Merge remote-tracking branch 'origin/master' into worktree/fix-multi-select-custom-answer

# Conflicts:
#	apps/web/tests/snapshots/question-composer/answered.expected.md
#	apps/web/tests/snapshots/question-composer/session.jsonl
#	docs/core-data-structures/user-interaction.i18n.yaml
#	packages/client/ui-question/README.i18n.yaml
#	packages/host/apiproxy/README.i18n.yaml
#	packages/host/apiproxy/README.md
#	packages/host/apiproxy/README.zh.md
#	packages/ui/tui/README.i18n.yaml
#	packages/ui/user-interaction/README.i18n.yaml

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

@@ -1,6 +1,6 @@
 /**
  * Zero-state helpers for the interactive chat channel: prompt-directory and
- * Git-branch formatting, surface/tool-call derivations over the session log,
+ * Git-branch formatting, transcript/tool-call derivations over the session log,
  * session-reference context cards, the placeholder editor, and banner-reveal
  * timing constants. None of these close over channel state.
  * @module @deepseek-ai/dsh-tui/chat/helpers
@@ -15,7 +15,9 @@ import {
   truncateToWidth,
   visibleWidth,
 } from '@earendil-works/pi-tui'
-import type { Session } from '@deepseek-ai/dsh-session'
+import { isCompactCheckpointSource } from '@deepseek-ai/dsh-compact'
+import { isAppendSurfaceEvent, isReplacementSurfaceEvent } from '@deepseek-ai/dsh-session'
+import type { Session, SessionEvent } from '@deepseek-ai/dsh-session'
 import { scrubbedParentEnv } from '@deepseek-ai/dsh-subprocess'
 
 /** Editor that shows a placeholder without making it editable content. */
@@ -81,24 +83,16 @@ export function gitBranch(cwd: string): string | undefined {
 }
 
 /**
- * Sequence numbers currently visible on the session surface.
- * @param session - session whose surface nodes to read.
- * @returns the set of visible event sequence numbers.
- */
-export function activeSurfaceSeqs(session: Session): Set<number> {
-  return new Set(session.surface.nodes)
-}
-
-/**
- * Tool-call ids whose owning assistant message is on the active surface.
+ * Tool-call ids whose owning assistant message is append-origin, so its tool
+ * cards stay paired in the transcript after a replacement shadowed the message
+ * on the model surface.
  * @param session - session whose events to scan.
- * @param active - sequence numbers currently on the surface.
- * @returns the set of active tool-call ids.
+ * @returns the set of transcript tool-call ids.
  */
