@golba98/codexa 1.0.2 → 1.0.3

package/src/core/executables/executableResolver.test.ts

@@ -1,129 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { ChildProcess } from "node:child_process";
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { runCommand, type CommandResult } from "../process/CommandRunner.js";
-import { resolveExecutable, buildSpawnSpec } from "./executableResolver.js";
-
-function commandResult(overrides: Partial<CommandResult>): CommandResult {
-  return {
-    status: "completed",
-    exitCode: 0,
-    signal: null,
-    stdout: "",
-    stderr: "",
-    startedAt: 0,
-    endedAt: 0,
-    durationMs: 0,
-    userMessage: "Command completed.",
-    ...overrides,
-  };
-}
-
-function mockRunCommand(result: CommandResult, onCall?: (spec: Parameters<typeof runCommand>[0]) => void): typeof runCommand {
-  return ((spec) => {
-    onCall?.(spec);
-    return {
-      child: null as unknown as ChildProcess,
-      result: Promise.resolve(result),
-      cancel: () => undefined,
-    };
-  }) as typeof runCommand;
-}
-
-test("resolver: uses configuredPath", async () => {
-  const resolved = await resolveExecutable({
-    commandNames: ["test"],
-    label: "test",
-    configuredPath: process.execPath,
-  });
-  assert.equal(resolved, process.execPath);
-});
-
-test("resolver: uses environment override", async () => {
-  const original = process.env.TEST_EXECUTABLE;
-  process.env.TEST_EXECUTABLE = "custom-test";
-  try {
-    const resolved = await resolveExecutable({
-      commandNames: ["test"],
-      label: "test",
-      envOverrides: ["TEST_EXECUTABLE"],
-    });
-    assert.equal(resolved, "custom-test");
-  } finally {
-    if (original === undefined) delete process.env.TEST_EXECUTABLE;
-    else process.env.TEST_EXECUTABLE = original;
-  }
-});
-
-test("resolver: rejects environment override with shell metacharacters", async () => {
-  const original = process.env.TEST_EXECUTABLE;
-  process.env.TEST_EXECUTABLE = "custom-test & calc";
-  try {
-    await assert.rejects(
-      () => resolveExecutable({
-        commandNames: ["test"],
-        label: "test",
-        envOverrides: ["TEST_EXECUTABLE"],
-      }),
-      /shell metacharacters|single executable name/i,
-    );
-  } finally {
-    if (original === undefined) delete process.env.TEST_EXECUTABLE;
-    else process.env.TEST_EXECUTABLE = original;
-  }
-});
-
-test("resolver: rejects configured executable values that include arguments", async () => {
-  await assert.rejects(
-    () => resolveExecutable({
-      commandNames: ["test"],
-      label: "test",
-      configuredPath: "test --version",
-    }),
-    /single executable name/i,
-  );
-});
-
-test("resolver: accepts quoted executable paths with spaces", async () => {
-  const tempRoot = join(tmpdir(), `codexa resolver ${Date.now()}`);
-  const executablePath = join(tempRoot, "tool with spaces.exe");
-  mkdirSync(tempRoot, { recursive: true });
-  writeFileSync(executablePath, "");
-  try {
-    const resolved = await resolveExecutable({
-      commandNames: ["test"],
-      label: "test",
-      configuredPath: `"${executablePath}"`,
-    });
-    assert.equal(resolved, executablePath);
-  } finally {
-    rmSync(tempRoot, { recursive: true, force: true });
-  }
-});
-
-test("resolver: falls back to bare name if not found", async () => {
-  const mockImpl = mockRunCommand(commandResult({ status: "failed", exitCode: 1 }));
-  const resolved = await resolveExecutable({
-    runCommandImpl: mockImpl,
-    commandNames: ["mytest"],
-    label: "test",
-  });
-  assert.equal(resolved, "mytest");
-});
-
-test("buildSpawnSpec: wraps .cmd files in cmd.exe on Windows", async () => {
-  if (process.platform !== "win32") return;
-  const spec = buildSpawnSpec("test.cmd", ["arg1"]);
-  assert.equal(spec.executable, "cmd.exe");
-  assert.deepEqual(spec.args, ["/d", "/s", "/c", "call", "test.cmd", "arg1"]);
-});
-
-test("buildSpawnSpec: does not wrap .exe files", async () => {
-  if (process.platform !== "win32") return;
-  const spec = buildSpawnSpec("test.exe", ["arg1"]);
-  assert.equal(spec.executable, "test.exe");
-  assert.deepEqual(spec.args, ["arg1"]);
-});

