@os-eco/overstory-cli 0.9.1 → 0.9.2

package/src/doctor/dependencies.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import type { OverstoryConfig } from "../types.ts";
-import { checkDependencies } from "./dependencies.ts";
+import { checkAlias, checkDependencies, checkTool } from "./dependencies.ts";
 
 // Minimal config for testing
 const mockConfig: OverstoryConfig = {
@@ -237,3 +237,60 @@ describe("checkDependencies", () => {
 		expect(ovCheck?.category).toBe("dependencies");
 	});
 });
+
+describe("checkTool", () => {
+	test("git with --version passes", async () => {
+		const check = await checkTool("git", "--version", true);
+		expect(check.name).toBe("git availability");
+		expect(check.category).toBe("dependencies");
+		expect(check.status).toBe("pass");
+		expect(check.message).toContain("git");
+		expect(check.details).toBeArray();
+		expect(check.details?.length).toBeGreaterThan(0);
+	});
+
+	test("nonexistent tool with required: true returns fail", async () => {
+		const check = await checkTool("nonexistent-tool-xyz-999", "--version", true);
+		expect(check.status).toBe("fail");
+		expect(check.message).toContain("nonexistent-tool-xyz-999");
+		expect(check.fixable).toBe(true);
+	});
+
+	test("nonexistent tool with required: false returns warn", async () => {
+		const check = await checkTool("nonexistent-tool-xyz-999", "--version", false);
+		expect(check.status).toBe("warn");
+		expect(check.fixable).toBe(true);
+	});
+
+	test("installHint appears in details for missing tool", async () => {
+		const check = await checkTool("nonexistent-tool-xyz-999", "--version", true, "@test/fake-pkg");
+		expect(check.status).toBe("fail");
+		const detailsText = check.details?.join(" ") ?? "";
+		expect(detailsText).toContain("npm install -g @test/fake-pkg");
+	});
+});
+
+describe("checkAlias", () => {
+	test("real tool alias passes", async () => {
+		// git is universally available — use it as a "real alias"
+		const check = await checkAlias("git-tool", "git");
+		expect(check.name).toBe("git alias");
+		expect(check.category).toBe("dependencies");
+		expect(check.status).toBe("pass");
+		expect(check.message).toContain("git");
+	});
+
+	test("nonexistent alias returns warn", async () => {
+		const check = await checkAlias("some-tool", "nonexistent-alias-xyz-999");
+		expect(check.status).toBe("warn");
+		expect(check.name).toBe("nonexistent-alias-xyz-999 alias");
+		expect(check.fixable).toBe(true);
+	});
+
+	test("nonexistent alias with installHint includes hint in details", async () => {
+		const check = await checkAlias("some-tool", "nonexistent-alias-xyz-999", "@test/fake-pkg");
+		expect(check.status).toBe("warn");
+		const detailsText = check.details?.join(" ") ?? "";
+		expect(detailsText).toContain("@test/fake-pkg");
+	});
+});

package/src/doctor/dependencies.ts

