@os-eco/overstory-cli 0.6.7 → 0.6.9

package/src/commands/spec.ts

@@ -11,6 +11,7 @@
 import { mkdir } from "node:fs/promises";
 import { join } from "node:path";
 import { ValidationError } from "../errors.ts";
+import { printSuccess } from "../logging/color.ts";
 
 export interface SpecWriteOptions {
 	body?: string;
@@ -93,6 +94,6 @@ export async function specWriteCommand(taskId: string, opts: SpecWriteOptions):
 	const { resolveProjectRoot } = await import("../config.ts");
 	const projectRoot = await resolveProjectRoot(process.cwd());
 
-	const specPath = await writeSpec(projectRoot, taskId, body, opts.agent);
-	process.stdout.write(`${specPath}\n`);
+	await writeSpec(projectRoot, taskId, body, opts.agent);
+	printSuccess("Spec written", taskId);
 }

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

@@ -245,7 +245,8 @@ describe("stopCommand stop behavior", () => {
 		const { deps, tmuxCalls } = makeDeps({ [session.tmuxSession]: true });
 		const output = await captureStdout(() => stopCommand("my-builder", {}, deps));
 
-		expect(output).toContain(`Agent "my-builder" stopped`);
+		expect(output).toContain("Agent stopped");
+		expect(output).toContain("my-builder");
 		expect(output).toContain(`Tmux session killed: ${session.tmuxSession}`);
 		expect(tmuxCalls.killSession).toHaveLength(1);
 		expect(tmuxCalls.killSession[0]?.name).toBe(session.tmuxSession);
@@ -313,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);
@@ -365,19 +368,20 @@ describe("stopCommand --clean-worktree", () => {
 		expect(worktreeCalls.remove[0]?.options?.forceBranch).toBe(true);
 	});
 
-	test("--clean-worktree failure is non-fatal (agent still stopped, warning on stderr)", async () => {
+	test("--clean-worktree failure is non-fatal (agent still stopped, warning on stdout)", async () => {
 		const session = makeAgentSession({ state: "working" });
 		saveSessionsToDb([session]);
 
 		const { deps } = makeDeps({ [session.tmuxSession]: true }, { shouldFail: true });
-		const { stderr, stdout } = await captureStderr(() =>
+		const { stdout } = await captureStderr(() =>
 			stopCommand("my-builder", { cleanWorktree: true }, deps),
 		);
 
 		// Agent was still stopped
-		expect(stdout).toContain(`Agent "my-builder" stopped`);
-		// Warning written to stderr
-		expect(stderr).toContain("Warning: failed to remove worktree");
+		expect(stdout).toContain("Agent stopped");
+		expect(stdout).toContain("my-builder");
+		// Warning written to stdout (via printWarning)
+		expect(stdout).toContain("Failed to remove worktree");
 
 		// Session is marked completed despite worktree failure
 		const { store } = openSessionStore(overstoryDir);

package/src/commands/stop.ts

@@ -11,6 +11,8 @@
 import { join } from "node:path";
 import { loadConfig } from "../config.ts";
 import { AgentError, ValidationError } from "../errors.ts";
+import { jsonOutput } from "../json.ts";
+import { printSuccess, printWarning } from "../logging/color.ts";
 import { openSessionStore } from "../sessions/compat.ts";
 import { removeWorktree } from "../worktree/manager.ts";
 import { isSessionAlive, killSession } from "../worktree/tmux.ts";
@@ -103,24 +105,22 @@ export async function stopCommand(
 				worktreeRemoved = true;
 			} catch (err) {
 				const msg = err instanceof Error ? err.message : String(err);
-				process.stderr.write(`Warning: failed to remove worktree: ${msg}\n`);
+				if (!json) printWarning("Failed to remove worktree", msg);
 			}
 		}
 
 		if (json) {
-			process.stdout.write(
-				`${JSON.stringify({
-					stopped: true,
-					agentName,
-					sessionId: session.id,
-					capability: session.capability,
-					tmuxKilled: alive,
-					worktreeRemoved,
-					force,
-				})}\n`,
-			);
+			jsonOutput("stop", {
+				stopped: true,
+				agentName,
+				sessionId: session.id,
+				capability: session.capability,
+				tmuxKilled: alive,
+				worktreeRemoved,
+				force,
+			});
 		} else {
-			process.stdout.write(`Agent "${agentName}" stopped (session: ${session.id})\n`);
+			printSuccess("Agent stopped", agentName);
 			if (alive) {
 				process.stdout.write(`  Tmux session killed: ${session.tmuxSession}\n`);
 			} else {

package/src/commands/supervisor.ts

@@ -20,6 +20,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 { createTrackerClient, resolveBackend, trackerCliName } from "../tracker/factory.ts";
 import type { AgentSession } from "../types.ts";
@@ -229,9 +231,9 @@ async function startSupervisor(opts: {
 		};
 
 		if (opts.json) {
-			process.stdout.write(`${JSON.stringify(output)}\n`);
+			jsonOutput("supervisor start", output);
 		} else {
-			process.stdout.write(`Supervisor '${opts.name}' started\n`);
+			printSuccess("Supervisor started", opts.name);
 			process.stdout.write(`  Tmux:    ${tmuxSession}\n`);
 			process.stdout.write(`  Root:    ${projectRoot}\n`);
 			process.stdout.write(`  Task:    ${opts.task}\n`);
@@ -290,9 +292,9 @@ async function stopSupervisor(opts: { name: string; json: boolean }): Promise<vo
 		store.updateLastActivity(opts.name);
 
 		if (opts.json) {
-			process.stdout.write(`${JSON.stringify({ stopped: true, sessionId: session.id })}\n`);
+			jsonOutput("supervisor stop", { stopped: true, sessionId: session.id });
 		} else {
-			process.stdout.write(`Supervisor '${opts.name}' stopped (session: ${session.id})\n`);
+			printSuccess("Supervisor stopped", opts.name);
 		}
 	} finally {
 		store.close();
@@ -324,9 +326,9 @@ async function statusSupervisor(opts: { name?: string; json: boolean }): Promise
 				session.state === "zombie"
 			) {
 				if (opts.json) {
-					process.stdout.write(`${JSON.stringify({ running: false })}\n`);
+					jsonOutput("supervisor status", { running: false });
 				} else {
-					process.stdout.write(`Supervisor '${opts.name}' is not running\n`);
+					printHint("Supervisor not running");
 				}
 				return;
 			}
@@ -356,7 +358,7 @@ async function statusSupervisor(opts: { name?: string; json: boolean }): Promise
 			};
 
 			if (opts.json) {
-				process.stdout.write(`${JSON.stringify(status)}\n`);
+				jsonOutput("supervisor status", status);
 			} else {
 				const stateLabel = alive ? "running" : session.state;
 				process.stdout.write(`Supervisor '${opts.name}': ${stateLabel}\n`);
@@ -376,9 +378,9 @@ async function statusSupervisor(opts: { name?: string; json: boolean }): Promise
 
 			if (supervisors.length === 0) {
 				if (opts.json) {
-					process.stdout.write(`${JSON.stringify([])}\n`);
+					jsonOutput("supervisor status", { supervisors: [] });
 				} else {
-					process.stdout.write("No supervisor sessions found\n");
+					printHint("No supervisor sessions found");
 				}
 				return;
 			}
@@ -410,7 +412,7 @@ async function statusSupervisor(opts: { name?: string; json: boolean }): Promise
 			);
 
 			if (opts.json) {
-				process.stdout.write(`${JSON.stringify(statuses)}\n`);
+				jsonOutput("supervisor status", { supervisors: statuses });
 			} else {
 				process.stdout.write("Supervisor sessions:\n");
 				for (const status of statuses) {

package/src/commands/trace.test.ts

@@ -14,6 +14,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { ValidationError } from "../errors.ts";
 import { createEventStore } from "../events/store.ts";
+import { stripAnsi } from "../logging/color.ts";
 import { createSessionStore } from "../sessions/store.ts";
 import type { InsertEvent } from "../types.ts";
 import { traceCommand } from "./trace.ts";
@@ -149,8 +150,8 @@ describe("traceCommand", () => {
 
 			await traceCommand(["--json", "--limit", "50", "my-agent"]);
 			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);
 		});
 
 		test("target is extracted correctly when flags come after", async () => {
@@ -161,8 +162,8 @@ describe("traceCommand", () => {
 
 			await traceCommand(["my-agent", "--json", "--limit", "50"]);
 			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);
 		});
 	});
 
@@ -180,7 +181,14 @@ describe("traceCommand", () => {
 			await traceCommand(["builder-1", "--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("trace");
+			expect(parsed.events).toEqual([]);
 		});
 	});
 
@@ -198,9 +206,9 @@ describe("traceCommand", () => {
 			await traceCommand(["builder-1", "--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 () => {
@@ -219,9 +227,9 @@ describe("traceCommand", () => {
 			await traceCommand(["builder-1", "--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");
@@ -239,8 +247,8 @@ describe("traceCommand", () => {
 			await traceCommand(["builder-1", "--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([]);
 		});
 	});
 
@@ -256,7 +264,7 @@ describe("traceCommand", () => {
 			await traceCommand(["builder-1"]);
 			const out = output();
 
-			expect(out).toContain("Timeline for builder-1");
+			expect(stripAnsi(out)).toContain("Timeline for builder-1");
 		});
 
 		test("shows event count", async () => {
@@ -413,8 +421,8 @@ describe("traceCommand", () => {
 			await traceCommand(["builder-1", "--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 () => {
@@ -428,8 +436,8 @@ describe("traceCommand", () => {
 			await traceCommand(["builder-1", "--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);
 		});
 	});
 
@@ -448,8 +456,8 @@ describe("traceCommand", () => {
 			await traceCommand(["builder-1", "--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 () => {
@@ -462,8 +470,8 @@ describe("traceCommand", () => {
 			await traceCommand(["builder-1", "--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 () => {
@@ -475,8 +483,8 @@ describe("traceCommand", () => {
 			await traceCommand(["builder-1", "--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 () => {
@@ -518,9 +526,9 @@ describe("traceCommand", () => {
 			await traceCommand(["my-custom-agent", "--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Record<string, unknown>[];
-			expect(parsed).toHaveLength(1);
-			expect(parsed[0]?.agentName).toBe("my-custom-agent");
+			const parsed = JSON.parse(out.trim()) as { events: Record<string, unknown>[] };
+			expect(parsed.events).toHaveLength(1);
+			expect(parsed.events[0]?.agentName).toBe("my-custom-agent");
 		});
 
 		test("task ID pattern is detected and resolved to agent name via SessionStore", async () => {
@@ -556,9 +564,9 @@ describe("traceCommand", () => {
 			await traceCommand(["overstory-rj1k", "--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Record<string, unknown>[];
-			expect(parsed).toHaveLength(1);
-			expect(parsed[0]?.agentName).toBe("builder-for-task");
+			const parsed = JSON.parse(out.trim()) as { events: Record<string, unknown>[] };
+			expect(parsed.events).toHaveLength(1);
+			expect(parsed.events[0]?.agentName).toBe("builder-for-task");
 		});
 
 		test("unresolved task ID falls back to using task ID as agent name", async () => {
@@ -575,8 +583,8 @@ describe("traceCommand", () => {
 			await traceCommand(["myproj-abc1", "--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("short agent names without task pattern are not resolved as task IDs", async () => {
@@ -589,9 +597,9 @@ describe("traceCommand", () => {
 			await traceCommand(["scout", "--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Record<string, unknown>[];
-			expect(parsed).toHaveLength(1);
-			expect(parsed[0]?.agentName).toBe("scout");
+			const parsed = JSON.parse(out.trim()) as { events: Record<string, unknown>[] };
+			expect(parsed.events).toHaveLength(1);
+			expect(parsed.events[0]?.agentName).toBe("scout");
 		});
 	});
 
@@ -610,9 +618,9 @@ describe("traceCommand", () => {
 			await traceCommand(["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");
 			}
 		});
@@ -710,11 +718,11 @@ describe("traceCommand", () => {
 			await traceCommand(["builder-1", "--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 () => {
@@ -738,7 +746,7 @@ describe("traceCommand", () => {
 			await traceCommand(["builder-1"]);
 			const out = output();
 
-			expect(out).toContain("Timeline for builder-1");
+			expect(stripAnsi(out)).toContain("Timeline for builder-1");
 			expect(out).toContain("1 event");
 		});
 	});

package/src/commands/trace.ts

@@ -10,8 +10,9 @@ 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 { accent, color } from "../logging/color.ts";
 import { openSessionStore } from "../sessions/compat.ts";
 import type { EventType, StoredEvent } from "../types.ts";
 
@@ -129,7 +130,7 @@ function buildEventDetail(event: StoredEvent): string {
 function printTimeline(events: StoredEvent[], agentName: string, useAbsoluteTime: boolean): void {
 	const w = process.stdout.write.bind(process.stdout);
 
-	w(`${color.bold(`Timeline for ${agentName}`)}\n`);
+	w(`${color.bold(`Timeline for ${accent(agentName)}`)}\n`);
 	w(`${"=".repeat(70)}\n`);
 
 	if (events.length === 0) {
@@ -243,7 +244,7 @@ async function executeTrace(target: string, opts: TraceOpts): Promise<void> {
 	const eventsFile = Bun.file(eventsDbPath);
 	if (!(await eventsFile.exists())) {
 		if (json) {
-			process.stdout.write("[]\n");
+			jsonOutput("trace", { events: [] });
 		} else {
 			process.stdout.write("No events data yet.\n");
 		}
@@ -260,7 +261,7 @@ async function executeTrace(target: string, opts: TraceOpts): Promise<void> {
 		});
 
 		if (json) {
-			process.stdout.write(`${JSON.stringify(events)}\n`);
+			jsonOutput("trace", { events });
 			return;
 		}
 

package/src/commands/watch.ts

@@ -10,6 +10,7 @@ import { join } from "node:path";
 import { Command } from "commander";
 import { loadConfig } from "../config.ts";
 import { OverstoryError } from "../errors.ts";
+import { printError, printHint, printSuccess } from "../logging/color.ts";
 import type { HealthCheck } from "../types.ts";
 import { startDaemon } from "../watchdog/daemon.ts";
 import { isProcessRunning } from "../watchdog/health.ts";
@@ -130,9 +131,8 @@ async function runWatch(opts: { interval?: string; background?: boolean }): Prom
 		// Check if a watchdog is already running
 		const existingPid = await readPidFile(pidFilePath);
 		if (existingPid !== null && isProcessRunning(existingPid)) {
-			process.stderr.write(
-				`Error: Watchdog already running (PID: ${existingPid}). ` +
-					`Kill it first or remove ${pidFilePath}\n`,
+			printError(
+				`Watchdog already running (PID: ${existingPid}). Kill it first or remove ${pidFilePath}`,
 			);
 			process.exitCode = 1;
 			return;
@@ -168,16 +168,14 @@ async function runWatch(opts: { interval?: string; background?: boolean }): Prom
 		// Write PID file for later cleanup
 		await writePidFile(pidFilePath, childPid);
 
-		process.stdout.write(
-			`Watchdog started in background (PID: ${childPid}, interval: ${intervalMs}ms)\n`,
-		);
-		process.stdout.write(`PID file: ${pidFilePath}\n`);
+		printSuccess("Watchdog started in background", `PID: ${childPid}, interval: ${intervalMs}ms`);
+		printHint(`PID file: ${pidFilePath}`);
 		return;
 	}
 
 	// Foreground mode: show real-time health checks
-	process.stdout.write(`Watchdog running (interval: ${intervalMs}ms)\n`);
-	process.stdout.write("Press Ctrl+C to stop.\n\n");
+	printSuccess("Watchdog running", `interval: ${intervalMs}ms`);
+	printHint("Press Ctrl+C to stop.");
 
 	// Write PID file so `--background` check and external tools can find us
 	await writePidFile(pidFilePath, process.pid);
@@ -200,7 +198,7 @@ async function runWatch(opts: { interval?: string; background?: boolean }): Prom
 		stop();
 		// Clean up PID file on graceful shutdown
 		removePidFile(pidFilePath).finally(() => {
-			process.stdout.write("\nWatchdog stopped.\n");
+			printSuccess("Watchdog stopped.");
 			process.exit(0);
 		});
 	});

package/src/commands/worktree.test.ts

@@ -131,7 +131,7 @@ describe("worktreeCommand", () => {
 			await worktreeCommand(["list"]);
 			const out = output();
 
-			expect(out).toBe("No agent worktrees found.\n");
+			expect(out).toContain("No agent worktrees found");
 		});
 
 		test("with overstory worktrees lists them with agent info", async () => {
@@ -220,21 +220,27 @@ describe("worktreeCommand", () => {
 			await worktreeCommand(["list", "--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Array<{
-				path: string;
-				branch: string;
-				head: string;
-				agentName: string | null;
-				state: string | null;
-				taskId: string | null;
-			}>;
-
-			expect(parsed).toHaveLength(1);
-			expect(parsed[0]?.path).toBe(worktreePath);
-			expect(parsed[0]?.branch).toBe("overstory/test-agent/task-1");
-			expect(parsed[0]?.agentName).toBe("test-agent");
-			expect(parsed[0]?.state).toBe("working");
-			expect(parsed[0]?.taskId).toBe("task-1");
+			const parsed = JSON.parse(out.trim()) as {
+				success: boolean;
+				command: string;
+				worktrees: Array<{
+					path: string;
+					branch: string;
+					head: string;
+					agentName: string | null;
+					state: string | null;
+					taskId: string | null;
+				}>;
+			};
+
+			expect(parsed.success).toBe(true);
+			expect(parsed.command).toBe("worktree list");
+			expect(parsed.worktrees).toHaveLength(1);
+			expect(parsed.worktrees[0]?.path).toBe(worktreePath);
+			expect(parsed.worktrees[0]?.branch).toBe("overstory/test-agent/task-1");
+			expect(parsed.worktrees[0]?.agentName).toBe("test-agent");
+			expect(parsed.worktrees[0]?.state).toBe("working");
+			expect(parsed.worktrees[0]?.taskId).toBe("task-1");
 		});
 
 		test("worktrees without sessions show unknown state", async () => {
@@ -266,7 +272,7 @@ describe("worktreeCommand", () => {
 			await worktreeCommand(["clean"]);
 			const out = output();
 
-			expect(out).toBe("No worktrees to clean.\n");
+			expect(out).toContain("No worktrees to clean");
 		});
 
 		test("with completed agent worktree removes it and reports count", async () => {
@@ -308,7 +314,8 @@ describe("worktreeCommand", () => {
 			await worktreeCommand(["clean"]);
 			const out = output();
 
-			expect(out).toContain("Removed: overstory/completed-agent/task-done");
+			expect(out).toContain("Removed");
+			expect(out).toContain("overstory/completed-agent/task-done");
 			expect(out).toContain("Cleaned 1 worktree");
 
 			// Verify the worktree directory is gone
@@ -455,7 +462,7 @@ describe("worktreeCommand", () => {
 			const out = output();
 
 			// Stalled agents should not be cleaned by default (only completed/zombie are cleaned)
-			expect(out).toBe("No worktrees to clean.\n");
+			expect(out).toContain("No worktrees to clean");
 		});
 
 		test("--completed flag only cleans completed agents", async () => {
@@ -704,7 +711,7 @@ describe("worktreeCommand", () => {
 
 			// Worktree should be removed
 			expect(existsSync(wtPath)).toBe(false);
-			expect(out).toContain("Removed: overstory/unmerged-agent/task-force");
+			expect(out).toContain("overstory/unmerged-agent/task-force");
 		});
 
 		test("without --force, removes worktrees whose branches ARE merged", async () => {