pi-subagents 0.81.0 → 0.82.1

package/bundle/{chunk-VJHOELQP.js → chunk-46XKCPJR.js}

@@ -1,6 +1,6 @@
 import {
   PROJECT_SUBAGENTS_RELATIVE_DIR
-} from "./chunk-3DC5KBVP.js";
+} from "./chunk-5TYMSZX3.js";
 import {
   DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS,
   DEFAULT_GLOBAL_CONCURRENCY_LIMIT,
@@ -22,7 +22,7 @@ import {
   withFileLease,
   writeAtomicJson,
   writePrivateAtomicJson
-} from "./chunk-ZBC44JJ3.js";
+} from "./chunk-CIZQXJ5Q.js";
 import {
   DIRS,
   SUBAGENT_LIFECYCLE_ARTIFACT_VERSION,
@@ -109,6 +109,28 @@ var TOOL_CALL_INDEX_DIR = "@tool-calls";
 function isTerminalState(state) {
   return state === "complete" || state === "failed" || state === "partial" || state === "paused" || state === "stopped" || state === "rejected";
 }
+function isCorruptStatusError(error, statusPath) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.startsWith(`Failed to parse async status file '${statusPath}'`) || message.startsWith(`Failed to validate async status file '${statusPath}'`);
+}
+var reportedCorruptTerminalStatus = /* @__PURE__ */ new Map();
+function warnCorruptTerminalStatus(runId, statusPath, error, onCorruptStatus) {
+  let fileSignature = "unavailable";
+  try {
+    const stat = fs.statSync(statusPath);
+    fileSignature = `${stat.size}:${stat.mtimeMs}:${stat.ctimeMs}:${stat.ino}`;
+  } catch (statError) {
+    if (statError.code !== "ENOENT") throw statError;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  const signature = `${fileSignature}
+${message}`;
+  if (reportedCorruptTerminalStatus.get(statusPath) === signature) return;
+  reportedCorruptTerminalStatus.set(statusPath, signature);
+  const warning = `Skipping indexed terminal run '${runId}' with corrupt status at '${statusPath}': ${message}`;
+  if (onCorruptStatus) onCorruptStatus(warning);
+  else console.error(`[pi-subagents] ${warning}`);
+}
 function indexRoot(asyncDirRoot) {
   return path2.join(asyncDirRoot, TERMINAL_RUN_INDEX_DIR);
 }
@@ -177,8 +199,8 @@ function sessionDirs(asyncDirRoot, sessionId) {
     throw error;
   }
 }
