agent-relay-orchestrator 0.91.1 → 0.91.3

package/package.json

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

package/src/git.ts

@@ -22,6 +22,20 @@ export function git(args: string[], cwd: string): GitResult {
   };
 }
 
+/** Run `git -C cwd <args>` and preserve stdout exactly for path-safe parsers. */
+export function gitRaw(args: string[], cwd: string): GitResult {
+  const proc = Bun.spawnSync(["git", "-C", cwd, ...args], {
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  return {
+    ok: proc.exitCode === 0,
+    stdout: proc.stdout.toString(),
+    stderr: proc.stderr.toString().trim(),
+  };
+}
+
 /** Like {@link git} but throws on a non-zero exit, returning stdout on success. */
 export function requireGit(args: string[], cwd: string): string {
   const result = git(args, cwd);

package/src/shared-callmux.ts

@@ -63,6 +63,7 @@ export function sharedCallmuxOptionsFromEnv(env: Record<string, string | undefin
   const port = numberEnv(env[SHARED_CALLMUX_PORT_ENV]) ?? parsed?.port ?? DEFAULT_SHARED_CALLMUX_PORT;
   const url = explicitUrl ?? `http://${host}:${port}/mcp`;
   return {
+    // PATH/env-resolved callmux must be >=0.21.0; generated config uses exposeMetaTools.
     command: env[SHARED_CALLMUX_COMMAND_ENV] || "callmux",
     host,
     port,
@@ -91,6 +92,8 @@ export function writeSharedCallmuxConfig(opts: Pick<SharedCallmuxOptions, "confi
     maxConcurrency: numberFromRecord(source, "maxConcurrency") ?? 20,
     callTimeoutMs: numberFromRecord(source, "callTimeoutMs") ?? 180_000,
     outputFormat: stringFromRecord(source, "outputFormat") ?? "auto",
+    // Relay workers consume only proxied tokenlean+github tools; suppress callmux meta-tools.
+    exposeMetaTools: false,
   };
   mkdirSync(dirname(opts.configPath), { recursive: true });
   writeFileSync(opts.configPath, JSON.stringify(generated, null, 2) + "\n", { mode: 0o600 });

package/src/terminal-stream.ts

@@ -603,6 +603,12 @@ class SessionStream {
       // 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 (!forceAbort && this.broadcastState !== "ground") {
+        this.resyncDirty = true;
+        this.flush(); // let the sequence tail complete normally; retry with a fresh capture
+        if (!this.resyncTimer) this.resyncTimer = setTimeout(() => void this.doResync(), RESYNC_GROUND_RETRY_MS);
+        return;
+      }
       if (!repaint || this.closed || this.subscribers.size === 0) {
         this.flush(); // release any post-capture deltas normally (no repaint to inject)
         return;

package/src/workspace-probe/merge.ts

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 import type { WorkspaceMergePreview, WorkspaceMergeResult } from "agent-relay-sdk";
-import { git } from "../git";
+import { git, gitRaw } from "../git";
 import { prMergedState } from "../workspace-pr";
 import { refreshWorkspaceDeps } from "./deps";
 import { populateMergeState, resolveBranchRef, syncBaseFromOrigin, upstreamRef, workspaceGitState } from "./git-state";
@@ -65,6 +65,79 @@ function worktreeForBranch(repoRoot: string, branch: string): { path: string; di
   return { path: match.path, dirty: status.ok ? status.stdout.length > 0 : true };
 }
 
+function splitNul(stdout: string): string[] {
+  return stdout.split("\0").filter(Boolean);
+}
+
+function dirtyPathSet(worktreePath: string): Set<string> {
+  const status = gitRaw(["status", "--porcelain=v1", "-z", "--untracked-files=all"], worktreePath);
+  if (!status.ok) return new Set<string>();
+  const paths = new Set<string>();
+  const entries = splitNul(status.stdout);
+  for (let i = 0; i < entries.length; i += 1) {
+    const entry = entries[i] ?? "";
+    if (entry.length < 4) continue;
+    const code = entry.slice(0, 2);
+    const path = entry.slice(3);
+    paths.add(path);
+    if (code[0] === "R" || code[0] === "C") i += 1;
+  }
+  return paths;
+}
+
+function changedPathList(worktreePath: string, oldBaseTip: string, newBaseTip: string): string[] {
+  const diff = gitRaw(["diff", "--name-only", "-z", oldBaseTip, newBaseTip], worktreePath);
+  return diff.ok ? splitNul(diff.stdout) : [];
+}
+
+function restorePathsFromHead(worktreePath: string, paths: string[]): boolean {
+  if (paths.length === 0) return true;
+  return git(["restore", "--staged", "--worktree", "--", ...paths], worktreePath).ok;
+}
+
+function resetIndexPathsToHead(worktreePath: string, paths: string[]): boolean {
+  if (paths.length === 0) return true;
+  return git(["reset", "-q", "HEAD", "--", ...paths], worktreePath).ok;
+}
+
+function logBaseWorktreeSyncWarning(base: string, worktreePath: string, message: string): void {
+  console.error(`[orchestrator] Warning: advanced ${base} but could not fully sync dirty base worktree ${worktreePath}: ${message}`);
+}
+
+/**
+ * After a dirty checked-out base is advanced with ref plumbing, bring the checkout forward
+ * without clobbering human WIP. `read-tree -m -u old new` is the primary mechanism: it
+ * updates clean paths in the index and worktree and refuses before overwriting local edits.
+ * If it refuses, preserve the land by leaving the ref advanced, restore only paths that were
+ * clean before the ref move, and normalize conflicting landed paths to unstaged edits.
+ */
+function syncDirtyBaseWorktreeAfterRefAdvance(
+  base: string,
+  baseWorktree: { path: string; dirty: boolean } | undefined,
+  oldBaseTip: string,
+  newBaseTip: string,
+  dirtyBefore: Set<string> | undefined,
+): void {
+  if (!baseWorktree?.dirty || !dirtyBefore) return;
+  const readTree = git(["read-tree", "-m", "-u", oldBaseTip, newBaseTip], baseWorktree.path);
+  if (readTree.ok) return;
+
+  const changedPaths = changedPathList(baseWorktree.path, oldBaseTip, newBaseTip);
+  const cleanChangedPaths = changedPaths.filter((path) => !dirtyBefore.has(path));
+  const dirtyChangedPaths = changedPaths.filter((path) => dirtyBefore.has(path));
+  const restoredClean = restorePathsFromHead(baseWorktree.path, cleanChangedPaths);
+  const resetDirtyIndex = resetIndexPathsToHead(baseWorktree.path, dirtyChangedPaths);
+  logBaseWorktreeSyncWarning(
+    base,
+    baseWorktree.path,
+    [
+      readTree.stderr || "read-tree refused local changes",
+      restoredClean ? undefined : "failed to restore clean landed paths",
+      resetDirtyIndex ? undefined : "failed to reset conflicting path index",
+    ].filter(Boolean).join("; "),
+  );
+}
+
 // Populate a preview's PR fields from `gh` ground truth; returns whether the PR is merged
 // (#168/#304). One home for the PR-landing rule so the worktree- and repoRoot-based previews
 // can't drift. On a merge it stamps the merge SHA so the relay can finalize a parked pr land.
@@ -441,16 +514,19 @@ function syncLocalBaseToUpstream(
   // Sync IN the base worktree only when it's clean — that keeps its working tree consistent
   // with the advanced ref (the pristine home-repo checkout). When the base worktree is dirty
   // (#644: a human's WIP in the shared checkout) we must NOT refuse and stall the whole repo's
-  // lands: advance the ref directly with update-ref instead. This is immune to the checkout's
-  // state and never reads or writes the human's working tree — their uncommitted work is left
-  // exactly as-is (the ref moves underneath; their files on disk are untouched).
+  // lands: advance the ref directly with update-ref, then best-effort sync the checked-out
+  // index/worktree forward for paths that are not human-modified (#681).
   if (baseWorktree && !baseWorktree.dirty) {
     const ff = git(["merge", "--ff-only", upstream], baseWorktree.path);
     if (!ff.ok) return { ok: false, error: ff.stderr || `failed to fast-forward ${base} to ${upstream}` };
     return { ok: true };
   }
-  const update = git(["update-ref", `refs/heads/${base}`, upstreamSha], repoRoot);
+  const oldBaseTip = git(["rev-parse", base], repoRoot).stdout;
+  const dirtyBefore = baseWorktree?.dirty ? dirtyPathSet(baseWorktree.path) : undefined;
+  const updateArgs = oldBaseTip ? ["update-ref", `refs/heads/${base}`, upstreamSha, oldBaseTip] : ["update-ref", `refs/heads/${base}`, upstreamSha];
+  const update = git(updateArgs, repoRoot);
   if (!update.ok) return { ok: false, error: update.stderr || `failed to advance ${base} to ${upstream}` };
+  if (oldBaseTip) syncDirtyBaseWorktreeAfterRefAdvance(base, baseWorktree, oldBaseTip, upstreamSha, dirtyBefore);
   return { ok: true };
 }
 
@@ -512,11 +588,11 @@ function mergeRebaseFf(
   // only when it exists AND is clean — that keeps its working tree consistent with the
   // advanced ref (the pristine home-repo checkout). When the base worktree is dirty
   // (#644: a human's WIP in the shared checkout) we must NOT refuse and stall every lane's
-  // land: fall through to ref-plumbing (update-ref / synthesized no-ff merge) below, which
-  // advances refs/heads/<base> without reading or touching that working tree. The human's
-  // uncommitted work is left exactly as-is — the ref moves underneath, their files untouched.
+  // land: fall through to ref-plumbing (update-ref / synthesized no-ff merge) below, then
+  // best-effort sync clean landed paths in the dirty checkout while preserving WIP (#681).
   let baseTip = headSha;
   const baseWorktree = worktreeForBranch(repoRoot, base);
+  const dirtyBasePathsBefore = baseWorktree?.dirty ? dirtyPathSet(baseWorktree.path) : undefined;
   if (baseWorktree && !baseWorktree.dirty) {
     if (behind === 0) {
       const ff = git(["merge", "--ff-only", branch], baseWorktree.path);
@@ -533,13 +609,18 @@ function mergeRebaseFf(
       baseTip = git(["rev-parse", "HEAD"], baseWorktree.path).stdout;
     }
   } else if (behind === 0) {
-    const update = git(["update-ref", `refs/heads/${base}`, headSha], repoRoot);
+    const oldBaseTip = git(["rev-parse", base], repoRoot).stdout;
+    const update = oldBaseTip
+      ? git(["update-ref", `refs/heads/${base}`, headSha, oldBaseTip], repoRoot)
+      : git(["update-ref", `refs/heads/${base}`, headSha], repoRoot);
     if (!update.ok) return head({ status: "review_requested", error: update.stderr || "failed to advance base ref" });
+    if (oldBaseTip) syncDirtyBaseWorktreeAfterRefAdvance(base, baseWorktree, oldBaseTip, headSha, dirtyBasePathsBefore);
   } else {
     const baseSha = git(["rev-parse", base], repoRoot).stdout;
     const merged = recordNoFfMerge(repoRoot, base, baseSha, headSha, landMergeMessage(branch, landedSubject));
     if (!merged.ok) return head(merged.conflict ? { conflict: true, status: "conflict", error: merged.error } : { status: "review_requested", error: merged.error });
     baseTip = merged.mergeSha;
+    syncDirtyBaseWorktreeAfterRefAdvance(base, baseWorktree, baseSha, baseTip, dirtyBasePathsBefore);
   }
 
   // Publish the advanced base so local and origin converge (#190). We verified