@os-eco/overstory-cli 0.8.5 → 0.8.7

package/src/merge/resolver.ts

@@ -11,6 +11,7 @@
  * Disabled tiers are skipped. Uses Bun.spawn for all subprocess calls.
  */
 
+import { unlinkSync } from "node:fs";
 import { MergeError } from "../errors.ts";
 import type { MulchClient } from "../mulch/client.ts";
 import { getRuntime } from "../runtimes/registry.ts";
@@ -50,6 +51,30 @@ async function runGit(
 	return { stdout, stderr, exitCode };
 }
 
+/**
+ * os-eco runtime state path prefixes and exact filenames.
+ * Files matching these are bookkeeping artifacts that change during normal
+ * orchestration and should be auto-committed rather than blocking merges.
+ */
+const OS_ECO_STATE_PREFIXES = [
+	".seeds/",
+	".overstory/",
+	".greenhouse/",
+	".mulch/",
+	".canopy/",
+	".claude/",
+];
+const OS_ECO_STATE_FILES = ["CLAUDE.md"];
+
+/**
+ * Returns true if a file path is an os-eco runtime state file
+ * (issue tracker, groups, expertise, prompts, etc.).
+ */
+function isOsEcoStateFile(filePath: string): boolean {
+	if (OS_ECO_STATE_FILES.includes(filePath)) return true;
+	return OS_ECO_STATE_PREFIXES.some((prefix) => filePath.startsWith(prefix));
+}
+
 /**
  * Get the list of tracked files with uncommitted changes (unstaged or staged).
  * Returns deduplicated list of file paths. An empty list means the working tree is clean.
@@ -70,6 +95,24 @@ async function checkDirtyWorkingTree(repoRoot: string): Promise<string[]> {
 	return [...new Set(files)];
 }
 
+/**
+ * Auto-commit os-eco runtime state files so they don't block merges.
+ * Returns true if a commit was made, false if there was nothing to commit.
+ */
+async function autoCommitStateFiles(repoRoot: string, stateFiles: string[]): Promise<boolean> {
+	if (stateFiles.length === 0) return false;
+
+	const { exitCode: addCode } = await runGit(repoRoot, ["add", ...stateFiles]);
+	if (addCode !== 0) return false;
+
+	const { exitCode: commitCode } = await runGit(repoRoot, [
+		"commit",
+		"-m",
+		"chore: sync os-eco runtime state",
+	]);
+	return commitCode === 0;
+}
+
 /**
  * Get the list of conflicted files from `git diff --name-only --diff-filter=U`.
  */
@@ -142,6 +185,24 @@ export function resolveConflictsUnion(content: string): string | null {
 	});
 }
 
