@os-eco/overstory-cli 0.6.8 → 0.6.9

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

@@ -18,6 +18,7 @@ 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. */
@@ -114,12 +115,7 @@ function printJSON(checks: DoctorCheck[]): void {
 	const warn = checks.filter((c) => c.status === "warn").length;
 	const fail = checks.filter((c) => c.status === "fail").length;
 
-	const output = {
-		checks,
-		summary: { pass, warn, fail },
-	};
-
-	process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+	jsonOutput("doctor", { checks, summary: { pass, warn, fail } });
 }
 
 /** Options for dependency injection in doctorCommand. */

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 () => {

package/src/commands/feed.ts

@@ -11,6 +11,7 @@ import { Command } from "commander";
 import { loadConfig } from "../config.ts";
 import { ValidationError } from "../errors.ts";
 import { createEventStore } from "../events/store.ts";
+import { jsonOutput } from "../json.ts";
 import type { ColorFn } from "../logging/color.ts";
 import { color } from "../logging/color.ts";
 import type { EventType, StoredEvent } from "../types.ts";
@@ -189,7 +190,7 @@ async function executeFeed(opts: FeedOpts): Promise<void> {
 	const eventsFile = Bun.file(eventsDbPath);
 	if (!(await eventsFile.exists())) {
 		if (json) {
-			process.stdout.write("[]\n");
+			jsonOutput("feed", { events: [] });
 		} else {
 			process.stdout.write("No events data yet.\n");
 		}
@@ -228,7 +229,7 @@ async function executeFeed(opts: FeedOpts): Promise<void> {
 			const events = queryEvents({ since, limit });
 
 			if (json) {
-				process.stdout.write(`${JSON.stringify(events)}\n`);
+				jsonOutput("feed", { events });
 				return;
 			}