@askdkc/dsh-cli 0.11.3

package/lib/types/screens/Chat.js

@@ -0,0 +1,4299 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { t, getLang, setLang, isLang, writeLangPref, readLangPref, subscribeLang, LANGS } from '../i18n.js';
+import { readThemePref } from '../themePrefs.js';
+import { readPresetPref } from '../presetPrefs.js';
+import { readModelPref } from '../modelPrefs.js';
+import { readActivityFrames } from '../activityPrefs.js';
+import { envThemeOverride } from '../components/design-system/ThemeProvider.js';
+import { hasPath } from '../dsh-adapter/settingsEditor.js';
+import { planReload } from '../reload.js';
+import { AlternateScreen, Box, Image, Text, useInput, ScrollBox, useTheme, useTerminalSize } from '../ui.js';
+import { usePageInset } from '../components/PageMargin.js';
+import { POINTER } from '../terminal-utils/figures.js';
+import { isPlainReturnInput, modLabel } from '../utils/modifiers.js';
+import { actionMatches } from '../utils/keymap.js';
+import { formatTokens } from '../terminal-utils/format.js';
+import { homeDir } from '../utils/paths.js';
+import { execFileNoThrow } from '../utils/execFileNoThrow.js';
+import { cleanRenderText, cleanScalarText } from '../dsh-adapter/sanitize.js';
+import { deriveModelGroups, modelPickerLanding, recentCatalogModels, RECENTS_GROUP_PROVIDER, } from '../modelGroups.js';
+import { readModelRecents, recordModelUse } from '../modelRecents.js';
+import { TuiDialogStore } from '../dsh-adapter/dialogs.js';
+import { TuiStatusStore } from '../dsh-adapter/status.js';
+import { ActivityStore, useActivity } from '../dsh-adapter/activity-store.js';
+import { runProviderWizard } from '../dsh-adapter/providerWizard.js';
+import { ApprovalStore } from '../dsh-adapter/approvals.js';
+import { AskUserQuestionPanel } from '../components/questions/AskUserQuestionPanel.js';
+import { ApprovalPanel } from '../components/approvals/ApprovalPanel.js';
+import { ExtensionDialog } from '../components/ExtensionDialog.js';
+import { useSearchHighlight } from '../ink/hooks/use-search-highlight.js';
+import { useTerminalTitle } from '../ink/hooks/use-terminal-title.js';
+import { useTerminalFocus } from '../ink/hooks/use-terminal-focus.js';
+import { useCopyOnSelect } from '../ink/hooks/use-copy-on-select.js';
+import { useSelection } from '../ink/hooks/use-selection.js';
+import { NoSelect } from '../ink/components/NoSelect.js';
+import { LogoHeader, MessageList } from '../components/MessageList.js';
+import { TimelineRail } from '../components/TimelineRail.js';
+import { ScrollbarGutter } from '../components/ScrollbarGutter.js';
+import { normalizeScrollGutter } from '../tuiDisplayPrefs.js';
+import { OverlayAbove } from '../components/OverlayAbove.js';
+import { TooltipLayer } from '../components/Tooltip.js';
+import { PromptInput } from '../components/PromptInput.js';
+import { PromptEditorLayer, usePromptEditorOpen } from '../components/PromptEditor.js';
+import { GoalTodoPanel } from '../components/GoalTodoPanel.js';
+import { AutoRecapRow } from '../components/AutoRecapRow.js';
+import { BalanceReportRow } from '../components/BalanceReportRow.js';
+import { LoadedContextPanel } from '../components/LoadedContextPanel.js';
+import { StatusLine } from './StatusLine.js';
+import { WorkingSpinner, useThinkingStatus } from '../components/WorkingSpinner.js';
+import { ActivityLine, contextPressurePct } from '../components/ActivityLine.js';
+import { ModelPicker } from '../components/ModelPicker.js';
+import { PluginSceneBoundary } from '../components/PluginSceneBoundary.js';
+import { PluginStatusViewBoundary } from '../components/PluginStatusViewBoundary.js';
+import { ImagePreviewOverlay } from '../components/ImagePreviewOverlay.js';
+import { SkillsPicker, SkillsPickerLoading } from '../components/SkillsPicker.js';
+import { MigrateConfirm, MigratePicker } from '../components/MigratePicker.js';
+import { collectMigratePickerRows, MIGRATE_SCAN_SPECS, parseImportSummary, resolveMigrateCommand } from '../dsh-adapter/migrate/picker.js';
+import { collectActivitySamples, recentAgentsFrom } from '../dsh-adapter/migrate/recent-agents.js';
+import { MIGRATION_ADAPTERS } from '../dsh-adapter/migrate/index.js';
+import { SessionSupervisor } from './SessionSupervisor.js';
+import { SessionTree } from './SessionTree.js';
+import { Settings } from './Settings.js';
+import { WorkspacePicker } from '../components/WorkspacePicker.js';
+import { WorkspaceMenuPicker } from '../components/WorkspaceMenuPicker.js';
+import { WorkspaceFlowPicker } from '../components/WorkspaceFlowPicker.js';
+import { ActivityPicker } from '../components/ActivityPicker.js';
+import { ColorPicker } from '../components/ColorPicker.js';
+import { EffortSlider } from '../components/EffortSlider.js';
+import { PresetPicker } from '../components/PresetPicker.js';
+import { PermissionsPicker } from '../components/PermissionsPicker.js';
+import { PlanPicker } from '../components/PlanPicker.js';
+import { LangPicker } from '../components/LangPicker.js';
+import { ThemePicker, getThemeOptions } from '../components/ThemePicker.js';
+import { AUTO_THEME_NAME, getAutoThemeBase } from '../theme.js';
+import { FRAME_PRESETS, PRESET_NAMES } from '../components/activityFrames.js';
+import { ThinkingToggle } from '../components/ThinkingToggle.js';
+import { HistorySearchDialog } from '../components/HistorySearchDialog.js';
+import { RewindPicker } from '../components/RewindPicker.js';
+import { BtwPanel } from '../components/BtwPanel.js';
+import { RecapPanel } from '../components/RecapPanel.js';
+import { isValidSessionColor, SESSION_COLOR_NAMES } from '../terminal-utils/sessionColors.js';
+import { TipsPanel } from '../components/TipsPanel.js';
+import { SubagentDashboard } from '../components/SubagentDashboard.js';
+import { JobsPanel } from '../components/JobsPanel.js';
+import { SubagentDetailScene } from '../components/SubagentDetailScene.js';
+import { FileActionsPanel, FILE_ACTION_COUNT } from '../components/FileActionsPanel.js';
+import { openExternal, openFile, revealInFileManager } from '../utils/openExternal.js';
+import { resolveTargetPath } from '../utils/fileTarget.js';
+import { classifyOpenTarget } from '../utils/urlGuard.js';
+import { statSync } from 'node:fs';
+import { setClipboard } from '../ink/termio/osc.js';
+import { TerminalWriteContext } from '../ink/useTerminalNotification.js';
+import instances from '../ink/instances.js';
+import { useAnimationFrame } from '../ink/hooks/use-animation-frame.js';
+import { useExternalVersion } from '../hooks/useExternalVersion.js';
+import { TrajectoryScene } from './TrajectoryScene.js';
+import { resumeFailureText } from '../sessions/resumeFailure.js';
+import { markHomeSeen } from '../homePrefs.js';
+import { extendTrajectory, projectWave } from '../dsh-adapter/trajectory/index.js';
+import { miniWakeWidth } from '../components/trajectory/MiniWake.js';
+import { readTrajectorySeen, writeTrajectorySeen } from '../trajectoryPrefs.js';
+import { LoadingState } from '../components/design-system/LoadingState.js';
+import { Pane } from '../components/design-system/Pane.js';
+import { loadHistory } from '../history.js';
+import { formatLoadedContextReport } from '../utils/loaded-context.js';
+import { NO_OVERLAY, chatOverlayReducer, dialogOverlayVisible, wrapIndex, } from './chatOverlay.js';
+/** Strip the focus/global-input surface even from untyped plugins. Local
+ * click, hover, and captured drag stay inside the view and are kept. */
+function StatusViewBox({ ref: _ref, tabIndex: _tabIndex, autoFocus: _autoFocus, onContextMenu: _onContextMenu, onFocus: _onFocus, onFocusCapture: _onFocusCapture, onBlur: _onBlur, onBlurCapture: _onBlurCapture, onKeyDown: _onKeyDown, onKeyDownCapture: _onKeyDownCapture, onWheel: _onWheel, ...props }) {
+    return _jsx(Box, { ...props });
+}
+/** Text refs would expose the host DOM node; status text is presentation. */
+function StatusViewText({ ref: _ref, ...props }) {
+    return _jsx(Text, { ...props });
+}
+/** Rich status views receive pointer-only layout/text primitives, never the
+ * input, channel, raw-ANSI, or terminal-write parts of the full UI kit. */
+const STATUS_VIEW_UI = Object.freeze({
+    Box: StatusViewBox,
+    Image,
+    Text: StatusViewText,
+    useTerminalSize,
+});
+/** Shared empty snapshot for hosts whose channel has no event log. */
+const NO_EVENTS = [];
+const COMMAND_RESULT_CELLS = 200;
+/** Ceiling for one `dsh-tui migrate` child run. Discovery parses every source
+ *  file, but a healthy import of thousands of conversations finishes well
+ *  inside this; without a cap a wedged child would hang the loop forever. */
+const MIGRATE_CHILD_TIMEOUT_MS = 30 * 60 * 1000;
+function cleanCommandError(error) {
+    try {
+        if (error instanceof Error) {
+            return typeof error.message === 'string'
+                ? cleanRenderText(error.message, COMMAND_RESULT_CELLS)
+                : '';
+        }
+        return cleanScalarText(error, COMMAND_RESULT_CELLS);
+    }
+    catch {
+        return '';
+    }
+}
+function clonePermissionPresetSnapshot(snapshot) {
+    return {
+        availability: snapshot.availability,
+        options: snapshot.options.map(option => ({ ...option })),
+        ...(snapshot.current === undefined ? {} : { current: { ...snapshot.current } }),
+    };
+}
+/** Row kinds the message-selection cursor can land on. */
+const SELECTABLE_KINDS = new Set([
+    'user',
+    'assistant',
+    'tool',
+    'reasoning',
+    'interrupt',
+    'local',
+    'local-output',
+    'compact',
+]);
+/** Shared empty list for mode-gated derived rows (stable reference, so
+ *  downstream consumers never see a changing prop when the mode is off). */
+const NO_ROWS = [];
+/** `max` → `Max` (effort levels arrive lower-case from the adapter). */
+function capitalize(text) {
+    return text.length === 0 ? text : text[0].toUpperCase() + text.slice(1);
+}
+/** Terminal-title spinner frames. */
+const TITLE_SPINNER_FRAMES = ['⠂', '⠐'];
+/** Searchable transcript text for one row (`/` incsearch):
+ *  user text, assistant text, thinking, tool args/results, local output). */
+function searchableText(row) {
+    switch (row.kind) {
+        case 'tool':
+            return row.tool
+                ? `${row.tool.name} ${row.tool.argsText} ${row.tool.resultText ?? ''} ${row.tool.errorText ?? ''}`
+                : '';
+        default:
+            return row.text;
+    }
+}
+/**
+ * Main chat screen: a scrollable transcript
+ * (with the user message the viewport is showing pinned above the transcript
+ * while scrolled up, and a 1-column minimap scrollbar with one node per
+ * user message — the current message's node is highlighted, clicking a node
+ * jumps to it), transient notifications, the working spinner, the bordered
+ * prompt
+ * input (with slash-command overlay) and the status line pinned at the
+ * bottom.
+ *
+ * Ctrl+O toggles expanded detail globally; Shift+↑ enters message-selection
+ * mode (↑/↓ move, Enter expands the selected row, Esc exits); Ctrl+C
+ * interrupts the running turn, or (when idle) asks for a second Ctrl+C to
+ * exit; Enter while scrolled up jumps back to the bottom.
+ */
+/**
+ * Shared inert approval store for hosts that render Chat without an
+ * approval seam (headless verify scripts). Never parked into, so its
+ * snapshot stays null and the approval panel never mounts.
+ */
+let fallbackApprovalStore;
+/**
+ * Shared inert extension stores for hosts that render Chat without the
+ * dsh-tui-extensions row (headless verify scripts, bare embeds). Never
+ * written, so plugin dialogs/status contributions never mount and
+ * no shortcut ever matches.
+ */
+let fallbackDialogStore;
+let fallbackStatusStore;
+/** Standalone mounts (tests, bare embeds) without the composition root's store. */
+let fallbackActivityStore;
+/** Identity of one caret-preview dismissal: the token (its title) on the
+ *  image, so the same image staged twice is dismissed per token. */
+function peekKey(image, title) {
+    return `${title ?? ''} ${image.id}`;
+}
+export function Chat({ channel, questionStore, approvalStore, extensionDialogs, extensionStatus, activityStore, extensionShortcuts, themeHost, onExit, onUpdate, onRestart, fullscreen = false, trajectorySeen: trajectorySeenProp, injectControllerRef, promptControllerRef: promptControllerRefProp, renderScene, openHomeOnBoot, }) {
+    const writeRaw = React.useContext(TerminalWriteContext);
+    // Re-render whenever the channel mutates; rows/status are read fresh below.
+    // DEFAULT lane on purpose (useExternalVersion): the channel version bumps
+    // at streaming cadence (every ~16ms via emitStream), and a useSyncExternalStore
+    // wakeup would force a SyncLane render per bump — each such sync commit
+    // preempting the in-flight Default render and ending with Default work
+    // still pending feeds React's nested-update counter until error #185 kills
+    // the process (beta.3; the reveal-store half was PR #680, this is the
+    // channel half — the surviving source on Windows timer granularity).
+    useExternalVersion(channel.subscribe, () => channel.version);
+    // Re-render on language switches so the whole UI hot-swaps its strings.
+    React.useSyncExternalStore(subscribeLang, getLang);
+    const promptEditorOpen = usePromptEditorOpen();
+    // The pending ask-user-question (DSH user-interaction seam): the model's
+    // `ask_user_question` tool parks here until the panel is answered.
+    const questionSnapshot = React.useSyncExternalStore(listener => questionStore.subscribe(listener), () => questionStore.getSnapshot());
+    // The pending tool-approval ask (DSH approval seam): the permission layer
+    // parks here until the panel decides; shown with priority over a pending
+    // questionnaire since it gates a tool about to run. Hosts that pass no
+    // approvalStore share one inert instance that never holds an ask.
+    const approvals = approvalStore ?? (fallbackApprovalStore ??= new ApprovalStore());
+    const approvalSnapshot = React.useSyncExternalStore(listener => approvals.subscribe(listener), () => approvals.getSnapshot());
+    // The pending managed plugin dialog (tuiDialogs seam): a plugin's
+    // select/confirm/input request parks here until the panel settles it.
+    // Priority sits right below the approval panel (a gated tool outranks a
+    // plugin's question) and above the questionnaire. Hosts without the
+    // extensions row share one inert store that never holds a dialog.
+    const dialogs = extensionDialogs ?? (fallbackDialogStore ??= new TuiDialogStore());
+    const dialogSnapshot = React.useSyncExternalStore(listener => dialogs.subscribe(listener), () => dialogs.getSnapshot());
+    // Plugin status contributions: text keys join into one line; bounded rich
+    // views keep their own rows immediately above the prompt.
+    const statusContributions = extensionStatus ?? (fallbackStatusStore ??= new TuiStatusStore());
+    // The working line: the working-activity plugin's published value for THIS
+    // session, read from its session projection. No projection value (plugin
+    // absent, or nothing published yet) simply means the classic spinner below.
+    const activityValues = activityStore ?? (fallbackActivityStore ??= new ActivityStore());
+    const workingActivity = useActivity(activityValues, channel.sessionId);
+    const subscribeStatus = React.useCallback((listener) => statusContributions.subscribe(listener), [statusContributions]);
+    const statusEntries = React.useSyncExternalStore(subscribeStatus, () => statusContributions.getSnapshot());
+    const statusViews = React.useSyncExternalStore(subscribeStatus, () => statusContributions.getViewSnapshot());
+    // Shortcut handler failures surface as toasts (the registry also logs
+    // them); the hook is re-pointed on every mount so a stale closure never
+    // outlives its channel.
+    React.useEffect(() => {
+        if (extensionShortcuts === undefined)
+            return;
+        return extensionShortcuts.setErrorHandler(combo => {
+            channel.notify(t('ext-shortcut-failed', { combo }), { color: 'error', timeoutMs: 4000 });
+        });
+    }, [extensionShortcuts, channel]);
+    // When a questionnaire batch completes, fold a Q&A summary into the
+    // transcript (the tool card itself is hidden from the message list).
+    const questionOpenRef = React.useRef(questionSnapshot !== null);
+    React.useEffect(() => {
+        const wasOpen = questionOpenRef.current;
+        questionOpenRef.current = questionSnapshot !== null;
+        if (wasOpen && questionSnapshot === null) {
+            for (const summary of questionStore.takeSummaries()) {
+                channel.pushLocal(summary.title, summary.lines);
+            }
+        }
+    }, [channel, questionSnapshot, questionStore]);
+    const [expanded, setExpanded] = React.useState(false);
+    const [helpOpen, setHelpOpen] = React.useState(false);
+    const [handle, setHandle] = React.useState(null);
+    /**
+     * Conversation timeline snapshot (reported by MessageList): one entry
+     * per user turn plus the viewport-derived navigation targets. The
+     * ACTIVE turn — the one whose content owns the viewport top row — pins
+     * the sticky prompt header AND highlights the transcript rail's tick,
+     * from one report so the two can never disagree; upId/downId drive the
+     * rail's ▲/▼. Null activeId while pinned to the bottom only when there
+     * are no turns (header hidden there anyway).
+     */
+    const [timeline, setTimeline] = React.useState({
+        turns: [],
+        activeId: null,
+        upId: null,
+        downId: null,
+    });
+    const [selectionActive, setSelectionActive] = React.useState(false);
+    const [selectedId, setSelectedId] = React.useState(null);
+    const [expandedRows, setExpandedRows] = React.useState(() => new Set());
+    /** 流式 reasoning 行相对 thinkingFold 默认值的用户切换。与
+     *  expandedRows 分开：preview 默认三行、full 默认全文，点击在两者间
+     *  翻转；落定后自动回到普通行的折叠语义。 */
+    const [streamViewToggledRows, setStreamViewToggledRows] = React.useState(() => new Set());
+    /**
+     * The transient-dialog layer (every picker/dialog `<OverlayAbove>` hosts,
+     * plus /tips) as ONE value: mutual exclusion between the panels is
+     * structural instead of emerging from "an open picker makes the prompt
+     * inert". Transitions live in the pure reducer (chatOverlay.ts), which
+     * scripts/verify-chat-overlay.ts pins without a renderer. Async data the
+     * pickers show (model list, preset roster, …) stays in the caches below —
+     * it persists across open/close so a reopened picker paints the previous
+     * list while the fresh one loads, exactly as the boolean era did.
+     */
+    const [overlay, dispatchOverlay] = React.useReducer(chatOverlayReducer, NO_OVERLAY);
+    // `/migrate` picker rows (null = collecting in the background; the picker
+    // shows its empty state until the sub-second scan lands).
+    const [migrateRows, setMigrateRows] = React.useState(null);
+    // Multi-select state (PRD): checked agent ids + the confirmation layer's
+    // frozen snapshot of the checked rows.
+    const [migrateChecked, setMigrateChecked] = React.useState(new Set());
+    const [migratePending, setMigratePending] = React.useState([]);
+    // Smart-hint arming: while the migration hint notification is up, a bare
+    // Enter (empty prompt, no overlay) jumps straight into the picker with
+    // that source pre-checked (PRD #4). Any other key disarms.
+    const [migrateHintAgent, setMigrateHintAgent] = React.useState(null);
+    // Chat and PromptInput both receive one parsed stdin batch. Keep the
+    // permission focus synchronous so arrow+Enter in the same batch uses the
+    // post-arrow row rather than the previous render's index.
+    const permissionOverlayFocusRef = React.useRef(null);
+    React.useEffect(() => {
+        if (overlay.kind === 'permission') {
+            // Seed each concrete picker instance after commit. Keyboard handlers
+            // update this ref synchronously; render must remain side-effect free.
+            if (permissionOverlayFocusRef.current?.overlay !== overlay) {
+                permissionOverlayFocusRef.current = { overlay, index: overlay.index };
+            }
+        }
+        else {
+            permissionOverlayFocusRef.current = null;
+        }
+    }, [overlay]);
+    const [models, setModels] = React.useState([]);
+    /** Provider display identities for the /model group level; refreshed alongside `models`. */
+    const [providerInfos, setProviderInfos] = React.useState([]);
+    React.useEffect(() => {
+        const subscribe = channel.providerSetup?.()?.oauth?.onCredentialChange;
+        if (subscribe === undefined)
+            return;
+        return subscribe(() => {
+            channel.invalidateModelCompletion();
+            void channel.listModels().then(setModels).catch(() => setModels([]));
+            void channel.listProviders().then(setProviderInfos).catch(() => setProviderInfos([]));
+        });
+    }, [channel]);
+    /** /model 最近使用分组：成功切换即记录（去重置顶，上限 10），重启保留。 */
+    const [modelRecents, setModelRecents] = React.useState(() => readModelRecents());
+    /** Two-level /model: the drilled-in provider route; undefined = group level.
+     *  Reset on open; stale ids resolve back to the group level via `activeModelGroup`. */
+    const [modelGroup, setModelGroup] = React.useState(undefined);
+    /** True while the picker sits in the single-provider fast path (drilled in
+     *  at open, the group level never shown): Esc closes directly and no back
+     *  hint renders — a pinned recents pseudo-group must not fake a two-level
+     *  walk the user never saw (issue #527 regression: repro-picker-windowing). */
+    const [modelPickerDirect, setModelPickerDirect] = React.useState(false);
+    /** Group rows over the current catalog, first-appearance (registry) order,
+     *  with the pinned recents pseudo-group first when any entry is catalogued. */
+    const modelGroups = React.useMemo(() => deriveModelGroups(models, providerInfos, modelRecents), [models, providerInfos, modelRecents]);
+    /** The drilled-in group, but only while it still exists in the catalog. */
+    const activeModelGroup = modelGroup !== undefined && modelGroups.some(group => group.provider === modelGroup)
+        ? modelGroup
+        : undefined;
+    const groupModels = React.useMemo(() => {
+        if (activeModelGroup === undefined)
+            return [];
+        if (activeModelGroup === RECENTS_GROUP_PROVIDER)
+            return recentCatalogModels(modelRecents, models);
+        return models.filter(model => model.provider === activeModelGroup);
+    }, [models, modelRecents, activeModelGroup]);
+    /** Switch + record: every successful switch feeds the /model recents group
+     *  (picker Enter/click, `/model provider/id`, the wizard's live switch,
+     *  and /reload's applied model all ride this one path). */
+    const switchModelRecorded = (provider, id, name) => {
+        if (name !== undefined)
+            channel.notify(t('model-switching', { name }));
+        return channel.switchModel(provider, id).then((ok) => {
+            if (!ok)
+                return ok;
+            if (name !== undefined)
+                channel.notify(t('model-switched', { name }));
+            setModelRecents(recordModelUse({ provider, id }));
+            return ok;
+        });
+    };
+    /** `/skills` 技能目录（issue #204）：null = 注册表快照在途。 */
+    const [skillsList, setSkillsList] = React.useState(null);
+    /**
+     * The session supervisor — the ONE screen behind `/resume`, `/agentview`,
+     * `/home`, `/bg` and the composer's 🏠 button.
+     *
+     * Those were three screens over one domain (a workspace rail here, a
+     * search surface there, a live-status overview somewhere else), which is why
+     * each new session feature needed patching into all three and why the
+     * three disagreed about what switching a session even does. There is now a
+     * single surface and a single runtime behind every entry point: this
+     * terminal hosts several sessions, leaving one parks it rather than ending
+     * it, and a session another terminal holds is visible but not enterable.
+     *
+     * Seeded from the host's one-shot landing decision (`openHomeOnBoot`): the
+     * first ordinary launch of an installation lands here instead of on a blank
+     * conversation, because that is the launch where "which project am I working
+     * on" has not been answered yet. Every later launch starts on the chat
+     * screen, and the screen stays reachable.
+     */
+    const [supervisorOpen, setSupervisorOpen] = React.useState(openHomeOnBoot === true);
+    /** `/tree` opens the session family tree (pi's Session Tree): every rewind
+     *  fork stitched back onto the message it diverged from, hover previews,
+     *  and per-node rewind/fork/adopt actions. Like the supervisor, a screen. */
+    const [treeOpen, setTreeOpen] = React.useState(false);
+    /**
+     * The session backgrounded when the screen opened via ←/`/bg` (the "Esc
+     *  returns to that conversation" return target), cleared on close.
+     */
+    const [agentViewReturnId, setAgentViewReturnId] = React.useState(undefined);
+    /** Live agent-view rows: the prompt footer's "← N agents" hint reads the
+     *  needs-input count from here (cached snapshot in the channel). The
+     *  `?.()` fallbacks keep pre-agent-view test stubs (channel facades in
+     *  scripts/*) rendering — the real channel always provides the seams. */
+    const EMPTY_AGENT_VIEW_ROWS = [];
+    const agentViewRows = React.useSyncExternalStore(listener => channel.subscribeAgentView?.(listener) ?? (() => { }), () => channel.agentViewRows?.() ?? EMPTY_AGENT_VIEW_ROWS);
+    const backgroundAgentsNeedingInput = agentViewRows.filter(row => row.status === 'needs-input' && !row.current).length;
+    /** Background the attached session and open the supervisor
+     *  (`/bg`, `/background`, and ← on an empty prompt all land here). The
+     *  backgrounded session becomes the screen's return target (final Esc
+     *  attaches back to it). */
+    const backgroundToAgentView = React.useCallback(() => {
+        void channel.backgroundCurrent().then((result) => {
+            if (result.ok) {
+                setAgentViewReturnId(result.backgroundedSessionId);
+                agentViewOpenSessionRef.current = channel.agentId;
+                setSupervisorOpen(true);
+            }
+        });
+    }, [channel]);
+    /** `/settings` opens the plugin settings screen (issue #165) — like the
+     *  browser, a screen rather than a panel: it owns its own focus, staged
+     *  drafts and keyboard; Chat only opens it. */
+    const [settingsOpen, setSettingsOpen] = React.useState(false);
+    const [workspaceTargets, setWorkspaceTargets] = React.useState([]);
+    const workspaceFlowRequestRef = React.useRef(0);
+    const workspaceFlowAbortRef = React.useRef(null);
+    /** `/preset` agent-preset roster (issue #8): loads async, persists. */
+    const [presetOptions, setPresetOptions] = React.useState([]);
+    /** `/effort` adapter levels: load async before the slider opens. */
+    const [effortOptions, setEffortOptions] = React.useState([]);
+    const [themeName, setTheme] = useTheme();
+    const { rows: terminalRows } = useTerminalSize();
+    const [showAllMessages, setShowAllMessages] = React.useState(false);
+    /** Scope the fold to this question: an aborted ask can promote its queued
+     *  successor without ever publishing an idle (null) snapshot. */
+    const [minimizedQuestionKey, setMinimizedQuestionKey] = React.useState(null);
+    const questionMinimized = questionSnapshot !== null && minimizedQuestionKey === questionSnapshot.key;
+    /** Fold state for the GoalTodoPanel todo section (ctrl/cmd+q or click). */
+    const [todoCollapsed, setTodoCollapsed] = React.useState(false);
+    const [thinkingVisible, setThinkingVisible] = React.useState(true);
+    /** ctrl+r history-search entries (loaded on open, persists). */
+    const [historyEntries, setHistoryEntries] = React.useState([]);
+    const [historyFill, setHistoryFill] = React.useState(null);
+    /** Monotonic token: only the latest rewind decision may land (a slow
+     *  plugin answering after the user moved on must not open a confirm for
+     *  a row they are no longer looking at). */
+    const rewindRequestRef = React.useRef(0);
+    /** /btw side-question overlay: pure UI state — the answer never
+     *  enters the transcript or the session log. */
+    const [btw, setBtw] = React.useState(null);
+    const btwAbortRef = React.useRef(null);
+    const closeBtw = () => {
+        btwAbortRef.current?.abort();
+        btwAbortRef.current = null;
+        setBtw(null);
+    };
+    /** /recap overlay (pi-recap semantics): pure UI state like /btw — the
+     *  summary never enters the transcript or session log; applying the
+     *  proposed title goes through the normal /rename path. `auto` marks the
+     *  recapOnOpen-triggered run (rendered as the dim AutoRecapRow until
+     *  expanded); `expanded` lifts an auto recap into the full RecapPanel;
+     *  `rowsAtTrigger` is the last user-row id when the auto run started —
+     *  a newer user row (the user starts a new message) retires the recap. */
+    const [recap, setRecap] = React.useState(null);
+    const recapAbortRef = React.useRef(null);
+    const closeRecap = () => {
+        recapAbortRef.current?.abort();
+        recapAbortRef.current = null;
+        setRecap(null);
+    };
+    /** /balance report (`BalanceReportRow`): pure UI state like /recap — the
+     *  result never enters the transcript or session log. Clicking the row
+     *  re-queries (refreshing keeps the stale summary visible); a session
+     *  switch retires the report. */
+    const [balance, setBalance] = React.useState(null);
+    const balanceSeqRef = React.useRef(0);
+    const runBalance = React.useCallback(() => {
+        const seq = ++balanceSeqRef.current;
+        setBalance(prev => ({ result: prev?.result ?? null, refreshing: true }));
+        void channel.balanceInfo().then(result => {
+            if (balanceSeqRef.current !== seq)
+                return;
+            setBalance({ result, refreshing: false });
+        });
+    }, [channel]);
+    const balanceSessionId = channel.agentId;
+    React.useEffect(() => {
+        // Retire every in-flight /balance completion from the previous binding;
+        // the balance seam has no UI session id in its readonly DTO.
+        balanceSeqRef.current += 1;
+        setBalance(null);
+    }, [balanceSessionId]);
+    // A side question belongs to its captured session just like a recap. Chat
+    // remains mounted across /resume, so explicitly retire its request/UI when
+    // the binding changes instead of allowing a former conversation to finish.
+    React.useEffect(() => {
+        btwAbortRef.current?.abort();
+        btwAbortRef.current = null;
+        setBtw(null);
+    }, [channel.agentId]);
+    // Auto-recap (`dsh-tui.recapOnOpen`): every time the session switches
+    // (mount = open/resume, rewind/fork included), summarize its tail into
+    // the dim AutoRecapRow. Failures stay silent in auto mode — `/recap`
+    // surfaces them; the summary never enters the transcript or session log.
+    const autoRecapSessionId = channel.agentId;
+    React.useEffect(() => {
+        // A session switch retires the previous recap outright — an old
+        // session's 回顾 has no place above a new conversation.
+        setRecap(null);
+        if (!channel.autoRecapOnOpen)
+            return;
+        // No conversation yet (/new): nothing to recap, don't even fire.
+        if (!channel.rows.some(row => row.kind === 'user' || row.kind === 'assistant'))
+            return;
+        recapAbortRef.current?.abort();
+        const controller = new AbortController();
+        recapAbortRef.current = controller;
+        const lastUserId = channel.rows.filter(row => row.kind === 'user').at(-1)?.id ?? -1;
+        setRecap({ raw: '', summary: '', error: undefined, done: false, titleApplied: false, auto: true, expanded: false, rowsAtTrigger: lastUserId });
+        void channel.recapRecent({
+            signal: controller.signal,
+            onText: delta => setRecap(prev => (prev ? { ...prev, raw: prev.raw + delta } : prev)),
+        }).then(result => {
+            if (controller.signal.aborted)
+                return;
+            setRecap(prev => {
+                if (prev === null || !prev.auto)
+                    return prev;
+                // Auto mode stays quiet on failure (no activity / llm missing / error).
+                if (result.summary === null)
+                    return null;
+                return { ...prev, summary: result.summary, title: result.title, error: result.error, done: true };
+            });
+        }).catch(() => {
+            if (!controller.signal.aborted)
+                setRecap(null);
+        });
+        return () => controller.abort();
+    }, [autoRecapSessionId]);
+    // The user starts a new message → the auto recap has served its purpose
+    // (catching them up) and bows out. A newer user row is the signal; the
+    // assistant's own streamed rows don't count.
+    const lastUserRowId = channel.rows.filter(row => row.kind === 'user').at(-1)?.id ?? -1;
+    React.useEffect(() => {
+        if (recap !== null &&
+            recap.auto &&
+            recap.rowsAtTrigger !== undefined &&
+            lastUserRowId > recap.rowsAtTrigger) {
+            closeRecap();
+        }
+    }, [lastUserRowId, recap]);
+    /**
+     * Session switches that do not go through `/new` (agent-view attach,
+     * backgrounding, `/resume`) remount the transcript tree without resetting
+     * view-local state. Row-id-based UI would keep pointing at rows of the
+     * PREVIOUS session (ids restart at 0 after an adopt), so the new session
+     * renders with stale folds/expansion/selection — the "entered a freshly
+     * dispatched session and it renders wrong" bug. Reset the same set `/new`
+     * resets, plus the search overlay and the side question, and repaint the
+     * transcript from the top.
+     */
+    const repaintTranscript = () => {
+        const ink = instances.get(process.stdout) ?? instances.values().next().value;
+        // Wait one task so React commits the new session's tree before the
+        // scrollback clear repaints (same pattern as `/new`).
+        setTimeout(() => {
+            handle?.scrollTo(0);
+            ink?.clearScrollbackAndRedraw();
+        }, 0);
+    };
+    const lastAgentIdRef = React.useRef(undefined);
+    React.useEffect(() => {
+        const id = channel.agentId;
+        if (lastAgentIdRef.current === undefined) {
+            lastAgentIdRef.current = id;
+            return;
+        }
+        if (lastAgentIdRef.current === id)
+            return;
+        lastAgentIdRef.current = id;
+        setExpanded(false);
+        setExpandedRows(new Set());
+        setSelectedId(null);
+        setSelectionActive(false);
+        setShowAllMessages(false);
+        setLoadedContextOpen(false);
+        setSearchQuery('');
+        setSearchCursor(0);
+        setSearchCount(0);
+        setSearchCurrent(0);
+        closeBtw();
+        repaintTranscript();
+    }, [channel.agentId]); // eslint-disable-line react-hooks/exhaustive-deps
+    /** The session attached when the agent view opened; a close on a
+     *  DIFFERENT session means a switch happened inside the view, and the
+     *  transcript repaint cannot be skipped. */
+    const agentViewOpenSessionRef = React.useRef(undefined);
+    /**
+     * Leaving a whole screen (agent view, browser) remounts the transcript
+     * tree, which would replay the ~3.4s whale opening animation on every
+     * close — competing with resumed or streaming rows for frame budget.
+     * Suppress the intro on those remounts; `/deepseek` re-enables it.
+     */
+    const suppressLogoIntroRef = React.useRef(false);
+    /** Subagent dashboard (Ctrl+A): displays active/completed subagents. */
+    const [subagentDashboardOpen, setSubagentDashboardOpen] = React.useState(false);
+    const [jobsPanelOpen, setJobsPanelOpen] = React.useState(false);
+    // MessageList forwards these open handlers to every memoized row. Their
+    // identities must survive token/metrics updates, including for tool rows.
+    const openJobsPanel = React.useCallback(() => setJobsPanelOpen(true), []);
+    /** Detail view for a specific subagent (opened from dashboard). */
+    const [subagentDetailId, setSubagentDetailId] = React.useState(null);
+    /**
+     * Hidden `/deepseek` easter egg: each invocation bumps this key so the
+     * logo header remounts and replays the whale spout + text shimmer.
+     */
+    const [logoNonce, setLogoNonce] = React.useState(0);
+    React.useEffect(() => () => btwAbortRef.current?.abort(), []);
+    React.useEffect(() => () => recapAbortRef.current?.abort(), []);
+    /**
+     * The trajectory scene (issue #80 evolution). Unlike every other overlay
+     * here it is not a panel but a whole screen: while open, Chat renders the
+     * scene INSTEAD of the conversation (see the early return below) and hands
+     * it the keyboard. Chat itself stays mounted, so scroll position, pickers
+     * and in-flight turn state survive the round trip untouched.
+     */
+    const [sceneOpen, setSceneOpen] = React.useState(false);
+    /**
+     * Close the scene.
+     *
+     * Leaving the alternate screen makes the terminal restore the main buffer;
+     * Ink restores the matching saved frame and diffs any conversation changes
+     * that happened while the scene was open.
+     */
+    const closeScene = React.useCallback(() => {
+        setSceneOpen(false);
+    }, []);
+    /** Open the scene, mark failures seen, and retire the key hint for good. */
+    const openScene = React.useCallback(() => {
+        seenFailuresRef.current = trajectoryRef.current?.counts.errors ?? 0;
+        setTrajectorySeen(previous => {
+            if (!previous)
+                writeTrajectorySeen();
+            return true;
+        });
+        setSceneOpen(true);
+    }, []);
+    /**
+     * Leave the session supervisor for the conversation.
+     *
+     * The one-shot landing preference is written here rather than at boot: a
+     * process that dies before the user ever sees the screen (a config error, a
+     * crash during the first render) must not burn the installation's only
+     * first-launch landing. Writing on the way OUT means "the user has seen it".
+     *
+     * Leaving also honours `/bg`'s return target. `/background` moved the
+     * session the user was in to the background and opened this screen; a plain
+     * Esc out of it re-attaches to that session instead of silently leaving them
+     * on the fresh one, which is what "go back to what I was doing" means. Any
+     * explicit mount inside the screen clears the target first, so this can
+     * never undo a choice the user just made.
+     */
+    const closeHome = React.useCallback(() => {
+        suppressLogoIntroRef.current = true;
+        markHomeSeen();
+        const returnTo = agentViewReturnId;
+        setAgentViewReturnId(undefined);
+        setSupervisorOpen(false);
+        if (returnTo !== undefined && returnTo !== channel.agentId) {
+            void channel.resumeTo(returnTo).then((result) => {
+                if (result.ok)
+                    repaintTranscript();
+            }).catch(() => undefined);
+        }
+    }, [agentViewReturnId, channel, repaintTranscript]);
+    /** The startup summary gives way to transcript rows after the first local command or message. */
+    const loadedContextVisible = channel.rows.length === 0 && channel.loadedContext !== undefined;
+    /** Startup context panel: collapsed by default, toggled with Ctrl+P. */
+    const [loadedContextOpen, setLoadedContextOpen] = React.useState(false);
+    const toggleLoadedContext = React.useCallback(() => {
+        setLoadedContextOpen(previous => !previous);
+    }, []);
+    const renderedLoadedContextOpen = React.useRef(loadedContextOpen);
+    React.useLayoutEffect(() => {
+        if (renderedLoadedContextOpen.current === loadedContextOpen)
+            return;
+        renderedLoadedContextOpen.current = loadedContextOpen;
+        // Reanchor after the new panel geometry commits. Requesting it in the
+        // key handler lets a pending paint consume it on the old tall layout,
+        // leaving the collapsed summary stranded outside the physical viewport.
+        const ink = instances.get(process.stdout) ?? instances.values().next().value;
+        ink?.invalidatePrevFrame();
+        ink?.reanchorViewport();
+    }, [loadedContextOpen]);
+    /**
+     * Click-to-act targets: the Ink instance's hyperlink-open callback (wired
+     * in the effect below) resolves every clickable target the transcript
+     * renders — http(s) links open the browser, `dsh-file:`/`file://` paths
+     * open the file-action menu. `dsh-file:` payloads are RAW display paths
+     * (possibly relative), so they resolve against the CURRENT channel cwd
+     * at click time (read through a ref so this callback keeps a stable
+     * identity — it is threaded into memoized row components).
+     */
+    const cwdRef = React.useRef(channel.cwd);
+    React.useEffect(() => {
+        cwdRef.current = channel.cwd;
+    }, [channel.cwd]);
+    const openFileActions = React.useCallback((rawPath) => {
+        const resolved = resolveTargetPath(rawPath, cwdRef.current);
+        // Whether the target is a directory decides the first menu row's label
+        // ("open file" vs "open folder"). Missing paths count as files.
+        let isDir = false;
+        try {
+            isDir = statSync(resolved).isDirectory();
+        }
+        catch {
+            isDir = false;
+        }
+        dispatchOverlay({ type: 'open', overlay: { kind: 'file-actions', path: resolved, index: 0, isDir } });
+    }, []);
+    /** Run one file-action menu row: 0 = open file, 1 = reveal in file
+     *  manager, 2 = copy absolute path. */
+    const runFileAction = React.useCallback((index, path) => {
+        if (index === 0)
+            openFile(path);
+        else if (index === 1)
+            revealInFileManager(path);
+        else
+            void setClipboard(path);
+    }, []);
+    /** Shared open path for the modal image preview: composer `[Image #N]`
+     *  tokens and transcript thumbnails both land here. */
+    const openImagePreview = React.useCallback((image, title) => {
+        // Snapshot only metadata/facades on an explicit open, not on every streamed
+        // token. Unvisited attachments stay lazy and duplicate image occurrences stay distinct.
+        const gallery = channel.rows.flatMap(row => (row.images ?? []).map(image => ({ image })));
+        let index = gallery.findIndex(entry => entry.image === image);
+        if (index < 0) {
+            index = gallery.length;
+            gallery.push({ image, title });
+        }
+        dispatchOverlay({
+            type: 'open',
+            overlay: { kind: 'image-preview', image, gallery, index, ...(title === undefined ? {} : { title }) },
+        });
+    }, [channel]);
+    // Agent-binding generation is monotonic across every agent replacement
+    // and bumps before the replacement emit, closing the ABA hole where a
+    // resumed session reuses the same id. Partial test/embed channels fall
+    // back to staged-image generation.
+    const previewBindingGeneration = channel.agentBindingGeneration
+        ?? channel.stagedImageGeneration?.()
+        ?? 0;
+    const previewGenerationRef = React.useRef(previewBindingGeneration);
+    const imagePreviewOwned = previewGenerationRef.current === previewBindingGeneration;
+    React.useEffect(() => {
+        if (previewGenerationRef.current === previewBindingGeneration)
+            return;
+        previewGenerationRef.current = previewBindingGeneration;
+        dispatchOverlay({ type: 'close-if', kind: 'image-preview' });
+    }, [previewBindingGeneration]);
+    // A questionnaire/approval/plugin dialog owns the keyboard while pending
+    // (their guard runs BEFORE the overlay key chain), so a preview left open
+    // underneath would be visually on top yet key-dead. Close it instead.
+    const previewBlocked = questionSnapshot !== null || approvalSnapshot !== null || dialogSnapshot !== null;
+    React.useEffect(() => {
+        if (overlay.kind === 'image-preview' &&
+            previewBlocked) {
+            dispatchOverlay({ type: 'close-if', kind: 'image-preview' });
+        }
+    }, [overlay.kind, previewBlocked]);
+    // Caret-driven preview (Grok Build's chip peek): while the composer caret
+    // sits on a staged `[Image #N]` — at its start, the token inverted — the
+    // same card shows over the transcript, and it goes away when the caret
+    // leaves (the cell just after the token is not "on" it). It is
+    // derived state, not an overlay: the prompt keeps the keyboard, so ←/→
+    // walk from image to image with the card following. Esc (or a click
+    // outside the card) dismisses it for THIS token until the caret leaves and
+    // comes back; a click on the token always shows it again.
+    const [caretPreview, setCaretPreview] = React.useState(null);
+    const [peekSuppressed, setPeekSuppressed] = React.useState(null);
+    const handleCaretImage = React.useCallback((image, title, reason) => {
+        if (image === undefined) {
+            setCaretPreview(null);
+            setPeekSuppressed(null);
+            return;
+        }
+        setCaretPreview({ image, ...(title === undefined ? {} : { title }) });
+        const key = peekKey(image, title);
+        setPeekSuppressed(current => reason === 'click' || current !== key ? null : current);
+    }, []);
+    const peekPreview = !previewBlocked && overlay.kind === 'none' && caretPreview !== null
+        && peekSuppressed !== peekKey(caretPreview.image, caretPreview.title)
+        ? caretPreview
+        : null;
+    /** Esc / click-outside on the peek: dismissed for this token until the
+     *  caret leaves it. PromptInput's Esc arm calls this first — its listener
+     *  runs before Chat's and the prompt stays live under a peek. */
+    const dismissPeek = () => {
+        if (peekPreview !== null)
+            setPeekSuppressed(peekKey(peekPreview.image, peekPreview.title));
+    };
+    /** The card on screen, if any: the modal overlay first, else the peek. */
+    const activePreview = !previewBlocked && overlay.kind === 'image-preview'
+        ? { image: overlay.image, ...(overlay.title === undefined ? {} : { title: overlay.title }), peek: false }
+        : peekPreview !== null
+            ? { ...peekPreview, peek: true }
+            : null;
+    const handleOpenTarget = React.useCallback((url) => {
+        const classification = classifyOpenTarget(url);
+        if (classification.kind === 'file-actions') {
+            openFileActions(classification.path);
+            return;
+        }
+        if (classification.kind === 'external') {
+            openExternal(url);
+            return;
+        }
+        // Non-http(s) schemes from model/plugin-shaped links are not handed to
+        // the OS handler — see urlGuard.ts. Silently ignored: a toast needs
+        // channel state the Ink click path does not carry.
+    }, [openFileActions]);
+    // Wire the click-to-open callback into the Ink instance (the field is
+    // otherwise never set — clicking links was a no-op). Re-wired whenever
+    // the handler changes (cwd moves), cleared on unmount.
+    React.useEffect(() => {
+        const ink = instances.get(process.stdout) ?? instances.values().next().value;
+        if (ink)
+            ink.onHyperlinkClick = handleOpenTarget;
+        return () => {
+            const current = instances.get(process.stdout) ?? instances.values().next().value;
+            if (current)
+                current.onHyperlinkClick = undefined;
+        };
+    }, [handleOpenTarget]);
+    /** `/` transcript search (less-style incsearch).
+     *  Only the bar's open/closed mode lives in `overlay`; the query and match
+     *  counters persist past the bar closing so n/N keep walking the matches. */
+    const searchActive = overlay.kind === 'search';
+    const [searchQuery, setSearchQuery] = React.useState('');
+    const [searchCursor, setSearchCursor] = React.useState(0);
+    const [searchCount, setSearchCount] = React.useState(0);
+    const [searchCurrent, setSearchCurrent] = React.useState(0);
+    const searchAnchorRef = React.useRef(0);
+    const rowRefsRef = React.useRef(new Map());
+    const { setQuery: setHighlight } = useSearchHighlight();
+    // Sticky (pinned-to-bottom) scroll state, subscribed imperatively so
+    // wheel events don't re-render React — only the header/pill flip.
+    // Deliberately KEPT on useSyncExternalStore despite the SyncLane wakeup
+    // cost: the renderer's at-bottom re-pin flips sticky WITHOUT firing the
+    // scroll subscribers (see ScrollBox's subscribe doc), so only uSES's
+    // every-render getSnapshot check picks that flip up — a pure
+    // notification-driven subscription misses it and the new-message pill
+    // stops reflecting reality (repro-pill). Wheel cadence is an
+    // interaction-rate source (not streaming-rate), the streaming-side
+    // #185 sources are all Default-lane now, and the overflow guard
+    // backstops the residue.
+    const isSticky = React.useSyncExternalStore(cb => (handle ? handle.subscribe(cb) : () => { }), () => (handle ? handle.isSticky() : true));
+    // Whale idle gate: the settled header scrolls away with the transcript,
+    // and the idle planner is worth nothing the moment its art leaves the
+    // viewport — pause it there (timers cleared, the resting pose's cached
+    // rows stay painted so scroll geometry never shifts) and re-arm a fresh
+    // cycle when the user scrolls back to the top. Same uSES rationale as
+    // isSticky above: the renderer's sticky re-pin doesn't fire scroll
+    // subscribers, only the every-render snapshot check picks it up.
+    const WHALE_ART_CUTOFF_ROWS = 16; // marginTop + the 13-row whale art
+    const whaleArtVisible = React.useSyncExternalStore(cb => (handle ? handle.subscribe(cb) : () => { }), () => {
+        if (!handle)
+            return true;
+        // A transcript that fits the viewport always shows the header.
+        if (handle.getScrollHeight() <= handle.getViewportHeight())
+            return true;
+        // Visible while the art block intersects the viewport. A sticky bottom
+        // pin with an overflow smaller than the art's height still leaves the
+        // art on screen — visibility, not pin state, decides whether the idle
+        // planner earns its keep.
+        return handle.getScrollTop() < WHALE_ART_CUTOFF_ROWS;
+    });
+    const subscribeTooltipInvalidation = React.useCallback((listener) => (handle ? handle.subscribe(listener) : () => { }), [handle]);
+    // "N new messages" pill: new rows whose top edge is still BELOW the
+    // viewport bottom. The count decrements as the user scrolls down through
+    // them and hits 0 (pill hides) once every new row has been on screen —
+    // no need to wait for the exact-bottom sticky restore. Chat anchors the
+    // "seen up to" point by ROW ID (stable across loadOlder prepends, unlike
+    // a rows.length index); MessageList owns the row offsets, so it computes
+    // how many rows past that anchor lie below the viewport and reports it.
+    const lastSeenRowIdRef = React.useRef(null);
+    const [unseenCount, setUnseenCount] = React.useState(0);
+    React.useEffect(() => {
+        if (isSticky) {
+            lastSeenRowIdRef.current = null;
+            setUnseenCount(0);
+        }
+        else if (lastSeenRowIdRef.current === null) {
+            lastSeenRowIdRef.current = channel.rows.length
+                ? channel.rows[channel.rows.length - 1].id
+                : -1;
+        }
+    }, [isSticky, channel.rows]);
+    // The pill shows whenever the view is off the bottom (one-click return
+    // home): with unseen rows it counts them, otherwise it is the plain
+    // "return to bottom" affordance (Enter/End/click all land it).
+    const showPill = !isSticky;
+    // Idle Ctrl+C: first press arms an exit, second press exits. Under
+    // Windows ConPTY the key
+    // arrives as stdin data (key.ctrl && input === 'c') — the useInput
+    // branch below is the only path; SIGINT is not emitted.
+    const exitPendingRef = React.useRef(false);
+    const exitTimerRef = React.useRef(null);
+    // Live view into the prompt's text for the Ctrl+C rule (clears text when
+    // non-empty; the double-press exit only arms on an empty input).
+    const ownPromptControllerRef = React.useRef(null);
+    const promptControllerRef = promptControllerRefProp ?? ownPromptControllerRef;
+    /**
+     * Owner of the unsent draft. Every screen this component renders INSTEAD of
+     * the conversation (the session screen, the tree, settings, the jobs and
+     * subagent panels, the trajectory scene) unmounts the composer, and the
+     * composer keeps its text in local state — so without this the half-written
+     * prompt died on the way in. The slot lives here, outlives that unmount, and
+     * is dropped the moment the attached session changes so no draft can follow
+     * the user into a different conversation.
+     */
+    const promptDraftRef = React.useRef({ current: null });
+    /**
+     * Latest channel for the unmount release below: that effect must not re-run
+     * on a channel identity change, yet its cleanup must release against the
+     * channel of the last render.
+     */
+    const channelRef = React.useRef(channel);
+    channelRef.current = channel;
+    /**
+     * Release the staged images a WAITING snapshot alone owns.
+     *
+     * While a draft waits in the slot for the composer to remount, the snapshot
+     * is the only owner of the capabilities behind its `[Image #N]` tokens. If
+     * Chat itself goes away first (leaving an early-return screen by exiting the
+     * TUI), nothing would ever restore or discard them — the session's
+     * 128-entry FIFO would evict live entries instead. The `hasStagedImage`
+     * guard keeps a capability the channel already recycled a no-op; both calls
+     * are idempotent.
+     *
+     * Scope, deliberately narrow (review round 7): a capability a QUEUED message
+     * still references (`channel.pending`) is never revoked here. The real
+     * double-hold path is paste an image → queue the draft with Tab while the
+     * model works → recall that line from input history with ↑ (same stageId
+     * rebound to the draft) → park the composer. Delivery resolves its refs from
+     * the enqueue-time capture, so a late revoke would only bite a host that
+     * re-resolves them afterwards — this keeps the rule identical to
+     * `stageIdIsRetained` instead of relying on that.
+     *
+     * A composer that is still MOUNTED when Chat unmounts is NOT covered: React
+     * runs this parent cleanup BEFORE the child's, so the child then writes its
+     * draft into the now-dead ref and those ids ride the channel's lifetime out
+     * (the #942 review's remaining P2). Neither unmount path loses anything
+     * user-visible — the channel dies with them.
+     */
+    React.useEffect(() => {
+        return () => {
+            const snapshot = promptDraftRef.current.current;
+            promptDraftRef.current.current = null;
+            if (snapshot === null)
+                return;
+            const queued = new Set();
+            for (const item of channelRef.current.pending) {
+                // `?? []`: a foreign/embedded host may hand us a pending entry without
+                // images, and a throw inside an unmount cleanup escapes into the exit
+                // path — every other reader of this field guards it the same way.
+                for (const image of item.images ?? [])
+                    queued.add(image.stageId);
+            }
+            for (const [, stageId] of snapshot.images) {
+                if (queued.has(stageId))
+                    continue;
+                if (channelRef.current.hasStagedImage?.(stageId) === true) {
+                    channelRef.current.discardStagedImage(stageId);
+                }
+            }
+        };
+    }, []);
+    const draftSessionId = channel.agentId;
+    /** Session the effect below last reconciled against; a change is a switch. */
+    const draftSessionRef = React.useRef(draftSessionId);
+    /**
+     * The session a fill Chat itself requested belongs to, if one is in flight.
+     *
+     * A rewind's restored message arrives in the same commit that replaces the
+     * session, and it belongs to the NEW binding — the user picked it. The
+     * composer cannot tell, so Chat says so here, at the two call sites that ask
+     * for a fill.
+     *
+     * Keyed by the session id rather than a bare flag, so it can only ever excuse
+     * the switch it was written for. Do NOT clear it when the composer consumes
+     * the fill: a child's layout effects run before the parent's, so the fill is
+     * consumed in the very commit this effect judges, and clearing it there would
+     * wipe the message the user just got back.
+     */
+    const pendingFillRef = React.useRef(null);
+    /**
+     * Drop the composer's text when the session underneath it is replaced.
+     *
+     * A LAYOUT effect, not a passive one: the clear has to land in the commit
+     * that swaps the session. A passive effect is flushed later, and anything
+     * typed in between (the tree's hand-off, a fast user) would be wiped with the
+     * old conversation's text. Which DRAFT the slot keeps is a separate question,
+     * answered by the snapshot's owner fields.
+     */
+    React.useLayoutEffect(() => {
+        if (draftSessionRef.current === draftSessionId)
+            return;
+        draftSessionRef.current = draftSessionId;
+        // A stored draft can only belong to the conversation being replaced: the
+        // composer is the one that writes it, and it writes it on the way out.
+        promptDraftRef.current.current = null;
+        if (pendingFillRef.current === draftSessionId) {
+            pendingFillRef.current = null;
+            return;
+        }
+        promptControllerRef.current?.clear();
+    }, [draftSessionId]);
+    const previewGallery = activePreview === null ? [] : activePreview.peek
+        ? promptControllerRef.current?.previewImages?.() ?? [activePreview]
+        : overlay.kind === 'image-preview' ? overlay.gallery ?? [activePreview] : [];
+    // Peek entries are rebuilt from the prompt every render: match by
+    // attachment id + token title, not facade identity.
+    const previewIndex = activePreview?.peek
+        ? previewGallery.findIndex(entry => entry.image.id === activePreview.image.id && entry.title === activePreview.title)
+        : overlay.kind === 'image-preview' ? overlay.index ?? 0 : -1;
+    const stepPreview = (delta) => {
+        if (!activePreview?.peek) {
+            dispatchOverlay({ type: 'image-step', delta });
+            return;
+        }
+        const index = previewIndex + delta;
+        const entry = previewGallery[index];
+        if (!entry)
+            return;
+        // A gallery click promotes the caret peek to a modal without moving or
+        // editing the draft. Suppress the original peek so Esc really closes it.
+        setPeekSuppressed(peekKey(activePreview.image, activePreview.title));
+        dispatchOverlay({ type: 'open', overlay: { kind: 'image-preview', ...entry, gallery: previewGallery, index } });
+    };
+    // Publish the external-injection controller (dsh.nvim etc.) every render so
+    // the adapter-owned socket can append to the prompt and submit. `submit`
+    // mirrors an Enter press: `channel.submit` routes through the DSH inbox
+    // (queued after the current turn while working), then the input is cleared.
+    React.useEffect(() => {
+        if (!injectControllerRef)
+            return;
+        injectControllerRef.current = {
+            append: (text) => {
+                promptControllerRef.current?.append(text);
+            },
+            submit: () => {
+                const controller = promptControllerRef.current;
+                if (!controller)
+                    return;
+                const text = controller.append('').trim();
+                if (text === '')
+                    return;
+                channel.submit(text);
+                controller.clear();
+                channel.notify(channel.working ? t('input-sent-after-turn') : t('input-injected'), { timeoutMs: 2500 });
+            },
+        };
+        return () => {
+            injectControllerRef.current = null;
+        };
+    });
+    const requestExit = () => {
+        if (exitPendingRef.current) {
+            onExit();
+        }
+        else {
+            exitPendingRef.current = true;
+            channel.notify(t('exit-press-again'));
+            exitTimerRef.current = setTimeout(() => {
+                exitPendingRef.current = false;
+            }, 3000);
+        }
+    };
+    React.useEffect(() => {
+        return () => {
+            if (exitTimerRef.current)
+                clearTimeout(exitTimerRef.current);
+        };
+    }, []);
+    // Spinner timing refs, fed from channel state each render (the spinner
+    // only mounts while working, so values are stable for the mount).
+    const responseLengthRef = React.useRef(0);
+    const uploadTokensRef = React.useRef(0);
+    const loadingStartTimeRef = React.useRef(0);
+    const totalPausedMsRef = React.useRef(0);
+    const pauseStartTimeRef = React.useRef(null);
+    responseLengthRef.current = channel.responseChars;
+    // Most recent request's real upload (input + cache read/write occupy the
+    // wire exactly like the context window); 0 until the first usage event.
+    const lastUploadTokens = channel.lastUsage === undefined
+        ? 0
+        : channel.lastUsage.input + channel.lastUsage.cacheRead + channel.lastUsage.cacheWrite;
+    uploadTokensRef.current = lastUploadTokens;
+    loadingStartTimeRef.current = channel.turnStart;
+    const thinkingStatus = useThinkingStatus(channel.spinnerMode === 'thinking');
+    // Terminal tab title: the session
+    // title when set, else "dsh-TUI"; a `⠂/⠐` spinner prefix while a turn is
+    // working (960ms cadence, only while the terminal is focused), a static
+    // `✦` otherwise. dsh-TUI brands the idle prefix with the DeepSeek whale.
+    const [titleFrame, setTitleFrame] = React.useState(0);
+    const terminalFocused = useTerminalFocus();
+    // Mouse text selection auto-copy: active only in
+    // fullscreen (<AlternateScreen> supplies mouse tracking); a no-op
+    // subscription in inline mode, where selection belongs to the terminal.
+    // The copy clears the highlight and posts a transient notification.
+    // Smart migration hint (product ask): ~12s after mount, one background
+    // pass over the foreign-agent stores; when a source was active inside the
+    // 20-minute window, surface the user's own wording once per session. The
+    // file-level mtime scan is the counter's walk shape (sub-second) and runs
+    // off the render path; failures read as "no data" and stay silent.
+    const migrateHintShownRef = React.useRef(false);
+    React.useEffect(() => {
+        if (migrateHintShownRef.current)
+            return;
+        const timer = setTimeout(() => {
+            migrateHintShownRef.current = true;
+            void (async () => {
+                const newest = await new Promise(resolve => {
+                    setImmediate(() => resolve(collectActivitySamples(MIGRATION_ADAPTERS, adapter => MIGRATE_SCAN_SPECS[adapter.id])));
+                });
+                const top = recentAgentsFrom(newest, Date.now())[0];
+                if (top !== undefined) {
+                    channel.notify(t('migrate-hint-notify', { agent: top.label }), { timeoutMs: 10000 });
+                    // PRD #4: while the hint is up, a bare Enter (empty prompt, no
+                    // overlay) jumps into the picker with this source pre-checked;
+                    // the global key layer below consumes it, anything else disarms.
+                    setMigrateHintAgent(top.agentId);
+                    setTimeout(() => setMigrateHintAgent(current => current === top.agentId ? null : current), 10_000);
+                }
+            })();
+        }, 12_000);
+        return () => clearTimeout(timer);
+    }, [channel]);
+    useCopyOnSelect(text => channel.notify(t('copied-chars', { n: text.length }), { timeoutMs: 1500 }), 
+    // Stale-selection refusal: the highlighted rows were replaced in place
+    // (streaming overwrite), so nothing was copied — say why instead of
+    // letting the highlight vanish silently.
+    () => channel.notify(t('copy-refused-stale'), { timeoutMs: 2500 }));
+    const { clearSelection: clearMouseSelection, hasSelection: hasMouseSelection } = useSelection();
+    React.useEffect(() => {
+        if (!channel.working || !terminalFocused)
+            return;
+        const interval = setInterval(() => {
+            setTitleFrame(f => (f + 1) % TITLE_SPINNER_FRAMES.length);
+        }, 960);
+        return () => { clearInterval(interval); };
+    }, [channel.working, terminalFocused]);
+    const titlePrefix = channel.working
+        ? (TITLE_SPINNER_FRAMES[titleFrame] ?? '✦')
+        : '✦';
+    useTerminalTitle(`${titlePrefix} 🐋 ${channel.sessionTitle}`);
+    const handleWorkspaceResult = (result) => {
+        workspaceFlowAbortRef.current = null;
+        if (result.kind === 'target') {
+            dispatchOverlay({ type: 'close-if', kind: 'workspace-flow' });
+            void channel.switchWorkspace(result.target);
+            return;
+        }
+        if (result.choices.length === 0) {
+            dispatchOverlay({ type: 'close-if', kind: 'workspace-flow' });
+            channel.notify(t('workspace-command-empty'));
+            return;
+        }
+        // open-if: 'workspace-flow' stays allowed so an in-flow action can
+        // transition to its next stage; a picker the user opened after leaving
+        // the menu wins over a late command result.
+        dispatchOverlay({
+            type: 'open-if',
+            overlay: { kind: 'workspace-flow', flow: result, index: 0, busy: false, input: null },
+            when: ['none', 'workspace-flow'],
+        });
+    };
+    const runWorkspaceFlowAction = (action) => {
+        const request = ++workspaceFlowRequestRef.current;
+        const controller = new AbortController();
+        workspaceFlowAbortRef.current = controller;
+        dispatchOverlay({ type: 'flow-busy', busy: true });
+        void Promise.resolve()
+            .then(() => action(controller.signal))
+            .then((result) => {
+            if (request === workspaceFlowRequestRef.current)
+                handleWorkspaceResult(result);
+        })
+            .catch((error) => {
+            if (request !== workspaceFlowRequestRef.current)
+                return;
+            workspaceFlowAbortRef.current = null;
+            dispatchOverlay({ type: 'flow-busy', busy: false });
+            channel.notify(t('workspace-command-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'error', timeoutMs: 8000 });
+        });
+    };
+    /** Bare `/workspace` menu rows: built-in subcommands first, then the
+     *  dynamically registered extensions (same reserved-name filter the Tab
+     *  completion applies). Recomputed per render — the extension list is
+     *  live. */
+    const workspaceMenuOptions = [
+        { id: 'resume', label: 'resume', description: t('workspace-menu-resume-desc') },
+        { id: 'rename', label: 'rename', description: t('workspace-menu-rename-desc') },
+        { id: 'open', label: 'open', description: t('workspace-menu-open-desc') },
+        // Optional call: verify/repro scripts and embedders stub the channel
+        // without the workspace-commands API — render must not throw for them
+        // (a thrown render unmounts the whole Ink root).
+        ...(channel.workspaceCommands?.() ?? [])
+            .filter(command => !['resume', 'rename', 'open'].includes(command.name.toLowerCase()))
+            .map(command => ({ id: command.name, label: command.name, description: command.description })),
+    ];
+    const openWorkspaceTarget = (reference) => {
+        void channel.resolveWorkspace(reference).then((target) => {
+            if (target === undefined) {
+                channel.notify(t('workspace-uri-invalid', { uri: reference }), { color: 'error', timeoutMs: 8000 });
+                return;
+            }
+            void channel.switchWorkspace(target);
+        }).catch((error) => {
+            channel.notify(t('workspace-uri-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'error', timeoutMs: 8000 });
+        });
+    };
+    const openWorkspaceResume = () => {
+        void channel.listWorkspaces().then((targets) => {
+            if (targets.length === 0) {
+                channel.notify(t('workspace-none'));
+                return;
+            }
+            setWorkspaceTargets(targets);
+            // open-if: the listing is async — whatever the user opened meanwhile wins.
+            dispatchOverlay({
+                type: 'open-if',
+                overlay: {
+                    kind: 'workspace-picker',
+                    index: Math.max(0, targets.findIndex(target => target.cwd === channel.cwd)),
+                },
+                when: ['none'],
+            });
+        }).catch((error) => {
+            channel.notify(t('workspace-list-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'error' });
+        });
+    };
+    /**
+     * Run one /workspace menu row (Enter path, shared with the mouse click):
+     * built-ins dispatch locally, extension commands go through the channel.
+     */
+    const runWorkspaceMenuOption = (option) => {
+        dispatchOverlay({ type: 'close-if', kind: 'workspace-menu' });
+        if (option === undefined)
+            return;
+        if (option.id === 'resume') {
+            openWorkspaceResume();
+        }
+        else if (option.id === 'rename') {
+            channel.notify(t('workspace-rename-usage'));
+        }
+        else if (option.id === 'open') {
+            channel.notify(t('workspace-open-usage'));
+        }
+        else {
+            void channel.runWorkspaceCommand(option.id, '').then((result) => {
+                if (result !== undefined)
+                    handleWorkspaceResult(result);
+            }).catch((error) => {
+                channel.notify(t('workspace-command-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'error', timeoutMs: 8000 });
+            });
+        }
+    };
+    /**
+     * Dispatch a slash command; false lets the input flow to the model.
+     * Built-in names run the local switch; anything registered by a DSH
+     * plugin (plan/goal/…) dispatches through the command registry, whose
+     * result text lands as a notification. `rawInput` carries the text after
+     * the command name (`/plan off` → ` off`).
+     */
+    const runExternalCommand = (name, rawInput, images = []) => {
+        const originAgentBinding = channel.agentBindingGeneration;
+        return channel.runExternalCommandOutcome(name, rawInput, images).then((outcome) => {
+            if (channel.agentBindingGeneration !== originAgentBinding)
+                return false;
+            if (outcome === undefined) {
+                channel.notify(t('command-not-found', { name }), { color: 'error' });
+                return false;
+            }
+            const cleaned = cleanRenderText(outcome.text, COMMAND_RESULT_CELLS);
+            if (cleaned !== '') {
+                channel.notify(cleaned, outcome.kind === 'error' ? { color: 'error' } : undefined);
+            }
+            return outcome.consumeDraft;
+        }).catch((error) => {
+            if (channel.agentBindingGeneration !== originAgentBinding)
+                return false;
+            const detail = cleanCommandError(error);
+            if (detail !== '')
+                channel.notify(detail, { color: 'error' });
+            return false;
+        });
+    };
+    /** Route every permission switch through the official command path when it
+     *  is registered; otherwise fall back to the permission-presets service's
+     *  own write path (the same handler the command drives) so the picker and
+     *  typed `/permission <preset>` keep working on compositions where the
+     *  command row never reaches this agent's registry. The fallback carries no
+     *  images: it is not a registry command and has no image grammar. */
+    const runPermissionCommand = (rawInput, images = []) => {
+        const originAgentBinding = channel.agentBindingGeneration;
+        const mounted = channel.commandList.some(command => command.external && command.name === 'permission');
+        const run = mounted
+            ? channel.runExternalCommandOutcome('permission', rawInput, images)
+            : channel.runPermissionPreset(rawInput.trim()).then(ok => ok ? { kind: 'success', text: '', consumeDraft: true } : undefined);
+        return run.then((outcome) => {
+            if (channel.agentBindingGeneration !== originAgentBinding)
+                return false;
+            if (outcome === undefined) {
+                channel.notify(t('command-not-found', { name: 'permission' }), { color: 'error' });
+                return false;
+            }
+            const cleaned = cleanRenderText(outcome.text, COMMAND_RESULT_CELLS);
+            if (cleaned !== '') {
+                channel.notify(cleaned, outcome.kind === 'error' ? { color: 'error' } : undefined);
+            }
+            return outcome.consumeDraft;
+        }).catch((error) => {
+            if (channel.agentBindingGeneration !== originAgentBinding)
+                return false;
+            const detail = cleanCommandError(error);
+            if (detail !== '')
+                channel.notify(detail, { color: 'error' });
+            return false;
+        });
+    };
+    /** Hot-swap the UI language (`/lang <id>` and the LangPicker both land
+     *  here): persist to ~/.dsh-tui/lang.json and mirror into the dsh-tui
+     *  settings namespace when it is served (best effort). */
+    const applyLang = (lang) => {
+        const ok = writeLangPref(lang);
+        setLang(lang);
+        const settingsHost = channel.settingsHost();
+        const tuiView = settingsHost?.listNamespaces().find(entry => entry.ns === 'dsh-tui');
+        if (settingsHost !== undefined && tuiView !== undefined) {
+            void settingsHost
+                .write('dsh-tui', [{ op: 'set', path: ['lang'], value: lang }], tuiView.revision)
+                .catch(() => { });
+        }
+        channel.notify(ok ? t('lang-switched', { lang }) : t('lang-switch-failed', { lang }), { color: ok ? 'success' : 'error' });
+    };
+    /** Localized label of one /reload surface, for the change report. */
+    const reloadKindLabel = (kind) => {
+        switch (kind) {
+            case 'theme': return t('reload-kind-theme');
+            case 'lang': return t('reload-kind-lang');
+            case 'preset': return t('reload-kind-preset');
+            case 'model': return t('reload-kind-model');
+            case 'activity': return t('reload-kind-activity');
+        }
+    };
+    /** Collect picker rows off the current turn: the scan is synchronous FS
+     *  work (name-only walk + per-file stat), so it is deferred by one macrotask
+     *  to let the overlay paint its loading state first. */
+    const collectMigrateRows = () => new Promise(resolve => {
+        setImmediate(() => resolve(collectMigratePickerRows(Date.now())));
+    });
+    /** Run `dsh-tui migrate <args>` in a child process through the package
+     *  bin; resolves with the exit code and the combined output. Uses the
+     *  shared no-throw runner (bounded capture, timeout, windowsHide): a wedged
+     *  child would otherwise hang the sequential per-source loop forever. */
+    const runMigrateChild = async (parts) => {
+        const { dirname } = await import('node:path');
+        const { fileURLToPath } = await import('node:url');
+        const { resolveOwnBin } = await import('../dsh-adapter/migrate/bin-path.js');
+        // This file sits at a different depth per layout (src/screens vs
+        // lib/types/screens), so the bin resolves by upward probe — see
+        // bin-path.ts; a fixed dirname count fails on real installs.
+        const bin = resolveOwnBin(dirname(fileURLToPath(import.meta.url)));
+        if (bin === undefined) {
+            channel.notify(t('migrate-spawn-failed'), { color: 'error', timeoutMs: 8000 });
+            return { code: -1, out: '' };
+        }
+        const result = await execFileNoThrow(process.execPath, [bin, 'migrate', ...parts], {
+            timeout: MIGRATE_CHILD_TIMEOUT_MS,
+        });
+        // A killed child reports `code: null` and whatever it managed to print; put
+        // the reason on the record so the transcript does not read as a silent
+        // failure. Nothing at all (no code, no output) means it never really ran.
+        if (result.code === null) {
+            return {
+                code: null,
+                out: `${result.stdout}${result.stderr}${t('migrate-child-timeout', { minutes: MIGRATE_CHILD_TIMEOUT_MS / 60_000 })}\n`,
+            };
+        }
+        if (result.code === 1 && result.stdout === '' && result.stderr === '') {
+            channel.notify(t('migrate-spawn-failed'), { color: 'error', timeoutMs: 8000 });
+        }
+        // stdout carries the per-source report, stderr the usage/error lines;
+        // both belong in the /migrate transcript row.
+        return { code: result.code, out: `${result.stdout}${result.stderr}` };
+    };
+    /** Orchestrate the confirmation layer's confirmed rows (PRD #3): one child
+     *  per source, sequential; per-source progress notifications (throttled by
+     *  the source boundary — no intra-source spam), real per-source counters
+     *  parsed from each child's report, and a final summary that NEVER claims
+     *  success for a source that did not run (the P2 fix). */
+    const spawnMigrateSources = (rows, dryRun) => {
+        const allOut = [];
+        let failures = 0;
+        void (async () => {
+            for (let i = 0; i < rows.length; i++) {
+                const row = rows[i];
+                channel.notify(t(dryRun ? 'migrate-previewing-source' : 'migrate-importing-source', { label: row.label, i: i + 1, n: rows.length }), { timeoutMs: 4000 });
+                const { code, out } = await runMigrateChild(dryRun ? [row.agentId, '--dry-run'] : [row.agentId]);
+                allOut.push(...out.split('\n').map(line => cleanRenderText(line, 400)).filter(Boolean));
+                if (code !== 0)
+                    failures += 1;
+                // Per-source real counters straight from the child's report line.
+                const summary = parseImportSummary(out).find(entry => entry.agentId === row.agentId);
+                if (!dryRun && summary !== undefined) {
+                    channel.notify(t('migrate-source-done', { label: row.label, imported: summary.imported, existing: summary.existing }), { timeoutMs: 6000 });
+                }
+            }
+            // The transcript row is this run's record. When a source failed AND no
+            // child output was captured at all (killed by the timeout, or never
+            // spawned), the success wording would contradict the notification right
+            // above it — report the failure here too.
+            const fallbackLine = failures > 0
+                ? t('migrate-failed', { n: failures })
+                : t(dryRun ? 'migrate-all-previewed' : 'migrate-all-done', { n: rows.length });
+            channel.pushLocal('/migrate', allOut.length > 0 ? allOut : [fallbackLine]);
+            channel.notify(failures === 0
+                ? t(dryRun ? 'migrate-all-previewed' : 'migrate-all-done', { n: rows.length })
+                : t('migrate-failed', { n: failures }), failures === 0 ? { timeoutMs: 6000 } : { color: 'error', timeoutMs: 10000 });
+        })();
+    };
+    const runCommand = (name, rawInput = '', images = []) => {
+        switch (name) {
+            case 'activity': {
+                // Ported from the pi working-activity extension: bare `/activity`
+                // opens the interactive indicator picker; `/activity frames <name>`
+                // switches directly; `/activity frames` lists presets; `/activity
+                // status` shows the current choice. The choice persists to
+                // ~/.dsh-tui/working-activity.json and survives restarts.
+                const parts = rawInput.trim().split(/\s+/).filter(Boolean);
+                if (parts[0] === 'status') {
+                    setHelpOpen(false);
+                    channel.pushLocal('/activity', [
+                        t('activity-current-preset', { name: channel.activityFrames ?? 'moon8' }),
+                        t('activity-switch-hint'),
+                        t('activity-persist-hint'),
+                    ]);
+                    return true;
+                }
+                if (parts[0] === 'frames') {
+                    setHelpOpen(false);
+                    if (parts[1]) {
+                        channel.setActivityFrames(parts[1].toLowerCase());
+                        return true;
+                    }
+                    const current = channel.activityFrames;
+                    channel.pushLocal('/activity', [
+                        t('activity-current-direct', { name: current ?? 'moon8' }),
+                        ...PRESET_NAMES.map(name => `${name.padEnd(10)} ${name === 'random' ? t('activity-random-each') : FRAME_PRESETS[name].frames.slice(0, 5).join(' ')}${name === current ? t('activity-current-marker') : ''}`),
+                    ]);
+                    return true;
+                }
+                if (parts.length > 0) {
+                    channel.notify(t('activity-usage'), { color: 'warning' });
+                    return true;
+                }
+                setHelpOpen(false);
+                dispatchOverlay({
+                    type: 'open',
+                    overlay: {
+                        kind: 'activity',
+                        index: Math.max(0, PRESET_NAMES.indexOf(channel.activityFrames ?? 'random')),
+                    },
+                });
+                return true;
+            }
+            case 'preset': {
+                // issue #8: bare `/preset` opens the roster picker (standard/ptc/
+                // minimal/cordis plus any user-authored presets); `/preset <id>`
+                // switches directly; `/preset status` shows the current choice. A
+                // blank session swaps composition in place (official blank-only
+                // rule); a started session is locked and the choice persists as the
+                // default for future sessions (~/.dsh-tui/agent-preset.json).
+                const parts = rawInput.trim().split(/\s+/).filter(Boolean);
+                if (parts[0] === 'status') {
+                    setHelpOpen(false);
+                    channel.pushLocal('/preset', [
+                        t('preset-current', { name: channel.agentPreset ?? t('preset-roster-missing') }),
+                        t('preset-switch-hint'),
+                        t('preset-persist-hint'),
+                        t('preset-lock-hint'),
+                    ]);
+                    return true;
+                }
+                if (parts.length > 0) {
+                    setHelpOpen(false);
+                    void channel.switchPreset(parts[0]);
+                    return true;
+                }
+                setHelpOpen(false);
+                // The picker opens immediately over the cached roster (no loading
+                // pane — deliberate contrast with /model); the fresh list lands with
+                // the authoritative focus. Both loader writes are kind-guarded, so a
+                // picker the user already left is not resurrected or re-focused.
+                dispatchOverlay({
+                    type: 'open',
+                    overlay: {
+                        kind: 'preset',
+                        index: Math.max(0, presetOptions.findIndex(preset => preset.id === channel.agentPreset)),
+                    },
+                });
+                void channel.listPresets().then((list) => {
+                    if (list.length === 0) {
+                        dispatchOverlay({ type: 'close-if', kind: 'preset' });
+                        channel.notify(t('preset-roster-unmounted'), { color: 'warning' });
+                        return;
+                    }
+                    setPresetOptions(list);
+                    const index = list.findIndex(preset => preset.id === channel.agentPreset);
+                    dispatchOverlay({ type: 'set-index', kind: 'preset', index: index >= 0 ? index : 0 });
+                });
+                return true;
+            }
+            case 'effort': {
+                // Bare `/effort` opens the rheostat slider over the live route's
+                // adapter levels (←/→ applies each step immediately); `/effort <id>`
+                // sets directly (validated by the channel); `/effort status` prints
+                // the current level. The choice persists to ~/.dsh-tui/effort.json.
+                const parts = rawInput.trim().split(/\s+/).filter(Boolean);
+                if (parts[0] === 'status') {
+                    setHelpOpen(false);
+                    channel.pushLocal('/effort', [
+                        t('effort-current', { name: channel.reasoningEffort ?? '—' }),
+                        t('effort-usage'),
+                    ]);
+                    return true;
+                }
+                if (parts.length > 0) {
+                    setHelpOpen(false);
+                    void channel.setEffort(parts[0]);
+                    return true;
+                }
+                setHelpOpen(false);
+                void channel.listEfforts().then(({ efforts, defaultEffort }) => {
+                    // 0/1-tier routes were already notified by listEfforts.
+                    if (efforts.length <= 1)
+                        return;
+                    setEffortOptions(efforts);
+                    const current = channel.reasoningEffort ?? defaultEffort;
+                    const index = efforts.findIndex(effort => effort.id === current);
+                    // open-if: a picker the user opened during the round trip wins
+                    // over this late-arriving slider.
+                    dispatchOverlay({
+                        type: 'open-if',
+                        overlay: { kind: 'effort', index: index >= 0 ? index : 0 },
+                        when: ['none'],
+                    });
+                });
+                return true;
+            }
+            case 'lang': {
+                // `/lang` shows the current UI language, `/lang en|zh` switches
+                // (hot-swap, persisted to ~/.dsh-tui/lang.json), bare `/lang` opens
+                // the en/zh picker. Precedence on next launch: DSH_TUI_LANG >
+                // settings.yaml `dsh-tui.lang` > cordis.yml `lang` > the persisted
+                // choice.
+                const parts = rawInput.trim().split(/\s+/).filter(Boolean);
+                if (parts[0] === 'status') {
+                    setHelpOpen(false);
+                    channel.pushLocal('/lang', [
+                        t('lang-current', { lang: getLang() }),
+                        t('lang-switch-hint'),
+                        t('lang-persist-hint'),
+                    ]);
+                    return true;
+                }
+                if (parts.length > 0) {
+                    setHelpOpen(false);
+                    if (isLang(parts[0])) {
+                        applyLang(parts[0]);
+                    }
+                    else {
+                        channel.notify(t('lang-unknown', { lang: parts[0] }), { color: 'error' });
+                    }
+                    return true;
+                }
+                setHelpOpen(false);
+                dispatchOverlay({
+                    type: 'open',
+                    overlay: { kind: 'lang', index: getLang() === 'zh' ? 0 : 1 },
+                });
+                return true;
+            }
+            case 'theme': {
+                // Bare `/theme` opens the interactive color picker (`auto` + built-in
+                // palettes + static/runtime themes); `/theme <name>`
+                // switches directly; `/theme status` shows the current choice.
+                // `auto` follows the terminal background (OSC 11). Selection
+                // persists to ~/.dsh-tui/theme.json and hot swaps via the
+                // ThemeProvider setter (DSH_TUI_THEME still wins on next launch).
+                const parts = rawInput.trim().split(/\s+/).filter(Boolean);
+                if (parts[0] === 'status') {
+                    setHelpOpen(false);
+                    channel.pushLocal('/theme', [
+                        t('theme-current', { name: themeName }),
+                        // `auto` resolves through terminal-background detection; show
+                        // which palette it currently maps to.
+                        ...(themeName === AUTO_THEME_NAME
+                            ? [t('theme-auto-resolved', { name: getAutoThemeBase() })]
+                            : []),
+                        t('theme-switch-hint'),
+                        t('theme-persist-hint'),
+                        t('theme-custom-hint'),
+                    ]);
+                    return true;
+                }
+                if (parts.length > 0) {
+                    setHelpOpen(false);
+                    // setTheme rejects unknown names via isThemeAvailable, so pass the
+                    // raw argument instead of resolving it against the catalog first.
+                    const ok = setTheme(parts[0]);
+                    channel.notify(ok ? t('theme-switched-saved', { name: parts[0] }) : t('theme-unknown', { name: parts[0] }), { color: ok ? 'success' : 'error' });
+                    return true;
+                }
+                setHelpOpen(false);
+                dispatchOverlay({
+                    type: 'open',
+                    overlay: {
+                        kind: 'theme',
+                        index: Math.max(0, getThemeOptions(themeHost).findIndex(option => option.value === themeName)),
+                    },
+                });
+                return true;
+            }
+            case 'color': {
+                // `/color`（按会话持久化的 accent）：无参打开调色板选择器，
+                // `/color <name>` 直接设置，`/color status` 显示当前，`/color
+                // reset` 清除回主题默认。颜色经 `session/color` 事件按会话保存
+                // ——resume/rewind 后仍是这个会话自己的颜色（见 channel.ts）。
+                setHelpOpen(false);
+                const parts = rawInput.trim().split(/\s+/).filter(Boolean);
+                if (parts.length === 0) {
+                    dispatchOverlay({
+                        type: 'open',
+                        overlay: {
+                            kind: 'color',
+                            index: Math.max(0, SESSION_COLOR_NAMES.indexOf(channel.sessionColor)),
+                        },
+                    });
+                    return true;
+                }
+                if (parts[0] === 'status') {
+                    channel.pushLocal('/color', [
+                        channel.sessionColor === ''
+                            ? t('color-current-none')
+                            : t('color-current', { name: channel.sessionColor }),
+                        t('color-usage', { list: SESSION_COLOR_NAMES.join('/') }),
+                    ]);
+                    return true;
+                }
+                if (parts[0] === 'reset') {
+                    channel.setSessionColor('');
+                    channel.notify(t('color-reset'));
+                    return true;
+                }
+                const colorName = parts[0].toLowerCase();
+                if (!isValidSessionColor(colorName)) {
+                    channel.notify(t('color-unknown', { name: colorName, list: SESSION_COLOR_NAMES.join(' · ') }), { color: 'error' });
+                    return true;
+                }
+                channel.setSessionColor(colorName);
+                channel.notify(t('color-set', { name: colorName }), { color: 'success' });
+                return true;
+            }
+            case 'new': {
+                // One-shot `/new` (issue #25): the old session stays persisted and
+                // is recoverable via /resume, so discarding the live view is
+                // non-destructive — no second confirmation is required.
+                setHelpOpen(false);
+                void channel.newSession().then((ok) => {
+                    if (!ok)
+                        return;
+                    // A new session is a fresh terminal page, not merely an emptied
+                    // transcript. Reset view-local state, return the ScrollBox to the
+                    // top, then clear native scrollback and repaint the whale homepage.
+                    setExpanded(false);
+                    setExpandedRows(new Set());
+                    setStreamViewToggledRows(new Set());
+                    setSelectedId(null);
+                    setSelectionActive(false);
+                    setShowAllMessages(false);
+                    setLoadedContextOpen(false);
+                    handle?.scrollTo(0);
+                    channel.notify(t('new-session-started'));
+                    const ink = instances.get(process.stdout) ?? instances.values().next().value;
+                    // Wait one task so React commits the empty transcript/homepage tree;
+                    // clearing before that would immediately repaint the old session.
+                    setTimeout(() => {
+                        handle?.scrollTo(0);
+                        ink?.clearScrollbackAndRedraw();
+                    }, 0);
+                });
+                return true;
+            }
+            case 'clear':
+                channel.clear();
+                // channel.clear() resets row ids to 0; stale expanded/selection
+                // state would mis-highlight fresh rows (known-limitation fix).
+                setExpandedRows(new Set());
+                setStreamViewToggledRows(new Set());
+                setSelectedId(null);
+                setSelectionActive(false);
+                return true;
+            case 'compact':
+                channel.compact();
+                return true;
+            case 'trace':
+                // `/trace` is kept as the discoverable spelling of Ctrl+T: the
+                // command menu is where a user finds out the trajectory exists.
+                setHelpOpen(false);
+                openScene();
+                return true;
+            case 'context': {
+                setHelpOpen(false);
+                const context = channel.loadedContext;
+                if (context === undefined) {
+                    channel.notify(t('context-unavailable'), { color: 'warning' });
+                    return true;
+                }
+                channel.pushLocal('/context', formatLoadedContextReport(context));
+                return true;
+            }
+            case 'help':
+                setHelpOpen(true);
+                return true;
+            case 'model': {
+                // `/model <provider/model>` switches directly (same live-fork path
+                // as the picker's Enter), bare `/model` opens the picker.
+                const parts = rawInput.trim().split(/\s+/).filter(Boolean);
+                if (parts.length > 0) {
+                    setHelpOpen(false);
+                    const spec = parts[0];
+                    const slash = spec.indexOf('/');
+                    const provider = slash >= 0 ? spec.slice(0, slash) : undefined;
+                    const id = slash >= 0 ? spec.slice(slash + 1) : spec;
+                    if (provider === undefined || id.length === 0 || provider.length === 0) {
+                        channel.notify(t('model-usage'), { color: 'warning' });
+                        return true;
+                    }
+                    void channel.listModels().then((list) => {
+                        const model = list.find(m => m.provider === provider && m.id === id);
+                        if (model === undefined) {
+                            channel.notify(t('model-unknown', { spec }), { color: 'error', timeoutMs: 8000 });
+                            return;
+                        }
+                        void switchModelRecorded(provider, id, model.name);
+                    });
+                    return true;
+                }
+                setHelpOpen(false);
+                // Opens over the cached catalog (empty cache shows the loading
+                // pane); the fresh list lands with the authoritative focus, and the
+                // kind-guarded set-index cannot re-focus a picker the user left.
+                // Seed-on-open: the model in use IS a use — recording it here means
+                // the recents group exists before the first post-update switch, and
+                // switching A→B keeps A in the list (the file records what was
+                // used, not only switches made after the file appeared).
+                let recentsNow = modelRecents;
+                if (channel.provider !== '' && channel.model !== ''
+                    && !recentsNow.some(ref => ref.provider === channel.provider && ref.id === channel.model)) {
+                    recentsNow = recordModelUse({ provider: channel.provider, id: channel.model });
+                    setModelRecents(recentsNow);
+                }
+                // Two-level landing: recents (when catalogued) focus their pinned
+                // row; else multi-provider catalogs focus the current provider's
+                // group row; a single-provider catalog without a meaningful recents
+                // list drills straight into its model list (pre-grouping UX).
+                {
+                    const landing = modelPickerLanding(models, channel.provider, channel.model, recentsNow);
+                    setModelGroup(landing.group);
+                    setModelPickerDirect(landing.group !== undefined);
+                    dispatchOverlay({ type: 'open', overlay: { kind: 'model', index: landing.index } });
+                }
+                void channel.listModels().then((list) => {
+                    setModels(list);
+                    const landing = modelPickerLanding(list, channel.provider, channel.model, recentsNow);
+                    setModelGroup(landing.group);
+                    setModelPickerDirect(landing.group !== undefined);
+                    dispatchOverlay({ type: 'set-index', kind: 'model', index: landing.index });
+                });
+                void channel.listProviders().then(setProviderInfos).catch(() => setProviderInfos([]));
+                return true;
+            }
+            case 'skills': {
+                // issue #204: 列出当前 agent 的完整技能目录（名称 + 来源 + 简述），
+                // Enter 把可直调技能以 `/name ` 填回输入行（completion-only 分发的
+                // 同一路径）。注册表读取走 channel（快照 scoped 到 live agent）。
+                // `/skills <name>` 直达同一个填回动作，跳过选择器。
+                const parts = rawInput.trim().split(/\s+/).filter(Boolean);
+                if (parts.length > 0) {
+                    setHelpOpen(false);
+                    void channel.listSkills().then((list) => {
+                        if (list === undefined) {
+                            channel.notify(t('skills-load-failed'), { color: 'error' });
+                            return;
+                        }
+                        const skill = list.find(s => s.name === parts[0]);
+                        if (skill === undefined) {
+                            channel.notify(t('skills-unknown', { name: parts[0] }), { color: 'error' });
+                            return;
+                        }
+                        if (skill.userInvocable)
+                            setHistoryFill(`/${skill.name} `);
+                        else
+                            channel.notify(t('skills-not-invocable', { name: parts[0] }), { color: 'warning' });
+                    });
+                    return true;
+                }
+                setHelpOpen(false);
+                setSkillsList(null);
+                dispatchOverlay({ type: 'open', overlay: { kind: 'skills', index: 0 } });
+                void channel.listSkills().then((list) => {
+                    if (list === undefined) {
+                        dispatchOverlay({ type: 'close-if', kind: 'skills' });
+                        channel.notify(t('skills-load-failed'), { color: 'error' });
+                        return;
+                    }
+                    setSkillsList(list);
+                });
+                return true;
+            }
+            case 'provider': {
+                // Interactive add-provider wizard (/provider): drives the shared
+                // question panel, persists profile + key via the channel's settings/
+                // credentials seams. No picker state — AskUserQuestionPanel renders it.
+                setHelpOpen(false);
+                const host = channel.providerSetup();
+                if (!host) {
+                    channel.notify(t('provider-unavailable'), { color: 'warning', timeoutMs: 8000 });
+                    return true;
+                }
+                void runProviderWizard({
+                    host,
+                    ask: (request, options) => questionStore.ask(request, options),
+                    notify: (text, options) => channel.notify(text, options),
+                    pushLocal: (title, lines) => channel.pushLocal(title, lines),
+                    working: () => channel.working,
+                    switchModel: (provider, model) => switchModelRecorded(provider, model),
+                }).then((outcome) => {
+                    // A catalog-changing outcome invalidates every cached model surface
+                    // so `/model` (picker + completion) reflects it immediately — the
+                    // same consistency the picker's per-open refetch provides, minus
+                    // the stale flash on the next open. The wizard's live-switch branch
+                    // already dropped the completion cache via switchModelRecorded;
+                    // this covers keep-current, add, edit, delete and OAuth login/logout.
+                    if (outcome === 'added' || outcome === 'updated'
+                        || outcome === 'deleted' || outcome === 'signed-out') {
+                        channel.invalidateModelCompletion();
+                        void channel.listModels().then(setModels);
+                        void channel.listProviders().then(setProviderInfos).catch(() => setProviderInfos([]));
+                    }
+                }).catch(() => {
+                    // The wizard notifies on every handled failure; this only swallows
+                    // an unexpected reject so it never surfaces as an unhandled promise.
+                });
+                return true;
+            }
+            case 'thinking':
+                setHelpOpen(false);
+                dispatchOverlay({
+                    type: 'open',
+                    overlay: { kind: 'thinking', focus: thinkingVisible ? 0 : 1 },
+                });
+                return true;
+            case 'tokens': {
+                const usage = t('tokens-usage', { in: formatTokens(channel.tokens.input), out: formatTokens(channel.tokens.output) });
+                if (channel.contextWindow === undefined) {
+                    channel.notify(usage);
+                }
+                else {
+                    const percent = Math.max(0, Math.min(100, Math.round((channel.tokens.input / channel.contextWindow) * 100)));
+                    channel.notify(t('tokens-usage-context', { usage, percent }));
+                }
+                return true;
+            }
+            case 'resume':
+            /**
+             * `/resume`, `/home` and `/agentview` are one screen.
+             *
+             * They were three implementations of one domain and drifted apart: the
+             * same session could be listed by all three, each with its own selection
+             * model and its own idea of what opening one does. Keeping the three
+             * commands is about muscle memory, not about three surfaces — every one
+             * of them lands here, on the same runtime.
+             */
+            case 'home':
+            case 'agentview': {
+                setHelpOpen(false);
+                // The screen opens immediately and loads its own list. Waiting for the
+                // listing here would make it feel slower the more history a project
+                // has, which is exactly backwards.
+                agentViewOpenSessionRef.current = channel.agentId;
+                setSupervisorOpen(true);
+                return true;
+            }
+            case 'bg':
+            case 'background': {
+                // `/background`: the attached session moves to the background
+                // (it keeps running in this process), the terminal lands on a fresh
+                // session, and the supervisor opens on top.
+                setHelpOpen(false);
+                backgroundToAgentView();
+                return true;
+            }
+            case 'workspace': {
+                setHelpOpen(false);
+                const trimmed = rawInput.trim();
+                const separator = trimmed.search(/\s/u);
+                const subcommand = (separator < 0 ? trimmed : trimmed.slice(0, separator)).toLowerCase();
+                const input = separator < 0 ? '' : trimmed.slice(separator).trim();
+                if (subcommand === '') {
+                    // Bare `/workspace` opens the action menu (resume / rename / open
+                    // plus any registered extensions) instead of a text usage line.
+                    dispatchOverlay({ type: 'open', overlay: { kind: 'workspace-menu', index: 0 } });
+                }
+                else if (subcommand === 'resume') {
+                    openWorkspaceResume();
+                }
+                else if (subcommand === 'rename') {
+                    if (input.length === 0)
+                        channel.notify(t('workspace-rename-usage'));
+                    else
+                        void channel.renameWorkspace(input);
+                }
+                else if (subcommand === 'open') {
+                    if (input.length === 0)
+                        channel.notify(t('workspace-open-usage'));
+                    else
+                        openWorkspaceTarget(input);
+                }
+                else if (channel.workspaceCommands().some(command => command.name.toLowerCase() === subcommand
+                    || command.aliases?.some(alias => alias.toLowerCase() === subcommand))) {
+                    void channel.runWorkspaceCommand(subcommand, input).then((result) => {
+                        if (result !== undefined)
+                            handleWorkspaceResult(result);
+                    }).catch((error) => {
+                        channel.notify(t('workspace-command-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'error', timeoutMs: 8000 });
+                    });
+                }
+                else {
+                    channel.notify(t('workspace-command-unknown', { command: subcommand }), { color: 'error' });
+                }
+                return true;
+            }
+            case 'rename': {
+                setHelpOpen(false);
+                const title = rawInput.trim();
+                if (title.length === 0) {
+                    channel.pushLocal('/rename', [
+                        t('rename-current', { title: channel.sessionTitle || '—' }),
+                        t('rename-usage'),
+                    ]);
+                    return true;
+                }
+                channel.renameSession(title);
+                channel.notify(t('rename-done', { title }));
+                return true;
+            }
+            case 'rewind':
+                // Same picker as PromptInput's double-Esc on an empty input;
+                // `openRewind` notifies when there is nothing to rewind.
+                setHelpOpen(false);
+                openRewind();
+                return true;
+            case 'tree': {
+                // The session family tree (pi's Session Tree): every fork branch
+                // stitched back, hover previews, per-node rewind/fork/adopt.
+                setHelpOpen(false);
+                setTreeOpen(true);
+                return true;
+            }
+            case 'fork': {
+                // Tip fork (kimi-code semantics): a persisted copy of the whole
+                // conversation the user enters via /resume — the live session and
+                // its running turn stay untouched.
+                setHelpOpen(false);
+                void channel.forkSession();
+                return true;
+            }
+            case 'exit':
+            case 'quit':
+            case 'q':
+                onExit();
+                return true;
+            case 'status': {
+                const usage = channel.lastUsage;
+                const pct = channel.contextWindow === undefined
+                    ? undefined
+                    : Math.max(0, Math.min(100, Math.round((channel.tokens.input / channel.contextWindow) * 100)));
+                const lines = [
+                    `${t('status-model', { model: channel.model })}${channel.reasoningEffort ? ` · ${capitalize(channel.reasoningEffort)} effort` : ''}`,
+                    `${t('status-state', { state: channel.working ? t('status-working') : t('status-idle') })}`,
+                    `${t('status-session', { id: channel.agentId })}`,
+                    `${t('status-dir', { cwd: channel.displayCwd })}${channel.gitBranch ? ` · ${channel.gitBranch}` : ''}`,
+                    `Tokens ${formatTokens(channel.tokens.input)} in → ${formatTokens(channel.tokens.output)} out`,
+                ];
+                if (usage !== undefined) {
+                    const total = usage.input + usage.cacheRead + usage.cacheWrite;
+                    const rate = total > 0 ? ((usage.cacheRead / total) * 100).toFixed(1) : '0.0';
+                    lines.push(t('cost-cache-rate', { rate, read: formatTokens(usage.cacheRead), write: formatTokens(usage.cacheWrite) }));
+                }
+                if (pct !== undefined)
+                    lines.push(t('cost-context', { pct }));
+                if (channel.sessionTitle)
+                    lines.push(t('status-title', { title: channel.sessionTitle }));
+                setHelpOpen(false);
+                channel.pushLocal('/status', lines);
+                return true;
+            }
+            case 'cost': {
+                const usage = channel.lastUsage;
+                const lines = [
+                    `Tokens ${formatTokens(channel.tokens.input)} in → ${formatTokens(channel.tokens.output)} out`,
+                ];
+                if (usage !== undefined) {
+                    const total = usage.input + usage.cacheRead + usage.cacheWrite;
+                    const rate = total > 0 ? ((usage.cacheRead / total) * 100).toFixed(1) : '0.0';
+                    lines.push(t('cost-cache-hit-rate', { rate, read: formatTokens(usage.cacheRead), write: formatTokens(usage.cacheWrite) }));
+                }
+                lines.push(t('cost-note'));
+                setHelpOpen(false);
+                channel.pushLocal('/cost', lines);
+                return true;
+            }
+            case 'balance': {
+                // DeepSeek official account balance (free read-only endpoint): the
+                // channel resolves DEEPSEEK_API_KEY through the credentials seam and
+                // queries api.deepseek.com/user/balance. The result renders as the
+                // interactive BalanceReportRow (hover for details, click to refresh).
+                setHelpOpen(false);
+                runBalance();
+                return true;
+            }
+            case 'settings': {
+                // Plugin settings screen (issue #165): opens immediately; the screen
+                // reads sections + namespaces from the channel itself.
+                setHelpOpen(false);
+                setSettingsOpen(true);
+                return true;
+            }
+            case 'config': {
+                const userHome = process.env.USERPROFILE ?? '';
+                const lines = [
+                    t('doctor-example-config', { path: 'dsh --profile dsh-tui' }),
+                    t('doctor-user-config', { path: `${userHome}/.dsh/profiles/dsh-tui/cordis.patch.yml` }),
+                    '',
+                    t('doctor-launch-hint'),
+                    t('doctor-route-hint'),
+                ];
+                setHelpOpen(false);
+                channel.pushLocal('/config', lines);
+                return true;
+            }
+            case 'doctor':
+                setHelpOpen(false);
+                channel.pushLocal('/doctor', channel.doctorInfo());
+                return true;
+            case 'migrate': {
+                // Double entry points with the CLI. BARE `/migrate` opens the
+                // multi-select picker; `/migrate <agent>` opens the CONFIRMATION
+                // layer for that single source (PRD #2 — a bulk import is never one
+                // keystroke away). Validity is decided against the adapter REGISTRY,
+                // never the picker's row cache: on a fresh mount that cache is empty,
+                // and deriving the answer from it made every `/migrate <agent>` report
+                // an unknown source until the picker had been opened once.
+                setHelpOpen(false);
+                const command = resolveMigrateCommand(rawInput, MIGRATION_ADAPTERS.map(adapter => adapter.id));
+                if (command.kind === 'unknown') {
+                    channel.notify(t('migrate-unknown-agent', { agent: command.agentId }), { color: 'error', timeoutMs: 8000 });
+                    return true;
+                }
+                if (command.kind === 'usage') {
+                    channel.notify(t('migrate-usage'), { color: 'error', timeoutMs: 8000 });
+                    return true;
+                }
+                if (command.kind === 'dry-run-needs-source') {
+                    channel.notify(t('migrate-dry-run-needs-source'), { color: 'error', timeoutMs: 8000 });
+                    return true;
+                }
+                if (command.kind === 'import') {
+                    void (async () => {
+                        // Rows carry the scannable count the confirmation line shows; a
+                        // warm cache from an earlier picker visit is reused as is.
+                        const rows = migrateRows ?? await collectMigrateRows();
+                        const row = rows.find(candidate => candidate.agentId === command.agentId);
+                        if (row === undefined) {
+                            channel.notify(t('migrate-unknown-agent', { agent: command.agentId }), { color: 'error', timeoutMs: 8000 });
+                            return;
+                        }
+                        if (command.dryRun) {
+                            spawnMigrateSources([row], true);
+                            return;
+                        }
+                        setMigratePending([row]);
+                        // Pin the checked set to the source this confirmation is about:
+                        // Esc returns to the picker, and a stale set from an earlier visit
+                        // would there contradict what the confirmation just showed.
+                        setMigrateChecked(new Set([row.agentId]));
+                        dispatchOverlay({ type: 'open', overlay: { kind: 'migrate-confirm' } });
+                    })();
+                    return true;
+                }
+                // Bare `/migrate` starts a NEW flow: drop the previous run's checks
+                // (only Esc-out-of-confirm keeps them) and let the picker show its
+                // scanning state until the rows land.
+                setMigrateRows(null);
+                setMigrateChecked(new Set());
+                dispatchOverlay({ type: 'open', overlay: { kind: 'migrate', index: 0 } });
+                void collectMigrateRows().then(setMigrateRows);
+                return true;
+            }
+            case 'plugins':
+                // Plugin diagnostics (C-070): trust banner first, then descriptor /
+                // grant matrix / ledger tail — or validate+negotiate for
+                // `/plugins check <path>` (rawInput carries the subcommand).
+                setHelpOpen(false);
+                channel.pushLocal('/plugins', channel.pluginsInfo(rawInput));
+                return true;
+            case 'export': {
+                const target = channel.exportSession();
+                channel.notify(target === null
+                    ? t('export-failed')
+                    : t('export-saved', { target }), target === null ? { color: 'error', timeoutMs: 8000 } : { timeoutMs: 8000 });
+                return true;
+            }
+            case 'init': {
+                const result = channel.initWorkspace();
+                if (result === null)
+                    channel.notify(t('agentsmd-create-failed'), { color: 'error' });
+                else if (result === 'exists')
+                    channel.notify(t('agentsmd-exists'));
+                else
+                    channel.notify(t('agentsmd-created', { result }));
+                return true;
+            }
+            case 'jobs':
+                setHelpOpen(false);
+                setJobsPanelOpen(true);
+                return true;
+            case 'agents':
+                setHelpOpen(false);
+                void channel.listSubagents().then((lines) => {
+                    channel.pushLocal('/agents', lines);
+                });
+                return true;
+            case 'login': {
+                setHelpOpen(false);
+                void channel.describeCredential('DEEPSEEK_API_KEY')
+                    .catch(() => undefined)
+                    .then(async (status) => {
+                    const keyStatus = status === undefined
+                        ? t('login-credentials-unavailable')
+                        : status.configured
+                            ? t('login-key-configured', { ref: 'DEEPSEEK_API_KEY' })
+                            : t('login-key-missing');
+                    // OAuth account states ride along only while a dsh-auth-style
+                    // plugin is mounted; absent it the lines below are exactly the
+                    // pre-plugin set.
+                    const oauth = await channel.oauthProviderStatuses().catch(() => undefined);
+                    channel.pushLocal('/login', [
+                        t('login-api-key', { status: keyStatus }),
+                        ...(status === undefined
+                            ? []
+                            : [
+                                t('login-credential-source', { source: status.source ?? t('login-source-none') }),
+                                t('login-credential-storage', {
+                                    mode: t(status.writable ? 'login-storage-writable' : 'login-storage-read-only'),
+                                }),
+                            ]),
+                        t('login-base-url', { url: process.env.DEEPSEEK_BASE_URL ?? t('login-official-endpoint') }),
+                        ...(oauth === undefined
+                            ? []
+                            : [
+                                t('login-oauth-heading'),
+                                ...oauth.map(row => t('login-oauth-row', {
+                                    provider: row.provider,
+                                    state: row.signedIn
+                                        ? row.expiresAt === undefined
+                                            ? t('login-auth-in')
+                                            : t('login-oauth-in', { time: new Date(row.expiresAt).toISOString() })
+                                        : row.expired
+                                            ? t('login-oauth-expired')
+                                            : t('login-oauth-signed-out'),
+                                })),
+                                t('login-oauth-hint'),
+                            ]),
+                    ]);
+                });
+                return true;
+            }
+            case 'logout':
+                channel.notify(t('login-logout-hint'));
+                return true;
+            case 'permission': {
+                // The command itself is registered by the permission-presets row
+                // (dsh-base): bare `/permission` opens the preset picker and Enter
+                // dispatches `/permission <preset>`; `/permission status` prints the
+                // policy explainer; other arguments pass through verbatim.
+                // The row may be mounted as a service without its command ever
+                // reaching this agent's registry (composition-dependent) — when the
+                // service snapshot is usable the TUI still owns the entry and
+                // switches through the service write path (never the model).
+                const mounted = channel.commandList.some(command => command.external && command.name === 'permission');
+                let serviceUsable = false;
+                try {
+                    serviceUsable = channel.permissionPresets().availability === 'runtime';
+                }
+                catch {
+                    serviceUsable = false;
+                }
+                const reachable = mounted || serviceUsable;
+                const parts = rawInput.trim().split(/\s+/).filter(Boolean);
+                if (reachable && parts[0] === 'status') {
+                    setHelpOpen(false);
+                    const snapshot = channel.permissionPresets();
+                    if (snapshot.options.some(option => option.value === 'status')) {
+                        return runPermissionCommand(rawInput, images);
+                    }
+                    const currentName = snapshot.availability === 'unavailable'
+                        ? t('permission-roster-unavailable')
+                        : snapshot.current?.name ?? '—';
+                    channel.pushLocal('/permission', [
+                        t('permission-current', { name: currentName }),
+                        t('permission-policy-hint'),
+                        t('permission-approval-hint'),
+                        t('permission-root-hint', { cwd: channel.cwd }),
+                        t('permission-path-hint'),
+                    ]);
+                    return true;
+                }
+                if (reachable && parts.length === 0) {
+                    setHelpOpen(false);
+                    const snapshot = channel.permissionPresets();
+                    if (snapshot.availability === 'unavailable' || snapshot.options.length === 0) {
+                        return runPermissionCommand(rawInput, images);
+                    }
+                    const currentValue = snapshot.current?.kind === 'preset' ? snapshot.current.value : undefined;
+                    const currentIndex = currentValue === undefined
+                        ? -1
+                        : snapshot.options.findIndex(option => option.value === currentValue);
+                    const index = currentIndex >= 0
+                        ? currentIndex
+                        : Math.min(1, snapshot.options.length - 1);
+                    dispatchOverlay({
+                        type: 'open',
+                        overlay: {
+                            kind: 'permission',
+                            index,
+                            snapshot: clonePermissionPresetSnapshot(snapshot),
+                        },
+                    });
+                    return true;
+                }
+                if (reachable) {
+                    setHelpOpen(false);
+                    return runPermissionCommand(rawInput, images);
+                }
+                return false;
+            }
+            case 'plan': {
+                // Registered by dsh-plan-mode: bare `/plan` opens an on/off picker
+                // marked with the current state instead of toggling blindly; Enter
+                // dispatches `/plan` or `/plan off`. Arguments pass through verbatim
+                // (`/plan off`), and an unmounted row falls back to the default
+                // external path.
+                const mounted = channel.commandList.some(command => command.external && command.name === 'plan');
+                const parts = rawInput.trim().split(/\s+/).filter(Boolean);
+                if (mounted && parts.length === 0) {
+                    setHelpOpen(false);
+                    dispatchOverlay({
+                        type: 'open',
+                        overlay: { kind: 'plan', index: channel.mode.plan === true ? 0 : 1 },
+                    });
+                    return true;
+                }
+                if (mounted) {
+                    setHelpOpen(false);
+                    return runExternalCommand('plan', rawInput, images);
+                }
+                return false;
+            }
+            case 'add-dir':
+                setHelpOpen(false);
+                channel.pushLocal('/add-dir', [
+                    t('permission-root-hint', { cwd: channel.cwd }),
+                    t('permission-path-hint'),
+                ]);
+                return true;
+            case 'hooks':
+                setHelpOpen(false);
+                channel.pushLocal('/hooks', [
+                    t('hooks-not-mounted'),
+                    t('hooks-mount-hint'),
+                ]);
+                return true;
+            case 'mcp':
+                setHelpOpen(false);
+                channel.pushLocal('/mcp', channel.mcpStatus());
+                return true;
+            case 'update':
+                setHelpOpen(false);
+                if (onUpdate === undefined) {
+                    channel.notify(t('update-unavailable'), { color: 'warning' });
+                }
+                else if (channel.working) {
+                    channel.notify(t('update-working'), { color: 'warning' });
+                }
+                else {
+                    channel.notify(t('update-starting'));
+                    onUpdate();
+                }
+                return true;
+            case 'reload': {
+                // pi-style soft reload: re-read the persisted preference files
+                // (~/.dsh-tui/{theme,lang,agent-preset,model,working-activity}.json)
+                // and re-apply live, honoring the boot-time precedence (env >
+                // cordis.yml > settings user layer > pref). The dsh-tui settings
+                // namespace is NOT re-read here — its watch applies edits live and
+                // the platform watcher hot-reloads settings.yaml itself. What no
+                // reload can re-read (cordis.yml root config, frozen fullscreen,
+                // newly built code) is listed in the footer and served by /restart.
+                setHelpOpen(false);
+                const tuiNamespace = channel.settingsHost()
+                    ?.listNamespaces()
+                    .find(entry => entry.ns === 'dsh-tui');
+                const plan = planReload({
+                    envTheme: envThemeOverride(),
+                    envLang: isLang(process.env.DSH_TUI_LANG) ? process.env.DSH_TUI_LANG : undefined,
+                    themePref: readThemePref(),
+                    currentTheme: themeName,
+                    langPref: readLangPref(),
+                    currentLang: getLang(),
+                    langOverriddenBySettings: tuiNamespace !== undefined && hasPath(tuiNamespace.user, ['lang']),
+                    configuredLang: channel.configuredLang,
+                    configuredPreset: channel.configuredPreset,
+                    presetPref: readPresetPref(),
+                    currentPreset: channel.agentPreset,
+                    configuredModel: {
+                        provider: channel.configuredProvider,
+                        model: channel.configuredModel,
+                    },
+                    modelPref: readModelPref(),
+                    currentModel: { provider: channel.provider, model: channel.model },
+                    configuredActivity: channel.configuredActivityFrames,
+                    activityPref: readActivityFrames(),
+                    currentActivity: channel.activityFrames,
+                });
+                for (const item of plan.apply) {
+                    switch (item.kind) {
+                        case 'theme':
+                            setTheme(item.to);
+                            break;
+                        case 'lang':
+                            applyLang(item.to);
+                            break;
+                        case 'preset':
+                            void channel.switchPreset(item.to);
+                            break;
+                        case 'model':
+                            if (item.route !== undefined) {
+                                void switchModelRecorded(item.route.provider, item.route.model);
+                            }
+                            break;
+                        case 'activity':
+                            channel.setActivityFrames(item.to);
+                            break;
+                    }
+                }
+                const lines = [t('reload-header')];
+                for (const item of plan.apply) {
+                    lines.push(t('reload-applied', {
+                        kind: reloadKindLabel(item.kind),
+                        from: item.from,
+                        to: item.to,
+                    }));
+                }
+                for (const kind of plan.unchanged) {
+                    lines.push(t('reload-unchanged', { kind: reloadKindLabel(kind) }));
+                }
+                for (const skip of plan.skipped) {
+                    const key = skip.reason === 'env-wins'
+                        ? 'reload-skipped-env'
+                        : skip.reason === 'config-wins' ? 'reload-skipped-config' : 'reload-skipped-invalid';
+                    lines.push(t(key, { kind: reloadKindLabel(skip.kind) }));
+                }
+                lines.push(t('reload-footer'));
+                channel.pushLocal('/reload', lines);
+                return true;
+            }
+            case 'restart':
+                // pi-style reload tail: /reload cannot re-read boot-time-only state
+                // (cordis.yml root config, frozen fullscreen layout, newly built
+                // code), so /restart respawns the process with the original argv and
+                // resumes this session — the /update handoff minus the pnpm step.
+                setHelpOpen(false);
+                if (onRestart === undefined) {
+                    channel.notify(t('restart-unavailable'), { color: 'warning' });
+                }
+                else if (channel.working) {
+                    channel.notify(t('update-working'), { color: 'warning' });
+                }
+                else {
+                    channel.notify(t('restart-starting'));
+                    onRestart();
+                }
+                return true;
+            case 'vim': {
+                // `/vim`：切换输入框的 vim 编辑开关。状态在
+                // PromptInput 内部（controllerRef.toggleVim），每次切换落回 insert
+                // 子模式；Esc 进 normal、i/a/o 回 insert。会话级、不持久化。
+                setHelpOpen(false);
+                const on = promptControllerRef.current?.toggleVim() ?? false;
+                channel.notify(t(on ? 'vim-on' : 'vim-off'));
+                return true;
+            }
+            case 'terminal-setup':
+                setHelpOpen(false);
+                channel.pushLocal('/terminal-setup', [
+                    t('terminal-setup-hint'),
+                    t('terminal-paste-hint', { mod: modLabel }),
+                ]);
+                return true;
+            case 'recap': {
+                // `/recap`（pi-recap 语义）：对会话最近活动做一次无工具单轮
+                // 调用，生成一行摘要 + 建议标题。摘要是纯 UI 状态（不进 transcript
+                // 也不进 session log）；建议标题经「应用」按钮走 /rename 路径。
+                setHelpOpen(false);
+                recapAbortRef.current?.abort();
+                const controller = new AbortController();
+                recapAbortRef.current = controller;
+                setRecap({ raw: '', summary: '', error: undefined, done: false, titleApplied: false, auto: false, expanded: true });
+                void channel.recapRecent({
+                    signal: controller.signal,
+                    onText: delta => setRecap(prev => (prev ? { ...prev, raw: prev.raw + delta } : prev)),
+                }).then(result => {
+                    if (controller.signal.aborted)
+                        return;
+                    setRecap(prev => (prev
+                        ? {
+                            ...prev,
+                            summary: result.summary ?? prev.raw,
+                            title: result.title,
+                            error: result.error,
+                            done: true,
+                        }
+                        : prev));
+                }).catch(error => {
+                    if (controller.signal.aborted)
+                        return;
+                    setRecap(prev => prev ? { ...prev, error: error instanceof Error ? error.message : String(error), done: true } : prev);
+                });
+                return true;
+            }
+            case 'btw': {
+                // `/btw`：单轮无工具侧问，overlay 态纯 UI，不打断主回合、不写
+                // 会话历史。空参数只提示用法。
+                setHelpOpen(false);
+                const question = rawInput.trim();
+                if (!question) {
+                    channel.notify(t('btw-usage'), { timeoutMs: 3000 });
+                    return true;
+                }
+                btwAbortRef.current?.abort();
+                const controller = new AbortController();
+                btwAbortRef.current = controller;
+                setBtw({ question, answer: '', done: false });
+                void channel.sideQuestion(question, {
+                    signal: controller.signal,
+                    onText: delta => setBtw(prev => (prev ? { ...prev, answer: prev.answer + delta } : prev)),
+                }).then(result => {
+                    if (controller.signal.aborted)
+                        return;
+                    setBtw(prev => (prev ? { ...prev, answer: result.answer ?? prev.answer, error: result.error, done: true } : prev));
+                }).catch(error => {
+                    if (controller.signal.aborted)
+                        return;
+                    setBtw(prev => prev ? { ...prev, error: error instanceof Error ? error.message : String(error), done: true } : prev);
+                });
+                return true;
+            }
+            case 'deepseek': {
+                // Hidden easter egg: replay the logo header's whale spout + text
+                // shimmer. The command is intentionally not in the suggestion/help
+                // catalogs; PromptInput recognizes it through HIDDEN_COMMAND_NAMES.
+                setHelpOpen(false);
+                suppressLogoIntroRef.current = false;
+                setLogoNonce(n => n + 1);
+                // Bring the logo back into view if the transcript has scrolled.
+                setTimeout(() => {
+                    handle?.scrollTo(0);
+                }, 0);
+                return true;
+            }
+            case 'tips':
+                setHelpOpen(false);
+                dispatchOverlay({ type: 'open', overlay: { kind: 'tips' } });
+                return true;
+            case 'connect':
+                setHelpOpen(false);
+                channel.pushLocal('/connect', [t('connect-none')]);
+                return true;
+            default: {
+                // Plugin-registered command (DSH command registry): dispatch through
+                // the channel, whose execution logs command/run + command/done (the
+                // plan-mode projection folds those records, so /plan state stays
+                // consistent). Unknown names fall through to the model.
+                const external = channel.commandList.find(command => command.external && command.name === name);
+                if (external) {
+                    setHelpOpen(false);
+                    return runExternalCommand(name, rawInput, images);
+                }
+                return false;
+            }
+        }
+    };
+    // === Message-selection mode (Shift+↑ message actions) ===
+    // NOTE: rows is a live in-place array on the channel (no new reference per
+    // update), so derived lists must be computed per render — a useMemo keyed
+    // on `channel.rows` would freeze at the first empty snapshot forever.
+    // Both lists only feed their respective modes; computing them
+    // unconditionally cost an O(rows) scan + array allocation per render
+    // (every streamed chunk), so they are gated on the consuming mode.
+    const selectableRows = selectionActive
+        ? channel.rows.filter(row => SELECTABLE_KINDS.has(row.kind))
+        : NO_ROWS;
+    // ctrl+r history search: substring match on the query, newest first.
+    // The draft lives in the overlay variant; the derived '' while closed
+    // keeps the memo inputs stable (nothing renders the matches then).
+    const historyQuery = overlay.kind === 'history' ? overlay.query : '';
+    const historyMatches = React.useMemo(() => {
+        const q = historyQuery.trim().toLowerCase();
+        return q ? historyEntries.filter(e => e.text.toLowerCase().includes(q)) : historyEntries;
+    }, [historyEntries, historyQuery]);
+    // Double-Esc rewind: the user's own messages, newest first (the list shows
+    // selectable user turns; steering side-questions are excluded). Computed
+    // per render while the picker is open — `channel.rows` is a live in-place
+    // array (see selectableRows).
+    const rewindRows = overlay.kind === 'rewind'
+        ? channel.rows
+            .filter(row => row.kind === 'user' && row.label === undefined)
+            .reverse()
+        : NO_ROWS;
+    /** Open the rewind picker (from PromptInput's double-Esc on an empty input). */
+    const openRewind = () => {
+        // The overlay is not 'rewind' yet this render, so rewindRows is empty —
+        // scan directly instead of reading the gated list.
+        const candidates = channel.rows
+            .filter(row => row.kind === 'user' && row.label === undefined)
+            .reverse();
+        if (candidates.length === 0) {
+            channel.notify(t('rewind-none'));
+            return;
+        }
+        rewindRequestRef.current += 1;
+        dispatchOverlay({
+            type: 'open',
+            overlay: { kind: 'rewind', index: 0, confirm: null, modes: null, modeIndex: 0, busy: false },
+        });
+    };
+    /**
+     * Enter on a rewind candidate: ask the plugins first (tui/rewind-prompt).
+     * A veto keeps the list open; offered modes turn the confirm pane into a
+     * choice list; "no opinion" lands on the plain confirm as before.
+     */
+    const requestRewindConfirm = async (row) => {
+        const token = ++rewindRequestRef.current;
+        dispatchOverlay({ type: 'rewind-busy', busy: true });
+        const decision = await channel.promptRewind(row);
+        if (token !== rewindRequestRef.current)
+            return;
+        if (decision === 'cancel') {
+            dispatchOverlay({ type: 'rewind-busy', busy: false });
+            return;
+        }
+        dispatchOverlay({ type: 'rewind-decision', confirm: row, modes: decision?.modes ?? null });
+    };
+    /** Execute the confirmed rewind; the message comes back into the input. */
+    const performRewind = async (row, mode = null) => {
+        const text = await channel.rewindTo(row, mode);
+        if (text !== null) {
+            // The restored message belongs to the binding `rewindTo` just created,
+            // not to the one it replaced: it is the user's choice, and the switch
+            // effect must not treat it as the old conversation's leftovers.
+            pendingFillRef.current = String(channel.agentId);
+            // Put the restored message back in the prompt for re-editing.
+            setHistoryFill(text);
+            channel.notify(t('rewind-done'));
+        }
+    };
+    /**
+     * The session's trajectory projection, folded here rather than inside the
+     * scene.
+     *
+     * Two things fall out of owning it at this level: the status-line chip can
+     * show live counters without a second fold, and opening the scene is
+     * instant because the build is already warm. The fold is incremental — it
+     * consumes only events appended since the last render — so an idle
+     * conversation pays nothing for it.
+     */
+    const trajectoryRef = React.useRef(null);
+    trajectoryRef.current = extendTrajectory(trajectoryRef.current, 
+    // oxlint-disable-next-line typescript/no-unnecessary-condition -- runtime guard: headless hosts render Chat with a partial channel
+    channel.traceEvents?.() ?? NO_EVENTS);
+    const trajectory = trajectoryRef.current;
+    /**
+     * The status-line wake.
+     *
+     * Projected onto a dozen-odd columns and memoized against the ledger's row
+     * count, so it recomputes when the session actually grows rather than on
+     * every animation tick. The tick only re-colours the cells it already has.
+     */
+    const { columns: terminalColumns } = useTerminalSize();
+    const pageInsetX = usePageInset().x;
+    const wakeWidth = miniWakeWidth(terminalColumns);
+    const wakeBand = React.useMemo(() => wakeWidth === 0
+        ? undefined
+        // `sequence`, not the scene's `compressed`: at sixteen columns an idle
+        // gap cannot express how long it was, so it only reads as a broken
+        // strip. Equal-width columns give a continuous silhouette, which is
+        // the only thing this size can actually say.
+        // Width is also clamped to the row count: with fewer rows than
+        // columns the strip would be mostly gaps, which reads as broken
+        // rather than as short. It simply grows as the session does.
+        : projectWave(trajectory.nodes, Math.min(wakeWidth, trajectory.nodes.length), 'sequence'), 
+    // The node array is mutated in place by the incremental fold, so its
+    // length is the honest dependency; its identity never changes.
+    // oxlint-disable-next-line react-hooks/exhaustive-deps
+    [trajectory.nodes, trajectory.counts.rows, wakeWidth]);
+    const [wakeTickRef, wakeTime] = useAnimationFrame(channel.working ? 120 : null);
+    /**
+     * The key hint beside the strip retires itself once the trajectory has been
+     * opened — teaching belongs in the first minute, not on every frame forever.
+     */
+    const [trajectorySeen, setTrajectorySeen] = React.useState(() => trajectorySeenProp ?? readTrajectorySeen());
+    /**
+     * The one failure worth pointing at.
+     *
+     * Only the LATEST failed tool row carries the footnote, and only while its
+     * failures are unseen. Repeating it under every historical failure would be
+     * exactly the clutter the whole entry design is trying to avoid — one
+     * pointer, at the newest problem, is enough to find the rest.
+     */
+    const seenFailuresRef = React.useRef(0);
+    const unreadFailures = Math.max(0, trajectory.counts.errors - seenFailuresRef.current);
+    const failureHintRowId = React.useMemo(() => {
+        if (unreadFailures === 0)
+            return null;
+        for (let index = channel.rows.length - 1; index >= 0; index--) {
+            const row = channel.rows[index];
+            if (row?.kind === 'tool' && row.tool?.status === 'error')
+                return row.id;
+        }
+        return null;
+        // oxlint-disable-next-line react-hooks/exhaustive-deps
+    }, [channel.rows, channel.version, unreadFailures]);
+    // Row seeking under layout virtualization: a mounted row seeks directly;
+    // an unmounted one is force-mounted first, then sought by the completion
+    // effect below once its ref lands.
+    const [forceMountRowId, setForceMountRowId] = React.useState(null);
+    const seekRow = (rowId) => {
+        const el = rowRefsRef.current.get(rowId);
+        if (el) {
+            handle?.scrollToElement(el);
+            return;
+        }
+        setForceMountRowId(rowId);
+    };
+    /**
+     * Reveal-and-seek for a row folded behind the recent-rows window (the
+     * rail's tick for an old turn, the doc's revealAndSeekRow): expand the
+     * fold first, then the ordinary seek takes over — the completion effect
+     * below force-mounts the row and scrollToElement lands it once its ref
+     * (and Yoga top) exist. The fold toggle is idempotent, so calling this
+     * for an already-revealed row is harmless.
+     */
+    const revealAndSeekRow = (rowId) => {
+        if (!showAllMessages)
+            setShowAllMessages(true);
+        seekRow(rowId);
+    };
+    React.useLayoutEffect(() => {
+        if (forceMountRowId === null)
+            return;
+        const el = rowRefsRef.current.get(forceMountRowId);
+        if (el) {
+            handle?.scrollToElement(el);
+            // Clear deferred to a macrotask: clearing here would let React's
+            // synchronous re-render narrow the virtualization window and unmount
+            // the row BEFORE the renderer's deferred pass reads its Yoga top
+            // (scrollAnchor processing runs in a microtask) — the seek would
+            // silently no-op (detached anchor element).
+            setTimeout(() => setForceMountRowId(null), 0);
+        }
+    });
+    // `/` transcript search: rows whose searchable text contains the query.
+    // Computed per render — `channel.rows` is a live in-place array (see
+    // selectableRows); a useMemo would freeze the match list at mount.
+    const searchMatches = (() => {
+        const q = searchQuery.toLowerCase();
+        if (!q)
+            return [];
+        return channel.rows
+            .map((row, index) => ({ row, index, text: searchableText(row).toLowerCase() }))
+            .filter(m => m.text.includes(q));
+    })();
+    // Incsearch: highlight all matches (screen-space overlay) and keep the
+    // current match row in view as the query changes.
+    React.useEffect(() => {
+        if (!searchActive)
+            return;
+        setHighlight(searchQuery);
+        const count = searchMatches.length;
+        setSearchCount(count);
+        const current = Math.min(searchCurrent, Math.max(0, count - 1));
+        setSearchCurrent(current);
+        const target = searchMatches[current];
+        // oxlint-disable-next-line typescript/no-unnecessary-condition -- runtime guard: out-of-range index on an empty/filtered list
+        if (target) {
+            seekRow(target.row.id);
+        }
+    }, [searchQuery, searchActive]);
+    // n/N navigation: move the current match into view.
+    React.useEffect(() => {
+        if (!searchActive)
+            return;
+        const target = searchMatches[searchCurrent];
+        // oxlint-disable-next-line typescript/no-unnecessary-condition -- runtime guard: out-of-range index on an empty/filtered list
+        if (target) {
+            seekRow(target.row.id);
+        }
+    }, [searchCurrent]);
+    const enterSelection = () => {
+        setSelectionActive(true);
+        const last = selectableRows[selectableRows.length - 1];
+        // oxlint-disable-next-line typescript/no-unnecessary-condition -- runtime guard: empty selectable list
+        setSelectedId(last ? last.id : null);
+    };
+    const moveSelection = (delta) => {
+        if (selectedId === null)
+            return;
+        const index = selectableRows.findIndex(row => row.id === selectedId);
+        if (index < 0)
+            return;
+        const next = selectableRows[index + delta];
+        // oxlint-disable-next-line typescript/no-unnecessary-condition -- runtime guard: out-of-range index
+        if (next)
+            setSelectedId(next.id);
+    };
+    // useCallback: these feed MessageList → MemoRow's shallow compare; fresh
+    // closures each render would defeat every row's memo.
+    const toggleRowExpanded = React.useCallback((rowId) => {
+        setExpandedRows((previous) => {
+            const next = new Set(previous);
+            if (next.has(rowId))
+                next.delete(rowId);
+            else
+                next.add(rowId);
+            return next;
+        });
+    }, []);
+    const toggleStreamView = React.useCallback((rowId) => {
+        setStreamViewToggledRows((previous) => {
+            const next = new Set(previous);
+            if (next.has(rowId))
+                next.delete(rowId);
+            else
+                next.add(rowId);
+            return next;
+        });
+    }, []);
+    const registerRowRef = React.useCallback((rowId, el) => {
+        if (el)
+            rowRefsRef.current.set(rowId, el);
+        else
+            rowRefsRef.current.delete(rowId);
+    }, []);
+    /** Deduplicate terminals that report one Enter as parsed Return then raw CR/LF. */
+    const lastModalEnterAtRef = React.useRef(0);
+    useInput((input, key, event) => {
+        // Prompt-slot panels own the keyboard while visible. Their own useInput
+        // handles the relevant keys; Chat registered first, so yielding here
+        // still lets the panel receive them. PromptInput now stays mounted but
+        // suspended to preserve async command drafts, making this guard also
+        // essential for Ctrl+C: it must never clear the hidden composer.
+        if (btw !== null
+            || overlay.kind === 'tips'
+            || (recap !== null && (!recap.auto || recap.expanded)))
+            return;
+        // The session tree owns the whole terminal while it is up: plain letters
+        // drive its search, clicks and Enter drive its action menu.
+        if (treeOpen)
+            return;
+        // The session supervisor owns the whole terminal while it is up: its rail
+        // and session list bind ↑/↓/Enter/Tab/Esc, its filter box takes the plain
+        // letters that would otherwise reach the prompt, and the directory picker
+        // and menus it opens are its own modal layers.
+        if (supervisorOpen)
+            return;
+        // Same for the settings screen: plain letters (s save / d discard) and
+        // the field draft editor belong to it alone.
+        if (settingsOpen)
+            return;
+        // Subagent dashboard or detail scene: it owns the keyboard while open.
+        if (subagentDashboardOpen || subagentDetailId !== null)
+            return;
+        // The `/jobs` panel replaces the conversation too, so it owns Esc (close)
+        // and k (kill) while open. Unguarded, Esc meant to CLOSE the panel also
+        // reached the chat:cancel branch below whenever a turn was in flight —
+        // dismissing the panel and killing the turn with one key.
+        if (jobsPanelOpen)
+            return;
+        // A plugin scene (dsh-tui-scenes) or the trajectory scene owns the whole
+        // screen while open: every key belongs to it. Unguarded, an Esc meant to
+        // CLOSE the scene also reached the chat:cancel branch below whenever a
+        // turn was in flight — closing the view and killing the turn in one key.
+        if (sceneOpen || channel.pluginScene !== undefined)
+            return;
+        // Mouse wheel scrolls the transcript even while a question/approval/
+        // dialog panel is open — those panels own arrow/Enter/Esc keys, but the
+        // transcript above them should still be scrollable in fullscreen mode.
+        //
+        // Wheel routing is position-first: events landing over a ScrollBox
+        // (transcript, help, subagent panels…) are consumed by that box in
+        // App's input batch (onWheelAt) and never reach this branch. What
+        // arrives here is the fallback: wheel over non-scroll areas (prompt,
+        // status bar) or over floating overlays.
+        //   - Help stays yielded: PromptInput's help ScrollBox handles the
+        //     remaining global wheel while help is open (both covered layers
+        //     must not move).
+        //   - Pickers/dialogs are modal: wheel that fell through over them
+        //     must NOT scroll the transcript behind (the audit's
+        //     pass-through gap), so yield like the keyboard guards above.
+        // Events only arrive with mouse tracking on; inline mode never sees
+        // them, so this is a no-op there.
+        if (key.wheelUp || key.wheelDown) {
+            if (helpOpen)
+                return;
+            // Any open transient dialog is modal to the wheel; the one exception
+            // mirrors the render gate — a workspace picker whose target list has
+            // not landed paints nothing, so wheel-through keeps scrolling.
+            const overlayModal = overlay.kind !== 'none' &&
+                (overlay.kind !== 'workspace-picker' || workspaceTargets.length > 0);
+            if (overlayModal)
+                return;
+            handle?.scrollBy(key.wheelUp ? -3 : 3);
+            event.stopImmediatePropagation();
+            return;
+        }
+        // PgUp/PgDn page the transcript a full viewport at a time — the keyboard
+        // counterpart of the wheel branch above. Without it, a fullscreen session
+        // has no keyboard route to scrollback at all: the alt screen holds no
+        // native scrollback (see MessageList's historyPaint gate), so a mouse-less
+        // user cannot reach an earlier turn.
+        //
+        // Fullscreen only, on purpose. Inline mode paints committed history onto
+        // the main screen, so the terminal's OWN scrollback owns these keys there;
+        // claiming them would break paging that already works, exactly like the
+        // wheel branch above is a no-op inline.
+        //
+        // Routing mirrors the wheel branch: help stays yielded (PromptInput pages
+        // its help viewport with the same keys) and open pickers/dialogs are modal,
+        // so the transcript behind them must not move. Every guard above (session
+        // tree, settings, scenes, dashboards) already claimed the keyboard — those
+        // surfaces page their own lists with these keys.
+        //
+        // The question/approval/dialog panels deliberately do NOT yield: like the
+        // wheel branch above (whose comment spells this out), those panels mount
+        // BELOW the transcript — replacing the prompt, not covering it — so the
+        // transcript above them stays visible and scrollable while a decision is
+        // pending. The panels bind ↑/↓/Space/Tab/Enter/Esc and never these keys,
+        // so paging cannot steal anything from them.
+        if ((key.pageUp || key.pageDown) && fullscreen) {
+            if (helpOpen)
+                return;
+            const overlayModal = overlay.kind !== 'none' &&
+                (overlay.kind !== 'workspace-picker' || workspaceTargets.length > 0);
+            if (overlayModal)
+                return;
+            // One less than the viewport keeps a row of context so a page never
+            // reads as a blank jump; a not-yet-measured handle falls back to a
+            // fixed page rather than paging by 0 (a dead key). The final page
+            // overshoots and the renderer clamps it exactly onto maxScroll, whose
+            // positional at-bottom restore re-pins sticky (the #421/#422 wheel
+            // contract) — so paging back home clears the new-messages pill too.
+            const viewport = handle?.getViewportHeight() ?? 0;
+            const page = viewport > 1 ? viewport - 1 : 12;
+            handle?.scrollBy(key.pageUp ? -page : page);
+            event.stopImmediatePropagation();
+            return;
+        }
+        // Help is modal over Chat. Chat's listener registers before PromptInput's,
+        // so yield every remaining key before any global/custom shortcut, search,
+        // selection, or working-turn cancellation branch can mutate hidden state.
+        // PromptInput then owns Esc, navigation, Tab guards, and ordinary typing.
+        if (helpOpen)
+            return;
+        // The questionnaire / approval panel / managed plugin dialog owns the
+        // keyboard while one is pending (the panel's own useInput handles
+        // ↑/↓/Space/Tab/Enter/Esc; the prompt input is suspended, so nothing
+        // else should see these keys).
+        if (approvalSnapshot !== null || dialogSnapshot !== null)
+            return;
+        if (questionSnapshot !== null) {
+            // Only transcript navigation belongs here. The mounted questionnaire
+            // owns fold/expand keys, including when it interrupts another screen.
+            if (questionMinimized && !isSticky && (isPlainReturnInput(input, key) || key.end)) {
+                handle?.scrollToBottom();
+                event.stopImmediatePropagation();
+            }
+            return;
+        }
+        const returnCandidate = isPlainReturnInput(input, key);
+        const returnNow = Date.now();
+        const plainReturn = returnCandidate && returnNow - lastModalEnterAtRef.current >= 80;
+        if (plainReturn)
+            lastModalEnterAtRef.current = returnNow;
+        if (overlay.kind === 'image-preview') {
+            // Modal gallery owns plain left/right. Caret peeks below still leave
+            // navigation with PromptInput. Esc/Ctrl+C/Enter keep their close semantics.
+            if (key.escape || (key.ctrl && input === 'c') || plainReturn) {
+                dispatchOverlay({ type: 'close' });
+            }
+            else if (!key.ctrl && !key.meta && !key.shift && (key.leftArrow || key.rightArrow)) {
+                dispatchOverlay({ type: 'image-step', delta: key.leftArrow ? -1 : 1 });
+            }
+            event.stopImmediatePropagation();
+            return;
+        }
+        if (peekPreview !== null && key.escape) {
+            // Caret-driven preview: Esc dismisses it until the caret leaves the
+            // token (PromptInput's own Esc arm normally gets there first; this is
+            // the fallback when the prompt is not listening). Every other key
+            // stays with the prompt, so the caret keeps moving (and the card
+            // follows it) while the preview is up.
+            dismissPeek();
+            event.stopImmediatePropagation();
+            return;
+        }
+        // Esc clears a settled mouse selection before the ordinary chat meanings
+        // below, but never before a top-level modal. Otherwise a preview opened
+        // over selected transcript text needed two Esc presses to close.
+        // hasSelection() is an imperative read — no subscription needed.
+        if (key.escape && hasMouseSelection()) {
+            clearMouseSelection();
+            event.stopImmediatePropagation();
+            return;
+        }
+        if (overlay.kind === 'search') {
+            // Transcript search bar (less-style): edit the query, Enter commits
+            // (query persists for n/N), Esc/ctrl+c cancels back to the anchor.
+            if (key.escape || (key.ctrl && input === 'c')) {
+                dispatchOverlay({ type: 'close' });
+                setHighlight('');
+                handle?.scrollTo(searchAnchorRef.current);
+            }
+            else if (plainReturn) {
+                // Enter commits; 0-match junk queries don't persist.
+                if (searchCount === 0)
+                    setSearchQuery('');
+                dispatchOverlay({ type: 'close' });
+            }
+            else if (key.backspace) {
+                if (searchCursor > 0) {
+                    setSearchQuery(searchQuery.slice(0, searchCursor - 1) + searchQuery.slice(searchCursor));
+                    setSearchCursor(searchCursor - 1);
+                }
+            }
+            else if (key.delete) {
+                if (searchCursor < searchQuery.length) {
+                    setSearchQuery(searchQuery.slice(0, searchCursor) + searchQuery.slice(searchCursor + 1));
+                }
+            }
+            else if (key.leftArrow) {
+                setSearchCursor(c => Math.max(0, c - 1));
+            }
+            else if (key.rightArrow) {
+                setSearchCursor(c => Math.min(searchQuery.length, c + 1));
+            }
+            else if (key.home) {
+                setSearchCursor(0);
+            }
+            else if (key.end) {
+                setSearchCursor(searchQuery.length);
+            }
+            else if (!key.ctrl && !key.meta && !key.super && input) {
+                const next = searchQuery.slice(0, searchCursor) + input + searchQuery.slice(searchCursor);
+                setSearchQuery(next);
+                setSearchCursor(searchCursor + input.length);
+            }
+            event.stopImmediatePropagation();
+            return;
+        }
+        // After Enter closed the search bar, n/N keep walking the matches
+        // The query persists across bar open/close so n/N keep working.
+        // Transcript mode only — in prompt mode n/N are ordinary input chars.
+        if (expanded && input === 'n' && searchQuery && searchCount > 0 && !key.ctrl && !key.meta && !key.super) {
+            setSearchCurrent(i => (i >= searchCount - 1 ? 0 : i + 1));
+            event.stopImmediatePropagation();
+            return;
+        }
+        if (expanded && input === 'N' && searchQuery && searchCount > 0 && !key.ctrl && !key.meta && !key.super) {
+            setSearchCurrent(i => (i <= 0 ? searchCount - 1 : i - 1));
+            event.stopImmediatePropagation();
+            return;
+        }
+        if (overlay.kind === 'thinking') {
+            if (key.upArrow || key.downArrow) {
+                dispatchOverlay({ type: 'move', delta: key.upArrow ? -1 : 1, count: 2 });
+            }
+            else if (plainReturn) {
+                const visible = overlay.focus === 0;
+                setThinkingVisible(visible);
+                dispatchOverlay({ type: 'close' });
+                channel.notify(t('thinking-toggled', { state: visible ? t('thinking-on') : t('thinking-off') }));
+            }
+            else if (key.escape) {
+                dispatchOverlay({ type: 'close' });
+            }
+            return;
+        }
+        if (overlay.kind === 'workspace-flow') {
+            const { flow, busy, input: flowInput } = overlay;
+            if (key.escape) {
+                if (flowInput !== null && !busy) {
+                    dispatchOverlay({ type: 'flow-input', input: null });
+                    return;
+                }
+                workspaceFlowAbortRef.current?.abort();
+                workspaceFlowAbortRef.current = null;
+                workspaceFlowRequestRef.current += 1;
+                dispatchOverlay({ type: 'close' });
+                return;
+            }
+            if (busy)
+                return;
+            if (flowInput !== null) {
+                const choice = flow.choices.find(candidate => candidate.id === flowInput.choiceId);
+                const editor = choice?.input;
+                if (plainReturn) {
+                    const value = flowInput.value.trim();
+                    if (value.length === 0) {
+                        channel.notify(t('workspace-flow-input-empty'), { color: 'warning' });
+                    }
+                    else if (editor !== undefined) {
+                        runWorkspaceFlowAction(signal => editor.submit(value, signal));
+                    }
+                }
+                else if (key.backspace && flowInput.cursor > 0) {
+                    dispatchOverlay({
+                        type: 'flow-input-edit',
+                        value: flowInput.value.slice(0, flowInput.cursor - 1) + flowInput.value.slice(flowInput.cursor),
+                        cursor: flowInput.cursor - 1,
+                    });
+                }
+                else if (key.delete && flowInput.cursor < flowInput.value.length) {
+                    dispatchOverlay({
+                        type: 'flow-input-edit',
+                        value: flowInput.value.slice(0, flowInput.cursor) + flowInput.value.slice(flowInput.cursor + 1),
+                        cursor: flowInput.cursor,
+                    });
+                }
+                else if (key.leftArrow) {
+                    dispatchOverlay({
+                        type: 'flow-input-edit',
+                        value: flowInput.value,
+                        cursor: Math.max(0, flowInput.cursor - 1),
+                    });
+                }
+                else if (key.rightArrow) {
+                    dispatchOverlay({
+                        type: 'flow-input-edit',
+                        value: flowInput.value,
+                        cursor: Math.min(flowInput.value.length, flowInput.cursor + 1),
+                    });
+                }
+                else if (input.length > 0 && !key.ctrl && !key.meta && !key.super && !key.tab) {
+                    dispatchOverlay({
+                        type: 'flow-input-edit',
+                        value: flowInput.value.slice(0, flowInput.cursor) + input + flowInput.value.slice(flowInput.cursor),
+                        cursor: flowInput.cursor + input.length,
+                    });
+                }
+                return;
+            }
+            if (key.upArrow || key.downArrow) {
+                dispatchOverlay({ type: 'move', delta: key.upArrow ? -1 : 1, count: flow.choices.length });
+            }
+            else if (key.tab && !key.shift) {
+                const choice = flow.choices[overlay.index];
+                if (choice?.input !== undefined) {
+                    const value = choice.input.initialValue ?? '';
+                    const flowInputNext = {
+                        choiceId: choice.id,
+                        value,
+                        cursor: value.length,
+                        ...(choice.input.placeholder === undefined ? {} : { placeholder: choice.input.placeholder }),
+                    };
+                    dispatchOverlay({ type: 'flow-input', input: flowInputNext });
+                }
+            }
+            else if (plainReturn) {
+                const choice = flow.choices[overlay.index];
+                if (choice !== undefined) {
+                    runWorkspaceFlowAction(signal => choice.choose(signal));
+                }
+            }
+            return;
+        }
+        if (overlay.kind === 'workspace-picker') {
+            if (key.upArrow || key.downArrow) {
+                dispatchOverlay({ type: 'move', delta: key.upArrow ? -1 : 1, count: workspaceTargets.length });
+            }
+            else if (plainReturn) {
+                const target = workspaceTargets[overlay.index];
+                dispatchOverlay({ type: 'close' });
+                if (target !== undefined)
+                    void channel.switchWorkspace(target);
+            }
+            else if (key.escape) {
+                dispatchOverlay({ type: 'close' });
+            }
+            return;
+        }
+        if (overlay.kind === 'workspace-menu') {
+            const menu = workspaceMenuOptions;
+            if (key.upArrow || key.downArrow) {
+                dispatchOverlay({ type: 'move', delta: key.upArrow ? -1 : 1, count: menu.length });
+            }
+            else if (plainReturn) {
+                const option = menu[overlay.index];
+                runWorkspaceMenuOption(option);
+            }
+            else if (key.escape) {
+                dispatchOverlay({ type: 'close' });
+            }
+            return;
+        }
+        if (overlay.kind === 'model') {
+            // Two-level picker: group rows at the top (Enter drills in), one
+            // provider's models below (Enter switches, the same live-fork path as
+            // the flat picker always had). Esc/⌫ climbs one level and only closes
+            // at the top; a single-group catalog never shows the group level, so
+            // Esc there closes directly.
+            const rowCount = activeModelGroup === undefined ? modelGroups.length : groupModels.length;
+            if (key.upArrow || key.downArrow) {
+                dispatchOverlay({ type: 'move', delta: key.upArrow ? -1 : 1, count: rowCount });
+            }
+            else if (plainReturn) {
+                if (activeModelGroup === undefined) {
+                    const group = modelGroups[overlay.index];
+                    if (!group) {
+                        dispatchOverlay({ type: 'close' });
+                        return;
+                    }
+                    setModelGroup(group.provider);
+                    // The recents group opens on its most-recent entry; a provider
+                    // group on its current model when it owns one, else its first row.
+                    if (group.provider === RECENTS_GROUP_PROVIDER) {
+                        dispatchOverlay({ type: 'set-index', kind: 'model', index: 0 });
+                        return;
+                    }
+                    const landing = modelPickerLanding(models.filter(model => model.provider === group.provider), channel.provider, channel.model);
+                    dispatchOverlay({ type: 'set-index', kind: 'model', index: landing.index });
+                    return;
+                }
+                const model = groupModels[overlay.index];
+                // oxlint-disable-next-line typescript/no-unnecessary-condition -- runtime guard: out-of-range index on an empty list
+                if (model) {
+                    // Enter switches the live model right away: the conversation is
+                    // forked at its end and continued with an agent routed to the new
+                    // model (history replays unchanged) — and feeds the recents group.
+                    dispatchOverlay({ type: 'close' });
+                    void switchModelRecorded(model.provider, model.id, model.name);
+                }
+                else {
+                    dispatchOverlay({ type: 'close' });
+                }
+            }
+            else if (key.escape || key.backspace) {
+                if (activeModelGroup !== undefined && modelGroups.length > 1 && !modelPickerDirect) {
+                    setModelGroup(undefined);
+                    const groupIndex = Math.max(0, modelGroups.findIndex(group => group.provider === activeModelGroup));
+                    dispatchOverlay({ type: 'set-index', kind: 'model', index: groupIndex });
+                }
+                else {
+                    dispatchOverlay({ type: 'close' });
+                }
+            }
+            return;
+        }
+        if (overlay.kind === 'skills') {
+            const list = skillsList ?? [];
+            if (key.upArrow || key.downArrow) {
+                // count 0 (snapshot still loading) is a no-op inside the reducer.
+                dispatchOverlay({ type: 'move', delta: key.upArrow ? -1 : 1, count: list.length });
+            }
+            else if (plainReturn) {
+                const skill = list[overlay.index];
+                dispatchOverlay({ type: 'close' });
+                // 可直调技能 Enter 填入 `/name `——与 / 菜单选中技能同一条
+                // completion-only 分发路径；模型专用技能（userInvocable=false）只关闭。
+                // oxlint-disable-next-line typescript/no-unnecessary-condition -- runtime guard: out-of-range index on an empty list
+                if (skill?.userInvocable)
+                    setHistoryFill(`/${skill.name} `);
+            }
+            else if (key.escape) {
+                dispatchOverlay({ type: 'close' });
+            }
+            return;
+        }
+        // Armed migration hint (PRD #4): bare Enter while the hint notification
+        // is up — no overlay and an EMPTY prompt — jumps into the picker with the
+        // hinted source pre-checked; every other key disarms silently. The empty
+        // check is explicit because the composer owns that state: an Enter that
+        // submitted a written message must not also open the picker, and this
+        // listener runs before PromptInput's, so the event is consumed here too.
+        if (migrateHintAgent !== null && overlay.kind === 'none') {
+            if (plainReturn && !(promptControllerRef.current?.hasText() ?? false)) {
+                const agent = migrateHintAgent;
+                event.stopImmediatePropagation();
+                setMigrateHintAgent(null);
+                setMigrateRows(null);
+                setMigrateChecked(new Set([agent]));
+                dispatchOverlay({ type: 'open', overlay: { kind: 'migrate', index: 0 } });
+                void collectMigrateRows().then(setMigrateRows);
+                return;
+            }
+            setMigrateHintAgent(null);
+        }
+        if (overlay.kind === 'migrate') {
+            const rows = migrateRows ?? [];
+            if (key.upArrow || key.downArrow) {
+                dispatchOverlay({ type: 'move', delta: key.upArrow ? -1 : 1, count: rows.length });
+            }
+            else if (key.escape) {
+                dispatchOverlay({ type: 'close' });
+            }
+            else if (rows.length > 0) {
+                const row = rows[overlay.index];
+                if (input === ' ' && row !== undefined) {
+                    setMigrateChecked(current => {
+                        const next = new Set(current);
+                        if (next.has(row.agentId))
+                            next.delete(row.agentId);
+                        else
+                            next.add(row.agentId);
+                        return next;
+                    });
+                }
+                else if (input === 'a' && !key.ctrl && !key.meta) {
+                    // All/none toggle: a checked-everything state collapses to none.
+                    setMigrateChecked(current => current.size >= rows.length ? new Set() : new Set(rows.map(candidate => candidate.agentId)));
+                }
+                else if (plainReturn) {
+                    // Checked set wins; the focused row acts as a single selection
+                    // when nothing is checked (PRD #1).
+                    const chosen = migrateChecked.size > 0
+                        ? rows.filter(candidate => migrateChecked.has(candidate.agentId))
+                        : row !== undefined ? [row] : [];
+                    if (chosen.length > 0) {
+                        setMigratePending(chosen);
+                        dispatchOverlay({ type: 'close' });
+                        dispatchOverlay({ type: 'open', overlay: { kind: 'migrate-confirm' } });
+                    }
+                }
+            }
+            return;
+        }
+        if (overlay.kind === 'migrate-confirm') {
+            if (key.escape) {
+                // Back to the picker with the checked set preserved (PRD #2's
+                // "cancel" reads cheapest as "let me change the selection").
+                dispatchOverlay({ type: 'close' });
+                dispatchOverlay({ type: 'open', overlay: { kind: 'migrate', index: 0 } });
+            }
+            else if (plainReturn) {
+                dispatchOverlay({ type: 'close' });
+                spawnMigrateSources(migratePending, false);
+            }
+            else if (input === 'd' && !key.ctrl && !key.meta) {
+                dispatchOverlay({ type: 'close' });
+                spawnMigrateSources(migratePending, true);
+            }
+            return;
+        }
+        if (overlay.kind === 'activity') {
+            if (key.upArrow || key.downArrow) {
+                dispatchOverlay({ type: 'move', delta: key.upArrow ? -1 : 1, count: PRESET_NAMES.length });
+            }
+            else if (plainReturn) {
+                const name = PRESET_NAMES[overlay.index];
+                dispatchOverlay({ type: 'close' });
+                if (name)
+                    channel.setActivityFrames(name);
+            }
+            else if (key.escape) {
+                dispatchOverlay({ type: 'close' });
+            }
+            return;
+        }
+        if (overlay.kind === 'color') {
+            if (key.upArrow || key.downArrow) {
+                dispatchOverlay({ type: 'move', delta: key.upArrow ? -1 : 1, count: SESSION_COLOR_NAMES.length });
+            }
+            else if (plainReturn) {
+                const name = SESSION_COLOR_NAMES[overlay.index];
+                dispatchOverlay({ type: 'close' });
+                if (name) {
+                    channel.setSessionColor(name);
+                    channel.notify(t('color-set', { name }), { color: 'success' });
+                }
+            }
+            else if (key.escape) {
+                dispatchOverlay({ type: 'close' });
+            }
+            return;
+        }
+        if (overlay.kind === 'effort') {
+            if (key.leftArrow || key.rightArrow) {
+                const delta = key.leftArrow ? -1 : 1;
+                // The same wrap rule the reducer applies — computed here too so the
+                // newly focused level is applied in this very keystroke.
+                const next = wrapIndex(overlay.index, delta, effortOptions.length);
+                dispatchOverlay({ type: 'move', delta, count: effortOptions.length });
+                const option = effortOptions[next];
+                // Live-apply: the slider IS the control; Esc does not revert.
+                if (option)
+                    void channel.setEffort(option.id);
+            }
+            else if (plainReturn || key.escape) {
+                dispatchOverlay({ type: 'close' });
+            }
+            return;
+        }
+        if (overlay.kind === 'preset') {
+            if (key.upArrow || key.downArrow) {
+                dispatchOverlay({ type: 'move', delta: key.upArrow ? -1 : 1, count: presetOptions.length });
+            }
+            else if (plainReturn) {
+                const option = presetOptions[overlay.index];
+                dispatchOverlay({ type: 'close' });
+                if (option)
+                    void channel.switchPreset(option.id);
+            }
+            else if (key.escape) {
+                dispatchOverlay({ type: 'close' });
+            }
+            return;
+        }
+        if (overlay.kind === 'permission') {
+            if (key.upArrow || key.downArrow) {
+                const currentIndex = permissionOverlayFocusRef.current?.overlay === overlay
+                    ? permissionOverlayFocusRef.current.index
+                    : overlay.index;
+                const nextIndex = wrapIndex(currentIndex, key.upArrow ? -1 : 1, overlay.snapshot.options.length);
+                permissionOverlayFocusRef.current = { overlay, index: nextIndex };
+                dispatchOverlay({ type: 'set-index', kind: 'permission', index: nextIndex });
+            }
+            else if (plainReturn) {
+                const currentIndex = permissionOverlayFocusRef.current?.overlay === overlay
+                    ? permissionOverlayFocusRef.current.index
+                    : overlay.index;
+                const option = overlay.snapshot.options[currentIndex];
+                permissionOverlayFocusRef.current = null;
+                dispatchOverlay({ type: 'close' });
+                if (option !== undefined)
+                    void runPermissionCommand(` ${option.value}`);
+            }
+            else if (key.escape) {
+                permissionOverlayFocusRef.current = null;
+                dispatchOverlay({ type: 'close' });
+            }
+            return;
+        }
+        if (overlay.kind === 'plan') {
+            if (key.upArrow || key.downArrow) {
+                dispatchOverlay({ type: 'move', delta: key.upArrow ? -1 : 1, count: 2 });
+            }
+            else if (plainReturn) {
+                const on = overlay.index === 0;
+                dispatchOverlay({ type: 'close' });
+                void runExternalCommand('plan', on ? '' : ' off');
+            }
+            else if (key.escape) {
+                dispatchOverlay({ type: 'close' });
+            }
+            return;
+        }
+        if (overlay.kind === 'lang') {
+            if (key.upArrow || key.downArrow) {
+                dispatchOverlay({ type: 'move', delta: key.upArrow ? -1 : 1, count: 2 });
+            }
+            else if (plainReturn) {
+                const lang = LANGS[overlay.index];
+                dispatchOverlay({ type: 'close' });
+                if (lang !== undefined)
+                    applyLang(lang);
+            }
+            else if (key.escape) {
+                dispatchOverlay({ type: 'close' });
+            }
+            return;
+        }
+        if (overlay.kind === 'theme') {
+            const options = getThemeOptions(themeHost);
+            if (key.upArrow || key.downArrow) {
+                dispatchOverlay({ type: 'move', delta: key.upArrow ? -1 : 1, count: options.length });
+            }
+            else if (plainReturn) {
+                dispatchOverlay({ type: 'close' });
+                const name = options[overlay.index]?.value;
+                if (name !== undefined) {
+                    const ok = setTheme(name);
+                    channel.notify(ok ? t('theme-switched-saved', { name }) : t('theme-switch-failed', { name }), { color: ok ? 'success' : 'error' });
+                }
+            }
+            else if (key.escape) {
+                dispatchOverlay({ type: 'close' });
+            }
+            return;
+        }
+        if (overlay.kind === 'history') {
+            const { query, cursor, focus } = overlay;
+            if (key.escape) {
+                dispatchOverlay({ type: 'close' });
+            }
+            else if (key.ctrl && (input === 'c' || input === 'd')) {
+                // History search cancels on ctrl+c/ctrl+d too.
+                dispatchOverlay({ type: 'close' });
+            }
+            else if (plainReturn) {
+                const entry = historyMatches[focus];
+                // oxlint-disable-next-line typescript/no-unnecessary-condition -- runtime guard: out-of-range index on an empty match list
+                if (entry) {
+                    setHistoryFill(entry.text);
+                    dispatchOverlay({ type: 'close' });
+                }
+            }
+            else if (key.upArrow) {
+                if (historyMatches.length > 0) {
+                    dispatchOverlay({ type: 'move', delta: -1, count: historyMatches.length });
+                }
+            }
+            else if (key.downArrow || actionMatches('history', input, key)) {
+                // History search next — ↓ and the history key (default Ctrl+R)
+                // walk to the next match.
+                if (historyMatches.length > 0) {
+                    dispatchOverlay({ type: 'move', delta: 1, count: historyMatches.length });
+                }
+            }
+            else if (key.backspace) {
+                if (cursor > 0) {
+                    dispatchOverlay({
+                        type: 'history-edit',
+                        query: query.slice(0, cursor - 1) + query.slice(cursor),
+                        cursor: cursor - 1,
+                        focus: 0,
+                    });
+                }
+            }
+            else if (key.delete) {
+                if (cursor < query.length) {
+                    dispatchOverlay({
+                        type: 'history-edit',
+                        query: query.slice(0, cursor) + query.slice(cursor + 1),
+                        focus: 0,
+                    });
+                }
+            }
+            else if (key.leftArrow) {
+                // Step by code point, not UTF-16 unit: an emoji is two units, and
+                // a mid-pair caret offset would split it in the SearchBox render.
+                if (cursor > 0) {
+                    const ch = [...query.slice(0, cursor)].pop();
+                    dispatchOverlay({ type: 'history-edit', cursor: cursor - ch.length });
+                }
+            }
+            else if (key.rightArrow) {
+                if (cursor < query.length) {
+                    const ch = [...query.slice(cursor)][0];
+                    dispatchOverlay({ type: 'history-edit', cursor: cursor + ch.length });
+                }
+            }
+            else if (key.home) {
+                dispatchOverlay({ type: 'history-edit', cursor: 0 });
+            }
+            else if (key.end) {
+                dispatchOverlay({ type: 'history-edit', cursor: query.length });
+            }
+            else if (!key.ctrl && !key.meta && !key.super && input) {
+                dispatchOverlay({
+                    type: 'history-edit',
+                    query: query.slice(0, cursor) + input + query.slice(cursor),
+                    cursor: cursor + input.length,
+                    focus: 0,
+                });
+            }
+            return;
+        }
+        if (overlay.kind === 'rewind') {
+            // While the plugin decision is in flight the picker is read-only;
+            // Esc abandons the wait (the stale answer is dropped by the token).
+            if (overlay.busy) {
+                if (key.escape) {
+                    rewindRequestRef.current += 1;
+                    dispatchOverlay({ type: 'rewind-busy', busy: false });
+                }
+                return;
+            }
+            if (overlay.confirm !== null) {
+                const row = overlay.confirm;
+                if (overlay.modes !== null) {
+                    // Plugin offered modes: the confirm pane is a choice list —
+                    // option 0 is always the built-in conversation-only rewind.
+                    const optionCount = overlay.modes.length + 1;
+                    if (key.upArrow || key.downArrow) {
+                        dispatchOverlay({ type: 'move', delta: key.upArrow ? -1 : 1, count: optionCount });
+                    }
+                    else if (plainReturn) {
+                        const mode = overlay.modeIndex === 0 ? null : (overlay.modes[overlay.modeIndex - 1]?.id ?? null);
+                        dispatchOverlay({ type: 'close' });
+                        void performRewind(row, mode);
+                    }
+                    else if (key.escape) {
+                        dispatchOverlay({ type: 'rewind-back' });
+                    }
+                    return;
+                }
+                // Confirmation state: Enter rewinds, Esc backs out to the list.
+                if (plainReturn) {
+                    dispatchOverlay({ type: 'close' });
+                    void performRewind(row);
+                }
+                else if (key.escape) {
+                    dispatchOverlay({ type: 'rewind-back' });
+                }
+            }
+            else if (key.upArrow || key.downArrow) {
+                dispatchOverlay({ type: 'move', delta: key.upArrow ? -1 : 1, count: rewindRows.length });
+            }
+            else if (plainReturn) {
+                const row = rewindRows[overlay.index];
+                // oxlint-disable-next-line typescript/no-unnecessary-condition -- runtime guard: out-of-range index on an empty list
+                if (row)
+                    void requestRewindConfirm(row);
+            }
+            else if (key.escape) {
+                dispatchOverlay({ type: 'close' });
+            }
+            return;
+        }
+        if (overlay.kind === 'file-actions') {
+            // Click-to-act file menu: ↑/↓ move, Enter runs the focused action,
+            // Esc closes.
+            if (key.upArrow || key.downArrow) {
+                dispatchOverlay({ type: 'move', delta: key.upArrow ? -1 : 1, count: FILE_ACTION_COUNT });
+            }
+            else if (plainReturn) {
+                const path = overlay.path;
+                dispatchOverlay({ type: 'close' });
+                runFileAction(overlay.index, path);
+            }
+            else if (key.escape) {
+                dispatchOverlay({ type: 'close' });
+            }
+            return;
+        }
+        if (actionMatches('trajectory', input, key)) {
+            // The trajectory scene key (default Ctrl+T) opens it at any point in
+            // the session.
+            openScene();
+            return;
+        }
+        if (actionMatches('dashboard', input, key)) {
+            // The subagent dashboard key (default Ctrl+A) opens the dashboard.
+            // Consume the key: without the stop the prompt editor's readline
+            // binding ALSO fires (Ctrl+A moves the caret to line start), so one
+            // press both opens the overlay and jumps the cursor.
+            setSubagentDashboardOpen(true);
+            event.stopImmediatePropagation();
+            return;
+        }
+        if (actionMatches('contextPanel', input, key) && loadedContextVisible) {
+            // The loaded-context panel key (default Ctrl+P) toggles the startup
+            // panel while it is on screen (transcript still empty); once rows take
+            // over and the panel disappears the key has nothing left to do.
+            toggleLoadedContext();
+            return;
+        }
+        if (actionMatches('history', input, key) && !helpOpen) {
+            setHistoryEntries(loadHistory());
+            dispatchOverlay({
+                type: 'open',
+                overlay: { kind: 'history', query: '', cursor: 0, focus: 0 },
+            });
+            return;
+        }
+        if (key.shift && key.upArrow && !selectionActive && !helpOpen) {
+            enterSelection();
+        }
+        else if (selectionActive) {
+            if (key.upArrow) {
+                moveSelection(-1);
+            }
+            else if (key.downArrow) {
+                moveSelection(1);
+            }
+            else if (plainReturn && selectedId !== null) {
+                toggleRowExpanded(selectedId);
+            }
+            else if (key.escape) {
+                setSelectionActive(false);
+                setSelectedId(null);
+            }
+        }
+        else if (key.escape && channel.working && !helpOpen && !promptControllerRef.current?.vimActive()) {
+            // Esc interrupts a running turn (the prompt input
+            // only sees esc when idle, where it has the double-tap-clear meaning).
+            // With messages queued for delivery, interrupt-and-deliver them right
+            // away (Codex behavior); otherwise a plain interrupt parks the queue.
+            // vim mode (either submode) yields: there Esc is a MODE key (INSERT→
+            // NORMAL, NORMAL = no-op/cancel pending d) and the prompt owns it;
+            // interrupting still works via Ctrl+C / Ctrl+Enter.
+            if (channel.pending.length > 0) {
+                const count = channel.interruptAndDeliver(channel.pending.map(item => ({
+                    text: item.text,
+                    images: item.images ?? [],
+                })));
+                if (count > 0) {
+                    channel.notify(t('interrupt-delivered', { n: count }), { timeoutMs: 2500 });
+                }
+            }
+            else {
+                channel.cancel();
+            }
+            event.stopImmediatePropagation();
+        }
+        else if (actionMatches('transcript', input, key) && !helpOpen) {
+            // Leaving transcript mode (default Ctrl+O) — search was already
+            // handled above. Help is modal: toggling this state behind the
+            // overlay is invisible, then the next `/` unexpectedly opens
+            // transcript search instead of slash-command completion after Help
+            // closes.
+            setExpanded(previous => !previous);
+            // The toggle rewrites every thinking row's layout at once. The
+            // ordinary scroll-based diff pushes rows into terminal scrollback on
+            // each expand and nothing removes them on collapse — rapid toggling
+            // drifts the virtual↔scrollback mapping until writes misland
+            // (garbled transcript, duplicated rows). Re-anchor the next frame:
+            // in-place viewport repaint, nothing added to scrollback. Lookup
+            // falls back to the only live instance for embedders whose stdout
+            // isn't process.stdout (test harnesses).
+            const ink = instances.get(process.stdout) ?? instances.values().next().value;
+            ink?.reanchorViewport();
+        }
+        else if (input === '/' && !key.ctrl && !key.meta && !key.super && !helpOpen) {
+            // `/` in transcript mode (Ctrl+O expanded):
+            // search is active on the transcript screen where `/` isn't a command).
+            if (expanded) {
+                searchAnchorRef.current = handle?.getScrollTop() ?? 0;
+                setSearchQuery('');
+                setSearchCursor(0);
+                setSearchCurrent(0);
+                setSearchCount(0);
+                dispatchOverlay({ type: 'open', overlay: { kind: 'search' } });
+                event.stopImmediatePropagation();
+            }
+        }
+        else if (key.ctrl && (input === 'c' || input === 'd')) {
+            // Ctrl+C interrupts a running turn; idle Ctrl+C
+            // CLEARS a non-empty prompt (single press) and only arms the
+            // double-press exit when the input is empty; ctrl+d keeps the
+            // time-based double-press exit regardless.
+            if (channel.working) {
+                // First press while working only interrupts. If that abort is still
+                // converging (cancelPending) the next press is the user insisting on
+                // leaving: go straight to the exit funnel. Without this, a stuck turn
+                // (long tool call that never settles, silent stream) swallows every
+                // Ctrl+C forever — raw mode keeps the launcher's SIGINT escape
+                // unreachable until the TUI exits.
+                if (channel.cancelPending) {
+                    onExit();
+                }
+                else {
+                    channel.cancel();
+                    // Interrupt replaces any previously armed exit: the next press
+                    // must re-confirm instead of exiting out from under the turn.
+                    exitPendingRef.current = false;
+                    if (exitTimerRef.current)
+                        clearTimeout(exitTimerRef.current);
+                }
+            }
+            else if (input === 'c' && promptControllerRef.current?.consumeSelectionCopy()) {
+                // A mouse selection is active: Ctrl+C copies it to the clipboard
+                // (via the prompt controller — Chat's listener registers first) and
+                // KEEPS the selection for further editing. The key is consumed.
+                exitPendingRef.current = false;
+                if (exitTimerRef.current)
+                    clearTimeout(exitTimerRef.current);
+            }
+            else if (input === 'c' && promptControllerRef.current?.hasText()) {
+                promptControllerRef.current.clear();
+                // A pending exit arm no longer makes sense once the user is editing.
+                exitPendingRef.current = false;
+                if (exitTimerRef.current)
+                    clearTimeout(exitTimerRef.current);
+            }
+            else {
+                requestExit();
+            }
+        }
+        else if (actionMatches('redraw', input, key)) {
+            // Redraw (default Ctrl+L) — clear the physical terminal and
+            // repaint.
+            instances.get(process.stdout)?.forceRedraw();
+            // Consume: same readline-shadowing rule as dashboard/showAll below.
+            event.stopImmediatePropagation();
+        }
+        else if (actionMatches('showAll', input, key)) {
+            setShowAllMessages(previous => !previous);
+            // Ctrl+E is also the editor's line-end binding — stop the press from
+            // additionally moving the caret (one press, one meaning).
+            event.stopImmediatePropagation();
+        }
+        else if (actionMatches('todoFold', input, key)) {
+            // Fold/unfold the GoalTodoPanel todo section (default Ctrl+Q) — works
+            // mid-turn too: the collapsed line keeps the done/total count and the
+            // live task preview, so long todo lists stop crowding the prompt.
+            setTodoCollapsed(previous => !previous);
+            // Consume: same readline-shadowing rule as dashboard/showAll above.
+            event.stopImmediatePropagation();
+        }
+        else if (plainReturn && !isSticky) {
+            // Enter while scrolled up returns to the bottom: the
+            // affordance now exists whenever the view is off the bottom, not
+            // only with unseen rows).
+            handle?.scrollToBottom();
+        }
+        else if (key.end && !isSticky) {
+            // End = jump to bottom, less/vim semantics. Global on the chat
+            // screen (search/history overlays consume their own End first —
+            // cursor-to-line-end there). At the bottom already: no-op, so the
+            // key stays harmless in muscle memory.
+            handle?.scrollToBottom();
+            event.stopImmediatePropagation();
+        }
+        else if (extensionShortcuts !== undefined && extensionShortcuts.dispatch(input, key)) {
+            // Plugin shortcut (tuiShortcuts seam): matched only after every
+            // built-in global binding above declined — locals always win, and the
+            // registry additionally refuses the prompt editor's own combos at
+            // registration, so a plugin can never shadow anything. The handler
+            // runs fire-and-forget; its errors arrive via the onError hook
+            // (wired to the toast below).
+            event.stopImmediatePropagation();
+        }
+    });
+    // Working-activity line (spinner slot): context-pressure prefix shares the
+    // StatusLine thresholds (amber ≥ 80, red ≥ 95).
+    const activityWarnPct = contextPressurePct(channel.lastUsage, channel.contextWindow);
+    // ── Interrupt lane ─────────────────────────────────────────────────────
+    // The approval and ask_user_question panels park the agent until the user
+    // answers, but they render inside the conversation layout — every screen
+    // early-return below (plugin scene, browser, settings, subagent, trace)
+    // used to win over them, leaving the session stuck with no visible cause.
+    // While one is pending and a screen is up, the panel takes the whole
+    // terminal INSTEAD of the screen. The screen's open flag survives, so the
+    // decision lands back on the screen (remounted fresh — the same lifecycle
+    // as closing and reopening it); keyboard exclusivity holds because the
+    // covered screen is unmounted, exactly like the chat-state prompt slot.
+    // The panel elements are shared with the prompt-slot chain below so the
+    // two mount sites cannot drift.
+    const approvalPanelNode = approvalSnapshot !== null ? (_jsx(ApprovalPanel, { approval: approvalSnapshot, background: approvalSnapshot.agentId !== channel.agentId, onDecide: outcome => approvals.decide(outcome) }, approvalSnapshot.key)) : null;
+    const questionPanelNode = questionSnapshot !== null ? (_jsx(AskUserQuestionPanel, { question: questionSnapshot.question, position: questionSnapshot.position, total: questionSnapshot.total, answered: questionSnapshot.answered, initialDraft: questionSnapshot.draft, onAnswer: selection => questionStore.answerCurrent(selection), onCancel: () => questionStore.cancelCurrent(), onBack: questionSnapshot.canGoBack
+            ? draft => questionStore.backCurrent(draft)
+            : undefined, collapsed: questionMinimized, onExpand: () => setMinimizedQuestionKey(null), onToggleFold: () => setMinimizedQuestionKey(previous => previous === questionSnapshot.key ? null : questionSnapshot.key), fullscreen: fullscreen }, questionSnapshot.key)) : null;
+    const interruptPanel = approvalPanelNode ?? questionPanelNode;
+    const screenOpen = channel.pluginScene !== undefined || supervisorOpen || settingsOpen
+        || subagentDetailId !== null || subagentDashboardOpen || sceneOpen;
+    if (interruptPanel !== null && screenOpen) {
+        const node = (_jsx(Box, { flexDirection: "column", width: "100%", paddingX: 1, children: interruptPanel }));
+        return fullscreen ? node : _jsx(AlternateScreen, { children: node });
+    }
+    // A plugin scene (dsh-tui-scenes) takes the whole terminal the same way
+    // the trajectory scene does, and sits at the TOP of this return chain:
+    // an open() landing while the session browser or the trajectory scene is
+    // up must still take the screen (and the keyboard, via the useInput guard
+    // above), not queue silently behind them. Closing the plugin scene lands
+    // back on whatever screen was up before, so these early returns read as a
+    // stack. The component comes from the registry, so its identity is stable
+    // across renders and its hook state survives re-renders; it receives the
+    // TUI's own React + ui kit because a plugin importing its own React copy
+    // would die on the first hook call under this reconciler.
+    // The scene is third-party code, so it renders inside a boundary: a render
+    // crash reports to the transcript and closes the scene instead of taking
+    // the whole TUI down through ink's app-level boundary.
+    const pluginScene = channel.pluginScene;
+    if (pluginScene !== undefined) {
+        const node = (_jsx(PluginSceneBoundary, { id: pluginScene.id, onError: (id, error) => {
+                channel.notify(t('plugin-scene-crashed', { id, err: error.message }), { color: 'error' });
+                channel.closePluginScene();
+            }, children: renderScene ? renderScene(pluginScene.id, channel) : _jsxs(Text, { children: ["Scene unavailable: ", pluginScene.id] }) }));
+        return fullscreen ? node : _jsx(AlternateScreen, { children: node });
+    }
+    /**
+     * The session supervisor: a screen in the same sense as the tree — an early
+     * return after every hook above has run, so there is no transcript
+     * underneath to repaint or bled through.
+     *
+     * It sits ABOVE the session tree because it is the surface a launch can
+     * start on (`openHomeOnBoot`): a first launch has no conversation to come
+     * back to, and every action it offers either mounts a session (which closes
+     * it) or starts a new one.
+     *
+     * Behind it, every session this terminal hosts keeps running — that is the
+     * runtime the screen describes, not an implementation detail of it. A turn
+     * that was in flight when the user opened this screen is still in flight
+     * while they read the list, which is why closing the screen only repaints
+     * the transcript when the attached session actually changed.
+     */
+    if (supervisorOpen) {
+        /**
+         * Live state per session, from the channel's own agent-view projection.
+         * Reading the projection rather than a parallel source is what keeps this
+         * screen and the attention hints in the composer footer from disagreeing
+         * about which session is waiting for input.
+         */
+        const agentRowOf = (sessionId) => agentViewRows.find(row => row.id === sessionId);
+        const supervisorNode = (_jsx(SessionSupervisor, { channel: channel, home: homeDir(), onClose: closeHome, approval: approvalSnapshot, onApprove: outcome => approvals.decide(outcome), onOpenSession: async (sessionId) => {
+                const result = await channel.resumeTo(sessionId);
+                if (!result.ok) {
+                    const text = resumeFailureText(result);
+                    if (text !== undefined)
+                        channel.notify(text, { color: 'error', timeoutMs: 8000 });
+                    return false;
+                }
+                channel.notify(t('resume-resumed'));
+                suppressLogoIntroRef.current = true;
+                setAgentViewReturnId(undefined);
+                setSupervisorOpen(false);
+                repaintTranscript();
+                return true;
+            }, onNewSession: async (target) => {
+                const ok = await channel.switchWorkspace(target);
+                if (ok) {
+                    suppressLogoIntroRef.current = true;
+                    setAgentViewReturnId(undefined);
+                    setSupervisorOpen(false);
+                    repaintTranscript();
+                }
+                return ok;
+            }, onStopSession: async (sessionId) => channel.stopBackgroundAgent?.(sessionId) ?? false, liveStateOf: (sessionId) => {
+                const row = agentRowOf(sessionId);
+                return row === undefined
+                    ? undefined
+                    : { status: row.status, live: row.live, current: row.current, summary: row.summary };
+            } }));
+        // Inline hosts enter the alternate screen for the duration; full-screen
+        // hosts are already in it and must not nest a second one.
+        return fullscreen ? supervisorNode : _jsx(AlternateScreen, { children: supervisorNode });
+    }
+    // The session tree follows the browser's rule exactly: it REPLACES the
+    // conversation (an early return after every hook above has run), so there
+    // is no transcript underneath to be repainted or bled through. The dropped
+    // turn's prompt returns through the same fill path a rewind picker uses.
+    if (treeOpen) {
+        const tree = (_jsx(SessionTree, { channel: channel, currentSessionId: channel.agentId, onClose: () => setTreeOpen(false), onRestoreText: (text) => {
+                // The tree rewound to a node and is handing that turn's prompt back,
+                // exactly like the picker does. It belongs to the binding the tree
+                // action just created.
+                pendingFillRef.current = String(channel.agentId);
+                setHistoryFill(text);
+            } }));
+        return fullscreen ? tree : _jsx(AlternateScreen, { children: tree });
+    }
+    // The settings screen follows the browser's rule exactly: it REPLACES the
+    // conversation (an early return after every hook above has run), so there
+    // is no transcript underneath to be repainted or bled through.
+    if (settingsOpen) {
+        const screen = _jsx(Settings, { channel: channel, onClose: () => setSettingsOpen(false) });
+        return fullscreen ? screen : _jsx(AlternateScreen, { children: screen });
+    }
+    // Subagent detail scene: displays detailed view of a specific subagent.
+    // Like the browser and settings, it replaces the conversation entirely.
+    if (subagentDetailId !== null) {
+        const subagent = channel.subagents.find(s => s.agentId === subagentDetailId);
+        if (!subagent) {
+            // Agent not found, go back to dashboard
+            setSubagentDetailId(null);
+            setSubagentDashboardOpen(true);
+            return null;
+        }
+        const scene = (_jsx(SubagentDetailScene, { subagent: subagent, onInterrupt: (id) => channel.subagentControl.interrupt(id), onBack: () => {
+                setSubagentDetailId(null);
+                setSubagentDashboardOpen(true);
+            } }));
+        return fullscreen ? scene : _jsx(AlternateScreen, { children: scene });
+    }
+    // Jobs panel: background jobs (running/killed) with kill/inspect actions.
+    // Like the browser and settings, it replaces the conversation entirely.
+    if (jobsPanelOpen) {
+        const panel = (_jsx(JobsPanel, { jobs: channel.backgroundJobs ?? [], onClose: () => setJobsPanelOpen(false), onKill: (id) => {
+                // Stub channels (verify harnesses) have no jobControl — surface
+                // the same failure toast as a refused kill instead of throwing.
+                if (channel.jobControl?.kill(id) !== true) {
+                    channel.notify(t('jobs-kill-failed', { id }), { color: 'error' });
+                }
+            } }));
+        return fullscreen ? panel : _jsx(AlternateScreen, { children: panel });
+    }
+    // Subagent dashboard: displays all active and completed subagents.
+    // Like the browser and settings, it replaces the conversation entirely.
+    if (subagentDashboardOpen) {
+        const dashboard = (_jsx(SubagentDashboard, { subagents: [...channel.subagents], onSelect: (id) => {
+                setSubagentDashboardOpen(false);
+                setSubagentDetailId(id);
+            }, onClose: () => setSubagentDashboardOpen(false) }));
+        return fullscreen ? dashboard : _jsx(AlternateScreen, { children: dashboard });
+    }
+    /** Prompt input is inert while a modal dialog owns the keyboard. The
+     *  overlay union covers every picker/dialog and /tips in one check;
+     *  message-selection mode and the /btw panel live outside it. */
+    const promptSelectionActive = selectionActive || overlay.kind !== 'none' || btw !== null;
+    // These panels replace the visible composer, but PromptInput remains
+    // mounted (suspended) so an async registry command cannot lose its exact
+    // text/image draft while it waits for a user decision.
+    const promptReplacementOpen = approvalPanelNode !== null
+        || dialogSnapshot !== null
+        || overlay.kind === 'tips'
+        || (recap !== null && (!recap.auto || recap.expanded))
+        || btw !== null
+        || questionPanelNode !== null;
+    // The trajectory scene replaces the conversation for as long as it is open.
+    // Rendering it INSTEAD of (not above) the transcript is what makes it a
+    // screen rather than an overlay: it owns the full viewport, and the
+    // conversation's own frame is never resized while it is up. Chat stays
+    // mounted, so every hook above has already run and no state is lost.
+    // `<AlternateScreen>` is skipped when the app is already fullscreen —
+    // nesting it would emit a second DEC 1049, and its unmount would drop the
+    // whole app back to the main screen.
+    if (sceneOpen) {
+        const scene = _jsx(TrajectoryScene, { channel: channel, build: trajectory, onClose: closeScene });
+        return fullscreen ? scene : _jsx(AlternateScreen, { children: scene });
+    }
+    // 浮层整体挂载条件：与内部各面板的可见条件同值（数据门在
+    // dialogOverlayVisible 里逐面板镜像）。关闭时把整个 absolute 浮层从树里
+    // 移除——渲染器的"移除 absolute 节点"检测只看被移除子树自身的
+    // style.position（dom.ts collectRemovedRects），若浮层常驻、只移除其
+    // 普通子节点，blit 解毒不触发，被覆盖的转录行会在 blit-skip 后留空
+    // （Esc 关 picker 一片空白的根因）。
+    const dialogOverlayOpen = dialogOverlayVisible(overlay, {
+        workspaceTargetCount: workspaceTargets.length,
+        effortOptionCount: effortOptions.length,
+        presetOptionCount: presetOptions.length,
+    }) && !(overlay.kind === 'permission'
+        && (approvalSnapshot !== null || questionSnapshot !== null || dialogSnapshot !== null));
+    // The sticky header pins the turn owning the viewport top row
+    // (timeline.activeId, reported by MessageList) — scrolled up to an old
+    // turn, it carries THAT turn's prompt, not the latest one.
+    // channel.rows is a live in-place array, so the lookup is per-render.
+    const anchorUserRowId = timeline.activeId;
+    const anchorUserText = anchorUserRowId === null
+        ? null
+        : channel.rows.find(row => row.id === anchorUserRowId)?.text ?? null;
+    // Modal image preview, shared by the composer's [Image #N] tokens and the
+    // transcript thumbnails. It normally lives INSIDE the transcript row, so
+    // the card centers over the conversation and the sticky header, prompt
+    // and status rows stay visible. While the fullscreen draft editor is open
+    // it moves to the root, after PromptEditorLayer, so it still paints above
+    // the editor (the editor state stays put; closing the preview restores it).
+    // The layer needs its region before its first paint (see the component):
+    // the transcript viewport height from the ScrollBox handle and the content
+    // column width. The full-screen (editor-open) placement uses the terminal.
+    const imagePreviewRegion = promptEditorOpen
+        ? { columns: terminalColumns, rows: terminalRows }
+        : { columns: terminalColumns, rows: handle?.getViewportHeight() ?? terminalRows };
+    const imagePreviewNode = activePreview !== null && (activePreview.peek || imagePreviewOwned)
+        ? (_jsx(ImagePreviewOverlay, { image: activePreview.image, title: activePreview.title, navigation: previewGallery.length > 1 && previewIndex >= 0 ? {
+                index: previewIndex, total: previewGallery.length,
+                onPrevious: () => stepPreview(-1), onNext: () => stepPreview(1),
+            } : undefined, onClose: activePreview.peek
+                ? () => setPeekSuppressed(peekKey(activePreview.image, activePreview.title))
+                : () => dispatchOverlay({ type: 'close-if', kind: 'image-preview' }), region: imagePreviewRegion }))
+        : null;
+    return (_jsxs(Box, { ref: wakeTickRef, flexDirection: "column", flexGrow: 1, width: "100%", children: [!isSticky && anchorUserText && (_jsx(PinnedTurnHeader, { text: anchorUserText, onClick: () => {
+                    // Click snaps the pinned prompt to the viewport top. Jump by the
+                    // SAME content coordinate the
+                    // rail's tick uses (timeline turn top = the prompt TEXT top):
+                    // the element-based seek lands the row wrapper's margin at the
+                    // top instead — one row shy of the text top the anchor rule
+                    // compares against — and the header would flip to the previous
+                    // turn immediately after the click.
+                    const turn = timeline.turns.find(t => t.id === anchorUserRowId);
+                    if (turn)
+                        handle?.scrollTo(turn.top);
+                    else if (anchorUserRowId !== null)
+                        seekRow(anchorUserRowId);
+                    else
+                        handle?.scrollToBottom();
+                } })), _jsxs(Box, { flexDirection: "row", flexGrow: 1, flexShrink: 1, marginRight: -pageInsetX, children: [_jsxs(ScrollBox, { ref: setHandle, flexDirection: "column", flexGrow: 1, flexShrink: 1, stickyScroll: true, children: [_jsx(LogoHeader, { model: channel.model, effort: channel.reasoningEffort, cwd: channel.displayCwd, whale: channel.whale, whaleIdle: channel.whaleIdle && whaleArtVisible, working: channel.working, 
+                                // Resuming a long session skips the ~3.4s opening animation: it
+                                // keeps firing low-frequency React commits that compete with the
+                                // transcript mount batches (and the first wheel events) for the
+                                // frame budget right when the user wants to read history. Fresh
+                                // sessions keep the full intro; restored ones settle instantly.
+                                // A remount after a whole screen closed also settles instantly
+                                // (see suppressLogoIntroRef).
+                                skipIntro: suppressLogoIntroRef.current || channel.rows.length > 30 }, logoNonce), loadedContextVisible && (_jsx(LoadedContextPanel, { context: channel.loadedContext, open: loadedContextOpen, onToggle: toggleLoadedContext })), _jsx(MessageList, { rows: channel.rows, failureHintRowId: failureHintRowId, failureHint: t('traj-hint-failure', { key: `${modLabel}t` }), expanded: expanded, expandedRows: expandedRows, selectedId: selectionActive ? selectedId : null, onToggleRow: toggleRowExpanded, streamViewToggledRows: streamViewToggledRows, onToggleStreamView: toggleStreamView, model: channel.model, diffLayout: channel.diffLayout, thinkingFold: channel.thinkingFold, toolBackground: channel.toolBackground, foldTerminalCommand: channel.foldTerminalCommand, smoothStreaming: channel.smoothStreaming, activityFrames: channel.activityFrames, showAll: showAllMessages, thinkingVisible: thinkingVisible, historyPaintEnabled: !fullscreen, onToggleAll: () => { setShowAllMessages(previous => !previous); }, onLoadOlder: () => channel.loadOlder(), registerRowRef: registerRowRef, scrollHandle: handle, forceMountRowId: forceMountRowId, newSinceRowId: isSticky ? null : lastSeenRowIdRef.current, onUnseenCount: setUnseenCount, onTimeline: setTimeline, onOpenSubagent: setSubagentDetailId, onOpenJobs: openJobsPanel, onOpenFile: openFileActions, sessionCwd: channel.cwd, onPreviewImage: openImagePreview, suppressImageGraphics: activePreview !== null })] }), (() => {
+                        // Gutter mode (settings `dsh-tui.scrollGutter`): the timeline
+                        // rail (default), the proportional scrollbar, or nothing. The
+                        // slot keeps its 2 columns in both rendered modes (Qwen's
+                        // permanent-gutter rule — an appearing/disappearing gutter
+                        // changes the transcript width and rewraps everything).
+                        const gutter = normalizeScrollGutter(channel.scrollGutter);
+                        if (gutter === 'hidden')
+                            return null;
+                        if (gutter === 'scrollbar') {
+                            return _jsx(ScrollbarGutter, { handle: handle, terminalWidth: terminalColumns });
+                        }
+                        return (_jsx(TimelineRail, { handle: handle, turns: timeline.turns, activeId: timeline.activeId, upId: timeline.upId, downId: timeline.downId, terminalWidth: terminalColumns, hoverEnabled: !promptSelectionActive, onRevealTurn: revealAndSeekRow }));
+                    })(), !promptEditorOpen && imagePreviewNode] }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [showPill && (_jsx(NewMessagesPill, { count: unseenCount, onClick: () => handle?.scrollToBottom() })), channel.working &&
+                        (channel.activityEnabled &&
+                            !channel.minimal &&
+                            workingActivity !== undefined &&
+                            workingActivity.line !== '' &&
+                            workingActivity.phase !== 'idle' ? (_jsx(Box, { marginTop: 1, children: _jsx(ActivityLine, { activity: workingActivity, activityFrames: channel.activityFrames, warnPct: activityWarnPct, warnDanger: activityWarnPct !== undefined && activityWarnPct >= 95, 
+                                // Upload = real tokens of the last request; download =
+                                // the animated chars/4 estimate, matching the classic
+                                // spinner's counter (the suffix used raw chars before,
+                                // inflating the reading next to a real upload number).
+                                suffix: `${lastUploadTokens > 0 ? ` · ↑ ${formatTokens(lastUploadTokens)}` : ''} · ↓ ${formatTokens(Math.round(channel.responseChars / 4))} tokens` }) })) : (_jsx(WorkingSpinner, { mode: channel.spinnerMode, hasActiveTools: channel.activeToolCount > 0, responseLengthRef: responseLengthRef, uploadTokensRef: uploadTokensRef, loadingStartTimeRef: loadingStartTimeRef, totalPausedMsRef: totalPausedMsRef, pauseStartTimeRef: pauseStartTimeRef, thinkingStatus: thinkingStatus }))), _jsx(GoalTodoPanel, { channel: channel, collapsed: todoCollapsed, onToggle: () => setTodoCollapsed(previous => !previous) }), recap !== null && recap.auto && !recap.expanded && (_jsx(AutoRecapRow, { summary: recap.summary, streaming: !recap.done, onExpand: () => setRecap(prev => (prev ? { ...prev, expanded: true } : prev)), onDismiss: () => closeRecap() })), balance !== null && (_jsx(BalanceReportRow, { result: balance.result, refreshing: balance.refreshing, tokens: channel.tokens, model: channel.model, onRefresh: runBalance, onDismiss: () => setBalance(null) })), statusEntries.length > 0 && (_jsx(Text, { dimColor: true, wrap: "truncate", children: statusEntries.map(entry => entry.text).join(' · ') })), activePreview === null && statusViews.map(view => (_jsx(PluginStatusViewBoundary, { viewKey: view.key, onError: (key, error) => statusContributions.reportViewError(key, error), children: _jsx(Box, { flexDirection: "column", flexShrink: 0, maxHeight: view.maxRows, overflow: "hidden", children: _jsx(Box, { flexDirection: "column", flexShrink: 0, children: React.createElement(view.component, {
+                                    React,
+                                    ui: STATUS_VIEW_UI,
+                                }) }) }) }, `${view.key}:${view.registrationId}`))), _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [approvalPanelNode !== null ? (approvalPanelNode) : dialogSnapshot !== null ? (_jsx(ExtensionDialog, { dialog: dialogSnapshot, onDecide: value => dialogs.decide(dialogSnapshot.key, value), onCancel: () => dialogs.cancel(dialogSnapshot.key) }, dialogSnapshot.key)) : overlay.kind === 'tips' ? (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(TipsPanel, { onClose: () => dispatchOverlay({ type: 'close-if', kind: 'tips' }) }) })) : recap !== null && (!recap.auto || recap.expanded) ? (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(RecapPanel, { summary: recap.summary, title: recap.title, error: recap.error, streaming: !recap.done, titleApplied: recap.titleApplied, onClose: () => {
+                                        // An expanded auto recap collapses back to its dim row;
+                                        // a manual /recap closes outright.
+                                        if (recap.auto) {
+                                            setRecap(prev => (prev ? { ...prev, expanded: false } : prev));
+                                        }
+                                        else {
+                                            closeRecap();
+                                        }
+                                    }, onCopy: () => {
+                                        void setClipboard(recap.summary ?? '').then(raw => { if (raw)
+                                            writeRaw?.(raw); });
+                                        channel.notify(t('copied-chars', { n: (recap.summary ?? '').length }), { timeoutMs: 1500 });
+                                    }, onApplyTitle: () => {
+                                        if (recap.title === undefined || recap.titleApplied)
+                                            return;
+                                        channel.renameSession(recap.title);
+                                        setRecap(prev => (prev ? { ...prev, titleApplied: true } : prev));
+                                        channel.notify(t('recap-title-applied-notify', { title: recap.title }), { color: 'success' });
+                                    } }) })) : btw !== null ? (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(BtwPanel, { question: btw.question, answer: btw.answer, error: btw.error, streaming: !btw.done, onClose: closeBtw, onCopy: () => {
+                                        void setClipboard(btw.answer ?? '').then(raw => { if (raw)
+                                            writeRaw?.(raw); });
+                                        channel.notify(t('copied-chars', { n: (btw.answer ?? '').length }), { timeoutMs: 1500 });
+                                    } }) })) : questionPanelNode !== null ? (questionPanelNode) : null, _jsx(PromptInput, { channel: channel, suspended: promptReplacementOpen, draftCache: promptDraftRef.current, helpOpen: helpOpen, onToggleHelp: () => { setHelpOpen(previous => !previous); }, onRunCommand: runCommand, selectionActive: promptSelectionActive, fillText: historyFill, onFillConsumed: () => setHistoryFill(null), onRewindRequest: openRewind, onBackgroundRequest: backgroundToAgentView, 
+                                // The 🏠 at the head of the input row opens the same session screen
+                                // `/resume` and `/agentview` open — one surface, three doors. It is
+                                // gated on this prop rather than a setting, so hosts that mount the
+                                // prompt without a session screen (and the layout regressions that
+                                // pin the row's column budget) keep the row they had.
+                                onOpenSessions: () => {
+                                    agentViewOpenSessionRef.current = channel.agentId;
+                                    setSupervisorOpen(true);
+                                }, backgroundAgentsNeedingInput: 
+                                // Only the real channel supplies the seam; pre-agent-view test
+                                // stubs must not grow the footer row (layout-dependent
+                                // regressions pin the visible row count). The footer only
+                                // renders while some session actually waits (N > 0): a
+                                // permanent idle row would steal a transcript row on every
+                                // real channel — one row is enough to scroll the startup
+                                // header fully off a short terminal, pausing its viewport
+                                // clock and shifting every row-count layout invariant.
+                                channel.agentViewRows !== undefined && backgroundAgentsNeedingInput > 0
+                                    ? backgroundAgentsNeedingInput
+                                    : undefined, controllerRef: promptControllerRef, onCaretImage: handleCaretImage, caretPreviewOpen: peekPreview !== null, onDismissCaretPreview: dismissPeek }, "prompt-input"), _jsx(StatusLine, { channel: channel, activity: workingActivity, selectionActive: selectionActive, helpOpen: helpOpen, wake: wakeBand === undefined
+                                    ? undefined
+                                    : {
+                                        band: wakeBand,
+                                        hint: trajectorySeen ? undefined : `${modLabel}t`,
+                                        tick: Math.floor(wakeTime / 120),
+                                    } }), dialogOverlayOpen && (_jsxs(OverlayAbove, { maxHeight: Math.max(terminalRows - 8, 1), children: [overlay.kind === 'thinking' && (_jsx(ThinkingToggle, { currentValue: thinkingVisible, focusIndex: overlay.focus, onPick: (index) => {
+                                            // 点击行 = 设焦点 + 应用（与 Enter 同一条路径）
+                                            const visible = index === 0;
+                                            setThinkingVisible(visible);
+                                            dispatchOverlay({ type: 'close' });
+                                            channel.notify(t('thinking-toggled', { state: visible ? t('thinking-on') : t('thinking-off') }));
+                                        } })), overlay.kind === 'workspace-picker' && workspaceTargets.length > 0 && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(WorkspacePicker, { targets: workspaceTargets, focusIndex: overlay.index, currentCwd: channel.cwd, onPick: (index) => {
+                                                // 点击行 = 切换该行目标（与 Enter 同一条路径）
+                                                const target = workspaceTargets[index];
+                                                dispatchOverlay({ type: 'close' });
+                                                if (target !== undefined)
+                                                    void channel.switchWorkspace(target);
+                                            } }) })), overlay.kind === 'workspace-menu' && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(WorkspaceMenuPicker, { options: workspaceMenuOptions, focusIndex: overlay.index, onPick: (index) => {
+                                                // 点击行 = 执行该行（与 Enter 同一条路径）
+                                                runWorkspaceMenuOption(workspaceMenuOptions[index]);
+                                            } }) })), overlay.kind === 'workspace-flow' && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(WorkspaceFlowPicker, { title: overlay.flow.title, choices: overlay.flow.choices, focusIndex: overlay.index, busy: overlay.busy, input: overlay.input, onPick: (index) => {
+                                                // 点击行 = 设焦点 + 执行分支（与 Enter 同一条路径）；
+                                                // busy/输入态在组件侧禁点
+                                                const choice = overlay.flow.choices[index];
+                                                if (choice === undefined)
+                                                    return;
+                                                dispatchOverlay({ type: 'set-index', kind: 'workspace-flow', index });
+                                                runWorkspaceFlowAction(signal => choice.choose(signal));
+                                            } }) })), overlay.kind === 'model' && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: models.length === 0 ? (_jsx(ModelPickerLoading, {})) : activeModelGroup === undefined ? (_jsx(ModelPicker, { groups: modelGroups, focusIndex: overlay.index, currentProvider: channel.provider, onPick: (index) => {
+                                                // 点击分组行 = 进入该组（与 Enter 同一条路径）
+                                                const group = modelGroups[index];
+                                                if (!group)
+                                                    return;
+                                                setModelGroup(group.provider);
+                                                if (group.provider === RECENTS_GROUP_PROVIDER) {
+                                                    dispatchOverlay({ type: 'set-index', kind: 'model', index: 0 });
+                                                    return;
+                                                }
+                                                const landing = modelPickerLanding(models.filter(model => model.provider === group.provider), channel.provider, channel.model);
+                                                dispatchOverlay({ type: 'set-index', kind: 'model', index: landing.index });
+                                            } })) : (_jsx(ModelPicker, { models: groupModels, groupLabel: activeModelGroup === RECENTS_GROUP_PROVIDER
+                                                ? t('picker-group-recent')
+                                                : modelGroups.find(group => group.provider === activeModelGroup)?.label, showBack: modelGroups.length > 1 && !modelPickerDirect, showProviderPrefix: activeModelGroup === RECENTS_GROUP_PROVIDER, focusIndex: overlay.index, currentModel: `${channel.provider}/${channel.model}`, onPick: (index) => {
+                                                // 点击行 = 应用该行模型（与 Enter 同一条路径）
+                                                const model = groupModels[index];
+                                                if (!model)
+                                                    return;
+                                                dispatchOverlay({ type: 'close' });
+                                                void switchModelRecorded(model.provider, model.id, model.name);
+                                            } })) })), overlay.kind === 'migrate' && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(MigratePicker, { rows: migrateRows ?? [], focusIndex: overlay.index, checked: migrateChecked, loading: migrateRows === null, onPick: (index) => {
+                                                const row = (migrateRows ?? [])[index];
+                                                if (!row)
+                                                    return;
+                                                setMigrateChecked(current => {
+                                                    const next = new Set(current);
+                                                    if (next.has(row.agentId))
+                                                        next.delete(row.agentId);
+                                                    else
+                                                        next.add(row.agentId);
+                                                    return next;
+                                                });
+                                            } }) })), overlay.kind === 'migrate-confirm' && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(MigrateConfirm, { rows: migratePending }) })), overlay.kind === 'skills' && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: skillsList === null ? (_jsx(SkillsPickerLoading, {})) : (_jsx(SkillsPicker, { skills: skillsList, focusIndex: overlay.index, onPick: (index) => {
+                                                const skill = skillsList[index];
+                                                if (!skill)
+                                                    return;
+                                                dispatchOverlay({ type: 'close' });
+                                                if (skill.userInvocable)
+                                                    setHistoryFill(`/${skill.name} `);
+                                            } })) })), overlay.kind === 'activity' && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(ActivityPicker, { focusIndex: overlay.index, currentPreset: channel.activityFrames, onPick: (index) => {
+                                                dispatchOverlay({ type: 'close' });
+                                                const name = PRESET_NAMES[index];
+                                                if (name)
+                                                    channel.setActivityFrames(name);
+                                            } }) })), overlay.kind === 'color' && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(ColorPicker, { focusIndex: overlay.index, currentColor: channel.sessionColor, onPick: (index) => {
+                                                dispatchOverlay({ type: 'close' });
+                                                const name = SESSION_COLOR_NAMES[index];
+                                                if (name) {
+                                                    channel.setSessionColor(name);
+                                                    channel.notify(t('color-set', { name }), { color: 'success' });
+                                                }
+                                            } }) })), overlay.kind === 'effort' && effortOptions.length > 1 && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(EffortSlider, { options: effortOptions, focusIndex: overlay.index, currentId: channel.reasoningEffort, 
+                                            // 点击档位 = 移到该档并即时应用（与 ←/→ 同语义）
+                                            onPick: (index) => {
+                                                dispatchOverlay({ type: 'set-index', kind: 'effort', index });
+                                                const option = effortOptions[index];
+                                                if (option)
+                                                    void channel.setEffort(option.id);
+                                            } }) })), overlay.kind === 'preset' && presetOptions.length > 0 && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(PresetPicker, { presets: presetOptions, focusIndex: overlay.index, currentPreset: channel.agentPreset, onPick: (index) => {
+                                                dispatchOverlay({ type: 'close' });
+                                                const option = presetOptions[index];
+                                                if (option)
+                                                    void channel.switchPreset(option.id);
+                                            } }) })), overlay.kind === 'permission' && overlay.snapshot.options.length > 0 && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(PermissionsPicker, { options: overlay.snapshot.options, focusIndex: overlay.index, currentValue: overlay.snapshot.current?.value, cwd: channel.cwd, onPick: (index) => {
+                                                if (approvalSnapshot !== null || questionSnapshot !== null || dialogSnapshot !== null)
+                                                    return;
+                                                const option = overlay.snapshot.options[index];
+                                                dispatchOverlay({ type: 'close' });
+                                                if (option !== undefined)
+                                                    void runPermissionCommand(` ${option.value}`);
+                                            } }) })), overlay.kind === 'plan' && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(PlanPicker, { focusIndex: overlay.index, currentOn: channel.mode.plan === true, onPick: (index) => {
+                                                dispatchOverlay({ type: 'close' });
+                                                const on = index === 0;
+                                                void runExternalCommand('plan', on ? '' : ' off');
+                                            } }) })), overlay.kind === 'lang' && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(LangPicker, { focusIndex: overlay.index, currentLang: getLang(), onPick: (index) => {
+                                                const lang = LANGS[index];
+                                                if (lang === undefined)
+                                                    return;
+                                                dispatchOverlay({ type: 'close' });
+                                                applyLang(lang);
+                                            } }) })), overlay.kind === 'theme' && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(ThemePicker, { focusIndex: overlay.index, currentTheme: themeName, themeHost: themeHost, onPick: (index) => {
+                                                dispatchOverlay({ type: 'close' });
+                                                const name = getThemeOptions(themeHost)[index]?.value;
+                                                if (name !== undefined) {
+                                                    const ok = setTheme(name);
+                                                    channel.notify(ok ? t('theme-switched-saved', { name }) : t('theme-switch-failed', { name }), { color: ok ? 'success' : 'error' });
+                                                }
+                                            } }) })), overlay.kind === 'history' && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(HistorySearchDialog, { query: overlay.query, cursorOffset: overlay.cursor, matches: historyMatches, focusIndex: overlay.focus, onPick: (index) => {
+                                                // 点击行 = 填入该历史命令（与 Enter 同路径）
+                                                const entry = historyMatches[index];
+                                                if (entry) {
+                                                    setHistoryFill(entry.text);
+                                                    dispatchOverlay({ type: 'close' });
+                                                }
+                                            } }) })), overlay.kind === 'rewind' && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(RewindPicker, { rows: rewindRows, focusIndex: overlay.index, confirmRow: overlay.confirm, modes: overlay.modes, modeIndex: overlay.modeIndex, busy: overlay.busy, onPickRow: (index) => {
+                                                // 列表页点击只选中：进入确认态保留键盘 Enter 显式触发
+                                                dispatchOverlay({ type: 'set-index', kind: 'rewind', index });
+                                            }, onConfirm: () => {
+                                                // 确认页即显式确认层，点击直接执行（与 Enter 同路径）
+                                                const row = overlay.confirm;
+                                                if (row === null)
+                                                    return;
+                                                dispatchOverlay({ type: 'close' });
+                                                void performRewind(row);
+                                            }, onPickMode: (index) => {
+                                                // 模式列表点击直接执行该模式（与 Enter 同路径）
+                                                const row = overlay.confirm;
+                                                if (row === null)
+                                                    return;
+                                                // 模式页仅当 modes 非空才渲染，这里空安全取值
+                                                const mode = index === 0 ? null : (overlay.modes?.[index - 1]?.id ?? null);
+                                                dispatchOverlay({ type: 'close' });
+                                                void performRewind(row, mode);
+                                            } }) })), overlay.kind === 'file-actions' && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(FileActionsPanel, { path: overlay.path, isDir: overlay.isDir, focusIndex: overlay.index, onPick: (index) => {
+                                                // 点击行直接执行该动作（与 Enter 同路径）
+                                                const path = overlay.path;
+                                                dispatchOverlay({ type: 'close' });
+                                                runFileAction(index, path);
+                                            } }) })), overlay.kind === 'search' && _jsx(TranscriptSearch, { query: searchQuery, cursorOffset: searchCursor, count: searchCount, current: searchCurrent })] }))] })] }), _jsx(TooltipLayer, { invalidationKey: `${overlay.kind}:${dialogOverlayOpen}:${btw !== null}`, subscribeInvalidation: subscribeTooltipInvalidation }), _jsx(PromptEditorLayer, {}), promptEditorOpen && imagePreviewNode] }));
+}
+/**
+ * The pinned prompt header shown above the ScrollBox while the user has
+ * scrolled up. It pins the user message the transcript viewport is currently
+ * showing — the topmost visible user message, or the nearest one above when only assistant
+ * content fills the view — so it tracks which turn the user is reading
+ * instead of always carrying the latest prompt. Fixed at 1 row so the
+ * ScrollBox never shifts when the text changes.
+ */
+function PinnedTurnHeader({ text, onClick, }) {
+    const { columns } = useTerminalSize();
+    // A one-row Box does not clip its children. Flatten hard line breaks before
+    // truncating, otherwise later prompt lines paint down the transcript gutter.
+    const label = cleanRenderText(`${POINTER} ${text}`, Math.max(1, columns - 1));
+    return (_jsx(Box, { flexShrink: 0, width: "100%", height: 1, overflow: "hidden", paddingRight: 1, onClick: onClick, children: _jsx(Text, { color: "userPromptLabel", bold: true, wrap: "truncate-end", children: label }) }));
+}
+/** The `↓ N new messages` pill shown while scrolled up with new content. */
+function NewMessagesPill({ count, onClick, }) {
+    const [hover, setHover] = React.useState(false);
+    return (_jsx(NoSelect, { paddingX: 2, paddingTop: 1, children: _jsx(Box, { backgroundColor: hover ? 'userMessageBackgroundHover' : 'background', onClick: onClick, onMouseEnter: () => { setHover(true); }, onMouseLeave: () => { setHover(false); }, children: _jsxs(Text, { color: "inverseText", bold: true, children: [' ', count > 0
+                        ? t(count === 1 ? 'new-message' : 'new-messages', { n: count })
+                        : t('back-to-bottom'), ' '] }) }) }));
+}
+/** /model while the provider catalog is still loading. */
+function ModelPickerLoading() {
+    return (_jsx(Pane, { color: "permission", children: _jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { bold: true, color: "permission", children: t('picker-title-model') }), _jsx(LoadingState, { message: t('model-loading'), bold: true, subtitle: t('model-loading-subtitle') })] }) }));
+}
+/**
+ * The `/` incsearch bar: a
+ * single row above the prompt input with the query, a block cursor, and the
+ * match counter (`current/count`) or a red `no matches` when nothing hits.
+ */ function TranscriptSearch({ query, cursorOffset, count, current, }) {
+    const cursorChar = cursorOffset < query.length ? query[cursorOffset] : ' ';
+    return (_jsxs(NoSelect, { borderTopDimColor: true, borderBottom: false, borderLeft: false, borderRight: false, borderStyle: "single", marginTop: 1, paddingLeft: 2, width: "100%", children: [_jsx(Text, { children: "/" }), _jsx(Text, { children: query.slice(0, cursorOffset) }), _jsx(Text, { inverse: true, children: cursorChar }), cursorOffset < query.length && _jsx(Text, { children: query.slice(cursorOffset + 1) }), _jsx(Box, { flexGrow: 1 }), query && count === 0 ? (_jsxs(Text, { color: "error", children: [t('search-no-matches'), " "] })) : count > 0 ? (_jsxs(Text, { dimColor: true, children: [Math.min(current + 1, count), "/", count, '  '] })) : null] }));
+}