@@ -157,8 +157,9 @@ async function checkBdCgoSupport(): Promise<DoctorCheck> {
 
 /**
  * Check if a short alias for a CLI tool is available.
+ * @internal Exported for testing.
  */
-async function checkAlias(
+export async function checkAlias(
 	toolName: string,
 	alias: string,
 	installHint?: string,
@@ -208,8 +209,9 @@ async function checkAlias(
 
 /**
  * Check if a CLI tool is available by attempting to run it with a version flag.
+ * @internal Exported for testing.
  */
-async function checkTool(
+export async function checkTool(
 	name: string,
 	versionFlag: string,
 	required: boolean,

package/src/doctor/providers.test.ts

@@ -104,7 +104,7 @@ describe("checkProviders", () => {
 			const config = makeConfig({
 				providers: {
 					anthropic: { type: "native" },
-					openrouter: { type: "gateway", baseUrl: "https://openrouter.ai/api/v1" },
+					openrouter: { type: "gateway", baseUrl: "http://127.0.0.1:19873" },
 				},
 			});
 			const checks = await checkProviders(config, OVERSTORY_DIR);
@@ -241,11 +241,29 @@ describe("checkProviders", () => {
 	});
 
 	describe("tool-use-compat check", () => {
+		// Local HTTP server to avoid network calls to real openrouter.ai
+		let localServer: ReturnType<typeof Bun.serve>;
+		let localBaseUrl: string;
+
+		beforeAll(() => {
+			localServer = Bun.serve({
+				port: 0,
+				fetch() {
+					return new Response("ok");
+				},
+			});
+			localBaseUrl = `http://127.0.0.1:${localServer.port}`;
+		});
+
+		afterAll(async () => {
+			await localServer.stop();
+		});
+
 		test("tool-heavy role with provider-prefixed model warns", async () => {
 			const config = makeConfig({
 				models: { builder: "openrouter/openai/gpt-4o" },
 				providers: {
-					openrouter: { type: "gateway", baseUrl: "https://openrouter.ai/api/v1" },
+					openrouter: { type: "gateway", baseUrl: localBaseUrl },
 				},
 			});
 			const checks = await checkProviders(config, OVERSTORY_DIR);
@@ -260,7 +278,7 @@ describe("checkProviders", () => {
 			const config = makeConfig({
 				models: { lead: "openrouter/openai/gpt-4o" },
 				providers: {
-					openrouter: { type: "gateway", baseUrl: "https://openrouter.ai/api/v1" },
+					openrouter: { type: "gateway", baseUrl: localBaseUrl },
 				},
 			});
 			const checks = await checkProviders(config, OVERSTORY_DIR);
@@ -287,7 +305,7 @@ describe("checkProviders", () => {
 					merger: "openrouter/openai/gpt-4o",
 				},
 				providers: {
-					openrouter: { type: "gateway", baseUrl: "https://openrouter.ai/api/v1" },
+					openrouter: { type: "gateway", baseUrl: localBaseUrl },
 				},
 			});
 			const checks = await checkProviders(config, OVERSTORY_DIR);
@@ -298,6 +316,24 @@ describe("checkProviders", () => {
 	});
 
 	describe("model-provider-ref(s) check", () => {
+		// Local HTTP server to avoid network calls to real openrouter.ai
+		let localServer: ReturnType<typeof Bun.serve>;
+		let localBaseUrl: string;
+
+		beforeAll(() => {
+			localServer = Bun.serve({
+				port: 0,
+				fetch() {
+					return new Response("ok");
+				},
+			});
+			localBaseUrl = `http://127.0.0.1:${localServer.port}`;
+		});
+
+		afterAll(async () => {
+			await localServer.stop();
+		});
+
 		test("model referencing unknown provider fails", async () => {
 			const config = makeConfig({
 				models: { builder: "unknownprovider/some-model" },
@@ -315,7 +351,7 @@ describe("checkProviders", () => {
 			const config = makeConfig({
 				models: { builder: "openrouter/openai/gpt-4o" },
 				providers: {
-					openrouter: { type: "gateway", baseUrl: "https://openrouter.ai/api/v1" },
+					openrouter: { type: "gateway", baseUrl: localBaseUrl },
 				},
 			});
 			const checks = await checkProviders(config, OVERSTORY_DIR);

package/src/doctor/types.ts

@@ -14,7 +14,8 @@ export type DoctorCategory =
 	| "logs"
 	| "version"
 	| "ecosystem"
-	| "providers";
+	| "providers"
+	| "watchdog";
 
 /** Result of a single doctor health check. */
 export interface DoctorCheck {

package/src/doctor/version.test.ts

@@ -1,6 +1,10 @@
-import { describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { cleanupTempDir } from "../test-helpers.ts";
 import type { OverstoryConfig } from "../types.ts";
-import { checkVersion } from "./version.ts";
+import { checkCurrentVersion, checkVersion, checkVersionSync } from "./version.ts";
 
 // Minimal config for testing
 const mockConfig: OverstoryConfig = {
@@ -135,3 +139,103 @@ describe("checkVersion", () => {
 		}
 	});
 });
+
+describe("checkCurrentVersion", () => {
+	test("passes against real repo root", async () => {
+		// Use the real overstory repo root (two levels up from src/doctor/)
+		const toolRoot = join(import.meta.dir, "..", "..");
+		const check = await checkCurrentVersion(toolRoot);
+		expect(check.name).toBe("version-current");
+		expect(check.category).toBe("version");
+		expect(check.status).toBe("pass");
+		expect(check.message).toMatch(/ov v\d+\.\d+\.\d+/);
+	});
+
+	test("fails for temp dir without version field", async () => {
+		const tempDir = await mkdtemp(join(tmpdir(), "version-test-"));
+		try {
+			// Write a package.json without a version field
+			await Bun.write(join(tempDir, "package.json"), JSON.stringify({ name: "test" }));
+			const check = await checkCurrentVersion(tempDir);
+			expect(check.name).toBe("version-current");
+			expect(check.status).toBe("fail");
+			expect(check.message).toContain("no version field");
+		} finally {
+			await cleanupTempDir(tempDir);
+		}
+	});
+
+	test("fails for temp dir without package.json", async () => {
+		const tempDir = await mkdtemp(join(tmpdir(), "version-test-"));
+		try {
+			const check = await checkCurrentVersion(tempDir);
+			expect(check.name).toBe("version-current");
+			expect(check.status).toBe("fail");
+		} finally {
+			await cleanupTempDir(tempDir);
+		}
+	});
+});
+
+describe("checkVersionSync", () => {
+	let tempDir: string;
+
+	beforeEach(async () => {
+		tempDir = await mkdtemp(join(tmpdir(), "version-sync-test-"));
+	});
+
+	afterEach(async () => {
+		await cleanupTempDir(tempDir);
+	});
+
+	test("passes when versions match", async () => {
+		await Bun.write(
+			join(tempDir, "package.json"),
+			JSON.stringify({ name: "test", version: "1.2.3" }),
+		);
+		const { mkdir } = await import("node:fs/promises");
+		await mkdir(join(tempDir, "src"), { recursive: true });
+		await Bun.write(
+			join(tempDir, "src", "index.ts"),
+			'const VERSION = "1.2.3";\nexport { VERSION };\n',
+		);
+
+		const check = await checkVersionSync(tempDir);
+		expect(check.name).toBe("package-json-sync");
+		expect(check.category).toBe("version");
+		expect(check.status).toBe("pass");
+		expect(check.message).toContain("synchronized");
+		expect(check.details?.join(" ")).toContain("1.2.3");
+	});
+
+	test("warns when versions mismatch", async () => {
+		await Bun.write(
+			join(tempDir, "package.json"),
+			JSON.stringify({ name: "test", version: "1.0.0" }),
+		);
+		const { mkdir } = await import("node:fs/promises");
+		await mkdir(join(tempDir, "src"), { recursive: true });
+		await Bun.write(
+			join(tempDir, "src", "index.ts"),
+			'const VERSION = "2.0.0";\nexport { VERSION };\n',
+		);
+
+		const check = await checkVersionSync(tempDir);
+		expect(check.name).toBe("package-json-sync");
+		expect(check.status).toBe("warn");
+		expect(check.message).toContain("mismatch");
+		expect(check.fixable).toBe(true);
+	});
+
+	test("warns when src/index.ts is missing", async () => {
+		await Bun.write(
+			join(tempDir, "package.json"),
+			JSON.stringify({ name: "test", version: "1.0.0" }),
+		);
+		// No src/index.ts created
+
+		const check = await checkVersionSync(tempDir);
+		expect(check.name).toBe("package-json-sync");
+		expect(check.status).toBe("warn");
+	});
+});

package/src/doctor/version.ts

@@ -28,8 +28,9 @@ export const checkVersion: DoctorCheckFn = async (
 
 /**
  * Check that the current version can be determined from package.json.
+ * @internal Exported for testing.
  */
-async function checkCurrentVersion(toolRoot: string): Promise<DoctorCheck> {
+export async function checkCurrentVersion(toolRoot: string): Promise<DoctorCheck> {
 	try {
 		const packageJsonPath = join(toolRoot, "package.json");
 		const packageJson = (await Bun.file(packageJsonPath).json()) as { version?: string };
@@ -62,8 +63,9 @@ async function checkCurrentVersion(toolRoot: string): Promise<DoctorCheck> {
 
 /**
  * Check that package.json version matches src/index.ts VERSION constant.
+ * @internal Exported for testing.
  */
-async function checkVersionSync(toolRoot: string): Promise<DoctorCheck> {
+export async function checkVersionSync(toolRoot: string): Promise<DoctorCheck> {
 	try {
 		// Read package.json version
 		const packageJsonPath = join(toolRoot, "package.json");

package/src/doctor/watchdog.test.ts

@@ -0,0 +1,167 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { utimes } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { OverstoryConfig } from "../types.ts";
+import { checkWatchdog } from "./watchdog.ts";
+
+describe("checkWatchdog", () => {
+	let tempDir: string;
+	let mockConfig: OverstoryConfig;
+
+	beforeEach(() => {
+		tempDir = mkdtempSync(join(tmpdir(), "overstory-watchdog-test-"));
+		mockConfig = {
+			project: { name: "test", root: tempDir, canonicalBranch: "main" },
+			agents: {
+				manifestPath: "",
+				baseDir: "",
+				maxConcurrent: 5,
+				staggerDelayMs: 100,
+				maxDepth: 2,
+				maxSessionsPerRun: 0,
+				maxAgentsPerLead: 5,
+			},
+			worktrees: { baseDir: "" },
+			taskTracker: { backend: "auto", enabled: true },
+			mulch: { enabled: true, domains: [], primeFormat: "markdown" },
+			merge: { aiResolveEnabled: false, reimagineEnabled: false },
+			providers: {
+				anthropic: { type: "native" },
+			},
+			watchdog: {
+				tier0Enabled: true,
+				tier0IntervalMs: 30000,
+				tier1Enabled: false,
+				tier2Enabled: false,
+				staleThresholdMs: 300000,
+				zombieThresholdMs: 600000,
+				nudgeIntervalMs: 60000,
+			},
+			models: {},
+			logging: { verbose: false, redactSecrets: true },
+		};
+	});
+
+	afterEach(() => {
+		rmSync(tempDir, { recursive: true, force: true });
+	});
+
+	test("all checks skip when tier0Enabled is false — returns single pass check", async () => {
+		mockConfig.watchdog.tier0Enabled = false;
+		const checks = await checkWatchdog(mockConfig, tempDir);
+
+		expect(checks).toHaveLength(1);
+		expect(checks[0]?.status).toBe("pass");
+		expect(checks[0]?.message).toContain("disabled");
+	});
+
+	test("PID file missing — returns warn about daemon not running", async () => {
+		const checks = await checkWatchdog(mockConfig, tempDir);
+
+		const pidCheck = checks.find((c) => c.name === "watchdog pid file");
+		expect(pidCheck).toBeDefined();
+		expect(pidCheck?.status).toBe("warn");
+		expect(pidCheck?.message).toContain("PID file not found");
+	});
+
+	test("PID file corrupted — returns fail with fixable", async () => {
+		writeFileSync(join(tempDir, "watchdog.pid"), "not-a-pid");
+		const checks = await checkWatchdog(mockConfig, tempDir);
+
+		const integrityCheck = checks.find((c) => c.name === "watchdog pid integrity");
+		expect(integrityCheck).toBeDefined();
+		expect(integrityCheck?.status).toBe("fail");
+		expect(integrityCheck?.fixable).toBe(true);
+		expect(integrityCheck?.details?.some((d) => d.includes("not-a-pid"))).toBe(true);
+	});
+
+	test("PID file with valid PID but process not running — returns warn (stale PID)", async () => {
+		// PID 999999999 is extremely unlikely to exist
+		writeFileSync(join(tempDir, "watchdog.pid"), "999999999");
+		const checks = await checkWatchdog(mockConfig, tempDir);
+
+		const processCheck = checks.find((c) => c.name === "watchdog process");
+		expect(processCheck).toBeDefined();
+		expect(processCheck?.status).toBe("warn");
+		expect(processCheck?.message).toContain("stale PID file");
+		expect(processCheck?.fixable).toBe(true);
+	});
+
+	test("PID file with current process PID — returns pass", async () => {
+		writeFileSync(join(tempDir, "watchdog.pid"), String(process.pid));
+		const checks = await checkWatchdog(mockConfig, tempDir);
+
+		const processCheck = checks.find((c) => c.name === "watchdog process");
+		expect(processCheck).toBeDefined();
+		expect(processCheck?.status).toBe("pass");
+		expect(processCheck?.message).toContain("running");
+	});
+
+	test("PID file older than 24 hours — returns staleness warn", async () => {
+		const pidFile = join(tempDir, "watchdog.pid");
+		writeFileSync(pidFile, String(process.pid));
+
+		// Set mtime 25 hours ago
+		const twentyFiveHoursAgo = new Date(Date.now() - 25 * 60 * 60 * 1000);
+		await utimes(pidFile, twentyFiveHoursAgo, twentyFiveHoursAgo);
+
+		const checks = await checkWatchdog(mockConfig, tempDir);
+
+		const stalenessCheck = checks.find((c) => c.name === "watchdog pid staleness");
+		expect(stalenessCheck).toBeDefined();
+		expect(stalenessCheck?.status).toBe("warn");
+		expect(stalenessCheck?.message).toContain("older than 24 hours");
+		expect(stalenessCheck?.details?.some((d) => d.includes("hours"))).toBe(true);
+	});
+
+	test("Tier 2 monitor check skipped when tier2Enabled=false — no monitor check in results", async () => {
+		mockConfig.watchdog.tier2Enabled = false;
+		writeFileSync(join(tempDir, "watchdog.pid"), String(process.pid));
+		const checks = await checkWatchdog(mockConfig, tempDir);
+
+		const monitorCheck = checks.find((c) => c.name === "tier2 monitor");
+		expect(monitorCheck).toBeUndefined();
+	});
+
+	test("Tier 1 triage check skipped when tier1Enabled=false — no triage check in results", async () => {
+		mockConfig.watchdog.tier1Enabled = false;
+		writeFileSync(join(tempDir, "watchdog.pid"), String(process.pid));
+		const checks = await checkWatchdog(mockConfig, tempDir);
+
+		const triageCheck = checks.find((c) => c.name === "tier1 triage");
+		expect(triageCheck).toBeUndefined();
+	});
+
+	test("Tier 2 monitor check warns when no monitor session found", async () => {
+		mockConfig.watchdog.tier2Enabled = true;
+		writeFileSync(join(tempDir, "watchdog.pid"), String(process.pid));
+		// No sessions.db or sessions.json — openSessionStore creates empty DB
+		const checks = await checkWatchdog(mockConfig, tempDir);
+
+		const monitorCheck = checks.find((c) => c.name === "tier2 monitor");
+		expect(monitorCheck).toBeDefined();
+		// Either warns about not running or store unavailable — both are acceptable
+		expect(monitorCheck?.status).toBe("warn");
+	});
+
+	test("Tier 1 triage check does not crash when enabled", async () => {
+		mockConfig.watchdog.tier1Enabled = true;
+		writeFileSync(join(tempDir, "watchdog.pid"), String(process.pid));
+		// getRuntime will succeed (defaults to "claude" which is always registered)
+		let checks: Awaited<ReturnType<typeof checkWatchdog>>;
+		try {
+			checks = await checkWatchdog(mockConfig, tempDir);
+		} catch {
+			// Should not throw
+			expect(false).toBe(true);
+			return;
+		}
+
+		const triageCheck = checks.find((c) => c.name === "tier1 triage");
+		expect(triageCheck).toBeDefined();
+		// Either pass or warn — depending on environment; it should not throw
+		expect(triageCheck?.status === "pass" || triageCheck?.status === "warn").toBe(true);
+	});
+});

package/src/doctor/watchdog.ts

@@ -0,0 +1,158 @@
+import { existsSync } from "node:fs";
+import { stat, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { getRuntime } from "../runtimes/registry.ts";
+import { openSessionStore } from "../sessions/compat.ts";
+import { isProcessRunning } from "../watchdog/health.ts";
+import type { DoctorCheck, DoctorCheckFn } from "./types.ts";
+
+/**
+ * Watchdog subsystem health checks.
+ * Validates PID file integrity, process liveness, and tier availability.
+ */
+export const checkWatchdog: DoctorCheckFn = async (
+	config,
+	overstoryDir,
+): Promise<DoctorCheck[]> => {
+	const checks: DoctorCheck[] = [];
+
+	// If tier0 is disabled, skip all checks with a single pass result
+	if (!config.watchdog.tier0Enabled) {
+		checks.push({
+			name: "watchdog disabled",
+			category: "watchdog",
+			status: "pass",
+			message: "Watchdog daemon is disabled (tier0Enabled: false)",
+		});
+		return checks;
+	}
+
+	const pidFilePath = join(overstoryDir, "watchdog.pid");
+
+	// Check 1: PID file exists and is readable
+	if (!existsSync(pidFilePath)) {
+		checks.push({
+			name: "watchdog pid file",
+			category: "watchdog",
+			status: "warn",
+			message: "Watchdog PID file not found — daemon may not be running",
+		});
+	} else {
+		// Check 2: PID file not corrupted
+		const pidText = await Bun.file(pidFilePath).text();
+		const pid = Number.parseInt(pidText.trim(), 10);
+
+		if (Number.isNaN(pid) || pid <= 0) {
+			checks.push({
+				name: "watchdog pid integrity",
+				category: "watchdog",
+				status: "fail",
+				message: "Watchdog PID file is corrupted",
+				details: [`Raw content: ${pidText.trim()}`],
+				fixable: true,
+				fix: async () => {
+					await unlink(pidFilePath);
+					return ["Removed corrupted watchdog PID file"];
+				},
+			});
+		} else {
+			// Check 3: PID alive via isProcessRunning()
+			const alive = isProcessRunning(pid);
+			if (!alive) {
+				checks.push({
+					name: "watchdog process",
+					category: "watchdog",
+					status: "warn",
+					message: "Watchdog process is not running (stale PID file)",
+					details: [`PID: ${pid}`],
+					fixable: true,
+					fix: async () => {
+						await unlink(pidFilePath);
+						return ["Removed stale watchdog PID file"];
+					},
+				});
+			} else {
+				checks.push({
+					name: "watchdog process",
+					category: "watchdog",
+					status: "pass",
+					message: "Watchdog daemon is running",
+				});
+			}
+
+			// Check 4: PID file staleness > 24h
+			const fileStat = await stat(pidFilePath);
+			const ageMs = Date.now() - fileStat.mtimeMs;
+			const twentyFourHoursMs = 24 * 60 * 60 * 1000;
+			if (ageMs > twentyFourHoursMs) {
+				const ageHours = Math.round(ageMs / (1000 * 60 * 60));
+				checks.push({
+					name: "watchdog pid staleness",
+					category: "watchdog",
+					status: "warn",
+					message: "Watchdog PID file is older than 24 hours",
+					details: [`File age: ${ageHours} hours`],
+				});
+			}
+		}
+	}
+
+	// Check 5: Tier 2 monitor running if tier2Enabled
+	if (config.watchdog.tier2Enabled) {
+		try {
+			const { store } = openSessionStore(overstoryDir);
+			try {
+				const sessions = store.getAll();
+				const monitorActive = sessions.some(
+					(s) => s.capability === "monitor" && s.state !== "completed" && s.state !== "zombie",
+				);
+				if (!monitorActive) {
+					checks.push({
+						name: "tier2 monitor",
+						category: "watchdog",
+						status: "warn",
+						message: "Tier 2 monitor is enabled but not running",
+					});
+				} else {
+					checks.push({
+						name: "tier2 monitor",
+						category: "watchdog",
+						status: "pass",
+						message: "Tier 2 monitor agent is active",
+					});
+				}
+			} finally {
+				store.close();
+			}
+		} catch {
+			checks.push({
+				name: "tier2 monitor",
+				category: "watchdog",
+				status: "warn",
+				message: "Tier 2 monitor check skipped — session store unavailable",
+			});
+		}
+	}
+
+	// Check 6: Tier 1 triage available if tier1Enabled
+	if (config.watchdog.tier1Enabled) {
+		try {
+			getRuntime(config?.runtime?.printCommand ?? config?.runtime?.default, config);
+			checks.push({
+				name: "tier1 triage",
+				category: "watchdog",
+				status: "pass",
+				message: "Tier 1 triage runtime is available",
+			});
+		} catch {
+			checks.push({
+				name: "tier1 triage",
+				category: "watchdog",
+				status: "warn",
+				message: "Tier 1 triage is enabled but runtime is not available",
+			});
+		}
+	}
+
+	return checks;
+};

package/src/e2e/init-sling-lifecycle.test.ts

@@ -124,7 +124,7 @@ describe("E2E: init→sling lifecycle on external project", () => {
 
 		const manifest = await loader.load();
 
-		// All 7 agents present (supervisor removed: deprecated, use lead instead)
+		// All 8 agents present (supervisor removed: deprecated, use lead instead)
 		const agentNames = Object.keys(manifest.agents).sort();
 		expect(agentNames).toEqual([
 			"builder",
@@ -132,6 +132,7 @@ describe("E2E: init→sling lifecycle on external project", () => {
 			"lead",
 			"merger",
 			"monitor",
+			"orchestrator",
 			"reviewer",
 			"scout",
 		]);