agent-relay-orchestrator 0.118.1 → 0.118.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.118.1",
+  "version": "0.118.3",
   "description": "Agent Relay orchestrator — manages agent lifecycle across hosts",
   "type": "module",
   "bin": {

package/src/api.ts

@@ -479,7 +479,7 @@ export function startApiServer(config: OrchestratorConfig, probeCache: ProviderP
         if (!authorized(req, config)) return error("unauthorized", 401);
         try {
           const { target } = resolveInsideBase(url.searchParams.get("path") || undefined, config.baseDir);
-          return json(workspaceGitState({
+          return json(await workspaceGitState({
             worktreePath: target,
             baseRef: url.searchParams.get("baseRef") || undefined,
             baseSha: url.searchParams.get("baseSha") || undefined,
@@ -493,7 +493,7 @@ export function startApiServer(config: OrchestratorConfig, probeCache: ProviderP
         if (!authorized(req, config)) return error("unauthorized", 401);
         try {
           const { target } = resolveInsideBase(url.searchParams.get("path") || undefined, config.baseDir);
-          return json(workspaceDiff({
+          return json(await workspaceDiff({
             worktreePath: target,
             baseRef: url.searchParams.get("baseRef") || undefined,
             baseSha: url.searchParams.get("baseSha") || undefined,
@@ -506,17 +506,17 @@ export function startApiServer(config: OrchestratorConfig, probeCache: ProviderP
 
       if (req.method === "GET" && url.pathname === "/api/workspace/merge-preview") {
         if (!authorized(req, config)) return error("unauthorized", 401);
-        return mergePreviewResponse(url, config.baseDir);
+        return await mergePreviewResponse(url, config.baseDir);
       }
 
       if (req.method === "GET" && url.pathname === "/api/workspace/branch-merge-preview") {
         if (!authorized(req, config)) return error("unauthorized", 401);
-        return branchMergePreviewResponse(url, config.baseDir);
+        return await branchMergePreviewResponse(url, config.baseDir);
       }
 
       if (req.method === "GET" && url.pathname === "/api/workspace/recovery-branches") {
         if (!authorized(req, config)) return error("unauthorized", 401);
-        return recoveryBranchesResponse(url, config.baseDir);
+        return await recoveryBranchesResponse(url, config.baseDir);
       }
 
       if (req.method === "GET" && url.pathname === "/api/providers") {

package/src/control.ts

@@ -96,7 +96,7 @@ export function createControlHandler(
         const result = await handleShutdown(command.params, command.type === "agent.restart");
         await relay.updateCommand(command.id, "succeeded", result);
       } else if (command.type === "workspace.cleanup") {
-        const result = cleanupWorkspace({
+        const result = await cleanupWorkspace({
           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,
@@ -108,7 +108,7 @@ export function createControlHandler(
         });
         await relay.updateCommand(command.id, "succeeded", result);
       } else if (command.type === "workspace.reconcile") {
-        const result = reconcileWorkspace({
+        const result = await reconcileWorkspace({
           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,
@@ -143,7 +143,7 @@ export function createControlHandler(
         await relay.updateCommand(command.id, mergeCommandStatus(result), result as unknown as Record<string, unknown>, result.error);
       } else if (command.type === "workspace.pr-arm-auto-merge") {
         const rawPrNumber = command.params.prNumber;
-        const result = armWorkspacePrAutoMerge({
+        const result = await armWorkspacePrAutoMerge({
           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,
@@ -154,7 +154,7 @@ export function createControlHandler(
         await relay.updateCommand(command.id, result.autoMergeArmed ? "succeeded" : "failed", result as unknown as Record<string, unknown>, result.error);
       } else if (command.type === "workspace.pr-merge") {
         const rawPrNumber = command.params.prNumber;
-        const result = mergeWorkspacePr({
+        const result = await mergeWorkspacePr({
           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,
@@ -165,7 +165,7 @@ export function createControlHandler(
         await relay.updateCommand(command.id, result.relayMerged ? "succeeded" : "failed", result as unknown as Record<string, unknown>, result.error);
       } else if (command.type === "workspace.pr-refresh") {
         const rawPrNumber = command.params.prNumber;
-        const result = refreshWorkspacePrBranch({
+        const result = await refreshWorkspacePrBranch({
           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,
@@ -175,14 +175,14 @@ export function createControlHandler(
         });
         await relay.updateCommand(command.id, result.prRefreshed ? "succeeded" : "failed", result as unknown as Record<string, unknown>, result.error);
       } else if (command.type === "workspace.deps-refresh") {
-        const result = refreshWorkspaceDeps(
+        const result = await refreshWorkspaceDeps(
           typeof command.params.repoRoot === "string" ? command.params.repoRoot : "",
           typeof command.params.worktreePath === "string" ? command.params.worktreePath : "",
           { checkOnly: command.params.checkOnly === true },
         );
         await relay.updateCommand(command.id, "succeeded", { workspaceId: typeof command.params.workspaceId === "string" ? command.params.workspaceId : undefined, ...result });
       } else if (command.type === "workspace.recovery-branch-discard") {
-        const result = discardRecoveryBranch({
+        const result = await discardRecoveryBranch({
           repoRoot: typeof command.params.repoRoot === "string" ? command.params.repoRoot : undefined,
           branch: typeof command.params.branch === "string" ? command.params.branch : undefined,
           baseRef: typeof command.params.baseRef === "string" ? command.params.baseRef : undefined,
@@ -191,7 +191,7 @@ export function createControlHandler(
         });
         await relay.updateCommand(command.id, "succeeded", result as unknown as Record<string, unknown>);
       } else if (command.type === "workspace.idle-refresh") {
-        const result = idleRefreshWorktree({
+        const result = await idleRefreshWorktree({
           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,
@@ -201,7 +201,7 @@ export function createControlHandler(
         });
         await relay.updateCommand(command.id, result.error ? "failed" : "succeeded", result as unknown as Record<string, unknown>, result.error);
       } else if (command.type === "workspace.prune") {
-        const result = pruneWorktrees({
+        const result = await pruneWorktrees({
           repoRoot: typeof command.params.repoRoot === "string" ? command.params.repoRoot : undefined,
         });
         await relay.updateCommand(command.id, "succeeded", result);

package/src/git.ts

@@ -2,6 +2,8 @@
 // Extracted from workspace-probe.ts so that giant keeps shrinking (epic #291) and the
 // `git -C` invocation lives in one place.
 
+import { execProcess } from "./process";
+
 interface GitResult {
   ok: boolean;
   stdout: string;
@@ -9,36 +11,18 @@ interface GitResult {
 }
 
 /** Run `git -C cwd <args>` and capture trimmed stdout/stderr; never throws. */
-export function git(args: string[], cwd: string): GitResult {
-  const proc = Bun.spawnSync(["git", "-C", cwd, ...args], {
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-  return {
-    ok: proc.exitCode === 0,
-    stdout: proc.stdout.toString().trim(),
-    stderr: proc.stderr.toString().trim(),
-  };
+export async function git(args: string[], cwd: string): Promise<GitResult> {
+  return await execProcess(["git", "-C", cwd, ...args]);
 }
 
 /** Run `git -C cwd <args>` and preserve stdout exactly for path-safe parsers. */
-export function gitRaw(args: string[], cwd: string): GitResult {
-  const proc = Bun.spawnSync(["git", "-C", cwd, ...args], {
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-  return {
-    ok: proc.exitCode === 0,
-    stdout: proc.stdout.toString(),
-    stderr: proc.stderr.toString().trim(),
-  };
+export async function gitRaw(args: string[], cwd: string): Promise<GitResult> {
+  return await execProcess(["git", "-C", cwd, ...args], { trimStdout: false });
 }
 
 /** Like {@link git} but throws on a non-zero exit, returning stdout on success. */
-export function requireGit(args: string[], cwd: string): string {
-  const result = git(args, cwd);
+export async function requireGit(args: string[], cwd: string): Promise<string> {
+  const result = await git(args, cwd);
   if (!result.ok) throw new Error(result.stderr || `git ${args.join(" ")} failed`);
   return result.stdout;
 }

package/src/process.ts

@@ -0,0 +1,41 @@
+export interface ExecResult {
+  ok: boolean;
+  exitCode: number | null;
+  stdout: string;
+  stderr: string;
+}
+
+interface ExecOptions {
+  cwd?: string;
+  env?: Record<string, string | undefined>;
+  stdout?: "pipe" | "ignore";
+  stderr?: "pipe" | "ignore";
+  trimStdout?: boolean;
+  trimStderr?: boolean;
+}
+
+async function readStream(stream: ReadableStream<Uint8Array> | undefined): Promise<string> {
+  if (!stream) return "";
+  return await new Response(stream).text();
+}
+
+export async function execProcess(cmd: string[], options: ExecOptions = {}): Promise<ExecResult> {
+  const proc = Bun.spawn(cmd, {
+    cwd: options.cwd,
+    env: options.env,
+    stdin: "ignore",
+    stdout: options.stdout ?? "pipe",
+    stderr: options.stderr ?? "pipe",
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    proc.exited,
+    options.stdout === "ignore" ? Promise.resolve("") : readStream(proc.stdout),
+    options.stderr === "ignore" ? Promise.resolve("") : readStream(proc.stderr),
+  ]);
+  return {
+    ok: exitCode === 0,
+    exitCode,
+    stdout: options.trimStdout === false ? stdout : stdout.trim(),
+    stderr: options.trimStderr === false ? stderr : stderr.trim(),
+  };
+}

package/src/relay.ts

@@ -68,6 +68,8 @@ export interface RelayCommand {
 const RECONNECT_INITIAL_MS = 30_000;
 const RECONNECT_MAX_MS = 3_600_000; // 1 hour
 const RECONNECT_JITTER_MS = 1_000;
+const TRANSIENT_ABORT_RECONNECT_MS = 250;
+const ABORT_FAILURES_BEFORE_DISCONNECT = 3;
 
 export function buildRegistrationMeta(
   config: Pick<OrchestratorConfig, "tmuxPrefix">,
@@ -94,6 +96,7 @@ export function createRelayClient(config: OrchestratorConfig, probeCache: Provid
   const agentId = `orchestrator-${config.id}`;
   let heartbeatTimer: Timer | null = null;
   let connected = false;
+  let abortFailures = 0;
   const reconnectMgr = new ReconnectionManager({ initialMs: RECONNECT_INITIAL_MS, maxMs: RECONNECT_MAX_MS, jitterMs: RECONNECT_JITTER_MS });
   let cursorFloor = 0;
   let apiUrl: string | undefined;
@@ -134,6 +137,7 @@ export function createRelayClient(config: OrchestratorConfig, probeCache: Provid
     const registered = await res.json().catch(() => null) as { runtimeToken?: { token?: string } } | null;
     if (registered?.runtimeToken?.token) http.setToken(registered.runtimeToken.token);
     connected = true;
+    abortFailures = 0;
     reconnectMgr.reset();
 
     // Bootstrap message cursor
@@ -167,7 +171,20 @@ export function createRelayClient(config: OrchestratorConfig, probeCache: Provid
         connected = true;
         reconnectMgr.reset();
       }
+      abortFailures = 0;
     } catch (err) {
+      if (isAbortError(err)) {
+        abortFailures += 1;
+        if (connected && abortFailures === 1) {
+          console.error(`[orchestrator] Relay heartbeat timed out: ${err}; retrying quickly`);
+        }
+        if (abortFailures < ABORT_FAILURES_BEFORE_DISCONNECT) {
+          await reconnect(TRANSIENT_ABORT_RECONNECT_MS);
+          return;
+        }
+      } else {
+        abortFailures = 0;
+      }
       if (connected) {
         console.error(`[orchestrator] Lost connection to relay: ${err}`);
         connected = false;
@@ -176,9 +193,10 @@ export function createRelayClient(config: OrchestratorConfig, probeCache: Provid
     }
   }
 
-  async function reconnect(): Promise<void> {
-    const delayMs = reconnectMgr.nextDelay();
-    console.error(`[orchestrator] Reconnecting in ${Math.round(delayMs / 1000)}s...`);
+  async function reconnect(delayOverrideMs?: number): Promise<void> {
+    const delayMs = delayOverrideMs ?? reconnectMgr.nextDelay();
+    const label = delayMs < 1000 ? `${delayMs}ms` : `${Math.round(delayMs / 1000)}s`;
+    console.error(`[orchestrator] Reconnecting in ${label}...`);
     await new Promise((resolve) => setTimeout(resolve, delayMs));
     try {
       await register();
@@ -258,3 +276,8 @@ export function createRelayClient(config: OrchestratorConfig, probeCache: Provid
     get connected() { return connected; },
   };
 }
+
+function isAbortError(error: unknown): boolean {
+  return error instanceof DOMException && error.name === "AbortError"
+    || typeof error === "object" && error !== null && (error as { name?: string }).name === "AbortError";
+}

package/src/spawn/acquisition.ts

@@ -3,6 +3,7 @@ import { existsSync, mkdirSync, renameSync, rmSync, statSync, writeFileSync } fr
 import { basename, dirname, join, resolve } from "node:path";
 import { errMessage, isPathWithinBase } from "agent-relay-sdk";
 import { git, requireGit } from "../git";
+import { execProcess } from "../process";
 import type { ProjectAcquisitionManifest } from "./types";
 
 export interface ProjectAcquisitionResult {
@@ -35,7 +36,7 @@ export async function applyProjectAcquisitionManifest(
   }
 }
 
-async function withAcquisitionLock(rootPath: string, baseDir: string, fn: () => ProjectAcquisitionResult): Promise<ProjectAcquisitionResult> {
+async function withAcquisitionLock(rootPath: string, baseDir: string, fn: () => Promise<ProjectAcquisitionResult>): Promise<ProjectAcquisitionResult> {
   const lockDir = join(resolve(baseDir), ".agent-relay", "locks", `acquire-${hash(rootPath)}.lock`);
   mkdirSync(dirname(lockDir), { recursive: true });
   const started = Date.now();
@@ -52,22 +53,22 @@ async function withAcquisitionLock(rootPath: string, baseDir: string, fn: () =>
     }
   }
   try {
-    return fn();
+    return await fn();
   } finally {
     rmSync(lockDir, { recursive: true, force: true });
   }
 }
 
-function applyManifestLocked(manifest: ProjectAcquisitionManifest, baseDir: string): ProjectAcquisitionResult {
+async function applyManifestLocked(manifest: ProjectAcquisitionManifest, baseDir: string): Promise<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);
+    await cloneRoot(manifest, baseDir);
     action = "cloned";
   }
-  const syncAction = syncRoot(manifest);
+  const syncAction = await syncRoot(manifest);
   if (syncAction === "synced" && action !== "cloned") action = "synced";
   return {
     applied: true,
@@ -75,7 +76,7 @@ function applyManifestLocked(manifest: ProjectAcquisitionManifest, baseDir: stri
     rootPath,
     remoteUrl,
     ...(manifest.ref ? { ref: manifest.ref } : {}),
-    headSha: git(["rev-parse", "HEAD"], rootPath).stdout || undefined,
+    headSha: (await git(["rev-parse", "HEAD"], rootPath)).stdout || undefined,
   };
 }
 
@@ -90,7 +91,7 @@ function validateManifest(manifest: ProjectAcquisitionManifest, baseDir: string)
   }
 }
 
-function cloneRoot(manifest: ProjectAcquisitionManifest, baseDir: string): void {
+async function cloneRoot(manifest: ProjectAcquisitionManifest, baseDir: string): Promise<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}`);
@@ -100,7 +101,7 @@ function cloneRoot(manifest: ProjectAcquisitionManifest, baseDir: string): void
   const args = ["clone", "--origin", "origin"];
   if (manifest.ref) args.push("--branch", manifest.ref);
   args.push(manifest.remoteUrl.trim(), tmp);
-  const cloned = runGit(args, parent);
+  const cloned = await runGit(args, parent);
   if (!cloned.ok) {
     rmSync(tmp, { recursive: true, force: true });
     throw new Error(`git clone failed for ${rootPath}: ${cloned.stderr || cloned.stdout}`);
@@ -113,29 +114,29 @@ function cloneRoot(manifest: ProjectAcquisitionManifest, baseDir: string): void
   }
 }
 
-function syncRoot(manifest: ProjectAcquisitionManifest): "synced" | "noop" {
+async function syncRoot(manifest: ProjectAcquisitionManifest): Promise<"synced" | "noop"> {
   const rootPath = resolve(manifest.rootPath);
-  assertExistingGitRoot(rootPath);
-  assertRemote(rootPath, manifest.remoteUrl.trim());
-  const status = git(["status", "--porcelain"], rootPath);
+  await assertExistingGitRoot(rootPath);
+  await assertRemote(rootPath, manifest.remoteUrl.trim());
+  const status = await 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);
+  const fetch = await 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);
+  const target = await checkoutSyncTarget(rootPath, manifest.ref);
   if (!target) return "noop";
-  const head = requireGit(["rev-parse", "HEAD"], rootPath);
-  const targetHead = requireGit(["rev-parse", target], rootPath);
+  const head = await requireGit(["rev-parse", "HEAD"], rootPath);
+  const targetHead = await requireGit(["rev-parse", target], rootPath);
   if (head === targetHead) return "noop";
-  if (!git(["merge-base", "--is-ancestor", "HEAD", target], rootPath).ok) {
+  if (!(await 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);
+  const merged = await 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 {
+async function assertExistingGitRoot(rootPath: string): Promise<void> {
   let stat;
   try {
     stat = statSync(rootPath);
@@ -143,58 +144,48 @@ function assertExistingGitRoot(rootPath: string): void {
     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);
+  const top = await 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);
+async function assertRemote(rootPath: string, remoteUrl: string): Promise<void> {
+  const current = await 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 {
+async function checkoutSyncTarget(rootPath: string, ref: string | undefined): Promise<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 ((await git(["show-ref", "--verify", "--quiet", remoteBranch], rootPath)).ok) {
+      if ((await git(["show-ref", "--verify", "--quiet", `refs/heads/${name}`], rootPath)).ok) {
+        const checked = await 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);
+        const checked = await 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 ((await git(["rev-parse", "--verify", name], rootPath)).ok) {
+      const checked = await 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);
+  const upstream = await 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);
+  const originHead = await 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(),
-  };
+async function runGit(args: string[], cwd: string): Promise<{ ok: boolean; stdout: string; stderr: string }> {
+  return await execProcess(["git", ...args], { cwd });
 }
 
 function hash(value: string): string {

package/src/spawn/spawn-agent.ts

@@ -88,7 +88,7 @@ export async function spawnAgent(
 
   closeSync(logFd);
 
-  const runner = d.spawnRunner(name, command, spawnOpts.cwd, env, logFile);
+  const runner = await d.spawnRunner(name, command, spawnOpts.cwd, env, logFile);
 
   d.addSessionRecord({
     name,

package/src/spawn/supervisor.ts

@@ -11,13 +11,14 @@ import { SESSION_DIR } from "./constants";
 import { disableSystemdSupervisor, forceSystemdSupervisor } from "../config";
 import { logLines } from "./log-utils";
 import { currentSessionPid, ensureSessionDir, findSessionRecord, isSessionRecordAlive, loadState, logFilePath, readRunnerInfo, removeSessionRecord, sessionSupervisor } from "./runtime";
-import { systemdMainPid, systemdUnitDiagnostics, systemdUnitName } from "./systemd";
+import { systemdMainPidAsync, systemdUnitDiagnostics, systemdUnitName } from "./systemd";
 import type { SessionRecord, SessionSupervisor, SpawnedRunner } from "./types";
+import { execProcess } from "../process";
 
-export function spawnRunner(name: string, command: string[], cwd: string, env: Record<string, string>, logFile: string): SpawnedRunner {
-  if (shouldUseSystemdSupervisor()) {
+export async function spawnRunner(name: string, command: string[], cwd: string, env: Record<string, string>, logFile: string): Promise<SpawnedRunner> {
+  if (await shouldUseSystemdSupervisor()) {
     try {
-      return spawnSystemdRunner(name, command, cwd, env, logFile);
+      return await spawnSystemdRunner(name, command, cwd, env, logFile);
     } catch (error) {
       console.error(`[orchestrator] systemd runner supervisor unavailable for ${name}: ${errMessage(error)}`);
       console.error("[orchestrator] Falling back to process child; this agent will not survive orchestrator service restart.");
@@ -44,32 +45,24 @@ export function spawnRunner(name: string, command: string[], cwd: string, env: R
   }
 }
 
-function shouldUseSystemdSupervisor(): boolean {
+async function shouldUseSystemdSupervisor(): Promise<boolean> {
   if (process.platform !== "linux") return false;
   if (disableSystemdSupervisor()) return false;
   if (forceSystemdSupervisor()) return true;
-  const result = Bun.spawnSync(["systemctl", "--user", "show-environment"], {
-    stdin: "ignore",
-    stdout: "ignore",
-    stderr: "ignore",
-  });
-  return result.exitCode === 0;
+  const result = await execProcess(["systemctl", "--user", "show-environment"], { stdout: "ignore", stderr: "ignore" });
+  return result.ok;
 }
 
-function spawnSystemdRunner(name: string, command: string[], cwd: string, env: Record<string, string>, logFile: string): SpawnedRunner {
+async function spawnSystemdRunner(name: string, command: string[], cwd: string, env: Record<string, string>, logFile: string): Promise<SpawnedRunner> {
   const unit = systemdUnitName(name);
   const launchScript = launchScriptPath(name);
   ensureSessionDir();
   writeFileSync(launchScript, buildLaunchScript(command, cwd, env), { mode: 0o700 });
   chmodSync(launchScript, 0o700);
 
-  Bun.spawnSync(["systemctl", "--user", "stop", `${unit}.service`], {
-    stdin: "ignore",
-    stdout: "ignore",
-    stderr: "ignore",
-  });
+  await execProcess(["systemctl", "--user", "stop", `${unit}.service`], { stdout: "ignore", stderr: "ignore" });
 
-  const result = Bun.spawnSync([
+  const result = await execProcess([
     "systemd-run",
     "--user",
     `--unit=${unit}`,
@@ -78,17 +71,12 @@ function spawnSystemdRunner(name: string, command: string[], cwd: string, env: R
     `--property=StandardOutput=append:${logFile}`,
     `--property=StandardError=append:${logFile}`,
     launchScript,
-  ], {
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-  if (result.exitCode !== 0) {
-    const stderr = result.stderr.toString().trim();
-    throw new Error(stderr || `systemd-run failed with exit code ${result.exitCode}`);
+  ]);
+  if (!result.ok) {
+    throw new Error(result.stderr || `systemd-run failed with exit code ${result.exitCode}`);
   }
 
-  const pid = waitForSystemdMainPid(unit, 2_000);
+  const pid = await waitForSystemdMainPid(unit, 2_000);
   if (!pid) throw new Error(`systemd unit ${unit}.service started without a MainPID`);
   return { pid, supervisor: { type: "systemd", unit, launchScript } };
 }
@@ -113,12 +101,12 @@ export function buildLaunchScript(command: string[], cwd: string, env: Record<st
   ].join("\n");
 }
 
-function waitForSystemdMainPid(unit: string, timeoutMs: number): number {
+async function waitForSystemdMainPid(unit: string, timeoutMs: number): Promise<number> {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
-    const pid = systemdMainPid(unit);
+    const pid = await systemdMainPidAsync(unit);
     if (pid > 0 && isPidAlive(pid)) return pid;
-    Bun.sleepSync(50);
+    await Bun.sleep(50);
   }
   return 0;
 }

package/src/spawn/systemd.ts

@@ -1,5 +1,6 @@
 import { sanitizeFsName } from "agent-relay-sdk/fs-name";
 import { isPidAlive } from "agent-relay-sdk/process-utils";
+import { execProcess } from "../process";
 
 export type SystemdUnitLiveness = "alive" | "dead" | "unknown";
 
@@ -57,6 +58,40 @@ export function systemdUnitDiagnostics(unit: string): SystemdUnitDiagnostics {
   };
 }
 
+export async function systemdUnitDiagnosticsAsync(unit: string): Promise<SystemdUnitDiagnostics> {
+  const result = await execProcess([
+    "systemctl", "--user", "show", `${unit}.service`,
+    "-p", "ActiveState",
+    "-p", "SubState",
+    "-p", "Result",
+    "-p", "ExecMainCode",
+    "-p", "ExecMainStatus",
+    "-p", "MainPID",
+  ]);
+  if (!result.ok) {
+    return {
+      unit,
+      unavailable: result.stderr || `systemctl show exited with ${result.exitCode}`,
+    };
+  }
+  const props = new Map<string, string>();
+  for (const line of result.stdout.split("\n")) {
+    const index = line.indexOf("=");
+    if (index <= 0) continue;
+    props.set(line.slice(0, index), line.slice(index + 1));
+  }
+  const mainPid = Number(props.get("MainPID"));
+  return {
+    unit,
+    activeState: props.get("ActiveState") || undefined,
+    subState: props.get("SubState") || undefined,
+    result: props.get("Result") || undefined,
+    execMainCode: props.get("ExecMainCode") || undefined,
+    execMainStatus: props.get("ExecMainStatus") || undefined,
+    mainPid: Number.isFinite(mainPid) && mainPid > 0 ? mainPid : undefined,
+  };
+}
+
 export function systemdUnitLivenessFromDiagnostics(
   diagnostics: SystemdUnitDiagnostics,
   isAlive: (pid: number) => boolean,
@@ -82,3 +117,7 @@ export function systemdUnitLiveness(unit: string): SystemdUnitLiveness {
 export function systemdMainPid(unit: string): number {
   return systemdUnitDiagnostics(unit).mainPid ?? 0;
 }
+
+export async function systemdMainPidAsync(unit: string): Promise<number> {
+  return (await systemdUnitDiagnosticsAsync(unit)).mainPid ?? 0;
+}