@os-eco/overstory-cli 0.7.2 → 0.7.4

package/src/commands/log.ts

@@ -370,6 +370,76 @@ export async function autoRecordExpertise(params: {
 	return recordedDomains;
 }
 
+interface AppliedRecordsData {
+	taskId: string | null;
+	agentName: string;
+	capability: string;
+	records: Array<{ id: string; domain: string }>;
+}
+
+/**
+ * Append outcome entries to the mulch records that were applied when this agent was spawned.
+ *
+ * At spawn time, sling.ts writes .overstory/agents/{name}/applied-records.json listing
+ * the mx-* IDs from the prime output. At session-end, this function reads that file,
+ * appends a "success" outcome to each record, and deletes the file.
+ *
+ * @returns Number of records successfully updated.
+ */
+export async function appendOutcomeToAppliedRecords(params: {
+	mulchClient: MulchClient;
+	agentName: string;
+	capability: string;
+	taskId: string | null;
+	projectRoot: string;
+}): Promise<number> {
+	const appliedRecordsPath = join(
+		params.projectRoot,
+		".overstory",
+		"agents",
+		params.agentName,
+		"applied-records.json",
+	);
+	const appliedFile = Bun.file(appliedRecordsPath);
+	if (!(await appliedFile.exists())) return 0;
+
+	let data: AppliedRecordsData;
+	try {
+		data = JSON.parse(await appliedFile.text()) as AppliedRecordsData;
+	} catch {
+		return 0;
+	}
+
+	const { records } = data;
+	if (!records || records.length === 0) return 0;
+
+	const taskSuffix = params.taskId ? ` for task ${params.taskId}` : "";
+	const outcome = {
+		status: "success" as const,
+		agent: params.agentName,
+		notes: `Applied by ${params.capability} agent ${params.agentName}${taskSuffix}. Session completed.`,
+	};
+
+	let appended = 0;
+	for (const { id, domain } of records) {
+		try {
+			await params.mulchClient.appendOutcome(domain, id, outcome);
+			appended++;
+		} catch {
+			// Non-fatal per record
+		}
+	}
+
+	try {
+		const { unlink } = await import("node:fs/promises");
+		await unlink(appliedRecordsPath);
+	} catch {
+		// Non-fatal: file may already be gone
+	}
+
+	return appended;
+}
+
 /**
  * Core implementation for the log command.
  */
@@ -427,29 +497,28 @@ async function runLog(opts: {
 			logger.toolStart(toolName, toolInput ?? {});
 			updateLastActivity(config.project.root, opts.agent);
 
-			// When --stdin is used, also write to EventStore for structured observability
-			if (opts.stdin) {
-				try {
-					const eventsDbPath = join(config.project.root, ".overstory", "events.db");
-					const eventStore = createEventStore(eventsDbPath);
-					const filtered = toolInput
-						? filterToolArgs(toolName, toolInput)
-						: { args: {}, summary: toolName };
-					eventStore.insert({
-						runId: null,
-						agentName: opts.agent,
-						sessionId,
-						eventType: "tool_start",
-						toolName,
-						toolArgs: JSON.stringify(filtered.args),
-						toolDurationMs: null,
-						level: "info",
-						data: JSON.stringify({ summary: filtered.summary }),
-					});
-					eventStore.close();
-				} catch {
-					// Non-fatal: EventStore write should not break hook execution
-				}
+			// Always write to EventStore for structured observability
+			// (works for both Claude Code --stdin and Pi runtime --tool-name agents)
+			try {
+				const eventsDbPath = join(config.project.root, ".overstory", "events.db");
+				const eventStore = createEventStore(eventsDbPath);
+				const filtered = toolInput
+					? filterToolArgs(toolName, toolInput)
+					: { args: {}, summary: toolName };
+				eventStore.insert({
+					runId: null,
+					agentName: opts.agent,
+					sessionId,
+					eventType: "tool_start",
+					toolName,
+					toolArgs: JSON.stringify(filtered.args),
+					toolDurationMs: null,
+					level: "info",
+					data: JSON.stringify({ summary: filtered.summary }),
+				});
+				eventStore.close();
+			} catch {
+				// Non-fatal: EventStore write should not break hook execution
 			}
 			break;
 		}
@@ -458,79 +527,78 @@ async function runLog(opts: {
 			logger.toolEnd(toolName, 0);
 			updateLastActivity(config.project.root, opts.agent);
 
-			// When --stdin is used, write to EventStore and correlate with tool-start
-			if (opts.stdin) {
-				try {
-					const eventsDbPath = join(config.project.root, ".overstory", "events.db");
-					const eventStore = createEventStore(eventsDbPath);
-					const filtered = toolInput
-						? filterToolArgs(toolName, toolInput)
-						: { args: {}, summary: toolName };
-					eventStore.insert({
-						runId: null,
-						agentName: opts.agent,
-						sessionId,
-						eventType: "tool_end",
-						toolName,
-						toolArgs: JSON.stringify(filtered.args),
-						toolDurationMs: null,
-						level: "info",
-						data: JSON.stringify({ summary: filtered.summary }),
-					});
-					const correlation = eventStore.correlateToolEnd(opts.agent, toolName);
-					if (correlation) {
-						logger.toolEnd(toolName, correlation.durationMs);
-					}
-					eventStore.close();
-				} catch {
-					// Non-fatal: EventStore write should not break hook execution
+			// Always write to EventStore for structured observability
+			// (works for both Claude Code --stdin and Pi runtime --tool-name agents)
+			try {
+				const eventsDbPath = join(config.project.root, ".overstory", "events.db");
+				const eventStore = createEventStore(eventsDbPath);
+				const filtered = toolInput
+					? filterToolArgs(toolName, toolInput)
+					: { args: {}, summary: toolName };
+				eventStore.insert({
+					runId: null,
+					agentName: opts.agent,
+					sessionId,
+					eventType: "tool_end",
+					toolName,
+					toolArgs: JSON.stringify(filtered.args),
+					toolDurationMs: null,
+					level: "info",
+					data: JSON.stringify({ summary: filtered.summary }),
+				});
+				const correlation = eventStore.correlateToolEnd(opts.agent, toolName);
+				if (correlation) {
+					logger.toolEnd(toolName, correlation.durationMs);
 				}
+				eventStore.close();
+			} catch {
+				// Non-fatal: EventStore write should not break hook execution
+			}
 
-				// Throttled token snapshot recording
-				if (sessionId) {
-					try {
-						// Throttle check
-						const snapshotMarkerPath = join(logsBase, opts.agent, ".last-snapshot");
-						const SNAPSHOT_INTERVAL_MS = 30_000;
-						const snapshotMarkerFile = Bun.file(snapshotMarkerPath);
-						let shouldSnapshot = true;
-
-						if (await snapshotMarkerFile.exists()) {
-							const lastTs = Number.parseInt(await snapshotMarkerFile.text(), 10);
-							if (!Number.isNaN(lastTs) && Date.now() - lastTs < SNAPSHOT_INTERVAL_MS) {
-								shouldSnapshot = false;
-							}
+			// Throttled token snapshot recording (requires sessionId from --stdin; skipped for Pi agents)
+			if (sessionId) {
+				try {
+					// Throttle check
+					const snapshotMarkerPath = join(logsBase, opts.agent, ".last-snapshot");
+					const SNAPSHOT_INTERVAL_MS = 30_000;
+					const snapshotMarkerFile = Bun.file(snapshotMarkerPath);
+					let shouldSnapshot = true;
+
+					if (await snapshotMarkerFile.exists()) {
+						const lastTs = Number.parseInt(await snapshotMarkerFile.text(), 10);
+						if (!Number.isNaN(lastTs) && Date.now() - lastTs < SNAPSHOT_INTERVAL_MS) {
+							shouldSnapshot = false;
 						}
+					}
 
-						if (shouldSnapshot) {
-							const resolvedTranscriptPath = await resolveTranscriptPath(
-								config.project.root,
-								sessionId,
-								logsBase,
-								opts.agent,
-							);
-							if (resolvedTranscriptPath) {
-								const usage = await parseTranscriptUsage(resolvedTranscriptPath);
-								const cost = estimateCost(usage);
-								const metricsDbPath = join(config.project.root, ".overstory", "metrics.db");
-								const metricsStore = createMetricsStore(metricsDbPath);
-								metricsStore.recordSnapshot({
-									agentName: opts.agent,
-									inputTokens: usage.inputTokens,
-									outputTokens: usage.outputTokens,
-									cacheReadTokens: usage.cacheReadTokens,
-									cacheCreationTokens: usage.cacheCreationTokens,
-									estimatedCostUsd: cost,
-									modelUsed: usage.modelUsed,
-									createdAt: new Date().toISOString(),
-								});
-								metricsStore.close();
-								await Bun.write(snapshotMarkerPath, String(Date.now()));
-							}
+					if (shouldSnapshot) {
+						const resolvedTranscriptPath = await resolveTranscriptPath(
+							config.project.root,
+							sessionId,
+							logsBase,
+							opts.agent,
+						);
+						if (resolvedTranscriptPath) {
+							const usage = await parseTranscriptUsage(resolvedTranscriptPath);
+							const cost = estimateCost(usage);
+							const metricsDbPath = join(config.project.root, ".overstory", "metrics.db");
+							const metricsStore = createMetricsStore(metricsDbPath);
+							metricsStore.recordSnapshot({
+								agentName: opts.agent,
+								inputTokens: usage.inputTokens,
+								outputTokens: usage.outputTokens,
+								cacheReadTokens: usage.cacheReadTokens,
+								cacheCreationTokens: usage.cacheCreationTokens,
+								estimatedCostUsd: cost,
+								modelUsed: usage.modelUsed,
+								createdAt: new Date().toISOString(),
+							});
+							metricsStore.close();
+							await Bun.write(snapshotMarkerPath, String(Date.now()));
 						}
-					} catch {
-						// Non-fatal: snapshot recording should not break tool-end handling
 					}
+				} catch {
+					// Non-fatal: snapshot recording should not break tool-end handling
 				}
 			}
 			break;
@@ -681,29 +749,44 @@ async function runLog(opts: {
 							// Non-fatal: mulch learn/record should not break session-end handling
 						}
 					}
-				}
 
-				// Write session-end event to EventStore when --stdin is used
-				if (opts.stdin) {
-					try {
-						const eventsDbPath = join(config.project.root, ".overstory", "events.db");
-						const eventStore = createEventStore(eventsDbPath);
-						eventStore.insert({
-							runId: null,
-							agentName: opts.agent,
-							sessionId,
-							eventType: "session_end",
-							toolName: null,
-							toolArgs: null,
-							toolDurationMs: null,
-							level: "info",
-							data: transcriptPath ? JSON.stringify({ transcriptPath }) : null,
-						});
-						eventStore.close();
-					} catch {
-						// Non-fatal: EventStore write should not break session-end
+					// Append outcomes to applied mulch records (outcome feedback loop).
+					// Reads applied-records.json written by sling.ts at spawn time.
+					if (!PERSISTENT_CAPABILITIES.has(agentSession.capability)) {
+						try {
+							const mulchClient = createMulchClient(config.project.root);
+							await appendOutcomeToAppliedRecords({
+								mulchClient,
+								agentName: opts.agent,
+								capability: agentSession.capability,
+								taskId,
+								projectRoot: config.project.root,
+							});
+						} catch {
+							// Non-fatal
+						}
 					}
 				}
+
+				// Always write session-end event to EventStore (not just when --stdin is used)
+				try {
+					const eventsDbPath = join(config.project.root, ".overstory", "events.db");
+					const eventStore = createEventStore(eventsDbPath);
+					eventStore.insert({
+						runId: null,
+						agentName: opts.agent,
+						sessionId,
+						eventType: "session_end",
+						toolName: null,
+						toolArgs: null,
+						toolDurationMs: null,
+						level: "info",
+						data: transcriptPath ? JSON.stringify({ transcriptPath }) : null,
+					});
+					eventStore.close();
+				} catch {
+					// Non-fatal: EventStore write should not break session-end
+				}
 			}
 			// Clear the current session marker
 			{

package/src/commands/logs.test.ts

@@ -1,8 +1,9 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdir, rm, writeFile } from "node:fs/promises";
+import { mkdir, writeFile } 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 type { LogEvent } from "../types.ts";
 import { logsCommand } from "./logs.ts";
 
@@ -51,7 +52,7 @@ describe("logsCommand", () => {
 
 		// Clean up temp directory
 		try {
-			await rm(tmpDir, { recursive: true, force: true });
+			await cleanupTempDir(tmpDir);
 		} catch {
 			// Ignore cleanup errors
 		}

package/src/commands/mail.test.ts

@@ -6,13 +6,14 @@
  */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdir, mkdtemp, readdir, rm } from "node:fs/promises";
+import { mkdir, mkdtemp, readdir } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { createEventStore } from "../events/store.ts";
 import { stripAnsi } from "../logging/color.ts";
 import { createMailClient } from "../mail/client.ts";
 import { createMailStore } from "../mail/store.ts";
+import { cleanupTempDir } from "../test-helpers.ts";
 import type { StoredEvent } from "../types.ts";
 import { AUTO_NUDGE_TYPES, isDispatchNudge, mailCommand, shouldAutoNudge } from "./mail.ts";
 
@@ -70,7 +71,7 @@ describe("mailCommand", () => {
 		process.stdout.write = origWrite;
 		process.stderr.write = origStderrWrite;
 		process.chdir(origCwd);
-		await rm(tempDir, { recursive: true, force: true });
+		await cleanupTempDir(tempDir);
 	});
 
 	describe("list", () => {

package/src/commands/metrics.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 { createMetricsStore } from "../metrics/store.ts";
+import { cleanupTempDir } from "../test-helpers.ts";
 import type { SessionMetrics } from "../types.ts";
 import { metricsCommand } from "./metrics.ts";
 
@@ -44,7 +45,7 @@ describe("metricsCommand", () => {
 	afterEach(async () => {
 		process.stdout.write = originalWrite;
 		process.chdir(originalCwd);
-		await rm(tempDir, { recursive: true, force: true });
+		await cleanupTempDir(tempDir);
 	});
 
 	function output(): string {
@@ -366,7 +367,7 @@ describe("formatDuration helper", () => {
 	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/nudge.test.ts

@@ -1,10 +1,11 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdirSync } from "node:fs";
-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";
 import { createSessionStore } from "../sessions/store.ts";
+import { cleanupTempDir } from "../test-helpers.ts";
 import type { AgentSession, StoredEvent } from "../types.ts";
 
 /**
@@ -22,7 +23,7 @@ beforeEach(async () => {
 });
 
 afterEach(async () => {
-	await rm(tempDir, { recursive: true, force: true });
+	await cleanupTempDir(tempDir);
 });
 
 /**

package/src/commands/prime.test.ts

@@ -1,5 +1,5 @@
 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, createTempGitRepo } from "../test-helpers.ts";
@@ -55,7 +55,7 @@ describe("primeCommand", () => {
 		process.stdout.write = originalWrite;
 		process.stderr.write = originalStderrWrite;
 		process.chdir(originalCwd);
-		await rm(tempDir, { recursive: true, force: true });
+		await cleanupTempDir(tempDir);
 	});
 
 	function output(): string {
@@ -366,6 +366,7 @@ recentTasks: []
 !hooks.json
 !groups.json
 !agent-defs/
+!README.md
 `;
 
 		test("creates .overstory/.gitignore if missing", async () => {

package/src/commands/prime.ts

@@ -18,22 +18,7 @@ import { createMulchClient } from "../mulch/client.ts";
 import { openSessionStore } from "../sessions/compat.ts";
 import type { AgentIdentity, AgentManifest, SessionCheckpoint, SessionMetrics } from "../types.ts";
 import { getCurrentSessionName } from "../worktree/tmux.ts";
-
-/**
- * Gitignore content for .overstory/.gitignore.
- * TODO: Import from init.ts once it's exported (parallel branch change).
- * Wildcard+whitelist pattern: ignore everything except tracked config files.
- */
-const OVERSTORY_GITIGNORE = `# Wildcard+whitelist: ignore everything, whitelist tracked files
-# Auto-healed by ov prime on each session start
-*
-!.gitignore
-!config.yaml
-!agent-manifest.json
-!hooks.json
-!groups.json
-!agent-defs/
-`;
+import { OVERSTORY_GITIGNORE } from "./init.ts";
 
 export interface PrimeOptions {
 	agent?: string;

package/src/commands/replay.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 { replayCommand } from "./replay.ts";
 
@@ -64,7 +65,7 @@ describe("replayCommand", () => {
 	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/run.test.ts

@@ -11,6 +11,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { SessionStore } from "../sessions/store.ts";
 import { createRunStore, createSessionStore } from "../sessions/store.ts";
+import { cleanupTempDir } from "../test-helpers.ts";
 import type { AgentSession, InsertRun, RunStore } from "../types.ts";
 
 let tempDir: string;
@@ -31,7 +32,7 @@ beforeEach(async () => {
 afterEach(async () => {
 	runStore.close();
 	sessionStore.close();
-	await rm(tempDir, { recursive: true, force: true });
+	await cleanupTempDir(tempDir);
 });
 
 /** Write a run ID to current-run.txt. */

package/src/commands/sling.test.ts

@@ -14,9 +14,11 @@ import {
 	checkParentAgentLimit,
 	checkRunSessionLimit,
 	checkTaskLock,
+	extractMulchRecordIds,
 	inferDomainsFromFiles,
 	isRunningAsRoot,
 	parentHasScouts,
+	shouldShowScoutWarning,
 	validateHierarchy,
 } from "./sling.ts";
 
@@ -275,6 +277,65 @@ describe("parentHasScouts", () => {
 	});
 });
 
+/**
+ * Tests for shouldShowScoutWarning (overstory-6eyw).
+ *
+ * shouldShowScoutWarning determines whether the "spawning builder without scouts"
+ * warning should be emitted. It is a pure function extracted from slingCommand
+ * so it can be suppressed via --no-scout-check or --skip-scout.
+ */
+
+describe("shouldShowScoutWarning", () => {
+	function makeSession(
+		parentAgent: string | null,
+		capability: string,
+	): { parentAgent: string | null; capability: string } {
+		return { parentAgent, capability };
+	}
+
+	const withScout = [makeSession("lead-alpha", "scout"), makeSession("lead-alpha", "builder")];
+	const withoutScout = [makeSession("lead-alpha", "builder")];
+	const empty: { parentAgent: string | null; capability: string }[] = [];
+
+	test("returns true when builder has parent but no scouts", () => {
+		expect(shouldShowScoutWarning("builder", "lead-alpha", withoutScout, false, false)).toBe(true);
+	});
+
+	test("returns false when builder has parent and scouts exist", () => {
+		expect(shouldShowScoutWarning("builder", "lead-alpha", withScout, false, false)).toBe(false);
+	});
+
+	test("returns false when capability is not builder", () => {
+		expect(shouldShowScoutWarning("scout", "lead-alpha", empty, false, false)).toBe(false);
+		expect(shouldShowScoutWarning("reviewer", "lead-alpha", empty, false, false)).toBe(false);
+		expect(shouldShowScoutWarning("lead", "lead-alpha", empty, false, false)).toBe(false);
+	});
+
+	test("returns false when parentAgent is null (coordinator spawn)", () => {
+		expect(shouldShowScoutWarning("builder", null, withoutScout, false, false)).toBe(false);
+	});
+
+	test("returns false when noScoutCheck is true (flag suppresses warning)", () => {
+		expect(shouldShowScoutWarning("builder", "lead-alpha", withoutScout, true, false)).toBe(false);
+	});
+
+	test("returns false when skipScout is true (lead opted out of scouting)", () => {
+		expect(shouldShowScoutWarning("builder", "lead-alpha", withoutScout, false, true)).toBe(false);
+	});
+
+	test("returns false when both noScoutCheck and skipScout are true", () => {
+		expect(shouldShowScoutWarning("builder", "lead-alpha", withoutScout, true, true)).toBe(false);
+	});
+
+	test("returns false with empty sessions and no parent", () => {
+		expect(shouldShowScoutWarning("builder", null, empty, false, false)).toBe(false);
+	});
+
+	test("returns true with empty sessions and a parent (no scouts ever spawned)", () => {
+		expect(shouldShowScoutWarning("builder", "lead-alpha", empty, false, false)).toBe(true);
+	});
+});
+
 /**
  * Tests for hierarchy validation in sling.
  *
@@ -1147,3 +1208,69 @@ describe("sling runtime integration", () => {
 		expect(state.phase).toBe("loading");
 	});
 });
+
+describe("extractMulchRecordIds", () => {
+	test("returns empty array for empty string", () => {
+		expect(extractMulchRecordIds("")).toEqual([]);
+	});
+
+	test("returns empty when no mx-IDs present", () => {
+		const text = "## agents (2 records)\n- convention without ID";
+		expect(extractMulchRecordIds(text)).toEqual([]);
+	});
+
+	test("extracts single ID from a domain", () => {
+		const text = "## agents (1 records)\n- [convention] Some. (mx-abc123)";
+		expect(extractMulchRecordIds(text)).toEqual([{ id: "mx-abc123", domain: "agents" }]);
+	});
+
+	test("extracts multiple IDs from same domain", () => {
+		const text = ["## typescript", "- first. (mx-aaa111)", "- second. (mx-bbb222)"].join("\n");
+		expect(extractMulchRecordIds(text)).toEqual([
+			{ id: "mx-aaa111", domain: "typescript" },
+			{ id: "mx-bbb222", domain: "typescript" },
+		]);
+	});
+
+	test("extracts IDs from multiple domains", () => {
+		const text = ["## agents", "- agent. (mx-111aaa)", "## typescript", "- ts. (mx-222bbb)"].join(
+			"\n",
+		);
+		expect(extractMulchRecordIds(text)).toEqual([
+			{ id: "mx-111aaa", domain: "agents" },
+			{ id: "mx-222bbb", domain: "typescript" },
+		]);
+	});
+
+	test("ignores non-domain headings with no mx-IDs", () => {
+		const text = [
+			"## Quick Reference",
+			"- use mulch search",
+			"## agents",
+			"- real. (mx-deadbeef)",
+		].join("\n");
+		expect(extractMulchRecordIds(text)).toEqual([{ id: "mx-deadbeef", domain: "agents" }]);
+	});
+
+	test("deduplicates repeated pairs", () => {
+		const text = ["## agents", "- first. (mx-aabbcc)", "- dup. (mx-aabbcc)"].join("\n");
+		expect(extractMulchRecordIds(text)).toEqual([{ id: "mx-aabbcc", domain: "agents" }]);
+	});
+
+	test("handles realistic ml prime output", () => {
+		const text = [
+			"## agents (3 records, updated just now)",
+			"- [convention] lead.md convention. (mx-636708)",
+			"- [convention] writeOverlay(). (mx-b7fa3d)",
+			"## typescript (2 records, updated just now)",
+			"- [convention] No any types. (mx-2ce43d)",
+			"## Quick Reference",
+			"- mulch search",
+		].join("\n");
+		const result = extractMulchRecordIds(text);
+		expect(result).toHaveLength(3);
+		expect(result).toContainEqual({ id: "mx-636708", domain: "agents" });
+		expect(result).toContainEqual({ id: "mx-b7fa3d", domain: "agents" });
+		expect(result).toContainEqual({ id: "mx-2ce43d", domain: "typescript" });
+	});
+});