lark-remote 0.5.17 → 0.5.19

package/dist/card/final-answer-file.js

@@ -0,0 +1,42 @@
+/**
+ * 完整回答超出一张卡片时，落成 Markdown 文件随卡片发送。
+ *
+ * 为什么不再拆纯文本消息：拆出来的「完整回答（1/N）」与卡片正文重复
+ * （2026-11-02 实机反馈：同一篇回答用户看到两遍），而且纯文本会丢表格、
+ * 代码块等 Markdown 结构。文件通道保留原文逐字不变，且只多一条文件消息。
+ *
+ * 调用方负责用后删除：`bestEffortUnlink()` 见 `common/fs.ts`。
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { cardWithHeader } from './card-shared.js';
+import { markdownDiv } from './collapsible.js';
+/** 文件名里的可读时间戳（本地时区），如 `20261102-0715`。 */
+function fileStamp(now) {
+    const pad = (n) => String(n).padStart(2, '0');
+    return (`${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}` +
+        `-${pad(now.getHours())}${pad(now.getMinutes())}`);
+}
+/**
+ * 把完整回答写进系统临时目录里的 `.md` 文件，返回绝对路径。
+ *
+ * 文件名带时间戳与随机后缀：同一分钟内的多个 run 不会互相覆盖，也不会在
+ * 飞书里显示成同名附件。内容逐字写入，不做任何截断或转义。
+ */
+export function writeFinalAnswerFile(text, now = new Date()) {
+    const suffix = randomUUID().slice(0, 8);
+    const filePath = path.join(os.tmpdir(), `lark-remote-final-answer-${fileStamp(now)}-${suffix}.md`);
+    fs.writeFileSync(filePath, text, 'utf8');
+    return filePath;
+}
+/** 文件通道失败时的提示卡——终态反馈也只走卡片，不发纯文本。 */
+export function finalAnswerFileFailureCard(message) {
+    return cardWithHeader({
+        template: 'red',
+        title: '⚠️ 完整回答文件发送失败',
+        elements: [markdownDiv(`完整回答没能作为 Markdown 文件发出：${message}`)],
+    });
+}
+//# sourceMappingURL=final-answer-file.js.map

package/dist/card/run-card-session.js

@@ -50,6 +50,8 @@ export class RunCardSession extends CardSession {
         await this.prepareTerminalUpdate();
         this.state = finishRun(this.state, terminal, meta);
         await this.updateCard();
+        // 终态帧必须真的落地（throttle 通道 resolve 时 patch 还没发）。
+        await this.confirmTerminalFrame(`runId=${this.state.runId} terminal=${this.state.terminal}`);
         this.release();
     }
 }

package/dist/card/run-renderer.d.ts

@@ -85,6 +85,6 @@ export declare function renderRunCard(state: RunState, options?: RunCardRenderOp
  * by streaming sessions.
  */
 export declare function renderRunCardDetailed(state: RunState, options?: RunCardRenderOptions): RunCardRenderOutcome;
-/** Exact-match marker used in the card before the answer is sent separately. */
-export declare const FINAL_ANSWER_OVERFLOW_MARKER = "_\u6700\u7EC8\u56DE\u7B54\u8F83\u957F\uFF0C\u5B8C\u6574\u5185\u5BB9\u5DF2\u968F\u540E\u53D1\u9001_";
+/** Exact-match marker: the body is delivered as an attached Markdown file. */
+export declare const FINAL_ANSWER_OVERFLOW_MARKER = "_\u6700\u7EC8\u56DE\u7B54\u8F83\u957F\uFF0C\u5B8C\u6574\u5185\u5BB9\u89C1\u968F\u9644\u7684 Markdown \u6587\u4EF6_";
 export {};

package/dist/card/run-renderer.js

@@ -1,4 +1,4 @@
-import { isRunActive, isRunTerminal, } from './run-state.js';
+import { isLiveBackgroundJob, isRunActive, isRunTerminal, } from './run-state.js';
 import { terminalToColor, terminalToLabel, newSessionButton, stopButton, compactButton, cardButton, agentDisplayName, } from './card-shared.js';
 import { collapsibleMarkdownPanel, markdownDiv } from './collapsible.js';
 import { toolBodyMd, toolHeaderText } from './tool-render.js';
@@ -941,22 +941,27 @@ function renderLegacyRunCard(state, options) {
     };
     return truncatedSkeleton;
 }
