pi-subagents 0.81.0 → 0.82.0

package/bundle/{chunk-26C3WLYQ.js → chunk-ZLINIYTP.js}

@@ -11,27 +11,35 @@ import {
   startWatchdogDiffBaselineCapture,
   writeUserWatchdogEnabled,
   writeWatchdogModelSettings
-} from "./chunk-BPS2AGBZ.js";
+} from "./chunk-W2SZ22EM.js";
 import {
   resolveGitRepositoryIdentity
-} from "./chunk-KSWQVGDW.js";
+} from "./chunk-7PCKZHR5.js";
 import {
   listAsyncRuns,
+  ownsRun,
   parallelHandoffPath,
   parseWorkflowChildSummary,
   readAsyncRecoveryDescriptor,
-  resolveRetainedWorktreeCwd,
-  utf8Tail
-} from "./chunk-NNLASTQE.js";
+  resolveRetainedWorktreeCwd
+} from "./chunk-VH5OAWVG.js";
 import {
   deepFreezeWorkflowArgs,
   normalizeWorkflowArgs
 } from "./chunk-NF7IEKBH.js";
 import {
   HOST_STEP_MAX_COUNT,
+  WORKFLOW_STOP_CAUSE_OWNER_EXITED,
+  WORKFLOW_STOP_CAUSE_RUNTIME_REPLACED,
   assertUniqueHostStepIds,
+  checkRecordedPidLiveness,
+  currentBootId,
+  currentPidNamespaceScope,
+  currentRecordedPid,
   hasLiveNestedDescendants,
   isActiveAsyncState,
+  isRecordedPid,
+  isReusableWorkflowStopCause,
   normalizeWorktreeBaseRef,
   parseHostStepNode,
   previewSimpleWorkflowRun,
@@ -41,23 +49,22 @@ import {
   reconcileAsyncRun,
   resolveMissionStoreLocation,
   validateMissionId,
-  validateModelResponseAliases,
   workflowRunParamsFingerprint
-} from "./chunk-VJHOELQP.js";
+} from "./chunk-NRQ75MGH.js";
 import {
   requestAsyncCommand,
   watchAsyncControlInbox
-} from "./chunk-BJN5LUQY.js";
+} from "./chunk-OYF6AFDY.js";
 import {
   supervisorChannelDir
-} from "./chunk-G5DKFLLI.js";
+} from "./chunk-4SDU2BZX.js";
 import {
   createHerdrClient,
   detectHerdr
-} from "./chunk-V2JWDB5U.js";
+} from "./chunk-52UBALJL.js";
 import {
   getProjectSubagentsDir
-} from "./chunk-3DC5KBVP.js";
+} from "./chunk-5TYMSZX3.js";
 import {
   ExternalJobProviderError,
   getExternalJobProvider,
@@ -67,7 +74,7 @@ import {
 } from "./chunk-YYREO77V.js";
 import {
   mergeRuntimeAgents
-} from "./chunk-3IF2PGW7.js";
+} from "./chunk-YKEWIB4M.js";
 import {
   CODE_OWNED_EXTERNAL_CLI_ADAPTER_LABEL,
   PI_CODING_AGENT_PACKAGE,
@@ -98,8 +105,8 @@ import {
   normalizeModelSegment,
   normalizeWorkflowLaneMetadata,
   parseFrontmatter,
-  parseFrontmatterList,
   parsePackageName,
+  parseUnquotedList,
   readStatus,
   removeBuiltinAgentOverride,
   removeBuiltinAgentOverrideFields,
@@ -122,7 +129,7 @@ import {
   withFileLease,
   writeAtomicJson,
   writePrivateAtomicJson
-} from "./chunk-ZBC44JJ3.js";
+} from "./chunk-CIZQXJ5Q.js";
 import {
   DIRS,
   INTERCOM_DETACH_REQUEST_EVENT,
@@ -3082,8 +3089,8 @@ function withDeclaredExtensionPaths(config, filePath) {
   const { extensions: _extensions, subagentOnlyExtensions: _subagentOnlyExtensions, ...withoutResolvedExtensions } = config;
   return {
     ...withoutResolvedExtensions,
-    ...frontmatter.extensions !== void 0 ? { extensions: parseFrontmatterList(frontmatter.extensions) } : {},
-    ...frontmatter.subagentOnlyExtensions !== void 0 ? { subagentOnlyExtensions: parseFrontmatterList(frontmatter.subagentOnlyExtensions) } : {}
+    ...frontmatter.extensions !== void 0 ? { extensions: parseUnquotedList(frontmatter.extensions) } : {},
+    ...frontmatter.subagentOnlyExtensions !== void 0 ? { subagentOnlyExtensions: parseUnquotedList(frontmatter.subagentOnlyExtensions) } : {}
   };
 }
 function editableAgentConfig(agent) {
@@ -5071,6 +5078,197 @@ function createParentWake(pi, now = Date.now) {
   };
 }
 
+// src/workflows/workflow-launch-record.ts
+import * as fs9 from "node:fs";
+import * as path8 from "node:path";
+var WORKFLOW_LAUNCH_RECORD_FILE = "launch.json";
+function launchRecordPath(asyncDir) {
+  return path8.join(asyncDir, WORKFLOW_LAUNCH_RECORD_FILE);
+}
+function writeWorkflowLaunchRecord(asyncDir, record) {
+  writeAtomicJson(launchRecordPath(asyncDir), record);
+}
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function invalid(error2) {
+  return { ok: false, missing: false, error: error2 };
+}
+function readWorkflowLaunchRecord(asyncDir) {
+  let text2;
+  try {
+    text2 = fs9.readFileSync(launchRecordPath(asyncDir), "utf-8");
+  } catch (error2) {
+    if (error2.code === "ENOENT") return { ok: false, missing: true, error: "launch.json is missing" };
+    return invalid(`could not be read: ${error2 instanceof Error ? error2.message : String(error2)}`);
+  }
+  let value;
+  try {
+    value = JSON.parse(text2);
+  } catch (error2) {
+    return invalid(`not valid JSON: ${error2 instanceof Error ? error2.message : String(error2)}`);
+  }
+  if (!isPlainObject(value)) return invalid("not a JSON object");
+  if (value.version !== 1) return invalid("version must be 1");
+  if (typeof value.scriptDigest !== "string" || !value.scriptDigest) return invalid("scriptDigest must be a non-empty string");
+  if (value.source === "structured") return { ok: true, record: { version: 1, source: "structured", scriptDigest: value.scriptDigest } };
+  if (value.source !== "script" && value.source !== "resource") return invalid('source must be "script", "resource", or "structured"');
+  if (!isPlainObject(value.params)) return invalid("params must be an object");
+  return { ok: true, record: { version: 1, source: value.source, params: value.params, scriptDigest: value.scriptDigest } };
+}
+
+// src/workflows/workflow-resume-claim.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import * as fs10 from "node:fs";
+import * as path9 from "node:path";
+var CLAIM_FILE_PATTERN = /^resumed-by\.([1-9][0-9]*)\.json$/;
+var RELEASED_CLAIM_FILE_PATTERN = /^resumed-by\.([1-9][0-9]*)\.json\.released-/;
+var REFUSAL_FILE = "resume-refused.json";
+var MAX_CLAIM_ROUNDS = 8;
+var heldClaimsKey = /* @__PURE__ */ Symbol.for("pi-subagents.workflow-resume-claims.v1");
+var heldClaimsGlobal = globalThis;
+var heldClaims = heldClaimsGlobal[heldClaimsKey] ?? (heldClaimsGlobal[heldClaimsKey] = /* @__PURE__ */ new Set());
+function claimFilePath(asyncDir, generation) {
+  return path9.join(asyncDir, `resumed-by.${generation}.json`);
+}
+function isClaim(value) {
+  if (!isRecordedPid(value) || Array.isArray(value)) return false;
+  const claim = value;
+  return claim.version === 1 && typeof claim.claimedAt === "number" && typeof claim.newRunId === "string" && claim.newRunId.length > 0 && (claim.trigger === "auto" || claim.trigger === "manual" || claim.trigger === "reuse");
+}
+function readTopClaim(asyncDir, retries = 3) {
+  let generation = 0;
+  let releasedGeneration = 0;
+  try {
+    for (const name of fs10.readdirSync(asyncDir)) {
+      const live = CLAIM_FILE_PATTERN.exec(name);
+      if (live) generation = Math.max(generation, Number(live[1]));
+      const released = RELEASED_CLAIM_FILE_PATTERN.exec(name);
+      if (released) releasedGeneration = Math.max(releasedGeneration, Number(released[1]));
+    }
+  } catch (error2) {
+    return error2.code === "ENOENT" ? { kind: "open", generation: 0 } : { kind: "unreadable" };
+  }
+  if (releasedGeneration > generation || generation === 0) return { kind: "open", generation: Math.max(releasedGeneration, generation) };
+  const filePath = claimFilePath(asyncDir, generation);
+  let text2;
+  try {
+    text2 = fs10.readFileSync(filePath, "utf-8");
+  } catch (error2) {
+    if (error2.code === "ENOENT" && retries > 0) return readTopClaim(asyncDir, retries - 1);
+    return { kind: "unreadable" };
+  }
+  try {
+    const value = JSON.parse(text2);
+    return isClaim(value) ? { kind: "claim", generation, filePath, claim: value } : { kind: "open", generation };
+  } catch {
+    return { kind: "open", generation };
+  }
+}
+function readWorkflowResumeClaim(asyncDir) {
+  const top = readTopClaim(asyncDir);
+  return top.kind === "claim" ? top.claim : void 0;
+}
+function resumedRunStarted(sourceAsyncDir, newRunId) {
+  return path9.basename(newRunId) === newRunId && fs10.existsSync(path9.join(path9.dirname(sourceAsyncDir), newRunId, "status.json"));
+}
+function claimantLiveness(filePath, claim, liveness) {
+  if (claim.pid === process.pid && claim.bootId === currentBootId() && claim.pidNamespaceScope === currentPidNamespaceScope()) return heldClaims.has(filePath) ? "alive" : "dead";
+  return liveness ? liveness(claim) : checkRecordedPidLiveness(claim);
+}
+function workflowResumeClaimState(asyncDir, options = {}) {
+  const top = readTopClaim(asyncDir);
+  if (top.kind === "unreadable") return { kind: "unreadable" };
+  if (top.kind !== "claim") return { kind: "none" };
+  if (resumedRunStarted(asyncDir, top.claim.newRunId)) return { kind: "resumed", newRunId: top.claim.newRunId };
+  return claimantLiveness(top.filePath, top.claim, options.liveness) === "dead" ? { kind: "none" } : { kind: "busy", pid: top.claim.pid, newRunId: top.claim.newRunId };
+}
+function createClaimFile(filePath, claim) {
+  const tempPath = `${filePath}.${process.pid}.${randomUUID3()}.tmp`;
+  try {
+    fs10.writeFileSync(tempPath, JSON.stringify(claim, null, 2), "utf-8");
+    fs10.linkSync(tempPath, filePath);
+    return true;
+  } catch (error2) {
+    if (error2.code === "EEXIST") return false;
+    throw error2;
+  } finally {
+    fs10.rmSync(tempPath, { force: true });
+  }
+}
+function claimWorkflowResume(asyncDir, input) {
+  const claim = {
+    version: 1,
+    ...currentRecordedPid(),
+    claimedAt: input.now ?? Date.now(),
+    newRunId: input.newRunId,
+    trigger: input.trigger
+  };
+  for (let round = 0; round < MAX_CLAIM_ROUNDS; round++) {
+    const top2 = readTopClaim(asyncDir);
+    if (top2.kind === "unreadable") return { kind: "unreadable" };
+    if (top2.kind === "claim") {
+      if (top2.claim.newRunId === input.newRunId && top2.claim.pid === process.pid) {
+        heldClaims.add(top2.filePath);
+        return { kind: "owner" };
+      }
+      if (resumedRunStarted(asyncDir, top2.claim.newRunId)) return { kind: "resumed", newRunId: top2.claim.newRunId };
+      if (claimantLiveness(top2.filePath, top2.claim, input.liveness) !== "dead") return { kind: "busy", pid: top2.claim.pid };
+    }
+    const filePath = claimFilePath(asyncDir, top2.generation + 1);
+    if (createClaimFile(filePath, claim)) {
+      heldClaims.add(filePath);
+      return { kind: "owner" };
+    }
+  }
+  const top = readTopClaim(asyncDir);
+  return top.kind === "claim" ? { kind: "busy", pid: top.claim.pid } : { kind: "unreadable" };
+}
+function releaseWorkflowResumeClaim(asyncDir, newRunId) {
+  const top = readTopClaim(asyncDir);
+  if (top.kind !== "claim" || top.claim.newRunId !== newRunId || top.claim.pid !== process.pid) return;
+  try {
+    fs10.renameSync(top.filePath, `${top.filePath}.released-${randomUUID3()}`);
+  } catch (error2) {
+    if (error2.code !== "ENOENT") throw error2;
+  }
+  heldClaims.delete(top.filePath);
+}
+function recordWorkflowResumeRefusal(asyncDir, refusal, now = Date.now()) {
+  writeAtomicJson(path9.join(asyncDir, REFUSAL_FILE), { version: 1, ...refusal, refusedAt: now });
+}
+function readWorkflowResumeRefusal(asyncDir) {
+  try {
+    const value = JSON.parse(fs10.readFileSync(path9.join(asyncDir, REFUSAL_FILE), "utf-8"));
+    return value?.version === 1 && typeof value.reason === "string" && typeof value.byHand === "string" && typeof value.refusedAt === "number" && (value.newRunId === void 0 || typeof value.newRunId === "string") ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resumeByHandText(runId) {
+  return `Resume by hand: subagent({ action: "resume", id: "${runId}" })`;
+}
+function relaunchByHandText(runId) {
+  return `Relaunch it by hand with options: { reuseFrom: "${runId}" }.`;
+}
+function refusalSentence(reason, byHand) {
+  return `${reason.replace(/\.$/, "")}.${byHand ? ` ${byHand}` : ""}`;
+}
+function hasWorkflowResumeRefusal(asyncDir) {
+  return fs10.existsSync(path9.join(asyncDir, REFUSAL_FILE));
+}
+var RESUMED_AS = { auto: "Auto-resumed as", manual: "Resumed as", reuse: "Relaunched as" };
+function describeWorkflowResume(asyncDir, runId) {
+  const claim = readWorkflowResumeClaim(asyncDir);
+  const refusal = readWorkflowResumeRefusal(asyncDir);
+  if (refusal && (!claim || refusal.newRunId === claim.newRunId)) {
+    return `Not auto-resumed: ${refusalSentence(refusal.reason, refusal.byHand)}`;
+  }
+  if (claim) return `${RESUMED_AS[claim.trigger]} ${claim.newRunId}.`;
+  const launch = readWorkflowLaunchRecord(asyncDir);
+  return launch.ok && launch.record.source !== "structured" ? resumeByHandText(runId) : relaunchByHandText(runId);
+}
+
 // src/runs/background/notify.ts
 import { statSync as statSync2 } from "node:fs";
 import { debuglog } from "node:util";
@@ -5250,15 +5448,15 @@ function nonemptyPath(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
 function retainedChildPath(value, producerConfirmed = false) {
-  const path15 = nonemptyPath(value);
-  if (!path15) return { status: "unavailable" };
-  if (producerConfirmed) return { status: "verified", path: path15 };
+  const path17 = nonemptyPath(value);
+  if (!path17) return { status: "unavailable" };
+  if (producerConfirmed) return { status: "verified", path: path17 };
   try {
-    return statSync2(path15).isFile() ? { status: "verified", path: path15 } : { status: "unavailable" };
+    return statSync2(path17).isFile() ? { status: "verified", path: path17 } : { status: "unavailable" };
   } catch (error2) {
     const code = typeof error2 === "object" && error2 !== null && "code" in error2 && typeof error2.code === "string" ? error2.code : void 0;
     if (code === "ENOENT" || code === "ENOTDIR") return { status: "unavailable" };
-    return { status: "error", error: { path: path15, ...code ? { code } : {}, message: error2 instanceof Error ? error2.message : String(error2) } };
+    return { status: "error", error: { path: path17, ...code ? { code } : {}, message: error2 instanceof Error ? error2.message : String(error2) } };
   }
 }
 function formatRetainedPathError(label, error2) {
@@ -5362,10 +5560,12 @@ function formatCorrelationLines(details) {
   return [
     details.asyncDir ? `Retention-managed async directory: ${boundedSafeText(details.asyncDir)}` : void 0,
     details.workflowRunId ? `Workflow run: ${details.workflowRunId}` : void 0,
+    details.resumeNotice,
     details.childRuns?.length ? `Child runs: ${details.childRuns.map(formatChildRun).join(", ")}` : void 0,
     details.reconciledFromDetachedChild ? `Reconciled detached child: ${details.reconciledFromDetachedChild}` : void 0
   ].filter((line) => line !== void 0);
 }
+var RESUME_NOTICE_PREFIXES = ["Auto-resumed as ", "Resumed as ", "Relaunched as ", "Not auto-resumed: ", "Resume by hand: ", "Relaunch it by hand with "];
 var WATCHDOG_BLOCKERS_HEADING = "Watchdog blockers:";
 function formatWatchdogBlockerLines(details) {
   if (!details.watchdogBlockers?.length) return [];
@@ -5448,6 +5648,8 @@ function parseSubagentNotifyContent(content) {
   const workflowRunIndex = body.findIndex((line) => line.startsWith("Workflow run: "));
   const childRunsIndex = body.findIndex((line) => line.startsWith("Child runs: "));
   const reconciledIndex = body.findIndex((line) => line.startsWith("Reconciled detached child: "));
+  const resumeNoticeLine = workflowRunIndex >= 0 ? body[workflowRunIndex + 1] : void 0;
+  const resumeNotice = resumeNoticeLine && RESUME_NOTICE_PREFIXES.some((prefix) => resumeNoticeLine.startsWith(prefix)) ? resumeNoticeLine : void 0;
   const watchdogIndex = body.findIndex((line) => line === WATCHDOG_BLOCKERS_HEADING);
   const watchdogBlockers = watchdogIndex >= 0 ? parseWatchdogBlockerLines(body.slice(watchdogIndex + 1)) : [];
   const metadataIndexes = [sessionIndex, handoffIndex, workflowRunIndex, childRunsIndex, reconciledIndex, watchdogIndex].filter((index) => index >= 0);
@@ -5481,6 +5683,7 @@ function parseSubagentNotifyContent(content) {
     resultPreview,
     ...handoffPath ? { handoffPath } : {},
     ...workflowRunId ? { workflowRunId } : {},
+    ...resumeNotice ? { resumeNotice } : {},
     ...childRuns?.length ? { childRuns } : {},
     ...reconciledFromDetachedChild ? { reconciledFromDetachedChild } : {},
     ...watchdogBlockers.length ? { watchdogBlockers } : {},
@@ -5706,6 +5909,8 @@ ${outputPreview}` : outputPreview;
   }) : void 0;
   const reconciledFromDetachedChild = typeof result5.reconciledFromDetachedChild === "string" ? result5.reconciledFromDetachedChild : void 0;
   const asyncDir = nonemptyPath(result5.asyncDir);
+  const stopCause = result5.workflow?.stopCause;
+  const resumeNotice = workflowRunId && asyncDir && isReusableWorkflowStopCause(stopCause) ? describeWorkflowResume(asyncDir, workflowRunId) : void 0;
   const watchdogBlockers = [];
   const watchdogConcerns = [];
   const collectWatchdogFindings = (owner, progress) => {
@@ -5738,6 +5943,7 @@ ${watchdogConcerns.map((warning) => `- ${warning}`).join("\n")}` : resultPreview
     ...handoffPath ? { handoffPath } : {},
     ...rawRunId ? { runId: rawRunId } : {},
     ...workflowRunId ? { workflowRunId } : {},
+    ...resumeNotice ? { resumeNotice } : {},
     ...childRuns.length ? { childRuns } : {},
     ...childOutputs?.length ? { childOutputs } : {},
     ...reconciledFromDetachedChild ? { reconciledFromDetachedChild } : {},
@@ -6391,9 +6597,9 @@ function registerPiWebSessionLiveness(registration) {
 }
 
 // src/runs/background/wait-subscriptions.ts
-import * as fs9 from "node:fs";
-import * as path8 from "node:path";
-import { randomUUID as randomUUID3 } from "node:crypto";
+import * as fs11 from "node:fs";
+import * as path10 from "node:path";
+import { randomUUID as randomUUID4 } from "node:crypto";
 var SUBSCRIPTION_VERSION = 1;
 var STATUS_OUTCOMES = /* @__PURE__ */ new Set(["timed out", "could not be reconciled", "needs attention", "reconciliation failed"]);
 var RECONCILE_INTERVAL_MS = 1e3;
@@ -6412,7 +6618,7 @@ function needsAttention(run) {
   return run.activityState === "needs_attention" || run.steps.some((step) => step.activityState === "needs_attention");
 }
 function subscriptionFile(dir, token) {
-  return path8.join(dir, `${token}.json`);
+  return path10.join(dir, `${token}.json`);
 }
 function formatWaitSubscriptions(state, now = Date.now()) {
   const subscriptions = [...state.waitSubscriptions?.values() ?? []].sort((left, right) => left.createdAt - right.createdAt);
@@ -6426,7 +6632,7 @@ function formatWaitSubscriptions(state, now = Date.now()) {
 function createWaitSubscriptionManager(pi, state, options = {}) {
   const asyncDirRoot = options.asyncDirRoot ?? DIRS.async;
   const resultsDir = options.resultsDir ?? DIRS.results;
-  const subscriptionsDir = options.subscriptionsDir ?? path8.join(path8.dirname(asyncDirRoot), "wait-subscriptions");
+  const subscriptionsDir = options.subscriptionsDir ?? path10.join(path10.dirname(asyncDirRoot), "wait-subscriptions");
   const now = options.now ?? Date.now;
   const subscriptions = state.waitSubscriptions ?? /* @__PURE__ */ new Map();
   state.waitSubscriptions = subscriptions;
@@ -6440,16 +6646,16 @@ function createWaitSubscriptionManager(pi, state, options = {}) {
     lastForeignSweepAt = sweptAt;
     let files;
     try {
-      files = fs9.readdirSync(subscriptionsDir).filter((file) => file.endsWith(".json"));
+      files = fs11.readdirSync(subscriptionsDir).filter((file) => file.endsWith(".json"));
     } catch (error2) {
       if (!isNotFound(error2)) console.error(`Failed to scan wait subscriptions in '${subscriptionsDir}':`, error2);
       return;
     }
     for (const file of files) {
-      const filePath = path8.join(subscriptionsDir, file);
+      const filePath = path10.join(subscriptionsDir, file);
       let record;
       try {
-        record = parseRecord(JSON.parse(fs9.readFileSync(filePath, "utf-8")));
+        record = parseRecord(JSON.parse(fs11.readFileSync(filePath, "utf-8")));
       } catch (error2) {
         console.error(`Ignoring invalid wait subscription '${filePath}':`, error2);
         continue;
@@ -6458,7 +6664,7 @@ function createWaitSubscriptionManager(pi, state, options = {}) {
       if (record.sessionId === state.currentSessionId) continue;
       if (sweptAt < record.expiresAt + FOREIGN_SWEEP_GRACE_MS) continue;
       try {
-        fs9.unlinkSync(filePath);
+        fs11.unlinkSync(filePath);
       } catch (error2) {
         if (!isNotFound(error2)) console.error(`Failed to remove expired wait subscription '${filePath}':`, error2);
       }
@@ -6466,7 +6672,7 @@ function createWaitSubscriptionManager(pi, state, options = {}) {
   };
   const remove = (record) => {
     try {
-      fs9.unlinkSync(subscriptionFile(subscriptionsDir, record.token));
+      fs11.unlinkSync(subscriptionFile(subscriptionsDir, record.token));
     } catch (error2) {
       if (!isNotFound(error2)) throw error2;
     }
@@ -6587,7 +6793,7 @@ Parent action: ${STATUS_OUTCOMES.has(outcome) ? STATUS_ACTION : COMPLETION_ACTIO
       const createdAt = now();
       const record = {
         version: SUBSCRIPTION_VERSION,
-        token: randomUUID3(),
+        token: randomUUID4(),
         sessionId,
         targetKind: input.targetKind,
         runId: input.runId,
@@ -6595,7 +6801,7 @@ Parent action: ${STATUS_OUTCOMES.has(outcome) ? STATUS_ACTION : COMPLETION_ACTIO
         createdAt,
         expiresAt: createdAt + input.timeoutMs
       };
-      fs9.mkdirSync(subscriptionsDir, { recursive: true });
+      fs11.mkdirSync(subscriptionsDir, { recursive: true });
       writeAtomicJson(subscriptionFile(subscriptionsDir, record.token), record);
       subscriptions.set(record.token, record);
       return record;
@@ -6607,21 +6813,21 @@ Parent action: ${STATUS_OUTCOMES.has(outcome) ? STATUS_ACTION : COMPLETION_ACTIO
       if (!state.currentSessionId) return;
       let files;
       try {
-        files = fs9.readdirSync(subscriptionsDir).filter((file) => file.endsWith(".json"));
+        files = fs11.readdirSync(subscriptionsDir).filter((file) => file.endsWith(".json"));
       } catch (error2) {
         if (isNotFound(error2)) return;
         throw error2;
       }
       for (const file of files) {
         try {
-          const record = parseRecord(JSON.parse(fs9.readFileSync(path8.join(subscriptionsDir, file), "utf-8")));
+          const record = parseRecord(JSON.parse(fs11.readFileSync(path10.join(subscriptionsDir, file), "utf-8")));
           if (!record || file !== `${record.token}.json`) continue;
           if (record.sessionId === state.currentSessionId) {
             subscriptions.set(record.token, record);
             if (record.targetKind === "foreground" && !state.foregroundRuns?.has(record.runId)) unresolvedRestoredForegroundTokens.add(record.token);
           }
         } catch (error2) {
-          console.error(`Ignoring invalid wait subscription '${path8.join(subscriptionsDir, file)}':`, error2);
+          console.error(`Ignoring invalid wait subscription '${path10.join(subscriptionsDir, file)}':`, error2);
         }
       }
       reconcile();
@@ -6644,25 +6850,25 @@ Parent action: ${STATUS_OUTCOMES.has(outcome) ? STATUS_ACTION : COMPLETION_ACTIO
 }
 
 // src/runs/shared/child-session.ts
-import * as fs12 from "node:fs";
-import * as path11 from "node:path";
+import * as fs14 from "node:fs";
+import * as path13 from "node:path";
 import { pathToFileURL } from "node:url";
 
 // src/runs/shared/child-commands.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
-import * as fs10 from "node:fs";
-import * as path9 from "node:path";
+import { randomUUID as randomUUID5 } from "node:crypto";
+import * as fs12 from "node:fs";
+import * as path11 from "node:path";
 import { Type } from "typebox";
 var CHILD_COMMAND_TOOL = "subagent_command";
 var writeAtomicJson2 = createAtomicJsonWriter({ mode: 384 });
 var MAX_OUTPUT_BYTES = 8 * 1024;
 var RECENT_COMMANDS = 20;
 function childCommandStatePath(channelDir) {
-  return path9.join(channelDir, "commands.json");
+  return path11.join(channelDir, "commands.json");
 }
 function readChildCommandState(channelDir) {
   try {
-    return JSON.parse(fs10.readFileSync(childCommandStatePath(channelDir), "utf8"));
+    return JSON.parse(fs12.readFileSync(childCommandStatePath(channelDir), "utf8"));
   } catch (error2) {
     if (error2.code === "ENOENT") return void 0;
     throw error2;
@@ -6678,7 +6884,7 @@ function text(result5) {
   return Buffer.from(result5.content.filter((part) => part.type === "text").map((part) => part.text).join("\n")).subarray(-MAX_OUTPUT_BYTES).toString("utf8");
 }
 function createChildCommandRuntime(channelDir) {
-  const ownerId = randomUUID4();
+  const ownerId = randomUUID5();
   const jobs = /* @__PURE__ */ new Map();
   const usedIds = /* @__PURE__ */ new Set();
   let closed = false;
@@ -6834,7 +7040,7 @@ async function waitForCommand(settled, waitMs, signal) {
   }
 }
 function commandReplyPath(channelDir, id) {
-  return path9.join(channelDir, "command-replies", `${id}.json`);
+  return path11.join(channelDir, "command-replies", `${id}.json`);
 }
 async function controlChildCommand(channelDir, operation, toolCallId, signal) {
   const current = readChildCommandState(channelDir);
@@ -6849,7 +7055,7 @@ async function controlChildCommand(channelDir, operation, toolCallId, signal) {
     throw new Error("Child command controller is closed.");
   }
   if (operation !== "status" && !toolCallId) throw new Error("An exact toolCallId is required; command controls never target the next command.");
-  const id = randomUUID4();
+  const id = randomUUID5();
   const deadlineAt = Date.now() + 5e3;
   const request = { type: "command", id, ownerId: current.ownerId, operation, ...toolCallId ? { toolCallId } : {}, deadlineAt };
   requestAsyncCommand(channelDir, request);
@@ -6858,7 +7064,7 @@ async function controlChildCommand(channelDir, operation, toolCallId, signal) {
     while (Date.now() < deadlineAt) {
       if (signal?.aborted) throw new Error("Command control wait aborted; delivery may still be pending.");
       try {
-        const reply = JSON.parse(fs10.readFileSync(replyPath, "utf8"));
+        const reply = JSON.parse(fs12.readFileSync(replyPath, "utf8"));
         if (reply.error) throw new Error(reply.error);
         if (reply.state) return reply.state;
       } catch (error2) {
@@ -6868,7 +7074,7 @@ async function controlChildCommand(channelDir, operation, toolCallId, signal) {
     }
     throw new Error("Command control acknowledgement timed out. Inspect command status; cancellation is not confirmed.");
   } finally {
-    fs10.rmSync(replyPath, { force: true });
+    fs12.rmSync(replyPath, { force: true });
   }
 }
 
@@ -6892,8 +7098,8 @@ function pinChildCacheRetention(agent, env) {
 }
 
 // src/runs/background/runner-aliases.ts
-import * as fs11 from "node:fs";
-import * as path10 from "node:path";
+import * as fs13 from "node:fs";
+import * as path12 from "node:path";
 var JITI_ALIAS_ENV = "JITI_ALIAS";
 var HOST_PEER_ALIASES = [
   { specifier: "@earendil-works/pi-coding-agent", pkg: "@earendil-works/pi-coding-agent", subpath: "." },
@@ -6916,7 +7122,7 @@ var CHORD_PEER_ALIASES = [
 ];
 function readManifest(packageDir) {
   try {
-    return JSON.parse(fs11.readFileSync(path10.join(packageDir, "package.json"), "utf-8"));
+    return JSON.parse(fs13.readFileSync(path12.join(packageDir, "package.json"), "utf-8"));
   } catch {
     return void 0;
   }
@@ -6953,7 +7159,7 @@ function resolvePackageSubpath(packageDir, subpath) {
     const map = typeof exportsField === "string" || Array.isArray(exportsField) || exportsField && typeof exportsField === "object" && !Object.keys(exportsField).some((key) => key.startsWith(".")) ? { ".": exportsField } : exportsField;
     if (subpath in map) {
       const exact = exportTarget(map[subpath]);
-      return typeof exact === "string" ? path10.resolve(packageDir, exact) : void 0;
+      return typeof exact === "string" ? path12.resolve(packageDir, exact) : void 0;
     }
     let best;
     for (const [pattern, entry] of Object.entries(map)) {
@@ -6968,23 +7174,23 @@ function resolvePackageSubpath(packageDir, subpath) {
     const target = exportTarget(best.entry);
     if (typeof target !== "string") return void 0;
     const wildcard = subpath.slice(best.prefix.length, subpath.length - best.suffix.length);
-    return path10.resolve(packageDir, target.replaceAll("*", () => wildcard));
+    return path12.resolve(packageDir, target.replaceAll("*", () => wildcard));
   }
   if (subpath !== ".") return void 0;
-  return path10.resolve(packageDir, typeof manifest.main === "string" && manifest.main.trim() ? manifest.main : "index.js");
+  return path12.resolve(packageDir, typeof manifest.main === "string" && manifest.main.trim() ? manifest.main : "index.js");
 }
 function findPeerPackageDir(piPackageRoot, pkg, hostName) {
   if (hostName === pkg) return piPackageRoot;
-  const candidates = [path10.join(piPackageRoot, "node_modules", pkg)];
+  const candidates = [path12.join(piPackageRoot, "node_modules", pkg)];
   let dir = piPackageRoot;
   for (; ; ) {
-    const parent = path10.dirname(dir);
+    const parent = path12.dirname(dir);
     if (parent === dir) break;
-    if (path10.basename(parent) === "node_modules" || path10.basename(path10.dirname(parent)) === "node_modules") {
-      const modulesRoot = path10.basename(parent) === "node_modules" ? parent : path10.dirname(parent);
-      candidates.push(path10.join(modulesRoot, pkg));
+    if (path12.basename(parent) === "node_modules" || path12.basename(path12.dirname(parent)) === "node_modules") {
+      const modulesRoot = path12.basename(parent) === "node_modules" ? parent : path12.dirname(parent);
+      candidates.push(path12.join(modulesRoot, pkg));
     }
-    candidates.push(path10.join(parent, "node_modules", pkg));
+    candidates.push(path12.join(parent, "node_modules", pkg));
     dir = parent;
   }
   return candidates.find((candidate) => readManifest(candidate)?.name === pkg);
@@ -7001,7 +7207,7 @@ function resolveHostPeerAliases(piPackageRoot) {
     const packageDir = findPeerPackageDir(piPackageRoot, pkg, hostManifest?.name);
     const target = packageDir ? resolvePackageSubpath(packageDir, subpath) : void 0;
     if (optional && packageDir && target === void 0) continue;
-    if (target && fs11.existsSync(target)) aliases[specifier] = fs11.realpathSync(target);
+    if (target && fs13.existsSync(target)) aliases[specifier] = fs13.realpathSync(target);
     else if (pkg !== CHORD_PACKAGE || chordRequired) missing.push(specifier);
   }
   return { aliases, missing };
@@ -7049,14 +7255,36 @@ function inheritParentProviders(modelRuntime, parentProviders, claimedProviderId
 }
 var CHILD_PROMPT_RUNTIME_EXTENSION_PATH = "<inline:pi-subagents:prompt-runtime>";
 var CHILD_PROMPT_BOUNDARY_EXTENSION_PATH = "<inline:pi-subagents:prompt-boundary>";
+var PI_UNICODE_SPACES = new RegExp("[\\u00A0\\u2000-\\u200A\\u202F\\u205F\\u3000]", "g");
+function childExtensionFileIdentity(extensionPath) {
+  if (!path13.isAbsolute(extensionPath)) return void 0;
+  try {
+    const stat = fs14.statSync(extensionPath, { bigint: true });
+    return stat.isFile() ? `${stat.dev}:${stat.ino}` : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function createRequiredChildExtensionIdentity(requiredPaths) {
+  const aliases = new Map([...requiredPaths].map((extensionPath) => [extensionPath, childExtensionFileIdentity(extensionPath) ?? extensionPath]));
+  const identities = new Set(aliases.values());
+  return (extensionPath) => {
+    const known = aliases.get(extensionPath);
+    if (known !== void 0) return known;
+    const identity = childExtensionFileIdentity(extensionPath);
+    if (identity === void 0 || !identities.has(identity)) return void 0;
+    aliases.set(extensionPath, identity);
+    return identity;
+  };
+}
 function orderChildPromptHooks(result5) {
-  const runtime = result5.extensions.filter(({ path: path15 }) => path15 === CHILD_PROMPT_RUNTIME_EXTENSION_PATH);
-  const boundary = result5.extensions.filter(({ path: path15 }) => path15 === CHILD_PROMPT_BOUNDARY_EXTENSION_PATH);
-  const others = result5.extensions.filter(({ path: path15 }) => path15 !== CHILD_PROMPT_RUNTIME_EXTENSION_PATH && path15 !== CHILD_PROMPT_BOUNDARY_EXTENSION_PATH);
+  const runtime = result5.extensions.filter(({ path: path17 }) => path17 === CHILD_PROMPT_RUNTIME_EXTENSION_PATH);
+  const boundary = result5.extensions.filter(({ path: path17 }) => path17 === CHILD_PROMPT_BOUNDARY_EXTENSION_PATH);
+  const others = result5.extensions.filter(({ path: path17 }) => path17 !== CHILD_PROMPT_RUNTIME_EXTENSION_PATH && path17 !== CHILD_PROMPT_BOUNDARY_EXTENSION_PATH);
   return { ...result5, extensions: [...runtime, ...others, ...boundary] };
 }
 function prioritizeChildCommandRuntime(result5) {
-  const index = result5.extensions.findIndex(({ path: path15 }) => path15 === "<inline:pi-subagents:commands>");
+  const index = result5.extensions.findIndex(({ path: path17 }) => path17 === "<inline:pi-subagents:commands>");
   if (index < 0) return result5;
   if (result5.extensions.some((extension, otherIndex) => otherIndex !== index && extension.tools?.has("bash"))) {
     const extensions2 = result5.extensions.filter((_, otherIndex) => otherIndex !== index);
@@ -7160,7 +7388,7 @@ function missingBuiltinMcpTools(session, names) {
   const direct = new Set(session.getAllTools().filter((tool) => tool.exposure === "direct").map(({ name }) => name));
   return names.filter((name) => !active2.has(name) || !direct.has(name));
 }
-function flushQueuedProviderRegistrations(loader, modelRuntime, onError, requiredPaths) {
+function flushQueuedProviderRegistrations(loader, modelRuntime, onError, isRequiredSource) {
   const claimedProviderIds = /* @__PURE__ */ new Set();
   if (!("getExtensions" in loader) || typeof loader.getExtensions !== "function") return { claimedProviderIds, registered: false };
   const { runtime } = loader.getExtensions();
@@ -7172,7 +7400,7 @@ function flushQueuedProviderRegistrations(loader, modelRuntime, onError, require
       registered = true;
     } catch (error2) {
       onError?.({ extensionPath, event: "register_provider", error: error2 });
-      if (requiredPaths.has(extensionPath)) throw new Error(`Required child extension provider registration failed for '${extensionPath}': ${error2 instanceof Error ? error2.message : String(error2)}`);
+      if (isRequiredSource(extensionPath)) throw new Error(`Required child extension provider registration failed for '${extensionPath}': ${error2 instanceof Error ? error2.message : String(error2)}`);
     }
   }
   if (Array.isArray(runtime.pendingProviderRegistrations)) runtime.pendingProviderRegistrations = [];
@@ -7183,7 +7411,7 @@ function flushQueuedProviderRegistrations(loader, modelRuntime, onError, require
       registered = true;
     } catch (error2) {
       onError?.({ extensionPath, event: "register_provider", error: error2 });
-      if (requiredPaths.has(extensionPath)) throw new Error(`Required child extension provider registration failed for '${extensionPath}': ${error2 instanceof Error ? error2.message : String(error2)}`);
+      if (isRequiredSource(extensionPath)) throw new Error(`Required child extension provider registration failed for '${extensionPath}': ${error2 instanceof Error ? error2.message : String(error2)}`);
     }
   }
   if (Array.isArray(runtime.pendingNativeProviderRegistrations)) runtime.pendingNativeProviderRegistrations = [];
@@ -7197,7 +7425,7 @@ function flushQueuedProviderRegistrations(loader, modelRuntime, onError, require
       registered = true;
     } catch (error2) {
       onError?.({ extensionPath, event: "register_virtual_model", error: error2 });
-      if (requiredPaths.has(extensionPath)) throw new Error(`Required child extension virtual model registration failed for '${extensionPath}': ${error2 instanceof Error ? error2.message : String(error2)}`);
+      if (isRequiredSource(extensionPath)) throw new Error(`Required child extension virtual model registration failed for '${extensionPath}': ${error2 instanceof Error ? error2.message : String(error2)}`);
     }
   }
   if (Array.isArray(virtualModelQueue.pendingVirtualModelRegistrations)) virtualModelQueue.pendingVirtualModelRegistrations = [];
@@ -7207,14 +7435,14 @@ async function loadHostPiCodingAgent() {
   const overrideRoot = process.env[PI_CODING_AGENT_PACKAGE_ROOT_ENV]?.trim() || void 0;
   const root = resolveHostPiPackageRoot();
   if (root) {
-    const entry = fs12.realpathSync(resolveHostPackageEntry(root, root === overrideRoot ? overrideRoot : void 0));
+    const entry = fs14.realpathSync(resolveHostPackageEntry(root, root === overrideRoot ? overrideRoot : void 0));
     return import(pathToFileURL(entry).href);
   }
   return import(PI_CODING_AGENT_PACKAGE);
 }
 function resolveHostPackageEntry(root, overrideRoot) {
-  const packageJson = path11.join(root, "package.json");
-  const source = fs12.readFileSync(packageJson, "utf8");
+  const packageJson = path13.join(root, "package.json");
+  const source = fs14.readFileSync(packageJson, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(source);
@@ -7275,6 +7503,12 @@ function createDefaultChildSessionFactory(options = {}) {
           return typeof value === "function" ? value.bind(target) : value;
         }
       })) }] : [];
+      const requiredPaths = new Set((launch.requiredExtensions ?? []).map(({ path: path17 }) => path17));
+      const requiredExtensionIdentity = createRequiredChildExtensionIdentity(requiredPaths);
+      const resolvedExtensionPaths = /* @__PURE__ */ new Map();
+      const isRequiredSource = (extensionPath) => requiredPaths.size > 0 && requiredExtensionIdentity(
+        resolvedExtensionPaths.get(extensionPath) ?? extensionPath.replace(PI_UNICODE_SPACES, " ")
+      ) !== void 0;
       const loader = new pi.DefaultResourceLoader({
         cwd: launch.cwd,
         agentDir,
@@ -7311,13 +7545,18 @@ function createDefaultChildSessionFactory(options = {}) {
       };
       let inheritedProviders = /* @__PURE__ */ new Set();
       const open = async () => {
-        const requiredPaths = new Set((launch.requiredExtensions ?? []).map(({ path: path15 }) => path15));
         applyProcessEnv(launch.processEnv);
         if (!resetExtensionCacheOnReload(loader) && (launch.ambientExtensions || launch.extensionPaths.length)) launch.onExtensionError?.({ extensionPath: "<loader>", event: "load", error: new Error("pi's extension cache reset is unavailable; extensions loaded into this child share module state with other sessions in this process.") });
         await loader.reload();
-        const loadErrors = requiredPaths.size > 0 ? loader.getExtensions().errors.filter(({ path: path15 }) => requiredPaths.has(path15)) : [];
-        if (loadErrors.length > 0) throw new Error(`Required child extension failed to load: ${loadErrors.map(({ path: path15, error: error2 }) => `${path15}: ${error2}`).join("; ")}`);
-        const queued = flushQueuedProviderRegistrations(loader, modelRuntime, launch.onExtensionError, requiredPaths);
+        if (requiredPaths.size > 0) for (const extension of loader.getExtensions().extensions) resolvedExtensionPaths.set(extension.path, extension.resolvedPath);
+        const loadErrors = requiredPaths.size > 0 ? loader.getExtensions().errors.filter(({ path: path17 }) => isRequiredSource(path17)) : [];
+        if (loadErrors.length > 0) throw new Error(`Required child extension failed to load: ${loadErrors.map(({ path: path17, error: error2 }) => `${path17}: ${error2}`).join("; ")}`);
+        const queued = flushQueuedProviderRegistrations(loader, modelRuntime, launch.onExtensionError, isRequiredSource);
+        if (requiredPaths.size > 0) {
+          const loadedIdentities = new Set(loader.getExtensions().extensions.map(({ resolvedPath }) => requiredExtensionIdentity(resolvedPath)));
+          const missing = [...requiredPaths].filter((extensionPath) => !loadedIdentities.has(requiredExtensionIdentity(extensionPath)));
+          if (missing.length) throw new Error(`Required child extension failed to load: ${missing.join(", ")}`);
+        }
         if (launch.parentProviderRegistry) inheritedProviders = inheritParentProviders(modelRuntime, launch.parentProviderRegistry, queued.claimedProviderIds, launch.onExtensionError);
         if (queued.registered || inheritedProviders.size > 0) {
           try {
@@ -7328,7 +7567,7 @@ function createDefaultChildSessionFactory(options = {}) {
           }
         }
         const newSessionOptions = launch.parentSessionFile ? { parentSession: launch.parentSessionFile } : void 0;
-        const newSessionFile = launch.storage.kind === "file" && !fs12.existsSync(launch.storage.sessionFile);
+        const newSessionFile = launch.storage.kind === "file" && !fs14.existsSync(launch.storage.sessionFile);
         const sessionManager = launch.storage.kind === "file" ? pi.SessionManager.open(launch.storage.sessionFile, void 0, launch.cwd) : launch.storage.kind === "dir" ? pi.SessionManager.create(launch.cwd, launch.storage.sessionDir, newSessionOptions) : launch.storage.kind === "memory" ? pi.SessionManager.inMemory(launch.cwd, newSessionOptions) : pi.SessionManager.create(launch.cwd, void 0, newSessionOptions);
         const header = newSessionFile && launch.parentSessionFile ? sessionManager.getHeader() : null;
         if (header) header.parentSession = launch.parentSessionFile;
@@ -7354,7 +7593,7 @@ function createDefaultChildSessionFactory(options = {}) {
           await session2.bindExtensions({
             mode: "print",
             onError: (error2) => {
-              if (binding && requiredPaths.has(error2.extensionPath)) requiredStartupErrors.push(`${error2.extensionPath} (${error2.event}): ${error2.error}`);
+              if (binding && isRequiredSource(error2.extensionPath)) requiredStartupErrors.push(`${error2.extensionPath} (${error2.event}): ${error2.error}`);
               launch.onExtensionError?.({ extensionPath: error2.extensionPath, event: error2.event, error: error2.error });
             }
           });
@@ -7382,7 +7621,7 @@ function createDefaultChildSessionFactory(options = {}) {
         if (disposals !== disposalsAtStart) cancel.abort();
         const ready = (async () => {
           try {
-            await builtinMcp.waitForTools(signal, () => loader.getExtensions().errors.find(({ path: path15 }) => path15 === "builtin:mcp")?.error);
+            await builtinMcp.waitForTools(signal, () => loader.getExtensions().errors.find(({ path: path17 }) => path17 === "builtin:mcp")?.error);
             if (disposals !== disposalsAtStart) throw new Error("The child session factory was disposed while the child waited for its MCP tools.");
             if (signal.aborted) throw new Error("The child launch was cancelled while waiting for its MCP tools.");
             const missing = missingBuiltinMcpTools(session, builtinMcpTools.map(({ name }) => name));
@@ -7471,7 +7710,7 @@ function childSessionFactory() {
 }
 function createLazyPlacementFactory(local) {
   let placed;
-  const factory = async () => placed ??= (await import("./chunk-TUWLXTAM.js")).createPlacementAwareChildSessionFactory(local);
+  const factory = async () => placed ??= (await import("./chunk-MHZ4G23A.js")).createPlacementAwareChildSessionFactory(local);
   return {
     async create(launch) {
       return launch.machine ? (await factory()).create(launch) : local.create(launch);
@@ -7493,13 +7732,10 @@ async function disposeChildSessions() {
 
 // src/workflows/workflow-reuse.ts
 import { createHash as createHash3 } from "node:crypto";
-import * as fs13 from "node:fs";
-import * as path12 from "node:path";
-var WORKFLOW_STOP_CAUSE_RUNTIME_REPLACED = "runtime-replaced";
+import * as fs15 from "node:fs";
+import * as path14 from "node:path";
 var WORKFLOW_CHILD_JOURNAL_FILE = "workflow-children.jsonl";
-function workflowRuntimeReplacedRelaunchNotice(runId) {
-  return `Async children that were still running keep running. Relaunching the same workflow script with the same args from this session reuses finished children and re-attaches to running ones; from another session, add options: { reuseFrom: "${runId}" }.`;
-}
+var WORKFLOW_RUNTIME_REPLACED_STOP_NOTICE = "Async children that were still running keep running, and finished children are kept.";
 function runtimeReplacedAbortReason() {
   return Object.assign(new Error("Workflow stopped because the extension session was replaced or reloaded."), { workflowStopCause: WORKFLOW_STOP_CAUSE_RUNTIME_REPLACED });
 }
@@ -7516,9 +7752,9 @@ function workflowChildFingerprint(params) {
   return sha256(workflowRunParamsFingerprint(params));
 }
 function appendWorkflowChildJournal(workflowAsyncDir, record) {
-  const journalPath = path12.join(workflowAsyncDir, WORKFLOW_CHILD_JOURNAL_FILE);
+  const journalPath = path14.join(workflowAsyncDir, WORKFLOW_CHILD_JOURNAL_FILE);
   try {
-    fs13.appendFileSync(journalPath, `${JSON.stringify(record)}
+    fs15.appendFileSync(journalPath, `${JSON.stringify(record)}
 `, "utf-8");
   } catch (error2) {
     console.error(`Failed to append workflow child journal '${journalPath}':`, error2);
@@ -7528,7 +7764,7 @@ function readWorkflowChildJournal(runId, workflowAsyncDir) {
   const source = { runId, started: /* @__PURE__ */ new Map(), settled: /* @__PURE__ */ new Map() };
   let text2 = "";
   try {
-    text2 = fs13.readFileSync(path12.join(workflowAsyncDir, WORKFLOW_CHILD_JOURNAL_FILE), "utf-8");
+    text2 = fs15.readFileSync(path14.join(workflowAsyncDir, WORKFLOW_CHILD_JOURNAL_FILE), "utf-8");
   } catch {
     return source;
   }
@@ -7548,6 +7784,44 @@ function readWorkflowChildJournal(runId, workflowAsyncDir) {
   }
   return source;
 }
+var WORKFLOW_REUSE_CHAIN_MAX_LINKS = 16;
+function readWorkflowReuseChain(asyncDirRoot, headRunId, headStatus) {
+  const source = readWorkflowChildJournal(headRunId, path14.join(asyncDirRoot, headRunId));
+  const visited = /* @__PURE__ */ new Set([headRunId]);
+  let next = headStatus.workflow?.reusedFrom;
+  for (let links = 0; isRunId(next) && links < WORKFLOW_REUSE_CHAIN_MAX_LINKS && !visited.has(next); links++) {
+    visited.add(next);
+    const asyncDir = path14.join(asyncDirRoot, next);
+    let status;
+    try {
+      status = readStatus(asyncDir);
+    } catch {
+      break;
+    }
+    if (status?.mode !== "workflow" || status.workflow?.scriptDigest !== headStatus.workflow?.scriptDigest) break;
+    const link = readWorkflowChildJournal(next, asyncDir);
+    for (const key of /* @__PURE__ */ new Set([...link.started.keys(), ...link.settled.keys()])) {
+      if (source.started.has(key) || source.settled.has(key)) continue;
+      const started = link.started.get(key);
+      const settled = link.settled.get(key);
+      if (started) source.started.set(key, started);
+      if (settled) source.settled.set(key, settled);
+    }
+    next = status.workflow?.reusedFrom;
+  }
+  return source;
+}
+function claimedWorkflowRunRefusal(runId, claim, named) {
+  const run = `${named ? "options.reuseFrom: workflow" : "Workflow"} run '${runId}'`;
+  if (claim.kind === "resumed") return `${run} was resumed as ${claim.newRunId}; wait on it or stop it.`;
+  if (claim.kind === "busy") return `${run} is being resumed by pid ${claim.pid}; wait for it.`;
+  return `${run} has a resume claim that cannot be read; wait or remove it.`;
+}
+function assertWorkflowRunNotClaimed(asyncDir, runId, named, claimOwnerRunId) {
+  const claim = workflowResumeClaimState(asyncDir);
+  if (claim.kind === "none" || claim.kind !== "unreadable" && claim.newRunId === claimOwnerRunId) return;
+  throw new Error(claimedWorkflowRunRefusal(runId, claim, named));
+}
 function findWorkflowReuseSource(asyncDirRoot, sessionId, scriptDigest, argsDigest) {
   let runIds;
   try {
@@ -7556,7 +7830,7 @@ function findWorkflowReuseSource(asyncDirRoot, sessionId, scriptDigest, argsDige
     return void 0;
   }
   for (const runId of runIds) {
-    const asyncDir = path12.join(asyncDirRoot, runId);
+    const asyncDir = path14.join(asyncDirRoot, runId);
     let status;
     try {
       status = readStatus(asyncDir);
@@ -7564,18 +7838,23 @@ function findWorkflowReuseSource(asyncDirRoot, sessionId, scriptDigest, argsDige
       continue;
     }
     if (status?.mode !== "workflow" || status.workflow?.scriptDigest !== scriptDigest || status.workflow.argsDigest !== argsDigest) continue;
-    return status.workflow.stopCause === WORKFLOW_STOP_CAUSE_RUNTIME_REPLACED ? readWorkflowChildJournal(runId, asyncDir) : void 0;
+    if (!isReusableWorkflowStopCause(status.workflow.stopCause)) return void 0;
+    assertWorkflowRunNotClaimed(asyncDir, runId, false);
+    return readWorkflowReuseChain(asyncDirRoot, runId, status);
   }
   return void 0;
 }
-function readNamedWorkflowReuseSource(asyncDirRoot, runId, scriptDigest, cwd) {
-  const status = runId === path12.basename(runId) && runId !== "." && runId !== ".." ? readStatus(path12.join(asyncDirRoot, runId)) : null;
+function readNamedWorkflowReuseSource(asyncDirRoot, runId, scriptDigest, cwd, claimOwnerRunId) {
+  const runName = isRunId(runId);
+  if (runName) reconcileAsyncRun(path14.join(asyncDirRoot, runId));
+  const status = runName ? readStatus(path14.join(asyncDirRoot, runId)) : null;
   if (!status) throw new Error(`options.reuseFrom: workflow run '${runId}' was not found.`);
   if (status.mode !== "workflow") throw new Error(`options.reuseFrom: run '${runId}' is not a workflow run.`);
-  if (status.workflow?.stopCause !== WORKFLOW_STOP_CAUSE_RUNTIME_REPLACED) throw new Error(`options.reuseFrom: workflow run '${runId}' did not stop because its session was replaced, so its children cannot be reused.`);
+  if (!isReusableWorkflowStopCause(status.workflow?.stopCause)) throw new Error(`options.reuseFrom: workflow run '${runId}' did not stop because its session was replaced or its Pi process exited, so its children cannot be reused.`);
   if (status.workflow.scriptDigest !== scriptDigest) throw new Error(`options.reuseFrom: workflow run '${runId}' ran a different workflow script.`);
   if (status.cwd !== cwd) throw new Error(`options.reuseFrom: workflow run '${runId}' ran in '${status.cwd}', not '${cwd}'.`);
-  return readWorkflowChildJournal(runId, path12.join(asyncDirRoot, runId));
+  assertWorkflowRunNotClaimed(path14.join(asyncDirRoot, runId), runId, true, claimOwnerRunId);
+  return readWorkflowReuseChain(asyncDirRoot, runId, status);
 }
 function matchWorkflowReuse(source, key, fingerprint) {
   const settled = source.settled.get(key);
@@ -7584,6 +7863,74 @@ function matchWorkflowReuse(source, key, fingerprint) {
   return started?.fingerprint === fingerprint ? { kind: "started", runId: started.runId } : void 0;
 }
 
+// src/workflows/workflow-resume.ts
+import { randomUUID as randomUUID6 } from "node:crypto";
+import * as path15 from "node:path";
+var MAX_WORKFLOW_RESUME_ATTEMPTS = 3;
+function workflowResumeRefusal(code, reason, runId) {
+  const byHand = code === "launch-missing" || code === "launch-invalid" || code === "structured" || code === "digest" || code === "authority" ? relaunchByHandText(runId) : code === "capacity" || code === "attempts" || code === "launch-failed" ? resumeByHandText(runId) : "";
+  return { code, reason, byHand };
+}
+function manualWorkflowResumeRefusalText(runId, refusal) {
+  return `Cannot resume workflow '${runId}': ${refusalSentence(refusal.reason, refusal.byHand === relaunchByHandText(runId) ? refusal.byHand : "")}`;
+}
+function workflowResumeTargetId(asyncDirRoot, params) {
+  if (params.message !== void 0 || params.task !== void 0 || params.index !== void 0) return void 0;
+  if (Array.isArray(params.chain) && params.chain.length > 0) return void 0;
+  const id = params.id ?? params.runId;
+  if (!isRunId(id)) return void 0;
+  let status;
+  try {
+    status = readStatus(path15.join(asyncDirRoot, id));
+  } catch {
+    return void 0;
+  }
+  return status?.mode === "workflow" && status.parentWorkflowRunId === void 0 ? id : void 0;
+}
+function prepareWorkflowResume(input) {
+  const { asyncDirRoot, sourceRunId, trigger } = input;
+  const refuse = (code, reason) => ({ ok: false, ...workflowResumeRefusal(code, reason, sourceRunId) });
+  const sourceAsyncDir = path15.join(asyncDirRoot, sourceRunId);
+  const stored = readStatus(sourceAsyncDir);
+  if (stored && !ownsRun(input.currentSessionId, stored.sessionId)) return refuse("not-owned", "it was started in another session; reopen that session to resume it");
+  if (trigger === "manual") reconcileAsyncRun(sourceAsyncDir);
+  const status = readStatus(sourceAsyncDir);
+  if (!status || status.mode !== "workflow" || !isReusableWorkflowStopCause(status.workflow?.stopCause)) return refuse("not-interrupted", "not interrupted; pass message to revive one of its children");
+  const attempt = (status.workflow?.resumeOrigin?.attempt ?? 0) + (status.workflow?.stopCause === WORKFLOW_STOP_CAUSE_OWNER_EXITED ? 1 : 0);
+  if (trigger === "auto" && attempt > MAX_WORKFLOW_RESUME_ATTEMPTS) return refuse("attempts", `${MAX_WORKFLOW_RESUME_ATTEMPTS} resumes already followed Pi exits`);
+  const read = readWorkflowLaunchRecord(sourceAsyncDir);
+  if (!read.ok) return read.missing ? refuse("launch-missing", "launch.json is missing (the run started before launches were saved)") : refuse("launch-invalid", `launch.json is invalid: ${read.error}`);
+  const record = read.record;
+  if (record.source === "structured") return refuse("structured", "launched from tasks/chain");
+  if (record.source === "script" && (typeof record.params.workflowScript !== "string" || workflowScriptDigest(record.params.workflowScript) !== record.scriptDigest)) {
+    return refuse("launch-invalid", "launch.json is invalid: its script does not match its scriptDigest");
+  }
+  const normalized = normalizePublicSubagentExecution(record.params);
+  if (!normalized.ok) return refuse("launch-invalid", `launch.json is invalid: ${normalized.error}`);
+  const newRunId = input.newRunId ?? randomUUID6();
+  const claim = claimWorkflowResume(sourceAsyncDir, { newRunId, trigger, now: input.now });
+  if (claim.kind === "resumed") return refuse("claim-resumed", `resumed as ${claim.newRunId}; wait on it or stop it`);
+  if (claim.kind === "busy") return refuse("claim-busy", `being resumed by pid ${claim.pid}`);
+  if (claim.kind === "unreadable") return refuse("claim-busy", "its resume claim cannot be read; wait or remove it");
+  return {
+    ok: true,
+    prepared: {
+      sourceRunId,
+      sourceAsyncDir,
+      newRunId,
+      trigger,
+      params: {
+        ...record.params,
+        async: true,
+        reuseFrom: sourceRunId,
+        ...status.admissionCapabilityCeiling ? { capabilityCeiling: status.admissionCapabilityCeiling } : {}
+      },
+      expectedScriptDigest: record.scriptDigest,
+      resumeOrigin: { sourceRunId, attempt }
+    }
+  };
+}
+
 // src/extension/subagent-options.ts
 import { isDeepStrictEqual } from "node:util";
 import { Compile } from "typebox/compile";
@@ -7622,140 +7969,8 @@ function flattenSubagentToolOptions(params, disabled) {
   return { ...topLevel, ...options };
 }
 
-// src/runs/foreground/foreground-history.ts
-import * as fs14 from "node:fs";
-import * as path13 from "node:path";
-var MAX_REMEMBERED_FOREGROUND_RUNS = 50;
-var HISTORY_VERSION = 1;
-var MAX_INLINE_OUTPUT_BYTES = 64 * 1024;
-var MAX_RESUME_CONTRACT_BYTES = 64 * 1024;
-function historyPath(resultsDir) {
-  return path13.join(resultsDir, "foreground-history.json");
-}
-function boundedTail(value) {
-  return utf8Tail(value, MAX_INLINE_OUTPUT_BYTES).text;
-}
-function compactChild(child) {
-  const outputPath = child.artifactPaths?.outputPath ?? child.savedOutputPath;
-  return {
-    agent: child.agent,
-    index: child.index,
-    ...child.sessionName ? { sessionName: child.sessionName } : {},
-    ...child.context ? { context: child.context } : {},
-    ...child.sessionFile ? { sessionFile: child.sessionFile } : {},
-    ...child.model ? { model: child.model } : {},
-    ...child.thinking ? { thinking: child.thinking } : {},
-    status: child.status,
-    ...child.activityState ? { activityState: child.activityState } : {},
-    ...child.lastActivityAt !== void 0 ? { lastActivityAt: child.lastActivityAt } : {},
-    ...child.currentTool ? { currentTool: child.currentTool } : {},
-    ...child.currentToolStartedAt !== void 0 ? { currentToolStartedAt: child.currentToolStartedAt } : {},
-    ...child.currentPath ? { currentPath: child.currentPath } : {},
-    ...child.turnCount !== void 0 ? { turnCount: child.turnCount } : {},
-    ...child.tokens !== void 0 ? { tokens: child.tokens } : {},
-    ...child.toolCount !== void 0 ? { toolCount: child.toolCount } : {},
-    ...child.exitCode !== void 0 ? { exitCode: child.exitCode } : {},
-    ...child.error ? { error: child.error } : {},
-    ...!outputPath && child.finalOutput ? { finalOutput: boundedTail(child.finalOutput) } : {},
-    ...child.outputState ? { outputState: child.outputState } : {},
-    ...child.outputPartial ? { outputPartial: true } : {},
-    ...child.outputMode ? { outputMode: child.outputMode } : {},
-    ...child.savedOutputPath ? { savedOutputPath: child.savedOutputPath } : {},
-    ...child.outputSaveError ? { outputSaveError: child.outputSaveError } : {},
-    ...child.artifactPaths ? { artifactPaths: child.artifactPaths } : {},
-    ...child.transcriptPath ? { transcriptPath: child.transcriptPath } : {},
-    ...child.transcriptError ? { transcriptError: child.transcriptError } : {},
-    ...child.acceptance ? { acceptance: child.acceptance } : {},
-    ...child.resumeContract ? { resumeContract: child.resumeContract } : {},
-    ...child.launchContractDigest ? { launchContractDigest: child.launchContractDigest } : {},
-    ...child.extensionBindings ? { extensionBindings: child.extensionBindings } : {},
-    ...child.requiredExtensions ? { requiredExtensions: child.requiredExtensions } : {},
-    ...child.capabilityCeiling ? { capabilityCeiling: child.capabilityCeiling } : {},
-    ...child.updatedAt !== void 0 ? { updatedAt: child.updatedAt } : {}
-  };
-}
-function isRestorableForegroundStatus(status) {
-  return status === "completed" || status === "failed" || status === "paused" || status === "stopped";
-}
-function isRestorableResumeContract(value) {
-  if (value === void 0) return true;
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  try {
-    if (Buffer.byteLength(JSON.stringify(value), "utf8") > MAX_RESUME_CONTRACT_BYTES) return false;
-    validateModelResponseAliases(value?.modelResponseAliases);
-  } catch {
-    return false;
-  }
-  const contract = value;
-  if (Object.keys(contract).some((key) => !["modelResponseAliases", "outputSchema", "agentContract", "acceptance", "output", "outputMode"].includes(key))) return false;
-  if (contract.outputSchema !== void 0 && contract.outputSchema !== false && (!contract.outputSchema || typeof contract.outputSchema !== "object" || Array.isArray(contract.outputSchema))) return false;
-  if (contract.agentContract !== void 0 && (!contract.agentContract || typeof contract.agentContract !== "object" || Array.isArray(contract.agentContract) || contract.agentContract.version !== 1)) return false;
-  if (validateAcceptanceInput(contract.acceptance).length > 0) return false;
-  if (contract.output !== void 0 && typeof contract.output !== "string" && typeof contract.output !== "boolean") return false;
-  return contract.outputMode === void 0 || contract.outputMode === "inline" || contract.outputMode === "file-only";
-}
-function compactRun(run) {
-  if (!run.sessionId) return void 0;
-  if (run.children.length === 0 || !run.children.every((child) => isRestorableForegroundStatus(child.status) && isRestorableResumeContract(child.resumeContract))) return void 0;
-  return {
-    runId: run.runId,
-    mode: run.mode,
-    cwd: run.cwd,
-    sessionId: run.sessionId,
-    updatedAt: run.updatedAt,
-    children: run.children.map(compactChild)
-  };
-}
-function readIndex(resultsDir) {
-  const filePath = historyPath(resultsDir);
-  if (!fs14.existsSync(filePath)) return { version: HISTORY_VERSION, runs: [] };
-  try {
-    const parsed = JSON.parse(fs14.readFileSync(filePath, "utf-8"));
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return { version: HISTORY_VERSION, runs: [] };
-    const record = parsed;
-    if (record.version !== HISTORY_VERSION || !Array.isArray(record.runs)) return { version: HISTORY_VERSION, runs: [] };
-    return { version: HISTORY_VERSION, runs: record.runs.filter(isRestorableRun) };
-  } catch {
-    return { version: HISTORY_VERSION, runs: [] };
-  }
-}
-function isRestorableRun(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const run = value;
-  return typeof run.runId === "string" && Boolean(run.runId) && (run.mode === "single" || run.mode === "parallel" || run.mode === "chain") && typeof run.cwd === "string" && Boolean(run.cwd) && typeof run.sessionId === "string" && Boolean(run.sessionId) && typeof run.updatedAt === "number" && Number.isFinite(run.updatedAt) && Array.isArray(run.children) && run.children.length > 0 && run.children.every((child) => Boolean(child && typeof child === "object" && !Array.isArray(child) && typeof child.agent === "string" && typeof child.index === "number" && isRestorableResumeContract(child.resumeContract) && isRestorableForegroundStatus(child.status)));
-}
-function sortAndBound(runs, limit) {
-  return [...runs].sort((left, right) => right.updatedAt - left.updatedAt).slice(0, limit);
-}
-function persistForegroundRunHistory(state, options = {}) {
-  const resultsDir = options.resultsDir ?? DIRS.results;
-  const limit = options.limit ?? MAX_REMEMBERED_FOREGROUND_RUNS;
-  const existing = readIndex(resultsDir);
-  const merged = new Map(existing.runs.map((run) => [run.runId, run]));
-  for (const run of state.foregroundRuns?.values() ?? []) {
-    const compact = compactRun(run);
-    if (compact) merged.set(compact.runId, compact);
-  }
-  const runs = sortAndBound([...merged.values()], limit);
-  writePrivateAtomicJson(historyPath(resultsDir), { version: HISTORY_VERSION, runs });
-}
-function restoreForegroundRunHistory(state, options = {}) {
-  const sessionId = options.sessionId ?? state.currentSessionId;
-  if (!sessionId) return 0;
-  const index = readIndex(options.resultsDir ?? DIRS.results);
-  const runs = sortAndBound(index.runs.filter((run) => run.sessionId === sessionId), options.limit ?? MAX_REMEMBERED_FOREGROUND_RUNS);
-  state.foregroundRuns ??= /* @__PURE__ */ new Map();
-  let restored = 0;
-  for (const run of runs) {
-    if (state.foregroundRuns.has(run.runId)) continue;
-    state.foregroundRuns.set(run.runId, run);
-    restored += 1;
-  }
-  return restored;
-}
-
 // src/runs/background/retained-children.ts
-import * as fs15 from "node:fs";
+import * as fs16 from "node:fs";
 var MAX_RETAINED_CHILDREN = 10;
 var MAX_RETAINED_CHILD_CANDIDATES = 100;
 var MAX_TASK_SUMMARY_LENGTH = 120;
@@ -7769,7 +7984,7 @@ function retainedSessionFile(sessionFile) {
   if (!sessionFile) return { state: "not-resumable", reason: "no persisted session file" };
   if (!sessionFile.endsWith(".jsonl")) return { state: "not-resumable", reason: "persisted session file is not a .jsonl file" };
   try {
-    const stat = fs15.lstatSync(sessionFile);
+    const stat = fs16.lstatSync(sessionFile);
     if (!stat.isFile() || stat.isSymbolicLink()) return { state: "not-resumable", reason: "persisted session file is not a regular file" };
     return { state: "resumable", sessionPath: sessionFile };
   } catch (error2) {
@@ -7796,7 +8011,7 @@ function childResumability(run, step) {
   let requiredCwd;
   try {
     requiredCwd = resolveRetainedWorktreeCwd(parallelHandoffPath(run.asyncDir), run.id, step.index) ?? recoveryDescriptor.cwd ?? run.cwd;
-    if (!requiredCwd || !fs15.statSync(requiredCwd).isDirectory()) return { state: "not-resumable", reason: `required cwd is missing: ${requiredCwd ?? "unknown"}` };
+    if (!requiredCwd || !fs16.statSync(requiredCwd).isDirectory()) return { state: "not-resumable", reason: `required cwd is missing: ${requiredCwd ?? "unknown"}` };
   } catch (error2) {
     return { state: "not-resumable", reason: `resume dependency unavailable: ${error2 instanceof Error ? error2.message : String(error2)}` };
   }
@@ -7857,52 +8072,52 @@ function formatRetainedChildren(children) {
 }
 
 // src/runs/shared/external-job-bridge.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
-import * as fs16 from "node:fs";
+import { randomUUID as randomUUID7 } from "node:crypto";
+import * as fs17 from "node:fs";
 import * as os2 from "node:os";
-import * as path14 from "node:path";
+import * as path16 from "node:path";
 var EXTERNAL_JOB_BRIDGE_REQUEST_DIR = "external-job-requests";
 var EXTERNAL_JOB_BRIDGE_RESPONSE_DIR = "external-job-responses";
 var CHILD_BRIDGE_SWEEP_INTERVAL_MS = 1e3;
 var MAX_REQUESTS_PER_SWEEP = 100;
 var inFlight = /* @__PURE__ */ new Set();
 function requestDir(asyncDir) {
-  return path14.join(asyncDir, EXTERNAL_JOB_BRIDGE_REQUEST_DIR);
+  return path16.join(asyncDir, EXTERNAL_JOB_BRIDGE_REQUEST_DIR);
 }
 function responseDir(asyncDir) {
-  return path14.join(asyncDir, EXTERNAL_JOB_BRIDGE_RESPONSE_DIR);
+  return path16.join(asyncDir, EXTERNAL_JOB_BRIDGE_RESPONSE_DIR);
 }
 function requestPath(asyncDir, id) {
-  return path14.join(requestDir(asyncDir), `${id}.json`);
+  return path16.join(requestDir(asyncDir), `${id}.json`);
 }
 function isDispatchOperation(operation) {
   return operation === "start" || operation === "follow-up";
 }
 function dispatchClaimDir(asyncDir, id) {
-  return path14.join(requestDir(asyncDir), `${id}.claim`);
+  return path16.join(requestDir(asyncDir), `${id}.claim`);
 }
 function dispatchClaimTempDir(asyncDir, id) {
-  return path14.join(requestDir(asyncDir), `${id}.claim.tmp-${randomUUID5()}`);
+  return path16.join(requestDir(asyncDir), `${id}.claim.tmp-${randomUUID7()}`);
 }
 function dispatchClaimCompletedPath(claimDir) {
-  return path14.join(claimDir, "completed.json");
+  return path16.join(claimDir, "completed.json");
 }
 function dispatchClaimHandlePath(claimDir) {
-  return path14.join(claimDir, "handle.json");
+  return path16.join(claimDir, "handle.json");
 }
 function completedDispatchClaimExists(asyncDir, id) {
-  return fs16.existsSync(dispatchClaimCompletedPath(dispatchClaimDir(asyncDir, id)));
+  return fs17.existsSync(dispatchClaimCompletedPath(dispatchClaimDir(asyncDir, id)));
 }
 function responsePath(asyncDir, id) {
-  return path14.join(responseDir(asyncDir), `${id}.json`);
+  return path16.join(responseDir(asyncDir), `${id}.json`);
 }
 function readJson2(filePath) {
-  return JSON.parse(fs16.readFileSync(filePath, "utf-8"));
+  return JSON.parse(fs17.readFileSync(filePath, "utf-8"));
 }
 function processStartIdentity(pid) {
   if (process.platform === "linux") {
     try {
-      const stat = fs16.readFileSync(`/proc/${pid}/stat`, "utf-8");
+      const stat = fs17.readFileSync(`/proc/${pid}/stat`, "utf-8");
       const commandEnd = stat.lastIndexOf(")");
       if (commandEnd === -1) return void 0;
       const fields = stat.slice(commandEnd + 1).trim().split(/\s+/);
@@ -8022,16 +8237,16 @@ function claimDispatchRequest(asyncDir, filePath, request) {
   const claimDir = dispatchClaimDir(asyncDir, request.id);
   const tempClaimDir = dispatchClaimTempDir(asyncDir, request.id);
   try {
-    fs16.mkdirSync(tempClaimDir);
-    writeAtomicJson(path14.join(tempClaimDir, "owner.json"), owner);
-    writeAtomicJson(path14.join(tempClaimDir, "request.json"), claimed);
-    fs16.renameSync(tempClaimDir, claimDir);
+    fs17.mkdirSync(tempClaimDir);
+    writeAtomicJson(path16.join(tempClaimDir, "owner.json"), owner);
+    writeAtomicJson(path16.join(tempClaimDir, "request.json"), claimed);
+    fs17.renameSync(tempClaimDir, claimDir);
   } catch (error2) {
-    fs16.rmSync(tempClaimDir, { recursive: true, force: true });
+    fs17.rmSync(tempClaimDir, { recursive: true, force: true });
     if (isClaimConflictError(error2)) return void 0;
     throw error2;
   }
-  fs16.rmSync(filePath, { force: true });
+  fs17.rmSync(filePath, { force: true });
   return { request: claimed, filePath: claimDir };
 }
 function parseClaimOwner(value) {
@@ -8051,7 +8266,7 @@ function claimOwnerIsDead(owner) {
 }
 function readClaimOwner(claimDir) {
   try {
-    return parseClaimOwner(readJson2(path14.join(claimDir, "owner.json")));
+    return parseClaimOwner(readJson2(path16.join(claimDir, "owner.json")));
   } catch {
     return void 0;
   }
@@ -8113,23 +8328,23 @@ function createChildExternalJobBridgeSweeper() {
 function serviceExternalJobBridgeRequests(asyncDir) {
   let files;
   try {
-    files = fs16.readdirSync(requestDir(asyncDir), { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json") && !completedDispatchClaimExists(asyncDir, entry.name.replace(/\.json$/, "")) || entry.isDirectory() && entry.name.endsWith(".claim") && !fs16.existsSync(dispatchClaimCompletedPath(path14.join(requestDir(asyncDir), entry.name)))).map((entry) => entry.name).slice(0, MAX_REQUESTS_PER_SWEEP);
+    files = fs17.readdirSync(requestDir(asyncDir), { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json") && !completedDispatchClaimExists(asyncDir, entry.name.replace(/\.json$/, "")) || entry.isDirectory() && entry.name.endsWith(".claim") && !fs17.existsSync(dispatchClaimCompletedPath(path16.join(requestDir(asyncDir), entry.name)))).map((entry) => entry.name).slice(0, MAX_REQUESTS_PER_SWEEP);
   } catch (error2) {
     if (error2.code === "ENOENT") return;
     throw error2;
   }
-  fs16.mkdirSync(responseDir(asyncDir), { recursive: true });
+  fs17.mkdirSync(responseDir(asyncDir), { recursive: true });
   for (const file of files) {
     serviceExternalJobBridgeRequestFile(asyncDir, file);
   }
 }
 function serviceExternalJobBridgeRequestFile(asyncDir, file) {
-  fs16.mkdirSync(responseDir(asyncDir), { recursive: true });
+  fs17.mkdirSync(responseDir(asyncDir), { recursive: true });
   if (file.endsWith(".claim")) {
     serviceExternalJobDispatchClaim(asyncDir, file);
     return;
   }
-  const filePath = path14.join(requestDir(asyncDir), file);
+  const filePath = path16.join(requestDir(asyncDir), file);
   let request;
   try {
     request = assertRequest(readJson2(filePath), filePath);
@@ -8145,14 +8360,14 @@ function serviceExternalJobBridgeRequestFile(asyncDir, file) {
       message: error2 instanceof Error ? error2.message : String(error2),
       completedAt: Date.now()
     });
-    fs16.rmSync(filePath, { force: true });
+    fs17.rmSync(filePath, { force: true });
     return;
   }
   if (isDispatchOperation(request.operation) && completedDispatchClaimExists(asyncDir, request.id)) {
-    fs16.rmSync(filePath, { force: true });
+    fs17.rmSync(filePath, { force: true });
     return;
   }
-  if (inFlight.has(request.id) || fs16.existsSync(responsePath(asyncDir, request.id))) return;
+  if (inFlight.has(request.id) || fs17.existsSync(responsePath(asyncDir, request.id))) return;
   if (isDispatchOperation(request.operation) && request.claimedAt !== void 0) return;
   const claimed = isDispatchOperation(request.operation) ? claimDispatchRequest(asyncDir, filePath, request) : { request, filePath };
   if (!claimed) return;
@@ -8163,7 +8378,7 @@ function serviceExternalJobBridgeRequestFile(asyncDir, file) {
     if (isDispatchOperation(claimedRequest.operation)) {
       writeAtomicJson(dispatchClaimCompletedPath(claimed.filePath), { completedAt: Date.now() });
     } else {
-      fs16.rmSync(claimed.filePath, { recursive: true, force: true });
+      fs17.rmSync(claimed.filePath, { recursive: true, force: true });
     }
   }).catch((error2) => {
     writeAtomicJson(responsePath(asyncDir, claimedRequest.id), {
@@ -8181,21 +8396,21 @@ function serviceExternalJobBridgeRequestFile(asyncDir, file) {
   });
 }
 function serviceExternalJobDispatchClaim(asyncDir, file) {
-  const claimDir = path14.join(requestDir(asyncDir), file);
-  if (fs16.existsSync(dispatchClaimCompletedPath(claimDir))) return;
+  const claimDir = path16.join(requestDir(asyncDir), file);
+  if (fs17.existsSync(dispatchClaimCompletedPath(claimDir))) return;
   const owner = readClaimOwner(claimDir);
-  if (!owner && fs16.existsSync(requestPath(asyncDir, file.replace(/\.claim$/, ""))) && !fs16.existsSync(responsePath(asyncDir, file.replace(/\.claim$/, "")))) {
-    fs16.rmSync(claimDir, { recursive: true, force: true });
+  if (!owner && fs17.existsSync(requestPath(asyncDir, file.replace(/\.claim$/, ""))) && !fs17.existsSync(responsePath(asyncDir, file.replace(/\.claim$/, "")))) {
+    fs17.rmSync(claimDir, { recursive: true, force: true });
     return;
   }
   if (!claimOwnerIsDead(owner)) return;
   let request;
   try {
-    request = assertRequest(readJson2(path14.join(claimDir, "request.json")), path14.join(claimDir, "request.json"));
+    request = assertRequest(readJson2(path16.join(claimDir, "request.json")), path16.join(claimDir, "request.json"));
   } catch {
     return;
   }
-  if (!isDispatchOperation(request.operation) || fs16.existsSync(responsePath(asyncDir, request.id))) return;
+  if (!isDispatchOperation(request.operation) || fs17.existsSync(responsePath(asyncDir, request.id))) return;
   const handle = readClaimHandle(request.provider, claimDir);
   if (handle) {
     writeAtomicJson(responsePath(asyncDir, request.id), {
@@ -8207,7 +8422,7 @@ function serviceExternalJobDispatchClaim(asyncDir, file) {
       completedAt: Date.now()
     });
     writeAtomicJson(dispatchClaimCompletedPath(claimDir), { completedAt: Date.now() });
-    fs16.rmSync(requestPath(asyncDir, request.id), { force: true });
+    fs17.rmSync(requestPath(asyncDir, request.id), { force: true });
     return;
   }
   writeAtomicJson(responsePath(asyncDir, request.id), {
@@ -8219,8 +8434,8 @@ function serviceExternalJobDispatchClaim(asyncDir, file) {
     message: `External-job ${request.operation} for provider '${request.provider}' was claimed by a host process that is no longer alive before a provider job id was committed. Refusing to redispatch the prompt automatically.`,
     completedAt: Date.now()
   });
-  fs16.rmSync(claimDir, { recursive: true, force: true });
-  fs16.rmSync(requestPath(asyncDir, request.id), { force: true });
+  fs17.rmSync(claimDir, { recursive: true, force: true });
+  fs17.rmSync(requestPath(asyncDir, request.id), { force: true });
 }
 
 // src/shared/provider-diagnostics.ts
@@ -8349,6 +8564,14 @@ export {
   COMPLETION_ACTION,
   STATUS_ACTION,
   createParentWake,
+  writeWorkflowLaunchRecord,
+  resumedRunStarted,
+  workflowResumeClaimState,
+  claimWorkflowResume,
+  releaseWorkflowResumeClaim,
+  recordWorkflowResumeRefusal,
+  refusalSentence,
+  hasWorkflowResumeRefusal,
   incrementalChildCompletionTriggersTurn,
   formatIncrementalChildCompletion,
   parseSubagentNotifyContent,
@@ -8370,19 +8593,21 @@ export {
   childSessionFactory,
   childSessionFactoryModule,
   disposeChildSessions,
-  workflowRuntimeReplacedRelaunchNotice,
+  WORKFLOW_RUNTIME_REPLACED_STOP_NOTICE,
   runtimeReplacedAbortReason,
   workflowStopCause,
   workflowScriptDigest,
   workflowChildFingerprint,
   appendWorkflowChildJournal,
+  claimedWorkflowRunRefusal,
   findWorkflowReuseSource,
   readNamedWorkflowReuseSource,
   matchWorkflowReuse,
+  workflowResumeRefusal,
+  manualWorkflowResumeRefusalText,
+  workflowResumeTargetId,
+  prepareWorkflowResume,
   flattenSubagentToolOptions,
-  MAX_REMEMBERED_FOREGROUND_RUNS,
-  persistForegroundRunHistory,
-  restoreForegroundRunHistory,
   listRetainedChildren,
   formatRetainedChildren
 };