lark-remote 0.5.3 → 0.5.5

package/CHANGELOG.md

@@ -5,6 +5,44 @@ 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.5] - 2026-10-18
+
+### 新增
+
+- **`/config` 卡片可以切换 DSH 的 provider**：新增 `agents.dsh.provider`。卡片里的 provider 下拉取自 DSH 的实时目录（打开卡片时强制刷新，在 DSH 侧新增 provider 后不必重启 lark-remote）。切换 provider 不清空会话，下一次运行用新 provider 重新对齐；显式配置的 provider 不可用时运行直接失败，不会静默改用别的 provider。模型留空时用该 provider 的默认模型
+- **DSH 支持压缩（Compact）**：运行卡片的压缩按钮对 DSH 生效，走 DSH 的命令通道、只在会话空闲时执行。按钮的渲染与执行改用同一份「该 agent 是否声明支持压缩」判据，不再出现能点下去但必然失败的按钮
+- **DSH 权限预设与飞书审批转发**：新增 `agents.dsh.permissionPreset`（沙箱模式 + 审批策略），在会话首次运行前用 `/permission` 对齐一次；DSH 不提供该命令时运行 fail closed，不会带着用户没选的权限继续跑。运行期间的审批请求渲染成卡片底部的「允许一次 / 拒绝」，允许只对当次调用生效；旧版 DSH 没有应答通道时回退为「请到 DSH Web UI 处理」，回合保持存活
+- **DSH 未运行时由 lark-remote 后台拉起**：探测不到 DSH Web Host 时自动以后台脱离方式启动 `dsh web`（默认最多等 30 秒端口就绪），lark-remote 退出或重启都不会停止它；已在运行则直接复用。设 `agents.dsh.manageProcess: false` 可改为只连接已在跑的实例，`dshHome` / `dshCommand` / `startTimeoutMs` 分别指定启动目录、可执行文件与等待上限
+
+### 变更
+
+- **DSH 凭据改为自动签发**：DSH 0.2.x 起接口要求认证。lark-remote 默认读取 DSH 的持久凭据文件（`$DSH_HOME/.credentials.yaml`，未设置 `DSH_HOME` 时为 `~/.dsh/.credentials.yaml`，文件权限必须是 `0600`），用其中的浏览器会话签名密钥现签一个短时效凭据，`dsh web` 重启后不需要再手动更新 token。`agents.dsh.token` 降级为凭据文件不可读时的 YAML 兜底，并且不再出现在 `/config` 卡片上——启动 token 每个进程随机生成、重启即换，写进飞书卡片既会过期又多余
+- **opencode 会话读取适配 2.0**：会话列表与历史改用 2.0 的导出结构（同时保留 1.x 的读法），工具执行结果按新形态解析
+- **DSH 配置卡片文案精简**：权限预设不再在卡片上堆长段说明
+
+### 修复
+
+- **第一条消息是图片/文件时不再被静默丢弃**：会话归属绑定只发生在文本消息入口，媒体入口此前只做只读检查。全新安装的用户第一条消息若是图片/文件，媒体下载被丢掉、绑定也永远完不成。现在文本与媒体走同一个授权入口
+- **点停止后执行位不再被卡住**：DSH 会接受 HTTP 连接但可能永不返回（卡住的模型请求），运行协程于是停在等待处，`/stop` 和空闲超时都腾不出该工作目录的执行位。请求加上默认 60 秒超时并可取消
+- **opencode 后台服务不可用时不再让卡片挂一小时**：2.0 的对话走共享后台进程，该进程不可用时以前没有任何提示，卡片要等完整的重试退避（约 1 小时）才结束。现在直接报错并给出 `opencode service restart` 的处置提示
+- **审批应答发送失败时保留重试入口**：连接断开或进程退出导致应答没送达时，卡片此前静默停在可点状态，用户以为已经批准。现在写明失败原因并保留原按钮重试（应答成功才消费该次审批的一次性标识）
+- **DSH「本 run」token 不再少算**：跑了多趟工具往返的回合只统计了最后一条用量，现在按回合汇总该回合内所有调用
+- **运行结束的使用量归属本轮自己的会话**：回合中途 `/new` / `/resume` / `/cd` 会移动全局会话指针，收尾按全局指针读取用量会把别的会话的 token 记到这条运行上
+- **中断后迟到的上一轮错误不再影响新一轮**：回合加了代际标识，回调落地前复核归属；同时清理了唤醒后遗留的兜底定时器，高频事件不再持续堆积
+- **替换连接时先等旧连接销毁完成**：不再让两个 agent 服务进程重叠，同一会话不会被两个进程同时持有；陈旧实例锁的接管改为「原子改名 + 复核」两步，中间不再可能被第三个进程插入
+- **恢复会话时不再错认前缀相同的会话 id**：文件名匹配从「包含子串」改为按 `<id>.jsonl` / `_<id>.jsonl` 结尾匹配，完整 id 的前缀或相似 id 不再命中；读取 DSH 会话内容也加上目录守卫，会话属于另一个工作目录时 fail closed
+- **思考过程不再被换行切碎**：同一条思考的增量按字拼接，此前每段增量都插一个换行
+
+## [0.5.4] - 2026-10-12
+
+### 修复
+
+- **codex「本 run」token 少算（多步运行只统计了最后一步）**：codex 每发起一次模型调用就记一条 token 用量，一个回合里有几趟工具往返就有几条，而运行结束卡片与 `/resume` 末尾统计此前只取最后一条。于是一个跑了 7 趟工具往返的回合，实际输出 3,648 个 token 只显示 679、未命中缓存的输入 3,022 只显示 212。现在按回合汇总该回合内所有调用的用量，与 codex 自己按回合统计的结果逐字段一致；「Context」仍显示最后一次调用的上下文窗口占用，累计用量与 `Total` 的取法不变。恢复会话时服务端可能重放上回合的用量，已按回合标识丢弃。更早的、不带回合标识的记录保持原读法
+
+### 变更
+
+- **测试注释与用例类型对齐**：一处用例注释改为不点名具体消息；两处 app-server 用例的类型写法与协议定义对齐（这些文件不在既有类型检查覆盖范围内，改动不影响运行时行为）。无行为变化
+
 ## [0.5.3] - 2026-10-12
 
 ### 修复

