lark-remote 0.5.17 → 0.5.18

package/CHANGELOG.md

@@ -5,6 +5,22 @@ 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.18] - 2026-11-02
+
+### 修复
+
+- **超长最终回答不再在卡片里被拦腰截断**：运行卡的状态层对正文有 12,000 字符的窗口，此前这个窗口对**最新一条**正文同样生效，超出窗口的回答只剩尾部一截、还从句子中间开始。现在最新一条正文不设窗口（它就是要展示的输出），只有被更晚的正文顶替之后才按窗口截断留痕；回合结束时优先采用运行器手里的完整正文——DSH 在回合结束交出整条 assistant 消息，不依赖增量拼接，重连丢帧也不缺头。六个 agent 各用自己的真实转换器回放同一篇超长回答做回归
+- **表格超限不再被误判成「卡片装不下」而重复补发完整回答**：最终回答里的表格超过单卡上限时，渲染器只是省略最旧的几张并在原位留一句提示，正文其实完整地画在了卡上；此前这句提示被当成溢出信号，卡片照常渲染正文之外又补发一条「完整回答」，同一篇回答用户看到两遍。现在正文仍在卡内一律按「完整」上报，只有正文真被占位替代时才走补发通道
+- **DSH 自动恢复不再选中子 agent 派生会话**：DSH 0.2.x 把子 agent 派生的会话也列进会话列表（同一个工作目录、更新时间取委托结束时刻，常比父会话还新），按「最新会话」自动恢复于是选中了它；这类会话不接受按顶层会话寻址，读取被服务端拒绝后又被吞成空事件——切换工作目录后的恢复卡只剩一行标题，还绑在一个续跑不了的会话上，下一条消息必然报错。现在列表与寻址统一排除这类会话（判定只认来源标记：会话 id 的形态和父会话字段都会误伤正常会话）
+
+### 变更
+
+- **完整回答溢出改走 Markdown 文件，最终回答不再发纯文本**：正文装不进一张卡时，把完整回答逐字写成临时 `.md` 文件随卡片发出，发送后尽力清理；卡上的提示改为「完整内容见随附的 Markdown 文件」。原先拆成「完整回答（1/N）」多条纯文本有两个硬伤：与卡片正文重复，且丢掉表格与代码块结构。文件发送失败时只发提示卡，并在日志里留落盘路径
+
+### 维护
+
+- **用例头注释不再点名已删除的测试文件**：15 个锚点用例头部的「合并自 …」列的是早前测试收敛时删掉的旧文件名，读者按名去找会落到不存在的路径；只保留「本文件覆盖什么」，需要指路的改指向仍然存在的共享 fixture。无行为变化
+
 ## [0.5.17] - 2026-11-01
 
 ### 维护

package/dist/bridge/index.d.ts

