release/v1.2.4

.github/release-notes/v1.2.4.md

@@ -0,0 +1,12 @@
+# Memmy v1.2.4
+
+基于 v1.2.3 之后已合入并验证的改动，发布稳定版 v1.2.4；本版本集中改进模型配置、Agent 运行时、Memory 可靠性、浏览器与电脑历史采集，以及跨平台运行时分发。
+
+- OpenCode V2 对话采集支持连续会话和真实扫描先到场景，补齐生命周期、去重和 L3 暂不可用时的可恢复行为；微信采集增加瞬态变化重试，并在退出时取消等待中的采集任务。
+- BYOK 与内置模型配置统一凭据来源和账号投影，连接测试隔离页面卸载后的响应，保留迁移后的模型模式；补充模型思考级别、token 预算、协议选择、视觉能力和 DeepSeek-V4.1-Flash-1017 能力登记。
+- Agent runtime 增强 Hook 生命周期、执行等待、OpenAI-compatible 请求、模型错误诊断和工具结果处理；显式停止取代整轮超时，恢复会话继续使用明确的模型选择。
+- Memory 改进跨账号候选去重、Embedding 输入校验与失败批次隔离、任务记忆删除、采集边界和运行时构建，并为各平台 runtime 产物生成校验和。
+- 桌面端补齐 slash command 与子命令建议、技能 Markdown 展示、社交登录入口、模型思考控制，以及浏览器和电脑历史授权与恢复路径；Windows History 与微信路径继续保留失败可见性和隐私边界。
+- 打包链路统一 Agent 与 Memory 多平台 runtime 构建、版本同步和依赖安装脚本，保持源码、安装包和运行时元数据一致；真实安装、覆盖升级和签名发布仍需按发版门禁分别验收。
+
+本文件只记录 v1.2.4 的版本范围；Full Harness 回归、独立审查、Draft PR、合并、签名 tag、打包和发布仍是相互独立的门槛。

.github/workflows/memory-release.yml

@@ -6,7 +6,7 @@ on:
       version:
         description: Memory version (X.Y.Z)
         required: true
-        default: 2.1.6
+        default: 2.1.7
   push:
     tags:
       - "memory-v*"

.github/workflows/runtime-artifacts.yml

