@ricsam/r5d-worker 0.0.57 → 0.0.58

package/dist/cjs/workspace-sync.cjs

@@ -960,7 +960,7 @@ function hydrateProjectFromShadowOptimistically(input, relativeRoot, visibleRoot
     expectedCheckoutSnapshot = checkoutGitSnapshot(visibleRoot);
     return expectedCheckoutSnapshot !== null;
   };
-  let currentGitlinks = new Map(checkoutGitlinks(visibleRoot).map((entry) => [entry.filePath, entry]));
+  const currentGitlinks = new Map(checkoutGitlinks(visibleRoot).map((entry) => [entry.filePath, entry]));
   const changedPaths = [.../* @__PURE__ */ new Set([...preimage.keys(), ...desired.keys()])].filter(
     (filePath) => !hydrationEntriesEqual(preimage.get(filePath), desired.get(filePath))
   );
@@ -1582,6 +1582,33 @@ function resetUncommittedShadowSnapshot(input) {
   }
   runGit(input, input.shadowRoot, ["clean", "-fd"], "clean interrupted workspace snapshot");
 }
+function activeWorkspaceRebase(input) {
+  for (const name of ["rebase-merge", "rebase-apply"]) {
+    const resolved = runGitResult(input, input.shadowRoot, ["rev-parse", "--git-path", name]);
+    if (resolved.exitCode !== 0 || !resolved.stdout) continue;
+    const gitPath = import_node_path.default.isAbsolute(resolved.stdout) ? resolved.stdout : import_node_path.default.resolve(input.shadowRoot, resolved.stdout);
+    if (import_node_fs.default.existsSync(gitPath)) return name;
+  }
+  return null;
+}
+function remediationRebaseInProgressResult(input, result) {
+  if (input.trigger.type !== "remediation" && input.trigger.type !== "remediation_confirm") return null;
+  const rebaseKind = activeWorkspaceRebase(input);
+  if (!rebaseKind) return null;
+  const conflictPaths = runGitResult(input, input.shadowRoot, ["diff", "--name-only", "--diff-filter=U", "-z"]).stdout.split("\0").filter(Boolean).sort();
+  const status = reportedStatus(gitStatus(input));
+  return {
+    ...result,
+    outcome: "conflict_blocked",
+    expectedHead: revParse(input, `origin/${WORKSPACE_BRANCH}`),
+    candidateHead: revParse(input, "ORIG_HEAD") ?? revParse(input, "HEAD") ?? void 0,
+    rebaseCount: 1,
+    gitStatus: status,
+    affectedProjects: affectedProjects(conflictPaths),
+    affectedPaths: reportedPaths(conflictPaths),
+    error: `Workspace conflict remediation has an in-progress ${rebaseKind}; the index and worktree were preserved until the resolver completes or aborts it.`
+  };
+}
 function fastForwardCleanShadowForNewCheckouts(input) {
   if (!input.newVisibleCheckouts?.length) return null;
   runGit(input, input.shadowRoot, ["add", "-A"], "stage existing workspace changes before checkout hydration");
@@ -1801,17 +1828,66 @@ function convergeRedundantInboundCandidate(input, result) {
     affectedPaths: []
   };
 }
