@os-eco/overstory-cli 0.6.9 → 0.6.10

package/src/doctor/ecosystem.ts

@@ -0,0 +1,155 @@
+import type { DoctorCheck, DoctorCheckFn } from "./types.ts";
+
+/**
+ * Ecosystem health checks.
+ *
+ * Validates that os-eco CLI tools (ml, sd, cn) are on PATH and report valid
+ * semver versions. Intentionally does NOT duplicate the availability checks in
+ * dependencies.ts — those confirm the binaries exist. These checks focus on
+ * whether the reported version string is parseable semver, and whether the
+ * tools are mutually compatible.
+ *
+ * Fix closures reinstall the relevant package via `bun install -g <pkg>`.
+ */
+
+/** A single os-eco ecosystem tool. */
+interface EcosystemTool {
+	/** Human-readable tool name. */
+	name: string;
+	/** Primary binary to invoke for version check. */
+	bin: string;
+	/** npm package name for install / reinstall. */
+	pkg: string;
+}
+
+const ECOSYSTEM_TOOLS: EcosystemTool[] = [
+	{ name: "mulch", bin: "ml", pkg: "@os-eco/mulch-cli" },
+	{ name: "seeds", bin: "sd", pkg: "@os-eco/seeds-cli" },
+	{ name: "canopy", bin: "cn", pkg: "@os-eco/canopy-cli" },
+];
+
+/** Spawner abstraction — injected in tests, uses Bun.spawn in production. */
+export type Spawner = (
+	args: string[],
+) => Promise<{ exitCode: number; stdout: string; stderr: string }>;
+
+async function defaultSpawner(
+	args: string[],
+): Promise<{ exitCode: number; stdout: string; stderr: string }> {
+	const proc = Bun.spawn(args, {
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const exitCode = await proc.exited;
+	const stdout = await new Response(proc.stdout).text();
+	const stderr = await new Response(proc.stderr).text();
+	return { exitCode, stdout, stderr };
+}
+
+/**
+ * Loose semver extractor.
+ * Finds the first x.y.z (optionally x.y.z-pre or x.y.z+build) token in a string.
+ * Returns null when no valid semver token is found.
+ */
+export function parseSemver(output: string): string | null {
+	const match = /(\d+\.\d+\.\d+(?:[-.+][a-zA-Z0-9._-]*)?)/.exec(output);
+	return match?.[1] ?? null;
+}
+
+/** Internal result of probing a binary's version output. */
+interface VersionProbeResult {
+	available: boolean;
+	version: string | null;
+	raw: string;
+}
+
+async function probeVersion(bin: string, spawner: Spawner): Promise<VersionProbeResult> {
+	try {
+		const { exitCode, stdout, stderr } = await spawner([bin, "--version"]);
+		const raw = (stdout + stderr).trim();
+		if (exitCode !== 0) {
+			return { available: false, version: null, raw };
+		}
+		const version = parseSemver(raw);
+		return { available: true, version, raw };
+	} catch {
+		return { available: false, version: null, raw: "" };
+	}
+}
+
+/** Build a DoctorCheck for a single ecosystem tool. */
+function buildCheck(tool: EcosystemTool, probe: VersionProbeResult): DoctorCheck {
+	const { bin, pkg, name } = tool;
+
+	if (!probe.available) {
+		return {
+			name: `${name} semver`,
+			category: "ecosystem",
+			status: "warn",
+			message: `${bin} is not available — cannot verify version`,
+			details: [`Install: bun install -g ${pkg}`],
+			fixable: true,
+			fix: async () => {
+				const proc = Bun.spawn(["bun", "install", "-g", pkg], {
+					stdout: "inherit",
+					stderr: "inherit",
+				});
+				await proc.exited;
+				return [`Installed ${pkg}`];
+			},
+		};
+	}
+
+	if (probe.version === null) {
+		return {
+			name: `${name} semver`,
+			category: "ecosystem",
+			status: "warn",
+			message: `${bin} --version output is not parseable semver`,
+			details: [
+				`Raw output: ${probe.raw || "(empty)"}`,
+				"Expected format: x.y.z",
+				`Reinstall: bun install -g ${pkg}`,
+			],
+			fixable: true,
+			fix: async () => {
+				const proc = Bun.spawn(["bun", "install", "-g", pkg], {
+					stdout: "inherit",
+					stderr: "inherit",
+				});
+				await proc.exited;
+				return [`Reinstalled ${pkg}`];
+			},
+		};
+	}
+
+	return {
+		name: `${name} semver`,
+		category: "ecosystem",
+		status: "pass",
+		message: `${name} v${probe.version} (valid semver)`,
+		details: [probe.raw],
+	};
+}
+
+/**
+ * Factory that creates a DoctorCheckFn with an injectable spawner.
+ * Used for testing without module-level mocks.
+ */
+export function makeCheckEcosystem(spawner: Spawner = defaultSpawner): DoctorCheckFn {
+	return async (_config, _overstoryDir): Promise<DoctorCheck[]> => {
+		const checks: DoctorCheck[] = [];
+
+		for (const tool of ECOSYSTEM_TOOLS) {
+			const probe = await probeVersion(tool.bin, spawner);
+			checks.push(buildCheck(tool, probe));
+		}
+
+		return checks;
+	};
+}
+
+/**
+ * Ecosystem health check — validates semver version output for ml, sd, cn.
+ */
+export const checkEcosystem: DoctorCheckFn = makeCheckEcosystem();

package/src/doctor/merge-queue.test.ts

@@ -213,4 +213,102 @@ describe("checkMergeQueue", () => {
 		expect(duplicateCheck?.message).toContain("duplicate branch entries");
 		expect(duplicateCheck?.details?.[0]).toContain("feature/duplicate");
 	});
+
+	test("fix() deletes stale pending entries", () => {
+		const dbPath = join(tempDir, "merge-queue.db");
+		const queue = createMergeQueue(dbPath);
+		queue.close();
+
+		const staleDate = new Date();
+		staleDate.setDate(staleDate.getDate() - 2); // 2 days ago
+
+		const db = new Database(dbPath);
+		db.prepare(
+			"INSERT INTO merge_queue (branch_name, task_id, agent_name, files_modified, status, enqueued_at) VALUES (?, ?, ?, ?, ?, ?)",
+		).run(
+			"feature/stale-1",
+			"beads-abc",
+			"test-agent",
+			JSON.stringify(["src/test.ts"]),
+			"pending",
+			staleDate.toISOString(),
+		);
+		db.prepare(
+			"INSERT INTO merge_queue (branch_name, task_id, agent_name, files_modified, status, enqueued_at) VALUES (?, ?, ?, ?, ?, ?)",
+		).run(
+			"feature/stale-2",
+			"beads-def",
+			"test-agent",
+			JSON.stringify(["src/other.ts"]),
+			"merging",
+			staleDate.toISOString(),
+		);
+		db.close();
+
+		const checks = checkMergeQueue(mockConfig, tempDir) as DoctorCheck[];
+
+		const staleCheck = checks.find((c) => c?.name === "merge-queue.db staleness");
+		expect(staleCheck?.fix).toBeDefined();
+
+		const actions = staleCheck?.fix?.();
+		expect(Array.isArray(actions)).toBe(true);
+		const actionsArr = actions as string[];
+		expect(actionsArr.some((a) => a.includes("Deleted") && a.includes("stale"))).toBe(true);
+
+		// Verify entries were deleted
+		const verifyDb = new Database(dbPath);
+		const remaining = verifyDb
+			.prepare("SELECT COUNT(*) as count FROM merge_queue WHERE status IN ('pending', 'merging')")
+			.get() as { count: number };
+		verifyDb.close();
+		expect(remaining.count).toBe(0);
+	});
+
+	test("fix() removes duplicate entries keeping newest", () => {
+		const dbPath = join(tempDir, "merge-queue.db");
+		const queue = createMergeQueue(dbPath);
+		queue.enqueue({
+			branchName: "feature/dup",
+			taskId: "beads-abc",
+			agentName: "agent-1",
+			filesModified: ["src/a.ts"],
+		});
+		queue.enqueue({
+			branchName: "feature/dup",
+			taskId: "beads-def",
+			agentName: "agent-2",
+			filesModified: ["src/b.ts"],
+		});
+		queue.enqueue({
+			branchName: "feature/other",
+			taskId: "beads-ghi",
+			agentName: "agent-3",
+			filesModified: ["src/c.ts"],
+		});
+		queue.close();
+
+		const checks = checkMergeQueue(mockConfig, tempDir) as DoctorCheck[];
+
+		const dupCheck = checks.find((c) => c?.name === "merge-queue.db duplicates");
+		expect(dupCheck?.fix).toBeDefined();
+
+		const actions = dupCheck?.fix?.();
+		expect(Array.isArray(actions)).toBe(true);
+		const actionsArr = actions as string[];
+		expect(actionsArr.some((a) => a.includes("Removed") && a.includes("duplicate"))).toBe(true);
+
+		// Verify only 2 entries remain (1 per branch)
+		const verifyDb = new Database(dbPath);
+		const remaining = verifyDb.prepare("SELECT COUNT(*) as count FROM merge_queue").get() as {
+			count: number;
+		};
+		// Check the newest entry for feature/dup is kept (highest id)
+		const dupEntries = verifyDb
+			.prepare("SELECT agent_name FROM merge_queue WHERE branch_name = 'feature/dup'")
+			.all() as Array<{ agent_name: string }>;
+		verifyDb.close();
+		expect(remaining.count).toBe(2);
+		expect(dupEntries).toHaveLength(1);
+		expect(dupEntries[0]?.agent_name).toBe("agent-2"); // newest entry kept
+	});
 });

