lark-remote 0.5.19 → 0.5.20

package/dist/bridge/job-watch.d.ts

@@ -0,0 +1,68 @@
+import type { Runner } from '../runner/index.js';
+import type { AgentKind } from '../agent-kinds.js';
+import type { CommandContext } from './index.js';
+import type { RunCardSnapshot } from './index.js';
+/**
+ * 终态卡后台任务订阅与停止（bridge 结构治理第 2 刀）。
+ *
+ * run 的卡片在 `result` 那一帧就关闭了，但后台任务（DSH/kimi 的宿主后台作业）
+ * 的生命周期跨 run：job.kill 停止、名单订阅、PATCH 串行链全部收在这里，与
+ * 卡片快照（bridge 侧 runCardSnapshots）按 runId 对齐。
+ *
+ * 依赖显式注入（与 ApprovalActions / CompactLifecycle 同一模式）。两张核心
+ * 状态表都归本类所有：
+ * - `jobWatches`：runId → 中止句柄。与卡片快照同生命周期——快照被淘汰、任务
+ *   全结束、patch 失败时退订。上限天然受 RUN_CARD_SNAPSHOT_MAX 约束（一张卡
+ *   最多一条流）。
+ * - `jobCardPatches`：同一张卡的 patch 串行链（runId → 链尾）。「停止按钮」和
+ *   「订阅帧」都会改同一张终态卡：不串行化时两条 PATCH 并发，后发先至的那条
+ *   会把卡片写回旧内容（任务又变回「运行中」）。
+ */
+export interface JobWatchLifecycleDeps {
+    getRunner(cwd: string, kind?: AgentKind): Runner;
+    /** 终态快照表在 bridge 侧（rememberRunCardSnapshot 收口），这里只读。 */
+    getRunCardSnapshot(runId: string): RunCardSnapshot | undefined;
+    /** 「停止任务」后的整卡重渲染（失败回退发新卡）。 */
+    updateCardInPlace(card: object, ctx: CommandContext): Promise<boolean>;
+    /** 订阅帧的原位 PATCH（已知卡，失败不补发）。 */
+    patchCard(messageId: string, card: object): Promise<boolean>;
+}
+export declare class JobWatchLifecycle {
+    private readonly deps;
+    /** 终态卡后台任务订阅（runId → 中止句柄）。 */
+    private jobWatches;
+    /** 同一张卡的 patch 串行链（runId → 链尾）。 */
+    private jobCardPatches;
+    constructor(deps: JobWatchLifecycleDeps);
+    /** 退订一张终态卡的后台任务名单（幂等）。 */
+    stopJobWatch(runId: string): void;
+    /**
+     * 停止终态卡上的一个后台任务。
+     *
+     * 后台任务的生命周期跨 run（这就是它需要单独入口的原因），所以解析路径是
+     * 终态快照（runId → sessionId/cwd/agentKind）+ 该工作区的 runner 实例，
+     * 而不是 activeRuns。成功后同步摘掉 state 里的任务并就地重渲染，否则按钮
+     * 会留在卡片上而任务早已结束。
+     */
+    killBackgroundJob(runId: string, jobId: string, ctx: CommandContext): Promise<boolean>;
+    /**
+     * 让终态卡的后台任务小节跟着宿主继续更新。
+     *
+     * run 的卡片在 `result` 那一帧就关闭了，但后台任务还能再跑很久：不订阅，
+     * 卡片会一直写「运行中」并留着停止按钮，点了必然失败。退订条件写
+     * 在 {@link consumeJobRoster} 里——名单清空、patch 失败、订阅中断、快照被
+     * 淘汰，任一命中即退出；**绝不因为 patch 失败补发新卡**。
+     */
+    startBackgroundJobWatch(runId: string, snapshot: RunCardSnapshot, runner: Runner): void;
+    /** 消费宿主推来的整份任务名单，直到全结束 / 流断 / patch 失败 / 外部退订。 */
+    private consumeJobRoster;
+    /** 订阅断了但任务仍未结算：把在跑的任务标成「状态未知」并重渲染一次。 */
+    private markJobsUnknown;
+    /**
+     * 一张终态卡的 PATCH 串行链。
+     *
+     * 渲染放在链内执行（`task` 里读 `snapshot.state`），后入链的任务必然看到更新
+     * 后的状态；否则「停止」与「订阅帧」并发时卡片可能回退。
+     */
+    private enqueueJobCardPatch;
+}

package/dist/bridge/job-watch.js

