@os-eco/overstory-cli 0.6.4 → 0.6.6

package/src/merge/resolver.test.ts

@@ -24,6 +24,7 @@ import {
 	createMergeResolver,
 	looksLikeProse,
 	parseConflictPatterns,
+	resolveConflictsUnion,
 } from "./resolver.ts";
 
 /**
@@ -53,7 +54,7 @@ function mockSpawnResult(
 function makeTestEntry(overrides?: Partial<MergeEntry>): MergeEntry {
 	return {
 		branchName: overrides?.branchName ?? "feature-branch",
-		beadId: overrides?.beadId ?? "bead-123",
+		taskId: overrides?.taskId ?? "bead-123",
 		agentName: overrides?.agentName ?? "test-agent",
 		filesModified: overrides?.filesModified ?? ["src/test.ts"],
 		enqueuedAt: overrides?.enqueuedAt ?? new Date().toISOString(),
@@ -551,7 +552,7 @@ describe("createMergeResolver", () => {
 
 			const entry = makeTestEntry({
 				branchName: "overstory/my-agent/bead-xyz",
-				beadId: "bead-xyz",
+				taskId: "bead-xyz",
 				agentName: "my-agent",
 				filesModified: ["src/test.ts"],
 			});
@@ -564,7 +565,7 @@ describe("createMergeResolver", () => {
 			const result = await resolver.resolve(entry, defaultBranch, repoDir);
 
 			expect(result.entry.branchName).toBe("overstory/my-agent/bead-xyz");
-			expect(result.entry.beadId).toBe("bead-xyz");
+			expect(result.entry.taskId).toBe("bead-xyz");
 			expect(result.entry.agentName).toBe("my-agent");
 		});
 	});
@@ -744,7 +745,7 @@ describe("createMergeResolver", () => {
 
 				const entry = makeTestEntry({
 					branchName: "feature-branch",
-					beadId: "bead-abc-123",
+					taskId: "bead-abc-123",
 					agentName: "test-builder",
 					filesModified: ["src/test.ts"],
 				});
@@ -811,7 +812,7 @@ describe("createMergeResolver", () => {
 
 				const entry = makeTestEntry({
 					branchName: "feature-branch",
-					beadId: "bead-fail-456",
+					taskId: "bead-fail-456",
 					agentName: "test-agent",
 					filesModified: ["src/test.ts"],
 				});
@@ -906,7 +907,7 @@ describe("createMergeResolver", () => {
 
 				const entry = makeTestEntry({
 					branchName: "feature-branch",
-					beadId: "bead-ai-789",
+					taskId: "bead-ai-789",
 					filesModified: ["src/test.ts"],
 				});
 
@@ -981,7 +982,7 @@ describe("createMergeResolver", () => {
 
 				const entry = makeTestEntry({
 					branchName: "feature-branch",
-					beadId: "bead-reimagine-xyz",
+					taskId: "bead-reimagine-xyz",
 					filesModified: ["src/reimagine-target.ts"],
 				});
 
@@ -1288,6 +1289,157 @@ describe("createMergeResolver", () => {
 		});
 	});
 
+	describe("resolveConflictsUnion", () => {
+		test("returns null when no conflict markers are present", () => {
+			expect(resolveConflictsUnion("no conflicts here\n")).toBeNull();
+			expect(resolveConflictsUnion("")).toBeNull();
+		});
+
+		test("keeps both canonical and incoming content for a single conflict", () => {
+			const content = [
+				"<<<<<<< HEAD\n",
+				'{"id":"a"}\n',
+				'{"id":"c"}\n',
+				"=======\n",
+				'{"id":"a"}\n',
+				'{"id":"b"}\n',
+				">>>>>>> feature-branch\n",
+			].join("");
+			const result = resolveConflictsUnion(content);
+			expect(result).not.toBeNull();
+			expect(result).toContain('{"id":"a"}\n{"id":"c"}\n');
+			expect(result).toContain('{"id":"a"}\n{"id":"b"}\n');
+			// No conflict markers remain
+			expect(result).not.toContain("<<<<<<<");
+			expect(result).not.toContain("=======");
+			expect(result).not.toContain(">>>>>>>");
+		});
+
+		test("resolves multiple conflict blocks with union strategy", () => {
+			const block = (canonical: string, incoming: string): string =>
+				`<<<<<<< HEAD\n${canonical}\n=======\n${incoming}\n>>>>>>> branch\n`;
+			const content = `${block("line-a\n", "line-b\n")}middle\n${block("line-c\n", "line-d\n")}`;
+			const result = resolveConflictsUnion(content);
+			expect(result).not.toBeNull();
+			expect(result).toContain("line-a\n");
+			expect(result).toContain("line-b\n");
+			expect(result).toContain("middle\n");
+			expect(result).toContain("line-c\n");
+			expect(result).toContain("line-d\n");
+			expect(result).not.toContain("<<<<<<<");
+		});
+	});
+
+	describe("merge=union gitattribute support", () => {
+		test("union strategy preserves lines from both sides (git handles cleanly or via auto-resolve)", async () => {
+			const repoDir = await createTempGitRepo();
+			try {
+				const defaultBranch = await getDefaultBranch(repoDir);
+
+				// Set up .gitattributes with merge=union for *.jsonl files so that
+				// both git's built-in union driver AND overstory's Tier 2 union path
+				// are configured to keep all lines from both sides.
+				await commitFile(repoDir, ".gitattributes", "*.jsonl merge=union\n");
+				// Common ancestor: one line
+				await commitFile(repoDir, "data.jsonl", '{"id":"a"}\n');
+
+				// Feature branch: adds line b
+				await runGitInDir(repoDir, ["checkout", "-b", "feature-branch"]);
+				await commitFile(repoDir, "data.jsonl", '{"id":"a"}\n{"id":"b"}\n');
+
+				// Back to main: adds line c (diverges from ancestor)
+				await runGitInDir(repoDir, ["checkout", defaultBranch]);
+				await commitFile(repoDir, "data.jsonl", '{"id":"a"}\n{"id":"c"}\n');
+
+				const entry = makeTestEntry({
+					branchName: "feature-branch",
+					filesModified: ["data.jsonl"],
+				});
+
+				const resolver = createMergeResolver({
+					aiResolveEnabled: false,
+					reimagineEnabled: false,
+				});
+
+				const result = await resolver.resolve(entry, defaultBranch, repoDir);
+
+				// With merge=union, git either resolves cleanly (Tier 1) or
+				// overstory's union path handles it (Tier 2). Either way, success
+				// and both sides' content must be preserved.
+				expect(result.success).toBe(true);
+				expect(result.entry.status).toBe("merged");
+
+				// Both sides' lines must be present — no lines dropped
+				const file = Bun.file(join(repoDir, "data.jsonl"));
+				const content = await file.text();
+				expect(content).toContain('{"id":"a"}');
+				expect(content).toContain('{"id":"b"}');
+				expect(content).toContain('{"id":"c"}');
+			} finally {
+				await cleanupTempDir(repoDir);
+			}
+		});
+
+		test("Tier 2 union auto-resolve keeps both sides when git produces conflict markers", async () => {
+			// This test verifies the Tier 2 code path: when git produces conflict
+			// markers for a file that has merge=union set in .gitattributes,
+			// overstory resolves it by keeping both canonical and incoming content.
+			// We produce conflict markers by doing a content conflict on a file whose
+			// attribute is set to merge=union AFTER the conflict state exists, then
+			// run only the auto-resolve path via a standalone resolver call.
+			//
+			// To force conflict markers despite merge=union: we DON'T commit
+			// .gitattributes before the merge, so git uses the default driver and
+			// produces conflict markers. Then we write .gitattributes to the working
+			// tree (not committed) so git check-attr sees it and our code detects union.
+			const repoDir = await createTempGitRepo();
+			try {
+				const defaultBranch = await getDefaultBranch(repoDir);
+
+				// Common ancestor
+				await commitFile(repoDir, "data.jsonl", '{"id":"a"}\n');
+
+				// Feature branch: adds line b (also appends to same position as main)
+				await runGitInDir(repoDir, ["checkout", "-b", "feature-branch"]);
+				await commitFile(repoDir, "data.jsonl", '{"id":"a"}\n{"id":"b"}\n');
+
+				// Back to main: adds line c — diverges from ancestor at same position
+				await runGitInDir(repoDir, ["checkout", defaultBranch]);
+				await commitFile(repoDir, "data.jsonl", '{"id":"a"}\n{"id":"c"}\n');
+
+				// Now WRITE .gitattributes to working tree (not committed).
+				// git check-attr reads from the working tree during Tier 2.
+				await Bun.write(`${repoDir}/.gitattributes`, "*.jsonl merge=union\n");
+
+				// Attempt merge — git uses default driver (no committed .gitattributes)
+				// so it WILL produce conflict markers if branches diverge at same position.
+				// (If git resolves cleanly, the test still passes because content is preserved.)
+				const entry = makeTestEntry({
+					branchName: "feature-branch",
+					filesModified: ["data.jsonl"],
+				});
+
+				const resolver = createMergeResolver({
+					aiResolveEnabled: false,
+					reimagineEnabled: false,
+				});
+
+				const result = await resolver.resolve(entry, defaultBranch, repoDir);
+
+				expect(result.success).toBe(true);
+				expect(result.entry.status).toBe("merged");
+
+				const file = Bun.file(join(repoDir, "data.jsonl"));
+				const content = await file.text();
+				expect(content).toContain('{"id":"a"}');
+				expect(content).toContain('{"id":"b"}');
+				expect(content).toContain('{"id":"c"}');
+			} 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

@@ -89,6 +89,47 @@ function resolveConflictsKeepIncoming(content: string): string | null {
 	});
 }
 
+/**
+ * Parse conflict markers in file content and keep ALL lines from both sides.
+ * Used when the file has `merge=union` gitattribute — dedup-on-read handles duplicates.
+ *
+ * A conflict block looks like:
+ * ```
+ * <<<<<<< HEAD
+ * canonical content
+ * =======
+ * incoming content
+ * >>>>>>> branch
+ * ```
+ *
+ * This function replaces each conflict block with canonical + incoming content concatenated.
+ * Returns the resolved content, or null if no conflict markers were found.
+ */
+export function resolveConflictsUnion(content: string): string | null {
+	const conflictPattern = /^<{7} .+\n([\s\S]*?)^={7}\n([\s\S]*?)^>{7} .+\n?/gm;
+
+	if (!conflictPattern.test(content)) {
+		return null;
+	}
+
+	// Reset regex lastIndex after test()
+	conflictPattern.lastIndex = 0;
+
+	return content.replace(conflictPattern, (_match, canonical: string, incoming: string) => {
+		return canonical + incoming;
+	});
+}
+
+/**
+ * Check if a file has the `merge=union` gitattribute set.
+ * Returns true if `git check-attr merge -- <file>` ends with ": merge: union".
+ */
+async function checkMergeUnion(repoRoot: string, filePath: string): Promise<boolean> {
+	const { stdout, exitCode } = await runGit(repoRoot, ["check-attr", "merge", "--", filePath]);
+	if (exitCode !== 0) return false;
+	return stdout.trim().endsWith(": merge: union");
+}
+
 /**
  * Read a file's content using Bun.file().
  */
