@ricsam/r5d-worker 0.0.44 → 0.0.46

package/dist/cjs/main.cjs

@@ -282,7 +282,25 @@ async function readResponseText(response) {
   }
 }
 const R5D_ARTIFACTS_DIR_REF = "$R5D_ARTIFACTS_DIR";
+const R5D_PLANS_DIR_REF = "$R5D_PLANS_DIR";
+const R5D_ACTIVE_PLAN_FILE_REF = "$R5D_ACTIVE_PLAN_FILE";
 const R5D_PLANS_DIR_ENV = "R5D_PLANS_DIR";
+const BUILT_IN_TOOL_PATH_REFS = [R5D_ARTIFACTS_DIR_REF, R5D_PLANS_DIR_REF, R5D_ACTIVE_PLAN_FILE_REF];
+function parseBuiltInToolPath(inputPath) {
+  const normalized = inputPath.replace(/\\/g, "/");
+  const match = /^\$(?:\{([A-Za-z_][A-Za-z0-9_]*)\}|([A-Za-z_][A-Za-z0-9_]*))(?:\/(.*))?$/.exec(normalized);
+  if (!match) {
+    return null;
+  }
+  const ref = `$${match[1] ?? match[2]}`;
+  if (!BUILT_IN_TOOL_PATH_REFS.includes(ref)) {
+    throw new Error(`Unsupported tool path variable "${ref}". Supported variables: ${BUILT_IN_TOOL_PATH_REFS.join(", ")}.`);
+  }
+  return {
+    ref,
+    relativePath: match[3] ?? ""
+  };
+}
 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}`);
@@ -291,7 +309,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 sync directory`);
+    throw new Error(`${label} escapes its allowed root`);
   }
 }
 function sessionArtifactDir(artifactRoot, sessionId) {
@@ -324,7 +342,11 @@ function planEnv(planRoot, projectId, branchName, activePlanId) {
   return env;
 }
 function isArtifactEnvPath(filePath) {
-  return filePath === R5D_ARTIFACTS_DIR_REF || filePath.startsWith(`${R5D_ARTIFACTS_DIR_REF}/`);
+  try {
+    return parseBuiltInToolPath(filePath)?.ref === R5D_ARTIFACTS_DIR_REF;
+  } catch {
+    return false;
+  }
 }
 function artifactApiBasePath(projectId, branchName, sessionId) {
   return `/preview-api/${encodeURIComponent(projectId)}/${encodeURIComponent(branchName)}/artifacts/${encodeURIComponent(sessionId)}`;
@@ -431,56 +453,72 @@ async function fetchSessionArtifactManifest(input) {
     label: "artifact"
   });
 }
+const sessionArtifactSyncQueues = /* @__PURE__ */ new Map();
 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,
+  const queueKey = `${import_node_path.default.resolve(input.artifactRoot)}\0${input.sessionId}`;
+  const previous = sessionArtifactSyncQueues.get(queueKey);
+  const queued = (previous ? previous.catch(() => "") : Promise.resolve("")).then(async () => {
+    const targetDir = sessionArtifactDir(input.artifactRoot, input.sessionId);
+    const artifacts = await fetchSessionArtifactManifest(input);
+    return syncRemoteFileSet({
       targetDir,
-      file: artifact,
-      label: "artifact"
-    })
+      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"
+      })
+    });
   });
+  sessionArtifactSyncQueues.set(queueKey, queued);
+  const release = () => {
+    if (sessionArtifactSyncQueues.get(queueKey) === queued) sessionArtifactSyncQueues.delete(queueKey);
+  };
+  void queued.then(release, release);
+  return queued;
 }
