@os-eco/overstory-cli 0.8.4 → 0.8.6

package/src/commands/init.test.ts

@@ -702,6 +702,143 @@ describe("initCommand: ecosystem bootstrap", () => {
 	});
 });
 
+describe("initCommand: scaffold commit", () => {
+	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("git commit is called with scaffold message when git add succeeds and changes are staged", async () => {
+		const calls: string[][] = [];
+		const spawner: import("./init.ts").Spawner = async (args) => {
+			calls.push(args);
+			const key = args.join(" ");
+			// Sibling tool calls: all "not installed"
+			if (key.endsWith("--version")) return { exitCode: 1, stdout: "", stderr: "not found" };
+			// git add: success
+			if (key.startsWith("git add")) return { exitCode: 0, stdout: "", stderr: "" };
+			// git diff --cached --quiet: exit 1 means changes are staged
+			if (key.startsWith("git diff --cached --quiet"))
+				return { exitCode: 1, stdout: "", stderr: "" };
+			// git commit: success
+			if (key.startsWith("git commit")) return { exitCode: 0, stdout: "", stderr: "" };
+			return { exitCode: 1, stdout: "", stderr: "not found" };
+		};
+
+		await initCommand({ _spawner: spawner });
+
+		expect(calls).toContainEqual([
+			"git",
+			"commit",
+			"-m",
+			"chore: initialize overstory and ecosystem tools",
+		]);
+	});
+
+	test("git commit is NOT called when git diff reports nothing staged (exit 0)", async () => {
+		const calls: string[][] = [];
+		const spawner: import("./init.ts").Spawner = async (args) => {
+			calls.push(args);
+			const key = args.join(" ");
+			if (key.endsWith("--version")) return { exitCode: 1, stdout: "", stderr: "not found" };
+			if (key.startsWith("git add")) return { exitCode: 0, stdout: "", stderr: "" };
+			// exit 0 = nothing staged
+			if (key.startsWith("git diff --cached --quiet"))
+				return { exitCode: 0, stdout: "", stderr: "" };
+			if (key.startsWith("git commit")) return { exitCode: 0, stdout: "", stderr: "" };
+			return { exitCode: 1, stdout: "", stderr: "not found" };
+		};
+
+		await initCommand({ _spawner: spawner });
+
+		const commitCalls = calls.filter((c) => c[0] === "git" && c[1] === "commit");
+		expect(commitCalls).toHaveLength(0);
+	});
+
+	test("git commit failure does not throw — init still succeeds", async () => {
+		const spawner: import("./init.ts").Spawner = async (args) => {
+			const key = args.join(" ");
+			if (key.endsWith("--version")) return { exitCode: 1, stdout: "", stderr: "not found" };
+			if (key.startsWith("git add")) return { exitCode: 0, stdout: "", stderr: "" };
+			if (key.startsWith("git diff --cached --quiet"))
+				return { exitCode: 1, stdout: "", stderr: "" };
+			// commit fails
+			if (key.startsWith("git commit"))
+				return { exitCode: 1, stdout: "", stderr: "nothing to commit" };
+			return { exitCode: 1, stdout: "", stderr: "not found" };
+		};
+
+		// Should not throw
+		await expect(initCommand({ _spawner: spawner })).resolves.toBeUndefined();
+
+		// .overstory files should still be created
+		const configPath = join(tempDir, ".overstory", "config.yaml");
+		const exists = await Bun.file(configPath).exists();
+		expect(exists).toBe(true);
+	});
+
+	test("git add failure skips commit without throwing", async () => {
+		const calls: string[][] = [];
+		const spawner: import("./init.ts").Spawner = async (args) => {
+			calls.push(args);
+			const key = args.join(" ");
+			if (key.endsWith("--version")) return { exitCode: 1, stdout: "", stderr: "not found" };
+			// git add fails
+			if (key.startsWith("git add")) return { exitCode: 1, stdout: "", stderr: "git add failed" };
+			if (key.startsWith("git commit")) return { exitCode: 0, stdout: "", stderr: "" };
+			return { exitCode: 1, stdout: "", stderr: "not found" };
+		};
+
+		await expect(initCommand({ _spawner: spawner })).resolves.toBeUndefined();
+
+		// commit should NOT have been called since add failed
+		const commitCalls = calls.filter((c) => c[0] === "git" && c[1] === "commit");
+		expect(commitCalls).toHaveLength(0);
+	});
+
+	test("--json output includes scaffoldCommitted boolean", async () => {
+		const spawner: import("./init.ts").Spawner = async (args) => {
+			const key = args.join(" ");
+			if (key.endsWith("--version")) return { exitCode: 1, stdout: "", stderr: "not found" };
+			if (key.startsWith("git add")) return { exitCode: 0, stdout: "", stderr: "" };
+			if (key.startsWith("git diff --cached --quiet"))
+				return { exitCode: 1, stdout: "", stderr: "" };
+			if (key.startsWith("git commit")) return { exitCode: 0, stdout: "", stderr: "" };
+			return { exitCode: 1, stdout: "", stderr: "not found" };
+		};
+
+		let capturedOutput = "";
+		const restoreWrite = process.stdout.write;
+		process.stdout.write = ((chunk: unknown) => {
+			capturedOutput += String(chunk);
+			return true;
+		}) as typeof process.stdout.write;
+
+		await initCommand({ json: true, _spawner: spawner });
+
+		process.stdout.write = restoreWrite;
+
+		const jsonLine = capturedOutput.split("\n").find((line) => line.startsWith('{"success":'));
+		expect(jsonLine).toBeDefined();
+		const parsed = JSON.parse(jsonLine ?? "{}") as Record<string, unknown>;
+		expect(typeof parsed.scaffoldCommitted).toBe("boolean");
+		expect(parsed.scaffoldCommitted).toBe(true);
+	});
+});
+
 describe("initCommand: .gitattributes setup", () => {
 	let tempDir: string;
 	let originalCwd: string;

package/src/commands/init.ts

@@ -815,13 +815,69 @@ export async function initCommand(opts: InitOptions): Promise<void> {
 		}
 	}
 
-	// 12. Output final result
+	// 12. Auto-commit scaffold files so ecosystem dirs are tracked before agents create branches.
+	// Without this, agent branches that add files to .mulch/.seeds/.canopy cause
+	// untracked-vs-tracked conflicts in ov merge (overstory-fe42).
+	let scaffoldCommitted = false;
+	const pathsToAdd: string[] = [OVERSTORY_DIR];
+
+	// Add .gitattributes if it exists
+	try {
+		await stat(join(projectRoot, ".gitattributes"));
+		pathsToAdd.push(".gitattributes");
+	} catch {
+		// not present — skip
+	}
+
+	// Add CLAUDE.md if it exists (may have been modified by onboard)
+	try {
+		await stat(join(projectRoot, "CLAUDE.md"));
+		pathsToAdd.push("CLAUDE.md");
+	} catch {
+		// not present — skip
+	}
+
+	// Add sibling tool dirs that were created
+	for (const tool of SIBLING_TOOLS) {
+		try {
+			await stat(join(projectRoot, tool.dotDir));
+			pathsToAdd.push(tool.dotDir);
+		} catch {
+			// not present — skip
+		}
+	}
+
+	const addResult = await spawner(["git", "add", ...pathsToAdd], { cwd: projectRoot });
+	if (addResult.exitCode !== 0) {
+		printWarning("Scaffold commit skipped", addResult.stderr.trim() || "git add failed");
+	} else {
+		// git diff --cached --quiet exits 0 if nothing staged, 1 if changes are staged
+		const diffResult = await spawner(["git", "diff", "--cached", "--quiet"], {
+			cwd: projectRoot,
+		});
+		if (diffResult.exitCode !== 0) {
+			// Changes are staged — commit them
+			const commitResult = await spawner(
+				["git", "commit", "-m", "chore: initialize overstory and ecosystem tools"],
+				{ cwd: projectRoot },
+			);
+			if (commitResult.exitCode === 0) {
+				printSuccess("Committed", "scaffold files");
+				scaffoldCommitted = true;
+			} else {
+				printWarning("Scaffold commit failed", commitResult.stderr.trim() || "git commit failed");
+			}
+		}
+	}
+
+	// 13. Output final result
 	if (opts.json) {
 		jsonOutput("init", {
 			project: projectName,
 			tools: toolResults,
 			onboard: onboardResults,
 			gitattributes: gitattrsUpdated,
+			scaffoldCommitted,
 		});
 		return;
 	}

package/src/commands/inspect.test.ts

@@ -9,7 +9,7 @@
  */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtemp } from "node:fs/promises";