package/src/doctor/merge-queue.ts

@@ -114,6 +114,18 @@ export const checkMergeQueue: DoctorCheckFn = (_config, overstoryDir): DoctorChe
 				message: `Found ${staleEntries.length} potentially stale queue entries`,
 				details: staleEntries,
 				fixable: true,
+				fix: () => {
+					const fixDb = new Database(dbPath);
+					fixDb.exec("PRAGMA busy_timeout=5000");
+					const staleThreshold = new Date(now.getTime() - staleThresholdMs).toISOString();
+					const result = fixDb
+						.prepare(
+							"DELETE FROM merge_queue WHERE status IN ('pending', 'merging') AND enqueued_at < ?",
+						)
+						.run(staleThreshold);
+					fixDb.close();
+					return [`Deleted ${result.changes} stale merge queue entries`];
+				},
 			});
 		}
 
@@ -134,6 +146,17 @@ export const checkMergeQueue: DoctorCheckFn = (_config, overstoryDir): DoctorChe
 				message: "Found duplicate branch entries in queue",
 				details: duplicates,
 				fixable: true,
+				fix: () => {
+					const fixDb = new Database(dbPath);
+					fixDb.exec("PRAGMA busy_timeout=5000");
+					const result = fixDb
+						.prepare(
+							"DELETE FROM merge_queue WHERE id NOT IN (SELECT MAX(id) FROM merge_queue GROUP BY branch_name)",
+						)
+						.run();
+					fixDb.close();
+					return [`Removed ${result.changes} duplicate merge queue entries`];
+				},
 			});
 		}
 	} finally {

package/src/doctor/structure.test.ts

@@ -6,7 +6,7 @@
  */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import { mkdir, mkdtemp, rm, utimes } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { OverstoryConfig } from "../types.ts";
@@ -288,4 +288,133 @@ describe("checkStructure", () => {
 		expect(tempFilesCheck).toBeDefined();
 		expect(tempFilesCheck?.status).toBe("pass");
 	});
+
+	test("fix() creates missing subdirectories", async () => {
+		await mkdir(overstoryDir, { recursive: true });
+
+		const checks = await checkStructure(mockConfig, overstoryDir);
+
+		const dirsCheck = checks.find((c) => c.name === "Required subdirectories");
+		expect(dirsCheck?.status).toBe("fail");
+		expect(dirsCheck?.fix).toBeDefined();
+
+		const actions = await dirsCheck?.fix?.();
+		expect(actions).toBeDefined();
+		expect(actions?.length).toBeGreaterThan(0);
+		expect(actions?.some((a) => a.includes("agents/"))).toBe(true);
+		expect(actions?.some((a) => a.includes("worktrees/"))).toBe(true);
+		expect(actions?.some((a) => a.includes("specs/"))).toBe(true);
+		expect(actions?.some((a) => a.includes("logs/"))).toBe(true);
+
+		// Verify directories were actually created
+		const { stat: fsStat } = await import("node:fs/promises");
+		const agentsStat = await fsStat(join(overstoryDir, "agents"));
+		expect(agentsStat.isDirectory()).toBe(true);
+		const worktreesStat = await fsStat(join(overstoryDir, "worktrees"));
+		expect(worktreesStat.isDirectory()).toBe(true);
+	});
+
+	test("fix() appends missing .gitignore entries", async () => {
+		await mkdir(overstoryDir, { recursive: true });
+		await Bun.write(join(overstoryDir, ".gitignore"), `*\n!.gitignore\n!config.yaml\n`);
+
+		const checks = await checkStructure(mockConfig, overstoryDir);
+
+		const gitignoreCheck = checks.find((c) => c.name === ".gitignore entries");
+		expect(gitignoreCheck?.status).toBe("warn");
+		expect(gitignoreCheck?.fix).toBeDefined();
+
+		const actions = await gitignoreCheck?.fix?.();
+		expect(actions).toBeDefined();
+		expect(actions?.length).toBeGreaterThan(0);
+		expect(actions?.some((a) => a.includes("!agent-manifest.json"))).toBe(true);
+
+		// Verify entries were appended
+		const content = await Bun.file(join(overstoryDir, ".gitignore")).text();
+		expect(content).toContain("!agent-manifest.json");
+		expect(content).toContain("!hooks.json");
+	});
+
+	test("fix() removes leftover temp files", async () => {
+		await mkdir(overstoryDir, { recursive: true });
+		const tmpFile = join(overstoryDir, "config.yaml.tmp");
+		const bakFile = join(overstoryDir, "old.bak");
+		await Bun.write(tmpFile, "temp content");
+		await Bun.write(bakFile, "backup content");
+
+		const checks = await checkStructure(mockConfig, overstoryDir);
+
+		const tempCheck = checks.find((c) => c.name === "Leftover temp files");
+		expect(tempCheck?.status).toBe("warn");
+		expect(tempCheck?.fix).toBeDefined();
+
+		const actions = await tempCheck?.fix?.();
+		expect(actions).toBeDefined();
+		expect(actions?.some((a) => a.includes("config.yaml.tmp"))).toBe(true);
+		expect(actions?.some((a) => a.includes("old.bak"))).toBe(true);
+
+		// Verify files were deleted
+		expect(await Bun.file(tmpFile).exists()).toBe(false);
+		expect(await Bun.file(bakFile).exists()).toBe(false);
+	});
+
+	test("passes when no stale lock files exist", async () => {
+		await mkdir(overstoryDir, { recursive: true });
+
+		const checks = await checkStructure(mockConfig, overstoryDir);
+
+		const lockCheck = checks.find((c) => c.name === "Stale lock files");
+		expect(lockCheck).toBeDefined();
+		expect(lockCheck?.status).toBe("pass");
+		expect(lockCheck?.fix).toBeUndefined();
+	});
+
+	test("warns when stale lock files exist", async () => {
+		await mkdir(overstoryDir, { recursive: true });
+		const lockFile = join(overstoryDir, "mail.lock");
+		await Bun.write(lockFile, "locked");
+		// Set mtime to 10 minutes ago
+		const tenMinutesAgo = new Date(Date.now() - 10 * 60 * 1000);
+		await utimes(lockFile, tenMinutesAgo, tenMinutesAgo);
+
+		const checks = await checkStructure(mockConfig, overstoryDir);
+
+		const lockCheck = checks.find((c) => c.name === "Stale lock files");
+		expect(lockCheck).toBeDefined();
+		expect(lockCheck?.status).toBe("warn");
+		expect(lockCheck?.details).toContain("mail.lock");
+		expect(lockCheck?.fixable).toBe(true);
+		expect(lockCheck?.fix).toBeDefined();
+	});
+
+	test("does not warn about fresh lock files", async () => {
+		await mkdir(overstoryDir, { recursive: true });
+		// Write a fresh lock file (just created = now)
+		await Bun.write(join(overstoryDir, "sessions.lock"), "locked");
+
+		const checks = await checkStructure(mockConfig, overstoryDir);
+
+		const lockCheck = checks.find((c) => c.name === "Stale lock files");
+		expect(lockCheck?.status).toBe("pass");
+	});
+
+	test("fix() removes stale lock files", async () => {
+		await mkdir(overstoryDir, { recursive: true });
+		const lockFile = join(overstoryDir, "stale.lock");
+		await Bun.write(lockFile, "locked");
+		// Set mtime to 10 minutes ago
+		const tenMinutesAgo = new Date(Date.now() - 10 * 60 * 1000);
+		await utimes(lockFile, tenMinutesAgo, tenMinutesAgo);
+
+		const checks = await checkStructure(mockConfig, overstoryDir);
+
+		const lockCheck = checks.find((c) => c.name === "Stale lock files");
+		expect(lockCheck?.fix).toBeDefined();
+
+		const actions = await lockCheck?.fix?.();
+		expect(actions?.some((a) => a.includes("stale.lock"))).toBe(true);
+
+		// Verify the lock file was removed
+		expect(await Bun.file(lockFile).exists()).toBe(false);
+	});
 });

