pi-subagents 0.81.0 → 0.82.1

package/bundle/{chunk-XMFLCKMQ.js → chunk-QE4AGIMG.js}

@@ -3,7 +3,7 @@ import {
   projectRuntimeAcknowledgedExtensions,
   registerSubagentPromptBoundary,
   registerSubagentPromptRuntime
-} from "./chunk-L5ZHE4L4.js";
+} from "./chunk-3JCDWF4V.js";
 import {
   INSPECTOR_ACTIONS,
   canQueueRetainedAsyncFollowUp,
@@ -25,15 +25,19 @@ import {
   updateSteeringTarget,
   waitForSteeringAction,
   workflowAsyncChildSteeringGuidance
-} from "./chunk-CEKS3TFO.js";
-import "./chunk-74RT5YQE.js";
+} from "./chunk-PBK2I7WY.js";
+import {
+  REX_LOCAL_MACHINE,
+  isRexLocalMachine,
+  resolveRexLocalPlacement
+} from "./chunk-RMQFMMAT.js";
 import {
   COMPLETION_ACTION,
   DEFAULT_CONTROL_CONFIG,
   HERDR_FOREGROUND_CONTROL_CHANGED_EVENT,
   JITI_ALIAS_ENV,
-  MAX_REMEMBERED_FOREGROUND_RUNS,
   STATUS_ACTION,
+  WORKFLOW_RUNTIME_REPLACED_STOP_NOTICE,
   appendWorkflowChildJournal,
   attachNestedChildrenToResultChildren,
   buildControlEvent,
@@ -45,6 +49,8 @@ import {
   childSessionFactoryModule,
   childSessionHasQueuedMessages,
   claimControlNotification,
+  claimWorkflowResume,
+  claimedWorkflowRunRefusal,
   clearProviderRetry,
   controlChildCommand,
   createChildExternalJobBridgeSweeper,
@@ -72,11 +78,12 @@ import {
   isScheduledRunAction,
   isWorkflowScriptPath,
   listRetainedChildren,
+  manualWorkflowResumeRefusalText,
   matchWorkflowReuse,
   normalizePublicSubagentExecution,
   observeProviderDiagnostics,
   parseWatchdogThinkingInput,
-  persistForegroundRunHistory,
+  prepareWorkflowResume,
   projectChildSessionEventForJson,
   projectWorkflowKeyRevival,
   readNamedWorkflowReuseSource,
@@ -84,13 +91,16 @@ import {
   readWorkflowReceipt,
   recommendStrongWatchdogModel,
   recommendWatchdogModel,
+  recordWorkflowResumeRefusal,
   recordWorkflowRevival,
+  releaseWorkflowResumeClaim,
   resolveControlConfig,
   resolveHostPeerAliases,
   resolveSubagentResultStatus,
   resolveToolTimeoutMs,
   resolveWatchdogModelInput,
   resolveWorkflowReceiptResumeEntry,
+  resumedRunStarted,
   retainLiveForegroundNestedRoute,
   retainsChildCommand,
   shouldEmitOpenToolAttention,
@@ -103,11 +113,13 @@ import {
   withWorkflowRevivals,
   workflowChildFingerprint,
   workflowReceiptPath,
-  workflowRuntimeReplacedRelaunchNotice,
+  workflowResumeRefusal,
+  workflowResumeTargetId,
   workflowScriptDigest,
   workflowStopCause,
+  writeWorkflowLaunchRecord,
   writeWorkflowReceipt
-} from "./chunk-26C3WLYQ.js";
+} from "./chunk-ZIV4J4HG.js";
 import {
   NATIVE_SUPERVISOR_TOOL_NAME,
   SUBAGENT_PARENT_SESSION_ENV,
@@ -117,22 +129,26 @@ import {
   finalizeToolResult,
   registerPinnedTool,
   resolveCurrentSessionId,
+  resolvePiSessionId,
   resolveSupervisorChannelDir,
   resolveWaitToolConfig,
   resolveWatchdogConfig,
   sendRuleViolationWarning,
   writeWatchdogModelSettings
-} from "./chunk-BPS2AGBZ.js";
+} from "./chunk-VSUSLDNW.js";
 import {
-  currentCompletionOwnerId,
+  MAX_REMEMBERED_FOREGROUND_RUNS,
+  discardRunningForegroundRun,
+  foregroundChildStateLabel,
   formatAsyncResultTranscript,
   formatAsyncRunTranscript,
   formatNestedRunTranscript,
   inspectSubagentFleet,
+  persistForegroundRun,
   resolveSubagentRunId,
   resolveWorkflowChatProgress,
   stopAsyncRun
-} from "./chunk-KSWQVGDW.js";
+} from "./chunk-FXUXCX2K.js";
 import {
   MODEL_ONLY_TOOL,
   RunFanoutLimitError,
@@ -194,7 +210,7 @@ import {
   writeParallelHandoffGroup,
   writeRunFanoutBudgetDescriptor,
   writeWorktreeSetupHandoff
-} from "./chunk-NNLASTQE.js";
+} from "./chunk-6XJB7PIX.js";
 import {
   authorizeWorkflowResourceHost,
   claimWorkflowChildPermit,
@@ -211,10 +227,10 @@ import {
   canPreferFork,
   createForkContextResolver,
   resolveSubagentLaunchContext
-} from "./chunk-ARRKBB2B.js";
+} from "./chunk-GJECHSAR.js";
 import {
   handleRefinementAction
-} from "./chunk-EYNJ6VL6.js";
+} from "./chunk-PLCCBLPY.js";
 import {
   ActiveAsyncCapacityError,
   acquireActiveAsyncCapacity,
@@ -228,7 +244,7 @@ import {
   resolveDisabledFeatureSurface,
   resolveMaxActiveAsyncRunsPerSession,
   transferActiveAsyncCapacity
-} from "./chunk-WSBNENFS.js";
+} from "./chunk-UCPP4GNU.js";
 import {
   DEFAULT_STALE_TERMINAL_ACTIVE_MARKER_MS,
   MACHINE_DIFF_OPTIONS,
@@ -239,12 +255,15 @@ import {
   activeRunMarkerAgeMs,
   attachMissionToLaunchResult,
   attachRootChildrenToSteps,
-  checkPidLiveness,
+  checkRecordedPidLiveness,
   cleanupWorktrees,
   createMissionWorkflowState,
   createNestedRoute,
   createWorktrees,
+  currentBootId,
+  currentCompletionOwnerId,
   currentPidNamespaceScope,
+  currentRecordedPid,
   diffWorktrees,
   encodeIndexSegment,
   executeWorkflowHostCommand,
@@ -304,7 +323,7 @@ import {
   writeNestedControlRequest,
   writeNestedControlResult,
   writeNestedEvent
-} from "./chunk-VJHOELQP.js";
+} from "./chunk-46XKCPJR.js";
 import {
   closeSteerInbox,
   consumeSteerRequests,
@@ -312,7 +331,7 @@ import {
   readRevivalBriefs,
   requestAsyncSteer,
   watchAsyncControlInbox
-} from "./chunk-BJN5LUQY.js";
+} from "./chunk-OYF6AFDY.js";
 import "./chunk-NIXWDZZV.js";
 import {
   INTERCOM_BRIDGE_MARKER,
@@ -321,7 +340,7 @@ import {
   resolveIntercomBridge,
   resolveIntercomSessionTarget,
   resolveSubagentIntercomTarget
-} from "./chunk-ZP3HODFH.js";
+} from "./chunk-XSWOTIA3.js";
 import {
   resolveLaunchBinding,
   stableJsonDigest
@@ -335,7 +354,7 @@ import {
   resolvePiLaunchToolPlan,
   resolveRuntimeModulePath,
   supervisorChannelDir
-} from "./chunk-G5DKFLLI.js";
+} from "./chunk-4SDU2BZX.js";
 import {
   assertRequiredChildExtensionsAdmitted,
   hasMandatoryRequiredChildExtensions,
@@ -346,7 +365,7 @@ import {
 import {
   HERDR_PROJECT_PANE_ACTIONS,
   handleHerdrProjectPaneAction
-} from "./chunk-V2JWDB5U.js";
+} from "./chunk-52UBALJL.js";
 import "./chunk-7J4ZXMY7.js";
 import {
   PROJECT_SUBAGENTS_RELATIVE_DIR,
@@ -359,12 +378,12 @@ import {
   getProjectSubagentsDir,
   writeArtifact,
   writeMetadata
-} from "./chunk-3DC5KBVP.js";
+} from "./chunk-5TYMSZX3.js";
 import "./chunk-N2BN7BF5.js";
 import {
   getExternalJobProvider
 } from "./chunk-YYREO77V.js";
-import "./chunk-3IF2PGW7.js";
+import "./chunk-YKEWIB4M.js";
 import {
   CODE_OWNED_EXTERNAL_CLI_ADAPTER_IDS,
   ChainOutputValidationError,
@@ -512,7 +531,7 @@ import {
   writeAtomicJson,
   writeInitialProgressFile,
   writePrivateAtomicJson
-} from "./chunk-ZBC44JJ3.js";
+} from "./chunk-CIZQXJ5Q.js";
 import {
   CHAIN_RUNS_DIR,
   DEFAULT_ARTIFACT_CONFIG,
@@ -884,6 +903,11 @@ function machineSettingsFrom(settings, keys, filePath) {
       throw new Error(`Subagent settings in '${filePath}' set 'machines.${key}.env'. Saved-machine runs use the remote Herdr/Pi environment; configure credentials and environment on '${key}' and remove the local env map.`);
     }
   }
+  if (record2.rex !== void 0) {
+    const rex = record2.rex, ssh = rex && typeof rex === "object" && !Array.isArray(rex) && Object.keys(rex).every((field) => field === "ssh") ? rex.ssh : void 0;
+    if (typeof ssh !== "string") throw new Error(`Subagent settings in '${filePath}' have invalid 'machines.${key}.rex'; expected { "ssh": "<ssh target>" }.`);
+    entry.rex = { ssh: validateTarget(ssh, key) };
+  }
   return entry;
 }
 function readMachineSettings(cwd, keys) {
@@ -891,9 +915,14 @@ function readMachineSettings(cwd, keys) {
   const projectPath = path.join(getProjectConfigDir(findProjectRootForSettings(cwd)), "settings.json");
   const user = machineSettingsFrom(readJsonObject(userPath), keys, userPath);
   const project = projectPath === userPath ? void 0 : machineSettingsFrom(readJsonObject(projectPath), keys, projectPath);
+  if (project?.rex) throw new Error(`Project settings '${projectPath}' set a Rex SSH host in 'machines'. Move the rex entry to your user settings '${userPath}'; only user settings choose which host a task runs on.`);
   if (!user && !project) return void 0;
   return { ...user, ...project };
 }
+function userRexMachine(machine) {
+  const userPath = path.join(getAgentDir(), "settings.json");
+  return machineSettingsFrom(readJsonObject(userPath), [machine], userPath)?.rex !== void 0;
+}
 function findProjectRootForSettings(cwd) {
   let current = path.resolve(cwd);
   while (true) {
@@ -903,6 +932,12 @@ function findProjectRootForSettings(cwd) {
     current = parent;
   }
 }
+function remoteMachineCwd(stepCwd, root, name) {
+  const step = stepCwd?.trim();
+  if (step && isRemoteAbsolute(step)) return step;
+  if (!root) throw new Error(`No root for ${name} in this repo. Set subagents.machines.${name}.cwd in .pi/settings.json or pass an absolute cwd on that machine.`);
+  return step ? path.posix.join(root, step) : root;
+}
 function resolveHerdrMachinePlacement(input) {
   const requested = validateMachineName(input.machine);
   const catalog = input.catalogJson !== void 0 ? parseMachineCatalog(input.catalogJson) : readHerdrMachineCatalog(input.env ?? process.env, input.herdrBin ?? process.env.HERDR_BIN ?? "herdr");
@@ -913,11 +948,7 @@ function resolveHerdrMachinePlacement(input) {
   if (settings?.env && Object.keys(settings.env).length > 0) {
     throw new Error(`Saved-machine environment for '${name}' must be configured remotely. Remove machines.${name}.env and configure the remote Herdr/Pi session instead.`);
   }
-  const stepCwd = input.stepCwd?.trim();
-  let cwd;
-  if (stepCwd && isRemoteAbsolute(stepCwd)) cwd = stepCwd;
-  else if (settings?.cwd) cwd = stepCwd ? path.posix.join(settings.cwd, stepCwd) : settings.cwd;
-  else throw new Error(`No root for ${name} in this repo. Set subagents.machines.${name}.cwd in .pi/settings.json or pass an absolute cwd on that machine.`);
+  const cwd = remoteMachineCwd(input.stepCwd, settings?.cwd, name);
   return {
     machine: {
       provider: "herdr",
@@ -930,8 +961,31 @@ function resolveHerdrMachinePlacement(input) {
     ...settings?.env ? { env: settings.env } : {}
   };
 }
+function resolveMachinePlacement(input) {
+  const requested = validateMachineName(input.machine);
+  const settings = input.settings ?? readMachineSettings(input.cwd, [requested]);
+  if (requested === REX_LOCAL_MACHINE) {
+    if (settings?.rex) throw new Error("Machine 'local' is reserved for a Rex pane on this machine; give the Rex SSH host in subagents.machines.local.rex another name.");
+    return { machine: resolveRexLocalPlacement({ cwd: input.cwd, stepCwd: input.stepCwd, env: input.env }) };
+  }
+  if (settings?.rex) return { machine: { provider: "rex", id: requested, target: settings.rex.ssh, cwd: validateRemoteCwd(remoteMachineCwd(input.stepCwd, settings.cwd, requested), requested) } };
+  return resolveHerdrMachinePlacement(input);
+}
 function formatHerdrMachineRunnerUnsupported(input) {
   if (input.machine === void 0) return void 0;
+  const name = input.machine.trim();
+  let rex;
+  try {
+    rex = name === REX_LOCAL_MACHINE || userRexMachine(name);
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+  if (rex) {
+    if (input.runnerType !== void 0 && input.runnerType !== "pi") return `Agent '${input.agentName}' requested machine '${name}', but Rex supports native Pi children only. Remove the machine or use a native Pi agent.`;
+    if (input.worktree === true) return `Agent '${input.agentName}' requested machine '${name}', but managed worktrees cannot be combined with machine placement.`;
+    if (process.platform === "win32") return `Machine '${name}' runs the child in a Rex pane, which is not supported on Windows.`;
+    return void 0;
+  }
   if (input.runnerType !== void 0 && input.runnerType !== "pi" && input.runnerType !== "external-cli") {
     return `Agent '${input.agentName}' requested machine '${input.machine}', but this runner cannot use pane-native Herdr placement. Use native Pi or a built-in Claude, Codex, or Cursor profile.`;
   }
@@ -2044,7 +2098,9 @@ function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, launchP
   const runnerProcessInstanceId = randomUUID2();
   const hasRevivalLease = typeof cfg.revivalLease === "object";
   const launchBarrierToken = hasRevivalLease ? void 0 : runnerProcessInstanceId;
-  const launchConfig = { ...cfg, runnerProcessInstanceId, ...launchBarrierToken ? { launchBarrierToken } : {} };
+  const launcher = cfg.launcher;
+  const bootId = launcher ? void 0 : currentBootId();
+  const launchConfig = { ...cfg, runnerProcessInstanceId, ...launchBarrierToken ? { launchBarrierToken } : {}, ...bootId ? { bootId } : {} };
   writePrivateAtomicJson(cfgPath, launchConfig);
   const command = binaryHost ?? nodeExecutable;
   const launchForStartup = launchConfig;
@@ -2060,7 +2116,6 @@ function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, launchP
   if (startupAckPath) fs7.rmSync(startupAckPath, { force: true });
   if (startupConfirmPath) fs7.rmSync(startupConfirmPath, { force: true });
   if (startupProceedPath) fs7.rmSync(startupProceedPath, { force: true });
-  const launcher = launchConfig.launcher;
   const identityPath = launcher && launchBarrierToken && launchAsyncDir ? path6.join(launchAsyncDir, "runner-startup.json") : void 0;
   if (identityPath) fs7.rmSync(identityPath, { force: true });
   let runnerIdentity;
@@ -2132,7 +2187,7 @@ function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, launchP
             writePrivateAtomicJson(path6.join(asyncDir, "launcher-close.json"), { version: 1, runId, runnerProcessInstanceId, closeObservedAt: Date.now(), exitCode, signal, ...runnerIdentity ? { runnerPid: runnerIdentity.pid } : {} });
           } catch {
           }
-          if (!runnerIdentity || runnerIdentity.pidNamespaceScope !== currentPidNamespaceScope() || checkPidLiveness(runnerIdentity.pid, process.kill, runnerIdentity.pidNamespaceScope !== void 0) !== "dead") return;
+          if (!runnerIdentity || runnerIdentity.pidNamespaceScope !== currentPidNamespaceScope() || checkRecordedPidLiveness(runnerIdentity) !== "dead") return;
         }
         finalizeProcessTerminal(asyncDir, runId, {
           processInstanceId: runnerProcessInstanceId,
@@ -2188,7 +2243,7 @@ function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, launchP
     try {
       writePrivateAtomicJson(initialStatusPath, {
         ...initialStatus,
-        ...launcher ? {} : { pid: proc.pid, pidNamespaceScope: currentPidNamespaceScope() },
+        ...launcher ? {} : { pid: proc.pid, pidNamespaceScope: currentPidNamespaceScope(), ...bootId ? { bootId } : {} },
         processTerminal: { version: 1, state: "pending", runId: initialStatus.runId, runnerProcessInstanceId }
       });
       updateActiveRunIndex(path6.dirname(initialStatusPath), initialStatus.state, initialStatus.toolCallId);
@@ -2375,7 +2430,7 @@ function buildAsyncRunnerSteps(id, params) {
     let machineEnv;
     if (requestedMachine) {
       try {
-        const placement = resolveHerdrMachinePlacement({ machine: requestedMachine, cwd: runnerCwd, stepCwd: s.cwd ?? params.machineCwd });
+        const placement = resolveMachinePlacement({ machine: requestedMachine, cwd: runnerCwd, stepCwd: s.cwd ?? params.machineCwd });
         machine = placement.machine;
         machineEnv = placement.env;
       } catch (error) {
@@ -2867,6 +2922,7 @@ function executeAsyncChain(id, params) {
   }
   const initialStatusAt = Date.now();
   const initialCompletionOwnerId = ctx.completionOwnerId ?? currentCompletionOwnerId();
+  const completionOwnerProcess = currentRecordedPid();
   const launchParentSessionId = ctx.parentSessionId ?? ctx.currentSessionId;
   try {
     writeRetainedRequiredChildExtensions(asyncDir, params.requiredExtensions ?? ctx.childRuntime?.requiredExtensions ?? resolveRequiredChildExtensions(launchParentSessionId ?? void 0));
@@ -2891,6 +2947,7 @@ function executeAsyncChain(id, params) {
         asyncDir,
         sessionId: ctx.currentSessionId,
         completionOwnerId: ctx.completionOwnerId ?? currentCompletionOwnerId(),
+        completionOwnerProcess,
         ...capabilityCeiling ? { capabilityCeiling } : {},
         piPackageRoot,
         childSessionFactoryModule: childSessionFactoryModule(),
@@ -2932,6 +2989,7 @@ function executeAsyncChain(id, params) {
         runId: id,
         ...ctx.currentSessionId ? { sessionId: ctx.currentSessionId } : {},
         ...initialCompletionOwnerId ? { completionOwnerId: initialCompletionOwnerId } : {},
+        completionOwnerProcess,
         mode: resultMode,
         state: "running",
         startedAt: initialStatusAt,
@@ -3148,7 +3206,7 @@ function executeAsyncSingle(id, params) {
   let machineEnv;
   if (requestedMachine) {
     try {
-      const placement = resolveHerdrMachinePlacement({ machine: requestedMachine, cwd: runnerCwd, stepCwd: params.machineCwd });
+      const placement = resolveMachinePlacement({ machine: requestedMachine, cwd: runnerCwd, stepCwd: params.machineCwd });
       machine = placement.machine;
       machineEnv = placement.env;
     } catch (error) {
@@ -3404,6 +3462,7 @@ function executeAsyncSingle(id, params) {
   let spawnResultOrPromise = {};
   const initialStatusAt = Date.now();
   const initialCompletionOwnerId = ctx.completionOwnerId ?? currentCompletionOwnerId();
+  const completionOwnerProcess = currentRecordedPid();
   const launchParentSessionId = ctx.parentSessionId ?? ctx.currentSessionId;
   try {
     spawnResultOrPromise = spawnRunner(
@@ -3485,6 +3544,7 @@ function executeAsyncSingle(id, params) {
         asyncDir,
         sessionId: ctx.currentSessionId,
         completionOwnerId: ctx.completionOwnerId ?? currentCompletionOwnerId(),
+        completionOwnerProcess,
         ...capabilityCeiling ? { capabilityCeiling } : {},
         piPackageRoot,
         childSessionFactoryModule: childSessionFactoryModule(),
@@ -3529,6 +3589,7 @@ function executeAsyncSingle(id, params) {
         runId: id,
         ...ctx.currentSessionId ? { sessionId: ctx.currentSessionId } : {},
         ...initialCompletionOwnerId ? { completionOwnerId: initialCompletionOwnerId } : {},
+        completionOwnerProcess,
         mode: "single",
         ...params.toolCallId ? { toolCallId: params.toolCallId } : {},
         state: "running",
@@ -3926,7 +3987,8 @@ var WORKFLOW_FENCE = /^```(?:js|javascript) workflow[ \t]*$/;
 var PLAIN_JS_FENCE = /^```(?:js|javascript)[ \t]*$/;
 var OPEN_FENCE = /^(`{3,}|~{3,})/;
 var CLOSE_FENCE = /^(`{3,}|~{3,})[ \t]*$/;
-var FILE_FALLBACK = 'Or write the script to a file and pass its path, such as workflow: "./script.js".';
+var SUMMARY_NOTE = 'On some models, text written after a tool call in the same turn reaches the session only as a summary without code blocks, so for the rest of this turn write the script to a file and pass its path, such as workflow: "./script.js".';
+var FILE_FALLBACK = `If the block is in your reply: ${SUMMARY_NOTE}`;
 function readReplyWorkflowScript(sessionManager, toolCallId) {
   const branch = sessionManager.getBranch();
   for (let index = branch.length - 1; index >= 0; index--) {
@@ -3942,7 +4004,7 @@ function readReplyWorkflowScript(sessionManager, toolCallId) {
 function scriptFromReply(content) {
   const replyCalls = content.filter((block) => block.type === "toolCall" && block.name === "subagent" && (block.arguments?.workflow === true || block.arguments?.workflow === "true")).length;
   if (replyCalls > 1) return { error: `This reply has ${replyCalls} subagent calls with workflow: true; a reply can carry only one. Pass other scripts as workflow file paths.` };
-  if (!content.some((block) => block.type === "text")) return { error: 'The assistant message that issued this call has no text in the session, so the reply\'s visible text, including any ```js workflow block, never reached it. Write the script to a file and pass its path, such as workflow: "./script.js".' };
+  if (!content.some((block) => block.type === "text")) return { error: `The assistant message that issued this call has no text in the session, so the reply's visible text, including any \`\`\`js workflow block, never reached it. ${SUMMARY_NOTE}` };
   const text = content.flatMap((block) => block.type === "text" && typeof block.text === "string" ? [block.text] : []).join("\n");
   const { tagged, plain, unclosed } = workflowBlocks(text);
   if (unclosed) return { error: "The script's fenced block in this reply is not closed." };
@@ -4535,25 +4597,6 @@ ${createDone}
     }
   });
 }
-function resolvePiSessionId(sessionFile) {
-  if (!sessionFile) return void 0;
-  try {
-    const fd = fs12.openSync(sessionFile, "r");
-    try {
-      const buffer = Buffer.alloc(16 * 1024);
-      const bytes = fs12.readSync(fd, buffer, 0, buffer.length, 0);
-      const line = buffer.toString("utf-8", 0, bytes).split("\n", 1)[0];
-      if (!line) return void 0;
-      const header = JSON.parse(line);
-      if (header.type === "session" && typeof header.id === "string" && /^[A-Za-z0-9-]{8,}$/.test(header.id)) return header.id;
-      return void 0;
-    } finally {
-      fs12.closeSync(fd);
-    }
-  } catch {
-    return void 0;
-  }
-}
 function scheduleCleanup(nodeExecutable, paths) {
   try {
     const watchdog = spawn2(nodeExecutable, ["-e", ORCA_CLEANUP_WATCHDOG_SCRIPT, String(CLEANUP_DELAY_MS), ...paths], {
@@ -5576,7 +5619,8 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
     };
     return result2;
   }
-  const mutationSnapshot = options.machine ? { source: "tracked-files", trackedOnly: true, cwd: options.cwd ?? runtimeCwd, dirtyFiles: [], fingerprints: {}, unavailable: "Local Git evidence is not authoritative for a pane-native remote run." } : snapshotTrackedMutations(options.cwd ?? runtimeCwd);
+  const mutationCwd = isRexLocalMachine(options.machine) ? options.machine.cwd : options.cwd ?? runtimeCwd;
+  const mutationSnapshot = options.machine && !isRexLocalMachine(options.machine) ? { source: "tracked-files", trackedOnly: true, cwd: mutationCwd, dirtyFiles: [], fingerprints: {}, unavailable: "Local Git evidence is not authoritative for a pane-native remote run." } : snapshotTrackedMutations(mutationCwd);
   let structuredOutputToolInvoked = false;
   let structuredOutputMessageStartIndex;
   let toolAvailabilityError;
@@ -6293,7 +6337,7 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
       const toolDiagnosticError = diagnostic ? formatChildToolDiagnostic(diagnostic, { host: "parent" }) : void 0;
       toolAvailabilityError = toolDiagnosticError;
       result2.runtimeAcknowledgedExtensions = capture.runtimeAcknowledgedExtensions();
-      if (session?.machineEvidence) result2.nativeMachine = { provider: "herdr", machineId: session.machineEvidence.machineId, ...session.machineEvidence.initial ? { initialGit: session.machineEvidence.initial } : {}, ...session.machineEvidence.final ? { finalGit: session.machineEvidence.final } : {} };
+      if (session?.machineEvidence) result2.nativeMachine = { provider: session.machineEvidence.provider, machineId: session.machineEvidence.machineId, ...session.machineEvidence.initial ? { initialGit: session.machineEvidence.initial } : {}, ...session.machineEvidence.final ? { finalGit: session.machineEvidence.final } : {} };
       let closeError = result2.error ?? toolDiagnosticError ?? assistantError;
       const promptErrorMessage = promptError === void 0 ? void 0 : promptError instanceof Error ? promptError.message : String(promptError);
       if (promptError !== void 0) childPromptFailed = true;
@@ -6500,7 +6544,7 @@ ${formatInheritedProviderDiagnostic({ agent: agent.name, model: launch.session.m
     durationMs: progress.durationMs
   };
   const remoteGitChanged = result2.nativeMachine?.initialGit && result2.nativeMachine.finalGit ? result2.nativeMachine.initialGit.head !== result2.nativeMachine.finalGit.head || result2.nativeMachine.initialGit.dirty !== result2.nativeMachine.finalGit.dirty : void 0;
-  const mutationEvidence = result2.nativeMachine ? { source: "tracked-files", trackedOnly: true, changedFiles: [], attemptedMutation: remoteGitChanged === true, ...remoteGitChanged === void 0 ? { unavailable: "Remote Git before/after evidence was incomplete." } : {} } : collectTrackedMutationEvidence(mutationSnapshot, options.cwd ?? runtimeCwd);
+  const mutationEvidence = result2.nativeMachine && !isRexLocalMachine(options.machine) ? { source: "tracked-files", trackedOnly: true, changedFiles: [], attemptedMutation: remoteGitChanged === true, ...remoteGitChanged === void 0 ? { unavailable: "Remote Git before/after evidence was incomplete." } : {} } : collectTrackedMutationEvidence(mutationSnapshot, mutationCwd);
   const acceptanceOutput = getFinalOutput(result2.messages ?? []);
   const structuredText = result2.structuredOutput === void 0 ? void 0 : JSON.stringify(result2.structuredOutput, null, 2);
   let fullOutput = stripAcceptanceReport(acceptanceOutput);
@@ -8350,10 +8394,7 @@ function errorMessage2(error) {
 function runnerExitedWithoutResult(asyncDir, runId, resultPath) {
   const status = readStatus(asyncDir);
   if (!status || status.state !== "running" && status.state !== "queued" || typeof status.pid !== "number") return false;
-  const observedScope = currentPidNamespaceScope();
-  if (status.pidNamespaceScope !== void 0 && status.pidNamespaceScope !== observedScope) return false;
-  const pidScopeVerified = status.pidNamespaceScope !== void 0 && status.pidNamespaceScope === observedScope;
-  if (checkPidLiveness(status.pid, void 0, pidScopeVerified) !== "dead") return false;
+  if (checkRecordedPidLiveness({ pid: status.pid, pidNamespaceScope: status.pidNamespaceScope, bootId: status.bootId }) !== "dead") return false;
   return !fs17.existsSync(resultPath) && !(status.sessionId && resultPayloadPathForSessionRun(asyncDir, status.sessionId, runId));
 }
 async function awaitExistingAsyncRun(asyncDir, runId, signal) {
@@ -8543,7 +8584,7 @@ function formatRememberedForegroundStatus(run) {
   for (const child of run.children) {
     const output = rememberedForegroundChildOutput(child).trim().split(/\r?\n/).find((line) => line.trim());
     const parts = [
-      `${child.index + 1}. ${child.sessionName?.trim() || child.agent} ${child.status}`,
+      `${child.index + 1}. ${child.sessionName?.trim() || child.agent} ${foregroundChildStateLabel(run, child)}`,
       child.exitCode !== void 0 ? `exit ${child.exitCode}` : void 0,
       child.detachedReason ? `detached: ${child.detachedReason}` : void 0,
       child.acceptance ? `acceptance: ${child.acceptance.status}` : void 0,
@@ -10159,9 +10200,11 @@ function trimRememberedForegroundRuns(state) {
     state.foregroundRuns.delete(oldestTerminal.runId);
   }
 }
-function persistRememberedForegroundRuns(state) {
+function persistRememberedForegroundRun(state, runId) {
+  const run = state.foregroundRuns?.get(runId);
+  if (!run) return;
   try {
-    persistForegroundRunHistory(state);
+    persistForegroundRun(run);
   } catch (error) {
     console.error("Failed to persist foreground run history:", error);
   }
@@ -10180,6 +10223,49 @@ function foregroundChildActivityFromProgress(progress) {
     ...progress?.toolCount !== void 0 ? { toolCount: progress.toolCount } : {}
   };
 }
+function rememberedForegroundChild(input, result2, index, status, updatedAt) {
+  const resumeContract = omitUndefinedProperties({
+    modelResponseAliases: input.modelResponseAliases,
+    outputSchema: input.params.outputSchema,
+    agentContract: input.params.agentContract,
+    acceptance: input.params.acceptance,
+    output: input.effectiveOutput,
+    outputMode: input.effectiveOutputMode
+  });
+  return {
+    agent: result2.agent,
+    index,
+    ...result2.sessionName ? { sessionName: result2.sessionName } : {},
+    ...result2.context ? { context: result2.context } : {},
+    status,
+    ...foregroundChildActivityFromProgress(result2.progress),
+    updatedAt,
+    ...result2.exitCode !== void 0 ? { exitCode: result2.exitCode } : {},
+    ...result2.error ? { error: result2.error } : {},
+    ...result2.finalOutput ? { finalOutput: result2.finalOutput } : {},
+    ...result2.outputState ? { outputState: result2.outputState } : {},
+    ...result2.outputPartial ? { outputPartial: true } : {},
+    ...result2.outputMode ? { outputMode: result2.outputMode } : {},
+    ...result2.savedOutputPath ? { savedOutputPath: result2.savedOutputPath } : {},
+    ...result2.outputSaveError ? { outputSaveError: result2.outputSaveError } : {},
+    ...result2.sessionFile ? { sessionFile: result2.sessionFile } : {},
+    ...result2.model ? { model: result2.model } : {},
+    ...result2.thinking ? { thinking: result2.thinking } : {},
+    ...result2.artifactPaths ? { artifactPaths: result2.artifactPaths } : {},
+    ...result2.transcriptPath ? { transcriptPath: result2.transcriptPath } : {},
+    ...result2.transcriptError ? { transcriptError: result2.transcriptError } : {},
+    ...result2.detachedReason ? { detachedReason: result2.detachedReason } : {},
+    ...result2.acceptance ? { acceptance: result2.acceptance } : {},
+    ...Object.keys(resumeContract).length ? { resumeContract } : {},
+    ...result2.launchContractDigest ? { launchContractDigest: result2.launchContractDigest } : {},
+    ...input.extensionBindings ? { extensionBindings: input.extensionBindings } : {},
+    ...input.requiredExtensions?.length ? { requiredExtensions: input.requiredExtensions } : {},
+    ...result2.launchResolvedExtensions ? { launchResolvedExtensions: result2.launchResolvedExtensions } : {},
+    ...result2.runtimeAcknowledgedExtensions ? { runtimeAcknowledgedExtensions: result2.runtimeAcknowledgedExtensions } : {},
+    ...result2.capabilityCeiling ? { capabilityCeiling: result2.capabilityCeiling } : {},
+    ...result2.capabilityAudit ? { capabilityAudit: result2.capabilityAudit } : {}
+  };
+}
 function rememberForegroundRun(state, input) {
   state.foregroundRuns ??= /* @__PURE__ */ new Map();
   const previous = state.foregroundRuns.get(input.runId);
@@ -10191,61 +10277,38 @@ function rememberForegroundRun(state, input) {
     ...input.sessionId ? { sessionId: input.sessionId } : {},
     updatedAt,
     children: input.results.map((result2, index) => {
-      const resumeContract = omitUndefinedProperties({
-        modelResponseAliases: input.modelResponseAliases,
-        outputSchema: input.params.outputSchema,
-        agentContract: input.params.agentContract,
-        acceptance: input.params.acceptance,
-        output: input.effectiveOutput,
-        outputMode: input.effectiveOutputMode
-      });
-      const child = {
-        agent: result2.agent,
-        index,
-        ...result2.sessionName ? { sessionName: result2.sessionName } : {},
-        ...result2.context ? { context: result2.context } : {},
-        status: resolveSubagentResultStatus(omitUndefinedProperties({
-          exitCode: result2.exitCode,
-          interrupted: result2.interrupted,
-          detached: result2.detached,
-          processSignal: result2.processSignal,
-          timedOut: result2.timedOut,
-          stopped: result2.stopped,
-          turnBudgetExceeded: result2.turnBudgetExceeded
-        })),
-        ...foregroundChildActivityFromProgress(result2.progress),
-        updatedAt,
-        ...result2.exitCode !== void 0 ? { exitCode: result2.exitCode } : {},
-        ...result2.error ? { error: result2.error } : {},
-        ...result2.finalOutput ? { finalOutput: result2.finalOutput } : {},
-        ...result2.outputState ? { outputState: result2.outputState } : {},
-        ...result2.outputPartial ? { outputPartial: true } : {},
-        ...result2.outputMode ? { outputMode: result2.outputMode } : {},
-        ...result2.savedOutputPath ? { savedOutputPath: result2.savedOutputPath } : {},
-        ...result2.outputSaveError ? { outputSaveError: result2.outputSaveError } : {},
-        ...result2.sessionFile ? { sessionFile: result2.sessionFile } : {},
-        ...result2.model ? { model: result2.model } : {},
-        ...result2.thinking ? { thinking: result2.thinking } : {},
-        ...result2.artifactPaths ? { artifactPaths: result2.artifactPaths } : {},
-        ...result2.transcriptPath ? { transcriptPath: result2.transcriptPath } : {},
-        ...result2.transcriptError ? { transcriptError: result2.transcriptError } : {},
-        ...result2.detachedReason ? { detachedReason: result2.detachedReason } : {},
-        ...result2.acceptance ? { acceptance: result2.acceptance } : {},
-        ...Object.keys(resumeContract).length ? { resumeContract } : {},
-        ...result2.launchContractDigest ? { launchContractDigest: result2.launchContractDigest } : {},
-        ...input.extensionBindings ? { extensionBindings: input.extensionBindings } : {},
-        ...input.requiredExtensions?.length ? { requiredExtensions: input.requiredExtensions } : {},
-        ...result2.launchResolvedExtensions ? { launchResolvedExtensions: result2.launchResolvedExtensions } : {},
-        ...result2.runtimeAcknowledgedExtensions ? { runtimeAcknowledgedExtensions: result2.runtimeAcknowledgedExtensions } : {},
-        ...result2.capabilityCeiling ? { capabilityCeiling: result2.capabilityCeiling } : {},
-        ...result2.capabilityAudit ? { capabilityAudit: result2.capabilityAudit } : {}
-      };
+      const child = rememberedForegroundChild(input, result2, index, resolveSubagentResultStatus(omitUndefinedProperties({
+        exitCode: result2.exitCode,
+        interrupted: result2.interrupted,
+        detached: result2.detached,
+        processSignal: result2.processSignal,
+        timedOut: result2.timedOut,
+        stopped: result2.stopped,
+        turnBudgetExceeded: result2.turnBudgetExceeded
+      })), updatedAt);
       const recovered = previous?.children[index];
       return child.status === "detached" && recovered && recovered.status !== "detached" ? recovered : child;
     })
   });
   trimRememberedForegroundRuns(state);
-  persistRememberedForegroundRuns(state);
+  persistRememberedForegroundRun(state, input.runId);
+}
+function rememberRunningForegroundRun(input) {
+  const updatedAt = Date.now();
+  try {
+    persistForegroundRun({
+      runId: input.runId,
+      mode: "single",
+      cwd: input.cwd,
+      ...input.sessionId ? { sessionId: input.sessionId } : {},
+      updatedAt,
+      children: [rememberedForegroundChild(input, input.child, 0, "running", updatedAt)],
+      owner: currentRecordedPid(),
+      ...input.parentWorkflowRunId ? { parentWorkflowRunId: input.parentWorkflowRunId } : {}
+    });
+  } catch (error) {
+    console.error("Failed to persist running foreground run:", error);
+  }
 }
 function applyControlEventToRememberedForegroundRun(state, event) {
   const run = state.foregroundRuns?.get(event.runId);
@@ -10320,7 +10383,7 @@ function updateRememberedForegroundChild(state, input) {
     ...input.result.capabilityAudit ? { capabilityAudit: input.result.capabilityAudit } : {}
   });
   trimRememberedForegroundRuns(state);
-  persistRememberedForegroundRuns(state);
+  persistRememberedForegroundRun(state, input.runId);
   const output = getSingleResultOutput(input.result).trim();
   const success = terminalStatus === "completed";
   const summary = !success && input.result.error ? `${input.result.error}${output ? `
@@ -12501,9 +12564,9 @@ function importWorkflowAwaitedChildResult(completed, options) {
     }
   };
 }
-function stopAwaitedAsyncChildOnAbort(signal, state, runId, asyncDir, kill, reattachedFromOtherSession = false) {
+function stopAwaitedAsyncChildOnAbort(signal, state, runId, asyncDir, kill, reattached = false) {
   const stopOnAbort = () => {
-    if (!workflowStopCause(signal?.reason)) stopAsyncRun(state, runId, kill, { asyncDir, resolvedId: runId, ...reattachedFromOtherSession ? { reattachedRunId: runId } : {} });
+    if (!workflowStopCause(signal?.reason)) stopAsyncRun(state, runId, kill, { asyncDir, resolvedId: runId, ...reattached ? { reattachedRunId: runId } : {} });
   };
   if (signal?.aborted) stopOnAbort();
   else signal?.addEventListener("abort", stopOnAbort, { once: true });
@@ -13016,7 +13079,7 @@ async function runSinglePath(data, deps) {
   if (requestedMachine) {
     try {
       assertRequiredChildExtensionsAdmitted([requiredExtensions], { agent: agentConfig.name, runnerType: agentConfig.runner?.type, machine: requestedMachine });
-      foregroundMachine = resolveHerdrMachinePlacement({ machine: requestedMachine, cwd: ctx.cwd, stepCwd: params.machineCwd }).machine;
+      foregroundMachine = resolveMachinePlacement({ machine: requestedMachine, cwd: ctx.cwd, stepCwd: params.machineCwd }).machine;
     } catch (error) {
       return toExecutionErrorResult(params, error instanceof Error ? error : new Error(String(error)), data.contextPolicy.contextSummary);
     }
@@ -13209,6 +13272,13 @@ async function runSinglePath(data, deps) {
     onUpdate(update);
   } : void 0;
   const deadlineAt = data.deadlineAt ?? (data.timeoutMs !== void 0 ? Date.now() + data.timeoutMs : void 0);
+  const discardRunningRecord = () => {
+    try {
+      discardRunningForegroundRun(runId);
+    } catch (discardError) {
+      console.error("Failed to discard running foreground run:", discardError);
+    }
+  };
   let r;
   let resolveDetachedWorkflowChild;
   const detachedWorkflowChild = params.workflowAwaitDetached === true ? new Promise((resolve10) => {
@@ -13216,6 +13286,27 @@ async function runSinglePath(data, deps) {
   }) : void 0;
   try {
     const childSessionFile = sessionFileForTask(params.agent, 0, modelOverride, modelOverrideFromParent, modelOrigin);
+    rememberRunningForegroundRun({
+      modelResponseAliases,
+      runId,
+      mode: "single",
+      cwd: singleCwd,
+      sessionId: data.parentSessionId,
+      params,
+      effectiveOutput,
+      effectiveOutputMode,
+      extensionBindings: params.extensionBindings,
+      requiredExtensions,
+      child: omitUndefinedProperties({
+        agent: params.agent,
+        context: shouldForkAgent(contextPolicy, params.agent) ? "fork" : "fresh",
+        sessionFile: childSessionFile,
+        model: modelOverride,
+        thinking: resolveEffectiveThinking(modelOverride, thinkingOverrideForTask()),
+        capabilityCeiling: data.capabilityCeiling
+      }),
+      parentWorkflowRunId: params.workflowParentRunId ?? foregroundControl?.parentWorkflowRunId
+    });
     const launched = await runSync(ctx.cwd, agents, params.agent, task, compactOptional({
       machine: foregroundMachine,
       parentProviderRegistry: ctx.modelRegistry,
@@ -13291,7 +13382,12 @@ async function runSinglePath(data, deps) {
         }
         try {
           if (worktreeSetup) {
-            await finalizeSingleWorktreeHandoff({ worktreeSetup, artifactsDir, runId, cwd: sourceCwd, agent: params.agent, result: result2, workflowKey: params.workflowKey, lane });
+            try {
+              await finalizeSingleWorktreeHandoff({ worktreeSetup, artifactsDir, runId, cwd: sourceCwd, agent: params.agent, result: result2, workflowKey: params.workflowKey, lane });
+            } catch (error) {
+              discardRunningRecord();
+              throw error;
+            }
           }
           try {
             updateRememberedForegroundChild(deps.state, { runId, mode: "single", cwd: singleCwd, sessionId: data.parentSessionId, index: 0, result: result2, events: deps.pi.events, notify: true });
@@ -13340,6 +13436,7 @@ async function runSinglePath(data, deps) {
     }
     r = launched.detached && detachedWorkflowChild ? await detachedWorkflowChild : launched;
   } catch (error) {
+    discardRunningRecord();
     await cleanupSingleWorktree();
     throw error;
   } finally {
@@ -13350,7 +13447,12 @@ async function runSinglePath(data, deps) {
   }
   let worktreeHandoff;
   if (worktreeSetup) {
-    worktreeHandoff = r.detached ? { suffix: pendingHandoff ? formatParallelHandoffReference(pendingHandoff) : "", reference: pendingHandoff } : await finalizeSingleWorktreeHandoff({ worktreeSetup, artifactsDir, runId, cwd: sourceCwd, agent: params.agent, result: r, workflowKey: params.workflowKey, lane });
+    try {
+      worktreeHandoff = r.detached ? { suffix: pendingHandoff ? formatParallelHandoffReference(pendingHandoff) : "", reference: pendingHandoff } : await finalizeSingleWorktreeHandoff({ worktreeSetup, artifactsDir, runId, cwd: sourceCwd, agent: params.agent, result: r, workflowKey: params.workflowKey, lane });
+    } catch (error) {
+      discardRunningRecord();
+      throw error;
+    }
   }
   if (r.progress) allProgress.push(r.progress);
   if (r.artifactPaths) allArtifactPaths.push(r.artifactPaths);
@@ -14029,6 +14131,14 @@ function createScheduledOwnerState(source, ownerSessionId, ctx) {
     workflowChildStops: /* @__PURE__ */ new Map()
   };
 }
+function savedWorkflowLaunchParams(params) {
+  const { reuseFrom: _reuseFrom, scheduleOrigin: _scheduleOrigin, resumeOrigin: _resumeOrigin, ...saved } = params;
+  return saved;
+}
+function workflowLaunchRecord(launch, cwd, scriptDigest) {
+  if (launch.source === "structured") return { version: 1, source: "structured", scriptDigest };
+  return { version: 1, source: launch.source, params: { ...launch.params, cwd }, scriptDigest };
+}
 function createSubagentExecutor(deps) {
   const executorDeps = deps;
   const delegatedThinkingOverrides = /* @__PURE__ */ new WeakMap();
@@ -14036,6 +14146,8 @@ function createSubagentExecutor(deps) {
   const delegatedExecutions = /* @__PURE__ */ new WeakSet();
   const publicExecutions = /* @__PURE__ */ new WeakSet();
   const workflowResourcePermits = /* @__PURE__ */ new WeakMap();
+  const publicWorkflowLaunches = /* @__PURE__ */ new WeakMap();
+  const workflowResumeLaunches = /* @__PURE__ */ new WeakMap();
   const workflowPermitContexts = /* @__PURE__ */ new WeakMap();
   const warnedArtifactPackageDirs = /* @__PURE__ */ new Set();
   const scheduledOwnerExecutors = /* @__PURE__ */ new Map();
@@ -14051,7 +14163,13 @@ function createSubagentExecutor(deps) {
       if (error) throw new Error(error);
     }
   };
-  const execute = async (_id, params, signal, onUpdate, ctx, preserveActiveSession = false, parentModelOverride) => {
+  const pendingReuseClaimReleases = /* @__PURE__ */ new WeakMap();
+  const execute = (...args) => executeRequest(...args).finally(() => {
+    const releaseReuseClaim = pendingReuseClaimReleases.get(args[1]);
+    pendingReuseClaimReleases.delete(args[1]);
+    releaseReuseClaim?.();
+  });
+  const executeRequest = async (_id, params, signal, onUpdate, ctx, preserveActiveSession = false, parentModelOverride) => {
     const projectScopeError = projectScopeTrustError(params, ctx);
     if (projectScopeError) return projectScopeError;
     const deps2 = withSessionProjectTrust(executorDeps, ctx);
@@ -14063,6 +14181,8 @@ function createSubagentExecutor(deps) {
     const delegatedExecution = delegatedExecutions.has(params);
     const publicExecution = publicExecutions.has(params);
     const workflowResourcePermit = workflowResourcePermits.get(params);
+    const workflowResumeLaunch = workflowResumeLaunches.get(params);
+    const publicWorkflowLaunch = publicWorkflowLaunches.get(params);
     const workflowPermitContext = workflowPermitContexts.get(params);
     const delegatedWorkflowPermit = workflowPermitContext && "root" in workflowPermitContext ? workflowPermitContext.root : void 0;
     const workflowChildPermitLaunch = workflowPermitContext && "child" in workflowPermitContext ? workflowPermitContext.child : void 0;
@@ -14180,13 +14300,14 @@ function createSubagentExecutor(deps) {
       const workflowDepth = checkSubagentDepth(deps2.config.maxSubagentDepth, deps2.childRuntime).depth;
       const asyncWorkflow = requestParams.async !== false;
       const topLevelAsyncWorkflow = asyncWorkflow && workflowDepth === 0 && !inheritedNestedRoute(deps2) && !requestParams.workflowParentRunId;
-      const workflowRunId = asyncWorkflow ? randomUUID5() : void 0;
+      const workflowRunId = asyncWorkflow ? workflowResumeLaunch?.presetRunId ?? randomUUID5() : void 0;
       if (requestParams.reuseFrom !== void 0 && !topLevelAsyncWorkflow) {
         return { content: [{ type: "text", text: "options.reuseFrom requires an async top-level workflow." }], isError: true, details: { mode: "workflow", results: [] } };
       }
-      let namedWorkflowReuseSource;
+      let workflowReuseSource;
       try {
-        if (requestParams.reuseFrom !== void 0) namedWorkflowReuseSource = readNamedWorkflowReuseSource(DIRS.async, requestParams.reuseFrom, workflowScriptDigest(requestParams.workflowScript), workflowCwd);
+        if (requestParams.reuseFrom !== void 0) workflowReuseSource = readNamedWorkflowReuseSource(DIRS.async, requestParams.reuseFrom, workflowScriptDigest(requestParams.workflowScript), workflowCwd, workflowResumeLaunch?.presetRunId);
+        else if (workflowRunId) workflowReuseSource = findWorkflowReuseSource(DIRS.async, resolveCurrentSessionId(ctx.sessionManager), workflowScriptDigest(requestParams.workflowScript), workflowArgsDigest);
       } catch (error) {
         return { content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: true, details: { mode: "workflow", results: [] } };
       }
@@ -14256,17 +14377,37 @@ function createSubagentExecutor(deps) {
         const completionOwnerId = deps2.state.completionOwnerId ?? currentCompletionOwnerId();
         deps2.state.completionOwnerId = completionOwnerId;
         const workflowScriptSourceDigest = workflowScriptDigest(requestParams.workflowScript);
-        const workflowReuseSource = namedWorkflowReuseSource ?? findWorkflowReuseSource(DIRS.async, currentSessionId, workflowScriptSourceDigest, workflowArgsDigest);
         const workflowRunEvidence = { ...workflowArgsEvidence, scriptDigest: workflowScriptSourceDigest };
         if (workflowReuseSource) workflowRunEvidence.reusedFrom = workflowReuseSource.runId;
+        if (workflowResumeLaunch) workflowRunEvidence.resumeOrigin = workflowResumeLaunch.resumeOrigin;
         const workflowJournalFingerprints = /* @__PURE__ */ new Map();
+        const storageFailure = (error) => {
+          workflowCapacity?.rollback();
+          return { content: [{ type: "text", text: `Failed to create async workflow storage: ${error instanceof Error ? error.message : String(error)}` }], isError: true, details: { mode: "workflow", results: [] } };
+        };
+        if (workflowReuseSource) {
+          const reuseSourceDir = path19.join(DIRS.async, workflowReuseSource.runId);
+          let claim;
+          try {
+            claim = claimWorkflowResume(reuseSourceDir, { newRunId: workflowRunId, trigger: "reuse" });
+          } catch (error) {
+            return storageFailure(error);
+          }
+          if (claim.kind !== "owner") {
+            workflowCapacity?.rollback();
+            return { content: [{ type: "text", text: claimedWorkflowRunRefusal(workflowReuseSource.runId, claim, requestParams.reuseFrom !== void 0) }], isError: true, details: { mode: "workflow", results: [] } };
+          }
+          pendingReuseClaimReleases.set(params, () => {
+            if (!fs21.existsSync(statusPath)) releaseWorkflowResumeClaim(reuseSourceDir, workflowRunId);
+          });
+        }
         try {
           fs21.mkdirSync(asyncDir, { recursive: true });
           writeRunFanoutBudgetDescriptor(asyncDir, workflowFanoutBudget);
+          if (topLevelAsyncWorkflow && publicWorkflowLaunch) writeWorkflowLaunchRecord(asyncDir, workflowLaunchRecord(publicWorkflowLaunch, workflowCwd, workflowScriptSourceDigest));
           fs21.mkdirSync(DIRS.results, { recursive: true });
         } catch (error) {
-          workflowCapacity?.rollback();
-          return { content: [{ type: "text", text: `Failed to create async workflow storage: ${error instanceof Error ? error.message : String(error)}` }], isError: true, details: { mode: "workflow", results: [] } };
+          return storageFailure(error);
         }
         const controller = new AbortController();
         deps2.state.workflowControllers ??= /* @__PURE__ */ new Map();
@@ -14287,7 +14428,7 @@ function createSubagentExecutor(deps) {
           cwd: workflowCwd,
           ...workflowSessionRoot ? { sessionRoot: workflowSessionRoot } : {},
           ...requestParams.scheduleOrigin ? { scheduleOrigin: requestParams.scheduleOrigin } : {},
-          pid: process.pid,
+          ...currentRecordedPid(),
           ...workflowCapabilityCeiling2 ? { admissionCapabilityCeiling: workflowCapabilityCeiling2 } : {},
           steps: [],
           ...workflowPreflight ? { preflight: workflowPreflight } : {},
@@ -14876,7 +15017,7 @@ Parent action: ${COMPLETION_ACTION}` : content,
                   const priorAsyncDir = path19.join(DIRS.async, priorRunId);
                   appendWorkflowChildJournal(asyncDir, { type: "start", key, fingerprint: journalFingerprint, runId: priorRunId });
                   recordReusedWorkflowChild(key, priorRunId);
-                  const stopListener = stopAwaitedAsyncChildOnAbort(workflowSignal, deps2.state, priorRunId, priorAsyncDir, deps2.kill, requestParams.reuseFrom !== void 0);
+                  const stopListener = stopAwaitedAsyncChildOnAbort(workflowSignal, deps2.state, priorRunId, priorAsyncDir, deps2.kill, true);
                   const reattached = await awaitExistingAsyncRun(priorAsyncDir, priorRunId, workflowSignal).finally(stopListener.remove);
                   const claimedPath = reattached.status === "settled" ? claimWorkflowAwaitedResult(priorAsyncDir, workflowRunId, { ...reattached.result.importedPublication, runId: priorRunId }) : void 0;
                   if (reattached.status === "settled" && claimedPath) {
@@ -15052,7 +15193,7 @@ Parent action: ${COMPLETION_ACTION}` : content,
               if (promoted) status = promoted;
             }
             const errorPreview = status.error && status.error.length > 1e3 ? `${status.error.slice(0, 1e3)}\u2026 (truncated; full error: ${statusPath} (error))` : status.error;
-            const terminalSummary = `${status.state === "complete" ? "Workflow completed after detached child finished." : errorPreview ?? (pauseForDetached ? "Workflow paused." : "Workflow failed.")}${stopCause ? ` ${workflowRuntimeReplacedRelaunchNotice(workflowRunId)}` : ""}${workflowOutputPathMappingSummary2(partial.children)}${finalPreflightWarnings.length ? ` ${finalPreflightWarnings.join(" ")}` : ""}`;
+            const terminalSummary = `${status.state === "complete" ? "Workflow completed after detached child finished." : errorPreview ?? (pauseForDetached ? "Workflow paused." : "Workflow failed.")}${stopCause ? ` ${WORKFLOW_RUNTIME_REPLACED_STOP_NOTICE}` : ""}${workflowOutputPathMappingSummary2(partial.children)}${finalPreflightWarnings.length ? ` ${finalPreflightWarnings.join(" ")}` : ""}`;
             const outputWarning = writeWorkflowAggregateOutput(workflowAggregateOutputPath2, terminalSummary, producedChildOutputPaths2);
             const resultSummary = appendWorkflowOutputWarning(terminalSummary, outputWarning);
             const receiptState = status.state === "complete" ? "complete" : status.state === "paused" ? "paused" : status.state === "stopped" ? "stopped" : "failed";
@@ -15115,6 +15256,7 @@ Parent action: ${COMPLETION_ACTION}` : content,
       let liveWorkflow = { trace: [], emits: [], console: [], ...workflowResource ? { resource: workflowResource.provenance } : {} };
       const childProgress = /* @__PURE__ */ new Map();
       const childLaunches = /* @__PURE__ */ new Map();
+      const blockingWorkflowChildren = /* @__PURE__ */ new Set();
       let activityTimer;
       let lastProgressAt = 0;
       let workflowProgressClosed = false;
@@ -15202,6 +15344,10 @@ Parent action: ${COMPLETION_ACTION}` : content,
                 workflowPermitContexts.set(childRequest, { child: { permit: delegatedWorkflowPermit, workflowRunId: foregroundWorkflowRunId, childKey: key } });
               }
               workflowLaunchObservers.set(childRequest, (launch) => {
+                if (launch.async && launch.runId && (childRequest.workflowAwaitAsync === true || childRequest.action === "resume")) {
+                  (deps2.state.blockingWorkflowChildren ??= /* @__PURE__ */ new Set()).add(launch.runId);
+                  blockingWorkflowChildren.add(launch.runId);
+                }
                 childLaunches.set(key, { agent: launch.agent, ...launch.runId ? { runId: launch.runId } : {} });
                 try {
                   sendWorkflowProgress();
@@ -15323,6 +15469,7 @@ ${partial.console.map((entry) => `[${entry.level}] ${entry.text}`).join("\n")}`]
         }, workflowFanoutBudget));
       } finally {
         workflowProgressClosed = true;
+        for (const runId2 of blockingWorkflowChildren) deps2.state.blockingWorkflowChildren?.delete(runId2);
         if (activityTimer) clearTimeout(activityTimer);
         childProgress.clear();
       }
@@ -15745,6 +15892,8 @@ ${item.text}` } : item)
         return withBudget(inspectSubagentStatus(paramsWithResolvedCwd, omitUndefinedProperties({ state: deps2.state, nested: nestedScope, sessionRoots, abandonedSlotReleaseAfterMs: resolveAbandonedSlotReleaseAfterMs(deps2.config.capacity?.abandonedSlotReleaseAfterMs) })));
       }
       if (action === "resume") {
+        const workflowResumeSourceId = workflowResumeTargetId(DIRS.async, paramsWithResolvedCwd);
+        if (workflowResumeSourceId) return resumeWorkflowById(_id, workflowResumeSourceId, signal, ctx);
         return resumeAsyncRun(omitUndefinedProperties({
           params: paramsWithResolvedCwd,
           requestCwd,
@@ -16570,6 +16719,8 @@ ${item.text}` } : item)
     const workflow = publicParams.workflow;
     const errorResult = (text) => Promise.resolve({ content: [{ type: "text", text }], isError: true, details: { mode: publicParams.action ? "management" : "workflow", results: [] } });
     const scriptTextHint = " A workflow string is a named workflow resource or a script file path. To run script text, write it in one ```js workflow block in the same reply and call subagent({ workflow: true }).";
+    let workflowLaunch;
+    const workflowResumeLaunch = workflowResumeLaunches.get(params);
     if (publicParams.tasks !== void 0 || publicParams.chain !== void 0) {
       const kind = publicParams.tasks !== void 0 ? "tasks" : "chain";
       const resolved = resolveStructuredWorkflowResource({ kind, steps: publicParams[kind], task: publicParams.task });
@@ -16577,10 +16728,20 @@ ${item.text}` } : item)
       const { tasks: _tasks, chain: _chain, task: _task, ...withoutStructuredInput } = publicParams;
       publicParams = { ...withoutStructuredInput, workflowScript: resolved.resource.script };
       workflowResourcePermits.set(publicParams, resolved.resource.permit);
+      workflowLaunch = { source: "structured" };
     } else if (typeof workflow === "string" && !isWorkflowScriptPath(workflow)) {
       const resolved = resolveWorkflowResource(workflow, publicParams.args, ctx.sessionManager.getSessionId() ?? void 0);
+      if (workflowResumeLaunch && !resolved.ok) {
+        workflowResumeLaunch.refusal = { code: "authority", reason: `workflow resource '${workflow}' can no longer be resolved: ${resolved.error}` };
+        return errorResult(workflowResumeLaunch.refusal.reason);
+      }
+      if (workflowResumeLaunch && resolved.ok && workflowScriptDigest(resolved.resource.script) !== workflowResumeLaunch.expectedScriptDigest) {
+        workflowResumeLaunch.refusal = { code: "digest", reason: `workflow resource '${workflow}' changed since the run started` };
+        return errorResult(workflowResumeLaunch.refusal.reason);
+      }
       if (!resolved.ok) return Promise.resolve({ content: [{ type: "text", text: resolved.error + scriptTextHint }], isError: true, details: { mode: "workflow", results: [] } });
       const { workflow: _workflow, args: _args, ...withoutResourceInput } = publicParams;
+      workflowLaunch = { source: "resource", params: savedWorkflowLaunchParams(publicParams) };
       publicParams = { ...withoutResourceInput, workflowScript: resolved.resource.script };
       workflowResourcePermits.set(publicParams, resolved.resource.permit);
     } else if (workflow !== void 0 || publicParams.workflowScript !== void 0) {
@@ -16595,10 +16756,56 @@ ${item.text}` } : item)
       }
       const { workflow: _workflow, ...withoutWorkflowSource } = publicParams;
       publicParams = { ...withoutWorkflowSource, workflowScript, args: "error" in normalizedArgs ? publicParams.args : deepFreezeWorkflowArgs(normalizedArgs.args) };
+      workflowLaunch = { source: "script", params: savedWorkflowLaunchParams(publicParams) };
     }
+    if (workflowLaunch && publicParams.action === void 0) publicWorkflowLaunches.set(publicParams, workflowLaunch);
+    if (workflowResumeLaunch) workflowResumeLaunches.set(publicParams, workflowResumeLaunch);
     publicExecutions.add(publicParams);
     return executeWithSingleDispatchGuard(id, publicParams, signal, onUpdate, ctx);
   };
+  const executeWorkflowResume = async (id, prepared, signal, ctx) => {
+    const params = { ...prepared.params };
+    const launch = { presetRunId: prepared.newRunId, resumeOrigin: prepared.resumeOrigin, expectedScriptDigest: prepared.expectedScriptDigest };
+    workflowResumeLaunches.set(params, launch);
+    let result2;
+    try {
+      result2 = await executePublic(id, params, signal, void 0, ctx);
+    } catch (error) {
+      result2 = { content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: true, details: { mode: "workflow", results: [] } };
+    }
+    if (resumedRunStarted(prepared.sourceAsyncDir, prepared.newRunId)) return { result: result2, launched: true };
+    const firstText = result2.content.find((block) => block.type === "text")?.text ?? "no result";
+    const refusal = launch.refusal ? workflowResumeRefusal(launch.refusal.code, launch.refusal.reason, prepared.sourceRunId) : result2.details?.activeAsyncCapacity ? workflowResumeRefusal("capacity", `capacity refused: ${firstText}`, prepared.sourceRunId) : workflowResumeRefusal("launch-failed", `launch failed: ${firstText}`, prepared.sourceRunId);
+    releaseWorkflowResumeClaim(prepared.sourceAsyncDir, prepared.newRunId);
+    if (prepared.trigger === "auto") {
+      try {
+        recordWorkflowResumeRefusal(prepared.sourceAsyncDir, { reason: refusal.reason, byHand: refusal.byHand, newRunId: prepared.newRunId });
+      } catch (error) {
+        console.error(`Failed to record why workflow ${prepared.sourceRunId} was not resumed:`, error);
+      }
+    }
+    return { result: result2, launched: false, refusal };
+  };
+  const resumeWorkflowById = async (id, sourceRunId, signal, ctx) => {
+    const refused = (text) => ({ content: [{ type: "text", text }], isError: true, details: { mode: "management", results: [] } });
+    let preparation;
+    try {
+      preparation = prepareWorkflowResume({ asyncDirRoot: DIRS.async, sourceRunId, trigger: "manual", now: Date.now(), currentSessionId: resolveCurrentSessionId(ctx.sessionManager) });
+    } catch (error) {
+      return refused(`Cannot resume workflow '${sourceRunId}': ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!preparation.ok) return refused(manualWorkflowResumeRefusalText(sourceRunId, preparation));
+    const outcome = await executeWorkflowResume(id, preparation.prepared, signal, ctx);
+    if (!outcome.launched) return refused(manualWorkflowResumeRefusalText(sourceRunId, outcome.refusal));
+    const resumedLine = `Resumed workflow '${sourceRunId}' as ${preparation.prepared.newRunId}.`;
+    const textIndex = outcome.result.content.findIndex((block) => block.type === "text");
+    const content = [...outcome.result.content];
+    const first = content[textIndex];
+    if (first?.type === "text") content[textIndex] = { ...first, text: `${resumedLine}
+${first.text}` };
+    else content.unshift({ type: "text", text: resumedLine });
+    return { ...outcome.result, content };
+  };
   const executeDelegated = async (id, params, signal, onUpdate, ctx) => {
     const disabledFeatureError = disabledFeatureResult(params);
     if (disabledFeatureError) return disabledFeatureError;
@@ -16637,7 +16844,7 @@ ${item.text}` } : item)
     if (!ownerId) return;
     for (const owner of scheduledOwnerExecutors.get(ownerId)?.values() ?? []) yield owner.state;
   }
-  return { execute: executeWithSingleDispatchGuard, executePublic, executeDelegated, executeScheduled, getCurrentSupervisorOwnerStates };
+  return { execute: executeWithSingleDispatchGuard, executePublic, executeDelegated, executeScheduled, executeWorkflowResume, getCurrentSupervisorOwnerStates };
 }
 export {
   DEFAULT_ASYNC_TIMEOUT_MS,