@golba98/codexa 1.0.2 → 1.0.3

package/src/ui/CodexLogo.tsx

@@ -1,55 +0,0 @@
-import React from "react";
-import { Box, Text } from "ink";
-import { useTheme } from "./theme.js";
-import type { LayoutMode } from "./layout.js";
-
-// Full 4-line ASCII banner — rendered only in "full" mode.
-const BANNER = [
-  "  ____   ___  ____  _____ _  __    _    ",
-  " / ___| / _ \\|  _ \\| ____| |/ /   / \\   ",
-  "| |    | | | | | | |  _| | ' /   / _ \\  ",
-  "|_|     \\___/|_| |_|_____|_|\\_\\ /_/ \\_\\ "
-];
-
-
-interface CodexLogoProps {
-  /** Which layout mode we're in. Defaults to "full". */
-  layout?: LayoutMode;
-}
-
-export function CodexLogo({ layout = "full" }: CodexLogoProps) {
-  const theme = useTheme();
-
-  function colorForIndex(index: number): string {
-    return theme.LOGO[index % theme.LOGO.length] ?? theme.LOGO[0];
-  }
-
-  // Micro mode — no logo rendered at all
-  if (layout === "micro") return null;
-
-  // Compact mode — single colourful line: ✦ CODEXA
-  if (layout === "compact") {
-    const letters = ["C", "O", "D", "E", "X", "A"];
-    return (
-      <Box>
-        <Text color={theme.LOGO[0]} bold>{"✦ "}</Text>
-        {letters.map((char, index) => (
-          <Text key={index} color={colorForIndex(index)} bold>
-            {char}
-          </Text>
-        ))}
-      </Box>
-    );
-  }
-
-  // Full mode — ASCII banner to stay stable across terminals/codepages.
-  return (
-    <Box flexDirection="column" overflow="hidden">
-      {BANNER.map((line, index) => (
-        <Text key={line} color={colorForIndex(index)} wrap="truncate">
-          {line}
-        </Text>
-      ))}
-    </Box>
-  );
-}

package/src/ui/Markdown.test.ts

