lark-remote 0.5.9 → 0.5.12

package/dist/router/index.js

@@ -319,6 +319,10 @@ const IMMEDIATE_ACTION_CMDS = new Set([
     'queue.diagnose',
     'queue.edit',
     'queue.input',
+    // 终态卡「停止后台任务」：纯远程 job/kill 请求，不产生 agent 工作（§9.19
+    // 控制操作免排队）。排进串行队列会等当前 run 结束才杀任务——stop 类按钮
+    // 排队正是 §9.6 要防的形态，且排队期间还占 lane 多出一张排队卡。
+    'job.kill',
     'order.delete',
     'order.page',
     'order.aliasEdit',
@@ -365,6 +369,20 @@ export const COMPACT_ACTION_CMDS = new Set(['compact', 'resume.compact']);
 function payloadOffset(value) {
     return Math.max(0, Math.trunc(Number(value.offset) || 0));
 }
+/**
+ * existsSync + statSync 的 TOCTOU 安全目录校验：路径在两次 syscalls 之间被删时
+ * statSync 会抛错——落进 enqueueImmediate / 队列任务的静默 catch，点击/命令
+ * 毫无反馈（违反「点击必有反馈」红线；同族 handleLsRefresh/Page/Filter 均已
+ * try/catch 防护）。统一返回 false 走「路径无效」回复。
+ */
+function isDirectorySafe(p) {
+    try {
+        return fs.existsSync(p) && fs.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * 搜索框提交值单源读取：`inputValue` 主路（CardKit 2.0 input 提交（键盘回车/
  * 完成键）经 raw `action.input_value` 回传，SDK normalizer 会丢弃
@@ -822,128 +840,143 @@ export class CommandRouter {
             await this.bridge.sendResult({ text: '⚠️ 正在压缩会话，消息将在压缩完成后按顺序执行。' }, ctx);
             return;
         }
-        // 1.5. If the user edited the message, the original closure (captured at
-        // enqueue time with stale content) must NOT run. Register a one-shot
-        // replacement closure on the task's EXISTING queue slot BEFORE any await:
-        // interruptCurrentRun / markQueueCardExecuting can let the chain advance to
-        // this task's begin, and begin consumes the replacement at that point — a
-        // registration after those awaits would arrive too late (the stale closure
-        // runs and the replacement leaks as a permanent dead closure). Registering
-        // on the existing slot (instead of removeFromQueue + re-enqueue) preserves
-        // the queue position: enqueue can only append to the promise chain tail,
-        // which would put the edited task behind tasks queued after it.
-        if (targetTask.editedMessage) {
-            const editedContent = targetTask.editedMessage;
-            ///Step3: 替换闭包复用原任务的 binding（不重新快照）+ 恢复丢失的
-            // cwdOverride（lane cwd 同源）。否则编辑后重新执行的 run 会丢 cwd 与绑定。
-            this.bridge.setTaskReplacement(cwd, messageId, async () => {
-                await this.handle(editedContent, ctx, {
-                    cwdOverride: cwd,
-                    binding: targetTask.binding,
+        // 1.4. Hold the target's run-card start until this handler has sent its
+        // final feedback. The queue chain can advance during the awaits below
+        // (interruptCurrentRun / the queue-card PATCH): the target may begin and
+        // call forwardToClaude before the toast is sent. Without this hold the
+        // run card would land first, leaving the toast as the newest message —
+        // the chat list then previews the toast instead of the run card's title
+        // (which is how the user follows a run without opening the conversation).
+        // Registered before any await, released in finally on every exit path;
+        // forwardToClaude waits for it before creating the run card.
+        const releaseRunStart = this.bridge.holdQueueTaskRun(cwd, messageId);
+        try {
+            // 1.5. If the user edited the message, the original closure (captured at
+            // enqueue time with stale content) must NOT run. Register a one-shot
+            // replacement closure on the task's EXISTING queue slot BEFORE any await:
+            // interruptCurrentRun / markQueueCardExecuting can let the chain advance to
+            // this task's begin, and begin consumes the replacement at that point — a
+            // registration after those awaits would arrive too late (the stale closure
+            // runs and the replacement leaks as a permanent dead closure). Registering
+            // on the existing slot (instead of removeFromQueue + re-enqueue) preserves
+            // the queue position: enqueue can only append to the promise chain tail,
+            // which would put the edited task behind tasks queued after it.
+            if (targetTask.editedMessage) {
+                const editedContent = targetTask.editedMessage;
+                ///Step3: 替换闭包复用原任务的 binding（不重新快照）+ 恢复丢失的
+                // cwdOverride（lane cwd 同源）。否则编辑后重新执行的 run 会丢 cwd 与绑定。
+                this.bridge.setTaskReplacement(cwd, messageId, async () => {
+                    await this.handle(editedContent, ctx, {
+                        cwdOverride: cwd,
+                        binding: targetTask.binding,
+                    });
                 });
+            }
+            // 2. Stop current running process
+            // (Note: queue executing count is reset inside Bridge.interruptCurrentRun
+            //  so all stop paths — /stop, /t, card stop, queue.immediate — are covered.)
+            const interrupt = await this.bridge.interruptCurrentRunDetailed({
+                userId: ctx.userId,
+                chatId: ctx.chatId,
+                cwd,
             });
-        }
-        // 2. Stop current running process
-        // (Note: queue executing count is reset inside Bridge.interruptCurrentRun
-        //  so all stop paths — /stop, /t, card stop, queue.immediate — are covered.)
-        const interrupt = await this.bridge.interruptCurrentRunDetailed({
-            userId: ctx.userId,
-            chatId: ctx.chatId,
-            cwd,
-        });
-        const stopped = interrupt.stopped;
-        // A remote (DSH) stop is only a request; when it cannot be confirmed the
-        // target must not be promised "immediate" execution — its prompt would sit
-        // behind the still-running turn with no visible progress.
-        const stopUnconfirmed = interrupt.stop?.status === 'unconfirmed';
-        getLogger().info(`[router] queue.immediate: stopped=${stopped} unconfirmed=${stopUnconfirmed}`);
-        // 3. Remove all tasks BEFORE this one (by position in the current queue).
-        // The target may have begun while interruptCurrentRun was awaiting (the chain
-        // advances concurrently): then it is already out of the snapshot and every
-        // remaining queued task is BEHIND it — clearing must stop, not run off the
-        // end and delete tasks queued after the target.
-        const tasks = this.bridge.getQueuedTasks(cwd);
-        const targetIdx = tasks.findIndex((t) => t.messageId === messageId);
-        let removedCount = 0;
-        // Phase 1: remove synchronously. The queue chain advances on any await
-        // (card PATCH round trips included), so every task before the target must
-        // be removed before yielding to the event loop — otherwise a task the user
-        // asked to clear can begin executing while its cancellation card is still
-        // in flight.
-        for (let i = 0; i < targetIdx; i++) {
-            const task = tasks[i];
-            // 撤销卡片由 removeFromQueue 统一触发（fire-and-forget），保持本循环
-            // 同步推进的既有不变式。
-            if (this.bridge.removeFromQueue(cwd, task.messageId)) {
-                removedCount++;
+            const stopped = interrupt.stopped;
+            // A remote (DSH) stop is only a request; when it cannot be confirmed the
+            // target must not be promised "immediate" execution — its prompt would sit
+            // behind the still-running turn with no visible progress.
+            const stopUnconfirmed = interrupt.stop?.status === 'unconfirmed';
+            getLogger().info(`[router] queue.immediate: stopped=${stopped} unconfirmed=${stopUnconfirmed}`);
+            // 3. Remove all tasks BEFORE this one (by position in the current queue).
+            // The target may have begun while interruptCurrentRun was awaiting (the chain
+            // advances concurrently): then it is already out of the snapshot and every
+            // remaining queued task is BEHIND it — clearing must stop, not run off the
+            // end and delete tasks queued after the target.
+            const tasks = this.bridge.getQueuedTasks(cwd);
+            const targetIdx = tasks.findIndex((t) => t.messageId === messageId);
+            let removedCount = 0;
+            // Phase 1: remove synchronously. The queue chain advances on any await
+            // (card PATCH round trips included), so every task before the target must
+            // be removed before yielding to the event loop — otherwise a task the user
+            // asked to clear can begin executing while its cancellation card is still
+            // in flight.
+            for (let i = 0; i < targetIdx; i++) {
+                const task = tasks[i];
+                // 撤销卡片由 removeFromQueue 统一触发（fire-and-forget），保持本循环
+                // 同步推进的既有不变式。
+                if (this.bridge.removeFromQueue(cwd, task.messageId)) {
+                    removedCount++;
+                }
             }
-        }
-        if (targetIdx < 0) {
-            getLogger().debug(`[router] queue.immediate: target no longer queued (began/cancelled), not clearing tasks behind it`);
-        }
-        // 4. DO NOT remove the target task - keep it in queue to execute immediately
-        // The queue will naturally execute it after the current task (which we just stopped)
-        // 4.4. Refresh the replacement with the latest edited content (idempotent:
-        // re-registering over the same slot). Covers the user editing the message
-        // again while interruptCurrentRun was awaiting; skipped automatically once
-        // the task has begun, because getQueuedTask then returns undefined.
-        const latestTask = this.bridge.getQueuedTask(cwd, messageId);
-        if (latestTask?.editedMessage) {
-            const editedContent = latestTask.editedMessage;
-            ///Step3: 复用原任务 binding + 恢复 cwdOverride（同上）。
-            this.bridge.setTaskReplacement(cwd, messageId, async () => {
-                await this.handle(editedContent, ctx, {
-                    cwdOverride: cwd,
-                    binding: latestTask.binding,
+            if (targetIdx < 0) {
+                getLogger().debug(`[router] queue.immediate: target no longer queued (began/cancelled), not clearing tasks behind it`);
+            }
+            // 4. DO NOT remove the target task - keep it in queue to execute immediately
+            // The queue will naturally execute it after the current task (which we just stopped)
+            // 4.4. Refresh the replacement with the latest edited content (idempotent:
+            // re-registering over the same slot). Covers the user editing the message
+            // again while interruptCurrentRun was awaiting; skipped automatically once
+            // the task has begun, because getQueuedTask then returns undefined.
+            const latestTask = this.bridge.getQueuedTask(cwd, messageId);
+            if (latestTask?.editedMessage) {
+                const editedContent = latestTask.editedMessage;
+                ///Step3: 复用原任务 binding + 恢复 cwdOverride（同上）。
+                this.bridge.setTaskReplacement(cwd, messageId, async () => {
+                    await this.handle(editedContent, ctx, {
+                        cwdOverride: cwd,
+                        binding: latestTask.binding,
+                    });
                 });
-            });
-        }
-        // 4.5/6. The target must only be marked executing (and the toast may only
-        // promise immediate execution) when it is really the next task after the
-        // stop. While interruptCurrentRun was awaiting, a task ahead of the target
-        // may have begun and now occupy the cwd — the target is still queued
-        // but is NOT next, so its card must stay queued and the toast must say so.
-        const targetStillQueued = this.bridge.getQueuedTask(cwd, messageId) !== undefined;
-        if (!targetStillQueued) {
-            // The target began or was cancelled while earlier awaits were in flight —
-            // a success toast must never promise execution of a task that will not
-            // run. The two missing-reason states get distinct feedback: a target
-            // that began while the interrupt was in flight is already executing, so
-            // the toast must acknowledge that instead of telling the user nothing
-            // was scheduled; only a target that was actually cancelled (never began)
-            // gets the "未安排执行" wording.
-            if (this.bridge.hasTaskBegan(messageId)) {
-                await this.bridge.sendResult({ text: `ℹ️ 目标消息已开始执行，无需重复操作。已清除 ${removedCount} 条排队消息。` }, ctx);
+            }
+            // 4.5/6. The target must only be marked executing (and the toast may only
+            // promise immediate execution) when it is really the next task after the
+            // stop. While interruptCurrentRun was awaiting, a task ahead of the target
+            // may have begun and now occupy the cwd — the target is still queued
+            // but is NOT next, so its card must stay queued and the toast must say so.
+            const targetStillQueued = this.bridge.getQueuedTask(cwd, messageId) !== undefined;
+            if (!targetStillQueued) {
+                // The target began or was cancelled while earlier awaits were in flight —
+                // a success toast must never promise execution of a task that will not
+                // run. The two missing-reason states get distinct feedback: a target
+                // that began while the interrupt was in flight is already executing, so
+                // the toast must acknowledge that instead of telling the user nothing
+                // was scheduled; only a target that was actually cancelled (never began)
+                // gets the "未安排执行" wording.
+                if (this.bridge.hasTaskBegan(messageId)) {
+                    await this.bridge.sendResult({ text: `ℹ️ 目标消息已开始执行，无需重复操作。已清除 ${removedCount} 条排队消息。` }, ctx);
+                }
+                else {
+                    await this.bridge.sendResult({
+                        text: `⚠️ 目标消息已不在队列中（可能已被撤销），未安排执行。已清除 ${removedCount} 条排队消息。`,
+                    }, ctx);
+                }
+                return;
+            }
+            const workspaceBusy = this.bridge.isBusyFor(cwd);
+            if (stopUnconfirmed) {
+                const name = interrupt.agentKind ? agentDisplayName(interrupt.agentKind) : 'agent';
+                await this.bridge.sendResult({
+                    text: `⚠️ 未能确认 ${name} 的 turn 已停止，它可能仍在后台运行。\n` +
+                        `已清除 ${removedCount} 条排队消息；您的消息已提交，但可能要等该 turn 结束后才开始。`,
+                }, ctx);
+            }
+            else if (!workspaceBusy) {
+                // Normal path: nothing new began during the stop, the target is next.
+                // Mark its own card as executing now so buttons grey out immediately.
+                // Done BEFORE any removal so getQueuedTask still returns the task with
+                // its (possibly edited) messagePreview for the card. The queue callback's
+                // later updateQueueCardToExecuting call becomes a no-op (idempotent).
+                await this.bridge.markQueueCardExecuting(cwd, messageId);
+                const stopPrefix = stopped ? '⚡ 已停止当前任务，' : '';
+                await this.bridge.sendResult({ text: `${stopPrefix}清除了 ${removedCount} 条排队消息。您的消息将立即执行。` }, ctx);
             }
             else {
                 await this.bridge.sendResult({
-                    text: `⚠️ 目标消息已不在队列中（可能已被撤销），未安排执行。已清除 ${removedCount} 条排队消息。`,
+                    text: `⚠️ 排在目标之前的任务已开始执行，目标消息保持排队。已清除 ${removedCount} 条排队消息。`,
                 }, ctx);
             }
-            return;
-        }
-        const workspaceBusy = this.bridge.isBusyFor(cwd);
-        if (stopUnconfirmed) {
-            const name = interrupt.agentKind ? agentDisplayName(interrupt.agentKind) : 'agent';
-            await this.bridge.sendResult({
-                text: `⚠️ 未能确认 ${name} 的 turn 已停止，它可能仍在后台运行。\n` +
-                    `已清除 ${removedCount} 条排队消息；您的消息已提交，但可能要等该 turn 结束后才开始。`,
-            }, ctx);
-        }
-        else if (!workspaceBusy) {
-            // Normal path: nothing new began during the stop, the target is next.
-            // Mark its own card as executing now so buttons grey out immediately.
-            // Done BEFORE any removal so getQueuedTask still returns the task with
-            // its (possibly edited) messagePreview for the card. The queue callback's
-            // later updateQueueCardToExecuting call becomes a no-op (idempotent).
-            await this.bridge.markQueueCardExecuting(cwd, messageId);
-            const stopPrefix = stopped ? '⚡ 已停止当前任务，' : '';
-            await this.bridge.sendResult({ text: `${stopPrefix}清除了 ${removedCount} 条排队消息。您的消息将立即执行。` }, ctx);
         }
-        else {
-            await this.bridge.sendResult({
-                text: `⚠️ 排在目标之前的任务已开始执行，目标消息保持排队。已清除 ${removedCount} 条排队消息。`,
-            }, ctx);
+        finally {
+            releaseRunStart();
         }
     }
     /**
@@ -958,6 +991,11 @@ export class CommandRouter {
         const task = this.bridge.getQueuedTask(cwd, messageId);
         const queueInfo = this.bridge.getQueueInfo(cwd);
         const activeRuns = this.bridge.getAllActiveRuns();
+        // 「排在当前任务之前」按诊断目标自己的位置算（与 sendQueueStatusCard 同法）。
+        // getQueueInfo.tasksAhead 是队尾视角（len-1），诊断目标不是队尾时数字误导。
+        const queuedTasks = this.bridge.getQueuedTasks(cwd);
+        const targetIdx = queuedTasks.findIndex((t) => t.messageId === messageId);
+        const tasksAhead = targetIdx >= 0 ? targetIdx : queueInfo.tasksAhead;
         // Build diagnostic info
         const now = new Date().toLocaleString('zh-CN');
         const pid = process.pid;
@@ -997,7 +1035,7 @@ export class CommandRouter {
                         tag: 'div',
                         text: {
                             tag: 'lark_md',
-                            content: `**队列状态**\n- 排队的任务数: ${queueInfo.position}\n- 当前正在运行: ${queueInfo.isRunning ? '✅ 是' : '❌ 否'}\n- 排在当前任务之前的消息数: ${queueInfo.tasksAhead}`,
+                            content: `**队列状态**\n- 排队的任务数: ${queueInfo.position}\n- 当前正在运行: ${queueInfo.isRunning ? '✅ 是' : '❌ 否'}\n- 排在当前任务之前的消息数: ${tasksAhead}`,
                         },
                     },
                     { tag: 'hr' },
@@ -1188,7 +1226,7 @@ export class CommandRouter {
         const resolvedTarget = path.resolve(targetPath);
         // 与 ls.browse 对齐：目标只要存在且是目录即可切换（不再做子树/父级限制）。
         // 安全边界由 binder owner 认证兜底，见 docs/zh/architecture/design.md §9.7 更新说明。
-        if (!fs.existsSync(resolvedTarget) || !fs.statSync(resolvedTarget).isDirectory()) {
+        if (!isDirectorySafe(resolvedTarget)) {
             await this.bridge.sendResult({ text: `路径无效: ${resolvedTarget}` }, ctx);
             return;
         }
@@ -1355,7 +1393,7 @@ export class CommandRouter {
             return;
         }
         const resolvedTarget = path.resolve(targetPath);
-        if (!fs.existsSync(resolvedTarget) || !fs.statSync(resolvedTarget).isDirectory()) {
+        if (!isDirectorySafe(resolvedTarget)) {
             await this.bridge.sendResult({ text: `路径无效: ${resolvedTarget}` }, ctx);
             return;
         }
@@ -1402,8 +1440,12 @@ export class CommandRouter {
     async handleJobKill(value, ctx) {
         const runId = typeof value.runId === 'string' ? value.runId : '';
         const jobId = typeof value.jobId === 'string' ? value.jobId : '';
-        if (!runId || !jobId)
+        // miss path 必回复（本文件的设计约束）：旧版/异常卡片 payload 缺参时
+        // 静默 return 会让点击毫无反应，用户无从判断。
+        if (!runId || !jobId) {
+            await this.bridge.sendResult({ text: CARD_PAYLOAD_MISSING }, ctx);
             return;
+        }
         if (await this.bridge.killBackgroundJob(runId, jobId, ctx))
             return;
         await this.bridge.sendResult({ text: '停止失败：任务可能已自行结束，或记录已回收' }, ctx);
@@ -1728,12 +1770,14 @@ export class CommandRouter {
         }
         // Refresh the /ws list card in place so "recent" sort is immediately visible
         await this.refreshListCard('ws', value, ctx);
-        // Toast feedback (suppress text when a persistent message was already sent)
+        // Toast feedback (suppress text when a persistent message was already sent).
+        // 兜底文案必须用 warning 型：ws.use 不在 DIRECT_RETURN_CMDS，toast 经
+        // enqueueImmediate fire-and-forget，而 forwardActionFeedback 只转发
+        // error/warning 型——success 型兜底会被双重吞掉，点击毫无反馈。
         return {
-            toast: {
-                type: 'success',
-                content: fallbackToast ?? '',
-            },
+            toast: fallbackToast
+                ? { type: 'warning', content: fallbackToast }
+                : { type: 'success', content: '' },
         };
     }
     /**
@@ -2588,7 +2632,15 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
         if (!fs.existsSync(resolved)) {
             return { text: `路径不存在: ${resolved}` };
         }
-        const stat = fs.statSync(resolved);
+        // TOCTOU：existsSync 与 statSync 之间路径被删时 statSync 抛错，会落进队列
+        // 任务的静默 catch（用户无反馈）——按路径无效回复，与下方 realpath 守卫同口径。
+        let stat;
+        try {
+            stat = fs.statSync(resolved);
+        }
+        catch {
+            return { text: `路径无效: ${resolved}` };
+        }
         if (!stat.isDirectory()) {
             return { text: `不是目录: ${resolved}` };
         }
@@ -3182,6 +3234,11 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
                     return { text: `workspace "${name}" 不存在` };
                 if (!fs.existsSync(wsPath))
                     return { text: `路径不存在: ${wsPath}` };
+                // 目录校验与 /cd、ls.switch 对齐：目录被删后同路径出现同名文件（或
+                // workspace.json 被手改）时 realpath 照样成功——放行会让下一次 run
+                // 以文件为 cwd spawn（ENOTDIR）。
+                if (!isDirectorySafe(wsPath))
+                    return { text: `不是目录: ${wsPath}` };
                 // Canonicalize via realpath so it matches Claude JSONL cwd (2026-06-21).
                 // TOCTOU guard: mirror cmdCd — if the path vanishes
                 // between existsSync and realpath, reply gracefully instead of

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

@@ -175,6 +175,11 @@ export class CodexAppServerRunner extends ConnectionBasedRunner {
         this.currentTranslator = null;
         this.activeThreadId = null;
         this.foreignThreadIds.clear();
+        // pendingApprovals 必须随轮次清理（与 base-acp-runner 同口径）：连接长驻，
+        // 服务端请求 id 在 respawn 后会从小数字重新计数——留着旧条目等于让下一轮
+        // 迟到的卡片点击把载荷回给无关的新请求（coordinator 的超时 cancel 也可能
+        // 落在新一轮的连接上）。
+        this.pendingApprovals.clear();
     }
     async releaseConnection(cwd) {
         await this.connectionManager.release(cwd);
@@ -394,6 +399,13 @@ export class CodexAppServerRunner extends ConnectionBasedRunner {
             this.noteForeignThread(params);
             return;
         }
+        if (method === NotificationMethod.SERVER_REQUEST_RESOLVED) {
+            // 审批被外部结算（Web UI 先答 / 服务端自动放行）时同步摘除 runner 侧
+            // 条目——否则迟到的卡片点击会向已结算的 requestId 回信（服务端报错）。
+            const requestId = params?.requestId;
+            if (requestId !== undefined)
+                this.pendingApprovals.delete(requestId);
+        }
         const events = this.currentTranslator?.handleNotification(method, params) ?? [];
         this.pushEvents(events);
     }

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

@@ -132,6 +132,10 @@ export declare abstract class BaseAcpTranslator {
     protected handleToolCall(event: ToolCallEvent, _sessionId: string): AcpTranslatorEvent[];
     /**
      * tool_call_update → user/tool_result. status:'failed' → is_error:true.
+     *
+     * 终态（completed/failed）产出 tool_result；非终态的 tool_result 由
+     * {@link emitToolResultForNonTerminalUpdate} 裁定（reducer 见到 tool_result
+     * 即置 status:'ok'——无内容的非终态 tool_result 会把运行中的工具提前翻成 ✅）。
      */
     protected handleToolCallUpdate(event: ToolCallUpdateEvent, _sessionId: string): AcpTranslatorEvent[];
     /**
@@ -183,6 +187,14 @@ export declare abstract class BaseAcpTranslator {
      * ({output} / {error}).
      */
     protected extractToolResultContent(event: ToolCallUpdateEvent): unknown;
+    /**
+     * 非终态 tool_call_update 是否附带 tool_result。默认 true（opencode seam
+     * 契约：in-progress 的输出快照随 tool_result 进面板）。kimi 覆写为
+     * 「有内容才发」——它的 in-progress 只带流式 args，空 tool_result 会让
+     * reducer 把运行中的工具提前置 ✅ + 空输出（终态丢失时面板停在错误的
+     * 「已完成」）。
+     */
+    protected emitToolResultForNonTerminalUpdate(content: unknown): boolean;
     /**
      * usage_update → context occupancy bookkeeping. The wire shape is
      * {used, size} (+ opencode: cost:{amount}) — context occupancy, not

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

@@ -269,6 +269,10 @@ export class BaseAcpTranslator {
     }
     /**
      * tool_call_update → user/tool_result. status:'failed' → is_error:true.
+     *
+     * 终态（completed/failed）产出 tool_result；非终态的 tool_result 由
+     * {@link emitToolResultForNonTerminalUpdate} 裁定（reducer 见到 tool_result
+     * 即置 status:'ok'——无内容的非终态 tool_result 会把运行中的工具提前翻成 ✅）。
      */
     handleToolCallUpdate(event, _sessionId) {
         const isError = event.status === 'failed';
@@ -293,6 +297,13 @@ export class BaseAcpTranslator {
             else if (event.rawInput !== undefined && event.rawInput !== null) {
                 this.trackToolCallArgs(event.toolCallId, stringifyUnknown(event.rawInput));
             }
+            // 非终态是否发 tool_result 由子类裁定（emitToolResultForNonTerminalUpdate）：
+            // opencode 的 in-progress 带输出快照，seam 契约钉死「patch + tool_result」
+            // 都要发（面板在工具运行时显示部分输出）；kimi 的 in-progress 只带流式
+            // args，空 tool_result 会让 reducer 把运行中的工具提前置 ✅ + 空输出。
+            if (!this.emitToolResultForNonTerminalUpdate(content)) {
+                return useUpdate ? [useUpdate] : [];
+            }
         }
         const events = [];
         if (useUpdate)
@@ -390,6 +401,17 @@ export class BaseAcpTranslator {
     extractToolResultContent(event) {
         return event.rawOutput ?? '';
     }
+    /**
+     * 非终态 tool_call_update 是否附带 tool_result。默认 true（opencode seam
+     * 契约：in-progress 的输出快照随 tool_result 进面板）。kimi 覆写为
+     * 「有内容才发」——它的 in-progress 只带流式 args，空 tool_result 会让
+     * reducer 把运行中的工具提前置 ✅ + 空输出（终态丢失时面板停在错误的
+     * 「已完成」）。
+     */
+    emitToolResultForNonTerminalUpdate(content) {
+        void content;
+        return true;
+    }
     /**
      * usage_update → context occupancy bookkeeping. The wire shape is
      * {used, size} (+ opencode: cost:{amount}) — context occupancy, not

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

@@ -1,4 +1,5 @@
 import { getLogger } from '../../logger/index.js';
+import { StringDecoder } from 'node:string_decoder';
 /**
  * Parse JSONL (newline-delimited JSON) from a readable stream.
  *
@@ -30,6 +31,8 @@ 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 = [];
+    // 跨 chunk 多字节字符的边界安全解码器（见 stdout 'data' 处理）。
+    const decoder = new StringDecoder('utf8');
     // 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
@@ -60,6 +63,11 @@ 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 (nit).
     function flushAndFinish() {
+        // decoder.end() 吐出被 chunk 边界切开的最后一个多字节字符的残余字节
+        //（无残尾时返回空串）：不加这句，末尾被切开的字符会凭空丢失。
+        const tail = decoder.end();
+        if (tail)
+            partialFragments.push(tail);
         if (partialFragments.length > 0) {
             const trimmed = partialFragments.join('').trim();
             if (trimmed)
@@ -109,7 +117,10 @@ export function createJSONLStream(stdout, options) {
         }
     }
     stdout.on('data', (chunk) => {
-        const text = chunk.toString('utf-8');
+        // StringDecoder 按字节边界解码：多字节字符（中文/emoji）被 chunk 边界
+        // 切开时，裸 toString 会产出不可逆的 U+FFFD（同族修复见
+        // jsonrpc/transport.ts，claude 的中文输出走本流）。
+        const text = decoder.write(chunk);
         // 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

package/dist/runner/common/jsonrpc/connection-manager.d.ts

@@ -147,6 +147,12 @@ export declare class ConnectionManager<TClient extends ConnectionClient = JsonRp
      *
      * `idleTtlMs: 0` = 不回收（与 claude 会话层的 `armIdleTimer` 同口径；按 0
      * setTimeout 会秒删刚建好的连接，等于每条消息重起一次进程）。
+     *
+     * 定时器回调带 **slot 身份校验**：武装之后 slot 可能已被替换——进程自退走
+     * baseOnClose（删 slot 但不经过 disposeSlot）、或同 cwd 已 acquire 了新连接。
+     * 这两种情况下本定时器都已过期，不得回收「当时恰好挂在该 cwd 上」的连接：
+     * 2026-10-24 线上事故即一条泄漏的过期 TTL 杀掉继任连接的在途 turn，卡片
+     * 误报 "Codex app-server connection closed"。
      */
     notifyIdle(cwd: string): void;
     private createClient;

package/dist/runner/common/jsonrpc/connection-manager.js

@@ -84,7 +84,17 @@ export class ConnectionManager {
             if (existing) {
                 // If a create is in flight, wait for it
                 if (existing.createPromise) {
-                    return existing.createPromise;
+                    const client = await existing.createPromise;
+                    // 快速路径复核（与下方建槽方的竞态复核对称）：await 期间槽位被
+                    // release()/disposeAll() 删掉时，建槽方会 dispose 该连接并重试——
+                    // 直接返回会把「已被建槽方 dispose 的连接」交给本调用方（表现为
+                    // setupTurn 抛 ConnectionLostError 走 respawn-retry 自愈）。槽位
+                    // 不再持有该 client 时与本轮创建同路：重试。
+                    const current = this.slots.get(cwd);
+                    if (current && current.client === client) {
+                        return client;
+                    }
+                    continue;
                 }
                 // Reuse when the (session-aware) reuse predicate holds — e.g. the client
                 // is ready and its transport is alive (default), or it is bound to the
@@ -183,18 +193,27 @@ export class ConnectionManager {
      *
      * `idleTtlMs: 0` = 不回收（与 claude 会话层的 `armIdleTimer` 同口径；按 0
      * setTimeout 会秒删刚建好的连接，等于每条消息重起一次进程）。
+     *
+     * 定时器回调带 **slot 身份校验**：武装之后 slot 可能已被替换——进程自退走
+     * baseOnClose（删 slot 但不经过 disposeSlot）、或同 cwd 已 acquire 了新连接。
+     * 这两种情况下本定时器都已过期，不得回收「当时恰好挂在该 cwd 上」的连接：
+     * 2026-10-24 线上事故即一条泄漏的过期 TTL 杀掉继任连接的在途 turn，卡片
+     * 误报 "Codex app-server connection closed"。
      */
     notifyIdle(cwd) {
         if (this.idleTtlMs <= 0)
             return;
         const slot = this.slots.get(cwd);
-        if (slot) {
-            this.clearIdleTimer(slot);
-            slot.idleTimer = setTimeout(() => {
-                getLogger().info(`[${this.logTag}] idle timeout for cwd=${cwd}, releasing connection`);
-                this.disposeSlot(cwd);
-            }, this.idleTtlMs);
-        }
+        if (!slot)
+            return;
+        this.clearIdleTimer(slot);
+        slot.idleTimer = setTimeout(() => {
+            slot.idleTimer = null;
+            if (this.slots.get(cwd) !== slot)
+                return;
+            getLogger().info(`[${this.logTag}] idle timeout for cwd=${cwd}, releasing connection`);
+            this.disposeSlot(cwd);
+        }, this.idleTtlMs);
     }
     // =========================================================================
     // Internal
@@ -222,7 +241,13 @@ export class ConnectionManager {
                 getLogger().info(`[${this.logTag}] connection closed cwd=${cwd}`);
                 // 只清理自己创建的 slot：并发 release + 重新 acquire 后 slot 可能已被
                 // 新连接占据，误删会破坏新连接。
-                if (this.slots.get(cwd)?.client === client) {
+                const current = this.slots.get(cwd);
+                if (current?.client === client) {
+                    // 进程自退（codex app-server 偶发 exit 0，非本程序发起，不经
+                    // disposeSlot）也要撤掉挂在旧 slot 上的 idle TTL：定时器不随 slot
+                    // 删除而取消，到期时会按 cwd 误杀继任连接的在途 turn（2026-10-24
+                    // 线上事故，见 notifyIdle 的身份校验与对应回归测试）。
+                    this.clearIdleTimer(current);
                     this.slots.delete(cwd);
                     this.onConnectionLost?.(cwd);
                 }