-function recentMarkerFiles(dirs, limit) {
-  return dirs.flatMap(markerFiles).sort((left, right) => right.name.localeCompare(left.name)).slice(0, limit).map((marker) => path2.join(marker.dir, marker.name));
+function recentMarkerFiles(dirs, limit, endedAfter) {
+  return dirs.flatMap(markerFiles).filter((marker) => endedAfter === void 0 || !(Number(marker.name.slice(0, TIMESTAMP_WIDTH)) < endedAfter)).sort((left, right) => right.name.localeCompare(left.name)).slice(0, limit).map((marker) => path2.join(marker.dir, marker.name));
 }
 function readTerminalRunToolCallIndex(asyncDirRoot, toolCallId) {
   const runIds = [];
@@ -206,7 +228,7 @@ function readTerminalRunToolCallIndex(asyncDirRoot, toolCallId) {
 }
 function readRecentTerminalRunIndex(asyncDirRoot, options = {}) {
   const limit = options.limit === void 0 ? Number.POSITIVE_INFINITY : Math.max(0, Math.floor(options.limit));
-  const candidates = recentMarkerFiles(sessionDirs(asyncDirRoot, options.sessionId), limit);
+  const candidates = recentMarkerFiles(sessionDirs(asyncDirRoot, options.sessionId), limit, options.endedAfter);
   const runIds = [];
   const seen = /* @__PURE__ */ new Set();
   for (const marker of candidates) {
@@ -221,7 +243,15 @@ function readRecentTerminalRunIndex(asyncDirRoot, options = {}) {
       continue;
     }
     const asyncDir = path2.join(asyncDirRoot, entry.runId);
-    const status = readStatus(asyncDir);
+    const statusPath = path2.join(asyncDir, "status.json");
+    let status;
+    try {
+      status = readStatus(asyncDir);
+    } catch (error) {
+      if (!isCorruptStatusError(error, statusPath)) throw error;
+      warnCorruptTerminalStatus(entry.runId, statusPath, error, options.onCorruptStatus);
+      continue;
+    }
     if (!status || !isTerminalState(status.state) || status.sessionId !== entry.sessionId || status.runId && status.runId !== entry.runId) {
       removeInvalidMarker(marker);
       continue;
@@ -742,11 +772,11 @@ function resolveInheritedNestedRoute(route) {
     return void 0;
   }
 }
-function inheritedNestedRouteOf(runtime) {
-  return runtime?.nestedRoute ? resolveInheritedNestedRoute(runtime.nestedRoute) : void 0;
+function inheritedNestedRouteOf(runtime2) {
+  return runtime2?.nestedRoute ? resolveInheritedNestedRoute(runtime2.nestedRoute) : void 0;
 }
-function inheritedNestedParentAddressOf(runtime) {
-  const parent = runtime?.nestedParent;
+function inheritedNestedParentAddressOf(runtime2) {
+  const parent = runtime2?.nestedParent;
   if (!parent || !isSafeNestedId(parent.parentRunId)) return void 0;
   const depth = Math.min(Math.max(1, clampNumber(parent.depth) ?? 1), MAX_DEPTH);
   return {
@@ -1936,7 +1966,7 @@ async function executeWorkflowHostCommand(input) {
 }
 
 // src/workflows/scripted-workflow.ts
-import { accessSync, constants as constants2, readFileSync as readFileSync6, realpathSync as realpathSync3, statSync as statSync3 } from "node:fs";
+import { accessSync, constants as constants2, readFileSync as readFileSync6, realpathSync as realpathSync3, statSync as statSync4 } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname as dirname6, resolve as resolvePath } from "node:path";
 import { Worker } from "node:worker_threads";
@@ -3703,7 +3733,7 @@ async function runWorkflowScript(options) {
       if (staleCwd) process.chdir(options.processCwd);
       else {
         const target = realpathSync3(options.processCwd);
-        if (!statSync3(target).isDirectory()) {
+        if (!statSync4(target).isDirectory()) {
           const error = new Error(`ENOTDIR: not a directory, access '${target}'`);
           error.code = "ENOTDIR";
           throw error;
@@ -5585,7 +5615,12 @@ function parsePersistedBinding(value, source) {
 function readMissionBinding(asyncDir) {
   const bindingPath = path12.join(asyncDir, MISSION_BINDING_FILE);
   if (!fs11.existsSync(bindingPath)) return void 0;
-  return parsePersistedBinding(JSON.parse(fs11.readFileSync(bindingPath, "utf-8")), bindingPath);
+  const raw = fs11.readFileSync(bindingPath, "utf-8");
+  try {
+    return parsePersistedBinding(JSON.parse(raw), bindingPath);
+  } catch (error) {
+    throw new Error(`Invalid mission binding file '${bindingPath}': ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
 }
 function syncMissionFromAsyncCompletion(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
@@ -6156,8 +6191,66 @@ function cleanupResultIndexes(resultsDir, now = Date.now(), maxAgeMs = 24 * 60 *
   return removed;
 }
 
+// src/shared/completion-owner.ts
+import { randomUUID as randomUUID6 } from "node:crypto";
+var COMPLETION_OWNER_KEY = /* @__PURE__ */ Symbol.for("pi-subagents.completion-owner-id");
+var OWNING_SESSION_COMPLETION_OWNER = "owning-session";
+function currentCompletionOwnerId() {
+  const runtime2 = globalThis;
+  runtime2[COMPLETION_OWNER_KEY] ??= randomUUID6();
+  return runtime2[COMPLETION_OWNER_KEY];
+}
+
+// src/runs/background/boot-id.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+import * as fs14 from "node:fs";
+
+// src/runs/background/pid-namespace.ts
+import * as fs13 from "node:fs";
+var resolved = false;
+var cachedScope;
+function currentPidNamespaceScope() {
+  if (resolved) return cachedScope;
+  resolved = true;
+  if (process.platform !== "linux") return void 0;
+  try {
+    const scope = fs13.readlinkSync("/proc/self/ns/pid", "utf-8").trim();
+    cachedScope = scope || void 0;
+  } catch {
+    cachedScope = void 0;
+  }
+  return cachedScope;
+}
+
+// src/runs/background/boot-id.ts
+function readBootIdFromOs() {
+  try {
+    if (process.platform === "linux") return fs14.readFileSync("/proc/sys/kernel/random/boot_id", "utf-8").trim() || void 0;
+    if (process.platform === "darwin") {
+      return execFileSync2("sysctl", ["-n", "kern.bootsessionuuid"], { encoding: "utf-8", timeout: 1e3, stdio: ["ignore", "pipe", "ignore"] }).trim() || void 0;
+    }
+  } catch {
+  }
+  return void 0;
+}
+var BOOT_ID_KEY = /* @__PURE__ */ Symbol.for("pi-subagents.boot-id.v1");
+var runtime = globalThis;
+var reader = readBootIdFromOs;
+function currentBootId() {
+  const cached = runtime[BOOT_ID_KEY];
+  if (cached) return cached.value;
+  const value = reader();
+  runtime[BOOT_ID_KEY] = { value };
+  return value;
+}
+function currentRecordedPid() {
+  const pidNamespaceScope = currentPidNamespaceScope();
+  const bootId = currentBootId();
+  return { pid: process.pid, ...pidNamespaceScope ? { pidNamespaceScope } : {}, ...bootId ? { bootId } : {} };
+}
+
 // src/runs/background/stale-run-reconciler.ts
-import * as fs15 from "node:fs";
+import * as fs16 from "node:fs";
 import * as path15 from "node:path";
 
 // src/runs/background/parallel-groups.ts
@@ -6191,25 +6284,15 @@ function flatToLogicalStepIndex(flatIndex, chainStepCount, groups) {
   return Math.max(0, chainStepCount - 1);
 }
 
-// src/runs/background/pid-namespace.ts
-import * as fs13 from "node:fs";
-var resolved = false;
-var cachedScope;
-function currentPidNamespaceScope() {
-  if (resolved) return cachedScope;
-  resolved = true;
-  if (process.platform !== "linux") return void 0;
-  try {
-    const scope = fs13.readlinkSync("/proc/self/ns/pid", "utf-8").trim();
-    cachedScope = scope || void 0;
-  } catch {
-    cachedScope = void 0;
-  }
-  return cachedScope;
+// src/workflows/workflow-stop-cause.ts
+var WORKFLOW_STOP_CAUSE_RUNTIME_REPLACED = "runtime-replaced";
+var WORKFLOW_STOP_CAUSE_OWNER_EXITED = "owner-exited";
+function isReusableWorkflowStopCause(cause) {
+  return cause === WORKFLOW_STOP_CAUSE_RUNTIME_REPLACED || cause === WORKFLOW_STOP_CAUSE_OWNER_EXITED;
 }
 
 // src/runs/background/workflow-terminal-proof.ts
-import * as fs14 from "node:fs";
+import * as fs15 from "node:fs";
 import * as path14 from "node:path";
 var TERMINAL_WORKFLOW_STATES = /* @__PURE__ */ new Set(["completed", "failed", "stopped"]);
 function isTerminalAsyncState(state) {
@@ -6247,7 +6330,7 @@ function readWorkflowChildProcessEvidence(workflowAsyncDir, steps) {
 }
 function launchFailedBeforeRunner(step, childDir) {
   if (step.status !== "failed" || !step.error) return false;
-  return !childDir || !["process-terminal.json", "runner-startup.json"].some((file) => fs14.existsSync(path14.join(childDir, file)));
+  return !childDir || !["process-terminal.json", "runner-startup.json"].some((file) => fs15.existsSync(path14.join(childDir, file)));
 }
 function readWorkflowChildEvidence(workflowAsyncDir, step) {
   const label = step.workflowKey ?? step.agent;
@@ -6255,7 +6338,7 @@ function readWorkflowChildEvidence(workflowAsyncDir, step) {
   if (!step.async) return void 0;
   if (!step.runId || path14.basename(step.runId) !== step.runId) return { state: "unknown", reason: `async workflow child ${label} is missing run id` };
   const childDir = path14.join(path14.dirname(workflowAsyncDir), step.runId);
-  if (!fs14.existsSync(childDir)) return launchFailedBeforeRunner(step) ? void 0 : { state: "unknown", reason: `async workflow child ${label} directory is missing` };
+  if (!fs15.existsSync(childDir)) return launchFailedBeforeRunner(step) ? void 0 : { state: "unknown", reason: `async workflow child ${label} directory is missing` };
   const childStatus = readStatus(childDir);
   if (!childStatus) return launchFailedBeforeRunner(step, childDir) ? void 0 : { state: "unknown", reason: `async workflow child ${label} status is missing or unreadable` };
   if (!isTerminalAsyncState(childStatus.state)) return { state: "pending", reason: `async workflow child ${label} is still ${childStatus.state}` };
@@ -6302,17 +6385,17 @@ function readRunnerStartupDiagnostics(asyncDir) {
   const maxBytes = 64 * 1024;
   let content;
   try {
-    const stat = fs15.statSync(stderrPath);
+    const stat = fs16.statSync(stderrPath);
     if (stat.size <= 0) return void 0;
-    const fd = fs15.openSync(stderrPath, "r");
+    const fd = fs16.openSync(stderrPath, "r");
     try {
       const bytesToRead = Math.min(stat.size, maxBytes);
       const start = Math.max(0, stat.size - bytesToRead);
       const buffer = Buffer.alloc(bytesToRead);
-      fs15.readSync(fd, buffer, 0, bytesToRead, start);
+      fs16.readSync(fd, buffer, 0, bytesToRead, start);
       content = buffer.toString("utf-8").trim();
     } finally {
-      fs15.closeSync(fd);
+      fs16.closeSync(fd);
     }
   } catch {
     return void 0;
@@ -6327,15 +6410,15 @@ function isNotFoundError(error) {
 }
 function appendJsonlBestEffort(filePath, payload) {
   try {
-    fs15.mkdirSync(path15.dirname(filePath), { recursive: true });
-    fs15.appendFileSync(filePath, `${JSON.stringify(payload)}
+    fs16.mkdirSync(path15.dirname(filePath), { recursive: true });
+    fs16.appendFileSync(filePath, `${JSON.stringify(payload)}
 `, "utf-8");
   } catch {
   }
 }
 function regularFileExists(filePath) {
   try {
-    return fs15.statSync(filePath).isFile();
+    return fs16.statSync(filePath).isFile();
   } catch (error) {
     if (isNotFoundError(error)) return false;
     throw error;
@@ -6343,7 +6426,7 @@ function regularFileExists(filePath) {
 }
 function readResultRepairData(resultPath) {
   try {
-    const data = JSON.parse(fs15.readFileSync(resultPath, "utf-8"));
+    const data = JSON.parse(fs16.readFileSync(resultPath, "utf-8"));
     if (data.error !== void 0 && typeof data.error !== "string") throw new Error(`Invalid async result file '${resultPath}': error must be a string.`);
     const state = data.success ? "complete" : data.state === "stopped" ? "stopped" : data.state === "rejected" ? "rejected" : data.state === "partial" ? "partial" : data.state === "paused" || data.exitCode === 0 ? "paused" : "failed";
     const results = Array.isArray(data.results) ? data.results.map((entry, index) => {
@@ -6460,13 +6543,15 @@ function settledWorkflowChildStatus(asyncDir, workflowRunId, step, now) {
   if (settled.stopped === void 0) delete settled.stopped;
   return settled;
 }
-function buildFailedRepair(status, asyncDir, now, reason) {
+function buildFailedRepair(status, asyncDir, now, reason, ownerExited = false, adoptCompletionOwnerId) {
   const runId = status.runId || path15.basename(asyncDir);
   const pid = typeof status.pid === "number" ? status.pid : "unknown";
+  const exitedWorkflow = ownerExited && status.mode === "workflow" ? status.workflow : void 0;
+  const completionOwnerId = exitedWorkflow ? adoptCompletionOwnerId || OWNING_SESSION_COMPLETION_OWNER : status.completionOwnerId;
   const terminal3 = readProcessTerminal(asyncDir, { runId }) ?? status.processTerminal;
   const runnerExit = terminal3?.state === "observed" || terminal3?.state === "unknown" ? terminal3.instances?.find((instance) => instance.kind === "runner" && instance.processInstanceId === terminal3.runnerProcessInstanceId) : void 0;
   const exitText = runnerExit?.kind === "runner" ? `exited with code ${runnerExit.exitCode ?? "none"}${runnerExit.signal ? ` (signal ${runnerExit.signal})` : ""}` : "exited or disappeared";
-  const baseMessage = reason ?? `Async runner process ${pid} ${exitText} before writing a result. Marked run failed by stale-run reconciliation.`;
+  const baseMessage = reason ?? (exitedWorkflow ? `The Pi process (PID ${pid}) that ran workflow ${runId} exited before the workflow finished. Marked run failed by stale-run reconciliation. Its finished children are kept.` : `Async runner process ${pid} ${exitText} before writing a result. Marked run failed by stale-run reconciliation.`);
   const diagnostics = readRunnerStartupDiagnostics(asyncDir);
   const message = diagnostics ? `${baseMessage}
 
@@ -6502,7 +6587,10 @@ ${diagnostics}` : baseMessage;
     activityState: void 0,
     lastUpdate: now,
     endedAt: now,
-    steps: repairedSteps
+    steps: repairedSteps,
+    // Read from the pre-repair status: the repair time would make an old crash look new.
+    ...exitedWorkflow ? { workflow: { ...exitedWorkflow, stopCause: WORKFLOW_STOP_CAUSE_OWNER_EXITED, ownerExitedAt: status.lastUpdate ?? status.startedAt } } : {},
+    ...completionOwnerId ? { completionOwnerId } : {}
   };
   const resultAgent = repairedSteps[status.currentStep ?? 0]?.agent ?? repairedSteps[0]?.agent ?? "subagent";
   return {
@@ -6512,7 +6600,9 @@ ${diagnostics}` : baseMessage;
       id: runId,
       agent: resultAgent,
       mode: status.mode,
-      ...status.completionOwnerId ? { completionOwnerId: status.completionOwnerId } : {},
+      ...exitedWorkflow ? { workflow: { stopCause: WORKFLOW_STOP_CAUSE_OWNER_EXITED } } : {},
+      ...completionOwnerId ? { completionOwnerId } : {},
+      ...status.completionOwnerProcess ? { completionOwnerProcess: status.completionOwnerProcess } : {},
       ...status.parentWorkflowRunId ? { parentWorkflowRunId: status.parentWorkflowRunId } : {},
       ...status.workflowKey ? { workflowKey: status.workflowKey } : {},
       success: false,
@@ -6538,8 +6628,8 @@ ${diagnostics}` : baseMessage;
     }
   };
 }
-function writeFailedRepair(asyncDir, status, resultPath, now, reason) {
-  const repair = buildFailedRepair(status, asyncDir, now, reason);
+function writeFailedRepair(asyncDir, status, resultPath, now, reason, ownerExited = false, adoptCompletionOwnerId) {
+  const repair = buildFailedRepair(status, asyncDir, now, reason, ownerExited, adoptCompletionOwnerId);
   if (repair.result.sessionId) writeAsyncResultFile(resultPath, repair.result);
   writeAtomicJson(path15.join(asyncDir, "status.json"), repair.status);
   updateActiveRunIndex(asyncDir, repair.status.state, repair.status.toolCallId);
@@ -6599,7 +6689,7 @@ function checkPidLiveness(pid, kill = process.kill, probeZombie = false) {
     kill(pid, 0);
     if (probeZombie && process.platform === "linux") {
       try {
-        const stat = fs15.readFileSync(`/proc/${pid}/stat`, "utf-8");
+        const stat = fs16.readFileSync(`/proc/${pid}/stat`, "utf-8");
         const closeParen = stat.lastIndexOf(") ");
         if (closeParen >= 0 && stat[closeParen + 2] === "Z") return "dead";
       } catch {
@@ -6613,6 +6703,19 @@ function checkPidLiveness(pid, kill = process.kill, probeZombie = false) {
     return "unknown";
   }
 }
+function isRecordedPid(value) {
+  if (!value || typeof value !== "object") return false;
+  const { pid, pidNamespaceScope, bootId } = value;
+  return typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0 && (pidNamespaceScope === void 0 || typeof pidNamespaceScope === "string") && (bootId === void 0 || typeof bootId === "string");
+}
+function checkRecordedPidLiveness(recorded, observation = { observedScope: currentPidNamespaceScope(), observedBootId: currentBootId() }) {
+  const { observedScope, observedBootId } = observation;
+  if (recorded.pidNamespaceScope === observedScope && recorded.bootId && observedBootId && recorded.bootId !== observedBootId) return "dead";
+  const scopeMismatch = recorded.pidNamespaceScope !== void 0 && recorded.pidNamespaceScope !== observedScope;
+  const scopeVerified = recorded.pidNamespaceScope !== void 0 && recorded.pidNamespaceScope === observedScope;
+  const liveness = observation.probe ? observation.probe(recorded.pid) : checkPidLiveness(recorded.pid, observation.kill, scopeVerified);
+  return liveness === "dead" && scopeMismatch ? "unknown" : liveness;
+}
 function reconcileAsyncRun(asyncDir, options = {}, observeStatus) {
   const now = options.now?.() ?? Date.now();
   const status = readStatus(asyncDir);
@@ -6665,11 +6768,11 @@ function reconcileAsyncRun(asyncDir, options = {}, observeStatus) {
       return { status: null, repaired: false, resultPath };
     }
   }
-  const observedScope = options.pidNamespaceScope ? options.pidNamespaceScope() : currentPidNamespaceScope();
-  const pidScopeMismatch = effectiveStatus.pidNamespaceScope !== void 0 && effectiveStatus.pidNamespaceScope !== observedScope;
-  const pidScopeVerified = effectiveStatus.pidNamespaceScope !== void 0 && effectiveStatus.pidNamespaceScope === observedScope;
-  const observedLiveness = checkPidLiveness(effectiveStatus.pid, options.kill, pidScopeVerified);
-  const liveness = observedLiveness === "dead" && pidScopeMismatch ? "unknown" : observedLiveness;
+  const liveness = checkRecordedPidLiveness({ pid: effectiveStatus.pid, pidNamespaceScope: effectiveStatus.pidNamespaceScope, bootId: effectiveStatus.bootId }, {
+    kill: options.kill,
+    observedScope: options.pidNamespaceScope ? options.pidNamespaceScope() : currentPidNamespaceScope(),
+    observedBootId: options.bootId ? options.bootId() : currentBootId()
+  });
   if (liveness !== "dead") {
     const staleAfterMs = options.staleAlivePidMs ?? 24 * 60 * 60 * 1e3;
     const lastUpdate = effectiveStatus.lastUpdate ?? effectiveStatus.startedAt;
@@ -6678,7 +6781,7 @@ function reconcileAsyncRun(asyncDir, options = {}, observeStatus) {
     const message = `Async runner PID ${effectiveStatus.pid} ${probe}; status has not updated for ${now - lastUpdate}ms, so stale-run reconciliation marked the run failed because PID ownership is unverified.`;
     return writeFailedRepair(asyncDir, effectiveStatus, resultPath, now, message);
   }
-  return writeFailedRepair(asyncDir, effectiveStatus, resultPath, now);
+  return writeFailedRepair(asyncDir, effectiveStatus, resultPath, now, void 0, true, options.adoptCompletionOwnerId);
 }
 
 // src/policy/authority.ts
@@ -6908,7 +7011,7 @@ async function runSetupCommand(command, args, options) {
 }
 
 // src/runs/shared/worktree.ts
-import * as fs16 from "node:fs";
+import * as fs17 from "node:fs";
 import * as os2 from "node:os";
 import * as path16 from "node:path";
 var DEFAULT_WORKTREE_PROVIDER = "auto";
@@ -7045,7 +7148,7 @@ function currentWorktreePatch(worktreePath, baseCommit) {
   assertWorktreeMutationAllowed();
   let tempDir;
   try {
-    tempDir = fs16.mkdtempSync(path16.join(os2.tmpdir(), "pi-worktree-index-"));
+    tempDir = fs17.mkdtempSync(path16.join(os2.tmpdir(), "pi-worktree-index-"));
   } catch (error) {
     return { error: error instanceof Error ? error.message : String(error) };
   }
@@ -7060,7 +7163,7 @@ function currentWorktreePatch(worktreePath, baseCommit) {
     return { patch: diff.stdout };
   } finally {
     try {
-      fs16.rmSync(tempDir, { recursive: true, force: true });
+      fs17.rmSync(tempDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -7070,7 +7173,7 @@ function validateWorktreePatchRepresentsCurrentWorktree(worktreePath, baseCommit
   if (validationError) return validationError;
   let capturedPatch;
   try {
-    capturedPatch = fs16.readFileSync(patchPath, "utf-8");
+    capturedPatch = fs17.readFileSync(patchPath, "utf-8");
   } catch (error) {
     return error instanceof Error ? error.message : String(error);
   }
@@ -7124,9 +7227,9 @@ function normalizeComparableCwd(cwd) {
     try {
       let realpath;
       try {
-        realpath = fs16.realpathSync.native(existing);
+        realpath = fs17.realpathSync.native(existing);
       } catch {
-        realpath = fs16.realpathSync(existing);
+        realpath = fs17.realpathSync(existing);
       }
       return path16.join(realpath, ...missingSegments.reverse());
     } catch {
@@ -7326,7 +7429,7 @@ function buildNativeProjectPath(dedicatedRoot, repoRoot) {
 }
 function ensureProjectWorktreeDir(dedicatedRoot, repoRoot) {
   try {
-    fs16.mkdirSync(buildNativeProjectPath(dedicatedRoot, repoRoot), { recursive: true });
+    fs17.mkdirSync(buildNativeProjectPath(dedicatedRoot, repoRoot), { recursive: true });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`failed to create worktree base directory ${dedicatedRoot}: ${message}`);
@@ -7386,7 +7489,7 @@ function linkNodeModulesIfPresent(toplevel, worktreePath) {
   const nodeModulesLinkPath = path16.join(worktreePath, "node_modules");
   const hasDirectoryEntry = (candidate) => {
     try {
-      fs16.lstatSync(candidate);
+      fs17.lstatSync(candidate);
       return true;
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
@@ -7397,14 +7500,14 @@ function linkNodeModulesIfPresent(toplevel, worktreePath) {
     if (hasDirectoryEntry(nodeModulesLinkPath)) return false;
     let sourceRealPath;
     try {
-      if (!fs16.statSync(nodeModulesPath).isDirectory()) throw new Error("source node_modules is not a directory");
-      sourceRealPath = fs16.realpathSync.native(nodeModulesPath);
+      if (!fs17.statSync(nodeModulesPath).isDirectory()) throw new Error("source node_modules is not a directory");
+      sourceRealPath = fs17.realpathSync.native(nodeModulesPath);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
       throw error;
     }
-    fs16.symlinkSync(nodeModulesPath, nodeModulesLinkPath, process.platform === "win32" ? "junction" : "dir");
-    if (!fs16.lstatSync(nodeModulesLinkPath).isSymbolicLink() || fs16.realpathSync.native(nodeModulesLinkPath) !== sourceRealPath) {
+    fs17.symlinkSync(nodeModulesPath, nodeModulesLinkPath, process.platform === "win32" ? "junction" : "dir");
+    if (!fs17.lstatSync(nodeModulesLinkPath).isSymbolicLink() || fs17.realpathSync.native(nodeModulesLinkPath) !== sourceRealPath) {
       throw new Error("created link does not resolve to the source node_modules");
     }
     return true;
@@ -7438,10 +7541,10 @@ function resolveWorktreeSetupHook(repoRoot, config) {
   } else {
     throw new Error("worktree setup hook must be an absolute path or a repo-relative path");
   }
-  if (!fs16.existsSync(resolvedPath)) {
+  if (!fs17.existsSync(resolvedPath)) {
     throw new Error(`worktree setup hook not found: ${resolvedPath}`);
   }
-  if (fs16.statSync(resolvedPath).isDirectory()) {
+  if (fs17.statSync(resolvedPath).isDirectory()) {
     throw new Error(`worktree setup hook must be a file, got directory: ${resolvedPath}`);
   }
   return {
@@ -7542,7 +7645,7 @@ async function createNativeWorktree(tx, toplevel, cwdRelative, runId, index, bas
   const branch = await tx.git(toplevel, ["show-ref", "--verify", "--quiet", `refs/heads/${naming.requestedBranch}`], [0, 1]);
   let pathExists = false;
   try {
-    fs16.lstatSync(worktreePath);
+    fs17.lstatSync(worktreePath);
     pathExists = true;
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") throw error;
@@ -7594,7 +7697,7 @@ async function createWorktrunkWorktree(tx, toplevel, cwdRelative, runId, index,
     const worktreePathCandidate = path16.resolve(output.path);
     let stat;
     try {
-      stat = fs16.lstatSync(worktreePathCandidate);
+      stat = fs17.lstatSync(worktreePathCandidate);
     } catch (error) {
       throw new Error(`Worktrunk provisioning returned a missing worktree path: ${worktreePathCandidate}`, { cause: error instanceof Error ? error : void 0 });
     }
@@ -7637,21 +7740,21 @@ function removeSyntheticPath(worktree, syntheticPath) {
   }
   let stat;
   try {
-    stat = fs16.lstatSync(resolved2);
+    stat = fs17.lstatSync(resolved2);
   } catch (error) {
     const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
     if (code === "ENOENT") return;
     throw error;
   }
   if (stat.isSymbolicLink()) {
-    fs16.unlinkSync(resolved2);
+    fs17.unlinkSync(resolved2);
     return;
   }
   if (stat.isDirectory()) {
-    fs16.rmSync(resolved2, { recursive: true, force: true });
+    fs17.rmSync(resolved2, { recursive: true, force: true });
     return;
   }
-  fs16.rmSync(resolved2, { force: true });
+  fs17.rmSync(resolved2, { force: true });
 }
 function removeSyntheticPathsBeforeDiff(worktree) {
   if (worktree.syntheticPaths.length === 0) return;
@@ -7695,7 +7798,7 @@ function captureWorktreeDiff(setup, worktree, agent, patchPath) {
   const diffStat = runGitChecked(worktree.path, ["diff", "--cached", ...MACHINE_DIFF_OPTIONS, "--stat", setup.baseCommit]).trim();
   const patch = runGitChecked(worktree.path, ["diff", "--cached", ...MACHINE_PATCH_OPTIONS, setup.baseCommit]);
   const numstat = runGitChecked(worktree.path, ["diff", "--cached", ...MACHINE_DIFF_OPTIONS, "--numstat", setup.baseCommit]);
-  fs16.writeFileSync(patchPath, patch, "utf-8");
+  fs17.writeFileSync(patchPath, patch, "utf-8");
   if (!patch.trim()) {
     return emptyDiff(worktree.index, agent, worktree.branch, patchPath);
   }
@@ -7715,14 +7818,14 @@ function captureWorktreeDiff(setup, worktree, agent, patchPath) {
 }
 function writeEmptyPatch(patchPath) {
   try {
-    fs16.writeFileSync(patchPath, "", "utf-8");
+    fs17.writeFileSync(patchPath, "", "utf-8");
   } catch {
   }
 }
 function handoffRecordsPatch(manifestPath, patchPath) {
-  if (!manifestPath || !fs16.existsSync(manifestPath)) return false;
+  if (!manifestPath || !fs17.existsSync(manifestPath)) return false;
   try {
-    const manifest = JSON.parse(fs16.readFileSync(manifestPath, "utf-8"));
+    const manifest = JSON.parse(fs17.readFileSync(manifestPath, "utf-8"));
     if (manifest.version !== 1 || !Array.isArray(manifest.groups)) return false;
     const resolvedPatchPath = path16.resolve(patchPath);
     return manifest.groups.some((group) => Array.isArray(group.children) && group.children.some(
@@ -7779,9 +7882,9 @@ function cleanupSingleWorktree(setup, worktree, intent) {
       const captured = (intent.capturedDiffs ?? setup.capturedDiffs)?.find((diff) => diff.index === worktree.index);
       let patchValidationError;
       let patchCaptured = false;
-      if (captured !== void 0 && captured.error === void 0 && fs16.existsSync(captured.patchPath) && handoffRecordsPatch(intent.handoffManifestPath, captured.patchPath)) {
+      if (captured !== void 0 && captured.error === void 0 && fs17.existsSync(captured.patchPath) && handoffRecordsPatch(intent.handoffManifestPath, captured.patchPath)) {
         try {
-          if (fs16.statSync(captured.patchPath).size > 0) {
+          if (fs17.statSync(captured.patchPath).size > 0) {
             patchValidationError = validateWorktreePatchRepresentsCurrentWorktree(worktree.path, setup.baseCommit, captured.patchPath);
             patchCaptured = patchValidationError === void 0;
           }
@@ -7911,7 +8014,7 @@ async function compensateSetup(tx) {
             throw new Error(tx.progress.unknown);
           }
           await git(["worktree", "remove", "--force", attempt.path]);
-        } else if (fs16.existsSync(attempt.path)) {
+        } else if (fs17.existsSync(attempt.path)) {
           tx.unknown("Unregistered partial allocation retained");
           throw new Error(tx.progress.unknown);
         }
@@ -8031,7 +8134,7 @@ async function createWorktrees(cwd, runId, count, options = {}) {
 function diffWorktrees(setup, agents, diffsDir) {
   assertWorktreeMutationAllowed();
   try {
-    fs16.mkdirSync(diffsDir, { recursive: true });
+    fs17.mkdirSync(diffsDir, { recursive: true });
   } catch {
     return [];
   }
@@ -8216,7 +8319,14 @@ export {
   resultCandidateFilesForToolCall,
   missionObserverResultCandidateFiles,
   cleanupResultIndexes,
+  OWNING_SESSION_COMPLETION_OWNER,
+  currentCompletionOwnerId,
   currentPidNamespaceScope,
+  currentBootId,
+  currentRecordedPid,
+  WORKFLOW_STOP_CAUSE_RUNTIME_REPLACED,
+  WORKFLOW_STOP_CAUSE_OWNER_EXITED,
+  isReusableWorkflowStopCause,
   isTerminalAsyncState,
   withWorkflowChildRunModel,
   readWorkflowChildProcessEvidence,
@@ -8224,6 +8334,8 @@ export {
   readWorkflowTerminalProof,
   reconcileNestedAsyncDescendants,
   checkPidLiveness,
+  isRecordedPid,
+  checkRecordedPidLiveness,
   reconcileAsyncRun,
   resolveAuthorityDecision,
   validateAuthorityPolicy,