@os-eco/overstory-cli 0.6.7 → 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,8 @@ 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";
 import { createSession, isSessionAlive, killSession, sendKeys } from "../worktree/tmux.ts";
@@ -189,9 +191,9 @@ async function startMonitor(opts: { json: boolean; attach: boolean }): Promise<v
 		};
 
 		if (json) {
-			process.stdout.write(`${JSON.stringify(output)}\n`);
+			jsonOutput("monitor start", output);
 		} else {
-			process.stdout.write("Monitor started\n");
+			printSuccess("Monitor started");
 			process.stdout.write(`  Tmux:    ${tmuxSession}\n`);
 			process.stdout.write(`  Root:    ${projectRoot}\n`);
 			process.stdout.write(`  PID:     ${pid}\n`);
@@ -247,9 +249,9 @@ 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 {
-			process.stdout.write(`Monitor stopped (session: ${session.id})\n`);
+			printSuccess("Monitor stopped", session.id);
 		}
 	} finally {
 		store.close();
@@ -279,9 +281,9 @@ 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 {
-				process.stdout.write("Monitor is not running\n");
+				printHint("Monitor is not running");
 			}
 			return;
 		}
@@ -306,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,8 @@ 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";
 import { isSessionAlive, sendKeys } from "../worktree/tmux.ts";
@@ -309,11 +311,9 @@ 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) {
-					process.stdout.write(`📢 Nudged "${agentName}"\n`);
+					printSuccess("Nudge delivered", agentName);
 				} else {
 					throw new AgentError(`Nudge failed: ${result.reason}`, { agentName });
 				}

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,6 +15,8 @@ import { join } from "node:path";
 import { Command, CommanderError } from "commander";
 import { loadConfig } from "../config.ts";
 import { ValidationError } from "../errors.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";
 
@@ -82,9 +84,9 @@ 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 {
-			process.stdout.write("No active run\n");
+			printHint("No active run");
 		}
 		return;
 	}
@@ -95,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`);
@@ -129,9 +129,9 @@ 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 {
-			process.stdout.write("No runs recorded yet.\n");
+			printHint("No runs recorded yet");
 		}
 		return;
 	}
@@ -142,12 +142,12 @@ 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;
 		}
 
 		if (runs.length === 0) {
-			process.stdout.write("No runs recorded yet.\n");
+			printHint("No runs recorded yet");
 			return;
 		}
 
@@ -159,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);
@@ -177,9 +177,9 @@ 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 {
-			process.stderr.write("No active run to complete\n");
+			printError("No active run to complete");
 		}
 		process.exitCode = 1;
 		return;
@@ -202,9 +202,9 @@ 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 {
-		process.stdout.write(`Run ${runId} marked as completed\n`);
+		printSuccess("Run completed", runId);
 	}
 }
 
@@ -216,9 +216,9 @@ 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 {
-			process.stderr.write(`Run ${runId} not found\n`);
+			printError("Run not found", runId);
 		}
 		process.exitCode = 1;
 		return;
@@ -230,11 +230,9 @@ 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 {
-				process.stderr.write(`Run ${runId} not found\n`);
+				printError("Run not found", runId);
 			}
 			process.exitCode = 1;
 			return;
@@ -243,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) {
@@ -264,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,8 @@ 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";
 import { createMulchClient } from "../mulch/client.ts";
@@ -707,9 +709,9 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 		};
 
 		if (opts.json ?? false) {
-			process.stdout.write(`${JSON.stringify(output)}\n`);
+			jsonOutput("sling", output);
 		} else {
-			process.stdout.write(`Agent "${name}" launched!\n`);
+			printSuccess("Agent launched", name);
 			process.stdout.write(`   Task:     ${taskId}\n`);
 			process.stdout.write(`   Branch:   ${branchName}\n`);
 			process.stdout.write(`   Worktree: ${worktreePath}\n`);

package/src/commands/spec.test.ts

@@ -142,13 +142,13 @@ describe("writeSpec", () => {
 // === specWriteCommand (CLI integration) ===
 
 describe("specWriteCommand (integration)", () => {
-	test("writes spec and prints path", async () => {
+	test("writes spec and prints success", async () => {
 		await specWriteCommand("task-cmd", { body: "# CLI Spec" });
 
-		// Path may differ due to macOS /var -> /private/var symlink resolution
-		expect(stdoutOutput.trim()).toContain(".overstory/specs/task-cmd.md");
+		expect(stdoutOutput).toContain("Spec written");
+		expect(stdoutOutput).toContain("task-cmd");
 
-		const specPath = stdoutOutput.trim();
+		const specPath = join(tempDir, ".overstory", "specs", "task-cmd.md");
 		const content = await Bun.file(specPath).text();
 		expect(content).toBe("# CLI Spec\n");
 	});
@@ -156,9 +156,10 @@ describe("specWriteCommand (integration)", () => {
 	test("writes spec with agent attribution", async () => {
 		await specWriteCommand("task-attr", { body: "# Attributed", agent: "scout-2" });
 
-		expect(stdoutOutput.trim()).toContain(".overstory/specs/task-attr.md");
+		expect(stdoutOutput).toContain("Spec written");
+		expect(stdoutOutput).toContain("task-attr");
 
-		const specPath = stdoutOutput.trim();
+		const specPath = join(tempDir, ".overstory", "specs", "task-attr.md");
 		const content = await Bun.file(specPath).text();
 		expect(content).toContain("<!-- written-by: scout-2 -->");
 		expect(content).toContain("# Attributed");
@@ -167,9 +168,10 @@ describe("specWriteCommand (integration)", () => {
 	test("writes spec without agent when agent is omitted", async () => {
 		await specWriteCommand("task-noagent", { body: "# No Agent" });
 
-		expect(stdoutOutput.trim()).toContain(".overstory/specs/task-noagent.md");
+		expect(stdoutOutput).toContain("Spec written");
+		expect(stdoutOutput).toContain("task-noagent");
 
-		const specPath = stdoutOutput.trim();
+		const specPath = join(tempDir, ".overstory", "specs", "task-noagent.md");
 		const content = await Bun.file(specPath).text();
 		expect(content).not.toContain("written-by");
 		expect(content).toBe("# No Agent\n");