@ricsam/r5d-worker 0.0.93 → 0.0.95

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;
@@ -4073,7 +4096,7 @@ async function startWorker(options) {
     }
     return heads;
   };
-  const pushChangedProjectHeads = async (activeMountIds, publishedHead, publicationHeads, suppressedMountIds = /* @__PURE__ */ new Set()) => {
+  const pushChangedProjectHeads = async (activeMountIds, publishedHead, publicationHeads, expectedMirrorHeads, suppressedMountIds = /* @__PURE__ */ new Set()) => {
     const active = new Set(activeMountIds);
     for (const project of projectConfigById.values()) {
       if (!readyProjectIds.has(project.projectId) || !repositoryMirrorWritesAllowed(project)) continue;
@@ -4088,6 +4111,12 @@ async function startWorker(options) {
         }
       }
       if (changed.size === 0) continue;
+      const branchLeases = /* @__PURE__ */ new Map();
+      for (const branchName of changed.keys()) {
+        const mountId = projectMountId(project.projectId, branchName);
+        if (!expectedMirrorHeads.has(mountId)) throw new Error(`Missing observed hidden-mirror lease for active project mount ${mountId}`);
+        branchLeases.set(branchName, expectedMirrorHeads.get(mountId) ?? null);
+      }
       const connection = projectConnection(project);
       const results = await pushProjectMirrorHeads({
         projectRoot: configuredProjectRoot(projectsRoot, project),
@@ -4096,12 +4125,25 @@ async function startWorker(options) {
         credentialHelper: connection.credentialHelper,
         credentialUsername: connection.mirrorCredentialUsername,
         onlyBranches: new Set(changed.keys()),
-        publicationHeads: changed
+        publicationHeads: changed,
+        expectedMirrorHeads: branchLeases,
+        branchIds: new Map(project.branches.map(({ branchId, branchName }) => [branchName, branchId]))
       });
       assertProjectMirrorHeadsPushed(results);
       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(
@@ -4127,6 +4169,7 @@ async function startWorker(options) {
           credentialHelper: deletion.credentialHelper,
           credentialUsername: deletion.credentialUsername
         });
+        fetchedProjectMirrorRefsTokens.delete(deletion.projectId);
       }
       if (deletion.tombstoneId && !deletion.projectDeleted) {
         projectWorkspaceState = projectWorkspaceStateStore.recordMirrorRefDeletion({
@@ -4137,43 +4180,103 @@ 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
-          })
-        });
-      } 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) => {
+  const applyObservedProjectHeadsAfterInboundWorkspace = async (bundles, activeMountIds, requireObservedHeads, integratedWorkspaceHead) => {
     const active = new Set(activeMountIds);
     for (const bundle of bundles) {
       const project = projectConfigById.get(bundle.projectId);
@@ -4185,7 +4288,16 @@ async function startWorker(options) {
           projectRoot: bundle.projectRoot,
           primaryBranchName: bundle.primaryBranchName,
           observations,
-          branchMutationAllowed: (branchName, checkoutPath) => !projectBranchMountBusy(project.projectId, branchName, checkoutPath)
+          branchMutationAllowed: (branchName, checkoutPath) => !projectBranchMountBusy(project.projectId, branchName, checkoutPath),
+          serverSyncedWorkspaceCovered: async (observation) => {
+            if (!integratedWorkspaceHead) return false;
+            for (const workspaceHead of observation.serverSyncedWorkspaceHeads) {
+              if (await tryGitAsync(["merge-base", "--is-ancestor", workspaceHead, integratedWorkspaceHead], { cwd: workspaceShadowRoot })) {
+                return true;
+              }
+            }
+            return false;
+          }
         });
         if (requireObservedHeads) {
           for (const observation of observations) {
@@ -4310,6 +4422,12 @@ async function startWorker(options) {
     const outerRemediation = input.trigger.type === "remediation" || input.trigger.type === "remediation_confirm";
     const mounts = outerRemediation ? workspaceGitMountsForRemediation(configuredMounts) : configuredMounts;
     const observedProjectHeads = outerRemediation ? [] : await observeProjectHeadsBeforeOuterWorkspace({ allowNonFastForward: false, failClosed: false });
+    const expectedMirrorHeads = /* @__PURE__ */ new Map();
+    for (const bundle of observedProjectHeads) {
+      for (const observation of bundle.observations) {
+        expectedMirrorHeads.set(projectMountId(bundle.projectId, observation.branchName), observation.mirrorHead);
+      }
+    }
     const inboundMoveMountIds = new Set(
       observedProjectHeads.flatMap(
         ({ projectId, observations }) => observations.filter(({ shouldMove }) => shouldMove).map(({ branchName }) => projectMountId(projectId, branchName))
@@ -4331,12 +4449,17 @@ async function startWorker(options) {
       requiredAncestorHeads: input.requiredAncestorHeads,
       assertStillAdmitted: input.assertStillAdmitted,
       afterWorkspacePublished: outerRemediation ? void 0 : async ({ activeMountIds, publishedHead }) => {
-        await pushChangedProjectHeads(activeMountIds, publishedHead, publicationHeads, inboundMoveMountIds);
+        await pushChangedProjectHeads(activeMountIds, publishedHead, publicationHeads, expectedMirrorHeads, inboundMoveMountIds);
       }
     });
     input.assertStillAdmitted?.();
     if (["no_change", "updated", "pushed"].includes(result.outcome) && !outerRemediation) {
-      await applyObservedProjectHeadsAfterInboundWorkspace(observedProjectHeads, result.activeMountIds, false);
+      await applyObservedProjectHeadsAfterInboundWorkspace(
+        observedProjectHeads,
+        result.activeMountIds,
+        false,
+        result.localHead ?? result.remoteHead
+      );
     }
     return mapWorkspaceGitResult(input.attemptId, input.trigger, result);
   };
@@ -4420,6 +4543,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,
@@ -4504,7 +4628,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
       }
     };
@@ -5221,7 +5347,9 @@ async function startWorker(options) {
           workspaceRemediationAncestorGuardV1: true,
           workspaceIncidentConfigDeferralV1: true,
           workspaceConfigResetToCanonicalV1: true,
-          projectBranchDeletionFastAckV1: true
+          projectBranchDeletionFastAckV1: true,
+          projectMirrorLeaseV1: true,
+          projectMirrorRefsTokensV1: true
         },
         projectRoot: projectsRoot,
         artifactRoot,
@@ -5259,6 +5387,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.93",
+  "version": "0.0.95",
   "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
+};