fix(sandbox): close classifier evidence gaps (round 2)

packages/bash/bash-sandbox/src/helpers.ts

@@ -52,7 +52,12 @@ export function classifyRunnerFailure(
   for (const rule of rules) {
     if (rule.allowedExitCodes !== undefined && !rule.allowedExitCodes.includes(exitCode)) continue
     const informationalLines = new Set((rule.informationalLines ?? []).map(line => line.toLowerCase()))
-    const fatalSignatures = rule.fatalSignatures.map(signature => signature.toLowerCase())
+    // An empty substring matches every string in JavaScript. Ignore it so a
+    // malformed public rule cannot turn a gated exit status into evidence by
+    // itself; keep any valid signatures beside it active.
+    const fatalSignatures = rule.fatalSignatures
+      .filter(signature => signature.length > 0)
+      .map(signature => signature.toLowerCase())
     for (const line of lines) {
       const lowered = line.toLowerCase()
       if (informationalLines.has(lowered)) continue

packages/bash/bash-sandbox/tests/partial-landlock.spec.ts

@@ -1,7 +1,7 @@
 /**
- * Deterministic composition proof for the partial-Landlock diagnostic: the
- * real local provider and sandbox bash executor wrap commands through a POSIX
- * fake launcher that prints the native informational line before exec.
+ * Deterministic real-process proofs for runner classification: the real local
+ * provider and sandbox bash executor exercise an outer-shell launch failure
+ * and a POSIX fake Landlock launcher that prints its notice before exec.
  */
 
 import { mkdtemp, rm, writeFile } from 'node:fs/promises'
@@ -64,6 +64,26 @@ async function setup(fatal = false): Promise<SandboxBashExecutor> {
 }
 
 describe('partial Landlock runner-failure classification', () => {
+  it.skipIf(process.platform === 'win32')('classifies a genuinely missing configured runner through the outer bash exec rule', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'dsh-missing-sandbox-runner-'))
+    tempDirs.push(dir)
+    const missingRunner = join(dir, 'missing-runner')
+    const ctx = new Context()
+    contexts.push(ctx)
+    await ctx.plugin(LocalSandboxProvider, {
+      runnerCommand: [missingRunner],
+      runnerFailureSignatures: ['configured-runner: fatal'],
+    })
+    await ctx.plugin(SandboxPolicyService, { mode: 'read-only', workspaceRoot: process.cwd() })
+    await ctx.plugin(LocalSubprocessService)
+    await ctx.plugin(SandboxBashExecutor, { cwd: process.cwd(), timeoutMs: 5_000 })
+
+    const error = await ctx.bash.run(ctx.bash.resolve({ command: 'true' })).catch((value: unknown) => value)
+    expect(error).toMatchObject({ name: 'SandboxUnavailableError', code: SANDBOX_UNAVAILABLE })
+    expect(error).toBeInstanceOf(Error)
+    expect((error as Error).message).toContain(missingRunner)
+  })
+
   it('keeps true, false, and child exit 125 as child outcomes when the notice is the only runner line', async () => {
     const bash = await setup()
     for (const [command, exitCode] of [['true', 0], ['false', 1], ['exit 125', 125]] as const) {

packages/bash/bash-sandbox/tests/sandbox.spec.ts

@@ -234,6 +234,24 @@ describe('classifyDenial', () => {
 })
 
 describe('classifyRunnerFailure', () => {
+  it('ignores empty fatal signatures instead of treating exit status or notice text as evidence', () => {
+    const notice = 'landlock-run: partial enforcement (older Landlock ABI)'
+    const emptyRule = [{ allowedExitCodes: [125], fatalSignatures: [''] }]
+    expect(classifyRunnerFailure(125, '', emptyRule)).toBeUndefined()
+    expect(classifyRunnerFailure(125, notice, emptyRule)).toBeUndefined()
+  })
+
+  it('keeps valid fatal signatures active beside an ignored empty entry', () => {
+    const notice = 'landlock-run: partial enforcement (older Landlock ABI)'
+    const fatal = 'landlock-run: ruleset creation failed'
+    const rules = [{
+      allowedExitCodes: [125],
+      fatalSignatures: ['', 'landlock-run: '],
+      informationalLines: [notice],
+    }]
+    expect(classifyRunnerFailure(125, `${notice}\nchild diagnostic\n${fatal}`, rules)).toEqual({ detail: fatal })
+  })
+
   it('matches an outer-shell rule case-insensitively only at its exit codes and configured argv0', () => {
     const rules = [{
       allowedExitCodes: [126, 127],

packages/client/runtime/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/client/runtime/README.md
-README.md: 82f1bc95a6128245f88f01a0de0849494cb98359
-README.zh.md: f3aba75d18671fe377ec8305693ea5025d51e0de
+README.md: 89e58f967f852bb0786a5b7d73fa8e924fa282e0
+README.zh.md: 960e2fceede1b500af9ee2063ec9283e2b7b271a

packages/client/runtime/README.md

@@ -26,7 +26,7 @@ SlotsService gives the renderer separate bare observables for `useSessions` and
 
 ## The human transcript
 
-`ConversationSnapshot.nodes` is the human transcript, not the model surface. `TranscriptAdapter` projects the raw window in log order — every append-origin surface event (`isAppendSurfaceEvent`) at its own log position, plus one `CompactionSummaryNode` marker per landed compaction checkpoint — and never consults surface order. A landed compaction therefore keeps the conversation it shadowed on the model side: the marker reports where the model stopped seeing that history instead of erasing it. Model-only replacement copies stay out: a pruned `tool/result` and a regenerated `assistant/message` rewrite one node for the model and mark no boundary. A checkpoint is a `user/message` carrying the compaction seam's plugin source that **replaced** a surface range; an appending plugin-sourced `user/message` is injected context, not a compaction. The adapter's plugin literal is pinned to the seam's own declaration by a type-only import of the cordis-free [`dsh-compact/checkpoint`](../../compact/compact/README.md) leaf, so renaming it there fails `tsc` here; a **value** import of the package would fail the client purity gate, and the package **root** is unreachable even as a type (it reaches `dsh-session`'s root, whose `Context` merge collides the host `sessions` with this program's). `tests/compact-checkpoint-pin.spec.ts` covers the same drift behaviorally.
+`ConversationSnapshot.nodes` is the human transcript, not the model surface. `TranscriptAdapter` projects the raw window in log order — every append-origin surface event (`isAppendSurfaceEvent`) at its own log position, plus one `CompactionSummaryNode` marker per landed compaction checkpoint — and never consults surface order. `ConversationSnapshot.turnEnds` maps each completed turn in that window to its `turn/end` seq, retaining turn completion independently from the transcript so presentation can require a real boundary before enabling an action. A landed compaction therefore keeps the conversation it shadowed on the model side: the marker reports where the model stopped seeing that history instead of erasing it. Model-only replacement copies stay out: a pruned `tool/result` and a regenerated `assistant/message` rewrite one node for the model and mark no boundary. A checkpoint is a `user/message` carrying the compaction seam's plugin source that **replaced** a surface range; an appending plugin-sourced `user/message` is injected context, not a compaction. The adapter's plugin literal is pinned to the seam's own declaration by a type-only import of the cordis-free [`dsh-compact/checkpoint`](../../compact/compact/README.md) leaf, so renaming it there fails `tsc` here; a **value** import of the package would fail the client purity gate, and the package **root** is unreachable even as a type (it reaches `dsh-session`'s root, whose `Context` merge collides the host `sessions` with this program's). `tests/compact-checkpoint-pin.spec.ts` covers the same drift behaviorally.
 
 Because the projection is log-ordered, the node array is seq-monotonic by construction: log-only `command/run` / `command/done` nodes splice in by seq, `Session` merges interrupted frozen nodes by their fractional seqs, and a window whose checkpoint cites a shadowed range outside it renders the marker with nothing logged. The marker's summary text comes from the checkpoint's `compact/summary` provenance; a window cut that left the provenance outside makes the row non-expandable rather than empty, and a later page that supplies it resolves the text. Performance contract: one append materializes at most one node and copies the projection only when it adds that node; an event that changes no node keeps the previous array reference (a chunk storm costs nothing), and unchanged nodes keep their object identity.
 

packages/client/runtime/README.zh.md

@@ -26,7 +26,7 @@ SlotsService 分别为 renderer 提供 `useSessions` 与 `useWorkspaces` 的裸
 
 ## 面向人的 transcript（文本记录）
 
-`ConversationSnapshot.nodes` 是面向人的 transcript，不是模型 surface。`TranscriptAdapter` 按日志顺序投影原始窗口——每个 append 来源的 surface 事件（`isAppendSurfaceEvent`）落在它自己的日志位置上，外加每次落地的压缩（compaction）检查点贡献一个 `CompactionSummaryNode` 标记——且从不查询 surface 顺序。于是一次落地的压缩会保留它在模型侧遮蔽掉的对话：标记报告模型从哪里开始看不见那段历史，而不是把它抹掉。仅模型可见的 replacement 副本不进入记录：被裁剪的 `tool/result` 和重新生成的 `assistant/message` 只为模型重写一个节点，不标记任何边界。检查点是携带压缩 seam 插件来源、且**替换**了一段 surface 范围的 `user/message`；一条 append 的插件来源 `user/message` 是注入上下文，不是压缩。适配器的插件字面量通过对无 cordis 的 [`dsh-compact/checkpoint`](../../compact/compact/README.md) 叶子做仅类型导入，钉在压缩 seam 自己的声明上：在那里改名会让此处 `tsc` 失败；而对该包（package）做**值**导入会被客户端纯度门禁拒绝，包的**根**即便作为类型也无法到达（它会到达 `dsh-session` 的根，其 `Context` 合并会让 host 的 `sessions` 与本程序的冲突）。`tests/compact-checkpoint-pin.spec.ts` 从行为侧覆盖同一漂移。
+`ConversationSnapshot.nodes` 是面向人的 transcript，不是模型 surface。`TranscriptAdapter` 按日志顺序投影原始窗口——每个 append 来源的 surface 事件（`isAppendSurfaceEvent`）落在它自己的日志位置上，外加每次落地的压缩（compaction）检查点贡献一个 `CompactionSummaryNode` 标记——且从不查询 surface 顺序。`ConversationSnapshot.turnEnds` 把该窗口中的每个已完成轮次映射到其 `turn/end` seq；它独立于 transcript 保留轮次完成状态，使呈现层能够在启用操作前要求存在真实边界。于是一次落地的压缩会保留它在模型侧遮蔽掉的对话：标记报告模型从哪里开始看不见那段历史，而不是把它抹掉。仅模型可见的 replacement 副本不进入记录：被裁剪的 `tool/result` 和重新生成的 `assistant/message` 只为模型重写一个节点，不标记任何边界。检查点是携带压缩 seam 插件来源、且**替换**了一段 surface 范围的 `user/message`；一条 append 的插件来源 `user/message` 是注入上下文，不是压缩。适配器的插件字面量通过对无 cordis 的 [`dsh-compact/checkpoint`](../../compact/compact/README.md) 叶子做仅类型导入，钉在压缩 seam 自己的声明上：在那里改名会让此处 `tsc` 失败；而对该包（package）做**值**导入会被客户端纯度门禁拒绝，包的**根**即便作为类型也无法到达（它会到达 `dsh-session` 的根，其 `Context` 合并会让 host 的 `sessions` 与本程序的冲突）。`tests/compact-checkpoint-pin.spec.ts` 从行为侧覆盖同一漂移。
 
 由于投影按日志顺序，节点数组天然按 seq 单调：仅日志的 `command/run` / `command/done` 节点按 seq 插入，`Session` 按分数 seq 归并被打断的冻结节点，而检查点所引范围落在窗口之外的窗口会渲染出标记且不打印任何日志。标记的摘要文本来自检查点的 `compact/summary` 溯源；窗口切分把溯源留在窗口外时该行不可展开而非空白，后续补上溯源的分页会解析出文本。性能契约：一次追加最多物化一个节点，并且仅在加入该节点时复制投影；不改变任何节点的事件保持上一次的数组引用（分片风暴零成本），未变化的节点保持其对象标识。
 

packages/client/runtime/src/client/sessions/conversation.ts

@@ -331,6 +331,8 @@ export interface ConversationSnapshot {
   sessionId: SessionId
   /** Human transcript plus retry notices and interrupted-turn terminal nodes in event order. */
   nodes: readonly ConversationNode[]
+  /** In-window completed turn number -> its `turn/end` event seq. */
+  turnEnds: ReadonlyMap<number, number>
   partial: PartialAssistant | null
   runningCalls: readonly RunningToolCall[]
   /**

packages/client/runtime/src/client/sessions/session.ts

@@ -113,6 +113,11 @@ export class Session implements SessionFace {
   private pendingCache: { rev: number; value: PendingInteraction[] } | null = null
   private derivedRev = 0
   private nodesCache: { projected: readonly ConversationNode[]; derivedRev: number; value: readonly ConversationNode[] } | null = null
+  /** Completed turn boundaries retained from the raw window so presentation
+   *  actions never infer a safe fork point from transcript content alone. */
+  private turnEnds = new Map<number, number>()
+  private turnEndsRev = 0
+  private turnEndsCache: { rev: number; value: ReadonlyMap<number, number> } | null = null
   /** Authoritative stream-only inbox snapshot; pending work never hits history. */
   private queued: QueuedMessage[] = []
   private queueRev = 0
@@ -821,6 +826,8 @@ export class Session implements SessionFace {
         return
       }
       case 'turn/end': {
+        this.turnEnds.set(event.data.turn, event.seq)
+        this.turnEndsRev++
         if (event.data.reason.kind === 'aborted' || event.data.reason.kind === 'disposed') {
           this.settleScheduledRetry('cancelled', event.data.turn)
         }
@@ -911,6 +918,8 @@ export class Session implements SessionFace {
     this.callsRev++
     this.derivedNodes = []
     this.derivedRev++
+    this.turnEnds = new Map()
+    this.turnEndsRev++
     this.codeDispatches = new Map()
     this.dispatchesRev++
     for (let i = 0; i < this.events.length; i++) {
@@ -942,6 +951,9 @@ export class Session implements SessionFace {
     if (this.callsCache === null || this.callsCache.rev !== this.callsRev) {
       this.callsCache = { rev: this.callsRev, value: [...this.openCalls.values()] }
     }
+    if (this.turnEndsCache === null || this.turnEndsCache.rev !== this.turnEndsRev) {
+      this.turnEndsCache = { rev: this.turnEndsRev, value: new Map(this.turnEnds) }
+    }
     if (this.pendingCache === null || this.pendingCache.rev !== this.pendingRev) {
       this.pendingCache = { rev: this.pendingRev, value: [...this.pending.values()] }
     }
@@ -955,6 +967,7 @@ export class Session implements SessionFace {
     return {
       sessionId: this.sessionId,
       nodes,
+      turnEnds: this.turnEndsCache.value,
       partial,
       runningCalls: this.callsCache.value,
       pending: this.pendingCache.value,

packages/client/runtime/tests/session.spec.ts

@@ -426,6 +426,7 @@ describe('live event path', () => {
     feed(ev.turnEnd(10, 1, 'aborted')) // no assistant/message ever arrives
     const snapshot = session.getSnapshot()
     expect(snapshot.partial).toBeNull()
+    expect(snapshot.turnEnds.get(1)).toBe(10)
     const frozen = snapshot.nodes.at(-1)
     expect(frozen).toMatchObject({ kind: 'assistant', interrupted: true, blocks: [{ kind: 'text', text: '说到一半' }] })
     // Ordered inside the flow: after the user message (seq 7), before any later turn.
@@ -1215,6 +1216,7 @@ describe('reference stability (the memo contract)', () => {
     expect(after).not.toBe(before)
     expect(after.runningCalls).toBe(before.runningCalls)
     expect(after.pending).toBe(before.pending)
+    expect(after.turnEnds).toBe(before.turnEnds)
     // And a mutation on the tracked domain swaps that array.
     feed(ev.toolResult(11, 1, 'c1', 'ECHO'))
     const resolved = session.getSnapshot()

packages/client/test-runtime/src/fixtures.ts

@@ -46,6 +46,7 @@ export function conversationSnapshot(sessionId: SessionId): ConversationSnapshot
   return {
     sessionId,
     nodes: [],
+    turnEnds: new Map(),
     partial: null,
     runningCalls: [],
     codeDispatches: new Map(),

packages/client/ui-conversation/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/client/ui-conversation/README.md
-README.md: 728d67aaccee609d5f28ee8744c1f11ca74b040a
-README.zh.md: eec1d36b9758dddcf63eb75c3a74c51b4afb0a72
+README.md: e1dbe7d4d5992b6b5b029fddfc9d9857ccae7443
+README.zh.md: fd82ad65f8e903a6f7106e8b8ff8eccbf1435957

packages/client/ui-conversation/README.md

@@ -38,7 +38,7 @@ The todo surfaces are two registrations over that shape, both plain registrant p
 
 `QueueDock` is the terminal input-dock entry at `order: 20`. It hides while empty, renders one pending row directly, and defaults two or more rows to a collapsed `"<n> 条排队消息"` header whose button expands or collapses the complete list. The header exposes `aria-expanded` and `aria-controls`; the expanded list scrolls within a 180px height bound. An active edit or mutation keeps its rows visible, and emptying the queue restores the collapsed default for the next queue. Each visible ordinary-session row remains a single-line preview with its exact-occurrence edit, delete, and strict-steer actions; addressed subagents retain the rows as a read-only projection because their continuation transport does not expose queue mutation. If strict steer loses to a closed window, the original occurrence remains queued for normal delivery; if the driver already claimed it, normal delivery is already underway. Neither converged race displays a failure, while transport and unknown failures do.
 
-The Host's placement-aware `session/queue` snapshot also carries pending steering. QueueDock filters it out, while ChatView projects it as a user-style bubble with Copy at the conversation tail; Fork stays absent because the message has not entered a durable turn. The Host delays steering retirement until the durable `steering/message` has entered the mux stream. On that accepted live event, the client runtime retires the first matching current steering occurrence before publishing the snapshot; historical events cannot hide later occurrences that reuse the same `MessageId`. The bubble therefore hands off without a gap or duplicate, restores Copy and Fork from the durable node, and survives reconnect from the same authority.
+The Host's placement-aware `session/queue` snapshot also carries pending steering. QueueDock filters it out, while ChatView projects it as a user-style bubble with Copy at the conversation tail; Fork stays absent because the message has not entered a durable turn. The Host delays steering retirement until the durable `steering/message` has entered the mux stream. On that accepted live event, the client runtime retires the first matching current steering occurrence before publishing the snapshot; historical events cannot hide later occurrences that reuse the same `MessageId`. The bubble therefore hands off without a gap or duplicate, immediately restores Copy and the branch control from the durable node, enables branch only when that node is the completed turn's transcript tail, and survives reconnect from the same authority.
 
 Keyboard message submission resolves delivery from the addressed session's running state and steering capability. While idle, Enter and Cmd/Ctrl+Enter both perform an ordinary Queue send. While a primary session is running, the browser-persisted General Settings preference assigns plain Enter to `Queue` (the default) or `Steer`, and Cmd/Ctrl+Enter performs the other behavior; Shift+Enter remains a newline. Addressed subagents keep both gestures on their Queue-only continuation transport even while running. The preference affects only the steer-capable busy-state gesture pair, and the send button and non-keyboard submit actions remain Queue. Composer Steer uses the existing best-effort `session.prompt(mode: 'steer')` contract: if the current next-step window closes before acceptance, AgentLoop admits the message as the next waking Queue turn without surfacing a failure or losing the draft transaction.
 
@@ -63,8 +63,8 @@ None; this package neither assembles nor sends a provider request.
 - **Compaction markers show no scale** — the row does not yet report how many messages or which range the checkpoint replaced.
 - **Stats-line durations cover the in-window flow only** — LLM and tool wall times fold the snapshot's assistant `timing` and tool call/result pairs, so nodes outside the loaded event window (older history) are not counted.
 - **Details panel is the minimal form and currently has no entry point** — selected call args/result raw display; the Input/Output/Metadata switch, Prev/Next stepping, and See-in-trajectory deep link are deferred. Tool rows stopped being details-panel click targets and nothing replaced that gesture, so `ChatViewInjected.openDetails` is implemented but uncalled and the panel (including its terminal card) is unreachable in the assembled application; its rendering stays covered by mounting it with a selection directly.
-- **Assistant per-message paging is a reserved slot** — drawn in the design, not implemented. The finalized content IconActions row (copy / branch / clock) ships under the last content-text assistant of each turn only; mid-turn narration and Think-only nodes stay chrome-free. Branch forks through the turn containing that message, increments the inherited title on the client, and then opens the child, while a fork or rename failure leaves the source selected.
-- **Sent user messages cannot be edited** — the user bubble's IconActions row carries clock / copy / branch only, and branching from the message is the nearest gesture. The control returns with the capability behind it: a client mutation over a settled user message, plus the host behavior for the turn that already consumed it ([decision](../../../.agents/notes/implemented/simplification/2026-07-31-drop-user-message-edit-stub.md)).
+- **Assistant per-message paging is a reserved slot** — drawn in the design, not implemented. The finalized content IconActions row (copy / clock / branch) ships under the last content-text assistant of each turn only; mid-turn narration and Think-only nodes stay chrome-free. Branch stays disabled unless that message is also the last transcript node of a completed turn; when enabled, it forks through that turn, increments the inherited title on the client, and opens the child. A fork or rename failure leaves the source selected ([decision](../../../.agents/notes/implemented/bug-fix/2026-08-02-message-fork-actions-require-completed-turn-tail.md)).
+- **Sent user messages cannot be edited** — user bubbles retain clock, copy, and branch; branch stays disabled unless a completed turn's transcript ends at that user message. Editing returns with the capability behind it: a client mutation over a settled user message, plus the host behavior for the turn that already consumed it ([decision](../../../.agents/notes/implemented/simplification/2026-07-31-drop-user-message-edit-stub.md)).
 - **The sparkle icon for the others tool row is a hand-drawn approximation** — the design glyph's vector geometry is not exportable locally; promotion into ui-primitives waits on an exact export.
 - **The approval panel's "Always allow this type" is deferred** — durable grants need a grant-storage design; only allow-once/reject answer today.
 - **TodoPanel truncates long item text to one ellipsized line** — the figma strip has no wrap or expand affordance; full text is not readable inline.

packages/client/ui-conversation/README.zh.md

@@ -14,7 +14,7 @@
 
 已记录的非用户消息渲染为默认折叠的 `上下文注入` 展开项。它通过包内部的 `DisclosureRow` 与 `ToolRow` 共享 Tool calls 标题栏的几何与交互，同时保留上下文语义：展开内容区的高度会随内容自适应，最大为 141px，超出后滚动，并以内联 JSON 展示 `content` 和 `source`，且不会合成工具状态、摘要或键控 toolview 分发（[决策](../../../.agents/notes/implemented/feature/2026-07-30-web-context-injection-disclosure.md)）。
 
-Think 行默认保持折叠，并在不展开思维链的情况下暴露实时推理吞吐：当 reasoning block 是流式尾部时，摘要从结算后的首行切换到最新的非空行，其单行滚动区会随每个 delta 追到行内末端。展开该行会移除移动摘要，让完整 reasoning 进入普通页面流，因此页面阅读不会与内部跟随器争夺滚动；结算后恢复左对齐的稳定首行摘要（[决策](../../../.agents/notes/implemented/feature/2026-08-02-web-thinking-tail-scroll.md)）。
+Think 行默认保持折叠，并在不展开思维链的情况下暴露实时推理（reasoning）吞吐：当推理块是流式输出尾部时，摘要从结算后的首行切换到最新的非空行，其单行滚动区会随每个 delta 追到行内末端。展开该行会移除移动摘要，让完整推理进入普通页面流，因此页面阅读不会与内部跟随器争夺滚动；结算后恢复左对齐的稳定首行摘要（[决策](../../../.agents/notes/implemented/feature/2026-08-02-web-thinking-tail-scroll.md)）。
 
 通用工具行把内置的 bash、read、search、write、edit 和 run_code 名称归入专用视觉变体。文件系统变体会渲染 edit 图标和路径摘要；该路径是悬停下划线链接，点击后通过宿主操作系统的默认应用打开文件（`host.openPath`，相对路径相对会话 cwd 解析）。工具行不再是整行点击目标，也不会打开 details 面板。code 变体以模型撰写的 `description` 作摘要，展开后显示程序本身；其已记录的子调用经由同一个键控 toolview 空位渲染为始终可见的嵌套行（自定义注册和 GenericToolCard fallback 原样适用于子行）。Cordis 生命周期工具复用这些通用变体，同时以统一的 Cordis 强调色呈现 `Inspect`、`Mount temporary Plugin` 和 `Unmount temporary Plugin`；mount 行保留 code 变体的可展开源码渲染。
 
@@ -38,7 +38,7 @@ todo 两个面就是在该形状上的两个注册项，都是普通注册方插
 
 `QueueDock` 是 `order: 20` 的末端 input-dock 条目。队列为空时隐藏；只有一个待处理项时直接渲染该行；存在两个或更多待处理项时，默认收起为 `"<n> 条排队消息"` 表头，其按钮可展开或收起完整列表。表头暴露 `aria-expanded` 和 `aria-controls`；展开后的列表以 180px 为高度上限，并可滚动。存在进行中的编辑或变更时，列表行会保持可见；队列清空后，下一次出现队列时会恢复默认收起状态。普通会话中的每条可见行仍是单行预览，并提供针对精确单次入队项的编辑、删除和严格 steering（中途引导）操作；已寻址 subagent 则保留只读行，因为其继续执行传输不提供 Queue 变更。如果严格 steering 输给已关闭的窗口，原单次入队项会留在 Queue 中正常投递；如果驱动器已经认领该项，正常投递就已开始。这两种已收敛的竞态都不显示失败，传输和未知错误仍会显示。
 
-Host 带 placement 的 `session/queue` 快照也会携带待处理 steering。QueueDock 会将其过滤掉，ChatView 则把它投影为会话流末尾带复制操作的用户样式气泡；消息尚未进入持久轮次，因此不显示 fork。Host 会等持久 `steering/message` 进入 mux 流之后再退役 steering。客户端运行时接纳该实时事件时，会在发布快照前退役第一个匹配的当前 steering 单次入队项；历史事件无法隐藏后来复用同一 `MessageId` 的单次入队项。气泡交接时因而不会产生空档或重复，会从持久节点恢复复制与 fork 操作，并能在重连后从同一权威恢复。
+Host 带 placement 的 `session/queue` 快照也会携带待处理 steering。QueueDock 会将其过滤掉，ChatView 则把它投影为会话流末尾带复制操作的用户样式气泡；消息尚未进入持久轮次，因此不显示 fork。Host 会等持久 `steering/message` 进入 mux 流之后再退役 steering。客户端运行时接纳该实时事件时，会在发布快照前退役第一个匹配的当前 steering 单次入队项；历史事件无法隐藏后来复用同一 `MessageId` 的单次入队项。气泡交接时因而不会产生空档或重复，会立即从持久节点恢复复制操作与分支控件，仅当该节点是已完成轮次的 transcript 尾部时才启用分支，并能在重连后从同一权威恢复。
 
 键盘消息提交会根据所寻址会话的运行状态和 steering 能力解析投递方式。空闲时，Enter 和 Cmd/Ctrl+Enter 都执行普通 Queue 发送。主会话运行期间，浏览器持久化的 General Settings 偏好会把普通 Enter 分配为 `Queue`（默认值）或 `Steer`，Cmd/Ctrl+Enter 则执行另一种行为；Shift+Enter 仍然换行。已寻址 subagent 即使正在运行，也会让这两个手势都使用其仅支持 Queue 的继续执行传输。该偏好只影响支持 steering 的繁忙态手势对，发送按钮与非键盘提交操作仍使用 Queue。Composer Steer 复用现有尽力而为的 `session.prompt(mode: 'steer')` 契约：如果当前 next-step 窗口在接纳前关闭，AgentLoop 会把消息接纳为下一条唤醒 Queue 轮次，不显示失败，也不会丢失草稿事务。
 
@@ -63,8 +63,8 @@ Host 带 placement 的 `session/queue` 快照也会携带待处理 steering。Qu
 - **压缩标记不显示规模**：该行尚不报告检查点替换了多少条消息或哪段范围。
 - **统计行的耗时只覆盖窗口内消息流**：LLM 与工具墙钟时间由快照的 assistant `timing` 与工具 call/result 配对折算，落在已加载事件窗口之外的节点（更早的历史）不计入。
 - **详情面板是最小形态，且当前没有入口**：以原始形式显示已选择调用的参数／结果；Input/Output/Metadata 切换、Prev/Next 步进与 See-in-trajectory 深链接暂缓实现。工具行已不再是详情面板的点击目标，且没有任何手势接替它，因此 `ChatViewInjected.openDetails` 虽已实现却无人调用，该面板（含其终端卡片）在组装后的应用中不可达；其渲染仍由直接以选中态挂载它来覆盖。
-- **assistant 逐消息分页是预留 slot**：设计中已有图稿，尚未实现。已定稿的内容 IconActions 行（复制／分支／时钟）只挂在每个轮次中最后一条带 text 内容的 assistant 下；轮次中间的叙述与纯 Think 节点不带 chrome。分支会 fork 到包含该消息的轮次末尾，在 client 端递增继承标题后打开子会话，而 fork 或改名失败时源会话保持选中。
-- **已发送的 user 消息无法编辑**：user 气泡的 IconActions 行只有时钟／复制／分支，从该消息分支是最接近的手势。该控件要与其背后的能力一起回归：既需要针对已定稿 user 消息的 client 变更，也需要 host 侧对已经消费过它的轮次给出行为（[决策](../../../.agents/notes/implemented/simplification/2026-07-31-drop-user-message-edit-stub.md)）。
+- **assistant 逐消息分页是预留 slot**：设计中已有图稿，尚未实现。已定稿的内容 IconActions 行（复制／时钟／分支）只挂在每个轮次中最后一条带 text 内容的 assistant 下；轮次中间的叙述与纯 Think 节点不带 chrome。除非该消息同时也是已完成轮次的最后一个 transcript 节点，否则分支保持禁用；启用后，它会 fork 到该轮次末尾，在 client 端递增继承标题并打开子会话。fork 或改名失败时源会话保持选中（[决策](../../../.agents/notes/implemented/bug-fix/2026-08-02-message-fork-actions-require-completed-turn-tail.md)）。
+- **已发送的 user 消息无法编辑**：user 气泡保留时钟、复制和分支；除非已完成轮次的 transcript 结束于该 user 消息，否则分支保持禁用。编辑功能要与其背后的能力一起回归：既需要针对已定稿 user 消息的 client 变更，也需要 host 侧对已经消费过它的轮次给出行为（[决策](../../../.agents/notes/implemented/simplification/2026-07-31-drop-user-message-edit-stub.md)）。
 - **others 工具行的闪光图标是手绘近似版本**：无法在本地导出设计字形的矢量几何；等到存在精确导出后再将其提升到 ui-primitives。
 - **审批面板的「始终允许此类」暂缓**：持久授权需要授权存储设计；今天只能回答允许一次／拒绝。
 - **TodoPanel 将过长条目截成单行省略号**：figma 条没有换行或展开入口，完整文本无法在行内读完。

packages/client/ui-conversation/src/client/chat/AssistantMarkdown.tsx

@@ -4,9 +4,10 @@
 // view groups them into tool rows through its keyed toolview slot (figma
 // step-summary flow). Shared by finalized nodes and the streaming partial;
 // the turn-level loading dots live in the chat view's tail, not here.
-// Finalized turn-tail content (text) nodes append IconActions once streaming
-// ends (`time` is omitted for mid-turn narration); Think / tool-head-only
-// nodes stay chrome-free.
+// Finalized content (text) nodes append IconActions once streaming ends
+// (`time` is omitted for mid-turn narration); their branch action is enabled
+// only when the node is also the completed turn's transcript tail. Think /
+// tool-head-only nodes stay chrome-free.
 
 import { memo, useMemo } from 'react'
 import type { AssistantBlock } from '@deepseek-ai/dsh-client-runtime/client'
@@ -28,8 +29,10 @@ export interface AssistantMarkdownProps {
   time?: number | undefined
   /** Event sequence used as the fork boundary; omitted while streaming. */
   seq?: number | undefined
-  /** Fork the session through the turn containing this finalized message. */
+  /** Fork the session through this finalized message's completed turn when eligible. */
   onFork?: ((seq: number) => void) | undefined
+  /** The message is not the transcript tail of a completed turn. */
+  forkUnavailable?: boolean | undefined
   /** The owning view's locale seat, passed down as a plain prop. */
   t: ChatViewSlotProps['t']
 }
@@ -76,7 +79,7 @@ function ThinkRow({ text, running, t }: { text: string; running: boolean; t: Ass
 }
 
 export const AssistantMarkdown = memo(function AssistantMarkdown({
-  blocks, streaming, interrupted, time, seq, onFork, t,
+  blocks, streaming, interrupted, time, seq, onFork, forkUnavailable, t,
 }: AssistantMarkdownProps) {
   // Stable per locale revision (t identity changes on switch): a fresh object
   // per render would rebuild MarkdownText's component table every chunk.
@@ -120,6 +123,7 @@ export const AssistantMarkdown = memo(function AssistantMarkdown({
           time={time}
           clock="end"
           onBranch={onFork === undefined || seq === undefined ? undefined : () => { onFork(seq) }}
+          branchUnavailable={forkUnavailable}
           className={css.actions}
           t={t}
         />

packages/client/ui-conversation/src/client/chat/ChatView.tsx

@@ -30,7 +30,7 @@ import type {
 import type { SnapshotSelectorHook } from '@deepseek-ai/dsh-client-ui-slots'
 import { IconChevronDownOutline14 } from '@deepseek-ai/dsh-client-ui-primitives'
 import type { ChatViewSlotProps } from '../contract/slots.ts'
-import { assistantActionsSeqs, deriveChatFlow, type ChatFlowItem } from './chat-flow.ts'
+import { assistantActionsSeqs, deriveChatFlow, messageBranchSeqs, type ChatFlowItem } from './chat-flow.ts'
 import { AssistantMarkdown } from './AssistantMarkdown.tsx'
 import { GenericCommandCard } from './GenericCommandCard.tsx'
 import { GenericToolCard } from './GenericToolCard.tsx'
@@ -236,6 +236,7 @@ export function ChatView({
   useSession, useSessions, useStore, renderSlot, sessionId, openFile, loadOlder, inspectCall, chatScroll, forkAt, t,
 }: ChatViewSlotProps) {
   const nodes = useSession(s => s.nodes)
+  const turnEnds = useSession(s => s.turnEnds)
   const inbox = useSession(s => s.queue)
   // Workspace root off the session list row: path summaries display relative to it.
   const cwd = useSessions(s => s.byId[sessionId]?.cwd)
@@ -257,6 +258,7 @@ export function ChatView({
   // Only the last content assistant of each turn owns IconActions; mid-turn
   // text (before tools) omits `time` so AssistantMarkdown stays chrome-free.
   const actionSeqs = useMemo(() => assistantActionsSeqs(nodes), [nodes])
+  const branchSeqs = useMemo(() => messageBranchSeqs(nodes, turnEnds), [nodes, turnEnds])
 
   const listRef = useRef<HTMLDivElement | null>(null)
   const atBottomRef = useRef(true)
@@ -413,6 +415,7 @@ export function ChatView({
           time={actionSeqs.has(node.seq) ? node.time : undefined}
           seq={node.seq}
           onFork={forkAt}
+          forkUnavailable={!branchSeqs.has(node.seq)}
           t={t}
         />
       )
@@ -428,6 +431,7 @@ export function ChatView({
         node={node}
         retryActive={node.kind === 'model-retry' && node.seq === activeRetry}
         onFork={forkAt}
+        forkUnavailable={!branchSeqs.has(node.seq)}
         t={t}
       />
     )

packages/client/ui-conversation/src/client/chat/MessageIconActions.module.css

@@ -43,3 +43,23 @@
   background: var(--dsw-alias-interactive-bg-hover);
   color: var(--dsw-alias-label-secondary);
 }
+
+/* Unavailable stays focusable and hoverable so Tooltip can explain why. */
+.action[data-unavailable] {
+  cursor: default;
+  opacity: 0.4;
+}
+
+.action[data-unavailable]:hover {
+  background: transparent;
+  color: var(--dsw-alias-label-tertiary);
+}
+
+.visuallyHidden {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  overflow: hidden;
+  clip: rect(0 0 0 0);
+  white-space: nowrap;
+}

packages/client/ui-conversation/src/client/chat/MessageIconActions.tsx

@@ -1,7 +1,7 @@
 // Shared IconActions chrome for user, steering, and assistant messages: copy
 // live, optional branch wiring, and an optional date-aware clock.
 
-import { useCallback } from 'react'
+import { useCallback, useId } from 'react'
 import {
   IconBranchOutline16, IconCopyOutline16, Tooltip,
 } from '@deepseek-ai/dsh-client-ui-primitives'
@@ -17,9 +17,11 @@ export interface MessageIconActionsProps {
   time?: number | undefined
   /** Clock before icons (user) or after (assistant). */
   clock: 'start' | 'end'
-  /** Fork the session at this message. */
+  /** Fork the session at this message; omission hides the branch action. */
   onBranch?: (() => void) | undefined
-  /** Whether to render the branch action; defaults to true. */
+  /** The message is not a completed transcript tail, so branch stays visible but unavailable. */
+  branchUnavailable?: boolean | undefined
+  /** Additional branch visibility gate for transient message chrome; defaults to true. */
   showBranch?: boolean | undefined
   /** Parent layout class composed onto the actions row. */
   className?: string | undefined
@@ -33,9 +35,10 @@ export interface MessageIconActionsProps {
  * @returns The actions row element.
  */
 export function MessageIconActions({
-  text, time, clock, onBranch, showBranch = true, className, t,
+  text, time, clock, onBranch, branchUnavailable = false, showBranch = true, className, t,
 }: MessageIconActionsProps) {
   const day = useCalendarDay()
+  const reasonId = useId()
   const onCopy = useCallback(() => {
     void writeClipboard(text)
   }, [text])
@@ -52,13 +55,25 @@ export function MessageIconActions({
           <IconCopyOutline16 />
         </button>
       </Tooltip>
-      {showBranch && (
-        <Tooltip label={t('message.branch')} side="bottom">
-          <button type="button" className={css.action} aria-label={t('message.branch')} onClick={onBranch}>
+      {showBranch && onBranch !== undefined && (
+        <Tooltip label={branchUnavailable ? t('message.branchUnavailable') : t('message.branch')} side="bottom">
+          {/* Native disabled buttons do not deliver the hover/focus events Tooltip needs. */}
+          <button
+            type="button"
+            className={css.action}
+            aria-label={t('message.branch')}
+            aria-disabled={branchUnavailable || undefined}
+            aria-describedby={branchUnavailable ? reasonId : undefined}
+            data-unavailable={branchUnavailable || undefined}
+            onClick={branchUnavailable ? undefined : onBranch}
+          >
             <IconBranchOutline16 />
           </button>
         </Tooltip>
       )}
+      {showBranch && onBranch !== undefined && branchUnavailable && (
+        <span id={reasonId} className={css.visuallyHidden}>{t('message.branchUnavailable')}</span>
+      )}
       {clock === 'end' ? clockEl : null}
     </div>
   )

packages/client/ui-conversation/src/client/chat/MessageItem.tsx

@@ -26,8 +26,10 @@ export interface MessageItemProps {
     | TurnErrorNode
     | UnknownSurfaceNode
   retryActive?: boolean
-  /** Fork the session through the turn containing this message (user-bubble branch action). */
+  /** Fork through this message's completed turn when eligible. */
   onFork?: (seq: number) => void
+  /** The message is not the transcript tail of a completed turn. */
+  forkUnavailable?: boolean
   /** The owning view's locale seat, passed down as a plain prop. */
   t: ChatViewSlotProps['t']
 }
@@ -220,7 +222,7 @@ export function PendingSteeringBubble({ content, t }: {
 }
 
 export const MessageItem = memo(function MessageItem({
-  node, retryActive = false, onFork, t,
+  node, retryActive = false, onFork, forkUnavailable = false, t,
 }: MessageItemProps) {
   const truncated = (total: number): string => t('json.truncated', { total })
   switch (node.kind) {
@@ -236,6 +238,7 @@ export const MessageItem = memo(function MessageItem({
               time={node.time}
               clock="start"
               onBranch={onFork === undefined ? undefined : () => { onFork(node.seq) }}
+              branchUnavailable={forkUnavailable}
               className={css.actions}
               t={t}
             />

packages/client/ui-conversation/src/client/chat/chat-flow.ts

@@ -5,8 +5,8 @@
  * reuse the first notice's row while projecting the latest retry turn.
  * Item identity keys are stable across snapshots so the list parent can
  * subscribe to keys only while rows subscribe to content. IconActions ownership
- * (last content assistant per turn) is derived here too so ChatView and the
- * flow share one gate.
+ * and completed-turn branch points are derived here too so ChatView and the
+ * flow share their gates.
  */
 import type {
   AssistantBlock, ConversationNode, ToolResultNode,
@@ -47,6 +47,39 @@ export function assistantActionsSeqs(nodes: readonly ConversationNode[]): Readon
   return new Set(lastByTurn.values())
 }
 
+/**
+ * Seq set of message rows that may fork: the last transcript node of a
+ * completed turn, when that node owns message chrome. A later tool, reasoning,
+ * error, or other transcript node leaves the earlier message's branch action
+ * unavailable because the Host would include the whole turn.
+ * @param nodes - snapshot nodes in event order.
+ * @param turnEnds - completed turn boundaries retained from the event window.
+ * @returns Message seq values whose visible position matches the fork boundary.
+ */
+export function messageBranchSeqs(
+  nodes: readonly ConversationNode[],
+  turnEnds: ReadonlyMap<number, number>,
+): ReadonlySet<number> {
+  const result = new Set<number>()
+  const boundaries = [...turnEnds].sort((a, b) => a[1] - b[1])
+  let nodeIndex = 0
+  for (const [turn, endSeq] of boundaries) {
+    let tail: ConversationNode | undefined
+    while (nodeIndex < nodes.length) {
+      const candidate = nodes[nodeIndex]
+      if (candidate === undefined || candidate.seq > endSeq) break
+      tail = candidate
+      nodeIndex++
+    }
+    if (tail?.kind === 'user'
+      || (tail?.kind === 'steering' && tail.turn === turn)
+      || (tail?.kind === 'assistant' && tail.turn === turn && hasContentText(tail.blocks))) {
+      result.add(tail.seq)
+    }
+  }
+  return result
+}
+
 /**
  * Group finalized nodes into the step-summary flow.
  * @param nodes - snapshot nodes in human-transcript and durable-notice order.

packages/client/ui-conversation/src/client/contract/slots.ts

@@ -461,7 +461,7 @@ export interface ChatViewInjected {
     /** Last recorded offset, or null when pinned or never recorded. */
     read: () => number | null
   }
-  /** Fork the session through the turn containing the message at `seq`, then open the child. */
+  /** Fork through the completed turn ending at the eligible message `seq`, then open the child. */
   forkAt: (seq: number) => void
 }
 

packages/client/ui-conversation/src/client/locales.ts

@@ -59,6 +59,7 @@ export const zh = {
   'message.unknownBlock': '未知内容块',
   'message.stopped': '已停止',
   'message.branch': '在新对话中分支',
+  'message.branchUnavailable': '仅可从已完成轮次的最后一条消息分支',
   'message.retry.active': '正在重试模型请求',
   'message.retry.cancelled': '模型请求重试已取消',
   'message.retry.started': '已重试模型请求',
@@ -166,6 +167,7 @@ export const en = {
   'message.unknownBlock': 'Unknown content block',
   'message.stopped': 'Stopped',
   'message.branch': 'Branch into a new conversation',
+  'message.branchUnavailable': 'Available only on the last message of a completed turn',
   'message.retry.active': 'Retrying model request',
   'message.retry.cancelled': 'Model request retry cancelled',
   'message.retry.started': 'Retried model request',

packages/client/ui-conversation/tests/chat-branch-tails.spec.tsx

@@ -36,12 +36,14 @@ describe('MessageItem arms', () => {
     // Same-day clock: construct "today at 14:24" so the label stays `HH:mm`.
     const now = new Date()
     const time = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 14, 24).getTime()
+    const onFork = vi.fn()
     render(
       <MessageItem t={t} node={{
         kind: 'user', seq: 1, time,
         content: [{ type: 'text', text: 'hello bubble' }] as never,
         source: null,
       }}
+      onFork={onFork}
       />,
     )
     expect(screen.getByText('14:24')).toBeTruthy()
@@ -50,6 +52,8 @@ describe('MessageItem arms', () => {
     expect(screen.queryByRole('button', { name: '编辑' })).toBeNull()
     fireEvent.click(screen.getByRole('button', { name: '复制' }))
     expect(writeText).toHaveBeenCalledWith('hello bubble')
+    fireEvent.click(screen.getByRole('button', { name: '在新对话中分支' }))
+    expect(onFork).toHaveBeenCalledWith(1)
   })
 
   it('user copy falls back to execCommand when clipboard.writeText is unavailable', () => {
@@ -74,6 +78,30 @@ describe('MessageItem arms', () => {
     expect(exec).toHaveBeenCalledWith('copy')
   })
 
+  it('keeps an unavailable branch focusable and explains why without sending a fork', () => {
+    const onFork = vi.fn()
+    render(
+      <MessageItem t={t} node={{
+        kind: 'user', seq: 1, time: 1_000,
+        content: [{ type: 'text', text: 'open turn' }] as never,
+        source: null,
+      }}
+      onFork={onFork}
+      forkUnavailable
+      />,
+    )
+    const branch = screen.getByRole('button', { name: '在新对话中分支' }) as HTMLButtonElement
+    expect(branch.disabled).toBe(false)
+    expect(branch.getAttribute('aria-disabled')).toBe('true')
+    const reasonId = branch.getAttribute('aria-describedby')
+    expect(reasonId).not.toBeNull()
+    expect(document.getElementById(reasonId!)?.textContent).toBe('仅可从已完成轮次的最后一条消息分支')
+    fireEvent.click(branch)
+    expect(onFork).not.toHaveBeenCalled()
+    fireEvent.focus(branch)
+    expect(screen.getByRole('tooltip').textContent).toBe('仅可从已完成轮次的最后一条消息分支')
+  })
+
   it('user copy stays quiet when execCommand throws or is absent', () => {
     Object.defineProperty(navigator, 'clipboard', {
       configurable: true,
@@ -420,12 +448,15 @@ describe('small branch tails', () => {
     })
     const now = new Date()
     const time = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 14, 24).getTime()
+    const onFork = vi.fn()
     const settled = render(
       <AssistantMarkdown
         t={t}
         blocks={[{ kind: 'text', text: 'answer body' }, { kind: 'reasoning', text: 'hidden' }]}
         streaming={false}
         time={time}
+        seq={3}
+        onFork={onFork}
       />,
     )
     expect(settled.getByText('14:24')).toBeTruthy()
@@ -433,6 +464,8 @@ describe('small branch tails', () => {
     expect(settled.getByRole('button', { name: '在新对话中分支' })).toBeTruthy()
     fireEvent.click(settled.getByRole('button', { name: '复制' }))
     expect(writeText).toHaveBeenCalledWith('answer body')
+    fireEvent.click(settled.getByRole('button', { name: '在新对话中分支' }))
+    expect(onFork).toHaveBeenCalledWith(3)
     settled.unmount()
 
     const thinkOnly = render(

packages/client/ui-conversation/tests/chat-code-subcalls.spec.tsx

@@ -67,7 +67,7 @@ function snapshotWith(
   runningCalls: RunningToolCall[] = [],
 ): ConversationSnapshot {
   return {
-    sessionId: SID, nodes, partial: null, runningCalls, codeDispatches,
+    sessionId: SID, nodes, turnEnds: new Map(), partial: null, runningCalls, codeDispatches,
     pending: [], queue: [], running: runningCalls.length > 0, composerPhase: 'active', removed: false,
     openState: 'open', openError: null,
     hasMore: false, loadingOlder: false, promptError: null, blank: false, subagent: null, lastAgentError: null,

packages/client/ui-conversation/tests/chat-stats-bash-sample.spec.tsx

@@ -32,7 +32,7 @@ const assistant = (seq: number, turn: number, usage?: unknown): AssistantMessage
 
 function snapshotBase(): ConversationSnapshot {
   return {
-    sessionId: SID, nodes: [], partial: null, runningCalls: [], codeDispatches: new Map(),
+    sessionId: SID, nodes: [], turnEnds: new Map(), partial: null, runningCalls: [], codeDispatches: new Map(),
     pending: [], queue: [], running: false, composerPhase: 'active', removed: false, openState: 'open', openError: null,
     hasMore: false, loadingOlder: false, promptError: null, blank: false, subagent: null, lastAgentError: null,
   }

packages/client/ui-conversation/tests/chat-view.spec.tsx

@@ -20,7 +20,7 @@ import { zh as commonZh } from '@deepseek-ai/dsh-client-locale/src/locales/zh.ts
 import { createChatStore } from '../src/client/stores.ts'
 import { ChatView } from '../src/client/chat/ChatView.tsx'
 import { zh } from '../src/client/locales.ts'
-import { assistantActionsSeqs, deriveChatFlow, flowKeys } from '../src/client/chat/chat-flow.ts'
+import { assistantActionsSeqs, deriveChatFlow, flowKeys, messageBranchSeqs } from '../src/client/chat/chat-flow.ts'
 
 afterEach(cleanup)
 // Keyless create() persists under the bare declared key; clear between cases
@@ -33,7 +33,7 @@ const SID = 's1' as SessionId
 
 function snapshotBase(): ConversationSnapshot {
   return {
-    sessionId: SID, nodes: [], partial: null, runningCalls: [], codeDispatches: new Map(),
+    sessionId: SID, nodes: [], turnEnds: new Map(), partial: null, runningCalls: [], codeDispatches: new Map(),
     pending: [], queue: [], running: false, composerPhase: 'active', removed: false, openState: 'open', openError: null,
     hasMore: false, loadingOlder: false, promptError: null, blank: false, subagent: null, lastAgentError: null,
   }
@@ -211,6 +211,29 @@ describe('chat-flow derivation', () => {
     ])
     expect([...seqs].sort((a, b) => a - b)).toEqual([5, 7])
   })
+
+  it('messageBranchSeqs keeps only message rows at completed transcript tails', () => {
+    const interruptedThink: AssistantMessageNode = {
+      kind: 'assistant', seq: 4.1, time: 4_100, turn: 1, step: 2,
+      blocks: [{ kind: 'reasoning', text: 'bad path' }], interrupted: true,
+    }
+    const nodes: ConversationNode[] = [
+      user(1, 'first'),
+      assistant(2, 'answer before tools'),
+      toolResult(3, 'a'),
+      interruptedThink,
+      user(6, 'second'),
+      assistant(7, 'clean tail', 2),
+      user(10, 'user-only tail'),
+      {
+        kind: 'steering', messageId: 'steering-tail' as never,
+        seq: 13, time: 13_000, turn: 4,
+        content: [{ type: 'text', text: 'steering tail' }], source: null,
+      },
+    ]
+    const seqs = messageBranchSeqs(nodes, new Map([[1, 5], [2, 8], [3, 11], [4, 14]]))
+    expect([...seqs]).toEqual([7, 10, 13])
+  })
 })
 
 describe('ChatView', () => {
@@ -302,8 +325,18 @@ describe('ChatView', () => {
     expect(view.getAllByText('interrupt now')).toHaveLength(1)
     expect(view.container.querySelector('[data-pending-steering]')).toBeNull()
     expect(view.getAllByRole('button', { name: '复制' })).toHaveLength(2)
+    const durableBubble = view.getByText('interrupt now').closest('[class*="userRow"]') as HTMLElement
+    const unavailable = within(durableBubble).getByRole('button', { name: '在新对话中分支' })
+    expect(unavailable.getAttribute('aria-disabled')).toBe('true')
+    fireEvent.click(unavailable)
+    expect(h.forkAt).not.toHaveBeenCalled()
+
+    act(() => {
+      h.set({ running: false, turnEnds: new Map([[1, 3]]) })
+    })
     const branchButtons = view.getAllByRole('button', { name: '在新对话中分支' })
     expect(branchButtons).toHaveLength(2)
+    expect(branchButtons.map(button => button.getAttribute('aria-disabled'))).toEqual(['true', null])
     fireEvent.click(branchButtons[1]!)
     expect(h.forkAt).toHaveBeenCalledWith(2)
   })
@@ -404,21 +437,47 @@ describe('ChatView', () => {
         user(5, 'next'),
         assistant(6, 'second turn', 2),
       ],
+      turnEnds: new Map([[1, 4], [2, 6]]),
     })
     const view = render(<h.ChatView {...h.props} />)
-    // 2 user + 2 turn-tail assistants; mid-turn text at seq 2 stays chrome-free.
+    // Every message footer keeps branch visible; only completed assistant tails enable it.
     expect(view.getAllByRole('button', { name: '复制' })).toHaveLength(4)
-    expect(view.getAllByRole('button', { name: '在新对话中分支' })).toHaveLength(4)
+    const branchButtons = view.getAllByRole('button', { name: '在新对话中分支' })
+    expect(branchButtons).toHaveLength(4)
+    expect(branchButtons.map(button => button.getAttribute('aria-disabled'))).toEqual(['true', null, 'true', null])
   })
 
-  it('forks from both user and finalized assistant message actions at their event seq', () => {
-    const h = makeHarness({ nodes: [user(1, 'question'), assistant(2, 'answer')] })
+  it('enables fork only on the finalized assistant at the completed transcript tail', () => {
+    const h = makeHarness({
+      nodes: [user(1, 'question'), assistant(2, 'answer')],
+      turnEnds: new Map([[1, 3]]),
+    })
     const view = render(<h.ChatView {...h.props} />)
     const buttons = view.getAllByRole('button', { name: '在新对话中分支' })
     expect(buttons).toHaveLength(2)
+    expect(buttons.map(button => button.getAttribute('aria-disabled'))).toEqual(['true', null])
     fireEvent.click(buttons[0]!)
     fireEvent.click(buttons[1]!)
-    expect(h.forkAt.mock.calls).toEqual([[1], [2]])
+    expect(h.forkAt.mock.calls).toEqual([[2]])
+  })
+
+  it('keeps branch visible but unavailable when tool and interrupted Think follow the response', () => {
+    const interruptedThink: AssistantMessageNode = {
+      kind: 'assistant', seq: 4.1, time: 4_100, turn: 1, step: 2,
+      blocks: [{ kind: 'reasoning', text: 'bad path' }], interrupted: true,
+    }
+    const h = makeHarness({
+      nodes: [user(1, 'question'), assistant(2, 'answer'), toolResult(3, 'a'), interruptedThink],
+      turnEnds: new Map([[1, 5]]),
+    })
+    const view = render(<h.ChatView {...h.props} />)
+    expect(view.getAllByRole('button', { name: '复制' })).toHaveLength(2)
+    const buttons = view.getAllByRole('button', { name: '在新对话中分支' })
+    expect(buttons).toHaveLength(2)
+    expect(buttons.every(button => button.getAttribute('aria-disabled') === 'true')).toBe(true)
+    fireEvent.click(buttons[0]!)
+    fireEvent.click(buttons[1]!)
+    expect(h.forkAt).not.toHaveBeenCalled()
   })
 
   it('renders assistant Markdown across history, streaming, final, and interrupted states while user text stays literal', () => {

packages/client/ui-conversation/tests/diff-card.spec.tsx

@@ -335,7 +335,7 @@ describe('DetailsPanel diff Output section', () => {
 
   function snapshot(over: Partial<ConversationSnapshot> = {}): ConversationSnapshot {
     return {
-      sessionId: SID, nodes: [], partial: null, runningCalls: [], codeDispatches: new Map(),
+      sessionId: SID, nodes: [], turnEnds: new Map(), partial: null, runningCalls: [], codeDispatches: new Map(),
       pending: [], queue: [], running: false, composerPhase: 'active', removed: false,
       openState: 'open', openError: null, hasMore: false, loadingOlder: false,
       promptError: null, blank: false, subagent: null, lastAgentError: null, ...over,

packages/client/ui-conversation/tests/gate-branch-tails.spec.tsx

@@ -24,7 +24,7 @@ const SID = 's1' as SessionId
 
 function snapshotBase(): ConversationSnapshot {
   return {
-    sessionId: SID, nodes: [], partial: null, runningCalls: [], codeDispatches: new Map(),
+    sessionId: SID, nodes: [], turnEnds: new Map(), partial: null, runningCalls: [], codeDispatches: new Map(),
     pending: [], queue: [], running: false, composerPhase: 'active', removed: false, openState: 'open', openError: null,
     hasMore: false, loadingOlder: false, promptError: null, blank: false, subagent: null, lastAgentError: null,
   }

packages/client/ui-conversation/tests/input-bar.spec.tsx

@@ -23,7 +23,7 @@ const SID = 's1' as SessionId
 
 function snapshotOf(overrides: Partial<ConversationSnapshot> = {}): ConversationSnapshot {
   return {
-    sessionId: SID, nodes: [], partial: null, runningCalls: [], codeDispatches: new Map(),
+    sessionId: SID, nodes: [], turnEnds: new Map(), partial: null, runningCalls: [], codeDispatches: new Map(),
     pending: [], queue: [], running: false, composerPhase: 'active', removed: false,
     openState: 'open', openError: null, hasMore: false, loadingOlder: false,
     promptError: null, blank: false, subagent: null, lastAgentError: null,

packages/client/ui-conversation/tests/input-matrix.spec.tsx

@@ -26,7 +26,7 @@ const SID = 's1' as SessionId
 /** Standard-props InputBar mount over a real shell (the composer-bar entry shape). */
 function mountBar(shell: SessionInputShell, over?: { running?: boolean; disabled?: boolean }) {
   const session = createSnapshotStore<ConversationSnapshot>({
-    sessionId: SID, nodes: [], partial: null, runningCalls: [], codeDispatches: new Map(),
+    sessionId: SID, nodes: [], turnEnds: new Map(), partial: null, runningCalls: [], codeDispatches: new Map(),
     pending: [], queue: [], running: over?.running ?? false, composerPhase: 'active',
     removed: over?.disabled ?? false, openState: 'open', openError: null, hasMore: false,
     loadingOlder: false, promptError: null, blank: false, subagent: null, lastAgentError: null,

packages/client/ui-conversation/tests/input-scenarios.spec.tsx

@@ -112,7 +112,7 @@ async function scopedBench(register?: (slash: SlashService) => void) {
   actx.on('slash/input-consume-token', req => shell.consumeToken(req.guard) ? true : undefined)
   const wiring = shell
   const sessionStore = createSnapshotStore<ConversationSnapshot>({
-    sessionId, nodes: [], partial: null, runningCalls: [], codeDispatches: new Map(),
+    sessionId, nodes: [], turnEnds: new Map(), partial: null, runningCalls: [], codeDispatches: new Map(),
     pending: [], queue: [], running: false, composerPhase: 'active', removed: false,
     openState: 'open', openError: null, hasMore: false, loadingOlder: false,
     promptError: null, blank: false, subagent: null, lastAgentError: null,

packages/client/ui-conversation/tests/queue-dock.spec.tsx

@@ -32,7 +32,7 @@ function row(id: string, text: string | null, preview = text ?? '[image]'): Queu
 
 function snapshotWith(queue: QueuedMessage[]): ConversationSnapshot {
   return {
-    sessionId: SID, nodes: [], partial: null, runningCalls: [], codeDispatches: new Map(),
+    sessionId: SID, nodes: [], turnEnds: new Map(), partial: null, runningCalls: [], codeDispatches: new Map(),
     pending: [], queue, running: true, composerPhase: 'active', removed: false, openState: 'open', openError: null,
     hasMore: false, loadingOlder: false, promptError: null, blank: false, subagent: null, lastAgentError: null,
   }

packages/client/ui-conversation/tests/read-card.spec.tsx

@@ -283,7 +283,7 @@ describe('DetailsPanel Output section (read)', () => {
 
   function snapshot(over: Partial<ConversationSnapshot> = {}): ConversationSnapshot {
     return {
-      sessionId: SID, nodes: [], partial: null, runningCalls: [], codeDispatches: new Map(),
+      sessionId: SID, nodes: [], turnEnds: new Map(), partial: null, runningCalls: [], codeDispatches: new Map(),
       pending: [], queue: [], running: false, composerPhase: 'active', removed: false,
       openState: 'open', openError: null, hasMore: false, loadingOlder: false,
       promptError: null, blank: false, subagent: null, lastAgentError: null, ...over,

packages/client/ui-conversation/tests/search-card.spec.tsx

@@ -397,7 +397,7 @@ describe('DetailsPanel Output section (search)', () => {
 
   function snapshot(over: Partial<ConversationSnapshot> = {}): ConversationSnapshot {
     return {
-      sessionId: SID, nodes: [], partial: null, runningCalls: [], codeDispatches: new Map(),
+      sessionId: SID, nodes: [], turnEnds: new Map(), partial: null, runningCalls: [], codeDispatches: new Map(),
       pending: [], queue: [], running: false, composerPhase: 'active', removed: false,
       openState: 'open', openError: null, hasMore: false, loadingOlder: false,
       promptError: null, blank: false, subagent: null, lastAgentError: null, ...over,

packages/client/ui-conversation/tests/skeleton.spec.tsx

@@ -68,7 +68,7 @@ const workspaceState = (items: readonly WorkspaceView[]): WorkspaceListState =>
 
 function conversationSnapshot(overrides: Partial<ConversationSnapshot> = {}): ConversationSnapshot {
   return {
-    sessionId: SID, nodes: [], partial: null, runningCalls: [], codeDispatches: new Map(),
+    sessionId: SID, nodes: [], turnEnds: new Map(), partial: null, runningCalls: [], codeDispatches: new Map(),
     pending: [], queue: [], running: false, composerPhase: 'active', removed: false,
     openState: 'open', openError: null, hasMore: false, loadingOlder: false,
     promptError: null, blank: false, subagent: null, lastAgentError: null,

packages/client/ui-conversation/tests/terminal-card.spec.tsx

@@ -477,7 +477,7 @@ describe('DetailsPanel Output section', () => {
 
   function snapshot(over: Partial<ConversationSnapshot> = {}): ConversationSnapshot {
     return {
-      sessionId: SID, nodes: [], partial: null, runningCalls: [], codeDispatches: new Map(),
+      sessionId: SID, nodes: [], turnEnds: new Map(), partial: null, runningCalls: [], codeDispatches: new Map(),
       pending: [], queue: [], running: false, composerPhase: 'active', removed: false,
       openState: 'open', openError: null, hasMore: false, loadingOlder: false,
       promptError: null, blank: false, subagent: null, lastAgentError: null, ...over,

packages/client/ui-conversation/tests/web-card.spec.tsx

@@ -232,7 +232,7 @@ describe('DetailsPanel web Output section', () => {
 
   function snapshot(over: Partial<ConversationSnapshot> = {}): ConversationSnapshot {
     return {
-      sessionId: SID, nodes: [], partial: null, runningCalls: [], codeDispatches: new Map(),
+      sessionId: SID, nodes: [], turnEnds: new Map(), partial: null, runningCalls: [], codeDispatches: new Map(),
       pending: [], queue: [], running: false, composerPhase: 'active', removed: false,
       openState: 'open', openError: null, hasMore: false, loadingOlder: false,
       promptError: null, blank: false, subagent: null, lastAgentError: null, ...over,

packages/client/ui-primitives/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/client/ui-primitives/README.md
-README.md: 8bdc3f043488631424c85a4319020c3d8ba5437b
-README.zh.md: 52b507bb924ca4c05e92ed09d819339621c3bc20
+README.md: 7318acd9b9a6047b1144789bcd2655132237f6c5
+README.zh.md: e326846dc2099472bc0a81dff093ff24b614559b

packages/client/ui-primitives/README.md

@@ -10,7 +10,7 @@ Pure React atoms (zero cordis): StateDot, ic_ds_* icons, Button/Pill/Menu/Modal/
 
 ## Markdown rendering
 
-`MarkdownText` renders GFM and `$…$` / `$$…$$` TeX math from untrusted assistant output through React elements, with math typeset by KaTeX and trusted commands disabled. It omits raw HTML, neutralizes relative and non-HTTP(S)/mailto links, opens HTTP(S) links with safe external-link attributes, and renders image alt text without loading remote resources; `MessageText` remains the literal-text primitive for user-authored content. `extractMarkdownPlainText` removes Markdown presentation markup for compact labels while preserving raw HTML as literal text. Element spacing, tables, links, and inline code use the same `--dsw-alias-markdown-*` / `--dsw-font-markdown-*` tokens as deepsuite `@deepseek/md`. Fenced blocks render through `CodeBlock` (language banner, copy control, shiki for the registered grammars).
+`MarkdownText` renders GFM and `$…$` / `$$…$$` TeX math from untrusted assistant output through React elements, with math typeset by KaTeX and trusted commands disabled. It omits raw HTML, neutralizes relative and non-HTTP(S)/mailto links, opens HTTP(S) links with safe external-link attributes, and renders absolute HTTP(S) images without a referrer; relative paths, absolute local paths, `file:` URLs, and unsupported schemes retain their alt text. `MessageText` remains the literal-text primitive for user-authored content. `extractMarkdownPlainText` removes Markdown presentation markup for compact labels while preserving raw HTML as literal text. Element spacing, responsive images, tables, links, and inline code use the same `--dsw-alias-markdown-*` / `--dsw-font-markdown-*` tokens as deepsuite `@deepseek/md`. Fenced blocks render through `CodeBlock` (language banner, copy control, shiki for the registered grammars).
 
 ## Terminal output
 

packages/client/ui-primitives/README.zh.md

@@ -10,7 +10,7 @@
 
 ## Markdown 渲染
 
-`MarkdownText` 通过 React 元素渲染来自不受信任 assistant 输出的 GFM 与 `$…$` / `$$…$$` TeX 公式，公式由 KaTeX 排版并禁用受信任命令。它会省略原始 HTML，使相对链接及非 HTTP(S)/mailto 链接失效，以安全的外部链接属性打开 HTTP(S) 链接，并只渲染图片 alt 文本而不加载远程资源；`MessageText` 仍是用户创作内容使用的字面文本原语。`extractMarkdownPlainText` 会移除 Markdown 呈现标记以用于紧凑标签，同时将原始 HTML 保留为字面文本。元素间距、表格、链接与行内代码使用与 deepsuite `@deepseek/md` 相同的 `--dsw-alias-markdown-*` / `--dsw-font-markdown-*` token。围栏代码块通过 `CodeBlock` 渲染（语言横幅、复制控件，以及对已注册语法使用 shiki）。
+`MarkdownText` 通过 React 元素渲染来自不受信任 assistant 输出的 GFM 与 `$…$` / `$$…$$` TeX 公式，公式由 KaTeX 排版并禁用受信任命令。它会省略原始 HTML，使相对链接及非 HTTP(S)/mailto 链接失效，以安全的外部链接属性打开 HTTP(S) 链接，并在不发送 referrer 的情况下渲染采用绝对 HTTP(S) URL 的图片；相对路径、绝对本地路径、`file:` URL 与不受支持的 scheme 会保留其 alt 文本。`MessageText` 仍是用户创作内容使用的字面文本原语。`extractMarkdownPlainText` 会移除 Markdown 呈现标记以用于紧凑标签，同时将原始 HTML 保留为字面文本。元素间距、响应式图片、表格、链接与行内代码使用与 deepsuite `@deepseek/md` 相同的 `--dsw-alias-markdown-*` / `--dsw-font-markdown-*` token。围栏代码块通过 `CodeBlock` 渲染（语言横幅、复制控件，以及对已注册语法使用 shiki）。
 
 ## 终端输出
 

packages/client/ui-primitives/src/markdown/MarkdownText.module.css

@@ -230,3 +230,14 @@
   color: var(--dsw-alias-label-tertiary);
   font-style: italic;
 }
+
+.image {
+  display: block;
+  width: auto;
+  max-width: 100%;
+  height: auto;
+  margin: 0;
+  border-radius: 8px;
+  background: var(--dsw-alias-bg-base);
+  object-fit: contain;
+}

packages/client/ui-primitives/src/markdown/MarkdownText.tsx

@@ -37,6 +37,15 @@ export interface MarkdownCodeLabels {
   copiedLabel?: string | undefined
 }
 
+function remoteImageUrl(url: string): string | undefined {
+  try {
+    const protocol = new URL(url).protocol
+    return protocol === 'http:' || protocol === 'https:' ? url : undefined
+  } catch {
+    return undefined
+  }
+}
+
 /** Build the component table; while `streaming`, fences render the plain arm (see CodeBlock). */
 function buildComponents(streaming: boolean, codeLabels?: MarkdownCodeLabels): Components {
   return {
@@ -53,7 +62,20 @@ function buildComponents(streaming: boolean, codeLabels?: MarkdownCodeLabels): C
         </a>
       )
     },
-    img: ({ alt = '' }) => <span className={css.imageAlt}>{alt}</span>,
+    img: ({ alt = '', src = '' }) => {
+      const imageSrc = remoteImageUrl(src)
+      if (imageSrc === undefined) return <span className={css.imageAlt}>{alt}</span>
+      return (
+        <img
+          className={css.image}
+          src={imageSrc}
+          alt={alt}
+          loading="lazy"
+          decoding="async"
+          referrerPolicy="no-referrer"
+        />
+      )
+    },
     table: ({ children }) => (
       <div className={css.tableScroll}>
         <table>{children}</table>
@@ -98,7 +120,9 @@ const streamingComponents = buildComponents(true)
  * pass a reference-stable object (memoized per locale revision), because the
  * component table memoizes on its identity and a fresh literal per render
  * would rebuild it every streaming chunk.
- * @returns A GFM document with TeX math rendered through KaTeX and raw HTML, relative links, unsafe protocols, and remote images disabled.
+ * @returns A GFM document with TeX math rendered through KaTeX; raw HTML,
+ * relative links, and unsafe protocols are disabled, while absolute HTTP(S)
+ * images render directly.
  */
 export function MarkdownText({ text, streaming = false, codeLabels }: {
   text: string

packages/client/ui-primitives/tests/markdown.spec.tsx

@@ -99,13 +99,35 @@ describe('MarkdownText', () => {
     expect(screen.getByRole('button', { name: 'Copy code' })).toBeTruthy()
   })
 
-  it('neutralizes raw HTML, unsafe or relative links, and remote images', () => {
+  it('renders absolute HTTP(S) images with bounded presentation', () => {
+    const markdown = [
+      '![secure diagram](https://example.com/secure.png)',
+      '![plain diagram](http://example.com/plain.png)',
+    ].join('\n\n')
+    const { container } = render(<MarkdownText text={markdown} />)
+    const images = [...container.querySelectorAll('img')]
+    expect(images.map(image => image.getAttribute('src'))).toEqual([
+      'https://example.com/secure.png',
+      'http://example.com/plain.png',
+    ])
+    for (const image of images) {
+      expect(image.getAttribute('loading')).toBe('lazy')
+      expect(image.getAttribute('decoding')).toBe('async')
+      expect(image.getAttribute('referrerpolicy')).toBe('no-referrer')
+    }
+  })
+
+  it('neutralizes raw HTML, unsafe or relative links, and unsupported images', () => {
     const markdown = [
       '<script>globalThis.compromised = true</script>',
       '<img src="x" onerror="globalThis.compromised = true">',
       '[script](javascript:alert(1)) [relative](/settings)',
       '[mail](mailto:dev@example.com) [web](http://example.com) [upper](HTTPS://example.com)',
-      '![remote diagram](https://example.com/private.png)',
+      '![relative diagram](private.png)',
+      '![absolute diagram](/workspace/private.png)',
+      '![file diagram](file:///workspace/private.png)',
+      '![script diagram](javascript:alert(1))',
+      '![mail diagram](mailto:dev@example.com)',
     ].join('\n\n')
     const { container } = render(<MarkdownText text={markdown} />)
 
@@ -117,7 +139,11 @@ describe('MarkdownText', () => {
     expect(screen.getByRole('link', { name: 'mail' }).getAttribute('target')).toBeNull()
     expect(screen.getByRole('link', { name: 'web' }).getAttribute('rel')).toBe('noopener noreferrer')
     expect(screen.getByRole('link', { name: 'upper' }).getAttribute('target')).toBe('_blank')
-    expect(screen.getByText('remote diagram')).toBeTruthy()
+    expect(screen.getByText('relative diagram')).toBeTruthy()
+    expect(screen.getByText('absolute diagram')).toBeTruthy()
+    expect(screen.getByText('file diagram')).toBeTruthy()
+    expect(screen.getByText('script diagram')).toBeTruthy()
+    expect(screen.getByText('mail diagram')).toBeTruthy()
   })
 
   it('keeps incomplete streaming Markdown renderable', () => {

packages/ui/tui/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/ui/tui/README.md
-README.md: c81cac891403e5294c4456ce4d4048ecd74666ce
-README.zh.md: 01055619f4df460284564f0a1816de366d809e01
+README.md: a577fb2f858f61eb765d4a1a9564f452d01d92c1
+README.zh.md: 61e1b9d526a00e3c8cbc2c9ed0cc483e2ab8dba2

packages/ui/tui/README.md

@@ -22,7 +22,7 @@ Typing `@` at a token boundary searches files and directories under the session
 
 When optional `ctx.sessionReferences` is mounted, the same `@` menu also offers metadata-only session candidates, inserts `@[label](dsh-session:<payload>)`, and prepares the selected snapshots before dispatch. Session references remain structured because the model has no filesystem-like tool for retrieving session snapshots later. Preparation disables duplicate submission and restores the editor input on failure. The TUI chooses `agent.steer()` or `agent.followup()` from the status after that asynchronous preparation, so idle follow-ups still dispatch `agent/prompt-submit` while in-turn steering joins at a checkpoint without that hook.
 
-While the agent is running, ordinary editor submissions call `agent.steer()`; otherwise they call `agent.followup()`. A slash at the start of the submitted line enters `ctx.commands` instead: known commands execute directly, unknown commands produce a warning, and neither path automatically reaches the model. A command producer may explicitly schedule agent work; [`dsh-plan-mode`](../../plan/plan-mode/README.md#model-and-human-surfaces) uses that contract for `/plan [message]`. The TUI registers `/help`, `/model`, `/clear`, `/palette`, `/reload`, `/resume`, `/status`, and `/exit` as agent-scoped definitions; every other effective command joins autocomplete and `/help` dynamically, as do `/skill:` completions. A status line above the editor reports the turn phase the TUI derives from session events — waiting for the first token, thinking, responding, or executing tools — with the elapsed time in that phase and the running step total, refreshed each second, and ends with the `Enter sends steering, Esc cancels` hint; while steering messages wait to reach the model it inserts a `N queued ·` badge before the hint that clears as each drains. During a live standalone compaction bracket, a fixed `Context being compacted <elapsed>` row appears above the prompt, the idle prompt caret becomes a one-cell throbbing `⊙`, and terminal progress stays active until close; the row and glyph share the bracket's one refresh timer. This live state is never reconstructed from the log; a failed close adds `Compaction failed: <error>` to the transcript, while a resumed orphaned start never activates the indicator ([decision](../../../.agents/notes/implemented/feature/2026-07-30-compaction-progress-visibility.md)). Ctrl+C or Escape cancels a running turn. Tool and injected-context cards collapse long bodies into a configurable head/tail preview; Ctrl+O cycles tool cards through collapsed preview, full output, and hidden — the hidden phase drops tool cards from the transcript entirely while context cards stay at their preview, since injected instructions are not tool traffic. An injected-context card renders its message as prose with the producer's outer reminder frame stripped, so neither the fold nor the frame stripping depends on the payload's syntax. Ctrl+R toggles reasoning, Ctrl+L redraws, and Ctrl+D exits while idle.
+While the agent is running, ordinary editor submissions call `agent.steer()`; otherwise they call `agent.followup()`. A slash at the start of the submitted line enters `ctx.commands` instead: known commands execute directly, unknown commands produce a warning, and neither path automatically reaches the model. A command producer may explicitly schedule agent work; [`dsh-plan-mode`](../../plan/plan-mode/README.md#model-and-human-surfaces) uses that contract for `/plan [message]`. The TUI registers `/help`, `/model`, `/clear`, `/details`, `/palette`, `/reload`, `/resume`, `/status`, and `/exit` as agent-scoped definitions; every other effective command joins autocomplete and `/help` dynamically, as do `/skill:` completions. A status line above the editor reports the turn phase the TUI derives from session events — waiting for the first token, thinking, responding, or executing tools — with the elapsed time in that phase and the running step total, refreshed each second, and ends with the `Enter sends steering, Esc cancels` hint; while steering messages wait to reach the model it inserts a `N queued ·` badge before the hint that clears as each drains. During a live standalone compaction bracket, a fixed `Context being compacted <elapsed>` row appears above the prompt, the idle prompt caret becomes a one-cell throbbing `⊙`, and terminal progress stays active until close; the row and glyph share the bracket's one refresh timer. This live state is never reconstructed from the log; a failed close adds `Compaction failed: <error>` to the transcript, while a resumed orphaned start never activates the indicator ([decision](../../../.agents/notes/implemented/feature/2026-07-30-compaction-progress-visibility.md)). Ctrl+C or Escape cancels a running turn. Tool and injected-context cards collapse long bodies into a configurable head/tail preview; Ctrl+O cycles tool cards through collapsed preview, full output, and hidden — the hidden phase drops tool cards from the transcript entirely while context cards stay at their preview, since injected instructions are not tool traffic. The hidden phase also folds each turn's assistant steps into one message: the first step with visible text or reasoning keeps the turn's single `Assistant` header, later steps render as headerless continuations, and a step without a visible body renders nothing; leaving the hidden phase restores the per-step headers. An injected-context card renders its message as prose with the producer's outer reminder frame stripped, so neither the fold nor the frame stripping depends on the payload's syntax. Ctrl+R toggles reasoning, Ctrl+L redraws, and Ctrl+D exits while idle. `/details` names the same state those two shortcuts cycle: bare it opens a centered keyboard toggle with one entry per dimension — `Tool cards` and `Reasoning` — showing the live values, where Tab cycles the highlighted entry and applies the change immediately (the transcript behind the dialog is the preview), and Enter, Esc, or Ctrl+C closes; `/details collapsed|expanded|hidden` jumps tool cards to that phase directly, and `/details reasoning [on|off]` sets — or bare `reasoning` toggles — reasoning-block display; arguments combine in one invocation, an unknown argument fails with the usage line, and a combined invocation applies reasoning first so its transcript rebuild never drops the card notice.
 
 `/model` opens the advisory `ctx.llm` catalog as a keyboard selector: a filter box above the list narrows rows by a case-insensitive substring over each row's `provider/model` label, model name, and description, keeping the highlighted row selected when it survives the filter; Up/Down moves, Shift+Tab cycles the focused model's adapter-advertised reasoning efforts in display order, Enter selects the model and effort, and Escape clears a non-empty filter before a second Escape closes it. When an adapter does not advertise a default effort, the cycle also includes `Default`, which clears an explicit selection and preserves the provider default; models without selectable effort metadata ignore Shift+Tab. The selector renders the exact advertised effort list—including `off` when present—and does not synthesize, clamp, or transfer an effort between models. `/model <model>` still selects an unambiguous model id directly, while `/model <provider>/<model>` selects an exact target and uses its adapter default when one exists. The configured target or latest logged request header initializes the selector, and an unlisted current model remains visible because catalogs are advisory. Selection is local to this TUI session. Prompt assembly snapshots the target for one step, replaces `{{provider}}` and `{{model}}`, and applies the same provider/model/reasoning-effort target through `agent/request`; a switch during assembly therefore starts with a later step. The request header durably records targets that reach the model, while an unused selection remains process-local.
 
@@ -57,6 +57,7 @@ A launcher can seed a fresh session's first turn by providing `INITIAL_SKILL_KEY
 | `questionDialogMaxHeight` | `20` | Question-panel maximum rows |
 | `modelDialogWidth` | `76` | Model-selector width in columns |
 | `modelDialogMaxHeight` | `20` | Model-selector maximum rows |
+| `detailsDialogWidth` | `72` | Transcript-details selector width in columns |
 | `fileSearchMaxResults` | `20` | Maximum file and directory candidates shown for one `@` query |
 | `fileSearchMaxEntries` | `10000` | Maximum paths retained in the bounded workspace index used by bare fuzzy queries |
 | `fileSearchExcludedDirectories` | `['.git', 'node_modules']` | Directory basenames omitted from traversal and direct completion |

packages/ui/tui/README.zh.md

@@ -22,7 +22,7 @@ TUI 从追加来源的会话事件重建已恢复历史，渲染 Markdown 响应
 
 挂载可选的 `ctx.sessionReferences` 后，同一个 `@` 菜单还会提供仅含元数据的会话候选项，插入 `@[label](dsh-session:<payload>)`，并在分派前准备所选快照。会话引用保持结构化，因为模型没有类似文件系统的工具可在稍后检索会话快照。准备期间会禁止重复提交，并在失败时恢复编辑器输入。TUI 会在异步准备后根据状态选择 `agent.steer()` 或 `agent.followup()`，因此空闲 followup 仍会分派 `agent/prompt-submit`，而轮次中的 steering 会在检查点加入且不触发该 hook。
 
-Agent 运行时，普通编辑器提交会调用 `agent.steer()`；其他时候调用 `agent.followup()`。提交行以斜杠开头时会改为进入 `ctx.commands`：已知命令直接执行，未知命令产生警告，两条路径都不会自动到达模型。命令生产方可以显式调度 agent 工作；[`dsh-plan-mode`](../../plan/plan-mode/README.md#model-and-human-surfaces) 使用该契约实现 `/plan [message]`。TUI 将 `/help`、`/model`、`/clear`、`/palette`、`/reload`、`/resume`、`/status` 和 `/exit` 注册为 agent 作用域定义；其他所有有效命令都会动态加入自动补全与 `/help`，`/skill:` 补全也相同。编辑器上方的状态行会报告 TUI 从会话事件派生的轮次阶段，包括等待首个 token、思考、响应或执行工具；它显示该阶段已经过时间和运行中的步骤总数，每秒刷新，并以 `Enter sends steering, Esc cancels` 提示结尾。Steering 消息等待到达模型期间，会在提示前插入 `N queued ·` 徽标，每条消息排空后随即清除。在实时独立压缩（compaction）标记对处于开启状态期间，提示词上方会显示固定的 `Context being compacted <elapsed>` 状态行，空闲提示符光标会变成占一个终端字符单元并呈呼吸律动的 `⊙`，终端进度状态则会保持活跃，直至标记对闭合；该状态行和字形共用标记对的同一个刷新定时器。该实时状态绝不会从日志中重建；闭合失败时会向 transcript 添加 `Compaction failed: <error>`，而恢复会话时遇到的陈旧未匹配 start 绝不会激活该指示器（[决策](../../../.agents/notes/implemented/feature/2026-07-30-compaction-progress-visibility.md)）。Ctrl+C 或 Escape 会取消运行中的轮次。工具卡片与注入上下文卡片都把长主体折叠为可配置的头尾预览；Ctrl+O 让工具卡片在折叠预览、完整输出、隐藏三种状态间循环——隐藏阶段把工具卡片从 transcript 中完全去掉，而上下文卡片保持预览，因为注入的指令不属于工具流量。注入上下文卡片把消息渲染为文本，并去掉生产方的外层提醒外框，因此折叠与去外框都不依赖载荷的语法。Ctrl+R 切换 reasoning，Ctrl+L 重绘，Ctrl+D 在空闲时退出。
+Agent 运行时，普通编辑器提交会调用 `agent.steer()`；其他时候调用 `agent.followup()`。提交行以斜杠开头时会改为进入 `ctx.commands`：已知命令直接执行，未知命令产生警告，两条路径都不会自动到达模型。命令生产方可以显式调度 agent 工作；[`dsh-plan-mode`](../../plan/plan-mode/README.md#model-and-human-surfaces) 使用该契约实现 `/plan [message]`。TUI 将 `/help`、`/model`、`/clear`、`/details`、`/palette`、`/reload`、`/resume`、`/status` 和 `/exit` 注册为 agent 作用域定义；其他所有有效命令都会动态加入自动补全与 `/help`，`/skill:` 补全也相同。编辑器上方的状态行会报告 TUI 从会话事件派生的轮次阶段，包括等待首个 token、思考、响应或执行工具；它显示该阶段已经过时间和运行中的步骤总数，每秒刷新，并以 `Enter sends steering, Esc cancels` 提示结尾。Steering 消息等待到达模型期间，会在提示前插入 `N queued ·` 徽标，每条消息排空后随即清除。在实时独立压缩（compaction）标记对处于开启状态期间，提示词上方会显示固定的 `Context being compacted <elapsed>` 状态行，空闲提示符光标会变成占一个终端字符单元并呈呼吸律动的 `⊙`，终端进度状态则会保持活跃，直至标记对闭合；该状态行和字形共用标记对的同一个刷新定时器。该实时状态绝不会从日志中重建；闭合失败时会向 transcript 添加 `Compaction failed: <error>`，而恢复会话时遇到的陈旧未匹配 start 绝不会激活该指示器（[决策](../../../.agents/notes/implemented/feature/2026-07-30-compaction-progress-visibility.md)）。Ctrl+C 或 Escape 会取消运行中的轮次。工具卡片与注入上下文卡片都把长主体折叠为可配置的头尾预览；Ctrl+O 让工具卡片在折叠预览、完整输出、隐藏三种状态间循环——隐藏阶段把工具卡片从 transcript 中完全去掉，而上下文卡片保持预览，因为注入的指令不属于工具流量。隐藏阶段还会把每个轮次的 assistant 步骤折叠为一条消息：第一个有可见文本或 reasoning 的步骤保留该轮次唯一的 `Assistant` 标题，之后的步骤渲染为无标题的续段，没有可见正文的步骤则不渲染任何内容；离开隐藏阶段会恢复每步各自的标题。注入上下文卡片把消息渲染为文本，并去掉生产方的外层提醒外框，因此折叠与去外框都不依赖载荷的语法。Ctrl+R 切换 reasoning，Ctrl+L 重绘，Ctrl+D 在空闲时退出。`/details` 命名的正是这两个快捷键循环的同一份状态：不带参数时打开一个居中的键盘开关，每个维度一个条目——`Tool cards` 与 `Reasoning`——显示实时值，Tab 循环高亮条目并立即应用变更（对话框背后的 transcript 即是预览），Enter、Esc 或 Ctrl+C 关闭；`/details collapsed|expanded|hidden` 让工具卡片直接跳到该阶段，`/details reasoning [on|off]` 设置——或裸 `reasoning` 切换——reasoning 块显示；参数可在一次调用中组合，未知参数会以用法行报错，组合调用先应用 reasoning，使其 transcript 重建不会丢掉卡片通知。
 
 `/model` 将建议性的 `ctx.llm` catalog 打开为键盘选择器：列表上方设有一个过滤框，按对每行 `provider/model` 标签、模型名称和描述的大小写不敏感子串匹配来缩小行集，并在高亮行仍通过过滤时保持其选中状态；Up/Down 移动，Shift+Tab 按显示顺序循环切换适配器为焦点模型公布的推理强度，Enter 选择模型和推理强度，Escape 会先清除非空过滤内容，再次按下才关闭选择器。适配器未公布默认推理强度时，循环还会包含 `Default`，该项会清除显式选择并保留提供方默认行为；没有可选推理强度元数据的模型会忽略 Shift+Tab。选择器会原样呈现公布的推理强度列表（包括存在时的 `off`），不会合成、自动调整或在模型之间转移推理强度。`/model <model>` 仍可直接选择无歧义的模型 id，`/model <provider>/<model>` 则选择精确目标，并在存在时使用其适配器默认值。已配置目标或最新记录的请求 header 会初始化选择器；由于 catalog 仅提供建议，未列出的当前模型仍会显示。选择仅对本 TUI 会话有效。提示词组装会为一个步骤建立目标快照，替换 `{{provider}}` 和 `{{model}}`，并通过 `agent/request` 应用同一个提供方／模型／推理强度目标；因此组装期间的切换会从后续步骤开始生效。请求 header 会持久记录真正到达模型的目标，未使用的选择则只存在于进程本地。
 
@@ -57,6 +57,7 @@ Footer 将会话报告的用量汇总为 `↑<uncached input> ↓<output>`；任
 | `questionDialogMaxHeight` | `20` | 问题面板最大行数 |
 | `modelDialogWidth` | `76` | 模型选择器宽度（列数） |
 | `modelDialogMaxHeight` | `20` | 模型选择器最大行数 |
+| `detailsDialogWidth` | `72` | transcript 细节选择器宽度（列数） |
 | `fileSearchMaxResults` | `20` | 一次 `@` 查询显示的最大文件和目录候选数 |
 | `fileSearchMaxEntries` | `10000` | 无路径模糊查询使用的有界工作区索引最多保留的路径数 |
 | `fileSearchExcludedDirectories` | `['.git', 'node_modules']` | 遍历和直接补全时忽略的目录 basename |

packages/ui/tui/src/components/dialogs.ts

@@ -34,6 +34,7 @@ import type {
 import type { AskUserQuestionItem } from '@deepseek-ai/dsh-user-interaction'
 import { BRACKETED_PASTE_END, BRACKETED_PASTE_START, displayText, sanitizePastedText } from './text.ts'
 import { dialogSelectTheme, type Palette } from './theme.ts'
+import type { ToolCardVisibility } from './transcript.ts'
 import {
   renderTuiPromptTemplate,
   type TuiPromptTemplateToken,
@@ -432,6 +433,79 @@ export class ModelDialog implements Component {
   }
 }
 
+/** Both transcript-detail dimensions, applied immediately on each Tab. */
+export interface DetailsSelection {
+  readonly visibility: ToolCardVisibility
+  readonly showReasoning: boolean
+}
+
+const TOOL_CARD_PHASES: readonly ToolCardVisibility[] = ['collapsed', 'expanded', 'hidden']
+
+/**
+ * Keyboard toggle over the two transcript-detail entries — tool-card
+ * visibility and reasoning display. Tab cycles the highlighted entry's value
+ * and applies it immediately, so the transcript behind the dialog is the live
+ * preview; Enter, Esc, or Ctrl+C closes.
+ */
+export class DetailsDialog implements Component {
+  private readonly list: SelectList
+  private readonly toolsItem: SelectItem
+  private readonly reasoningItem: SelectItem
+
+  constructor(
+    private visibility: ToolCardVisibility,
+    private showReasoning: boolean,
+    private readonly palette: Palette,
+    private readonly apply: (selection: DetailsSelection) => void,
+    private readonly close: () => void,
+  ) {
+    this.toolsItem = { value: 'tools', label: 'Tool cards', description: visibility }
+    this.reasoningItem = { value: 'reasoning', label: 'Reasoning', description: this.reasoningLabel() }
+    this.list = new SelectList([this.toolsItem, this.reasoningItem], 2, dialogSelectTheme(palette))
+    this.list.onSelect = close
+  }
+
+  private reasoningLabel(): string {
+    return this.showReasoning ? 'shown' : 'hidden'
+  }
+
+  /** Cycle the highlighted entry one step and apply the new state. */
+  private cycle(): void {
+    const selected = this.list.getSelectedItem()
+    /* v8 ignore next -- the two-entry list always has a selection. */
+    if (selected === null) return
+    if (selected.value === 'tools') {
+      const index = TOOL_CARD_PHASES.indexOf(this.visibility)
+      this.visibility = TOOL_CARD_PHASES[(index + 1) % TOOL_CARD_PHASES.length] as ToolCardVisibility
+      this.toolsItem.description = this.visibility
+    } else {
+      this.showReasoning = !this.showReasoning
+      this.reasoningItem.description = this.reasoningLabel()
+    }
+    this.apply({ visibility: this.visibility, showReasoning: this.showReasoning })
+  }
+
+  invalidate(): void {
+    this.list.invalidate()
+  }
+
+  handleInput(data: string): void {
+    if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl('c'))) this.close()
+    else if (matchesKey(data, Key.tab)) this.cycle()
+    else this.list.handleInput(data)
+    this.invalidate()
+  }
+
+  render(width: number): string[] {
+    const innerWidth = Math.max(1, width - 4)
+    return renderDialog('Transcript details', [
+      ...this.list.render(innerWidth),
+      '',
+      this.palette.dim('↑/↓ move • Tab toggle • Enter/Esc close'),
+    ], width, this.palette)
+  }
+}
+
 /** The provider/model route recovered from a resume candidate's log. */
 export interface ResumeRoute {
   provider: string

packages/ui/tui/src/components/transcript.ts

@@ -149,20 +149,28 @@ export class UserMessageComponent extends Container {
   }
 }
 
-/** Children of a settled assistant message: optional reasoning block then the response text. */
+/**
+ * Children of a settled assistant message: optional reasoning block then the
+ * response text. A folded continuation (a later step of a turn while tool cards
+ * are hidden) drops the `Assistant` header and renders nothing when it has no
+ * visible body, so tool-only steps leave no blank segment behind.
+ */
 function assistantMessageChildren(
   content: readonly ContentBlock[],
   showReasoning: boolean,
+  foldedContinuation: boolean,
   palette: Palette,
   mdTheme: MarkdownTheme,
 ): Component[] {
   const reasoning = displayText(textBlocks(content, 'reasoning').trim())
   const text = displayText(textBlocks(content, 'text').trim())
-  const children: Component[] = [
-    new Spacer(1),
-    new Text(messageHeader('Assistant', palette.accent, palette), 0, 0),
-  ]
-  if (reasoning && showReasoning) {
+  const showsReasoning = reasoning !== '' && showReasoning
+  if (foldedContinuation && !showsReasoning && text === '') return []
+  const children: Component[] = [new Spacer(1)]
+  if (!foldedContinuation) {
+    children.push(new Text(messageHeader('Assistant', palette.accent, palette), 0, 0))
+  }
+  if (showsReasoning) {
     children.push(
       new Text(palette.italic(palette.dim('Reasoning')), 0, 0),
       new Markdown(reasoning, 0, 0, mdTheme, { color: value => palette.dim(value), italic: true }),
@@ -220,6 +228,7 @@ interface StreamingBlock {
 export class StreamingAssistantComponent extends Container {
   private readonly blocks = new Map<number, StreamingBlock>()
   private settledContent: readonly ContentBlock[] | undefined
+  private foldedContinuation = false
   /**
    * The step's timing footer. The renderer keeps it at the tail of the chat so
    * it trails any tool cards the step appends after this assistant message; it
@@ -228,7 +237,8 @@ export class StreamingAssistantComponent extends Container {
   readonly timing: StepTimingComponent
 
   constructor(
-    position: StepPosition,
+    /** The step's turn/step coordinates, used to group steps into their turn. */
+    readonly position: StepPosition,
     events: () => readonly SessionEvent[],
     now: () => number,
     private showReasoning: boolean,
@@ -299,18 +309,49 @@ export class StreamingAssistantComponent extends Container {
     this.rebuild()
   }
 
-  private rebuild(): void {
-    this.clear()
-    const content: readonly ContentBlock[] = this.settledContent ?? [...this.blocks.entries()]
+  /**
+   * Mark this step as a folded continuation of its turn: no `Assistant` header,
+   * and no output at all while the step has no visible body. Used while tool
+   * cards are hidden so a turn reads as one assistant message.
+   * @param folded - Whether to render as a headerless continuation.
+   */
+  setFoldedContinuation(folded: boolean): void {
+    if (this.foldedContinuation === folded) return
+    this.foldedContinuation = folded
+    this.rebuild()
+  }
+
+  /**
+   * Whether the step currently renders visible reasoning or text.
+   * @returns `true` when a header-owning render would show a body.
+   */
+  hasVisibleBody(): boolean {
+    const content = this.presentedContent()
+    return textBlocks(content, 'text').trim() !== ''
+      || (this.showReasoning && textBlocks(content, 'reasoning').trim() !== '')
+  }
+
+  /** The settled content when available, otherwise the streamed blocks in model order. */
+  private presentedContent(): readonly ContentBlock[] {
+    return this.settledContent ?? [...this.blocks.entries()]
       .sort(([left], [right]) => left - right)
       .flatMap<ContentBlock>(([, block]) => {
         if (block.type === 'text') return [{ type: 'text', text: block.text }]
         if (block.type === 'reasoning') return [{ type: 'reasoning', text: block.text }]
         return []
       })
-    for (const child of assistantMessageChildren(content, this.showReasoning, this.palette, this.mdTheme)) {
-      this.addChild(child)
-    }
+  }
+
+  private rebuild(): void {
+    this.clear()
+    const children = assistantMessageChildren(
+      this.presentedContent(),
+      this.showReasoning,
+      this.foldedContinuation,
+      this.palette,
+      this.mdTheme,
+    )
+    for (const child of children) this.addChild(child)
   }
 }
 

packages/ui/tui/src/config.ts

@@ -48,6 +48,8 @@ export interface TuiConfig {
   modelDialogWidth?: number
   /** Model-selector maximum height in terminal rows. */
   modelDialogMaxHeight?: number
+  /** Transcript-details selector width in terminal columns. */
+  detailsDialogWidth?: number
   /** Maximum fuzzy file candidates displayed for one `@` query. */
   fileSearchMaxResults?: number
   /** Maximum paths retained in one `@` workspace index. */
@@ -71,6 +73,7 @@ const questionDialogWidthSchema = z.number().step(1).min(20).default(200)
 const questionDialogMaxHeightSchema = z.number().step(1).min(6).default(20)
 const modelDialogWidthSchema = z.number().step(1).min(20).default(76)
 const modelDialogMaxHeightSchema = z.number().step(1).min(6).default(20)
+const detailsDialogWidthSchema = z.number().step(1).min(20).default(72)
 const fileSearchMaxResultsSchema = z.number().step(1).min(1).default(DEFAULT_FILE_SEARCH_MAX_RESULTS)
 const fileSearchMaxEntriesSchema = z.number().step(1).min(1).default(DEFAULT_FILE_SEARCH_MAX_ENTRIES)
 const fileSearchExcludedDirectoriesSchema = z.array(z.string()).default([...DEFAULT_FILE_SEARCH_EXCLUDED_DIRECTORIES])
@@ -102,6 +105,7 @@ const tuiConfigSchemaFields = {
   questionDialogMaxHeight: questionDialogMaxHeightSchema,
   modelDialogWidth: modelDialogWidthSchema,
   modelDialogMaxHeight: modelDialogMaxHeightSchema,
+  detailsDialogWidth: detailsDialogWidthSchema,
   fileSearchMaxResults: fileSearchMaxResultsSchema,
   fileSearchMaxEntries: fileSearchMaxEntriesSchema,
   fileSearchExcludedDirectories: fileSearchExcludedDirectoriesSchema,
@@ -142,6 +146,7 @@ export const Config: z<Config> = z.object({
   questionDialogMaxHeight: tuiConfigSchemaFields.questionDialogMaxHeight,
   modelDialogWidth: tuiConfigSchemaFields.modelDialogWidth,
   modelDialogMaxHeight: tuiConfigSchemaFields.modelDialogMaxHeight,
+  detailsDialogWidth: tuiConfigSchemaFields.detailsDialogWidth,
   fileSearchMaxResults: tuiConfigSchemaFields.fileSearchMaxResults,
   fileSearchMaxEntries: tuiConfigSchemaFields.fileSearchMaxEntries,
   fileSearchExcludedDirectories: tuiConfigSchemaFields.fileSearchExcludedDirectories,
@@ -171,6 +176,7 @@ export interface ResolvedTuiConfig {
   questionDialogMaxHeight: number
   modelDialogWidth: number
   modelDialogMaxHeight: number
+  detailsDialogWidth: number
   fileSearchMaxResults: number
   fileSearchMaxEntries: number
   fileSearchExcludedDirectories: string[]
@@ -196,6 +202,7 @@ export function resolveTuiConfig(config: TuiConfig | undefined): ResolvedTuiConf
     questionDialogMaxHeight: config?.questionDialogMaxHeight ?? 20,
     modelDialogWidth: config?.modelDialogWidth ?? 76,
     modelDialogMaxHeight: config?.modelDialogMaxHeight ?? 20,
+    detailsDialogWidth: config?.detailsDialogWidth ?? 72,
     fileSearchMaxResults: config?.fileSearchMaxResults ?? DEFAULT_FILE_SEARCH_MAX_RESULTS,
     fileSearchMaxEntries: config?.fileSearchMaxEntries ?? DEFAULT_FILE_SEARCH_MAX_ENTRIES,
     fileSearchExcludedDirectories: [...(config?.fileSearchExcludedDirectories ?? DEFAULT_FILE_SEARCH_EXCLUDED_DIRECTORIES)],

packages/ui/tui/src/index.ts

@@ -105,6 +105,7 @@ import {
 } from './components/transcript.ts'
 import {
   compactTargetLabel,
+  DetailsDialog,
   diagnosticMeter,
   formatDiagnosticCount,
   formatDiagnosticNumber,
@@ -113,6 +114,7 @@ import {
   StatusCardComponent,
   PromptContextComponent,
   targetLabel,
+  type DetailsSelection,
   type StatusCardRow,
 } from './components/dialogs.ts'
 import {
@@ -337,6 +339,10 @@ export function createTuiChat(
   let toolsVisibility: ToolCardVisibility = 'collapsed'
   let streaming: StreamingAssistantComponent | undefined
   let completedStreaming: StreamingAssistantComponent | undefined
+  // Assistant step components in model order per turn, for hidden-mode folding:
+  // with tool cards hidden, a turn keeps one Assistant header and later steps
+  // render as headerless continuations (see applyTurnFolding).
+  const assistantSteps = new Map<number, StreamingAssistantComponent[]>()
   let runningStatus: RunningStatus | undefined
   let fadingStatus: FadingStatus | undefined
   /**
@@ -646,6 +652,35 @@ export function createTuiChat(
     return card
   }
 
+  /**
+   * Re-derive hidden-mode folding for one turn: the first step with a visible
+   * body owns the turn's single Assistant header, every other step renders as a
+   * headerless continuation (empty ones render nothing). Any other visibility
+   * restores the per-step headers.
+   */
+  const applyTurnFolding = (turn: number): void => {
+    const steps = assistantSteps.get(turn)
+    if (steps === undefined) return
+    let headerSeen = false
+    for (const step of steps) {
+      if (toolsVisibility !== 'hidden') {
+        step.setFoldedContinuation(false)
+      } else if (!headerSeen && step.hasVisibleBody()) {
+        headerSeen = true
+        step.setFoldedContinuation(false)
+      } else {
+        step.setFoldedContinuation(true)
+      }
+    }
+  }
+
+  const registerAssistantStep = (component: StreamingAssistantComponent): void => {
+    const steps = assistantSteps.get(component.position.turn) ?? []
+    steps.push(component)
+    assistantSteps.set(component.position.turn, steps)
+    applyTurnFolding(component.position.turn)
+  }
+
   const removeStreaming = (current: StreamingAssistantComponent | undefined): void => {
     if (current === undefined) return
     for (const child of [current, current.timing]) {
@@ -653,6 +688,15 @@ export function createTuiChat(
       /* v8 ignore next -- streaming components and their timing footers are retained only while attached to the chat. */
       if (index >= 0) chat.children.splice(index, 1)
     }
+    const steps = assistantSteps.get(current.position.turn)
+    /* v8 ignore next -- every attached streaming component is registered in the fold map. */
+    if (steps === undefined) return
+    const index = steps.indexOf(current)
+    /* v8 ignore next -- registration precedes attachment, so the component is present until this removal. */
+    if (index < 0) return
+    steps.splice(index, 1)
+    // A retracted step may have owned the turn's hidden-mode header.
+    applyTurnFolding(current.position.turn)
   }
 
   /**
@@ -691,6 +735,7 @@ export function createTuiChat(
       palette,
       mdTheme,
     )
+    registerAssistantStep(streaming)
     chat.addChild(streaming)
     chat.addChild(streaming.timing)
   }
@@ -754,12 +799,22 @@ export function createTuiChat(
         startAssistantStep(event.data)
         break
       case 'assistant/chunk':
-        if (options.renderChunks) streaming?.update(event.data.chunk)
+        if (options.renderChunks && streaming !== undefined) {
+          streaming.update(event.data.chunk)
+          // The first streamed text/reasoning may make this step the turn's
+          // hidden-mode header owner (or a continuation with a visible body).
+          applyTurnFolding(streaming.position.turn)
+        }
         break
       case 'assistant/message':
         completedStreaming = undefined
-        if (streaming === undefined || !chat.children.includes(streaming)) startAssistantStep(event.data)
-        streaming?.settle(event.data.message.content)
+        // A settled component stays attached but never absorbs a later message
+        // of the same step; both the live and replay paths start a new one.
+        if (streaming === undefined || streaming.isSettled() || !chat.children.includes(streaming)) startAssistantStep(event.data)
+        if (streaming !== undefined) {
+          streaming.settle(event.data.message.content)
+          applyTurnFolding(streaming.position.turn)
+        }
         break
       case 'llm/retry': {
         retractFailedStreaming()
@@ -870,6 +925,7 @@ export function createTuiChat(
     toolCards.clear()
     allToolCards.clear()
     contextCards.clear()
+    assistantSteps.clear()
     streaming = undefined
     todo.update([])
     const transcriptCalls = transcriptToolCallIds(agent.session)
@@ -979,32 +1035,99 @@ export function createTuiChat(
   // same reason.
   ui.queryTerminalColorScheme({ timeoutMs: 2000 }).catch(() => {})
 
-  const toggleTools = (): void => {
-    // The cycle order puts the two common reading modes adjacent: preview ->
-    // full detail -> conversation-only, then back to the preview default.
-    toolsVisibility = toolsVisibility === 'collapsed' ? 'expanded'
-      : toolsVisibility === 'expanded' ? 'hidden' : 'collapsed'
+  const setToolsVisibility = (next: ToolCardVisibility): void => {
+    toolsVisibility = next
     for (const card of allToolCards) card.setVisibility(toolsVisibility)
     // Context cards carry injected instructions rather than tool traffic, so
     // they never hide: the hidden phase reads as their collapsed preview.
     for (const card of contextCards) card.setExpanded(toolsVisibility === 'expanded')
+    // Hidden mode folds each turn's steps into one assistant message; other
+    // modes restore the per-step Assistant headers.
+    for (const turn of assistantSteps.keys()) applyTurnFolding(turn)
     appendNotice(toolsVisibility === 'hidden' ? 'Tool cards hidden.' : `Tool and context cards ${toolsVisibility}.`)
   }
 
-  const toggleReasoning = (): void => {
-    showReasoning = !showReasoning
+  const toggleTools = (): void => {
+    // The cycle order puts the two common reading modes adjacent: preview ->
+    // full detail -> conversation-only, then back to the preview default.
+    setToolsVisibility(toolsVisibility === 'collapsed' ? 'expanded'
+      : toolsVisibility === 'expanded' ? 'hidden' : 'collapsed')
+  }
+
+  const setReasoning = (show: boolean): void => {
+    showReasoning = show
     const activeStreaming = streaming
     rebuildTranscript(false)
     /* v8 ignore next -- the non-streaming command path is covered; this branch preserves an active stream across rebuild. */
     if (activeStreaming !== undefined) {
       streaming = activeStreaming
       streaming.setShowReasoning(showReasoning)
+      registerAssistantStep(activeStreaming)
       chat.addChild(activeStreaming)
       chat.addChild(activeStreaming.timing)
     }
     appendNotice(`Reasoning blocks ${showReasoning ? 'shown' : 'hidden'}.`)
   }
 
+  const toggleReasoning = (): void => { setReasoning(!showReasoning) }
+
+  // The selector and the argument grammar mutate the same closure state the
+  // Ctrl+O cycle and Ctrl+R toggle drive, so every entry converges.
+  let detailsOverlay: TuiOverlaySession | undefined
+  const showDetailsSelector = (): void => {
+    void detailsOverlay?.close()
+    const session = overlayManager.open({
+      create: () => new DetailsDialog(
+        toolsVisibility,
+        showReasoning,
+        palette,
+        // Each Tab applies immediately; one dimension changes per call.
+        (selection: DetailsSelection) => {
+          if (selection.showReasoning !== showReasoning) setReasoning(selection.showReasoning)
+          if (selection.visibility !== toolsVisibility) setToolsVisibility(selection.visibility)
+        },
+        () => { void session.close() },
+      ),
+      options: { width: resolved.detailsDialogWidth, anchor: 'center', margin: 1 },
+    })
+    detailsOverlay = session
+    void session.closed.then(() => {
+      if (detailsOverlay === session) detailsOverlay = undefined
+    })
+    requestRender()
+  }
+
+  // `/details` names the same transcript-detail state the Ctrl+O cycle and
+  // Ctrl+R toggle mutate, so a user can jump to a mode without cycling.
+  const runDetails = (rawInput: string): CommandResult => {
+    const tokens = rawInput.split(/\s+/u).filter(token => token !== '')
+    if (tokens.length === 0) {
+      showDetailsSelector()
+      return { kind: 'success' }
+    }
+    let visibility: ToolCardVisibility | undefined
+    let reasoning: boolean | undefined
+    for (let token = tokens.shift(); token !== undefined; token = tokens.shift()) {
+      if (token === 'collapsed' || token === 'expanded' || token === 'hidden') {
+        visibility = token
+      } else if (token === 'reasoning') {
+        const value = tokens[0]
+        if (value === 'on' || value === 'off') {
+          tokens.shift()
+          reasoning = value === 'on'
+        } else {
+          reasoning = !showReasoning
+        }
+      } else {
+        return { kind: 'error', text: `Unknown /details argument "${token}". Usage: /details [collapsed|expanded|hidden] [reasoning [on|off]]` }
+      }
+    }
+    // Reasoning first: its transcript rebuild would drop the visibility notice.
+    if (reasoning !== undefined) setReasoning(reasoning)
+    if (visibility !== undefined) setToolsVisibility(visibility)
+    return { kind: 'success' }
+  }
+
   const showHelp = (): void => {
     const commandLines = ctx.commands.list(agent).map((command) => {
       const input = command.input === undefined ? '' : ` ${command.input.hint}`
@@ -1190,6 +1313,12 @@ export function createTuiChat(
       description: 'Clear the transcript view (session history is unchanged)',
       handler: () => { chat.clear(); requestRender(); return { kind: 'success' } },
     })
+    commandCtx.commands.register({
+      name: 'details',
+      description: 'Select tool-card visibility and reasoning display',
+      input: { hint: '[collapsed|expanded|hidden] [reasoning [on|off]]' },
+      handler: ({ rawInput }) => runDetails(rawInput),
+    })
     commandCtx.commands.register({
       name: 'palette',
       description: 'Show every color and attribute role this terminal renders',
@@ -1529,7 +1658,6 @@ export function createTuiChat(
     if (event.type === 'tool/result') fileSearch.invalidate()
     recordEventUsage(tokens, event)
     if (event.type === 'turn/start' && runningStatus !== undefined) runningStatus.turn = event.data.turn
-    if (event.type === 'assistant/message' && streaming?.isSettled()) streaming = undefined
     // Track live standalone compaction state.
     if (event.type === 'compact/start' && event.data.turn === null) {
       if (compacting === undefined) {

packages/ui/tui/tests/snapshots/details-command.expected.txt

@@ -0,0 +1,42 @@
+terminal 100x40 buffer=normal length=40 base=0 viewport=0
+lifecycle started=1 stopped=0 progress=inactive
+title "DSH snapshot"
+cursor hidden column=7 viewportRow=17 bufferRow=17
+buffer
+0| " DEEPSEEK HARNESS"
+  style 1-8 fg=bright-magenta bold
+  style 10-16 bold
+1| " Snapshot agent ready."
+  style 1-21 dim
+2| " main-session"
+  style 1-12 dim
+3| <blank>
+4| "Assistant                                                                                           "
+  style 0-8 fg=bright-magenta bold underline
+5| "Running the check now.                                                                              "
+6| "Model wait 0.0s                                                                                     "
+  style 0-14 dim
+7| <blank>
+8| "You                                                                                                 "
+  style 0-2 fg=bright-magenta bold underline
+9| "Inspect the renderer.                                                                               "
+10| "Model wait 0.0s · Completed 2026-07-30 18:00:00                                                     "
+  style 0-46 dim
+11| <blank>
+12| "Reasoning blocks hidden.                                                                            "
+  style 0-23 dim
+13| <blank>
+14| "Tool cards hidden.                                                                                  "
+  style 0-17 dim
+15| <blank>
+16| "/workspace/project (tui-staging)  deepseek-v4-flash  ↑0 ↓0  0% context"
+  style 0-17 fg=bright-magenta bold
+  style 18-31 dim
+  style 34-50 dim
+  style 53-57 dim
+  style 60-69 dim
+17| " dsh >                                                                                              "
+  style 1-3 fg=bright-magenta bold
+  style 5-6 dim
+  style 7-7 inverse
+18-39| <blank>

packages/ui/tui/tests/snapshots/details-selector.expected.txt

@@ -0,0 +1,72 @@
+terminal 100x40 buffer=normal length=40 base=0 viewport=0
+lifecycle started=1 stopped=0 progress=inactive
+title "DSH snapshot"
+cursor hidden column=0 viewportRow=39 bufferRow=39
+buffer
+0| " DEEPSEEK HARNESS"
+  style 1-8 fg=bright-magenta bold
+  style 10-16 bold
+1| " Snapshot agent ready."
+  style 1-21 dim
+2| " main-session"
+  style 1-12 dim
+3| <blank>
+4| "Assistant                                                                                           "
+  style 0-8 fg=bright-magenta bold underline
+5| "Running the check now.                                                                              "
+6| "Model wait 0.0s                                                                                     "
+  style 0-14 dim
+7| <blank>
+8| "You                                                                                                 "
+  style 0-2 fg=bright-magenta bold underline
+9| "Inspect the renderer.                                                                               "
+10| <blank>
+11| "Assistant                                                                                           "
+  style 0-8 fg=bright-magenta bold underline
+12| <blank>
+13| "● Tool / bash / Run the coverage gate"
+  style 0-36 fg=green
+14| "$ pnpm run test:coverage                                                                            "
+  style 0-23 dim
+15| "/workspace/project                                                                                  "
+  style 0-17 dim
+16| "… +4 lines (Ctrl+O to expand)                                                                       "
+  style 0-28 dim
+17| "[exit 0]      ╭ Transcript details ──────────────────────────────────────────────────╮              "
+  style 0-7 dim
+  style 14-85 fg=bright-magenta
+18| "Model wait 0.0│ → Tool cards                      collapsed                          │              "
+  style 0-13 dim
+  style 14-14 fg=bright-magenta
+  style 16-58 fg=bright-magenta inverse
+  style 85-85 fg=bright-magenta
+19| "              │   Reasoning                       hidden                             │              "
+  style 14-14 fg=bright-magenta
+  style 27-55 dim
+  style 85-85 fg=bright-magenta
+20| "Reasoning bloc│                                                                      │              "
+  style 0-13 dim
+  style 14-14 fg=bright-magenta
+  style 85-85 fg=bright-magenta
+21| "              │ ↑/↓ move • Tab toggle • Enter/Esc close                              │              "
+  style 14-14 fg=bright-magenta
+  style 16-54 dim
+  style 85-85 fg=bright-magenta
+22| "Tool cards hid╰──────────────────────────────────────────────────────────────────────╯              "
+  style 0-13 dim
+  style 14-85 fg=bright-magenta
+23| <blank>
+24| "Tool and context cards collapsed.                                                                   "
+  style 0-32 dim
+25| <blank>
+26| "/workspace/project (tui-staging)  deepseek-v4-flash  ↑0 ↓0  0% context"
+  style 0-17 fg=bright-magenta bold
+  style 18-31 dim
+  style 34-50 dim
+  style 53-57 dim
+  style 60-69 dim
+27| " dsh >                                                                                              "
+  style 1-3 fg=bright-magenta bold
+  style 5-6 dim
+  style 7-7 inverse
+28-39| <blank>

packages/ui/tui/tests/snapshots/disposed-terminal.expected.txt

@@ -1,7 +1,7 @@
-terminal 92x32 buffer=normal length=37 base=5 viewport=5
+terminal 92x32 buffer=normal length=39 base=7 viewport=7
 lifecycle started=1 stopped=1 progress=inactive
 title "DSH snapshot"
-cursor visible column=0 viewportRow=31 bufferRow=36
+cursor visible column=0 viewportRow=31 bufferRow=38
 buffer
 0| " DEEPSEEK HARNESS"
   style 1-8 fg=bright-magenta bold
@@ -29,48 +29,52 @@ buffer
 12| "                                                                                            "
 13| "/clear — Clear the transcript view (session history is unchanged)                           "
   style 0-64 dim
-14| "/exit — Exit after the active turn reaches idle                                             "
+14| "/details [collapsed|expanded|hidden] [reasoning [on|off]] — Select tool-card visibility and "
+  style 0-91 dim
+15| "reasoning display                                                                           "
+  style 0-16 dim
+16| "/exit — Exit after the active turn reaches idle                                             "
   style 0-46 dim
-15| "/help — Show keyboard shortcuts and commands                                                "
+17| "/help — Show keyboard shortcuts and commands                                                "
   style 0-43 dim
-16| "/model [[provider/]model] — Show or switch this session's model                             "
+18| "/model [[provider/]model] — Show or switch this session's model                             "
   style 0-62 dim
-17| "/palette — Show every color and attribute role this terminal renders                        "
+19| "/palette — Show every color and attribute role this terminal renders                        "
   style 0-67 dim
-18| "/quit — Exit after the active turn reaches idle                                             "
+20| "/quit — Exit after the active turn reaches idle                                             "
   style 0-46 dim
-19| "/reload — EXPERIMENTAL (dev): re-read loader config files and apply the diff (idle only)    "
+21| "/reload — EXPERIMENTAL (dev): re-read loader config files and apply the diff (idle only)    "
   style 0-87 dim
-20| "/resume — List this workspace's resumable sessions                                          "
+22| "/resume — List this workspace's resumable sessions                                          "
   style 0-49 dim
-21| "/status — Show session diagnostics, system prompt, and registered tools                     "
+23| "/status — Show session diagnostics, system prompt, and registered tools                     "
   style 0-70 dim
-22| "/skill:<name> [instructions] — load a skill into the conversation                           "
+24| "/skill:<name> [instructions] — load a skill into the conversation                           "
   style 0-64 dim
-23| <blank>
-24| "provider stream failed after partial output                                                 "
-  style 0-42 fg=red
 25| <blank>
-26| "The previous process ended during this turn.                                                "
-  style 0-43 fg=yellow
+26| "provider stream failed after partial output                                                 "
+  style 0-42 fg=red
 27| <blank>
-28| "Turn stopped: the agent was disposed.                                                       "
-  style 0-36 fg=yellow
+28| "The previous process ended during this turn.                                                "
+  style 0-43 fg=yellow
 29| <blank>
-30| "Turn ended: plugin-policy.                                                                  "
-  style 0-25 fg=yellow
+30| "Turn stopped: the agent was disposed.                                                       "
+  style 0-36 fg=yellow
 31| <blank>
-32| "Unknown command: /unknown-advanced-command                                                  "
-  style 0-41 fg=yellow
+32| "Turn ended: plugin-policy.                                                                  "
+  style 0-25 fg=yellow
 33| <blank>
-34| "/workspace/project (tui-staging)  deepseek-v4-flash  ↑0 ↓0  0% context"
+34| "Unknown command: /unknown-advanced-command                                                  "
+  style 0-41 fg=yellow
+35| <blank>
+36| "/workspace/project (tui-staging)  deepseek-v4-flash  ↑0 ↓0  0% context"
   style 0-17 fg=bright-magenta bold
   style 18-31 dim
   style 34-50 dim
   style 53-57 dim
   style 60-69 dim
-35| " dsh >                                                                                      "
+37| " dsh >                                                                                      "
   style 1-3 fg=bright-magenta bold
   style 5-6 dim
   style 7-7 inverse
-36| <blank>
+38| <blank>

packages/ui/tui/tests/snapshots/errors-and-help.expected.txt

@@ -1,7 +1,7 @@
-terminal 92x32 buffer=normal length=36 base=4 viewport=4
+terminal 92x32 buffer=normal length=38 base=6 viewport=6
 lifecycle started=1 stopped=0 progress=inactive
 title "DSH snapshot"
-cursor hidden column=7 viewportRow=31 bufferRow=35
+cursor hidden column=7 viewportRow=31 bufferRow=37
 buffer
 0| " DEEPSEEK HARNESS"
   style 1-8 fg=bright-magenta bold
@@ -29,47 +29,51 @@ buffer
 12| "                                                                                            "
 13| "/clear — Clear the transcript view (session history is unchanged)                           "
   style 0-64 dim
-14| "/exit — Exit after the active turn reaches idle                                             "
+14| "/details [collapsed|expanded|hidden] [reasoning [on|off]] — Select tool-card visibility and "
+  style 0-91 dim
+15| "reasoning display                                                                           "
+  style 0-16 dim
+16| "/exit — Exit after the active turn reaches idle                                             "
   style 0-46 dim
-15| "/help — Show keyboard shortcuts and commands                                                "
+17| "/help — Show keyboard shortcuts and commands                                                "
   style 0-43 dim
-16| "/model [[provider/]model] — Show or switch this session's model                             "
+18| "/model [[provider/]model] — Show or switch this session's model                             "
   style 0-62 dim
-17| "/palette — Show every color and attribute role this terminal renders                        "
+19| "/palette — Show every color and attribute role this terminal renders                        "
   style 0-67 dim
-18| "/quit — Exit after the active turn reaches idle                                             "
+20| "/quit — Exit after the active turn reaches idle                                             "
   style 0-46 dim
-19| "/reload — EXPERIMENTAL (dev): re-read loader config files and apply the diff (idle only)    "
+21| "/reload — EXPERIMENTAL (dev): re-read loader config files and apply the diff (idle only)    "
   style 0-87 dim
-20| "/resume — List this workspace's resumable sessions                                          "
+22| "/resume — List this workspace's resumable sessions                                          "
   style 0-49 dim
-21| "/status — Show session diagnostics, system prompt, and registered tools                     "
+23| "/status — Show session diagnostics, system prompt, and registered tools                     "
   style 0-70 dim
-22| "/skill:<name> [instructions] — load a skill into the conversation                           "
+24| "/skill:<name> [instructions] — load a skill into the conversation                           "
   style 0-64 dim
-23| <blank>
-24| "provider stream failed after partial output                                                 "
-  style 0-42 fg=red
 25| <blank>
-26| "The previous process ended during this turn.                                                "
-  style 0-43 fg=yellow
+26| "provider stream failed after partial output                                                 "
+  style 0-42 fg=red
 27| <blank>
-28| "Turn stopped: the agent was disposed.                                                       "
-  style 0-36 fg=yellow
+28| "The previous process ended during this turn.                                                "
+  style 0-43 fg=yellow
 29| <blank>
-30| "Turn ended: plugin-policy.                                                                  "
-  style 0-25 fg=yellow
+30| "Turn stopped: the agent was disposed.                                                       "
+  style 0-36 fg=yellow
 31| <blank>
-32| "Unknown command: /unknown-advanced-command                                                  "
-  style 0-41 fg=yellow
+32| "Turn ended: plugin-policy.                                                                  "
+  style 0-25 fg=yellow
 33| <blank>
-34| "/workspace/project (tui-staging)  deepseek-v4-flash  ↑0 ↓0  0% context"
+34| "Unknown command: /unknown-advanced-command                                                  "
+  style 0-41 fg=yellow
+35| <blank>
+36| "/workspace/project (tui-staging)  deepseek-v4-flash  ↑0 ↓0  0% context"
   style 0-17 fg=bright-magenta bold
   style 18-31 dim
   style 34-50 dim
   style 53-57 dim
   style 60-69 dim
-35| " dsh >                                                                                      "
+37| " dsh >                                                                                      "
   style 1-3 fg=bright-magenta bold
   style 5-6 dim
   style 7-7 inverse

packages/ui/tui/tests/snapshots/tool-cards-hidden-folded.expected.txt

@@ -0,0 +1,46 @@
+terminal 100x40 buffer=normal length=40 base=0 viewport=0
+lifecycle started=1 stopped=0 progress=inactive
+title "DSH snapshot"
+cursor hidden column=7 viewportRow=20 bufferRow=20
+buffer
+0| " DEEPSEEK HARNESS"
+  style 1-8 fg=bright-magenta bold
+  style 10-16 bold
+1| " Snapshot agent ready."
+  style 1-21 dim
+2| " main-session"
+  style 1-12 dim
+3| <blank>
+4| "Assistant                                                                                           "
+  style 0-8 fg=bright-magenta bold underline
+5| "Inspecting the renderer first.                                                                      "
+6| "Model wait 0.0s                                                                                     "
+  style 0-14 dim
+7| <blank>
+8| "You                                                                                                 "
+  style 0-2 fg=bright-magenta bold underline
+9| "Refactor the renderer.                                                                              "
+10| "Model wait 0.0s · Completed 2026-07-29 22:30:00                                                     "
+  style 0-46 dim
+11| <blank>
+12| "The renderer is sound; no refactor needed.                                                          "
+13| "Model wait 0.0s · Completed 2026-07-29 22:30:00                                                     "
+  style 0-46 dim
+14| <blank>
+15| "Tool and context cards expanded.                                                                    "
+  style 0-31 dim
+16| <blank>
+17| "Tool cards hidden.                                                                                  "
+  style 0-17 dim
+18| <blank>
+19| "/workspace/project (tui-staging)  deepseek-v4-flash  ↑0 ↓0  0% context"
+  style 0-17 fg=bright-magenta bold
+  style 18-31 dim
+  style 34-50 dim
+  style 53-57 dim
+  style 60-69 dim
+20| " dsh >                                                                                              "
+  style 1-3 fg=bright-magenta bold
+  style 5-6 dim
+  style 7-7 inverse
+21-39| <blank>

packages/ui/tui/tests/snapshots/untrusted-controls.expected.txt

@@ -13,46 +13,41 @@ buffer
 3| <blank>
 4| "Assistant                                                                                           "
   style 0-8 fg=bright-magenta bold underline
-5| <blank>
-6| "You                                                                                                 "
+5| "Reasoning                                                                                           "
+  style 0-8 dim italic
+6| "Unsafe reasoning \\x1b]2;snapshot-controlled\\x07\\x09\\x7f\\x9b31m                                      "
+  style 0-61 dim italic
+7| "Unsafe assistant \\x1b]2;snapshot-controlled\\x07\\x09\\x7f\\x9b31m                                      "
+8| "Model wait 0.0s                                                                                     "
+  style 0-14 dim
+9| <blank>
+10| "You                                                                                                 "
   style 0-2 fg=bright-magenta bold underline
-7| "Unsafe user \\x1b]2;snapshot-controlled\\x07\\x09\\x7f\\x9b31m                                           "
-8| <blank>
-9| "● Tool / unsafe / Unsafe description \\x1b]2;snapshot-controlled\\x07\\x09\\x7f\\x9b31m"
+11| "Unsafe user \\x1b]2;snapshot-controlled\\x07\\x09\\x7f\\x9b31m                                           "
+12| <blank>
+13| "Assistant                                                                                           "
+  style 0-8 fg=bright-magenta bold underline
+14| <blank>
+15| "● Tool / unsafe / Unsafe description \\x1b]2;snapshot-controlled\\x07\\x09\\x7f\\x9b31m"
   style 0-81 fg=green
-10| "$ Unsafe title \\x1b]2;snapshot-controlled\\x07\\x09\\x7f\\x9b31m                                        "
+16| "$ Unsafe title \\x1b]2;snapshot-controlled\\x07\\x09\\x7f\\x9b31m                                        "
   style 0-59 dim
-11| "/unsafe/\\x1b]2;snapshot-controlled\\x07\\x09\\x7f\\x9b31m                                               "
+17| "/unsafe/\\x1b]2;snapshot-controlled\\x07\\x09\\x7f\\x9b31m                                               "
   style 0-52 dim
-12| "Unsafe output \\x1b]2;snapshot-controlled\\x07\\x09\\x7f\\x9b31m                                         "
+18| "Unsafe output \\x1b]2;snapshot-controlled\\x07\\x09\\x7f\\x9b31m                                         "
   style 0-58 dim
-13| "[signal SIG\\x1b]2;snapshot-controlled\\x07\\x09\\x7f\\x9b31m]                                           "
+19| "[signal SIG\\x1b]2;snapshot-controlled\\x07\\x09\\x7f\\x9b31m]                                           "
   style 0-56 fg=red
-14| "Model wait 0.0s · Completed 2026-07-21 15:00:00                                                     "
+20| "Model wait 0.0s · Completed 2026-07-21 15:00:00                                                     "
   style 0-46 dim
-15| <blank>
-16| "Context · unsafe-\\x1b]2;snapshot-controlled\\x07\\x09\\x7f\\x9b31m"
+21| <blank>
+22| "Context · unsafe-\\x1b]2;snapshot-controlled\\x07\\x09\\x7f\\x9b31m"
   style 0-61 dim
-17| "Unsafe context \\x1b]2;snapshot-controlled\\x07\\x09\\x7f\\x9b31m                                        "
+23| "Unsafe context \\x1b]2;snapshot-controlled\\x07\\x09\\x7f\\x9b31m                                        "
   style 0-59 dim
-18| <blank>
-19| "Unsafe turn error \\x1b]2;snapshot-controlled\\x07\\x09\\x7f\\x9b31m                                     "
+24| <blank>
+25| "Unsafe turn error \\x1b]2;snapshot-controlled\\x07\\x09\\x7f\\x9b31m                                     "
   style 0-62 fg=red
-20-21| <blank>
-22| "Plan"
-  style 0-3 fg=bright-magenta bold
-23| "  ● Unsafe todo \\x1b]2;snapshot-controlled\\x07\\x09\\x7f\\x9b31m"
-  style 2-2 fg=yellow
-24| "/workspace/project (tui-staging)  deepseek-v4-flash  ↑0 ↓0  0% context"
-  style 0-17 fg=bright-magenta bold
-  style 18-31 dim
-  style 34-50 dim
-  style 53-57 dim
-  style 60-69 dim
-25| " dsh >                                                                                              "
-  style 1-3 fg=bright-magenta bold
-  style 5-6 dim
-  style 7-7 inverse
 26| "                                                                                                    "
 27| "  Question 1/1 (1 unanswered) · Unsafe header \\x1b]2;snapshot-controlled\\x07\\x09\\x7f\\x9b31m         "
   style 2-90 dim

packages/ui/tui/tests/tui.snapshot.ts

@@ -44,6 +44,9 @@ const CHECKPOINTS = [
   'cordis-tools-pending',
   'advanced-cards-collapsed',
   'advanced-cards-expanded',
+  'tool-cards-hidden-folded',
+  'details-command',
+  'details-selector',
   'untrusted-controls',
   'question-dialog',
   'question-dialog-single-option',
@@ -609,6 +612,71 @@ describe('TUI terminal-state snapshots', () => {
     await disposeSnapshot(harness)
   })
 
+  it('pins the hidden phase folding a multi-step turn into one assistant message', async () => {
+    const nowSpy = vi.spyOn(Date, 'now').mockReturnValue(new Date(2026, 6, 29, 22, 30, 0).getTime())
+    const harness = await setupSnapshot({
+      tools: ADVANCED_CARD_TOOLS,
+      config: { maxToolOutputLines: 3 },
+    }, { columns: 100, rows: 40 })
+    await renderAfter(harness, () => {
+      appendUser(harness.session, 'Refactor the renderer.')
+      appendAssistant(harness.session, [{ type: 'text', text: 'Inspecting the renderer first.' }])
+      appendToolCalls(harness.session, [
+        { id: 'fold-1', name: 'bash', arguments: { command: 'pnpm run test' } },
+      ])
+      appendToolResult(harness.session, 'fold-1', [{ type: 'text', text: 'all tests pass' }])
+      harness.session.append('step/end', { turn: 1, step: 1 })
+      harness.session.append('step/start', { turn: 1, step: 2 })
+      appendAssistant(harness.session, [{ type: 'text', text: 'The renderer is sound; no refactor needed.' }], undefined, { turn: 1, step: 2 })
+      harness.session.append('step/end', { turn: 1, step: 2 })
+      harness.session.append('turn/end', { turn: 1, reason: { kind: 'completed' } })
+    })
+    // collapsed -> expanded -> hidden: one Assistant header, no tool card.
+    await renderAfter(harness, () => { harness.terminal.send('\x0f') })
+    await renderAfter(harness, () => { harness.terminal.send('\x0f') })
+    await checkpoint('tool-cards-hidden-folded', harness.terminal, { includeScrollback: true })
+    nowSpy.mockRestore()
+    await disposeSnapshot(harness)
+  })
+
+  it('pins /details jumping card visibility and reasoning display to named states', async () => {
+    const nowSpy = vi.spyOn(Date, 'now').mockReturnValue(new Date(2026, 6, 30, 18, 0, 0).getTime())
+    const harness = await setupSnapshot({
+      tools: ADVANCED_CARD_TOOLS,
+      config: { maxToolOutputLines: 3 },
+    }, { columns: 100, rows: 40 })
+    await renderAfter(harness, () => {
+      appendUser(harness.session, 'Inspect the renderer.')
+      appendAssistant(harness.session, [
+        { type: 'reasoning', text: 'The tool card and this block vanish under /details hidden reasoning off.' },
+        { type: 'text', text: 'Running the check now.' },
+      ])
+      appendToolCalls(harness.session, [
+        { id: 'details-1', name: 'bash', arguments: { command: 'pnpm run test' } },
+      ])
+      appendToolResult(harness.session, 'details-1', [{ type: 'text', text: 'all tests pass' }])
+      harness.session.append('step/end', { turn: 1, step: 1 })
+      harness.session.append('turn/end', { turn: 1, reason: { kind: 'completed' } })
+    })
+    await renderAfter(harness, () => {
+      harness.terminal.send('/details hidden reasoning off')
+      harness.terminal.send('\r')
+    })
+    await checkpoint('details-command', harness.terminal, { includeScrollback: true })
+    // Bare /details opens the two-entry toggle seeded with the current
+    // hidden/reasoning-off state; one Tab immediately cycles tool cards
+    // hidden -> collapsed, so the frame pins the applied notice, the restored
+    // tool card behind the dialog, and the updated entry value together.
+    await renderAfter(harness, () => {
+      harness.terminal.send('/details')
+      harness.terminal.send('\r')
+      harness.terminal.send('\t')
+    })
+    await checkpoint('details-selector', harness.terminal, { includeScrollback: true })
+    nowSpy.mockRestore()
+    await disposeSnapshot(harness)
+  })
+
   it('renders terminal controls as inert text across transcripts, tools, dialogs, diagnostics, and title', async () => {
     const nowSpy = vi.spyOn(Date, 'now').mockReturnValue(new Date(2026, 6, 21, 15, 0, 0).getTime())
     const tools = {

packages/ui/tui/tests/tui.spec.ts

@@ -192,6 +192,7 @@ describe('TUI config', () => {
       questionDialogMaxHeight: 20,
       modelDialogWidth: 76,
       modelDialogMaxHeight: 20,
+      detailsDialogWidth: 72,
       fileSearchMaxResults: 20,
       fileSearchMaxEntries: 10_000,
       fileSearchExcludedDirectories: ['.git', 'node_modules'],
@@ -216,6 +217,7 @@ describe('TUI config', () => {
       questionDialogMaxHeight: 14,
       modelDialogWidth: 64,
       modelDialogMaxHeight: 16,
+      detailsDialogWidth: 44,
       fileSearchMaxResults: 7,
       fileSearchMaxEntries: 123,
       fileSearchExcludedDirectories: ['.git', 'generated'],
@@ -232,6 +234,7 @@ describe('TUI config', () => {
       questionDialogMaxHeight: 14,
       modelDialogWidth: 64,
       modelDialogMaxHeight: 16,
+      detailsDialogWidth: 44,
       fileSearchMaxResults: 7,
       fileSearchMaxEntries: 123,
       fileSearchExcludedDirectories: ['.git', 'generated'],
@@ -2687,6 +2690,94 @@ describe('pi-tui chat lifecycle and transcript', () => {
     await dispose(result)
   })
 
+  it('/details sets card visibility and reasoning display from arguments', async () => {
+    const result = await setup()
+    const run = async (line: string): Promise<void> => {
+      result.terminal.send(line)
+      result.terminal.send('\r')
+      await tick()
+    }
+
+    await run('/details hidden')
+    expect(result.terminal.output).toContain('Tool cards hidden.')
+
+    await run('/details expanded reasoning off')
+    expect(result.terminal.output).toContain('Tool and context cards expanded.')
+    expect(result.terminal.output).toContain('Reasoning blocks hidden.')
+
+    await run('/details reasoning on')
+    expect(result.terminal.output).toContain('Reasoning blocks shown.')
+
+    // Bare `reasoning` toggles: shown -> hidden.
+    const toggleOutput = result.terminal.output.length
+    await run('/details reasoning')
+    expect(result.terminal.output.slice(toggleOutput)).toContain('Reasoning blocks hidden.')
+    await run('/details collapsed')
+    expect(result.terminal.output.slice(toggleOutput)).toContain('Tool and context cards collapsed.')
+
+    await run('/details bogus')
+    expect(result.terminal.output).toContain('Unknown /details argument "bogus"')
+
+    await dispose(result)
+  })
+
+  it('bare /details opens the transcript-details toggle and Tab applies immediately', async () => {
+    const result = await setup()
+    const open = async (): Promise<number> => {
+      const from = result.terminal.output.length
+      result.terminal.send('/details')
+      result.terminal.send('\r')
+      await vi.waitFor(() => { expect(result.terminal.output.slice(from)).toContain('Transcript details') })
+      return from
+    }
+
+    const opened = await open()
+    expect(result.terminal.output.slice(opened)).toContain('Tool cards')
+    expect(result.terminal.output.slice(opened)).toContain('Reasoning')
+
+    // A second /details while the selector is open replaces the overlay
+    // instead of stacking a second one behind it.
+    await result.ctx.commands.execute(result.agent, '/details', new AbortController().signal)
+    await tick()
+
+    // Each Tab applies one step immediately while the dialog stays open:
+    // collapsed -> expanded -> hidden -> collapsed (wraparound).
+    result.terminal.send('\t')
+    await tick()
+    expect(result.terminal.output).toContain('Tool and context cards expanded.')
+    result.terminal.send('\t')
+    await tick()
+    expect(result.terminal.output).toContain('Tool cards hidden.')
+    result.terminal.send('\t')
+    await tick()
+    expect(result.terminal.output).toContain('Tool and context cards collapsed.')
+
+    // The reasoning entry toggles the same way.
+    result.terminal.send('\x1b[B')
+    result.terminal.send('\t')
+    await tick()
+    expect(result.terminal.output).toContain('Reasoning blocks hidden.')
+
+    // Enter closes without further changes.
+    const entered = result.terminal.output.length
+    result.terminal.send('\r')
+    await tick()
+    expect(result.terminal.output.slice(entered)).not.toContain('Reasoning blocks')
+
+    // Esc and Ctrl+C also close; the reopened dialog shows the live values.
+    const reopened = await open()
+    expect(result.terminal.output.slice(reopened)).toContain('collapsed')
+    expect(result.terminal.output.slice(reopened)).toContain('hidden')
+    result.terminal.send('\x1b')
+    await tick()
+    const ctrlCOutput = await open()
+    result.terminal.send('\x03')
+    await tick()
+    expect(result.terminal.output.slice(ctrlCOutput)).not.toContain('Reasoning blocks')
+
+    await dispose(result)
+  })
+
   it('sends, steers, handles commands, global keys, and disposed-agent input', async () => {
     const result = await setup()
 
@@ -5167,6 +5258,134 @@ describe('tool cards and surface replay', () => {
     expect(mounted).not.toContain('stored model-only payload')
     await dispose(result)
   })
+
+  /** The last repainted frame, with CSI/OSC escapes and carriage returns stripped. */
+  const lastFrame = (terminal: FakeTerminal): string => terminal.output
+    .slice(terminal.output.lastIndexOf('\x1b[2J'))
+    .replaceAll(/\x1b\[[0-9;]*[A-Za-z]|\x1b\][^\x07]*\x07|\r/g, '')
+
+  const countAssistantHeaders = (frame: string): number => frame.split('\n')
+    .filter(row => row.trim() === 'Assistant').length
+
+  /** One turn with text -> tool call/result -> text across two steps. */
+  const appendTwoStepTurn = (session: Awaited<ReturnType<typeof setup>>['session']): void => {
+    appendUser(session, 'fold me')
+    appendAssistant(session, [{ type: 'text', text: 'first step text' }])
+    session.append('tool/call', { turn: 1, step: 1, callId: 'fold-1' as never, name: 'bash', arguments: '{}' })
+    session.append('tool/result', {
+      turn: 1, step: 1,
+      message: createToolResultMessage({
+        callId: 'fold-1' as never, content: [{ type: 'text', text: 'tool body' }], isError: false,
+      }),
+    }, { surfaceOp: 'append' })
+    session.append('step/end', { turn: 1, step: 1 })
+    session.append('step/start', { turn: 1, step: 2 })
+    appendAssistant(session, [{ type: 'text', text: 'second step text' }], undefined, { turn: 1, step: 2 })
+    session.append('step/end', { turn: 1, step: 2 })
+    session.append('turn/end', { turn: 1, reason: { kind: 'completed' } })
+  }
+
+  it('folds a turn to one Assistant header in hidden mode and restores headers on cycle', async () => {
+    const result = await setup({ tools })
+    appendTwoStepTurn(result.session)
+    await tick()
+
+    // Collapsed (default): each step keeps its own header.
+    result.terminal.send('\x0c')
+    await tick()
+    expect(countAssistantHeaders(lastFrame(result.terminal))).toBe(2)
+
+    // collapsed -> expanded -> hidden.
+    result.terminal.send('\x0f')
+    result.terminal.send('\x0f')
+    await tick()
+    result.terminal.send('\x0c')
+    await tick()
+    const hidden = lastFrame(result.terminal)
+    expect(countAssistantHeaders(hidden)).toBe(1)
+    expect(hidden).toContain('first step text')
+    expect(hidden).toContain('second step text')
+    expect(hidden).not.toContain('Tool / bash')
+    // The fold keeps model order: header text precedes the continuation.
+    expect(hidden.indexOf('first step text')).toBeLessThan(hidden.indexOf('second step text'))
+
+    // hidden -> collapsed restores per-step headers.
+    result.terminal.send('\x0f')
+    await tick()
+    result.terminal.send('\x0c')
+    await tick()
+    expect(countAssistantHeaders(lastFrame(result.terminal))).toBe(2)
+    await dispose(result)
+  })
+
+  it('gives the hidden-mode header to the first step with a visible body and keeps turns separate', async () => {
+    const result = await setup({ tools })
+    // Turn 1, step 1 is tool-only; step 2 carries the turn's text.
+    appendUser(result.session, 'tool-only first step')
+    appendAssistant(result.session, [{ type: 'tool-call', id: 'only-1' as never, name: 'bash', arguments: '{}' }])
+    result.session.append('tool/call', { turn: 1, step: 1, callId: 'only-1' as never, name: 'bash', arguments: '{}' })
+    result.session.append('tool/result', {
+      turn: 1, step: 1,
+      message: createToolResultMessage({
+        callId: 'only-1' as never, content: [{ type: 'text', text: 'tool body' }], isError: false,
+      }),
+    }, { surfaceOp: 'append' })
+    result.session.append('step/end', { turn: 1, step: 1 })
+    result.session.append('step/start', { turn: 1, step: 2 })
+    appendAssistant(result.session, [{ type: 'text', text: 'late turn-one text' }], undefined, { turn: 1, step: 2 })
+    result.session.append('step/end', { turn: 1, step: 2 })
+    result.session.append('turn/end', { turn: 1, reason: { kind: 'completed' } })
+    // Turn 2 keeps its own header.
+    result.session.append('turn/start', { turn: 2, trigger: { kind: 'message', source: { kind: 'user' } } })
+    appendUser(result.session, 'next turn')
+    result.session.append('step/start', { turn: 2, step: 1 })
+    appendAssistant(result.session, [{ type: 'text', text: 'turn-two text' }], undefined, { turn: 2, step: 1 })
+    result.session.append('step/end', { turn: 2, step: 1 })
+    result.session.append('turn/end', { turn: 2, reason: { kind: 'completed' } })
+    await tick()
+
+    result.terminal.send('\x0f')
+    result.terminal.send('\x0f')
+    await tick()
+    result.terminal.send('\x0c')
+    await tick()
+    const hidden = lastFrame(result.terminal)
+    // One header per turn: the tool-only step neither renders a blank segment
+    // nor consumes turn one's header, which the late text step owns.
+    expect(countAssistantHeaders(hidden)).toBe(2)
+    expect(hidden).toContain('late turn-one text')
+    expect(hidden).toContain('turn-two text')
+    const rows = hidden.split('\n').map(row => row.trim())
+    const turnOneHeader = rows.indexOf('Assistant')
+    expect(rows[turnOneHeader + 1]).toBe('late turn-one text')
+    await dispose(result)
+  })
+
+  it('folds live hidden-mode streaming once a later step shows text', async () => {
+    const result = await setup({ tools, status: 'running' })
+    result.terminal.send('\x0f')
+    result.terminal.send('\x0f')
+    await tick()
+    result.session.append('assistant/chunk', { turn: 1, step: 1, chunk: { type: 'text-delta', index: 0, text: 'live first' } })
+    result.session.append('step/end', { turn: 1, step: 1 })
+    result.session.append('step/start', { turn: 1, step: 2 })
+    result.session.append('assistant/chunk', { turn: 1, step: 2, chunk: { type: 'text-delta', index: 0, text: 'live second' } })
+    await tick()
+    result.terminal.send('\x0c')
+    await tick()
+    const hidden = lastFrame(result.terminal)
+    expect(countAssistantHeaders(hidden)).toBe(1)
+    expect(hidden).toContain('live first')
+    expect(hidden).toContain('live second')
+
+    // A transcript rebuild (resize) recomputes the same fold from the log.
+    result.terminal.resize(89)
+    await tick()
+    const rebuilt = lastFrame(result.terminal)
+    expect(countAssistantHeaders(rebuilt)).toBe(1)
+    expect(rebuilt).toContain('live second')
+    await dispose(result)
+  })
 })
 
 describe('TUI user-interaction dialogs', () => {