-export function activeToolCallIds(session: Session, active: ReadonlySet<number>): Set<string> {
+export function transcriptToolCallIds(session: Session): Set<string> {
   const ids = new Set<string>()
   for (const event of session.events) {
-    if (event.type !== 'assistant/message' || !active.has(event.seq)) continue
+    if (event.type !== 'assistant/message' || !isAppendSurfaceEvent(event)) continue
     for (const block of event.data.message.content) {
       if (block.type === 'tool-call') ids.add(block.id)
     }
@@ -106,6 +100,26 @@ export function activeToolCallIds(session: Session, active: ReadonlySet<number>)
   return ids
 }
 
+/**
+ * Whether an event is a landed compaction checkpoint. Recognition goes through
+ * {@link isCompactCheckpointSource} — the compaction seam's backend-independent
+ * contract for the source every backend stamps on its replacement user message —
+ * rather than the shape of the replacement. Other replacements (a pruned
+ * `tool/result`, a regenerated `assistant/message`) rewrite one node for the
+ * model and mark no boundary in the conversation.
+ *
+ * Both current call sites already test the replacement themselves. The check
+ * keeps the exported predicate true to its name for a third caller, rather than
+ * making that caller repeat it.
+ * @param event - event to test.
+ * @returns true when the event compacted a surface range.
+ */
+export function isCompactCheckpoint(event: SessionEvent): boolean {
+  return event.type === 'user/message'
+    && isCompactCheckpointSource(event.data.source)
+    && isReplacementSurfaceEvent(event)
+}
+
 /**
  * Read a session-reference context card's display labels from an event source.
  * @param source - event source to inspect.

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

@@ -52,15 +52,28 @@ function pretty(value: unknown): string {
   return displayText(serialized ?? String(value))
 }
 
+/**
+ * A side's content lines under the terminator rule the Web DiffBlock also
+ * applies: empty text is zero lines (a full deletion's `newText`, a create's
+ * absent `oldText`), and a single trailing newline terminates the last line
+ * rather than adding an empty one. An interior blank line survives. Keeping the
+ * two front ends on the same rule holds their `+A -R` footers in step.
+ */
+function diffContentLines(text: string): string[] {
+  if (text === '') return []
+  const body = text.endsWith('\n') ? text.slice(0, -1) : text
+  return body.split('\n')
+}
+
 /** A file diff as colored `+`/`-` lines, optionally prefixed with its path. */
 function diffLines(diff: FileDiff, palette: Palette): string[] {
   // The card header is a fixed `Tool / <name>` frame that never names a file, so
   // each hunk always carries its own path header (no redundancy to suppress).
   const lines = [palette.bold(displayText(diff.path))]
   if (diff.oldText !== null) {
-    for (const line of displayText(diff.oldText).split('\n')) lines.push(palette.error(`- ${line}`))
+    for (const line of diffContentLines(displayText(diff.oldText))) lines.push(palette.error(`- ${line}`))
   }
-  for (const line of displayText(diff.newText).split('\n')) lines.push(palette.success(`+ ${line}`))
+  for (const line of diffContentLines(displayText(diff.newText))) lines.push(palette.success(`+ ${line}`))
   return lines
 }
 
@@ -389,10 +402,29 @@ export class ToolCardComponent implements Component {
     const glyph = this.result === undefined ? '○' : '●'
     const rawBody = this.renderBody()
     const view = this.resultView ?? this.callView
-    const genericContent = view.card === 'generic' ? view.content ?? this.result?.content : undefined
-    const unknownXml = this.definition === undefined && genericContent !== undefined
+    // 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 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 === 'search'
+        ? 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 */
+          ? this.result?.content
+          : undefined
+    const unknownXml = this.definition === undefined && markdownContent !== undefined
       ? renderUnknownXml(
-        displayText(contentText(genericContent)),
+        displayText(contentText(markdownContent)),
         this.maxOutputLines,
         this.visibility === 'expanded',
         displayText,
@@ -405,7 +437,7 @@ export class ToolCardComponent implements Component {
     // A generic card renders title and result as one Markdown document, so the
     // document's own block spacing is preserved, then dims every row — the whole
     // card body reads as one dim block under the status-colored header.
-    const body = unknownXml ?? (genericContent !== undefined && rawBody.lines.length > 0
+    const body = unknownXml ?? (markdownContent !== undefined && rawBody.lines.length > 0
       ? this.dimBody(rawBody, width)
       : [...rawBody.prelude, ...rawBody.lines])
     const visibleBody = unknownXml !== undefined || this.visibility === 'expanded'
@@ -488,21 +520,31 @@ export class ToolCardComponent implements Component {
     }
     if (view.card === 'diff') {
       // The header no longer names the file, so each diff keeps its own path
-      // header. A trailing footer summarizes the change (`+A -R · N file(s)`).
+      // header. A trailing footer summarizes the change (`+A -R · N file(s)`),
+      // on the same terminator rule and distinct-path count the Web DiffBlock
+      // uses, so the two front ends' footers agree.
       let added = 0
       let removed = 0
+      const paths = new Set<string>()
       const hunks = view.diffs.flatMap((diff, index) => {
-        if (diff.oldText !== null) removed += displayText(diff.oldText).split('\n').length
-        added += displayText(diff.newText).split('\n').length
+        paths.add(diff.path)
+        if (diff.oldText !== null) removed += diffContentLines(displayText(diff.oldText)).length
+        added += diffContentLines(displayText(diff.newText)).length
         return [...index > 0 ? [''] : [], ...diffLines(diff, this.palette)]
       })
-      const files = view.diffs.length
+      const files = paths.size
       const footer = this.palette.dim(`└ +${added} -${removed} · ${files} file${files === 1 ? '' : 's'}`)
       // A diff's own `+`/`-` colors carry its meaning, so it renders verbatim
       // rather than under the dim result-output color.
       return { prelude: [...hunks, footer], lines: [] }
     }
-    const content = view.content ?? this.result?.content
+    // 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[] = []
     // The presenter title headlines the body now that the header is a fixed

packages/ui/tui/src/config.ts

@@ -122,8 +122,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
 }

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

@@ -35,6 +35,7 @@ import type { ContentBlock, MessageId } from '@deepseek-ai/dsh-llm'
 import type {} from '@deepseek-ai/dsh-llm-retry'
 import { renderPrompt } from '@deepseek-ai/dsh-system-prompt'
 import {
+  isReplacementSurfaceEvent,
   lastActivityTime,
   SessionId,
   type SessionEvent,
@@ -68,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,
@@ -79,6 +80,7 @@ import {
 import {
   fadeGlyph,
   formatQueuedStatus,
+  formatStatusDuration,
   openStepPhase,
   openTurn,
   pulseLevel,
@@ -120,14 +122,14 @@ import {
 } from './chat/skill-invocation.ts'
 import { ReferenceAutocompleteProvider } from './chat/autocomplete.ts'
 import {
-  activeSurfaceSeqs,
-  activeToolCallIds,
   BANNER_REVEAL_INTERVAL_MS,
   BANNER_REVEAL_STEPS,
   formatCwd,
   gitBranch,
   HintEditor,
+  isCompactCheckpoint,
   sessionReferenceCard,
+  transcriptToolCallIds,
 } from './chat/helpers.ts'
 import {
   createModelController,
@@ -225,9 +227,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'
 
@@ -261,6 +263,13 @@ export const inject = ['agents', 'sessions', 'commands', 'userInteraction', 'too
 /** Model guidance for path-only file references selected through the TUI. */
 export const FILE_REFERENCE_PROMPT = 'Paths prefixed with @ are files explicitly referenced by the user. Use the read tool when their contents are needed; do not claim to have inspected a file before reading it.'
 
+/**
+ * Transcript row standing in for one compacted range. The conversation the
+ * compaction replaced stays rendered above it: the marker reports where the
+ * model stopped seeing that history, not that the history is gone.
+ */
+const COMPACTION_MARKER = '… earlier context was compacted …'
+
 interface RunningStatus {
   turn: number | undefined
   timer: ReturnType<typeof setInterval>
@@ -321,6 +330,7 @@ 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.
@@ -329,6 +339,14 @@ export function createTuiChat(
   let completedStreaming: StreamingAssistantComponent | undefined
   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.
@@ -392,6 +410,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)
@@ -405,23 +424,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('>')
@@ -430,7 +457,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(' ')}`)
@@ -445,6 +472,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)
@@ -478,6 +506,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),
@@ -529,8 +560,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
@@ -539,21 +570,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),
     }
@@ -563,9 +603,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') {
@@ -808,6 +848,23 @@ export function createTuiChat(
     }
   }
 
+  const renderCompactionMarker = (): void => {
+    chat.addChild(new Spacer(1))
+    chat.addChild(new Text(palette.dim(COMPACTION_MARKER), 0, 0))
+  }
+
+  /**
+   * Replay the human transcript from the append-only log. The model-visible
+   * surface shadows compacted ranges, so it is not the source here: every
+   * append-origin message stays rendered, and a replacement contributes at most
+   * the compaction marker at its own log position.
+   *
+   * The `tool/call` pairing check has no live counterpart, because only replay
+   * can meet an orphan: `tool/call` carries no `surfaceOp` of its own, so it
+   * inherits transcript membership from the `assistant/message` that advertised
+   * it, which the live listener has necessarily just rendered. A loaded log is a
+   * replay boundary, so the pairing is re-derived here instead of assumed.
+   */
   const rebuildTranscript = (populateHistory: boolean): void => {
     chat.clear()
     toolCards.clear()
@@ -815,15 +872,13 @@ export function createTuiChat(
     contextCards.clear()
     streaming = undefined
     todo.update([])
-    const active = activeSurfaceSeqs(agent.session)
-    const activeCalls = activeToolCallIds(agent.session, active)
+    const transcriptCalls = transcriptToolCallIds(agent.session)
     for (const event of agent.session.events) {
-      const isSurface = event.type === 'user/message'
-        || event.type === 'assistant/message'
-        || event.type === 'tool/result'
-        || event.type === 'steering/message'
-      if (isSurface && !active.has(event.seq)) continue
-      if (event.type === 'tool/call' && !activeCalls.has(event.data.callId)) continue
+      if (isReplacementSurfaceEvent(event)) {
+        if (isCompactCheckpoint(event)) renderCompactionMarker()
+        continue
+      }
+      if (event.type === 'tool/call' && !transcriptCalls.has(event.data.callId)) continue
       renderEvent(event, { addHistory: populateHistory, renderChunks: false })
     }
     requestRender()
@@ -1475,8 +1530,37 @@ export function createTuiChat(
     recordEventUsage(tokens, event)
     if (event.type === 'turn/start' && runningStatus !== undefined) runningStatus.turn = event.data.turn
     if (event.type === 'assistant/message' && streaming?.isSettled()) streaming = undefined
-    if ('surfaceOp' in event && typeof event.surfaceOp === 'object') {
-      rebuildTranscript(false)
+    // 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)) {
+      if (isCompactCheckpoint(event)) renderCompactionMarker()
+      requestRender()
       return
     }
     renderEvent(event, { addHistory: false, renderChunks: true })
@@ -1515,6 +1599,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
@@ -1537,6 +1624,7 @@ export function createTuiChat(
     disposeAgent()
     disposeSchemeListener()
     disposeTargetListeners()
+    modelController.detach()
   }
 
   // Sweep reveal of the whole banner: the header wipes in left-to-right over
@@ -1602,11 +1690,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 {