@ricsam/r5d-worker 0.0.73 → 0.0.75

package/dist/mjs/main.mjs

@@ -5,7 +5,6 @@ import { createHash } from "node:crypto";
 import os, { hostname } from "node:os";
 import { spawn as spawnChildProcess } from "node:child_process";
 import { installCliUpdate, readInstalledCliVersion } from "./cli-update.mjs";
-import { configureVisibleGitIdentity } from "./git-identity.mjs";
 import {
   grantWorkerHeartbeatBusyGrace,
   hasWorkerHeartbeatTimedOutWithBusyGrace,
@@ -14,20 +13,9 @@ import {
 import { terminateProcessTree } from "./process-tree.mjs";
 import { createPtyOutputCoalescer } from "./pty-output-coalescer.mjs";
 import { openWorkerPortForwardRelay } from "./port-forward-client.mjs";
-import { applyWorkspaceIncidentUpdate, releasePendingWorkspaceHead, WorkspaceIncidentOrderingFence } from "./workspace-incident-state.mjs";
+import { applyWorkspaceIncidentUpdate } from "./workspace-incident-state.mjs";
 import { acquireWorkspaceCommandMutation, runWorkspaceCommand } from "./workspace-command-sync-policy.mjs";
-import {
-  WORKSPACE_PUBLICATION_QUIET_MS,
-  WORKSPACE_IDLE_SAFETY_SCAN_MS,
-  ExplicitWorkspacePublicationQueue,
-  WorkspaceManifestRevisionFence,
-  processWorkspaceConvergenceState,
-  waitForWorkspacePublicationOnShutdown,
-  workspaceBootstrapEstablishesVisibleBaseline,
-  workspacePublicationIncidentAction,
-  workspacePublicationTelemetry
-} from "./workspace-convergence.mjs";
-import { inspectWorkspaceManifestFilesystem } from "./workspace-manifest-admission.mjs";
+import { WorkspaceMutationGate } from "./workspace-mutation-gate.mjs";
 import {
   isRetryableWorkerServerStatus,
   superviseWorkerRuntime,
@@ -38,11 +26,26 @@ import {
 } from "./supervisor.mjs";
 import { managedProjectRoot, validateManagedBranchName } from "./managed-paths.mjs";
 import {
-  WorkspaceSyncSingleFlight,
-  convergeWorkspaceHead,
-  synchronizeWorkspace,
-  workspaceProjectsForSync
-} from "./workspace-sync.mjs";
+  createLinkedProjectBranch,
+  deleteLinkedProjectBranch,
+  deleteProjectMirrorBranch,
+  ensureProjectWorktrees,
+  fastForwardProjectHeadsFromMirror,
+  projectWorktreeConfigurationFingerprint,
+  projectWorktreeOperationInProgress,
+  pushProjectMirrorHeads,
+  removeProjectWorktrees
+} from "./project-worktrees.mjs";
+import {
+  ProjectWorkspaceStateStore,
+  pruneAuthoritativelyDesiredBranchDeletions
+} from "./project-workspace-state.mjs";
+import {
+  ensureWorkspaceGitClone,
+  hydrateWorkspaceGitMounts,
+  resetWorkspaceGit,
+  synchronizeWorkspaceGit
+} from "./workspace-git-sync.mjs";
 class WorkerServerUnavailableError extends Error {
   name = "WorkerServerUnavailableError";
 }
@@ -52,12 +55,34 @@ const LABEL_RE = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,62}$/;
 const DEFAULT_READ_LIMIT = 2e3;
 const DEFAULT_READ_MAX_BYTES = 5e4;
 const MAX_LINE_LENGTH = 2e3;
+const WORKSPACE_GIT_QUIET_MS = 5e3;
+const WORKSPACE_GIT_PERIODIC_MS = 6e4;
 const activeProcesses = /* @__PURE__ */ new Map();
 const pendingProcessTerminals = /* @__PURE__ */ new Map();
 const cancelledProcessRuns = /* @__PURE__ */ new Set();
 const activePtys = /* @__PURE__ */ new Map();
 let currentWorkerSocket = null;
-const workspaceSyncSingleFlight = new WorkspaceSyncSingleFlight();
+const workspaceMutationGate = new WorkspaceMutationGate();
+let workspaceSyncQueue = Promise.resolve();
+const workspaceSyncSingleFlight = {
+  runExclusive(operation) {
+    const queued = workspaceMutationGate.runSync(operation);
+    workspaceSyncQueue = queued.then(
+      () => void 0,
+      () => void 0
+    );
+    return queued;
+  },
+  runMutation(operation) {
+    return workspaceMutationGate.runMutation(operation);
+  },
+  acquireMutation() {
+    return workspaceMutationGate.acquireMutation();
+  },
+  afterCurrent() {
+    return workspaceSyncQueue;
+  }
+};
 let githubCredential = null;
 let visibleGitIdentity = null;
 function defaultConfigPath() {
@@ -620,20 +645,11 @@ function gitAuthArgs(auth) {
   const scopedKey = gitExtraHeaderConfigKey(auth.extraHeaderUrl);
   return ["-c", "http.extraHeader=", "-c", `${scopedKey}=`, "-c", `${scopedKey}=${auth.header}`];
 }
-const visibleCheckoutGitTestHarness = {
-  gitAuthArgs,
-  commandArgs: (args, auth) => ["git", ...NON_RECURSIVE_GIT_CONFIG_ARGS, ...gitAuthArgs(auth), ...args],
-  cloneArgs: (remoteUrl, branchPath) => ["clone", "--no-recurse-submodules", "--origin", "origin", remoteUrl, branchPath],
-  fetchArgs: (...args) => ["fetch", "--no-recurse-submodules", ...args]
+const workerGitCommand = {
+  commandArgs: (args, auth) => ["git", ...NON_RECURSIVE_GIT_CONFIG_ARGS, ...gitAuthArgs(auth), ...args]
 };
-function visibleCheckoutCloneArgs(remoteUrl, branchPath) {
-  return visibleCheckoutGitTestHarness.cloneArgs(remoteUrl, branchPath);
-}
-function visibleCheckoutFetchArgs(...args) {
-  return visibleCheckoutGitTestHarness.fetchArgs(...args);
-}
 function runGit(args, options = {}) {
-  const command = visibleCheckoutGitTestHarness.commandArgs(args, options.auth);
+  const command = workerGitCommand.commandArgs(args, options.auth);
   const result = Bun.spawnSync(command, {
     cwd: options.cwd,
     stdout: "pipe",
@@ -662,9 +678,6 @@ function getGitBlobHashForContent(content) {
   const buffer = typeof content === "string" ? Buffer.from(content, "utf8") : content;
   return createHash("sha1").update(`blob ${buffer.length}\0`).update(buffer).digest("hex");
 }
-function hasWorktreeChanges(cwd) {
-  return runGit(["status", "--porcelain"], { cwd }).trim().length > 0;
-}
 function isInsideBranchPath(branchPath, filePath) {
   const relative = path.relative(path.resolve(branchPath), path.resolve(filePath));
   return relative === "" || relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
@@ -774,33 +787,9 @@ function resolveWorkerFilePath(branchPath, inputPath, builtInPaths) {
     scope: "project"
   };
 }
-function fallbackInternalRemoteUrl(baseUrl, projectId) {
+function canonicalProjectRemoteUrl(baseUrl, projectId) {
   return new URL(`/git/${projectId}.git`, baseUrl).toString();
 }
-function visibleCheckoutRemoteFor(input) {
-  const canonicalCheckout = input.manifest?.canonicalCheckouts?.find((checkout) => checkout.branchName === input.branchName);
-  if (!canonicalCheckout && input.manifest) {
-    if (!input.manifest.repoHttpUrl) {
-      throw new Error(`Project ${input.projectId} has no connected repository; connect one before opening its checkouts`);
-    }
-    return {
-      remoteUrl: input.manifest.repoHttpUrl,
-      authHeader: input.manifest.repoAuthHeader ?? null,
-      persistAuth: true,
-      reconcileExistingOrigin: true,
-      requireRemoteBranch: false,
-      requiredBaseCommit: null
-    };
-  }
-  return {
-    remoteUrl: fallbackInternalRemoteUrl(input.baseUrl, input.projectId),
-    authHeader: `Authorization: Bearer ${input.token}`,
-    persistAuth: false,
-    reconcileExistingOrigin: true,
-    requireRemoteBranch: true,
-    requiredBaseCommit: canonicalCheckout?.scaffoldCommitHash ?? null
-  };
-}
 function gitExtraHeaderUrlForRemote(remoteUrl) {
   try {
     return new URL(remoteUrl).origin;
@@ -817,44 +806,25 @@ function gitAuthForRemote(remoteUrl, authHeader) {
     header: authHeader
   };
 }
-function hasNormalVisibleGitDir(branchPath) {
-  const gitPath = path.join(branchPath, ".git");
-  return fs.existsSync(gitPath) && fs.statSync(gitPath).isDirectory();
-}
-function ensureOriginRemote(branchPath, remoteUrl) {
-  if (tryGit(["remote", "get-url", "origin"], { cwd: branchPath })) {
-    runGit(["remote", "set-url", "origin", remoteUrl], { cwd: branchPath });
-  } else {
-    runGit(["remote", "add", "origin", remoteUrl], { cwd: branchPath });
-  }
-}
-function originRemoteUrl(branchPath) {
-  if (!tryGit(["remote", "get-url", "origin"], { cwd: branchPath })) return null;
-  return runGit(["remote", "get-url", "origin"], { cwd: branchPath });
-}
 function shellQuote(value) {
   return `'${value.replace(/'/g, "'\\''")}'`;
 }
 function githubCredentialsPath() {
   return path.join(os.homedir(), ".r5d", "github-credentials");
 }
-function decodeBasicAuthHeader(authHeader) {
+function decodeGitAuthHeader(authHeader) {
   const match = /^Authorization:\s*Basic\s+(.+)$/i.exec(authHeader.trim());
-  if (!match) {
-    return null;
-  }
-  const decoded = Buffer.from(match[1], "base64").toString("utf8");
-  const separatorIndex = decoded.indexOf(":");
-  if (separatorIndex <= 0) {
-    return null;
+  if (match) {
+    const decoded = Buffer.from(match[1], "base64").toString("utf8");
+    const separatorIndex = decoded.indexOf(":");
+    if (separatorIndex <= 0) return null;
+    return { username: decoded.slice(0, separatorIndex), password: decoded.slice(separatorIndex + 1) };
   }
-  return {
-    username: decoded.slice(0, separatorIndex),
-    password: decoded.slice(separatorIndex + 1)
-  };
+  const bearer = /^Authorization:\s*Bearer\s+(.+)$/i.exec(authHeader.trim());
+  return bearer?.[1] ? { username: "r5d-worker", password: bearer[1] } : null;
 }
 function writeCredentialStoreEntry(remoteUrl, authHeader) {
-  const credentials = decodeBasicAuthHeader(authHeader);
+  const credentials = decodeGitAuthHeader(authHeader);
   if (!credentials) {
     return null;
   }
@@ -888,29 +858,9 @@ function writeCredentialStoreEntry(remoteUrl, authHeader) {
   fs.chmodSync(storePath, 384);
   return storePath;
 }
-function configureVisibleGitHubAuth(branchPath, remoteUrl, authHeader) {
-  if (!authHeader) {
-    return;
-  }
+function credentialHelperForRemote(remoteUrl, authHeader) {
   const credentialStore = writeCredentialStoreEntry(remoteUrl, authHeader);
-  if (credentialStore) {
-    runGit(["config", "credential.helper", `store --file=${shellQuote(credentialStore)}`], { cwd: branchPath });
-    runGit(["config", "credential.useHttpPath", "false"], { cwd: branchPath });
-    return;
-  }
-  runGit(["config", `${gitExtraHeaderConfigKey(gitExtraHeaderUrlForRemote(remoteUrl))}`, authHeader], { cwd: branchPath });
-}
-function clearVisibleGitAuthentication(branchPath) {
-  let extraHeaderKeys = [];
-  try {
-    extraHeaderKeys = runGit(["config", "--local", "--name-only", "--get-regexp", "^http\\..*extraheader$"], { cwd: branchPath }).split(/\r?\n/).filter(Boolean);
-  } catch {
-  }
-  for (const key of extraHeaderKeys) {
-    tryGit(["config", "--local", "--unset-all", key], { cwd: branchPath });
-  }
-  runGit(["config", "--local", "--replace-all", "credential.helper", ""], { cwd: branchPath });
-  tryGit(["config", "--local", "--unset-all", "credential.useHttpPath"], { cwd: branchPath });
+  return credentialStore ? `store --file=${shellQuote(credentialStore)}` : null;
 }
 function dockerConfigPath() {
   return path.join(os.homedir(), ".docker", "config.json");
@@ -990,188 +940,26 @@ function githubProcessEnv() {
     ...githubCliEnv(githubCredential?.token)
   };
 }
-function checkoutVisibleBranch(input) {
-  const branchExists = tryGit(["show-ref", "--verify", "--quiet", `refs/heads/${input.branchName}`], { cwd: input.branchPath });
-  const remoteBranchExists = tryGit(["show-ref", "--verify", "--quiet", `refs/remotes/origin/${input.branchName}`], {
-    cwd: input.branchPath
-  });
-  const defaultRemoteExists = tryGit(["show-ref", "--verify", "--quiet", `refs/remotes/origin/${input.defaultBranch}`], {
-    cwd: input.branchPath
-  });
-  const clean = !hasWorktreeChanges(input.branchPath);
-  if (remoteBranchExists && clean) {
-    runGit(["checkout", "--no-recurse-submodules", "-B", input.branchName, `origin/${input.branchName}`], {
-      cwd: input.branchPath
-    });
-    return;
-  }
-  if (branchExists) {
-    runGit(["checkout", "--no-recurse-submodules", input.branchName], { cwd: input.branchPath });
-    return;
-  }
-  if (defaultRemoteExists) {
-    runGit(["checkout", "--no-recurse-submodules", "-B", input.branchName, `origin/${input.defaultBranch}`], {
-      cwd: input.branchPath
-    });
-    return;
-  }
-  runGit(["checkout", "--no-recurse-submodules", "-B", input.branchName], { cwd: input.branchPath });
-}
-function reconcileRewrittenCanonicalHistory(input) {
-  const remoteRef = `refs/remotes/origin/${input.branchName}`;
-  if (!tryGit(["rev-parse", "--verify", "HEAD"], { cwd: input.branchPath })) return;
-  if (!tryGit(["show-ref", "--verify", "--quiet", remoteRef], { cwd: input.branchPath })) return;
-  if (tryGit(["merge-base", "HEAD", remoteRef], { cwd: input.branchPath })) return;
-  if (hasWorktreeChanges(input.branchPath)) return;
-  const localTree = runGit(["rev-parse", "HEAD^{tree}"], { cwd: input.branchPath });
-  const remoteTree = runGit(["rev-parse", `${remoteRef}^{tree}`], { cwd: input.branchPath });
-  if (localTree !== remoteTree) return;
-  const previousHead = runGit(["rev-parse", "HEAD"], { cwd: input.branchPath });
-  runGit(["update-ref", `refs/r5d/pre-canonical-checkout/${previousHead}`, previousHead], { cwd: input.branchPath });
-  runGit(["checkout", "--no-recurse-submodules", "-B", input.branchName, remoteRef], { cwd: input.branchPath });
-}
-function migrateExistingCheckoutToRequiredRemote(input) {
-  if (originRemoteUrl(input.branchPath) === input.remoteUrl) return;
-  const dirtyWorkingTree = hasWorktreeChanges(input.branchPath);
-  if (dirtyWorkingTree && input.requiredBaseCommit) {
-    throw new Error(`Cannot migrate dirty checkout for ${input.branchName} to its canonical remote`);
-  }
-  const preserveWorkingTree = dirtyWorkingTree;
-  runGit(
-    visibleCheckoutFetchArgs("--no-tags", input.remoteUrl, `+refs/heads/${input.branchName}:refs/remotes/origin/${input.branchName}`),
-    {
-      cwd: input.branchPath,
-      auth: input.remoteAuth
-    }
-  );
-  const canonicalRemoteRef = `refs/remotes/origin/${input.branchName}`;
-  if (!tryGit(["show-ref", "--verify", "--quiet", canonicalRemoteRef], { cwd: input.branchPath })) {
-    throw new Error(`Canonical branch ${input.branchName} is unavailable during checkout migration`);
-  }
-  if (input.requiredBaseCommit && (!tryGit(["cat-file", "-e", `${input.requiredBaseCommit}^{commit}`], { cwd: input.branchPath }) || !tryGit(["merge-base", "--is-ancestor", input.requiredBaseCommit, canonicalRemoteRef], { cwd: input.branchPath }))) {
-    throw new Error(`Canonical branch ${input.branchName} is not derived from required scaffold ${input.requiredBaseCommit}`);
-  }
-  ensureOriginRemote(input.branchPath, input.remoteUrl);
-  if (preserveWorkingTree) return;
-  if (tryGit(["rev-parse", "--verify", "HEAD"], { cwd: input.branchPath })) {
-    const previousHead = runGit(["rev-parse", "HEAD"], { cwd: input.branchPath });
-    runGit(["update-ref", `refs/r5d/pre-canonical-checkout/${previousHead}`, previousHead], { cwd: input.branchPath });
-  }
-  runGit(["checkout", "--no-recurse-submodules", "-B", input.branchName, `origin/${input.branchName}`], {
-    cwd: input.branchPath
-  });
+function primaryProjectBranch(config) {
+  if (config.branches.length === 0) throw new Error(`Project ${config.projectId} has no configured branches`);
+  if (config.branches.some(({ branchName }) => branchName === "main")) return "main";
+  if (config.branches.some(({ branchName }) => branchName === config.defaultBranch)) return config.defaultBranch;
+  return config.branches[0].branchName;
 }
-function assertCheckoutDerivedFromRequiredBase(input) {
-  const remoteRevision = `refs/remotes/origin/${input.branchName}`;
-  for (const revision of [remoteRevision, "HEAD"]) {
-    if (!tryGit(["cat-file", "-e", `${input.requiredBaseCommit}^{commit}`], { cwd: input.branchPath }) || !tryGit(["merge-base", "--is-ancestor", input.requiredBaseCommit, revision], { cwd: input.branchPath })) {
-      throw new Error(`Canonical checkout ${input.branchName} is not derived from required scaffold ${input.requiredBaseCommit}`);
-    }
-  }
+function configuredProjectRoot(projectsRoot, config) {
+  return managedProjectRoot(projectsRoot, config.checkoutPathSegments);
 }
-function ensureVisibleGitCheckout(input) {
-  validateBranchName(input.branchName);
-  fs.mkdirSync(input.projectRoot, { recursive: true });
-  const branchPath = path.join(input.projectRoot, input.branchName);
-  const createdCheckout = !hasNormalVisibleGitDir(branchPath);
-  if (createdCheckout) {
-    fs.rmSync(branchPath, { recursive: true, force: true });
-    fs.mkdirSync(path.dirname(branchPath), { recursive: true });
-    const cloned = tryGit(visibleCheckoutCloneArgs(input.remoteUrl, branchPath), {
-      auth: input.remoteAuth
-    });
-    if (!cloned && input.requireRemoteBranch) {
-      fs.rmSync(branchPath, { recursive: true, force: true });
-      throw new Error(`Failed to clone canonical checkout for branch ${input.branchName}`);
-    }
-    if (!cloned) {
-      fs.mkdirSync(branchPath, { recursive: true });
-      runGit(["init"], { cwd: branchPath });
-    }
-    ensureOriginRemote(branchPath, input.remoteUrl);
-    if (input.clearPersistentAuth) clearVisibleGitAuthentication(branchPath);
-    else configureVisibleGitHubAuth(branchPath, input.remoteUrl, input.persistentAuthHeader);
-    configureVisibleGitIdentity(branchPath, visibleGitIdentity, runGit);
-    tryGit(visibleCheckoutFetchArgs("origin", "--prune"), { cwd: branchPath, auth: input.remoteAuth });
-    if (input.requireRemoteBranch && !tryGit(["show-ref", "--verify", "--quiet", `refs/remotes/origin/${input.branchName}`], { cwd: branchPath })) {
-      fs.rmSync(branchPath, { recursive: true, force: true });
-      throw new Error(`Canonical branch ${input.branchName} is unavailable after clone`);
-    }
-    checkoutVisibleBranch({ branchPath, branchName: input.branchName, defaultBranch: input.defaultBranch });
-    if (input.requiredBaseCommit) {
-      try {
-        assertCheckoutDerivedFromRequiredBase({
-          branchPath,
-          branchName: input.branchName,
-          requiredBaseCommit: input.requiredBaseCommit
-        });
-      } catch (error) {
-        fs.rmSync(branchPath, { recursive: true, force: true });
-        throw error;
-      }
-    }
-    return branchPath;
-  }
-  if (input.requireRemoteBranch) {
-    if (input.allowRequiredRemoteMigration === false && originRemoteUrl(branchPath) !== input.remoteUrl) {
-      throw new Error(`Canonical checkout ${input.branchName} no longer uses its required remote`);
-    }
-    migrateExistingCheckoutToRequiredRemote({
-      branchPath,
-      branchName: input.branchName,
-      remoteUrl: input.remoteUrl,
-      remoteAuth: input.remoteAuth,
-      requiredBaseCommit: input.requiredBaseCommit
-    });
-    runGit(
-      visibleCheckoutFetchArgs("--no-tags", input.remoteUrl, `+refs/heads/${input.branchName}:refs/remotes/origin/${input.branchName}`),
-      {
-        cwd: branchPath,
-        auth: input.remoteAuth
-      }
-    );
-  }
-  if (input.reconcileExistingOrigin) {
-    ensureOriginRemote(branchPath, input.remoteUrl);
-  }
-  if (!input.requireRemoteBranch) {
-    tryGit(visibleCheckoutFetchArgs("origin", "--prune"), { cwd: branchPath, auth: input.remoteAuth });
-  }
-  if (input.requireRemoteBranch && !tryGit(["show-ref", "--verify", "--quiet", `refs/remotes/origin/${input.branchName}`], { cwd: branchPath })) {
-    throw new Error(`Existing checkout for ${input.branchName} does not contain its canonical remote branch`);
-  }
-  if (input.requireRemoteBranch) {
-    reconcileRewrittenCanonicalHistory({ branchPath, branchName: input.branchName });
-  }
-  if (input.requiredBaseCommit) {
-    assertCheckoutDerivedFromRequiredBase({
-      branchPath,
-      branchName: input.branchName,
-      requiredBaseCommit: input.requiredBaseCommit
-    });
-  }
-  if (input.clearPersistentAuth) clearVisibleGitAuthentication(branchPath);
-  else configureVisibleGitHubAuth(branchPath, input.remoteUrl, input.persistentAuthHeader);
-  configureVisibleGitIdentity(branchPath, visibleGitIdentity, runGit);
-  return branchPath;
+function configuredProjectBranchPath(projectsRoot, config, branchName) {
+  validateBranchName(branchName);
+  return path.join(configuredProjectRoot(projectsRoot, config), ...branchName.split("/"));
 }
-function ensureBranchWorktree(input) {
-  const defaultBranch = input.manifest?.defaultBranch || "main";
-  const remote = visibleCheckoutRemoteFor(input);
-  return {
-    branchPath: ensureVisibleGitCheckout({
-      projectRoot: input.projectRoot,
-      branchName: input.branchName,
-      remoteUrl: remote.remoteUrl,
-      remoteAuth: gitAuthForRemote(remote.remoteUrl, remote.authHeader),
-      persistentAuthHeader: remote.persistAuth ? remote.authHeader : null,
-      defaultBranch,
-      reconcileExistingOrigin: remote.reconcileExistingOrigin,
-      requireRemoteBranch: remote.requireRemoteBranch,
-      requiredBaseCommit: remote.requiredBaseCommit,
-      clearPersistentAuth: !remote.persistAuth
-    })
-  };
+function hasProjectWorktree(checkoutPath) {
+  try {
+    const stat = fs.lstatSync(path.join(checkoutPath, ".git"));
+    return stat.isFile() || stat.isDirectory();
+  } catch {
+    return false;
+  }
 }
 function describeWorkerSessionTarget(target) {
   return target.type === "project" ? `${target.projectId}/${target.branchName}` : `${target.ownerUserId}/${target.rootProfile}`;
@@ -1182,40 +970,21 @@ function resolveWorkerSessionTarget(input) {
       return { target: input.target, rootPath: input.projectsRoot };
     }
     if (!fs.existsSync(path.join(input.workspaceShadowRoot, ".git"))) {
-      throw new Error("The canonical workspace checkout is not initialized on this worker");
+      throw new Error("The workspace sync checkout is not initialized on this worker");
     }
     return { target: input.target, rootPath: input.workspaceShadowRoot };
   }
-  const manifest = input.manifestByProjectId.get(input.target.projectId);
-  const projectRoot = projectRootFor(input.projectsRoot, input.target.projectId, input.manifestByProjectId);
-  const worktree = ensureBranchWorktree({
-    projectId: input.target.projectId,
-    baseUrl: input.baseUrl,
-    token: input.token,
-    projectRoot,
-    syncRoot: input.syncRoot,
-    branchName: input.target.branchName,
-    manifest
-  });
-  return { target: input.target, rootPath: worktree.branchPath, manifest };
-}
-function workspaceSyncCheckoutTargets(input) {
-  const selected = /* @__PURE__ */ new Map();
-  const add = (target) => {
-    selected.set(`${target.projectId}\0${target.branchName}`, target);
-  };
-  if (input.canonicalCheckoutOnly) {
-    add(input.canonicalCheckoutOnly);
-  } else if (input.includeAllManifestCheckouts) {
-    for (const project of input.projects) {
-      for (const branchName of project.branches) add({ projectId: project.projectId, branchName });
-    }
-  } else {
-    for (const target of input.pendingTargets) add(target);
+  const target = input.target;
+  const config = input.projectConfigById.get(target.projectId);
+  if (!config) throw new Error(`Project ${target.projectId} is missing from the worker workspace configuration`);
+  if (!config.branches.some(({ branchName }) => branchName === target.branchName)) {
+    throw new Error(`Project branch ${target.projectId}/${target.branchName} is missing from the worker workspace configuration`);
   }
-  return [...selected.values()].sort(
-    (left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName)
-  );
+  const branchPath = configuredProjectBranchPath(input.projectsRoot, config, target.branchName);
+  if (!hasProjectWorktree(branchPath)) {
+    throw new Error(`Project branch ${target.projectId}/${target.branchName} is not initialized on this worker`);
+  }
+  return { target, rootPath: branchPath, config };
 }
 function resolveCommandCwd(branchPath, cwd) {
   if (!cwd) {
@@ -1739,6 +1508,77 @@ async function executeLsOperation(input) {
   });
   return listWorkerDirectory(input.resolvedTarget.rootPath, input.message.path, input.message.limit, builtInPaths);
 }
+function resolveWorkerCodePath(branchPath, inputPath) {
+  if (typeof inputPath !== "string" || !inputPath.startsWith("/") || inputPath.includes("\0")) {
+    throw new Error("Code path must be an absolute virtual path");
+  }
+  const rawSegments = inputPath.replace(/\\/g, "/").split("/");
+  if (rawSegments.includes("..")) throw new Error(`Invalid code path: ${inputPath}`);
+  const displayPath = path.posix.normalize(inputPath.replace(/\\/g, "/"));
+  const relativePath = displayPath.replace(/^\/+/, "");
+  const pathSegments = relativePath ? relativePath.split("/") : [];
+  if (pathSegments.some((segment) => segment.toLowerCase() === ".git")) {
+    throw new Error("Code paths cannot access Git metadata");
+  }
+  const resolvedBranchPath = path.resolve(branchPath);
+  const absolutePath = path.resolve(resolvedBranchPath, ...pathSegments);
+  assertInsideRoot(resolvedBranchPath, absolutePath, "Code path");
+  if (!fs.existsSync(absolutePath)) throw new Error(`Code path not found: ${displayPath}`);
+  const realBranchPath = fs.realpathSync(resolvedBranchPath);
+  const realPath = fs.realpathSync(absolutePath);
+  assertInsideRoot(realBranchPath, realPath, "Code path");
+  const realRelativePath = path.relative(realBranchPath, realPath).split(path.sep);
+  if (realRelativePath.some((segment) => segment.toLowerCase() === ".git")) {
+    throw new Error("Code paths cannot access Git metadata");
+  }
+  return { absolutePath, displayPath };
+}
+function listWorkerCodeDirectory(branchPath, inputPath) {
+  const resolved = resolveWorkerCodePath(branchPath, inputPath);
+  if (!fs.statSync(resolved.absolutePath).isDirectory()) {
+    throw new Error(`Code directory not found: ${resolved.displayPath}`);
+  }
+  const entries = fs.readdirSync(resolved.absolutePath, { withFileTypes: true }).filter((entry) => entry.name.toLowerCase() !== ".git").flatMap((entry) => {
+    const entryPath = path.posix.join(resolved.displayPath, entry.name);
+    try {
+      const resolvedEntry = resolveWorkerCodePath(branchPath, entryPath);
+      const stats = fs.statSync(resolvedEntry.absolutePath);
+      if (!stats.isFile() && !stats.isDirectory()) return [];
+      return [
+        {
+          name: entry.name,
+          type: stats.isDirectory() ? "directory" : "file",
+          size: stats.isDirectory() ? null : stats.size,
+          mtime: stats.mtime.toISOString()
+        }
+      ];
+    } catch {
+      return [];
+    }
+  }).sort((left, right) => Number(right.type === "directory") - Number(left.type === "directory") || left.name.localeCompare(right.name));
+  return { type: "code_list", path: resolved.displayPath, entries };
+}
+function readWorkerCodeFile(branchPath, inputPath) {
+  const resolved = resolveWorkerCodePath(branchPath, inputPath);
+  const stats = fs.statSync(resolved.absolutePath);
+  if (!stats.isFile()) throw new Error(`Code file not found: ${resolved.displayPath}`);
+  const bytes = fs.readFileSync(resolved.absolutePath);
+  return {
+    type: "code_read",
+    path: resolved.displayPath,
+    size: bytes.length,
+    mtime: stats.mtime.toISOString(),
+    base64: bytes.toString("base64")
+  };
+}
+function executeCodeListOperation(input) {
+  if (input.resolvedTarget.target.type !== "project") throw new Error("Code listing requires a project branch target");
+  return listWorkerCodeDirectory(input.resolvedTarget.rootPath, input.message.path);
+}
+function executeCodeReadOperation(input) {
+  if (input.resolvedTarget.target.type !== "project") throw new Error("Code reading requires a project branch target");
+  return readWorkerCodeFile(input.resolvedTarget.rootPath, input.message.path);
+}
 function readWorkerImageFile(branchPath, filePath, builtInPaths) {
   const resolved = resolveWorkerFilePath(branchPath, filePath, builtInPaths);
   if (!fs.existsSync(resolved.absolutePath) || !fs.statSync(resolved.absolutePath).isFile()) {
@@ -1791,6 +1631,10 @@ async function executeOperation(input) {
       return executeLsOperation({ ...input, message: input.message });
     case "view_file_bytes":
       return executeViewFileBytesOperation({ ...input, message: input.message });
+    case "code_list":
+      return executeCodeListOperation({ ...input, message: input.message });
+    case "code_read":
+      return executeCodeReadOperation({ ...input, message: input.message });
   }
 }
 function targetIdentityEnv(target) {
@@ -2390,19 +2234,16 @@ function websocketUrl(baseUrl, label) {
   url.searchParams.set("version", getWorkerVersion());
   return url.toString();
 }
-function projectRootFor(projectsRoot, projectId, manifestByProjectId) {
-  const manifest = manifestByProjectId.get(projectId);
-  if (!manifest) throw new Error(`Project ${projectId} is missing from the worker workspace manifest`);
-  return managedProjectRoot(projectsRoot, manifest.checkoutPathSegments);
-}
 async function startWorker(options) {
   process.on("uncaughtException", (error) => {
     process.stderr.write(`[r5d-worker] uncaught exception: ${error instanceof Error ? error.stack ?? error.message : String(error)}
 `);
   });
   process.on("unhandledRejection", (reason) => {
-    process.stderr.write(`[r5d-worker] unhandled rejection: ${reason instanceof Error ? reason.stack ?? reason.message : String(reason)}
-`);
+    process.stderr.write(
+      `[r5d-worker] unhandled rejection: ${reason instanceof Error ? reason.stack ?? reason.message : String(reason)}
+`
+    );
   });
   const config = readConfig(options.configPath);
   const { baseUrl, token } = resolveCredentials(options, config);
@@ -2431,402 +2272,785 @@ async function startWorker(options) {
   fs.mkdirSync(syncRoot, { recursive: true });
   fs.mkdirSync(artifactRoot, { recursive: true });
   fs.mkdirSync(planRoot, { recursive: true });
-  const manifestByProjectId = /* @__PURE__ */ new Map();
-  const pendingManifestCheckouts = /* @__PURE__ */ new Map();
+  const projectWorkspaceStateStore = new ProjectWorkspaceStateStore({
+    stateRoot: path.join(syncRoot, "project-state"),
+    projectsRoot
+  });
+  let projectWorkspaceState = projectWorkspaceStateStore.read();
+  const projectConfigById = /* @__PURE__ */ new Map();
+  const pendingCheckouts = /* @__PURE__ */ new Map();
+  const readyProjectIds = /* @__PURE__ */ new Set();
+  const reconciledProjectConfigFingerprints = /* @__PURE__ */ new Map();
+  const lastObservedProjectHeads = /* @__PURE__ */ new Map();
+  const pendingMirrorDeletes = /* @__PURE__ */ new Map();
   let workspaceRemoteUrl = null;
+  let workspaceGitIdentity = null;
+  let workspaceConfigured = false;
   let activeWorkspaceIncidentId = null;
-  const workspaceIncidentOrdering = new WorkspaceIncidentOrderingFence();
-  const workspaceConvergence = processWorkspaceConvergenceState(path.join(syncRoot, "workspace-convergence.json"));
-  const workspaceManifestRevision = new WorkspaceManifestRevisionFence();
-  let workspaceReady = false;
-  let workspacePublicationTimer;
-  let workspaceSafetyScan;
-  let workspaceManifestHydrationTimer;
-  let workspaceManifestHydrationInFlight = false;
-  let workspaceSafetyScanInFlight = false;
-  let workspaceHeadConvergenceInFlight = false;
-  let pendingWorkspaceHead;
-  let pendingPublication;
-  const explicitWorkspacePublications = new ExplicitWorkspacePublicationQueue();
+  let workspaceAutomaticTimer;
+  let workspacePeriodicTimer;
+  let pendingAutomaticTrigger;
+  let automaticSyncInFlight = false;
   let terminalReplayTimer;
   let workspaceSyncRequestsInFlight = 0;
   let sessionArtifactSyncRequestsInFlight = 0;
   let cliUpdateInProgress = false;
   let reloadAfterClose = false;
   let shutdownAfterClose = false;
-  const workspaceSyncInput = (trigger, overrides = {}) => {
-    if (!workspaceRemoteUrl) throw new Error("Worker workspace manifest has not been received");
-    const projects = workspaceProjectsForSync([...manifestByProjectId.values()], trigger);
+  const bearerAuthHeader = `Authorization: Bearer ${token}`;
+  const projectBranchKey = (projectId, branchName) => `${projectId}\0${branchName}`;
+  const projectMountId = (projectId, branchName) => `project:${projectId}:${encodeURIComponent(branchName)}`;
+  const projectPlanMountId = (projectId, branchName) => `plan:${projectId}:${encodeURIComponent(branchName)}`;
+  const workspaceProjectRelativePath = (projectId, branchName) => path.posix.join("projects", projectId, "branches", encodeURIComponent(branchName));
+  const workspacePlanRelativePath = (projectId, branchName) => path.posix.join("plans", projectId, encodeURIComponent(branchName));
+  const projectConnection = (project) => {
+    const mirrorUrl = canonicalProjectRemoteUrl(baseUrl, project.projectId);
+    const mirrorAuth = gitAuthForRemote(mirrorUrl, bearerAuthHeader);
+    const originUrl = project.repoHttpUrl ?? mirrorUrl;
+    const originHeader = project.repoHttpUrl ? project.repoAuthHeader : bearerAuthHeader;
+    const originAuth = gitAuthForRemote(originUrl, originHeader);
+    const credentialHelper = originHeader ? credentialHelperForRemote(originUrl, originHeader) : null;
+    return { mirrorUrl, mirrorAuth, originUrl, originAuth, credentialHelper };
+  };
+  const durableDeletionForBranch = (projectId, checkoutPathSegments, branchName) => projectWorkspaceState.tombstones.find(
+    (tombstone) => tombstone.projectId === projectId && tombstone.checkoutPathSegments[0] === checkoutPathSegments[0] && tombstone.checkoutPathSegments[1] === checkoutPathSegments[1] && (tombstone.kind === "project" || tombstone.branchName === branchName)
+  );
+  const stageProjectBranchDeletion = (project, branchName, requireLocalBranch) => {
+    const projectRoot = configuredProjectRoot(projectsRoot, project);
+    const primaryBranchName = primaryProjectBranch(project);
+    const connection = projectConnection(project);
+    const sourcePath = configuredProjectBranchPath(projectsRoot, project, branchName);
+    if (requireLocalBranch || hasProjectWorktree(sourcePath)) {
+      deleteLinkedProjectBranch({ projectRoot, primaryBranchName, branchName });
+    }
+    const planSourcePath = path.join(planRoot, project.projectId, ...branchName.split("/"));
+    fs.rmSync(planSourcePath, { recursive: true, force: true });
+    const key = projectBranchKey(project.projectId, branchName);
+    const durableDeletion = durableDeletionForBranch(project.projectId, project.checkoutPathSegments, branchName);
+    pendingCheckouts.delete(key);
+    pendingMirrorDeletes.set(key, {
+      id: projectMountId(project.projectId, branchName),
+      projectId: project.projectId,
+      branchName,
+      gitDirectory: configuredProjectBranchPath(projectsRoot, project, primaryBranchName),
+      mirrorUrl: connection.mirrorUrl,
+      mirrorAuth: connection.mirrorAuth,
+      sourcePath,
+      workspaceRelativePath: workspaceProjectRelativePath(project.projectId, branchName),
+      planSourcePath,
+      planWorkspaceRelativePath: workspacePlanRelativePath(project.projectId, branchName),
+      ...durableDeletion ? { tombstoneId: durableDeletion.id } : {},
+      ...durableDeletion?.kind === "project" ? { projectDeleted: !projectWorkspaceState.desiredProjects.some(({ projectId }) => projectId === project.projectId) } : {}
+    });
+  };
+  const stageProjectDeletion = (project) => {
+    const projectRoot = configuredProjectRoot(projectsRoot, project);
+    const connection = projectConnection(project);
+    const branches = project.branches.map(({ branchName }) => ({
+      branchName,
+      sourcePath: configuredProjectBranchPath(projectsRoot, project, branchName),
+      planSourcePath: path.join(planRoot, project.projectId, ...branchName.split("/"))
+    }));
+    removeProjectWorktrees({ projectRoot, branchNames: branches.map(({ branchName }) => branchName) });
+    for (const branch of branches) {
+      fs.rmSync(branch.planSourcePath, { recursive: true, force: true });
+      const key = projectBranchKey(project.projectId, branch.branchName);
+      const durableDeletion = durableDeletionForBranch(project.projectId, project.checkoutPathSegments, branch.branchName);
+      pendingCheckouts.delete(key);
+      pendingMirrorDeletes.set(key, {
+        id: projectMountId(project.projectId, branch.branchName),
+        projectId: project.projectId,
+        branchName: branch.branchName,
+        // The project Git directory is intentionally gone before the outer
+        // tree is published. Use the outer workspace repository to delete the
+        // hidden ref only after that publication succeeds.
+        gitDirectory: workspaceShadowRoot,
+        mirrorUrl: connection.mirrorUrl,
+        mirrorAuth: connection.mirrorAuth,
+        sourcePath: branch.sourcePath,
+        workspaceRelativePath: workspaceProjectRelativePath(project.projectId, branch.branchName),
+        planSourcePath: branch.planSourcePath,
+        planWorkspaceRelativePath: workspacePlanRelativePath(project.projectId, branch.branchName),
+        ...durableDeletion ? { tombstoneId: durableDeletion.id } : {},
+        ...durableDeletion?.kind === "project" ? { projectDeleted: !projectWorkspaceState.desiredProjects.some(({ projectId }) => projectId === project.projectId) } : {}
+      });
+    }
+    readyProjectIds.delete(project.projectId);
+    reconciledProjectConfigFingerprints.delete(project.projectId);
+  };
+  const cleanupConfigForDurableDeletion = (deletion) => {
+    const desiredLayout = projectWorkspaceState.desiredProjects.find(
+      (project) => project.projectId === deletion.projectId && project.checkoutPathSegments[0] === deletion.checkoutPathSegments[0] && project.checkoutPathSegments[1] === deletion.checkoutPathSegments[1]
+    );
+    const liveConfig = projectConfigById.get(deletion.projectId);
+    const branchNames = deletion.kind === "project" ? deletion.branchNames : desiredLayout?.branches.map(({ branchName }) => branchName) ?? [];
+    const defaultBranch = desiredLayout?.defaultBranch ?? (branchNames.includes("main") ? "main" : branchNames[0] ?? "main");
     return {
-      workerLabel: label,
-      remoteUrl: workspaceRemoteUrl,
-      authHeader: `Authorization: Bearer ${token}`,
-      projectsRoot,
-      plansRoot: planRoot,
-      shadowRoot: workspaceShadowRoot,
-      projects,
-      trigger,
-      ...overrides
+      projectId: deletion.projectId,
+      checkoutPathSegments: [...deletion.checkoutPathSegments],
+      projectPath: liveConfig?.projectPath ?? deletion.checkoutPathSegments.join("/"),
+      repoHttpUrl: liveConfig?.repoHttpUrl ?? null,
+      repoAuthHeader: liveConfig?.repoAuthHeader ?? null,
+      defaultBranch,
+      branches: branchNames.map(
+        (branchName) => liveConfig?.branches.find((branch) => branch.branchName === branchName) ?? {
+          branchName,
+          sourceBranchName: null,
+          // Deletion never consumes the baseline, but retain a structurally
+          // valid value for the shared worker-project shape.
+          baseCommitHash: "0".repeat(40)
+        }
+      )
     };
   };
-  const sendWorkspaceSyncResult = (authority, result) => {
-    try {
-      ws.send(JSON.stringify({ type: "workspace_sync_result", ...authority, result }));
-    } catch (error) {
-      process.stderr.write(
-        `[r5d-worker] failed to send workspace_sync_result on its issuing connection: ${error instanceof Error ? error.message : String(error)}
-`
-      );
+  const stageDurableWorkspaceDeletions = () => {
+    for (const deletion of projectWorkspaceState.pendingTreeDeletions) {
+      const cleanupConfig = cleanupConfigForDurableDeletion(deletion);
+      if (deletion.kind === "project") {
+        if (!deletion.projectDeleted) {
+          if (fs.existsSync(deletion.managedPath)) {
+            removeProjectWorktrees({ projectRoot: deletion.managedPath, branchNames: deletion.branchNames });
+          }
+          readyProjectIds.delete(deletion.projectId);
+          reconciledProjectConfigFingerprints.delete(deletion.projectId);
+          continue;
+        }
+        stageProjectDeletion(cleanupConfig);
+        continue;
+      }
+      const primaryPath = deletion.primaryBranchName ? configuredProjectBranchPath(projectsRoot, cleanupConfig, deletion.primaryBranchName) : null;
+      stageProjectBranchDeletion(cleanupConfig, deletion.branchName, Boolean(primaryPath && hasProjectWorktree(primaryPath)));
+    }
+    for (const deletion of projectWorkspaceState.pendingMirrorRefDeletions) {
+      const key = projectBranchKey(deletion.projectId, deletion.branchName);
+      const planSourcePath = path.join(planRoot, deletion.projectId, ...deletion.branchName.split("/"));
+      fs.rmSync(planSourcePath, { recursive: true, force: true });
+      pendingMirrorDeletes.set(key, {
+        id: projectMountId(deletion.projectId, deletion.branchName),
+        projectId: deletion.projectId,
+        branchName: deletion.branchName,
+        gitDirectory: workspaceShadowRoot,
+        mirrorUrl: canonicalProjectRemoteUrl(baseUrl, deletion.projectId),
+        mirrorAuth: gitAuthForRemote(canonicalProjectRemoteUrl(baseUrl, deletion.projectId), bearerAuthHeader),
+        sourcePath: deletion.managedPath,
+        workspaceRelativePath: workspaceProjectRelativePath(deletion.projectId, deletion.branchName),
+        planSourcePath,
+        planWorkspaceRelativePath: workspacePlanRelativePath(deletion.projectId, deletion.branchName),
+        tombstoneId: deletion.tombstoneId
+      });
     }
   };
-  const sendWorkspaceReady = () => {
-    const manifestRevision = workspaceManifestRevision.readyRevision();
-    if (!workspaceReady || !manifestRevision) return;
-    try {
-      ws.send(
-        JSON.stringify({
-          type: "workspace_ready",
-          manifestRevision,
-          pendingCheckouts: [...pendingManifestCheckouts.values()].sort(
-            (left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName)
-          ),
-          ...workspaceConvergence.snapshot()
-        })
-      );
-    } catch (error) {
-      process.stderr.write(`[r5d-worker] failed to send workspace readiness: ${error instanceof Error ? error.message : String(error)}
-`);
+  const pruneStaleOuterWorkspaceEntries = (entries) => {
+    const remove = (candidate) => {
+      if (candidate) fs.rmSync(candidate, { recursive: true, force: true });
+    };
+    for (const entry of entries) {
+      if (entry.kind === "branch") {
+        projectWorkspaceState = projectWorkspaceStateStore.beginBranchDeletion({
+          projectId: entry.projectId,
+          branchName: entry.branchName
+        });
+        remove(entry.projectTreePath);
+        remove(entry.planTreePath);
+        continue;
+      }
+      remove(entry.projectTreePath);
+      remove(entry.planTreePath);
+      for (const branch of entry.branches) {
+        remove(branch.projectTreePath);
+        remove(branch.planTreePath);
+      }
     }
   };
-  const targetMayMutateVisibleWorkspace = (target) => target.type === "project" || target.rootProfile === "visible_projects";
-  const armWorkspacePublication = (trigger, options2 = { delayMs: WORKSPACE_PUBLICATION_QUIET_MS }) => {
-    workspaceConvergence.schedule();
-    if (currentWorkerSocket !== ws || ws.readyState !== WebSocket.OPEN) return;
-    sendWorkspaceReady();
-    if (options2.requestId && !explicitWorkspacePublications.schedule({ requestId: options2.requestId, trigger }, pendingPublication?.requestId)) {
-      return;
-    }
-    if (!options2.requestId && explicitWorkspacePublications.hasScheduled()) return;
-    if (workspacePublicationTimer) clearTimeout(workspacePublicationTimer);
-    workspacePublicationTimer = setTimeout(
-      () => {
-        workspacePublicationTimer = void 0;
-        if (options2.requestId) explicitWorkspacePublications.consumeScheduled(options2.requestId);
-        if (currentWorkerSocket !== ws || ws.readyState !== WebSocket.OPEN) return;
-        if (!workspaceReady || !workspaceRemoteUrl) {
-          armWorkspacePublication(trigger, { delayMs: 1e3, ...options2.requestId ? { requestId: options2.requestId } : {} });
-          return;
-        }
-        if (activeWorkspaceIncidentId) {
-          workspaceConvergence.block();
-          sendWorkspaceReady();
-          if (workspacePublicationIncidentAction(options2.requestId) === "defer_automatic") return;
-          if (pendingPublication) {
-            explicitWorkspacePublications.enqueue({ requestId: options2.requestId, trigger }, pendingPublication.requestId);
-            return;
+  const effectiveWorkerProjects = (projects) => {
+    const incomingById = new Map(projects.map((project) => [project.projectId, project]));
+    const pending = new Set(
+      projectWorkspaceState.locallyPendingCreatedBranches.map(({ projectId, branchName }) => projectBranchKey(projectId, branchName))
+    );
+    return projectWorkspaceState.effectiveDesiredProjects.flatMap((layout) => {
+      const incoming = incomingById.get(layout.projectId);
+      if (!incoming) return [];
+      const existing = projectConfigById.get(layout.projectId);
+      const branches = layout.branches.flatMap(({ branchName }) => {
+        const configured = incoming.branches.find((branch) => branch.branchName === branchName);
+        if (configured) return [configured];
+        const retained = existing?.branches.find((branch) => branch.branchName === branchName);
+        if (retained) return [retained];
+        if (!pending.has(projectBranchKey(layout.projectId, branchName))) return [];
+        const branchPath = configuredProjectBranchPath(
+          projectsRoot,
+          { ...incoming, checkoutPathSegments: layout.checkoutPathSegments },
+          branchName
+        );
+        if (!hasProjectWorktree(branchPath)) return [];
+        return [
+          {
+            branchName,
+            sourceBranchName: null,
+            baseCommitHash: runGit(["rev-parse", "HEAD"], { cwd: branchPath })
           }
-          const snapshot2 = workspaceConvergence.snapshot();
-          pendingPublication = {
-            requestId: options2.requestId,
-            trigger,
-            dirtyGeneration: snapshot2.dirtyGeneration,
-            visibleBaselineHead: workspaceConvergence.visibleBaselineHead(),
-            explicit: true,
-            workInFlight: false,
-            requestedAt: Date.now()
-          };
-          try {
-            ws.send(
-              JSON.stringify({
-                type: "workspace_publication_request",
-                requestId: options2.requestId,
-                trigger,
-                dirtyGeneration: snapshot2.dirtyGeneration,
-                localHead: snapshot2.localHead,
-                desiredCanonicalHead: snapshot2.desiredCanonicalHead
-              })
-            );
-          } catch (error) {
-            pendingPublication = void 0;
-            workspaceConvergence.defer();
+        ];
+      });
+      return [{ ...incoming, checkoutPathSegments: [...layout.checkoutPathSegments], branches }];
+    });
+  };
+  const buildWorkspaceMounts = () => {
+    const mounts = [];
+    for (const project of [...projectConfigById.values()].sort((left, right) => left.projectId.localeCompare(right.projectId))) {
+      const projectRoot = configuredProjectRoot(projectsRoot, project);
+      for (const branch of [...project.branches].sort((left, right) => left.branchName.localeCompare(right.branchName))) {
+        const branchPath = configuredProjectBranchPath(projectsRoot, project, branch.branchName);
+        mounts.push({
+          id: projectMountId(project.projectId, branch.branchName),
+          sourcePath: branchPath,
+          workspaceRelativePath: workspaceProjectRelativePath(project.projectId, branch.branchName),
+          sourceMode: "git",
+          hydrateDeletionMode: "git",
+          busy: () => hasProjectWorktree(branchPath) && projectWorktreeOperationInProgress(branchPath)
+        });
+        mounts.push({
+          id: projectPlanMountId(project.projectId, branch.branchName),
+          sourcePath: path.join(planRoot, project.projectId, ...branch.branchName.split("/")),
+          workspaceRelativePath: workspacePlanRelativePath(project.projectId, branch.branchName),
+          sourceMode: "all",
+          hydrateDeletionMode: "all"
+        });
+      }
+      void projectRoot;
+    }
+    mounts.push({
+      id: "workspace-plans",
+      sourcePath: path.join(planRoot, "workspace"),
+      workspaceRelativePath: "workspace-plans",
+      sourceMode: "all",
+      hydrateDeletionMode: "all"
+    });
+    for (const deletion of pendingMirrorDeletes.values()) {
+      mounts.push({
+        id: deletion.id,
+        sourcePath: deletion.sourcePath,
+        workspaceRelativePath: deletion.workspaceRelativePath,
+        sourceMode: "git",
+        hydrateDeletionMode: "git",
+        deleteWhenSourceMissing: true
+      });
+      mounts.push({
+        id: `${deletion.id}:plan`,
+        sourcePath: deletion.planSourcePath,
+        workspaceRelativePath: deletion.planWorkspaceRelativePath,
+        sourceMode: "all",
+        hydrateDeletionMode: "all",
+        deleteWhenSourceMissing: true
+      });
+    }
+    return mounts;
+  };
+  const workspaceLocalHead = () => fs.existsSync(path.join(workspaceShadowRoot, ".git")) && tryGit(["rev-parse", "--verify", "HEAD"], { cwd: workspaceShadowRoot }) ? runGit(["rev-parse", "HEAD"], { cwd: workspaceShadowRoot }) : null;
+  const workspaceGitStatus = () => {
+    try {
+      return runGit(["status", "--porcelain"], { cwd: workspaceShadowRoot });
+    } catch {
+      return "";
+    }
+  };
+  const affectedProjects = (paths) => [
+    ...new Set(
+      paths.flatMap((filePath) => {
+        const match = /^(?:projects|plans)\/([^/]+)\//.exec(filePath);
+        return match?.[1] ? [match[1]] : [];
+      })
+    )
+  ].sort();
+  const ensureConfiguredProjects = () => {
+    for (const project of projectConfigById.values()) {
+      validateProjectId(project.projectId);
+      for (const branch of project.branches) validateBranchName(branch.branchName);
+      const projectRoot = configuredProjectRoot(projectsRoot, project);
+      const configFingerprint = projectWorktreeConfigurationFingerprint({ ...project, gitIdentity: workspaceGitIdentity });
+      const alreadyReady = readyProjectIds.has(project.projectId) && reconciledProjectConfigFingerprints.get(project.projectId) === configFingerprint && project.branches.every(({ branchName }) => hasProjectWorktree(configuredProjectBranchPath(projectsRoot, project, branchName)));
+      if (alreadyReady) {
+        for (const branch of project.branches) pendingCheckouts.delete(projectBranchKey(project.projectId, branch.branchName));
+        continue;
+      }
+      try {
+        const connection = projectConnection(project);
+        const states = ensureProjectWorktrees({
+          projectRoot,
+          primaryBranchName: primaryProjectBranch(project),
+          branches: project.branches,
+          originUrl: connection.originUrl,
+          originAuth: connection.originAuth,
+          mirrorUrl: connection.mirrorUrl,
+          mirrorAuth: connection.mirrorAuth,
+          credentialHelper: connection.credentialHelper,
+          gitIdentity: workspaceGitIdentity
+        });
+        readyProjectIds.add(project.projectId);
+        reconciledProjectConfigFingerprints.set(project.projectId, configFingerprint);
+        for (const state of states) {
+          pendingCheckouts.delete(projectBranchKey(project.projectId, state.branchName));
+          const key = projectBranchKey(project.projectId, state.branchName);
+          if (!lastObservedProjectHeads.has(key)) lastObservedProjectHeads.set(key, state.mirrorHead);
+          if ((state.ahead ?? 0) > 0) {
             process.stderr.write(
-              `[r5d-worker] failed to request blocked workspace publication authority: ${error instanceof Error ? error.message : String(error)}
+              `[r5d-worker] ${project.projectPath}/${state.branchName} is ${state.ahead} commit(s) ahead of origin; switching workers may require publishing or reconciling those commits
 `
             );
-            armWorkspacePublication(trigger, { delayMs: 1e3, requestId: options2.requestId });
           }
-          return;
         }
-        if (pendingPublication) {
-          armWorkspacePublication(trigger, { delayMs: 1e3, ...options2.requestId ? { requestId: options2.requestId } : {} });
-          return;
+      } catch (error) {
+        readyProjectIds.delete(project.projectId);
+        reconciledProjectConfigFingerprints.delete(project.projectId);
+        for (const branch of project.branches) {
+          pendingCheckouts.set(projectBranchKey(project.projectId, branch.branchName), {
+            projectId: project.projectId,
+            branchName: branch.branchName
+          });
         }
-        const snapshot = workspaceConvergence.snapshot();
-        const requestId = options2.requestId ?? crypto.randomUUID();
-        pendingPublication = {
-          requestId,
-          trigger,
-          dirtyGeneration: snapshot.dirtyGeneration,
-          visibleBaselineHead: workspaceConvergence.visibleBaselineHead(),
-          explicit: options2.requestId !== void 0,
-          workInFlight: false,
-          requestedAt: Date.now()
-        };
+        process.stderr.write(
+          `[r5d-worker] failed to initialize project ${project.projectPath}: ${error instanceof Error ? error.message : String(error)}
+`
+        );
+      }
+    }
+  };
+  const collectAheadOfOriginBranches = () => {
+    const aheadBranches = [];
+    for (const project of projectConfigById.values()) {
+      if (!readyProjectIds.has(project.projectId) || project.branches.length === 0) continue;
+      const connection = projectConnection(project);
+      const primaryPath = configuredProjectBranchPath(projectsRoot, project, primaryProjectBranch(project));
+      if (!tryGit(["fetch", "--no-recurse-submodules", "--prune", "origin", "+refs/heads/*:refs/remotes/origin/*"], {
+        cwd: primaryPath,
+        auth: connection.originAuth
+      })) {
+        process.stderr.write(`[r5d-worker] could not refresh origin divergence for ${project.projectPath}
+`);
+      }
+      for (const branch of project.branches) {
+        const branchPath = configuredProjectBranchPath(projectsRoot, project, branch.branchName);
+        if (!hasProjectWorktree(branchPath)) continue;
         try {
-          ws.send(
-            JSON.stringify({
-              type: "workspace_publication_request",
-              requestId,
-              trigger,
-              dirtyGeneration: snapshot.dirtyGeneration,
-              localHead: snapshot.localHead,
-              desiredCanonicalHead: snapshot.desiredCanonicalHead
-            })
-          );
+          let ahead = 0;
+          const originRef = `refs/remotes/origin/${branch.branchName}`;
+          if (tryGit(["show-ref", "--verify", "--quiet", originRef], { cwd: branchPath })) {
+            const counts = runGit(["rev-list", "--left-right", "--count", `${originRef}...HEAD`], { cwd: branchPath }).split(/\s+/).map(Number);
+            ahead = Number.isSafeInteger(counts[1]) ? counts[1] : 0;
+          } else if (tryGit(["cat-file", "-e", `${branch.baseCommitHash}^{commit}`], { cwd: branchPath })) {
+            const count = Number(runGit(["rev-list", "--count", `${branch.baseCommitHash}..HEAD`], { cwd: branchPath }));
+            ahead = Number.isSafeInteger(count) ? count : 0;
+          }
+          if (ahead > 0) aheadBranches.push({ projectId: project.projectId, branchName: branch.branchName, ahead });
         } catch (error) {
-          pendingPublication = void 0;
-          workspaceConvergence.defer();
           process.stderr.write(
-            `[r5d-worker] failed to request workspace publication: ${error instanceof Error ? error.message : String(error)}
+            `[r5d-worker] could not measure origin divergence for ${project.projectPath}/${branch.branchName}: ${error instanceof Error ? error.message : String(error)}
 `
           );
-          armWorkspacePublication(trigger, { delayMs: 1e3, ...options2.requestId ? { requestId: options2.requestId } : {} });
         }
-      },
-      Math.max(0, options2.delayMs)
+      }
+    }
+    return aheadBranches.sort(
+      (left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName)
     );
-    workspacePublicationTimer.unref();
   };
-  const markWorkspaceDirty = (trigger, force = false) => {
-    workspaceConvergence.markDirty();
-    armWorkspacePublication(trigger, { delayMs: force ? 0 : WORKSPACE_PUBLICATION_QUIET_MS });
-  };
-  const convergeAvailableWorkspaceHead = async () => {
-    if (pendingWorkspaceHead === void 0 || !workspaceReady || !workspaceRemoteUrl || activeWorkspaceIncidentId || workspaceHeadConvergenceInFlight) {
-      return;
+  const pushChangedProjectHeads = (activeMountIds, publishedHead) => {
+    const active = new Set(activeMountIds);
+    for (const project of projectConfigById.values()) {
+      if (!readyProjectIds.has(project.projectId)) continue;
+      const changed = /* @__PURE__ */ new Set();
+      for (const branch of project.branches) {
+        if (!active.has(projectMountId(project.projectId, branch.branchName))) continue;
+        const branchPath = configuredProjectBranchPath(projectsRoot, project, branch.branchName);
+        if (!hasProjectWorktree(branchPath)) continue;
+        const head = runGit(["rev-parse", "HEAD"], { cwd: branchPath });
+        if (lastObservedProjectHeads.get(projectBranchKey(project.projectId, branch.branchName)) !== head) {
+          changed.add(branch.branchName);
+        }
+      }
+      if (changed.size === 0) continue;
+      const connection = projectConnection(project);
+      const results = pushProjectMirrorHeads({
+        projectRoot: configuredProjectRoot(projectsRoot, project),
+        branchNames: project.branches.map(({ branchName }) => branchName),
+        mirrorUrl: connection.mirrorUrl,
+        mirrorAuth: connection.mirrorAuth,
+        onlyBranches: changed
+      });
+      for (const result of results) {
+        if (result.pushed) lastObservedProjectHeads.set(projectBranchKey(project.projectId, result.branchName), result.head);
+      }
     }
-    const advertisedHead = pendingWorkspaceHead;
-    pendingWorkspaceHead = void 0;
-    workspaceConvergence.observeCanonicalHead(advertisedHead);
-    workspaceHeadConvergenceInFlight = true;
-    try {
-      const snapshot = workspaceConvergence.snapshot();
-      const hydrateVisible = !pendingPublication && snapshot.dirtyGeneration === snapshot.publishedGeneration;
-      const converged = await workspaceSyncSingleFlight.runExclusive(
-        () => convergeWorkspaceHead(workspaceSyncInput({ type: "inbound_head", detail: advertisedHead ?? "unborn" }), {
-          hydrateVisible
-        })
-      );
-      workspaceConvergence.observeCanonicalHead(converged.canonicalHead);
-      if (converged.hydrated) workspaceConvergence.setLocalHead(converged.localHead);
-      if (hydrateVisible && converged.localChanges) {
-        markWorkspaceDirty({ type: "periodic", detail: "inbound overlap retained for next publication" });
+    const publishedTombstoneIds = [
+      ...new Set(
+        [...pendingMirrorDeletes.values()].flatMap(
+          (deletion) => active.has(deletion.id) && deletion.tombstoneId ? [deletion.tombstoneId] : []
+        )
+      )
+    ];
+    if (publishedTombstoneIds.length > 0) {
+      projectWorkspaceState = projectWorkspaceStateStore.recordTreePublication({
+        tombstoneIds: publishedTombstoneIds,
+        publishedHead
+      });
+    }
+    for (const [key, deletion] of pendingMirrorDeletes) {
+      if (!active.has(deletion.id)) continue;
+      if (!deletion.projectDeleted) {
+        deleteProjectMirrorBranch({
+          gitDirectory: deletion.gitDirectory,
+          branchName: deletion.branchName,
+          mirrorUrl: deletion.mirrorUrl,
+          mirrorAuth: deletion.mirrorAuth
+        });
       }
-      sendWorkspaceReady();
-    } catch (error) {
-      pendingWorkspaceHead = advertisedHead;
-      process.stderr.write(
-        `[r5d-worker] failed to fetch available workspace head: ${error instanceof Error ? error.message : String(error)}
+      if (deletion.tombstoneId && !deletion.projectDeleted) {
+        projectWorkspaceState = projectWorkspaceStateStore.recordMirrorRefDeletion({
+          tombstoneId: deletion.tombstoneId,
+          branchName: deletion.branchName
+        });
+      }
+      pendingMirrorDeletes.delete(key);
+      lastObservedProjectHeads.delete(key);
+    }
+  };
+  const refreshProjectHeadsAfterInboundWorkspace = () => {
+    for (const project of projectConfigById.values()) {
+      if (!readyProjectIds.has(project.projectId) || project.branches.length === 0) continue;
+      try {
+        const connection = projectConnection(project);
+        const refreshed = fastForwardProjectHeadsFromMirror({
+          projectRoot: configuredProjectRoot(projectsRoot, project),
+          primaryBranchName: primaryProjectBranch(project),
+          branchNames: project.branches.map(({ branchName }) => branchName),
+          mirrorUrl: connection.mirrorUrl,
+          mirrorAuth: connection.mirrorAuth
+        });
+        for (const state of refreshed) {
+          lastObservedProjectHeads.set(
+            projectBranchKey(project.projectId, state.branchName),
+            state.fastForwarded && state.mirrorHead ? state.mirrorHead : state.previousHead
+          );
+        }
+      } catch (error) {
+        process.stderr.write(
+          `[r5d-worker] failed to refresh project heads after workspace update: ${error instanceof Error ? error.message : String(error)}
 `
-      );
-    } finally {
-      workspaceHeadConvergenceInFlight = false;
-      heartbeatBusyGrace = grantWorkerHeartbeatBusyGrace(lastServerHeartbeatAt, heartbeatBusyGrace);
-      if (pendingWorkspaceHead !== void 0) {
-        setTimeout(() => void convergeAvailableWorkspaceHead(), 1e3).unref();
+        );
       }
     }
   };
-  const manifestCheckoutKey = (projectId, branchName) => `${projectId}\0${branchName}`;
-  const allManifestCheckouts = () => [...manifestByProjectId.values()].flatMap(
-    (manifest) => manifest.branches.map((branchName) => ({ projectId: manifest.projectId, branchName }))
-  );
-  const resolveMessageTarget = (target) => resolveWorkerSessionTarget({
-    target,
-    baseUrl,
-    token,
-    projectsRoot,
-    syncRoot,
-    workspaceShadowRoot,
-    manifestByProjectId
+  const reseedProjectHeadsAfterWorkspaceReset = () => {
+    for (const project of projectConfigById.values()) {
+      if (!readyProjectIds.has(project.projectId)) continue;
+      const connection = projectConnection(project);
+      const states = ensureProjectWorktrees({
+        projectRoot: configuredProjectRoot(projectsRoot, project),
+        primaryBranchName: primaryProjectBranch(project),
+        branches: project.branches,
+        originUrl: connection.originUrl,
+        originAuth: connection.originAuth,
+        mirrorUrl: connection.mirrorUrl,
+        mirrorAuth: connection.mirrorAuth,
+        credentialHelper: connection.credentialHelper,
+        gitIdentity: workspaceGitIdentity
+      });
+      for (const state of states) {
+        lastObservedProjectHeads.set(projectBranchKey(project.projectId, state.branchName), state.head);
+      }
+    }
+  };
+  const mapWorkspaceGitResult = (attemptId, trigger, result) => ({
+    type: "workspace_sync",
+    attemptId,
+    workerLabel: label,
+    trigger,
+    outcome: result.outcome === "pushed" ? "published" : result.outcome,
+    startingHead: result.startingHead,
+    ...result.localHead ? { localHead: result.localHead } : {},
+    ...result.publishedHead ? { publishedHead: result.publishedHead } : {},
+    rebaseCount: result.rebaseCount,
+    diffSizeBytes: result.diffSizeBytes,
+    gitStatus: workspaceGitStatus(),
+    affectedProjects: affectedProjects(result.affectedPaths),
+    affectedPaths: result.affectedPaths,
+    discardedPaths: [],
+    localChangesDiscarded: false,
+    ...result.conflictPaths ? { conflictPaths: result.conflictPaths } : {},
+    ...result.conflictSnapshotRefs ? { conflictSnapshotRefs: result.conflictSnapshotRefs } : {},
+    ...result.error ? { error: result.error } : {}
   });
-  const ensureVisibleWorktrees = (targets, options2 = {}) => {
-    const created = [];
-    for (const target of targets) {
-      const manifest = manifestByProjectId.get(target.projectId);
-      const key = manifestCheckoutKey(target.projectId, target.branchName);
-      if (!manifest || !manifest.branches.includes(target.branchName)) {
-        pendingManifestCheckouts.delete(key);
-        continue;
+  const failedWorkspaceSyncResult = (attemptId, trigger, error) => ({
+    type: "workspace_sync",
+    attemptId,
+    workerLabel: label,
+    trigger,
+    outcome: "failed",
+    startingHead: workspaceLocalHead(),
+    ...workspaceLocalHead() ? { localHead: workspaceLocalHead() } : {},
+    rebaseCount: 0,
+    diffSizeBytes: 0,
+    gitStatus: workspaceGitStatus(),
+    affectedProjects: [],
+    affectedPaths: [],
+    discardedPaths: [],
+    localChangesDiscarded: false,
+    error: error instanceof Error ? error.message : String(error)
+  });
+  const performWorkspaceSync = async (input) => {
+    if (!workspaceRemoteUrl || !workspaceGitIdentity) throw new Error("Worker workspace configuration has not been received");
+    const mounts = buildWorkspaceMounts();
+    const remoteAuth = gitAuthForRemote(workspaceRemoteUrl, bearerAuthHeader);
+    const credentialHelper = credentialHelperForRemote(workspaceRemoteUrl, bearerAuthHeader);
+    if (input.resetToCanonical) {
+      const reset = resetWorkspaceGit({
+        workspacePath: workspaceShadowRoot,
+        remoteUrl: workspaceRemoteUrl,
+        remoteAuth,
+        credentialHelper,
+        gitIdentity: workspaceGitIdentity,
+        mounts
+      });
+      reseedProjectHeadsAfterWorkspaceReset();
+      return {
+        type: "workspace_sync",
+        attemptId: input.attemptId,
+        workerLabel: label,
+        trigger: input.trigger,
+        outcome: "reset",
+        startingHead: reset.startingHead,
+        ...reset.localHead ? { localHead: reset.localHead } : {},
+        ...reset.remoteHead ? { publishedHead: reset.remoteHead } : {},
+        rebaseCount: 0,
+        diffSizeBytes: 0,
+        gitStatus: workspaceGitStatus(),
+        affectedProjects: affectedProjects(reset.discardedPaths),
+        affectedPaths: reset.discardedPaths,
+        discardedPaths: reset.discardedPaths,
+        localChangesDiscarded: reset.discardedPaths.length > 0 || reset.startingHead !== reset.remoteHead
+      };
+    }
+    const outerRemediation = input.trigger.type === "remediation" || input.trigger.type === "remediation_confirm";
+    const result = await synchronizeWorkspaceGit({
+      attemptId: input.attemptId,
+      workerLabel: label,
+      workspacePath: workspaceShadowRoot,
+      remoteUrl: workspaceRemoteUrl,
+      remoteAuth,
+      credentialHelper,
+      gitIdentity: workspaceGitIdentity,
+      mounts,
+      commitDetail: input.confirmationReason ?? input.trigger.detail,
+      allowLargeDiff: input.confirmedLargeDiff,
+      skipMountMirror: outerRemediation,
+      skipMountHydration: outerRemediation,
+      afterWorkspacePublished: outerRemediation ? void 0 : ({ activeMountIds, publishedHead }) => {
+        pushChangedProjectHeads(activeMountIds, publishedHead);
       }
-      const projectRoot = projectRootFor(projectsRoot, manifest.projectId, manifestByProjectId);
-      const branchPath = path.join(projectRoot, target.branchName);
-      const existed = hasNormalVisibleGitDir(branchPath);
-      const remote = visibleCheckoutRemoteFor({
-        baseUrl,
-        token,
-        projectId: manifest.projectId,
-        branchName: target.branchName,
-        manifest
+    });
+    if (["no_change", "updated", "pushed"].includes(result.outcome) && !outerRemediation) {
+      refreshProjectHeadsAfterInboundWorkspace();
+    }
+    return mapWorkspaceGitResult(input.attemptId, input.trigger, result);
+  };
+  const sendWorkspaceSyncResult = (requestId, result) => {
+    try {
+      sendWorkerMessage(ws, {
+        type: "workspace_sync_result",
+        ...requestId ? { requestId } : {},
+        result
       });
-      ensureVisibleGitCheckout({
-        projectRoot,
-        branchName: target.branchName,
-        remoteUrl: remote.remoteUrl,
-        remoteAuth: gitAuthForRemote(remote.remoteUrl, remote.authHeader),
-        persistentAuthHeader: remote.persistAuth ? remote.authHeader : null,
-        defaultBranch: manifest.defaultBranch || "main",
-        reconcileExistingOrigin: remote.reconcileExistingOrigin,
-        requireRemoteBranch: remote.requireRemoteBranch,
-        requiredBaseCommit: remote.requiredBaseCommit,
-        allowRequiredRemoteMigration: !(options2.strictCanonicalRevalidation && remote.requiredBaseCommit),
-        clearPersistentAuth: !remote.persistAuth
+    } catch (error) {
+      process.stderr.write(
+        `[r5d-worker] failed to send workspace sync result: ${error instanceof Error ? error.message : String(error)}
+`
+      );
+    }
+  };
+  const runWorkspaceSync = async (input) => {
+    const attemptId = input.attemptId ?? crypto.randomUUID();
+    const requestedAt = Date.now();
+    let queueEnteredAt = requestedAt;
+    let syncStartedAt = requestedAt;
+    workspaceSyncRequestsInFlight += 1;
+    let result;
+    try {
+      result = await workspaceSyncSingleFlight.runExclusive(async () => {
+        queueEnteredAt = Date.now();
+        syncStartedAt = Date.now();
+        try {
+          return await performWorkspaceSync({
+            attemptId,
+            trigger: input.trigger,
+            confirmedLargeDiff: input.confirmedLargeDiff,
+            confirmationReason: input.confirmationReason,
+            resetToCanonical: input.resetToCanonical
+          });
+        } catch (error) {
+          return failedWorkspaceSyncResult(attemptId, input.trigger, error);
+        }
       });
-      if (!existed) created.push(target);
+    } finally {
+      workspaceSyncRequestsInFlight -= 1;
     }
-    return created;
+    const finishedAt = Date.now();
+    result = {
+      ...result,
+      telemetry: {
+        totalMs: finishedAt - requestedAt,
+        queueMs: queueEnteredAt - requestedAt,
+        prepareMs: 0,
+        synchronizeMs: finishedAt - syncStartedAt
+      }
+    };
+    if (input.sendResult !== false) sendWorkspaceSyncResult(input.requestId, result);
+    return result;
   };
-  const schedulePendingManifestCheckoutHydration = (delayMs = 0) => {
-    if (workspaceManifestHydrationTimer || workspaceManifestHydrationInFlight || pendingManifestCheckouts.size === 0 || currentWorkerSocket !== ws || ws.readyState !== WebSocket.OPEN) {
+  const scheduleAutomaticWorkspaceSync = (trigger, delayMs = WORKSPACE_GIT_QUIET_MS) => {
+    pendingAutomaticTrigger = trigger;
+    if (!workspaceConfigured || activeWorkspaceIncidentId || currentWorkerSocket !== ws || ws.readyState !== WebSocket.OPEN || automaticSyncInFlight) {
       return;
     }
-    workspaceManifestHydrationTimer = setTimeout(
+    if (workspaceAutomaticTimer) clearTimeout(workspaceAutomaticTimer);
+    workspaceAutomaticTimer = setTimeout(
       () => {
-        workspaceManifestHydrationTimer = void 0;
-        if (!workspaceReady || !workspaceRemoteUrl || activeWorkspaceIncidentId || pendingPublication || pendingManifestCheckouts.size === 0 || currentWorkerSocket !== ws || ws.readyState !== WebSocket.OPEN) {
-          if (pendingManifestCheckouts.size > 0 && currentWorkerSocket === ws && ws.readyState === WebSocket.OPEN) {
-            schedulePendingManifestCheckoutHydration(1e3);
-          }
-          return;
-        }
-        workspaceManifestHydrationInFlight = true;
-        void workspaceSyncSingleFlight.runExclusive(async () => {
-          if (!workspaceReady || activeWorkspaceIncidentId || currentWorkerSocket !== ws || ws.readyState !== WebSocket.OPEN) {
-            return;
-          }
-          const targets = [...pendingManifestCheckouts.values()];
-          ensureVisibleWorktrees(targets, { strictCanonicalRevalidation: true });
-          for (const target of targets) {
-            const manifest = manifestByProjectId.get(target.projectId);
-            if (!manifest || !manifest.branches.includes(target.branchName)) continue;
-            const branchPath = path.join(projectRootFor(projectsRoot, target.projectId, manifestByProjectId), target.branchName);
-            if (hasNormalVisibleGitDir(branchPath)) {
-              pendingManifestCheckouts.delete(manifestCheckoutKey(target.projectId, target.branchName));
-            }
+        workspaceAutomaticTimer = void 0;
+        const scheduledTrigger = pendingAutomaticTrigger;
+        pendingAutomaticTrigger = void 0;
+        if (!scheduledTrigger || !workspaceConfigured || activeWorkspaceIncidentId || currentWorkerSocket !== ws) return;
+        automaticSyncInFlight = true;
+        void runWorkspaceSync({ trigger: scheduledTrigger }).then((result) => {
+          if (result.outcome === "failed") {
+            pendingAutomaticTrigger = scheduledTrigger;
           }
-        }).then(() => sendWorkspaceReady()).catch((error) => {
-          process.stderr.write(
-            `[r5d-worker] pending manifest checkout hydration failed: ${error instanceof Error ? error.message : String(error)}
-`
-          );
         }).finally(() => {
-          workspaceManifestHydrationInFlight = false;
+          automaticSyncInFlight = false;
           heartbeatBusyGrace = grantWorkerHeartbeatBusyGrace(lastServerHeartbeatAt, heartbeatBusyGrace);
-          if (pendingManifestCheckouts.size > 0) schedulePendingManifestCheckoutHydration(1e3);
+          if (pendingAutomaticTrigger && !activeWorkspaceIncidentId) {
+            scheduleAutomaticWorkspaceSync(pendingAutomaticTrigger, WORKSPACE_GIT_QUIET_MS);
+          }
         });
       },
       Math.max(0, delayMs)
     );
-    workspaceManifestHydrationTimer.unref();
+    workspaceAutomaticTimer.unref();
   };
-  const runRequestedWorkspaceSync = async (authority, trigger, overrides = {}) => {
-    const requestedAt = Date.now();
-    let queueEnteredAt = requestedAt;
-    let prepareStartedAt = requestedAt;
-    let synchronizeStartedAt = requestedAt;
-    let synchronizeFinishedAt = requestedAt;
+  const markWorkspaceDirty = (trigger, force = false) => {
+    scheduleAutomaticWorkspaceSync(trigger, force ? 0 : WORKSPACE_GIT_QUIET_MS);
+  };
+  const targetMayMutateVisibleWorkspace = (target) => target.type === "project" || target.rootProfile === "visible_projects";
+  const resolveMessageTarget = (target) => resolveWorkerSessionTarget({
+    target,
+    projectsRoot,
+    workspaceShadowRoot,
+    projectConfigById
+  });
+  const configureWorkerWorkspace = async (message) => {
     workspaceSyncRequestsInFlight += 1;
     try {
-      let pendingTargets = [];
-      const result = await workspaceSyncSingleFlight.runExclusive(async () => {
-        queueEnteredAt = Date.now();
-        const shouldEnsureCheckouts = !overrides.skipVisibleMirror && !overrides.resetToCanonical;
-        const syncProjects = workspaceProjectsForSync([...manifestByProjectId.values()], trigger);
-        if (!workspaceRemoteUrl) throw new Error("Worker workspace manifest has not been received");
-        const allowedCheckoutKeys = new Set(
-          syncProjects.flatMap((project) => project.branches.map((branchName) => manifestCheckoutKey(project.projectId, branchName)))
-        );
-        const scopedPendingTargets = [...pendingManifestCheckouts.values()].filter(
-          (target) => allowedCheckoutKeys.has(manifestCheckoutKey(target.projectId, target.branchName))
+      return await workspaceSyncSingleFlight.runExclusive(async () => {
+        workspaceConfigured = false;
+        configureGitHubAuth(message.githubCredential);
+        visibleGitIdentity = message.gitIdentity;
+        workspaceGitIdentity = message.gitIdentity;
+        workspaceRemoteUrl = message.workspaceRemoteUrl;
+        projectWorkspaceState = projectWorkspaceStateStore.reconcile({
+          desiredProjects: message.projects
+        });
+        pruneAuthoritativelyDesiredBranchDeletions(pendingMirrorDeletes, message.projects);
+        const effectiveProjects = effectiveWorkerProjects(message.projects).map((project) => ({
+          ...project,
+          branches: project.branches.filter(({ branchName }) => !pendingMirrorDeletes.has(projectBranchKey(project.projectId, branchName)))
+        }));
+        const nextProjectConfigById = new Map(effectiveProjects.map((project) => [project.projectId, project]));
+        for (const existingProject of projectConfigById.values()) {
+          const nextProject = nextProjectConfigById.get(existingProject.projectId);
+          if (!nextProject) {
+            stageProjectDeletion(existingProject);
+            continue;
+          }
+          const nextBranches = new Set(nextProject.branches.map(({ branchName }) => branchName));
+          for (const existingBranch of existingProject.branches) {
+            if (!nextBranches.has(existingBranch.branchName)) {
+              stageProjectBranchDeletion(existingProject, existingBranch.branchName, false);
+            }
+          }
+        }
+        projectConfigById.clear();
+        for (const project of effectiveProjects) projectConfigById.set(project.projectId, project);
+        const configuredKeys = new Set(
+          effectiveProjects.flatMap((project) => project.branches.map(({ branchName }) => projectBranchKey(project.projectId, branchName)))
         );
-        prepareStartedAt = Date.now();
-        let checkoutTargets = [];
-        if (shouldEnsureCheckouts) {
-          checkoutTargets = workspaceSyncCheckoutTargets({
-            projects: syncProjects,
-            pendingTargets: scopedPendingTargets,
-            includeAllManifestCheckouts: trigger.type === "connect",
-            ...trigger.canonicalCheckoutOnly && trigger.projectId && trigger.branchName ? { canonicalCheckoutOnly: { projectId: trigger.projectId, branchName: trigger.branchName } } : {}
-          });
+        for (const key of pendingCheckouts.keys()) {
+          if (!configuredKeys.has(key)) pendingCheckouts.delete(key);
         }
-        pendingTargets = shouldEnsureCheckouts ? scopedPendingTargets : [];
-        const createdCheckouts = ensureVisibleWorktrees(checkoutTargets, {
-          strictCanonicalRevalidation: true
-        });
-        const newVisibleCheckoutByKey = /* @__PURE__ */ new Map();
-        for (const target of [...overrides.newVisibleCheckouts ?? [], ...createdCheckouts, ...pendingTargets]) {
-          const key = manifestCheckoutKey(target.projectId, target.branchName);
-          if (allowedCheckoutKeys.has(key)) newVisibleCheckoutByKey.set(key, target);
+        for (const projectId of [...readyProjectIds]) {
+          if (!projectConfigById.has(projectId)) readyProjectIds.delete(projectId);
         }
-        const newVisibleCheckouts = [...newVisibleCheckoutByKey.values()];
-        const input = workspaceSyncInput(trigger, {
-          ...overrides,
-          ...shouldEnsureCheckouts && !trigger.canonicalCheckoutOnly ? { visibleBaselineHead: workspaceConvergence.visibleBaselineHead() } : {},
-          ...newVisibleCheckouts.length > 0 ? { newVisibleCheckouts } : {}
+        const remoteAuth = gitAuthForRemote(message.workspaceRemoteUrl, bearerAuthHeader);
+        const credentialHelper = credentialHelperForRemote(message.workspaceRemoteUrl, bearerAuthHeader);
+        ensureWorkspaceGitClone({
+          workspacePath: workspaceShadowRoot,
+          remoteUrl: message.workspaceRemoteUrl,
+          remoteAuth,
+          credentialHelper,
+          gitIdentity: message.gitIdentity
         });
-        synchronizeStartedAt = Date.now();
-        let synchronized;
-        try {
-          synchronized = await synchronizeWorkspace(input);
-        } finally {
-          synchronizeFinishedAt = Date.now();
+        pruneStaleOuterWorkspaceEntries(projectWorkspaceStateStore.discoverStaleOuterEntries(workspaceShadowRoot));
+        stageDurableWorkspaceDeletions();
+        const mountsBeforeGit = buildWorkspaceMounts();
+        hydrateWorkspaceGitMounts(
+          workspaceShadowRoot,
+          mountsBeforeGit.filter((mount) => !mount.deleteWhenSourceMissing && !fs.existsSync(mount.sourcePath))
+        );
+        ensureConfiguredProjects();
+        let result = await performWorkspaceSync({
+          attemptId: crypto.randomUUID(),
+          trigger: { type: "connect" }
+        });
+        if (["no_change", "published", "updated", "conflict_reset", "reset"].includes(result.outcome)) {
+          const staleAfterInbound = projectWorkspaceStateStore.discoverStaleOuterEntries(workspaceShadowRoot);
+          if (staleAfterInbound.length > 0) {
+            pruneStaleOuterWorkspaceEntries(staleAfterInbound);
+            stageDurableWorkspaceDeletions();
+            result = await performWorkspaceSync({
+              attemptId: crypto.randomUUID(),
+              trigger: { type: "connect" }
+            });
+          }
         }
-        return synchronized;
-      });
-      const completedAt = Date.now();
-      const resultWithTelemetry = {
-        ...result,
-        telemetry: {
-          totalMs: completedAt - requestedAt,
-          queueMs: queueEnteredAt - requestedAt,
-          prepareMs: synchronizeStartedAt - prepareStartedAt,
-          synchronizeMs: synchronizeFinishedAt - synchronizeStartedAt
+        const publishedHead = result.publishedHead ?? result.localHead ?? result.startingHead;
+        if (publishedHead && ["no_change", "published", "updated", "conflict_reset", "reset"].includes(result.outcome)) {
+          const layoutCleanupIds = projectWorkspaceState.pendingTreeDeletions.flatMap(
+            (deletion) => deletion.kind === "project" && !deletion.projectDeleted ? [deletion.tombstoneId] : []
+          );
+          if (layoutCleanupIds.length > 0) {
+            projectWorkspaceState = projectWorkspaceStateStore.recordTreePublication({
+              tombstoneIds: layoutCleanupIds,
+              publishedHead
+            });
+          }
         }
-      };
-      if (resultWithTelemetry.outcome === "no_change" || resultWithTelemetry.outcome === "published" || resultWithTelemetry.outcome === "updated" || resultWithTelemetry.outcome === "conflict_reset") {
-        for (const target of pendingTargets) {
-          const key = manifestCheckoutKey(target.projectId, target.branchName);
-          if (pendingManifestCheckouts.get(key) === target) pendingManifestCheckouts.delete(key);
+        workspaceConfigured = true;
+        const pending = [...pendingCheckouts.values()].sort(
+          (left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName)
+        );
+        return { result, pending, aheadOfOriginBranches: collectAheadOfOriginBranches() };
+      });
+    } catch (error) {
+      workspaceConfigured = fs.existsSync(path.join(workspaceShadowRoot, ".git"));
+      for (const project of message.projects) {
+        for (const branch of project.branches) {
+          pendingCheckouts.set(projectBranchKey(project.projectId, branch.branchName), {
+            projectId: project.projectId,
+            branchName: branch.branchName
+          });
         }
       }
-      sendWorkspaceSyncResult(authority, resultWithTelemetry);
-      return resultWithTelemetry;
-    } catch (error) {
-      const completedAt = Date.now();
-      const result = {
-        type: "workspace_sync",
-        attemptId: overrides.attemptId ?? crypto.randomUUID(),
-        workerLabel: label,
-        trigger,
-        outcome: "failed",
-        startingHead: null,
-        rebaseCount: 0,
-        diffSizeBytes: 0,
-        gitStatus: "",
-        affectedProjects: [],
-        affectedPaths: [],
-        discardedPaths: [],
-        localChangesDiscarded: false,
-        telemetry: {
-          totalMs: completedAt - requestedAt,
-          queueMs: queueEnteredAt - requestedAt,
-          prepareMs: Math.max(0, synchronizeStartedAt - prepareStartedAt),
-          synchronizeMs: Math.max(0, synchronizeFinishedAt - synchronizeStartedAt)
-        },
-        error: error instanceof Error ? error.message : String(error)
+      return {
+        result: failedWorkspaceSyncResult(crypto.randomUUID(), { type: "connect" }, error),
+        pending: [...pendingCheckouts.values()],
+        aheadOfOriginBranches: []
       };
-      sendWorkspaceSyncResult(authority, result);
-      return result;
     } finally {
       workspaceSyncRequestsInFlight -= 1;
     }
@@ -2843,17 +3067,26 @@ async function startWorker(options) {
   const handleGracefulShutdown = () => {
     if (shutdownAfterClose) return;
     shutdownAfterClose = true;
-    void waitForWorkspacePublicationOnShutdown({
-      snapshot: () => workspaceConvergence.snapshot(),
-      forcePublication: () => armWorkspacePublication({ type: "manual", detail: "graceful worker shutdown" }, { delayMs: 0 })
-    }).then((outcome) => {
-      process.stdout.write(`[r5d-worker] graceful workspace publication ${outcome}
-`);
+    if (workspaceAutomaticTimer) {
+      clearTimeout(workspaceAutomaticTimer);
+      workspaceAutomaticTimer = void 0;
+    }
+    void (async () => {
+      if (workspaceConfigured && !activeWorkspaceIncidentId) {
+        await runWorkspaceSync({
+          trigger: { type: "manual", detail: "graceful worker shutdown" }
+        });
+      }
+      await workspaceSyncSingleFlight.afterCurrent();
       if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
         ws.close(1e3, "Worker shutting down");
       } else {
         process.exit(0);
       }
+    })().catch((error) => {
+      process.stderr.write(`[r5d-worker] graceful workspace sync failed: ${error instanceof Error ? error.message : String(error)}
+`);
+      ws.close(1011, "Worker shutdown sync failed");
     });
   };
   process.on("SIGTERM", handleGracefulShutdown);
@@ -2886,11 +3119,7 @@ async function startWorker(options) {
         r5dctlVersion: readInstalledCliVersion("r5dctl"),
         capabilities: {
           updateClis: true,
-          canonicalResolverCheckout: true,
           browserPortForwarding: true,
-          globalWorkspaceSyncLeaseV1: true,
-          eventualWorkspaceSyncV1: true,
-          workspaceIncidentCandidatePinV1: true,
           execStdinV1: true
         },
         projectRoot: projectsRoot,
@@ -2917,302 +3146,153 @@ async function startWorker(options) {
       if (message.type === "connected") {
         return;
       }
-      if (message.type === "workspace_manifest") {
-        const revisionToken = workspaceManifestRevision.begin(message.revision);
-        workspaceReady = false;
-        const manifestFilesystem = inspectWorkspaceManifestFilesystem({
-          projectsRoot,
-          workspaceShadowRoot,
-          projects: message.projects
-        });
-        const completed = await workspaceSyncSingleFlight.runExclusive(async () => {
-          if (!workspaceManifestRevision.isCurrent(revisionToken)) return false;
-          const firstBootstrap = manifestFilesystem.firstBootstrap;
-          configureGitHubAuth(message.githubCredential);
-          visibleGitIdentity = message.gitIdentity;
-          workspaceRemoteUrl = message.workspaceRemoteUrl;
-          manifestByProjectId.clear();
-          for (const project of message.projects) manifestByProjectId.set(project.projectId, project);
-          const currentCheckouts = allManifestCheckouts();
-          const currentCheckoutKeys = new Set(
-            currentCheckouts.map(({ projectId, branchName }) => manifestCheckoutKey(projectId, branchName))
-          );
-          for (const key of pendingManifestCheckouts.keys()) {
-            if (!currentCheckoutKeys.has(key)) pendingManifestCheckouts.delete(key);
-          }
-          for (const checkout of currentCheckouts) {
-            const key = manifestCheckoutKey(checkout.projectId, checkout.branchName);
-            const branchPath = path.join(projectRootFor(projectsRoot, checkout.projectId, manifestByProjectId), checkout.branchName);
-            if (!hasNormalVisibleGitDir(branchPath)) pendingManifestCheckouts.set(key, checkout);
-          }
-          if (!workspaceManifestRevision.isCurrent(revisionToken)) return false;
-          const created = firstBootstrap ? ensureVisibleWorktrees(currentCheckouts, { strictCanonicalRevalidation: true }) : [];
-          if (!workspaceManifestRevision.isCurrent(revisionToken)) return false;
-          const bootstrapped = await convergeWorkspaceHead(workspaceSyncInput({ type: "connect" }, { newVisibleCheckouts: created }), {
-            // An existing checkout becomes routable after a fetch. Its
-            // visible tree converges asynchronously; first bootstrap alone
-            // must materialize the canonical snapshot before readiness.
-            // Re-check the incident immediately before convergence so a
-            // concurrently delivered fence forces fetch-only behavior.
-            hydrateVisible: firstBootstrap && !activeWorkspaceIncidentId
-          });
-          if (!workspaceManifestRevision.isCurrent(revisionToken)) return false;
-          if (workspaceBootstrapEstablishesVisibleBaseline({
-            hydrated: bootstrapped.hydrated,
-            firstBootstrap,
-            incidentActive: Boolean(activeWorkspaceIncidentId),
-            currentLocalHead: workspaceConvergence.snapshot().localHead,
-            currentVisibleBaselineHead: workspaceConvergence.visibleBaselineHead()
-          })) {
-            workspaceConvergence.setLocalHead(bootstrapped.localHead);
-          }
-          workspaceConvergence.observeCanonicalHead(bootstrapped.canonicalHead);
-          for (const checkout of currentCheckouts) {
-            const manifest = manifestByProjectId.get(checkout.projectId);
-            if (!manifest) continue;
-            const branchPath = path.join(projectRootFor(projectsRoot, checkout.projectId, manifestByProjectId), checkout.branchName);
-            if (hasNormalVisibleGitDir(branchPath)) {
-              pendingManifestCheckouts.delete(manifestCheckoutKey(checkout.projectId, checkout.branchName));
-            }
-          }
-          process.stdout.write(`[r5d-worker] workspace manifest: ${message.projects.length} projects
-`);
-          return true;
+      if (message.type === "workspace_config") {
+        const configured = await configureWorkerWorkspace(message);
+        sendWorkerMessage(ws, {
+          type: "workspace_configured",
+          requestId: message.requestId,
+          result: configured.result,
+          pendingCheckouts: configured.pending,
+          aheadOfOriginBranches: configured.aheadOfOriginBranches
         });
-        if (!completed || !workspaceManifestRevision.complete(revisionToken)) return;
-        workspaceReady = true;
-        sendWorkspaceReady();
-        schedulePendingManifestCheckoutHydration();
-        if (!workspaceSafetyScan) {
-          workspaceSafetyScan = setInterval(() => {
-            if (!workspaceReady || !workspaceRemoteUrl || activeWorkspaceIncidentId || pendingPublication || workspaceSafetyScanInFlight) {
-              return;
-            }
-            workspaceSafetyScanInFlight = true;
-            void (async () => {
-              const before = workspaceConvergence.snapshot();
-              const hydrateVisible = before.dirtyGeneration === before.publishedGeneration;
-              const converged = await workspaceSyncSingleFlight.runExclusive(
-                () => convergeWorkspaceHead(workspaceSyncInput({ type: "periodic", detail: "idle convergence scan" }), {
-                  hydrateVisible
-                })
-              );
-              workspaceConvergence.observeCanonicalHead(converged.canonicalHead);
-              if (converged.hydrated) workspaceConvergence.setLocalHead(converged.localHead);
-              if (converged.localChanges && hydrateVisible) {
-                markWorkspaceDirty({ type: "periodic", detail: "idle safety scan" });
-              }
-              sendWorkspaceReady();
-            })().catch((error) => {
-              process.stderr.write(
-                `[r5d-worker] idle workspace safety scan failed: ${error instanceof Error ? error.message : String(error)}
+        process.stdout.write(
+          `[r5d-worker] workspace configured: ${message.projects.length} project(s), ${configured.pending.length} pending checkout(s)
 `
-              );
-            }).finally(() => {
-              workspaceSafetyScanInFlight = false;
-              heartbeatBusyGrace = grantWorkerHeartbeatBusyGrace(lastServerHeartbeatAt, heartbeatBusyGrace);
-            });
-          }, WORKSPACE_IDLE_SAFETY_SCAN_MS);
-          workspaceSafetyScan.unref();
+        );
+        if (!workspacePeriodicTimer) {
+          workspacePeriodicTimer = setInterval(() => {
+            scheduleAutomaticWorkspaceSync({ type: "periodic", detail: "periodic workspace reconciliation" }, 0);
+          }, WORKSPACE_GIT_PERIODIC_MS);
+          workspacePeriodicTimer.unref();
         }
-        pendingWorkspaceHead = workspaceConvergence.snapshot().desiredCanonicalHead;
-        void convergeAvailableWorkspaceHead();
-        if (workspaceConvergence.snapshot().dirtyGeneration > workspaceConvergence.snapshot().publishedGeneration) {
-          armWorkspacePublication({ type: "periodic", detail: "resume dirty generation after reconnect" }, { delayMs: 0 });
+        if (pendingAutomaticTrigger && !activeWorkspaceIncidentId) {
+          scheduleAutomaticWorkspaceSync(pendingAutomaticTrigger, 0);
         }
         return;
       }
       if (message.type === "sync_workspace") {
-        await runRequestedWorkspaceSync(
-          {
-            requestId: message.requestId,
-            intentId: message.intentId,
-            leaseEpoch: message.leaseEpoch,
-            leaseToken: message.leaseToken
-          },
-          message.trigger,
-          {
-            attemptId: message.attemptId,
-            quarantineRef: message.quarantineRef,
-            confirmedLargeDiff: message.confirmedLargeDiff,
-            confirmationReason: message.confirmationReason,
-            expectedIncidentCandidateHead: message.expectedIncidentCandidateHead,
-            resetToCanonical: message.resetToCanonical,
-            skipVisibleMirror: message.skipVisibleMirror
-          }
-        );
-        return;
-      }
-      if (message.type === "workspace_head_available") {
-        workspaceConvergence.observeCanonicalHead(message.canonicalHead);
-        pendingWorkspaceHead = message.canonicalHead;
-        sendWorkspaceReady();
-        void convergeAvailableWorkspaceHead();
-        return;
-      }
-      if (message.type === "workspace_publication_now") {
-        armWorkspacePublication(message.trigger, { delayMs: 0, requestId: message.requestId });
+        await runWorkspaceSync({
+          requestId: message.requestId,
+          attemptId: message.attemptId,
+          trigger: message.trigger,
+          confirmedLargeDiff: message.confirmedLargeDiff,
+          confirmationReason: message.confirmationReason,
+          resetToCanonical: message.resetToCanonical
+        });
         return;
       }
-      if (message.type === "workspace_publication_authority") {
-        const publication = pendingPublication;
-        if (!publication || publication.requestId !== message.requestId) {
-          process.stderr.write(`[r5d-worker] ignoring publication authority for unknown request ${message.requestId}
-`);
-          return;
-        }
-        if (message.status !== "granted") {
-          pendingPublication = void 0;
-          workspaceConvergence.observeCanonicalHead(message.canonicalHead);
-          const applyBlockedResponse = message.status === "blocked" && workspaceIncidentOrdering.permitsBlockedResponse(message.incidentId);
-          if (applyBlockedResponse) {
-            workspaceConvergence.block();
-            if (message.incidentId) activeWorkspaceIncidentId = message.incidentId;
-          } else {
-            workspaceConvergence.resetTransientPublicationState();
-            workspaceConvergence.observeIncidentState(Boolean(activeWorkspaceIncidentId));
-            if (message.status === "busy") {
-              armWorkspacePublication(publication.trigger, {
-                delayMs: message.retryAfterMs ?? 1e3,
-                requestId: publication.requestId
-              });
-            } else if (!activeWorkspaceIncidentId) {
-              const explicit = explicitWorkspacePublications.next();
-              if (explicit) {
-                armWorkspacePublication(explicit.trigger, { delayMs: 0, requestId: explicit.requestId });
-              } else if (workspaceConvergence.snapshot().dirtyGeneration > workspaceConvergence.snapshot().publishedGeneration) {
-                armWorkspacePublication(publication.trigger, { delayMs: 0 });
-              }
-            }
-          }
-          sendWorkspaceReady();
-          return;
-        }
-        publication.attemptId = message.attemptId;
-        publication.authorityToken = message.authorityToken;
-        publication.workInFlight = true;
-        pendingPublication = publication;
-        if (currentWorkerSocket !== ws) {
-          publication.workInFlight = false;
-          workspaceConvergence.resetTransientPublicationState();
-          return;
-        }
-        workspaceConvergence.beginPreparing();
-        sendWorkspaceReady();
-        let prepareStartedAt = Date.now();
-        let synchronizeStartedAt = prepareStartedAt;
-        let synchronizeStarted = false;
-        let result;
+      if (message.type === "create_project_branch") {
         try {
-          result = await workspaceSyncSingleFlight.runExclusive(async () => {
-            prepareStartedAt = Date.now();
-            const pendingTargets = [...pendingManifestCheckouts.values()];
-            const createdCheckouts = ensureVisibleWorktrees(pendingTargets, { strictCanonicalRevalidation: true });
-            synchronizeStartedAt = Date.now();
-            synchronizeStarted = true;
-            const prepared = await synchronizeWorkspace(
-              workspaceSyncInput(publication.trigger, {
-                attemptId: message.attemptId,
-                quarantineRef: message.quarantineRef,
-                expectedCanonicalHead: message.expectedHead,
-                visibleBaselineHead: publication.visibleBaselineHead,
-                newVisibleCheckouts: [...createdCheckouts, ...pendingTargets]
-              })
-            );
-            for (const target of pendingTargets) {
-              pendingManifestCheckouts.delete(manifestCheckoutKey(target.projectId, target.branchName));
+          projectWorkspaceState = projectWorkspaceStateStore.recordPendingCreatedBranch({
+            projectId: message.projectId,
+            branchName: message.targetBranch
+          });
+          const created = await workspaceSyncSingleFlight.runMutation(() => {
+            const project = projectConfigById.get(message.projectId);
+            if (!project) throw new Error(`Project ${message.projectId} is missing from the worker workspace configuration`);
+            if (!readyProjectIds.has(project.projectId)) {
+              throw new Error(`Project ${project.projectPath} is not initialized on this worker`);
+            }
+            if (!project.branches.some(({ branchName }) => branchName === message.sourceBranch)) {
+              throw new Error(`Source branch ${message.sourceBranch} is missing from the worker workspace configuration`);
+            }
+            if (project.branches.some(({ branchName }) => branchName === message.targetBranch)) {
+              throw new Error(`Project branch ${message.targetBranch} already exists`);
+            }
+            const createdBranch = createLinkedProjectBranch({
+              projectRoot: configuredProjectRoot(projectsRoot, project),
+              sourceBranchName: message.sourceBranch,
+              branchName: message.targetBranch
+            });
+            projectConfigById.set(project.projectId, {
+              ...project,
+              branches: [
+                ...project.branches,
+                {
+                  branchName: message.targetBranch,
+                  sourceBranchName: message.sourceBranch,
+                  baseCommitHash: createdBranch.baseCommitHash
+                }
+              ]
+            });
+            lastObservedProjectHeads.set(projectBranchKey(project.projectId, message.targetBranch), null);
+            return createdBranch;
+          });
+          sendWorkerMessage(ws, {
+            type: "operation_result",
+            requestId: message.requestId,
+            result: {
+              type: "create_project_branch",
+              branchName: message.targetBranch,
+              baseCommitHash: created.baseCommitHash
             }
-            return prepared.outcome === "updated" ? { ...prepared, outcome: "no_change" } : prepared;
           });
-        } catch (error) {
-          if (!synchronizeStarted) synchronizeStartedAt = Date.now();
-          result = {
-            type: "workspace_sync",
-            attemptId: message.attemptId,
-            workerLabel: label,
-            trigger: publication.trigger,
-            outcome: "failed",
-            startingHead: message.expectedHead,
-            expectedHead: message.expectedHead,
-            rebaseCount: 0,
-            diffSizeBytes: 0,
-            gitStatus: "",
-            affectedProjects: [],
-            affectedPaths: [],
-            discardedPaths: [],
-            localChangesDiscarded: false,
-            error: error instanceof Error ? error.message : String(error)
-          };
-        }
-        const finishedAt = Date.now();
-        result = {
-          ...result,
-          dirtyGeneration: publication.dirtyGeneration,
-          telemetry: workspacePublicationTelemetry({
-            requestedAt: publication.requestedAt,
-            prepareStartedAt,
-            synchronizeStartedAt,
-            finishedAt
-          })
-        };
-        workspaceConvergence.beginSubmitting();
-        sendWorkspaceReady();
-        try {
-          ws.send(
-            JSON.stringify({
-              type: "workspace_publication_result",
-              requestId: publication.requestId,
-              attemptId: message.attemptId,
-              authorityToken: message.authorityToken,
-              dirtyGeneration: publication.dirtyGeneration,
-              result
-            })
+          markWorkspaceDirty(
+            {
+              type: "manual",
+              projectId: message.projectId,
+              branchName: message.targetBranch,
+              detail: `created project branch from ${message.sourceBranch}`
+            },
+            true
           );
         } catch (error) {
-          workspaceConvergence.resetTransientPublicationState();
-          throw error;
-        } finally {
-          publication.workInFlight = false;
-          if (currentWorkerSocket !== ws) workspaceConvergence.resetTransientPublicationState();
+          sendWorkerMessage(ws, {
+            type: "operation_result",
+            requestId: message.requestId,
+            error: error instanceof Error ? error.message : String(error)
+          });
         }
         return;
       }
-      if (message.type === "workspace_publication_completed") {
-        const publication = pendingPublication;
-        if (!publication || publication.requestId !== message.requestId || publication.attemptId !== message.attemptId) {
-          process.stderr.write(`[r5d-worker] ignoring completion for unknown publication ${message.requestId}
-`);
-          return;
-        }
-        pendingPublication = void 0;
-        workspaceConvergence.observeCanonicalHead(message.canonicalHead);
-        if (message.status === "published" || message.status === "no_change") {
-          workspaceConvergence.complete({
-            generation: Math.min(message.publishedGeneration ?? publication.dirtyGeneration, publication.dirtyGeneration),
-            canonicalHead: message.canonicalHead,
-            published: true
+      if (message.type === "delete_project_branch") {
+        try {
+          const deletionKey = projectBranchKey(message.projectId, message.branchName);
+          projectWorkspaceState = projectWorkspaceStateStore.beginBranchDeletion({
+            projectId: message.projectId,
+            branchName: message.branchName
           });
-        } else if (message.status === "blocked" && workspaceIncidentOrdering.permitsBlockedResponse(message.incidentId)) {
-          if (message.visibleBaselineHead) workspaceConvergence.setVisibleBaselineHead(message.visibleBaselineHead);
-          workspaceConvergence.block();
-          if (message.incidentId) activeWorkspaceIncidentId = message.incidentId;
-        } else {
-          workspaceConvergence.resetTransientPublicationState();
-          workspaceConvergence.observeIncidentState(Boolean(activeWorkspaceIncidentId));
-        }
-        sendWorkspaceReady();
-        const explicit = message.status === "retry" && publication.explicit ? { requestId: publication.requestId, trigger: publication.trigger } : explicitWorkspacePublications.next();
-        if (explicit) {
-          armWorkspacePublication(explicit.trigger, {
-            delayMs: message.retryAfterMs ?? 0,
-            requestId: explicit.requestId
+          await workspaceSyncSingleFlight.runMutation(() => {
+            const project = projectConfigById.get(message.projectId);
+            if (!project) throw new Error(`Project ${message.projectId} is missing from the worker workspace configuration`);
+            if (pendingMirrorDeletes.has(deletionKey)) return;
+            stageProjectBranchDeletion(project, message.branchName, true);
+            projectConfigById.set(project.projectId, {
+              ...project,
+              branches: project.branches.filter(({ branchName }) => branchName !== message.branchName)
+            });
+          });
+          const result = await runWorkspaceSync({
+            trigger: {
+              type: "manual",
+              projectId: message.projectId,
+              branchName: message.branchName,
+              detail: "deleted project branch"
+            },
+            confirmedLargeDiff: true,
+            confirmationReason: "explicit project branch deletion",
+            sendResult: false
+          });
+          if (result.outcome === "failed" || result.outcome === "conflict_blocked" || result.outcome === "large_diff_blocked") {
+            throw new Error(result.error ?? `Project branch deletion workspace sync ended with ${result.outcome}`);
+          }
+          if (pendingMirrorDeletes.has(deletionKey)) {
+            throw new Error("Project branch deletion did not remove the hidden mirror ref");
+          }
+          sendWorkerMessage(ws, {
+            type: "operation_result",
+            requestId: message.requestId,
+            result: {
+              type: "delete_project_branch",
+              branchName: message.branchName
+            }
+          });
+        } catch (error) {
+          sendWorkerMessage(ws, {
+            type: "operation_result",
+            requestId: message.requestId,
+            error: error instanceof Error ? error.message : String(error)
           });
-        } else if (message.status === "retry" || message.status === "failed" || workspaceConvergence.snapshot().dirtyGeneration > workspaceConvergence.snapshot().publishedGeneration) {
-          armWorkspacePublication(publication.trigger, { delayMs: message.retryAfterMs ?? 1e3 });
-        }
-        if (message.canonicalHead !== workspaceConvergence.snapshot().localHead) {
-          pendingWorkspaceHead = message.canonicalHead;
-          void convergeAvailableWorkspaceHead();
         }
         return;
       }
@@ -3243,31 +3323,11 @@ async function startWorker(options) {
         return;
       }
       if (message.type === "workspace_incident_updated") {
-        workspaceIncidentOrdering.observe(message);
         const previousIncidentId = activeWorkspaceIncidentId;
-        const nextIncidentId = applyWorkspaceIncidentUpdate(activeWorkspaceIncidentId, message);
-        if (message.incidentId && (previousIncidentId === message.incidentId || nextIncidentId === message.incidentId) && message.originWorkerLabel === label && message.visibleBaselineHead) {
-          workspaceConvergence.setVisibleBaselineHead(message.visibleBaselineHead);
-        }
-        activeWorkspaceIncidentId = nextIncidentId;
-        const releasedHead = releasePendingWorkspaceHead(
-          previousIncidentId,
-          activeWorkspaceIncidentId,
-          message.status === "resolved" || message.status === "confirmed" || message.status === "reset" ? message.incidentId : null
-        );
-        workspaceConvergence.observeIncidentState(Boolean(activeWorkspaceIncidentId));
-        if (releasedHead.fetchAuthoritativeHead) {
-          pendingWorkspaceHead = workspaceConvergence.snapshot().desiredCanonicalHead;
-          void convergeAvailableWorkspaceHead();
+        activeWorkspaceIncidentId = applyWorkspaceIncidentUpdate(activeWorkspaceIncidentId, message);
+        if (previousIncidentId && !activeWorkspaceIncidentId && (message.status === "resolved" || message.status === "confirmed" || message.status === "reset")) {
+          scheduleAutomaticWorkspaceSync(pendingAutomaticTrigger ?? { type: "periodic", detail: "resume after workspace incident" }, 0);
         }
-        const explicit = !activeWorkspaceIncidentId ? explicitWorkspacePublications.next() : void 0;
-        if (explicit) {
-          armWorkspacePublication(explicit.trigger, { delayMs: 0, requestId: explicit.requestId });
-        } else if (!activeWorkspaceIncidentId && workspaceConvergence.snapshot().dirtyGeneration > workspaceConvergence.snapshot().publishedGeneration) {
-          armWorkspacePublication({ type: "periodic", detail: "resume after workspace incident" }, { delayMs: 0 });
-        }
-        if (!activeWorkspaceIncidentId) schedulePendingManifestCheckoutHydration();
-        sendWorkspaceReady();
         return;
       }
       if (message.type === "exec_terminal_ack") {
@@ -3458,7 +3518,7 @@ async function startWorker(options) {
         const activePty = activePtys.get(message.ptyId);
         closePty(message);
         if (activePty && targetMayMutateVisibleWorkspace(activePty.target)) {
-          armWorkspacePublication({ type: "process_terminal", detail: `pty ${message.ptyId} closed` }, { delayMs: 0 });
+          markWorkspaceDirty({ type: "process_terminal", detail: `pty ${message.ptyId} closed` }, true);
         }
         return;
       }
@@ -3555,7 +3615,7 @@ async function startWorker(options) {
         });
         return;
       }
-      if (message.type === "read" || message.type === "write" || message.type === "edit" || message.type === "grep" || message.type === "find" || message.type === "ls" || message.type === "view_file_bytes") {
+      if (message.type === "read" || message.type === "write" || message.type === "edit" || message.type === "grep" || message.type === "find" || message.type === "ls" || message.type === "view_file_bytes" || message.type === "code_list" || message.type === "code_read") {
         try {
           const result = await runWorkspaceCommand(message.target, workspaceSyncSingleFlight, async () => {
             const resolvedTarget = resolveMessageTarget(message.target);
@@ -3615,20 +3675,13 @@ async function startWorker(options) {
     process.off("SIGTERM", handleGracefulShutdown);
     process.off("SIGINT", handleGracefulShutdown);
     stopHeartbeatWatchdog();
-    if (workspacePublicationTimer) {
-      clearTimeout(workspacePublicationTimer);
-      workspacePublicationTimer = void 0;
-    }
-    if (!pendingPublication?.workInFlight) {
-      workspaceConvergence.resetTransientPublicationState();
-    }
-    if (workspaceSafetyScan) {
-      clearInterval(workspaceSafetyScan);
-      workspaceSafetyScan = void 0;
+    if (workspaceAutomaticTimer) {
+      clearTimeout(workspaceAutomaticTimer);
+      workspaceAutomaticTimer = void 0;
     }
-    if (workspaceManifestHydrationTimer) {
-      clearTimeout(workspaceManifestHydrationTimer);
-      workspaceManifestHydrationTimer = void 0;
+    if (workspacePeriodicTimer) {
+      clearInterval(workspacePeriodicTimer);
+      workspacePeriodicTimer = void 0;
     }
     if (terminalReplayTimer) {
       clearInterval(terminalReplayTimer);
@@ -3721,24 +3774,22 @@ if (isCliEntrypoint()) {
 export {
   describeWorkerSessionTarget,
   editWorkerTextFile,
-  ensureVisibleGitCheckout,
   findWorkerFiles,
   githubCliEnv,
   grepWorkerFiles,
   isArtifactEnvPath,
+  listWorkerCodeDirectory,
   listWorkerDirectory,
   prepareArtifactEnvForShell,
   prepareBuiltInToolPathsForTarget,
   preparePlanEnvForShell,
   prepareShellEnvForTarget,
+  readWorkerCodeFile,
   readWorkerImageFile,
   readWorkerTextFile,
   resolveHostShell,
   resolveWorkerFilePath,
   resolveWorkerSessionTarget,
   syncSessionArtifacts,
-  visibleCheckoutGitTestHarness,
-  visibleCheckoutRemoteFor,
-  workspaceSyncCheckoutTargets,
   writeWorkerTextFile
 };