@ricsam/r5d-worker 0.0.56 → 0.0.58

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

@@ -0,0 +1,81 @@
+import { createHash } from "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 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 };
+  }
+}
+export {
+  RECENT_WORKSPACE_SYNC_PROOF_MAX_AGE_MS,
+  RecentWorkspaceSyncProofCache,
+  readShadowWorkspaceCanonicalHead,
+  workspaceSyncScopeKey
+};

package/dist/mjs/workspace-sync.mjs

@@ -911,7 +911,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))
   );
@@ -1533,6 +1533,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 = path.isAbsolute(resolved.stdout) ? resolved.stdout : path.resolve(input.shadowRoot, resolved.stdout);
+    if (fs.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");
@@ -1752,17 +1779,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");
@@ -1776,6 +1852,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) {
@@ -1831,15 +1909,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");
@@ -1848,22 +1923,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,
@@ -1876,8 +1950,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,
@@ -1886,16 +1962,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 {
@@ -1915,17 +1988,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);
@@ -1941,8 +2011,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,
@@ -1952,17 +2024,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) {
@@ -2047,6 +2115,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/types/workspace-sync-fast-path.d.ts

@@ -0,0 +1,69 @@
+export declare const RECENT_WORKSPACE_SYNC_PROOF_MAX_AGE_MS = 15000;
+export type WorkspaceSyncFastPathMissReason = "unsupported_trigger" | "canonical_checkout" | "visible_mirror_skipped" | "reset_requested" | "incident_active" | "worker_busy" | "pending_checkouts" | "canonical_head_missing" | "no_recent_proof" | "proof_invalidated" | "proof_expired" | "scope_changed" | "canonical_head_changed";
+export type WorkspaceSyncFastPathDecision = {
+    hit: true;
+    reason: "recent_stable_no_change";
+    canonicalHead: string;
+    proofAgeMs: number;
+} | {
+    hit: false;
+    reason: WorkspaceSyncFastPathMissReason;
+};
+type WorkspaceSyncScopeProject = {
+    projectId: string;
+    checkoutPathSegments: readonly string[];
+    projectPath: string;
+    repoHttpUrl: string | null;
+    defaultBranch: string;
+    branches: readonly string[];
+    canonicalCheckouts: ReadonlyArray<{
+        branchName: string;
+        scaffoldCommitHash: string;
+    }>;
+};
+type WorkspaceSyncFastPathInput = {
+    trigger: {
+        type: string;
+        canonicalCheckoutOnly?: boolean;
+    };
+    allowRecentNoChangeFastPath: boolean;
+    canonicalHead?: string | null;
+    scopeKey: string;
+    nowMs: number;
+    skipVisibleMirror?: boolean;
+    resetToCanonical?: boolean;
+    incidentActive: boolean;
+    workerBusy: boolean;
+    pendingCheckouts: boolean;
+};
+/**
+ * Fingerprints the inputs that determine which visible paths participate in a
+ * generic workspace scan. Authentication headers are deliberately excluded.
+ */
+export declare function workspaceSyncScopeKey(remoteUrl: string, projects: readonly WorkspaceSyncScopeProject[]): string;
+export declare function readShadowWorkspaceCanonicalHead(shadowRoot: string): string | null;
+/**
+ * A short-lived proof cache for the duplicate scan between the worker's
+ * periodic stable-fingerprint pass and an immediately following agent start.
+ *
+ * The proof is process/connection local. Callers invalidate it before every
+ * known local mutation and retain an observation generation while a scan is
+ * running, so a mutation racing the scan cannot publish a usable proof.
+ */
+export declare class RecentWorkspaceSyncProofCache {
+    private readonly maxAgeMs;
+    private generation;
+    private proof;
+    constructor(maxAgeMs?: number);
+    beginObservation(): number;
+    invalidate(): void;
+    recordStable(input: {
+        observationGeneration: number;
+        canonicalHead: string | null;
+        scopeKey: string;
+        observedAtMs: number;
+        workerBusy: boolean;
+    }): boolean;
+    evaluate(input: WorkspaceSyncFastPathInput): WorkspaceSyncFastPathDecision;
+}
+export {};

package/dist/types/workspace-sync.d.ts

@@ -32,7 +32,7 @@ export type WorkspaceSyncTrigger = {
     canonicalCheckoutOnly?: boolean;
     detail?: string;
 };
-export type WorkspaceSyncOutcome = "no_change" | "candidate_ready" | "published" | "updated" | "conflict_reset" | "large_diff_blocked" | "reset" | "failed";
+export type WorkspaceSyncOutcome = "no_change" | "candidate_ready" | "published" | "updated" | "conflict_reset" | "large_diff_blocked" | "conflict_blocked" | "reset" | "failed";
 export type WorkspaceSyncResult = {
     type: "workspace_sync";
     attemptId: string;
@@ -52,6 +52,17 @@ export type WorkspaceSyncResult = {
     discardedPaths: string[];
     localChangesDiscarded: boolean;
     sampledCanonicalCheckoutTreeHash?: string;
+    telemetry?: {
+        totalMs: number;
+        queueMs: number;
+        prepareMs: number;
+        synchronizeMs: number;
+        fastPath: {
+            hit: boolean;
+            reason: string;
+            proofAgeMs?: number;
+        };
+    };
     error?: string;
 };
 export type WorkspaceSyncInput = {
@@ -122,6 +133,7 @@ export declare class WorkspaceSyncSingleFlight {
     runPrepared(prepare: () => WorkspaceSyncInput): Promise<WorkspaceSyncResult>;
     fingerprint(input: WorkspaceSyncInput): Promise<string>;
     fingerprintPrepared(prepare: () => WorkspaceSyncInput): Promise<string>;
+    runExclusive<T>(operation: () => Promise<T> | T): Promise<T>;
     runMutation<T>(operation: () => Promise<T> | T): Promise<T>;
     acquireMutation(): Promise<WorkspaceMutationLease>;
     afterCurrent(): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.56",
+  "version": "0.0.58",
   "type": "module",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/mjs/main.mjs",