@@ -1,157 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { parseMarkdown } from "./Markdown.js";
-import type { ParaSegment, CodeSegment, Segment } from "./Markdown.js";
-
-const SAMPLE = [
-  "# Summary",
-  "",
-  "The current rendering path is flattening the assistant response into a dense block.",
-  "",
-  "What needs to improve:",
-  "",
-  "- Preserve paragraph spacing.",
-  "- Keep bullet lists readable.",
-  "- Keep code blocks separate.",
-  "- Avoid merging activity logs with final answers.",
-  "",
-  "Steps:",
-  "",
-  "1. Sanitize unsafe control characters.",
-  "2. Preserve markdown structure.",
-  "3. Render semantic blocks with spacing.",
-  "4. Verify streaming still works.",
-  "",
-  "Example command:",
-  "",
-  "```powershell",
-  "npm run typecheck",
-  "npm run build",
-  "```",
-  "",
-  "Assistant: Done. Formatting pipeline is now applied.",
-].join("\n");
-
-function segmentText(segments: Segment[]): string {
-  return segments.flatMap((segment) => {
-    if (segment.type === "code") return segment.lines;
-    if (segment.type === "header") return segment.parts.map((part) => part.text);
-    if (segment.type === "list") return segment.items.flatMap((item) => item.parts.map((part) => part.text));
-    return segment.lines.flatMap((line) => line.map((part) => part.text));
-  }).join("\n");
-}
-
-test("sample response produces separate segments, not one dense para", () => {
-  const segments = parseMarkdown(SAMPLE);
-  const types = segments.map((s) => s.type);
-
-  assert.ok(
-    segments.length >= 7,
-    `expected ≥7 segments, got ${segments.length}: ${JSON.stringify(types)}`,
-  );
-  assert.equal(segments[0]?.type, "header", "first segment must be the header");
-  assert.ok(types.includes("code"), "expected a code segment");
-  assert.ok(types.includes("list"), "expected a list segment");
-});
-
-test("blank lines between paragraphs produce separate ParaSegments", () => {
-  const segments = parseMarkdown(SAMPLE);
-  const paras = segments.filter((s): s is ParaSegment => s.type === "para");
-
-  for (const para of paras) {
-    const text = para.lines.flat().map((p) => p.text).join(" ");
-    assert.ok(
-      !(text.includes("rendering path") && text.includes("What needs to improve")),
-      "two distinct paragraphs must not share one ParaSegment",
-    );
-  }
-});
-
-test("blank lines inside code blocks are preserved", () => {
-  const input = "```\nline1\n\nline3\n```";
-  const segments = parseMarkdown(input);
-  assert.equal(segments.length, 1);
-  assert.equal(segments[0]?.type, "code");
-  const code = segments[0] as CodeSegment;
-  assert.deepEqual(code.lines, ["line1", "", "line3"]);
-});
-
-test("plain paragraphs with no blank lines stay in one segment", () => {
-  const input = "Line one.\nLine two.\nLine three.";
-  const segments = parseMarkdown(input);
-  assert.equal(segments.length, 1);
-  assert.equal(segments[0]?.type, "para");
-  const para = segments[0] as ParaSegment;
-  assert.equal(para.lines.length, 3);
-});
-
-test("header immediately followed by text produces two segments", () => {
-  const input = "# Title\n\nSome text here.";
-  const segments = parseMarkdown(input);
-  assert.equal(segments[0]?.type, "header");
-  assert.equal(segments[1]?.type, "para");
-});
-
-test("cleans local markdown file links into compact terminal paths", () => {
-  const input = "The app shell lives in [`src/App.tsx`](C:/Users/Example/Projects/Project/src/App.tsx#L22).";
-  const text = segmentText(parseMarkdown(input));
-
-  assert.match(text, /src\/App\.tsx:22/);
-  assert.doesNotMatch(text, /C:\/Users/);
-  assert.doesNotMatch(text, /\]\(/);
-});
-
-test("cleans Windows absolute paths in prose", () => {
-  const input = "Formal proof: C:\\Users\\Example\\Projects\\Project\\docs\\proof.md#L26";
-  const text = segmentText(parseMarkdown(input));
-
-  assert.match(text, /docs\/proof\.md:26/);
-  assert.doesNotMatch(text, /C:\\Users/);
-});
-
-test("cleans file paths with encoded spaces", () => {
-  const input = "Overview: [README.md](file:///C:/Users/Example/Projects/5-Date%20Verification/README.md)";
-  const text = segmentText(parseMarkdown(input));
-
-  assert.match(text, /README\.md/);
-  assert.doesNotMatch(text, /file:\/\//);
-  assert.doesNotMatch(text, /5-Date%20Verification/);
-});
-
-test("cleans local line ranges", () => {
-  const input = "See [proof](C:/Users/Example/Projects/Project/docs/proof.md#L26-L31).";
-  const text = segmentText(parseMarkdown(input));
-
-  assert.match(text, /proof \(docs\/proof\.md:26-31\)/);
-  assert.doesNotMatch(text, /C:\/Users/);
-});
-
-test("external web markdown links remain unchanged", () => {
-  const input = "Docs: [OpenAI](https://platform.openai.com/docs).";
-  const text = segmentText(parseMarkdown(input));
-
-  assert.match(text, /\[OpenAI\]\(https:\/\/platform\.openai\.com\/docs\)/);
-});
-
-test("inline-code web links remain unchanged", () => {
-  const input = "Use `https://platform.openai.com/docs` for reference.";
-  const text = segmentText(parseMarkdown(input));
-
-  assert.match(text, /https:\/\/platform\.openai\.com\/docs/);
-});
-
-test("code blocks are not rewritten by terminal answer cleanup", () => {
-  const input = [
-    "```text",
-    "C:/Users/Example/Project/src/App.tsx#L22",
-    "[README.md](file:///C:/Project/README.md)",
-    "```",
-  ].join("\n");
-  const segments = parseMarkdown(input);
-  const code = segments[0] as CodeSegment;
-
-  assert.deepEqual(code.lines, [
-    "C:/Users/Example/Project/src/App.tsx#L22",
-    "[README.md](file:///C:/Project/README.md)",
-  ]);
-});

package/src/ui/ModelPickerProviderScope.test.tsx

@@ -1,411 +0,0 @@
-/**
- * Tests that the model picker is correctly scoped to each provider:
- * - model lists contain only models for the correct provider
- * - picker title/copy uses the provider-specific label
- * - modelPickerLabel is set on each runtime
- */
-
-import assert from "node:assert/strict";
-import { PassThrough } from "node:stream";
-import test from "node:test";
-import React from "react";
-import { render } from "ink";
-import { ThemeProvider } from "./theme.js";
-import { ModelPickerScreen } from "./ModelPickerScreen.js";
-import { createLayoutSnapshot } from "./layout.js";
-import { ANTHROPIC_FALLBACK_MODELS, GEMINI_FALLBACK_MODELS, providerModelsToCodexCapabilities } from "../core/providerRuntime/models.js";
-import { anthropicRuntime } from "../core/providerRuntime/anthropic.js";
-import { geminiRuntime } from "../core/providerRuntime/gemini.js";
-import { getSelectableModelCapabilities } from "../core/models/codexModelCapabilities.js";
-import { ProviderPicker } from "./ProviderPicker.js";
-import type { ProviderConfig } from "../core/providerLauncher/types.js";
-
-class TestInput extends PassThrough {
-  readonly isTTY = true;
-  setRawMode(): this { return this; }
-  override resume(): this { return this; }
-  override pause(): this { return this; }
-  ref(): this { return this; }
-  unref(): this { return this; }
-}
-
-class TestOutput extends PassThrough {
-  readonly isTTY = true;
-  columns = 120;
-  rows = 40;
-}
-
-function stripAnsi(value: string): string {
-  return value.replace(/\[[0-?]*[ -/]*[@-~]/g, "");
-}
-
-function sleep(ms = 50): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// ---------------------------------------------------------------------------
-// Model list content — no cross-provider leakage
-// ---------------------------------------------------------------------------
-
-test("ANTHROPIC_FALLBACK_MODELS uses short CLI alias model IDs (not full API IDs)", () => {
-  const ids = ANTHROPIC_FALLBACK_MODELS.map((m) => m.modelId);
-  for (const id of ids) {
-    assert.ok(
-      !id.startsWith("gpt-"),
-      `Anthropic model list must not contain OpenAI model: "${id}"`,
-    );
-  }
-  // Short aliases, not full versioned API IDs
-  assert.ok(ids.includes("opus"), "Missing opus alias");
-  assert.ok(ids.includes("sonnet"), "Missing sonnet alias");
-  assert.ok(ids.includes("haiku"), "Missing haiku alias");
-});
-
-test("ANTHROPIC_FALLBACK_MODELS contains the expected models", () => {
-  const ids = ANTHROPIC_FALLBACK_MODELS.map((m) => m.modelId);
-  assert.ok(ids.includes("opus"), "Missing opus");
-  assert.ok(ids.includes("sonnet"), "Missing sonnet");
-  assert.ok(ids.includes("haiku"), "Missing haiku");
-});
-
-test("ANTHROPIC_FALLBACK_MODELS does not contain OpenAI model IDs", () => {
-  for (const m of ANTHROPIC_FALLBACK_MODELS) {
-    assert.ok(
-      !m.modelId.startsWith("gpt-"),
-      `Anthropic model list must not contain OpenAI model: "${m.modelId}"`,
-    );
-  }
-});
-
-test("GEMINI_FALLBACK_MODELS contains only gemini- model IDs", () => {
-  for (const m of GEMINI_FALLBACK_MODELS) {
-    assert.ok(
-      m.modelId.startsWith("gemini-"),
-      `Expected modelId to start with "gemini-", got: "${m.modelId}"`,
-    );
-  }
-});
-
-test("GEMINI_FALLBACK_MODELS contains the expected models", () => {
-  const ids = GEMINI_FALLBACK_MODELS.map((m) => m.modelId);
-  assert.equal(ids[0], "gemini-3-flash-preview", "Default fast Gemini route should stay first");
-  assert.ok(ids.includes("gemini-3.1-pro-preview"), "Missing gemini-3.1-pro-preview");
-  assert.ok(ids.includes("gemini-3-flash-preview"), "Missing gemini-3-flash-preview");
-  assert.ok(ids.includes("gemini-3.1-flash-lite-preview"), "Missing gemini-3.1-flash-lite-preview");
-  assert.ok(ids.includes("gemini-2.5-pro"), "Missing gemini-2.5-pro");
-  assert.ok(ids.includes("gemini-2.5-flash"), "Missing gemini-2.5-flash");
-  assert.ok(ids.includes("gemini-2.5-flash-lite"), "Missing gemini-2.5-flash-lite");
-  assert.ok(!ids.includes("gemini-3-flash"), "Gemini 3 Flash must not be offered; use preview ID");
-  assert.ok(!ids.includes("gemini-3.1-pro"), "Gemini 3.1 Pro must not be offered without preview suffix");
-});
-
-test("GEMINI_FALLBACK_MODELS maps display names to exact CLI IDs with no reasoning support", () => {
-  const expected = new Map([
-    ["Gemini 3.1 Pro Preview", "gemini-3.1-pro-preview"],
-    ["Gemini 3 Flash Preview", "gemini-3-flash-preview"],
-    ["Gemini 3.1 Flash Lite Preview", "gemini-3.1-flash-lite-preview"],
-    ["Gemini 2.5 Pro", "gemini-2.5-pro"],
-    ["Gemini 2.5 Flash", "gemini-2.5-flash"],
-    ["Gemini 2.5 Flash Lite", "gemini-2.5-flash-lite"],
-  ]);
-
-  assert.equal(GEMINI_FALLBACK_MODELS.length, expected.size);
-  for (const model of GEMINI_FALLBACK_MODELS) {
-    assert.equal(model.modelId, expected.get(model.label), `Unexpected CLI ID for ${model.label}`);
-    assert.equal(model.id, model.modelId);
-    assert.equal(model.supportedReasoningLevels, null);
-  }
-});
-
-test("GEMINI_FALLBACK_MODELS does not contain OpenAI or Claude model IDs", () => {
-  for (const m of GEMINI_FALLBACK_MODELS) {
-    assert.ok(!m.modelId.startsWith("gpt-"), `Gemini list must not contain OpenAI model: "${m.modelId}"`);
-    assert.ok(!m.modelId.startsWith("claude-"), `Gemini list must not contain Claude model: "${m.modelId}"`);
-  }
-});
-
-// ---------------------------------------------------------------------------
-// providerModelsToCodexCapabilities conversion
-// ---------------------------------------------------------------------------
-
-test("providerModelsToCodexCapabilities converts Anthropic models to selectable capabilities", () => {
-  const caps = providerModelsToCodexCapabilities(ANTHROPIC_FALLBACK_MODELS, "sonnet");
-  const selectable = getSelectableModelCapabilities(caps);
-
-  assert.ok(selectable.length > 0, "Should produce selectable models");
-  const modelIds = selectable.map((m) => m.model);
-  assert.ok(modelIds.includes("sonnet"), "Should include sonnet alias");
-  assert.ok(modelIds.includes("opus"), "Should include opus alias");
-  assert.ok(modelIds.includes("haiku"), "Should include haiku alias");
-  for (const id of modelIds) {
-    assert.ok(!id.startsWith("gpt-"), `Converted Anthropic capabilities must not contain OpenAI model: "${id}"`);
-  }
-  const sonnet = selectable.find((model) => model.model === "sonnet");
-  assert.deepEqual(
-    sonnet?.supportedReasoningLevels?.map((level) => level.id),
-    ["low", "medium", "high", "max"],
-  );
-});
-
-test("Claude reasoning options do not include OpenAI-only levels", () => {
-  const caps = providerModelsToCodexCapabilities(ANTHROPIC_FALLBACK_MODELS, "sonnet");
-  const sonnet = getSelectableModelCapabilities(caps).find((model) => model.model === "sonnet");
-  const opus = getSelectableModelCapabilities(caps).find((model) => model.model === "opus");
-  const ids = sonnet?.supportedReasoningLevels?.map((level) => level.id) ?? [];
-
-  assert.deepEqual(ids, ["low", "medium", "high", "max"]);
-  assert.deepEqual(opus?.supportedReasoningLevels?.map((level) => level.id), ["low", "medium", "high", "xhigh", "max"]);
-  assert.ok(!ids.includes("xhigh"), "Sonnet fallback must not show xhigh unless verified");
-  assert.ok(!ids.includes("none"), "Claude picker must not show OpenAI none reasoning");
-  assert.ok(!ids.includes("minimal"), "Claude picker must not show OpenAI minimal reasoning");
-});
-
-test("providerModelsToCodexCapabilities converts Gemini models to selectable capabilities", () => {
-  const caps = providerModelsToCodexCapabilities(GEMINI_FALLBACK_MODELS, "gemini-2.5-pro");
-  const selectable = getSelectableModelCapabilities(caps);
-
-  assert.ok(selectable.length > 0, "Should produce selectable models");
-  const modelIds = selectable.map((m) => m.model);
-  assert.ok(modelIds.includes("gemini-3.1-pro-preview"), "Should include gemini-3.1-pro-preview");
-  assert.ok(modelIds.includes("gemini-3-flash-preview"), "Should include gemini-3-flash-preview");
-  assert.ok(modelIds.includes("gemini-3.1-flash-lite-preview"), "Should include gemini-3.1-flash-lite-preview");
-  assert.ok(modelIds.includes("gemini-2.5-pro"), "Should include gemini-2.5-pro");
-  assert.ok(modelIds.includes("gemini-2.5-flash"), "Should include gemini-2.5-flash");
-  assert.ok(modelIds.includes("gemini-2.5-flash-lite"), "Should include gemini-2.5-flash-lite");
-  assert.ok(!modelIds.includes("gemini-3-flash"), "Should not include legacy non-preview Gemini 3 Flash");
-  for (const id of modelIds) {
-    assert.ok(!id.startsWith("gpt-"), `Converted Gemini capabilities must not contain OpenAI model: "${id}"`);
-    assert.ok(!id.startsWith("claude-"), `Converted Gemini capabilities must not contain Claude model: "${id}"`);
-  }
-  for (const model of selectable) {
-    assert.equal(model.supportedReasoningLevels, null);
-  }
-});
-
-// ---------------------------------------------------------------------------
-// ProviderRuntime.modelPickerLabel
-// ---------------------------------------------------------------------------
-
-test("anthropicRuntime.modelPickerLabel is 'Claude'", () => {
-  assert.equal(anthropicRuntime.modelPickerLabel, "Claude");
-});
-
-test("geminiRuntime.modelPickerLabel is 'Gemini'", () => {
-  assert.equal(geminiRuntime.modelPickerLabel, "Gemini");
-});
-
-// ---------------------------------------------------------------------------
-// ModelPickerScreen renders correct copy per provider label
-// ---------------------------------------------------------------------------
-
-test("model picker renders 'Choose a Claude model' when activeProviderLabel is Claude", async () => {
-  const stdin = new TestInput();
-  const stdout = new TestOutput();
-  let output = "";
-  stdout.on("data", (chunk) => { output += chunk.toString(); });
-
-  const claudeModels = getSelectableModelCapabilities(
-    providerModelsToCodexCapabilities(ANTHROPIC_FALLBACK_MODELS, "sonnet"),
-  );
-
-  const { cleanup } = render(
-    <ThemeProvider theme="mono">
-      <ModelPickerScreen
-        layout={createLayoutSnapshot(120, 40)}
-        models={claudeModels}
-        currentModel="sonnet"
-        currentReasoning="high"
-        activeProviderLabel="Claude"
-        onSelect={() => {}}
-        onCancel={() => {}}
-      />
-    </ThemeProvider>,
-    { stdin: stdin as any, stdout: stdout as any, debug: true },
-  );
-
-  try {
-    await sleep(100);
-    const stripped = stripAnsi(output);
-    assert.match(stripped, /Choose a Claude model to use inside Codexa/);
-    // Must not say "OpenAI"
-    assert.ok(!stripped.includes("OpenAI"), "Should not mention OpenAI when picking Claude models");
-  } finally {
-    cleanup();
-  }
-});
-
-test("model picker renders 'Choose a Gemini model' when activeProviderLabel is Gemini", async () => {
-  const stdin = new TestInput();
-  const stdout = new TestOutput();
-  let output = "";
-  stdout.on("data", (chunk) => { output += chunk.toString(); });
-
-  const geminiModels = getSelectableModelCapabilities(
-    providerModelsToCodexCapabilities(GEMINI_FALLBACK_MODELS, "gemini-2.5-pro"),
-  );
-
-  const { cleanup } = render(
-    <ThemeProvider theme="mono">
-      <ModelPickerScreen
-        layout={createLayoutSnapshot(120, 40)}
-        models={geminiModels}
-        currentModel="gemini-2.5-pro"
-        currentReasoning="high"
-        activeProviderLabel="Gemini"
-        onSelect={() => {}}
-        onCancel={() => {}}
-      />
-    </ThemeProvider>,
-    { stdin: stdin as any, stdout: stdout as any, debug: true },
-  );
-
-  try {
-    await sleep(100);
-    const stripped = stripAnsi(output);
-    assert.match(stripped, /Choose a Gemini model to use inside Codexa/);
-    assert.ok(!stripped.includes("OpenAI"), "Should not mention OpenAI when picking Gemini models");
-  } finally {
-    cleanup();
-  }
-});
-
-test("model picker renders 'Choose an OpenAI model' when activeProviderLabel is OpenAI", async () => {
-  const stdin = new TestInput();
-  const stdout = new TestOutput();
-  let output = "";
-  stdout.on("data", (chunk) => { output += chunk.toString(); });
-
-  const { cleanup } = render(
-    <ThemeProvider theme="mono">
-      <ModelPickerScreen
-        layout={createLayoutSnapshot(120, 40)}
-        models={[]}
-        currentModel="gpt-5.4"
-        currentReasoning="high"
-        activeProviderLabel="OpenAI"
-        onSelect={() => {}}
-        onCancel={() => {}}
-      />
-    </ThemeProvider>,
-    { stdin: stdin as any, stdout: stdout as any, debug: true },
-  );
-
-  try {
-    await sleep(100);
-    const stripped = stripAnsi(output);
-    assert.match(stripped, /Choose an OpenAI model to use inside Codexa/);
-  } finally {
-    cleanup();
-  }
-});
-
-test("model picker Claude list does not contain OpenAI models", async () => {
-  const stdin = new TestInput();
-  const stdout = new TestOutput();
-  let output = "";
-  stdout.on("data", (chunk) => { output += chunk.toString(); });
-
-  const claudeModels = getSelectableModelCapabilities(
-    providerModelsToCodexCapabilities(ANTHROPIC_FALLBACK_MODELS, "sonnet"),
-  );
-
-  const { cleanup } = render(
-    <ThemeProvider theme="mono">
-      <ModelPickerScreen
-        layout={createLayoutSnapshot(120, 40)}
-        models={claudeModels}
-        currentModel="sonnet"
-        currentReasoning="high"
-        activeProviderLabel="Claude"
-        onSelect={() => {}}
-        onCancel={() => {}}
-      />
-    </ThemeProvider>,
-    { stdin: stdin as any, stdout: stdout as any, debug: true },
-  );
-
-  try {
-    await sleep(100);
-    const stripped = stripAnsi(output);
-    // OpenAI model names must not appear in the rendered output
-    assert.ok(!stripped.includes("gpt-5"), "Claude picker must not display OpenAI models");
-    // Claude models must appear (new labels: "Sonnet 4.6", "Opus 4.7", "Haiku 4.5")
-    assert.ok(
-      stripped.includes("Sonnet 4.6") || stripped.includes("Opus 4.7") || stripped.includes("Haiku 4.5"),
-      "Claude picker must display Claude model names",
-    );
-  } finally {
-    cleanup();
-  }
-});
-
-// ---------------------------------------------------------------------------
-// ProviderPicker initialProviderId — lands in actions panel for that provider
-// ---------------------------------------------------------------------------
-
-test("ProviderPicker with initialProviderId=anthropic starts in actions mode showing anthropic actions", async () => {
-  const stdin = new TestInput();
-  const stdout = new TestOutput();
-  let output = "";
-  stdout.on("data", (chunk) => { output += chunk.toString(); });
-
-  const mockProviders: ProviderConfig[] = [
-    {
-      id: "openai",
-      displayName: "OpenAI",
-      currentModel: "gpt-5",
-      backendType: "openai-api-key",
-      routeMode: "in-codexa",
-      enabled: true,
-      statusLabel: "Enabled",
-      launchCommand: null,
-      isDefault: false,
-      isActiveRoute: true,
-      routeUnavailableReason: null,
-    },
-    {
-      id: "anthropic",
-      displayName: "Anthropic",
-      currentModel: "sonnet",
-      backendType: "claude-code-auth",
-      routeMode: "in-codexa",
-      enabled: true,
-      statusLabel: "Enabled",
-      launchCommand: null,
-      isDefault: false,
-      isActiveRoute: false,
-      routeUnavailableReason: null,
-    },
-  ];
-
-  const { cleanup } = render(
-    <ThemeProvider theme="mono">
-      <ProviderPicker
-        layout={createLayoutSnapshot(120, 40)}
-        providers={mockProviders}
-        onAction={() => {}}
-        onCancel={() => {}}
-        initialProviderId="anthropic"
-      />
-    </ThemeProvider>,
-    { stdin: stdin as any, stdout: stdout as any, debug: true },
-  );
-
-  try {
-    await sleep(100);
-    const stripped = stripAnsi(output);
-    // Should be in actions mode for Anthropic — shows action items, not the provider list
-    assert.ok(
-      stripped.includes("Anthropic") || stripped.includes("anthropic"),
-      "ProviderPicker should show Anthropic context when initialProviderId=anthropic",
-    );
-    // Should NOT be stuck on OpenAI's panel
-    assert.ok(
-      !stripped.includes("Select model") || stripped.includes("Anthropic"),
-      "Actions panel should be scoped to Anthropic",
-    );
-    assert.ok(stripped.includes("Refresh Claude capabilities"), "Anthropic action should refresh Claude capabilities");
-  } finally {
-    cleanup();
-  }
-});