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";
@@ -459,10 +459,25 @@ 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) => {
+						const lowerF = f.toLowerCase();
+					// Filter only .ralphy/progress.txt (exact match) - other files inside .ralphy/ are kept
+					const normalizedF = lowerF.replace(/\\/g, "/");
+					if (normalizedF === `${RALPHY_DIR}/${PROGRESS_FILE}`.toLowerCase()) {
+							logDebug(`Agent ${agentNum}: Filtered infrastructure file: ${f}`);
+							return false;
+						}
+						// Skip invalid Windows paths
+						if (basename(f).toLowerCase() === "nul" || f.trim() === "") {
+							logDebug(`Agent ${agentNum}: Filtered invalid/NUL file path: ${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.ts

@@ -14,6 +14,30 @@ import {
 import { dirname, join, sep } from "node:path";
 import { logDebug } from "../ui/logger.ts";
 
+/**
+ * Simple glob matcher to avoid adding heavy dependencies.
+ * Supports: "*.log" (suffix), "prefix*" (prefix), "test.*.js" (middle), "node_modules" (exact), "dir/**" (tree)
+ */
+function matchesPattern(filename: string, pattern: string): boolean {
+	if (pattern === filename) return true;
+	if (pattern.endsWith("/**") && filename.startsWith(pattern.slice(0, -3))) return true;
+	if (pattern.startsWith("*") && !pattern.includes("*", 1)) return filename.endsWith(pattern.slice(1));
+	if (pattern.endsWith("*") && !pattern.slice(0, -1).includes("*")) return filename.startsWith(pattern.slice(0, -1));
+	// Handle middle wildcards like "test.*.js"
+	if (pattern.includes("*")) {
+		const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, ".*");
+		return new RegExp(`^${escaped}$`).test(filename);
+	}
+	return false;
+}
+
+/**
+ * Check if a file should be ignored based on a list of patterns.
+ */
+function isIgnored(item: string, patterns: string[]): boolean {
+	return patterns.some((p) => matchesPattern(item, p));
+}
+
 /**
  * Default directories to symlink (read-only dependencies).
  * These are never modified by agents, so sharing them saves disk space.
@@ -69,6 +93,17 @@ export const DEFAULT_COPY_PATTERNS = [
 	"pyproject.toml",
 ];
 
+/**
+ * Directories/files that should ALWAYS be ignored (neither copied nor symlinked).
+ */
+export const DEFAULT_IGNORED = [
+	".ralphy-sandboxes",
+	".ralphy-worktrees",
+	"nul",
+	"*.log",
+	"*.sqlite",
+];
+
 export interface SandboxOptions {
 	/** Original working directory */
 	originalDir: string;
@@ -119,8 +154,8 @@ export async function createSandbox(options: SandboxOptions): Promise<SandboxRes
 	mkdirSync(sandboxDir, { recursive: true });
 
 	try {
-		// Get all items in the original directory
-		const items = readdirSync(originalDir);
+		// Get all items in the original directory, filtering out ignored items
+		const items = readdirSync(originalDir).filter((item) => !isIgnored(item, DEFAULT_IGNORED));
 
 		// Track which items we've handled
 		const handled = new Set<string>();
@@ -153,7 +188,7 @@ export async function createSandbox(options: SandboxOptions): Promise<SandboxRes
 			if (handled.has(item)) continue;
 
 			const originalPath = join(originalDir, item);
-			const sandboxPath = join(sandboxDir, item);
+			const sandboxPathItem = join(sandboxDir, item);
 
 			// Skip if it's a symlink pointing outside (like node_modules might be)
 			try {
@@ -164,20 +199,28 @@ export async function createSandbox(options: SandboxOptions): Promise<SandboxRes
 					const target = readlinkSync(originalPath);
 					const resolvedTarget = join(dirname(originalPath), target);
 					if (existsSync(resolvedTarget)) {
-						symlinkSync(target, sandboxPath);
+						symlinkSync(target, sandboxPathItem);
 						symlinksCreated++;
 					} else {
 						logDebug(`Agent ${agentNum}: Skipping broken symlink ${item} -> ${target}`);
 					}
 				} else if (stat.isDirectory()) {
-					// Copy directory recursively, preserving timestamps for change detection
-					cpSync(originalPath, sandboxPath, { recursive: true, preserveTimestamps: true });
+					// Copy directory recursively using smart copy
+					const stats = copyRecursive(
+						originalPath,
+						sandboxPathItem,
+						DEFAULT_IGNORED,
+						symlinkDirs,
+						agentNum,
+					);
+					// Count top-level directory as 1 copy (ignoring internal file count)
 					filesCopied++;
+					symlinksCreated += stats.symlinks;
 				} else if (stat.isFile()) {
 					// Copy file and preserve timestamps for change detection
-					copyFileSync(originalPath, sandboxPath);
+					copyFileSync(originalPath, sandboxPathItem);
 					try {
-						utimesSync(sandboxPath, stat.atime, stat.mtime);
+						utimesSync(sandboxPathItem, stat.atime, stat.mtime);
 					} catch (utimeErr) {
 						logDebug(`Agent ${agentNum}: Failed to preserve timestamps for ${item}: ${utimeErr}`);
 					}
@@ -336,3 +379,92 @@ export function getSandboxBase(workDir: string): string {
 	}
 	return sandboxBase;
 }
+
+/**
+ * Recursively copy a directory:
+ * - Skips directories in 'ignoreNames'
+ * - Creates symlinks for directories in 'symlinkNames' (instead of recursing)
+ * - Copies everything else
+ */
+function copyRecursive(
+	src: string,
+	dest: string,
+	ignoreNames: string[],
+	symlinkNames: string[],
+	agentNum: number,
+): { files: number; symlinks: number } {
+	let files = 0;
+	let symlinks = 0;
+
+	if (!existsSync(src)) return { files, symlinks };
+
+	if (!existsSync(dest)) {
+		mkdirSync(dest, { recursive: true });
+	}
+
+	const items = readdirSync(src);
+	for (const item of items) {
+		// Skip ignored directories (e.g. .ralphy-sandboxes, *.log)
+		if (isIgnored(item, ignoreNames)) {
+			continue;
+		}
+
+		const srcPath = join(src, item);
+		const destPath = join(dest, item);
+
+		try {
+			const stat = lstatSync(srcPath);
+
+			if (stat.isDirectory()) {
+				// Symlink read-only dependency dirs (node_modules, vendor, etc.) even when nested.
+				// This is intentional for performance - agents don't modify dependencies, only source files.
+				// Sharing these across sandboxes avoids duplicating GBs of packages per agent.
+				if (symlinkNames.includes(item)) {
+					try {
+						// Create a junction/symlink to the SOURCE directory
+						symlinkSync(srcPath, destPath, "junction");
+						logDebug(`Agent ${agentNum}: Symlinked nested dir ${item}`);
+						symlinks++;
+					} catch (symlinkErr) {
+						// Fallback: if symlink fails, try to copy responsibly
+						logDebug(
+							`Agent ${agentNum}: Failed to symlink nested ${item}, falling back to copy: ${symlinkErr}`,
+						);
+						const subStats = copyRecursive(
+							srcPath,
+							destPath,
+							ignoreNames,
+							symlinkNames,
+							agentNum,
+						);
+						files += subStats.files;
+						symlinks += subStats.symlinks;
+					}
+				} else {
+					// Normal directory: recurse
+					const subStats = copyRecursive(
+						srcPath,
+						destPath,
+						ignoreNames,
+						symlinkNames,
+						agentNum,
+					);
+					files += subStats.files;
+					symlinks += subStats.symlinks;
+				}
+			} else if (stat.isFile()) {
+				copyFileSync(srcPath, destPath);
+				files++;
+				try {
+					utimesSync(destPath, stat.atime, stat.mtime);
+				} catch {
+					// Ignore timestamp errors
+				}
+			}
+		} catch (err) {
+			logDebug(`Agent ${agentNum}: Failed to copy ${item} in recursive copy: ${err}`);
+		}
+	}
+
+	return { files, symlinks };
+}