@os-eco/overstory-cli 0.6.9 → 0.6.10

package/src/commands/sling.ts

@@ -561,7 +561,7 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 		}
 
 		// 9. Deploy hooks config (capability-specific guards)
-		await deployHooks(worktreePath, name, capability);
+		await deployHooks(worktreePath, name, capability, config.project.qualityGates);
 
 		// 9b. Send auto-dispatch mail so it exists when SessionStart hook fires.
 		// This eliminates the race where coordinator sends dispatch AFTER agent boots.

package/src/commands/upgrade.test.ts

@@ -0,0 +1,46 @@
+/**
+ * Tests for the ov upgrade command.
+ *
+ * Structural tests for CLI registration and option parsing.
+ * Network calls and subprocess execution happen via real implementations;
+ * this file tests command structure and output format rather than side effects.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { createUpgradeCommand } from "./upgrade.ts";
+
+describe("createUpgradeCommand — CLI structure", () => {
+	test("command has correct name", () => {
+		const cmd = createUpgradeCommand();
+		expect(cmd.name()).toBe("upgrade");
+	});
+
+	test("description mentions overstory", () => {
+		const cmd = createUpgradeCommand();
+		expect(cmd.description().toLowerCase()).toContain("overstory");
+	});
+
+	test("has --check option", () => {
+		const cmd = createUpgradeCommand();
+		const optionNames = cmd.options.map((o) => o.long);
+		expect(optionNames).toContain("--check");
+	});
+
+	test("has --json option", () => {
+		const cmd = createUpgradeCommand();
+		const optionNames = cmd.options.map((o) => o.long);
+		expect(optionNames).toContain("--json");
+	});
+
+	test("has --all option", () => {
+		const cmd = createUpgradeCommand();
+		const optionNames = cmd.options.map((o) => o.long);
+		expect(optionNames).toContain("--all");
+	});
+
+	test("returns a Command instance", () => {
+		const cmd = createUpgradeCommand();
+		// Commander Command instances have a .parse method
+		expect(typeof cmd.parse).toBe("function");
+	});
+});

package/src/commands/upgrade.ts

@@ -0,0 +1,259 @@
+/**
+ * CLI command: ov upgrade [--check] [--all] [--json]
+ *
+ * Upgrades overstory (and optionally all os-eco tools) to their latest npm versions.
+ * --check: Compare current vs latest without installing.
+ * --all:   Upgrade all 4 ecosystem tools (overstory, mulch, seeds, canopy).
+ * --json:  Output result as JSON envelope.
+ */
+
+import { Command } from "commander";
+import { jsonError, jsonOutput } from "../json.ts";
+import { muted, printError, printHint, printSuccess, printWarning } from "../logging/color.ts";
+
+const OVERSTORY_PACKAGE = "@os-eco/overstory-cli";
+
+const ALL_PACKAGES = [
+	"@os-eco/overstory-cli",
+	"@os-eco/mulch-cli",
+	"@os-eco/seeds-cli",
+	"@os-eco/canopy-cli",
+] as const;
+
+export interface UpgradeOptions {
+	check?: boolean;
+	all?: boolean;
+	json?: boolean;
+}
+
+async function getCurrentVersion(): Promise<string> {
+	const pkgPath = new URL("../../package.json", import.meta.url);
+	const pkg = JSON.parse(await Bun.file(pkgPath).text()) as { version: string };
+	return pkg.version;
+}
+
+async function fetchLatestVersion(packageName: string): Promise<string> {
+	const res = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
+	if (!res.ok) {
+		throw new Error(
+			`Failed to fetch npm registry for ${packageName}: ${res.status} ${res.statusText}`,
+		);
+	}
+	const data = (await res.json()) as { version: string };
+	return data.version;
+}
+
+async function runInstall(packageName: string): Promise<number> {
+	const proc = Bun.spawn(["bun", "install", "-g", `${packageName}@latest`], {
+		stdout: "inherit",
+		stderr: "inherit",
+	});
+	return proc.exited;
+}
+
+interface PackageResult {
+	package: string;
+	current: string;
+	latest: string;
+	upToDate: boolean;
+	updated: boolean;
+	error?: string;
+}
+
+async function upgradePackage(packageName: string): Promise<PackageResult> {
+	let latest: string;
+	try {
+		latest = await fetchLatestVersion(packageName);
+	} catch (err) {
+		const error = err instanceof Error ? err.message : String(err);
+		return {
+			package: packageName,
+			current: "unknown",
+			latest: "unknown",
+			upToDate: false,
+			updated: false,
+			error,
+		};
+	}
+
+	const exitCode = await runInstall(packageName);
+	if (exitCode !== 0) {
+		return {
+			package: packageName,
+			current: "unknown",
+			latest,
+			upToDate: false,
+			updated: false,
+			error: `bun install failed with exit code ${exitCode}`,
+		};
+	}
+	return { package: packageName, current: "unknown", latest, upToDate: false, updated: true };
+}
+
+async function executeUpgradeSingle(opts: UpgradeOptions): Promise<void> {
+	const json = opts.json ?? false;
+	const checkOnly = opts.check ?? false;
+
+	let current: string;
+	let latest: string;
+	try {
+		[current, latest] = await Promise.all([
+			getCurrentVersion(),
+			fetchLatestVersion(OVERSTORY_PACKAGE),
+		]);
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		if (json) {
+			jsonError("upgrade", msg);
+		} else {
+			printError("Failed to check for updates", msg);
+		}
+		process.exitCode = 1;
+		return;
+	}
+
+	const upToDate = current === latest;
+
+	if (checkOnly) {
+		if (json) {
+			jsonOutput("upgrade", { current, latest, upToDate });
+		} else if (upToDate) {
+			printSuccess("Already up to date", current);
+		} else {
+			printWarning(`Update available: ${current} → ${latest}`);
+			printHint("Run 'ov upgrade' to install the latest version");
+			process.exitCode = 1;
+		}
+		return;
+	}
+
+	if (upToDate) {
+		if (json) {
+			jsonOutput("upgrade", { current, latest, upToDate: true, updated: false });
+		} else {
+			printSuccess("Already up to date", current);
+		}
+		return;
+	}
+
+	if (!json) {
+		process.stdout.write(
+			`${muted(`Upgrading ${OVERSTORY_PACKAGE} from ${current} to ${latest}...`)}\n`,
+		);
+	}
+
+	const exitCode = await runInstall(OVERSTORY_PACKAGE);
+
+	if (exitCode !== 0) {
+		if (json) {
+			jsonError("upgrade", `bun install failed with exit code ${exitCode}`);
+		} else {
+			printError("Upgrade failed", `bun install exited with code ${exitCode}`);
+		}
+		process.exitCode = 1;
+		return;
+	}
+
+	if (json) {
+		jsonOutput("upgrade", { current, latest, upToDate: false, updated: true });
+	} else {
+		printSuccess("Upgraded to", latest);
+	}
+}
+
+async function executeUpgradeAll(opts: UpgradeOptions): Promise<void> {
+	const json = opts.json ?? false;
+	const checkOnly = opts.check ?? false;
+
+	// Fetch all latest versions in parallel
+	const latestResults = await Promise.allSettled(
+		ALL_PACKAGES.map((pkg) => fetchLatestVersion(pkg)),
+	);
+
+	if (checkOnly) {
+		// For --check --all, we just report status without installing
+		const results: Array<{ package: string; latest: string; error?: string }> = [];
+		let anyOutdated = false;
+
+		for (let i = 0; i < ALL_PACKAGES.length; i++) {
+			const pkg = ALL_PACKAGES[i] as string;
+			const result = latestResults[i];
+			if (result === undefined || result.status === "rejected") {
+				const error =
+					result?.status === "rejected"
+						? result.reason instanceof Error
+							? result.reason.message
+							: String(result.reason)
+						: "unknown error";
+				results.push({ package: pkg, latest: "unknown", error });
+				anyOutdated = true;
+			} else {
+				results.push({ package: pkg, latest: result.value });
+				// We can't easily get current versions for all tools without spawning them
+				// so for --all --check we just report latest versions available
+			}
+		}
+
+		if (json) {
+			jsonOutput("upgrade", { packages: results });
+		} else {
+			for (const r of results) {
+				if (r.error) {
+					printError(`${r.package}`, r.error);
+				} else {
+					process.stdout.write(`  ${r.package} → ${r.latest}\n`);
+				}
+			}
+			if (anyOutdated) process.exitCode = 1;
+		}
+		return;
+	}
+
+	// Install all packages
+	if (!json) {
+		process.stdout.write(`${muted("Upgrading all os-eco tools to latest...")}\n`);
+	}
+
+	const results: PackageResult[] = await Promise.all(
+		ALL_PACKAGES.map((pkg) => upgradePackage(pkg)),
+	);
+
+	const anyError = results.some((r) => r.error !== undefined);
+
+	if (json) {
+		if (anyError) {
+			jsonError("upgrade", `One or more packages failed to upgrade`);
+		} else {
+			jsonOutput("upgrade", { packages: results, updated: true });
+		}
+	} else {
+		for (const r of results) {
+			if (r.error) {
+				printError(`Failed to upgrade ${r.package}`, r.error);
+			} else {
+				printSuccess(`Upgraded ${r.package} to`, r.latest);
+			}
+		}
+	}
+
+	if (anyError) process.exitCode = 1;
+}
+
+export async function executeUpgrade(opts: UpgradeOptions): Promise<void> {
+	if (opts.all) {
+		await executeUpgradeAll(opts);
+	} else {
+		await executeUpgradeSingle(opts);
+	}
+}
+
+export function createUpgradeCommand(): Command {
+	return new Command("upgrade")
+		.description("Upgrade overstory to the latest version from npm")
+		.option("--check", "Check for updates without installing")
+		.option("--all", "Upgrade all os-eco ecosystem tools")
+		.option("--json", "Output as JSON")
+		.action(async (opts: UpgradeOptions) => {
+			await executeUpgrade(opts);
+		});
+}