@@ -0,0 +1,101 @@
+name: Agent and Memory runtime artifacts
+run-name: runtime-artifacts-${{ github.ref_name }}
+
+on:
+  workflow_dispatch:
+    inputs:
+      runtime:
+        description: Runtime packages to build
+        type: choice
+        options: [both, memory]
+        default: both
+  push:
+    branches: [zy_memory_runtime_*]
+permissions:
+  contents: read
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - target: darwin-arm64
+            runner: macos-14
+            arch: arm64
+          - target: darwin-x64
+            runner: macos-15-intel
+            arch: x64
+          - target: linux-arm64
+            runner: ubuntu-24.04-arm
+            arch: arm64
+          - target: linux-x64
+            runner: ubuntu-24.04
+            arch: x64
+          - target: windows-arm64
+            runner: windows-11-arm
+            arch: arm64
+          - target: windows-x64
+            runner: windows-2025
+            arch: x64
+    runs-on: ${{ matrix.runner }}
+    timeout-minutes: 45
+    defaults:
+      run:
+        shell: bash
+    env:
+      COPYFILE_DISABLE: '1'
+      PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: '1'
+      ELECTRON_SKIP_BINARY_DOWNLOAD: '1'
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 26.0.0
+          architecture: ${{ matrix.arch }}
+          cache: npm
+      - name: Install build dependencies
+        run: npm ci --no-audit --no-fund
+      - name: Install Agent build dependencies
+        if: github.event_name == 'workflow_dispatch' && inputs.runtime != 'memory'
+        run: npm --prefix App/memmy-agent install --ignore-scripts --no-audit --no-fund
+      - name: Build Agent runtime
+        if: github.event_name == 'workflow_dispatch' && inputs.runtime != 'memory'
+        run: npm run agent:runtime:package -- --target "${{ matrix.target }}" --output "$RUNNER_TEMP/runtime-artifacts"
+      - name: Build Memory runtime
+        run: npm run runtime:package -w @memmy/memory -- --target "${{ matrix.target }}" --output "$RUNNER_TEMP/runtime-artifacts"
+      - name: Verify unpacked runtimes and native dependencies
+        run: node scripts/internal/shared/verify-runtime-artifacts.mjs "$RUNNER_TEMP/runtime-artifacts" "${{ matrix.target }}" "${{ inputs.runtime || 'memory' }}"
+      - uses: actions/upload-artifact@v4
+        with:
+          name: runtimes-${{ matrix.target }}
+          path: ${{ runner.temp }}/runtime-artifacts/*
+          if-no-files-found: error
+          compression-level: 0
+          retention-days: 14
+
+  collect:
+    needs: build
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 26.0.0
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: runtimes-*
+          path: runtime-input
+      - name: Collect runtime archives with checksums
+        run: node scripts/internal/shared/collect-runtime-artifacts.mjs runtime-input runtime-output "${{ inputs.runtime || 'memory' }}"
+      - uses: actions/upload-artifact@v4
+        with:
+          name: all-platform-runtimes
+          path: runtime-output/*
+          if-no-files-found: error
+          compression-level: 0
+          retention-days: 14

.gitignore

@@ -1,5 +1,6 @@
 node_modules/
 dist/
+App/memmy-agent/npm-packages/
 release/
 App/shell/desktop/release/
 Mac软件打包/

AgentSourceCore/src/index.ts

@@ -4,6 +4,7 @@ export * from "./cursor-source-turn.js";
 export * from "./claude-code-source-turn.js";
 export * from "./openclaw-source-turn.js";
 export * from "./opencode-source-turn.js";
+export * from "./opencode-database-source.js";
 export * from "./hermes-source-turn.js";
 export * from "./deepseek-source-turn.js";
 export * from "./deepseek-session-files.js";

AgentSourceCore/src/opencode-database-source.ts

@@ -0,0 +1,123 @@
+import type { OpencodeSource, OpencodeSession } from "./opencode-source-turn.js";
+
+interface Database {
+  prepare(sql: string): { all(...parameters: string[]): unknown[]; get(...parameters: string[]): unknown };
+}
+type Row = Record<string, unknown>;
+const record = (value: unknown): Row => value && typeof value === "object" && !Array.isArray(value) ? value as Row : {};
+const parse = (value: unknown): Row => {
+  if (typeof value !== "string") return record(value);
+  try { return record(JSON.parse(value)); } catch { return {}; }
+};
+
+/** Adapt both native database generations to the same turn parser. Only one
+ * session is materialised at a time; all callers open the database read-only. */
+export function createOpencodeDatabaseSource(db: Database, conversationId?: string): OpencodeSource | null {
+  const hasTable = (name: string) => Boolean(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(name));
+  const v2 = hasTable("session_v2") && hasTable("session_message");
+  if (!v2 && !(hasTable("session") && hasTable("message") && hasTable("part"))) return null;
+  const table = v2 ? "session_v2" : "session";
+  const columns = new Set(db.prepare(`PRAGMA table_info(${table})`).all().map(row => record(row).name));
+  const sessions = db.prepare(`SELECT id, parent_id AS parentId, directory${columns.has("agent") ? ", agent" : ""}${columns.has("revert") ? ", revert" : ""} FROM ${table}${conversationId ? " WHERE id = ?" : ""} ORDER BY time_created ASC, id ASC`);
+  const messages = db.prepare(v2
+    ? "SELECT id, type, data, time_created FROM session_message WHERE session_id = ? ORDER BY seq ASC, id ASC"
+    : "SELECT id, data FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC");
+  const parts = v2 ? null : db.prepare("SELECT id, data FROM part WHERE message_id = ? ORDER BY time_created ASC, id ASC");
+  // Official V1 -> V2 migration retains the original tables. They are positive
+  // provenance for migrated messages, whose completion/parent/tool identity must
+  // remain identical to captures made before upgrading. Native V2 rows still
+  // require their own durable idle boundary.
+  const legacyMessages = v2 && hasTable("message") && hasTable("part")
+    ? db.prepare("SELECT id, data FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC") : null;
+  const legacyParts = legacyMessages ? db.prepare("SELECT id, data FROM part WHERE message_id = ? ORDER BY time_created ASC, id ASC") : null;
+  const currentParts = new Map<string, Array<{ id: string; data: unknown }>>();
+  return {
+    sessions: () => sessions.all(...(conversationId ? [conversationId] : [])).map(value => {
+      const row = record(value);
+      const revert = parse(row.revert);
+      return {
+        id: String(row.id), parentId: row.parentId == null ? null : String(row.parentId),
+        directory: row.directory == null ? null : String(row.directory),
+        agent: typeof row.agent === "string" ? row.agent : null,
+        revertMessageId: typeof revert.messageID === "string" ? revert.messageID : null
+      } satisfies OpencodeSession;
+    }),
+    messages(sessionId) {
+      const rows = messages.all(sessionId).map(record);
+      if (!v2) return rows.map(row => ({ id: String(row.id), data: parse(row.data) }));
+      currentParts.clear();
+      let parentID = "";
+      let agent = "";
+      let turnAssistants: Row[] = [];
+      const result: Array<{ id: string; data: Row }> = [];
+      const legacy = legacyMessages?.all(sessionId).map(record) || [];
+      const migratedIds = new Set(rows.map(row => String(row.id)));
+      const legacyIds = new Set<string>();
+      if (legacy.some(row => migratedIds.has(String(row.id)))) {
+        for (const row of legacy) {
+          const id = String(row.id);
+          legacyIds.add(id);
+          const data = parse(row.data);
+          const owner = data.role === "assistant" ? String(data.parentID || "") : id;
+          // V2 may have removed/reverted a migrated user. Keep its ordinal slot
+          // for existing source identities, but never resurrect deleted history.
+          const visible = migratedIds.has(owner);
+          result.push({ id, data: visible ? data : {} });
+          if (!visible) continue;
+          currentParts.set(id, legacyParts!.all(id).map(value => {
+            const part = record(value); return { id: String(part.id), data: parse(part.data) };
+          }));
+        }
+      }
+      for (const row of rows) {
+        const data = parse(row.data);
+        const type = data.type || row.type;
+        const id = String(row.id);
+        if (legacyIds.has(id)) continue;
+        if (type === "agent-switched") { agent = String(data.agent || ""); continue; }
+        if (type === "user") {
+          parentID = id;
+          turnAssistants = [];
+          result.push({ id, data: { role: "user", time: data.time || { created: row.time_created } } });
+          currentParts.set(id, [{ id: id + ":text", data: { type: "text", text: data.text } }]);
+        } else if (type === "assistant" && parentID) {
+          const assistant = { ...data, nativeTurnPending: true, role: "assistant", parentID, agent: data.agent || agent };
+          turnAssistants.push(assistant);
+          result.push({ id, data: assistant });
+          const content = Array.isArray(data.content) ? data.content.map(record) : [];
+          currentParts.set(id, content.map((part, index) => {
+            if (part.type !== "tool") return { id: `${id}:${index}`, data: part };
+            const state = record(part.state);
+            const output = Array.isArray(state.content)
+              ? state.content.map(record).filter(item => item.type === "text").map(item => item.text).join("\n") : "";
+            return { id: `${id}:${index}`, data: {
+              type: "tool", callID: part.id, tool: part.name,
+              metadata: { providerExecuted: part.executed === true },
+              state: { ...state, output: state.status === "error" ? record(state.error).message || output : output, time: part.time }
+            } };
+          }));
+        } else if (type === "idle") {
+          // V2 persists an explicit terminal boundary, including tool-only and
+          // interrupted turns. Do not infer completion from an intermediate step.
+          // A final failed/empty assistant can be filtered by the shared parser.
+          // Close all steps so the last useful text/tool still has the terminal status.
+          for (const assistant of turnAssistants) {
+            assistant.nativeTurnCompleted = true;
+            assistant.nativeTurnPending = false;
+            if (data.outcome === "failed" || data.outcome === "interrupted") assistant.nativeStatus = "failed";
+            if (data.outcome === "interrupted") assistant.error = { name: "MessageAbortedError" };
+            assistant.time = { ...record(assistant.time), completed: record(data.time).created || row.time_created };
+          }
+          // Freeze the completed turn. Synthetic continuations and independent
+          // compactions are not new user turns and cannot reopen this parent.
+          parentID = "";
+          turnAssistants = [];
+        }
+      }
+      return result;
+    },
+    parts: messageId => parts
+      ? parts.all(messageId).map(value => { const row = record(value); return { id: String(row.id), data: parse(row.data) }; })
+      : currentParts.get(messageId) || []
+  };
+}

