@pellux/goodvibes-tui 2.0.21 → 2.1.1

package/src/main.ts

@@ -3,6 +3,7 @@ import { resolveGoodVibesDaemonHome, resolveGoodVibesHome } from '@pellux/goodvi
 import { Compositor } from './renderer/compositor.ts';
 import { type Line } from '@pellux/goodvibes-sdk/platform/types';
 import { UIFactory } from './renderer/ui-factory.ts';
+import { resolveThrobberActivity } from './renderer/throbber.ts';
 import { Orchestrator } from '@pellux/goodvibes-sdk/platform/core';
 import { InputHandler } from './input/handler.ts';
 import { SelectionManager } from '@pellux/goodvibes-terminal-shell';
@@ -17,31 +18,35 @@ import { handleBrokerApprovalChange, buildFixSessionAffordance, buildFixSessionE
 import { CommandRegistry } from './input/command-registry.ts';
 import type { CommandContext } from './input/command-registry.ts';
 import { requestedEffortLevel } from './providers/reasoning-effort-surface.ts';
-import { renderProcessIndicator } from './renderer/process-indicator.ts';
+import { wireWorkTree } from './core/work-tree-wiring.ts';
 import { registerBuiltinCommands } from './input/commands.ts';
 import { ScheduleManager } from '@pellux/goodvibes-sdk/platform/tools';
 import { InputHistory } from './input/input-history.ts';
-import { getTierPromptSupplement, getTierForContextWindow } from '@pellux/goodvibes-sdk/platform/providers';
+import { describeContextWindowSource, getTierPromptSupplement, getTierForContextWindow } from '@pellux/goodvibes-sdk/platform/providers';
 import { GitStatusProvider } from './renderer/git-status.ts';
 import type { GitHeaderInfo } from './renderer/git-status.ts';
 import { createShellLayout } from './renderer/layout-engine.ts';
-import { buildShellFooter, estimateShellFooterHeight, promptCursorOffset } from './renderer/shell-surface.ts';
+import { buildShellFooter, estimateShellFooterHeight, promptCursorOffset, statusCostText } from './renderer/shell-surface.ts';
+import { HEADER_GAP_ROWS, withHeaderGap } from './renderer/header-line.ts';
+import { TranscriptScroll } from './shell/transcript-scroll.ts';
+import { formatStatusReport } from './shell/status-report.ts';
+import { voiceCaptureDescription } from './renderer/voice-capture-chip.ts';
+import { voiceCaptureRowVisible } from './core/voice-capture-status.ts';
+import { resolveWebSurfaceUrl } from '@pellux/goodvibes-sdk/platform/runtime/feature-announcements';
 import { createFailoverTurnState, resolveActiveModelDisplay } from './core/active-model-identity.ts';
 import { computePromptContentWidth } from './renderer/prompt-content-width.ts';
-import { buildConversationViewport } from './renderer/conversation-layout.ts';
-import { applyConversationOverlays } from './renderer/conversation-overlays.ts';
-import { buildPanelCompositeData } from './renderer/panel-composite.ts';
+import { buildConversationViewport, centerViewportContent } from './renderer/conversation-layout.ts';
+import { applyConversationOverlays, buildConversationLayers } from './renderer/conversation-overlays.ts';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
-import { registerBuiltinPanels } from './panels/builtin-panels.ts';
 import { bootstrapRuntime } from './runtime/bootstrap.ts';
 import type { BootstrapContext } from './runtime/bootstrap.ts';
 import { selfUpdateAtLaunch } from './cli/launch-auto-update.ts';
 import { buildSharedOrchestratorCoreServices, refreshMemoryRecallSnapshot } from './runtime/orchestrator-core-services.ts';
 import { createSessionContinuityHintsBuilder } from './runtime/session-continuity-hints.ts';
-import { resolveWebSurfaceUrl } from '@pellux/goodvibes-sdk/platform/runtime/feature-announcements';
 import { readLastSessionPointer } from '@/runtime/index.ts';
 import { startRecoveryAutosave } from './runtime/recovery-autosave.ts';
-import { scheduleRecoveryOffer } from './runtime/recovery-prompt.ts';
+import { startRecoveryOffer } from './runtime/recovery-prompt.ts';
+import { createStartupTypeaheadGate } from './runtime/startup-typeahead-gate.ts';
 import { buildRecoveryOfferWiring } from './runtime/recovery-offer-wiring.ts';
 import { handleBlockingShellInput, type PendingPermissionState } from './shell/blocking-input.ts';
 import { handleErrorAffordanceKey } from './shell/recovery-input-helpers.ts';
@@ -53,21 +58,21 @@ import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { prepareShellCliRuntime } from './cli/entrypoint.ts';
 import { applyInitialTuiCliState, reportFatalStartupError } from './cli/tui-startup.ts';
 import { applyConfiguredHitlMode, applyRuntimeConfigValue, applyTerminalRuntimeConfigDefaults } from '@pellux/goodvibes-terminal-shell';
-import { renderToolCallBlock } from './renderer/tool-call.ts';
 import { installVoiceCapture } from './shell/voice-capture-shell.ts';
 import { allowTerminalWrite, installFullScreenTerminalOutputGuard } from '@pellux/goodvibes-terminal-shell/terminal-output-guard';
 import { installProcessLifecycle } from './runtime/process-lifecycle.ts';
 import { createRenderScheduler } from '@pellux/goodvibes-terminal-shell';
 import { buildCommandArgsHint } from './input/command-args-hint.ts';
 import { summarizeRunningAgents } from './renderer/process-summary.ts';
-import { footerFleetCost } from './panels/fleet-read-model.ts';
+import { footerFleetCost } from './views/fleet-read-model.ts';
+import { footerTargetRows } from './renderer/footer-targets.ts';
 import { formatUserFacingErrorLine } from './core/format-user-error.ts';
 import { wireStreamEventMetrics, createStreamMetrics, type StreamMetrics, type WireStreamEventMetricsResult } from './core/stream-event-wiring.ts';
 import { wireTurnEventHandlers } from './core/turn-event-wiring.ts';
 import { resolveContextStatusHint } from './renderer/context-status-hint.ts';
 import { isEffectiveDangerMode } from '@pellux/goodvibes-sdk/platform/config';
 import { applyComposerCapture, applyAtModelDirective } from './input/composer-capture.ts';
-import { makeComposerEditorOpener } from './input/composer-editor.ts';
+import { makeComposerEditorOpener, makeFileEditorOpener } from './input/composer-editor.ts';
 import { evaluateSessionMaintenance } from '@/runtime/index.ts';
 import { createCancelGeneration } from './core/turn-cancellation.ts';
 import { wireInteractionSeams, createMemoryProvenanceUi } from './runtime/interaction-seams.ts';
@@ -75,14 +80,15 @@ import { createPowerChipSource } from './core/power-chip-source.ts';
 import { fetchDaemonPowerState, installKeepAwakeRemoteForward } from './runtime/power-keepawake-remote.ts';
 import { wrapRequestPermissionWithAlert } from './core/approval-alert.ts';
 import { createTerminalNotifier } from './core/terminal-notifier.ts';
-import { setPanelFrameRequester } from './panels/base-panel.ts';
 import { createDeferredRender } from './renderer/deferred-render.ts';
 import { wireSessionAmbience } from './runtime/session-ambience-wiring.ts';
 import { createSpokenTurnInputOptions } from './audio/spoken-turn-model-routing.ts';
 
 import { ALT_SCREEN_ENTER, ALT_SCREEN_EXIT, MOUSE_ENABLE, MOUSE_DISABLE, CURSOR_HIDE, CURSOR_SHOW, CLEAR_SCREEN, KEYBOARD_EXT_ENABLE, KEYBOARD_EXT_DISABLE, PASTE_ENABLE, PASTE_DISABLE, FOCUS_ENABLE, FOCUS_DISABLE } from './renderer/terminal-escapes.ts';
 import { installBackgroundThemeProbe } from './renderer/terminal-bg-probe.ts';
+import { registerThemeRefresh } from './renderer/theme.ts';
 import { VERSION } from './version.ts';
+import { SessionViews } from './shell/session-views.ts';
 
 async function main() {
   const stdout = process.stdout;
@@ -158,12 +164,12 @@ async function main() {
   // that should compete with real session alerts for attention).
   for (const line of launchUpdateLines) systemMessageRouter.low(`[Update] ${line}`);
 
-  const panelManager = ctx.services.panelManager;
-  const buildSessionContinuityHints = createSessionContinuityHintsBuilder({ readModels: uiServices.readModels, panelManager });
+  const buildSessionContinuityHints = createSessionContinuityHintsBuilder({ readModels: uiServices.readModels });
 
   // Callable before the scheduler exists; see deferred-render.ts for why.
   const deferredRender = createDeferredRender();
   const render = deferredRender.render;
+  const typeahead = createStartupTypeaheadGate(); // keys typed before a startup modal appeared never answer it
 
   let pendingPermission: PendingPermissionState | null = null;
   // One-key jump/attach to a spawned CI fix-session: the affordance ARMS the id; the next 'j' runs the resume so the user never retypes it.
@@ -183,12 +189,12 @@ async function main() {
   }));
   refreshFixSessionsFromApprovals(() => approvalBroker.listApprovals(), onFixSessionStarted, onFixSessionError); // catch pre-subscription stamps
 
-  let scrollTop = 0;
-  let scrollLocked = true;
-  // Cached from the overlay-aware clamp the renderer computes (conversation-layout) each frame so scroll() clamps against exactly what is displayed, not a footer estimate.
-  let lastMaxScroll: number | null = null;
+  // Where the main transcript is scrolled to; each frame's overlay-aware clamp (conversation-layout) is fed back so a scroll clamps against exactly what is displayed (shell/transcript-scroll.ts).
+  const transcript = new TranscriptScroll();
   // Stream and tool-timer state; mutated by wireStreamEventMetrics handlers, read during render.
   const streamMetrics: StreamMetrics = createStreamMetrics();
+  // When the running compaction was first seen (the throbber's elapsed time); undefined while none runs.
+  let compactingSinceMs: number | undefined;
   // Live failover record, written by the failover path, read every frame so the header and footer agree.
   const failoverState = createFailoverTurnState();
 
@@ -196,33 +202,37 @@ async function main() {
   // Live-microphone footer row (push-to-talk or the wake detector); assigned once voice capture is wired below, null until then so pre-wiring frames size correctly.
   let voiceCaptureStatus: () => import('./core/voice-capture-status.ts').VoiceCaptureIndicatorState | null = () => null;
 
+  // Agents and background processes opened full screen (shell/session-views.ts); set once the input handler exists.
+  let sessionViews: SessionViews | null = null;
+  let lastHeaderModel = runtime.model;
   const getViewportHeight = (): number => {
     if (input.onboardingWizard.active) return stdout.rows || 24;
     const promptLines: number = input.getVisiblePromptLineCount(getPromptContentWidth());
     const currentModel = providerRegistry.getCurrentModel();
     const contextWindow = providerRegistry.getContextWindowForModel(currentModel);
     const rows = stdout.rows || 24;
-    // Compact threshold must match buildShellFooter's `compact: height < 30` posture below, else estimateShellFooterHeight's cached-height fast path answers with the wrong mode.
-    return rows - 2 - estimateShellFooterHeight(promptLines, contextWindow, rows < 30, voiceCaptureStatus());
+    // The header row (+ the session chips), and on the main screen the empty row under them (a view's body brings its own).
+    return rows - (sessionViews?.headerRows() ?? 1) - (sessionViews?.active ? 0 : HEADER_GAP_ROWS) - estimateShellFooterHeight(promptLines);
   };
 
   const scroll = (delta: number) => {
-    // Prefer the last clamp the renderer computed (overlay- and real-footer-aware).
-    // The footer estimate is only a fallback for the pre-first-render frame.
-    const maxScroll = lastMaxScroll ?? Math.max(0, conversation.history.getLineCount() - getViewportHeight());
-    scrollTop = Math.max(0, Math.min(scrollTop + delta, maxScroll));
-    // Re-lock if user scrolled to bottom, otherwise unlock
-    scrollLocked = scrollTop >= maxScroll;
+    if (sessionViews?.active) { sessionViews.scroll(-delta); return; } // a view scrolls its own lines (up is positive there)
+    // The footer estimate is only a fallback for the pre-first-render frame; reaching the bottom re-locks.
+    transcript.scrollBy(delta, () => Math.max(0, conversation.history.getLineCount() - getViewportHeight()));
   };
 
-  const scrollToEnd = (vHeight: number) => {
-    // Respect a manual scroll-up by the user: only auto-follow the tail when parked at the
-    // bottom (scrollLocked). submitInput re-locks on new input so turns resume following.
-    if (!scrollLocked) return;
-    scrollTop = Math.max(0, conversation.history.getLineCount() - vHeight);
+  // Back to the live bottom: re-lock, and the next frame follows the tail again.
+  const scrollToLiveBottom = () => {
+    transcript.toBottom();
+    render();
   };
 
+  // Respect a manual scroll-up: only follow the tail while parked at the bottom (submitInput re-locks on new input).
+  const scrollToEnd = (vHeight: number) => transcript.followTail(conversation.history.getLineCount(), vHeight);
+
   const unsubs: Array<() => void> = [];
+  // The work tree's live facts: call/turn timings, agent lanes, the call a permission prompt holds, fold persistence (work-tree-wiring.ts).
+  unsubs.push(...wireWorkTree({ conversation, events: uiServices.events, agentManager, listChains: () => ctx.services.wrfcController.listChains(), fleetNodes: () => ctx.services.processRegistry.query().nodes, pendingCallId: () => pendingPermission?.callId, turnActive: () => orchestrator.isThinking, sessionsDir: ctx.services.surface.sessionsDir, sessionId: () => runtime.sessionId, requestRender: () => render() }).unsubs);
   let recoveryInterval: ReturnType<typeof setInterval> | null = null;
   let stopSpokenOutputForExit: (() => Promise<void>) | null = null;
   // The optional "used N memories" provenance chip (default OFF), see interaction-seams.ts.
@@ -273,7 +283,7 @@ async function main() {
   unsubs.push(...ambience.unsubs);
   const submitInput = (text: string, content?: ContentPart[], options: { readonly spokenOutput?: boolean } = {}) => {
     input.clearModalStack();
-    scrollLocked = true; // Re-lock on any user input
+    transcript.toBottom(); // Re-lock on any user input
     conversation.dismissSplash(); // owner rule: any submission retires the splash for the run
     let processedText = applyAtModelDirective(text, {
       providerRegistry, runtime, configManager, notify: (m) => systemMessageRouter.high(m),
@@ -311,16 +321,14 @@ async function main() {
       render();
       return;
     }
-    scrollLocked = false;
-    scrollTop = Math.max(0, line);
+    transcript.jumpTo(line);
     render();
   };
 
   const scrollToLine = (line: number) => {
     conversation.getDisplayBlocks();
     const maxScroll = Math.max(0, conversation.history.getLineCount() - getViewportHeight());
-    scrollLocked = false;
-    scrollTop = Math.max(0, Math.min(line, maxScroll));
+    transcript.jumpTo(line, maxScroll);
     render();
   };
 
@@ -352,12 +360,12 @@ async function main() {
         ...buildPendingPermissionExtras(request, resolve, approvalBroker),
       };
       render();
-    }), { focusTracker: ctx.services.focusTracker, configGet: (k: string) => configManager.get(k as Parameters<typeof configManager.get>[0]), webhookNotifier: ctx.services.webhookNotifier, terminalNotifier });
+    }), { focusTracker: ctx.services.focusTracker, configGet: (k: string) => configManager.get(k as Parameters<typeof configManager.get>[0]), webhookNotifier: ctx.services.webhookNotifier, terminalNotifier, conversation });
 
   const input: InputHandler = new InputHandler(
     () => render(),
     selection,
-    () => scrollTop,
+    () => transcript.top,
     getViewportHeight,
     () => conversation.history,
     scroll,
@@ -390,7 +398,6 @@ async function main() {
       shell: {
         bookmarkManager: ctx.services.bookmarkManager,
         keybindingsManager: ctx.services.keybindingsManager,
-        panelManager,
         processManager,
         profileManager: ctx.services.profileManager,
       },
@@ -409,9 +416,19 @@ async function main() {
   );
 
   orchestratorRefs.getViewportHeight = getViewportHeight; orchestratorRefs.scrollToEnd = scrollToEnd;
+  const views = new SessionViews({
+    conversation, agentManager, processManager, fleetNodes: () => ctx.services.processRegistry.query().nodes,
+    steer: (id, text) => ctx.views.fleet.actions.steer(id, text), killAgent: (id) => ctx.views.fleet.actions.kill(id, { cascade: true }),
+    mainBusy: () => orchestrator.isThinking, mainModel: () => lastHeaderModel, promptText: () => input.prompt, requestRender: () => render(),
+  });
+  sessionViews = views; input.sessionView = views; unsubs.push(() => views.dispose());
+  // Esc while the main transcript is scrolled back returns to the live bottom and never interrupts the turn (handler-modal-stack.ts).
+  input.transcriptScroll = { scrolledBack: () => transcript.scrolledBack && !views.active, toBottom: scrollToLiveBottom };
+  commandContext.openSessionView = (target) => views.open(target);
 
   input.setCommandRegistry(commandRegistry, commandContext);
   commandContext.openComposerEditor = makeComposerEditorOpener({ buffer: input, stdin, stdout, writeGuard: allowTerminalWrite, repaint: () => { compositor.resetDiff(); render(); }, cwd: workingDir, env: process.env, notify: (m) => systemMessageRouter.high(m) });
+  commandContext.openFileInEditor = makeFileEditorOpener({ stdin, stdout, writeGuard: allowTerminalWrite, repaint: () => { compositor.resetDiff(); render(); }, cwd: workingDir, env: process.env, notify: (m) => systemMessageRouter.high(m) });
   input.setConversationManager(conversation);
   input.setContentWidth(getPromptContentWidth()); input.filePicker.setOnUpdate(() => render());
   // retirement: agentDetailModal/processModal setOnRefresh wiring removed,
@@ -437,26 +454,37 @@ async function main() {
 
     // Cache the current model for consistent values across the entire render frame
     const currentModel = providerRegistry.getCurrentModel();
-    // Resolve the effective context window (provider_api / configured_cap overrides) once,
-    // so the footer meter, footer-height, and context inspector agree with the Tokens panel.
-    const contextWindow = providerRegistry.getContextWindowForModel(currentModel);
+    // Resolve the context window once, so the footer meter, the status hint and
+    // the context inspector agree. Only a window some source states is shown:
+    // null means unknown (a guess, or disproven by a larger accepted request),
+    // and every consumer below reads 0 as "no window to measure against".
+    const knownContextWindow = providerRegistry.getKnownContextWindowForModel(currentModel);
+    const contextWindow = knownContextWindow ?? 0;
     const sessionSnapshot = uiServices.readModels.session.getSnapshot();
     const agentSnapshot = uiServices.readModels.agents.getSnapshot();
 
     const activeModel = resolveActiveModelDisplay({ serving: currentModel, configuredRegistryKey: configManager.get('provider.model') as string, configuredLabel: runtime.model, configuredProvider: runtime.provider, failover: failoverState.current() });
-    const headerLines = UIFactory.createHeader(width, activeModel.headerModel, activeModel.headerProvider, conversation.title || undefined, lastGitInfoRef.value, undefined, activeModel.divergenceNote);
+    lastHeaderModel = activeModel.headerModel;
+    const viewFrame = views.frame(width); // an agent or process open full screen, or null in main
+    const headerLines = viewFrame ? [viewFrame.header] : UIFactory.createHeader(width, activeModel.headerModel, conversation.title || undefined, lastGitInfoRef.value, undefined, activeModel.divergenceNote);
+    const chipsRow = views.chips(width);
+    if (chipsRow) headerLines.push(chipsRow);
+    // Scrolled away from the live bottom: the back-to-bottom pill, with the esc keycap only while the next Esc goes there.
+    const promptEmpty = input.prompt.length === 0 && !input.commandMode;
+    const backToBottom = viewFrame
+      ? (views.scrolledBack() ? { escKey: views.escGoesToBottom() } : null)
+      : (transcript.scrolledBack && !conversation.isSplashShowing() ? { escKey: promptEmpty && !conversation.workTree.focused && !input.indicatorFocused } : null);
     const managerAgents = agentManager.list().filter((a) => a.status === 'running' || a.status === 'pending');
     const runtimeAgents = agentSnapshot.active;
     const runningAgentSummary = summarizeRunningAgents(managerAgents, runtimeAgents, ctx.services.wrfcController.listChains());
     const runningAgentCount = runningAgentSummary.count;
-    const runningProcessCount = processManager.list().filter((p) => !p.status.startsWith('done')).length;
+    const runningProcessCount = processManager.list().filter((p) => !p.done).length;
     const cw = getPromptContentWidth();
     const promptInfo = input.getWrappedPromptInfo(cw);
     const commandArgsHint = buildCommandArgsHint(input.prompt, commandRegistry);
     const composerState = deriveComposerState({
       text: input.prompt,
       commandMode: input.commandMode,
-      panelFocused: input.panelFocused,
       pendingApproval: pendingPermission !== null,
       hasAttachments: input.getImageAttachments().size > 0, turnState: sessionSnapshot.turnState,
     });
@@ -464,84 +492,86 @@ async function main() {
       evaluate: (args) => evaluateSessionMaintenance({ configManager, ...args, sessionMemoryCount: ctx.services.sessionMemoryStore.list().length }),
       currentTokens: orchestrator.lastInputTokens, contextWindow,
     });
+    // What main is doing while it works (a turn, a compaction): the throbber row above the input area.
+    const compacting = ctx.services.contextAccountingHolder.getSource()?.getCompactionState().isCompacting === true;
+    if (compacting && compactingSinceMs === undefined) compactingSinceMs = Date.now();
+    else if (!compacting) compactingSinceMs = undefined;
+    const throbberNow = Date.now();
+    const activeToolCallId = streamMetrics.activeToolCallId;
+    // An ask brokered for a background agent carries an attribution; only main's own ask is main's activity.
+    const mainApproval = pendingPermission && pendingPermission.attribution === undefined ? pendingPermission : null;
+    const throbberActivity = resolveThrobberActivity({
+      turnActive: orchestrator.isThinking,
+      compacting,
+      compactingSinceMs,
+      pendingApproval: mainApproval ? { name: mainApproval.tool, args: mainApproval.args } : null,
+      activeTool: streamMetrics.activeToolName !== undefined
+        ? { name: streamMetrics.activeToolName, args: activeToolCallId !== undefined ? streamMetrics.toolArgsByCallId.get(activeToolCallId) : undefined, startedAtMs: streamMetrics.activeToolStartedAtMs }
+        : null,
+      modelPhrase: UIFactory.busyPhrase(orchestrator.thinkingFrame, orchestrator.streamingOutputTokens, UIFactory.computeRenderStallInfo(streamMetrics, throbberNow), mainApproval !== null),
+      turnStartMs: streamMetrics.startTime,
+      ttftMs: streamMetrics.ttftMs,
+      tokenSpeed: (configManager.get('display.showTokenSpeed') as boolean) ? streamMetrics.tokenSpeed : undefined,
+      now: throbberNow,
+    });
+    const throbber = throbberActivity ? { spinner: orchestrator.getSpinner(), frame: orchestrator.thinkingFrame, activity: throbberActivity } : null;
     const footerLines = buildShellFooter({
       width,
       promptText: promptInfo.visibleLines.join('\n'),
       promptLineCount: promptInfo.visibleLines.length,
       promptCursorPos: promptCursorOffset(promptInfo),
-      usage: { up: orchestrator.usage.input, down: orchestrator.usage.output, fleetCostUsd: footerFleetCost(() => ctx.services.processRegistry.query().nodes, runningAgentCount > 0) },
+      usage: { up: orchestrator.usage.input, down: orchestrator.usage.output, cacheRead: orchestrator.usage.cacheRead, cacheWrite: orchestrator.usage.cacheWrite, fleetCostUsd: footerFleetCost(() => ctx.services.processRegistry.query().nodes, runningAgentCount > 0) },
       showExitNotice: input.showExitNotice,
       lastCopyTime: input.lastCopyTime,
-      model: activeModel.footerModel, modelNote: activeModel.divergenceNote,
-      toolCount: toolRegistry.list().length,
-      workingDir,
-      provider: activeModel.footerProvider,
-      contextWindow,
+      model: activeModel.footerModel, // prices the cost; the header names the model
+      workingDir, homeDirectory, view: viewFrame?.footer ?? null,
+      branch: lastGitInfoRef.value?.branch,
+      contextWindow: knownContextWindow,
       contextStatusHint,
       retryHint: retryAffordanceHint(retryAffordance),
       scriptableStatusLine: scriptableStatusline.current(),
-      // Compact footer posture on short terminals so the shell stays usable.
-      compact: height < 30,
       // behavior.autoCompactThreshold is stored as a percent integer (e.g. 80);
-      // the meter expects a fraction [0..1]. Clamp to [0,1] to guard nonsense values.
+      // the bar expects a fraction [0..1]. Clamp to [0,1] to guard nonsense values.
       compactThreshold: Math.min(1, Math.max(0, (configManager.get('behavior.autoCompactThreshold') as number) / 100)),
       dangerMode: isEffectiveDangerMode(configManager),
       lastInputTokens: orchestrator.lastInputTokens,
       commandArgsHint,
-      hitlMode: modeManager.getHITLMode(),
-      // Cross-surface spine posture segment (adopted-daemon mode only).
-      sessionSpineStatus: (() => { const s = uiServices.platform.externalServices?.inspect(); return s?.sessionSpineActive && s.sessionSpineStatus && s.sessionSpineStatus !== 'unknown' ? s.sessionSpineStatus : undefined; })(), runningAgentCount, runningProcessCount,
-      webSurfaceUrl: configManager.get('web.enabled') ? resolveWebSurfaceUrl(configManager) : undefined,
+      runningAgentCount, runningProcessCount,
       // Always-visible "sleep disabled" chip, topology-aware: the DAEMON's state in adopted-external mode, the in-process manager otherwise (power-chip-source.ts).
       powerKeepAwake: powerChipSource.get().keepAwake,
-      // Composer must not read as focused while the panel/process indicator owns keyboard focus.
-      promptFocused: !input.panelFocused && !input.indicatorFocused,
+      // Composer must not read as focused while the process indicator owns keyboard focus.
+      promptFocused: !input.indicatorFocused && !conversation.workTree.focused && viewFrame?.footer.disabledReason === undefined, workTreeFocused: conversation.workTree.focused && !viewFrame,
       indicatorFocused: input.indicatorFocused,
       runningAgentProgress: runningAgentSummary.progress,
-      composerMode: composerState.modeLabel,
-      composerStatus: composerState.statusLabel,
       composerFlags: composerState.flags,
       composerPendingRisk: composerState.pendingRisk, permissionMode: configManager.get('permissions.mode') as string, voiceCapture: voiceCaptureStatus(),
+      throbber, turnRunning: orchestrator.isThinking, backToBottom,
     }).lines;
 
     const onboardingOwnsScreen = input.onboardingWizard.active;
-    const shellHeaderLines = onboardingOwnsScreen ? [] : headerLines;
+    // The main screen keeps one empty row under the header; a view's body starts with its own.
+    const shellHeaderLines = onboardingOwnsScreen ? [] : viewFrame ? headerLines : withHeaderGap(headerLines, width);
+    input.bodyTopRow = shellHeaderLines.length; // mouse rows map to transcript rows from here
     const shellFooterLines = onboardingOwnsScreen ? [] : footerLines;
-    const panelWidth = !onboardingOwnsScreen && panelManager.isVisible() && panelManager.getAllOpen().length > 0
-      ? panelManager.getRightWidth(width)
-      : 0;
+    input.footerTargets = footerTargetRows(shellFooterLines, height - shellFooterLines.length); // clickable usage rows open Usage
     const shellLayout = createShellLayout({
       width,
       height,
       headerHeight: shellHeaderLines.length,
       footerHeight: shellFooterLines.length,
-      panelWidth,
     });
-    input.setPanelMouseLayout(shellLayout.panel
-      ? {
-          x: shellLayout.panel.x,
-          y: shellLayout.panel.y,
-          width: shellLayout.panel.width,
-          height: shellLayout.panel.height,
-          hasBottomPane: panelManager.isBottomPaneVisible() && panelManager.getBottomPane().panels.length > 0,
-          verticalSplitRatio: panelManager.getVerticalSplitRatio(),
-        }
-      : null);
     const vHeight = shellLayout.body.height;
     const conversationWidth = shellLayout.conversation.width;
     activeConversationWidth = conversationWidth;
-    const hasPanelWorkspace = !onboardingOwnsScreen && panelManager.isVisible() && panelManager.getAllOpen().length > 0;
-    conversation.setSplashSuppressed(hasPanelWorkspace);
 
     // Flush pending renders after updating the width provider and splash posture
     // so the transcript and splash rebuild against the current shell layout.
+    conversation.workTree.tickLive(); // running beads spin and count up
     conversation.getDisplayBlocks();
     if (conversation.consumeSplashTransition()) compositor.requestFullRepaint(); // splash → transcript: repaint the whole viewport once
 
     // Calculate how many rows are consumed by overlays (thinking, permissions, queue, file picker)
     let overlayRows = 0;
-    if (orchestrator.isThinking) overlayRows += 2; // spinner + blank
-    if (pendingPermission) overlayRows += PermissionPromptUI.getPromptHeight(pendingPermission, pendingPermission.hunkState, pendingPermission.detailsExpanded, pendingPermission.requestedBy, PermissionPromptUI.promptViewState(pendingPermission, conversationWidth, approvalBroker));
     overlayRows += orchestrator.messageQueue.length * 3; // queued messages
     // File picker and model picker overlay rows computed from actual rendered line count below
     // Selection modal overlay rows are computed from actual rendered line count below
@@ -553,102 +583,83 @@ async function main() {
       conversation,
       width: conversationWidth,
       viewportHeight: vHeight,
-      scrollTop,
-      scrollLocked,
+      scrollTop: transcript.top,
+      scrollLocked: transcript.locked,
       overlayRows,
     });
-    scrollTop = conversationViewport.nextScrollTop;
-    lastMaxScroll = conversationViewport.maxScroll;
-    let viewport = conversationViewport.viewport;
-
-    if (orchestrator.isThinking) {
-      const showSpeed = configManager.get('display.showTokenSpeed') as boolean;
-      const showPreview = configManager.get('display.showToolPreview') as boolean;
-      const partialToolPreview = showPreview ? sessionSnapshot.streamToolPreview : undefined;
-      // Elapsed from turn start (stream or tool execution), used for the thinking indicator timer.
-      const turnElapsedMs = streamMetrics.startTime > 0 ? Date.now() - streamMetrics.startTime : undefined;
-      // Suppressed while a tool executes, its ticking timer is the honest indicator then.
-      const stallInfo = UIFactory.computeRenderStallInfo(streamMetrics, Date.now());
-      const thinking = UIFactory.createThinkingFragment(
-        conversationWidth,
-        orchestrator.getSpinner(),
-        orchestrator.thinkingFrame,
-        showSpeed ? streamMetrics.tokenSpeed : undefined,
-        showPreview ? partialToolPreview : undefined,
-        orchestrator.streamingInputTokens > 0 ? orchestrator.streamingInputTokens : undefined,
-        orchestrator.streamingOutputTokens > 0 ? orchestrator.streamingOutputTokens : undefined,
-        turnElapsedMs,
-        streamMetrics.ttftMs,
-        stallInfo,
-        pendingPermission !== null,
-      );
-      viewport.push(...thinking);
-      // Live tool timer: render the currently executing tool row with ticking elapsed.
-      if (streamMetrics.activeToolName !== undefined && streamMetrics.activeToolStartedAtMs !== undefined) {
-        const liveToolCall = { id: streamMetrics.activeToolCallId ?? 'live', name: streamMetrics.activeToolName, arguments: {} };
-        viewport.push(...renderToolCallBlock(liveToolCall, 'executing', undefined, conversationWidth, undefined, undefined, undefined, streamMetrics.activeToolStartedAtMs));
-      }
+    // Unlocked but already at the bottom (a jump that landed there, output that
+    // shrank) is the live bottom: it follows again, and the pill drawn this frame goes.
+    if (transcript.settle(conversationViewport.nextScrollTop, conversationViewport.maxScroll) && backToBottom && !viewFrame) render();
+    const scrollTop = transcript.top;
+    let viewport = viewFrame ? viewFrame.body(vHeight) : conversation.isSplashShowing()
+      ? centerViewportContent(conversationViewport.viewport, conversationViewport.effectiveHeight, conversationWidth)
+      : conversationViewport.viewport;
+
+    if (orchestrator.isThinking && !viewFrame) {
+      // The spinner and phrase are the throbber's (above the input area); the
+      // opt-in partial tool preview keeps its own faint row under the transcript.
+      const partialToolPreview = (configManager.get('display.showToolPreview') as boolean) ? sessionSnapshot.streamToolPreview : undefined;
+      if (partialToolPreview) viewport.push(UIFactory.createToolPreviewRow(conversationWidth, partialToolPreview));
     }
 
-    if (pendingPermission) {
-      viewport.push(...PermissionPromptUI.createPromptLines(conversationWidth, pendingPermission, pendingPermission.hunkState, pendingPermission.detailsExpanded, pendingPermission.requestedBy, PermissionPromptUI.promptViewState(pendingPermission, conversationWidth, approvalBroker)));
-    }
-
-    viewport.push(...UIFactory.createQueuedMessageList(conversationWidth, orchestrator.listQueuedMessages()));
-    viewport.push(...memoryProvenanceUi.renderChip(conversationWidth, configManager));
-
-    viewport = applyConversationOverlays(viewport, {
-      input,
-      conversation,
-      commandRegistry,
-      keybindingsManager: ctx.services.keybindingsManager,
-      conversationWidth,
-      viewportHeight: vHeight,
-      contextWindow,
-    });
+    if (!viewFrame) viewport.push(...UIFactory.createQueuedMessageList(conversationWidth, orchestrator.listQueuedMessages()), ...memoryProvenanceUi.renderChip(conversationWidth, configManager));
 
-    // Panel composite data
-    const panelComposite = onboardingOwnsScreen
-      ? { panelData: undefined, panelWidth: 0 }
-      : buildPanelCompositeData(
-        panelManager,
-        input,
-        shellLayout.panel?.width ?? 0,
-        shellLayout.panel?.height ?? vHeight,
-      );
+    const overlayContext = { input, conversation, commandRegistry, keybindingsManager: ctx.services.keybindingsManager, contextWindow };
+    viewport = applyConversationOverlays(viewport, { ...overlayContext, conversationWidth, viewportHeight: vHeight });
 
     compositor.composite({
       width, height,
       header: shellHeaderLines,
       viewport,
       footer: shellFooterLines,
-      selection: onboardingOwnsScreen ? undefined : {
+      selection: onboardingOwnsScreen || viewFrame ? undefined : {
         isCellSelected: (col, row) => selection.isCellSelected(col, row),
         scrollTop,
         lineCount: conversation.history.getLineCount(),
       },
-      search: !onboardingOwnsScreen && input.searchManager.active ? {
+      search: !onboardingOwnsScreen && !viewFrame && input.searchManager.active ? {
         manager: input.searchManager,
         scrollTop,
         viewportStartY: shellHeaderLines.length,
       } : undefined,
-      panel: panelComposite.panelData,
-      panelWidth: panelComposite.panelWidth,
-    });
+      layers: buildConversationLayers({ ...overlayContext, screenWidth: width, screenHeight: height, headerRows: shellHeaderLines.length, footerRows: shellFooterLines.length, permission: pendingPermission ? PermissionPromptUI.renderPromptModal(width, height, pendingPermission, pendingPermission, approvalBroker) : null }),
+    }); typeahead.framePainted(); // a startup modal counts as seen from its first painted frame
   };
   const renderScheduler = createRenderScheduler(renderNow, undefined, () => lifecycle.isTerminalRestored()); // coalescer; no frames after terminal restore
   deferredRender.set(() => renderScheduler.schedule()); // from here on, render() actually schedules
   const terminalOutputGuard = installFullScreenTerminalOutputGuard({ stdout, stderr: process.stderr, onCapture: (total) => { commandContext.session.runtime.terminalWritesIntercepted = total; render(); } });
 
   setRenderRequest(() => renderScheduler.flushNow()); // bootstrap's 16ms coalescer composites via the (restore-gated) scheduler
-  setPanelFrameRequester(render); // live panels repaint when idle (a replay finding: fleet sat stale until keypress)
   orchestratorRefs.requestRender = render;
   commandContext.renderRequest = render;
+  // /status: what the footer rows used to show, from the same sources (shell/status-report.ts).
+  commandContext.describeStatus = () => {
+    const serving = providerRegistry.getCurrentModel();
+    const active = resolveActiveModelDisplay({ serving, configuredRegistryKey: configManager.get('provider.model') as string, configuredLabel: runtime.model, configuredProvider: runtime.provider, failover: failoverState.current() });
+    const spine = uiServices.platform.externalServices?.inspect();
+    const voice = voiceCaptureStatus();
+    const git = lastGitInfoRef.value;
+    return formatStatusReport({
+      workingDirectory: workingDir, branch: git?.branch, dirty: git?.dirty,
+      model: active.footerModel, provider: active.footerProvider, modelNote: active.divergenceNote,
+      permissionMode: configManager.get('permissions.mode') as string, toolCount: toolRegistry.list().length, notifyMode: modeManager.getHITLMode(),
+      usage: orchestrator.usage,
+      cost: statusCostText({ up: orchestrator.usage.input, down: orchestrator.usage.output, cacheRead: orchestrator.usage.cacheRead, cacheWrite: orchestrator.usage.cacheWrite, fleetCostUsd: footerFleetCost(() => ctx.services.processRegistry.query().nodes, true) }, active.footerModel),
+      contextTokens: orchestrator.lastInputTokens, contextWindow: providerRegistry.getKnownContextWindowForModel(serving) ?? 0, contextWindowSource: describeContextWindowSource(serving),
+      compactFraction: Math.min(1, Math.max(0, (configManager.get('behavior.autoCompactThreshold') as number) / 100)),
+      sessionSpine: spine?.sessionSpineActive && spine.sessionSpineStatus && spine.sessionSpineStatus !== 'unknown' ? spine.sessionSpineStatus : undefined,
+      webSurfaceUrl: configManager.get('web.enabled') ? resolveWebSurfaceUrl(configManager) : undefined,
+      autoApprove: isEffectiveDangerMode(configManager), keepAwake: powerChipSource.get().keepAwake,
+      microphone: voice && voiceCaptureRowVisible(voice) ? voiceCaptureDescription(voice) : null,
+      runningAgents: agentManager.list().filter((a) => a.status === 'running' || a.status === 'pending').length,
+      runningProcesses: processManager.list().filter((p) => !p.done).length,
+    });
+  };
   wireShellUiOpeners({
     commandContext,
     input,
-    panelManager,
-    conversation,
+    views: ctx.views,
+    viewPanelAdapter: ctx.services.panelManager,
     configManager,
     providerRegistry,
     runtime,
@@ -667,7 +678,7 @@ async function main() {
     render, trustPromptRef,
   });
 
-  const { refreshGit, unsubs: turnUnsubs } = wireTurnEventHandlers({
+  const { refreshGit, unsubs: turnUnsubs, continueTurnAfterFailover } = wireTurnEventHandlers({
     events: uiServices.events,
     conversation,
     runtime,
@@ -709,7 +720,7 @@ async function main() {
   const streamResult: WireStreamEventMetricsResult = wireStreamEventMetrics({
     events: uiServices.events, orchestrator, providerRegistry,
     systemMessageRouter, render, metrics: streamMetrics,
-    providerOptimizer: ctx.services.providerOptimizer, costLookup: providerRegistry, retryTurn,
+    providerOptimizer: ctx.services.providerOptimizer, costLookup: providerRegistry, retryTurn, onFailoverRetry: continueTurnAfterFailover,
     failoverState, getConfiguredRegistryKey: () => configManager.get('provider.model') as string | undefined,
     // The REQUESTED level, through the one helper every remap site reads from.
     getConfiguredReasoningEffort: () => requestedEffortLevel(configManager),
@@ -729,15 +740,16 @@ async function main() {
   // --- Terminal setup ---
   stdin.setRawMode(true); stdin.resume(); stdin.setEncoding('utf8');
   allowTerminalWrite(() => stdout.write((cli.flags.noAltScreen ? '' : ALT_SCREEN_ENTER) + CLEAR_SCREEN + CURSOR_HIDE + MOUSE_ENABLE + KEYBOARD_EXT_ENABLE + PASTE_ENABLE + FOCUS_ENABLE));
-  // forced dark/light applies before first paint; auto (TTY only) fires the
-  // OSC 11 probe and repaints once if light wins. filterInput strips the reply from stdin.
-  const themeProbe = installBackgroundThemeProbe({ configManager, isTTY: Boolean(stdout.isTTY), env: process.env, writeQuery: (b) => allowTerminalWrite(() => stdout.write(b)), requestRepaint: () => { compositor.resetDiff(); render(); } });
+  // forced dark/light applies before first paint; auto (TTY only) repaints once if the OSC 11 probe says light. probePalette adds OSC 10 + OSC 4;0..15
+  // and retries until the terminal answers (terminal-palette-reader.ts); the `system` theme re-themes when it arrives. filterInput strips replies from stdin.
+  registerThemeRefresh(() => conversation.clearLineCache()); // theme/mode change: cached transcript lines re-render in the new colours
+  const themeProbe = installBackgroundThemeProbe({ configManager, isTTY: Boolean(stdout.isTTY), writeQuery: (b) => allowTerminalWrite(() => stdout.write(b)), requestRepaint: () => { compositor.resetDiff(); render(); }, probePalette: true, forwardInput: (b) => routeInput(b), subscribeResize: (l) => { stdout.on('resize', l); } });
 
   // continueRecovery lets --continue/bare --resume check the target session for a live crash snapshot newer than its store before resuming (see tui-startup.ts).
-  applyInitialTuiCliState({ cli, input, commandRegistry, commandContext, shellPaths: ctx.services.shellPaths, surface: ctx.services.surface, render, continueRecovery: { sessionManager: ctx.services.sessionManager, runtime, conversation, writeLastSessionPointer, receipt: (line) => systemMessageRouter.userReceipt(line) } });
+  const typeaheadHooks = { onModalShown: () => typeahead.arm(), onFlowSettled: () => { const held = typeahead.release(); if (held.length > 0) routeInput(held); } };
+  applyInitialTuiCliState({ cli, input, commandRegistry, commandContext, shellPaths: ctx.services.shellPaths, surface: ctx.services.surface, render, continueRecovery: { sessionManager: ctx.services.sessionManager, runtime, conversation, writeLastSessionPointer, receipt: (line) => systemMessageRouter.userReceipt(line), typeahead: typeaheadHooks } });
 
-  stdin.on('data', (raw: string) => {
-    const data = themeProbe.filterInput(raw); if (data.length === 0) return;
+  const routeInput = (data: string): void => {
     const blocking = handleBlockingShellInput({
       data, pendingPermission, render,
       abortTurn: () => orchestrator.abort(),
@@ -760,7 +772,8 @@ async function main() {
     }
 
     input.feed(data);
-  });
+  };
+  stdin.on('data', (raw: string) => { const data = typeahead.filter(themeProbe.filterInput(raw)); if (data.length > 0) routeInput(data); });
   process.on('SIGINT', sigintHandler); process.on('unhandledRejection', unhandledRejectionHandler); stdout.on('resize', resizeHandler);
 
   // State restores happen ONLY when the user explicitly asks, a CLI flag
@@ -769,16 +782,13 @@ async function main() {
   // deliberately no unconditional auto-restore here: a bare launch never
   // loads a saved conversation on its own (owner ruling).
 
-  // Initial render
-  conversation.rebuildHistory();
-  render();
-
-  // Crash-recovery snapshot: asked, never assumed. Scheduled after the first
-  // frame so the question is drawn rather than posed at a blank terminal.
-  scheduleRecoveryOffer(buildRecoveryOfferWiring({
+  // Crash-recovery snapshot: asked, never assumed, and opened before the first frame so the composer is never live under it;
+  // keys typed before it was painted are held and replayed into the composer once it is answered (startup-typeahead-gate.ts).
+  void startRecoveryOffer(buildRecoveryOfferWiring({
     surface: ctx.services.surface, sessionManager: ctx.services.sessionManager, runtime, conversation, commandContext,
-    writeLastSessionPointer, receipt: (line) => systemMessageRouter.userReceipt(line), render,
+    writeLastSessionPointer, receipt: (line) => systemMessageRouter.userReceipt(line), render, typeahead: typeaheadHooks,
   }));
+  conversation.rebuildHistory(); render(); // initial render
 
   // Auto-save to recovery file every 60s + multi-instance liveness-marker
   // refresh, see runtime/recovery-autosave.ts.