@modesto_ma/dsh-channels 0.1.0 → 0.3.0

package/src/settings/surface.ts

@@ -23,6 +23,7 @@ import type {
   AccessMutationResponse,
   AccessWire,
   CatalogWire,
+  ChannelPhaseWire,
   ChannelStatusWire,
   CleanupPreviewWire,
   CleanupResponse,
@@ -51,15 +52,30 @@ import {
 } from './overlay.ts'
 import type { OverlayLogger, OverlayPatch, OverlayStore } from './overlay.ts'
 import type { SettingsCatalog } from './catalog.ts'
+import type { SettingsDirectoryPicker } from './directory-picker.ts'
 
 /** The slice of `FeishuService` the panel needs (structural, easy to fake). */
 export interface SettingsTarget {
   isRunning(): boolean
   isRestarting(): boolean
+  /** True while an explicit connect action is in flight (panel button busy state). */
+  isConnecting(): boolean
   health(): HealthSnapshot
   startedAtMs(): number | undefined
   uptimeMs(): number | undefined
   startError(): string | undefined
+  /**
+   * Whether the Feishu application credentials resolve. A false value means the
+   * plugin is loaded but deliberately holds no connection: the panel guides the
+   * user through configuring credentials instead of reporting a failure.
+   */
+  isConfigured(): boolean
+  /** Human-readable names of the missing configuration items (never values). */
+  missingConfig(): readonly string[]
+  /** Re-read credential presence (the credentials store is hot-reloaded on disk). */
+  refreshReadiness(): Promise<void>
+  /** Connect with the current config; throws when credentials are incomplete or the handshake fails. */
+  connect(): Promise<void>
   configSnapshot(): FeishuConfig
   baseConfigSnapshot(): FeishuConfig
   runningConfigSnapshot(): FeishuConfig | undefined
@@ -144,7 +160,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,
   },
@@ -164,14 +180,14 @@ const FIELD_META: Record<EditableKey, { label: string; help: string; min?: numbe
   },
   authRequestTtlDays: {
     label: '授权申请有效期（天）',
-    help: '入群/用户授权申请卡的有效期，1–30 天；过期后卡片需重新触发申请（也可直接在「访问与授权」面板处理）。',
+    help: '入群/用户授权申请卡的有效期，1–30 天；过期后卡片需重新触发申请（也可在本页下方「待处理申请」中处理）。',
     min: 1,
     max: 30,
     step: 1,
   },
   acceptAttachments: { label: '接收并保存附件', help: '接收飞书图片、文件与合并转发记录，保存到工作区的 attachments/ 目录；模型不会自动读取，需要时用文件工具自行查看。关闭后附件消息不保存、不触发回复。' },
-  workspaceRetention: { label: '过期工作区保留期', help: '超过所选天数没有活动的飞书工作区会进入下方「工作区清理」列表；「关闭」表示永不删除。DSH 会话日志不受影响。' },
-  workspaceRetentionAuto: { label: '自动执行工作区清理', help: '开启后插件在启动时及每天执行一次过期工作区清理；关闭时只能在下方卡片手动清理。开启前请确认保留期已设置。' },
+  workspaceRetention: { label: '过期目录保留期', help: '超过所选天数没有活动的飞书话题目录（以及旧版本按话题建立的工作区目录）会进入下方清理列表；用户工作区本身永不删除。DSH 会话日志不受影响。' },
+  workspaceRetentionAuto: { label: '自动执行目录清理', help: '开启后插件在启动时及每天执行一次过期目录清理；关闭时只能在下方卡片手动清理。开启前请确认保留期已设置。' },
   provider: { label: '模型服务商', help: '留空 = 使用部署默认；例如 deepseek-official。', placeholder: '留空 = 部署默认' },
   model: { label: '模型 id', help: '留空 = 使用部署默认；例如 deepseek-v4-flash。', placeholder: '留空 = 部署默认' },
   reasoningEffort: { label: '推理档位', help: '模型声明的精确档位 id（如 high / max）；留空 = 适配器默认。', placeholder: '留空 = 适配器默认' },
@@ -190,9 +206,9 @@ const GROUP_OF: Record<EditableKey, EditableFieldWire['group']> = {
   threadFallback: 'behavior',
   welcomeOnboarding: 'behavior',
   allowPermissionSwitch: 'behavior',
-  adminOpenId: 'behavior',
-  accessMode: 'behavior',
-  authRequestTtlDays: 'behavior',
+  adminOpenId: 'access',
+  accessMode: 'access',
+  authRequestTtlDays: 'access',
   acceptAttachments: 'content',
   provider: 'model',
   model: 'model',
@@ -296,6 +312,23 @@ function withCurrentOption(
   return inherit === undefined ? [extra] : [inherit, extra, ...rest]
 }
 
+/**
+ * Mark the workspace-root field as browsable when the host can open its native
+ * directory chooser. Every other host (no `directoryPicker`, or the `browse`
+ * backend of remote/headless sessions) keeps the plain text input.
+ *
+ * @param fields - Host field descriptors after the selector catalog is applied.
+ * @param available - whether a native directory chooser can be opened.
+ * @returns the descriptors with `browse: 'directory'` on `baseDir` when usable.
+ */
+export function withDirectoryBrowse(
+  fields: readonly EditableFieldWire[],
+  available: boolean,
+): EditableFieldWire[] {
+  if (!available) return [...fields]
+  return fields.map(field => (field.key === 'baseDir' ? { ...field, browse: 'directory' } : field))
+}
+
 function messageOf(error: unknown): string {
   return error instanceof Error ? error.message : String(error)
 }
@@ -370,6 +403,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) },
@@ -377,12 +418,34 @@ export function readOnlyFields(config: FeishuConfig): ReadOnlyFieldWire[] {
   ]
 }
 