package/src/doctor/databases.test.ts

@@ -307,4 +307,42 @@ describe("checkDatabases", () => {
 		expect(integrityCheck?.status).toBe("fail");
 		expect(integrityCheck?.message).toContain("Failed to open or validate");
 	});
+
+	test("fix() enables WAL mode on database", () => {
+		// Create mail.db without WAL mode
+		const mailDb = new Database(join(tempDir, "mail.db"));
+		mailDb.exec(`
+			CREATE TABLE messages (
+				id TEXT PRIMARY KEY,
+				from_agent TEXT NOT NULL,
+				to_agent TEXT NOT NULL,
+				subject TEXT NOT NULL,
+				body TEXT NOT NULL,
+				type TEXT NOT NULL DEFAULT 'status',
+				priority TEXT NOT NULL DEFAULT 'normal',
+				thread_id TEXT,
+				payload TEXT,
+				read INTEGER NOT NULL DEFAULT 0,
+				created_at TEXT NOT NULL DEFAULT (datetime('now'))
+			)
+		`);
+		mailDb.close();
+
+		const checks = checkDatabases(mockConfig, tempDir) as DoctorCheck[];
+
+		const walCheck = checks.find((c) => c?.name === "mail.db WAL mode");
+		expect(walCheck?.status).toBe("warn");
+		expect(walCheck?.fix).toBeDefined();
+
+		const actions = walCheck?.fix?.();
+		expect(Array.isArray(actions)).toBe(true);
+		expect((actions as string[]).some((a) => a.includes("WAL mode"))).toBe(true);
+		expect((actions as string[]).some((a) => a.includes("mail.db"))).toBe(true);
+
+		// Verify WAL mode is now enabled
+		const verifyDb = new Database(join(tempDir, "mail.db"));
+		const journalMode = verifyDb.prepare<{ journal_mode: string }, []>("PRAGMA journal_mode").get();
+		verifyDb.close();
+		expect(journalMode?.journal_mode?.toLowerCase()).toBe("wal");
+	});
 });

