@os-eco/overstory-cli 0.8.7 → 0.9.2

package/src/commands/watch.ts

@@ -9,17 +9,19 @@
 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 { resolveOverstoryBin } from "../utils/bin.ts";
+import { readPidFile, removePidFile, writePidFile } from "../utils/pid.ts";
 import { startDaemon } from "../watchdog/daemon.ts";
 import { isProcessRunning } from "../watchdog/health.ts";
 
 /**
  * Format a health check for display.
+ * @internal Exported for testing.
  */
-function formatCheck(check: HealthCheck): string {
+export function formatCheck(check: HealthCheck): string {
 	const actionIcon =
 		check.action === "terminate"
 			? "x"
@@ -36,83 +38,6 @@ function formatCheck(check: HealthCheck): string {
 	return line;
 }
 
-// isProcessRunning is imported from ../watchdog/health.ts (ZFC shared utility)
-
-/**
- * Read the PID from the watchdog PID file.
- * Returns null if the file doesn't exist or can't be parsed.
- */
-async function readPidFile(pidFilePath: string): Promise<number | null> {
-	const file = Bun.file(pidFilePath);
-	const exists = await file.exists();
-	if (!exists) {
-		return null;
-	}
-
-	try {
-		const text = await file.text();
-		const pid = Number.parseInt(text.trim(), 10);
-		if (Number.isNaN(pid) || pid <= 0) {
-			return null;
-		}
-		return pid;
-	} catch {
-		return null;
-	}
-}
-
-/**
- * Write a PID to the watchdog PID file.
- */
-async function writePidFile(pidFilePath: string, pid: number): Promise<void> {
-	await Bun.write(pidFilePath, `${pid}\n`);
-}
-
-/**
- * Remove the watchdog PID file.
- */
-async function removePidFile(pidFilePath: string): Promise<void> {
-	const { unlink } = await import("node:fs/promises");
-	try {
-		await unlink(pidFilePath);
-	} catch {
-		// File may already be gone — not an error
-	}
-}
-
-/**
- * Resolve the path to the overstory binary for re-launching.
- * Uses `which overstory` first, then falls back to process.argv.
- */
-async function resolveOverstoryBin(): Promise<string> {
-	try {
-		const proc = Bun.spawn(["which", "ov"], {
-			stdout: "pipe",
-			stderr: "pipe",
-		});
-		const exitCode = await proc.exited;
-		if (exitCode === 0) {
-			const binPath = (await new Response(proc.stdout).text()).trim();
-			if (binPath.length > 0) {
-				return binPath;
-			}
-		}
-	} catch {
-		// which not available or overstory not on PATH
-	}
-
-	// Fallback: use the script that's currently running (process.argv[1])
-	const scriptPath = process.argv[1];
-	if (scriptPath) {
-		return scriptPath;
-	}
-
-	throw new OverstoryError(
-		"Cannot resolve overstory binary path for background launch",
-		"WATCH_ERROR",
-	);
-}
-
 /**
  * Core implementation for the watch command.
  */
@@ -213,17 +138,17 @@ async function runWatch(opts: {
 	});
 
 	// Keep running until interrupted
-	process.on("SIGINT", () => {
-		stop();
-		// Clean up PID file on graceful shutdown
-		removePidFile(pidFilePath).finally(() => {
-			printSuccess("Watchdog stopped.");
-			process.exit(0);
+	await new Promise<void>((resolve) => {
+		process.on("SIGINT", () => {
+			stop();
+			// Clean up PID file on graceful shutdown
+			removePidFile(pidFilePath).finally(() => {
+				printSuccess("Watchdog stopped.");
+				process.exitCode = 0;
+				resolve();
+			});
 		});
 	});
-
-	// Block forever
-	await new Promise(() => {});
 }
 
 export function createWatchCommand(): Command {

package/src/config.test.ts

@@ -371,6 +371,7 @@ watchdog:
   tier0Enabled: false
   tier0IntervalMs: 20000
   tier1Enabled: true
+  triageTimeoutMs: 15000
 `);
 
 		const config = await loadConfig(tempDir);
@@ -568,6 +569,151 @@ watchdog:
 		await expect(loadConfig(tempDir)).rejects.toThrow(ValidationError);
 	});
 
+	// rpcTimeoutMs tests
+	test("defaults rpcTimeoutMs to 5000", async () => {
+		const config = await loadConfig(tempDir);
+		expect(config.watchdog.rpcTimeoutMs).toBe(5000);
+	});
+
+	test("accepts valid rpcTimeoutMs", async () => {
+		await writeConfig(`
+watchdog:
+  rpcTimeoutMs: 10000
+`);
+		const config = await loadConfig(tempDir);
+		expect(config.watchdog.rpcTimeoutMs).toBe(10000);
+	});
+
+	test("rejects rpcTimeoutMs below 1000", async () => {
+		await writeConfig(`
+watchdog:
+  rpcTimeoutMs: 999
+`);
+		await expect(loadConfig(tempDir)).rejects.toThrow(ValidationError);
+	});
+
+	test("rejects rpcTimeoutMs above 30000", async () => {
+		await writeConfig(`
+watchdog:
+  rpcTimeoutMs: 30001
+`);
+		await expect(loadConfig(tempDir)).rejects.toThrow(ValidationError);
+	});
+
+	// triageTimeoutMs tests
+	test("defaults triageTimeoutMs to 30000", async () => {
+		const config = await loadConfig(tempDir);
+		expect(config.watchdog.triageTimeoutMs).toBe(30000);
+	});
+
+	test("accepts valid triageTimeoutMs", async () => {
+		await writeConfig(`
+watchdog:
+  triageTimeoutMs: 60000
+`);
+		const config = await loadConfig(tempDir);
+		expect(config.watchdog.triageTimeoutMs).toBe(60000);
+	});
+
+	test("rejects triageTimeoutMs below 5000", async () => {
+		await writeConfig(`
+watchdog:
+  triageTimeoutMs: 4999
+`);
+		await expect(loadConfig(tempDir)).rejects.toThrow(ValidationError);
+	});
+
+	test("rejects triageTimeoutMs above 120000", async () => {
+		await writeConfig(`
+watchdog:
+  triageTimeoutMs: 120001
+`);
+		await expect(loadConfig(tempDir)).rejects.toThrow(ValidationError);
+	});
+
+	test("rejects triageTimeoutMs >= tier0IntervalMs when tier1 is enabled", async () => {
+		// Must include tier0Enabled to avoid deprecated-key migration that would remap tier1Enabled
+		await writeConfig(`
+watchdog:
+  tier0Enabled: true
+  tier1Enabled: true
+  tier0IntervalMs: 30000
+  triageTimeoutMs: 30000
+`);
+		await expect(loadConfig(tempDir)).rejects.toThrow(ValidationError);
+	});
+
+	test("accepts triageTimeoutMs < tier0IntervalMs when tier1 is enabled", async () => {
+		await writeConfig(`
+watchdog:
+  tier0Enabled: true
+  tier1Enabled: true
+  tier0IntervalMs: 60000
+  triageTimeoutMs: 30000
+`);
+		const config = await loadConfig(tempDir);
+		expect(config.watchdog.triageTimeoutMs).toBe(30000);
+	});
+
+	test("allows triageTimeoutMs >= tier0IntervalMs when tier1 is disabled", async () => {
+		await writeConfig(`
+watchdog:
+  tier0Enabled: true
+  tier1Enabled: false
+  tier0IntervalMs: 30000
+  triageTimeoutMs: 30000
+`);
+		const config = await loadConfig(tempDir);
+		expect(config.watchdog.triageTimeoutMs).toBe(30000);
+	});
+
+	// maxEscalationLevel tests
+	test("defaults maxEscalationLevel to 3", async () => {
+		const config = await loadConfig(tempDir);
+		expect(config.watchdog.maxEscalationLevel).toBe(3);
+	});
+
+	test("accepts valid maxEscalationLevel", async () => {
+		await writeConfig(`
+watchdog:
+  maxEscalationLevel: 5
+`);
+		const config = await loadConfig(tempDir);
+		expect(config.watchdog.maxEscalationLevel).toBe(5);
+	});
+
+	test("rejects maxEscalationLevel below 1", async () => {
+		await writeConfig(`
+watchdog:
+  maxEscalationLevel: 0
+`);
+		await expect(loadConfig(tempDir)).rejects.toThrow(ValidationError);
+	});
+
+	test("rejects maxEscalationLevel above 5", async () => {
+		await writeConfig(`
+watchdog:
+  maxEscalationLevel: 6
+`);
+		await expect(loadConfig(tempDir)).rejects.toThrow(ValidationError);
+	});
+
+	test("accepts maxEscalationLevel boundary values 1 and 5", async () => {
+		await writeConfig(`
+watchdog:
+  maxEscalationLevel: 1
+`);
+		let config = await loadConfig(tempDir);
+		expect(config.watchdog.maxEscalationLevel).toBe(1);
+
+		await writeConfig(`
+watchdog:
+  maxEscalationLevel: 5
+`);
+		config = await loadConfig(tempDir);
+		expect(config.watchdog.maxEscalationLevel).toBe(5);
+	});
+
 	test("accepts empty models section", async () => {
 		await writeConfig(`
 models:
@@ -1153,6 +1299,110 @@ coordinator:
 	});
 });
 
+describe("YAML parser edge cases", () => {
+	let tempDir: string;
+
+	beforeEach(async () => {
+		tempDir = await mkdtemp(join(tmpdir(), "overstory-test-"));
+		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("inline comments are stripped from values", async () => {
+		await writeConfig(`
+project:
+  canonicalBranch: develop # this is a comment
+`);
+		const config = await loadConfig(tempDir);
+		expect(config.project.canonicalBranch).toBe("develop");
+	});
+
+	test("quoted strings containing # are preserved (not treated as comments)", async () => {
+		await writeConfig(`
+project:
+  canonicalBranch: "feature#branch"
+`);
+		const config = await loadConfig(tempDir);
+		expect(config.project.canonicalBranch).toBe("feature#branch");
+	});
+
+	test("single-quoted strings containing # are preserved", async () => {
+		await writeConfig(`
+project:
+  canonicalBranch: 'feature#branch'
+`);
+		const config = await loadConfig(tempDir);
+		expect(config.project.canonicalBranch).toBe("feature#branch");
+	});
+
+	test("boolean coercion: true/True/TRUE all parse as true", async () => {
+		// Test with three separate configs since they all map to the same field
+		for (const val of ["true", "True", "TRUE"]) {
+			await writeConfig(`mulch:\n  enabled: ${val}\n`);
+			const config = await loadConfig(tempDir);
+			expect(config.mulch.enabled).toBe(true);
+		}
+	});
+
+	test("boolean coercion: false/False/FALSE all parse as false", async () => {
+		for (const val of ["false", "False", "FALSE"]) {
+			await writeConfig(`mulch:\n  enabled: ${val}\n`);
+			const config = await loadConfig(tempDir);
+			expect(config.mulch.enabled).toBe(false);
+		}
+	});
+
+	test("yes/no are treated as plain strings, not booleans", async () => {
+		// The YAML parser does NOT treat yes/no as booleans (unlike YAML 1.1)
+		await writeConfig(`
+project:
+  canonicalBranch: yes
+`);
+		const config = await loadConfig(tempDir);
+		// "yes" is a plain string, not coerced to boolean
+		expect(config.project.canonicalBranch).toBe("yes");
+	});
+
+	test("integer number coercion", async () => {
+		await writeConfig(`
+agents:
+  maxConcurrent: 42
+`);
+		const config = await loadConfig(tempDir);
+		expect(config.agents.maxConcurrent).toBe(42);
+	});
+
+	test("float number coercion", async () => {
+		// maxSessionsPerRun doesn't accept floats, but the parser itself parses them.
+		// Use a field that passes validation as a number.
+		await writeConfig(`
+agents:
+  maxSessionsPerRun: 5
+  staggerDelayMs: 1500
+`);
+		const config = await loadConfig(tempDir);
+		expect(config.agents.staggerDelayMs).toBe(1500);
+	});
+
+	test("underscore-separated numbers are coerced correctly", async () => {
+		await writeConfig(`
+watchdog:
+  staleThresholdMs: 300_000
+  zombieThresholdMs: 600_000
+`);
+		const config = await loadConfig(tempDir);
+		expect(config.watchdog.staleThresholdMs).toBe(300_000);
+		expect(config.watchdog.zombieThresholdMs).toBe(600_000);
+	});
+});
+
 describe("DEFAULT_CONFIG", () => {
 	test("has all required top-level keys", () => {
 		expect(DEFAULT_CONFIG.project).toBeDefined();

package/src/config.ts

@@ -87,6 +87,9 @@ export const DEFAULT_CONFIG: OverstoryConfig = {
 		staleThresholdMs: 300_000, // 5 minutes
 		zombieThresholdMs: 600_000, // 10 minutes
 		nudgeIntervalMs: 60_000, // 1 minute between progressive nudge stages
+		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
 	},
 	coordinator: {
 		exitTriggers: {
@@ -590,6 +593,46 @@ function validateConfig(config: OverstoryConfig): void {
 		});
 	}
 
+	if (config.watchdog.rpcTimeoutMs !== undefined) {
+		if (config.watchdog.rpcTimeoutMs < 1000 || config.watchdog.rpcTimeoutMs > 30000) {
+			throw new ValidationError("watchdog.rpcTimeoutMs must be between 1000 and 30000", {
+				field: "watchdog.rpcTimeoutMs",
+				value: config.watchdog.rpcTimeoutMs,
+			});
+		}
+	}
+
+	if (config.watchdog.triageTimeoutMs !== undefined) {
+		if (config.watchdog.triageTimeoutMs < 5000 || config.watchdog.triageTimeoutMs > 120000) {
+			throw new ValidationError("watchdog.triageTimeoutMs must be between 5000 and 120000", {
+				field: "watchdog.triageTimeoutMs",
+				value: config.watchdog.triageTimeoutMs,
+			});
+		}
+
+		if (
+			config.watchdog.tier1Enabled &&
+			config.watchdog.triageTimeoutMs >= config.watchdog.tier0IntervalMs
+		) {
+			throw new ValidationError(
+				"watchdog.triageTimeoutMs must be less than tier0IntervalMs when tier1 is enabled",
+				{
+					field: "watchdog.triageTimeoutMs",
+					value: config.watchdog.triageTimeoutMs,
+				},
+			);
+		}
+	}
+
+	if (config.watchdog.maxEscalationLevel !== undefined) {
+		if (config.watchdog.maxEscalationLevel < 1 || config.watchdog.maxEscalationLevel > 5) {
+			throw new ValidationError("watchdog.maxEscalationLevel must be between 1 and 5", {
+				field: "watchdog.maxEscalationLevel",
+				value: config.watchdog.maxEscalationLevel,
+			});
+		}
+	}
+
 	// 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])) {

package/src/doctor/agents.test.ts

@@ -124,13 +124,41 @@ describe("checkAgents", () => {
 		expect(parseCheck?.status).toBe("pass");
 	});
 
-	test("fails when agent has invalid model", async () => {
+	test("passes when agent uses a non-empty model string", async () => {
 		const manifest = {
 			version: "1.0",
 			agents: {
 				scout: {
 					file: "scout.md",
-					model: "invalid-model",
+					model: "gpt-5-4",
+					tools: ["Read"],
+					capabilities: ["explore"],
+					canSpawn: false,
+					constraints: [],
+				},
+			},
+			capabilityIndex: {
+				explore: ["scout"],
+			},
+		};
+
+		await mkdir(join(overstoryDir, "agent-defs"), { recursive: true });
+		await Bun.write(join(overstoryDir, "agent-manifest.json"), JSON.stringify(manifest, null, 2));
+		await Bun.write(join(overstoryDir, "agent-defs", "scout.md"), "# Scout");
+
+		const checks = await checkAgents(mockConfig, overstoryDir);
+
+		const parseCheck = checks.find((c) => c.name === "Manifest parsing");
+		expect(parseCheck?.status).toBe("pass");
+	});
+
+	test("fails when agent model is empty", async () => {
+		const manifest = {
+			version: "1.0",
+			agents: {
+				scout: {
+					file: "scout.md",
+					model: "",
 					tools: ["Read"],
 					capabilities: ["explore"],
 					canSpawn: false,
@@ -148,7 +176,9 @@ describe("checkAgents", () => {
 
 		const parseCheck = checks.find((c) => c.name === "Manifest parsing");
 		expect(parseCheck?.status).toBe("fail");
-		expect(parseCheck?.details?.some((d) => d.includes("model"))).toBe(true);
+		expect(parseCheck?.details?.some((d) => d.includes('"model" must be a non-empty string'))).toBe(
+			true,
+		);
 	});
 
 	test("fails when agent has zero capabilities", async () => {
@@ -378,7 +408,44 @@ sessionsCompleted: -5
 		expect(identityCheck?.details?.some((d) => d.includes("sessionsCompleted"))).toBe(true);
 	});
 
-	test("warns about stale identity files", async () => {
+	test("does not warn for runtime-named identities when the recorded role exists", async () => {
+		const manifest = {
+			version: "1.0",
+			agents: {
+				scout: {
+					file: "scout.md",
+					model: "haiku",
+					tools: ["Read"],
+					capabilities: ["explore"],
+					canSpawn: false,
+					constraints: [],
+				},
+			},
+			capabilityIndex: {
+				explore: ["scout"],
+			},
+		};
+
+		await mkdir(join(overstoryDir, "agent-defs"), { recursive: true });
+		await mkdir(join(overstoryDir, "agents", "scout-task-123"), { recursive: true });
+		await Bun.write(join(overstoryDir, "agent-manifest.json"), JSON.stringify(manifest, null, 2));
+		await Bun.write(join(overstoryDir, "agent-defs", "scout.md"), "# Scout");
+
+		const identity = `name: scout-task-123
+capability: scout
+created: "2024-01-01T00:00:00Z"
+sessionsCompleted: 5
+`;
+
+		await Bun.write(join(overstoryDir, "agents", "scout-task-123", "identity.yaml"), identity);
+
+		const checks = await checkAgents(mockConfig, overstoryDir);
+
+		const staleCheck = checks.find((c) => c.name === "Stale identities");
+		expect(staleCheck).toBeUndefined();
+	});
+
+	test("warns about stale identity files when the recorded role is missing", async () => {
 		const manifest = {
 			version: "1.0",
 			agents: {
@@ -413,7 +480,7 @@ sessionsCompleted: 5
 
 		const staleCheck = checks.find((c) => c.name === "Stale identities");
 		expect(staleCheck?.status).toBe("warn");
-		expect(staleCheck?.details?.some((d) => d.includes("old-agent"))).toBe(true);
+		expect(staleCheck?.details?.some((d) => d.includes("obsolete"))).toBe(true);
 	});
 
 	test("warns when identity name contains invalid characters", async () => {

package/src/doctor/agents.ts

@@ -3,7 +3,6 @@ import { join } from "node:path";
 import type { AgentManifest } from "../types.ts";
 import type { DoctorCheck, DoctorCheckFn } from "./types.ts";
 
-const VALID_MODELS = new Set(["sonnet", "opus", "haiku"]);
 const VALID_NAME_REGEX = /^[a-zA-Z0-9_-]+$/;
 
 /**
@@ -64,8 +63,8 @@ async function loadAndValidateManifest(
 				errors.push(`Agent "${name}": "file" must be a non-empty string`);
 			}
 
-			if (typeof agentDef.model !== "string" || !VALID_MODELS.has(agentDef.model)) {
-				errors.push(`Agent "${name}": "model" must be one of: sonnet, opus, haiku`);
+			if (typeof agentDef.model !== "string" || agentDef.model.length === 0) {
+				errors.push(`Agent "${name}": "model" must be a non-empty string`);
 			}
 
 			if (!Array.isArray(agentDef.tools)) {
@@ -313,12 +312,6 @@ export const checkAgents: DoctorCheckFn = async (_config, overstoryDir): Promise
 
 			identityFileCount++;
 
-			// Check if agent still exists in manifest
-			if (!manifest.agents[agentName]) {
-				staleIdentities.push(agentName);
-				continue;
-			}
-
 			// Parse and validate identity
 			try {
 				const content = await Bun.file(identityPath).text();
@@ -346,6 +339,13 @@ export const checkAgents: DoctorCheckFn = async (_config, overstoryDir): Promise
 					identityErrors.push(`${agentName}: "sessionsCompleted" must be a non-negative integer`);
 				}
 
+				// Identity directories are keyed by runtime agent names (for example
+				// lead-foo-1234), not by manifest role names. Validate the recorded
+				// role/capability against the manifest instead of the directory name.
+				if (identity.capability && !manifest.agents[identity.capability]) {
+					staleIdentities.push(`${agentName} (capability: ${identity.capability})`);
+				}
+
 				// Validate name is valid identifier
 				if (identity.name && !VALID_NAME_REGEX.test(identity.name)) {
 					identityErrors.push(
@@ -384,7 +384,7 @@ export const checkAgents: DoctorCheckFn = async (_config, overstoryDir): Promise
 				category: "agents",
 				status: "warn",
 				message: `Found ${staleIdentities.length} stale identity file(s)`,
-				details: staleIdentities.map((name) => `${name} (agent no longer in manifest)`),
+				details: staleIdentities.map((name) => `${name} (role not present in manifest)`),
 				fixable: true,
 			});
 		}

package/src/doctor/consistency.test.ts

@@ -375,6 +375,41 @@ describe("checkConsistency", () => {
 		expect(warnOrFail.length).toBe(0);
 	});
 
+	test("ignores completed sessions whose tmux, pid, and worktree are gone", async () => {
+		const dbPath = join(overstoryDir, "sessions.db");
+		const store = createSessionStore(dbPath);
+
+		store.upsert({
+			id: "session-1",
+			agentName: "completed-agent",
+			capability: "builder",
+			worktreePath: join(overstoryDir, "worktrees", "completed-agent"),
+			branchName: "overstory/completed-agent/test-123",
+			taskId: "test-123",
+			tmuxSession: "overstory-testproject-completed-agent",
+			state: "completed",
+			pid: 99999,
+			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);
+		mockListSessions.mockResolvedValue([]);
+
+		const checks = await checkConsistency(config, overstoryDir, mockDeps);
+
+		expect(checks.find((c) => c.name === "dead-pids")?.status).toBe("pass");
+		expect(checks.find((c) => c.name === "missing-worktrees")?.status).toBe("pass");
+		expect(checks.find((c) => c.name === "missing-tmux")?.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"));

package/src/doctor/consistency.ts

@@ -89,6 +89,10 @@ export async function checkConsistency(
 		return checks;
 	}
 
+	// Completed/zombie sessions are retained for history and metrics. Their tmux
+	// sessions, PIDs, and worktrees may legitimately be gone.
+	const liveSessions = storeSessions.filter((s) => s.state !== "completed" && s.state !== "zombie");
+
 	// Now perform cross-validation checks
 
 	// 4. Check for orphaned worktrees (worktree exists but no SessionStore entry)
@@ -155,7 +159,7 @@ export async function checkConsistency(
 	}
 
 	// 6. Check for dead processes in SessionStore
-	const deadSessions = storeSessions.filter((s) => s.pid !== null && !isProcessAliveFn(s.pid));
+	const deadSessions = liveSessions.filter((s) => s.pid !== null && !isProcessAliveFn(s.pid));
 
 	if (deadSessions.length > 0) {
 		checks.push({
@@ -177,7 +181,7 @@ export async function checkConsistency(
 
 	// 7. Check for SessionStore entries with missing worktrees
 	const existingWorktreePaths = new Set(worktrees.map((wt) => wt.path));
-	const missingWorktrees = storeSessions.filter((s) => {
+	const missingWorktrees = liveSessions.filter((s) => {
 		// Try to normalize the SessionStore path for comparison
 		try {
 			const normalizedPath = realpathSync(s.worktreePath);
@@ -208,7 +212,7 @@ export async function checkConsistency(
 
 	// 8. Check for SessionStore entries with missing tmux sessions
 	const existingTmuxNames = new Set(tmuxSessions.map((s) => s.name));
-	const missingTmux = storeSessions.filter((s) => !existingTmuxNames.has(s.tmuxSession));
+	const missingTmux = liveSessions.filter((s) => !existingTmuxNames.has(s.tmuxSession));
 
 	if (missingTmux.length > 0) {
 		checks.push({