@ricsam/r5d-worker 0.0.135 → 0.0.137

package/dist/cjs/main.cjs

@@ -4301,6 +4301,8 @@ async function startWorker(options, projectRuntime = {
     });
   };
   const projectBranchMountBusy = (projectId, branchName, branchPath) => !readyProjectIds.has(projectId) || projectBranchMountActivityBusy(projectId, branchName, branchPath);
+  const projectBranchMountFenced = (projectId, branchName, branchPath) => !readyProjectIds.has(projectId) || projectConfigById.get(projectId)?.executionDisabled === true || hasProjectWorktree(branchPath) && (0, import_project_worktrees.projectWorktreeOperationInProgress)(branchPath) || canonicalWorkspaceMutationIsActive(activeWorkspaceMutationTargets());
+  const projectBranchMountProcessLive = (projectId, branchName) => (0, import_workspace_automatic_sync_policy.projectBranchHasActiveWorkspaceTarget)(projectId, branchName, activeWorkspaceMutationTargets());
   const inventoryConfiguredProjectCheckouts = () => {
     const inventory = { projects: [], missingCheckouts: [] };
     for (const project of projectConfigById.values()) {
@@ -4386,7 +4388,11 @@ async function startWorker(options, projectRuntime = {
               ].filter((id) => typeof id === "string")
             )
           ].join(", ") || "no live declared holder",
-          busy: () => projectBranchMountBusy(project.projectId, branch.branchName, branchPath),
+          // A running job no longer pins its checkout: merge hydration folds
+          // inbound changes into it. The plan mount below keeps the old fence
+          // because its all-mode hydration is a plain mirror.
+          busy: () => projectBranchMountFenced(project.projectId, branch.branchName, branchPath),
+          processLive: () => projectBranchMountProcessLive(project.projectId, branch.branchName),
           mutationToken: () => projectWorkspaceMutationToken(project.projectId, branch.branchName),
           busyForRecovery: () => projectBranchMountExclusiveSyncBusy(project.projectId, branch.branchName, branchPath)
         });

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.135",
+  "version": "0.0.137",
   "type": "commonjs"
 }

package/dist/cjs/workspace-git-sync.cjs