@@ -0,0 +1,146 @@
+import { isLiveBackgroundJob, markBackgroundJobsUnknown, removeBackgroundJob, syncBackgroundJobs, } from '../card/run-state.js';
+import { renderRunCard } from '../card/run-renderer.js';
+import { getLogger } from '../logger/index.js';
+import { errorMessage } from './final-usage.js';
+export class JobWatchLifecycle {
+    deps;
+    /** 终态卡后台任务订阅（runId → 中止句柄）。 */
+    jobWatches = new Map();
+    /** 同一张卡的 patch 串行链（runId → 链尾）。 */
+    jobCardPatches = new Map();
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /** 退订一张终态卡的后台任务名单（幂等）。 */
+    stopJobWatch(runId) {
+        this.jobWatches.get(runId)?.abort();
+        this.jobWatches.delete(runId);
+        this.jobCardPatches.delete(runId);
+    }
+    /**
+     * 停止终态卡上的一个后台任务。
+     *
+     * 后台任务的生命周期跨 run（这就是它需要单独入口的原因），所以解析路径是
+     * 终态快照（runId → sessionId/cwd/agentKind）+ 该工作区的 runner 实例，
+     * 而不是 activeRuns。成功后同步摘掉 state 里的任务并就地重渲染，否则按钮
+     * 会留在卡片上而任务早已结束。
+     */
+    async killBackgroundJob(runId, jobId, ctx) {
+        const snapshot = this.deps.getRunCardSnapshot(runId);
+        const sessionId = snapshot?.state.sessionId;
+        if (!snapshot || !sessionId)
+            return false;
+        const runner = this.deps.getRunner(snapshot.cwd, snapshot.agentKind);
+        if (typeof runner.killJob !== 'function')
+            return false;
+        const killed = await runner.killJob(sessionId, jobId);
+        if (!killed)
+            return false;
+        snapshot.state = removeBackgroundJob(snapshot.state, jobId);
+        // 与订阅帧共用一条串行链：两条 PATCH 并发时，后发先至的那条会把卡片写回
+        // 旧内容（刚停掉的任务又显示成「运行中」）。
+        await this.enqueueJobCardPatch(runId, async () => {
+            await this.deps.updateCardInPlace(renderRunCard(snapshot.state, snapshot.options), ctx);
+            return true;
+        });
+        // 卡片上已经没有在跑的任务：不必再等宿主推下一帧，直接退订。
+        if (!(snapshot.state.backgroundJobs ?? []).some(isLiveBackgroundJob)) {
+            this.stopJobWatch(runId);
+        }
+        return true;
+    }
+    /**
+     * 让终态卡的后台任务小节跟着宿主继续更新。
+     *
+     * run 的卡片在 `result` 那一帧就关闭了，但后台任务还能再跑很久：不订阅，
+     * 卡片会一直写「运行中」并留着停止按钮，点了必然失败。退订条件写
+     * 在 {@link consumeJobRoster} 里——名单清空、patch 失败、订阅中断、快照被
+     * 淘汰，任一命中即退出；**绝不因为 patch 失败补发新卡**。
+     */
+    startBackgroundJobWatch(runId, snapshot, runner) {
+        const live = (snapshot.state.backgroundJobs ?? []).some(isLiveBackgroundJob);
+        if (!live)
+            return;
+        const sessionId = snapshot.state.sessionId;
+        const messageId = snapshot.messageId;
+        const watchJobs = runner.watchJobs;
+        if (!sessionId || !messageId || typeof watchJobs !== 'function') {
+            // 没有卡 id 就没有 patch 的落点：保留收尾快照，不另发一张卡。
+            getLogger().info(`[lark-remote] background jobs stay on the turn snapshot runId=${runId} ` +
+                `(sessionId=${sessionId ?? '-'} messageId=${messageId ?? '-'} watchable=${typeof watchJobs === 'function'})`);
+            return;
+        }
+        const controller = new AbortController();
+        this.jobWatches.set(runId, controller);
+        void this.consumeJobRoster(runId, snapshot, controller, (signal) => watchJobs.call(runner, sessionId, signal));
+    }
+    /** 消费宿主推来的整份任务名单，直到全结束 / 流断 / patch 失败 / 外部退订。 */
+    async consumeJobRoster(runId, snapshot, controller, watch) {
+        const messageId = snapshot.messageId;
+        if (!messageId)
+            return;
+        let allEnded = false;
+        // 订阅帧 PATCH 已失败 → 卡片不可达：finally 不再补 markJobsUnknown。
+        let cardLost = false;
+        try {
+            for await (const roster of watch(controller.signal)) {
+                const next = syncBackgroundJobs(snapshot.state, roster);
+                // 名单没变化就不打 PATCH：宿主可能重复推同一份。
+                if (next === snapshot.state)
+                    continue;
+                snapshot.state = next;
+                const ok = await this.enqueueJobCardPatch(runId, () => this.deps.patchCard(messageId, renderRunCard(snapshot.state, snapshot.options)));
+                if (!ok) {
+                    getLogger().warn(`[lark-remote] background job card update failed, stop watching runId=${runId}`);
+                    // 卡片已不可达：markJobsUnknown 的补写注定再失败，且「标未知」
+                    // 是写给卡片读者看的——没有卡就没有读者。置标志让 finally 跳过。
+                    cardLost = true;
+                    return;
+                }
+                if (!(snapshot.state.backgroundJobs ?? []).some(isLiveBackgroundJob)) {
+                    allEnded = true;
+                    return;
+                }
+            }
+        }
+        catch (err) {
+            if (!controller.signal.aborted) {
+                getLogger().warn(`[lark-remote] background job watch failed runId=${runId}: ${errorMessage(err)}`);
+            }
+        }
+        finally {
+            const externallyAborted = controller.signal.aborted;
+            controller.abort();
+            // 流断了而任务没结算：监控中断 ≠ 任务结束，标成未知而不是继续写「运行中」。
+            // 但卡片 PATCH 已失败（cardLost）时不补写：补写注定失败且语义错位。
+            if (!allEnded && !cardLost && !externallyAborted)
+                await this.markJobsUnknown(runId, snapshot);
+            this.jobWatches.delete(runId);
+            this.jobCardPatches.delete(runId);
+        }
+    }
+    /** 订阅断了但任务仍未结算：把在跑的任务标成「状态未知」并重渲染一次。 */
+    async markJobsUnknown(runId, snapshot) {
+        const next = markBackgroundJobsUnknown(snapshot.state);
+        if (next === snapshot.state)
+            return;
+        snapshot.state = next;
+        const messageId = snapshot.messageId;
+        if (!messageId)
+            return;
+        await this.enqueueJobCardPatch(runId, () => this.deps.patchCard(messageId, renderRunCard(snapshot.state, snapshot.options)));
+    }
+    /**
+     * 一张终态卡的 PATCH 串行链。
+     *
+     * 渲染放在链内执行（`task` 里读 `snapshot.state`），后入链的任务必然看到更新
+     * 后的状态；否则「停止」与「订阅帧」并发时卡片可能回退。
+     */
+    enqueueJobCardPatch(runId, task) {
+        const previous = this.jobCardPatches.get(runId) ?? Promise.resolve();
+        const next = previous.then(task, task);
+        this.jobCardPatches.set(runId, next.then(() => undefined, () => undefined));
+        return next;
+    }
+}
+//# sourceMappingURL=job-watch.js.map

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

