agent-relay-orchestrator 0.37.0 → 0.39.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.37.0",
+  "version": "0.39.0",
   "description": "Agent Relay orchestrator — manages agent lifecycle across hosts",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.22"
+    "agent-relay-sdk": "0.2.24"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/control.ts

@@ -4,6 +4,7 @@ import type { ManagedAgentReport, RelayClient, RelayCommand } from "./relay";
 import { handleSelfUpgrade } from "./self-upgrade";
 import { spawnAgent, stopSession, type SpawnOptions } from "./spawn";
 import { cleanupWorkspace, mergeWorkspace, pruneWorktrees, reconcileWorkspace, refreshWorkspaceDeps, workspacesRoot } from "./workspace-probe";
+import { armWorkspacePrAutoMerge } from "./workspace-pr";
 
 interface ControlHandler {
   handleCommand(command: RelayCommand): Promise<boolean>;
@@ -120,8 +121,20 @@ export function createControlHandler(
           push: command.params.push !== false,
           prTitle: typeof command.params.prTitle === "string" ? command.params.prTitle : undefined,
           prBody: typeof command.params.prBody === "string" ? command.params.prBody : undefined,
+          autoMerge: command.params.autoMerge === "on-green" || command.params.autoMerge === "on-approval" || command.params.autoMerge === "manual" ? command.params.autoMerge : undefined,
         });
         await relay.updateCommand(command.id, "succeeded", result as unknown as Record<string, unknown>);
