fix(acp): reap the agent process before a run resolves

The ACP executor spawned the Agent with the run workspace as its cwd and
called kill() without awaiting exit, so execute() resolved while the child
was still alive. On Windows a live process' cwd is an open directory handle,
so the harness-studio server test failed with EBUSY: rmdir on its temp
workspace. POSIX permits that removal, which is why only windows-latest broke.

reapAgent now awaits the child's exit with a bounded grace period and
escalates to SIGKILL so a wedged Agent cannot hang a run instead. A new
executor test asserts the process has exited and its cwd is removable once
execute() resolves; it fails against the previous kill-and-forget path.
Validated with packages/harness Vitest (168 tests), tsc --noEmit, and
harness-studio test/server.test.ts (43 tests) on macOS; the windows-latest
job is the authoritative receipt for the platform behavior.

Co-authored-by: QoderAI <qoder_ai@qoder.com>

Author: phodal

packages/harness/src/exec/acp-sdk.ts

@@ -25,6 +25,7 @@ import { redactTraceValue } from "./qoder-sdk.js";
 const ACP_SDK_MODULE = "@agentclientprotocol/sdk";
 const MAX_PROTOCOL_EVENTS = 2_000;
 const MAX_PROTOCOL_PAYLOAD_BYTES = 65_536;
+const AGENT_EXIT_GRACE_MS = 2_000;
 
 type AcpSdk = typeof import("@agentclientprotocol/sdk");
 
@@ -253,13 +254,35 @@ export class AcpSdkExecutor implements HarnessExecutor {
         },
       };
     } finally {
-      if (child !== undefined && child.exitCode === null && child.signalCode === null) {
-        child.kill();
-      }
+      await reapAgent(child);
     }
   }
 }
 
+/**
+ * Terminate the Agent and wait for its exit before the run resolves. A live
+ * child holds an open handle on its cwd, so a caller that removes the run
+ * workspace right after `execute` fails with EBUSY on Windows.
+ */
+async function reapAgent(child: ChildProcessWithoutNullStreams | undefined): Promise<void> {
+  if (child === undefined || child.exitCode !== null || child.signalCode !== null) return;
+  const exited = new Promise<void>((resolvePromise) => {
+    child.once("exit", () => resolvePromise());
+    child.once("error", () => resolvePromise());
+  });
+  child.kill();
+  await Promise.race([exited, delay(AGENT_EXIT_GRACE_MS)]);
+  if (child.exitCode !== null || child.signalCode !== null) return;
+  child.kill("SIGKILL");
+  await Promise.race([exited, delay(AGENT_EXIT_GRACE_MS)]);
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolvePromise) => {
+    setTimeout(resolvePromise, ms).unref();
+  });
+}
+
 async function requestWithAbort<T>(
   request: () => Promise<T>,
   signal: AbortSignal | undefined,

packages/harness/test/acp-sdk.test.ts

@@ -1,4 +1,7 @@
-import { dirname, resolve } from "node:path";
+import { spawn, type ChildProcess } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { describe, expect, it } from "vitest";
 import { compileHarness } from "../src/compiler/compile.js";
@@ -135,4 +138,39 @@ describe("AcpSdkExecutor", () => {
     expect(methods).toContain("$/cancel_request");
     expect(Date.now() - startedAt).toBeLessThan(5_000);
   });
+
+  it("reaps the Agent before resolving so the run workspace can be removed", async () => {
+    const { bundle } = await compileHarness(SOURCE);
+    const { revision } = resolveHarness(bundle!, "live-acp", "acp", {
+      adapter: () => ACP_ADAPTER_DESCRIPTOR,
+    });
+    const workspace = await mkdtemp(join(tmpdir(), "acp-agent-cwd-"));
+    const agents: ChildProcess[] = [];
+    const executor = new AcpSdkExecutor({
+      command: process.execPath,
+      args: [FIXTURE],
+      requestPermission: async (_requestId, request) => ({
+        outcome: { outcome: "selected", optionId: request.options[0]!.optionId },
+      }),
+      spawnAgent: ((command, args, options) => {
+        const child = spawn(command as string, args as string[], options as object);
+        agents.push(child);
+        return child;
+      }) as typeof spawn,
+    });
+
+    // The fixture Agent stays alive until its stdio closes, so a run that
+    // resolves without reaping it leaves the process holding this cwd.
+    const result = await executor.execute(revision!, bundle!, {
+      prompt: "Prove ACP works",
+      cwd: workspace,
+    });
+
+    expect(result.exitCode).toBe(0);
+    expect(agents).toHaveLength(1);
+    const agentProcess = agents[0]!;
+    expect(agentProcess.exitCode === null && agentProcess.signalCode === null).toBe(false);
+    // Windows refuses to remove a directory that is a live process' cwd.
+    await rm(workspace, { recursive: true });
+  });
 });