-async function resolveArtifactEnvFilePath(input) {
-  if (!isArtifactEnvPath(input.filePath)) {
-    return null;
+async function prepareBuiltInToolPaths(input) {
+  const parsed = parseBuiltInToolPath(input.filePath);
+  if (!parsed) {
+    return void 0;
   }
-  if (!input.sessionId) {
-    throw new Error(`${R5D_ARTIFACTS_DIR_REF} paths require an active chat session`);
+  if (parsed.ref === R5D_ARTIFACTS_DIR_REF) {
+    if (input.access === "write") {
+      throw new Error(
+        `${R5D_ARTIFACTS_DIR_REF} attachments are read-only. Copy them into a project path before editing or creating files.`
+      );
+    }
+    if (!input.sessionId) {
+      throw new Error(`${R5D_ARTIFACTS_DIR_REF} paths require an active chat session`);
+    }
+    return {
+      artifactsDir: await syncSessionArtifacts({
+        baseUrl: input.baseUrl,
+        token: input.token,
+        projectId: input.projectId,
+        branchName: input.branchName,
+        sessionId: input.sessionId,
+        artifactRoot: input.artifactRoot
+      })
+    };
   }
-  if (!input.filePath.startsWith(`${R5D_ARTIFACTS_DIR_REF}/`)) {
-    throw new Error(`Artifact path must reference a file under ${R5D_ARTIFACTS_DIR_REF}/`);
+  const plansDir = projectPlanDir(input.planRoot, input.projectId, input.branchName);
+  import_node_fs.default.mkdirSync(plansDir, { recursive: true });
+  if (parsed.ref === R5D_PLANS_DIR_REF) {
+    return { plansDir };
   }
-  const targetDir = await syncSessionArtifacts({
-    baseUrl: input.baseUrl,
-    token: input.token,
-    projectId: input.projectId,
-    branchName: input.branchName,
-    sessionId: input.sessionId,
-    artifactRoot: input.artifactRoot
-  });
-  const relativePath = import_node_path.default.posix.normalize(input.filePath.slice(`${R5D_ARTIFACTS_DIR_REF}/`.length));
-  if (!relativePath || relativePath === "." || relativePath.startsWith("../") || relativePath.includes("\0")) {
-    throw new Error(`Invalid artifact path: ${input.filePath}`);
+  if (!input.activePlanId) {
+    throw new Error(`${R5D_ACTIVE_PLAN_FILE_REF} paths require an active plan`);
   }
-  const absolutePath = import_node_path.default.resolve(targetDir, ...relativePath.split("/"));
-  assertInsideRoot(targetDir, absolutePath, "Artifact path");
+  validatePlanId(input.activePlanId);
   return {
-    absolutePath,
-    virtualPath: `${R5D_ARTIFACTS_DIR_REF}/${relativePath}`
+    plansDir,
+    activePlanFile: import_node_path.default.join(plansDir, `${input.activePlanId}.plan.md`)
   };
 }
-function rejectArtifactWritePath(filePath) {
-  if (isArtifactEnvPath(filePath)) {
-    throw new Error(`${R5D_ARTIFACTS_DIR_REF} attachments are read-only. Copy them into a project path before editing or creating files.`);
-  }
-}
 async function prepareArtifactEnvForShell(input) {
   if (!input.sessionId) {
     return {};
@@ -631,10 +669,63 @@ function assertAllowedProjectPath(repoRelativePath, inputPath) {
     throw new Error(`Invalid project file path: ${inputPath}`);
   }
 }
-function resolveWorkerFilePath(branchPath, inputPath) {
+function assertPathInsideRealRoot(rootPath, candidatePath, label) {
+  const resolvedRoot = import_node_path.default.resolve(rootPath);
+  const resolvedCandidate = import_node_path.default.resolve(candidatePath);
+  assertInsideRoot(resolvedRoot, resolvedCandidate, label);
+  let existingPath = resolvedCandidate;
+  while (!import_node_fs.default.existsSync(existingPath)) {
+    const parentPath = import_node_path.default.dirname(existingPath);
+    if (parentPath === existingPath) {
+      throw new Error(`${label} root does not exist: ${rootPath}`);
+    }
+    existingPath = parentPath;
+  }
+  const realRoot = import_node_fs.default.realpathSync(resolvedRoot);
+  const realExistingPath = import_node_fs.default.realpathSync(existingPath);
+  assertInsideRoot(realRoot, realExistingPath, label);
+}
+function resolveVirtualWorkerFilePath(inputPath, parsed, builtInPaths) {
+  if (parsed.relativePath.split("/").includes("..")) {
+    throw new Error(`Invalid ${parsed.ref} path: ${inputPath}`);
+  }
+  let rootPath;
+  let absolutePath;
+  if (parsed.ref === R5D_ARTIFACTS_DIR_REF) {
+    rootPath = builtInPaths?.artifactsDir;
+  } else if (parsed.ref === R5D_PLANS_DIR_REF) {
+    rootPath = builtInPaths?.plansDir;
+  } else {
+    if (parsed.relativePath) {
+      throw new Error(`${R5D_ACTIVE_PLAN_FILE_REF} must reference the active plan file directly`);
+    }
+    rootPath = builtInPaths?.plansDir;
+    absolutePath = builtInPaths?.activePlanFile;
+  }
+  if (!rootPath || parsed.ref === R5D_ACTIVE_PLAN_FILE_REF && !absolutePath) {
+    const requirement = parsed.ref === R5D_ARTIFACTS_DIR_REF ? "an active chat session" : "an active plan";
+    throw new Error(`${parsed.ref} paths require ${requirement}`);
+  }
+  const normalizedPath = parsed.relativePath ? import_node_path.default.posix.normalize(parsed.relativePath).replace(/^\/+|\/+$/g, "") : "";
+  const normalizedRelativePath = normalizedPath === "." ? "" : normalizedPath;
+  absolutePath ??= normalizedRelativePath ? import_node_path.default.resolve(rootPath, ...normalizedRelativePath.split("/")) : import_node_path.default.resolve(rootPath);
+  assertPathInsideRealRoot(rootPath, absolutePath, `${parsed.ref} path`);
+  return {
+    absolutePath,
+    displayPath: normalizedRelativePath ? `${parsed.ref}/${normalizedRelativePath}` : parsed.ref,
+    repoRelativePath: null,
+    scope: "virtual",
+    virtualRootPath: import_node_path.default.resolve(rootPath)
+  };
+}
+function resolveWorkerFilePath(branchPath, inputPath, builtInPaths) {
   if (typeof inputPath !== "string" || inputPath.length === 0 || inputPath.includes("\0")) {
     throw new Error(`File path must be a non-empty string. Got: ${JSON.stringify(inputPath)}`);
   }
+  const parsedBuiltInPath = parseBuiltInToolPath(inputPath);
+  if (parsedBuiltInPath) {
+    return resolveVirtualWorkerFilePath(inputPath, parsedBuiltInPath, builtInPaths);
+  }
   const resolvedBranchPath = import_node_path.default.resolve(branchPath);
   if (import_node_path.default.isAbsolute(inputPath)) {
     const absolutePath2 = import_node_path.default.resolve(inputPath);
@@ -1091,13 +1182,13 @@ async function withFileMutationQueue(key, operation) {
   }
 }
 function mutationQueueKey(projectId, branchName, resolved) {
-  if (resolved.scope === "host") {
-    return `host:${import_node_path.default.normalize(resolved.absolutePath)}`;
+  if (resolved.scope !== "project") {
+    return `${resolved.scope}:${import_node_path.default.normalize(resolved.absolutePath)}`;
   }
   return `project:${projectId}:${branchName}:${import_node_path.default.posix.normalize(resolved.repoRelativePath)}`;
 }
-function readWorkerTextFile(branchPath, filePath, offset, limit) {
-  const resolved = resolveWorkerFilePath(branchPath, filePath);
+function readWorkerTextFile(branchPath, filePath, offset, limit, builtInPaths) {
+  const resolved = resolveWorkerFilePath(branchPath, filePath, builtInPaths);
   if (!import_node_fs.default.existsSync(resolved.absolutePath) || !import_node_fs.default.statSync(resolved.absolutePath).isFile()) {
     throw new Error(`File not found: ${resolved.displayPath}`);
   }
@@ -1111,8 +1202,8 @@ function readWorkerTextFile(branchPath, filePath, offset, limit) {
     ...formatted
   };
 }
-function writeWorkerTextFile(branchPath, filePath, content) {
-  const resolved = resolveWorkerFilePath(branchPath, filePath);
+function writeWorkerTextFile(branchPath, filePath, content, builtInPaths) {
+  const resolved = resolveWorkerFilePath(branchPath, filePath, builtInPaths);
   import_node_fs.default.mkdirSync(import_node_path.default.dirname(resolved.absolutePath), { recursive: true });
   import_node_fs.default.writeFileSync(resolved.absolutePath, content, "utf8");
   return {
@@ -1121,8 +1212,8 @@ function writeWorkerTextFile(branchPath, filePath, content) {
     gitBlobHash: getGitBlobHashForContent(content)
   };
 }
-function editWorkerTextFile(branchPath, filePath, edits) {
-  const resolved = resolveWorkerFilePath(branchPath, filePath);
+function editWorkerTextFile(branchPath, filePath, edits, builtInPaths) {
+  const resolved = resolveWorkerFilePath(branchPath, filePath, builtInPaths);
   if (!Array.isArray(edits) || edits.length === 0) {
     throw new Error("edit requires at least one replacement");
   }
@@ -1169,46 +1260,57 @@ function editWorkerTextFile(branchPath, filePath, edits) {
   };
 }
 async function executeReadFileOperation(input) {
-  const artifact = await resolveArtifactEnvFilePath({
+  const builtInPaths = await prepareBuiltInToolPaths({
     filePath: input.message.filePath,
     baseUrl: input.baseUrl,
     token: input.token,
     projectId: input.projectId,
     branchName: input.message.branchName,
     sessionId: input.message.sessionId,
-    artifactRoot: input.artifactRoot
+    activePlanId: input.message.activePlanId,
+    artifactRoot: input.artifactRoot,
+    planRoot: input.planRoot,
+    access: "read"
   });
-  if (artifact) {
-    if (!import_node_fs.default.existsSync(artifact.absolutePath) || !import_node_fs.default.statSync(artifact.absolutePath).isFile()) {
-      throw new Error(`File not found: ${artifact.virtualPath}`);
-    }
-    const buffer = import_node_fs.default.readFileSync(artifact.absolutePath);
-    const formatted = formatLineNumberedContent(buffer.toString("utf8"), input.message.offset, input.message.limit);
-    return {
-      type: "read",
-      kind: "text",
-      file: artifact.virtualPath,
-      gitBlobHash: getGitBlobHashForContent(buffer),
-      ...formatted
-    };
-  }
   const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
-  return readWorkerTextFile(workspace.branchPath, input.message.filePath, input.message.offset, input.message.limit);
+  return readWorkerTextFile(workspace.branchPath, input.message.filePath, input.message.offset, input.message.limit, builtInPaths);
 }
 async function executeWriteFileOperation(input) {
-  rejectArtifactWritePath(input.message.filePath);
+  const builtInPaths = await prepareBuiltInToolPaths({
+    filePath: input.message.filePath,
+    baseUrl: input.baseUrl,
+    token: input.token,
+    projectId: input.projectId,
+    branchName: input.message.branchName,
+    sessionId: input.message.sessionId,
+    activePlanId: input.message.activePlanId,
+    artifactRoot: input.artifactRoot,
+    planRoot: input.planRoot,
+    access: "write"
+  });
   const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
-  const resolved = resolveWorkerFilePath(workspace.branchPath, input.message.filePath);
+  const resolved = resolveWorkerFilePath(workspace.branchPath, input.message.filePath, builtInPaths);
   return withFileMutationQueue(mutationQueueKey(input.projectId, input.message.branchName, resolved), async () => {
-    return writeWorkerTextFile(workspace.branchPath, input.message.filePath, input.message.content);
+    return writeWorkerTextFile(workspace.branchPath, input.message.filePath, input.message.content, builtInPaths);
   });
 }
 async function executeEditFileOperation(input) {
-  rejectArtifactWritePath(input.message.filePath);
+  const builtInPaths = await prepareBuiltInToolPaths({
+    filePath: input.message.filePath,
+    baseUrl: input.baseUrl,
+    token: input.token,
+    projectId: input.projectId,
+    branchName: input.message.branchName,
+    sessionId: input.message.sessionId,
+    activePlanId: input.message.activePlanId,
+    artifactRoot: input.artifactRoot,
+    planRoot: input.planRoot,
+    access: "write"
+  });
   const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
-  const resolved = resolveWorkerFilePath(workspace.branchPath, input.message.filePath);
+  const resolved = resolveWorkerFilePath(workspace.branchPath, input.message.filePath, builtInPaths);
   return withFileMutationQueue(mutationQueueKey(input.projectId, input.message.branchName, resolved), async () => {
-    return editWorkerTextFile(workspace.branchPath, input.message.filePath, input.message.edits);
+    return editWorkerTextFile(workspace.branchPath, input.message.filePath, input.message.edits, builtInPaths);
   });
 }
 const IGNORED_ENTRY_NAMES = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".next", ".cache", "coverage", "target"]);
@@ -1229,16 +1331,20 @@ function normalizeFindPattern(pattern) {
 function walkWorkerEntries(branchPath, start) {
   const entries = [];
   const visitedDirectories = /* @__PURE__ */ new Set();
+  const realVirtualRoot = start.scope === "virtual" ? import_node_fs.default.realpathSync(start.virtualRootPath) : null;
   const visit = (absolutePath, isRoot) => {
     let stat;
     try {
       stat = import_node_fs.default.statSync(absolutePath);
+      if (realVirtualRoot) {
+        assertInsideRoot(realVirtualRoot, import_node_fs.default.realpathSync(absolutePath), `${start.displayPath} path`);
+      }
     } catch (error) {
       if (isRoot) throw error;
       return;
     }
-    const displayPath = start.scope === "project" ? toProjectDisplayPath(branchPath, absolutePath) : import_node_path.default.resolve(absolutePath);
     const hostRelativePath = import_node_path.default.relative(start.absolutePath, absolutePath).split(import_node_path.default.sep).join(import_node_path.default.posix.sep);
+    const displayPath = start.scope === "project" ? toProjectDisplayPath(branchPath, absolutePath) : start.scope === "virtual" ? hostRelativePath ? `${start.displayPath}/${hostRelativePath}` : start.displayPath : import_node_path.default.resolve(absolutePath);
     const matchPath = start.scope === "project" ? displayPath : hostRelativePath || import_node_path.default.basename(start.absolutePath);
     entries.push({ absolutePath, displayPath, matchPath, stat });
     if (!stat.isDirectory()) return;
@@ -1269,8 +1375,8 @@ function walkWorkerEntries(branchPath, start) {
 function isProbablyText(bytes) {
   return !bytes.subarray(0, Math.min(bytes.length, 4096)).includes(0);
 }
-function grepWorkerFiles(branchPath, input) {
-  const start = resolveWorkerFilePath(branchPath, input.path ?? ".");
+function grepWorkerFiles(branchPath, input, builtInPaths) {
+  const start = resolveWorkerFilePath(branchPath, input.path ?? ".", builtInPaths);
   if (!import_node_fs.default.existsSync(start.absolutePath)) {
     throw new Error(`Path not found: ${start.displayPath}`);
   }
@@ -1316,17 +1422,34 @@ function grepWorkerFiles(branchPath, input) {
   };
 }
 async function executeGrepOperation(input) {
-  const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
-  return grepWorkerFiles(workspace.branchPath, {
-    pattern: input.message.pattern,
-    path: input.message.path,
-    glob: input.message.glob,
-    caseSensitive: input.message.caseSensitive,
-    limit: input.message.limit
+  const toolPath = input.message.path ?? ".";
+  const builtInPaths = await prepareBuiltInToolPaths({
+    filePath: toolPath,
+    baseUrl: input.baseUrl,
+    token: input.token,
+    projectId: input.projectId,
+    branchName: input.message.branchName,
+    sessionId: input.message.sessionId,
+    activePlanId: input.message.activePlanId,
+    artifactRoot: input.artifactRoot,
+    planRoot: input.planRoot,
+    access: "read"
   });
+  const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
+  return grepWorkerFiles(
+    workspace.branchPath,
+    {
+      pattern: input.message.pattern,
+      path: input.message.path,
+      glob: input.message.glob,
+      caseSensitive: input.message.caseSensitive,
+      limit: input.message.limit
+    },
+    builtInPaths
+  );
 }
-function findWorkerFiles(branchPath, input) {
-  const start = resolveWorkerFilePath(branchPath, input.path ?? ".");
+function findWorkerFiles(branchPath, input, builtInPaths) {
+  const start = resolveWorkerFilePath(branchPath, input.path ?? ".", builtInPaths);
   if (!import_node_fs.default.existsSync(start.absolutePath) || !import_node_fs.default.statSync(start.absolutePath).isDirectory()) {
     throw new Error(`Directory not found: ${start.displayPath}`);
   }
@@ -1360,16 +1483,33 @@ function findWorkerFiles(branchPath, input) {
   };
 }
 async function executeFindOperation(input) {
-  const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
-  return findWorkerFiles(workspace.branchPath, {
-    pattern: input.message.pattern,
-    path: input.message.path,
-    entryType: input.message.entryType,
-    limit: input.message.limit
+  const toolPath = input.message.path ?? ".";
+  const builtInPaths = await prepareBuiltInToolPaths({
+    filePath: toolPath,
+    baseUrl: input.baseUrl,
+    token: input.token,
+    projectId: input.projectId,
+    branchName: input.message.branchName,
+    sessionId: input.message.sessionId,
+    activePlanId: input.message.activePlanId,
+    artifactRoot: input.artifactRoot,
+    planRoot: input.planRoot,
+    access: "read"
   });
+  const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
+  return findWorkerFiles(
+    workspace.branchPath,
+    {
+      pattern: input.message.pattern,
+      path: input.message.path,
+      entryType: input.message.entryType,
+      limit: input.message.limit
+    },
+    builtInPaths
+  );
 }
-function listWorkerDirectory(branchPath, inputPath = ".", inputLimit) {
-  const resolved = resolveWorkerFilePath(branchPath, inputPath);
+function listWorkerDirectory(branchPath, inputPath = ".", inputLimit, builtInPaths) {
+  const resolved = resolveWorkerFilePath(branchPath, inputPath, builtInPaths);
   if (!import_node_fs.default.existsSync(resolved.absolutePath) || !import_node_fs.default.statSync(resolved.absolutePath).isDirectory()) {
     throw new Error(`Directory not found: ${resolved.displayPath}`);
   }
@@ -1387,11 +1527,24 @@ function listWorkerDirectory(branchPath, inputPath = ".", inputLimit) {
   };
 }
 async function executeLsOperation(input) {
+  const toolPath = input.message.path ?? ".";
+  const builtInPaths = await prepareBuiltInToolPaths({
+    filePath: toolPath,
+    baseUrl: input.baseUrl,
+    token: input.token,
+    projectId: input.projectId,
+    branchName: input.message.branchName,
+    sessionId: input.message.sessionId,
+    activePlanId: input.message.activePlanId,
+    artifactRoot: input.artifactRoot,
+    planRoot: input.planRoot,
+    access: "read"
+  });
   const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
-  return listWorkerDirectory(workspace.branchPath, input.message.path, input.message.limit);
+  return listWorkerDirectory(workspace.branchPath, input.message.path, input.message.limit, builtInPaths);
 }
-function readWorkerImageFile(branchPath, filePath) {
-  const resolved = resolveWorkerFilePath(branchPath, filePath);
+function readWorkerImageFile(branchPath, filePath, builtInPaths) {
+  const resolved = resolveWorkerFilePath(branchPath, filePath, builtInPaths);
   if (!import_node_fs.default.existsSync(resolved.absolutePath) || !import_node_fs.default.statSync(resolved.absolutePath).isFile()) {
     throw new Error(`File not found: ${resolved.displayPath}`);
   }
@@ -1413,38 +1566,20 @@ function readWorkerImageFile(branchPath, filePath) {
   };
 }
 async function executeViewFileBytesOperation(input) {
-  const artifact = await resolveArtifactEnvFilePath({
+  const builtInPaths = await prepareBuiltInToolPaths({
     filePath: input.message.filePath,
     baseUrl: input.baseUrl,
     token: input.token,
     projectId: input.projectId,
     branchName: input.message.branchName,
     sessionId: input.message.sessionId,
-    artifactRoot: input.artifactRoot
+    activePlanId: input.message.activePlanId,
+    artifactRoot: input.artifactRoot,
+    planRoot: input.planRoot,
+    access: "read"
   });
-  if (artifact) {
-    if (!import_node_fs.default.existsSync(artifact.absolutePath) || !import_node_fs.default.statSync(artifact.absolutePath).isFile()) {
-      throw new Error(`File not found: ${artifact.virtualPath}`);
-    }
-    const extension = import_node_path.default.extname(artifact.absolutePath).toLowerCase();
-    const mediaType = extension === ".jpg" || extension === ".jpeg" ? "image/jpeg" : extension === ".png" ? "image/png" : null;
-    if (!mediaType) {
-      throw new Error("read supports PNG and JPEG image inputs only");
-    }
-    const bytes = import_node_fs.default.readFileSync(artifact.absolutePath);
-    const dimensions = readImageDimensions(bytes, mediaType);
-    return {
-      type: "view_file_bytes",
-      filePath: artifact.virtualPath,
-      mediaType,
-      base64: bytes.toString("base64"),
-      fileSizeBytes: bytes.length,
-      width: dimensions.width,
-      height: dimensions.height
-    };
-  }
   const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
-  return readWorkerImageFile(workspace.branchPath, input.message.filePath);
+  return readWorkerImageFile(workspace.branchPath, input.message.filePath, builtInPaths);
 }
 async function executeOperation(input) {
   switch (input.message.type) {
@@ -2083,6 +2218,7 @@ async function startWorker(options) {
   import_node_fs.default.mkdirSync(artifactRoot, { recursive: true });
   import_node_fs.default.mkdirSync(planRoot, { recursive: true });
   const manifestByProjectId = /* @__PURE__ */ new Map();
+  const pendingManifestCheckouts = /* @__PURE__ */ new Map();
   const workspaceSyncSingleFlight = new import_workspace_sync.WorkspaceSyncSingleFlight();
   let workspaceRemoteUrl = null;
   let activeWorkspaceIncidentId = null;
@@ -2091,6 +2227,7 @@ async function startWorker(options) {
   let periodicWorkspaceScanInFlight = false;
   let terminalReplayTimer;
   let workspaceSyncRequestsInFlight = 0;
+  let sessionArtifactSyncRequestsInFlight = 0;
   let cliUpdateInProgress = false;
   let reloadAfterClose = false;
   const workspaceSyncInput = (trigger, overrides = {}) => {
@@ -2110,37 +2247,64 @@ async function startWorker(options) {
   const sendWorkspaceSyncResult = (requestId, result) => {
     sendWorkerMessage(ws, { type: "workspace_sync_result", requestId, result });
   };
-  const ensureAllVisibleWorkspaceCheckouts = () => {
+  const manifestCheckoutKey = (projectId, branchName) => `${projectId}\0${branchName}`;
+  const allManifestCheckouts = () => [...manifestByProjectId.values()].flatMap(
+    (manifest) => manifest.branches.map((branchName) => ({ projectId: manifest.projectId, branchName }))
+  );
+  const ensureVisibleWorkspaceCheckouts = (targets) => {
     const created = [];
-    for (const manifest of manifestByProjectId.values()) {
-      for (const branchName of manifest.branches) {
-        const branchPath = import_node_path.default.join(projectRootFor(projectsRoot, manifest.projectId, manifestByProjectId), branchName);
-        const existed = import_node_fs.default.existsSync(import_node_path.default.join(branchPath, ".git"));
-        const githubRemoteUrl = githubRemoteUrlFor(baseUrl, manifest.projectId, manifest);
-        ensureVisibleGitCheckout({
-          projectRoot: projectRootFor(projectsRoot, manifest.projectId, manifestByProjectId),
-          branchName,
-          githubRemoteUrl,
-          githubAuth: gitAuthForRemote(githubRemoteUrl, manifest.repoAuthHeader),
-          githubAuthHeader: manifest.repoAuthHeader,
-          defaultBranch: manifest.defaultBranch || "main",
-          reconcileExistingOrigin: Boolean(manifest.repoHttpUrl)
-        });
-        if (!existed) created.push({ projectId: manifest.projectId, branchName });
+    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 projectRoot = projectRootFor(projectsRoot, manifest.projectId, manifestByProjectId);
+      const branchPath = import_node_path.default.join(projectRoot, target.branchName);
+      const existed = hasNormalVisibleGitDir(branchPath);
+      const githubRemoteUrl = githubRemoteUrlFor(baseUrl, manifest.projectId, manifest);
+      ensureVisibleGitCheckout({
+        projectRoot,
+        branchName: target.branchName,
+        githubRemoteUrl,
+        githubAuth: gitAuthForRemote(githubRemoteUrl, manifest.repoAuthHeader),
+        githubAuthHeader: manifest.repoAuthHeader,
+        defaultBranch: manifest.defaultBranch || "main",
+        reconcileExistingOrigin: Boolean(manifest.repoHttpUrl)
+      });
+      if (!existed) created.push(target);
     }
     return created;
   };
   const runRequestedWorkspaceSync = async (requestId, trigger, overrides = {}) => {
     workspaceSyncRequestsInFlight += 1;
     try {
-      const newVisibleCheckouts = trigger.type === "connect" ? ensureAllVisibleWorkspaceCheckouts() : [];
-      const result = await workspaceSyncSingleFlight.run(
-        workspaceSyncInput(trigger, {
+      let pendingTargets = [];
+      const result = await workspaceSyncSingleFlight.runPrepared(() => {
+        const shouldEnsureCheckouts = !overrides.skipVisibleMirror && !overrides.resetToCanonical;
+        let checkoutTargets = [];
+        if (shouldEnsureCheckouts) {
+          checkoutTargets = trigger.type === "connect" ? allManifestCheckouts() : [...pendingManifestCheckouts.values()];
+        }
+        pendingTargets = shouldEnsureCheckouts ? [...pendingManifestCheckouts.values()] : [];
+        const createdCheckouts = ensureVisibleWorkspaceCheckouts(checkoutTargets);
+        const newVisibleCheckoutByKey = /* @__PURE__ */ new Map();
+        for (const target of [...overrides.newVisibleCheckouts ?? [], ...createdCheckouts, ...pendingTargets]) {
+          newVisibleCheckoutByKey.set(manifestCheckoutKey(target.projectId, target.branchName), target);
+        }
+        const newVisibleCheckouts = [...newVisibleCheckoutByKey.values()];
+        return workspaceSyncInput(trigger, {
           ...overrides,
           ...newVisibleCheckouts.length > 0 ? { newVisibleCheckouts } : {}
-        })
-      );
+        });
+      });
+      if (result.outcome === "no_change" || result.outcome === "published" || result.outcome === "updated" || result.outcome === "conflict_reset") {
+        for (const target of pendingTargets) {
+          const key = manifestCheckoutKey(target.projectId, target.branchName);
+          if (pendingManifestCheckouts.get(key) === target) pendingManifestCheckouts.delete(key);
+        }
+      }
       previousPeriodicFingerprint = null;
       sendWorkspaceSyncResult(requestId, result);
       return result;
@@ -2233,9 +2397,26 @@ async function startWorker(options) {
         configureGitHubAuth(message.githubCredential);
         visibleGitIdentity = message.gitIdentity;
         workspaceRemoteUrl = message.workspaceRemoteUrl;
+        const previousCheckoutKeys = new Set(
+          allManifestCheckouts().map(({ projectId, branchName }) => manifestCheckoutKey(projectId, branchName))
+        );
         const migratedProjectIds = (0, import_managed_paths.migrateLegacyProjectRoots)(projectsRoot, message.projects);
         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);
+          if (previousCheckoutKeys.has(key)) continue;
+          const branchPath = import_node_path.default.join(projectRootFor(projectsRoot, checkout.projectId, manifestByProjectId), checkout.branchName);
+          if (!hasNormalVisibleGitDir(branchPath)) pendingManifestCheckouts.set(key, checkout);
+        }
+        previousPeriodicFingerprint = null;
         process.stdout.write(
           `[r5d-worker] workspace manifest: ${message.projects.length} projects${migratedProjectIds.length > 0 ? `; migrated ${migratedProjectIds.length} project checkout root(s)` : ""}
 `
@@ -2246,8 +2427,15 @@ async function startWorker(options) {
             if (!workspaceRemoteUrl || activeWorkspaceIncidentId || cliUpdateInProgress || periodicWorkspaceScanInFlight) return;
             periodicWorkspaceScanInFlight = true;
             void (async () => {
-              const input = workspaceSyncInput({ type: "periodic" });
-              const fingerprint = await workspaceSyncSingleFlight.fingerprint(input);
+              if (pendingManifestCheckouts.size > 0) {
+                previousPeriodicFingerprint = null;
+                await runRequestedWorkspaceSync(crypto.randomUUID(), {
+                  type: "periodic",
+                  detail: "workspace manifest additions"
+                });
+                return;
+              }
+              const fingerprint = await workspaceSyncSingleFlight.fingerprintPrepared(() => workspaceSyncInput({ type: "periodic" }));
               if (fingerprint === emptyFingerprint) {
                 previousPeriodicFingerprint = null;
                 return;
@@ -2287,6 +2475,34 @@ async function startWorker(options) {
         }
         return;
       }
+      if (message.type === "sync_session_artifacts") {
+        sessionArtifactSyncRequestsInFlight += 1;
+        try {
+          await syncSessionArtifacts({
+            baseUrl,
+            token,
+            projectId: message.projectId,
+            branchName: message.branchName,
+            sessionId: message.sessionId,
+            artifactRoot
+          });
+          sendWorkerMessage(ws, {
+            type: "session_artifacts_sync_result",
+            requestId: message.requestId,
+            sessionId: message.sessionId
+          });
+        } catch (error) {
+          sendWorkerMessage(ws, {
+            type: "session_artifacts_sync_result",
+            requestId: message.requestId,
+            sessionId: message.sessionId,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        } finally {
+          sessionArtifactSyncRequestsInFlight -= 1;
+        }
+        return;
+      }
       if (message.type === "workspace_incident_updated") {
         activeWorkspaceIncidentId = message.status === "remediating" || message.status === "waiting_for_worker" ? message.incidentId : null;
         previousPeriodicFingerprint = null;
@@ -2305,7 +2521,7 @@ async function startWorker(options) {
           });
           return;
         }
-        if (activeProcesses.size > 0 || activePtys.size > 0 || workspaceSyncRequestsInFlight > 0) {
+        if (activeProcesses.size > 0 || activePtys.size > 0 || workspaceSyncRequestsInFlight > 0 || sessionArtifactSyncRequestsInFlight > 0) {
           sendWorkerMessage(ws, {
             type: "update_clis_result",
             requestId: message.requestId,
@@ -2486,6 +2702,7 @@ async function startWorker(options) {
             projectRoot,
             syncRoot,
             artifactRoot,
+            planRoot,
             manifest
           });
           ws.send(