@golba98/codexa 1.0.3 → 1.0.5

package/src/core/{workspaceGuard.ts → workspace/workspaceGuard.ts}

@@ -3,19 +3,41 @@ import { normalizeWorkspaceRoot } from "./workspaceRoot.js";
 
 type PathStyle = "windows" | "posix";
 
+export function normalizeDiagnosticPath(filePath: string): string {
+  let pathPart = filePath;
+  let drivePrefix = "";
+
+  if (/^[A-Za-z]:[\\/]/.test(filePath)) {
+    drivePrefix = filePath.slice(0, 2);
+    pathPart = filePath.slice(2);
+  }
+
+  // Robustly strip trailing colon-separated line/column numbers.
+  // Handles:
+  //   path/to/file.rs:109:12
+  //   path/to/file.rs:109
+  //   C:\path\to\file.rs:12:5
+  const diagnosticSuffixRegex = /:(\d+)(?::(\d+))?$/;
+  pathPart = pathPart.replace(diagnosticSuffixRegex, "");
+
+  return drivePrefix + pathPart;
+}
+
 export interface WorkspacePathViolation {
   rawPath: string;
   normalizedPath: string;
 }
 
 const QUOTED_ABSOLUTE_PATH_PATTERN =
-  /(["'`])((?:[A-Za-z]:[\\/]|\\\\[^\\/\r\n]+[\\/][^\\/\r\n]+[\\/]|\/)[^"'`\r\n]+?)\1/g;
+  /(["'`])((?:[A-Za-z]:[\\/]|\\\\[^\\/\r\n]+[\\/][^\\/\r\n]+[\\/]|\/|~\/)[^"'`\r\n]+?)\1/g;
 const QUOTED_RELATIVE_PATH_PATTERN = /(["'`])((?:\.\.?[\\/])[^"'`\r\n]+?)\1/g;
 const WINDOWS_DRIVE_PATH_PATTERN = /(?:^|[\s([{\],;=])([A-Za-z]:[\\/][^\s"'`<>|]+)/g;
 const WINDOWS_UNC_PATH_PATTERN =
   /(?:^|[\s([{\],;=])(\\\\[^\\/\s"'`<>|]+[\\/][^\\/\s"'`<>|]+(?:[\\/][^\s"'`<>|]+)*)/g;
-const POSIX_ABSOLUTE_PATH_PATTERN = /(?:^|[\s([{\],;=])(\/(?:[^\/\s"'`<>|]+\/)+[^\s"'`<>|]+)/g;
+const POSIX_ABSOLUTE_PATH_PATTERN = /(?:^|[\s([{\],;=])((?:\/|~\/)(?:[^\/\s"'`<>|]+\/)+[^\s"'`<>|]+)/g;
 const RELATIVE_PATH_PATTERN = /(?:^|[\s([{\],;=])((?:\.\.?[\\/])(?:[^\s"'`<>|]+(?:[\\/][^\s"'`<>|]+)*))/g;
+const RUST_RELATIVE_DIAGNOSTIC_PATH_PATTERN =
+  /(?:^|[\s([{\],;=])((?:[A-Za-z0-9_.-]+[\\/])+[A-Za-z0-9_.-]+\.rs(?::\d+(?::\d+)?)?)/g;
 const TRAILING_PUNCTUATION_PATTERN = /[),.;:\]}]+$/;
 const DIRECTORY_NAVIGATION_PATTERN = /(?:^|[;&\n]|&&|\|\|)\s*(cd|pushd|set-location)\b/i;
 
@@ -24,7 +46,7 @@ function detectPathStyle(pathValue: string): PathStyle | null {
     return "windows";
   }
 
-  if (pathValue.startsWith("/")) {
+  if (pathValue.startsWith("/") || pathValue.startsWith("~/")) {
     return "posix";
   }
 
@@ -47,6 +69,42 @@ function isExplicitRelativePath(pathValue: string): boolean {
   return /^(?:\.\.?[\\/])/.test(pathValue);
 }
 
+function hasRustRelativeDiagnosticShape(pathValue: string): boolean {
+  return /^(?:[A-Za-z0-9_.-]+[\\/])+[A-Za-z0-9_.-]+\.rs(?::\d+(?::\d+)?)?$/.test(pathValue);
+}
+
+function normalizedPathSegments(pathValue: string): string[] {
+  return normalizeDiagnosticPath(pathValue)
+    .replace(/\\/g, "/")
+    .split("/")
+    .filter(Boolean)
+    .map((segment) => segment.toLowerCase());
+}
+
+export function isSkippedExternalDependencyPath(pathValue: string): boolean {
+  const segments = normalizedPathSegments(pathValue);
+
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    const next = segments[i + 1];
+    const afterNext = segments[i + 2];
+
+    if (segment === ".cargo" && next === "registry") return true;
+    if (segment === ".cargo" && next === "git" && afterNext === "checkouts") return true;
+    if (
+      segment === "target" ||
+      segment === "node_modules" ||
+      segment === ".pnpm-store" ||
+      segment === ".npm" ||
+      segment === ".cache"
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 function normalizeAbsolutePath(pathValue: string, style: PathStyle): string {
   const pathApi = getPathApi(style);
   const resolved = pathApi.normalize(pathApi.resolve(pathValue));
@@ -149,7 +207,7 @@ export function extractExplicitPathReferences(text: string): string[] {
 
   const addMatch = (candidate: string) => {
     const cleaned = stripTrailingPunctuation(stripWrappingQuotes(candidate.trim()));
-    if (!cleaned || (!detectPathStyle(cleaned) && !isExplicitRelativePath(cleaned))) {
+    if (!cleaned || (!detectPathStyle(cleaned) && !isExplicitRelativePath(cleaned) && !hasRustRelativeDiagnosticShape(cleaned))) {
       return;
     }
 
@@ -169,6 +227,7 @@ export function extractExplicitPathReferences(text: string): string[] {
     WINDOWS_UNC_PATH_PATTERN,
     POSIX_ABSOLUTE_PATH_PATTERN,
     RELATIVE_PATH_PATTERN,
+    RUST_RELATIVE_DIAGNOSTIC_PATH_PATTERN,
   ]) {
     pattern.lastIndex = 0;
     let match = pattern.exec(text);
@@ -181,24 +240,49 @@ export function extractExplicitPathReferences(text: string): string[] {
   return matches;
 }
 
+export function formatSkippedDependencyPath(pathValue: string): string {
+  const parts = pathValue.replace(/\\/g, "/").split("/");
+  const registryIndex = parts.indexOf("registry");
+  if (registryIndex !== -1 && parts[registryIndex + 1] === "src" && parts[registryIndex + 2]?.includes("index.crates.io")) {
+    return parts.slice(registryIndex + 3).join("/");
+  }
+  const gitIndex = parts.indexOf("git");
+  if (gitIndex !== -1 && parts[gitIndex + 1] === "checkouts") {
+    return parts.slice(gitIndex + 2).join("/");
+  }
+  return parts[parts.length - 1] ?? pathValue;
+}
+
 export function findOutsideWorkspacePaths(
   text: string,
   workspaceRoot: string,
   allowedRoots: readonly string[] = [],
-): WorkspacePathViolation[] {
+): { violations: WorkspacePathViolation[]; skippedExternalPaths: string[] } {
   const violations: WorkspacePathViolation[] = [];
+  const skippedExternalPaths: string[] = [];
   const seen = new Set<string>();
   const workspaceStyle = detectPathStyle(workspaceRoot) ?? "windows";
 
   for (const rawPath of extractExplicitPathReferences(text)) {
-    if (isPathInsideAllowedRoots(rawPath, workspaceRoot, allowedRoots)) {
+    const cleanPath = normalizeDiagnosticPath(rawPath);
+    if (isSkippedExternalDependencyPath(cleanPath)) {
+      skippedExternalPaths.push(cleanPath);
+      continue;
+    }
+
+    if (isPathInsideAllowedRoots(cleanPath, workspaceRoot, allowedRoots)) {
+      continue;
+    }
+
+    const explicitStyle = detectPathStyle(cleanPath) ?? workspaceStyle;
+    const normalizedPath = detectPathStyle(cleanPath)
+      ? normalizeAbsolutePath(cleanPath, explicitStyle)
+      : resolveWorkspacePath(cleanPath, workspaceRoot);
+    if (isSkippedExternalDependencyPath(normalizedPath)) {
+      skippedExternalPaths.push(normalizedPath);
       continue;
     }
 
-    const explicitStyle = detectPathStyle(rawPath) ?? workspaceStyle;
-    const normalizedPath = detectPathStyle(rawPath)
-      ? normalizeAbsolutePath(rawPath, explicitStyle)
-      : resolveWorkspacePath(rawPath, workspaceRoot);
     const comparisonKey = explicitStyle === "windows" ? normalizedPath.toLowerCase() : normalizedPath;
 
     if (seen.has(comparisonKey)) {
@@ -209,7 +293,7 @@ export function findOutsideWorkspacePaths(
     violations.push({ rawPath, normalizedPath });
   }
 
-  return violations;
+  return { violations, skippedExternalPaths };
 }
 
 export function containsDirectoryNavigationCommand(command: string): boolean {
@@ -248,7 +332,7 @@ export function getPromptWorkspaceGuardMessage(
   workspaceRoot: string,
   allowedRoots: readonly string[] = [],
 ): string | null {
-  const violations = findOutsideWorkspacePaths(prompt, workspaceRoot, allowedRoots);
+  const { violations } = findOutsideWorkspacePaths(prompt, workspaceRoot, allowedRoots);
   if (violations.length === 0) {
     return null;
   }
@@ -274,7 +358,7 @@ export function getShellWorkspaceGuardMessage(
     ].join("\n");
   }
 
-  const violations = findOutsideWorkspacePaths(command, workspaceRoot, allowedRoots);
+  const { violations } = findOutsideWorkspacePaths(command, workspaceRoot, allowedRoots);
   if (violations.length === 0) {
     return null;
   }

package/src/headless/execRunner.ts

@@ -8,12 +8,12 @@ import {
   resolveRuntimeConfig,
   type ResolvedRuntimeConfig,
 } from "../config/runtimeConfig.js";
-import { loadProjectInstructions, type ProjectInstructionsLoadResult } from "../core/projectInstructions.js";
+import { loadProjectInstructions, type ProjectInstructionsLoadResult } from "../core/workspace/projectInstructions.js";
 import { getBackendProvider } from "../core/providers/registry.js";
 import type { BackendProvider } from "../core/providers/types.js";
 import { isNoiseLine } from "../core/providers/codexTranscript.js";
 import { sanitizeTerminalOutput } from "../core/terminal/terminalSanitize.js";
-import { resolveWorkspaceRoot } from "../core/workspaceRoot.js";
+import { resolveWorkspaceRoot } from "../core/workspace/workspaceRoot.js";
 import type { RunToolActivity } from "../session/types.js";
 
 // ─── Types & constants ────────────────────────────────────────────────────────

package/src/index.tsx

@@ -7,55 +7,35 @@ import { APP_NAME, formatTerminalTitlePath } from "./config/settings.js";
 import { getTerminalCapability } from "./core/terminal/terminalCapabilities.js";
 import * as renderDebug from "./core/perf/renderDebug.js";
 import { MIN_VIEWPORT_COLS, MIN_VIEWPORT_ROWS } from "./ui/layout.js";
-import {
-  reassertIntendedTerminalTitle,
-  setIntendedTerminalTitle,
-  startTerminalTitleStartupGuard,
-} from "./core/terminal/terminalTitle.js";
-import { resolveWorkspaceRoot } from "./core/workspaceRoot.js";
-import {
-  createTerminalModeController,
-  TERMINAL_SEQUENCES,
-  traceTerminalClear,
-  writeTerminalControl,
-} from "./core/terminal/terminalControl.js";
-import { performStartupClear } from "./core/terminal/startupClear.js";
-
-type RenderHandle = Pick<Instance, "clear" | "cleanup" | "waitUntilExit">;
-const KITTY_KEYBOARD_OPTIONS: RenderOptions["kittyKeyboard"] = {
-  mode: "auto",
-  flags: ["disambiguateEscapeCodes"],
-};
-
-/**
- * Typed subset of the internal Ink class instance we access to disable Ink's
- * built-in resize listener. Post-startup repainting is driven by React layout
- * state, not by forcing Ink's private render buffers.
- */
-interface InkInstance {
-  unsubscribeResize?: () => void;
-}
-
-/**
- * Resolve the real Ink class instance via Ink's internal WeakMap<stdout, Ink>.
- * Returns null if resolution fails (e.g. different Ink version, test mocks).
- */
-function resolveInkInstance(stdout: AppStdout): InkInstance | null {
-  try {
-    // Bun doesn't resolve bare subpath imports like "ink/build/instances.js"
-    // so we resolve ink's main entry first, then derive the sibling path.
-    const { createRequire } = require("node:module");
-    const req = createRequire(import.meta.url);
-    const inkMain = req.resolve("ink");
-    const instancesPath = inkMain.replace(/index\.js$/, "instances.js");
-    const instances = req(instancesPath);
-    const weakMap: WeakMap<object, InkInstance> =
-      instances.default ?? instances;
-    return weakMap.get(stdout as object) ?? null;
-  } catch {
-    return null;
-  }
-}
+import {
+  setIntendedTerminalTitle,
+} from "./core/terminal/terminalTitle.js";
+import { resolveWorkspaceRoot } from "./core/workspace/workspaceRoot.js";
+import {
+  createTerminalModeController,
+  writeTerminalControl,
+} from "./core/terminal/terminalControl.js";
+import { resolveInkRenderInstance, type InkRenderInstance } from "./core/terminal/inkRenderReset.js";
+import { resetFrameLockForResize, wrapStdoutWithFrameLock } from "./core/terminal/frameLock.js";
+
+type RenderHandle = Pick<Instance, "clear" | "cleanup" | "waitUntilExit">;
+
+export function resolveKittyKeyboardOptions(
+  env: Record<string, string | undefined>,
+): RenderOptions["kittyKeyboard"] | undefined {
+  // Ink's auto mode probes with CSI ? u. Kitty's response can race Ink's
+  // regular input listeners and leak into both the first frame and composer.
+  // A direct Kitty session is already known to support the protocol, so enable
+  // it without probing. Avoid protocol negotiation in all other terminals.
+  if ((env.TERM ?? "").toLowerCase() !== "xterm-kitty") {
+    return undefined;
+  }
+
+  return {
+    mode: "enabled",
+    flags: ["disambiguateEscapeCodes"],
+  };
+}
 
 export interface AppStdout {
   isTTY: boolean;
@@ -74,7 +54,7 @@ export interface StartAppDependencies {
   platform: NodeJS.Platform;
   argv: string[];
   renderApp: (node: React.ReactElement, options?: RenderOptions) => RenderHandle;
-  resolveInkInstanceForStdout: (stdout: AppStdout) => InkInstance | null;
+  resolveInkInstanceForStdout: (stdout: AppStdout) => InkRenderInstance | null;
   registerExitHandler: (handler: () => void) => void;
 }
 
@@ -112,7 +92,7 @@ export function startApp({
   platform = process.platform,
   argv = process.argv.slice(2),
   renderApp = render,
-  resolveInkInstanceForStdout = resolveInkInstance,
+  resolveInkInstanceForStdout = resolveInkRenderInstance,
   registerExitHandler = (handler) => {
     process.on("exit", handler);
   },
@@ -123,7 +103,11 @@ export function startApp({
     return { started: true, exitCode: 0 };
   }
 
-  const terminal = createTerminalModeController((chunk) => stdout.write(chunk));
+  // Wrap stdout to implement frame locking, deduplication, and width-safe row
+  // padding via \x1b[K injection across the entire TUI.
+  const wrappedStdout = wrapStdoutWithFrameLock({ stdout, env });
+
+  const terminal = createTerminalModeController((chunk) => wrappedStdout.write(chunk));
   const writeStdout = (chunk: string, source: string): boolean => terminal.write(chunk, source);
 
   const writeStderr = (chunk: string, source: string): boolean => {
@@ -163,56 +147,38 @@ export function startApp({
     return { started: false, exitCode: 1 };
   }
   const launchArgs: LaunchArgs = parsedLaunchArgs.value;
-  setIntendedTerminalTitle(env.CODEXA_INITIAL_TERMINAL_TITLE ?? APP_NAME, {
-    force: true,
-    reason: "index-safe-fallback-title",
-    write: (chunk) => writeStdout(chunk, "src/index.tsx:title.fallback"),
-  });
-  const stopStartupTitleGuard = startTerminalTitleStartupGuard({
-    write: (chunk) => writeStdout(chunk, "src/index.tsx:title.startupGuard"),
-    reason: "index-startup-guard",
-    intervalMs: 150,
-    durationMs: 3500,
-  });
-
-  // Clear the screen (viewport + scrollback) and move cursor home before Ink
-  // renders the first frame.  This removes any previous terminal content so
-  // the app opens into a clean screen.  We stay in the normal screen buffer
-  // (no \x1b[?1049h) to preserve mouse text selection after exit.
-  // Skipped when --no-clear or CODEXA_NO_CLEAR=1 is set.
-  // NOTE: Mouse reporting is NOT enabled here — managed solely by app.tsx.
-  traceTerminalClear("src/index.tsx:startup", { mode: "transcript" });
-  performStartupClear({
-    write: (c) => writeStdout(c, "src/index.tsx:startup"),
-    noClear: launchArgs.noClear,
-    env,
-  });
-  const startupWorkspaceRoot = resolveWorkspaceRoot();
+  // Main chat starts in the normal screen buffer so the startup frame and later
+  // transcript rows are owned by native terminal scrollback. Overlay screens
+  // enter alternate-screen mode from app.tsx only while an overlay is active.
+  const startupWorkspaceRoot = resolveWorkspaceRoot();
   const startupSettings = loadSettings();
   const startupTitle =
     formatTerminalTitlePath(startupWorkspaceRoot, startupSettings.ui.terminalTitleMode) || APP_NAME;
-  setIntendedTerminalTitle(startupTitle, {
-    force: true,
-    reason: "startup-title",
-    write: (chunk) => writeStdout(chunk, "src/index.tsx:startup.title"),
-  });
-  reassertIntendedTerminalTitle({
-    write: (chunk) => writeStdout(chunk, "src/index.tsx:startup.titleReady"),
-    reason: "startup-title-ready",
-  });
-  terminal.setBracketedPaste(true, "src/index.tsx:startup.bracketedPaste");
-
+  setIntendedTerminalTitle(startupTitle, {
+    force: true,
+    reason: "startup-title",
+    write: (chunk) => writeStdout(chunk, "src/index.tsx:startup.title"),
+  });
+  terminal.setBracketedPaste(true, "src/index.tsx:startup.bracketedPaste");
+
   let cleanupDone = false;
   let repaintArmed = false;
   let renderHandle: RenderHandle | null = null;
-  let inkInstance: InkInstance | null = null;
-
-  const onResize = () => {
-    renderDebug.traceEvent("terminal", "resize", {
+  let inkInstance: InkRenderInstance | null = null;
+  let previousResizeCols = stdout.columns;
+  let previousResizeRows = stdout.rows;
+
+  const onResize = () => {
+    resetFrameLockForResize(wrappedStdout);
+    renderDebug.traceEvent("terminal", "resize", {
+      previousCols: previousResizeCols,
+      previousRows: previousResizeRows,
       cols: stdout.columns,
       rows: stdout.rows,
       invalid: hasInvalidRestoreDimensions(stdout),
     });
+    previousResizeCols = stdout.columns;
+    previousResizeRows = stdout.rows;
 
     if (hasInvalidRestoreDimensions(stdout)) {
       // Transient invalid dimensions (e.g. during maximize/restore on
@@ -234,12 +200,12 @@ export function startApp({
   const cleanup = () => {
     if (cleanupDone) return;
     cleanupDone = true;
-    stopStartupTitleGuard();
-    stdout.off("resize", onResize);
+    stdout.off("resize", onResize);
     renderHandle?.cleanup();
     // Restore terminal state: disable mouse reporting and bracketed paste.
     terminal.setMouseReporting(false, "src/index.tsx:cleanup.mouse");
     terminal.setBracketedPaste(false, "src/index.tsx:cleanup.bracketedPaste");
+    terminal.setAlternateScreen(false, "src/index.tsx:cleanup.alternateScreen");
     terminal.resetModes();
     activeRoot = null;
   };
@@ -269,13 +235,15 @@ export function startApp({
   process.on("uncaughtException", handleFatal);
   process.on("unhandledRejection", handleFatal);
 
-  renderHandle = renderApp(<App launchArgs={launchArgs} />, {
-    kittyKeyboard: KITTY_KEYBOARD_OPTIONS,
-  });
+  const kittyKeyboard = resolveKittyKeyboardOptions(env);
+  renderHandle = renderApp(<App launchArgs={launchArgs} />, {
+    ...(kittyKeyboard ? { kittyKeyboard } : {}),
+    stdout: wrappedStdout as any,
+  });
 
   // Resolve the real Ink class instance to get access to lastOutput,
   // onRender, calculateLayout, etc.  Gracefully degrades to null in tests.
-  inkInstance = resolveInkInstanceForStdout(stdout);
+  inkInstance = resolveInkInstanceForStdout(wrappedStdout);
 
   // Remove Ink's own resize handler so the app is the sole resize handler.
   // This eliminates the race where Ink's resized() fires alongside our

package/src/session/appSession.ts

@@ -18,7 +18,7 @@ import {
   upsertRunToolActivity,
   type UIStateAction,
 } from "./chatLifecycle.js";
-import type { RunFileActivity } from "../core/workspaceActivity.js";
+import type { RunFileActivity } from "../core/workspace/workspaceActivity.js";
 import type { RunToolActivity } from "./types.js";
 import type { LiveRenderUpdate } from "./liveRenderScheduler.js";
 import * as renderDebug from "../core/perf/renderDebug.js";
@@ -47,7 +47,7 @@ export type SessionAction =
   | { type: "SUBMIT_PROMPT_RUN"; historyValue?: string; events: TimelineEvent[]; turnId: number; runId: number }
   | { type: "HISTORY_UP" }
   | { type: "HISTORY_DOWN" }
-  | { type: "CLEAR_TRANSCRIPT" }
+  | { type: "CLEAR_TRANSCRIPT"; seedEvents?: TimelineEvent[] }
   | { type: "SET_ACTIVE_EVENTS"; events: TimelineEvent[] }
   | { type: "RUN_APPEND_ACTIVITY"; runId: number; activity: RunFileActivity[] }
   | { type: "RUN_APPLY_PROGRESS_UPDATES"; runId: number; updates: BackendProgressUpdate[] }
@@ -98,9 +98,9 @@ export type SessionAction =
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
-export function createInitialSessionState(): SessionState {
+export function createInitialSessionState(options: { staticEvents?: TimelineEvent[] } = {}): SessionState {
   return {
-    staticEvents: [],
+    staticEvents: options.staticEvents ?? [],
     activeEvents: [],
     uiState: { kind: "IDLE" },
     externalCliStatus: "idle",
@@ -327,11 +327,12 @@ export function reduceSessionState(state: SessionState, action: SessionAction):
       renderDebug.traceEvent("transcript", "clear", {
         previousStaticEventsLength: state.staticEvents.length,
         previousActiveEventsLength: state.activeEvents.length,
+        seedEventsLength: action.seedEvents?.length ?? 0,
         uiStateKind: state.uiState.kind,
       });
       return {
         ...state,
-        staticEvents: [],
+        staticEvents: action.seedEvents ?? [],
         activeEvents: [],
         uiState: { kind: "IDLE" },
         clearCount: state.clearCount + 1,
@@ -694,8 +695,10 @@ export function reduceSessionState(state: SessionState, action: SessionAction):
 
 // ─── Hook ────────────────────────────────────────────────────────────────────
 
-export function useAppSessionState() {
-  const [state, setState] = useState<SessionState>(createInitialSessionState);
+export function useAppSessionState(initialStaticEvents?: () => TimelineEvent[]) {
+  const [state, setState] = useState<SessionState>(() =>
+    createInitialSessionState({ staticEvents: initialStaticEvents?.() ?? [] }),
+  );
   const queueRef = useRef<SessionAction[]>([]);
   const scheduledRef = useRef(false);
 

package/src/session/chatLifecycle.ts

@@ -2,7 +2,7 @@ import { MAX_CHAT_LINES } from "../config/settings.js";
 import type { AvailableBackend } from "../config/settings.js";
 import type { ResolvedRuntimeConfig } from "../config/runtimeConfig.js";
 import type { BackendProgressUpdate } from "../core/providers/types.js";
-import { summarizeRunActivity, type RunFileActivity } from "../core/workspaceActivity.js";
+import { summarizeRunActivity, type RunFileActivity } from "../core/workspace/workspaceActivity.js";
 import * as renderDebug from "../core/perf/renderDebug.js";
 import type {
   RunEvent,

package/src/session/liveRenderScheduler.ts

@@ -1,5 +1,5 @@
 import type { BackendProgressUpdate } from "../core/providers/types.js";
-import type { RunFileActivity } from "../core/workspaceActivity.js";
+import type { RunFileActivity } from "../core/workspace/workspaceActivity.js";
 import type { RunToolActivity } from "./types.js";
 import * as renderDebug from "../core/perf/renderDebug.js";
 

package/src/session/types.ts

@@ -3,7 +3,7 @@ import type {
   AvailableBackend,
 } from "../config/settings.js";
 import type { ResolvedRuntimeConfig } from "../config/runtimeConfig.js";
-import type { RunActivitySummary, RunFileActivity } from "../core/workspaceActivity.js";
+import type { RunActivitySummary, RunFileActivity } from "../core/workspace/workspaceActivity.js";
 
 // ─── Screen routing ──────────────────────────────────────────────────────────
 

package/src/test/runtimeTestUtils.ts

@@ -1,4 +1,11 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { resolveRuntimeConfig, type RuntimeConfig, DEFAULT_RUNTIME_CONFIG, type ResolvedRuntimeConfig } from "../config/runtimeConfig.js";
+import type { ProviderId } from "../core/providerLauncher/types.js";
+import { resetAnthropicRouteValidationCacheForTests } from "../core/providerRuntime/anthropic.js";
+import { resetAntigravityRouteValidationCacheForTests } from "../core/providerRuntime/antigravity.js";
+import type { ProviderModel } from "../core/providerRuntime/types.js";
 
 export function makeResolvedRuntime(overrides: Partial<RuntimeConfig> = {}): ResolvedRuntimeConfig {
   return resolveRuntimeConfig({
@@ -12,3 +19,86 @@ export function makeResolvedRuntime(overrides: Partial<RuntimeConfig> = {}): Res
 }
 
 export const TEST_RUNTIME = makeResolvedRuntime();
+
+function agyModel(id: string, label: string): ProviderModel {
+  return {
+    id,
+    modelId: id,
+    label,
+    description: null,
+    defaultReasoningLevel: null,
+    supportedReasoningLevels: null,
+    source: "discovered",
+  };
+}
+
+/**
+ * The catalog `agy models` reports on a configured machine. Antigravity resolves
+ * its status, backend kind, and model labels from whatever discovery last found,
+ * so tests that assert on any of those need a catalog seeded rather than
+ * whatever happens to be installed.
+ */
+export const ANTIGRAVITY_FIXTURE_MODELS: readonly ProviderModel[] = [
+  agyModel("gemini-3.5-flash", "Gemini 3.5 Flash"),
+  agyModel("gemini-3.1-pro", "Gemini 3.1 Pro"),
+  agyModel("claude-sonnet-4-6", "Claude Sonnet 4.6"),
+  agyModel("claude-sonnet-4-6-think", "Claude Sonnet 4.6 (Thinking)"),
+  agyModel("gpt-oss-120b", "GPT-OSS 120B"),
+];
+
+/**
+ * Drops every provider's in-memory discovery result.
+ *
+ * Bun shares the module registry across test files, so a catalog discovered by
+ * one test (some probe the real `claude` / `agy` CLIs) otherwise survives into
+ * the next and takes precedence over both the cache and the fallback list —
+ * making assertions depend on file order and on what is installed locally.
+ */
+export function resetProviderDiscoveryState(): void {
+  resetAntigravityRouteValidationCacheForTests();
+  resetAnthropicRouteValidationCacheForTests();
+}
+
+/**
+ * Runs `fn` with HOME pointed at a throwaway directory holding only the provider
+ * model cache built from `seed`.
+ *
+ * Provider discovery reads `~/.codexa-model-cache.json`, so a test that calls it
+ * without this is asserting against the developer's own machine — it passes with
+ * a warm cache and fails on a cold one (or in CI). HOME is read per call (see
+ * `getProviderModelCacheFile`), so redirecting the env var here is enough.
+ *
+ * Antigravity's in-memory discovery is reset around the body as well: Bun shares
+ * the module registry across test files, so a catalog discovered by one file
+ * otherwise leaks into the next and takes precedence over the seeded cache,
+ * making results depend on file order. Seed exactly what the assertions need.
+ */
+export function withSeededModelCache<T>(
+  seed: Partial<Record<ProviderId, readonly ProviderModel[]>>,
+  fn: () => T,
+): T {
+  const tempHome = mkdtempSync(join(tmpdir(), "codexa-test-home-"));
+  const previousHome = process.env.HOME;
+  const previousUserProfile = process.env.USERPROFILE;
+  try {
+    process.env.HOME = tempHome;
+    delete process.env.USERPROFILE;
+    const providers = Object.fromEntries(
+      Object.entries(seed).map(([providerId, models]) => [providerId, { discoveredAt: 1, models }]),
+    );
+    writeFileSync(
+      join(tempHome, ".codexa-model-cache.json"),
+      `${JSON.stringify({ version: 1, providers }, null, 2)}\n`,
+      "utf8",
+    );
+    resetProviderDiscoveryState();
+    return fn();
+  } finally {
+    if (previousHome === undefined) delete process.env.HOME;
+    else process.env.HOME = previousHome;
+    if (previousUserProfile === undefined) delete process.env.USERPROFILE;
+    else process.env.USERPROFILE = previousUserProfile;
+    rmSync(tempHome, { recursive: true, force: true });
+    resetProviderDiscoveryState();
+  }
+}

package/src/ui/{ActivityBars.tsx → chrome/ActivityBars.tsx}

@@ -1,6 +1,6 @@
 import React from "react";
 import { Box, Text } from "ink";
-import { useTheme } from "./theme.js";
+import { useTheme } from "../theme.js";
 
 // ─── WaveBar ─────────────────────────────────────────────────────────────────
 // Audio-visualizer style wave. Renders as a single <Text> node to minimise

package/src/ui/{ActivityIndicator.tsx → chrome/ActivityIndicator.tsx}

@@ -1,7 +1,7 @@
 import React, { useState, useEffect } from "react";
 import { Text } from "ink";
-import type { UIState, ExternalCliStatus } from "../session/types.js";
-import { useTheme } from "./theme.js";
+import type { UIState, ExternalCliStatus } from "../../session/types.js";
+import { useTheme } from "../theme.js";
 
 const SPINNER_FRAMES = ["?", "?", "?", "?", "?", "?", "?", "?", "?", "?"];
 const STREAMING_FRAMES = ["?", "?", "?", "?"];
@@ -36,7 +36,7 @@ export function ActivityIndicator({ uiState, externalCliStatus = "idle" }: Activ
   let bold = false;
 
   if (isError) {
-    glyph = "�";
+    glyph = "�";
     color = theme.error;
     bold = true;
   } else if (isAction) {

package/src/ui/{AnimatedStatusText.tsx → chrome/AnimatedStatusText.tsx}

@@ -1,8 +1,8 @@
 import React, { useEffect, useState } from "react";
 import { Text } from "ink";
-import * as renderDebug from "../core/perf/renderDebug.js";
-import { useTheme } from "./theme.js";
-import { sanitizeTerminalOutput } from "../core/terminal/terminalSanitize.js";
+import * as renderDebug from "../../core/perf/renderDebug.js";
+import { useTheme } from "../theme.js";
+import { sanitizeTerminalOutput } from "../../core/terminal/terminalSanitize.js";
 import { BUSY_STATUS_FRAME_MS, BUSY_STATUS_FRAMES, getBusyStatusFrame } from "./busyStatusAnimation.js";
 
 interface AnimatedStatusTextProps {