@golba98/codexa 1.0.1 → 1.0.3

package/src/config/launchArgs.test.ts

@@ -1,158 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { parseLaunchArgs } from "./launchArgs.js";
-
-test("parses profile and repeated config overrides", () => {
-  const parsed = parseLaunchArgs([
-    "--profile",
-    "review",
-    "--config",
-    "model=\"gpt-5.4\"",
-    "-c",
-    "codexa.mode=\"suggest\"",
-  ]);
-
-  assert.equal(parsed.ok, true);
-  if (!parsed.ok) return;
-
-  assert.equal(parsed.value.help, false);
-  assert.equal(parsed.value.version, false);
-  assert.equal(parsed.value.initialPrompt, null);
-  assert.equal(parsed.value.profile, "review");
-  assert.deepEqual(parsed.value.configOverrides, [
-    "model=\"gpt-5.4\"",
-    "codexa.mode=\"suggest\"",
-  ]);
-  assert.deepEqual(parsed.value.passthroughArgs, [
-    "--profile",
-    "review",
-    "--config",
-    "model=\"gpt-5.4\"",
-    "-c",
-    "codexa.mode=\"suggest\"",
-  ]);
-});
-
-test("rejects missing profile values", () => {
-  const parsed = parseLaunchArgs(["--profile"]);
-  assert.equal(parsed.ok, false);
-  if (parsed.ok) return;
-  assert.match(parsed.error, /--profile/i);
-});
-
-test("rejects malformed config payloads", () => {
-  const parsed = parseLaunchArgs(["--config", "model"]);
-  assert.equal(parsed.ok, false);
-  if (parsed.ok) return;
-  assert.match(parsed.error, /key=value/i);
-});
-
-test("parses inline profile and config assignments", () => {
-  const parsed = parseLaunchArgs([
-    "--profile=review",
-    "--config=model=\"gpt-5.4-mini\"",
-    "-c=codexa.mode=\"auto-edit\"",
-  ]);
-
-  assert.equal(parsed.ok, true);
-  if (!parsed.ok) return;
-
-  assert.equal(parsed.value.profile, "review");
-  assert.deepEqual(parsed.value.configOverrides, [
-    "model=\"gpt-5.4-mini\"",
-    "codexa.mode=\"auto-edit\"",
-  ]);
-  assert.deepEqual(parsed.value.passthroughArgs, [
-    "--profile=review",
-    "--config=model=\"gpt-5.4-mini\"",
-    "-c=codexa.mode=\"auto-edit\"",
-  ]);
-});
-
-test("parses model flags as runtime config overrides", () => {
-  const parsed = parseLaunchArgs([
-    "--model",
-    "gpt-5.3-codex",
-    "-m",
-    "gpt-5.4-mini",
-    "Say",
-    "READY",
-    "only.",
-  ]);
-
-  assert.equal(parsed.ok, true);
-  if (!parsed.ok) return;
-
-  assert.equal(parsed.value.initialPrompt, "Say READY only.");
-  assert.deepEqual(parsed.value.configOverrides, [
-    "model=\"gpt-5.3-codex\"",
-    "model=\"gpt-5.4-mini\"",
-  ]);
-  assert.deepEqual(parsed.value.passthroughArgs, [
-    "--model",
-    "gpt-5.3-codex",
-    "-m",
-    "gpt-5.4-mini",
-  ]);
-  // Last --model flag wins (same order as layered config)
-  assert.equal(parsed.value.modelOverride, "gpt-5.4-mini");
-});
-
-test("parses inline model flag assignment", () => {
-  const parsed = parseLaunchArgs(["--model=gpt-5.5", "compare", "this"]);
-
-  assert.equal(parsed.ok, true);
-  if (!parsed.ok) return;
-
-  assert.equal(parsed.value.initialPrompt, "compare this");
-  assert.deepEqual(parsed.value.configOverrides, ["model=\"gpt-5.5\""]);
-  assert.deepEqual(parsed.value.passthroughArgs, ["--model=gpt-5.5"]);
-  assert.equal(parsed.value.modelOverride, "gpt-5.5");
-});
-
-test("modelOverride is null when no --model flag is given", () => {
-  const parsed = parseLaunchArgs(["--profile", "review", "some", "prompt"]);
-
-  assert.equal(parsed.ok, true);
-  if (!parsed.ok) return;
-
-  assert.equal(parsed.value.modelOverride, null);
-});
-
-test("rejects missing model flag values", () => {
-  const parsed = parseLaunchArgs(["--model"]);
-  assert.equal(parsed.ok, false);
-  if (parsed.ok) return;
-  assert.match(parsed.error, /--model/i);
-});
-
-test("parses help and version flags without passthrough", () => {
-  const parsed = parseLaunchArgs(["--help", "-v"]);
-  assert.equal(parsed.ok, true);
-  if (!parsed.ok) return;
-
-  assert.equal(parsed.value.help, true);
-  assert.equal(parsed.value.version, true);
-  assert.equal(parsed.value.initialPrompt, null);
-  assert.deepEqual(parsed.value.passthroughArgs, []);
-});
-
-test("parses positional arguments as an initial prompt", () => {
-  const parsed = parseLaunchArgs(["--profile", "review", "explain", "this", "repo"]);
-  assert.equal(parsed.ok, true);
-  if (!parsed.ok) return;
-
-  assert.equal(parsed.value.profile, "review");
-  assert.equal(parsed.value.initialPrompt, "explain this repo");
-  assert.deepEqual(parsed.value.passthroughArgs, ["--profile", "review"]);
-});
-
-test("parses arguments after -- as an initial prompt", () => {
-  const parsed = parseLaunchArgs(["--", "--help", "as", "text"]);
-  assert.equal(parsed.ok, true);
-  if (!parsed.ok) return;
-
-  assert.equal(parsed.value.help, false);
-  assert.equal(parsed.value.initialPrompt, "--help as text");
-  assert.deepEqual(parsed.value.passthroughArgs, []);
-});

