@os-eco/overstory-cli 0.8.2 → 0.8.4

package/src/commands/stop.test.ts

@@ -260,13 +260,61 @@ describe("stopCommand validation", () => {
 		await expect(stopCommand("my-builder", {}, deps)).rejects.toThrow(/already completed/);
 	});
 
-	test("throws AgentError when agent is already zombie", async () => {
+	test("succeeds when agent is zombie (cleanup, no error)", async () => {
 		const session = makeAgentSession({ state: "zombie" });
 		saveSessionsToDb([session]);
 
-		const { deps } = makeDeps();
-		await expect(stopCommand("my-builder", {}, deps)).rejects.toThrow(AgentError);
-		await expect(stopCommand("my-builder", {}, deps)).rejects.toThrow(/zombie/);
+		const { deps } = makeDeps({ [session.tmuxSession]: false });
+		const output = await captureStdout(() => stopCommand("my-builder", {}, deps));
+
+		expect(output).toContain("Agent stopped");
+		expect(output).toContain("Zombie agent cleaned up");
+
+		const { store } = openSessionStore(overstoryDir);
+		const updated = store.getByName("my-builder");
+		store.close();
+		expect(updated?.state).toBe("completed");
+	});
+});
+
+describe("stopCommand zombie cleanup", () => {
+	test("zombie + --clean-worktree removes worktree", async () => {
+		const session = makeAgentSession({ state: "zombie" });
+		saveSessionsToDb([session]);
+
+		const { deps, worktreeCalls } = makeDeps({ [session.tmuxSession]: false });
+		const output = await captureStdout(() =>
+			stopCommand("my-builder", { cleanWorktree: true }, deps),
+		);
+
+		expect(output).toContain("Agent stopped");
+		expect(output).toContain("Zombie agent cleaned up");
+		expect(output).toContain(`Worktree removed: ${session.worktreePath}`);
+		expect(worktreeCalls.remove).toHaveLength(1);
+
+		const { store } = openSessionStore(overstoryDir);
+		const updated = store.getByName("my-builder");
+		store.close();
+		expect(updated?.state).toBe("completed");
+	});
+
+	test("zombie + --json includes wasZombie: true", async () => {
+		const session = makeAgentSession({ state: "zombie" });
+		saveSessionsToDb([session]);
+
+		const { deps } = makeDeps({ [session.tmuxSession]: false });
+		const output = await captureStdout(() => stopCommand("my-builder", { json: true }, deps));
+
+		const parsed = JSON.parse(output.trim()) as Record<string, unknown>;
+		expect(parsed.success).toBe(true);
+		expect(parsed.stopped).toBe(true);
+		expect(parsed.wasZombie).toBe(true);
+		expect(parsed.agentName).toBe("my-builder");
+
+		const { store } = openSessionStore(overstoryDir);
+		const updated = store.getByName("my-builder");
+		store.close();
+		expect(updated?.state).toBe("completed");
 	});
 });
 

package/src/commands/stop.ts

@@ -86,9 +86,7 @@ export async function stopCommand(
 			throw new AgentError(`Agent "${agentName}" is already completed`, { agentName });
 		}
 
-		if (session.state === "zombie") {
-			throw new AgentError(`Agent "${agentName}" is already zombie (dead)`, { agentName });
-		}
+		const isZombie = session.state === "zombie";
 
 		const isHeadless = session.tmuxSession === "" && session.pid !== null;
 
@@ -140,6 +138,7 @@ export async function stopCommand(
 				pidKilled,
 				worktreeRemoved,
 				force,
+				wasZombie: isZombie,
 			});
 		} else {
 			printSuccess("Agent stopped", agentName);
@@ -156,6 +155,9 @@ export async function stopCommand(
 					process.stdout.write(`  Tmux session was already dead\n`);
 				}
 			}
+			if (isZombie) {
+				process.stdout.write(`  Zombie agent cleaned up (state → completed)\n`);
+			}
 			if (cleanWorktree && worktreeRemoved) {
 				process.stdout.write(`  Worktree removed: ${session.worktreePath}\n`);
 			}

package/src/commands/supervisor.ts

