fix: prevent merge conflicts and improve parallel agent isolation

cli/src/execution/parallel.ts

@@ -1,5 +1,5 @@
 import { copyFileSync, cpSync, existsSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import simpleGit from "simple-git";
 import { PROGRESS_FILE, RALPHY_DIR } from "../config/loader.ts";
 import { logTaskProgress } from "../config/writer.ts";
@@ -27,7 +27,15 @@ import { clearDeferredTask, recordDeferredTask } from "./deferred.ts";
 import { buildParallelPrompt } from "./prompt.ts";
 import { isRetryableError, withRetry } from "./retry.ts";
 import { commitSandboxChanges } from "./sandbox-git.ts";
-import { cleanupSandbox, createSandbox, getModifiedFiles, getSandboxBase } from "./sandbox.ts";
+import {
+	cleanupSandbox,
+	createSandbox,
+	DEFAULT_IGNORED,
+	getModifiedFiles,
+	getSandboxBase,
+	isIgnored,
+	matchesPattern,
+} from "./sandbox.ts";
 import type { ExecutionOptions, ExecutionResult } from "./sequential.ts";
 
 interface ParallelAgentResult {
@@ -459,10 +467,40 @@ export async function runParallel(
 			if (!failureReason && aiResult?.success && agentUsedSandbox && worktreeDir) {
 				try {
 					const modifiedFiles = await getModifiedFiles(worktreeDir, workDir);
-					if (modifiedFiles.length > 0) {
+					const filteredFiles = modifiedFiles.filter((f) => {
+
+						if (f.trim() === "") {
+							return false;
+						}
+
+						const normalized = f.replace(/\\/g, "/");
+
+						// Check against all default ignore patterns
+						for (const pattern of DEFAULT_IGNORED) {
+							if (pattern.endsWith("/")) {
+								const dir = pattern.slice(0, -1);
+								// Check for exact directory match or if path starts with directory/
+								if (normalized === dir || normalized.startsWith(pattern)) {
+									logDebug(`Agent ${agentNum}: Filtered infrastructure file: ${f}`);
+									return false;
+								}
+							} else {
+								// File ignores: check basename
+								// e.g. "nul" matches "src/foo/nul"
+								const baseName = normalized.split("/").pop() || "";
+								if (matchesPattern(baseName, pattern, false)) {
+									logDebug(`Agent ${agentNum}: Filtered ignored file: ${f}`);
+									return false;
+								}
+							}
+						}
+
+						return true;
+					});
+					if (filteredFiles.length > 0) {
 						const commitResult = await commitSandboxChanges(
 							workDir,
-							modifiedFiles,
+							filteredFiles,
 							worktreeDir,
 							task.title,
 							agentNum,

cli/src/execution/prompt.ts

@@ -181,8 +181,6 @@ export function buildParallelPrompt(options: ParallelPromptOptions): string {
 		step++;
 	}
 
-	instructions.push(`${step}. Update ${progressFile} with what you did`);
-	step++;
 	if (allowCommit) {
 		instructions.push(`${step}. Commit your changes with a descriptive message`);
 	} else {

cli/src/execution/sandbox-git.ts

@@ -104,8 +104,21 @@ export async function commitSandboxChanges(
 				}
 			}
 
-			// Stage all modified files
-			await git.add(modifiedFiles);
+			// Filter out files ignored by .gitignore to prevent "path is ignored" errors
+			const ignored = (await git.checkIgnore(modifiedFiles)) || [];
+			const filesToAdd = modifiedFiles.filter((f) => !ignored.includes(f));
+
+			if (filesToAdd.length === 0) {
+				logDebug(`Agent ${agentNum}: No files to add (all were ignored)`);
+				return {
+					success: true,
+					branchName,
+					filesCommitted: 0,
+				};
+			}
+
+			// Stage modified files
+			await git.add(filesToAdd);
 
 			// Commit
 			const commitMessage = `feat: ${taskName}\n\nAutomated commit by Ralphy agent ${agentNum}`;

cli/src/execution/sandbox.test.ts

@@ -0,0 +1,130 @@
+import { describe, expect, it } from "bun:test";
+import { matchesPattern, isIgnored } from "./sandbox.ts";
+
+describe("matchesPattern", () => {
+	describe("directory match (pattern/)", () => {
+		it("should match directory when isDirectory is true or undefined", () => {
+			expect(matchesPattern("node_modules", "node_modules/")).toBe(true);
+			expect(matchesPattern("node_modules", "node_modules/", true)).toBe(true);
+			expect(matchesPattern(".ralphy", ".ralphy/", true)).toBe(true);
+		});
+
+		it("should NOT match file when isDirectory is false", () => {
+			expect(matchesPattern("node_modules", "node_modules/", false)).toBe(false);
+			expect(matchesPattern(".ralphy", ".ralphy/", false)).toBe(false);
+		});
+	});
+
+	describe("exact match", () => {
+		it("should match exact filenames", () => {
+			expect(matchesPattern("node_modules", "node_modules")).toBe(true);
+			expect(matchesPattern(".ralphy", ".ralphy")).toBe(true);
+		});
+
+		it("should not match different filenames", () => {
+			expect(matchesPattern("node_modules", "vendor")).toBe(false);
+		});
+	});
+
+	describe("suffix match (*.ext)", () => {
+		it("should match files ending with extension", () => {
+			expect(matchesPattern("debug.log", "*.log")).toBe(true);
+			expect(matchesPattern("error.log", "*.log")).toBe(true);
+			expect(matchesPattern("test.sqlite", "*.sqlite")).toBe(true);
+		});
+
+		it("should NOT match when dot is treated as regex wildcard", () => {
+			// This is the key test - "*.log" should NOT match "testXlog"
+			// because we use string comparison, not regex
+			expect(matchesPattern("testXlog", "*.log")).toBe(false);
+			expect(matchesPattern("test-log", "*.log")).toBe(false);
+		});
+
+		it("should not match files without the extension", () => {
+			expect(matchesPattern("logfile", "*.log")).toBe(false);
+			expect(matchesPattern("log", "*.log")).toBe(false);
+		});
+	});
+
+	describe("prefix match (prefix*)", () => {
+		it("should match files starting with prefix", () => {
+			expect(matchesPattern("test123", "test*")).toBe(true);
+			expect(matchesPattern("test.js", "test*")).toBe(true);
+		});
+
+		it("should NOT match when dot is treated as regex wildcard", () => {
+			// "test.*" as prefix should use string comparison
+			expect(matchesPattern("testXjs", "test.")).toBe(false);
+		});
+
+		it("should not match files without the prefix", () => {
+			expect(matchesPattern("mytest", "test*")).toBe(false);
+		});
+	});
+
+	describe("tree match (dir/**)", () => {
+		it("should match all files under directory", () => {
+			expect(matchesPattern("src/foo.js", "src/**")).toBe(true);
+			expect(matchesPattern("src/nested/bar.ts", "src/**")).toBe(true);
+		});
+
+		it("should not match files outside directory", () => {
+			expect(matchesPattern("lib/foo.js", "src/**")).toBe(false);
+		});
+	});
+
+	describe("middle wildcard (test.*.js)", () => {
+		it("should match with proper regex escaping", () => {
+			expect(matchesPattern("test.foo.js", "test.*.js")).toBe(true);
+			expect(matchesPattern("test.bar.js", "test.*.js")).toBe(true);
+		});
+
+		it("should escape dots properly - not match when dot is wildcard", () => {
+			// "test.*.js" should NOT match "testXfooXjs" because dots are escaped
+			expect(matchesPattern("testXfooXjs", "test.*.js")).toBe(false);
+		});
+
+		it("should escape other metacharacters", () => {
+			// Pattern with special chars should work correctly
+			expect(matchesPattern("file[1].txt", "file[*].txt")).toBe(true);
+			expect(matchesPattern("file(test).log", "file(*).log")).toBe(true);
+		});
+	});
+});
+
+describe("isIgnored", () => {
+	it("should return true if any pattern matches", () => {
+		expect(isIgnored(".ralphy", [".ralphy-sandboxes", ".ralphy"])).toBe(true);
+		expect(isIgnored("debug.log", ["*.log", "*.sqlite"])).toBe(true);
+	});
+
+	it("should return false if no pattern matches", () => {
+		expect(isIgnored("src", [".ralphy", "node_modules"])).toBe(false);
+	});
+
+	it("should handle DEFAULT_IGNORED patterns correctly", () => {
+		const DEFAULT_IGNORED = [
+			".ralphy-sandboxes/",
+			".ralphy-worktrees/",
+			".ralphy/",
+			"nul",
+		];
+
+		// Matches because strict=undefined allows directory patterns to match
+		// This simulates typical lenient behavior if type isn't known, or just directory check
+		expect(isIgnored(".ralphy", DEFAULT_IGNORED)).toBe(true);
+
+		// Should explicitly match if isDirectory=true
+		expect(isIgnored(".ralphy", DEFAULT_IGNORED, true)).toBe(true);
+
+		// Should NOT match if isDirectory=false
+		expect(isIgnored(".ralphy", DEFAULT_IGNORED, false)).toBe(false);
+
+		// Removed *.log from ignore list, so these should return false
+		expect(isIgnored("debug.log", DEFAULT_IGNORED)).toBe(false);
+
+		expect(isIgnored("nul", DEFAULT_IGNORED)).toBe(true);
+		expect(isIgnored("src", DEFAULT_IGNORED)).toBe(false);
+		expect(isIgnored("package.json", DEFAULT_IGNORED)).toBe(false);
+	});
+});