lark-remote 0.4.5 → 0.5.1

package/dist/runner/claude/session.js

@@ -43,7 +43,7 @@ const DEFAULT_IDLE_TTL_MS = 30 * 60 * 1000;
 const COMPACTION_RESULT_SUBTYPES = new Set(['compact', 'compaction']);
 /**
  * ClaudeSession extends SpawningRunner 复用其 spawn/pid 文件/killOrphan/
- * Terminator/SpawnHeartbeat/退出分发器机制（P1-1/P1-10/P1-11 契约保持），
+ * Terminator/SpawnHeartbeat/退出分发器机制（契约保持），
  * 但 run() 覆盖为「长驻 + 按 turn 消费」：进程跨 turn 存活，turn 结束以
  * stream-json result 事件（非 compact）为界，而不是进程退出。
  */
@@ -127,7 +127,7 @@ export class ClaudeSession extends SpawningRunner {
             // 或 --resume 目标会话）。比较进程当前 session（init 报告值）而非 spawn
             // 请求值：bridge 会把 init 的 session_id 写回 SessionStore，第二条消息
             // 带着它来；若拿 spawn 请求值（''）比较，每条消息都会误判切换、杀进程
-            // 重启，长驻设计失效（2026-08-16 review P0）。
+            // 重启，长驻设计失效（2026-08-16）。
             if (this.isRunning && this.sessionId !== (opts.sessionId ?? '')) {
                 getLogger().info(`[${this.logTag}] session mismatch: process=${this.sessionId || '(fresh)'} ` +
                     `requested=${opts.sessionId ?? '(fresh)'}, recycling process`);
@@ -174,7 +174,7 @@ export class ClaudeSession extends SpawningRunner {
             getLogger().warn(`[${this.logTag}] respondPermission skipped: process not running requestId=${requestId}`);
             return;
         }
-        // review P2-2：requestId 不在待审批表（已 control_cancel / 进程回收）时
+        // requestId 不在待审批表（已 control_cancel / 进程回收）时
         // 丢弃响应，不能以空 updatedInput allow（claude 会拿空输入执行工具）。
         if (!this.pendingToolInputs.has(requestId)) {
             getLogger().warn(`[${this.logTag}] respondPermission dropped: unknown requestId=${requestId}`);
@@ -204,7 +204,7 @@ export class ClaudeSession extends SpawningRunner {
     async respondAskUserQuestion(requestId, answers) {
         if (!this.isRunning)
             return;
-        // review P2-2：未知 requestId 时不能回写缺原始 questions 的 answers
+        // 未知 requestId 时不能回写缺原始 questions 的 answers
         // （官方要求 updatedInput 必须包含原始 questions）。
         if (!this.pendingToolInputs.has(requestId)) {
             getLogger().warn(`[${this.logTag}] respondAskUserQuestion dropped: unknown requestId=${requestId}`);
@@ -285,7 +285,7 @@ export class ClaudeSession extends SpawningRunner {
      */
     async startProcess(opts) {
         if (this.isRunning) {
-            // review P3-4：复用进程（跨 turn 长驻）时清掉上一轮的空闲回收 timer——
+            // 复用进程（跨 turn 长驻）时清掉上一轮的空闲回收 timer——
             // 否则长 turn 中它会空转触发一次（回调因 turnActive 空转返回，无害但
             // 多余）；新一轮结束后的 armIdleTimer 会重新武装。
             this.clearIdleTimer();
@@ -381,7 +381,7 @@ export class ClaudeSession extends SpawningRunner {
     // =========================================================================
     /**
      * 消费事件队列直到本 turn 的 result 事件（非 compact/compaction）。
-     * 消费者提前关闭生成器（bridge 循环体抛错）→ 杀进程防孤儿（P1-11 语义）。
+     * 消费者提前关闭生成器（bridge 循环体抛错）→ 杀进程防孤儿（语义）。
      *
      * result = turn 终态（2026-08-16 真实 claude 实测：长驻模式下 result 之后
      * 不再有 stdout 事件，后台任务完成是静默的；旧 -p 流程「等进程退出再收尾」
@@ -554,7 +554,7 @@ export class ClaudeSession extends SpawningRunner {
     async translateEvent(raw) {
         const event = raw;
         const type = event.type;
-        // review P3-3：--resume 会先重放上一轮历史事件（旧 result 之外还可能有
+        // --resume 会先重放上一轮历史事件（旧 result 之外还可能有
         // 旧 assistant/user 内容）。init 之前除 init 本身外一律丢弃，避免历史
         // 内容混进当前卡片（result 分支的 sawInit 守卫升级为全类型守卫）。
         if (type !== 'system' && !this.sawInit)
@@ -678,7 +678,7 @@ export class ClaudeSession extends SpawningRunner {
         const request = (raw.request ?? {});
         const subtype = request.subtype;
         if (subtype !== 'can_use_tool') {
-            // review P3-1：未知 subtype 不能静默丢弃——claude 在等 control_response，
+            // 未知 subtype 不能静默丢弃——claude 在等 control_response，
             // 不回应 turn 会永久挂起（无审批卡、无超时）。deny 兜底让 claude 继续。
             getLogger().warn(`[${this.logTag}] unknown control request subtype=${String(subtype)} requestId=${requestId}`);
             void this.writeControlResponse(requestId, {
@@ -692,7 +692,7 @@ export class ClaudeSession extends SpawningRunner {
         const toolName = String(request.tool_name ?? '');
         const input = (request.input ?? {});
         this.pendingToolInputs.set(requestId, input);
-        // review P1：允许所有只放行工具权限；AskUserQuestion 不能被空 answers
+        // 允许所有只放行工具权限；AskUserQuestion 不能被空 answers
         // 自动放行（claude 会把空答案当作已作答），必须继续上抛卡片让用户回答。
         if (this.autoApprove && toolName !== 'AskUserQuestion') {
             getLogger().info(`[${this.logTag}] auto-approving requestId=${requestId} tool=${toolName}`);
@@ -702,7 +702,7 @@ export class ClaudeSession extends SpawningRunner {
             }).catch((err) => {
                 getLogger().warn(`[${this.logTag}] auto-approve write failed requestId=${requestId}: ${err.message}`);
             });
-            // review P2-1：自动放行不经过协调器/respondPermission，条目不会随
+            // 自动放行不经过协调器/respondPermission，条目不会随
             // 响应被删除——立即释放，否则长会话（允许所有）下 Map 无界增长。
             this.pendingToolInputs.delete(requestId);
             return [];
@@ -717,7 +717,7 @@ export class ClaudeSession extends SpawningRunner {
                     behavior: 'deny',
                     message: '无法解析 AskUserQuestion 选项',
                 }).catch(() => { });
-                // review P2-1：解析失败 deny 后同样释放条目（不经过 respondPermission）。
+                // 解析失败 deny 后同样释放条目（不经过 respondPermission）。
                 this.pendingToolInputs.delete(requestId);
                 return [];
             }
@@ -760,7 +760,7 @@ export class ClaudeSession extends SpawningRunner {
             ];
         }
         // 非命令工具的兜底防御：input 无 command 字段时 JSON 序列化，但空对象
-        // 序列化成 `{}` 对用户无意义——内容为空时回退展示工具名（review P3-5）。
+        // 序列化成 `{}` 对用户无意义——内容为空时回退展示工具名。
         const rawCommand = typeof input.command === 'string' ? input.command : JSON.stringify(input);
         const command = rawCommand && rawCommand !== '{}' && rawCommand !== 'null'
             ? rawCommand
@@ -817,7 +817,7 @@ function parseUserQuestions(input) {
         const question = typeof q.question === 'string' ? q.question : '';
         if (!question)
             continue;
-        // review P3-2：answers 字典以问题文本为 key，重复文本会互相覆盖——
+        // answers 字典以问题文本为 key，重复文本会互相覆盖——
         // 视为解析失败（调用方 deny 兜底），不把坏问题上抛给用户。
         if (seenQuestions.has(question))
             return [];
@@ -839,7 +839,7 @@ function parseUserQuestions(input) {
                 });
             }
         }
-        // review P3-2：零选项问题无法作答（多选连自定义答案都没有），视为
+        // 零选项问题无法作答（多选连自定义答案都没有），视为
         // 解析失败（调用方 deny 兜底），不把坏问题上抛给用户。
         if (options.length === 0)
             return [];

package/dist/runner/codex/app-server/runner.d.ts

@@ -42,6 +42,8 @@ export declare class CodexAppServerRunner extends ConnectionBasedRunner<JsonRpcC
     private connectionManager;
     private currentTranslator;
     private activeThreadId;
+    /** 本轮已记录过日志的外来（子 agent）线程 id，避免逐条 delta 刷盘。 */
+    private foreignThreadIds;
     private model?;
     private modelProvider?;
     private reasoningEffort?;
@@ -91,7 +93,33 @@ export declare class CodexAppServerRunner extends ConnectionBasedRunner<JsonRpcC
      * thread/resume（按 sessionId 恢复既有线程）→ turn/start。
      */
     protected setupTurn(message: string, opts: SpawnOptions): Promise<void>;
+    /**
+     * Route one server notification into the current turn's translator.
+     *
+     * App-server 把已知线程的通知全部复用同一条 stdio 连接：agent 用
+     * multi-agent v2 派生子 agent 后，子线程的 `turn/started`、`item/*`、
+     * `turn/completed`、`thread/tokenUsage/updated` 会与本轮通知交错到达
+     * （2026-10-09 实测）。一个 turn 只属于一个线程，因此外来线程的通知一律
+     * 丢弃——否则子线程的 `turn/started` 会覆盖本轮 threadId，会话写回把子
+     * 线程 id 当成顶层会话指针存盘（冷连接 `thread/resume` 直接报
+     * "cannot resume an unloaded multi-agent v2 sub-agent"），且子线程的
+     * `turn/completed` 会提前结束本轮 run、token 用量也会串台。
+     */
     private handleNotification;
+    /**
+     * 线程归属闸门：通知是否属于本轮 turn 的线程。
+     *
+     * - 无 threadId 的通知（如部分 warning）没有线程维度可用，放行；
+     * - `serverRequest/resolved` 保持线程无关：审批按 requestId 关联（桥侧
+     *   ApprovalCoordinator 跟踪），子 agent 的审批同样必须能结算，否则卡片
+     *   上的审批条目会一直挂在 pending。
+     */
+    private belongsToActiveThread;
+    /**
+     * 每个被忽略的外来线程只记一条日志：这是会话指针被污染的入口，出问题时
+     * 必须能从日志直接看到「本轮忽略了哪些子线程」，同时避免逐条 delta 刷盘。
+     */
+    private noteForeignThread;
     private handleServerRequest;
     private buildGrantedPermissions;
     /** 拒绝权限审批：空 fileSystem + 关闭网络（真实 GrantedPermissionProfile）。 */

package/dist/runner/codex/app-server/runner.js

@@ -12,6 +12,7 @@
  */
 import { ConnectionManager, } from '../../common/jsonrpc/connection-manager.js';
 import { CodexAppServerTranslator } from './translator.js';
+import { NotificationMethod, } from './protocol-types.js';
 import { RpcErrorCode } from '../../common/acp/protocol-types.js';
 import { mapAnswersByIndex } from '../../question-common.js';
 import { getLogger } from '../../../logger/index.js';
@@ -102,6 +103,8 @@ export class CodexAppServerRunner extends ConnectionBasedRunner {
     connectionManager;
     currentTranslator = null;
     activeThreadId = null;
+    /** 本轮已记录过日志的外来（子 agent）线程 id，避免逐条 delta 刷盘。 */
+    foreignThreadIds = new Set();
     model;
     modelProvider;
     reasoningEffort;
@@ -136,7 +139,7 @@ export class CodexAppServerRunner extends ConnectionBasedRunner {
             },
         };
         this.connectionManager = new ConnectionManager(managerOpts);
-        // 协议停止通道（design §3.3）：codex 的 cancel 是 `turn/interrupt` 请求，已由
+        // 协议停止通道：codex 的 cancel 是 `turn/interrupt` 请求，已由
         // cancelCurrentTurn 实现；登记后 win32 优雅停止才有通道可用（否则一路树杀）。
         this.connectionManager.stopper = ({ client }) => this.buildCooperativeStop(client);
     }
@@ -171,6 +174,7 @@ export class CodexAppServerRunner extends ConnectionBasedRunner {
     clearTurnState() {
         this.currentTranslator = null;
         this.activeThreadId = null;
+        this.foreignThreadIds.clear();
     }
     async releaseConnection(cwd) {
         await this.connectionManager.release(cwd);
@@ -235,7 +239,7 @@ export class CodexAppServerRunner extends ConnectionBasedRunner {
         else if (pending.kind === 'permissions') {
             // 权限审批的响应没有 decision 字段（真实协议只回 granted profile +
             // scope）：decline/cancel 必须返回空授权（拒绝全部），否则会把用户已
-            // 勾选的条目当作授予返回（2026-08-12 review 发现：勾选后点「拒绝」实
+            // 勾选的条目当作授予返回（2026-08-12 ：勾选后点「拒绝」实
             // 际授予了所选权限）。accept/acceptForSession 才带用户勾选的条目。
             const denied = action === 'decline' || action === 'cancel';
             client.respond(requestId, {
@@ -358,11 +362,12 @@ export class CodexAppServerRunner extends ConnectionBasedRunner {
         }
         else {
             const threadResult = await client.request('thread/start', threadParams);
-            // 会话键假设（review P2-4）：主线程 thread.id === session_meta.session_id，
+            // 会话键假设：主线程 thread.id === session_meta.session_id，
             // 故 thread.id 可同时用作协议 threadId 与 store/session reader 的 session
             // 键（bridge 用 turn_started 通知的 threadId 写回，/resume、Compact 按此
             // 键定位 JSONL）。forked/subagent 线程二者会分叉（openai/codex#29327），
-            // 桥只把主线程作为顶层会话，不在此链路内。
+            // 桥只把主线程作为顶层会话——子线程的通知由 handleNotification 的线程
+            // 归属闸门挡掉，不会进来（见 belongsToActiveThread）。
             threadId = threadResult.thread.id;
         }
         this.activeThreadId = threadId;
@@ -372,10 +377,58 @@ export class CodexAppServerRunner extends ConnectionBasedRunner {
         const turnResult = await client.request('turn/start', turnParams);
         this.currentTurnId = turnResult.turn.id;
     }
+    /**
+     * Route one server notification into the current turn's translator.
+     *
+     * App-server 把已知线程的通知全部复用同一条 stdio 连接：agent 用
+     * multi-agent v2 派生子 agent 后，子线程的 `turn/started`、`item/*`、
+     * `turn/completed`、`thread/tokenUsage/updated` 会与本轮通知交错到达
+     * （2026-10-09 实测）。一个 turn 只属于一个线程，因此外来线程的通知一律
+     * 丢弃——否则子线程的 `turn/started` 会覆盖本轮 threadId，会话写回把子
+     * 线程 id 当成顶层会话指针存盘（冷连接 `thread/resume` 直接报
+     * "cannot resume an unloaded multi-agent v2 sub-agent"），且子线程的
+     * `turn/completed` 会提前结束本轮 run、token 用量也会串台。
+     */
     handleNotification(method, params) {
+        if (!this.belongsToActiveThread(method, params)) {
+            this.noteForeignThread(params);
+            return;
+        }
         const events = this.currentTranslator?.handleNotification(method, params) ?? [];
         this.pushEvents(events);
     }
+    /**
+     * 线程归属闸门：通知是否属于本轮 turn 的线程。
+     *
+     * - 无 threadId 的通知（如部分 warning）没有线程维度可用，放行；
+     * - `serverRequest/resolved` 保持线程无关：审批按 requestId 关联（桥侧
+     *   ApprovalCoordinator 跟踪），子 agent 的审批同样必须能结算，否则卡片
+     *   上的审批条目会一直挂在 pending。
+     */
+    belongsToActiveThread(method, params) {
+        const active = this.activeThreadId;
+        if (!active)
+            return true;
+        if (method === NotificationMethod.SERVER_REQUEST_RESOLVED)
+            return true;
+        const threadId = params?.threadId;
+        if (typeof threadId !== 'string' || threadId.length === 0)
+            return true;
+        return threadId === active;
+    }
+    /**
+     * 每个被忽略的外来线程只记一条日志：这是会话指针被污染的入口，出问题时
+     * 必须能从日志直接看到「本轮忽略了哪些子线程」，同时避免逐条 delta 刷盘。
+     */
+    noteForeignThread(params) {
+        const threadId = params?.threadId;
+        if (typeof threadId !== 'string' || threadId.length === 0)
+            return;
+        if (this.foreignThreadIds.has(threadId))
+            return;
+        this.foreignThreadIds.add(threadId);
+        getLogger().info(`[${this.logTag}] ignoring notifications from foreign thread threadId=${threadId} activeThreadId=${this.activeThreadId}`);
+    }
     handleServerRequest(id, method, params) {
         const events = this.currentTranslator?.handleServerRequest(id, method, params) ?? [];
         if (events.length === 0) {

package/dist/runner/codex/app-server/translator.d.ts

@@ -26,7 +26,7 @@ export declare class CodexAppServerTranslator {
     /** Full command output per item id (item-scoped snapshot). */
     private toolOutputByItem;
     /**
-     * Tool identity per item id (信息保真 C2): recorded at item/started, spread
+     * Tool identity per item id (信息保真): recorded at item/started, spread
      * into every toolOutput turn_diff, released at item/completed.
      */
     private toolItemMeta;
@@ -85,7 +85,7 @@ export declare class CodexAppServerTranslator {
     private handlePlanUpdated;
     private handleTokenUsageUpdated;
     /**
-     * warning 通知 → notice 事件（信息保真 C2：运行期告警不再静默丢弃）。
+     * warning 通知 → notice 事件（信息保真 运行期告警不再静默丢弃）。
      */
     private handleWarning;
     /**

package/dist/runner/codex/app-server/translator.js

@@ -27,7 +27,7 @@ export class CodexAppServerTranslator {
     /** Full command output per item id (item-scoped snapshot). */
     toolOutputByItem = new Map();
     /**
-     * Tool identity per item id (信息保真 C2): recorded at item/started, spread
+     * Tool identity per item id (信息保真): recorded at item/started, spread
      * into every toolOutput turn_diff, released at item/completed.
      */
     toolItemMeta = new Map();
@@ -326,7 +326,7 @@ export class CodexAppServerTranslator {
                 return [];
             }
             this.toolOutputByItem.set(item.id, authoritative);
-            // 信息保真 C2：完成事件同样携带身份，并在发出后释放 meta。
+            // 信息保真 完成事件同样携带身份，并在发出后释放 meta。
             const meta = this.toolItemMeta.get(item.id);
             this.toolItemMeta.delete(item.id);
             return [
@@ -383,7 +383,7 @@ export class CodexAppServerTranslator {
                 ];
             }
         }
-        // 信息保真 C2：webSearch/mcpToolCall/dynamicToolCall 等无专属 completed 分支的
+        // 信息保真 webSearch/mcpToolCall/dynamicToolCall 等无专属 completed 分支的
         // 工具 item 也必须收尾——否则 run-state 侧工具块永挂 running（无 completedAt/终态），
         // toolItemMeta 泄漏到下个 turn 的 clear() 才被释放。
         if (this.startedToolItems.has(item.id)) {
@@ -466,7 +466,7 @@ export class CodexAppServerTranslator {
         return [];
     }
     /**
-     * warning 通知 → notice 事件（信息保真 C2：运行期告警不再静默丢弃）。
+     * warning 通知 → notice 事件（信息保真 运行期告警不再静默丢弃）。
      */
     handleWarning(params) {
         return [
@@ -653,7 +653,7 @@ export class CodexAppServerTranslator {
             // item/started 锚定工具块位置（真实时序）：命令开始时即创建工具块，
             // 而不是等到首个输出 delta——否则后续 reasoning item 会插到 command 之前。
             this.startedToolItems.add(item.id);
-            // 信息保真 C2：记录工具身份，随 turn_diff 透传（run-state 首见时写入）。
+            // 信息保真 记录工具身份，随 turn_diff 透传（run-state 首见时写入）。
             this.toolItemMeta.set(item.id, {
                 toolName: 'Bash',
                 toolInput: { command: item.command, ...(item.cwd ? { cwd: item.cwd } : {}) },

package/dist/runner/common/acp/acp-approval.d.ts

@@ -2,7 +2,7 @@
  * ACP approval/permission mapping and lifecycle shared by the kimi and
  * opencode ACP runners.
  *
- * Extracted from runner.ts and translator.ts to avoid duplication (G5).
+ * Extracted from runner.ts and translator.ts to avoid duplication.
  * Shape source: approval.ts:28-29 — optionId is opaque, echo back as-is.
  */
 import type { ApprovalView } from '../../types.js';
@@ -33,7 +33,7 @@ export declare function buildAcpPermissionOutcome(action: string, options: Permi
 /**
  * 从服务端 options kind 派生审批决定列表：accept/decline/cancel 恒有；
  * 带 always 类 option（kimi approve_always / opencode allow_always）才提供
- * acceptForSession（§P4「本会话总是允许」）。kimi/opencode 两侧共用。
+ * acceptForSession（「本会话总是允许」）。kimi/opencode 两侧共用。
  */
 export declare function deriveAcpAvailableDecisions(options: PermissionOption[]): string[];
 /** 截断长文本并追加省略号（translator 审批 reason 用，原先两份相同拷贝）。 */

package/dist/runner/common/acp/acp-approval.js

@@ -2,7 +2,7 @@
  * ACP approval/permission mapping and lifecycle shared by the kimi and
  * opencode ACP runners.
  *
- * Extracted from runner.ts and translator.ts to avoid duplication (G5).
+ * Extracted from runner.ts and translator.ts to avoid duplication.
  * Shape source: approval.ts:28-29 — optionId is opaque, echo back as-is.
  */
 import { getLogger } from '../../../logger/index.js';
@@ -10,7 +10,7 @@ import { getLogger } from '../../../logger/index.js';
  * Find an option by matching its `kind` against a list of candidate values,
  * and return the `optionId` to echo back in the approval response.
  * ACP option kind values vary between kimi versions; this handles both
- * the documented names and the observed real names (§2.3).
+ * the documented names and the observed real names.
  */
 function findOptionIdByKind(options, candidateKinds) {
     for (const kind of candidateKinds) {
@@ -54,7 +54,7 @@ export function buildAcpPermissionOutcome(action, options, kinds) {
 /**
  * 从服务端 options kind 派生审批决定列表：accept/decline/cancel 恒有；
  * 带 always 类 option（kimi approve_always / opencode allow_always）才提供
- * acceptForSession（§P4「本会话总是允许」）。kimi/opencode 两侧共用。
+ * acceptForSession（「本会话总是允许」）。kimi/opencode 两侧共用。
  */
 export function deriveAcpAvailableDecisions(options) {
     const decisions = ['accept', 'decline', 'cancel'];

package/dist/runner/common/acp/base-acp-runner.js

@@ -15,7 +15,7 @@ export class BaseAcpRunner extends ConnectionBasedRunner {
     constructor(opts, connectionManager) {
         super(opts);
         this.connectionManager = connectionManager;
-        // 协议停止通道（design §3.3）：ACP 的 cancel 就是 `session/cancel`，已由
+        // 协议停止通道：ACP 的 cancel 就是 `session/cancel`，已由
         // cancelCurrentTurn 实现。这里只做登记接线——manager 建在 super() 实参里，
         // 那时 this 不可用，所以只能等 super() 返回后再赋值。
         connectionManager.stopper = ({ client }) => this.buildCooperativeStop(client);

package/dist/runner/common/acp/base-translator.d.ts

@@ -114,7 +114,7 @@ export declare abstract class BaseAcpTranslator {
      */
     setOperationKind(kind: 'turn' | 'compact'): void;
     /**
-     * plan update → PlanEvent（信息保真 C3.2：不再显式丢弃）。
+     * plan update → PlanEvent（信息保真 不再显式丢弃）。
      * ACP PlanEntry: { content, priority, status }（status: pending/in_progress/
      * completed）。基类具体方法：kimi/opencode wire 结构相同，直接复用。
      */
@@ -125,7 +125,7 @@ export declare abstract class BaseAcpTranslator {
      * JSON.parse (older agents send JSON strings) — keeps the card from
      * crashing on undefined input.
      *
-     * 信息保真 C3.1：kind 命中 KIND_TO_TOOL 时用映射名渲染结构化面板；
+     * 信息保真 kind 命中 KIND_TO_TOOL 时用映射名渲染结构化面板；
      * title 与 name 不同时把 title 存到 content block 的 summary 字段
      * （渲染层做面板副标题）。
      */
@@ -144,7 +144,7 @@ export declare abstract class BaseAcpTranslator {
     /** tool_use name recorded at tool_call time (kind mapping wins, else title). */
     protected getToolCallName(toolCallId: string): string | undefined;
     /**
-     * kind → canonical tool name (信息保真 C3.1). Shared by the initial tool_call
+     * kind → canonical tool name (信息保真). Shared by the initial tool_call
      * handler and the tool_call_update patch builder so both agree on the name.
      */
     protected toolNameFromKind(kind: string | undefined): string | undefined;

package/dist/runner/common/acp/base-translator.js

@@ -1,6 +1,6 @@
 import { NotificationMethod, ServerRequestMethod, SessionEventType, } from './protocol-types.js';
 /**
- * ACP tool kind → 常用工具名映射（信息保真 C3.1，数据驱动无 agent 分支）。
+ * ACP tool kind → 常用工具名映射（信息保真，数据驱动无 agent 分支）。
  * kind 命中映射时用映射名渲染结构化面板；否则回落 title（维持现状）。
  */
 const KIND_TO_TOOL = {
@@ -199,7 +199,7 @@ export class BaseAcpTranslator {
     // Shared notification handlers
     // =========================================================================
     /**
-     * plan update → PlanEvent（信息保真 C3.2：不再显式丢弃）。
+     * plan update → PlanEvent（信息保真 不再显式丢弃）。
      * ACP PlanEntry: { content, priority, status }（status: pending/in_progress/
      * completed）。基类具体方法：kimi/opencode wire 结构相同，直接复用。
      */
@@ -224,7 +224,7 @@ export class BaseAcpTranslator {
      * JSON.parse (older agents send JSON strings) — keeps the card from
      * crashing on undefined input.
      *
-     * 信息保真 C3.1：kind 命中 KIND_TO_TOOL 时用映射名渲染结构化面板；
+     * 信息保真 kind 命中 KIND_TO_TOOL 时用映射名渲染结构化面板；
      * title 与 name 不同时把 title 存到 content block 的 summary 字段
      * （渲染层做面板副标题）。
      */
@@ -327,7 +327,7 @@ export class BaseAcpTranslator {
         return this.toolCallNameByCallId.get(toolCallId);
     }
     /**
-     * kind → canonical tool name (信息保真 C3.1). Shared by the initial tool_call
+     * kind → canonical tool name (信息保真). Shared by the initial tool_call
      * handler and the tool_call_update patch builder so both agree on the name.
      */
     toolNameFromKind(kind) {

package/dist/runner/common/acp/protocol-types.js

@@ -45,7 +45,7 @@ export const RpcErrorCode = {
 //
 // REAL envelope: {sessionId, update: {sessionUpdate: '<kind>', ...}}.
 // The discriminator field is `update.sessionUpdate` — there is NO nested
-// `event.type` / `event.delta` (S5/S6 打回根因：旧实现读 params.event，
+// `event.type` / `event.delta` (旧实现读 params.event，
 // 真实通知全部静默丢弃)。
 // =============================================================================
 /** Notification method names for ACP protocol. */

package/dist/runner/common/connection-based-runner.d.ts

@@ -51,7 +51,7 @@ export declare abstract class ConnectionBasedRunner<TClient, TEvent = AgentEvent
     /** Set up the turn: acquire + thread|session new/resume + prompt. */
     protected abstract setupTurn(message: string, opts: SpawnOptions): Promise<void>;
     /**
-     * 本连接的协议停止通道（design §3.3）。
+     * 本连接的协议停止通道。
      *
      * win32 上「优雅停止」没有可拦截的跨进程 SIGTERM，只能经 agent 自有协议通道
      * 请求对方收摊。子类把这个方法的结果交给 ConnectionManager.stopper，由后者按

package/dist/runner/common/connection-based-runner.js

@@ -28,7 +28,7 @@ export class ConnectionBasedRunner {
         this.turnIdleTimeoutMs = opts.turnIdleTimeoutMs ?? defaultTurnIdleTimeoutMs;
     }
     /**
-     * 本连接的协议停止通道（design §3.3）。
+     * 本连接的协议停止通道。
      *
      * win32 上「优雅停止」没有可拦截的跨进程 SIGTERM，只能经 agent 自有协议通道
      * 请求对方收摊。子类把这个方法的结果交给 ConnectionManager.stopper，由后者按
@@ -141,7 +141,7 @@ export class ConnectionBasedRunner {
     async stop(_opts) {
         if (!this._isRunning)
             return;
-        // CC-01: 启动阶段（client/session 未建立）也必须记录停止意图，否则 /stop 被吞、
+        // 启动阶段（client/session 未建立）也必须记录停止意图，否则 /stop 被吞、
         // turn 照常执行。executeTurn 在 setup 完成后检查 stopRequested 补发 cancel。
         this.stopRequested = true;
         this.forceFinish = true;

package/dist/runner/common/jsonl-stream.d.ts

@@ -4,7 +4,7 @@ import type { Readable } from 'node:stream';
 interface JSONLStreamOptions {
     onParseError?: (line: string) => void;
     /**
-     * Pause stdout once `lineQueue` exceeds this depth (P1-4 backpressure).
+     * Pause stdout once `lineQueue` exceeds this depth (backpressure).
      * Default 100 (matches production; tests may pass a smaller value).
      */
     pauseThreshold?: number;
@@ -23,7 +23,7 @@ interface JSONLStreamOptions {
  * - JSON parse errors: when `options.onParseError` is provided, bad lines are
  *   forwarded to the callback; otherwise a warning is logged via getLogger().warn
  *   and the line is skipped.
- * - Optional backpressure (P1-4): when `pauseThreshold` is set, stdout is
+ * - Optional backpressure: when `pauseThreshold` is set, stdout is
  *   paused once the parsed-line queue exceeds the threshold and resumed once
  *   the consumer drains it back below `resumeThreshold`, bounding memory in
  *   long runs where the producer (agent stdout) outpaces the consumer (card

package/dist/runner/common/jsonl-stream.js

@@ -8,7 +8,7 @@ import { getLogger } from '../../logger/index.js';
  * - JSON parse errors: when `options.onParseError` is provided, bad lines are
  *   forwarded to the callback; otherwise a warning is logged via getLogger().warn
  *   and the line is skipped.
- * - Optional backpressure (P1-4): when `pauseThreshold` is set, stdout is
+ * - Optional backpressure: when `pauseThreshold` is set, stdout is
  *   paused once the parsed-line queue exceeds the threshold and resumed once
  *   the consumer drains it back below `resumeThreshold`, bounding memory in
  *   long runs where the producer (agent stdout) outpaces the consumer (card
@@ -22,7 +22,7 @@ import { getLogger } from '../../logger/index.js';
  */
 export function createJSONLStream(stdout, options) {
     const lineQueue = [];
-    // P3-1: accumulate partial-line fragments in an array instead of repeatedly
+    // accumulate partial-line fragments in an array instead of repeatedly
     // string-concatenating a growing `partialLine`. A huge single JSON line
     // (large tool_result / text_end) spanning many chunks caused O(n²) copies:
     // each chunk rebuilt `partialLine + text` over the whole accumulated prefix.
@@ -30,7 +30,7 @@ export function createJSONLStream(stdout, options) {
     // and push complete lines; the residual tail stays as array fragments until
     // the next newline or stream end. Net allocation: O(n) instead of O(n²).
     const partialFragments = [];
-    // P2-14: accumulated byte length of partialFragments. Backpressure (above)
+    // accumulated byte length of partialFragments. Backpressure (above)
     // only counts COMPLETE lines in lineQueue; a never-newline stream (malformed
     // output, binary garbage) accumulates fragments without ever completing a
     // line, so pause never fires and memory grows unbounded. Cap the partial
@@ -41,13 +41,13 @@ export function createJSONLStream(stdout, options) {
     const completeLines = [];
     let done = false;
     let resolveNext = null;
-    // P1-4 backpressure thresholds. Default matches production (100).
+    // backpressure thresholds. Default matches production (100).
     const pauseThreshold = options?.pauseThreshold ?? 100;
     // Default low-water mark is half the high-water mark for meaningful hysteresis
     // (avoids per-line pause/resume thrashing when callers don't set it explicitly).
     let resumeThreshold = options?.resumeThreshold ?? Math.max(0, Math.floor(pauseThreshold / 2));
     // Clamp misconfiguration: resumeThreshold > pauseThreshold would resume at queue
-    // high water then immediately re-pause on the next line → thrash (P1-4 review nit).
+    // high water then immediately re-pause on the next line → thrash (nit).
     if (resumeThreshold > pauseThreshold)
         resumeThreshold = pauseThreshold;
     let paused = false;
@@ -58,7 +58,7 @@ export function createJSONLStream(stdout, options) {
         }
     }
     // Flush any trailing partial line and mark the stream finished. Shared by the
-    // 'end'/'close'/'error' handlers so flush logic lives in one place (P1-4 review nit).
+    // 'end'/'close'/'error' handlers so flush logic lives in one place (nit).
     function flushAndFinish() {
         if (partialFragments.length > 0) {
             const trimmed = partialFragments.join('').trim();
@@ -70,7 +70,7 @@ export function createJSONLStream(stdout, options) {
         done = true;
         notify();
     }
-    // P2-14: flush an oversize partial line as a bad line. When partialFragments
+    // flush an oversize partial line as a bad line. When partialFragments
     // exceeds the byte cap, the partial line is treated as malformed (a single
     // JSON line should never reach 10MB) and reported via onParseError rather
     // than accumulated indefinitely. Resets the buffer so a pathological stream
@@ -93,7 +93,7 @@ export function createJSONLStream(stdout, options) {
     }
     // Apply backpressure after pushing new lines: pause stdout when the queue
     // exceeds the high-water mark so the producer stops feeding until the
-    // consumer drains it. P1-4 bounds memory in long runs.
+    // consumer drains it.bounds memory in long runs.
     function maybePause() {
         if (pauseThreshold > 0 && !paused && lineQueue.length > pauseThreshold) {
             paused = true;
@@ -110,7 +110,7 @@ export function createJSONLStream(stdout, options) {
     }
     stdout.on('data', (chunk) => {
         const text = chunk.toString('utf-8');
-        // P3-1: split on newlines. The first segment continues the pending partial
+        // split on newlines. The first segment continues the pending partial
         // line (joined with accumulated fragments — one join per chunk, not per
         // byte); subsequent segments are complete lines. The last segment is the
         // new partial tail (kept as a single fragment).
@@ -119,7 +119,7 @@ export function createJSONLStream(stdout, options) {
             // No newline in this chunk: the whole chunk is a partial fragment.
             partialFragments.push(segments[0]);
             partialBytes += segments[0].length;
-            // P2-14: cap the partial line. A never-newline stream would otherwise
+            // cap the partial line. A never-newline stream would otherwise
             // accumulate fragments without bound (backpressure only counts complete
             // lines). Flush as a bad line once the byte cap is exceeded.
             if (partialBytes > PARTIAL_BYTE_LIMIT) {
@@ -140,7 +140,7 @@ export function createJSONLStream(stdout, options) {
             // Last segment is the new partial tail.
             partialFragments.push(segments[segments.length - 1]);
             partialBytes = segments[segments.length - 1].length;
-            // P2-14: the trailing partial tail can itself exceed the cap if a single
+            // the trailing partial tail can itself exceed the cap if a single
             // chunk is larger than 10MB with no internal newline.
             if (partialBytes > PARTIAL_BYTE_LIMIT) {
                 flushOversizePartial();
@@ -162,7 +162,7 @@ export function createJSONLStream(stdout, options) {
     stdout.on('close', () => {
         flushAndFinish();
     });
-    // P1-4: handle stdout 'error' so the generator terminates instead of
+    // handle stdout 'error' so the generator terminates instead of
     // hanging forever on the `await new Promise` below. Without this, a stdout
     // error (e.g. broken pipe, runner crash) leaves the consumer awaiting a
     // notify that never comes → bridge serial queue blocks permanently. We do

package/dist/runner/common/jsonrpc/client.d.ts

@@ -44,7 +44,7 @@ export declare class JsonRpcClient<InitializeResult = unknown> {
      * Replace the per-run hooks (used by the runner to bridge
      * notifications/server requests into the active turn's translator).
      * Connection-layer hooks (slot cleanup / onConnectionLost) are preserved:
-     * review P2-1 — an overwrite here previously silenced onClose slot cleanup,
+     * an overwrite here previously silenced onClose slot cleanup,
      * leaving dead slots behind after the server process was killed.
      */
     setHooks(hooks: ClientHooks): void;