@katyella/legio 0.1.2 → 0.2.0

package/src/commands/up.ts

@@ -5,7 +5,7 @@
  * 1. Check git repo
  * 2. Initialize .legio/ if needed (legio init)
  * 3. Start the server in daemon mode (legio server start --daemon)
- *    The server auto-starts the coordinator with watchdog.
+ *    The server auto-starts the coordinator with watchman.
  * 4. Start the gateway (legio gateway start --no-attach)
  * 5. Open the browser (unless --no-open)
  *
@@ -16,7 +16,7 @@ import { spawn } from "node:child_process";
 import { access, readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { ServerError, ValidationError } from "../errors.ts";
-import { isProcessRunning } from "../watchdog/health.ts";
+import { isProcessRunning } from "../watchman/health.ts";
 
 function getFlag(args: string[], flag: string): string | undefined {
 	const idx = args.indexOf(flag);
@@ -118,7 +118,7 @@ Options:
 
 legio up initializes .legio/ if needed, starts the server in daemon mode,
 starts the gateway, and opens the browser. The server auto-starts the
-coordinator with watchdog. Running legio up when already running is a no-op.`;
+coordinator with watchman. Running legio up when already running is a no-op.`;
 
 /**
  * Entry point for \`legio up [options]\`.
@@ -238,14 +238,18 @@ export async function upCommand(args: string[], deps: UpDeps = {}): Promise<void
 		// ignore status check errors, proceed to try starting
 	}
 	if (!gatewayRunning) {
-		const gatewayStart = await run(["legio", "gateway", "start", "--no-attach"], {
-			cwd: projectRoot,
-		});
-		if (gatewayStart.exitCode === 0) {
-			gatewayStarted = true;
-			if (!json && gatewayStart.stdout) process.stdout.write(gatewayStart.stdout);
-		} else {
-			process.stderr.write(`Warning: gateway start failed: ${gatewayStart.stderr.trim()}\n`);
+		try {
+			const gatewayResult = await run(["legio", "gateway", "start", "--no-attach", "--json"], {
+				cwd: projectRoot,
+			});
+			if (gatewayResult.exitCode === 0) {
+				gatewayStarted = true;
+				if (!json) process.stdout.write("Gateway started\n");
+			} else if (!json) {
+				process.stderr.write(`Warning: gateway start failed: ${gatewayResult.stderr.trim()}\n`);
+			}
+		} catch {
+			if (!json) process.stderr.write("Warning: gateway start failed\n");
 		}
 	}
 

package/src/commands/watchman.ts

@@ -0,0 +1,327 @@
+/**
+ * CLI command: legio watchman start/stop/status
+ *
+ * Unified daemon combining:
+ *   - Health monitoring (watchdog): session health checks, zombie detection, recovery
+ *   - Mail delivery (mailman): poll for unread mail, nudge agents
+ *   - Beacon safety net: detect stuck beacons and send follow-up Enter
+ *
+ * PID file: .legio/watchman.pid
+ */
+
+import { spawn } from "node:child_process";
+import { readFile, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { loadConfig } from "../config.ts";
+import { LegioError } from "../errors.ts";
+import type { HealthCheck } from "../types.ts";
+import { startDaemon } from "../watchman/daemon.ts";
+import { isProcessRunning } from "../watchman/health.ts";
+
+function getFlag(args: string[], flag: string): string | undefined {
+	const idx = args.indexOf(flag);
+	if (idx === -1 || idx + 1 >= args.length) return undefined;
+	return args[idx + 1];
+}
+
+function hasFlag(args: string[], flag: string): boolean {
+	return args.includes(flag);
+}
+
+/**
+ * Format a health check for display.
+ */
+function formatCheck(check: HealthCheck): string {
+	const actionIcon =
+		check.action === "terminate"
+			? "💀"
+			: check.action === "escalate"
+				? "⚠️"
+				: check.action === "investigate"
+					? "🔍"
+					: "✅";
+	const pidLabel = check.pidAlive === null ? "n/a" : check.pidAlive ? "up" : "down";
+	let line = `${actionIcon} ${check.agentName}: ${check.state} (tmux=${check.tmuxAlive ? "up" : "down"}, pid=${pidLabel})`;
+	if (check.reconciliationNote) {
+		line += ` [${check.reconciliationNote}]`;
+	}
+	return line;
+}
+
+/**
+ * Read the PID from the watchman PID file.
+ */
+async function readPidFile(pidFilePath: string): Promise<number | null> {
+	try {
+		const text = await readFile(pidFilePath, "utf-8");
+		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 watchman PID file.
+ */
+async function writePidFile(pidFilePath: string, pid: number): Promise<void> {
+	await writeFile(pidFilePath, `${pid}\n`);
+}
+
+/**
+ * Remove the watchman PID file.
+ */
+async function removePidFile(pidFilePath: string): Promise<void> {
+	try {
+		await unlink(pidFilePath);
+	} catch {
+		// File may already be gone
+	}
+}
+
+/**
+ * Resolve the path to the legio binary for re-launching.
+ */
+async function resolveLegioBin(): Promise<string> {
+	try {
+		const result = await new Promise<{ exitCode: number; stdout: string }>((resolve) => {
+			const proc = spawn("which", ["legio"], { stdio: ["ignore", "pipe", "pipe"] });
+			const stdoutChunks: Buffer[] = [];
+			proc.stdout?.on("data", (chunk: Buffer) => stdoutChunks.push(chunk));
+			proc.on("close", (code: number | null) => {
+				resolve({ exitCode: code ?? 1, stdout: Buffer.concat(stdoutChunks).toString("utf-8") });
+			});
+		});
+		if (result.exitCode === 0) {
+			const binPath = result.stdout.trim();
+			if (binPath.length > 0) return binPath;
+		}
+	} catch {
+		// which not available
+	}
+	const scriptPath = process.argv[1];
+	if (scriptPath) return scriptPath;
+	throw new LegioError("Cannot resolve legio binary path for background launch", "WATCHMAN_ERROR");
+}
+
+/** Handle `legio watchman start` */
+async function handleStart(args: string[]): Promise<void> {
+	const background = hasFlag(args, "--background");
+	const intervalStr = getFlag(args, "--interval");
+
+	const cwd = process.cwd();
+	const config = await loadConfig(cwd);
+	const root = config.project.root;
+	const intervalMs = intervalStr
+		? Number.parseInt(intervalStr, 10)
+		: config.watchman.tier0IntervalMs;
+	const pidFilePath = join(root, ".legio", "watchman.pid");
+
+	if (background) {
+		// Check if already running
+		const existingPid = await readPidFile(pidFilePath);
+		if (existingPid !== null && isProcessRunning(existingPid)) {
+			process.stderr.write(
+				`Error: Watchman already running (PID: ${existingPid}). ` +
+					`Kill it first or remove ${pidFilePath}\n`,
+			);
+			process.exitCode = 1;
+			return;
+		}
+
+		if (existingPid !== null) {
+			await removePidFile(pidFilePath);
+		}
+
+		const childArgs: string[] = ["watchman", "start"];
+		if (intervalStr) {
+			childArgs.push("--interval", intervalStr);
+		}
+
+		const legioBin = await resolveLegioBin();
+		const child = spawn(process.execPath, ["--import", "tsx", legioBin, ...childArgs], {
+			cwd,
+			stdio: "ignore",
+			detached: true,
+		});
+		child.unref();
+
+		const childPid = child.pid ?? 0;
+		await writePidFile(pidFilePath, childPid);
+
+		process.stdout.write(
+			`Watchman started in background (PID: ${childPid}, interval: ${intervalMs}ms)\n`,
+		);
+		process.stdout.write(`PID file: ${pidFilePath}\n`);
+		return;
+	}
+
+	// Foreground mode
+	process.stdout.write(
+		`Watchman running (health: ${intervalMs}ms, mail: ${config.watchman.mailIntervalMs}ms)\n`,
+	);
+	process.stdout.write("Press Ctrl+C to stop.\n\n");
+
+	await writePidFile(pidFilePath, process.pid);
+
+	const { stop } = startDaemon({
+		root,
+		intervalMs,
+		zombieThresholdMs: config.watchman.zombieThresholdMs,
+		mailIntervalMs: config.watchman.mailIntervalMs,
+		reNudgeIntervalMs: config.watchman.reNudgeIntervalMs,
+		warnAfterMs: config.watchman.warnAfterMs,
+		beaconNudgeMs: config.watchman.beaconNudgeMs,
+		onHealthCheck(check) {
+			const timestamp = new Date().toISOString().slice(11, 19);
+			process.stdout.write(`[${timestamp}] ${formatCheck(check)}\n`);
+		},
+		onNudge(agentName, nudgeCount) {
+			const timestamp = new Date().toISOString().slice(11, 19);
+			process.stdout.write(`[${timestamp}] 📬 Nudged ${agentName} (attempt ${nudgeCount})\n`);
+		},
+		onWarn(agentName, unreadSinceMs) {
+			const timestamp = new Date().toISOString().slice(11, 19);
+			const seconds = Math.round(unreadSinceMs / 1000);
+			process.stdout.write(`[${timestamp}] ⚠️  ${agentName} has had unread mail for ${seconds}s\n`);
+		},
+	});
+
+	process.on("SIGINT", () => {
+		stop();
+		removePidFile(pidFilePath).finally(() => {
+			process.stdout.write("\nWatchman stopped.\n");
+			process.exit(0);
+		});
+	});
+
+	// Block forever
+	await new Promise(() => {});
+}
+
+/** Handle `legio watchman stop` */
+async function handleStop(args: string[]): Promise<void> {
+	const json = hasFlag(args, "--json");
+	const cwd = process.cwd();
+	const config = await loadConfig(cwd);
+	const pidFilePath = join(config.project.root, ".legio", "watchman.pid");
+
+	const pid = await readPidFile(pidFilePath);
+
+	if (pid === null) {
+		if (json) {
+			process.stdout.write(`${JSON.stringify({ stopped: false, reason: "not running" })}\n`);
+		} else {
+			process.stdout.write("Watchman is not running (no PID file)\n");
+		}
+		return;
+	}
+
+	if (!isProcessRunning(pid)) {
+		await removePidFile(pidFilePath);
+		if (json) {
+			process.stdout.write(
+				`${JSON.stringify({ stopped: false, reason: "stale PID file cleaned" })}\n`,
+			);
+		} else {
+			process.stdout.write("Watchman is not running (stale PID file cleaned)\n");
+		}
+		return;
+	}
+
+	try {
+		process.kill(pid, "SIGTERM");
+	} catch {
+		// Process may have just exited
+	}
+
+	await removePidFile(pidFilePath);
+
+	if (json) {
+		process.stdout.write(`${JSON.stringify({ stopped: true, pid })}\n`);
+	} else {
+		process.stdout.write(`Watchman stopped (PID: ${pid})\n`);
+	}
+}
+
+/** Handle `legio watchman status` */
+async function handleStatus(args: string[]): Promise<void> {
+	const json = hasFlag(args, "--json");
+	const cwd = process.cwd();
+	const config = await loadConfig(cwd);
+	const pidFilePath = join(config.project.root, ".legio", "watchman.pid");
+
+	const pid = await readPidFile(pidFilePath);
+
+	if (pid === null) {
+		if (json) {
+			process.stdout.write(`${JSON.stringify({ running: false })}\n`);
+		} else {
+			process.stdout.write("Watchman: not running\n");
+		}
+		return;
+	}
+
+	const running = isProcessRunning(pid);
+
+	if (!running) {
+		await removePidFile(pidFilePath);
+	}
+
+	if (json) {
+		process.stdout.write(`${JSON.stringify({ running, pid: running ? pid : null })}\n`);
+	} else if (running) {
+		process.stdout.write(`Watchman: running (PID: ${pid})\n`);
+	} else {
+		process.stdout.write("Watchman: not running (stale PID file cleaned)\n");
+	}
+}
+
+const WATCHMAN_HELP = `legio watchman — Unified daemon (health + mail + beacon)
+
+Usage: legio watchman <subcommand> [options]
+
+Subcommands:
+  start                Start the watchman daemon
+    --background       Daemonize (run in background)
+    --interval <ms>    Health check interval in milliseconds (default: from config)
+  stop                 Stop the watchman daemon
+    --json             JSON output
+  status               Show watchman status
+    --json             JSON output
+
+Options:
+  --help, -h           Show this help
+
+The watchman daemon combines three capabilities:
+  1. Health monitoring: session health checks, zombie detection, auto-recovery
+  2. Mail delivery: polls for unread mail and nudges agents until they read it
+  3. Beacon safety net: detects stuck beacons and sends follow-up Enter`;
+
+export async function watchmanCommand(args: string[]): Promise<void> {
+	if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
+		process.stdout.write(`${WATCHMAN_HELP}\n`);
+		return;
+	}
+
+	const subcommand = args[0];
+	const subArgs = args.slice(1);
+
+	switch (subcommand) {
+		case "start":
+			await handleStart(subArgs);
+			break;
+		case "stop":
+			await handleStop(subArgs);
+			break;
+		case "status":
+			await handleStatus(subArgs);
+			break;
+		default:
+			process.stderr.write(
+				`Unknown watchman subcommand: ${subcommand ?? "(none)"}. Use: start, stop, status\n`,
+			);
+			process.exitCode = 1;
+	}
+}

package/src/commands/worktree.test.ts

@@ -2,7 +2,7 @@ import { spawn } from "node:child_process";
 import { existsSync, realpathSync } from "node:fs";
 import { access, mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { createSessionStore } from "../sessions/store.ts";
 import { cleanupTempDir, createTempGitRepo, runGitInDir } from "../test-helpers.ts";
 import type { AgentSession } from "../types.ts";
@@ -20,7 +20,6 @@ describe("worktreeCommand", () => {
 	let chunks: string[];
 	let originalWrite: typeof process.stdout.write;
 	let tempDir: string;
-	let originalCwd: string;
 
 	beforeEach(async () => {
 		// Spy on stdout
@@ -42,14 +41,11 @@ describe("worktreeCommand", () => {
 			`project:\n  name: test\n  root: ${tempDir}\n  canonicalBranch: main\n`,
 		);
 
-		// Change to temp dir so loadConfig() works
-		originalCwd = process.cwd();
-		process.chdir(tempDir);
+		vi.spyOn(process, "cwd").mockReturnValue(tempDir);
 	});
 
 	afterEach(async () => {
 		process.stdout.write = originalWrite;
-		process.chdir(originalCwd);
 		await cleanupTempDir(tempDir);
 	});
 

package/src/config.test.ts

@@ -1,10 +1,9 @@
-import { mkdir, mkdtemp, realpath, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
-import { DEFAULT_CONFIG, loadConfig, resolveProjectRoot } from "./config.ts";
+import { DEFAULT_CONFIG, loadConfig } from "./config.ts";
 import { ValidationError } from "./errors.ts";
-import { cleanupTempDir, createTempGitRepo, runGitInDir } from "./test-helpers.ts";
 
 describe("loadConfig", () => {
 	let tempDir: string;
@@ -33,7 +32,8 @@ describe("loadConfig", () => {
 		expect(config.project.canonicalBranch).toBe("main");
 		expect(config.agents.maxConcurrent).toBe(25);
 		expect(config.agents.maxDepth).toBe(2);
-		expect(config.beads.enabled).toBe(true);
+		expect(config.taskTracker.enabled).toBe(true);
+		expect(config.taskTracker.backend).toBe("auto");
 		expect(config.mulch.enabled).toBe(true);
 		expect(config.mulch.primeFormat).toBe("markdown");
 		expect(config.logging.verbose).toBe(false);
@@ -61,7 +61,7 @@ agents:
 		expect(config.agents.maxConcurrent).toBe(10);
 		// Non-overridden values keep defaults
 		expect(config.agents.maxDepth).toBe(2);
-		expect(config.beads.enabled).toBe(true);
+		expect(config.taskTracker.enabled).toBe(true);
 	});
 
 	test("always sets project.root to the actual projectRoot", async () => {
@@ -78,8 +78,9 @@ project:
 	test("parses boolean values correctly", async () => {
 		await ensureLegioDir();
 		await writeConfig(`
-beads:
+taskTracker:
   enabled: false
+  backend: beads
 mulch:
   enabled: true
 logging:
@@ -89,7 +90,8 @@ logging:
 
 		const config = await loadConfig(tempDir);
 
-		expect(config.beads.enabled).toBe(false);
+		expect(config.taskTracker.enabled).toBe(false);
+		expect(config.taskTracker.backend).toBe("beads");
 		expect(config.mulch.enabled).toBe(true);
 		expect(config.logging.verbose).toBe(true);
 		expect(config.logging.redactSecrets).toBe(false);
@@ -118,7 +120,7 @@ watchdog:
 
 		const config = await loadConfig(tempDir);
 		expect(config.agents.staggerDelayMs).toBe(5000);
-		expect(config.watchdog.tier0IntervalMs).toBe(60000);
+		expect(config.watchman.tier0IntervalMs).toBe(60000);
 	});
 
 	test("handles quoted string values", async () => {
@@ -202,9 +204,9 @@ watchdog:
 
 		const config = await loadConfig(tempDir);
 		// Local override
-		expect(config.watchdog.tier0Enabled).toBe(true);
+		expect(config.watchman.tier0Enabled).toBe(true);
 		// Non-overridden value from config.yaml preserved
-		expect(config.watchdog.zombieThresholdMs).toBe(120000);
+		expect(config.watchman.zombieThresholdMs).toBe(120000);
 	});
 
 	test("migrates deprecated watchdog tier1/tier2 keys to tier0/tier1", async () => {
@@ -218,10 +220,22 @@ watchdog:
 
 		const config = await loadConfig(tempDir);
 		// Old tier1 (mechanical daemon) → new tier0
-		expect(config.watchdog.tier0Enabled).toBe(true);
-		expect(config.watchdog.tier0IntervalMs).toBe(45000);
+		expect(config.watchman.tier0Enabled).toBe(true);
+		expect(config.watchman.tier0IntervalMs).toBe(45000);
 		// Old tier2 (AI triage) → new tier1
-		expect(config.watchdog.tier1Enabled).toBe(true);
+		expect(config.watchman.tier1Enabled).toBe(true);
+	});
+
+	test("migrates deprecated 'beads' key to taskTracker", async () => {
+		await ensureLegioDir();
+		await writeConfig(`
+beads:
+  enabled: false
+`);
+
+		const config = await loadConfig(tempDir);
+		expect(config.taskTracker.enabled).toBe(false);
+		expect(config.taskTracker.backend).toBe("auto");
 	});
 
 	test("new-style tier keys take precedence over deprecated keys", async () => {
@@ -235,9 +249,9 @@ watchdog:
 
 		const config = await loadConfig(tempDir);
 		// New keys used directly — no migration needed
-		expect(config.watchdog.tier0Enabled).toBe(false);
-		expect(config.watchdog.tier0IntervalMs).toBe(20000);
-		expect(config.watchdog.tier1Enabled).toBe(true);
+		expect(config.watchman.tier0Enabled).toBe(false);
+		expect(config.watchman.tier0IntervalMs).toBe(20000);
+		expect(config.watchman.tier1Enabled).toBe(true);
 	});
 });
 
@@ -336,99 +350,15 @@ models:
 	});
 });
 
-describe("resolveProjectRoot", () => {
-	let repoDir: string;
-
-	afterEach(async () => {
-		if (repoDir) {
-			// Remove worktrees before cleaning up
-			try {
-				await runGitInDir(repoDir, ["worktree", "prune"]);
-			} catch {
-				// Best effort
-			}
-			await cleanupTempDir(repoDir);
-		}
-	});
-
-	test("returns startDir when .legio/config.yaml exists there", async () => {
-		repoDir = await createTempGitRepo();
-		await mkdir(join(repoDir, ".legio"), { recursive: true });
-		await writeFile(join(repoDir, ".legio", "config.yaml"), "project:\n  canonicalBranch: main\n");
-
-		const result = await resolveProjectRoot(repoDir);
-		expect(result).toBe(repoDir);
-	});
-
-	test("resolves worktree to main project root", async () => {
-		repoDir = await createTempGitRepo();
-		// Resolve symlinks (macOS /var -> /private/var) to match git's output
-		repoDir = await realpath(repoDir);
-		await mkdir(join(repoDir, ".legio"), { recursive: true });
-		await writeFile(join(repoDir, ".legio", "config.yaml"), "project:\n  canonicalBranch: main\n");
-
-		// Create a worktree like legio sling does
-		const worktreeDir = join(repoDir, ".legio", "worktrees", "test-agent");
-		await mkdir(join(repoDir, ".legio", "worktrees"), { recursive: true });
-		await runGitInDir(repoDir, ["worktree", "add", "-b", "legio/test-agent/task-1", worktreeDir]);
-
-		// resolveProjectRoot from the worktree should return the main repo
-		const result = await resolveProjectRoot(worktreeDir);
-		expect(result).toBe(repoDir);
-	});
-
-	test("resolves worktree to main root even when config.yaml is committed (regression)", async () => {
-		repoDir = await createTempGitRepo();
-		repoDir = await realpath(repoDir);
-
-		// Commit .legio/config.yaml so the worktree gets a copy via git
-		// (this is what legio init does — the file is tracked)
-		await mkdir(join(repoDir, ".legio"), { recursive: true });
-		await writeFile(join(repoDir, ".legio", "config.yaml"), "project:\n  canonicalBranch: main\n");
-		await runGitInDir(repoDir, ["add", ".legio/config.yaml"]);
-		await runGitInDir(repoDir, ["commit", "-m", "add legio config"]);
-
-		// Create a worktree — it will now have .legio/config.yaml from git
-		const worktreeDir = join(repoDir, ".legio", "worktrees", "mail-scout");
-		await mkdir(join(repoDir, ".legio", "worktrees"), { recursive: true });
-		await runGitInDir(repoDir, ["worktree", "add", "-b", "legio/mail-scout/task-1", worktreeDir]);
-
-		// Must resolve to main repo root, NOT the worktree
-		// (even though worktree has its own .legio/config.yaml)
-		const result = await resolveProjectRoot(worktreeDir);
-		expect(result).toBe(repoDir);
-	});
-
-	test("loadConfig resolves correct root from worktree", async () => {
-		repoDir = await createTempGitRepo();
-		// Resolve symlinks (macOS /var -> /private/var) to match git's output
-		repoDir = await realpath(repoDir);
-		await mkdir(join(repoDir, ".legio"), { recursive: true });
-		await writeFile(
-			join(repoDir, ".legio", "config.yaml"),
-			"project:\n  canonicalBranch: develop\n",
-		);
-
-		const worktreeDir = join(repoDir, ".legio", "worktrees", "agent-2");
-		await mkdir(join(repoDir, ".legio", "worktrees"), { recursive: true });
-		await runGitInDir(repoDir, ["worktree", "add", "-b", "legio/agent-2/task-2", worktreeDir]);
-
-		// loadConfig from the worktree should resolve to the main project root
-		const config = await loadConfig(worktreeDir);
-		expect(config.project.root).toBe(repoDir);
-		expect(config.project.canonicalBranch).toBe("develop");
-	});
-});
-
 describe("DEFAULT_CONFIG", () => {
 	test("has all required top-level keys", () => {
 		expect(DEFAULT_CONFIG.project).toBeDefined();
 		expect(DEFAULT_CONFIG.agents).toBeDefined();
 		expect(DEFAULT_CONFIG.worktrees).toBeDefined();
-		expect(DEFAULT_CONFIG.beads).toBeDefined();
+		expect(DEFAULT_CONFIG.taskTracker).toBeDefined();
 		expect(DEFAULT_CONFIG.mulch).toBeDefined();
 		expect(DEFAULT_CONFIG.merge).toBeDefined();
-		expect(DEFAULT_CONFIG.watchdog).toBeDefined();
+		expect(DEFAULT_CONFIG.watchman).toBeDefined();
 		expect(DEFAULT_CONFIG.models).toBeDefined();
 		expect(DEFAULT_CONFIG.logging).toBeDefined();
 	});
@@ -438,8 +368,8 @@ describe("DEFAULT_CONFIG", () => {
 		expect(DEFAULT_CONFIG.agents.maxConcurrent).toBe(25);
 		expect(DEFAULT_CONFIG.agents.maxDepth).toBe(2);
 		expect(DEFAULT_CONFIG.agents.staggerDelayMs).toBe(2_000);
-		expect(DEFAULT_CONFIG.watchdog.tier0IntervalMs).toBe(30_000);
-		expect(DEFAULT_CONFIG.watchdog.zombieThresholdMs).toBe(600_000);
+		expect(DEFAULT_CONFIG.watchman.tier0IntervalMs).toBe(30_000);
+		expect(DEFAULT_CONFIG.watchman.zombieThresholdMs).toBe(600_000);
 	});
 
 	test("agents.maxAgentsPerLead defaults to 5", () => {