talos-code 0.0.1 → 0.2.0

package/dist/tui/app.js

@@ -0,0 +1,4098 @@
+import { keySavedText } from "../provider/store.js";
+import { developmentLog, developmentLogError, developmentTextEvidence } from "../diagnostics/development-log.js";
+import { describeError, errorViewLines } from "../i18n/error-view.js";
+import { t, tn } from "../i18n/index.js";
+import { execFile } from 'node:child_process';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { benchedKeyText, unusableKeyRefusal } from "./catalog-service.js";
+import { providerOfModel, screenChildEnvironment } from "../provider/environment-keys.js";
+import { createBootSequenceComponent } from "./boot/boot-sequence.js";
+import { completeBoot, createBootState, markBootError, markBootReady, shouldRenderBootLogo, skipBoot } from "./boot/boot-sequence.js";
+import { commandMenuFastTextInput, commandMenuHighlight, commandMenuItems, commandMenuOverlay, completeCommandSelection, createCommandMenuSelectionStore } from "./components/command-menu.js";
+import { applyComposerFastEditorAction, applyComposerFastPasteInput, composerFastEditorAction, composerFastPasteInput, composerFastTextInput, composerOwnsPaste, createComposerStore, planComposerHistoryAction, reverseHistoryMatch } from "./components/composer.js";
+import { headerLine } from "./components/header.js";
+import { createMarkdownParseMemo, markdownBlockLines, markdownRenderPropsEqual, markdownSafeText, parseMarkdownInline } from "./components/markdown.js";
+import { renderDiffModel } from "./components/diff.js";
+import { parseUnifiedDiff } from "./diff-model.js";
+import { activityWord, busyIndicatorText } from "./components/status-indicator.js";
+import { isAnimatedActivity, retryCountdownEnd } from "./live-activity.js";
+import { smallWindowNotice, usageFacts, usageViewText } from "./usage-view.js";
+import { exportSession } from "./session-export.js";
+import { secretValuesFromEnvironment } from "../diagnostics/redact.js";
+import { busyCommand, busyEnterAction, busyTip, tipsOnEnter } from "./busy-input.js";
+import { saveUiPreference, useUiPreferences } from "./ui-preferences.js";
+import { thoughtLine, visibleTranscriptItems as visibleItemsOf } from "./components/thinking-row.js";
+import { agentRosterLine, frameRowsFor } from "./components/terminal-shell.js";
+import { toolRowView } from "./components/tool-row.js";
+/* Lane RD contract (R3): toolRowView(row,width,expanded,now?) draws `running 12 s` from `now`; a renderer without the
+   parameter ignores it. */
+const toolRowWithClock = toolRowView;
+import { createTranscriptMeasurementStore, estimateTranscriptItemRows, planTranscriptVirtualWindow, transcriptAnnouncement, transcriptMeasurementKey } from "./components/transcript-virtualizer.js";
+import { copySelection, createEditorState, deleteBackward, deleteForward, draftOf, editInsert, editorFromDraft, insertPaste, killToEnd, killToStart, killWordBackward, moveCursor, moveVertical, moveWord, previousGraphemeBoundary, redoEditor, replaceEditorText, undoEditor, yank } from "./editor.js";
+import { editExternally } from "./external-editor.js";
+import { FILE_COMPLETION_MAX_ROWS, completeProjectFiles, fileCompletionOverlay } from "./file-completion.js";
+import { createProjectFileIndexCache } from "./project-file-index.js";
+import { permissionRuleCounts, usageLine } from "./status-view.js";
+import { filterHistory, historyPickerOverlay } from "./overlays/history-picker.js";
+import { closeFocus, createFocusState, openFocus } from "./focus-manager.js";
+import { createInterruptController, EXIT_CONFIRM_WINDOW_MS, exitHintText } from "./interrupt.js";
+import { bootPlan, currentBuildId } from "./launch-state.js";
+import { CLI_VERSION, TALOS_BASE_COMMIT } from "../version.js";
+import { KEYBINDINGS, cyclePermissionMode, resolveKeybinding, sanitizeInputText, splitInputChunk } from "./keybindings.js";
+import { APPROVAL_DEFAULT_SELECTED, approvalDialogFit, approvalDialogModel, approvalInputGate, approvalKeyOutcome, renderApprovalDialog } from "./overlays/approval-dialog.js";
+import { fitOverlay, renderFittedOverlay, renderOverlay } from "./overlays/scroll-window.js";
+import { commitModelSelection, createModelPickerModel, modelPickerOverlay } from "./overlays/model-picker.js";
+import { effortLineOverlay, orderedEfforts } from "./overlays/effort-line.js";
+import { consentQuestion, createProviderPickerModel, maskedSecret, providerConsentOverlay, providerKeyOverlay, providerKeySourceLabel, providerPickerEnter, providerPickerItems, providerPickerOverlay, providerLoginChoiceOverlay, providerOAuthOverlay } from "./overlays/provider-picker.js";
+import { createSessionPickerModel, filterSessions, sessionPickerOverlay } from "./overlays/session-picker.js";
+import { agentTreeOverlay as agentTreeOverlayContent, createAgentTreeOverlayModel, moveAgentTreeSelection, selectedAgentRow } from "./overlays/agent-tree.js";
+import { createAgentView } from "./agent-view.js";
+import { agentRosterRows } from "./agent-roster.js";
+import { helpDialogOverlay } from "./overlays/help-dialog.js";
+import { queueEditorOverlay, queueEditorSelected } from "./overlays/queue-editor.js";
+import { contextInspectorOverlay } from "./overlays/context-inspector.js";
+import { createTranscriptSearchState, moveTranscriptSearchSelection, selectedTranscriptMatch, transcriptSearchMatches, transcriptSearchOverlay } from "./overlays/transcript-search.js";
+import { trustCenterModel, trustCenterOverlay } from "./overlays/trust-center.js";
+import { createMcpCenterModel, moveMcpCenterSelection, mcpCenterOverlay, replaceMcpCenterRow, selectedMcpServer } from "./overlays/mcp-center.js";
+import { createMcpFacade } from "../services/mcp-facade.js";
+import { createHookCenterModel, moveHookCenterSelection, hookCenterOverlay, replaceHookCenterRow, selectedHook } from "./overlays/hook-center.js";
+import { createHookFacade } from "../services/hook-facade.js";
+import { createPluginCenterModel, movePluginCenterSelection, pluginCenterOverlay, selectedPlugin } from "./overlays/plugin-center.js";
+import { createPluginFacade } from "../services/plugin-facade.js";
+import { createMemoryCenterModel, moveMemoryCenterSelection, memoryCenterOverlay, selectedMemory } from "./overlays/memory-center.js";
+import { createMemoryFacade } from "../services/memory-facade.js";
+import { createNotesCenterModel, moveNotesCenterSelection, notesCenterOverlay, selectedNote } from "./overlays/notes-center.js";
+import { createNotesFacade } from "../services/notes-facade.js";
+import { createTasksCenterModel, moveTasksCenterSelection, tasksCenterOverlay, selectedTask } from "./overlays/tasks-center.js";
+import { createTaskBoardFacade } from "../services/task-board-facade.js";
+import { createLibraryCenterModel, moveLibraryCenterSelection, libraryCenterOverlay, selectedLibraryEntry, setLibraryCenterDuplicateScan, setLibraryCenterPreview } from "./overlays/library-center.js";
+import { attachLibraryContextToken, createLibraryFacade, detachLibraryContextToken } from "../services/library-facade.js";
+import { createResearchCenterModel, moveResearchCenterSelection, researchCenterOverlay, selectedResearch, setResearchCenterDetail } from "./overlays/research-center.js";
+import { createResearchFacade } from "../services/research-facade.js";
+import { createAutomationCenterModel, moveAutomationCenterSelection, automationCenterOverlay, selectedAutomation, setAutomationCenterDetail } from "./overlays/automation-center.js";
+import { createAutomationFacade } from "../services/automation-facade.js";
+import { createForgeCenterModel, moveForgeCenterSelection, forgeCenterOverlay, selectedForgeTool, setForgeCenterDetail } from "./overlays/forge-center.js";
+import { createForgeFacade } from "../services/forge-facade.js";
+import { createTrustAuthority } from "../security/trust-authority.js";
+import { createSessionMetadataStore, sessionMetadataRoot } from "../sessions/metadata-store.js";
+import { moveSelection } from "./selection-list.js";
+import { createTuiSessionController, TuiNotReadyError } from "./session-controller.js";
+import { parseSlashCommand, SLASH_COMMANDS } from "./slash-commands.js";
+import { initialTuiState, reasoningUsageLabel, reduceTuiEvent } from "./state.js";
+import { appendTranscriptMessage, appendTranscriptWarning, createTranscriptModel, transcriptItemRaw, transcriptItemText } from "./transcript-model.js";
+import { createTuiTheme, themeColor } from "./theme.js";
+import { DEFAULT_THEME_ACCENT } from "./theme-catalog.js";
+import { THEME_CHOICES, createThemeStore, parseThemeChoice } from "./theme-store.js";
+import { themeLabel, themePickerOverlay } from "./overlays/theme-picker.js";
+import { checkpointFilesText, rangeFiles, undoPickerOverlay, undoRange } from "./overlays/checkpoint-picker.js";
+import { checkpointChanges, createCheckpointStore, sessionCheckpoints } from "../workspace/checkpoint-store.js";
+import { reapplyToCheckpoint, rewindToCheckpoint } from "../workspace/restore.js";
+import { hasActiveRuns } from "../runtime/active-run.js";
+import { PROMPT_HISTORY_LIMIT, createPromptHistoryStore, promptHistoryEnabled } from "./prompt-history-store.js";
+import { configSet, configUnset } from "../config/commands.js";
+import { osc52CopySequence, reduceViewport, transcriptEventAddsItem } from "./components/transcript.js";
+import { MODEL_ID, NO_MODEL, NO_PROVIDER_MODEL, closeOverlay, createTuiAppState, lastProjectToken, modelItems, openOverlay, permissionDryRunSlash, pickerMove, providerItems, queuedActionPreview, reduceAppAction, replaceLastProjectToken, sessionStatusText, slashCommandIntent, slashCommandToCliArgs, togglePlanMode, } from "./shell-model.js";
+import { deriveShellLayout, pickerWindow } from "./shell-layout.js";
+import { budget as layoutBudget, MIN_COLUMNS, MIN_ROWS } from "./regions/budget.js";
+import { composerMeasure, createRegionViews } from "./regions/views.js";
+import { displayWidth, truncateDisplay, truncateMiddle } from "./text-width.js";
+import { decideShellInput } from "./shell-input.js";
+import { createRenderCoordinator } from "./render-coordinator.js";
+import { MOTION_FRAME_MS, frameIndex } from "./render-scheduler.js";
+import { onboardingSteps } from "./onboarding.js";
+import { setupEndLines, setupOverlay, setupStart } from "./setup-wizard.js";
+import { createVimState, handleVimInput, toggleVim, vimModeHint } from "./vim-mode.js";
+export { closeOverlay, createTuiAppState, permissionDryRunSlash, queuedActionPreview, reduceAppAction, slashCommandIntent, slashCommandToCliArgs, togglePlanMode } from "./shell-model.js";
+const execFileAsync = promisify(execFile);
+/* R5b D5 (Q-R5-15): the last 1,000 prompts, the same bound in memory and on disk. */
+const MAX_HISTORY = PROMPT_HISTORY_LIMIT;
+/* R1 lane I (E5): a refresh after a run ends returns equal data in new objects; keeping the old object keeps React from
+   committing an identical frame on an idle screen. */
+function sameValue(a, b) { if (a === b)
+    return true; try {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+catch {
+    return false;
+} }
+function errorCode(error) { const code = error?.code; return typeof code === 'string' && /^[A-Z0-9_]{1,64}$/u.test(code) ? code : 'UNAVAILABLE'; }
+/* The provider, catalog and key paths printed only the error's code before R2; the error anatomy keeps it that way (it
+   gets the code and nothing else), so no message text of those paths reaches the screen. */
+function codeOnly(error) { return { code: errorCode(error) }; }
+/*
+ * R2 (Q-R2-4, gate E6): every error the app shows is lane E's anatomy — headline · what to do · dim "Details: … (CODE)
+ * · where to look" — with the action that failed in front of the headline; `note` is a fact the person must also read
+ * ("The key was not saved."); `rejected` says the action was refused, not broken. The raw message reaches only the
+ * details line, through describeError.
+ */
+export function screenErrorText(error, context, { note, rejected = false } = {}) {
+    const view = describeError(error);
+    const what = note ? t('screen.error.withNote', { what: view.what, note }) : view.what;
+    return errorViewLines({ ...view, what: context ? t(rejected ? 'screen.error.rejected' : 'screen.error.context', { context, what }) : what }).join('\n');
+}
+/* One row (a notice inside an overlay): the same parts, joined. */
+function screenErrorLine(error, context) { return screenErrorText(error, context).split('\n').join(' · '); }
+/* The action that failed: a dictionary label, or a slash command with its operation. */
+const act = (id, params) => t(id, params);
+export function reasoningEffortChoices(model) {
+    if (model.reasoning !== true || !Array.isArray(model.reasoningEfforts) || model.reasoningEfforts.length === 0)
+        return [];
+    /* R5a (owner 2026-09-24): always in TALOS's order, default first, never in the order the model declares them. */
+    return ['default', ...orderedEfforts(model.reasoningEfforts)];
+}
+export async function selectExplicitModel(id, catalog, setControllerModel) { await commitModelSelection({ id, catalog, setControllerModel }); }
+export async function runControllerSlashAction(name, controller) { if (name !== 'compact')
+    return null; const result = await controller.compact(); return result?.compattato === false ? t('screen.compact.already') : t('screen.compact.done'); }
+/* P13: what still works while an agent is watched (the rest of the keys do nothing; Esc goes back). */
+const AGENT_VIEW_ACTIONS = new Set(['interrupt', 'exit', 'agent-tree', 'page-up', 'page-down', 'transcript-top', 'transcript-bottom', 'redraw', 'reasoning-toggle', 'tool-details', 'help']);
+function localMessage(state, text) { const id = `local-${Date.now()}-${Math.random()}`; const base = state.messages.length >= 511 ? state.messages.slice(-511) : state.messages; return { ...state, messages: [...base, { id, role: 'assistant', text }], transcript: appendTranscriptWarning(state.transcript, text) }; }
+function userMessage(state, text, id = `user-${Date.now()}-${Math.random()}`) { const base = state.messages.length >= 511 ? state.messages.slice(-511) : state.messages; return { ...state, messages: [...base, { id, role: 'user', text }], transcript: appendTranscriptMessage(state.transcript, { role: 'user', text }) }; }
+/* R5b D4 (Q-R5-14): the theme is live. run.ts hands the app the store it paints the background from; without one (tests,
+   embedders) the app keeps its own, seeded from `capabilities` and `accentId` as before. The colours below follow the store
+   at every render, and a change of theme remounts the main tree (its key), so memoised rows are drawn again. */
+export function createTuiAppComponent(React, Ink, baseCapabilities = { interactive: true, color: true, motion: true, unicode: true }, accentId, givenThemeStore) {
+    const h = React.createElement;
+    const themeStore = givenThemeStore ?? createThemeStore(baseCapabilities, accentId ?? DEFAULT_THEME_ACCENT);
+    let capabilities = baseCapabilities, theme = createTuiTheme(capabilities, accentId);
+    let bootColor, transcriptColor, pickerColor, approvalColor, toolColor, footerColor;
+    const applyLive = (live) => {
+        capabilities = live.capabilities;
+        theme = live.theme;
+        bootColor = themeColor(theme, 'boot');
+        transcriptColor = themeColor(theme, 'transcript');
+        pickerColor = themeColor(theme, 'picker');
+        approvalColor = themeColor(theme, 'approval');
+        toolColor = themeColor(theme, 'tool');
+        footerColor = themeColor(theme, 'footer');
+    };
+    applyLive(themeStore.getSnapshot());
+    const BootSequence = createBootSequenceComponent(React, Ink);
+    const Regions = createRegionViews(React, Ink);
+    /* The composer region (regions/views.ts): subscribes to the composer store itself, capped by the budget. */
+    const ComposerView = Regions.ComposerRegion;
+    const renderInline = (text, keyPrefix) => parseMarkdownInline(text).map((token, index) => {
+        const key = `${keyPrefix}-${index}`;
+        if (token.kind === 'strong')
+            return h(Ink.Text, { key, bold: true }, token.text);
+        if (token.kind === 'emphasis')
+            return h(Ink.Text, { key, italic: true }, token.text);
+        if (token.kind === 'code')
+            return h(Ink.Text, { key, color: toolColor }, token.text);
+        if (token.kind === 'strike')
+            return h(Ink.Text, { key, strikethrough: true, dimColor: true }, token.text);
+        if (token.kind === 'link')
+            return h(React.Fragment, { key }, h(Ink.Text, { underline: true, color: pickerColor }, token.text), h(Ink.Text, { dimColor: true }, ` (${token.href})`));
+        return h(Ink.Text, { key }, token.text);
+    });
+    const MarkdownView = React.memo(function MarkdownView({ text, width }) {
+        const parseMemoRef = React.useRef(null);
+        if (!parseMemoRef.current)
+            parseMemoRef.current = createMarkdownParseMemo();
+        const blocks = parseMemoRef.current.get(text);
+        return h(React.Fragment, null, ...blocks.map((block, index) => {
+            if (block.kind === 'heading')
+                return h(Ink.Text, { key: index, bold: true }, ...renderInline(block.text, `h-${index}`));
+            if (block.kind === 'code')
+                return h(Ink.Box, { key: index, flexDirection: 'column' }, ...block.tokens.map((line, lineIndex) => h(Ink.Text, { key: lineIndex }, ...line.map((token, tokenIndex) => h(Ink.Text, { key: tokenIndex, dimColor: token.kind === 'comment', bold: token.kind === 'keyword' || token.kind === 'key' }, markdownSafeText(token.text))))));
+            if (block.kind === 'blockquote')
+                return h(Ink.Box, { key: index, flexDirection: 'column', paddingLeft: 1 }, ...block.text.split('\n').map((line, lineIndex) => h(Ink.Text, { key: lineIndex, dimColor: true }, h(Ink.Text, { bold: true }, '│ '), ...renderInline(line, `q-${index}-${lineIndex}`))));
+            if (block.kind === 'list')
+                return h(Ink.Box, { key: index, flexDirection: 'column' }, ...block.items.map((item, itemIndex) => h(Ink.Text, { key: itemIndex }, '  '.repeat(block.depths[itemIndex] ?? 0) + (block.ordered ? String(block.start + itemIndex) + '. ' : '• '), ...renderInline(item, `l-${index}-${itemIndex}`))));
+            if (block.kind === 'table') {
+                const layout = markdownBlockLines(block, width);
+                return h(Ink.Box, { key: index, flexDirection: 'column' }, ...layout.lines.map((line, lineIndex) => h(Ink.Text, { key: lineIndex, bold: layout.mode === 'wide' && lineIndex === 0, dimColor: lineIndex === 1 && layout.mode === 'wide' }, line || ' ')));
+            }
+            return h(Ink.Text, { key: index }, ...renderInline(block.text, `p-${index}`));
+        }));
+    }, markdownRenderPropsEqual);
+    /* The command menu (lane O builder, fitted to its budget like every overlay, Q-R1-3). It subscribes to the composer and
+       selection stores itself, so typing a query re-renders the menu, not the root. */
+    const CommandMenuView = React.memo(function CommandMenuView({ composerStore, selectionStore, maxRows, columns }) {
+        const editor = React.useSyncExternalStore(composerStore.subscribe, composerStore.getSnapshot, composerStore.getSnapshot);
+        const selection = React.useSyncExternalStore(selectionStore.subscribe, selectionStore.getSnapshot, selectionStore.getSnapshot);
+        /* R4 Q-R4-5: the highlight is the row Enter runs; none after a typo (Enter then sends the text as typed). */
+        return renderOverlay(h, Ink, commandMenuOverlay({ text: editor.text, selected: commandMenuHighlight(editor.text, selection) }), { maxRows, columns, accentColor: pickerColor });
+    }, (previous, next) => previous.composerStore === next.composerStore && previous.selectionStore === next.selectionStore && previous.maxRows === next.maxRows && previous.columns === next.columns);
+    const MeasuredTranscriptRow = React.memo(function MeasuredTranscriptRow({ item, measurementKey, measurementStore, renderItem }) {
+        const ref = React.useRef(null);
+        /* R1 lane I measurement (E5): `useBoxMetrics` also tracks left/top and sets state when a row only MOVES (an overlay
+           opens, the terminal resizes), which cost one identical full repaint. The height is read after layout instead, on
+           every render of this row, and the store publishes only a changed height; a row that only moved commits nothing. */
+        React.useLayoutEffect(() => {
+            const node = ref.current;
+            if (!node)
+                return;
+            const { height } = Ink.measureElement(node);
+            if (height > 0)
+                measurementStore.measure(measurementKey, height);
+        });
+        return h(Ink.Box, { ref, flexDirection: 'column' }, renderItem(item));
+    }, (previous, next) => previous.item === next.item && previous.measurementKey === next.measurementKey && previous.measurementStore === next.measurementStore && previous.renderItem === next.renderItem);
+    /*
+     * R1 (Q-R1-2, E4, E9): the transcript inside its region. The window is planned in ROWS with measured heights
+     * (`useBoxMetrics` per mounted item; an item never mounted is counted, not estimated), the region is bottom-anchored
+     * and clipped, and the one announcement row keeps the person's latest prompt in sight (D-04). `onPlan` reports the
+     * geometry the key handlers need (PageUp/PageDown, Ctrl+Home) and the rows added while the person reads above the
+     * tail, so the view stays where they left it.
+     */
+    const TranscriptView = React.memo(function TranscriptView({ items, scrollRows, rowBudget, width, raw, expandedTools, reasoningVisible = true, revealId, measurementStore, renderItem, onPlan, dimColor, now }) {
+        React.useSyncExternalStore(measurementStore.subscribe, measurementStore.getSnapshot, measurementStore.getSnapshot);
+        /* R5a S8: a collapsed reasoning block is one row, a shown one a box: the choice is part of every measured height. */
+        const variant = (raw ? 'raw' : expandedTools ? 'pretty-expanded' : 'pretty-compact') + (reasoningVisible ? '' : '-thought');
+        const revealIndex = revealId ? items.findIndex((item) => item.id === revealId) : -1;
+        /* Lane RD contract (R3): the estimate may read the clock of a running row; an estimator without it ignores it. */
+        const estimateOptions = { raw, expandedTools, reasoningVisible, ...(typeof now === 'number' ? { now } : {}) };
+        const heightOf = (item) => measurementStore.height(transcriptMeasurementKey(item.id, width, variant)) ?? estimateTranscriptItemRows(item, width, estimateOptions);
+        const plan = (budgetRows) => planTranscriptVirtualWindow({ items, offset: 0, rowBudget: budgetRows, scrollRows, revealIndex, heightOf });
+        let planned = plan(rowBudget), announcement = null;
+        const latestUser = (() => { for (let index = items.length - 1; index >= 0; index--) {
+            const item = items[index];
+            if (item.kind === 'message' && item.role === 'user')
+                return index;
+        } return -1; })();
+        const announce = (window) => {
+            const hidden = window.hiddenAbove ?? 0;
+            const promptAboveView = latestUser >= 0 && window.firstRowFromBottom !== undefined && window.firstRowFromBottom(latestUser) >= (window.scrollRows ?? 0) + Math.max(0, rowBudget - 1);
+            const messagesAbove = items.slice(0, hidden).filter((item) => item.kind === 'message').length;
+            const latest = latestUser >= 0 ? items[latestUser] : null;
+            return transcriptAnnouncement({ hiddenAbove: hidden, hiddenMessagesAbove: messagesAbove, latestPrompt: latest && latest.kind === 'message' ? latest.text : null, promptAboveView, width });
+        };
+        if (rowBudget > 1) {
+            announcement = announce(planned);
+            if (announcement)
+                planned = plan(rowBudget - 1);
+        }
+        const anchorIndex = planned.end > 0 ? planned.end - 1 : -1;
+        const indexById = (id) => items.findIndex((item) => item.id === id);
+        const report = {
+            totalRows: planned.totalRows ?? 0, maxScroll: planned.maxScroll ?? 0, scrollRows: planned.scrollRows ?? 0, itemRows: announcement ? rowBudget - 1 : rowBudget,
+            anchorId: anchorIndex >= 0 ? items[anchorIndex].id : null, anchorBelow: anchorIndex >= 0 && planned.rowsBelow ? planned.rowsBelow(anchorIndex) : 0,
+            belowOf: (id) => { const index = indexById(id); return index >= 0 && planned.rowsBelow ? planned.rowsBelow(index) : null; },
+        };
+        React.useLayoutEffect(() => { onPlan(report); }, [onPlan, report.totalRows, report.maxScroll, report.scrollRows, report.itemRows, report.anchorId, report.anchorBelow]);
+        return h(Regions.TranscriptRegion, { rows: rowBudget, announcement, clipBelow: planned.clipBelow ?? 0, color: dimColor }, ...planned.rows.map((item) => {
+            const measurementKey = transcriptMeasurementKey(item.id, width, variant);
+            return h(MeasuredTranscriptRow, { key: item.id, item, measurementKey, measurementStore, renderItem });
+        }));
+    }, (previous, next) => previous.items === next.items && previous.scrollRows === next.scrollRows && previous.rowBudget === next.rowBudget && previous.width === next.width && previous.raw === next.raw && previous.expandedTools === next.expandedTools && previous.reasoningVisible === next.reasoningVisible && previous.revealId === next.revealId && previous.measurementStore === next.measurementStore && previous.renderItem === next.renderItem && previous.onPlan === next.onPlan && previous.dimColor === next.dimColor && previous.now === next.now);
+    return function TuiApp(props) {
+        const live = React.useSyncExternalStore(themeStore.subscribe, themeStore.getSnapshot, themeStore.getSnapshot);
+        applyLive(live);
+        const { runtime, registry, catalog, invocation, projectRoot, paths, permissionRules, autoClassifier, initialPrompt, initialReasoningEffort = null, renderCoordinator, keymap: effectiveKeymap = KEYBINDINGS, terminalSize } = props;
+        const inkApp = Ink.useApp();
+        const inkStdout = Ink.useStdout?.();
+        const stdout = inkStdout?.stdout ?? process.stdout;
+        const baseModel = invocation.model ?? 'openai:gpt-5-mini';
+        const baseMode = (invocation.permissionMode ?? 'default');
+        const [state, setState] = React.useState(() => initialTuiState({ model: NO_PROVIDER_MODEL, permissionMode: baseMode }));
+        const [appState, setAppState] = React.useState(() => ({ ...createTuiAppState(), reasoningVisible: props.reasoning === 'visible' }));
+        const composerStoreRef = React.useRef(null);
+        if (!composerStoreRef.current)
+            composerStoreRef.current = createComposerStore(appState.editor);
+        const composerStore = composerStoreRef.current;
+        const currentEditor = () => composerStore.getSnapshot();
+        const commandMenuSelectionStoreRef = React.useRef(null);
+        if (!commandMenuSelectionStoreRef.current)
+            commandMenuSelectionStoreRef.current = createCommandMenuSelectionStore();
+        const commandMenuSelectionStore = commandMenuSelectionStoreRef.current;
+        const transcriptMeasurementStoreRef = React.useRef(null);
+        if (!transcriptMeasurementStoreRef.current)
+            transcriptMeasurementStoreRef.current = createTranscriptMeasurementStore();
+        const transcriptMeasurementStore = transcriptMeasurementStoreRef.current;
+        const [vim, setVim] = React.useState(() => createVimState());
+        /* R4 contract (lane F owns launch-state.ts and BootSequence): the boot plays full only on the first launch and after an
+           update, short otherwise (Q-R4-4). Asked once per mount; a plan that cannot be read is a full boot. */
+        const bootPlanRef = React.useRef(null);
+        if (!bootPlanRef.current) {
+            try {
+                bootPlanRef.current = bootPlan({ dataRoot: paths.dataRoot, version: CLI_VERSION, build: currentBuildId() ?? TALOS_BASE_COMMIT, now: Date.now() });
+            }
+            catch {
+                bootPlanRef.current = { mode: 'full', firstLaunch: true };
+            }
+        }
+        const [boot, setBoot] = React.useState(() => createBootState(Date.now()));
+        /* R4 Q-R4-9 / E9: each entry keeps its paste blocks, so a recalled paste stays collapsed; the text is sent as it was. */
+        const [history, setHistory] = React.useState([]);
+        const historyIndexRef = React.useRef(-1);
+        const reverseIndexRef = React.useRef(0);
+        const [viewport, setViewport] = React.useState(() => ({ offset: 0, pageSize: 12, unseen: 0, followingTail: true }));
+        const [pending, setPending] = React.useState(null);
+        const [approvalExpanded, setApprovalExpanded] = React.useState(false);
+        const [approvalScroll, setApprovalScroll] = React.useState(0);
+        /* R3 gate E11 (Q-R3-6): the highlighted choice of the approval dialog, Deny by default. */
+        const [approvalSelected, setApprovalSelected] = React.useState(APPROVAL_DEFAULT_SELECTED);
+        /*
+         * R3 approval key race, owner decision (binding): for APPROVAL_GRACE_MS after the dialog is first shown for a request,
+         * keys keep going to the composer and never answer it; after that the dialog takes every key. What the key handler
+         * needs is read from refs set synchronously when the approval arrives, never from the last render (Ink's useInput
+         * closes over the previous render, so routing by render state made a key's target depend on paint timing).
+         */
+        const clockRef = React.useRef(props.clock ?? Date.now);
+        const approvalShownRef = React.useRef(null);
+        const pendingRef = React.useRef(null);
+        const approvalUiRef = React.useRef({ expanded: false, selected: APPROVAL_DEFAULT_SELECTED });
+        /* R3 Q-R3-13: null while unknown (no probe, or not answered yet). */
+        const [sandboxVerified, setSandboxVerified] = React.useState(null);
+        const sandboxAskedRef = React.useRef(false);
+        const askSandboxRef = React.useRef(() => { });
+        askSandboxRef.current = () => {
+            const probe = props.shellIsolation;
+            if (!probe || sandboxAskedRef.current)
+                return;
+            sandboxAskedRef.current = true;
+            /* A check stopped because TALOS is quitting answers nothing: no label either way. */
+            void probe().then(result => { if (!result.aborted)
+                setSandboxVerified(result.verified === true); }, () => { });
+        };
+        /* R3 (lane RD contract): a once-a-second clock for running tool rows (`running 12 s`), ticking only while a tool runs. */
+        const [toolNow, setToolNow] = React.useState(() => Date.now());
+        /* R1 lane O contract: help scrolls inside maxRows (PgUp/PgDn, Up/Down); the approval scroll stops at the fit's last offset. */
+        const [helpOffset, setHelpOffset] = React.useState(0);
+        const helpMaxOffsetRef = React.useRef(0);
+        const helpPageRef = React.useRef(1);
+        const approvalMaxOffsetRef = React.useRef(0);
+        const [diff, setDiff] = React.useState('');
+        const [pickerQuery, setPickerQuery] = React.useState('');
+        const [pickerSelection, setPickerSelection] = React.useState(() => ({ query: '', selected: 0, pageSize: 10 }));
+        const [modelRows, setModelRows] = React.useState([]);
+        const [providerRows, setProviderRows] = React.useState([]);
+        const [sessionRows, setSessionRows] = React.useState([]);
+        const [agentRows, setAgentRows] = React.useState([]);
+        const [agentTreeOverlay, setAgentTreeOverlay] = React.useState(null);
+        /* P13 (owner decisions 2026-09-26): the agent whose transcript takes the main view (agent-view.ts), read-only. */
+        const [agentView, setAgentView] = React.useState(null);
+        const agentViewRef = React.useRef(null);
+        const mainViewportRef = React.useRef(null);
+        const [providerStep, setProviderStep] = React.useState({ kind: 'list' });
+        const [chosenProvider, setChosenProvider] = React.useState(null);
+        const [selectionLoaded, setSelectionLoaded] = React.useState(false);
+        const [keyMissing, setKeyMissing] = React.useState(false);
+        const [modelList, setModelList] = React.useState({ loading: false, verified: false, notice: '', label: '', engineDown: false });
+        /* P17 (owner decisions 2026-09-26): the guided setup — first launch when something is missing, /setup, `talos setup`.
+           It chains the provider, key and model windows that exist; `setupTransitionRef` holds the setup open while one window
+           hands over to the next (the provider window closes, the model window opens). */
+        const [setupActive, setSetupActive] = React.useState(false);
+        const setupRef = React.useRef(false);
+        const setupTransitionRef = React.useRef(false);
+        /* A local engine chosen in the setup that did not answer: its model window says so (R retries, Esc goes back), and the
+           engine becomes the chosen provider only when one of its models is chosen. */
+        const setupPendingProviderRef = React.useRef(null);
+        /* P21: the OpenRouter sign-in under way (its loopback port closes on cancel, timeout or success). */
+        const oauthLoginRef = React.useRef(null);
+        const [providerSecret, setProviderSecret] = React.useState('');
+        const [auxCompletions, setAuxCompletions] = React.useState([]);
+        const [fileCompletion, setFileCompletion] = React.useState(null);
+        const fileCompletionRef = React.useRef(null);
+        fileCompletionRef.current = fileCompletion;
+        /* The token last looked up, the token the person closed with Esc (the list stays closed until the token changes), and a
+           sequence number so a slow answer for an older token is dropped. */
+        /* R5b D6: the project walk behind @, built once and reused for a short while (project-file-index.ts). */
+        const projectIndexRef = React.useRef(createProjectFileIndexCache(projectRoot));
+        const completionWatchRef = React.useRef({ token: null, dismissed: null, seq: 0 });
+        const [currentModelMeta, setCurrentModelMeta] = React.useState(null);
+        const [reasoningEffort, setReasoningEffort] = React.useState(initialReasoningEffort);
+        const [modelEffortStep, setModelEffortStep] = React.useState(null);
+        /* R5a: the effort line was opened by /effort (not as /model's second step): Backspace does not lead to a model list. */
+        const [effortOnly, setEffortOnly] = React.useState(false);
+        const [busySince, setBusySince] = React.useState(() => Date.now());
+        const [motionNow, setMotionNow] = React.useState(() => Date.now());
+        const [renderEpoch, setRenderEpoch] = React.useState(0);
+        const [queuedActions, setQueuedActions] = React.useState([]);
+        const [queueEditor, setQueueEditor] = React.useState(null);
+        const [transcriptSearch, setTranscriptSearch] = React.useState(null);
+        const [transcriptSelectedId, setTranscriptSelectedId] = React.useState(null);
+        const [transcriptRevealId, setTranscriptRevealId] = React.useState(null);
+        const [transcriptRaw, setTranscriptRaw] = React.useState(false);
+        const [trustCenter, setTrustCenter] = React.useState(null);
+        const [mcpCenter, setMcpCenter] = React.useState(null);
+        const [hookCenter, setHookCenter] = React.useState(null);
+        const [pluginCenter, setPluginCenter] = React.useState(null);
+        const [memoryCenter, setMemoryCenter] = React.useState(null);
+        const [notesCenter, setNotesCenter] = React.useState(null);
+        const [tasksCenter, setTasksCenter] = React.useState(null);
+        const [libraryCenter, setLibraryCenter] = React.useState(null);
+        const [researchCenter, setResearchCenter] = React.useState(null);
+        const [automationCenter, setAutomationCenter] = React.useState(null);
+        const [forgeCenter, setForgeCenter] = React.useState(null);
+        const [contextStatus, setContextStatus] = React.useState(null);
+        const [contextInspector, setContextInspector] = React.useState(null);
+        /* R5b D4: the /theme picker — the row chosen, and the theme in use when it opened (Esc puts it back). */
+        const [themePicker, setThemePicker] = React.useState(null);
+        /* R5b D3 (Q-R5-13): the /undo picker (its rows, the highlighted one, and the question: null, 0 Cancel or 1 act). */
+        const [undoPicker, setUndoPicker] = React.useState(null);
+        /* R5b: the /history list (its filter and the highlighted row). */
+        const [historyPicker, setHistoryPicker] = React.useState(null);
+        const checkpointStoreRef = React.useRef(undefined);
+        const checkpointStoreFor = () => { if (checkpointStoreRef.current === undefined)
+            checkpointStoreRef.current = paths?.checkpointsRoot ? createCheckpointStore({ rootDir: paths.checkpointsRoot, projectRoot }) : null; return checkpointStoreRef.current; };
+        const controllerRef = React.useRef(null);
+        const modelPickerRef = React.useRef(null);
+        const providerPickerRef = React.useRef(null);
+        const sessionPickerRef = React.useRef(null);
+        /* R4: a resume or fork being confirmed; a second Enter meanwhile attached the session twice and left its cut-off run
+           "writing" (measured in s09 once Enter ran the command on the first press: review D-08). */
+        const sessionConfirmingRef = React.useRef(false);
+        const mcpFacadeRef = React.useRef(null);
+        const hookFacadeRef = React.useRef(null);
+        const pluginFacadeRef = React.useRef(null);
+        const memoryFacadeRef = React.useRef(null);
+        const notesFacadeRef = React.useRef(null);
+        const tasksFacadeRef = React.useRef(null);
+        const libraryFacadeRef = React.useRef(null);
+        const researchFacadeRef = React.useRef(null);
+        const automationFacadeRef = React.useRef(null);
+        const forgeFacadeRef = React.useRef(null);
+        /* R4 Q-R4-7 / E7: the exit rule lives in interrupt.ts; it reads, at the moment of the key, whether the composer has a
+           draft, a picker or dialog is open, or the `@` list is open (interruptContextRef is refreshed on every render). */
+        const interruptContextRef = React.useRef(() => ({ draft: false, dialog: false, completion: false }));
+        const interruptRef = React.useRef(null);
+        if (!interruptRef.current)
+            interruptRef.current = createInterruptController({ context: () => interruptContextRef.current() });
+        /* R1 lane X contract (D-12): the first Ctrl+C at idle only arms the exit; the hint stays in the status row for the
+           confirmation window. Its single timer is the only commit an idle screen may make (one clear after 2 s, gate E5).
+           R4: the hint names the key that armed it (Ctrl+C or Ctrl+D). */
+        const [exitHint, setExitHint] = React.useState(false);
+        const [exitHintKey, setExitHintKey] = React.useState('ctrl-c');
+        const exitHintTimerRef = React.useRef(null);
+        const clearExitHintTimer = () => { if (exitHintTimerRef.current !== null) {
+            clearTimeout(exitHintTimerRef.current);
+            exitHintTimerRef.current = null;
+        } };
+        const showExitHint = (key = 'ctrl-c') => { clearExitHintTimer(); setExitHintKey(key); setExitHint(true); exitHintTimerRef.current = setTimeout(() => { exitHintTimerRef.current = null; setExitHint(false); }, EXIT_CONFIRM_WINDOW_MS); };
+        const hideExitHint = () => { if (exitHintTimerRef.current === null)
+            return; clearExitHintTimer(); setExitHint(false); };
+        React.useEffect(() => () => clearExitHintTimer(), []);
+        /* R1 lane contract (TuiAppProps.onExit): the last session id and transcript, reported once on unmount. The unmount
+           covers /exit, Ctrl+C, Ctrl+D and a forced exit, and runs before Ink leaves the alternate screen. */
+        const exitSnapshotRef = React.useRef({ sessionId: null, items: [] });
+        exitSnapshotRef.current = { sessionId: state.sessionId, items: state.transcript.items };
+        const onExitRef = React.useRef(props.onExit);
+        onExitRef.current = props.onExit;
+        React.useEffect(() => () => { onExitRef.current?.(exitSnapshotRef.current); }, []);
+        /* R1 E9/E15: the transcript's last plan, read by the scroll keys; its anchor keeps a scrolled view still. */
+        const transcriptPlanRef = React.useRef({ totalRows: 0, maxScroll: 0, scrollRows: 0, itemRows: 0, anchorId: null, anchorBelow: 0, belowOf: () => null });
+        const onTranscriptPlan = React.useCallback((plan) => {
+            const previous = transcriptPlanRef.current;
+            transcriptPlanRef.current = plan;
+            if (!previous.anchorId)
+                return;
+            const below = plan.belowOf(previous.anchorId);
+            if (below === null || below === previous.anchorBelow)
+                return;
+            const delta = below - previous.anchorBelow;
+            setViewport((view) => view.followingTail || view.offset === 0 ? view : { ...view, offset: Math.max(0, view.offset + delta) });
+        }, []);
+        const transcriptPageRows = () => Math.max(1, transcriptPlanRef.current.itemRows - 1);
+        const scrollTranscript = (event) => {
+            setTranscriptRevealId(null);
+            setViewport((view) => {
+                const plan = transcriptPlanRef.current, pageSize = transcriptPageRows(), current = { ...view, offset: Math.min(plan.maxScroll, Math.max(0, plan.scrollRows)), pageSize };
+                if (event === 'top')
+                    return plan.maxScroll > 0 ? { ...current, offset: plan.maxScroll, followingTail: false } : reduceViewport(current, 'jump-tail', 0);
+                if (event === 'jump-tail')
+                    return reduceViewport(current, 'jump-tail', 0);
+                return reduceViewport(current, event, plan.maxScroll + pageSize);
+            });
+        };
+        const reasoningVisibleRef = React.useRef(appState.reasoningVisible);
+        reasoningVisibleRef.current = appState.reasoningVisible;
+        const renderCoordinatorRef = React.useRef(null);
+        if (!renderCoordinatorRef.current)
+            renderCoordinatorRef.current = renderCoordinator ?? createRenderCoordinator();
+        const coordinator = renderCoordinatorRef.current;
+        const visibleEpochRef = React.useRef(0);
+        const eventSequenceRef = React.useRef(0);
+        const onboardingShownRef = React.useRef(false);
+        React.useEffect(() => {
+            const unsubscribe = coordinator.subscribe(batch => setRenderEpoch(batch.epoch));
+            return () => { unsubscribe(); if (!renderCoordinator)
+                coordinator.dispose(); };
+        }, [coordinator, renderCoordinator]);
+        React.useLayoutEffect(() => {
+            if (renderEpoch <= visibleEpochRef.current)
+                return;
+            visibleEpochRef.current = renderEpoch;
+            coordinator.markVisible(renderEpoch);
+        }, [coordinator, renderEpoch]);
+        /* ⛔ Fails closed: a catalog that cannot answer is a send that does not happen. */
+        const readinessFor = async (model) => {
+            if (typeof catalog?.readiness !== 'function')
+                return { ready: false, code: 'PROVIDER_NOT_CHOSEN', provider: null, message: t('screen.readiness.unavailable') };
+            try {
+                return await catalog.readiness(model);
+            }
+            catch (error) {
+                return { ready: false, code: 'PROVIDER_NOT_CHOSEN', provider: null, message: t('screen.readiness.unchecked', { code: errorCode(error) }) };
+            }
+        };
+        if (!controllerRef.current)
+            controllerRef.current = createTuiSessionController({
+                runtime, projectRoot, model: baseModel, mode: baseMode, rules: permissionRules ?? { allow: [], ask: [], deny: [] }, paths, ...(autoClassifier ? { autoClassifier } : {}), readiness: readinessFor,
+                onEvent: (event) => {
+                    developmentLog('ui.runtime_event', event, event?.type === 'run.failed' ? 'error' : 'debug', 'tui');
+                    const eventId = `runtime-${++eventSequenceRef.current}-${String(event.type)}`;
+                    coordinator.enqueueEvent(eventId, () => {
+                        if (event.type === 'run.started')
+                            setBusySince(Date.now());
+                        if (event.type === 'run.completed' || event.type === 'run.failed' || event.type === 'run.cancelled')
+                            interruptRef.current.reset();
+                        if (transcriptEventAddsItem(event) && (event.type !== 'reasoning.started' || reasoningVisibleRef.current))
+                            setViewport((view) => reduceViewport(view, 'new-content', 0));
+                        setState((current) => reduceTuiEvent(current, event));
+                    });
+                },
+                onApproval: (next) => {
+                    developmentLog('ui.approval', { requestId: next?.requestId ?? null, action: next?.action ?? null, reason: next?.reason ?? null }, 'info', 'tui');
+                    /* R3 approval key race: the grace starts when a request is first shown, not on every redraw. */
+                    pendingRef.current = next;
+                    if (!next)
+                        approvalShownRef.current = null;
+                    else if (approvalShownRef.current?.requestId !== next.requestId) {
+                        approvalShownRef.current = { requestId: next.requestId, shownAt: clockRef.current(), answered: false };
+                        approvalUiRef.current = { expanded: false, selected: APPROVAL_DEFAULT_SELECTED };
+                    }
+                    return coordinator.immediate('approval', () => {
+                        if (next)
+                            setTranscriptSearch(null);
+                        setPending(next);
+                        setApprovalExpanded(false);
+                        setApprovalScroll(0);
+                        setApprovalSelected(APPROVAL_DEFAULT_SELECTED);
+                        /* R3 Q-R3-7 (gate E7): the status says `waiting for you` exactly while the dialog is open. */
+                        setState((current) => current.waitingForPerson === Boolean(next) ? current : { ...current, waitingForPerson: Boolean(next) });
+                        setAppState((current) => next ? openOverlay(current, { kind: 'approval', requestId: next.requestId }) : (current.overlay?.kind === 'approval' ? closeOverlay(current) : current));
+                    });
+                },
+                onQueueChange: (next) => { developmentLog('ui.queue', { count: next.length, kinds: next.map(row => row.kind) }, 'debug', 'tui'); return coordinator.enqueueEvent(`queue-${++eventSequenceRef.current}`, () => setQueuedActions([...next])); },
+                onQueueRestored: (next) => coordinator.enqueueEvent(`queue-restored-${++eventSequenceRef.current}`, () => { setQueueEditor({ selected: 0, editing: false, draft: '' }); setState((current) => localMessage(current, tn('screen.queue.restored', next.length))); }),
+                onQueuedSlash: (text) => executeSlashRef.current(text),
+                onQueuedDispatch: (action) => coordinator.enqueueEvent(`queue-dispatch-${++eventSequenceRef.current}`, () => { setViewport((view) => reduceViewport(view, 'new-content', 0)); setState((current) => userMessage(current, action.kind === 'command' ? `!${action.text}` : action.text)); }),
+                onSteerState: (next) => coordinator.enqueueEvent(`steer-${++eventSequenceRef.current}-${next.status}`, () => setState((current) => localMessage(current, next.status === 'requested' ? t('screen.steer.requested')
+                    : next.status === 'applied' ? t('screen.steer.applied')
+                        : next.status === 'cancelled' ? t('screen.steer.cancelled')
+                            : screenErrorText(Object.assign(new Error(next.message), { code: next.code }), act('screen.action.steering'), { rejected: next.status !== 'failed' })))),
+                onError: (error) => { developmentLogError('ui.error', error, {}, 'tui'); return coordinator.enqueueEvent(`error-${++eventSequenceRef.current}`, () => setState((current) => localMessage(current, screenErrorText(error)))); },
+            });
+        const controller = controllerRef.current;
+        const executeSlashRef = React.useRef(async () => { });
+        React.useEffect(() => { developmentLog('ui.state', { focus: appState.focus.current, overlay: appState.overlay?.kind ?? null, running: state.running, sessionId: state.sessionId, model: state.status.model, permissionMode: state.status.permissionMode, queueCount: queuedActions.length }, 'debug', 'tui'); }, [appState.focus.current, appState.overlay?.kind, state.running, state.sessionId, state.status.model, state.status.permissionMode, queuedActions.length]);
+        async function refreshContextStatus() {
+            const id = state.sessionId ?? controller.current?.() ?? null;
+            if (!id || typeof runtime.contextStatus !== 'function') {
+                setContextStatus(null);
+                return null;
+            }
+            try {
+                const next = await runtime.contextStatus(id);
+                setContextStatus((current) => sameValue(current, next) ? current : next);
+                return next;
+            }
+            catch {
+                setContextStatus(null);
+                return null;
+            }
+        }
+        React.useEffect(() => { void refreshContextStatus(); }, [state.sessionId, state.running]);
+        function closeAgentView() {
+            const handle = agentViewRef.current;
+            agentViewRef.current = null;
+            handle?.close();
+            setAgentView(null);
+            const saved = mainViewportRef.current;
+            mainViewportRef.current = null;
+            setViewport((view) => saved ?? { ...view, offset: 0, unseen: 0, followingTail: true });
+        }
+        function openAgentView(row) {
+            agentViewRef.current?.close();
+            if (!mainViewportRef.current)
+                mainViewportRef.current = viewport;
+            setViewport((view) => ({ ...view, offset: 0, unseen: 0, followingTail: true }));
+            agentViewRef.current = createAgentView({ runtime, target: { sessionId: row.id, task: row.task }, secretValues: secretValuesFromEnvironment(process.env), onChange: (next) => setAgentView(next) });
+        }
+        /* Another session in use (resume, fork, /clear) and the app closing let go of the watched agent. */
+        React.useEffect(() => { if (agentViewRef.current)
+            closeAgentView(); }, [state.sessionId]);
+        React.useEffect(() => () => { agentViewRef.current?.close(); agentViewRef.current = null; }, []);
+        async function refreshAgentRows() {
+            try {
+                const tree = await controller.agentTree();
+                const rows = agentRosterRows(tree);
+                setAgentRows((current) => sameValue(current, rows) ? current : rows);
+                setAgentTreeOverlay((current) => {
+                    if (!current)
+                        return current;
+                    const selectedId = selectedAgentRow(current)?.id ?? tree?.focusId ?? null;
+                    return createAgentTreeOverlayModel(rows, selectedId);
+                });
+            }
+            catch { /* Agent roster is read-only chrome; runtime errors remain on the primary session path. */ }
+        }
+        React.useEffect(() => { void refreshAgentRows(); }, [state.sessionId, state.running, state.tools.length, state.messages.length]);
+        React.useEffect(() => {
+            let alive = true;
+            /* B1 slice 18: a prompt given on the command line waits in the composer when no provider, model or key is ready. */
+            void (initialPrompt?.trim() ? readinessFor(controller.model()) : Promise.resolve(null)).then((readiness) => {
+                const prompt = readiness && !readiness.ready ? undefined : initialPrompt;
+                return controller.initialize({ resume: invocation.resume, fork: invocation.fork, initialPrompt: prompt }).then((id) => {
+                    if (!alive)
+                        return;
+                    if (prompt?.trim())
+                        setState((current) => ({ ...userMessage(current, prompt.trim(), `user-${Date.now()}`), sessionId: id ?? current.sessionId }));
+                    if (readiness && !readiness.ready) {
+                        const editor = replaceEditorText(currentEditor(), String(initialPrompt).trim());
+                        composerStore.replace(editor);
+                        setAppState((current) => ({ ...current, editor }));
+                        setState((current) => localMessage(current, readiness.message));
+                    }
+                    setBoot((current) => markBootReady(current, Date.now()));
+                    void refreshAgentRows();
+                });
+            }).catch((error) => { if (alive) {
+                setBoot((current) => markBootError(current));
+                setState((current) => localMessage(current, screenErrorText(error, act('screen.action.startup'))));
+            } });
+            void refreshSelection(() => alive);
+            return () => { alive = false; controller.close(); };
+        }, []);
+        const updateEditor = (fn) => { const editor = composerStore.update(fn); setAppState((current) => current.editor === editor ? current : { ...current, editor }); return editor; };
+        const setEditorText = (text) => updateEditor(editor => replaceEditorText(editor, text));
+        /*
+         * R4 Q-R4-8 / E8: the `@` list follows the composer while the person types (it opened on Tab only: gate §0.8). It
+         * listens to the composer store, so the fast input path keeps its speed: a key that does not change the `@` token at
+         * the end of the text costs one comparison and no render. Nothing runs while the screen is idle (R1).
+         */
+        const checkCompletion = (force = false) => {
+            const watch = completionWatchRef.current;
+            const token = lastProjectToken(composerStore.getSnapshot().text);
+            if (!force && token === watch.token)
+                return;
+            watch.token = token;
+            const seq = ++watch.seq;
+            if (force)
+                watch.dismissed = null;
+            if (!token || token === watch.dismissed) {
+                if (!token)
+                    watch.dismissed = null;
+                setFileCompletion((current) => current === null ? current : null);
+                return;
+            }
+            void completeProjectFiles(projectRoot, token, { index: () => projectIndexRef.current.get() }).then(({ rows, source }) => { if (watch.seq === seq)
+                setFileCompletion({ token, rows, selected: 0, source }); }, () => { if (watch.seq === seq)
+                setFileCompletion(null); });
+        };
+        const checkCompletionRef = React.useRef(() => { });
+        checkCompletionRef.current = () => checkCompletion(false);
+        React.useEffect(() => { const run = () => checkCompletionRef.current(); run(); return composerStore.subscribe(run); }, [composerStore]);
+        const addLocal = (text) => setState((current) => localMessage(current, text));
+        /* R4 Q-R4-6: Ctrl+L and /redraw repaint the screen and keep the conversation and the draft (Claude Code
+           `chat:clearInput` "Force a full screen redraw, preserving input and conversation", keybindings.md, 2.1.280 → 2026-09-22,
+           gate B.3). Ink's own write erases the frame it drew and draws it again; a remount alone wrote nothing (Ink skips a
+           frame equal to the last one). */
+        const repaintScreen = () => { try {
+            if (typeof inkStdout?.write === 'function')
+                inkStdout.write('');
+        }
+        catch { /* a repaint that cannot be written leaves the screen as it is */ } };
+        /* R5a S5/S8 (Q-R5-7, Q-R5-9): what Enter does while TALOS works, and the reasoning choice, both remembered. */
+        const prefs = useUiPreferences(React, { paths, projectRoot, given: { ...(props.busyInput ? { busyInput: props.busyInput } : {}), ...(props.reasoning ? { reasoning: props.reasoning } : {}) }, applyReasoning: (visible) => setAppState((current) => current.reasoningVisible === visible ? current : { ...current, reasoningVisible: visible }), onSaveError: (error) => addLocal(screenErrorText(error, act('screen.action.saveSetting'))) });
+        /* R5b D4 (Q-R5-14): a theme kept from /theme holds at once and is saved in the user configuration (every project). */
+        /* R5b D3: go back to (or re-apply up to) the chosen checkpoint; another TALOS on this project refuses it first. */
+        const runUndo = async (picked) => {
+            const store = checkpointStoreFor(), chosen = picked.rows[picked.selected];
+            if (!store || !chosen)
+                return;
+            try {
+                if (await hasActiveRuns(paths, { exceptPid: process.pid, projectRoot })) {
+                    addLocal(t('screen.undo.otherRun'));
+                    return;
+                }
+                const { direction } = undoRange(picked.rows, picked.selected);
+                const done = (direction === 'rewind' ? await rewindToCheckpoint({ store, id: chosen.id }) : await reapplyToCheckpoint({ store, id: chosen.id })).filter(row => checkpointChanges(row).length > 0);
+                addLocal(tn(direction === 'rewind' ? 'screen.undo.done' : 'screen.undo.redone', done.length, { files: checkpointFilesText(rangeFiles(done)) }));
+            }
+            catch (error) {
+                addLocal(screenErrorText(error, act('screen.action.command', { command: 'undo' })));
+            }
+        };
+        /* R5b D3 (gate finding 10: nothing on screen said a checkpoint was taken): a turn that changed files leaves one dim row. The
+           runtime finalizes the checkpoint after the run's last event, so an open one is waited for, briefly. */
+        const runStartedAtRef = React.useRef(null);
+        React.useEffect(() => {
+            if (state.running) {
+                if (!runStartedAtRef.current)
+                    runStartedAtRef.current = new Date().toISOString();
+                return;
+            }
+            const since = runStartedAtRef.current, sessionId = state.sessionId;
+            runStartedAtRef.current = null;
+            const store = since && sessionId ? checkpointStoreFor() : null;
+            if (!store || !since || !sessionId)
+                return;
+            let alive = true;
+            void (async () => {
+                for (let attempt = 0; attempt < 20 && alive; attempt += 1) {
+                    const rows = (await sessionCheckpoints(store, sessionId)).filter(row => row.createdAt >= since);
+                    if (!rows.length)
+                        return;
+                    if (rows.some(row => row.state === 'open')) {
+                        await new Promise(resolve => setTimeout(resolve, 150));
+                        continue;
+                    }
+                    const files = rangeFiles(rows);
+                    if (files.length && alive)
+                        setState((current) => ({ ...current, transcript: appendTranscriptWarning(current.transcript, t('screen.undo.marker', { files: checkpointFilesText(files) })) }));
+                    return;
+                }
+            })().catch((error) => developmentLogError('tui.checkpoint.marker.failure', error, {}, 'tui-app'));
+            return () => { alive = false; };
+        }, [state.running]);
+        const keepTheme = (id) => {
+            themeStore.set(id);
+            void saveUiPreference({ paths, projectRoot, patch: { theme: id } }).then(() => addLocal(t('screen.theme.set', { theme: themeLabel(id) })), () => addLocal(t('screen.theme.setUnsaved', { theme: themeLabel(id) })));
+        };
+        const runKeyAction = (action) => {
+            setAppState((current) => reduceAppAction(current, { type: 'key-action', action }));
+            if (action === 'redraw')
+                repaintScreen();
+            /* R5a S8 (Q-R5-9): Ctrl+T shows or hides every reasoning block, and the choice is remembered in `ui.reasoning`. */
+            if (action === 'reasoning-toggle')
+                prefs.rememberReasoning(!reasoningVisibleRef.current);
+        };
+        /* R4 Q-R4-9: a draft goes back into the composer with its paste blocks. */
+        const restoreDraft = (draft) => { const editor = editorFromDraft(draft); composerStore.replace(editor); setAppState((current) => current.editor === editor ? current : { ...current, editor }); return editor; };
+        const rememberDraft = (draft) => setHistory((rows) => draft.text.trim() ? [draft, ...rows.filter(row => row.text !== draft.text)].slice(0, MAX_HISTORY) : rows);
+        /* R5b D5 (Q-R5-15): what was SENT is also kept on disk for the next sessions of this project (a cleared draft is not: the
+           person chose to drop it). The kept rows are read once, after the ones typed meanwhile; a prompt sent before the store
+           is ready waits for it. Off (ui.history.persist false): nothing is read or written. */
+        const historyStoreRef = React.useRef({ store: null, ready: false, waiting: [] });
+        const persistDraft = (draft) => {
+            const kept = historyStoreRef.current;
+            if (!draft.text.trim())
+                return;
+            if (!kept.ready) {
+                kept.waiting.push(draft);
+                return;
+            }
+            if (kept.store)
+                void kept.store.append(draft).catch((error) => developmentLogError('tui.history.append.failure', error, {}, 'tui-app'));
+        };
+        const rememberSent = (draft) => { rememberDraft(draft); persistDraft(draft); };
+        React.useEffect(() => {
+            let alive = true;
+            void (async () => {
+                const kept = historyStoreRef.current;
+                try {
+                    if (await promptHistoryEnabled({ paths, projectRoot })) {
+                        const store = createPromptHistoryStore({ paths, projectRoot, secrets: secretValuesFromEnvironment(process.env) });
+                        const rows = await store.load();
+                        kept.store = store;
+                        if (alive)
+                            setHistory((current) => { const seen = new Set(current.map(row => row.text)); return [...current, ...rows.filter(row => !seen.has(row.text))].slice(0, MAX_HISTORY); });
+                    }
+                }
+                catch (error) {
+                    developmentLogError('tui.history.load.failure', error, {}, 'tui-app');
+                }
+                kept.ready = true;
+                const waiting = kept.waiting.splice(0);
+                for (const draft of waiting)
+                    persistDraft(draft);
+            })();
+            return () => { alive = false; };
+        }, []);
+        const transcriptItemsForCurrentView = () => appState.reasoningVisible ? state.transcript.items : state.transcript.items.filter((item) => item.kind !== 'reasoning');
+        const transcriptItemForSelection = (preferred = transcriptSelectedId) => {
+            const items = transcriptItemsForCurrentView();
+            return items.find((item) => item.id === preferred) ?? items.at(-1) ?? null;
+        };
+        const jumpTranscriptItem = (itemId) => {
+            const items = transcriptItemsForCurrentView(), index = items.findIndex((item) => item.id === itemId);
+            if (index < 0)
+                return;
+            /* R1: the row planner scrolls the target into view (revealIndex); the view stops following the tail. */
+            setTranscriptSelectedId(itemId);
+            setTranscriptRevealId(itemId);
+            setViewport((view) => index === items.length - 1 ? view : { ...view, followingTail: false });
+        };
+        const copyTranscriptItem = (preferred = transcriptSelectedId) => {
+            const item = transcriptItemForSelection(preferred);
+            if (!item) {
+                const notice = t('screen.copy.nothing');
+                setTranscriptSearch((current) => current ? { ...current, notice } : { ...createTranscriptSearchState(null), raw: transcriptRaw, notice });
+                return;
+            }
+            try {
+                const text = transcriptRaw ? transcriptItemRaw(item) : transcriptItemText(item);
+                const sequence = osc52CopySequence(text);
+                stdout.write(sequence);
+                setTranscriptSelectedId(item.id);
+                const notice = t('screen.copy.requested');
+                setTranscriptSearch((current) => current ? { ...current, selectedId: item.id, raw: transcriptRaw, notice } : { ...createTranscriptSearchState(item.id), raw: transcriptRaw, notice });
+            }
+            catch (error) {
+                const notice = screenErrorLine(error, act('screen.action.copy'));
+                setTranscriptSearch((current) => current ? { ...current, notice } : { ...createTranscriptSearchState(item.id), raw: transcriptRaw, notice });
+            }
+        };
+        const openTranscriptSearch = () => {
+            const item = transcriptItemForSelection();
+            const selectedId = item?.id ?? null;
+            if (selectedId)
+                setTranscriptSelectedId(selectedId);
+            setTranscriptSearch({ ...createTranscriptSearchState(selectedId), raw: transcriptRaw });
+        };
+        const showModel = (provider, model) => setState((current) => ({ ...current, status: { ...current.status, model: !provider ? NO_PROVIDER_MODEL : providerOfModel(model) === provider ? model : NO_MODEL } }));
+        async function refreshSelection(isAlive = () => true) {
+            try {
+                const id = typeof catalog?.chosenProvider === 'function' ? await catalog.chosenProvider() : null;
+                if (!isAlive())
+                    return;
+                setChosenProvider(id);
+                const model = controller.model();
+                showModel(id, model);
+                if (id && providerOfModel(model) === id) {
+                    const rows = await catalog.listModels({ provider: id });
+                    if (!isAlive())
+                        return;
+                    setCurrentModelMeta(rows.find(row => row.id === model) ?? null);
+                    /* R4 Q-R4-13 (lane F's onboardingSteps): a missing key is said on the first screen, before anything is sent. */
+                    const readiness = await readinessFor(model);
+                    if (!isAlive())
+                        return;
+                    setKeyMissing(!readiness.ready && (readiness.code === 'PROVIDER_KEY_MISSING' || readiness.code === 'PROVIDER_KEY_BENCHED'));
+                }
+                else
+                    setCurrentModelMeta(null);
+            }
+            catch {
+                if (isAlive())
+                    setCurrentModelMeta(null);
+            }
+            finally {
+                if (isAlive())
+                    setSelectionLoaded(true);
+            }
+        }
+        React.useEffect(() => {
+            if (!selectionLoaded || onboardingShownRef.current)
+                return;
+            const steps = onboardingSteps({ projectTrusted: true, providerConfigured: Boolean(chosenProvider), modelConfigured: Boolean(chosenProvider && providerOfModel(controller.model()) === chosenProvider), keyMissing: keyMissing && chosenProvider ? chosenProvider : keyMissing, ...(props.loadedFiles ? { loadedFiles: props.loadedFiles } : {}) });
+            if (!steps.length)
+                return;
+            onboardingShownRef.current = true;
+            const info = steps.filter(step => step.kind === 'info').map(step => step.text);
+            /* P17: on the first launch the missing steps are the guided setup, not a list of commands to type. */
+            if (bootPlanRef.current?.firstLaunch && !initialPrompt?.trim() && !invocation.setup) {
+                void (async () => {
+                    let row;
+                    try {
+                        row = chosenProvider ? (await catalog.listProviders()).find((entry) => entry.id === chosenProvider) : undefined;
+                    }
+                    catch {
+                        row = undefined;
+                    }
+                    const plan = setupStart({ firstLaunch: true, providerChosen: Boolean(chosenProvider), providerUsable: Boolean(row?.configured), keyBenched: Boolean(row?.benched), modelChosen: Boolean(chosenProvider && providerOfModel(controller.model()) === chosenProvider) });
+                    if (info.length)
+                        setState((current) => localMessage(current, info.join('\n')));
+                    if (plan.start) {
+                        await startSetup(plan.from);
+                        return;
+                    }
+                    const todo = steps.filter(step => step.kind !== 'info');
+                    if (todo.length)
+                        setState((current) => localMessage(current, [t('screen.onboarding.setup'), ...todo.map(step => '• ' + step.text + (step.command ? ' ' + step.command : ''))].join('\n')));
+                })();
+                return;
+            }
+            const todo = steps.filter(step => step.kind !== 'info');
+            setState((current) => localMessage(current, [...info, ...(todo.length ? [t('screen.onboarding.setup'), ...todo.map(step => '• ' + step.text + (step.command ? ' ' + step.command : ''))] : [])].join('\n')));
+        }, [selectionLoaded, chosenProvider, currentModelMeta, keyMissing]);
+        const closeCurrentOverlay = () => { oauthLoginRef.current?.cancel(); oauthLoginRef.current = null; setTrustCenter(null); setMcpCenter(null); setHookCenter(null); setPluginCenter(null); setMemoryCenter(null); setNotesCenter(null); setTasksCenter(null); setLibraryCenter(null); setProviderSecret(''); setProviderStep({ kind: 'list' }); setModelEffortStep(null); setEffortOnly(false); setPickerQuery(''); setPickerSelection({ query: '', selected: 0, pageSize: 10 }); setAppState((current) => closeOverlay(current)); };
+        const applyOverlay = (overlay) => setAppState((current) => openOverlay(current, overlay));
+        /* B1 slice 18: the models of the chosen provider only; with none chosen, /provider opens first and comes back here. */
+        const loadModels = async (provider) => {
+            const target = provider ?? chosenProvider;
+            if (!target) {
+                await loadProviders();
+                return;
+            }
+            applyOverlay({ kind: 'model', provider: target });
+            setModelEffortStep(null);
+            setPickerQuery('');
+            setPickerSelection({ query: '', selected: 0, pageSize: 10 });
+            setModelRows([]);
+            setModelList({ loading: true, verified: false, notice: t('screen.model.loading'), label: target, engineDown: false });
+            modelPickerRef.current?.cancel();
+            const model = createModelPickerModel(catalog, { provider: target, current: controller.model() });
+            modelPickerRef.current = model;
+            try {
+                await model.open();
+                if (modelPickerRef.current !== model)
+                    return;
+                setModelRows([...model.rows()]);
+                setModelList({ loading: false, verified: model.verified(), notice: model.notice(), label: model.label(), engineDown: model.engineDown() });
+            }
+            catch (error) {
+                addLocal(screenErrorText(codeOnly(error), act('screen.action.modelPicker')));
+            }
+        };
+        const chooseProviderAndOpenModels = async (row) => {
+            try {
+                await catalog.chooseProvider(row.id);
+            }
+            catch (error) {
+                addLocal(screenErrorText(codeOnly(error), act('screen.action.providerChoice')));
+                return;
+            }
+            setChosenProvider(row.id);
+            showModel(row.id, controller.model());
+            setupTransitionRef.current = true;
+            try {
+                setProviderStep({ kind: 'list' });
+                setProviderSecret('');
+                setAppState((current) => closeOverlay(current));
+                await loadModels(row.id);
+            }
+            finally {
+                setupTransitionRef.current = false;
+            }
+        };
+        /* P17: the setup starts at the first missing step; it ends when its windows close (a model chosen, or Esc), and says
+           whether TALOS is ready — checked, not assumed: a provider, its key and the model's readiness. */
+        const startSetup = async (from) => {
+            setupRef.current = true;
+            setSetupActive(true);
+            setupTransitionRef.current = true;
+            try {
+                if (from === 'model' && chosenProvider) {
+                    await loadModels(chosenProvider);
+                    return;
+                }
+                await loadProviders();
+                /* The key step opens at once for the chosen provider (the consent first when its key is in the environment): no
+                   probe of a provider that has no usable key yet. */
+                if (from === 'key' && chosenProvider) {
+                    const row = (await catalog.listProviders()).find((entry) => entry.id === chosenProvider);
+                    if (row) {
+                        const preliminary = providerPickerEnter({ selectedProvider: row.id, configured: row.configured, requiresKey: row.requiresKey, keySource: row.keySource });
+                        setProviderSecret('');
+                        setProviderStep(preliminary.kind === 'environment-consent' ? { kind: 'consent', provider: row, choice: 'no' } : keyStepFor(row));
+                    }
+                }
+            }
+            catch (error) {
+                addLocal(screenErrorText(codeOnly(error), act('screen.action.providerPicker')));
+            }
+            finally {
+                setupTransitionRef.current = false;
+            }
+        };
+        const finishSetup = async () => {
+            if (!setupRef.current)
+                return;
+            setupRef.current = false;
+            setSetupActive(false);
+            const model = controller.model();
+            const pending = setupPendingProviderRef.current;
+            setupPendingProviderRef.current = null;
+            if (pending && providerOfModel(model) === pending.id) {
+                try {
+                    await catalog.chooseProvider(pending.id);
+                    setChosenProvider(pending.id);
+                    showModel(pending.id, model);
+                }
+                catch (error) {
+                    addLocal(screenErrorText(codeOnly(error), act('screen.action.providerChoice')));
+                }
+            }
+            let ready = false;
+            try {
+                const provider = typeof catalog?.chosenProvider === 'function' ? await catalog.chosenProvider() : null;
+                ready = Boolean(provider && providerOfModel(model) === provider && (await readinessFor(model)).ready);
+            }
+            catch {
+                ready = false;
+            }
+            addLocal(setupEndLines(ready ? { ready: true, model } : { ready: false }).join('\n'));
+        };
+        React.useEffect(() => {
+            if (!setupRef.current || appState.overlay || setupTransitionRef.current)
+                return;
+            void finishSetup();
+        }, [appState.overlay]);
+        const setupAskedRef = React.useRef(false);
+        React.useEffect(() => {
+            if (!invocation.setup || !selectionLoaded || setupAskedRef.current)
+                return;
+            setupAskedRef.current = true;
+            void startSetup('provider');
+        }, [selectionLoaded]);
+        const loadProviders = async () => {
+            applyOverlay({ kind: 'provider' });
+            setPickerQuery('');
+            setPickerSelection({ query: '', selected: 0, pageSize: 10 });
+            setProviderStep({ kind: 'list' });
+            setProviderSecret('');
+            const model = createProviderPickerModel(catalog);
+            providerPickerRef.current = model;
+            try {
+                await model.open();
+                setProviderRows([...model.rows()]);
+            }
+            catch (error) {
+                addLocal(screenErrorText(error, act('screen.action.providerPicker')));
+            }
+        };
+        const keyStepFor = (row, remediation) => row.id === 'openrouter' && typeof catalog?.startOpenRouterLogin === 'function'
+            ? { kind: 'login-choice', provider: row, choice: 'browser', ...(remediation ? { remediation } : {}) }
+            : { kind: 'key', provider: row, testing: false, result: null, ...(remediation ? { remediation } : {}) };
+        const oauthErrorText = (provider, error) => {
+            const code = String(error?.code ?? '');
+            const status = error?.status ?? '?';
+            const known = ['OAUTH_TIMEOUT', 'OAUTH_SCAMBIO_RIFIUTATO', 'OAUTH_RETE', 'OAUTH_RISPOSTA_INATTESA', 'OAUTH_DENIED', 'OAUTH_CODE_MISSING'];
+            return known.includes(code) ? t(`screen.provider.oauthError.${code}`, { provider: provider.label, status }) : t('screen.provider.oauthError.other');
+        };
+        /* P21 (owner decisions 2026-09-26): the browser opens (the address is shown anyway), the loopback waits, a code can be
+           pasted instead; the key that comes back is tested and saved like a pasted one, then the models open. */
+        const completeOAuth = async (provider, key) => {
+            setProviderStep((current) => current.kind === 'oauth' ? { ...current, phase: 'exchanging', message: null } : current);
+            let result;
+            try {
+                result = await catalog.setProviderKey(provider.id, key);
+            }
+            catch (error) {
+                setProviderStep((current) => current.kind === 'oauth' ? { ...current, phase: 'failed', message: screenErrorText(codeOnly(error), act('screen.action.keyTest')) } : current);
+                return;
+            }
+            finally {
+                key = '';
+            }
+            if (!result.saved) {
+                setProviderStep((current) => current.kind === 'oauth' ? { ...current, phase: 'failed', message: result.message } : current);
+                return;
+            }
+            oauthLoginRef.current = null;
+            addLocal(t('screen.provider.oauthSaved', { provider: provider.label }));
+            const refreshed = (await catalog.listProviders()).find((entry) => entry.id === provider.id) ?? { ...provider, configured: true };
+            await chooseProviderAndOpenModels(refreshed);
+        };
+        const startOAuth = async (provider) => {
+            oauthLoginRef.current?.cancel();
+            oauthLoginRef.current = null;
+            setProviderSecret('');
+            let login;
+            try {
+                login = await catalog.startOpenRouterLogin();
+            }
+            catch (error) {
+                setProviderStep({ kind: 'oauth', provider, url: '', mode: 'browser', opened: false, phase: 'failed', message: oauthErrorText(provider, error) });
+                return;
+            }
+            oauthLoginRef.current = login;
+            /* The address also goes to the conversation, unboxed: a person copies it there without the window's borders. */
+            addLocal(t('screen.provider.oauthAddress', { provider: provider.label, url: login.url }));
+            setProviderStep({ kind: 'oauth', provider, url: login.url, mode: login.mode, opened: login.opened, phase: login.mode === 'paste' ? 'paste' : 'waiting', message: null });
+            login.key.then((key) => { if (oauthLoginRef.current === login)
+                void completeOAuth(provider, key); }, (error) => {
+                if (oauthLoginRef.current !== login || error?.code === 'OAUTH_CANCELLED')
+                    return;
+                oauthLoginRef.current = null;
+                setProviderStep((current) => current.kind === 'oauth' ? { ...current, phase: 'failed', message: oauthErrorText(provider, error) } : current);
+            });
+        };
+        const routeProviderSelection = async (row, { allowEnvironmentConsent = true } = {}) => {
+            const originalIndex = providerRows.findIndex((provider) => provider.id === row.id);
+            if (originalIndex >= 0)
+                providerPickerRef.current?.select(originalIndex);
+            if (allowEnvironmentConsent) {
+                const preliminary = providerPickerEnter({ selectedProvider: row.id, configured: row.configured, requiresKey: row.requiresKey, keySource: row.keySource });
+                if (preliminary.kind === 'environment-consent') {
+                    setProviderStep({ kind: 'consent', provider: row, choice: 'no' });
+                    return;
+                }
+            }
+            let probe = null;
+            try {
+                probe = await providerPickerRef.current?.probeSelected() ?? await catalog.probeProvider(row.id);
+            }
+            catch (error) {
+                addLocal(screenErrorText(codeOnly(error), act('screen.action.healthCheck', { provider: row.label })));
+                return;
+            }
+            const next = providerPickerEnter({ selectedProvider: row.id, configured: row.configured, requiresKey: row.requiresKey, keySource: row.keySource, probe });
+            if (next.kind === 'provider-setup') {
+                setProviderSecret('');
+                setProviderStep(keyStepFor(row, next.remediation ?? undefined));
+                return;
+            }
+            if (next.kind === 'provider-remediation') {
+                /* P17 (owner decision 8): in the setup, a local engine that is down opens its model window, which says how to start it. */
+                if (setupRef.current && row.local && !row.requiresKey) {
+                    setupPendingProviderRef.current = row;
+                    setupTransitionRef.current = true;
+                    try {
+                        setProviderStep({ kind: 'list' });
+                        setProviderSecret('');
+                        setAppState((current) => closeOverlay(current));
+                        await loadModels(row.id);
+                    }
+                    finally {
+                        setupTransitionRef.current = false;
+                    }
+                    return;
+                }
+                addLocal(next.remediation?.message || probe?.detail || t('screen.provider.notReady', { provider: row.label }));
+                return;
+            }
+            if (next.kind === 'environment-consent') {
+                setProviderStep({ kind: 'consent', provider: row, choice: 'no' });
+                return;
+            }
+            if (next.remediation && next.remediation.code !== 'none')
+                addLocal(next.remediation.message);
+            await chooseProviderAndOpenModels(row);
+        };
+        /* R4 Q-R4-13: the local list is read first and the picker opens with it, so its first frame already holds the rows or
+           the empty-state line (it never shows an empty box that only later turns out to be empty or failed). */
+        const loadSessions = async (action) => {
+            const model = createSessionPickerModel(controller, action, { metadataRoot: sessionMetadataRoot(paths.dataRoot) });
+            sessionPickerRef.current = model;
+            try {
+                await model.open();
+            }
+            catch (error) {
+                addLocal(screenErrorText(error, act('screen.action.sessionPicker')));
+                return;
+            }
+            if (sessionPickerRef.current !== model)
+                return;
+            setSessionRows([...model.rows()]);
+            setPickerQuery('');
+            setPickerSelection({ query: '', selected: 0, pageSize: 10 });
+            applyOverlay({ kind: 'session', action });
+        };
+        const loadTrustCenter = async () => {
+            try {
+                const snapshot = await createTrustAuthority({ projectRoot, trustRoot: paths.trust.projects }).inspect();
+                setTrustCenter(trustCenterModel(snapshot, { permissionMode: controller.mode() }));
+            }
+            catch (error) {
+                addLocal(screenErrorText(error, act('screen.action.trustCenter')));
+            }
+        };
+        const mcpFacade = () => mcpFacadeRef.current ??= (createMcpFacade({ projectRoot, paths }));
+        const loadMcpCenter = async (selectedId) => {
+            try {
+                const rows = await mcpFacade().list();
+                const selected = selectedId ? Math.max(0, rows.findIndex(row => row.id === selectedId)) : mcpCenter?.selected ?? 0;
+                setMcpCenter(createMcpCenterModel(rows, selected));
+            }
+            catch (error) {
+                addLocal(screenErrorText(error, act('screen.action.mcpCenter')));
+            }
+        };
+        const actOnMcpCenter = async (action) => {
+            const row = mcpCenter ? selectedMcpServer(mcpCenter) : null;
+            if (!row)
+                return;
+            try {
+                if (action === 'probe') {
+                    const measured = await mcpFacade().probe(row.id);
+                    setMcpCenter((current) => current ? replaceMcpCenterRow(current, measured) : current);
+                    return;
+                }
+                if (action === 'trust')
+                    await mcpFacade().trust(row.id);
+                else
+                    await mcpFacade().untrust(row.id);
+                await loadMcpCenter(row.id);
+            }
+            catch (error) {
+                addLocal(screenErrorText(error, act('screen.action.mcp', { action })));
+            }
+        };
+        const hookFacade = () => hookFacadeRef.current ??= (createHookFacade({ projectRoot, paths }));
+        const loadHookCenter = async (selectedId) => {
+            try {
+                const rows = await hookFacade().list();
+                const found = selectedId ? rows.findIndex(row => row.id === selectedId) : -1;
+                const selected = found >= 0 ? found : hookCenter?.selected ?? 0;
+                setHookCenter(createHookCenterModel(rows, selected));
+            }
+            catch (error) {
+                addLocal(screenErrorText(error, act('screen.action.hookCenter')));
+            }
+        };
+        const actOnHookCenter = async (action) => {
+            const row = hookCenter ? selectedHook(hookCenter) : null;
+            if (!row)
+                return;
+            try {
+                if (action === 'dry-run') {
+                    if (state.running) {
+                        addLocal(t('screen.hooks.dryRunBusy'));
+                        return;
+                    }
+                    const eventType = row.events[0];
+                    if (!eventType) {
+                        addLocal(t('screen.hooks.noEvent'));
+                        return;
+                    }
+                    const result = await hookFacade().dryRun(row.id, { eventType });
+                    setHookCenter((current) => current ? replaceHookCenterRow(current, { ...row, lastDryRun: result }) : current);
+                    return;
+                }
+                if (action === 'trust')
+                    await hookFacade().trust(row.id);
+                else if (action === 'untrust')
+                    await hookFacade().untrust(row.id);
+                else if (row.quarantine.active)
+                    await hookFacade().releaseQuarantine(row.id);
+                else
+                    await hookFacade().quarantine(row.id, t('screen.hooks.manualQuarantine'));
+                await loadHookCenter(row.id);
+            }
+            catch (error) {
+                addLocal(screenErrorText(error, act('screen.action.hook', { action })));
+            }
+        };
+        const pluginFacade = () => pluginFacadeRef.current ??= (createPluginFacade({ projectRoot, paths }));
+        const loadPluginCenter = async (selectedId) => {
+            try {
+                const rows = await pluginFacade().list();
+                const found = selectedId ? rows.findIndex(row => row.id === selectedId) : -1;
+                const selected = found >= 0 ? found : pluginCenter?.selected ?? 0;
+                setPluginCenter(createPluginCenterModel(rows, selected));
+            }
+            catch (error) {
+                addLocal(screenErrorText(error, act('screen.action.pluginCenter')));
+            }
+        };
+        const actOnPluginCenter = async (action) => {
+            const row = pluginCenter ? selectedPlugin(pluginCenter) : null;
+            if (!row)
+                return;
+            try {
+                if (action === 'trust')
+                    await pluginFacade().trust(row.id);
+                else if (action === 'untrust')
+                    await pluginFacade().untrust(row.id);
+                else if (row.quarantine.active)
+                    await pluginFacade().releaseQuarantine(row.id);
+                else
+                    await pluginFacade().quarantine(row.id, t('screen.plugins.manualQuarantine'));
+                await loadPluginCenter(row.id);
+            }
+            catch (error) {
+                addLocal(screenErrorText(error, act('screen.action.plugin', { action })));
+            }
+        };
+        const memoryFacade = () => memoryFacadeRef.current ??= (createMemoryFacade({ projectRoot, paths }));
+        const loadMemoryCenter = async (query, selectedId) => {
+            try {
+                const snapshot = query === undefined ? await memoryFacade().list() : await memoryFacade().search(query);
+                const found = selectedId ? snapshot.rows.findIndex(row => row.id === selectedId) : -1;
+                const selected = found >= 0 ? found : memoryCenter?.selected ?? 0;
+                setMemoryCenter(createMemoryCenterModel(snapshot, selected));
+            }
+            catch (error) {
+                addLocal(screenErrorText(error, act('screen.action.memoryCenter')));
+            }
+        };
+        const notesFacade = () => notesFacadeRef.current ??= (createNotesFacade({ projectRoot, paths }));
+        const loadNotesCenter = async (selectedId) => {
+            try {
+                const snapshot = await notesFacade().list();
+                const found = selectedId ? snapshot.rows.findIndex(row => row.id === selectedId) : -1;
+                const selected = found >= 0 ? found : notesCenter?.selected ?? 0;
+                setNotesCenter(createNotesCenterModel(snapshot, selected));
+            }
+            catch (error) {
+                addLocal(screenErrorText(error, act('screen.action.notesCenter')));
+            }
+        };
+        const tasksFacade = () => tasksFacadeRef.current ??= (createTaskBoardFacade({ projectRoot, paths }));
+        const loadTasksCenter = async (selectedId) => {
+            try {
+                const snapshot = await tasksFacade().list();
+                const found = selectedId ? snapshot.rows.findIndex(row => row.id === selectedId) : -1;
+                const selected = found >= 0 ? found : tasksCenter?.selected ?? 0;
+                setTasksCenter(createTasksCenterModel(snapshot, selected));
+            }
+            catch (error) {
+                addLocal(screenErrorText(error, act('screen.action.taskBoard')));
+            }
+        };
+        const libraryFacade = () => libraryFacadeRef.current ??= (createLibraryFacade({ projectRoot, paths }));
+        const loadLibraryCenter = async (selectedId) => {
+            try {
+                const snapshot = await libraryFacade().list();
+                const found = selectedId ? snapshot.rows.findIndex(row => row.id === selectedId) : -1;
+                const selected = found >= 0 ? found : libraryCenter?.selected ?? 0;
+                setLibraryCenter(createLibraryCenterModel(snapshot, selected));
+            }
+            catch (error) {
+                addLocal(screenErrorText(error, act('screen.action.libraryCenter')));
+            }
+        };
+        const forgeFacade = () => forgeFacadeRef.current ??= createForgeFacade({ forgeRoot: join(paths.dataRoot, 'forge') }, { registry });
+        const loadForgeCenter = async (selectedId) => {
+            try {
+                const snapshot = await forgeFacade().list();
+                const found = selectedId ? snapshot.rows.findIndex(row => row.id === selectedId) : -1;
+                const selected = found >= 0 ? found : forgeCenter?.selected ?? 0;
+                const base = createForgeCenterModel(snapshot, selected);
+                setForgeCenter(base);
+                const row = snapshot.rows[selected];
+                if (row) {
+                    const detail = await forgeFacade().read(row.id);
+                    setForgeCenter((current) => current ? setForgeCenterDetail(current, detail) : current);
+                }
+            }
+            catch (error) {
+                addLocal(screenErrorText(error, act('screen.action.forgeCenter')));
+            }
+        };
+        const automationFacade = () => automationFacadeRef.current ??= createAutomationFacade({ projectRoot, dataRoot: paths.dataRoot });
+        const loadAutomationCenter = async (selectedId) => {
+            try {
+                const snapshot = await automationFacade().list();
+                const found = selectedId ? snapshot.rows.findIndex(row => row.id === selectedId) : -1;
+                const selected = found >= 0 ? found : automationCenter?.selected ?? 0;
+                const base = createAutomationCenterModel(snapshot, selected);
+                setAutomationCenter(base);
+                const row = snapshot.rows[selected];
+                if (row) {
+                    const detail = await automationFacade().read(row.id);
+                    setAutomationCenter((current) => current ? setAutomationCenterDetail(current, detail) : current);
+                }
+            }
+            catch (error) {
+                addLocal(screenErrorText(error, act('screen.action.automationCenter')));
+            }
+        };
+        const researchFacade = () => researchFacadeRef.current ??= createResearchFacade({ projectRoot }, { registry });
+        const loadResearchCenter = async (selectedId) => {
+            try {
+                const snapshot = await researchFacade().list();
+                const found = selectedId ? snapshot.rows.findIndex(row => row.id === selectedId) : -1;
+                const selected = found >= 0 ? found : researchCenter?.selected ?? 0;
+                const base = createResearchCenterModel(snapshot, selected);
+                setResearchCenter(base);
+                const row = snapshot.rows[selected];
+                if (row) {
+                    const detail = await researchFacade().read(row.id);
+                    setResearchCenter((current) => current ? setResearchCenterDetail(current, detail) : current);
+                }
+            }
+            catch (error) {
+                addLocal(screenErrorText(error, act('screen.action.researchCenter')));
+            }
+        };
+        /* Owner 2026-09-25 ("after a restart /effort says the model declares no levels, though I set one with the same model"):
+           the rows TALOS already knows (catalog.listModels, read at startup and by `/model <id>`) may lack a model's levels that
+           the provider's live list (catalog.providerModels, what the /model picker reads) has. Asked only when levels are missing. */
+        const modelMetaWithLevels = async (id, known) => {
+            if (known && reasoningEffortChoices(known).length)
+                return known;
+            const provider = providerOfModel(id);
+            if (!provider || typeof catalog?.providerModels !== 'function')
+                return known;
+            try {
+                return (await catalog.providerModels(provider)).rows.find((candidate) => candidate.id === id) ?? known;
+            }
+            catch {
+                return known;
+            }
+        };
+        const applyConfiguredReasoningDefault = (row) => {
+            const supported = Boolean(reasoningEffort && row?.reasoning === true && row.reasoningEfforts?.includes(reasoningEffort));
+            if (typeof runtime.setDefaultReasoningEffort === 'function')
+                runtime.setDefaultReasoningEffort(supported ? reasoningEffort : null);
+            if (reasoningEffort && !supported) {
+                setReasoningEffort(null);
+                addLocal(t('screen.effort.notAffirmed', { effort: reasoningEffort, model: row?.id ?? controller.model() }));
+            }
+        };
+        /* The effort chosen on the line of nodes, from /model's second step or from /effort (R5a, owner 2026-09-24). */
+        const applyEffortChoice = async (row, choice) => {
+            const sameLiveModel = Boolean(state.sessionId && state.status.model === row.id);
+            try {
+                await commitModelSelection({ id: row.id, catalog, setControllerModel: (id) => controller.setModel(id) });
+                if (choice === 'default') {
+                    await configUnset({ paths, projectRoot, scope: 'project-user', path: 'reasoningEffort' });
+                    if (typeof runtime.setDefaultReasoningEffort === 'function')
+                        runtime.setDefaultReasoningEffort(null);
+                    const retainedLiveEffort = sameLiveModel ? reasoningEffort : null;
+                    setReasoningEffort(retainedLiveEffort);
+                    setCurrentModelMeta(row);
+                    setState((current) => localMessage({ ...current, status: { ...current.status, model: row.id } }, retainedLiveEffort
+                        ? t('screen.model.changedEffortClearedKept', { model: row.id, effort: retainedLiveEffort })
+                        : t('screen.model.changedEffortCleared', { model: row.id })));
+                }
+                else {
+                    await configSet({ paths, projectRoot, scope: 'project-user', path: 'reasoningEffort', value: choice });
+                    if (typeof runtime.setDefaultReasoningEffort === 'function')
+                        runtime.setDefaultReasoningEffort(choice);
+                    if (sameLiveModel && typeof runtime.setReasoningEffort === 'function')
+                        await runtime.setReasoningEffort(state.sessionId, choice);
+                    setReasoningEffort(choice);
+                    setCurrentModelMeta(row);
+                    setState((current) => localMessage({ ...current, status: { ...current.status, model: row.id } }, t(sameLiveModel ? 'screen.model.changedEffortSession' : 'screen.model.changedEffort', { model: row.id, effort: choice })));
+                }
+                closeCurrentOverlay();
+            }
+            catch (error) {
+                addLocal(screenErrorText(error, act('screen.action.effortChange')));
+            }
+        };
+        /* R5b D2 (owner decision Q-R5-12, R5 gate §5.1): /clear, and every resume or fork, start from an empty view; the session
+           attached then redraws its own history once (a fork drew the earlier conversation twice: the old view, then the replay). */
+        const freshView = () => { setState((current) => ({ ...current, messages: [], streamingAssistant: null, reasoning: null, tools: [], warnings: [], transcript: createTranscriptModel(), compactions: 0 })); setDiff(''); setTranscriptRevealId(null); setViewport((view) => ({ ...view, offset: 0, unseen: 0, followingTail: true })); };
+        const executeSlash = async (text) => {
+            const parsed = parseSlashCommand(text);
+            setAuxCompletions([]);
+            if (!SLASH_COMMANDS.some(command => command.name === parsed.name)) {
+                addLocal(parsed.suggestions.length ? t('screen.slash.unknownSuggest', { name: parsed.name, suggestions: parsed.suggestions.map(value => `/${value}`).join(', ') }) : t('screen.slash.unknown', { name: parsed.name }));
+                return;
+            }
+            /* P17 (owner decision 4): /setup runs the guided setup again, from the provider. */
+            if (parsed.name === 'setup') {
+                await startSetup('provider');
+                return;
+            }
+            const intent = slashCommandIntent(text);
+            if (intent?.kind === 'open-overlay') {
+                if (intent.overlay.kind === 'model') {
+                    await loadModels(intent.overlay.provider);
+                    return;
+                }
+                if (intent.overlay.kind === 'provider') {
+                    await loadProviders();
+                    return;
+                }
+                if (intent.overlay.kind === 'session') {
+                    await loadSessions(intent.overlay.action);
+                    return;
+                }
+                applyOverlay(intent.overlay);
+                return;
+            }
+            if (intent?.kind === 'key-action') {
+                runKeyAction(intent.action);
+                return;
+            }
+            if (intent?.kind === 'select-model') {
+                if (!MODEL_ID.test(intent.id)) {
+                    addLocal(t('screen.usage.model'));
+                    return;
+                }
+                const providerId = providerOfModel(intent.id);
+                try {
+                    const row = (await catalog.listProviders()).find((entry) => entry.id === providerId);
+                    if (!row) {
+                        addLocal(t('screen.model.unknownProvider', { provider: String(providerId) }));
+                        return;
+                    }
+                    if (!row.configured) {
+                        if (row.requiresKey) {
+                            const refusal = unusableKeyRefusal(row.id, row.benched);
+                            addLocal(refusal.message);
+                        }
+                        else
+                            addLocal(t('screen.model.configureFirst', { provider: row.label }));
+                        return;
+                    }
+                    const probe = await catalog.probeProvider(row.id);
+                    if (probe.readinessCode) {
+                        addLocal(probe.remediation?.message || probe.detail || t('screen.provider.notReady', { provider: row.label }));
+                        return;
+                    }
+                    if (probe.remediation && probe.remediation.code !== 'none')
+                        addLocal(probe.remediation.message);
+                    if (chosenProvider !== row.id) {
+                        await catalog.chooseProvider(row.id);
+                        setChosenProvider(row.id);
+                    }
+                }
+                catch (error) {
+                    addLocal(screenErrorText(codeOnly(error), act('screen.action.modelChange')));
+                    return;
+                }
+                try {
+                    await selectExplicitModel(intent.id, catalog, (id) => controller.setModel(id));
+                    setState((current) => localMessage({ ...current, status: { ...current.status, model: intent.id } }, t('screen.model.changed', { model: intent.id })));
+                    const rows = await catalog.listModels({ provider: providerId ?? undefined });
+                    const meta = await modelMetaWithLevels(intent.id, rows.find(row => row.id === intent.id) ?? null);
+                    setCurrentModelMeta(meta);
+                    applyConfiguredReasoningDefault(meta);
+                }
+                catch (error) {
+                    addLocal(screenErrorText(error, act('screen.action.modelChange')));
+                }
+                return;
+            }
+            if (intent?.kind === 'session-id') {
+                try {
+                    freshView();
+                    const id = intent.action === 'resume' ? await controller.resumeSession(intent.id) : await controller.forkSession(intent.id);
+                    addLocal(intent.action === 'resume' ? t('screen.session.attached', { id }) : t('screen.session.forked', { from: intent.id, id }));
+                }
+                catch (error) {
+                    addLocal(screenErrorText(error, act(intent.action === 'resume' ? 'screen.action.resume' : 'screen.action.fork')));
+                }
+                return;
+            }
+            if (parsed.name === 'forge') {
+                const operation = parsed.args[0] ?? 'list';
+                if (operation === 'list' || operation === 'inspect') {
+                    const id = operation === 'inspect' ? parsed.args[1] : undefined;
+                    if (operation === 'inspect' && !id) {
+                        addLocal(t('screen.usage.forgeInspect'));
+                        return;
+                    }
+                    await loadForgeCenter(id);
+                    return;
+                }
+                if (operation === 'enable' || operation === 'disable') {
+                    const id = parsed.args[1], ownerSessionId = state.sessionId;
+                    if (!id || !ownerSessionId) {
+                        addLocal(t('screen.forge.needsSessionAndTool'));
+                        return;
+                    }
+                    try {
+                        await forgeFacade().setEnabled(ownerSessionId, id, operation === 'enable');
+                        await loadForgeCenter(id);
+                    }
+                    catch (error) {
+                        addLocal(screenErrorText(error, act('screen.action.commandOperation', { command: 'forge', operation })));
+                    }
+                    return;
+                }
+                if (operation === 'rollback') {
+                    const id = parsed.args[1], revision = Number(parsed.args[2]), ownerSessionId = state.sessionId;
+                    if (!id || !Number.isSafeInteger(revision) || revision < 1 || !ownerSessionId) {
+                        addLocal(t('screen.usage.forgeRollback'));
+                        return;
+                    }
+                    try {
+                        await forgeFacade().rollback(ownerSessionId, id, revision);
+                        await loadForgeCenter(id);
+                    }
+                    catch (error) {
+                        addLocal(screenErrorText(error, act('screen.action.commandOperation', { command: 'forge', operation })));
+                    }
+                    return;
+                }
+                if (!['validate', 'scan', 'simulate', 'install', 'versions'].includes(operation)) {
+                    addLocal(t('screen.usage.forge'));
+                    return;
+                }
+            }
+            if (parsed.name === 'automations') {
+                const operation = parsed.args[0] ?? 'list';
+                if (operation === 'list' || operation === 'read' || operation === 'dry-run' || operation === 'history') {
+                    const id = operation === 'list' ? undefined : parsed.args[1];
+                    if (operation !== 'list' && !id) {
+                        addLocal(t('screen.usage.automationsOperation', { operation }));
+                        return;
+                    }
+                    await loadAutomationCenter(id);
+                    return;
+                }
+                if (operation === 'health') {
+                    try {
+                        const health = await automationFacade().health();
+                        addLocal(t('screen.automation.runner', { state: String(health.state) }));
+                    }
+                    catch (error) {
+                        addLocal(screenErrorText(error, act('screen.action.commandOperation', { command: 'automations', operation })));
+                    }
+                    return;
+                }
+                if (!['add', 'enable', 'disable', 'delete', 'run', 'serve', 'schedule', 'install-runner', 'uninstall-runner'].includes(operation)) {
+                    addLocal(t('screen.usage.automations'));
+                    return;
+                }
+            }
+            if (parsed.name === 'research') {
+                const operation = parsed.args[0] ?? 'list';
+                if (operation === 'list' || operation === 'read') {
+                    const id = operation === 'read' ? parsed.args[1] : undefined;
+                    if (operation === 'list' && parsed.args.length > 1) {
+                        addLocal(t('screen.usage.research'));
+                        return;
+                    }
+                    if (operation === 'read' && (!id || parsed.args.length !== 2)) {
+                        addLocal(t('screen.usage.researchRead'));
+                        return;
+                    }
+                    await loadResearchCenter(id);
+                    return;
+                }
+                if (operation === 'pause' || operation === 'resume' || operation === 'cancel') {
+                    const id = parsed.args[1];
+                    if (!id || parsed.args.length !== 2) {
+                        addLocal(t('screen.usage.researchOperation', { operation }));
+                        return;
+                    }
+                    const ownerSessionId = state.sessionId ?? id;
+                    try {
+                        if (operation === 'pause')
+                            await researchFacade().pause(ownerSessionId, id);
+                        else if (operation === 'resume')
+                            await researchFacade().resume(ownerSessionId, id);
+                        else
+                            await researchFacade().cancel(ownerSessionId, id);
+                        await loadResearchCenter(id);
+                    }
+                    catch (error) {
+                        addLocal(screenErrorText(error, act('screen.action.commandOperation', { command: 'research', operation })));
+                    }
+                    return;
+                }
+                if (operation === 'export') {
+                    const id = parsed.args[1], format = (parsed.args[2] ?? 'md'), out = parsed.args[3];
+                    if (!id || parsed.args.length > 4) {
+                        addLocal(t('screen.usage.researchExport'));
+                        return;
+                    }
+                    try {
+                        const result = await researchFacade().exportFile(id, format, out);
+                        addLocal(t('screen.research.exported', { path: result.path }));
+                    }
+                    catch (error) {
+                        addLocal(screenErrorText(error, act('screen.action.commandOperation', { command: 'research', operation })));
+                    }
+                    return;
+                }
+                if (!['start', 'rename', 'delete'].includes(operation)) {
+                    addLocal(t('screen.usage.research'));
+                    return;
+                }
+                /* start/rename/delete keep the existing child-CLI behavior; live controls above never cross the process boundary. */
+            }
+            if (parsed.name === 'library') {
+                const operation = parsed.args[0] ?? 'list';
+                if (operation === 'list') {
+                    if (parsed.args.length > 1) {
+                        addLocal(t('screen.usage.library'));
+                        return;
+                    }
+                    await loadLibraryCenter();
+                    return;
+                }
+                if (!['search', 'read', 'preview', 'duplicates', 'context-ref', 'import', 'export', 'rename', 'delete'].includes(operation)) {
+                    addLocal(t('screen.usage.library'));
+                    return;
+                }
+                /* non-list operations continue through the child CLI; runLibraryCommand uses this same facade. */
+            }
+            if (parsed.name === 'tasks') {
+                const operation = parsed.args[0] ?? 'list';
+                if (operation === 'list') {
+                    if (parsed.args.length > 1) {
+                        addLocal(t('screen.usage.tasks'));
+                        return;
+                    }
+                    await loadTasksCenter();
+                    return;
+                }
+                if (['depend', 'undepend', 'evidence', 'unevidence', 'assign', 'unassign', 'schedule', 'unschedule'].includes(operation)) {
+                    const taskId = parsed.args[1], targetId = parsed.args[2];
+                    if (parsed.args.length !== 3 || !taskId || !targetId) {
+                        addLocal(t('screen.usage.tasksOperation', { operation }));
+                        return;
+                    }
+                    try {
+                        if (operation === 'depend')
+                            await tasksFacade().depend(taskId, targetId);
+                        else if (operation === 'undepend')
+                            await tasksFacade().undepend(taskId, targetId);
+                        else if (operation === 'evidence')
+                            await tasksFacade().addEvidence(taskId, targetId);
+                        else if (operation === 'unevidence')
+                            await tasksFacade().removeEvidence(taskId, targetId);
+                        else if (operation === 'assign')
+                            await tasksFacade().assignAgent(taskId, targetId);
+                        else if (operation === 'unassign')
+                            await tasksFacade().unassignAgent(taskId, targetId);
+                        else if (operation === 'schedule')
+                            await tasksFacade().attachSchedule(taskId, targetId);
+                        else
+                            await tasksFacade().detachSchedule(taskId, targetId);
+                        await loadTasksCenter(taskId);
+                    }
+                    catch (error) {
+                        addLocal(screenErrorText(error, act('screen.action.commandOperation', { command: 'tasks', operation })));
+                    }
+                    return;
+                }
+                if (!['add', 'update', 'complete', 'delete'].includes(operation)) {
+                    addLocal(t('screen.usage.tasks'));
+                    return;
+                }
+                /* add/update/complete/delete deliberately continue through the child CLI; runTasksCommand uses this same facade. */
+            }
+            if (parsed.name === 'notes') {
+                const operation = parsed.args[0] ?? 'list';
+                if (operation === 'list') {
+                    if (parsed.args.length > 1) {
+                        addLocal(t('screen.usage.notes'));
+                        return;
+                    }
+                    await loadNotesCenter();
+                    return;
+                }
+                if (operation === 'link' || operation === 'unlink') {
+                    const noteId = parsed.args[1], targetKind = parsed.args[2], targetId = parsed.args[3];
+                    if (parsed.args.length !== 4 || !noteId || !targetKind || !targetId || !['session', 'task', 'research'].includes(targetKind)) {
+                        addLocal(t('screen.usage.notesOperation', { operation }));
+                        return;
+                    }
+                    try {
+                        if (operation === 'link')
+                            await notesFacade().link(noteId, targetKind, targetId);
+                        else
+                            await notesFacade().unlink(noteId, targetKind, targetId);
+                        await loadNotesCenter(noteId);
+                    }
+                    catch (error) {
+                        addLocal(screenErrorText(error, act('screen.action.commandOperation', { command: 'notes', operation })));
+                    }
+                    return;
+                }
+                if (!['add', 'update', 'delete'].includes(operation)) {
+                    addLocal(t('screen.usage.notes'));
+                    return;
+                }
+                /* add/update/delete deliberately continue through the existing child CLI path; runNotesCommand uses this same facade. */
+            }
+            if (parsed.name === 'memory') {
+                const operation = parsed.args[0] ?? 'list';
+                if (operation === 'list') {
+                    if (parsed.args.length > 1) {
+                        addLocal(t('screen.usage.memory'));
+                        return;
+                    }
+                    await loadMemoryCenter();
+                    return;
+                }
+                if (operation === 'search') {
+                    const query = parsed.args.slice(1).join(' ').trim();
+                    if (!query) {
+                        addLocal(t('screen.usage.memorySearch'));
+                        return;
+                    }
+                    await loadMemoryCenter(query);
+                    return;
+                }
+                /* add/update/delete deliberately continue through the existing child CLI path; that command now uses this same facade. */
+            }
+            if (parsed.name === 'mcp') {
+                const operation = parsed.args[0] ?? 'list';
+                if (operation === 'list') {
+                    if (parsed.args.length > 1) {
+                        addLocal(t('screen.usage.mcp'));
+                        return;
+                    }
+                    await loadMcpCenter();
+                    return;
+                }
+                if (!['test', 'trust', 'untrust'].includes(operation) || parsed.args.length !== 2) {
+                    addLocal(t('screen.usage.mcp'));
+                    return;
+                }
+                const serverId = parsed.args[1];
+                try {
+                    if (operation === 'test') {
+                        const measured = await mcpFacade().probe(serverId);
+                        const rows = await mcpFacade().list();
+                        const selected = Math.max(0, rows.findIndex(row => row.id === serverId));
+                        setMcpCenter(replaceMcpCenterRow(createMcpCenterModel(rows, selected), measured));
+                    }
+                    else {
+                        if (operation === 'trust')
+                            await mcpFacade().trust(serverId);
+                        else
+                            await mcpFacade().untrust(serverId);
+                        await loadMcpCenter(serverId);
+                    }
+                }
+                catch (error) {
+                    addLocal(screenErrorText(error, act('screen.action.commandOperation', { command: 'mcp', operation })));
+                }
+                return;
+            }
+            if (parsed.name === 'hooks') {
+                const operation = parsed.args[0] ?? 'list';
+                if (operation === 'list') {
+                    if (parsed.args.length > 1) {
+                        addLocal(t('screen.usage.hooks'));
+                        return;
+                    }
+                    await loadHookCenter();
+                    return;
+                }
+                const hookId = parsed.args[1];
+                if (!hookId) {
+                    addLocal(t('screen.usage.hooks'));
+                    return;
+                }
+                try {
+                    if (operation === 'history') {
+                        if (parsed.args.length > 3) {
+                            addLocal(t('screen.usage.hooksHistory'));
+                            return;
+                        }
+                        const rawLimit = parsed.args[2];
+                        let limit = 8;
+                        if (rawLimit !== undefined) {
+                            limit = Number(rawLimit);
+                            if (!Number.isSafeInteger(limit) || limit < 1 || limit > 50) {
+                                addLocal(t('screen.hooks.historyLimit'));
+                                return;
+                            }
+                        }
+                        const [history, rows] = await Promise.all([hookFacade().history(hookId, { limit }), hookFacade().list()]);
+                        const selected = Math.max(0, rows.findIndex(row => row.id === hookId));
+                        const base = createHookCenterModel(rows, selected);
+                        const row = selectedHook(base);
+                        setHookCenter(row ? replaceHookCenterRow(base, { ...row, lastExecutions: history }) : base);
+                        return;
+                    }
+                    if (operation === 'dry-run') {
+                        const eventType = parsed.args[2];
+                        if (!eventType) {
+                            addLocal(t('screen.usage.hooksDryRun'));
+                            return;
+                        }
+                        const action = parsed.args.length > 3 ? parsed.args.slice(3).join(' ') : null;
+                        const result = await hookFacade().dryRun(hookId, { eventType, action });
+                        const rows = await hookFacade().list();
+                        const selected = Math.max(0, rows.findIndex(row => row.id === hookId));
+                        const base = createHookCenterModel(rows, selected);
+                        const row = selectedHook(base);
+                        setHookCenter(row ? replaceHookCenterRow(base, { ...row, lastDryRun: result }) : base);
+                        return;
+                    }
+                    if (operation === 'trust') {
+                        if (parsed.args.length !== 2) {
+                            addLocal(t('screen.usage.hooksTrust'));
+                            return;
+                        }
+                        await hookFacade().trust(hookId);
+                    }
+                    else if (operation === 'untrust') {
+                        if (parsed.args.length !== 2) {
+                            addLocal(t('screen.usage.hooksUntrust'));
+                            return;
+                        }
+                        await hookFacade().untrust(hookId);
+                    }
+                    else if (operation === 'quarantine') {
+                        await hookFacade().quarantine(hookId, parsed.args.length > 2 ? parsed.args.slice(2).join(' ') : null);
+                    }
+                    else if (operation === 'release' || operation === 'release-quarantine') {
+                        if (parsed.args.length !== 2) {
+                            addLocal(t('screen.usage.hooksRelease'));
+                            return;
+                        }
+                        await hookFacade().releaseQuarantine(hookId);
+                    }
+                    else {
+                        addLocal(t('screen.usage.hooks'));
+                        return;
+                    }
+                    await loadHookCenter(hookId);
+                }
+                catch (error) {
+                    addLocal(screenErrorText(error, act('screen.action.commandOperation', { command: 'hooks', operation })));
+                }
+                return;
+            }
+            if (parsed.name === 'plugins') {
+                const operation = parsed.args[0] ?? 'list';
+                if (operation === 'list') {
+                    if (parsed.args.length > 1) {
+                        addLocal(t('screen.usage.plugins'));
+                        return;
+                    }
+                    await loadPluginCenter();
+                    return;
+                }
+                if (['trust', 'untrust', 'quarantine', 'release', 'release-quarantine'].includes(operation)) {
+                    const pluginId = parsed.args[1];
+                    if (!pluginId) {
+                        addLocal(t('screen.usage.pluginsOperation', { operation }));
+                        return;
+                    }
+                    try {
+                        if (operation === 'trust') {
+                            if (parsed.args.length !== 2) {
+                                addLocal(t('screen.usage.pluginsTrust'));
+                                return;
+                            }
+                            await pluginFacade().trust(pluginId);
+                        }
+                        else if (operation === 'untrust') {
+                            if (parsed.args.length !== 2) {
+                                addLocal(t('screen.usage.pluginsUntrust'));
+                                return;
+                            }
+                            await pluginFacade().untrust(pluginId);
+                        }
+                        else if (operation === 'quarantine')
+                            await pluginFacade().quarantine(pluginId, parsed.args.length > 2 ? parsed.args.slice(2).join(' ') : null);
+                        else {
+                            if (parsed.args.length !== 2) {
+                                addLocal(t('screen.usage.pluginsRelease'));
+                                return;
+                            }
+                            await pluginFacade().releaseQuarantine(pluginId);
+                        }
+                        await loadPluginCenter(pluginId);
+                    }
+                    catch (error) {
+                        addLocal(screenErrorText(error, act('screen.action.commandOperation', { command: 'plugins', operation })));
+                    }
+                    return;
+                }
+                if (operation !== 'install' && operation !== 'remove') {
+                    addLocal(t('screen.usage.plugins'));
+                    return;
+                }
+                /* install/remove deliberately continue into the existing child CLI installer path below. */
+            }
+            if (parsed.name === 'exit') {
+                inkApp.exit();
+                return;
+            }
+            if (parsed.name === 'clear') {
+                freshView();
+                return;
+            }
+            /* R5b D7 (Q-R5-17): the R4 block, then the sandbox, the rules by scope, tasks and notes, and the usage. */
+            if (parsed.name === 'status') {
+                const work = async () => { try {
+                    const [tasks, notes] = await Promise.all([tasksFacade().list(), notesFacade().list()]);
+                    if (tasks.state !== 'ready' || notes.state !== 'ready')
+                        return null;
+                    return { open: tasks.rows.filter(row => row.status !== 'done').length, doing: tasks.rows.filter(row => row.status === 'doing').length, notes: notes.rows.length };
+                }
+                catch {
+                    return null;
+                } };
+                const [rules, counts] = await Promise.all([permissionRuleCounts({ paths, projectRoot }), work()]);
+                const facts = usageFacts({ model: state.status.model, usage: state.usage, contextStatus, compactions: state.compactions });
+                addLocal(sessionStatusText({ session: state.sessionId, running: state.running, model: state.status.model, mode: state.status.permissionMode, tools: state.tools.length, facts: { sandbox: sandboxVerified, rules, work: counts, usage: usageLine(facts.snapshot, state.status.model) } }));
+                return;
+            }
+            if (parsed.name === 'usage') {
+                addLocal(usageViewText({ model: state.status.model, facts: usageFacts({ model: state.status.model, usage: state.usage, contextStatus, compactions: state.compactions }) }));
+                return;
+            }
+            /* R5a (owner 2026-09-24): /effort opens the current model's levels as a line of nodes; /effort <level> sets one. */
+            if (parsed.name === 'effort') {
+                let row = await modelMetaWithLevels(state.status.model, currentModelMeta);
+                if (row !== currentModelMeta)
+                    setCurrentModelMeta(row);
+                const choices = row ? reasoningEffortChoices(row) : [];
+                if (!row || !choices.length) {
+                    addLocal(t('screen.effort.none', { model: state.status.model }));
+                    return;
+                }
+                const wanted = parsed.args[0]?.toLowerCase();
+                if (wanted) {
+                    const choice = choices.find(level => level === wanted);
+                    if (!choice) {
+                        addLocal(t('screen.effort.invalid', { level: wanted, model: row.id, choices: choices.join(', ') }));
+                        return;
+                    }
+                    await applyEffortChoice(row, choice);
+                    return;
+                }
+                applyOverlay({ kind: 'model', provider: row.provider });
+                setModelEffortStep(row);
+                setEffortOnly(true);
+                setPickerQuery('');
+                setPickerSelection({ query: '', selected: Math.max(0, choices.indexOf(reasoningEffort ?? 'default')), pageSize: 10 });
+                return;
+            }
+            /* R5b D1 (Q-R5-12): the conversation to a file, Markdown by default, the person's messages kept. */
+            /* R5b D2 (Q-R5-12): a name for this conversation, kept in the CLI's session metadata (the /resume picker shows it). */
+            if (parsed.name === 'rename') {
+                const name = parsed.args.join(' ').trim();
+                if (!state.sessionId) {
+                    addLocal(t('screen.rename.noSession'));
+                    return;
+                }
+                if (!name) {
+                    addLocal(t('screen.usage.rename'));
+                    return;
+                }
+                try {
+                    const store = createSessionMetadataStore({ rootDir: sessionMetadataRoot(paths.dataRoot) });
+                    if (name === '--clear') {
+                        await store.setName(state.sessionId, null);
+                        addLocal(t('screen.rename.cleared'));
+                    }
+                    else {
+                        const saved = await store.setName(state.sessionId, name);
+                        addLocal(t('screen.rename.done', { name: saved.name ?? name }));
+                    }
+                }
+                catch (error) {
+                    addLocal(error?.code === 'SESSION_METADATA_INVALID' ? t('screen.usage.rename') : screenErrorText(error, act('screen.action.command', { command: 'rename' })));
+                }
+                return;
+            }
+            /* R5b D4 (Q-R5-14): /theme opens the picker (the arrows preview); /theme <name> sets one at once. */
+            /* R5b (owner 2026-09-25): the messages sent in this project, newest first; choosing one fills the composer. */
+            if (parsed.name === 'history') {
+                setHistoryPicker({ query: '', selected: 0 });
+                return;
+            }
+            /* R5b (Q-R5-19): the person's last message, sent again through the same path as Enter (queue, steer, readiness). */
+            if (parsed.name === 'retry') {
+                const last = [...state.transcript.items].reverse().find((item) => item.kind === 'message' && item.role === 'user');
+                if (!last?.text.trim()) {
+                    addLocal(t('screen.retry.none'));
+                    return;
+                }
+                const editor = createEditorState(last.text);
+                composerStore.replace(editor);
+                setAppState((current) => ({ ...current, editor }));
+                await submit();
+                return;
+            }
+            /* R5b (Q-R5-19): an answer to the clipboard through the terminal (OSC 52, as Alt+C); the notice says what that means. */
+            if (parsed.name === 'copy') {
+                const nth = parsed.args[0] === undefined ? 1 : Number(parsed.args[0]);
+                if (parsed.args.length > 1 || !Number.isSafeInteger(nth) || nth < 1) {
+                    addLocal(t('screen.usage.copy'));
+                    return;
+                }
+                const answers = state.transcript.items.filter((item) => item.kind === 'message' && item.role === 'assistant' && item.text.trim());
+                if (!answers.length) {
+                    addLocal(t('screen.copy.noAnswer'));
+                    return;
+                }
+                const answer = answers[answers.length - nth];
+                if (!answer) {
+                    addLocal(tn('screen.copy.noSuchAnswer', answers.length));
+                    return;
+                }
+                try {
+                    stdout.write(osc52CopySequence(answer.text));
+                    addLocal(t('screen.copy.answer', { n: nth, chars: answer.text.length.toLocaleString('en-US') }));
+                }
+                catch (error) {
+                    addLocal(screenErrorText(error, act('screen.action.copy')));
+                }
+                return;
+            }
+            /* R5b D3 (Q-R5-13): this conversation's checkpoints with their files; never while a turn runs. */
+            if (parsed.name === 'undo') {
+                if (state.running) {
+                    addLocal(t('screen.undo.busy'));
+                    return;
+                }
+                const store = checkpointStoreFor();
+                if (!store) {
+                    addLocal(t('screen.undo.unavailable'));
+                    return;
+                }
+                /* A resumed conversation is known to the controller before its first event reaches the state. */
+                const undoSession = state.sessionId ?? controller.current() ?? null;
+                if (!undoSession) {
+                    addLocal(t('screen.undo.none'));
+                    return;
+                }
+                try {
+                    const rows = (await sessionCheckpoints(store, undoSession)).filter(row => row.state !== 'open' && checkpointChanges(row).length > 0);
+                    if (!rows.length) {
+                        addLocal(t('screen.undo.none'));
+                        return;
+                    }
+                    setUndoPicker({ rows, selected: 0, confirm: null });
+                }
+                catch (error) {
+                    addLocal(screenErrorText(error, act('screen.action.command', { command: 'undo' })));
+                }
+                return;
+            }
+            if (parsed.name === 'theme') {
+                const wanted = parsed.args.join(' ').trim();
+                if (!wanted) {
+                    setThemePicker({ selected: Math.max(0, THEME_CHOICES.indexOf(themeStore.getSnapshot().id)), original: themeStore.getSnapshot().id });
+                    return;
+                }
+                const id = parseThemeChoice(wanted);
+                if (!id) {
+                    addLocal(t('screen.theme.invalid', { name: wanted, choices: THEME_CHOICES.join(', ') }));
+                    return;
+                }
+                keepTheme(id);
+                return;
+            }
+            if (parsed.name === 'export') {
+                try {
+                    const done = await exportSession({ runtime, sessionId: state.sessionId, projectRoot, args: parsed.args, secrets: secretValuesFromEnvironment(process.env) });
+                    addLocal(t('screen.export.saved', { format: done.format, path: done.path }));
+                }
+                catch (error) {
+                    addLocal(error?.code === 'EXPORT_USAGE' ? t('screen.usage.export') : error?.code === 'SESSION_NOT_FOUND' ? t('screen.export.nothing') : screenErrorText(error, act('screen.action.command', { command: 'export' })));
+                }
+                return;
+            }
+            if (parsed.name === 'busy') {
+                const out = busyCommand(parsed.args, prefs.currentBusyInput());
+                if (out.mode)
+                    prefs.setBusyInput(out.mode);
+                addLocal(out.text);
+                return;
+            }
+            if (parsed.name === 'queue') {
+                const operation = parsed.args[0] ?? 'show';
+                if (operation === 'clear') {
+                    try {
+                        const dropped = await controller.clearQueue();
+                        setQueueEditor(null);
+                        addLocal(dropped.length ? tn('screen.queue.cleared', dropped.length) : t('screen.queue.empty'));
+                    }
+                    catch (error) {
+                        addLocal(screenErrorText(error, act('screen.action.queueClear')));
+                    }
+                    return;
+                }
+                if (operation === 'run') {
+                    if (state.running) {
+                        addLocal(t('screen.queue.busy'));
+                        return;
+                    }
+                    try {
+                        if (!controller.queue().length) {
+                            addLocal(t('screen.queue.empty'));
+                            return;
+                        }
+                        await controller.dispatchQueue();
+                        addLocal(t('screen.queue.resumed'));
+                    }
+                    catch (error) {
+                        addLocal(screenErrorText(error, act('screen.action.queueDispatch')));
+                    }
+                    return;
+                }
+                if (operation !== 'show') {
+                    addLocal(t('screen.usage.queue'));
+                    return;
+                }
+                if (!controller.queue().length) {
+                    addLocal(t('screen.queue.empty'));
+                    return;
+                }
+                setQueueEditor({ selected: 0, editing: false, draft: '' });
+                return;
+            }
+            if (parsed.name === 'context') {
+                if (!state.sessionId) {
+                    addLocal(t('screen.context.noSession'));
+                    return;
+                }
+                if (typeof runtime.contextStatus !== 'function') {
+                    addLocal(t('screen.context.unavailable'));
+                    return;
+                }
+                try {
+                    const next = await runtime.contextStatus(state.sessionId);
+                    setContextStatus(next);
+                    setContextInspector(next);
+                }
+                catch (error) {
+                    addLocal(screenErrorText(error, act('screen.action.contextInspection')));
+                }
+                return;
+            }
+            if (parsed.name === 'permissions') {
+                try {
+                    const dry = permissionDryRunSlash(parsed.args, permissionRules ?? { allow: [], ask: [], deny: [] }, projectRoot);
+                    if (dry !== null) {
+                        addLocal(dry);
+                        return;
+                    }
+                }
+                catch (error) {
+                    addLocal(screenErrorText(error, act('screen.action.permissionDryRun')));
+                    return;
+                }
+                await loadTrustCenter();
+                return;
+            }
+            if (parsed.name === 'plan') {
+                const next = togglePlanMode(controller.mode(), baseMode);
+                controller.setMode(next);
+                setState((current) => localMessage({ ...current, status: { ...current.status, permissionMode: next } }, t(next === 'plan' ? 'screen.plan.enabled' : 'screen.plan.disabled')));
+                return;
+            }
+            if (parsed.name === 'diff') {
+                try {
+                    const result = await execFileAsync('git', ['diff', '--no-ext-diff', '--unified=3'], { cwd: projectRoot, windowsHide: true, maxBuffer: 512 * 1024 });
+                    setDiff(String(result.stdout || t('screen.diff.noChanges')));
+                }
+                catch (error) {
+                    setDiff(String(error?.stdout || error?.stderr || error?.message || t('screen.diff.failed')));
+                }
+                return;
+            }
+            try {
+                const local = await runControllerSlashAction(parsed.name, controller);
+                if (local !== null) {
+                    addLocal(local);
+                    return;
+                }
+            }
+            catch (error) {
+                addLocal(screenErrorText(error, act('screen.action.command', { command: parsed.name })));
+                return;
+            }
+            const cliArgs = slashCommandToCliArgs(parsed.name, parsed.args);
+            /* ⛔ B1 slice 18: the child runs with TALOS_ENVIRONMENT_KEYS=consent, so a command started from this screen never uses an
+               environment key the person has not approved here, whatever this process's own environment says. */
+            if (cliArgs) {
+                try {
+                    const entry = process.argv[1];
+                    if (!entry)
+                        throw new Error('CLI_ENTRY_UNAVAILABLE');
+                    const result = await execFileAsync(process.execPath, [entry, '--project', projectRoot, '--no-color', ...cliArgs], { windowsHide: true, maxBuffer: 512 * 1024, env: screenChildEnvironment(process.env) });
+                    addLocal(String(result.stdout || result.stderr || t('screen.word.ok')).trim());
+                }
+                catch (error) {
+                    /* The child CLI already printed its failure in the error anatomy (errors.ts): it is shown under one headline; a
+                       child that could not start at all is described like any other error. */
+                    const printed = String(error?.stderr ?? '').trim();
+                    addLocal(printed ? `${t('screen.slash.childFailed', { name: parsed.name })}\n${printed}` : screenErrorText(error, act('screen.action.command', { command: parsed.name })));
+                }
+                return;
+            }
+            addLocal(t('screen.slash.notAvailable', { name: parsed.name }));
+        };
+        executeSlashRef.current = executeSlash;
+        /* R5a Q-R5-8: a command that changes the session waits for the turn, in the same queue as the prompts. */
+        const deferSlashCommand = async (text) => { const name = parseSlashCommand(text).name; try {
+            await controller.deferSlash(text, { running: state.running });
+            addLocal(t('screen.busyInput.queuedSlash', { name }));
+        }
+        catch (error) {
+            addLocal(screenErrorText(error, act('screen.action.command', { command: name })));
+        } };
+        /* Alt+S, and Enter in the `steer` busy mode (Q-R5-7): the draft steers the running turn; it leaves the composer only once
+           the runtime took it. */
+        const steerDraft = () => {
+            const draft = draftOf(currentEditor()), text = draft.text;
+            return controller.steer(text, { running: state.running }).then((outcome) => {
+                if (outcome.status !== 'requested')
+                    return;
+                const clearedEditor = createEditorState('');
+                composerStore.replace(clearedEditor);
+                setAppState((current) => ({ ...current, editor: clearedEditor }));
+                rememberSent(draft);
+                historyIndexRef.current = -1;
+                reverseIndexRef.current = 0;
+                setAuxCompletions([]);
+            }).catch((error) => addLocal(screenErrorText(error, act('screen.action.steering'), { rejected: true })));
+        };
+        const submit = async () => {
+            const draft = draftOf(currentEditor());
+            const text = currentEditor().text;
+            if (!text.trim())
+                return;
+            developmentLog('ui.submit.begin', { text: developmentTextEvidence(text), model: controller.model(), running: state.running, mode: controller.mode() }, 'info', 'tui');
+            /* R5a S5 (Q-R5-7, Q-R5-8; E8): what Enter does now (busy-input.ts); the first time while TALOS works, a one-time tip. */
+            const busyAction = busyEnterAction({ text, running: state.running, mode: prefs.currentBusyInput() });
+            if (tipsOnEnter(busyAction) && prefs.firstBusyEnter())
+                addLocal(busyTip(prefs.currentBusyInput()));
+            if (busyAction === 'steer') {
+                await steerDraft();
+                return;
+            }
+            const clearedEditor = createEditorState('');
+            composerStore.replace(clearedEditor);
+            setAppState((current) => ({ ...current, editor: clearedEditor, focus: current.focus.current === 'composer' ? current.focus : createFocusState('composer'), overlay: null }));
+            setVim((current) => current.enabled ? { ...current, mode: 'insert' } : current);
+            rememberSent(draft);
+            historyIndexRef.current = -1;
+            reverseIndexRef.current = 0;
+            setTranscriptRevealId(null);
+            setViewport((view) => ({ ...view, offset: 0, unseen: 0, followingTail: true }));
+            if (text.trim().startsWith('/')) {
+                if (busyAction === 'slash-after-turn')
+                    await deferSlashCommand(text.trim());
+                else
+                    await executeSlash(text.trim());
+                return;
+            }
+            if (!text.trim().startsWith('!')) {
+                const readiness = await readinessFor(controller.model());
+                developmentLog('ui.readiness', { model: controller.model(), readiness }, readiness.ready ? 'debug' : 'warning', 'tui');
+                if (!readiness.ready) {
+                    restoreDraft(draft);
+                    addLocal(readiness.message);
+                    return;
+                }
+            }
+            const willQueue = state.running || controller.queue().length > 0;
+            /* R3 Q-R3-7 (gate E7): a prompt that goes straight to the model says `starting` until its run starts (measured gate §0.3:
+               without it the screen said `idle` and the roster `unknown` after the provider had the request). A `!` command has no run. */
+            const sendsToModel = !willQueue && !text.trim().startsWith('!');
+            if (!willQueue)
+                setState((current) => { const next = userMessage(current, text.trim()); return sendsToModel ? { ...next, sentAt: Date.now(), lastTurn: null } : next; });
+            try {
+                const outcome = await controller.send(text, { model: controller.model(), running: state.running });
+                developmentLog('ui.submit.accepted', { outcome }, 'info', 'tui');
+                if (busyAction === 'interrupt-and-send' && outcome.queued)
+                    await controller.interrupt();
+            }
+            catch (error) {
+                if (sendsToModel)
+                    setState((current) => current.running ? current : { ...current, sentAt: null });
+                developmentLogError('ui.submit.failure', error, { model: controller.model() }, 'tui');
+                addLocal(error instanceof TuiNotReadyError ? error.message : screenErrorText(error, act('screen.action.run')));
+            }
+        };
+        const historyMove = (delta) => { if (!history.length)
+            return; const next = Math.max(-1, Math.min(history.length - 1, historyIndexRef.current + delta)); historyIndexRef.current = next; reverseIndexRef.current = 0; restoreDraft(next >= 0 ? (history[next] ?? '') : ''); };
+        const reverseSearch = () => { const found = reverseHistoryMatch(history, currentEditor().text, reverseIndexRef.current); if (!found) {
+            reverseIndexRef.current = 0;
+            return;
+        } reverseIndexRef.current = found.index + 1; historyIndexRef.current = found.index; restoreDraft(history[found.index] ?? found.value); };
+        const cycleMode = () => { const next = cyclePermissionMode(controller.mode()); controller.setMode(next); setState((current) => ({ ...current, status: { ...current.status, permissionMode: next } })); };
+        const cancelActiveRun = () => { void controller.cancel().then((dropped) => { if (dropped.length)
+            addLocal(tn('screen.queue.cancelledRun', dropped.length)); }).catch((error) => addLocal(screenErrorText(error, act('screen.action.cancel')))); };
+        const filteredModels = modelItems(modelRows, pickerQuery);
+        const effortRows = modelEffortStep ? reasoningEffortChoices(modelEffortStep) : [];
+        const filteredProviders = providerPickerItems(providerRows, pickerQuery, { reachable: id => providerPickerRef.current?.reachable(id) ?? null });
+        const filteredSessions = filterSessions(sessionRows, pickerQuery);
+        const activePickerRows = appState.focus.current === 'model-picker' ? (modelEffortStep ? effortRows : filteredModels) : appState.focus.current === 'provider-picker' ? filteredProviders : appState.focus.current === 'session-picker' ? filteredSessions : [];
+        const movePicker = (action) => {
+            const movement = pickerMove(action);
+            if (!movement)
+                return;
+            if (appState.focus.current === 'command-menu') {
+                /* R4 Q-R4-5: after a typo nothing is highlighted; the first arrow key lands on the top row. */
+                const text = currentEditor().text;
+                if (commandMenuHighlight(text, commandMenuSelectionStore.getSnapshot()) < 0)
+                    commandMenuSelectionStore.highlight(0);
+                else
+                    commandMenuSelectionStore.move(commandMenuItems(text).length, movement);
+                return;
+            }
+            setPickerSelection((current) => moveSelection({ ...current, query: pickerQuery }, activePickerRows.length, movement));
+        };
+        const pickerBackspace = () => {
+            if (appState.focus.current === 'model-picker' && modelEffortStep) {
+                if (effortOnly)
+                    return;
+                setModelEffortStep(null);
+                setPickerSelection({ query: '', selected: 0, pageSize: 10 });
+                return;
+            }
+            if (appState.focus.current === 'command-menu') {
+                updateEditor(editor => { const next = deleteBackward(editor); if (next.text.length === 0)
+                    setTimeout(() => setAppState((current) => ({ ...current, focus: closeFocus(current.focus) })), 0); return next; });
+                commandMenuSelectionStore.reset();
+                return;
+            }
+            if (appState.focus.current === 'provider-picker' && (providerStep.kind === 'key' || providerStep.kind === 'oauth'))
+                setProviderSecret((value) => value.slice(0, -1));
+            else if (appState.focus.current === 'provider-picker' && providerStep.kind === 'consent') { /* nothing to erase */ }
+            else
+                setPickerQuery((value) => value.slice(0, -1));
+            setPickerSelection((current) => ({ ...current, selected: 0 }));
+        };
+        /*
+         * R4 Q-R4-5 / gate E6: in the command menu Enter RUNS the highlighted command through the one dispatcher — the composer
+         * gets `/<name>` and `submit` runs it exactly as if the person had typed the name and pressed Enter (history, slash
+         * branch, "Did you mean"). With nothing highlighted (a typo, or arguments typed) Enter sends the text as typed. Tab
+         * (`complete`) keeps completing `/<name> ` for arguments (the highlighted row, else the top row).
+         */
+        const confirmPicker = async (mode = 'run') => {
+            if (appState.focus.current === 'command-menu') {
+                const selected = commandMenuSelectionStore.getSnapshot().selected;
+                const rows = commandMenuItems(currentEditor().text);
+                const highlighted = commandMenuHighlight(currentEditor().text, commandMenuSelectionStore.getSnapshot());
+                const row = highlighted >= 0 ? rows[highlighted] : mode === 'complete' ? rows[selected] : undefined;
+                if (mode === 'complete' && !row)
+                    return;
+                setAppState((current) => ({ ...current, focus: closeFocus(current.focus) }));
+                commandMenuSelectionStore.reset();
+                setPickerSelection({ query: '', selected: 0, pageSize: 10 });
+                if (mode === 'complete') {
+                    setEditorText(completeCommandSelection(row.command));
+                    return;
+                }
+                if (row)
+                    setEditorText(`/${row.command.name}`);
+                await submit();
+                return;
+            }
+            const selected = pickerSelection.selected;
+            if (appState.focus.current === 'model-picker') {
+                if (modelEffortStep) {
+                    const choice = effortRows[selected];
+                    if (!choice)
+                        return;
+                    await applyEffortChoice(modelEffortStep, choice);
+                    return;
+                }
+                const row = filteredModels[selected];
+                if (!row)
+                    return;
+                const choices = reasoningEffortChoices(row);
+                if (choices.length) {
+                    setModelEffortStep(row);
+                    setPickerQuery('');
+                    setPickerSelection({ query: '', selected: 0, pageSize: 10 });
+                    return;
+                }
+                try {
+                    await commitModelSelection({ id: row.id, catalog, setControllerModel: (id) => controller.setModel(id) });
+                    if (typeof runtime.setDefaultReasoningEffort === 'function')
+                        runtime.setDefaultReasoningEffort(null);
+                    setReasoningEffort(null);
+                    setCurrentModelMeta(row);
+                    setState((current) => localMessage({ ...current, status: { ...current.status, model: row.id } }, t('screen.model.changedNoEffort', { model: row.id })));
+                    closeCurrentOverlay();
+                }
+                catch (error) {
+                    addLocal(screenErrorText(error, act('screen.action.modelChange')));
+                }
+                return;
+            }
+            if (appState.focus.current === 'provider-picker') {
+                if (providerStep.kind === 'login-choice') {
+                    const step = providerStep;
+                    if (step.choice === 'browser') {
+                        await startOAuth(step.provider);
+                        return;
+                    }
+                    setProviderSecret('');
+                    setProviderStep({ kind: 'key', provider: step.provider, testing: false, result: null, ...(step.remediation ? { remediation: step.remediation } : {}) });
+                    return;
+                }
+                if (providerStep.kind === 'oauth') {
+                    const step = providerStep;
+                    if (step.phase === 'failed') {
+                        await startOAuth(step.provider);
+                        return;
+                    }
+                    if (step.phase !== 'paste' || !oauthLoginRef.current)
+                        return;
+                    const pasted = providerSecret;
+                    setProviderSecret('');
+                    if (!pasted.trim())
+                        return;
+                    try {
+                        await oauthLoginRef.current.submit(pasted);
+                    }
+                    catch (error) {
+                        if (error?.code === 'OAUTH_CODE_MISSING')
+                            setProviderStep({ ...step, message: oauthErrorText(step.provider, error) });
+                    }
+                    return;
+                }
+                if (providerStep.kind === 'consent') {
+                    const step = providerStep;
+                    try {
+                        await catalog.answerEnvironmentKey(step.provider.id, step.choice);
+                    }
+                    catch (error) {
+                        addLocal(screenErrorText(codeOnly(error), act('screen.action.answer')));
+                        return;
+                    }
+                    const refreshed = (await catalog.listProviders()).find((entry) => entry.id === step.provider.id) ?? { ...step.provider, keySource: step.choice === 'yes' ? 'environment' : 'environment-declined' };
+                    if (step.choice === 'yes')
+                        addLocal(t('screen.provider.envKeyUsed', { variable: step.provider.environmentVariable ?? t('screen.provider.envKeyFallback'), provider: step.provider.label }));
+                    await routeProviderSelection(step.choice === 'yes' ? refreshed : { ...refreshed, keySource: 'environment-declined' }, { allowEnvironmentConsent: false });
+                    return;
+                }
+                if (providerStep.kind === 'key') {
+                    const step = providerStep;
+                    if (step.testing)
+                        return;
+                    let secret = providerSecret;
+                    setProviderSecret('');
+                    if (!secret.trim())
+                        return;
+                    setProviderStep({ ...step, testing: true, result: null });
+                    let result;
+                    try {
+                        result = await catalog.setProviderKey(step.provider.id, secret);
+                    }
+                    catch (error) {
+                        setProviderStep({ ...step, testing: false, result: null });
+                        addLocal(screenErrorText(codeOnly(error), act('screen.action.keyTest'), { note: t('screen.provider.keyNotSaved') }));
+                        return;
+                    }
+                    finally {
+                        secret = '';
+                    }
+                    if (!result.saved) {
+                        setProviderStep({ ...step, testing: false, result });
+                        return;
+                    }
+                    addLocal(t('screen.provider.keySaved', { message: result.message, saved: keySavedText() })); /* R2 lane K (E13): the memory store must not claim the system keyring */
+                    const refreshed = (await catalog.listProviders()).find((entry) => entry.id === step.provider.id) ?? { ...step.provider, configured: true };
+                    await chooseProviderAndOpenModels(refreshed);
+                    return;
+                }
+                const row = filteredProviders[selected];
+                if (!row)
+                    return;
+                await routeProviderSelection(row);
+                return;
+            }
+            if (appState.focus.current === 'session-picker') {
+                const model = sessionPickerRef.current;
+                if (!model || sessionConfirmingRef.current)
+                    return;
+                model.setQuery(pickerQuery);
+                if (!model.rows()[selected])
+                    return;
+                model.select(selected);
+                const from = model.rows()[selected];
+                sessionConfirmingRef.current = true;
+                try {
+                    freshView();
+                    const id = await model.confirm();
+                    closeCurrentOverlay();
+                    if (id && model.action() === 'fork')
+                        addLocal(t('screen.session.forked', { from: from.title || from.id, id }));
+                }
+                catch (error) {
+                    addLocal(screenErrorText(error, act('screen.action.sessionAction')));
+                }
+                finally {
+                    sessionConfirmingRef.current = false;
+                }
+                return;
+            }
+        };
+        /* R4 Q-R4-7: a picker, dialog or center is open (the approval dialog answers its own keys, R3 E11). */
+        const dialogOpen = () => Boolean((appState.overlay && appState.overlay.kind !== 'approval') || appState.focus.current === 'command-menu' || queueEditor || transcriptSearch || contextInspector || themePicker || undoPicker || historyPicker || agentTreeOverlay || trustCenter || mcpCenter || hookCenter || pluginCenter || memoryCenter || notesCenter || tasksCenter || libraryCenter || researchCenter || automationCenter || forgeCenter);
+        interruptContextRef.current = () => ({ draft: composerStore.getSnapshot().text.length > 0, dialog: dialogOpen(), completion: Boolean(fileCompletionRef.current) });
+        const closeAnyDialog = () => {
+            if (appState.focus.current === 'provider-picker')
+                providerPickerRef.current?.cancel();
+            if (appState.focus.current === 'model-picker')
+                modelPickerRef.current?.cancel();
+            if (appState.focus.current === 'session-picker')
+                sessionPickerRef.current?.cancel();
+            if (appState.focus.current === 'command-menu')
+                commandMenuSelectionStore.reset();
+            setQueueEditor(null);
+            setTranscriptSearch(null);
+            setContextInspector(null);
+            setAgentTreeOverlay(null);
+            setResearchCenter(null);
+            setAutomationCenter(null);
+            setForgeCenter(null);
+            closeCurrentOverlay();
+        };
+        /* R4 Q-R4-7 / E7: a cleared draft goes into history first, so ↑ brings it back (with its paste blocks, Q-R4-9). */
+        const clearDraftIntoHistory = () => { rememberDraft(draftOf(currentEditor())); historyIndexRef.current = -1; reverseIndexRef.current = 0; const cleared = createEditorState(''); composerStore.replace(cleared); setAppState((current) => ({ ...current, editor: cleared })); setAuxCompletions([]); };
+        /* R4 Q-R4-8: Esc closes the `@` list until the token changes; ↑/↓ move its highlight; Tab or Enter insert the
+           highlighted path (a folder keeps the list open one level down, a file ends with a space and closes it). Enter on a
+           file already typed in full is not taken: it sends the prompt. */
+        const dismissCompletion = () => { const watch = completionWatchRef.current; watch.dismissed = fileCompletionRef.current?.token ?? watch.token; watch.seq++; setFileCompletion(null); };
+        const moveCompletion = (delta) => setFileCompletion((current) => current && current.rows.length ? { ...current, selected: Math.max(0, Math.min(current.rows.length - 1, current.selected + delta)) } : current);
+        const acceptCompletion = (how) => {
+            const current = fileCompletionRef.current, row = current?.rows[current.selected];
+            if (!current || !row)
+                return false;
+            if (how === 'enter' && row.value === current.token)
+                return false;
+            const value = row.directory ? row.value : `${row.value} `;
+            updateEditor(editor => lastProjectToken(editor.text) === current.token ? replaceLastProjectToken(editor, current.token, value) : editor);
+            return true;
+        };
+        /* R4 E7: interrupt.ts decides; app.ts only carries the decision out. */
+        const applyInterrupt = (decision, key) => {
+            if (decision === 'cancel') {
+                cancelActiveRun();
+                return;
+            }
+            if (decision === 'arm-exit') {
+                showExitHint(key);
+                return;
+            }
+            if (decision === 'exit' || decision === 'force-exit') {
+                inkApp.exit();
+                return;
+            }
+            if (decision === 'close-dialog') {
+                hideExitHint();
+                closeAnyDialog();
+                return;
+            }
+            if (decision === 'clear-draft') {
+                hideExitHint();
+                clearDraftIntoHistory();
+                return;
+            }
+            if (decision === 'delete-forward') {
+                updateEditor(deleteForward);
+                return;
+            }
+            if (decision === 'close-completion') {
+                dismissCompletion();
+                return;
+            }
+            if (decision === 'stop-run') {
+                void controller.interrupt().catch((error) => addLocal(screenErrorText(error, act('screen.action.interrupt'))));
+                return;
+            }
+            setAuxCompletions([]);
+            setTranscriptRevealId(null);
+            setViewport((view) => ({ ...view, offset: 0, unseen: 0, followingTail: true }));
+        };
+        const handleSemanticAction = (action, key) => {
+            /* R3 E11: the approval dialog's keys are handled by handleApprovalKey, from the synchronous refs; a render that still
+               shows the dialog after it closed must not answer anything. */
+            if (appState.focus.current === 'approval' && (action.startsWith('approval-') || action === 'interrupt'))
+                return;
+            if (fileCompletionRef.current?.rows.length && appState.focus.current === 'composer') {
+                if ((action === 'history-prev' || action === 'history-next') && !key?.ctrl) {
+                    moveCompletion(action === 'history-prev' ? -1 : 1);
+                    return;
+                }
+                if (action === 'palette' && acceptCompletion('tab'))
+                    return;
+                if (action === 'submit' && acceptCompletion('enter'))
+                    return;
+            }
+            if (action === 'overlay-close') {
+                closeCurrentOverlay();
+                return;
+            }
+            if (action === 'picker-cancel' && setupRef.current && appState.focus.current === 'model-picker' && modelList.engineDown && !modelEffortStep) {
+                modelPickerRef.current?.cancel();
+                setupTransitionRef.current = true;
+                setupPendingProviderRef.current = null;
+                void loadProviders().finally(() => { setupTransitionRef.current = false; });
+                return;
+            }
+            if (action === 'picker-cancel') {
+                if (appState.focus.current === 'provider-picker')
+                    providerPickerRef.current?.cancel();
+                if (appState.focus.current === 'model-picker')
+                    modelPickerRef.current?.cancel();
+                if (appState.focus.current === 'session-picker')
+                    sessionPickerRef.current?.cancel();
+                closeCurrentOverlay();
+                return;
+            }
+            if (appState.focus.current === 'provider-picker' && providerStep.kind === 'login-choice' && (action === 'picker-up' || action === 'picker-home')) {
+                setProviderStep({ ...providerStep, choice: 'browser' });
+                return;
+            }
+            if (appState.focus.current === 'provider-picker' && providerStep.kind === 'login-choice' && (action === 'picker-down' || action === 'picker-end')) {
+                setProviderStep({ ...providerStep, choice: 'paste-key' });
+                return;
+            }
+            if (appState.focus.current === 'provider-picker' && providerStep.kind === 'consent' && (action === 'picker-up' || action === 'picker-home')) {
+                setProviderStep({ ...providerStep, choice: 'no' });
+                return;
+            }
+            if (appState.focus.current === 'provider-picker' && providerStep.kind === 'consent' && (action === 'picker-down' || action === 'picker-end')) {
+                setProviderStep({ ...providerStep, choice: 'yes' });
+                return;
+            }
+            if (appState.focus.current === 'provider-picker' && providerStep.kind !== 'list' && action.startsWith('picker-') && action !== 'picker-confirm' && action !== 'picker-backspace')
+                return;
+            if (action.startsWith('picker-') && action !== 'picker-confirm' && action !== 'picker-backspace') {
+                movePicker(action);
+                return;
+            }
+            if (action === 'picker-backspace') {
+                pickerBackspace();
+                return;
+            }
+            if (action === 'picker-confirm') {
+                void confirmPicker();
+                return;
+            }
+            if (action === 'command-complete' && appState.focus.current === 'command-menu') {
+                void confirmPicker('complete');
+                return;
+            }
+            if (action === 'interrupt') {
+                if (key?.escape) {
+                    const decision = interruptRef.current.esc(state.running);
+                    if (decision === 'stop-run') {
+                        void controller.interrupt().catch((error) => addLocal(screenErrorText(error, act('screen.action.interrupt'))));
+                        return;
+                    }
+                    applyInterrupt(decision, 'ctrl-c');
+                    return;
+                }
+                const result = interruptRef.current.ctrlC(state.running);
+                if (result === 'cancel')
+                    cancelActiveRun();
+                else
+                    applyInterrupt(result, 'ctrl-c');
+                return;
+            }
+            /* R4 Q-R4-7: Ctrl+D where the composer does not own it (a picker), and a key a person bound to clear-draft. */
+            if (action === 'exit') {
+                applyInterrupt(interruptRef.current.ctrlD(state.running), 'ctrl-d');
+                return;
+            }
+            if (action === 'clear-draft') {
+                if (currentEditor().text.length)
+                    applyInterrupt('clear-draft', 'ctrl-c');
+                return;
+            }
+            if (action === 'vim-toggle') {
+                setVim((current) => toggleVim(current));
+                return;
+            }
+            if (action === 'agent-tree') {
+                void controller.agentTree().then((tree) => {
+                    const rows = agentRosterRows(tree);
+                    setAgentRows(rows);
+                    if (!rows.length) {
+                        addLocal(t('screen.agents.none'));
+                        return;
+                    }
+                    setAgentTreeOverlay(createAgentTreeOverlayModel(rows, tree?.focusId ?? controller.current()));
+                }).catch((error) => addLocal(screenErrorText(error, act('screen.action.agentTree'))));
+                return;
+            }
+            if (action === 'steer') {
+                void steerDraft();
+                return;
+            }
+            if (action === 'command-menu') {
+                const editor = composerStore.update(current => editInsert(current, '/'));
+                commandMenuSelectionStore.reset();
+                setAppState((current) => ({ ...current, editor, focus: openFocus(current.focus, 'command-menu') }));
+                setPickerSelection({ query: '', selected: 0, pageSize: 10 });
+                return;
+            }
+            if (action === 'model-picker') {
+                void loadModels();
+                return;
+            }
+            if (action === 'provider-picker') {
+                void loadProviders();
+                return;
+            }
+            if (action === 'help') {
+                setHelpOffset(0);
+                applyOverlay({ kind: 'help' });
+                return;
+            }
+            if (action === 'reasoning-toggle' || action === 'tool-details' || action === 'redraw') {
+                runKeyAction(action);
+                return;
+            }
+            if (action === 'transcript-search') {
+                openTranscriptSearch();
+                return;
+            }
+            if (action === 'transcript-raw') {
+                setTranscriptRaw((value) => !value);
+                setTranscriptSearch((current) => current ? { ...current, raw: !transcriptRaw, notice: null } : current);
+                return;
+            }
+            if (action === 'transcript-copy') {
+                copyTranscriptItem();
+                return;
+            }
+            if (action === 'permission-cycle') {
+                cycleMode();
+                return;
+            }
+            if (action === 'page-up') {
+                scrollTranscript('page-up');
+                return;
+            }
+            if (action === 'page-down') {
+                scrollTranscript('page-down');
+                return;
+            }
+            if (action === 'history-search') {
+                reverseSearch();
+                return;
+            }
+            if (action === 'history-prev' && key?.ctrl) {
+                historyMove(1);
+                return;
+            }
+            if (action === 'history-next' && key?.ctrl) {
+                historyMove(-1);
+                return;
+            }
+            if (action === 'external-editor') {
+                void editExternally({ text: currentEditor().text, editor: process.env.VISUAL ?? process.env.EDITOR, tmpRoot: paths.cacheRoot }).then(setEditorText).catch(error => addLocal(screenErrorText(error, act('screen.action.externalEditor'))));
+                return;
+            }
+            if (action === 'palette') {
+                const token = lastProjectToken(currentEditor().text);
+                if (token) {
+                    checkCompletion(true);
+                    return;
+                }
+                const rows = commandMenuItems(currentEditor().text);
+                setAuxCompletions(rows.slice(0, 8).map(row => `/${row.command.name}`));
+                if (rows.length === 1)
+                    setEditorText(completeCommandSelection(rows[0].command));
+                return;
+            }
+            if (action === 'newline') {
+                updateEditor(editor => editInsert(editor, '\n'));
+                return;
+            }
+            if (action === 'submit') {
+                void submit();
+                return;
+            }
+            if (action === 'undo') {
+                updateEditor(undoEditor);
+                return;
+            }
+            if (action === 'redo') {
+                updateEditor(redoEditor);
+                return;
+            }
+            if (action === 'home') {
+                updateEditor(editor => moveCursor(editor, 'home'));
+                return;
+            }
+            if (action === 'end') {
+                updateEditor(editor => moveCursor(editor, 'end'));
+                return;
+            }
+            if (action === 'left') {
+                updateEditor(editor => moveCursor(editor, 'left'));
+                return;
+            }
+            if (action === 'right') {
+                updateEditor(editor => moveCursor(editor, 'right'));
+                return;
+            }
+            if (action === 'word-left') {
+                updateEditor(editor => moveWord(editor, -1));
+                return;
+            }
+            if (action === 'word-right') {
+                updateEditor(editor => moveWord(editor, 1));
+                return;
+            }
+            if (action === 'select-home') {
+                updateEditor(editor => moveCursor(editor, 'home', true));
+                return;
+            }
+            if (action === 'select-end') {
+                updateEditor(editor => moveCursor(editor, 'end', true));
+                return;
+            }
+            if (action === 'select-left') {
+                updateEditor(editor => moveCursor(editor, 'left', true));
+                return;
+            }
+            if (action === 'select-right') {
+                updateEditor(editor => moveCursor(editor, 'right', true));
+                return;
+            }
+            if (action === 'select-up') {
+                updateEditor(editor => moveVertical(editor, -1, true));
+                return;
+            }
+            if (action === 'select-down') {
+                updateEditor(editor => moveVertical(editor, 1, true));
+                return;
+            }
+            if (action === 'select-word-left') {
+                updateEditor(editor => moveWord(editor, -1, true));
+                return;
+            }
+            if (action === 'select-word-right') {
+                updateEditor(editor => moveWord(editor, 1, true));
+                return;
+            }
+            if (action === 'copy-selection') {
+                updateEditor(copySelection);
+                return;
+            }
+            if (action === 'kill-start') {
+                updateEditor(killToStart);
+                return;
+            }
+            if (action === 'kill-end') {
+                updateEditor(killToEnd);
+                return;
+            }
+            if (action === 'kill-word') {
+                updateEditor(killWordBackward);
+                return;
+            }
+            if (action === 'yank') {
+                updateEditor(yank);
+                return;
+            }
+            if (action === 'delete-forward') {
+                if (key?.ctrl) {
+                    applyInterrupt(interruptRef.current.ctrlD(state.running), 'ctrl-d');
+                    return;
+                }
+                updateEditor(deleteForward);
+                return;
+            }
+            if (action === 'backspace') {
+                updateEditor(deleteBackward);
+                return;
+            }
+            if (action === 'history-prev') {
+                const editor = currentEditor();
+                const hadSelection = editor.selectionAnchor !== undefined;
+                const moved = moveVertical(editor, -1);
+                if (moved.cursor !== editor.cursor || hadSelection)
+                    updateEditor(() => moved);
+                else
+                    historyMove(1);
+                return;
+            }
+            if (action === 'history-next') {
+                const editor = currentEditor();
+                const hadSelection = editor.selectionAnchor !== undefined;
+                const moved = moveVertical(editor, 1);
+                if (moved.cursor !== editor.cursor || hadSelection)
+                    updateEditor(() => moved);
+                else
+                    historyMove(-1);
+                return;
+            }
+        };
+        /* R4 Q-R4-8: an open `@` list counts as completions: the composer's fast paths step aside so its keys reach the list. */
+        const auxCount = auxCompletions.length + (fileCompletion ? 1 : 0);
+        const pasteOwner = composerOwnsPaste({
+            bootPhase: boot.phase,
+            focus: appState.focus.current,
+            modalOwner: Boolean(appState.overlay || queueEditor || transcriptSearch || contextInspector || themePicker || undoPicker || historyPicker || agentTreeOverlay || agentView || trustCenter || mcpCenter || hookCenter || pluginCenter || memoryCenter || notesCenter || tasksCenter || libraryCenter || researchCenter || automationCenter || forgeCenter || pending),
+            vimMode: vim.enabled ? vim.mode : 'disabled',
+            auxCount,
+        });
+        Ink.usePaste((pastedText) => {
+            /* R3-KEYS: no C0 or DEL character reaches the editor or the model, except a line break. */
+            composerStore.update(editor => applyComposerFastPasteInput(editor, sanitizeInputText(pastedText)));
+        }, { isActive: pasteOwner });
+        /* R3 gate E11: one key in the approval dialog (Q-R3-5/6/14). Esc from the summary and Ctrl+C deny and stop the turn;
+           Enter answers the highlight (Deny by default: deny and continue); a digit answers at once; [5] only in the full review. */
+        const answerApproval = (choice, stop) => {
+            const current = pendingRef.current, shown = approvalShownRef.current;
+            if (!current || !shown || shown.answered || shown.requestId !== current.requestId)
+                return;
+            shown.answered = true;
+            void controller.resolveApproval(current.requestId, choice).then(() => { if (stop)
+                return controller.interrupt(); }).catch((error) => addLocal(screenErrorText(error, act('screen.action.approval'))));
+        };
+        const handleApprovalKey = (ch, key) => {
+            const ui = approvalUiRef.current;
+            if (ui.expanded && (key.pageUp || key.pageup || key.pageDown || key.pagedown || key.upArrow || key.downArrow)) {
+                const delta = (key.pageDown || key.pagedown) ? 4 : (key.pageUp || key.pageup) ? -4 : key.downArrow ? 1 : -1;
+                setApprovalScroll((value) => Math.max(0, Math.min(approvalMaxOffsetRef.current, value + delta)));
+                return;
+            }
+            const action = resolveKeybinding(ch, key, ['approval', 'global'], effectiveKeymap);
+            const outcome = approvalKeyOutcome(action, { expanded: ui.expanded, selected: ui.selected, escape: Boolean(key.escape) });
+            if (outcome.kind === 'answer') {
+                answerApproval(outcome.choice, outcome.stop);
+                return;
+            }
+            if (outcome.kind === 'select') {
+                approvalUiRef.current = { ...ui, selected: outcome.selected };
+                setApprovalSelected(outcome.selected);
+                return;
+            }
+            if (outcome.kind === 'toggle-review' || outcome.kind === 'back') {
+                const expanded = outcome.kind === 'toggle-review' ? !ui.expanded : false;
+                approvalUiRef.current = { ...ui, expanded };
+                setApprovalExpanded(expanded);
+                setApprovalScroll(0);
+                return;
+            }
+            if (action === 'tool-details' || action === 'reasoning-toggle' || action === 'redraw')
+                runKeyAction(action);
+        };
+        Ink.useInput((rawCh, rawKey) => {
+            /* R3-KEYS: a mixed chunk is its leading key, then text with no control character. */
+            for (const part of splitInputChunk(rawCh, rawKey))
+                handleInput(part.ch, part.key);
+        });
+        const handleInput = (ch, key) => {
+            const approvalGate = approvalInputGate(approvalShownRef.current, clockRef.current());
+            if (approvalGate === 'dialog') {
+                coordinator.immediate('approval', () => handleApprovalKey(ch, key));
+                return;
+            }
+            /* In the grace the key belongs to what is under the dialog, and only the composer takes it. */
+            const graceComposer = approvalGate === 'grace';
+            const focusNow = graceComposer && appState.focus.current === 'approval' ? (appState.focus.stack.at(-1) ?? 'composer') : appState.focus.current;
+            if (graceComposer && focusNow !== 'composer')
+                return;
+            const modalOwner = Boolean((appState.overlay && !(graceComposer && appState.overlay.kind === 'approval')) || queueEditor || transcriptSearch || contextInspector || themePicker || undoPicker || historyPicker || agentTreeOverlay || agentView || trustCenter || mcpCenter || hookCenter || pluginCenter || memoryCenter || notesCenter || tasksCenter || libraryCenter || researchCenter || automationCenter || forgeCenter || (pending && !graceComposer));
+            /* R1 E15 / Q-R1-7 (no mouse capture): Ctrl+Home and Ctrl+End move the transcript to its first and newest rows, as in
+               Claude Code fullscreen and Qwen Code. The keymap resolver drops Ctrl on Home/End, so they are read here first. */
+            if (key?.ctrl && (key.home || key.end) && !modalOwner && boot.phase === 'ready') {
+                scrollTranscript(key.home ? 'top' : 'jump-tail');
+                return;
+            }
+            /* P13: the watched agent's transcript scrolls the same way (the view owns the composer, not the transcript). */
+            if (agentView && !agentTreeOverlay && !appState.overlay && key?.ctrl && (key.home || key.end) && boot.phase === 'ready') {
+                scrollTranscript(key.home ? 'top' : 'jump-tail');
+                return;
+            }
+            /* Lane O: the help overlay scrolls inside its budget; the keymap has no help-context scroll keys, so they are read here. */
+            if (appState.overlay?.kind === 'help' && (key.pageUp || key.pageDown || key.upArrow || key.downArrow)) {
+                const step = key.pageUp || key.pageDown ? helpPageRef.current : 1, delta = key.pageUp || key.upArrow ? -step : step;
+                setHelpOffset((value) => Math.max(0, Math.min(helpMaxOffsetRef.current, value + delta)));
+                return;
+            }
+            const fastDecision = decideShellInput({
+                ch, key, focus: focusNow, composerText: currentEditor().text, commandMenuOpen: focusNow === 'command-menu',
+                trustCenterOpen: Boolean(trustCenter), approvalExpanded, boot, keymap: effectiveKeymap,
+            });
+            const fastText = composerFastTextInput({ bootPhase: boot.phase, focus: focusNow, modalOwner, vimMode: vim.enabled ? vim.mode : 'disabled', auxCount, key, routed: fastDecision.routed });
+            if (fastText !== null) {
+                composerStore.update(editor => editInsert(editor, fastText));
+                return;
+            }
+            const fastPaste = composerFastPasteInput({ bootPhase: boot.phase, focus: focusNow, modalOwner, vimMode: vim.enabled ? vim.mode : 'disabled', auxCount, key, routed: fastDecision.routed });
+            if (fastPaste !== null) {
+                composerStore.update(editor => applyComposerFastPasteInput(editor, fastPaste));
+                return;
+            }
+            const fastEditorAction = composerFastEditorAction({ bootPhase: boot.phase, focus: focusNow, modalOwner, vimMode: vim.enabled ? vim.mode : 'disabled', auxCount, routed: fastDecision.routed, editor: currentEditor() });
+            if (fastEditorAction !== null) {
+                composerStore.update(editor => applyComposerFastEditorAction(editor, fastEditorAction));
+                return;
+            }
+            const historyPlan = planComposerHistoryAction({
+                bootPhase: boot.phase, focus: focusNow, modalOwner, vimMode: vim.enabled ? vim.mode : 'disabled', auxCount,
+                routed: fastDecision.routed, key, editor: currentEditor(), history, historyIndex: historyIndexRef.current, reverseIndex: reverseIndexRef.current,
+            });
+            if (historyPlan !== null) {
+                historyIndexRef.current = historyPlan.historyIndex;
+                reverseIndexRef.current = historyPlan.reverseIndex;
+                composerStore.replace(historyPlan.editor);
+                return;
+            }
+            const commandQuery = commandMenuFastTextInput({ bootPhase: boot.phase, focus: focusNow, modalOwner, key, routed: fastDecision.routed });
+            if (commandQuery !== null) {
+                commandMenuSelectionStore.reset();
+                composerStore.update(editor => editInsert(editor, commandQuery));
+                return;
+            }
+            coordinator.immediate('input', () => {
+                if (forgeCenter) {
+                    if (key.ctrl && (ch === 'c' || ch === 'C')) {
+                        setForgeCenter(null);
+                        return;
+                    }
+                    if (key.escape || (ch === 'q' && !key.ctrl && !key.meta)) {
+                        setForgeCenter(null);
+                        return;
+                    }
+                    const loadSelected = (next) => { setForgeCenter(next); const row = selectedForgeTool(next); if (row)
+                        void forgeFacade().read(row.id).then(detail => setForgeCenter((current) => current ? setForgeCenterDetail(current, detail) : current)).catch((error) => addLocal(screenErrorText(error, act('screen.action.forgeDetail')))); };
+                    if (key.upArrow) {
+                        loadSelected(moveForgeCenterSelection(forgeCenter, -1));
+                        return;
+                    }
+                    if (key.downArrow) {
+                        loadSelected(moveForgeCenterSelection(forgeCenter, 1));
+                        return;
+                    }
+                    const row = selectedForgeTool(forgeCenter);
+                    if (ch === 'r') {
+                        void loadForgeCenter(row?.id);
+                        return;
+                    }
+                    if (!row)
+                        return;
+                    const ownerSessionId = state.sessionId;
+                    if (ch === 'e') {
+                        if (!ownerSessionId) {
+                            addLocal(t('screen.forge.needsSession'));
+                            return;
+                        }
+                        void forgeFacade().setEnabled(ownerSessionId, row.id, !row.enabled).then(() => loadForgeCenter(row.id)).catch((error) => addLocal(screenErrorText(error, act('screen.action.forgeToggle'))));
+                        return;
+                    }
+                    if (ch === 'b') {
+                        if (!ownerSessionId) {
+                            addLocal(t('screen.forge.rollbackNeedsSession'));
+                            return;
+                        }
+                        const versions = Array.isArray(forgeCenter.detail?.versions) ? forgeCenter.detail.versions : [];
+                        const current = row.ownerRevision ?? Number.MAX_SAFE_INTEGER;
+                        const candidates = versions.map((v) => Number(v.revision ?? v.ownerRevision)).filter((v) => Number.isSafeInteger(v) && v < current).sort((a, b) => b - a);
+                        const target = candidates[0];
+                        if (!target) {
+                            addLocal(t('screen.forge.noEarlierRevision'));
+                            return;
+                        }
+                        void forgeFacade().rollback(ownerSessionId, row.id, target).then(() => loadForgeCenter(row.id)).catch((error) => addLocal(screenErrorText(error, act('screen.action.forgeRollback'))));
+                        return;
+                    }
+                    return;
+                }
+                if (automationCenter) {
+                    if (key.ctrl && (ch === 'c' || ch === 'C')) {
+                        setAutomationCenter(null);
+                        return;
+                    }
+                    if (key.escape || (ch === 'q' && !key.ctrl && !key.meta)) {
+                        setAutomationCenter(null);
+                        return;
+                    }
+                    const loadSelected = (next) => { setAutomationCenter(next); const row = selectedAutomation(next); if (row)
+                        void automationFacade().read(row.id).then(detail => setAutomationCenter((current) => current ? setAutomationCenterDetail(current, detail) : current)).catch((error) => addLocal(screenErrorText(error, act('screen.action.automationDetail')))); };
+                    if (key.upArrow) {
+                        loadSelected(moveAutomationCenterSelection(automationCenter, -1));
+                        return;
+                    }
+                    if (key.downArrow) {
+                        loadSelected(moveAutomationCenterSelection(automationCenter, 1));
+                        return;
+                    }
+                    const row = selectedAutomation(automationCenter);
+                    if (ch === 'u') {
+                        void loadAutomationCenter(row?.id);
+                        return;
+                    }
+                    if (ch === 'd' && row) {
+                        void automationFacade().read(row.id).then(detail => setAutomationCenter((current) => current ? setAutomationCenterDetail(current, detail) : current)).catch((error) => addLocal(screenErrorText(error, act('screen.action.automationDryRun'))));
+                        return;
+                    }
+                    return;
+                }
+                if (researchCenter) {
+                    if (key.ctrl && (ch === 'c' || ch === 'C')) {
+                        setResearchCenter(null);
+                        return;
+                    }
+                    if (key.escape || (ch === 'q' && !key.ctrl && !key.meta)) {
+                        setResearchCenter(null);
+                        return;
+                    }
+                    if (key.upArrow) {
+                        const next = moveResearchCenterSelection(researchCenter, -1);
+                        setResearchCenter(next);
+                        const row = selectedResearch(next);
+                        if (row)
+                            void researchFacade().read(row.id).then(detail => setResearchCenter((current) => current ? setResearchCenterDetail(current, detail) : current)).catch((error) => addLocal(screenErrorText(error, act('screen.action.researchDetail'))));
+                        return;
+                    }
+                    if (key.downArrow) {
+                        const next = moveResearchCenterSelection(researchCenter, 1);
+                        setResearchCenter(next);
+                        const row = selectedResearch(next);
+                        if (row)
+                            void researchFacade().read(row.id).then(detail => setResearchCenter((current) => current ? setResearchCenterDetail(current, detail) : current)).catch((error) => addLocal(screenErrorText(error, act('screen.action.researchDetail'))));
+                        return;
+                    }
+                    const row = selectedResearch(researchCenter);
+                    if (ch === 'u') {
+                        void loadResearchCenter(row?.id);
+                        return;
+                    }
+                    if (!row)
+                        return;
+                    const ownerSessionId = state.sessionId ?? row.id;
+                    if (ch === 'p') {
+                        void researchFacade().pause(ownerSessionId, row.id).then(() => loadResearchCenter(row.id)).catch((error) => addLocal(screenErrorText(error, act('screen.action.researchPause'))));
+                        return;
+                    }
+                    if (ch === 'r') {
+                        void researchFacade().resume(ownerSessionId, row.id).then(() => loadResearchCenter(row.id)).catch((error) => addLocal(screenErrorText(error, act('screen.action.researchResume'))));
+                        return;
+                    }
+                    if (ch === 'c') {
+                        void researchFacade().cancel(ownerSessionId, row.id).then(() => loadResearchCenter(row.id)).catch((error) => addLocal(screenErrorText(error, act('screen.action.researchCancel'))));
+                        return;
+                    }
+                    if (ch === 'e') {
+                        void researchFacade().exportFile(row.id, 'md').then(result => addLocal(t('screen.research.exported', { path: result.path }))).catch((error) => addLocal(screenErrorText(error, act('screen.action.researchExport'))));
+                        return;
+                    }
+                    return;
+                }
+                if (libraryCenter) {
+                    if (key.ctrl && (ch === 'c' || ch === 'C')) {
+                        setLibraryCenter(null);
+                        return;
+                    }
+                    if (key.escape || (ch === 'q' && !key.ctrl && !key.meta)) {
+                        setLibraryCenter(null);
+                        return;
+                    }
+                    if (key.upArrow) {
+                        setLibraryCenter((current) => current ? moveLibraryCenterSelection(current, -1) : current);
+                        return;
+                    }
+                    if (key.downArrow) {
+                        setLibraryCenter((current) => current ? moveLibraryCenterSelection(current, 1) : current);
+                        return;
+                    }
+                    if (ch === 'r') {
+                        const row = selectedLibraryEntry(libraryCenter);
+                        void loadLibraryCenter(row?.id);
+                        return;
+                    }
+                    if (ch === 'p') {
+                        const row = selectedLibraryEntry(libraryCenter);
+                        if (!row)
+                            return;
+                        void libraryFacade().preview(row.id).then(preview => setLibraryCenter((current) => current ? setLibraryCenterPreview(current, preview) : current)).catch((error) => addLocal(screenErrorText(error, act('screen.action.libraryPreview'))));
+                        return;
+                    }
+                    if (ch === 'u') {
+                        const row = selectedLibraryEntry(libraryCenter);
+                        if (!row)
+                            return;
+                        void libraryFacade().duplicates(row.id).then(scan => setLibraryCenter((current) => current ? setLibraryCenterDuplicateScan(current, scan) : current)).catch((error) => addLocal(screenErrorText(error, act('screen.action.libraryDuplicates'))));
+                        return;
+                    }
+                    if (ch === 'a') {
+                        const row = selectedLibraryEntry(libraryCenter);
+                        if (!row)
+                            return;
+                        void libraryFacade().prepareContextReference(row.id).then(reference => { setEditorText(attachLibraryContextToken(currentEditor().text, reference.token)); setLibraryCenter(null); }).catch((error) => addLocal(screenErrorText(error, act('screen.action.libraryAttach'))));
+                        return;
+                    }
+                    if (ch === 'd') {
+                        const row = selectedLibraryEntry(libraryCenter), token = row?.context.token;
+                        if (!token)
+                            return;
+                        setEditorText(detachLibraryContextToken(currentEditor().text, token));
+                        setLibraryCenter(null);
+                        return;
+                    }
+                    return;
+                }
+                if (tasksCenter) {
+                    if (key.ctrl && (ch === 'c' || ch === 'C')) {
+                        setTasksCenter(null);
+                        return;
+                    }
+                    if (key.escape || (ch === 'q' && !key.ctrl && !key.meta)) {
+                        setTasksCenter(null);
+                        return;
+                    }
+                    if (key.upArrow) {
+                        setTasksCenter((current) => current ? moveTasksCenterSelection(current, -1) : current);
+                        return;
+                    }
+                    if (key.downArrow) {
+                        setTasksCenter((current) => current ? moveTasksCenterSelection(current, 1) : current);
+                        return;
+                    }
+                    if (ch === 'r') {
+                        const row = selectedTask(tasksCenter);
+                        void loadTasksCenter(row?.id);
+                        return;
+                    }
+                    return;
+                }
+                if (notesCenter) {
+                    if (key.ctrl && (ch === 'c' || ch === 'C')) {
+                        if (state.running)
+                            cancelActiveRun();
+                        else
+                            setNotesCenter(null);
+                        return;
+                    }
+                    if (key.escape || (ch === 'q' && !key.ctrl && !key.meta)) {
+                        setNotesCenter(null);
+                        return;
+                    }
+                    if (key.upArrow) {
+                        setNotesCenter((current) => current ? moveNotesCenterSelection(current, -1) : current);
+                        return;
+                    }
+                    if (key.downArrow) {
+                        setNotesCenter((current) => current ? moveNotesCenterSelection(current, 1) : current);
+                        return;
+                    }
+                    if (ch === 'r') {
+                        const row = selectedNote(notesCenter);
+                        void loadNotesCenter(row?.id);
+                        return;
+                    }
+                    if (ch === 'c') {
+                        const row = selectedNote(notesCenter);
+                        if (!row)
+                            return;
+                        void notesFacade().composerReference(row.id).then((reference) => { const existing = currentEditor().text; setEditorText(existing.trim() ? existing + '\n\n' + reference : reference); setNotesCenter(null); }).catch((error) => addLocal(screenErrorText(error, act('screen.action.noteAttach'))));
+                        return;
+                    }
+                    return;
+                }
+                if (memoryCenter) {
+                    if (key.ctrl && (ch === 'c' || ch === 'C')) {
+                        if (state.running)
+                            cancelActiveRun();
+                        else
+                            setMemoryCenter(null);
+                        return;
+                    }
+                    if (key.escape || (ch === 'q' && !key.ctrl && !key.meta)) {
+                        setMemoryCenter(null);
+                        return;
+                    }
+                    if (key.upArrow) {
+                        setMemoryCenter((current) => current ? moveMemoryCenterSelection(current, -1) : current);
+                        return;
+                    }
+                    if (key.downArrow) {
+                        setMemoryCenter((current) => current ? moveMemoryCenterSelection(current, 1) : current);
+                        return;
+                    }
+                    if (ch === 'r') {
+                        const row = selectedMemory(memoryCenter);
+                        void loadMemoryCenter(undefined, row?.id);
+                        return;
+                    }
+                    return;
+                }
+                if (pluginCenter) {
+                    if (key.ctrl && (ch === 'c' || ch === 'C')) {
+                        if (state.running)
+                            cancelActiveRun();
+                        else
+                            setPluginCenter(null);
+                        return;
+                    }
+                    if (key.escape) {
+                        setPluginCenter(null);
+                        return;
+                    }
+                    if (key.upArrow) {
+                        setPluginCenter((current) => current ? movePluginCenterSelection(current, -1) : current);
+                        return;
+                    }
+                    if (key.downArrow) {
+                        setPluginCenter((current) => current ? movePluginCenterSelection(current, 1) : current);
+                        return;
+                    }
+                    if (ch === 't') {
+                        void actOnPluginCenter('trust');
+                        return;
+                    }
+                    if (ch === 'u') {
+                        void actOnPluginCenter('untrust');
+                        return;
+                    }
+                    if (ch === 'q') {
+                        void actOnPluginCenter('toggle-quarantine');
+                        return;
+                    }
+                    if (ch === 'r') {
+                        const row = selectedPlugin(pluginCenter);
+                        void loadPluginCenter(row?.id);
+                        return;
+                    }
+                    return;
+                }
+                if (hookCenter) {
+                    if (key.ctrl && (ch === 'c' || ch === 'C')) {
+                        if (state.running)
+                            cancelActiveRun();
+                        else
+                            setHookCenter(null);
+                        return;
+                    }
+                    if (key.escape) {
+                        setHookCenter(null);
+                        return;
+                    }
+                    if (key.upArrow) {
+                        setHookCenter((current) => current ? moveHookCenterSelection(current, -1) : current);
+                        return;
+                    }
+                    if (key.downArrow) {
+                        setHookCenter((current) => current ? moveHookCenterSelection(current, 1) : current);
+                        return;
+                    }
+                    if (ch === 'd') {
+                        void actOnHookCenter('dry-run');
+                        return;
+                    }
+                    if (ch === 't') {
+                        void actOnHookCenter('trust');
+                        return;
+                    }
+                    if (ch === 'u') {
+                        void actOnHookCenter('untrust');
+                        return;
+                    }
+                    if (ch === 'q') {
+                        void actOnHookCenter('toggle-quarantine');
+                        return;
+                    }
+                    if (ch === 'r') {
+                        const row = selectedHook(hookCenter);
+                        void loadHookCenter(row?.id);
+                        return;
+                    }
+                    return;
+                }
+                if (mcpCenter) {
+                    if (key.ctrl && (ch === 'c' || ch === 'C')) {
+                        if (state.running)
+                            cancelActiveRun();
+                        else
+                            setMcpCenter(null);
+                        return;
+                    }
+                    if (key.escape || (ch === 'q' && !key.ctrl && !key.meta)) {
+                        setMcpCenter(null);
+                        return;
+                    }
+                    if (key.upArrow) {
+                        setMcpCenter((current) => current ? moveMcpCenterSelection(current, -1) : current);
+                        return;
+                    }
+                    if (key.downArrow) {
+                        setMcpCenter((current) => current ? moveMcpCenterSelection(current, 1) : current);
+                        return;
+                    }
+                    if (key.return || ch === 'p') {
+                        void actOnMcpCenter('probe');
+                        return;
+                    }
+                    if (ch === 't') {
+                        void actOnMcpCenter('trust');
+                        return;
+                    }
+                    if (ch === 'u') {
+                        void actOnMcpCenter('untrust');
+                        return;
+                    }
+                    if (ch === 'r') {
+                        const row = selectedMcpServer(mcpCenter);
+                        void loadMcpCenter(row?.id);
+                        return;
+                    }
+                    return;
+                }
+                if (historyPicker) {
+                    const shown = filterHistory(history, historyPicker.query);
+                    if (key.escape || (key.ctrl && (ch === 'c' || ch === 'C'))) {
+                        setHistoryPicker(null);
+                        return;
+                    }
+                    if (key.return) {
+                        const chosen = shown[Math.min(historyPicker.selected, shown.length - 1)];
+                        setHistoryPicker(null);
+                        if (chosen)
+                            restoreDraft(chosen);
+                        return;
+                    }
+                    if (key.upArrow) {
+                        setHistoryPicker({ ...historyPicker, selected: Math.max(0, historyPicker.selected - 1) });
+                        return;
+                    }
+                    if (key.downArrow) {
+                        setHistoryPicker({ ...historyPicker, selected: Math.min(Math.max(0, shown.length - 1), historyPicker.selected + 1) });
+                        return;
+                    }
+                    if (key.backspace || key.delete) {
+                        setHistoryPicker({ query: historyPicker.query.slice(0, previousGraphemeBoundary(historyPicker.query, historyPicker.query.length)), selected: 0 });
+                        return;
+                    }
+                    if (ch && !key.ctrl && !key.meta && !/[\x00-\x1f\x7f]/u.test(ch)) {
+                        setHistoryPicker({ query: historyPicker.query + ch, selected: 0 });
+                        return;
+                    }
+                    return;
+                }
+                if (undoPicker) {
+                    if (key.ctrl && (ch === 'c' || ch === 'C')) {
+                        setUndoPicker(null);
+                        return;
+                    }
+                    if (undoPicker.confirm === null) {
+                        if (key.escape) {
+                            setUndoPicker(null);
+                            return;
+                        }
+                        if (key.upArrow) {
+                            setUndoPicker({ ...undoPicker, selected: Math.max(0, undoPicker.selected - 1) });
+                            return;
+                        }
+                        if (key.downArrow) {
+                            setUndoPicker({ ...undoPicker, selected: Math.min(undoPicker.rows.length - 1, undoPicker.selected + 1) });
+                            return;
+                        }
+                        if (key.return) {
+                            setUndoPicker({ ...undoPicker, confirm: 0 });
+                            return;
+                        }
+                        return;
+                    }
+                    if (key.escape) {
+                        setUndoPicker({ ...undoPicker, confirm: null });
+                        return;
+                    }
+                    if (key.upArrow || key.leftArrow) {
+                        setUndoPicker({ ...undoPicker, confirm: 0 });
+                        return;
+                    }
+                    if (key.downArrow || key.rightArrow) {
+                        setUndoPicker({ ...undoPicker, confirm: 1 });
+                        return;
+                    }
+                    if (key.return) {
+                        const picked = undoPicker;
+                        setUndoPicker(null);
+                        if (picked.confirm === 1)
+                            void runUndo(picked);
+                        return;
+                    }
+                    return;
+                }
+                if (themePicker) {
+                    const move = (selected) => { const next = Math.max(0, Math.min(THEME_CHOICES.length - 1, selected)); setThemePicker({ ...themePicker, selected: next }); themeStore.set(THEME_CHOICES[next]); };
+                    if (key.escape || (key.ctrl && (ch === 'c' || ch === 'C'))) {
+                        themeStore.set(themePicker.original);
+                        setThemePicker(null);
+                        return;
+                    }
+                    if (key.return) {
+                        setThemePicker(null);
+                        keepTheme(THEME_CHOICES[themePicker.selected]);
+                        return;
+                    }
+                    if (key.upArrow) {
+                        move(themePicker.selected - 1);
+                        return;
+                    }
+                    if (key.downArrow) {
+                        move(themePicker.selected + 1);
+                        return;
+                    }
+                    if (key.home) {
+                        move(0);
+                        return;
+                    }
+                    if (key.end) {
+                        move(THEME_CHOICES.length - 1);
+                        return;
+                    }
+                    return;
+                }
+                if (contextInspector) {
+                    if (key.ctrl && (ch === 'c' || ch === 'C')) {
+                        applyInterrupt(interruptRef.current.ctrlC(state.running), 'ctrl-c');
+                        return;
+                    }
+                    if (key.escape || key.return || (ch === 'q' && !key.ctrl && !key.meta)) {
+                        setContextInspector(null);
+                        return;
+                    }
+                    return;
+                }
+                if (agentTreeOverlay) {
+                    if (key.ctrl && (ch === 'c' || ch === 'C')) {
+                        if (state.running)
+                            cancelActiveRun();
+                        else
+                            setAgentTreeOverlay(null);
+                        return;
+                    }
+                    if (key.escape || (ch === 'q' && !key.ctrl && !key.meta)) {
+                        setAgentTreeOverlay(null);
+                        return;
+                    }
+                    /* P13: Enter watches the selected agent live; on the session in use it goes back to it. */
+                    if (key.return) {
+                        const row = selectedAgentRow(agentTreeOverlay);
+                        setAgentTreeOverlay(null);
+                        if (!row || row.id === agentView?.sessionId)
+                            return;
+                        if (row.id === controller.current())
+                            closeAgentView();
+                        else
+                            openAgentView(row);
+                        return;
+                    }
+                    if (key.upArrow) {
+                        setAgentTreeOverlay((current) => current ? moveAgentTreeSelection(current, -1) : current);
+                        return;
+                    }
+                    if (key.downArrow) {
+                        setAgentTreeOverlay((current) => current ? moveAgentTreeSelection(current, 1) : current);
+                        return;
+                    }
+                    if (key.pageUp || key.pageup) {
+                        setAgentTreeOverlay((current) => current ? moveAgentTreeSelection(current, -5) : current);
+                        return;
+                    }
+                    if (key.pageDown || key.pagedown) {
+                        setAgentTreeOverlay((current) => current ? moveAgentTreeSelection(current, 5) : current);
+                        return;
+                    }
+                    if (key.home) {
+                        setAgentTreeOverlay((current) => current ? { ...current, selected: 0 } : current);
+                        return;
+                    }
+                    if (key.end) {
+                        setAgentTreeOverlay((current) => current ? { ...current, selected: Math.max(0, current.rows.length - 1) } : current);
+                        return;
+                    }
+                    return;
+                }
+                if (queueEditor) {
+                    const entries = controller.queueEntries(), selected = queueEditorSelected(entries, queueEditor.selected);
+                    if (queueEditor.editing) {
+                        if (key.escape) {
+                            setQueueEditor({ ...queueEditor, editing: false, draft: '' });
+                            return;
+                        }
+                        if (key.return) {
+                            if (selected)
+                                void controller.editQueue(selected.id, queueEditor.draft).then(() => setQueueEditor((current) => current ? { ...current, editing: false, draft: '' } : current)).catch((error) => addLocal(screenErrorText(error, act('screen.action.queueEdit'))));
+                            return;
+                        }
+                        if (key.backspace) {
+                            setQueueEditor({ ...queueEditor, draft: queueEditor.draft.slice(0, previousGraphemeBoundary(queueEditor.draft, queueEditor.draft.length)) });
+                            return;
+                        }
+                        if (ch && !key.ctrl && !key.meta) {
+                            setQueueEditor({ ...queueEditor, draft: queueEditor.draft + ch });
+                            return;
+                        }
+                    }
+                    else {
+                        if (key.escape || (ch === 'q' && !key.ctrl && !key.meta)) {
+                            setQueueEditor(null);
+                            return;
+                        }
+                        if (key.shift && key.upArrow && selected) {
+                            void controller.moveQueue(selected.id, -1).then(() => setQueueEditor((current) => current ? { ...current, selected: Math.max(0, current.selected - 1) } : current)).catch((error) => addLocal(screenErrorText(error, act('screen.action.queueMove'))));
+                            return;
+                        }
+                        if (key.shift && key.downArrow && selected) {
+                            void controller.moveQueue(selected.id, 1).then(() => setQueueEditor((current) => current ? { ...current, selected: Math.min(Math.max(0, controller.queueEntries().length - 1), current.selected + 1) } : current)).catch((error) => addLocal(screenErrorText(error, act('screen.action.queueMove'))));
+                            return;
+                        }
+                        if (key.upArrow) {
+                            setQueueEditor({ ...queueEditor, selected: Math.max(0, queueEditor.selected - 1) });
+                            return;
+                        }
+                        if (key.downArrow) {
+                            setQueueEditor({ ...queueEditor, selected: Math.min(Math.max(0, entries.length - 1), queueEditor.selected + 1) });
+                            return;
+                        }
+                        if (ch === 'e' && selected) {
+                            setQueueEditor({ ...queueEditor, editing: true, draft: selected.text });
+                            return;
+                        }
+                        if (ch === 'd' && selected) {
+                            void controller.deleteQueue(selected.id).then(() => setQueueEditor((current) => { const count = controller.queueEntries().length; if (!count)
+                                return null; return current ? { ...current, selected: Math.min(current.selected, count - 1) } : current; })).catch((error) => addLocal(screenErrorText(error, act('screen.action.queueDelete'))));
+                            return;
+                        }
+                        if (ch === 'c') {
+                            void controller.clearQueue().then(() => setQueueEditor(null)).catch((error) => addLocal(screenErrorText(error, act('screen.action.queueClear'))));
+                            return;
+                        }
+                        if (ch === 'r') {
+                            if (state.running) {
+                                addLocal(t('screen.queue.resumeBusy'));
+                                return;
+                            }
+                            void controller.dispatchQueue().then(() => { if (!controller.queue().length)
+                                setQueueEditor(null); }).catch((error) => addLocal(screenErrorText(error, act('screen.action.queueResume'))));
+                            return;
+                        }
+                    }
+                }
+                if (transcriptSearch) {
+                    const items = transcriptItemsForCurrentView();
+                    const matches = transcriptSearchMatches(items, transcriptSearch.query, transcriptSearch.mode);
+                    const selected = selectedTranscriptMatch(matches, transcriptSearch.selectedId ?? transcriptSelectedId);
+                    const applySelection = (itemId) => { setTranscriptSelectedId(itemId); setTranscriptSearch((current) => current ? { ...current, selectedId: itemId, notice: null } : current); if (itemId)
+                        jumpTranscriptItem(itemId); };
+                    if (key.escape) {
+                        setTranscriptSearch(null);
+                        return;
+                    }
+                    /* R4 Q-R4-7: Ctrl+C closes the search like any dialog, before any exit is armed. */
+                    if (key.ctrl && (ch === 'c' || ch === 'C')) {
+                        applyInterrupt(interruptRef.current.ctrlC(state.running), 'ctrl-c');
+                        return;
+                    }
+                    if (key.tab) {
+                        const mode = transcriptSearch.mode === 'literal' ? 'fuzzy' : 'literal';
+                        const nextMatches = transcriptSearchMatches(items, transcriptSearch.query, mode);
+                        const itemId = selectedTranscriptMatch(nextMatches, transcriptSearch.selectedId ?? transcriptSelectedId)?.itemId ?? null;
+                        setTranscriptSelectedId(itemId);
+                        setTranscriptSearch({ ...transcriptSearch, mode, selectedId: itemId, notice: null });
+                        if (itemId)
+                            jumpTranscriptItem(itemId);
+                        return;
+                    }
+                    if (key.meta && ch.toLowerCase() === 'r') {
+                        const raw = !transcriptRaw;
+                        setTranscriptRaw(raw);
+                        setTranscriptSearch({ ...transcriptSearch, raw, notice: null });
+                        return;
+                    }
+                    if (key.meta && ch.toLowerCase() === 'c') {
+                        copyTranscriptItem(selected?.itemId ?? null);
+                        return;
+                    }
+                    if (key.upArrow || key.downArrow) {
+                        const itemId = moveTranscriptSearchSelection(matches, selected?.itemId ?? null, key.downArrow ? 1 : -1);
+                        applySelection(itemId);
+                        return;
+                    }
+                    if (key.return) {
+                        if (selected)
+                            jumpTranscriptItem(selected.itemId);
+                        setTranscriptSearch(null);
+                        return;
+                    }
+                    if (key.backspace) {
+                        const query = transcriptSearch.query.slice(0, previousGraphemeBoundary(transcriptSearch.query, transcriptSearch.query.length));
+                        const nextMatches = transcriptSearchMatches(items, query, transcriptSearch.mode), itemId = selectedTranscriptMatch(nextMatches, transcriptSearch.selectedId)?.itemId ?? null;
+                        setTranscriptSelectedId(itemId);
+                        setTranscriptSearch({ ...transcriptSearch, query, selectedId: itemId, notice: null });
+                        if (itemId)
+                            jumpTranscriptItem(itemId);
+                        return;
+                    }
+                    if (ch && !key.ctrl && !key.meta) {
+                        const query = transcriptSearch.query + ch, nextMatches = transcriptSearchMatches(items, query, transcriptSearch.mode), itemId = selectedTranscriptMatch(nextMatches, transcriptSearch.selectedId)?.itemId ?? null;
+                        setTranscriptSelectedId(itemId);
+                        setTranscriptSearch({ ...transcriptSearch, query, selectedId: itemId, notice: null });
+                        if (itemId)
+                            jumpTranscriptItem(itemId);
+                        return;
+                    }
+                    return;
+                }
+                /* P13 (owner decisions 2 and 7): watching an agent is read-only. Esc goes back to the main session and does NOT
+                   interrupt the turn (Claude Code fixed exactly that); Ctrl+C still stops the whole turn; the agent tree, scrolling,
+                   redraw, reasoning and tool details still work; typing does nothing. */
+                if (agentView) {
+                    if (key.escape) {
+                        closeAgentView();
+                        return;
+                    }
+                    const viewAction = resolveKeybinding(ch, key, ['global', 'transcript', 'composer'], effectiveKeymap);
+                    if (viewAction && AGENT_VIEW_ACTIONS.has(viewAction)) {
+                        handleSemanticAction(viewAction, key);
+                        return;
+                    }
+                    return;
+                }
+                const vimOwnsInput = boot.phase === 'ready' && !trustCenter && !mcpCenter && !hookCenter && !pluginCenter && !memoryCenter && !notesCenter && !tasksCenter && !libraryCenter && !researchCenter && !automationCenter && !forgeCenter && focusNow === 'composer' && vim.enabled && (vim.mode === 'normal' || Boolean(key.escape));
+                if (vimOwnsInput) {
+                    const vimResult = handleVimInput({ state: vim, editor: currentEditor(), ch, key });
+                    if (vimResult.handled) {
+                        setVim(vimResult.state);
+                        if (vimResult.editor !== currentEditor())
+                            updateEditor(() => vimResult.editor);
+                        setAuxCompletions([]);
+                        return;
+                    }
+                }
+                const decision = decideShellInput({
+                    ch, key, focus: focusNow, composerText: currentEditor().text, commandMenuOpen: focusNow === 'command-menu',
+                    trustCenterOpen: Boolean(trustCenter), approvalExpanded, boot, keymap: effectiveKeymap,
+                });
+                if (decision.closeTrustCenter) {
+                    setTrustCenter(null);
+                    return;
+                }
+                if (decision.approvalScrollDelta !== null) {
+                    const delta = decision.approvalScrollDelta;
+                    setApprovalScroll((value) => Math.max(0, Math.min(approvalMaxOffsetRef.current, value + delta)));
+                    return;
+                }
+                if (decision.skipBoot)
+                    setBoot((current) => skipBoot(current));
+                const routed = decision.routed;
+                if (!routed)
+                    return;
+                if (routed.kind === 'action') {
+                    handleSemanticAction(routed.action, key);
+                    return;
+                }
+                if (routed.kind === 'text') {
+                    if (focusNow === 'provider-picker' && providerStep.kind === 'key') {
+                        if (!providerStep.testing) {
+                            if (providerStep.result)
+                                setProviderStep({ ...providerStep, result: null });
+                            setProviderSecret((value) => value + routed.text);
+                        }
+                        return;
+                    }
+                    if (focusNow === 'provider-picker' && providerStep.kind === 'login-choice')
+                        return;
+                    if (focusNow === 'provider-picker' && providerStep.kind === 'oauth') {
+                        if (providerStep.phase === 'waiting') {
+                            if (routed.text.trim().toLowerCase() === 'c')
+                                setProviderStep({ ...providerStep, phase: 'paste', message: null });
+                            return;
+                        }
+                        if (providerStep.phase === 'paste') {
+                            setProviderSecret((value) => value + routed.text);
+                            return;
+                        }
+                        return;
+                    }
+                    if (focusNow === 'provider-picker' && providerStep.kind === 'consent') {
+                        const letter = routed.text.trim().toLowerCase();
+                        if (letter === 'y' || letter === 'n')
+                            setProviderStep({ ...providerStep, choice: letter === 'y' ? 'yes' : 'no' });
+                        return;
+                    }
+                    if (focusNow === 'model-picker' && modelEffortStep)
+                        return;
+                    if (focusNow === 'model-picker' && setupRef.current && modelList.engineDown && !pickerQuery && (routed.text === 'r' || routed.text === 'R') && appState.overlay?.kind === 'model') {
+                        void loadModels(appState.overlay.provider);
+                        return;
+                    }
+                    if (focusNow === 'model-picker' || focusNow === 'provider-picker' || focusNow === 'session-picker') {
+                        setPickerQuery((value) => value + routed.text);
+                        setPickerSelection((current) => ({ ...current, selected: 0 }));
+                        return;
+                    }
+                    if (focusNow === 'command-menu') {
+                        updateEditor(editor => editInsert(editor, routed.text));
+                        commandMenuSelectionStore.reset();
+                        setPickerSelection((current) => ({ ...current, selected: 0 }));
+                        return;
+                    }
+                    setAuxCompletions([]);
+                    updateEditor(editor => routed.text.length > 1 || routed.text.includes('\n') ? insertPaste(editor, routed.text) : editInsert(editor, routed.text));
+                }
+            });
+        };
+        const terminalRows = terminalSize?.rows ?? Number(stdout?.rows ?? process.stdout.rows ?? 30), terminalColumns = terminalSize?.columns ?? Number(stdout?.columns ?? process.stdout.columns ?? 100);
+        /* R5a S1 (gate finding 1): the turn's usage AND the context status go to lane R's snapshot; neither hides the other. */
+        const facts = React.useMemo(() => usageFacts({ model: state.status.model, usage: state.usage, contextStatus, compactions: state.compactions }), [state.status.model, state.usage, contextStatus, state.compactions]);
+        /* R5a (owner 2026-09-24): a window below 64k keeps the simple mode; said once per model. */
+        const smallWindowSaidRef = React.useRef(null);
+        React.useEffect(() => { const text = smallWindowNotice(facts.profile, state.status.model); if (text && smallWindowSaidRef.current !== state.status.model) {
+            smallWindowSaidRef.current = state.status.model;
+            addLocal(text);
+        } }, [facts.profile, state.status.model]);
+        /* R3 Q-R3-13 (R0 decisions 1 and 4): `Full access` and `No sandbox` lead the status row and no width drops them. */
+        const layout = deriveShellLayout({
+            state, appState, viewport, terminalRows, terminalColumns, projectRoot, queuedActions, busySince, bullet: theme.glyphs.bullet, branch: theme.glyphs.branch,
+            snapshot: facts.snapshot, safety: { fullAccess: state.status.permissionMode === 'bypassPermissions', noSandbox: sandboxVerified === false }, busyInput: prefs.busyInput, exitHint,
+        });
+        const { columns, activity, shortcutLine, rosterLine, queueLine, footerLine, statusBar: statusRow } = layout;
+        /* R3 Q-R3-9: no `Run · …` rows; R5a S8: a collapsed reasoning block is drawn once it has ended (thinking-row.ts). */
+        /* P13: the watched agent's transcript takes the main view; the main session's is kept as it was. */
+        const shownTranscriptItems = (agentView ? agentView.transcript.items : state.transcript.items);
+        /* In an agent's transcript its prompt is the task the main session gave it, not the person's words, and the answers are
+           the agent's: "You" and "TALOS" would say otherwise. */
+        const watchingAgent = Boolean(agentView);
+        const visibleTranscriptItems = React.useMemo(() => visibleItemsOf(shownTranscriptItems, appState.reasoningVisible), [shownTranscriptItems, appState.reasoningVisible]);
+        const renderTranscriptItem = React.useCallback((item) => {
+            const selected = item.id === transcriptSelectedId, prefix = selected ? '› ' : '';
+            if (transcriptRaw)
+                return h(Ink.Text, { key: item.id, inverse: selected, dimColor: !selected }, prefix + transcriptItemRaw(item));
+            if (item.kind === 'message')
+                return h(Ink.Box, { key: item.id, flexDirection: 'column' }, h(Ink.Text, { bold: item.role === 'user', color: transcriptColor, inverse: selected }, prefix + t(item.role === 'user' ? (watchingAgent ? 'screen.agentView.task' : 'screen.transcript.you') : (watchingAgent ? 'screen.agentView.agent' : 'screen.transcript.assistant'))), h(MarkdownView, { text: item.text, width: columns }));
+            if (item.kind === 'reasoning')
+                return appState.reasoningVisible ? h(Ink.Box, { key: item.id, borderStyle: 'single', flexDirection: 'column' }, h(Ink.Text, { dimColor: true, inverse: selected }, prefix + t('screen.transcript.reasoning')), h(Ink.Text, { dimColor: true }, item.text || ' ')) : h(Ink.Text, { key: item.id, dimColor: true, inverse: selected }, prefix + thoughtLine(item));
+            /* The selected row carries a two-cell prefix: its header is drawn two cells narrower so it never wraps (lane RD). */
+            if (item.kind === 'tool') {
+                const rendered = toolRowWithClock(item, selected ? Math.max(1, columns - 2) : columns, appState.expandedTools, toolNow);
+                return h(Ink.Box, { key: item.id, flexDirection: 'column' }, h(Ink.Text, { color: toolColor, inverse: selected }, prefix + rendered.title + ' · ' + rendered.statusLabel), ...rendered.detailLines.map((line, index) => h(Ink.Text, { key: index, dimColor: true }, line)));
+            }
+            if (item.kind === 'warning')
+                return h(Ink.Text, { key: item.id, dimColor: true, inverse: selected }, prefix + item.text);
+            return null;
+        }, [transcriptSelectedId, transcriptRaw, columns, appState.expandedTools, appState.reasoningVisible, toolNow, watchingAgent]);
+        const diffView = diff ? renderDiffModel(parseUnifiedDiff(diff), columns) : null;
+        const vimHint = vimModeHint(vim);
+        React.useEffect(() => {
+            if (!capabilities.motion || boot.phase !== 'ready' || !isAnimatedActivity(activity.kind))
+                return;
+            return coordinator.startMotion(() => setMotionNow(Date.now()));
+        }, [coordinator, capabilities.motion, boot.phase, activity.kind]);
+        /* Lane RD contract: running rows show their elapsed seconds; a clock, not an animation, so it ticks with motion off.
+           R5a S4: the same clock counts a known retry wait down, and stops when the wait is over (nothing ticks for nothing). */
+        React.useEffect(() => {
+            const until = activity.kind === 'tool' ? Infinity : activity.kind === 'retrying' ? retryCountdownEnd(state.retry) : null;
+            if (boot.phase !== 'ready' || until === null)
+                return;
+            setToolNow(Date.now());
+            const timer = setInterval(() => { const now = Date.now(); coordinator.enqueueEvent(`tool-clock-${++eventSequenceRef.current}`, () => setToolNow(now)); if (now >= until)
+                clearInterval(timer); }, 1_000);
+            return () => clearInterval(timer);
+        }, [coordinator, boot.phase, activity.kind, state.retry]);
+        /*
+         * R3 Q-R3-13 (R0 decision 4, owner 2026-09-24): the check starts at STARTUP, in the background, after the first frame,
+         * so neither the first frame nor a key waits for it; the label appears when the verdict arrives (a cached verdict:
+         * at once). Quitting aborts a check still running (main.ts, abortIsolationChecks): it ends what it started and
+         * answers nothing. Asked once.
+         */
+        React.useEffect(() => { const timer = setTimeout(() => askSandboxRef.current(), 0); return () => clearTimeout(timer); }, []);
+        const statusStartedAt = activity.startedAt ?? busySince;
+        const statusElapsed = typeof activity.frozenMs === 'number' ? activity.frozenMs : Math.max(0, motionNow - statusStartedAt);
+        const statusFrame = frameIndex(statusElapsed, MOTION_FRAME_MS, theme.glyphs.spinner.length);
+        const statusText = exitHint ? exitHintText(exitHintKey) : busyIndicatorText({ kind: activity.kind, elapsedMs: statusElapsed, frame: statusFrame, unicode: capabilities.unicode, frames: theme.glyphs.spinner, ...(activity.tool ? { tool: activity.tool } : {}), ...(activity.agents ? { agents: activity.agents } : {}), retry: state.retry, nowMs: Math.max(toolNow, state.retry?.at ?? 0) });
+        /* R3 gate E7: the main roster row says what the CLI knows while a turn is open (the kernel list says `unknown` or `running`),
+           and after the turn done / interrupted / failed like the status row (owner decision, R3 follow-up: one vocabulary). */
+        const turnOpen = state.running || typeof state.sentAt === 'number';
+        const mainRowStatus = turnOpen ? activityWord(activity.kind, activity.tool, activity.agents) : state.lastTurn ? activityWord(state.lastTurn.outcome) : undefined;
+        /*
+         * R1 gate E1: one height budget per frame. The composer's row count comes from its store as a primitive, so the
+         * fast input path still re-renders only the composer on a key and the whole screen only when the composer gains or
+         * loses a row. `frameRowsFor` is the same switch run.ts uses for the root frame (Q-R1-6).
+         */
+        const composerSize = React.useSyncExternalStore(composerStore.subscribe, () => { const measured = composerMeasure(composerStore.getSnapshot(), columns, vimHint); return `${measured.lines}:${measured.hints}`; }, () => '1:0');
+        const [composerLines, composerHints] = composerSize.split(':').map(Number);
+        const reasoningLine = (currentModelMeta?.reasoning === true || reasoningEffort !== null) ? t('screen.reasoning.line', { effort: reasoningEffort ?? t('screen.effort.modelDefault'), usage: reasoningUsageLabel(state.usage) }) : null;
+        const rosterLines = agentRows.length
+            ? agentRows.map((row) => h(Ink.Text, { key: `agent-roster-${row.id}`, color: row.hasCollision ? approvalColor : footerColor, bold: row.hasCollision, wrap: 'truncate-end' }, agentRosterLine({ row, width: columns, nowMs: motionNow, hideModel: row.role === 'main' && row.id === state.sessionId, ...(mainRowStatus && row.role === 'main' && row.id === state.sessionId ? { status: mainRowStatus } : {}) })))
+            : [h(Ink.Text, { key: 'agent-roster-main', color: footerColor, wrap: 'truncate-end' }, rosterLine)];
+        const budgetInput = { rows: terminalRows, columns: terminalColumns, frameRows: frameRowsFor(terminalRows), composerLines, composerHints, header: 1, shortcut: 1, roster: rosterLines.length, extras: (queueLine ? 1 : 0) + (reasoningLine ? 1 : 0), footer: 1, status: layout.showActivity ? 1 : 0 };
+        /* The most rows an overlay, menu or diff may take (contract with lane O: `maxRows`), known before any is built. */
+        const maxRows = layoutBudget(budgetInput).overlayMaxRows;
+        const pickerRowsLimit = Math.max(1, Math.min(12, maxRows - 5));
+        /* The command menu's height follows its query, which the fast input path writes to the stores without a root render:
+           the root reads the fitted height as a primitive, so it re-renders only when the menu gains or loses a row. */
+        const menuOpen = appState.focus.current === 'command-menu';
+        const menuRows = React.useSyncExternalStore(composerStore.subscribe, () => { if (!menuOpen)
+            return 0; const text = composerStore.getSnapshot().text; const fitted = fitOverlay(commandMenuOverlay({ text, selected: commandMenuHighlight(text, commandMenuSelectionStore.getSnapshot()) }), { maxRows, columns }); return fitted.rows.length + (fitted.border ? 2 : 0); }, () => 0);
+        if (terminalColumns < MIN_COLUMNS || terminalRows < MIN_ROWS)
+            return h(Regions.TooSmall, { key: 'too-small', columns: terminalColumns });
+        if (boot.phase !== 'ready' && boot.phase !== 'error')
+            return h(Regions.Region, { key: `boot-${appState.redrawNonce}`, rows: frameRowsFor(terminalRows), paddingTop: 1 }, h(BootSequence, { state: boot, mode: bootPlanRef.current.mode, hint: t('firstrun.boot.skipHint'), logo: shouldRenderBootLogo(capabilities), motion: capabilities.motion, unicode: capabilities.unicode, width: columns, accentColor: bootColor, mutedColor: footerColor, onComplete: () => setBoot((current) => completeBoot(current, Date.now())) }), h(Ink.Text, { dimColor: true, color: footerColor, wrap: 'truncate-end' }, projectRoot));
+        const renderPickerRows = (rowsToRender, selected, label) => { const view = pickerWindow(rowsToRender, selected, pickerRowsLimit); return view.rows.map((row, index) => { const absolute = view.start + index; return h(Ink.Text, { key: `${absolute}-${label(row)}`, inverse: absolute === selected, color: pickerColor }, `${absolute === selected ? '›' : ' '} ${label(row)}`); }); };
+        /*
+         * Q-R1-3 / E3: every overlay gets `maxRows` (contract with lane O) and is fitted by overlays/scroll-window.ts, which
+         * wraps each line itself and returns one Ink row per row: the rows it returns are the rows it draws, so the budget
+         * receives the overlay's exact height and no overlay can push the composer off the screen.
+         */
+        const fittedPanel = (fitted) => ({ element: renderFittedOverlay(h, Ink, fitted, { accentColor: pickerColor }), rows: fitted.rows.length + (fitted.border ? 2 : 0) });
+        const overlayOf = (content) => fittedPanel(fitOverlay(content, { maxRows, columns }));
+        /* P17: in the guided setup, each window says its step; a local engine that is down offers R and Esc (decision 8). */
+        const setupWrap = (content, step) => {
+            if (!setupActive)
+                return content;
+            /* On a local engine that is down, Esc goes back to the providers: the step line does not also say it skips. */
+            if (step === 'model' && modelList.engineDown) {
+                const wrapped = setupOverlay(content, step, { escSkips: false });
+                return { ...wrapped, foot: [...(wrapped.foot ?? []), { text: t('firstrun.setup.retryHint'), tone: 'dim' }] };
+            }
+            /* The key and consent windows say what Esc does in their own line ("Esc cancels"): one wording per window. */
+            return setupOverlay(content, step, { escSkips: step !== 'key' });
+        };
+        let overlayNode = null;
+        if (historyPicker)
+            overlayNode = overlayOf(historyPickerOverlay({ rows: history, picker: historyPicker, width: columns }));
+        else if (undoPicker)
+            overlayNode = overlayOf(undoPickerOverlay(undoPicker));
+        else if (themePicker)
+            overlayNode = overlayOf(themePickerOverlay({ selected: themePicker.selected, current: themePicker.original, colors: live.capabilities.color }));
+        else if (contextInspector)
+            overlayNode = overlayOf(contextInspectorOverlay(contextInspector));
+        else if (agentTreeOverlay)
+            overlayNode = overlayOf(agentTreeOverlayContent(agentTreeOverlay, { width: Math.max(1, columns - 2), nowMs: motionNow, currentSessionId: controller.current(), running: state.running, viewingId: agentView?.sessionId ?? null }));
+        else if (trustCenter)
+            overlayNode = overlayOf(trustCenterOverlay(trustCenter));
+        else if (mcpCenter)
+            overlayNode = overlayOf(mcpCenterOverlay(mcpCenter));
+        else if (hookCenter)
+            overlayNode = overlayOf(hookCenterOverlay(hookCenter));
+        else if (pluginCenter)
+            overlayNode = overlayOf(pluginCenterOverlay(pluginCenter));
+        else if (memoryCenter)
+            overlayNode = overlayOf(memoryCenterOverlay(memoryCenter));
+        else if (notesCenter)
+            overlayNode = overlayOf(notesCenterOverlay(notesCenter));
+        else if (tasksCenter)
+            overlayNode = overlayOf(tasksCenterOverlay(tasksCenter));
+        else if (forgeCenter)
+            overlayNode = overlayOf(forgeCenterOverlay(forgeCenter));
+        else if (automationCenter)
+            overlayNode = overlayOf(automationCenterOverlay(automationCenter));
+        else if (researchCenter)
+            overlayNode = overlayOf(researchCenterOverlay(researchCenter));
+        else if (libraryCenter)
+            overlayNode = overlayOf(libraryCenterOverlay(libraryCenter));
+        else if (queueEditor)
+            overlayNode = overlayOf(queueEditorOverlay({ entries: controller.queueEntries(), selected: queueEditor.selected, paused: controller.queuePaused(), editing: queueEditor.editing, draft: queueEditor.draft }));
+        else if (appState.overlay?.kind === 'help') {
+            const fitted = fitOverlay(helpDialogOverlay(effectiveKeymap, { offset: helpOffset }), { maxRows, columns });
+            helpMaxOffsetRef.current = fitted.sections[0]?.maxOffset ?? 0;
+            helpPageRef.current = Math.max(1, maxRows - 4);
+            overlayNode = fittedPanel(fitted);
+        }
+        else if (appState.overlay?.kind === 'approval' && pending) {
+            const model = approvalDialogModel(pending, { expanded: approvalExpanded, selected: approvalSelected, unsandboxed: sandboxVerified === false });
+            const fit = approvalDialogFit(model, { columns, maxRows, scrollOffset: approvalScroll });
+            approvalMaxOffsetRef.current = fit.maxOffset;
+            overlayNode = { element: renderApprovalDialog(h, Ink, model, { accentColor: approvalColor, columns, maxRows, scrollOffset: Math.min(approvalScroll, fit.maxOffset) }), rows: fit.rows + (fit.border ? 2 : 0) };
+        }
+        else if (transcriptSearch)
+            overlayNode = overlayOf(transcriptSearchOverlay({ items: visibleTranscriptItems, state: { ...transcriptSearch, selectedId: transcriptSelectedId, raw: transcriptRaw }, raw: transcriptRaw }));
+        else if (appState.overlay?.kind === 'model')
+            overlayNode = modelEffortStep
+                ? overlayOf(effortLineOverlay({ name: modelEffortStep.name, choices: effortRows, selected: pickerSelection.selected, current: state.status.model === modelEffortStep.id ? (reasoningEffort ?? 'default') : null, width: Math.max(20, columns - 6), unicode: capabilities.unicode }))
+                : overlayOf(setupWrap(modelPickerOverlay({ label: modelList.label, provider: appState.overlay.provider, loading: modelList.loading, verified: modelList.verified, notice: modelList.notice ?? '', query: pickerQuery, rows: filteredModels, selected: pickerSelection.selected }), 'model'));
+        else if (appState.overlay?.kind === 'provider' && providerStep.kind === 'login-choice')
+            overlayNode = overlayOf(setupWrap(providerLoginChoiceOverlay({ label: providerStep.provider.label, choice: providerStep.choice, notice: providerStep.remediation?.message ?? (providerStep.provider.benched ? t('screen.provider.benchedRetry', { benched: benchedKeyText(providerStep.provider.label, providerStep.provider.benched) }) : null) }), 'key'));
+        else if (appState.overlay?.kind === 'provider' && providerStep.kind === 'oauth')
+            overlayNode = overlayOf(setupWrap(providerOAuthOverlay({ label: providerStep.provider.label, url: providerStep.url, mode: providerStep.mode, opened: providerStep.opened, phase: providerStep.phase, masked: maskedSecret(providerSecret), message: providerStep.message }), 'key'));
+        else if (appState.overlay?.kind === 'provider' && providerStep.kind === 'consent')
+            overlayNode = overlayOf(setupWrap(providerConsentOverlay({ provider: providerStep.provider, choice: providerStep.choice }), 'key'));
+        else if (appState.overlay?.kind === 'provider' && providerStep.kind === 'key') {
+            const label = providerStep.provider.label;
+            /* B1 slice 18: a one-token key test is stated on this step, before Enter sends it; no further question is asked. */
+            const keyTestNotice = typeof catalog?.keyTestNotice === 'function' ? catalog.keyTestNotice(providerStep.provider.id) : null;
+            /* B1 slice 25: a provider whose saved key is benched says so here, with the cause and until when, before another key is typed. */
+            const remediation = providerStep.remediation?.message ?? null;
+            const benched = !remediation && providerStep.provider.benched ? t('screen.provider.benchedRetry', { benched: benchedKeyText(label, providerStep.provider.benched) }) : null;
+            overlayNode = overlayOf(setupWrap(providerKeyOverlay({ label, remediation, benched, masked: maskedSecret(providerSecret), keyTestNotice, testing: providerStep.testing, result: providerStep.result?.message ?? null }), 'key'));
+        }
+        else if (appState.overlay?.kind === 'provider')
+            overlayNode = overlayOf(setupWrap(providerPickerOverlay({ query: pickerQuery, rows: filteredProviders, selected: pickerSelection.selected, chosen: chosenProvider, reachable: id => providerPickerRef.current?.reachable(id) ?? null }), 'provider'));
+        else if (appState.overlay?.kind === 'session')
+            overlayNode = overlayOf(sessionPickerOverlay({ action: appState.overlay.action, query: pickerQuery, rows: filteredSessions, selected: pickerSelection.selected }));
+        const diffPanel = diffView ? overlayOf({ head: [{ text: t('screen.diff.title', { mode: diffView.mode }), tone: 'title' }], sections: [{ lines: diffView.lines.map(line => ({ text: line.text, tone: line.kind === 'file' || line.kind === 'hunk' || line.kind === 'add' || line.kind === 'remove' ? 'strong' : 'dim' })), offset: 0 }] }) : null;
+        const auxLines = auxCompletions.length && !appState.overlay && !queueEditor && !transcriptSearch && !contextInspector && !themePicker && !undoPicker && !historyPicker && !mcpCenter && !hookCenter && !pluginCenter && !memoryCenter && !notesCenter && !tasksCenter && !libraryCenter && !researchCenter && !automationCenter && !forgeCenter ? auxCompletions.map((value) => h(Ink.Text, { key: value, dimColor: true, wrap: 'truncate-end' }, `  ${value}`)) : [];
+        /* R4 Q-R4-8 / E13: the live `@` list in the completions region, fitted to its own cap and to the R1 budget. */
+        const completionPanel = fileCompletion && appState.focus.current === 'composer' && !appState.overlay && !queueEditor && !transcriptSearch && !contextInspector && !themePicker && !undoPicker && !historyPicker && !agentTreeOverlay && !trustCenter && !mcpCenter && !hookCenter && !pluginCenter && !memoryCenter && !notesCenter && !tasksCenter && !libraryCenter && !researchCenter && !automationCenter && !forgeCenter
+            ? fittedPanel(fitOverlay(fileCompletionOverlay(fileCompletion), { maxRows: Math.min(maxRows, FILE_COMPLETION_MAX_ROWS), columns }))
+            : null;
+        const auxNodes = completionPanel ? [completionPanel.element] : auxLines;
+        const b = layoutBudget({ ...budgetInput, overlay: overlayNode?.rows ?? null, menu: menuRows || null, diff: diffPanel?.rows ?? null, aux: completionPanel?.rows ?? (auxLines.length || null) });
+        /* R5a S9 (review D-14): the header names the folder once; `interactive` said nothing, `degraded` still does. */
+        const agentViewTask = agentView ? (agentView.task ?? t('screen.agentView.unnamed')) : '';
+        const headerStatus = agentView ? t(agentView.done ? 'screen.agentView.done' : 'screen.agentView.watching', { task: agentViewTask }) : boot.phase === 'error' ? t('screen.header.degraded') : '';
+        const header = headerLine({ workspace: truncateMiddle(projectRoot, Math.max(1, columns - displayWidth(headerLine({ workspace: '', status: headerStatus })) - 3)), status: headerStatus });
+        /* E1/E2: the root is exactly the frame; every region below is a box of the height the budget gave it, in this order,
+           so the composer, the status row and the chrome sit at the bottom of the screen (D-03) and nothing overwrites
+           anything (D-02). */
+        return h(Ink.Box, { key: `main-${appState.redrawNonce}-${live.id}`, flexDirection: 'column', height: b.frameRows, flexShrink: 0, overflowY: 'hidden' }, h(Regions.Header, { key: 'header', rows: b.header, text: header, color: bootColor }), h(TranscriptView, { key: 'transcript', items: visibleTranscriptItems, scrollRows: viewport.offset, rowBudget: b.transcript, width: columns, raw: transcriptRaw, expandedTools: appState.expandedTools, reasoningVisible: appState.reasoningVisible, now: toolNow, revealId: transcriptRevealId, measurementStore: transcriptMeasurementStore, renderItem: renderTranscriptItem, onPlan: onTranscriptPlan, dimColor: footerColor }), h(Regions.Panels, { key: 'panels', budget: b, diff: diffPanel?.element ?? null, overlay: overlayNode?.element ?? null, aux: auxNodes, menu: menuOpen ? h(CommandMenuView, { composerStore, selectionStore: commandMenuSelectionStore, maxRows: b.menu, columns }) : null }), b.status ? h(Ink.Text, { key: 'status', color: footerColor, dimColor: exitHint, wrap: 'truncate-end' }, statusText) : null, b.composer ? (agentView
+            ? h(Ink.Box, { key: 'composer', borderStyle: 'single', flexDirection: 'column', flexShrink: 0, height: 2 + b.composerContent + b.composerHints, overflowY: 'hidden' }, h(Ink.Text, { dimColor: true, wrap: 'truncate-end' }, t('screen.agentView.readOnly')))
+            : h(ComposerView, { key: 'composer', store: composerStore, vimHint, contentRows: b.composerContent, hintRows: b.composerHints, columns })) : null, h(Regions.StatusBar, { key: 'status-bar', budget: b, shortcutLine: agentView ? truncateDisplay(t('screen.agentView.shortcuts'), Math.max(1, columns)) : shortcutLine, rosterLines, queueLine, reasoningLine, footerLine, statusSegments: statusRow.segments, toneColors: { warn: theme.colors.warning, high: theme.colors.danger, critical: theme.colors.danger }, color: footerColor }));
+    };
+}