lark-remote 0.5.14 → 0.5.16

package/CHANGELOG.md

@@ -5,6 +5,38 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.16] - 2026-11-01
+
+### 修复
+
+- **Claude / Pi 的「本 run」用量在多步回合下不再低报**：卡片「本 run」与 `/resume`、自动恢复卡、完成通知卡的 Input / Output 由会话文件兜底读取，此前这两个 agent 只取**最后一条 assistant 消息**，而一条消息等于一次模型请求——带工具往返的回合里显示的是最后一次请求的量，整轮消耗被系统性低估。现在汇总末个真人回合内的所有 assistant 消息；`Context` 仍是末次请求的窗口水位、`累计` 仍是会话总量，口径不变。没有真人输入的旧数据或截断文件退回末条采样，不会把整份会话当成一轮
+- **DSH 回合进行中的读数不再显示上一轮**：进程重启后的自动恢复与 `/resume`、没有活动用量时的中途读取、完成通知卡，此前优先取**上一个已结算回合**的数字（取值顺序与它自己的注释相反），当前回合已消耗的量被显示成上一轮。现在在途回合优先
+- **DSH 的 `Context` 不再虚高**：窗口水位此前把整回合的输出一路相加，而前几步的输出早已计入后续请求的输入，属重复计数；`Context` 始终以会话文件为准，于是终态卡的上下文占用行随回合变长而虚高、百分比一起失真。现在只取末次请求的输出
+- **Kimi / opencode 新回合刚开始时显示 0，不再显示上一轮残留**：回合已发出、模型还没产生任何用量采样的时刻，两个 reader 此前退回上一轮的最后一条记录，卡片把「刚开始的空回合」画成「刚结束那一轮」的消耗。现在按「末个回合」契约显示 0（`Context` 保留上一轮水位，因为窗口占用确实延续）；整份记录里没有回合标记的旧数据沿用原有语义
+- **`/compact` 收尾不再做无用功**：opencode 与 DSH 的会话读取给不出压缩次数，此前的重试把「这个 agent 没有该字段」当成「还没落盘」，每次压缩固定多跑两次完整导出 / 读取且永远等不到。现在 reader 显式声明能否产出压缩计数，声明不能的不再重试
+
+### 维护
+
+- **用量来源与 result 事件语义拆成两个字段**：原先一个字段同时承担「Input/Output 来自 live 还是会话文件」和「result 事件是否按 live 语义处理（启动前的 result 丢弃、会话指针写回）」，而 Kimi / opencode 的 live 通知只带上下文占用、没有输入输出拆分，却被迫声明成 live 来源。现在前者单独声明为会话文件，result 事件语义走新的声明位。无行为变化
+- **跨 agent 的用量口径断言集中到一处**：本 run / `Context` / 累计三条不变量原本每个 reader 各写一套期望值，容易把错误语义固化成测试基线；现在 Claude / Pi / DSH / Kimi / opencode 的回归用例共用同一组断言。无行为变化
+- **新增 token 用量口径文档**（中英文）：三个 scope 的硬不变量、live 与会话文件两条生产路径、同一低报问题反复复发的原因、六个 reader 各自的回合边界与 `Context` 公式，以及尚未落地的共享聚合器与子 agent 用量过滤缺口
+
+## [0.5.15] - 2026-10-31
+
+### 修复
+
+- **`/stop` 落在「刚发消息、卡片还没建好」的窗口里不再空跑整轮**：此前卡片已经定格成「已中断」，但 agent 进程还没起来、没有可杀的进程，`run()` 入口又会把停止标记重置回去，于是整轮照常跑完并继续改动工作区。现在卡片一旦进入终态就直接收口，不再启动 agent
+- **中断归因不再串台**：显式 `/stop` 不再被上一次遗留的粘性「审批超时」状态盖掉；在审批卡上点「取消」现在会如实归因成用户取消并由卡片透传，终态卡不再显示「审批超时」（该文案此前实际不可达）
+- **目标状态读不到时不再谎报「已完成」**：终态复核探测不到目标状态时显式标记为「未知」；投影里缺少目标域按「明确没有目标」处理，不会把普通会话误标成「目标未确认」
+- **opencode / kimi 卡片「本 run」token 低报或虚高**：ACP 的用量通知只带上下文占用与花费、没有输入输出拆分，这两个 agent 的卡片只能从会话文件兜底读取。opencode 取的是「最后一条 assistant 消息」而一条消息等于一次模型请求，实测一条 25 次请求的 run 卡片显示 Input 543 / Output 1,250，真实消耗是 20,040 / 10,358（相邻两张卡的「累计」差值反而对得上）；kimi 更直接把整条会话的总量当本 run。现在两个 reader 都汇总**末个 turn** 的采样：opencode 以它自带的 turn 结束标记为边界（文件停在回合中间时就是当前回合），kimi 以 `turn.prompt` 为边界；`Context` 仍是末次请求的窗口水位，`累计` 仍是会话总量，口径不变；没有 turn 标记的旧数据沿用原语义
+- **opencode 冷启动失败不再引导用户重启服务**：daemon 刚重启时模型目录还在加载，`/api/model` 会连续几分钟返 503，旧退避（0.5/1.5/3 秒）整段落在这个窗口里、四次重试无一命中，失败文案又叫用户 `opencode service restart`——重启只会清掉已热状态、重新进入同一个窗口。现在退避改为 0.5/2/8/20/45 秒（连每次请求自身约 10 秒超时，覆盖约 2 分钟窗口），重试耗尽后丢弃该工作目录的缓存连接、下一轮重新拉起 agent server，不再复用一个没激活的子进程；文案改成「冷启动/模型目录加载期间的临时状态，等 1–2 分钟重发」
+- **`/compact` 的卡片流启动失败时补发静态终态卡**，不再只剩一条「Compact 已触发」加一个表情；兜底的完成通知卡标题跟随真实终态
+- **收尾报文更如实**：区分「没收到结果」与「结果没落到卡片上」，不再用同一句话盖掉两种原因
+
+### 变更
+
+- run 终态卡文案更如实：目标被阻断 / 已暂停分别显示「目标被阻断」「目标已暂停」，不再统一写「已完成」；目标读取失败时标题写「完成（目标未确认）」、摘要首行同步；`goal_continuing` 的原消息表情由 Done 改为 OnIt；run 是否活跃改用统一的终态判据收口
+
 ## [0.5.14] - 2026-10-28
 
 ### 修复

