@ricsam/r5d-worker 0.0.33 → 0.0.35

package/dist/cjs/main.cjs

@@ -34,6 +34,7 @@ __export(main_exports, {
   findWorkerFiles: () => findWorkerFiles,
   githubCliEnv: () => githubCliEnv,
   grepWorkerFiles: () => grepWorkerFiles,
+  inspectManagedWorkspace: () => inspectManagedWorkspace,
   isArtifactEnvPath: () => isArtifactEnvPath,
   listWorkerDirectory: () => listWorkerDirectory,
   prepareArtifactEnvForShell: () => prepareArtifactEnvForShell,
@@ -41,8 +42,10 @@ __export(main_exports, {
   readWorkerImageFile: () => readWorkerImageFile,
   readWorkerTextFile: () => readWorkerTextFile,
   resolveHostShell: () => resolveHostShell,
+  resolveManagedCheckoutPath: () => resolveManagedCheckoutPath,
   resolveProjectFilePath: () => resolveProjectFilePath,
   resolveWorkerFilePath: () => resolveWorkerFilePath,
+  selectManifestSyncTargets: () => selectManifestSyncTargets,
   syncManifestProjectsFromInternal: () => syncManifestProjectsFromInternal,
   syncProjectPlans: () => syncProjectPlans,
   syncSessionArtifacts: () => syncSessionArtifacts
@@ -743,6 +746,11 @@ function resolveWorkerFilePath(branchPath, inputPath) {
     const displayPath = toProjectDisplayPath(resolvedBranchPath, absolutePath2);
     const repoRelativePath2 = displayPath === "." ? "" : displayPath;
     assertAllowedProjectPath(repoRelativePath2, inputPath);
+    const realBranchPath2 = import_node_fs.default.existsSync(resolvedBranchPath) ? import_node_fs.default.realpathSync(resolvedBranchPath) : resolvedBranchPath;
+    const realTargetPath2 = resolveThroughExistingAncestor(absolutePath2);
+    if (!isInsideBranchPath(realBranchPath2, realTargetPath2)) {
+      throw new Error(`Project file path escapes its checkout through a symbolic link: ${inputPath}`);
+    }
     return {
       absolutePath: absolutePath2,
       displayPath,
@@ -761,6 +769,11 @@ function resolveWorkerFilePath(branchPath, inputPath) {
   if (!isInsideBranchPath(resolvedBranchPath, absolutePath)) {
     throw new Error(`Invalid project file path: ${inputPath}`);
   }
+  const realBranchPath = import_node_fs.default.existsSync(resolvedBranchPath) ? import_node_fs.default.realpathSync(resolvedBranchPath) : resolvedBranchPath;
+  const realTargetPath = resolveThroughExistingAncestor(absolutePath);
+  if (!isInsideBranchPath(realBranchPath, realTargetPath)) {
+    throw new Error(`Project file path escapes its checkout through a symbolic link: ${inputPath}`);
+  }
   return {
     absolutePath,
     displayPath: repoRelativePath || ".",
@@ -772,11 +785,60 @@ function resolveProjectFilePath(branchPath, inputPath) {
   const resolved = resolveWorkerFilePath(branchPath, inputPath);
   if (resolved.scope === "host") {
     throw new Error(
-      `Project file writes must use a checkout-relative path. Absolute host paths are read-only in file tools: ${inputPath}`
+      `Project file writes must resolve inside the selected managed checkout: ${inputPath}`
     );
   }
   return resolved;
 }
+function resolveThroughExistingAncestor(inputPath) {
+  const suffix = [];
+  let cursor = import_node_path.default.resolve(inputPath);
+  while (!import_node_fs.default.existsSync(cursor)) {
+    const parent = import_node_path.default.dirname(cursor);
+    if (parent === cursor) return import_node_path.default.resolve(inputPath);
+    suffix.unshift(import_node_path.default.basename(cursor));
+    cursor = parent;
+  }
+  return import_node_path.default.resolve(import_node_fs.default.realpathSync(cursor), ...suffix);
+}
+function resolveManagedCheckoutPath(input) {
+  const originManifest = input.manifests.find((manifest) => manifest.projectId === input.originProjectId);
+  const candidate = import_node_path.default.isAbsolute(input.inputPath) ? import_node_path.default.resolve(input.inputPath) : import_node_path.default.resolve(
+    input.projectsRoot,
+    originManifest?.repoSlug ?? input.originProjectId,
+    input.originBranchName,
+    input.inputPath
+  );
+  const resolvedCandidate = resolveThroughExistingAncestor(candidate);
+  for (const manifest of input.manifests) {
+    const branches = manifest.branches.length > 0 ? manifest.branches : [manifest.defaultBranch || "main"];
+    for (const branchName of branches) {
+      const checkoutPath = import_node_path.default.resolve(input.projectsRoot, manifest.repoSlug || manifest.projectId, branchName);
+      if (!hasNormalVisibleGitDir(checkoutPath)) continue;
+      const resolvedCheckoutPath = import_node_fs.default.existsSync(checkoutPath) ? import_node_fs.default.realpathSync(checkoutPath) : checkoutPath;
+      const matchesLexically = isInsideBranchPath(checkoutPath, candidate);
+      if (!matchesLexically) continue;
+      if (!isInsideBranchPath(resolvedCheckoutPath, resolvedCandidate)) {
+        throw new Error(`Managed path escapes its checkout through a symbolic link: ${input.inputPath}`);
+      }
+      const repoRelativePath = toProjectDisplayPath(resolvedCheckoutPath, resolvedCandidate);
+      assertAllowedProjectPath(repoRelativePath === "." ? "" : repoRelativePath, input.inputPath);
+      return {
+        type: "resolve_managed_path",
+        resolved: {
+          projectId: manifest.projectId,
+          projectPath: manifest.projectPath,
+          branchName,
+          checkoutPath,
+          inputPath: input.inputPath,
+          absolutePath: candidate,
+          repoRelativePath: repoRelativePath === "." ? "" : repoRelativePath
+        }
+      };
+    }
+  }
+  return { type: "resolve_managed_path", resolved: null };
+}
 function resolveRemoteUrl(baseUrl, remoteUrl) {
   if (/^https?:\/\//i.test(remoteUrl)) {
     return remoteUrl;
@@ -1145,6 +1207,9 @@ async function forceSyncManifestBranchFromInternal(input) {
   if (!target) {
     throw new Error(`Internal remote has neither ${input.branchName} nor main`);
   }
+  if (hasInternalWorktreeChanges(context)) {
+    return null;
+  }
   await runInternalGitAsync(context, ["reset", "--hard", target]);
   await runInternalGitAsync(context, ["clean", "-fd", "--", ".", ":(exclude).git"]);
   return getInternalCommitHash(context);
@@ -1152,21 +1217,34 @@ async function forceSyncManifestBranchFromInternal(input) {
 function findRepositorySyncBlockers(input) {
   const targetByKey = new Map(input.targets.map((target) => [`${target.projectId}:${target.branchName}`, target]));
   const blockedBy = [];
-  for (const process2 of input.processes) {
-    const target = targetByKey.get(`${process2.projectId}:${process2.branchName}`);
-    if (target) blockedBy.push({ ...target, kind: "process", id: process2.id });
-  }
   for (const shell of input.shells) {
     const target = targetByKey.get(`${shell.projectId}:${shell.branchName}`);
     if (target) blockedBy.push({ ...target, kind: "shell", id: shell.id });
   }
   return blockedBy;
 }
+function selectManifestSyncTargets(input) {
+  if (!input.requestedTargets) {
+    return input.manifests.flatMap((manifest) => {
+      const branches = manifest.branches.length > 0 ? manifest.branches : [manifest.defaultBranch || "main"];
+      return [...new Set(branches)].map((branchName) => ({ manifest, branchName }));
+    });
+  }
+  const manifestsByProjectId = new Map(input.manifests.map((manifest) => [manifest.projectId, manifest]));
+  const selected = /* @__PURE__ */ new Map();
+  for (const target of input.requestedTargets) {
+    const manifest = manifestsByProjectId.get(target.projectId);
+    if (!manifest) {
+      continue;
+    }
+    selected.set(`${target.projectId}\0${target.branchName}`, { manifest, branchName: target.branchName });
+  }
+  return [...selected.values()];
+}
 async function syncManifestProjectsFromInternal(input) {
-  const requestedProjectIds = input.projectIds ? new Set(input.projectIds) : null;
-  const targets = input.manifests.filter((manifest) => !requestedProjectIds || requestedProjectIds.has(manifest.projectId)).flatMap((manifest) => {
-    const branches = manifest.branches.length > 0 ? manifest.branches : [manifest.defaultBranch || "main"];
-    return [...new Set(branches)].map((branchName) => ({ manifest, branchName }));
+  const targets = selectManifestSyncTargets({
+    manifests: input.manifests,
+    requestedTargets: input.requestedTargets
   });
   const blockedBy = findRepositorySyncBlockers({
     targets: targets.map(({ manifest, branchName }) => ({
@@ -1174,22 +1252,18 @@ async function syncManifestProjectsFromInternal(input) {
       projectPath: manifest.projectPath,
       branchName
     })),
-    processes: [...activeProcesses].map(([id, active]) => ({
-      id,
-      projectId: active.projectId,
-      branchName: active.branchName
-    })),
     shells: [...activePtys].map(([id, active]) => ({
       id,
       projectId: active.projectId,
       branchName: active.branchName
     }))
   });
-  if (blockedBy.length > 0) {
-    return { status: "blocked", results: [], blockedBy };
-  }
+  const blockedTargetKeys = new Set(blockedBy.map((blocker) => `${blocker.projectId}\0${blocker.branchName}`));
   const results = [];
   for (const { manifest, branchName } of targets) {
+    if (blockedTargetKeys.has(`${manifest.projectId}\0${branchName}`)) {
+      continue;
+    }
     try {
       const commitHash = await forceSyncManifestBranchFromInternal({
         projectId: manifest.projectId,
@@ -1200,6 +1274,16 @@ async function syncManifestProjectsFromInternal(input) {
         branchName,
         manifest
       });
+      if (commitHash === null) {
+        blockedBy.push({
+          projectId: manifest.projectId,
+          projectPath: manifest.projectPath,
+          branchName,
+          kind: "dirty_checkout",
+          id: `${manifest.projectId}:${branchName}`
+        });
+        continue;
+      }
       results.push({
         projectId: manifest.projectId,
         projectPath: manifest.projectPath,
@@ -1217,10 +1301,11 @@ async function syncManifestProjectsFromInternal(input) {
       });
     }
   }
+  const hasFailures = results.some((result) => result.status === "failed");
   return {
-    status: results.some((result) => result.status === "failed") ? "partial" : "completed",
+    status: blockedBy.length > 0 && results.length === 0 ? "blocked" : blockedBy.length > 0 || hasFailures ? "partial" : "completed",
     results,
-    blockedBy: []
+    blockedBy
   };
 }
 function resolveCommandCwd(branchPath, cwd) {
@@ -1271,6 +1356,60 @@ async function streamCommandOutput(stream, onData) {
 function ensureOperationBranch(input) {
   return ensureBranchWorkspace(input);
 }
+async function inspectManagedWorkspace(input) {
+  const candidates = input.manifests.flatMap((manifest) => {
+    const branches = manifest.branches.length > 0 ? manifest.branches : [manifest.defaultBranch || "main"];
+    return branches.map((branchName) => ({
+      manifest,
+      branchName,
+      checkoutPath: import_node_path.default.resolve(input.projectsRoot, manifest.repoSlug || manifest.projectId, branchName)
+    }));
+  });
+  const inspected = await Promise.all(
+    candidates.map(async ({ manifest, branchName, checkoutPath }) => {
+      const gitDir = internalGitDirFor(input.syncRoot, manifest.projectId, branchName);
+      if (!hasNormalVisibleGitDir(checkoutPath) || !import_node_fs.default.existsSync(gitDir)) return null;
+      const context = {
+        gitDir,
+        workTree: checkoutPath,
+        auth: internalGitAuth(input.baseUrl, input.token)
+      };
+      try {
+        const status = await runInternalGitAsync(context, ["status", "--porcelain", "--", ".", ":(exclude).git"]);
+        let commitHash = null;
+        for (const revision of [
+          "HEAD",
+          `refs/remotes/${R5D_REMOTE_NAME}/${branchName}`,
+          `refs/remotes/${R5D_REMOTE_NAME}/main`
+        ]) {
+          try {
+            commitHash = await runInternalGitAsync(context, ["rev-parse", "--verify", revision]);
+            break;
+          } catch {
+          }
+        }
+        if (!commitHash) return null;
+        return {
+          projectId: manifest.projectId,
+          projectPath: manifest.projectPath,
+          branchName,
+          checkoutPath,
+          commitHash,
+          status,
+          dirty: status.trim().length > 0
+        };
+      } catch {
+        return null;
+      }
+    })
+  );
+  return {
+    type: "workspace_status",
+    checkouts: inspected.filter((checkout) => checkout !== null).sort(
+      (left, right) => left.projectPath.localeCompare(right.projectPath) || left.branchName.localeCompare(right.branchName)
+    )
+  };
+}
 function internalGitProcessEnv(workspace, env) {
   if (env?.R5D_USE_INTERNAL_GIT !== "1") {
     return {};
@@ -1837,6 +1976,22 @@ function pullBranch(input) {
 }
 async function executeOperation(input) {
   switch (input.message.type) {
+    case "resolve_managed_path":
+      return resolveManagedCheckoutPath({
+        projectsRoot: input.projectsRoot,
+        manifests: input.manifests,
+        originProjectId: input.message.projectId,
+        originBranchName: input.message.branchName,
+        inputPath: input.message.inputPath
+      });
+    case "workspace_status":
+      return await inspectManagedWorkspace({
+        baseUrl: input.baseUrl,
+        token: input.token,
+        projectsRoot: input.projectsRoot,
+        syncRoot: input.syncRoot,
+        manifests: input.manifests
+      });
     case "read":
       return executeReadFileOperation({ ...input, message: input.message });
     case "write":
@@ -1939,9 +2094,11 @@ async function executeCommand(input) {
       projectId: input.projectId,
       sessionId: input.message.sessionId ?? "",
       branchName: input.message.branchName,
+      mode: "foreground",
+      startCommitHash: "",
       argv: input.message.argv,
       command: input.message.argv.join(" "),
-      cwd: input.message.cwd,
+      cwd,
       startedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
     if (input.message.timeoutMs) {
@@ -2044,17 +2201,28 @@ async function executeStreamingCommand(input) {
       projectId: input.projectId,
       sessionId: input.message.sessionId,
       branchName: input.message.branchName,
+      mode: input.message.mode,
+      startCommitHash: input.message.startCommitHash,
+      launchWorkspaceActionId: input.message.launchWorkspaceActionId,
       credentialId: input.message.credentialId,
+      pid: subprocess.pid,
+      processGroupId: subprocess.pid,
       argv: input.message.argv,
       command: input.message.command,
-      cwd: input.message.cwd,
+      // Persist the resolved absolute cwd so reconnect reports and process
+      // history retain the actual execution location, including cross-project
+      // managed paths.
+      cwd,
       startedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
     started = true;
     sendWorkerMessage(input.ws, {
       type: "exec_started",
       requestId: input.message.requestId,
-      runId: input.message.runId
+      runId: input.message.runId,
+      cwd,
+      pid: subprocess.pid,
+      processGroupId: subprocess.pid
     });
     if (input.message.timeoutMs) {
       timeout = setTimeout(() => {
@@ -2133,7 +2301,12 @@ function buildActiveProcessReports() {
     projectId: active.projectId,
     sessionId: active.sessionId,
     branchName: active.branchName,
+    mode: active.mode,
+    startCommitHash: active.startCommitHash,
+    ...active.launchWorkspaceActionId ? { launchWorkspaceActionId: active.launchWorkspaceActionId } : {},
     ...active.credentialId ? { credentialId: active.credentialId } : {},
+    ...active.pid !== void 0 ? { pid: active.pid } : {},
+    ...active.processGroupId !== void 0 ? { processGroupId: active.processGroupId } : {},
     argv: active.argv,
     command: active.command,
     ...active.cwd ? { cwd: active.cwd } : {},
@@ -2580,7 +2753,7 @@ async function startWorker(options) {
               projectsRoot,
               syncRoot,
               manifests: [...manifestByProjectId.values()],
-              projectIds: message.projectIds
+              requestedTargets: message.targets
             });
             for (const result of syncResult.results) {
               if (result.status !== "synced") continue;
@@ -2630,6 +2803,7 @@ async function startWorker(options) {
           requestId: message.requestId,
           result: syncResult
         });
+        sendActiveProcessReport(ws);
         return;
       }
       if (message.type === "update_clis") {
@@ -2811,7 +2985,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" || message.type === "sync" || message.type === "confirm_large_diff" || message.type === "pull_branch") {
+      if (message.type === "resolve_managed_path" || message.type === "workspace_status" || 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 === "sync" || message.type === "confirm_large_diff" || message.type === "pull_branch") {
         try {
           await repositorySyncQueue;
           const manifest = manifestByProjectId.get(message.projectId);
@@ -2824,6 +2998,8 @@ async function startWorker(options) {
             projectRoot,
             syncRoot,
             artifactRoot,
+            projectsRoot,
+            manifests: [...manifestByProjectId.values()],
             manifest
           });
           ws.send(
@@ -2939,6 +3115,7 @@ if (isCliEntrypoint()) {
   findWorkerFiles,
   githubCliEnv,
   grepWorkerFiles,
+  inspectManagedWorkspace,
   isArtifactEnvPath,
   listWorkerDirectory,
   prepareArtifactEnvForShell,
@@ -2946,8 +3123,10 @@ if (isCliEntrypoint()) {
   readWorkerImageFile,
   readWorkerTextFile,
   resolveHostShell,
+  resolveManagedCheckoutPath,
   resolveProjectFilePath,
   resolveWorkerFilePath,
+  selectManifestSyncTargets,
   syncManifestProjectsFromInternal,
   syncProjectPlans,
   syncSessionArtifacts

package/dist/cjs/package.json

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

package/dist/mjs/main.mjs

@@ -693,6 +693,11 @@ function resolveWorkerFilePath(branchPath, inputPath) {
     const displayPath = toProjectDisplayPath(resolvedBranchPath, absolutePath2);
     const repoRelativePath2 = displayPath === "." ? "" : displayPath;
     assertAllowedProjectPath(repoRelativePath2, inputPath);
+    const realBranchPath2 = fs.existsSync(resolvedBranchPath) ? fs.realpathSync(resolvedBranchPath) : resolvedBranchPath;
+    const realTargetPath2 = resolveThroughExistingAncestor(absolutePath2);
+    if (!isInsideBranchPath(realBranchPath2, realTargetPath2)) {
+      throw new Error(`Project file path escapes its checkout through a symbolic link: ${inputPath}`);
+    }
     return {
       absolutePath: absolutePath2,
       displayPath,
@@ -711,6 +716,11 @@ function resolveWorkerFilePath(branchPath, inputPath) {
   if (!isInsideBranchPath(resolvedBranchPath, absolutePath)) {
     throw new Error(`Invalid project file path: ${inputPath}`);
   }
+  const realBranchPath = fs.existsSync(resolvedBranchPath) ? fs.realpathSync(resolvedBranchPath) : resolvedBranchPath;
+  const realTargetPath = resolveThroughExistingAncestor(absolutePath);
+  if (!isInsideBranchPath(realBranchPath, realTargetPath)) {
+    throw new Error(`Project file path escapes its checkout through a symbolic link: ${inputPath}`);
+  }
   return {
     absolutePath,
     displayPath: repoRelativePath || ".",
@@ -722,11 +732,60 @@ function resolveProjectFilePath(branchPath, inputPath) {
   const resolved = resolveWorkerFilePath(branchPath, inputPath);
   if (resolved.scope === "host") {
     throw new Error(
-      `Project file writes must use a checkout-relative path. Absolute host paths are read-only in file tools: ${inputPath}`
+      `Project file writes must resolve inside the selected managed checkout: ${inputPath}`
     );
   }
   return resolved;
 }
+function resolveThroughExistingAncestor(inputPath) {
+  const suffix = [];
+  let cursor = path.resolve(inputPath);
+  while (!fs.existsSync(cursor)) {
+    const parent = path.dirname(cursor);
+    if (parent === cursor) return path.resolve(inputPath);
+    suffix.unshift(path.basename(cursor));
+    cursor = parent;
+  }
+  return path.resolve(fs.realpathSync(cursor), ...suffix);
+}
+function resolveManagedCheckoutPath(input) {
+  const originManifest = input.manifests.find((manifest) => manifest.projectId === input.originProjectId);
+  const candidate = path.isAbsolute(input.inputPath) ? path.resolve(input.inputPath) : path.resolve(
+    input.projectsRoot,
+    originManifest?.repoSlug ?? input.originProjectId,
+    input.originBranchName,
+    input.inputPath
+  );
+  const resolvedCandidate = resolveThroughExistingAncestor(candidate);
+  for (const manifest of input.manifests) {
+    const branches = manifest.branches.length > 0 ? manifest.branches : [manifest.defaultBranch || "main"];
+    for (const branchName of branches) {
+      const checkoutPath = path.resolve(input.projectsRoot, manifest.repoSlug || manifest.projectId, branchName);
+      if (!hasNormalVisibleGitDir(checkoutPath)) continue;
+      const resolvedCheckoutPath = fs.existsSync(checkoutPath) ? fs.realpathSync(checkoutPath) : checkoutPath;
+      const matchesLexically = isInsideBranchPath(checkoutPath, candidate);
+      if (!matchesLexically) continue;
+      if (!isInsideBranchPath(resolvedCheckoutPath, resolvedCandidate)) {
+        throw new Error(`Managed path escapes its checkout through a symbolic link: ${input.inputPath}`);
+      }
+      const repoRelativePath = toProjectDisplayPath(resolvedCheckoutPath, resolvedCandidate);
+      assertAllowedProjectPath(repoRelativePath === "." ? "" : repoRelativePath, input.inputPath);
+      return {
+        type: "resolve_managed_path",
+        resolved: {
+          projectId: manifest.projectId,
+          projectPath: manifest.projectPath,
+          branchName,
+          checkoutPath,
+          inputPath: input.inputPath,
+          absolutePath: candidate,
+          repoRelativePath: repoRelativePath === "." ? "" : repoRelativePath
+        }
+      };
+    }
+  }
+  return { type: "resolve_managed_path", resolved: null };
+}
 function resolveRemoteUrl(baseUrl, remoteUrl) {
   if (/^https?:\/\//i.test(remoteUrl)) {
     return remoteUrl;
@@ -1095,6 +1154,9 @@ async function forceSyncManifestBranchFromInternal(input) {
   if (!target) {
     throw new Error(`Internal remote has neither ${input.branchName} nor main`);
   }
+  if (hasInternalWorktreeChanges(context)) {
+    return null;
+  }
   await runInternalGitAsync(context, ["reset", "--hard", target]);
   await runInternalGitAsync(context, ["clean", "-fd", "--", ".", ":(exclude).git"]);
   return getInternalCommitHash(context);
@@ -1102,21 +1164,34 @@ async function forceSyncManifestBranchFromInternal(input) {
 function findRepositorySyncBlockers(input) {
   const targetByKey = new Map(input.targets.map((target) => [`${target.projectId}:${target.branchName}`, target]));
   const blockedBy = [];
-  for (const process2 of input.processes) {
-    const target = targetByKey.get(`${process2.projectId}:${process2.branchName}`);
-    if (target) blockedBy.push({ ...target, kind: "process", id: process2.id });
-  }
   for (const shell of input.shells) {
     const target = targetByKey.get(`${shell.projectId}:${shell.branchName}`);
     if (target) blockedBy.push({ ...target, kind: "shell", id: shell.id });
   }
   return blockedBy;
 }
+function selectManifestSyncTargets(input) {
+  if (!input.requestedTargets) {
+    return input.manifests.flatMap((manifest) => {
+      const branches = manifest.branches.length > 0 ? manifest.branches : [manifest.defaultBranch || "main"];
+      return [...new Set(branches)].map((branchName) => ({ manifest, branchName }));
+    });
+  }
+  const manifestsByProjectId = new Map(input.manifests.map((manifest) => [manifest.projectId, manifest]));
+  const selected = /* @__PURE__ */ new Map();
+  for (const target of input.requestedTargets) {
+    const manifest = manifestsByProjectId.get(target.projectId);
+    if (!manifest) {
+      continue;
+    }
+    selected.set(`${target.projectId}\0${target.branchName}`, { manifest, branchName: target.branchName });
+  }
+  return [...selected.values()];
+}
 async function syncManifestProjectsFromInternal(input) {
-  const requestedProjectIds = input.projectIds ? new Set(input.projectIds) : null;
-  const targets = input.manifests.filter((manifest) => !requestedProjectIds || requestedProjectIds.has(manifest.projectId)).flatMap((manifest) => {
-    const branches = manifest.branches.length > 0 ? manifest.branches : [manifest.defaultBranch || "main"];
-    return [...new Set(branches)].map((branchName) => ({ manifest, branchName }));
+  const targets = selectManifestSyncTargets({
+    manifests: input.manifests,
+    requestedTargets: input.requestedTargets
   });
   const blockedBy = findRepositorySyncBlockers({
     targets: targets.map(({ manifest, branchName }) => ({
@@ -1124,22 +1199,18 @@ async function syncManifestProjectsFromInternal(input) {
       projectPath: manifest.projectPath,
       branchName
     })),
-    processes: [...activeProcesses].map(([id, active]) => ({
-      id,
-      projectId: active.projectId,
-      branchName: active.branchName
-    })),
     shells: [...activePtys].map(([id, active]) => ({
       id,
       projectId: active.projectId,
       branchName: active.branchName
     }))
   });
-  if (blockedBy.length > 0) {
-    return { status: "blocked", results: [], blockedBy };
-  }
+  const blockedTargetKeys = new Set(blockedBy.map((blocker) => `${blocker.projectId}\0${blocker.branchName}`));
   const results = [];
   for (const { manifest, branchName } of targets) {
+    if (blockedTargetKeys.has(`${manifest.projectId}\0${branchName}`)) {
+      continue;
+    }
     try {
       const commitHash = await forceSyncManifestBranchFromInternal({
         projectId: manifest.projectId,
@@ -1150,6 +1221,16 @@ async function syncManifestProjectsFromInternal(input) {
         branchName,
         manifest
       });
+      if (commitHash === null) {
+        blockedBy.push({
+          projectId: manifest.projectId,
+          projectPath: manifest.projectPath,
+          branchName,
+          kind: "dirty_checkout",
+          id: `${manifest.projectId}:${branchName}`
+        });
+        continue;
+      }
       results.push({
         projectId: manifest.projectId,
         projectPath: manifest.projectPath,
@@ -1167,10 +1248,11 @@ async function syncManifestProjectsFromInternal(input) {
       });
     }
   }
+  const hasFailures = results.some((result) => result.status === "failed");
   return {
-    status: results.some((result) => result.status === "failed") ? "partial" : "completed",
+    status: blockedBy.length > 0 && results.length === 0 ? "blocked" : blockedBy.length > 0 || hasFailures ? "partial" : "completed",
     results,
-    blockedBy: []
+    blockedBy
   };
 }
 function resolveCommandCwd(branchPath, cwd) {
@@ -1221,6 +1303,60 @@ async function streamCommandOutput(stream, onData) {
 function ensureOperationBranch(input) {
   return ensureBranchWorkspace(input);
 }
+async function inspectManagedWorkspace(input) {
+  const candidates = input.manifests.flatMap((manifest) => {
+    const branches = manifest.branches.length > 0 ? manifest.branches : [manifest.defaultBranch || "main"];
+    return branches.map((branchName) => ({
+      manifest,
+      branchName,
+      checkoutPath: path.resolve(input.projectsRoot, manifest.repoSlug || manifest.projectId, branchName)
+    }));
+  });
+  const inspected = await Promise.all(
+    candidates.map(async ({ manifest, branchName, checkoutPath }) => {
+      const gitDir = internalGitDirFor(input.syncRoot, manifest.projectId, branchName);
+      if (!hasNormalVisibleGitDir(checkoutPath) || !fs.existsSync(gitDir)) return null;
+      const context = {
+        gitDir,
+        workTree: checkoutPath,
+        auth: internalGitAuth(input.baseUrl, input.token)
+      };
+      try {
+        const status = await runInternalGitAsync(context, ["status", "--porcelain", "--", ".", ":(exclude).git"]);
+        let commitHash = null;
+        for (const revision of [
+          "HEAD",
+          `refs/remotes/${R5D_REMOTE_NAME}/${branchName}`,
+          `refs/remotes/${R5D_REMOTE_NAME}/main`
+        ]) {
+          try {
+            commitHash = await runInternalGitAsync(context, ["rev-parse", "--verify", revision]);
+            break;
+          } catch {
+          }
+        }
+        if (!commitHash) return null;
+        return {
+          projectId: manifest.projectId,
+          projectPath: manifest.projectPath,
+          branchName,
+          checkoutPath,
+          commitHash,
+          status,
+          dirty: status.trim().length > 0
+        };
+      } catch {
+        return null;
+      }
+    })
+  );
+  return {
+    type: "workspace_status",
+    checkouts: inspected.filter((checkout) => checkout !== null).sort(
+      (left, right) => left.projectPath.localeCompare(right.projectPath) || left.branchName.localeCompare(right.branchName)
+    )
+  };
+}
 function internalGitProcessEnv(workspace, env) {
   if (env?.R5D_USE_INTERNAL_GIT !== "1") {
     return {};
@@ -1787,6 +1923,22 @@ function pullBranch(input) {
 }
 async function executeOperation(input) {
   switch (input.message.type) {
+    case "resolve_managed_path":
+      return resolveManagedCheckoutPath({
+        projectsRoot: input.projectsRoot,
+        manifests: input.manifests,
+        originProjectId: input.message.projectId,
+        originBranchName: input.message.branchName,
+        inputPath: input.message.inputPath
+      });
+    case "workspace_status":
+      return await inspectManagedWorkspace({
+        baseUrl: input.baseUrl,
+        token: input.token,
+        projectsRoot: input.projectsRoot,
+        syncRoot: input.syncRoot,
+        manifests: input.manifests
+      });
     case "read":
       return executeReadFileOperation({ ...input, message: input.message });
     case "write":
@@ -1889,9 +2041,11 @@ async function executeCommand(input) {
       projectId: input.projectId,
       sessionId: input.message.sessionId ?? "",
       branchName: input.message.branchName,
+      mode: "foreground",
+      startCommitHash: "",
       argv: input.message.argv,
       command: input.message.argv.join(" "),
-      cwd: input.message.cwd,
+      cwd,
       startedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
     if (input.message.timeoutMs) {
@@ -1994,17 +2148,28 @@ async function executeStreamingCommand(input) {
       projectId: input.projectId,
       sessionId: input.message.sessionId,
       branchName: input.message.branchName,
+      mode: input.message.mode,
+      startCommitHash: input.message.startCommitHash,
+      launchWorkspaceActionId: input.message.launchWorkspaceActionId,
       credentialId: input.message.credentialId,
+      pid: subprocess.pid,
+      processGroupId: subprocess.pid,
       argv: input.message.argv,
       command: input.message.command,
-      cwd: input.message.cwd,
+      // Persist the resolved absolute cwd so reconnect reports and process
+      // history retain the actual execution location, including cross-project
+      // managed paths.
+      cwd,
       startedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
     started = true;
     sendWorkerMessage(input.ws, {
       type: "exec_started",
       requestId: input.message.requestId,
-      runId: input.message.runId
+      runId: input.message.runId,
+      cwd,
+      pid: subprocess.pid,
+      processGroupId: subprocess.pid
     });
     if (input.message.timeoutMs) {
       timeout = setTimeout(() => {
@@ -2083,7 +2248,12 @@ function buildActiveProcessReports() {
     projectId: active.projectId,
     sessionId: active.sessionId,
     branchName: active.branchName,
+    mode: active.mode,
+    startCommitHash: active.startCommitHash,
+    ...active.launchWorkspaceActionId ? { launchWorkspaceActionId: active.launchWorkspaceActionId } : {},
     ...active.credentialId ? { credentialId: active.credentialId } : {},
+    ...active.pid !== void 0 ? { pid: active.pid } : {},
+    ...active.processGroupId !== void 0 ? { processGroupId: active.processGroupId } : {},
     argv: active.argv,
     command: active.command,
     ...active.cwd ? { cwd: active.cwd } : {},
@@ -2530,7 +2700,7 @@ async function startWorker(options) {
               projectsRoot,
               syncRoot,
               manifests: [...manifestByProjectId.values()],
-              projectIds: message.projectIds
+              requestedTargets: message.targets
             });
             for (const result of syncResult.results) {
               if (result.status !== "synced") continue;
@@ -2580,6 +2750,7 @@ async function startWorker(options) {
           requestId: message.requestId,
           result: syncResult
         });
+        sendActiveProcessReport(ws);
         return;
       }
       if (message.type === "update_clis") {
@@ -2761,7 +2932,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" || message.type === "sync" || message.type === "confirm_large_diff" || message.type === "pull_branch") {
+      if (message.type === "resolve_managed_path" || message.type === "workspace_status" || 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 === "sync" || message.type === "confirm_large_diff" || message.type === "pull_branch") {
         try {
           await repositorySyncQueue;
           const manifest = manifestByProjectId.get(message.projectId);
@@ -2774,6 +2945,8 @@ async function startWorker(options) {
             projectRoot,
             syncRoot,
             artifactRoot,
+            projectsRoot,
+            manifests: [...manifestByProjectId.values()],
             manifest
           });
           ws.send(
@@ -2888,6 +3061,7 @@ export {
   findWorkerFiles,
   githubCliEnv,
   grepWorkerFiles,
+  inspectManagedWorkspace,
   isArtifactEnvPath,
   listWorkerDirectory,
   prepareArtifactEnvForShell,
@@ -2895,8 +3069,10 @@ export {
   readWorkerImageFile,
   readWorkerTextFile,
   resolveHostShell,
+  resolveManagedCheckoutPath,
   resolveProjectFilePath,
   resolveWorkerFilePath,
+  selectManifestSyncTargets,
   syncManifestProjectsFromInternal,
   syncProjectPlans,
   syncSessionArtifacts

package/dist/mjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "type": "module"
 }

package/dist/types/main.d.ts

@@ -26,6 +26,10 @@ type WorkerRepositorySyncTarget = {
     projectPath: string;
     branchName: string;
 };
+type WorkerRepositorySyncSelector = {
+    projectId: string;
+    branchName: string;
+};
 type WorkerRepositorySyncResult = {
     status: "completed" | "partial" | "blocked";
     results: Array<WorkerRepositorySyncTarget & ({
@@ -36,7 +40,7 @@ type WorkerRepositorySyncResult = {
         error: string;
     })>;
     blockedBy: Array<WorkerRepositorySyncTarget & {
-        kind: "process" | "shell";
+        kind: "dirty_checkout" | "shell";
         id: string;
     }>;
 };
@@ -68,6 +72,28 @@ type WorkerViewFileBytesResult = {
     width: number;
     height: number;
 };
+type WorkerManagedCheckout = {
+    projectId: string;
+    projectPath: string;
+    branchName: string;
+    checkoutPath: string;
+};
+type WorkerResolveManagedPathResult = {
+    type: "resolve_managed_path";
+    resolved: (WorkerManagedCheckout & {
+        inputPath: string;
+        absolutePath: string;
+        repoRelativePath: string;
+    }) | null;
+};
+type WorkerWorkspaceStatusResult = {
+    type: "workspace_status";
+    checkouts: Array<WorkerManagedCheckout & {
+        commitHash: string;
+        status: string;
+        dirty: boolean;
+    }>;
+};
 export declare function isArtifactEnvPath(filePath: string): boolean;
 export declare function syncSessionArtifacts(input: {
     baseUrl: string;
@@ -119,6 +145,13 @@ export declare function resolveWorkerFilePath(branchPath: string, inputPath: str
 export declare function resolveProjectFilePath(branchPath: string, inputPath: string): Extract<ResolvedWorkerFilePath, {
     scope: "project";
 }>;
+export declare function resolveManagedCheckoutPath(input: {
+    projectsRoot: string;
+    manifests: WorkerProjectManifestEntry[];
+    originProjectId: string;
+    originBranchName: string;
+    inputPath: string;
+}): WorkerResolveManagedPathResult;
 export declare function githubCliEnv(token: string | null | undefined): Record<string, string>;
 export declare function ensureVisibleGitCheckout(input: {
     projectRoot: string;
@@ -131,25 +164,34 @@ export declare function ensureVisibleGitCheckout(input: {
 }): string;
 export declare function findRepositorySyncBlockers(input: {
     targets: WorkerRepositorySyncTarget[];
-    processes: Array<{
-        id: string;
-        projectId: string;
-        branchName: string;
-    }>;
     shells: Array<{
         id: string;
         projectId: string;
         branchName: string;
     }>;
 }): WorkerRepositorySyncResult["blockedBy"];
+export declare function selectManifestSyncTargets(input: {
+    manifests: WorkerProjectManifestEntry[];
+    requestedTargets?: WorkerRepositorySyncSelector[];
+}): Array<{
+    manifest: WorkerProjectManifestEntry;
+    branchName: string;
+}>;
 export declare function syncManifestProjectsFromInternal(input: {
     baseUrl: string;
     token: string;
     projectsRoot: string;
     syncRoot: string;
     manifests: WorkerProjectManifestEntry[];
-    projectIds?: string[];
+    requestedTargets?: WorkerRepositorySyncSelector[];
 }): Promise<WorkerRepositorySyncResult>;
+export declare function inspectManagedWorkspace(input: {
+    baseUrl: string;
+    token: string;
+    projectsRoot: string;
+    syncRoot: string;
+    manifests: WorkerProjectManifestEntry[];
+}): Promise<WorkerWorkspaceStatusResult>;
 export declare function readWorkerTextFile(branchPath: string, filePath: string, offset?: number, limit?: number): WorkerReadFileResult;
 export declare function grepWorkerFiles(branchPath: string, input: {
     pattern: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "type": "module",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/mjs/main.mjs",