@xyagent/cli 0.0.1 → 1.1.0

package/src-ext/core/scanQrRenderer.mjs

@@ -0,0 +1,40 @@
+// `agentlink scan` 终端二维码渲染 —— 封装 `qrcode-terminal`(`small: true`)。
+//
+// spec S6（二维码展示兜底）：终端不支持 ASCII 二维码渲染时（渲染抛错），
+// SHALL 回退为打印 payload 文本，不因渲染失败中断配对流程。因此本函数
+// **永不抛错**——渲染失败被内部吞掉并转成文本兜底。
+
+import qrcodeTerminal from "qrcode-terminal";
+
+/**
+ * 在终端渲染 payload 的 ASCII 二维码；渲染失败时回退打印 payload 文本。
+ *
+ * @param {string} payload  二维码内容（qr_payload deeplink）
+ * @param {{
+ *   generateImpl?: (input: string, opts: {small: boolean}, cb: (output: string) => void) => void,
+ *   print?: (s: string) => void,
+ *   warn?: (s: string) => void,
+ * }} [deps]
+ * @returns {{ ok: boolean, mode: "qr" | "text", error?: string }}
+ */
+export function renderQrToTerminal(payload, { generateImpl, print, warn } = {}) {
+  // NB: must call through `qrcodeTerminal.generate(...)`, not a bare
+  // reference to the method — qrcode-terminal's generate() reads `this.error`
+  // internally, and a detached reference loses that binding (`this` would be
+  // undefined under ESM's implicit strict mode), throwing on every call.
+  const generate = generateImpl || ((input, opts, cb) => qrcodeTerminal.generate(input, opts, cb));
+  const doPrint = print || ((s) => console.log(s));
+  const doWarn = warn || ((s) => console.warn(s));
+  const text = payload == null ? "" : String(payload);
+  try {
+    generate(text, { small: true }, (output) => {
+      doPrint(output);
+    });
+    return { ok: true, mode: "qr" };
+  } catch (err) {
+    const message = String(err?.message || err);
+    doWarn(`⚠ 二维码渲染失败，回退为文本（仍可完成配对）：${message}`);
+    doPrint(text);
+    return { ok: false, mode: "text", error: message };
+  }
+}

package/src-ext/core/scanWorkspaces.mjs

@@ -11,6 +11,7 @@
 
 import crypto from "node:crypto";
 import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -22,6 +23,7 @@ const DEFAULT_LIMIT = 50;
 const MAX_LIMIT = 500;
 const HARD_TIMEOUT_MS = 5000;
 const GIT_BRANCH_TIMEOUT_MS = 200;
+const execFileAsync = promisify(execFile);
 
 // Runtime metadata — agentKind values must match dart stub ScannedAgentGroup.kind exactly.
 const RUNTIME_META = {
@@ -49,6 +51,11 @@ const RUNTIME_META = {
     tagline: "Agentlink 内置对话智能体",
     idPrefix: "hm",
   },
+  Qwen: { agentKind: "Qwen", emoji: "🌊", tagline: "Qwen CLI", idPrefix: "qw" },
+  Kimi: { agentKind: "Kimi", emoji: "🌙", tagline: "Kimi CLI", idPrefix: "km" },
+  CodeBuddy: { agentKind: "CodeBuddy", emoji: "🤖", tagline: "CodeBuddy", idPrefix: "cb" },
+  Cursor: { agentKind: "Cursor", emoji: "⌨️", tagline: "Cursor", idPrefix: "cu" },
+  OpenCode: { agentKind: "OpenCode", emoji: "🧩", tagline: "OpenCode", idPrefix: "oo" },
 };
 
 // runtimeKind string → RUNTIME_META key
@@ -58,6 +65,7 @@ const RUNTIME_KIND_MAP = {
   claude: "Claude Code",
   codex: "Codex",
   hermes: "Hermes",
+  qwen: "Qwen", kimi: "Kimi", codebuddy: "CodeBuddy", cursor: "Cursor", opencode: "OpenCode",
 };
 
 // ─── utility functions ───────────────────────────────────────────────────────