@@ -11,7 +11,7 @@ export interface AgentBinding {
      * 会话代际快照（与 sessionId 同刻捕获）。随 binding 带到执行时刻：若执行前
      * session 指针被移动（/new、/cd、/resume、/config 切换），该 run 的 init /
      * turn_started 写回判 stale 跳过，避免「先发消息 → 后点新会话」时旧 sessionId
-     * 被写回复活（2026-10-07 事故）。缺省时回退到执行起点捕获，保持旧行为。
+     * 被写回复活。缺省时回退到执行起点捕获，保持旧行为。
      */
     sessionEpoch?: number;
 }
@@ -161,7 +161,7 @@ export declare class QueueManager {
      * interrupt credit to exactly the interrupted task's slot) and the display
      * info the queue card needs to name what a waiting message waits for.
      *
-     * 2026-10-09 线上：一次 Compact 占着 lane，新消息的排队卡却写「位置: 第 1
+     * 一次 Compact 占着 lane，新消息的排队卡曾写「位置: 第 1
      * 位 / 前面还有: 0 条消息」——开卡判据看 lane（含正在执行者），位置文案只看
      * 等待队列，两个口径的差集正是这条记录。
      */
@@ -276,7 +276,7 @@ export declare class QueueManager {
     /**
      * 排队卡头部。只有前面确实还有等待中的消息时才说「排队」；前面为空时
      * 用户等的是当前正在执行的任务（例如 Compact），用「等待当前任务结束」
-     * 表达才不会与「前面还有 0 条」自相矛盾（2026-10-09 线上实例）。
+     * 表达才不会与「前面还有 0 条」自相矛盾。
      */
     private queueCardHeader;
     /** Send a queue status card showing current queue position and actions. */

package/dist/bridge/queue-manager.js

@@ -1,5 +1,5 @@
 import { getLogger } from '../logger/index.js';
-import { cardWithHeader } from '../card/card-shared.js';
+import { cardButton, cardWithHeader } from '../card/card-shared.js';
 import { displayName } from '../platform/path.js';
 /**
  * Per-workspace cap on the number of tasks WAITING to execute.
@@ -71,7 +71,7 @@ export class QueueManager {
      * interrupt credit to exactly the interrupted task's slot) and the display
      * info the queue card needs to name what a waiting message waits for.
      *
-     * 2026-10-09 线上：一次 Compact 占着 lane，新消息的排队卡却写「位置: 第 1
+     * 一次 Compact 占着 lane，新消息的排队卡曾写「位置: 第 1
      * 位 / 前面还有: 0 条消息」——开卡判据看 lane（含正在执行者），位置文案只看
      * 等待队列，两个口径的差集正是这条记录。
      */
@@ -227,8 +227,8 @@ export class QueueManager {
         }
         // 身份不变量 tripwire：同一 cwd 内 queue key 必须唯一（一次入队动作一个
         // key，铸造点 router.mintQueueTaskKey）。撞 key 时数组（追加）与 taskIndex
-        // （覆盖）必然漂移，位置显示/撤销/立即执行/卡片更新会串到别的条目上——
-        // 2026-10-08 线上缺陷就是这么长出来的。这里不改行为，只留证据。
+        // （覆盖）必然漂移，位置显示/撤销/立即执行/卡片更新会串到别的条目上。
+        // 这里不改行为，只留证据。
         if (this.indexGet(cwd, queuedTask.messageId)) {
             getLogger().warn(`[queue-manager] duplicate queue key cwd=${cwd} messageId=${queuedTask.messageId} — ` +
                 'queue identity must be minted per enqueue action (see router.mintQueueTaskKey)');
@@ -304,8 +304,7 @@ export class QueueManager {
             // so pruning the oldest entries is safe.
             if (this.beganMessageIds.size >= 10_000) {
                 const oldest = this.beganMessageIds.values().next().value;
-                if (oldest !== undefined)
-                    this.beganMessageIds.delete(oldest);
+                this.beganMessageIds.delete(oldest);
             }
             this.beganMessageIds.add(messageId);
         }
@@ -453,7 +452,7 @@ export class QueueManager {
     /**
      * 排队卡头部。只有前面确实还有等待中的消息时才说「排队」；前面为空时
      * 用户等的是当前正在执行的任务（例如 Compact），用「等待当前任务结束」
-     * 表达才不会与「前面还有 0 条」自相矛盾（2026-10-09 线上实例）。
+     * 表达才不会与「前面还有 0 条」自相矛盾。
      */
     queueCardHeader(tasksAhead) {
         return {
@@ -537,7 +536,7 @@ export class QueueManager {
         if (occupant) {
             // 只有可能挡住队列、需要用户归因的占用者才自报身份。「正在执行: 💬 消息」
             // 对普通消息占用者没有信息量——用户刚发的就是消息，「💡 消息将按顺序执行…」
-            // 也只是复述排队本身，一并省去（2026-10-11）。压缩额外说明何时轮到用户。
+            // 也只是复述排队本身，一并省去。压缩额外说明何时轮到用户。
             if (occupant.kind !== 'message') {
                 elements.push({
                     tag: 'div',
@@ -572,13 +571,7 @@ export class QueueManager {
                 // Edit button: a pending (queued) task is editable by default. The
                 // executing/cancelled states render via dedicated card builders that
                 // hard-disable all buttons, so this builder only serves pending cards.
-                elements.push({
-                    tag: 'button',
-                    text: { tag: 'plain_text', content: '✏️ 编辑' },
-                    type: 'default',
-                    size: 'small',
-                    behaviors: [{ type: 'callback', value: { cmd: 'queue.edit', cwd, messageId } }],
-                });
+                elements.push(cardButton('✏️ 编辑', { cmd: 'queue.edit', cwd, messageId }, { type: 'default', size: 'small' }));
             }
             elements.push({ tag: 'hr' });
         }
@@ -604,20 +597,8 @@ export class QueueManager {
      */
     buildQueueActionButtons(cwd, messageId, disabled, opts) {
         return [
-            {
-                tag: 'button',
-                text: { tag: 'plain_text', content: '❌ 撤销' },
-                type: 'danger',
-                disabled,
-                behaviors: [{ type: 'callback', value: { cmd: 'queue.cancel', cwd, messageId } }],
-            },
-            {
-                tag: 'button',
-                text: { tag: 'plain_text', content: opts?.immediateLabel ?? '⚡ 立即执行' },
-                type: 'primary',
-                disabled: disabled || opts?.immediateLabel !== undefined,
-                behaviors: [{ type: 'callback', value: { cmd: 'queue.immediate', cwd, messageId } }],
-            },
+            cardButton('❌ 撤销', { cmd: 'queue.cancel', cwd, messageId }, { type: 'danger', disabled }),
+            cardButton(opts?.immediateLabel ?? '⚡ 立即执行', { cmd: 'queue.immediate', cwd, messageId }, { type: 'primary', disabled: disabled || opts?.immediateLabel !== undefined }),
         ];
     }
     /**

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

@@ -10,7 +10,7 @@ import { type RunTerminal } from './run-state.js';
  * Render the approval area for a run card.
  * Returns an array of CardKit 2.0 elements to append to the card body.
  */
-export declare function renderApprovalArea(approval: ApprovalView | undefined, opts?: {
+export declare function renderApprovalArea(approval: ApprovalView, opts?: {
     expired?: boolean;
     runId?: string;
     terminal?: RunTerminal;
@@ -24,7 +24,7 @@ export declare function renderApprovalArea(approval: ApprovalView | undefined, o
  * 层一起超限，超限卡被飞书整卡拒收（11310）→ 审批不可见。兜底层换用本入口后
  * 结构性保证 ≤ 几个元素 + ≤ 1KB 文本，审批入口（红线）在任何降级档都活着。
  */
-export declare function renderApprovalAreaCompact(approval: ApprovalView | undefined, opts?: {
+export declare function renderApprovalAreaCompact(approval: ApprovalView, opts?: {
     expired?: boolean;
     runId?: string;
     terminal?: RunTerminal;

package/dist/card/approval-render.js

@@ -71,8 +71,6 @@ function pushIf(arr, el) {
  * Returns an array of CardKit 2.0 elements to append to the card body.
  */
 export function renderApprovalArea(approval, opts) {
-    if (!approval)
-        return [];
     // 终态（done/error/interrupted/idle_timeout）下 run 已结束：coordinator 已
     // 释放，按钮点击无处响应，隐藏整个审批区避免"点了没反应"。
     if (isTerminalHidden(opts))
@@ -123,8 +121,6 @@ export function renderApprovalArea(approval, opts) {
  * 结构性保证 ≤ 几个元素 + ≤ 1KB 文本，审批入口（红线）在任何降级档都活着。
  */
 export function renderApprovalAreaCompact(approval, opts) {
-    if (!approval)
-        return [];
     if (isTerminalHidden(opts))
         return [];
     const elements = [
@@ -533,112 +529,128 @@ function renderQuestionApproval(approval, expired, runId) {
             break;
         }
         renderedQuestions++;
-        const q = questions[i];
-        const selected = q.selected ?? [];
-        const header = capApprovalText(q.header || `问题 ${i + 1}`, APPROVAL_LABEL_BYTES);
-        const freeText = (q.options?.length ?? 0) === 0;
+        elements.push(...renderQuestionBlock(approval, i, runId));
+    }
+    // 提问卡底部统一「跳过回答」：走现有 approval.respond + decision=decline
+    // （coordinator 对 question 允许 decline 作为安全兜底），runner 按协议映射
+    // 跳过语义（Claude deny / Codex 空 answers / Kimi action decline / Pi cancelled）。
+    if (!expired) {
+        elements.push(cardButton('⏭️ 跳过回答', {
+            cmd: 'approval.respond',
+            decision: 'decline',
+            requestId: approval.requestId,
+            runId,
+            nonce: mkNonce(),
+        }, { type: 'default' }));
+    }
+    return elements;
+}
+/**
+ * 渲染单题区块：题面 + 详情面板 + 选项行/输入框 + （多选）提交按钮。
+ * 从 renderQuestionApproval 的循环体抽出；循环保留题数/元素预算裁剪与
+ * 卡片装配。交互组件（按钮/输入框）继续直挂 body elements——本函数输出
+ * 必须始终被 expectNoV1ActionContainer 断言覆盖（200861 红线，见
+ * run-renderer.test.ts 的 question 系列）；nonce 仍由各交互元素生成时
+ * 各自调用一次 mkNonce()，不在块外缓存复用。
+ */
+function renderQuestionBlock(approval, qIndex, runId) {
+    const q = approval.questions?.[qIndex];
+    // 越界防御（正常调用由循环边界保证）；不虚构题面。
+    if (!q)
+        return [];
+    const elements = [];
+    const selected = q.selected ?? [];
+    const header = capApprovalText(q.header || `问题 ${qIndex + 1}`, APPROVAL_LABEL_BYTES);
+    const freeText = (q.options?.length ?? 0) === 0;
+    elements.push({
+        tag: 'div',
+        text: {
+            tag: 'lark_md',
+            content: `**${header}**${q.multiSelect ? '（可多选）' : ''}\n${capApprovalText(q.question)}`,
+        },
+    });
+    if (q.detail) {
+        // 题面外的补充正文（DSH plan-review 提问把计划全文放这里）：必须随题
+        // 渲染，否则用户是在「看不见计划」的情况下批准。与 ExitPlanMode 的
+        // 计划面板同口径：反引号中和 + 表格限数 + 字节预算折叠展示。
+        const neutralized = q.detail.replace(/`/g, '·');
+        const content = truncateUtf8(truncateMarkdownTables(neutralized), PLAN_PANEL_BYTES);
+        elements.push(collapsibleMarkdownPanel({
+            title: '📋 详情',
+            expanded: false,
+            border: 'blue',
+            content,
+        }));
+    }
+    if (freeText) {
+        // 自由文本题（Codex options:null / Pi extension input）：无选项行，
+        // 直接渲染题面 + 输入框，提交走 answerCustom（coordinator 不要求有选项）。
+        elements.push(renderAnswerInput(approval.requestId, qIndex, q.placeholder ?? '输入回答…', runId));
+        // 已答回显：input_value 不跨卡片更新保留，多题场景下用户提交后若还有
+        // 其他问题未答，卡片必须展示已答文本（与自定义答案选中态同模式）。
+        const answered = q.selected?.find((s) => s.length > 0);
+        if (answered) {
+            elements.push({
+                tag: 'div',
+                text: { tag: 'lark_md', content: `✍️ 已答：${capApprovalText(answered)}` },
+            });
+        }
+        return elements;
+    }
+    // 选项渲染上限（label 是回调 payload 不可截断，只能按条数折叠）。
+    const options = q.options ?? [];
+    for (const option of options.slice(0, MAX_RENDERED_OPTIONS)) {
+        const isSelected = selected.includes(option.label);
+        // 单选/多选图标区分：单选 ⚪/🔵（radio 隐喻），多选 ⬜/☑️（checkbox 隐喻）。
+        const icon = q.multiSelect ? (isSelected ? '☑️' : '⬜') : isSelected ? '🔵' : '⚪';
+        elements.push(renderOptionRow(approval.requestId, qIndex, option, isSelected, icon, runId));
+    }
+    if (options.length > MAX_RENDERED_OPTIONS) {
         elements.push({
             tag: 'div',
             text: {
                 tag: 'lark_md',
-                content: `**${header}**${q.multiSelect ? '（可多选）' : ''}\n${capApprovalText(q.question)}`,
+                content: `_…另有 ${options.length - MAX_RENDERED_OPTIONS} 个选项未展示（卡片元素预算）_`,
             },
         });
-        if (q.detail) {
-            // 题面外的补充正文（DSH plan-review 提问把计划全文放这里）：必须随题
-            // 渲染，否则用户是在「看不见计划」的情况下批准。与 ExitPlanMode 的
-            // 计划面板同口径：反引号中和 + 表格限数 + 字节预算折叠展示。
-            const neutralized = q.detail.replace(/`/g, '·');
-            const content = truncateUtf8(truncateMarkdownTables(neutralized), PLAN_PANEL_BYTES);
-            elements.push(collapsibleMarkdownPanel({
-                title: '📋 详情',
-                expanded: false,
-                border: 'blue',
-                content,
-            }));
-        }
-        if (freeText) {
-            // 自由文本题（Codex options:null / Pi extension input）：无选项行，
-            // 直接渲染题面 + 输入框，提交走 answerCustom（coordinator 不要求有选项）。
-            elements.push(renderAnswerInput(approval.requestId, i, q.placeholder ?? '输入回答…', runId));
-            // 已答回显：input_value 不跨卡片更新保留，多题场景下用户提交后若还有
-            // 其他问题未答，卡片必须展示已答文本（与自定义答案选中态同模式）。
-            const answered = q.selected?.find((s) => s.length > 0);
-            if (answered) {
-                elements.push({
-                    tag: 'div',
-                    text: { tag: 'lark_md', content: `✍️ 已答：${capApprovalText(answered)}` },
-                });
-            }
-            continue;
-        }
-        // 选项渲染上限（label 是回调 payload 不可截断，只能按条数折叠）。
-        const options = q.options ?? [];
-        for (const option of options.slice(0, MAX_RENDERED_OPTIONS)) {
-            const isSelected = selected.includes(option.label);
-            // 单选/多选图标区分：单选 ⚪/🔵（radio 隐喻），多选 ⬜/☑️（checkbox 隐喻）。
-            const icon = q.multiSelect ? (isSelected ? '☑️' : '⬜') : isSelected ? '🔵' : '⚪';
-            elements.push(renderOptionRow(approval.requestId, i, option, isSelected, icon, runId));
-        }
-        if (options.length > MAX_RENDERED_OPTIONS) {
-            elements.push({
-                tag: 'div',
-                text: {
-                    tag: 'lark_md',
-                    content: `_…另有 ${options.length - MAX_RENDERED_OPTIONS} 个选项未展示（卡片元素预算）_`,
-                },
-            });
-        }
-        // 自定义答案（Other）的选中态展示：选项按钮无法表示自由文本，单独显示
-        // 已选文本，避免「点了没反应」的困惑。
-        const customSelected = q.selected?.find((s) => !q.options.some((o) => o.label === s));
-        if (customSelected) {
+    }
+    // 自定义答案（Other）的选中态展示：选项按钮无法表示自由文本，单独显示
+    // 已选文本，避免「点了没反应」的困惑。
+    const customSelected = q.selected?.find((s) => !q.options.some((o) => o.label === s));
+    if (customSelected) {
+        elements.push({
+            tag: 'div',
+            text: { tag: 'lark_md', content: `✍️ 自定义答案：${capApprovalText(customSelected)}` },
+        });
+    }
+    // 单选问题提供自定义答案（Other）输入——输入文本后提交
+    // （移动端键盘回车/完成键，桌面端输入框右侧提交图标），input_value 经
+    // connector raw 事件回传。
+    // 显隐按 isOther !== false：Kimi form 会丢弃非声明选项值，翻译时置
+    // isOther=false 隐藏输入；Claude 未设置该字段默认显示（行为不变）。
+    if (!q.multiSelect && q.isOther !== false) {
+        elements.push(renderAnswerInput(approval.requestId, qIndex, '自定义答案（Other）…', runId, 'approval.answerCustom'));
+    }
+    // Codex user_note：选项之外的补充说明（allowNote 数据驱动门控）。
+    // 提交走 answerNote（coordinator 记录 note，随答案一起提交），已填回显。
+    if (q.allowNote === true) {
+        elements.push(renderAnswerInput(approval.requestId, qIndex, '补充说明（可选）…', runId, 'approval.answerNote'));
+        if (q.note) {
             elements.push({
                 tag: 'div',
-                text: { tag: 'lark_md', content: `✍️ 自定义答案：${capApprovalText(customSelected)}` },
+                text: { tag: 'lark_md', content: `📝 ${capApprovalText(q.note)}` },
             });
         }
-        // 单选问题提供自定义答案（Other）输入——输入文本后提交
-        // （移动端键盘回车/完成键，桌面端输入框右侧提交图标），input_value 经
-        // connector raw 事件回传。
-        // 显隐按 isOther !== false：Kimi form 会丢弃非声明选项值，翻译时置
-        // isOther=false 隐藏输入；Claude 未设置该字段默认显示（行为不变）。
-        if (!q.multiSelect && q.isOther !== false) {
-            elements.push(renderAnswerInput(approval.requestId, i, '自定义答案（Other）…', runId, 'approval.answerCustom'));
-        }
-        // Codex user_note：选项之外的补充说明（allowNote 数据驱动门控）。
-        // 提交走 answerNote（coordinator 记录 note，随答案一起提交），已填回显。
-        if (q.allowNote === true) {
-            elements.push(renderAnswerInput(approval.requestId, i, '补充说明（可选）…', runId, 'approval.answerNote'));
-            if (q.note) {
-                elements.push({
-                    tag: 'div',
-                    text: { tag: 'lark_md', content: `📝 ${capApprovalText(q.note)}` },
-                });
-            }
-        }
-        // 多选问题：有勾选才给提交按钮（单选在协调器内即时提交）。
-        if (q.multiSelect && selected.length > 0) {
-            elements.push(cardButton(`✅ 提交答案（已选 ${selected.length} 项）`, {
-                cmd: 'approval.answerSubmit',
-                requestId: approval.requestId,
-                questionIndex: i,
-                runId,
-                nonce: mkNonce(),
-            }, { type: 'primary' }));
-        }
     }
-    // 提问卡底部统一「跳过回答」：走现有 approval.respond + decision=decline
-    // （coordinator 对 question 允许 decline 作为安全兜底），runner 按协议映射
-    // 跳过语义（Claude deny / Codex 空 answers / Kimi action decline / Pi cancelled）。
-    if (!expired) {
-        elements.push(cardButton('⏭️ 跳过回答', {
-            cmd: 'approval.respond',
-            decision: 'decline',
+    // 多选问题：有勾选才给提交按钮（单选在协调器内即时提交）。
+    if (q.multiSelect && selected.length > 0) {
+        elements.push(cardButton(`✅ 提交答案（已选 ${selected.length} 项）`, {
+            cmd: 'approval.answerSubmit',
             requestId: approval.requestId,
+            questionIndex: qIndex,
             runId,
             nonce: mkNonce(),
-        }, { type: 'default' }));
+        }, { type: 'primary' }));
     }
     return elements;
 }
@@ -693,7 +705,7 @@ function renderOptionRow(requestId, questionIndex, option, isSelected, icon, run
 function renderAnswerInput(requestId, questionIndex, placeholder, runId, cmd = 'approval.answerCustom') {
     // name 必须含 cmd，保证同一题同时渲染多个输入框（如单选选项题的
     // Other 输入 + Note 输入）时元素 name 唯一——飞书对同卡内重复 name
-    // 报 ErrCode 11310 拒绝整卡（2026-08-19 线上：name(answer-custom-0-0) duplicate）。
+    // 报 ErrCode 11310 拒绝整卡。
     const kind = cmd === 'approval.answerNote' ? 'note' : 'custom';
     return {
         tag: 'input',

package/dist/card/card-budget.js

@@ -165,7 +165,7 @@ function enforceElementBudget(card, opts = {}, bytesBefore) {
  * when table truncation alone doesn't bring the card under the byte limit.
  *
  * 裁剪判定是**结构化**的：所有 collapsible_panel 都是待裁剪对象，不看面板
- * 标题文本。历史教训（2026-08-08）：旧实现用
+ * 标题文本。历史教训：旧实现用
  * emoji 标题模式（🤖👤💭🔧🟢🔴）识别「会话事件面板」，但真实
  * sessionEventPanel 产出的标题是裸英文 type 名（emoji 在事件正文而非标题），
  * 导致裁剪阶段对真实 resume 卡零命中，任何 >28KB 的卡片无裁剪直通极端降级，

package/dist/card/card-helpers.d.ts

@@ -27,7 +27,7 @@ export declare function parseJumpOffset(inputValue: unknown, pageSize: number):
  * Build the CardKit 2.0 pagination block shared by /ls, /ws, /resume, /active,
  * /order.
  *
- * 第一性原理（2026-09-10 窄屏重设计）：分页栏要同时承载「页码信息」和「翻页
+ * 第一性原理（窄屏）：分页栏要同时承载「页码信息」和「翻页
  * 控件」两类需求。旧布局把两者塞进同一行 `column_set`（文案 weighted 4 : 输入
  * weighted 2），手机窄屏下 auto 按钮先占走固有宽度，剩余宽度按 4:2 切分后文案
  * 列只有百来像素、输入框只有几十像素——文案折行、输入框窄到没法点。
@@ -104,8 +104,8 @@ export declare function searchBar(opts: {
  *
  * 旧口径是 `events.slice(-max)`：按**原始事件条数**截尾。工具往返（bash 调用 →
  * job 登记 → 结果）一段就能把窗口占满，于是重返会话的用户真正需要的两条信息
- * ——最后一句我说了什么、最后一句它答了什么——被挤出窗口。2026-10-19 实测：
- * 自动恢复卡 5 个面板全是 bash 调用，一条用户消息、一条 assistant 正文都没有。
+ * ——最后一句我说了什么、最后一句它答了什么——被挤出窗口：自动恢复卡 5 个
+ * 面板全是 bash 调用，一条用户消息、一条 assistant 正文都没有。
  *
  * 契约：先取最新 `max` 条，再把最后一条 `user` 与最后一条 `assistant`（正文）
  * 不在窗口内时补进来——补位时淘汰最早的**非锚点**事件。输出保持时间顺序，