package/src/config/layeredConfig.test.ts

@@ -1,143 +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";
-
-function writeText(filePath: string, contents: string): void {
-  mkdirSync(join(filePath, ".."), { recursive: true });
-  writeFileSync(filePath, contents, "utf-8");
-}
-
-test("resolves user config, trusted project config, profiles, and CLI overrides deterministically", async () => {
-  const tempRoot = mkdtempSync(join(tmpdir(), "codexa-layered-config-"));
-  const tempHome = join(tempRoot, "home");
-  const workspaceRoot = join(tempRoot, "repo", "packages", "app");
-  const projectRoot = join(tempRoot, "repo");
-  const previousCodexHome = process.env.CODEX_HOME;
-  process.env.CODEX_HOME = tempHome;
-
-  try {
-    mkdirSync(join(projectRoot, ".git"), { recursive: true });
-    mkdirSync(join(workspaceRoot, ".codex"), { recursive: true });
-    mkdirSync(join(projectRoot, ".codex"), { recursive: true });
-    mkdirSync(tempHome, { recursive: true });
-
-    writeFileSync(join(tempHome, "config.toml"), [
-      "model = \"gpt-5.2\"",
-      "[codexa]",
-      "backend = \"openai-native\"",
-      "",
-      "[profiles.review]",
-      "service_tier = \"fast\"",
-    ].join("\n"), "utf-8");
-
-    writeFileSync(join(projectRoot, ".codex", "config.toml"), [
-      "model = \"gpt-5.4\"",
-      "profile = \"review\"",
-      "[codexa]",
-      "mode = \"suggest\"",
-      "",
-      "[profiles.review]",
-      "approval_policy = \"never\"",
-      "",
-      "[profiles.review.sandbox_workspace_write]",
-      "network_access = true",
-      "writable_roots = [\"./roots/project\"]",
-    ].join("\n"), "utf-8");
-
-    writeFileSync(join(workspaceRoot, ".codex", "config.toml"), [
-      "personality = \"pragmatic\"",
-      "",
-      "[profiles.review]",
-      "model_reasoning_effort = \"high\"",
-    ].join("\n"), "utf-8");
-
-    const trustStore = await import(`./trustStore.js?layered-trust=${Date.now()}`);
-    trustStore.setProjectTrust(projectRoot, true);
-
-    const layeredConfig = await import(`./layeredConfig.js?layered=${Date.now()}`);
-    const result = layeredConfig.resolveLayeredConfig({
-      workspaceRoot,
-      launchArgs: {
-        help: false,
-        version: false,
-        initialPrompt: null,
-        profile: null,
-        configOverrides: [
-          "model=\"gpt-5.4-mini\"",
-          "codexa.mode=\"full-auto\"",
-          "mcp.enabled=true",
-        ],
-        passthroughArgs: [],
-        modelOverride: "gpt-5.4-mini",
-      },
-    });
-
-    assert.equal(result.runtime.provider, "openai-native");
-    assert.equal(result.runtime.model, "gpt-5.4-mini");
-    assert.equal(result.runtime.reasoningLevel, "high");
-    assert.equal(result.runtime.mode, "full-auto");
-    assert.equal(result.runtime.policy.approvalPolicy, "never");
-    assert.equal(result.runtime.policy.networkAccess, "enabled");
-    assert.equal(result.runtime.policy.serviceTier, "fast");
-    assert.equal(result.runtime.policy.personality, "pragmatic");
-    assert.equal(result.diagnostics.selectedProfile, "review");
-    assert.equal(result.diagnostics.selectedProfileSource, "Project config");
-    assert.equal(result.diagnostics.projectTrusted, true);
-    assert.match(result.runtime.policy.writableRoots[0] ?? "", /roots[\\/]project/i);
-    assert.match(result.diagnostics.fieldSources.model, /CLI override/i);
-    assert.match(result.diagnostics.fieldSources["policy.approvalPolicy"], /Profile review from Project config/i);
-    assert.ok(result.diagnostics.ignoredEntries.some((entry: string) => /mcp\.enabled/i.test(entry)));
-  } finally {
-    if (previousCodexHome === undefined) {
-      delete process.env.CODEX_HOME;
-    } else {
-      process.env.CODEX_HOME = previousCodexHome;
-    }
-    rmSync(tempRoot, { recursive: true, force: true });
-  }
-});
-
-test("blocks project config when the detected project root is untrusted", async () => {
-  const tempRoot = mkdtempSync(join(tmpdir(), "codexa-layered-untrusted-"));
-  const tempHome = join(tempRoot, "home");
-  const workspaceRoot = join(tempRoot, "repo", "app");
-  const projectRoot = join(tempRoot, "repo");
-  const previousCodexHome = process.env.CODEX_HOME;
-  process.env.CODEX_HOME = tempHome;
-
-  try {
-    mkdirSync(join(projectRoot, ".git"), { recursive: true });
-    mkdirSync(join(projectRoot, ".codex"), { recursive: true });
-    mkdirSync(tempHome, { recursive: true });
-
-    writeFileSync(join(tempHome, "config.toml"), "model = \"gpt-5.2\"\n", "utf-8");
-    writeFileSync(join(projectRoot, ".codex", "config.toml"), "model = \"gpt-5.4-mini\"\n", "utf-8");
-
-    const layeredConfig = await import(`./layeredConfig.js?untrusted=${Date.now()}`);
-    const result = layeredConfig.resolveLayeredConfig({
-      workspaceRoot,
-      launchArgs: {
-        help: false,
-        version: false,
-        initialPrompt: null,
-        profile: null,
-        configOverrides: [],
-        passthroughArgs: [],
-        modelOverride: null,
-      },
-    });
-
-    assert.equal(result.runtime.model, "gpt-5.2");
-    assert.equal(result.diagnostics.projectTrusted, false);
-    assert.ok(result.diagnostics.layers.some((layer: { status: string }) => layer.status === "blocked"));
-  } finally {
-    if (previousCodexHome === undefined) {
-      delete process.env.CODEX_HOME;
-    } else {
-      process.env.CODEX_HOME = previousCodexHome;
-    }
-    rmSync(tempRoot, { recursive: true, force: true });
-  }
-});