package/src/core/executables/geminiExecutable.test.ts

@@ -1,116 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import type { ChildProcess } from "node:child_process";
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { buildGeminiSpawnSpec, resetGeminiExecutableCacheForTests, resolveGeminiExecutable } from "./geminiExecutable.js";
-import { runCommand, type CommandResult } from "../process/CommandRunner.js";
-
-function commandResult(overrides: Partial<CommandResult>): CommandResult {
-  return {
-    status: "completed",
-    exitCode: 0,
-    signal: null,
-    stdout: "",
-    stderr: "",
-    startedAt: 0,
-    endedAt: 0,
-    durationMs: 0,
-    userMessage: "Command completed.",
-    ...overrides,
-  };
-}
-
-function mockRunCommand(onCall: (spec: Parameters<typeof runCommand>[0]) => CommandResult): typeof runCommand {
-  return ((spec) => ({
-    child: null as unknown as ChildProcess,
-    result: Promise.resolve(onCall(spec)),
-    cancel: () => undefined,
-  })) as typeof runCommand;
-}
-
-async function withEnv<T>(env: Partial<NodeJS.ProcessEnv>, callback: () => Promise<T>): Promise<T> {
-  const originalExecutable = process.env.GEMINI_EXECUTABLE;
-  const originalCliPath = process.env.GEMINI_CLI_PATH;
-  const originalAppData = process.env.APPDATA;
-  try {
-    if ("GEMINI_EXECUTABLE" in env) process.env.GEMINI_EXECUTABLE = env.GEMINI_EXECUTABLE;
-    else delete process.env.GEMINI_EXECUTABLE;
-    if ("GEMINI_CLI_PATH" in env) process.env.GEMINI_CLI_PATH = env.GEMINI_CLI_PATH;
-    else delete process.env.GEMINI_CLI_PATH;
-    if ("APPDATA" in env) process.env.APPDATA = env.APPDATA;
-    resetGeminiExecutableCacheForTests();
-    return await callback();
-  } finally {
-    if (originalExecutable === undefined) delete process.env.GEMINI_EXECUTABLE;
-    else process.env.GEMINI_EXECUTABLE = originalExecutable;
-    if (originalCliPath === undefined) delete process.env.GEMINI_CLI_PATH;
-    else process.env.GEMINI_CLI_PATH = originalCliPath;
-    if (originalAppData === undefined) delete process.env.APPDATA;
-    else process.env.APPDATA = originalAppData;
-    resetGeminiExecutableCacheForTests();
-  }
-}
-
-test("Gemini resolver: env GEMINI_EXECUTABLE wins over PATH", async () => {
-  await withEnv({ GEMINI_EXECUTABLE: "env-gemini.cmd" }, async () => {
-    let whereCalled = false;
-    const resolved = await resolveGeminiExecutable({
-      runCommandImpl: mockRunCommand((spec) => {
-        if (spec.executable === "where.exe") whereCalled = true;
-        return commandResult({ stdout: "C:\\Tools\\gemini.cmd\n" });
-      }),
-    });
-
-    assert.equal(resolved, "env-gemini.cmd");
-    assert.equal(whereCalled, false);
-  });
-});
-
-test("Gemini resolver: APPDATA npm shim fallback works", async () => {
-  if (process.platform !== "win32") return;
-  const tempRoot = join(tmpdir(), `codexa-gemini-${Date.now()}`);
-  const npmDir = join(tempRoot, "npm");
-  const shim = join(npmDir, "gemini.cmd");
-  mkdirSync(npmDir, { recursive: true });
-  writeFileSync(shim, "@echo off\r\n", "utf-8");
-
-  try {
-    await withEnv({ APPDATA: tempRoot }, async () => {
-      const resolved = await resolveGeminiExecutable({
-        runCommandImpl: mockRunCommand(() => commandResult({ status: "failed", exitCode: 1 })),
-      });
-      assert.equal(resolved, shim);
-    });
-  } finally {
-    rmSync(tempRoot, { recursive: true, force: true });
-  }
-});
-
-test("Gemini resolver: PowerShell function text is not accepted as executable path", async () => {
-  if (process.platform !== "win32") return;
-  await withEnv({}, async () => {
-    const tempRoot = join(tmpdir(), `codexa-gemini-real-${Date.now()}`);
-    const npmDir = join(tempRoot, "npm");
-    const shim = join(npmDir, "gemini.cmd");
-    mkdirSync(npmDir, { recursive: true });
-    writeFileSync(shim, "@echo off\r\n", "utf-8");
-    process.env.APPDATA = tempRoot;
-    try {
-      const resolved = await resolveGeminiExecutable({
-        runCommandImpl: mockRunCommand(() => commandResult({ stdout: "function gemini { param($p) }\n" })),
-      });
-      assert.equal(resolved, shim);
-    } finally {
-      rmSync(tempRoot, { recursive: true, force: true });
-    }
-  });
-});
-
-test("Gemini spawn spec bypasses PowerShell and targets the resolved executable", () => {
-  const spec = buildGeminiSpawnSpec("C:\\Users\\Example\\AppData\\Roaming\\npm\\gemini.cmd", ["-p", "Respond with READY only."]);
-  assert.equal(spec.executable, "C:\\Users\\Example\\AppData\\Roaming\\npm\\gemini.cmd");
-  assert.deepEqual(spec.args, ["-p", "Respond with READY only."]);
-  assert.equal(spec.shell, undefined);
-});

