@ricsam/r5d-worker 0.0.14 → 0.0.16

package/dist/cjs/main.cjs

@@ -32,7 +32,9 @@ __export(main_exports, {
   ensureVisibleGitCheckout: () => ensureVisibleGitCheckout,
   isArtifactEnvPath: () => isArtifactEnvPath,
   prepareArtifactEnvForShell: () => prepareArtifactEnvForShell,
+  preparePlanEnvForShell: () => preparePlanEnvForShell,
   resolveProjectFilePath: () => resolveProjectFilePath,
+  syncProjectPlans: () => syncProjectPlans,
   syncSessionArtifacts: () => syncSessionArtifacts
 });
 module.exports = __toCommonJS(main_exports);
@@ -56,7 +58,7 @@ const LEGACY_BUILD_IT_NOW_REMOTE_NAME = "build-it-now";
 const activeProcesses = /* @__PURE__ */ new Map();
 const cancelledProcessRuns = /* @__PURE__ */ new Set();
 const activePtys = /* @__PURE__ */ new Map();
-const branchLocks = /* @__PURE__ */ new Map();
+let currentWorkerSocket = null;
 let containerRegistryCredential = null;
 let visibleGitIdentity = null;
 function defaultConfigPath() {
@@ -71,6 +73,9 @@ function defaultSyncRoot() {
 function defaultArtifactRoot() {
   return import_node_path.default.join(import_node_os.default.homedir(), ".r5d", "artifacts");
 }
+function defaultPlanRoot() {
+  return import_node_path.default.join(import_node_os.default.homedir(), ".r5d", "plans");
+}
 function printHelp() {
   process.stdout.write(`Usage:
   r5d-worker start --label <label> [--base-url <url>] [--token <token>] [--api-key <key>]
@@ -85,6 +90,7 @@ Options:
   --project-root <dir>  Override projects checkout root (default ~/.r5d/projects)
   --sync-root <dir>     Override r5d internal sync git root (default ~/.r5d/sync)
   --artifact-root <dir> Override session artifact root (default from R5D_ARTIFACTS_ROOT or ~/.r5d/artifacts)
+  --plan-root <dir>     Override synced plan root (default from R5D_PLANS_ROOT or ~/.r5d/plans)
   -v, --version         Show r5d-worker version
   -h, --help            Show this help
 `);
@@ -206,6 +212,11 @@ function parseArgs(argv) {
       options.artifactRoot = artifactRoot;
       continue;
     }
+    const planRoot = readOption("--plan-root");
+    if (planRoot !== void 0) {
+      options.planRoot = planRoot;
+      continue;
+    }
     rest.push(arg);
   }
   if (options.version) {
@@ -249,6 +260,7 @@ async function readResponseText(response) {
   }
 }
 const R5D_ARTIFACTS_DIR_REF = "$R5D_ARTIFACTS_DIR";
+const R5D_PLANS_DIR_ENV = "R5D_PLANS_DIR";
 function validateArtifactSessionId(sessionId) {
   if (!/^(migration-)?[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(sessionId)) {
     throw new Error(`Invalid artifact session id: ${sessionId}`);
@@ -257,7 +269,7 @@ function validateArtifactSessionId(sessionId) {
 function assertInsideRoot(rootPath, candidatePath, label) {
   const relative = import_node_path.default.relative(rootPath, candidatePath);
   if (relative === ".." || relative.startsWith(`..${import_node_path.default.sep}`) || import_node_path.default.isAbsolute(relative)) {
-    throw new Error(`${label} escapes the artifact directory`);
+    throw new Error(`${label} escapes sync directory`);
   }
 }
 function sessionArtifactDir(artifactRoot, sessionId) {
@@ -272,6 +284,23 @@ function artifactEnv(artifactRoot, sessionId) {
     R5D_ARTIFACTS_DIR: sessionArtifactDir(artifactRoot, sessionId)
   };
 }
+function projectPlanDir(planRoot, projectId, branchName) {
+  validateProjectId(projectId);
+  validateBranchName(branchName);
+  return import_node_path.default.join(planRoot, projectId, branchName);
+}
+function planEnv(planRoot, projectId, branchName, activePlanId) {
+  const plansDir = projectPlanDir(planRoot, projectId, branchName);
+  const env = {
+    [R5D_PLANS_DIR_ENV]: plansDir
+  };
+  if (activePlanId) {
+    validatePlanId(activePlanId);
+    env.R5D_ACTIVE_PLAN_ID = activePlanId;
+    env.R5D_ACTIVE_PLAN_FILE = import_node_path.default.join(plansDir, `${activePlanId}.plan.md`);
+  }
+  return env;
+}
 function isArtifactEnvPath(filePath) {
   return filePath === R5D_ARTIFACTS_DIR_REF || filePath.startsWith(`${R5D_ARTIFACTS_DIR_REF}/`);
 }
@@ -284,99 +313,150 @@ function artifactManifestUrl(baseUrl, projectId, branchName, sessionId) {
 function artifactDownloadUrl(baseUrl, projectId, branchName, sessionId, filename) {
   return new URL(`${artifactApiBasePath(projectId, branchName, sessionId)}/${encodeURIComponent(filename)}`, baseUrl);
 }
+function planApiBasePath(projectId, branchName) {
+  return `/preview-api/${encodeURIComponent(projectId)}/${encodeURIComponent(branchName)}/plans`;
+}
+function planManifestUrl(baseUrl, projectId, branchName) {
+  return new URL(planApiBasePath(projectId, branchName), baseUrl);
+}
+function planDownloadUrl(baseUrl, projectId, branchName, filename) {
+  return new URL(`${planApiBasePath(projectId, branchName)}/${encodeURIComponent(filename)}`, baseUrl);
+}
 function sha256Path(filePath) {
   return (0, import_node_crypto.createHash)("sha256").update(import_node_fs.default.readFileSync(filePath)).digest("hex");
 }
-function parseSessionArtifactManifest(value) {
-  if (!value || typeof value !== "object" || !Array.isArray(value.artifacts)) {
-    throw new Error("Artifact manifest response is invalid");
+function parseRemoteFileManifest(value, collectionKey, label) {
+  if (!value || typeof value !== "object" || !Array.isArray(value[collectionKey])) {
+    throw new Error(`${label} manifest response is invalid`);
   }
-  return value.artifacts.map((entry) => {
+  return value[collectionKey].map((entry) => {
     if (!entry || typeof entry !== "object") {
-      throw new Error("Artifact manifest entry is invalid");
+      throw new Error(`${label} manifest entry is invalid`);
     }
-    const artifact = entry;
-    if (typeof artifact.filename !== "string" || artifact.filename.includes("/") || artifact.filename.includes("\\")) {
-      throw new Error("Artifact manifest entry has an invalid filename");
+    const file = entry;
+    if (typeof file.filename !== "string" || file.filename.includes("/") || file.filename.includes("\\")) {
+      throw new Error(`${label} manifest entry has an invalid filename`);
     }
-    if (typeof artifact.size !== "number" || !Number.isFinite(artifact.size) || artifact.size < 0) {
-      throw new Error(`Artifact manifest entry has an invalid size: ${artifact.filename}`);
+    if (typeof file.size !== "number" || !Number.isFinite(file.size) || file.size < 0) {
+      throw new Error(`${label} manifest entry has an invalid size: ${file.filename}`);
     }
-    if (typeof artifact.sha256 !== "string" || !/^[a-f0-9]{64}$/i.test(artifact.sha256)) {
-      throw new Error(`Artifact manifest entry has an invalid sha256: ${artifact.filename}`);
+    if (typeof file.sha256 !== "string" || !/^[a-f0-9]{64}$/i.test(file.sha256)) {
+      throw new Error(`${label} manifest entry has an invalid sha256: ${file.filename}`);
     }
     return {
-      filename: artifact.filename,
-      size: artifact.size,
-      sha256: artifact.sha256.toLowerCase()
+      filename: file.filename,
+      size: file.size,
+      sha256: file.sha256.toLowerCase()
     };
   });
 }
-async function fetchSessionArtifactManifest(input) {
-  const response = await fetch(artifactManifestUrl(input.baseUrl, input.projectId, input.branchName, input.sessionId), {
+async function fetchRemoteFileManifest(input) {
+  const response = await fetch(input.url, {
     headers: {
       Authorization: `Bearer ${input.token}`
     }
   });
   if (!response.ok) {
     const detail = (await readResponseText(response)).trim();
-    throw new Error(`Failed to fetch artifact manifest (${response.status})${detail ? `: ${detail}` : ""}`);
+    throw new Error(`Failed to fetch ${input.label} manifest (${response.status})${detail ? `: ${detail}` : ""}`);
   }
-  return parseSessionArtifactManifest(await response.json());
+  return parseRemoteFileManifest(await response.json(), input.collectionKey, input.label);
 }
-async function downloadSessionArtifact(input) {
-  const targetDir = sessionArtifactDir(input.artifactRoot, input.sessionId);
-  const targetPath = import_node_path.default.join(targetDir, input.artifact.filename);
-  assertInsideRoot(targetDir, targetPath, "Artifact path");
-  const response = await fetch(
-    artifactDownloadUrl(input.baseUrl, input.projectId, input.branchName, input.sessionId, input.artifact.filename),
-    {
-      headers: {
-        Authorization: `Bearer ${input.token}`
-      }
+async function downloadRemoteSyncedFile(input) {
+  const targetPath = import_node_path.default.join(input.targetDir, input.file.filename);
+  assertInsideRoot(input.targetDir, targetPath, input.label);
+  const response = await fetch(input.url, {
+    headers: {
+      Authorization: `Bearer ${input.token}`
     }
-  );
+  });
   if (!response.ok) {
     const detail = (await readResponseText(response)).trim();
-    throw new Error(`Failed to download artifact ${input.artifact.filename} (${response.status})${detail ? `: ${detail}` : ""}`);
+    throw new Error(`Failed to download ${input.label} ${input.file.filename} (${response.status})${detail ? `: ${detail}` : ""}`);
   }
   const buffer = Buffer.from(await response.arrayBuffer());
   const receivedHash = (0, import_node_crypto.createHash)("sha256").update(buffer).digest("hex");
-  if (receivedHash !== input.artifact.sha256) {
-    throw new Error(`Downloaded artifact ${input.artifact.filename} failed sha256 verification`);
+  if (receivedHash !== input.file.sha256) {
+    throw new Error(`Downloaded ${input.label} ${input.file.filename} failed sha256 verification`);
   }
-  if (buffer.length !== input.artifact.size) {
-    throw new Error(`Downloaded artifact ${input.artifact.filename} has unexpected size`);
+  if (buffer.length !== input.file.size) {
+    throw new Error(`Downloaded ${input.label} ${input.file.filename} has unexpected size`);
   }
   const tempPath = `${targetPath}.${process.pid}.${Date.now()}.tmp`;
   import_node_fs.default.writeFileSync(tempPath, buffer);
   import_node_fs.default.renameSync(tempPath, targetPath);
 }
-async function syncSessionArtifacts(input) {
-  const targetDir = sessionArtifactDir(input.artifactRoot, input.sessionId);
-  import_node_fs.default.mkdirSync(targetDir, { recursive: true });
-  const artifacts = await fetchSessionArtifactManifest(input);
-  const manifestNames = new Set(artifacts.map((artifact) => artifact.filename));
-  for (const artifact of artifacts) {
-    const localPath = import_node_path.default.join(targetDir, artifact.filename);
-    assertInsideRoot(targetDir, localPath, "Artifact path");
+async function syncRemoteFileSet(input) {
+  import_node_fs.default.mkdirSync(input.targetDir, { recursive: true });
+  const manifestNames = new Set(input.files.map((file) => file.filename));
+  for (const file of input.files) {
+    const localPath = import_node_path.default.join(input.targetDir, file.filename);
+    assertInsideRoot(input.targetDir, localPath, input.label);
     if (import_node_fs.default.existsSync(localPath)) {
       const stats = import_node_fs.default.statSync(localPath);
-      if (stats.isFile() && stats.size === artifact.size && sha256Path(localPath) === artifact.sha256) {
+      if (stats.isFile() && stats.size === file.size && sha256Path(localPath) === file.sha256) {
         continue;
       }
       import_node_fs.default.rmSync(localPath, { recursive: true, force: true });
     }
-    await downloadSessionArtifact({ ...input, artifact });
+    await input.download(file);
   }
-  for (const localName of import_node_fs.default.readdirSync(targetDir)) {
+  for (const localName of import_node_fs.default.readdirSync(input.targetDir)) {
     if (!manifestNames.has(localName)) {
-      const localPath = import_node_path.default.join(targetDir, localName);
-      assertInsideRoot(targetDir, localPath, "Artifact path");
+      const localPath = import_node_path.default.join(input.targetDir, localName);
+      assertInsideRoot(input.targetDir, localPath, input.label);
       import_node_fs.default.rmSync(localPath, { recursive: true, force: true });
     }
   }
-  return targetDir;
+  return input.targetDir;
+}
+async function fetchSessionArtifactManifest(input) {
+  return fetchRemoteFileManifest({
+    url: artifactManifestUrl(input.baseUrl, input.projectId, input.branchName, input.sessionId),
+    token: input.token,
+    collectionKey: "artifacts",
+    label: "artifact"
+  });
+}
+async function syncSessionArtifacts(input) {
+  const targetDir = sessionArtifactDir(input.artifactRoot, input.sessionId);
+  const artifacts = await fetchSessionArtifactManifest(input);
+  return syncRemoteFileSet({
+    targetDir,
+    files: artifacts,
+    label: "Artifact path",
+    download: (artifact) => downloadRemoteSyncedFile({
+      url: artifactDownloadUrl(input.baseUrl, input.projectId, input.branchName, input.sessionId, artifact.filename),
+      token: input.token,
+      targetDir,
+      file: artifact,
+      label: "artifact"
+    })
+  });
+}
+async function fetchProjectPlanManifest(input) {
+  return fetchRemoteFileManifest({
+    url: planManifestUrl(input.baseUrl, input.projectId, input.branchName),
+    token: input.token,
+    collectionKey: "plans",
+    label: "plan"
+  });
+}
+async function syncProjectPlans(input) {
+  const targetDir = projectPlanDir(input.planRoot, input.projectId, input.branchName);
+  const plans = await fetchProjectPlanManifest(input);
+  return syncRemoteFileSet({
+    targetDir,
+    files: plans,
+    label: "Plan path",
+    download: (plan) => downloadRemoteSyncedFile({
+      url: planDownloadUrl(input.baseUrl, input.projectId, input.branchName, plan.filename),
+      token: input.token,
+      targetDir,
+      file: plan,
+      label: "plan"
+    })
+  });
 }
 async function resolveArtifactEnvFilePath(input) {
   if (!isArtifactEnvPath(input.filePath)) {
@@ -435,6 +515,19 @@ async function prepareArtifactEnvForShell(input) {
     R5D_ARTIFACTS_DIR: artifactsDir
   };
 }
+async function preparePlanEnvForShell(input) {
+  try {
+    await syncProjectPlans(input);
+  } catch (error) {
+    process.stderr.write(
+      `[r5d-worker] plan sync skipped for ${input.projectId}/${input.branchName}: ${error instanceof Error ? error.message : String(error)}
+`
+    );
+  }
+  const plansDir = projectPlanDir(input.planRoot, input.projectId, input.branchName);
+  import_node_fs.default.mkdirSync(plansDir, { recursive: true });
+  return planEnv(input.planRoot, input.projectId, input.branchName, input.activePlanId);
+}
 async function verifyR5dctlAuth(baseUrl, token) {
   const statusUrl = new URL("/api/r5dctl/auth/status", baseUrl);
   let response;
@@ -479,11 +572,24 @@ function validateLabel(label) {
     throw new Error("Worker label must start with a letter or number and may contain letters, numbers, dots, underscores, and hyphens");
   }
 }
+function validateProjectId(projectId) {
+  if (projectId === "local" || projectId === "local-code") {
+    return;
+  }
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(projectId)) {
+    throw new Error(`Invalid project id from server: ${projectId}`);
+  }
+}
 function validateBranchName(branchName) {
   if (branchName !== "main" && !BRANCH_RE.test(branchName)) {
     throw new Error(`Invalid branch name from server: ${branchName}`);
   }
 }
+function validatePlanId(planId) {
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(planId)) {
+    throw new Error(`Invalid plan id from server: ${planId}`);
+  }
+}
 function gitExtraHeaderConfigKey(extraHeaderUrl) {
   return `http.${normalizeBaseUrl(extraHeaderUrl)}/.extraHeader`;
 }
@@ -584,31 +690,6 @@ function resolveProjectFilePath(branchPath, virtualPath) {
   assertInsideBranch(branchPath, absolutePath);
   return { absolutePath, virtualPath: repoRelativePath ? `/${repoRelativePath}` : "/", repoRelativePath };
 }
-function branchLockKey(projectId, branchName) {
-  return `${projectId}:${branchName}`;
-}
-async function withBranchLock(projectId, branchName, fn) {
-  const key = branchLockKey(projectId, branchName);
-  const previous = branchLocks.get(key) ?? Promise.resolve();
-  let release = () => {
-  };
-  const next = new Promise((resolve) => {
-    release = resolve;
-  });
-  const queued = previous.catch(() => {
-  }).then(() => next);
-  branchLocks.set(key, queued);
-  await previous.catch(() => {
-  });
-  try {
-    return await fn();
-  } finally {
-    release();
-    if (branchLocks.get(key) === queued) {
-      branchLocks.delete(key);
-    }
-  }
-}
 function resolveRemoteUrl(baseUrl, remoteUrl) {
   if (/^https?:\/\//i.test(remoteUrl)) {
     return remoteUrl;
@@ -1532,6 +1613,14 @@ async function executeCommand(input) {
       sessionId: input.message.sessionId,
       artifactRoot: input.artifactRoot
     });
+    const planProcessEnv = await preparePlanEnvForShell({
+      baseUrl: input.baseUrl,
+      token: input.token,
+      projectId: input.projectId,
+      branchName: input.message.branchName,
+      planRoot: input.planRoot,
+      activePlanId: input.message.env?.R5D_ACTIVE_PLAN_ID
+    });
     const cwd = resolveCommandCwd(workspace.branchPath, input.message.cwd);
     const subprocess = Bun.spawn(input.message.argv, {
       cwd,
@@ -1542,10 +1631,20 @@ async function executeCommand(input) {
         ...containerRegistryEnv(),
         ...input.message.env ?? {},
         ...internalGitProcessEnv(workspace, input.message.env),
-        ...artifactProcessEnv
+        ...artifactProcessEnv,
+        ...planProcessEnv
       }
     });
-    activeProcesses.set(input.message.runId, { process: subprocess, command: input.message.argv });
+    activeProcesses.set(input.message.runId, {
+      process: subprocess,
+      projectId: input.projectId,
+      sessionId: input.message.sessionId ?? "",
+      branchName: input.message.branchName,
+      argv: input.message.argv,
+      command: input.message.argv.join(" "),
+      cwd: input.message.cwd,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
     if (input.message.timeoutMs) {
       timeout = setTimeout(() => {
         subprocess.kill("SIGTERM");
@@ -1583,9 +1682,7 @@ async function executeCommand(input) {
 }
 async function executeStreamingCommand(input) {
   const startedAt = Date.now();
-  let timeout;
   let started = false;
-  let timedOut = false;
   try {
     if (cancelledProcessRuns.delete(input.message.runId)) {
       sendWorkerMessage(input.ws, {
@@ -1613,6 +1710,14 @@ async function executeStreamingCommand(input) {
       sessionId: input.message.sessionId,
       artifactRoot: input.artifactRoot
     });
+    const planProcessEnv = await preparePlanEnvForShell({
+      baseUrl: input.baseUrl,
+      token: input.token,
+      projectId: input.projectId,
+      branchName: input.message.branchName,
+      planRoot: input.planRoot,
+      activePlanId: input.message.env?.R5D_ACTIVE_PLAN_ID
+    });
     const cwd = resolveCommandCwd(workspace.branchPath, input.message.cwd);
     const subprocess = Bun.spawn(input.message.argv, {
       cwd,
@@ -1623,22 +1728,26 @@ async function executeStreamingCommand(input) {
         ...containerRegistryEnv(),
         ...input.message.env ?? {},
         ...internalGitProcessEnv(workspace, input.message.env),
-        ...artifactProcessEnv
+        ...artifactProcessEnv,
+        ...planProcessEnv
       }
     });
-    activeProcesses.set(input.message.runId, { process: subprocess, command: input.message.argv });
+    activeProcesses.set(input.message.runId, {
+      process: subprocess,
+      projectId: input.projectId,
+      sessionId: input.message.sessionId,
+      branchName: input.message.branchName,
+      argv: input.message.argv,
+      command: input.message.command,
+      cwd: input.message.cwd,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
     started = true;
     sendWorkerMessage(input.ws, {
       type: "exec_started",
       requestId: input.message.requestId,
       runId: input.message.runId
     });
-    if (input.message.timeoutMs) {
-      timeout = setTimeout(() => {
-        timedOut = true;
-        subprocess.kill("SIGTERM");
-      }, input.message.timeoutMs);
-    }
     const [exitCode] = await Promise.all([
       subprocess.exited,
       streamCommandOutput(subprocess.stdout, (data) => {
@@ -1662,8 +1771,7 @@ async function executeStreamingCommand(input) {
       type: "exec_exit",
       runId: input.message.runId,
       exitCode,
-      durationMs: Date.now() - startedAt,
-      ...timedOut ? { timedOut: true } : {}
+      durationMs: Date.now() - startedAt
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -1683,15 +1791,36 @@ async function executeStreamingCommand(input) {
       });
     }
   } finally {
-    if (timeout) {
-      clearTimeout(timeout);
-    }
     activeProcesses.delete(input.message.runId);
     cancelledProcessRuns.delete(input.message.runId);
   }
 }
 function sendWorkerMessage(ws, message) {
-  ws.send(JSON.stringify(message));
+  const target = currentWorkerSocket ?? ws;
+  try {
+    target.send(JSON.stringify(message));
+  } catch (error) {
+    process.stderr.write(`[r5d-worker] failed to send ${message.type}: ${error instanceof Error ? error.message : String(error)}
+`);
+  }
+}
+function buildActiveProcessReports() {
+  return Array.from(activeProcesses.entries()).filter(([, active]) => active.sessionId.length > 0).map(([runId, active]) => ({
+    runId,
+    projectId: active.projectId,
+    sessionId: active.sessionId,
+    branchName: active.branchName,
+    argv: active.argv,
+    command: active.command,
+    ...active.cwd ? { cwd: active.cwd } : {},
+    startedAt: active.startedAt
+  }));
+}
+function sendActiveProcessReport(ws) {
+  sendWorkerMessage(ws, {
+    type: "active_processes",
+    processes: buildActiveProcessReports()
+  });
 }
 const PTY_BRIDGE_SCRIPT = String.raw`
 const readline = require("node:readline");
@@ -1875,7 +2004,7 @@ function resolveHostShell() {
   }
   return { file: process.env.SHELL || "/bin/bash", args: ["-l"] };
 }
-function openPty(input) {
+async function openPty(input) {
   try {
     const branchPath = ensureBranchWorkspace({
       projectId: input.projectId,
@@ -1886,6 +2015,14 @@ function openPty(input) {
       branchName: input.message.branchName,
       manifest: input.manifest
     });
+    const planProcessEnv = await preparePlanEnvForShell({
+      baseUrl: input.baseUrl,
+      token: input.token,
+      projectId: input.projectId,
+      branchName: input.message.branchName,
+      planRoot: input.planRoot,
+      activePlanId: input.message.env?.R5D_ACTIVE_PLAN_ID
+    });
     const shell = resolveHostShell();
     const ptyProcess = createNodePtyBridge({
       file: shell.file,
@@ -1899,6 +2036,7 @@ function openPty(input) {
           ...process.env,
           ...containerRegistryEnv(),
           ...input.message.env ?? {},
+          ...planProcessEnv,
           R5D_PROJECT_ID: input.projectId,
           R5D_BRANCH_NAME: input.message.branchName
         }
@@ -1999,6 +2137,7 @@ async function startWorker(options) {
   const projectsRoot = import_node_path.default.resolve(options.projectRoot ?? defaultProjectsRoot());
   const syncRoot = import_node_path.default.resolve(options.syncRoot ?? process.env.R5D_SYNC_ROOT ?? defaultSyncRoot());
   const artifactRoot = import_node_path.default.resolve(options.artifactRoot ?? process.env.R5D_ARTIFACTS_ROOT ?? defaultArtifactRoot());
+  const planRoot = import_node_path.default.resolve(options.planRoot ?? process.env.R5D_PLANS_ROOT ?? defaultPlanRoot());
   process.stdout.write(`[r5d-worker] label: ${label}
 `);
   process.stdout.write(`[r5d-worker] projects root: ${projectsRoot}
@@ -2006,6 +2145,8 @@ async function startWorker(options) {
   process.stdout.write(`[r5d-worker] sync root: ${syncRoot}
 `);
   process.stdout.write(`[r5d-worker] artifact root: ${artifactRoot}
+`);
+  process.stdout.write(`[r5d-worker] plan root: ${planRoot}
 `);
   process.stdout.write(`[r5d-worker] server: ${baseUrl}
 `);
@@ -2014,6 +2155,7 @@ async function startWorker(options) {
   import_node_fs.default.mkdirSync(projectsRoot, { recursive: true });
   import_node_fs.default.mkdirSync(syncRoot, { recursive: true });
   import_node_fs.default.mkdirSync(artifactRoot, { recursive: true });
+  import_node_fs.default.mkdirSync(planRoot, { recursive: true });
   const manifestByProjectId = /* @__PURE__ */ new Map();
   const ws = new WebSocket(websocketUrl(baseUrl, label), {
     headers: {
@@ -2021,6 +2163,7 @@ async function startWorker(options) {
     }
   });
   ws.addEventListener("open", () => {
+    currentWorkerSocket = ws;
     const hello = {
       type: "hello",
       hostInfo: {
@@ -2030,10 +2173,12 @@ async function startWorker(options) {
         pid: process.pid,
         version: getWorkerVersion(),
         projectRoot: projectsRoot,
-        artifactRoot
+        artifactRoot,
+        planRoot
       }
     };
     ws.send(JSON.stringify(hello));
+    sendActiveProcessReport(ws);
     process.stdout.write("[r5d-worker] connected\n");
   });
   ws.addEventListener("message", (event) => {
@@ -2056,17 +2201,29 @@ async function startWorker(options) {
           const branches = project.branches.length > 0 ? project.branches : [project.defaultBranch || "main"];
           for (const branchName of branches) {
             try {
-              await withBranchLock(project.projectId, branchName, async () => {
-                ensureBranchWorkspace({
-                  projectId: project.projectId,
+              ensureBranchWorkspace({
+                projectId: project.projectId,
+                baseUrl,
+                token,
+                projectRoot,
+                syncRoot,
+                branchName,
+                manifest: project
+              });
+              try {
+                await syncProjectPlans({
                   baseUrl,
                   token,
-                  projectRoot,
-                  syncRoot,
+                  projectId: project.projectId,
                   branchName,
-                  manifest: project
+                  planRoot
                 });
-              });
+              } catch (error) {
+                process.stderr.write(
+                  `[r5d-worker] plan sync skipped for ${project.projectId}/${branchName}: ${error instanceof Error ? error.message : String(error)}
+`
+                );
+              }
             } catch (error) {
               process.stderr.write(
                 `[r5d-worker] failed to sync ${project.repoSlug}/${branchName}: ${error instanceof Error ? error.message : String(error)}
@@ -2094,7 +2251,7 @@ async function startWorker(options) {
             requestId: message.requestId,
             runId: message.runId,
             cancelled: true,
-            message: active ? `Sent SIGTERM to ${active.command.join(" ")}` : "Cancellation queued before command start"
+            message: active ? `Sent SIGTERM to ${active.command}` : "Cancellation queued before command start"
           })
         );
         return;
@@ -2104,7 +2261,7 @@ async function startWorker(options) {
         const projectRoot = projectRootFor(projectsRoot, message.projectId, manifestByProjectId);
         process.stdout.write(`[r5d-worker] pty ${message.ptyId}: ${message.projectId}/${message.branchName}
 `);
-        openPty({ ws, message, projectId: message.projectId, baseUrl, token, projectRoot, syncRoot, manifest });
+        await openPty({ ws, message, projectId: message.projectId, baseUrl, token, projectRoot, syncRoot, planRoot, manifest });
         return;
       }
       if (message.type === "pty_input") {
@@ -2124,11 +2281,17 @@ async function startWorker(options) {
         const projectRoot = projectRootFor(projectsRoot, message.projectId, manifestByProjectId);
         process.stdout.write(`[r5d-worker] exec ${message.runId}: ${message.argv.join(" ")}
 `);
-        const result = await withBranchLock(
-          message.projectId,
-          message.branchName,
-          () => executeCommand({ message, projectId: message.projectId, baseUrl, token, projectRoot, syncRoot, artifactRoot, manifest })
-        );
+        const result = await executeCommand({
+          message,
+          projectId: message.projectId,
+          baseUrl,
+          token,
+          projectRoot,
+          syncRoot,
+          artifactRoot,
+          planRoot,
+          manifest
+        });
         ws.send(JSON.stringify(result));
         return;
       }
@@ -2143,11 +2306,18 @@ async function startWorker(options) {
           const projectRoot = projectRootFor(projectsRoot, message.projectId, manifestByProjectId);
           process.stdout.write(`[r5d-worker] exec_start ${message.runId}: ${message.argv.join(" ")}
 `);
-          void withBranchLock(
-            message.projectId,
-            message.branchName,
-            () => executeStreamingCommand({ ws, message, projectId: message.projectId, baseUrl, token, projectRoot, syncRoot, artifactRoot, manifest })
-          ).catch((error) => {
+          void executeStreamingCommand({
+            ws,
+            message,
+            projectId: message.projectId,
+            baseUrl,
+            token,
+            projectRoot,
+            syncRoot,
+            artifactRoot,
+            planRoot,
+            manifest
+          }).catch((error) => {
             sendWorkerMessage(ws, {
               type: "exec_start_error",
               requestId: message.requestId,
@@ -2169,11 +2339,16 @@ async function startWorker(options) {
         try {
           const manifest = manifestByProjectId.get(message.projectId);
           const projectRoot = projectRootFor(projectsRoot, message.projectId, manifestByProjectId);
-          const result = await withBranchLock(
-            message.projectId,
-            message.branchName,
-            () => executeOperation({ message, projectId: message.projectId, baseUrl, token, projectRoot, syncRoot, artifactRoot, manifest })
-          );
+          const result = await executeOperation({
+            message,
+            projectId: message.projectId,
+            baseUrl,
+            token,
+            projectRoot,
+            syncRoot,
+            artifactRoot,
+            manifest
+          });
           ws.send(
             JSON.stringify({
               type: "operation_result",
@@ -2208,10 +2383,31 @@ async function startWorker(options) {
     });
   });
   ws.addEventListener("close", (event) => {
+    if (currentWorkerSocket === ws) {
+      currentWorkerSocket = null;
+    }
     closeAllPtys();
     const reason = event.reason ? `: ${event.reason}` : "";
     process.stderr.write(`[r5d-worker] disconnected (${event.code}${reason})
 `);
+    if (activeProcesses.size > 0) {
+      const delayMs = 2e3;
+      process.stderr.write(`[r5d-worker] ${activeProcesses.size} process(es) still active; reconnecting in ${delayMs}ms
+`);
+      const reconnect = () => {
+        void startWorker(options).catch((error) => {
+          process.stderr.write(`[r5d-worker] reconnect failed: ${error instanceof Error ? error.message : String(error)}
+`);
+          if (activeProcesses.size > 0) {
+            setTimeout(reconnect, delayMs);
+            return;
+          }
+          process.exit(1);
+        });
+      };
+      setTimeout(reconnect, delayMs);
+      return;
+    }
     process.exit(event.code === 1e3 ? 0 : 1);
   });
   ws.addEventListener("error", (event) => {
@@ -2252,6 +2448,8 @@ if (isCliEntrypoint()) {
   ensureVisibleGitCheckout,
   isArtifactEnvPath,
   prepareArtifactEnvForShell,
+  preparePlanEnvForShell,
   resolveProjectFilePath,
+  syncProjectPlans,
   syncSessionArtifacts
 });