package/src/config/persistence.test.ts

@@ -1,110 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { mergeRuntimeIntoTomlConfig } from "./layeredConfig.js";
-import { DEFAULT_RUNTIME_CONFIG } from "./runtimeConfig.js";
-import {
-  extractLegacyRuntime,
-  getDefaultSettings,
-  parseSettingsData,
-  serializeSettings,
-} from "./persistence.js";
-
-test("extracts legacy flat runtime settings for migration", () => {
-  const runtime = extractLegacyRuntime({
-    backend: "codex-subprocess",
-    model: "gpt-5.4-mini",
-    mode: "suggest",
-    reasoning_level: "medium",
-  });
-
-  assert.equal(runtime?.model, "gpt-5.4-mini");
-  assert.equal(runtime?.mode, "suggest");
-  assert.equal(runtime?.reasoningLevel, "medium");
-});
-
-test("keeps UI and auth settings separate from runtime persistence", () => {
-  const initial = {
-    ui: {
-      layoutStyle: "gemini-shell",
-      theme: "purple",
-      workspaceDisplayMode: "simple" as const,
-      terminalTitleMode: "name" as const,
-      showBusyLoader: false,
-      terminalMouseMode: "selection" as const,
-      customTheme: { TEXT: "#fff" },
-    },
-    auth: {
-      preference: "runner-managed" as const,
-    },
-    header: {
-      showBrand: true,
-      showWorkspace: true,
-      showProvider: false,
-      showModel: false,
-      showReasoning: false,
-      showContext: false,
-      showAuthStatus: false,
-    },
-  };
-
-  const serialized = serializeSettings(initial);
-  const parsed = parseSettingsData(serialized);
-
-  assert.equal("runtime" in serialized, false);
-  assert.equal(parsed.ui.theme, "purple");
-  assert.equal(parsed.ui.workspaceDisplayMode, "simple");
-  assert.equal(parsed.ui.terminalTitleMode, "name");
-  assert.equal(parsed.ui.showBusyLoader, false);
-  assert.equal(parsed.ui.terminalMouseMode, "selection");
-  assert.equal(parsed.auth.preference, "runner-managed");
-});
-
-test("falls back to defaults for missing UI or auth preferences", () => {
-  const parsed = parseSettingsData({});
-  const defaults = getDefaultSettings();
-
-  assert.equal(parsed.ui.layoutStyle, defaults.ui.layoutStyle);
-  assert.equal(parsed.ui.theme, defaults.ui.theme);
-  assert.equal(parsed.ui.workspaceDisplayMode, defaults.ui.workspaceDisplayMode);
-  assert.equal(parsed.ui.terminalTitleMode, defaults.ui.terminalTitleMode);
-  assert.equal(parsed.ui.showBusyLoader, defaults.ui.showBusyLoader);
-  assert.equal(parsed.auth.preference, defaults.auth.preference);
-});
-
-test("maps legacy directory display settings into workspace display mode", () => {
-  assert.equal(parseSettingsData({ directory_display_mode: "normal" }).ui.workspaceDisplayMode, "dir");
-  assert.equal(parseSettingsData({ directoryDisplayMode: "simple" }).ui.workspaceDisplayMode, "simple");
-});
-
-test("parses workspace display and busy loader from camel and snake case", () => {
-  assert.equal(parseSettingsData({ workspace_display_mode: "name", terminal_title_mode: "simple", show_busy_loader: false }).ui.workspaceDisplayMode, "name");
-  assert.equal(parseSettingsData({ workspaceDisplayMode: "dir", terminalTitleMode: "name", showBusyLoader: true }).ui.showBusyLoader, true);
-  assert.equal(parseSettingsData({ terminalTitleMode: "name" }).ui.terminalTitleMode, "name");
-});
-
-test("merges legacy runtime fields into TOML without overwriting existing values", () => {
-  const merged = mergeRuntimeIntoTomlConfig({
-    model: "gpt-5.4",
-    codexa: {
-      mode: "suggest",
-    },
-  }, {
-    ...DEFAULT_RUNTIME_CONFIG,
-    model: "gpt-5.4-mini",
-    mode: "full-auto",
-    policy: {
-      ...DEFAULT_RUNTIME_CONFIG.policy,
-      networkAccess: "enabled",
-      writableRoots: ["C:\\safe"],
-      personality: "pragmatic",
-    },
-  });
-
-  assert.equal(merged.model, "gpt-5.4");
-  assert.deepEqual(merged.codexa, { mode: "suggest" });
-  assert.deepEqual(merged.sandbox_workspace_write, {
-    network_access: true,
-    writable_roots: ["C:\\safe"],
-  });
-  assert.equal(merged.personality, "pragmatic");
-});

