@ricsam/r5d-worker 0.0.35 → 0.0.36

package/dist/cjs/main.cjs

@@ -34,7 +34,6 @@ __export(main_exports, {
   findWorkerFiles: () => findWorkerFiles,
   githubCliEnv: () => githubCliEnv,
   grepWorkerFiles: () => grepWorkerFiles,
-  inspectManagedWorkspace: () => inspectManagedWorkspace,
   isArtifactEnvPath: () => isArtifactEnvPath,
   listWorkerDirectory: () => listWorkerDirectory,
   prepareArtifactEnvForShell: () => prepareArtifactEnvForShell,
@@ -42,10 +41,8 @@ __export(main_exports, {
   readWorkerImageFile: () => readWorkerImageFile,
   readWorkerTextFile: () => readWorkerTextFile,
   resolveHostShell: () => resolveHostShell,
-  resolveManagedCheckoutPath: () => resolveManagedCheckoutPath,
   resolveProjectFilePath: () => resolveProjectFilePath,
   resolveWorkerFilePath: () => resolveWorkerFilePath,
-  selectManifestSyncTargets: () => selectManifestSyncTargets,
   syncManifestProjectsFromInternal: () => syncManifestProjectsFromInternal,
   syncProjectPlans: () => syncProjectPlans,
   syncSessionArtifacts: () => syncSessionArtifacts
@@ -746,11 +743,6 @@ 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,
@@ -769,11 +761,6 @@ 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 || ".",
@@ -785,60 +772,11 @@ function resolveProjectFilePath(branchPath, inputPath) {
   const resolved = resolveWorkerFilePath(branchPath, inputPath);
   if (resolved.scope === "host") {
     throw new Error(
-      `Project file writes must resolve inside the selected managed checkout: ${inputPath}`
+      `Project file writes must use a checkout-relative path. Absolute host paths are read-only in file tools: ${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;
@@ -1207,9 +1145,6 @@ 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);
@@ -1217,34 +1152,21 @@ 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 targets = selectManifestSyncTargets({
-    manifests: input.manifests,
-    requestedTargets: input.requestedTargets
+  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 blockedBy = findRepositorySyncBlockers({
     targets: targets.map(({ manifest, branchName }) => ({
@@ -1252,18 +1174,22 @@ 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
     }))
   });
-  const blockedTargetKeys = new Set(blockedBy.map((blocker) => `${blocker.projectId}\0${blocker.branchName}`));
+  if (blockedBy.length > 0) {
+    return { status: "blocked", results: [], blockedBy };
+  }
   const results = [];
   for (const { manifest, branchName } of targets) {
-    if (blockedTargetKeys.has(`${manifest.projectId}\0${branchName}`)) {
-      continue;
-    }
     try {
       const commitHash = await forceSyncManifestBranchFromInternal({
         projectId: manifest.projectId,
@@ -1274,16 +1200,6 @@ 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,
@@ -1301,11 +1217,10 @@ async function syncManifestProjectsFromInternal(input) {
       });
     }
   }
-  const hasFailures = results.some((result) => result.status === "failed");
   return {
-    status: blockedBy.length > 0 && results.length === 0 ? "blocked" : blockedBy.length > 0 || hasFailures ? "partial" : "completed",
+    status: results.some((result) => result.status === "failed") ? "partial" : "completed",
     results,
-    blockedBy
+    blockedBy: []
   };
 }
 function resolveCommandCwd(branchPath, cwd) {
@@ -1356,60 +1271,6 @@ 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 {};
@@ -1976,22 +1837,6 @@ 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":
@@ -2095,7 +1940,8 @@ async function executeCommand(input) {
       sessionId: input.message.sessionId ?? "",
       branchName: input.message.branchName,
       mode: "foreground",
-      startCommitHash: "",
+      pid: subprocess.pid,
+      processGroupId: process.platform === "win32" ? void 0 : subprocess.pid,
       argv: input.message.argv,
       command: input.message.argv.join(" "),
       cwd,
@@ -2202,16 +2048,11 @@ async function executeStreamingCommand(input) {
       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,
+      processGroupId: process.platform === "win32" ? void 0 : subprocess.pid,
+      credentialId: input.message.credentialId,
       argv: input.message.argv,
       command: input.message.command,
-      // 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()
     });
@@ -2222,7 +2063,7 @@ async function executeStreamingCommand(input) {
       runId: input.message.runId,
       cwd,
       pid: subprocess.pid,
-      processGroupId: subprocess.pid
+      ...process.platform === "win32" ? {} : { processGroupId: subprocess.pid }
     });
     if (input.message.timeoutMs) {
       timeout = setTimeout(() => {
@@ -2301,12 +2142,12 @@ function buildActiveProcessReports() {
     projectId: active.projectId,
     sessionId: active.sessionId,
     branchName: active.branchName,
+    platform: process.platform,
+    arch: process.arch,
     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 } : {},
+    ...active.credentialId ? { credentialId: active.credentialId } : {},
     argv: active.argv,
     command: active.command,
     ...active.cwd ? { cwd: active.cwd } : {},
@@ -2753,7 +2594,7 @@ async function startWorker(options) {
               projectsRoot,
               syncRoot,
               manifests: [...manifestByProjectId.values()],
-              requestedTargets: message.targets
+              projectIds: message.projectIds
             });
             for (const result of syncResult.results) {
               if (result.status !== "synced") continue;
@@ -2803,7 +2644,6 @@ async function startWorker(options) {
           requestId: message.requestId,
           result: syncResult
         });
-        sendActiveProcessReport(ws);
         return;
       }
       if (message.type === "update_clis") {
@@ -2985,7 +2825,7 @@ async function startWorker(options) {
         }
         return;
       }
-      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") {
+      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") {
         try {
           await repositorySyncQueue;
           const manifest = manifestByProjectId.get(message.projectId);
@@ -2998,8 +2838,6 @@ async function startWorker(options) {
             projectRoot,
             syncRoot,
             artifactRoot,
-            projectsRoot,
-            manifests: [...manifestByProjectId.values()],
             manifest
           });
           ws.send(
@@ -3115,7 +2953,6 @@ if (isCliEntrypoint()) {
   findWorkerFiles,
   githubCliEnv,
   grepWorkerFiles,
-  inspectManagedWorkspace,
   isArtifactEnvPath,
   listWorkerDirectory,
   prepareArtifactEnvForShell,
@@ -3123,10 +2960,8 @@ 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.35",
+  "version": "0.0.36",
   "type": "commonjs"
 }

package/dist/mjs/main.mjs

@@ -693,11 +693,6 @@ 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,
@@ -716,11 +711,6 @@ 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 || ".",
@@ -732,60 +722,11 @@ function resolveProjectFilePath(branchPath, inputPath) {
   const resolved = resolveWorkerFilePath(branchPath, inputPath);
   if (resolved.scope === "host") {
     throw new Error(
-      `Project file writes must resolve inside the selected managed checkout: ${inputPath}`
+      `Project file writes must use a checkout-relative path. Absolute host paths are read-only in file tools: ${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;
@@ -1154,9 +1095,6 @@ 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);
@@ -1164,34 +1102,21 @@ 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 targets = selectManifestSyncTargets({
-    manifests: input.manifests,
-    requestedTargets: input.requestedTargets
+  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 blockedBy = findRepositorySyncBlockers({
     targets: targets.map(({ manifest, branchName }) => ({
@@ -1199,18 +1124,22 @@ 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
     }))
   });
-  const blockedTargetKeys = new Set(blockedBy.map((blocker) => `${blocker.projectId}\0${blocker.branchName}`));
+  if (blockedBy.length > 0) {
+    return { status: "blocked", results: [], blockedBy };
+  }
   const results = [];
   for (const { manifest, branchName } of targets) {
-    if (blockedTargetKeys.has(`${manifest.projectId}\0${branchName}`)) {
-      continue;
-    }
     try {
       const commitHash = await forceSyncManifestBranchFromInternal({
         projectId: manifest.projectId,
@@ -1221,16 +1150,6 @@ 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,
@@ -1248,11 +1167,10 @@ async function syncManifestProjectsFromInternal(input) {
       });
     }
   }
-  const hasFailures = results.some((result) => result.status === "failed");
   return {
-    status: blockedBy.length > 0 && results.length === 0 ? "blocked" : blockedBy.length > 0 || hasFailures ? "partial" : "completed",
+    status: results.some((result) => result.status === "failed") ? "partial" : "completed",
     results,
-    blockedBy
+    blockedBy: []
   };
 }
 function resolveCommandCwd(branchPath, cwd) {
@@ -1303,60 +1221,6 @@ 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 {};
@@ -1923,22 +1787,6 @@ 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":
@@ -2042,7 +1890,8 @@ async function executeCommand(input) {
       sessionId: input.message.sessionId ?? "",
       branchName: input.message.branchName,
       mode: "foreground",
-      startCommitHash: "",
+      pid: subprocess.pid,
+      processGroupId: process.platform === "win32" ? void 0 : subprocess.pid,
       argv: input.message.argv,
       command: input.message.argv.join(" "),
       cwd,
@@ -2149,16 +1998,11 @@ async function executeStreamingCommand(input) {
       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,
+      processGroupId: process.platform === "win32" ? void 0 : subprocess.pid,
+      credentialId: input.message.credentialId,
       argv: input.message.argv,
       command: input.message.command,
-      // 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()
     });
@@ -2169,7 +2013,7 @@ async function executeStreamingCommand(input) {
       runId: input.message.runId,
       cwd,
       pid: subprocess.pid,
-      processGroupId: subprocess.pid
+      ...process.platform === "win32" ? {} : { processGroupId: subprocess.pid }
     });
     if (input.message.timeoutMs) {
       timeout = setTimeout(() => {
@@ -2248,12 +2092,12 @@ function buildActiveProcessReports() {
     projectId: active.projectId,
     sessionId: active.sessionId,
     branchName: active.branchName,
+    platform: process.platform,
+    arch: process.arch,
     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 } : {},
+    ...active.credentialId ? { credentialId: active.credentialId } : {},
     argv: active.argv,
     command: active.command,
     ...active.cwd ? { cwd: active.cwd } : {},
@@ -2700,7 +2544,7 @@ async function startWorker(options) {
               projectsRoot,
               syncRoot,
               manifests: [...manifestByProjectId.values()],
-              requestedTargets: message.targets
+              projectIds: message.projectIds
             });
             for (const result of syncResult.results) {
               if (result.status !== "synced") continue;
@@ -2750,7 +2594,6 @@ async function startWorker(options) {
           requestId: message.requestId,
           result: syncResult
         });
-        sendActiveProcessReport(ws);
         return;
       }
       if (message.type === "update_clis") {
@@ -2932,7 +2775,7 @@ async function startWorker(options) {
         }
         return;
       }
-      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") {
+      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") {
         try {
           await repositorySyncQueue;
           const manifest = manifestByProjectId.get(message.projectId);
@@ -2945,8 +2788,6 @@ async function startWorker(options) {
             projectRoot,
             syncRoot,
             artifactRoot,
-            projectsRoot,
-            manifests: [...manifestByProjectId.values()],
             manifest
           });
           ws.send(
@@ -3061,7 +2902,6 @@ export {
   findWorkerFiles,
   githubCliEnv,
   grepWorkerFiles,
-  inspectManagedWorkspace,
   isArtifactEnvPath,
   listWorkerDirectory,
   prepareArtifactEnvForShell,
@@ -3069,10 +2909,8 @@ 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.35",
+  "version": "0.0.36",
   "type": "module"
 }

package/dist/types/main.d.ts

@@ -26,10 +26,6 @@ type WorkerRepositorySyncTarget = {
     projectPath: string;
     branchName: string;
 };
-type WorkerRepositorySyncSelector = {
-    projectId: string;
-    branchName: string;
-};
 type WorkerRepositorySyncResult = {
     status: "completed" | "partial" | "blocked";
     results: Array<WorkerRepositorySyncTarget & ({
@@ -40,7 +36,7 @@ type WorkerRepositorySyncResult = {
         error: string;
     })>;
     blockedBy: Array<WorkerRepositorySyncTarget & {
-        kind: "dirty_checkout" | "shell";
+        kind: "process" | "shell";
         id: string;
     }>;
 };
@@ -72,28 +68,6 @@ 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;
@@ -145,13 +119,6 @@ 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;
@@ -164,34 +131,25 @@ 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[];
-    requestedTargets?: WorkerRepositorySyncSelector[];
+    projectIds?: string[];
 }): 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.35",
+  "version": "0.0.36",
   "type": "module",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/mjs/main.mjs",