@@ -143,7 +143,7 @@ async function startSupervisor(opts: {
 		);
 		const manifest = await manifestLoader.load();
 		const resolvedModel = resolveModel(config, manifest, "supervisor", "opus");
-		const runtime = getRuntime(undefined, config);
+		const runtime = getRuntime(undefined, config, "supervisor");
 
 		// Deploy supervisor-specific hooks to the project root's .claude/ directory.
 		await runtime.deployConfig(projectRoot, undefined, {

package/src/config.test.ts

@@ -4,6 +4,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
 	clearProjectRootOverride,
+	clearWarningsSeen,
 	DEFAULT_CONFIG,
 	DEFAULT_QUALITY_GATES,
 	loadConfig,
@@ -432,9 +433,11 @@ describe("validateConfig", () => {
 		tempDir = await mkdtemp(join(tmpdir(), "overstory-test-"));
 		const { mkdir } = await import("node:fs/promises");
 		await mkdir(join(tempDir, ".overstory"), { recursive: true });
+		clearWarningsSeen();
 	});
 
 	afterEach(async () => {
+		clearWarningsSeen();
 		await cleanupTempDir(tempDir);
 	});
 
@@ -691,6 +694,39 @@ models:
 		expect((err as ValidationError).message).toContain("provider-prefixed ref");
 	});
 
+	test("accepts bare model name when runtime.default is codex", async () => {
+		await writeConfig(`
+runtime:
+  default: codex
+models:
+  coordinator: gpt-5.3-codex
+`);
+		const config = await loadConfig(tempDir);
+		expect(config.models.coordinator).toBe("gpt-5.3-codex");
+	});
+
+	test("warns on bare non-Anthropic model in tool-heavy role when runtime.default is codex", async () => {
+		await writeConfig(`
+runtime:
+  default: codex
+models:
+  builder: gpt-5.3-codex
+`);
+		const origWrite = process.stderr.write;
+		let capturedStderr = "";
+		process.stderr.write = ((s: string | Uint8Array) => {
+			if (typeof s === "string") capturedStderr += s;
+			return true;
+		}) as typeof process.stderr.write;
+		try {
+			await loadConfig(tempDir);
+		} finally {
+			process.stderr.write = origWrite;
+		}
+		expect(capturedStderr).toContain("WARNING: models.builder uses non-Anthropic model");
+		expect(capturedStderr).toContain("gpt-5.3-codex");
+	});
+
 	test("warns on non-Anthropic model in tool-heavy role", async () => {
 		await writeConfig(`
 providers:
@@ -716,6 +752,33 @@ models:
 		expect(capturedStderr).toContain("openrouter/openai/gpt-4");
 	});
 
+	test("warns only once per role/model combination across multiple loadConfig calls", async () => {
+		await writeConfig(`
+providers:
+  openrouter:
+    type: gateway
+    baseUrl: https://openrouter.ai/api/v1
+    authTokenEnv: OPENROUTER_API_KEY
+models:
+  builder: openrouter/openai/gpt-4
+`);
+		const origWrite = process.stderr.write;
+		const stderrLines: string[] = [];
+		process.stderr.write = ((s: string | Uint8Array) => {
+			if (typeof s === "string") stderrLines.push(s);
+			return true;
+		}) as typeof process.stderr.write;
+		try {
+			await loadConfig(tempDir);
+			await loadConfig(tempDir);
+			await loadConfig(tempDir);
+		} finally {
+			process.stderr.write = origWrite;
+		}
+		const warnings = stderrLines.filter((l) => l.includes("WARNING: models.builder"));
+		expect(warnings.length).toBe(1);
+	});
+
 	test("does not warn for non-Anthropic model in non-tool-heavy role", async () => {
 		await writeConfig(`
 providers:

package/src/config.ts

@@ -5,6 +5,14 @@ import type { OverstoryConfig, QualityGate, TaskTrackerBackend } from "./types.t
 // Module-level project root override (set by --project global flag)
 let _projectRootOverride: string | undefined;
 
+// Tracks warnings already emitted this process to avoid repeating on every loadConfig call.
+const _warnedOnce = new Set<string>();
+
+/** Clear the dedup warning set. Intended for tests only. */
+export function clearWarningsSeen(): void {
+	_warnedOnce.clear();
+}
+
 /** Override project root for all config resolution (used by --project global flag). */
 export function setProjectRootOverride(path: string): void {
 	_projectRootOverride = path;
@@ -698,9 +706,24 @@ function validateConfig(config: OverstoryConfig): void {
 		}
 	}
 
-	// models: validate each value — accepts aliases and provider-prefixed refs
+	if (config.runtime?.capabilities) {
+		for (const [cap, runtimeName] of Object.entries(config.runtime.capabilities)) {
+			if (runtimeName !== undefined && (typeof runtimeName !== "string" || runtimeName === "")) {
+				throw new ValidationError(`runtime.capabilities.${cap} must be a non-empty string`, {
+					field: `runtime.capabilities.${cap}`,
+					value: runtimeName,
+				});
+			}
+		}
+	}
+
+	// models: validate each value.
+	// - Standard runtimes: aliases (sonnet/opus/haiku) or provider-prefixed refs.
+	// - Codex runtime: also allow bare model refs (e.g. gpt-5.3-codex).
 	const validAliases = ["sonnet", "opus", "haiku"];
 	const toolHeavyRoles = ["builder", "scout"];
+	const defaultRuntime = config.runtime?.default ?? "claude";
+	const allowBareModelRefs = defaultRuntime === "codex";
 	for (const [role, model] of Object.entries(config.models)) {
 		if (model === undefined) continue;
 		if (model.includes("/")) {
@@ -716,13 +739,25 @@ function validateConfig(config: OverstoryConfig): void {
 				);
 			}
 			if (toolHeavyRoles.includes(role)) {
-				process.stderr.write(
-					`[overstory] WARNING: models.${role} uses non-Anthropic model '${model}'. Tool-use compatibility cannot be verified at config time.\n`,
-				);
+				const warnKey = `non-anthropic:${role}:${model}`;
+				if (!_warnedOnce.has(warnKey)) {
+					_warnedOnce.add(warnKey);
+					process.stderr.write(
+						`[overstory] WARNING: models.${role} uses non-Anthropic model '${model}'. Tool-use compatibility cannot be verified at config time.\n`,
+					);
+				}
 			}
 		} else {
-			// Must be a valid alias
+			// Must be a valid alias unless codex runtime is active.
 			if (!validAliases.includes(model)) {
+				if (allowBareModelRefs) {
+					if (toolHeavyRoles.includes(role)) {
+						process.stderr.write(
+							`[overstory] WARNING: models.${role} uses non-Anthropic model '${model}'. Tool-use compatibility cannot be verified at config time.\n`,
+						);
+					}
+					continue;
+				}
 				throw new ValidationError(
 					`models.${role} must be a valid alias (${validAliases.join(", ")}) or a provider-prefixed ref (e.g., openrouter/openai/gpt-4)`,
 					{

package/src/index.ts

@@ -49,7 +49,7 @@ import { ConfigError, OverstoryError, WorktreeError } from "./errors.ts";
 import { jsonError } from "./json.ts";
 import { brand, chalk, muted, setQuiet } from "./logging/color.ts";
 
-export const VERSION = "0.8.2";
+export const VERSION = "0.8.4";
 
 const rawArgs = process.argv.slice(2);
 
@@ -271,7 +271,7 @@ program
 		"Agent type: builder | scout | reviewer | lead | merger",
 		"builder",
 	)
-	.option("--name <name>", "Unique agent name")
+	.option("--name <name>", "Unique agent name (auto-generated if omitted)")
 	.option("--spec <path>", "Path to task spec file")
 	.option("--files <list>", "Exclusive file scope (comma-separated)")
 	.option("--parent <agent>", "Parent agent for hierarchy tracking")

package/src/merge/resolver.test.ts

@@ -290,6 +290,105 @@ describe("createMergeResolver", () => {
 		});
 	});
 
+	describe("Dirty working tree pre-check", () => {
+		test("throws MergeError when unstaged changes exist on tracked files", async () => {
+			const repoDir = await createTempGitRepo();
+			try {
+				const defaultBranch = await getDefaultBranch(repoDir);
+				// Create a tracked file and then leave it modified (unstaged)
+				await commitFile(repoDir, "src/main.ts", "original content\n");
+				await runGitInDir(repoDir, ["checkout", "-b", "feature-branch"]);
+				await commitFile(repoDir, "src/feature.ts", "feature content\n");
+				await runGitInDir(repoDir, ["checkout", defaultBranch]);
+				// Modify a tracked file without staging
+				await Bun.write(`${repoDir}/src/main.ts`, "modified content\n");
+
+				const entry = makeTestEntry({
+					branchName: "feature-branch",
+					filesModified: ["src/feature.ts"],
+				});
+
+				const resolver = createMergeResolver({
+					aiResolveEnabled: false,
+					reimagineEnabled: false,
+				});
+
+				await expect(resolver.resolve(entry, defaultBranch, repoDir)).rejects.toThrow(MergeError);
+			} finally {
+				await cleanupTempDir(repoDir);
+			}
+		});
+
+		test("throws MergeError with message listing dirty files", async () => {
+			const repoDir = await createTempGitRepo();
+			try {
+				const defaultBranch = await getDefaultBranch(repoDir);
+				await commitFile(repoDir, "src/main.ts", "original content\n");
+				await runGitInDir(repoDir, ["checkout", "-b", "feature-branch"]);
+				await commitFile(repoDir, "src/feature.ts", "feature content\n");
+				await runGitInDir(repoDir, ["checkout", defaultBranch]);
+				await Bun.write(`${repoDir}/src/main.ts`, "modified content\n");
+
+				const entry = makeTestEntry({ branchName: "feature-branch" });
+				const resolver = createMergeResolver({ aiResolveEnabled: false, reimagineEnabled: false });
+
+				try {
+					await resolver.resolve(entry, defaultBranch, repoDir);
+					expect(true).toBe(false); // should not reach
+				} catch (err: unknown) {
+					expect(err).toBeInstanceOf(MergeError);
+					const mergeErr = err as MergeError;
+					expect(mergeErr.message).toContain("src/main.ts");
+					expect(mergeErr.message).toContain("Commit or stash");
+				}
+			} finally {
+				await cleanupTempDir(repoDir);
+			}
+		});
+
+		test("throws MergeError when staged but uncommitted changes exist", async () => {
+			const repoDir = await createTempGitRepo();
+			try {
+				const defaultBranch = await getDefaultBranch(repoDir);
+				await commitFile(repoDir, "src/main.ts", "original content\n");
+				await runGitInDir(repoDir, ["checkout", "-b", "feature-branch"]);
+				await commitFile(repoDir, "src/feature.ts", "feature content\n");
+				await runGitInDir(repoDir, ["checkout", defaultBranch]);
+				// Modify and stage (but don't commit)
+				await Bun.write(`${repoDir}/src/main.ts`, "staged but not committed\n");
+				await runGitInDir(repoDir, ["add", "src/main.ts"]);
+
+				const entry = makeTestEntry({ branchName: "feature-branch" });
+				const resolver = createMergeResolver({ aiResolveEnabled: false, reimagineEnabled: false });
+
+				await expect(resolver.resolve(entry, defaultBranch, repoDir)).rejects.toThrow(MergeError);
+			} finally {
+				await cleanupTempDir(repoDir);
+			}
+		});
+
+		test("clean working tree proceeds normally to Tier 1", async () => {
+			const repoDir = await createTempGitRepo();
+			try {
+				const defaultBranch = await getDefaultBranch(repoDir);
+				await setupCleanMerge(repoDir, defaultBranch);
+
+				const entry = makeTestEntry({
+					branchName: "feature-branch",
+					filesModified: ["src/feature-file.ts"],
+				});
+
+				const resolver = createMergeResolver({ aiResolveEnabled: false, reimagineEnabled: false });
+				const result = await resolver.resolve(entry, defaultBranch, repoDir);
+
+				expect(result.success).toBe(true);
+				expect(result.tier).toBe("clean-merge");
+			} finally {
+				await cleanupTempDir(repoDir);
+			}
+		});
+	});
+
 	describe("Tier 1 fail -> Tier 2: Auto-resolve", () => {
 		test("auto-resolves conflicts keeping incoming changes with correct content", async () => {
 			const repoDir = await createTempGitRepo();

package/src/merge/resolver.ts

@@ -50,6 +50,26 @@ async function runGit(
 	return { stdout, stderr, exitCode };
 }
 
+/**
+ * Get the list of tracked files with uncommitted changes (unstaged or staged).
+ * Returns deduplicated list of file paths. An empty list means the working tree is clean.
+ */
+async function checkDirtyWorkingTree(repoRoot: string): Promise<string[]> {
+	const { stdout: unstaged } = await runGit(repoRoot, ["diff", "--name-only"]);
+	const { stdout: staged } = await runGit(repoRoot, ["diff", "--name-only", "--cached"]);
+	const files = [
+		...unstaged
+			.trim()
+			.split("\n")
+			.filter((l) => l.length > 0),
+		...staged
+			.trim()
+			.split("\n")
+			.filter((l) => l.length > 0),
+	];
+	return [...new Set(files)];
+}
+
 /**
  * Get the list of conflicted files from `git diff --name-only --diff-filter=U`.
  */
@@ -593,6 +613,17 @@ export function createMergeResolver(options: {
 				}
 			}
 
+			// Pre-check: abort early if working tree has uncommitted changes.
+			// When dirty tracked files exist, git merge refuses to start (exit 1, no conflict markers),
+			// causing all tiers to cascade with empty conflict lists and a misleading final error.
+			const dirtyFiles = await checkDirtyWorkingTree(repoRoot);
+			if (dirtyFiles.length > 0) {
+				throw new MergeError(
+					`Working tree has uncommitted changes to tracked files: ${dirtyFiles.join(", ")}. Commit or stash changes before running ov merge.`,
+					{ branchName: entry.branchName },
+				);
+			}
+
 			let lastTier: ResolutionTier = "clean-merge";
 			let conflictFiles: string[] = [];
 

package/src/metrics/transcript.test.ts

@@ -6,7 +6,7 @@
  *
  * Coverage:
  *   - parseTranscriptUsage (transcript.ts)
- *   - estimateCost re-export (transcript.ts -> pricing.ts)
+ *   - estimateCost (pricing.ts, imported directly)
  *   - getPricingForModel (pricing.ts)
  */
 
@@ -15,8 +15,8 @@ import { mkdtemp } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { cleanupTempDir } from "../test-helpers.ts";
-import { getPricingForModel, estimateCost as pricingEstimateCost } from "./pricing.ts";
-import { estimateCost, parseTranscriptUsage } from "./transcript.ts";
+import { estimateCost, getPricingForModel } from "./pricing.ts";
+import { parseTranscriptUsage } from "./transcript.ts";
 
 let tempDir: string;
 
@@ -479,17 +479,5 @@ describe("getPricingForModel", () => {
 	});
 });
 
-// === re-export parity ===
-
-describe("estimateCost re-export parity", () => {
-	test("transcript.estimateCost and pricing.estimateCost produce same result", () => {
-		const usage = {
-			inputTokens: 1_000_000,
-			outputTokens: 1_000_000,
-			cacheReadTokens: 1_000_000,
-			cacheCreationTokens: 1_000_000,
-			modelUsed: "claude-opus-4-6",
-		};
-		expect(estimateCost(usage)).toBe(pricingEstimateCost(usage));
-	});
-});
+// estimateCost re-export removed from transcript.ts (overstory-aa00).
+// estimateCost is now imported directly from pricing.ts everywhere.

package/src/metrics/transcript.ts

@@ -27,8 +27,6 @@ import type { TokenUsage } from "./pricing.ts";
 
 export type TranscriptUsage = TokenUsage;
 
-export { estimateCost } from "./pricing.ts";
-
 /**
  * Narrow an unknown value to determine if it looks like a transcript assistant entry.
  * Returns the usage fields if valid, or null otherwise.

package/src/runtimes/claude.ts

@@ -5,7 +5,8 @@
 import { mkdir } from "node:fs/promises";
 import { join } from "node:path";
 import { deployHooks } from "../agents/hooks-deployer.ts";
-import { estimateCost, parseTranscriptUsage } from "../metrics/transcript.ts";
+import { estimateCost } from "../metrics/pricing.ts";
+import { parseTranscriptUsage } from "../metrics/transcript.ts";
 import type { ResolvedModel } from "../types.ts";
 import type {
 	AgentRuntime,
@@ -219,6 +220,22 @@ export class ClaudeRuntime implements AgentRuntime {
 	buildEnv(model: ResolvedModel): Record<string, string> {
 		return model.env ?? {};
 	}
+
+	/**
+	 * Return the Claude Code transcript directory for a given project root.
+	 *
+	 * Claude Code stores session transcripts at ~/.claude/projects/<projectKey>/
+	 * where <projectKey> is the project root path with "/" replaced by "-".
+	 *
+	 * @param projectRoot - Absolute path to the project root
+	 * @returns Absolute path to the transcript directory, or null if HOME is unavailable
+	 */
+	getTranscriptDir(projectRoot: string): string | null {
+		const home = process.env.HOME ?? "";
+		if (home.length === 0) return null;
+		const projectKey = projectRoot.replace(/\//g, "-");
+		return join(home, ".claude", "projects", projectKey);
+	}
 }
 
 /** Singleton instance for use in callers that do not need DI. */

package/src/runtimes/codex.test.ts

@@ -20,7 +20,7 @@ describe("CodexRuntime", () => {
 	});
 
 	describe("buildSpawnCommand", () => {
-		test("basic command uses codex exec with --full-auto and --json", () => {
+		test("basic command uses interactive codex with --full-auto", () => {
 			const opts: SpawnOpts = {
 				model: "gpt-5-codex",
 				permissionMode: "bypass",
@@ -28,11 +28,25 @@ describe("CodexRuntime", () => {
 				env: {},
 			};
 			const cmd = runtime.buildSpawnCommand(opts);
-			expect(cmd).toContain("codex exec --full-auto --json");
+			expect(cmd).toContain("codex --full-auto");
 			expect(cmd).toContain("--model gpt-5-codex");
 			expect(cmd).toContain("Read AGENTS.md");
 		});
 
+		test("manifest aliases omit --model so codex uses default configured model", () => {
+			for (const alias of ["sonnet", "opus", "haiku"]) {
+				const opts: SpawnOpts = {
+					model: alias,
+					permissionMode: "bypass",
+					cwd: "/tmp/worktree",
+					env: {},
+				};
+				const cmd = runtime.buildSpawnCommand(opts);
+				expect(cmd).toContain("codex --full-auto");
+				expect(cmd).not.toContain(" --model ");
+			}
+		});
+
 		test("permissionMode is NOT included in command (Codex uses OS sandbox)", () => {
 			const opts: SpawnOpts = {
 				model: "gpt-5-codex",
@@ -146,7 +160,7 @@ describe("CodexRuntime", () => {
 			};
 			const cmd = runtime.buildSpawnCommand(opts);
 			expect(cmd).toBe(
-				"codex exec --full-auto --json --model gpt-5-codex 'Read AGENTS.md for your task assignment and begin immediately.'",
+				"codex --full-auto --model gpt-5-codex 'Read AGENTS.md for your task assignment and begin immediately.'",
 			);
 		});
 
@@ -254,7 +268,7 @@ describe("CodexRuntime", () => {
 	});
 
 	describe("detectReady", () => {
-		test("returns ready for empty pane (headless — always ready)", () => {
+		test("returns ready for empty pane", () => {
 			const state = runtime.detectReady("");
 			expect(state).toEqual({ phase: "ready" });
 		});
@@ -279,7 +293,7 @@ describe("CodexRuntime", () => {
 	});
 
 	describe("requiresBeaconVerification", () => {
-		test("returns false (headless — no beacon needed)", () => {
+		test("returns false (no beacon verification needed)", () => {
 			expect(runtime.requiresBeaconVerification()).toBe(false);
 		});
 	});
@@ -664,7 +678,7 @@ describe("CodexRuntime integration: spawn command structure", () => {
 			env: { OVERSTORY_AGENT_NAME: "builder-1" },
 		});
 		expect(cmd).toBe(
-			"codex exec --full-auto --json --model gpt-5-codex 'Read AGENTS.md for your task assignment and begin immediately.'",
+			"codex --full-auto --model gpt-5-codex 'Read AGENTS.md for your task assignment and begin immediately.'",
 		);
 	});
 
@@ -677,7 +691,7 @@ describe("CodexRuntime integration: spawn command structure", () => {
 			appendSystemPrompt: baseDefinition,
 			env: { OVERSTORY_AGENT_NAME: "coordinator" },
 		});
-		expect(cmd).toContain("codex exec --full-auto --json --model gpt-5-codex");
+		expect(cmd).toContain("codex --full-auto --model gpt-5-codex");
 		expect(cmd).toContain("# Coordinator");
 		expect(cmd).toContain("You are the coordinator agent.");
 		expect(cmd).toContain("Read AGENTS.md");
@@ -691,7 +705,7 @@ describe("CodexRuntime integration: spawn command structure", () => {
 			appendSystemPromptFile: "/project/.overstory/agent-defs/coordinator.md",
 			env: { OVERSTORY_AGENT_NAME: "coordinator" },
 		});
-		expect(cmd).toContain("codex exec --full-auto --json --model gpt-5-codex");
+		expect(cmd).toContain("codex --full-auto --model gpt-5-codex");
 		expect(cmd).toContain("$(cat '/project/.overstory/agent-defs/coordinator.md')");
 		expect(cmd).toContain("Read AGENTS.md");
 	});