@@ -36,6 +36,7 @@ __export(workspace_git_sync_exports, {
   WORKSPACE_GIT_HYDRATION_RECOVERIES: () => WORKSPACE_GIT_HYDRATION_RECOVERIES,
   WORKSPACE_GIT_HYDRATION_TRANSACTION: () => WORKSPACE_GIT_HYDRATION_TRANSACTION,
   WORKSPACE_MERGE_HYDRATION_SWITCH: () => WORKSPACE_MERGE_HYDRATION_SWITCH,
+  WORKSPACE_PROCESS_BUSY_FENCE_SWITCH: () => WORKSPACE_PROCESS_BUSY_FENCE_SWITCH,
   WorkspaceHydrationRecoveryRequiredError: () => WorkspaceHydrationRecoveryRequiredError,
   WorkspaceRemediationAncestryError: () => WorkspaceRemediationAncestryError,
   configureExistingWorkspaceGitForRemediation: () => configureExistingWorkspaceGitForRemediation,
@@ -86,12 +87,20 @@ const WORKSPACE_MERGE_HYDRATION_SWITCH = "R5D_MERGE_HYDRATION";
 function workspaceMergeHydrationEnabled() {
   return process.env[WORKSPACE_MERGE_HYDRATION_SWITCH] !== "0";
 }
+const WORKSPACE_PROCESS_BUSY_FENCE_SWITCH = "R5D_PROCESS_BUSY_FENCE";
+function workspaceProcessBusyFenceEnabled() {
+  return process.env[WORKSPACE_PROCESS_BUSY_FENCE_SWITCH] === "1";
+}
+function mountBusy(mount) {
+  if (mount.busy !== void 0 && mount.busy()) return true;
+  return workspaceProcessBusyFenceEnabled() && mount.processLive?.() === true;
+}
 const hydrationPreBlobLedgers = /* @__PURE__ */ new Map();
 function hydrationPreBlobLedger(workspacePath) {
   const key = import_node_path.default.resolve(workspacePath);
   let ledger = hydrationPreBlobLedgers.get(key);
   if (!ledger) {
-    ledger = new import_workspace_hydration_ledger.WorkspaceHydrationPreBlobLedger();
+    ledger = new import_workspace_hydration_ledger.WorkspaceHydrationLedger();
     hydrationPreBlobLedgers.set(key, ledger);
   }
   return ledger;
@@ -531,7 +540,7 @@ function workspaceGitHydrationHolds(workspacePath, mounts, tolerateIdleRecordedB
   if (head === null) return true;
   if (!receipt) return false;
   return mounts ? configuredWorkspaceHydrationBasisMounts(resolvedWorkspacePath, mounts).every(
-    (mount) => workspaceHydrationReceiptCoversMount(receipt, head, mount) || Boolean((tolerateIdleRecordedBasis || mount.busy?.()) && workspaceHydrationReceiptMountBasisHead(receipt, mount))
+    (mount) => workspaceHydrationReceiptCoversMount(receipt, head, mount) || Boolean((tolerateIdleRecordedBasis || mountBusy(mount)) && workspaceHydrationReceiptMountBasisHead(receipt, mount))
   ) : Boolean(receipt && receipt.mounts.every((mount) => tolerateIdleRecordedBasis || mount.head === head));
 }
 const WORKSPACE_GIT_BASIS_REF_PREFIX = "refs/r5d/workspace-basis/";
@@ -1492,6 +1501,12 @@ function resolveGitObjectsSync(workspacePath, names) {
   });
   return resolved;
 }
+function storeWorkspaceBlobs(workspacePath, blobs) {
+  for (const [objectId, content] of blobs) {
+    const written = gitOutputSync(workspacePath, ["hash-object", "-w", "-t", "blob", "--no-filters", "--stdin"], "store hydration ledger blob", content).toString().trim();
+    if (written !== objectId) throw new Error(`Hydration ledger blob ${objectId} was stored as ${written}`);
+  }
+}
 function readWorkspaceBlobs(workspacePath, objectIds) {
   const blobs = /* @__PURE__ */ new Map();
   const unique = [...new Set(objectIds)];
@@ -1983,7 +1998,7 @@ function activeMounts(mounts) {
   const tombstones = [];
   const skipped = [];
   for (const mount of mounts) {
-    if (mount.busy?.()) skipped.push(mount);
+    if (mountBusy(mount)) skipped.push(mount);
     else if (import_node_fs.default.existsSync(mount.sourcePath)) active.push(mount);
     else if (mount.deleteWhenSourceMissing) tombstones.push(mount);
     else skipped.push(mount);
@@ -2121,9 +2136,9 @@ function hydrateWorkspaceGitMountsRaw(workspacePath, mounts, options = {}) {
   const skippedMountIds = [];
   const mergeSkips = [];
   const rollbackScopes = /* @__PURE__ */ new Map();
-  const preBlobs = {};
+  const ledgerEntries = {};
   for (const mount of mounts) {
-    if (!options.ignoreBusy && mount.busy?.()) {
+    if (!options.ignoreBusy && mountBusy(mount)) {
       skippedMountIds.push(mount.id);
       continue;
     }
@@ -2170,7 +2185,20 @@ function hydrateWorkspaceGitMountsRaw(workspacePath, mounts, options = {}) {
         continue;
       }
       hydratedMountIds.push(mount.id);
-      preBlobs[mount.id] = Object.fromEntries(mergePlan.decision.preBlobs);
+      storeWorkspaceBlobs(workspacePath, mergePlan.decision.blobsToStore);
+      const left = /* @__PURE__ */ new Map();
+      for (const entry of journal.entries) left.set(entry.relativePath, entry.after);
+      const entries = {};
+      for (const [relativePath, preBlob] of mergePlan.decision.preBlobs) {
+        const postBlob = mergePlan.decision.postBlobs.get(relativePath) ?? null;
+        let after = left.get(relativePath);
+        if (after === void 0) {
+          const current = (0, import_working_tree_mirror.inspectWorkingTreePath)(mount.sourcePath, relativePath);
+          after = current.kind === "entry" ? current.stat : null;
+        }
+        entries[relativePath] = { preBlob, postBlob, stat: after && after.isFile() ? (0, import_working_tree_mirror.projectedFileEntry)(after) : null };
+      }
+      ledgerEntries[mount.id] = entries;
       continue;
     }
     const sourceRoot = workspaceMountOuterPath(workspacePath, mount);
@@ -2218,7 +2246,7 @@ function hydrateWorkspaceGitMountsRaw(workspacePath, mounts, options = {}) {
     });
     hydratedMountIds.push(mount.id);
   }
-  return { hydratedMountIds: hydratedMountIds.sort(), skippedMountIds: skippedMountIds.sort(), mergeSkips, rollbackScopes, preBlobs };
+  return { hydratedMountIds: hydratedMountIds.sort(), skippedMountIds: skippedMountIds.sort(), mergeSkips, rollbackScopes, ledgerEntries };
 }
 async function selectMountsWithUnchangedOuterSubtree(workspacePath, receipt, head, mounts) {
   const candidates = mounts.flatMap((mount) => {
@@ -2259,7 +2287,7 @@ async function hydrateWorkspaceGitMountsTransactionally(input) {
   const targetHead = input.recordCurrentHead ? await revParseAsync(workspacePath, "HEAD") : null;
   const receiptBeforeTransaction = targetHead ? await readHydratedWorkspaceReceiptAsync(workspacePath) : null;
   const computeSelection = () => {
-    const busyMountIds = new Set(input.ignoreBusy ? [] : candidateMounts.filter((mount) => mount.busy?.()).map(({ id }) => id));
+    const busyMountIds = new Set(input.ignoreBusy ? [] : candidateMounts.filter((mount) => mountBusy(mount)).map(({ id }) => id));
     const requestedIds = new Set(input.mounts.map(({ id }) => id));
     const requiredIds = new Set(requiredMounts.map(({ id }) => id));
     const hydrationMounts = input.mounts.filter(({ id }) => !busyMountIds.has(id));
@@ -2278,7 +2306,7 @@ async function hydrateWorkspaceGitMountsTransactionally(input) {
   };
   const noopCandidate = computeSelection();
   if (noopCandidate.hydrationMounts.length === 0 && noopCandidate.advancedDurabilityMounts.length === 0 && noopCandidate.targetReceipt && lstatIfExists(hydrationTransactionPath(workspacePath)) === null && workspaceHydrationReceiptsEqual(receiptBeforeTransaction, noopCandidate.targetReceipt) && await hydratedWorkspaceReceiptFileIsV3(workspacePath) && await workspaceBasisRefsAreCurrentAsync(workspacePath, noopCandidate.targetReceipt)) {
-    return { hydratedMountIds: [], skippedMountIds: noopCandidate.skippedMountIds, mergeSkips: [] };
+    return { hydratedMountIds: [], skippedMountIds: noopCandidate.skippedMountIds, mergeSkips: [], hydratedEntryPaths: {} };
   }
   const hooks = input.hydrationHooks;
   const context = {
@@ -2298,6 +2326,7 @@ async function hydrateWorkspaceGitMountsTransactionally(input) {
         const basis = input.mergeBases?.get(mount.id);
         if (basis) mergeBases[mount.id] = basis;
       }
+      const liveBefore = new Set(hydrationMounts.filter((mount) => mergeBases[mount.id] && mount.processLive?.()).map(({ id }) => id));
       const hydration = await (0, import_workspace_filesystem_executor.workspaceFilesystemExecutor)().run("hydration_transaction", {
         workspacePath,
         hydrationMounts: hydrationMounts.map(workspaceGitMountData),
@@ -2306,16 +2335,27 @@ async function hydrateWorkspaceGitMountsTransactionally(input) {
         ...Object.keys(mergeBases).length > 0 ? { mergeBases } : {}
       });
       const ledger = hydrationPreBlobLedger(workspacePath);
+      const hydratedEntryPaths = {};
       for (const mount of hydrationMounts) {
         if (!hydration.hydratedMountIds.includes(mount.id)) continue;
-        const preBlobs = mergeBases[mount.id] ? hydration.hydratedPreBlobs[mount.id] : void 0;
-        if (preBlobs) ledger.record(mount, preBlobs);
-        else ledger.clearMount(mount);
+        const entries = mergeBases[mount.id] ? hydration.hydratedEntries[mount.id] : void 0;
+        if (!entries) {
+          ledger.clearMount(mount);
+          continue;
+        }
+        const processLiveAcrossHydration = liveBefore.has(mount.id) || mount.processLive?.() === true;
+        hydratedEntryPaths[mount.id] = Object.keys(entries).sort();
+        ledger.record(
+          mount,
+          Object.fromEntries(Object.entries(entries).map(([relativePath, entry]) => [relativePath, { ...entry, processLiveAcrossHydration }])),
+          { replacePreBlobFor: input.ledgerMergedPaths?.get(mount.id) ?? [] }
+        );
       }
       return {
         hydratedMountIds: hydration.hydratedMountIds,
         skippedMountIds: [.../* @__PURE__ */ new Set([...selection.skippedMountIds, ...hydration.skippedMounts.map(({ mountId }) => mountId)])].sort(),
-        mergeSkips: hydration.skippedMounts
+        mergeSkips: hydration.skippedMounts,
+        hydratedEntryPaths
       };
     } finally {
       releaseHold?.();
@@ -2380,7 +2420,7 @@ function runHydrationTransactionJob(input) {
     markHydrationTransactionDurable(workspacePath);
     if (targetReceipt) updateHydratedWorkspaceReceipt(workspacePath, targetReceipt);
     removeHydrationTransaction(workspacePath);
-    return { hydratedMountIds: hydration.hydratedMountIds, skippedMounts, hydratedPreBlobs: hydration.preBlobs };
+    return { hydratedMountIds: hydration.hydratedMountIds, skippedMounts, hydratedEntries: hydration.ledgerEntries };
   } catch (error) {
     const transactionPath = hydrationTransactionPath(workspacePath);
     if (lstatIfExists(transactionPath) && hydrationTransactionCommitted(transactionPath)) {
@@ -2434,7 +2474,7 @@ async function hydrateWorkspaceGitMounts(workspacePath, mounts, options = {}) {
   const resolvedWorkspacePath = import_node_path.default.resolve(workspacePath);
   const gitDirectory = import_node_path.default.join(resolvedWorkspacePath, ".git");
   if (!import_node_fs.default.existsSync(gitDirectory)) {
-    const skippedMountIds = options.ignoreBusy ? [] : mounts.filter((mount) => mount.busy?.()).map(({ id }) => id).sort();
+    const skippedMountIds = options.ignoreBusy ? [] : mounts.filter((mount) => mountBusy(mount)).map(({ id }) => id).sort();
     const skipped = new Set(skippedMountIds);
     const selected = mounts.filter(({ id }) => !skipped.has(id));
     const releaseHold = options.hydrationHooks?.holdMounts(
@@ -2479,7 +2519,7 @@ async function recoverWorkspaceGitHydration(workspacePath, mounts, options = {})
     (mount) => !workspaceHydrationReceiptCoversMount(currentReceipt, currentHead, mount)
   );
   if (workspaceHydrationReceiptMatchesMounts(currentReceipt, currentHead, configuredBasisMounts)) return;
-  const busyMountIds = new Set(options.ignoreBusy ? [] : uncoveredBasisMounts.filter((mount) => mount.busy?.()).map(({ id }) => id));
+  const busyMountIds = new Set(options.ignoreBusy ? [] : uncoveredBasisMounts.filter((mount) => mountBusy(mount)).map(({ id }) => id));
   const recoveryMounts = uncoveredBasisMounts.filter(
     (mount) => workspaceHydrationReceiptMountBasisHead(currentReceipt, mount) === null || !options.preserveStaleBases && !busyMountIds.has(mount.id) && workspaceHydrationReceiptMountBasisHead(preservedBases, mount) !== workspaceHydrationReceiptMountBasisHead(currentReceipt, mount)
   );
@@ -2507,7 +2547,7 @@ async function recoverWorkspaceGitHydration(workspacePath, mounts, options = {})
 async function resetWorkspaceGit(input) {
   const workspacePath = import_node_path.default.resolve(input.workspacePath);
   validateMounts(workspacePath, input.mounts);
-  const busyResetMountIds = input.mounts.filter((mount) => mount.busy?.()).map(({ id }) => id);
+  const busyResetMountIds = input.mounts.filter((mount) => mountBusy(mount)).map(({ id }) => id);
   if (busyResetMountIds.length > 0) {
     throw new Error(`Workspace reset cannot run while mounts are busy: ${busyResetMountIds.sort().join(", ")}`);
   }
@@ -2539,7 +2579,7 @@ async function resetWorkspaceGit(input) {
   const selected = activeMounts(input.mounts);
   const requiredLiveMountsBeforeHydration = input.mounts.filter(({ sourcePath }) => import_node_fs.default.existsSync(sourcePath));
   const bootstrapMounts = selected.skipped.filter((mount) => {
-    if (mount.deleteWhenSourceMissing || import_node_fs.default.existsSync(mount.sourcePath) || mount.busy?.()) return false;
+    if (mount.deleteWhenSourceMissing || import_node_fs.default.existsSync(mount.sourcePath) || mountBusy(mount)) return false;
     const outerPath = import_node_path.default.join(workspacePath, ...mount.workspaceRelativePath.replace(/\\/g, "/").split("/"));
     return import_node_fs.default.existsSync(outerPath);
   });
@@ -2860,10 +2900,12 @@ async function runWorkspaceGitSynchronization(input, remoteHeadFetches) {
   const projectedMountBases = /* @__PURE__ */ new Map();
   const mountSkipReasons = {};
   const staleRewriteLedger = hydrationPreBlobLedger(workspacePath);
-  const staleRewriteBlobsFor = (mount) => {
-    const preBlobs = staleRewriteLedger.preBlobs(mount);
-    return preBlobs.size > 0 ? Object.fromEntries(preBlobs) : void 0;
+  const hydrationLedgerFor = (mount) => {
+    const entries = staleRewriteLedger.entries(mount);
+    return entries.size > 0 ? Object.fromEntries(entries) : void 0;
   };
+  const forceHydrationMountIds = /* @__PURE__ */ new Set();
+  const ledgerMergedPathsByMount = /* @__PURE__ */ new Map();
   const recordStaleRewrite = (mount, paths) => {
     projectionSkippedIds.add(mount.id);
     mountSkipReasons[mount.id] = { reason: "stale_rewrite_detected", paths: [...paths] };
@@ -2877,7 +2919,7 @@ async function runWorkspaceGitSynchronization(input, remoteHeadFetches) {
     for (const mount of mounts) {
       const projectionToken = projectionMutationTokens.get(mount.id);
       if (projectionToken !== void 0 && mount.mutationToken?.() !== projectionToken) cycleSkippedMountIds.add(mount.id);
-      if (mount.busy?.()) cycleSkippedMountIds.add(mount.id);
+      if (mountBusy(mount)) cycleSkippedMountIds.add(mount.id);
     }
   };
   const classifyMounts = (activeCandidates, additionalSkippedIds = []) => {
@@ -2900,16 +2942,128 @@ async function runWorkspaceGitSynchronization(input, remoteHeadFetches) {
     };
   };
   const mountProjectionIsCurrent = (mount) => mount.lastProjectedMutationToken !== void 0 && !mount.deleteWhenSourceMissing && mount.preserveLocalOnHydrationBasisChange !== true && projectionBasisHead !== null && workspaceHydrationReceiptMountBasisHead(projectionBasisReceipt, mount) === projectionBasisHead && projectionMutationTokens.get(mount.id) === mount.lastProjectedMutationToken && mount.mutationToken?.() === mount.lastProjectedMutationToken;
+  const mergeProjectMount = async (mount, basisHead, currentHead) => {
+    const releaseMergeHold = input.hydrationHooks?.holdMounts([mount.id], `merge projection of mount ${mount.id}`);
+    let merged;
+    try {
+      const hydrationLedger = hydrationLedgerFor(mount);
+      merged = await (0, import_workspace_filesystem_executor.workspaceFilesystemExecutor)().run("projection_merge", {
+        workspacePath,
+        mount: {
+          id: mount.id,
+          sourcePath: mount.sourcePath,
+          workspaceRelativePath: normalizedWorkspaceMountPath(mount.workspaceRelativePath),
+          sourceMode: mount.sourceMode
+        },
+        basisHead,
+        currentHead,
+        attemptId,
+        ...hydrationLedger ? { hydrationLedger } : {}
+      });
+    } finally {
+      releaseMergeHold?.();
+    }
+    if (merged.staleRewriteCleared.length > 0) staleRewriteLedger.forget(mount, merged.staleRewriteCleared);
+    if (merged.kind === "stale_rewrite") {
+      recordStaleRewrite(mount, merged.paths);
+      return { kind: "skipped" };
+    }
+    if (merged.kind === "conflict" && mount.processLive?.()) {
+      projectionSkippedIds.add(mount.id);
+      mountSkipReasons[mount.id] = { reason: "projection_conflict_deferred", paths: merged.conflictPaths };
+      const holders = mount.describeHolders?.();
+      process.stderr.write(
+        `[r5d-worker] projection of mount ${mount.id} conflicts with the workspace head at ${merged.conflictPaths.join(", ")}; deferred while a process runs in the checkout${holders ? ` (${holders})` : ""}, reported once the mount is idle
+`
+      );
+      return { kind: "skipped" };
+    }
+    mergedProjectionBases.set(mount.id, {
+      projectedCommit: merged.oursCommit,
+      projectedFiles: merged.projectedFiles,
+      readAtMs: merged.readAtMs
+    });
+    if (merged.kind === "conflict") {
+      const refs = snapshotConflict({ workspacePath, attemptId, localHead: merged.oursCommit, remoteHead: currentHead });
+      return {
+        kind: "conflict",
+        result: {
+          outcome: "conflict_blocked",
+          startingHead,
+          localHead: merged.oursCommit,
+          remoteHead: initial.remoteHead,
+          publishedHead: initial.remoteHead,
+          rebaseCount: 0,
+          diffSizeBytes: 0,
+          affectedPaths: merged.conflictPaths,
+          activeMountIds: [],
+          skippedMountIds: input.mounts.map(({ id }) => id).sort(),
+          conflictPaths: merged.conflictPaths,
+          conflictSnapshotRefs: refs,
+          conflictKind: "projection_merge",
+          ...verifiedAncestorHeads ? { verifiedAncestorHeads } : {},
+          error: merged.error
+        }
+      };
+    }
+    mergedProjectionTrees.set(mount.id, merged.resultTree);
+    mergedProjectionMounts.push(mount);
+    if (merged.ledgerMergedPaths.length > 0) {
+      forceHydrationMountIds.add(mount.id);
+      ledgerMergedPathsByMount.set(mount.id, merged.ledgerMergedPaths);
+    }
+    return { kind: "projected" };
+  };
   if (!input.skipMountMirror) {
     const mergeProjectionEnabled = process.env.R5D_WORKSPACE_MERGE_PROJECTION !== "0";
     const mergeSupport = mergeProjectionEnabled ? (0, import_workspace_merge_projection.workspaceMergeProjectionSupport)() : { supported: false, error: "Workspace merge projection is disabled by R5D_WORKSPACE_MERGE_PROJECTION=0" };
+    const activeProjectionIds = new Set(selected.active.map(({ id }) => id));
     for (const mount of [...selected.active, ...selected.tombstones]) {
       if (deferredMountIds.has(mount.id)) continue;
       const basisHead = workspaceHydrationReceiptMountBasisHead(projectionBasisReceipt, mount);
-      if (projectionBasisHead === null || basisHead === projectionBasisHead) {
+      if (projectionBasisHead === null) {
         fastProjectionMounts.push(mount);
         continue;
       }
+      if (basisHead === projectionBasisHead) {
+        const hydrationLedger = activeProjectionIds.has(mount.id) ? hydrationLedgerFor(mount) : void 0;
+        if (!hydrationLedger || !Object.values(hydrationLedger).some(({ processLiveAcrossHydration }) => processLiveAcrossHydration) || !mergeSupport.supported) {
+          fastProjectionMounts.push(mount);
+          continue;
+        }
+        if (cycleSkippedMountIds.has(mount.id) || mountBusy(mount)) {
+          cycleSkippedMountIds.add(mount.id);
+          continue;
+        }
+        const releaseCheckHold = input.hydrationHooks?.holdMounts([mount.id], `hydration ledger check of mount ${mount.id}`);
+        let checked;
+        try {
+          checked = await (0, import_workspace_filesystem_executor.workspaceFilesystemExecutor)().run("projection_mirror", {
+            workspacePath,
+            mount: workspaceGitMountData(mount),
+            hydrationLedger,
+            checkOnly: true
+          });
+        } finally {
+          releaseCheckHold?.();
+        }
+        if (checked.staleRewriteCleared.length > 0) staleRewriteLedger.forget(mount, checked.staleRewriteCleared);
+        if (checked.staleRewritePaths.length > 0) {
+          recordStaleRewrite(mount, checked.staleRewritePaths);
+          continue;
+        }
+        if (checked.ledgerMergePaths.length === 0) {
+          fastProjectionMounts.push(mount);
+          continue;
+        }
+        if (cycleSkippedMountIds.has(mount.id) || mountBusy(mount)) {
+          cycleSkippedMountIds.add(mount.id);
+          continue;
+        }
+        const outcome2 = await mergeProjectMount(mount, projectionBasisHead, projectionBasisHead);
+        if (outcome2.kind === "conflict") return outcome2.result;
+        continue;
+      }
       if (basisHead === null) {
         deferredMountIds.add(mount.id);
         continue;
@@ -2919,62 +3073,12 @@ async function runWorkspaceGitSynchronization(input, remoteHeadFetches) {
         projectionWarning = mergeSupport.error ?? "Git 2.40 or newer is required for stale workspace mount projection";
         continue;
       }
-      if (cycleSkippedMountIds.has(mount.id) || mount.busy?.()) {
+      if (cycleSkippedMountIds.has(mount.id) || mountBusy(mount)) {
         cycleSkippedMountIds.add(mount.id);
         continue;
       }
-      const releaseMergeHold = input.hydrationHooks?.holdMounts([mount.id], `merge projection of mount ${mount.id}`);
-      let merged;
-      try {
-        const staleRewriteBlobs = staleRewriteBlobsFor(mount);
-        merged = await (0, import_workspace_filesystem_executor.workspaceFilesystemExecutor)().run("projection_merge", {
-          workspacePath,
-          mount: {
-            id: mount.id,
-            sourcePath: mount.sourcePath,
-            workspaceRelativePath: normalizedWorkspaceMountPath(mount.workspaceRelativePath),
-            sourceMode: mount.sourceMode
-          },
-          basisHead,
-          currentHead: projectionBasisHead,
-          attemptId,
-          ...staleRewriteBlobs ? { staleRewriteBlobs } : {}
-        });
-      } finally {
-        releaseMergeHold?.();
-      }
-      if (merged.staleRewriteCleared.length > 0) staleRewriteLedger.forget(mount, merged.staleRewriteCleared);
-      if (merged.kind === "stale_rewrite") {
-        recordStaleRewrite(mount, merged.paths);
-        continue;
-      }
-      mergedProjectionBases.set(mount.id, {
-        projectedCommit: merged.oursCommit,
-        projectedFiles: merged.projectedFiles,
-        readAtMs: merged.readAtMs
-      });
-      if (merged.kind === "conflict") {
-        const refs = snapshotConflict({ workspacePath, attemptId, localHead: merged.oursCommit, remoteHead: projectionBasisHead });
-        return {
-          outcome: "conflict_blocked",
-          startingHead,
-          localHead: merged.oursCommit,
-          remoteHead: initial.remoteHead,
-          publishedHead: initial.remoteHead,
-          rebaseCount: 0,
-          diffSizeBytes: 0,
-          affectedPaths: merged.conflictPaths,
-          activeMountIds: [],
-          skippedMountIds: input.mounts.map(({ id }) => id).sort(),
-          conflictPaths: merged.conflictPaths,
-          conflictSnapshotRefs: refs,
-          conflictKind: "projection_merge",
-          ...verifiedAncestorHeads ? { verifiedAncestorHeads } : {},
-          error: merged.error
-        };
-      }
-      mergedProjectionTrees.set(mount.id, merged.resultTree);
-      mergedProjectionMounts.push(mount);
+      const outcome = await mergeProjectMount(mount, basisHead, projectionBasisHead);
+      if (outcome.kind === "conflict") return outcome.result;
     }
   }
   if (projectionWarning) process.stderr.write(`[r5d-worker] ${projectionWarning}
@@ -2984,7 +3088,7 @@ async function runWorkspaceGitSynchronization(input, remoteHeadFetches) {
     const completionReceiptMounts = configuredWorkspaceHydrationBasisMounts(workspacePath, input.mounts);
     const currentReceiptBeforeHydration = await readHydratedWorkspaceReceiptAsync(workspacePath);
     refreshCycleSkippedMounts(completionReceiptMounts);
-    const mountIsAlreadyCovered = (mount) => Boolean(
+    const mountIsAlreadyCovered = (mount) => !forceHydrationMountIds.has(mount.id) && Boolean(
       currentHeadBeforeHydration && workspaceHydrationReceiptCoversMount(currentReceiptBeforeHydration, currentHeadBeforeHydration, mount)
     );
     if (currentHeadBeforeHydration && completionReceiptMounts.every((mount) => cycleSkippedMountIds.has(mount.id) || mountIsAlreadyCovered(mount))) {
@@ -3005,6 +3109,7 @@ async function runWorkspaceGitSynchronization(input, remoteHeadFetches) {
       currentHeadBeforeHydration,
       uncoveredCompletionMounts
     ) : /* @__PURE__ */ new Set();
+    for (const id of forceHydrationMountIds) unchangedMountIds.delete(id);
     const hydrationMounts = uncoveredCompletionMounts.filter(({ id }) => !unchangedMountIds.has(id));
     const mergeBases = /* @__PURE__ */ new Map();
     if (workspaceMergeHydrationEnabled()) {
@@ -3022,9 +3127,19 @@ async function runWorkspaceGitSynchronization(input, remoteHeadFetches) {
       requiredMounts: uncoveredRequiredLiveMounts.filter(({ id }) => !unchangedMountIds.has(id)),
       recordCurrentHead: true,
       hydrationHooks: input.hydrationHooks,
-      ...mergeBases.size > 0 ? { mergeBases } : {}
+      ...mergeBases.size > 0 ? { mergeBases } : {},
+      ...ledgerMergedPathsByMount.size > 0 ? { ledgerMergedPaths: ledgerMergedPathsByMount } : {}
     });
     for (const id of hydration.skippedMountIds) cycleSkippedMountIds.add(id);
+    for (const mount of hydrationMounts) {
+      const mergedPaths = ledgerMergedPathsByMount.get(mount.id);
+      if (!mergedPaths || !hydration.hydratedMountIds.includes(mount.id)) continue;
+      const written = new Set(hydration.hydratedEntryPaths[mount.id] ?? []);
+      const settled = mergedPaths.filter((relativePath) => !written.has(relativePath));
+      if (settled.length > 0) staleRewriteLedger.forget(mount, settled);
+      ledgerMergedPathsByMount.delete(mount.id);
+      forceHydrationMountIds.delete(mount.id);
+    }
     if (currentHeadBeforeHydration) {
       for (const id of hydration.hydratedMountIds) {
         if (mergeBases.has(id)) projectedMountBases.set(id, { projectedCommit: currentHeadBeforeHydration, projectedFiles: null });
@@ -3049,7 +3164,7 @@ async function runWorkspaceGitSynchronization(input, remoteHeadFetches) {
       const receipt = await readHydratedWorkspaceReceiptAsync(workspacePath);
       const transactionSkippedMountIds = new Set(hydration.skippedMountIds);
       const idleMounts = completionReceiptMounts.filter(
-        (mount) => !cycleSkippedMountIds.has(mount.id) && !transactionSkippedMountIds.has(mount.id) && !mount.busy?.() && !projectionSkippedIds.has(mount.id)
+        (mount) => !cycleSkippedMountIds.has(mount.id) && !transactionSkippedMountIds.has(mount.id) && !mountBusy(mount) && !projectionSkippedIds.has(mount.id)
       );
       if (currentHead && !idleMounts.every((mount) => workspaceHydrationReceiptCoversMount(receipt, currentHead, mount))) {
         throw new Error(`Workspace inbound integration ${currentHead} could not be fully hydrated before publication continued`);
@@ -3091,7 +3206,7 @@ async function runWorkspaceGitSynchronization(input, remoteHeadFetches) {
       const fastActiveMounts = fastProjectionMounts.filter(({ id }) => selectedActiveIds.has(id));
       const fastTombstones = fastProjectionMounts.filter(({ id }) => !selectedActiveIds.has(id));
       for (const mount of fastActiveMounts) {
-        if (cycleSkippedMountIds.has(mount.id) || mount.busy?.()) {
+        if (cycleSkippedMountIds.has(mount.id) || mountBusy(mount)) {
           cycleSkippedMountIds.add(mount.id);
           continue;
         }
@@ -3101,22 +3216,33 @@ async function runWorkspaceGitSynchronization(input, remoteHeadFetches) {
         }
         const releaseMirrorHold = input.hydrationHooks?.holdMounts([mount.id], `projection of mount ${mount.id}`);
         let staleRewritePaths;
+        let ledgerMergePaths;
         try {
-          const staleRewriteBlobs = staleRewriteBlobsFor(mount);
+          const hydrationLedger = hydrationLedgerFor(mount);
           const mirrored = await (0, import_workspace_filesystem_executor.workspaceFilesystemExecutor)().run("projection_mirror", {
             workspacePath,
             mount: workspaceGitMountData(mount),
-            ...staleRewriteBlobs ? { staleRewriteBlobs } : {}
+            ...hydrationLedger ? { hydrationLedger } : {}
           });
           staleRewritePaths = mirrored.staleRewritePaths;
+          ledgerMergePaths = mirrored.ledgerMergePaths;
           if (mirrored.staleRewriteCleared.length > 0) staleRewriteLedger.forget(mount, mirrored.staleRewriteCleared);
-          if (staleRewritePaths.length === 0) {
+          if (staleRewritePaths.length === 0 && ledgerMergePaths.length === 0) {
             projectedGitlinks.push({ mount, gitlinks: mirrored.gitlinks });
             projectedMountFiles.set(mount.id, { files: mirrored.projectedFiles, readAtMs: mirrored.readAtMs });
           }
         } finally {
           releaseMirrorHold?.();
         }
+        if (ledgerMergePaths.length > 0) {
+          projectionSkippedIds.add(mount.id);
+          mountSkipReasons[mount.id] = { reason: "hydration_target_changed", paths: ledgerMergePaths };
+          process.stderr.write(
+            `[r5d-worker] projection of mount ${mount.id} skipped: a running process rewrote ${(0, import_workspace_hydration_merge.describeHydrationSkipPaths)(mount.sourcePath, ledgerMergePaths)} while the cycle prepared the mirror; the next cycle merges it
+`
+          );
+          continue;
+        }
         if (staleRewritePaths.length > 0) {
           recordStaleRewrite(mount, staleRewritePaths);
           continue;
@@ -3338,42 +3464,59 @@ ${push.stdout}`)) {
   }
   throw new Error(`Workspace push did not converge after ${maxPushAttempts} attempts`);
 }
-function detectStaleRewrites(workspacePath, mount, staleRewriteBlobs) {
+function inspectHydrationLedger(workspacePath, mount, hydrationLedger) {
   const outerRoot = workspaceMountOuterPath(workspacePath, mount);
   const stale = [];
+  const merge = [];
   const cleared = [];
-  for (const [relativePath, blob] of Object.entries(staleRewriteBlobs)) {
-    const algorithm = (0, import_git_blob_hash.gitObjectHashAlgorithmFor)(blob);
+  for (const [relativePath, entry] of Object.entries(hydrationLedger)) {
+    const algorithm = (0, import_git_blob_hash.gitObjectHashAlgorithmFor)(entry.preBlob);
     if (!algorithm) continue;
     const source = (0, import_working_tree_mirror.inspectWorkingTreePath)(mount.sourcePath, relativePath);
     if (source.kind !== "entry" || !source.stat.isFile()) {
-      cleared.push(relativePath);
+      if (entry.postBlob !== null) cleared.push(relativePath);
       continue;
     }
+    if (entry.stat && (0, import_working_tree_mirror.projectedFileEntryMatches)(entry.stat, source.stat)) continue;
     const content = import_node_fs.default.readFileSync(source.absolutePath);
+    const hash = (0, import_git_blob_hash.gitBlobHash)(content, algorithm);
+    if (hash === entry.postBlob) continue;
     const outer = (0, import_working_tree_mirror.inspectWorkingTreePath)(outerRoot, relativePath);
     const outerEqual = outer.kind === "entry" && outer.stat.isFile() && import_node_fs.default.readFileSync(outer.absolutePath).equals(content);
-    if ((0, import_git_blob_hash.gitBlobHash)(content, algorithm) !== blob) {
-      if (!outerEqual) cleared.push(relativePath);
+    if (outerEqual) {
+      cleared.push(relativePath);
       continue;
     }
-    if (outerEqual) {
+    if (entry.processLiveAcrossHydration) {
+      merge.push(relativePath);
+      continue;
+    }
+    if (hash !== entry.preBlob) {
       cleared.push(relativePath);
       continue;
     }
     stale.push(relativePath);
   }
-  return { stale: stale.sort(), cleared: cleared.sort() };
+  return { stale: stale.sort(), merge: merge.sort(), cleared: cleared.sort() };
 }
 function runProjectionMirrorJob(input) {
   const workspacePath = import_node_path.default.resolve(input.workspacePath);
   let staleRewriteCleared = [];
-  if (input.staleRewriteBlobs) {
-    const detected = detectStaleRewrites(workspacePath, input.mount, input.staleRewriteBlobs);
-    staleRewriteCleared = detected.cleared;
-    if (detected.stale.length > 0) {
-      return { gitlinks: [], projectedFiles: {}, readAtMs: Date.now(), staleRewritePaths: detected.stale, staleRewriteCleared };
+  if (input.hydrationLedger) {
+    const inspected = inspectHydrationLedger(workspacePath, input.mount, input.hydrationLedger);
+    staleRewriteCleared = inspected.cleared;
+    if (inspected.stale.length > 0 || inspected.merge.length > 0 || input.checkOnly) {
+      return {
+        gitlinks: [],
+        projectedFiles: {},
+        readAtMs: Date.now(),
+        staleRewritePaths: inspected.stale,
+        ledgerMergePaths: inspected.merge,
+        staleRewriteCleared
+      };
     }
+  } else if (input.checkOnly) {
+    return { gitlinks: [], projectedFiles: {}, readAtMs: Date.now(), staleRewritePaths: [], ledgerMergePaths: [], staleRewriteCleared };
   }
   const projectedFiles = /* @__PURE__ */ new Map();
   const projected = mirrorMountsToWorkspace(workspacePath, [input.mount], projectedFiles);
@@ -3382,6 +3525,7 @@ function runProjectionMirrorJob(input) {
     projectedFiles: Object.fromEntries(projectedFiles),
     readAtMs: Date.now(),
     staleRewritePaths: [],
+    ledgerMergePaths: [],
     staleRewriteCleared
   };
 }
@@ -3422,6 +3566,7 @@ const workspaceGitSyncTestHarness = {
   WORKSPACE_GIT_HYDRATION_RECOVERIES,
   WORKSPACE_GIT_HYDRATION_TRANSACTION,
   WORKSPACE_MERGE_HYDRATION_SWITCH,
+  WORKSPACE_PROCESS_BUSY_FENCE_SWITCH,
   WorkspaceHydrationRecoveryRequiredError,
   WorkspaceRemediationAncestryError,
   configureExistingWorkspaceGitForRemediation,