@ricsam/r5d-worker 0.0.94 → 0.0.96

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

@@ -1483,13 +1483,38 @@ function hydrateWorkspaceGitMountsRaw(workspacePath, mounts, options = {}) {
   }
   return { hydratedMountIds: hydratedMountIds.sort(), skippedMountIds: skippedMountIds.sort() };
 }
+async function selectMountsWithUnchangedOuterSubtree(workspacePath, receipt, head, mounts) {
+  const candidates = mounts.flatMap((mount) => {
+    const basisHead = workspaceHydrationReceiptMountBasisHead(receipt, mount);
+    return basisHead && basisHead !== head ? [{ mount, basisHead }] : [];
+  });
+  if (candidates.length === 0) return /* @__PURE__ */ new Set();
+  const objects = await resolveGitObjectIdsAsync(
+    workspacePath,
+    candidates.flatMap(({ mount, basisHead }) => [
+      workspaceTreeObjectName(basisHead, mount.workspaceRelativePath),
+      workspaceTreeObjectName(head, mount.workspaceRelativePath)
+    ])
+  );
+  const unchanged = /* @__PURE__ */ new Set();
+  for (const { mount, basisHead } of candidates) {
+    const before = objects.get(workspaceTreeObjectName(basisHead, mount.workspaceRelativePath)) ?? null;
+    const after = objects.get(workspaceTreeObjectName(head, mount.workspaceRelativePath)) ?? null;
+    if (before === after) unchanged.add(mount.id);
+  }
+  return unchanged;
+}
 async function hydrateWorkspaceGitMountsTransactionally(input) {
   const workspacePath = import_node_path.default.resolve(input.workspacePath);
   const durabilityMounts = input.durabilityMounts ?? input.mounts;
   const receiptMounts = input.receiptMounts ?? durabilityMounts;
   const requiredMounts = input.requiredMounts ?? input.mounts;
+  const carryMounts = input.carryMounts ?? [];
+  if (carryMounts.length > 0 && !input.recordCurrentHead) {
+    throw new Error("Workspace hydration can only carry unchanged mounts while recording the current head");
+  }
   const candidateMounts = [
-    ...new Map([...input.mounts, ...durabilityMounts, ...requiredMounts].map((mount) => [mount.id, mount])).values()
+    ...new Map([...input.mounts, ...durabilityMounts, ...requiredMounts, ...carryMounts].map((mount) => [mount.id, mount])).values()
   ];
   if (input.recordCurrentHead && !await workspaceCheckoutDurabilityIsCurrentAsync(workspacePath)) {
     throw new Error("Workspace checkout is not durably materialized at its current HEAD");
@@ -1505,12 +1530,13 @@ async function hydrateWorkspaceGitMountsTransactionally(input) {
       ({ id }) => !busyMountIds.has(id) && (requestedIds.has(id) || !requiredIds.has(id))
     );
     const unavailableRequiredIds = requiredMounts.filter(({ id }) => busyMountIds.has(id) || !requestedIds.has(id)).map(({ id }) => id);
+    const carriedMounts = carryMounts.filter(({ id }) => !busyMountIds.has(id));
     return {
       busyMountIds,
       hydrationMounts: hydrationMounts2,
       advancedDurabilityMounts: advancedDurabilityMounts2,
       skippedMountIds: [.../* @__PURE__ */ new Set([...busyMountIds, ...unavailableRequiredIds])].sort(),
-      targetReceipt: targetHead ? receiptWithMountsAtHead(receiptBeforeTransaction, targetHead, advancedDurabilityMounts2, receiptMounts) : null
+      targetReceipt: targetHead ? receiptWithMountsAtHead(receiptBeforeTransaction, targetHead, [...advancedDurabilityMounts2, ...carriedMounts], receiptMounts) : null
     };
   };
   const noopCandidate = computeSelection();
@@ -1686,14 +1712,26 @@ async function changedPaths(workspacePath, baseRevision, headRevision) {
   const base = baseRevision ?? emptyTreeHash(workspacePath);
   return (await gitAsync(workspacePath, ["diff", "--name-only", "--no-renames", "-z", base, headRevision], "inspect workspace commit paths")).split("\0").filter(Boolean).sort();
 }
-async function diffSizeBytes(workspacePath, baseRevision, headRevision, limit) {
+async function diffSizeBytes(workspacePath, baseRevision, headRevision, limit, pathspecs = []) {
   const base = baseRevision ?? emptyTreeHash(workspacePath);
-  const subprocess = Bun.spawn(["git", ...NON_RECURSIVE_GIT_CONFIG, "diff", "--binary", "--no-ext-diff", base, headRevision], {
-    cwd: workspacePath,
-    stdout: "pipe",
-    stderr: "pipe",
-    env: (0, import_git_process_environment.workerGitProcessEnvironment)()
-  });
+  const subprocess = Bun.spawn(
+    [
+      "git",
+      ...NON_RECURSIVE_GIT_CONFIG,
+      "diff",
+      "--binary",
+      "--no-ext-diff",
+      base,
+      headRevision,
+      ...pathspecs.length > 0 ? ["--", ...pathspecs] : []
+    ],
+    {
+      cwd: workspacePath,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: (0, import_git_process_environment.workerGitProcessEnvironment)()
+    }
+  );
   const stderrPromise = new Response(subprocess.stderr).text();
   const reader = subprocess.stdout.getReader();
   let total = 0;
@@ -1713,6 +1751,73 @@ async function diffSizeBytes(workspacePath, baseRevision, headRevision, limit) {
   if (exitCode !== 0) throw new Error(`Measure workspace diff: ${stderr || `git exited ${exitCode}`}`);
   return total;
 }
+async function resolveGitObjectIdsAsync(workspacePath, names) {
+  const resolved = /* @__PURE__ */ new Map();
+  const unique = [...new Set(names)];
+  if (unique.length === 0) return resolved;
+  const subprocess = Bun.spawn(gitCommandArgs(["cat-file", "--batch-check"]), {
+    cwd: workspacePath,
+    stdin: Buffer.from(`${unique.join("\n")}
+`),
+    stdout: "pipe",
+    stderr: "pipe",
+    env: (0, import_git_process_environment.workerGitProcessEnvironment)()
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(subprocess.stdout).text(),
+    new Response(subprocess.stderr).text(),
+    subprocess.exited
+  ]);
+  if (exitCode !== 0) throw new Error(`Resolve workspace objects: ${stderr.trim() || `git exited ${exitCode}`}`);
+  const lines = stdout.split("\n").filter((line) => line.length > 0);
+  if (lines.length !== unique.length) {
+    throw new Error(`Resolve workspace objects: expected ${unique.length} results, received ${lines.length}`);
+  }
+  unique.forEach((name, index) => {
+    const match = /^([0-9a-f]{40,64}) \S+ \d+$/.exec(lines[index]);
+    resolved.set(name, match ? match[1] : null);
+  });
+  return resolved;
+}
+function workspaceTreeObjectName(revision, workspaceRelativePath) {
+  return `${revision}:${normalizedWorkspaceMountPath(workspaceRelativePath)}`;
+}
+async function measureInitialPublicationDiffSize(input) {
+  const candidates = input.mounts.filter(
+    (mount) => typeof mount.initialPublicationSourceRelativePath === "string"
+  );
+  if (candidates.length === 0) return null;
+  const revisions = [input.localHead, ...input.remoteHead ? [input.remoteHead] : []];
+  const objects = await resolveGitObjectIdsAsync(
+    input.workspacePath,
+    candidates.flatMap(
+      (mount) => revisions.flatMap((revision) => [
+        workspaceTreeObjectName(revision, mount.workspaceRelativePath),
+        workspaceTreeObjectName(revision, mount.initialPublicationSourceRelativePath)
+      ])
+    )
+  );
+  const lookup = (revision, workspaceRelativePath) => revision ? objects.get(workspaceTreeObjectName(revision, workspaceRelativePath)) ?? null : null;
+  const initialPublications = candidates.flatMap((mount) => {
+    const published = lookup(input.localHead, mount.workspaceRelativePath);
+    if (!published || lookup(input.remoteHead, mount.workspaceRelativePath)) return [];
+    const source = lookup(input.localHead, mount.initialPublicationSourceRelativePath) ?? lookup(input.remoteHead, mount.initialPublicationSourceRelativePath);
+    return [{ mount, published, source }];
+  });
+  if (initialPublications.length === 0) return null;
+  let size = await input.measure(
+    input.workspacePath,
+    input.remoteHead,
+    input.localHead,
+    input.limit,
+    initialPublications.map(({ mount }) => `:(exclude,literal)${normalizedWorkspaceMountPath(mount.workspaceRelativePath)}`)
+  );
+  for (const { published, source } of initialPublications) {
+    if (size > input.limit) break;
+    size += await input.measure(input.workspacePath, source, published, input.limit - size);
+  }
+  return { size, mountIds: initialPublications.map(({ mount }) => mount.id).sort() };
+}
 function conflictPaths(workspacePath) {
   const result = gitResult(workspacePath, ["diff", "--name-only", "--diff-filter=U", "-z"]);
   return result.exitCode === 0 ? result.stdout.split("\0").filter(Boolean).sort() : [];
@@ -1940,12 +2045,19 @@ async function synchronizeWorkspaceGit(input) {
     const uncoveredCompletionBasisMounts = completionReceiptMounts.filter(
       (mount) => !cycleSkippedMountIds.has(mount.id) && !projectionSkippedIds.has(mount.id) && !mountIsAlreadyCovered(mount)
     );
+    const unchangedMountIds = currentHeadBeforeHydration ? await selectMountsWithUnchangedOuterSubtree(
+      workspacePath,
+      currentReceiptBeforeHydration,
+      currentHeadBeforeHydration,
+      uncoveredCompletionMounts
+    ) : /* @__PURE__ */ new Set();
     const hydration = await hydrateWorkspaceGitMountsTransactionally({
       workspacePath,
-      mounts: uncoveredCompletionMounts,
-      durabilityMounts: uncoveredCompletionBasisMounts,
+      mounts: uncoveredCompletionMounts.filter(({ id }) => !unchangedMountIds.has(id)),
+      durabilityMounts: uncoveredCompletionBasisMounts.filter(({ id }) => !unchangedMountIds.has(id)),
+      carryMounts: uncoveredCompletionMounts.filter(({ id }) => unchangedMountIds.has(id)),
       receiptMounts: completionReceiptMounts,
-      requiredMounts: uncoveredRequiredLiveMounts,
+      requiredMounts: uncoveredRequiredLiveMounts.filter(({ id }) => !unchangedMountIds.has(id)),
       recordCurrentHead: true
     });
     for (const id of hydration.skippedMountIds) cycleSkippedMountIds.add(id);
@@ -2095,8 +2207,25 @@ async function synchronizeWorkspaceGit(input) {
       };
     }
     const paths = await changedPaths(workspacePath, remoteHead, localHead);
-    const size = paths.length > 0 ? await (input.measureDiffSize ?? diffSizeBytes)(workspacePath, remoteHead, localHead, maxDiffBytes) : 0;
+    const measureDiffSize = input.measureDiffSize ?? diffSizeBytes;
+    let size = paths.length > 0 ? await measureDiffSize(workspacePath, remoteHead, localHead, maxDiffBytes) : 0;
     input.assertStillAdmitted?.();
+    let initialPublicationMountIds;
+    if (paths.length > 0 && size > maxDiffBytes && !input.allowLargeDiff) {
+      const initialPublication = await measureInitialPublicationDiffSize({
+        workspacePath,
+        remoteHead,
+        localHead,
+        mounts: input.mounts,
+        limit: maxDiffBytes,
+        measure: measureDiffSize
+      });
+      input.assertStillAdmitted?.();
+      if (initialPublication && initialPublication.size <= maxDiffBytes) {
+        size = initialPublication.size;
+        initialPublicationMountIds = initialPublication.mountIds;
+      }
+    }
     if (paths.length > 0 && size > maxDiffBytes && !input.allowLargeDiff) {
       const classifiedMounts = classifyMounts([...selected.active, ...selected.tombstones]);
       return {
@@ -2141,7 +2270,9 @@ async function synchronizeWorkspaceGit(input) {
       "push",
       "--no-recurse-submodules"
     ];
-    if (input.allowLargeDiff) pushArgs.push(`--push-option=${WORKSPACE_GIT_CONFIRMED_LARGE_DIFF_PUSH_OPTION}`);
+    if (input.allowLargeDiff || initialPublicationMountIds) {
+      pushArgs.push(`--push-option=${WORKSPACE_GIT_CONFIRMED_LARGE_DIFF_PUSH_OPTION}`);
+    }
     pushArgs.push("origin", `HEAD:refs/heads/${WORKSPACE_GIT_BRANCH}`);
     const push = await gitResultAsync(workspacePath, pushArgs);
     if (push.exitCode === 0) {
@@ -2163,6 +2294,7 @@ async function synchronizeWorkspaceGit(input) {
         diffSizeBytes: size,
         affectedPaths: paths,
         ...completedMounts,
+        ...initialPublicationMountIds ? { initialPublicationMountIds } : {},
         ...verifiedAncestorHeads ? { verifiedAncestorHeads } : {},
         ...projectionWarning ? { error: projectionWarning } : {}
       };

package/dist/mjs/main.mjs

@@ -58,6 +58,7 @@ import { assertDisjointManagedRoots, managedProjectRoot, validateManagedBranchNa
 import {
   applyObservedProjectMirrorHeads,
   assertProjectMirrorHeadsPushed,
+  computeLocalProjectMirrorRefsToken,
   createOrRetryLinkedProjectBranch,
   deleteLinkedProjectBranch,
   deleteProjectMirrorBranch,
@@ -70,6 +71,7 @@ import {
   pushProjectMirrorHeads,
   removeProjectWorktrees
 } from "./project-worktrees.mjs";
+import { projectMirrorFetchDecision } from "./project-mirror-fetch-policy.mjs";
 import {
   PROJECT_SNAPSHOT_RECOVERY_HELPER_COMMAND,
   recoverProjectSnapshotsInChild,
@@ -119,6 +121,7 @@ const DEFAULT_READ_MAX_BYTES = 5e4;
 const MAX_LINE_LENGTH = 2e3;
 const WORKSPACE_GIT_QUIET_MS = 5e3;
 const WORKSPACE_GIT_PERIODIC_MS = 6e4;
+const PROJECT_MIRROR_OBSERVE_CONCURRENCY = 6;
 const WORKSPACE_INCIDENT_CONFIG_REFRESH_TIMEOUT_MS = 6e4;
 const PTY_INPUT_BUSY_GRACE_MS = 3e3;
 const PTY_FOREGROUND_POLL_MS = 1e3;
@@ -1009,6 +1012,21 @@ function resolveWorkerFilePath(branchPath, inputPath, builtInPaths) {
 function canonicalProjectRemoteUrl(baseUrl, projectId) {
   return new URL(`/git/${projectId}.git`, baseUrl).toString();
 }
+async function mapWithConcurrencyLimit(items, limit, task) {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  await Promise.all(
+    Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, async () => {
+      while (true) {
+        const index = nextIndex;
+        nextIndex += 1;
+        if (index >= items.length) return;
+        results[index] = await task(items[index], index);
+      }
+    })
+  );
+  return results;
+}
 function shellQuote(value) {
   return `'${value.replace(/'/g, "'\\''")}'`;
 }
@@ -3468,6 +3486,10 @@ async function startWorker(options) {
   const readyProjectIds = /* @__PURE__ */ new Set();
   const reconciledProjectConfigFingerprints = /* @__PURE__ */ new Map();
   const lastObservedProjectHeads = /* @__PURE__ */ new Map();
+  const advertisedProjectMirrorRefsTokens = /* @__PURE__ */ new Map();
+  const fetchedProjectMirrorRefsTokens = /* @__PURE__ */ new Map();
+  const lastProjectMirrorFetchAtMs = /* @__PURE__ */ new Map();
+  const projectMirrorFetchSkippingEnabled = process.env.R5D_PROJECT_MIRROR_FETCH_SKIP !== "0";
   const pendingMirrorDeletes = /* @__PURE__ */ new Map();
   let workspaceRemoteUrl = null;
   let workspaceCredentialHelper = null;
@@ -3485,6 +3507,7 @@ async function startWorker(options) {
   let automaticSyncInFlight = false;
   let terminalReplayTimer;
   let workspaceSyncRequestsInFlight = 0;
+  let lastWorkspaceSyncMirrorObservationMs = 0;
   let sessionArtifactSyncRequestsInFlight = 0;
   let cliUpdateInProgress = false;
   let reloadAfterClose = false;
@@ -3808,6 +3831,7 @@ async function startWorker(options) {
         const branchKey = projectBranchKey(project.projectId, branch.branchName);
         const creatorLocalIncarnation = creatorLocalIncarnations.get(branchKey) === branch.branchId;
         const preservesCheckoutPathMove = checkoutPathMoveBranches.has(branchKey);
+        const initialPublicationSourceBranch = creatorLocalIncarnation ? branch.sourceBranchName : null;
         mounts.push({
           id: projectMountId(project.projectId, branch.branchName),
           hydrationIncarnationKey: branch.branchId,
@@ -3817,6 +3841,7 @@ async function startWorker(options) {
           sourceMode: "git",
           hydrateDeletionMode: "git",
           preserveLocalOnInitialOuterAbsence: creatorLocalIncarnation,
+          ...initialPublicationSourceBranch ? { initialPublicationSourceRelativePath: workspaceProjectRelativePath(project.projectId, initialPublicationSourceBranch) } : {},
           preserveLocalOnHydrationBasisChange: preservesCheckoutPathMove,
           busy: () => projectBranchMountBusy(project.projectId, branch.branchName, branchPath),
           mutationToken: () => projectWorkspaceMutationToken(project.projectId, branch.branchName),
@@ -3831,6 +3856,7 @@ async function startWorker(options) {
           sourceMode: "all",
           hydrateDeletionMode: "all",
           preserveLocalOnInitialOuterAbsence: creatorLocalIncarnation,
+          ...initialPublicationSourceBranch ? { initialPublicationSourceRelativePath: workspacePlanRelativePath(project.projectId, initialPublicationSourceBranch) } : {},
           preserveLocalOnHydrationBasisChange: preservesCheckoutPathMove,
           busy: () => projectBranchMountBusy(project.projectId, branch.branchName, branchPath),
           mutationToken: () => projectWorkspaceMutationToken(project.projectId, branch.branchName),
@@ -4110,6 +4136,17 @@ async function startWorker(options) {
       for (const result of results) {
         lastObservedProjectHeads.set(projectBranchKey(project.projectId, result.branchName), result.head);
       }
+      try {
+        fetchedProjectMirrorRefsTokens.set(
+          project.projectId,
+          await computeLocalProjectMirrorRefsToken({
+            projectRoot: configuredProjectRoot(projectsRoot, project),
+            primaryBranchName: primaryProjectBranch(project)
+          })
+        );
+      } catch {
+        fetchedProjectMirrorRefsTokens.delete(project.projectId);
+      }
     }
     const publishedTombstoneIds = [
       ...new Set(
@@ -4135,6 +4172,7 @@ async function startWorker(options) {
           credentialHelper: deletion.credentialHelper,
           credentialUsername: deletion.credentialUsername
         });
+        fetchedProjectMirrorRefsTokens.delete(deletion.projectId);
       }
       if (deletion.tombstoneId && !deletion.projectDeleted) {
         projectWorkspaceState = projectWorkspaceStateStore.recordMirrorRefDeletion({
@@ -4145,42 +4183,101 @@ async function startWorker(options) {
       pendingMirrorDeletes.delete(key);
       if (deletion.projectDeleted && !projectConfigById.has(deletion.projectId) && ![...pendingMirrorDeletes.values()].some((pending) => pending.projectId === deletion.projectId)) {
         removeProjectCredentialStore(deletion.projectId);
+        advertisedProjectMirrorRefsTokens.delete(deletion.projectId);
+        fetchedProjectMirrorRefsTokens.delete(deletion.projectId);
+        lastProjectMirrorFetchAtMs.delete(deletion.projectId);
       }
       lastObservedProjectHeads.delete(key);
     }
   };
+  const observeSingleProjectMirrorBundle = async (project, options2) => {
+    const connection = projectConnection(project);
+    const projectRoot = configuredProjectRoot(projectsRoot, project);
+    const primaryBranchName = primaryProjectBranch(project);
+    if (options2.refreshRemote) {
+      const advertisedBeforeFetch = advertisedProjectMirrorRefsTokens.get(project.projectId);
+      const observations = await observeProjectMirrorHeads({
+        projectRoot,
+        primaryBranchName,
+        branchNames: project.branches.map(({ branchName }) => branchName),
+        mirrorUrl: connection.mirrorUrl,
+        credentialHelper: connection.credentialHelper,
+        credentialUsername: connection.mirrorCredentialUsername,
+        allowNonFastForward: options2.allowNonFastForward,
+        branchIds: new Map(project.branches.map(({ branchId, branchName }) => [branchName, branchId]))
+      });
+      if (advertisedBeforeFetch === void 0) fetchedProjectMirrorRefsTokens.delete(project.projectId);
+      else fetchedProjectMirrorRefsTokens.set(project.projectId, advertisedBeforeFetch);
+      lastProjectMirrorFetchAtMs.set(project.projectId, Date.now());
+      return { projectId: project.projectId, projectRoot, primaryBranchName, observations };
+    }
+    return {
+      projectId: project.projectId,
+      projectRoot,
+      primaryBranchName,
+      observations: await observeProjectMirrorHeads({
+        projectRoot,
+        primaryBranchName,
+        branchNames: project.branches.map(({ branchName }) => branchName),
+        mirrorUrl: connection.mirrorUrl,
+        credentialHelper: connection.credentialHelper,
+        credentialUsername: connection.mirrorCredentialUsername,
+        allowNonFastForward: options2.allowNonFastForward,
+        branchIds: new Map(project.branches.map(({ branchId, branchName }) => [branchName, branchId])),
+        refreshRemote: false
+      })
+    };
+  };
   const observeProjectHeadsBeforeOuterWorkspace = async (input) => {
-    const bundles = [];
-    for (const project of projectConfigById.values()) {
-      if (project.executionDisabled || !readyProjectIds.has(project.projectId) || project.branches.length === 0) continue;
-      try {
-        const connection = projectConnection(project);
-        const projectRoot = configuredProjectRoot(projectsRoot, project);
-        const primaryBranchName = primaryProjectBranch(project);
-        bundles.push({
-          projectId: project.projectId,
-          projectRoot,
-          primaryBranchName,
-          observations: await observeProjectMirrorHeads({
-            projectRoot,
-            primaryBranchName,
-            branchNames: project.branches.map(({ branchName }) => branchName),
-            mirrorUrl: connection.mirrorUrl,
-            credentialHelper: connection.credentialHelper,
-            credentialUsername: connection.mirrorCredentialUsername,
-            allowNonFastForward: input.allowNonFastForward,
-            branchIds: new Map(project.branches.map(({ branchId, branchName }) => [branchName, branchId]))
-          })
-        });
-      } catch (error) {
-        if (input.failClosed) throw error;
+    const observationStartedAt = Date.now();
+    const eligibleProjects = [...projectConfigById.values()].filter(
+      (project) => !project.executionDisabled && readyProjectIds.has(project.projectId) && project.branches.length > 0
+    );
+    try {
+      if (input.failClosed) {
+        const bundles2 = [];
+        for (const project of eligibleProjects) {
+          bundles2.push(await observeSingleProjectMirrorBundle(project, { allowNonFastForward: input.allowNonFastForward, refreshRemote: true }));
+        }
+        return bundles2;
+      }
+      let fetchedCount = 0;
+      const bundles = await mapWithConcurrencyLimit(
+        eligibleProjects,
+        PROJECT_MIRROR_OBSERVE_CONCURRENCY,
+        async (project) => {
+          try {
+            const decision = projectMirrorFetchDecision({
+              advertisedToken: advertisedProjectMirrorRefsTokens.get(project.projectId),
+              fetchedToken: fetchedProjectMirrorRefsTokens.get(project.projectId),
+              lastFetchAtMs: lastProjectMirrorFetchAtMs.get(project.projectId),
+              nowMs: Date.now(),
+              skippingEnabled: projectMirrorFetchSkippingEnabled
+            });
+            if (decision.fetch) fetchedCount += 1;
+            return await observeSingleProjectMirrorBundle(project, {
+              allowNonFastForward: input.allowNonFastForward,
+              refreshRemote: decision.fetch
+            });
+          } catch (error) {
+            process.stderr.write(
+              `[r5d-worker] failed to observe project mirror heads before workspace update: ${error instanceof Error ? error.message : String(error)}
+`
+            );
+            return null;
+          }
+        }
+      );
+      if (fetchedCount > 0) {
         process.stderr.write(
-          `[r5d-worker] failed to observe project mirror heads before workspace update: ${error instanceof Error ? error.message : String(error)}
+          `[r5d-worker] project mirror observation fetched ${fetchedCount} of ${eligibleProjects.length} mirror(s)
 `
         );
       }
+      return bundles.filter((bundle) => bundle !== null);
+    } finally {
+      lastWorkspaceSyncMirrorObservationMs = Date.now() - observationStartedAt;
     }
-    return bundles;
   };
   const applyObservedProjectHeadsAfterInboundWorkspace = async (bundles, activeMountIds, requireObservedHeads, integratedWorkspaceHead) => {
     const active = new Set(activeMountIds);
@@ -4359,6 +4456,12 @@ async function startWorker(options) {
       }
     });
     input.assertStillAdmitted?.();
+    if (result.initialPublicationMountIds && result.initialPublicationMountIds.length > 0) {
+      process.stderr.write(
+        `[r5d-worker] published first checkout copies above the automatic diff-size limit, measured against their source subtrees at ${result.diffSizeBytes} bytes: ${result.initialPublicationMountIds.join(", ")}
+`
+      );
+    }
     if (["no_change", "updated", "pushed"].includes(result.outcome) && !outerRemediation) {
       await applyObservedProjectHeadsAfterInboundWorkspace(
         observedProjectHeads,
@@ -4449,6 +4552,7 @@ async function startWorker(options) {
       result = await workspaceSyncSingleFlight.runExclusive(async () => {
         queueEnteredAt = Date.now();
         syncStartedAt = Date.now();
+        lastWorkspaceSyncMirrorObservationMs = 0;
         if (!deferredWorkspaceSyncTriggerIsAllowed(deferredWorkspaceConfiguration, activeWorkspaceIncidentId, input.trigger)) {
           return await failedWorkspaceSyncResult(
             attemptId,
@@ -4533,7 +4637,9 @@ async function startWorker(options) {
       telemetry: {
         totalMs: finishedAt - requestedAt,
         queueMs: queueEnteredAt - requestedAt,
-        prepareMs: 0,
+        // Duration of the pre-outer mirror-head observation phase; near zero
+        // on a cycle whose token-gated observation skipped every fetch.
+        prepareMs: lastWorkspaceSyncMirrorObservationMs,
         synchronizeMs: finishedAt - syncStartedAt
       }
     };
@@ -5251,7 +5357,8 @@ async function startWorker(options) {
           workspaceIncidentConfigDeferralV1: true,
           workspaceConfigResetToCanonicalV1: true,
           projectBranchDeletionFastAckV1: true,
-          projectMirrorLeaseV1: true
+          projectMirrorLeaseV1: true,
+          projectMirrorRefsTokensV1: true
         },
         projectRoot: projectsRoot,
         artifactRoot,
@@ -5289,6 +5396,17 @@ async function startWorker(options) {
       if (message.type === "connected") {
         return;
       }
+      if (message.type === "project_mirror_refs_tokens") {
+        advertisedProjectMirrorRefsTokens.clear();
+        if (message.tokens && typeof message.tokens === "object") {
+          for (const [projectId, token2] of Object.entries(message.tokens)) {
+            if (typeof token2 === "string" && /^[0-9a-f]{64}$/.test(token2)) {
+              advertisedProjectMirrorRefsTokens.set(projectId, token2);
+            }
+          }
+        }
+        return;
+      }
       if (message.type === "workspace_config") {
         const receiptGeneration = ++workspaceConfigurationReceiptGeneration;
         const refreshesDeferredConfiguration = deferredWorkspaceConfiguration !== null && activeWorkspaceIncidentId === null && message.deferWorkspaceSyncForIncidentId === void 0;

package/dist/mjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.94",
+  "version": "0.0.96",
   "type": "module"
 }

package/dist/mjs/project-mirror-fetch-policy.mjs

@@ -0,0 +1,16 @@
+const PROJECT_MIRROR_FETCH_BACKSTOP_MS = 10 * 6e4;
+function projectMirrorFetchDecision(input) {
+  if (!input.skippingEnabled) return { fetch: true, reason: "skipping_disabled" };
+  if (input.advertisedToken === void 0) return { fetch: true, reason: "no_advertised_token" };
+  if (input.fetchedToken === void 0) return { fetch: true, reason: "never_fetched" };
+  if (input.advertisedToken !== input.fetchedToken) return { fetch: true, reason: "token_changed" };
+  const backstopMs = input.backstopMs ?? PROJECT_MIRROR_FETCH_BACKSTOP_MS;
+  if (input.lastFetchAtMs === void 0 || input.nowMs - input.lastFetchAtMs >= backstopMs) {
+    return { fetch: true, reason: "backstop_elapsed" };
+  }
+  return { fetch: false, reason: "token_match" };
+}
+export {
+  PROJECT_MIRROR_FETCH_BACKSTOP_MS,
+  projectMirrorFetchDecision
+};

package/dist/mjs/project-mirror-refs-token.mjs

@@ -0,0 +1,24 @@
+import { createHash } from "node:crypto";
+const PROJECT_MIRROR_REF_PREFIX = "refs/r5d/mirror/";
+const PROJECT_SERVER_SYNCED_REF_PREFIX = "refs/r5d/server-synced/";
+function hashProjectMirrorRefs(refs) {
+  const lines = refs.map(({ objectName, refname }) => `${objectName} ${refname}`).sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
+  return createHash("sha256").update(lines.join("\n")).digest("hex");
+}
+function canonicalizeLocalProjectMirrorRefs(refs) {
+  const canonical = [];
+  for (const { refname, objectName } of refs) {
+    if (refname.startsWith(PROJECT_MIRROR_REF_PREFIX)) {
+      canonical.push({ refname: `refs/heads/${refname.slice(PROJECT_MIRROR_REF_PREFIX.length)}`, objectName });
+    } else if (refname.startsWith(PROJECT_SERVER_SYNCED_REF_PREFIX)) {
+      canonical.push({ refname, objectName });
+    }
+  }
+  return canonical;
+}
+export {
+  PROJECT_MIRROR_REF_PREFIX,
+  PROJECT_SERVER_SYNCED_REF_PREFIX,
+  canonicalizeLocalProjectMirrorRefs,
+  hashProjectMirrorRefs
+};