@os-eco/overstory-cli 0.8.5 → 0.8.6

package/src/commands/spec.ts

@@ -11,11 +11,13 @@
 import { mkdir } from "node:fs/promises";
 import { join } from "node:path";
 import { ValidationError } from "../errors.ts";
+import { jsonOutput } from "../json.ts";
 import { printSuccess } from "../logging/color.ts";
 
 export interface SpecWriteOptions {
 	body?: string;
 	agent?: string;
+	json?: boolean;
 }
 
 /**
@@ -94,6 +96,10 @@ export async function specWriteCommand(taskId: string, opts: SpecWriteOptions):
 	const { resolveProjectRoot } = await import("../config.ts");
 	const projectRoot = await resolveProjectRoot(process.cwd());
 
-	await writeSpec(projectRoot, taskId, body, opts.agent);
-	printSuccess("Spec written", taskId);
+	const specPath = await writeSpec(projectRoot, taskId, body, opts.agent);
+	if (opts.json) {
+		jsonOutput("spec-write", { taskId, path: specPath });
+	} else {
+		printSuccess("Spec written", taskId);
+	}
 }

package/src/commands/stop.test.ts

@@ -20,6 +20,26 @@ import { cleanupTempDir, createTempGitRepo } from "../test-helpers.ts";
 import type { AgentSession } from "../types.ts";
 import { type StopDeps, stopCommand } from "./stop.ts";
 
+// --- Fake Git (for branch deletion) ---
+
+interface GitCallTracker {
+	deleteBranch: Array<{ repoRoot: string; branch: string }>;
+}
+
+function makeFakeGit(shouldSucceed = true): {
+	git: NonNullable<StopDeps["_git"]>;
+	calls: GitCallTracker;
+} {
+	const calls: GitCallTracker = { deleteBranch: [] };
+	const git: NonNullable<StopDeps["_git"]> = {
+		deleteBranch: async (repoRoot: string, branch: string): Promise<boolean> => {
+			calls.deleteBranch.push({ repoRoot, branch });
+			return shouldSucceed;
+		},
+	};
+	return { git, calls };
+}
+
 // --- Fake Process (for headless agents) ---
 
 /** Track calls to fake process for assertions. */
@@ -224,18 +244,26 @@ async function captureStderr(fn: () => Promise<void>): Promise<{ stderr: string;
 	return { stderr: stderrChunks.join(""), stdout: stdoutChunks.join("") };
 }
 
-/** Build default deps with fake tmux and worktree. */
+/** Build default deps with fake tmux, worktree, and git. */
 function makeDeps(
 	sessionAliveMap: Record<string, boolean> = {},
 	worktreeConfig?: { shouldFail?: boolean },
+	gitConfig?: { shouldSucceed?: boolean },
 ): {
 	deps: StopDeps;
 	tmuxCalls: TmuxCallTracker;
 	worktreeCalls: WorktreeCallTracker;
+	gitCalls: GitCallTracker;
 } {
 	const { tmux, calls: tmuxCalls } = makeFakeTmux(sessionAliveMap);
 	const { worktree, calls: worktreeCalls } = makeFakeWorktree(worktreeConfig?.shouldFail);
-	return { deps: { _tmux: tmux, _worktree: worktree }, tmuxCalls, worktreeCalls };
+	const { git, calls: gitCalls } = makeFakeGit(gitConfig?.shouldSucceed ?? true);
+	return {
+		deps: { _tmux: tmux, _worktree: worktree, _git: git },
+		tmuxCalls,
+		worktreeCalls,
+		gitCalls,
+	};
 }
 
 // --- Tests ---
@@ -251,13 +279,14 @@ describe("stopCommand validation", () => {
 		await expect(stopCommand("nonexistent-agent", {}, deps)).rejects.toThrow(AgentError);
 	});
 
