@ricsam/r5d-worker 0.0.123 → 0.0.125

package/dist/cjs/package.json

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

package/dist/cjs/project-checkout-garbage.cjs

@@ -34,7 +34,8 @@ __export(project_checkout_garbage_exports, {
   isStagedProjectCheckoutPath: () => isStagedProjectCheckoutPath,
   ownedStagedPath: () => ownedStagedPath,
   removeStagedProjectCheckout: () => removeStagedProjectCheckout,
-  stageProjectCheckoutForDeletion: () => stageProjectCheckoutForDeletion
+  stageProjectCheckoutForDeletion: () => stageProjectCheckoutForDeletion,
+  stageProjectForDeletion: () => stageProjectForDeletion
 });
 module.exports = __toCommonJS(project_checkout_garbage_exports);
 var import_node_crypto = require("node:crypto");
@@ -58,11 +59,33 @@ function stageProjectCheckoutForDeletion(projectRoot, branchName, checkoutPath)
   import_node_fs.default.renameSync(checkoutPath, target);
   return target;
 }
+function stageProjectForDeletion(projectsRoot, projectRoot) {
+  const root = import_node_path.default.resolve(projectsRoot);
+  const resolved = import_node_path.default.resolve(projectRoot);
+  const relative = import_node_path.default.relative(root, resolved);
+  const segments = relative.split(import_node_path.default.sep);
+  if (!relative || relative.startsWith("..") || import_node_path.default.isAbsolute(relative) || segments.length !== 2 || segments.some((segment) => !segment || segment.startsWith("."))) {
+    throw new Error(`Cannot stage ${projectRoot} for deletion: not a project root under ${projectsRoot}`);
+  }
+  if (!isRealDirectory(resolved)) throw new Error(`Cannot stage ${projectRoot} for deletion: not a directory`);
+  const garbageRoot = import_node_path.default.join(root, segments[0], PROJECT_DELETED_CHECKOUTS_DIRECTORY);
+  import_node_fs.default.mkdirSync(garbageRoot, { recursive: true });
+  if (!isRealDirectory(garbageRoot)) throw new Error(`Cannot stage ${projectRoot} for deletion: ${garbageRoot} is not a directory`);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const target = import_node_path.default.join(garbageRoot, `${segments[1]}-${timestamp}-${(0, import_node_crypto.randomUUID)().slice(0, 8)}`);
+  import_node_fs.default.renameSync(resolved, target);
+  return target;
+}
 function isStagedProjectCheckoutPath(projectsRoot, candidate) {
   const relative = import_node_path.default.relative(import_node_path.default.resolve(projectsRoot), import_node_path.default.resolve(candidate));
   if (!relative || relative.startsWith("..") || import_node_path.default.isAbsolute(relative)) return false;
   const segments = relative.split(import_node_path.default.sep);
-  return segments.length === 4 && segments[2] === PROJECT_DELETED_CHECKOUTS_DIRECTORY && segments[3] !== "" && !segments[3].startsWith(".");
+  const entry = segments[segments.length - 1];
+  if (!entry || entry.startsWith(".")) return false;
+  if (segments.length === 4)
+    return segments[2] === PROJECT_DELETED_CHECKOUTS_DIRECTORY && !segments[0].startsWith(".") && !segments[1].startsWith(".");
+  if (segments.length === 3) return segments[1] === PROJECT_DELETED_CHECKOUTS_DIRECTORY && !segments[0].startsWith(".");
+  return false;
 }
 function ownedStagedPath(projectsRoot, candidate) {
   const root = import_node_path.default.resolve(projectsRoot);
@@ -95,6 +118,11 @@ function discoverStagedProjectCheckouts(projectsRoot) {
   const staged = [];
   for (const namespace of realDirectoryEntries(root)) {
     if (namespace.startsWith(".")) continue;
+    const namespaceGarbageRoot = import_node_path.default.join(root, namespace, PROJECT_DELETED_CHECKOUTS_DIRECTORY);
+    for (const entry of realDirectoryEntries(namespaceGarbageRoot)) {
+      const candidate = import_node_path.default.join(namespaceGarbageRoot, entry);
+      if (ownedStagedPath(root, candidate)) staged.push(candidate);
+    }
     for (const project of realDirectoryEntries(import_node_path.default.join(root, namespace))) {
       if (project.startsWith(".")) continue;
       const garbageRoot = import_node_path.default.join(root, namespace, project, PROJECT_DELETED_CHECKOUTS_DIRECTORY);
@@ -186,5 +214,6 @@ class ProjectCheckoutGarbageCollector {
   isStagedProjectCheckoutPath,
   ownedStagedPath,
   removeStagedProjectCheckout,
-  stageProjectCheckoutForDeletion
+  stageProjectCheckoutForDeletion,
+  stageProjectForDeletion
 });

package/dist/cjs/project-workspace-state.cjs

@@ -314,47 +314,63 @@ function lstatIfExists(targetPath) {
     throw error;
   }
 }
-function ensureDurableStateRoot(stateRoot) {
+async function fsyncDirectoryAsync(directory) {
+  const handle = await import_node_fs.default.promises.open(directory, "r");
+  try {
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+async function lstatIfExistsAsync(targetPath) {
+  try {
+    return await import_node_fs.default.promises.lstat(targetPath);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+async function ensureDurableStateRoot(stateRoot) {
   const resolvedStateRoot = import_node_path.default.resolve(stateRoot);
   let existingAncestor = resolvedStateRoot;
-  while (!lstatIfExists(existingAncestor)) {
+  while (!await lstatIfExistsAsync(existingAncestor)) {
     const parent = import_node_path.default.dirname(existingAncestor);
     if (parent === existingAncestor) throw new Error(`Project workspace state has no existing ancestor: ${resolvedStateRoot}`);
     existingAncestor = parent;
   }
-  const ancestorStat = lstatIfExists(existingAncestor);
+  const ancestorStat = await lstatIfExistsAsync(existingAncestor);
   if (!ancestorStat || ancestorStat.isSymbolicLink() || !ancestorStat.isDirectory()) {
     throw new Error(`Project workspace state must descend from a real directory: ${resolvedStateRoot}`);
   }
-  import_node_fs.default.mkdirSync(resolvedStateRoot, { recursive: true, mode: 448 });
+  await import_node_fs.default.promises.mkdir(resolvedStateRoot, { recursive: true, mode: 448 });
   let current = resolvedStateRoot;
   while (true) {
-    const stat = lstatIfExists(current);
+    const stat = await lstatIfExistsAsync(current);
     if (!stat || stat.isSymbolicLink() || !stat.isDirectory()) {
       throw new Error(`Project workspace state path must be a real directory: ${current}`);
     }
-    fsyncDirectory(current);
+    await fsyncDirectoryAsync(current);
     if (current === existingAncestor) break;
     current = import_node_path.default.dirname(current);
   }
 }
-function writeStateAtomically(stateRoot, statePath, state, afterStateRootFsync) {
-  ensureDurableStateRoot(stateRoot);
+async function writeStateAtomically(stateRoot, statePath, state, afterStateRootFsync) {
+  await ensureDurableStateRoot(stateRoot);
   afterStateRootFsync?.();
   const temporaryPath = import_node_path.default.join(stateRoot, `.${PROJECT_WORKSPACE_STATE_FILE}.${process.pid}.${(0, import_node_crypto.randomUUID)()}.tmp`);
-  let descriptor;
+  let handle;
   try {
-    descriptor = import_node_fs.default.openSync(temporaryPath, "wx", 384);
-    import_node_fs.default.writeFileSync(descriptor, `${JSON.stringify(normalizeState(state), null, 2)}
+    handle = await import_node_fs.default.promises.open(temporaryPath, "wx", 384);
+    await handle.writeFile(`${JSON.stringify(normalizeState(state), null, 2)}
 `, "utf8");
-    import_node_fs.default.fsyncSync(descriptor);
-    import_node_fs.default.closeSync(descriptor);
-    descriptor = void 0;
-    import_node_fs.default.renameSync(temporaryPath, statePath);
-    fsyncDirectory(stateRoot);
+    await handle.sync();
+    await handle.close();
+    handle = void 0;
+    await import_node_fs.default.promises.rename(temporaryPath, statePath);
+    await fsyncDirectoryAsync(stateRoot);
   } finally {
-    if (descriptor !== void 0) import_node_fs.default.closeSync(descriptor);
-    import_node_fs.default.rmSync(temporaryPath, { force: true });
+    if (handle !== void 0) await handle.close();
+    await import_node_fs.default.promises.rm(temporaryPath, { force: true });
   }
 }
 function createBranchTombstone(project, branchName) {
@@ -730,7 +746,7 @@ class ProjectWorkspaceStateStore {
       locallyPendingCreatedBranches: state.locallyPendingCreatedBranches
     });
   }
-  reconcile(input) {
+  async reconcile(input) {
     const previous = readState(this.statePath);
     const authoritativeDesiredProjects = normalizeDesiredProjects(input.desiredProjects);
     for (const project of authoritativeDesiredProjects) {
@@ -806,11 +822,11 @@ class ProjectWorkspaceStateStore {
       enabledRepositoryTransitions: previous.enabledRepositoryTransitions.filter(({ projectId }) => authoritativeProjectIds.has(projectId)),
       tombstones
     });
-    writeStateAtomically(this.stateRoot, this.statePath, nextState);
+    await writeStateAtomically(this.stateRoot, this.statePath, nextState);
     return stateView(this.projectsRoot, nextState);
   }
   /** Record a successful enabled reseed without letting disabled config consume it. */
-  recordEnabledRepositoryTransition(input) {
+  async recordEnabledRepositoryTransition(input) {
     const [transition] = normalizeEnabledRepositoryTransitions([input]);
     const state = readState(this.statePath);
     if (!state.desiredProjects.some(({ projectId }) => projectId === transition.projectId)) {
@@ -819,11 +835,11 @@ class ProjectWorkspaceStateStore {
     state.enabledRepositoryTransitions = state.enabledRepositoryTransitions.filter(({ projectId }) => projectId !== transition.projectId);
     state.enabledRepositoryTransitions.push(transition);
     state.enabledRepositoryTransitions.sort((left, right) => left.projectId.localeCompare(right.projectId));
-    writeStateAtomically(this.stateRoot, this.statePath, state);
+    await writeStateAtomically(this.stateRoot, this.statePath, state);
     return stateView(this.projectsRoot, state);
   }
   /** Persist the create intent before invoking Git so a crash cannot orphan an untracked worktree. */
-  recordPendingCreatedBranch(input) {
+  async recordPendingCreatedBranch(input) {
     const [pending] = normalizePendingCreatedBranches([input]);
     const state = readState(this.statePath);
     const existingPending = state.locallyPendingCreatedBranches.find(
@@ -846,11 +862,11 @@ class ProjectWorkspaceStateStore {
     state.locallyPendingCreatedBranches.sort(
       (left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName)
     );
-    writeStateAtomically(this.stateRoot, this.statePath, state);
+    await writeStateAtomically(this.stateRoot, this.statePath, state);
     return stateView(this.projectsRoot, state);
   }
   /** Roll back an intent only when Git failed before creating its branch. */
-  rollbackPendingCreatedBranch(input) {
+  async rollbackPendingCreatedBranch(input) {
     const [pending] = normalizePendingCreatedBranches([input]);
     const state = readState(this.statePath);
     const key = pendingCreatedBranchKey(pending);
@@ -863,11 +879,11 @@ class ProjectWorkspaceStateStore {
     );
     const project = state.desiredProjects.find(({ projectId }) => projectId === pending.projectId);
     if (project) project.branches = project.branches.filter(({ branchName }) => branchName !== pending.branchName);
-    writeStateAtomically(this.stateRoot, this.statePath, state);
+    await writeStateAtomically(this.stateRoot, this.statePath, state);
     return stateView(this.projectsRoot, state);
   }
   /** Clear a create intent after an authoritative desired config contains it. */
-  clearPendingCreatedBranch(input) {
+  async clearPendingCreatedBranch(input) {
     const [pending] = normalizePendingCreatedBranches([input]);
     const state = readState(this.statePath);
     const key = pendingCreatedBranchKey(pending);
@@ -877,11 +893,11 @@ class ProjectWorkspaceStateStore {
     state.locallyPendingCreatedBranches = state.locallyPendingCreatedBranches.filter(
       (candidate) => pendingCreatedBranchKey(candidate) !== key
     );
-    writeStateAtomically(this.stateRoot, this.statePath, state);
+    await writeStateAtomically(this.stateRoot, this.statePath, state);
     return stateView(this.projectsRoot, state);
   }
   /** Persist a branch tombstone before mutating its linked worktree or local ref. */
-  beginBranchDeletion(input) {
+  async beginBranchDeletion(input) {
     const [target] = normalizePendingCreatedBranches([input]);
     const state = readState(this.statePath);
     const project = state.desiredProjects.find(({ projectId }) => projectId === target.projectId);
@@ -897,10 +913,10 @@ class ProjectWorkspaceStateStore {
     state.locallyPendingCreatedBranches = state.locallyPendingCreatedBranches.filter(
       (candidate) => pendingCreatedBranchKey(candidate) !== key
     );
-    writeStateAtomically(this.stateRoot, this.statePath, state);
+    await writeStateAtomically(this.stateRoot, this.statePath, state);
     return stateView(this.projectsRoot, state);
   }
-  recordTreePublication(input) {
+  async recordTreePublication(input) {
     if (!GIT_OBJECT_ID_PATTERN.test(input.publishedHead)) throw new Error("Invalid published workspace head");
     const state = readState(this.statePath);
     const ids = new Set(input.tombstoneIds);
@@ -913,10 +929,10 @@ class ProjectWorkspaceStateStore {
     state.tombstones = state.tombstones.filter(
       (tombstone) => !tombstone.treePublishedHead || tombstone.kind === "branch" && !branchIsCurrentlyDesired(state.desiredProjects, tombstone.projectId, tombstone.branchName)
     );
-    if (changed) writeStateAtomically(this.stateRoot, this.statePath, state);
+    if (changed) await writeStateAtomically(this.stateRoot, this.statePath, state);
     return stateView(this.projectsRoot, state);
   }
-  recordMirrorRefDeletion(input) {
+  async recordMirrorRefDeletion(input) {
     (0, import_managed_paths.validateManagedBranchName)(input.branchName);
     const state = readState(this.statePath);
     const tombstone = state.tombstones.find(({ id }) => id === input.tombstoneId);
@@ -935,13 +951,13 @@ class ProjectWorkspaceStateStore {
     if (branchNames.every((branchName) => tombstone.mirrorRefsDeleted.includes(branchName))) {
       state.tombstones = state.tombstones.filter(({ id }) => id !== tombstone.id);
     }
-    writeStateAtomically(this.stateRoot, this.statePath, state);
+    await writeStateAtomically(this.stateRoot, this.statePath, state);
     return stateView(this.projectsRoot, state);
   }
 }
 const projectWorkspaceStateTestHarness = {
   writeEmptyStateAtDurableRootBoundary(stateRoot, afterStateRootFsync) {
-    writeStateAtomically(stateRoot, import_node_path.default.join(stateRoot, PROJECT_WORKSPACE_STATE_FILE), EMPTY_STATE, afterStateRootFsync);
+    return writeStateAtomically(stateRoot, import_node_path.default.join(stateRoot, PROJECT_WORKSPACE_STATE_FILE), EMPTY_STATE, afterStateRootFsync);
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/project-worktrees.cjs

@@ -29,6 +29,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var project_worktrees_exports = {};
 __export(project_worktrees_exports, {
   PROJECT_REMOVED_CHECKOUTS_DIRECTORY: () => PROJECT_REMOVED_CHECKOUTS_DIRECTORY,
+  PROJECT_WORKTREE_SNAPSHOT_OWNER_SESSION_ID: () => PROJECT_WORKTREE_SNAPSHOT_OWNER_SESSION_ID,
   PROJECT_WORKTREE_SNAPSHOT_PREFIX: () => PROJECT_WORKTREE_SNAPSHOT_PREFIX,
   ProjectBranchCreationRollbackIncompleteError: () => ProjectBranchCreationRollbackIncompleteError,
   applyObservedProjectMirrorHeads: () => applyObservedProjectMirrorHeads,
@@ -52,7 +53,11 @@ __export(project_worktrees_exports, {
   pushProjectMirrorHeads: () => pushProjectMirrorHeads,
   recoverStaleProjectWorktreeSnapshots: () => recoverStaleProjectWorktreeSnapshots,
   removeProjectWorktrees: () => removeProjectWorktrees,
-  reseedProjectHeadsFromMirror: () => reseedProjectHeadsFromMirror
+  reseedProjectHeadsFromMirror: () => reseedProjectHeadsFromMirror,
+  runProjectSnapshotApplyJob: () => runProjectSnapshotApplyJob,
+  runProjectSnapshotCreateJob: () => runProjectSnapshotCreateJob,
+  runProjectSnapshotPersistJob: () => runProjectSnapshotPersistJob,
+  runProjectSnapshotRollbackJob: () => runProjectSnapshotRollbackJob
 });
 module.exports = __toCommonJS(project_worktrees_exports);
 var import_node_crypto = require("node:crypto");
@@ -64,6 +69,7 @@ var import_managed_paths = require("./managed-paths.cjs");
 var import_project_checkout_garbage = require("./project-checkout-garbage.cjs");
 var import_project_mirror_refs_token = require("./project-mirror-refs-token.cjs");
 var import_working_tree_mirror = require("./working-tree-mirror.cjs");
+var import_workspace_filesystem_executor = require("./workspace-filesystem-executor.cjs");
 const PROJECT_WORKTREE_SNAPSHOT_PREFIX = "r5d-project-worktrees-";
 const PROJECT_WORKTREE_SNAPSHOT_MANIFEST = "transaction.json";
 const PROJECT_WORKTREE_SNAPSHOT_MANIFEST_VERSION = 1;
@@ -479,7 +485,7 @@ function assertNoOutstandingSnapshotForProject(temporaryRoot, projectRoot) {
     }
   }
 }
-function snapshotBranchTrees(projectRoot, branches, temporaryRoot, onProgress, scope = "project") {
+function snapshotBranchTrees(projectRoot, branches, temporaryRoot, onProgress, scope, ownerSessionId) {
   const resolvedProjectRoot = import_node_path.default.resolve(projectRoot);
   const resolvedTemporaryRoot = import_node_path.default.resolve(temporaryRoot ?? import_node_os.default.tmpdir());
   assertNoOutstandingSnapshotForProject(resolvedTemporaryRoot, resolvedProjectRoot);
@@ -502,7 +508,7 @@ function snapshotBranchTrees(projectRoot, branches, temporaryRoot, onProgress, s
       state: "building",
       scope,
       ownerProcessId: process.pid,
-      ownerSessionId: PROJECT_WORKTREE_SNAPSHOT_OWNER_SESSION_ID,
+      ownerSessionId,
       projectRoot: resolvedProjectRoot,
       branches: branchSnapshots,
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -1025,7 +1031,7 @@ async function reconcileLinkedLayout(input) {
     plan.push({ branchName: branch.branchName, checkoutPath, seed: resolved.seed, action: keep ? "keep" : "reset" });
   }
   const mutatedBranches = new Set(plan.filter(({ action }) => action !== "keep").map(({ branchName }) => branchName));
-  if (mutatedBranches.size > 0) input.beforeDestructiveMutation(mutatedBranches);
+  if (mutatedBranches.size > 0) await input.beforeDestructiveMutation(mutatedBranches);
   for (const entry of plan) {
     if (entry.action === "keep") continue;
     if (entry.action === "reset") {
@@ -1066,13 +1072,19 @@ async function ensureProjectWorktrees(input) {
   const snapshotStorageRoot = import_node_path.default.resolve(input.snapshotRoot ?? import_node_os.default.tmpdir());
   assertNoOutstandingSnapshotForProject(snapshotStorageRoot, projectRoot);
   let snapshot;
-  const ensureSnapshot = (branchNames) => {
-    snapshot ??= snapshotBranchTrees(
-      projectRoot,
-      branchNames ? input.branches.filter(({ branchName }) => branchNames.has(branchName)) : input.branches,
-      snapshotStorageRoot,
-      input.onSnapshotProgress,
-      branchNames ? "branches" : "project"
+  const ensureSnapshot = async (branchNames) => {
+    snapshot ??= await (0, import_workspace_filesystem_executor.workspaceFilesystemExecutor)().run(
+      "project_snapshot_create",
+      {
+        projectRoot,
+        branches: (branchNames ? input.branches.filter(({ branchName }) => branchNames.has(branchName)) : input.branches).map((branch) => ({
+          ...branch
+        })),
+        temporaryRoot: snapshotStorageRoot,
+        scope: branchNames ? "branches" : "project",
+        ownerSessionId: PROJECT_WORKTREE_SNAPSHOT_OWNER_SESSION_ID
+      },
+      { onProgress: input.onSnapshotProgress }
     );
     return snapshot;
   };
@@ -1090,10 +1102,12 @@ async function ensureProjectWorktrees(input) {
         ...input,
         projectRoot,
         defaultBranch,
-        beforeDestructiveMutation: ensureSnapshot
+        beforeDestructiveMutation: async (branchNames) => {
+          await ensureSnapshot(branchNames);
+        }
       }));
     } else {
-      ensureSnapshot();
+      await ensureSnapshot();
       mirrorHeads = await initializeLinkedLayout({ ...input, projectRoot, defaultBranch });
       mutatedBranches = new Set(input.branches.map(({ branchName }) => branchName));
     }
@@ -1101,17 +1115,12 @@ async function ensureProjectWorktrees(input) {
     if (mutatedBranches.size > 0 && !preparedSnapshot) {
       throw new Error("Project worktree mutation started without a prepared recovery snapshot");
     }
-    for (const branch of input.branches) {
-      if (!mutatedBranches.has(branch.branchName)) continue;
+    const snapshotMirrors = input.branches.flatMap((branch) => {
+      if (!mutatedBranches.has(branch.branchName)) return [];
       const snapshotPath = preparedSnapshot?.paths.get(branch.branchName);
-      if (!snapshotPath) continue;
-      (0, import_working_tree_mirror.mirrorWorkingTree)({
-        sourceRoot: snapshotPath,
-        targetRoot: branchPath(projectRoot, branch.branchName),
-        sourceMode: "all",
-        deletionMode: "git"
-      });
-    }
+      return snapshotPath ? [{ snapshotPath, targetPath: branchPath(projectRoot, branch.branchName) }] : [];
+    });
+    if (snapshotMirrors.length > 0) await (0, import_workspace_filesystem_executor.workspaceFilesystemExecutor)().run("project_snapshot_apply", { mirrors: snapshotMirrors });
     const states = [];
     for (const branch of input.branches) {
       const checkoutPath = branchPath(projectRoot, branch.branchName);
@@ -1127,24 +1136,23 @@ async function ensureProjectWorktrees(input) {
     states.sort((left, right) => left.branchName.localeCompare(right.branchName));
     if (snapshot) {
       const primaryGitDirectory = import_node_path.default.join(branchPath(projectRoot, input.primaryBranchName), ".git");
-      persistReconciledProjectAndConsumeSnapshot(
+      await (0, import_workspace_filesystem_executor.workspaceFilesystemExecutor)().run("project_snapshot_persist", {
         snapshot,
-        void 0,
-        snapshot.manifest.scope === "branches" ? [
+        durabilityPaths: snapshot.manifest.scope === "branches" ? [
           ...snapshot.manifest.branches.map(({ branchName }) => branchPath(projectRoot, branchName)),
           // Branch refs and worktree registrations moved in the shared
           // administrative directory; objects are fsynced by git itself.
           import_node_path.default.join(primaryGitDirectory, "refs"),
           import_node_path.default.join(primaryGitDirectory, "packed-refs"),
           import_node_path.default.join(primaryGitDirectory, "worktrees")
-        ] : void 0
-      );
+        ] : null
+      });
     }
     return states;
   } catch (error) {
     if (!snapshot) throw error;
     try {
-      rollbackProjectWorktreeSnapshot(snapshot);
+      await (0, import_workspace_filesystem_executor.workspaceFilesystemExecutor)().run("project_snapshot_rollback", { snapshot });
     } catch (recoveryError) {
       throw new Error(
         `Project worktree reconciliation failed and its snapshot could not be fully restored; recovery state is retained at ${snapshot.root}`,
@@ -1275,7 +1283,7 @@ function createLinkedProjectBranch(input) {
     throw error;
   }
 }
-function createOrRetryLinkedProjectBranch(input) {
+async function createOrRetryLinkedProjectBranch(input) {
   if (input.pendingRetry) {
     deleteLinkedProjectBranch({
       projectRoot: input.projectRoot,
@@ -1283,7 +1291,12 @@ function createOrRetryLinkedProjectBranch(input) {
       branchName: input.branchName
     });
   }
-  return createLinkedProjectBranch(input);
+  return await (0, import_workspace_filesystem_executor.workspaceFilesystemExecutor)().run("project_branch_create", {
+    projectRoot: input.projectRoot,
+    sourceBranchName: input.sourceBranchName,
+    branchName: input.branchName,
+    workingTree: input.workingTree
+  });
 }
 function classifyProjectCheckout(input) {
   const checkoutPath = branchPath(input.projectRoot, input.branchName);
@@ -1377,7 +1390,8 @@ function removeProjectWorktrees(input) {
       throw new Error(`Project branch ${branchName} has an in-progress Git operation`);
     }
   }
-  import_node_fs.default.rmSync(projectRoot, { recursive: true, force: true });
+  if (!import_node_fs.default.existsSync(projectRoot)) return {};
+  return { stagedForCollectionPath: (0, import_project_checkout_garbage.stageProjectForDeletion)(input.projectsRoot, projectRoot) };
 }
 async function deleteProjectMirrorBranch(input) {
   (0, import_managed_paths.validateManagedBranchName)(input.branchName);
@@ -1620,11 +1634,37 @@ async function reseedProjectHeadsFromMirror(input) {
     reseeded: moved
   }));
 }
+function runProjectSnapshotCreateJob(input, context) {
+  return snapshotBranchTrees(input.projectRoot, input.branches, input.temporaryRoot, context.progress, input.scope, input.ownerSessionId);
+}
+function runProjectSnapshotApplyJob(input) {
+  for (const { snapshotPath, targetPath } of input.mirrors) {
+    (0, import_working_tree_mirror.mirrorWorkingTree)({ sourceRoot: snapshotPath, targetRoot: targetPath, sourceMode: "all", deletionMode: "git" });
+  }
+  return null;
+}
+function runProjectSnapshotPersistJob(input) {
+  persistReconciledProjectAndConsumeSnapshot(input.snapshot, void 0, input.durabilityPaths ?? void 0);
+  return null;
+}
+function runProjectSnapshotRollbackJob(input) {
+  rollbackProjectWorktreeSnapshot(input.snapshot);
+  return null;
+}
 const projectWorktreesTestHarness = {
   commandArgs: gitCommandArgs,
   configureRepository,
   createPreparedSnapshot(input) {
-    return { root: snapshotBranchTrees(input.projectRoot, input.branches, input.temporaryRoot, void 0, input.scope).root };
+    return {
+      root: snapshotBranchTrees(
+        input.projectRoot,
+        input.branches,
+        input.temporaryRoot,
+        void 0,
+        input.scope ?? "project",
+        PROJECT_WORKTREE_SNAPSHOT_OWNER_SESSION_ID
+      ).root
+    };
   },
   consumeSnapshot(snapshotRoot) {
     const manifest = readSnapshotManifest(snapshotRoot);
@@ -1641,6 +1681,7 @@ const projectWorktreesTestHarness = {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PROJECT_REMOVED_CHECKOUTS_DIRECTORY,
+  PROJECT_WORKTREE_SNAPSHOT_OWNER_SESSION_ID,
   PROJECT_WORKTREE_SNAPSHOT_PREFIX,
   ProjectBranchCreationRollbackIncompleteError,
   applyObservedProjectMirrorHeads,
@@ -1664,5 +1705,9 @@ const projectWorktreesTestHarness = {
   pushProjectMirrorHeads,
   recoverStaleProjectWorktreeSnapshots,
   removeProjectWorktrees,
-  reseedProjectHeadsFromMirror
+  reseedProjectHeadsFromMirror,
+  runProjectSnapshotApplyJob,
+  runProjectSnapshotCreateJob,
+  runProjectSnapshotPersistJob,
+  runProjectSnapshotRollbackJob
 });

package/dist/cjs/recovery-journal-protocol.cjs

@@ -0,0 +1,56 @@
+"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 recovery_journal_protocol_exports = {};
+__export(recovery_journal_protocol_exports, {
+  WORKER_RECOVERY_JOURNAL_OPS: () => WORKER_RECOVERY_JOURNAL_OPS,
+  isWorkerRecoveryJournalOp: () => isWorkerRecoveryJournalOp,
+  serializeWorkerRecoveryJournalError: () => serializeWorkerRecoveryJournalError
+});
+module.exports = __toCommonJS(recovery_journal_protocol_exports);
+const WORKER_RECOVERY_JOURNAL_OPS = [
+  "admit",
+  "readmitUnknownBranchDeletion",
+  "record",
+  "unknown",
+  "unknownRun",
+  "acknowledgeResult",
+  "acknowledgeOutput",
+  "acknowledgeTerminal",
+  "cancelSession",
+  "isRequestCancelled",
+  "operations",
+  "recoveryState",
+  "terminals",
+  "outputReplayBegin",
+  "outputReplayNext",
+  "outputReplayEnd"
+];
+function isWorkerRecoveryJournalOp(value) {
+  return typeof value === "string" && WORKER_RECOVERY_JOURNAL_OPS.includes(value);
+}
+function serializeWorkerRecoveryJournalError(error) {
+  if (!(error instanceof Error)) return { name: "Error", message: String(error) };
+  return { name: error.name, message: error.message, ...typeof error.stack === "string" ? { stack: error.stack } : {} };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WORKER_RECOVERY_JOURNAL_OPS,
+  isWorkerRecoveryJournalOp,
+  serializeWorkerRecoveryJournalError
+});