@ricsam/r5d-worker 0.0.56 → 0.0.58

package/dist/cjs/main.cjs

@@ -65,10 +65,14 @@ var import_process_tree = require("./process-tree.cjs");
 var import_port_forward_client = require("./port-forward-client.cjs");
 var import_workspace_incident_state = require("./workspace-incident-state.cjs");
 var import_workspace_command_sync_policy = require("./workspace-command-sync-policy.cjs");
+var import_workspace_sync_fast_path = require("./workspace-sync-fast-path.cjs");
 var import_supervisor = require("./supervisor.cjs");
 var import_managed_paths = require("./managed-paths.cjs");
 var import_workspace_sync = require("./workspace-sync.cjs");
 const import_meta = {};
+function workspaceSyncFastPathTelemetry(decision) {
+  return decision.hit ? { hit: true, reason: decision.reason, proofAgeMs: decision.proofAgeMs } : { hit: false, reason: decision.reason };
+}
 class WorkerServerUnavailableError extends Error {
   name = "WorkerServerUnavailableError";
 }
@@ -2407,6 +2411,7 @@ async function startWorker(options) {
   let sessionArtifactSyncRequestsInFlight = 0;
   let cliUpdateInProgress = false;
   let reloadAfterClose = false;
+  const recentWorkspaceSyncProof = new import_workspace_sync_fast_path.RecentWorkspaceSyncProofCache();
   const workspaceSyncInput = (trigger, overrides = {}) => {
     if (!workspaceRemoteUrl) throw new Error("Worker workspace manifest has not been received");
     const projects = (0, import_workspace_sync.workspaceProjectsForSync)([...manifestByProjectId.values()], trigger);
@@ -2498,19 +2503,64 @@ async function startWorker(options) {
     }
     return created;
   };
-  const runRequestedWorkspaceSync = async (authority, trigger, overrides = {}) => {
+  const runRequestedWorkspaceSync = async (authority, trigger, overrides = {}, authoritativeCanonicalHead, allowRecentNoChangeFastPath) => {
+    const requestedAt = Date.now();
+    let queueEnteredAt = requestedAt;
+    let prepareStartedAt = requestedAt;
+    let synchronizeStartedAt = requestedAt;
+    let synchronizeFinishedAt = requestedAt;
+    let fastPathDecision = { hit: false, reason: "no_recent_proof" };
     workspaceSyncRequestsInFlight += 1;
     try {
       let pendingTargets = [];
-      const result = await workspaceSyncSingleFlight.runPrepared(() => {
+      const result = await workspaceSyncSingleFlight.runExclusive(async () => {
+        queueEnteredAt = Date.now();
         const shouldEnsureCheckouts = !overrides.skipVisibleMirror && !overrides.resetToCanonical;
         const syncProjects = (0, import_workspace_sync.workspaceProjectsForSync)([...manifestByProjectId.values()], trigger);
+        if (!workspaceRemoteUrl) throw new Error("Worker workspace manifest has not been received");
+        const scopeKey = (0, import_workspace_sync_fast_path.workspaceSyncScopeKey)(workspaceRemoteUrl, syncProjects);
         const allowedCheckoutKeys = new Set(
           syncProjects.flatMap((project) => project.branches.map((branchName) => manifestCheckoutKey(project.projectId, branchName)))
         );
         const scopedPendingTargets = [...pendingManifestCheckouts.values()].filter(
           (target) => allowedCheckoutKeys.has(manifestCheckoutKey(target.projectId, target.branchName))
         );
+        const workerBusy = activeProcesses.size > 0 || activePtys.size > 0 || cliUpdateInProgress;
+        fastPathDecision = recentWorkspaceSyncProof.evaluate({
+          trigger,
+          allowRecentNoChangeFastPath,
+          canonicalHead: authoritativeCanonicalHead,
+          scopeKey,
+          nowMs: Date.now(),
+          skipVisibleMirror: overrides.skipVisibleMirror,
+          resetToCanonical: overrides.resetToCanonical,
+          incidentActive: activeWorkspaceIncidentId !== null,
+          workerBusy,
+          pendingCheckouts: scopedPendingTargets.length > 0 || Boolean(overrides.newVisibleCheckouts?.length)
+        });
+        if (fastPathDecision.hit) {
+          prepareStartedAt = queueEnteredAt;
+          synchronizeStartedAt = queueEnteredAt;
+          synchronizeFinishedAt = queueEnteredAt;
+          return {
+            type: "workspace_sync",
+            attemptId: overrides.attemptId ?? crypto.randomUUID(),
+            workerLabel: label,
+            trigger,
+            outcome: "no_change",
+            startingHead: fastPathDecision.canonicalHead,
+            expectedHead: fastPathDecision.canonicalHead,
+            publishedHead: fastPathDecision.canonicalHead,
+            rebaseCount: 0,
+            diffSizeBytes: 0,
+            gitStatus: "",
+            affectedProjects: [],
+            affectedPaths: [],
+            discardedPaths: [],
+            localChangesDiscarded: false
+          };
+        }
+        prepareStartedAt = Date.now();
         let checkoutTargets = [];
         if (shouldEnsureCheckouts) {
           checkoutTargets = workspaceSyncCheckoutTargets({
@@ -2530,21 +2580,53 @@ async function startWorker(options) {
           if (allowedCheckoutKeys.has(key)) newVisibleCheckoutByKey.set(key, target);
         }
         const newVisibleCheckouts = [...newVisibleCheckoutByKey.values()];
-        return workspaceSyncInput(trigger, {
+        const input = workspaceSyncInput(trigger, {
           ...overrides,
           ...newVisibleCheckouts.length > 0 ? { newVisibleCheckouts } : {}
         });
+        synchronizeStartedAt = Date.now();
+        recentWorkspaceSyncProof.invalidate();
+        const observationGeneration = recentWorkspaceSyncProof.beginObservation();
+        const workerWasBusyDuringObservation = workerBusy;
+        let synchronized;
+        try {
+          synchronized = await (0, import_workspace_sync.synchronizeWorkspace)(input);
+        } finally {
+          synchronizeFinishedAt = Date.now();
+        }
+        if ((synchronized.outcome === "no_change" || synchronized.outcome === "updated") && pendingTargets.length === 0) {
+          recentWorkspaceSyncProof.recordStable({
+            observationGeneration,
+            canonicalHead: synchronized.publishedHead ?? null,
+            scopeKey,
+            observedAtMs: synchronizeFinishedAt,
+            workerBusy: workerWasBusyDuringObservation || activeProcesses.size > 0 || activePtys.size > 0 || cliUpdateInProgress || activeWorkspaceIncidentId !== null
+          });
+        }
+        return synchronized;
       });
-      if (result.outcome === "no_change" || result.outcome === "published" || result.outcome === "updated" || result.outcome === "conflict_reset") {
+      const completedAt = Date.now();
+      const resultWithTelemetry = {
+        ...result,
+        telemetry: {
+          totalMs: completedAt - requestedAt,
+          queueMs: queueEnteredAt - requestedAt,
+          prepareMs: synchronizeStartedAt - prepareStartedAt,
+          synchronizeMs: synchronizeFinishedAt - synchronizeStartedAt,
+          fastPath: workspaceSyncFastPathTelemetry(fastPathDecision)
+        }
+      };
+      if (resultWithTelemetry.outcome === "no_change" || resultWithTelemetry.outcome === "published" || resultWithTelemetry.outcome === "updated" || resultWithTelemetry.outcome === "conflict_reset") {
         for (const target of pendingTargets) {
           const key = manifestCheckoutKey(target.projectId, target.branchName);
           if (pendingManifestCheckouts.get(key) === target) pendingManifestCheckouts.delete(key);
         }
       }
       previousPeriodicFingerprint = null;
-      sendWorkspaceSyncResult(authority, result);
-      return result;
+      sendWorkspaceSyncResult(authority, resultWithTelemetry);
+      return resultWithTelemetry;
     } catch (error) {
+      const completedAt = Date.now();
       const result = {
         type: "workspace_sync",
         attemptId: overrides.attemptId ?? crypto.randomUUID(),
@@ -2559,6 +2641,13 @@ async function startWorker(options) {
         affectedPaths: [],
         discardedPaths: [],
         localChangesDiscarded: false,
+        telemetry: {
+          totalMs: completedAt - requestedAt,
+          queueMs: queueEnteredAt - requestedAt,
+          prepareMs: Math.max(0, synchronizeStartedAt - prepareStartedAt),
+          synchronizeMs: Math.max(0, synchronizeFinishedAt - synchronizeStartedAt),
+          fastPath: workspaceSyncFastPathTelemetry(fastPathDecision)
+        },
         error: error instanceof Error ? error.message : String(error)
       };
       previousPeriodicFingerprint = null;
@@ -2634,6 +2723,7 @@ async function startWorker(options) {
         return;
       }
       if (message.type === "workspace_manifest") {
+        recentWorkspaceSyncProof.invalidate();
         await workspaceSyncSingleFlight.runMutation(() => {
           configureGitHubAuth(message.githubCredential);
           visibleGitIdentity = message.gitIdentity;
@@ -2678,6 +2768,7 @@ async function startWorker(options) {
                 (target) => genericCheckoutKeys.has(manifestCheckoutKey(target.projectId, target.branchName))
               );
               if (hasPendingGenericCheckout) {
+                recentWorkspaceSyncProof.invalidate();
                 previousPeriodicFingerprint = null;
                 requestWorkspaceSync({
                   type: "periodic",
@@ -2685,17 +2776,36 @@ async function startWorker(options) {
                 });
                 return;
               }
-              const fingerprint = await workspaceSyncSingleFlight.fingerprintPrepared(() => workspaceSyncInput({ type: "periodic" }));
-              if (fingerprint === emptyFingerprint) {
+              const observation = await workspaceSyncSingleFlight.runExclusive(() => {
+                const observationGeneration = recentWorkspaceSyncProof.beginObservation();
+                const input = workspaceSyncInput({ type: "periodic" });
+                const workerBusy = activeProcesses.size > 0 || activePtys.size > 0 || cliUpdateInProgress;
+                return {
+                  observationGeneration,
+                  scopeKey: (0, import_workspace_sync_fast_path.workspaceSyncScopeKey)(input.remoteUrl, input.projects),
+                  fingerprint: (0, import_workspace_sync.calculateWorkspaceDiffFingerprint)(input),
+                  canonicalHead: (0, import_workspace_sync_fast_path.readShadowWorkspaceCanonicalHead)(workspaceShadowRoot),
+                  workerBusy
+                };
+              });
+              if (observation.fingerprint === emptyFingerprint) {
+                recentWorkspaceSyncProof.recordStable({
+                  observationGeneration: observation.observationGeneration,
+                  canonicalHead: observation.canonicalHead,
+                  scopeKey: observation.scopeKey,
+                  observedAtMs: Date.now(),
+                  workerBusy: observation.workerBusy || activeProcesses.size > 0 || activePtys.size > 0 || cliUpdateInProgress
+                });
                 previousPeriodicFingerprint = null;
                 return;
               }
-              if (previousPeriodicFingerprint !== fingerprint) {
-                previousPeriodicFingerprint = fingerprint;
+              recentWorkspaceSyncProof.invalidate();
+              if (previousPeriodicFingerprint !== observation.fingerprint) {
+                previousPeriodicFingerprint = observation.fingerprint;
                 return;
               }
               previousPeriodicFingerprint = null;
-              requestWorkspaceSync({ type: "periodic" }, fingerprint);
+              requestWorkspaceSync({ type: "periodic" }, observation.fingerprint);
             })().catch((error) => {
               process.stderr.write(
                 `[r5d-worker] periodic workspace synchronization failed: ${error instanceof Error ? error.message : String(error)}
@@ -2726,7 +2836,9 @@ async function startWorker(options) {
             confirmationReason: message.confirmationReason,
             resetToCanonical: message.resetToCanonical,
             skipVisibleMirror: message.skipVisibleMirror
-          }
+          },
+          message.canonicalHead,
+          message.allowRecentNoChangeFastPath
         );
         return;
       }
@@ -2757,6 +2869,7 @@ async function startWorker(options) {
         return;
       }
       if (message.type === "workspace_incident_updated") {
+        recentWorkspaceSyncProof.invalidate();
         const previousIncidentId = activeWorkspaceIncidentId;
         activeWorkspaceIncidentId = (0, import_workspace_incident_state.applyWorkspaceIncidentUpdate)(activeWorkspaceIncidentId, message);
         previousPeriodicFingerprint = null;
@@ -2803,6 +2916,7 @@ async function startWorker(options) {
           return;
         }
         cliUpdateInProgress = true;
+        recentWorkspaceSyncProof.invalidate();
         try {
           const result = await (0, import_cli_update.installCliUpdate)(message);
           sendWorkerMessage(ws, {
@@ -2865,6 +2979,7 @@ async function startWorker(options) {
           });
           return;
         }
+        recentWorkspaceSyncProof.invalidate();
         const releaseWorkspaceMutation = await (0, import_workspace_command_sync_policy.acquireWorkspaceCommandMutation)(message.target, workspaceSyncSingleFlight);
         let leaseTransferred = false;
         try {
@@ -2892,6 +3007,7 @@ async function startWorker(options) {
         return;
       }
       if (message.type === "pty_input") {
+        recentWorkspaceSyncProof.invalidate();
         writePty(ws, message);
         return;
       }
@@ -2900,6 +3016,7 @@ async function startWorker(options) {
         return;
       }
       if (message.type === "pty_close") {
+        recentWorkspaceSyncProof.invalidate();
         closePty(message);
         return;
       }
@@ -2914,6 +3031,7 @@ async function startWorker(options) {
           });
           return;
         }
+        recentWorkspaceSyncProof.invalidate();
         let result;
         try {
           const runCommand = async () => {
@@ -2946,6 +3064,7 @@ async function startWorker(options) {
           });
           return;
         }
+        recentWorkspaceSyncProof.invalidate();
         sendWorkerMessage(ws, {
           type: "exec_accepted",
           requestId: message.requestId,
@@ -2977,6 +3096,7 @@ async function startWorker(options) {
         return;
       }
       if (message.type === "read" || message.type === "write" || message.type === "edit" || message.type === "grep" || message.type === "find" || message.type === "ls" || message.type === "view_file_bytes") {
+        if (message.type === "write" || message.type === "edit") recentWorkspaceSyncProof.invalidate();
         try {
           const result = await workspaceSyncSingleFlight.runMutation(async () => {
             const resolvedTarget = resolveMessageTarget(message.target);
@@ -3025,6 +3145,7 @@ async function startWorker(options) {
     });
   });
   ws.addEventListener("close", (event) => {
+    recentWorkspaceSyncProof.invalidate();
     stopHeartbeatWatchdog();
     if (periodicWorkspaceScan) {
       clearInterval(periodicWorkspaceScan);

package/dist/cjs/package.json

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

package/dist/cjs/workspace-sync-fast-path.cjs

@@ -0,0 +1,108 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var workspace_sync_fast_path_exports = {};
+__export(workspace_sync_fast_path_exports, {
+  RECENT_WORKSPACE_SYNC_PROOF_MAX_AGE_MS: () => RECENT_WORKSPACE_SYNC_PROOF_MAX_AGE_MS,
+  RecentWorkspaceSyncProofCache: () => RecentWorkspaceSyncProofCache,
+  readShadowWorkspaceCanonicalHead: () => readShadowWorkspaceCanonicalHead,
+  workspaceSyncScopeKey: () => workspaceSyncScopeKey
+});
+module.exports = __toCommonJS(workspace_sync_fast_path_exports);
+var import_node_crypto = require("node:crypto");
+const RECENT_WORKSPACE_SYNC_PROOF_MAX_AGE_MS = 15e3;
+function stableProjectShape(project) {
+  return {
+    projectId: project.projectId,
+    checkoutPathSegments: [...project.checkoutPathSegments],
+    projectPath: project.projectPath,
+    repoHttpUrl: project.repoHttpUrl,
+    defaultBranch: project.defaultBranch,
+    branches: [...project.branches].sort(),
+    canonicalCheckouts: [...project.canonicalCheckouts].sort(
+      (left, right) => left.branchName.localeCompare(right.branchName) || left.scaffoldCommitHash.localeCompare(right.scaffoldCommitHash)
+    )
+  };
+}
+function workspaceSyncScopeKey(remoteUrl, projects) {
+  const stableProjects = [...projects].map(stableProjectShape).sort((left, right) => left.projectId.localeCompare(right.projectId) || left.projectPath.localeCompare(right.projectPath));
+  return (0, import_node_crypto.createHash)("sha256").update(JSON.stringify({ remoteUrl, projects: stableProjects })).digest("hex");
+}
+function readShadowWorkspaceCanonicalHead(shadowRoot) {
+  const result = Bun.spawnSync(["git", "rev-parse", "--verify", "HEAD"], {
+    cwd: shadowRoot,
+    stdout: "pipe",
+    stderr: "ignore"
+  });
+  if (result.exitCode !== 0) return null;
+  const head = result.stdout.toString().trim();
+  return /^[0-9a-f]{40,64}$/.test(head) ? head : null;
+}
+class RecentWorkspaceSyncProofCache {
+  constructor(maxAgeMs = RECENT_WORKSPACE_SYNC_PROOF_MAX_AGE_MS) {
+    this.maxAgeMs = maxAgeMs;
+  }
+  maxAgeMs;
+  generation = 0;
+  proof = null;
+  beginObservation() {
+    return this.generation;
+  }
+  invalidate() {
+    this.generation += 1;
+  }
+  recordStable(input) {
+    if (input.observationGeneration !== this.generation || input.workerBusy || !input.canonicalHead || !/^[0-9a-f]{40,64}$/.test(input.canonicalHead)) {
+      return false;
+    }
+    this.proof = {
+      canonicalHead: input.canonicalHead,
+      scopeKey: input.scopeKey,
+      observedAtMs: input.observedAtMs,
+      generation: this.generation
+    };
+    return true;
+  }
+  evaluate(input) {
+    if (!input.allowRecentNoChangeFastPath || input.trigger.type !== "inbound_head") {
+      return { hit: false, reason: "unsupported_trigger" };
+    }
+    if (input.trigger.canonicalCheckoutOnly) return { hit: false, reason: "canonical_checkout" };
+    if (input.skipVisibleMirror) return { hit: false, reason: "visible_mirror_skipped" };
+    if (input.resetToCanonical) return { hit: false, reason: "reset_requested" };
+    if (input.incidentActive) return { hit: false, reason: "incident_active" };
+    if (input.workerBusy) return { hit: false, reason: "worker_busy" };
+    if (input.pendingCheckouts) return { hit: false, reason: "pending_checkouts" };
+    if (!input.canonicalHead) return { hit: false, reason: "canonical_head_missing" };
+    const proof = this.proof;
+    if (!proof) return { hit: false, reason: "no_recent_proof" };
+    if (proof.generation !== this.generation) return { hit: false, reason: "proof_invalidated" };
+    const proofAgeMs = Math.max(0, input.nowMs - proof.observedAtMs);
+    if (proofAgeMs > this.maxAgeMs) return { hit: false, reason: "proof_expired" };
+    if (proof.scopeKey !== input.scopeKey) return { hit: false, reason: "scope_changed" };
+    if (proof.canonicalHead !== input.canonicalHead) return { hit: false, reason: "canonical_head_changed" };
+    return { hit: true, reason: "recent_stable_no_change", canonicalHead: proof.canonicalHead, proofAgeMs };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RECENT_WORKSPACE_SYNC_PROOF_MAX_AGE_MS,
+  RecentWorkspaceSyncProofCache,
+  readShadowWorkspaceCanonicalHead,
+  workspaceSyncScopeKey
+});