package/src/core/executables/pathSanityScan.test.ts

@@ -1,47 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { readdirSync, readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
-
-function collectTsFiles(dir: string): string[] {
-  const result: string[] = [];
-  for (const entry of readdirSync(dir)) {
-    const full = join(dir, entry);
-    if (statSync(full).isDirectory()) {
-      result.push(...collectTsFiles(full));
-    } else if (full.endsWith(".ts")) {
-      result.push(full);
-    }
-  }
-  return result;
-}
-
-const SRC_ROOT = join(import.meta.dirname, "../../..");
-
-// Guard against personal user-specific paths appearing in source.
-// Patterns are split across array entries to prevent THIS file from matching itself.
-const BANNED_FRAGMENTS: Array<[string, string]> = [
-  ["C", ":\\\\Users\\\\jorda"],
-  ["C", ":/Users/jorda"],
-];
-
-test("no source files contain personal hardcoded user paths", { timeout: 30_000 }, () => {
-  const patterns = BANNED_FRAGMENTS.map(([a, b]) => new RegExp(a + b));
-  const files = collectTsFiles(SRC_ROOT);
-  const violations: string[] = [];
-
-  for (const file of files) {
-    const content = readFileSync(file, "utf-8");
-    for (const pattern of patterns) {
-      if (pattern.test(content)) {
-        violations.push(`${file}: matches ${pattern}`);
-      }
-    }
-  }
-
-  assert.deepEqual(
-    violations,
-    [],
-    `Personal hardcoded user paths found in source:\n${violations.join("\n")}`,
-  );
-});

package/src/core/githubDiagnostics.test.ts

@@ -1,92 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { 
-  parseRepoIdentity, 
-  classifyDiagnostics, 
-  type DiagnosticResult, 
-  type RepoIdentity 
-} from "./githubDiagnostics.js";
-
-test("parseRepoIdentity: handles various GitHub URL formats", () => {
-  const cases = [
-    {
-      url: "https://github.com/owner/repo.git",
-      expected: { owner: "owner", repo: "repo", provider: "github" }
-    },
-    {
-      url: "git@github.com:owner/repo.git",
-      expected: { owner: "owner", repo: "repo", provider: "github" }
-    },
-    {
-      url: "https://github.com/owner/repo",
-      expected: { owner: "owner", repo: "repo", provider: "github" }
-    },
-    {
-      url: "ssh://git@github.com/owner/repo.git",
-      expected: { owner: "owner", repo: "repo", provider: "github" }
-    }
-  ];
-
-  for (const { url, expected } of cases) {
-    const result = parseRepoIdentity(url);
-    assert.ok(result);
-    assert.equal(result.owner, expected.owner);
-    assert.equal(result.repo, expected.repo);
-    assert.equal(result.provider, expected.provider);
-  }
-});
-
-test("parseRepoIdentity: handles missing or non-GitHub origins", () => {
-  assert.equal(parseRepoIdentity(null), null);
-  assert.equal(parseRepoIdentity(""), null);
-  
-  const other = parseRepoIdentity("https://gitlab.com/owner/repo.git");
-  assert.ok(other);
-  assert.equal(other.provider, "other");
-});
-
-test("classifyDiagnostics: handles all status combinations", () => {
-  const repo: RepoIdentity = { owner: "o", repo: "r", provider: "github", remoteUrl: "..." };
-  
-  const pass: DiagnosticResult = { path: "p", status: "PASS", evidence: "e", blocker: null, recommendedUse: false };
-  const fail: DiagnosticResult = { path: "p", status: "FAIL", evidence: "e", blocker: "b", recommendedUse: false };
-  const partial: DiagnosticResult = { path: "p", status: "PARTIAL", evidence: "e", blocker: "b", recommendedUse: false };
-
-  // 1. All PASS -> Local Git + GH CLI
-  assert.equal(
-    classifyDiagnostics(repo, pass, pass, pass, fail),
-    "Local Git + GH CLI"
-  );
-
-  // 2. GH CLI missing but connector OK -> Connector-only
-  assert.equal(
-    classifyDiagnostics(repo, fail, pass, pass, pass),
-    "Local Git + connector PR creation"
-  );
-
-  // 3. .git write fails but connector OK -> Connector-only
-  assert.equal(
-    classifyDiagnostics(repo, pass, pass, fail, pass),
-    "Connector-only"
-  );
-
-  // 4. Connector read OK but write unknown (treated as PASS if not auth error)
-  assert.equal(
-    classifyDiagnostics(repo, fail, fail, fail, pass),
-    "Connector-only"
-  );
-
-  // 5. Connector permission rejected
-  const connectorRejected: DiagnosticResult = { path: "p", status: "PARTIAL", evidence: "e", blocker: "auth error", recommendedUse: false };
-  assert.equal(
-    classifyDiagnostics(repo, fail, fail, fail, connectorRejected),
-    "Cannot publish yet"
-  );
-
-  // 6. Non-GitHub repo
-  const otherRepo: RepoIdentity = { owner: "", repo: "", provider: "other", remoteUrl: "..." };
-  assert.equal(
-    classifyDiagnostics(otherRepo, pass, pass, pass, pass),
-    "Cannot publish yet"
-  );
-});

package/src/core/hollowResponseFormat.test.ts

@@ -1,58 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { formatHollowResponse } from "./hollowResponseFormat.js";
-import type { HollowResponseResult } from "./codexPrompt.js";
-
-function makeResult(kind: HollowResponseResult["kind"], reason = ""): HollowResponseResult {
-  return { isHollow: true, kind, reason };
-}
-
-test("greeting produces exactly 2 lines", () => {
-  const out = formatHollowResponse(makeResult("greeting"));
-  const lines = out.split("\n");
-  assert.equal(lines.length, 2);
-  assert.match(lines[0]!, /generic greeting/);
-  assert.match(lines[1]!, /Retry/);
-});
-
-test("filler produces exactly 2 lines", () => {
-  const out = formatHollowResponse(makeResult("filler"));
-  const lines = out.split("\n");
-  assert.equal(lines.length, 2);
-  assert.match(lines[0]!, /acknowledged without acting/);
-});
-
-test("clarification produces exactly 2 lines", () => {
-  const out = formatHollowResponse(makeResult("clarification"));
-  const lines = out.split("\n");
-  assert.equal(lines.length, 2);
-  assert.match(lines[0]!, /clarification/);
-  assert.match(lines[1]!, /suggest mode/);
-});
-
-test("short-no-action produces exactly 2 lines", () => {
-  const out = formatHollowResponse(makeResult("short-no-action"));
-  const lines = out.split("\n");
-  assert.equal(lines.length, 2);
-  assert.match(lines[0]!, /too brief/);
-});
-
-test("no emoji or warning symbols in any output", () => {
-  for (const kind of ["greeting", "filler", "clarification", "short-no-action"] as const) {
-    const out = formatHollowResponse(makeResult(kind));
-    assert.doesNotMatch(out, /⚠/);
-    assert.doesNotMatch(out, /---/);
-  }
-});
-
-test("verbose=false omits raw response", () => {
-  const out = formatHollowResponse(makeResult("greeting"), "Hello.");
-  assert.doesNotMatch(out, /Hello\./);
-});
-
-test("verbose=true appends raw response", () => {
-  const out = formatHollowResponse(makeResult("greeting"), "Hello.", true);
-  assert.match(out, /Backend response: Hello\./);
-  const lines = out.split("\n");
-  assert.equal(lines.length, 4); // 2 message lines + blank + backend response
-});

package/src/core/launchContext.test.ts

@@ -1,157 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-import test from "node:test";
-import {
-  buildWorkspaceStatusMessage,
-  createWorkspaceRelaunchPlan,
-  guardWorkspaceRelaunch,
-  resolveLaunchContext,
-} from "./launchContext.js";
-import { normalizeWorkspaceRoot } from "./workspaceRoot.js";
-
-function createTempWorkspace(): string {
-  return mkdtempSync(join(tmpdir(), "codexa-launch-context-"));
-}
-
-test("uses installed launcher metadata when available", () => {
-  const context = resolveLaunchContext({
-    workspaceRoot: "C:/target",
-    packageRoot: "C:/repo",
-    execPath: "C:/Program Files/nodejs/node.exe",
-    env: {
-      CODEXA_LAUNCH_KIND: "installed-bin",
-      CODEXA_PACKAGE_ROOT: "C:/repo",
-      CODEXA_LAUNCHER_SCRIPT: "C:/repo/bin/codexa.js",
-      CODEXA_RELAUNCH_EXECUTABLE: "C:/Program Files/nodejs/node.exe",
-      CODEXA_RELAUNCH_ARGS: JSON.stringify(["C:/repo/bin/codexa.js", "--profile", "review"]),
-    },
-  });
-
-  assert.equal(context.launchKind, "installed-bin");
-  assert.equal(context.packageRoot, "C:\\repo");
-  assert.equal(context.launcherScriptPath, "C:/repo/bin/codexa.js");
-  assert.equal(context.relaunchExecutable, "C:/Program Files/nodejs/node.exe");
-  assert.deepEqual(context.relaunchArgs, ["C:/repo/bin/codexa.js", "--profile", "review"]);
-});
-
-test("falls back to bun repo launch metadata when no installed launcher env exists", () => {
-  const context = resolveLaunchContext({
-    workspaceRoot: "C:/repo",
-    packageRoot: "C:/repo",
-    execPath: "C:/tools/bun.exe",
-    hasBunRuntime: true,
-    forwardArgs: ["--profile", "review", "--config", "model=\"gpt-5.4\""],
-    env: {},
-  });
-
-  assert.equal(context.launchKind, "dev-run");
-  assert.equal(context.relaunchExecutable, "C:/tools/bun.exe");
-  assert.deepEqual(context.relaunchArgs, [
-    "run",
-    "--silent",
-    join("C:\\repo", "src", "index.tsx"),
-    "--",
-    "--profile",
-    "review",
-    "--config",
-    "model=\"gpt-5.4\"",
-  ]);
-});
-
-test("creates an installed-bin relaunch plan with normalized target cwd and env", () => {
-  const root = createTempWorkspace();
-  try {
-    const nextWorkspace = join(root, "next");
-    mkdirSync(nextWorkspace);
-
-    const context = resolveLaunchContext({
-      workspaceRoot: root,
-      packageRoot: "C:/repo",
-      execPath: "C:/Program Files/nodejs/node.exe",
-      env: {
-        CODEXA_LAUNCH_KIND: "installed-bin",
-        CODEXA_PACKAGE_ROOT: "C:/repo",
-        CODEXA_LAUNCHER_SCRIPT: "C:/repo/bin/codexa.js",
-        CODEXA_RELAUNCH_EXECUTABLE: "C:/Program Files/nodejs/node.exe",
-        CODEXA_RELAUNCH_ARGS: JSON.stringify(["C:/repo/bin/codexa.js", "--profile", "review"]),
-      },
-    });
-
-    const result = createWorkspaceRelaunchPlan(".\\next", context, {});
-    assert.equal(result.ok, true);
-    if (!result.ok) return;
-
-    assert.equal(result.plan.executable, "C:/Program Files/nodejs/node.exe");
-    assert.deepEqual(result.plan.args, ["C:/repo/bin/codexa.js", "--profile", "review"]);
-    assert.equal(result.plan.cwd, normalizeWorkspaceRoot(nextWorkspace));
-    assert.equal(result.plan.env.CODEX_WORKSPACE_ROOT, normalizeWorkspaceRoot(nextWorkspace));
-    assert.equal(result.plan.env.CODEXA_LAUNCH_KIND, "installed-bin");
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("rejects relaunch targets that do not exist", () => {
-  const root = createTempWorkspace();
-  try {
-    const context = resolveLaunchContext({
-      workspaceRoot: root,
-      packageRoot: root,
-      execPath: "C:/tools/bun.exe",
-      hasBunRuntime: true,
-      env: {},
-    });
-
-    const result = createWorkspaceRelaunchPlan(".\\missing", context, {});
-    assert.equal(result.ok, false);
-    if (result.ok) return;
-    assert.match(result.message, /does not exist/i);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("rejects relaunch targets that are files instead of directories", () => {
-  const root = createTempWorkspace();
-  try {
-    const fileTarget = join(root, "notes.txt");
-    writeFileSync(fileTarget, "hello", "utf8");
-    const context = resolveLaunchContext({
-      workspaceRoot: root,
-      packageRoot: root,
-      execPath: "C:/tools/bun.exe",
-      hasBunRuntime: true,
-      env: {},
-    });
-
-    const result = createWorkspaceRelaunchPlan(".\\notes.txt", context, {});
-    assert.equal(result.ok, false);
-    if (result.ok) return;
-    assert.match(result.message, /not a directory/i);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("blocks workspace relaunch while busy", () => {
-  assert.deepEqual(guardWorkspaceRelaunch(false), { allowed: true });
-  assert.equal(guardWorkspaceRelaunch(true).allowed, false);
-  assert.match(guardWorkspaceRelaunch(true).message ?? "", /finish the current run/i);
-});
-
-test("describes dev launch mode with install guidance", () => {
-  const message = buildWorkspaceStatusMessage(resolveLaunchContext({
-    workspaceRoot: "C:/repo",
-    packageRoot: "C:/repo",
-    execPath: "C:/tools/bun.exe",
-    hasBunRuntime: true,
-    env: {},
-  }));
-
-  assert.match(message, /Launch mode: dev\/repo launch/i);
-  assert.match(message, /npm link/i);
-  assert.match(message, /where codexa/i);
-  assert.match(message, /\/workspace relaunch <path>/i);
-});

package/src/core/models/codexCapabilities.test.ts

@@ -1,45 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { parseCodexCliCapabilities } from "./codexCapabilities.js";
-
-test("detects exec help flags and strips ANSI noise", () => {
-  const capabilities = parseCodexCliCapabilities(
-    "\u001B[32mOptions:\u001B[0m\n  --ask-for-approval <policy>\n  --sandbox <mode>\n  -c, --config <key=value>\n",
-    "Global options:\n  --ask-for-approval <policy>\n",
-  );
-
-  assert.deepEqual(capabilities, {
-    askForApproval: true,
-    sandbox: true,
-    config: true,
-    fullAuto: false,
-  });
-});
-
-test("does not promote top-level approval flags into exec capabilities", () => {
-  const capabilities = parseCodexCliCapabilities(
-    "Usage: codex exec [OPTIONS]\n  --sandbox <mode>\n  --full-auto\n",
-    "Global options:\n  --ask-for-approval <policy>\n  --sandbox <mode>\n  --full-auto\n",
-  );
-
-  assert.deepEqual(capabilities, {
-    askForApproval: false,
-    sandbox: true,
-    config: false,
-    fullAuto: true,
-  });
-});
-
-test("requires exact option tokens instead of prose guesses", () => {
-  const capabilities = parseCodexCliCapabilities(
-    "This build documents ask-for-approval compatibility in prose only.\nIt also mentions sandbox_mode in config docs.\n",
-    "Use full auto mode for trusted environments.\n",
-  );
-
-  assert.deepEqual(capabilities, {
-    askForApproval: false,
-    sandbox: false,
-    config: false,
-    fullAuto: false,
-  });
-});