agent-relay-orchestrator 0.58.0 → 0.59.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.58.0",
+  "version": "0.59.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.34"
+    "agent-relay-sdk": "0.2.35"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/control.ts

@@ -122,6 +122,12 @@ export function createControlHandler(
           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,
+          prLanded: isRecord(command.params.prLanded)
+            ? {
+                sha: typeof command.params.prLanded.sha === "string" ? command.params.prLanded.sha : undefined,
+                subject: typeof command.params.prLanded.subject === "string" ? command.params.prLanded.subject : undefined,
+              }
+            : undefined,
         });
         await relay.updateCommand(command.id, "succeeded", result as unknown as Record<string, unknown>);
       } else if (command.type === "workspace.pr-arm-auto-merge") {

package/src/workspace-pr.ts

@@ -7,6 +7,7 @@ interface PullRequestState {
   url?: string;
   sha?: string;
   number?: number;
+  title?: string;
   reviewDecision?: PrReviewDecision;
   statusCheckRollup?: unknown[];
   mergeable?: string;
@@ -19,7 +20,7 @@ function prReviewDecision(value: unknown): PrReviewDecision | 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,mergeable,mergeStateStatus"], {
+  const proc = Bun.spawnSync(["gh", "pr", "view", branch, "--json", "state,url,mergeCommit,number,title,reviewDecision,statusCheckRollup,mergeable,mergeStateStatus"], {
     cwd,
     stdin: "ignore",
     stdout: "pipe",
@@ -33,6 +34,7 @@ export function prMergedState(cwd: string, branch: string | undefined): PullRequ
       url?: string;
       mergeCommit?: { oid?: string } | null;
       number?: number;
+      title?: unknown;
       reviewDecision?: unknown;
       statusCheckRollup?: unknown;
       mergeable?: unknown;
@@ -41,6 +43,7 @@ export function prMergedState(cwd: string, branch: string | undefined): PullRequ
     if (!data.state) return undefined;
     const sha = data.mergeCommit?.oid;
     const number = typeof data.number === "number" && Number.isSafeInteger(data.number) ? data.number : undefined;
+    const title = typeof data.title === "string" && data.title.trim() ? data.title.trim() : undefined;
     const reviewDecision = prReviewDecision(data.reviewDecision);
     const statusCheckRollup = Array.isArray(data.statusCheckRollup) ? data.statusCheckRollup : undefined;
     const mergeable = typeof data.mergeable === "string" ? data.mergeable : undefined;
@@ -50,6 +53,7 @@ export function prMergedState(cwd: string, branch: string | undefined): PullRequ
       url: data.url,
       ...(sha ? { sha } : {}),
       ...(number ? { number } : {}),
+      ...(title ? { title } : {}),
       ...(reviewDecision ? { reviewDecision } : {}),
       ...(statusCheckRollup ? { statusCheckRollup } : {}),
       ...(mergeable ? { mergeable } : {}),

package/src/workspace-probe.ts

@@ -599,6 +599,25 @@ function upstreamRef(worktreePath: string, base: string): string | undefined {
   return res.ok && res.stdout ? res.stdout : undefined;
 }
 
+/**
+ * Best-effort fetch of `base`'s upstream and return the ref to cut a recycled branch from.
+ * Used by the #423 PR-land recycle: a squash merge lands on ORIGIN while the worktree's local
+ * base is never advanced, so cutting from local base would recycle onto stale main. Fetching
+ * the upstream and returning `origin/<base>` (when it resolves) yields a branch off CURRENT
+ * base. Falls back to the local base ref when there is no upstream (no remote) or the
+ * upstream ref can't be resolved — the caller still verifies it contains the merge SHA.
+ */
+function syncBaseFromOrigin(worktreePath: string, base: string | undefined): string | undefined {
+  if (!base) return undefined;
+  const upstream = upstreamRef(worktreePath, base);
+  if (!upstream) return base;
+  const slash = upstream.indexOf("/");
+  const remote = slash > 0 ? upstream.slice(0, slash) : undefined;
+  const remoteBranch = slash > 0 ? upstream.slice(slash + 1) : base;
+  if (remote) git(["fetch", remote, remoteBranch], worktreePath); // best-effort freshness
+  return git(["rev-parse", "--verify", "--quiet", upstream], worktreePath).ok ? upstream : base;
+}
+
 function resolveBaseRef(worktreePath: string, baseRef?: string, baseSha?: string): string | undefined {
   for (const candidate of [baseRef, baseSha]) {
     if (candidate && git(["rev-parse", "--verify", "--quiet", `${candidate}^{commit}`], worktreePath).ok) {
@@ -721,6 +740,15 @@ interface WorkspaceMergeInput {
    *  - "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";
+  /**
+   * Set when the relay observed this branch's PR already merged on the remote and is
+   * dispatching a land-and-continue RECYCLE (#423). Carries the relay's ground truth (the
+   * merge SHA/subject). Its presence forces the live-owner recycle even when local git can't
+   * see the landing — a squash onto an advanced base re-creates the work as a new commit
+   * (patch ids drift, trees diverge) so `previewWorkspaceMerge` reports ahead>0 and would
+   * otherwise loop via review_requested. prMerged is monotonic and was read from THIS host's
+   * own `checkPr` scan, so trusting it is safe; we still refuse on a dirty tree. */
+  prLanded?: { sha?: string; subject?: string };
 }
 
 /** Behind-count of HEAD relative to `base`, from inside `worktreePath`. */
@@ -791,6 +819,7 @@ function applyPrMergeState(base: WorkspaceMergePreview, cwd: string, branch: str
   if (pr.state !== "merged") return false;
   base.prMerged = true;
   if (pr.sha) base.prMergeSha = pr.sha;
+  if (pr.title) base.prMergeSubject = pr.title;
   return true;
 }
 
@@ -915,6 +944,27 @@ export function mergeWorkspace(input: WorkspaceMergeInput): WorkspaceMergeResult
 
   if (preview.missing) return head({ status: "cleaned", error: preview.reason });
   if (preview.error) return head({ status: "review_requested", error: preview.error });
+  // #423 squash-recycle: the relay observed this branch's PR merged on the remote (ground
+  // truth) and asked for a land-and-continue recycle. For a squash onto an ADVANCED base —
+  // the common case in a busy PR-land instance — local cherry/tree detection can't see the
+  // landing, so `preview.noop` is false and we'd fall through to mergeRebaseFf → "origin
+  // moved ahead" → review_requested → re-fired every ~2min (soft-loop). Trust prLanded and
+  // recycle straight to a fresh branch off the UPDATED upstream base (the squash landed on
+  // origin; local base was never advanced).
+  //
+  // Two hard guardrails, because this resets the owner's branch:
+  //   1. Dirty tree → never reset (would blow away uncommitted work). Fall through to the
+  //      reason guard below → review_requested, retried next scan.
+  //   2. Only recycle once the fetched base actually CONTAINS the merge SHA. If the fetch
+  //      hasn't propagated the PR merge yet, fall through rather than reset onto a base
+  //      missing the landed work — never reset on an unverified ground-truth/refs mismatch.
+  if (input.prLanded?.sha && (preview.dirtyCount ?? 0) === 0) {
+    const startRef = syncBaseFromOrigin(worktreePath, preview.baseRef);
+    if (startRef && git(["merge-base", "--is-ancestor", input.prLanded.sha, startRef], worktreePath).ok) {
+      const landedPreview: WorkspaceMergePreview = { ...preview, noop: true, prMerged: true, prMergeSha: input.prLanded.sha, reason: "PR merged on remote" };
+      return resolveNoopMerge(input, worktreePath, repoRoot, branch, landedPreview, head, startRef);
+    }
+  }
   // Nothing to land (ahead=0, clean): the branch tree is already in base. Resolve it
   // to a terminal state so it leaves the steward queue instead of looping forever in
   // review_requested (#230). Reclaim the spent worktree/branch when the owner is gone.
@@ -943,16 +993,22 @@ function resolveNoopMerge(
   branch: string | undefined,
   preview: WorkspaceMergePreview,
   head: (field: Partial<WorkspaceMergeResult>) => WorkspaceMergeResult,
+  // Start point for the recycled branch. Defaults to the local base ref (the rebase-ff
+  // noop path, where the relay just advanced local base). The PR-land recycle (#423) passes
+  // the upstream tip (e.g. origin/main) so the live owner continues off UPDATED base rather
+  // than the worktree's stale local base.
+  startRef?: string,
 ): WorkspaceMergeResult {
   // Live owner (#327): recycle-to-continue instead of bricking the session.
   if (input.deleteBranch === false) {
     const base = preview.baseRef;
     if (base && branch) {
       const fresh = nextBranchName(repoRoot, branch);
-      if (git(["checkout", "-B", fresh, base], worktreePath).ok) {
+      const start = startRef ?? base;
+      if (git(["checkout", "-B", fresh, start], worktreePath).ok) {
         // Old branch's tree is already in base (that's what noop means) — safe to drop.
         const oldDeleted = git(["branch", "-D", branch], repoRoot).ok;
-        const baseSha = git(["rev-parse", base], worktreePath).stdout || undefined;
+        const baseSha = git(["rev-parse", start], worktreePath).stdout || undefined;
         // Recycled onto base, which may declare deps the symlinked node_modules lacks (#51).
         const depsRefresh = refreshWorkspaceDeps(repoRoot, worktreePath);
         const reportDeps = depsRefresh.refreshed || depsRefresh.stale || depsRefresh.error;