agent-relay-orchestrator 0.120.0 → 0.120.1

package/package.json

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

package/src/spawn/supervisor.ts

@@ -1,4 +1,4 @@
-import { chmodSync, closeSync, existsSync, openSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import type { OrchestratorConfig } from "../config";
 import type { ManagedSessionExitDiagnostics } from "../relay";
@@ -15,26 +15,33 @@ import { systemdMainPidAsync, systemdUnitDiagnostics, systemdUnitName } from "./
 import type { SessionRecord, SessionSupervisor, SpawnedRunner } from "./types";
 import { execProcess } from "../process";
 
+const FILE_BACKED_ENV_PAYLOADS = new Map<string, string>([
+  ["AGENT_RELAY_AGENT_PROFILE_JSON", "agent-profile.json"],
+  ["AGENT_RELAY_WORKSPACE_JSON", "workspace.json"],
+  ["AGENT_RELAY_INJECTION_EVENTS_JSON", "relay-injection-events.json"],
+]);
+
 export async function spawnRunner(name: string, command: string[], cwd: string, env: Record<string, string>, logFile: string): Promise<SpawnedRunner> {
+  const launchScript = launchScriptPath(name);
+  const launch = materializeLaunchPayload(launchScript, command, env);
   if (await shouldUseSystemdSupervisor()) {
     try {
-      return await spawnSystemdRunner(name, command, cwd, env, logFile);
+      return await spawnSystemdRunner(name, launch.command, cwd, launch.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.");
     }
   }
 
-  const launchScript = launchScriptPath(name);
   ensureSessionDir();
-  writeFileSync(launchScript, buildLaunchScript(command, cwd, env), { mode: 0o700 });
+  writeFileSync(launchScript, buildLaunchScript(launch.command, cwd, launch.env), { mode: 0o700 });
   chmodSync(launchScript, 0o700);
 
   const logFd = openSync(logFile, "a");
   try {
     const proc = Bun.spawn([launchScript], {
       cwd,
-      env,
+      env: launch.env,
       stdin: "ignore",
       stdout: logFd,
       stderr: logFd,
@@ -86,6 +93,47 @@ function launchScriptPath(session: string): string {
   return join(SESSION_DIR, `${safe}.sh`);
 }
 
+function launchPayloadDirPath(launchScript: string): string {
+  return `${launchScript}.d`;
+}
+
+function payloadFilePath(launchScript: string, filename: string): string {
+  return join(launchPayloadDirPath(launchScript), filename);
+}
+
+function materializeEnvPayload(env: Record<string, string>, launchScript: string): Record<string, string> {
+  const nextEnv = { ...env };
+  for (const [envKey, filename] of FILE_BACKED_ENV_PAYLOADS) {
+    const value = nextEnv[envKey];
+    if (typeof value !== "string" || value.length === 0) continue;
+    const filePath = payloadFilePath(launchScript, filename);
+    mkdirSync(launchPayloadDirPath(launchScript), { recursive: true });
+    writeFileSync(filePath, value);
+    delete nextEnv[envKey];
+    nextEnv[`${envKey}_FILE`] = filePath;
+  }
+  return nextEnv;
+}
+
+function materializeCommandArg(command: string[], env: Record<string, string>, launchScript: string, flag: string, envKey: string, filename: string): void {
+  const index = command.indexOf(flag);
+  if (index < 0 || !command[index + 1]) return;
+  const filePath = payloadFilePath(launchScript, filename);
+  mkdirSync(launchPayloadDirPath(launchScript), { recursive: true });
+  writeFileSync(filePath, command[index + 1]!);
+  command.splice(index, 2);
+  env[`${envKey}_FILE`] = filePath;
+}
+
+export function materializeLaunchPayload(launchScript: string, command: string[], env: Record<string, string>): { command: string[]; env: Record<string, string> } {
+  const nextCommand = [...command];
+  const nextEnv = materializeEnvPayload(env, launchScript);
+  materializeCommandArg(nextCommand, nextEnv, launchScript, "--prompt", "AGENT_RELAY_PROMPT", "prompt.txt");
+  materializeCommandArg(nextCommand, nextEnv, launchScript, "--system-prompt-append", "AGENT_RELAY_SYSTEM_PROMPT_APPEND", "system-prompt-append.txt");
+  materializeCommandArg(nextCommand, nextEnv, launchScript, "--append-system-prompt", "AGENT_RELAY_SYSTEM_PROMPT_APPEND", "system-prompt-append.txt");
+  return { command: nextCommand, env: nextEnv };
+}
+
 export function buildLaunchScript(command: string[], cwd: string, env: Record<string, string>): string {
   const exports = Object.entries(env)
     .filter(([key, value]) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(key) && value !== undefined)
@@ -252,7 +300,10 @@ function killSystemdUnit(unit: string): void {
 
 function cleanupSupervisor(supervisor: SessionSupervisor): void {
   if (supervisor.type === "systemd" && supervisor.unit) stopSystemdUnit(supervisor.unit);
-  if (supervisor.launchScript) rmSync(supervisor.launchScript, { force: true });
+  if (supervisor.launchScript) {
+    rmSync(supervisor.launchScript, { force: true });
+    rmSync(launchPayloadDirPath(supervisor.launchScript), { recursive: true, force: true });
+  }
 }
 
 export function cleanupSessionRecord(record: SessionRecord): void {

package/src/workspace-probe/probe.ts

@@ -91,7 +91,9 @@ export async function resolveSpawnWorkspace(input: WorkspaceResolutionInput): Pr
   if (input.resumeWorkspace?.mode === "branch-from") {
     const resume = input.resumeWorkspace;
     const repoRoot = probe.repoRoot;
-    const baseSha = await requireGit(["rev-parse", resume.branch], repoRoot);
+    const startSha = await requireGit(["rev-parse", resume.branch], repoRoot);
+    const baseRef = resume.baseRef ?? await terminalBaseRef(repoRoot, resume.branch);
+    const baseSha = resume.baseSha ?? (baseRef ? await requireGit(["rev-parse", baseRef], repoRoot) : undefined);
     const id = workspaceId(input);
     const workspaceRoot = input.workspaceRoot ? resolve(input.workspaceRoot) : workspacesRoot(homedir());
     const worktreePath = join(workspaceRoot, repoSlug(repoRoot), id);
@@ -103,7 +105,7 @@ export async function resolveSpawnWorkspace(input: WorkspaceResolutionInput): Pr
         sourceCwd,
         worktreePath,
         branch: existing.branch,
-        baseRef: resume.branch,
+        baseRef,
         baseSha,
         requestedMode,
         probe,
@@ -112,7 +114,7 @@ export async function resolveSpawnWorkspace(input: WorkspaceResolutionInput): Pr
 
     const branch = await availableBranch(repoRoot, branchName(input, id));
     mkdirSync(join(worktreePath, ".."), { recursive: true });
-    await requireGit(["worktree", "add", "-b", branch, worktreePath, baseSha], repoRoot);
+    await requireGit(["worktree", "add", "-b", branch, worktreePath, startSha], repoRoot);
     const deps = await provisionWorkspaceDeps(repoRoot, worktreePath);
     const symlinks = provisionWorkspaceSymlinks(repoRoot, worktreePath, input.workspaceSymlinks ?? []);
     return {
@@ -125,8 +127,8 @@ export async function resolveSpawnWorkspace(input: WorkspaceResolutionInput): Pr
         sourceCwd,
         worktreePath,
         branch,
-        baseRef: resume.branch,
-        baseSha,
+        ...(baseRef ? { baseRef } : {}),
+        ...(baseSha ? { baseSha } : {}),
         status: "active",
         deps,
         ...(symlinks.linked.length || symlinks.errors ? { symlinks } : {}),