@ricsam/r5d-worker 0.0.101 → 0.0.104

package/dist/cjs/main.cjs

@@ -72,6 +72,8 @@ var import_workspace_incident_state = require("./workspace-incident-state.cjs");
 var import_workspace_automatic_sync_policy = require("./workspace-automatic-sync-policy.cjs");
 var import_workspace_command_sync_policy = require("./workspace-command-sync-policy.cjs");
 var import_workspace_mutation_gate = require("./workspace-mutation-gate.cjs");
+var import_workspace_projection_ledger = require("./workspace-projection-ledger.cjs");
+var import_workspace_sync_coalescer = require("./workspace-sync-coalescer.cjs");
 var import_workspace_path_move = require("./workspace-path-move.cjs");
 var import_workspace_project_config_policy = require("./workspace-project-config-policy.cjs");
 var import_workspace_preserve_only_policy = require("./workspace-preserve-only-policy.cjs");
@@ -175,6 +177,12 @@ const workspaceSyncSingleFlight = {
   acquireMutation() {
     return workspaceMutationGate.acquireMutation();
   },
+  runBranchMutation(operation) {
+    return workspaceMutationGate.runBranchMutation(operation);
+  },
+  branchMutationQueuePosition() {
+    return workspaceMutationGate.branchMutationQueuePosition();
+  },
   afterCurrent() {
     return workspaceSyncQueue;
   }
@@ -305,6 +313,7 @@ const workerPtyTestHarness = {
   removeEnvFiles: removePtyEnvFiles,
   resolveEnvFileReferences: resolvePtyEnvFileReferences,
   commandHasWorkspaceEffect: workerCommandHasWorkspaceEffect,
+  targetProcessEnv,
   canonicalSyncTerminalHead,
   ptyIsWorkspaceBusy: workerPtyIsWorkspaceBusy,
   parseLinuxForegroundBusy: parseLinuxPtyForegroundBusy
@@ -312,21 +321,12 @@ const workerPtyTestHarness = {
 function defaultConfigPath() {
   return import_node_path.default.join(import_node_os.default.homedir(), ".config", "r5d", "r5dctl", "config.json");
 }
-function defaultProjectsRoot() {
-  return import_node_path.default.join(import_node_os.default.homedir(), ".r5d", "projects");
-}
-function defaultSyncRoot() {
-  return import_node_path.default.join(import_node_os.default.homedir(), ".r5d", "sync");
-}
-function defaultArtifactRoot() {
-  return import_node_path.default.join(import_node_os.default.homedir(), ".r5d", "artifacts");
-}
-function defaultPlanRoot() {
-  return import_node_path.default.join(import_node_os.default.homedir(), ".r5d", "plans");
+function defaultRootDir() {
+  return import_node_path.default.join(import_node_os.default.homedir(), ".r5d");
 }
 function printHelp() {
   process.stdout.write(`Usage:
-  r5d-worker start --label <label> [--base-url <url>] [--token <token>] [--api-key <key>]
+  r5d-worker start --label <label> [--root <dir>] [--base-url <url>] [--token <token>] [--api-key <key>]
   r5d-worker --version
 
 Options:
@@ -335,10 +335,7 @@ Options:
   --token <token>       r5d worker token
   --api-key <key>       r5d API key
   --config <path>       Config path (default ~/.config/r5d/r5dctl/config.json)
-  --project-root <dir>  Override projects checkout root (default ~/.r5d/projects)
-  --sync-root <dir>     Override r5d internal sync git root (default ~/.r5d/sync)
-  --artifact-root <dir> Override session artifact root (default from R5D_ARTIFACTS_ROOT or ~/.r5d/artifacts)
-  --plan-root <dir>     Override synced plan root (default from R5D_PLANS_ROOT or ~/.r5d/plans)
+  --root <dir>          Override worker data root (default from R5D_ROOT or ~/.r5d)
   -v, --version         Show r5d-worker version
   -h, --help            Show this help
 `);
@@ -453,24 +450,9 @@ function parseArgs(argv) {
       options.label = label;
       continue;
     }
-    const projectRoot = readOption("--project-root");
-    if (projectRoot !== void 0) {
-      options.projectRoot = projectRoot;
-      continue;
-    }
-    const syncRoot = readOption("--sync-root");
-    if (syncRoot !== void 0) {
-      options.syncRoot = syncRoot;
-      continue;
-    }
-    const artifactRoot = readOption("--artifact-root");
-    if (artifactRoot !== void 0) {
-      options.artifactRoot = artifactRoot;
-      continue;
-    }
-    const planRoot = readOption("--plan-root");
-    if (planRoot !== void 0) {
-      options.planRoot = planRoot;
+    const rootDir = readOption("--root");
+    if (rootDir !== void 0) {
+      options.rootDir = rootDir;
       continue;
     }
     rest.push(arg);
@@ -515,11 +497,9 @@ async function readResponseText(response) {
     return "";
   }
 }
-const R5D_ARTIFACTS_DIR_REF = "$R5D_ARTIFACTS_DIR";
-const R5D_PLANS_DIR_REF = "$R5D_PLANS_DIR";
-const R5D_ACTIVE_PLAN_FILE_REF = "$R5D_ACTIVE_PLAN_FILE";
-const R5D_PLANS_DIR_ENV = "R5D_PLANS_DIR";
-const BUILT_IN_TOOL_PATH_REFS = [R5D_ARTIFACTS_DIR_REF, R5D_PLANS_DIR_REF, R5D_ACTIVE_PLAN_FILE_REF];
+const R5D_ROOT_REF = "$R5D_ROOT";
+const R5D_ROOT_ENV = "R5D_ROOT";
+const BUILT_IN_TOOL_PATH_REFS = [R5D_ROOT_REF];
 function parseBuiltInToolPath(inputPath) {
   const normalized = inputPath.replace(/\\/g, "/");
   const match = /^\$(?:\{([A-Za-z_][A-Za-z0-9_]*)\}|([A-Za-z_][A-Za-z0-9_]*))(?:\/(.*))?$/.exec(normalized);
@@ -535,6 +515,26 @@ function parseBuiltInToolPath(inputPath) {
     relativePath: match[3] ?? ""
   };
 }
+function expandRootPathSegments(relativePath, builtInPaths) {
+  const values = {
+    R5D_SESSION_ID: builtInPaths.sessionId,
+    R5D_PROJECT_ID: builtInPaths.projectId,
+    R5D_BRANCH_NAME: builtInPaths.branchName,
+    R5D_ACTIVE_PLAN_ID: builtInPaths.activePlanId
+  };
+  let expandedPath = relativePath;
+  for (const [variableName, value] of Object.entries(values)) {
+    const variablePattern = new RegExp(`\\$(?:\\{${variableName}\\}|${variableName})(?=\\/|\\.|$)`, "g");
+    if (!variablePattern.test(expandedPath)) continue;
+    if (!value) throw new Error(`$${variableName} is unavailable for this worker path`);
+    expandedPath = expandedPath.replace(variablePattern, value);
+  }
+  const unsupportedVariable = /\$(?:\{([A-Za-z_][A-Za-z0-9_]*)\}|([A-Za-z_][A-Za-z0-9_]*))/.exec(expandedPath);
+  if (unsupportedVariable) {
+    throw new Error(`Unsupported ${R5D_ROOT_REF} path variable "$${unsupportedVariable[1] ?? unsupportedVariable[2]}"`);
+  }
+  return expandedPath.split("/").filter(Boolean);
+}
 function validateArtifactSessionId(sessionId) {
   if (!/^(migration-)?[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(sessionId)) {
     throw new Error(`Invalid artifact session id: ${sessionId}`);
@@ -550,14 +550,6 @@ function sessionArtifactDir(artifactRoot, sessionId) {
   validateArtifactSessionId(sessionId);
   return import_node_path.default.join(artifactRoot, sessionId);
 }
-function artifactEnv(artifactRoot, sessionId) {
-  if (!sessionId) {
-    return {};
-  }
-  return {
-    R5D_ARTIFACTS_DIR: sessionArtifactDir(artifactRoot, sessionId)
-  };
-}
 function projectPlanDir(planRoot, projectId, branchName) {
   validateProjectId(projectId);
   validateBranchName(branchName);
@@ -570,21 +562,18 @@ function targetPlanDir(planRoot, target) {
   }
   return import_node_path.default.join(planRoot, "workspace");
 }
-function planEnv(planRoot, target, activePlanId) {
-  const plansDir = targetPlanDir(planRoot, target);
-  const env = {
-    [R5D_PLANS_DIR_ENV]: plansDir
-  };
+function planEnv(activePlanId) {
+  const env = {};
   if (activePlanId) {
     validatePlanId(activePlanId);
     env.R5D_ACTIVE_PLAN_ID = activePlanId;
-    env.R5D_ACTIVE_PLAN_FILE = import_node_path.default.join(plansDir, `${activePlanId}.plan.md`);
   }
   return env;
 }
 function isArtifactEnvPath(filePath) {
   try {
-    return parseBuiltInToolPath(filePath)?.ref === R5D_ARTIFACTS_DIR_REF;
+    const parsed = parseBuiltInToolPath(filePath);
+    return parsed?.ref === R5D_ROOT_REF && parsed.relativePath.split("/").filter(Boolean)[0] === "artifacts";
   } catch {
     return false;
   }
@@ -726,48 +715,46 @@ async function prepareBuiltInToolPaths(input) {
   if (!parsed) {
     return void 0;
   }
-  if (parsed.ref === R5D_ARTIFACTS_DIR_REF) {
+  const builtInPaths = {
+    rootDir: input.rootDir,
+    sessionId: input.sessionId,
+    activePlanId: input.activePlanId,
+    ...input.target.type === "project" ? { projectId: input.target.projectId, branchName: input.target.branchName } : {}
+  };
+  const rootPathSegments = expandRootPathSegments(parsed.relativePath, builtInPaths);
+  if (rootPathSegments[0] === "artifacts") {
     if (input.access === "write") {
       throw new Error(
-        `${R5D_ARTIFACTS_DIR_REF} attachments are read-only. Copy them into a project path before editing or creating files.`
+        `${R5D_ROOT_REF}/artifacts attachments are read-only. Copy them into a project path before editing or creating files.`
       );
     }
-    if (!input.sessionId) {
-      throw new Error(`${R5D_ARTIFACTS_DIR_REF} paths require an active chat session`);
-    }
-    return {
-      artifactsDir: await syncSessionArtifacts({
-        baseUrl: input.baseUrl,
-        token: input.token,
-        sessionId: input.sessionId,
-        artifactRoot: input.artifactRoot
-      })
-    };
-  }
-  const plansDir = targetPlanDir(input.planRoot, input.target);
-  import_node_fs.default.mkdirSync(plansDir, { recursive: true });
-  if (parsed.ref === R5D_PLANS_DIR_REF) {
-    return { plansDir };
+    const referencedSessionId = rootPathSegments[1];
+    if (!referencedSessionId) return builtInPaths;
+    validateArtifactSessionId(referencedSessionId);
+    await syncSessionArtifacts({
+      baseUrl: input.baseUrl,
+      token: input.token,
+      sessionId: referencedSessionId,
+      artifactRoot: import_node_path.default.join(input.rootDir, "artifacts")
+    });
   }
-  if (!input.activePlanId) {
-    throw new Error(`${R5D_ACTIVE_PLAN_FILE_REF} paths require an active plan`);
+  if (rootPathSegments[0] === "plans") {
+    import_node_fs.default.mkdirSync(targetPlanDir(import_node_path.default.join(input.rootDir, "plans"), input.target), { recursive: true });
   }
-  validatePlanId(input.activePlanId);
-  return {
-    plansDir,
-    activePlanFile: import_node_path.default.join(plansDir, `${input.activePlanId}.plan.md`)
-  };
+  return builtInPaths;
 }
 async function prepareArtifactEnvForShell(input) {
+  const env = { [R5D_ROOT_ENV]: input.rootDir };
   if (!input.sessionId) {
-    return {};
+    return env;
   }
+  const artifactRoot = import_node_path.default.join(input.rootDir, "artifacts");
   try {
     await syncSessionArtifacts({
       baseUrl: input.baseUrl,
       token: input.token,
       sessionId: input.sessionId,
-      artifactRoot: input.artifactRoot
+      artifactRoot
     });
   } catch (error) {
     process.stderr.write(
@@ -775,16 +762,14 @@ async function prepareArtifactEnvForShell(input) {
 `
     );
   }
-  const artifactsDir = sessionArtifactDir(input.artifactRoot, input.sessionId);
+  const artifactsDir = sessionArtifactDir(artifactRoot, input.sessionId);
   import_node_fs.default.mkdirSync(artifactsDir, { recursive: true });
-  return {
-    R5D_ARTIFACTS_DIR: artifactsDir
-  };
+  return env;
 }
 function preparePlanEnvForShell(input) {
-  const plansDir = targetPlanDir(input.planRoot, input.target);
+  const plansDir = targetPlanDir(import_node_path.default.join(input.rootDir, "plans"), input.target);
   import_node_fs.default.mkdirSync(plansDir, { recursive: true });
-  return planEnv(input.planRoot, input.target, input.activePlanId);
+  return planEnv(input.activePlanId);
 }
 async function verifyR5dctlAuth(baseUrl, token, workerLabel) {
   const statusUrl = new URL("/api/r5dctl/auth/status", baseUrl);
@@ -952,30 +937,17 @@ function resolveVirtualWorkerFilePath(inputPath, parsed, builtInPaths) {
   if (parsed.relativePath.split("/").includes("..")) {
     throw new Error(`Invalid ${parsed.ref} path: ${inputPath}`);
   }
-  let rootPath;
-  let absolutePath;
-  if (parsed.ref === R5D_ARTIFACTS_DIR_REF) {
-    rootPath = builtInPaths?.artifactsDir;
-  } else if (parsed.ref === R5D_PLANS_DIR_REF) {
-    rootPath = builtInPaths?.plansDir;
-  } else {
-    if (parsed.relativePath) {
-      throw new Error(`${R5D_ACTIVE_PLAN_FILE_REF} must reference the active plan file directly`);
-    }
-    rootPath = builtInPaths?.plansDir;
-    absolutePath = builtInPaths?.activePlanFile;
-  }
-  if (!rootPath || parsed.ref === R5D_ACTIVE_PLAN_FILE_REF && !absolutePath) {
-    const requirement = parsed.ref === R5D_ARTIFACTS_DIR_REF ? "an active chat session" : "an active plan";
-    throw new Error(`${parsed.ref} paths require ${requirement}`);
-  }
-  const normalizedPath = parsed.relativePath ? import_node_path.default.posix.normalize(parsed.relativePath).replace(/^\/+|\/+$/g, "") : "";
+  const rootPath = builtInPaths?.rootDir;
+  if (!rootPath) throw new Error(`${R5D_ROOT_REF} paths require an available worker root`);
+  const expandedPath = expandRootPathSegments(parsed.relativePath, builtInPaths);
+  if (expandedPath.includes("..")) throw new Error(`Invalid ${parsed.ref} path: ${inputPath}`);
+  const normalizedPath = expandedPath.length > 0 ? import_node_path.default.posix.normalize(expandedPath.join("/")).replace(/^\/+|\/+$/g, "") : "";
   const normalizedRelativePath = normalizedPath === "." ? "" : normalizedPath;
-  absolutePath ??= normalizedRelativePath ? import_node_path.default.resolve(rootPath, ...normalizedRelativePath.split("/")) : import_node_path.default.resolve(rootPath);
+  const absolutePath = normalizedRelativePath ? import_node_path.default.resolve(rootPath, ...normalizedRelativePath.split("/")) : import_node_path.default.resolve(rootPath);
   assertPathInsideRealRoot(rootPath, absolutePath, `${parsed.ref} path`);
   return {
     absolutePath,
-    displayPath: normalizedRelativePath ? `${parsed.ref}/${normalizedRelativePath}` : parsed.ref,
+    displayPath: parsed.relativePath ? `${parsed.ref}/${parsed.relativePath}` : parsed.ref,
     repoRelativePath: null,
     scope: "virtual",
     virtualRootPath: import_node_path.default.resolve(rootPath)
@@ -2219,8 +2191,7 @@ async function executeReadFileOperation(input) {
     token: input.token,
     sessionId: input.message.sessionId,
     activePlanId: input.message.activePlanId,
-    artifactRoot: input.artifactRoot,
-    planRoot: input.planRoot,
+    rootDir: input.rootDir,
     access: "read"
   });
   return readWorkerTextFile(input.resolvedTarget.rootPath, input.message.filePath, input.message.offset, input.message.limit, builtInPaths);
@@ -2233,8 +2204,7 @@ async function executeWriteFileOperation(input) {
     token: input.token,
     sessionId: input.message.sessionId,
     activePlanId: input.message.activePlanId,
-    artifactRoot: input.artifactRoot,
-    planRoot: input.planRoot,
+    rootDir: input.rootDir,
     access: "write"
   });
   input.assertAdmission();
@@ -2252,8 +2222,7 @@ async function executeEditFileOperation(input) {
     token: input.token,
     sessionId: input.message.sessionId,
     activePlanId: input.message.activePlanId,
-    artifactRoot: input.artifactRoot,
-    planRoot: input.planRoot,
+    rootDir: input.rootDir,
     access: "write"
   });
   input.assertAdmission();
@@ -2380,8 +2349,7 @@ async function executeGrepOperation(input) {
     token: input.token,
     sessionId: input.message.sessionId,
     activePlanId: input.message.activePlanId,
-    artifactRoot: input.artifactRoot,
-    planRoot: input.planRoot,
+    rootDir: input.rootDir,
     access: "read"
   });
   return grepWorkerFiles(
@@ -2439,8 +2407,7 @@ async function executeFindOperation(input) {
     token: input.token,
     sessionId: input.message.sessionId,
     activePlanId: input.message.activePlanId,
-    artifactRoot: input.artifactRoot,
-    planRoot: input.planRoot,
+    rootDir: input.rootDir,
     access: "read"
   });
   return findWorkerFiles(
@@ -2481,8 +2448,7 @@ async function executeLsOperation(input) {
     token: input.token,
     sessionId: input.message.sessionId,
     activePlanId: input.message.activePlanId,
-    artifactRoot: input.artifactRoot,
-    planRoot: input.planRoot,
+    rootDir: input.rootDir,
     access: "read"
   });
   return listWorkerDirectory(input.resolvedTarget.rootPath, input.message.path, input.message.limit, builtInPaths);
@@ -2588,8 +2554,7 @@ async function executeViewFileBytesOperation(input) {
     token: input.token,
     sessionId: input.message.sessionId,
     activePlanId: input.message.activePlanId,
-    artifactRoot: input.artifactRoot,
-    planRoot: input.planRoot,
+    rootDir: input.rootDir,
     access: "read"
   });
   return readWorkerImageFile(input.resolvedTarget.rootPath, input.message.filePath, builtInPaths);
@@ -2629,27 +2594,30 @@ function targetIdentityEnv(target) {
     R5D_BRANCH_NAME: ""
   };
 }
+function targetProcessEnv(rootDir, target) {
+  return { [R5D_ROOT_ENV]: rootDir, ...targetIdentityEnv(target) };
+}
 async function prepareShellEnvForTarget(input) {
   const artifactProcessEnv = await prepareArtifactEnvForShell({
     baseUrl: input.baseUrl,
     token: input.token,
     sessionId: input.sessionId,
-    artifactRoot: input.artifactRoot
+    rootDir: input.rootDir
   });
   if (input.target.type === "workspace" && input.target.rootProfile === "canonical_sync") {
     return {
       ...artifactProcessEnv,
-      ...targetIdentityEnv(input.target)
+      ...targetProcessEnv(input.rootDir, input.target)
     };
   }
   return {
     ...artifactProcessEnv,
     ...preparePlanEnvForShell({
       target: input.target,
-      planRoot: input.planRoot,
+      rootDir: input.rootDir,
       activePlanId: input.activePlanId
     }),
-    ...targetIdentityEnv(input.target)
+    ...targetProcessEnv(input.rootDir, input.target)
   };
 }
 async function executeCommand(input) {
@@ -2664,13 +2632,12 @@ async function executeCommand(input) {
   };
   input.setPreparationHeartbeatLease(true);
   try {
-    const targetProcessEnv = await prepareShellEnvForTarget({
+    const targetProcessEnv2 = await prepareShellEnvForTarget({
       target: input.resolvedTarget.target,
       baseUrl: input.baseUrl,
       token: input.token,
       sessionId: input.message.sessionId,
-      artifactRoot: input.artifactRoot,
-      planRoot: input.planRoot,
+      rootDir: input.rootDir,
       activePlanId: input.message.env?.R5D_ACTIVE_PLAN_ID
     });
     const cwd = resolveCommandCwd(input.resolvedTarget.rootPath, input.message.cwd);
@@ -2680,7 +2647,7 @@ async function executeCommand(input) {
       stdout: "pipe",
       stderr: "pipe",
       detached: true,
-      env: workerChildProcessEnvironment([githubProcessEnv(), input.message.env ?? {}, targetProcessEnv])
+      env: workerChildProcessEnvironment([githubProcessEnv(), input.message.env ?? {}, targetProcessEnv2])
     });
     spawnedProcess = subprocess;
     credentialBearingProcessGroups.set(subprocess.pid, subprocess);
@@ -2769,13 +2736,12 @@ async function executeStreamingCommand(input) {
       });
       return;
     }
-    const targetProcessEnv = await prepareShellEnvForTarget({
+    const targetProcessEnv2 = await prepareShellEnvForTarget({
       target: input.resolvedTarget.target,
       baseUrl: input.baseUrl,
       token: input.token,
       sessionId: input.message.sessionId,
-      artifactRoot: input.artifactRoot,
-      planRoot: input.planRoot,
+      rootDir: input.rootDir,
       activePlanId: input.message.env?.R5D_ACTIVE_PLAN_ID
     });
     const cwd = resolveCommandCwd(input.resolvedTarget.rootPath, input.message.cwd);
@@ -2789,7 +2755,7 @@ async function executeStreamingCommand(input) {
       stdout: "pipe",
       stderr: "pipe",
       detached: true,
-      env: workerChildProcessEnvironment([githubProcessEnv(), input.message.env ?? {}, targetProcessEnv])
+      env: workerChildProcessEnvironment([githubProcessEnv(), input.message.env ?? {}, targetProcessEnv2])
     });
     spawnedProcess = subprocess;
     credentialBearingProcessGroups.set(subprocess.pid, subprocess);
@@ -3253,10 +3219,10 @@ async function openPty(input) {
   }
   const planProcessEnv = !(input.resolvedTarget.target.type === "workspace" && input.resolvedTarget.target.rootProfile === "canonical_sync") ? preparePlanEnvForShell({
     target: input.resolvedTarget.target,
-    planRoot: input.planRoot,
+    rootDir: input.rootDir,
     activePlanId: input.message.env?.R5D_ACTIVE_PLAN_ID
   }) : {};
-  const targetProcessEnv = targetIdentityEnv(input.resolvedTarget.target);
+  const targetEnv = targetProcessEnv(input.rootDir, input.resolvedTarget.target);
   const shell = resolveHostShell(input.message.command);
   const outputCoalescer = (0, import_pty_output_coalescer.createPtyOutputCoalescer)({
     send: (data) => {
@@ -3288,7 +3254,7 @@ async function openPty(input) {
           githubProcessEnv(),
           resolvePtyEnvFileReferences(input.message.env ?? {}, stagedEnvFiles),
           planProcessEnv,
-          targetProcessEnv,
+          targetEnv,
           shell.env ?? {}
         ])
       },
@@ -3461,12 +3427,13 @@ async function startWorker(options) {
   initializeCredentialStoreDirectoryOnce();
   const label = requireValue(options.label, "Missing required --label <label>");
   validateLabel(label);
-  const projectsRoot = import_node_path.default.resolve(options.projectRoot ?? defaultProjectsRoot());
-  const syncRoot = import_node_path.default.resolve(options.syncRoot ?? process.env.R5D_SYNC_ROOT ?? defaultSyncRoot());
+  const rootDir = import_node_path.default.resolve(options.rootDir ?? process.env.R5D_ROOT ?? defaultRootDir());
+  const projectsRoot = import_node_path.default.join(rootDir, "projects");
+  const syncRoot = import_node_path.default.join(rootDir, "sync");
   const workspaceShadowRoot = import_node_path.default.join(syncRoot, "workspace");
   const projectWorktreeSnapshotsRoot = import_node_path.default.join(syncRoot, "project-worktree-snapshots");
-  const artifactRoot = import_node_path.default.resolve(options.artifactRoot ?? process.env.R5D_ARTIFACTS_ROOT ?? defaultArtifactRoot());
-  const planRoot = import_node_path.default.resolve(options.planRoot ?? process.env.R5D_PLANS_ROOT ?? defaultPlanRoot());
+  const artifactRoot = import_node_path.default.join(rootDir, "artifacts");
+  const planRoot = import_node_path.default.join(rootDir, "plans");
   (0, import_managed_paths.assertDisjointManagedRoots)([
     { label: "projects root", rootPath: projectsRoot },
     { label: "sync root", rootPath: syncRoot },
@@ -3475,13 +3442,7 @@ async function startWorker(options) {
   ]);
   process.stdout.write(`[r5d-worker] label: ${label}
 `);
-  process.stdout.write(`[r5d-worker] projects root: ${projectsRoot}
-`);
-  process.stdout.write(`[r5d-worker] sync root: ${syncRoot}
-`);
-  process.stdout.write(`[r5d-worker] artifact root: ${artifactRoot}
-`);
-  process.stdout.write(`[r5d-worker] plan root: ${planRoot}
+  process.stdout.write(`[r5d-worker] root: ${rootDir}
 `);
   process.stdout.write(`[r5d-worker] server: ${baseUrl}
 `);
@@ -3506,9 +3467,29 @@ async function startWorker(options) {
   const reconciledProjectConfigFingerprints = /* @__PURE__ */ new Map();
   const lastObservedProjectHeads = /* @__PURE__ */ new Map();
   const advertisedProjectMirrorRefsTokens = /* @__PURE__ */ new Map();
+  const advertisedProjectMirrorMountTokens = /* @__PURE__ */ new Map();
+  let advertisedWorkspaceHead;
   const fetchedProjectMirrorRefsTokens = /* @__PURE__ */ new Map();
-  const lastProjectMirrorFetchAtMs = /* @__PURE__ */ new Map();
+  const fetchedProjectMirrorMountTokens = /* @__PURE__ */ new Map();
   const projectMirrorFetchSkippingEnabled = process.env.R5D_PROJECT_MIRROR_FETCH_SKIP !== "0";
+  const forgetLocalProjectMirrorRefsTokens = (projectId, branchName) => {
+    fetchedProjectMirrorRefsTokens.delete(projectId);
+    if (branchName === void 0) fetchedProjectMirrorMountTokens.delete(projectId);
+    else fetchedProjectMirrorMountTokens.get(projectId)?.delete(branchName);
+  };
+  const recordLocalProjectMirrorRefsTokens = async (project) => {
+    try {
+      const tokens = await (0, import_project_worktrees.computeLocalProjectMirrorRefsTokens)({
+        projectRoot: configuredProjectRoot(projectsRoot, project),
+        primaryBranchName: primaryProjectBranch(project),
+        mounts: project.branches.map(({ branchId, branchName }) => ({ branchId, branchName }))
+      });
+      fetchedProjectMirrorRefsTokens.set(project.projectId, tokens.project);
+      fetchedProjectMirrorMountTokens.set(project.projectId, tokens.mounts);
+    } catch {
+      forgetLocalProjectMirrorRefsTokens(project.projectId);
+    }
+  };
   const pendingMirrorDeletes = /* @__PURE__ */ new Map();
   let workspaceRemoteUrl = null;
   let workspaceCredentialHelper = null;
@@ -3523,10 +3504,12 @@ async function startWorker(options) {
   let workspacePeriodicTimer;
   let pendingAutomaticTrigger;
   const pendingCreatedBranchPublicationNotBefore = /* @__PURE__ */ new Map();
+  const workspaceProjectionLedger = new import_workspace_projection_ledger.WorkspaceProjectionLedger();
   let automaticSyncInFlight = false;
   let terminalReplayTimer;
   let workspaceSyncRequestsInFlight = 0;
   let lastWorkspaceSyncMirrorObservationMs = 0;
+  let lastInventoriedMissingCheckouts;
   let sessionArtifactSyncRequestsInFlight = 0;
   let cliUpdateInProgress = false;
   let reloadAfterClose = false;
@@ -3584,8 +3567,15 @@ async function startWorker(options) {
     const primaryBranchName = primaryProjectBranch(project);
     const connection = projectConnection(project);
     const sourcePath = configuredProjectBranchPath(projectsRoot, project, branchName);
-    if (requireLocalBranch || hasProjectWorktree(sourcePath)) {
-      (0, import_project_worktrees.deleteLinkedProjectBranch)({ projectRoot, primaryBranchName, branchName });
+    const primaryPath = configuredProjectBranchPath(projectsRoot, project, primaryBranchName);
+    if (requireLocalBranch || import_node_fs.default.existsSync(sourcePath) && hasProjectWorktree(primaryPath)) {
+      const deleted = (0, import_project_worktrees.deleteLinkedProjectBranch)({ projectRoot, primaryBranchName, branchName });
+      if (deleted.movedAsidePath) {
+        process.stderr.write(
+          `[r5d-worker] set aside ${sourcePath}, which was not a linked worktree of ${project.projectPath}, at ${deleted.movedAsidePath}
+`
+        );
+      }
     }
     const planSourcePath = import_node_path.default.join(planRoot, project.projectId, ...branchName.split("/"));
     import_node_fs.default.rmSync(planSourcePath, { recursive: true, force: true });
@@ -3658,11 +3648,17 @@ async function startWorker(options) {
     if (branchName === primaryBranchName) {
       throw new Error(`Cannot hide preserve-only project branch ${project.projectId}/${branchName} because it is the active anchor`);
     }
-    (0, import_project_worktrees.deleteLinkedProjectBranch)({
+    const deleted = (0, import_project_worktrees.deleteLinkedProjectBranch)({
       projectRoot: configuredProjectRoot(projectsRoot, project),
       primaryBranchName,
       branchName
     });
+    if (deleted.movedAsidePath) {
+      process.stderr.write(
+        `[r5d-worker] set aside ${branchPath}, which was not a linked worktree of ${project.projectPath}, at ${deleted.movedAsidePath}
+`
+      );
+    }
     import_node_fs.default.rmSync(import_node_path.default.join(planRoot, project.projectId, ...branchName.split("/")), { recursive: true, force: true });
     readyProjectIds.delete(project.projectId);
     reconciledProjectConfigFingerprints.delete(project.projectId);
@@ -3831,6 +3827,40 @@ async function startWorker(options) {
     });
   };
   const projectBranchMountBusy = (projectId, branchName, branchPath) => !readyProjectIds.has(projectId) || projectBranchMountActivityBusy(projectId, branchName, branchPath);
+  const inventoryConfiguredProjectCheckouts = () => {
+    const inventory = { projects: [], missingCheckouts: [] };
+    for (const project of projectConfigById.values()) {
+      if (project.executionDisabled || !readyProjectIds.has(project.projectId) || project.branches.length === 0) {
+        inventory.projects.push(project);
+        continue;
+      }
+      const checkouts = (0, import_project_worktrees.inventoryProjectCheckouts)({
+        projectRoot: configuredProjectRoot(projectsRoot, project),
+        primaryBranchName: primaryProjectBranch(project),
+        branchNames: project.branches.map(({ branchName }) => branchName)
+      });
+      if (checkouts.missingCheckouts.length === 0) {
+        inventory.projects.push(project);
+        continue;
+      }
+      for (const missing of checkouts.missingCheckouts) inventory.missingCheckouts.push({ projectId: project.projectId, ...missing });
+      const linked = new Set(checkouts.linkedBranchNames);
+      inventory.projects.push({ ...project, branches: project.branches.filter(({ branchName }) => linked.has(branchName)) });
+    }
+    inventory.missingCheckouts.sort(
+      (left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName)
+    );
+    return inventory;
+  };
+  const reportedMissingCheckouts = (inventory) => inventory.missingCheckouts.map(({ projectId, branchName, reason }) => ({ projectId, branchName, reason }));
+  const logMissingCheckouts = (inventory) => {
+    if (inventory.missingCheckouts.length === 0) return;
+    const described = inventory.missingCheckouts.map(({ checkoutPath, reason }) => `${checkoutPath} (${reason === "missing" ? "directory missing" : "not a linked worktree of the project"})`).join(", ");
+    process.stderr.write(
+      `[r5d-worker] skipping ${inventory.missingCheckouts.length} configured project checkout(s) this cycle: ${described}; delete the branch through the platform or reconnect this worker to recreate the checkout
+`
+    );
+  };
   const buildWorkspaceMounts = (projects = projectConfigById.values()) => {
     const mounts = [];
     const creatorLocalIncarnations = new Map(
@@ -3892,7 +3922,7 @@ async function startWorker(options) {
       workspaceRelativePath: "workspace-plans",
       sourceMode: "all",
       hydrateDeletionMode: "all",
-      // Workspace-level agents receive this directory through R5D_PLANS_DIR.
+      // Workspace-level agents reach this directory through $R5D_ROOT/plans.
       // Keep both projection and hydration away from it while any visible-
       // projects process, PTY, or built-in write/edit is active or reserved.
       busy: () => {
@@ -3930,7 +3960,10 @@ async function startWorker(options) {
         deleteWhenSourceMissing: true
       });
     }
-    return mounts;
+    return mounts.map((mount) => {
+      const lastProjectedMutationToken = workspaceProjectionLedger.lastProjectedToken(mount);
+      return lastProjectedMutationToken === void 0 ? mount : { ...mount, lastProjectedMutationToken };
+    });
   };
   const workspaceLocalHead = async () => {
     if (!import_node_fs.default.existsSync(import_node_path.default.join(workspaceShadowRoot, ".git"))) return null;
@@ -4106,9 +4139,9 @@ async function startWorker(options) {
       (left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName)
     );
   };
-  const captureProjectHeadsForWorkspacePublication = async () => {
+  const captureProjectHeadsForWorkspacePublication = async (projects = projectConfigById.values()) => {
     const heads = /* @__PURE__ */ new Map();
-    for (const project of projectConfigById.values()) {
+    for (const project of projects) {
       if (!readyProjectIds.has(project.projectId)) continue;
       for (const branch of project.branches) {
         const branchPath = configuredProjectBranchPath(projectsRoot, project, branch.branchName);
@@ -4118,9 +4151,9 @@ async function startWorker(options) {
     }
     return heads;
   };
-  const pushChangedProjectHeads = async (activeMountIds, publishedHead, publicationHeads, expectedMirrorHeads, suppressedMountIds = /* @__PURE__ */ new Set()) => {
+  const pushChangedProjectHeads = async (activeMountIds, publishedHead, publicationHeads, expectedMirrorHeads, suppressedMountIds = /* @__PURE__ */ new Set(), projects = projectConfigById.values()) => {
     const active = new Set(activeMountIds);
-    for (const project of projectConfigById.values()) {
+    for (const project of projects) {
       if (!readyProjectIds.has(project.projectId) || !(0, import_repository_transition_policy.repositoryMirrorWritesAllowed)(project)) continue;
       const changed = /* @__PURE__ */ new Map();
       for (const branch of project.branches) {
@@ -4155,17 +4188,7 @@ async function startWorker(options) {
       for (const result of results) {
         lastObservedProjectHeads.set(projectBranchKey(project.projectId, result.branchName), result.head);
       }
-      try {
-        fetchedProjectMirrorRefsTokens.set(
-          project.projectId,
-          await (0, import_project_worktrees.computeLocalProjectMirrorRefsToken)({
-            projectRoot: configuredProjectRoot(projectsRoot, project),
-            primaryBranchName: primaryProjectBranch(project)
-          })
-        );
-      } catch {
-        fetchedProjectMirrorRefsTokens.delete(project.projectId);
-      }
+      await recordLocalProjectMirrorRefsTokens(project);
     }
     const publishedTombstoneIds = [
       ...new Set(
@@ -4191,7 +4214,7 @@ async function startWorker(options) {
           credentialHelper: deletion.credentialHelper,
           credentialUsername: deletion.credentialUsername
         });
-        fetchedProjectMirrorRefsTokens.delete(deletion.projectId);
+        forgetLocalProjectMirrorRefsTokens(deletion.projectId, deletion.branchName);
       }
       if (deletion.tombstoneId && !deletion.projectDeleted) {
         projectWorkspaceState = projectWorkspaceStateStore.recordMirrorRefDeletion({
@@ -4203,8 +4226,8 @@ async function startWorker(options) {
       if (deletion.projectDeleted && !projectConfigById.has(deletion.projectId) && ![...pendingMirrorDeletes.values()].some((pending) => pending.projectId === deletion.projectId)) {
         removeProjectCredentialStore(deletion.projectId);
         advertisedProjectMirrorRefsTokens.delete(deletion.projectId);
-        fetchedProjectMirrorRefsTokens.delete(deletion.projectId);
-        lastProjectMirrorFetchAtMs.delete(deletion.projectId);
+        advertisedProjectMirrorMountTokens.delete(deletion.projectId);
+        forgetLocalProjectMirrorRefsTokens(deletion.projectId);
       }
       lastObservedProjectHeads.delete(key);
     }
@@ -4213,71 +4236,63 @@ async function startWorker(options) {
     const connection = projectConnection(project);
     const projectRoot = configuredProjectRoot(projectsRoot, project);
     const primaryBranchName = primaryProjectBranch(project);
-    if (options2.refreshRemote) {
-      const advertisedBeforeFetch = advertisedProjectMirrorRefsTokens.get(project.projectId);
-      const observations = await (0, import_project_worktrees.observeProjectMirrorHeads)({
-        projectRoot,
-        primaryBranchName,
-        branchNames: project.branches.map(({ branchName }) => branchName),
-        mirrorUrl: connection.mirrorUrl,
-        credentialHelper: connection.credentialHelper,
-        credentialUsername: connection.mirrorCredentialUsername,
-        allowNonFastForward: options2.allowNonFastForward,
-        branchIds: new Map(project.branches.map(({ branchId, branchName }) => [branchName, branchId]))
-      });
-      if (advertisedBeforeFetch === void 0) fetchedProjectMirrorRefsTokens.delete(project.projectId);
-      else fetchedProjectMirrorRefsTokens.set(project.projectId, advertisedBeforeFetch);
-      lastProjectMirrorFetchAtMs.set(project.projectId, Date.now());
-      return { projectId: project.projectId, projectRoot, primaryBranchName, observations };
-    }
-    return {
-      projectId: project.projectId,
+    const observations = await (0, import_project_worktrees.observeProjectMirrorHeads)({
       projectRoot,
       primaryBranchName,
-      observations: await (0, import_project_worktrees.observeProjectMirrorHeads)({
-        projectRoot,
-        primaryBranchName,
-        branchNames: project.branches.map(({ branchName }) => branchName),
-        mirrorUrl: connection.mirrorUrl,
-        credentialHelper: connection.credentialHelper,
-        credentialUsername: connection.mirrorCredentialUsername,
-        allowNonFastForward: options2.allowNonFastForward,
-        branchIds: new Map(project.branches.map(({ branchId, branchName }) => [branchName, branchId])),
-        refreshRemote: false
-      })
-    };
+      branchNames: project.branches.map(({ branchName }) => branchName),
+      mirrorUrl: connection.mirrorUrl,
+      credentialHelper: connection.credentialHelper,
+      credentialUsername: connection.mirrorCredentialUsername,
+      allowNonFastForward: options2.allowNonFastForward,
+      branchIds: new Map(project.branches.map(({ branchId, branchName }) => [branchName, branchId])),
+      refreshRemote: options2.fetch.scope !== "none",
+      ...options2.fetch.scope === "mounts" ? { fetchOnlyBranches: new Set(options2.fetch.mounts.map(({ branchName }) => branchName)) } : {}
+    });
+    if (options2.fetch.scope !== "none") await recordLocalProjectMirrorRefsTokens(project);
+    return { projectId: project.projectId, projectRoot, primaryBranchName, observations };
   };
   const observeProjectHeadsBeforeOuterWorkspace = async (input) => {
     const observationStartedAt = Date.now();
-    const eligibleProjects = [...projectConfigById.values()].filter(
+    const eligibleProjects = [...input.projects ?? projectConfigById.values()].filter(
       (project) => !project.executionDisabled && readyProjectIds.has(project.projectId) && project.branches.length > 0
     );
     try {
       if (input.failClosed) {
         const bundles2 = [];
         for (const project of eligibleProjects) {
-          bundles2.push(await observeSingleProjectMirrorBundle(project, { allowNonFastForward: input.allowNonFastForward, refreshRemote: true }));
+          bundles2.push(
+            await observeSingleProjectMirrorBundle(project, {
+              allowNonFastForward: input.allowNonFastForward,
+              fetch: { scope: "project", reason: "fail_closed" }
+            })
+          );
         }
         return bundles2;
       }
-      let fetchedCount = 0;
+      let wholeMirrorFetches = 0;
+      let scopedMirrorFetches = 0;
+      let fetchedMounts = 0;
+      let eligibleMounts = 0;
       const bundles = await mapWithConcurrencyLimit(
         eligibleProjects,
         PROJECT_MIRROR_OBSERVE_CONCURRENCY,
         async (project) => {
           try {
-            const decision = (0, import_project_mirror_fetch_policy.projectMirrorFetchDecision)({
-              advertisedToken: advertisedProjectMirrorRefsTokens.get(project.projectId),
-              fetchedToken: fetchedProjectMirrorRefsTokens.get(project.projectId),
-              lastFetchAtMs: lastProjectMirrorFetchAtMs.get(project.projectId),
-              nowMs: Date.now(),
+            const fetch2 = (0, import_project_mirror_fetch_policy.planProjectMirrorObservationFetch)({
+              branchNames: project.branches.map(({ branchName }) => branchName),
+              advertisedProjectToken: advertisedProjectMirrorRefsTokens.get(project.projectId),
+              advertisedMountTokens: advertisedProjectMirrorMountTokens.get(project.projectId),
+              fetchedProjectToken: fetchedProjectMirrorRefsTokens.get(project.projectId),
+              fetchedMountTokens: fetchedProjectMirrorMountTokens.get(project.projectId) ?? /* @__PURE__ */ new Map(),
               skippingEnabled: projectMirrorFetchSkippingEnabled
             });
-            if (decision.fetch) fetchedCount += 1;
-            return await observeSingleProjectMirrorBundle(project, {
-              allowNonFastForward: input.allowNonFastForward,
-              refreshRemote: decision.fetch
-            });
+            eligibleMounts += project.branches.length;
+            if (fetch2.scope === "project") wholeMirrorFetches += 1;
+            if (fetch2.scope === "mounts") {
+              scopedMirrorFetches += 1;
+              fetchedMounts += fetch2.mounts.length;
+            }
+            return await observeSingleProjectMirrorBundle(project, { allowNonFastForward: input.allowNonFastForward, fetch: fetch2 });
           } catch (error) {
             process.stderr.write(
               `[r5d-worker] failed to observe project mirror heads before workspace update: ${error instanceof Error ? error.message : String(error)}
@@ -4287,9 +4302,9 @@ async function startWorker(options) {
           }
         }
       );
-      if (fetchedCount > 0) {
+      if (wholeMirrorFetches + scopedMirrorFetches > 0) {
         process.stderr.write(
-          `[r5d-worker] project mirror observation fetched ${fetchedCount} of ${eligibleProjects.length} mirror(s)
+          `[r5d-worker] project mirror observation fetched ${wholeMirrorFetches + scopedMirrorFetches} of ${eligibleProjects.length} mirror(s) (${wholeMirrorFetches} whole, ${scopedMirrorFetches} scoped to ${fetchedMounts} of ${eligibleMounts} mount(s))
 `
         );
       }
@@ -4348,7 +4363,7 @@ async function startWorker(options) {
       }
     }
   };
-  const mapWorkspaceGitResult = async (attemptId, trigger, result) => {
+  const mapWorkspaceGitResult = async (attemptId, trigger, result, missingCheckouts) => {
     const activeProjectBranchPublications = (0, import_workspace_publication_evidence.activeProjectBranchPublicationEvidence)([...projectConfigById.values()], result.activeMountIds);
     return {
       type: "workspace_sync",
@@ -4366,6 +4381,7 @@ async function startWorker(options) {
       affectedPaths: result.affectedPaths,
       activeMountIds: result.activeMountIds,
       skippedMountIds: result.skippedMountIds,
+      ...missingCheckouts ? { missingCheckouts } : {},
       activeProjectBranchPublications,
       discardedPaths: [],
       localChangesDiscarded: false,
@@ -4393,6 +4409,7 @@ async function startWorker(options) {
       affectedPaths: [],
       discardedPaths: [],
       localChangesDiscarded: false,
+      ...lastInventoriedMissingCheckouts ? { missingCheckouts: lastInventoriedMissingCheckouts } : {},
       error: error instanceof Error ? error.message : String(error)
     };
   };
@@ -4401,8 +4418,13 @@ async function startWorker(options) {
     if (!workspaceRemoteUrl || !workspaceCredentialHelper || !workspaceCredentialUsername || !workspaceGitIdentity) {
       throw new Error("Worker workspace configuration has not been received");
     }
-    const configuredMounts = buildWorkspaceMounts();
+    const checkoutInventory = inventoryConfiguredProjectCheckouts();
+    logMissingCheckouts(checkoutInventory);
+    const missingCheckouts = reportedMissingCheckouts(checkoutInventory);
+    lastInventoriedMissingCheckouts = missingCheckouts;
+    const configuredMounts = buildWorkspaceMounts(checkoutInventory.projects);
     if (input.resetToCanonical) {
+      workspaceProjectionLedger.reset();
       const resetHasBusyLiveMount = configuredMounts.some(
         (mount) => !(mount.deleteWhenSourceMissing && !import_node_fs.default.existsSync(mount.sourcePath)) && mount.busy?.()
       );
@@ -4411,7 +4433,8 @@ async function startWorker(options) {
       }
       const observedProjectHeads2 = await observeProjectHeadsBeforeOuterWorkspace({
         allowNonFastForward: true,
-        failClosed: true
+        failClosed: true,
+        projects: checkoutInventory.projects
       });
       const reset = await (0, import_workspace_git_sync.resetWorkspaceGit)({
         workspacePath: workspaceShadowRoot,
@@ -4439,13 +4462,15 @@ async function startWorker(options) {
         affectedPaths: reset.discardedPaths,
         activeMountIds: reset.activeMountIds,
         skippedMountIds: reset.skippedMountIds,
+        missingCheckouts,
         discardedPaths: reset.discardedPaths,
         localChangesDiscarded: reset.discardedPaths.length > 0 || reset.startingHead !== reset.remoteHead
       };
     }
     const outerRemediation = input.trigger.type === "remediation" || input.trigger.type === "remediation_confirm";
     const mounts = outerRemediation ? (0, import_workspace_git_sync.workspaceGitMountsForRemediation)(configuredMounts) : configuredMounts;
-    const observedProjectHeads = outerRemediation ? [] : await observeProjectHeadsBeforeOuterWorkspace({ allowNonFastForward: false, failClosed: false });
+    if (outerRemediation) workspaceProjectionLedger.reset();
+    const observedProjectHeads = outerRemediation ? [] : await observeProjectHeadsBeforeOuterWorkspace({ allowNonFastForward: false, failClosed: false, projects: checkoutInventory.projects });
     const expectedMirrorHeads = /* @__PURE__ */ new Map();
     for (const bundle of observedProjectHeads) {
       for (const observation of bundle.observations) {
@@ -4457,7 +4482,7 @@ async function startWorker(options) {
         ({ projectId, observations }) => observations.filter(({ shouldMove }) => shouldMove).map(({ branchName }) => projectMountId(projectId, branchName))
       )
     );
-    const publicationHeads = outerRemediation ? /* @__PURE__ */ new Map() : await captureProjectHeadsForWorkspacePublication();
+    const publicationHeads = outerRemediation ? /* @__PURE__ */ new Map() : await captureProjectHeadsForWorkspacePublication(checkoutInventory.projects);
     const result = await (0, import_workspace_git_sync.synchronizeWorkspaceGit)({
       attemptId: input.attemptId,
       workerLabel: label,
@@ -4471,9 +4496,20 @@ async function startWorker(options) {
       allowLargeDiff: input.confirmedLargeDiff,
       skipMountMirror: outerRemediation,
       requiredAncestorHeads: input.requiredAncestorHeads,
+      // Same gate as the mirror fetches: while the server's read of the hidden
+      // workspace head equals the head this clone last fetched or pushed, the
+      // cycle's workspace head fetches would transfer nothing.
+      advertisedRemoteHead: projectMirrorFetchSkippingEnabled && !outerRemediation ? advertisedWorkspaceHead : void 0,
       assertStillAdmitted: input.assertStillAdmitted,
       afterWorkspacePublished: outerRemediation ? void 0 : async ({ activeMountIds, publishedHead }) => {
-        await pushChangedProjectHeads(activeMountIds, publishedHead, publicationHeads, expectedMirrorHeads, inboundMoveMountIds);
+        await pushChangedProjectHeads(
+          activeMountIds,
+          publishedHead,
+          publicationHeads,
+          expectedMirrorHeads,
+          inboundMoveMountIds,
+          checkoutInventory.projects
+        );
       },
       hydrationHooks: workspaceHydrationTransactionHooks
     });
@@ -4492,7 +4528,11 @@ async function startWorker(options) {
         result.localHead ?? result.remoteHead
       );
     }
-    return mapWorkspaceGitResult(input.attemptId, input.trigger, result);
+    const mapped = await mapWorkspaceGitResult(input.attemptId, input.trigger, result, missingCheckouts);
+    if (!outerRemediation) {
+      workspaceProjectionLedger.recordCycle({ result: mapped, mounts, projectedMutationTokens: result.projectedMutationTokens });
+    }
+    return mapped;
   };
   const sendWorkspaceSyncResult = (requestId, result) => {
     try {
@@ -4530,17 +4570,143 @@ async function startWorker(options) {
     }, unsafeWorkspaceSyncRecoveryBounceDelayMs(attempt));
     timer.unref();
   };
+  const captureWorkspaceSyncAdmission = () => ({
+    generation: workerAdmissionGeneration,
+    activeIncidentId: activeWorkspaceIncidentId,
+    deferredIncidentId: deferredWorkspaceConfiguration?.incidentId ?? null
+  });
+  const workspaceSyncAdmissionSnapshotsMatch = (left, right) => left.generation === right.generation && left.activeIncidentId === right.activeIncidentId && left.deferredIncidentId === right.deferredIncidentId;
+  const assertWorkspaceSyncStillAdmitted = (admitted, trigger) => {
+    if (!workspaceSyncAdmissionSnapshotsMatch(admitted, captureWorkspaceSyncAdmission()) || currentWorkerSocket !== ws || ws.readyState !== WebSocket.OPEN || !deferredWorkspaceSyncTriggerIsAllowed(deferredWorkspaceConfiguration, activeWorkspaceIncidentId, trigger)) {
+      throw new WorkspaceSyncAdmissionChangedError("Workspace synchronization admission changed while asynchronous work was in flight");
+    }
+  };
+  const executeWorkspaceSyncCycle = async (input) => {
+    const attemptId = input.attemptId;
+    lastWorkspaceSyncMirrorObservationMs = 0;
+    if (!deferredWorkspaceSyncTriggerIsAllowed(deferredWorkspaceConfiguration, activeWorkspaceIncidentId, input.trigger)) {
+      return await failedWorkspaceSyncResult(
+        attemptId,
+        input.trigger,
+        new Error(
+          `Workspace synchronization was fenced while queued by incident ${deferredWorkspaceConfiguration?.incidentId ?? activeWorkspaceIncidentId ?? "unknown"}`
+        )
+      );
+    }
+    try {
+      input.assertStillAdmitted();
+      const hasDurableBranchDeletion = projectWorkspaceState.tombstones.some((tombstone) => tombstone.kind === "branch");
+      return await performWorkspaceSync({
+        attemptId,
+        trigger: input.trigger,
+        confirmedLargeDiff: input.confirmedLargeDiff === true || hasDurableBranchDeletion,
+        confirmationReason: input.confirmationReason ?? (hasDurableBranchDeletion ? "durable project branch deletion" : void 0),
+        resetToCanonical: input.resetToCanonical,
+        requiredAncestorHeads: input.requiredAncestorHeads,
+        assertStillAdmitted: input.assertStillAdmitted
+      });
+    } catch (error) {
+      workspaceProjectionLedger.reset();
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const hydrationRecoverable = workspaceSyncFailureHydrationIsSafe({
+        error,
+        resetToCanonical: input.resetToCanonical === true,
+        inspectRecoverableHydration: () => (0, import_workspace_git_sync.workspaceGitHydrationIsRecoverable)(workspaceShadowRoot, buildWorkspaceMounts())
+      });
+      if (hydrationRecoverable) {
+        if (error instanceof WorkspaceSyncAdmissionChangedError) {
+          process.stderr.write(
+            `[r5d-worker] workspace synchronization was cancelled with every mount at a recorded basis; the next cycle converges it: ${errorMessage}
+`
+          );
+        }
+        return await failedWorkspaceSyncResult(attemptId, input.trigger, error);
+      }
+      const fenced = fenceUnsafeWorkspaceSyncFailure({
+        hydrationRecoverable,
+        resetToCanonical: input.resetToCanonical === true,
+        recoveryAttempts: unsafeWorkspaceSyncRecoveryAttempts,
+        maxRecoveryAttempts: WORKSPACE_UNSAFE_SYNC_MAX_RECOVERY_ATTEMPTS,
+        hasRetainableWork: activeProcesses.size > 0 || credentialBearingProcessGroups.size > 0 || activePtys.size > 0 || pendingProcessTerminals.size > 0,
+        bouncePending: unsafeWorkspaceSyncBouncePending,
+        invalidateExecution: () => {
+          workspaceConfigured = false;
+          advanceWorkerAdmissionGeneration();
+        },
+        scheduleRecoveryBounce: () => {
+          unsafeWorkspaceSyncRecoveryAttempts += 1;
+          scheduleUnsafeWorkspaceSyncRecoveryBounce(errorMessage);
+        },
+        fatalExit: (exitCode) => {
+          process.stderr.write(
+            `[r5d-worker] workspace synchronization failed without a recoverable hydration basis; exiting for exact recovery after ${unsafeWorkspaceSyncRecoveryAttempts} in-process recovery attempt(s): ${errorMessage}
+`
+          );
+          process.exit(exitCode);
+        },
+        exitCode: 1
+      });
+      if (fenced === "recovery_pending") {
+        process.stderr.write(
+          `[r5d-worker] workspace synchronization failed without a recoverable hydration basis while in-process recovery is already pending: ${errorMessage}
+`
+        );
+      }
+      return {
+        ...await failedWorkspaceSyncResult(attemptId, input.trigger, error),
+        failureReason: "unsafe_hydration",
+        recoveryAttempt: unsafeWorkspaceSyncRecoveryAttempts
+      };
+    }
+  };
+  const REMEDIATION_TRIGGER_TYPES = /* @__PURE__ */ new Set(["remediation", "remediation_confirm", "remediation_reset"]);
+  const isOrdinaryWorkspaceSyncRequest = (input) => input.confirmedLargeDiff !== true && input.resetToCanonical !== true && !(input.requiredAncestorHeads && input.requiredAncestorHeads.length > 0) && !REMEDIATION_TRIGGER_TYPES.has(input.trigger.type);
+  const LOCAL_ACTIVITY_TRIGGER_TYPES = /* @__PURE__ */ new Set([
+    "write",
+    "edit",
+    "shell_inline",
+    "process_terminal",
+    "process_cancel"
+  ]);
+  const answerOrdinaryWorkspaceSyncFromLastCycle = (requests) => {
+    if (!workspaceConfigured) return null;
+    return workspaceProjectionLedger.answerFromLastCycle({
+      // A workspace-rooted command carries no project target because it may
+      // have touched any checkout.
+      targetMountIds: requests.map(
+        ({ trigger }) => LOCAL_ACTIVITY_TRIGGER_TYPES.has(trigger.type) && trigger.projectId && trigger.branchName ? projectMountId(trigger.projectId, trigger.branchName) : null
+      ),
+      mounts: buildWorkspaceMounts(),
+      pendingDeletions: pendingMirrorDeletes.size > 0 || projectWorkspaceState.pendingTreeDeletions.length > 0 || projectWorkspaceState.pendingMirrorRefDeletions.length > 0
+    });
+  };
+  const ordinaryWorkspaceSyncCoalescer = new import_workspace_sync_coalescer.WorkspaceSyncCoalescer({
+    runExclusive: (operation) => workspaceSyncSingleFlight.runExclusive(operation),
+    runBatch: async (requests) => {
+      const startedAtMs = Date.now();
+      const admission = captureWorkspaceSyncAdmission();
+      const staleAttemptIds = /* @__PURE__ */ new Set();
+      const admitted = [];
+      for (const request of requests) {
+        if (workspaceSyncAdmissionSnapshotsMatch(request.admission, admission)) admitted.push(request);
+        else staleAttemptIds.add(request.attemptId);
+      }
+      const leader = admitted[0];
+      if (!leader) return { result: null, ranCycle: false, startedAtMs, finishedAtMs: Date.now(), prepareMs: 0, staleAttemptIds };
+      const answered = answerOrdinaryWorkspaceSyncFromLastCycle(admitted);
+      if (answered) return { result: answered, ranCycle: false, startedAtMs, finishedAtMs: Date.now(), prepareMs: 0, staleAttemptIds };
+      const result = await executeWorkspaceSyncCycle({
+        attemptId: leader.attemptId,
+        trigger: leader.trigger,
+        assertStillAdmitted: () => assertWorkspaceSyncStillAdmitted(admission, leader.trigger)
+      });
+      return { result, ranCycle: true, startedAtMs, finishedAtMs: Date.now(), prepareMs: lastWorkspaceSyncMirrorObservationMs, staleAttemptIds };
+    }
+  });
   const runWorkspaceSync = async (input) => {
     const attemptId = input.attemptId ?? crypto.randomUUID();
     const requestedAt = Date.now();
-    const admittedGeneration = workerAdmissionGeneration;
-    const admittedActiveIncidentId = activeWorkspaceIncidentId;
-    const admittedDeferredIncidentId = deferredWorkspaceConfiguration?.incidentId ?? null;
-    const assertStillAdmitted = () => {
-      if (admittedGeneration !== workerAdmissionGeneration || admittedActiveIncidentId !== activeWorkspaceIncidentId || admittedDeferredIncidentId !== (deferredWorkspaceConfiguration?.incidentId ?? null) || currentWorkerSocket !== ws || ws.readyState !== WebSocket.OPEN || !deferredWorkspaceSyncTriggerIsAllowed(deferredWorkspaceConfiguration, activeWorkspaceIncidentId, input.trigger)) {
-        throw new WorkspaceSyncAdmissionChangedError("Workspace synchronization admission changed while asynchronous work was in flight");
-      }
-    };
+    const admission = captureWorkspaceSyncAdmission();
     if (!deferredWorkspaceSyncTriggerIsAllowed(deferredWorkspaceConfiguration, activeWorkspaceIncidentId, input.trigger)) {
       const result2 = {
         ...await failedWorkspaceSyncResult(
@@ -4566,104 +4732,47 @@ async function startWorker(options) {
       }
       ws.send(JSON.stringify({ type: "workspace_sync_started", attemptId }));
     }
-    let queueEnteredAt = requestedAt;
-    let syncStartedAt = requestedAt;
+    let queueMs = 0;
+    let prepareMs = 0;
+    let synchronizeMs = 0;
     workspaceSyncRequestsInFlight += 1;
     let result;
     try {
-      result = await workspaceSyncSingleFlight.runExclusive(async () => {
-        queueEnteredAt = Date.now();
-        syncStartedAt = Date.now();
-        lastWorkspaceSyncMirrorObservationMs = 0;
-        if (!deferredWorkspaceSyncTriggerIsAllowed(deferredWorkspaceConfiguration, activeWorkspaceIncidentId, input.trigger)) {
-          return await failedWorkspaceSyncResult(
-            attemptId,
-            input.trigger,
-            new Error(
-              `Workspace synchronization was fenced while queued by incident ${deferredWorkspaceConfiguration?.incidentId ?? activeWorkspaceIncidentId ?? "unknown"}`
-            )
-          );
-        }
-        try {
-          assertStillAdmitted();
-          const hasDurableBranchDeletion = projectWorkspaceState.tombstones.some((tombstone) => tombstone.kind === "branch");
-          return await performWorkspaceSync({
+      if (isOrdinaryWorkspaceSyncRequest(input)) {
+        const settlement = await ordinaryWorkspaceSyncCoalescer.request({ attemptId, trigger: input.trigger, admission });
+        queueMs = settlement.startedAtMs - requestedAt;
+        prepareMs = settlement.prepareMs;
+        synchronizeMs = settlement.finishedAtMs - settlement.startedAtMs;
+        result = settlement.staleAttemptIds.has(attemptId) || settlement.result === null ? await failedWorkspaceSyncResult(
+          attemptId,
+          input.trigger,
+          new Error("Workspace synchronization admission changed while the request was queued")
+        ) : { ...settlement.result, attemptId, trigger: input.trigger };
+      } else {
+        result = await workspaceSyncSingleFlight.runExclusive(async () => {
+          const startedAt = Date.now();
+          queueMs = startedAt - requestedAt;
+          const cycleResult = await executeWorkspaceSyncCycle({
             attemptId,
             trigger: input.trigger,
-            confirmedLargeDiff: input.confirmedLargeDiff === true || hasDurableBranchDeletion,
-            confirmationReason: input.confirmationReason ?? (hasDurableBranchDeletion ? "durable project branch deletion" : void 0),
+            confirmedLargeDiff: input.confirmedLargeDiff,
+            confirmationReason: input.confirmationReason,
             resetToCanonical: input.resetToCanonical,
             requiredAncestorHeads: input.requiredAncestorHeads,
-            assertStillAdmitted
+            assertStillAdmitted: () => assertWorkspaceSyncStillAdmitted(admission, input.trigger)
           });
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          const hydrationRecoverable = workspaceSyncFailureHydrationIsSafe({
-            error,
-            resetToCanonical: input.resetToCanonical === true,
-            inspectRecoverableHydration: () => (0, import_workspace_git_sync.workspaceGitHydrationIsRecoverable)(workspaceShadowRoot, buildWorkspaceMounts())
-          });
-          if (hydrationRecoverable) {
-            if (error instanceof WorkspaceSyncAdmissionChangedError) {
-              process.stderr.write(
-                `[r5d-worker] workspace synchronization was cancelled with every mount at a recorded basis; the next cycle converges it: ${errorMessage}
-`
-              );
-            }
-            return await failedWorkspaceSyncResult(attemptId, input.trigger, error);
-          }
-          const fenced = fenceUnsafeWorkspaceSyncFailure({
-            hydrationRecoverable,
-            resetToCanonical: input.resetToCanonical === true,
-            recoveryAttempts: unsafeWorkspaceSyncRecoveryAttempts,
-            maxRecoveryAttempts: WORKSPACE_UNSAFE_SYNC_MAX_RECOVERY_ATTEMPTS,
-            hasRetainableWork: activeProcesses.size > 0 || credentialBearingProcessGroups.size > 0 || activePtys.size > 0 || pendingProcessTerminals.size > 0,
-            bouncePending: unsafeWorkspaceSyncBouncePending,
-            invalidateExecution: () => {
-              workspaceConfigured = false;
-              advanceWorkerAdmissionGeneration();
-            },
-            scheduleRecoveryBounce: () => {
-              unsafeWorkspaceSyncRecoveryAttempts += 1;
-              scheduleUnsafeWorkspaceSyncRecoveryBounce(errorMessage);
-            },
-            fatalExit: (exitCode) => {
-              process.stderr.write(
-                `[r5d-worker] workspace synchronization failed without a recoverable hydration basis; exiting for exact recovery after ${unsafeWorkspaceSyncRecoveryAttempts} in-process recovery attempt(s): ${errorMessage}
-`
-              );
-              process.exit(exitCode);
-            },
-            exitCode: 1
-          });
-          if (fenced === "recovery_pending") {
-            process.stderr.write(
-              `[r5d-worker] workspace synchronization failed without a recoverable hydration basis while in-process recovery is already pending: ${errorMessage}
-`
-            );
-          }
-          return {
-            ...await failedWorkspaceSyncResult(attemptId, input.trigger, error),
-            failureReason: "unsafe_hydration",
-            recoveryAttempt: unsafeWorkspaceSyncRecoveryAttempts
-          };
-        }
-      });
+          prepareMs = lastWorkspaceSyncMirrorObservationMs;
+          synchronizeMs = Date.now() - startedAt;
+          return cycleResult;
+        });
+      }
     } finally {
       workspaceSyncRequestsInFlight -= 1;
     }
     if (result.outcome !== "failed") unsafeWorkspaceSyncRecoveryAttempts = 0;
-    const finishedAt = Date.now();
     result = {
       ...result,
-      telemetry: {
-        totalMs: finishedAt - requestedAt,
-        queueMs: queueEnteredAt - requestedAt,
-        // Duration of the pre-outer mirror-head observation phase; near zero
-        // on a cycle whose token-gated observation skipped every fetch.
-        prepareMs: lastWorkspaceSyncMirrorObservationMs,
-        synchronizeMs: finishedAt - syncStartedAt
-      }
+      telemetry: { totalMs: Date.now() - requestedAt, queueMs, prepareMs, synchronizeMs }
     };
     if (input.sendResult !== false) sendWorkspaceSyncResult(input.requestId, result);
     sendLifecycleProgress(
@@ -4933,6 +5042,7 @@ async function startWorker(options) {
           );
         }
         workspaceConfigured = false;
+        workspaceProjectionLedger.reset();
         const preserveOnlyBranches = message.projects.flatMap(
           (project) => project.preserveOnlyBranches.map(({ branchId, branchName }) => ({ branchId, projectId: project.projectId, branchName }))
         );
@@ -4942,6 +5052,16 @@ async function startWorker(options) {
             preserveOnlyBranches
           });
         }
+        for (const project of message.projects) {
+          for (const branch of project.branches) {
+            const pending2 = projectWorkspaceState.locallyPendingCreatedBranches.find(
+              (candidate) => candidate.projectId === project.projectId && candidate.branchName === branch.branchName
+            );
+            if (pending2 && pending2.branchId === branch.branchId) {
+              projectWorkspaceState = projectWorkspaceStateStore.clearPendingCreatedBranch(pending2);
+            }
+          }
+        }
         const stillPendingCreatedBranches = new Map(
           projectWorkspaceState.locallyPendingCreatedBranches.map((branch) => [
             (0, import_workspace_automatic_sync_policy.pendingCreatedBranchKey)(branch.projectId, branch.branchName),
@@ -5383,11 +5503,10 @@ async function startWorker(options) {
           workspaceConfigResetToCanonicalV1: true,
           projectBranchDeletionFastAckV1: true,
           projectMirrorLeaseV1: true,
-          projectMirrorRefsTokensV1: true
+          projectMirrorRefsTokensV1: true,
+          projectBranchWorkingTreeModeV1: true
         },
-        projectRoot: projectsRoot,
-        artifactRoot,
-        planRoot
+        root: rootDir
       }
     };
     ws.send(JSON.stringify(hello));
@@ -5422,14 +5541,12 @@ async function startWorker(options) {
         return;
       }
       if (message.type === "project_mirror_refs_tokens") {
+        const advertised = (0, import_project_mirror_fetch_policy.parseProjectMirrorRefsTokensMessage)(message);
         advertisedProjectMirrorRefsTokens.clear();
-        if (message.tokens && typeof message.tokens === "object") {
-          for (const [projectId, token2] of Object.entries(message.tokens)) {
-            if (typeof token2 === "string" && /^[0-9a-f]{64}$/.test(token2)) {
-              advertisedProjectMirrorRefsTokens.set(projectId, token2);
-            }
-          }
-        }
+        for (const [projectId, token2] of advertised.projectTokens) advertisedProjectMirrorRefsTokens.set(projectId, token2);
+        advertisedProjectMirrorMountTokens.clear();
+        for (const [projectId, tokens] of advertised.mountTokens) advertisedProjectMirrorMountTokens.set(projectId, tokens);
+        advertisedWorkspaceHead = advertised.workspaceHead;
         return;
       }
       if (message.type === "workspace_config") {
@@ -5502,13 +5619,21 @@ async function startWorker(options) {
           });
           return;
         }
+        sendWorkerMessage(ws, {
+          type: "operation_queued",
+          requestId: message.requestId,
+          queuePosition: workspaceSyncSingleFlight.branchMutationQueuePosition()
+        });
         try {
+          if (message.workingTree !== "carry" && message.workingTree !== "clean") {
+            throw new Error('Project branch creation requires workingTree "carry" or "clean"');
+          }
           const pendingBranch = {
             branchId: message.branchId,
             projectId: message.projectId,
             branchName: message.targetBranch
           };
-          const created = await workspaceSyncSingleFlight.runMutation(() => {
+          const created = await workspaceSyncSingleFlight.runBranchMutation(() => {
             if (workspaceOperationsAreFenced(deferredWorkspaceConfiguration, activeWorkspaceIncidentId)) {
               throw new Error(
                 `Project branch creation was fenced while queued by workspace incident ${deferredWorkspaceConfiguration?.incidentId ?? activeWorkspaceIncidentId}`
@@ -5549,6 +5674,7 @@ async function startWorker(options) {
                 primaryBranchName: primaryProjectBranch(project),
                 sourceBranchName: message.sourceBranch,
                 branchName: message.targetBranch,
+                workingTree: message.workingTree,
                 pendingRetry: pendingWasRecorded
               });
               gitBranchCreated = true;
@@ -5605,9 +5731,14 @@ async function startWorker(options) {
           });
           return;
         }
+        sendWorkerMessage(ws, {
+          type: "operation_queued",
+          requestId: message.requestId,
+          queuePosition: workspaceSyncSingleFlight.branchMutationQueuePosition()
+        });
         try {
           const deletionKey = projectBranchKey(message.projectId, message.branchName);
-          const deletionNeedsSync = await workspaceSyncSingleFlight.runMutation(() => {
+          const deletionNeedsSync = await workspaceSyncSingleFlight.runBranchMutation(() => {
             if (workspaceOperationsAreFenced(deferredWorkspaceConfiguration, activeWorkspaceIncidentId)) {
               throw new Error(
                 `Project branch deletion was fenced while queued by workspace incident ${deferredWorkspaceConfiguration?.incidentId ?? activeWorkspaceIncidentId}`
@@ -5638,6 +5769,9 @@ async function startWorker(options) {
               projectId: message.projectId,
               branchName: message.branchName
             });
+            if (pendingLocalBranch) {
+              projectWorkspaceState = projectWorkspaceStateStore.clearPendingCreatedBranch(pendingLocalBranch);
+            }
             pendingCreatedBranchPublicationNotBefore.delete((0, import_workspace_automatic_sync_policy.pendingCreatedBranchKey)(message.projectId, message.branchName));
             if (pendingMirrorDeletes.has(deletionKey)) return true;
             stageProjectBranchDeletion(project, message.branchName, true);
@@ -5915,7 +6049,7 @@ async function startWorker(options) {
             ws,
             message,
             resolvedTarget,
-            planRoot,
+            rootDir,
             assertAdmission: assertMessageAdmission,
             ...releaseWorkspaceMutation ? { releaseWorkspaceMutation } : {},
             ...targetMayMutateVisibleWorkspace(message.target) ? {
@@ -6013,8 +6147,7 @@ async function startWorker(options) {
               resolvedTarget,
               baseUrl,
               token,
-              artifactRoot,
-              planRoot,
+              rootDir,
               setPreparationHeartbeatLease: (active) => {
                 sendWorkerMessageFromCurrentSource(ws, {
                   type: "heartbeat_lease",
@@ -6083,8 +6216,7 @@ async function startWorker(options) {
               resolvedTarget,
               baseUrl,
               token,
-              artifactRoot,
-              planRoot,
+              rootDir,
               setPreparationHeartbeatLease: (active) => {
                 sendWorkerMessageFromCurrentSource(ws, {
                   type: "heartbeat_lease",
@@ -6166,8 +6298,7 @@ async function startWorker(options) {
               resolvedTarget,
               baseUrl,
               token,
-              artifactRoot,
-              planRoot,
+              rootDir,
               assertAdmission: assertMessageAdmission
             });
           });