pi-subagents 0.82.1 → 0.83.0

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

@@ -3,7 +3,7 @@ import {
   projectRuntimeAcknowledgedExtensions,
   registerSubagentPromptBoundary,
   registerSubagentPromptRuntime
-} from "./chunk-3JCDWF4V.js";
+} from "./chunk-CGXWSNPA.js";
 import {
   INSPECTOR_ACTIONS,
   canQueueRetainedAsyncFollowUp,
@@ -25,12 +25,13 @@ import {
   updateSteeringTarget,
   waitForSteeringAction,
   workflowAsyncChildSteeringGuidance
-} from "./chunk-PBK2I7WY.js";
+} from "./chunk-527E3D2J.js";
 import {
-  REX_LOCAL_MACHINE,
+  PLACED_RESTORE_UNSUPPORTED,
+  formatHerdrMachineRunnerUnsupported,
   isRexLocalMachine,
-  resolveRexLocalPlacement
-} from "./chunk-RMQFMMAT.js";
+  resolveMachinePlacement
+} from "./chunk-P2NCCTZP.js";
 import {
   COMPLETION_ACTION,
   DEFAULT_CONTROL_CONFIG,
@@ -119,7 +120,7 @@ import {
   workflowStopCause,
   writeWorkflowLaunchRecord,
   writeWorkflowReceipt
-} from "./chunk-ZIV4J4HG.js";
+} from "./chunk-CDI3GMNV.js";
 import {
   NATIVE_SUPERVISOR_TOOL_NAME,
   SUBAGENT_PARENT_SESSION_ENV,
@@ -135,7 +136,7 @@ import {
   resolveWatchdogConfig,
   sendRuleViolationWarning,
   writeWatchdogModelSettings
-} from "./chunk-VSUSLDNW.js";
+} from "./chunk-CZTMUBUI.js";
 import {
   MAX_REMEMBERED_FOREGROUND_RUNS,
   discardRunningForegroundRun,
@@ -148,7 +149,7 @@ import {
   resolveSubagentRunId,
   resolveWorkflowChatProgress,
   stopAsyncRun
-} from "./chunk-FXUXCX2K.js";
+} from "./chunk-4BW55BTL.js";
 import {
   MODEL_ONLY_TOOL,
   RunFanoutLimitError,
@@ -210,7 +211,7 @@ import {
   writeParallelHandoffGroup,
   writeRunFanoutBudgetDescriptor,
   writeWorktreeSetupHandoff
-} from "./chunk-6XJB7PIX.js";
+} from "./chunk-OOFW75PV.js";
 import {
   authorizeWorkflowResourceHost,
   claimWorkflowChildPermit,
@@ -227,14 +228,15 @@ import {
   canPreferFork,
   createForkContextResolver,
   resolveSubagentLaunchContext
-} from "./chunk-GJECHSAR.js";
+} from "./chunk-HLE22FSH.js";
 import {
   handleRefinementAction
-} from "./chunk-PLCCBLPY.js";
+} from "./chunk-Y3I6H6DV.js";
 import {
   ActiveAsyncCapacityError,
   acquireActiveAsyncCapacity,
   disabledFeatureNotice,
+  disabledFeatureSectionNotice,
   disabledFeatureUseError,
   getActiveAsyncCapacitySnapshot,
   inspectActiveAsyncCapacityOwner,
@@ -244,7 +246,7 @@ import {
   resolveDisabledFeatureSurface,
   resolveMaxActiveAsyncRunsPerSession,
   transferActiveAsyncCapacity
-} from "./chunk-UCPP4GNU.js";
+} from "./chunk-RZJN63GU.js";
 import {
   DEFAULT_STALE_TERMINAL_ACTIVE_MARKER_MS,
   MACHINE_DIFF_OPTIONS,
@@ -323,7 +325,7 @@ import {
   writeNestedControlRequest,
   writeNestedControlResult,
   writeNestedEvent
-} from "./chunk-46XKCPJR.js";
+} from "./chunk-5ESXK62X.js";
 import {
   closeSteerInbox,
   consumeSteerRequests,
@@ -331,7 +333,7 @@ import {
   readRevivalBriefs,
   requestAsyncSteer,
   watchAsyncControlInbox
-} from "./chunk-OYF6AFDY.js";
+} from "./chunk-BKFWQ642.js";
 import "./chunk-NIXWDZZV.js";
 import {
   INTERCOM_BRIDGE_MARKER,
@@ -340,7 +342,7 @@ import {
   resolveIntercomBridge,
   resolveIntercomSessionTarget,
   resolveSubagentIntercomTarget
-} from "./chunk-XSWOTIA3.js";
+} from "./chunk-MHX22USZ.js";
 import {
   resolveLaunchBinding,
   stableJsonDigest
@@ -354,7 +356,7 @@ import {
   resolvePiLaunchToolPlan,
   resolveRuntimeModulePath,
   supervisorChannelDir
-} from "./chunk-4SDU2BZX.js";
+} from "./chunk-CSSZRTKY.js";
 import {
   assertRequiredChildExtensionsAdmitted,
   hasMandatoryRequiredChildExtensions,
@@ -365,7 +367,7 @@ import {
 import {
   HERDR_PROJECT_PANE_ACTIONS,
   handleHerdrProjectPaneAction
-} from "./chunk-52UBALJL.js";
+} from "./chunk-WG2OTTAK.js";
 import "./chunk-7J4ZXMY7.js";
 import {
   PROJECT_SUBAGENTS_RELATIVE_DIR,
@@ -378,14 +380,13 @@ import {
   getProjectSubagentsDir,
   writeArtifact,
   writeMetadata
-} from "./chunk-5TYMSZX3.js";
-import "./chunk-N2BN7BF5.js";
+} from "./chunk-VTMNBPCQ.js";
+import "./chunk-XA3DY6UG.js";
 import {
   getExternalJobProvider
 } from "./chunk-YYREO77V.js";
-import "./chunk-YKEWIB4M.js";
+import "./chunk-JHZ6DZ5M.js";
 import {
-  CODE_OWNED_EXTERNAL_CLI_ADAPTER_IDS,
   ChainOutputValidationError,
   MAX_STREAMED_RECENT_TOOLS,
   MISSING_STRUCTURED_ACCEPTANCE_REPORT_ERROR,
@@ -449,7 +450,6 @@ import {
   formatUnknownAgentError,
   getAgentDir,
   getFinalOutput,
-  getProjectConfigDir,
   getSingleResultOutput,
   getStepAgents,
   hasEmptyTerminalAssistantResponse,
@@ -531,7 +531,7 @@ import {
   writeAtomicJson,
   writeInitialProgressFile,
   writePrivateAtomicJson
-} from "./chunk-CIZQXJ5Q.js";
+} from "./chunk-7F5SK2U3.js";
 import {
   CHAIN_RUNS_DIR,
   DEFAULT_ARTIFACT_CONFIG,
@@ -560,7 +560,7 @@ import {
   resolveMaxSubagentSpawnsPerSession,
   truncateOutput,
   wrapForkTask
-} from "./chunk-5LFLVSTM.js";
+} from "./chunk-JEZOSEWG.js";
 import {
   safeTerminalText
 } from "./chunk-YFCK7H2S.js";
@@ -573,8 +573,8 @@ import {
 
 // src/runs/foreground/subagent-executor.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
-import * as fs21 from "node:fs";
-import * as path19 from "node:path";
+import * as fs20 from "node:fs";
+import * as path18 from "node:path";
 
 // src/shared/capacity-resilient-json.ts
 var defaultTimerApi = {
@@ -775,235 +775,24 @@ function finishForegroundChild(control, index) {
 }
 
 // src/extension/doctor.ts
-import * as fs8 from "node:fs";
-import * as path7 from "node:path";
+import * as fs7 from "node:fs";
+import * as path6 from "node:path";
 
 // src/runs/background/async-execution.ts
 import { spawn } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
-import * as fs7 from "node:fs";
-import * as path6 from "node:path";
+import * as fs6 from "node:fs";
+import * as path5 from "node:path";
 import { fileURLToPath } from "node:url";
 import * as nodeModule from "node:module";
 
-// src/runs/shared/herdr-machine.ts
-import { spawnSync } from "node:child_process";
-import * as fs from "node:fs";
-import * as path from "node:path";
-var MAX_MACHINE_NAME_LENGTH = 128;
-var HERDR_MACHINE_LIST_TIMEOUT_MS = 7500;
-var MAX_HERDR_MACHINE_LIST_BYTES = 1024 * 1024;
-var CONTROL_CHARS = /[\u0000-\u001f\u007f]/u;
-var SUPPORTED_MACHINE_ADAPTERS = new Set(CODE_OWNED_EXTERNAL_CLI_ADAPTER_IDS);
-function validateMachineName(value) {
-  const trimmed = value.trim();
-  if (!trimmed) throw new Error("Herdr machine id or label is required.");
-  if (trimmed.length > MAX_MACHINE_NAME_LENGTH) throw new Error(`Herdr machine '${trimmed.slice(0, 24)}\u2026' exceeds ${MAX_MACHINE_NAME_LENGTH} characters.`);
-  if (CONTROL_CHARS.test(trimmed)) throw new Error("Herdr machine id or label contains control characters.");
-  return trimmed;
-}
-function validateTarget(value, requested) {
-  const target = value.trim();
-  if (!target || target.startsWith("-") || /[\s\u0000-\u001f\u007f]/u.test(target)) {
-    throw new Error(`Herdr machine '${requested}' has an ssh target that cannot be passed safely: ${JSON.stringify(target)}.`);
-  }
-  return target;
-}
-function isRemoteAbsolute(value) {
-  return value.startsWith("/") || value === "~" || value.startsWith("~/");
-}
-function validateRemoteCwd(value, requested) {
-  const cwd = value.trim();
-  if (!isRemoteAbsolute(cwd)) throw new Error(`Herdr machine '${requested}' cwd must be an absolute POSIX path or start with '~': ${JSON.stringify(cwd)}.`);
-  if (CONTROL_CHARS.test(cwd)) throw new Error(`Herdr machine '${requested}' cwd contains control characters.`);
-  return cwd.length > 1 ? cwd.replace(/\/+$/u, "") : cwd;
-}
-function parseMachineCatalog(json) {
-  let parsed;
-  try {
-    parsed = JSON.parse(json);
-  } catch (error) {
-    throw new Error(`Failed to parse herdr machine list --json: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  const entries = Array.isArray(parsed) ? parsed : parsed && typeof parsed === "object" && Array.isArray(parsed.machines) ? parsed.machines : void 0;
-  if (!entries) throw new Error("herdr machine list --json returned no machine list.");
-  return entries.flatMap((entry) => {
-    if (!entry || typeof entry !== "object" || Array.isArray(entry)) return [];
-    const record2 = entry;
-    if (typeof record2.id !== "string" || !record2.id.trim() || typeof record2.target !== "string") return [];
-    return [{
-      id: record2.id.trim(),
-      ...typeof record2.label === "string" && record2.label.trim() ? { label: record2.label.trim() } : {},
-      target: record2.target,
-      ...typeof record2.session === "string" && record2.session.trim() ? { session: record2.session.trim() } : {},
-      enabled: record2.enabled !== false
-    }];
-  });
-}
-function readHerdrMachineCatalog(env, herdrBin) {
-  const result2 = spawnSync(herdrBin, ["machine", "list", "--json"], {
-    env,
-    encoding: "utf-8",
-    maxBuffer: MAX_HERDR_MACHINE_LIST_BYTES,
-    timeout: HERDR_MACHINE_LIST_TIMEOUT_MS,
-    windowsHide: true
-  });
-  if (result2.error) {
-    const code = result2.error.code;
-    if (code === "ENOENT") throw new Error(`Herdr CLI '${herdrBin}' was not found on PATH. Saved-machine placement needs Herdr installed locally.`);
-    throw new Error(`Failed to run herdr machine list --json: ${result2.error.message}`);
-  }
-  if (result2.status !== 0) throw new Error(`herdr machine list --json exited with code ${result2.status}: ${(result2.stderr || result2.stdout).trim()}`);
-  return parseMachineCatalog(result2.stdout);
-}
-function selectMachine(catalog, requested) {
-  const byId = catalog.find((entry) => entry.id === requested);
-  const matches = byId ? [byId] : catalog.filter((entry) => entry.label === requested);
-  if (matches.length > 1) throw new Error(`Machine label '${requested}' is ambiguous; use its profile ID.`);
-  const machine = matches[0];
-  if (!machine) {
-    const saved = catalog.filter((entry) => entry.enabled).map((entry) => entry.label ?? entry.id);
-    throw new Error(`Herdr machine '${requested}' was not found. Saved machines: ${saved.length ? saved.join(", ") : "none"}. Add one with herdr machine add <target> --label <name>.`);
-  }
-  if (!machine.enabled) throw new Error(`Machine '${requested}' is disabled. Run herdr machine enable ${machine.id}.`);
-  return machine;
-}
-function readJsonObject(filePath) {
-  if (!fs.existsSync(filePath)) return {};
-  let parsed;
-  try {
-    parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-  } catch (error) {
-    throw new Error(`Failed to read settings file '${filePath}': ${error instanceof Error ? error.message : String(error)}`);
-  }
-  return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
-}
-function machineSettingsFrom(settings, keys, filePath) {
-  const subagents = settings.subagents;
-  if (!subagents || typeof subagents !== "object" || Array.isArray(subagents)) return void 0;
-  const machines = subagents.machines;
-  if (machines === void 0) return void 0;
-  if (!machines || typeof machines !== "object" || Array.isArray(machines)) throw new Error(`Subagent settings in '${filePath}' have invalid 'machines'; expected an object keyed by machine label or id.`);
-  const key = keys.find((candidate) => candidate in machines);
-  if (key === void 0) return void 0;
-  const value = machines[key];
-  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`Subagent settings in '${filePath}' have invalid 'machines.${key}'; expected an object with 'cwd' and optional 'env'.`);
-  const record2 = value;
-  const entry = {};
-  if (record2.cwd !== void 0) {
-    if (typeof record2.cwd !== "string" || !record2.cwd.trim()) throw new Error(`Subagent settings in '${filePath}' have invalid 'machines.${key}.cwd'; expected a non-empty string.`);
-    entry.cwd = validateRemoteCwd(record2.cwd, key);
-  }
-  if (record2.env !== void 0) {
-    if (!record2.env || typeof record2.env !== "object" || Array.isArray(record2.env) || Object.entries(record2.env).some(([name, item]) => !/^[A-Za-z_][A-Za-z0-9_]*$/u.test(name) || typeof item !== "string")) {
-      throw new Error(`Subagent settings in '${filePath}' have invalid 'machines.${key}.env'; expected an object of string values keyed by variable name.`);
-    }
-    entry.env = { ...record2.env };
-    if (Object.keys(entry.env).length > 0) {
-      throw new Error(`Subagent settings in '${filePath}' set 'machines.${key}.env'. Saved-machine runs use the remote Herdr/Pi environment; configure credentials and environment on '${key}' and remove the local env map.`);
-    }
-  }
-  if (record2.rex !== void 0) {
-    const rex = record2.rex, ssh = rex && typeof rex === "object" && !Array.isArray(rex) && Object.keys(rex).every((field) => field === "ssh") ? rex.ssh : void 0;
-    if (typeof ssh !== "string") throw new Error(`Subagent settings in '${filePath}' have invalid 'machines.${key}.rex'; expected { "ssh": "<ssh target>" }.`);
-    entry.rex = { ssh: validateTarget(ssh, key) };
-  }
-  return entry;
-}
-function readMachineSettings(cwd, keys) {
-  const userPath = path.join(getAgentDir(), "settings.json");
-  const projectPath = path.join(getProjectConfigDir(findProjectRootForSettings(cwd)), "settings.json");
-  const user = machineSettingsFrom(readJsonObject(userPath), keys, userPath);
-  const project = projectPath === userPath ? void 0 : machineSettingsFrom(readJsonObject(projectPath), keys, projectPath);
-  if (project?.rex) throw new Error(`Project settings '${projectPath}' set a Rex SSH host in 'machines'. Move the rex entry to your user settings '${userPath}'; only user settings choose which host a task runs on.`);
-  if (!user && !project) return void 0;
-  return { ...user, ...project };
-}
-function userRexMachine(machine) {
-  const userPath = path.join(getAgentDir(), "settings.json");
-  return machineSettingsFrom(readJsonObject(userPath), [machine], userPath)?.rex !== void 0;
-}
-function findProjectRootForSettings(cwd) {
-  let current = path.resolve(cwd);
-  while (true) {
-    if (fs.existsSync(path.join(getProjectConfigDir(current), "settings.json"))) return current;
-    const parent = path.dirname(current);
-    if (parent === current) return path.resolve(cwd);
-    current = parent;
-  }
-}
-function remoteMachineCwd(stepCwd, root, name) {
-  const step = stepCwd?.trim();
-  if (step && isRemoteAbsolute(step)) return step;
-  if (!root) throw new Error(`No root for ${name} in this repo. Set subagents.machines.${name}.cwd in .pi/settings.json or pass an absolute cwd on that machine.`);
-  return step ? path.posix.join(root, step) : root;
-}
-function resolveHerdrMachinePlacement(input) {
-  const requested = validateMachineName(input.machine);
-  const catalog = input.catalogJson !== void 0 ? parseMachineCatalog(input.catalogJson) : readHerdrMachineCatalog(input.env ?? process.env, input.herdrBin ?? process.env.HERDR_BIN ?? "herdr");
-  const selected = selectMachine(catalog, requested);
-  const name = selected.label ?? selected.id;
-  const keys = [.../* @__PURE__ */ new Set([requested, ...selected.label ? [selected.label] : [], selected.id])];
-  const settings = input.settings ?? readMachineSettings(input.cwd, keys);
-  if (settings?.env && Object.keys(settings.env).length > 0) {
-    throw new Error(`Saved-machine environment for '${name}' must be configured remotely. Remove machines.${name}.env and configure the remote Herdr/Pi session instead.`);
-  }
-  const cwd = remoteMachineCwd(input.stepCwd, settings?.cwd, name);
-  return {
-    machine: {
-      provider: "herdr",
-      id: selected.id,
-      ...selected.label ? { label: selected.label } : {},
-      target: validateTarget(selected.target, requested),
-      ...selected.session && selected.session !== "default" ? { session: selected.session } : {},
-      cwd: validateRemoteCwd(cwd, requested)
-    },
-    ...settings?.env ? { env: settings.env } : {}
-  };
-}
-function resolveMachinePlacement(input) {
-  const requested = validateMachineName(input.machine);
-  const settings = input.settings ?? readMachineSettings(input.cwd, [requested]);
-  if (requested === REX_LOCAL_MACHINE) {
-    if (settings?.rex) throw new Error("Machine 'local' is reserved for a Rex pane on this machine; give the Rex SSH host in subagents.machines.local.rex another name.");
-    return { machine: resolveRexLocalPlacement({ cwd: input.cwd, stepCwd: input.stepCwd, env: input.env }) };
-  }
-  if (settings?.rex) return { machine: { provider: "rex", id: requested, target: settings.rex.ssh, cwd: validateRemoteCwd(remoteMachineCwd(input.stepCwd, settings.cwd, requested), requested) } };
-  return resolveHerdrMachinePlacement(input);
-}
-function formatHerdrMachineRunnerUnsupported(input) {
-  if (input.machine === void 0) return void 0;
-  const name = input.machine.trim();
-  let rex;
-  try {
-    rex = name === REX_LOCAL_MACHINE || userRexMachine(name);
-  } catch (error) {
-    return error instanceof Error ? error.message : String(error);
-  }
-  if (rex) {
-    if (input.runnerType !== void 0 && input.runnerType !== "pi") return `Agent '${input.agentName}' requested machine '${name}', but Rex supports native Pi children only. Remove the machine or use a native Pi agent.`;
-    if (input.worktree === true) return `Agent '${input.agentName}' requested machine '${name}', but managed worktrees cannot be combined with machine placement.`;
-    if (process.platform === "win32") return `Machine '${name}' runs the child in a Rex pane, which is not supported on Windows.`;
-    return void 0;
-  }
-  if (input.runnerType !== void 0 && input.runnerType !== "pi" && input.runnerType !== "external-cli") {
-    return `Agent '${input.agentName}' requested machine '${input.machine}', but this runner cannot use pane-native Herdr placement. Use native Pi or a built-in Claude, Codex, or Cursor profile.`;
-  }
-  if (input.runnerType === "external-cli" && (input.adapter === void 0 || !SUPPORTED_MACHINE_ADAPTERS.has(input.adapter))) {
-    return `Agent '${input.agentName}' requested machine '${input.machine}', but generic external-cli commands cannot be remote-wrapped safely. Use claude-code, claude-code-writer, codex-exec, codex-exec-writer, cursor-agent, or cursor-agent-writer.`;
-  }
-  if (input.worktree === true) return `Agent '${input.agentName}' requested machine '${input.machine}', but managed worktrees are local git operations and cannot be combined with a Herdr saved machine.`;
-  if (process.platform === "win32") return "Herdr saved-machine pane transport requires hardened OpenSSH StreamLocal forwarding, which is not supported from a Windows host yet.";
-  return void 0;
-}
-
 // src/runs/shared/launch-cwd.ts
-import * as fs2 from "node:fs";
+import * as fs from "node:fs";
 function preflightLaunchCwd(requestedCwd, effectiveCwd) {
   const resolution = requestedCwd === effectiveCwd ? "" : `
 (resolved from ${JSON.stringify(requestedCwd)})`;
   try {
-    if (!fs2.statSync(effectiveCwd).isDirectory()) {
+    if (!fs.statSync(effectiveCwd).isDirectory()) {
       return `Subagent launch aborted: cwd is not a directory: ${effectiveCwd}${resolution}`;
     }
   } catch (error) {
@@ -1025,23 +814,23 @@ function backgroundProcessOptions(platform = process.platform) {
 }
 
 // src/runs/shared/child-launch.ts
-import * as fs4 from "node:fs";
-import * as path3 from "node:path";
+import * as fs3 from "node:fs";
+import * as path2 from "node:path";
 
 // src/extension/fanout-child.ts
-import * as fs3 from "node:fs";
+import * as fs2 from "node:fs";
 import * as os from "node:os";
-import * as path2 from "node:path";
+import * as path from "node:path";
 function getSubagentSessionRoot(parentSessionFile) {
   if (parentSessionFile) {
-    const baseName = path2.basename(parentSessionFile, ".jsonl");
-    const sessionsDir = path2.dirname(parentSessionFile);
-    return path2.join(sessionsDir, baseName);
+    const baseName = path.basename(parentSessionFile, ".jsonl");
+    const sessionsDir = path.dirname(parentSessionFile);
+    return path.join(sessionsDir, baseName);
   }
-  return fs3.mkdtempSync(path2.join(os.tmpdir(), "pi-subagent-session-"));
+  return fs2.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-session-"));
 }
 function expandTilde(p) {
-  return p.startsWith("~/") ? path2.join(os.homedir(), p.slice(2)) : p;
+  return p.startsWith("~/") ? path.join(os.homedir(), p.slice(2)) : p;
 }
 function createChildSafeState() {
   return {
@@ -1127,7 +916,7 @@ ${request.message.trim()}`,
             inboxState.pendingResults.delete(request.requestId);
             inboxState.seen.add(request.requestId);
             try {
-              fs3.unlinkSync(request.filePath);
+              fs2.unlinkSync(request.filePath);
             } catch {
             }
           } finally {
@@ -1413,12 +1202,12 @@ function childProcessEnv(input, toolPlan) {
 }
 function childStorage(input) {
   if (input.sessionFile) {
-    fs4.mkdirSync(path3.dirname(input.sessionFile), { recursive: true });
+    fs3.mkdirSync(path2.dirname(input.sessionFile), { recursive: true });
     return { kind: "file", sessionFile: input.sessionFile };
   }
   if (!input.sessionEnabled) return { kind: "memory" };
   if (input.sessionDir) {
-    fs4.mkdirSync(input.sessionDir, { recursive: true });
+    fs3.mkdirSync(input.sessionDir, { recursive: true });
     return { kind: "dir", sessionDir: input.sessionDir };
   }
   return { kind: "default" };
@@ -1472,8 +1261,8 @@ function buildInProcessChildLaunch(input) {
   let supervisorDir;
   if (input.orchestratorIntercomTarget && input.parentSessionId && input.runId) {
     supervisorDir = supervisorChannelDir(input.runId, input.childAgentName, input.childIndex);
-    fs4.mkdirSync(path3.join(supervisorDir, "requests"), { recursive: true });
-    fs4.mkdirSync(path3.join(supervisorDir, "replies"), { recursive: true });
+    fs3.mkdirSync(path2.join(supervisorDir, "requests"), { recursive: true });
+    fs3.mkdirSync(path2.join(supervisorDir, "replies"), { recursive: true });
   }
   const thinkingCeiling = intersectThinkingCeilings(input.thinkingCeiling, inherited?.thinkingCeiling);
   let structuredValue;
@@ -1558,7 +1347,8 @@ ${input.systemPrompt}` : void 0;
     requiredExtensions: toolPlan.requiredExtensions,
     ambientExtensions,
     hooks: capturedHooks.hooks,
-    ...input.host === "runner" ? { processEnv: childProcessEnv(input, toolPlan) } : {},
+    // A foreground child gets only its own bindings, so it never sees those of the session that launched it.
+    ...input.host === "runner" ? { processEnv: childProcessEnv(input, toolPlan) } : { processEnv: { [PI_SUBAGENT_EXTENSION_BINDINGS_ENV]: encodeExtensionBindings(input.extensionBindings) }, restoreProcessEnv: true },
     runtime: config,
     noSkills: !input.inheritSkills,
     noContextFiles: !input.inheritProjectContext,
@@ -1642,14 +1432,14 @@ function usageBudgetExceededMessage(state) {
 }
 
 // src/runs/background/runner-startup-failure.ts
-import * as fs5 from "node:fs";
-import * as path4 from "node:path";
+import * as fs4 from "node:fs";
+import * as path3 from "node:path";
 function persistRunnerStartupFailure(input) {
   const now = Date.now();
-  const statusPath = path4.join(input.asyncDir, "status.json");
+  const statusPath = path3.join(input.asyncDir, "status.json");
   let status = {};
   try {
-    status = JSON.parse(fs5.readFileSync(statusPath, "utf-8"));
+    status = JSON.parse(fs4.readFileSync(statusPath, "utf-8"));
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
   }
@@ -1671,7 +1461,7 @@ function persistRunnerStartupFailure(input) {
   });
   const existingCandidate = readProcessTerminalCandidate(input.asyncDir);
   const stepCount = Math.max(1, status.steps?.length ?? 0);
-  writePrivateAtomicJson(path4.join(input.asyncDir, "process-terminal-candidate.json"), {
+  writePrivateAtomicJson(path3.join(input.asyncDir, "process-terminal-candidate.json"), {
     ...existingCandidate,
     version: 1,
     runId: input.runId,
@@ -1685,19 +1475,19 @@ function persistRunnerStartupFailure(input) {
 
 // src/runs/background/chain-append.ts
 import { randomUUID } from "node:crypto";
-import * as fs6 from "node:fs";
-import * as path5 from "node:path";
+import * as fs5 from "node:fs";
+import * as path4 from "node:path";
 var APPEND_REQUESTS_DIR = "append-requests";
 function appendDir(asyncDir) {
-  return path5.join(asyncDir, APPEND_REQUESTS_DIR);
+  return path4.join(asyncDir, APPEND_REQUESTS_DIR);
 }
 function appendRequestPath(asyncDir, request) {
-  return path5.join(appendDir(asyncDir), `${request.createdAt}-${request.id}.json`);
+  return path4.join(appendDir(asyncDir), `${request.createdAt}-${request.id}.json`);
 }
 function listAppendRequestFiles(asyncDir) {
   const dir = appendDir(asyncDir);
   try {
-    return fs6.readdirSync(dir).filter((entry) => entry.endsWith(".json")).map((entry) => path5.join(dir, entry)).sort();
+    return fs5.readdirSync(dir).filter((entry) => entry.endsWith(".json")).map((entry) => path4.join(dir, entry)).sort();
   } catch (error) {
     if (error.code === "ENOENT") return [];
     throw error;
@@ -1733,7 +1523,7 @@ function enqueueChainAppendRequest(input) {
     createdAt: input.now ?? Date.now(),
     steps: input.steps
   };
-  fs6.mkdirSync(appendDir(input.asyncDir), { recursive: true });
+  fs5.mkdirSync(appendDir(input.asyncDir), { recursive: true });
   const persist = () => writeAtomicJson(appendRequestPath(input.asyncDir, request), request);
   if (input.admit) input.admit(persist);
   else persist();
@@ -1744,7 +1534,7 @@ function enqueueChainAppendRequest(input) {
   } catch (error) {
     bookkeepingErrors.push(`pending append count failed: ${error instanceof Error ? error.message : String(error)}`);
   }
-  const statusPath = path5.join(input.asyncDir, "status.json");
+  const statusPath = path4.join(input.asyncDir, "status.json");
   const updatedStatus = { ...status, pendingAppends: pendingCount, lastUpdate: request.createdAt };
   try {
     writeAtomicJson(statusPath, updatedStatus);
@@ -1752,7 +1542,7 @@ function enqueueChainAppendRequest(input) {
     bookkeepingErrors.push(`status update failed: ${error instanceof Error ? error.message : String(error)}`);
   }
   try {
-    appendJsonl(path5.join(input.asyncDir, "events.jsonl"), JSON.stringify({
+    appendJsonl(path4.join(input.asyncDir, "events.jsonl"), JSON.stringify({
       type: "subagent.chain.append.requested",
       ts: request.createdAt,
       runId: input.runId,
@@ -1766,7 +1556,7 @@ function enqueueChainAppendRequest(input) {
   return { request, pendingCount, ...bookkeepingErrors.length > 0 ? { bookkeepingError: bookkeepingErrors.join("; ") } : {} };
 }
 function readAppendRequest(filePath) {
-  const raw = JSON.parse(fs6.readFileSync(filePath, "utf-8"));
+  const raw = JSON.parse(fs5.readFileSync(filePath, "utf-8"));
   if (!raw.id || typeof raw.id !== "string") return void 0;
   const createdAt = raw.createdAt;
   if (typeof createdAt !== "number" || !Number.isFinite(createdAt)) return void 0;
@@ -1813,28 +1603,28 @@ var piPackageSelection = (() => {
 })();
 var piPackageRoot = piPackageSelection.root;
 function resolveJitiCliFromPackageJson(packageJsonPath) {
-  if (!fs7.existsSync(packageJsonPath)) return void 0;
-  const packageRoot = path6.dirname(packageJsonPath);
-  const pkg = JSON.parse(fs7.readFileSync(packageJsonPath, "utf-8"));
+  if (!fs6.existsSync(packageJsonPath)) return void 0;
+  const packageRoot = path5.dirname(packageJsonPath);
+  const pkg = JSON.parse(fs6.readFileSync(packageJsonPath, "utf-8"));
   const binField = pkg.bin;
   const binPath = typeof binField === "string" ? binField : binField?.jiti ?? Object.values(binField ?? {})[0];
   const candidates = [binPath, "lib/jiti-cli.mjs"].filter((candidate) => Boolean(candidate));
   for (const candidate of candidates) {
-    const cliPath = path6.resolve(packageRoot, candidate);
-    if (fs7.existsSync(cliPath)) return cliPath;
+    const cliPath = path5.resolve(packageRoot, candidate);
+    if (fs6.existsSync(cliPath)) return cliPath;
   }
   return void 0;
 }
 function resolveJitiCliPath() {
   const candidates = [
     () => require2.resolve("jiti/package.json"),
-    () => piPackageRoot ? nodeModule.createRequire(path6.join(piPackageRoot, "package.json")).resolve("jiti/package.json") : void 0,
+    () => piPackageRoot ? nodeModule.createRequire(path5.join(piPackageRoot, "package.json")).resolve("jiti/package.json") : void 0,
     () => {
       if (!process.argv[1]) return void 0;
-      const piEntry = fs7.realpathSync(process.argv[1]);
+      const piEntry = fs6.realpathSync(process.argv[1]);
       return nodeModule.createRequire(piEntry).resolve("jiti/package.json");
     },
-    () => piPackageRoot ? path6.join(piPackageRoot, "node_modules", "jiti", "package.json") : void 0
+    () => piPackageRoot ? path5.join(piPackageRoot, "node_modules", "jiti", "package.json") : void 0
   ];
   for (const candidate of candidates) {
     try {
@@ -1848,12 +1638,12 @@ function resolveJitiCliPath() {
   return void 0;
 }
 var jitiCliPath = resolveJitiCliPath();
-var asyncRunnerModuleDir = path6.dirname(fileURLToPath(new URL("../src/runs/background/async-execution.js", import.meta.url).href));
+var asyncRunnerModuleDir = path5.dirname(fileURLToPath(new URL("../src/runs/background/async-execution.js", import.meta.url).href));
 function asyncRunnerSourcePath() {
   return resolveRuntimeModulePath(asyncRunnerModuleDir, "subagent-runner-bootstrap");
 }
 function sourceUnderNodeModules() {
-  return asyncRunnerSourcePath().split(path6.sep).some((segment) => segment.toLowerCase() === "node_modules");
+  return asyncRunnerSourcePath().split(path5.sep).some((segment) => segment.toLowerCase() === "node_modules");
 }
 function supportsNativeRunner(nodeExecutable) {
   return Boolean(process.features.typescript) && typeof nodeModule.registerHooks === "function" && nodeExecutable === process.execPath && !sourceUnderNodeModules();
@@ -1875,25 +1665,25 @@ function resolveAsyncRunnerLogPaths(cfg) {
   const asyncDir = typeof cfg.asyncDir === "string" ? cfg.asyncDir : void 0;
   if (!asyncDir) return void 0;
   return {
-    stdoutPath: path6.join(asyncDir, "runner.stdout.log"),
-    stderrPath: path6.join(asyncDir, "runner.stderr.log")
+    stdoutPath: path5.join(asyncDir, "runner.stdout.log"),
+    stderrPath: path5.join(asyncDir, "runner.stderr.log")
   };
 }
 function closeFd(fd) {
   if (fd === void 0) return;
   try {
-    fs7.closeSync(fd);
+    fs6.closeSync(fd);
   } catch {
   }
 }
 var RUNNER_STARTUP_TIMEOUT_MS = 1e4;
 function waitForStartupInterval(delayMs = 20) {
-  return new Promise((resolve10) => setTimeout(resolve10, delayMs));
+  return new Promise((resolve9) => setTimeout(resolve9, delayMs));
 }
 function readRunnerStartup(startupPath, expectedState, expectedToken) {
-  if (!fs7.existsSync(startupPath)) return void 0;
+  if (!fs6.existsSync(startupPath)) return void 0;
   try {
-    const payload = JSON.parse(fs7.readFileSync(startupPath, "utf-8"));
+    const payload = JSON.parse(fs6.readFileSync(startupPath, "utf-8"));
     if (payload.state === "error" && typeof payload.error === "string") return { ok: false, error: payload.error, startupDidNotProceed: true };
     if (payload.state !== expectedState) return void 0;
     if (typeof payload.token !== "string" || expectedToken !== void 0 && payload.token !== expectedToken) {
@@ -1907,7 +1697,7 @@ function readRunnerStartup(startupPath, expectedState, expectedToken) {
 async function waitForRunnerStartup(startupPath, expectedState, timeoutMs, expectedToken, processClosed) {
   const confirmOpen = async (result2) => {
     if (!processClosed || result2.ok === false) return result2;
-    const outcome = await Promise.race([processClosed.then((exit) => ({ exit })), new Promise((resolve10) => setImmediate(() => resolve10(void 0)))]);
+    const outcome = await Promise.race([processClosed.then((exit) => ({ exit })), new Promise((resolve9) => setImmediate(() => resolve9(void 0)))]);
     if (!outcome) return result2;
     const finalResult2 = readRunnerStartup(startupPath, expectedState, expectedToken);
     if (finalResult2?.ok === false) return finalResult2;
@@ -2022,7 +1812,7 @@ async function completeRunnerStartupHandshake(startupPath, startupAckPath, start
     }
     const closedAtCommit = await Promise.race([
       processClosed.then((exit) => exit),
-      new Promise((resolve10) => setImmediate(() => resolve10(void 0)))
+      new Promise((resolve9) => setImmediate(() => resolve9(void 0)))
     ]);
     const observedExit = closedAtCommit ?? getObservedProcessExit();
     if (observedExit) {
@@ -2040,12 +1830,12 @@ async function completeRunnerStartupHandshake(startupPath, startupAckPath, start
       return { pid: proc.pid, runnerProcessInstanceId, error: message, terminationObserved, startupDidNotProceed: true };
     }
     try {
-      fs7.rmSync(startupPath, { force: true });
+      fs6.rmSync(startupPath, { force: true });
     } catch {
     }
     return { pid: proc.pid, runnerProcessInstanceId };
   } finally {
-    await new Promise((resolve10) => setImmediate(resolve10));
+    await new Promise((resolve9) => setImmediate(resolve9));
   }
 }
 function persistPreProceedStartupFailure(asyncDir, runId, runnerProcessInstanceId, sessionId, completionOwnerId, message) {
@@ -2080,9 +1870,9 @@ function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, launchP
   const nodeExecutable = resolveNodeExecutable();
   const nativeRunnerSupported = supportsNativeRunner(nodeExecutable);
   const runner = asyncRunnerSourcePath();
-  const runnerIsJavaScript = path6.extname(runner) === ".js";
-  const bootstrap = resolveRuntimeModulePath(path6.dirname(runner), "binary-bootstrap");
-  if (binaryHost && !fs7.existsSync(bootstrap)) return { error: `Background runner bootstrap not found: ${bootstrap}` };
+  const runnerIsJavaScript = path5.extname(runner) === ".js";
+  const bootstrap = resolveRuntimeModulePath(path5.dirname(runner), "binary-bootstrap");
+  if (binaryHost && !fs6.existsSync(bootstrap)) return { error: `Background runner bootstrap not found: ${bootstrap}` };
   if (!binaryHost && !runnerIsJavaScript && !nativeRunnerSupported && !jitiCliPath) {
     return { error: sourceUnderNodeModules() ? "Background runner source is installed under node_modules, so upstream jiti is required for TypeScript execution." : "Background runner requires enabled native TypeScript with synchronous module hooks, or installed upstream jiti for TypeScript execution." };
   }
@@ -2093,7 +1883,7 @@ function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, launchP
   if (hostPeerAliases.missing.length > 0) {
     return { error: `Background children require the host npm package (${PI_CODING_AGENT_PACKAGE}) with its dependencies; ${piPackageRoot} does not provide ${hostPeerAliases.missing.join(", ")}.` };
   }
-  fs7.mkdirSync(TEMP_ROOT_DIR, { recursive: true });
+  fs6.mkdirSync(TEMP_ROOT_DIR, { recursive: true });
   const cfgPath = getAsyncConfigPath(suffix);
   const runnerProcessInstanceId = randomUUID2();
   const hasRevivalLease = typeof cfg.revivalLease === "object";
@@ -2108,23 +1898,23 @@ function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, launchP
   const launchRunId = typeof launchForStartup.id === "string" ? launchForStartup.id : suffix;
   const launchSessionId = typeof launchForStartup.sessionId === "string" ? launchForStartup.sessionId : void 0;
   const launchCompletionOwnerId = typeof launchForStartup.completionOwnerId === "string" ? launchForStartup.completionOwnerId : void 0;
-  const startupPath = typeof launchForStartup.revivalLease === "object" && launchAsyncDir ? path6.join(launchAsyncDir, "runner-startup.json") : void 0;
-  const startupAckPath = startupPath ? path6.join(path6.dirname(startupPath), "runner-startup-ack.json") : void 0;
-  const startupConfirmPath = startupPath ? path6.join(path6.dirname(startupPath), "runner-startup-confirm.json") : void 0;
-  const startupProceedPath = launchAsyncDir && (startupPath || launchBarrierToken) ? path6.join(launchAsyncDir, "runner-startup-proceed.json") : void 0;
-  if (startupPath) fs7.rmSync(startupPath, { force: true });
-  if (startupAckPath) fs7.rmSync(startupAckPath, { force: true });
-  if (startupConfirmPath) fs7.rmSync(startupConfirmPath, { force: true });
-  if (startupProceedPath) fs7.rmSync(startupProceedPath, { force: true });
-  const identityPath = launcher && launchBarrierToken && launchAsyncDir ? path6.join(launchAsyncDir, "runner-startup.json") : void 0;
-  if (identityPath) fs7.rmSync(identityPath, { force: true });
+  const startupPath = typeof launchForStartup.revivalLease === "object" && launchAsyncDir ? path5.join(launchAsyncDir, "runner-startup.json") : void 0;
+  const startupAckPath = startupPath ? path5.join(path5.dirname(startupPath), "runner-startup-ack.json") : void 0;
+  const startupConfirmPath = startupPath ? path5.join(path5.dirname(startupPath), "runner-startup-confirm.json") : void 0;
+  const startupProceedPath = launchAsyncDir && (startupPath || launchBarrierToken) ? path5.join(launchAsyncDir, "runner-startup-proceed.json") : void 0;
+  if (startupPath) fs6.rmSync(startupPath, { force: true });
+  if (startupAckPath) fs6.rmSync(startupAckPath, { force: true });
+  if (startupConfirmPath) fs6.rmSync(startupConfirmPath, { force: true });
+  if (startupProceedPath) fs6.rmSync(startupProceedPath, { force: true });
+  const identityPath = launcher && launchBarrierToken && launchAsyncDir ? path5.join(launchAsyncDir, "runner-startup.json") : void 0;
+  if (identityPath) fs6.rmSync(identityPath, { force: true });
   let runnerIdentity;
   const terminateBeforeProceed = (pid) => !launcher ? terminateRunnerBeforeProceed(pid) : runnerIdentity !== void 0 && runnerIdentity.pidNamespaceScope === currentPidNamespaceScope() && terminateRunnerBeforeProceed(runnerIdentity.pid);
   const adoptRunnerIdentity = (pid, pidNamespaceScope) => {
     if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid < 1) return `Async runner reported an invalid process identity in '${launchAsyncDir}'.`;
     runnerIdentity = { pid, ...typeof pidNamespaceScope === "string" ? { pidNamespaceScope } : {} };
     try {
-      const status = JSON.parse(fs7.readFileSync(initialStatusPath, "utf-8"));
+      const status = JSON.parse(fs6.readFileSync(initialStatusPath, "utf-8"));
       writePrivateAtomicJson(initialStatusPath, { ...status, pid, ...runnerIdentity.pidNamespaceScope !== void 0 ? { pidNamespaceScope: runnerIdentity.pidNamespaceScope } : {} });
       return void 0;
     } catch (error) {
@@ -2136,9 +1926,9 @@ function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, launchP
   let stderrFd;
   try {
     if (logPaths) {
-      fs7.mkdirSync(path6.dirname(logPaths.stdoutPath), { recursive: true });
-      stdoutFd = fs7.openSync(logPaths.stdoutPath, "a");
-      stderrFd = fs7.openSync(logPaths.stderrPath, "a");
+      fs6.mkdirSync(path5.dirname(logPaths.stdoutPath), { recursive: true });
+      stdoutFd = fs6.openSync(logPaths.stdoutPath, "a");
+      stderrFd = fs6.openSync(logPaths.stderrPath, "a");
     }
     const preload = Object.keys(hostPeerAliases.aliases).length > 0 ? ["--import", new URL("../../../runner-peer-preload.mjs", new URL("../src/runs/background/async-execution.js", import.meta.url).href).href] : [];
     const args = binaryHost ? ["--no-extensions", "--no-skills", "--no-prompt-templates", "--no-session", "--mode", "rpc", "--extension", bootstrap] : runnerIsJavaScript ? [...preload, runner, cfgPath] : nativeRunnerSupported ? [...preload, "--experimental-strip-types", runner, cfgPath] : [...preload, jitiCliPath, runner, cfgPath];
@@ -2165,10 +1955,10 @@ function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, launchP
     proc.once("exit", (exitCode, signal) => {
       observedProcessExit = { exitCode, signal };
     });
-    const processClosed = new Promise((resolve10) => {
+    const processClosed = new Promise((resolve9) => {
       proc.once("close", (exitCode, signal) => {
         observedProcessExit ??= { exitCode, signal };
-        resolve10({ exitCode, signal });
+        resolve9({ exitCode, signal });
       });
     });
     closeFd(stdoutFd);
@@ -2184,7 +1974,7 @@ function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, launchP
         if (typeof asyncDir !== "string" || typeof runId !== "string") return;
         if (launcher) {
           try {
-            writePrivateAtomicJson(path6.join(asyncDir, "launcher-close.json"), { version: 1, runId, runnerProcessInstanceId, closeObservedAt: Date.now(), exitCode, signal, ...runnerIdentity ? { runnerPid: runnerIdentity.pid } : {} });
+            writePrivateAtomicJson(path5.join(asyncDir, "launcher-close.json"), { version: 1, runId, runnerProcessInstanceId, closeObservedAt: Date.now(), exitCode, signal, ...runnerIdentity ? { runnerPid: runnerIdentity.pid } : {} });
           } catch {
           }
           if (!runnerIdentity || runnerIdentity.pidNamespaceScope !== currentPidNamespaceScope() || checkRecordedPidLiveness(runnerIdentity) !== "dead") return;
@@ -2201,7 +1991,7 @@ function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, launchP
           try {
             let status;
             try {
-              status = JSON.parse(fs7.readFileSync(path6.join(asyncDir, "status.json"), "utf-8"));
+              status = JSON.parse(fs6.readFileSync(path5.join(asyncDir, "status.json"), "utf-8"));
               status.processTerminal = persisted;
             } catch {
               status = {
@@ -2246,7 +2036,7 @@ function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, launchP
         ...launcher ? {} : { pid: proc.pid, pidNamespaceScope: currentPidNamespaceScope(), ...bootId ? { bootId } : {} },
         processTerminal: { version: 1, state: "pending", runId: initialStatus.runId, runnerProcessInstanceId }
       });
-      updateActiveRunIndex(path6.dirname(initialStatusPath), initialStatus.state, initialStatus.toolCallId);
+      updateActiveRunIndex(path5.dirname(initialStatusPath), initialStatus.state, initialStatus.toolCallId);
     } catch (error) {
       const message = `Failed to persist initial async status: ${error instanceof Error ? error.message : String(error)}`;
       if (launchAsyncDir) persistPreProceedStartupFailure(launchAsyncDir, launchRunId, runnerProcessInstanceId, launchSessionId, launchCompletionOwnerId, message);
@@ -2387,7 +2177,7 @@ function buildAsyncRunnerSteps(id, params) {
     if (error instanceof ChainOutputValidationError) return { error: error.message };
     throw error;
   }
-  const diagnosticContext = params.unknownAgentDiagnosticContext ?? unknownAgentDiagnosticContext(discoverAgents(path6.resolve(runnerCwd), "both"));
+  const diagnosticContext = params.unknownAgentDiagnosticContext ?? unknownAgentDiagnosticContext(discoverAgents(path5.resolve(runnerCwd), "both"));
   for (const s of chain) {
     const stepAgents = isParallelStep(s) ? s.parallel.map((t) => t.agent) : isDynamicParallelStep(s) ? [s.parallel.agent] : [s.agent];
     for (const agentName of stepAgents) {
@@ -2484,7 +2274,7 @@ function buildAsyncRunnerSteps(id, params) {
       stepCwd,
       ctx.cwd,
       a.skillPath,
-      a.filePath ? path6.dirname(a.filePath) : stepCwd
+      a.filePath ? path5.dirname(a.filePath) : stepCwd
     );
     if (missingSkills.includes("pi-subagents")) throw new UnavailableSubagentSkillError(UNAVAILABLE_SUBAGENT_SKILL_ERROR);
     const systemPrompt = buildEffectiveSystemPrompt({ agent: a, resolvedSkills, cwd: stepCwd });
@@ -2657,7 +2447,7 @@ function buildAsyncRunnerSteps(id, params) {
       acceptanceRole: a.acceptanceRole,
       ...s.gateOn ? { gateOn: s.gateOn } : {},
       ...behavior.outputSchema ? { structuredOutputSchema: behavior.outputSchema } : {},
-      ...behavior.outputSchema ? { structuredOutput: createStructuredOutputRuntime(behavior.outputSchema, path6.join(asyncDir, "structured-output"), { acceptanceReport: resolveAcceptanceReportMode(s.acceptance) }) } : {},
+      ...behavior.outputSchema ? { structuredOutput: createStructuredOutputRuntime(behavior.outputSchema, path5.join(asyncDir, "structured-output"), { acceptanceReport: resolveAcceptanceReportMode(s.acceptance) }) } : {},
       ...resolvedToolBudget.budget ? { toolBudget: resolvedToolBudget.budget } : {},
       ...s.worktree ? { worktree: true } : {}
     };
@@ -2834,11 +2624,11 @@ function executeAsyncChain(id, params) {
   const capabilityCeiling = params.capabilityCeiling ?? resolveCurrentSubagentCapabilityCeiling(ctx.currentSessionId);
   const inheritedNestedRoute2 = inheritedNestedRouteOf(ctx.childRuntime);
   const nestedAddress = inheritedNestedRoute2 ? inheritedNestedParentAddressOf(ctx.childRuntime) : void 0;
-  const asyncDir = inheritedNestedRoute2 ? path6.join(TEMP_ROOT_DIR, "nested-subagent-runs", inheritedNestedRoute2.rootRunId, id) : path6.join(DIRS.async, id);
+  const asyncDir = inheritedNestedRoute2 ? path5.join(TEMP_ROOT_DIR, "nested-subagent-runs", inheritedNestedRoute2.rootRunId, id) : path5.join(DIRS.async, id);
   let runFanoutBudget;
   try {
     runFanoutBudget = params.runFanoutBudget ?? createRunFanoutBudget(id, 64);
-    fs7.mkdirSync(asyncDir, { recursive: true });
+    fs6.mkdirSync(asyncDir, { recursive: true });
     writeRunFanoutBudgetDescriptor(asyncDir, runFanoutBudget);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -2864,9 +2654,9 @@ function executeAsyncChain(id, params) {
     sessionFilesByFlatIndex,
     thinkingOverridesByFlatIndex,
     contextForAgent: params.contextForAgent,
-    progressDir: params.progressDir ?? (artifactsDir ? path6.join(artifactsDir, "progress", id) : resultMode === "parallel" ? path6.join(asyncDir, "progress") : void 0),
+    progressDir: params.progressDir ?? (artifactsDir ? path5.join(artifactsDir, "progress", id) : resultMode === "parallel" ? path5.join(asyncDir, "progress") : void 0),
     agentContract: params.agentContract,
-    outputBaseDir: artifactsDir ? path6.join(artifactsDir, "outputs", id) : void 0,
+    outputBaseDir: artifactsDir ? path5.join(artifactsDir, "outputs", id) : void 0,
     dynamicFanoutMaxItems: params.dynamicFanoutMaxItems,
     maxSubagentDepth,
     waitToolEnabled: params.waitToolEnabled,
@@ -2887,7 +2677,7 @@ function executeAsyncChain(id, params) {
   });
   if ("error" in built) {
     try {
-      fs7.rmSync(asyncDir, { recursive: true, force: true });
+      fs6.rmSync(asyncDir, { recursive: true, force: true });
     } catch {
     }
     return formatAsyncStartError(resultMode, built.error);
@@ -2927,7 +2717,7 @@ function executeAsyncChain(id, params) {
   try {
     writeRetainedRequiredChildExtensions(asyncDir, params.requiredExtensions ?? ctx.childRuntime?.requiredExtensions ?? resolveRequiredChildExtensions(launchParentSessionId ?? void 0));
   } catch (error) {
-    fs7.rmSync(asyncDir, { recursive: true, force: true });
+    fs6.rmSync(asyncDir, { recursive: true, force: true });
     return formatAsyncStartError(resultMode, `Failed to record required child extensions: ${error instanceof Error ? error.message : String(error)}`);
   }
   let spawnResultOrPromise = {};
@@ -2943,7 +2733,7 @@ function executeAsyncChain(id, params) {
         artifactsDir: artifactConfig.enabled ? artifactsDir : void 0,
         artifactConfig,
         share: shareEnabled,
-        sessionDir: sessionRoot ? path6.join(sessionRoot, `async-${id}`) : void 0,
+        sessionDir: sessionRoot ? path5.join(sessionRoot, `async-${id}`) : void 0,
         asyncDir,
         sessionId: ctx.currentSessionId,
         completionOwnerId: ctx.completionOwnerId ?? currentCompletionOwnerId(),
@@ -3000,7 +2790,7 @@ function executeAsyncChain(id, params) {
         ...launcher ? { launcher } : {},
         steps: initialStatusSteps
       },
-      path6.join(asyncDir, "status.json"),
+      path5.join(asyncDir, "status.json"),
       launchParentSessionId,
       (proof) => emitProcessTerminalEvent(ctx, proof),
       (runnerProcessInstanceId) => params.activeAsyncCapacity?.markStarted(runnerProcessInstanceId)
@@ -3123,7 +2913,7 @@ function executeAsyncChain(id, params) {
   return spawnResultOrPromise instanceof Promise ? spawnResultOrPromise.then(finishSpawnResult) : finishSpawnResult(spawnResultOrPromise);
 }
 function workflowAwaitedAsyncResultPath(asyncDir) {
-  return path6.join(asyncDir, "workflow-result.json");
+  return path5.join(asyncDir, "workflow-result.json");
 }
 function executeAsyncSingle(id, params) {
   const {
@@ -3193,6 +2983,7 @@ function executeAsyncSingle(id, params) {
   const requestedMachine = params.machine ?? agentConfig.machine;
   const machineUnsupported = formatHerdrMachineRunnerUnsupported({ machine: requestedMachine, agentName: agentConfig.name, runnerType: agentConfig.runner?.type, adapter: agentConfig.runner?.type === "external-cli" ? agentConfig.runner.adapter : void 0, worktree: params.worktree });
   if (machineUnsupported) return formatAsyncStartError("single", machineUnsupported);
+  if (requestedMachine && params.revivalLease) return formatAsyncStartError("single", PLACED_RESTORE_UNSUPPORTED);
   const resolvedLauncher = resolveAgentRunnerLauncher(agentConfig, ctx.runnerLaunchers, requestedMachine);
   if (resolvedLauncher.error) return formatAsyncStartError("single", resolvedLauncher.error);
   const launcher = resolvedLauncher.launcher;
@@ -3231,16 +3022,16 @@ function executeAsyncSingle(id, params) {
     runnerCwd,
     ctx.cwd,
     agentConfig.skillPath,
-    agentConfig.filePath ? path6.dirname(agentConfig.filePath) : runnerCwd
+    agentConfig.filePath ? path5.dirname(agentConfig.filePath) : runnerCwd
   );
   if (missingSkills.includes("pi-subagents")) return formatAsyncStartError("single", UNAVAILABLE_SUBAGENT_SKILL_ERROR);
   const inheritedNestedRoute2 = inheritedNestedRouteOf(ctx.childRuntime);
   const nestedAddress = inheritedNestedRoute2 ? inheritedNestedParentAddressOf(ctx.childRuntime) : void 0;
-  const asyncDir = inheritedNestedRoute2 ? path6.join(TEMP_ROOT_DIR, "nested-subagent-runs", inheritedNestedRoute2.rootRunId, id) : path6.join(DIRS.async, id);
+  const asyncDir = inheritedNestedRoute2 ? path5.join(TEMP_ROOT_DIR, "nested-subagent-runs", inheritedNestedRoute2.rootRunId, id) : path5.join(DIRS.async, id);
   let runFanoutBudget;
   try {
     runFanoutBudget = params.runFanoutBudget ?? createRunFanoutBudget(id, 64);
-    fs7.mkdirSync(asyncDir, { recursive: true });
+    fs6.mkdirSync(asyncDir, { recursive: true });
     writeRunFanoutBudgetDescriptor(asyncDir, runFanoutBudget);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -3251,14 +3042,14 @@ function executeAsyncSingle(id, params) {
     };
   }
   const effectiveOutput = normalizeSingleOutputOverride(params.output, agentConfig.output);
-  const outputPath = resolveSingleOutputPath(effectiveOutput, ctx.cwd, instructionCwd, params.outputBaseDir ?? (artifactsDir ? path6.join(artifactsDir, "outputs", id) : void 0));
+  const outputPath = resolveSingleOutputPath(effectiveOutput, ctx.cwd, instructionCwd, params.outputBaseDir ?? (artifactsDir ? path5.join(artifactsDir, "outputs", id) : void 0));
   const systemPrompt = buildEffectiveSystemPrompt({ agent: agentConfig, resolvedSkills, cwd: runnerCwd });
   const outputMode = params.outputMode ?? agentConfig.outputMode ?? "inline";
   const validationError = validateFileOnlyOutputMode(outputMode, outputPath, `Async single run (${agent})`);
   if (validationError) return formatAsyncStartError("single", validationError);
   const taskWithOutputInstruction = injectSingleOutputInstruction(task, outputPath, agentConfig);
   const reads = params.reads !== void 0 ? params.reads : agentConfig.defaultReads ?? false;
-  const readPaths = Array.isArray(reads) ? machine ? externalRunner ? reads.map((read) => read === "~" || read.startsWith("~/") || path6.posix.isAbsolute(read) ? read : path6.posix.resolve(instructionCwd, read)) : [] : managedWorktreeProvider === "worktrunk" ? resolveExistingReadInstructionPaths(reads, instructionCwd, readExistenceCwd) : resolveExistingReadPaths(reads, readExistenceCwd) : [];
+  const readPaths = Array.isArray(reads) ? machine ? externalRunner ? reads.map((read) => read === "~" || read.startsWith("~/") || path5.posix.isAbsolute(read) ? read : path5.posix.resolve(instructionCwd, read)) : [] : managedWorktreeProvider === "worktrunk" ? resolveExistingReadInstructionPaths(reads, instructionCwd, readExistenceCwd) : resolveExistingReadPaths(reads, readExistenceCwd) : [];
   const readsInstruction = readPaths.length > 0 ? `[Read from: ${readPaths.join(", ")}]
 
 ` : "";
@@ -3330,8 +3121,8 @@ function executeAsyncSingle(id, params) {
   if (resolvedToolTimeout.error) return formatAsyncStartError("single", resolvedToolTimeout.error);
   const toolTimeoutMs = resolvedToolTimeout.toolTimeoutMs;
   const initialUsageBudget = usageBudgetState(params.usageBudget, void 0);
-  const resolvedSessionDir = params.sessionDir ?? (sessionRoot ? path6.join(sessionRoot, `async-${id}`) : void 0);
-  const structuredOutput = params.structuredOutputSchema ? createStructuredOutputRuntime(params.structuredOutputSchema, path6.join(asyncDir, "structured-output"), { acceptanceReport: resolveAcceptanceReportMode(params.acceptance) }) : void 0;
+  const resolvedSessionDir = params.sessionDir ?? (sessionRoot ? path5.join(sessionRoot, `async-${id}`) : void 0);
+  const structuredOutput = params.structuredOutputSchema ? createStructuredOutputRuntime(params.structuredOutputSchema, path5.join(asyncDir, "structured-output"), { acceptanceReport: resolveAcceptanceReportMode(params.acceptance) }) : void 0;
   let selectedModel = model;
   let requestedModel;
   if (!externalRunner) {
@@ -3454,7 +3245,7 @@ function executeAsyncSingle(id, params) {
   };
   if (!externalRunner) {
     try {
-      writePrivateAtomicJson(path6.join(asyncDir, "recovery-descriptor.json"), recoveryDescriptor);
+      writePrivateAtomicJson(path5.join(asyncDir, "recovery-descriptor.json"), recoveryDescriptor);
     } catch (error) {
       return formatAsyncStartError("single", `Failed to persist async recovery descriptor for '${id}': ${error instanceof Error ? error.message : String(error)}`);
     }
@@ -3601,7 +3392,7 @@ function executeAsyncSingle(id, params) {
         ...launcher ? { launcher } : {},
         steps: [{ agent, status: "pending", ...lane ? { lane } : {}, ...model ? { model } : {}, ...contextLimit !== void 0 ? { contextLimit } : {} }]
       },
-      path6.join(asyncDir, "status.json"),
+      path5.join(asyncDir, "status.json"),
       launchParentSessionId,
       (proof) => emitProcessTerminalEvent(ctx, proof),
       (runnerProcessInstanceId) => params.activeAsyncCapacity?.markStarted(runnerProcessInstanceId),
@@ -3809,10 +3600,10 @@ function lineFromCheck(label, check) {
 }
 function formatExistingDirectory(label, dirPath) {
   try {
-    if (!fs8.existsSync(dirPath)) return `- ${label}: missing (${dirPath})`;
-    const stats = fs8.statSync(dirPath);
+    if (!fs7.existsSync(dirPath)) return `- ${label}: missing (${dirPath})`;
+    const stats = fs7.statSync(dirPath);
     if (!stats.isDirectory()) throw new Error(`not a directory: ${dirPath}`);
-    fs8.accessSync(dirPath, fs8.constants.R_OK | fs8.constants.W_OK);
+    fs7.accessSync(dirPath, fs7.constants.R_OK | fs7.constants.W_OK);
     return `- ${label}: ok (${dirPath})`;
   } catch (error) {
     return `- ${label}: failed (${dirPath}) \u2014 ${errorText(error)}`;
@@ -3840,10 +3631,10 @@ function formatSkillSourceCounts(skills) {
 }
 function formatConfiguredSessionDir(input) {
   if (input.requestedSessionDir) {
-    return path7.resolve(input.expandTilde?.(input.requestedSessionDir) ?? input.requestedSessionDir);
+    return path6.resolve(input.expandTilde?.(input.requestedSessionDir) ?? input.requestedSessionDir);
   }
   if (input.config.defaultSessionDir) {
-    return path7.resolve(input.expandTilde?.(input.config.defaultSessionDir) ?? input.config.defaultSessionDir);
+    return path6.resolve(input.expandTilde?.(input.config.defaultSessionDir) ?? input.config.defaultSessionDir);
   }
   return "not configured";
 }
@@ -3852,7 +3643,7 @@ function formatSessionLines(input) {
   const lines = [
     lineFromCheck("configured session dir", () => `- configured session dir: ${formatConfiguredSessionDir(input)}`),
     `- current session file: ${sessionFile ?? "not available"}`,
-    `- current session dir: ${sessionFile ? path7.dirname(sessionFile) : "not available"}`,
+    `- current session dir: ${sessionFile ? path6.dirname(sessionFile) : "not available"}`,
     `- current session id: ${input.currentSessionId ?? input.state.currentSessionId ?? "not available"}`
   ];
   if (input.sessionError) lines.push(`- session manager: failed \u2014 ${input.sessionError}`);
@@ -3987,8 +3778,7 @@ var WORKFLOW_FENCE = /^```(?:js|javascript) workflow[ \t]*$/;
 var PLAIN_JS_FENCE = /^```(?:js|javascript)[ \t]*$/;
 var OPEN_FENCE = /^(`{3,}|~{3,})/;
 var CLOSE_FENCE = /^(`{3,}|~{3,})[ \t]*$/;
-var SUMMARY_NOTE = 'On some models, text written after a tool call in the same turn reaches the session only as a summary without code blocks, so for the rest of this turn write the script to a file and pass its path, such as workflow: "./script.js".';
-var FILE_FALLBACK = `If the block is in your reply: ${SUMMARY_NOTE}`;
+var SUMMARY_NOTE = `On some hosts, text written after a tool call in the same turn reaches the session only as a summary without code blocks, so for the rest of this turn pass the script's source as a tool argument: options: { script: "..." } in place of workflow: true, with the call's other fields unchanged.`;
 function readReplyWorkflowScript(sessionManager, toolCallId) {
   const branch = sessionManager.getBranch();
   for (let index = branch.length - 1; index >= 0; index--) {
@@ -4011,7 +3801,7 @@ function scriptFromReply(content) {
   const blocks = tagged.length > 0 ? tagged : plain.length === 1 ? plain : [];
   if (blocks.length !== 1) {
     const untagged = tagged.length === 0 && plain.length > 1 ? ` This reply has ${plain.length} untagged js blocks; open the script's block with the line "\`\`\`js workflow".` : "";
-    return { error: `workflow: true needs one fenced block in the same reply as the tool call, opened with the exact line "\`\`\`js workflow" and closed with "\`\`\`"; found ${tagged.length}.${untagged} ${FILE_FALLBACK}` };
+    return { error: `workflow: true needs one fenced block in the same reply as the tool call, opened with the exact line "\`\`\`js workflow" and closed with "\`\`\`"; found ${tagged.length}.${untagged} If the block is in your reply: ${SUMMARY_NOTE}` };
   }
   const script = blocks[0];
   if (!script.trim()) return { error: "The script's fenced block in this reply is empty." };
@@ -4038,14 +3828,14 @@ function workflowBlocks(text) {
 }
 
 // src/runs/foreground/execution.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync6, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "node:fs";
-import * as path11 from "node:path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync6, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import * as path10 from "node:path";
 
 // src/shared/fork-session-cwd.ts
-import * as fs9 from "node:fs";
-import * as path8 from "node:path";
+import * as fs8 from "node:fs";
+import * as path7 from "node:path";
 function alignForkedSessionCwd(sessionFile, cwd) {
-  const lines = fs9.readFileSync(sessionFile, "utf-8").split("\n").filter((line) => line.trim().length > 0);
+  const lines = fs8.readFileSync(sessionFile, "utf-8").split("\n").filter((line) => line.trim().length > 0);
   const entries = lines.map((line, index) => {
     try {
       return JSON.parse(line);
@@ -4056,16 +3846,16 @@ function alignForkedSessionCwd(sessionFile, cwd) {
   });
   const header = entries[0];
   if (header?.type !== "session") throw new Error(`Forked session ${sessionFile} does not start with a session header.`);
-  const effectiveCwd = fs9.realpathSync.native(path8.resolve(cwd));
+  const effectiveCwd = fs8.realpathSync.native(path7.resolve(cwd));
   if (header.cwd === effectiveCwd) return;
   header.cwd = effectiveCwd;
-  fs9.writeFileSync(sessionFile, `${entries.map((entry) => JSON.stringify(entry)).join("\n")}
+  fs8.writeFileSync(sessionFile, `${entries.map((entry) => JSON.stringify(entry)).join("\n")}
 `, "utf-8");
 }
 
 // src/shared/child-transcript.ts
-import * as fs10 from "node:fs";
-import * as path9 from "node:path";
+import * as fs9 from "node:fs";
+import * as path8 from "node:path";
 var MAX_TOOL_PAYLOAD_BYTES = 32 * 1024;
 var TOOL_PAYLOAD_TRUNCATION_MARKER = "\n\n\u2026 payload truncated";
 function boundedPayload(value, maxBytes = MAX_TOOL_PAYLOAD_BYTES) {
@@ -4142,7 +3932,7 @@ function createChildTranscriptWriter(input) {
     const markerBytes = Buffer.byteLength(marker, "utf-8");
     if (bytesWritten + markerBytes > maxBytes) return false;
     try {
-      fs10.appendFileSync(input.transcriptPath, marker, "utf-8");
+      fs9.appendFileSync(input.transcriptPath, marker, "utf-8");
       bytesWritten += markerBytes;
       return true;
     } catch (error) {
@@ -4170,15 +3960,15 @@ function createChildTranscriptWriter(input) {
       return;
     }
     try {
-      fs10.appendFileSync(input.transcriptPath, line, "utf-8");
+      fs9.appendFileSync(input.transcriptPath, line, "utf-8");
       bytesWritten += bytes;
     } catch (error) {
       writeError = `Failed to write child transcript '${input.transcriptPath}': ${errorMessage(error)}`;
     }
   };
   try {
-    fs10.mkdirSync(path9.dirname(input.transcriptPath), { recursive: true });
-    fs10.writeFileSync(input.transcriptPath, "", "utf-8");
+    fs9.mkdirSync(path8.dirname(input.transcriptPath), { recursive: true });
+    fs9.writeFileSync(input.transcriptPath, "", "utf-8");
   } catch (error) {
     writeError = `Failed to initialize child transcript '${input.transcriptPath}': ${errorMessage(error)}`;
   }
@@ -4300,7 +4090,7 @@ ${text}`;
 }
 
 // src/shared/jsonl-writer.ts
-import * as fs11 from "node:fs";
+import * as fs10 from "node:fs";
 var DEFAULT_MAX_JSONL_BYTES = 50 * 1024 * 1024;
 function createJsonlWriter(filePath, source, deps = {}) {
   if (!filePath) {
@@ -4311,7 +4101,7 @@ function createJsonlWriter(filePath, source, deps = {}) {
       }
     };
   }
-  const createWriteStream3 = deps.createWriteStream ?? ((targetPath) => fs11.createWriteStream(targetPath, { flags: "a" }));
+  const createWriteStream3 = deps.createWriteStream ?? ((targetPath) => fs10.createWriteStream(targetPath, { flags: "a" }));
   let stream;
   try {
     stream = createWriteStream3(filePath);
@@ -4361,15 +4151,15 @@ function createJsonlWriter(filePath, source, deps = {}) {
       closed = true;
       const current = stream;
       stream = void 0;
-      await new Promise((resolve10) => current.end(() => resolve10()));
+      await new Promise((resolve9) => current.end(() => resolve9()));
     }
   };
 }
 
 // src/runs/shared/orca-progress-tabs.ts
 import { spawn as spawn2 } from "node:child_process";
-import * as fs12 from "node:fs";
-import * as path10 from "node:path";
+import * as fs11 from "node:fs";
+import * as path9 from "node:path";
 import { createHash, randomUUID as randomUUID3 } from "node:crypto";
 var ORCA_CREATE_TIMEOUT_MS = 2e4;
 var ORCA_KILL_GRACE_MS = 2e3;
@@ -4414,10 +4204,10 @@ var ORCA_CLEANUP_WATCHDOG_SCRIPT = [
 ].join("");
 function executableFile(candidate) {
   try {
-    const stats = fs12.statSync(candidate);
+    const stats = fs11.statSync(candidate);
     if (!stats.isFile()) return false;
     if (process.platform === "win32") return true;
-    fs12.accessSync(candidate, fs12.constants.X_OK);
+    fs11.accessSync(candidate, fs11.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -4431,9 +4221,9 @@ function executableNames(command, env) {
 function resolveOrcaCommand(env = process.env) {
   const override = env.PI_SUBAGENT_ORCA_BINARY?.trim();
   if (override) return executableFile(override) ? override : void 0;
-  for (const directory of (env.PATH ?? "").split(path10.delimiter).filter(Boolean)) {
+  for (const directory of (env.PATH ?? "").split(path9.delimiter).filter(Boolean)) {
     for (const name of executableNames("orca", env)) {
-      const candidate = path10.join(directory, name);
+      const candidate = path9.join(directory, name);
       if (executableFile(candidate)) return candidate;
     }
   }
@@ -4470,15 +4260,15 @@ function viewerCommand(nodeExecutable, logPath, donePath) {
   return invocation;
 }
 function progressRoot() {
-  return path10.join(TEMP_ROOT_DIR, "orca-progress");
+  return path9.join(TEMP_ROOT_DIR, "orca-progress");
 }
 function pruneStaleProgressFiles(root, now = Date.now()) {
   try {
-    for (const entry of fs12.readdirSync(root, { withFileTypes: true })) {
+    for (const entry of fs11.readdirSync(root, { withFileTypes: true })) {
       if (!entry.isFile() || !entry.name.endsWith(".log") && !entry.name.endsWith(".done") && !entry.name.endsWith(".ready") && !entry.name.endsWith(".pending")) continue;
-      const file = path10.join(root, entry.name);
+      const file = path9.join(root, entry.name);
       try {
-        if (now - fs12.statSync(file).mtimeMs > STALE_PROGRESS_MAX_AGE_MS) fs12.rmSync(file, { force: true });
+        if (now - fs11.statSync(file).mtimeMs > STALE_PROGRESS_MAX_AGE_MS) fs11.rmSync(file, { force: true });
       } catch {
       }
     }
@@ -4491,9 +4281,9 @@ function safeSegment(value, fallback = "subagent") {
 }
 function observerManifestPath(cwd, stem) {
   try {
-    const dir = path10.join(getProjectSubagentsDir(resolveSequenceScope(cwd)), "views", "orca");
-    fs12.mkdirSync(dir, { recursive: true, mode: 448 });
-    return path10.join(dir, `${stem}.json`);
+    const dir = path9.join(getProjectSubagentsDir(resolveSequenceScope(cwd)), "views", "orca");
+    fs11.mkdirSync(dir, { recursive: true, mode: 448 });
+    return path9.join(dir, `${stem}.json`);
   } catch {
     return void 0;
   }
@@ -4501,7 +4291,7 @@ function observerManifestPath(cwd, stem) {
 function writeObserverManifest(manifestPath, manifest) {
   if (!manifestPath) return;
   try {
-    fs12.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}
+    fs11.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `, { encoding: "utf-8", mode: 384 });
   } catch {
   }
@@ -4511,18 +4301,18 @@ function sleepSync(ms) {
   Atomics.wait(signal, 0, 0, ms);
 }
 function resolveSequenceScope(cwd) {
-  let current = path10.resolve(cwd);
+  let current = path9.resolve(cwd);
   try {
-    current = fs12.realpathSync(current);
+    current = fs11.realpathSync(current);
   } catch {
   }
   while (true) {
     try {
-      if (fs12.existsSync(path10.join(current, ".git"))) return current;
+      if (fs11.existsSync(path9.join(current, ".git"))) return current;
     } catch {
     }
-    const parent = path10.dirname(current);
-    if (parent === current) return path10.resolve(cwd);
+    const parent = path9.dirname(current);
+    if (parent === current) return path9.resolve(cwd);
     current = parent;
   }
 }
@@ -4530,18 +4320,18 @@ function sequenceKey(cwd) {
   return createHash("sha256").update(resolveSequenceScope(cwd)).digest("hex").slice(0, 20);
 }
 function withSequenceLock(root, key, fn) {
-  const lockPath = path10.join(root, `counter-${key}.lock`);
+  const lockPath = path9.join(root, `counter-${key}.lock`);
   let locked = false;
   for (let attempt = 0; attempt < COUNTER_LOCK_RETRIES; attempt++) {
     try {
-      fs12.mkdirSync(lockPath, { mode: 448 });
+      fs11.mkdirSync(lockPath, { mode: 448 });
       locked = true;
       break;
     } catch (error) {
       if (error.code !== "EEXIST") break;
       try {
-        if (Date.now() - fs12.statSync(lockPath).mtimeMs > COUNTER_LOCK_STALE_MS) {
-          fs12.rmSync(lockPath, { recursive: true, force: true });
+        if (Date.now() - fs11.statSync(lockPath).mtimeMs > COUNTER_LOCK_STALE_MS) {
+          fs11.rmSync(lockPath, { recursive: true, force: true });
           continue;
         }
       } catch {
@@ -4554,7 +4344,7 @@ function withSequenceLock(root, key, fn) {
     return fn();
   } finally {
     try {
-      fs12.rmSync(lockPath, { recursive: true, force: true });
+      fs11.rmSync(lockPath, { recursive: true, force: true });
     } catch {
     }
   }
@@ -4563,18 +4353,18 @@ function predecessorMarker(pathValue) {
   if (!pathValue) return void 0;
   const ready = pathValue.endsWith(".pending") ? pathValue.replace(/\.pending$/, ".ready") : pathValue;
   const pending = ready.replace(/\.ready$/, ".pending");
-  if (fs12.existsSync(ready) || fs12.existsSync(pending)) return pending;
+  if (fs11.existsSync(ready) || fs11.existsSync(pending)) return pending;
   return void 0;
 }
 function reserveTabSequence(root, cwd) {
   const key = sequenceKey(cwd);
-  const counterPath = path10.join(root, `counter-${key}`);
-  const createDone = path10.join(root, `create-${key}-${randomUUID3()}.pending`);
+  const counterPath = path9.join(root, `counter-${key}`);
+  const createDone = path9.join(root, `create-${key}-${randomUUID3()}.pending`);
   return withSequenceLock(root, key, () => {
     let current = 0;
     let previousCreateDone;
     try {
-      const raw = fs12.readFileSync(counterPath, "utf-8");
+      const raw = fs11.readFileSync(counterPath, "utf-8");
       const [countLine, previousLine] = raw.split("\n");
       const parsed = Number.parseInt(countLine ?? "", 10);
       if (Number.isSafeInteger(parsed) && parsed >= 0) current = parsed;
@@ -4583,14 +4373,14 @@ function reserveTabSequence(root, cwd) {
     }
     const next = current + 1;
     try {
-      fs12.writeFileSync(createDone, "", { encoding: "utf-8", mode: 384 });
-      fs12.writeFileSync(counterPath, `${next}
+      fs11.writeFileSync(createDone, "", { encoding: "utf-8", mode: 384 });
+      fs11.writeFileSync(counterPath, `${next}
 ${createDone}
 `, { encoding: "utf-8", mode: 384 });
       return { sequence: next, previousCreateDone, createDone };
     } catch {
       try {
-        fs12.rmSync(createDone, { force: true });
+        fs11.rmSync(createDone, { force: true });
       } catch {
       }
       return void 0;
@@ -4612,8 +4402,8 @@ function scheduleCleanup(nodeExecutable, paths) {
 }
 function loadOrcaProgressTabsConfig() {
   try {
-    const configPath = path10.join(getAgentDir(), "extensions", "subagent", "config.json");
-    const parsed = JSON.parse(fs12.readFileSync(configPath, "utf-8"));
+    const configPath = path9.join(getAgentDir(), "extensions", "subagent", "config.json");
+    const parsed = JSON.parse(fs11.readFileSync(configPath, "utf-8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
     const value = parsed.orcaProgressTabs;
     if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
@@ -4632,7 +4422,7 @@ function createOrcaProgressTab(input) {
   const nodeExecutable = resolveNodeExecutable();
   const root = progressRoot();
   try {
-    fs12.mkdirSync(root, { recursive: true, mode: 448 });
+    fs11.mkdirSync(root, { recursive: true, mode: 448 });
   } catch {
     return void 0;
   }
@@ -4646,12 +4436,12 @@ function createOrcaProgressTab(input) {
   const tabSequence = reservation.sequence;
   const stem = `${runId}-${index}-${randomUUID3()}`;
   const stepCount = typeof input.stepCount === "number" && Number.isInteger(input.stepCount) && input.stepCount > 0 ? input.stepCount : 1;
-  const logPath = path10.join(root, `${stem}.log`);
-  const donePath = path10.join(root, `${stem}.done`);
+  const logPath = path9.join(root, `${stem}.log`);
+  const donePath = path9.join(root, `${stem}.done`);
   const title = `subagents \xB7 ${agent} \xB7 ${tabSequence}`;
   const markCreateReady = () => {
     try {
-      fs12.writeFileSync(reservation.createDone.replace(/\.pending$/, ".ready"), "");
+      fs11.writeFileSync(reservation.createDone.replace(/\.pending$/, ".ready"), "");
     } catch {
     }
   };
@@ -4663,36 +4453,36 @@ function createOrcaProgressTab(input) {
     role: "run",
     runId,
     title,
-    worktree: path10.resolve(cwd),
+    worktree: path9.resolve(cwd),
     state: "opening",
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     logPath
   });
   try {
-    fs12.writeFileSync(logPath, `pi-subagents / ${agent}
+    fs11.writeFileSync(logPath, `pi-subagents / ${agent}
 run ${runId} \xB7 ${stepCount === 1 ? "1 child" : `${stepCount} children`}
 ${"\u2500".repeat(48)}
 `, { encoding: "utf-8", mode: 384 });
-    fs12.rmSync(donePath, { force: true });
+    fs11.rmSync(donePath, { force: true });
   } catch {
     markCreateReady();
     return void 0;
   }
   let available = true;
   let truncated = false;
-  let scheduledBytes = fs12.statSync(logPath).size;
+  let scheduledBytes = fs11.statSync(logPath).size;
   const progressByteLimit = MAX_MIRROR_BYTES - MIRROR_FOOTER_RESERVE_BYTES;
-  const logStream = fs12.createWriteStream(logPath, { flags: "a", mode: 384 });
+  const logStream = fs11.createWriteStream(logPath, { flags: "a", mode: 384 });
   const failObserver = () => {
     if (!available) return;
     available = false;
     logStream.destroy();
     try {
-      fs12.rmSync(logPath, { force: true });
+      fs11.rmSync(logPath, { force: true });
     } catch {
     }
     try {
-      fs12.rmSync(donePath, { force: true });
+      fs11.rmSync(donePath, { force: true });
     } catch {
     }
   };
@@ -4713,8 +4503,8 @@ ${"\u2500".repeat(48)}
   };
   let createSettled = false;
   let resolveCreationSettled;
-  const creationSettled = new Promise((resolve10) => {
-    resolveCreationSettled = resolve10;
+  const creationSettled = new Promise((resolve9) => {
+    resolveCreationSettled = resolve9;
   });
   let cleanupPaths;
   const scheduleDeferredCleanup = () => {
@@ -4736,7 +4526,7 @@ ${"\u2500".repeat(48)}
       "terminal",
       "create",
       "--worktree",
-      `path:${path10.resolve(cwd)}`,
+      `path:${path9.resolve(cwd)}`,
       "--title",
       title,
       "--command",
@@ -4804,7 +4594,7 @@ ${"\u2500".repeat(16)} child ${index2 + 1}/${count} \xB7 ${label} ${"\u2500".rep
       let verifiedSessionFile;
       if (sessionId && sessionFile) {
         try {
-          verifiedSessionFile = fs12.realpathSync(sessionFile);
+          verifiedSessionFile = fs11.realpathSync(sessionFile);
         } catch {
         }
       }
@@ -4819,18 +4609,18 @@ ${terminalMessage}
       if (scheduledBytes + Buffer.byteLength(footer) > MAX_MIRROR_BYTES) footer = `
 ${status}
 `;
-      return new Promise((resolve10) => {
+      return new Promise((resolve9) => {
         logStream.end(footer, () => {
           if (available) {
             try {
-              fs12.writeFileSync(donePath, `${status}
+              fs11.writeFileSync(donePath, `${status}
 `, { encoding: "utf-8", mode: 384 });
             } catch {
             }
             cleanupPaths = [logPath, donePath];
             scheduleDeferredCleanup();
           }
-          resolve10();
+          resolve9();
         });
       });
     }
@@ -5456,7 +5246,7 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     childIndex: options.index ?? 0
   }) : void 0;
   const permissionRules = resolvePermissionRules(options.permissions, agent.permissions);
-  const permissionAuditPath = permissionRules && options.artifactsDir ? path11.join(options.artifactsDir, "permission-audit", `${options.runId}-${options.index ?? 0}.jsonl`) : void 0;
+  const permissionAuditPath = permissionRules && options.artifactsDir ? path10.join(options.artifactsDir, "permission-audit", `${options.runId}-${options.index ?? 0}.jsonl`) : void 0;
   let onWatchdogStatus;
   const launch = buildInProcessChildLaunch({
     machine: options.machine,
@@ -5647,7 +5437,7 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
   const childSessions = options.childSessionFactory ?? childSessionFactory();
   const partialOutput = createPartialOutputTracker();
   let childPromptFailed = false;
-  const exitCode = await new Promise((resolve10) => {
+  const exitCode = await new Promise((resolve9) => {
     const jsonlWriter = createJsonlWriter(shared.jsonlPath, { pause() {
     }, resume() {
     } });
@@ -5720,6 +5510,8 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
     let agentSettledReceived = false;
     let queuedDrainHold = false;
     let compactionStartedReceived = false;
+    let terminalAgentEndReceived = false;
+    let compactionAfterFinalOpen = false;
     let finalDrainTimer;
     let finalHardFinishTimer;
     let watchdogTailTimer;
@@ -5762,7 +5554,7 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
       if (sessionSettled || finalDrainTimer || lifecycleFinished) return;
       finalDrainTimer = setTimeout(() => {
         if (lifecycleFinished || sessionSettled) return;
-        if (capture.finalDrainHeld() || observeQueuedDrainHold()) {
+        if (capture.finalDrainHeld() || observeQueuedDrainHold() || compactionAfterFinalOpen) {
           finalDrainTimer = void 0;
           armFinalDrainTimer();
           return;
@@ -5776,9 +5568,7 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
           if (lifecycleFinished || sessionSettled) return;
           settle(void 0, true);
         }, HARD_FINISH_MS);
-        finalHardFinishTimer.unref?.();
       }, FINAL_STOP_GRACE_MS);
-      finalDrainTimer.unref?.();
     };
     function armWatchdogTail() {
       if (!cleanTerminalAssistantStopReceived && !agentSettledReceived || watchdogTailTimer || lifecycleFinished || sessionSettled) return;
@@ -5796,12 +5586,18 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
       }, childWatchdog?.watchdogTailTimeoutMs ?? 12e4);
       watchdogTailTimer.unref?.();
     }
-    const applyChildLifecycle = (action) => {
+    const applyChildLifecycle = (action, event) => {
       if (action === "cancel-drain") {
-        cleanTerminalAssistantStopReceived = false;
+        terminalAgentEndReceived = event?.type === "agent_end" && event.willRetry !== true && cleanTerminalAssistantStopReceived;
         agentSettledReceived = false;
         clearFinalDrainTimers();
         clearWatchdogTailTimer();
+        if (terminalAgentEndReceived) {
+          startFinalDrain();
+          return;
+        }
+        cleanTerminalAssistantStopReceived = false;
+        compactionAfterFinalOpen = false;
         return;
       }
       if (action === "start-drain") startFinalDrain();
@@ -5851,7 +5647,7 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
         }
         await session?.dispose();
       }).catch(() => void 0).then(() => {
-        resolve10(code);
+        resolve9(code);
       });
     };
     const drainPendingControlEvents = () => {
@@ -5883,13 +5679,13 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
     };
     const recordActiveToolCall = (event, args, now) => {
       const key = toolTimeoutCallKey(event, ++activeToolSequence);
-      const path20 = resolveCurrentPath(event.toolName, args);
+      const path19 = resolveCurrentPath(event.toolName, args);
       const active = {
         key,
         tool: event.toolName,
         args: extractToolArgsPreview(args),
         startedAt: now,
-        ...path20 !== void 0 ? { path: path20 } : {}
+        ...path19 !== void 0 ? { path: path19 } : {}
       };
       activeToolCalls.set(key, active);
       const keys = activeToolKeysByName.get(active.tool) ?? [];
@@ -6042,11 +5838,17 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
       if (evt.type === "compaction_start") {
         compactionStartedReceived = true;
         if (agentSettledReceived) afterCompactionSettlement = true;
+        if (terminalAgentEndReceived) compactionAfterFinalOpen = true;
       }
       if (evt.type === "compaction_end" && evt.willRetry === true) {
         compactionStartedReceived = false;
         afterCompactionSettlement = false;
       }
+      if (evt.type === "compaction_end" && evt.willRetry !== true && compactionAfterFinalOpen) {
+        compactionAfterFinalOpen = false;
+        clearFinalDrainTimers();
+        startFinalDrain();
+      }
       if (evt.type === "turn_start" || evt.type === "agent_start" || evt.type === "auto_retry_start") {
         queuedDrainHold = false;
       }
@@ -6073,7 +5875,7 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
         agentSettledReceived = true;
         afterCompactionSettlement = compactionStartedReceived;
       }
-      applyChildLifecycle(lifecycleAction);
+      applyChildLifecycle(lifecycleAction, evt);
       if (isChildWatchdogStatusEvent(evt)) {
         if (!childWatchdog) return;
         const next = acceptChildWatchdogEvent({
@@ -6625,7 +6427,7 @@ ${resolvedOutput.saveError}` : resolvedOutput.saveError;
 }
 function writeStructuredOutputArtifacts(runtime, value, acceptanceReport) {
   try {
-    mkdirSync6(path11.dirname(runtime.outputPath), { recursive: true });
+    mkdirSync6(path10.dirname(runtime.outputPath), { recursive: true });
     writeFileSync4(runtime.outputPath, JSON.stringify(value), { mode: 384 });
     if (runtime.acceptanceReportPath) {
       if (acceptanceReport !== void 0) writeFileSync4(runtime.acceptanceReportPath, JSON.stringify(acceptanceReport), { mode: 384 });
@@ -6655,7 +6457,7 @@ async function runSyncCompletionInner(runtimeCwd, agents, agentName, task, optio
   const childSessionName = deriveChildSessionName({ agent: agentName, task });
   const agent = agents.find((a) => a.name === agentName);
   if (!agent) {
-    const diagnosticContext = options.unknownAgentDiagnosticContext ?? unknownAgentDiagnosticContext(discoverAgents(path11.resolve(options.cwd ?? runtimeCwd), "both"));
+    const diagnosticContext = options.unknownAgentDiagnosticContext ?? unknownAgentDiagnosticContext(discoverAgents(path10.resolve(options.cwd ?? runtimeCwd), "both"));
     return redactResultPrompt(withRunContext({
       index: options.index ?? 0,
       agent: agentName,
@@ -6748,7 +6550,7 @@ async function runSyncCompletionInner(runtimeCwd, agents, agentName, task, optio
 ${acceptancePrompt}` : task;
   options.onEffectivePrompt?.(taskWithAcceptance);
   const sessionEnabled = Boolean(options.sessionFile || options.sessionDir) || shareEnabled;
-  if (options.context === "fork" && options.sessionFile && existsSync5(options.sessionFile)) {
+  if (options.context === "fork" && options.sessionFile && existsSync4(options.sessionFile)) {
     alignForkedSessionCwd(options.sessionFile, options.cwd ?? runtimeCwd);
   }
   const skillNames = options.skills ?? agent.skills ?? [];
@@ -6758,7 +6560,7 @@ ${acceptancePrompt}` : task;
     skillCwd,
     runtimeCwd,
     agent.skillPath,
-    agent.filePath ? path11.dirname(agent.filePath) : skillCwd
+    agent.filePath ? path10.dirname(agent.filePath) : skillCwd
   );
   if (skillNames.some((skill) => skill.trim() === "pi-subagents") && missingSkills.includes("pi-subagents")) {
     return redactResultPrompt(withRunContext({
@@ -6913,7 +6715,7 @@ ${PROMPT_REDACTED}; live Prompt Audit only.
       messages: attemptResult.messages ?? [],
       error: attemptResult.error,
       processSignal: attemptResult.processSignal,
-      sessionAvailable: Boolean(options.sessionFile && existsSync5(options.sessionFile)),
+      sessionAvailable: Boolean(options.sessionFile && existsSync4(options.sessionFile)),
       alreadyResumed: attemptIndex > 0,
       stopped: attemptResult.stopped || attemptResult.detached || Boolean(detachedReason) || Boolean(options.workflowChildPermitLaunch) || options.signal?.aborted,
       interrupted: attemptResult.interrupted || options.interruptSignal?.aborted,
@@ -6984,7 +6786,7 @@ ${recovery.diagnostic}` : recovery.diagnostic;
     result2.outputSaveError = result2.outputSaveError ? `${result2.outputSaveError}
 ${message}` : message;
   }
-  if (options.sessionFile && (existsSync5(options.sessionFile) || result2.messages?.length)) {
+  if (options.sessionFile && (existsSync4(options.sessionFile) || result2.messages?.length)) {
     result2.sessionFile = options.sessionFile;
   } else if (shareEnabled && options.sessionDir) {
     const sessionFile = findLatestSessionFile(options.sessionDir);
@@ -7089,8 +6891,8 @@ async function runSync(runtimeCwd, agents, agentName, task, options) {
   let activeDetachAttempt;
   let detachReadyPublished = false;
   let resolveReceipt;
-  const receipt = new Promise((resolve10) => {
-    resolveReceipt = resolve10;
+  const receipt = new Promise((resolve9) => {
+    resolveReceipt = resolve9;
   });
   const originSignal = options.signal;
   const originController = new AbortController();
@@ -7344,8 +7146,8 @@ var WATCHDOG_THINKING_VALUES = ["inherit", ...THINKING_LEVELS];
 // src/shared/pruned-fork.ts
 import { Buffer as Buffer2 } from "node:buffer";
 import { createHash as createHash2 } from "node:crypto";
-import * as fs13 from "node:fs";
-import * as path12 from "node:path";
+import * as fs12 from "node:fs";
+import * as path11 from "node:path";
 var MAX_INHERITED_SESSION_BYTES = 64 * 1024;
 var MIN_USEFUL_SPILL_BYTES = 320;
 var MAX_ITEM_SUMMARY_CHARS = 160;
@@ -7374,7 +7176,7 @@ function stableJson(value) {
   throw new Error(`Pruned fork cannot serialize ${typeof value} transcript data.`);
 }
 function readEntries(sessionFile) {
-  return fs13.readFileSync(sessionFile, "utf-8").split("\n").filter((line) => line.trim()).map((line, index) => {
+  return fs12.readFileSync(sessionFile, "utf-8").split("\n").filter((line) => line.trim()).map((line, index) => {
     try {
       const parsed = JSON.parse(line);
       if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || typeof parsed.type !== "string") throw new Error("entry must be an object with a type");
@@ -7615,17 +7417,17 @@ function prunedForkRecoveryPath(sessionFile) {
   return `${sessionFile}.pruned-recovery.json`;
 }
 function writeAtomicPrivate(filePath, content, mode) {
-  const tempFile = path12.join(path12.dirname(filePath), `.${path12.basename(filePath)}.${process.pid}.tmp`);
+  const tempFile = path11.join(path11.dirname(filePath), `.${path11.basename(filePath)}.${process.pid}.tmp`);
   try {
-    fs13.writeFileSync(tempFile, content, { encoding: "utf-8", mode });
-    fs13.chmodSync(tempFile, mode);
-    fs13.renameSync(tempFile, filePath);
+    fs12.writeFileSync(tempFile, content, { encoding: "utf-8", mode });
+    fs12.chmodSync(tempFile, mode);
+    fs12.renameSync(tempFile, filePath);
   } finally {
-    fs13.rmSync(tempFile, { force: true });
+    fs12.rmSync(tempFile, { force: true });
   }
 }
 function writeEntriesAtomic(sessionFile, entries) {
-  writeAtomicPrivate(sessionFile, serializedEntries(entries), fs13.statSync(sessionFile).mode & 511);
+  writeAtomicPrivate(sessionFile, serializedEntries(entries), fs12.statSync(sessionFile).mode & 511);
 }
 async function pruneForkSessionFile(sessionFile, summarize, options = {}) {
   const entries = readEntries(sessionFile);
@@ -7666,11 +7468,11 @@ async function pruneForkSessionFile(sessionFile, summarize, options = {}) {
   try {
     writeAtomicPrivate(recoveryPath, `${JSON.stringify(payload, null, "	")}
 `, 384);
-    const stored = JSON.parse(fs13.readFileSync(recoveryPath, "utf-8"));
+    const stored = JSON.parse(fs12.readFileSync(recoveryPath, "utf-8"));
     if (!validateRecovery(stored) || stableJson(stored) !== stableJson(payload)) throw new Error("Pruned fork stored recovery payload failed validation.");
     writeEntriesAtomic(sessionFile, entries);
   } catch (error) {
-    fs13.rmSync(recoveryPath, { force: true });
+    fs12.rmSync(recoveryPath, { force: true });
     throw error;
   }
   return true;
@@ -7719,11 +7521,11 @@ async function createPrunedForkSessionWriter(ctx, config, signal) {
 }
 
 // src/runs/foreground/async-dismiss-action.ts
-import * as fs14 from "node:fs";
-import * as path13 from "node:path";
+import * as fs13 from "node:fs";
+import * as path12 from "node:path";
 function dismissRecoveredWorkflow(state, location) {
   const asyncDir = location.asyncDir;
-  const runId = location.resolvedId ?? (asyncDir ? path13.basename(asyncDir) : "requested");
+  const runId = location.resolvedId ?? (asyncDir ? path12.basename(asyncDir) : "requested");
   if (!asyncDir) {
     return {
       content: [{ type: "text", text: `Recovered workflow '${runId}' has no disk status to dismiss.` }],
@@ -7762,7 +7564,7 @@ function dismissRecoveredWorkflow(state, location) {
   }
   let latestStatus = status;
   const resultPath = resultFilePath(DIRS.results, status.runId);
-  if (fs14.existsSync(resultPath)) {
+  if (fs13.existsSync(resultPath)) {
     const reconciled = reconcileAsyncRun(asyncDir).status;
     if (reconciled && reconciled.state !== "running") {
       return {
@@ -7774,7 +7576,7 @@ function dismissRecoveredWorkflow(state, location) {
     if (reconciled) latestStatus = reconciled;
   }
   const dismissed = { ...latestStatus, displayDismissedAt: Date.now() };
-  writeAtomicJson(path13.join(asyncDir, "status.json"), dismissed);
+  writeAtomicJson(path12.join(asyncDir, "status.json"), dismissed);
   const repaired = reconcileAsyncRun(asyncDir).status;
   if (repaired && repaired.state !== "running") {
     return {
@@ -7795,8 +7597,8 @@ function dismissRecoveredWorkflow(state, location) {
 }
 
 // src/runs/foreground/workflow-detach-reconcile.ts
-import * as fs15 from "node:fs";
-import * as path14 from "node:path";
+import * as fs14 from "node:fs";
+import * as path13 from "node:path";
 
 // src/workflows/workflow-settlement.ts
 var UNSUPPORTED_DETACHED_WORKFLOW_CONTINUATION = "unsupported-continuation: detached workflow child settled, but JavaScript workflow continuation was not persisted. Resume the workflow explicitly instead of treating the completed child as top-level workflow completion.";
@@ -8028,9 +7830,9 @@ function workflowResultChildren(status, childRunId, result2, existingResults, re
   }));
 }
 function reconcileWorkflowReceipt(status, childRunId, result2, asyncDir, resolution) {
-  const receiptRoot = path14.dirname(asyncDir);
+  const receiptRoot = path13.dirname(asyncDir);
   const receiptPath = workflowReceiptPath(receiptRoot, status.runId);
-  if (!fs15.existsSync(receiptPath)) return void 0;
+  if (!fs14.existsSync(receiptPath)) return void 0;
   const receipt = readWorkflowReceipt(receiptRoot, status.runId);
   const step = status.steps?.find((candidate) => candidate.runId === childRunId);
   const key = step?.workflowKey;
@@ -8039,13 +7841,13 @@ function reconcileWorkflowReceipt(status, childRunId, result2, asyncDir, resolut
   if (!entry) throw new Error(`Workflow receipt '${status.runId}' has no detached child key '${key}'.`);
   let resumability;
   try {
-    const target = resolveAsyncResumeTarget({ id: childRunId, dir: path14.join(DIRS.async, childRunId) }, {}, { requireSessionFile: true, sessionId: status.sessionId });
+    const target = resolveAsyncResumeTarget({ id: childRunId, dir: path13.join(DIRS.async, childRunId) }, {}, { requireSessionFile: true, sessionId: status.sessionId });
     resumability = target.kind === "revive" ? { state: "resumable" } : { state: "not-resumable", reason: "child is still running" };
   } catch (error) {
     resumability = { state: "not-resumable", reason: error instanceof Error ? error.message : String(error) };
   }
   const outputReference = result2.savedOutputPath ?? result2.outputReference?.path ?? entry.outputReference;
-  const childStatus = readStatus(path14.join(DIRS.async, childRunId));
+  const childStatus = readStatus(path13.join(DIRS.async, childRunId));
   const externalStep = childStatus?.steps?.length === 1 && childStatus.steps[0]?.runner?.type === "external-cli" ? childStatus.steps[0] : void 0;
   const externalRunner = normalizeExternalCliRunnerStatus(result2.runner?.type === "external-cli" ? result2.runner : externalStep?.runner);
   const externalProcess = result2.externalProcess ?? externalStep?.externalProcess;
@@ -8089,9 +7891,9 @@ function reconcileWorkflowReceipt(status, childRunId, result2, asyncDir, resolut
   return { receipt: next, path: writeWorkflowReceipt(asyncDir, next) };
 }
 function appendDetachedWorkflowEvent(asyncDir, event) {
-  const eventsPath = path14.join(asyncDir, "events.jsonl");
+  const eventsPath = path13.join(asyncDir, "events.jsonl");
   try {
-    fs15.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs14.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
   } catch (error) {
     console.error(`Failed to append detached workflow event '${eventsPath}':`, error);
@@ -8099,7 +7901,7 @@ function appendDetachedWorkflowEvent(asyncDir, event) {
 }
 function reconcileDetachedWorkflowChildCompletion(input) {
   const job = input.state.asyncJobs.get(input.workflowRunId);
-  const asyncDir = job?.asyncDir ?? path14.join(DIRS.async, input.workflowRunId);
+  const asyncDir = job?.asyncDir ?? path13.join(DIRS.async, input.workflowRunId);
   const status = readStatus(asyncDir);
   if (!status) return false;
   const matchingControls = input.workflowKey === void 0 ? [] : [...input.state.foregroundControls?.values() ?? []].filter(
@@ -8124,7 +7926,7 @@ function reconcileDetachedWorkflowChildCompletion(input) {
   const resultPath = resultFilePath(DIRS.results, input.workflowRunId);
   let existing;
   try {
-    const parsed = JSON.parse(fs15.readFileSync(resultPath, "utf-8"));
+    const parsed = JSON.parse(fs14.readFileSync(resultPath, "utf-8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) existing = parsed;
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
@@ -8170,7 +7972,7 @@ function reconcileDetachedWorkflowChildCompletion(input) {
     terminalOutcome: receipt?.terminalOutcome,
     eventMetadata: { reconciledFromDetachedChild: input.childRunId }
   });
-  writeAtomicJson(path14.join(asyncDir, "status.json"), plan.status);
+  writeAtomicJson(path13.join(asyncDir, "status.json"), plan.status);
   updateActiveRunIndex(asyncDir, plan.status.state, plan.status.toolCallId);
   if (job) {
     job.status = plan.status.state;
@@ -8222,14 +8024,14 @@ function reconcileDetachedWorkflowChildCompletion(input) {
 }
 
 // src/runs/background/chain-root-attachment.ts
-import * as fs16 from "node:fs";
-import * as path15 from "node:path";
+import * as fs15 from "node:fs";
+import * as path14 from "node:path";
 var TERMINAL_STATES = /* @__PURE__ */ new Set(["complete", "failed", "partial", "paused", "stopped"]);
 var TERMINAL_STEP_STATUSES = /* @__PURE__ */ new Set(["complete", "completed", "failed", "partial", "paused", "stopped"]);
 function readResultFile(resultPath) {
   let raw;
   try {
-    raw = fs16.readFileSync(resultPath, "utf-8");
+    raw = fs15.readFileSync(resultPath, "utf-8");
   } catch (error) {
     if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
       return void 0;
@@ -8241,7 +8043,7 @@ function readResultFile(resultPath) {
 function readImportedResultFile(root, status) {
   const direct = readResultFile(root.resultPath);
   if (direct || !status?.sessionId) return direct;
-  const indexedPath = resultPayloadPathForSessionRun(path15.dirname(root.resultPath), status.sessionId, root.runId);
+  const indexedPath = resultPayloadPathForSessionRun(path14.dirname(root.resultPath), status.sessionId, root.runId);
   return indexedPath ? readResultFile(indexedPath) : void 0;
 }
 function selectedStatusStep(status, index) {
@@ -8376,10 +8178,10 @@ async function waitForImportedAsyncRoot(root, options = {}) {
     } else {
       terminalSince = void 0;
     }
-    if (!status && !fs16.existsSync(root.asyncDir)) {
+    if (!status && !fs15.existsSync(root.asyncDir)) {
       throw new Error(`Attached async root '${root.runId}' directory does not exist: ${root.asyncDir}`);
     }
-    await new Promise((resolve10) => setTimeout(resolve10, pollIntervalMs));
+    await new Promise((resolve9) => setTimeout(resolve9, pollIntervalMs));
   }
 }
 function resolveAsyncRootResultPath(resultsDir, runId) {
@@ -8387,7 +8189,7 @@ function resolveAsyncRootResultPath(resultsDir, runId) {
 }
 
 // src/runs/background/await-async-run.ts
-import * as fs17 from "node:fs";
+import * as fs16 from "node:fs";
 function errorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -8395,7 +8197,7 @@ function runnerExitedWithoutResult(asyncDir, runId, resultPath) {
   const status = readStatus(asyncDir);
   if (!status || status.state !== "running" && status.state !== "queued" || typeof status.pid !== "number") return false;
   if (checkRecordedPidLiveness({ pid: status.pid, pidNamespaceScope: status.pidNamespaceScope, bootId: status.bootId }) !== "dead") return false;
-  return !fs17.existsSync(resultPath) && !(status.sessionId && resultPayloadPathForSessionRun(asyncDir, status.sessionId, runId));
+  return !fs16.existsSync(resultPath) && !(status.sessionId && resultPayloadPathForSessionRun(asyncDir, status.sessionId, runId));
 }
 async function awaitExistingAsyncRun(asyncDir, runId, signal) {
   signal.throwIfAborted();
@@ -8430,7 +8232,7 @@ function claimWorkflowAwaitedResult(asyncDir, claimant, read) {
   try {
     return withResultRunLease(asyncDir, read.runId, () => {
       if (resultSnapshotReplaced(resultPath, read)) return void 0;
-      fs17.renameSync(resultPath, claimedPath);
+      fs16.renameSync(resultPath, claimedPath);
       return claimedPath;
     });
   } catch {
@@ -8439,8 +8241,8 @@ function claimWorkflowAwaitedResult(asyncDir, claimant, read) {
 }
 
 // src/runs/background/run-status.ts
-import * as fs18 from "node:fs";
-import * as path16 from "node:path";
+import * as fs17 from "node:fs";
+import * as path15 from "node:path";
 var STRUCTURED_PREVIEW_WITH_PATH_CHARS = 500;
 function formatProcessTerminal(value) {
   if (!value) return "missing";
@@ -8450,7 +8252,7 @@ function debugProcessTerminal(asyncDir, status) {
   const expected = { runId: status.runId, runnerProcessInstanceId: status.processTerminal?.runnerProcessInstanceId };
   return {
     sidecar: readProcessTerminal(asyncDir, expected),
-    overlay: sanitizeProcessTerminal(status.processTerminal, expected, path16.join(asyncDir, "status.json"))
+    overlay: sanitizeProcessTerminal(status.processTerminal, expected, path15.join(asyncDir, "status.json"))
   };
 }
 function formatCapacityOwner(inspect) {
@@ -8484,9 +8286,9 @@ function formatRunLifecycleDebug(input) {
     "Run lifecycle debug",
     `Run: ${status.runId}`,
     `Dir: ${asyncDir}`,
-    `Status file: ${path16.join(asyncDir, "status.json")}`,
+    `Status file: ${path15.join(asyncDir, "status.json")}`,
     status.workflowReceiptPath ? `Workflow receipt: ${status.workflowReceiptPath}` : void 0,
-    `Process terminal file: ${path16.join(asyncDir, "process-terminal.json")}`,
+    `Process terminal file: ${path15.join(asyncDir, "process-terminal.json")}`,
     `Session: ${status.sessionId ?? "unknown"}`,
     `State: ${status.state}`,
     `Mode: ${status.mode}`,
@@ -8501,7 +8303,7 @@ function formatRunLifecycleDebug(input) {
   return lines.join("\n");
 }
 function hasExistingSessionFile(value) {
-  return typeof value === "string" && fs18.existsSync(value);
+  return typeof value === "string" && fs17.existsSync(value);
 }
 function formatResumeGuidance(runId, children, fallbackSessionFile, options = {}) {
   if (options.stopped) return "Resume: unavailable; stopped runs are not resumable. Start a new run instead.";
@@ -8564,9 +8366,9 @@ function externalJobFollowUpSupported(provider) {
 }
 function rememberedForegroundChildOutput(child) {
   const outputPath = child.artifactPaths?.outputPath ?? child.savedOutputPath;
-  if (outputPath && fs18.existsSync(outputPath)) {
+  if (outputPath && fs17.existsSync(outputPath)) {
     try {
-      const artifactOutput = fs18.readFileSync(outputPath, "utf-8").trim();
+      const artifactOutput = fs17.readFileSync(outputPath, "utf-8").trim();
       if (artifactOutput) return artifactOutput;
     } catch {
     }
@@ -8865,8 +8667,8 @@ No running work was terminated.` }],
       };
     }
     const effectiveRunId = status?.runId ?? resolvedId ?? "unknown";
-    const logPath = path16.join(asyncDir, `subagent-log-${effectiveRunId}.md`);
-    const eventsPath = path16.join(asyncDir, "events.jsonl");
+    const logPath = path15.join(asyncDir, `subagent-log-${effectiveRunId}.md`);
+    const eventsPath = path15.join(asyncDir, "events.jsonl");
     if (status) {
       if (params.action === "debug.run") {
         const { sidecar, overlay } = debugProcessTerminal(asyncDir, status);
@@ -8915,7 +8717,7 @@ No running work was terminated.` }],
       const updated = status.lastUpdate ? new Date(status.lastUpdate).toISOString() : "n/a";
       const statusActivityText = status.state === "running" ? formatActivityLabel(status.lastActivityAt, status.activityState) : void 0;
       const steeringText = formatSteeringSummary(status);
-      const processTerminal = readProcessTerminal(asyncDir, { runId: status.runId, runnerProcessInstanceId: status.processTerminal?.runnerProcessInstanceId }) ?? sanitizeProcessTerminal(status.processTerminal, { runId: status.runId, runnerProcessInstanceId: status.processTerminal?.runnerProcessInstanceId }, path16.join(asyncDir, "status.json"));
+      const processTerminal = readProcessTerminal(asyncDir, { runId: status.runId, runnerProcessInstanceId: status.processTerminal?.runnerProcessInstanceId }) ?? sanitizeProcessTerminal(status.processTerminal, { runId: status.runId, runnerProcessInstanceId: status.processTerminal?.runnerProcessInstanceId }, path15.join(asyncDir, "status.json"));
       const runFanoutBudgetDescriptor = readRunFanoutBudgetDescriptor(asyncDir);
       const runFanoutBudget = runFanoutBudgetDescriptor ? getRunFanoutBudgetSnapshot(runFanoutBudgetDescriptor) : status.runFanoutBudget;
       let missionId;
@@ -8951,7 +8753,7 @@ Extensions denied: ${status.capabilityCeiling.denyExtensions ? "yes" : "no"} (so
         status.parentWorkflowRunId ? `Workflow parent: ${status.parentWorkflowRunId}${status.workflowKey ? ` (${status.workflowKey})` : ""}` : void 0,
         status.mode === "workflow" && workflowReturnPreview !== void 0 ? `Return: ${workflowReturnPreview}` : void 0,
         status.mode === "workflow" && workflowEmitPreview !== void 0 ? `Latest emit: ${workflowEmitPreview}` : void 0,
-        status.mode === "workflow" && (workflowReturnPreview?.endsWith("\u2026") || workflowEmitPreview?.endsWith("\u2026")) ? `Full return value and emits: ${path16.join(asyncDir, "status.json")} (workflow.value, workflow.emits)` : void 0,
+        status.mode === "workflow" && (workflowReturnPreview?.endsWith("\u2026") || workflowEmitPreview?.endsWith("\u2026")) ? `Full return value and emits: ${path15.join(asyncDir, "status.json")} (workflow.value, workflow.emits)` : void 0,
         `Progress: ${progressLabel}`,
         ...status.mode === "workflow" ? formatWorkflowChecklistText(projectWorkflowChecklist({
           graph: status.workflowGraph,
@@ -8969,7 +8771,7 @@ Extensions denied: ${status.capabilityCeiling.denyExtensions ? "yes" : "no"} (so
         outputPath ? `Output: ${outputPath}` : void 0,
         status.parallelHandoff ? `Parallel handoff: ${status.parallelHandoff.path}` : void 0,
         reconciliation.message ? `Diagnosis: ${reconciliation.message}` : void 0,
-        reconciliation.resultPath && fs18.existsSync(reconciliation.resultPath) ? `Result: ${reconciliation.resultPath}` : void 0
+        reconciliation.resultPath && fs17.existsSync(reconciliation.resultPath) ? `Result: ${reconciliation.resultPath}` : void 0
       ].filter((line) => Boolean(line));
       const liveWorkflowControls = status.mode === "workflow" && deps.state?.currentSessionId === status.sessionId && deps.state?.workflowControllers?.has(status.runId) ? [...deps.state?.foregroundControls.values() ?? []].filter((control) => control.parentWorkflowRunId === status.runId && control.sessionId === status.sessionId && (control.activeChildren?.size ?? 0) > 0) : [];
       let hasExternalJobFollowUpHint = false;
@@ -9031,8 +8833,8 @@ Extensions denied: ${status.capabilityCeiling.denyExtensions ? "yes" : "no"} (so
           }
         }
         lines.push(...formatNestedRunStatusLines(step.children, { indent: "  ", commandHints: true, maxLines: 20 }));
-        const stepOutputPath = path16.join(asyncDir, `output-${index}.log`);
-        if (stepOutputPath !== outputPath && fs18.existsSync(stepOutputPath)) lines.push(`  Output: ${stepOutputPath}`);
+        const stepOutputPath = path15.join(asyncDir, `output-${index}.log`);
+        if (stepOutputPath !== outputPath && fs17.existsSync(stepOutputPath)) lines.push(`  Output: ${stepOutputPath}`);
         if (step.status === "running" && step.runner?.type !== "external-cli" && step.runner?.type !== "external-job" && status.mode !== "workflow") {
           lines.push(`  Intercom target: ${resolveSubagentIntercomTarget(status.runId, step.agent, index)} (if registered)`);
           lines.push(`  Steer: subagent({ action: "steer", id: "${status.runId}", message: "...", options: { index: ${index} } })`);
@@ -9065,8 +8867,8 @@ Extensions denied: ${status.capabilityCeiling.denyExtensions ? "yes" : "no"} (so
       if (status.state !== "running") {
         lines.push(allExternal ? hasExternalJobFollowUpHint ? "Resume: use the external-job follow-up hint above." : "Resume: unavailable; external runners do not persist Pi sessions." : formatResumeGuidance(status.runId, status.steps ?? [], status.sessionFile, { stopped: status.state === "stopped" || status.stopped === true, otherSession: foreign(status.sessionId) }));
       }
-      if (fs18.existsSync(logPath)) lines.push(`Log: ${logPath}`);
-      if (fs18.existsSync(eventsPath)) lines.push(`Events: ${eventsPath}`);
+      if (fs17.existsSync(logPath)) lines.push(`Log: ${logPath}`);
+      if (fs17.existsSync(eventsPath)) lines.push(`Events: ${eventsPath}`);
       return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "single", runId: status.runId, ...status.toolCallId ? { toolCallId: status.toolCallId } : {}, results: [], ...status.workflowReceiptPath ? { workflowReceiptPath: status.workflowReceiptPath } : {}, ...status.preflight ? { preflight: status.preflight } : {}, ...status.workflow?.preflightWarnings?.length ? { preflightWarnings: status.workflow.preflightWarnings } : {}, ...workflowChildren ? { workflowChildren } : {}, ...workflowTerminalProof ? { workflowTerminalProof } : {}, ...runFanoutBudget ? { runFanoutBudget } : {}, ...processTerminal ? { lifecycleStatus: { processTerminal } } : {} } };
     }
   }
@@ -9079,7 +8881,7 @@ Extensions denied: ${status.capabilityCeiling.denyExtensions ? "yes" : "no"} (so
       };
     }
     try {
-      const raw = fs18.readFileSync(resultPath, "utf-8");
+      const raw = fs17.readFileSync(resultPath, "utf-8");
       const data = JSON.parse(raw);
       if (params.view === "transcript") {
         try {
@@ -9172,16 +8974,16 @@ function applyForceTopLevelAsyncOverride(params, depth, forceTopLevelAsync) {
 
 // src/runs/shared/worktree-cleanup-apply.ts
 import { createHash as createHash5 } from "node:crypto";
-import { spawnSync as spawnSync3 } from "node:child_process";
-import * as fs20 from "node:fs";
-import * as path18 from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
+import * as fs19 from "node:fs";
+import * as path17 from "node:path";
 
 // src/runs/shared/worktree-cleanup-plan.ts
 import { createHash as createHash4, randomUUID as randomUUID4 } from "node:crypto";
-import { spawnSync as spawnSync2 } from "node:child_process";
-import * as fs19 from "node:fs";
+import { spawnSync } from "node:child_process";
+import * as fs18 from "node:fs";
 import * as os2 from "node:os";
-import * as path17 from "node:path";
+import * as path16 from "node:path";
 var WORKTREE_CLEANUP_PLAN_VERSION = 1;
 var WORKTREE_CLEANUP_PLAN_TTL_MS = 30 * 60 * 1e3;
 var MAX_DISCOVERED_HANDOFFS = 256;
@@ -9189,7 +8991,7 @@ var MAX_PLAN_ENTRIES = 512;
 var MAX_METADATA_FILE_BYTES = 2 * 1024 * 1024;
 function runGit(cwd, args) {
   try {
-    const result2 = spawnSync2("git", ["-C", cwd, ...args], { encoding: "utf-8", windowsHide: true });
+    const result2 = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8", windowsHide: true });
     return {
       stdout: result2.stdout ?? "",
       stderr: result2.stderr ?? "",
@@ -9213,7 +9015,7 @@ function runGitChecked(cwd, args) {
   if (result2.status !== 0) throw new Error(gitFailure(result2, `git -C ${cwd} ${args.join(" ")}`));
   return result2.stdout.trim();
 }
-function realpathExisting(candidate, nativeRealpath = fs19.realpathSync.native, fallbackRealpath = fs19.realpathSync) {
+function realpathExisting(candidate, nativeRealpath = fs18.realpathSync.native, fallbackRealpath = fs18.realpathSync) {
   try {
     return nativeRealpath(candidate);
   } catch {
@@ -9221,29 +9023,29 @@ function realpathExisting(candidate, nativeRealpath = fs19.realpathSync.native,
   }
 }
 function comparablePath(candidate) {
-  let current = path17.resolve(candidate);
+  let current = path16.resolve(candidate);
   const missingSegments = [];
   let canonical = current;
   while (true) {
     try {
-      canonical = path17.join(realpathExisting(current), ...missingSegments.reverse());
+      canonical = path16.join(realpathExisting(current), ...missingSegments.reverse());
       break;
     } catch {
-      const parent = path17.dirname(current);
+      const parent = path16.dirname(current);
       if (parent === current) break;
-      missingSegments.push(path17.basename(current));
+      missingSegments.push(path16.basename(current));
       current = parent;
     }
   }
-  const normalized = path17.normalize(canonical);
+  const normalized = path16.normalize(canonical);
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
 function samePath(left, right) {
   if (comparablePath(left) === comparablePath(right)) return true;
   if (process.platform !== "win32") return false;
   try {
-    const leftStat = fs19.statSync(left, { bigint: true });
-    const rightStat = fs19.statSync(right, { bigint: true });
+    const leftStat = fs18.statSync(left, { bigint: true });
+    const rightStat = fs18.statSync(right, { bigint: true });
     return leftStat.dev !== 0n && leftStat.ino !== 0n && leftStat.dev === rightStat.dev && leftStat.ino === rightStat.ino;
   } catch {
     return false;
@@ -9253,15 +9055,15 @@ function resolveExistingPath(candidate) {
   try {
     return realpathExisting(candidate);
   } catch {
-    return path17.resolve(candidate);
+    return path16.resolve(candidate);
   }
 }
 function pathInside(root, candidate, strict = false) {
   const normalizedRoot = comparablePath(root);
   const normalizedCandidate = comparablePath(candidate);
   if (!strict && normalizedRoot === normalizedCandidate) return true;
-  const relative3 = path17.relative(normalizedRoot, normalizedCandidate);
-  return relative3 !== "" && relative3 !== ".." && !relative3.startsWith(`..${path17.sep}`) && !path17.isAbsolute(relative3);
+  const relative3 = path16.relative(normalizedRoot, normalizedCandidate);
+  return relative3 !== "" && relative3 !== ".." && !relative3.startsWith(`..${path16.sep}`) && !path16.isAbsolute(relative3);
 }
 function sha2562(value) {
   return createHash4("sha256").update(value, "utf-8").digest("hex");
@@ -9273,7 +9075,7 @@ function validatePlanId(planId) {
   return planId;
 }
 function resolveCleanupRepoRoot(repo) {
-  const requested = path17.resolve(repo);
+  const requested = path16.resolve(repo);
   const toplevel = runGitChecked(requested, ["rev-parse", "--show-toplevel"]);
   return realpathExisting(toplevel);
 }
@@ -9281,17 +9083,17 @@ function resolveCleanupBaseDir(repoRoot, configuredBaseDir) {
   const raw = configuredBaseDir ?? process.env.PI_SUBAGENTS_WORKTREE_DIR;
   let dedicatedRoot;
   if (raw === void 0 || configuredBaseDir === void 0 && !raw.trim()) {
-    dedicatedRoot = path17.join(path17.dirname(repoRoot), "worktrees");
+    dedicatedRoot = path16.join(path16.dirname(repoRoot), "worktrees");
   } else {
     const trimmed = raw.trim();
     if (!trimmed) throw new Error("worktree base directory cannot be empty");
-    const expanded = trimmed.startsWith("~/") ? path17.join(os2.homedir(), trimmed.slice(2)) : trimmed;
-    dedicatedRoot = path17.isAbsolute(expanded) ? expanded : path17.resolve(repoRoot, expanded);
+    const expanded = trimmed.startsWith("~/") ? path16.join(os2.homedir(), trimmed.slice(2)) : trimmed;
+    dedicatedRoot = path16.isAbsolute(expanded) ? expanded : path16.resolve(repoRoot, expanded);
   }
-  return path17.resolve(path17.join(dedicatedRoot, path17.basename(repoRoot)));
+  return path16.resolve(path16.join(dedicatedRoot, path16.basename(repoRoot)));
 }
 function cleanupContainmentInvalid(repoRoot, projectDir) {
-  const extensionsDir = path17.join(getAgentDir(), "extensions");
+  const extensionsDir = path16.join(getAgentDir(), "extensions");
   return samePath(projectDir, repoRoot) || pathInside(repoRoot, projectDir, true) || pathInside(extensionsDir, projectDir);
 }
 function parseGitWorktreeList(raw) {
@@ -9330,14 +9132,14 @@ function isRegisteredCleanupWorktree(repoRoot, candidate) {
   return listGitWorktrees(repoRoot).some((tree) => samePath(tree.path, candidate));
 }
 function readJsonFile(filePath) {
-  return JSON.parse(fs19.readFileSync(filePath, "utf-8"));
+  return JSON.parse(fs18.readFileSync(filePath, "utf-8"));
 }
 function isRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function readManifest(manifestPath) {
   try {
-    const stat = fs19.lstatSync(manifestPath);
+    const stat = fs18.lstatSync(manifestPath);
     if (stat.isSymbolicLink() || !stat.isFile()) return { error: `parallel handoff manifest is not a regular file: ${manifestPath}` };
     if (stat.size > MAX_METADATA_FILE_BYTES) return { error: `parallel handoff manifest exceeds the ${MAX_METADATA_FILE_BYTES}-byte limit: ${manifestPath}` };
     const parsed = readParallelHandoffManifest(manifestPath);
@@ -9355,22 +9157,22 @@ function discoverHandoffPaths(repoRoot, input) {
   const paths = [];
   const warnings = [];
   const add = (candidate) => {
-    const resolved = path17.isAbsolute(candidate) ? path17.resolve(candidate) : path17.resolve(repoRoot, candidate);
+    const resolved = path16.isAbsolute(candidate) ? path16.resolve(candidate) : path16.resolve(repoRoot, candidate);
     if (!paths.some((existing) => comparablePath(existing) === comparablePath(resolved))) paths.push(resolved);
   };
   if (input.handoffPath) add(input.handoffPath);
   for (const candidate of input.handoffPaths ?? []) add(candidate);
-  const artifactsDir = path17.join(repoRoot, PROJECT_SUBAGENTS_RELATIVE_DIR, "artifacts");
-  const projectHandoffPath = path17.join(artifactsDir, "handoff.json");
-  if (fs19.existsSync(projectHandoffPath)) add(projectHandoffPath);
-  const handoffsDir = path17.join(artifactsDir, "handoffs");
+  const artifactsDir = path16.join(repoRoot, PROJECT_SUBAGENTS_RELATIVE_DIR, "artifacts");
+  const projectHandoffPath = path16.join(artifactsDir, "handoff.json");
+  if (fs18.existsSync(projectHandoffPath)) add(projectHandoffPath);
+  const handoffsDir = path16.join(artifactsDir, "handoffs");
   try {
-    const stat = fs19.lstatSync(handoffsDir);
+    const stat = fs18.lstatSync(handoffsDir);
     if (stat.isSymbolicLink() || !stat.isDirectory()) {
       warnings.push(`ignored non-directory handoff metadata root: ${handoffsDir}`);
     } else {
-      const entries = fs19.readdirSync(handoffsDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name).sort().slice(0, MAX_DISCOVERED_HANDOFFS);
-      for (const entry of entries) add(path17.join(handoffsDir, entry));
+      const entries = fs18.readdirSync(handoffsDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name).sort().slice(0, MAX_DISCOVERED_HANDOFFS);
+      for (const entry of entries) add(path16.join(handoffsDir, entry));
       if (entries.length === MAX_DISCOVERED_HANDOFFS) warnings.push(`handoff metadata discovery capped at ${MAX_DISCOVERED_HANDOFFS} files`);
     }
   } catch (error) {
@@ -9380,9 +9182,9 @@ function discoverHandoffPaths(repoRoot, input) {
   return { paths: paths.sort((left, right) => comparablePath(left).localeCompare(comparablePath(right))), warnings: [...new Set(warnings)].sort() };
 }
 function readStatusBesideManifest(manifestPath) {
-  const statusPath = path17.join(path17.dirname(manifestPath), "status.json");
+  const statusPath = path16.join(path16.dirname(manifestPath), "status.json");
   try {
-    const stat = fs19.lstatSync(statusPath);
+    const stat = fs18.lstatSync(statusPath);
     if (stat.isSymbolicLink() || !stat.isFile()) return { statusPath, error: `async status is not a regular file: ${statusPath}` };
     if (stat.size > MAX_METADATA_FILE_BYTES) return { statusPath, error: `async status exceeds the ${MAX_METADATA_FILE_BYTES}-byte limit: ${statusPath}` };
     const parsed = readJsonFile(statusPath);
@@ -9443,7 +9245,7 @@ function loadMetadata(input, repoRoot) {
       continue;
     }
     const manifestRoot = resolveExistingPath(manifestPath);
-    if (manifestRoot !== manifestPath && fs19.lstatSync(manifestPath).isSymbolicLink()) {
+    if (manifestRoot !== manifestPath && fs18.lstatSync(manifestPath).isSymbolicLink()) {
       warnings.push(`ignored symlinked handoff manifest: ${manifestPath}`);
       continue;
     }
@@ -9452,9 +9254,9 @@ function loadMetadata(input, repoRoot) {
   return { records, paths: discovered.paths, warnings: [...new Set(warnings)].sort() };
 }
 function inspectPath(candidate) {
-  const resolved = path17.resolve(candidate);
+  const resolved = path16.resolve(candidate);
   try {
-    const stat = fs19.lstatSync(resolved);
+    const stat = fs18.lstatSync(resolved);
     if (stat.isSymbolicLink()) return { resolved, missing: false, symlink: true, directory: false };
     return { resolved, realpath: realpathExisting(resolved), missing: false, symlink: false, directory: stat.isDirectory() };
   } catch (error) {
@@ -9464,7 +9266,7 @@ function inspectPath(candidate) {
   }
 }
 function metadataPath(manifestPath, candidate) {
-  return path17.isAbsolute(candidate) ? path17.resolve(candidate) : path17.resolve(path17.dirname(manifestPath), candidate);
+  return path16.isAbsolute(candidate) ? path16.resolve(candidate) : path16.resolve(path16.dirname(manifestPath), candidate);
 }
 function metadataRecordPath(record2) {
   return metadataPath(record2.manifestPath, record2.task.path);
@@ -9505,7 +9307,7 @@ function inspectRunState(record2, now, foregroundRunOwnership) {
     }
   }
   try {
-    const markerAge = activeRunMarkerAgeMs(path17.dirname(record2.statusPath), now);
+    const markerAge = activeRunMarkerAgeMs(path16.dirname(record2.statusPath), now);
     if (markerAge !== void 0) {
       if (markerAge <= DEFAULT_STALE_TERMINAL_ACTIVE_MARKER_MS) return { kind: "active", reason: "owning run still has a recent active marker" };
       return { kind: "stale", reason: `terminal active marker is stale (${Math.floor(markerAge / 1e3)}s old)` };
@@ -9566,7 +9368,7 @@ function isPatchCaptured(record2, worktreePath, baseCommit) {
   if (inspection.missing || !inspection.realpath) return { error: "captured handoff patch is missing" };
   let patchStat;
   try {
-    patchStat = fs19.statSync(patchPath);
+    patchStat = fs18.statSync(patchPath);
   } catch (error) {
     return { error: `captured patch cannot be inspected: ${error instanceof Error ? error.message : String(error)}` };
   }
@@ -9579,7 +9381,7 @@ function isPatchCaptured(record2, worktreePath, baseCommit) {
 }
 function buildManagedEntry(input) {
   const { repoRoot, baseDir, targetHead, rootPath, git, record: record2, foregroundRunOwnership } = input;
-  const gitWorktreePath = path17.resolve(git.path);
+  const gitWorktreePath = path16.resolve(git.path);
   const metadataWorktreePath = metadataRecordPath(record2);
   const worktreePath = resolveExistingPath(metadataWorktreePath);
   const entry = buildEntryBase({ path: worktreePath, branch: git.branch ?? "", source: "both", git, metadata: record2, targetHead });
@@ -9596,13 +9398,13 @@ function buildManagedEntry(input) {
   if (pathInspection.missing) return blockedEntry(entry, "stale", "unknown", "worktree path is missing from disk");
   if (pathInspection.symlink) return blockedEntry(entry, "unknown", "unknown", "worktree path is a symlink; cleanup requires a real directory");
   if (!pathInspection.directory || !pathInspection.realpath) return blockedEntry(entry, "unknown", "unknown", "worktree path is not a directory");
-  const extensionsDir = path17.join(getAgentDir(), "extensions");
+  const extensionsDir = path16.join(getAgentDir(), "extensions");
   if (pathInside(extensionsDir, pathInspection.realpath)) return blockedEntry(entry, "ineligible", "keep", `worktree real path is inside Pi extensions directory '${extensionsDir}'`);
   if (input.containmentInvalid || !pathInside(baseDir, pathInspection.realpath, true)) return blockedEntry(entry, "ineligible", "keep", `worktree real path is outside configured base directory '${baseDir}'`);
   const recordedBaseDir = record2.task.recordedBaseDir;
-  if (typeof recordedBaseDir !== "string" || !path17.isAbsolute(recordedBaseDir)) return blockedEntry(entry, "unknown", "keep", "handoff metadata has no creation-time base directory proof");
-  const creationRelative = path17.relative(recordedBaseDir, pathInspection.realpath);
-  if (!creationRelative || creationRelative === ".." || creationRelative.startsWith(`..${path17.sep}`) || path17.isAbsolute(creationRelative)) return blockedEntry(entry, "ineligible", "keep", `worktree real path is outside its creation-time recorded base directory '${recordedBaseDir}'`);
+  if (typeof recordedBaseDir !== "string" || !path16.isAbsolute(recordedBaseDir)) return blockedEntry(entry, "unknown", "keep", "handoff metadata has no creation-time base directory proof");
+  const creationRelative = path16.relative(recordedBaseDir, pathInspection.realpath);
+  if (!creationRelative || creationRelative === ".." || creationRelative.startsWith(`..${path16.sep}`) || path16.isAbsolute(creationRelative)) return blockedEntry(entry, "ineligible", "keep", `worktree real path is outside its creation-time recorded base directory '${recordedBaseDir}'`);
   if (rootPath === comparablePath(pathInspection.realpath)) return blockedEntry(entry, "ineligible", "keep", "worktree is the repository root");
   if (git.locked) return blockedEntry(entry, "ineligible", "keep", "Git worktree is locked");
   if (!git.branch) return blockedEntry(entry, "unknown", "unknown", "detached worktrees have no metadata-recorded branch");
@@ -9781,7 +9583,7 @@ function buildWorktreeCleanupPlan(input) {
   };
 }
 function worktreeCleanupPlanPath(repoRoot, planId) {
-  return path17.join(repoRoot, PROJECT_SUBAGENTS_RELATIVE_DIR, "cleanup-plans", `${validatePlanId(planId)}.json`);
+  return path16.join(repoRoot, PROJECT_SUBAGENTS_RELATIVE_DIR, "cleanup-plans", `${validatePlanId(planId)}.json`);
 }
 function createWorktreeCleanupPlan(input) {
   const plan = buildWorktreeCleanupPlan(input);
@@ -9829,13 +9631,13 @@ function formatWorktreeCleanupPlan(created) {
 
 // src/runs/shared/worktree-cleanup-apply.ts
 function assertContainedRealPath(repoRoot, candidate, create = false) {
-  const relative3 = path18.relative(repoRoot, candidate);
-  if (!relative3 || relative3 === ".." || relative3.startsWith(`..${path18.sep}`) || path18.isAbsolute(relative3)) throw new Error("Cleanup evidence must be inside the selected repository.");
+  const relative3 = path17.relative(repoRoot, candidate);
+  if (!relative3 || relative3 === ".." || relative3.startsWith(`..${path17.sep}`) || path17.isAbsolute(relative3)) throw new Error("Cleanup evidence must be inside the selected repository.");
   let current = repoRoot;
-  for (const segment of relative3.split(path18.sep)) {
-    current = path18.join(current, segment);
-    if (!fs20.existsSync(current) && create) fs20.mkdirSync(current, { mode: 448 });
-    const stat = fs20.lstatSync(current);
+  for (const segment of relative3.split(path17.sep)) {
+    current = path17.join(current, segment);
+    if (!fs19.existsSync(current) && create) fs19.mkdirSync(current, { mode: 448 });
+    const stat = fs19.lstatSync(current);
     if (stat.isSymbolicLink()) throw new Error(`Cleanup evidence cannot use a symlink: ${current}`);
   }
 }
@@ -9843,14 +9645,14 @@ function loadReviewedCleanupPlan(repo, planId, now = Date.now()) {
   const repoRoot = resolveCleanupRepoRoot(repo);
   const file = worktreeCleanupPlanPath(repoRoot, planId);
   assertContainedRealPath(repoRoot, file);
-  const stat = fs20.statSync(file);
+  const stat = fs19.statSync(file);
   if (!stat.isFile() || stat.size > 2 * 1024 * 1024) throw new Error("Cleanup plan is not a bounded regular file.");
-  const plan = JSON.parse(fs20.readFileSync(file, "utf-8"));
-  if (plan.version !== 1 || plan.planId !== planId || plan.repoRoot !== repoRoot || !Number.isFinite(plan.createdAt) || !Number.isFinite(plan.expiresAt) || plan.createdAt > now || plan.expiresAt <= now && !fs20.existsSync(file.replace(/\.json$/, ".claim")) || plan.expiresAt - plan.createdAt !== WORKTREE_CLEANUP_PLAN_TTL_MS) throw new Error("Cleanup plan is invalid, expired, or belongs to another repository.");
-  if (!Array.isArray(plan.entries) || plan.entries.length > 512 || !Array.isArray(plan.baseDirs) || plan.baseDirs.length !== 1 || !plan.baseDirs.every((item) => typeof item === "string" && path18.isAbsolute(item)) || !Array.isArray(plan.metadataPaths) || !plan.metadataPaths.every((item) => typeof item === "string" && path18.isAbsolute(item)) || !Array.isArray(plan.pruneCandidates)) throw new Error("Cleanup plan has invalid inventory fields.");
+  const plan = JSON.parse(fs19.readFileSync(file, "utf-8"));
+  if (plan.version !== 1 || plan.planId !== planId || plan.repoRoot !== repoRoot || !Number.isFinite(plan.createdAt) || !Number.isFinite(plan.expiresAt) || plan.createdAt > now || plan.expiresAt <= now && !fs19.existsSync(file.replace(/\.json$/, ".claim")) || plan.expiresAt - plan.createdAt !== WORKTREE_CLEANUP_PLAN_TTL_MS) throw new Error("Cleanup plan is invalid, expired, or belongs to another repository.");
+  if (!Array.isArray(plan.entries) || plan.entries.length > 512 || !Array.isArray(plan.baseDirs) || plan.baseDirs.length !== 1 || !plan.baseDirs.every((item) => typeof item === "string" && path17.isAbsolute(item)) || !Array.isArray(plan.metadataPaths) || !plan.metadataPaths.every((item) => typeof item === "string" && path17.isAbsolute(item)) || !Array.isArray(plan.pruneCandidates)) throw new Error("Cleanup plan has invalid inventory fields.");
   const paths = /* @__PURE__ */ new Set();
   for (const entry of plan.entries) {
-    if (!entry || typeof entry.path !== "string" || !path18.isAbsolute(entry.path) || typeof entry.branch !== "string" || !["remove", "keep", "unknown"].includes(entry.decision) || !entry.preconditions || entry.preconditions.path !== entry.path || entry.preconditions.branch !== entry.branch || !Array.isArray(entry.reasons) || !entry.reasons.every((reason) => typeof reason === "string") || paths.has(entry.path)) throw new Error("Cleanup plan has invalid or duplicate entries.");
+    if (!entry || typeof entry.path !== "string" || !path17.isAbsolute(entry.path) || typeof entry.branch !== "string" || !["remove", "keep", "unknown"].includes(entry.decision) || !entry.preconditions || entry.preconditions.path !== entry.path || entry.preconditions.branch !== entry.branch || !Array.isArray(entry.reasons) || !entry.reasons.every((reason) => typeof reason === "string") || paths.has(entry.path)) throw new Error("Cleanup plan has invalid or duplicate entries.");
     paths.add(entry.path);
   }
   const hash = createHash5("sha256").update(JSON.stringify(worktreeCleanupContentPayload(plan))).digest("hex");
@@ -9860,7 +9662,7 @@ function loadReviewedCleanupPlan(repo, planId, now = Date.now()) {
 function recordRemoval(entry) {
   const manifest = readParallelHandoffManifest(entry.handoffPath);
   if (!manifest || manifest.runId !== entry.runId) throw new Error("Handoff ownership changed before recording removal.");
-  const tasks = manifest.groups.flatMap((group) => group.cleanup.tasks).filter((task) => task.index === entry.taskIndex && samePath(path18.resolve(path18.dirname(entry.handoffPath), task.path), entry.path) && task.branch === entry.branch);
+  const tasks = manifest.groups.flatMap((group) => group.cleanup.tasks).filter((task) => task.index === entry.taskIndex && samePath(path17.resolve(path17.dirname(entry.handoffPath), task.path), entry.path) && task.branch === entry.branch);
   if (tasks.length !== 1) throw new Error("Handoff task no longer identifies exactly one removed worktree.");
   if (tasks[0].worktreeRemoved) return;
   tasks[0].worktreeRemoved = true;
@@ -9875,20 +9677,20 @@ async function applyReviewedCleanupPlan(input) {
   return withWorktreeTransaction(() => withRepositoryWorktreeLock(input.repo, async () => {
     const plan = loadReviewedCleanupPlan(input.repo, input.planId);
     const claimPath = worktreeCleanupPlanPath(plan.repoRoot, plan.planId).replace(/\.json$/, ".claim");
-    const receiptPath = path18.join(claimPath, "receipt.json");
-    assertContainedRealPath(plan.repoRoot, path18.dirname(claimPath));
+    const receiptPath = path17.join(claimPath, "receipt.json");
+    assertContainedRealPath(plan.repoRoot, path17.dirname(claimPath));
     try {
-      fs20.mkdirSync(claimPath, { mode: 448 });
+      fs19.mkdirSync(claimPath, { mode: 448 });
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
       assertContainedRealPath(plan.repoRoot, receiptPath);
-      const receipt2 = JSON.parse(fs20.readFileSync(receiptPath, "utf-8"));
+      const receipt2 = JSON.parse(fs19.readFileSync(receiptPath, "utf-8"));
       if (receipt2.version !== 1 || receipt2.planId !== plan.planId || receipt2.repoRoot !== plan.repoRoot || receipt2.contentHash !== plan.contentHash || !Array.isArray(receipt2.entries) || !["applying", "complete", "partial"].includes(receipt2.state)) throw new Error("Claimed cleanup plan has an invalid receipt; inspect it before creating a fresh plan.");
       for (const entry of plan.entries.filter((entry2) => receipt2.state !== "complete" && entry2.decision === "remove" && receipt2.entries.some((item) => (item?.state === "removing" || item?.state === "removed") && item.path === entry2.path && item.branch === entry2.branch))) {
-        await new Promise((resolve10) => setImmediate(resolve10));
+        await new Promise((resolve9) => setImmediate(resolve9));
         input.signal?.throwIfAborted();
         try {
-          fs20.lstatSync(entry.path);
+          fs19.lstatSync(entry.path);
           continue;
         } catch (error2) {
           if (error2.code !== "ENOENT") throw error2;
@@ -9910,7 +9712,7 @@ async function applyReviewedCleanupPlan(input) {
     try {
       const selected = input.select?.(plan);
       for (const entry of plan.entries.filter((item) => item.decision === "remove")) {
-        await new Promise((resolve10) => setImmediate(resolve10));
+        await new Promise((resolve9) => setImmediate(resolve9));
         input.signal?.throwIfAborted();
         if (selected && !selected.has(entry.path)) {
           receipt.entries.push({ path: entry.path, branch: entry.branch, state: "kept", reason: "outside the current retention excess" });
@@ -9920,7 +9722,7 @@ async function applyReviewedCleanupPlan(input) {
             withHandoffWriteLock(entry.handoffPath, () => {
               const manifest = readParallelHandoffManifest(entry.handoffPath);
               if (!manifest || manifest.runId !== entry.runId) throw new Error("Handoff ownership changed before cleanup validation.");
-              const fresh = buildWorktreeCleanupPlan({ repo: plan.repoRoot, candidatePaths: [entry.path], handoffPaths: plan.metadataPaths, worktreeBaseDir: path18.dirname(plan.baseDirs[0]), foregroundRunOwnership: input.foregroundRunOwnership });
+              const fresh = buildWorktreeCleanupPlan({ repo: plan.repoRoot, candidatePaths: [entry.path], handoffPaths: plan.metadataPaths, worktreeBaseDir: path17.dirname(plan.baseDirs[0]), foregroundRunOwnership: input.foregroundRunOwnership });
               const candidate = fresh.entries.find((item) => item.path === entry.path);
               if (fresh.warnings?.some((warning) => /capped|failed to inspect/.test(warning)) || !candidate || candidate.decision !== "remove" || candidate.handoffPath !== entry.handoffPath || candidate.runId !== entry.runId || candidate.taskIndex !== entry.taskIndex || candidate.patchPath !== entry.patchPath || JSON.stringify(candidate.preconditions) !== JSON.stringify(entry.preconditions)) {
                 receipt.entries.push({ path: entry.path, branch: entry.branch, state: "kept", reason: candidate?.reasons.join("; ") || "reviewed ownership or Git facts changed" });
@@ -9930,7 +9732,7 @@ async function applyReviewedCleanupPlan(input) {
               const journalEntry = { path: entry.path, branch: entry.branch, state: "removing", reason: "removal prepared; outcome not yet recorded" };
               receipt.entries.push(journalEntry);
               writePrivateAtomicJson(receiptPath, receipt);
-              const removed = spawnSync3("git", ["-C", plan.repoRoot, "worktree", "remove", "--", entry.path], { encoding: "utf-8", windowsHide: true });
+              const removed = spawnSync2("git", ["-C", plan.repoRoot, "worktree", "remove", "--", entry.path], { encoding: "utf-8", windowsHide: true });
               if (removed.status !== 0) throw new Error(removed.error?.message || removed.stderr.trim() || "git worktree remove failed");
               journalEntry.state = "removed";
               journalEntry.reason = "worktree removed; local branch retained";
@@ -10018,13 +9820,13 @@ function inheritedRunFanoutBudget(deps) {
   return deps.childRuntime?.runFanoutBudget;
 }
 function resolveRequestedCwd(runtimeCwd, requestedCwd) {
-  return requestedCwd ? path19.resolve(runtimeCwd, requestedCwd) : runtimeCwd;
+  return requestedCwd ? path18.resolve(runtimeCwd, requestedCwd) : runtimeCwd;
 }
 function readWorkflowScriptFile(requestedPath, requestedCwd, runtimeCwd) {
-  const scriptPath = path19.resolve(resolveRequestedCwd(runtimeCwd, requestedCwd), requestedPath);
+  const scriptPath = path18.resolve(resolveRequestedCwd(runtimeCwd, requestedCwd), requestedPath);
   let script;
   try {
-    script = fs21.readFileSync(scriptPath, "utf8");
+    script = fs20.readFileSync(scriptPath, "utf8");
   } catch (error) {
     return { error: `Failed to read workflow script '${scriptPath}': ${error instanceof Error ? error.message : String(error)}` };
   }
@@ -10098,7 +9900,7 @@ function nestedResolutionScopeForExecutor(deps) {
   };
 }
 function trustedSessionRoots(parentSessionFile, deps) {
-  const roots = deps.config.defaultSessionDir ? [path19.resolve(deps.expandTilde(deps.config.defaultSessionDir))] : [];
+  const roots = deps.config.defaultSessionDir ? [path18.resolve(deps.expandTilde(deps.config.defaultSessionDir))] : [];
   if (parentSessionFile) for (const sessionFile of [parentSessionFile, ...inheritedSessionIds(parentSessionFile)]) roots.push(deps.getSubagentSessionRoot(sessionFile));
   return [...new Set(roots)];
 }
@@ -10428,9 +10230,9 @@ function resolveForegroundResumeTarget(params, state, options = {}) {
   if (index < 0 || index >= run.children.length) throw new Error(`Foreground run '${run.runId}' has ${run.children.length} children. Index ${index} is out of range.`);
   const child = run.children[index];
   if (!child.sessionFile) throw new Error(`Foreground run '${run.runId}' child ${index} does not have a persisted session file to resume from.`);
-  if (path19.extname(child.sessionFile) !== ".jsonl") throw new Error(`Foreground run '${run.runId}' child ${index} session file must be a .jsonl file: ${child.sessionFile}`);
-  const sessionFile = path19.resolve(child.sessionFile);
-  if (!fs21.existsSync(sessionFile)) throw new Error(`Foreground run '${run.runId}' child ${index} session file does not exist: ${child.sessionFile}`);
+  if (path18.extname(child.sessionFile) !== ".jsonl") throw new Error(`Foreground run '${run.runId}' child ${index} session file must be a .jsonl file: ${child.sessionFile}`);
+  const sessionFile = path18.resolve(child.sessionFile);
+  if (!fs20.existsSync(sessionFile)) throw new Error(`Foreground run '${run.runId}' child ${index} session file does not exist: ${child.sessionFile}`);
   return {
     runId: run.runId,
     mode: run.mode,
@@ -10481,7 +10283,7 @@ function resolveResumeTarget(params, state, options = {}) {
     foregroundError = error;
   }
   try {
-    const asyncParams = options.exactOnly && requested && !params.dir ? { ...params, dir: path19.join(DIRS.async, requested) } : params;
+    const asyncParams = options.exactOnly && requested && !params.dir ? { ...params, dir: path18.join(DIRS.async, requested) } : params;
     asyncTarget = {
       source: "async",
       ...resolveAsyncResumeTarget(asyncParams, {}, compactOptional({
@@ -10517,7 +10319,7 @@ function resolveResumeTarget(params, state, options = {}) {
 function getAsyncInterruptTarget(state, runId, location, options = {}) {
   if (location?.asyncDir) {
     return {
-      asyncId: location.resolvedId ?? runId ?? path19.basename(location.asyncDir),
+      asyncId: location.resolvedId ?? runId ?? path18.basename(location.asyncDir),
       asyncDir: location.asyncDir
     };
   }
@@ -10566,7 +10368,7 @@ function persistAsyncWorkflowControlEvent(input) {
     } : {}
   };
   try {
-    fs21.appendFileSync(path19.join(input.job.asyncDir, "events.jsonl"), `${JSON.stringify(record2)}
+    fs20.appendFileSync(path18.join(input.job.asyncDir, "events.jsonl"), `${JSON.stringify(record2)}
 `, "utf-8");
   } catch (error) {
     if (!isStorageCapacityError(error)) throw error;
@@ -10886,25 +10688,25 @@ function nestedRunAgent(run) {
   return run.agent ?? run.agents?.[0] ?? (run.steps?.length === 1 ? run.steps[0]?.agent : void 0);
 }
 function pathWithin(base, candidate) {
-  const resolvedBase = path19.resolve(base);
-  const resolvedCandidate = path19.resolve(candidate);
-  return resolvedCandidate === resolvedBase || resolvedCandidate.startsWith(`${resolvedBase}${path19.sep}`);
+  const resolvedBase = path18.resolve(base);
+  const resolvedCandidate = path18.resolve(candidate);
+  return resolvedCandidate === resolvedBase || resolvedCandidate.startsWith(`${resolvedBase}${path18.sep}`);
 }
 function validateNestedSessionFile(run, trustedSessionRoots2, resolveSource, visited = []) {
   const sessionFile = nestedRunSessionFile(run);
   if (!sessionFile) throw new Error(`Nested run '${run.id}' does not have a persisted session file to resume from.`);
-  if (path19.extname(sessionFile) !== ".jsonl") throw new Error(`Nested run '${run.id}' session file must be a .jsonl file: ${sessionFile}`);
-  const resolved = path19.resolve(sessionFile);
-  if (!path19.isAbsolute(sessionFile)) throw new Error(`Nested run '${run.id}' session file must be absolute: ${sessionFile}`);
-  if (!fs21.existsSync(resolved)) throw new Error(`Nested run '${run.id}' session file does not exist: ${sessionFile}`);
-  const stat = fs21.lstatSync(resolved);
+  if (path18.extname(sessionFile) !== ".jsonl") throw new Error(`Nested run '${run.id}' session file must be a .jsonl file: ${sessionFile}`);
+  const resolved = path18.resolve(sessionFile);
+  if (!path18.isAbsolute(sessionFile)) throw new Error(`Nested run '${run.id}' session file must be absolute: ${sessionFile}`);
+  if (!fs20.existsSync(resolved)) throw new Error(`Nested run '${run.id}' session file does not exist: ${sessionFile}`);
+  const stat = fs20.lstatSync(resolved);
   if (!stat.isFile() || stat.isSymbolicLink()) throw new Error(`Nested run '${run.id}' session file is not a regular file: ${sessionFile}`);
-  const realSessionFile = fs21.realpathSync(resolved);
-  const trustedRoots = trustedSessionRoots2.filter((root) => fs21.existsSync(root)).map((root) => fs21.realpathSync(root));
+  const realSessionFile = fs20.realpathSync(resolved);
+  const trustedRoots = trustedSessionRoots2.filter((root) => fs20.existsSync(root)).map((root) => fs20.realpathSync(root));
   if (!trustedRoots.some((root) => pathWithin(root, realSessionFile))) {
     throw new Error(`Nested run '${run.id}' session file is outside trusted nested session roots: ${sessionFile}`);
   }
-  if (!realSessionFile.split(path19.sep).includes(run.id)) {
+  if (!realSessionFile.split(path18.sep).includes(run.id)) {
     const sourceId = run.revivedFrom;
     const chain = [...visited, run.id];
     const source = sourceId && chain.length <= 8 && !chain.includes(sourceId) ? resolveSource(sourceId) : void 0;
@@ -10945,7 +10747,7 @@ function resolveNestedResumeTarget(match, trustedSessionRoots2, resolveSource) {
     state,
     agent,
     index: 0,
-    cwd: asyncDir ? path19.dirname(asyncDir) : void 0,
+    cwd: asyncDir ? path18.dirname(asyncDir) : void 0,
     sessionFile: validateNestedSessionFile(run, trustedSessionRoots2, resolveSource),
     ...run.capabilityCeiling ? { capabilityCeiling: run.capabilityCeiling } : {},
     ...recoveryDescriptor ? { recoveryDescriptor } : {}
@@ -10992,7 +10794,7 @@ async function waitForNestedControlResult(target, requestId, ignoredFiles, timeo
   while (Date.now() < deadline) {
     const result2 = findNestedControlResult(target.match.route, requestId, target.match.run.id, ignoredFiles);
     if (result2) return result2;
-    await new Promise((resolve10) => setTimeout(resolve10, 50));
+    await new Promise((resolve9) => setTimeout(resolve9, 50));
   }
   return void 0;
 }
@@ -11013,7 +10815,7 @@ function directNestedAsyncInterrupt(target) {
   const run = target.match.run;
   const asyncDir = resolveNestedAsyncDir(target.match.rootRunId, run);
   if (!asyncDir) return void 0;
-  const status = reconcileAsyncRun(asyncDir, { resultsDir: path19.join(DIRS.results, "nested", target.match.rootRunId) }).status;
+  const status = reconcileAsyncRun(asyncDir, { resultsDir: path18.join(DIRS.results, "nested", target.match.rootRunId) }).status;
   const pid = typeof status?.pid === "number" && status.pid > 0 ? status.pid : run.pid;
   if (!status || status.state !== "running" || typeof pid !== "number" || pid <= 0) return void 0;
   try {
@@ -11028,7 +10830,7 @@ async function directNestedAsyncSteer(input) {
   const run = input.target.match.run;
   const asyncDir = resolveNestedAsyncDir(input.target.match.rootRunId, run);
   if (!asyncDir) return void 0;
-  const status = reconcileAsyncRun(asyncDir, { resultsDir: path19.join(DIRS.results, "nested", input.target.match.rootRunId) }).status;
+  const status = reconcileAsyncRun(asyncDir, { resultsDir: path18.join(DIRS.results, "nested", input.target.match.rootRunId) }).status;
   if (!status || status.state !== "running" && status.state !== "queued") return void 0;
   const steps = status.steps ?? [];
   if (input.index !== void 0) {
@@ -11137,10 +10939,10 @@ async function resumeExternalJobFollowUp(input) {
   const runId = externalJobFollowUpRunId(requestDigest);
   const nestedRoute = inheritedNestedRoute(input.deps);
   const runRoots = nestedRoute ? nestedRunScope(nestedRoute.rootRunId) : { asyncDirRoot: DIRS.async, resultsDir: DIRS.results };
-  const asyncDir = path19.join(runRoots.asyncDirRoot, runId);
+  const asyncDir = path18.join(runRoots.asyncDirRoot, runId);
   const currentSessionId = input.deps.state.currentSessionId;
   if (!currentSessionId) return { content: [{ type: "text", text: "External-job follow-up requires an active parent session." }], isError: true, details: { mode: "management", results: [] } };
-  if (fs21.existsSync(asyncDir) || fs21.existsSync(resultFilePath(runRoots.resultsDir, runId))) {
+  if (fs20.existsSync(asyncDir) || fs20.existsSync(resultFilePath(runRoots.resultsDir, runId))) {
     return externalJobFollowUpStarted({ sourceRunId: input.target.runId, runId, asyncDir, duplicate: true, interactive: input.ctx.hasUI });
   }
   const depthState = checkSubagentDepth(input.deps.config.maxSubagentDepth, input.deps.childRuntime);
@@ -11341,7 +11143,7 @@ async function resumeAsyncRun(input) {
     inheritGlobalContext: recoveryDescriptor.inheritGlobalContext,
     inheritSkills: recoveryDescriptor.inheritSkills,
     source: "project",
-    filePath: recoveryDescriptor.agentFilePath ?? path19.join(getProjectSubagentsDir(recoveryDescriptor.cwd), "recovery-agent"),
+    filePath: recoveryDescriptor.agentFilePath ?? path18.join(getProjectSubagentsDir(recoveryDescriptor.cwd), "recovery-agent"),
     ...discovered.maxThinking ? { maxThinking: discovered.maxThinking } : {}
   } : void 0);
   if (!baseAgentConfig) {
@@ -11362,7 +11164,7 @@ async function resumeAsyncRun(input) {
   if (target.source === "async" && target.managedWorktree && target.asyncDir) {
     try {
       const protectedCwd = await protectRetainedWorktreeForResume(parallelHandoffPath(target.asyncDir), target.runId, target.index, input.signal);
-      if (path19.resolve(protectedCwd) !== path19.resolve(effectiveCwd)) throw new Error("Retained worktree cwd changed during resume admission.");
+      if (path18.resolve(protectedCwd) !== path18.resolve(effectiveCwd)) throw new Error("Retained worktree cwd changed during resume admission.");
     } catch (error) {
       return { content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: true, details: { mode: "management", results: [] } };
     }
@@ -11415,7 +11217,7 @@ async function resumeAsyncRun(input) {
         limit: resolveMaxActiveAsyncRunsPerSession(input.deps.config.maxActiveAsyncRunsPerSession),
         runId: runId2,
         kind: "runner",
-        asyncDir: path19.join(DIRS.async, runId2)
+        asyncDir: path18.join(DIRS.async, runId2)
       }, { liveWorkflowRunIds: new Set(input.deps.state.workflowControllers?.keys() ?? []), abandonedSlotReleaseAfterMs: resolveAbandonedSlotReleaseAfterMs(input.deps.config.capacity?.abandonedSlotReleaseAfterMs) }) : void 0;
     } catch (error) {
       if (error instanceof ActiveAsyncCapacityError) return { content: [{ type: "text", text: error.message }], isError: true, details: { mode: "chain", results: [], activeAsyncCapacity: error.snapshot } };
@@ -11435,7 +11237,7 @@ async function resumeAsyncRun(input) {
       goal,
       attachRoot: {
         runId: target.runId,
-        asyncDir: target.asyncDir ?? path19.join(DIRS.async, target.runId),
+        asyncDir: target.asyncDir ?? path18.join(DIRS.async, target.runId),
         resultPath: resolveAsyncRootResultPath(DIRS.results, target.runId),
         index: target.index,
         agent: target.agent,
@@ -11539,13 +11341,13 @@ async function resumeAsyncRun(input) {
       limit: resolveMaxActiveAsyncRunsPerSession(input.deps.config.maxActiveAsyncRunsPerSession),
       sourceRunId: target.runId,
       runId,
-      asyncDir: path19.join(DIRS.async, runId)
+      asyncDir: path18.join(DIRS.async, runId)
     }, { abandonedSlotReleaseAfterMs: resolveAbandonedSlotReleaseAfterMs(input.deps.config.capacity?.abandonedSlotReleaseAfterMs) }) : acquireActiveAsyncCapacity({
       sessionId: input.deps.state.currentSessionId,
       limit: resolveMaxActiveAsyncRunsPerSession(input.deps.config.maxActiveAsyncRunsPerSession),
       runId,
       kind: "runner",
-      asyncDir: path19.join(DIRS.async, runId)
+      asyncDir: path18.join(DIRS.async, runId)
     }, { abandonedSlotReleaseAfterMs: resolveAbandonedSlotReleaseAfterMs(input.deps.config.capacity?.abandonedSlotReleaseAfterMs) });
   } catch (error) {
     if (error instanceof ActiveAsyncCapacityError) return { content: [{ type: "text", text: error.message }], isError: true, details: { mode: "single", results: [], activeAsyncCapacity: error.snapshot } };
@@ -11556,7 +11358,7 @@ async function resumeAsyncRun(input) {
   const artifactsDir = recoveryDescriptor?.artifactsDir ?? getArtifactsDir(parentSessionFile, effectiveCwd, artifactConfig.dir);
   const availableModels = input.ctx.modelRegistry.getAvailable().map(toModelInfo);
   const parentModel = input.parentModel;
-  const revivalAsyncDir = path19.join(DIRS.async, runId);
+  const revivalAsyncDir = path18.join(DIRS.async, runId);
   const revivalOutputBaseDir = resolveSingleRunOutputBaseDir(input.deps, artifactsDir, runId);
   const inheritedOutput = foregroundContract?.output ?? recoveryDescriptor?.outputPath;
   const inheritedOutputPath = input.params.output === void 0 && input.params.workflowParentRunId === void 0 ? (target.source === "foreground" ? target.savedOutputPath : void 0) ?? resolveSingleOutputPath(inheritedOutput, input.requestCwd, effectiveCwd, revivalOutputBaseDir) : void 0;
@@ -11664,12 +11466,12 @@ async function resumeAsyncRun(input) {
     return result2;
   }
   notifyLaunch();
-  for (const brief of queuedBriefs) fs21.rmSync(brief.path, { force: true });
+  for (const brief of queuedBriefs) fs20.rmSync(brief.path, { force: true });
   if (queuedBriefs.length > 0 && sourceAsyncDir) {
     const sourceStatus = readStatus(sourceAsyncDir);
     if (sourceStatus?.steering) {
       for (const brief of queuedBriefs) updateSteeringTarget(sourceStatus.steering, brief.request.id, target.index, "delivered", Date.now());
-      createCapacityResilientJsonWriter({ keepAlive: true }).write(path19.join(sourceAsyncDir, "status.json"), sourceStatus);
+      createCapacityResilientJsonWriter({ keepAlive: true }).write(path18.join(sourceAsyncDir, "status.json"), sourceStatus);
     }
   }
   const revivedId = result2.details.asyncId ?? runId;
@@ -11731,7 +11533,7 @@ function formatFailedSingleRunOutput(result2, displayOutput) {
     cappedOutput = capInlineOutput(output, { artifactPath: result2.artifactPaths?.outputPath, savedPath: result2.savedOutputPath });
     lines.push("", "Output:", cappedOutput);
   }
-  if (cappedOutput === output && result2.artifactPaths?.outputPath && fs21.existsSync(result2.artifactPaths.outputPath)) {
+  if (cappedOutput === output && result2.artifactPaths?.outputPath && fs20.existsSync(result2.artifactPaths.outputPath)) {
     lines.push("", `Output artifact: ${result2.artifactPaths.outputPath}`);
   }
   return lines.join("\n");
@@ -11824,7 +11626,7 @@ async function maybeBuildForegroundIntercomReceipt(input) {
 }
 function diagnosticContextFromDiscovery(discovered, cwd, scope) {
   if (discovered.cwd && discovered.scope && discovered.directories) return unknownAgentDiagnosticContext({ ...discovered, cwd: discovered.cwd, scope: discovered.scope, directories: discovered.directories });
-  return unknownAgentDiagnosticContext(discoverAgents(path19.resolve(cwd), scope));
+  return unknownAgentDiagnosticContext(discoverAgents(path18.resolve(cwd), scope));
 }
 function canonicalizeAgentName(name, agents, diagnostics, context) {
   const resolved = resolveAgentName(name, agents);
@@ -11857,12 +11659,12 @@ function workflowValidationOptions(deps, params, runtimeCwd, parentModelProvider
   };
 }
 function canonicalizeExecutionParams(params, agents, diagnostics, context) {
-  const resolve10 = (name, location) => {
+  const resolve9 = (name, location) => {
     const result2 = canonicalizeAgentName(name, agents, diagnostics, context);
     return result2.error && location ? { error: `${result2.error} (${location})` } : result2;
   };
   if (params.agent) {
-    const result2 = resolve10(params.agent);
+    const result2 = resolve9(params.agent);
     if (result2.error) return { error: result2.error };
     params = omitUndefinedProperties({ ...params, agent: result2.name });
     const agent = agents.find((candidate) => candidate.name === result2.name);
@@ -11881,7 +11683,7 @@ function canonicalizeExecutionParams(params, agents, diagnostics, context) {
     const tasks = [];
     for (let index = 0; index < params.tasks.length; index++) {
       const task = params.tasks[index];
-      const result2 = resolve10(task.agent, `task ${index + 1}`);
+      const result2 = resolve9(task.agent, `task ${index + 1}`);
       if (result2.error) return { error: result2.error };
       tasks.push({ ...task, agent: result2.name });
     }
@@ -11895,7 +11697,7 @@ function canonicalizeExecutionParams(params, agents, diagnostics, context) {
         const parallel = [];
         for (let taskIndex = 0; taskIndex < step.parallel.length; taskIndex++) {
           const task = step.parallel[taskIndex];
-          const result2 = resolve10(task.agent, `step ${index + 1}, task ${taskIndex + 1}`);
+          const result2 = resolve9(task.agent, `step ${index + 1}, task ${taskIndex + 1}`);
           if (result2.error) return { error: result2.error };
           parallel.push({ ...task, agent: result2.name });
         }
@@ -11903,13 +11705,13 @@ function canonicalizeExecutionParams(params, agents, diagnostics, context) {
         continue;
       }
       if (isDynamicParallelStep(step)) {
-        const result2 = resolve10(step.parallel.agent, `step ${index + 1}`);
+        const result2 = resolve9(step.parallel.agent, `step ${index + 1}`);
         if (result2.error) return { error: result2.error };
         chain.push({ ...step, parallel: { ...step.parallel, agent: result2.name } });
         continue;
       }
       if ("agent" in step && typeof step.agent === "string") {
-        const result2 = resolve10(step.agent, `step ${index + 1}`);
+        const result2 = resolve9(step.agent, `step ${index + 1}`);
         if (result2.error) return { error: result2.error };
         chain.push({ ...step, agent: result2.name });
         continue;
@@ -12776,7 +12578,7 @@ async function createSingleWorktreeSetup(cwd, runId, agent, setupHook, setupHook
   }
 }
 function resolveConfiguredSingleRunOutputBaseDir(deps) {
-  return deps.config.singleRunOutputBaseDir ? path19.resolve(deps.expandTilde(deps.config.singleRunOutputBaseDir)) : void 0;
+  return deps.config.singleRunOutputBaseDir ? path18.resolve(deps.expandTilde(deps.config.singleRunOutputBaseDir)) : void 0;
 }
 function sanitizeRunPathSegment(value, maxBytes = 120) {
   const sanitized = value.trim().replace(/[^A-Za-z0-9._-]+/g, "_").replace(/^_+|_+$/g, "");
@@ -12785,22 +12587,22 @@ function sanitizeRunPathSegment(value, maxBytes = 120) {
   return sanitized.slice(0, maxBytes).replace(/_+$/, "") || "unknown";
 }
 function resolveSingleRunOutputBaseDir(deps, artifactsDir, runId) {
-  return resolveConfiguredSingleRunOutputBaseDir(deps) ?? path19.join(artifactsDir, "outputs", sanitizeRunPathSegment(runId));
+  return resolveConfiguredSingleRunOutputBaseDir(deps) ?? path18.join(artifactsDir, "outputs", sanitizeRunPathSegment(runId));
 }
 function suffixedOutputPath(outputPath, suffix) {
-  const parsed = path19.parse(outputPath);
-  return path19.join(parsed.dir, `${parsed.name}.${suffix}${parsed.ext || ".md"}`);
+  const parsed = path18.parse(outputPath);
+  return path18.join(parsed.dir, `${parsed.name}.${suffix}${parsed.ext || ".md"}`);
 }
 function workflowChildDefaultOutput(aggregateOutputPath, artifactsDir, workflowRunId, workflowKey) {
   if (aggregateOutputPath) return suffixedOutputPath(aggregateOutputPath, workflowKey);
-  return path19.join(artifactsDir, "outputs", sanitizeRunPathSegment(workflowRunId), `${workflowKey}.md`);
+  return path18.join(artifactsDir, "outputs", sanitizeRunPathSegment(workflowRunId), `${workflowKey}.md`);
 }
 function workflowHostCommandRunner(input) {
   return async (key, params, signal) => {
     const authorizationError = input.authorize?.(key, params);
     if (authorizationError) throw new Error(authorizationError);
-    const defaultOutputPath = path19.join(input.artifactsDir, "outputs", sanitizeRunPathSegment(input.workflowRunId), "host", `${sanitizeRunPathSegment(key)}.log`);
-    const outputPath = params.output ? path19.resolve(input.workflowCwd, params.output) : defaultOutputPath;
+    const defaultOutputPath = path18.join(input.artifactsDir, "outputs", sanitizeRunPathSegment(input.workflowRunId), "host", `${sanitizeRunPathSegment(key)}.log`);
+    const outputPath = params.output ? path18.resolve(input.workflowCwd, params.output) : defaultOutputPath;
     const claimPath = resolveWorkflowHostOutputClaimPath(outputPath);
     const previous = input.claimedOutputPaths.get(claimPath);
     if (previous) throw new Error(`runs.host('${key}') output path is already claimed by '${previous}': ${outputPath}.`);
@@ -12814,8 +12616,8 @@ function writeWorkflowAggregateOutput(outputPath, text, producedChildOutputPaths
   if (!outputPath) return void 0;
   try {
     if (producedChildOutputPaths.has(resolveWorkflowHostOutputClaimPath(outputPath))) return void 0;
-    fs21.mkdirSync(path19.dirname(outputPath), { recursive: true });
-    fs21.writeFileSync(outputPath, text, "utf-8");
+    fs20.mkdirSync(path18.dirname(outputPath), { recursive: true });
+    fs20.writeFileSync(outputPath, text, "utf-8");
     return void 0;
   } catch (error) {
     return `Output file error: ${outputPath}
@@ -12886,7 +12688,7 @@ function resolveWorkflowChildOutputPath(input) {
   }
   const output = rawOutput === true || rawOutput === "true" ? agentOutput : hasExplicitOutput ? rawOutput : input.aggregateOutputPath ? workflowChildDefaultOutput(input.aggregateOutputPath, input.artifactsDir, input.workflowRunId, input.key) : agentOutput;
   return {
-    path: resolveSingleOutputPath(output, input.ctxCwd, childCwd, input.configuredOutputBaseDir ?? path19.join(input.artifactsDir, "outputs", sanitizeRunPathSegment(input.workflowRunId))),
+    path: resolveSingleOutputPath(output, input.ctxCwd, childCwd, input.configuredOutputBaseDir ?? path18.join(input.artifactsDir, "outputs", sanitizeRunPathSegment(input.workflowRunId))),
     inherited: !hasExplicitOutput && !input.aggregateOutputPath && agentOutput !== void 0
   };
 }
@@ -12951,7 +12753,7 @@ async function finalizeSingleWorktreeHandoff(input) {
   try {
     return await withWorktreeTransaction(() => {
       admitted = true;
-      const diffsDir = path19.join(input.artifactsDir, "worktree-diffs", input.runId);
+      const diffsDir = path18.join(input.artifactsDir, "worktree-diffs", input.runId);
       const diffs = diffWorktrees(input.worktreeSetup, [input.agent], diffsDir);
       const diffSummary = formatWorktreeDiffSummary(diffs);
       const manifestPath = parallelHandoffPath(input.artifactsDir, input.runId);
@@ -13197,7 +12999,7 @@ async function runSinglePath(data, deps) {
     await cleanupSingleWorktree();
     return { content: [{ type: "text", text: validationError }], isError: true, details: { mode: "single", results: [], parallelHandoff: pendingHandoff } };
   }
-  const structuredRuntime = params.outputSchema ? createStructuredOutputRuntime(params.outputSchema, artifactConfig.enabled ? path19.join(artifactsDir, "structured-output", runId) : void 0, { acceptanceReport: resolveAcceptanceReportMode(params.acceptance) }) : void 0;
+  const structuredRuntime = params.outputSchema ? createStructuredOutputRuntime(params.outputSchema, artifactConfig.enabled ? path18.join(artifactsDir, "structured-output", runId) : void 0, { acceptanceReport: resolveAcceptanceReportMode(params.acceptance) }) : void 0;
   const reads = readsOverride !== void 0 ? readsOverride : agentConfig.defaultReads ?? false;
   const readPaths = !foregroundMachine && Array.isArray(reads) ? resolveExistingReadPaths(reads, singleCwd) : [];
   const readsInstruction = readPaths.length > 0 ? `[Read from: ${readPaths.join(", ")}]
@@ -13281,8 +13083,8 @@ async function runSinglePath(data, deps) {
   };
   let r;
   let resolveDetachedWorkflowChild;
-  const detachedWorkflowChild = params.workflowAwaitDetached === true ? new Promise((resolve10) => {
-    resolveDetachedWorkflowChild = resolve10;
+  const detachedWorkflowChild = params.workflowAwaitDetached === true ? new Promise((resolve9) => {
+    resolveDetachedWorkflowChild = resolve9;
   }) : void 0;
   try {
     const childSessionFile = sessionFileForTask(params.agent, 0, modelOverride, modelOverrideFromParent, modelOrigin);
@@ -13427,7 +13229,7 @@ async function runSinglePath(data, deps) {
     }));
     if (launched.detached && foregroundControl) {
       foregroundControl.stopForRuntimeReplacement = () => {
-        const sessionFile = childSessionFile && fs21.existsSync(childSessionFile) ? childSessionFile : void 0;
+        const sessionFile = childSessionFile && fs20.existsSync(childSessionFile) ? childSessionFile : void 0;
         const stopped = { ...launched, detached: void 0, stopped: true, exitCode: 1, error: RUNTIME_REPLACED_STOP_ERROR, finalOutput: RUNTIME_REPLACED_STOP_ERROR, sessionFile };
         rememberForegroundRun(deps.state, { modelResponseAliases, runId, mode: "single", cwd: singleCwd, sessionId: data.parentSessionId, results: [stopped], params, effectiveOutput, effectiveOutputMode, extensionBindings: params.extensionBindings, requiredExtensions });
         if (childSessionControls) childSessionControls.stop(RUNTIME_REPLACED_STOP_ERROR);
@@ -13595,8 +13397,8 @@ function bindMissionWorkflowChildAsyncLaunch(params, binding, asyncByDefault, as
   const requestedAsync = params.async ?? asyncByDefault;
   if (!binding || !requestedAsync || params.clarify === true) return params;
   const id = asyncId.trim();
-  if (!id || path19.basename(id) !== id) throw new Error("workflow child async id must be a single path segment");
-  writeMissionAsyncBinding(path19.join(nestedRootRunId ? nestedRunScope(nestedRootRunId).asyncDirRoot : DIRS.async, id), binding);
+  if (!id || path18.basename(id) !== id) throw new Error("workflow child async id must be a single path segment");
+  writeMissionAsyncBinding(path18.join(nestedRootRunId ? nestedRunScope(nestedRootRunId).asyncDirRoot : DIRS.async, id), binding);
   return { ...params, workflowChildAsyncId: id };
 }
 function workflowChildResult(key, result2, childParams = {}, resumeState, forcedTerminalOutcome) {
@@ -13737,7 +13539,7 @@ var WORKFLOW_STEP_STATES = /* @__PURE__ */ new Set(["pending", "running", "compl
 function isSafeWorkflowChildRunId(value) {
   if (typeof value !== "string") return false;
   const runId = value.trim();
-  return value === runId && Boolean(runId) && Buffer.byteLength(runId, "utf8") <= MAX_WORKFLOW_CHILD_RUN_ID_BYTES && path19.basename(runId) === runId && path19.win32.basename(runId) === runId && !/[\\/]/.test(runId) && !runId.includes("..") && !/[\u0000-\u001f\u007f]/.test(runId);
+  return value === runId && Boolean(runId) && Buffer.byteLength(runId, "utf8") <= MAX_WORKFLOW_CHILD_RUN_ID_BYTES && path18.basename(runId) === runId && path18.win32.basename(runId) === runId && !/[\\/]/.test(runId) && !runId.includes("..") && !/[\u0000-\u001f\u007f]/.test(runId);
 }
 function isMissingWorkflowReceiptDiagnostic(error, workflowRunId) {
   return error instanceof Error && error.message.startsWith(`Workflow receipt '${workflowRunId}' is not available because the workflow may still be active or terminal receipt writing failed.`);
@@ -13746,7 +13548,7 @@ function missingWorkflowReceiptResumeHint(reference, state) {
   try {
     if (!state.currentSessionId) return void 0;
     const workflowRunId = reference.workflowRunId.trim();
-    const workflowStatus = readStatus(path19.join(DIRS.async, workflowRunId));
+    const workflowStatus = readStatus(path18.join(DIRS.async, workflowRunId));
     if (!workflowStatus || workflowStatus.runId !== workflowRunId || workflowStatus.mode !== "workflow" || workflowStatus.sessionId !== state.currentSessionId || typeof workflowStatus.startedAt !== "number" || !Number.isFinite(workflowStatus.startedAt) || !WORKFLOW_RESUME_HINT_PARENT_STATES.has(workflowStatus.state) || !Array.isArray(workflowStatus.steps) || workflowStatus.steps.some((step) => {
       if (!step || typeof step !== "object" || Array.isArray(step)) return true;
       const record2 = step;
@@ -13781,7 +13583,7 @@ function resolveWorkflowResume(reference, deps, parentSessionFile, index) {
     if (status?.runId === runId && status.parentWorkflowRunId && status.workflowKey) {
       const receiptPath = workflowReceiptPath(DIRS.async, status.parentWorkflowRunId);
       try {
-        fs21.statSync(receiptPath);
+        fs20.statSync(receiptPath);
       } catch (error) {
         if (error.code === "ENOENT") return { runId, runIds: [runId] };
         throw error;
@@ -13840,11 +13642,11 @@ async function steerWorkflowChildByKey(input) {
       });
       if (!result2.details.steering?.targets.some((target) => target.reason === CHILD_SESSION_NOT_RUNNING_YET) || Date.now() >= deadline) return workflowSteerReceipt(input.key, result2);
     }
-    const workflowStatus = readStatus(path19.join(asyncDirRoot, input.workflowRunId));
+    const workflowStatus = readStatus(path18.join(asyncDirRoot, input.workflowRunId));
     const step = workflowStatus?.steps?.find((candidate) => candidate.workflowKey === input.key);
     const childRunId = step?.runId ?? input.resolveRunId?.();
     if (childRunId) {
-      const asyncDir = path19.join(asyncDirRoot, childRunId);
+      const asyncDir = path18.join(asyncDirRoot, childRunId);
       const childStatus = reconcileAsyncRun(asyncDir).status;
       if (childStatus && childStatus.state !== "running" && childStatus.state !== "queued" && (input.options.mode !== "follow_up" || !canQueueRetainedAsyncFollowUp(childStatus, input.options.index))) {
         return { key: input.key, state: "missed", error: `Workflow child '${input.key}' is ${childStatus.state}.` };
@@ -13874,7 +13676,7 @@ async function steerWorkflowChildByKey(input) {
     if (input.signal?.aborted || Date.now() >= deadline) {
       return { key: input.key, state: "missed", error: `Workflow child '${input.key}' had no live steering route.` };
     }
-    await new Promise((resolve10) => setTimeout(resolve10, Math.min(10, Math.max(1, deadline - Date.now()))));
+    await new Promise((resolve9) => setTimeout(resolve9, Math.min(10, Math.max(1, deadline - Date.now()))));
   }
 }
 async function preflightWorkflowWorktrees(input) {
@@ -14320,7 +14122,7 @@ function createSubagentExecutor(deps) {
             limit: resolveMaxActiveAsyncRunsPerSession(deps2.config.maxActiveAsyncRunsPerSession),
             runId: workflowRunId,
             kind: "workflow",
-            asyncDir: path19.join(DIRS.async, workflowRunId)
+            asyncDir: path18.join(DIRS.async, workflowRunId)
           }, { liveWorkflowRunIds: new Set(deps2.state.workflowControllers?.keys() ?? []), abandonedSlotReleaseAfterMs: resolveAbandonedSlotReleaseAfterMs(deps2.config.capacity?.abandonedSlotReleaseAfterMs) });
         } catch (error) {
           if (error instanceof ActiveAsyncCapacityError) {
@@ -14366,11 +14168,11 @@ function createSubagentExecutor(deps) {
       };
       if (workflowRunId) {
         const toolCallId = _id;
-        const workflowSessionRoot = requestParams.sessionDir ? path19.resolve(deps2.expandTilde(requestParams.sessionDir)) : trustedSessionRoots(ctx.sessionManager.getSessionFile() ?? null, deps2)[0];
-        const asyncDir = path19.join(DIRS.async, workflowRunId);
+        const workflowSessionRoot = requestParams.sessionDir ? path18.resolve(deps2.expandTilde(requestParams.sessionDir)) : trustedSessionRoots(ctx.sessionManager.getSessionFile() ?? null, deps2)[0];
+        const asyncDir = path18.join(DIRS.async, workflowRunId);
         const resultPath = resultFilePath(DIRS.results, workflowRunId);
-        const statusPath = path19.join(asyncDir, "status.json");
-        const eventsPath = path19.join(asyncDir, "events.jsonl");
+        const statusPath = path18.join(asyncDir, "status.json");
+        const eventsPath = path18.join(asyncDir, "events.jsonl");
         const startedAt = Date.now();
         const currentSessionId = resolveCurrentSessionId(ctx.sessionManager);
         const workflowCapabilityCeiling2 = intersectSubagentCapabilityCeilings(requestParams.capabilityCeiling, resolveCurrentSubagentCapabilityCeiling(currentSessionId));
@@ -14386,7 +14188,7 @@ function createSubagentExecutor(deps) {
           return { content: [{ type: "text", text: `Failed to create async workflow storage: ${error instanceof Error ? error.message : String(error)}` }], isError: true, details: { mode: "workflow", results: [] } };
         };
         if (workflowReuseSource) {
-          const reuseSourceDir = path19.join(DIRS.async, workflowReuseSource.runId);
+          const reuseSourceDir = path18.join(DIRS.async, workflowReuseSource.runId);
           let claim;
           try {
             claim = claimWorkflowResume(reuseSourceDir, { newRunId: workflowRunId, trigger: "reuse" });
@@ -14398,14 +14200,14 @@ function createSubagentExecutor(deps) {
             return { content: [{ type: "text", text: claimedWorkflowRunRefusal(workflowReuseSource.runId, claim, requestParams.reuseFrom !== void 0) }], isError: true, details: { mode: "workflow", results: [] } };
           }
           pendingReuseClaimReleases.set(params, () => {
-            if (!fs21.existsSync(statusPath)) releaseWorkflowResumeClaim(reuseSourceDir, workflowRunId);
+            if (!fs20.existsSync(statusPath)) releaseWorkflowResumeClaim(reuseSourceDir, workflowRunId);
           });
         }
         try {
-          fs21.mkdirSync(asyncDir, { recursive: true });
+          fs20.mkdirSync(asyncDir, { recursive: true });
           writeRunFanoutBudgetDescriptor(asyncDir, workflowFanoutBudget);
           if (topLevelAsyncWorkflow && publicWorkflowLaunch) writeWorkflowLaunchRecord(asyncDir, workflowLaunchRecord(publicWorkflowLaunch, workflowCwd, workflowScriptSourceDigest));
-          fs21.mkdirSync(DIRS.results, { recursive: true });
+          fs20.mkdirSync(DIRS.results, { recursive: true });
         } catch (error) {
           return storageFailure(error);
         }
@@ -14438,7 +14240,7 @@ function createSubagentExecutor(deps) {
         };
         const appendWorkflowEvent = (event) => {
           try {
-            fs21.appendFileSync(eventsPath, `${JSON.stringify({ ts: Date.now(), runId: workflowRunId, ...event })}
+            fs20.appendFileSync(eventsPath, `${JSON.stringify({ ts: Date.now(), runId: workflowRunId, ...event })}
 `, "utf-8");
           } catch (error) {
             console.error(`Failed to append async workflow event '${eventsPath}':`, error);
@@ -14467,7 +14269,7 @@ function createSubagentExecutor(deps) {
           const message = `Failed to write async workflow result ${resultPath}: ${error instanceof Error ? error.message : String(error)}`;
           console.error(message, error);
           try {
-            if (currentSessionId && fallbackResultPayloadPathForSessionRun(path19.dirname(resultPath), currentSessionId, workflowRunId)) return true;
+            if (currentSessionId && fallbackResultPayloadPathForSessionRun(path18.dirname(resultPath), currentSessionId, workflowRunId)) return true;
           } catch (pendingError) {
             console.error(`Failed to verify pending async workflow result '${workflowRunId}':`, pendingError);
           }
@@ -14575,8 +14377,8 @@ Parent action: ${STATUS_ACTION}`,
             };
             pendingResultPublication = void 0;
             runPersistence.write(resultPath, payload);
-            if (!resultPublished) pendingResultPublication = new Promise((resolve10) => {
-              settleResultPublication = resolve10;
+            if (!resultPublished) pendingResultPublication = new Promise((resolve9) => {
+              settleResultPublication = resolve9;
             });
             return true;
           } catch (error) {
@@ -14913,7 +14715,7 @@ Parent action: ${STATUS_ACTION}`,
             const step = status.steps?.find((candidate) => candidate.workflowKey === key);
             if (!step) return;
             if (runId2) step.runId = runId2;
-            step.async = runId2 !== void 0 && path19.basename(runId2) === runId2 && fs21.existsSync(path19.join(path19.dirname(asyncDir), runId2));
+            step.async = runId2 !== void 0 && path18.basename(runId2) === runId2 && fs20.existsSync(path18.join(path18.dirname(asyncDir), runId2));
             persist({ tolerateStatusWriteFailure: true });
           };
           try {
@@ -15014,7 +14816,7 @@ Parent action: ${COMPLETION_ACTION}` : content,
                 }
                 if (priorChild?.kind === "started") {
                   const priorRunId = priorChild.runId;
-                  const priorAsyncDir = path19.join(DIRS.async, priorRunId);
+                  const priorAsyncDir = path18.join(DIRS.async, priorRunId);
                   appendWorkflowChildJournal(asyncDir, { type: "start", key, fingerprint: journalFingerprint, runId: priorRunId });
                   recordReusedWorkflowChild(key, priorRunId);
                   const stopListener = stopAwaitedAsyncChildOnAbort(workflowSignal, deps2.state, priorRunId, priorAsyncDir, deps2.kill, true);
@@ -15236,7 +15038,7 @@ Parent action: ${COMPLETION_ACTION}` : content,
       const workflowOutput = typeof workflowChildDefaults.output === "string" || typeof workflowChildDefaults.output === "boolean" ? workflowChildDefaults.output : void 0;
       const configuredOutputBaseDir = resolveConfiguredSingleRunOutputBaseDir(deps2);
       const workflowAggregateOutputPath = resolveSingleOutputPath(workflowOutput, ctx.cwd, workflowCwd, resolveSingleRunOutputBaseDir(deps2, workflowArtifactsDir, foregroundWorkflowRunId));
-      const workflowFullResultPath = path19.join(workflowArtifactsDir, `${sanitizeRunPathSegment(foregroundWorkflowRunId)}_workflow-result.md`);
+      const workflowFullResultPath = path18.join(workflowArtifactsDir, `${sanitizeRunPathSegment(foregroundWorkflowRunId)}_workflow-result.md`);
       const claimedOutputPaths = /* @__PURE__ */ new Map();
       const childOutputOverrides = /* @__PURE__ */ new Map();
       const childOutputClaimPaths = /* @__PURE__ */ new Map();
@@ -15507,7 +15309,7 @@ ${partial.console.map((entry) => `[${entry.level}] ${entry.text}`).join("\n")}`]
         if (paramsWithResolvedCwd.mode === "apply") {
           try {
             if (!paramsWithResolvedCwd.repo?.trim() || !paramsWithResolvedCwd.planId?.trim() || paramsWithResolvedCwd.handoffPath !== void 0) throw new Error("worktree.cleanup apply requires explicit repo and planId, without handoffPath.");
-            const repo = path19.resolve(requestCwd, paramsWithResolvedCwd.repo);
+            const repo = path18.resolve(requestCwd, paramsWithResolvedCwd.repo);
             const plan = loadReviewedCleanupPlan(repo, paramsWithResolvedCwd.planId);
             const decision = resolveAuthorityDecision({ action: "discardWorktree", ...deps2.config.authorityPolicy === void 0 ? {} : { policy: deps2.config.authorityPolicy } });
             if (decision === "forbid") throw new Error("Authority policy forbids worktree cleanup.");
@@ -15537,8 +15339,8 @@ Remove up to ${plan.entries.filter((entry) => entry.decision === "remove").lengt
         }
         try {
           const created = createWorktreeCleanupPlan({
-            repo: paramsWithResolvedCwd.repo?.trim() ? path19.isAbsolute(paramsWithResolvedCwd.repo) ? paramsWithResolvedCwd.repo : path19.resolve(requestCwd, paramsWithResolvedCwd.repo) : requestCwd,
-            ...paramsWithResolvedCwd.handoffPath ? { handoffPath: path19.isAbsolute(paramsWithResolvedCwd.handoffPath) ? paramsWithResolvedCwd.handoffPath : path19.resolve(requestCwd, paramsWithResolvedCwd.handoffPath) } : {},
+            repo: paramsWithResolvedCwd.repo?.trim() ? path18.isAbsolute(paramsWithResolvedCwd.repo) ? paramsWithResolvedCwd.repo : path18.resolve(requestCwd, paramsWithResolvedCwd.repo) : requestCwd,
+            ...paramsWithResolvedCwd.handoffPath ? { handoffPath: path18.isAbsolute(paramsWithResolvedCwd.handoffPath) ? paramsWithResolvedCwd.handoffPath : path18.resolve(requestCwd, paramsWithResolvedCwd.handoffPath) } : {},
             ...deps2.config.worktreeBaseDir ? { worktreeBaseDir: deps2.config.worktreeBaseDir } : {},
             foregroundRunOwnership: (runId2) => {
               if (deps2.state.foregroundControls.has(runId2)) return "active";
@@ -15571,7 +15373,7 @@ ${paramsWithResolvedCwd.handoffPath}`);
         }
         if (!confirmed) return { content: [{ type: "text", text: "Worktree discard canceled; preserved worktrees were not changed." }], details: { mode: "management", results: [] } };
         try {
-          const manifestPath = path19.isAbsolute(paramsWithResolvedCwd.handoffPath) ? paramsWithResolvedCwd.handoffPath : path19.resolve(requestCwd, paramsWithResolvedCwd.handoffPath);
+          const manifestPath = path18.isAbsolute(paramsWithResolvedCwd.handoffPath) ? paramsWithResolvedCwd.handoffPath : path18.resolve(requestCwd, paramsWithResolvedCwd.handoffPath);
           const discarded = await withWorktreeTransaction(() => discardPreservedWorktrees(
             manifestPath,
             { kind: decision === "confirm" ? "confirmed" : "policy", ...deps2.config.authorityPolicy ? { policy: deps2.config.authorityPolicy } : {} }
@@ -15589,7 +15391,7 @@ ${paramsWithResolvedCwd.handoffPath}`);
         if (!laneId) return { content: [{ type: "text", text: `${action} requires laneId.` }], isError: true, details: { mode: "management", results: [] } };
         const handoffPath = paramsWithResolvedCwd.handoffPath?.trim();
         if (!handoffPath) return { content: [{ type: "text", text: `${action} requires handoffPath for the existing parallel handoff manifest.` }], isError: true, details: { mode: "management", results: [] } };
-        const manifestPath = path19.isAbsolute(handoffPath) ? handoffPath : path19.resolve(requestCwd, handoffPath);
+        const manifestPath = path18.isAbsolute(handoffPath) ? handoffPath : path18.resolve(requestCwd, handoffPath);
         try {
           if (action === "lane.status") {
             let manifest;
@@ -15765,9 +15567,7 @@ Usage is not reset. Compaction keeps the same budget; a new parent session start
       if (action === "guide") {
         try {
           const guide = readSubagentGuide(paramsWithResolvedCwd.topic);
-          const [topic, section] = paramsWithResolvedCwd.topic?.split("/") ?? [];
-          const fullNotice = topic === "tool-reference" ? disabledFeatureNotice(disabledFeatures) : void 0;
-          const notice = fullNotice && section !== void 0 ? "Some options and actions documented here are disabled by config in this session; guide topic tool-reference lists them." : fullNotice;
+          const notice = paramsWithResolvedCwd.topic?.includes("/") ? disabledFeatureSectionNotice(disabledFeatures) : disabledFeatureNotice(disabledFeatures);
           return {
             content: [{ type: "text", text: notice ? `${notice}
 
@@ -15918,7 +15718,7 @@ ${item.text}` } : item)
         if (paramsWithResolvedCwd.dir) {
           try {
             const location = resolveAsyncRunLocation(paramsWithResolvedCwd, DIRS.async, DIRS.results);
-            const runId2 = location.resolvedId ?? targetRunId ?? path19.basename(location.asyncDir ?? paramsWithResolvedCwd.dir);
+            const runId2 = location.resolvedId ?? targetRunId ?? path18.basename(location.asyncDir ?? paramsWithResolvedCwd.dir);
             const directoryStatus = location.asyncDir ? readStatus(location.asyncDir) : null;
             if (directoryStatus?.mode === "workflow") {
               return steerWorkflowRun({ state: deps2.state, runId: runId2, asyncDir: location.asyncDir, message, mode: resolveSteerDeliveryMode(paramsWithResolvedCwd.mode), index: paramsWithResolvedCwd.index, signal });
@@ -16051,7 +15851,7 @@ ${item.text}` } : item)
           if (!stopChild) return { content: [{ type: "text", text: `Workflow ${workflowRunId} child stop is unavailable in this extension runtime.` }], isError: true, details: { mode: "management", results: [] } };
           if (!stopChild(resolution.child.id, `Workflow child '${resolution.child.id}' stopped.`)) return { content: [{ type: "text", text: `Child '${paramsWithResolvedCwd.childId}' in workflow ${workflowRunId} is not available to stop.` }], isError: true, details: { mode: "management", results: [] } };
           try {
-            fs21.appendFileSync(path19.join(asyncJob.asyncDir, "events.jsonl"), `${JSON.stringify({
+            fs20.appendFileSync(path18.join(asyncJob.asyncDir, "events.jsonl"), `${JSON.stringify({
               type: "subagent.child-status",
               version: 1,
               runId: workflowRunId,
@@ -16077,7 +15877,7 @@ ${item.text}` } : item)
         if (paramsWithResolvedCwd.dir) {
           try {
             const location = resolveAsyncRunLocation(paramsWithResolvedCwd, DIRS.async, DIRS.results);
-            const stopResult2 = stopAsyncRun(deps2.state, location.resolvedId ?? targetRunId ?? path19.basename(location.asyncDir ?? paramsWithResolvedCwd.dir), deps2.kill, location, paramsWithResolvedCwd.childId);
+            const stopResult2 = stopAsyncRun(deps2.state, location.resolvedId ?? targetRunId ?? path18.basename(location.asyncDir ?? paramsWithResolvedCwd.dir), deps2.kill, location, paramsWithResolvedCwd.childId);
             return stopResult2 ?? { content: [{ type: "text", text: `No running or queued async run was found for '${targetRunId ?? paramsWithResolvedCwd.dir}'.` }], isError: true, details: { mode: "management", results: [] } };
           } catch (error) {
             const text = error instanceof Error ? error.message : String(error);
@@ -16325,7 +16125,7 @@ ${item.text}` } : item)
     if (foregroundTimeout.error) return buildRequestedModeError(effectiveParams, foregroundTimeout.error);
     const controlConfig = resolveControlConfig(deps2.config.control, effectiveParams.control);
     const requestedWorkflowChildAsyncId = typeof effectiveParams.workflowChildAsyncId === "string" ? effectiveParams.workflowChildAsyncId.trim() : "";
-    const asyncRunId = requestedWorkflowChildAsyncId && path19.basename(requestedWorkflowChildAsyncId) === requestedWorkflowChildAsyncId ? requestedWorkflowChildAsyncId : randomUUID5();
+    const asyncRunId = requestedWorkflowChildAsyncId && path18.basename(requestedWorkflowChildAsyncId) === requestedWorkflowChildAsyncId ? requestedWorkflowChildAsyncId : randomUUID5();
     const topLevelAsyncCapacityEligible = depth === 0 && !inheritedNestedRouteValue && !effectiveParams.workflowParentRunId;
     const topLevelAsync = effectiveAsync && topLevelAsyncCapacityEligible;
     let activeAsyncCapacity;
@@ -16337,7 +16137,7 @@ ${item.text}` } : item)
           limit: activeLimit,
           runId: asyncRunId,
           kind: "runner",
-          asyncDir: path19.join(DIRS.async, asyncRunId)
+          asyncDir: path18.join(DIRS.async, asyncRunId)
         }, { liveWorkflowRunIds: new Set(deps2.state.workflowControllers?.keys() ?? []), abandonedSlotReleaseAfterMs: resolveAbandonedSlotReleaseAfterMs(deps2.config.capacity?.abandonedSlotReleaseAfterMs) });
         deps2.state.activeAsyncCapacity = getActiveAsyncCapacitySnapshot(requestSessionId, activeLimit, { liveWorkflowRunIds: new Set(deps2.state.workflowControllers?.keys() ?? []), abandonedSlotReleaseAfterMs: resolveAbandonedSlotReleaseAfterMs(deps2.config.capacity?.abandonedSlotReleaseAfterMs) });
       } catch (error) {
@@ -16373,13 +16173,13 @@ ${item.text}` } : item)
     let sessionRoot;
     sessionRunId = effectiveAsync ? asyncRunId : runId;
     if (effectiveParams.sessionDir) {
-      sessionRoot = path19.join(path19.resolve(deps2.expandTilde(effectiveParams.sessionDir)), sessionRunId);
+      sessionRoot = path18.join(path18.resolve(deps2.expandTilde(effectiveParams.sessionDir)), sessionRunId);
     } else {
-      const baseSessionRoot = deps2.config.defaultSessionDir ? path19.resolve(deps2.expandTilde(deps2.config.defaultSessionDir)) : deps2.getSubagentSessionRoot(parentSessionFile);
-      sessionRoot = path19.join(baseSessionRoot, sessionRunId);
+      const baseSessionRoot = deps2.config.defaultSessionDir ? path18.resolve(deps2.expandTilde(deps2.config.defaultSessionDir)) : deps2.getSubagentSessionRoot(parentSessionFile);
+      sessionRoot = path18.join(baseSessionRoot, sessionRunId);
     }
     try {
-      fs21.mkdirSync(sessionRoot, { recursive: true });
+      fs20.mkdirSync(sessionRoot, { recursive: true });
     } catch (error) {
       activeAsyncCapacity?.rollback();
       const message = error instanceof Error ? error.message : String(error);
@@ -16389,7 +16189,7 @@ ${item.text}` } : item)
         contextPolicy.contextSummary
       );
     }
-    const sessionDirForIndex = (idx) => path19.join(sessionRoot, `run-${idx ?? 0}`);
+    const sessionDirForIndex = (idx) => path18.join(sessionRoot, `run-${idx ?? 0}`);
     const forkSessionFileForTask = (agentName, idx = 0) => {
       if (!shouldForkAgent(contextPolicy, agentName)) return void 0;
       return forkSessionFileForIndex(idx);
@@ -16399,8 +16199,8 @@ ${item.text}` } : item)
       await prepareForkSessionForIndex(idx);
     };
     const thinkingOverrideForTask = () => delegatedThinkingOverride;
-    const childSessionFileForTask = (agentName, idx, modelOverride, modelOverrideFromParent, modelOrigin) => forkSessionFileForTask(agentName, idx, modelOverride, modelOverrideFromParent, modelOrigin) ?? path19.join(sessionDirForIndex(idx), "session.jsonl");
-    const childSessionFileForIndex = (idx) => path19.join(sessionDirForIndex(idx), "session.jsonl");
+    const childSessionFileForTask = (agentName, idx, modelOverride, modelOverrideFromParent, modelOrigin) => forkSessionFileForTask(agentName, idx, modelOverride, modelOverrideFromParent, modelOrigin) ?? path18.join(sessionDirForIndex(idx), "session.jsonl");
+    const childSessionFileForIndex = (idx) => path18.join(sessionDirForIndex(idx), "session.jsonl");
     try {
       assertLaunchableAgentsAllowedBeforeFork();
       if (!(effectiveParams.clarify === true && ctx.hasUI) || deps2.config.forkContext?.mode === "pruned") {