package/src/doctor/structure.ts

@@ -1,4 +1,4 @@
-import { access, constants } from "node:fs/promises";
+import { access, constants, mkdir, rm, stat } from "node:fs/promises";
 import { join } from "node:path";
 import type { AgentManifest } from "../types.ts";
 import type { DoctorCheck, DoctorCheckFn } from "./types.ts";
@@ -87,6 +87,18 @@ export const checkStructure: DoctorCheckFn = async (
 				: `Missing ${missingDirs.length} subdirectory(ies)`,
 		details: missingDirs.length > 0 ? missingDirs : undefined,
 		fixable: missingDirs.length > 0,
+		fix:
+			missingDirs.length > 0
+				? async () => {
+						const actions: string[] = [];
+						for (const dir of missingDirs) {
+							const dirPath = join(overstoryDir, dir.replace(/\/$/, ""));
+							await mkdir(dirPath, { recursive: true });
+							actions.push(`Created missing directory: ${dir}`);
+						}
+						return actions;
+					}
+				: undefined,
 	});
 
 	// Check 4: .gitignore contents — validate wildcard+whitelist model
@@ -115,6 +127,19 @@ export const checkStructure: DoctorCheckFn = async (
 					: `Missing ${missingEntries.length} entry(ies)`,
 			details: missingEntries.length > 0 ? missingEntries : undefined,
 			fixable: missingEntries.length > 0,
+			fix:
+				missingEntries.length > 0
+					? async () => {
+							const actions: string[] = [];
+							const content = await Bun.file(gitignorePath).text();
+							const suffix = content.endsWith("\n") ? "" : "\n";
+							await Bun.write(gitignorePath, `${content + suffix + missingEntries.join("\n")}\n`);
+							for (const entry of missingEntries) {
+								actions.push(`Added .gitignore entry: ${entry}`);
+							}
+							return actions;
+						}
+					: undefined,
 		});
 	} catch {
 		// .gitignore doesn't exist, already reported in required files check
@@ -189,10 +214,71 @@ export const checkStructure: DoctorCheckFn = async (
 				tempFiles.length === 0 ? "No temp files found" : `Found ${tempFiles.length} temp file(s)`,
 			details: tempFiles.length > 0 ? tempFiles : undefined,
 			fixable: tempFiles.length > 0,
+			fix:
+				tempFiles.length > 0
+					? async () => {
+							const actions: string[] = [];
+							for (const file of tempFiles) {
+								await rm(join(overstoryDir, file), { force: true });
+								actions.push(`Removed temp file: ${file}`);
+							}
+							return actions;
+						}
+					: undefined,
 		});
 	} catch {
 		// Ignore errors scanning for temp files
 	}
 
