agent-relay-orchestrator 0.113.0 → 0.115.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.113.0",
+  "version": "0.115.0",
   "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.96",
+    "agent-relay-sdk": "0.2.97",
     "callmux": "0.23.0"
   },
   "devDependencies": {

package/src/command-poller.ts

@@ -0,0 +1,43 @@
+import type { RelayClient, RelayCommand } from "./relay";
+
+interface CommandPollerControl {
+  handleCommand(command: RelayCommand): Promise<boolean>;
+}
+
+interface CommandPollerOptions {
+  relay: Pick<RelayClient, "connected" | "pollCommands">;
+  control: CommandPollerControl;
+  log?: (message: string) => void;
+}
+
+export function createCommandPoller({ relay, control, log = console.error }: CommandPollerOptions) {
+  let inFlight = false;
+
+  async function tick(): Promise<boolean> {
+    if (!relay.connected || inFlight) return false;
+    inFlight = true;
+    try {
+      const commands = await relay.pollCommands();
+      if (commands.length > 0) {
+        log(`[orchestrator] Received ${commands.length} command(s)`);
+      }
+      for (const command of commands) {
+        log(`[orchestrator] Handling command: ${command.type} ${command.id}`);
+        await control.handleCommand(command);
+      }
+      return true;
+    } catch (err) {
+      log(`[orchestrator] Poll error: ${err}`);
+      return false;
+    } finally {
+      inFlight = false;
+    }
+  }
+
+  return {
+    tick,
+    get inFlight() {
+      return inFlight;
+    },
+  };
+}

package/src/index.ts

@@ -12,6 +12,7 @@ import { sweepEmptyWorkspaceContainers, workspacesRoot } from "./workspace-probe
 import { startOrchestratorMaintenanceScheduler } from "./maintenance";
 import { OrchestratorQuotaPoller } from "./quota-poller";
 import { SharedCallmuxSupervisor } from "./shared-callmux";
+import { createCommandPoller } from "./command-poller";
 
 const args = process.argv.slice(2);
 
@@ -123,20 +124,9 @@ async function startup(): Promise<void> {
 }
 
 function startPolling(): void {
+  const commandPoller = createCommandPoller({ relay, control });
   pollTimer = setInterval(async () => {
-    if (!relay.connected) return;
-    try {
-      const commands = await relay.pollCommands();
-      if (commands.length > 0) {
-        console.error(`[orchestrator] Received ${commands.length} command(s)`);
-      }
-      for (const command of commands) {
-        console.error(`[orchestrator] Handling command: ${command.type} ${command.id}`);
-        await control.handleCommand(command);
-      }
-    } catch (err) {
-      console.error(`[orchestrator] Poll error: ${err}`);
-    }
+    await commandPoller.tick();
   }, POLL_INTERVAL_MS);
 }
 

package/src/shared-callmux.ts

@@ -313,11 +313,20 @@ function callmuxServerFromProvisioningVariant(value: unknown): { name: string; s
   const metadata = isRecord(definition.metadata) ? definition.metadata : {};
   const provenance = isRecord(value.provenance) ? value.provenance : {};
   if (metadata.sharedListenerEligible !== true && provenance.sharedListenerEligible !== true) return null;
-  const callmuxServer = isRecord(metadata.callmuxServer) ? metadata.callmuxServer : callmuxServerFromMcpServer(definition.server);
-  const server = cloneServer(callmuxServer);
+  const rawCallmuxServer = isRecord(metadata.callmuxServer) ? metadata.callmuxServer : callmuxServerFromMcpServer(definition.server);
+  const server = cloneServer(mergeConfigEnv(rawCallmuxServer));
   return server ? { name: value.name, server } : null;
 }
 
+function mergeConfigEnv(server: Record<string, unknown>): Record<string, unknown> {
+  if (!isRecord(server.configEnv)) return server;
+  const { configEnv, ...rest } = server;
+  return {
+    ...rest,
+    env: { ...(configEnv as Record<string, string>), ...(isRecord(rest.env) ? (rest.env as Record<string, string>) : {}) },
+  };
+}
+
 function callmuxServerFromMcpServer(server: Record<string, unknown>): Record<string, unknown> {
   const out: Record<string, unknown> = {};
   if (typeof server.command === "string") {

package/src/spawn/spawn-agent.ts

@@ -3,15 +3,45 @@ import type { OrchestratorConfig } from "../config";
 import { resolveSpawnWorkspace, workspacesRoot } from "../workspace-probe";
 import type { ManagedAgentReport } from "../relay";
 import { buildEnv, buildRunnerCommand, defaultSpawnLabel, isWithinBaseDir, sessionName } from "./command";
-import { addSessionRecord, ensureLogDir, ensureRunnerInfoDir, logFilePath, runnerInfoPath, sessionReportFields } from "./runtime";
+import { addSessionRecord, currentSessionPid, findSessionRecord, ensureLogDir, ensureRunnerInfoDir, logFilePath, runnerInfoPath, sessionRecordLiveness, sessionReportFields } from "./runtime";
 import { managedAgentId } from "./sessions";
 import { spawnRunner } from "./supervisor";
 import type { SpawnOptions } from "./types";
 
+interface SpawnAgentDeps {
+  resolveSpawnWorkspace: typeof resolveSpawnWorkspace;
+  spawnRunner: typeof spawnRunner;
+  addSessionRecord: typeof addSessionRecord;
+  findSessionRecord: typeof findSessionRecord;
+  sessionRecordLiveness: typeof sessionRecordLiveness;
+  currentSessionPid: typeof currentSessionPid;
+  sessionReportFields: typeof sessionReportFields;
+  ensureLogDir: typeof ensureLogDir;
+  ensureRunnerInfoDir: typeof ensureRunnerInfoDir;
+  logFilePath: typeof logFilePath;
+  runnerInfoPath: typeof runnerInfoPath;
+}
+
+const defaultSpawnAgentDeps: SpawnAgentDeps = {
+  resolveSpawnWorkspace,
+  spawnRunner,
+  addSessionRecord,
+  findSessionRecord,
+  sessionRecordLiveness,
+  currentSessionPid,
+  sessionReportFields,
+  ensureLogDir,
+  ensureRunnerInfoDir,
+  logFilePath,
+  runnerInfoPath,
+};
+
 export async function spawnAgent(
   opts: SpawnOptions,
   config: OrchestratorConfig,
+  deps: Partial<SpawnAgentDeps> = {},
 ): Promise<ManagedAgentReport> {
+  const d = { ...defaultSpawnAgentDeps, ...deps };
   const label = opts.label || defaultSpawnLabel();
   const agentId = opts.agentId || managedAgentId(config, opts.provider, label);
   const name = sessionName(config, opts.provider, label, opts.spawnRequestId ?? agentId);
@@ -22,21 +52,27 @@ export async function spawnAgent(
   if (!isWithinBaseDir(opts.cwd, config.baseDir)) {
     throw new Error(`cwd must be within base directory: ${config.baseDir}`);
   }
+  const existing = existingSpawnSession(opts, d);
+  if (existing) return existing;
 
-  const resolvedWorkspace = await resolveSpawnWorkspace({
+  const resolvedWorkspace = await d.resolveSpawnWorkspace({
     ...opts,
     label,
     workspaceSymlinks: opts.workspaceSymlinks,
     workspaceRoot: workspacesRoot(config.baseDir),
   });
+  if (resolvedWorkspace.reusedExisting) {
+    const existingAfterPrep = existingSpawnSession(opts, d);
+    if (existingAfterPrep) return existingAfterPrep;
+  }
   const spawnOpts = { ...opts, label, agentId, cwd: resolvedWorkspace.cwd, workspace: resolvedWorkspace.workspace };
 
   const command = buildRunnerCommand(spawnOpts, config);
 
-  ensureLogDir();
-  ensureRunnerInfoDir();
-  const logFile = logFilePath(name);
-  const runnerInfoFile = runnerInfoPath(name);
+  d.ensureLogDir();
+  d.ensureRunnerInfoDir();
+  const logFile = d.logFilePath(name);
+  const runnerInfoFile = d.runnerInfoPath(name);
   rmSync(runnerInfoFile, { force: true });
   const env = buildEnv({ ...spawnOpts, env: { ...(spawnOpts.env ?? {}), AGENT_RELAY_RUNNER_INFO_FILE: runnerInfoFile } }, config, logFile, name);
   const logFd = openSync(logFile, "w");
@@ -48,9 +84,9 @@ export async function spawnAgent(
 
   closeSync(logFd);
 
-  const runner = spawnRunner(name, command, spawnOpts.cwd, env, logFile);
+  const runner = d.spawnRunner(name, command, spawnOpts.cwd, env, logFile);
 
-  addSessionRecord({
+  d.addSessionRecord({
     name,
     pid: runner.pid,
     supervisor: runner.supervisor,
@@ -81,7 +117,7 @@ export async function spawnAgent(
     profile: spawnOpts.profile,
     workspaceMode: spawnOpts.workspaceMode, lifecycle: spawnOpts.lifecycle ?? "persistent",
     workspace: spawnOpts.workspace,
-    ...sessionReportFields({ name, supervisor: runner.supervisor, runnerInfoFile, agentId, provider: spawnOpts.provider }),
+    ...d.sessionReportFields({ name, supervisor: runner.supervisor, runnerInfoFile, agentId, provider: spawnOpts.provider }),
     cwd: spawnOpts.cwd,
     label,
     approvalMode: spawnOpts.approvalMode || "guarded",
@@ -92,3 +128,33 @@ export async function spawnAgent(
     startedAt: Date.now(),
   };
 }
+
+function existingSpawnSession(opts: SpawnOptions, deps: Pick<SpawnAgentDeps, "findSessionRecord" | "sessionRecordLiveness" | "currentSessionPid" | "sessionReportFields">): ManagedAgentReport | undefined {
+  if (!opts.spawnRequestId) return undefined;
+  const record = deps.findSessionRecord({ spawnRequestId: opts.spawnRequestId, policyName: opts.policyName });
+  if (!record) return undefined;
+  const liveness = deps.sessionRecordLiveness(record);
+  if (liveness === "dead") return undefined;
+  const pid = deps.currentSessionPid(record);
+  return {
+    agentId: record.agentId,
+    provider: record.provider as ManagedAgentReport["provider"],
+    model: record.model,
+    effort: record.effort,
+    profile: record.profile,
+    workspaceMode: record.workspaceMode,
+    lifecycle: record.lifecycle ?? "persistent",
+    workspace: record.workspace,
+    ...deps.sessionReportFields(record),
+    cwd: record.cwd,
+    label: record.label,
+    approvalMode: record.approvalMode || "guarded",
+    policyName: record.policyName,
+    spawnRequestId: record.spawnRequestId,
+    automationRunId: record.automationRunId,
+    pid,
+    startedAt: record.startedAt,
+  };
+}
+
+export type { SpawnAgentDeps };

package/src/workspace-probe/probe.ts

@@ -91,9 +91,24 @@ export async function resolveSpawnWorkspace(input: WorkspaceResolutionInput): Pr
     const repoRoot = probe.repoRoot;
     const baseSha = requireGit(["rev-parse", resume.branch], repoRoot);
     const id = workspaceId(input);
-    const branch = await availableBranch(repoRoot, branchName(input, id));
     const workspaceRoot = input.workspaceRoot ? resolve(input.workspaceRoot) : workspacesRoot(homedir());
     const worktreePath = join(workspaceRoot, repoSlug(repoRoot), id);
+    const existing = existingRegisteredWorktree(repoRoot, worktreePath);
+    if (existing) {
+      return existingWorkspaceResolution({
+        id,
+        repoRoot,
+        sourceCwd,
+        worktreePath,
+        branch: existing.branch,
+        baseRef: resume.branch,
+        baseSha,
+        requestedMode,
+        probe,
+      });
+    }
+
+    const branch = await availableBranch(repoRoot, branchName(input, id));
     mkdirSync(join(worktreePath, ".."), { recursive: true });
     requireGit(["worktree", "add", "-b", branch, worktreePath, baseSha], repoRoot);
     const deps = provisionWorkspaceDeps(repoRoot, worktreePath);
@@ -122,9 +137,24 @@ export async function resolveSpawnWorkspace(input: WorkspaceResolutionInput): Pr
   const repoRoot = probe.repoRoot;
   const baseRef = terminalBaseRef(repoRoot, probe.branch);
   const baseSha = probe.headSha ?? requireGit(["rev-parse", "HEAD"], repoRoot);
-  const branch = await availableBranch(repoRoot, branchName(input, id));
   const workspaceRoot = input.workspaceRoot ? resolve(input.workspaceRoot) : workspacesRoot(homedir());
   const worktreePath = join(workspaceRoot, repoSlug(repoRoot), id);
+  const existing = existingRegisteredWorktree(repoRoot, worktreePath);
+  if (existing) {
+    return existingWorkspaceResolution({
+      id,
+      repoRoot,
+      sourceCwd,
+      worktreePath,
+      branch: existing.branch,
+      baseRef,
+      baseSha,
+      requestedMode,
+      probe,
+    });
+  }
+
+  const branch = await availableBranch(repoRoot, branchName(input, id));
   mkdirSync(join(worktreePath, ".."), { recursive: true });
   requireGit(["worktree", "add", "-b", branch, worktreePath, baseSha], repoRoot);
 
@@ -156,3 +186,45 @@ export async function resolveSpawnWorkspace(input: WorkspaceResolutionInput): Pr
     },
   };
 }
+
+function existingRegisteredWorktree(repoRoot: string, worktreePath: string): { branch?: string } | undefined {
+  const resolvedPath = resolve(worktreePath);
+  if (!existsSync(resolvedPath)) return undefined;
+  const listed = git(["worktree", "list", "--porcelain"], repoRoot);
+  if (!listed.ok) return undefined;
+  const match = parseWorktrees(listed.stdout).find((worktree) => resolve(worktree.path) === resolvedPath);
+  if (!match) return undefined;
+  const topLevel = git(["rev-parse", "--show-toplevel"], resolvedPath);
+  if (!topLevel.ok || resolve(topLevel.stdout) !== resolvedPath) return undefined;
+  return { branch: match.branch };
+}
+
+function existingWorkspaceResolution(input: {
+  id: string;
+  repoRoot: string;
+  sourceCwd: string;
+  worktreePath: string;
+  branch?: string;
+  baseRef?: string;
+  baseSha?: string;
+  requestedMode: WorkspaceMode | "inherit";
+  probe: WorkspaceProbe;
+}): WorkspaceResolution {
+  return {
+    cwd: input.worktreePath,
+    reusedExisting: true,
+    workspace: {
+      id: input.id,
+      mode: "isolated",
+      requestedMode: input.requestedMode,
+      repoRoot: input.repoRoot,
+      sourceCwd: input.sourceCwd,
+      worktreePath: input.worktreePath,
+      ...(input.branch ? { branch: input.branch } : {}),
+      ...(input.baseRef ? { baseRef: input.baseRef } : {}),
+      ...(input.baseSha ? { baseSha: input.baseSha } : {}),
+      status: "active",
+      probe: input.probe,
+    },
+  };
+}

package/src/workspace-probe/types.ts

@@ -33,6 +33,7 @@ export interface WorkspaceResolutionInput {
 export interface WorkspaceResolution {
   cwd: string;
   workspace: WorkspaceMetadata;
+  reusedExisting?: boolean;
 }
 
 export interface WorkspaceMergeInput {