package/src/doctor/databases.ts

@@ -1,4 +1,5 @@
 import { Database } from "bun:sqlite";
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 import type { DoctorCheck, DoctorCheckFn } from "./types.ts";
 
@@ -187,6 +188,12 @@ export const checkDatabases: DoctorCheckFn = (_config, overstoryDir): DoctorChec
 					message: `Database ${dbSpec.name} is not using WAL mode`,
 					details: ["WAL mode improves concurrent access performance"],
 					fixable: true,
+					fix: () => {
+						const fixDb = new Database(dbPath);
+						fixDb.exec("PRAGMA journal_mode=WAL");
+						fixDb.close();
+						return [`Enabled WAL mode on ${dbSpec.name}`];
+					},
 				});
 			} else {
 				checks.push({
@@ -222,13 +229,3 @@ export const checkDatabases: DoctorCheckFn = (_config, overstoryDir): DoctorChec
 
 	return checks;
 };
-
-/** Helper to check if file exists (synchronous). */
-function existsSync(path: string): boolean {
-	try {
-		const { existsSync } = require("node:fs");
-		return existsSync(path);
-	} catch {
-		return false;
-	}
-}

package/src/doctor/ecosystem.test.ts

@@ -0,0 +1,307 @@
+/**
+ * Tests for the ecosystem doctor check module.
+ *
+ * We inject a mock spawner instead of using mock.module() to avoid cross-test
+ * leakage (see mulch record mx-56558b on why mock.module() is avoided).
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { OverstoryConfig } from "../types.ts";
+import { makeCheckEcosystem, parseSemver } from "./ecosystem.ts";
+
+// ---------------------------------------------------------------------------
+// Minimal config fixture
+// ---------------------------------------------------------------------------
+
+const mockConfig: OverstoryConfig = {
+	project: {
+		name: "test-project",
+		root: "/tmp/test",
+		canonicalBranch: "main",
+	},
+	agents: {
+		manifestPath: "/tmp/.overstory/agent-manifest.json",
+		baseDir: "/tmp/.overstory/agents",
+		maxConcurrent: 5,
+		staggerDelayMs: 1000,
+		maxDepth: 2,
+		maxSessionsPerRun: 0,
+	},
+	worktrees: {
+		baseDir: "/tmp/.overstory/worktrees",
+	},
+	taskTracker: {
+		backend: "auto",
+		enabled: false,
+	},
+	mulch: {
+		enabled: false,
+		domains: [],
+		primeFormat: "markdown",
+	},
+	merge: {
+		aiResolveEnabled: false,
+		reimagineEnabled: false,
+	},
+	providers: {
+		anthropic: { type: "native" },
+	},
+	watchdog: {
+		tier0Enabled: false,
+		tier0IntervalMs: 30000,
+		tier1Enabled: false,
+		tier2Enabled: false,
+		staleThresholdMs: 300000,
+		zombieThresholdMs: 600000,
+		nudgeIntervalMs: 60000,
+	},
+	models: {},
+	logging: {
+		verbose: false,
+		redactSecrets: true,
+	},
+};
+
+// ---------------------------------------------------------------------------
+// Mock spawner helpers
+// ---------------------------------------------------------------------------
+
+type SpawnResponse = { exitCode: number; stdout: string; stderr: string };
+
+/**
+ * Build a mock spawner that dispatches by binary name (first arg).
+ */
+function makeMockSpawner(responses: Record<string, SpawnResponse>) {
+	return async (args: string[]): Promise<SpawnResponse> => {
+		const bin = args[0] ?? "";
+		return (
+			responses[bin] ?? {
+				exitCode: 127,
+				stdout: "",
+				stderr: `${bin}: command not found`,
+			}
+		);
+	};
+}
+
+// ---------------------------------------------------------------------------
+// parseSemver unit tests
+// ---------------------------------------------------------------------------
+
+describe("parseSemver", () => {
+	test("extracts bare semver", () => {
+		expect(parseSemver("1.2.3")).toBe("1.2.3");
+	});
+
+	test("extracts semver from prefixed output", () => {
+		expect(parseSemver("mulch v1.0.0")).toBe("1.0.0");
+		expect(parseSemver("seeds version 2.3.4")).toBe("2.3.4");
+	});
+
+	test("extracts semver with prerelease", () => {
+		expect(parseSemver("1.2.3-alpha.1")).toBe("1.2.3-alpha.1");
+	});
+
+	test("extracts semver with build metadata", () => {
+		expect(parseSemver("1.2.3+build.42")).toBe("1.2.3+build.42");
+	});
+
+	test("returns null for non-semver strings", () => {
+		expect(parseSemver("not-a-version")).toBeNull();
+		expect(parseSemver("")).toBeNull();
+		expect(parseSemver("v2.0")).toBeNull();
+	});
+
+	test("extracts first semver when multiple exist", () => {
+		expect(parseSemver("tool 1.0.0 requires node 18.0.0")).toBe("1.0.0");
+	});
+});
+
+// ---------------------------------------------------------------------------
+// checkEcosystem integration tests
+// ---------------------------------------------------------------------------
+
+describe("checkEcosystem", () => {
+	test("returns exactly 3 checks (one per tool)", async () => {
+		const spawner = makeMockSpawner({
+			ml: { exitCode: 0, stdout: "1.0.0\n", stderr: "" },
+			sd: { exitCode: 0, stdout: "2.0.0\n", stderr: "" },
+			cn: { exitCode: 0, stdout: "3.0.0\n", stderr: "" },
+		});
+		const check = makeCheckEcosystem(spawner);
+		const results = await check(mockConfig, "/tmp/.overstory");
+
+		expect(results).toHaveLength(3);
+	});
+
+	test("check names match tool names", async () => {
+		const spawner = makeMockSpawner({
+			ml: { exitCode: 0, stdout: "1.0.0\n", stderr: "" },
+			sd: { exitCode: 0, stdout: "2.0.0\n", stderr: "" },
+			cn: { exitCode: 0, stdout: "3.0.0\n", stderr: "" },
+		});
+		const check = makeCheckEcosystem(spawner);
+		const results = await check(mockConfig, "/tmp/.overstory");
+
+		const names = results.map((r) => r.name);
+		expect(names).toContain("mulch semver");
+		expect(names).toContain("seeds semver");
+		expect(names).toContain("canopy semver");
+	});
+
+	test("all checks report category 'ecosystem'", async () => {
+		const spawner = makeMockSpawner({
+			ml: { exitCode: 0, stdout: "1.0.0\n", stderr: "" },
+			sd: { exitCode: 0, stdout: "2.0.0\n", stderr: "" },
+			cn: { exitCode: 0, stdout: "3.0.0\n", stderr: "" },
+		});
+		const check = makeCheckEcosystem(spawner);
+		const results = await check(mockConfig, "/tmp/.overstory");
+
+		for (const r of results) {
+			expect(r.category).toBe("ecosystem");
+		}
+	});
+
+	test("pass when all tools report valid semver", async () => {
+		const spawner = makeMockSpawner({
+			ml: { exitCode: 0, stdout: "mulch v1.2.3\n", stderr: "" },
+			sd: { exitCode: 0, stdout: "seeds 0.5.0\n", stderr: "" },
+			cn: { exitCode: 0, stdout: "0.1.0\n", stderr: "" },
+		});
+		const check = makeCheckEcosystem(spawner);
+		const results = await check(mockConfig, "/tmp/.overstory");
+
+		for (const r of results) {
+			expect(r.status).toBe("pass");
+		}
+	});
+
+	test("warn when a tool is not available (non-zero exit code)", async () => {
+		const spawner = makeMockSpawner({
+			ml: { exitCode: 127, stdout: "", stderr: "ml: command not found" },
+			sd: { exitCode: 0, stdout: "1.0.0\n", stderr: "" },
+			cn: { exitCode: 0, stdout: "1.0.0\n", stderr: "" },
+		});
+		const check = makeCheckEcosystem(spawner);
+		const results = await check(mockConfig, "/tmp/.overstory");
+
+		const mulch = results.find((r) => r.name === "mulch semver");
+		expect(mulch?.status).toBe("warn");
+		expect(mulch?.fixable).toBe(true);
+		expect(typeof mulch?.fix).toBe("function");
+	});
+
+	test("warn when version output is not valid semver", async () => {
+		const spawner = makeMockSpawner({
+			ml: { exitCode: 0, stdout: "mulch dev-build\n", stderr: "" },
+			sd: { exitCode: 0, stdout: "1.0.0\n", stderr: "" },
+			cn: { exitCode: 0, stdout: "1.0.0\n", stderr: "" },
+		});
+		const check = makeCheckEcosystem(spawner);
+		const results = await check(mockConfig, "/tmp/.overstory");
+
+		const mulch = results.find((r) => r.name === "mulch semver");
+		expect(mulch?.status).toBe("warn");
+		expect(mulch?.message).toContain("not parseable semver");
+		expect(mulch?.fixable).toBe(true);
+	});
+
+	test("passing checks include version in message", async () => {
+		const spawner = makeMockSpawner({
+			ml: { exitCode: 0, stdout: "1.2.3\n", stderr: "" },
+			sd: { exitCode: 0, stdout: "1.2.3\n", stderr: "" },
+			cn: { exitCode: 0, stdout: "1.2.3\n", stderr: "" },
+		});
+		const check = makeCheckEcosystem(spawner);
+		const results = await check(mockConfig, "/tmp/.overstory");
+
+		for (const r of results) {
+			expect(r.status).toBe("pass");
+			expect(r.message).toContain("1.2.3");
+		}
+	});
+
+	test("passing checks include raw output in details", async () => {
+		const spawner = makeMockSpawner({
+			ml: { exitCode: 0, stdout: "mulch v1.0.0\n", stderr: "" },
+			sd: { exitCode: 0, stdout: "seeds 1.0.0\n", stderr: "" },
+			cn: { exitCode: 0, stdout: "1.0.0\n", stderr: "" },
+		});
+		const check = makeCheckEcosystem(spawner);
+		const results = await check(mockConfig, "/tmp/.overstory");
+
+		const mulch = results.find((r) => r.name === "mulch semver");
+		expect(mulch?.details).toContain("mulch v1.0.0");
+	});
+
+	test("unavailable tool details include install hint", async () => {
+		const spawner = makeMockSpawner({
+			ml: { exitCode: 127, stdout: "", stderr: "not found" },
+			sd: { exitCode: 0, stdout: "1.0.0\n", stderr: "" },
+			cn: { exitCode: 0, stdout: "1.0.0\n", stderr: "" },
+		});
+		const check = makeCheckEcosystem(spawner);
+		const results = await check(mockConfig, "/tmp/.overstory");
+
+		const mulch = results.find((r) => r.name === "mulch semver");
+		const hasHint = mulch?.details?.some((d) => d.includes("@os-eco/mulch-cli"));
+		expect(hasHint).toBe(true);
+	});
+
+	test("all checks have required DoctorCheck fields", async () => {
+		const spawner = makeMockSpawner({
+			ml: { exitCode: 0, stdout: "1.0.0\n", stderr: "" },
+			sd: { exitCode: 0, stdout: "1.0.0\n", stderr: "" },
+			cn: { exitCode: 0, stdout: "1.0.0\n", stderr: "" },
+		});
+		const check = makeCheckEcosystem(spawner);
+		const results = await check(mockConfig, "/tmp/.overstory");
+
+		for (const r of results) {
+			expect(typeof r.name).toBe("string");
+			expect(r.name.length).toBeGreaterThan(0);
+			expect(r.category).toBe("ecosystem");
+			expect(["pass", "warn", "fail"]).toContain(r.status);
+			expect(typeof r.message).toBe("string");
+		}
+	});
+
+	test("failing checks are marked fixable and have a fix closure", async () => {
+		const spawner = makeMockSpawner({}); // all tools unavailable
+		const check = makeCheckEcosystem(spawner);
+		const results = await check(mockConfig, "/tmp/.overstory");
+
+		for (const r of results) {
+			expect(r.status).toBe("warn");
+			expect(r.fixable).toBe(true);
+			expect(typeof r.fix).toBe("function");
+		}
+	});
+
+	test("handles version in stderr when stdout is empty", async () => {
+		const spawner = makeMockSpawner({
+			ml: { exitCode: 0, stdout: "", stderr: "1.0.0" },
+			sd: { exitCode: 0, stdout: "1.0.0\n", stderr: "" },
+			cn: { exitCode: 0, stdout: "1.0.0\n", stderr: "" },
+		});
+		const check = makeCheckEcosystem(spawner);
+		const results = await check(mockConfig, "/tmp/.overstory");
+
+		const mulch = results.find((r) => r.name === "mulch semver");
+		expect(mulch?.status).toBe("pass");
+	});
+
+	test("handles spawn exception gracefully", async () => {
+		const errorSpawner = async (_args: string[]) => {
+			throw new Error("spawn failed");
+		};
+		const check = makeCheckEcosystem(errorSpawner);
+		const results = await check(mockConfig, "/tmp/.overstory");
+
+		expect(results).toHaveLength(3);
+		for (const r of results) {
+			expect(r.status).toBe("warn");
+		}
+	});
+});