AgentSourceCore/src/opencode-source-turn.ts

@@ -59,6 +59,9 @@ interface OpencodeAssistant {
   pendingTool: boolean;
   hasOrdinaryTool: boolean;
   hasStructuredOutput: boolean;
+  nativeTurnCompleted: boolean;
+  nativeTurnPending: boolean;
+  nativeStatus?: "succeeded" | "failed";
 }
 
 /**
@@ -112,7 +115,10 @@ export async function* readOpencodeSession(
       toolResults: collected.toolResults,
       pendingTool: collected.pendingTool,
       hasOrdinaryTool: collected.hasOrdinaryTool,
-      hasStructuredOutput: data.structured !== undefined
+      hasStructuredOutput: data.structured !== undefined,
+      nativeTurnCompleted: data.nativeTurnCompleted === true,
+      nativeTurnPending: data.nativeTurnPending === true,
+      nativeStatus: data.nativeStatus === "failed" ? "failed" : undefined
     };
     // An assistant with neither text nor a tool is idle bookkeeping (`step-finish` only).
     if (!assistant.assistantText && assistant.toolCalls.length === 0 && !assistant.pendingTool) continue;
@@ -134,7 +140,7 @@ export async function* readOpencodeSession(
     const profileId = user.userAgent || assistantProfileId(assistants);
     let reason = "";
     if (!user.query.trim()) reason = "turn_content_incomplete";
-    else if (!last) reason = "turn_incomplete";
+    else if (!last || last.nativeTurnPending) reason = "turn_incomplete";
     else if (assistants.some((assistant) => assistant.pendingTool)) reason = "turn_incomplete";
     else if (!last.aborted && opencodeAssistantStillOpen(last)) reason = "turn_incomplete";
     // An interrupted turn still counts when it produced text or a finished tool.
@@ -145,7 +151,7 @@ export async function* readOpencodeSession(
       source: OPENCODE_SOURCE_ID, conversationId: session.id, turnId: user.id, profileId,
       startedAt: user.startedAt, completedAt, sequence: user.ordinal,
       completionEvidence: last!.aborted ? `assistant_aborted:${last!.id}` : `assistant_completed:${last!.id}`,
-      query: redactSecrets(user.query), answer: redactSecrets(answer), status: "succeeded",
+      query: redactSecrets(user.query), answer: redactSecrets(answer), status: last!.nativeStatus || "succeeded",
       toolCalls: pairSourceToolCalls(toolCalls, toolResults).map(redactCall), toolResults: toolResults.map(redactResult),
       ...(session.directory ? { workspacePath: session.directory } : {})
     };
@@ -229,6 +235,7 @@ function collectParts(source: OpencodeSource, messageId: string): {
  */
 function opencodeAssistantStillOpen(last: OpencodeAssistant): boolean {
   if (!last.completedAt) return true;
+  if (last.nativeTurnCompleted) return false;
   if (last.hasStructuredOutput) return false;
   if (!last.finish || last.finish === "tool-calls" || last.finish === "unknown") return true;
   return last.hasOrdinaryTool;

App/backend/local-api-contracts/package.json

@@ -14,7 +14,7 @@
   },
   "scripts": {
     "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json",
-    "test": "npm run typecheck && vitest run tests/desktop-runtime-manifest.test.ts tests/language.test.ts",
+    "test": "npm run typecheck && vitest run tests/desktop-runtime-manifest.test.ts tests/language.test.ts tests/model-catalog-resolver.test.ts tests/model-thinking-levels.test.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {