dsh-code 1.2.0 → 1.3.0

package/src/app.ts

@@ -45,10 +45,10 @@ import { parseRainbowArgument, rainbowRoll, rainbowSeedLabel, rerollRainbow } fr
 import { ThemePanel } from './theme-panel.ts'
 import { LanguagePanel } from './language-panel.ts'
 import { getLanguage, parseLanguageName, t, type LanguageName, type MessageKey } from './i18n.ts'
-import { UpdatePanel } from './update-panel.ts'
+import { UpdatePanel, subscribeUpdateApplyRunning } from './update-panel.ts'
 import type { LauncherUpdateStatus } from './update.ts'
 import { WHALE_GLYPH, WHALE_GLYPH_COLUMNS } from './whale-glyph.ts'
-import { DSH_CODE_VERSION, dshKernelVersion } from './version.ts'
+import { dshKernelVersion, headerBrandTitle } from './version.ts'
 import type { TranscriptStore } from './store.ts'
 import { DEFAULT_TERMINAL_TITLE, sanitizeTerminalTitle, terminalTitleSequence, useTerminalTitle } from './terminal-title.ts'
 import { settledEntryCount, type TranscriptEntry } from './render/projection.ts'
@@ -112,6 +112,7 @@ import {
   recallOlder,
   recordLocalEntry,
   type RecallState,
+  appendRecall,
 } from './history.ts'
 import type { SessionDirectoryOptions, SessionRow } from './session-directory.ts'
 import { parseReviewArgument, type GitDiffView, type ReviewBranch, type ReviewCommit, type ReviewSelection } from './git-workflow.ts'
@@ -125,6 +126,7 @@ import { ProviderAuthorizationLogoutPanel, ProviderAuthorizationPanel } from './
 import {
   looksLikeImagePath,
   parsePastedAttachmentPaths,
+  looksLikePathDraft,
   type FilePathInspection,
   type ImagePathInspection,
 } from './attachments.ts'
@@ -158,6 +160,12 @@ function readSettledRowCap(): number {
 
 /** Reset region/style, clear the visible screen and scrollback, then home. */
 const RESIZE_REFLOW_CLEAR = '\x1b[r\x1b[0m\x1b[H\x1b[2J\x1b[3J\x1b[H'
+/**
+ * Same as {@link RESIZE_REFLOW_CLEAR} without wiping native scrollback.
+ * History-cap trims remount `<Static>` but must not `\x1b[3J` a user who is
+ * reading earlier messages above the fold.
+ */
+const TRIM_REFLOW_CLEAR = '\x1b[r\x1b[0m\x1b[H\x1b[2J\x1b[H'
 /** Ask terminals supporting DEC synchronized updates to hold the frame. */
 const SYNCHRONIZED_UPDATE_BEGIN = '\x1b[?2026h'
 /** Release the held frame after Ink has replayed the source-backed Static rows. */
@@ -285,6 +293,22 @@ const LOCAL_COMMANDS: readonly LocalCommand[] = [
 
 const LOCAL_COMMAND_NAMES = new Set(LOCAL_COMMANDS.map(command => command.label.slice(1)))
 
+/**
+ * TUI-local commands that take no input. Extra tokens used to fall through
+ * as a prompt (`/queue clear` reached the model); they now surface usage.
+ */
+const BARE_LOCAL_COMMANDS = new Set([
+  'quit', 'help', 'clear', 'copy', 'update', 'schedule', 'statusline', 'theme',
+  'history', 'queue', 'usage', 'agents', 'todos', 'subagent',
+])
+
+/** Split a slash line into the command name and any trailing input. */
+function slashNameAndArgs(text: string): { readonly name: string; readonly args: string } | undefined {
+  const match = /^\/([a-z][a-z0-9_-]*)(?:$|[\t ](.*))$/u.exec(text)
+  if (match === null || match[1] === undefined) return undefined
+  return { name: match[1], args: (match[2] ?? '').trim() }
+}
+
 /** One mutation the terminal may request for a pending next-turn inbox item. */
 export type QueueMutation =
   | { readonly kind: 'remove' }
@@ -621,27 +645,33 @@ function DeepDivingLine({ since, animated = true }: { since: number; animated?:
  * cap counts explicit newlines and terminal wrapping, slicing from the END so
  * the freshest tokens stay visible while a long reply streams; the complete
  * text lands in the flushed scrollback once the turn assembles it.
+ *
+ * Body wrap width for a streaming tail. `rowColumns` is the same width
+ * passed to `transcriptEntryLines` (terminal minus the last-column safety);
+ * the hanging prefix then shrinks the body so streamed text and settled
+ * markdown wrap on the same column.
  */
-function StreamTail({ text, dim, maxRows, prefix = '', continuationPrefix = prefix, children }: {
+export function streamTailBodyColumns(rowColumns: number, prefix: string, continuationPrefix = prefix): number {
+  const width = Math.max(1, Math.floor(rowColumns))
+  const prefixColumns = Math.max(visibleColumns(prefix), visibleColumns(continuationPrefix))
+  return Math.max(1, width - prefixColumns)
+}
+
+function StreamTail({ text, dim, maxRows, prefix = '', continuationPrefix = prefix, children, columns }: {
   text: string
   dim: boolean
   maxRows: number
   prefix?: string
   continuationPrefix?: string
   children?: ReactElement
+  /** Same physical row width `transcriptEntryLines` uses (terminal minus 2). */
+  columns: number
 }): ReactElement {
-  const columns = useStdout().stdout?.columns ?? 80
   const safeRows = Math.max(1, maxRows)
-  // The final extra column keeps a caret from wrapping onto an unbudgeted
-  // row. Both prefixes participate because every physical row repeats its
-  // hanging indent.
-  const prefixColumns = Math.max(visibleColumns(prefix), visibleColumns(continuationPrefix))
-  // Content takes the full physical row minus prefixes and the final wrap
-  // column — a forced 10-column FLOOR on a narrower terminal made every row
-  // autowrap onto a second, unbudgeted row (the live budget then
-  // under-counted and the tree overflowed), so the width now shrinks with
-  // the real terminal instead of flooring at 10.
-  const contentColumns = Math.max(1, columns - 1 - prefixColumns)
+  // Both prefixes participate because every physical row repeats its hanging
+  // indent. The wrap matches settled markdown (row width minus prefix), so
+  // the flush at turn end does not reflow the last paragraph.
+  const contentColumns = streamTailBodyColumns(columns, prefix, continuationPrefix)
   const initial = displayTail(text, contentColumns, safeRows)
   // Reserve one row for the omission marker only when a marker is needed.
   const tail = initial.truncated && safeRows > 1
@@ -865,9 +895,9 @@ function Header({ resumed }: { resumed: boolean }): ReactElement {
     const version = dshKernelVersion()
     return version === undefined ? undefined : `dsh-v${version}`
   })()
-  const title = `DeepSeek Harness · v${DSH_CODE_VERSION}`
+  const title = headerBrandTitle()
   const slogan = 'Into the Unknown  探索未至之境'
-  const hint = resumed ? 'resumed · /help · Esc interrupt' : '/help · Esc interrupt · Ctrl+C quit'
+  const hint = resumed ? t('header.hintResumed') : t('header.hint')
   const copyWidths = [visibleColumns(title), visibleColumns(slogan), visibleColumns(hint)]
   if (kernelLine !== undefined) copyWidths.push(visibleColumns(kernelLine))
   const copyColumns = Math.max(...copyWidths)
@@ -1301,25 +1331,19 @@ function StatusLine({ facts, stats, busy, columns, items, onRows, animated }: {
   const flowTick = useFrames(BUSY_CHASE_TICK_MS, flowActive)
   const flowMs = flowActive ? flowTick * BUSY_CHASE_TICK_MS + (flow?.phaseMs ?? 0) : undefined
   const language = getLanguage()
-  const layout = useMemo(() => layoutStatusBar(facts, stats, Math.max(8, columns - 2), {
-    busy,
-    items,
-    // Match the composer content budget: border + horizontal padding are
-    // already excluded, and layoutStatusBar shrinks this ceiling as needed.
-    contextWidth: Math.max(5, columns - 6),
-  }), [
-    facts.model,
-    facts.mode,
-    facts.cwd,
-    facts.branch,
-    facts.sessionId,
-    facts.title,
-    facts.sandbox,
-    facts.plan,
-    facts.permission,
-    facts.goal?.phase,
-    facts.goal?.rounds,
-    facts.goal?.max,
+  const layout = useMemo(() => {
+    // The layout reads translations through t(); naming the current language
+    // here makes that external store value an explicit cache invalidator.
+    void language
+    return layoutStatusBar(facts, stats, Math.max(8, columns - 2), {
+      busy,
+      items,
+      // Match the composer content budget: border + horizontal padding are
+      // already excluded, and layoutStatusBar shrinks this ceiling as needed.
+      contextWidth: Math.max(5, columns - 6),
+    })
+  }, [
+    facts,
     stats,
     busy,
     columns,
@@ -1640,7 +1664,7 @@ function QuestionBar({ store, snapshot, locked }: { store: QuestionStore; snapsh
   }, [request])
 
   const question = pending?.request.questions[index]
-  const options = question?.options ?? []
+  const options = useMemo(() => question?.options ?? [], [question])
   const isPlan = question?.intent?.kind === 'plan-review'
   const isMulti = question?.multiSelect === true
   const currentDraft = drafts[index] ?? initialQuestionDraft(question)
@@ -1976,7 +2000,7 @@ function ModelPanel({ directory, error, current, onSelect, onProviders, onRetry,
   const [cursor, setCursor] = useState(0)
   const stdout = useStdout().stdout
   const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30)
-  const rows = directory?.rows ?? []
+  const rows = useMemo(() => directory?.rows ?? [], [directory])
   // Direct-typing filter over provider and model names (the /mode contract):
   // printable keys edit the query, so a long directory is searchable without
   // a separate search mode. With a query active, q/r/g/G stop acting as
@@ -3327,10 +3351,13 @@ function entryKindLabel(entry: TranscriptEntry | undefined): string {
  * retained entry is converted to physical rows, but only one viewport slice
  * reaches Ink, so even a huge reasoning block cannot grow the dynamic tree.
  */
-function VerbosePanel({ entries, onClose }: { entries: readonly TranscriptEntry[]; onClose: () => void }): ReactElement {
-  const stdout = useStdout().stdout
-  const columns = stdout?.columns ?? 80
-  const rows = stdout?.rows ?? 30
+function VerbosePanel({ entries, onClose, columns, rows }: {
+  entries: readonly TranscriptEntry[]
+  onClose: () => void
+  /** Live terminal columns from App's resize store — not useStdout, so memo cannot skip a reflow. */
+  columns: number
+  rows: number
+}): ReactElement {
   const viewport = inspectorViewport(columns, rows)
   const [cursor, setCursor] = useState(() => Math.max(0, entries.length - 1))
   const [scroll, setScroll] = useState(0)
@@ -3343,6 +3370,8 @@ function VerbosePanel({ entries, onClose }: { entries: readonly TranscriptEntry[
     [entry, viewport.contentColumns],
   )
   const visibleScroll = clampScroll(scroll, allLines.length, viewport.bodyRows)
+  const visibleScrollRef = useRef(visibleScroll)
+  visibleScrollRef.current = visibleScroll
 
   useEffect(() => {
     cursorRef.current = cursor
@@ -3352,7 +3381,7 @@ function VerbosePanel({ entries, onClose }: { entries: readonly TranscriptEntry[
     const current = cursorRef.current
     const next = followInspectorCursor(current, previousLength.current, entries.length)
     if (next !== current) {
-      savedScroll.current.set(current, visibleScroll)
+      savedScroll.current.set(current, visibleScrollRef.current)
       setCursor(next)
       setScroll(savedScroll.current.get(next) ?? 0)
     }
@@ -3485,6 +3514,16 @@ interface CompletionCandidate {
   origin: 'command' | 'skill' | 'mention'
 }
 
+/**
+ * Wrap one completion-menu cursor step. An empty menu keeps the index at 0:
+ * `% 0` is NaN, and a NaN index silently disables the highlight, the accept
+ * key, and any later Enter that runs through the menu.
+ */
+export function stepCompletionIndex(index: number, delta: number, count: number): number {
+  if (count <= 0) return 0
+  return ((index + delta) % count + count) % count
+}
+
 /**
  * Resolve completion candidates for the current input: TUI-local commands,
  * the live registry descriptors, and user-invocable skills, filtered by the
@@ -3700,7 +3739,7 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
   /** Open the /todos subpage (full todo list in one bounded panel). */
   openTodos: () => void
   openUsage: () => void
-  /** Open the /resume picker in delete mode, optionally pre-armed on one id. */
+  /** Open the dedicated /delete picker, optionally pre-armed on one id. */
   openDelete: (id?: string) => void
   openDiff: (argument: string) => void
   reviewChanges: (selection: ReviewSelection) => void
@@ -3828,27 +3867,28 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
     preferredColumnRef.current = null
   }, [editorColumns])
 
-  // A /history panel acceptance lands as a fill: place the sanitized text at
-  // the end of the composer and resume recall from that entry.
+  // A /history panel acceptance lands as a fill: append the sanitized text to
+  // the composer and resume recall from that entry. Appending (never
+  // replacing) is what keeps a half-written draft and its prepared
+  // attachments from being destroyed by picking a history entry.
   useEffect(() => {
     if (historyFill === undefined) return
     const safe = sanitizeDraftText(historyFill.text)
-    draftImagesRef.current = []
-    setDraftImages([])
-    draftFilesRef.current = []
-    setDraftFiles([])
-    valueRef.current = safe
-    cursorRef.current = safe.length
-    setValue(safe)
-    setCursor(safe.length)
+    const current = valueRef.current
+    const joined = appendRecall(current, safe)
+    valueRef.current = joined
+    cursorRef.current = joined.length
+    setValue(joined)
+    setCursor(joined.length)
     resetCursorBlink()
     preferredColumnRef.current = null
     setDismissedMenuValue(undefined)
     recall.current = {
       entries: recallSpace,
       index: historyFill.index,
-      savedDraft: safe,
-      lastRecalled: safe,
+      // The draft this fill appended to stays reachable: Down walks back to it.
+      savedDraft: current,
+      lastRecalled: joined,
     }
     historyConsumed()
   }, [historyFill, recallSpace, historyConsumed, resetCursorBlink])
@@ -3905,7 +3945,7 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
     return () => {
       stdin.read = originalRead
     }
-  }, [focusReporting, stdin])
+  }, [focusReporting, inputStdout, stdin])
 
   // Keep the navigation's recall space fresh while browsing state survives
   // (new local submissions extend the space; the index stays valid unless
@@ -3919,7 +3959,7 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
   const [completionIndex, setCompletionIndex] = useState(0)
   const [dismissedMenuValue, setDismissedMenuValue] = useState<string | undefined>(undefined)
   const candidates = completionCandidates(value, descriptors, skills)
-  const slashActive = candidates.length > 0 && value.startsWith('/') && !value.includes(' ') && !value.includes('\n')
+  const slashActive = candidates.length > 0 && value.startsWith('/') && !value.includes(' ') && !value.includes('\n') && !looksLikePathDraft(value)
 
   // @mention token: the last `@word` on the cursor's line before the cursor.
   const beforeCursor = value.slice(0, cursor)
@@ -4035,8 +4075,8 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
     const requestId = mentionRequestRef.current + 1
     mentionRequestRef.current = requestId
     if (!active || !mentionActive) {
-      setMentionRows([])
-      setMentionError(undefined)
+      setMentionRows(current => current.length === 0 ? current : [])
+      setMentionError(current => current === undefined ? current : undefined)
       return
     }
     setMentionError(undefined)
@@ -4059,7 +4099,7 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
       clearTimeout(timer)
       controller.abort()
     }
-  }, [active, mentionActive, mentionToken?.query])
+  }, [active, loadMentions, mentionActive, mentionToken?.query])
 
   // Codex routes keys to the topmost surface first. Completion therefore
   // remains available while a turn runs, and Esc dismisses it before the
@@ -4095,6 +4135,23 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
   // the App's dynamic budget can reserve it instead of overflowing.
   const menuHeightRows = menuActive ? completionMenuRowCount(inputTerminalRows, menuRows.length) : 0
 
+  /**
+   * What accepting the highlighted completion candidate would insert, or ''
+   * when nothing can be accepted (no rows, or an image row that resolves
+   * asynchronously). The Enter branch uses it to tell a real accept from a
+   * no-op that must fall through to submission.
+   */
+  const highlightedCompletion = (): string => {
+    if (mentionActive) {
+      const row = rankedMentionRows[completionIndex % Math.max(1, rankedMentionRows.length)]
+      if (row === undefined) return ''
+      if (row.kind === 'file' && row.path !== undefined && looksLikeImagePath(row.path)) return ''
+      return row.label.startsWith('@') ? row.label : `@${row.label}${row.kind === 'directory' ? '/' : ''}`
+    }
+    const candidate = candidates[completionIndex % Math.max(1, candidates.length)]
+    return candidate === undefined ? '' : `${candidate.label} `
+  }
+
   /** Accept the highlighted completion-menu candidate into the draft. */
   const acceptMenuCandidate = (): void => {
     if (mentionActive && mentionToken !== undefined) {
@@ -4184,6 +4241,18 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
     preferredColumnRef.current = null
     setCompletionIndex(0)
     setDismissedMenuValue(undefined)
+    // A file drag (any OS / terminal) often writes the path without
+    // bracketed-paste wrappers, so it lands as ordinary insert. If the whole
+    // draft is one drop path, attach it the same way a copied pathname paste
+    // would.
+    const dropped = parsePastedAttachmentPaths(edit.value)
+    if (dropped.images.length > 0 || dropped.files.length > 0) {
+      valueRef.current = ''
+      cursorRef.current = 0
+      setValue('')
+      setCursor(0)
+      insertDroppedAttachments(dropped.images, dropped.files)
+    }
   }
 
   /** Move the cursor without editing; horizontal moves clear the column preference. */
@@ -4415,8 +4484,19 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
       // exactly, in which case Enter submits it (typing a full "/effort" and
       // pressing return must run the command, not re-accept its own text).
       if (menuActive) {
+        // Accepting can be a no-op: the menu is open with no matches yet, the
+        // slash line already spells its candidate, or a mention insertion
+        // repeats the token already in the draft. Enter must reach the submit
+        // path in every one of those cases, or the message cannot be sent.
+        const highlighted = highlightedCompletion()
+        const repeatsToken = mentionActive && mentionToken !== undefined && cursor === liveValue.length
+          && liveValue.slice(mentionToken.start, cursor) === highlighted
+        // The slash rule is a whole-list exact match, not a highlighted-row
+        // comparison: typing `/mode` once the list is open must run the
+        // command even when the highlight happens to rest on `/model`.
         const exactSlash = !mentionActive && candidates.some(candidate => candidate.label === liveValue)
-        if (!exactSlash) {
+        const acceptNoop = highlighted === '' || repeatsToken || exactSlash
+        if (!acceptNoop) {
           acceptMenuCandidate()
           return
         }
@@ -4530,7 +4610,7 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
       if (text === '/copy') {
         void copyLastResponse().then(
           outcome => notify(outcome),
-          error => notify(`copy failed: ${error instanceof Error ? error.message : String(error)}`, 'error'),
+          error => notify(t('notice.copyFailed', { message: error instanceof Error ? error.message : String(error) }), 'error'),
         )
         return
       }
@@ -4677,6 +4757,11 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
         openDelete(text.slice(7).trim())
         return
       }
+      const slash = slashNameAndArgs(text)
+      if (slash !== undefined && BARE_LOCAL_COMMANDS.has(slash.name) && slash.args !== '') {
+        notify(t('notice.usage.bareCommand', { name: slash.name }), 'warning')
+        return
+      }
       // Delivery mode: everything above this point is a local command or a
       // panel opener and always runs out of band. A real prompt follows the
       // composer's Tab choice — `steer` joins the running turn, the default
@@ -4706,11 +4791,11 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
       return
     }
     if (menuActive && key.upArrow) {
-      setCompletionIndex(index => (index + menuRows.length - 1) % menuRows.length)
+      setCompletionIndex(index => stepCompletionIndex(index, -1, menuRows.length))
       return
     }
     if (menuActive && key.downArrow) {
-      setCompletionIndex(index => (index + 1) % menuRows.length)
+      setCompletionIndex(index => stepCompletionIndex(index, 1, menuRows.length))
       return
     }
     // Batched Home/End/Delete/Backspace sequences bypass Ink's one-key parser
@@ -4803,10 +4888,13 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
       return
     }
     if (input !== '' && !key.ctrl && !key.meta) {
-      // Bracketed-paste wrappers arrive as unknown escape sequences stripped
-      // of their ESC. Markers may ride their own chunk or the edges of a
-      // content chunk; strip every occurrence and track the open-paste flag
-      // so a chunk that is exactly LF inserts instead of submitting.
+      // Bracketed-paste wrappers arrive as escape sequences Ink has stripped
+      // only ONE leading ESC from, so the tail marker still carries its own:
+      // strip both spellings before the payload is read, or a dragged path
+      // reaches the attachment parser with a trailing control byte and fails.
+      // Markers may ride their own chunk or the edges of a content chunk; the
+      // open-paste flag is tracked so a chunk that is exactly LF inserts
+      // instead of submitting.
       let text = input
       if (text.includes(PASTE_START_MARKER)) {
         pasteBracketRef.current = true
@@ -4821,13 +4909,12 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
           clearTimeout(timer)
           pasteBracketCancelRef.current = undefined
         }
-        text = text.replaceAll(PASTE_START_MARKER, '')
       }
       if (text.includes(PASTE_END_MARKER)) {
         pasteBracketRef.current = false
         pasteBracketCancelRef.current?.()
-        text = text.replaceAll(PASTE_END_MARKER, '')
       }
+      text = stripPasteMarkers(text)
       if (text === '') return
       if (text.length > 1) {
         // A path-list paste splits into images and files; prose falls through
@@ -4921,7 +5008,9 @@ function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch
   // the reserve from outliving the menu (unmount or inactive handoff).
   useEffect(() => {
     onMenuRows(menuHeightRows)
-    return () => onMenuRows(0)
+    return () => {
+      if (menuHeightRows !== 0) onMenuRows(0)
+    }
   }, [menuHeightRows, onMenuRows])
   // The composer band: the old border's three-row footprint repainted as a
   // background-color band (the Codex-style shaded composer strip) — one
@@ -5386,14 +5475,22 @@ export function App(props: AppProps): ReactElement {
   const [authorizationDirectory, setAuthorizationDirectory] = useState<ProviderAuthorizationDirectory | undefined>(undefined)
   const [authorizationError, setAuthorizationError] = useState<string | undefined>(undefined)
   const [modelLoadEpoch, setModelLoadEpoch] = useState(0)
+  /** Bumped when /effort's catalog lookup must be ignored (panel closed or superseded). */
+  const effortLookupEpoch = useRef(0)
   const [notice, setNotice] = useState<{ text: string; tone: NoticeTone } | undefined>(undefined)
   const notify = useCallback((text: string, tone: NoticeTone = 'info'): void => {
     setNotice({ text, tone })
   }, [])
 
+  const {
+    loadModels,
+    loadModelProviders,
+    loadProviderAuthorizations,
+    onBridgeReady,
+  } = props
   useEffect(() => {
-    props.onBridgeReady({ notify })
-  }, [])
+    onBridgeReady({ notify })
+  }, [notify, onBridgeReady])
   useEffect(() => {
     if (!modelOpen) return
     let cancelled = false
@@ -5402,7 +5499,7 @@ export function App(props: AppProps): ReactElement {
     // Enter the promise chain before invoking the loader so a provider that
     // throws synchronously becomes an in-panel error instead of escaping the
     // React effect and tearing down Ink.
-    Promise.resolve().then(() => props.loadModels()).then((loaded) => {
+    Promise.resolve().then(() => loadModels()).then((loaded) => {
       if (!cancelled) setDirectory(loaded)
     }, (error: unknown) => {
       if (!cancelled) setModelError(error instanceof Error ? error.message : String(error))
@@ -5410,13 +5507,13 @@ export function App(props: AppProps): ReactElement {
     return () => {
       cancelled = true
     }
-  }, [modelOpen, modelLoadEpoch, props.loadModels])
+  }, [loadModels, modelOpen, modelLoadEpoch])
   useEffect(() => {
-    if (!modelOpen || props.loadModelProviders === undefined) return
+    if (!modelOpen || loadModelProviders === undefined) return
     let cancelled = false
     setProviderDirectory(undefined)
     setProviderError(undefined)
-    Promise.resolve().then(() => props.loadModelProviders!()).then((loaded) => {
+    Promise.resolve().then(() => loadModelProviders()).then((loaded) => {
       if (!cancelled) setProviderDirectory(loaded)
     }, (error: unknown) => {
       if (!cancelled) setProviderError(error instanceof Error ? error.message : String(error))
@@ -5424,13 +5521,13 @@ export function App(props: AppProps): ReactElement {
     return () => {
       cancelled = true
     }
-  }, [modelOpen, modelLoadEpoch, props.loadModelProviders])
+  }, [loadModelProviders, modelOpen, modelLoadEpoch])
   useEffect(() => {
-    if (!modelOpen || props.loadProviderAuthorizations === undefined) return
+    if (!modelOpen || loadProviderAuthorizations === undefined) return
     let cancelled = false
     setAuthorizationDirectory(undefined)
     setAuthorizationError(undefined)
-    Promise.resolve().then(() => props.loadProviderAuthorizations!()).then((loaded) => {
+    Promise.resolve().then(() => loadProviderAuthorizations()).then((loaded) => {
       if (!cancelled) setAuthorizationDirectory(loaded)
     }, (error: unknown) => {
       if (!cancelled) setAuthorizationError(error instanceof Error ? error.message : String(error))
@@ -5438,7 +5535,7 @@ export function App(props: AppProps): ReactElement {
     return () => {
       cancelled = true
     }
-  }, [modelOpen, modelLoadEpoch, props.loadProviderAuthorizations])
+  }, [loadProviderAuthorizations, modelOpen, modelLoadEpoch])
   useEffect(() => {
     const subscribe = props.subscribeModelProviders
     if (!modelOpen || subscribe === undefined) return
@@ -5482,6 +5579,8 @@ export function App(props: AppProps): ReactElement {
   const [pluginOpen, setPluginOpen] = useState(false)
   const [pluginQuery, setPluginQuery] = useState('')
   const [updateOpen, setUpdateOpen] = useState(false)
+  const [updateApplying, setUpdateApplying] = useState(false)
+  useEffect(() => subscribeUpdateApplyRunning(setUpdateApplying), [])
   const [scheduleOpen, setScheduleOpen] = useState(false)
   const [jobsOpen, setJobsOpen] = useState(false)
   const [statuslineOpen, setStatuslineOpen] = useState(false)
@@ -5493,7 +5592,7 @@ export function App(props: AppProps): ReactElement {
   const [subagentOpen, setSubagentOpen] = useState(false)
   const [todosOpen, setTodosOpen] = useState(false)
   const [usageOpen, setUsageOpen] = useState(false)
-  /** /delete state: delete-mode hint plus an optional pre-armed row id. */
+  /** /delete state: dedicated picker mode plus an optional pre-armed row id. */
   const [resumeDelete, setResumeDelete] = useState<{ mode: boolean; id?: string }>({ mode: false })
   /** The row id awaiting y/n in the COMPOSER (codex delete confirm): the
    * composer takes the keys, the resume panel yields until it settles. */
@@ -5506,11 +5605,12 @@ export function App(props: AppProps): ReactElement {
   const cancelDelete = useCallback((): void => {
     setDeleteConfirmId(undefined)
   }, [])
+  const deleteSession = props.deleteSession
   const confirmDelete = useCallback((): void => {
     const id = deleteConfirmId
     if (id === undefined) return
     setDeleteConfirmId(undefined)
-    void props.deleteSession(id).then(outcome => {
+    void deleteSession(id).then(outcome => {
       notify(outcome)
       // Keep the picker open and reload: a successful deletion must vanish
       // from the list immediately, not look like a no-op.
@@ -5518,7 +5618,7 @@ export function App(props: AppProps): ReactElement {
     }, (reason: unknown) => {
       notify(t('notice.deleteFailed', { message: reason instanceof Error ? reason.message : String(reason) }), 'error')
     })
-  }, [deleteConfirmId, props.deleteSession, notify])
+  }, [deleteSession, deleteConfirmId, notify])
   /** The /history panel's accepted entry: text plus its recall-space index. */
   const [historyFill, setHistoryFill] = useState<{ text: string; index: number } | undefined>(undefined)
   /** Submissions recorded in this process (Codex local history; persistent file stays in the runner). */
@@ -5557,40 +5657,69 @@ export function App(props: AppProps): ReactElement {
   const agentRows = useSyncExternalStore(subscribeSubagents, readAgentRows)
   const approvalPending = approvalSnapshot.pending !== undefined
   const questionPending = questionSnapshot.pending !== undefined
-  // While any modal owns the keys, the prompt box passes everything through.
+  /**
+   * Every keyboard-owning surface that is mutually exclusive with the composer,
+   * in precedence order. This ONE list drives the composer gate, the transcript
+   * visibility, the frozen band's hint, and the hand-off when a human approval
+   * or question arrives, so a panel cannot be wired into one of them and
+   * forgotten in the others.
+   */
+  const panelSurfaces: readonly { readonly hint: string; readonly open: boolean; readonly close: () => void }[] = [
+    { hint: 'the diff review', open: diffView !== undefined, close: () => setDiffView(undefined) },
+    { hint: 'the review picker', open: reviewPickerOpen, close: () => setReviewPickerOpen(false) },
+    {
+      hint: '/model',
+      open: modelOpen,
+      close: () => {
+        setModelOpen(false)
+        setProviderOpen(false)
+        setProviderAction(undefined)
+        setEffortFor(undefined)
+      },
+    },
+    { hint: '/help', open: helpOpen, close: () => setHelpOpen(false) },
+    { hint: '/mode', open: modeOpen, close: () => setModeOpen(false) },
+    { hint: '/permission', open: permissionOpen, close: () => setPermissionOpen(false) },
+    { hint: '/resume', open: resumeOpen, close: () => setResumeOpen(false) },
+    { hint: '/search', open: searchOpen, close: () => setSearchOpen(false) },
+    { hint: '/plugin', open: pluginOpen, close: () => setPluginOpen(false) },
+    { hint: '/update', open: updateOpen, close: () => setUpdateOpen(false) },
+    { hint: '/schedule', open: scheduleOpen, close: () => setScheduleOpen(false) },
+    { hint: '/jobs', open: jobsOpen, close: () => setJobsOpen(false) },
+    { hint: '/statusline', open: statuslineOpen, close: () => setStatuslineOpen(false) },
+    { hint: '/theme', open: themeOpen, close: () => setThemeOpen(false) },
+    { hint: '/language', open: languageOpen, close: () => setLanguageOpen(false) },
+    { hint: '/history', open: historyOpen, close: () => setHistoryOpen(false) },
+    { hint: '/queue', open: queueOpen, close: () => setQueueOpen(false) },
+    { hint: '/agents', open: agentsOpen, close: () => setAgentsOpen(false) },
+    { hint: '/subagent', open: subagentOpen, close: () => setSubagentOpen(false) },
+    { hint: '/todos', open: todosOpen, close: () => setTodosOpen(false) },
+    { hint: '/usage', open: usageOpen, close: () => setUsageOpen(false) },
+  ]
+  const panelSurfacesRef = useRef(panelSurfaces)
+  panelSurfacesRef.current = panelSurfaces
+  const openPanel = panelSurfaces.find(surface => surface.open)
+  // The Ctrl+O inspector is the one surface the composer already yields to
+  // through verboseOpen; it rides the same gate without a panel row.
+  const inspectorVisible = verboseOpen && !approvalPending && !questionPending
+  const modalVisible = openPanel !== undefined || inspectorVisible || approvalPending || questionPending
   // While a deletion waits for y/n, the composer takes the keys (the resume
   // panel yields): the confirm is typed IN the input box, not as an invisible
   // panel keypress.
   const inputActive = deleteConfirmId !== undefined
     ? !approvalPending && !questionPending
-    : !modelOpen && !helpOpen && !modeOpen && !permissionOpen && !resumeOpen && !pluginOpen && !updateOpen && !scheduleOpen && !jobsOpen && !statuslineOpen && !themeOpen && !languageOpen && !historyOpen && !queueOpen && !agentsOpen && !subagentOpen && !todosOpen && !usageOpen && !verboseOpen && diffView === undefined && !reviewPickerOpen && !approvalPending && !questionPending
-  const transcriptVisible = !modelOpen && !helpOpen && !modeOpen && !permissionOpen && !resumeOpen && !pluginOpen && !updateOpen && !scheduleOpen && !jobsOpen && !statuslineOpen && !themeOpen && !languageOpen && !historyOpen && !queueOpen && !agentsOpen && !subagentOpen && !todosOpen && !usageOpen && !verboseOpen && diffView === undefined && !reviewPickerOpen && !approvalPending && !questionPending
+    : !modalVisible
+  const transcriptVisible = !modalVisible
 
-  // Human questions outrank local inspectors. Close the lower modal instead
-  // of leaving an approval/question visible but keyboard-locked behind it.
+  // Human questions outrank local inspectors. Close every open surface instead
+  // of leaving it visible but keyboard-locked behind the approval.
   useEffect(() => {
     if (!approvalPending && !questionPending) return
-    setModelOpen(false)
-    setProviderOpen(false)
-    setProviderAction(undefined)
-    setEffortFor(undefined)
-    setHelpOpen(false)
-    setModeOpen(false)
-    setPermissionOpen(false)
-    setResumeOpen(false)
-    setPluginOpen(false)
-    setUpdateOpen(false)
-    setScheduleOpen(false)
-    setStatuslineOpen(false)
-    setThemeOpen(false)
-    setHistoryOpen(false)
-    setQueueOpen(false)
-    setAgentsOpen(false)
-    setSubagentOpen(false)
-    setTodosOpen(false)
+    for (const surface of panelSurfacesRef.current) {
+      if (surface.open) surface.close()
+    }
     setDeleteConfirmId(undefined)
     setVerboseOpen(false)
-    setDiffView(undefined)
   }, [approvalPending, questionPending])
 
   // Append-only transcript: everything up to the first still-mutable entry
@@ -5774,8 +5903,6 @@ export function App(props: AppProps): ReactElement {
     : visibleLiveLines.slice(-liveAudit.allocation.live)
   const auditedReasoningRows = liveAudit.allocation.reasoning
   const auditedAnswerRows = liveAudit.allocation.answer
-  const inspectorVisible = verboseOpen && !approvalPending && !questionPending
-  const modalVisible = modelOpen || helpOpen || modeOpen || permissionOpen || resumeOpen || pluginOpen || updateOpen || scheduleOpen || jobsOpen || statuslineOpen || themeOpen || languageOpen || historyOpen || queueOpen || agentsOpen || subagentOpen || todosOpen || usageOpen || inspectorVisible || diffView !== undefined || reviewPickerOpen || approvalPending || questionPending
   // The surface that currently owns the keyboard, named in the frozen band:
   // an empty composer under a panel must not advertise typing it cannot
   // accept — every key actually feeds the panel (which may or may not
@@ -5784,65 +5911,43 @@ export function App(props: AppProps): ReactElement {
     ? 'the approval prompt'
     : questionPending
       ? 'the question'
-      : diffView !== undefined
-        ? 'the diff review'
-        : reviewPickerOpen
-          ? 'the review picker'
-        : modelOpen
-          ? '/model'
-          : helpOpen
-            ? '/help'
-            : modeOpen
-              ? '/mode'
-              : permissionOpen
-                ? '/permission'
-                : resumeOpen
-                  ? '/resume'
-                  : pluginOpen
-                    ? '/plugin'
-                    : updateOpen
-                      ? '/update'
-                      : scheduleOpen
-                        ? '/schedule'
-                        : jobsOpen
-                          ? '/jobs'
-                        : statuslineOpen
-                          ? '/statusline'
-                          : themeOpen
-                            ? '/theme'
-                            : languageOpen
-                              ? '/language'
-                            : historyOpen
-                              ? '/history'
-                              : agentsOpen
-                                ? '/agents'
-                                : subagentOpen
-                                  ? '/subagent'
-                                  : todosOpen
-                                    ? '/todos'
-                                    : usageOpen
-                                      ? '/usage'
-                                      : inspectorVisible
-                                        ? 'history details'
-                                        : undefined
+      : openPanel?.hint ?? (inspectorVisible ? 'history details' : undefined)
+  // One way out of every panel, matching Esc: while a panel owns the keys,
+  // Ctrl+C closes it instead of silently doing nothing. The composer keeps its
+  // own three states (interrupt the turn / clear the draft / quit) whenever no
+  // panel is open, and the approval and question bars keep theirs.
+  useStableInput((input, key) => {
+    if (!(key.ctrl && input === 'c')) return
+    if (approvalPending || questionPending || deleteConfirmId !== undefined) return
+    if (openPanel !== undefined) openPanel.close()
+    else if (inspectorVisible) setVerboseOpen(false)
+  }, true)
   const frozenHint = keyboardOwner === undefined
     ? undefined
-    : `keys go to ${keyboardOwner} · esc ${approvalPending ? 'rejects' : questionPending ? 'cancels' : 'closes'}`
+    : t('frozen.keysGoTo', {
+      owner: keyboardOwner,
+      action: approvalPending
+        ? t('frozen.action.rejects')
+        : questionPending
+          ? t('frozen.action.cancels')
+          : updateApplying && updateOpen
+            ? t('frozen.action.waits')
+            : t('frozen.action.closes'),
+    })
   const closeInspector = useCallback((): void => {
     setVerboseOpen(false)
   }, [])
-  const refreshScreen = (): void => {
-    // Same source-backed clear the resize path uses: reset the scroll region
-    // (`\x1b[r`) before wiping screen AND scrollback, then home the cursor.
-    // A bare `\x1b[2J\x1b[3J\x1b[H` leaves a previously set scroll region in
-    // place, so Ink's next repaint positions against stale bounds — the
-    // stale-position flicker where the screen keeps redrawing.
+  const refreshScreen = useCallback((opts?: { wipeScrollback?: boolean }): void => {
+    // Resize / Ctrl+L wipe screen AND scrollback. A history-cap trim remounts
+    // Static at the current width, so native scrollback must stay — the user
+    // may be reading messages above the fold.
+    const clear = opts?.wipeScrollback === false ? TRIM_REFLOW_CLEAR : RESIZE_REFLOW_CLEAR
     if (appStdout !== undefined) {
       synchronizedReplayPending.current = true
-      appStdout.write(SYNCHRONIZED_UPDATE_BEGIN + RESIZE_REFLOW_CLEAR)
+      appStdout.write(SYNCHRONIZED_UPDATE_BEGIN + clear)
     }
     setRefreshEpoch(epoch => epoch + 1)
-  }
+  }, [appStdout])
   const applyRainbow = (seed?: number): void => {
     // Replace the memoized roll, then setTheme so getPalette() and the
     // painters pick the new values; persist rainbow as the active theme
@@ -5871,8 +5976,8 @@ export function App(props: AppProps): ReactElement {
   const settledNeedsTrim = settledRowsCache.current?.needsTrim === true
   useEffect(() => {
     if (!settledNeedsTrim || busy || streamingActive) return
-    refreshScreen()
-  }, [settledNeedsTrim, busy, streamingActive])
+    refreshScreen({ wipeScrollback: false })
+  }, [busy, refreshScreen, settledNeedsTrim, streamingActive])
 
   const sessionHasImages = useMemo(() => view.entries.some(entry =>
     (entry.kind === 'user' || entry.kind === 'pending') && (entry.images?.length ?? 0) > 0), [view.entries])
@@ -5902,6 +6007,7 @@ export function App(props: AppProps): ReactElement {
     setModelLoadEpoch(epoch => epoch + 1)
   }
   const closeModelSurface = (): void => {
+    effortLookupEpoch.current += 1
     setModelOpen(false)
     setProviderOpen(false)
     setProviderAction(undefined)
@@ -6130,6 +6236,7 @@ export function App(props: AppProps): ReactElement {
               continuationPrefix: '  ',
               dim: true,
               maxRows: auditedReasoningRows,
+              columns: Math.max(1, terminalColumns - 2),
             })
             // The collapsed marker shimmers only while reasoning streams
             // alone: once answer text flows, a periodically re-rendered
@@ -6146,6 +6253,7 @@ export function App(props: AppProps): ReactElement {
                 continuationPrefix: '  ',
                 dim: true,
                 maxRows: auditedReasoningRows,
+                columns: Math.max(1, terminalColumns - 2),
               })
           : undefined,
         view.streaming !== '' && auditedAnswerRows > 0
@@ -6153,7 +6261,7 @@ export function App(props: AppProps): ReactElement {
             StreamTail,
             // The same two-column gutter as settled replies: streamed text
             // lands exactly where the assembled message will render.
-            { text: view.streaming, dim: false, maxRows: auditedAnswerRows, prefix: '  ' },
+            { text: view.streaming, dim: false, maxRows: auditedAnswerRows, prefix: '  ', columns: Math.max(1, terminalColumns - 2) },
             busy ? createElement(Caret, { animated: animations }) : undefined,
           )
           : undefined,
@@ -6220,6 +6328,8 @@ export function App(props: AppProps): ReactElement {
       ? createElement(MemoVerbosePanel, {
         entries: view.entries,
         onClose: closeInspector,
+        columns: terminalColumns,
+        rows: terminalRows,
       })
       : undefined,
     modeOpen && !approvalPending && !questionPending
@@ -6256,11 +6366,18 @@ export function App(props: AppProps): ReactElement {
         currentCwd: props.workspaceRoot,
         load: props.loadSessions,
         readTranscript: props.loadSessionTranscript,
-        requestDelete,
+        requestDelete: resumeDelete.mode ? requestDelete : undefined,
         deleteConfirmId,
         reloadToken: deleteReloadToken,
         deleteMode: resumeDelete.mode,
-        select: (row: SessionRow) => { props.switchSession(row); setResumeOpen(false) },
+        presetId: resumeDelete.id,
+        select: (row: SessionRow) => {
+          // Defense in depth: the dedicated delete picker must never turn a
+          // selection into a session switch, even if its key routing regresses.
+          if (resumeDelete.mode) return
+          props.switchSession(row)
+          setResumeOpen(false)
+        },
         close: () => setResumeOpen(false),
       })
       : undefined,
@@ -6425,6 +6542,7 @@ export function App(props: AppProps): ReactElement {
         interrupt: props.interrupt,
         quit: props.quit,
         openModel: () => {
+          effortLookupEpoch.current += 1
           setDirectory(undefined)
           setModelError(undefined)
           setProviderDirectory(undefined)
@@ -6447,7 +6565,9 @@ export function App(props: AppProps): ReactElement {
           // never as "the model has no efforts" — the adapter advertises
           // levels for every deepseek model, so "no efforts" is almost
           // always a failed resolveModelInfo, not a fact.
+          const epoch = ++effortLookupEpoch.current
           void props.loadModels().then((loaded) => {
+            if (epoch !== effortLookupEpoch.current) return
             const [provider, model] = modelLabel.split('/')
             const row = loaded.rows.find(candidate => candidate.provider === provider && candidate.model === model)
               ?? loaded.rows.find(candidate => candidate.model === model && candidate.reasoning !== undefined)
@@ -6507,7 +6627,9 @@ export function App(props: AppProps): ReactElement {
         openDelete: (id?: string) => {
           const armed = id === undefined || id === '' ? undefined : id
           setResumeDelete({ mode: true, ...armed === undefined ? {} : { id: armed } })
-          setDeleteConfirmId(armed)
+          // Confirm after the picker resolves the id against the listing —
+          // the argument may be a suffix of the displayed id, not the row key.
+          setDeleteConfirmId(undefined)
           setResumeOpen(true)
         },
         openDiff: (argument: string) => {