package/dist/bridge/approval-coordinator.d.ts

@@ -37,6 +37,15 @@ export declare class ApprovalCoordinator {
     private approvals;
     /** 已提交过的 nonce（按 requestId）：同一按钮连点/飞书重投递只生效一次。 */
     private submittedNonces;
+    /**
+     * 用户是否在审批卡上主动点了「取消」。
+     *
+     * run 的终态归因需要它：cancel 在真实协议里是「停止等待」，agent 可能继续
+     * 跑，turn 结束时只剩一个泛化的 interrupted。桥据此把终态写成
+     * approval_cancelled，与 /stop（user_stop）、审批超时（approval_timeout）
+     * 区分开。仅在 responder 成功后置位——提交失败仍可重试。
+     */
+    private userCancelled;
     private readonly approvalTimeoutMs;
     private readonly responder;
     private readonly interruptTurn;
@@ -139,6 +148,10 @@ export declare class ApprovalCoordinator {
      * approvals must not be resurrected or rewritten.
      */
     updateView(requestId: number | string, view: ApprovalView): void;
+    /**
+     * 用户是否在审批卡上主动点了「取消」（终态归因用；提交失败不置位）。
+     */
+    get cancelledByUser(): boolean;
     /**
      * Get the number of pending approvals.
      */

package/dist/bridge/approval-coordinator.js

@@ -16,6 +16,15 @@ export class ApprovalCoordinator {
     approvals = new Map();
     /** 已提交过的 nonce（按 requestId）：同一按钮连点/飞书重投递只生效一次。 */
     submittedNonces = new Map();
+    /**
+     * 用户是否在审批卡上主动点了「取消」。
+     *
+     * run 的终态归因需要它：cancel 在真实协议里是「停止等待」，agent 可能继续
+     * 跑，turn 结束时只剩一个泛化的 interrupted。桥据此把终态写成
+     * approval_cancelled，与 /stop（user_stop）、审批超时（approval_timeout）
+     * 区分开。仅在 responder 成功后置位——提交失败仍可重试。
+     */
+    userCancelled = false;
     approvalTimeoutMs;
     responder;
     interruptTurn;
@@ -131,6 +140,9 @@ export class ApprovalCoordinator {
         try {
             await this.responder(ctx.requestId, effectiveAction);
             tracked.state = 'resolved';
+            // 终态归因：用户主动取消才置位（accept/decline 都是"继续本轮"）。
+            if (effectiveAction.action === 'cancel')
+                this.userCancelled = true;
             // nonce 在 responder 成功后才消费：失败可原按钮重试，
             // 不会被自己的 nonce 去重挡掉（失败后已回滚 pending 并重新计时）。
             this.consumeNonce(ctx.requestId, ctx.nonce);
@@ -301,6 +313,12 @@ export class ApprovalCoordinator {
             return;
         tracked.view = view;
     }
+    /**
+     * 用户是否在审批卡上主动点了「取消」（终态归因用；提交失败不置位）。
+     */
+    get cancelledByUser() {
+        return this.userCancelled;
+    }
     /**
      * Get the number of pending approvals.
      */

package/dist/bridge/index.js

@@ -50,10 +50,36 @@ const TERMINAL_REACTION_EMOJI = {
     error: 'ERROR',
     idle_timeout: 'Alarm',
     interrupted: 'SHHH',
+    // 本轮结束但目标继续：任务还没完，不能打 ✓（Done）。
+    goal_continuing: 'OnIt',
 };
 function terminalReactionEmoji(terminal) {
     return TERMINAL_REACTION_EMOJI[terminal] ?? 'Done';
 }
+/**
+ * 完成通知卡的标题 / 配色 / 结果行。
+ *
+ * 这张卡只在流式卡失败（settle==='unsent'）时补发，但终态必须如实反映：
+ * 写死「✅ 会话已完成」会把出错/中断的 run 报成成功。
+ */
+function completionNotificationPresentation(terminal) {
+    switch (terminal) {
+        case 'error':
+            return { title: '⚠️ 会话出错', template: 'red' };
+        case 'interrupted':
+            return { title: '⏹ 会话已中断', template: 'grey' };
+        case 'idle_timeout':
+            return { title: '⏱ 会话已超时', template: 'orange' };
+        case 'goal_continuing':
+            return { title: '⏳ 本轮结束，目标继续', template: 'orange' };
+        case 'finalizing':
+            return { title: '⏳ 会话仍在收尾', template: 'orange' };
+        case 'running':
+            return { title: '🔴 会话运行中', template: 'blue' };
+        case 'done':
+            return { title: '✅ 会话已完成', template: 'green', result: 'completed' };
+    }
+}
 /**
  * 单点化：`'runCompact' in runner` 鸭子探测
  * codex app-server + kimi/opencode ACP runner 满足。
@@ -1194,7 +1220,7 @@ export class Bridge {
      * @param dropFromCard 该 result 是陈旧重放，不得进卡片（调用方 continue 跳过 push）
      */
     observeResultEvent(event, opts) {
-        const { sawInit, usageAuthority, usage, writeback, runId } = opts;
+        const { sawInit, liveResultEvents, usage, writeback, runId } = opts;
         const preInitResult = !sawInit;
         const preInitTerminal = preInitResult && (event.subtype === 'error' || event.subtype === 'interrupted')
             ? {
@@ -1202,7 +1228,7 @@ export class Bridge {
                 errorMessage: event.errorMessage,
             }
             : undefined;
-        if (preInitResult && usageAuthority !== 'live') {
+        if (preInitResult && !liveResultEvents) {
             getLogger().info(`[lark-remote] pre-init result ignored (resume replay) runId=${runId}`);
             return { sawResult: false, dropFromCard: true, preInitTerminal };
         }
@@ -1210,11 +1236,11 @@ export class Bridge {
         getLogger().info(preInitResult
             ? `[lark-remote] pre-init result from live runner (app-server setup failure) runId=${runId}`
             : `[lark-remote] result event received runId=${runId}`);
-        // app-server 模式 setup 失败路径（thread/start 成功后 turn/start 失败）不会有
-        // turn_started 事件，store 不会写回新线程 id；runner 已在 result 里兜底上报。
-        // 仅当 runner 声明 live usage（app-server）且会话指针未动时写回，避免下条消息
-        // 再开一个孤儿线程。其余 agent 不在此列（各自有 system.init / turn_started 写回）。
-        if (usageAuthority === 'live')
+        // 连接型 runner 的 setup 失败路径（thread/start 成功后 turn/start 失败）
+        // 不会有 turn_started 事件，store 不会写回新线程 id；runner 已在 result 里
+        // 兜底上报。仅当 runner 声明 live result 语义且会话指针未动时写回，避免
+        // 下条消息再开一个孤儿线程。其余 agent 不在此列（各自有 init/turn_started 写回）。
+        if (liveResultEvents)
             writeBackResultSession(writeback, event.session_id);
         return { sawResult: !preInitResult, dropFromCard: false, preInitTerminal };
     }
@@ -1263,7 +1289,7 @@ export class Bridge {
      * 4) 已终态且未收到 result（如 spawn 失败后 interrupted）→ 无 usage 可补，跳过
      */
     async finishRunAfterStream(opts) {
-        const { cardSession, usage, sawResult, pendingPreInitTerminal, agentKind, runId } = opts;
+        const { cardSession, usage, sawResult, sawAnyResult, pendingPreInitTerminal, agentKind, runId, } = opts;
         const finalState = cardSession.currentState;
         if (finalState.terminal === 'finalizing') {
             // 三态终态映射（2026-08-14）：interrupted（审批超时/取消、/stop）是独立
@@ -1280,9 +1306,14 @@ export class Bridge {
                     : goalContinues
                         ? 'goal_continuing'
                         : 'done';
+            // 中断归因：用户主动取消审批（cancel）优先于"未归类"。用户 /stop 的
+            // 路径先置了终态（interrupted + user_stop），不会走到这里。
+            const approvalCancelled = terminal === 'interrupted' &&
+                this.approvalCoordinators.get(runId)?.cancelledByUser === true;
             await cardSession.finish(terminal, {
                 resultSubtype: subtype,
                 errorMsg: finalState.errorMsg,
+                ...(approvalCancelled ? { interruptedReason: 'approval_cancelled' } : {}),
                 ...usage.meta(),
             });
             return;
@@ -1300,7 +1331,13 @@ export class Bridge {
             else {
                 await cardSession.finish('error', {
                     ...usage.meta(),
-                    errorMsg: agentDisplayName(agentKind) + ' 输出流已结束，但未收到 result 事件',
+                    // sawAnyResult=true 说明 result 收到了、只是没能落到卡片（reducer 的
+                    // sessionId 守卫或 pre-init 守卫挡下）。报文不能再说"未收到 result
+                    // 事件"，否则排障会去查输出流而不是查守卫。
+                    errorMsg: agentDisplayName(agentKind) +
+                        (sawAnyResult
+                            ? ' 输出流已结束，但本轮结果未能落到卡片上'
+                            : ' 输出流已结束，但未收到 result 事件'),
                 });
             }
             return;
@@ -1316,12 +1353,17 @@ export class Bridge {
      * Handles idle watchdog, event processing, session sync, and state transitions.
      */
     async runAgentStreamToEnd(runner, cardSession, activeRun, sessionId, sessionEpochAtStart, ctx, cwd, runId, message, agentKind = this.config.defaultAgent) {
-        // Runner 声明的 usage 权威来源：codex app-server = 'live'
-        // （turn/started 的 tokenUsage.last 是本 turn 增量）。其余 runner 未声明。
+        // Runner 声明的 usage 权威来源：codex app-server / pi RPC = 'live'
+        // （live 带 input/output）；opencode/kimi ACP live 只有 context，声明
+        // 'jsonl'。result 事件的 live 语义（pre-init/写回）单独声明，不能和
+        // 用量来源共用一个字段。
         const usageAuthority = runner.getUsageAuthority?.();
+        const liveResultEvents = runner.usesLiveResultEvents?.() ?? usageAuthority === 'live';
         // §9.12 空闲看门狗：判定口径见 startIdleWatchdog；武装点在 cardSession.start() 之后。
         let watchdog = null;
         let sawResult = false;
+        /** 收到过任何 result（含被守卫丢弃/未进卡片的）：收尾报文据此措辞。 */
+        let sawAnyResult = false;
         // A runner can fail before emitting its synthetic system/init (e.g. DSH
         // session/create -> 401). The pre-init guard below drops that result to
         // protect Claude resume replay, but if the stream ends without ever seeing
@@ -1345,9 +1387,14 @@ export class Bridge {
                 // Card stream failed - continue with static fallback below, but ensure
                 // we don't silently fail if the fallback also fails (covered in catch below).
             }
-            if (cardSession.currentState.terminal !== 'running') {
-                // Card session did not enter running state - still try to send static fallback
-                getLogger().info(`[lark-remote] cardSession not running, using static fallback`);
+            // /stop（或队列「立即执行」的中断）可能落在建卡窗口内：卡片已定格为
+            // 终态，但 runner 还没开始跑，runner.stop() 也没有进程可杀——spawn 型
+            // 与连接型 runner 的 stop() 在 run() 之前都是空操作，且 run() 入口会
+            // 重置停止标记。必须在这里收口，否则用户看到「已中断」，agent 仍会把
+            // 这一轮跑完并改写工作区。finalizeRun 仍会照常收尾（settle / reaction）。
+            if (isRunTerminal(cardSession.currentState.terminal)) {
+                getLogger().info(`[lark-remote] card terminal before run start, skip runner runId=${runId} terminal=${cardSession.currentState.terminal}`);
+                return;
             }
             // 单 interval 看门狗。事件到来时只刷新时间戳（无 timer 操作）；
             // interval 周期检查静默时长，超时才 finish('idle_timeout') + stop()。
@@ -1409,7 +1456,7 @@ export class Bridge {
                 if (event.type === 'result') {
                     const outcome = this.observeResultEvent(event, {
                         sawInit,
-                        usageAuthority,
+                        liveResultEvents,
                         usage,
                         writeback,
                         runId,
@@ -1418,6 +1465,7 @@ export class Bridge {
                         pendingPreInitTerminal ??= outcome.preInitTerminal;
                     if (outcome.sawResult)
                         sawResult = true;
+                    sawAnyResult = true;
                     // 陈旧 result 不进卡片：run-state reducer 本来也会因 sessionId 未定而
                     // 跳过，在 bridge 层就拦掉可以省下一次无谓的 push + render。
                     if (outcome.dropFromCard) {
@@ -1464,6 +1512,7 @@ export class Bridge {
                 cardSession,
                 usage,
                 sawResult,
+                sawAnyResult,
                 pendingPreInitTerminal,
                 agentKind,
                 runId,
@@ -1561,7 +1610,7 @@ export class Bridge {
             // but NOT when streaming succeeded (card already shows completion).
             const sessionId = cardSession.currentState.sessionId;
             if (sessionId && runCardSent) {
-                await this.sendCompletionNotificationCard(sessionId, cwd, ctx, activeRun.agentKind);
+                await this.sendCompletionNotificationCard(sessionId, cwd, ctx, activeRun.agentKind, cardSession.currentState.terminal);
             }
             if (finalRender.finalAnswerStatus === 'overflow' && finalRender.finalAnswerText) {
                 await this.sendFinalAnswerOverflow(finalRender.finalAnswerText, ctx);
@@ -1609,7 +1658,8 @@ export class Bridge {
      * It's sent as a new message (not updating the run card) so users can easily
      * find and return to this session without scrolling up.
      */
-    async sendCompletionNotificationCard(sessionId, cwd, ctx, agentKind = this.config.defaultAgent) {
+    async sendCompletionNotificationCard(sessionId, cwd, ctx, agentKind = this.config.defaultAgent, terminal = 'done') {
+        const presentation = completionNotificationPresentation(terminal);
         try {
             // cap the events read for the notification card — without
             // maxEvents claude returns every event after the last user message and
@@ -1626,10 +1676,10 @@ export class Bridge {
             }, {
                 agentKind,
                 headerText: `📂 \`${cwd}\`\n会话: **${sessionId}**`,
-                title: '✅ 会话已完成',
-                usageResult: 'completed',
+                title: presentation.title,
+                ...(presentation.result ? { usageResult: presentation.result } : {}),
                 actions: [resumeUseButton(sessionId, agentKind)],
-                headerTemplate: 'green',
+                headerTemplate: presentation.template,
             });
             // send through sendResult so enforceCardBudget guards the card
             // (previously sent via connector directly, bypassing the budget — long
@@ -1861,14 +1911,15 @@ export class Bridge {
         }
         await this.sendResult({ text: '🗜 Compact 已触发，正在压缩会话…' }, ctx);
         const compactRunId = randomUUID();
+        // 渲染选项同时用于流式卡与「卡片流没建起来」时的静态兜底卡——两者必须
+        // 同门控，否则兜底卡会渲染出与本次 run 不一致的按钮。
+        const renderOptions = { agentKind };
         const cardSession = new RunCardSession({
             connector: this.connector,
             chatId: ctx.chatId,
             replyTo: ctx.messageId,
             runId: compactRunId,
-            renderOptions: {
-                agentKind,
-            },
+            renderOptions,
         });
         // 压缩与普通 run 共用同一套生命周期——注册进 activeRuns（/stop 有对象可停、
         // /active 看得见）、挂 §9.12 空闲看门狗、终态后补 reaction。缺任何一环，卡住的
@@ -1927,8 +1978,11 @@ export class Bridge {
             // 压缩结束后从会话 jsonl 读权威统计（压缩后上下文、压缩次数、本次压缩
             // token 消耗与会话累计）。thread/compacted 通知与 jsonl 落盘几乎同时
             // （实测差 ~9ms），compactCount 未读到则短重试，仍失败优雅降级（无统计）。
+            // 不支持 compactCount 的 reader（opencode/dsh）不重试——否则每次 compact
+            // 都会固定多跑两次完整 export/读取，且永远等不到该字段。
+            const compactCountSupported = this.sessionReaderRegistry.tryGet(agentKind)?.supportsCompactCount !== false;
             let finalUsage = resolveFinalUsage(this.sessionReaderRegistry, this.config.defaultAgent, sessionId, cwd, agentKind);
-            for (let attempt = 0; !finalUsage?.compactCount && attempt < 2; attempt++) {
+            for (let attempt = 0; compactCountSupported && !finalUsage?.compactCount && attempt < 2; attempt++) {
                 await sleep(150);
                 finalUsage = resolveFinalUsage(this.sessionReaderRegistry, this.config.defaultAgent, sessionId, cwd, agentKind);
             }
@@ -1955,6 +2009,15 @@ export class Bridge {
         }
         finally {
             watchdog?.stop();
+            // 与 run 路径同口径的降级：卡片流没建起来（start 失败 / stream 未收尾）时，
+            // 终态只存在于内存里。settle() 释放 producer 并等 stream 收尾；'unsent'
+            // 表示用户手里没有卡，必须补一张静态终态卡，否则只剩「Compact 已触发」
+            // 和一条 reaction，用户既不知道失败也不知道原因。
+            const settled = await cardSession.settle();
+            if (settled === 'unsent') {
+                const finalRender = renderRunCardDetailed(cardSession.currentState, renderOptions);
+                await this.sendResult({ card: finalRender.card }, ctx);
+            }
             // 只摘自己的槽位：/stop 可能已删掉本条并让排队的下一条占住同一 cwd。
             if (this.activeRuns.get(cwd) === activeRun) {
                 this.activeRuns.delete(cwd);

package/dist/bridge/run-usage.d.ts

@@ -28,5 +28,10 @@ export declare class RunUsageCollector {
     observeResult(event: ResultEvent): void;
     finalize(finalUsage: FinalUsageSnapshot | undefined, authority: UsageAuthority | undefined): void;
     meta(): UsageSnapshot;
+    /**
+     * 收尾探针。input/output 必须在这里出现：卡片"本 run"的这两个数来自
+     * `resolveFinalUsage`（ACP 的 live 层只有 context 占用、没有 input/output），
+     * 不带它们时日志无法区分"本 run 合计"与"末次请求"。
+     */
     logSummary(runId: string): string;
 }

package/dist/bridge/run-usage.js

@@ -79,9 +79,14 @@ export class RunUsageCollector {
     meta() {
         return this.resolved;
     }
+    /**
+     * 收尾探针。input/output 必须在这里出现：卡片"本 run"的这两个数来自
+     * `resolveFinalUsage`（ACP 的 live 层只有 context 占用、没有 input/output），
+     * 不带它们时日志无法区分"本 run 合计"与"末次请求"。
+     */
     logSummary(runId) {
         const meta = this.meta();
-        return `[lark-remote] final usage runId=${runId} contextLength=${meta.contextLength} contextLimit=${meta.contextLimit ?? 'undefined'} compactCount=${meta.compactCount ?? 'undefined'} cacheRead=${meta.cacheReadTokens ?? 'undefined'} cacheCreate=${meta.cacheCreationTokens ?? 'undefined'}`;
+        return `[lark-remote] final usage runId=${runId} contextLength=${meta.contextLength} contextLimit=${meta.contextLimit ?? 'undefined'} compactCount=${meta.compactCount ?? 'undefined'} input=${meta.inputTokens ?? 'undefined'} output=${meta.outputTokens ?? 'undefined'} cacheRead=${meta.cacheReadTokens ?? 'undefined'} cacheCreate=${meta.cacheCreationTokens ?? 'undefined'} total=${meta.totalTokens ?? 'undefined'}`;
     }
 }
 //# sourceMappingURL=run-usage.js.map

package/dist/card/run-renderer.js

@@ -1137,13 +1137,12 @@ function buildSummaryContent(state, options = {}) {
         }
     }
     else if (state.terminal === 'interrupted') {
-        // 审批超时（approval_expired 已标记）是「无人响应被自动取消」，不是用户
-        // 主动终止；如实展示原因，避免用户误判为 Agent 出错或自己操作过。
-        // 顶层 approvalExpired 优先：approval_resolved 会移除审批条目，但标记
-        // 必须活到终态渲染（2026-08-15 事故回归）。
+        // 中断来源三元：审批超时 / 用户取消审批 / 用户主动终止。
+        // 显式原因优先：approvalExpired 是粘性标记（cancel 语义下 agent 可能继续跑），
+        // 用户随后主动 /stop 时若仍按过期渲染，就把「我自己停的」误报成自动取消。
         const expiredApproval = state.interruptedReason === 'approval_timeout' ||
-            state.approvalExpired === true ||
-            (state.approvals ?? []).some((a) => a.expired);
+            (state.interruptedReason === undefined &&
+                (state.approvalExpired === true || (state.approvals ?? []).some((a) => a.expired)));
         elements.push(markdownDiv(expiredApproval
             ? '⏰ **审批超时未响应，已自动取消**'
             : state.interruptedReason === 'approval_cancelled'
@@ -1165,6 +1164,9 @@ function buildSummaryContent(state, options = {}) {
             : state.operationKind === 'compaction'
                 ? '\n\n🗜 Compact 完成'
                 : '\n\n（未返回内容）';
+        // goal 本 run 读不到（known=false）时不能写「已完成」：这是 GoalStateEvent
+        // 契约里明令禁止的推断（读不到 ≠ 没有目标）。run 本身成功，只是目标维度未知。
+        const goalUnknown = state.terminal === 'done' && state.goalKnown === false;
         // RunState 的用量字段就是 formatUsageStats 的入参形态（同为
         // `UsageSnapshot`）——原先这里逐字段抄了 17 行，加一个字段要同时改
         // RunState、FinishMeta 和这张清单（§9.21）。
@@ -1174,7 +1176,9 @@ function buildSummaryContent(state, options = {}) {
             // 本轮结束但目标继续：不能报"已完成"，也不能说"出错"。
             ...(state.terminal === 'goal_continuing'
                 ? { completedLabel: '⏳ 本轮结束 · 目标仍在继续' }
-                : {}),
+                : goalUnknown
+                    ? { completedLabel: '✅ 本轮完成 · 目标状态未确认' }
+                    : {}),
         });
         elements.push(markdownDiv(usageStatsStr + empty));
         // 后台任务：跨 turn 生命周期，必须显式告知并可逐个停止。
@@ -1302,7 +1306,17 @@ function headerTitle(state, options = {}) {
     if (state.terminal === 'goal_continuing')
         return `⏳ ${agent} · 本轮结束（目标继续）`;
     if (state.terminal === 'done') {
-        return state.goal?.phase === 'complete' ? `✅ ${agent} · 目标已完成` : `✅ ${agent} · 已完成`;
+        // goal 维度优先于「完成」：blocked/paused 不是任务做完了，complete 才是；
+        // 读不到（goalKnown=false）时也不能替宿主宣布完成。
+        if (state.goal?.phase === 'complete')
+            return `✅ ${agent} · 目标已完成`;
+        if (state.goal?.phase === 'blocked')
+            return `⛔ ${agent} · 目标被阻断`;
+        if (state.goal?.phase === 'paused')
+            return `⏸ ${agent} · 目标已暂停`;
+        if (state.goalKnown === false)
+            return `✅ ${agent} · 完成（目标未确认）`;
+        return `✅ ${agent} · 已完成`;
     }
     if (state.terminal === 'error')
         return `⚠️ ${agent} · 出错`;

package/dist/router/index.js

@@ -12,6 +12,7 @@ import { AGENT_KINDS, resolveAgentKind } from '../agent-kinds.js';
 import { getLogger } from '../logger/index.js';
 import { stripPlaceholders } from '../inbound/placeholder.js';
 import { clampInt } from '../common/clamp.js';
+import { isRunTerminal } from '../card/run-state.js';
 import { activeRunUsage } from './active-run-usage.js';
 import { markdownDiv, buildSessionHistoryCard, paginationBar, parseJumpOffset, SEARCH_INPUT_NAME, PAGE_JUMP_INVALID_HINT, } from '../card/card-helpers.js';
 import { MAX_FILE_UPLOAD_SIZE } from '../connector/file-limits.js';
@@ -2496,14 +2497,10 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
         }
         const { events, usage, aiTitle, recap, displayTitle } = reader.readSessionContent(sessionId, cwd, { maxEvents: opts?.maxEvents });
         const activeRun = this.bridge.getActiveRunFor(cwd);
-        // 只检查内存中的 activeRun 状态
-        // 只有当 activeRun 存在且不是终态时，才认为任务仍在进行中
+        // 只检查内存中的 activeRun 状态：存在且未收尾才算进行中。
+        // 终态集合取 run-state 的单源判据（新增终态时不会漏掉这一处）。
         const activeRunning = activeRun !== undefined &&
-            activeRun.terminal !== 'done' &&
-            activeRun.terminal !== 'error' &&
-            activeRun.terminal !== 'interrupted' &&
-            activeRun.terminal !== 'idle_timeout' &&
-            activeRun.terminal !== 'goal_continuing' &&
+            !isRunTerminal(activeRun.terminal) &&
             activeRun.sessionId === sessionId;
         const activeUsage = activeRunUsage(activeRun);
         return {

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

@@ -73,6 +73,22 @@ export declare abstract class BaseAcpRunner<TTranslator extends BaseAcpTranslato
      */
     protected abstract onCompactPromptFired(promptPromise: Promise<SessionPromptResult>, translator: TTranslator, sessionId: string, opts: SpawnOptions, baselineTotalCount: number): void;
     private withSessionSetupRetry;
+    /**
+     * 建立会话（session/new|resume），重试耗尽后丢弃该 cwd 缓存的连接。
+     *
+     * 「服务端未就绪」类错误（isRetryableSessionSetupError）说明这个 agent server
+     * 自身半死：opencode v2 的 location 在每轮拉起的 `opencode acp` 子进程里 boot，
+     * boot 期间后台服务不可用会让它长期停在未激活，后续轮次复用同一连接只会重复
+     * 失败——用户重启 opencode service 也治不好，因为连接缓存在本进程里
+     * （2026-10-30 现场：4 次重试全失败，重启服务与 lark-remote 都无效）。丢掉连接
+     * 后下一轮重新 spawn，拿到的是新进程的新状态。
+     *
+     * 只对声明为可重试的错误生效：kimi 等沿用默认 `isRetryableSessionSetupError`
+     * = false，行为不变（session id 不存在之类的确定性失败不踢连接）。
+     */
+    private setupSessionWithRetry;
+    /** Dispose the cached connection for `cwd`; never mask the setup error. */
+    private discardConnection;
     protected currentSessionId(): string | null;
     protected cancelCurrentTurn(): Promise<void>;
     protected clearTurnState(): void;

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

@@ -58,6 +58,40 @@ export class BaseAcpRunner extends ConnectionBasedRunner {
             }
         }
     }
+    /**
+     * 建立会话（session/new|resume），重试耗尽后丢弃该 cwd 缓存的连接。
+     *
+     * 「服务端未就绪」类错误（isRetryableSessionSetupError）说明这个 agent server
+     * 自身半死：opencode v2 的 location 在每轮拉起的 `opencode acp` 子进程里 boot，
+     * boot 期间后台服务不可用会让它长期停在未激活，后续轮次复用同一连接只会重复
+     * 失败——用户重启 opencode service 也治不好，因为连接缓存在本进程里
+     * （2026-10-30 现场：4 次重试全失败，重启服务与 lark-remote 都无效）。丢掉连接
+     * 后下一轮重新 spawn，拿到的是新进程的新状态。
+     *
+     * 只对声明为可重试的错误生效：kimi 等沿用默认 `isRetryableSessionSetupError`
+     * = false，行为不变（session id 不存在之类的确定性失败不踢连接）。
+     */
+    async setupSessionWithRetry(cwd, fn) {
+        try {
+            return await this.withSessionSetupRetry(fn);
+        }
+        catch (err) {
+            if (this.isRetryableSessionSetupError(err)) {
+                await this.discardConnection(cwd);
+            }
+            throw err;
+        }
+    }
+    /** Dispose the cached connection for `cwd`; never mask the setup error. */
+    async discardConnection(cwd) {
+        try {
+            await this.connectionManager.release(cwd);
+            getLogger().warn(`[${this.logTag}] dropped cached connection after session setup failure cwd=${cwd}`);
+        }
+        catch (err) {
+            getLogger().warn(`[${this.logTag}] failed to drop cached connection cwd=${cwd}: ${err.message}`);
+        }
+    }
     currentSessionId() {
         return this.activeSessionId;
     }
@@ -203,13 +237,13 @@ export class BaseAcpRunner extends ConnectionBasedRunner {
                 sessionId: opts.sessionId,
                 cwd: opts.cwd,
             };
-            const resumeResult = await this.withSessionSetupRetry(() => client.request('session/resume', resumeParams));
+            const resumeResult = await this.setupSessionWithRetry(opts.cwd, () => client.request('session/resume', resumeParams));
             this.onSessionEstablished(resumeResult);
             sessionId = opts.sessionId;
         }
         else {
             const newParams = { cwd: opts.cwd, mcpServers: [] };
-            const newResult = await this.withSessionSetupRetry(() => client.request('session/new', newParams));
+            const newResult = await this.setupSessionWithRetry(opts.cwd, () => client.request('session/new', newParams));
             this.onSessionEstablished(newResult);
             sessionId = newResult.sessionId;
         }
@@ -286,7 +320,7 @@ export class BaseAcpRunner extends ConnectionBasedRunner {
             // memory. On a reused connection the session is already loaded —
             // resume is idempotent and harmless.
             const resumeParams = { sessionId, cwd: opts.cwd };
-            const resumeResult = await this.withSessionSetupRetry(() => client.request('session/resume', resumeParams));
+            const resumeResult = await this.setupSessionWithRetry(opts.cwd, () => client.request('session/resume', resumeParams));
             this.onSessionEstablished(resumeResult);
             const translator = this.createTranslator();
             translator.setOperationKind('compact');

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

@@ -122,7 +122,9 @@ export declare abstract class ConnectionBasedRunner<TClient, TEvent = AgentEvent
      * One-way by design: an evicted instance never returns to the cache.
      */
     markOrphaned(): void;
-    getUsageAuthority(): 'live';
+    getUsageAuthority(): 'live' | 'jsonl';
+    /** 连接型 runner 的 result 事件都是 runner 自己产出的 live 语义。 */
+    usesLiveResultEvents(): boolean;
     killOrphan(): void;
     registerExitHandlers(): void;
     unregisterExitHandlers(): void;

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

@@ -221,6 +221,10 @@ export class ConnectionBasedRunner {
     getUsageAuthority() {
         return 'live';
     }
+    /** 连接型 runner 的 result 事件都是 runner 自己产出的 live 语义。 */
+    usesLiveResultEvents() {
+        return true;
+    }
     killOrphan() {
         // No-op: the connection is managed by ConnectionManager.
     }

package/dist/runner/dsh/client.js

@@ -430,6 +430,11 @@ export class DshClient {
         // 拿不到投影 = 宿主没这个会话的投影，不等于"没有 goal"。
         if (!snapshot)
             return { known: false, goal: null };
+        // 投影快照存在但没有 goal 域 = 宿主明确没有目标（未用过 goal 的会话就是这样）。
+        // 不能把缺失当成"读不懂"：goalFromProjection(undefined) 也返回 undefined，
+        // 那会把每次普通会话都误报成「目标状态未确认」。
+        if (!('goal' in snapshot.values))
+            return { known: true, goal: null };
         const parsed = goalFromProjection(snapshot.values.goal);
         if (parsed === undefined)
             return { known: false, goal: null };