@os-eco/overstory-cli 0.7.0 → 0.7.3

package/src/commands/log.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtemp, readdir, rm, stat } from "node:fs/promises";
+import { mkdir, mkdtemp, readdir, stat } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { ValidationError } from "../errors.ts";
@@ -9,8 +9,9 @@ import { createMailStore } from "../mail/store.ts";
 import { createMetricsStore } from "../metrics/store.ts";
 import type { MulchClient } from "../mulch/client.ts";
 import { createRunStore, createSessionStore } from "../sessions/store.ts";
+import { cleanupTempDir } from "../test-helpers.ts";
 import type { AgentSession, MulchLearnResult, StoredEvent } from "../types.ts";
-import { autoRecordExpertise, logCommand } from "./log.ts";
+import { appendOutcomeToAppliedRecords, autoRecordExpertise, logCommand } from "./log.ts";
 
 /**
  * Tests for `overstory log` command.
@@ -50,7 +51,7 @@ describe("logCommand", () => {
 	afterEach(async () => {
 		process.stdout.write = originalWrite;
 		process.chdir(originalCwd);
-		await rm(tempDir, { recursive: true, force: true });
+		await cleanupTempDir(tempDir);
 	});
 
 	function output(): string {
@@ -58,18 +59,28 @@ describe("logCommand", () => {
 	}
 
 	/**
-	 * Fake MulchClient for testing autoRecordExpertise.
-	 * Only learn() and record() are implemented — other methods are stubs.
+	 * Fake MulchClient for testing autoRecordExpertise and appendOutcomeToAppliedRecords.
+	 * Only learn(), record(), and appendOutcome() are implemented — other methods are stubs.
 	 * Justified: we are testing orchestration logic, not the mulch CLI itself.
 	 */
 	function createFakeMulchClient(
 		learnResult: MulchLearnResult,
-		opts?: { recordShouldFail?: boolean },
+		opts?: { recordShouldFail?: boolean; appendOutcomeShouldFail?: boolean },
 	): {
 		client: MulchClient;
 		recordCalls: Array<{ domain: string; options: Record<string, unknown> }>;
+		appendOutcomeCalls: Array<{
+			domain: string;
+			id: string;
+			outcome: Record<string, unknown>;
+		}>;
 	} {
 		const recordCalls: Array<{ domain: string; options: Record<string, unknown> }> = [];
+		const appendOutcomeCalls: Array<{
+			domain: string;
+			id: string;
+			outcome: Record<string, unknown>;
+		}> = [];
 		const client = {
 			async learn() {
 				return learnResult;
@@ -80,8 +91,14 @@ describe("logCommand", () => {
 				}
 				recordCalls.push({ domain, options });
 			},
+			async appendOutcome(domain: string, id: string, outcome: Record<string, unknown>) {
+				if (opts?.appendOutcomeShouldFail) {
+					throw new Error("mulch appendOutcome failed");
+				}
+				appendOutcomeCalls.push({ domain, id, outcome });
+			},
 		} as unknown as MulchClient;
-		return { client, recordCalls };
+		return { client, recordCalls, appendOutcomeCalls };
 	}
 
 	test("--help flag shows help text", async () => {
@@ -229,6 +246,7 @@ describe("logCommand", () => {
 			lastActivity: new Date().toISOString(),
 			escalationLevel: 0,
 			stalledSince: null,
+			transcriptPath: null,
 		};
 		const store = createSessionStore(dbPath);
 		store.upsert(session);
@@ -284,6 +302,7 @@ describe("logCommand", () => {
 			lastActivity: new Date().toISOString(),
 			escalationLevel: 0,
 			stalledSince: null,
+			transcriptPath: null,
 		};
 		const sessStore = createSessionStore(sessionsDbPath);
 		sessStore.upsert(session);
@@ -324,6 +343,7 @@ describe("logCommand", () => {
 			lastActivity: new Date(Date.now() - 60_000).toISOString(),
 			escalationLevel: 0,
 			stalledSince: null,
+			transcriptPath: null,
 		};
 		const store = createSessionStore(dbPath);
 		store.upsert(session);
@@ -363,6 +383,7 @@ describe("logCommand", () => {
 			lastActivity: new Date(Date.now() - 60_000).toISOString(),
 			escalationLevel: 0,
 			stalledSince: null,
+			transcriptPath: null,
 		};
 		const store = createSessionStore(dbPath);
 		store.upsert(session);
@@ -400,6 +421,7 @@ describe("logCommand", () => {
 				lastActivity: new Date().toISOString(),
 				escalationLevel: 0,
 				stalledSince: null,
+				transcriptPath: null,
 			});
 			sessionStoreLocal.close();
 
@@ -457,6 +479,7 @@ describe("logCommand", () => {
 				lastActivity: new Date().toISOString(),
 				escalationLevel: 0,
 				stalledSince: null,
+				transcriptPath: null,
 			});
 			sessionStoreLocal.close();
 
@@ -487,6 +510,7 @@ describe("logCommand", () => {
 				lastActivity: new Date().toISOString(),
 				escalationLevel: 0,
 				stalledSince: null,
+				transcriptPath: null,
 			});
 			sessionStoreLocal.close();
 
@@ -541,6 +565,7 @@ describe("logCommand", () => {
 				lastActivity: new Date().toISOString(),
 				escalationLevel: 0,
 				stalledSince: null,
+				transcriptPath: null,
 			});
 			sessionStoreLocal.close();
 
@@ -594,6 +619,7 @@ describe("logCommand", () => {
 			lastActivity: new Date().toISOString(),
 			escalationLevel: 0,
 			stalledSince: null,
+			transcriptPath: null,
 		};
 		const store = createSessionStore(dbPath);
 		store.upsert(session);
@@ -634,6 +660,7 @@ describe("logCommand", () => {
 			lastActivity: new Date().toISOString(),
 			escalationLevel: 0,
 			stalledSince: null,
+			transcriptPath: null,
 		};
 		const store = createSessionStore(dbPath);
 		store.upsert(session);
@@ -676,6 +703,7 @@ describe("logCommand", () => {
 			lastActivity: oldTimestamp,
 			escalationLevel: 0,
 			stalledSince: null,
+			transcriptPath: null,
 		};
 		const store = createSessionStore(dbPath);
 		store.upsert(session);
@@ -715,6 +743,7 @@ describe("logCommand", () => {
 			lastActivity: new Date().toISOString(),
 			escalationLevel: 0,
 			stalledSince: null,
+			transcriptPath: null,
 		};
 		const store = createSessionStore(dbPath);
 		store.upsert(session);
@@ -773,6 +802,54 @@ describe("logCommand", () => {
 		expect(eventsContent).toContain("unknown");
 	});
 
+	test("tool-start writes to EventStore without --stdin flag (Pi runtime path)", async () => {
+		await logCommand(["tool-start", "--agent", "pi-agent", "--tool-name", "Read"]);
+
+		const eventsDbPath = join(tempDir, ".overstory", "events.db");
+		const eventStore = createEventStore(eventsDbPath);
+		const events = eventStore.getByAgent("pi-agent");
+		eventStore.close();
+
+		expect(events).toHaveLength(1);
+		expect(events[0]?.eventType).toBe("tool_start");
+		expect(events[0]?.toolName).toBe("Read");
+		expect(events[0]?.sessionId).toBeNull();
+		expect(events[0]?.agentName).toBe("pi-agent");
+	});
+
+	test("tool-end writes to EventStore without --stdin flag (Pi runtime path)", async () => {
+		await logCommand(["tool-start", "--agent", "pi-end-agent", "--tool-name", "Write"]);
+		await logCommand(["tool-end", "--agent", "pi-end-agent", "--tool-name", "Write"]);
+
+		const eventsDbPath = join(tempDir, ".overstory", "events.db");
+		const eventStore = createEventStore(eventsDbPath);
+		const events = eventStore.getByAgent("pi-end-agent");
+		eventStore.close();
+
+		expect(events).toHaveLength(2);
+		const startEv = events.find((e) => e.eventType === "tool_start");
+		const endEv = events.find((e) => e.eventType === "tool_end");
+		expect(startEv).toBeDefined();
+		expect(endEv).toBeDefined();
+		expect(startEv?.toolName).toBe("Write");
+		expect(endEv?.toolName).toBe("Write");
+		expect(startEv?.sessionId).toBeNull();
+	});
+
+	test("session-end writes to EventStore without --stdin flag (Pi runtime path)", async () => {
+		await logCommand(["session-end", "--agent", "pi-session-agent"]);
+
+		const eventsDbPath = join(tempDir, ".overstory", "events.db");
+		const eventStore = createEventStore(eventsDbPath);
+		const events = eventStore.getByAgent("pi-session-agent");
+		eventStore.close();
+
+		expect(events).toHaveLength(1);
+		expect(events[0]?.eventType).toBe("session_end");
+		expect(events[0]?.sessionId).toBeNull();
+		expect(events[0]?.agentName).toBe("pi-session-agent");
+	});
+
 	test("--help includes --stdin option in output", async () => {
 		await logCommand(["--help"]);
 		const out = output();
@@ -800,6 +877,7 @@ describe("logCommand", () => {
 			lastActivity: new Date().toISOString(),
 			escalationLevel: 0,
 			stalledSince: null,
+			transcriptPath: null,
 		};
 		const store = createSessionStore(dbPath);
 		store.upsert(session);
@@ -839,6 +917,7 @@ describe("logCommand", () => {
 			lastActivity: new Date().toISOString(),
 			escalationLevel: 0,
 			stalledSince: null,
+			transcriptPath: null,
 		};
 		const store = createSessionStore(dbPath);
 		store.upsert(session);
@@ -1168,7 +1247,7 @@ describe("logCommand --stdin integration", () => {
 	});
 
 	afterEach(async () => {
-		await rm(tempDir, { recursive: true, force: true });
+		await cleanupTempDir(tempDir);
 	});
 
 	/**
@@ -1373,6 +1452,7 @@ try {
 		const scriptPath = join(tempDir, "_run-log-empty.ts");
 		const scriptContent = `
 import { logCommand } from "${join(import.meta.dir, "log.ts").replace(/\\/g, "/")}";
+
 try {
 	await logCommand(["tool-start", "--agent", "empty-stdin-agent", "--stdin"]);
 } catch (e) {
@@ -1447,3 +1527,177 @@ try {
 		// tool_result is not stored in EventStore (filtered out), but tool_name was parsed correctly
 	});
 });
+
+describe("appendOutcomeToAppliedRecords", () => {
+	let tempDir: string;
+
+	/** Minimal fake MulchClient for appendOutcomeToAppliedRecords tests. */
+	function makeOutcomeClient(opts?: { appendOutcomeShouldFail?: boolean }): {
+		client: MulchClient;
+		appendOutcomeCalls: Array<{ domain: string; id: string; outcome: Record<string, unknown> }>;
+	} {
+		const appendOutcomeCalls: Array<{
+			domain: string;
+			id: string;
+			outcome: Record<string, unknown>;
+		}> = [];
+		const client = {
+			async appendOutcome(domain: string, id: string, outcome: Record<string, unknown>) {
+				if (opts?.appendOutcomeShouldFail) throw new Error("mulch appendOutcome failed");
+				appendOutcomeCalls.push({ domain, id, outcome });
+			},
+		} as unknown as MulchClient;
+		return { client, appendOutcomeCalls };
+	}
+
+	beforeEach(async () => {
+		tempDir = await mkdtemp(join(tmpdir(), "outcome-test-"));
+	});
+
+	afterEach(async () => {
+		await cleanupTempDir(tempDir);
+	});
+
+	test("returns 0 when applied-records.json does not exist (backward compat)", async () => {
+		const { client } = makeOutcomeClient();
+		const count = await appendOutcomeToAppliedRecords({
+			mulchClient: client,
+			agentName: "test-agent",
+			capability: "builder",
+			taskId: "bead-001",
+			projectRoot: tempDir,
+		});
+		expect(count).toBe(0);
+	});
+
+	test("returns 0 when records array is empty", async () => {
+		const agentDir = join(tempDir, ".overstory", "agents", "test-agent");
+		await mkdir(agentDir, { recursive: true });
+		await Bun.write(
+			join(agentDir, "applied-records.json"),
+			JSON.stringify({
+				taskId: "bead-001",
+				agentName: "test-agent",
+				capability: "builder",
+				records: [],
+			}),
+		);
+
+		const { client } = makeOutcomeClient();
+		const count = await appendOutcomeToAppliedRecords({
+			mulchClient: client,
+			agentName: "test-agent",
+			capability: "builder",
+			taskId: "bead-001",
+			projectRoot: tempDir,
+		});
+		expect(count).toBe(0);
+	});
+
+	test("calls appendOutcome for each record and returns count", async () => {
+		const agentDir = join(tempDir, ".overstory", "agents", "test-agent");
+		await mkdir(agentDir, { recursive: true });
+		const records = [
+			{ id: "mx-aaa111", domain: "agents" },
+			{ id: "mx-bbb222", domain: "typescript" },
+		];
+		await Bun.write(
+			join(agentDir, "applied-records.json"),
+			JSON.stringify({
+				taskId: "bead-001",
+				agentName: "test-agent",
+				capability: "builder",
+				records,
+			}),
+		);
+
+		const { client, appendOutcomeCalls } = makeOutcomeClient();
+		const count = await appendOutcomeToAppliedRecords({
+			mulchClient: client,
+			agentName: "test-agent",
+			capability: "builder",
+			taskId: "bead-001",
+			projectRoot: tempDir,
+		});
+
+		expect(count).toBe(2);
+		expect(appendOutcomeCalls).toHaveLength(2);
+		expect(appendOutcomeCalls[0]).toMatchObject({ id: "mx-aaa111", domain: "agents" });
+		expect(appendOutcomeCalls[1]).toMatchObject({ id: "mx-bbb222", domain: "typescript" });
+		expect(appendOutcomeCalls[0]?.outcome).toMatchObject({
+			status: "success",
+			agent: "test-agent",
+		});
+	});
+
+	test("cleans up applied-records.json after processing", async () => {
+		const agentDir = join(tempDir, ".overstory", "agents", "test-agent");
+		await mkdir(agentDir, { recursive: true });
+		const appliedPath = join(agentDir, "applied-records.json");
+		await Bun.write(
+			appliedPath,
+			JSON.stringify({
+				taskId: "bead-001",
+				agentName: "test-agent",
+				capability: "builder",
+				records: [{ id: "mx-abc123", domain: "agents" }],
+			}),
+		);
+
+		const { client } = makeOutcomeClient();
+		await appendOutcomeToAppliedRecords({
+			mulchClient: client,
+			agentName: "test-agent",
+			capability: "builder",
+			taskId: "bead-001",
+			projectRoot: tempDir,
+		});
+
+		expect(await Bun.file(appliedPath).exists()).toBe(false);
+	});
+
+	test("continues when individual appendOutcome calls fail (non-fatal per record)", async () => {
+		const agentDir = join(tempDir, ".overstory", "agents", "test-agent");
+		await mkdir(agentDir, { recursive: true });
+		const records = [
+			{ id: "mx-fail111", domain: "agents" },
+			{ id: "mx-fail222", domain: "typescript" },
+		];
+		await Bun.write(
+			join(agentDir, "applied-records.json"),
+			JSON.stringify({
+				taskId: "bead-002",
+				agentName: "test-agent",
+				capability: "builder",
+				records,
+			}),
+		);
+
+		// appendOutcomeShouldFail=true makes all calls throw — should return 0 but not throw
+		const { client } = makeOutcomeClient({ appendOutcomeShouldFail: true });
+		const count = await appendOutcomeToAppliedRecords({
+			mulchClient: client,
+			agentName: "test-agent",
+			capability: "builder",
+			taskId: "bead-002",
+			projectRoot: tempDir,
+		});
+		expect(count).toBe(0);
+	});
+
+	test("returns 0 for malformed JSON", async () => {
+		const agentDir = join(tempDir, ".overstory", "agents", "test-agent");
+		await mkdir(agentDir, { recursive: true });
+		await Bun.write(join(agentDir, "applied-records.json"), "not-valid-json{{{");
+
+		const { client } = makeOutcomeClient();
+		const count = await appendOutcomeToAppliedRecords({
+			mulchClient: client,
+			agentName: "test-agent",
+			capability: "builder",
+			taskId: null,
+			projectRoot: tempDir,
+		});
+		expect(count).toBe(0);
+	});
+});