@ricsam/r5d-worker 0.0.132 → 0.0.134

package/dist/mjs/main.mjs

@@ -62,11 +62,21 @@ import {
 } from "./workspace-command-sync-policy.mjs";
 import { WorkspaceMutationGate } from "./workspace-mutation-gate.mjs";
 import { WorkspaceMountHoldAbortedError, WorkspaceMountHoldFence } from "./workspace-mount-hold-fence.mjs";
+import {
+  commandTargets,
+  describeCommandAdditionalTargets,
+  normalizeCommandAdditionalTargets
+} from "./workspace-command-targets.mjs";
 import { installWorkspaceFilesystemExecutorFailureHandler, workspaceFilesystemExecutor } from "./workspace-filesystem-executor.mjs";
+import { findHydrationRecovery } from "./workspace-hydration-recovery-state.mjs";
 import { WorkspaceProjectionLedger } from "./workspace-projection-ledger.mjs";
 import { WorkspaceSyncCoalescer } from "./workspace-sync-coalescer.mjs";
 import { checkoutPathMovePublicationComplete } from "./workspace-path-move.mjs";
-import { busyProjectConfigurationChangeIds, deferredProjectConfigurationPendingBranches } from "./workspace-project-config-policy.mjs";
+import {
+  busyProjectConfigurationChanges,
+  deferredProjectConfigurationPendingBranches,
+  describeBusyProjectConfigurationChanges
+} from "./workspace-project-config-policy.mjs";
 import { creatorLocalProjectBranchIsAuthorized, workerProjectBranchDisposition } from "./workspace-preserve-only-policy.mjs";
 import { assertProjectBranchDeletionIncarnation } from "./workspace-branch-incarnation-policy.mjs";
 import { activeProjectBranchPublicationEvidence } from "./workspace-publication-evidence.mjs";
