Merge remote-tracking branch 'origin/master' into codex/pr-1037-resolution

# Conflicts:
#	packages/ui/tui/README.i18n.yaml

packages/ui/tui/src/chat/model-command.ts

@@ -8,7 +8,7 @@
  */
 
 import type { AgentLlmTarget, AgentLlmTargetRef } from '@deepseek-ai/dsh-agent'
-import { errorChain, type ReasoningEffortId } from '@deepseek-ai/dsh-llm'
+import { errorChain, LlmError, type ReasoningEffortId } from '@deepseek-ai/dsh-llm'
 import type { TuiOverlaySession } from '../extension/types.ts'
 import { displayText } from '../components/text.ts'
 import {
@@ -37,6 +37,8 @@ export interface ModelController {
   resetContextResolution(): void
   /** Forget the tracked selector overlay (shutdown). */
   clearOverlay(): void
+  /** Remove the adapter-registration listener (channel detach). */
+  detach(): void
 }
 
 type ContextResolution =
@@ -55,8 +57,15 @@ export function createModelController(deps: ModelControllerDeps): ModelControlle
   let modelOverlay: TuiOverlaySession | undefined
   let modelCommands = Promise.resolve()
 
+  // A route whose adapter has not registered yet. Loader activation order is
+  // service-driven, so the TUI can mount before a configured adapter plugin
+  // activates; that transient NO_ADAPTER is not an error — the resolution
+  // waits for the next `llm/adapters-updated` commit instead of surfacing it.
+  let awaitingAdapter = false
+
   const resolveContextWindow = (selected: AgentLlmTarget | undefined): void => {
     contextWindow = undefined
+    awaitingAdapter = false
     const resolution: Promise<ContextResolution> = selected === undefined
       ? Promise.resolve({ kind: 'resolved', contextWindow: undefined } as const)
       : ctx.llm.resolveModelInfo(selected.provider, selected.model).then(
@@ -67,6 +76,10 @@ export function createModelController(deps: ModelControllerDeps): ModelControlle
     void resolution.then((result) => {
       if (contextResolution !== resolution) return
       if (result.kind === 'error') {
+        if (selected !== undefined && result.error instanceof LlmError && result.error.code === 'NO_ADAPTER') {
+          awaitingAdapter = true
+          return
+        }
         deps.appendNotice(`Could not resolve model context: ${errorChain(result.error)}`, 'error')
         return
       }
@@ -74,6 +87,15 @@ export function createModelController(deps: ModelControllerDeps): ModelControlle
       deps.requestRender()
     })
   }
+  // The wait cannot go stale against `target.current`: every target change
+  // re-enters resolveContextWindow, which clears it. A commit that still
+  // lacks the route parks the resolution again rather than erroring, so
+  // unrelated topology changes stay silent. The disposer rides the channel's
+  // detachListeners() through detach(), matching the sibling listeners.
+  const disposeAdapterListener = ctx.on('llm/adapters-updated', () => {
+    if (deps.isDisposed() || !awaitingAdapter) return
+    resolveContextWindow(target.current)
+  })
   resolveContextWindow(target.current)
 
   const selectModel = (
@@ -187,5 +209,8 @@ export function createModelController(deps: ModelControllerDeps): ModelControlle
     clearOverlay(): void {
       modelOverlay = undefined
     },
+    detach(): void {
+      disposeAdapterListener()
+    },
   }
 }

packages/ui/tui/src/chat/timing.ts

@@ -1,8 +1,8 @@
 /**
- * Per-step timing model and running-status glyph animation for the terminal
+ * Per-step timing model and prompt-status glyph animation for the terminal
  * front door. Timing buckets are replayed from the session event stream; the
- * running glyph fades in on turn start, throbs while the turn runs, and fades
- * out on turn end.
+ * active glyph fades in when work starts, throbs while work runs, and fades out
+ * when it ends.
  * @module @deepseek-ai/dsh-tui/chat/timing
  */
 
@@ -10,25 +10,25 @@ import type { SessionEvent } from '@deepseek-ai/dsh-session'
 import type { Palette } from '../components/theme.ts'
 
 /**
- * Render cadence of the running prompt while active, and while the glyph fades
- * out after a turn ends. ~20 fps so the truecolor glyph fade reads smoothly;
+ * Render cadence of the status prompt while active, and while the glyph fades
+ * out after work ends. ~20 fps so the truecolor glyph fade reads smoothly;
  * the same tick keeps the elapsed-time text (0.1 s resolution) current. Only
  * changed terminal cells are re-emitted, so the faster tick stays cheap.
  */
 export const STATUS_ANIMATION_INTERVAL_MS = 50
 
 /**
- * Milliseconds over which the running glyph fades in when a turn starts and
- * fades out after it ends. The fade is an envelope over the running pulse:
+ * Milliseconds over which the status glyph fades in when work starts and fades
+ * out after it ends. The fade is an envelope over the active pulse:
  * inside it the glyph throbs (see {@link STATUS_PULSE_PERIOD_MS}).
  */
 export const STATUS_FADE_MS = 300
 
-/** Milliseconds for one full brightness throb of the running glyph. */
+/** Milliseconds for one full brightness throb of the active status glyph. */
 export const STATUS_PULSE_PERIOD_MS = 1400
 
 /**
- * Brightness floor of the running throb, as a fraction of the settled gray. At
+ * Brightness floor of the status throb, as a fraction of the settled gray. At
  * 0 the pulse swells from the near-background trough up to full and back. The
  * trough is still rendered as the dimmest gray, not clipped to a blank, so the
  * cosine breathes symmetrically bold→dim→bold.
@@ -36,7 +36,7 @@ export const STATUS_PULSE_PERIOD_MS = 1400
 export const STATUS_PULSE_FLOOR = 0
 
 /**
- * Muted-gray foreground the truecolor running glyph fades through, from the
+ * Muted-gray foreground the truecolor status glyph fades through, from the
  * near-background trough (opacity 0) to the settled dim gray (opacity 1). Same
  * hue-free gray as the idle caret, so the glyph reads as the caret dimly
  * appearing rather than a colored indicator. Foreground-only, matching the
@@ -185,6 +185,9 @@ export const TIMING_BUCKET_GLYPHS: Record<TimingBucket, string> = {
   tools: '⚙',
 }
 
+/** Status glyph for a live standalone compaction bracket. */
+const COMPACTING_GLYPH = '⊙'
+
 /**
  * Derive the currently open step's active timing bucket, or `undefined` when no
  * step is open. The open step is the last `step/start` with no later matching
@@ -219,25 +222,32 @@ export function openStepPhase(events: readonly SessionEvent[]): TimingBucket | u
 }
 
 /**
- * The running agent's phase glyph, or `undefined` when idle. A running turn
- * with no open step falls back to the pre-first-token wait so a glyph is always
- * available while the agent works; it fades in on turn start, throbs while the
- * turn runs, and fades out on turn end (see {@link fadeGlyph}).
+ * The active status glyph, or `undefined` when idle. A running turn takes
+ * precedence over standalone compaction and falls back to the pre-first-token
+ * wait when no step is open. The caller applies the shared fade and throb
+ * animation (see {@link fadeGlyph}).
  * @param events - Session events to derive the phase from.
  * @param running - Whether the agent is currently running.
- * @returns The phase glyph, or `undefined` when idle.
+ * @param compacting - Whether a live standalone compaction bracket is open.
+ * @returns The active status glyph, or `undefined` when idle.
  */
-export function runningPhaseGlyph(events: readonly SessionEvent[], running: boolean): string | undefined {
-  if (!running) return undefined
-  const bucket = openStepPhase(events) ?? 'ttft'
-  return TIMING_BUCKET_GLYPHS[bucket]
+export function runningPhaseGlyph(
+  events: readonly SessionEvent[],
+  running: boolean,
+  compacting: boolean,
+): string | undefined {
+  if (running) {
+    const bucket = openStepPhase(events) ?? 'ttft'
+    return TIMING_BUCKET_GLYPHS[bucket]
+  }
+  return compacting ? COMPACTING_GLYPH : undefined
 }
 
 /**
- * The running throb's brightness at continuous clock `nowMs`: a cosine between
+ * The status throb's brightness at continuous clock `nowMs`: a cosine between
  * {@link STATUS_PULSE_FLOOR} and 1 over {@link STATUS_PULSE_PERIOD_MS}, so the
  * dim glyph breathes bold→dim→bold without ever blinking off. Multiplied by the
- * fade envelope, which alone drives appear/disappear at turn boundaries.
+ * fade envelope, which alone drives appear/disappear at work boundaries.
  *
  * @param nowMs - Monotonic render clock in milliseconds.
  * @returns Brightness fraction in [{@link STATUS_PULSE_FLOOR}, 1].
@@ -249,14 +259,14 @@ export function pulseLevel(nowMs: number): number {
 }
 
 /**
- * One frame of the running glyph at fade `opacity` (0 = near-background trough
+ * One frame of the status glyph at fade `opacity` (0 = near-background trough
  * gray, 1 = settled dim gray). The character and its width never change — only
  * the gray fades — so the prompt caret column stays fixed and the glyph reads as
  * the caret dimly breathing, never a colored indicator.
  *
  * With truecolor the glyph's 24-bit gray foreground interpolates continuously
  * between {@link STATUS_FADE_GRAY}'s trough and settled stops, so both the fade
- * and the running throb render as a smooth, symmetric brightness swing with no
+ * and the status throb render as a smooth, symmetric brightness swing with no
  * hard cutoff to clip the trough into a blank. Without truecolor there is no
  * per-frame gray, so `visible` (driven by the fade envelope, not the opacity)
  * shows the glyph in the palette's muted role or leaves a blank column — a
@@ -264,7 +274,7 @@ export function pulseLevel(nowMs: number): number {
  * no throb-driven blink. With color off entirely a visible glyph is bare,
  * holding the caret column on a monochrome terminal.
  *
- * @param glyph - The phase glyph to paint.
+ * @param glyph - The status glyph to paint.
  * @param palette - Active palette supplying the muted (dim gray) role.
  * @param colorEnabled - Whether ANSI is emitted at all.
  * @param truecolor - Whether the terminal accepts 24-bit foreground codes.

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/theme.ts

@@ -46,6 +46,8 @@ export type AttributeRole = <T extends string>(text: T) => T
  */
 export interface Palette {
   accent: ColorRole
+  /** DeepSeek brand ink; exact gradient callers may override it on truecolor terminals. */
+  brand: ColorRole
   /** The terminal's own default foreground; still a color, so it does not stack. */
   text: ColorRole
   /** The one recessed tone, below `text`: tool-card bodies, chrome, reasoning, footers. */
@@ -63,7 +65,7 @@ export interface Palette {
 }
 
 /** Names of the palette's color roles, in the order `/palette` prints them. */
-export const COLOR_ROLES = ['text', 'dim', 'accent', 'code', 'success', 'warning', 'error'] as const
+export const COLOR_ROLES = ['text', 'dim', 'accent', 'brand', 'code', 'success', 'warning', 'error'] as const
 
 /** Names of the palette's attribute roles, in the order `/palette` prints them. */
 export const ATTRIBUTE_ROLES = ['bold', 'italic', 'underline', 'strike', 'selected'] as const
@@ -86,8 +88,9 @@ export interface RoleSpec {
  *
  * Only the standard 16-color set and SGR attributes appear here. Terminals remap
  * those to the user's active theme, so the TUI stays legible on any background;
- * a fixed 24-bit color would not. The brand gradient is the one deliberate
- * exception ({@link gradientText}).
+ * a fixed 24-bit color would not. The startup gradient and exact official mark
+ * color are the two deliberate brand exceptions ({@link gradientText},
+ * {@link brandText}).
  *
  * @param scheme - Active terminal color scheme; only `code` differs between them.
  * @returns The SGR spec for every color and attribute role.
@@ -109,6 +112,7 @@ export function paletteSpec(scheme: TerminalColorScheme): {
       // prominent text on screen.
       dim: { open: '2;39', close: '22;39', purpose: 'The one recessed tone: tool bodies, chrome, footers' },
       accent: { open: '95', close: '39', purpose: 'The one emphasis color: role headers, prompt, borders' },
+      brand: { open: '34', close: '39', purpose: 'DeepSeek brand art when truecolor is unavailable' },
       // ANSI 36 (cyan) is difficult to read on a light background — use ANSI 34
       // (blue) which is legible on both light and dark schemes.
       code: scheme === 'light'
@@ -168,6 +172,19 @@ const BRAND_GRADIENT = [
   [36, 152, 255], // #2498FF
 ] as const
 
+/** Official DeepSeek icon ink from the shipped 24x24 SVG. */
+const DEEPSEEK_BRAND_RGB = BRAND_GRADIENT[0]
+
+/**
+ * Paint trusted static DeepSeek brand art with the official `#4D6BFE` ink.
+ * @param text - Static brand text or raster cells.
+ * @returns text wrapped in the official truecolor foreground and a foreground reset.
+ */
+export function brandText(text: string): string {
+  const [r, g, b] = DEEPSEEK_BRAND_RGB
+  return `\x1b[38;2;${r};${g};${b}m${text}\x1b[39m`
+}
+
 /**
  * Sample {@link BRAND_GRADIENT} at fraction `t` via piecewise-linear
  * interpolation across its stops.
@@ -199,13 +216,12 @@ function brandColorAt(t: number): readonly [number, number, number] {
  * @returns `text` wrapped in truecolor SGR foreground codes.
  */
 export function gradientText(text: string): string {
-  // The sole caller passes the ASCII product name, so UTF-16 unit iteration
-  // samples exactly one color per visible letter.
-  const last = Math.max(1, text.length - 1)
+  const glyphs = Array.from(text)
+  const last = Math.max(1, glyphs.length - 1)
   let painted = ''
-  for (let index = 0; index < text.length; index += 1) {
+  for (let index = 0; index < glyphs.length; index += 1) {
     const [r, g, b] = brandColorAt(index / last)
-    painted += `\x1b[38;2;${r};${g};${b}m${text.charAt(index)}`
+    painted += `\x1b[38;2;${r};${g};${b}m${glyphs[index]}`
   }
   return `${painted}\x1b[39m`
 }

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

@@ -186,20 +186,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 }),
@@ -257,6 +265,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
@@ -265,7 +274,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,
@@ -336,18 +346,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)
   }
 }
 
@@ -405,6 +446,7 @@ export class ToolCardComponent implements Component {
    * @param event - The `tool/result` event payload.
    */
   updateResult(event: Extract<SessionEvent, { type: 'tool/result' }>['data']): void {
+    this.diffBodyCache = undefined
     const result = event.message.content[0]
     this.result = {
       content: [...result.content],
@@ -441,23 +483,26 @@ export class ToolCardComponent implements Component {
     const glyph = this.result === undefined ? '○' : '●'
     const rawBody = this.renderBody()
     const view = this.resultView ?? this.callView
-    // A generic card's own content, or a read card's `content` fallback (the
+    // A generic card's own content, a read card's `content` fallback (the
     // envelope-stripped file text — the TUI has no dedicated read rendering, so a
-    // read renders exactly as before the read card existed), or a web card's
-    // fallback to the raw result content (the `web` view carries no `content`
-    // copy), all render as one dim Markdown block below, so links/lists/headings
-    // keep the unified dim styling rather than reading as bare text. Terminal and
-    // diff cards own their body styling, so they are excluded (mirrors
-    // renderBody's post-terminal/diff fallback).
+    // read renders exactly as before the read card existed), or a search/web
+    // card's fallback to the raw result content (neither the `search` nor the
+    // `web` view carries a `content` copy), all render as one dim Markdown block
+    // below, so links/lists/headings keep the unified dim styling rather than
+    // reading as bare text. A search card thus stays byte-identical to the
+    // pre-search-card generic fallback. Terminal and diff cards own their body
+    // styling, so they are excluded (mirrors renderBody's post-terminal/diff fallback).
     const markdownContent = view.card === 'generic' || view.card === 'read'
       ? view.content ?? this.result?.content
-      : view.card === 'web'
-        // A web resultView is only assigned alongside this.result (the result
-        // handler sets both) and the pending callView is never a web card, so
-        // the optional-chain undefined side is unreachable here.
-        /* v8 ignore next */
+      : view.card === 'search'
         ? this.result?.content
-        : undefined
+        : view.card === 'web'
+          // A web resultView is only assigned alongside this.result (the result
+          // handler sets both) and the pending callView is never a web card, so
+          // the optional-chain undefined side is unreachable here.
+          /* v8 ignore next */
+          ? this.result?.content
+          : undefined
     const unknownXml = this.definition === undefined && markdownContent !== undefined
       ? renderUnknownXml(
         displayText(contentText(markdownContent)),
@@ -578,11 +623,12 @@ export class ToolCardComponent implements Component {
       this.diffBodyCache = { view, body }
       return body
     }
-    // A generic or read card carries its own envelope-stripped `content`; a `web`
-    // card carries no `content` copy and falls back to the raw result content
-    // here. (Mirrors the `markdownContent` selection in render(); a read card has
-    // no dedicated TUI rendering, so its `content` takes the same body path,
-    // keeping read output as it was before the read card existed.)
+    // A generic or read card carries its own envelope-stripped `content`; a
+    // search or web card carries no `content` copy and falls back to the raw
+    // result content here. (Mirrors the `markdownContent` selection in render();
+    // a read card has no dedicated TUI rendering, so its `content` takes the same
+    // body path, keeping read output as it was before the read card existed, and
+    // a search card stays byte-identical to the pre-search-card fallback.)
     const content = (view.card === 'generic' || view.card === 'read' ? view.content : undefined) ?? this.result?.content
     const prelude: string[] = []
     const lines: string[] = []

packages/ui/tui/src/config.ts

@@ -50,6 +50,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. */
@@ -74,6 +76,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])
@@ -106,6 +109,7 @@ const tuiConfigSchemaFields = {
   questionDialogMaxHeight: questionDialogMaxHeightSchema,
   modelDialogWidth: modelDialogWidthSchema,
   modelDialogMaxHeight: modelDialogMaxHeightSchema,
+  detailsDialogWidth: detailsDialogWidthSchema,
   fileSearchMaxResults: fileSearchMaxResultsSchema,
   fileSearchMaxEntries: fileSearchMaxEntriesSchema,
   fileSearchExcludedDirectories: fileSearchExcludedDirectoriesSchema,
@@ -126,8 +130,8 @@ export interface Config extends TuiConfig {
   /**
    * Skill name auto-invoked as this session's first user turn, exactly as if
    * the user typed `/skill:<name>`. Set only by a launcher for a fresh
-   * skill-guided session (`dsh migrate`/`dsh upgrade`); absent leaves the first
-   * turn to the user.
+   * skill-guided session (`dsh migrate`/`dsh upgrade`); absent
+   * leaves the first turn to the user.
    */
   initialSkill?: string
 }
@@ -147,6 +151,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,
@@ -177,6 +182,7 @@ export interface ResolvedTuiConfig {
   questionDialogMaxHeight: number
   modelDialogWidth: number
   modelDialogMaxHeight: number
+  detailsDialogWidth: number
   fileSearchMaxResults: number
   fileSearchMaxEntries: number
   fileSearchExcludedDirectories: string[]
@@ -203,6 +209,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/extension/types.ts

@@ -37,6 +37,8 @@ export interface TuiFocusable {
 export interface TuiTheme {
   /** Render ordinary foreground text. */
   readonly text: (value: string) => string
+  /** Render trusted static brand art with the host's configured brand treatment. */
+  readonly brand: (value: string) => string
   /** Render secondary information and low-emphasis hints, the one tone below `text`. */
   readonly dim: (value: string) => string
   /** Render the active accent role. */

packages/ui/tui/src/index.ts

@@ -69,7 +69,7 @@ import type {
   TuiTheme,
 } from './extension/types.ts'
 import { displayInlineText, displayText } from './components/text.ts'
-import { createPalette, markdownTheme, renderPalette, selectTheme } from './components/theme.ts'
+import { brandText, createPalette, markdownTheme, renderPalette, selectTheme } from './components/theme.ts'
 import { contentText, parseArguments } from './components/content.ts'
 import {
   cacheHitRate,
@@ -80,6 +80,7 @@ import {
 import {
   fadeGlyph,
   formatQueuedStatus,
+  formatStatusDuration,
   openStepPhase,
   openTurn,
   pulseLevel,
@@ -104,6 +105,7 @@ import {
 } from './components/transcript.ts'
 import {
   compactTargetLabel,
+  DetailsDialog,
   diagnosticMeter,
   formatDiagnosticCount,
   formatDiagnosticNumber,
@@ -112,6 +114,7 @@ import {
   StatusCardComponent,
   PromptContextComponent,
   targetLabel,
+  type DetailsSelection,
   type StatusCardRow,
 } from './components/dialogs.ts'
 import {
@@ -226,9 +229,9 @@ export const TUI_GOODBYE_MESSAGE_KEY = 'tuiGoodbyeMessage'
 /**
  * Context key a launcher sets before any Loader entry mounts
  * (`ctx.provide(INITIAL_SKILL_KEY, name)`) to seed a fresh session's first user
- * turn with `/skill:<name>` — the `dsh migrate`/`dsh upgrade` guided-session
- * entry. The launcher sets it only when minting a fresh session, so it never
- * re-fires on a resumed one. Absent leaves the first turn to the user.
+ * turn with `/skill:<name>` — the `dsh migrate`/`dsh upgrade`
+ * guided-session entry. The launcher sets it only when minting a fresh session,
+ * so it never re-fires on a resumed one. Absent leaves the first turn to the user.
  */
 export const INITIAL_SKILL_KEY = 'tuiInitialSkill'
 
@@ -329,14 +332,27 @@ export function createTuiChat(
   })
   editor.hintPrefix = initialInputPrompt
   const todo = new TodoComponent(palette)
+  const compactionStatusLine = new Text('', 0, 0)
   let showReasoning = resolved.showReasoning
   // Ctrl+O cycles collapsed -> expanded -> hidden. Codex-style: hidden drops
   // tool cards entirely, collapsed previews, expanded shows full bodies.
   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
+  /**
+   * Live standalone compaction observed by this process. Never derive this
+   * state from history: a resumed log may contain a stale orphaned start.
+   */
+  let compacting: {
+    startedAt: number
+    timer: ReturnType<typeof setInterval>
+  } | undefined
   // TUI steering submissions that the inbox has not yet claimed or discarded.
   // Correlation ids avoid guessing whether a running-state submission actually
   // joined steering or fell back to the queued-turn FIFO during turn close.
@@ -400,6 +416,7 @@ export function createTuiChat(
     throw new Error('TUI prompt built-ins failed to initialize')
   }
   const updatePromptValues = (): void => {
+    const renderTime = now()
     cwdValue.set(palette.bold(palette.accent(formattedCwd)))
     gitValue.set(branch === undefined ? undefined : palette.dim(` (${displayText(branch)})`))
     const rate = cacheHitRate(tokens)
@@ -413,23 +430,31 @@ export function createTuiChat(
     const queued = runningStatus === undefined ? undefined : formatQueuedStatus(pendingSteering.size)
     queuedValue.set(queued === undefined ? undefined : palette.dim(queued))
     symbolValue.set(palette.bold(palette.accent('dsh')))
+    compactionStatusLine.setText(compacting === undefined
+      ? ''
+      : palette.dim(`Context being compacted ${formatStatusDuration(renderTime - compacting.startedAt)}`))
     // `${indicator}` owns the caret column and its trailing gap before the
-    // cursor. The phase glyph replaces the `>` caret in place — same width
-    // every frame — fading in as a turn starts, throbbing while it runs, and
-    // fading out after it ends before the plain `>` returns. Only the gray
+    // cursor. The active status glyph replaces the `>` caret in place — same
+    // width every frame — fading in when work starts, throbbing while it runs,
+    // and fading out after it ends before the plain `>` returns. Only the gray
     // brightness changes, so the cursor never shifts.
-    const runningGlyph = runningPhaseGlyph(agent.session.events, runningStatus !== undefined)
+    const statusGlyph = runningPhaseGlyph(
+      agent.session.events,
+      runningStatus !== undefined,
+      compacting !== undefined,
+    )
     // Remember the live phase glyph so the fade-out shows it, not the ttft
     // fallback the derivation returns once the closing turn's step has ended.
-    if (runningStatus !== undefined && runningGlyph !== undefined) runningStatus.lastGlyph = runningGlyph
-    // The fade envelope gates appear/disappear; the running throb breathes the
-    // glyph the whole turn. Truecolor opacity is envelope × throb; the
+    if (runningStatus !== undefined && statusGlyph !== undefined) runningStatus.lastGlyph = statusGlyph
+    // The fade envelope gates appear/disappear; the active throb breathes the
+    // glyph throughout the operation. Truecolor opacity is envelope × throb; the
     // non-truecolor fallback keys visibility off the envelope alone, so the
     // throb never blinks it. `envelope` clamps to [0, 1].
-    const envelope = runningStatus !== undefined && runningGlyph !== undefined
-      ? { glyph: runningGlyph, level: Math.min(1, (now() - runningStatus.startedAt) / STATUS_FADE_MS) }
+    const activeSince = runningStatus?.startedAt ?? compacting?.startedAt
+    const envelope = activeSince !== undefined && statusGlyph !== undefined
+      ? { glyph: statusGlyph, level: Math.min(1, (renderTime - activeSince) / STATUS_FADE_MS) }
       : fadingStatus !== undefined
-        ? { glyph: fadingStatus.glyph, level: Math.max(0, 1 - (now() - fadingStatus.endedAt) / STATUS_FADE_MS) }
+        ? { glyph: fadingStatus.glyph, level: Math.max(0, 1 - (renderTime - fadingStatus.endedAt) / STATUS_FADE_MS) }
         : undefined
     const caret = envelope === undefined
       ? palette.dim('>')
@@ -438,7 +463,7 @@ export function createTuiChat(
         palette,
         resolved.theme.color,
         resolved.theme.color && resolved.theme.truecolor,
-        envelope.level * pulseLevel(now()),
+        envelope.level * pulseLevel(renderTime),
         envelope.level >= 0.5,
       )
     indicatorValue.set(`${caret}${palette.dim(' ')}`)
@@ -453,6 +478,7 @@ export function createTuiChat(
   ui.addChild(new Spacer(1))
   todoContainer.addChild(todo)
   ui.addChild(todoContainer)
+  ui.addChild(compactionStatusLine)
   ui.addChild(promptContext)
   ui.addChild(editor)
   ui.setFocus(editor)
@@ -486,6 +512,9 @@ export function createTuiChat(
 
   const extensionTheme: TuiTheme = Object.freeze({
     text: (value: string) => palette.text(value),
+    brand: (value: string) => resolved.theme.color
+      ? resolved.theme.truecolor ? brandText(value) : palette.brand(value)
+      : value,
     dim: (value: string) => palette.dim(value),
     accent: (value: string) => palette.accent(value),
     success: (value: string) => palette.success(value),
@@ -537,8 +566,8 @@ export function createTuiChat(
     requestRender()
   }
 
-  /** Stop the running and fade-out timers and drop both states at once. */
-  const clearStatus = (): void => {
+  /** Stop the turn-phase running and fade-out timers and drop both states. */
+  const clearTurnStatus = (): void => {
     if (runningStatus !== undefined) {
       clearInterval(runningStatus.timer)
       runningStatus = undefined
@@ -547,21 +576,30 @@ export function createTuiChat(
       clearInterval(fadingStatus.timer)
       fadingStatus = undefined
     }
-    runtime.terminal.setProgress(false)
+    runtime.terminal.setProgress(compacting !== undefined)
+  }
+
+  /** Hard clear: drop every indicator, including a live compaction bracket. */
+  const clearStatus = (): void => {
+    if (compacting !== undefined) {
+      clearInterval(compacting.timer)
+      compacting = undefined
+    }
+    clearTurnStatus()
   }
 
   /**
-   * On the running → non-running edge, hand the last rendered glyph to a
-   * fade-out that re-renders until it settles on the `>` caret, then stops its
-   * own timer. A hard clear (teardown) skips this via {@link clearStatus}.
+   * Hand the last active glyph to a fade-out that re-renders until it settles
+   * on the `>` caret, then stops its own timer. A hard clear (teardown) skips
+   * this via {@link clearStatus}.
    */
   const beginFadeOut = (glyph: string): void => {
-    clearStatus()
+    clearTurnStatus()
     const fading: FadingStatus = {
       glyph,
       endedAt: now(),
       timer: setInterval(() => {
-        if (now() - fading.endedAt >= STATUS_FADE_MS) clearStatus()
+        if (now() - fading.endedAt >= STATUS_FADE_MS) clearTurnStatus()
         renderStatus()
       }, STATUS_ANIMATION_INTERVAL_MS),
     }
@@ -571,9 +609,9 @@ export function createTuiChat(
   const setStatus = (status: AgentStatus): void => {
     const priorTurn = runningStatus?.turn
     const fadeOutGlyph = status !== 'running' ? runningStatus?.lastGlyph : undefined
-    if (status === 'running') clearStatus()
+    if (status === 'running') clearTurnStatus()
     else if (fadeOutGlyph !== undefined) beginFadeOut(fadeOutGlyph)
-    else clearStatus()
+    else clearTurnStatus()
     editor.borderColor = status === 'running' ? text => palette.accent(text) : text => palette.dim(text)
     editor.hint = status === 'running' ? palette.dim(displayInlineText(resolved.theme.inputPlaceholder)) : undefined
     if (status === 'running') {
@@ -615,6 +653,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]) {
@@ -622,6 +689,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)
   }
 
   /**
@@ -660,6 +736,7 @@ export function createTuiChat(
       palette,
       mdTheme,
     )
+    registerAssistantStep(streaming)
     chat.addChild(streaming)
     chat.addChild(streaming.timing)
   }
@@ -723,12 +800,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()
@@ -847,6 +934,7 @@ export function createTuiChat(
     toolCards.clear()
     allToolCards.clear()
     contextCards.clear()
+    assistantSteps.clear()
     streaming = undefined
     todo.update([])
     const transcriptCalls = transcriptToolCallIds(agent.session)
@@ -956,32 +1044,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}`
@@ -1167,6 +1322,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',
@@ -1506,7 +1667,32 @@ 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) {
+        const startedAt = now()
+        compacting = {
+          startedAt,
+          timer: setInterval(renderStatus, STATUS_ANIMATION_INTERVAL_MS),
+        }
+        runtime.terminal.setProgress(true)
+      }
+      requestRender()
+      return
+    }
+    if (event.type === 'compact/end' && event.data.turn === null && compacting !== undefined) {
+      const fadeOutGlyph = runningPhaseGlyph(agent.session.events, false, true)
+      clearInterval(compacting.timer)
+      compacting = undefined
+      if (event.data.error !== undefined) {
+        appendNotice(`Compaction failed: ${event.data.error}`, 'warning')
+      }
+      // A concurrently running turn owns the indicator. Keep its timer and
+      // progress bit instead of letting the compaction fade clear that state.
+      if (runningStatus === undefined && fadeOutGlyph !== undefined) beginFadeOut(fadeOutGlyph)
+      requestRender()
+      return
+    }
     // A replacement mutates only the model surface, so the rendered transcript
     // keeps what it already showed; a landed summary checkpoint adds its marker.
     if (isReplacementSurfaceEvent(event)) {
@@ -1550,6 +1736,9 @@ export function createTuiChat(
     // TUI stays mounted. Retained agents accept deliveries after detachment, so
     // without this a later send would drive a zombie agent/session; mark
     // disposed so dispatchMessage reports it instead.
+    // The hard clear also retires live compaction. A later compact/end is
+    // intentionally presentation-silent: this disposal notice owns the
+    // terminal outcome, and no animation may survive agent detachment.
     clearStatus()
     appendNotice(`Agent "${agent.id}" was disposed.`, 'warning')
     disposed = true
@@ -1572,6 +1761,7 @@ export function createTuiChat(
     disposeAgent()
     disposeSchemeListener()
     disposeTargetListeners()
+    modelController.detach()
   }
 
   // Sweep reveal of the whole banner: the header wipes in left-to-right over
@@ -1637,11 +1827,11 @@ export function createTuiChat(
   })
   startBannerReveal()
 
-  // A launcher-seeded first turn (`dsh migrate`/`dsh upgrade`): invoke the
-  // named skill exactly as a typed `/skill:<name>` would, once the chat is live
-  // and the agent is idle. The launcher sets this only for a fresh session, so
-  // there is no prior turn to collide with; invokeSkill reports an unknown skill
-  // as a notice.
+  // A launcher-seeded first turn (`dsh migrate`/`dsh upgrade`):
+  // invoke the named skill exactly as a typed `/skill:<name>` would, once the
+  // chat is live and the agent is idle. The launcher sets this only for a fresh
+  // session, so there is no prior turn to collide with; invokeSkill reports an
+  // unknown skill as a notice.
   if (config.initialSkill !== undefined) invokeSkill(config.initialSkill, '')
 
   return {