package/src/config/runtimeConfig.test.ts

@@ -1,218 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  DEFAULT_RUNTIME_CONFIG,
-  addWritableRoot,
-  buildRuntimeSummary,
-  buildCodexConfigOverrides,
-  diffRuntimeConfig,
-  formatPermissionsStatus,
-  formatRuntimeStatus,
-  mergeRuntimeConfig,
-  normalizeRuntimeConfig,
-  removeWritableRoot,
-  resolveRuntimeConfig,
-} from "./runtimeConfig.js";
-
-test("defaults resolve into a concrete runtime config", () => {
-  const resolved = resolveRuntimeConfig(DEFAULT_RUNTIME_CONFIG);
-
-  assert.equal(resolved.model, DEFAULT_RUNTIME_CONFIG.model);
-  assert.equal(resolved.mode, DEFAULT_RUNTIME_CONFIG.mode);
-  assert.equal(resolved.planMode, false);
-  assert.equal(resolved.policy.approvalPolicy, "on-request");
-  assert.equal(resolved.policy.sandboxMode, "workspace-write");
-  assert.equal(resolved.policy.networkAccess, false);
-  assert.equal(resolved.policy.serviceTier, "flex");
-  assert.equal(resolved.policy.personality, "none");
-});
-
-test("mode inheritance resolves to expected approval and sandbox policies", () => {
-  const suggest = resolveRuntimeConfig(normalizeRuntimeConfig({ mode: "suggest" }));
-  const autoEdit = resolveRuntimeConfig(normalizeRuntimeConfig({ mode: "auto-edit" }));
-  const fullAuto = resolveRuntimeConfig(normalizeRuntimeConfig({ mode: "full-auto" }));
-
-  assert.equal(suggest.policy.sandboxMode, "read-only");
-  assert.equal(suggest.policy.approvalPolicy, "on-request");
-  assert.equal(autoEdit.policy.sandboxMode, "workspace-write");
-  assert.equal(fullAuto.policy.sandboxMode, "workspace-write");
-});
-
-test("explicit policy overrides beat inherited mode defaults", () => {
-  const resolved = resolveRuntimeConfig(normalizeRuntimeConfig({
-    mode: "suggest",
-    policy: {
-      approvalPolicy: "never",
-      sandboxMode: "danger-full-access",
-      networkAccess: "enabled",
-    },
-  }));
-
-  assert.equal(resolved.policy.approvalPolicy, "never");
-  assert.equal(resolved.policy.sandboxMode, "danger-full-access");
-  assert.equal(resolved.policy.networkAccess, true);
-});
-
-test("writable roots normalize and dedupe", () => {
-  const withRoots = addWritableRoot(addWritableRoot(DEFAULT_RUNTIME_CONFIG, "C:/Repo"), "C:\\Repo\\");
-  assert.equal(withRoots.policy.writableRoots.length, 1);
-
-  const removed = removeWritableRoot(withRoots, "c:/repo");
-  assert.equal(removed.policy.writableRoots.length, 0);
-});
-
-test("writable root normalization strips redundant trailing separators", () => {
-  const normalized = normalizeRuntimeConfig({
-    policy: {
-      writableRoots: ["C:\\Repo\\", "C:\\Repo", "C:\\Repo\\\\nested\\..\\"],
-    },
-  });
-
-  assert.deepEqual(normalized.policy.writableRoots, ["C:\\Repo"]);
-});
-
-test("merges runtime overrides onto a canonical base", () => {
-  const merged = mergeRuntimeConfig(DEFAULT_RUNTIME_CONFIG, {
-    model: "gpt-5.4-mini",
-    planMode: true,
-    policy: {
-      writableRoots: ["C:/Repo/extra"],
-      serviceTier: "fast",
-    },
-  });
-
-  assert.equal(merged.model, "gpt-5.4-mini");
-  assert.equal(merged.planMode, true);
-  assert.deepEqual(merged.policy.writableRoots, ["C:\\Repo\\extra"]);
-  assert.equal(merged.policy.serviceTier, "fast");
-});
-
-test("diffRuntimeConfig emits only fields that differ from the base", () => {
-  const target = normalizeRuntimeConfig({
-    model: "gpt-5.4-mini",
-    planMode: true,
-    policy: {
-      networkAccess: "enabled",
-      personality: "pragmatic",
-    },
-  });
-
-  assert.deepEqual(diffRuntimeConfig(DEFAULT_RUNTIME_CONFIG, target), {
-    model: "gpt-5.4-mini",
-    planMode: true,
-    policy: {
-      networkAccess: "enabled",
-      personality: "pragmatic",
-    },
-  });
-});
-
-test("builds deterministic codex config overrides", () => {
-  const resolved = resolveRuntimeConfig(normalizeRuntimeConfig({
-    model: "gpt-5.4-mini",
-    mode: "suggest",
-    reasoningLevel: "medium",
-    policy: {
-      approvalPolicy: "never",
-      sandboxMode: "workspace-write",
-      networkAccess: "enabled",
-      writableRoots: ["C:/Repo/extra"],
-      serviceTier: "fast",
-      personality: "pragmatic",
-    },
-  }));
-  const writableRoot = resolved.policy.writableRoots[0];
-
-  assert.deepEqual(buildCodexConfigOverrides(resolved), [
-    "model_reasoning_effort=medium",
-    "approval_policy=never",
-    "sandbox_workspace_write.network_access=true",
-    `sandbox_workspace_write.writable_roots=${JSON.stringify([writableRoot])}`,
-    "service_tier=fast",
-    "personality=pragmatic",
-  ]);
-});
-
-test("builds runtime summary with network and writable-root indicators", () => {
-  const summary = buildRuntimeSummary(resolveRuntimeConfig(normalizeRuntimeConfig({
-    policy: {
-      networkAccess: "enabled",
-      writableRoots: ["C:/Repo/extra"],
-    },
-  })));
-
-  assert.equal(summary.networkLabel, "Net: on");
-  assert.equal(summary.writableRootsLabel, "Roots: 1");
-});
-
-test("formats permissions status with configured and effective policy", () => {
-  const runtime = normalizeRuntimeConfig({
-    mode: "suggest",
-    policy: {
-      approvalPolicy: "inherit",
-      sandboxMode: "inherit",
-      networkAccess: "enabled",
-      writableRoots: ["C:/Repo/extra"],
-    },
-  });
-  const status = formatPermissionsStatus(runtime, resolveRuntimeConfig(runtime), "C:\\Workspace");
-
-  assert.match(status, /Permissions status:/);
-  assert.match(status, /Approval policy: configured Inherit; effective On request/);
-  assert.match(status, /Network access: configured Enabled; effective Enabled/);
-  assert.match(status, /Configured:/);
-  assert.match(status, /Effective:/);
-});
-
-test("formats runtime status with effective policy details", () => {
-  const resolved = resolveRuntimeConfig(DEFAULT_RUNTIME_CONFIG);
-  const status = formatRuntimeStatus(resolved, {
-    workspaceRoot: "C:\\Workspace",
-    tokensUsed: 512,
-  });
-
-  assert.match(status, /Provider:/);
-  assert.match(status, /Plan mode: Disabled/);
-  assert.match(status, /Approval policy:/);
-  assert.match(status, /Sandbox mode:/);
-  assert.match(status, /Tokens used: ~512/);
-});
-
-test("formats runtime status with loaded project instructions", () => {
-  const resolved = resolveRuntimeConfig(DEFAULT_RUNTIME_CONFIG);
-  const status = formatRuntimeStatus(resolved, {
-    workspaceRoot: "C:\\Workspace",
-    projectInstructions: {
-      status: "loaded",
-      instructions: { path: "C:\\Workspace\\AGENTS.md", content: "# Instructions" },
-    },
-  });
-
-  assert.match(status, /Project instructions: loaded/);
-  assert.match(status, /Source: C:\\Workspace\\AGENTS\.md/);
-});
-
-test("formats runtime status with project instructions error", () => {
-  const resolved = resolveRuntimeConfig(DEFAULT_RUNTIME_CONFIG);
-  const status = formatRuntimeStatus(resolved, {
-    workspaceRoot: "C:\\Workspace",
-    projectInstructions: {
-      status: "error",
-      path: "C:\\Workspace\\AGENTS.md",
-      message: "ENOENT: file not found",
-    },
-  });
-
-  assert.match(status, /Project instructions: error/);
-  assert.match(status, /ENOENT/);
-});
-
-test("formats runtime status with missing project instructions", () => {
-  const resolved = resolveRuntimeConfig(DEFAULT_RUNTIME_CONFIG);
-  const status = formatRuntimeStatus(resolved, {
-    workspaceRoot: "C:\\Workspace",
-    projectInstructions: { status: "missing" },
-  });
-
-  assert.match(status, /Project instructions: none/);
-});