@golba98/codexa 1.0.3 → 1.0.5

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,39 @@ 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 === "mistral") return "Mistral Vibe CLI";
+  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 {
@@ -77,9 +110,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,
@@ -87,8 +120,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,
@@ -99,32 +132,35 @@ import {
   normalizeReasoningForModelCapabilities,
   type CodexModelCapabilities,
 } from "./core/models/codexModelCapabilities.js";
+import { loadSeededCodexCapabilities } from "./core/models/codexModelsCacheSeed.js";
 import {
   buildDevLaunchNotice,
   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 {
-  formatContextCompact,
-  formatContextLength,
-  resolveModelContextLength,
-  type ModelContextMetadata,
+} from "./core/workspace/workspaceGuard.js";
+import {
+  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";
@@ -137,11 +173,18 @@ import {
   getProviderRuntime,
   isProviderRouteConfigured,
   isProviderRoutableInCodexa,
+  persistProviderDiscovery,
   resolveActiveProviderRoute,
   validateProviderRouteActivation,
 } from "./core/providerRuntime/registry.js";
 import { hasGeminiApiKey, runGeminiDiagnostics } from "./core/providerRuntime/gemini.js";
 import { checkLocalProvider, runLocalDiagnostics, setLocalProviderConfig } from "./core/providerRuntime/local.js";
+import {
+  detectVibeActiveModel,
+  launchMistralVibeCli,
+  resetMistralVibeSession,
+  resolveVibeExecutable,
+} from "./core/providerRuntime/mistralVibe.js";
 import { validateAnthropicRoute, ANTHROPIC_ROUTE_SETUP_MESSAGE } from "./core/providerRuntime/anthropic.js";
 import { providerModelsToCodexCapabilities } from "./core/providerRuntime/models.js";
 import {
@@ -154,16 +197,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 {
@@ -174,7 +214,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,
@@ -198,25 +238,25 @@ import {
   submitPlanFeedback,
   type PlanFlowState,
 } from "./session/planFlow.js";
-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 { ModelPickerScreen } from "./ui/ModelPickerScreen.js";
-import { ModePicker } from "./ui/ModePicker.js";
-import { PlanActionPicker, type PlanActionValue, measurePlanActionPickerRows } from "./ui/PlanActionPicker.js";
-import { PermissionsPanel, type PermissionsPanelAction } from "./ui/PermissionsPanel.js";
-import { ProviderPicker } from "./ui/ProviderPicker.js";
-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 { AuthPanel } from "./ui/panels/AuthPanel.js";
+import { BackendPicker } from "./ui/panels/BackendPicker.js";
+import { measureBottomComposerRows, MemoizedBottomComposer } from "./ui/chrome/BottomComposer.js";
+import { resolveStartupHeaderMode, useTerminalViewport } from "./ui/layout.js";
+import { ModelPickerScreen } from "./ui/panels/ModelPickerScreen.js";
+import { ModePicker } from "./ui/panels/ModePicker.js";
+import { PlanActionPicker, type PlanActionValue, measurePlanActionPickerRows } from "./ui/panels/PlanActionPicker.js";
+import { PermissionsPanel, type PermissionsPanelAction } from "./ui/panels/PermissionsPanel.js";
+import { ProviderPicker } from "./ui/panels/ProviderPicker.js";
+import { ReasoningPicker } from "./ui/panels/ReasoningPicker.js";
+import { AttachmentImportPanel, type PendingImportFile } from "./ui/panels/AttachmentImportPanel.js";
+import { SelectionPanel } from "./ui/panels/SelectionPanel.js";
+import { SettingsPanel } from "./ui/panels/SettingsPanel.js";
+import { UpdatePromptPanel } from "./ui/panels/UpdatePromptPanel.js";
+import { measureTextEntryPanelRows, TextEntryPanel } from "./ui/panels/TextEntryPanel.js";
+import { ThemePicker } from "./ui/panels/ThemePicker.js";
+import { getFocusTargetForScreen, FOCUS_IDS } from "./ui/input/focus.js";
+import { ThemeProvider, THEMES } from "./ui/theme.js";
+import { buildActiveRuntimeDisplay, runtimeDisplayToSummary } from "./ui/render/runtimeDisplay.js";
 import {
   cancelThemeSelection,
   commitThemeSelection,
@@ -226,9 +266,11 @@ import {
   type ThemeSelectionState,
 } from "./ui/themeFlow.js";
 import { isBusy as isUiBusy } from "./session/types.js";
-import { AppShell } from "./ui/AppShell.js";
-import { checkForUpdates, formatLocalDevUpdateStatus, formatUpdateInstructions, shouldRunStartupUpdateCheck, type UpdateCheckResult } from "./core/updateCheck.js";
-import { isLocalDevChannel } from "./core/channel.js";
+import { AppShell } from "./ui/chrome/AppShell.js";
+import { TranscriptShell } from "./ui/timeline/TranscriptShell.js";
+import type { RuntimeAvailability } from "./ui/chrome/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 +302,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",
@@ -324,6 +411,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 ────────────────────────────────────────────────────────────
 
@@ -375,17 +468,60 @@ 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
   const [conversationChars, setConversationChars] = useState(0);
-  const [modelCapabilities, setModelCapabilities] = useState<CodexModelCapabilities | null>(null);
+  // Seeded synchronously from local caches (codex's models_cache.json or the
+  // persisted last-good discovery) so the model picker opens instantly with
+  // real models; live discovery replaces this in the background.
+  const [modelCapabilities, setModelCapabilities] = useState<CodexModelCapabilities | null>(() => loadSeededCodexCapabilities());
   const [modelCapabilitiesBusy, setModelCapabilitiesBusy] = useState(false);
+  // True while a provider route switch is validating (subprocess probes);
+  // drives the model picker's loading state for non-openai providers.
+  const [routeSwitchBusy, setRouteSwitchBusy] = useState(false);
   const [activeContextMetadata, setActiveContextMetadata] = useState<ModelContextMetadata | null>(null);
   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);
@@ -395,9 +531,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(() => {
@@ -409,26 +550,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);
@@ -447,7 +633,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 =
@@ -487,6 +673,7 @@ export function App({ launchArgs }: AppProps) {
       setLocalProviderConfig(providerWorkspaceConfig.providers?.local);
       return buildProviderRegistry({
         activeModel: model,
+        workspaceRoot,
         workspaceConfig: providerWorkspaceConfig,
         diagnostics: providerDiagnosticsRef.current,
         routeErrors: providerRouteErrorsRef.current,
@@ -496,13 +683,38 @@ export function App({ launchArgs }: AppProps) {
     // updates mutate providerDiagnosticsRef/providerRouteErrorsRef (refs, not state)
     // and then increment the nonce to trigger a re-read of those refs.
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [model, providerWorkspaceConfig, registryNonce],
+    [model, providerWorkspaceConfig, registryNonce, workspaceRoot],
   );
   const workspaceDefaultProvider = useMemo(
     () => providerRegistry.find((provider) => provider.isDefault) ?? providerRegistry[0] ?? null,
     [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(() => {
@@ -521,7 +733,10 @@ export function App({ launchArgs }: AppProps) {
   const modelPickerDiscovery = useMemo(() => {
     if (modelPickerProviderId === "openai") return null;
     return discoverProviderModels(modelPickerProviderId);
-  }, [modelPickerProviderId]);
+    // registryNonce is intentionally included: route validation discovers models
+    // as a side effect and bumps the nonce so an open picker re-reads them.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [modelPickerProviderId, registryNonce]);
   const providerModelCapabilities = useMemo(() => {
     if (!modelPickerDiscovery) return null;
     return providerModelsToCodexCapabilities(modelPickerDiscovery.models, activeProviderRoute.modelId);
@@ -736,17 +951,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>(() => ({
@@ -768,22 +972,73 @@ export function App({ launchArgs }: AppProps) {
     [planFlow],
   );
 
-  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 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"),
@@ -808,63 +1063,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(() => {
@@ -898,9 +1105,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,
@@ -909,8 +1166,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,
@@ -1189,13 +1449,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") {
@@ -1328,6 +1587,9 @@ export function App({ launchArgs }: AppProps) {
           providerRouteErrorsRef.current["anthropic"] = result.message ?? ANTHROPIC_ROUTE_SETUP_MESSAGE;
         } else {
           delete providerRouteErrorsRef.current["anthropic"];
+          // Persist the freshly discovered catalog so newly released Claude
+          // models replace the stale on-disk cache without a manual refresh.
+          persistProviderDiscovery(discoverProviderModels("anthropic"));
         }
       } catch {
         // Best-effort probe — failures are surfaced only when the user activates the route.
@@ -1343,6 +1605,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>;
@@ -1362,13 +1625,6 @@ 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;
@@ -1619,11 +1875,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,
@@ -1638,9 +1889,7 @@ export function App({ launchArgs }: AppProps) {
     persistActiveRoute,
     persistProviderDefaultModelAndReasoning,
     providerWorkspaceConfig.activeRoute,
-    terminalTitleMode,
     updateRuntimeConfig,
-    workspaceRoot,
   ]);
 
   const setPlanModeWithNotice = useCallback((nextEnabled: boolean) => {
@@ -1718,11 +1967,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({
@@ -1771,6 +2015,12 @@ export function App({ launchArgs }: AppProps) {
     }
 
     modelSelectionInFlightRef.current = true;
+    // Reflect the target provider in the model picker immediately: route
+    // validation below can take seconds (subprocess probes), and until it
+    // persists the new active route, modelPickerProviderId would otherwise
+    // keep resolving to the stale route.
+    setPendingRouteProviderId(providerId);
+    setRouteSwitchBusy(true);
     traceInputDebug("model_selection_app_start", getInputDebugSnapshot({
       handler: "setModelAndReasoningWithNotice",
       model: nextModel,
@@ -1779,11 +2029,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,
@@ -1802,8 +2052,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({
@@ -1841,6 +2090,10 @@ export function App({ launchArgs }: AppProps) {
         model: nextModel,
         reasoningLevel: normalizedReasoning,
       }));
+      if (providerId === "mistral" && activeProviderRoute.providerId !== "mistral") {
+        // Switching to Vibe starts a fresh CLI conversation instead of resuming a stale one.
+        resetMistralVibeSession(workspaceRoot);
+      }
       persistActiveRoute(providerId, nextModel, normalizedReasoning, validation.backendKind, geminiSelection);
       setPendingRouteProviderId(null);
       traceInputDebug("model_selection_app_success", getInputDebugSnapshot({
@@ -1850,11 +2103,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({
@@ -1863,13 +2111,14 @@ export function App({ launchArgs }: AppProps) {
         reasoning: nextReasoning,
         error: message,
       }));
+      setPendingRouteProviderId(null);
       appendErrorEvent("Model selection failed", message);
-      forceRefreshCurrentTerminalTitle("model_selection_failed", false);
     } finally {
+      setRouteSwitchBusy(false);
       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);
@@ -1898,11 +2147,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) {
@@ -2059,7 +2303,11 @@ export function App({ launchArgs }: AppProps) {
   }, [appendSystemEvent, busy]);
 
   const openProviderPicker = useCallback(() => {
-    setPendingRouteProviderId(null);
+    // Mid route switch, keep the pending id so initialProviderId highlights
+    // the provider being activated instead of the stale route.
+    if (!modelSelectionInFlightRef.current) {
+      setPendingRouteProviderId(null);
+    }
     const gate = guardConfigMutation("backend", busy);
     if (!gate.allowed) {
       appendSystemEvent("Busy", gate.message ?? "Finish the current run before opening providers.");
@@ -2067,6 +2315,32 @@ export function App({ launchArgs }: AppProps) {
     }
 
     setScreen("provider-picker");
+    providerDiagnosticsRef.current.mistral = {
+      ...providerDiagnosticsRef.current.mistral,
+      selectedModel: detectVibeActiveModel({ cwd: workspaceRoot }).modelId,
+      availabilityStatus: "checking",
+    };
+    void resolveVibeExecutable({ cwd: workspaceRoot }).then((resolvedCommand) => {
+      if (!isMountedRef.current) return;
+      const modelDetection = detectVibeActiveModel({ cwd: workspaceRoot });
+      providerDiagnosticsRef.current.mistral = {
+        resolvedCommand,
+        selectedModel: modelDetection.modelId,
+        modelSource: modelDetection.source,
+        configPath: modelDetection.configPath,
+        availabilityStatus: resolvedCommand ? "available" : "unavailable",
+      };
+      setRegistryNonce((n) => n + 1);
+    }).catch(() => {
+      if (!isMountedRef.current) return;
+      providerDiagnosticsRef.current.mistral = {
+        selectedModel: detectVibeActiveModel({ cwd: workspaceRoot }).modelId,
+        resolvedCommand: null,
+        availabilityStatus: "unavailable",
+      };
+      setRegistryNonce((n) => n + 1);
+    });
+    markProviderAvailability("local", "checking", "provider-picker-open");
     void checkLocalProvider({ override: providerWorkspaceConfig.providers?.local }).then((result) => {
       if (!isMountedRef.current) return;
       if (result.diagnostics) {
@@ -2079,7 +2353,7 @@ export function App({ launchArgs }: AppProps) {
       }
       setRegistryNonce((n) => n + 1);
     }).catch(() => undefined);
-  }, [appendSystemEvent, busy, providerWorkspaceConfig.providers]);
+  }, [appendSystemEvent, busy, markProviderAvailability, providerWorkspaceConfig.providers, workspaceRoot]);
 
   const setWorkspaceDefaultProviderWithNotice = useCallback((providerId: ProviderId) => {
     const provider = findProvider(providerRegistry, providerId);
@@ -2096,7 +2370,9 @@ export function App({ launchArgs }: AppProps) {
       const routeConfigured = isProviderRouteConfigured(providerId);
       appendSystemEvent(
         "Provider default updated",
-        provider.routeMode === "in-codexa" && routeConfigured
+        provider.routeMode === "launch-only"
+          ? `${provider.displayName} is now the workspace default external CLI. Active chat route remains ${activeRouteProvider?.displayName ?? "OpenAI"} / ${model}.`
+          : provider.routeMode === "in-codexa" && routeConfigured
           ? `${provider.displayName} is now the workspace default provider. Active chat route remains ${activeRouteProvider?.displayName ?? "OpenAI"} / ${model}.`
           : `${provider.displayName} is set as the workspace default, but in-Codexa routing is not configured yet. Active chat route remains ${activeRouteProvider?.displayName ?? "OpenAI"} / ${model}.`,
       );
@@ -2138,6 +2414,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) {
@@ -2247,10 +2524,14 @@ 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,
           }).then((discovery) => {
+            persistProviderDiscovery(discovery);
             if (discovery.diagnostics) {
               providerDiagnosticsRef.current[providerId] = discovery.diagnostics as Record<string, string | number | boolean | null>;
             }
@@ -2342,10 +2623,10 @@ export function App({ launchArgs }: AppProps) {
     setScreen("main");
     appendSystemEvent(
       "Provider launch",
-      `Suspending Codexa and launching ${provider.displayName}. Codexa will resume when the external CLI exits.`,
+      `Suspending Codexa and launching ${provider.displayName}${providerId === "mistral" ? ` / ${provider.currentModel}` : ""}. Codexa will resume when the external CLI exits.`,
     );
 
-    void launchProviderCli(provider, {
+    const launchOptions = {
       cwd: workspaceRoot,
       stdin,
       beforeLaunch: () => {
@@ -2353,12 +2634,20 @@ 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) => {
+    };
+    const launchPromise = providerId === "mistral"
+      ? launchMistralVibeCli(provider, launchOptions)
+      : launchProviderCli(provider, launchOptions);
+
+    void launchPromise.then((result) => {
       if (!isMountedRef.current) return;
-      appendSystemEvent("Provider launch", result.message);
+      if (providerId === "mistral" && (result.status === "missing-command" || result.status === "spawn-error")) {
+        appendErrorEvent("Mistral Vibe launch failed", result.message);
+      } else {
+        appendSystemEvent("Provider launch", result.message);
+      }
     }).catch((error) => {
       if (!isMountedRef.current) return;
       const message = error instanceof Error ? error.message : "Provider launch failed.";
@@ -2368,10 +2657,10 @@ export function App({ launchArgs }: AppProps) {
     activeProviderRoute,
     appendErrorEvent,
     appendSystemEvent,
-    forceRefreshCurrentTerminalTitle,
-    mouseCapture,
+    effectiveMouseCapture,
     providerRegistry,
     providerWorkspaceConfig.providers,
+    markProviderAvailability,
     modelCapabilities,
     reasoningLevel,
     refreshModelCapabilities,
@@ -2385,7 +2674,11 @@ export function App({ launchArgs }: AppProps) {
   ]);
 
   const openModelPicker = useCallback(() => {
-    setPendingRouteProviderId(null);
+    // While a route switch is validating, keep the pending id so the picker
+    // shows the target provider instead of snapping back to the stale route.
+    if (!modelSelectionInFlightRef.current) {
+      setPendingRouteProviderId(null);
+    }
     traceInputDebug("model_picker_open_request", getInputDebugSnapshot({
       handler: "openModelPicker",
       currentScreen: screen,
@@ -2573,6 +2866,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,
@@ -2884,23 +3189,37 @@ 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;
+    resetMistralVibeSession(workspaceRoot);
     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, workspaceRoot]);
 
   const handleShellExecute = useCallback((command: string) => {
     const safeCommand = sanitizeTerminalInput(command).trim();
@@ -2912,7 +3231,6 @@ export function App({ launchArgs }: AppProps) {
 
     const shellId = createEventId();
     const startTime = Date.now();
-    writeCurrentTerminalTitleBeforeStateChange("before-shell-start");
 
     const initialEvent: ShellEvent = {
       id: shellId,
@@ -2975,9 +3293,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) {
@@ -3021,9 +3336,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);
@@ -3156,7 +3470,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);
@@ -3283,9 +3596,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}`);
@@ -3348,7 +3658,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) {
@@ -3408,7 +3717,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;
               }
             }
@@ -3446,7 +3754,6 @@ export function App({ launchArgs }: AppProps) {
             }
             traceLiveRunDiagnostics("completed");
             void finalizePromptRun(runId, turnId, "completed", undefined, finalResponse);
-            forceRefreshCurrentTerminalTitle("prompt_run_completed", false);
           };
 
           if (flushedLiveUpdates) {
@@ -3479,7 +3786,6 @@ export function App({ launchArgs }: AppProps) {
 
             traceLiveRunDiagnostics("failed");
             void finalizePromptRun(runId, turnId, "failed", errorMessage);
-            forceRefreshCurrentTerminalTitle("prompt_run_failed", false);
           };
 
           if (flushedLiveUpdates) {
@@ -3535,8 +3841,6 @@ export function App({ launchArgs }: AppProps) {
     appendSystemEvent,
     authStatus.state,
     finalizePromptRun,
-    forceRefreshCurrentTerminalTitle,
-    writeCurrentTerminalTitleBeforeStateChange,
     mode,
     provider,
     projectInstructions,
@@ -3550,15 +3854,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;
@@ -3944,8 +4254,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}:`);
@@ -4052,8 +4367,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;
         }
@@ -4164,7 +4479,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)
@@ -4254,19 +4576,19 @@ export function App({ launchArgs }: AppProps) {
     workspaceRoot,
   ]);
 
-  const modelDisplayName = activeRuntimeDisplay.modelDisplay;
-  const composerReasoningLevel = "";
-  const headerRuntimeSummary = useMemo(
-    () => runtimeDisplayToSummary(activeRuntimeDisplay, runtimeSummary),
-    [activeRuntimeDisplay, runtimeSummary],
-  );
-  const effectiveHeaderConfig = useMemo<HeaderConfig>(() => ({
-    ...headerConfig,
-    showProvider: true,
-    showModel: false,
-    showReasoning: false,
-    showContext: false,
-  }), [headerConfig]);
+  const modelDisplayName = activeRuntimeDisplay.modelDisplay;
+  const composerReasoningLevel = "";
+  const headerRuntimeSummary = useMemo(
+    () => runtimeDisplayToSummary(activeRuntimeDisplay, runtimeSummary),
+    [activeRuntimeDisplay, runtimeSummary],
+  );
+  const effectiveHeaderConfig = useMemo<HeaderConfig>(() => ({
+    ...headerConfig,
+    showProvider: true,
+    showModel: false,
+    showReasoning: false,
+    showContext: false,
+  }), [headerConfig]);
 
   // Memoize the composer element so AppShell's memo check (prev.composer ===
   // next.composer) passes during streaming. Without this, a new JSX element is
@@ -4299,7 +4621,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("");
@@ -4313,14 +4635,14 @@ export function App({ launchArgs }: AppProps) {
       <MemoizedBottomComposer
         key={composerInstanceKey}
         layout={terminalLayout}
-        uiState={uiState}
-        mode={mode}
-        model={modelDisplayName}
-        footerModelDisplay={activeRuntimeDisplay.footerModelDisplay}
-        themeName={activeThemeName}
-        reasoningLevel={composerReasoningLevel}
-        contextDisplay={activeRuntimeDisplay.contextDisplay}
-        planMode={planMode}
+        uiState={uiState}
+        mode={mode}
+        model={modelDisplayName}
+        footerModelDisplay={activeRuntimeDisplay.footerModelDisplay}
+        themeName={activeThemeName}
+        reasoningLevel={composerReasoningLevel}
+        contextDisplay={activeRuntimeDisplay.contextDisplay}
+        planMode={planMode}
         showBusyLoader={showBusyLoader}
         tokensUsed={estimateTokens(conversationChars)}
         modelSpec={currentModelSpec}
@@ -4358,11 +4680,11 @@ export function App({ launchArgs }: AppProps) {
     composerInstanceKey,
     terminalLayout,
     uiState,
-    mode,
-    modelDisplayName,
-    activeRuntimeDisplay.footerModelDisplay,
-    activeRuntimeDisplay.contextDisplay,
-    activeThemeName,
+    mode,
+    modelDisplayName,
+    activeRuntimeDisplay.footerModelDisplay,
+    activeRuntimeDisplay.contextDisplay,
+    activeThemeName,
     composerReasoningLevel,
     planMode,
     showBusyLoader,
@@ -4385,21 +4707,17 @@ export function App({ launchArgs }: AppProps) {
     togglePlanModeWithNotice,
     handleClear,
     cycleModeWithNotice,
-    handleQuit,
-    activeProviderRoute.providerId,
-    sessionState.externalCliStatus,
-  ]);
+    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}
@@ -4408,25 +4726,44 @@ export function App({ launchArgs }: AppProps) {
         activeEvents={activeEvents}
         uiState={uiState}
         verboseMode={verboseMode}
-        mouseCapture={mouseCapture}
-        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")}
-              />
-            )}
+        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
@@ -4448,7 +4785,8 @@ export function App({ launchArgs }: AppProps) {
                 currentModel={modelPickerCurrentModel}
                 currentReasoning={modelPickerCurrentReasoning}
                 activeProviderLabel={modelPickerProviderLabel}
-                isLoading={modelPickerProviderId === "openai" && modelCapabilitiesBusy && modelPickerModels.length === 0}
+                isLoading={modelPickerModels.length === 0
+                  && ((modelPickerProviderId === "openai" && modelCapabilitiesBusy) || routeSwitchBusy)}
                 emptyMessage={modelPickerEmptyMessage}
                 onSelect={(m, r, geminiSelection) => {
                   if (pendingRouteProviderId && pendingRouteProviderId !== activeProviderRoute.providerId) {
@@ -4579,7 +4917,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.");
@@ -4676,18 +5014,19 @@ export function App({ launchArgs }: AppProps) {
                 onSkipUntilNextVersion={handleSkipUpdateVersion}
               />
             )}
-          </>
-        }
-        mainPanel={null}
-        mainPanelMode="viewport"
-        composer={composerElement}
-        composerRows={composerRows}
-        panelHint={screen !== "main" && 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}
-      />
+            </>
+          }
+          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>
   );
 }