lark-remote 0.5.9 → 0.5.12

package/CHANGELOG.md

@@ -5,6 +5,55 @@ 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.12] - 2026-10-24
+
+### 修复
+
+- **Bash 工具结果不再偶发丢失**：kimi 的终端子进程退出后，runner 会等 stdout 尾部 flush（最多 200ms）再推 Bash 输出；但 `terminal/wait_for_exit` 此前在 flush 之前就返回，服务端拿到响应后立即 release 并结束回合，回合结果可能先于延迟推送的 tool_result 到达，卡片上的 Bash 面板变成空输出。现在 wait_for_exit 在 tool_result 入队后才返回，保证输出先于回合结束送达
+
+### 维护
+
+- **测试同步原语收紧**：pid 文件改为等完整内容再读（避免读到空串后把 0 当 PID 轮询进程组）；kimi 压缩完成用例改由 mock server 在收到 prompt 后延迟落记录，消除并行负载下的假红。无行为变化
+
+## [0.5.11] - 2026-10-24
+
+### 修复
+
+- **审批卡在超长或超量输入下不再整卡消失**：审批理由、题面、选项、文件变更等 agent 产出的文本此前没有上限，一条超长理由（实测 3 万字符）或 8 题 × 5 选项就能把卡片顶出字节/元素预算，被飞书整卡拒收——审批彻底不可见，回合只能挂到超时。现在自由文本按字节截断、题数/选项/变更条目按渲染上限折叠，最底层兜底卡改用紧凑审批区：审批按钮在任何降级档都保留
+- **停止 bash 任务后卡片稳定显示「已手动终止」**：停止路径与自然收尾会并发写同一张卡的终态，后写者胜出；现在首个终态胜出，不再被随后的「执行失败」覆盖
+- **内容审核截断后的自动续跑接回本轮会话**：续跑此前用入队时的会话快照，新会话第一条消息被截断时会落到一个全新的空会话，本轮上下文全部丢失；现在按卡片状态 → 运行中会话 → 起点快照三级取本轮实际使用的会话
+- **DSH 停止后残留的排队 prompt 不再被下一个回合隐形执行**：服务端 cancel 不会清空 inbox，被停的 prompt 可能仍留在里面等下一个无人订阅的 turn 认领（耗 token、改工作区、卡片不可见）。现在 cancel 确认关闭后补一次撤回探测，确认不在或撤回成功才清在途标记；退出路径的 cancel 走同一收尾
+- **DSH 断线重连后的历史缺口会回填**：重连快照按消息截取，断连期间积压超过 200 条消息时快照首条会越过上次游标，中间的运行事件此前对本次订阅永久缺失。现在用 `session/page` 的游标向前翻页补齐（最多 20×200 条）；尾部是用户消息时事件探测返回 `unknown`，不再误报「已停止」
+- **pi 会话切换后旧连接不再误杀新回合**：`/new`、`/resume` 切换会替换连接，旧连接迟到的关闭/事件此前会被推进新回合的共享队列，导致新消息未发出即丢失或新回合空转「成功」。现在连接回调带轮次代际锚点，非当前轮的迟到回调直接丢弃
+- **上下文占用统计包含末轮输出**：统一口径改为「输入 + 输出 + 缓存读 + 缓存写」，与文档和压缩水位一致；长收尾回合不再系统性低估数千到数万 token
+- **会话列表不再把 subagent 子会话当成父会话**：codex 按 id 读取与列表/active 同口径过滤子线程；kimi 的工作目录判定改用同路径比较，大小写或尾分隔符差异不再让会话从列表消失
+- **配置 YAML 语法错误不再静默退出**：与配置校验失败同路径在终端输出原因并退出，而不是零输出地无声退出
+- **工作区兜底与路径竞态收紧**：没有当前目录时取「最近使用」的工作区而不是最早保存的别名；`/cd`、`ls.switch`、`/ws use` 的目录检查补 TOCTOU 防护，路径在检查与使用之间被删时给出明确回复而不是静默失败
+- **只有 chatId 的旧绑定记录可以重新认领**：这类记录此前会让所有消息被静默拒绝且永远无法重新绑定，现在视为未绑定，任意首条私聊可重新认领
+- **卡片动作不再被在途媒体下载卡住**：会话变更类卡片动作执行前的入站冲刷改为 2 秒有界等待，大文件下载在途时点「新会话」不再让整个聊天停摆到下载超时；clone 引导期间到达的附件直接忽略，不再落盘或与引导话术冲突
+- **`job.kill` 等纯远程操作立即执行**：终态卡上的「停止后台任务」不再排进串行队列等当前 run 结束
+- **显式清空的模型配置重启后不再被旧选择填回**：`/config` 里清空模型/服务商等于回到默认，残留的旧选择不会再把它填回去
+- **其他可靠性修复**：实例锁改为先写完整临时文件再原子链接，消除并发启动时的空文件窗口；pi 大上下文压缩不再受 60 秒请求超时影响；kimi 非终态的空工具结果不再把运行中的工具提前标成完成；DSH 会话读取遇到单条畸形事件只跳过该条，不再整张恢复卡变空；JSONL 流按字节边界解码，中文/emoji 被 chunk 切开时不再出现乱码
+
+### 安全
+
+- **退出时取消 DSH 回合的凭据临时文件不再可预测**：此前把短时 cookie 写到 `<tmpdir>/lark-remote-exit-cancel-<pid>.hdr`，同机其他用户可预建软链把凭据引到自己可读的文件。现在写入仅本人可进入的随机 0700 临时目录、文件 0600，正常结束与异常路径都会清理
+
+### 变更
+
+- **架构文档同步**：last-session 允许 cwd 缺失、两处终端直写豁免、标题显示宽度常量、DSH follow 快照与事件落盘顺序，中英两侧一致
+
+## [0.5.10] - 2026-10-24
+
+### 修复
+
+- **点「立即执行」后，run 卡片不再抢在最终 toast 前面**：立即执行的 run 起始会等当前排队卡完成交接再建卡。否则 toast 会成为点击后最后一条新消息，聊天列表预览停在 toast 文案上，而 run 卡片后续的「思考中 / 工具 / 完成」变化不点进会话就看不到
+- **长时间运行不再被过期的空闲定时器误杀**：工作区连接自行退出（如 codex app-server 偶发 exit 0）后，挂在旧连接上的空闲回收定时器此前不会被取消，约 30 分钟后会按工作目录回收后来接替的新连接，正在跑的回合被杀、卡片误报「连接已关闭」。现在定时器只回收自己武装时那个连接，进程自退时同时撤掉定时器，继任连接自己的空闲回收仍然照常生效
+
+### 变更
+
+- **英文架构文档补齐排队卡叙述**：立即执行时的 run 起始闸门与 toast 排序，中英两侧一致
+
 ## [0.5.9] - 2026-10-22
 
 ### 新增

