@os-eco/overstory-cli 0.7.2 → 0.7.4

package/src/commands/doctor.test.ts

@@ -10,10 +10,11 @@
  */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtemp, rm } from "node:fs/promises";
+import { mkdtemp } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { ValidationError } from "../errors.ts";
+import { cleanupTempDir } from "../test-helpers.ts";
 import { doctorCommand } from "./doctor.ts";
 
 describe("doctorCommand", () => {
@@ -47,7 +48,7 @@ describe("doctorCommand", () => {
 	afterEach(async () => {
 		process.stdout.write = originalWrite;
 		process.chdir(originalCwd);
-		await rm(tempDir, { recursive: true, force: true });
+		await cleanupTempDir(tempDir);
 	});
 
 	function output(): string {

package/src/commands/errors.test.ts

@@ -9,11 +9,12 @@
  */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtemp, rm } from "node:fs/promises";
+import { mkdtemp } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { ValidationError } from "../errors.ts";
 import { createEventStore } from "../events/store.ts";
+import { cleanupTempDir } from "../test-helpers.ts";
 import type { InsertEvent } from "../types.ts";
 import { errorsCommand } from "./errors.ts";
 
@@ -64,7 +65,7 @@ describe("errorsCommand", () => {
 	afterEach(async () => {
 		process.stdout.write = originalWrite;
 		process.chdir(originalCwd);
-		await rm(tempDir, { recursive: true, force: true });
+		await cleanupTempDir(tempDir);
 	});
 
 	function output(): string {

package/src/commands/feed.test.ts

@@ -9,11 +9,12 @@
  */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtemp, rm } from "node:fs/promises";
+import { mkdtemp } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { ValidationError } from "../errors.ts";
 import { createEventStore } from "../events/store.ts";
+import { cleanupTempDir } from "../test-helpers.ts";
 import type { InsertEvent } from "../types.ts";
 import { feedCommand } from "./feed.ts";
 
@@ -64,7 +65,7 @@ describe("feedCommand", () => {
 	afterEach(async () => {
 		process.stdout.write = originalWrite;
 		process.chdir(originalCwd);
-		await rm(tempDir, { recursive: true, force: true });
+		await cleanupTempDir(tempDir);
 	});
 
 	function output(): string {

package/src/commands/feed.ts

@@ -13,14 +13,7 @@ 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 {
-	buildAgentColorMap,
-	buildEventDetail,
-	extendAgentColorMap,
-	formatAbsoluteTime,
-} from "../logging/format.ts";
-import { eventLabel } from "../logging/theme.ts";
+import { buildAgentColorMap, extendAgentColorMap, formatEventLine } from "../logging/format.ts";
 import type { StoredEvent } from "../types.ts";
 
 /**
@@ -28,27 +21,7 @@ import type { StoredEvent } from "../types.ts";
  * HH:MM:SS LABEL agentname    detail
  */
 function printEvent(event: StoredEvent, colorMap: Map<string, ColorFn>): void {
-	const w = process.stdout.write.bind(process.stdout);
-
-	const timeStr = formatAbsoluteTime(event.createdAt);
-
-	const label = eventLabel(event.eventType);
-
-	const levelColorFn =
-		event.level === "error" ? color.red : event.level === "warn" ? color.yellow : null;
-	const applyLevel = (text: string) => (levelColorFn ? levelColorFn(text) : text);
-
-	const detail = buildEventDetail(event, 60);
-	const detailSuffix = detail ? ` ${color.dim(detail)}` : "";
-
-	const agentColorFn = colorMap.get(event.agentName) ?? color.gray;
-	const agentLabel = ` ${agentColorFn(event.agentName.padEnd(15))}`;
-
-	w(
-		`${color.dim(timeStr)} ` +
-			`${applyLevel(label.color(color.bold(label.compact)))}` +
-			`${agentLabel}${detailSuffix}\n`,
-	);
+	process.stdout.write(`${formatEventLine(event, colorMap)}\n`);
 }
 
 interface FeedOpts {

package/src/commands/inspect.test.ts

@@ -9,13 +9,14 @@
  */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtemp, rm } from "node:fs/promises";
+import { mkdtemp } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { ValidationError } from "../errors.ts";
 import { createEventStore } from "../events/store.ts";
 import { createMetricsStore } from "../metrics/store.ts";
 import { createSessionStore } from "../sessions/store.ts";
+import { cleanupTempDir } from "../test-helpers.ts";
 import type { InsertEvent, SessionMetrics } from "../types.ts";
 import { gatherInspectData, inspectCommand } from "./inspect.ts";
 
@@ -89,7 +90,7 @@ describe("inspectCommand", () => {
 	afterEach(async () => {
 		process.stdout.write = originalWrite;
 		process.chdir(originalCwd);
-		await rm(tempDir, { recursive: true, force: true });
+		await cleanupTempDir(tempDir);
 	});
 
 	function output(): string {

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 () => {
@@ -785,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();
@@ -1182,7 +1247,7 @@ describe("logCommand --stdin integration", () => {
 	});
 
 	afterEach(async () => {
-		await rm(tempDir, { recursive: true, force: true });
+		await cleanupTempDir(tempDir);
 	});
 
 	/**
@@ -1387,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) {
@@ -1461,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);
+	});
+});