agent-relay-orchestrator 0.58.0 → 0.60.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.58.0",
+  "version": "0.60.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.36"
   },
   "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/terminal-stream.ts

@@ -68,6 +68,10 @@ interface PendingCommand {
   resolve: (lines: string[]) => void;
   reject: (err: Error) => void;
   timer: ReturnType<typeof setTimeout> | null;
+  // Fired SYNCHRONOUSLY when this command's reply block closes — before readLoop hands any
+  // later same-chunk %output to enqueue(). The resync screen-capture uses it to snapshot the
+  // pre-capture delta boundary (#275 dedup); see snapshotPreCaptureDeltas.
+  onFinishSync?: () => void;
 }
 // On attach we include this many lines of tmux scrollback ABOVE the current screen so the
 // viewer can scroll back through pre-attach history (the client lands on the live screen;
@@ -352,6 +356,12 @@ class SessionStream {
   // long the ground gate has been deferring (for the CAN fallback).
   private resyncInFlight = false;
   private groundDeferStart = 0;
+  // #275 dedup: deltas that were in `pending` at the resync capture's %end — the PRE-capture
+  // %output. doResync drains exactly these before the repaint; %output that arrives after the
+  // capture (even later in the same readLoop chunk) accumulates in a fresh `pending` and
+  // applies ON TOP of the repaint on the trailing flush, never re-scrolled beneath it.
+  private resyncPreCapture: Uint8Array[] | null = null;
+  private resyncPreCaptureBytes = 0;
 
   constructor(
     private readonly session: string,
@@ -456,6 +466,11 @@ class SessionStream {
     const entry = this.pendingCommands.shift();
     if (!entry) return; // unexpected extra block — drop it rather than mis-correlate
     if (entry.timer) clearTimeout(entry.timer);
+    // Snapshot the delta boundary NOW, synchronously, before resolve() and before readLoop
+    // processes any further %output in this chunk — so the boundary is exactly this block's %end.
+    if (entry.onFinishSync) {
+      try { entry.onFinishSync(); } catch {}
+    }
     if (isError) entry.reject(new Error(block.lines.join(" ").trim() || "tmux command error"));
     else entry.resolve(block.lines.map(latin1LineToUtf8));
   }
@@ -587,16 +602,22 @@ class SessionStream {
     this.resyncInFlight = true;
     try {
       const repaint = await this.resyncRepaint();
-      if (!repaint || this.closed || this.subscribers.size === 0) return;
-      // Ordering (#275): every %output read before the capture's %end is already in
-      // `pending`; drain it to subscribers BEFORE the repaint so scrolled lines can't
-      // re-apply on top of it (the duplicate-text race). Deltas after %end describe
-      // post-capture changes and correctly apply on top of the repaint next flush.
-      this.flush();
+      // Ordering (#275): the %output snapshotted at the capture's %end (resyncPreCapture) is
+      // the PRE-capture stream — drain it to subscribers BEFORE the repaint so scrolled lines
+      // can't re-apply on top of it (the duplicate-text race). %output that arrived AFTER the
+      // capture stayed in `pending` and applies on top of the repaint via the trailing flush.
+      this.drainPreCaptureDeltas();
+      if (!repaint || this.closed || this.subscribers.size === 0) {
+        this.flush(); // release any post-capture deltas normally (no repaint to inject)
+        return;
+      }
       const out = forceAbort ? this.prependCan(repaint) : repaint;
       this.broadcast(out);
+      this.flush(); // post-capture deltas, on top of the fresh repaint
       tdbg(`resync ${this.session} bytes=${out.length} viewers=${this.subscribers.size}${forceAbort ? " (forced)" : ""}`);
     } catch (e) {
+      this.drainPreCaptureDeltas();
+      this.flush();
       tdbg(`resync ${this.session} failed: ${errMessage(e)}`);
     } finally {
       this.resyncInFlight = false;
@@ -628,12 +649,58 @@ class SessionStream {
   // The grid + cursor are read in-band through the control client (#275), so the capture
   // is serialized with %output deltas and costs no process spawn.
   private async resyncRepaint(): Promise<Uint8Array | null> {
-    const body = await this.readScreen();
-    if (!body) return null;
+    // ORDER IS LOAD-BEARING for the #275 dedup. The screen capture is the serialization
+    // point: doResync drains `pending` (pre-capture %output) and emits this repaint right
+    // after. So the capture MUST be the LAST in-band read here — any awaited round-trip
+    // after it (the old readCursorState/paneDims) lets live %output land in `pending` that
+    // doResync then flushes BEFORE this now-stale repaint, re-scrolling lines the repaint
+    // still shows on-screen into the client's scrollback → duplicated text under load.
+    // Read the cursor first; reuse the cached row count (resize drives its own backfill, so
+    // termRows is authoritative without a round-trip); capture the grid last.
     const cursor = await this.readCursorState();
-    const dims = await this.paneDims();
-    const rows = dims.rows ?? this.termRows;
-    return new TextEncoder().encode(buildInPlaceRepaint(body, rows, cursor));
+    // Capture LAST, and tag it so its %end snapshots the pre-capture delta boundary (the
+    // capture-pane reply IS the serialization point against the %output stream).
+    const lines = await this.command(
+      `capture-pane -p -e -t "${this.session}"`,
+      true,
+      () => this.snapshotPreCaptureDeltas(),
+    ).catch(() => null);
+    const body = lines ? lines.join("\n") : "";
+    if (!body) return null;
+    return new TextEncoder().encode(buildInPlaceRepaint(body, this.termRows, cursor));
+  }
+
+  // Swap the live `pending` buffer aside at the resync capture's %end: these chunks are the
+  // PRE-capture %output (drained before the repaint), and a fresh `pending` collects anything
+  // after (applied on top, next flush). Runs synchronously inside finishBlock (#275).
+  private snapshotPreCaptureDeltas(): void {
+    this.resyncPreCapture = this.pending;
+    this.resyncPreCaptureBytes = this.pendingBytes;
+    this.pending = [];
+    this.pendingBytes = 0;
+    if (this.flushTimer !== null) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+
+  // Broadcast the snapshotted pre-capture deltas (mirrors flush()'s ANSI-state bookkeeping)
+  // ahead of the repaint. No-op when nothing was snapshotted (capture timed out / errored).
+  private drainPreCaptureDeltas(): void {
+    const chunks = this.resyncPreCapture;
+    const total = this.resyncPreCaptureBytes;
+    this.resyncPreCapture = null;
+    this.resyncPreCaptureBytes = 0;
+    if (!chunks || total === 0) return;
+    const merged = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      merged.set(chunk, offset);
+      offset += chunk.length;
+    }
+    this.broadcastState = scanAnsiState(merged, this.broadcastState);
+    this.broadcast(merged);
+    if (this.broadcastState === "ground") this.fireGroundWaiters();
   }
 
   // Read tmux's authoritative grid (styled) plus a consistent cursor, and turn it into a
@@ -793,14 +860,14 @@ class SessionStream {
   // Write a command to the control client's stdin and register a FIFO entry for its reply
   // block. `wantReply` commands resolve with the block's lines (or reject on %error /
   // timeout); fire-and-forget commands resolve with [] once their empty block closes.
-  private command(line: string, wantReply = false): Promise<string[]> {
+  private command(line: string, wantReply = false, onFinishSync?: () => void): Promise<string[]> {
     if (this.closed) return wantReply ? Promise.reject(new Error("terminal stream closed")) : Promise.resolve([]);
     const stdin = this.proc?.stdin;
     if (!stdin || typeof stdin === "number") {
       return wantReply ? Promise.reject(new Error("control client unavailable")) : Promise.resolve([]);
     }
     return new Promise<string[]>((resolve, reject) => {
-      const entry: PendingCommand = { wantReply, lines: [], resolve, reject, timer: null };
+      const entry: PendingCommand = { wantReply, lines: [], resolve, reject, timer: null, onFinishSync };
       if (wantReply) entry.timer = setTimeout(() => this.commandTimeout(entry), COMMAND_TIMEOUT_MS);
       this.pendingCommands.push(entry);
       try {

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;