@os-eco/overstory-cli 0.6.8 → 0.6.9

package/src/commands/metrics.ts

@@ -8,6 +8,7 @@
 import { join } from "node:path";
 import { Command } from "commander";
 import { loadConfig } from "../config.ts";
+import { jsonOutput } from "../json.ts";
 import { createMetricsStore } from "../metrics/store.ts";
 
 interface MetricsOpts {
@@ -41,7 +42,7 @@ async function executeMetrics(opts: MetricsOpts): Promise<void> {
 	const dbFile = Bun.file(dbPath);
 	if (!(await dbFile.exists())) {
 		if (json) {
-			process.stdout.write('{"sessions":[]}\n');
+			jsonOutput("metrics", { sessions: [] });
 		} else {
 			process.stdout.write("No metrics data yet.\n");
 		}
@@ -54,7 +55,7 @@ async function executeMetrics(opts: MetricsOpts): Promise<void> {
 		const sessions = store.getRecentSessions(limit);
 
 		if (json) {
-			process.stdout.write(`${JSON.stringify({ sessions })}\n`);
+			jsonOutput("metrics", { sessions } as Record<string, unknown>);
 			return;
 		}
 

package/src/commands/monitor.ts

@@ -21,6 +21,7 @@ import { createIdentity, loadIdentity } from "../agents/identity.ts";
 import { createManifestLoader, resolveModel } from "../agents/manifest.ts";
 import { loadConfig } from "../config.ts";
 import { AgentError, ValidationError } from "../errors.ts";
+import { jsonOutput } from "../json.ts";
 import { printHint, printSuccess } from "../logging/color.ts";
 import { openSessionStore } from "../sessions/compat.ts";
 import type { AgentSession } from "../types.ts";
@@ -190,7 +191,7 @@ async function startMonitor(opts: { json: boolean; attach: boolean }): Promise<v
 		};
 
 		if (json) {
-			process.stdout.write(`${JSON.stringify(output)}\n`);
+			jsonOutput("monitor start", output);
 		} else {
 			printSuccess("Monitor started");
 			process.stdout.write(`  Tmux:    ${tmuxSession}\n`);
@@ -248,7 +249,7 @@ async function stopMonitor(opts: { json: boolean }): Promise<void> {
 		store.updateLastActivity(MONITOR_NAME);
 
 		if (json) {
-			process.stdout.write(`${JSON.stringify({ stopped: true, sessionId: session.id })}\n`);
+			jsonOutput("monitor stop", { stopped: true, sessionId: session.id });
 		} else {
 			printSuccess("Monitor stopped", session.id);
 		}
@@ -280,7 +281,7 @@ async function statusMonitor(opts: { json: boolean }): Promise<void> {
 			session.state === "zombie"
 		) {
 			if (json) {
-				process.stdout.write(`${JSON.stringify({ running: false })}\n`);
+				jsonOutput("monitor status", { running: false });
 			} else {
 				printHint("Monitor is not running");
 			}
@@ -307,7 +308,7 @@ async function statusMonitor(opts: { json: boolean }): Promise<void> {
 		};
 
 		if (json) {
-			process.stdout.write(`${JSON.stringify(status)}\n`);
+			jsonOutput("monitor status", status);
 		} else {
 			const stateLabel = alive ? "running" : session.state;
 			process.stdout.write(`Monitor: ${stateLabel}\n`);

package/src/commands/nudge.ts

@@ -13,6 +13,7 @@ import { join } from "node:path";
 import { Command } from "commander";
 import { AgentError } from "../errors.ts";
 import { createEventStore } from "../events/store.ts";
+import { jsonOutput } from "../json.ts";
 import { printSuccess } from "../logging/color.ts";
 import { openSessionStore } from "../sessions/compat.ts";
 import type { EventStore } from "../types.ts";
@@ -310,9 +311,7 @@ export async function nudgeCommand(args: string[]): Promise<void> {
 				const result = await nudgeAgent(projectRoot, agentName, message, opts.force ?? false);
 
 				if (opts.json) {
-					process.stdout.write(
-						`${JSON.stringify({ agentName, delivered: result.delivered, reason: result.reason })}\n`,
-					);
+					jsonOutput("nudge", { agentName, delivered: result.delivered, reason: result.reason });
 				} else if (result.delivered) {
 					printSuccess("Nudge delivered", agentName);
 				} else {

package/src/commands/prime.test.ts

@@ -62,10 +62,6 @@ describe("primeCommand", () => {
 		return chunks.join("");
 	}
 
-	function stderr(): string {
-		return stderrChunks.join("");
-	}
-
 	describe("Orchestrator priming (no --agent flag)", () => {
 		test("default prime outputs project context", async () => {
 			await primeCommand({});
@@ -113,12 +109,11 @@ describe("primeCommand", () => {
 		test("unknown agent outputs basic context and warns", async () => {
 			await primeCommand({ agent: "unknown-agent" });
 			const out = output();
-			const err = stderr();
 
 			expect(out).toContain("# Agent Context: unknown-agent");
 			expect(out).toContain("## Identity");
 			expect(out).toContain("New agent - no prior sessions");
-			expect(err).toContain('Warning: agent "unknown-agent" not found');
+			expect(out).toContain('agent "unknown-agent" not found');
 		});
 
 		test("agent with identity.yaml shows identity details", async () => {

package/src/commands/prime.ts

@@ -12,6 +12,7 @@ import { loadCheckpoint } from "../agents/checkpoint.ts";
 import { loadIdentity } from "../agents/identity.ts";
 import { createManifestLoader } from "../agents/manifest.ts";
 import { loadConfig } from "../config.ts";
+import { printWarning } from "../logging/color.ts";
 import { createMetricsStore } from "../metrics/store.ts";
 import { createMulchClient } from "../mulch/client.ts";
 import { openSessionStore } from "../sessions/compat.ts";
@@ -211,9 +212,7 @@ async function outputAgentContext(
 
 	// Warn if agent is completely unknown (no session and no identity)
 	if (!sessionExists && identity === null) {
-		process.stderr.write(
-			`Warning: agent "${agentName}" not found in sessions or identity store.\n`,
-		);
+		printWarning(`agent "${agentName}" not found in sessions or identity store.`);
 	}
 
 	sections.push("\n## Identity");

package/src/commands/replay.test.ts

@@ -133,7 +133,14 @@ describe("replayCommand", () => {
 			await replayCommand(["--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("replay");
+			expect(parsed.events).toEqual([]);
 		});
 	});
 
@@ -151,9 +158,9 @@ describe("replayCommand", () => {
 			await replayCommand(["--run", "run-001", "--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 () => {
@@ -172,9 +179,9 @@ describe("replayCommand", () => {
 			await replayCommand(["--run", "run-001", "--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");
@@ -192,8 +199,8 @@ describe("replayCommand", () => {
 			await replayCommand(["--run", "run-001", "--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([]);
 		});
 	});
 
@@ -332,9 +339,9 @@ describe("replayCommand", () => {
 			await replayCommand(["--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");
 			}
 		});
@@ -349,8 +356,8 @@ describe("replayCommand", () => {
 			await replayCommand(["--run", "run-001", "--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([]);
 		});
 	});
 
@@ -368,9 +375,9 @@ describe("replayCommand", () => {
 			await replayCommand(["--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");
 			}
 		});
@@ -387,9 +394,9 @@ describe("replayCommand", () => {
 			await replayCommand(["--agent", "builder-1", "--agent", "scout-1", "--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Record<string, unknown>[];
-			expect(parsed).toHaveLength(3);
-			const agents = new Set(parsed.map((e) => e.agentName));
+			const parsed = JSON.parse(out.trim()) as { events: Record<string, unknown>[] };
+			expect(parsed.events).toHaveLength(3);
+			const agents = new Set(parsed.events.map((e) => e.agentName));
 			expect(agents.has("builder-1")).toBe(true);
 			expect(agents.has("scout-1")).toBe(true);
 			expect(agents.has("reviewer-1")).toBe(false);
@@ -407,12 +414,12 @@ describe("replayCommand", () => {
 			await replayCommand(["--agent", "builder-1", "--agent", "scout-1", "--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Record<string, unknown>[];
-			expect(parsed).toHaveLength(3);
+			const parsed = JSON.parse(out.trim()) as { events: Record<string, unknown>[] };
+			expect(parsed.events).toHaveLength(3);
 			// They should be in chronological order
-			for (let i = 1; i < parsed.length; i++) {
-				const prev = parsed[i - 1];
-				const curr = parsed[i];
+			for (let i = 1; i < parsed.events.length; i++) {
+				const prev = parsed.events[i - 1];
+				const curr = parsed.events[i];
 				if (prev && curr) {
 					expect(
 						(prev.createdAt as string).localeCompare(curr.createdAt as string),
@@ -430,8 +437,8 @@ describe("replayCommand", () => {
 			await replayCommand(["--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([]);
 		});
 	});
 
@@ -451,9 +458,9 @@ describe("replayCommand", () => {
 			await replayCommand(["--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Record<string, unknown>[];
-			expect(parsed).toHaveLength(1);
-			expect(parsed[0]?.runId).toBe("run-from-file");
+			const parsed = JSON.parse(out.trim()) as { events: Record<string, unknown>[] };
+			expect(parsed.events).toHaveLength(1);
+			expect(parsed.events[0]?.runId).toBe("run-from-file");
 		});
 
 		test("falls back to 24h timeline when no current-run.txt", async () => {
@@ -467,8 +474,8 @@ describe("replayCommand", () => {
 			await replayCommand(["--json"]);
 			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("falls back to timeline when current-run.txt is empty", async () => {
@@ -482,8 +489,8 @@ describe("replayCommand", () => {
 			await replayCommand(["--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);
 		});
 	});
 
@@ -501,8 +508,8 @@ describe("replayCommand", () => {
 			await replayCommand(["--run", "run-001", "--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 200", async () => {
@@ -516,8 +523,8 @@ describe("replayCommand", () => {
 			await replayCommand(["--run", "run-001", "--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toHaveLength(200);
+			const parsed = JSON.parse(out.trim()) as { events: unknown[] };
+			expect(parsed.events).toHaveLength(200);
 		});
 
 		test("--limit applies to merged --agent queries", async () => {
@@ -532,8 +539,8 @@ describe("replayCommand", () => {
 			await replayCommand(["--agent", "builder-1", "--agent", "scout-1", "--json", "--limit", "4"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as unknown[];
-			expect(parsed).toHaveLength(4);
+			const parsed = JSON.parse(out.trim()) as { events: unknown[] };
+			expect(parsed.events).toHaveLength(4);
 		});
 	});
 
@@ -550,8 +557,8 @@ describe("replayCommand", () => {
 			await replayCommand(["--run", "run-001", "--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 () => {
@@ -564,8 +571,8 @@ describe("replayCommand", () => {
 			await replayCommand(["--run", "run-001", "--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 events", async () => {
@@ -577,8 +584,8 @@ describe("replayCommand", () => {
 			await replayCommand(["--run", "run-001", "--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([]);
 		});
 
 		test("--since causes absolute timestamps in text mode", async () => {
@@ -611,12 +618,12 @@ describe("replayCommand", () => {
 			await replayCommand(["--run", "run-001", "--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Record<string, unknown>[];
-			expect(parsed).toHaveLength(4);
+			const parsed = JSON.parse(out.trim()) as { events: Record<string, unknown>[] };
+			expect(parsed.events).toHaveLength(4);
 			// Verify chronological order
-			for (let i = 1; i < parsed.length; i++) {
-				const prev = parsed[i - 1];
-				const curr = parsed[i];
+			for (let i = 1; i < parsed.events.length; i++) {
+				const prev = parsed.events[i - 1];
+				const curr = parsed.events[i];
 				if (prev && curr) {
 					expect(
 						(prev.createdAt as string).localeCompare(curr.createdAt as string),
@@ -624,10 +631,10 @@ describe("replayCommand", () => {
 				}
 			}
 			// Verify interleaving: agents should alternate
-			expect(parsed[0]?.agentName).toBe("builder-1");
-			expect(parsed[1]?.agentName).toBe("scout-1");
-			expect(parsed[2]?.agentName).toBe("builder-1");
-			expect(parsed[3]?.agentName).toBe("scout-1");
+			expect(parsed.events[0]?.agentName).toBe("builder-1");
+			expect(parsed.events[1]?.agentName).toBe("scout-1");
+			expect(parsed.events[2]?.agentName).toBe("builder-1");
+			expect(parsed.events[3]?.agentName).toBe("scout-1");
 		});
 	});
 

package/src/commands/replay.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";
@@ -246,7 +247,7 @@ async function executeReplay(opts: ReplayOpts): Promise<void> {
 	const eventsFile = Bun.file(eventsDbPath);
 	if (!(await eventsFile.exists())) {
 		if (json) {
-			process.stdout.write("[]\n");
+			jsonOutput("replay", { events: [] });
 		} else {
 			process.stdout.write("No events data yet.\n");
 		}
@@ -305,7 +306,7 @@ async function executeReplay(opts: ReplayOpts): Promise<void> {
 		}
 
 		if (json) {
-			process.stdout.write(`${JSON.stringify(events)}\n`);
+			jsonOutput("replay", { events });
 			return;
 		}
 

package/src/commands/run.ts

@@ -15,7 +15,8 @@ import { join } from "node:path";
 import { Command, CommanderError } from "commander";
 import { loadConfig } from "../config.ts";
 import { ValidationError } from "../errors.ts";
-import { printError, printHint, printSuccess } from "../logging/color.ts";
+import { jsonError, jsonOutput } from "../json.ts";
+import { accent, printError, printHint, printSuccess } from "../logging/color.ts";
 import { createRunStore, createSessionStore } from "../sessions/store.ts";
 import type { AgentSession, Run } from "../types.ts";
 
@@ -83,7 +84,7 @@ async function showCurrentRun(overstoryDir: string, json: boolean): Promise<void
 	const runId = await readCurrentRunId(overstoryDir);
 	if (!runId) {
 		if (json) {
-			process.stdout.write('{"run":null,"message":"No active run"}\n');
+			jsonOutput("run", { run: null, message: "No active run" });
 		} else {
 			printHint("No active run");
 		}
@@ -96,23 +97,21 @@ async function showCurrentRun(overstoryDir: string, json: boolean): Promise<void
 		const run = runStore.getRun(runId);
 		if (!run) {
 			if (json) {
-				process.stdout.write(
-					`${JSON.stringify({ run: null, message: `Run ${runId} not found in store` })}\n`,
-				);
+				jsonOutput("run", { run: null, message: `Run ${runId} not found in store` });
 			} else {
-				process.stdout.write(`Run ${runId} not found in store\n`);
+				process.stdout.write(`Run ${accent(runId)} not found in store\n`);
 			}
 			return;
 		}
 
 		if (json) {
-			process.stdout.write(`${JSON.stringify({ run, duration: runDuration(run) })}\n`);
+			jsonOutput("run", { run, duration: runDuration(run) });
 			return;
 		}
 
 		process.stdout.write("Current Run\n");
 		process.stdout.write(`${"=".repeat(50)}\n`);
-		process.stdout.write(`  ID:       ${run.id}\n`);
+		process.stdout.write(`  ID:       ${accent(run.id)}\n`);
 		process.stdout.write(`  Status:   ${run.status}\n`);
 		process.stdout.write(`  Started:  ${run.startedAt}\n`);
 		process.stdout.write(`  Agents:   ${run.agentCount}\n`);
@@ -130,7 +129,7 @@ async function listRuns(overstoryDir: string, limit: number, json: boolean): Pro
 	const dbFile = Bun.file(dbPath);
 	if (!(await dbFile.exists())) {
 		if (json) {
-			process.stdout.write('{"runs":[]}\n');
+			jsonOutput("run list", { runs: [] });
 		} else {
 			printHint("No runs recorded yet");
 		}
@@ -143,7 +142,7 @@ async function listRuns(overstoryDir: string, limit: number, json: boolean): Pro
 
 		if (json) {
 			const runsWithDuration = runs.map((r) => ({ ...r, duration: runDuration(r) }));
-			process.stdout.write(`${JSON.stringify({ runs: runsWithDuration })}\n`);
+			jsonOutput("run list", { runs: runsWithDuration });
 			return;
 		}
 
@@ -160,7 +159,7 @@ async function listRuns(overstoryDir: string, limit: number, json: boolean): Pro
 		process.stdout.write(`${"-".repeat(70)}\n`);
 
 		for (const run of runs) {
-			const id = run.id.length > 35 ? `${run.id.slice(0, 32)}...` : run.id.padEnd(36);
+			const id = accent(run.id.length > 35 ? `${run.id.slice(0, 32)}...` : run.id.padEnd(36));
 			const status = run.status.padEnd(10);
 			const agents = String(run.agentCount).padEnd(7);
 			const duration = runDuration(run);
@@ -178,7 +177,7 @@ async function completeCurrentRun(overstoryDir: string, json: boolean): Promise<
 	const runId = await readCurrentRunId(overstoryDir);
 	if (!runId) {
 		if (json) {
-			process.stdout.write('{"success":false,"message":"No active run to complete"}\n');
+			jsonError("run complete", "No active run to complete");
 		} else {
 			printError("No active run to complete");
 		}
@@ -203,7 +202,7 @@ async function completeCurrentRun(overstoryDir: string, json: boolean): Promise<
 	}
 
 	if (json) {
-		process.stdout.write(`${JSON.stringify({ success: true, runId, status: "completed" })}\n`);
+		jsonOutput("run complete", { runId, status: "completed" });
 	} else {
 		printSuccess("Run completed", runId);
 	}
@@ -217,7 +216,7 @@ async function showRun(overstoryDir: string, runId: string, json: boolean): Prom
 	const dbFile = Bun.file(dbPath);
 	if (!(await dbFile.exists())) {
 		if (json) {
-			process.stdout.write(`${JSON.stringify({ run: null, message: `Run ${runId} not found` })}\n`);
+			jsonError("run show", `Run ${runId} not found`);
 		} else {
 			printError("Run not found", runId);
 		}
@@ -231,9 +230,7 @@ async function showRun(overstoryDir: string, runId: string, json: boolean): Prom
 		const run = runStore.getRun(runId);
 		if (!run) {
 			if (json) {
-				process.stdout.write(
-					`${JSON.stringify({ run: null, message: `Run ${runId} not found` })}\n`,
-				);
+				jsonError("run show", `Run ${runId} not found`);
 			} else {
 				printError("Run not found", runId);
 			}
@@ -244,13 +241,13 @@ async function showRun(overstoryDir: string, runId: string, json: boolean): Prom
 		const agents = sessionStore.getByRun(runId);
 
 		if (json) {
-			process.stdout.write(`${JSON.stringify({ run, duration: runDuration(run), agents })}\n`);
+			jsonOutput("run show", { run, duration: runDuration(run), agents });
 			return;
 		}
 
 		process.stdout.write("Run Details\n");
 		process.stdout.write(`${"=".repeat(60)}\n`);
-		process.stdout.write(`  ID:       ${run.id}\n`);
+		process.stdout.write(`  ID:       ${accent(run.id)}\n`);
 		process.stdout.write(`  Status:   ${run.status}\n`);
 		process.stdout.write(`  Started:  ${run.startedAt}\n`);
 		if (run.completedAt) {
@@ -265,7 +262,7 @@ async function showRun(overstoryDir: string, runId: string, json: boolean): Prom
 			for (const agent of agents) {
 				const agentDuration = formatAgentDuration(agent);
 				process.stdout.write(
-					`  ${agent.agentName} [${agent.capability}] ${agent.state} | ${agentDuration}\n`,
+					`  ${accent(agent.agentName)} [${agent.capability}] ${agent.state} | ${agentDuration}\n`,
 				);
 			}
 		} else {

package/src/commands/sling.ts

@@ -27,6 +27,7 @@ import { writeOverlay } from "../agents/overlay.ts";
 import { loadConfig } from "../config.ts";
 import { AgentError, HierarchyError, ValidationError } from "../errors.ts";
 import { inferDomain } from "../insights/analyzer.ts";
+import { jsonOutput } from "../json.ts";
 import { printSuccess } from "../logging/color.ts";
 import { createMailClient } from "../mail/client.ts";
 import { createMailStore } from "../mail/store.ts";
@@ -708,7 +709,7 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 		};
 
 		if (opts.json ?? false) {
-			process.stdout.write(`${JSON.stringify(output)}\n`);
+			jsonOutput("sling", output);
 		} else {
 			printSuccess("Agent launched", name);
 			process.stdout.write(`   Task:     ${taskId}\n`);

package/src/commands/status.test.ts

@@ -2,6 +2,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdir, mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { stripAnsi } from "../logging/color.ts";
 import { createSessionStore } from "../sessions/store.ts";
 import { createTempGitRepo } from "../test-helpers.ts";
 import type { AgentSession } from "../types.ts";
@@ -258,7 +259,7 @@ describe("run scoping", () => {
 	test("printStatus shows run ID when currentRunId is set", () => {
 		const data = makeStatusData({ currentRunId: "run-123" });
 		printStatus(data);
-		expect(output()).toContain("Run: run-123");
+		expect(stripAnsi(output())).toContain("Run: run-123");
 	});
 
 	test("printStatus does not show run line when currentRunId is undefined", () => {

package/src/commands/status.ts

@@ -9,7 +9,8 @@ import { join } from "node:path";
 import { Command } from "commander";
 import { loadConfig } from "../config.ts";
 import { ValidationError } from "../errors.ts";
-import { color } from "../logging/color.ts";
+import { jsonOutput } from "../json.ts";
+import { accent, color } from "../logging/color.ts";
 import { createMailStore } from "../mail/store.ts";
 import { createMergeQueue } from "../merge/queue.ts";
 import { createMetricsStore } from "../metrics/store.ts";
@@ -258,7 +259,7 @@ export function printStatus(data: StatusData): void {
 	w("Overstory Status\n");
 	w(`${"═".repeat(60)}\n\n`);
 	if (data.currentRunId) {
-		w(`Run: ${data.currentRunId}\n`);
+		w(`Run: ${accent(data.currentRunId)}\n`);
 	}
 
 	// Active agents
@@ -274,8 +275,8 @@ export function printStatus(data: StatusData): void {
 			const duration = formatDuration(endTime - new Date(agent.startedAt).getTime());
 			const tmuxAlive = tmuxSessionNames.has(agent.tmuxSession);
 			const aliveMarker = tmuxAlive ? color.green(">") : color.red("x");
-			w(`   ${aliveMarker} ${agent.agentName} [${agent.capability}] `);
-			w(`${agent.state} | ${agent.taskId} | ${duration}\n`);
+			w(`   ${aliveMarker} ${accent(agent.agentName)} [${agent.capability}] `);
+			w(`${agent.state} | ${accent(agent.taskId)} | ${duration}\n`);
 
 			const detail = data.verboseDetails?.[agent.agentName];
 			if (detail) {
@@ -357,7 +358,7 @@ async function executeStatus(opts: StatusOpts): Promise<void> {
 			process.stdout.write("\x1b[2J\x1b[H");
 			const data = await gatherStatus(root, agentName, verbose, runId);
 			if (json) {
-				process.stdout.write(`${JSON.stringify(data, null, "\t")}\n`);
+				jsonOutput("status", data as unknown as Record<string, unknown>);
 			} else {
 				printStatus(data);
 			}
@@ -366,7 +367,7 @@ async function executeStatus(opts: StatusOpts): Promise<void> {
 	} else {
 		const data = await gatherStatus(root, agentName, verbose, runId);
 		if (json) {
-			process.stdout.write(`${JSON.stringify(data, null, "\t")}\n`);
+			jsonOutput("status", data as unknown as Record<string, unknown>);
 		} else {
 			printStatus(data);
 		}

package/src/commands/stop.test.ts

@@ -314,6 +314,8 @@ describe("stopCommand --json output", () => {
 		const output = await captureStdout(() => stopCommand("my-builder", { json: true }, deps));
 
 		const parsed = JSON.parse(output.trim()) as Record<string, unknown>;
+		expect(parsed.success).toBe(true);
+		expect(parsed.command).toBe("stop");
 		expect(parsed.stopped).toBe(true);
 		expect(parsed.agentName).toBe("my-builder");
 		expect(parsed.sessionId).toBe(session.id);