+      } else if (command.type === "workspace.pr-arm-auto-merge") {
+        const rawPrNumber = command.params.prNumber;
+        const result = 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,
+          branch: typeof command.params.branch === "string" ? command.params.branch : undefined,
+          prNumber: typeof rawPrNumber === "number" && Number.isSafeInteger(rawPrNumber) ? rawPrNumber : undefined,
+          prUrl: typeof command.params.prUrl === "string" ? command.params.prUrl : undefined,
+        });
+        await relay.updateCommand(command.id, result.autoMergeArmed ? "succeeded" : "failed", result as unknown as Record<string, unknown>, result.error);
       } else if (command.type === "workspace.deps-refresh") {
         const result = refreshWorkspaceDeps(
           typeof command.params.repoRoot === "string" ? command.params.repoRoot : "",

package/src/spawn.ts

@@ -6,7 +6,7 @@ import type { OrchestratorConfig } from "./config";
 import type { ManagedAgentReport, ManagedSessionExitDiagnostics } from "./relay";
 import { resolveSpawnWorkspace, workspacesRoot } from "./workspace-probe";
 import type { WorkspaceMetadata, WorkspaceMode } from "agent-relay-sdk";
-import { errMessage } from "agent-relay-sdk";
+import { errMessage, extractClaudeModelUnavailableMessage } from "agent-relay-sdk";
 import { isPidAlive, parseProcStateIsZombie } from "agent-relay-sdk/process-utils";
 import { shellEscape } from "agent-relay-sdk/shell-utils";
 import { tmuxCommand, tmuxHasSession } from "agent-relay-sdk/tmux-utils";
@@ -890,6 +890,10 @@ function logFileDiagnostics(logFile: string): Pick<ManagedSessionExitDiagnostics
 }
 
 function describeSessionExit(record: SessionRecord, diagnostics: Omit<ManagedSessionExitDiagnostics, "lastError">): string {
+  if (record.provider === "claude") {
+    const modelUnavailable = extractClaudeModelUnavailableMessage((diagnostics.logTail ?? []).join("\n"));
+    if (modelUnavailable) return modelUnavailable;
+  }
   const seconds = Math.max(0, Math.round(diagnostics.runtimeMs / 1000));
   const parts = [`managed ${record.provider} session ${record.name} exited after ${seconds}s`];
   if (diagnostics.systemd?.unavailable) {
@@ -1104,7 +1108,7 @@ export function captureSessionMirror(
   // The mirror log lives in the same directory as the provider log (both written
   // by the same user on this host). Derive from the record's logFile when known so
   // it tracks any per-session log relocation.
-  const logDir = record?.logFile ? dirname(record.logFile) : LOG_DIR;
+  const logDir = record?.logFile ? dirname(record.logFile) : process.env.AGENT_RELAY_LOG_DIR || LOG_DIR;
   const mirrorPath = join(logDir, `session-mirror-${safeMirrorLogName(agentId)}.log`);
   let content: string;
   try {

package/src/workspace-pr.ts

@@ -0,0 +1,85 @@
+import { resolve } from "node:path";
+
+type PrReviewDecision = "APPROVED" | "CHANGES_REQUESTED" | "REVIEW_REQUIRED";
+
+interface PullRequestState {
+  state: "merged" | "open";
+  url?: string;
+  sha?: string;
+  number?: number;
+  reviewDecision?: PrReviewDecision;
+  statusCheckRollup?: unknown[];
+}
+
+function prReviewDecision(value: unknown): PrReviewDecision | undefined {
+  return value === "APPROVED" || value === "CHANGES_REQUESTED" || value === "REVIEW_REQUIRED" ? value : undefined;
+}
+
+export function prMergedState(cwd: string, branch: string | undefined): PullRequestState | undefined {
+  if (!branch) return undefined;
+  const proc = Bun.spawnSync(["gh", "pr", "view", branch, "--json", "state,url,mergeCommit,number,reviewDecision,statusCheckRollup"], {
+    cwd,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+    env: process.env,
+  });
+  if (proc.exitCode !== 0) return undefined;
+  try {
+    const data = JSON.parse(proc.stdout.toString()) as {
+      state?: string;
+      url?: string;
+      mergeCommit?: { oid?: string } | null;
+      number?: number;
+      reviewDecision?: unknown;
+      statusCheckRollup?: unknown;
+    };
+    if (!data.state) return undefined;
+    const sha = data.mergeCommit?.oid;
+    const number = typeof data.number === "number" && Number.isSafeInteger(data.number) ? data.number : undefined;
+    const reviewDecision = prReviewDecision(data.reviewDecision);
+    const statusCheckRollup = Array.isArray(data.statusCheckRollup) ? data.statusCheckRollup : undefined;
+    return {
+      state: data.state === "MERGED" ? "merged" : "open",
+      url: data.url,
+      ...(sha ? { sha } : {}),
+      ...(number ? { number } : {}),
+      ...(reviewDecision ? { reviewDecision } : {}),
+      ...(statusCheckRollup ? { statusCheckRollup } : {}),
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+export function armWorkspacePrAutoMerge(input: {
+  id?: string;
+  repoRoot?: string;
+  worktreePath?: string;
+  branch?: string;
+  prNumber?: number;
+  prUrl?: string;
+}): { workspaceId?: string; status: "merge_planned"; autoMergeArmed: boolean; prNumber?: number; prUrl?: string; error?: string } {
+  const cwd = input.worktreePath ? resolve(input.worktreePath) : input.repoRoot ? resolve(input.repoRoot) : undefined;
+  if (!cwd) return { workspaceId: input.id, status: "merge_planned", autoMergeArmed: false, error: "worktreePath or repoRoot required" };
+  const target = input.prNumber ? String(input.prNumber) : input.prUrl ?? input.branch;
+  if (!target) return { workspaceId: input.id, status: "merge_planned", autoMergeArmed: false, error: "prNumber, prUrl, or branch required" };
+  const proc = Bun.spawnSync(["gh", "pr", "merge", target, "--auto", "--merge"], {
+    cwd,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+    env: process.env,
+  });
+  if (proc.exitCode !== 0) {
+    return {
+      workspaceId: input.id,
+      status: "merge_planned",
+      autoMergeArmed: false,
+      prNumber: input.prNumber,
+      prUrl: input.prUrl,
+      error: proc.stderr.toString().trim() || proc.stdout.toString().trim() || "gh pr merge failed",
+    };
+  }
+  return { workspaceId: input.id, status: "merge_planned", autoMergeArmed: true, prNumber: input.prNumber, prUrl: input.prUrl };
+}

package/src/workspace-probe.ts

@@ -6,6 +6,7 @@ import type { WorkspaceDepsProvision, WorkspaceDepsRefreshDir, WorkspaceDepsRefr
 import { errMessage } from "agent-relay-sdk";
 import { sanitizeFsName } from "agent-relay-sdk/fs-name";
 import { git, requireGit } from "./git";
+import { prMergedState } from "./workspace-pr";
 
 const MAX_DIFF_PATCH_BYTES = 200_000;
 
@@ -715,6 +716,11 @@ interface WorkspaceMergeInput {
   push?: boolean;
   prTitle?: string;
   prBody?: string;
+  /** Auto-merge policy for pr-strategy lands (#305).
+   *  - "on-green": arm GitHub auto-merge after PR creation (default).
+   *  - "on-approval": open PR, do NOT arm; reviewer pipeline arms it later.
+   *  - "manual": open PR, do NOT arm (today's legacy behavior). */
+  autoMerge?: "on-green" | "on-approval" | "manual";
 }
 
 /** Behind-count of HEAD relative to `base`, from inside `worktreePath`. */
@@ -742,25 +748,6 @@ function ghAvailable(): boolean {
  * Returns undefined when there's no PR, no branch, or gh fails —
  * we never invent a merge.
  */
-function prMergedState(cwd: string, branch: string | undefined): { state: "merged" | "open"; url?: string; sha?: string } | undefined {
-  if (!branch) return undefined;
-  const proc = Bun.spawnSync(["gh", "pr", "view", branch, "--json", "state,url,mergeCommit"], {
-    cwd,
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-  if (proc.exitCode !== 0) return undefined; // no PR for the branch, or gh unavailable/unauthed
-  try {
-    const data = JSON.parse(proc.stdout.toString()) as { state?: string; url?: string; mergeCommit?: { oid?: string } | null };
-    if (!data.state) return undefined;
-    const sha = data.mergeCommit?.oid;
-    return { state: data.state === "MERGED" ? "merged" : "open", url: data.url, ...(sha ? { sha } : {}) };
-  } catch {
-    return undefined;
-  }
-}
-
 /**
  * Predict whether merging the branch's commits into base would conflict, using
  * git's three-way merge-tree (no working-tree changes). Exit 0 = clean, exit 1
@@ -798,6 +785,9 @@ function applyPrMergeState(base: WorkspaceMergePreview, cwd: string, branch: str
   if (!pr) return false;
   base.prState = pr.state;
   if (pr.url) base.prUrl = pr.url;
+  if (pr.number) base.prNumber = pr.number;
+  if (pr.reviewDecision) base.reviewDecision = pr.reviewDecision;
+  if (pr.statusCheckRollup) base.statusCheckRollup = pr.statusCheckRollup;
   if (pr.state !== "merged") return false;
   base.prMerged = true;
   if (pr.sha) base.prMergeSha = pr.sha;
@@ -913,7 +903,12 @@ export function mergeWorkspace(input: WorkspaceMergeInput): 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;
-  const branch = input.branch ?? shortBranch(git(["symbolic-ref", "--quiet", "--short", "HEAD"], worktreePath).stdout || undefined);
+  // Probe the live HEAD branch first — it's the authoritative source. Fall back to the
+  // DB-recorded branch only when the live probe fails (detached HEAD, missing worktree, etc.).
+  // This fixes #232: a stale DB branch value (non-null mismatch) would pass through the
+  // `input.branch ?? ...` guard unchanged and cause git to attempt merging a non-existent ref.
+  const liveBranch = shortBranch(git(["symbolic-ref", "--quiet", "--short", "HEAD"], worktreePath).stdout || undefined);
+  const branch = liveBranch ?? input.branch;
   const preview = previewWorkspaceMerge({ worktreePath, baseRef: input.baseRef, baseSha: input.baseSha, strategy: input.strategy });
   const strategy = preview.strategy;
   const head = (field: Partial<WorkspaceMergeResult>): WorkspaceMergeResult => ({ workspaceId: input.id, strategy, merged: false, status: "review_requested", branch, baseRef: preview.baseRef, ...field });
@@ -995,15 +990,45 @@ function mergePr(
   const body = input.prBody || `Automated PR for agent workspace branch \`${branch}\`.`;
   const args = ["pr", "create", "--head", branch, "--title", title, "--body", body];
   if (base) args.push("--base", base);
-  const proc = Bun.spawnSync(["gh", ...args], { cwd: worktreePath, stdin: "ignore", stdout: "pipe", stderr: "pipe" });
+  // Pass process.env explicitly so runtime env mutations (e.g. test PATH injection)
+  // are visible to the child process.  Bun's default is the startup-time env snapshot.
+  const proc = Bun.spawnSync(["gh", ...args], { cwd: worktreePath, stdin: "ignore", stdout: "pipe", stderr: "pipe", env: process.env });
   const stdout = proc.stdout.toString().trim();
   if (proc.exitCode !== 0) {
     return head({ status: "review_requested", error: proc.stderr.toString().trim() || "gh pr create failed" });
   }
   const prUrl = stdout.split("\n").map((line) => line.trim()).find((line) => /^https?:\/\//.test(line));
-  // PR opened: work is on its way out but not landed. Keep the worktree/branch
-  // alive for the PR; record the plan with the URL.
-  return head({ status: "merge_planned", prUrl, error: undefined });
+
+  // Auto-merge policy (#305). Treat absent as "on-green" so new lands always terminate.
+  const autoMerge = input.autoMerge ?? "on-green";
+
+  if (autoMerge === "on-approval") {
+    // Reviewer pipeline arms auto-merge later — don't arm here.
+    return head({ status: "merge_planned", prUrl, awaitingApproval: true, error: undefined });
+  }
+
+  if (autoMerge === "manual") {
+    // Legacy behavior: open the PR and stop — a human merges.
+    return head({ status: "merge_planned", prUrl, error: undefined });
+  }
+
+  // "on-green" (default): arm GitHub auto-merge. Use --merge (repo's merge style).
+  // Never throw — if arming fails (repo has auto-merge disabled) we still return
+  // merge_planned so the relay reconcile scan can finalize when the PR merges.
+  const mergeTarget = prUrl ?? branch!;
+  const armProc = Bun.spawnSync(["gh", "pr", "merge", mergeTarget, "--auto", "--merge"], {
+    cwd: worktreePath,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+    env: process.env,
+  });
+  if (armProc.exitCode !== 0) {
+    // Arm failed (e.g. repo has auto-merge disabled) — return merge_planned so the
+    // reconcile scan still finalizes when the PR is merged by a human.
+    return head({ status: "merge_planned", prUrl, autoMergeArmed: false, error: undefined });
+  }
+  return head({ status: "merge_planned", prUrl, autoMergeArmed: true, error: undefined });
 }
 
 // Identity stamped on the merge commit a no-ff land records (#287). The merge is a