+	// Check 7: Stale lock files (older than 5 minutes)
+	try {
+		const lockEntries = await Array.fromAsync(new Bun.Glob("*.lock").scan({ cwd: overstoryDir }));
+		const now = Date.now();
+		const staleLockThresholdMs = 5 * 60 * 1000;
+		const staleLockFiles: string[] = [];
+
+		for (const lockFile of lockEntries) {
+			try {
+				const lockPath = join(overstoryDir, lockFile);
+				const stats = await stat(lockPath);
+				const ageMs = now - stats.mtimeMs;
+				if (ageMs > staleLockThresholdMs) {
+					staleLockFiles.push(lockFile);
+				}
+			} catch {
+				// ignore stat errors
+			}
+		}
+
+		checks.push({
+			name: "Stale lock files",
+			category: "structure",
+			status: staleLockFiles.length === 0 ? "pass" : "warn",
+			message:
+				staleLockFiles.length === 0
+					? "No stale lock files found"
+					: `Found ${staleLockFiles.length} stale lock file(s)`,
+			details: staleLockFiles.length > 0 ? staleLockFiles : undefined,
+			fixable: staleLockFiles.length > 0,
+			fix:
+				staleLockFiles.length > 0
+					? async () => {
+							const actions: string[] = [];
+							for (const file of staleLockFiles) {
+								try {
+									await rm(join(overstoryDir, file), { force: true });
+									actions.push(`Removed stale lock file: ${file}`);
+								} catch {
+									// ignore removal errors
+								}
+							}
+							return actions;
+						}
+					: undefined,
+		});
+	} catch {
+		// ignore errors scanning for lock files
+	}
+
 	return checks;
 };

