@os-eco/overstory-cli 0.6.8 → 0.6.10

package/src/commands/costs.test.ts

@@ -116,7 +116,14 @@ describe("costsCommand", () => {
 			await costsCommand(["--json"]);
 			const out = output();
 
-			expect(out).toBe("[]\n");
+			const parsed = JSON.parse(out.trim()) as {
+				success: boolean;
+				command: string;
+				sessions: unknown[];
+			};
+			expect(parsed.success).toBe(true);
+			expect(parsed.command).toBe("costs");
+			expect(parsed.sessions).toEqual([]);
 		});
 	});
 
@@ -149,9 +156,10 @@ describe("costsCommand", () => {
 			await costsCommand(["--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(Array.isArray(parsed)).toBe(true);
-			expect(parsed).toHaveLength(2);
+			const parsed = JSON.parse(out.trim()) as { success: boolean; sessions: unknown[] };
+			expect(parsed.success).toBe(true);
+			expect(Array.isArray(parsed.sessions)).toBe(true);
+			expect(parsed.sessions).toHaveLength(2);
 		});
 
 		test("JSON output includes expected token fields", async () => {
@@ -173,9 +181,12 @@ describe("costsCommand", () => {
 			await costsCommand(["--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Record<string, unknown>[];
-			expect(parsed).toHaveLength(1);
-			const session = parsed[0];
+			const parsed = JSON.parse(out.trim()) as {
+				success: boolean;
+				sessions: Record<string, unknown>[];
+			};
+			expect(parsed.sessions).toHaveLength(1);
+			const session = parsed.sessions[0];
 			expect(session).toBeDefined();
 			expect(session?.inputTokens).toBe(100);
 			expect(session?.outputTokens).toBe(50);
@@ -193,8 +204,8 @@ describe("costsCommand", () => {
 			await costsCommand(["--json", "--agent", "nonexistent"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toEqual([]);
+			const parsed = JSON.parse(out.trim()) as { success: boolean; sessions: unknown[] };
+			expect(parsed.sessions).toEqual([]);
 		});
 
 		test("JSON --by-capability outputs grouped object", async () => {
@@ -221,12 +232,12 @@ describe("costsCommand", () => {
 			await costsCommand(["--json", "--by-capability"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Record<string, unknown>;
-			expect(parsed).toBeDefined();
-			expect(parsed.builder).toBeDefined();
-			expect(parsed.scout).toBeDefined();
+			const parsed = JSON.parse(out.trim()) as { grouped: Record<string, unknown> };
+			expect(parsed.grouped).toBeDefined();
+			expect(parsed.grouped.builder).toBeDefined();
+			expect(parsed.grouped.scout).toBeDefined();
 
-			const builderGroup = parsed.builder as Record<string, unknown>;
+			const builderGroup = parsed.grouped.builder as Record<string, unknown>;
 			expect(builderGroup.sessions).toBeDefined();
 			expect(builderGroup.totals).toBeDefined();
 		});
@@ -415,9 +426,9 @@ describe("costsCommand", () => {
 			await costsCommand(["--json", "--agent", "builder-1"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Record<string, unknown>[];
-			expect(parsed).toHaveLength(1);
-			expect(parsed[0]?.agentName).toBe("builder-1");
+			const parsed = JSON.parse(out.trim()) as { sessions: Record<string, unknown>[] };
+			expect(parsed.sessions).toHaveLength(1);
+			expect(parsed.sessions[0]?.agentName).toBe("builder-1");
 		});
 
 		test("returns empty for non-existent agent", async () => {
@@ -429,8 +440,8 @@ describe("costsCommand", () => {
 			await costsCommand(["--json", "--agent", "nonexistent"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toEqual([]);
+			const parsed = JSON.parse(out.trim()) as { sessions: unknown[] };
+			expect(parsed.sessions).toEqual([]);
 		});
 	});
 
@@ -456,9 +467,9 @@ describe("costsCommand", () => {
 			await costsCommand(["--json", "--run", "run-2026-01-01"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Record<string, unknown>[];
-			expect(parsed).toHaveLength(1);
-			expect(parsed[0]?.agentName).toBe("builder-1");
+			const parsed = JSON.parse(out.trim()) as { sessions: Record<string, unknown>[] };
+			expect(parsed.sessions).toHaveLength(1);
+			expect(parsed.sessions[0]?.agentName).toBe("builder-1");
 		});
 
 		test("returns empty when no sessions match run ID", async () => {
@@ -472,8 +483,8 @@ describe("costsCommand", () => {
 			await costsCommand(["--json", "--run", "run-nonexistent"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toEqual([]);
+			const parsed = JSON.parse(out.trim()) as { sessions: unknown[] };
+			expect(parsed.sessions).toEqual([]);
 		});
 	});
 
@@ -557,12 +568,11 @@ describe("costsCommand", () => {
 			await costsCommand(["--json", "--by-capability"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Record<
-				string,
-				{ sessions: unknown[]; totals: Record<string, unknown> }
-			>;
-			expect(parsed.builder?.sessions).toHaveLength(3);
-			expect(parsed.scout?.sessions).toHaveLength(1);
+			const parsed = JSON.parse(out.trim()) as {
+				grouped: Record<string, { sessions: unknown[]; totals: Record<string, unknown> }>;
+			};
+			expect(parsed.grouped.builder?.sessions).toHaveLength(3);
+			expect(parsed.grouped.scout?.sessions).toHaveLength(1);
 		});
 
 		test("empty data shows no session data message", async () => {
@@ -591,8 +601,8 @@ describe("costsCommand", () => {
 			await costsCommand(["--json", "--last", "3"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toHaveLength(3);
+			const parsed = JSON.parse(out.trim()) as { sessions: unknown[] };
+			expect(parsed.sessions).toHaveLength(3);
 		});
 
 		test("default limit is 20", async () => {
@@ -606,8 +616,8 @@ describe("costsCommand", () => {
 			await costsCommand(["--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toHaveLength(20);
+			const parsed = JSON.parse(out.trim()) as { sessions: unknown[] };
+			expect(parsed.sessions).toHaveLength(20);
 		});
 	});
 
@@ -705,9 +715,9 @@ describe("costsCommand", () => {
 			await costsCommand(["--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as SessionMetrics[];
-			const totalInput = parsed.reduce((sum, s) => sum + s.inputTokens, 0);
-			const totalOutput = parsed.reduce((sum, s) => sum + s.outputTokens, 0);
+			const parsed = JSON.parse(out.trim()) as { sessions: SessionMetrics[] };
+			const totalInput = parsed.sessions.reduce((sum, s) => sum + s.inputTokens, 0);
+			const totalOutput = parsed.sessions.reduce((sum, s) => sum + s.outputTokens, 0);
 			expect(totalInput).toBe(300);
 			expect(totalOutput).toBe(150);
 		});
@@ -1106,7 +1116,7 @@ describe("costsCommand", () => {
 			const out = output();
 
 			const parsed = JSON.parse(out.trim()) as Record<string, unknown>;
-			expect(parsed.error).toBe("no_transcript");
+			expect(parsed.error).toBe("No orchestrator transcript found");
 		});
 
 		test("--self in help text", async () => {

package/src/commands/costs.ts

@@ -11,6 +11,7 @@ import { join } from "node:path";
 import { Command } from "commander";
 import { loadConfig } from "../config.ts";
 import { ValidationError } from "../errors.ts";
+import { jsonError, jsonOutput } from "../json.ts";
 import { color } from "../logging/color.ts";
 import { createMetricsStore } from "../metrics/store.ts";
 import { estimateCost, parseTranscriptUsage } from "../metrics/transcript.ts";
@@ -272,10 +273,7 @@ async function executeCosts(opts: CostsOpts): Promise<void> {
 		const transcriptPath = await discoverOrchestratorTranscript(config.project.root);
 		if (!transcriptPath) {
 			if (json) {
-				process.stdout.write(
-					JSON.stringify({ error: "no_transcript", message: "No orchestrator transcript found" }) +
-						"\n",
-				);
+				jsonError("costs", "No orchestrator transcript found");
 			} else {
 				process.stdout.write(
 					"No orchestrator transcript found.\nExpected at: ~/.claude/projects/{project-key}/*.jsonl\n",
@@ -289,18 +287,16 @@ async function executeCosts(opts: CostsOpts): Promise<void> {
 		const cacheTotal = usage.cacheReadTokens + usage.cacheCreationTokens;
 
 		if (json) {
-			process.stdout.write(
-				`${JSON.stringify({
-					source: "self",
-					transcriptPath,
-					model: usage.modelUsed,
-					inputTokens: usage.inputTokens,
-					outputTokens: usage.outputTokens,
-					cacheReadTokens: usage.cacheReadTokens,
-					cacheCreationTokens: usage.cacheCreationTokens,
-					estimatedCostUsd: cost,
-				})}\n`,
-			);
+			jsonOutput("costs", {
+				source: "self",
+				transcriptPath,
+				model: usage.modelUsed,
+				inputTokens: usage.inputTokens,
+				outputTokens: usage.outputTokens,
+				cacheReadTokens: usage.cacheReadTokens,
+				cacheCreationTokens: usage.cacheCreationTokens,
+				estimatedCostUsd: cost,
+			});
 		} else {
 			const w = process.stdout.write.bind(process.stdout);
 			const separator = "\u2500".repeat(70);
@@ -327,9 +323,17 @@ async function executeCosts(opts: CostsOpts): Promise<void> {
 		const metricsFile = Bun.file(metricsDbPath);
 		if (!(await metricsFile.exists())) {
 			if (json) {
-				process.stdout.write(
-					`${JSON.stringify({ agents: [], totals: { inputTokens: 0, outputTokens: 0, cacheTokens: 0, costUsd: 0, burnRatePerMin: 0, tokensPerMin: 0 } })}\n`,
-				);
+				jsonOutput("costs", {
+					agents: [],
+					totals: {
+						inputTokens: 0,
+						outputTokens: 0,
+						cacheTokens: 0,
+						costUsd: 0,
+						burnRatePerMin: 0,
+						tokensPerMin: 0,
+					},
+				});
 			} else {
 				process.stdout.write(
 					"No live data available. Token snapshots begin after first tool call.\n",
@@ -345,9 +349,17 @@ async function executeCosts(opts: CostsOpts): Promise<void> {
 			const snapshots = metricsStore.getLatestSnapshots();
 			if (snapshots.length === 0) {
 				if (json) {
-					process.stdout.write(
-						`${JSON.stringify({ agents: [], totals: { inputTokens: 0, outputTokens: 0, cacheTokens: 0, costUsd: 0, burnRatePerMin: 0, tokensPerMin: 0 } })}\n`,
-					);
+					jsonOutput("costs", {
+						agents: [],
+						totals: {
+							inputTokens: 0,
+							outputTokens: 0,
+							cacheTokens: 0,
+							costUsd: 0,
+							burnRatePerMin: 0,
+							tokensPerMin: 0,
+						},
+					});
 				} else {
 					process.stdout.write(
 						"No live data available. Token snapshots begin after first tool call.\n",
@@ -428,19 +440,17 @@ async function executeCosts(opts: CostsOpts): Promise<void> {
 			const tokensPerMin = avgElapsedMs > 0 ? totalTokens / (avgElapsedMs / 60_000) : 0;
 
 			if (json) {
-				process.stdout.write(
-					`${JSON.stringify({
-						agents: agentData,
-						totals: {
-							inputTokens: totalInput,
-							outputTokens: totalOutput,
-							cacheTokens: totalCacheTokens,
-							costUsd: totalCost,
-							burnRatePerMin,
-							tokensPerMin,
-						},
-					})}\n`,
-				);
+				jsonOutput("costs", {
+					agents: agentData,
+					totals: {
+						inputTokens: totalInput,
+						outputTokens: totalOutput,
+						cacheTokens: totalCacheTokens,
+						costUsd: totalCost,
+						burnRatePerMin,
+						tokensPerMin,
+					},
+				});
 			} else {
 				const w = process.stdout.write.bind(process.stdout);
 				const separator = "\u2500".repeat(70);
@@ -502,7 +512,7 @@ async function executeCosts(opts: CostsOpts): Promise<void> {
 	const metricsFile = Bun.file(metricsDbPath);
 	if (!(await metricsFile.exists())) {
 		if (json) {
-			process.stdout.write("[]\n");
+			jsonOutput("costs", { sessions: [] });
 		} else {
 			process.stdout.write("No metrics data yet.\n");
 		}
@@ -532,9 +542,9 @@ async function executeCosts(opts: CostsOpts): Promise<void> {
 						totals: group.totals,
 					};
 				}
-				process.stdout.write(`${JSON.stringify(grouped)}\n`);
+				jsonOutput("costs", { grouped });
 			} else {
-				process.stdout.write(`${JSON.stringify(sessions)}\n`);
+				jsonOutput("costs", { sessions });
 			}
 			return;
 		}

package/src/commands/dashboard.ts

@@ -15,7 +15,7 @@ import { Command } from "commander";
 import { loadConfig } from "../config.ts";
 import { ValidationError } from "../errors.ts";
 import type { ColorFn } from "../logging/color.ts";
-import { color, noColor, visibleLength } from "../logging/color.ts";
+import { accent, color, noColor, visibleLength } from "../logging/color.ts";
 import { createMailStore, type MailStore } from "../mail/store.ts";
 import { createMergeQueue, type MergeQueue } from "../merge/queue.ts";
 import { createMetricsStore, type MetricsStore } from "../metrics/store.ts";
@@ -404,7 +404,7 @@ async function loadDashboardData(
 function renderHeader(width: number, interval: number, currentRunId?: string | null): string {
 	const left = color.bold(`ov dashboard v${PKG_VERSION}`);
 	const now = new Date().toLocaleTimeString();
-	const scope = currentRunId ? ` [run: ${currentRunId.slice(0, 8)}]` : " [all runs]";
+	const scope = currentRunId ? ` [run: ${accent(currentRunId.slice(0, 8))}]` : " [all runs]";
 	const right = `${now}${scope} | refresh: ${interval}ms`;
 	const padding = width - visibleLength(left) - right.length;
 	const line = left + " ".repeat(Math.max(0, padding)) + right;
@@ -497,10 +497,10 @@ function renderAgentPanel(
 
 		const icon = getStateIcon(agent.state);
 		const stateColor = getStateColor(agent.state);
-		const name = pad(truncate(agent.agentName, 15), 15);
+		const name = accent(pad(truncate(agent.agentName, 15), 15));
 		const capability = pad(truncate(agent.capability, 12), 12);
 		const state = pad(agent.state, 10);
-		const taskId = pad(truncate(agent.taskId, 16), 16);
+		const taskId = accent(pad(truncate(agent.taskId, 16), 16));
 		const endTime =
 			agent.state === "completed" || agent.state === "zombie"
 				? new Date(agent.lastActivity).getTime()
@@ -575,8 +575,8 @@ function renderMailPanel(
 
 		const priorityColorFn = getPriorityColor(msg.priority);
 		const priority = msg.priority === "normal" ? "" : `[${msg.priority}] `;
-		const from = truncate(msg.from, 12);
-		const to = truncate(msg.to, 12);
+		const from = accent(truncate(msg.from, 12));
+		const to = accent(truncate(msg.to, 12));
 		const subject = truncate(msg.subject, panelWidth - 40);
 		const time = timeAgo(msg.createdAt);
 
@@ -643,7 +643,7 @@ function renderMergeQueuePanel(
 
 		const statusColorFn = getMergeStatusColor(entry.status);
 		const status = pad(entry.status, 10);
-		const agent = truncate(entry.agentName, 15);
+		const agent = accent(truncate(entry.agentName, 15));
 		const branch = truncate(entry.branchName, panelWidth - 30);
 
 		const line = `${BOX.vertical} ${statusColorFn(status)} ${agent} ${branch}`;

package/src/commands/doctor.test.ts

@@ -85,10 +85,14 @@ describe("doctorCommand", () => {
 			const out = output();
 
 			const parsed = JSON.parse(out.trim()) as {
+				success: boolean;
+				command: string;
 				checks: unknown[];
 				summary: { pass: number; warn: number; fail: number };
 			};
 			expect(parsed).toBeDefined();
+			expect(parsed.success).toBe(true);
+			expect(parsed.command).toBe("doctor");
 			expect(Array.isArray(parsed.checks)).toBe(true);
 			expect(parsed.summary).toBeDefined();
 			expect(typeof parsed.summary.pass).toBe("number");
@@ -101,9 +105,13 @@ describe("doctorCommand", () => {
 			const out = output();
 
 			const parsed = JSON.parse(out.trim()) as {
+				success: boolean;
+				command: string;
 				checks: unknown[];
 				summary: { pass: number; warn: number; fail: number };
 			};
+			expect(parsed.success).toBe(true);
+			expect(parsed.command).toBe("doctor");
 			expect(parsed.checks).toEqual([]);
 			expect(parsed.summary.pass).toBe(0);
 			expect(parsed.summary.warn).toBe(0);

package/src/commands/doctor.ts

@@ -12,12 +12,14 @@ import { checkConfig } from "../doctor/config-check.ts";
 import { checkConsistency } from "../doctor/consistency.ts";
 import { checkDatabases } from "../doctor/databases.ts";
 import { checkDependencies } from "../doctor/dependencies.ts";
+import { checkEcosystem } from "../doctor/ecosystem.ts";
 import { checkLogs } from "../doctor/logs.ts";
 import { checkMergeQueue } from "../doctor/merge-queue.ts";
 import { checkStructure } from "../doctor/structure.ts";
 import type { DoctorCategory, DoctorCheck, DoctorCheckFn } from "../doctor/types.ts";
 import { checkVersion } from "../doctor/version.ts";
 import { ValidationError } from "../errors.ts";
+import { jsonOutput } from "../json.ts";
 import { color } from "../logging/color.ts";
 
 /** Registry of all check modules in execution order. */
@@ -31,8 +33,25 @@ const ALL_CHECKS: Array<{ category: DoctorCategory; fn: DoctorCheckFn }> = [
 	{ category: "merge", fn: checkMergeQueue },
 	{ category: "logs", fn: checkLogs },
 	{ category: "version", fn: checkVersion },
+	{ category: "ecosystem", fn: checkEcosystem },
 ];
 
+/**
+ * Execute all fix functions on non-passing fixable checks.
+ * Returns a list of human-readable actions taken.
+ */
+async function applyFixes(checks: DoctorCheck[]): Promise<string[]> {
+	const fixable = checks.filter((c) => c.fixable && c.status !== "pass" && c.fix);
+	const fixed: string[] = [];
+	for (const check of fixable) {
+		if (check.fix) {
+			const actions = await check.fix();
+			fixed.push(...actions);
+		}
+	}
+	return fixed;
+}
+
 /**
  * Format human-readable output for doctor checks.
  */
@@ -40,6 +59,7 @@ function printHumanReadable(
 	checks: DoctorCheck[],
 	verbose: boolean,
 	checkRegistry: Array<{ category: DoctorCategory; fn: DoctorCheckFn }>,
+	fixedItems?: string[],
 ): void {
 	const w = process.stdout.write.bind(process.stdout);
 
@@ -104,22 +124,28 @@ function printHumanReadable(
 	w(
 		`${color.bold("Summary:")} ${color.green(`${pass} passed`)}, ${color.yellow(`${warn} warning${warn === 1 ? "" : "s"}`)}, ${color.red(`${fail} failure${fail === 1 ? "" : "s"}`)}\n`,
 	);
+
+	if (fixedItems && fixedItems.length > 0) {
+		w(`\n${color.bold("Fixed:")}\n`);
+		for (const item of fixedItems) {
+			w(`  ${color.green("-")} ${item}\n`);
+		}
+	}
 }
 
 /**
  * Format JSON output for doctor checks.
  */
-function printJSON(checks: DoctorCheck[]): void {
+function printJSON(checks: DoctorCheck[], fixed?: string[]): void {
 	const pass = checks.filter((c) => c.status === "pass").length;
 	const warn = checks.filter((c) => c.status === "warn").length;
 	const fail = checks.filter((c) => c.status === "fail").length;
 
-	const output = {
+	jsonOutput("doctor", {
 		checks,
 		summary: { pass, warn, fail },
-	};
-
-	process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+		...(fixed && fixed.length > 0 ? { fixed } : {}),
+	});
 }
 
 /** Options for dependency injection in doctorCommand. */
@@ -137,59 +163,78 @@ export function createDoctorCommand(options?: DoctorCommandOptions): Command {
 		.option("--json", "Output as JSON")
 		.option("--verbose", "Show passing checks (default: only problems)")
 		.option("--category <name>", "Run only one category")
+		.option("--fix", "Attempt to auto-fix issues")
 		.addHelpText(
 			"after",
-			"\nCategories: dependencies, structure, config, databases, consistency, agents, merge, logs, version",
+			"\nCategories: dependencies, structure, config, databases, consistency, agents, merge, logs, version, ecosystem",
 		)
-		.action(async (opts: { json?: boolean; verbose?: boolean; category?: string }) => {
-			const json = opts.json ?? false;
-			const verbose = opts.verbose ?? false;
-			const categoryFilter = opts.category;
-
-			// Validate category filter if provided
-			if (categoryFilter !== undefined) {
-				const validCategories = ALL_CHECKS.map((c) => c.category);
-				if (!validCategories.includes(categoryFilter as DoctorCategory)) {
-					throw new ValidationError(
-						`Invalid category: ${categoryFilter}. Valid categories: ${validCategories.join(", ")}`,
-						{
-							field: "category",
-							value: categoryFilter,
-						},
-					);
+		.action(
+			async (opts: { json?: boolean; verbose?: boolean; category?: string; fix?: boolean }) => {
+				const json = opts.json ?? false;
+				const verbose = opts.verbose ?? false;
+				const categoryFilter = opts.category;
+				const fix = opts.fix ?? false;
+
+				// Validate category filter if provided
+				if (categoryFilter !== undefined) {
+					const validCategories = ALL_CHECKS.map((c) => c.category);
+					if (!validCategories.includes(categoryFilter as DoctorCategory)) {
+						throw new ValidationError(
+							`Invalid category: ${categoryFilter}. Valid categories: ${validCategories.join(", ")}`,
+							{
+								field: "category",
+								value: categoryFilter,
+							},
+						);
+					}
 				}
-			}
 
-			const cwd = process.cwd();
-			const config = await loadConfig(cwd);
-			const overstoryDir = join(config.project.root, ".overstory");
-
-			// Filter checks by category if specified
-			const allChecks = options?.checkRunners ?? ALL_CHECKS;
-			const checksToRun = categoryFilter
-				? allChecks.filter((c) => c.category === categoryFilter)
-				: allChecks;
-
-			// Run all checks sequentially
-			const results: DoctorCheck[] = [];
-			for (const { fn } of checksToRun) {
-				const checkResults = await fn(config, overstoryDir);
-				results.push(...checkResults);
-			}
+				const cwd = process.cwd();
+				const config = await loadConfig(cwd);
+				const overstoryDir = join(config.project.root, ".overstory");
 
-			// Output results
-			if (json) {
-				printJSON(results);
-			} else {
-				printHumanReadable(results, verbose, allChecks);
-			}
+				// Filter checks by category if specified
+				const allChecks = options?.checkRunners ?? ALL_CHECKS;
+				const checksToRun = categoryFilter
+					? allChecks.filter((c) => c.category === categoryFilter)
+					: allChecks;
 
-			// Set exit code if any check failed
-			const hasFailures = results.some((c) => c.status === "fail");
-			if (hasFailures) {
-				process.exitCode = 1;
-			}
-		});
+				// Run all checks sequentially
+				let results: DoctorCheck[] = [];
+				for (const { fn } of checksToRun) {
+					const checkResults = await fn(config, overstoryDir);
+					results.push(...checkResults);
+				}
+
+				// Apply fixes if requested
+				let fixedItems: string[] | undefined;
+				if (fix) {
+					const applied = await applyFixes(results);
+					if (applied.length > 0) {
+						fixedItems = applied;
+						// Re-run all checks to get fresh results after fixes
+						results = [];
+						for (const { fn } of checksToRun) {
+							const checkResults = await fn(config, overstoryDir);
+							results.push(...checkResults);
+						}
+					}
+				}
+
+				// Output results
+				if (json) {
+					printJSON(results, fixedItems);
+				} else {
+					printHumanReadable(results, verbose, allChecks, fixedItems);
+				}
+
+				// Set exit code if any check failed
+				const hasFailures = results.some((c) => c.status === "fail");
+				if (hasFailures) {
+					process.exitCode = 1;
+				}
+			},
+		);
 }
 
 /**