@@ -373,11 +373,14 @@ export declare class Bridge {
     /** Send a result message to the user (§7). Returns true on success, false on failure. */
     sendResult(result: CommandResult, ctx: CommandContext): Promise<boolean>;
     /**
-     * Deliver a final answer that cannot fit in the run card. Plain text avoids
-     * markdown parser limits and preserves every character; sequence labels make
-     * multi-message delivery unambiguous.
+     * Deliver a final answer that cannot fit in the run card as a Markdown file
+     * attachment. 卡片正文已被标记替代，文件是唯一的内容通道；此处绝不发纯文本
+     * （2026-11-02 定规：纯文本与卡片重复，也丢 Markdown 结构）。
+     *
+     * 失败时发一张提示卡（不是纯文本），并把完整回答留在临时文件里记日志，
+     * 便于事后找回。
      */
-    private sendFinalAnswerOverflow;
+    private sendFinalAnswerFile;
     /**
      * Update an existing card in place (原地更新) instead of sending a new one.
      *

package/dist/bridge/index.js

@@ -5,7 +5,8 @@ import { resolveFinalUsage, errorMessage } from './final-usage.js';
 import { getLogger } from '../logger/index.js';
 import { RunCardSession } from '../card/run-card-session.js';
 import { renderRunCard, renderRunCardDetailed, } from '../card/run-renderer.js';
-import { splitFinalAnswer } from '../card/final-answer-overflow.js';
+import { writeFinalAnswerFile, finalAnswerFileFailureCard } from '../card/final-answer-file.js';
+import { bestEffortUnlink } from '../common/fs.js';
 import { renderBashCard } from '../card/bash-renderer.js';
 import { BashCardSession, capBashOutput } from '../card/bash-card-session.js';
 import { isRunActive, isRunTerminal, removeBackgroundJob, } from '../card/run-state.js';
@@ -842,26 +843,26 @@ export class Bridge {
         }
     }
     /**
-     * Deliver a final answer that cannot fit in the run card. Plain text avoids
-     * markdown parser limits and preserves every character; sequence labels make
-     * multi-message delivery unambiguous.
+     * Deliver a final answer that cannot fit in the run card as a Markdown file
+     * attachment. 卡片正文已被标记替代，文件是唯一的内容通道；此处绝不发纯文本
+     * （2026-11-02 定规：纯文本与卡片重复，也丢 Markdown 结构）。
+     *
+     * 失败时发一张提示卡（不是纯文本），并把完整回答留在临时文件里记日志，
+     * 便于事后找回。
      */
-    async sendFinalAnswerOverflow(text, ctx) {
-        const chunks = splitFinalAnswer(text);
+    async sendFinalAnswerFile(text, ctx) {
+        let filePath;
         try {
-            for (let i = 0; i < chunks.length; i++) {
-                const prefix = chunks.length > 1 ? `完整回答（${i + 1}/${chunks.length}）\n\n` : '完整回答\n\n';
-                await this.connector.sendWithRetry(ctx.chatId, { text: prefix + chunks[i] }, { replyTo: ctx.messageId });
-            }
+            filePath = writeFinalAnswerFile(text);
+            await this.connector.sendFile(ctx.chatId, filePath);
         }
         catch (err) {
-            getLogger().error('[lark-remote] failed to deliver complete final answer:', err);
-            try {
-                await this.connector.sendWithRetry(ctx.chatId, { text: `⚠️ 完整回答补发失败：${errorMessage(err)}` }, { replyTo: ctx.messageId });
-            }
-            catch (fallbackErr) {
-                getLogger().error('[lark-remote] final-answer failure notice also failed:', fallbackErr);
-            }
+            getLogger().error(`[lark-remote] failed to deliver complete final answer as file (kept at ${filePath ?? 'not written'}):`, err);
+            await this.sendResult({ card: finalAnswerFileFailureCard(errorMessage(err)) }, ctx);
+        }
+        finally {
+            if (filePath)
+                bestEffortUnlink(filePath);
         }
     }
     /**
@@ -1613,7 +1614,7 @@ export class Bridge {
                 await this.sendCompletionNotificationCard(sessionId, cwd, ctx, activeRun.agentKind, cardSession.currentState.terminal);
             }
             if (finalRender.finalAnswerStatus === 'overflow' && finalRender.finalAnswerText) {
-                await this.sendFinalAnswerOverflow(finalRender.finalAnswerText, ctx);
+                await this.sendFinalAnswerFile(finalRender.finalAnswerText, ctx);
             }
             // Add a terminal-state emoji reaction to the user's original message
             this.finishTurnReactions(ctx, terminalReactionEmoji(cardSession.currentState.terminal));

package/dist/card/final-answer-file.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 把完整回答写进系统临时目录里的 `.md` 文件，返回绝对路径。
+ *
+ * 文件名带时间戳与随机后缀：同一分钟内的多个 run 不会互相覆盖，也不会在
+ * 飞书里显示成同名附件。内容逐字写入，不做任何截断或转义。
+ */
+export declare function writeFinalAnswerFile(text: string, now?: Date): string;
+/** 文件通道失败时的提示卡——终态反馈也只走卡片，不发纯文本。 */
+export declare function finalAnswerFileFailureCard(message: string): object;

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-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

@@ -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,

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;
 }
 /**
@@ -500,12 +526,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 +541,7 @@ function reduceAssistantEvent(state, event) {
                     ...blocks,
                     {
                         kind: 'text',
-                        content: keepTailMarked(content.text, MAX_TEXT_CHARS),
+                        content: content.text,
                         timestamp: event.timestamp,
                     },
                 ];
@@ -758,6 +786,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/runner/dsh/translator.d.ts

@@ -36,6 +36,14 @@ export declare class DshTranslator {
     private hasStreamUsage;
     /** 当前 attempt 的 id（start 帧携带，chunk 帧也带；断开重连重放时不变）。 */
     private attemptId;
+    /**
+     * 本 turn 末条 durable assistant 消息的正文（**完整**、未截断）。
+     *
+     * live chunk 是逐 delta 拼接、会被状态层的 MAX_TEXT_CHARS 窗口截断；
+     * durable `assistant/message` 一次就到齐全文。收 turn 时把它挂在 result 上，
+     * 卡片才能渲染完整回答（2026-11-01 输出块被截断缺陷）。
+     */
+    private lastMessageText?;
     /** Translate one live assistant-stream chunk into AgentEvents. */
     streamFrameToAgentEvents(frame: DshAssistantStreamFrame, _sessionId: string): AgentEvent[];
     /**

package/dist/runner/dsh/translator.js

@@ -34,6 +34,14 @@ export class DshTranslator {
     hasStreamUsage = false;
     /** 当前 attempt 的 id（start 帧携带，chunk 帧也带；断开重连重放时不变）。 */
     attemptId = '0';
+    /**
+     * 本 turn 末条 durable assistant 消息的正文（**完整**、未截断）。
+     *
+     * live chunk 是逐 delta 拼接、会被状态层的 MAX_TEXT_CHARS 窗口截断；
+     * durable `assistant/message` 一次就到齐全文。收 turn 时把它挂在 result 上，
+     * 卡片才能渲染完整回答（2026-11-01 输出块被截断缺陷）。
+     */
+    lastMessageText;
     /** Translate one live assistant-stream chunk into AgentEvents. */
     streamFrameToAgentEvents(frame, _sessionId) {
         if (frame.type === 'start') {
@@ -116,6 +124,10 @@ export class DshTranslator {
                 if (raw && typeof raw === 'object') {
                     this.recordMessageUsage(raw);
                 }
+                // 每条 durable 消息都带完整正文；记最后一条非空的就是本轮回答。
+                const text = messageText(ev.data.message);
+                if (text.trim())
+                    this.lastMessageText = text;
                 return [];
             }
             case 'tool/call': {
@@ -188,6 +200,9 @@ export class DshTranslator {
                         ? `turn ended with reason: ${reason}: ${detail}`
                         : `turn ended with reason: ${reason}`;
                 }
+                if (this.lastMessageText) {
+                    result.finalAnswerText = this.lastMessageText;
+                }
                 return [result];
             }
             default:
@@ -214,6 +229,27 @@ function parseToolArguments(raw) {
         return trimmed;
     }
 }
+/**
+ * 取 `assistant/message.message.content` 里的正文（type==='text' 的块）。
+ *
+ * 只收 text 块：reasoning 走独立面板（且另有 4000 字符窗口），tool-call 由
+ * `tool/call` 事件承载。块之间直接拼接、不插分隔符——同一条消息里的多个 text
+ * 块本来就是一段连续回答。
+ */
+function messageText(message) {
+    const content = message?.content;
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const block of content) {
+        if (!block || typeof block !== 'object')
+            continue;
+        const rec = block;
+        if (rec.type === 'text' && typeof rec.text === 'string')
+            parts.push(rec.text);
+    }
+    return parts.join('');
+}
 /**
  * Flatten a `tool/result.message.content` block list into display text.
  *

package/dist/runner/types.d.ts

@@ -294,6 +294,17 @@ export interface ResultEvent {
     subtype: 'success' | 'error' | 'interrupted';
     session_id: string;
     timestamp?: string;
+    /**
+     * 本 run 的权威最终回答全文（runner 手里有一份完整文本时才填）。
+     *
+     * 为什么必须由 runner 带过来：状态层对进度正文有 `MAX_TEXT_CHARS`（12000
+     * 字符）存储窗口，最终回答超过窗口时 blocks 里只剩尾部 + `…（前 N 字符已
+     * 省略）` 标记——渲染层再怎么「回答优先」也找不回被丢掉的头部。runner 在
+     * 收 turn 时拿到的是**完整** assistant 文本（一条消息，不是逐 delta 拼接），
+     * 把它挂在 result 上，`promoteFinalAnswer` 用它建立 finalAnswer，回答因此
+     * 不再被进度窗口截断（2026-11-01 卡片输出块被截断缺陷）。
+     */
+    finalAnswerText?: string;
     usage?: {
         /** Non-cached input tokens. For codex this is raw `input_tokens` minus
          *  `cached_input_tokens`; for pi/claude/opencode the raw value is already

package/dist/session/dsh/sessions.d.ts

@@ -7,8 +7,8 @@
  * — a synchronous HTTP round-trip to the local DSH host. This keeps the
  * router/bridge interface contract intact without touching any upstream logic.
  *
- * listSessions: session/list → filter by cwd → sort by updatedAt desc → local
- *   pagination (DSH v1 has no cursor pagination).
+ * listSessions: session/list → 排除 subagent 派生会话 → filter by cwd → sort by
+ *   updatedAt desc → local pagination (DSH v1 has no cursor pagination).
  * readSessionContent: session/projections → session/page → map SessionEvents +
  *   session-wide usage accumulation (assistant/message.usage)；本 run 的 flow
  *   字段 = 末个 turn（turn/start–turn/end）内所有采样之和，与 codex 同口径。
@@ -77,6 +77,11 @@ export declare class DshSessionReader implements AgentSessionReader {
      * Find the session row in `session/list` that matches BOTH id and cwd.
      * Returns undefined when the id belongs to another workspace (or is unknown) —
      * every caller treats that as "not usable here".
+     *
+     * subagent 派生会话也排除：它的 id + cwd 都能命中，但只能按
+     * `{kind:'subagent', parentSessionId, childSessionId}` 寻址，按顶层会话读会被
+     * 服务端拒绝（session/agent-busy）。在这里统一 fail-closed，比让每个调用方
+     * 各自吃一次拒绝异常更省事（那异常会被 catch 成空事件列表 = 一张空卡）。
      */
     private resolveSession;
     /** `session/page` needs an inclusive cursor; projections carry the watermark. */

package/dist/session/dsh/sessions.js

@@ -7,8 +7,8 @@
  * — a synchronous HTTP round-trip to the local DSH host. This keeps the
  * router/bridge interface contract intact without touching any upstream logic.
  *
- * listSessions: session/list → filter by cwd → sort by updatedAt desc → local
- *   pagination (DSH v1 has no cursor pagination).
+ * listSessions: session/list → 排除 subagent 派生会话 → filter by cwd → sort by
+ *   updatedAt desc → local pagination (DSH v1 has no cursor pagination).
  * readSessionContent: session/projections → session/page → map SessionEvents +
  *   session-wide usage accumulation (assistant/message.usage)；本 run 的 flow
  *   字段 = 末个 turn（turn/start–turn/end）内所有采样之和，与 codex 同口径。
@@ -198,6 +198,7 @@ export class DshSessionReader {
             const value = this.unary('session/list', {});
             const items = value.items ?? [];
             const filtered = items
+                .filter((i) => !isSubagentSession(i))
                 .filter((i) => i.cwd !== undefined && samePath(i.cwd, cwd))
                 .map((i) => ({
                 sessionId: String(i.sessionId),
@@ -374,10 +375,18 @@ export class DshSessionReader {
      * Find the session row in `session/list` that matches BOTH id and cwd.
      * Returns undefined when the id belongs to another workspace (or is unknown) —
      * every caller treats that as "not usable here".
+     *
+     * subagent 派生会话也排除：它的 id + cwd 都能命中，但只能按
+     * `{kind:'subagent', parentSessionId, childSessionId}` 寻址，按顶层会话读会被
+     * 服务端拒绝（session/agent-busy）。在这里统一 fail-closed，比让每个调用方
+     * 各自吃一次拒绝异常更省事（那异常会被 catch 成空事件列表 = 一张空卡）。
      */
     resolveSession(sessionId, cwd) {
         const value = this.unary('session/list', {});
-        return (value.items ?? []).find((i) => String(i.sessionId) === sessionId && i.cwd !== undefined && samePath(i.cwd, cwd));
+        return (value.items ?? []).find((i) => !isSubagentSession(i) &&
+            String(i.sessionId) === sessionId &&
+            i.cwd !== undefined &&
+            samePath(i.cwd, cwd));
     }
     /** `session/page` needs an inclusive cursor; projections carry the watermark. */
     resolveThroughSeq(sessionId, known) {
@@ -387,6 +396,18 @@ export class DshSessionReader {
         return typeof known.projections?.asOfSeq === 'number' ? known.projections.asOfSeq : -1;
     }
 }
+/**
+ * subagent 派生会话判定（DSH 0.2.x 起与顶层会话并列在 `session/list` 里）。
+ *
+ * 只认 `origin === 'subagent'`，别用更"顺手"的两个信号：
+ * - **id 前缀**：顶层是 `session-<uuid>`、subagent 是裸 `<uuid>`，但 v0 老会话
+ *   也是裸 uuid 且能正常读（`delegationDepth: 0`、无 `origin`）；
+ * - **`parentSessionId` 非空**：fork 与 `session-btw-*` 旁支同样带 parent，却是
+ *   可恢复的顶层会话。
+ */
+function isSubagentSession(item) {
+    return item.origin === 'subagent';
+}
 /** Preset moved from the summary top level to projections in DSH 0.2.x. */
 function sessionPreset(item) {
     const preset = item.projections?.values?.agentPreset ?? item.agentPreset;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lark-remote",
-  "version": "0.5.17",
+  "version": "0.5.18",
   "description": "Feishu (Lark) private-chat bridge to local coding agents — Claude Code / Codex / opencode / pi / kimi, with live-streaming CardKit 2.0 cards",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/card/final-answer-overflow.d.ts

@@ -1 +0,0 @@
-export declare function splitFinalAnswer(text: string, maxBytes?: number): string[];

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

@@ -1,46 +0,0 @@
-/**
- * Split an authoritative final answer into plain-text messages without losing
- * any content. Feishu cards have a hard size budget; a long answer must spill
- * rather than being silently truncated inside the progress card.
- */
-const FINAL_ANSWER_CHUNK_BYTES = 20_000;
-export function splitFinalAnswer(text, maxBytes = FINAL_ANSWER_CHUNK_BYTES) {
-    if (!text || maxBytes <= 0)
-        return text ? [text] : [];
-    const chunks = [];
-    let rest = text;
-    let remainingBytes = Buffer.byteLength(rest, 'utf8');
-    while (remainingBytes > maxBytes) {
-        let bytes = 0;
-        let end = 0;
-        let lastNewline = 0;
-        for (const char of rest) {
-            const charBytes = Buffer.byteLength(char, 'utf8');
-            if (bytes + charBytes > maxBytes)
-                break;
-            bytes += charBytes;
-            end += char.length;
-            if (char === '\n')
-                lastNewline = end;
-        }
-        if (end === 0) {
-            // A caller can choose a byte limit smaller than one codepoint. Keep one
-            // codepoint per chunk rather than looping forever with a zero-length cut.
-            const first = Array.from(rest)[0];
-            chunks.push(first);
-            rest = rest.slice(first.length);
-            remainingBytes -= Buffer.byteLength(first, 'utf8');
-            continue;
-        }
-        // Prefer a paragraph/line boundary when it does not waste most of a chunk.
-        const cut = lastNewline > 0 && lastNewline >= Math.floor(end * 0.6) ? lastNewline : end;
-        const chunk = rest.slice(0, cut);
-        chunks.push(chunk);
-        rest = rest.slice(cut);
-        remainingBytes -= Buffer.byteLength(chunk, 'utf8');
-    }
-    if (rest)
-        chunks.push(rest);
-    return chunks;
-}
-//# sourceMappingURL=final-answer-overflow.js.map