@os-eco/overstory-cli 0.6.8 → 0.6.10

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";
@@ -560,7 +561,7 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 		}
 
 		// 9. Deploy hooks config (capability-specific guards)
-		await deployHooks(worktreePath, name, capability);
+		await deployHooks(worktreePath, name, capability, config.project.qualityGates);
 
 		// 9b. Send auto-dispatch mail so it exists when SessionStart hook fires.
 		// This eliminates the race where coordinator sends dispatch AFTER agent boots.
@@ -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);

package/src/commands/stop.ts

@@ -11,6 +11,7 @@
 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";
@@ -109,17 +110,15 @@ export async function stopCommand(
 		}
 
 		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 {
 			printSuccess("Agent stopped", agentName);
 			if (alive) {

package/src/commands/supervisor.ts

@@ -20,6 +20,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 { createTrackerClient, resolveBackend, trackerCliName } from "../tracker/factory.ts";
@@ -230,7 +231,7 @@ async function startSupervisor(opts: {
 		};
 
 		if (opts.json) {
-			process.stdout.write(`${JSON.stringify(output)}\n`);
+			jsonOutput("supervisor start", output);
 		} else {
 			printSuccess("Supervisor started", opts.name);
 			process.stdout.write(`  Tmux:    ${tmuxSession}\n`);
@@ -291,7 +292,7 @@ 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 {
 			printSuccess("Supervisor stopped", opts.name);
 		}
@@ -325,7 +326,7 @@ 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 {
 					printHint("Supervisor not running");
 				}
@@ -357,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`);
@@ -377,7 +378,7 @@ 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 {
 					printHint("No supervisor sessions found");
 				}
@@ -411,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/upgrade.test.ts

@@ -0,0 +1,46 @@
+/**
+ * Tests for the ov upgrade command.
+ *
+ * Structural tests for CLI registration and option parsing.
+ * Network calls and subprocess execution happen via real implementations;
+ * this file tests command structure and output format rather than side effects.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { createUpgradeCommand } from "./upgrade.ts";
+
+describe("createUpgradeCommand — CLI structure", () => {
+	test("command has correct name", () => {
+		const cmd = createUpgradeCommand();
+		expect(cmd.name()).toBe("upgrade");
+	});
+
+	test("description mentions overstory", () => {
+		const cmd = createUpgradeCommand();
+		expect(cmd.description().toLowerCase()).toContain("overstory");
+	});
+
+	test("has --check option", () => {
+		const cmd = createUpgradeCommand();
+		const optionNames = cmd.options.map((o) => o.long);
+		expect(optionNames).toContain("--check");
+	});
+
+	test("has --json option", () => {
+		const cmd = createUpgradeCommand();
+		const optionNames = cmd.options.map((o) => o.long);
+		expect(optionNames).toContain("--json");
+	});
+
+	test("has --all option", () => {
+		const cmd = createUpgradeCommand();
+		const optionNames = cmd.options.map((o) => o.long);
+		expect(optionNames).toContain("--all");
+	});
+
+	test("returns a Command instance", () => {
+		const cmd = createUpgradeCommand();
+		// Commander Command instances have a .parse method
+		expect(typeof cmd.parse).toBe("function");
+	});
+});