package/src/doctor/types.ts

@@ -12,7 +12,8 @@ export type DoctorCategory =
 	| "agents"
 	| "merge"
 	| "logs"
-	| "version";
+	| "version"
+	| "ecosystem";
 
 /** Result of a single doctor health check. */
 export interface DoctorCheck {
@@ -21,8 +22,10 @@ export interface DoctorCheck {
 	status: "pass" | "warn" | "fail";
 	message: string;
 	details?: string[];
-	/** Whether this check issues can be auto-fixed (future --fix flag). */
+	/** Whether this check issues can be auto-fixed via --fix. */
 	fixable?: boolean;
+	/** Auto-fix closure — called when --fix flag is passed. Captures context at construction time. */
+	fix?: () => Promise<string[]> | string[];
 }
 
 /**

package/src/index.ts

@@ -15,6 +15,7 @@ import { createCoordinatorCommand } from "./commands/coordinator.ts";
 import { createCostsCommand } from "./commands/costs.ts";
 import { createDashboardCommand } from "./commands/dashboard.ts";
 import { createDoctorCommand } from "./commands/doctor.ts";
+import { createEcosystemCommand } from "./commands/ecosystem.ts";
 import { createErrorsCommand } from "./commands/errors.ts";
 import { createFeedCommand } from "./commands/feed.ts";
 import { createGroupCommand } from "./commands/group.ts";
@@ -37,13 +38,14 @@ import { createStatusCommand } from "./commands/status.ts";
 import { stopCommand } from "./commands/stop.ts";
 import { createSupervisorCommand } from "./commands/supervisor.ts";
 import { traceCommand } from "./commands/trace.ts";
+import { createUpgradeCommand } from "./commands/upgrade.ts";
 import { createWatchCommand } from "./commands/watch.ts";
 import { createWorktreeCommand } from "./commands/worktree.ts";
 import { OverstoryError, WorktreeError } from "./errors.ts";
 import { jsonError } from "./json.ts";
 import { brand, chalk, muted, setQuiet } from "./logging/color.ts";
 
-export const VERSION = "0.6.9";
+export const VERSION = "0.6.10";
 
 const rawArgs = process.argv.slice(2);
 
@@ -86,12 +88,14 @@ const COMMANDS = [
 	"logs",
 	"watch",
 	"trace",
+	"ecosystem",
 	"feed",
 	"errors",
 	"replay",
 	"run",
 	"costs",
 	"metrics",
+	"upgrade",
 ];
 
 function editDistance(a: string, b: string): number {
@@ -129,6 +133,8 @@ function suggestCommand(input: string): string | undefined {
 
 const program = new Command();
 
+let timingStart: number | undefined;
+
 program
 	.name("ov")
 	.description("Multi-agent orchestration for Claude Code")
@@ -136,6 +142,7 @@ program
 	.option("-q, --quiet", "Suppress non-error output")
 	.option("--json", "JSON output")
 	.option("--verbose", "Verbose output")
+	.option("--timing", "Print command execution time to stderr")
 	.addHelpCommand(false)
 	.configureHelp({
 		formatHelp(cmd, helper): string {
@@ -191,6 +198,17 @@ program.hook("preAction", (thisCmd) => {
 	if (opts.quiet) {
 		setQuiet(true);
 	}
+	if (opts.timing) {
+		timingStart = performance.now();
+	}
+});
+program.hook("postAction", () => {
+	if (program.opts().timing && timingStart !== undefined) {
+		const elapsed = performance.now() - timingStart;
+		const formatted =
+			elapsed < 1000 ? `${Math.round(elapsed)}ms` : `${(elapsed / 1000).toFixed(2)}s`;
+		process.stderr.write(`${muted(`Done in ${formatted}`)}\n`);
+	}
 });
 
 // Migrated commands — use addCommand() with createXCommand() factories
@@ -344,6 +362,8 @@ program
 
 program.addCommand(createFeedCommand());
 
+program.addCommand(createEcosystemCommand());
+
 program.addCommand(createErrorsCommand());
 
 program.addCommand(createReplayCommand());
@@ -354,6 +374,8 @@ program.addCommand(createCostsCommand());
 
 program.addCommand(createMetricsCommand());
 
+program.addCommand(createUpgradeCommand());
+
 // Handle unknown commands with Levenshtein fuzzy-match suggestions
 program.on("command:*", (operands) => {
 	const unknown = operands[0] ?? "";