package/dist/binder.js

@@ -44,7 +44,13 @@ export class OwnerBinder {
      */
     authorize(userId, chatId) {
         const bound = this.store.getContact();
-        if (bound) {
+        // 只有 chatId 没有 userId 的记录（老版本写入/手改文件）视同未绑定：
+        // bound.userId === undefined 时任何真实 openId 都判不等，一切消息被
+        // 静默 rejected 且永远无法重新认领——用户只能靠文档提示删文件。
+        if (bound && bound.userId === undefined) {
+            getLogger().warn('[binder] startup contact has chatId but no userId; treating as unbound (re-claimable)');
+        }
+        else if (bound) {
             if (userId === bound.userId)
                 return { kind: 'owner' };
             this.rejectedTotal++;

package/dist/bridge/index.d.ts

@@ -270,6 +270,15 @@ export declare class Bridge {
      * user edits a queued message (see router handleQueueImmediate).
      */
     setTaskReplacement(cwd: string, messageId: string, task: () => Promise<void>): void;
+    /**
+     * One-shot: hold the target's run-card start until the returned release is
+     * called. queue.immediate uses it so its final toast is sent before the run
+     * card — the toast would otherwise be the newest message and the chat list
+     * would stop previewing the run card's title changes. The queue slot itself
+     * still begins normally; only run-card creation waits (see
+     * QueueManager.holdTaskRunStart).
+     */
+    holdQueueTaskRun(cwd: string, messageId: string): () => void;
     /** Update queue card to "cancelled" status when user clicks 撤销. */
     updateQueueCardToCancelled(cwd: string, messageId: string): Promise<void>;
     /** Mark a queued task's card as executing immediately (grey out buttons).

package/dist/bridge/index.js

@@ -488,6 +488,17 @@ export class Bridge {
     setTaskReplacement(cwd, messageId, task) {
         this.queueManager.setTaskReplacement(cwd, messageId, task);
     }
+    /**
+     * One-shot: hold the target's run-card start until the returned release is
+     * called. queue.immediate uses it so its final toast is sent before the run
+     * card — the toast would otherwise be the newest message and the chat list
+     * would stop previewing the run card's title changes. The queue slot itself
+     * still begins normally; only run-card creation waits (see
+     * QueueManager.holdTaskRunStart).
+     */
+    holdQueueTaskRun(cwd, messageId) {
+        return this.queueManager.holdTaskRunStart(cwd, messageId);
+    }
     /** Update queue card to "cancelled" status when user clicks 撤销. */
     async updateQueueCardToCancelled(cwd, messageId) {
         await this.queueManager.updateQueueCardToCancelled(cwd, messageId);
@@ -671,8 +682,10 @@ export class Bridge {
         for (const [runId, b] of bashTargets) {
             getLogger().info(`[lark-remote] interrupt hit bash runId=${runId} cwd=${b.cwd} userId=${input.userId}`);
             await b.bashRunner.stop({ immediate: true });
-            // Update card to show interrupted state
-            await b.cardSession.finish('interrupted', { exitCode: -1 });
+            // Update card to show interrupted state. exitCode 不传（保持 null）：
+            // bash-renderer 的「已手动终止」文案要求 exitCode === null；传 -1 会让
+            // 该分支不可达，中断卡退化成「退出码: -1」的失败样式。
+            await b.cardSession.finish('interrupted');
             this.activeBashRuns.delete(runId);
             getLogger().info(`[lark-remote] interrupt bash stop done runId=${runId}`);
             stoppedCount++;
@@ -995,6 +1008,7 @@ export class Bridge {
         // 放在 finalize 之后：activeRuns 槽位已释放，续跑能正常开新卡片。
         await this.retryAfterContentFilter({
             cardSession,
+            activeRun,
             ctx,
             cwd,
             agentKind,
@@ -1031,6 +1045,12 @@ export class Bridge {
             getLogger().info(`[lark-remote] content_filter auto-retry skipped: session epoch moved runId=${state.runId}`);
             return;
         }
+        // 续跑必须接「本轮实际使用的 session」而非入队时刻快照（与 finalize 路径
+        // 的三级优先同口径：卡片状态 → activeRun → 起点快照）。快照只在 run 未建立
+        // 任何新会话时兜底。可证场景：新会话第一条消息（快照 undefined）被截断——
+        // init 已建立 S1，epoch 未动，传快照会让续跑落到全新空会话，本轮上下文
+        // 全部丢失；claude --resume fork 场景同理（init 上报的 id 才是权威）。
+        const retrySessionId = state.sessionId ?? params.activeRun.sessionId ?? params.sessionId;
         getLogger().warn(`[lark-remote] content_filter detected, auto-retrying once runId=${state.runId} cwd=${params.cwd}`);
         await this.sendResult({
             text: '🔁 上一回合被服务方内容审核截断（content_filter，通常是误报），已自动重试一次。',
@@ -1041,7 +1061,7 @@ export class Bridge {
                 cwdOverride: params.cwd,
                 binding: {
                     agent: params.agentKind,
-                    sessionId: params.sessionId,
+                    sessionId: retrySessionId,
                     sessionEpoch: params.sessionEpochAtStart,
                 },
                 autoRetry: true,
@@ -1209,6 +1229,11 @@ export class Bridge {
         });
         try {
             try {
+                // queue.immediate 的 run-start hold：目标槽位可能在 handler 发最终
+                // toast 之前就 begin（interrupt/PATCH 的 await 窗口）。activeRun 已
+                // 登记（队列语义照旧），只把建卡这一步挡到 toast 之后——run 卡片才是
+                // 点击后最后一条新消息，聊天列表预览跟随它的标题变化。
+                await this.queueManager.awaitTaskRunStart(cwd);
                 getLogger().debug(`[lark-remote] cardSession.start() begin runId=${runId}`);
                 await cardSession.start();
                 getLogger().info(`[lark-remote] cardSession.start() ok runId=${runId}`);

package/dist/bridge/queue-manager.d.ts

@@ -69,6 +69,11 @@ export interface ExecutingInfo {
      * settle 清掉后继任务的占用者（身份不用外部 id，同 §9.24 口径）。
      */
     slotId: number;
+    /**
+     * 本次执行条目自己的队列 key（排队卡身份，见 §9.24）。run 起始闸门按它
+     * 找到「当前 lane 占用者」持有的 hold；无 taskMeta 的任务为 undefined。
+     */
+    messageId?: string;
     kind: LaneTaskKind;
     /** 展示标签，例如 '💬 消息' / '🗜 Compact' / '📋 config.save'。 */
     label: string;
@@ -172,6 +177,17 @@ export declare class QueueManager {
     private interruptedSlots;
     /** Per-workspace messageId → replacement closure, set by queue.edit + immediate. */
     private taskReplacements;
+    /**
+     * Per-workspace messageId → run 起始 hold，单次消费。
+     *
+     * queue.immediate 在入口注册、finally 释放；目标任务的 begin 路径照常推进
+     * （槽位移除、排队卡翻执行态），但 `forwardToClaude` 在建 run 卡片前会等
+     * 当前 lane 占用者的 hold。这样「先 toast、后 run 卡片」与队列链推进速度
+     * 无关：run 卡片是点击后最后一条新消息，聊天列表预览才会跟随它的标题变化。
+     * hold 按队列 key 存（order.exec 的内部 key 也能命中），通过 executingInfo
+     * 找到当前占用者，不需要把队列 key 穿过 router/forwardToClaude 的参数。
+     */
+    private taskRunHolds;
     /**
      * MessageIds of tasks that have actually begun executing (cancellation check
      * passed, task removed from the queue). Entries are sticky: they remain
@@ -212,6 +228,21 @@ export declare class QueueManager {
      * Used for / commands that should respond immediately.
      */
     enqueueImmediate(cwd: string, task: () => Promise<void>): void;
+    /**
+     * 单次：hold 住某个排队任务的 run 起始，直到返回的 release 被调用。
+     *
+     * 与「hold 任务闭包」不同，这里只挡 `forwardToClaude` 建 run 卡片之前的
+     * 那一步：队列槽位照常 begin（排队卡翻执行态、began 记账都发生），所以
+     * queue.immediate 的成员资格判断不受影响，只是目标 run 卡片会等 toast。
+     * release 幂等；若任务在 begin 前被撤销，release 会清掉未消费的 hold。
+     */
+    holdTaskRunStart(cwd: string, messageId: string): () => void;
+    /**
+     * 等待当前 lane 占用者的 run 起始 hold。由 `forwardToClaude` 在建 run 卡片
+     * 前调用；hold 在当前调用里同步摘除，之后才注册的 hold 不会延长本次 run
+     * （release 仍会 settle 已捕获的 promise）。
+     */
+    awaitTaskRunStart(cwd: string): Promise<void>;
     /**
      * One-shot: replace the execution closure of an existing queued task in
      * place, preserving its queue position (tasks queued behind it still run

package/dist/bridge/queue-manager.js

@@ -87,6 +87,17 @@ export class QueueManager {
     interruptedSlots = new Map();
     /** Per-workspace messageId → replacement closure, set by queue.edit + immediate. */
     taskReplacements = new Map();
+    /**
+     * Per-workspace messageId → run 起始 hold，单次消费。
+     *
+     * queue.immediate 在入口注册、finally 释放；目标任务的 begin 路径照常推进
+     * （槽位移除、排队卡翻执行态），但 `forwardToClaude` 在建 run 卡片前会等
+     * 当前 lane 占用者的 hold。这样「先 toast、后 run 卡片」与队列链推进速度
+     * 无关：run 卡片是点击后最后一条新消息，聊天列表预览才会跟随它的标题变化。
+     * hold 按队列 key 存（order.exec 的内部 key 也能命中），通过 executingInfo
+     * 找到当前占用者，不需要把队列 key 穿过 router/forwardToClaude 的参数。
+     */
+    taskRunHolds = new Map();
     /**
      * MessageIds of tasks that have actually begun executing (cancellation check
      * passed, task removed from the queue). Entries are sticky: they remain
@@ -308,6 +319,7 @@ export class QueueManager {
             // is waiting for instead of reporting "前面还有 0 条".
             this.executingInfo.set(cwd, {
                 slotId,
+                messageId,
                 kind: taskMeta?.kind ?? 'message',
                 label: laneOccupantLabel(taskMeta?.kind ?? 'message', livePreview),
                 preview: livePreview,
@@ -339,6 +351,72 @@ export class QueueManager {
         getLogger().debug(`[queue-manager] enqueueImmediate cwd=${cwd}`);
         void task().catch((err) => getLogger().error('[queue-manager] immediate task error:', err));
     }
+    /**
+     * 单次：hold 住某个排队任务的 run 起始，直到返回的 release 被调用。
+     *
+     * 与「hold 任务闭包」不同，这里只挡 `forwardToClaude` 建 run 卡片之前的
+     * 那一步：队列槽位照常 begin（排队卡翻执行态、began 记账都发生），所以
+     * queue.immediate 的成员资格判断不受影响，只是目标 run 卡片会等 toast。
+     * release 幂等；若任务在 begin 前被撤销，release 会清掉未消费的 hold。
+     */
+    holdTaskRunStart(cwd, messageId) {
+        let resolve;
+        const hold = {
+            promise: new Promise((r) => {
+                resolve = r;
+            }),
+            release: () => resolve(),
+        };
+        let workspaceHolds = this.taskRunHolds.get(cwd);
+        if (!workspaceHolds) {
+            workspaceHolds = new Map();
+            this.taskRunHolds.set(cwd, workspaceHolds);
+        }
+        const holds = workspaceHolds.get(messageId);
+        if (holds) {
+            holds.push(hold);
+        }
+        else {
+            workspaceHolds.set(messageId, [hold]);
+        }
+        getLogger().debug(`[queue-manager] hold task run start cwd=${cwd} messageId=${messageId}`);
+        return () => {
+            // Resolve before mutating the map: `awaitTaskRunStart` may already have
+            // captured (and deleted) this entry, and the captured promise still needs
+            // to settle.
+            hold.release();
+            const current = this.taskRunHolds.get(cwd)?.get(messageId);
+            if (!current)
+                return;
+            const idx = current.indexOf(hold);
+            if (idx >= 0)
+                current.splice(idx, 1);
+            if (current.length > 0)
+                return;
+            this.taskRunHolds.get(cwd)?.delete(messageId);
+            if (this.taskRunHolds.get(cwd)?.size === 0)
+                this.taskRunHolds.delete(cwd);
+        };
+    }
+    /**
+     * 等待当前 lane 占用者的 run 起始 hold。由 `forwardToClaude` 在建 run 卡片
+     * 前调用；hold 在当前调用里同步摘除，之后才注册的 hold 不会延长本次 run
+     * （release 仍会 settle 已捕获的 promise）。
+     */
+    async awaitTaskRunStart(cwd) {
+        const messageId = this.executingInfo.get(cwd)?.messageId;
+        if (!messageId)
+            return;
+        const workspaceHolds = this.taskRunHolds.get(cwd);
+        const holds = workspaceHolds?.get(messageId);
+        if (!holds || holds.length === 0)
+            return;
+        workspaceHolds?.delete(messageId);
+        if (workspaceHolds?.size === 0)
+            this.taskRunHolds.delete(cwd);
+        getLogger().debug(`[queue-manager] awaiting task run start cwd=${cwd} messageId=${messageId} holds=${holds.length}`);
+        await Promise.all(holds.map((h) => h.promise));
+    }
     /**
      * One-shot: replace the execution closure of an existing queued task in
      * place, preserving its queue position (tasks queued behind it still run

package/dist/card/approval-render.d.ts

@@ -14,3 +14,17 @@ export declare function renderApprovalArea(approval: ApprovalView | undefined, o
     runId?: string;
     terminal?: string;
 }): object[];
+/**
+ * 紧凑审批区（run 卡 skeleton/truncatedSkeleton 兜底档专用）：固定小体积的
+ * 「标题 + 摘要 reason + 决策按钮」，不渲染正文/选项/题面。
+ *
+ * 为什么需要：完整审批区是唯一不受估算器管辖、也不参与 degraded/extreme 分层
+ * 裁剪的区域； pathological 输入（超长 reason、题数×选项爆元素数）会让所有兜底
+ * 层一起超限，超限卡被飞书整卡拒收（11310）→ 审批不可见。兜底层换用本入口后
+ * 结构性保证 ≤ 几个元素 + ≤ 1KB 文本，审批入口（红线）在任何降级档都活着。
+ */
+export declare function renderApprovalAreaCompact(approval: ApprovalView | undefined, opts?: {
+    expired?: boolean;
+    runId?: string;
+    terminal?: string;
+}): object[];