-/** Exact-match marker used in the card before the answer is sent separately. */
-export const FINAL_ANSWER_OVERFLOW_MARKER = '_最终回答较长，完整内容已随后发送_';
+/** Exact-match marker: the body is delivered as an attached Markdown file. */
+export const FINAL_ANSWER_OVERFLOW_MARKER = '_最终回答较长，完整内容见随附的 Markdown 文件_';
 /**
  * Build a card around the authoritative final answer.
  *
  * The answer is measured first with the fixed controls. Progress groups are
  * added newest-first only while the whole card still fits. If the answer
  * cannot fit even without progress/summary, the card carries an explicit
- * marker and the bridge sends the complete answer separately.
+ * marker and the bridge sends the complete answer as a Markdown file
+ * attachment (never as plain chat text).
+ *
+ * 「卡片装不下正文」与「表格数超上限」是两件事，只有前者才走补发通道：
+ * 飞书单卡最多 5 张 markdown 表（11310），多出来的最旧表格会被删掉并在原位
+ * 留 `_💡 前 N 个表格已省略_`——正文仍在卡片里，再补发一遍就是把用户已经看到
+ * 的整篇回答重复（2026-11-02 实机反馈）。
  */
 function buildFinalAnswerPriorityCard(state, options) {
     const finalAnswer = state.finalAnswer;
     const groups = groupBlocks(state.blocks);
     const prepared = prepareGroupContent(groups);
     const safeAnswer = truncateMarkdownTables(finalAnswer.content);
-    const requiresOverflow = safeAnswer !== finalAnswer.content;
     const ts = formatTimestamp(finalAnswer.timestamp);
     const answerElements = renderTextBlock(safeAnswer, ts, state.terminal !== 'running');
     const fixedStart = [statusRow(state), ...omittedBlocksHint(state)];
@@ -970,7 +975,6 @@ function buildFinalAnswerPriorityCard(state, options) {
         return assembleRunCard(state, options, [
             ...fixedStart,
             ...progress,
-            ...(requiresOverflow ? [markdownDiv(FINAL_ANSWER_OVERFLOW_MARKER)] : []),
             ...answerElements,
             ...(includeSummary ? summary : []),
             ...controls,
@@ -984,21 +988,15 @@ function buildFinalAnswerPriorityCard(state, options) {
                 break;
             best = candidate;
         }
-        return {
-            card: best,
-            finalAnswerStatus: requiresOverflow ? 'overflow' : 'full',
-            ...(requiresOverflow ? { finalAnswerText: finalAnswer.content } : {}),
-        };
+        // 正文已经在卡里（表格超限只是少渲染最旧的几张，原位有省略提示），
+        // 不再走补发通道。
+        return { card: best, finalAnswerStatus: 'full' };
     }
     // The answer outranks the usage summary. Keep the answer and controls first,
     // then retry without the summary before declaring a physical overflow.
     const withoutSummary = buildWithProgress(groups.length, false);
     if (withinRunCardBudget(withoutSummary)) {
-        return {
-            card: withoutSummary,
-            finalAnswerStatus: requiresOverflow ? 'overflow' : 'full',
-            ...(requiresOverflow ? { finalAnswerText: finalAnswer.content } : {}),
-        };
+        return { card: withoutSummary, finalAnswerStatus: 'full' };
     }
     const overflowCard = assembleRunCard(state, options, [
         ...fixedStart,
@@ -1204,11 +1202,26 @@ const BACKGROUND_JOB_INLINE_MAX = 36;
 const BACKGROUND_JOB_FOLD_DISPLAY_MAX = 180;
 const BACKGROUND_JOB_FOLD_LINES = 6;
 /**
- * 任务状态标签：目前 DSH 只会给 running/stopping，其他值按运行中处理。
+ * 任务状态标签：宿主的两态 + 桥侧观测出的「已结束 / 状态未知」。
+ *
+ * 「已结束」不是可有可无的修饰：卡片上曾经只有「运行中/停止中」，任务跑完之
+ * 后卡片仍然这么写，用户只能靠点一次停止按钮看它报错来判断任务是否还在。
  */
 function backgroundJobStatusLabel(status) {
+    if (status === 'ended')
+        return '已结束';
+    if (status === 'unknown')
+        return '状态未知';
     return status === 'stopping' ? '停止中' : '运行中';
 }
+/** 行尾状态（live 任务返回空串：运行中本来就是默认状态）。 */
+function backgroundJobStatusTail(status) {
+    if (status === 'ended')
+        return '✅ 已结束';
+    if (status === 'unknown')
+        return '⚠️ 状态未知';
+    return '';
+}
 /**
  * 生成能包住任意反引号串的代码围栏。命令里的 shell 反引号不能替换成 `'`
  * （那是改内容），只能选比内容里最长反引号串更长的围栏。
@@ -1246,24 +1259,40 @@ function buildBackgroundJobsSection(state) {
     const jobs = state.backgroundJobs ?? [];
     if (jobs.length === 0)
         return [];
-    const elements = [
-        markdownDiv(`🧵 **后台任务** ${jobs.length} 个仍在运行`),
-        markdownDiv('_本轮结束后继续，可逐个停止_', 'notation'),
-    ];
-    jobs.slice(0, MAX_BACKGROUND_JOB_LINES).forEach((job, index) => {
+    // 仍在跑的排前面：用户最先要知道的是"哪些还在占资源"。
+    const running = jobs.filter((job) => isLiveBackgroundJob(job));
+    const unknown = jobs.filter((job) => job.status === 'unknown');
+    const ended = jobs.filter((job) => !isLiveBackgroundJob(job) && job.status !== 'unknown');
+    const ordered = [...running, ...unknown, ...ended];
+    // 计数逐维列出：只说「N 个任务」会让"都还在跑"与"都结束了"读起来一样。
+    const counts = [];
+    if (running.length > 0)
+        counts.push(`${running.length} 个仍在运行`);
+    if (unknown.length > 0)
+        counts.push(`${unknown.length} 个状态未知`);
+    if (ended.length > 0)
+        counts.push(`${ended.length} 个已结束`);
+    const headline = ended.length === jobs.length ? '已全部结束' : counts.join(' · ');
+    const elements = [markdownDiv(`🧵 **后台任务** ${headline}`)];
+    if (running.length + unknown.length > 0) {
+        elements.push(markdownDiv('_本轮结束后继续，可逐个停止_', 'notation'));
+    }
+    ordered.slice(0, MAX_BACKGROUND_JOB_LINES).forEach((job, index) => {
         const label = job.label.trim();
+        const tail = backgroundJobStatusTail(job.status);
         const lineCount = label === '' ? 0 : label.split(/\r?\n/).length;
         const inline = label.length > 0 &&
             lineCount === 1 &&
             !label.includes('`') &&
             displayWidth(label) <= BACKGROUND_JOB_INLINE_MAX;
         if (inline) {
-            elements.push(markdownDiv(`· \`${label}\``));
+            elements.push(markdownDiv(`· \`${label}\`${tail ? ` · ${tail}` : ''}`));
         }
         else {
             // 多行/超宽/含反引号：代码块保留完整命令；只有超长才折叠。
+            // 命令原文一个字都不改，状态出现在围栏之后。
             const fence = codeFenceFor(label);
-            const content = `${fence}\n${label}\n${fence}`;
+            const content = `${fence}\n${label}\n${fence}${tail ? `\n\n${tail}` : ''}`;
             const fold = lineCount > BACKGROUND_JOB_FOLD_LINES ||
                 displayWidth(label) > BACKGROUND_JOB_FOLD_DISPLAY_MAX;
             elements.push(fold
@@ -1276,6 +1305,9 @@ function buildBackgroundJobsSection(state) {
                 })
                 : markdownDiv(content));
         }
+        // 已结束的任务不再给停止入口——那个按钮点下去只会回「可能已自行结束」。
+        if (job.status === 'ended')
+            return;
         elements.push({
             tag: 'column_set',
             columns: [

package/dist/card/run-state.d.ts

@@ -1,4 +1,4 @@
-import type { AgentEvent, ApprovalView, ToolHint, GoalView } from '../runner/index.js';
+import type { AgentEvent, BackgroundJobRoster, ApprovalView, ToolHint, GoalView } from '../runner/index.js';
 import type { UsageSnapshot } from '../session-contract.js';
 export type RunTerminal = 'running' | 'finalizing' | 'done' | 'error' | 'interrupted' | 'idle_timeout'
 /**
@@ -172,13 +172,11 @@ export interface RunState extends UsageSnapshot {
     /**
      * run 结束时仍在后台运行的任务。跨 turn 生命周期：卡片必须说清楚"这一轮
      * 结束了，但还有东西在跑"，并给出逐个停止的入口。
+     *
+     * 收尾之后这份名单仍会被 `syncBackgroundJobs` 更新（宿主会继续推送任务
+     * 生命周期），所以它是"最后一次观测到的名单"，不是"收尾那一刻的名单"。
      */
-    backgroundJobs?: Array<{
-        id: string;
-        label: string;
-        status?: string;
-        progress?: string;
-    }>;
+    backgroundJobs?: BackgroundJobRoster[];
     /**
      * 会话级长期目标（DSH goal）。跨 turn 生命周期：goal 仍 active 时，本轮结束
      * 只是"一轮结束"，宿主会自动续跑，卡片必须显示目标是什么、跑到第几轮。
@@ -208,5 +206,34 @@ export declare function reduceRunState(state: RunState, event: AgentEvent): RunS
  * 写成「整体重建」，字段一多就会漏带。
  */
 export declare function removeBackgroundJob(state: RunState, jobId: string): RunState;
+/**
+ * 该任务是否仍在跑（`ended` / `unknown` 都不算）。
+ *
+ * 卡片据此决定要不要渲染「⏹ 停止」：给已经结束的任务留一个点了必然失败的
+ * 按钮，等于逼用户拿「停止」当查询用。
+ */
+export declare function isLiveBackgroundJob(job: BackgroundJobRoster): boolean;
+/**
+ * 收尾后把宿主推来的整份任务名单同步进终态卡状态。
+ *
+ * 与 reducer 的分工：reducer 处理的是"收尾那一刻的名单"，只在 run 还在消费
+ * 事件时有效；终态之后 `reduceRunState` 直接早退（终态幂等），名单只能由
+ * 这里更新。
+ *
+ * 三条规则：
+ * - 名单里消失 = 宿主已结算（`job/list` 是整份替换，摘掉即结束）→ `ended`；
+ * - 名单里还在、宿主却给了终态词 → `ended`（有些宿主会把已结束的行留在名单里）；
+ * - `ended` 是终态，不回退成 running —— 同一个 job id 不会重新开始跑。
+ *
+ * 无变化时返回**同一个 state 引用**：bridge 靠它跳过无谓的卡片 patch。
+ */
+export declare function syncBackgroundJobs(state: RunState, roster: ReadonlyArray<BackgroundJobRoster>): RunState;
+/**
+ * 订阅断了但任务仍未结算：把在跑的任务标成「状态未知」。
+ *
+ * 监控中断不等于任务结束——不标出来，卡片又会退化成"最后一次观测当现状"，
+ * 正是这次要修的那个缺陷。未知态仍保留停止按钮（用户还能尝试停掉）。
+ */
+export declare function markBackgroundJobsUnknown(state: RunState): RunState;
 export declare function finishRun(state: RunState, terminal: RunFinalTerminal, meta?: FinishMeta): RunState;
 export {};

package/dist/card/run-state.js

@@ -43,6 +43,16 @@ export function createInitialRunState(runId) {
     };
 }
 export function reduceRunState(state, event) {
+    const next = reduceRunStateInner(state, event);
+    if (next === state)
+        return next;
+    // 每次迁移后归一：**只有最新一条 text 块**免于存储窗口——它是「输出」，
+    // 随时会被提升成最终回答；更早的正文退回进度窗口（内存与元素预算不变）。
+    const blocks = capStaleTextBlocks(next.blocks);
+    return blocks === next.blocks ? next : { ...next, blocks };
+}
+/** 单事件 → 单次状态迁移。窗口后置裁剪统一由 `reduceRunState` 做，这里不管。 */
+function reduceRunStateInner(state, event) {
     // 只有终态才阻止事件处理。finalizing 是非终态，
     // 仍需累积 assistant 内容（thinking、text、tool_use、后台任务输出）。
     const terminal = state.terminal;
@@ -142,14 +152,16 @@ function reduceTurnDiffEvent(state, event) {
         const capped = upsertSnapshotBlock(blocks, (b) => b.kind === 'text' && b.itemId === event.itemId, () => ({
             kind: 'text',
             itemId: event.itemId,
-            content: keepTailMarked(event.text, MAX_TEXT_CHARS),
+            // 最新那条正文不设窗口（它是「输出」），capStaleTextBlocks 负责在它被
+            // 更新的正文顶替后补上进度窗口。
+            content: event.text,
             timestamp: ts,
             ...(complete ? { completedAt: ts } : {}),
         }), (existing) => {
             const textBlock = existing;
             return {
                 ...textBlock,
-                content: keepTailMarked(event.text, MAX_TEXT_CHARS),
+                content: event.text,
                 // kimi：块锚点时间改为本次 diff 时间（整轮累积流不断续写，
                 // 标题应反映“最后写入时刻”而非首见时刻；move-to-end 后位置
                 // 与标题才一致）。codex app-server 不置 refreshTimestamp，
@@ -333,8 +345,10 @@ function reduceResultEvent(state, event) {
     // sessionId is set by system.init; undefined means init hasn't arrived yet.
     if (state.sessionId === undefined)
         return state;
-    const withFinalAnswer = promoteFinalAnswer(state, 'inferred');
     const resultEvent = event;
+    // runner 带过来的完整回答优先于 blocks 里的副本：副本可能是被窗口截过的
+    // （同一 turn 里回答之后又出现过更晚的正文），只能当兜底。
+    const withFinalAnswer = promoteFinalAnswer(state, 'inferred', resultEvent.finalAnswerText);
     const incomingSubtype = event.subtype;
     const incomingErrorMsg = incomingSubtype === 'error' ? (resultEvent.errorMessage ?? 'Agent 返回错误结果') : undefined;
     // 合并 subtype：error 优先，其次 interrupted（任一为 error 即 error；
@@ -385,13 +399,20 @@ function reduceFinalAnswerEvent(state, event) {
  * Agents without an explicit final-answer marker use their last non-empty
  * assistant text block. Moving it out of `blocks` protects it from
  * MAX_BLOCKS and lets the renderer assign it first claim on card space.
+ *
+ * `authoritativeText` 是 runner 在 result 上带来的完整回答（见
+ * `ResultEvent.finalAnswerText`）。blocks 里那条**通常**是完整的最新正文
+ * （见 capStaleTextBlocks），但它可能已被更晚的正文顶替而降级成窗口副本，
+ * 也可能在重连丢帧时缺内容；runner 给的全文优先级更高，是「输出永不截断」
+ * 的主数据源。
  */
-function promoteFinalAnswer(state, source) {
+function promoteFinalAnswer(state, source, authoritativeText) {
     if (state.finalAnswer) {
         return state.finalAnswer.complete
             ? state
             : { ...state, finalAnswer: { ...state.finalAnswer, complete: true } };
     }
+    const fullText = authoritativeText?.trim() ? authoritativeText : undefined;
     for (let i = state.blocks.length - 1; i >= 0; i--) {
         const block = state.blocks[i];
         if (block.kind !== 'text' || !block.content.trim())
@@ -400,13 +421,18 @@ function promoteFinalAnswer(state, source) {
             ...state,
             blocks: state.blocks.filter((_, index) => index !== i),
             finalAnswer: {
-                content: block.content,
+                content: fullText ?? block.content,
                 timestamp: block.timestamp,
                 complete: true,
                 source,
             },
         };
     }
+    // 进度块全被 MAX_BLOCKS 淘汰、只有 runner 全文可用时也要建立 finalAnswer——
+    // 否则长回答的最后一段会连「输出」面板都不存在。
+    if (fullText) {
+        return { ...state, finalAnswer: { content: fullText, complete: true, source } };
+    }
     return state;
 }
 /**
@@ -434,6 +460,95 @@ export function removeBackgroundJob(state, jobId) {
         backgroundJobs: (state.backgroundJobs ?? []).filter((job) => job.id !== jobId),
     };
 }
+/** 宿主仍在执行的任务状态词。状态缺失也算在跑——它还在名单上。 */
+const RUNNING_JOB_STATUSES = new Set(['running', 'stopping']);
+/**
+ * 该任务是否仍在跑（`ended` / `unknown` 都不算）。
+ *
+ * 卡片据此决定要不要渲染「⏹ 停止」：给已经结束的任务留一个点了必然失败的
+ * 按钮，等于逼用户拿「停止」当查询用。
+ */
+export function isLiveBackgroundJob(job) {
+    return job.status === undefined || RUNNING_JOB_STATUSES.has(job.status);
+}
+/** 宿主状态 → 桥侧状态：仍在跑的保留原词，其余已知终态归一成 `ended`。 */
+function bridgeJobStatus(status) {
+    return RUNNING_JOB_STATUSES.has(status) ? status : 'ended';
+}
+/**
+ * 收尾后把宿主推来的整份任务名单同步进终态卡状态。
+ *
+ * 与 reducer 的分工：reducer 处理的是"收尾那一刻的名单"，只在 run 还在消费
+ * 事件时有效；终态之后 `reduceRunState` 直接早退（终态幂等），名单只能由
+ * 这里更新。
+ *
+ * 三条规则：
+ * - 名单里消失 = 宿主已结算（`job/list` 是整份替换，摘掉即结束）→ `ended`；
+ * - 名单里还在、宿主却给了终态词 → `ended`（有些宿主会把已结束的行留在名单里）；
+ * - `ended` 是终态，不回退成 running —— 同一个 job id 不会重新开始跑。
+ *
+ * 无变化时返回**同一个 state 引用**：bridge 靠它跳过无谓的卡片 patch。
+ */
+export function syncBackgroundJobs(state, roster) {
+    const tracked = state.backgroundJobs ?? [];
+    const byId = new Map(roster.map((job) => [job.id, job]));
+    const next = tracked.map((job) => {
+        const row = byId.get(job.id);
+        if (!row)
+            return job.status === 'ended' ? job : { ...job, status: 'ended' };
+        if (job.status === 'ended')
+            return job;
+        const status = row.status === undefined ? job.status : bridgeJobStatus(row.status);
+        const label = row.label.trim() === '' ? job.label : row.label;
+        const progress = row.progress ?? job.progress;
+        if (status === job.status && label === job.label && progress === job.progress)
+            return job;
+        return {
+            ...job,
+            label,
+            ...(status === undefined ? {} : { status }),
+            ...(progress === undefined ? {} : { progress }),
+        };
+    });
+    // 新出现的任务只收仍在跑的：与收尾采集同一口径（列出已结束的任务只会被
+    // 读成"还在跑"）。
+    const seen = new Set(tracked.map((job) => job.id));
+    for (const row of roster) {
+        if (seen.has(row.id))
+            continue;
+        if (row.status !== undefined && !RUNNING_JOB_STATUSES.has(row.status))
+            continue;
+        next.push({
+            id: row.id,
+            label: row.label,
+            ...(row.status === undefined ? {} : { status: row.status }),
+            ...(row.progress === undefined ? {} : { progress: row.progress }),
+        });
+    }
+    if (next.length === tracked.length && next.every((job, index) => job === tracked[index])) {
+        return state;
+    }
+    return { ...state, backgroundJobs: next };
+}
+/**
+ * 订阅断了但任务仍未结算：把在跑的任务标成「状态未知」。
+ *
+ * 监控中断不等于任务结束——不标出来，卡片又会退化成"最后一次观测当现状"，
+ * 正是这次要修的那个缺陷。未知态仍保留停止按钮（用户还能尝试停掉）。
+ */
+export function markBackgroundJobsUnknown(state) {
+    const jobs = state.backgroundJobs;
+    if (!jobs || jobs.length === 0)
+        return state;
+    let changed = false;
+    const next = jobs.map((job) => {
+        if (!isLiveBackgroundJob(job))
+            return job;
+        changed = true;
+        return { ...job, status: 'unknown' };
+    });
+    return changed ? { ...state, backgroundJobs: next } : state;
+}
 /**
  * 运行期状态投影 → 状态行。
  *
@@ -500,12 +615,14 @@ function reduceAssistantEvent(state, event) {
         else if (content.type === 'text') {
             const blocks = markThinkingInactive(next.blocks);
             const last = blocks[blocks.length - 1];
+            // 最新正文原样保留（见 capStaleTextBlocks）：这里一旦按窗口截断，最终回答
+            // 就在进渲染层之前已经缺头，任何「回答优先」的排版都救不回来。
             const newBlocks = last?.kind === 'text'
                 ? [
                     ...blocks.slice(0, -1),
                     {
                         kind: 'text',
-                        content: keepTailMarked(last.content + content.text, MAX_TEXT_CHARS),
+                        content: last.content + content.text,
                         timestamp: last.timestamp ?? event.timestamp,
                     },
                 ]
@@ -513,7 +630,7 @@ function reduceAssistantEvent(state, event) {
                     ...blocks,
                     {
                         kind: 'text',
-                        content: keepTailMarked(content.text, MAX_TEXT_CHARS),
+                        content: content.text,
                         timestamp: event.timestamp,
                     },
                 ];
@@ -758,6 +875,42 @@ function keepLatestBlocks(blocks) {
 }
 /** 截断标记前缀（`keepTailMarked` 产出，含已丢弃正文计数）。 */
 const TRUNCATION_MARKER_RE = /^…（前 (\d+) 字符已省略）\n/;
+/**
+ * 给「已经不再是最新」的 text 块补上 `MAX_TEXT_CHARS` 存储窗口。
+ *
+ * 为什么最新一条不截：它就是卡片上的**输出**，终态还会被 `promoteFinalAnswer`
+ * 提成最终回答。提前按窗口切掉头部，渲染层再怎么回答优先也补不回来（2026-11-01
+ * 输出块被截断缺陷：16074 字符的回答只进到渲染层 12000 字符，且是从中间开始的）。
+ *
+ * 为什么其余 text 块仍然截：它们只是进度信息，卡片本来就只会展示最新几步；
+ * 存储层必须保持有界（`MAX_BLOCKS` × 窗口），否则长 run 的内存随历史线性增长。
+ *
+ * 判定用「最后一次出现的 text 块」而不是「最后一个块」：工具/思考出现在正文之后
+ * 时（例如回答写完再补一次思考），回答仍然是那张卡要展示的输出，不能因此被切。
+ */
+function capStaleTextBlocks(blocks) {
+    let newestText = -1;
+    for (let i = blocks.length - 1; i >= 0; i--) {
+        if (blocks[i].kind === 'text') {
+            newestText = i;
+            break;
+        }
+    }
+    if (newestText < 0)
+        return blocks;
+    let changed = false;
+    const capped = blocks.map((block, index) => {
+        if (index === newestText || block.kind !== 'text')
+            return block;
+        const content = block.content;
+        const windowed = keepTailMarked(content, MAX_TEXT_CHARS);
+        if (windowed === content)
+            return block;
+        changed = true;
+        return { ...block, content: windowed };
+    });
+    return changed ? capped : blocks;
+}
 /**
  * keepTail + 截断标记：被去头的存储内容以前缀如实标注（信息保真红线：禁止静默丢弃）。
  * 标记计入 maxChars 预算（存储总量仍 ≤ maxChars，保持既有长度不变量）。

package/dist/dsh/types.d.ts

@@ -51,6 +51,14 @@ export interface DshSessionSummary {
     running: boolean;
     blank: boolean;
     cwd?: string;
+    /**
+     * `'subagent'` for a session derived by delegation; absent for top-level
+     * sessions. Present since DSH 0.2.x, which lists subagent sessions next to
+     * their parent (same cwd, bare-uuid id, `updatedAt` = delegation end).
+     */
+    origin?: string;
+    /** Parent session of a subagent (absent on top-level sessions). */
+    parentSessionId?: string;
     /** Legacy top-level preset (pre-0.2 DSH). */
     agentPreset?: string;
     /** 0.2.x exposes preset/title through projections. */

package/dist/message-handlers.js

@@ -207,7 +207,9 @@ export function setupMessageHandlers(deps) {
         const actionValue = action.action.value;
         if (!actionValue?.cmd)
             return;
-        logger.info(`card action: ${actionValue.cmd}`);
+        logger.info(actionValue.cmd === 'stop'
+            ? `card action: stop runId=${actionValue.runId ?? '(none)'} messageId=${action.messageId}`
+            : `card action: ${actionValue.cmd}`);
         const userId = action.operator.openId;
         const chatId = action.chatId;
         const messageId = action.messageId;

package/dist/router/index.js

@@ -1319,14 +1319,15 @@ export class CommandRouter {
      * Handle stop card action: interrupt current run.
      */
     async handleCardStop(value, ctx) {
-        if (!value.runId || !ctx.userId || !ctx.chatId) {
+        if (!ctx.userId || !ctx.chatId || (!value.runId && !ctx.messageId)) {
             await this.bridge.sendResult({ text: '⚠️ 无效的停止请求，缺少必要信息' }, ctx);
             return;
         }
         const interrupt = await this.bridge.interruptCurrentRunDetailed({
             userId: ctx.userId,
             chatId: ctx.chatId,
-            runId: value.runId,
+            ...(value.runId ? { runId: value.runId } : {}),
+            cardMessageId: ctx.messageId,
         });
         const stopped = interrupt.stopped;
         // Regression 2026-06-22: card stop button silently no-op'd when the

package/dist/runner/dsh/client.d.ts

@@ -325,13 +325,20 @@ export declare class DshClient {
      */
     controlFrames(signal: AbortSignal): AsyncGenerator<DshProjectionItem>;
     /**
-     * One session's current background-job roster.
+     * Subscribe to one session's background-job roster as a live stream.
      *
-     * `job/list` 是流（生命周期变化时推整份名单），但"此刻有哪些任务在跑"只需
-     * 要第一帧：文档明确首帧就是当前真相（whole-set replacement）。取到即断开，
-     * 不长期持有连接——任务列表只用于收尾时的一句话与停止按钮。
+     * `job/list` 是整份替换流（whole-set replacement）：首帧就是当前真相，之后
+     * 任务生命周期一变就再推一整份。**run 结束之后**必须用这个长订阅——后台任务
+     * 跨 turn 存活，任务结束这件事只会在这条流上出现；收尾时取首帧即断开
+     * （{@link jobRows}）只够画那一瞬间的卡片。
+     */
+    watchJobs(sessionId: string, signal: AbortSignal): AsyncGenerator<DshJobView[]>;
+    /**
+     * One session's current background-job roster (snapshot).
      *
-     * 失败返回 undefined（与"没有任务"区分）：拿不到就别在卡片上写"0 个后台任务"。
+     * "此刻有哪些任务在跑"只需要第一帧：文档明确首帧就是当前真相，取到即断开，
+     * 不长期持有连接。失败返回 undefined（与"没有任务"区分）：拿不到就别在卡片
+     * 上写"0 个后台任务"。
      */
     jobRows(sessionId: string, opts?: {
         signal?: AbortSignal;

package/dist/runner/dsh/client.js

@@ -927,25 +927,35 @@ export class DshClient {
         }
     }
     /**
-     * One session's current background-job roster.
+     * Subscribe to one session's background-job roster as a live stream.
      *
-     * `job/list` 是流（生命周期变化时推整份名单），但"此刻有哪些任务在跑"只需
-     * 要第一帧：文档明确首帧就是当前真相（whole-set replacement）。取到即断开，
-     * 不长期持有连接——任务列表只用于收尾时的一句话与停止按钮。
+     * `job/list` 是整份替换流（whole-set replacement）：首帧就是当前真相，之后
+     * 任务生命周期一变就再推一整份。**run 结束之后**必须用这个长订阅——后台任务
+     * 跨 turn 存活，任务结束这件事只会在这条流上出现；收尾时取首帧即断开
+     * （{@link jobRows}）只够画那一瞬间的卡片。
+     */
+    async *watchJobs(sessionId, signal) {
+        for await (const frame of this.muxStream('job/list', { args: dshArgs('job/list', { sessionId }) }, signal)) {
+            const rows = frame;
+            if (rows?.type !== 'rows')
+                continue;
+            yield Array.isArray(rows.jobs) ? rows.jobs : [];
+        }
+    }
+    /**
+     * One session's current background-job roster (snapshot).
      *
-     * 失败返回 undefined（与"没有任务"区分）：拿不到就别在卡片上写"0 个后台任务"。
+     * "此刻有哪些任务在跑"只需要第一帧：文档明确首帧就是当前真相，取到即断开，
+     * 不长期持有连接。失败返回 undefined（与"没有任务"区分）：拿不到就别在卡片
+     * 上写"0 个后台任务"。
      */
     async jobRows(sessionId, opts = {}) {
         const timer = new AbortController();
         const timeout = setTimeout(() => timer.abort(), opts.timeoutMs ?? 2_000);
         const signal = opts.signal ? AbortSignal.any([opts.signal, timer.signal]) : timer.signal;
         try {
-            for await (const frame of this.muxStream('job/list', { args: dshArgs('job/list', { sessionId }) }, signal)) {
-                const rows = frame;
-                if (rows?.type === 'rows') {
-                    return Array.isArray(rows.jobs) ? rows.jobs : [];
-                }
-            }
+            for await (const rows of this.watchJobs(sessionId, signal))
+                return rows;
             return undefined;
         }
         catch (err) {