@modesto_ma/dsh-channels 0.2.0 → 0.4.0

package/src/settings/surface.ts

@@ -47,8 +47,15 @@ import type {
   SaveCredentialsResponse,
 } from './contract.ts'
 import {
+  configValueOf,
+  deleteOverlayKey,
+  mergeOverlay,
+  mergeOverlayPatch,
+  overlayValueOf,
+  overlayValues,
   parseOverlay,
   pickEditable,
+  setOverlayValue,
 } from './overlay.ts'
 import type { OverlayLogger, OverlayPatch, OverlayStore } from './overlay.ts'
 import type { SettingsCatalog } from './catalog.ts'
@@ -79,7 +86,7 @@ export interface SettingsTarget {
   configSnapshot(): FeishuConfig
   baseConfigSnapshot(): FeishuConfig
   runningConfigSnapshot(): FeishuConfig | undefined
-  applyOverlay(overlay: Partial<FeishuConfig>): void
+  applyOverlay(overlay: OverlayPatch): void
   restart(): Promise<void>
   credentialStates(): Promise<{ appId: CredentialInfo; appSecret: CredentialInfo }>
   setCredential(field: CredentialField, value: string): Promise<void>
@@ -125,10 +132,17 @@ const BOOLEAN_KEYS = new Set<EditableKey>([
   'welcomeOnboarding',
   'allowPermissionSwitch',
   'acceptAttachments',
+  'prefetchImages',
   'workspaceRetentionAuto',
+  'feishuTools.attachmentFetch',
+  'feishuTools.topicMessages',
 ])
 
 const SELECT_OPTIONS: Partial<Record<EditableKey, ReadonlyArray<{ value: string; label: string }>>> = {
+  attachmentStore: [
+    { value: 'native', label: 'DSH 原生附件库（默认）' },
+    { value: 'archive', label: '工作区 attachments/（旧版）' },
+  ],
   dmMode: [
     { value: 'open', label: '开放私聊' },
     { value: 'disabled', label: '禁用私聊' },
@@ -160,7 +174,7 @@ const SELECT_OPTIONS: Partial<Record<EditableKey, ReadonlyArray<{ value: string;
 const FIELD_META: Record<EditableKey, { label: string; help: string; min?: number; max?: number; step?: number; placeholder?: string; wide?: boolean }> = {
   baseDir: {
     label: '工作区根目录（文件落点）',
-    help: '每个飞书话题拥有独立工作区：私聊 <baseDir>/topics/p2p/<open_id>/<topic>/，群聊 <baseDir>/topics/groups/<chat_id>/<open_id>/<topic>/（topic 来自话题 id）。必须是绝对路径（~ 开头按家目录展开），保存时会创建该目录；只影响之后新建立的工作区 —— 已有话题即使 /renew 也沿用原工作区，旧文件不会迁移。',
+    help: '每个用户/群成员一个工作区：私聊 <baseDir>/p2p/<open_id>/，群聊 <baseDir>/groups/<chat_id>/<open_id>/；每个话题在其中拥有独立工作目录 <工作区>/topics/<话题>/（Git 仓库工作区可自动改用 worktree）。必须是绝对路径（~ 开头按家目录展开），保存时会创建该目录；只影响之后新建立的会话 —— 已有话题即使 /renew 也沿用原目录，旧文件不会迁移。',
     placeholder: '/Users/you/.dsh/dsh-channels/workspaces',
     wide: true,
   },
@@ -185,9 +199,104 @@ const FIELD_META: Record<EditableKey, { label: string; help: string; min?: numbe
     max: 30,
     step: 1,
   },
-  acceptAttachments: { label: '接收并保存附件', help: '接收飞书图片、文件与合并转发记录，保存到工作区的 attachments/ 目录；模型不会自动读取，需要时用文件工具自行查看。关闭后附件消息不保存、不触发回复。' },
-  workspaceRetention: { label: '过期工作区保留期', help: '超过所选天数没有活动的飞书工作区会进入下方「工作区清理」列表；「关闭」表示永不删除。DSH 会话日志不受影响。' },
-  workspaceRetentionAuto: { label: '自动执行工作区清理', help: '开启后插件在启动时及每天执行一次过期工作区清理；关闭时只能在下方卡片手动清理。开启前请确认保留期已设置。' },
+  acceptAttachments: {
+    label: '接收入站附件',
+    help: '接收飞书图片、文件与合并转发记录。native（默认）下入站附件存入 DSH 原生附件库：触发消息的图片预取进首轮、文件保持懒取，纯附件消息静默登记元数据；archive 下按旧版行为下载到工作区 attachments/。关闭后附件消息不保存、不触发模型、也不登记。',
+  },
+  attachmentStore: {
+    label: '入站附件存储后端',
+    help: 'native（默认）：图片与文件存入 DSH 原生附件库（不可变、内容寻址去重、读取校验、随 Session 回放；不自动清理）。archive：旧版下载到话题工作区 attachments/（可清理但会阻塞会话）。宿主未挂载附件服务时 native 自动降级 archive。',
+  },
+  prefetchImages: {
+    label: '预取触发消息的图片',
+    help: 'native 下把触发消息的图片预取为首轮 ImageBlock，会话/话题/卡片不等下载；失败、超限或超时的图片降级为清单中的懒取项。关闭后图片也需用 feishu_attachment_fetch 获取。',
+  },
+  prefetchTimeoutMs: {
+    label: '图片预取整段超时（ms）',
+    help: '一次触发消息图片预取的总超时（默认 10000 ms，100–120000）；到期后已取回的图片保留，其余降级为清单，不阻塞回合。',
+    min: 100,
+    max: 120_000,
+    step: 100,
+  },
+  prefetchImageMaxBytes: {
+    label: '单张预取图片上限（字节）',
+    help: '单张图片超过该字节数即不入首轮图片、留在清单懒取（默认 20971520 = 20 MiB）。',
+    min: 1,
+    max: 200 * 1024 * 1024,
+    step: 1,
+  },
+  prefetchTotalMaxBytes: {
+    label: '单次预取总量上限（字节）',
+    help: '一次触发消息图片预取的总字节预算（默认 52428800 = 50 MiB）；用尽后剩余图片降级为清单懒取。',
+    min: 1,
+    max: 1024 * 1024 * 1024,
+    step: 1,
+  },
+  historyBootstrapLimit: {
+    label: '首轮话题历史条数',
+    help: '新 Session 首轮自动附带本话题最近 N 条消息摘要（0 = 关闭，上限 20）；被动读取使用短预算，缺权限/失败时静默省略。更早的消息用 feishu_topic_messages 工具翻页。',
+    min: 0,
+    max: 20,
+    step: 1,
+  },
+  pendingAttachmentTtlMs: {
+    label: '静默附件登记有效期（ms）',
+    help: '纯附件/未触发消息只登记元数据（不下载）。超过该时长的登记由周期 GC 清除；0 = 不按时间清理（每个 scope 仍有容量上限）。默认 604800000 = 7 天。',
+    min: 0,
+    step: 1,
+  },
+  pendingAttachmentLimit: {
+    label: '静默附件登记容量（每个 scope）',
+    help: '每个 (会话, 话题, 发送者) scope 最多保留的登记条数（1–100）；超出时淘汰该 scope 最旧的一条。',
+    min: 1,
+    max: 100,
+    step: 1,
+  },
+  promptContextTimeoutMs: {
+    label: '被动读取预算（ms）',
+    help: '引用摘录与首轮话题历史这类被动 prompt 增强的整段预算（默认 3000 ms，100–10000）；超时即省略对应块、回合照跑。模型主动调用工具的读取超时另由 feishu_tools 超时控制。',
+    min: 100,
+    max: 10_000,
+    step: 100,
+  },
+  'feishuTools.attachmentFetch': {
+    label: '启用 feishu_attachment_fetch 工具',
+    help: '让模型按 message_id/file_key 懒取已授权消息的图片/文件。关闭后文件无法懒取，插件整体回退 archive 后端（入站文件直接下载到工作区）。对新会话生效。',
+  },
+  'feishuTools.attachmentFetchMaxResources': {
+    label: '单次取回资源数上限',
+    help: '一次工具调用最多取回的附件数量（默认 10，1–50）；超出会返回可读原因，模型可按 file_key 拆分重试。',
+    min: 1,
+    max: 50,
+    step: 1,
+  },
+  'feishuTools.attachmentFetchMaxBytes': {
+    label: '单次取回字节预算（字节）',
+    help: '一次工具调用的总下载字节预算（默认 104857600 = 100 MiB）；文件流式写入原生库，不整文件缓冲。',
+    min: 1,
+    max: 1024 * 1024 * 1024,
+    step: 1,
+  },
+  'feishuTools.attachmentFetchTimeoutMs': {
+    label: '单次取回超时（ms）',
+    help: '一次 feishu_attachment_fetch 的整段超时（默认 120000 ms，1000–600000）；到期取消下载并逐项报告可读原因。',
+    min: 1_000,
+    max: 600_000,
+    step: 1_000,
+  },
+  'feishuTools.topicMessages': {
+    label: '启用 feishu_topic_messages 工具',
+    help: '让模型按需读取引用消息与话题内更早的消息/附件。关闭只影响模型工具；被动的引用摘录与首轮历史仍由 historyBootstrapLimit 控制。',
+  },
+  'feishuTools.topicMessagesTimeoutMs': {
+    label: '单次话题读取超时（ms）',
+    help: '一次 feishu_topic_messages 的整段超时（默认 20000 ms，1000–120000）；被动摘录使用独立的短预算。',
+    min: 1_000,
+    max: 120_000,
+    step: 1_000,
+  },
+  workspaceRetention: { label: '过期目录保留期', help: '只清理工作区与 Agent 产物目录，不影响 Session 附件：默认 native 存储下附件在 DSH 原生附件库，不参与目录清理；仅当显式使用 archive 后端时，附件副本位于话题目录、会随目录清理。用户工作区本身永不删除，DSH 会话日志不受影响。' },
+  workspaceRetentionAuto: { label: '自动执行目录清理', help: '开启后插件在启动时及每天执行一次过期目录清理；关闭时只能在下方卡片手动清理。开启前请确认保留期已设置；清理只清理工作区与 Agent 产物目录，不影响 Session 附件。' },
   provider: { label: '模型服务商', help: '留空 = 使用部署默认；例如 deepseek-official。', placeholder: '留空 = 部署默认' },
   model: { label: '模型 id', help: '留空 = 使用部署默认；例如 deepseek-v4-flash。', placeholder: '留空 = 部署默认' },
   reasoningEffort: { label: '推理档位', help: '模型声明的精确档位 id（如 high / max）；留空 = 适配器默认。', placeholder: '留空 = 适配器默认' },
@@ -210,6 +319,21 @@ const GROUP_OF: Record<EditableKey, EditableFieldWire['group']> = {
   accessMode: 'access',
   authRequestTtlDays: 'access',
   acceptAttachments: 'content',
+  attachmentStore: 'content',
+  prefetchImages: 'content',
+  prefetchTimeoutMs: 'content',
+  prefetchImageMaxBytes: 'content',
+  prefetchTotalMaxBytes: 'content',
+  historyBootstrapLimit: 'content',
+  pendingAttachmentTtlMs: 'content',
+  pendingAttachmentLimit: 'content',
+  promptContextTimeoutMs: 'tools',
+  'feishuTools.attachmentFetch': 'tools',
+  'feishuTools.attachmentFetchMaxResources': 'tools',
+  'feishuTools.attachmentFetchMaxBytes': 'tools',
+  'feishuTools.attachmentFetchTimeoutMs': 'tools',
+  'feishuTools.topicMessages': 'tools',
+  'feishuTools.topicMessagesTimeoutMs': 'tools',
   provider: 'model',
   model: 'model',
   reasoningEffort: 'model',
@@ -403,6 +527,14 @@ export function normalizeAccessName(
 /** Build the read-only advanced card from the effective config. */
 export function readOnlyFields(config: FeishuConfig): ReadOnlyFieldWire[] {
   return [
+    {
+      key: 'topicIsolation',
+      label: '话题目录隔离',
+      value: config.topicIsolation === 'auto'
+        ? '自动（Git 仓库用 worktree，否则普通子目录）'
+        : config.topicIsolation === 'worktree' ? 'Git worktree（失败回退子目录）' : '普通子目录',
+      help: '每个话题的独立工作目录形式；在 profile 配置里用 topicIsolation 设置（auto / subdir / worktree）。',
+    },
     { key: 'routeTtlMs', label: '话题路由过期', value: formatDays(config.routeTtlMs), help: '超期话题的后续消息会被明确拒绝，而不是新建 Context-free Session。' },
     { key: 'approvalTimeoutMs', label: '审批卡片等待', value: formatSeconds(config.approvalTimeoutMs) },
     { key: 'questionTimeoutMs', label: '提问卡片等待', value: formatSeconds(config.questionTimeoutMs) },
@@ -528,9 +660,11 @@ export class SettingsSurface {
     const effective = this.target.configSnapshot()
     const overlay = await this.store.load()
     const running = this.target.runningConfigSnapshot()
-    const overriddenKeys = EDITABLE_KEYS.filter(key => overlay[key] !== undefined)
+    const overriddenKeys = EDITABLE_KEYS.filter(
+      key => overlayValueOf(overlay as Record<string, unknown>, key) !== undefined,
+    )
     const restartPendingKeys = this.target.isRunning() && running !== undefined
-      ? RESTART_KEYS.filter(key => effective[key] !== running[key])
+      ? RESTART_KEYS.filter(key => configValueOf(effective, key) !== configValueOf(running, key))
       : []
     const catalog = await this.catalogFor(effective.provider, effective.model)
     const fields = withDirectoryBrowse(
@@ -569,7 +703,7 @@ export class SettingsSurface {
     try {
       cleanup = await this.target.cleanupPreview()
     } catch (error) {
-      this.logger?.warn?.('dsh-channels: 工作区清理预览失败：%s', messageOf(error))
+      this.logger?.warn?.('dsh-channels: 目录清理预览失败：%s', messageOf(error))
       cleanup = {
         retention: effective.workspaceRetention,
         auto: effective.workspaceRetentionAuto,
@@ -603,7 +737,7 @@ export class SettingsSurface {
       config: {
         base: pickEditable(base) as Record<string, ConfigValue | undefined>,
         effective: pickEditable(effective) as Record<string, ConfigValue | undefined>,
-        overlay: overlay as EditableValues,
+        overlay: overlayValues(overlay),
         overriddenKeys,
         restartPendingKeys,
         fields,
@@ -633,7 +767,7 @@ export class SettingsSurface {
         clearedKeys.push(key)
         continue
       }
-      raw[key] = value
+      setOverlayValue(raw, key, value)
     }
 
     const parsed = parseOverlay(raw)
@@ -662,9 +796,8 @@ export class SettingsSurface {
 
     let merged: OverlayPatch
     try {
-      merged = { ...await this.store.load() }
-      for (const key of clearedKeys) delete merged[key]
-      Object.assign(merged, parsed.patch)
+      merged = mergeOverlayPatch(await this.store.load(), parsed.patch)
+      for (const key of clearedKeys) deleteOverlayKey(merged, key)
     } catch (error) {
       return { ok: false, error: `写入覆盖配置失败：${messageOf(error)}` }
     }
@@ -673,7 +806,7 @@ export class SettingsSurface {
     // provider (or lone model) leaves the session without a complete route,
     // so an edit to either side must end with both set or both cleared.
     if (values.provider !== undefined || values.model !== undefined) {
-      const prospective = { ...this.target.baseConfigSnapshot(), ...merged }
+      const prospective = mergeOverlay(this.target.baseConfigSnapshot(), merged)
       const hasProvider = (prospective.provider ?? '') !== ''
       const hasModel = (prospective.model ?? '') !== ''
       if (hasProvider !== hasModel) {

package/src/streamer.ts

@@ -11,7 +11,9 @@
  *     lines: the delegation status line (子代理 / 工作流 progress, settled
  *     workflow outcome, heartbeat) and the tool line (the parent's in-flight
  *     tool call). The lines are INDEPENDENT — a later tool call never
- *     supersedes the settled workflow status. Subagent children live in their
+ *     supersedes the settled workflow status. The lines render only on the
+ *     card that is currently streaming, so frozen segment cards never repeat
+ *     a stale status. Subagent children live in their
  *     own sessions: their `subagent/descriptor` / `tool/call` / `turn/end`
  *     events are folded into the parent turn's status line through
  *     `session.header.parentSession` (status only — the child's text output
@@ -19,10 +21,11 @@
  *  3. When the body outgrows one card's budget, the overflow is split at a
  *     clean breakpoint and sent as a continuation segment card (segment 2, 3,
  *     …) into the same topic; the stream then keeps flowing into the newest
- *     card. Reasoning is never segmented — it stays on card 1 and is clipped
- *     to the leftover budget (body has priority).
- *  4. `turnEnded(turn)` — finalize every segment card (`回复结束` / `回复失败`)
- *     and request the Typing → DONE/No reaction swap on the triggering message.
+ *     card. Reasoning is never segmented — it stays on card 1 inside the
+ *     fold panel's own fixed window, independent of the body length.
+ *  4. `finalize(turn)` — flip every segment card to its terminal state
+ *     (`回复结束` / `回复失败`), render the settled footer on the main card and
+ *     request the Typing → DONE/No reaction swap on the triggering message.
  *
  * The first visible text delta flips the panel title 推理中 → 回复中; the
  * final patch flips it to 回复结束 or 回复失败. Patching is throttled to `refreshMs` and
@@ -38,7 +41,7 @@
  */
 
 import type { AssistantStreamFrame, Session, SessionEvent, TurnEndReason } from './dsh-types.ts'
-import { buildCard, segmentCardContent } from './cards.ts'
+import { buildCard, segmentCardContent, segmentCardOptions } from './cards.ts'
 import type { CardState, PanelPhase } from './cards.ts'
 import type { FeishuChannel } from './feishu-channel.ts'
 import { cacheHitPct, foldAll, foldEvent } from './stats.ts'
@@ -49,7 +52,7 @@ import type { HeaderSample, StatsFold, UsageSample } from './stats.ts'
  * console can confirm which build of the activity status line is loaded.
  * Bump on every behavior change to this feature.
  */
-export const ACTIVITY_BUILD_MARKER = 'activity-status-v6'
+export const ACTIVITY_BUILD_MARKER = 'activity-status-v7'
 
 /** How a segment card reached Feishu. */
 export interface SegmentDelivery {
@@ -149,8 +152,6 @@ interface TurnState {
   header: HeaderSample | undefined
   /** Provider usage produced during THIS turn; never inherited from history. */
   lastUsage: UsageSample | undefined
-  /** Structured terminal failure for this turn, when `turn/end.kind=error`. */
-  failure: { message: string; code?: string } | undefined
   /** Segment cards in order; `cards[0]` is the attached reply card. */
   cards: SegmentCard[]
   dirty: boolean
@@ -161,6 +162,12 @@ interface TurnState {
   disposed: boolean
   /** Unix ms when the turn was attached (heartbeat elapsed base). */
   turnStartedAt: number
+  /** Wall-clock start of the currently open reasoning phase (undefined = not reasoning). */
+  reasoningSince: number | undefined
+  /** Accumulated wall-clock time the turn spent reasoning, in ms. A phase
+   *  opens at the first reasoning delta and closes when the step's output ends
+   *  (first answer text or step end), so tool execution is never counted. */
+  reasoningMs: number
   /** The in-flight tool call, if any (cleared by its `tool/result`). */
   toolActivity: { name: string; label: string; since: number } | undefined
   /** Live workflow-run folds projected by the workflow tool into this session. */
@@ -202,6 +209,8 @@ interface AttemptMark {
   cardCount: number
   bodyLengths: number[]
   reasoningLength: number
+  reasoningMs: number
+  reasoningSince: number | undefined
 }
 
 /** One live `tool-workflow/run-*` fold: run identity and member progress. */
@@ -321,7 +330,6 @@ export class TurnStreamer {
       reasoning: '',
       header: undefined,
       lastUsage: undefined,
-      failure: undefined,
       cards: [{
         messageId: cardMessageId,
         body: '',
@@ -339,6 +347,8 @@ export class TurnStreamer {
       finalized: false,
       disposed: false,
       turnStartedAt: Date.now(),
+      reasoningSince: undefined,
+      reasoningMs: 0,
       toolActivity: undefined,
       workflowRuns: new Map(),
       workflowEndStatus: undefined,
@@ -531,6 +541,9 @@ export class TurnStreamer {
     if (state === undefined || state.disposed) return
     switch (frame.type) {
       case 'start': {
+        // A new step starts: close any reasoning phase the previous step left
+        // open (defensive — its `end` frame normally does this first).
+        this.closeReasoning(state)
         state.attempts.set(frame.attemptId, this.attemptMark(state))
         if (state.turn === undefined) state.turn = frame.turn
         break
@@ -538,6 +551,7 @@ export class TurnStreamer {
       case 'chunk': {
         const chunk = frame.chunk
         if (chunk.type === 'text-delta') {
+          if (chunk.text !== '') this.closeReasoning(state)
           const last = state.cards[state.cards.length - 1]
           if (last !== undefined && !last.frozen && chunk.text !== '') {
             last.body += chunk.text
@@ -545,12 +559,17 @@ export class TurnStreamer {
             this.markDirty(session.id, state)
           }
         } else if (chunk.type === 'reasoning-delta' && chunk.text !== '') {
+          if (state.reasoningSince === undefined) state.reasoningSince = Date.now()
           state.reasoning += chunk.text
           this.markDirty(session.id, state)
         }
         break
       }
       case 'end': {
+        // The step's output is complete: a reasoning phase that ended with a
+        // tool call (no answer text) stops counting here, so the tool run that
+        // follows is not miscounted as reasoning time.
+        this.closeReasoning(state)
         const mark = state.attempts.get(frame.attemptId)
         state.attempts.delete(frame.attemptId)
         if (frame.outcome.kind === 'abandoned' && mark !== undefined) {
@@ -568,9 +587,18 @@ export class TurnStreamer {
       cardCount: state.cards.length,
       bodyLengths: state.cards.map(card => card.body.length),
       reasoningLength: state.reasoning.length,
+      reasoningMs: state.reasoningMs,
+      reasoningSince: state.reasoningSince,
     }
   }
 
+  /** Close an open reasoning phase, accumulating its wall-clock time. */
+  private closeReasoning(state: TurnState, now = Date.now()): void {
+    if (state.reasoningSince === undefined) return
+    state.reasoningMs += Math.max(0, now - state.reasoningSince)
+    state.reasoningSince = undefined
+  }
+
   /**
    * Drop one abandoned attempt's deltas. The attempt's text is a contiguous
    * suffix of the logical body: segments created during the attempt are
@@ -594,6 +622,9 @@ export class TurnStreamer {
       tail.dirty = true
     }
     state.reasoning = state.reasoning.slice(0, mark.reasoningLength)
+    // The abandoned attempt's reasoning time is not part of the visible turn.
+    state.reasoningMs = mark.reasoningMs
+    state.reasoningSince = mark.reasoningSince
   }
 
   private markDirty(sessionId: string, state: TurnState): void {
@@ -641,6 +672,9 @@ export class TurnStreamer {
         : context?.contextWindow ?? projected?.contextWindow,
       model: header?.model,
       effort: header?.effort,
+      // Only a turn that actually reasoned reports a duration; a non-reasoning
+      // model leaves the field undefined (rendered as `—`).
+      reasoningMs: state.reasoning === '' ? undefined : state.reasoningMs,
     }
   }
 
@@ -717,13 +751,10 @@ export class TurnStreamer {
    *     an elapsed counter so the card never sits silently.
    * Once the turn is finalized, the line switches to the SETTLED form
    * (workflow conclusion + finished-subagent summary) — the final card keeps
-   * the delegation status; only the tool line disappears.
+   * the delegation status; only the tool line disappears. A failed turn shows
+   * its diagnostic once, in the body: the status line never repeats it.
    */
   private delegationLine(state: TurnState, now: number): string {
-    if (state.failure !== undefined) {
-      const suffix = state.failure.code === undefined ? '' : ` · ${state.failure.code}`
-      return clipActivity(`🔴 本轮运行失败${suffix}`)
-    }
     if (state.finalized) return this.settledLine(state)
 
     let latest: WorkflowRun | undefined
@@ -832,10 +863,14 @@ export class TurnStreamer {
     }, this.heartbeatMs)
   }
 
-  private cardState(sessionId: string, state: TurnState, body: string): CardState {
-    // The snapshot point recomputes (and remembers) both activity lines so
-    // every patch — including heartbeat-driven ones — carries the current
-    // status and tool call.
+  /**
+   * Snapshot one card. `active` is true for the card currently streaming:
+   * only that card renders the transient activity lines, so frozen segment
+   * cards never repeat a stale tool/delegation line. Both lines are still
+   * recomputed (and remembered) on every snapshot so heartbeat/transition
+   * logging stays accurate.
+   */
+  private cardState(sessionId: string, state: TurnState, body: string, active = true): CardState {
     const now = Date.now()
     const status = this.delegationLine(state, now)
     if (status !== state.status) {
@@ -853,8 +888,8 @@ export class TurnStreamer {
       phase: state.phase,
       reasoning: state.reasoning,
       body,
-      status: state.status,
-      tool: state.tool,
+      status: active ? state.status : '',
+      tool: active ? state.tool : '',
       stats: this.statsFor(sessionId, state),
     }
   }
@@ -882,7 +917,7 @@ export class TurnStreamer {
       const card = state.cards[index]
       if (card === undefined || card.frozen || card.mode === 'text') return
 
-      const options = index === 0 ? {} : { panel: false, segment: index + 1 }
+      const options = segmentCardOptions(index)
       const split = segmentCardContent(this.cardState(sessionId, state, card.body), options)
       if (split.head === '') {
         // Degenerate budget (cannot happen with the real fixed overhead):
@@ -944,10 +979,10 @@ export class TurnStreamer {
       let lastError: unknown
       for (let attempt = 0; attempt < 3; attempt++) {
         try {
-          const snapshot = buildCard(this.cardState(sessionId, state, card.body), {
-            panel: false,
-            segment: index + 1,
-          })
+          const snapshot = buildCard(
+            this.cardState(sessionId, state, card.body, index === state.cards.length - 1),
+            segmentCardOptions(index),
+          )
           const delivery = await this.hooks.sendSegmentCard(sessionId, index + 1, snapshot, card.body)
           card.sending = false
           card.messageId = delivery.messageId
@@ -996,8 +1031,11 @@ export class TurnStreamer {
     if (!force && !card.dirty && !turnDirty) return
     if (!force && card.nextRetryAt > now) return
     card.dirty = false
-    const options = index === 0 ? {} : { panel: false, segment: index + 1 }
-    const snapshot = buildCard(this.cardState(sessionId, state, card.body), options)
+    const options = segmentCardOptions(index)
+    const snapshot = buildCard(
+      this.cardState(sessionId, state, card.body, index === state.cards.length - 1),
+      options,
+    )
     this.channel.updateCard(card.messageId, snapshot).catch((error: unknown) => {
       card.dirty = true
       card.failures++
@@ -1027,8 +1065,10 @@ export class TurnStreamer {
   ): void {
     if (state.finalized) return
     state.finalized = true
-    state.failure = failure
     state.phase = failure === undefined ? 'done' : 'error'
+    // A turn that ends inside a reasoning phase (e.g. no answer text) still
+    // reports the time it spent reasoning.
+    this.closeReasoning(state)
     if (failure !== undefined) {
       const code = failure.code === undefined ? '' : `\n\n错误码：\`${failure.code}\``
       const notice = `❌ **本轮运行失败**\n\n${failure.message}${code}`
@@ -1040,7 +1080,7 @@ export class TurnStreamer {
           // terminal diagnostic in its own continuation card instead.
           state.cards.push(this.freshSegment(notice))
         } else {
-          tail.body = tail.body.trim() === '' ? notice : `${tail.body}\n\n---\n\n${notice}`
+          tail.body = tail.body.trim() === '' ? notice : `${tail.body}\n\n${notice}`
           tail.dirty = true
         }
       }