+import { mkdir, mkdtemp } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { ValidationError } from "../errors.ts";
@@ -672,6 +672,7 @@ describe("inspectCommand", () => {
 				toolStats: [],
 				tokenUsage: null,
 				tmuxOutput: null,
+				headlessTurnInfo: null,
 			};
 
 			printInspectData(data);
@@ -710,6 +711,7 @@ describe("inspectCommand", () => {
 				toolStats: [],
 				tokenUsage: null,
 				tmuxOutput: "[Headless agent — showing recent tool events]",
+				headlessTurnInfo: null,
 			};
 
 			printInspectData(data);
@@ -720,6 +722,401 @@ describe("inspectCommand", () => {
 		});
 	});
 
+	// === stdout.log fallback (headless agents) ===
+
+	describe("stdout.log fallback", () => {
+		/** Create a headless session in SessionStore and return the overstoryDir. */
+		async function setupHeadlessSession(
+			agentName: string,
+			worktreePathVal = "/tmp/wt",
+		): Promise<string> {
+			const overstoryDir = join(tempDir, ".overstory");
+			const sessionsDbPath = join(overstoryDir, "sessions.db");
+			const store = createSessionStore(sessionsDbPath);
+			store.upsert({
+				id: `sess-${agentName}`,
+				agentName,
+				capability: "builder",
+				worktreePath: worktreePathVal,
+				branchName: `overstory/headless/${agentName}`,
+				taskId: "overstory-h10",
+				tmuxSession: "", // headless
+				state: "working",
+				pid: process.pid,
+				parentAgent: null,
+				depth: 0,
+				runId: null,
+				startedAt: new Date().toISOString(),
+				lastActivity: new Date().toISOString(),
+				escalationLevel: 0,
+				stalledSince: null,
+				transcriptPath: null,
+			});
+			store.close();
+			return overstoryDir;
+		}
+
+		/** Write NDJSON events to stdout.log in the agent's log dir. */
+		async function writeStdoutLog(
+			overstoryDir: string,
+			agentName: string,
+			events: Record<string, unknown>[],
+		): Promise<void> {
+			const logDir = join(overstoryDir, "logs", agentName, "2026-03-05T14-30-00-000Z");
+			await mkdir(logDir, { recursive: true });
+			const ndjson = `${events.map((e) => JSON.stringify(e)).join("\n")}\n`;
+			await Bun.write(join(logDir, "stdout.log"), ndjson);
+		}
+
+		test("populates recentToolCalls from stdout.log when events.db is empty", async () => {
+			const overstoryDir = await setupHeadlessSession("stdout-tools");
+			await writeStdoutLog(overstoryDir, "stdout-tools", [
+				{
+					type: "tool_start",
+					timestamp: "2026-03-05T14:30:01.000Z",
+					toolName: "Read",
+					argsSummary: "src/index.ts",
+				},
+				{
+					type: "tool_end",
+					timestamp: "2026-03-05T14:30:01.050Z",
+					toolName: "Read",
+					success: true,
+					durationMs: 50,
+				},
+				{
+					type: "tool_start",
+					timestamp: "2026-03-05T14:30:02.000Z",
+					toolName: "Edit",
+					argsSummary: "src/commands/inspect.ts",
+				},
+				{
+					type: "tool_end",
+					timestamp: "2026-03-05T14:30:02.200Z",
+					toolName: "Edit",
+					success: true,
+					durationMs: 200,
+				},
+			]);
+
+			const data = await gatherInspectData(tempDir, "stdout-tools", { noTmux: true });
+
+			expect(data.recentToolCalls.length).toBe(2);
+			expect(data.recentToolCalls[0]?.toolName).toBe("Read");
+			expect(data.recentToolCalls[0]?.durationMs).toBe(50);
+			expect(data.recentToolCalls[0]?.args).toBe("src/index.ts");
+			expect(data.recentToolCalls[1]?.toolName).toBe("Edit");
+			expect(data.recentToolCalls[1]?.durationMs).toBe(200);
+		});
+
+		test("populates tokenUsage from turn_end events when metrics.db is absent", async () => {
+			const overstoryDir = await setupHeadlessSession("stdout-tokens");
+			await writeStdoutLog(overstoryDir, "stdout-tokens", [
+				{
+					type: "turn_start",
+					timestamp: "2026-03-05T14:30:00.000Z",
+					turn: 1,
+				},
+				{
+					type: "turn_end",
+					timestamp: "2026-03-05T14:30:05.000Z",
+					inputTokens: 1000,
+					outputTokens: 500,
+					cacheReadTokens: 200,
+					model: "claude-sonnet-4-6",
+					contextUtilization: 0.3,
+				},
+				{
+					type: "turn_start",
+					timestamp: "2026-03-05T14:30:06.000Z",
+					turn: 2,
+				},
+				{
+					type: "turn_end",
+					timestamp: "2026-03-05T14:30:10.000Z",
+					inputTokens: 800,
+					outputTokens: 300,
+					cacheReadTokens: 150,
+					model: "claude-sonnet-4-6",
+					contextUtilization: 0.45,
+				},
+			]);
+
+			const data = await gatherInspectData(tempDir, "stdout-tokens", { noTmux: true });
+
+			// Token usage should be cumulative across turn_end events
+			expect(data.tokenUsage).not.toBeNull();
+			expect(data.tokenUsage?.inputTokens).toBe(1800);
+			expect(data.tokenUsage?.outputTokens).toBe(800);
+			expect(data.tokenUsage?.cacheReadTokens).toBe(350);
+			expect(data.tokenUsage?.modelUsed).toBe("claude-sonnet-4-6");
+			expect(data.tokenUsage?.cacheCreationTokens).toBe(0);
+			expect(data.tokenUsage?.estimatedCostUsd).toBeNull();
+		});
+
+		test("populates headlessTurnInfo with turn number, context utilization, and isMidTool", async () => {
+			const overstoryDir = await setupHeadlessSession("stdout-turn-info");
+			await writeStdoutLog(overstoryDir, "stdout-turn-info", [
+				{
+					type: "turn_start",
+					timestamp: "2026-03-05T14:30:00.000Z",
+					turn: 3,
+				},
+				{
+					type: "tool_start",
+					timestamp: "2026-03-05T14:30:01.000Z",
+					toolName: "Bash",
+					argsSummary: "bun test",
+				},
+				// No tool_end — still mid-tool
+			]);
+
+			const data = await gatherInspectData(tempDir, "stdout-turn-info", { noTmux: true });
+
+			expect(data.headlessTurnInfo).not.toBeNull();
+			expect(data.headlessTurnInfo?.currentTurn).toBe(3);
+			expect(data.headlessTurnInfo?.isMidTool).toBe(true);
+		});
+
+		test("isMidTool is false when last event is not tool_start", async () => {
+			const overstoryDir = await setupHeadlessSession("stdout-between-turns");
+			await writeStdoutLog(overstoryDir, "stdout-between-turns", [
+				{
+					type: "turn_start",
+					timestamp: "2026-03-05T14:30:00.000Z",
+					turn: 2,
+				},
+				{
+					type: "turn_end",
+					timestamp: "2026-03-05T14:30:05.000Z",
+					inputTokens: 500,
+					outputTokens: 200,
+					cacheReadTokens: 0,
+					model: "claude-sonnet-4-6",
+					contextUtilization: 0.2,
+				},
+			]);
+
+			const data = await gatherInspectData(tempDir, "stdout-between-turns", { noTmux: true });
+
+			expect(data.headlessTurnInfo?.isMidTool).toBe(false);
+			expect(data.headlessTurnInfo?.contextUtilization).toBeCloseTo(0.2);
+		});
+
+		test("does not overwrite tokenUsage from metrics.db with stdout.log data", async () => {
+			const overstoryDir = await setupHeadlessSession("stdout-no-override");
+			const metricsDbPath = join(overstoryDir, "metrics.db");
+
+			// Metrics DB has authoritative data
+			const metricsStore = createMetricsStore(metricsDbPath);
+			metricsStore.recordSession(
+				makeMetrics({
+					agentName: "stdout-no-override",
+					inputTokens: 9999,
+					outputTokens: 8888,
+					modelUsed: "claude-opus-4-6",
+				}),
+			);
+			metricsStore.close();
+
+			// stdout.log also has token data
+			await writeStdoutLog(overstoryDir, "stdout-no-override", [
+				{
+					type: "turn_end",
+					timestamp: "2026-03-05T14:30:05.000Z",
+					inputTokens: 100,
+					outputTokens: 50,
+					cacheReadTokens: 0,
+					model: "claude-sonnet-4-6",
+					contextUtilization: 0.1,
+				},
+			]);
+
+			const data = await gatherInspectData(tempDir, "stdout-no-override", { noTmux: true });
+
+			// metrics.db data wins
+			expect(data.tokenUsage?.inputTokens).toBe(9999);
+			expect(data.tokenUsage?.modelUsed).toBe("claude-opus-4-6");
+		});
+
+		test("gracefully handles missing stdout.log", async () => {
+			const overstoryDir = await setupHeadlessSession("stdout-missing");
+			// Create log dir but no stdout.log inside it
+			await mkdir(join(overstoryDir, "logs", "stdout-missing", "2026-03-05T14-30-00-000Z"), {
+				recursive: true,
+			});
+
+			const data = await gatherInspectData(tempDir, "stdout-missing", { noTmux: true });
+
+			expect(data.recentToolCalls).toEqual([]);
+			expect(data.tokenUsage).toBeNull();
+			expect(data.headlessTurnInfo).toBeNull();
+		});
+
+		test("gracefully handles no log dir at all", async () => {
+			await setupHeadlessSession("stdout-no-log-dir");
+			// Don't create any log dir
+
+			const data = await gatherInspectData(tempDir, "stdout-no-log-dir", { noTmux: true });
+
+			expect(data.recentToolCalls).toEqual([]);
+			expect(data.headlessTurnInfo).toBeNull();
+		});
+
+		test("respects limit when populating recentToolCalls from stdout.log", async () => {
+			const overstoryDir = await setupHeadlessSession("stdout-limit");
+			const events: Record<string, unknown>[] = [];
+			for (let i = 0; i < 10; i++) {
+				events.push({
+					type: "tool_start",
+					timestamp: `2026-03-05T14:30:0${i}.000Z`,
+					toolName: "Read",
+					argsSummary: `src/file${i}.ts`,
+				});
+				events.push({
+					type: "tool_end",
+					timestamp: `2026-03-05T14:30:0${i}.050Z`,
+					toolName: "Read",
+					success: true,
+					durationMs: 50,
+				});
+			}
+			await writeStdoutLog(overstoryDir, "stdout-limit", events);
+
+			const data = await gatherInspectData(tempDir, "stdout-limit", {
+				noTmux: true,
+				limit: 3,
+			});
+
+			expect(data.recentToolCalls.length).toBe(3);
+		});
+
+		test("printInspectData shows Turn Progress section when headlessTurnInfo is set", () => {
+			const data = {
+				session: {
+					id: "sess-tp",
+					agentName: "headless-turn-progress",
+					capability: "builder",
+					worktreePath: "/tmp/wt",
+					branchName: "overstory/headless/tp",
+					taskId: "overstory-tp",
+					tmuxSession: "",
+					state: "working" as const,
+					pid: 12345,
+					parentAgent: null,
+					depth: 0,
+					runId: null,
+					startedAt: new Date().toISOString(),
+					lastActivity: new Date().toISOString(),
+					escalationLevel: 0,
+					stalledSince: null,
+					transcriptPath: null,
+				},
+				timeSinceLastActivity: 1000,
+				recentToolCalls: [],
+				currentFile: null,
+				toolStats: [],
+				tokenUsage: null,
+				tmuxOutput: null,
+				headlessTurnInfo: {
+					currentTurn: 5,
+					contextUtilization: 0.625,
+					isMidTool: false,
+				},
+			};
+
+			printInspectData(data);
+
+			const out = output();
+			expect(out).toContain("Turn Progress");
+			expect(out).toContain("5");
+			expect(out).toContain("62.5%");
+			expect(out).toContain("between turns");
+		});
+
+		test("printInspectData shows executing tool status when isMidTool is true", () => {
+			const data = {
+				session: {
+					id: "sess-mid",
+					agentName: "headless-mid-tool",
+					capability: "builder",
+					worktreePath: "/tmp/wt",
+					branchName: "overstory/headless/mid",
+					taskId: "overstory-mid",
+					tmuxSession: "",
+					state: "working" as const,
+					pid: 12345,
+					parentAgent: null,
+					depth: 0,
+					runId: null,
+					startedAt: new Date().toISOString(),
+					lastActivity: new Date().toISOString(),
+					escalationLevel: 0,
+					stalledSince: null,
+					transcriptPath: null,
+				},
+				timeSinceLastActivity: 500,
+				recentToolCalls: [],
+				currentFile: null,
+				toolStats: [],
+				tokenUsage: null,
+				tmuxOutput: null,
+				headlessTurnInfo: {
+					currentTurn: 2,
+					contextUtilization: null,
+					isMidTool: true,
+				},
+			};
+
+			printInspectData(data);
+
+			const out = output();
+			expect(out).toContain("Turn Progress");
+			expect(out).toContain("executing tool");
+		});
+
+		test("uses latest log dir when multiple exist", async () => {
+			const overstoryDir = await setupHeadlessSession("stdout-multi-dir");
+			const agentLogsDir = join(overstoryDir, "logs", "stdout-multi-dir");
+
+			// Create two log dirs — the later one has the important data
+			const oldDir = join(agentLogsDir, "2026-03-05T10-00-00-000Z");
+			const newDir = join(agentLogsDir, "2026-03-05T14-30-00-000Z");
+			await mkdir(oldDir, { recursive: true });
+			await mkdir(newDir, { recursive: true });
+
+			// Old dir: no useful data
+			await Bun.write(join(oldDir, "stdout.log"), "");
+
+			// New dir: has turn data
+			const events = [
+				{
+					type: "turn_start",
+					timestamp: "2026-03-05T14:30:00.000Z",
+					turn: 7,
+				},
+				{
+					type: "turn_end",
+					timestamp: "2026-03-05T14:30:05.000Z",
+					inputTokens: 2000,
+					outputTokens: 700,
+					cacheReadTokens: 300,
+					model: "claude-sonnet-4-6",
+					contextUtilization: 0.55,
+				},
+			];
+			await Bun.write(
+				join(newDir, "stdout.log"),
+				`${events.map((e) => JSON.stringify(e)).join("\n")}\n`,
+			);
+
+			const data = await gatherInspectData(tempDir, "stdout-multi-dir", { noTmux: true });
+
+			expect(data.headlessTurnInfo?.currentTurn).toBe(7);
+			expect(data.tokenUsage?.inputTokens).toBe(2000);
+		});
+	});
+
 	// === Human-readable output ===
 
 	describe("human-readable output", () => {