@os-eco/overstory-cli 0.7.0 → 0.7.3

package/src/logging/logger.test.ts

@@ -1,7 +1,8 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-import { access, mkdtemp, readdir, readFile, rm } from "node:fs/promises";
+import { access, mkdtemp, readdir, readFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { cleanupTempDir } from "../test-helpers.ts";
 import type { LogEvent } from "../types.ts";
 import { createLogger } from "./logger.ts";
 
@@ -15,7 +16,7 @@ describe("createLogger", () => {
 	});
 
 	afterEach(async () => {
-		await rm(tempDir, { recursive: true, force: true });
+		await cleanupTempDir(tempDir);
 	});
 
 	async function readLogFile(filename: string): Promise<string> {

package/src/mail/broadcast.test.ts

@@ -41,6 +41,7 @@ describe("resolveGroupAddress", () => {
 			lastActivity: "2024-01-01T00:01:00Z",
 			escalationLevel: 0,
 			stalledSince: null,
+			transcriptPath: null,
 		};
 	}
 

package/src/mail/client.test.ts

@@ -1,8 +1,9 @@
 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 { MailError } from "../errors.ts";
+import { cleanupTempDir } from "../test-helpers.ts";
 import type { WorkerDonePayload } from "../types.ts";
 import { createMailClient, type MailClient, parsePayload } from "./client.ts";
 import { createMailStore, type MailStore } from "./store.ts";
@@ -20,7 +21,7 @@ describe("createMailClient", () => {
 
 	afterEach(async () => {
 		client.close();
-		await rm(tempDir, { recursive: true, force: true });
+		await cleanupTempDir(tempDir);
 	});
 
 	describe("send", () => {

package/src/mail/store.test.ts

@@ -1,8 +1,9 @@
 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 { MailError } from "../errors.ts";
+import { cleanupTempDir } from "../test-helpers.ts";
 import type { MailMessage } from "../types.ts";
 import { createMailStore, type MailStore } from "./store.ts";
 
@@ -17,7 +18,7 @@ describe("createMailStore", () => {
 
 	afterEach(async () => {
 		store.close();
-		await rm(tempDir, { recursive: true, force: true });
+		await cleanupTempDir(tempDir);
 	});
 
 	describe("insert", () => {

package/src/merge/queue.test.ts

@@ -1,9 +1,10 @@
 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 { MergeError } from "../errors.ts";
+import { cleanupTempDir } from "../test-helpers.ts";
 import { createMergeQueue } from "./queue.ts";
 
 describe("createMergeQueue", () => {
@@ -17,7 +18,7 @@ describe("createMergeQueue", () => {
 	});
 
 	afterEach(async () => {
-		await rm(tempDir, { recursive: true, force: true });
+		await cleanupTempDir(tempDir);
 	});
 
 	function makeInput(

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

@@ -13,10 +13,12 @@
 
 import { MergeError } from "../errors.ts";
 import type { MulchClient } from "../mulch/client.ts";
+import { getRuntime } from "../runtimes/registry.ts";
 import type {
 	ConflictHistory,
 	MergeEntry,
 	MergeResult,
+	OverstoryConfig,
 	ParsedConflictPattern,
 	ResolutionTier,
 } from "../types.ts";
@@ -243,6 +245,7 @@ async function tryAiResolve(
 	conflictFiles: string[],
 	repoRoot: string,
 	pastResolutions?: string[],
+	config?: OverstoryConfig,
 ): Promise<{ success: boolean; remainingConflicts: string[] }> {
 	const remainingConflicts: string[] = [];
 
@@ -265,7 +268,9 @@ async function tryAiResolve(
 				content,
 			].join(" ");
 
-			const proc = Bun.spawn(["claude", "--print", "-p", prompt], {
+			const runtime = getRuntime(config?.runtime?.printCommand ?? config?.runtime?.default, config);
+			const argv = runtime.buildPrintCommand(prompt);
+			const proc = Bun.spawn(argv, {
 				cwd: repoRoot,
 				stdout: "pipe",
 				stderr: "pipe",
@@ -315,6 +320,7 @@ async function tryReimagine(
 	entry: MergeEntry,
 	canonicalBranch: string,
 	repoRoot: string,
+	config?: OverstoryConfig,
 ): Promise<{ success: boolean }> {
 	// Abort the current merge
 	await runGit(repoRoot, ["merge", "--abort"]);
@@ -348,7 +354,9 @@ async function tryReimagine(
 				branchContent,
 			].join("");
 
-			const proc = Bun.spawn(["claude", "--print", "-p", prompt], {
+			const runtime = getRuntime(config?.runtime?.printCommand ?? config?.runtime?.default, config);
+			const argv = runtime.buildPrintCommand(prompt);
+			const proc = Bun.spawn(argv, {
 				cwd: repoRoot,
 				stdout: "pipe",
 				stderr: "pipe",
@@ -506,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 {
@@ -556,6 +564,7 @@ export function createMergeResolver(options: {
 	aiResolveEnabled: boolean;
 	reimagineEnabled: boolean;
 	mulchClient?: MulchClient;
+	config?: OverstoryConfig;
 }): MergeResolver {
 	return {
 		async resolve(
@@ -632,7 +641,12 @@ export function createMergeResolver(options: {
 			// Tier 3: AI-resolve
 			if (options.aiResolveEnabled && !history.skipTiers.includes("ai-resolve")) {
 				lastTier = "ai-resolve";
-				const aiResult = await tryAiResolve(conflictFiles, repoRoot, history.pastResolutions);
+				const aiResult = await tryAiResolve(
+					conflictFiles,
+					repoRoot,
+					history.pastResolutions,
+					options.config,
+				);
 				if (aiResult.success) {
 					if (options.mulchClient) {
 						recordConflictPattern(options.mulchClient, entry, "ai-resolve", conflictFiles, true);
@@ -651,7 +665,12 @@ export function createMergeResolver(options: {
 			// Tier 4: Re-imagine
 			if (options.reimagineEnabled && !history.skipTiers.includes("reimagine")) {
 				lastTier = "reimagine";
-				const reimagineResult = await tryReimagine(entry, canonicalBranch, repoRoot);
+				const reimagineResult = await tryReimagine(
+					entry,
+					canonicalBranch,
+					repoRoot,
+					options.config,
+				);
 				if (reimagineResult.success) {
 					if (options.mulchClient) {
 						recordConflictPattern(options.mulchClient, entry, "reimagine", conflictFiles, true);

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 () => {
@@ -611,6 +612,6 @@ describe("ClaudeRuntime integration: registry resolves 'claude' as default", ()
 	test("getRuntime rejects unknown runtimes", async () => {
 		const { getRuntime } = await import("./registry.ts");
 		expect(() => getRuntime("codex")).toThrow('Unknown runtime: "codex"');
-		expect(() => getRuntime("pi")).toThrow('Unknown runtime: "pi"');
+		expect(() => getRuntime("opencode")).toThrow('Unknown runtime: "opencode"');
 	});
 });