@golba98/codexa 1.0.2 → 1.0.4

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

@@ -1,212 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { afterEach } from "node:test";
-import type { ChildProcess } from "node:child_process";
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { runCommand, type CommandResult } from "../process/CommandRunner.js";
-import {
-  resolveCodexExecutable,
-  resetCodexExecutableCacheForTests,
-  spawnCodexProcess,
-} from "./codexExecutable.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;
-}
-
-async function withEnv<T>(env: Partial<NodeJS.ProcessEnv>, callback: () => Promise<T>): Promise<T> {
-  const originalCodexExe = process.env.CODEX_EXECUTABLE;
-  try {
-    if ("CODEX_EXECUTABLE" in env) process.env.CODEX_EXECUTABLE = env.CODEX_EXECUTABLE;
-    else delete process.env.CODEX_EXECUTABLE;
-    resetCodexExecutableCacheForTests();
-    return await callback();
-  } finally {
-    if (originalCodexExe === undefined) delete process.env.CODEX_EXECUTABLE;
-    else process.env.CODEX_EXECUTABLE = originalCodexExe;
-    resetCodexExecutableCacheForTests();
-  }
-}
-
-afterEach(() => {
-  resetCodexExecutableCacheForTests();
-});
-
-test("Codex resolver: configuredPath wins and bypasses env and PATH", async () => {
-  await withEnv({ CODEX_EXECUTABLE: "env-codex.cmd" }, async () => {
-    let whereCalled = false;
-    const resolved = await resolveCodexExecutable({
-      configuredPath: process.execPath,
-      runCommandImpl: mockRunCommand(commandResult(), () => { whereCalled = true; }),
-    });
-
-    assert.equal(resolved, process.execPath);
-    assert.equal(whereCalled, false, "where.exe should not be called when configuredPath is set");
-  });
-});
-
-test("Codex resolver: CODEX_EXECUTABLE env var used when no configuredPath", async () => {
-  await withEnv({ CODEX_EXECUTABLE: "env-codex.cmd" }, async () => {
-    let whereCalled = false;
-    const resolved = await resolveCodexExecutable({
-      runCommandImpl: mockRunCommand(commandResult(), () => { whereCalled = true; }),
-    });
-
-    assert.equal(resolved, "env-codex.cmd");
-    assert.equal(whereCalled, false, "where.exe should not be called when CODEX_EXECUTABLE is set");
-  });
-});
-
-test("Codex resolver: rejects unsafe CODEX_EXECUTABLE values", async () => {
-  await withEnv({ CODEX_EXECUTABLE: "codex.cmd & calc" }, async () => {
-    await assert.rejects(
-      () => resolveCodexExecutable({
-        runCommandImpl: mockRunCommand(commandResult()),
-      }),
-      /shell metacharacters|single executable name/i,
-    );
-  });
-});
-
-test("Codex resolver: accepts environment executable paths with spaces", async () => {
-  const tempRoot = join(tmpdir(), `codexa codex resolver ${Date.now()}`);
-  const codexPath = join(tempRoot, "codex cli.exe");
-  mkdirSync(tempRoot, { recursive: true });
-  writeFileSync(codexPath, "");
-  try {
-    await withEnv({ CODEX_EXECUTABLE: `"${codexPath}"` }, async () => {
-      const resolved = await resolveCodexExecutable({
-        runCommandImpl: mockRunCommand(commandResult()),
-      });
-      assert.equal(resolved, codexPath);
-    });
-  } finally {
-    rmSync(tempRoot, { recursive: true, force: true });
-  }
-});
-
-test("Codex resolver: Windows where.exe PATH lookup used when no env or config", async () => {
-  if (process.platform !== "win32") return;
-
-  const resolvedPath = join(tmpdir(), "codex.cmd");
-  writeFileSync(resolvedPath, "");
-  await withEnv({}, async () => {
-    const calls: Array<Parameters<typeof runCommand>[0]> = [];
-    const resolved = await resolveCodexExecutable({
-      runCommandImpl: mockRunCommand(
-        commandResult({ stdout: `${resolvedPath}\n` }),
-        (spec) => calls.push(spec),
-      ),
-    });
-
-    assert.equal(resolved, resolvedPath);
-    const whereCall = calls.find((c) => c.executable === "where.exe");
-    assert.ok(whereCall, "where.exe should have been called");
-  });
-});
-
-test("Codex resolver: bare fallback returned when nothing found (non-Windows)", async () => {
-  if (process.platform === "win32") return;
-
-  await withEnv({}, async () => {
-    const resolved = await resolveCodexExecutable({
-      runCommandImpl: mockRunCommand(commandResult({ exitCode: 1, status: "failed" })),
-    });
-
-    assert.equal(resolved, "codex", "Should fall back to bare codex name");
-  });
-});
-
-test("Codex resolver: Windows bare fallback when where.exe fails", async () => {
-  if (process.platform !== "win32") return;
-
-  await withEnv({}, async () => {
-    const resolved = await resolveCodexExecutable({
-      runCommandImpl: mockRunCommand(commandResult({ exitCode: 1, status: "failed" })),
-    });
-
-    assert.ok(["codex.cmd", "codex.exe", "codex"].includes(resolved), `Unexpected fallback: ${resolved}`);
-  });
-});
-
-test("Codex resolver: cache is populated after first resolution", async () => {
-  await withEnv({ CODEX_EXECUTABLE: "env-codex.cmd" }, async () => {
-    const first = await resolveCodexExecutable();
-    const second = await resolveCodexExecutable();
-
-    assert.equal(first, second);
-    assert.equal(first, "env-codex.cmd");
-  });
-});
-
-test("Codex resolver: configuredPath bypasses cache", async () => {
-  await withEnv({ CODEX_EXECUTABLE: "env-codex.cmd" }, async () => {
-    const cached = await resolveCodexExecutable();
-    assert.equal(cached, "env-codex.cmd");
-
-    const withOverride = await resolveCodexExecutable({
-      configuredPath: process.execPath,
-    });
-    assert.equal(withOverride, process.execPath);
-
-    const afterOverride = await resolveCodexExecutable();
-    assert.equal(afterOverride, "env-codex.cmd", "Cache should not be polluted by configuredPath call");
-  });
-});
-
-test("Codex resolver: resetCodexExecutableCacheForTests clears state", async () => {
-  await withEnv({ CODEX_EXECUTABLE: "first.cmd" }, async () => {
-    const first = await resolveCodexExecutable();
-    assert.equal(first, "first.cmd");
-  });
-
-  resetCodexExecutableCacheForTests();
-
-  await withEnv({ CODEX_EXECUTABLE: "second.cmd" }, async () => {
-    const second = await resolveCodexExecutable();
-    assert.equal(second, "second.cmd");
-  });
-});
-
-test("spawnCodexProcess wraps .cmd in cmd.exe on Windows", () => {
-  if (process.platform !== "win32") return;
-
-  const codexPath = "C:\\Users\\Example\\AppData\\Roaming\\npm\\codex.cmd";
-  const proc = spawnCodexProcess(codexPath, ["exec", "--help"], { stdio: ["ignore", "pipe", "pipe"] });
-  proc.kill();
-
-  assert.ok(proc, "Process should have been spawned");
-});
-
-test("spawnCodexProcess uses executable directly on non-Windows", () => {
-  if (process.platform === "win32") return;
-
-  const proc = spawnCodexProcess("echo", ["hello"], { stdio: ["ignore", "pipe", "pipe"] });
-  proc.kill();
-
-  assert.ok(proc, "Process should have been spawned");
-});

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
-});