@os-eco/overstory-cli 0.9.4 → 0.10.3

package/src/commands/stop.ts

@@ -12,12 +12,16 @@
  * With --clean-worktree, completed agents skip the kill step and proceed to cleanup.
  */
 
+import { unlink } from "node:fs/promises";
 import { join } from "node:path";
 import { loadConfig } from "../config.ts";
 import { AgentError, ValidationError } from "../errors.ts";
 import { jsonOutput } from "../json.ts";
 import { printSuccess, printWarning } from "../logging/color.ts";
+import { createMailStore } from "../mail/store.ts";
 import { openSessionStore } from "../sessions/compat.ts";
+import type { MergeReadyPayload } from "../types.ts";
+import { readPidFile } from "../utils/pid.ts";
 import { removeWorktree } from "../worktree/manager.ts";
 import { isProcessAlive, isSessionAlive, killProcessTree, killSession } from "../worktree/tmux.ts";
 
@@ -49,6 +53,56 @@ export interface StopDeps {
 	};
 }
 
+/**
+ * Build the lead_completed nudge subject based on whether the lead actually sent
+ * merge_ready before exiting (overstory-41fe). The merge_ready close-gate
+ * (commit 3e21338) prevents leads from running `sd close` without it, but a
+ * lead can still exit (process termination, watchdog kill, manual `ov stop`)
+ * without ever having sent one. The coordinator's surfacing of this nudge
+ * needs to distinguish those two cases.
+ */
+function buildLeadCompletedSubject(agentName: string, mailDbPath: string): string {
+	let mergeReadyBranches: string[] = [];
+	let mergeReadyCount = 0;
+	try {
+		const store = createMailStore(mailDbPath);
+		try {
+			const messages = store.getAll({ from: agentName, type: "merge_ready" });
+			mergeReadyCount = messages.length;
+			for (const msg of messages) {
+				if (msg.payload === null) continue;
+				try {
+					const parsed = JSON.parse(msg.payload) as Partial<MergeReadyPayload>;
+					if (typeof parsed.branch === "string" && parsed.branch.length > 0) {
+						mergeReadyBranches.push(parsed.branch);
+					}
+				} catch {
+					// Skip messages with unparseable payloads
+				}
+			}
+		} finally {
+			store.close();
+		}
+	} catch {
+		// If the mail store can't be opened (corrupt db, permissions), fall back
+		// to the historical ambiguous phrasing rather than blocking the stop.
+		return `Lead ${agentName} completed — check mail for merge_ready/worker_done`;
+	}
+
+	if (mergeReadyCount === 0) {
+		return `Lead ${agentName} exited — no merge_ready sent, needs coordinator follow-up`;
+	}
+	// Dedupe in case a lead resent merge_ready for the same branch
+	mergeReadyBranches = Array.from(new Set(mergeReadyBranches));
+	if (mergeReadyBranches.length === 0) {
+		return `Lead ${agentName} sent ${mergeReadyCount} merge_ready (branch unknown)`;
+	}
+	if (mergeReadyBranches.length === 1) {
+		return `Lead ${agentName} sent merge_ready for branch ${mergeReadyBranches[0]}`;
+	}
+	return `Lead ${agentName} sent ${mergeReadyBranches.length} merge_ready (branches: ${mergeReadyBranches.join(", ")})`;
+}
+
 /** Delete a git branch (best-effort, non-fatal). */
 async function deleteBranchBestEffort(repoRoot: string, branch: string): Promise<boolean> {
 	try {
@@ -115,20 +169,35 @@ export async function stopCommand(
 		}
 
 		const isZombie = session.state === "zombie";
-		const isHeadless = session.tmuxSession === "" && session.pid !== null;
+		// Headless task-scoped agents (Phase 3 spawn-per-turn): tmuxSession is ""
+		// and session.pid is null between turns. The live PID for an in-flight
+		// turn is published at .overstory/agents/<name>/turn.pid. Sapling RPC
+		// agents still use session.pid for their long-lived process.
+		const isHeadless = session.tmuxSession === "";
+		const turnPidPath = join(overstoryDir, "agents", agentName, "turn.pid");
 
 		let tmuxKilled = false;
 		let pidKilled = false;
 
 		// 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);
+			if (isHeadless) {
+				// Prefer the per-turn PID file (Phase 3) — this catches an in-flight
+				// claude turn for any task-scoped capability. Fall back to the
+				// session row's pid for legacy/long-lived headless runtimes (Sapling).
+				const turnPid = await readPidFile(turnPidPath);
+				const targetPid = turnPid ?? session.pid;
+				if (targetPid !== null && proc.isAlive(targetPid)) {
+					await proc.killTree(targetPid);
 					pidKilled = true;
 				}
+				// Reap the turn.pid file so a subsequent ov stop / mail injector
+				// doesn't see a stale entry. Idempotent.
+				try {
+					await unlink(turnPidPath);
+				} catch {
+					// already gone — non-fatal
+				}
 			} else {
 				// TUI agent: kill via tmux session
 				const alive = await tmux.isSessionAlive(session.tmuxSession);
@@ -138,9 +207,39 @@ export async function stopCommand(
 				}
 			}
 
-			// Mark session as completed
-			store.updateState(agentName, "completed");
+			// Mark session as completed via the guarded transition. `completed` is
+			// reachable from every non-completed state (including zombie, so `ov
+			// stop` can promote a watchdog-flagged zombie to a clean completion),
+			// so the only way this rejects is if state is already `completed` —
+			// which is the no-op we want anyway. Race-safe under overstory-a993.
+			store.tryTransitionState(agentName, "completed");
 			store.updateLastActivity(agentName);
+
+			// Auto-nudge coordinator when a lead truly completes so it wakes up
+			// to process merge_ready / worker_done messages without waiting for
+			// user input. Fires from `ov stop` (real completion signal) rather
+			// than the per-turn Stop hook, which was spamming the coordinator
+			// (overstory-49a7).
+			if (session.capability === "lead") {
+				try {
+					const mailDbPath = join(overstoryDir, "mail.db");
+					const subject = buildLeadCompletedSubject(agentName, mailDbPath);
+					const nudgesDir = join(overstoryDir, "pending-nudges");
+					const { mkdir } = await import("node:fs/promises");
+					await mkdir(nudgesDir, { recursive: true });
+					const markerPath = join(nudgesDir, "coordinator.json");
+					const marker = {
+						from: agentName,
+						reason: "lead_completed",
+						subject,
+						messageId: `auto-nudge-${agentName}-${Date.now()}`,
+						createdAt: new Date().toISOString(),
+					};
+					await Bun.write(markerPath, `${JSON.stringify(marker, null, "\t")}\n`);
+				} catch {
+					// Non-fatal: nudge failure should not break stop
+				}
+			}
 		}
 
 		// Optionally remove worktree and branch (best-effort, non-fatal)

package/src/commands/watch.test.ts

@@ -88,6 +88,7 @@ describe("watchCommand", () => {
 		expect(out).toContain("watch");
 		expect(out).toContain("--interval");
 		expect(out).toContain("--background");
+		expect(out).toContain("--kill-others");
 		expect(out).toContain("Tier 0");
 	});
 
@@ -113,6 +114,48 @@ describe("watchCommand", () => {
 		expect(process.exitCode).toBe(1);
 	});
 
+	test("foreground mode: refuses when a live foreign PID owns the lock", async () => {
+		// Spawn a long-running child to act as the "foreign live process". Its
+		// PID will not match our own, so acquirePidLock should refuse rather
+		// than treat the existing PID as idempotent self-ownership. The
+		// foreground path used to overwrite this file unconditionally — the
+		// overstory-8ef6 fix forces it to refuse.
+		const sleeper = Bun.spawn(["sleep", "30"], {
+			stdout: "ignore",
+			stderr: "ignore",
+		});
+		try {
+			const pidFilePath = join(tempDir, ".overstory", "watchdog.pid");
+			await Bun.write(pidFilePath, `${sleeper.pid}\n`);
+
+			// --json for structured output. No --background, so this exercises
+			// the foreground exclusion path. A correctly contested lock returns
+			// immediately (exit 1) without starting the daemon loop.
+			await watchCommand(["--json"]);
+
+			const out = output();
+			const jsonLine = out
+				.split("\n")
+				.map((l) => l.trim())
+				.find((l) => l.startsWith("{"));
+			expect(jsonLine).toBeDefined();
+			if (jsonLine) {
+				const parsed = JSON.parse(jsonLine);
+				expect(parsed.running).toBe(true);
+				expect(parsed.pid).toBe(sleeper.pid);
+				expect(parsed.error).toContain("already running");
+			}
+			expect(process.exitCode).toBe(1);
+
+			// PID file untouched — still the foreign owner's PID.
+			const fileContent = await Bun.file(pidFilePath).text();
+			expect(fileContent.trim()).toBe(`${sleeper.pid}`);
+		} finally {
+			sleeper.kill("SIGTERM");
+			await sleeper.exited.catch(() => {});
+		}
+	});
+
 	test("background mode: stale PID cleanup", async () => {
 		// Write a PID file with a non-running process (999999 is very unlikely to exist)
 		const pidFilePath = join(tempDir, ".overstory", "watchdog.pid");

package/src/commands/watch.ts

@@ -13,7 +13,13 @@ import { jsonOutput } from "../json.ts";
 import { printError, printHint, printSuccess } from "../logging/color.ts";
 import type { HealthCheck } from "../types.ts";
 import { resolveOverstoryBin } from "../utils/bin.ts";
-import { readPidFile, removePidFile, writePidFile } from "../utils/pid.ts";
+import {
+	type AcquirePidLockResult,
+	acquirePidLock,
+	readPidFile,
+	removePidFile,
+} from "../utils/pid.ts";
+import { findRunningWatchdogProcesses, type WatchdogProcess } from "../utils/process-scan.ts";
 import { startDaemon } from "../watchdog/daemon.ts";
 import { isProcessRunning } from "../watchdog/health.ts";
 
@@ -38,6 +44,39 @@ export function formatCheck(check: HealthCheck): string {
 	return line;
 }
 
+/**
+ * Format a "lock contested" error consistently across foreground/background.
+ */
+function formatLockContestedError(existingPid: number, pidFilePath: string): string {
+	if (existingPid <= 0) {
+		return `Watchdog PID file at ${pidFilePath} is owned by another process (could not read PID). Run 'ov watch --kill-others' or remove the file.`;
+	}
+	return `Watchdog already running (PID: ${existingPid}). Kill it first, run 'ov watch --kill-others', or remove ${pidFilePath}`;
+}
+
+/**
+ * Kill running `ov watch` daemons that are NOT the given excludedPid.
+ * Returns the list of PIDs killed (after a SIGTERM was issued — not waited).
+ */
+async function killForeignWatchdogs(
+	excludedPid: number | null,
+): Promise<{ killed: number[]; surveyed: WatchdogProcess[] }> {
+	const surveyed = await findRunningWatchdogProcesses();
+	const killed: number[] = [];
+	for (const proc of surveyed) {
+		if (excludedPid !== null && proc.pid === excludedPid) {
+			continue;
+		}
+		try {
+			process.kill(proc.pid, "SIGTERM");
+			killed.push(proc.pid);
+		} catch {
+			// Process already gone — not an error.
+		}
+	}
+	return { killed, surveyed };
+}
+
 /**
  * Core implementation for the watch command.
  */
@@ -45,6 +84,7 @@ async function runWatch(opts: {
 	interval?: string;
 	background?: boolean;
 	json?: boolean;
+	killOthers?: boolean;
 }): Promise<void> {
 	const cwd = process.cwd();
 	const config = await loadConfig(cwd);
@@ -59,26 +99,46 @@ async function runWatch(opts: {
 
 	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)) {
-			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}`,
-				);
+	// --kill-others: kill any pre-existing `ov watch` daemons before claiming
+	// the lock. Useful when an earlier release allowed multi-daemon state.
+	if (opts.killOthers) {
+		const { killed } = await killForeignWatchdogs(null);
+
+		// Wait for the just-killed processes to actually exit before reclaiming
+		// the PID file. Without this, the next acquirePidLock call sees a still-
+		// alive PID in the file and refuses, even though we issued SIGTERM
+		// nanoseconds earlier. Poll for up to ~2s.
+		const killedSet = new Set(killed);
+		if (killedSet.size > 0) {
+			const deadline = Date.now() + 2000;
+			while (Date.now() < deadline) {
+				const stillAlive = killed.filter((p) => isProcessRunning(p));
+				if (stillAlive.length === 0) break;
+				await Bun.sleep(50);
 			}
-			process.exitCode = 1;
-			return;
 		}
 
-		// Clean up stale PID file if process is no longer running
+		// Reclaim the PID file if it pointed at a process we just killed (it is
+		// either already dead or in flight to dead) or at any other dead PID.
+		const existingPid = await readPidFile(pidFilePath);
 		if (existingPid !== null) {
-			await removePidFile(pidFilePath);
+			if (killedSet.has(existingPid) || !isProcessRunning(existingPid)) {
+				await removePidFile(pidFilePath);
+			}
 		}
 
+		if (killed.length > 0) {
+			if (useJson) {
+				jsonOutput("watch", { killed });
+			} else {
+				printSuccess(`Killed ${killed.length} foreign watchdog process(es): ${killed.join(", ")}`);
+			}
+		} else if (!useJson) {
+			printHint("No foreign watchdog processes found.");
+		}
+	}
+
+	if (opts.background) {
 		// Build the args for the child process, forwarding --interval but not --background
 		const childArgs: string[] = ["watch"];
 		if (opts.interval) {
@@ -88,7 +148,21 @@ async function runWatch(opts: {
 		// Resolve the overstory binary path
 		const overstoryBin = await resolveOverstoryBin();
 
-		// Spawn a detached background process running `overstory watch` (without --background)
+		// Pre-check: surface "already running" before paying the cost of a spawn.
+		// This is only for friendly errors — the authoritative exclusion happens
+		// in the atomic acquirePidLock call below.
+		const existingPid = await readPidFile(pidFilePath);
+		if (existingPid !== null && isProcessRunning(existingPid)) {
+			if (useJson) {
+				jsonOutput("watch", { running: true, pid: existingPid, error: "Watchdog already running" });
+			} else {
+				printError(formatLockContestedError(existingPid, pidFilePath));
+			}
+			process.exitCode = 1;
+			return;
+		}
+
+		// Spawn the detached background daemon (foreground mode in the child).
 		const child = Bun.spawn(["bun", "run", overstoryBin, ...childArgs], {
 			cwd,
 			stdout: "ignore",
@@ -96,13 +170,33 @@ async function runWatch(opts: {
 			stdin: "ignore",
 		});
 
-		// Unref the child so the parent can exit without waiting for it
-		child.unref();
-
 		const childPid = child.pid;
 
-		// Write PID file for later cleanup
-		await writePidFile(pidFilePath, childPid);
+		// Atomically acquire the lock with the child's PID. If another writer
+		// raced in between our pre-check and the spawn, we have to kill our
+		// child and report contention.
+		const lockResult = await acquirePidLock(pidFilePath, childPid, isProcessRunning);
+		if (!lockResult.acquired) {
+			try {
+				child.kill("SIGTERM");
+			} catch {
+				// Already exited — not an error.
+			}
+			if (useJson) {
+				jsonOutput("watch", {
+					running: true,
+					pid: lockResult.existingPid,
+					error: "Watchdog already running",
+				});
+			} else {
+				printError(formatLockContestedError(lockResult.existingPid, pidFilePath));
+			}
+			process.exitCode = 1;
+			return;
+		}
+
+		// Lock is ours. Detach so this parent invocation can exit independently.
+		child.unref();
 
 		if (useJson) {
 			jsonOutput("watch", { pid: childPid, intervalMs, pidFile: pidFilePath });
@@ -113,7 +207,29 @@ async function runWatch(opts: {
 		return;
 	}
 
-	// Foreground mode: show real-time health checks
+	// Foreground mode: acquire the lock atomically before announcing anything.
+	// In the background-spawn case the parent has already written this PID into
+	// the lock file; acquirePidLock detects own-PID and returns acquired=true
+	// idempotently.
+	const lockResult: AcquirePidLockResult = await acquirePidLock(
+		pidFilePath,
+		process.pid,
+		isProcessRunning,
+	);
+	if (!lockResult.acquired) {
+		if (useJson) {
+			jsonOutput("watch", {
+				running: true,
+				pid: lockResult.existingPid,
+				error: "Watchdog already running",
+			});
+		} else {
+			printError(formatLockContestedError(lockResult.existingPid, pidFilePath));
+		}
+		process.exitCode = 1;
+		return;
+	}
+
 	if (useJson) {
 		jsonOutput("watch", { pid: process.pid, intervalMs, mode: "foreground" });
 	} else {
@@ -121,9 +237,6 @@ async function runWatch(opts: {
 		printHint("Press Ctrl+C to stop.");
 	}
 
-	// Write PID file so `--background` check and external tools can find us
-	await writePidFile(pidFilePath, process.pid);
-
 	const { stop } = startDaemon({
 		root: config.project.root,
 		intervalMs,
@@ -131,6 +244,7 @@ async function runWatch(opts: {
 		zombieThresholdMs,
 		nudgeIntervalMs: config.watchdog.nudgeIntervalMs,
 		tier1Enabled: config.watchdog.tier1Enabled,
+		notifyParentOnDeath: config.watchdog.notifyParentOnDeath ?? true,
 		onHealthCheck(check) {
 			const timestamp = new Date().toISOString().slice(11, 19);
 			process.stdout.write(`[${timestamp}] ${formatCheck(check)}\n`);
@@ -156,10 +270,21 @@ 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)")
+		.option(
+			"--kill-others",
+			"Kill any pre-existing 'ov watch' processes before starting (for cleanup of multi-daemon state)",
+		)
 		.option("--json", "Output as JSON")
-		.action(async (opts: { interval?: string; background?: boolean; json?: boolean }) => {
-			await runWatch(opts);
-		});
+		.action(
+			async (opts: {
+				interval?: string;
+				background?: boolean;
+				killOthers?: boolean;
+				json?: boolean;
+			}) => {
+				await runWatch(opts);
+			},
+		);
 }
 
 /**

package/src/config.ts

@@ -90,6 +90,7 @@ export const DEFAULT_CONFIG: OverstoryConfig = {
 		rpcTimeoutMs: 5_000, // 5 seconds for RPC getState() calls
 		triageTimeoutMs: 30_000, // 30 seconds for Tier 1 AI triage calls
 		maxEscalationLevel: 3, // Maximum escalation level before termination
+		notifyParentOnDeath: true, // Send worker_died mail to parent when watchdog terminates a child
 	},
 	coordinator: {
 		exitTriggers: {
@@ -633,6 +634,16 @@ function validateConfig(config: OverstoryConfig): void {
 		}
 	}
 
+	if (
+		config.watchdog.notifyParentOnDeath !== undefined &&
+		typeof config.watchdog.notifyParentOnDeath !== "boolean"
+	) {
+		throw new ValidationError("watchdog.notifyParentOnDeath must be a boolean", {
+			field: "watchdog.notifyParentOnDeath",
+			value: config.watchdog.notifyParentOnDeath,
+		});
+	}
+
 	// mulch.primeFormat must be one of the valid options
 	const validFormats = ["markdown", "xml", "json"] as const;
 	if (!validFormats.includes(config.mulch.primeFormat as (typeof validFormats)[number])) {
@@ -774,6 +785,18 @@ function validateConfig(config: OverstoryConfig): void {
 		}
 	}
 
+	// runtime.claudeHeadlessByDefault: must be a boolean if present
+	if (
+		config.runtime?.claudeHeadlessByDefault !== undefined &&
+		typeof config.runtime.claudeHeadlessByDefault !== "boolean"
+	) {
+		process.stderr.write(
+			`[overstory] WARNING: runtime.claudeHeadlessByDefault must be a boolean. Got: ${typeof config
+				.runtime.claudeHeadlessByDefault}. Ignoring.\n`,
+		);
+		config.runtime.claudeHeadlessByDefault = undefined;
+	}
+
 	if (config.runtime?.capabilities) {
 		for (const [cap, runtimeName] of Object.entries(config.runtime.capabilities)) {
 			if (runtimeName !== undefined && (typeof runtimeName !== "string" || runtimeName === "")) {

package/src/doctor/consistency.test.ts

@@ -410,6 +410,112 @@ describe("checkConsistency", () => {
 		expect(checks.find((c) => c.name === "missing-tmux")?.status).toBe("pass");
 	});
 
+	test("orphan-spawns: terminal state with live pid is flagged", async () => {
+		const dbPath = join(overstoryDir, "sessions.db");
+		const store = createSessionStore(dbPath);
+
+		store.upsert({
+			id: "session-1",
+			agentName: "orphaned-agent",
+			capability: "builder",
+			worktreePath: join(overstoryDir, "worktrees", "orphaned-agent"),
+			branchName: "overstory/orphaned-agent/test-123",
+			taskId: "test-123",
+			tmuxSession: "",
+			state: "completed",
+			pid: 4242,
+			parentAgent: null,
+			depth: 0,
+			runId: null,
+			startedAt: new Date().toISOString(),
+			lastActivity: new Date().toISOString(),
+			escalationLevel: 0,
+			stalledSince: null,
+			transcriptPath: null,
+		});
+		store.close();
+
+		mockIsProcessAlive.mockReturnValue(true);
+		mockListSessions.mockResolvedValue([]);
+
+		const checks = await checkConsistency(config, overstoryDir, mockDeps);
+
+		const orphanCheck = checks.find((c) => c.name === "orphan-spawns");
+		expect(orphanCheck).toBeDefined();
+		expect(orphanCheck?.status).toBe("warn");
+		expect(orphanCheck?.message).toContain("1 orphaned spawn");
+		expect(orphanCheck?.details?.[0]).toContain("orphaned-agent");
+		expect(orphanCheck?.fixable).toBe(true);
+	});
+
+	test("orphan-spawns: tmux dead but pid alive is flagged", async () => {
+		const dbPath = join(overstoryDir, "sessions.db");
+		const store = createSessionStore(dbPath);
+
+		store.upsert({
+			id: "session-1",
+			agentName: "tmux-dead-agent",
+			capability: "builder",
+			worktreePath: join(overstoryDir, "worktrees", "tmux-dead-agent"),
+			branchName: "overstory/tmux-dead-agent/test-123",
+			taskId: "test-123",
+			tmuxSession: "overstory-testproject-tmux-dead-agent",
+			state: "working",
+			pid: 4242,
+			parentAgent: null,
+			depth: 0,
+			runId: null,
+			startedAt: new Date().toISOString(),
+			lastActivity: new Date().toISOString(),
+			escalationLevel: 0,
+			stalledSince: null,
+			transcriptPath: null,
+		});
+		store.close();
+
+		mockIsProcessAlive.mockReturnValue(true);
+		// tmux server reports no matching session
+		mockListSessions.mockResolvedValue([]);
+
+		const checks = await checkConsistency(config, overstoryDir, mockDeps);
+
+		const orphanCheck = checks.find((c) => c.name === "orphan-spawns");
+		expect(orphanCheck?.status).toBe("warn");
+		expect(orphanCheck?.details?.[0]).toContain("tmux session");
+	});
+
+	test("orphan-spawns: passes when terminal-state pid is dead", async () => {
+		const dbPath = join(overstoryDir, "sessions.db");
+		const store = createSessionStore(dbPath);
+
+		store.upsert({
+			id: "session-1",
+			agentName: "clean-completed",
+			capability: "builder",
+			worktreePath: join(overstoryDir, "worktrees", "clean-completed"),
+			branchName: "overstory/clean-completed/test-123",
+			taskId: "test-123",
+			tmuxSession: "",
+			state: "completed",
+			pid: 4242,
+			parentAgent: null,
+			depth: 0,
+			runId: null,
+			startedAt: new Date().toISOString(),
+			lastActivity: new Date().toISOString(),
+			escalationLevel: 0,
+			stalledSince: null,
+			transcriptPath: null,
+		});
+		store.close();
+
+		mockIsProcessAlive.mockReturnValue(false);
+
+		const checks = await checkConsistency(config, overstoryDir, mockDeps);
+
+		expect(checks.find((c) => c.name === "orphan-spawns")?.status).toBe("pass");
+	});
+
 	test("handles tmux not installed gracefully", async () => {
 		// Mock tmux listing to throw an error
 		mockListSessions.mockRejectedValue(new Error("tmux: command not found"));