+/**
+ * Detect if any conflict block has non-whitespace content on the canonical (HEAD) side.
+ * Returns true if auto-resolving with keep-incoming would silently discard canonical content.
+ * Use this before calling resolveConflictsKeepIncoming to prevent data loss.
+ */
+export function hasContentfulCanonical(content: string): boolean {
+	const conflictPattern = /^<{7} .+\n([\s\S]*?)^={7}\n([\s\S]*?)^>{7} .+\n?/gm;
+	let match = conflictPattern.exec(content);
+	while (match !== null) {
+		const canonical = match[1] ?? "";
+		if (canonical.trim().length > 0) {
+			return true;
+		}
+		match = conflictPattern.exec(content);
+	}
+	return false;
+}
+
 /**
  * Check if a file has the `merge=union` gitattribute set.
  * Returns true if `git check-attr merge -- <file>` ends with ": merge: union".
@@ -189,12 +250,15 @@ async function tryCleanMerge(
 /**
  * Tier 2: Auto-resolve conflicts by keeping incoming (agent) changes.
  * Parses conflict markers and keeps the content between ======= and >>>>>>>.
+ * Skips files where the canonical side has non-whitespace content to prevent
+ * silent data loss — those files are escalated to higher tiers.
  */
 async function tryAutoResolve(
 	conflictFiles: string[],
 	repoRoot: string,
-): Promise<{ success: boolean; remainingConflicts: string[] }> {
+): Promise<{ success: boolean; remainingConflicts: string[]; contentDropWarnings: string[] }> {
 	const remainingConflicts: string[] = [];
+	const contentDropWarnings: string[] = [];
 
 	for (const file of conflictFiles) {
 		const filePath = `${repoRoot}/${file}`;
@@ -202,6 +266,18 @@ async function tryAutoResolve(
 		try {
 			const content = await readFile(filePath);
 			const isUnion = await checkMergeUnion(repoRoot, file);
+
+			// For non-union files, check if the canonical side has content.
+			// If it does, auto-resolving would silently discard that content.
+			// Escalate to a higher tier instead.
+			if (!isUnion && hasContentfulCanonical(content)) {
+				contentDropWarnings.push(
+					`auto-resolve skipped for ${file}: canonical side has content that would be discarded`,
+				);
+				remainingConflicts.push(file);
+				continue;
+			}
+
 			const resolved = isUnion
 				? resolveConflictsUnion(content)
 				: resolveConflictsKeepIncoming(content);
@@ -223,12 +299,12 @@ async function tryAutoResolve(
 	}
 
 	if (remainingConflicts.length > 0) {
-		return { success: false, remainingConflicts };
+		return { success: false, remainingConflicts, contentDropWarnings };
 	}
 
 	// All files resolved — commit
 	const { exitCode } = await runGit(repoRoot, ["commit", "--no-edit"]);
-	return { success: exitCode === 0, remainingConflicts };
+	return { success: exitCode === 0, remainingConflicts, contentDropWarnings };
 }
 
 /**
@@ -585,6 +661,7 @@ export function createMergeResolver(options: {
 	reimagineEnabled: boolean;
 	mulchClient?: MulchClient;
 	config?: OverstoryConfig;
+	onMergeSuccess?: (entry: MergeEntry) => Promise<void>;
 }): MergeResolver {
 	return {
 		async resolve(
@@ -613,127 +690,243 @@ export function createMergeResolver(options: {
 				}
 			}
 
-			// Pre-check: abort early if working tree has uncommitted changes.
+			// Pre-check: auto-commit os-eco state files, stash any remaining dirty tracked files.
 			// When dirty tracked files exist, git merge refuses to start (exit 1, no conflict markers),
 			// causing all tiers to cascade with empty conflict lists and a misleading final error.
 			const dirtyFiles = await checkDirtyWorkingTree(repoRoot);
 			if (dirtyFiles.length > 0) {
-				throw new MergeError(
-					`Working tree has uncommitted changes to tracked files: ${dirtyFiles.join(", ")}. Commit or stash changes before running ov merge.`,
-					{ branchName: entry.branchName },
-				);
+				const stateFiles = dirtyFiles.filter(isOsEcoStateFile);
+
+				// Auto-commit os-eco runtime state files so they don't block merges
+				if (stateFiles.length > 0) {
+					await autoCommitStateFiles(repoRoot, stateFiles);
+				}
+			}
+
+			// Re-check after auto-commit: any remaining dirty tracked files get stashed
+			// so clean-merge-eligible branches can proceed without manual intervention.
+			let didStash = false;
+			const remainingDirty = await checkDirtyWorkingTree(repoRoot);
+			if (remainingDirty.length > 0) {
+				const { exitCode: stashCode } = await runGit(repoRoot, [
+					"stash",
+					"push",
+					"-m",
+					"ov-merge: auto-stash dirty files",
+				]);
+				if (stashCode !== 0) {
+					throw new MergeError(
+						`Working tree has uncommitted changes to tracked files: ${remainingDirty.join(", ")}. Commit or stash changes before running ov merge.`,
+						{ branchName: entry.branchName },
+					);
+				}
+				didStash = true;
 			}
 
+			const warnings: string[] = [];
 			let lastTier: ResolutionTier = "clean-merge";
 			let conflictFiles: string[] = [];
 
-			// Tier 1: Clean merge
-			const cleanResult = await tryCleanMerge(entry, repoRoot);
-			if (cleanResult.success) {
-				return {
-					entry: { ...entry, status: "merged", resolvedTier: "clean-merge" },
-					success: true,
-					tier: "clean-merge",
-					conflictFiles: [],
-					errorMessage: null,
-				};
-			}
-			conflictFiles = cleanResult.conflictFiles;
-
-			// Query conflict history (if mulchClient available)
-			let history: ConflictHistory = {
-				skipTiers: [],
-				pastResolutions: [],
-				predictedConflictFiles: [],
-			};
-			if (options.mulchClient) {
-				history = await queryConflictHistory(options.mulchClient, entry);
-			}
+			try {
+				// Delete untracked files overlapping entry.filesModified before merging.
+				// git merge refuses to run if untracked files in the working tree would
+				// be overwritten by the incoming branch. Deleting them lets the merge
+				// proceed and bring in the branch version.
+				const { stdout: untrackedOut } = await runGit(repoRoot, [
+					"ls-files",
+					"--others",
+					"--exclude-standard",
+				]);
+				const untrackedFiles = untrackedOut
+					.trim()
+					.split("\n")
+					.filter((f) => f.length > 0);
+				const entryFileSet = new Set(entry.filesModified);
+				const overlappingUntracked = untrackedFiles.filter((f) => entryFileSet.has(f));
+				for (const file of overlappingUntracked) {
+					const filePath = `${repoRoot}/${file}`;
+					try {
+						if (await Bun.file(filePath).exists()) {
+							unlinkSync(filePath);
+						}
+						warnings.push(
+							`untracked file deleted before merge: ${file} (branch version will be used)`,
+						);
+					} catch {
+						// Ignore errors removing untracked files
+					}
+				}
 
-			// Tier 2: Auto-resolve (keep incoming)
-			if (!history.skipTiers.includes("auto-resolve")) {
-				lastTier = "auto-resolve";
-				const autoResult = await tryAutoResolve(conflictFiles, repoRoot);
-				if (autoResult.success) {
-					if (options.mulchClient) {
-						recordConflictPattern(options.mulchClient, entry, "auto-resolve", conflictFiles, true);
+				// Tier 1: Clean merge
+				const cleanResult = await tryCleanMerge(entry, repoRoot);
+				if (cleanResult.success) {
+					if (options.onMergeSuccess) {
+						try {
+							await options.onMergeSuccess({
+								...entry,
+								status: "merged",
+								resolvedTier: "clean-merge",
+							});
+						} catch {
+							// callback failures must not fail the merge
+						}
 					}
 					return {
-						entry: { ...entry, status: "merged", resolvedTier: "auto-resolve" },
+						entry: { ...entry, status: "merged", resolvedTier: "clean-merge" },
 						success: true,
-						tier: "auto-resolve",
-						conflictFiles,
+						tier: "clean-merge",
+						conflictFiles: [],
 						errorMessage: null,
+						warnings,
 					};
 				}
-				conflictFiles = autoResult.remainingConflicts;
-			} // If skipped, fall through to next tier
+				conflictFiles = cleanResult.conflictFiles;
 
-			// Tier 3: AI-resolve
-			if (options.aiResolveEnabled && !history.skipTiers.includes("ai-resolve")) {
-				lastTier = "ai-resolve";
-				const aiResult = await tryAiResolve(
-					conflictFiles,
-					repoRoot,
-					history.pastResolutions,
-					options.config,
-				);
-				if (aiResult.success) {
-					if (options.mulchClient) {
-						recordConflictPattern(options.mulchClient, entry, "ai-resolve", conflictFiles, true);
+				// Query conflict history (if mulchClient available)
+				let history: ConflictHistory = {
+					skipTiers: [],
+					pastResolutions: [],
+					predictedConflictFiles: [],
+				};
+				if (options.mulchClient) {
+					history = await queryConflictHistory(options.mulchClient, entry);
+				}
+
+				// Tier 2: Auto-resolve (keep incoming)
+				if (!history.skipTiers.includes("auto-resolve")) {
+					lastTier = "auto-resolve";
+					const autoResult = await tryAutoResolve(conflictFiles, repoRoot);
+					if (autoResult.contentDropWarnings.length > 0) {
+						warnings.push(...autoResult.contentDropWarnings);
 					}
-					return {
-						entry: { ...entry, status: "merged", resolvedTier: "ai-resolve" },
-						success: true,
-						tier: "ai-resolve",
+					if (autoResult.success) {
+						if (options.mulchClient) {
+							recordConflictPattern(
+								options.mulchClient,
+								entry,
+								"auto-resolve",
+								conflictFiles,
+								true,
+							);
+						}
+						if (options.onMergeSuccess) {
+							try {
+								await options.onMergeSuccess({
+									...entry,
+									status: "merged",
+									resolvedTier: "auto-resolve",
+								});
+							} catch {
+								// callback failures must not fail the merge
+							}
+						}
+						return {
+							entry: { ...entry, status: "merged", resolvedTier: "auto-resolve" },
+							success: true,
+							tier: "auto-resolve",
+							conflictFiles,
+							errorMessage: null,
+							warnings,
+						};
+					}
+					conflictFiles = autoResult.remainingConflicts;
+				} // If skipped, fall through to next tier
+
+				// Tier 3: AI-resolve
+				if (options.aiResolveEnabled && !history.skipTiers.includes("ai-resolve")) {
+					lastTier = "ai-resolve";
+					const aiResult = await tryAiResolve(
 						conflictFiles,
-						errorMessage: null,
-					};
+						repoRoot,
+						history.pastResolutions,
+						options.config,
+					);
+					if (aiResult.success) {
+						if (options.mulchClient) {
+							recordConflictPattern(options.mulchClient, entry, "ai-resolve", conflictFiles, true);
+						}
+						if (options.onMergeSuccess) {
+							try {
+								await options.onMergeSuccess({
+									...entry,
+									status: "merged",
+									resolvedTier: "ai-resolve",
+								});
+							} catch {
+								// callback failures must not fail the merge
+							}
+						}
+						return {
+							entry: { ...entry, status: "merged", resolvedTier: "ai-resolve" },
+							success: true,
+							tier: "ai-resolve",
+							conflictFiles,
+							errorMessage: null,
+							warnings,
+						};
+					}
+					conflictFiles = aiResult.remainingConflicts;
 				}
-				conflictFiles = aiResult.remainingConflicts;
-			}
 
-			// Tier 4: Re-imagine
-			if (options.reimagineEnabled && !history.skipTiers.includes("reimagine")) {
-				lastTier = "reimagine";
-				const reimagineResult = await tryReimagine(
-					entry,
-					canonicalBranch,
-					repoRoot,
-					options.config,
-				);
-				if (reimagineResult.success) {
-					if (options.mulchClient) {
-						recordConflictPattern(options.mulchClient, entry, "reimagine", conflictFiles, true);
+				// Tier 4: Re-imagine
+				if (options.reimagineEnabled && !history.skipTiers.includes("reimagine")) {
+					lastTier = "reimagine";
+					const reimagineResult = await tryReimagine(
+						entry,
+						canonicalBranch,
+						repoRoot,
+						options.config,
+					);
+					if (reimagineResult.success) {
+						if (options.mulchClient) {
+							recordConflictPattern(options.mulchClient, entry, "reimagine", conflictFiles, true);
+						}
+						if (options.onMergeSuccess) {
+							try {
+								await options.onMergeSuccess({
+									...entry,
+									status: "merged",
+									resolvedTier: "reimagine",
+								});
+							} catch {
+								// callback failures must not fail the merge
+							}
+						}
+						return {
+							entry: { ...entry, status: "merged", resolvedTier: "reimagine" },
+							success: true,
+							tier: "reimagine",
+							conflictFiles: [],
+							errorMessage: null,
+							warnings,
+						};
 					}
-					return {
-						entry: { ...entry, status: "merged", resolvedTier: "reimagine" },
-						success: true,
-						tier: "reimagine",
-						conflictFiles: [],
-						errorMessage: null,
-					};
 				}
-			}
 
-			// All enabled tiers failed — abort any in-progress merge
-			try {
-				await runGit(repoRoot, ["merge", "--abort"]);
-			} catch {
-				// merge --abort may fail if there's no merge in progress (e.g., after reimagine)
-			}
+				// All enabled tiers failed — abort any in-progress merge
+				try {
+					await runGit(repoRoot, ["merge", "--abort"]);
+				} catch {
+					// merge --abort may fail if there's no merge in progress (e.g., after reimagine)
+				}
 
-			if (options.mulchClient) {
-				recordConflictPattern(options.mulchClient, entry, lastTier, conflictFiles, false);
-			}
+				if (options.mulchClient) {
+					recordConflictPattern(options.mulchClient, entry, lastTier, conflictFiles, false);
+				}
 
-			return {
-				entry: { ...entry, status: "failed", resolvedTier: null },
-				success: false,
-				tier: lastTier,
-				conflictFiles,
-				errorMessage: `All enabled resolution tiers failed (last attempted: ${lastTier})`,
-			};
+				return {
+					entry: { ...entry, status: "failed", resolvedTier: null },
+					success: false,
+					tier: lastTier,
+					conflictFiles,
+					errorMessage: `All enabled resolution tiers failed (last attempted: ${lastTier})`,
+					warnings,
+				};
+			} finally {
+				if (didStash) {
+					await runGit(repoRoot, ["stash", "pop"]);
+				}
+			}
 		},
 	};
 }

package/src/runtimes/claude.test.ts

@@ -220,14 +220,16 @@ describe("ClaudeRuntime", () => {
 			expect(state).toEqual({ phase: "ready" });
 		});
 
-		test("returns ready for prompt indicator + shift+tab", () => {
+		test("returns loading for prompt indicator + shift+tab (no bypass permissions)", () => {
+			// shift+tab appears in ALL Claude Code sessions — it must NOT trigger ready
 			const state = runtime.detectReady("Claude Code\n\u276f\nshift+tab to chat");
-			expect(state).toEqual({ phase: "ready" });
+			expect(state).toEqual({ phase: "loading" });
 		});
 
-		test('returns ready for Try " + shift+tab', () => {
+		test('returns loading for Try " + shift+tab (no bypass permissions)', () => {
+			// False-positive scenario: shift+tab alone is not a reliable readiness signal
 			const state = runtime.detectReady('Try "help"\nshift+tab');
-			expect(state).toEqual({ phase: "ready" });
+			expect(state).toEqual({ phase: "loading" });
 		});
 
 		test("returns dialog for trust dialog", () => {
@@ -235,6 +237,20 @@ describe("ClaudeRuntime", () => {
 			expect(state).toEqual({ phase: "dialog", action: "Enter" });
 		});
 
+		test("returns dialog for bypass permissions confirmation", () => {
+			const state = runtime.detectReady(
+				"WARNING: Claude Code running in Bypass Permissions mode\n❯ 1. No, exit\n2. Yes, I accept",
+			);
+			expect(state).toEqual({ phase: "dialog", action: "type:2" });
+		});
+
+		test("bypass permissions confirmation takes precedence over ready indicators", () => {
+			const state = runtime.detectReady(
+				"WARNING: Claude Code running in Bypass Permissions mode\n❯ 1. No, exit\n2. Yes, I accept\nbypass permissions",
+			);
+			expect(state).toEqual({ phase: "dialog", action: "type:2" });
+		});
+
 		test("trust dialog takes precedence over ready indicators", () => {
 			const state = runtime.detectReady("trust this folder\n\u276f\nbypass permissions");
 			expect(state).toEqual({ phase: "dialog", action: "Enter" });
@@ -577,9 +593,10 @@ describe("ClaudeRuntime integration: detectReady matches pre-refactor tmux behav
 		expect(state.phase).toBe("ready");
 	});
 
-	test("ready: 'Try \"help\"' + 'shift+tab'", () => {
+	test("loading: 'Try \"help\"' + 'shift+tab' (no bypass permissions — false-positive fix)", () => {
+		// shift+tab appears in all Claude Code sessions, must not trigger ready without bypass permissions
 		const state = runtime.detectReady('Try "help"\nshift+tab');
-		expect(state.phase).toBe("ready");
+		expect(state.phase).toBe("loading");
 	});
 
 	test("not ready: only prompt (no status bar)", () => {
@@ -597,6 +614,14 @@ describe("ClaudeRuntime integration: detectReady matches pre-refactor tmux behav
 		expect(state.phase).toBe("dialog");
 		expect((state as { phase: "dialog"; action: string }).action).toBe("Enter");
 	});
+
+	test("dialog: bypass permissions confirmation", () => {
+		const state = runtime.detectReady(
+			"WARNING: Claude Code running in Bypass Permissions mode\n❯ 1. No, exit\n2. Yes, I accept",
+		);
+		expect(state.phase).toBe("dialog");
+		expect((state as { phase: "dialog"; action: string }).action).toBe("type:2");
+	});
 });
 
 describe("ClaudeRuntime integration: buildEnv matches pre-refactor env injection", () => {
@@ -652,6 +677,6 @@ describe("ClaudeRuntime integration: registry resolves 'claude' as default", ()
 	test("getRuntime rejects unknown runtimes", async () => {
 		const { getRuntime } = await import("./registry.ts");
 		expect(() => getRuntime("aider")).toThrow('Unknown runtime: "aider"');
-		expect(() => getRuntime("cursor")).toThrow('Unknown runtime: "cursor"');
+		expect(() => getRuntime("nonexistent")).toThrow('Unknown runtime: "nonexistent"');
 	});
 });

package/src/runtimes/claude.ts

@@ -31,6 +31,9 @@ export class ClaudeRuntime implements AgentRuntime {
 	/** Unique identifier for this runtime. */
 	readonly id = "claude";
 
+	/** Stability level. Claude Code is the primary runtime. */
+	readonly stability = "stable" as const;
+
 	/** Relative path to the instruction file within a worktree. */
 	readonly instructionPath = ".claude/CLAUDE.md";
 
@@ -136,14 +139,25 @@ export class ClaudeRuntime implements AgentRuntime {
 	 *
 	 * Detection phases:
 	 * - Trust dialog: "trust this folder" detected → `{ phase: "dialog", action: "Enter" }`
-	 * - Ready: prompt indicator (❯ or 'Try "') AND status bar ("bypass permissions"
-	 *   or "shift+tab") both present → `{ phase: "ready" }`
+	 * - Ready: prompt indicator (❯ or 'Try "') AND status bar ("bypass permissions")
+	 *   both present → `{ phase: "ready" }`
 	 * - Otherwise → `{ phase: "loading" }`
 	 *
 	 * @param paneContent - Captured tmux pane content to analyze
 	 * @returns Current readiness phase
 	 */
 	detectReady(paneContent: string): ReadyState {
+		// Claude Code v2.1.71+ shows a dedicated bypass confirmation screen.
+		// It already contains both a prompt marker and the phrase "bypass permissions",
+		// so it must be detected before the normal ready heuristics.
+		if (
+			paneContent.includes("WARNING: Claude Code running in Bypass Permissions mode") &&
+			paneContent.includes("1. No, exit") &&
+			paneContent.includes("2. Yes, I accept")
+		) {
+			return { phase: "dialog", action: "type:2" };
+		}
+
 		// Trust dialog takes precedence — it replaces the normal TUI temporarily.
 		// The caller should send the action key to dismiss it.
 		if (paneContent.includes("trust this folder")) {
@@ -155,8 +169,9 @@ export class ClaudeRuntime implements AgentRuntime {
 		const hasPrompt = paneContent.includes("\u276f") || paneContent.includes('Try "');
 
 		// Phase 2: status bar text confirms full TUI render.
-		const hasStatusBar =
-			paneContent.includes("bypass permissions") || paneContent.includes("shift+tab");
+		// Only match 'bypass permissions' — 'shift+tab' appears in ALL Claude Code sessions
+		// regardless of permission mode and would cause false-positive ready detection.
+		const hasStatusBar = paneContent.includes("bypass permissions");
 
 		if (hasPrompt && hasStatusBar) {
 			return { phase: "ready" };

package/src/runtimes/codex.test.ts

@@ -151,6 +151,19 @@ describe("CodexRuntime", () => {
 			expect(cmd).not.toContain("This inline content should be ignored");
 		});
 
+		test("sharedWritableDirs are exposed with --add-dir", () => {
+			const opts: SpawnOpts = {
+				model: "gpt-5-codex",
+				permissionMode: "bypass",
+				cwd: "/tmp/worktree",
+				sharedWritableDirs: ["/project/.overstory", "/project/.git"],
+				env: {},
+			};
+			const cmd = runtime.buildSpawnCommand(opts);
+			expect(cmd).toContain("--add-dir '/project/.overstory'");
+			expect(cmd).toContain("--add-dir '/project/.git'");
+		});
+
 		test("without appendSystemPrompt uses default AGENTS.md prompt", () => {
 			const opts: SpawnOpts = {
 				model: "gpt-5-codex",