+/**
+ * Derive the panel phase from readiness + runtime facts. The order matters:
+ * an incomplete configuration always wins (no connection is attempted), and a
+ * failed attempt is only reported while the channel is stopped.
+ */
+function phaseOf(target: SettingsTarget): ChannelPhaseWire {
+  // A connection attempt in flight is the honest label even though `start()`
+  // flips `started` before the handshake finishes. A live connection outranks
+  // missing credentials: removing a stored value does not drop the open socket,
+  // so the panel keeps the connection actions available and flags the missing
+  // credential separately (`configured: false`).
+  if (target.isRestarting()) return 'connecting'
+  if (target.isConnecting()) return target.isConfigured() ? 'connecting' : 'unconfigured'
+  if (target.isRunning()) return 'connected'
+  if (!target.isConfigured()) return 'unconfigured'
+  if (target.startError() !== undefined) return 'error'
+  return 'idle'
+}
+
 /** Assemble the status half of the panel payload. */
 function buildStatus(target: SettingsTarget, overlayPath: string): ChannelStatusWire {
   const health = target.health()
   const connection = health.connection
   return {
     running: target.isRunning(),
+    configured: target.isConfigured(),
+    phase: phaseOf(target),
+    missingConfig: [...target.missingConfig()],
     level: health.level,
     startedAt: target.startedAtMs(),
     uptimeMs: target.uptimeMs(),
@@ -402,7 +465,7 @@ function buildStatus(target: SettingsTarget, overlayPath: string): ChannelStatus
     reasons: health.reasons,
     version: DSH_CHANNELS_VERSION,
     overlayPath,
-    busy: target.isRestarting(),
+    busy: target.isRestarting() || target.isConnecting(),
   }
 }
 
@@ -419,10 +482,35 @@ export class SettingsSurface {
     private readonly store: OverlayStore,
     private readonly logger?: OverlayLogger,
     private readonly catalog?: SettingsCatalog,
+    private readonly directoryPicker?: SettingsDirectoryPicker,
   ) {}
 