@@ -138,7 +179,10 @@ async function tryAutoResolve(
 
 		try {
 			const content = await readFile(filePath);
-			const resolved = resolveConflictsKeepIncoming(content);
+			const isUnion = await checkMergeUnion(repoRoot, file);
+			const resolved = isUnion
+				? resolveConflictsUnion(content)
+				: resolveConflictsKeepIncoming(content);
 
 			if (resolved === null) {
 				// No conflict markers found (shouldn't happen but be defensive)
@@ -496,7 +540,7 @@ function recordConflictPattern(
 			type: "pattern",
 			description,
 			tags: ["merge-conflict"],
-			evidenceBead: entry.beadId,
+			evidenceBead: entry.taskId,
 		})
 		.catch(() => {});
 }

package/src/metrics/store.test.ts

@@ -32,7 +32,7 @@ afterEach(async () => {
 function makeSession(overrides: Partial<SessionMetrics> = {}): SessionMetrics {
 	return {
 		agentName: "test-agent",
-		beadId: "test-task-123",
+		taskId: "test-task-123",
 		capability: "builder",
 		startedAt: new Date("2026-01-01T00:00:00Z").toISOString(),
 		completedAt: new Date("2026-01-01T00:05:00Z").toISOString(),
@@ -78,7 +78,7 @@ describe("recordSession", () => {
 	test("all fields roundtrip correctly (camelCase TS → snake_case SQLite → camelCase TS)", () => {
 		const session = makeSession({
 			agentName: "special-agent",
-			beadId: "task-xyz",
+			taskId: "task-xyz",
 			capability: "reviewer",
 			startedAt: "2026-02-01T12:00:00Z",
 			completedAt: "2026-02-01T12:30:00Z",
@@ -119,15 +119,15 @@ describe("recordSession", () => {
 describe("getRecentSessions", () => {
 	test("returns sessions ordered by started_at DESC (most recent first)", () => {
 		const session1 = makeSession({
-			beadId: "task-1",
+			taskId: "task-1",
 			startedAt: "2026-01-01T10:00:00Z",
 		});
 		const session2 = makeSession({
-			beadId: "task-2",
+			taskId: "task-2",
 			startedAt: "2026-01-01T12:00:00Z",
 		});
 		const session3 = makeSession({
-			beadId: "task-3",
+			taskId: "task-3",
 			startedAt: "2026-01-01T11:00:00Z",
 		});
 
@@ -137,9 +137,9 @@ describe("getRecentSessions", () => {
 
 		const retrieved = store.getRecentSessions(10);
 		expect(retrieved).toHaveLength(3);
-		expect(retrieved[0]?.beadId).toBe("task-2"); // most recent
-		expect(retrieved[1]?.beadId).toBe("task-3");
-		expect(retrieved[2]?.beadId).toBe("task-1"); // oldest
+		expect(retrieved[0]?.taskId).toBe("task-2"); // most recent
+		expect(retrieved[1]?.taskId).toBe("task-3");
+		expect(retrieved[2]?.taskId).toBe("task-1"); // oldest
 	});
 
 	test("default limit is 20", () => {
@@ -147,7 +147,7 @@ describe("getRecentSessions", () => {
 		for (let i = 0; i < 25; i++) {
 			store.recordSession(
 				makeSession({
-					beadId: `task-${i}`,
+					taskId: `task-${i}`,
 					startedAt: new Date(Date.now() + i * 1000).toISOString(),
 				}),
 			);
@@ -158,9 +158,9 @@ describe("getRecentSessions", () => {
 	});
 
 	test("custom limit works (e.g., limit=2 returns only 2)", () => {
-		store.recordSession(makeSession({ beadId: "task-1" }));
-		store.recordSession(makeSession({ beadId: "task-2" }));
-		store.recordSession(makeSession({ beadId: "task-3" }));
+		store.recordSession(makeSession({ taskId: "task-1" }));
+		store.recordSession(makeSession({ taskId: "task-2" }));
+		store.recordSession(makeSession({ taskId: "task-3" }));
 
 		const retrieved = store.getRecentSessions(2);
 		expect(retrieved).toHaveLength(2);
@@ -176,9 +176,9 @@ describe("getRecentSessions", () => {
 
 describe("getSessionsByAgent", () => {
 	test("filters by agent name correctly", () => {
-		store.recordSession(makeSession({ agentName: "agent-a", beadId: "task-1" }));
-		store.recordSession(makeSession({ agentName: "agent-b", beadId: "task-2" }));
-		store.recordSession(makeSession({ agentName: "agent-a", beadId: "task-3" }));
+		store.recordSession(makeSession({ agentName: "agent-a", taskId: "task-1" }));
+		store.recordSession(makeSession({ agentName: "agent-b", taskId: "task-2" }));
+		store.recordSession(makeSession({ agentName: "agent-a", taskId: "task-3" }));
 
 		const retrieved = store.getSessionsByAgent("agent-a");
 		expect(retrieved).toHaveLength(2);
@@ -197,30 +197,30 @@ describe("getSessionsByAgent", () => {
 		store.recordSession(
 			makeSession({
 				agentName: "agent-x",
-				beadId: "task-1",
+				taskId: "task-1",
 				startedAt: "2026-01-01T10:00:00Z",
 			}),
 		);
 		store.recordSession(
 			makeSession({
 				agentName: "agent-x",
-				beadId: "task-2",
+				taskId: "task-2",
 				startedAt: "2026-01-01T12:00:00Z",
 			}),
 		);
 		store.recordSession(
 			makeSession({
 				agentName: "agent-x",
-				beadId: "task-3",
+				taskId: "task-3",
 				startedAt: "2026-01-01T11:00:00Z",
 			}),
 		);
 
 		const retrieved = store.getSessionsByAgent("agent-x");
 		expect(retrieved).toHaveLength(3);
-		expect(retrieved[0]?.beadId).toBe("task-2"); // most recent
-		expect(retrieved[1]?.beadId).toBe("task-3");
-		expect(retrieved[2]?.beadId).toBe("task-1"); // oldest
+		expect(retrieved[0]?.taskId).toBe("task-2"); // most recent
+		expect(retrieved[1]?.taskId).toBe("task-3");
+		expect(retrieved[2]?.taskId).toBe("task-1"); // oldest
 	});
 });
 
@@ -228,9 +228,9 @@ describe("getSessionsByAgent", () => {
 
 describe("getAverageDuration", () => {
 	test("average across all completed sessions (completedAt IS NOT NULL)", () => {
-		store.recordSession(makeSession({ beadId: "task-1", durationMs: 100_000 }));
-		store.recordSession(makeSession({ beadId: "task-2", durationMs: 200_000 }));
-		store.recordSession(makeSession({ beadId: "task-3", durationMs: 300_000 }));
+		store.recordSession(makeSession({ taskId: "task-1", durationMs: 100_000 }));
+		store.recordSession(makeSession({ taskId: "task-2", durationMs: 200_000 }));
+		store.recordSession(makeSession({ taskId: "task-3", durationMs: 300_000 }));
 
 		const avg = store.getAverageDuration();
 		expect(avg).toBe(200_000);
@@ -238,11 +238,11 @@ describe("getAverageDuration", () => {
 
 	test("average filtered by capability", () => {
 		store.recordSession(
-			makeSession({ beadId: "task-1", capability: "builder", durationMs: 100_000 }),
+			makeSession({ taskId: "task-1", capability: "builder", durationMs: 100_000 }),
 		);
-		store.recordSession(makeSession({ beadId: "task-2", capability: "scout", durationMs: 50_000 }));
+		store.recordSession(makeSession({ taskId: "task-2", capability: "scout", durationMs: 50_000 }));
 		store.recordSession(
-			makeSession({ beadId: "task-3", capability: "builder", durationMs: 200_000 }),
+			makeSession({ taskId: "task-3", capability: "builder", durationMs: 200_000 }),
 		);
 
 		const avgBuilder = store.getAverageDuration("builder");
@@ -258,9 +258,9 @@ describe("getAverageDuration", () => {
 	});
 
 	test("sessions with completedAt=null are excluded from average", () => {
-		store.recordSession(makeSession({ beadId: "task-1", durationMs: 100_000, completedAt: null }));
-		store.recordSession(makeSession({ beadId: "task-2", durationMs: 200_000 }));
-		store.recordSession(makeSession({ beadId: "task-3", durationMs: 300_000 }));
+		store.recordSession(makeSession({ taskId: "task-1", durationMs: 100_000, completedAt: null }));
+		store.recordSession(makeSession({ taskId: "task-2", durationMs: 200_000 }));
+		store.recordSession(makeSession({ taskId: "task-3", durationMs: 300_000 }));
 
 		const avg = store.getAverageDuration();
 		expect(avg).toBe(250_000); // (200_000 + 300_000) / 2
@@ -359,7 +359,7 @@ describe("token fields", () => {
 		store.recordSession(
 			makeSession({
 				agentName: "new-agent",
-				beadId: "new-task",
+				taskId: "new-task",
 				inputTokens: 5000,
 				outputTokens: 1000,
 				estimatedCostUsd: 0.42,
@@ -378,9 +378,9 @@ describe("token fields", () => {
 
 describe("getSessionsByRun", () => {
 	test("returns sessions matching run_id", () => {
-		store.recordSession(makeSession({ agentName: "a1", beadId: "t1", runId: "run-001" }));
-		store.recordSession(makeSession({ agentName: "a2", beadId: "t2", runId: "run-001" }));
-		store.recordSession(makeSession({ agentName: "a3", beadId: "t3", runId: "run-002" }));
+		store.recordSession(makeSession({ agentName: "a1", taskId: "t1", runId: "run-001" }));
+		store.recordSession(makeSession({ agentName: "a2", taskId: "t2", runId: "run-001" }));
+		store.recordSession(makeSession({ agentName: "a3", taskId: "t3", runId: "run-002" }));
 
 		const sessions = store.getSessionsByRun("run-001");
 		expect(sessions).toHaveLength(2);
@@ -388,13 +388,13 @@ describe("getSessionsByRun", () => {
 	});
 
 	test("returns empty array for unknown run_id", () => {
-		store.recordSession(makeSession({ agentName: "a1", beadId: "t1", runId: "run-001" }));
+		store.recordSession(makeSession({ agentName: "a1", taskId: "t1", runId: "run-001" }));
 		expect(store.getSessionsByRun("run-nonexistent")).toEqual([]);
 	});
 
 	test("sessions with null run_id are not returned", () => {
-		store.recordSession(makeSession({ agentName: "a1", beadId: "t1", runId: null }));
-		store.recordSession(makeSession({ agentName: "a2", beadId: "t2", runId: "run-001" }));
+		store.recordSession(makeSession({ agentName: "a1", taskId: "t1", runId: null }));
+		store.recordSession(makeSession({ agentName: "a2", taskId: "t2", runId: "run-001" }));
 		expect(store.getSessionsByRun("run-001")).toHaveLength(1);
 	});
 });
@@ -403,9 +403,9 @@ describe("getSessionsByRun", () => {
 
 describe("purge", () => {
 	test("purge all deletes everything and returns count", () => {
-		store.recordSession(makeSession({ agentName: "agent-a", beadId: "task-1" }));
-		store.recordSession(makeSession({ agentName: "agent-b", beadId: "task-2" }));
-		store.recordSession(makeSession({ agentName: "agent-c", beadId: "task-3" }));
+		store.recordSession(makeSession({ agentName: "agent-a", taskId: "task-1" }));
+		store.recordSession(makeSession({ agentName: "agent-b", taskId: "task-2" }));
+		store.recordSession(makeSession({ agentName: "agent-c", taskId: "task-3" }));
 
 		const count = store.purge({ all: true });
 		expect(count).toBe(3);
@@ -413,9 +413,9 @@ describe("purge", () => {
 	});
 
 	test("purge by agent deletes only that agent's records", () => {
-		store.recordSession(makeSession({ agentName: "agent-a", beadId: "task-1" }));
-		store.recordSession(makeSession({ agentName: "agent-b", beadId: "task-2" }));
-		store.recordSession(makeSession({ agentName: "agent-a", beadId: "task-3" }));
+		store.recordSession(makeSession({ agentName: "agent-a", taskId: "task-1" }));
+		store.recordSession(makeSession({ agentName: "agent-b", taskId: "task-2" }));
+		store.recordSession(makeSession({ agentName: "agent-a", taskId: "task-3" }));
 
 		const count = store.purge({ agent: "agent-a" });
 		expect(count).toBe(2);
@@ -431,7 +431,7 @@ describe("purge", () => {
 	});
 
 	test("purge with no options returns 0 without deleting", () => {
-		store.recordSession(makeSession({ beadId: "task-1" }));
+		store.recordSession(makeSession({ taskId: "task-1" }));
 
 		const count = store.purge({});
 		expect(count).toBe(0);

package/src/metrics/store.ts

@@ -152,7 +152,7 @@ function migrateTokenColumns(db: Database): void {
 function rowToMetrics(row: SessionRow): SessionMetrics {
 	return {
 		agentName: row.agent_name,
-		beadId: row.task_id,
+		taskId: row.task_id,
 		capability: row.capability,
 		startedAt: row.started_at,
 		completedAt: row.completed_at,
@@ -303,7 +303,7 @@ export function createMetricsStore(dbPath: string): MetricsStore {
 		recordSession(metrics: SessionMetrics): void {
 			insertStmt.run({
 				$agent_name: metrics.agentName,
-				$task_id: metrics.beadId,
+				$task_id: metrics.taskId,
 				$capability: metrics.capability,
 				$started_at: metrics.startedAt,
 				$completed_at: metrics.completedAt,