@@ -166,6 +174,7 @@ export async function readOpenClawWorkspaces({
   limit,
   includeBranch,
   workspaceRoot,
+  openclawHome,
 }) {
   const warnings = [];
 
@@ -174,7 +183,7 @@ export async function readOpenClawWorkspaces({
     dirs = [path.resolve(workspaceRoot)];
   } else {
     try {
-      dirs = resolveOpenClawAgentWorkspaceDirs();
+      dirs = readJsonlCwds(openclawHome ?? path.join(resolveOpenClawHomeDir(), "agents"));
     } catch (err) {
       warnings.push(`OpenClaw: failed to resolve workspace dirs: ${err.message}`);
       return { workspaces: [], warnings, truncated: false };
@@ -216,6 +225,29 @@ export async function readOpenClawWorkspaces({
   return { workspaces, warnings, truncated };
 }
 
+function readJsonlCwds(root) {
+  const found = new Set();
+  const visit = (dir) => {
+    let entries; try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const entry of entries) {
+      const item = path.join(dir, entry.name);
+      if (entry.isDirectory()) visit(item);
+      else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        try {
+          for (const line of fs.readFileSync(item, "utf8").split(/\r?\n/)) {
+            if (!line.trim()) continue;
+            const row = JSON.parse(line);
+            const cwd = row?.cwd ?? row?.message?.cwd ?? row?.context?.cwd;
+            if (typeof cwd === "string" && cwd) found.add(path.resolve(cwd));
+          }
+        } catch {}
+      }
+    }
+  };
+  visit(root);
+  return [...found];
+}
+
 // ─── Claude Code reader ───────────────────────────────────────────────────────
 
 /**
@@ -385,31 +417,19 @@ export async function readCodexWorkspaces({
   const cwdByPath = new Map(); // absolutePath → true (for dedupe)
 
   for (const dir of sessionDirs) {
-    let files;
-    try {
-      files = fs.readdirSync(dir);
-    } catch (err) {
-      if (err.code === "EACCES" || err.code === "EPERM") {
-        warnings.push(`Codex: permission denied reading ${dir}: ${err.message}`);
-      }
-      // ENOENT: dir doesn't exist — skip silently
-      continue;
-    }
-
-    for (const file of files) {
-      if (!file.endsWith(".jsonl")) continue;
-      const filePath = path.join(dir, file);
+    if (!fs.existsSync(dir)) continue;
+    for (const filePath of findFiles(dir, (name) => name.endsWith(".jsonl"))) {
       try {
         const content = fs.readFileSync(filePath, "utf8");
         const firstLine = content.split("\n")[0].trim();
         if (!firstLine) continue;
         const parsed = JSON.parse(firstLine);
-        const cwd = parsed?.cwd;
+        const cwd = parsed?.cwd ?? parsed?.payload?.cwd;
         if (typeof cwd === "string" && cwd) {
           cwdByPath.set(path.resolve(cwd.replace(/^~/, home)), true);
         }
       } catch (err) {
-        warnings.push(`Codex: failed to parse first line of ${file}: ${err.message}`);
+        warnings.push(`Codex: failed to parse session: ${err.message}`);
       }
     }
   }
@@ -714,7 +734,10 @@ export async function readHermesWorkspaces({
  */
 export async function scanWorkspacesByRuntime({ runtimeKind, gatewayId, params }) {
   const kind = normalizeRuntimeKind(runtimeKind);
-  const meta = RUNTIME_META[kind] ?? RUNTIME_META["OpenClaw"];
+  if (!kind) {
+    return { ok: true, agentKind: String(runtimeKind || ""), emoji: "", tagline: "", host: hostMeta(gatewayId), workspaces: [], truncated: false, scannedAt: new Date().toISOString(), warnings: [`unsupported runtime: ${runtimeKind}`] };
+  }
+  const meta = RUNTIME_META[kind];
   const limit = clampLimit(params?.limit ?? DEFAULT_LIMIT);
   const includeBranch = params?.includeBranch === true;
 
@@ -723,6 +746,9 @@ export async function scanWorkspacesByRuntime({ runtimeKind, gatewayId, params }
   if (params?.hermesProfilesRoot != null) {
     readerArgs.hermesProfilesRoot = params.hermesProfilesRoot;
   }
+  for (const key of ["root", "openclawHome", "hermesDbPath", "opencodeDbPath", "codexHome"]) {
+    if (params?.[key] != null) readerArgs[key] = params[key];
+  }
 
   // Wrap reader in 5s hard timeout
   const readerPromise = runReader(kind, readerArgs);
@@ -768,19 +794,24 @@ function clampLimit(raw) {
 }
 
 function normalizeRuntimeKind(kind) {
-  if (!kind) return "OpenClaw";
+  if (!kind) return null;
   const lower = String(kind).toLowerCase().trim();
-  return RUNTIME_KIND_MAP[lower] ?? "OpenClaw";
+  return RUNTIME_KIND_MAP[lower] ?? null;
 }
 
 async function runReader(kind, args) {
   try {
     switch (kind) {
       case "OpenClaw":    return await readOpenClawWorkspaces(args);
-      case "Claude Code": return await readClaudeWorkspaces(args);
+      case "Claude Code": return await readDirectoryNameWorkspaces(args, "Claude Code", path.join(os.homedir(), ".claude", "projects"), true);
       case "Codex":       return await readCodexWorkspaces(args);
-      case "Hermes":      return await readHermesWorkspaces(args);
-      default:            return await readOpenClawWorkspaces(args);
+      case "Hermes":      return args.hermesProfilesRoot ? await readHermesWorkspaces(args) : await readHermesDbWorkspaces(args);
+      case "Qwen":        return await readEncodedProjectWorkspaces(args, "Qwen", path.join(os.homedir(), ".qwen", "projects"));
+      case "Kimi":        return await readKimiWorkspaces(args);
+      case "CodeBuddy":   return await readCodeBuddyWorkspaces(args);
+      case "Cursor":      return await readCursorWorkspaces(args);
+      case "OpenCode":    return await readOpenCodeWorkspaces(args);
+      default:            return { workspaces: [], warnings: [`unsupported runtime: ${kind}`], truncated: false };
     }
   } catch (err) {
     // Permission errors degrade to warnings
@@ -791,6 +822,115 @@ async function runReader(kind, args) {
   }
 }
 
+async function workspaceEntries(paths, meta, limit, includeBranch) {
+  const selected = [...new Set(paths.map((p) => path.resolve(p)))].slice(0, clampLimit(limit));
+  const branches = await resolveBranches(selected, includeBranch);
+  return selected.map((absolutePath, i) => ({ id: pathToId(meta.idPrefix, absolutePath), name: path.basename(absolutePath), path: absolutePath, absolutePath, branch: branches[i], lastUsedAtMs: null }));
+}
+
+async function readProjectDirectoryWorkspaces({ limit, includeBranch, root }, kind, defaultRoot) {
+  const dir = root ?? defaultRoot; let entries = [];
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return { workspaces: [], warnings: [], truncated: false }; }
+  const paths = entries.filter((e) => e.isDirectory()).map((e) => path.join(dir, e.name));
+  return { workspaces: await workspaceEntries(paths, RUNTIME_META[kind], limit, includeBranch), warnings: [], truncated: paths.length > clampLimit(limit) };
+}
+
+async function readDirectoryNameWorkspaces(args, kind, defaultRoot, decode) {
+  let entries = []; const root = args.root ?? defaultRoot;
+  try { entries = fs.readdirSync(root, { withFileTypes: true }); } catch { return { workspaces: [], warnings: [], truncated: false }; }
+  const paths = entries.filter((e) => e.isDirectory()).map((e) => decode ? path.resolve("/" + e.name.replace(/^-/, "").replace(/-/g, path.sep)) : path.join(root, e.name));
+  return { workspaces: await workspaceEntries(paths, RUNTIME_META[kind], args.limit, args.includeBranch), warnings: [], truncated: paths.length > clampLimit(args.limit) };
+}
+
+async function readEncodedProjectWorkspaces(args, kind, root) {
+  let entries = []; try { entries = fs.readdirSync(args.root ?? root, { withFileTypes: true }); } catch { return { workspaces: [], warnings: [], truncated: false }; }
+  const paths = entries.filter((e) => e.isDirectory()).map((e) => path.resolve("/" + e.name.replace(/^-/, "").replace(/-/g, path.sep)));
+  return { workspaces: await workspaceEntries(paths, RUNTIME_META[kind], args.limit, args.includeBranch), warnings: [], truncated: paths.length > clampLimit(args.limit) };
+}
+
+function findFiles(root, predicate) {
+  const files = [];
+  const visit = (dir) => { let entries; try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; } for (const entry of entries) { const item = path.join(dir, entry.name); if (entry.isDirectory()) visit(item); else if (entry.isFile() && predicate(entry.name)) files.push(item); } };
+  visit(root); return files;
+}
+
+async function readKimiWorkspaces(args) {
+  const root = args.root ?? path.join(os.homedir(), ".kimi-code", "sessions");
+  const paths = [];
+  for (const file of findFiles(root, (name) => name === "state.json")) { try { const cwd = JSON.parse(fs.readFileSync(file, "utf8"))?.cwd; if (typeof cwd === "string" && cwd) paths.push(cwd); } catch {} }
+  return { workspaces: await workspaceEntries(paths, RUNTIME_META.Kimi, args.limit, args.includeBranch), warnings: [], truncated: paths.length > clampLimit(args.limit) };
+}
+
+async function readCodeBuddyWorkspaces(args) {
+  const root = args.root ?? path.join(os.homedir(), ".codebuddy", "projects");
+  const paths = [];
+  for (const file of findFiles(root, (name) => name.endsWith(".jsonl"))) { try { for (const line of fs.readFileSync(file, "utf8").split(/\r?\n/)) { const cwd = JSON.parse(line || "{}")?.cwd; if (typeof cwd === "string" && cwd) paths.push(cwd); } } catch {} }
+  return { workspaces: await workspaceEntries(paths, RUNTIME_META.CodeBuddy, args.limit, args.includeBranch), warnings: [], truncated: paths.length > clampLimit(args.limit) };
+}
+
+async function readCursorWorkspaces(args) {
+  const root = args.root ?? path.join(os.homedir(), ".cursor", "projects");
+  let entries = []; try { entries = fs.readdirSync(root, { withFileTypes: true }); } catch { return { workspaces: [], warnings: [], truncated: false }; }
+  const projects = entries.filter((entry) =>
+    entry.isDirectory() && fs.existsSync(path.join(root, entry.name, "agent-transcripts")),
+  );
+  const paths = [];
+  let unresolvedCount = 0;
+  for (const project of projects) {
+    const resolved = resolveCursorProjectSlug(project.name);
+    if (resolved) paths.push(resolved);
+    else unresolvedCount += 1;
+  }
+  const warnings = unresolvedCount > 0
+    ? [`${unresolvedCount} Cursor project${unresolvedCount === 1 ? " was" : "s were"} skipped because ${unresolvedCount === 1 ? "its" : "their"} slug could not be resolved to an existing directory`]
+    : [];
+  return { workspaces: await workspaceEntries(paths, RUNTIME_META.Cursor, args.limit, args.includeBranch), warnings, truncated: paths.length > clampLimit(args.limit) };
+}
+
+// Cursor replaces path separators and punctuation (`/`, `-`, `_`, `.`) with
+// the same `-` in project directory names. That encoding is lossy: never turn
+// every dash back into `/`. Instead, walk the real directory tree from `/` and
+// accept a candidate only when every component exists on disk.
+const CURSOR_SLUG_JOINERS = ["-", "_", ".", ""];
+function resolveCursorProjectSlug(slug) {
+  const segments = String(slug ?? "").replace(/^-+/, "").split("-").filter(Boolean);
+  if (segments.length === 0) return null;
+
+  const walk = (base, index) => {
+    if (index >= segments.length) return isExistingDirectory(base) ? base : null;
+    for (let end = segments.length; end > index; end -= 1) {
+      const parts = segments.slice(index, end);
+      for (const joiner of CURSOR_SLUG_JOINERS) {
+        const candidate = path.join(base, parts.join(joiner));
+        if (!isExistingDirectory(candidate)) continue;
+        const resolved = walk(candidate, end);
+        if (resolved) return resolved;
+      }
+    }
+    return null;
+  };
+
+  return walk(path.parse(process.cwd()).root, 0);
+}
+
+function isExistingDirectory(candidate) {
+  try { return fs.statSync(candidate).isDirectory(); } catch { return false; }
+}
+
+async function readSqlitePaths(dbPath, sql) {
+  try { const { stdout } = await execFileAsync("sqlite3", [dbPath, "-noheader", "-separator", "\t", sql], { timeout: HARD_TIMEOUT_MS }); return stdout.split(/\r?\n/).filter(Boolean).map((line) => line.split("\t")[0]).filter(Boolean); } catch { return []; }
+}
+async function readHermesDbWorkspaces(args) {
+  const db = args.hermesDbPath ?? path.join(os.homedir(), ".hermes", "state.db");
+  const paths = await readSqlitePaths(db, "SELECT cwd FROM sessions WHERE cwd IS NOT NULL AND cwd != '' GROUP BY cwd ORDER BY COUNT(*) DESC");
+  return { workspaces: await workspaceEntries(paths, RUNTIME_META.Hermes, args.limit, args.includeBranch), warnings: [], truncated: paths.length > clampLimit(args.limit) };
+}
+async function readOpenCodeWorkspaces(args) {
+  const db = args.opencodeDbPath ?? path.join(os.homedir(), ".local", "share", "opencode", "opencode.db");
+  const paths = await readSqlitePaths(db, "SELECT worktree FROM project WHERE worktree IS NOT NULL AND worktree != '' GROUP BY worktree ORDER BY MAX(time_updated) DESC");
+  return { workspaces: await workspaceEntries(paths, RUNTIME_META.OpenCode, args.limit, args.includeBranch), warnings: [], truncated: paths.length > clampLimit(args.limit) };
+}
+
 /**
  * Resolve OpenClaw home dir. Mirrors bin/agentlink resolveOpenClawHome():
  * OPENCLAW_HOME 环境变量优先，否则 <home>/.openclaw。

package/src-ext/core/unifiedDispatchHandler.mjs

@@ -9,7 +9,7 @@
  *
  * Injection points for testing:
  *   producerFactory({ relayUrl, bridgeToken, threadId }) → { postEvents }
- *   openclawInvoke({ input, onChunk }) → async void   (default: picoclaw wsHolder)
+ *   openclawInvoke({ input, onChunk }) → async void   (default: openclaw wsHolder)
  *   flushPolicy({ size, timeMs }) → 控制 micro-batched flush 触发阈值（默认 {size:1, timeMs:0} —— 即来即发，保流式体验）
  */
 
@@ -29,7 +29,7 @@ import { signGetCosObject } from "./cosUploadClient.mjs";
 // Streaming-first policy: size:1 means every envelope (especially
 // content_block.delta) posts immediately, so the App SSE stream receives
 // chunks as the runtime produces them rather than in 8-envelope batches.
-// Tests/picoclaw replay can override via flushPolicy if they want fewer POSTs.
+// Tests can override via flushPolicy if they want fewer POSTs.
 const DEFAULT_FLUSH_POLICY = Object.freeze({ size: 1, timeMs: 0 });
 const STREAM_DEBUG = process.env.BUBBO_DEBUG_STREAM === "1";
 
@@ -265,7 +265,7 @@ export function createUnifiedDispatchHandler({
       return false; // not a dispatch request — let caller handle it
     }
 
-    const { thread_id, run_id, input, blocks = [], workspace_path } = request.request ?? {};
+    const { thread_id, run_id, input, blocks = [], workspace_path, resume_session_id } = request.request ?? {};
 
     // Idempotency check
     if (dispatchedRunIds.has(run_id)) {
@@ -343,7 +343,7 @@ export function createUnifiedDispatchHandler({
       let runPausedFromRuntime = false;
 
       if (typeof openclawInvoke === "function") {
-        // Injected (test mode or picoclaw ws integration)
+        // Injected (test mode or ws integration)
         // thread_id 透传给 runtime adapter，让需要"按 thread 维护原生 session
         // 续接"的 runtime（如 claude --resume <sid>）可以做 mapping。
         await openclawInvoke({
@@ -352,6 +352,10 @@ export function createUnifiedDispatchHandler({
           input: effectiveInput,
           blocks: processedBlocks,
           workspace_path: workspace_path || null,
+          // relay only supplies this for the newest completed history import.
+          // Runtime adapters seed it only if their thread has no active local
+          // session, preventing later imported history from switching context.
+          resume_session_id: resume_session_id || null,
           // relay 信封顶层 sessionKey（App 侧 abort RPC 用它定位要杀的 run）
           session_key: request.sessionKey || null,
           onChunk: async (chunk) => {
@@ -423,8 +427,11 @@ export function createUnifiedDispatchHandler({
         });
       }
       try {
+        const failureCode = err?.code === "workspace_context_unavailable"
+          ? "workspace_context_unavailable"
+          : "runtime.crash";
         await producer.postEvents([
-          buildRunFailed(run_id, "runtime.crash", String(err?.message || err)),
+          buildRunFailed(run_id, failureCode, String(err?.message || err)),
         ]);
       } catch (postErr) {
         log.error("dispatch.post_failed.error", "failed to post run.failed envelope", {

package/src-ext/core/usageReporter.mjs

@@ -40,8 +40,7 @@ export function createUsageReporter({ publishEvent, runtime, log, debounceMs = D
   if (
     runtime !== "claude" &&
     runtime !== "codex" &&
-    runtime !== "hermes" &&
-    runtime !== "picoclaw"
+    runtime !== "hermes"
   ) {
     throw new Error(`createUsageReporter: bad runtime ${runtime}`);
   }

package/src-ext/openclaw-plugin/envelope-builder.cjs

@@ -448,7 +448,7 @@ function translateOpenClawChunkToEnvelope(chunk, runId, blockState) {
     }
     envelopes.push(env);
   } else if (event === "response.function_call_arguments.delta") {
-    // picoclaw legacy event name → maps to tool_use.start + arguments.delta.
+    // legacy event name → maps to tool_use.start + arguments.delta.
     // chunk shape: { call_id, name, arguments } where arguments is a JSON
     // fragment to append. We auto-start a tool_use block on first occurrence.
     const callId = String(chunk.call_id || "");
@@ -540,7 +540,7 @@ function translateOpenClawChunkToEnvelope(chunk, runId, blockState) {
     envelopes.push(started, completed);
   } else if (event === "response.output_text.done") {
     // No incremental envelope needed — full text already accumulated via deltas.
-    // If runtime carries authoritative full text on .done (e.g. picoclaw), prefer it.
+    // If the runtime carries authoritative full text on .done, prefer it.
     if (typeof chunk.text === "string" && chunk.text.length > 0) {
       text.content = chunk.text;
     }

package/src-ext/openclaw-plugin/todoTranslatorUtils.cjs

@@ -75,7 +75,7 @@ function normalizeStatus(raw) {
  * rawItems 中每项支持字段：
  *   - id?:         string（有则保留，无则生成 td_{idx}）
  *   - content?:    string（主内容字段，Claude/Hermes 用）
- *   - step?:       string（Codex/picoclaw 用，作为 content 的 fallback）
+ *   - step?:       string（Codex 用，作为 content 的 fallback）
  *   - status?:     string（经 normalizeStatus 归一）
  *
  * @param {Array<{id?: string, content?: string, step?: string, status?: string}>} rawItems

package/src-ext/runtime/_shared/bridgedSessionLedger.mjs

@@ -0,0 +1,60 @@
+// 桥接会话账本 —— 「重复导入」问题的方案 ①（打标侧）。
+//
+// 背景：经 AgentLink 桥接的实时对话会同时被 CLI 记进本机会话文件，且该文件与
+// 用户手动 CLI 会话**无任何可区分标记**（实测 CodeBuddy 两类文件的
+// `providerData.agent` 均为 "cli"）。桌面端「重新导入历史」会把已经通过实时
+// 链路存在于线程里的同一段话再追加一遍。
+//
+// 方案：bridge 每捕获到一个 CLI 原生 session id（onSession / resume_hint），
+// 就把 (runtime, session_id) 追加进本账本；桌面端导入扫描时读它，命中的
+// 会话文件整个跳过 —— 那段对话已经在线程里了。
+//
+// 三条口径：
+//   1. 账本位置**固定** `~/.agentlink/bridged-cli-sessions.ndjson`，不跟 bridge
+//      的 --debug state 走：CLI 本机历史本来就不分 debug，账本也不该分。
+//   2. 打标是 best-effort：写失败（磁盘满 / 权限）静默吞掉，绝不影响对话链路；
+//      漏标的代价只是「那一条会话可能被重复导入」，远小于打断实时对话。
+//   3. 只追加不清理：账本行是 40 字节量级，一万条才 400KB，不值得引入压缩逻辑。
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+/** 测试用环境变量：覆盖账本路径（生产不设，走 ~/.agentlink 固定位置）。 */
+const LEDGER_PATH_ENV = "AGENTLINK_BRIDGED_LEDGER";
+
+/** 进程内已记录的 session id —— 同一会话每轮对话都会报同一个 id，只落一行。 */
+const recorded = new Set();
+
+export function bridgedSessionLedgerPath() {
+  const override = process.env[LEDGER_PATH_ENV];
+  if (override) return override;
+  return path.join(os.homedir(), ".agentlink", "bridged-cli-sessions.ndjson");
+}
+
+/**
+ * 记录一个经桥接产生的 CLI 原生 session id。幂等（进程内去重 + 跨进程靠
+ * 桌面端读取时按 session_id 建集合，重复行无害）。
+ */
+export function recordBridgedSession(runtime, sessionId) {
+  const id = String(sessionId || "").trim();
+  if (!id) return;
+  const key = `${runtime}
${id}`;
+  if (recorded.has(key)) return;
+  recorded.add(key);
+  try {
+    const ledger = bridgedSessionLedgerPath();
+    fs.mkdirSync(path.dirname(ledger), { recursive: true });
+    fs.appendFileSync(
+      ledger,
+      `${JSON.stringify({ runtime: String(runtime || ""), session_id: id, recorded_at: new Date().toISOString() })}\n`,
+    );
+  } catch {
+    // best-effort：见文件头口径 2。
+  }
+}
+
+/** 测试用：清空进程内去重缓存（账本文件由测试自己管理）。 */
+export function resetBridgedSessionCacheForTest() {
+  recorded.clear();
+}

package/src-ext/runtime/_shared/claudeSchemaEvent.mjs

@@ -0,0 +1,49 @@
+/**
+ * Qwen Code 与 CodeBuddy 的 stream-json 都采用 Claude 风格消息信封：
+ * system(init) → assistant/user 消息 → result。这里直接翻成 unified chunks，
+ * 避免把两套官方兼容协议各写一遍。
+ */
+export function translateClaudeSchemaEvent(event) {
+  if (!event || typeof event !== "object") return null;
+  if (event.type === "result") {
+    if (event.is_error || event.subtype === "error") {
+      const message = event.error?.message || event.result || "runtime failed";
+      return { event: "response.failed", error: { message: String(message) } };
+    }
+    return { event: "response.completed" };
+  }
+
+  const message = event.message;
+  const blocks = Array.isArray(message?.content) ? message.content : [];
+  const parent = event.parent_tool_use_id || null;
+  const withParent = (chunk) => parent ? { ...chunk, parent_tool_use_id: parent } : chunk;
+  const chunks = [];
+
+  if (event.type === "assistant") {
+    for (const block of blocks) {
+      if (block?.type === "text" && block.text) {
+        chunks.push(withParent({ event: "response.output_text.delta", delta: String(block.text) }));
+      } else if ((block?.type === "thinking" || block?.type === "reasoning") && block.text) {
+        chunks.push(withParent({ event: "response.reasoning_summary_text.delta", delta: String(block.text) }));
+      } else if (block?.type === "tool_use") {
+        const callId = String(block.id || "");
+        const name = String(block.name || "unknown");
+        const input = block.input && typeof block.input === "object" ? block.input : {};
+        chunks.push(withParent({ event: "response.tool_use.start", call_id: callId, name, input }));
+        chunks.push(withParent({ event: "response.tool_use.completed", call_id: callId, name, input }));
+      }
+    }
+  } else if (event.type === "user") {
+    for (const block of blocks) {
+      if (block?.type !== "tool_result") continue;
+      const text = typeof block.content === "string" ? block.content : "";
+      chunks.push(withParent({
+        event: "response.tool_result",
+        call_id: String(block.tool_use_id || ""),
+        output: text ? [{ type: "text", format: "plain", text }] : [],
+        is_error: !!block.is_error,
+      }));
+    }
+  }
+  return chunks;
+}