package/README.en.md

@@ -32,7 +32,7 @@ In approval mode (Claude, Codex, Kimi), an approval card arrives before a comman
 - OS: macOS / Linux / Windows 10+ (native Windows support is verified on real hardware, with behavior matching macOS/Linux)
 - Node.js 20+ ([Bun](https://bun.sh/) for development)
 - A Feishu custom app (either way): scan-to-create (a QR code pops up in the terminal on first launch; scan it with the Feishu app to create the app and write credentials automatically); or create one manually in the Open Platform — enable bot capability, subscribe to `im.message.receive_v1` and `card.action.trigger` via **long connection** (WebSocket, no public address needed), with at least the `im:message` scope.
-- Claude Code CLI installed locally and logged in once in a terminal (`claude` → browser OAuth). Same idea for other agents (codex / opencode / pi / kimi): install the corresponding CLI first. DSH connects to a local DSH Web Host via HTTP+WebSocket (no local subprocess), default address `http://127.0.0.1:3080`.
+- Claude Code CLI installed locally and logged in once in a terminal (`claude` → browser OAuth). Same idea for other agents (codex / opencode / pi / kimi): install the corresponding CLI first. DSH connects to a local DSH Web Host via HTTP+WebSocket (no local subprocess), default address `http://127.0.0.1:3080`. lark-remote reads `$DSH_HOME/.credentials.yaml` (default `~/.dsh/.credentials.yaml`) and mints short-lived cookies automatically, so a `dsh web` restart needs no manual token update; `agents.dsh.token` is only a fallback when that file is unavailable.
 
 ## Installation
 

package/README.md

@@ -32,7 +32,7 @@
 - 操作系统：macOS / Linux / Windows 10+（原生 Windows 支持已完成真机验证，行为与 macOS/Linux 对齐）
 - Node.js 20+（开发时用 [Bun](https://bun.sh/)）
 - 飞书自建应用（二选一）：扫码创建（首次启动终端弹二维码，飞书 App 扫码即自动创建并写入凭据）；或手动在开放平台建应用——开启机器人能力，订阅 `im.message.receive_v1` 和 `card.action.trigger`，订阅方式选「长连接」（WebSocket，无需公网地址），权限至少 `im:message`。
-- Claude Code CLI：本地安装并在终端完成一次登录（`claude` → 浏览器 OAuth）。使用其他 agent（codex / opencode / pi / kimi）同理，先装好对应 CLI；DSH 需本地 DSH Web Host 在跑（默认 `http://127.0.0.1:3080`），lark-remote 通过 HTTP+WebSocket 直连、不 spawn 本地子进程。
+- Claude Code CLI：本地安装并在终端完成一次登录（`claude` → 浏览器 OAuth）。使用其他 agent（codex / opencode / pi / kimi）同理，先装好对应 CLI；DSH 需本地安装 `dsh` CLI，lark-remote 会在 DSH Web Host 未运行时后台拉起它（默认 `http://127.0.0.1:3080`，lark-remote 退出不影响 DSH）。lark-remote 会读取 DSH 的 `$DSH_HOME/.credentials.yaml`（默认 `~/.dsh/.credentials.yaml`）自动签发短期 cookie，`dsh web` 重启后无需重新复制 token；`agents.dsh.token` 仅作为凭据文件不可用时的 YAML 兜底，不在 `/config` 卡片展示。
 
 ## 安装
 

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

@@ -18,6 +18,8 @@ export interface TrackedApproval {
     view: ApprovalView;
     createdAt: number;
     timeoutTimer: ReturnType<typeof setTimeout> | null;
+    /** 本次审批的超时窗口（ms）：响应失败回滚 pending 时按同一窗口重新计时。 */
+    timeoutMs: number;
     /** AskUserQuestion 已答问题索引 → 答案 label[]（kind === 'question'）。 */
     answers?: Map<number, string[]>;
     /** AskUserQuestion 补充说明（Codex user_note）：问题索引 → 文本。 */
@@ -144,8 +146,23 @@ export declare class ApprovalCoordinator {
     private clearTimer;
     /** 装超时计时器；先清掉旧的，保证一个 requestId 最多只有一条待触发的计时。 */
     private armTimeout;
-    /** nonce 去重：同一 nonce 只允许生效一次（防连点/飞书重投递）。 */
+    /**
+     * nonce 去重（只校验不消费）：同一 nonce 已生效过则拒绝。
+     * 提交类操作在 responder 成功后才 `consumeNonce`，失败可原样重试。
+     */
     private assertFreshNonce;
+    /** 标记 nonce 已生效（同一按钮连点/飞书重投递只允许一次）。 */
+    private consumeNonce;
+    /** 校验并立即消费 nonce（切换/回显类操作：本身幂等，重复投递只生效一次）。 */
+    private assertAndConsumeNonce;
+    /** 清掉失败提示（重试或新视图到达时）。 */
+    private clearDeliveryError;
+    /**
+     * 响应发送失败：状态回滚 pending、卡片写失败原因并重新计时，允许用户重试。
+     * 不回滚成 failed——failed 会让后续点击永远报 "no longer pending"，
+     * 用户看到失败却没有任何重试入口。
+     */
+    private failSubmission;
     /** 记录问题答案到 tracked.answers（懒初始化 Map）。 */
     private recordAnswer;
     private getPendingQuestion;

package/dist/bridge/approval-coordinator.js

@@ -39,6 +39,7 @@ export class ApprovalCoordinator {
             // Already tracked — update state
             existing.state = 'pending';
             existing.view = event.view;
+            existing.timeoutMs = timeoutMs;
             // 重投必须重新计时：上一路的计时器在 resolved/expired 时已清掉，不重装
             // 这条审批就永不过期，server 只能无限等待（红线「审批超时自动 cancel」）。
             this.armTimeout(existing, timeoutMs);
@@ -51,6 +52,7 @@ export class ApprovalCoordinator {
             view: event.view,
             createdAt: Date.now(),
             timeoutTimer: null,
+            timeoutMs,
         };
         this.approvals.set(event.requestId, tracked);
         this.armTimeout(tracked, timeoutMs);
@@ -123,17 +125,25 @@ export class ApprovalCoordinator {
         // Atomic state transition: pending → submitting（同步，无 await）
         tracked.state = 'submitting';
         this.clearTimer(tracked);
+        // 重新提交时清掉上一次的失败提示（视图会随本次结果重渲染）。
+        this.clearDeliveryError(tracked);
         // Send response via the responder
         try {
             await this.responder(ctx.requestId, effectiveAction);
             tracked.state = 'resolved';
+            // nonce 在 responder 成功后才消费：失败可原按钮重试，
+            // 不会被自己的 nonce 去重挡掉（失败后已回滚 pending 并重新计时）。
+            this.consumeNonce(ctx.requestId, ctx.nonce);
             // 提交成功后立即从卡片移除审批区（agent 无关）：claude 控制协议没有
             // resolved 回发，不推就会「已点允许按钮仍在」残留 UI；codex 的 server
             // 稍后也会发 approval_resolved，reducer 按 requestId 过滤幂等。
             this.pushResolved(ctx.requestId);
         }
-        catch {
-            tracked.state = 'failed';
+        catch (err) {
+            // 响应失败必须向上抛（router 据此返回 error toast，而不是骗用户「已提交」），
+            // 并把失败原因写回卡片；状态回滚 pending + 重新装超时计时器，允许重试。
+            this.failSubmission(tracked, err);
+            throw err instanceof Error ? err : new Error(String(err));
         }
     }
     /**
@@ -183,7 +193,7 @@ export class ApprovalCoordinator {
             // 多选切换按钮同一 nonce 重复投递（双击/飞书重投递）只应
             // toggle 一次，否则勾选会被二次 toggle 抵消。单选用例的重复防护在
             // respondQuestionAnswers（提交即幂等，选中是 set 语义）。
-            this.assertFreshNonce(ctx.requestId, ctx.nonce);
+            this.assertAndConsumeNonce(ctx.requestId, ctx.nonce);
             if (selected.has(action.option)) {
                 selected.delete(action.option);
             }
@@ -266,7 +276,7 @@ export class ApprovalCoordinator {
         if (!text) {
             throw new Error('请输入补充说明');
         }
-        this.assertFreshNonce(ctx.requestId, ctx.nonce);
+        this.assertAndConsumeNonce(ctx.requestId, ctx.nonce);
         tracked.notes ??= new Map();
         tracked.notes.set(action.questionIndex, text);
         q.note = text;
@@ -295,7 +305,7 @@ export class ApprovalCoordinator {
         if (!text) {
             throw new Error('请输入修改意见');
         }
-        this.assertFreshNonce(ctx.requestId, ctx.nonce);
+        this.assertAndConsumeNonce(ctx.requestId, ctx.nonce);
         tracked.feedback = text;
         tracked.view.planFeedback = text;
         this.pushApprovalViewUpdate(ctx.requestId, tracked);
@@ -338,17 +348,50 @@ export class ApprovalCoordinator {
             this.expireApproval(tracked.requestId);
         }, timeoutMs);
     }
-    /** nonce 去重：同一 nonce 只允许生效一次（防连点/飞书重投递）。 */
+    /**
+     * nonce 去重（只校验不消费）：同一 nonce 已生效过则拒绝。
+     * 提交类操作在 responder 成功后才 `consumeNonce`，失败可原样重试。
+     */
     assertFreshNonce(requestId, nonce) {
         if (nonce === undefined)
             return;
-        const seen = this.submittedNonces.get(requestId) ?? new Set();
-        if (seen.has(nonce)) {
+        const seen = this.submittedNonces.get(requestId);
+        if (seen?.has(nonce)) {
             throw new Error(`Approval request ${requestId} already submitted (duplicate nonce)`);
         }
+    }
+    /** 标记 nonce 已生效（同一按钮连点/飞书重投递只允许一次）。 */
+    consumeNonce(requestId, nonce) {
+        if (nonce === undefined)
+            return;
+        const seen = this.submittedNonces.get(requestId) ?? new Set();
         seen.add(nonce);
         this.submittedNonces.set(requestId, seen);
     }
+    /** 校验并立即消费 nonce（切换/回显类操作：本身幂等，重复投递只生效一次）。 */
+    assertAndConsumeNonce(requestId, nonce) {
+        this.assertFreshNonce(requestId, nonce);
+        this.consumeNonce(requestId, nonce);
+    }
+    /** 清掉失败提示（重试或新视图到达时）。 */
+    clearDeliveryError(tracked) {
+        if (tracked.view.deliveryError === undefined)
+            return;
+        const { deliveryError: _deliveryError, ...view } = tracked.view;
+        tracked.view = view;
+    }
+    /**
+     * 响应发送失败：状态回滚 pending、卡片写失败原因并重新计时，允许用户重试。
+     * 不回滚成 failed——failed 会让后续点击永远报 "no longer pending"，
+     * 用户看到失败却没有任何重试入口。
+     */
+    failSubmission(tracked, err) {
+        const message = err instanceof Error ? err.message : String(err);
+        tracked.state = 'pending';
+        tracked.view = { ...tracked.view, deliveryError: message };
+        this.armTimeout(tracked, tracked.timeoutMs);
+        this.pushApprovalViewUpdate(tracked.requestId, tracked);
+    }
     /** 记录问题答案到 tracked.answers（懒初始化 Map）。 */
     recordAnswer(tracked, questionIndex, values) {
         tracked.answers ??= new Map();
@@ -413,6 +456,7 @@ export class ApprovalCoordinator {
         }
         tracked.state = 'submitting';
         this.clearTimer(tracked);
+        this.clearDeliveryError(tracked);
         try {
             await this.responder(ctx.requestId, {
                 action: 'answer',
@@ -420,10 +464,13 @@ export class ApprovalCoordinator {
                 ...(Object.keys(notes).length > 0 ? { notes } : {}),
             });
             tracked.state = 'resolved';
+            this.consumeNonce(ctx.requestId, ctx.nonce);
             this.pushResolved(ctx.requestId);
         }
-        catch {
-            tracked.state = 'failed';
+        catch (err) {
+            // 与 submit 同口径：失败上抛（router error toast）+ 卡片失败视图 + 可重试。
+            this.failSubmission(tracked, err);
+            throw err instanceof Error ? err : new Error(String(err));
         }
     }
     /** 推 approval_resolved 到卡片（移除审批区；幂等，失败仅记日志）。 */

package/dist/bridge/index.js

@@ -11,7 +11,7 @@ import { agentDisplayName, resumeUseButton } from '../card/card-shared.js';
 import { enforceCardBudget } from '../card/card-budget.js';
 import { normalizeResultUsage } from '../runner/common/result-usage.js';
 import { BashProcessRunner } from '../runner/index.js';
-import { AGENT_KINDS } from '../runner/types.js';
+import { AGENT_KINDS, supportsCompact } from '../runner/types.js';
 import { QueueManager, } from './queue-manager.js';
 import { ApprovalCoordinator, decisionToApprovalAction } from './approval-coordinator.js';
 import { InboundMediaHandler } from './inbound-media.js';
@@ -57,6 +57,27 @@ function terminalReactionEmoji(terminal) {
 function runnerHasRunCompact(runner) {
     return ('runCompact' in runner && typeof runner.runCompact === 'function');
 }
+/**
+ * 已告警过的能力不一致 kind。能力表（`COMPACT_CAPABILITY`）是声明，runner 方法
+ * 是实现；两者不一致是开发期缺陷，只在首次冲突时打 error，避免每次渲染刷屏。
+ */
+const compactMismatchWarned = new Set();
+/**
+ * Compact 能力的双重门控：声明的能力表 && runner 实际实现。
+ *
+ * 只做鸭子探测会把「漏实现」降级成静默隐藏按钮（dsh 就这样漏了），所以声明表
+ * 是必需项；只信声明表则可能渲染出点不动的死按钮，所以实现检查也保留。两者
+ * 不一致时打 error 日志，让缺陷在运行日志里可见。
+ */
+function runnerSupportsCompact(runner, kind) {
+    const declared = supportsCompact(kind);
+    const implemented = runnerHasRunCompact(runner);
+    if (declared !== implemented && !compactMismatchWarned.has(kind)) {
+        compactMismatchWarned.add(kind);
+        getLogger().error(`[lark-remote] compact capability mismatch kind=${kind} declared=${declared} implemented=${implemented}`);
+    }
+    return declared && implemented;
+}
 /**
  * 每个 cwd 保留的「可压缩 run」条数上限。Compact 按钮挂在终态 run 卡片上，
  * 卡片会被后续消息不断顶上去；无上限会让长跑进程随 run 数无界增长，而用户
@@ -250,6 +271,12 @@ export class Bridge {
                     return undefined;
                 return { mode: opencodeConfig.mode };
             }
+            case 'dsh': {
+                const dshConfig = agents?.dsh;
+                if (!dshConfig)
+                    return undefined;
+                return { permissionPreset: dshConfig.permissionPreset };
+            }
             default:
                 return undefined;
         }
@@ -265,7 +292,7 @@ export class Bridge {
      */
     hasRunCompact(cwd, kind = this.config.defaultAgent) {
         const runner = this.getRunner(cwd, kind);
-        return runnerHasRunCompact(runner);
+        return runnerSupportsCompact(runner, kind);
     }
     /** 入队时刻快照：当前 defaultAgent + 该 agent 的 sessionId（无 session 则 undefined）。
      *  唯一捕获点：排队消息在入队时刻把 agent+session 钉进 AgentBinding，随任务闭包带到执行时刻
@@ -816,9 +843,15 @@ export class Bridge {
         // Step 1: Create run session (runId, cardSession, activeRun tracking)
         const { runId, cardSession, activeRun } = this.createRunSession(ctx, cwd, runner, agentKind);
         // Step 2: Consume the agent stream (runner.run loop, event processing, state updates)
-        await this.runAgentStreamToEnd(runner, cardSession, sessionId, sessionEpochAtStart, ctx, cwd, runId, message, agentKind);
-        // Step 3: Finalize the run (error handling, fallback card, completion notification, cleanup)
-        await this.finalizeRun(cardSession, activeRun, ctx, cwd);
+        // 兜底：run 消费阶段任何异常都必须仍走 finalizeRun 释放 activeRuns 槽位，
+        // 否则该 cwd 永久 busy（后续消息被 busy-drop，只能手动 /stop）。
+        try {
+            await this.runAgentStreamToEnd(runner, cardSession, activeRun, sessionId, sessionEpochAtStart, ctx, cwd, runId, message, agentKind);
+        }
+        finally {
+            // Step 3: Finalize the run (error handling, fallback card, completion notification, cleanup)
+            await this.finalizeRun(cardSession, activeRun, ctx, cwd);
+        }
     }
     /**
      * Step 1 of forwardToClaude: Create run session components.
@@ -904,13 +937,19 @@ export class Bridge {
      * Step 2 of forwardToClaude: Run the agent and consume its event stream.
      * Handles idle watchdog, event processing, session sync, and state transitions.
      */
-    async runAgentStreamToEnd(runner, cardSession, sessionId, sessionEpochAtStart, ctx, cwd, runId, message, agentKind = this.config.defaultAgent) {
+    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 未声明。
         const usageAuthority = runner.getUsageAuthority?.();
         // §9.12 空闲看门狗：判定口径见 startIdleWatchdog；武装点在 cardSession.start() 之后。
         let watchdog = null;
         let sawResult = 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
+        // init the result was the only terminal signal we had. Keep it so the card
+        // shows the real error instead of the generic "no result" fallback.
+        let pendingPreInitTerminal;
         // 记录 result 是否为 error: error 时跳过 jsonl usage 读取 (见 stream end 处说明)
         let resultNotSuccess = false;
         // Final usage read from jsonl after the run completes. live stream-json does
@@ -1012,6 +1051,9 @@ export class Bridge {
                 }
                 if (event.type === 'system' && event.subtype === 'init') {
                     sawInit = true;
+                    // 本轮真实使用的 session（不可变身份）：指针在 run 中被 /new 等移动时，
+                    // 结束后的 usage 读取仍以它为准。
+                    activeRun.sessionId = event.session_id;
                     // 代际守卫：run 在途时 /new（或 new-session 卡片、/cd、/resume、
                     // /config 切换）移动了 session 指针，此 init 的写回是 stale 的——
                     // 跳过，否则 /new 的清空会被在途 run 静默撤销（2026-08-09 事故：
@@ -1047,6 +1089,8 @@ export class Bridge {
                     // （§9.22 守卫前提），此处 turn_started 写回保留为双保险：两者都用
                     // threadId 写回 sessionId（代际守卫一致），幂等。缺失会导致每次消息
                     // 都新建线程（thread/start 而非 thread/resume），会话无法延续。
+                    // init 缺失时以 threadId 作为本轮身份兜底。
+                    activeRun.sessionId ??= event.threadId;
                     const pointerMoved = this.sessionStore.getSessionEpoch(ctx.userId, agentKind) !== sessionEpochAtStart;
                     if (!pointerMoved) {
                         this.sessionStore.setSessionIdAndCwd(ctx.userId, agentKind, event.threadId, cwd);
@@ -1078,6 +1122,12 @@ export class Bridge {
                     const preInitResult = !sawInit;
                     if (preInitResult && usageAuthority !== 'live') {
                         getLogger().info(`[lark-remote] pre-init result ignored (resume replay) runId=${runId}`);
+                        if (event.subtype === 'error' || event.subtype === 'interrupted') {
+                            pendingPreInitTerminal ??= {
+                                subtype: event.subtype,
+                                errorMessage: event.errorMessage,
+                            };
+                        }
                         // Still reset idle timer — the CLI is alive and producing events.
                         watchdog?.touch();
                         // Do NOT push to cardSession: the run-state reducer would also
@@ -1085,6 +1135,12 @@ export class Bridge {
                         // layer avoids the push + render overhead for a no-op event.
                         continue;
                     }
+                    if (preInitResult && (event.subtype === 'error' || event.subtype === 'interrupted')) {
+                        pendingPreInitTerminal ??= {
+                            subtype: event.subtype,
+                            errorMessage: event.errorMessage,
+                        };
+                    }
                     if (!preInitResult) {
                         sawResult = true;
                     }
@@ -1204,7 +1260,11 @@ export class Bridge {
             // 但 result=error 时跳过: 进程可能立即退出未写新 usage (如 kimi 0.26+ 拒绝 -p+--auto
             // 立即 exit=1), 此时 jsonl 里是上一次成功 turn 的历史 usage, 会被误当作本次 usage 显示,
             // 误导用户以为本次出错的请求也消耗了 token。error 时只用 live 捕获的 usage (若有)。
-            const finalSessionId = this.sessionStore.getSessionId(ctx.userId, agentKind);
+            // 本轮使用的 session：run 期间 /new //resume //cd 会移动全局
+            // 指针，结束时再读 store 会把别条会话的 token/context 显示到这张卡上。
+            // 优先级：卡片状态（本轮 init 写入）→ activeRun（本轮 init/turn_started）
+            // → 本轮开始时捕获的 sessionId。三者都没有就跳过 usage，绝不回读全局指针。
+            const finalSessionId = cardSession.currentState.sessionId ?? activeRun.sessionId ?? sessionId;
             const finalUsage = resultNotSuccess
                 ? undefined
                 : resolveFinalUsage(this.sessionReaderRegistry, this.config.defaultAgent, finalSessionId, cwd, agentKind);
@@ -1262,10 +1322,21 @@ export class Bridge {
                 });
             }
             else if (finalState.terminal === 'running') {
-                await cardSession.finish('error', {
-                    ...usageMeta(),
-                    errorMsg: agentDisplayName(agentKind) + ' 输出流已结束，但未收到 result 事件',
-                });
+                if (pendingPreInitTerminal) {
+                    const terminal = pendingPreInitTerminal.subtype === 'interrupted' ? 'interrupted' : 'error';
+                    getLogger().warn(`[lark-remote] stream ended without init; using pre-init ${terminal} result runId=${runId} error=${pendingPreInitTerminal.errorMessage ?? '(none)'}`);
+                    await cardSession.finish(terminal, {
+                        ...usageMeta(),
+                        errorMsg: pendingPreInitTerminal.errorMessage ??
+                            agentDisplayName(agentKind) + (terminal === 'interrupted' ? ' 已中断' : ' 启动失败'),
+                    });
+                }
+                else {
+                    await cardSession.finish('error', {
+                        ...usageMeta(),
+                        errorMsg: agentDisplayName(agentKind) + ' 输出流已结束，但未收到 result 事件',
+                    });
+                }
             }
             else if (sawResult) {
                 // 已终态（interrupted/idle_timeout）+ result 已收到：首终态优先，
@@ -1391,7 +1462,7 @@ export class Bridge {
                 // 写入条件从「codex 终态」放宽为「runner 有 runCompact 的终态」
                 // （codex app-server + kimi acp 均满足）。
                 const runTerminal = cardSession.currentState.terminal;
-                const runnerHasCompact = runnerHasRunCompact(activeRun.runner);
+                const runnerHasCompact = runnerSupportsCompact(activeRun.runner, activeRun.agentKind);
                 if (runnerHasCompact &&
                     activeRun.runner.lifetime === 'workspace' &&
                     (runTerminal === 'done' ||
@@ -1609,9 +1680,9 @@ export class Bridge {
         if (await this.rejectIfCompactionInFlight(target.sessionId, cwd, target.agentKind, ctx)) {
             return;
         }
-        // Check that the runner has runCompact method
+        // Check that the runner has runCompact method（声明表 && runner 实现）
         const runner = this.getRunner(cwd, target.agentKind);
-        if (!runnerHasRunCompact(runner)) {
+        if (!runnerSupportsCompact(runner, target.agentKind)) {
             await this.sendResult({ text: '⚠️ 当前运行模式不支持 Compact' }, ctx);
             return;
         }
@@ -1670,7 +1741,8 @@ export class Bridge {
         log.info(`[lark-remote] streamCompact sessionId=${sessionId} cwd=${cwd}`);
         // 防御性能力检查：调用方已校验（runId / resume 两条路径），此处双保险并
         // 让 TS 收窄 runner 类型（'runCompact' in runner 之后的 cast 才合法）。
-        if (!('runCompact' in runner) ||
+        if (!runnerSupportsCompact(runner, agentKind) ||
+            !('runCompact' in runner) ||
             typeof runner.runCompact !== 'function') {
             await this.sendResult({ text: '⚠️ 当前运行模式不支持 Compact' }, ctx);
             return;
@@ -1855,9 +1927,10 @@ export class Bridge {
         // §5.3: kimi 压缩在途检测（与 handleCompactAction 同一入口）。
         if (await this.rejectIfCompactionInFlight(sessionId, cwd, agentKind, ctx))
             return;
-        // Check that the runner has runCompact（codex/kimi/opencode/pi/claude 鸭子探测）。
+        // Check that the runner has runCompact（声明表 && runner 实现；
+        // codex/kimi/opencode/pi/claude/dsh 均已实现）。
         const runner = this.getRunner(cwd, agentKind);
-        if (!runnerHasRunCompact(runner)) {
+        if (!runnerSupportsCompact(runner, agentKind)) {
             await this.sendResult({ text: '⚠️ 当前运行模式不支持 Compact' }, ctx);
             return;
         }

package/dist/card/approval-render.js

@@ -44,6 +44,13 @@ export function renderApprovalArea(approval, opts) {
         return [];
     }
     const elements = [];
+    if (approval.note) {
+        const neutralized = approval.note.replace(/`/g, '·');
+        elements.push({
+            tag: 'div',
+            text: { tag: 'lark_md', content: `ℹ️ ${neutralized}` },
+        });
+    }
     if (approval.kind === 'command') {
         elements.push(...renderCommandApproval(approval, opts?.expired, opts?.runId));
     }
@@ -59,6 +66,17 @@ export function renderApprovalArea(approval, opts) {
     else if (approval.kind === 'question') {
         elements.push(...renderQuestionApproval(approval, opts?.expired, opts?.runId));
     }
+    // 响应发送失败：明确告知原因 + 可重试，而不是静默停在可点状态。
+    if (approval.deliveryError) {
+        const neutralized = approval.deliveryError.replace(/`/g, '·');
+        elements.push({
+            tag: 'div',
+            text: {
+                tag: 'lark_md',
+                content: `⚠️ **审批提交失败**：${neutralized}\n可直接再次点击按钮重试。`,
+            },
+        });
+    }
     return elements;
 }
 /**

package/dist/card/run-state.js

@@ -327,21 +327,26 @@ function reduceAssistantEvent(state, event) {
     let next = state;
     for (const content of event.message.content) {
         if (content.type === 'thinking') {
+            // 增量通道语义：chunk 边界是传输事实，不是文档结构。同一 itemId 的连续
+            // 内容是同一块的增量，逐字拼接；itemId 变化才开新块。不能用 '\n' 表示
+            // “来了新 delta”——DSH/opencode 的 reasoning delta 是 token 粒度。
             const last = next.blocks[next.blocks.length - 1];
-            const newBlocks = last?.kind === 'thinking'
+            const prev = last?.kind === 'thinking' ? last : undefined;
+            const sameItem = prev !== undefined && prev.itemId === content.itemId;
+            const newBlocks = sameItem
                 ? [
                     ...next.blocks.slice(0, -1),
                     {
-                        kind: 'thinking',
-                        content: keepTailMarked(last.content + '\n' + content.thinking, MAX_REASONING_CHARS),
+                        ...prev,
+                        content: keepTailMarked(prev.content + content.thinking, MAX_REASONING_CHARS),
                         active: true,
-                        timestamp: last.timestamp ?? event.timestamp,
                     },
                 ]
                 : [
-                    ...next.blocks,
+                    ...markThinkingInactive(next.blocks),
                     {
                         kind: 'thinking',
+                        ...(content.itemId !== undefined ? { itemId: content.itemId } : {}),
                         content: keepTailMarked(content.thinking, MAX_REASONING_CHARS),
                         active: true,
                         timestamp: event.timestamp,

package/dist/config/index.d.ts

@@ -134,7 +134,15 @@ export declare const DEFAULT_DSH_HOST = "http://127.0.0.1:3080";
 /** DSH (DeepSeek Harness) Web Host connection config. */
 declare const DshConfigSchema: z.ZodObject<{
     host: z.ZodDefault<z.ZodString>;
+    manageProcess: z.ZodDefault<z.ZodBoolean>;
+    dshHome: z.ZodOptional<z.ZodString>;
+    dshCommand: z.ZodOptional<z.ZodString>;
+    startTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    token: z.ZodOptional<z.ZodString>;
+    credentialsFile: z.ZodOptional<z.ZodString>;
     agentPreset: z.ZodOptional<z.ZodString>;
+    permissionPreset: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodString>;
     model: z.ZodOptional<z.ZodString>;
     reasoningEffort: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
@@ -235,7 +243,15 @@ export declare const AppConfigSchema: z.ZodObject<{
         }, z.core.$strip>>;
         dsh: z.ZodOptional<z.ZodObject<{
             host: z.ZodDefault<z.ZodString>;
+            manageProcess: z.ZodDefault<z.ZodBoolean>;
+            dshHome: z.ZodOptional<z.ZodString>;
+            dshCommand: z.ZodOptional<z.ZodString>;
+            startTimeoutMs: z.ZodDefault<z.ZodNumber>;
+            token: z.ZodOptional<z.ZodString>;
+            credentialsFile: z.ZodOptional<z.ZodString>;
             agentPreset: z.ZodOptional<z.ZodString>;
+            permissionPreset: z.ZodOptional<z.ZodString>;
+            provider: z.ZodOptional<z.ZodString>;
             model: z.ZodOptional<z.ZodString>;
             reasoningEffort: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;