@os-eco/overstory-cli 0.6.8 → 0.6.10

package/src/commands/ecosystem.ts

@@ -0,0 +1,291 @@
+/**
+ * CLI command: ov ecosystem
+ *
+ * Shows a summary dashboard of all installed os-eco tools: version, update
+ * status (latest vs outdated), and doctor health (overstory only).
+ */
+
+import { Command } from "commander";
+import { jsonError, jsonOutput } from "../json.ts";
+import { accent, brand, color, muted } from "../logging/color.ts";
+
+const TOOLS = [
+	{ name: "overstory", cli: "ov", npm: "@os-eco/overstory-cli" },
+	{ name: "mulch", cli: "ml", npm: "@os-eco/mulch-cli" },
+	{ name: "seeds", cli: "sd", npm: "@os-eco/seeds-cli" },
+	{ name: "canopy", cli: "cn", npm: "@os-eco/canopy-cli" },
+] as const;
+
+export interface EcosystemOptions {
+	json?: boolean;
+}
+
+interface DoctorSummary {
+	pass: number;
+	warn: number;
+	fail: number;
+}
+
+interface ToolResult {
+	name: string;
+	cli: string;
+	npm: string;
+	installed: boolean;
+	version?: string;
+	latest?: string;
+	upToDate?: boolean;
+	doctorSummary?: DoctorSummary;
+	latestError?: string;
+}
+
+async function getInstalledVersion(cli: string): Promise<string | null> {
+	// Try --version --json first
+	try {
+		const proc = Bun.spawn([cli, "--version", "--json"], {
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		const exitCode = await proc.exited;
+		if (exitCode === 0) {
+			const stdout = await new Response(proc.stdout).text();
+			try {
+				const data = JSON.parse(stdout.trim()) as { version?: string };
+				if (data.version) return data.version;
+			} catch {
+				// Not valid JSON, fall through to plain text
+			}
+		}
+	} catch {
+		// CLI not found — fall through to plain text fallback
+	}
+
+	// Fallback: --version plain text
+	try {
+		const proc = Bun.spawn([cli, "--version"], {
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		const exitCode = await proc.exited;
+		if (exitCode === 0) {
+			const stdout = await new Response(proc.stdout).text();
+			const match = stdout.match(/(\d+\.\d+\.\d+)/);
+			if (match?.[1]) return match[1];
+		}
+	} catch {
+		// CLI not found
+	}
+
+	return null;
+}
+
+async function fetchLatestVersion(packageName: string): Promise<string> {
+	const res = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
+	if (!res.ok) {
+		throw new Error(`npm registry error: ${res.status} ${res.statusText}`);
+	}
+	const data = (await res.json()) as { version: string };
+	return data.version;
+}
+
+async function getDoctorSummary(): Promise<DoctorSummary | undefined> {
+	try {
+		const proc = Bun.spawn(["ov", "doctor", "--json"], {
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		await proc.exited;
+		const stdout = await new Response(proc.stdout).text();
+		const trimmed = stdout.trim();
+		if (trimmed) {
+			const data = JSON.parse(trimmed) as {
+				summary?: { pass?: number; warn?: number; fail?: number };
+			};
+			if (data.summary) {
+				return {
+					pass: data.summary.pass ?? 0,
+					warn: data.summary.warn ?? 0,
+					fail: data.summary.fail ?? 0,
+				};
+			}
+		}
+	} catch {
+		// Doctor failed — report nothing
+	}
+	return undefined;
+}
+
+async function checkTool(tool: { name: string; cli: string; npm: string }): Promise<ToolResult> {
+	const version = await getInstalledVersion(tool.cli);
+
+	if (version === null) {
+		return { name: tool.name, cli: tool.cli, npm: tool.npm, installed: false };
+	}
+
+	let latest: string | undefined;
+	let latestError: string | undefined;
+	let doctorSummary: DoctorSummary | undefined;
+
+	const latestPromise = fetchLatestVersion(tool.npm)
+		.then((v) => {
+			latest = v;
+		})
+		.catch((err) => {
+			latestError = err instanceof Error ? err.message : String(err);
+		});
+
+	const doctorPromise =
+		tool.name === "overstory"
+			? getDoctorSummary().then((d) => {
+					doctorSummary = d;
+				})
+			: Promise.resolve();
+
+	await Promise.all([latestPromise, doctorPromise]);
+
+	const upToDate = latest !== undefined ? version === latest : undefined;
+
+	return {
+		name: tool.name,
+		cli: tool.cli,
+		npm: tool.npm,
+		installed: true,
+		version,
+		latest,
+		upToDate,
+		doctorSummary,
+		latestError,
+	};
+}
+
+function formatDoctorLine(summary: DoctorSummary): string {
+	const parts: string[] = [];
+	if (summary.pass > 0) parts.push(color.green(`${summary.pass} passed`));
+	if (summary.warn > 0) parts.push(color.yellow(`${summary.warn} warn`));
+	if (summary.fail > 0) parts.push(color.red(`${summary.fail} fail`));
+	return parts.length > 0 ? parts.join(", ") : "no checks";
+}
+
+function printHumanOutput(results: ToolResult[]): void {
+	process.stdout.write(`${brand.bold("os-eco Ecosystem")}\n`);
+	process.stdout.write(`${"═".repeat(60)}\n`);
+	process.stdout.write("\n");
+
+	for (const tool of results) {
+		if (!tool.installed) {
+			process.stdout.write(
+				`  ${color.red("x")} ${accent(tool.name)} ${muted(`(${tool.cli})`)}  ${color.red("not installed")}\n`,
+			);
+			process.stdout.write(`    ${muted(`npm i -g ${tool.npm}`)}\n`);
+			process.stdout.write("\n");
+			continue;
+		}
+
+		// Determine status icon
+		let icon: string;
+		if (tool.latestError !== undefined || tool.upToDate === undefined) {
+			icon = muted("-");
+		} else if (tool.upToDate) {
+			icon = color.green("-");
+		} else {
+			icon = color.yellow("!");
+		}
+
+		process.stdout.write(`  ${icon} ${accent(tool.name)} ${muted(`(${tool.cli})`)}\n`);
+
+		// Version line
+		let versionLine = `Version: ${tool.version}`;
+		if (tool.latestError !== undefined) {
+			versionLine += ` ${muted("(version check failed)")}`;
+		} else if (tool.upToDate === true) {
+			versionLine += ` ${color.green("(up to date)")}`;
+		} else if (tool.upToDate === false) {
+			versionLine += ` ${color.yellow(`(outdated, latest: ${tool.latest})`)}`;
+		}
+		process.stdout.write(`    ${versionLine}\n`);
+
+		// Doctor summary (overstory only)
+		if (tool.doctorSummary !== undefined) {
+			process.stdout.write(`    Doctor:  ${formatDoctorLine(tool.doctorSummary)}\n`);
+		}
+
+		process.stdout.write("\n");
+	}
+
+	const installed = results.filter((t) => t.installed).length;
+	const missing = results.filter((t) => !t.installed).length;
+	const outdated = results.filter(
+		(t) => t.installed && t.upToDate === false && t.latestError === undefined,
+	).length;
+
+	let summary = `Summary: ${installed}/${results.length} installed`;
+	if (missing > 0) summary += `, ${missing} missing`;
+	if (outdated > 0) summary += `, ${outdated} outdated`;
+	process.stdout.write(`${summary}\n`);
+}
+
+export async function executeEcosystem(opts: EcosystemOptions): Promise<void> {
+	const json = opts.json ?? false;
+
+	let results: ToolResult[];
+	try {
+		results = await Promise.all(TOOLS.map((tool) => checkTool(tool)));
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		if (json) {
+			jsonError("ecosystem", msg);
+		} else {
+			process.stderr.write(`Error: ${msg}\n`);
+		}
+		process.exitCode = 1;
+		return;
+	}
+
+	if (json) {
+		const installed = results.filter((t) => t.installed).length;
+		const missing = results.filter((t) => !t.installed).length;
+		const outdated = results.filter(
+			(t) => t.installed && t.upToDate === false && t.latestError === undefined,
+		).length;
+
+		jsonOutput("ecosystem", {
+			tools: results.map((t) => {
+				const entry: Record<string, unknown> = {
+					name: t.name,
+					cli: t.cli,
+					npm: t.npm,
+					installed: t.installed,
+				};
+				if (t.installed) {
+					entry.version = t.version;
+					entry.latest = t.latest;
+					entry.upToDate = t.upToDate;
+					if (t.doctorSummary !== undefined) {
+						entry.doctorSummary = t.doctorSummary;
+					}
+					if (t.latestError !== undefined) {
+						entry.latestError = t.latestError;
+					}
+				}
+				return entry;
+			}),
+			summary: {
+				total: results.length,
+				installed,
+				missing,
+				outdated,
+			},
+		});
+		return;
+	}
+
+	printHumanOutput(results);
+}
+
+export function createEcosystemCommand(): Command {
+	return new Command("ecosystem")
+		.description("Show a summary dashboard of all installed os-eco tools")
+		.option("--json", "Output as JSON")
+		.action(async (opts: EcosystemOptions) => {
+			await executeEcosystem(opts);
+		});
+}

package/src/commands/errors.test.ts

@@ -133,7 +133,14 @@ describe("errorsCommand", () => {
 			await errorsCommand(["--json"]);
 			const out = output();
 
-			expect(out).toBe("[]\n");
+			const parsed = JSON.parse(out.trim()) as {
+				success: boolean;
+				command: string;
+				events: unknown[];
+			};
+			expect(parsed.success).toBe(true);
+			expect(parsed.command).toBe("errors");
+			expect(parsed.events).toEqual([]);
 		});
 	});
 
@@ -157,9 +164,9 @@ describe("errorsCommand", () => {
 			await errorsCommand(["--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toHaveLength(2);
-			expect(Array.isArray(parsed)).toBe(true);
+			const parsed = JSON.parse(out.trim()) as { events: unknown[] };
+			expect(parsed.events).toHaveLength(2);
+			expect(Array.isArray(parsed.events)).toBe(true);
 		});
 
 		test("JSON output includes expected fields", async () => {
@@ -176,9 +183,9 @@ describe("errorsCommand", () => {
 			await errorsCommand(["--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Record<string, unknown>[];
-			expect(parsed).toHaveLength(1);
-			const event = parsed[0];
+			const parsed = JSON.parse(out.trim()) as { events: Record<string, unknown>[] };
+			expect(parsed.events).toHaveLength(1);
+			const event = parsed.events[0];
 			expect(event).toBeDefined();
 			expect(event?.agentName).toBe("builder-1");
 			expect(event?.eventType).toBe("error");
@@ -201,8 +208,8 @@ describe("errorsCommand", () => {
 			await errorsCommand(["--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toEqual([]);
+			const parsed = JSON.parse(out.trim()) as { events: unknown[] };
+			expect(parsed.events).toEqual([]);
 		});
 	});
 
@@ -388,9 +395,9 @@ describe("errorsCommand", () => {
 			await errorsCommand(["--agent", "builder-1", "--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Record<string, unknown>[];
-			expect(parsed).toHaveLength(2);
-			for (const event of parsed) {
+			const parsed = JSON.parse(out.trim()) as { events: Record<string, unknown>[] };
+			expect(parsed.events).toHaveLength(2);
+			for (const event of parsed.events) {
 				expect(event.agentName).toBe("builder-1");
 			}
 		});
@@ -404,8 +411,8 @@ describe("errorsCommand", () => {
 			await errorsCommand(["--agent", "nonexistent", "--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toEqual([]);
+			const parsed = JSON.parse(out.trim()) as { events: unknown[] };
+			expect(parsed.events).toEqual([]);
 		});
 
 		test("only returns error-level events for the agent", async () => {
@@ -431,9 +438,9 @@ describe("errorsCommand", () => {
 			await errorsCommand(["--agent", "builder-1", "--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Record<string, unknown>[];
-			expect(parsed).toHaveLength(1);
-			expect(parsed[0]?.level).toBe("error");
+			const parsed = JSON.parse(out.trim()) as { events: Record<string, unknown>[] };
+			expect(parsed.events).toHaveLength(1);
+			expect(parsed.events[0]?.level).toBe("error");
 		});
 	});
 
@@ -451,9 +458,9 @@ describe("errorsCommand", () => {
 			await errorsCommand(["--run", "run-001", "--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Record<string, unknown>[];
-			expect(parsed).toHaveLength(2);
-			for (const event of parsed) {
+			const parsed = JSON.parse(out.trim()) as { events: Record<string, unknown>[] };
+			expect(parsed.events).toHaveLength(2);
+			for (const event of parsed.events) {
 				expect(event.runId).toBe("run-001");
 			}
 		});
@@ -467,8 +474,8 @@ describe("errorsCommand", () => {
 			await errorsCommand(["--run", "run-999", "--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toEqual([]);
+			const parsed = JSON.parse(out.trim()) as { events: unknown[] };
+			expect(parsed.events).toEqual([]);
 		});
 
 		test("only returns error-level events for the run", async () => {
@@ -487,9 +494,9 @@ describe("errorsCommand", () => {
 			await errorsCommand(["--run", "run-001", "--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Record<string, unknown>[];
-			expect(parsed).toHaveLength(1);
-			expect(parsed[0]?.level).toBe("error");
+			const parsed = JSON.parse(out.trim()) as { events: Record<string, unknown>[] };
+			expect(parsed.events).toHaveLength(1);
+			expect(parsed.events[0]?.level).toBe("error");
 		});
 	});
 
@@ -507,8 +514,8 @@ describe("errorsCommand", () => {
 			await errorsCommand(["--json", "--limit", "3"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toHaveLength(3);
+			const parsed = JSON.parse(out.trim()) as { events: unknown[] };
+			expect(parsed.events).toHaveLength(3);
 		});
 
 		test("default limit is 100", async () => {
@@ -522,8 +529,8 @@ describe("errorsCommand", () => {
 			await errorsCommand(["--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toHaveLength(100);
+			const parsed = JSON.parse(out.trim()) as { events: unknown[] };
+			expect(parsed.events).toHaveLength(100);
 		});
 	});
 
@@ -539,8 +546,8 @@ describe("errorsCommand", () => {
 			await errorsCommand(["--json", "--since", "2099-01-01T00:00:00Z"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toEqual([]);
+			const parsed = JSON.parse(out.trim()) as { events: unknown[] };
+			expect(parsed.events).toEqual([]);
 		});
 
 		test("--since with past timestamp returns all errors", async () => {
@@ -553,8 +560,8 @@ describe("errorsCommand", () => {
 			await errorsCommand(["--json", "--since", "2020-01-01T00:00:00Z"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toHaveLength(2);
+			const parsed = JSON.parse(out.trim()) as { events: unknown[] };
+			expect(parsed.events).toHaveLength(2);
 		});
 
 		test("--until with past timestamp returns no errors", async () => {
@@ -566,8 +573,8 @@ describe("errorsCommand", () => {
 			await errorsCommand(["--json", "--until", "2000-01-01T00:00:00Z"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toEqual([]);
+			const parsed = JSON.parse(out.trim()) as { events: unknown[] };
+			expect(parsed.events).toEqual([]);
 		});
 	});
 
@@ -608,8 +615,8 @@ describe("errorsCommand", () => {
 			await errorsCommand(["--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toHaveLength(3);
+			const parsed = JSON.parse(out.trim()) as { events: unknown[] };
+			expect(parsed.events).toHaveLength(3);
 		});
 
 		test("excludes non-error events from global view", async () => {
@@ -639,9 +646,9 @@ describe("errorsCommand", () => {
 			await errorsCommand(["--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Record<string, unknown>[];
-			expect(parsed).toHaveLength(1);
-			expect(parsed[0]?.level).toBe("error");
+			const parsed = JSON.parse(out.trim()) as { events: Record<string, unknown>[] };
+			expect(parsed.events).toHaveLength(1);
+			expect(parsed.events[0]?.level).toBe("error");
 		});
 	});
 });

package/src/commands/errors.ts

@@ -11,7 +11,8 @@ import { Command } from "commander";
 import { loadConfig } from "../config.ts";
 import { ValidationError } from "../errors.ts";
 import { createEventStore } from "../events/store.ts";
-import { color } from "../logging/color.ts";
+import { jsonOutput } from "../json.ts";
+import { accent, color } from "../logging/color.ts";
 import type { StoredEvent } from "../types.ts";
 
 /**
@@ -115,7 +116,7 @@ function printErrors(events: StoredEvent[]): void {
 		firstGroup = false;
 
 		w(
-			`${color.bold(agentName)} ${color.dim(`(${agentEvents.length} error${agentEvents.length === 1 ? "" : "s"})`)}\n`,
+			`${accent(agentName)} ${color.dim(`(${agentEvents.length} error${agentEvents.length === 1 ? "" : "s"})`)}\n`,
 		);
 
 		for (const event of agentEvents) {
@@ -179,7 +180,7 @@ async function executeErrors(opts: ErrorsOpts): Promise<void> {
 	const eventsFile = Bun.file(eventsDbPath);
 	if (!(await eventsFile.exists())) {
 		if (json) {
-			process.stdout.write("[]\n");
+			jsonOutput("errors", { events: [] });
 		} else {
 			process.stdout.write("No events data yet.\n");
 		}
@@ -209,7 +210,7 @@ async function executeErrors(opts: ErrorsOpts): Promise<void> {
 		}
 
 		if (json) {
-			process.stdout.write(`${JSON.stringify(events)}\n`);
+			jsonOutput("errors", { events });
 			return;
 		}
 

package/src/commands/feed.test.ts

@@ -138,7 +138,14 @@ describe("feedCommand", () => {
 			await feedCommand(["--json"]);
 			const out = output();
 
-			expect(out).toBe("[]\n");
+			const parsed = JSON.parse(out.trim()) as {
+				success: boolean;
+				command: string;
+				events: unknown[];
+			};
+			expect(parsed.success).toBe(true);
+			expect(parsed.command).toBe("feed");
+			expect(parsed.events).toEqual([]);
 		});
 	});
 
@@ -156,9 +163,9 @@ describe("feedCommand", () => {
 			await feedCommand(["--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toHaveLength(3);
-			expect(Array.isArray(parsed)).toBe(true);
+			const parsed = JSON.parse(out.trim()) as { events: unknown[] };
+			expect(parsed.events).toHaveLength(3);
+			expect(Array.isArray(parsed.events)).toBe(true);
 		});
 
 		test("JSON output includes expected fields", async () => {
@@ -177,9 +184,9 @@ describe("feedCommand", () => {
 			await feedCommand(["--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Record<string, unknown>[];
-			expect(parsed).toHaveLength(1);
-			const event = parsed[0];
+			const parsed = JSON.parse(out.trim()) as { events: Record<string, unknown>[] };
+			expect(parsed.events).toHaveLength(1);
+			const event = parsed.events[0];
 			expect(event).toBeDefined();
 			expect(event?.agentName).toBe("builder-1");
 			expect(event?.eventType).toBe("tool_start");
@@ -198,8 +205,8 @@ describe("feedCommand", () => {
 			await feedCommand(["--json", "--since", "2099-01-01T00:00:00Z"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toEqual([]);
+			const parsed = JSON.parse(out.trim()) as { events: unknown[] };
+			expect(parsed.events).toEqual([]);
 		});
 	});
 
@@ -317,9 +324,9 @@ describe("feedCommand", () => {
 			await feedCommand(["--agent", "builder-1", "--json"]);
 			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 { events: Record<string, unknown>[] };
+			expect(parsed.events).toHaveLength(1);
+			expect(parsed.events[0]?.agentName).toBe("builder-1");
 		});
 
 		test("filters to multiple agents", async () => {
@@ -333,9 +340,9 @@ describe("feedCommand", () => {
 			await feedCommand(["--agent", "builder-1", "--agent", "scout-1", "--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Record<string, unknown>[];
-			expect(parsed).toHaveLength(2);
-			const agents = parsed.map((e) => e.agentName);
+			const parsed = JSON.parse(out.trim()) as { events: Record<string, unknown>[] };
+			expect(parsed.events).toHaveLength(2);
+			const agents = parsed.events.map((e) => e.agentName);
 			expect(agents).toContain("builder-1");
 			expect(agents).toContain("scout-1");
 			expect(agents).not.toContain("builder-2");
@@ -356,9 +363,9 @@ describe("feedCommand", () => {
 			await feedCommand(["--run", "run-001", "--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Record<string, unknown>[];
-			expect(parsed).toHaveLength(2);
-			for (const event of parsed) {
+			const parsed = JSON.parse(out.trim()) as { events: Record<string, unknown>[] };
+			expect(parsed.events).toHaveLength(2);
+			for (const event of parsed.events) {
 				expect(event.runId).toBe("run-001");
 			}
 		});
@@ -378,8 +385,8 @@ describe("feedCommand", () => {
 			await feedCommand(["--json", "--limit", "10"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toHaveLength(10);
+			const parsed = JSON.parse(out.trim()) as { events: unknown[] };
+			expect(parsed.events).toHaveLength(10);
 		});
 
 		test("default limit is 50", async () => {
@@ -393,8 +400,8 @@ describe("feedCommand", () => {
 			await feedCommand(["--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toHaveLength(50);
+			const parsed = JSON.parse(out.trim()) as { events: unknown[] };
+			expect(parsed.events).toHaveLength(50);
 		});
 	});
 
@@ -411,8 +418,8 @@ describe("feedCommand", () => {
 			await feedCommand(["--json", "--since", "2099-01-01T00:00:00Z"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toEqual([]);
+			const parsed = JSON.parse(out.trim()) as { events: unknown[] };
+			expect(parsed.events).toEqual([]);
 		});
 
 		test("--since with past timestamp returns all events", async () => {
@@ -425,8 +432,8 @@ describe("feedCommand", () => {
 			await feedCommand(["--json", "--since", "2020-01-01T00:00:00Z"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toHaveLength(2);
+			const parsed = JSON.parse(out.trim()) as { events: unknown[] };
+			expect(parsed.events).toHaveLength(2);
 		});
 
 		test("default since is 5 minutes ago", async () => {
@@ -440,8 +447,8 @@ describe("feedCommand", () => {
 			await feedCommand(["--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toHaveLength(1);
+			const parsed = JSON.parse(out.trim()) as { events: unknown[] };
+			expect(parsed.events).toHaveLength(1);
 		});
 	});
 
@@ -503,11 +510,11 @@ describe("feedCommand", () => {
 			await feedCommand(["--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Record<string, unknown>[];
-			expect(parsed).toHaveLength(3);
-			expect(parsed[0]?.eventType).toBe("session_start");
-			expect(parsed[1]?.eventType).toBe("tool_start");
-			expect(parsed[2]?.eventType).toBe("session_end");
+			const parsed = JSON.parse(out.trim()) as { events: Record<string, unknown>[] };
+			expect(parsed.events).toHaveLength(3);
+			expect(parsed.events[0]?.eventType).toBe("session_start");
+			expect(parsed.events[1]?.eventType).toBe("tool_start");
+			expect(parsed.events[2]?.eventType).toBe("session_end");
 		});
 
 		test("handles event with all null optional fields", async () => {