@adhdev/daemon-core 0.9.82-rc.522 → 0.9.82-rc.524

package/dist/index.js

@@ -419,10 +419,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "d3a44d29416fef77ac6cd36f4798637571260dfb" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "d3a44d29" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.522" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-14T03:03:55.067Z" : void 0);
+  const commit = readInjected(true ? "91ed5e0752d70b62ebcc2cddcea4d502756cff0a" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "91ed5e07" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.524" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-14T07:23:02.573Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -794,6 +794,9 @@ function isNonRuntimeRootFile(file, policy) {
   }
   return false;
 }
+function deriveChangeArea(isDaemonAffecting, affectedPackages) {
+  return isDaemonAffecting ? "daemon" : affectedPackages.length > 0 ? "web" : "none";
+}
 function classifyChangedFileList(files, policy) {
   if (files.length === 0) {
     return { isDaemonAffecting: true, affectedPackages: [], ambiguousNonPackageFiles: [] };
@@ -816,9 +819,10 @@ async function classifyDaemonBuildChange(repoPath, buildCommit, options, policy)
   try {
     const diff = await runGit(repoPath, ["diff", "--name-only", `${buildCommit}..HEAD`], options);
     const files = diff.stdout.split("\n").map((line) => line.trim()).filter(Boolean);
-    return classifyChangedFileList(files, policy);
+    const { isDaemonAffecting, affectedPackages } = classifyChangedFileList(files, policy);
+    return { isDaemonAffecting, affectedPackages, changeArea: deriveChangeArea(isDaemonAffecting, affectedPackages) };
   } catch {
-    return { isDaemonAffecting: true, affectedPackages: [] };
+    return { isDaemonAffecting: true, affectedPackages: [], changeArea: "daemon" };
   }
 }
 async function classifyChangedPackages(repoPath, fromRef, toRef, options = {}) {
@@ -831,7 +835,7 @@ async function classifyChangedPackages(repoPath, fromRef, toRef, options = {}) {
   return refineVerdictThroughSubmodules(repoPath, fromRef, toRef, options, policy, rootVerdict);
 }
 async function refineVerdictThroughSubmodules(repoPath, fromRef, toRef, options, policy, rootVerdict) {
-  const strip = ({ isDaemonAffecting, affectedPackages }) => ({ isDaemonAffecting, affectedPackages });
+  const strip = ({ isDaemonAffecting, affectedPackages: affectedPackages2 }) => ({ isDaemonAffecting, affectedPackages: affectedPackages2, changeArea: deriveChangeArea(isDaemonAffecting, affectedPackages2) });
   const ambiguous = rootVerdict.ambiguousNonPackageFiles;
   if (ambiguous.length === 0) return strip(rootVerdict);
   let submodulePaths;
@@ -863,9 +867,11 @@ async function refineVerdictThroughSubmodules(repoPath, fromRef, toRef, options,
       return strip(rootVerdict);
     }
     if (subVerdict.isDaemonAffecting) {
+      const affectedPackages2 = [.../* @__PURE__ */ new Set([...rootVerdict.affectedPackages, ...subVerdict.affectedPackages])].sort();
       return {
         isDaemonAffecting: true,
-        affectedPackages: [.../* @__PURE__ */ new Set([...rootVerdict.affectedPackages, ...subVerdict.affectedPackages])].sort()
+        affectedPackages: affectedPackages2,
+        changeArea: deriveChangeArea(true, affectedPackages2)
       };
     }
     submoduleAffectedPackages.push(...subVerdict.affectedPackages);
@@ -873,9 +879,11 @@ async function refineVerdictThroughSubmodules(repoPath, fromRef, toRef, options,
   const rootPackagesBenign = rootVerdict.affectedPackages.every(
     (p) => policy.webOnlyPackages.has(p) && !policy.daemonRuntimePackages.has(p)
   );
+  const affectedPackages = [.../* @__PURE__ */ new Set([...rootVerdict.affectedPackages, ...submoduleAffectedPackages])].sort();
   return {
     isDaemonAffecting: !rootPackagesBenign,
-    affectedPackages: [.../* @__PURE__ */ new Set([...rootVerdict.affectedPackages, ...submoduleAffectedPackages])].sort()
+    affectedPackages,
+    changeArea: deriveChangeArea(!rootPackagesBenign, affectedPackages)
   };
 }
 async function listSubmodulePaths(repoPath, options) {
@@ -10753,6 +10761,14 @@ function normalizeMeshCommandConfig(entry, source) {
   if (entry.env !== void 0 && (!isMeshConfigRecord(entry.env) || !Object.values(entry.env).every((value) => typeof value === "string"))) {
     return { rejected: { source, command: commandText, reason: "env must be an object of string values" } };
   }
+  let scopes;
+  if (entry.scopes !== void 0) {
+    if (!Array.isArray(entry.scopes) || !entry.scopes.every((s2) => MESH_REFINE_VALIDATION_SCOPES.includes(s2))) {
+      return { rejected: { source, command: commandText, reason: `scopes must be an array of ${MESH_REFINE_VALIDATION_SCOPES.join(" | ")}` } };
+    }
+    const deduped = [...new Set(entry.scopes)];
+    scopes = deduped.length ? deduped : void 0;
+  }
   return {
     command: {
       command,
@@ -10763,7 +10779,8 @@ function normalizeMeshCommandConfig(entry, source) {
       ...typeof entry.cwd === "string" && entry.cwd.trim() ? { cwd: entry.cwd.trim() } : {},
       ...typeof entry.timeoutMs === "number" ? { timeoutMs: entry.timeoutMs } : {},
       ...typeof entry.outputLimitBytes === "number" ? { outputLimitBytes: entry.outputLimitBytes } : {},
-      ...isMeshConfigRecord(entry.env) ? { env: entry.env } : {}
+      ...isMeshConfigRecord(entry.env) ? { env: entry.env } : {},
+      ...scopes ? { scopes } : {}
     }
   };
 }
@@ -10920,7 +10937,7 @@ function resolveMeshRefineValidationPlan(mesh, workspace) {
     unavailableReason: validation.commands.length ? void 0 : "validation_unavailable: repo mesh/refine config has no validation.commands"
   };
 }
-var import_fs8, import_path8, yaml2, MESH_REFINE_VALIDATION_CATEGORIES, MESH_REFINE_CONFIG_LOCATIONS, MESH_REFINE_CONFIG_SCHEMA, SHELL_METACHAR_RE, SAFE_TOKEN_RE, SAFE_WIN32_EXEC_TOKEN_RE, isRecord2;
+var import_fs8, import_path8, yaml2, MESH_REFINE_VALIDATION_CATEGORIES, MESH_REFINE_VALIDATION_SCOPES, MESH_REFINE_CONFIG_LOCATIONS, MESH_REFINE_CONFIG_SCHEMA, SHELL_METACHAR_RE, SAFE_TOKEN_RE, SAFE_WIN32_EXEC_TOKEN_RE, isRecord2;
 var init_refine_config = __esm({
   "src/mesh/refine-config.ts"() {
     "use strict";
@@ -10928,6 +10945,7 @@ var init_refine_config = __esm({
     import_path8 = require("path");
     yaml2 = __toESM(require("js-yaml"));
     MESH_REFINE_VALIDATION_CATEGORIES = ["typecheck", "test", "lint", "build"];
+    MESH_REFINE_VALIDATION_SCOPES = ["none", "web", "daemon"];
     MESH_REFINE_CONFIG_LOCATIONS = [
       ".adhdev/refine.json",
       ".adhdev/refine.yaml",
@@ -10977,7 +10995,12 @@ var init_refine_config = __esm({
                   cwd: { type: "string" },
                   timeoutMs: { type: "number", minimum: 1e3, maximum: 6e5 },
                   outputLimitBytes: { type: "number", minimum: 1024, maximum: 1048576 },
-                  env: { type: "object", additionalProperties: { type: "string" } }
+                  env: { type: "object", additionalProperties: { type: "string" } },
+                  scopes: {
+                    type: "array",
+                    items: { enum: [...MESH_REFINE_VALIDATION_SCOPES] },
+                    description: "DOCS-ROOT: change-impact scopes this command runs in ('none'=docs-only, 'web', 'daemon'). Omitted/empty \u2192 runs in every area."
+                  }
                 }
               }
             },
@@ -10996,7 +11019,11 @@ var init_refine_config = __esm({
                   cwd: { type: "string" },
                   timeoutMs: { type: "number", minimum: 1e3, maximum: 6e5 },
                   outputLimitBytes: { type: "number", minimum: 1024, maximum: 1048576 },
-                  env: { type: "object", additionalProperties: { type: "string" } }
+                  env: { type: "object", additionalProperties: { type: "string" } },
+                  scopes: {
+                    type: "array",
+                    items: { enum: [...MESH_REFINE_VALIDATION_SCOPES] }
+                  }
                 }
               }
             }
@@ -17216,6 +17243,56 @@ async function runContinuousAutoFastForwardScan(components, mesh) {
     await delegateRemoteAutoFastForward(components, { meshId, nodeId, node, daemonId, workspace, policy, trigger: "reconcile_auto" });
   }
 }
+async function runPendingCoordinatorCatchupScan(components, mesh) {
+  const meshId = readNonEmptyString2(mesh?.id);
+  if (!meshId) return;
+  const localIds = expandDaemonIdForms([
+    readNonEmptyString2(components.statusInstanceId),
+    readNonEmptyString2(loadConfig().machineId)
+  ]);
+  let markers = [];
+  try {
+    markers = drainPendingMeshCoordinatorEvents(
+      meshId,
+      localIds.length > 0 ? localIds : void 0,
+      { onlyEvents: /* @__PURE__ */ new Set(["coordinator_catchup"]) }
+    );
+  } catch (e) {
+    LOG.warn("MeshReconcile", `Coordinator-catchup drain failed for mesh ${meshId}: ${e?.message || e}`);
+    return;
+  }
+  if (markers.length === 0) return;
+  const nodes = Array.isArray(mesh?.nodes) ? mesh.nodes : [];
+  for (const marker of markers) {
+    const meta = marker.metadataEvent || {};
+    const nodeId = readNonEmptyString2(marker.nodeId) || readNonEmptyString2(meta.nodeId);
+    const workspace = readNonEmptyString2(marker.workspace) || readNonEmptyString2(meta.workspace);
+    const baseBranch = readNonEmptyString2(meta.baseBranch);
+    if (!workspace) continue;
+    if (nodeId && nodeHasActiveMeshWork(components, meshId, nodeId)) {
+      try {
+        queuePendingMeshCoordinatorEvent(marker);
+      } catch {
+      }
+      continue;
+    }
+    try {
+      const ff = await fastForwardMeshNode({
+        meshId,
+        ...nodeId ? { nodeId } : {},
+        workspace,
+        ...baseBranch ? { branch: baseBranch } : {},
+        mode: "merge",
+        execute: true,
+        trigger: "refine_post_push_catchup",
+        allowAutoPublishSubmoduleMainCommits: mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true
+      });
+      LOG.info("MeshReconcile", `Coordinator catch-up ff for ${meshId}/${nodeId || workspace}: ${ff.code} (executed=${ff.executed})`);
+    } catch (e) {
+      LOG.warn("MeshReconcile", `Coordinator catch-up ff failed for ${meshId}/${nodeId || workspace}: ${e?.message || e}`);
+    }
+  }
+}
 function runIdleMaintenanceThenAssignQueue(components, args) {
   setImmediate(() => {
     maybeAutoFastForwardIdleNode(components, args).finally(() => {
@@ -22212,6 +22289,15 @@ async function runMeshReconcileTick(components) {
       }
     }
   }
+  for (const mesh of listMeshes()) {
+    const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
+    if (!daemonHostsMesh(mesh, selfIds)) continue;
+    try {
+      await runPendingCoordinatorCatchupScan(components, mesh);
+    } catch (e) {
+      LOG.warn("MeshReconcile", `Coordinator catch-up scan failed for mesh ${mesh.id}: ${e?.message || e}`);
+    }
+  }
   if (dispatchMeshCommand) {
     for (const mesh of listMeshes()) {
       const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
@@ -59315,6 +59401,8 @@ init_logger();
 init_debug_trace();
 init_dist();
 init_mesh_events();
+init_mesh_reconcile_identity();
+init_mesh_fast_forward();
 
 // src/mesh/mesh-refine-batch.ts
 var import_node_child_process5 = require("child_process");
@@ -60244,7 +60332,10 @@ function buildMeshRefineValidationPlan(mesh, workspace) {
     category: command.category,
     source: command.source,
     cwd: command.cwd,
-    timeoutMs: command.timeoutMs
+    timeoutMs: command.timeoutMs,
+    // DOCS-ROOT: surface the change-impact scopes so `mesh_refine_config` shows which
+    // area(s) each command runs in (absent → every area).
+    ...command.scopes ? { scopes: command.scopes } : {}
   });
   return {
     source: plan.source,
@@ -60357,9 +60448,33 @@ async function runMeshRefineValidationGate(mesh, workspace, opts) {
     return /\bdaemon-core\b|\bdaemon-cloud\b|\btest:daemon\b|check-vendor-drift/.test(haystack);
   };
   const scopeUnaffectedDaemon = opts?.changeImpact?.isDaemonAffecting === false;
+  const changeArea = opts?.changeImpact?.changeArea;
+  const commandRunsInArea = (candidate) => {
+    if (!changeArea) return true;
+    const scopes = candidate.scopes;
+    if (scopes && scopes.length) return scopes.includes(changeArea);
+    return changeArea !== "none";
+  };
   const skippedDaemonCommands = [];
+  const skippedScopeCommands = [];
   const commandsToRun = [];
   for (const candidate of selection.commands) {
+    if (!commandRunsInArea(candidate)) {
+      skippedScopeCommands.push(candidate.displayCommand);
+      summary.commandsRun.push({
+        command: candidate.command,
+        args: candidate.args,
+        displayCommand: candidate.displayCommand,
+        category: candidate.category,
+        source: candidate.source,
+        passed: true,
+        skipped: true,
+        skipReason: "unaffected_change_scope",
+        changeArea,
+        ...candidate.scopes ? { scopes: candidate.scopes } : {}
+      });
+      continue;
+    }
     if (scopeUnaffectedDaemon && isDaemonScopedCommand(candidate)) {
       skippedDaemonCommands.push(candidate.displayCommand);
       summary.commandsRun.push({
@@ -60380,7 +60495,9 @@ async function runMeshRefineValidationGate(mesh, workspace, opts) {
     summary.changeImpact = {
       isDaemonAffecting: opts.changeImpact.isDaemonAffecting,
       affectedPackages: opts.changeImpact.affectedPackages,
-      ...skippedDaemonCommands.length ? { skippedDaemonCommands } : {}
+      ...changeArea ? { changeArea } : {},
+      ...skippedDaemonCommands.length ? { skippedDaemonCommands } : {},
+      ...skippedScopeCommands.length ? { skippedScopeCommands } : {}
     };
   }
   if (runLegacyBootstrapCommands) {
@@ -60506,6 +60623,24 @@ function buildRefineJobHandle(self, args) {
     }
   };
 }
+function extractValidationFailureDiagnostics(validationSummary) {
+  if (!validationSummary || typeof validationSummary !== "object") return void 0;
+  const commandsRun = Array.isArray(validationSummary.commandsRun) ? validationSummary.commandsRun : [];
+  const failed = commandsRun.find((c) => c.passed === false);
+  const summaryFailureKind = validationSummary.failureKind;
+  if (!failed) {
+    return summaryFailureKind !== void 0 ? { failureKind: summaryFailureKind } : void 0;
+  }
+  const firstFailedCommand = typeof failed.displayCommand === "string" ? failed.displayCommand : typeof failed.command === "string" ? [failed.command, ...Array.isArray(failed.args) ? failed.args : []].join(" ").trim() : void 0;
+  const rawOutput = [failed.stderr, failed.stdout, failed.output].filter((s2) => typeof s2 === "string" && s2.length > 0).join("\n");
+  const outputTail = rawOutput.length > 600 ? rawOutput.slice(-600) : rawOutput;
+  return {
+    ...firstFailedCommand ? { firstFailedCommand } : {},
+    ...failed.exitCode !== void 0 ? { exitCode: failed.exitCode } : {},
+    ...failed.failureKind !== void 0 ? { failureKind: failed.failureKind } : summaryFailureKind !== void 0 ? { failureKind: summaryFailureKind } : {},
+    ...outputTail ? { outputTail } : {}
+  };
+}
 function slimRefineEventResult(result) {
   const slim = {};
   for (const key2 of [
@@ -60518,7 +60653,12 @@ function slimRefineEventResult(result) {
     "into",
     "terminalKind",
     "nextStep",
-    "finalBranchConvergenceState"
+    "finalBranchConvergenceState",
+    // QW4: merge conflict paths; QW5: cleanup branch-ref / residue warnings.
+    "conflictPaths",
+    "branchRefWarning",
+    "residueWarning",
+    "branchRefDeleted"
   ]) {
     if (result[key2] !== void 0) slim[key2] = result[key2];
   }
@@ -60527,12 +60667,15 @@ function slimRefineEventResult(result) {
   }
   if (result.validationSummary && typeof result.validationSummary === "object") {
     const vs = result.validationSummary;
+    const diagnostics = vs.status === "failed" ? extractValidationFailureDiagnostics(vs) : void 0;
     slim.validationSummary = {
       status: vs.status,
       failureCode: vs.failureCode,
+      failureKind: vs.failureKind,
       configSource: vs.configSource,
       configSourceType: vs.configSourceType,
-      commandsRunCount: Array.isArray(vs.commandsRun) ? vs.commandsRun.length : void 0
+      commandsRunCount: Array.isArray(vs.commandsRun) ? vs.commandsRun.length : void 0,
+      ...diagnostics ? { failure: diagnostics } : {}
     };
   }
   if (result.patchEquivalence && typeof result.patchEquivalence === "object") {
@@ -60673,6 +60816,8 @@ async function executeMeshRefineNodeSynchronously(self, meshId, nodeId, args) {
     const resolved = await refineResolveRefsStage(self, meshId, nodeId, args, refineStages);
     if (resolved.kind === "terminal") return resolved.result;
     const ctx = resolved.ctx;
+    const syncBase = await refineSyncBaseStage(self, ctx);
+    if (syncBase.kind === "terminal") return syncBase.result;
     const validation = await refineValidationStage(self, ctx);
     if (validation.kind === "terminal") return validation.result;
     const patchEquivalence = await refinePatchEquivalenceStage(self, ctx);
@@ -60761,6 +60906,152 @@ async function refineResolveRefsStage(self, meshId, nodeId, args, refineStages)
     }
   };
 }
+async function computeBranchBaseDivergence(execFileAsync4, cwd, baseHead, branchHead) {
+  let mergeBase;
+  try {
+    const { stdout } = await execFileAsync4("git", ["merge-base", baseHead, branchHead], { cwd, encoding: "utf8" });
+    mergeBase = stdout.trim() || void 0;
+  } catch {
+  }
+  let ahead = 0;
+  let behind = 0;
+  try {
+    const { stdout } = await execFileAsync4("git", ["rev-list", "--left-right", "--count", `${baseHead}...${branchHead}`], { cwd, encoding: "utf8" });
+    const [left, right] = stdout.trim().split(/\s+/).map((n) => Number.parseInt(n, 10));
+    behind = Number.isFinite(left) ? left : 0;
+    ahead = Number.isFinite(right) ? right : 0;
+  } catch {
+  }
+  return {
+    mergeBase,
+    ahead,
+    behind,
+    diverged: ahead > 0 && behind > 0,
+    // Strictly behind = base is a descendant of branch (branch is an ancestor of base):
+    // behind>0 with ahead===0.
+    isStrictlyBehind: behind > 0 && ahead === 0
+  };
+}
+async function refineSyncBaseStage(self, ctx) {
+  const { repoRoot, baseHead, node, branch, baseBranch, refineStages, execFileAsync: execFileAsync4 } = ctx;
+  let branchHead = ctx.branchHead;
+  const syncStarted = Date.now();
+  const divergence = await computeBranchBaseDivergence(execFileAsync4, node.workspace, baseHead, branchHead);
+  if (divergence.behind === 0) {
+    recordMeshRefineStage(refineStages, "sync_base", "passed", syncStarted, {
+      ahead: divergence.ahead,
+      behind: divergence.behind,
+      rebased: false,
+      reason: "branch_up_to_date_with_base"
+    });
+    return { kind: "continue", ctx };
+  }
+  try {
+    const preRebasePe = await runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead);
+    const alreadyMerged = !preRebasePe.actualPatchId && !!preRebasePe.expectedPatchId;
+    const submoduleConflict = preRebasePe.actionableHint?.kind === "submodule_conflict";
+    if (alreadyMerged || submoduleConflict) {
+      recordMeshRefineStage(refineStages, "sync_base", "passed", syncStarted, {
+        ahead: divergence.ahead,
+        behind: divergence.behind,
+        rebased: false,
+        reason: alreadyMerged ? "already_merged_via_other_path_skip_rebase" : "submodule_conflict_defer_to_patch_equivalence"
+      });
+      return { kind: "continue", ctx };
+    }
+  } catch {
+  }
+  const rebaseStarted = Date.now();
+  try {
+    (0, import_node_child_process7.execFileSync)("git", ["rebase", baseHead], { cwd: node.workspace, stdio: ["ignore", "pipe", "pipe"] });
+  } catch (rebaseErr) {
+    try {
+      (0, import_node_child_process7.execFileSync)("git", ["rebase", "--abort"], { cwd: node.workspace, stdio: "ignore" });
+    } catch {
+    }
+    let submoduleHintPatchEquivalence;
+    try {
+      submoduleHintPatchEquivalence = await runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, ctx.branchHead);
+    } catch {
+    }
+    const submoduleConflict = submoduleHintPatchEquivalence?.actionableHint?.kind === "submodule_conflict";
+    recordMeshRefineStage(refineStages, "sync_base", "failed", syncStarted, {
+      ahead: divergence.ahead,
+      behind: divergence.behind,
+      diverged: divergence.diverged,
+      error: rebaseErr?.message || String(rebaseErr),
+      ...submoduleConflict ? { submoduleConflict: true } : {}
+    });
+    if (submoduleConflict && submoduleHintPatchEquivalence) {
+      recordMeshRefineStage(refineStages, "patch_equivalence", "failed", rebaseStarted, {
+        equivalent: submoduleHintPatchEquivalence.equivalent,
+        expectedPatchId: submoduleHintPatchEquivalence.expectedPatchId,
+        actualPatchId: submoduleHintPatchEquivalence.actualPatchId,
+        error: submoduleHintPatchEquivalence.error,
+        actionableHint: submoduleHintPatchEquivalence.actionableHint
+      });
+      return { kind: "terminal", result: {
+        success: false,
+        code: "patch_equivalence_failed",
+        convergenceStatus: "blocked_review",
+        error: "Refinery patch-equivalence preflight failed (submodule gitlink conflict); merge/refine was not attempted.",
+        branch,
+        into: baseBranch,
+        patchEquivalence: submoduleHintPatchEquivalence,
+        refineStages,
+        finalBranchConvergenceState: {
+          branch,
+          baseBranch,
+          merged: false,
+          removed: false,
+          patchEquivalence: "failed",
+          status: "blocked_review"
+        }
+      } };
+    }
+    recordMeshRefineStage(refineStages, "patch_equivalence_after_auto_rebase", "failed", rebaseStarted, {
+      error: rebaseErr?.message || String(rebaseErr)
+    });
+    return { kind: "terminal", result: {
+      success: false,
+      code: "needs_rebase_with_conflicts",
+      convergenceStatus: "blocked_review",
+      error: divergence.diverged ? `Branch has diverged from ${baseBranch} (ahead ${divergence.ahead}, behind ${divergence.behind}) and auto-rebase onto the fetched base hit conflicts; resolve conflicts manually and retry.` : `Branch is behind ${baseBranch} and auto-rebase failed due to conflicts; resolve conflicts manually and retry.`,
+      branch,
+      into: baseBranch,
+      refineStages,
+      finalBranchConvergenceState: {
+        branch,
+        baseBranch,
+        merged: false,
+        removed: false,
+        status: "blocked_review"
+      }
+    } };
+  }
+  const { stdout: rebasedHeadStdout } = await execFileAsync4("git", ["rev-parse", "HEAD"], { cwd: node.workspace, encoding: "utf8" });
+  branchHead = rebasedHeadStdout.trim();
+  ctx.branchHead = branchHead;
+  let changeImpact = ctx.changeImpact;
+  try {
+    changeImpact = await classifyChangedPackages(node.workspace, baseHead, branchHead);
+    ctx.changeImpact = changeImpact;
+  } catch {
+  }
+  recordMeshRefineStage(refineStages, "sync_base", "passed", syncStarted, {
+    ahead: divergence.ahead,
+    behind: divergence.behind,
+    diverged: divergence.diverged,
+    rebased: true,
+    rebasedBranchHead: branchHead,
+    ...changeImpact ? { changeImpact } : {}
+  });
+  recordMeshRefineStage(refineStages, "patch_equivalence_after_auto_rebase", "passed", rebaseStarted, {
+    rebasedBranchHead: branchHead,
+    rebasedOnto: baseHead
+  });
+  return { kind: "continue", ctx };
+}
 async function refineValidationStage(self, ctx) {
   const { mesh, node, branch, baseBranch, refineStages } = ctx;
   const validationStarted = Date.now();
@@ -60785,7 +61076,7 @@ async function refineValidationStage(self, ctx) {
     { validationStatus: validationSummary.status, commandsRun: validationSummary.commandsRun.length }
   );
   if (validationSummary.status === "failed") {
-    const firstFailedCmd = Array.isArray(validationSummary.commandsRun) ? validationSummary.commandsRun.find((c) => c.success === false) : void 0;
+    const firstFailedCmd = Array.isArray(validationSummary.commandsRun) ? validationSummary.commandsRun.find((c) => c.passed === false) : void 0;
     const buildValidationFailedError = () => {
       const base = validationSummary.failureCode === "missing_dependencies" ? "Refinery validation dependencies are missing for a change-affected package; merge/refine was not attempted. To make this self-service, either (1) configure .adhdev/worktree_bootstrap.json (or validation.bootstrapCommands in .adhdev/refine.json) so Refinery installs deps before validation, or (2) converge the branch via the documented manual fast-forward-only bypass (rebase onto the fetched base, verify strict ancestry, then push ff-only) instead of the refine gate." : validationSummary.failureCode === "dependency_bootstrap_failed" ? "Refinery dependency/bootstrap command failed; merge/refine was not attempted." : validationSummary.failureCode === "spawn_resolution_failed" ? validationSummary.spawnResolutionError || "Refinery validation command could not be spawned (executable not found); merge/refine was not attempted." : "Refinery validation gate failed; merge/refine was not attempted.";
       if (!firstFailedCmd) return base;
@@ -60841,10 +61132,10 @@ ${tail}` : ""
   return { kind: "continue", ctx };
 }
 async function refinePatchEquivalenceStage(self, ctx) {
-  const { meshId, nodeId, args, repoRoot, baseHead, node, branch, baseBranch, validationSummary, refineStages, execFileAsync: execFileAsync4 } = ctx;
-  let branchHead = ctx.branchHead;
+  const { meshId, nodeId, args, repoRoot, baseHead, branch, baseBranch, validationSummary, refineStages } = ctx;
+  const branchHead = ctx.branchHead;
   const patchEquivalenceStarted = Date.now();
-  let patchEquivalence = await runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead);
+  const patchEquivalence = await runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead);
   recordMeshRefineStage(refineStages, "patch_equivalence", patchEquivalence.status, patchEquivalenceStarted, {
     equivalent: patchEquivalence.equivalent,
     expectedPatchId: patchEquivalence.expectedPatchId,
@@ -60853,90 +61144,8 @@ async function refinePatchEquivalenceStage(self, ctx) {
     actionableHint: patchEquivalence.actionableHint
   });
   if (!patchEquivalence.equivalent) {
-    let didAutoRebase = false;
-    let isBehindBase = false;
-    try {
-      (0, import_node_child_process7.execFileSync)("git", ["merge-base", "--is-ancestor", branchHead, baseHead], {
-        cwd: node.workspace,
-        stdio: "ignore"
-      });
-      isBehindBase = true;
-    } catch {
-    }
-    if (isBehindBase) {
-      const autoRebaseStarted = Date.now();
-      try {
-        (0, import_node_child_process7.execFileSync)("git", ["rebase", baseHead], {
-          cwd: node.workspace,
-          stdio: ["ignore", "pipe", "pipe"]
-        });
-        const { stdout: rebasedHeadStdout } = await execFileAsync4("git", ["rev-parse", "HEAD"], { cwd: node.workspace, encoding: "utf8" });
-        branchHead = rebasedHeadStdout.trim();
-        const rebasedPatchEquivalence = await runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead);
-        recordMeshRefineStage(refineStages, "patch_equivalence_after_auto_rebase", rebasedPatchEquivalence.status, autoRebaseStarted, {
-          equivalent: rebasedPatchEquivalence.equivalent,
-          expectedPatchId: rebasedPatchEquivalence.expectedPatchId,
-          actualPatchId: rebasedPatchEquivalence.actualPatchId,
-          error: rebasedPatchEquivalence.error,
-          rebasedBranchHead: branchHead
-        });
-        if (rebasedPatchEquivalence.equivalent) {
-          patchEquivalence = rebasedPatchEquivalence;
-          didAutoRebase = true;
-        } else {
-          return { kind: "terminal", result: {
-            success: false,
-            code: "needs_rebase",
-            convergenceStatus: "blocked_review",
-            error: "Branch was rebased onto base but patch equivalence still failed; manual intervention required.",
-            branch,
-            into: baseBranch,
-            validationSummary,
-            patchEquivalence: rebasedPatchEquivalence,
-            refineStages,
-            finalBranchConvergenceState: {
-              branch,
-              baseBranch,
-              merged: false,
-              removed: false,
-              validation: "passed",
-              patchEquivalence: "failed",
-              status: "blocked_review"
-            }
-          } };
-        }
-      } catch (rebaseErr) {
-        try {
-          (0, import_node_child_process7.execFileSync)("git", ["rebase", "--abort"], { cwd: node.workspace, stdio: "ignore" });
-        } catch {
-        }
-        recordMeshRefineStage(refineStages, "patch_equivalence_after_auto_rebase", "failed", autoRebaseStarted, {
-          error: rebaseErr?.message || String(rebaseErr)
-        });
-        return { kind: "terminal", result: {
-          success: false,
-          code: "needs_rebase_with_conflicts",
-          convergenceStatus: "blocked_review",
-          error: "Branch is behind base and auto-rebase failed due to conflicts; resolve conflicts manually and retry.",
-          branch,
-          into: baseBranch,
-          validationSummary,
-          patchEquivalence,
-          refineStages,
-          finalBranchConvergenceState: {
-            branch,
-            baseBranch,
-            merged: false,
-            removed: false,
-            validation: "passed",
-            patchEquivalence: "failed",
-            status: "blocked_review"
-          }
-        } };
-      }
-    }
     const alreadyMergedViaOtherPath = !patchEquivalence.actualPatchId && !!patchEquivalence.expectedPatchId;
-    if (!didAutoRebase && !alreadyMergedViaOtherPath) {
+    if (!alreadyMergedViaOtherPath) {
       return { kind: "terminal", result: {
         success: false,
         code: "patch_equivalence_failed",
@@ -60958,7 +61167,7 @@ async function refinePatchEquivalenceStage(self, ctx) {
         }
       } };
     }
-    if (!didAutoRebase && alreadyMergedViaOtherPath) {
+    {
       recordMeshRefineStage(refineStages, "merge", "skipped", Date.now(), {
         reason: "already_merged_via_other_path",
         note: "actualPatchId is empty; branch content is already present in base via a different commit path"
@@ -61166,8 +61375,145 @@ ${hintLines.join("\n")}` : "",
   }
   return { kind: "continue", ctx };
 }
+async function requestCoordinatorLocalCatchup(self, params) {
+  const { meshId, ctx, mesh, baseBranch, repoRoot } = params;
+  const coordinatorDaemonId = typeof ctx.args?.coordinatorDaemonId === "string" && ctx.args.coordinatorDaemonId.trim() ? ctx.args.coordinatorDaemonId.trim() : self.deps.statusInstanceId || void 0;
+  if (!coordinatorDaemonId) return void 0;
+  if (!Array.isArray(mesh?.nodes)) return void 0;
+  const coordinatorBaseNode = mesh.nodes.find((n) => !n?.isLocalWorktree && daemonIdListIncludes([coordinatorDaemonId], readStringValue(n?.daemonId)));
+  if (!coordinatorBaseNode) return void 0;
+  const coordinatorWorkspace = readStringValue(coordinatorBaseNode.repoRoot) || readStringValue(coordinatorBaseNode.workspace);
+  if (!coordinatorWorkspace) return void 0;
+  const drainIds = [self.deps.statusInstanceId].filter((v) => typeof v === "string" && v.length > 0);
+  const selfIds = resolveCoordinatorSelfIds(mesh, drainIds);
+  const coordinatorIsSelf = daemonIdListIncludes(selfIds, readStringValue(coordinatorBaseNode.daemonId));
+  if (coordinatorIsSelf) {
+    try {
+      const ff = await fastForwardMeshNode({
+        meshId,
+        nodeId: readStringValue(coordinatorBaseNode.id),
+        workspace: coordinatorWorkspace,
+        branch: baseBranch,
+        mode: "merge",
+        execute: true,
+        trigger: "refine_post_push_catchup",
+        allowAutoPublishSubmoduleMainCommits: mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true
+      });
+      return {
+        mode: "local_fast_forward",
+        coordinatorWorkspace,
+        sameAsRepoRoot: coordinatorWorkspace === repoRoot,
+        code: ff.code,
+        executed: ff.executed,
+        success: ff.success,
+        ...ff.blockingReasons?.length ? { blockingReasons: ff.blockingReasons } : {}
+      };
+    } catch (e) {
+      return { mode: "local_fast_forward", coordinatorWorkspace, error: e?.message || String(e) };
+    }
+  }
+  try {
+    queuePendingMeshCoordinatorEvent({
+      event: "coordinator_catchup",
+      meshId,
+      nodeLabel: readStringValue(coordinatorBaseNode.id) || "coordinator-base",
+      nodeId: readStringValue(coordinatorBaseNode.id),
+      workspace: coordinatorWorkspace,
+      metadataEvent: {
+        source: "refine_post_push_coordinator_catchup",
+        operation: "coordinator_catchup",
+        baseBranch,
+        coordinatorDaemonId,
+        reason: "post_push_base_advanced"
+      },
+      queuedAt: Date.now(),
+      targetCoordinatorDaemonId: coordinatorDaemonId
+    });
+    return { mode: "pending_marker_queued", coordinatorDaemonId, coordinatorWorkspace, baseBranch };
+  } catch (e) {
+    return { mode: "pending_marker_queued", coordinatorDaemonId, error: e?.message || String(e) };
+  }
+}
 async function refineMergeAndFinalizeStage(self, ctx) {
   const { meshId, nodeId, args, repoRoot, baseHead, node, branch, baseBranch, sourceNode, validationSummary, patchEquivalence, submoduleReachability, mesh, refineStages, execFileAsync: execFileAsync4 } = ctx;
+  const leaseKey = `${repoRoot}::${baseBranch}`;
+  const leaseHolder = buildRefineJobKey(self, meshId, nodeId);
+  if (self.refineBaseLeases.has(leaseKey) && self.refineBaseLeases.get(leaseKey) !== leaseHolder) {
+    recordMeshRefineStage(refineStages, "base_lease", "skipped", Date.now(), {
+      leaseKey,
+      heldBy: self.refineBaseLeases.get(leaseKey),
+      retryable: true
+    });
+    return { kind: "terminal", result: {
+      success: false,
+      code: "base_locked",
+      convergenceStatus: "blocked_review",
+      retryable: true,
+      error: `Another refine holds the base lease for ${baseBranch} in this repo; retry after it completes.`,
+      branch,
+      into: baseBranch,
+      validationSummary,
+      patchEquivalence,
+      submoduleReachability,
+      refineStages,
+      finalBranchConvergenceState: {
+        branch,
+        baseBranch,
+        merged: false,
+        removed: false,
+        status: "blocked_review"
+      }
+    } };
+  }
+  self.refineBaseLeases.set(leaseKey, leaseHolder);
+  try {
+    return await runRefineMergeAndFinalizeLocked(self, ctx);
+  } finally {
+    if (self.refineBaseLeases.get(leaseKey) === leaseHolder) self.refineBaseLeases.delete(leaseKey);
+  }
+}
+async function runRefineMergeAndFinalizeLocked(self, ctx) {
+  const { meshId, nodeId, args, repoRoot, baseHead, node, branch, baseBranch, sourceNode, validationSummary, patchEquivalence, submoduleReachability, mesh, refineStages, execFileAsync: execFileAsync4 } = ctx;
+  const casStarted = Date.now();
+  let baseMoved = false;
+  let liveBaseHead;
+  try {
+    await execFileAsync4("git", ["fetch", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8" });
+    const { stdout } = await execFileAsync4("git", ["rev-parse", `origin/${baseBranch}`], { cwd: repoRoot, encoding: "utf8" });
+    liveBaseHead = stdout.trim();
+    baseMoved = !!liveBaseHead && liveBaseHead !== baseHead;
+  } catch {
+  }
+  if (baseMoved) {
+    recordMeshRefineStage(refineStages, "base_cas", "failed", casStarted, {
+      pinnedBaseHead: baseHead,
+      liveBaseHead,
+      retryable: true
+    });
+    return { kind: "terminal", result: {
+      success: false,
+      code: "base_moved",
+      convergenceStatus: "blocked_review",
+      retryable: true,
+      error: `Base ${baseBranch} advanced from ${baseHead.slice(0, 7)} to ${(liveBaseHead || "").slice(0, 7)} after this node was validated; re-run refine to rebase onto and re-validate the new base.`,
+      branch,
+      into: baseBranch,
+      pinnedBaseHead: baseHead,
+      liveBaseHead,
+      validationSummary,
+      patchEquivalence,
+      submoduleReachability,
+      refineStages,
+      finalBranchConvergenceState: {
+        branch,
+        baseBranch,
+        merged: false,
+        removed: false,
+        status: "blocked_review"
+      }
+    } };
+  }
+  recordMeshRefineStage(refineStages, "base_cas", "passed", casStarted, { pinnedBaseHead: baseHead });
   let mergeResult;
   const mergeStarted = Date.now();
   try {
@@ -61179,16 +61525,33 @@ async function refineMergeAndFinalizeStage(self, ctx) {
     };
     recordMeshRefineStage(refineStages, "merge", "passed", mergeStarted, mergeResult);
   } catch (e) {
+    const mergeOutput = `${e?.stdout || ""}
+${e?.stderr || ""}`;
+    const conflictPaths = [...mergeOutput.matchAll(/Merge conflict in (.+)/g)].map((m) => m[1].trim()).filter(Boolean);
+    try {
+      await execFileAsync4("git", ["merge", "--abort"], { cwd: repoRoot, encoding: "utf8" });
+    } catch {
+    }
     recordMeshRefineStage(refineStages, "merge", "failed", mergeStarted, {
       error: e?.message || String(e),
       stdout: truncateValidationOutput(e?.stdout),
-      stderr: truncateValidationOutput(e?.stderr)
+      stderr: truncateValidationOutput(e?.stderr),
+      ...conflictPaths.length ? { conflictPaths } : {}
     });
     return { kind: "terminal", result: {
       success: false,
-      error: `Merge failed (conflicts?): ${e.message}`,
+      code: "merge_failed",
+      convergenceStatus: "not_mergeable",
+      error: conflictPaths.length ? `Merge failed \u2014 conflicts in ${conflictPaths.length} path(s): ${conflictPaths.join(", ")}. The branch cannot fast-forward-merge onto ${baseBranch}; resolve conflicts (rebase the branch onto the fetched base) and retry.` : `Merge failed (conflicts?): ${e?.message || String(e)}`,
+      branch,
+      into: baseBranch,
+      ...conflictPaths.length ? { conflictPaths } : {},
       validationSummary,
       patchEquivalence,
+      mergeResult: {
+        stdout: truncateValidationOutput(e?.stdout),
+        stderr: truncateValidationOutput(e?.stderr)
+      },
       refineStages,
       finalBranchConvergenceState: {
         branch,
@@ -61244,6 +61607,93 @@ async function refineMergeAndFinalizeStage(self, ctx) {
       }
     } };
   }
+  const requireApprovalForPush = mesh?.policy?.requireApprovalForPush ?? DEFAULT_MESH_POLICY.requireApprovalForPush;
+  let pushResult;
+  if (!requireApprovalForPush) {
+    const pushStarted = Date.now();
+    try {
+      await execFileAsync4("git", ["push", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8" });
+      pushResult = { pushed: true, remote: "origin", branch: baseBranch, durationMs: Date.now() - pushStarted };
+      recordMeshRefineStage(refineStages, "push", "passed", pushStarted, pushResult);
+    } catch (e) {
+      pushResult = {
+        pushed: false,
+        remote: "origin",
+        branch: baseBranch,
+        error: e?.message || String(e),
+        stderr: e?.stderr,
+        durationMs: Date.now() - pushStarted
+      };
+      recordMeshRefineStage(refineStages, "push", "failed", pushStarted, pushResult);
+      return { kind: "terminal", result: {
+        success: false,
+        code: "push_failed",
+        convergenceStatus: "blocked_review",
+        retryable: true,
+        merged: true,
+        mergedLocal: true,
+        pushed: false,
+        error: `Refinery merged '${branch}' into local ${baseBranch} but the push to origin failed; the worktree and branch ref were preserved (NOT cleaned up) so the push can be retried. Run: git -C ${repoRoot} push origin ${baseBranch}`,
+        branch,
+        into: baseBranch,
+        pushResult,
+        pushCommand: `git push origin ${baseBranch}`,
+        validationSummary,
+        patchEquivalence,
+        submoduleReachability,
+        submoduleAlignment,
+        mergeResult,
+        refineStages,
+        finalBranchConvergenceState: {
+          branch: baseBranch,
+          mergedBranch: branch,
+          baseBranch,
+          merged: true,
+          pushed: false,
+          removed: false,
+          validation: "passed",
+          patchEquivalence: "passed",
+          submoduleAlignment: submoduleAlignment.status,
+          status: "merged_push_failed",
+          nextStep: `Retry the push (git -C ${repoRoot} push origin ${baseBranch}); then the worktree can be cleaned up.`
+        }
+      } };
+    }
+  } else {
+    recordMeshRefineStage(refineStages, "push", "skipped", Date.now(), {
+      reason: "require_approval_for_push"
+    });
+    return { kind: "terminal", result: {
+      success: true,
+      merged: true,
+      mergedLocal: true,
+      pushed: false,
+      branch,
+      into: baseBranch,
+      validationSummary,
+      patchEquivalence,
+      submoduleReachability,
+      submoduleAlignment,
+      mergeResult,
+      refineStages,
+      pushReady: true,
+      pushCommand: `git push origin ${baseBranch}`,
+      pushNote: "requireApprovalForPush is enabled \u2014 the merge landed on the local base but was NOT pushed and the worktree was NOT cleaned up. Run the push (or approve it), then re-run refine/cleanup to remove the worktree.",
+      finalBranchConvergenceState: {
+        branch: baseBranch,
+        mergedBranch: branch,
+        baseBranch,
+        merged: true,
+        pushed: false,
+        removed: false,
+        validation: "passed",
+        patchEquivalence: "passed",
+        submoduleAlignment: submoduleAlignment.status,
+        status: "merged_local_pending_push",
+        nextStep: `Approve and run the push (git -C ${repoRoot} push origin ${baseBranch}); the worktree is retained until then.`
+      }
+    } };
+  }
   const cleanupStarted = Date.now();
   const refineSessionCleanupMode = self.normalizeMeshSessionCleanupMode(
     mesh?.policy?.sessionCleanupOnNodeRemove
@@ -61271,10 +61721,10 @@ async function refineMergeAndFinalizeStage(self, ctx) {
     sessionCleanupMode: refineSessionCleanupMode,
     ...refineSessionIds && refineSessionIds.length > 0 ? { sessionIds: refineSessionIds } : {},
     inlineMesh: args?.inlineMesh,
-    // REFINE-CLEANUP: refine reaches cleanup only AFTER a verified merge
-    // convergence, so any residual worktree dirtiness here is incidental
-    // (e.g. a bootstrap lockfile rewrite) — never unmerged work. `force`
-    // sets requireClean=false so a plain-dirty worktree no longer aborts
+    // REFINE-CLEANUP: refine reaches cleanup only AFTER a verified merge AND a
+    // successful push (DS1), so any residual worktree dirtiness here is
+    // incidental (e.g. a bootstrap lockfile rewrite) — never unmerged work.
+    // `force` sets requireClean=false so a plain-dirty worktree no longer aborts
     // removal with merged_cleanup_failed. Branch-ref deletion still keys off
     // mergeConvergence (NOT the force flag), so no merged work can be lost.
     force: true
@@ -61291,7 +61741,7 @@ async function refineMergeAndFinalizeStage(self, ctx) {
     appendLedgerEntry2(meshId, {
       kind: "node_removed",
       nodeId,
-      payload: { refined: true, mergedBranch: branch, into: baseBranch, validationSummary, patchEquivalence, submoduleReachability, submoduleAlignment }
+      payload: { refined: true, mergedBranch: branch, into: baseBranch, pushed: true, validationSummary, patchEquivalence, submoduleReachability, submoduleAlignment }
     });
     recordMeshRefineStage(refineStages, "ledger", "passed", ledgerStarted);
   } catch (e) {
@@ -61303,21 +61753,24 @@ async function refineMergeAndFinalizeStage(self, ctx) {
     mergedBranch: branch,
     baseBranch,
     merged: true,
+    pushed: true,
     removed: removeResult?.success !== false,
     validation: "passed",
     patchEquivalence: "passed",
     submoduleAlignment: submoduleAlignment.status,
-    status: removeResult?.success === false ? "merged_cleanup_failed" : "merged"
+    status: removeResult?.success === false ? "merged_cleanup_failed" : "merged_pushed"
   };
   if (removeResult?.success === false) {
     return { kind: "terminal", result: {
       success: false,
       code: "cleanup_failed",
-      error: "Refinery merge completed but worktree cleanup failed; manual cleanup/retry is required.",
+      error: "Refinery merge + push completed but worktree cleanup failed; the change is on origin \u2014 manual worktree cleanup/retry is required.",
       merged: true,
+      pushed: true,
       branch,
       into: baseBranch,
       removeResult,
+      pushResult,
       validationSummary,
       patchEquivalence,
       submoduleReachability,
@@ -61328,33 +61781,35 @@ async function refineMergeAndFinalizeStage(self, ctx) {
       finalBranchConvergenceState
     } };
   }
-  const requireApprovalForPush = mesh?.policy?.requireApprovalForPush ?? DEFAULT_MESH_POLICY.requireApprovalForPush;
-  let pushResult;
-  if (!requireApprovalForPush) {
-    const pushStarted = Date.now();
-    try {
-      await execFileAsync4("git", ["push", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8" });
-      pushResult = { pushed: true, remote: "origin", branch: baseBranch, durationMs: Date.now() - pushStarted };
-      recordMeshRefineStage(refineStages, "push", "passed", pushStarted, pushResult);
-      finalBranchConvergenceState.status = "merged_pushed";
-    } catch (e) {
-      pushResult = {
-        pushed: false,
-        remote: "origin",
-        branch: baseBranch,
-        error: e?.message || String(e),
-        stderr: e?.stderr,
-        durationMs: Date.now() - pushStarted
-      };
-      recordMeshRefineStage(refineStages, "push", "failed", pushStarted, pushResult);
+  let coordinatorCatchup;
+  try {
+    coordinatorCatchup = await requestCoordinatorLocalCatchup(self, {
+      meshId,
+      ctx,
+      mesh,
+      baseBranch,
+      repoRoot
+    });
+    if (coordinatorCatchup) {
+      recordMeshRefineStage(refineStages, "coordinator_catchup", "passed", Date.now(), coordinatorCatchup);
     }
+  } catch {
   }
+  const cleanupBranchRefWarning = typeof removeResult?.branchRefWarning === "string" ? removeResult.branchRefWarning : void 0;
+  const cleanupResidueWarning = typeof removeResult?.residueWarning === "string" ? removeResult.residueWarning : void 0;
+  const cleanupBranchRefDeleted = typeof removeResult?.worktreeCleanup?.branchRefDeleted === "boolean" ? removeResult.worktreeCleanup.branchRefDeleted : void 0;
   return { kind: "terminal", result: {
     success: true,
     merged: true,
+    pushed: true,
     branch,
     into: baseBranch,
     removeResult,
+    pushResult,
+    ...coordinatorCatchup ? { coordinatorCatchup } : {},
+    ...cleanupBranchRefWarning ? { branchRefWarning: cleanupBranchRefWarning } : {},
+    ...cleanupResidueWarning ? { residueWarning: cleanupResidueWarning } : {},
+    ...cleanupBranchRefDeleted !== void 0 ? { branchRefDeleted: cleanupBranchRefDeleted } : {},
     validationSummary,
     patchEquivalence,
     submoduleReachability,
@@ -61362,13 +61817,7 @@ async function refineMergeAndFinalizeStage(self, ctx) {
     mergeResult,
     refineStages,
     ...ledgerError ? { ledgerError } : {},
-    finalBranchConvergenceState,
-    // Push outcome or readiness info for coordinator.
-    ...pushResult ? { pushResult } : {
-      pushReady: true,
-      pushCommand: `git push origin ${baseBranch}`,
-      pushNote: "requireApprovalForPush is enabled \u2014 run the push command or obtain user approval before pushing."
-    }
+    finalBranchConvergenceState
   } };
 }
 async function batchRefineMeshNodes(self, meshId, requestedNodeIds, args) {
@@ -61523,29 +61972,34 @@ async function batchRefineMeshNodes(self, meshId, requestedNodeIds, args) {
   }
   return runMeshRefineBatchConvergence(self, meshId, orderedNodes, ordering, args);
 }
+var RETRYABLE_BASE_MOVEMENT_CODES = /* @__PURE__ */ new Set(["base_moved", "base_locked"]);
+function classifyBatchNodeConvergence(result) {
+  const code = typeof result.code === "string" ? result.code : "";
+  const stage = Array.isArray(result.refineStages) ? result.refineStages.filter((s2) => s2.status === "failed").map((s2) => s2.stage).filter(Boolean).pop() : void 0;
+  let convergence;
+  if (code === "already_merged" && result.alreadyMergedViaOtherPath) {
+    convergence = "skipped_patch_equivalent";
+  } else if (result.success === true) {
+    convergence = "merged_to_main";
+  } else if (code === "merge_failed" || stage === "merge") {
+    convergence = "not_mergeable";
+  } else {
+    convergence = "blocked_review";
+  }
+  const retryable = convergence === "blocked_review" && (result.retryable === true || RETRYABLE_BASE_MOVEMENT_CODES.has(code));
+  return { convergence, code, retryable, ...stage ? { stage } : {} };
+}
 async function runMeshRefineBatchConvergence(self, meshId, orderedNodes, ordering, args) {
-  const results = [];
-  for (const node of orderedNodes) {
+  const refineOne = async (node) => {
     let result;
     try {
       result = await executeMeshRefineNodeSynchronously(self, meshId, node.id, args);
     } catch (e) {
       result = { success: false, error: e?.message || String(e) };
     }
-    const code = typeof result.code === "string" ? result.code : "";
-    let convergence;
-    if (code === "already_merged" && result.alreadyMergedViaOtherPath) {
-      convergence = "skipped_patch_equivalent";
-    } else if (result.success === true) {
-      convergence = "merged_to_main";
-    } else if (code === "merge_failed") {
-      convergence = "not_mergeable";
-    } else {
-      convergence = "blocked_review";
-    }
+    const { convergence, code, stage, retryable } = classifyBatchNodeConvergence(result);
     const fbcs = result.finalBranchConvergenceState && typeof result.finalBranchConvergenceState === "object" ? result.finalBranchConvergenceState : void 0;
-    const stage = Array.isArray(result.refineStages) ? result.refineStages.filter((s2) => s2.status === "failed").map((s2) => s2.stage).filter(Boolean).pop() : void 0;
-    results.push({
+    return {
       nodeId: node.id,
       workspace: node.workspace,
       convergence,
@@ -61553,14 +62007,30 @@ async function runMeshRefineBatchConvergence(self, meshId, orderedNodes, orderin
       ...typeof result.blockedReason === "string" ? { reason: result.blockedReason } : {},
       ...stage ? { stage } : {},
       ...typeof result.error === "string" ? { error: result.error } : {},
+      ...retryable ? { retryable: true } : {},
       ...fbcs ? { finalBranchConvergenceState: fbcs } : {}
-    });
+    };
+  };
+  const results = [];
+  const retryQueue = [];
+  for (const node of orderedNodes) {
+    const outcome = await refineOne(node);
+    results.push(outcome);
+    if (outcome.retryable) retryQueue.push(node);
+  }
+  for (const node of retryQueue) {
+    const idx = results.findIndex((r) => r.nodeId === node.id);
+    const retried = await refineOne(node);
+    retried.retried = true;
+    if (idx >= 0) results[idx] = retried;
+    else results.push(retried);
   }
   const summary = {
     merged: results.filter((r) => r.convergence === "merged_to_main").length,
     skipped: results.filter((r) => r.convergence === "skipped_patch_equivalent").length,
     blocked: results.filter((r) => r.convergence === "blocked_review").length,
-    notMergeable: results.filter((r) => r.convergence === "not_mergeable").length
+    notMergeable: results.filter((r) => r.convergence === "not_mergeable").length,
+    ...retryQueue.length ? { retried: retryQueue.length } : {}
   };
   const allConverged = summary.blocked === 0 && summary.notMergeable === 0;
   return {
@@ -61773,7 +62243,7 @@ async function finishMeshRefineJob(self, handle, args) {
   }
   const completedAt = (/* @__PURE__ */ new Date()).toISOString();
   const refineCode = typeof result.code === "string" ? result.code : "";
-  const refineTerminalKind = result.success === true ? "completed" : refineCode === "blocked_review" ? "blocked_review" : refineCode === "validation_failed" || refineCode === "validation_dependencies_missing" ? "validation_failed" : refineCode === "submodule_reachability_failed" ? "submodule_reachability_failed" : refineCode === "merge_failed" || refineCode === "patch_equivalence_failed" || refineCode === "needs_rebase" || refineCode === "needs_rebase_with_conflicts" ? "merge_failed" : refineCode === "cleanup_failed" ? "cleanup_failed" : "merge_failed";
+  const refineTerminalKind = result.success === true ? "completed" : refineCode === "blocked_review" ? "blocked_review" : refineCode === "validation_failed" || refineCode === "validation_dependencies_missing" || refineCode === "missing_dependencies" || refineCode === "dependency_bootstrap_failed" || refineCode === "spawn_resolution_failed" || refineCode === "validation_unavailable" ? "validation_failed" : refineCode === "submodule_reachability_failed" ? "submodule_reachability_failed" : refineCode === "merge_failed" || refineCode === "patch_equivalence_failed" || refineCode === "needs_rebase" || refineCode === "needs_rebase_with_conflicts" ? "merge_failed" : refineCode === "cleanup_failed" ? "cleanup_failed" : "merge_failed";
   const isTerminalSuccess = refineTerminalKind === "completed";
   const blockerContext = isTerminalSuccess ? void 0 : (() => {
     const code = typeof result.code === "string" ? result.code : refineTerminalKind;
@@ -61804,9 +62274,12 @@ async function finishMeshRefineJob(self, handle, args) {
     }
     if (stage === "validation" && result.validationSummary) {
       const vs = result.validationSummary;
+      const diagnostics = extractValidationFailureDiagnostics(vs);
       ctx.details = {
         failureCode: vs.failureCode,
-        commandsRun: Array.isArray(vs.commandsRun) ? vs.commandsRun.length : void 0
+        failureKind: vs.failureKind,
+        commandsRun: Array.isArray(vs.commandsRun) ? vs.commandsRun.length : void 0,
+        ...diagnostics ? { failure: diagnostics } : {}
       };
     }
     return ctx;
@@ -62841,6 +63314,15 @@ var DaemonCommandRouter = class {
   runningRefineBatchJobs = /* @__PURE__ */ new Map();
   /** Terminal async batch Refinery jobs preserve the last batch outcome for late readers. */
   terminalRefineBatchJobs = /* @__PURE__ */ new Map();
+  /**
+   * DS2: in-process refinement leases keyed by `${repoRoot}::${baseBranch}`. Serialize
+   * the base-mutating window (candidate-SHA pin → merge → push) of concurrent single-node
+   * refines that target the SAME base branch in the same repo, so two refines cannot both
+   * validate against one baseHead and then race their merges (the base-movement race). The
+   * batch path is already sequential, so this only matters for overlapping single-node
+   * async jobs. Value = the meshId:nodeId job key holding the lease (for diagnostics).
+   */
+  refineBaseLeases = /* @__PURE__ */ new Map();
   constructor(deps) {
     this.deps = deps;
   }