+function preserveWorkspaceConflictCandidate(input, observed, options) {
+  try {
+    if (!options.baseRevision) throw new Error("the preserved workspace does not have an old-base commit");
+    runGit(input, input.shadowRoot, ["reset", "--hard", options.baseRevision], "restore old-base workspace conflict candidate");
+    runGit(input, input.shadowRoot, ["clean", "-fd"], "clean old-base workspace conflict candidate");
+    if (!options.preserveShadowCandidate) {
+      const projection = mirrorVisibleWorkspaceToShadow(input);
+      restoreUnscopedCanonicalCheckoutSubtrees(input);
+      const stagePathspecs = projection.opaqueRoots.flatMap((root) => [`:(exclude,literal)${root}`]);
+      runGit(input, input.shadowRoot, ["add", "-A", "--", ".", ...stagePathspecs], "stage preserved workspace conflict candidate");
+      forceStageCanonicalCheckoutFiles(input, projection.entries, projection.opaqueRoots);
+      if (stagedPaths(input).length > 0) {
+        runGit(input, input.shadowRoot, ["commit", "-m", commitMessage(input)], "commit preserved workspace conflict candidate");
+      }
+    }
+    const candidateHead = revParse(input, "HEAD");
+    if (!candidateHead) throw new Error("the preserved workspace conflict candidate does not have a commit");
+    assertUnscopedCanonicalCheckoutSubtreesMatchRemote(input, candidateHead);
+    const upload = uploadWorkspaceCandidate(input, candidateHead);
+    if (upload.exitCode !== 0) {
+      throw new Error(upload.stderr || upload.stdout || "workspace conflict candidate upload failed");
+    }
+    const conflictPaths = [...new Set(options.conflictPaths)].sort();
+    return {
+      ...observed,
+      outcome: "conflict_blocked",
+      expectedHead: options.expectedHead,
+      candidateHead,
+      quarantineRef: input.quarantineRef,
+      ...options.publishedHead ? { publishedHead: options.publishedHead } : {},
+      rebaseCount: options.rebaseCount ?? 0,
+      affectedProjects: affectedProjects(conflictPaths),
+      affectedPaths: reportedPaths(conflictPaths),
+      error: options.error,
+      gitStatus: gitStatus(input)
+    };
+  } catch (error) {
+    return {
+      ...observed,
+      outcome: "failed",
+      rebaseCount: options.rebaseCount ?? 0,
+      affectedProjects: affectedProjects(options.conflictPaths),
+      affectedPaths: reportedPaths(options.conflictPaths),
+      error: `Workspace synchronization found a conflict but could not preserve a durable candidate: ${error instanceof Error ? error.message : String(error)}`,
+      gitStatus: gitStatus(input)
+    };
+  }
+}
 async function synchronizeWorkspace(rawInput) {
   let input = { ...rawInput, attemptId: rawInput.attemptId ?? crypto.randomUUID() };
   try {
     input = { ...input, projects: workspaceProjectsForSync(input.projects, input.trigger) };
+    const isCanonicalRemediationSync = input.skipVisibleMirror === true && (input.trigger.type === "remediation" || input.trigger.type === "remediation_confirm");
     let mirroredGitlinkProjection = { entries: [], opaqueRoots: [], visiblePreimages: /* @__PURE__ */ new Map() };
     let fastForwardedFromHead = null;
     const shadowWasCreated = ensureShadowWorkspace(input);
     let hydrationPreimages = input.skipVisibleMirror ? hydrationPreimagesFromShadowRevision(input, shadowWasCreated ? null : revParse(input, "HEAD")) : /* @__PURE__ */ new Map();
     const remoteHeadAtStart = revParse(input, `origin/${WORKSPACE_BRANCH}`);
     const result = baseResult(input, remoteHeadAtStart);
-    const inboundConflictsAtStart = input.skipVisibleMirror && remoteHeadAtStart ? visibleHydrationConflictPaths(input, hydrationPreimages, `origin/${WORKSPACE_BRANCH}`) : [];
+    const inboundConflictsAtStart = input.skipVisibleMirror && !isCanonicalRemediationSync && remoteHeadAtStart ? visibleHydrationConflictPaths(input, hydrationPreimages, `origin/${WORKSPACE_BRANCH}`) : [];
     if (input.resetToCanonical) {
       if (input.trigger.canonicalCheckoutOnly) {
         throw new Error("A canonical-checkout-only synchronization cannot reset the authoritative resolver checkout");
@@ -1825,6 +1901,8 @@ async function synchronizeWorkspace(rawInput) {
         gitStatus: gitStatus(input)
       };
     }
+    const inProgressRemediation = remediationRebaseInProgressResult(input, result);
+    if (inProgressRemediation) return inProgressRemediation;
     if (!input.skipVisibleMirror) resetUncommittedShadowSnapshot(input);
     restoreUnscopedCanonicalCheckoutSubtrees(input);
     if (!input.skipVisibleMirror) {
@@ -1880,15 +1958,12 @@ async function synchronizeWorkspace(rawInput) {
     const hasUnpushedCommit = candidateHead ? !hasRemoteMain || !tryGit(input, input.shadowRoot, ["merge-base", "--is-ancestor", candidateHead, `origin/${WORKSPACE_BRANCH}`]) : false;
     if (hasUnpushedCommit && inboundConflictsAtStart.length > 0) {
       const conflictPaths = [.../* @__PURE__ */ new Set([...paths, ...inboundConflictsAtStart])].sort();
-      return {
-        ...observed,
-        outcome: "failed",
-        candidateHead: candidateHead ?? void 0,
-        affectedProjects: affectedProjects(conflictPaths),
-        affectedPaths: reportedPaths(conflictPaths),
-        error: "Inbound workspace update overlaps local visible changes; the old-base candidate was preserved for reconciliation.",
-        gitStatus: gitStatus(input)
-      };
+      return preserveWorkspaceConflictCandidate(input, observed, {
+        baseRevision: candidateHead,
+        expectedHead: revParse(input, `origin/${WORKSPACE_BRANCH}`),
+        conflictPaths,
+        error: "Inbound workspace update overlaps local visible changes; the old-base candidate was preserved for reconciliation."
+      });
     }
     if (!hasUnpushedCommit) {
       const localHead = revParse(input, "HEAD");
@@ -1897,22 +1972,21 @@ async function synchronizeWorkspace(rawInput) {
         runGit(input, input.shadowRoot, ["reset", "--hard", `origin/${WORKSPACE_BRANCH}`], "update workspace from canonical state");
         runGit(input, input.shadowRoot, ["clean", "-fd"], "clean updated workspace");
         assertPublishedCanonicalCheckoutTree(input, currentRemoteHead, sampledCanonicalCheckoutTreeHash);
-        mirrorShadowWorkspaceToVisible(input, mirroredGitlinkProjection.opaqueRoots, hydrationPreimages);
-        const inboundConflicts = input.trigger.canonicalCheckoutOnly ? [] : localHead ? hydrationConflictPaths(input, hydrationPreimages, localHead, currentRemoteHead) : visibleHydrationConflictPaths(input, hydrationPreimages, currentRemoteHead);
+        if (!isCanonicalRemediationSync) {
+          mirrorShadowWorkspaceToVisible(input, mirroredGitlinkProjection.opaqueRoots, hydrationPreimages);
+        }
+        const inboundConflicts = input.trigger.canonicalCheckoutOnly || isCanonicalRemediationSync ? [] : localHead ? hydrationConflictPaths(input, hydrationPreimages, localHead, currentRemoteHead) : visibleHydrationConflictPaths(input, hydrationPreimages, currentRemoteHead);
         if (inboundConflicts.length > 0 && localHead) {
           runGit(input, input.shadowRoot, ["reset", "--hard", localHead], "preserve old workspace base after inbound conflict");
           runGit(input, input.shadowRoot, ["clean", "-fd"], "clean preserved old workspace base");
           const conflictPaths = [.../* @__PURE__ */ new Set([...paths, ...inboundConflicts])].sort();
-          return {
-            ...observed,
-            outcome: "failed",
-            candidateHead: candidateHead ?? void 0,
+          return preserveWorkspaceConflictCandidate(input, observed, {
+            baseRevision: localHead,
+            expectedHead: currentRemoteHead,
             publishedHead: currentRemoteHead,
-            affectedProjects: affectedProjects(conflictPaths),
-            affectedPaths: reportedPaths(conflictPaths),
-            error: "Inbound workspace update overlaps local visible changes; disjoint updates were hydrated and the old base was preserved for reconciliation.",
-            gitStatus: gitStatus(input)
-          };
+            conflictPaths,
+            error: "Inbound workspace update overlaps local visible changes; disjoint updates were hydrated and the old base was preserved for reconciliation."
+          });
         }
         return {
           ...observed,
@@ -1925,8 +1999,10 @@ async function synchronizeWorkspace(rawInput) {
       const authoritativeHead = currentRemoteHead ?? localHead;
       if (authoritativeHead) {
         assertPublishedCanonicalCheckoutTree(input, authoritativeHead, sampledCanonicalCheckoutTreeHash);
-        mirrorShadowWorkspaceToVisible(input, mirroredGitlinkProjection.opaqueRoots, hydrationPreimages);
-        const hydrationConflicts2 = input.trigger.canonicalCheckoutOnly ? [] : fastForwardedFromHead ? hydrationConflictPaths(input, hydrationPreimages, fastForwardedFromHead, authoritativeHead) : visibleHydrationConflictPaths(input, hydrationPreimages, authoritativeHead);
+        if (!isCanonicalRemediationSync) {
+          mirrorShadowWorkspaceToVisible(input, mirroredGitlinkProjection.opaqueRoots, hydrationPreimages);
+        }
+        const hydrationConflicts2 = input.trigger.canonicalCheckoutOnly || isCanonicalRemediationSync ? [] : fastForwardedFromHead ? hydrationConflictPaths(input, hydrationPreimages, fastForwardedFromHead, authoritativeHead) : visibleHydrationConflictPaths(input, hydrationPreimages, authoritativeHead);
         if (hydrationConflicts2.length > 0 && fastForwardedFromHead) {
           runGit(
             input,
@@ -1935,16 +2011,13 @@ async function synchronizeWorkspace(rawInput) {
             "preserve old workspace base after new-checkout fast-forward conflict"
           );
           runGit(input, input.shadowRoot, ["clean", "-fd"], "clean preserved new-checkout workspace base");
-          return {
-            ...observed,
-            outcome: "failed",
-            candidateHead: candidateHead ?? void 0,
+          return preserveWorkspaceConflictCandidate(input, observed, {
+            baseRevision: fastForwardedFromHead,
+            expectedHead: currentRemoteHead,
             publishedHead: currentRemoteHead ?? void 0,
-            affectedProjects: affectedProjects(hydrationConflicts2),
-            affectedPaths: reportedPaths(hydrationConflicts2),
-            error: "Workspace fast-forward for a new checkout overlaps local visible changes; compatible updates were hydrated and the old base was preserved for reconciliation.",
-            gitStatus: gitStatus(input)
-          };
+            conflictPaths: hydrationConflicts2,
+            error: "Workspace fast-forward for a new checkout overlaps local visible changes; compatible updates were hydrated and the old base was preserved for reconciliation."
+          });
         }
       }
       return {
@@ -1964,17 +2037,14 @@ async function synchronizeWorkspace(rawInput) {
         const conflicted = runGitResult(input, input.shadowRoot, ["diff", "--name-only", "--diff-filter=U", "-z"]);
         const conflictPaths = [.../* @__PURE__ */ new Set([...paths, ...conflicted.stdout.split("\0").filter(Boolean)])].sort();
         runGit(input, input.shadowRoot, ["rebase", "--abort"], "preserve workspace candidate after rebase conflict");
-        return {
-          ...observed,
-          outcome: "failed",
+        return preserveWorkspaceConflictCandidate(input, observed, {
+          baseRevision: candidateHead,
           expectedHead,
-          candidateHead: candidateHead ?? void 0,
           rebaseCount,
-          affectedProjects: affectedProjects(conflictPaths),
-          affectedPaths: reportedPaths(conflictPaths),
-          error: `Workspace candidate conflicts with canonical head ${expectedHead}; local changes were preserved for reconciliation.`,
-          gitStatus: gitStatus(input)
-        };
+          preserveShadowCandidate: isCanonicalRemediationSync,
+          conflictPaths,
+          error: `Workspace candidate conflicts with canonical head ${expectedHead}; local changes were preserved for reconciliation.`
+        });
       }
       candidateHead = revParse(input, "HEAD");
       assertPublishedCanonicalCheckoutTree(input, "HEAD", sampledCanonicalCheckoutTreeHash);
@@ -1990,8 +2060,10 @@ async function synchronizeWorkspace(rawInput) {
       };
     }
     assertPublishedCanonicalCheckoutTree(input, candidateHead, sampledCanonicalCheckoutTreeHash);
-    mirrorShadowWorkspaceToVisible(input, mirroredGitlinkProjection.opaqueRoots, hydrationPreimages);
-    const hydrationConflicts = input.trigger.canonicalCheckoutOnly ? [] : candidateHeadBeforeRebase ? hydrationConflictPaths(input, hydrationPreimages, candidateHeadBeforeRebase, "HEAD") : visibleHydrationConflictPaths(input, hydrationPreimages, "HEAD");
+    if (!isCanonicalRemediationSync) {
+      mirrorShadowWorkspaceToVisible(input, mirroredGitlinkProjection.opaqueRoots, hydrationPreimages);
+    }
+    const hydrationConflicts = input.trigger.canonicalCheckoutOnly || isCanonicalRemediationSync ? [] : candidateHeadBeforeRebase ? hydrationConflictPaths(input, hydrationPreimages, candidateHeadBeforeRebase, "HEAD") : visibleHydrationConflictPaths(input, hydrationPreimages, "HEAD");
     if (hydrationConflicts.length > 0 && candidateHeadBeforeRebase) {
       runGit(
         input,
@@ -2001,17 +2073,13 @@ async function synchronizeWorkspace(rawInput) {
       );
       runGit(input, input.shadowRoot, ["clean", "-fd"], "clean old-base workspace candidate");
       const conflictPaths = [.../* @__PURE__ */ new Set([...paths, ...hydrationConflicts])].sort();
-      return {
-        ...observed,
-        outcome: "failed",
+      return preserveWorkspaceConflictCandidate(input, observed, {
+        baseRevision: candidateHeadBeforeRebase,
         expectedHead,
-        candidateHead,
         rebaseCount,
-        affectedProjects: affectedProjects(conflictPaths),
-        affectedPaths: reportedPaths(conflictPaths),
-        error: "Workspace changed while its candidate was reconciling; visible changes and the old-base candidate were preserved.",
-        gitStatus: gitStatus(input)
-      };
+        conflictPaths,
+        error: "Workspace changed while its candidate was reconciling; visible changes and the old-base candidate were preserved."
+      });
     }
     const upload = uploadWorkspaceCandidate(input, candidateHead);
     if (upload.exitCode !== 0) {
@@ -2096,6 +2164,9 @@ class WorkspaceSyncSingleFlight {
   fingerprintPrepared(prepare) {
     return this.enqueue(() => calculateWorkspaceDiffFingerprint(prepare()));
   }
+  runExclusive(operation) {
+    return this.enqueue(operation);
+  }
   runMutation(operation) {
     return this.mutationGate.runMutation(operation);
   }

package/dist/mjs/main.mjs

@@ -15,6 +15,11 @@ import { terminateProcessTree } from "./process-tree.mjs";
 import { openWorkerPortForwardRelay } from "./port-forward-client.mjs";
 import { applyWorkspaceIncidentUpdate, releasePendingWorkspaceHead } from "./workspace-incident-state.mjs";
 import { acquireWorkspaceCommandMutation, runWorkspaceCommand } from "./workspace-command-sync-policy.mjs";
+import {
+  RecentWorkspaceSyncProofCache,
+  readShadowWorkspaceCanonicalHead,
+  workspaceSyncScopeKey
+} from "./workspace-sync-fast-path.mjs";
 import {
   isRetryableWorkerServerStatus,
   superviseWorkerRuntime,
@@ -31,6 +36,9 @@ import {
   synchronizeWorkspace,
   workspaceProjectsForSync
 } from "./workspace-sync.mjs";
+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";
 }
@@ -2369,6 +2377,7 @@ async function startWorker(options) {
   let sessionArtifactSyncRequestsInFlight = 0;
   let cliUpdateInProgress = false;
   let reloadAfterClose = false;
+  const recentWorkspaceSyncProof = new RecentWorkspaceSyncProofCache();
   const workspaceSyncInput = (trigger, overrides = {}) => {
     if (!workspaceRemoteUrl) throw new Error("Worker workspace manifest has not been received");
     const projects = workspaceProjectsForSync([...manifestByProjectId.values()], trigger);
@@ -2460,19 +2469,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 = workspaceProjectsForSync([...manifestByProjectId.values()], trigger);
+        if (!workspaceRemoteUrl) throw new Error("Worker workspace manifest has not been received");
+        const scopeKey = 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({
@@ -2492,21 +2546,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 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(),
@@ -2521,6 +2607,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;
@@ -2596,6 +2689,7 @@ async function startWorker(options) {
         return;
       }
       if (message.type === "workspace_manifest") {
+        recentWorkspaceSyncProof.invalidate();
         await workspaceSyncSingleFlight.runMutation(() => {
           configureGitHubAuth(message.githubCredential);
           visibleGitIdentity = message.gitIdentity;
@@ -2640,6 +2734,7 @@ async function startWorker(options) {
                 (target) => genericCheckoutKeys.has(manifestCheckoutKey(target.projectId, target.branchName))
               );
               if (hasPendingGenericCheckout) {
+                recentWorkspaceSyncProof.invalidate();
                 previousPeriodicFingerprint = null;
                 requestWorkspaceSync({
                   type: "periodic",
@@ -2647,17 +2742,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: workspaceSyncScopeKey(input.remoteUrl, input.projects),
+                  fingerprint: calculateWorkspaceDiffFingerprint(input),
+                  canonicalHead: 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)}
@@ -2688,7 +2802,9 @@ async function startWorker(options) {
             confirmationReason: message.confirmationReason,
             resetToCanonical: message.resetToCanonical,
             skipVisibleMirror: message.skipVisibleMirror
-          }
+          },
+          message.canonicalHead,
+          message.allowRecentNoChangeFastPath
         );
         return;
       }
@@ -2719,6 +2835,7 @@ async function startWorker(options) {
         return;
       }
       if (message.type === "workspace_incident_updated") {
+        recentWorkspaceSyncProof.invalidate();
         const previousIncidentId = activeWorkspaceIncidentId;
         activeWorkspaceIncidentId = applyWorkspaceIncidentUpdate(activeWorkspaceIncidentId, message);
         previousPeriodicFingerprint = null;
@@ -2765,6 +2882,7 @@ async function startWorker(options) {
           return;
         }
         cliUpdateInProgress = true;
+        recentWorkspaceSyncProof.invalidate();
         try {
           const result = await installCliUpdate(message);
           sendWorkerMessage(ws, {
@@ -2827,6 +2945,7 @@ async function startWorker(options) {
           });
           return;
         }
+        recentWorkspaceSyncProof.invalidate();
         const releaseWorkspaceMutation = await acquireWorkspaceCommandMutation(message.target, workspaceSyncSingleFlight);
         let leaseTransferred = false;
         try {
@@ -2854,6 +2973,7 @@ async function startWorker(options) {
         return;
       }
       if (message.type === "pty_input") {
+        recentWorkspaceSyncProof.invalidate();
         writePty(ws, message);
         return;
       }
@@ -2862,6 +2982,7 @@ async function startWorker(options) {
         return;
       }
       if (message.type === "pty_close") {
+        recentWorkspaceSyncProof.invalidate();
         closePty(message);
         return;
       }
@@ -2876,6 +2997,7 @@ async function startWorker(options) {
           });
           return;
         }
+        recentWorkspaceSyncProof.invalidate();
         let result;
         try {
           const runCommand = async () => {
@@ -2908,6 +3030,7 @@ async function startWorker(options) {
           });
           return;
         }
+        recentWorkspaceSyncProof.invalidate();
         sendWorkerMessage(ws, {
           type: "exec_accepted",
           requestId: message.requestId,
@@ -2939,6 +3062,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);
@@ -2987,6 +3111,7 @@ async function startWorker(options) {
     });
   });
   ws.addEventListener("close", (event) => {
+    recentWorkspaceSyncProof.invalidate();
     stopHeartbeatWatchdog();
     if (periodicWorkspaceScan) {
       clearInterval(periodicWorkspaceScan);

package/dist/mjs/package.json

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