@@ -170,6 +180,16 @@ const workerLifecycleTestHarness = {
   workerCommandHasWorkspaceEffect
 };
 class ProjectWorkspaceConfigurationDeferredError extends Error {
+  constructor(changes) {
+    super(
+      `Project workspace configuration deferred while visible checkout activity is active: ${describeBusyProjectConfigurationChanges(changes)}`
+    );
+    this.changes = changes;
+    this.name = "ProjectWorkspaceConfigurationDeferredError";
+    this.projectIds = changes.map(({ projectId }) => projectId);
+  }
+  changes;
+  projectIds;
 }
 class WorkerServerUnavailableError extends Error {
   name = "WorkerServerUnavailableError";
@@ -393,13 +413,12 @@ const workspaceSyncSingleFlight = {
   afterCurrent() {
     return workspaceSyncQueue;
   },
-  mountHold(target, signal) {
-    if (target.type !== "project") return null;
-    const mountIds = [projectMountId(target.projectId, target.branchName)];
-    if (!workspaceMountHoldFence.isHeld(mountIds)) return null;
+  mountHold(targets, signal) {
+    const mountIds = targets.flatMap((target) => target.type === "project" ? [projectMountId(target.projectId, target.branchName)] : []);
+    if (mountIds.length === 0 || !workspaceMountHoldFence.isHeld(mountIds)) return null;
     const holder = workspaceMountHoldFence.describeHold(mountIds);
     process.stdout.write(
-      `[r5d-worker] command for ${target.projectId}/${target.branchName} waits for ${holder ?? "a workspace filesystem job"}
+      `[r5d-worker] command for ${targets.map(describeWorkerSessionTarget).join(", ")} waits for ${holder ?? "a workspace filesystem job"}
 `
     );
     return workspaceMountHoldFence.waitForRelease(mountIds, { signal });
@@ -1012,6 +1031,7 @@ function validateProjectId(projectId) {
 function validateBranchName(branchName) {
   validateManagedBranchName(branchName);
 }
+const commandTargetValidators = { validateProjectId, validateBranchName };
 const NON_RECURSIVE_GIT_CONFIG_ARGS = [
   "-c",
   "submodule.recurse=false",
@@ -2963,6 +2983,7 @@ async function executeCommand(input) {
     activeProcesses.set(input.message.runId, {
       process: subprocess,
       target: input.resolvedTarget.target,
+      additionalTargets: [...input.additionalTargets],
       sessionId: input.message.sessionId ?? "",
       mode: "foreground",
       pid: subprocess.pid,
@@ -3096,6 +3117,7 @@ async function executeStreamingCommand(input) {
     activeProcesses.set(input.message.runId, {
       process: subprocess,
       target: input.resolvedTarget.target,
+      additionalTargets: [...input.additionalTargets],
       sessionId: input.message.sessionId,
       mode: input.message.mode,
       pid: subprocess.pid,
@@ -3336,6 +3358,7 @@ function buildActiveProcessReports() {
   return Array.from(activeProcesses.entries()).filter(([, active]) => active.sessionId.length > 0).map(([runId, active]) => ({
     runId,
     target: active.target,
+    ...active.additionalTargets.length > 0 ? { additionalTargets: active.additionalTargets.flatMap((target) => target.type === "project" ? [target] : []) } : {},
     sessionId: active.sessionId,
     platform: process.platform,
     arch: process.arch,
@@ -3743,6 +3766,7 @@ async function openPty(input) {
     activePtys.set(input.message.ptyId, {
       ...ptyProcess,
       target: input.resolvedTarget.target,
+      additionalTargets: [...input.additionalTargets],
       foregroundBusy: true,
       lastInputAt: 0,
       ...input.releaseWorkspaceMutation ? { releaseWorkspaceMutation: input.releaseWorkspaceMutation } : {}
@@ -3968,6 +3992,7 @@ async function startWorker(options, projectRuntime = {
   let workspaceCredentialUsername = null;
   let workspaceGitIdentity = projectRuntime.gitIdentity;
   let workspaceConfigured = false;
+  let hydrationRecoveryRequired;
   let activeWorkspaceIncidentId = null;
   let deferredWorkspaceConfiguration = null;
   let deferredWorkspaceConfigurationRefreshTimer;
@@ -4267,12 +4292,12 @@ async function startWorker(options, projectRuntime = {
     });
   };
   const activeWorkspaceMutationTargets = () => [
-    ...Array.from(activeProcesses.values()).filter(workerCommandHasWorkspaceEffect).map(({ target }) => target),
+    ...Array.from(activeProcesses.values()).filter(workerCommandHasWorkspaceEffect).flatMap(({ target, additionalTargets }) => [target, ...additionalTargets]),
     ...credentialBearingProcessGroupTargets.values(),
-    ...workspaceSyncPriorityProcessTargets.values(),
+    ...Array.from(workspaceSyncPriorityProcessTargets.values()).flat(),
     ...workspaceSyncPriorityOperationTargets.values(),
-    ...Array.from(activePtys.values()).filter((pty) => workerPtyIsWorkspaceBusy(pty)).map(({ target }) => target),
-    ...workspaceSyncPriorityPtyTargets.values()
+    ...Array.from(activePtys.values()).filter((pty) => workerPtyIsWorkspaceBusy(pty)).flatMap(({ target, additionalTargets }) => [target, ...additionalTargets]),
+    ...Array.from(workspaceSyncPriorityPtyTargets.values()).flat()
   ];
   let visibleWorkspaceMutationEpoch = 0;
   const projectWorkspaceMutationEpochs = /* @__PURE__ */ new Map();
@@ -4284,6 +4309,9 @@ async function startWorker(options, projectRuntime = {
     const key = projectBranchKey(target.projectId, target.branchName);
     projectWorkspaceMutationEpochs.set(key, (projectWorkspaceMutationEpochs.get(key) ?? 0) + 1);
   };
+  const recordAdditionalTargetMutations = (additional) => {
+    for (const target of additional) recordVisibleWorkspaceMutation(target);
+  };
   const projectWorkspaceMutationToken = (projectId, branchName) => `${visibleWorkspaceMutationEpoch}:${projectWorkspaceMutationEpochs.get(projectBranchKey(projectId, branchName)) ?? 0}`;
   const canonicalWorkspaceMutationIsActive = (targets) => targets.some((target) => target.type === "workspace" && target.rootProfile === "canonical_sync");
   const projectBranchMountActivityBusy = (projectId, branchName, branchPath) => {
@@ -4369,6 +4397,24 @@ async function startWorker(options, projectRuntime = {
           preserveLocalOnInitialOuterAbsence: creatorLocalIncarnation,
           ...initialPublicationSourceBranch ? { initialPublicationSourceRelativePath: workspaceProjectRelativePath(project.projectId, initialPublicationSourceBranch) } : {},
           preserveLocalOnHydrationBasisChange: preservesCheckoutPathMove,
+          describeHolders: () => [
+            ...new Set(
+              [
+                ...[...activeProcesses.values()].filter(
+                  (entry) => projectBranchHasActiveWorkspaceTarget(project.projectId, branch.branchName, [
+                    entry.target,
+                    ...entry.additionalTargets
+                  ])
+                ).map((entry) => entry.sessionId),
+                ...[...activePtys.entries()].filter(
+                  ([, entry]) => projectBranchHasActiveWorkspaceTarget(project.projectId, branch.branchName, [
+                    entry.target,
+                    ...entry.additionalTargets
+                  ])
+                ).map(([ptyId]) => `pty:${ptyId}`)
+              ].filter((id) => typeof id === "string")
+            )
+          ].join(", ") || "no live declared holder",
           busy: () => projectBranchMountBusy(project.projectId, branch.branchName, branchPath),
           mutationToken: () => projectWorkspaceMutationToken(project.projectId, branch.branchName),
           busyForRecovery: () => projectBranchMountExclusiveSyncBusy(project.projectId, branch.branchName, branchPath)
@@ -4894,6 +4940,7 @@ async function startWorker(options, projectRuntime = {
       affectedPaths: result.affectedPaths,
       activeMountIds: result.activeMountIds,
       skippedMountIds: result.skippedMountIds,
+      ...result.mountSkipReasons ? { mountSkipReasons: result.mountSkipReasons } : {},
       ...missingCheckouts ? { missingCheckouts } : {},
       activeProjectBranchPublications,
       discardedPaths: [],
@@ -4906,8 +4953,11 @@ async function startWorker(options, projectRuntime = {
     };
   };
   const failedWorkspaceSyncResult = async (attemptId, trigger, error) => {
+    const recovery = findHydrationRecovery(error);
+    if (recovery) hydrationRecoveryRequired = recovery;
     const localHead = await workspaceLocalHead();
     return {
+      ...recovery ? { failureReason: "hydration_recovery_required", hydrationRecovery: recovery } : {},
       type: "workspace_sync",
       attemptId,
       workerLabel: label,
@@ -5130,6 +5180,12 @@ async function startWorker(options, projectRuntime = {
     } catch (error) {
       workspaceProjectionLedger.reset();
       const errorMessage = error instanceof Error ? error.message : String(error);
+      if (findHydrationRecovery(error)) {
+        workspaceConfigured = false;
+        projectRuntime.configuration = void 0;
+        advanceWorkerAdmissionGeneration();
+        return await failedWorkspaceSyncResult(attemptId, input.trigger, error);
+      }
       const hydrationRecoverable = workspaceSyncFailureHydrationIsSafe({
         error,
         resetToCanonical: input.resetToCanonical === true,
@@ -5373,6 +5429,10 @@ async function startWorker(options, projectRuntime = {
   projectRuntime.markWorkspaceDirty = markWorkspaceDirty;
   const targetMayMutateVisibleWorkspace = (target) => target.type === "project" || target.rootProfile === "visible_projects";
   const resolveMessageTarget = (target) => {
+    if (hydrationRecoveryRequired)
+      throw new Error(
+        `Workspace hydration recovery required for transaction ${hydrationRecoveryRequired.transactionId}; inspect r5dctl workspace status`
+      );
     if (!workspaceConfigured) throw new Error("Worker workspace configuration has not completed successfully");
     if (!deferredWorkspaceTargetIsAllowed(deferredWorkspaceConfiguration, activeWorkspaceIncidentId, target)) {
       throw new Error(
@@ -5392,6 +5452,11 @@ async function startWorker(options, projectRuntime = {
       projectConfigById
     });
   };
+  const resolveCommandMessageTarget = (target, additionalTargets) => {
+    const primary = resolveMessageTarget(target);
+    for (const additional of additionalTargets) resolveMessageTarget(additional);
+    return primary;
+  };
   const configureWorkerWorkspace = async (message, receiptGeneration) => {
     const configurationOperationId = crypto.randomUUID();
     sendLifecycleProgress({
@@ -5566,7 +5631,7 @@ async function startWorker(options, projectRuntime = {
           throw new Error("Workspace configuration was superseded by a different active workspace incident");
         }
         for (const project of message.projects) assertRepositoryTransitionState(project);
-        const busyConfigurationChanges = busyProjectConfigurationChangeIds({
+        const busyConfigurationChanges = busyProjectConfigurationChanges({
           currentProjects: [...projectConfigById.values()],
           incomingProjects: message.projects,
           activeTargets: activeWorkspaceMutationTargets(),
@@ -5577,12 +5642,44 @@ async function startWorker(options, projectRuntime = {
             return readyProjectIds.has(project.projectId) && reconciledProjectConfigFingerprints.get(project.projectId) === fingerprint && project.branches.every(({ branchName }) => hasProjectWorktree(configuredProjectBranchPath(projectsRoot, project, branchName)));
           }
         });
-        if (busyConfigurationChanges.length > 0) {
-          throw new ProjectWorkspaceConfigurationDeferredError(
-            `Project workspace configuration deferred while visible checkout activity is active: ${busyConfigurationChanges.join(", ")}`
+        if (busyConfigurationChanges.length > 0) throw new ProjectWorkspaceConfigurationDeferredError(busyConfigurationChanges);
+        workspaceConfigured = false;
+        if (message.recoverHydrationTransactionId) {
+          if (incidentDeferral.incidentId || message.resetToCanonical)
+            throw new Error("Hydration preservation cannot run during a canonical reset or another workspace incident");
+          if (activeProcesses.size || activePtys.size || credentialBearingProcessGroups.size || pendingProcessTerminals.size || activeWorkspaceMutationTargets().length) {
+            throw new Error("Stop active worker processes and terminals before preserving interrupted hydration");
+          }
+          const preservedHydration = await workspaceFilesystemExecutor().run("hydration_preserve_interrupted", {
+            workspacePath: workspaceShadowRoot,
+            expectedTransactionId: message.recoverHydrationTransactionId
+          });
+          process.stdout.write(
+            `[r5d-worker] Preserved hydration ${preservedHydration.transactionId}; archived evidence: ${preservedHydration.archivePath}
+`
+          );
+          for (const entry of preservedHydration.retainedEntries ?? []) {
+            process.stdout.write(
+              `[r5d-worker] Retained writer evidence for ${entry.mountId}: ${entry.sourcePath}; archived copy: ${entry.archivePath}
+`
+            );
+          }
+          hydrationRecoveryRequired = void 0;
+        }
+        const interruptedHydration = await workspaceFilesystemExecutor().run("hydration_recovery_inspect", {
+          workspacePath: workspaceShadowRoot
+        });
+        if (interruptedHydration) {
+          throw Object.assign(
+            new Error(
+              `Interrupted hydration ${interruptedHydration.transactionId} requires explicit recovery; checkout files and snapshots are preserved`
+            ),
+            {
+              code: "hydration_recovery_required",
+              hydrationRecovery: interruptedHydration
+            }
           );
         }
-        workspaceConfigured = false;
         workspaceProjectionLedger.reset();
         const preserveOnlyBranches = message.projects.flatMap(
           (project) => project.preserveOnlyBranches.map(({ branchId, branchName }) => ({ branchId, projectId: project.projectId, branchName }))
@@ -5848,6 +5945,7 @@ async function startWorker(options, projectRuntime = {
           deferredWorkspaceConfigurationRefreshTimer = void 0;
         }
         deferredWorkspaceConfiguration = null;
+        hydrationRecoveryRequired = void 0;
         workspaceConfigured = true;
         const pending = [...pendingCheckouts.values()].sort(
           (left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName)
@@ -5890,7 +5988,8 @@ async function startWorker(options, projectRuntime = {
         requireCredentialGenerationRestart(true, void 0, 1);
       }
       workspaceConfigured = false;
-      const deferred = error instanceof ProjectWorkspaceConfigurationDeferredError || error instanceof ProjectWorkspacePendingBranchPathChangeError;
+      const busyDeferral = error instanceof ProjectWorkspaceConfigurationDeferredError ? error : void 0;
+      const deferred = busyDeferral !== void 0 || error instanceof ProjectWorkspacePendingBranchPathChangeError;
       if (deferred) pendingCheckouts.clear();
       for (const pending of deferredProjectConfigurationPendingBranches(message.projects)) {
         pendingCheckouts.set(projectBranchKey(pending.projectId, pending.branchName), pending);
@@ -5900,7 +5999,11 @@ async function startWorker(options, projectRuntime = {
         pending: [...pendingCheckouts.values()].sort(
           (left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName)
         ),
-        aheadOfOriginBranches: []
+        aheadOfOriginBranches: [],
+        // A busy deferral is typed so the server can keep this socket, finish
+        // receipt recovery and renew the execution lease instead of closing
+        // the connection and retrying registration until the lease expires.
+        ...busyDeferral ? { deferredForBusyProjectIds: busyDeferral.projectIds } : {}
       };
     } finally {
       workspaceSyncRequestsInFlight -= 1;
@@ -6089,7 +6192,9 @@ async function startWorker(options, projectRuntime = {
           commandControlLaneV1: workerCommandLauncher?.supportsControlLane === true,
           projectMirrorLeaseV1: true,
           projectMirrorRefsTokensV1: true,
-          projectBranchWorkingTreeModeV1: true
+          projectBranchWorkingTreeModeV1: true,
+          commandAdditionalTargetsV1: true,
+          workspaceHydrationRecoveryV1: true
         },
         root: rootDir
       }
@@ -6325,7 +6430,7 @@ async function startWorker(options, projectRuntime = {
         }
         const digest = workerOperationDigest(message);
         const cached = projectRuntime.configuration;
-        const canReuseConfiguration = cached?.digest === digest && cached.workspaceSync?.remoteUrl === message.workspaceRemoteUrl && Boolean(cached.workspaceSync.credentialHelper) && cached.workspaceSync.credentialUsername === workerCredentialUsername && cached.workspaceSync.gitIdentity?.name === message.gitIdentity.name && cached.workspaceSync.gitIdentity?.email === message.gitIdentity.email && !unsafeWorkspaceSyncBouncePending && credentialGenerationFingerprint({ ...message, workerBaseUrl: baseUrl, workerAuthHeader: bearerAuthHeader }) === configuredCredentialGenerationFingerprint;
+        const canReuseConfiguration = !message.recoverHydrationTransactionId && !hydrationRecoveryRequired && cached?.digest === digest && cached.workspaceSync?.remoteUrl === message.workspaceRemoteUrl && Boolean(cached.workspaceSync.credentialHelper) && cached.workspaceSync.credentialUsername === workerCredentialUsername && cached.workspaceSync.gitIdentity?.name === message.gitIdentity.name && cached.workspaceSync.gitIdentity?.email === message.gitIdentity.email && !unsafeWorkspaceSyncBouncePending && credentialGenerationFingerprint({ ...message, workerBaseUrl: baseUrl, workerAuthHeader: bearerAuthHeader }) === configuredCredentialGenerationFingerprint;
         if (!canReuseConfiguration) {
           advanceWorkerAdmissionGeneration();
           projectRuntime.configuration = void 0;
@@ -6337,7 +6442,8 @@ async function startWorker(options, projectRuntime = {
           result: configured.result,
           pendingCheckouts: configured.pending,
           aheadOfOriginBranches: configured.aheadOfOriginBranches,
-          ...configured.deferredWorkspaceSyncForIncidentId ? { deferredWorkspaceSyncForIncidentId: configured.deferredWorkspaceSyncForIncidentId } : {}
+          ...configured.deferredWorkspaceSyncForIncidentId ? { deferredWorkspaceSyncForIncidentId: configured.deferredWorkspaceSyncForIncidentId } : {},
+          ...configured.deferredForBusyProjectIds ? { deferredForBusyProjectIds: configured.deferredForBusyProjectIds } : {}
         });
         if (receiptGeneration !== workspaceConfigurationReceiptGeneration || currentWorkerSocket !== ws || ws.readyState !== WebSocket.OPEN) {
           sendConfigured();
@@ -6368,7 +6474,17 @@ async function startWorker(options, projectRuntime = {
         if (configured.result.outcome !== "failed") unsafeWorkspaceSyncRecoveryAttempts = 0;
         sendConfigured();
         sendLifecycleProgress(
-          configured.result.outcome === "failed" ? {
+          configured.result.hydrationRecovery ? {
+            phase: "failed",
+            operationId: configured.result.attemptId,
+            detail: `Hydration recovery required: ${configured.result.hydrationRecovery.transactionId}; files and snapshots preserved`
+          } : configured.deferredForBusyProjectIds ? {
+            // Not a failure: the previous generation stays on disk and the
+            // server retries once the busy checkouts are idle.
+            phase: "configuring",
+            operationId: configured.result.attemptId,
+            detail: `Workspace configuration deferred while checkout activity is active on ${configured.deferredForBusyProjectIds.length} project(s)`
+          } : configured.result.outcome === "failed" ? {
             phase: "failed",
             operationId: configured.result.attemptId,
             detail: configured.result.error ?? "Workspace configuration failed"
@@ -6381,10 +6497,12 @@ async function startWorker(options, projectRuntime = {
           }
         );
         process.stdout.write(
-          `[r5d-worker] workspace configured: ${message.projects.length} project(s), ${configured.pending.length} pending checkout(s)
+          configured.result.hydrationRecovery ? `[r5d-worker] workspace hydration recovery required for ${configured.result.hydrationRecovery.transactionId}; execution remains fenced, files and snapshots preserved
+` : configured.deferredForBusyProjectIds ? `[r5d-worker] workspace configuration deferred while visible checkout activity is active on ${configured.deferredForBusyProjectIds.join(", ")}: ${configured.pending.length} checkout(s) pending until the server retries
+` : `[r5d-worker] workspace configured: ${message.projects.length} project(s), ${configured.pending.length} pending checkout(s)
 `
         );
-        if (refreshesDeferredConfiguration && configured.result.outcome === "failed" && deferredWorkspaceConfiguration !== null && currentWorkerSocket === ws) {
+        if (refreshesDeferredConfiguration && configured.result.outcome === "failed" && configured.result.failureReason !== "hydration_recovery_required" && !configured.deferredForBusyProjectIds && deferredWorkspaceConfiguration !== null && currentWorkerSocket === ws) {
           workspaceConfigured = false;
           advanceWorkerAdmissionGeneration();
           ws.close(1012, "Deferred workspace configuration refresh failed");
@@ -6776,6 +6894,7 @@ async function startWorker(options, projectRuntime = {
         if (active.workspaceEffect !== "none" && targetMayMutateVisibleWorkspace(active.target)) {
           recordVisibleWorkspaceMutation(active.target);
         }
+        if (active.workspaceEffect !== "none") recordAdditionalTargetMutations(active.additionalTargets);
         try {
           let bytesWritten = 0;
           if (message.data !== void 0 && message.data.length > 0) {
@@ -6825,16 +6944,19 @@ async function startWorker(options, projectRuntime = {
         let resourcesTransferred = false;
         let releaseWorkspaceMutation;
         let mutationLeaseTransferred = false;
+        let additionalTargets = [];
         try {
+          additionalTargets = normalizeCommandAdditionalTargets(message.target, message.additionalTargets, commandTargetValidators);
           resources = await acquireWorkerCommandLaunch(ws, message, assertMessageAdmission);
           const reservationAbort = registerPendingReservation(`pty:${message.ptyId}`, void 0);
           try {
             await reserveWorkspaceCommandAfterCurrentSync(
-              message.target,
+              commandTargets(message.target, additionalTargets),
               workspaceSyncSingleFlight,
               () => {
-                workspaceSyncPriorityPtyTargets.set(message.ptyId, message.target);
+                workspaceSyncPriorityPtyTargets.set(message.ptyId, commandTargets(message.target, additionalTargets));
                 if (targetMayMutateVisibleWorkspace(message.target)) recordVisibleWorkspaceMutation(message.target);
+                recordAdditionalTargetMutations(additionalTargets);
               },
               { signal: reservationAbort.signal }
             );
@@ -6847,19 +6969,26 @@ async function startWorker(options, projectRuntime = {
               `Shell opening was fenced while queued by workspace incident ${deferredWorkspaceConfiguration?.incidentId ?? activeWorkspaceIncidentId}`
             );
           }
-          const resolvedTarget = resolveMessageTarget(message.target);
-          process.stdout.write(`[r5d-worker] pty ${message.ptyId}: ${describeWorkerSessionTarget(message.target)}
-`);
+          const resolvedTarget = resolveCommandMessageTarget(message.target, additionalTargets);
+          process.stdout.write(
+            `[r5d-worker] pty ${message.ptyId}: ${describeWorkerSessionTarget(message.target)}${describeCommandAdditionalTargets(additionalTargets)}
+`
+          );
           await openPty({
             resources,
             ws,
             message,
             resolvedTarget,
+            additionalTargets,
             rootDir,
-            assertAdmission: assertMessageAdmission,
+            assertAdmission: () => {
+              assertMessageAdmission();
+              resolveCommandMessageTarget(message.target, additionalTargets);
+            },
             ...releaseWorkspaceMutation ? { releaseWorkspaceMutation } : {},
             ...targetMayMutateVisibleWorkspace(message.target) ? {
               onTerminal: () => {
+                recordAdditionalTargetMutations(additionalTargets);
                 markWorkspaceDirty({ type: "process_terminal", detail: `pty ${message.ptyId} completed` }, true, message.target);
               }
             } : {}
@@ -6892,6 +7021,7 @@ async function startWorker(options, projectRuntime = {
           return;
         }
         if (activePty && targetMayMutateVisibleWorkspace(activePty.target)) {
+          recordAdditionalTargetMutations(activePty.additionalTargets);
           markWorkspaceDirty({ type: "shell_inline", detail: `pty ${message.ptyId}` }, false, activePty.target);
         }
         writePty(ws, message);
@@ -6908,6 +7038,7 @@ async function startWorker(options, projectRuntime = {
         abortPendingReservation(`pty:${message.ptyId}`, "Shell closed before it started");
         await closePty(message);
         if (activePty && targetMayMutateVisibleWorkspace(activePty.target)) {
+          recordAdditionalTargetMutations(activePty.additionalTargets);
           markWorkspaceDirty({ type: "process_terminal", detail: `pty ${message.ptyId} closed` }, true, activePty.target);
         }
         sendWorkerMessage(ws, { type: "operation_completed", requestId: message.requestId });
@@ -6939,18 +7070,21 @@ async function startWorker(options, projectRuntime = {
         let resources;
         let targetReserved = false;
         const hasWorkspaceEffect = workerCommandHasWorkspaceEffect(message);
+        let additionalTargets = [];
         try {
+          additionalTargets = normalizeCommandAdditionalTargets(message.target, message.additionalTargets, commandTargetValidators);
           resources = await acquireWorkerCommandLaunch(ws, message, assertMessageAdmission);
           if (hasWorkspaceEffect) {
             const reservationAbort = registerPendingReservation(`run:${message.runId}`, message.sessionId);
             try {
               await reserveWorkspaceCommandAfterCurrentSync(
-                message.target,
+                commandTargets(message.target, additionalTargets),
                 workspaceSyncSingleFlight,
                 () => {
-                  workspaceSyncPriorityProcessTargets.set(message.runId, message.target);
+                  workspaceSyncPriorityProcessTargets.set(message.runId, commandTargets(message.target, additionalTargets));
                   targetReserved = true;
                   if (targetMayMutateVisibleWorkspace(message.target)) recordVisibleWorkspaceMutation(message.target);
+                  recordAdditionalTargetMutations(additionalTargets);
                 },
                 { signal: reservationAbort.signal }
               );
@@ -6964,13 +7098,16 @@ async function startWorker(options, projectRuntime = {
                 `One-shot command was fenced while queued by workspace incident ${deferredWorkspaceConfiguration?.incidentId ?? activeWorkspaceIncidentId}`
               );
             }
-            const resolvedTarget = resolveMessageTarget(message.target);
-            process.stdout.write(`[r5d-worker] exec ${message.runId}: ${message.argv.join(" ")}
-`);
+            const resolvedTarget = resolveCommandMessageTarget(message.target, additionalTargets);
+            process.stdout.write(
+              `[r5d-worker] exec ${message.runId}: ${message.argv.join(" ")}${describeCommandAdditionalTargets(additionalTargets)}
+`
+            );
             return await executeCommand({
               resources,
               message,
               resolvedTarget,
+              additionalTargets,
               baseUrl,
               token,
               rootDir,
@@ -6988,6 +7125,7 @@ async function startWorker(options, projectRuntime = {
                   );
                 }
                 assertMessageAdmission();
+                resolveCommandMessageTarget(message.target, additionalTargets);
               }
             });
           };
@@ -7013,6 +7151,7 @@ async function startWorker(options, projectRuntime = {
         }
         sendSerializedWorkerMessage(ws, JSON.stringify(result));
         if (hasWorkspaceEffect && targetMayMutateVisibleWorkspace(message.target)) {
+          recordAdditionalTargetMutations(additionalTargets);
           markWorkspaceDirty(
             { type: "shell_inline", sessionId: message.sessionId, processRunId: message.runId, detail: "foreground command completed" },
             true,
@@ -7038,11 +7177,23 @@ async function startWorker(options, projectRuntime = {
         });
         const hasWorkspaceEffect = workerCommandHasWorkspaceEffect(message);
         let resources;
+        let additionalTargets;
+        try {
+          additionalTargets = normalizeCommandAdditionalTargets(message.target, message.additionalTargets, commandTargetValidators);
+        } catch (error) {
+          sendWorkerMessageFromCurrentSource(ws, {
+            type: "exec_start_error",
+            requestId: message.requestId,
+            runId: message.runId,
+            error: error instanceof Error ? error.message : String(error)
+          });
+          return;
+        }
         const runCommand = async () => {
           try {
-            const resolvedTarget = resolveMessageTarget(message.target);
+            const resolvedTarget = resolveCommandMessageTarget(message.target, additionalTargets);
             process.stdout.write(
-              `[r5d-worker] exec_start ${message.runId}${message.commandClass === "control" ? " (control)" : ""}: ${message.argv.join(" ")}
+              `[r5d-worker] exec_start ${message.runId}${message.commandClass === "control" ? " (control)" : ""}: ${message.argv.join(" ")}${describeCommandAdditionalTargets(additionalTargets)}
 `
             );
             await executeStreamingCommand({
@@ -7050,6 +7201,7 @@ async function startWorker(options, projectRuntime = {
               ws,
               message,
               resolvedTarget,
+              additionalTargets,
               baseUrl,
               token,
               rootDir,
@@ -7060,10 +7212,14 @@ async function startWorker(options, projectRuntime = {
                   active
                 });
               },
-              assertAdmission: assertMessageAdmission
+              assertAdmission: () => {
+                assertMessageAdmission();
+                resolveCommandMessageTarget(message.target, additionalTargets);
+              }
             });
           } finally {
             if (hasWorkspaceEffect && targetMayMutateVisibleWorkspace(message.target)) {
+              recordAdditionalTargetMutations(additionalTargets);
               markWorkspaceDirty(
                 {
                   type: "process_terminal",
@@ -7085,12 +7241,13 @@ async function startWorker(options, projectRuntime = {
               const reservationAbort = registerPendingReservation(`run:${message.runId}`, message.sessionId);
               try {
                 await reserveWorkspaceCommandAfterCurrentSync(
-                  message.target,
+                  commandTargets(message.target, additionalTargets),
                   workspaceSyncSingleFlight,
                   () => {
-                    workspaceSyncPriorityProcessTargets.set(message.runId, message.target);
+                    workspaceSyncPriorityProcessTargets.set(message.runId, commandTargets(message.target, additionalTargets));
                     targetReserved = true;
                     if (targetMayMutateVisibleWorkspace(message.target)) recordVisibleWorkspaceMutation(message.target);
+                    recordAdditionalTargetMutations(additionalTargets);
                   },
                   { signal: reservationAbort.signal }
                 );

package/dist/mjs/package.json

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