@golba98/codexa 1.0.2 → 1.0.4

package/src/app.tsx

@@ -1,4 +1,4 @@
-import React, { startTransition, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import React, { startTransition, useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { spawn } from "child_process";
 import { existsSync } from "fs";
 import path from "node:path";
@@ -7,6 +7,38 @@ import path from "node:path";
 function appDiagLog(msg: string): void {
   void msg;
 }
+
+function normalizeRuntimeAvailability(value: unknown): RuntimeAvailability {
+  if (value === "checking" || value === "reconnecting") return value;
+  if (value === "available") return "available";
+  if (value === "unavailable" || value === "no-models") return "unavailable";
+  return "unknown";
+}
+
+function formatRuntimeProviderLabel(providerId: ProviderId): string {
+  if (providerId === "local") return "Local";
+  if (providerId === "google") return "Google";
+  if (providerId === "anthropic") return "Anthropic";
+  if (providerId === "antigravity") return "Antigravity";
+  return "OpenAI";
+}
+
+function readDiagnosticString(
+  diagnostics: Record<string, string | number | boolean | null> | undefined,
+  keys: string[],
+): string | null {
+  if (!diagnostics) return null;
+  for (const key of keys) {
+    const value = diagnostics[key];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return String(value);
+    }
+  }
+  return null;
+}
 import { Box, Text, useApp, useFocusManager, useInput, useStdin, useStdout } from "ink";
 import { handleCommand } from "./commands/handler.js";
 import {
@@ -17,6 +49,7 @@ import {
 import type { LaunchArgs } from "./config/launchArgs.js";
 import { loadSettings, saveSettings } from "./config/persistence.js";
 import {
+  APP_VERSION,
   type AuthPreference,
   type AvailableBackend,
   type AvailableMode,
@@ -76,9 +109,9 @@ import {
   probeCodexAuthStatus,
 } from "./core/auth/codexAuth.js";
 import { getTerminalSelectionProfile } from "./core/terminal/terminalSelection.js";
-import { copyToClipboard } from "./core/clipboard.js";
-import { normalizePlanReviewMarkdown, savePlan, readPlan } from "./core/planStorage.js";
-import { getBlockedCleanupFailure } from "./core/cleanupFastFail.js";
+import { copyToClipboard } from "./core/shared/clipboard.js";
+import { normalizePlanReviewMarkdown, savePlan, readPlan } from "./core/workspace/planStorage.js";
+import { getBlockedCleanupFailure } from "./core/shared/cleanupFastFail.js";
 import { runShellCommand, summarizeCommandResult } from "./core/process/CommandRunner.js";
 import {
   buildPlanExecutionPrompt,
@@ -86,8 +119,8 @@ import {
   detectHollowResponse,
   isClearlySafeGeneratedCleanupRequest,
   resolveExecutionMode,
-} from "./core/codexPrompt.js";
-import { formatHollowResponse } from "./core/hollowResponseFormat.js";
+} from "./core/codex/codexPrompt.js";
+import { formatHollowResponse } from "./core/shared/hollowResponseFormat.js";
 import {
   createFallbackModelCapabilities,
   findModelCapability,
@@ -103,31 +136,29 @@ import {
   buildWorkspaceCommandContext,
   createWorkspaceRelaunchPlan,
   guardWorkspaceRelaunch,
+  type LaunchContext,
   resolveLaunchContext,
-} from "./core/launchContext.js";
+} from "./core/workspace/launchContext.js";
 import {
   findOutsideWorkspacePaths,
+  formatSkippedDependencyPath,
   getPromptWorkspaceGuardMessage,
   getShellWorkspaceGuardMessage,
-} from "./core/workspaceGuard.js";
-import {
-  type ModelSpec,
-} from "./core/models/modelSpecs.js";
+} from "./core/workspace/workspaceGuard.js";
 import {
-  contextMetadataToModelSpec,
   formatContextCompact,
   formatContextLength,
   resolveModelContextLength,
   type ModelContextMetadata,
 } from "./core/providerRuntime/contextMetadata.js";
-import { captureWorkspaceSnapshot, createWorkspaceActivityTracker, diffWorkspaceSnapshots } from "./core/workspaceActivity.js";
-import { resolveWorkspaceRoot } from "./core/workspaceRoot.js";
+import { captureWorkspaceSnapshot, createWorkspaceActivityTracker, diffWorkspaceSnapshots } from "./core/workspace/workspaceActivity.js";
+import { resolveWorkspaceRoot } from "./core/workspace/workspaceRoot.js";
 import {
   importExternalFile,
   isImageFile,
   rewritePromptWithImportedPaths,
-} from "./core/attachments.js";
-import { loadProjectInstructions } from "./core/projectInstructions.js";
+} from "./core/shared/attachments.js";
+import { loadProjectInstructions } from "./core/workspace/projectInstructions.js";
 import { isNoiseLine } from "./core/providers/codexTranscript.js";
 import { getBackendProvider } from "./core/providers/registry.js";
 import type { BackendProgressUpdate, BackendProvider } from "./core/providers/types.js";
@@ -157,16 +188,13 @@ import {
 } from "./core/providerLauncher/workspaceConfig.js";
 import { sanitizeTerminalInput, sanitizeTerminalLines, sanitizeTerminalOutput } from "./core/terminal/terminalSanitize.js";
 import { createTerminalModeController, setTerminalControlUIState } from "./core/terminal/terminalControl.js";
+import { resolveInkRenderInstance, resetInkOutputForFreshFrame } from "./core/terminal/inkRenderReset.js";
+import { createClearFrameBoundaryController } from "./core/terminal/clearFrameBoundary.js";
 import {
-  acquireTerminalTitleGuard,
-  beginColdStartSequence,
-  deriveTerminalTitle,
-  reassertIntendedTerminalTitle,
-  refreshTerminalTitle,
   setTerminalTitleLifecycleState,
-  setIntendedTerminalTitle,
 } from "./core/terminal/terminalTitle.js";
-import { getStdinDebugState, traceInputDebug } from "./core/inputDebug.js";
+import { getStdinDebugState, traceInputDebug } from "./core/debug/inputDebug.js";
+import { traceModelStateDebug } from "./core/debug/modelStateDebug.js";
 import * as perf from "./core/perf/profiler.js";
 import * as renderDebug from "./core/perf/renderDebug.js";
 import {
@@ -177,7 +205,7 @@ import {
   getLocalGitRemoteUrl,
   parseRepoIdentity,
   type DiagnosticResult,
-} from "./core/githubDiagnostics.js";
+} from "./core/shared/githubDiagnostics.js";
 import type { RunEvent, Screen, ShellEvent, TimelineEvent, UIState, UserPromptEvent } from "./session/types.js";
 import {
   buildFollowUpPrompt,
@@ -204,7 +232,7 @@ import {
 import { AuthPanel } from "./ui/AuthPanel.js";
 import { BackendPicker } from "./ui/BackendPicker.js";
 import { measureBottomComposerRows, MemoizedBottomComposer } from "./ui/BottomComposer.js";
-import { useTerminalViewport } from "./ui/layout.js";
+import { resolveStartupHeaderMode, useTerminalViewport } from "./ui/layout.js";
 import { ModelPickerScreen } from "./ui/ModelPickerScreen.js";
 import { ModePicker } from "./ui/ModePicker.js";
 import { PlanActionPicker, type PlanActionValue, measurePlanActionPickerRows } from "./ui/PlanActionPicker.js";
@@ -214,10 +242,12 @@ import { ReasoningPicker } from "./ui/ReasoningPicker.js";
 import { AttachmentImportPanel, type PendingImportFile } from "./ui/AttachmentImportPanel.js";
 import { SelectionPanel } from "./ui/SelectionPanel.js";
 import { SettingsPanel } from "./ui/SettingsPanel.js";
+import { UpdatePromptPanel } from "./ui/UpdatePromptPanel.js";
 import { measureTextEntryPanelRows, TextEntryPanel } from "./ui/TextEntryPanel.js";
 import { ThemePicker } from "./ui/ThemePicker.js";
 import { getFocusTargetForScreen, FOCUS_IDS } from "./ui/focus.js";
 import { ThemeProvider, THEMES } from "./ui/theme.js";
+import { buildActiveRuntimeDisplay, runtimeDisplayToSummary } from "./ui/runtimeDisplay.js";
 import {
   cancelThemeSelection,
   commitThemeSelection,
@@ -228,7 +258,10 @@ import {
 } from "./ui/themeFlow.js";
 import { isBusy as isUiBusy } from "./session/types.js";
 import { AppShell } from "./ui/AppShell.js";
-import { checkForUpdates, formatUpdateInstructions, type UpdateCheckResult } from "./core/updateCheck.js";
+import { TranscriptShell } from "./ui/TranscriptShell.js";
+import type { RuntimeAvailability } from "./ui/RuntimeStatusBar.js";
+import { checkForUpdates, formatLocalDevUpdateStatus, formatUpdateInstructions, shouldRunStartupUpdateCheck, type UpdateCheckResult } from "./core/version/updateCheck.js";
+import { isLocalDevChannel } from "./core/version/channel.js";
 import {
   isCacheValid,
   loadUpdateCheckCache,
@@ -260,6 +293,51 @@ function createTurnId(): number {
   return nextTurnId++;
 }
 
+function createLaunchModeEvent(launchContext: LaunchContext): TimelineEvent | null {
+  const devLaunchNotice = buildDevLaunchNotice(launchContext);
+  if (!devLaunchNotice) return null;
+
+  return {
+    id: createEventId(),
+    type: "system",
+    createdAt: Date.now(),
+    title: sanitizeTerminalOutput("Launch mode"),
+    content: sanitizeTerminalOutput(devLaunchNotice, { preserveTabs: false, tabSize: 2 }),
+  };
+}
+
+function createProviderMigrationNoticeEvent(
+  notice: ProviderWorkspaceConfig["migrationNotice"] | undefined,
+  providerLabel: string | null = null,
+): TimelineEvent | null {
+  if (!notice) return null;
+
+  const resolvedProviderLabel = providerLabel ?? formatRuntimeProviderLabel(notice.revertedProviderId);
+  return {
+    id: createEventId(),
+    type: "system",
+    createdAt: Date.now(),
+    title: sanitizeTerminalOutput("Provider migrated"),
+    content: sanitizeTerminalOutput(
+      `${formatRuntimeProviderLabel(notice.deprecatedProviderId as ProviderId)} provider is no longer supported. Reverted to ${resolvedProviderLabel}.`,
+      { preserveTabs: false, tabSize: 2 },
+    ),
+  };
+}
+
+function createStartupStaticEvents({
+  launchContext,
+  providerWorkspaceConfig,
+}: {
+  launchContext: LaunchContext;
+  providerWorkspaceConfig: ProviderWorkspaceConfig;
+}): TimelineEvent[] {
+  return [
+    createLaunchModeEvent(launchContext),
+    createProviderMigrationNoticeEvent(providerWorkspaceConfig.migrationNotice),
+  ].filter((event): event is TimelineEvent => event !== null);
+}
+
 function createInitialAuthStatus(): CodexAuthProbeResult {
   return {
     state: "checking",
@@ -307,6 +385,9 @@ export function App({ launchArgs }: AppProps) {
     ? projectInstructionsLoad.instructions
     : null;
   const initialSettings = useRef(loadSettings());
+  const skippedUpdateVersionRef = useRef<string | null>(
+    initialSettings.current.updateCheck.skippedUpdateVersion ?? null,
+  );
   const initialProviderWorkspaceConfig = useRef<ProviderWorkspaceConfig>(loadProviderWorkspaceConfig(workspaceRoot));
   const initialLayeredConfig = useRef<LayeredConfigResult | null>(null);
   if (initialLayeredConfig.current === null) {
@@ -321,6 +402,12 @@ export function App({ launchArgs }: AppProps) {
     [launchContext],
   );
   const terminalLayout = useTerminalViewport();
+  // Assigned during render (like screenRef) so the clear-frame boundary can
+  // tell, at frame-write time, whether the committing tree was laid out
+  // against the current terminal width (the viewport hook commits dimensions
+  // on a trailing settle, so frames can lag stdout.columns).
+  const terminalLayoutColsRef = useRef<number | undefined>(terminalLayout.rawCols ?? terminalLayout.cols);
+  terminalLayoutColsRef.current = terminalLayout.rawCols ?? terminalLayout.cols;
 
   // ─── State & Refs ────────────────────────────────────────────────────────────
 
@@ -372,7 +459,26 @@ export function App({ launchArgs }: AppProps) {
   const screenRef = useRef<Screen>("main");
   screenRef.current = screen;
   const [composerInstanceKey, setComposerInstanceKey] = useState(0);
-  const { state: sessionState, dispatch: dispatchSession } = useAppSessionState();
+  // Bumped purely to force one extra React commit when the /clear boundary needs
+  // the authoritative post-clear frame flushed (see the syncRenderState effect).
+  const [, bumpPostClearRepaint] = useState(0);
+  // Bumped whenever a width-changing resize forces a physical terminal clear
+  // (see clearFrameBoundaryController below). TranscriptShell folds this into
+  // its <Static> key so already-flushed content (logo, past turns) reprints
+  // at the new width instead of staying erased — Ink's <Static> never
+  // re-emits items on its own once flushed.
+  const [staticRepaintGeneration, bumpStaticRepaintGeneration] = useState(0);
+  // Assigned during render (like screenRef) so the clear-frame boundary can
+  // tell, at frame-write time, whether the committing tree already contains
+  // the re-flushed <Static> content for a pending width repaint.
+  const staticRepaintGenerationRef = useRef(0);
+  staticRepaintGenerationRef.current = staticRepaintGeneration;
+  const { state: sessionState, dispatch: dispatchSession } = useAppSessionState(() => {
+    return createStartupStaticEvents({
+      launchContext,
+      providerWorkspaceConfig: initialProviderWorkspaceConfig.current,
+    });
+  });
   const [authStatus, setAuthStatus] = useState<CodexAuthProbeResult>(createInitialAuthStatus());
   const [authStatusBusy, setAuthStatusBusy] = useState(false);
   // Running character total across the conversation — used to estimate token usage
@@ -383,6 +489,24 @@ export function App({ launchArgs }: AppProps) {
   const { stdout } = useStdout();
   const { stdin } = useStdin();
   const terminalControl = useMemo(() => createTerminalModeController((chunk) => stdout.write(chunk)), [stdout]);
+  // Live Ink instance behind this stdout, used to reset Ink's frame caches on
+  // the /clear boundary so the next frame is authoritative (see handleClear).
+  const inkInstance = useMemo(() => resolveInkRenderInstance(stdout), [stdout]);
+  const clearFrameBoundaryController = useMemo(
+    () => createClearFrameBoundaryController({
+      instance: inkInstance,
+      terminalControl,
+      stdout,
+      source: "src/app.tsx:clearBoundary",
+      // Read at frame-write time; screenRef is assigned during render, so it
+      // always reflects the render that produced the frame being written.
+      isOverlayActive: () => screenRef.current !== "main",
+      onWidthResizeRefresh: () => bumpStaticRepaintGeneration((tick) => tick + 1),
+      getRenderedRepaintGeneration: () => staticRepaintGenerationRef.current,
+      getRenderedLayoutCols: () => terminalLayoutColsRef.current,
+    }),
+    [inkInstance, stdout, terminalControl],
+  );
   const [mouseOverride, setMouseOverride] = useState<boolean | null>(null);
   const [isMouseIdle, setIsMouseIdle] = useState(false);
   const mouseIdleTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
@@ -392,9 +516,14 @@ export function App({ launchArgs }: AppProps) {
     if (mouseIdleTimerRef.current) {
       clearTimeout(mouseIdleTimerRef.current);
     }
+    // We disable the idle timeout to ensure reliable trackpad/mouse-wheel scrolling
+    // in the pop-out window. Otherwise, after 1.5 seconds of inactivity, mouse capture
+    // turns off, and scrolling stops working entirely.
+    /*
     mouseIdleTimerRef.current = setTimeout(() => {
       setIsMouseIdle(true);
     }, 1500);
+    */
   }, []);
 
   useInput(() => {
@@ -406,26 +535,71 @@ export function App({ launchArgs }: AppProps) {
   const [planFlow, setPlanFlow] = useState<PlanFlowState>(createInitialPlanFlowState);
   const [initialRevisionText, setInitialRevisionText] = useState("");
   const [updateCheckResult, setUpdateCheckResult] = useState<UpdateCheckResult | null>(null);
-  // Mouse reporting defaults to the persisted terminalMouseMode setting.
-  // "wheel" (default) enables SGR mouse reporting so the timeline can receive
-  // wheel events; native drag-select then requires Shift in Windows Terminal.
-  // "selection" keeps the terminal in control of mouse events.
-  // /mouse toggles the in-session override without changing the saved setting.
-  //
-  // We apply an idle-timeout: if no wheel events or keypresses occur for 1.5s,
-  // we disable mouse reporting so native drag-selection works unmodified.
+  // Transcript mode leaves mouse reporting off so wheel/trackpad input scrolls
+  // the terminal emulator's native scrollback instead of an in-app viewport.
   const mouseCapture = (mouseOverride ?? (terminalMouseMode === "wheel")) && !isMouseIdle;
+  const effectiveMouseCapture = false;
+  const overlayMode = screen !== "main";
 
   // ─── Effects & Handlers ──────────────────────────────────────────────────────
 
   useEffect(() => {
-    // Default path writes the disable sequences defensively, preserving native
-    // terminal selection unless the user explicitly opts into /mouse capture.
-    terminalControl.setMouseReporting(mouseCapture, mouseCapture ? "src/app.tsx:mouseCapture.enable" : "src/app.tsx:mouseCapture.disable");
+    return () => {
+      clearFrameBoundaryController?.dispose();
+    };
+  }, [clearFrameBoundaryController]);
+
+  useEffect(() => {
+    if (!clearFrameBoundaryController) return;
+    const postClearRepaintPending = clearFrameBoundaryController.syncRenderState({
+      generation: sessionState.clearEpoch,
+      staticEventsLength: sessionState.staticEvents.length,
+      activeEventsLength: sessionState.activeEvents.length,
+      transcriptCleared: sessionState.staticEvents.length === 0 && sessionState.activeEvents.length === 0,
+      clearGenerationReady: sessionState.clearEpoch > 0 && sessionState.uiState.kind === "IDLE" && sessionState.activeEvents.length === 0,
+      uiStateKind: sessionState.uiState.kind,
+    });
+    if (postClearRepaintPending) {
+      // Ink already wrote (and suppressed) the cleared frame during the commit
+      // that preceded this passive effect, so the boundary's gate only became
+      // satisfiable just now. Force one more commit to deterministically flush
+      // the authoritative post-clear frame instead of waiting on an incidental
+      // later render. `bumpPostClearRepaint` is not an effect dependency, so this
+      // re-render does not re-run the effect (no loop).
+      bumpPostClearRepaint((tick) => tick + 1);
+    }
+  }, [clearFrameBoundaryController, sessionState]);
+
+  useEffect(() => {
+    // Main transcript mode keeps native terminal scrollback and selection in
+    // control. Keep writing the disable sequence defensively in case a previous
+    // version or overlay left mouse reporting enabled.
+    terminalControl.setMouseReporting(effectiveMouseCapture, effectiveMouseCapture ? "src/app.tsx:mouseCapture.enable" : "src/app.tsx:mouseCapture.disable");
     return () => {
       terminalControl.setMouseReporting(false, "src/app.tsx:mouseCapture.cleanup");
     };
-  }, [mouseCapture, terminalControl]);
+  }, [effectiveMouseCapture, terminalControl]);
+
+  useLayoutEffect(() => {
+    // The clear-frame boundary owns alternate-screen switching so the buffer
+    // flip happens atomically with the first frame of the new screen (see
+    // clearFrameBoundary.ts). Toggling from an effect would run after Ink has
+    // already written that frame into the wrong buffer — the overlay would
+    // land in the normal buffer's scrollback and the alt screen would open
+    // blank. This effect is only a fallback for environments where no live
+    // Ink instance could be resolved (tests, exotic Ink versions).
+    if (clearFrameBoundaryController) return;
+    terminalControl.setAlternateScreen(
+      overlayMode,
+      overlayMode ? "src/app.tsx:overlay.enterAlternateScreen" : "src/app.tsx:overlay.exitAlternateScreen",
+    );
+  }, [clearFrameBoundaryController, overlayMode, terminalControl]);
+
+  useEffect(() => {
+    return () => {
+      terminalControl.setAlternateScreen(false, "src/app.tsx:overlay.cleanupAlternateScreen");
+    };
+  }, [terminalControl]);
 
   const cleanupRef = useRef<(() => void) | null>(null);
   const activeRunLifecycleRef = useRef<PromptRunLifecycle | null>(null);
@@ -444,7 +618,7 @@ export function App({ launchArgs }: AppProps) {
   const modelSelectionInFlightRef = useRef(false);
   const providerRouteErrorsRef = useRef<Record<string, string>>({});
   const providerDiagnosticsRef = useRef<Record<string, Record<string, string | number | boolean | null>>>({});
-  const providerMigrationNoticeShownRef = useRef(false);
+  const providerMigrationNoticeShownRef = useRef(Boolean(initialProviderWorkspaceConfig.current.migrationNotice));
   const initialPromptSubmittedRef = useRef(false);
   const activeThemeName = getDisplayedThemeName(themeSelection);
   const activeTheme =
@@ -500,6 +674,31 @@ export function App({ launchArgs }: AppProps) {
     [providerRegistry],
   );
   const activeRouteProviderId = activeProviderRoute.providerId;
+  const markProviderAvailability = useCallback((
+    providerId: ProviderId,
+    availability: RuntimeAvailability,
+    reason: string,
+  ) => {
+    const previous = providerDiagnosticsRef.current[providerId] ?? {};
+    const selectedModel = typeof previous.selectedModel === "string" && previous.selectedModel.trim()
+      ? previous.selectedModel.trim()
+      : providerId === activeProviderRoute.providerId
+        ? activeProviderRoute.modelId
+        : null;
+    providerDiagnosticsRef.current[providerId] = {
+      ...previous,
+      selectedModel,
+      availabilityStatus: availability,
+      endpointCheckResult: availability,
+    };
+    traceModelStateDebug("provider_availability_marked", {
+      providerId,
+      selectedModel,
+      availability,
+      reason,
+    });
+    setRegistryNonce((current) => current + 1);
+  }, [activeProviderRoute.modelId, activeProviderRoute.providerId]);
 
   // Reset provider readiness when the user switches to a different provider.
   useEffect(() => {
@@ -733,17 +932,6 @@ export function App({ launchArgs }: AppProps) {
     () => formatWorkspaceDisplayPath(workspaceRoot, workspaceDisplayMode),
     [workspaceDisplayMode, workspaceRoot],
   );
-  const terminalTitleLabel = useMemo(
-    () => deriveTerminalTitle(workspaceRoot, terminalTitleMode),
-    [terminalTitleMode, workspaceRoot],
-  );
-  const latestTerminalTitleRef = useRef(terminalTitleLabel);
-  latestTerminalTitleRef.current = terminalTitleLabel;
-
-  // Cold-start: write title immediately on mount, then retry to outlast Windows Terminal shell integration.
-  // eslint-disable-next-line react-hooks/exhaustive-deps
-  useEffect(() => beginColdStartSequence(latestTerminalTitleRef.current), []);
-
   const { staticEvents, activeEvents, uiState, inputValue, cursor } = sessionState;
 
   const currentUserSettings = useMemo<UserSettingValues>(() => ({
@@ -765,16 +953,73 @@ export function App({ launchArgs }: AppProps) {
     [planFlow],
   );
 
-  const currentModelSpec = useMemo<ModelSpec>(() => {
-    return contextMetadataToModelSpec(activeContextMetadata ?? {
-      providerId: activeProviderRoute.providerId,
-      modelId: activeProviderRoute.modelId,
-      contextLength: null,
-      source: "unknown",
-      confidence: "unknown",
-      error: "Context length unavailable for this model.",
-    });
-  }, [activeContextMetadata, activeProviderRoute.modelId, activeProviderRoute.providerId]);
+  const activeRuntimeDisplay = useMemo(() => buildActiveRuntimeDisplay({
+    route: activeProviderRoute,
+    reasoningLevel,
+    mode,
+    tokensUsed: estimateTokens(conversationChars),
+    modelCapability: currentModelCapability,
+    contextMetadata: activeContextMetadata,
+  }), [
+    activeContextMetadata,
+    activeProviderRoute,
+    conversationChars,
+    currentModelCapability,
+    mode,
+    reasoningLevel,
+  ]);
+  const currentModelSpec = activeRuntimeDisplay.modelSpec;
+  const activeRuntimeAvailability = useMemo<RuntimeAvailability>(() => {
+    if (activeProviderRoute.providerId !== "local") {
+      return "available";
+    }
+    const diagnostics = providerDiagnosticsRef.current.local;
+    return normalizeRuntimeAvailability(diagnostics?.availabilityStatus ?? diagnostics?.endpointCheckResult);
+  // registryNonce intentionally re-reads providerDiagnosticsRef.
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [activeProviderRoute.providerId, registryNonce]);
+  const visibleRuntimeModelState = useMemo(() => {
+    const diagnostics = providerDiagnosticsRef.current[activeProviderRoute.providerId];
+    const providerLabel = activeRouteProvider?.displayName
+      ?? formatRuntimeProviderLabel(activeProviderRoute.providerId);
+    const diagnosticModel = readDiagnosticString(diagnostics, [
+      "selectedModel",
+      "modelId",
+      "currentModel",
+      "defaultModel",
+    ]);
+    const routeModel = activeProviderRoute.modelId?.trim();
+    const modelLabel = routeModel
+      || diagnosticModel
+      || (activeRuntimeAvailability === "checking" || activeRuntimeAvailability === "reconnecting"
+        ? "Detecting..."
+        : "Unknown");
+    const modelDisplay = activeRuntimeDisplay.footerModelDisplay?.trim()
+      || `${providerLabel} / ${modelLabel}`;
+    const diagnosticContext = readDiagnosticString(diagnostics, ["contextDisplay", "contextLength"]);
+    const contextDisplay = activeRuntimeDisplay.contextDisplay?.trim()
+      || diagnosticContext
+      || "Unknown";
+    const nextState = {
+      selectedProvider: activeProviderRoute.providerId,
+      selectedModel: modelLabel,
+      modelDisplay,
+      contextDisplay,
+      availability: activeRuntimeAvailability,
+    };
+    traceModelStateDebug("runtime_model_display_derived", nextState);
+    return nextState;
+  // registryNonce intentionally re-reads providerDiagnosticsRef.
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [
+    activeProviderRoute.modelId,
+    activeProviderRoute.providerId,
+    activeRuntimeAvailability,
+    activeRuntimeDisplay.contextDisplay,
+    activeRuntimeDisplay.footerModelDisplay,
+    activeRouteProvider?.displayName,
+    registryNonce,
+  ]);
 
   const hasUserPrompt = useMemo(
     () => staticEvents.some((e) => e.type === "user") || activeEvents.some((e) => e.type === "user"),
@@ -799,63 +1044,15 @@ export function App({ launchArgs }: AppProps) {
   const busyRef = useRef(busy);
   busyRef.current = busy;
 
-  const forceRefreshCurrentTerminalTitle = useCallback((debugEventName: string, busyState = busyRef.current) => {
-    refreshTerminalTitle({
-      terminalTitleMode,
-      workspaceName: deriveTerminalTitle(workspaceRoot, "dir"),
-      force: true,
-      debugEventName,
-      busyState,
-    });
-  }, [terminalTitleMode, workspaceRoot]);
-
-  const writeCurrentTerminalTitleBeforeStateChange = useCallback((reason: string) => {
-    setIntendedTerminalTitle(deriveTerminalTitle(workspaceRoot, terminalTitleMode), {
-      force: true,
-      reason,
-    });
-  }, [terminalTitleMode, workspaceRoot]);
-
-  // Re-assert terminal title whenever the app transitions between busy states,
-  // starts/stops streaming, or executes tools to recover from external overwrites.
+  const prevBusyRef = useRef(busy);
   useEffect(() => {
-    if (!busy) {
-      refreshTerminalTitle({
-        terminalTitleMode,
-        workspaceName: deriveTerminalTitle(workspaceRoot, "dir"),
-        force: true,
-        debugEventName: "busy-end",
-        busyState: false,
-      });
-      return;
+    if (!busy && prevBusyRef.current && screen === "main") {
+      intendedFocusTargetRef.current = FOCUS_IDS.composer;
+      focusManager.focus(FOCUS_IDS.composer);
     }
+    prevBusyRef.current = busy;
+  }, [busy, screen, focusManager]);
 
-    refreshTerminalTitle({
-      terminalTitleMode,
-      workspaceName: deriveTerminalTitle(workspaceRoot, "dir"),
-      force: true,
-      debugEventName: "busy-start",
-      busyState: true,
-    });
-
-    const timer = setInterval(() => {
-      refreshTerminalTitle({
-        terminalTitleMode,
-        workspaceName: deriveTerminalTitle(workspaceRoot, "dir"),
-        force: true,
-        debugEventName: "busy-guard",
-        busyState: true,
-      });
-    }, 250);
-
-    return () => {
-      clearInterval(timer);
-    };
-  }, [uiState.kind, busy, terminalTitleMode, workspaceRoot]);
-
-  useEffect(() => {
-    setIntendedTerminalTitle(terminalTitleLabel, { force: true, reason: "terminal-title-label-change" });
-  }, [terminalTitleLabel]);
   const modelCapabilitiesBusyRef = useRef(modelCapabilitiesBusy);
   modelCapabilitiesBusyRef.current = modelCapabilitiesBusy;
   const composerRows = useMemo(() => {
@@ -889,9 +1086,59 @@ export function App({ launchArgs }: AppProps) {
     terminalLayout,
     uiState,
   ]);
+  const activeRootComponent = screen === "main" ? "TranscriptShell" : "AppShell";
+  const startupHeaderMode = useMemo(
+    () => resolveStartupHeaderMode({
+      cols: terminalLayout.cols,
+      rows: terminalLayout.rows,
+      introRows: 8,
+      composerRows,
+    }),
+    [composerRows, terminalLayout.cols, terminalLayout.rows],
+  );
+  const previousStartupTraceKeyRef = useRef<string | null>(null);
+
+  useEffect(() => {
+    const nextKey = [
+      terminalLayout.cols,
+      terminalLayout.rows,
+      terminalLayout.mode,
+      activeRootComponent,
+      screen,
+      startupHeaderMode,
+      staticEvents.length,
+      activeEvents.length,
+      uiState.kind,
+    ].join("|");
+    if (previousStartupTraceKeyRef.current === nextKey) return;
+    previousStartupTraceKeyRef.current = nextKey;
+    renderDebug.traceEvent("startup", "state", {
+      cols: terminalLayout.cols,
+      rows: terminalLayout.rows,
+      layoutMode: terminalLayout.mode,
+      activeRoot: activeRootComponent,
+      screen,
+      startupHeaderMode,
+      logoBranchSelected: startupHeaderMode === "large",
+      staticEventsLength: staticEvents.length,
+      activeEventsLength: activeEvents.length,
+      uiStateKind: uiState.kind,
+    });
+  }, [
+    activeEvents.length,
+    activeRootComponent,
+    screen,
+    startupHeaderMode,
+    staticEvents.length,
+    terminalLayout.cols,
+    terminalLayout.mode,
+    terminalLayout.rows,
+    uiState.kind,
+  ]);
 
   renderDebug.useRenderDebug("Root", {
     screen,
+    activeRoot: activeRootComponent,
     uiStateKind: uiState.kind,
     staticEvents,
     activeEvents,
@@ -900,8 +1147,11 @@ export function App({ launchArgs }: AppProps) {
     cursor,
     busy,
     composerRows,
+    startupHeaderMode,
+    logoBranchSelected: startupHeaderMode === "large",
     cols: terminalLayout.cols,
     rows: terminalLayout.rows,
+    layoutMode: terminalLayout.mode,
     layoutEpoch: terminalLayout.layoutEpoch,
     planFlowKind: planFlow.kind,
     mode,
@@ -1180,13 +1430,12 @@ export function App({ launchArgs }: AppProps) {
   useEffect(() => {
     const notice = providerWorkspaceConfig.migrationNotice;
     if (!notice || providerMigrationNoticeShownRef.current) return;
-    providerMigrationNoticeShownRef.current = true;
     const providerLabel = findProvider(providerRegistry, notice.revertedProviderId)?.displayName ?? "OpenAI";
-    appendSystemEvent(
-      "Provider migrated",
-      `Antigravity provider is no longer supported. Reverted to ${providerLabel}.`,
-    );
-  }, [appendSystemEvent, providerRegistry, providerWorkspaceConfig.migrationNotice]);
+    const event = createProviderMigrationNoticeEvent(notice, providerLabel);
+    if (!event) return;
+    providerMigrationNoticeShownRef.current = true;
+    appendStaticEvent(event);
+  }, [appendStaticEvent, providerRegistry, providerWorkspaceConfig.migrationNotice]);
 
   useEffect(() => {
     if (projectInstructionsLoad.status === "loaded") {
@@ -1334,6 +1583,7 @@ export function App({ launchArgs }: AppProps) {
   useEffect(() => {
     void (async () => {
       try {
+        markProviderAvailability("local", "checking", "startup-probe");
         const result = await checkLocalProvider({ override: providerWorkspaceConfig.providers?.local });
         if (result.diagnostics) {
           providerDiagnosticsRef.current["local"] = result.diagnostics as Record<string, string | number | boolean | null>;
@@ -1353,43 +1603,44 @@ export function App({ launchArgs }: AppProps) {
   // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [workspaceRoot]);
 
-  useEffect(() => {
-    const devLaunchNotice = buildDevLaunchNotice(launchContext);
-    if (!devLaunchNotice) return;
-
-    appendSystemEvent("Launch mode", devLaunchNotice);
-  }, [appendSystemEvent, launchContext]);
-
   // Non-blocking background update check — runs once at startup.
   useEffect(() => {
     const ucSettings = initialSettings.current.updateCheck ?? DEFAULT_UPDATE_CHECK_SETTINGS;
-    if (!ucSettings.enabled) return;
+    if (!shouldRunStartupUpdateCheck(process.env, ucSettings.enabled)) return;
 
     const timer = setTimeout(() => {
       void (async () => {
         try {
           const cache = loadUpdateCheckCache();
-          if (cache && isCacheValid(cache, ucSettings.intervalHours)) {
-            if (cache.updateAvailable) {
-              setUpdateCheckResult({
-                status: "update-available",
-                currentVersion: cache.currentVersion,
-                latestVersion: cache.latestVersion,
-                checkedAt: cache.lastChecked,
-              });
-            }
+          if (cache && isCacheValid(cache, ucSettings.intervalHours, APP_VERSION)) {
+            if (cache.updateAvailable && cache.latestVersion) {
+              setUpdateCheckResult({
+                status: "update-available",
+                currentVersion: cache.currentVersion,
+                latestVersion: cache.latestVersion,
+                checkedAt: cache.lastChecked,
+              });
+              if (cache.latestVersion !== skippedUpdateVersionRef.current) {
+                setScreen("update-prompt");
+              }
+            }
             return;
           }
-          const result = await checkForUpdates({ enabled: true });
-          if (result.status !== "error") {
-            setUpdateCheckResult(result);
-            saveUpdateCheckCache({
-              lastChecked: result.checkedAt,
-              currentVersion: result.currentVersion,
-              latestVersion: result.latestVersion,
-              updateAvailable: result.status === "update-available",
-            });
-          }
+          const result = await checkForUpdates({ enabled: true });
+          if (result.status !== "error") {
+            setUpdateCheckResult(result);
+            saveUpdateCheckCache({
+              lastChecked: result.checkedAt,
+              currentVersion: result.currentVersion,
+              latestVersion: result.latestVersion,
+              updateAvailable: result.status === "update-available",
+            });
+            if (result.status === "update-available" && result.latestVersion) {
+              if (result.latestVersion !== skippedUpdateVersionRef.current) {
+                setScreen("update-prompt");
+              }
+            }
+          }
         } catch {
           // Never crash the TUI on a failed update check.
         }
@@ -1602,11 +1853,6 @@ export function App({ launchArgs }: AppProps) {
     }
     setScreen("main");
     appendSystemEvent("Reasoning updated", `Reasoning level is now ${formatReasoningLabel(nextReasoningLevel)}.`);
-    refreshTerminalTitle({
-      terminalTitleMode,
-      workspaceName: deriveTerminalTitle(workspaceRoot, "dir"),
-      force: true,
-    });
   }, [
     activeProviderRoute.backendKind,
     activeProviderRoute.modelId,
@@ -1621,9 +1867,7 @@ export function App({ launchArgs }: AppProps) {
     persistActiveRoute,
     persistProviderDefaultModelAndReasoning,
     providerWorkspaceConfig.activeRoute,
-    terminalTitleMode,
     updateRuntimeConfig,
-    workspaceRoot,
   ]);
 
   const setPlanModeWithNotice = useCallback((nextEnabled: boolean) => {
@@ -1701,11 +1945,6 @@ export function App({ launchArgs }: AppProps) {
         "Model updated",
         `Active model is now ${nextModel}. Reasoning set to ${formatReasoningLabel(normalizedReasoning)}.`,
       );
-      refreshTerminalTitle({
-        terminalTitleMode,
-        workspaceName: deriveTerminalTitle(workspaceRoot, "dir"),
-        force: true,
-      });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       traceInputDebug("model_selection_app_failure", getInputDebugSnapshot({
@@ -1762,11 +2001,11 @@ export function App({ launchArgs }: AppProps) {
 
     try {
       const normalizedReasoning = normalizeReasoningForModelCapabilities(nextModel, nextReasoning, routeCapabilities);
-      const releaseTitleGuard = acquireTerminalTitleGuard(500, () => {
-        forceRefreshCurrentTerminalTitle("provider_validation_active", true);
-      });
       let validation;
       try {
+        if (providerId === "local") {
+          markProviderAvailability("local", "checking", "provider-validation");
+        }
         validation = await validateProviderRouteActivation({
           route: {
             providerId,
@@ -1785,8 +2024,7 @@ export function App({ launchArgs }: AppProps) {
         }
         setRegistryNonce((n) => n + 1);
       } finally {
-        releaseTitleGuard();
-        forceRefreshCurrentTerminalTitle("after_provider_validation", false);
+        // Runtime status is rendered from provider diagnostics; no title guard is active here.
       }
       if (validation.status !== "ready") {
         traceInputDebug("model_selection_app_failure", getInputDebugSnapshot({
@@ -1833,11 +2071,6 @@ export function App({ launchArgs }: AppProps) {
       }));
 
       // Route changes are reflected reactively in the BottomComposer metadata row.
-      refreshTerminalTitle({
-        terminalTitleMode,
-        workspaceName: deriveTerminalTitle(workspaceRoot, "dir"),
-        force: true,
-      });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       traceInputDebug("model_selection_app_failure", getInputDebugSnapshot({
@@ -1847,12 +2080,11 @@ export function App({ launchArgs }: AppProps) {
         error: message,
       }));
       appendErrorEvent("Model selection failed", message);
-      forceRefreshCurrentTerminalTitle("model_selection_failed", false);
     } finally {
       modelSelectionInFlightRef.current = false;
       returnToChatMode("selection");
     }
-  }, [activeProviderRoute.modelId, activeProviderRoute.providerId, activeRouteProvider, appendErrorEvent, appendSystemEvent, busy, getInputDebugSnapshot, modelCapabilities, persistActiveRoute, providerWorkspaceConfig.providers, returnToChatMode, runtimeConfig.geminiCommandPath, updateRuntimeConfig, workspaceRoot]);
+  }, [activeProviderRoute.modelId, activeProviderRoute.providerId, activeRouteProvider, appendErrorEvent, appendSystemEvent, busy, getInputDebugSnapshot, markProviderAvailability, modelCapabilities, persistActiveRoute, providerWorkspaceConfig.providers, returnToChatMode, runtimeConfig.geminiCommandPath, updateRuntimeConfig, workspaceRoot]);
 
   const setAuthPreferenceWithNotice = useCallback((nextPreference: AuthPreference) => {
     setAuthPreference(nextPreference);
@@ -1881,11 +2113,6 @@ export function App({ launchArgs }: AppProps) {
     }
     if (nextSettings.terminalTitleMode !== terminalTitleMode) {
       setTerminalTitleMode(nextSettings.terminalTitleMode);
-      refreshTerminalTitle({
-        terminalTitleMode: nextSettings.terminalTitleMode,
-        workspaceName: deriveTerminalTitle(workspaceRoot, "dir"),
-        force: true,
-      });
     }
     const nextShowBusyLoader = parseBusyLoaderSettingValue(nextSettings.showBusyLoader);
     if (nextShowBusyLoader !== showBusyLoader) {
@@ -1898,6 +2125,33 @@ export function App({ launchArgs }: AppProps) {
     setScreen("main");
   }, [applyWorkspaceDisplayMode, showBusyLoader, terminalMouseMode, terminalTitleMode, workspaceDisplayMode]);
 
+  const handleSkipUpdateForSession = useCallback(() => {
+    setScreen("main");
+  }, []);
+
+  const handleSkipUpdateVersion = useCallback((version: string) => {
+    initialSettings.current.updateCheck = {
+      ...initialSettings.current.updateCheck,
+      skippedUpdateVersion: version,
+    };
+    saveSettings({
+      ui: {
+        layoutStyle: initialSettings.current.ui.layoutStyle,
+        theme: themeSelection.committedTheme,
+        workspaceDisplayMode,
+        terminalTitleMode,
+        showBusyLoader,
+        terminalMouseMode,
+        customTheme,
+      },
+      auth: { preference: authPreference },
+      header: headerConfig,
+      updateCheck: initialSettings.current.updateCheck,
+    });
+    skippedUpdateVersionRef.current = version;
+    setScreen("main");
+  }, [authPreference, customTheme, headerConfig, showBusyLoader, terminalMouseMode, terminalTitleMode, themeSelection.committedTheme, workspaceDisplayMode]);
+
   const setApprovalPolicyWithNotice = useCallback((nextValue: RuntimeApprovalPolicy) => {
     const gate = guardConfigMutation("mode", busy);
     if (!gate.allowed) {
@@ -2023,6 +2277,7 @@ export function App({ launchArgs }: AppProps) {
     }
 
     setScreen("provider-picker");
+    markProviderAvailability("local", "checking", "provider-picker-open");
     void checkLocalProvider({ override: providerWorkspaceConfig.providers?.local }).then((result) => {
       if (!isMountedRef.current) return;
       if (result.diagnostics) {
@@ -2035,7 +2290,7 @@ export function App({ launchArgs }: AppProps) {
       }
       setRegistryNonce((n) => n + 1);
     }).catch(() => undefined);
-  }, [appendSystemEvent, busy, providerWorkspaceConfig.providers]);
+  }, [appendSystemEvent, busy, markProviderAvailability, providerWorkspaceConfig.providers]);
 
   const setWorkspaceDefaultProviderWithNotice = useCallback((providerId: ProviderId) => {
     const provider = findProvider(providerRegistry, providerId);
@@ -2094,6 +2349,7 @@ export function App({ launchArgs }: AppProps) {
 
       if (providerId === "local") {
         appendSystemEvent("Model discovery", "Refreshing LM Studio metadata...");
+        markProviderAvailability("local", "checking", "use-in-codexa");
         void checkLocalProvider({ override: providerWorkspaceConfig.providers?.local }).then((validation) => {
           if (!isMountedRef.current) return;
           if (validation.diagnostics) {
@@ -2203,6 +2459,9 @@ export function App({ launchArgs }: AppProps) {
           appendSystemEvent("Model discovery", providerId === "anthropic"
             ? "Refreshing Claude capabilities..."
             : `Refreshing models for ${provider.displayName}...`);
+          if (providerId === "local") {
+            markProviderAvailability("local", "checking", "refresh-models");
+          }
           void runtime.refreshModels({
             cwd: workspaceRoot,
             localConfig: providerId === "local" ? providerWorkspaceConfig.providers?.local : undefined,
@@ -2309,8 +2568,7 @@ export function App({ launchArgs }: AppProps) {
         stdout.write("\n");
       },
       afterLaunch: () => {
-        terminalControl.setMouseReporting(mouseCapture, "src/app.tsx:providerLaunch.restoreMouse");
-        forceRefreshCurrentTerminalTitle("provider_launch_return", false);
+        terminalControl.setMouseReporting(effectiveMouseCapture, "src/app.tsx:providerLaunch.restoreMouse");
       },
     }).then((result) => {
       if (!isMountedRef.current) return;
@@ -2324,10 +2582,10 @@ export function App({ launchArgs }: AppProps) {
     activeProviderRoute,
     appendErrorEvent,
     appendSystemEvent,
-    forceRefreshCurrentTerminalTitle,
-    mouseCapture,
+    effectiveMouseCapture,
     providerRegistry,
     providerWorkspaceConfig.providers,
+    markProviderAvailability,
     modelCapabilities,
     reasoningLevel,
     refreshModelCapabilities,
@@ -2529,6 +2787,18 @@ export function App({ launchArgs }: AppProps) {
     dispatchSession({ type: "RESET_INPUT" });
   }, [dispatchSession]);
 
+  const resetToHomeScreen = useCallback((seedEvents: TimelineEvent[] = []) => {
+    dispatchSession({
+      type: "CLEAR_TRANSCRIPT",
+      seedEvents,
+    });
+    setConversationChars(0);
+    setScreen("main");
+    resetComposer();
+    intendedFocusTargetRef.current = FOCUS_IDS.composer;
+    focusManager.focus(FOCUS_IDS.composer);
+  }, [dispatchSession, focusManager, resetComposer]);
+
   const finalizePromptRun = useCallback((
     runId: number,
     turnId: number,
@@ -2840,23 +3110,36 @@ export function App({ launchArgs }: AppProps) {
   }, [dispatchSession]);
 
   const handleClear = useCallback(() => {
-    writeCurrentTerminalTitleBeforeStateChange("before-clear");
+    const clearGeneration = sessionState.clearEpoch + 1;
+    const clearBoundaryArmed = clearFrameBoundaryController?.beginClearGeneration(clearGeneration) ?? false;
+    renderDebug.traceEvent("terminal", "clearCommandReceived", {
+      clearGeneration,
+      clearPending: clearBoundaryArmed,
+      liveInkInstanceResolved: Boolean(inkInstance),
+    });
     cancelActiveRun(false);
     activeTurnIdRef.current = null;
     activeRunLifecycleRef.current = null;
     activeRunTimingRef.current = null;
     setPlanFlow(resetPlanFlow());
-    dispatchSession({ type: "CLEAR_TRANSCRIPT" });
-    setConversationChars(0);
-    setScreen("main");
-    resetComposer();
-    terminalControl.clearTranscript("src/app.tsx:handleClear");
-    refreshTerminalTitle({
-      terminalTitleMode,
-      workspaceName: deriveTerminalTitle(workspaceRoot, "dir"),
-      force: true,
+    renderDebug.traceEvent("terminal", "clearReactStateRequested", {
+      clearGeneration,
+      clearPending: clearBoundaryArmed,
     });
-  }, [cancelActiveRun, dispatchSession, resetComposer, terminalControl, terminalTitleMode, workspaceRoot, writeCurrentTerminalTitleBeforeStateChange]);
+    resetToHomeScreen(createStartupStaticEvents({
+      launchContext,
+      providerWorkspaceConfig,
+    }));
+    if (!clearBoundaryArmed) {
+      // Fallback path (unexpected Ink mismatch): preserve /clear semantics.
+      terminalControl.clearTranscript("src/app.tsx:handleClear:fallback");
+      resetInkOutputForFreshFrame({ instance: inkInstance, columns: stdout.columns });
+      renderDebug.traceEvent("terminal", "clearBoundaryFallback", {
+        clearGeneration,
+        liveInkInstanceResolved: Boolean(inkInstance),
+      });
+    }
+  }, [cancelActiveRun, clearFrameBoundaryController, inkInstance, launchContext, providerWorkspaceConfig, resetToHomeScreen, sessionState.clearEpoch, stdout.columns, terminalControl]);
 
   const handleShellExecute = useCallback((command: string) => {
     const safeCommand = sanitizeTerminalInput(command).trim();
@@ -2868,7 +3151,6 @@ export function App({ launchArgs }: AppProps) {
 
     const shellId = createEventId();
     const startTime = Date.now();
-    writeCurrentTerminalTitleBeforeStateChange("before-shell-start");
 
     const initialEvent: ShellEvent = {
       id: shellId,
@@ -2931,9 +3213,6 @@ export function App({ launchArgs }: AppProps) {
       safeCommand,
       { cwd: workspaceRoot },
       {
-        onProcessLifecycle: (event) => {
-          reassertIntendedTerminalTitle({ reason: `shell-process-${event}` });
-        },
         onStdout: (text) => {
           const lines = sanitizeTerminalLines(text.split(/\r?\n/));
           if (lines.length > 0) {
@@ -2977,9 +3256,8 @@ export function App({ launchArgs }: AppProps) {
       };
 
       dispatchSession({ type: "FINALIZE_SHELL", shellId, finalEvent });
-      forceRefreshCurrentTerminalTitle("shell_output_complete", false);
     });
-  }, [allowedWritableRoots, appendErrorEvent, dispatchSession, focusManager, forceRefreshCurrentTerminalTitle, workspaceRoot, writeCurrentTerminalTitleBeforeStateChange]);
+  }, [allowedWritableRoots, appendErrorEvent, dispatchSession, focusManager, workspaceRoot]);
 
   const handleWorkspaceRelaunch = useCallback((targetPath: string) => {
     const gate = guardWorkspaceRelaunch(busy);
@@ -3112,7 +3390,6 @@ export function App({ launchArgs }: AppProps) {
     setConversationChars((count) => count + safeProviderPrompt.length);
 
     const runId = createEventId();
-    writeCurrentTerminalTitleBeforeStateChange("before-prompt-run-start");
     perf.startSession(String(runId));
     perf.mark("dispatch_start");
     perf.setMeta("fast_cleanup", fastCleanupRun);
@@ -3239,9 +3516,6 @@ export function App({ launchArgs }: AppProps) {
           safeProviderPrompt,
           { runtime: runtimeForTurn, workspaceRoot, projectInstructions },
           {
-        onProcessLifecycle: (event) => {
-          reassertIntendedTerminalTitle({ reason: `codex-process-${event}` });
-        },
         onAssistantDelta: (chunk) => {
           const geminiBoundary = activeProviderRoute.providerId === "google";
           appDiagLog(`onAssistantDelta: provider=${activeProviderRoute.providerId} chunk.length=${chunk?.length ?? 0} isEmpty=${!chunk}`);
@@ -3304,7 +3578,6 @@ export function App({ launchArgs }: AppProps) {
           if (activity.status === "running") {
             return;
           }
-          forceRefreshCurrentTerminalTitle("tool_activity_complete", true);
           if (fastCleanupRun && !blockedCleanupFailureSurfaced) {
             const blockedCleanupFailure = getBlockedCleanupFailure(activity);
             if (blockedCleanupFailure) {
@@ -3364,7 +3637,6 @@ export function App({ launchArgs }: AppProps) {
                 const formatted = formatHollowResponse(hollow, safeResponse);
                 traceLiveRunDiagnostics("completed");
                 void finalizePromptRun(runId, turnId, "completed", undefined, formatted);
-                forceRefreshCurrentTerminalTitle("prompt_run_completed", false);
                 return;
               }
             }
@@ -3402,7 +3674,6 @@ export function App({ launchArgs }: AppProps) {
             }
             traceLiveRunDiagnostics("completed");
             void finalizePromptRun(runId, turnId, "completed", undefined, finalResponse);
-            forceRefreshCurrentTerminalTitle("prompt_run_completed", false);
           };
 
           if (flushedLiveUpdates) {
@@ -3435,7 +3706,6 @@ export function App({ launchArgs }: AppProps) {
 
             traceLiveRunDiagnostics("failed");
             void finalizePromptRun(runId, turnId, "failed", errorMessage);
-            forceRefreshCurrentTerminalTitle("prompt_run_failed", false);
           };
 
           if (flushedLiveUpdates) {
@@ -3491,8 +3761,6 @@ export function App({ launchArgs }: AppProps) {
     appendSystemEvent,
     authStatus.state,
     finalizePromptRun,
-    forceRefreshCurrentTerminalTitle,
-    writeCurrentTerminalTitleBeforeStateChange,
     mode,
     provider,
     projectInstructions,
@@ -3506,15 +3774,21 @@ export function App({ launchArgs }: AppProps) {
     if (!pendingImport) return;
     const replacements: Array<{ rawPath: string; workspaceRelativePath: string }> = [];
     for (const file of pendingImport.files) {
-      const destPath = await importExternalFile(file.srcPath, pendingImport.attachmentsDir);
-      const relPath = path.relative(workspaceRoot, destPath).replace(/\\/g, "/");
-      replacements.push({ rawPath: file.rawPath, workspaceRelativePath: relPath });
+      try {
+        const destPath = await importExternalFile(file.srcPath, pendingImport.attachmentsDir);
+        if (destPath) {
+          const relPath = path.relative(workspaceRoot, destPath).replace(/\\/g, "/");
+          replacements.push({ rawPath: file.rawPath, workspaceRelativePath: relPath });
+        }
+      } catch (err: any) {
+        appendErrorEvent("Import failed", `Could not import ${path.basename(file.srcPath)}: ${err.message}`);
+      }
     }
     const rewrittenPrompt = rewritePromptWithImportedPaths(pendingImport.prompt, replacements);
     setPendingImport(null);
     setScreen("main");
     startPromptRun(rewrittenPrompt, rewrittenPrompt, { submitTiming: createPromptRunTiming(), commitPrompt: true });
-  }, [pendingImport, workspaceRoot, startPromptRun]);
+  }, [pendingImport, workspaceRoot, startPromptRun, appendErrorEvent]);
 
   const handleImportCancel = useCallback(() => {
     if (!pendingImport) return;
@@ -3900,8 +4174,13 @@ export function App({ launchArgs }: AppProps) {
         case "diagnose_providers": {
           const lines: string[] = ["Provider CLI diagnostics:"];
           const diags = providerDiagnosticsRef.current;
-          const providerIds = ["openai", "anthropic", "google"] as const;
-          const labels: Record<string, string> = { openai: "OpenAI/Codex", anthropic: "Anthropic/Claude", google: "Google/Gemini" };
+          const providerIds = ["openai", "anthropic", "local", "antigravity"] as const;
+          const labels: Record<string, string> = {
+            openai: "OpenAI/Codex",
+            anthropic: "Anthropic/Claude",
+            local: "Local OpenAI-compatible",
+            antigravity: "Antigravity CLI",
+          };
           for (const id of providerIds) {
             const diag = diags[id];
             lines.push(`\n  ${labels[id] ?? id}:`);
@@ -4008,8 +4287,8 @@ export function App({ launchArgs }: AppProps) {
           appendSystemEvent(
             "Mouse mode updated",
             nextMouse
-              ? "SGR mouse capture on — in-app wheel scroll active. Native drag-select requires Shift (Windows Terminal). Run /mouse to disable."
-              : "SGR mouse capture off — native drag-select and native wheel scroll restored. Run /mouse to re-enable.",
+              ? "Mouse preference set to wheel mode. Main chat still uses native terminal scrollback; SGR capture is not used for transcript scrolling."
+              : "Mouse preference set to selection mode. Main chat uses native terminal scrollback and native drag-select.",
           );
           return;
         }
@@ -4051,6 +4330,10 @@ export function App({ launchArgs }: AppProps) {
           return;
         case "update": {
           const arg = commandResult.value ?? "status";
+          if (isLocalDevChannel() && arg !== "check") {
+            appendSystemEvent("Update", formatLocalDevUpdateStatus());
+            return;
+          }
           void (async () => {
             let freshResult = updateCheckResult;
             if (arg === "check" || freshResult === null) {
@@ -4058,18 +4341,22 @@ export function App({ launchArgs }: AppProps) {
                 freshResult = await checkForUpdates({ enabled: true });
                 setUpdateCheckResult(freshResult);
                 if (freshResult.status !== "error") {
-                  saveUpdateCheckCache({
-                    lastChecked: freshResult.checkedAt,
-                    currentVersion: freshResult.currentVersion,
-                    latestVersion: freshResult.latestVersion,
-                    updateAvailable: freshResult.status === "update-available",
-                  });
-                }
+                  saveUpdateCheckCache({
+                    lastChecked: freshResult.checkedAt,
+                    currentVersion: freshResult.currentVersion,
+                    latestVersion: freshResult.latestVersion,
+                    updateAvailable: freshResult.status === "update-available",
+                  });
+                }
               } catch {
                 freshResult = null;
               }
             }
-            appendSystemEvent("Update", formatUpdateInstructions(freshResult));
+            if (freshResult?.status === "update-available" && freshResult.latestVersion) {
+              setScreen("update-prompt");
+            } else {
+              appendSystemEvent("Update", formatUpdateInstructions(freshResult));
+            }
           })();
           return;
         }
@@ -4112,7 +4399,14 @@ export function App({ launchArgs }: AppProps) {
     }
 
     // Validate workspace access for normal prompts
-    const outsideViolations = findOutsideWorkspacePaths(value, workspaceRoot, allowedWritableRoots);
+    const { violations: outsideViolations, skippedExternalPaths } = findOutsideWorkspacePaths(value, workspaceRoot, allowedWritableRoots);
+
+    if (skippedExternalPaths.length > 0) {
+      for (const skipped of skippedExternalPaths) {
+        appendSystemEvent("Dependency skipped", `Skipped external dependency source: ${formatSkippedDependencyPath(skipped)}`);
+      }
+    }
+
     if (outsideViolations.length > 0) {
       if (runtimeConfig.policy.allowExternalFileImport) {
         const attachmentsDir = path.isAbsolute(runtimeConfig.policy.attachmentDir)
@@ -4202,51 +4496,12 @@ export function App({ launchArgs }: AppProps) {
     workspaceRoot,
   ]);
 
-  const modelDisplayName = useMemo(() => {
-    if (activeProviderRoute.providerId === "anthropic") {
-      const modelLabel = currentModelCapability?.label ?? activeProviderRoute.modelId;
-      return `Claude Code CLI / ${modelLabel} / reasoning: ${formatReasoningLabel(activeProviderRoute.reasoning ?? reasoningLevel)}`;
-    }
-    if (activeProviderRoute.providerId === "google" && activeProviderRoute.modelSelection) {
-      if (activeProviderRoute.modelSelection.kind === "auto") {
-        return `auto ${activeProviderRoute.modelSelection.family === "gemini-3" ? "Gemini 3" : "Gemini 2.5"}`;
-      }
-    }
-    if (activeProviderRoute.providerId === "local") {
-      return activeProviderRoute.modelId;
-    }
-    return model;
-  }, [
-    activeProviderRoute.modelId,
-    activeProviderRoute.modelSelection,
-    activeProviderRoute.providerId,
-    activeProviderRoute.reasoning,
-    currentModelCapability?.label,
-    model,
-    reasoningLevel,
-  ]);
-  const composerReasoningLevel = activeProviderRoute.providerId === "anthropic"
-    ? ""
-    : activeProviderRoute.reasoning ?? reasoningLevel;
-  const headerRuntimeSummary = useMemo(() => {
-    const contextLabel = activeContextMetadata?.contextLength != null
-      ? `${formatContextCompact(estimateTokens(conversationChars))} / ${activeContextMetadata.confidence === "estimated" ? "~" : ""}${formatContextCompact(activeContextMetadata.contextLength)}`
-      : "Unknown";
-
-    return {
-      ...runtimeSummary,
-      providerLabel: activeRouteProvider?.displayName ?? runtimeSummary.providerLabel,
-      modelLabel: modelDisplayName,
-      contextLabel,
-    };
-  }, [
-    activeContextMetadata?.confidence,
-    activeContextMetadata?.contextLength,
-    activeRouteProvider?.displayName,
-    conversationChars,
-    modelDisplayName,
-    runtimeSummary,
-  ]);
+  const modelDisplayName = activeRuntimeDisplay.modelDisplay;
+  const composerReasoningLevel = "";
+  const headerRuntimeSummary = useMemo(
+    () => runtimeDisplayToSummary(activeRuntimeDisplay, runtimeSummary),
+    [activeRuntimeDisplay, runtimeSummary],
+  );
   const effectiveHeaderConfig = useMemo<HeaderConfig>(() => ({
     ...headerConfig,
     showProvider: true,
@@ -4263,7 +4518,7 @@ export function App({ launchArgs }: AppProps) {
     if (planFlow.kind === "awaiting_action") {
       if (!hasVisibleTranscriptPlan) {
         return (
-          <Text color={activeTheme.MUTED}>
+          <Text color={activeTheme.textMuted}>
             Plan could not be displayed. Please ask Codexa to regenerate the plan.
           </Text>
         );
@@ -4286,7 +4541,7 @@ export function App({ launchArgs }: AppProps) {
           placeholder={planFlow.mode === "revise"
             ? "e.g. keep it to one file and add tests"
             : "e.g. keep it minimal and avoid touching other files"}
-          footerHint="Enter regenerate  Esc back  Backspace delete"
+          footerHint="Esc to close · Enter to confirm"
           initialValue={initialRevisionText}
           onSubmit={(value) => {
             setInitialRevisionText("");
@@ -4303,8 +4558,10 @@ export function App({ launchArgs }: AppProps) {
         uiState={uiState}
         mode={mode}
         model={modelDisplayName}
+        footerModelDisplay={activeRuntimeDisplay.footerModelDisplay}
         themeName={activeThemeName}
         reasoningLevel={composerReasoningLevel}
+        contextDisplay={activeRuntimeDisplay.contextDisplay}
         planMode={planMode}
         showBusyLoader={showBusyLoader}
         tokensUsed={estimateTokens(conversationChars)}
@@ -4339,12 +4596,14 @@ export function App({ launchArgs }: AppProps) {
     handleCancel,
     handlePlanFeedbackSubmit,
     hasVisibleTranscriptPlan,
-    activeTheme.MUTED,
+    activeTheme.textMuted,
     composerInstanceKey,
     terminalLayout,
     uiState,
     mode,
     modelDisplayName,
+    activeRuntimeDisplay.footerModelDisplay,
+    activeRuntimeDisplay.contextDisplay,
     activeThemeName,
     composerReasoningLevel,
     planMode,
@@ -4370,18 +4629,15 @@ export function App({ launchArgs }: AppProps) {
     cycleModeWithNotice,
     handleQuit,
     activeProviderRoute.providerId,
+    sessionState.externalCliStatus,
   ]);
 
   // ─── Render ──────────────────────────────────────────────────────────────────
 
-  // Plan review is shown inline in the Timeline, not as a separate overlay.
-  const mainPanelElement = null;
-
   return (
     <ThemeProvider theme={activeThemeName} customTheme={customTheme}>
-      <AppShell
+      <TranscriptShell
         layout={terminalLayout}
-        screen={screen}
         authState={authStatus.state}
         workspaceLabel={workspaceLabel}
         workspaceRoot={workspaceRoot}
@@ -4390,21 +4646,44 @@ export function App({ launchArgs }: AppProps) {
         activeEvents={activeEvents}
         uiState={uiState}
         verboseMode={verboseMode}
-        mouseCapture={mouseCapture}
-        onMouseActivity={resetMouseIdle}
-        selectionProfile={selectionProfile}
         clearCount={sessionState.clearCount}
-        headerConfig={effectiveHeaderConfig}
-        updateCheckResult={updateCheckResult}
-        panel={
-          <>
-            {screen === "backend-picker" && (
-              <BackendPicker
-                currentBackend={backend}
-                onSelect={(value) => setBackendWithNotice(value as AvailableBackend)}
-                onCancel={() => setScreen("main")}
-              />
-            )}
+        repaintGeneration={staticRepaintGeneration}
+        composer={composerElement}
+        composerRows={composerRows}
+        visible={screen === "main"}
+      />
+
+      {screen !== "main" && (
+        <AppShell
+          layout={terminalLayout}
+          screen={screen}
+          authState={authStatus.state}
+          workspaceLabel={workspaceLabel}
+          workspaceRoot={workspaceRoot}
+          runtimeSummary={headerRuntimeSummary}
+          staticEvents={staticEvents}
+          activeEvents={activeEvents}
+          uiState={uiState}
+          verboseMode={verboseMode}
+          mouseCapture={effectiveMouseCapture}
+          onMouseActivity={resetMouseIdle}
+          selectionProfile={selectionProfile}
+          clearCount={sessionState.clearCount}
+          headerConfig={effectiveHeaderConfig}
+          updateAvailable={
+            updateCheckResult?.status === "update-available" && updateCheckResult.latestVersion
+              ? { latestVersion: updateCheckResult.latestVersion, currentVersion: updateCheckResult.currentVersion }
+              : null
+          }
+          panel={
+            <>
+              {screen === "backend-picker" && (
+                <BackendPicker
+                  currentBackend={backend}
+                  onSelect={(value) => setBackendWithNotice(value as AvailableBackend)}
+                  onCancel={() => setScreen("main")}
+                />
+              )}
 
             {screen === "provider-picker" && (
               <ProviderPicker
@@ -4557,7 +4836,7 @@ export function App({ launchArgs }: AppProps) {
                 subtitle="Enter an absolute path or a path relative to the locked workspace."
                 placeholder="relative\\or\\absolute\\path"
                 inputLabel="Path"
-                footerHint="Enter save  Esc cancel  Backspace delete"
+                footerHint="Esc to close · Enter to confirm"
                 onSubmit={(value) => {
                   if (!value.trim()) {
                     appendSystemEvent("Runtime policy", "Writable root path cannot be empty.");
@@ -4644,18 +4923,29 @@ export function App({ launchArgs }: AppProps) {
                 onCancel={handleImportCancel}
               />
             )}
-          </>
-        }
-        mainPanel={null}
-        mainPanelMode="viewport"
-        composer={composerElement}
-        composerRows={composerRows}
-        panelHint={screen !== "main" && screen !== "model-picker" ? (
-          <Box marginTop={1} paddingX={1}>
-            <Text color={activeTheme.DIM}>Close the active panel with Esc to return to the composer.</Text>
-          </Box>
-        ) : null}
-      />
+
+            {screen === "update-prompt" && updateCheckResult?.status === "update-available" && updateCheckResult.latestVersion && (
+              <UpdatePromptPanel
+                focusId={FOCUS_IDS.updatePrompt}
+                currentVersion={updateCheckResult.currentVersion}
+                latestVersion={updateCheckResult.latestVersion}
+                onSkip={handleSkipUpdateForSession}
+                onSkipUntilNextVersion={handleSkipUpdateVersion}
+              />
+            )}
+            </>
+          }
+          mainPanel={null}
+          mainPanelMode="viewport"
+          composer={composerElement}
+          composerRows={composerRows}
+          panelHint={screen !== "model-picker" ? (
+            <Box marginTop={1} paddingX={1}>
+              <Text color={activeTheme.textDim}>Close the active panel with Esc to return to the composer.</Text>
+            </Box>
+          ) : null}
+        />
+      )}
     </ThemeProvider>
   );
 }