lark-remote 0.5.10 → 0.5.12

package/dist/card/run-renderer.js

@@ -9,7 +9,7 @@ import { displayWidth, truncateToDisplayWidth } from '../common/text-width.js';
 import { isContentFilterFailure } from '../common/turn-failure.js';
 import { formatClock, formatTimestamp } from './time.js';
 import { formatUsageStats } from '../router/usage-format.js';
-import { renderApprovalArea } from './approval-render.js';
+import { renderApprovalArea, renderApprovalAreaCompact } from './approval-render.js';
 const REASONING_BYTES = 4_500;
 const TEXT_BYTES = 10_000;
 const DEGRADED_THINKING_KEEP = 2;
@@ -448,6 +448,24 @@ function approvalArea(state) {
     }
     return elements;
 }
+/**
+ * 紧凑审批区（skeleton/truncatedSkeleton 兜底专用）：完整审批区不受估算器
+ * 管辖、不参与 degraded/extreme 分层裁剪，pathological 输入（超长 reason、
+ * 题数×选项爆元素数）会让所有兜底层一起超限——超限卡被飞书整卡拒收（11310），
+ * 审批彻底不可见，run 挂到审批超时/看门狗。兜底层换用紧凑形态（固定小体积、
+ * 保留决策/跳过按钮），结构性保证审批入口在任何降级档都活着。
+ */
+function approvalAreaCompact(state) {
+    const elements = [];
+    for (const slot of state.approvals ?? []) {
+        elements.push(...renderApprovalAreaCompact(slot.view, {
+            expired: slot.expired,
+            runId: state.runId,
+            terminal: state.terminal,
+        }));
+    }
+    return elements;
+}
 /** 底部操作行之前的内容区提示：被 MAX_BLOCKS 截掉的早期块计数（信息保真）。 */
 function omittedBlocksHint(state) {
     return state.omittedBlocks !== undefined && state.omittedBlocks > 0
@@ -654,11 +672,12 @@ function elapsedLabel(state) {
         return `${hours}h${String(minutes % 60).padStart(2, '0')}m`;
     return `${Math.floor(hours / 24)}d${String(hours % 24).padStart(2, '0')}h`;
 }
-/** token 数量的紧凑写法：`950` / `12K` / `1.2M`。 */
+/** token 数量的紧凑写法：`950` / `12K` / `1.0M`。 */
 function formatTokens(tokens) {
     if (tokens < 1000)
         return String(tokens);
-    if (tokens < 1_000_000)
+    // 千位边界取 M 档：999_500 起四舍五入会得到 "1000K"，直接按 M 档展示。
+    if (tokens < 999_500)
         return `${Math.round(tokens / 1000)}K`;
     return `${(tokens / 1_000_000).toFixed(1)}M`;
 }
@@ -885,20 +904,23 @@ export function renderRunCard(state, options = {}) {
         return extremeCard;
     }
     const skeletonCard = assembleRunCard(state, options, buildSkeletonElements(state, options));
-    // skeleton 卡是静态结构，理论上必 ≤28KB；保留兜底断言以防未来结构膨胀
-    if (Buffer.byteLength(JSON.stringify(skeletonCard), 'utf8') <= CARD_BUDGET_BYTES) {
+    // skeleton 卡是静态结构，理论上必 ≤28KB；但审批区/summary 携带 agent 产出
+    // 文本，仍可能把任一维度顶爆（此前只查字节——题数×选项的元素数超限会漏网）。
+    // 保留兜底断言以防未来结构膨胀；超限则降级到 truncatedSkeleton。
+    if (withinRunCardBudget(skeletonCard)) {
         return skeletonCard;
     }
-    // 理论上不可达：skeleton 已是静态最小结构。若仍超限（errorMsg 等无界文本
-    // 灌进 summary），硬截断只丢 summary——审批入口与 stop/新会话按钮是红线，
-    // 任何一级兜底都不能把它们截掉（丢了用户就再也停不下这个 run）。
+    // 理论上不可达：skeleton 已是静态最小结构。若仍超限（超长 reason、题数×
+    // 选项爆元素数等审批区输入），硬截断只丢 summary 与完整审批区——审批入口
+    // （紧凑形态：标题 + 摘要 + 决策/跳过按钮）与 stop/新会话按钮是红线，任何
+    // 一级兜底都不能把它们截掉（丢了用户就再也停不下这个 run / 答不了审批）。
     const truncatedSkeleton = {
         ...skeletonCard,
         body: {
             elements: [
                 statusRow(state),
                 markdownDiv('_⚠️ 输出过大_'),
-                ...approvalArea(state),
+                ...approvalAreaCompact(state),
                 ...actionRow(state, options),
             ],
         },

package/dist/common/text-width.js

@@ -54,6 +54,11 @@ function charWidth(ch) {
         return 2;
     if (code >= 0x2600 && code <= 0x27bf)
         return 2;
+    // Misc Technical 块（U+2300–U+23FF）：⏱⏹⏳⏸⏺ 等计时器/播放器符号在
+    // 状态行里实际使用，手机端按 emoji 宽度渲染——按 1 计会系统性低估行宽，
+    // 窄屏余量比设计值更小。
+    if (code >= 0x2300 && code <= 0x23ff)
+        return 2;
     return 1;
 }
 /**

package/dist/common/tool-summary.js

@@ -61,7 +61,9 @@ export function summarizeToolInput(name, input) {
         if (typeof v !== 'string')
             return '';
         const oneLine = v.replace(/\s+/g, ' ').trim();
-        return oneLine.length > max ? `${oneLine.slice(0, max)}…` : oneLine;
+        // 码点安全截断：裸 slice 切在代理对中间会留下孤立代理项进卡片
+        // （同族修复见 tool-render.ts 的 toolHeaderText）。
+        return truncate(oneLine, max);
     };
     /** First non-empty of several keys（DSH 同名工具跨版本改过参数名）。 */
     const pickAny = (keys, max = HEADER_SUMMARY_MAX) => {
@@ -82,7 +84,7 @@ export function summarizeToolInput(name, input) {
         for (const item of v) {
             if (typeof item === 'string' && item.trim()) {
                 const oneLine = item.replace(/\s+/g, ' ').trim();
-                return oneLine.length > max ? `${oneLine.slice(0, max)}…` : oneLine;
+                return truncate(oneLine, max);
             }
             if (item && typeof item === 'object') {
                 const path = item.path;

package/dist/config/codex-config.js

@@ -518,9 +518,11 @@ export function loadCodexConfig(opts = {}) {
         };
     }
     catch {
-        // config.toml 解析失败（readModelCatalogJsonPath 已把此场景标记为 catalog 声明退化 ''）：
-        // catalogMode 为 true 时绝不回退 bundled/FALLBACK，返回空 provider/模型列表；
-        // 非 catalog 才走 FALLBACK 兜底。
+        // config.toml 读取/解析失败：readModelCatalogJsonPath 对此返回
+        // TOML_PARSE_FAILED_SENTINEL（isCodexCatalogMode → false），进入本 catch
+        // 时 catalogMode 恒为 false——下面的 `if (catalogMode)` 分支实际不可达，
+        // 仅作防御保留。真正「catalog 声明退化」的场景（'' 哨兵）在 parse 之前
+        // 就已按 FALLBACK 兜底处理，不会走到这里。
         if (catalogMode) {
             return {
                 currentModel: '',

package/dist/config/index.js

@@ -353,7 +353,19 @@ export function loadConfig(configPath) {
         process.exit(1);
     }
     const raw = fs.readFileSync(configPath, 'utf-8');
-    const parsed = YAML.parse(raw);
+    // YAML 语法错误（tab 缩进等）必须与校验失败同路径（console.error + exit）：
+    // 直接上抛会冒到 main().catch——此时 logger 尚未 initLogger，getLogger()
+    // 写的是默认目录的自定义 --config-dir 对不上，且 logger 只写文件，终端
+    // 零输出，用户只看到进程无声退出。
+    let parsed;
+    try {
+        parsed = YAML.parse(raw);
+    }
+    catch (err) {
+        console.error(`[lark-remote] config YAML parse failed at ${configPath}:`);
+        console.error(`  ${err.message}`);
+        process.exit(1);
+    }
     const result = AppConfigSchema.safeParse(parsed);
     if (!result.success) {
         const errors = result.error.issues.map((i) => `  ${i.path.join('.')}: ${i.message}`).join('\n');

package/dist/index.js

@@ -34,9 +34,17 @@ import { InboundAuthorizer } from './inbound/authorize.js';
 import { stripPlaceholders } from './inbound/placeholder.js';
 import { buildSessionHistoryCard, pickResumeCardEvents } from './router/card-helpers.js';
 import { newSessionButton, resumeCompactButton, agentDisplayName } from './card/card-shared.js';
+import { sleep } from './common/sleep.js';
 import path from 'node:path';
 import fs from 'node:fs';
 import { bestEffortUnlink } from './common/fs.js';
+/**
+ * 会话变更类卡片动作执行前冲刷入站装配窗口的等待预算（ms）。flush 本身无下载
+ * 在途时瞬时完成（顺序保证完整）；预算只挡「in-flight 媒体下载卡住」的场景
+ * （下载超时 5 分钟/资源）——SDK 把卡片动作放进与消息共享的 per-chat 串行
+ * lane 并 await 到底，无界等待会让整个 chat 停摆到下载超时。
+ */
+const SESSION_MUTATING_FLUSH_BUDGET_MS = 2_000;
 /**
  * /stop 命令别名单源：普通消息的停止分支与 clone 活跃期拦截的排除条件
  * 共用同一判定，防止将来加别名时两处漂移。
@@ -363,9 +371,12 @@ function setupMessageHandlers(connector, router, bridge, sessionStore, workspace
             };
             let cwd = sessionStore.getCwd(turn.userId) ?? '';
             if (!cwd && workspaceStore) {
-                const workspaces = workspaceStore.list();
-                if (workspaces.length > 0)
-                    cwd = workspaces[0].path;
+                // 兜底取「最近使用」而非插入序首位：WorkspaceStore.list() 按 Map 插入序
+                // 返回（touch 原地改时间戳不重排），[0] 恒为最早保存的别名——触发时会把
+                // 消息静默发到最旧工作区，与「最近使用」直觉相反。
+                const recent = [...workspaceStore.list()].sort((a, b) => b.lastUsedAt - a.lastUsedAt);
+                if (recent.length > 0)
+                    cwd = recent[0].path;
             }
             const binding = bridge.currentBinding(turn.userId);
             bridge.enqueue(cwd, async () => {
@@ -456,6 +467,14 @@ function setupMessageHandlers(connector, router, bridge, sessionStore, workspace
             logger.warn(`[media] rejected inbound media from non-owner ${msg.userId}`);
             return;
         }
+        // clone 状态机活跃期：一切输入归 clone 流程、不落盘附件
+        // （inbound-unified-input-design.md §5.8；文本入口有同款闸门）。静默丢弃
+        // 而非发回执——装配器的「📎 已保存」回执会与 clone 引导话术冲突，诱导
+        // 用户「说一句话」触发 clone 的婉拒回复。
+        if (cloneSession.isActive()) {
+            logger.info(`[media] dropped inbound media during clone session ${msg.messageId}`);
+            return;
+        }
         // 读 router.config（活引用）：/config 保存后 setConfigValues 返回新对象，
         // 启动时捕获的 config 参数会过期（修复）。
         if (!router.config.inboundMedia.enabled) {
@@ -599,26 +618,14 @@ function setupMessageHandlers(connector, router, bridge, sessionStore, workspace
         // Add Typing reaction to indicate "still alive"
         void connector.addReaction(messageId, 'Typing');
         if (actionValue.cmd === 'stop') {
-            if (!actionValue.runId) {
-                logger.warn('[control] ignored stop card action without runId');
-                // Card button clicks must have visible feedback (design constraint: card button
-                // 点击必须有可见反馈，见 design.md §6.2)。
-                void bridge
-                    .sendResult({ text: '⚠️ 无效的停止请求，缺少必要信息' }, { userId, chatId, messageId })
-                    .catch((err) => logger.error('[control] card stop feedback failed:', err));
-                return;
-            }
-            void (async () => {
-                const stopped = await bridge.interruptCurrentRun({
-                    userId,
-                    chatId,
-                    runId: actionValue.runId,
-                });
-                if (!stopped) {
-                    // runId mismatch or run already exited — mirror /stop text miss path.
-                    await bridge.sendResult({ text: '该任务已结束，无需终止' }, { userId, chatId, messageId });
-                }
-            })().catch((err) => logger.error('[control] card stop failed:', err));
+            // 委托 router 的 handleCardStop（单一来源）：miss 反馈与 DSH unconfirmed
+            // 警告（「未能确认 turn 已停止，可能仍在后台运行」）都在那里。此前这里
+            // 内联只调 interruptCurrentRun——unconfirmed 反馈被丢，run 卡被翻成
+            // interrupted 却暗示干净停止；miss 文案也与 router 形成两份漂移拷贝。
+            // stop 绕串行队列的原则不变：本分支在队列分发之前直接 return。
+            void router
+                .handleCardAction({ ...actionValue, cmd: 'stop' }, { userId, chatId, messageId })
+                .catch((err) => logger.error('[control] card stop failed:', err));
             return;
         }
         const isImmediate = isImmediateAction(actionValue.cmd);
@@ -632,8 +639,19 @@ function setupMessageHandlers(connector, router, bridge, sessionStore, workspace
         // 保证窗口内先到的文本消息在本动作之前 commit（绑定旧 session/cwd/agent）。
         // 否则 700ms 静默窗内的消息会漂移到动作之后的新状态：例如输入「重新构建」
         // 后立即点「新会话」，消息会落到新会话。名单以 router 单源为准。
+        //
+        // 有界等待：flush 会等 in-flight 媒体下载落定（超时 5 分钟/
+        // 资源），而 SDK 的 chatQueue.cardActions 默认 'same'——卡片动作与消息共享
+        // 同一 per-chat 串行 lane 且被 await 到底。无界等待下，一个大视频在途 +
+        // 点「新会话」= 整个 chat 的所有消息与卡片动作停摆到下载超时。超预算后
+        // 放行本动作，flush 在后台继续：窗口内仍有未落定下载时，文本 commit 可能
+        // 落到本动作之后（漂移风险收窄到「卡住的下载 + 2s 内点击」的组合，可接受；
+        // 完整解法需要把 binding 快照进装配器，见 inbound-unified-input-design.md）。
         if (SESSION_MUTATING_ACTION_CMDS.has(actionValue.cmd)) {
-            await assembler.flush(userId, chatId, 'flush');
+            const flushP = assembler
+                .flush(userId, chatId, 'flush')
+                .catch((err) => logger.error('[control] inbound flush failed:', err));
+            await Promise.race([flushP, sleep(SESSION_MUTATING_FLUSH_BUDGET_MS)]);
         }
         // queue.input / config.save / approval.respond / approval.toggle /
         // approval.answer 系列返回 CardActionResponse toast 给点击用户即时反馈。

package/dist/instance-lock.d.ts

@@ -33,7 +33,15 @@ export declare class InstanceLock {
      * 与 CIM CommandLine 首 token 归一后必然一致（bun/node 垫片场景亦然）。
      */
     private lockContents;
-    /** 原子创建锁文件；已存在返回 false，其它 IO 错误向上抛。 */
+    /**
+     * 原子创建锁文件；已存在返回 false，其它 IO 错误向上抛。
+     *
+     * 先写完整临时文件再 `link()`：`open(wx)` 与 `write` 之间存在微秒级「空文件」
+     * 窗口，并发进程在该窗口读到的锁是「空 → 损坏 → 陈旧」，rename 夺走后双方
+     * 各持一份（A 的 fd 写进已被删掉的 inode、B 建了自己的锁 → 双实例）。
+     * link() 创建即含全部内容，窗口不存在；文件系统不支持 hardlink 时退回 wx
+     * 直建（该类 FS 上保留既有行为，竞态面收窄到该类文件系统）。
+     */
     private tryCreate;
     /**
      * 把夺来的活锁放回原位。优先 `link`（目标已存在会失败，不会覆盖更新的锁），

package/dist/instance-lock.js

@@ -177,22 +177,57 @@ export class InstanceLock {
     lockContents(pid) {
         return `${pid}\n${binaryName(process.execPath)}`;
     }
-    /** 原子创建锁文件；已存在返回 false，其它 IO 错误向上抛。 */
+    /**
+     * 原子创建锁文件；已存在返回 false，其它 IO 错误向上抛。
+     *
+     * 先写完整临时文件再 `link()`：`open(wx)` 与 `write` 之间存在微秒级「空文件」
+     * 窗口，并发进程在该窗口读到的锁是「空 → 损坏 → 陈旧」，rename 夺走后双方
+     * 各持一份（A 的 fd 写进已被删掉的 inode、B 建了自己的锁 → 双实例）。
+     * link() 创建即含全部内容，窗口不存在；文件系统不支持 hardlink 时退回 wx
+     * 直建（该类 FS 上保留既有行为，竞态面收窄到该类文件系统）。
+     */
     tryCreate() {
+        const tmp = `${this.lockPath}.new-${process.pid}-${randomBytes(6).toString('hex')}`;
         try {
-            const fd = fs.openSync(this.lockPath, 'wx');
+            const fd = fs.openSync(tmp, 'wx');
             try {
                 fs.writeSync(fd, this.lockContents(process.pid));
             }
             finally {
                 fs.closeSync(fd);
             }
-            return true;
+            try {
+                fs.linkSync(tmp, this.lockPath);
+                return true;
+            }
+            catch (err) {
+                const code = err.code;
+                if (code === 'EEXIST')
+                    return false;
+                if (code === 'EPERM' || code === 'EOPNOTSUPP' || code === 'ENOSYS' || code === 'EXDEV') {
+                    // hardlink 不可用（网络/overlay FS）：退回 wx 直建。
+                    try {
+                        const direct = fs.openSync(this.lockPath, 'wx');
+                        try {
+                            fs.writeSync(direct, this.lockContents(process.pid));
+                        }
+                        finally {
+                            fs.closeSync(direct);
+                        }
+                        return true;
+                    }
+                    catch (err2) {
+                        if (err2.code === 'EEXIST')
+                            return false;
+                        throw err2;
+                    }
+                }
+                throw err;
+            }
         }
-        catch (err) {
-            if (err.code === 'EEXIST')
-                return false;
-            throw err;
+        finally {
+            // 成功 link 后 tmp 与 lockPath 同 inode：删 tmp 只去掉多余名字（nlink 2→1）。
+            bestEffortUnlink(tmp);
         }
     }
     /**

package/dist/platform/identity.js

@@ -12,9 +12,9 @@
  *   （killOrphan）应按需调用，真机矩阵需实测整体耗时；
  * - platform 显式注入，win32 语义可在任意宿主上单测。
  */
-import { execFileSync, spawn } from 'node:child_process';
 import path from 'node:path';
 import { currentPlatform, isWin32 } from './select.js';
+import { spawnProcess, spawnProcessSync } from './spawn.js';
 const DEFAULT_TIMEOUT_MS = 3000;
 /** 拉起一次性查询进程并收全 stdout；超时/拉起失败/进程报错一律 null。 */
 function collect(file, args, timeoutMs) {
@@ -24,7 +24,7 @@ function collect(file, args, timeoutMs) {
             // stderr 用 ignore：查询进程的错误输出我们不需要，pipe 而不消费在极端
             // 情况下（管道缓冲满）会阻塞子进程，把一次性查询拖成挂起。
             // windowsHide：避免查询进程在桌面闪控制台窗口
-            proc = spawn(file, args, { stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
+            proc = spawnProcess(file, args, { stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
         }
         catch {
             resolve(null);
@@ -243,12 +243,13 @@ export function verifyPidIdentityVerdictSync(pid, opts) {
         return 'unknown';
     let stdout;
     try {
-        stdout = execFileSync('ps', ['-o', 'command=', '-p', String(pid)], {
+        const res = spawnProcessSync('ps', ['-o', 'command=', '-p', String(pid)], {
             encoding: 'utf-8',
             timeout: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
             stdio: ['ignore', 'pipe', 'ignore'],
             windowsHide: true,
         });
+        stdout = String(res.stdout ?? '');
     }
     catch {
         // 进程不存在 / ps 不可用 / 超时：查不到身份 → unknown（不杀）

package/dist/platform/path.js

@@ -21,8 +21,10 @@ function resolveOptions(opts) {
  */
 export function pathKey(p, opts) {
     const { platform } = resolveOptions(opts);
+    // linux：剥尾部分隔符，与 darwin/win32 同口径（否则 `/cd ~/repo/` 与
+    // `/cd ~/repo` 会被判成两个目录——darwin 分支注释写明的不变量）。
     if (platform === 'linux')
-        return p;
+        return p.replace(/\/+$/, '');
     if (isWin32(platform)) {
         // win32：\ 与 / 都是分隔符，且路径大小写不敏感
         return p.replaceAll('\\', '/').replace(/\/+$/, '').toLowerCase();

package/dist/platform/terminator-win32.d.ts

@@ -1,3 +1,15 @@
+/**
+ * win32 终止器：协议停止通道 → grace 等待 → taskkill 树杀。
+ *
+ * 状态机：
+ *   1. 进程已退出 → nothing（via='already-exited'）
+ *   2. immediate  → taskkill /PID <pid> /T /F
+ *   3. 优雅       → AgentStopperRegistry 查协议通道
+ *      - 无通道：打日志显式跳过优雅段（不等一个不会来的退出事件）→ 直接树杀
+ *      - 有通道：调用后与 exit 事件竞速等 graceMs，仍存活 → 树杀
+ *
+ * 依赖（spawn / 等待器 / 日志）全部构造注入，win32 语义可在任意宿主上单测。
+ */
 import type { ChildProcess, SpawnOptions } from 'node:child_process';
 import type { Terminator } from './terminator.js';
 import { AgentStopperRegistry } from './agent-stopper.js';
@@ -11,7 +23,7 @@ export interface Win32TerminatorDeps {
     agent?: string;
     /** 协议通道注册表注入（测试隔离）；默认进程级单例 */
     stoppers?: AgentStopperRegistry;
-    /** spawn 注入（测试用）；默认 node:child_process */
+    /** spawn 注入（测试用）；默认 platform/spawn.ts 的 spawnProcess */
     spawn?: SpawnLike;
     /** grace 等待器注入（测试用）；默认与 exit 事件竞速 */
     waitForExit?: WaitForExit;

package/dist/platform/terminator-win32.js

@@ -1,17 +1,5 @@
-/**
- * win32 终止器：协议停止通道 → grace 等待 → taskkill 树杀。
- *
- * 状态机：
- *   1. 进程已退出 → nothing（via='already-exited'）
- *   2. immediate  → taskkill /PID <pid> /T /F
- *   3. 优雅       → AgentStopperRegistry 查协议通道
- *      - 无通道：打日志显式跳过优雅段（不等一个不会来的退出事件）→ 直接树杀
- *      - 有通道：调用后与 exit 事件竞速等 graceMs，仍存活 → 树杀
- *
- * 依赖（spawn / 等待器 / 日志）全部构造注入，win32 语义可在任意宿主上单测。
- */
-import { spawn as nodeSpawn } from 'node:child_process';
 import { agentStopperRegistry } from './agent-stopper.js';
+import { spawnProcess } from './spawn.js';
 /** 退出判定统一口径（红线）：exitCode !== null || signalCode !== null。 */
 function isAlive(proc) {
     return proc.exitCode === null && proc.signalCode === null;
@@ -36,7 +24,9 @@ async function defaultWaitForExit(proc, ms) {
     });
 }
 export function createWin32Terminator(deps) {
-    const spawnFn = deps.spawn ?? nodeSpawn;
+    // 默认走 platform/spawn.ts 单点收口：taskkill 是系统二进制，
+    // cross-spawn 在 win32 之外直通、在 win32 垫片场景下受控执行。
+    const spawnFn = deps.spawn ?? spawnProcess;
     const stoppers = deps.stoppers ?? agentStopperRegistry;
     const waitForExit = deps.waitForExit ?? defaultWaitForExit;
     const log = deps.log;

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 会丢弃
@@ -973,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;
@@ -1012,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' },
@@ -1203,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;
         }
@@ -1370,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;
         }
@@ -1417,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);
@@ -1743,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: '' },
         };
     }
     /**
@@ -2603,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}` };
         }
@@ -3197,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