@os-eco/overstory-cli 0.8.6 → 0.8.7

package/src/commands/dashboard.ts

@@ -40,7 +40,13 @@ import { openSessionStore } from "../sessions/compat.ts";
 import type { SessionStore } from "../sessions/store.ts";
 import { createTrackerClient, resolveBackend } from "../tracker/factory.ts";
 import type { TrackerIssue } from "../tracker/types.ts";
-import type { EventStore, MailMessage, StoredEvent } from "../types.ts";
+import type {
+	AgentSession,
+	EventStore,
+	MailMessage,
+	OverstoryConfig,
+	StoredEvent,
+} from "../types.ts";
 import { evaluateHealth } from "../watchdog/health.ts";
 import { isProcessAlive } from "../worktree/tmux.ts";
 import { getCachedTmuxSessions, getCachedWorktrees, type StatusData } from "./status.ts";
@@ -296,6 +302,14 @@ interface TrackerCache {
 let trackerCache: TrackerCache | null = null;
 const TRACKER_CACHE_TTL_MS = 10_000; // 10 seconds
 
+/** Session data cached between ticks — stale-on-error fallback. */
+interface SessionDataCache {
+	sessions: AgentSession[];
+}
+
+/** Module-level session cache (persists across poll ticks, used as fallback on SQLite errors). */
+let sessionDataCache: SessionDataCache | null = null;
+
 interface DashboardData {
 	currentRunId?: string | null;
 	status: StatusData;
@@ -309,6 +323,8 @@ interface DashboardData {
 	tasks: TrackerIssue[];
 	recentEvents: StoredEvent[];
 	feedColorMap: Map<string, (s: string) => string>;
+	/** Runtime config for resolving per-capability runtime names in the agent panel. */
+	runtimeConfig?: OverstoryConfig["runtime"];
 }
 
 /**
@@ -336,9 +352,17 @@ async function loadDashboardData(
 	runId?: string | null,
 	thresholds?: { staleMs: number; zombieMs: number },
 	eventBuffer?: EventBuffer,
+	runtimeConfig?: OverstoryConfig["runtime"],
 ): Promise<DashboardData> {
-	// Get all sessions from the pre-opened session store
-	const allSessions = stores.sessionStore.getAll();
+	// Get all sessions from the pre-opened session store — fall back to cache on SQLite errors.
+	let allSessions: AgentSession[];
+	try {
+		allSessions = stores.sessionStore.getAll();
+		sessionDataCache = { sessions: allSessions };
+	} catch {
+		// SQLite lock contention or I/O error — use last known sessions
+		allSessions = sessionDataCache?.sessions ?? [];
+	}
 
 	// Get worktrees and tmux sessions via cached subprocess helpers
 	const worktrees = await getCachedWorktrees(root);
@@ -347,18 +371,22 @@ async function loadDashboardData(
 	// Evaluate health for active agents using the same logic as the watchdog.
 	const tmuxSessionNames = new Set(tmuxSessions.map((s) => s.name));
 	const healthThresholds = thresholds ?? { staleMs: 300_000, zombieMs: 600_000 };
-	for (const session of allSessions) {
-		if (session.state === "completed") continue;
-		const tmuxAlive = tmuxSessionNames.has(session.tmuxSession);
-		const check = evaluateHealth(session, tmuxAlive, healthThresholds);
-		if (check.state !== session.state) {
-			try {
-				stores.sessionStore.updateState(session.agentName, check.state);
-				session.state = check.state;
-			} catch {
-				// Best effort: don't fail dashboard if update fails
+	try {
+		for (const session of allSessions) {
+			if (session.state === "completed") continue;
+			const tmuxAlive = tmuxSessionNames.has(session.tmuxSession);
+			const check = evaluateHealth(session, tmuxAlive, healthThresholds);
+			if (check.state !== session.state) {
+				try {
+					stores.sessionStore.updateState(session.agentName, check.state);
+					session.state = check.state;
+				} catch {
+					// Best effort: don't fail dashboard if update fails
+				}
 			}
 		}
+	} catch {
+		// Best effort: evaluateHealth loop should not crash the dashboard
 	}
 
 	// If run-scoped, filter agents to only those belonging to the current run.
@@ -519,6 +547,7 @@ async function loadDashboardData(
 		tasks,
 		recentEvents,
 		feedColorMap,
+		runtimeConfig,
 	};
 }
 
@@ -536,6 +565,18 @@ function renderHeader(width: number, interval: number, currentRunId?: string | n
 	return `${line}\n${separator}`;
 }
 
+/**
+ * Resolve the runtime name for a given capability from config.
+ * Mirrors the lookup chain in runtimes/registry.ts getRuntime():
+ *   capabilities[cap] > runtime.default > "claude"
+ */
+function resolveRuntimeName(
+	capability: string,
+	runtimeConfig?: OverstoryConfig["runtime"],
+): string {
+	return runtimeConfig?.capabilities?.[capability] ?? runtimeConfig?.default ?? "claude";
+}
+
 /**
  * Render the agent panel (left 60%, dynamic height).
  */
@@ -556,7 +597,7 @@ export function renderAgentPanel(
 	output += `${CURSOR.cursorTo(startRow, 1)}${headerLine}${headerPadding}${dimBox.vertical}\n`;
 
 	// Column headers
-	const colStr = `${dimBox.vertical} St Name            Capability    State      Task ID          Duration  Live `;
+	const colStr = `${dimBox.vertical} St Name            Capability    Runtime   State      Task ID          Duration  Live `;
 	const colPadding = " ".repeat(
 		Math.max(0, leftWidth - visibleLength(colStr) - visibleLength(dimBox.vertical)),
 	);
@@ -588,6 +629,8 @@ export function renderAgentPanel(
 		const stateColorFn = stateColor(agent.state);
 		const name = accent(pad(truncate(agent.agentName, 15), 15));
 		const capability = pad(truncate(agent.capability, 12), 12);
+		const runtimeName = resolveRuntimeName(agent.capability, data.runtimeConfig);
+		const runtime = pad(truncate(runtimeName, 8), 8);
 		const state = pad(agent.state, 10);
 		const taskId = accent(pad(truncate(agent.taskId, 16), 16));
 		const endTime =
@@ -602,7 +645,7 @@ export function renderAgentPanel(
 			: data.status.tmuxSessions.some((s) => s.name === agent.tmuxSession);
 		const aliveDot = alive ? color.green(">") : color.red("x");
 
-		const lineContent = `${dimBox.vertical} ${stateColorFn(icon)}  ${name} ${capability} ${stateColorFn(state)} ${taskId} ${durationPadded} ${aliveDot}    `;
+		const lineContent = `${dimBox.vertical} ${stateColorFn(icon)}  ${name} ${capability} ${color.dim(runtime)} ${stateColorFn(state)} ${taskId} ${durationPadded} ${aliveDot}    `;
 		const linePadding = " ".repeat(
 			Math.max(0, leftWidth - visibleLength(lineContent) - visibleLength(dimBox.vertical)),
 		);
@@ -1020,10 +1063,33 @@ async function executeDashboard(opts: DashboardOpts): Promise<void> {
 		process.exit(0);
 	});
 
-	// Poll loop
+	// Poll loop — errors are caught per-tick so transient DB failures never crash the dashboard.
+	let lastGoodData: DashboardData | null = null;
+	let lastErrorMsg: string | null = null;
 	while (running) {
-		const data = await loadDashboardData(root, stores, runId, thresholds, eventBuffer);
-		renderDashboard(data, interval);
+		try {
+			const data = await loadDashboardData(
+				root,
+				stores,
+				runId,
+				thresholds,
+				eventBuffer,
+				config.runtime,
+			);
+			lastGoodData = data;
+			lastErrorMsg = null;
+			renderDashboard(data, interval);
+		} catch (err) {
+			// Render last good frame so the TUI stays alive, then show the error inline.
+			if (lastGoodData) {
+				renderDashboard(lastGoodData, interval);
+			}
+			lastErrorMsg = err instanceof Error ? err.message : String(err);
+			const w = process.stdout.columns ?? 100;
+			const h = process.stdout.rows ?? 30;
+			const errLine = `${CURSOR.cursorTo(h, 1)}\x1b[31m⚠ DB error (retrying):\x1b[0m ${truncate(lastErrorMsg, w - 30)}`;
+			process.stdout.write(errLine);
+		}
 		await Bun.sleep(interval);
 	}
 }

package/src/commands/ecosystem.test.ts

@@ -0,0 +1,101 @@
+/**
+ * Tests for the ov ecosystem command.
+ *
+ * Structural tests for CLI registration, plus a smoke test that runs the
+ * actual command and verifies the JSON output shape. The smoke test hits
+ * real CLIs and the npm registry, so it requires network access.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { createEcosystemCommand, executeEcosystem } from "./ecosystem.ts";
+
+describe("createEcosystemCommand — CLI structure", () => {
+	test("command has correct name", () => {
+		const cmd = createEcosystemCommand();
+		expect(cmd.name()).toBe("ecosystem");
+	});
+
+	test("description mentions os-eco", () => {
+		const cmd = createEcosystemCommand();
+		expect(cmd.description().toLowerCase()).toContain("os-eco");
+	});
+
+	test("has --json option", () => {
+		const cmd = createEcosystemCommand();
+		const optionNames = cmd.options.map((o) => o.long);
+		expect(optionNames).toContain("--json");
+	});
+
+	test("returns a Command instance", () => {
+		const cmd = createEcosystemCommand();
+		expect(typeof cmd.parse).toBe("function");
+	});
+});
+
+describe("executeEcosystem — JSON output shape", () => {
+	test("--json produces valid JSON with expected structure", async () => {
+		// Capture stdout
+		const chunks: string[] = [];
+		const originalWrite = process.stdout.write;
+		process.stdout.write = (chunk: string | Uint8Array) => {
+			chunks.push(typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk));
+			return true;
+		};
+
+		try {
+			await executeEcosystem({ json: true });
+		} finally {
+			process.stdout.write = originalWrite;
+		}
+
+		const output = chunks.join("");
+		const parsed = JSON.parse(output.trim());
+
+		// Envelope
+		expect(parsed.success).toBe(true);
+		expect(parsed.command).toBe("ecosystem");
+
+		// Tools array
+		expect(Array.isArray(parsed.tools)).toBe(true);
+		expect(parsed.tools.length).toBeGreaterThan(0);
+
+		// Each tool has required fields
+		for (const tool of parsed.tools) {
+			expect(typeof tool.name).toBe("string");
+			expect(typeof tool.cli).toBe("string");
+			expect(typeof tool.npm).toBe("string");
+			expect(typeof tool.installed).toBe("boolean");
+		}
+
+		// Summary
+		expect(typeof parsed.summary).toBe("object");
+		expect(typeof parsed.summary.total).toBe("number");
+		expect(typeof parsed.summary.installed).toBe("number");
+		expect(typeof parsed.summary.missing).toBe("number");
+		expect(typeof parsed.summary.outdated).toBe("number");
+		expect(parsed.summary.total).toBe(parsed.tools.length);
+	}, 30_000); // Network calls may be slow
+
+	test("includes overstory in tool list", async () => {
+		const chunks: string[] = [];
+		const originalWrite = process.stdout.write;
+		process.stdout.write = (chunk: string | Uint8Array) => {
+			chunks.push(typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk));
+			return true;
+		};
+
+		try {
+			await executeEcosystem({ json: true });
+		} finally {
+			process.stdout.write = originalWrite;
+		}
+
+		const parsed = JSON.parse(chunks.join("").trim());
+		const overstory = parsed.tools.find((t: { name: string }) => t.name === "overstory");
+		expect(overstory).toBeDefined();
+		// In CI, `ov` may not be globally installed — only assert version when installed
+		if (overstory.installed) {
+			expect(overstory.version).toBeDefined();
+		}
+	}, 30_000);
+});

package/src/commands/init.test.ts

@@ -839,6 +839,80 @@ describe("initCommand: scaffold commit", () => {
 	});
 });
 
+describe("initCommand: spawner error resilience", () => {
+	let tempDir: string;
+	let originalCwd: string;
+	let originalWrite: typeof process.stdout.write;
+
+	beforeEach(async () => {
+		tempDir = await createTempGitRepo();
+		originalCwd = process.cwd();
+		process.chdir(tempDir);
+		originalWrite = process.stdout.write;
+		process.stdout.write = (() => true) as typeof process.stdout.write;
+	});
+
+	afterEach(async () => {
+		process.chdir(originalCwd);
+		process.stdout.write = originalWrite;
+		await cleanupTempDir(tempDir);
+	});
+
+	test("spawner that throws ENOENT does not crash init — degrades gracefully", async () => {
+		const throwingSpawner: Spawner = async (args) => {
+			const key = args.join(" ");
+			// Allow git operations through (git add, git diff, git commit)
+			if (key.startsWith("git")) return { exitCode: 0, stdout: "", stderr: "" };
+			// Simulate ecosystem tool binary not found (ENOENT)
+			throw new Error(`spawn ENOENT: ${args[0]}: not found`);
+		};
+
+		// Should not throw — graceful degradation
+		await expect(initCommand({ _spawner: throwingSpawner })).resolves.toBeUndefined();
+
+		// Core .overstory files should still be created
+		const configPath = join(tempDir, ".overstory", "config.yaml");
+		expect(await Bun.file(configPath).exists()).toBe(true);
+	});
+
+	test("throwing spawner causes all ecosystem tools to be skipped", async () => {
+		const calls: string[][] = [];
+		const throwingSpawner: Spawner = async (args) => {
+			calls.push(args);
+			const key = args.join(" ");
+			if (key.startsWith("git")) return { exitCode: 0, stdout: "", stderr: "" };
+			throw new Error("spawn ENOENT");
+		};
+
+		await initCommand({ _spawner: throwingSpawner });
+
+		// init and onboard should NOT be called when --version throws
+		expect(calls).not.toContainEqual(["ml", "init"]);
+		expect(calls).not.toContainEqual(["sd", "init"]);
+		expect(calls).not.toContainEqual(["cn", "init"]);
+		expect(calls).not.toContainEqual(["ml", "onboard"]);
+		expect(calls).not.toContainEqual(["sd", "onboard"]);
+		expect(calls).not.toContainEqual(["cn", "onboard"]);
+	});
+
+	test("spawner that throws only on init (not --version) still skips gracefully", async () => {
+		// --version succeeds (tool appears installed), but init itself throws
+		const throwingInitSpawner: Spawner = async (args) => {
+			const key = args.join(" ");
+			if (key.startsWith("git")) return { exitCode: 0, stdout: "", stderr: "" };
+			if (key.endsWith("--version")) return { exitCode: 0, stdout: "1.0.0", stderr: "" };
+			if (key.endsWith("onboard")) return { exitCode: 0, stdout: "", stderr: "" };
+			// init itself throws
+			throw new Error("spawn ENOENT on init");
+		};
+
+		await expect(initCommand({ _spawner: throwingInitSpawner })).resolves.toBeUndefined();
+
+		const configPath = join(tempDir, ".overstory", "config.yaml");
+		expect(await Bun.file(configPath).exists()).toBe(true);
+	});
+});
+
 describe("initCommand: .gitattributes setup", () => {
 	let tempDir: string;
 	let originalCwd: string;

package/src/commands/init.ts

@@ -32,15 +32,21 @@ export type Spawner = (
 ) => Promise<{ exitCode: number; stdout: string; stderr: string }>;
 
 const defaultSpawner: Spawner = async (args, opts) => {
-	const proc = Bun.spawn(args, {
-		cwd: opts?.cwd,
-		stdout: "pipe",
-		stderr: "pipe",
-	});
-	const exitCode = await proc.exited;
-	const stdout = await new Response(proc.stdout).text();
-	const stderr = await new Response(proc.stderr).text();
-	return { exitCode, stdout, stderr };
+	try {
+		const proc = Bun.spawn(args, {
+			cwd: opts?.cwd,
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		const exitCode = await proc.exited;
+		const stdout = await new Response(proc.stdout).text();
+		const stderr = await new Response(proc.stderr).text();
+		return { exitCode, stdout, stderr };
+	} catch (err) {
+		// Binary not found (ENOENT) or other spawn failure — treat as non-zero exit
+		const message = err instanceof Error ? err.message : String(err);
+		return { exitCode: 1, stdout: "", stderr: message };
+	}
 };
 
 interface SiblingTool {
@@ -80,8 +86,12 @@ export function resolveToolSet(opts: InitOptions): SiblingTool[] {
 }
 
 async function isToolInstalled(cli: string, spawner: Spawner): Promise<boolean> {
-	const result = await spawner([cli, "--version"]);
-	return result.exitCode === 0;
+	try {
+		const result = await spawner([cli, "--version"]);
+		return result.exitCode === 0;
+	} catch {
+		return false;
+	}
 }
 
 async function initSiblingTool(
@@ -98,7 +108,15 @@ async function initSiblingTool(
 		return "skipped";
 	}
 
-	const result = await spawner([tool.cli, ...tool.initCmd], { cwd: projectRoot });
+	let result: { exitCode: number; stdout: string; stderr: string };
+	try {
+		result = await spawner([tool.cli, ...tool.initCmd], { cwd: projectRoot });
+	} catch (err) {
+		// Spawn failure (e.g. ENOENT) — treat as not installed
+		const message = err instanceof Error ? err.message : String(err);
+		printWarning(`${tool.name} init failed`, message);
+		return "skipped";
+	}
 	if (result.exitCode !== 0) {
 		// Check if dot directory already exists (already initialized)
 		try {
@@ -123,8 +141,12 @@ async function onboardTool(
 	const installed = await isToolInstalled(tool.cli, spawner);
 	if (!installed) return "current";
 
-	const result = await spawner([tool.cli, ...tool.onboardCmd], { cwd: projectRoot });
-	return result.exitCode === 0 ? "appended" : "current";
+	try {
+		const result = await spawner([tool.cli, ...tool.onboardCmd], { cwd: projectRoot });
+		return result.exitCode === 0 ? "appended" : "current";
+	} catch {
+		return "current";
+	}
 }
 
 /**

package/src/commands/sling.test.ts

@@ -22,6 +22,7 @@ import {
 	extractMulchRecordIds,
 	generateAgentName,
 	getCurrentBranch,
+	getSharedWritableDirs,
 	inferDomainsFromFiles,
 	isRunningAsRoot,
 	parentHasScouts,
@@ -343,6 +344,17 @@ describe("shouldShowScoutWarning", () => {
 	});
 });
 
+describe("getSharedWritableDirs", () => {
+	test("returns only .overstory for non-lead agents", () => {
+		expect(getSharedWritableDirs("/repo", "builder")).toEqual(["/repo/.overstory"]);
+		expect(getSharedWritableDirs("/repo", "scout")).toEqual(["/repo/.overstory"]);
+	});
+
+	test("includes canonical .git for lead agents", () => {
+		expect(getSharedWritableDirs("/repo", "lead")).toEqual(["/repo/.overstory", "/repo/.git"]);
+	});
+});
+
 describe("generateAgentName", () => {
 	test("returns capability-taskId when no collision", () => {
 		expect(generateAgentName("builder", "overstory-2f10", [])).toBe("builder-overstory-2f10");
@@ -1005,6 +1017,27 @@ describe("sling provider env injection building blocks", () => {
 		expect(combined.OVERSTORY_WORKTREE_PATH).toBe("/tmp/wt");
 	});
 
+	test("env dict from resolveModel can be spread with OVERSTORY_TASK_ID", () => {
+		const config = makeConfig(
+			{ builder: "openrouter/anthropic/claude-3-5-sonnet" },
+			{ openrouter: { type: "gateway", baseUrl: "https://openrouter.ai/api/v1" } },
+		);
+		const manifest = makeManifest();
+
+		const { env } = resolveModel(config, manifest, "builder", "sonnet");
+		// Simulates the spread in slingCommand: { ...env, OVERSTORY_AGENT_NAME: name, OVERSTORY_WORKTREE_PATH: wt, OVERSTORY_TASK_ID: taskId }
+		const combined: Record<string, string> = {
+			...(env ?? {}),
+			OVERSTORY_AGENT_NAME: "test-builder",
+			OVERSTORY_WORKTREE_PATH: "/tmp/wt",
+			OVERSTORY_TASK_ID: "overstory-1234",
+		};
+
+		expect(combined.OVERSTORY_AGENT_NAME).toBe("test-builder");
+		expect(combined.OVERSTORY_WORKTREE_PATH).toBe("/tmp/wt");
+		expect(combined.OVERSTORY_TASK_ID).toBe("overstory-1234");
+	});
+
 	test("resolveModel returns no env for native anthropic provider", () => {
 		const config = makeConfig({ builder: "sonnet" }, { anthropic: { type: "native" } });
 		const manifest = makeManifest();