@os-eco/overstory-cli 0.7.2 → 0.7.3

package/src/merge/resolver.test.ts

@@ -203,6 +203,9 @@ function createMockMulchClient(
 				action: "analyze",
 			};
 		},
+		async appendOutcome() {
+			// No-op stub: resolver tests don't exercise outcome appending
+		},
 	};
 }
 
@@ -1440,6 +1443,42 @@ describe("createMergeResolver", () => {
 		});
 	});
 
+	describe("queryConflictHistory uses sortByScore", () => {
+		test("passes sortByScore: true to mulch search when querying conflict history", async () => {
+			const repoDir = await createTempGitRepo();
+			try {
+				const defaultBranch = await getDefaultBranch(repoDir);
+				await setupContentConflict(repoDir, defaultBranch);
+
+				const entry = makeTestEntry({
+					branchName: "feature-branch",
+					filesModified: ["src/test.ts"],
+				});
+
+				// Capture search call options
+				let capturedSearchOptions: unknown;
+				const mockMulchClient = createMockMulchClient();
+				mockMulchClient.search = async (_query, options) => {
+					capturedSearchOptions = options;
+					return "";
+				};
+
+				const resolver = createMergeResolver({
+					aiResolveEnabled: false,
+					reimagineEnabled: false,
+					mulchClient: mockMulchClient,
+				});
+
+				await resolver.resolve(entry, defaultBranch, repoDir);
+
+				// Verify sortByScore was passed to search
+				expect(capturedSearchOptions).toMatchObject({ sortByScore: true });
+			} finally {
+				await cleanupTempDir(repoDir);
+			}
+		});
+	});
+
 	describe("AI-resolve with history context", () => {
 		test("includes historical context in AI prompt when available", async () => {
 			const repoDir = await createTempGitRepo();

package/src/merge/resolver.ts

@@ -514,7 +514,7 @@ async function queryConflictHistory(
 	entry: MergeEntry,
 ): Promise<ConflictHistory> {
 	try {
-		const searchOutput = await mulchClient.search("merge-conflict");
+		const searchOutput = await mulchClient.search("merge-conflict", { sortByScore: true });
 		const patterns = parseConflictPatterns(searchOutput);
 		return buildConflictHistory(patterns, entry.filesModified);
 	} catch {

package/src/mulch/client.test.ts

@@ -6,10 +6,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 { AgentError } from "../errors.ts";
+import { cleanupTempDir } from "../test-helpers.ts";
 import { createMulchClient } from "./client.ts";
 
 // Check if mulch is available
@@ -30,7 +31,7 @@ describe("createMulchClient", () => {
 	});
 
 	afterEach(async () => {
-		await rm(tempDir, { recursive: true, force: true });
+		await cleanupTempDir(tempDir);
 	});
 
 	/**
@@ -162,6 +163,33 @@ describe("createMulchClient", () => {
 			});
 			expect(typeof result).toBe("string");
 		});
+
+		test.skipIf(!hasMulch)("passes --sort-by-score flag in prime options", async () => {
+			await initMulch();
+			const client = createMulchClient(tempDir);
+			// mulch prime --sort-by-score may not be supported in older mulch versions;
+			// the interface and impl are forward-looking — test accepts both outcomes.
+			try {
+				const result = await client.prime([], "markdown", { sortByScore: true });
+				expect(typeof result).toBe("string");
+			} catch (error) {
+				expect(error).toBeInstanceOf(AgentError);
+			}
+		});
+
+		test.skipIf(!hasMulch)("passes --sort-by-score with --files together", async () => {
+			await initMulch();
+			const client = createMulchClient(tempDir);
+			try {
+				const result = await client.prime([], "markdown", {
+					files: ["src/config.ts"],
+					sortByScore: true,
+				});
+				expect(typeof result).toBe("string");
+			} catch (error) {
+				expect(error).toBeInstanceOf(AgentError);
+			}
+		});
 	});
 
 	describe("status", () => {
@@ -452,6 +480,39 @@ describe("createMulchClient", () => {
 			expect(typeof result).toBe("string");
 		});
 
+		test.skipIf(!hasMulch)("passes --classification flag when provided", async () => {
+			await initMulch();
+			const client = createMulchClient(tempDir);
+			const result = await client.search("test", { classification: "foundational" });
+			expect(typeof result).toBe("string");
+		});
+
+		test.skipIf(!hasMulch)("passes --outcome-status flag when provided (success)", async () => {
+			await initMulch();
+			const client = createMulchClient(tempDir);
+			const result = await client.search("test", { outcomeStatus: "success" });
+			expect(typeof result).toBe("string");
+		});
+
+		test.skipIf(!hasMulch)("passes --outcome-status flag when provided (failure)", async () => {
+			await initMulch();
+			const client = createMulchClient(tempDir);
+			const result = await client.search("test", { outcomeStatus: "failure" });
+			expect(typeof result).toBe("string");
+		});
+
+		test.skipIf(!hasMulch)("passes all search filters together", async () => {
+			await initMulch();
+			const client = createMulchClient(tempDir);
+			const result = await client.search("test", {
+				classification: "tactical",
+				outcomeStatus: "success",
+				sortByScore: true,
+				file: "src/config.ts",
+			});
+			expect(typeof result).toBe("string");
+		});
+
 		test.skipIf(!hasMulch)("roundtrip: record via API then search and find it", async () => {
 			await initMulch();
 			const addProc = Bun.spawn(["ml", "add", "roundtrip"], {

package/src/mulch/client.ts

@@ -28,9 +28,22 @@ export interface MulchClient {
 		options?: {
 			files?: string[];
 			excludeDomain?: string[];
+			sortByScore?: boolean;
 		},
 	): Promise<string>;
 
+	/** Append an outcome entry to an existing record by ID in the given domain. */
+	appendOutcome(
+		domain: string,
+		id: string,
+		outcome: {
+			status: "success" | "failure" | "partial";
+			agent?: string;
+			notes?: string;
+			duration?: number;
+		},
+	): Promise<void>;
+
 	/** Show domain statistics. */
 	status(): Promise<MulchStatus>;
 
@@ -58,7 +71,15 @@ export interface MulchClient {
 	query(domain?: string): Promise<string>;
 
 	/** Search records across all domains. */
-	search(query: string, options?: { file?: string; sortByScore?: boolean }): Promise<string>;
+	search(
+		query: string,
+		options?: {
+			file?: string;
+			sortByScore?: boolean;
+			classification?: string;
+			outcomeStatus?: "success" | "failure";
+		},
+	): Promise<string>;
 
 	/** Show expertise record changes since a git ref. */
 	diff(options?: { since?: string }): Promise<MulchDiffResult>;
@@ -214,6 +235,8 @@ interface MulchProgrammaticApi {
 			type?: string;
 			tag?: string;
 			classification?: string;
+			outcomeStatus?: "success" | "failure";
+			sortByScore?: boolean;
 			file?: string;
 			cwd?: string;
 		},
@@ -222,6 +245,22 @@ interface MulchProgrammaticApi {
 		domain: string,
 		options?: { type?: string; classification?: string; file?: string; cwd?: string },
 	): Promise<MulchExpertiseRecord[]>;
+	appendOutcome(
+		domain: string,
+		id: string,
+		outcome: {
+			status: "success" | "failure" | "partial";
+			agent?: string;
+			notes?: string;
+			duration?: number;
+			recorded_at?: string;
+		},
+		options?: { cwd?: string },
+	): Promise<{
+		record: MulchExpertiseRecord;
+		outcome: { status: string; agent?: string; notes?: string; recorded_at?: string };
+		total_outcomes: number;
+	}>;
 }
 
 const MULCH_PKG = "@os-eco/mulch-cli";
@@ -406,6 +445,9 @@ export function createMulchClient(cwd: string): MulchClient {
 			if (options?.excludeDomain && options.excludeDomain.length > 0) {
 				args.push("--exclude-domain", ...options.excludeDomain);
 			}
+			if (options?.sortByScore) {
+				args.push("--sort-by-score");
+			}
 			const { stdout } = await runMulch(args, "prime");
 			return stdout;
 		},
@@ -472,6 +514,9 @@ export function createMulchClient(cwd: string): MulchClient {
 				const api = await loadMulchApi();
 				const results = await api.searchExpertise(query, {
 					file: options?.file,
+					classification: options?.classification,
+					outcomeStatus: options?.outcomeStatus,
+					sortByScore: options?.sortByScore,
 					cwd,
 				});
 				return formatSearchResults(results);
@@ -595,5 +640,21 @@ export function createMulchClient(cwd: string): MulchClient {
 				throw new AgentError(`Failed to parse JSON from mulch compact: ${trimmed.slice(0, 200)}`);
 			}
 		},
+
+		async appendOutcome(domain, id, outcome) {
+			const api = await loadMulchApi();
+			try {
+				await api.appendOutcome(
+					domain,
+					id,
+					{ ...outcome, recorded_at: new Date().toISOString() },
+					{ cwd },
+				);
+			} catch (error) {
+				throw new AgentError(
+					`mulch appendOutcome ${domain}/${id} failed: ${error instanceof Error ? error.message : String(error)}`,
+				);
+			}
+		},
 	};
 }

package/src/runtimes/claude.test.ts

@@ -1,7 +1,8 @@
 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 { cleanupTempDir } from "../test-helpers.ts";
 import type { ResolvedModel } from "../types.ts";
 import { ClaudeRuntime } from "./claude.ts";
 import type { SpawnOpts } from "./types.ts";
@@ -239,7 +240,7 @@ describe("ClaudeRuntime", () => {
 		});
 
 		afterEach(async () => {
-			await rm(tempDir, { recursive: true, force: true });
+			await cleanupTempDir(tempDir);
 		});
 
 		test("writes overlay to .claude/CLAUDE.md when overlay is provided", async () => {
@@ -373,7 +374,7 @@ describe("ClaudeRuntime", () => {
 		});
 
 		afterEach(async () => {
-			await rm(tempDir, { recursive: true, force: true });
+			await cleanupTempDir(tempDir);
 		});
 
 		test("returns null for non-existent file", async () => {

package/src/runtimes/pi-guards.test.ts

@@ -349,7 +349,9 @@ describe("generatePiGuardExtension", () => {
 
 		test("generated code contains pi.exec ov log tool-start in tool_call handler", () => {
 			const generated = generatePiGuardExtension(builderHooks());
-			expect(generated).toContain('pi.exec("ov", ["log", "tool-start", "--agent", AGENT_NAME])');
+			expect(generated).toContain(
+				'pi.exec("ov", ["log", "tool-start", "--agent", AGENT_NAME, "--tool-name", event.toolName])',
+			);
 		});
 
 		test('generated code contains pi.on("tool_execution_end", ...)', () => {
@@ -359,7 +361,9 @@ describe("generatePiGuardExtension", () => {
 
 		test("generated code contains pi.exec ov log tool-end in tool_execution_end handler", () => {
 			const generated = generatePiGuardExtension(builderHooks());
-			expect(generated).toContain('pi.exec("ov", ["log", "tool-end", "--agent", AGENT_NAME])');
+			expect(generated).toContain(
+				'pi.exec("ov", ["log", "tool-end", "--agent", AGENT_NAME, "--tool-name", event.toolName])',
+			);
 		});
 
 		test('generated code contains pi.on("session_shutdown", ...)', () => {
@@ -373,6 +377,26 @@ describe("generatePiGuardExtension", () => {
 				'await pi.exec("ov", ["log", "session-end", "--agent", AGENT_NAME])',
 			);
 		});
+
+		test("tool_call handler passes --tool-name event.toolName to tool-start", () => {
+			const generated = generatePiGuardExtension(builderHooks());
+			expect(generated).toContain(
+				'pi.exec("ov", ["log", "tool-start", "--agent", AGENT_NAME, "--tool-name", event.toolName])',
+			);
+		});
+
+		test("tool_execution_end handler passes --tool-name event.toolName to tool-end", () => {
+			const generated = generatePiGuardExtension(builderHooks());
+			expect(generated).toContain(
+				'pi.exec("ov", ["log", "tool-end", "--agent", AGENT_NAME, "--tool-name", event.toolName])',
+			);
+		});
+
+		test("tool_execution_end handler uses named event parameter (not _event)", () => {
+			const generated = generatePiGuardExtension(builderHooks());
+			expect(generated).toContain('pi.on("tool_execution_end", async (event) => {');
+			expect(generated).not.toContain('pi.on("tool_execution_end", async (_event) => {');
+		});
 	});
 
 	describe("PiRuntime integration", () => {

package/src/runtimes/pi-guards.ts

@@ -241,7 +241,7 @@ export function generatePiGuardExtension(hooks: HooksDef): string {
 		`\tpi.on("tool_call", async (event) => {`,
 		`\t\t// Activity tracking: update lastActivity so watchdog knows agent is alive.`,
 		`\t\t// Fire-and-forget — do not await (avoids latency on every tool call).`,
-		`\t\tpi.exec("ov", ["log", "tool-start", "--agent", AGENT_NAME]).catch(() => {});`,
+		`\t\tpi.exec("ov", ["log", "tool-start", "--agent", AGENT_NAME, "--tool-name", event.toolName]).catch(() => {});`,
 		``,
 		`\t\t// 1. Block native team/task tools (all agents).`,
 		`\t\tif (TEAM_BLOCKED.has(event.toolName)) {`,
@@ -326,8 +326,8 @@ export function generatePiGuardExtension(hooks: HooksDef): string {
 		`\t * Tool execution end: fire-and-forget "ov log tool-end" for event tracking.`,
 		`\t * Paired with tool_call's tool-start fire for proper begin/end event logging.`,
 		`\t */`,
-		`\tpi.on("tool_execution_end", async (_event) => {`,
-		`\t\tpi.exec("ov", ["log", "tool-end", "--agent", AGENT_NAME]).catch(() => {});`,
+		`\tpi.on("tool_execution_end", async (event) => {`,
+		`\t\tpi.exec("ov", ["log", "tool-end", "--agent", AGENT_NAME, "--tool-name", event.toolName]).catch(() => {});`,
 		`\t});`,
 		``,
 		`\t/**`,

package/src/schema-consistency.test.ts

@@ -12,7 +12,7 @@
 
 import { Database } from "bun:sqlite";
 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 { createEventStore } from "./events/store.ts";
@@ -21,6 +21,8 @@ import { createMergeQueue } from "./merge/queue.ts";
 import { createMetricsStore } from "./metrics/store.ts";
 import { createSessionStore } from "./sessions/store.ts";
 
+import { cleanupTempDir } from "./test-helpers.ts";
+
 /** Extract sorted column names from a table via PRAGMA table_info(). */
 function getTableColumns(db: Database, tableName: string): string[] {
 	const rows = db.prepare(`PRAGMA table_info(${tableName})`).all() as Array<{ name: string }>;
@@ -35,7 +37,7 @@ describe("SQL schema consistency", () => {
 	});
 
 	afterEach(async () => {
-		await rm(tmpDir, { recursive: true, force: true });
+		await cleanupTempDir(tmpDir);
 	});
 
 	describe("SessionStore", () => {

package/src/sessions/compat.test.ts

@@ -6,9 +6,10 @@
  */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { mkdtemp, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { cleanupTempDir } from "../test-helpers.ts";
 import { openSessionStore } from "./compat.ts";
 
 let tempDir: string;
@@ -22,7 +23,7 @@ beforeEach(async () => {
 });
 
 afterEach(async () => {
-	await rm(tempDir, { recursive: true, force: true });
+	await cleanupTempDir(tempDir);
 });
 
 /** Create a sessions.json with the given entries. */

package/src/sessions/store.test.ts

@@ -6,9 +6,10 @@
  */
 
 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 { cleanupTempDir } from "../test-helpers.ts";
 import type { AgentSession, AgentState, InsertRun, Run, RunStore } from "../types.ts";
 import { createRunStore, createSessionStore, type SessionStore } from "./store.ts";
 
@@ -24,7 +25,7 @@ beforeEach(async () => {
 
 afterEach(async () => {
 	store.close();
-	await rm(tempDir, { recursive: true, force: true });
+	await cleanupTempDir(tempDir);
 });
 
 /** Helper to create an AgentSession with optional overrides. */

package/src/test-helpers.ts

@@ -95,9 +95,28 @@ export async function getDefaultBranch(repoDir: string): Promise<string> {
 
 /**
  * Remove a temp directory. Safe to call even if the directory doesn't exist.
+ *
+ * On Windows, SQLite WAL/SHM file handles may linger briefly after db.close(),
+ * causing EBUSY errors on immediate rm(). Retries with exponential backoff
+ * (up to ~1.5s total) to handle this OS-level timing issue.
  */
 export async function cleanupTempDir(dir: string): Promise<void> {
-	await rm(dir, { recursive: true, force: true });
+	const maxRetries = process.platform === "win32" ? 5 : 0;
+	for (let attempt = 0; attempt <= maxRetries; attempt++) {
+		try {
+			await rm(dir, { recursive: true, force: true });
+			return;
+		} catch (err: unknown) {
+			const code = (err as NodeJS.ErrnoException).code;
+			if (code === "EBUSY" && attempt < maxRetries) {
+				// Exponential backoff: 50, 100, 200, 400, 800ms
+				await Bun.sleep(50 * 2 ** attempt);
+				continue;
+			}
+			// Non-EBUSY or final attempt: swallow (temp dirs are cleaned by OS anyway)
+			if (code !== "ENOENT") return;
+		}
+	}
 }
 
 /**

package/src/watchdog/daemon.test.ts

@@ -15,11 +15,12 @@
  */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import { mkdir, mkdtemp } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { createEventStore } from "../events/store.ts";
 import { createSessionStore } from "../sessions/store.ts";
+import { cleanupTempDir } from "../test-helpers.ts";
 import type { AgentSession, HealthCheck, StoredEvent } from "../types.ts";
 import { buildCompletionMessage, runDaemonTick } from "./daemon.ts";
 
@@ -163,7 +164,7 @@ beforeEach(async () => {
 });
 
 afterEach(async () => {
-	await rm(tempRoot, { recursive: true, force: true });
+	await cleanupTempDir(tempRoot);
 });
 
 describe("daemon tick", () => {
@@ -1100,7 +1101,7 @@ describe("daemon mulch failure recording", () => {
 	});
 
 	afterEach(async () => {
-		await rm(tempRoot, { recursive: true, force: true });
+		await cleanupTempDir(tempRoot);
 	});
 
 	/** Track calls to the recordFailure mock. */

package/src/watchdog/triage.test.ts

@@ -7,9 +7,10 @@
  */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import { mkdir, mkdtemp } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { cleanupTempDir } from "../test-helpers.ts";
 import { buildTriagePrompt, classifyResponse, triageAgent } from "./triage.ts";
 
 describe("classifyResponse", () => {
@@ -97,7 +98,7 @@ describe("triageAgent", () => {
 	});
 
 	afterEach(async () => {
-		await rm(tempRoot, { recursive: true, force: true });
+		await cleanupTempDir(tempRoot);
 	});
 
 	test("returns 'extend' when no logs directory exists", async () => {