-	test("throws AgentError when agent is already completed", async () => {
+	test("throws AgentError when agent is already completed (without --clean-worktree)", async () => {
 		const session = makeAgentSession({ state: "completed" });
 		saveSessionsToDb([session]);
 
 		const { deps } = makeDeps();
 		await expect(stopCommand("my-builder", {}, deps)).rejects.toThrow(AgentError);
 		await expect(stopCommand("my-builder", {}, deps)).rejects.toThrow(/already completed/);
+		await expect(stopCommand("my-builder", {}, deps)).rejects.toThrow(/--clean-worktree/);
 	});
 
 	test("succeeds when agent is zombie (cleanup, no error)", async () => {
@@ -318,6 +347,65 @@ describe("stopCommand zombie cleanup", () => {
 	});
 });
 
+describe("stopCommand completed agent cleanup", () => {
+	test("completed + --clean-worktree removes worktree and branch", async () => {
+		const session = makeAgentSession({ state: "completed" });
+		saveSessionsToDb([session]);
+
+		const { deps, tmuxCalls, worktreeCalls, gitCalls } = makeDeps();
+		const output = await captureStdout(() =>
+			stopCommand("my-builder", { cleanWorktree: true }, deps),
+		);
+
+		expect(output).toContain("Agent stopped");
+		expect(output).toContain("already completed");
+		expect(output).toContain(`Worktree removed`);
+		expect(output).toContain(`Branch deleted`);
+
+		// No kill operations
+		expect(tmuxCalls.isSessionAlive).toHaveLength(0);
+		expect(tmuxCalls.killSession).toHaveLength(0);
+
+		// Worktree removed
+		expect(worktreeCalls.remove).toHaveLength(1);
+
+		// Branch deleted
+		expect(gitCalls.deleteBranch).toHaveLength(1);
+		expect(gitCalls.deleteBranch[0]?.branch).toBe(session.branchName);
+	});
+
+	test("completed + --clean-worktree + --json includes wasCompleted: true", async () => {
+		const session = makeAgentSession({ state: "completed" });
+		saveSessionsToDb([session]);
+
+		const { deps } = makeDeps();
+		const output = await captureStdout(() =>
+			stopCommand("my-builder", { cleanWorktree: true, 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.wasCompleted).toBe(true);
+		expect(parsed.tmuxKilled).toBe(false);
+		expect(parsed.pidKilled).toBe(false);
+		expect(parsed.worktreeRemoved).toBe(true);
+		expect(parsed.branchDeleted).toBe(true);
+	});
+
+	test("branch deletion failure is non-fatal for completed agent", async () => {
+		const session = makeAgentSession({ state: "completed" });
+		saveSessionsToDb([session]);
+
+		const { deps } = makeDeps({}, {}, { shouldSucceed: false });
+		// Should not throw even if branch deletion fails
+		const output = await captureStdout(() =>
+			stopCommand("my-builder", { cleanWorktree: true }, deps),
+		);
+		expect(output).toContain("Agent stopped");
+	});
+});
+
 describe("stopCommand stop behavior", () => {
 	test("stops a working agent (kills tmux, marks completed)", async () => {
 		const session = makeAgentSession({ state: "working" });
@@ -435,7 +523,7 @@ describe("stopCommand --clean-worktree", () => {
 		expect(worktreeCalls.remove[0]?.path).toBe(session.worktreePath);
 	});
 
-	test("--clean-worktree with --force passes force flags to removeWorktree", async () => {
+	test("--clean-worktree with --force passes force to removeWorktree (forceBranch is always false)", async () => {
 		const session = makeAgentSession({ state: "working" });
 		saveSessionsToDb([session]);
 
@@ -446,7 +534,37 @@ describe("stopCommand --clean-worktree", () => {
 
 		expect(worktreeCalls.remove).toHaveLength(1);
 		expect(worktreeCalls.remove[0]?.options?.force).toBe(true);
-		expect(worktreeCalls.remove[0]?.options?.forceBranch).toBe(true);
+		// forceBranch is always false because branch deletion is handled separately via git branch -D
+		expect(worktreeCalls.remove[0]?.options?.forceBranch).toBe(false);
+	});
+
+	test("--clean-worktree also deletes the branch", async () => {
+		const session = makeAgentSession({ state: "working" });
+		saveSessionsToDb([session]);
+
+		const { deps, gitCalls } = makeDeps({ [session.tmuxSession]: true });
+		const output = await captureStdout(() =>
+			stopCommand("my-builder", { cleanWorktree: true }, deps),
+		);
+
+		expect(gitCalls.deleteBranch).toHaveLength(1);
+		expect(gitCalls.deleteBranch[0]?.branch).toBe(session.branchName);
+		expect(output).toContain("Branch deleted");
+	});
+
+	test("branch deletion failure is non-fatal (agent still stopped)", async () => {
+		const session = makeAgentSession({ state: "working" });
+		saveSessionsToDb([session]);
+
+		const { deps } = makeDeps({ [session.tmuxSession]: true }, {}, { shouldSucceed: false });
+		const output = await captureStdout(() =>
+			stopCommand("my-builder", { cleanWorktree: true }, deps),
+		);
+		expect(output).toContain("Agent stopped");
+		const { store } = openSessionStore(overstoryDir);
+		const updated = store.getByName("my-builder");
+		store.close();
+		expect(updated?.state).toBe("completed");
 	});
 
 	test("--clean-worktree failure is non-fatal (agent still stopped, warning on stdout)", async () => {
@@ -505,15 +623,18 @@ describe("stopCommand headless agents", () => {
 		tmuxCalls: TmuxCallTracker;
 		procCalls: ProcessCallTracker;
 		worktreeCalls: WorktreeCallTracker;
+		gitCalls: GitCallTracker;
 	} {
 		const { tmux, calls: tmuxCalls } = makeFakeTmux({});
 		const { proc, calls: procCalls } = makeFakeProcess(pidAliveMap);
 		const { worktree, calls: worktreeCalls } = makeFakeWorktree(worktreeConfig?.shouldFail);
+		const { git, calls: gitCalls } = makeFakeGit();
 		return {
-			deps: { _tmux: tmux, _worktree: worktree, _process: proc },
+			deps: { _tmux: tmux, _worktree: worktree, _process: proc, _git: git },
 			tmuxCalls,
 			procCalls,
 			worktreeCalls,
+			gitCalls,
 		};
 	}
 

package/src/commands/stop.ts

@@ -6,7 +6,10 @@
  * 2a. For TUI agents: killing its tmux session (if alive)
  * 2b. For headless agents (tmuxSession === ''): sending SIGTERM to the process tree
  * 3. Marking it as completed in the SessionStore
- * 4. Optionally removing its worktree (--clean-worktree)
+ * 4. Optionally removing its worktree and branch (--clean-worktree)
+ *
+ * Completed agents: ov stop <name> without --clean-worktree throws a helpful error.
+ * With --clean-worktree, completed agents skip the kill step and proceed to cleanup.
  */
 
 import { join } from "node:path";
@@ -41,6 +44,24 @@ export interface StopDeps {
 		isAlive: (pid: number) => boolean;
 		killTree: (pid: number) => Promise<void>;
 	};
+	_git?: {
+		deleteBranch: (repoRoot: string, branch: string) => Promise<boolean>;
+	};
+}
+
+/** Delete a git branch (best-effort, non-fatal). */
+async function deleteBranchBestEffort(repoRoot: string, branch: string): Promise<boolean> {
+	try {
+		const proc = Bun.spawn(["git", "branch", "-D", branch], {
+			cwd: repoRoot,
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		const exitCode = await proc.exited;
+		return exitCode === 0;
+	} catch {
+		return false;
+	}
 }
 
 /**
@@ -48,7 +69,7 @@ export interface StopDeps {
  *
  * @param agentName - Name of the agent to stop
  * @param opts - Command options
- * @param deps - Optional dependency injection for testing (tmux, worktree, process)
+ * @param deps - Optional dependency injection for testing (tmux, worktree, process, git)
  */
 export async function stopCommand(
 	agentName: string,
@@ -69,6 +90,7 @@ export async function stopCommand(
 	const tmux = deps._tmux ?? { isSessionAlive, killSession };
 	const worktree = deps._worktree ?? { remove: removeWorktree };
 	const proc = deps._process ?? { isAlive: isProcessAlive, killTree: killProcessTree };
+	const git = deps._git ?? { deleteBranch: deleteBranchBestEffort };
 
 	const cwd = process.cwd();
 	const config = await loadConfig(cwd);
@@ -82,49 +104,69 @@ export async function stopCommand(
 			throw new AgentError(`Agent "${agentName}" not found`, { agentName });
 		}
 
-		if (session.state === "completed") {
-			throw new AgentError(`Agent "${agentName}" is already completed`, { agentName });
+		const isAlreadyCompleted = session.state === "completed";
+
+		// Completed agents without --clean-worktree: throw with helpful message
+		if (isAlreadyCompleted && !cleanWorktree) {
+			throw new AgentError(
+				`Agent "${agentName}" is already completed. Use --clean-worktree to remove its worktree.`,
+				{ agentName },
+			);
 		}
 
 		const isZombie = session.state === "zombie";
-
 		const isHeadless = session.tmuxSession === "" && session.pid !== null;
 
 		let tmuxKilled = false;
 		let pidKilled = false;
 
-		if (isHeadless && session.pid !== null) {
-			// Headless agent: kill via process tree instead of tmux
-			const alive = proc.isAlive(session.pid);
-			if (alive) {
-				await proc.killTree(session.pid);
-				pidKilled = true;
-			}
-		} else {
-			// TUI agent: kill via tmux session
-			const alive = await tmux.isSessionAlive(session.tmuxSession);
-			if (alive) {
-				await tmux.killSession(session.tmuxSession);
-				tmuxKilled = true;
+		// Skip kill operations for already-completed agents (process/tmux already gone)
+		if (!isAlreadyCompleted) {
+			if (isHeadless && session.pid !== null) {
+				// Headless agent: kill via process tree instead of tmux
+				const alive = proc.isAlive(session.pid);
+				if (alive) {
+					await proc.killTree(session.pid);
+					pidKilled = true;
+				}
+			} else {
+				// TUI agent: kill via tmux session
+				const alive = await tmux.isSessionAlive(session.tmuxSession);
+				if (alive) {
+					await tmux.killSession(session.tmuxSession);
+					tmuxKilled = true;
+				}
 			}
-		}
 
-		// Mark session as completed
-		store.updateState(agentName, "completed");
-		store.updateLastActivity(agentName);
+			// Mark session as completed
+			store.updateState(agentName, "completed");
+			store.updateLastActivity(agentName);
+		}
 
-		// Optionally remove worktree (best-effort, non-fatal)
+		// Optionally remove worktree and branch (best-effort, non-fatal)
 		let worktreeRemoved = false;
-		if (cleanWorktree && session.worktreePath) {
-			try {
-				await worktree.remove(projectRoot, session.worktreePath, {
-					force,
-					forceBranch: force,
-				});
-				worktreeRemoved = true;
-			} catch (err) {
-				const msg = err instanceof Error ? err.message : String(err);
-				if (!json) printWarning("Failed to remove worktree", msg);
+		let branchDeleted = false;
+		if (cleanWorktree) {
+			if (session.worktreePath) {
+				try {
+					await worktree.remove(projectRoot, session.worktreePath, {
+						force,
+						forceBranch: false,
+					});
+					worktreeRemoved = true;
+				} catch (err) {
+					const msg = err instanceof Error ? err.message : String(err);
+					if (!json) printWarning("Failed to remove worktree", msg);
+				}
+			}
+
+			// Delete the branch after removing the worktree (best-effort, non-fatal)
+			if (session.branchName) {
+				try {
+					branchDeleted = await git.deleteBranch(projectRoot, session.branchName);
+				} catch {
+					branchDeleted = false;
+				}
 			}
 		}
 
@@ -137,30 +179,40 @@ export async function stopCommand(
 				tmuxKilled,
 				pidKilled,
 				worktreeRemoved,
+				branchDeleted,
 				force,
 				wasZombie: isZombie,
+				wasCompleted: isAlreadyCompleted,
 			});
 		} else {
 			printSuccess("Agent stopped", agentName);
-			if (isHeadless) {
-				if (pidKilled) {
-					process.stdout.write(`  Process tree killed: PID ${session.pid}\n`);
-				} else {
-					process.stdout.write(`  Process was already dead (PID ${session.pid})\n`);
-				}
-			} else {
-				if (tmuxKilled) {
-					process.stdout.write(`  Tmux session killed: ${session.tmuxSession}\n`);
+			if (!isAlreadyCompleted) {
+				if (isHeadless) {
+					if (pidKilled) {
+						process.stdout.write(`  Process tree killed: PID ${session.pid}\n`);
+					} else {
+						process.stdout.write(`  Process was already dead (PID ${session.pid})\n`);
+					}
 				} else {
-					process.stdout.write(`  Tmux session was already dead\n`);
+					if (tmuxKilled) {
+						process.stdout.write(`  Tmux session killed: ${session.tmuxSession}\n`);
+					} else {
+						process.stdout.write(`  Tmux session was already dead\n`);
+					}
 				}
 			}
 			if (isZombie) {
 				process.stdout.write(`  Zombie agent cleaned up (state → completed)\n`);
 			}
+			if (isAlreadyCompleted) {
+				process.stdout.write(`  Agent was already completed (skipped kill)\n`);
+			}
 			if (cleanWorktree && worktreeRemoved) {
 				process.stdout.write(`  Worktree removed: ${session.worktreePath}\n`);
 			}
+			if (cleanWorktree && branchDeleted) {
+				process.stdout.write(`  Branch deleted: ${session.branchName}\n`);
+			}
 		}
 	} finally {
 		store.close();

package/src/commands/watch.ts

@@ -10,6 +10,7 @@ import { join } from "node:path";
 import { Command } from "commander";
 import { loadConfig } from "../config.ts";
 import { OverstoryError } from "../errors.ts";
+import { jsonOutput } from "../json.ts";
 import { printError, printHint, printSuccess } from "../logging/color.ts";
 import type { HealthCheck } from "../types.ts";
 import { startDaemon } from "../watchdog/daemon.ts";
@@ -115,7 +116,11 @@ async function resolveOverstoryBin(): Promise<string> {
 /**
  * Core implementation for the watch command.
  */
-async function runWatch(opts: { interval?: string; background?: boolean }): Promise<void> {
+async function runWatch(opts: {
+	interval?: string;
+	background?: boolean;
+	json?: boolean;
+}): Promise<void> {
 	const cwd = process.cwd();
 	const config = await loadConfig(cwd);
 
@@ -127,13 +132,19 @@ async function runWatch(opts: { interval?: string; background?: boolean }): Prom
 	const zombieThresholdMs = config.watchdog.zombieThresholdMs;
 	const pidFilePath = join(config.project.root, ".overstory", "watchdog.pid");
 
+	const useJson = opts.json ?? false;
+
 	if (opts.background) {
 		// Check if a watchdog is already running
 		const existingPid = await readPidFile(pidFilePath);
 		if (existingPid !== null && isProcessRunning(existingPid)) {
-			printError(
-				`Watchdog already running (PID: ${existingPid}). Kill it first or remove ${pidFilePath}`,
-			);
+			if (useJson) {
+				jsonOutput("watch", { running: true, pid: existingPid, error: "Watchdog already running" });
+			} else {
+				printError(
+					`Watchdog already running (PID: ${existingPid}). Kill it first or remove ${pidFilePath}`,
+				);
+			}
 			process.exitCode = 1;
 			return;
 		}
@@ -168,14 +179,22 @@ async function runWatch(opts: { interval?: string; background?: boolean }): Prom
 		// Write PID file for later cleanup
 		await writePidFile(pidFilePath, childPid);
 
-		printSuccess("Watchdog started in background", `PID: ${childPid}, interval: ${intervalMs}ms`);
-		printHint(`PID file: ${pidFilePath}`);
+		if (useJson) {
+			jsonOutput("watch", { pid: childPid, intervalMs, pidFile: pidFilePath });
+		} else {
+			printSuccess("Watchdog started in background", `PID: ${childPid}, interval: ${intervalMs}ms`);
+			printHint(`PID file: ${pidFilePath}`);
+		}
 		return;
 	}
 
 	// Foreground mode: show real-time health checks
-	printSuccess("Watchdog running", `interval: ${intervalMs}ms`);
-	printHint("Press Ctrl+C to stop.");
+	if (useJson) {
+		jsonOutput("watch", { pid: process.pid, intervalMs, mode: "foreground" });
+	} else {
+		printSuccess("Watchdog running", `interval: ${intervalMs}ms`);
+		printHint("Press Ctrl+C to stop.");
+	}
 
 	// Write PID file so `--background` check and external tools can find us
 	await writePidFile(pidFilePath, process.pid);
@@ -212,7 +231,8 @@ export function createWatchCommand(): Command {
 		.description("Start Tier 0 mechanical watchdog daemon")
 		.option("--interval <ms>", "Health check interval in milliseconds")
 		.option("--background", "Daemonize (run in background)")
-		.action(async (opts: { interval?: string; background?: boolean }) => {
+		.option("--json", "Output as JSON")
+		.action(async (opts: { interval?: string; background?: boolean; json?: boolean }) => {
 			await runWatch(opts);
 		});
 }

package/src/config.test.ts

@@ -1088,6 +1088,71 @@ describe("projectRootOverride", () => {
 	});
 });
 
+describe("coordinator.exitTriggers", () => {
+	let tempDir: string;
+
+	beforeEach(async () => {
+		tempDir = await mkdtemp(join(tmpdir(), "overstory-test-"));
+		const { mkdir } = await import("node:fs/promises");
+		await mkdir(join(tempDir, ".overstory"), { recursive: true });
+	});
+
+	afterEach(async () => {
+		await cleanupTempDir(tempDir);
+	});
+
+	async function writeConfig(yaml: string): Promise<void> {
+		await Bun.write(join(tempDir, ".overstory", "config.yaml"), yaml);
+	}
+
+	test("defaults all exitTriggers to false", async () => {
+		const config = await loadConfig(tempDir);
+		expect(config.coordinator?.exitTriggers.allAgentsDone).toBe(false);
+		expect(config.coordinator?.exitTriggers.taskTrackerEmpty).toBe(false);
+		expect(config.coordinator?.exitTriggers.onShutdownSignal).toBe(false);
+	});
+
+	test("parses coordinator.exitTriggers from config.yaml", async () => {
+		await writeConfig(`
+coordinator:
+  exitTriggers:
+    allAgentsDone: true
+    taskTrackerEmpty: true
+    onShutdownSignal: false
+`);
+		const config = await loadConfig(tempDir);
+		expect(config.coordinator?.exitTriggers.allAgentsDone).toBe(true);
+		expect(config.coordinator?.exitTriggers.taskTrackerEmpty).toBe(true);
+		expect(config.coordinator?.exitTriggers.onShutdownSignal).toBe(false);
+	});
+
+	test("partial exitTriggers override keeps unset values at default (false)", async () => {
+		await writeConfig(`
+coordinator:
+  exitTriggers:
+    onShutdownSignal: true
+`);
+		const config = await loadConfig(tempDir);
+		expect(config.coordinator?.exitTriggers.allAgentsDone).toBe(false);
+		expect(config.coordinator?.exitTriggers.taskTrackerEmpty).toBe(false);
+		expect(config.coordinator?.exitTriggers.onShutdownSignal).toBe(true);
+	});
+
+	test("config.local.yaml can override exitTriggers", async () => {
+		await writeConfig(`
+coordinator:
+  exitTriggers:
+    allAgentsDone: false
+`);
+		await Bun.write(
+			join(tempDir, ".overstory", "config.local.yaml"),
+			`coordinator:\n  exitTriggers:\n    allAgentsDone: true\n`,
+		);
+		const config = await loadConfig(tempDir);
+		expect(config.coordinator?.exitTriggers.allAgentsDone).toBe(true);
+	});
+});
+
 describe("DEFAULT_CONFIG", () => {
 	test("has all required top-level keys", () => {
 		expect(DEFAULT_CONFIG.project).toBeDefined();
@@ -1126,6 +1191,13 @@ describe("DEFAULT_CONFIG", () => {
 		expect(DEFAULT_CONFIG.project.qualityGates?.[2]?.command).toBe("bun run typecheck");
 	});
 
+	test("has coordinator with exitTriggers defaulting to false", () => {
+		expect(DEFAULT_CONFIG.coordinator).toBeDefined();
+		expect(DEFAULT_CONFIG.coordinator?.exitTriggers.allAgentsDone).toBe(false);
+		expect(DEFAULT_CONFIG.coordinator?.exitTriggers.taskTrackerEmpty).toBe(false);
+		expect(DEFAULT_CONFIG.coordinator?.exitTriggers.onShutdownSignal).toBe(false);
+	});
+
 	test("DEFAULT_QUALITY_GATES matches the project default gates", () => {
 		expect(DEFAULT_QUALITY_GATES).toHaveLength(3);
 		expect(DEFAULT_QUALITY_GATES[0]?.name).toBe("Tests");

package/src/config.ts

@@ -1,6 +1,11 @@
 import { dirname, join, resolve } from "node:path";
 import { ConfigError, ValidationError } from "./errors.ts";
-import type { OverstoryConfig, QualityGate, TaskTrackerBackend } from "./types.ts";
+import type {
+	CoordinatorExitTriggers,
+	OverstoryConfig,
+	QualityGate,
+	TaskTrackerBackend,
+} from "./types.ts";
 
 // Module-level project root override (set by --project global flag)
 let _projectRootOverride: string | undefined;
@@ -83,6 +88,13 @@ export const DEFAULT_CONFIG: OverstoryConfig = {
 		zombieThresholdMs: 600_000, // 10 minutes
 		nudgeIntervalMs: 60_000, // 1 minute between progressive nudge stages
 	},
+	coordinator: {
+		exitTriggers: {
+			allAgentsDone: false,
+			taskTrackerEmpty: false,
+			onShutdownSignal: false,
+		} as CoordinatorExitTriggers,
+	},
 	models: {},
 	logging: {
 		verbose: false,
@@ -663,6 +675,19 @@ function validateConfig(config: OverstoryConfig): void {
 		}
 	}
 
+	// coordinator.exitTriggers: validate all three flags are booleans if present
+	if (config.coordinator?.exitTriggers !== undefined) {
+		const et = config.coordinator.exitTriggers;
+		for (const key of ["allAgentsDone", "taskTrackerEmpty", "onShutdownSignal"] as const) {
+			if (typeof et[key] !== "boolean") {
+				throw new ValidationError(`coordinator.exitTriggers.${key} must be a boolean`, {
+					field: `coordinator.exitTriggers.${key}`,
+					value: et[key],
+				});
+			}
+		}
+	}
+
 	// runtime.default must be a string if present
 	if (config.runtime !== undefined && typeof config.runtime.default !== "string") {
 		process.stderr.write(

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.5";
+export const VERSION = "0.8.6";
 
 const rawArgs = process.argv.slice(2);
 
@@ -145,6 +145,7 @@ program
 	.name("ov")
 	.description("Multi-agent orchestration for Claude Code")
 	.version(VERSION, "-v, --version", "Print version")
+	.enablePositionalOptions()
 	.option("-q, --quiet", "Suppress non-error output")
 	.option("--json", "JSON output")
 	.option("--verbose", "Verbose output")
@@ -298,6 +299,7 @@ specCmd
 	.argument("<task-id>", "Task ID for the spec file")
 	.option("--body <content>", "Spec content (or pipe via stdin)")
 	.option("--agent <name>", "Agent writing the spec (for attribution)")
+	.option("--json", "Output as JSON")
 	.action(async (taskId, opts) => {
 		await specWriteCommand(taskId, opts);
 	});
@@ -307,6 +309,7 @@ program
 	.description("Load context for orchestrator/agent")
 	.option("--agent <name>", "Prime for a specific agent")
 	.option("--compact", "Output reduced context (for PreCompact hook)")
+	.option("--json", "Output as JSON")
 	.action(async (opts) => {
 		await primeCommand(opts);
 	});