@os-eco/overstory-cli 0.8.6 → 0.8.7

package/src/commands/sling.ts

@@ -42,8 +42,11 @@ import { createWorktree, rollbackWorktree } from "../worktree/manager.ts";
 import { spawnHeadlessAgent } from "../worktree/process.ts";
 import {
 	capturePaneContent,
+	checkSessionState,
 	createSession,
 	ensureTmuxAvailable,
+	isSessionAlive,
+	killSession,
 	sendKeys,
 	waitForTuiReady,
 } from "../worktree/tmux.ts";
@@ -274,6 +277,27 @@ export function shouldShowScoutWarning(
 	return !parentHasScouts(sessions, parentAgent);
 }
 
+/**
+ * Resolve which canonical repo directories should be writable to an
+ * interactive agent runtime in addition to its worktree sandbox.
+ *
+ * All interactive agents need `.overstory` so they can access shared mail,
+ * metrics, and session state. Only `lead` agents need canonical `.git`
+ * because they can spawn child worktrees from inside the runtime.
+ *
+ * @param projectRoot - Absolute path to the canonical repository root
+ * @param capability - Capability being launched
+ */
+export function getSharedWritableDirs(projectRoot: string, capability: string): string[] {
+	const sharedWritableDirs = [join(projectRoot, ".overstory")];
+
+	if (capability === "lead") {
+		sharedWritableDirs.push(join(projectRoot, ".git"));
+	}
+
+	return sharedWritableDirs;
+}
+
 /**
  * Check if any active agent is already working on the given task ID.
  * Returns the agent name if locked, or null if the task is free.
@@ -569,47 +593,63 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 	// 4. Resolve or create run_id for this spawn
 	const overstoryDir = join(config.project.root, ".overstory");
 	const currentRunPath = join(overstoryDir, "current-run.txt");
-	let runId: string;
-
-	const currentRunFile = Bun.file(currentRunPath);
-	if (await currentRunFile.exists()) {
-		runId = (await currentRunFile.text()).trim();
-	} else {
-		runId = `run-${new Date().toISOString().replace(/[:.]/g, "-")}`;
-		const runStore = createRunStore(join(overstoryDir, "sessions.db"));
-		try {
-			runStore.createRun({
-				id: runId,
-				startedAt: new Date().toISOString(),
-				coordinatorSessionId: null,
-				status: "active",
-			});
-		} finally {
-			runStore.close();
-		}
-		await Bun.write(currentRunPath, runId);
-	}
-
-	// 4b. Check per-run session limit
-	if (config.agents.maxSessionsPerRun > 0) {
-		const runCheckStore = createRunStore(join(overstoryDir, "sessions.db"));
-		try {
-			const run = runCheckStore.getRun(runId);
-			if (run && checkRunSessionLimit(config.agents.maxSessionsPerRun, run.agentCount)) {
-				throw new AgentError(
-					`Run session limit reached: ${run.agentCount}/${config.agents.maxSessionsPerRun} agents spawned in run "${runId}". ` +
-						`Increase agents.maxSessionsPerRun in config.yaml or start a new run.`,
-					{ agentName: name },
-				);
-			}
-		} finally {
-			runCheckStore.close();
-		}
-	}
 
 	// 5. Check name uniqueness and concurrency limit against active sessions
+	// (Session store opened here so we can also use it for parent run ID inheritance in step 4.)
 	const { store } = openSessionStore(overstoryDir);
 	try {
+		// 4a. Resolve run ID: inherit from parent → current-run.txt fallback → create new.
+		// Parent inheritance ensures child agents belong to the same run as their coordinator.
+		const runId = await (async (): Promise<string> => {
+			if (parentAgent) {
+				const parentSession = store.getByName(parentAgent);
+				if (parentSession?.runId) {
+					return parentSession.runId;
+				}
+			}
+
+			// Fallback: read current-run.txt (backward compat with single-coordinator setups).
+			const currentRunFile = Bun.file(currentRunPath);
+			if (await currentRunFile.exists()) {
+				const text = (await currentRunFile.text()).trim();
+				if (text) return text;
+			}
+
+			// Create a new run if none exists.
+			const newRunId = `run-${new Date().toISOString().replace(/[:.]/g, "-")}`;
+			const runStore = createRunStore(join(overstoryDir, "sessions.db"));
+			try {
+				runStore.createRun({
+					id: newRunId,
+					startedAt: new Date().toISOString(),
+					coordinatorSessionId: null,
+					coordinatorName: null,
+					status: "active",
+				});
+			} finally {
+				runStore.close();
+			}
+			await Bun.write(currentRunPath, newRunId);
+			return newRunId;
+		})();
+
+		// 4b. Check per-run session limit
+		if (config.agents.maxSessionsPerRun > 0) {
+			const runCheckStore = createRunStore(join(overstoryDir, "sessions.db"));
+			try {
+				const run = runCheckStore.getRun(runId);
+				if (run && checkRunSessionLimit(config.agents.maxSessionsPerRun, run.agentCount)) {
+					throw new AgentError(
+						`Run session limit reached: ${run.agentCount}/${config.agents.maxSessionsPerRun} agents spawned in run "${runId}". ` +
+							`Increase agents.maxSessionsPerRun in config.yaml or start a new run.`,
+						{ agentName: name },
+					);
+				}
+			} finally {
+				runCheckStore.close();
+			}
+		}
+
 		const activeSessions = store.getActive();
 		if (activeSessions.length >= config.agents.maxConcurrent) {
 			throw new AgentError(
@@ -858,6 +898,7 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 					...runtime.buildEnv(resolvedModel),
 					OVERSTORY_AGENT_NAME: name,
 					OVERSTORY_WORKTREE_PATH: worktreePath,
+					OVERSTORY_TASK_ID: taskId,
 				};
 				const argv = runtime.buildDirectSpawn({
 					cwd: worktreePath,
@@ -943,16 +984,19 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 					model: resolvedModel.model,
 					permissionMode: "bypass",
 					cwd: worktreePath,
+					sharedWritableDirs: getSharedWritableDirs(config.project.root, capability),
 					env: {
 						...runtime.buildEnv(resolvedModel),
 						OVERSTORY_AGENT_NAME: name,
 						OVERSTORY_WORKTREE_PATH: worktreePath,
+						OVERSTORY_TASK_ID: taskId,
 					},
 				});
 				const pid = await createSession(tmuxSessionName, worktreePath, spawnCmd, {
 					...runtime.buildEnv(resolvedModel),
 					OVERSTORY_AGENT_NAME: name,
 					OVERSTORY_WORKTREE_PATH: worktreePath,
+					OVERSTORY_TASK_ID: taskId,
 				});
 
 				// 13. Record session BEFORE sending the beacon so that hook-triggered
@@ -998,7 +1042,31 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 				// Wait for Claude Code TUI to render before sending input.
 				// Polling capture-pane is more reliable than a fixed sleep because
 				// TUI init time varies by machine load and model state.
-				await waitForTuiReady(tmuxSessionName, (content) => runtime.detectReady(content));
+				const tuiReady = await waitForTuiReady(tmuxSessionName, (content) =>
+					runtime.detectReady(content),
+				);
+				if (!tuiReady) {
+					const alive = await isSessionAlive(tmuxSessionName);
+					store.updateState(name, "completed");
+
+					if (alive) {
+						await killSession(tmuxSessionName);
+						throw new AgentError(
+							`Agent tmux session "${tmuxSessionName}" did not become ready during startup. The runtime may still be waiting on an interactive dialog or initializing too slowly.`,
+							{ agentName: name },
+						);
+					}
+
+					const sessionState = await checkSessionState(tmuxSessionName);
+					const detail =
+						sessionState === "no_server"
+							? "The tmux server is no longer running. It may have crashed or been killed externally."
+							: "The agent process may have crashed or exited immediately before the TUI became ready.";
+					throw new AgentError(
+						`Agent tmux session "${tmuxSessionName}" died during startup. ${detail}`,
+						{ agentName: name },
+					);
+				}
 				// Buffer for the input handler to attach after initial render
 				await Bun.sleep(1_000);
 

package/src/commands/supervisor.ts

@@ -185,11 +185,13 @@ async function startSupervisor(opts: {
 			env: {
 				...runtime.buildEnv(resolvedModel),
 				OVERSTORY_AGENT_NAME: opts.name,
+				OVERSTORY_TASK_ID: opts.task,
 			},
 		});
 		const pid = await createSession(tmuxSession, projectRoot, spawnCmd, {
 			...runtime.buildEnv(resolvedModel),
 			OVERSTORY_AGENT_NAME: opts.name,
+			OVERSTORY_TASK_ID: opts.task,
 		});
 
 		// Wait for Claude Code TUI to render before sending input

package/src/index.ts

@@ -49,7 +49,7 @@ import { ConfigError, OverstoryError, WorktreeError } from "./errors.ts";
 import { jsonError } from "./json.ts";
 import { brand, chalk, muted, setQuiet } from "./logging/color.ts";
 
-export const VERSION = "0.8.6";
+export const VERSION = "0.8.7";
 
 const rawArgs = process.argv.slice(2);
 

package/src/merge/resolver.test.ts

@@ -22,6 +22,7 @@ import type { MergeEntry, ParsedConflictPattern } from "../types.ts";
 import {
 	buildConflictHistory,
 	createMergeResolver,
+	hasContentfulCanonical,
 	looksLikeProse,
 	parseConflictPatterns,
 	resolveConflictsUnion,
@@ -86,6 +87,20 @@ async function setupContentConflict(dir: string, baseBranch: string): Promise<vo
 	await commitFile(dir, "src/test.ts", "main modified content\n");
 }
 
+/**
+ * Set up a conflict where the canonical (HEAD) side is empty in the conflict marker.
+ * Main deletes a shared line; feature replaces it. Git produces a conflict with an
+ * empty HEAD side, so hasContentfulCanonical returns false and auto-resolve can safely
+ * keep the incoming content.
+ */
+async function setupEmptyCanonicalConflict(dir: string, baseBranch: string): Promise<void> {
+	await commitFile(dir, "src/test.ts", "line1\nshared line\nline3\n");
+	await runGitInDir(dir, ["checkout", "-b", "feature-branch"]);
+	await commitFile(dir, "src/test.ts", "line1\nnew content\nline3\n");
+	await runGitInDir(dir, ["checkout", baseBranch]);
+	await commitFile(dir, "src/test.ts", "line1\nline3\n"); // main deletes "shared line"
+}
+
 /**
  * Create a delete/modify conflict: file is deleted on main but modified on
  * the feature branch. This produces a conflict with NO conflict markers in
@@ -431,11 +446,13 @@ describe("createMergeResolver", () => {
 	});
 
 	describe("Tier 1 fail -> Tier 2: Auto-resolve", () => {
-		test("auto-resolves conflicts keeping incoming changes with correct content", async () => {
+		test("auto-resolves conflicts when canonical side is empty (keeps incoming)", async () => {
 			const repoDir = await createTempGitRepo();
 			try {
 				const defaultBranch = await getDefaultBranch(repoDir);
-				await setupContentConflict(repoDir, defaultBranch);
+				// Use empty-canonical setup: main deletes a line, feature replaces it.
+				// The conflict marker has an empty HEAD side, so auto-resolve is safe.
+				await setupEmptyCanonicalConflict(repoDir, defaultBranch);
 
 				const entry = makeTestEntry({
 					branchName: "feature-branch",
@@ -453,11 +470,12 @@ describe("createMergeResolver", () => {
 				expect(result.tier).toBe("auto-resolve");
 				expect(result.entry.status).toBe("merged");
 				expect(result.entry.resolvedTier).toBe("auto-resolve");
+				expect(result.warnings).toEqual([]);
 
 				// The resolved file should contain the incoming (feature branch) content
 				const file = Bun.file(join(repoDir, "src/test.ts"));
 				const content = await file.text();
-				expect(content).toBe("feature content\n");
+				expect(content).toContain("new content");
 			} finally {
 				await cleanupTempDir(repoDir);
 			}
@@ -688,6 +706,7 @@ describe("createMergeResolver", () => {
 			expect(result).toHaveProperty("tier");
 			expect(result).toHaveProperty("conflictFiles");
 			expect(result).toHaveProperty("errorMessage");
+			expect(result).toHaveProperty("warnings");
 		});
 
 		test("failed result preserves original entry fields", async () => {
@@ -806,6 +825,117 @@ describe("createMergeResolver", () => {
 		});
 	});
 
+	describe("hasContentfulCanonical", () => {
+		test("returns true when canonical side has content", () => {
+			const content = [
+				"<<<<<<< HEAD\n",
+				"canonical content\n",
+				"=======\n",
+				"incoming content\n",
+				">>>>>>> feature-branch\n",
+			].join("");
+			expect(hasContentfulCanonical(content)).toBe(true);
+		});
+
+		test("returns false when canonical side is empty", () => {
+			const content = [
+				"<<<<<<< HEAD\n",
+				"=======\n",
+				"incoming content\n",
+				">>>>>>> feature-branch\n",
+			].join("");
+			expect(hasContentfulCanonical(content)).toBe(false);
+		});
+
+		test("returns false when canonical is whitespace only", () => {
+			const content = [
+				"<<<<<<< HEAD\n",
+				"   \n",
+				"\t\n",
+				"=======\n",
+				"incoming content\n",
+				">>>>>>> feature-branch\n",
+			].join("");
+			expect(hasContentfulCanonical(content)).toBe(false);
+		});
+
+		test("returns false when no conflict markers", () => {
+			expect(hasContentfulCanonical("no conflicts here\n")).toBe(false);
+			expect(hasContentfulCanonical("")).toBe(false);
+		});
+
+		test("returns true if ANY block has canonical content (multiple blocks)", () => {
+			const block1 = "<<<<<<< HEAD\n=======\nonly incoming\n>>>>>>> branch\n";
+			const block2 = "<<<<<<< HEAD\ncanonical content\n=======\nincoming\n>>>>>>> branch\n";
+			const content = `${block1}middle\n${block2}`;
+			expect(hasContentfulCanonical(content)).toBe(true);
+		});
+	});
+
+	describe("auto-resolve: content protection", () => {
+		test("auto-resolve skips files with contentful canonical, result includes warning", async () => {
+			const repoDir = await createTempGitRepo();
+			try {
+				const defaultBranch = await getDefaultBranch(repoDir);
+				// setupContentConflict: both canonical and incoming have content
+				await setupContentConflict(repoDir, defaultBranch);
+
+				const entry = makeTestEntry({
+					branchName: "feature-branch",
+					filesModified: ["src/test.ts"],
+				});
+
+				// AI and reimagine disabled — should FAIL because auto-resolve correctly refuses
+				const resolver = createMergeResolver({
+					aiResolveEnabled: false,
+					reimagineEnabled: false,
+				});
+
+				const result = await resolver.resolve(entry, defaultBranch, repoDir);
+
+				expect(result.success).toBe(false);
+				expect(result.warnings.length).toBeGreaterThan(0);
+				expect(result.warnings[0]).toContain("src/test.ts");
+			} finally {
+				await cleanupTempDir(repoDir);
+			}
+		});
+	});
+
+	describe("untracked files: no silent commit", () => {
+		test("untracked overlapping files are deleted, not committed", async () => {
+			const repoDir = await createTempGitRepo();
+			try {
+				const defaultBranch = await getDefaultBranch(repoDir);
+				await setupCleanMerge(repoDir, defaultBranch);
+
+				// Place an untracked file at the path the feature branch will bring in
+				await Bun.write(`${repoDir}/src/feature-file.ts`, "local untracked content\n");
+
+				const entry = makeTestEntry({
+					branchName: "feature-branch",
+					filesModified: ["src/feature-file.ts"],
+				});
+
+				const resolver = createMergeResolver({
+					aiResolveEnabled: false,
+					reimagineEnabled: false,
+				});
+
+				const result = await resolver.resolve(entry, defaultBranch, repoDir);
+
+				expect(result.success).toBe(true);
+				expect(result.warnings.some((w) => w.includes("src/feature-file.ts"))).toBe(true);
+
+				// Verify git log does NOT contain the "commit untracked files before merge" commit
+				const log = await runGitInDir(repoDir, ["log", "--oneline"]);
+				expect(log).not.toContain("commit untracked files before merge");
+			} finally {
+				await cleanupTempDir(repoDir);
+			}
+		});
+	});
+
 	describe("Tier 3: AI-resolve prose rejection", () => {
 		test("rejects prose output and falls through to failure", async () => {
 			const repoDir = await createTempGitRepo();
@@ -858,7 +988,8 @@ describe("createMergeResolver", () => {
 			const repoDir = await createTempGitRepo();
 			try {
 				const defaultBranch = await getDefaultBranch(repoDir);
-				await setupContentConflict(repoDir, defaultBranch);
+				// Use empty-canonical setup so auto-resolve completes successfully
+				await setupEmptyCanonicalConflict(repoDir, defaultBranch);
 
 				const entry = makeTestEntry({
 					branchName: "feature-branch",
@@ -884,7 +1015,8 @@ describe("createMergeResolver", () => {
 			const repoDir = await createTempGitRepo();
 			try {
 				const defaultBranch = await getDefaultBranch(repoDir);
-				await setupContentConflict(repoDir, defaultBranch);
+				// Use empty-canonical setup so auto-resolve completes successfully
+				await setupEmptyCanonicalConflict(repoDir, defaultBranch);
 
 				const entry = makeTestEntry({
 					branchName: "feature-branch",
@@ -1014,7 +1146,8 @@ describe("createMergeResolver", () => {
 			const repoDir = await createTempGitRepo();
 			try {
 				const defaultBranch = await getDefaultBranch(repoDir);
-				await setupContentConflict(repoDir, defaultBranch);
+				// Use empty-canonical setup so auto-resolve completes successfully
+				await setupEmptyCanonicalConflict(repoDir, defaultBranch);
 
 				const entry = makeTestEntry({
 					branchName: "feature-branch",
@@ -1709,7 +1842,8 @@ describe("createMergeResolver", () => {
 			const repoDir = await createTempGitRepo();
 			try {
 				const defaultBranch = await getDefaultBranch(repoDir);
-				await setupContentConflict(repoDir, defaultBranch);
+				// Use empty-canonical setup so auto-resolve completes successfully
+				await setupEmptyCanonicalConflict(repoDir, defaultBranch);
 
 				const entry = makeTestEntry({
 					branchName: "feature-branch",

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";
@@ -184,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".
@@ -231,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}`;
@@ -244,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);
@@ -265,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 };
 }
 
 /**
@@ -689,13 +723,15 @@ export function createMergeResolver(options: {
 				didStash = true;
 			}
 
+			const warnings: string[] = [];
 			let lastTier: ResolutionTier = "clean-merge";
 			let conflictFiles: string[] = [];
 
 			try {
-				// Commit untracked files overlapping entry.filesModified before merging.
+				// 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.
+				// 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",
@@ -707,9 +743,18 @@ export function createMergeResolver(options: {
 					.filter((f) => f.length > 0);
 				const entryFileSet = new Set(entry.filesModified);
 				const overlappingUntracked = untrackedFiles.filter((f) => entryFileSet.has(f));
-				if (overlappingUntracked.length > 0) {
-					await runGit(repoRoot, ["add", ...overlappingUntracked]);
-					await runGit(repoRoot, ["commit", "-m", "chore: commit untracked files before merge"]);
+				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 1: Clean merge
@@ -732,6 +777,7 @@ export function createMergeResolver(options: {
 						tier: "clean-merge",
 						conflictFiles: [],
 						errorMessage: null,
+						warnings,
 					};
 				}
 				conflictFiles = cleanResult.conflictFiles;
@@ -750,6 +796,9 @@ export function createMergeResolver(options: {
 				if (!history.skipTiers.includes("auto-resolve")) {
 					lastTier = "auto-resolve";
 					const autoResult = await tryAutoResolve(conflictFiles, repoRoot);
+					if (autoResult.contentDropWarnings.length > 0) {
+						warnings.push(...autoResult.contentDropWarnings);
+					}
 					if (autoResult.success) {
 						if (options.mulchClient) {
 							recordConflictPattern(
@@ -777,6 +826,7 @@ export function createMergeResolver(options: {
 							tier: "auto-resolve",
 							conflictFiles,
 							errorMessage: null,
+							warnings,
 						};
 					}
 					conflictFiles = autoResult.remainingConflicts;
@@ -812,6 +862,7 @@ export function createMergeResolver(options: {
 							tier: "ai-resolve",
 							conflictFiles,
 							errorMessage: null,
+							warnings,
 						};
 					}
 					conflictFiles = aiResult.remainingConflicts;
@@ -847,6 +898,7 @@ export function createMergeResolver(options: {
 							tier: "reimagine",
 							conflictFiles: [],
 							errorMessage: null,
+							warnings,
 						};
 					}
 				}
@@ -868,6 +920,7 @@ export function createMergeResolver(options: {
 					tier: lastTier,
 					conflictFiles,
 					errorMessage: `All enabled resolution tiers failed (last attempted: ${lastTier})`,
+					warnings,
 				};
 			} finally {
 				if (didStash) {