agent-relay-orchestrator 0.85.0 → 0.86.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.85.0",
+  "version": "0.86.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.65"
+    "agent-relay-sdk": "0.2.66"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/workspace-probe/merge.ts

@@ -438,8 +438,13 @@ function syncLocalBaseToUpstream(
   const upstreamSha = git(["rev-parse", "--verify", upstream], worktreePath).stdout;
   if (!upstreamSha) return { ok: false, error: `cannot resolve ${upstream} to sync ${base}` };
   const baseWorktree = worktreeForBranch(repoRoot, base);
-  if (baseWorktree) {
-    if (baseWorktree.dirty) return { ok: false, error: `base branch '${base}' has uncommitted changes in ${baseWorktree.path}; cannot sync to ${upstream}` };
+  // 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).
+  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 };
@@ -503,13 +508,16 @@ function mergeRebaseFf(
   const behind = countBehind(worktreePath, base);
 
   // Advance base. `baseTip` is base's new tip after the land: it equals headSha on a
-  // clean fast-forward, or the merge commit on a no-ff merge. If base is checked out
-  // somewhere, operate in that worktree so its working tree stays consistent; otherwise
-  // move/synthesize the ref directly. Refuse if the base worktree has uncommitted changes.
+  // clean fast-forward, or the merge commit on a no-ff merge. Operate IN the base worktree
+  // 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.
   let baseTip = headSha;
   const baseWorktree = worktreeForBranch(repoRoot, base);
-  if (baseWorktree) {
-    if (baseWorktree.dirty) return head({ status: "review_requested", error: `base branch '${base}' has uncommitted changes in ${baseWorktree.path}` });
+  if (baseWorktree && !baseWorktree.dirty) {
     if (behind === 0) {
       const ff = git(["merge", "--ff-only", branch], baseWorktree.path);
       if (!ff.ok) return head({ status: "review_requested", error: ff.stderr || "fast-forward into base failed" });