agent-relay-orchestrator 0.118.0 → 0.118.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.118.0",
+  "version": "0.118.1",
   "description": "Agent Relay orchestrator — manages agent lifecycle across hosts",
   "type": "module",
   "bin": {
@@ -17,7 +17,7 @@
   },
   "dependencies": {
     "agent-relay-providers": "0.104.1",
-    "agent-relay-sdk": "0.2.100",
+    "agent-relay-sdk": "0.2.101",
     "callmux": "0.23.0"
   },
   "devDependencies": {

package/src/command-poller.ts

@@ -8,14 +8,20 @@ interface CommandPollerOptions {
   relay: Pick<RelayClient, "connected" | "pollCommands">;
   control: CommandPollerControl;
   log?: (message: string) => void;
+  intervalMs?: number;
+  errorBackoffMs?: number;
 }
 
-export function createCommandPoller({ relay, control, log = console.error }: CommandPollerOptions) {
+export function createCommandPoller({ relay, control, log = console.error, intervalMs = 3_000, errorBackoffMs = 3_000 }: CommandPollerOptions) {
   let inFlight = false;
+  let stopped = true;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let lastTickErrored = false;
 
   async function tick(): Promise<boolean> {
     if (!relay.connected || inFlight) return false;
     inFlight = true;
+    lastTickErrored = false;
     try {
       const commands = await relay.pollCommands();
       if (commands.length > 0) {
@@ -27,6 +33,7 @@ export function createCommandPoller({ relay, control, log = console.error }: Com
       }
       return true;
     } catch (err) {
+      lastTickErrored = true;
       log(`[orchestrator] Poll error: ${err}`);
       return false;
     } finally {
@@ -34,8 +41,44 @@ export function createCommandPoller({ relay, control, log = console.error }: Com
     }
   }
 
+  function schedule(delayMs: number): void {
+    if (stopped) return;
+    timer = setTimeout(() => {
+      timer = undefined;
+      void runCycle();
+    }, delayMs);
+    timer.unref?.();
+  }
+
+  async function runCycle(): Promise<void> {
+    let errored = false;
+    try {
+      await tick();
+      errored = lastTickErrored;
+    } catch (err) {
+      errored = true;
+      log(`[orchestrator] Poll loop error: ${err}`);
+    } finally {
+      if (!stopped) schedule(errored ? errorBackoffMs : intervalMs);
+    }
+  }
+
+  function start(): void {
+    if (!stopped) return;
+    stopped = false;
+    schedule(0);
+  }
+
+  function stop(): void {
+    stopped = true;
+    if (timer) clearTimeout(timer);
+    timer = undefined;
+  }
+
   return {
     tick,
+    start,
+    stop,
     get inFlight() {
       return inFlight;
     },

package/src/control.ts

@@ -33,16 +33,10 @@ export function createControlHandler(
 
   async function handleSpawn(ctrl: Record<string, any>): Promise<boolean> {
     const opts = spawnOptionsFromControl(ctrl, config);
-
-    try {
-      const agent = await spawnAgent(opts, config);
-      managedAgents.push(agent);
-      console.error(`[orchestrator] Spawned ${opts.provider} agent: ${agent.tmuxSession}`);
-      return true;
-    } catch (err) {
-      console.error(`[orchestrator] Spawn failed: ${err}`);
-      return false;
-    }
+    const agent = await spawnAgent(opts, config);
+    managedAgents.push(agent);
+    console.error(`[orchestrator] Spawned ${opts.provider} agent: ${agent.tmuxSession}`);
+    return true;
   }
 
   async function handleShutdown(ctrl: Record<string, any>, restart = false): Promise<Record<string, unknown>> {
@@ -124,7 +118,7 @@ export function createControlHandler(
         });
         await relay.updateCommand(command.id, "succeeded", result);
       } else if (command.type === "workspace.merge") {
-        const result = mergeWorkspace({
+        const result = await mergeWorkspace({
           id: typeof command.params.workspaceId === "string" ? command.params.workspaceId : undefined,
           repoRoot: typeof command.params.repoRoot === "string" ? command.params.repoRoot : undefined,
           worktreePath: typeof command.params.worktreePath === "string" ? command.params.worktreePath : undefined,
@@ -297,6 +291,7 @@ function spawnOptionsFromRecord(source: Record<string, any>, config: Orchestrato
     automationRunId: typeof source.automationRunId === "string" ? source.automationRunId : undefined,
     requestedVia: typeof source.requestedVia === "string" ? source.requestedVia : undefined,
     resumeWorkspace: parseResumeWorkspace(source.resumeWorkspace),
+    acquisition: parseProjectAcquisition(source.acquisition),
   };
 }
 
@@ -331,3 +326,22 @@ function parseResumeWorkspace(value: unknown): import("./workspace-probe/types")
     baseSha: typeof value.baseSha === "string" ? value.baseSha : undefined,
   };
 }
+
+function parseProjectAcquisition(value: unknown): import("./spawn/types").ProjectAcquisitionManifest | undefined {
+  if (!isRecord(value)) return undefined;
+  if (value.mode !== "project-root" || value.sync !== "ff-only") return undefined;
+  const projectId = typeof value.projectId === "string" ? value.projectId : undefined;
+  const rootPath = typeof value.rootPath === "string" ? value.rootPath : undefined;
+  const cwd = typeof value.cwd === "string" ? value.cwd : undefined;
+  const remoteUrl = typeof value.remoteUrl === "string" ? value.remoteUrl : undefined;
+  if (!projectId || !rootPath || !cwd || !remoteUrl) return undefined;
+  return {
+    mode: "project-root",
+    projectId,
+    rootPath,
+    cwd,
+    remoteUrl,
+    ref: typeof value.ref === "string" ? value.ref : undefined,
+    sync: "ff-only",
+  };
+}

package/src/index.ts

@@ -60,7 +60,7 @@ const sharedCallmux = new SharedCallmuxSupervisor(config);
 const POLL_INTERVAL_MS = 3_000;
 const REGISTER_RETRY_MS = 5_000;
 const GUEST_REAP_INTERVAL_MS = 60_000;
-let pollTimer: Timer | null = null;
+let commandPoller: ReturnType<typeof createCommandPoller> | null = null;
 let healthCheckTimer: Timer | null = null;
 let guestReaperTimer: Timer | null = null;
 let apiServer: { stop(): void; url: string } | null = null;
@@ -124,10 +124,8 @@ async function startup(): Promise<void> {
 }
 
 function startPolling(): void {
-  const commandPoller = createCommandPoller({ relay, control });
-  pollTimer = setInterval(async () => {
-    await commandPoller.tick();
-  }, POLL_INTERVAL_MS);
+  commandPoller = createCommandPoller({ relay, control, intervalMs: POLL_INTERVAL_MS, errorBackoffMs: POLL_INTERVAL_MS });
+  commandPoller.start();
 }
 
 async function registerUntilConnected(): Promise<void> {
@@ -208,7 +206,7 @@ async function healthCheck(): Promise<void> {
 
 async function shutdown(): Promise<void> {
   console.error("[orchestrator] Shutting down...");
-  if (pollTimer) clearInterval(pollTimer);
+  commandPoller?.stop();
   if (healthCheckTimer) clearInterval(healthCheckTimer);
   if (guestReaperTimer) clearInterval(guestReaperTimer);
   if (apiServer) apiServer.stop();

package/src/spawn/acquisition.ts

@@ -0,0 +1,202 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { errMessage, isPathWithinBase } from "agent-relay-sdk";
+import { git, requireGit } from "../git";
+import type { ProjectAcquisitionManifest } from "./types";
+
+export interface ProjectAcquisitionResult {
+  applied: boolean;
+  action: "cloned" | "synced" | "noop";
+  rootPath: string;
+  remoteUrl: string;
+  ref?: string;
+  headSha?: string;
+}
+
+const inFlight = new Map<string, Promise<ProjectAcquisitionResult>>();
+const LOCK_TIMEOUT_MS = 5 * 60_000;
+const LOCK_POLL_MS = 100;
+
+export async function applyProjectAcquisitionManifest(
+  manifest: ProjectAcquisitionManifest | undefined,
+  baseDir: string,
+): Promise<ProjectAcquisitionResult | undefined> {
+  if (!manifest) return undefined;
+  const rootPath = resolve(manifest.rootPath);
+  const prior = inFlight.get(rootPath);
+  if (prior) return prior;
+  const run = withAcquisitionLock(rootPath, baseDir, () => applyManifestLocked(manifest, baseDir));
+  inFlight.set(rootPath, run);
+  try {
+    return await run;
+  } finally {
+    if (inFlight.get(rootPath) === run) inFlight.delete(rootPath);
+  }
+}
+
+async function withAcquisitionLock(rootPath: string, baseDir: string, fn: () => ProjectAcquisitionResult): Promise<ProjectAcquisitionResult> {
+  const lockDir = join(resolve(baseDir), ".agent-relay", "locks", `acquire-${hash(rootPath)}.lock`);
+  mkdirSync(dirname(lockDir), { recursive: true });
+  const started = Date.now();
+  for (;;) {
+    try {
+      mkdirSync(lockDir);
+      writeFileSync(join(lockDir, "owner"), `${process.pid}\n${rootPath}\n`);
+      break;
+    } catch (error) {
+      if (Date.now() - started > LOCK_TIMEOUT_MS) {
+        throw new Error(`repo acquisition lock timed out for ${rootPath}: ${errMessage(error)}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, LOCK_POLL_MS));
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    rmSync(lockDir, { recursive: true, force: true });
+  }
+}
+
+function applyManifestLocked(manifest: ProjectAcquisitionManifest, baseDir: string): ProjectAcquisitionResult {
+  validateManifest(manifest, baseDir);
+  const rootPath = resolve(manifest.rootPath);
+  const remoteUrl = manifest.remoteUrl.trim();
+  let action: ProjectAcquisitionResult["action"] = "noop";
+  if (!existsSync(rootPath)) {
+    cloneRoot(manifest, baseDir);
+    action = "cloned";
+  }
+  const syncAction = syncRoot(manifest);
+  if (syncAction === "synced" && action !== "cloned") action = "synced";
+  return {
+    applied: true,
+    action,
+    rootPath,
+    remoteUrl,
+    ...(manifest.ref ? { ref: manifest.ref } : {}),
+    headSha: git(["rev-parse", "HEAD"], rootPath).stdout || undefined,
+  };
+}
+
+function validateManifest(manifest: ProjectAcquisitionManifest, baseDir: string): void {
+  const rootPath = resolve(manifest.rootPath);
+  if (!manifest.remoteUrl.trim()) throw new Error("project acquisition remoteUrl is required");
+  if (!isPathWithinBase(rootPath, baseDir) || rootPath === resolve(baseDir)) {
+    throw new Error(`project acquisition rootPath must be within orchestrator baseDir: ${baseDir}`);
+  }
+  if (!isPathWithinBase(resolve(manifest.cwd), rootPath)) {
+    throw new Error(`project acquisition cwd must be within rootPath: ${manifest.cwd}`);
+  }
+}
+
+function cloneRoot(manifest: ProjectAcquisitionManifest, baseDir: string): void {
+  const rootPath = resolve(manifest.rootPath);
+  const parent = dirname(rootPath);
+  if (!isPathWithinBase(parent, baseDir)) throw new Error(`project acquisition parent must be within orchestrator baseDir: ${parent}`);
+  mkdirSync(parent, { recursive: true });
+  const tmp = join(parent, `.${basename(rootPath)}.agent-relay-clone-${process.pid}-${Date.now()}`);
+  rmSync(tmp, { recursive: true, force: true });
+  const args = ["clone", "--origin", "origin"];
+  if (manifest.ref) args.push("--branch", manifest.ref);
+  args.push(manifest.remoteUrl.trim(), tmp);
+  const cloned = runGit(args, parent);
+  if (!cloned.ok) {
+    rmSync(tmp, { recursive: true, force: true });
+    throw new Error(`git clone failed for ${rootPath}: ${cloned.stderr || cloned.stdout}`);
+  }
+  try {
+    renameSync(tmp, rootPath);
+  } catch (error) {
+    rmSync(tmp, { recursive: true, force: true });
+    throw new Error(`failed to install cloned repo at ${rootPath}: ${errMessage(error)}`);
+  }
+}
+
+function syncRoot(manifest: ProjectAcquisitionManifest): "synced" | "noop" {
+  const rootPath = resolve(manifest.rootPath);
+  assertExistingGitRoot(rootPath);
+  assertRemote(rootPath, manifest.remoteUrl.trim());
+  const status = git(["status", "--porcelain"], rootPath);
+  if (!status.ok) throw new Error(`git status failed for ${rootPath}: ${status.stderr}`);
+  if (status.stdout.trim()) throw new Error(`project root ${rootPath} has local changes; refusing ff-only sync before spawn`);
+  const fetch = git(["fetch", "--prune", "origin"], rootPath);
+  if (!fetch.ok) throw new Error(`git fetch failed for ${rootPath}: ${fetch.stderr || fetch.stdout}`);
+  const target = checkoutSyncTarget(rootPath, manifest.ref);
+  if (!target) return "noop";
+  const head = requireGit(["rev-parse", "HEAD"], rootPath);
+  const targetHead = requireGit(["rev-parse", target], rootPath);
+  if (head === targetHead) return "noop";
+  if (!git(["merge-base", "--is-ancestor", "HEAD", target], rootPath).ok) {
+    throw new Error(`project root ${rootPath} has diverged from ${target}; refusing non-fast-forward sync`);
+  }
+  const merged = git(["merge", "--ff-only", target], rootPath);
+  if (!merged.ok) throw new Error(`git ff-only sync failed for ${rootPath}: ${merged.stderr || merged.stdout}`);
+  return "synced";
+}
+
+function assertExistingGitRoot(rootPath: string): void {
+  let stat;
+  try {
+    stat = statSync(rootPath);
+  } catch (error) {
+    throw new Error(`project root does not exist after acquisition: ${rootPath}: ${errMessage(error)}`);
+  }
+  if (!stat.isDirectory()) throw new Error(`project root exists but is not a directory: ${rootPath}`);
+  const top = git(["rev-parse", "--show-toplevel"], rootPath);
+  if (!top.ok || resolve(top.stdout) !== rootPath) throw new Error(`project root exists but is not a git checkout root: ${rootPath}`);
+}
+
+function assertRemote(rootPath: string, remoteUrl: string): void {
+  const current = git(["remote", "get-url", "origin"], rootPath);
+  if (!current.ok || !current.stdout) throw new Error(`project root ${rootPath} has no origin remote`);
+  if (current.stdout.trim() !== remoteUrl) {
+    throw new Error(`project root ${rootPath} origin mismatch: expected ${remoteUrl}, found ${current.stdout.trim()}`);
+  }
+}
+
+function checkoutSyncTarget(rootPath: string, ref: string | undefined): string | undefined {
+  if (ref?.trim()) {
+    const name = ref.trim();
+    const remoteBranch = `refs/remotes/origin/${name}`;
+    if (git(["show-ref", "--verify", "--quiet", remoteBranch], rootPath).ok) {
+      if (git(["show-ref", "--verify", "--quiet", `refs/heads/${name}`], rootPath).ok) {
+        const checked = git(["checkout", name], rootPath);
+        if (!checked.ok) throw new Error(`git checkout ${name} failed for ${rootPath}: ${checked.stderr || checked.stdout}`);
+      } else {
+        const checked = git(["checkout", "-B", name, `origin/${name}`], rootPath);
+        if (!checked.ok) throw new Error(`git checkout ${name} failed for ${rootPath}: ${checked.stderr || checked.stdout}`);
+      }
+      return `origin/${name}`;
+    }
+    if (git(["rev-parse", "--verify", name], rootPath).ok) {
+      const checked = git(["checkout", name], rootPath);
+      if (!checked.ok) throw new Error(`git checkout ${name} failed for ${rootPath}: ${checked.stderr || checked.stdout}`);
+      return undefined;
+    }
+    throw new Error(`project acquisition ref "${name}" not found on origin for ${rootPath}`);
+  }
+  const upstream = git(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], rootPath);
+  if (upstream.ok && upstream.stdout) return upstream.stdout;
+  const originHead = git(["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], rootPath);
+  if (originHead.ok && originHead.stdout) return originHead.stdout;
+  throw new Error(`project root ${rootPath} has no upstream or origin/HEAD for ff-only sync`);
+}
+
+function runGit(args: string[], cwd: string): { ok: boolean; stdout: string; stderr: string } {
+  const proc = Bun.spawnSync(["git", ...args], {
+    cwd,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  return {
+    ok: proc.exitCode === 0,
+    stdout: proc.stdout.toString().trim(),
+    stderr: proc.stderr.toString().trim(),
+  };
+}
+
+function hash(value: string): string {
+  return createHash("sha1").update(resolve(value)).digest("hex").slice(0, 16);
+}

package/src/spawn/index.ts

@@ -1,4 +1,5 @@
 export * from "./command";
+export * from "./acquisition";
 export * from "./guests";
 export * from "./log-utils";
 export * from "./runtime";

package/src/spawn/spawn-agent.ts

@@ -2,6 +2,7 @@ import { closeSync, existsSync, openSync, rmSync } from "node:fs";
 import type { OrchestratorConfig } from "../config";
 import { resolveSpawnWorkspace, workspacesRoot } from "../workspace-probe";
 import type { ManagedAgentReport } from "../relay";
+import { applyProjectAcquisitionManifest } from "./acquisition";
 import { buildEnv, buildRunnerCommand, defaultSpawnLabel, isWithinBaseDir, sessionName } from "./command";
 import { addSessionRecord, currentSessionPid, findSessionRecord, ensureLogDir, ensureRunnerInfoDir, logFilePath, runnerInfoPath, sessionRecordLiveness, sessionReportFields } from "./runtime";
 import { managedAgentId } from "./sessions";
@@ -10,6 +11,7 @@ import type { SpawnOptions } from "./types";
 
 interface SpawnAgentDeps {
   resolveSpawnWorkspace: typeof resolveSpawnWorkspace;
+  applyProjectAcquisitionManifest: typeof applyProjectAcquisitionManifest;
   spawnRunner: typeof spawnRunner;
   addSessionRecord: typeof addSessionRecord;
   findSessionRecord: typeof findSessionRecord;
@@ -24,6 +26,7 @@ interface SpawnAgentDeps {
 
 const defaultSpawnAgentDeps: SpawnAgentDeps = {
   resolveSpawnWorkspace,
+  applyProjectAcquisitionManifest,
   spawnRunner,
   addSessionRecord,
   findSessionRecord,
@@ -46,12 +49,13 @@ export async function spawnAgent(
   const agentId = opts.agentId || managedAgentId(config, opts.provider, label);
   const name = sessionName(config, opts.provider, label, opts.spawnRequestId ?? agentId);
 
-  if (!existsSync(opts.cwd)) {
-    throw new Error(`cwd does not exist: ${opts.cwd}`);
-  }
   if (!isWithinBaseDir(opts.cwd, config.baseDir)) {
     throw new Error(`cwd must be within base directory: ${config.baseDir}`);
   }
+  await d.applyProjectAcquisitionManifest(opts.acquisition, config.baseDir);
+  if (!existsSync(opts.cwd)) {
+    throw new Error(`cwd does not exist: ${opts.cwd}`);
+  }
   const existing = existingSpawnSession(opts, d);
   if (existing) return existing;
 

package/src/spawn/types.ts

@@ -2,6 +2,16 @@ import type { OrchestratorConfig } from "../config";
 import type { AgentLifecycle, SpawnProvider, WorkspaceMetadata, WorkspaceMode } from "agent-relay-sdk";
 import type { ResumeWorkspaceTarget } from "../workspace-probe/types";
 
+export interface ProjectAcquisitionManifest {
+  mode: "project-root";
+  projectId: string;
+  rootPath: string;
+  cwd: string;
+  remoteUrl: string;
+  ref?: string;
+  sync: "ff-only";
+}
+
 export interface SpawnOptions {
   provider: SpawnProvider;
   cwd: string;
@@ -33,6 +43,8 @@ export interface SpawnOptions {
   requestedVia?: string;
   /** #635 — attach to or branch off an existing worktree instead of creating a fresh one. */
   resumeWorkspace?: ResumeWorkspaceTarget;
+  /** #410 — lazy clone/sync manifest, applied on the host before worktree prep. */
+  acquisition?: ProjectAcquisitionManifest;
 }
 
 export interface SessionInfo {

package/src/workspace-probe/land-gates-runner.ts

@@ -13,6 +13,8 @@ import { loadRepoLandGates } from "agent-relay-sdk/land-gates";
  *  are meant to be a FAST high-signal subset, not the full suite — keep the ceiling
  *  generous but bounded so a hung gate can't wedge the per-repo merge lease forever. */
 const DEFAULT_GATE_TIMEOUT_MS = 5 * 60 * 1000;
+const TIMEOUT_KILL_GRACE_MS = 1_000;
+const OUTPUT_CANCEL_GRACE_MS = 50;
 /** Cap on the full output streamed to the relay artifact (the notification only ever
  *  carries the tail). Errors usually surface at the END, so we keep the tail on overflow. */
 const MAX_FULL_OUTPUT_BYTES = 256 * 1024;
@@ -31,26 +33,88 @@ function combineOutput(stdout: string, stderr: string): string {
   return stdout || stderr;
 }
 
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+interface OutputCapture {
+  done: Promise<void>;
+  text(): string;
+  cancel(): void;
+}
+
+function captureProcessOutput(pipe: unknown): OutputCapture {
+  if (!(pipe instanceof ReadableStream)) {
+    return { done: Promise.resolve(), text: () => "", cancel: () => {} };
+  }
+
+  const reader = pipe.getReader();
+  const decoder = new TextDecoder();
+  let output = "";
+  let canceled = false;
+  const done = (async () => {
+    try {
+      while (!canceled) {
+        const chunk = await reader.read();
+        if (chunk.done) break;
+        output += decoder.decode(chunk.value, { stream: true });
+      }
+      output += decoder.decode();
+    } catch {
+      // A timeout cancels the reader intentionally so pipe EOF cannot hold up the gate result.
+    } finally {
+      try { reader.releaseLock(); } catch {}
+    }
+  })();
+
+  return {
+    done,
+    text: () => output,
+    cancel: () => {
+      canceled = true;
+      void reader.cancel().catch(() => {});
+    },
+  };
+}
+
+function signalGateProcessGroup(proc: ReturnType<typeof Bun.spawn>, signal: NodeJS.Signals): void {
+  if (typeof proc.pid === "number" && proc.pid > 0) {
+    try {
+      process.kill(-proc.pid, signal);
+      return;
+    } catch (err) {
+      if ((err as { code?: string }).code !== "ESRCH") {
+        try { proc.kill(signal); } catch {}
+      }
+      return;
+    }
+  }
+  try { proc.kill(signal); } catch {}
+}
+
 /** Run a single gate and capture its outcome. Never throws — a spawn failure (e.g.
  *  the command can't launch) is reported as a non-passing result so the caller can
  *  decide block-vs-warn from the gate's `optional` flag. */
-export function runOneLandGate(worktreePath: string, gate: LandGate): LandGateRunResult {
+export async function runOneLandGate(worktreePath: string, gate: LandGate): Promise<LandGateRunResult> {
   const cwd = gate.cwd ? resolve(worktreePath, gate.cwd) : worktreePath;
   const timeoutMs = gate.timeoutMs ?? DEFAULT_GATE_TIMEOUT_MS;
   const started = Date.now();
   const base = { name: gate.name, command: gate.command, optional: gate.optional === true } as const;
 
-  let proc: ReturnType<typeof Bun.spawnSync>;
+  let proc: ReturnType<typeof Bun.spawn>;
+  let timedOut = false;
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  let killTimeout: ReturnType<typeof setTimeout> | undefined;
   try {
     // A login shell so PATH (bun, node, project bins) resolves like the worker's own
     // environment; `env: process.env` makes runtime env mutations visible to the child.
-    proc = Bun.spawnSync(["bash", "-lc", gate.command], {
+    proc = Bun.spawn(["bash", "-lc", gate.command], {
       cwd,
       env: process.env,
       stdin: "ignore",
       stdout: "pipe",
       stderr: "pipe",
-      timeout: timeoutMs,
+      detached: true,
     });
   } catch (err) {
     const durationMs = Date.now() - started;
@@ -58,12 +122,47 @@ export function runOneLandGate(worktreePath: string, gate: LandGate): LandGateRu
     return { ...base, passed: false, exitCode: null, timedOut: false, durationMs, outputTail: output, output };
   }
 
+  const stdoutCapture = captureProcessOutput(proc.stdout);
+  const stderrCapture = captureProcessOutput(proc.stderr);
+  let timeoutTriggeredResolve: () => void = () => {};
+  const timeoutTriggered = new Promise<void>((resolve) => { timeoutTriggeredResolve = resolve; });
+  timeout = setTimeout(() => {
+    timedOut = true;
+    timeoutTriggeredResolve();
+    signalGateProcessGroup(proc, "SIGTERM");
+    stdoutCapture.cancel();
+    stderrCapture.cancel();
+    killTimeout = setTimeout(() => {
+      signalGateProcessGroup(proc, "SIGKILL");
+      stdoutCapture.cancel();
+      stderrCapture.cancel();
+    }, TIMEOUT_KILL_GRACE_MS);
+    killTimeout.unref?.();
+  }, timeoutMs);
+  timeout.unref?.();
+
+  const exitCodeRaw = await Promise.race([
+    proc.exited,
+    timeoutTriggered.then(async () => {
+      await Promise.race([proc.exited.then(() => undefined), sleep(TIMEOUT_KILL_GRACE_MS + OUTPUT_CANCEL_GRACE_MS)]);
+      return null;
+    }),
+  ]).finally(() => {
+    if (timeout) clearTimeout(timeout);
+    if (killTimeout) clearTimeout(killTimeout);
+  });
+  if (timedOut) {
+    stdoutCapture.cancel();
+    stderrCapture.cancel();
+    await Promise.race([Promise.allSettled([stdoutCapture.done, stderrCapture.done]), sleep(OUTPUT_CANCEL_GRACE_MS)]);
+  } else {
+    await Promise.all([stdoutCapture.done, stderrCapture.done]);
+  }
   const durationMs = Date.now() - started;
-  const stdout = proc.stdout ? proc.stdout.toString() : "";
-  const stderr = proc.stderr ? proc.stderr.toString() : "";
+  const stdout = stdoutCapture.text();
+  const stderr = stderrCapture.text();
   let combined = combineOutput(stdout, stderr);
-  const exitCode = typeof proc.exitCode === "number" ? proc.exitCode : null;
-  const timedOut = proc.exitedDueToTimeout === true;
+  const exitCode = timedOut ? null : typeof exitCodeRaw === "number" ? exitCodeRaw : null;
   const passed = exitCode === 0;
   if (timedOut) combined = `${combined}\n[land-gate] timed out after ${timeoutMs}ms`.trimStart();
   if (!combined) combined = passed ? "(gate produced no output)" : "(gate produced no output)";
@@ -100,7 +199,7 @@ export interface LandGatesResult {
  * (surfaced as a synthetic required gate) rather than an unhandled throw that would
  * crash the merge command — the worker fixes the config and re-lands.
  */
-export function runLandGates(worktreePath: string): LandGatesResult {
+export async function runLandGates(worktreePath: string): Promise<LandGatesResult> {
   const warnings: LandGateRunResult[] = [];
   let gates: LandGate[];
   try {
@@ -116,7 +215,7 @@ export function runLandGates(worktreePath: string): LandGatesResult {
   if (gates.length === 0) return { ran: 0, warnings };
 
   for (const gate of gates) {
-    const result = runOneLandGate(worktreePath, gate);
+    const result = await runOneLandGate(worktreePath, gate);
     if (result.passed) continue;
     if (result.optional) { warnings.push(result); continue; }
     // First required failure blocks the land — don't run the rest (the worker fixes

package/src/workspace-probe/merge.ts

@@ -346,7 +346,7 @@ function validPreviewStrategy(strategy: string | null): "pr" | "rebase-ff" | "au
  * Refuses on a dirty worktree, predicted conflicts, or nothing to merge. Never
  * destroys work on uncertainty.
  */
-export function mergeWorkspace(input: WorkspaceMergeInput): WorkspaceMergeResult {
+export async function mergeWorkspace(input: WorkspaceMergeInput): Promise<WorkspaceMergeResult> {
   if (!input.worktreePath) return { strategy: "rebase-ff", merged: false, status: "review_requested", error: "worktreePath required", workspaceId: input.id };
   const worktreePath = resolve(input.worktreePath);
   const repoRoot = input.repoRoot ? resolve(input.repoRoot) : worktreePath;
@@ -391,7 +391,7 @@ export function mergeWorkspace(input: WorkspaceMergeInput): WorkspaceMergeResult
   if (preview.conflict) return head({ conflict: true, status: "conflict", error: "merge would conflict with base" });
 
   if (strategy === "pr") return mergePr(input, worktreePath, branch, preview, head);
-  return mergeRebaseFf(input, worktreePath, repoRoot, branch, preview, head);
+  return await mergeRebaseFf(input, worktreePath, repoRoot, branch, preview, head);
 }
 
 /**
@@ -576,15 +576,15 @@ function recordNoFfMerge(
  * Returns the gate outcome, or an `abort` describing a merge result the caller must return early
  * (a real merge conflict computing the integrated tree, or a failure materializing it).
  */
-function runLandGatesOnIntegratedTree(
+async function runLandGatesOnIntegratedTree(
   repoRoot: string,
   worktreePath: string,
   behind: number,
   integrationBaseSha: string,
   headSha: string,
   mergeMessage: string,
-): { gates: LandGatesResult } | { abort: { conflict?: boolean; error: string } } {
-  if (behind === 0) return { gates: runLandGates(worktreePath) };
+): Promise<{ gates: LandGatesResult } | { abort: { conflict?: boolean; error: string } }> {
+  if (behind === 0) return { gates: await runLandGates(worktreePath) };
 
   const synth = synthesizeNoFfMerge(repoRoot, integrationBaseSha, headSha, mergeMessage);
   if (!synth.ok) return { abort: { conflict: synth.conflict, error: synth.error } };
@@ -600,7 +600,7 @@ function runLandGatesOnIntegratedTree(
     return { abort: { error: add.stderr || "failed to materialize integrated tree for land gates" } };
   }
   try {
-    return { gates: runLandGates(tmpWorktree) };
+    return { gates: await runLandGates(tmpWorktree) };
   } finally {
     git(["worktree", "remove", "--force", tmpWorktree], repoRoot);
     rmSync(tmpParent, { recursive: true, force: true });
@@ -643,14 +643,14 @@ function syncLocalBaseToUpstream(
   return { ok: true, baseSync };
 }
 
-function mergeRebaseFf(
+async function mergeRebaseFf(
   input: WorkspaceMergeInput,
   worktreePath: string,
   repoRoot: string,
   branch: string | undefined,
   preview: WorkspaceMergePreview,
   head: (field: Partial<WorkspaceMergeResult>) => WorkspaceMergeResult,
-): WorkspaceMergeResult {
+): Promise<WorkspaceMergeResult> {
   const base = preview.baseRef;
   if (!base) return head({ status: "review_requested", error: "no base branch to merge into" });
   if (!branch) return head({ status: "review_requested", error: "cannot determine agent branch" });
@@ -724,7 +724,7 @@ function mergeRebaseFf(
   // status:"review_requested" carrying `gateFailure`, NOT "conflict": gate failures bounce back to
   // the worker, never the merge-conflict/steward path. Optional-gate failures ride along as
   // `gateWarnings` on the successful land below.
-  const gateRun = runLandGatesOnIntegratedTree(repoRoot, worktreePath, behind, integrationBaseSha, headSha, landMergeMessage(branch, landedSubject));
+  const gateRun = await runLandGatesOnIntegratedTree(repoRoot, worktreePath, behind, integrationBaseSha, headSha, landMergeMessage(branch, landedSubject));
   if ("abort" in gateRun) {
     return gateRun.abort.conflict
       ? head({ conflict: true, status: "conflict", error: gateRun.abort.error })