Keep git worktree runs isolated from dirty repos

Author: egavrin

packages/local-runner/src/index.test.ts

@@ -356,7 +356,7 @@ test("workspace manager reopens an existing git branch without resetting it", as
   await manager.cleanup(reopened.workspacePath);
 });
 
-test("workspace manager overlays uncommitted working tree files into git workspaces", async () => {
+test("workspace manager keeps git workspaces clean when the source repo is dirty", async () => {
   const repo = await createRealGitRepo();
   await writeFile(join(repo, "vitest.config.ts"), "export default {};\n");
   const manager = new FileSystemWorkspaceManager();
@@ -368,10 +368,34 @@ test("workspace manager overlays uncommitted working tree files into git workspa
     baseRef: "main",
   });
 
-  assert.equal(await readFile(join(workspacePath, "vitest.config.ts"), "utf-8"), "export default {};\n");
+  assert.equal(await fileExists(join(workspacePath, "vitest.config.ts")), false);
   await manager.cleanup(workspacePath);
 });
 
+test("local runner emits a warning when it ignores dirty source changes for git worktrees", async () => {
+  const repo = await createRealGitRepo();
+  await writeFile(join(repo, "vitest.config.ts"), "export default {};\n");
+  const runner = new LocalRunner({
+    adapters: [new OrderedFakeAdapter()],
+  });
+  const request = createRequest(repo, "task-dirty-git-worktree");
+  request.workspace.isolation = "git-worktree";
+  request.workspace.baseRef = "main";
+
+  const { runId } = await runner.startTask(request);
+  await runner.awaitResult(runId);
+  const metadata = await runner.inspect(runId);
+  const events = await readEventLog(metadata.eventLogPath);
+
+  assert.equal(
+    events.some((event) =>
+      event.type === "log" &&
+      event.message.includes("ignored local uncommitted source-repo changes"),
+    ),
+    true,
+  );
+});
+
 test("local runner records artifacts and result metadata", async () => {
   const repo = await createRepo();
   const runner = new LocalRunner({

packages/local-runner/src/index.ts

@@ -105,30 +105,25 @@ async function copyRepoContents(sourceRepoPath: string, workspacePath: string):
   }
 }
 
-async function overlayGitWorkingTreeChanges(sourceRepoPath: string, workspacePath: string): Promise<void> {
-  const rawStatus = await execFileStdout("git", ["status", "--porcelain"], sourceRepoPath);
-  const entries = rawStatus
-    .split("\n")
-    .map((line) => line.trimEnd())
-    .filter(Boolean);
-
-  for (const entry of entries) {
-    const status = entry.slice(0, 2);
-    const rawPath = entry.slice(3);
-    const path = rawPath.includes(" -> ") ? rawPath.split(" -> ").at(-1)! : rawPath;
-    if (!path || path.startsWith(".git") || path.startsWith(".devagent-runner") || path.startsWith("node_modules")) {
-      continue;
-    }
-
-    const sourcePath = join(sourceRepoPath, path);
-    const workspacePathTarget = join(workspacePath, path);
-    if (status.includes("D")) {
-      await rm(workspacePathTarget, { recursive: true, force: true });
-      continue;
-    }
-
-    await mkdir(dirname(workspacePathTarget), { recursive: true });
-    await cp(sourcePath, workspacePathTarget, { recursive: true });
+async function hasDirtyWorkingTree(sourceRepoPath: string): Promise<boolean> {
+  try {
+    const rawStatus = await execFileStdout("git", ["status", "--porcelain"], sourceRepoPath);
+    return rawStatus
+      .split("\n")
+      .map((line) => line.trimEnd())
+      .some((line) => {
+        if (!line) return false;
+        const rawPath = line.slice(3);
+        const path = rawPath.includes(" -> ") ? rawPath.split(" -> ").at(-1)! : rawPath;
+        return Boolean(
+          path &&
+          !path.startsWith(".git") &&
+          !path.startsWith(".devagent-runner") &&
+          !path.startsWith("node_modules"),
+        );
+      });
+  } catch {
+    return false;
   }
 }
 
@@ -248,7 +243,6 @@ export class FileSystemWorkspaceManager implements WorkspaceManager {
           ? ["worktree", "add", workspacePath, spec.workBranch]
           : ["worktree", "add", "-B", spec.workBranch, workspacePath, spec.baseRef ?? "HEAD"];
         await execFileAsync("git", worktreeArgs, spec.sourceRepoPath);
-        await overlayGitWorkingTreeChanges(spec.sourceRepoPath, workspacePath);
         await linkSharedDependencies(spec.sourceRepoPath, workspacePath);
         return { workspacePath };
       } catch {
@@ -353,6 +347,20 @@ export class LocalRunner implements RunnerClient {
       }
     };
 
+    if (
+      request.workspace.isolation === "git-worktree" &&
+      await hasDirtyWorkingTree(request.workspace.sourceRepoPath)
+    ) {
+      onEvent({
+        protocolVersion: PROTOCOL_VERSION,
+        type: "log",
+        at: new Date().toISOString(),
+        taskId: request.taskId,
+        stream: "stdout",
+        message: "Runner ignored local uncommitted source-repo changes and used a clean isolated workspace.",
+      });
+    }
+
     const handle = await adapter.launch(request, workspacePath, artifactDir, onEvent);
     const metadata: RunMetadata = {
       runId: handle.id,