+  /**
+   * Re-read credential presence. The credentials store is hot-reloaded from
+   * disk, so a value edited outside the panel becomes visible within one poll
+   * instead of only after a restart/connect.
+   */
+  private async syncReadiness(): Promise<void> {
+    try {
+      await this.target.refreshReadiness()
+    } catch (error) {
+      this.logger?.warn?.('dsh-channels: 凭据状态刷新失败：%s', messageOf(error))
+    }
+  }
+
+  /**
+   * Reject panel writes while the connection lifecycle is in flight: saving an
+   * overlay or credentials then would race `applyOverlay()`/`start()` and can
+   * record a running-config snapshot that never took effect.
+   */
+  private writeBusy(): { ok: false; error: string } | undefined {
+    if (!this.target.isRestarting() && !this.target.isConnecting()) return undefined
+    return { ok: false, error: '飞书连接正在连接或重启，请稍候再试' }
+  }
+
   /** Wire status only (used by the client's 5 s poll). */
   async status(): Promise<ChannelStatusWire> {
+    await this.syncReadiness()
     return buildStatus(this.target, this.store.file)
   }
 
@@ -443,6 +531,7 @@ export class SettingsSurface {
 
   /** Status + editable config with provenance + read-only facts. */
   async panel(): Promise<PanelWire> {
+    await this.syncReadiness()
     const base = this.target.baseConfigSnapshot()
     const effective = this.target.configSnapshot()
     const overlay = await this.store.load()
@@ -452,12 +541,15 @@ export class SettingsSurface {
       ? RESTART_KEYS.filter(key => effective[key] !== running[key])
       : []
     const catalog = await this.catalogFor(effective.provider, effective.model)
-    const fields = applyCatalog(FIELD_DESCRIPTORS, catalog, {
-      provider: effective.provider,
-      model: effective.model,
-      reasoningEffort: effective.reasoningEffort,
-      agentPreset: effective.agentPreset,
-    })
+    const fields = withDirectoryBrowse(
+      applyCatalog(FIELD_DESCRIPTORS, catalog, {
+        provider: effective.provider,
+        model: effective.model,
+        reasoningEffort: effective.reasoningEffort,
+        agentPreset: effective.agentPreset,
+      }),
+      this.directoryPicker?.available === true,
+    )
 
     let credentialStates: { appId: CredentialInfo; appSecret: CredentialInfo } = {
       appId: { configured: false, writable: false },
@@ -485,7 +577,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,
@@ -507,6 +599,7 @@ export class SettingsSurface {
       access = {
         mode: effective.accessMode,
         admin: { configured: false },
+        loaded: false,
         groups: [],
         users: [],
         requests: [],
@@ -532,6 +625,8 @@ export class SettingsSurface {
 
   /** Validate + persist a partial edit; live fields take effect immediately. */
   async save(values: EditableValues): Promise<SaveConfigResponse> {
+    const busy = this.writeBusy()
+    if (busy !== undefined) return busy
     const unknown = Object.keys(values).filter(key => !(EDITABLE_KEYS as readonly string[]).includes(key))
     if (unknown.length > 0) {
       return { ok: false, error: `未知配置项：${unknown.join(', ')}` }
@@ -611,6 +706,8 @@ export class SettingsSurface {
 
   /** Drop every Web override and fall back to the profile config. */
   async clear(): Promise<ClearConfigResponse> {
+    const busy = this.writeBusy()
+    if (busy !== undefined) return busy
     try {
       await this.store.clear()
     } catch (error) {
@@ -622,6 +719,8 @@ export class SettingsSurface {
 
   /** Write provided credential values through the host seam (never echoed back). */
   async saveCredentials(values: SaveCredentialsRequest): Promise<SaveCredentialsResponse> {
+    const busy = this.writeBusy()
+    if (busy !== undefined) return busy
     const writes: Array<{ field: CredentialField; value: string }> = []
     const issues: FieldIssueWire[] = []
     for (const field of ['appId', 'appSecret'] as const) {
@@ -647,6 +746,8 @@ export class SettingsSurface {
 
   /** Remove the stored value behind one credential reference. */
   async clearCredential(field: CredentialField): Promise<ClearCredentialResponse> {
+    const busy = this.writeBusy()
+    if (busy !== undefined) return busy
     if (field !== 'appId' && field !== 'appSecret') {
       return { ok: false, error: '未知的凭据字段' }
     }
@@ -659,36 +760,67 @@ export class SettingsSurface {
   }
 
   /**
-   * Credential values are resolved on connect. When the channel is stopped,
-   * retry immediately (nothing to interrupt); when it is running, ask the user
-   * to reconnect. A failed retry still reports the save as successful.
+   * Credential values are resolved on connect. Opening a connection is gated on
+   * readiness: saving one half of the pair stores the value but keeps the
+   * plugin idle until the other half exists. When the channel is stopped and
+   * the pair is complete, connect immediately (nothing to interrupt); when it
+   * is running, the user reconnects to pick the value up.
    */
   private async finishCredentialChange(kind: 'save' | 'clear'): Promise<SaveCredentialsResponse> {
     if (this.target.isRunning()) {
       return { ok: true, panel: await this.panel(), reconnect: 'pending' }
     }
-    if (kind === 'clear') {
-      return { ok: true, panel: await this.panel(), reconnect: 'not-needed' }
+    if (kind === 'clear' || !this.target.isConfigured()) {
+      return { ok: true, panel: await this.panel(), reconnect: kind === 'clear' ? 'not-needed' : 'unconfigured' }
     }
     try {
-      await this.target.restart()
+      await this.target.connect()
       return { ok: true, panel: await this.panel(), reconnect: 'auto' }
     } catch (error) {
+      // The value is stored, but the channel did not come up: report the
+      // failure state instead of claiming a successful connection.
       return {
         ok: true,
         panel: await this.panel(),
-        reconnect: 'auto',
+        reconnect: 'failed',
         autoReconnectError: messageOf(error),
       }
     }
   }
 
-  /** Close and reopen the Feishu long connection with the latest config. */
+  /**
+   * The panel's single connect/reconnect action: reopen a running connection,
+   * or open the first one when the channel is stopped. Credentials must be
+   * complete — otherwise the panel points the user back at the credentials form
+   * instead of surfacing a startup error.
+   */
   async reconnect(): Promise<ReconnectResponse> {
+    // Credentials may have been edited on disk since the last poll; re-check
+    // presence before refusing the action.
+    await this.syncReadiness()
+    if (!this.target.isConfigured()) {
+      return {
+        ok: false,
+        error: '飞书应用凭据尚未配置完整，请先填写 App ID 与 App Secret 并保存',
+        unconfigured: true,
+      }
+    }
+    const wasRunning = this.target.isRunning()
     try {
-      await this.target.restart()
+      if (wasRunning) await this.target.restart()
+      else await this.target.connect()
     } catch (error) {
-      return { ok: false, error: `重连失败：${messageOf(error)}` }
+      return { ok: false, error: `${wasRunning ? '重连' : '连接'}失败：${messageOf(error)}` }
+    }
+    // `restart()` intentionally does not throw when the credentials vanished;
+    // verify the connection actually exists before reporting success.
+    if (!this.target.isRunning()) {
+      return {
+        ok: false,
+        unconfigured: !this.target.isConfigured(),
+        error: this.target.startError()
+          ?? (this.target.isConfigured() ? '飞书连接未建立' : '飞书应用凭据尚未配置完整，请先填写并保存凭据'),
+      }
     }
     return { ok: true, panel: await this.panel() }
   }
@@ -754,12 +886,26 @@ export class SettingsSurface {
     }
   }
 
+  /**
+   * Open the host's native directory chooser (the panel's「选择目录…」button).
+   *
+   * @param signal - caller lifetime; abort closes the OS dialog.
+   * @returns the chosen absolute path, or `null` when the operator cancels.
+   * @throws when the host provides no native directory chooser.
+   */
+  async pickDirectory(signal: AbortSignal): Promise<string | null> {
+    if (this.directoryPicker === undefined) throw new Error(PANEL_COPY.directoryPickFailed)
+    return await this.directoryPicker.pick(signal)
+  }
+
   /**
    * Run the workspace-retention cleanup once. Irreversible deletions are the
    * target's responsibility; the surface only reports the outcome and returns
    * a refreshed panel (its cleanup preview then reflects the remaining workspaces).
    */
   async runCleanup(): Promise<CleanupResponse> {
+    const busy = this.writeBusy()
+    if (busy !== undefined) return busy
     let result: CleanupRunWire
     try {
       result = await this.target.runWorkspaceCleanup()

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