@ashx-j/lunr 0.2.26 → 0.2.28

package/dist/node-runtime/{subagent-executor-LPZ4BHWE.js → subagent-executor-UI6SHG3X.js}

@@ -141,7 +141,6 @@ import {
   resolveSkillsWithFallback,
   resolveStepBehavior,
   resolveSubagentIntercomTarget,
-  resolveSubagentRequestParams,
   resolveSubagentResultStatus,
   resolveSubagentRunId,
   resolveTopLevelParallelConcurrency,
@@ -179,7 +178,7 @@ import {
   writeNestedControlRequest,
   writeNestedEvent,
   writePrivateAtomicJson
-} from "./chunk-2CFDTH5B.js";
+} from "./chunk-RLGY2QIL.js";
 import {
   DEFAULT_CONTROL_CONFIG,
   buildControlEvent,
@@ -197,42 +196,49 @@ import {
   READ_ONLY_WRITE_SPAWN_ERROR,
   resolveChildPermissions,
   snapshotParentPermissionMode
-} from "./chunk-PTFBPO3C.js";
-import "./chunk-YWOJIGFY.js";
+} from "./chunk-ZEVFBFNF.js";
+import "./chunk-YSB6URMT.js";
+import "./chunk-6ZZHGUSA.js";
 import "./chunk-53YJI7JU.js";
-import "./chunk-5ZQXRPMC.js";
-import "./chunk-XHIRAZ26.js";
-import "./chunk-5Q4A37RB.js";
+import "./chunk-IAZSK7KK.js";
+import "./chunk-TCT6PCUR.js";
 import {
   subagentCommunicationEnabled
-} from "./chunk-I74LN5JG.js";
-import "./chunk-UOEDI7RP.js";
-import "./chunk-2HMIRK7W.js";
+} from "./chunk-HUD2RFJW.js";
+import "./chunk-4KNKQGHM.js";
+import "./chunk-LHV3V67B.js";
 import "./chunk-URD2SLIT.js";
-import "./chunk-WIF24I7G.js";
-import "./chunk-M3LZLQW2.js";
+import {
+  resolveSubagentRequestParams
+} from "./chunk-APVM5NEU.js";
+import "./chunk-F2V2F4ZG.js";
+import "./chunk-BDRGN3L2.js";
 import "./chunk-FY4A63RK.js";
-import "./chunk-KKUTQQV7.js";
-import "./chunk-CSFI6YXL.js";
+import "./chunk-RYRGL7P4.js";
+import "./chunk-ES6PBSIE.js";
 import {
   SessionManager
-} from "./chunk-2KIPT4HJ.js";
+} from "./chunk-PWHTSQC4.js";
 import "./chunk-FVDOXRUD.js";
 import "./chunk-UJOCPOMX.js";
 import "./chunk-IMLCWLPI.js";
-import "./chunk-UAEOTO52.js";
+import "./chunk-MNQXDFPV.js";
 import "./chunk-RQ2Q5IYR.js";
-import "./chunk-B4HP6ZWM.js";
-import "./chunk-GS42T6MX.js";
-import "./chunk-RDDAZOMU.js";
-import "./chunk-FQMM2EZ2.js";
+import {
+  collectUsageRequests,
+  totalRequestUsage
+} from "./chunk-SWWHZ2RI.js";
+import "./chunk-RHCGYWO7.js";
+import "./chunk-QW3AAHWN.js";
+import "./chunk-JL4HYQXK.js";
+import "./chunk-64XTQNLA.js";
 import "./chunk-Q4Q6D4IY.js";
 import "./chunk-BRJX2PRC.js";
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/foreground/subagent-executor.js
 import { randomUUID as randomUUID4 } from "node:crypto";
-import * as fs15 from "node:fs";
-import * as path15 from "node:path";
+import * as fs16 from "node:fs";
+import * as path16 from "node:path";
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/foreground/chain-clarify.js
 import { matchesKey, visibleWidth, truncateToWidth } from "@ashx-j/lunr-tui";
@@ -916,16 +922,72 @@ var ChainClarifyComponent = class {
 };
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/foreground/chain-execution.js
-import * as fs7 from "node:fs";
-import * as path6 from "node:path";
+import * as fs8 from "node:fs";
+import * as path7 from "node:path";
+
+// packages/coding-agent/dist/builtin-extensions/pi-subagents/src/shared/session-tokens.js
+import * as fs from "node:fs";
+import * as path from "node:path";
+function parseSessionRequests(sessionPath) {
+  if (!sessionPath)
+    return [];
+  try {
+    let files = fs.statSync(sessionPath).isDirectory() ? fs.readdirSync(sessionPath).filter((name) => name.endsWith(".jsonl")).map((name) => path.join(sessionPath, name)) : [sessionPath], requests = /* @__PURE__ */ new Map();
+    for (let file of files) {
+      let entries = [];
+      for (let line of fs.readFileSync(file, "utf-8").split(`
+`))
+        try {
+          let entry = JSON.parse(line);
+          entry?.type && entries.push(entry);
+        } catch {
+        }
+      for (let request of collectUsageRequests(entries))
+        requests.set(request.id, request);
+    }
+    return [...requests.values()];
+  } catch {
+    return [];
+  }
+}
+function parseSessionUsage(sessionPath) {
+  let requests = parseSessionRequests(sessionPath);
+  if (requests.length === 0)
+    return null;
+  let total = totalRequestUsage(requests);
+  return {
+    input: total.input,
+    output: total.output,
+    cacheRead: total.cacheRead,
+    cacheWrite: total.cacheWrite,
+    cost: total.cost,
+    turns: requests.length,
+    unknownRequests: total.unknownRequests,
+    partialRequests: total.partialRequests,
+    unknownCosts: total.unknownCosts
+  };
+}
+function sessionUsageDelta(current, previous) {
+  return {
+    unknownRequests: Math.max(0, (current.unknownRequests ?? 0) - (previous?.unknownRequests ?? 0)),
+    partialRequests: Math.max(0, (current.partialRequests ?? 0) - (previous?.partialRequests ?? 0)),
+    unknownCosts: Math.max(0, (current.unknownCosts ?? 0) - (previous?.unknownCosts ?? 0)),
+    input: Math.max(0, current.input - (previous?.input ?? 0)),
+    output: Math.max(0, current.output - (previous?.output ?? 0)),
+    cacheRead: Math.max(0, current.cacheRead - (previous?.cacheRead ?? 0)),
+    cacheWrite: Math.max(0, current.cacheWrite - (previous?.cacheWrite ?? 0)),
+    cost: Math.max(0, current.cost - (previous?.cost ?? 0)),
+    turns: Math.max(0, current.turns - (previous?.turns ?? 0))
+  };
+}
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/foreground/execution.js
 import { spawn } from "node:child_process";
 import { existsSync as existsSync2, unlinkSync } from "node:fs";
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/shared/child-transcript.js
-import * as fs from "node:fs";
-import * as path from "node:path";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
 var CHILD_TRANSCRIPT_ARTIFACT_VERSION = 1, DEFAULT_MAX_CHILD_TRANSCRIPT_BYTES = 50 * 1024 * 1024;
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -973,7 +1035,7 @@ function createChildTranscriptWriter(input) {
     if (bytesWritten + markerBytes > maxBytes)
       return !1;
     try {
-      return fs.appendFileSync(input.transcriptPath, marker, "utf-8"), bytesWritten += markerBytes, !0;
+      return fs2.appendFileSync(input.transcriptPath, marker, "utf-8"), bytesWritten += markerBytes, !0;
     } catch (error) {
       return writeError = `Failed to write child transcript '${input.transcriptPath}': ${errorMessage(error)}`, !1;
     }
@@ -997,13 +1059,13 @@ function createChildTranscriptWriter(input) {
       return;
     }
     try {
-      fs.appendFileSync(input.transcriptPath, line, "utf-8"), bytesWritten += bytes;
+      fs2.appendFileSync(input.transcriptPath, line, "utf-8"), bytesWritten += bytes;
     } catch (error) {
       writeError = `Failed to write child transcript '${input.transcriptPath}': ${errorMessage(error)}`;
     }
   };
   try {
-    fs.mkdirSync(path.dirname(input.transcriptPath), { recursive: !0 }), fs.writeFileSync(input.transcriptPath, "", "utf-8");
+    fs2.mkdirSync(path2.dirname(input.transcriptPath), { recursive: !0 }), fs2.writeFileSync(input.transcriptPath, "", "utf-8");
   } catch (error) {
     writeError = `Failed to initialize child transcript '${input.transcriptPath}': ${errorMessage(error)}`;
   }
@@ -1225,17 +1287,17 @@ function evaluateCompletionMutationGuard(input) {
 }
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/shared/pi-spawn.js
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
 import { fileURLToPath } from "node:url";
 var PI_CODING_AGENT_PACKAGE = "@ashx-j/lunr", PI_SUBAGENT_PI_BINARY_ENV = "PI_SUBAGENT_PI_BINARY";
 function findPiPackageRootFromEntry(entryPoint) {
-  let dir = path2.dirname(entryPoint);
-  for (; dir !== path2.dirname(dir); ) {
-    let packageJsonPath = path2.join(dir, "package.json");
-    if (fs2.existsSync(packageJsonPath) && JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8")).name === PI_CODING_AGENT_PACKAGE)
+  let dir = path3.dirname(entryPoint);
+  for (; dir !== path3.dirname(dir); ) {
+    let packageJsonPath = path3.join(dir, "package.json");
+    if (fs3.existsSync(packageJsonPath) && JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8")).name === PI_CODING_AGENT_PACKAGE)
       return dir;
-    dir = path2.dirname(dir);
+    dir = path3.dirname(dir);
   }
 }
 function resolveInstalledPiPackageRoot() {
@@ -1244,7 +1306,7 @@ function resolveInstalledPiPackageRoot() {
 function resolvePiPackageRoot() {
   try {
     let entry = process.argv[1];
-    return entry ? findPiPackageRootFromEntry(fs2.realpathSync(entry)) : void 0;
+    return entry ? findPiPackageRootFromEntry(fs3.realpathSync(entry)) : void 0;
   } catch {
     return;
   }
@@ -1253,10 +1315,10 @@ function isRunnableNodeScript(filePath, existsSync11) {
   return existsSync11(filePath) ? /\.(?:mjs|cjs|js)$/i.test(filePath) : !1;
 }
 function normalizePath(filePath) {
-  return path2.isAbsolute(filePath) ? filePath : path2.resolve(filePath);
+  return path3.isAbsolute(filePath) ? filePath : path3.resolve(filePath);
 }
 function resolvePiCliScript(deps = {}) {
-  let existsSync11 = deps.existsSync ?? fs2.existsSync, realpathSync5 = deps.realpathSync ?? fs2.realpathSync, readFileSync8 = deps.readFileSync ?? ((filePath, encoding) => fs2.readFileSync(filePath, encoding)), argv1 = deps.argv1 ?? process.argv[1];
+  let existsSync11 = deps.existsSync ?? fs3.existsSync, realpathSync5 = deps.realpathSync ?? fs3.realpathSync, readFileSync9 = deps.readFileSync ?? ((filePath, encoding) => fs3.readFileSync(filePath, encoding)), argv1 = deps.argv1 ?? process.argv[1];
   if (argv1) {
     let argvPath = normalizePath(argv1);
     if (isRunnableNodeScript(argvPath, existsSync11))
@@ -1271,15 +1333,15 @@ function resolvePiCliScript(deps = {}) {
     let packageJsonPath = (deps.resolvePackageJson ?? (() => {
       let root = deps.piPackageRoot ?? resolvePiPackageRoot();
       if (root)
-        return path2.join(root, "package.json");
+        return path3.join(root, "package.json");
       let packageRoot = deps.resolvePackageEntry ? findPiPackageRootFromEntry(deps.resolvePackageEntry()) : resolveInstalledPiPackageRoot();
       if (!packageRoot)
         throw new Error(`Could not resolve ${PI_CODING_AGENT_PACKAGE} package root`);
-      return path2.join(packageRoot, "package.json");
-    }))(), binField = JSON.parse(readFileSync8(packageJsonPath, "utf-8")).bin, binPath = typeof binField == "string" ? binField : binField?.pi ?? Object.values(binField ?? {})[0];
+      return path3.join(packageRoot, "package.json");
+    }))(), binField = JSON.parse(readFileSync9(packageJsonPath, "utf-8")).bin, binPath = typeof binField == "string" ? binField : binField?.pi ?? Object.values(binField ?? {})[0];
     if (!binPath)
       return;
-    let candidate = path2.resolve(path2.dirname(packageJsonPath), binPath);
+    let candidate = path3.resolve(path3.dirname(packageJsonPath), binPath);
     if (isRunnableNodeScript(candidate, existsSync11))
       return candidate;
   } catch {
@@ -1298,7 +1360,7 @@ function getPiSpawnCommand(args, deps = {}) {
 }
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/shared/jsonl-writer.js
-import * as fs3 from "node:fs";
+import * as fs4 from "node:fs";
 var DEFAULT_MAX_JSONL_BYTES = 50 * 1024 * 1024;
 function createJsonlWriter(filePath, source, deps = {}) {
   if (!filePath)
@@ -1308,7 +1370,7 @@ function createJsonlWriter(filePath, source, deps = {}) {
       async close() {
       }
     };
-  let createWriteStream2 = deps.createWriteStream ?? ((targetPath) => fs3.createWriteStream(targetPath, { flags: "a" })), stream;
+  let createWriteStream2 = deps.createWriteStream ?? ((targetPath) => fs4.createWriteStream(targetPath, { flags: "a" })), stream;
   try {
     stream = createWriteStream2(filePath);
   } catch {
@@ -1346,13 +1408,6 @@ function createJsonlWriter(filePath, source, deps = {}) {
 }
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/shared/post-exit-stdio-guard.js
-function trySignalChild(child, signal) {
-  try {
-    return child.kill(signal);
-  } catch {
-    return !1;
-  }
-}
 function attachPostExitStdioGuard(child, options) {
   let { idleMs, hardMs } = options, exited = !1, stdoutEnded = !1, stderrEnded = !1, idleTimer, hardTimer, destroyUnendedStdio = () => {
     if (!stdoutEnded)
@@ -1380,12 +1435,12 @@ function attachPostExitStdioGuard(child, options) {
 }
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/shared/single-output.js
-import * as fs4 from "node:fs";
-import * as path3 from "node:path";
+import * as fs5 from "node:fs";
+import * as path4 from "node:path";
 function extractChildWrittenOutput(messages, outputPath, cwd) {
   if (!messages?.length || !outputPath)
     return;
-  let resolvedTarget = path3.resolve(cwd ?? ".", outputPath), comparableTarget = process.platform === "win32" ? resolvedTarget.toLowerCase() : resolvedTarget, successfulCallIds = /* @__PURE__ */ new Set();
+  let resolvedTarget = path4.resolve(cwd ?? ".", outputPath), comparableTarget = process.platform === "win32" ? resolvedTarget.toLowerCase() : resolvedTarget, successfulCallIds = /* @__PURE__ */ new Set();
   for (let message of messages)
     message.role === "toolResult" && message.isError === !1 && typeof message.toolCallId == "string" && successfulCallIds.add(message.toolCallId);
   let content;
@@ -1397,7 +1452,7 @@ function extractChildWrittenOutput(messages, outputPath, cwd) {
         let args = typeof part.arguments == "object" && part.arguments !== null && !Array.isArray(part.arguments) ? part.arguments : {};
         if (typeof args.path != "string" || typeof args.content != "string")
           continue;
-        let resolvedWritePath = path3.resolve(cwd ?? ".", args.path);
+        let resolvedWritePath = path4.resolve(cwd ?? ".", args.path);
         (process.platform === "win32" ? resolvedWritePath.toLowerCase() : resolvedWritePath) === comparableTarget && (content = args.content);
       }
   return content;
@@ -1413,12 +1468,12 @@ function normalizeSingleOutputOverride(output, defaultOutput) {
 function resolveSingleOutputPath(output, runtimeCwd, requestedCwd, relativeBaseDir) {
   if (typeof output != "string" || !output || output === "false" || output === "true")
     return;
-  if (path3.isAbsolute(output))
+  if (path4.isAbsolute(output))
     return output;
   if (relativeBaseDir)
-    return path3.resolve(relativeBaseDir, output);
-  let baseCwd = requestedCwd ? path3.isAbsolute(requestedCwd) ? requestedCwd : path3.resolve(runtimeCwd, requestedCwd) : runtimeCwd;
-  return path3.resolve(baseCwd, output);
+    return path4.resolve(relativeBaseDir, output);
+  let baseCwd = requestedCwd ? path4.isAbsolute(requestedCwd) ? requestedCwd : path4.resolve(runtimeCwd, requestedCwd) : runtimeCwd;
+  return path4.resolve(baseCwd, output);
 }
 function formatOutputPathInstruction(outputPath, capabilities) {
   return [
@@ -1461,7 +1516,7 @@ function formatByteSize(bytes) {
   return `${value.toFixed(1)} ${units[unitIndex]}`;
 }
 function formatSavedOutputReference(savedPath, fullOutput) {
-  let absolutePath = path3.resolve(savedPath), bytes = Buffer.byteLength(fullOutput, "utf-8"), lines = countLines(fullOutput);
+  let absolutePath = path4.resolve(savedPath), bytes = Buffer.byteLength(fullOutput, "utf-8"), lines = countLines(fullOutput);
   return {
     path: absolutePath,
     bytes,
@@ -1476,7 +1531,7 @@ function validateFileOnlyOutputMode(outputMode, outputPath, context) {
 function captureSingleOutputSnapshot(outputPath) {
   if (outputPath)
     try {
-      let stat = fs4.statSync(outputPath);
+      let stat = fs5.statSync(outputPath);
       return { exists: !0, mtimeMs: stat.mtimeMs, size: stat.size };
     } catch {
       return { exists: !1 };
@@ -1486,7 +1541,7 @@ function persistSingleOutput(outputPath, fullOutput) {
   if (!outputPath)
     return {};
   try {
-    return fs4.mkdirSync(path3.dirname(outputPath), { recursive: !0 }), fs4.writeFileSync(outputPath, fullOutput, "utf-8"), { savedPath: outputPath };
+    return fs5.mkdirSync(path4.dirname(outputPath), { recursive: !0 }), fs5.writeFileSync(outputPath, fullOutput, "utf-8"), { savedPath: outputPath };
   } catch (err) {
     return { error: err instanceof Error ? err.message : String(err) };
   }
@@ -1496,7 +1551,7 @@ function resolveSingleOutput(outputPath, fallbackOutput, beforeRun) {
     return { fullOutput: fallbackOutput };
   let changedSinceStart = !1;
   try {
-    let stat = fs4.statSync(outputPath);
+    let stat = fs5.statSync(outputPath);
     changedSinceStart = !beforeRun?.exists || stat.mtimeMs !== beforeRun.mtimeMs || stat.size !== beforeRun.size;
   } catch (error) {
     let code = error && typeof error == "object" && "code" in error ? error.code : void 0;
@@ -1508,7 +1563,7 @@ function resolveSingleOutput(outputPath, fallbackOutput, beforeRun) {
   }
   if (changedSinceStart)
     try {
-      return { fullOutput: fs4.readFileSync(outputPath, "utf-8"), savedPath: outputPath };
+      return { fullOutput: fs5.readFileSync(outputPath, "utf-8"), savedPath: outputPath };
     } catch (error) {
       return {
         fullOutput: fallbackOutput,
@@ -1608,10 +1663,10 @@ function projectChildLifecycle(event, terminalAssistantStop = !1) {
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/foreground/execution.js
 var artifactOutputByResult = /* @__PURE__ */ new WeakMap(), acceptanceOutputByResult = /* @__PURE__ */ new WeakMap();
 function emptyUsage() {
-  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0, unknownRequests: 0, partialRequests: 0, unknownCosts: 0 };
 }
 function sumUsage(target, source) {
-  target.input += source.input, target.output += source.output, target.cacheRead += source.cacheRead, target.cacheWrite += source.cacheWrite, target.cost += source.cost, target.turns += source.turns;
+  target.input += source.input, target.output += source.output, target.cacheRead += source.cacheRead, target.cacheWrite += source.cacheWrite, target.cost += source.cost, target.turns += source.turns, target.unknownRequests += source.unknownRequests ?? 0, target.partialRequests += source.partialRequests ?? 0, target.unknownCosts += source.unknownCosts ?? 0;
 }
 function formatTimeoutMessage(timeoutMs) {
   return `Subagent timed out after ${timeoutMs}ms.`;
@@ -1682,7 +1737,7 @@ function snapshotResult(result2, progress) {
   };
 }
 async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared) {
-  let effectiveThinking = options.thinkingOverride, modelArg = applyThinkingSuffix(model, effectiveThinking, options.thinkingOverride !== void 0), watchdogConfig = resolveWatchdogConfig(options.cwd ?? runtimeCwd), childWatchdog = watchdogConfig.ok ? resolveChildWatchdogConfig({
+  let usageBeforeAttempt = parseSessionUsage(options.sessionFile ?? options.sessionDir), effectiveThinking = options.thinkingOverride, modelArg = applyThinkingSuffix(model, effectiveThinking, options.thinkingOverride !== void 0), watchdogConfig = resolveWatchdogConfig(options.cwd ?? runtimeCwd), childWatchdog = watchdogConfig.ok ? resolveChildWatchdogConfig({
     config: watchdogConfig.config,
     agent: spec.childId,
     runId: options.runId,
@@ -1783,7 +1838,35 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
       env: spawnEnv,
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: !0
-    }), jsonlWriter = createJsonlWriter(shared.jsonlPath, proc.stdout), processClosed = !1, settled = !1, detached = !1, intercomStarted = !1, assistantError, removeAbortListener, removeInterruptListener, activityTimer, timeoutTimer, timeoutTerminationTimer, timeoutHardKillTimer, turnBudgetSoftReached = !1, turnBudgetTerminationTimer, turnBudgetHardKillTimer, protocolHardKillTimer, clearTurnBudgetTimers = () => {
+    }), jsonlWriter = createJsonlWriter(shared.jsonlPath, proc.stdout), spawned = typeof proc.pid == "number" && proc.pid > 0;
+    proc.once("spawn", () => {
+      spawned = !0;
+    });
+    let processClosed = !1, settled = !1, detached = !1, intercomStarted = !1, assistantError, removeAbortListener, removeInterruptListener, activityTimer, timeoutTimer, timeoutTerminationTimer, timeoutHardKillTimer, turnBudgetSoftReached = !1, turnBudgetTerminationTimer, turnBudgetHardKillTimer, protocolHardKillTimer, cancellationHardKillTimer, interruptTerminationTimer, terminationCheckTimer, terminationUnconfirmedReported = !1, clearCancellationTimers = () => {
+      terminationCheckTimer && clearTimeout(terminationCheckTimer), terminationCheckTimer = void 0, cancellationHardKillTimer && clearTimeout(cancellationHardKillTimer), interruptTerminationTimer && clearTimeout(interruptTerminationTimer), cancellationHardKillTimer = void 0, interruptTerminationTimer = void 0;
+    }, recordProcessError = (error) => {
+      result2.error || (result2.error = error instanceof Error ? error.message : String(error)), progress.error = result2.error, !childExited && !processClosed && !settled && !detached && (progress.status = "running", fireUpdate());
+    }, signalChild = (signal) => {
+      if (childExited || processClosed || settled || detached)
+        return !1;
+      let sent = !1;
+      try {
+        sent = proc.kill(signal);
+      } catch (error) {
+        recordProcessError(error);
+      }
+      return !sent && !childExited && !processClosed && !settled && !detached && recordProcessError(`Subagent ${signal} could not be delivered; child exit is not confirmed.`), signal === "SIGKILL" && !childExited && !processClosed && !settled && !detached && !terminationCheckTimer && !terminationUnconfirmedReported && (terminationCheckTimer = setTimeout(() => {
+        if (terminationCheckTimer = void 0, childExited || processClosed || settled || detached)
+          return;
+        terminationUnconfirmedReported = !0;
+        let message = `Subagent termination unconfirmed after SIGKILL${proc.pid ? ` (diagnostic PID ${proc.pid})` : ""}. This foreground call still owns the child and waits for its exit. Verify the child process before starting replacement work.`;
+        progress.status = "running", progress.error = message, progress.activityState = "needs_attention", progress.durationMs = Date.now() - startTime, appendRecentOutput(progress, [message]), emitUpdateSnapshot(message);
+      }, 2e3), terminationCheckTimer.unref?.()), sent;
+    }, scheduleCancellationHardKill = (delayMs) => {
+      cancellationHardKillTimer || childExited || processClosed || settled || detached || (cancellationHardKillTimer = setTimeout(() => {
+        cancellationHardKillTimer = void 0, !childExited && !processClosed && !settled && !detached && signalChild("SIGKILL");
+      }, delayMs), cancellationHardKillTimer.unref?.());
+    }, clearTurnBudgetTimers = () => {
       turnBudgetTerminationTimer && (clearTimeout(turnBudgetTerminationTimer), turnBudgetTerminationTimer = void 0), turnBudgetHardKillTimer && (clearTimeout(turnBudgetHardKillTimer), turnBudgetHardKillTimer = void 0);
     }, clearTimeoutTimers = () => {
       timeoutTimer && (clearTimeout(timeoutTimer), timeoutTimer = void 0), timeoutTerminationTimer && (clearTimeout(timeoutTerminationTimer), timeoutTerminationTimer = void 0), timeoutHardKillTimer && (clearTimeout(timeoutHardKillTimer), timeoutHardKillTimer = void 0);
@@ -1805,9 +1888,11 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
         return;
       }
       childExited || finalDrainTimer || settled || processClosed || detached || (finalDrainTimer = setTimeout(() => {
-        settled || processClosed || detached || !trySignalChild(proc, "SIGTERM") || (forcedTerminationSignal = !0, !cleanTerminalAssistantStopReceived && !agentSettledReceived && !assistantError && (result2.error = result2.error ?? `Subagent process did not exit within ${FINAL_STOP_GRACE_MS}ms after its terminal event. Forcing termination.`), finalHardKillTimer = setTimeout(() => {
-          settled || processClosed || detached || (forcedTerminationSignal = trySignalChild(proc, "SIGKILL") || forcedTerminationSignal);
-        }, HARD_KILL_MS), finalHardKillTimer.unref?.());
+        if (settled || processClosed || detached)
+          return;
+        forcedTerminationSignal = signalChild("SIGTERM") || forcedTerminationSignal, !cleanTerminalAssistantStopReceived && !agentSettledReceived && !assistantError && (result2.error = result2.error ?? `Subagent process did not exit within ${FINAL_STOP_GRACE_MS}ms after its terminal event. Forcing termination.`), finalHardKillTimer = setTimeout(() => {
+          settled || processClosed || detached || (forcedTerminationSignal = signalChild("SIGKILL") || forcedTerminationSignal);
+        }, HARD_KILL_MS), finalHardKillTimer.unref?.();
       }, FINAL_STOP_GRACE_MS), finalDrainTimer.unref?.());
     };
     function armWatchdogTail() {
@@ -1841,7 +1926,7 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
         return;
       options.intercomEvents?.emit(INTERCOM_DETACH_RESPONSE_EVENT, { requestId, accepted: !0, runId: options.runId, agent: spec.childId, childIndex: options.index ?? 0 }), detachForIntercom();
     }), finish = (code) => {
-      settled || (settled = !0, clearFinalDrainTimers(), clearWatchdogTailTimer(), clearStdioGuard(), clearTimeoutTimers(), clearTurnBudgetTimers(), protocolHardKillTimer && (clearTimeout(protocolHardKillTimer), protocolHardKillTimer = void 0), activityTimer && (clearInterval(activityTimer), activityTimer = void 0), unsubscribeIntercomDetach?.(), removeAbortListener?.(), removeInterruptListener?.(), resolve7(code));
+      settled || (settled = !0, clearCancellationTimers(), clearFinalDrainTimers(), clearWatchdogTailTimer(), clearStdioGuard(), clearTimeoutTimers(), clearTurnBudgetTimers(), protocolHardKillTimer && (clearTimeout(protocolHardKillTimer), protocolHardKillTimer = void 0), activityTimer && (clearInterval(activityTimer), activityTimer = void 0), unsubscribeIntercomDetach?.(), removeAbortListener?.(), removeInterruptListener?.(), resolve7(code));
     }, drainPendingControlEvents = () => {
       if (pendingControlEvents.length === 0)
         return;
@@ -1900,10 +1985,10 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
       if (!budget || result2.timedOut || result2.turnBudgetExceeded || interruptedByControl || processClosed || settled || detached)
         return;
       let message = turnBudgetExceededMessage(budget, turnCount);
-      result2.turnBudgetExceeded = !0, result2.wrapUpRequested = !0, result2.turnBudget = turnBudgetState(budget, turnCount, !0), result2.error = message, result2.finalOutput = message, progress.status = "failed", progress.error = message, progress.durationMs = Date.now() - startTime, fireUpdate(), trySignalChild(proc, "SIGINT"), turnBudgetTerminationTimer = setTimeout(() => {
-        processClosed || settled || detached || result2.timedOut || trySignalChild(proc, "SIGTERM");
+      result2.turnBudgetExceeded = !0, result2.wrapUpRequested = !0, result2.turnBudget = turnBudgetState(budget, turnCount, !0), result2.error = message, result2.finalOutput = message, progress.status = "failed", progress.error = message, progress.durationMs = Date.now() - startTime, fireUpdate(), signalChild("SIGINT"), turnBudgetTerminationTimer = setTimeout(() => {
+        processClosed || settled || detached || result2.timedOut || signalChild("SIGTERM");
       }, 1e3), turnBudgetTerminationTimer.unref?.(), turnBudgetHardKillTimer = setTimeout(() => {
-        processClosed || settled || detached || result2.timedOut || trySignalChild(proc, "SIGKILL");
+        processClosed || settled || detached || result2.timedOut || signalChild("SIGKILL");
       }, 4e3), turnBudgetHardKillTimer.unref?.();
     }, updateTurnBudget = (turnCount, terminalAssistantStop) => {
       let budget = options.turnBudget;
@@ -2008,7 +2093,7 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
           let stopReason = evt.message.stopReason, hasToolCall = Array.isArray(evt.message.content) && evt.message.content.some((part) => part.type === "toolCall"), terminalAssistantStop = stopReason === "stop" && !hasToolCall;
           updateTurnBudget(result2.usage.turns, terminalAssistantStop);
           let u = evt.message.usage;
-          if (u && (result2.usage.input += u.input || 0, result2.usage.output += u.output || 0, result2.usage.cacheRead += u.cacheRead || 0, result2.usage.cacheWrite += u.cacheWrite || 0, result2.usage.cost += u.cost?.total || 0, progress.tokens = result2.usage.input + result2.usage.output), !result2.model && evt.message.model) {
+          if (u && (result2.usage.input += u.input || 0, result2.usage.output += u.output || 0, result2.usage.cacheRead += u.cacheRead || 0, result2.usage.cacheWrite += u.cacheWrite || 0, result2.usage.cost += u.cost?.total || 0, result2.usage.unknownRequests += +(u.measurement === "unknown"), result2.usage.partialRequests += +(u.measurement === "partial"), result2.usage.unknownCosts += +(u.costSource === "unknown"), progress.tokens = result2.usage.input + result2.usage.output + result2.usage.cacheRead + result2.usage.cacheWrite), !result2.model && evt.message.model) {
             result2.model = evt.message.model;
             let parsed = splitKnownThinkingSuffix(evt.message.model);
             parsed.thinkingSuffix && (result2.thinking = parsed.thinkingSuffix.slice(1)), progress.model = result2.model, progress.thinking = result2.thinking;
@@ -2048,15 +2133,15 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
       let now = Date.now();
       updateActivityState(now) && (progress.durationMs = now - startTime, fireUpdate());
     }, 1e3), activityTimer.unref?.()), attemptTimeout && (timeoutTimer = setTimeout(() => {
-      processClosed || settled || detached || interruptedByControl || (result2.timedOut = !0, result2.error = attemptTimeout.message, result2.finalOutput = attemptTimeout.message, progress.status = "failed", progress.error = attemptTimeout.message, progress.durationMs = Date.now() - startTime, fireUpdate(), trySignalChild(proc, "SIGINT"), timeoutTerminationTimer = setTimeout(() => {
-        processClosed || settled || detached || trySignalChild(proc, "SIGTERM");
+      processClosed || settled || detached || interruptedByControl || (result2.timedOut = !0, result2.error = attemptTimeout.message, result2.finalOutput = attemptTimeout.message, progress.status = "failed", progress.error = attemptTimeout.message, progress.durationMs = Date.now() - startTime, fireUpdate(), signalChild("SIGINT"), timeoutTerminationTimer = setTimeout(() => {
+        processClosed || settled || detached || signalChild("SIGTERM");
       }, 1e3), timeoutTerminationTimer.unref?.(), timeoutHardKillTimer = setTimeout(() => {
-        processClosed || settled || detached || trySignalChild(proc, "SIGKILL");
+        processClosed || settled || detached || signalChild("SIGKILL");
       }, 4e3), timeoutHardKillTimer.unref?.());
     }, attemptTimeout.remainingMs), timeoutTimer.unref?.());
     let stderrTail = createBoundedByteTail(), stdoutReader = createBoundedLineReader({ onLine: processLine, onLimit: (limit) => {
-      result2.protocolError || (result2.protocolError = limit, result2.error = formatProtocolOutputLimit(limit), progress.status = "failed", progress.error = result2.error, progress.durationMs = Date.now() - startTime, fireUpdate(), childExited || (trySignalChild(proc, "SIGTERM"), protocolHardKillTimer = setTimeout(() => {
-        childExited || trySignalChild(proc, "SIGKILL");
+      result2.protocolError || (result2.protocolError = limit, result2.error = formatProtocolOutputLimit(limit), progress.status = "failed", progress.error = result2.error, progress.durationMs = Date.now() - startTime, fireUpdate(), childExited || (signalChild("SIGTERM"), protocolHardKillTimer = setTimeout(() => {
+        childExited || signalChild("SIGKILL");
       }, 3e3), protocolHardKillTimer.unref?.()));
     } }), stderrReader = createBoundedLineReader({
       stream: "stderr",
@@ -2064,15 +2149,19 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
       onLine: (line) => shared.transcriptWriter?.writeStderrLine(line),
       onLimit: (limit) => shared.transcriptWriter?.writeStderrLine(formatProtocolOutputLimit(limit))
     }), clearStdioGuard = attachPostExitStdioGuard(proc, { idleMs: 2e3, hardMs: 8e3 });
-    if (proc.stdout.on("data", (chunk) => stdoutReader.push(chunk)), proc.stderr.on("data", (chunk) => {
+    proc.stdout.on("data", (chunk) => stdoutReader.push(chunk)), proc.stderr.on("data", (chunk) => {
       stderrTail.push(chunk), stderrReader.push(chunk);
-    }), proc.on("exit", () => {
-      childExited = !0, clearFinalDrainTimers();
-    }), proc.on("close", (code, signal) => {
-      clearFinalDrainTimers(), clearStdioGuard(), jsonlWriter.close().catch(() => {
+    });
+    let confirmChildExit = () => {
+      childExited = !0, terminationUnconfirmedReported && (progress.error = result2.error, progress.activityState = void 0), clearCancellationTimers(), clearFinalDrainTimers();
+    };
+    if (proc.on("exit", confirmChildExit), proc.on("close", (code, signal) => {
+      confirmChildExit(), clearFinalDrainTimers(), clearStdioGuard(), jsonlWriter.close().catch(() => {
       });
       let toolDiagnosticError = readChildToolDiagnosticError(toolDiagnosticPath);
       cleanupTempDir(tempDir), stdoutReader.end(), stderrReader.end();
+      let persistedUsage = parseSessionUsage(options.sessionFile ?? options.sessionDir ?? result2.sessionFile);
+      persistedUsage && (result2.usageRequests = parseSessionRequests(options.sessionFile ?? options.sessionDir ?? result2.sessionFile), result2.usage = options.sessionFile ? persistedUsage : sessionUsageDelta(persistedUsage, usageBeforeAttempt), progress.tokens = result2.usage.input + result2.usage.output + result2.usage.cacheRead + result2.usage.cacheWrite);
       let stderr = stderrTail.text(), closeError = result2.error ?? toolDiagnosticError ?? assistantError, forcedDrainAfterFinalSuccess = forcedTerminationSignal && (cleanTerminalAssistantStopReceived || agentSettledReceived) && !closeError;
       code !== 0 && stderr.trim() && !closeError && !forcedDrainAfterFinalSuccess && (closeError = stderr.trim());
       let finalCode = forcedDrainAfterFinalSuccess ? 0 : forcedTerminationSignal || signal ? code ?? 1 : code ?? 0;
@@ -2100,19 +2189,23 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
       }
       !result2.error && closeError && (result2.error = closeError), processClosed = !0, finish(finalCode);
     }), proc.on("error", (error) => {
+      if (spawned) {
+        recordProcessError(error);
+        return;
+      }
       clearFinalDrainTimers(), clearStdioGuard(), jsonlWriter.close().catch(() => {
       }), cleanupTempDir(tempDir), stdoutReader.end(), stderrReader.end(), result2.error || (result2.error = error instanceof Error ? error.message : String(error)), finish(1);
     }), options.signal) {
       let kill = () => {
-        processClosed || detached || (proc.kill("SIGTERM"), setTimeout(() => !proc.killed && proc.kill("SIGKILL"), 3e3));
+        childExited || processClosed || settled || detached || (signalChild("SIGTERM"), scheduleCancellationHardKill(3e3));
       };
       options.signal.aborted ? kill() : (options.signal.addEventListener("abort", kill, { once: !0 }), removeAbortListener = () => options.signal?.removeEventListener("abort", kill));
     }
     if (options.interruptSignal) {
       let interrupt = () => {
-        processClosed || detached || settled || result2.timedOut || (interruptedByControl = !0, clearTimeoutTimers(), progress.status = "running", progress.durationMs = Date.now() - startTime, result2.interrupted = !0, result2.finalOutput = "Interrupted. Waiting for explicit next action.", progress.activityState = void 0, fireUpdate(), trySignalChild(proc, "SIGINT"), setTimeout(() => {
-          settled || processClosed || detached || trySignalChild(proc, "SIGTERM");
-        }, 1e3).unref?.());
+        processClosed || detached || settled || result2.timedOut || (interruptedByControl = !0, clearTimeoutTimers(), progress.status = "running", progress.durationMs = Date.now() - startTime, result2.interrupted = !0, result2.finalOutput = "Interrupted. Waiting for explicit next action.", progress.activityState = void 0, fireUpdate(), signalChild("SIGINT"), interruptTerminationTimer = setTimeout(() => {
+          childExited || settled || processClosed || detached || signalChild("SIGTERM");
+        }, 1e3), interruptTerminationTimer.unref?.(), scheduleCancellationHardKill(4e3));
       };
       options.interruptSignal.aborted ? interrupt() : (options.interruptSignal.addEventListener("abort", interrupt, { once: !0 }), removeInterruptListener = () => options.interruptSignal?.removeEventListener("abort", interrupt));
     }
@@ -2303,9 +2396,9 @@ ${acceptanceFailure2}` : acceptanceFailure2, recoveredResult.progress && (recove
 Acceptance evaluation failed: ${message}` : `Acceptance evaluation failed: ${message}`, options.onDetachedExit?.(recoveredResult);
       });
     }
-  } : options, lastResult, modelsToTry = candidates.length > 0 ? candidates : [void 0];
+  } : options, priorRequestIds = new Set(parseSessionRequests(options.sessionFile ?? options.sessionDir).map((request) => request.id)), lastResult, modelsToTry = candidates.length > 0 ? candidates : [void 0];
   for (let i = 0; i < modelsToTry.length; i++) {
-    let candidate = modelsToTry[i], outputSnapshot = captureSingleOutputSnapshot(options.outputPath), result3 = await runSingleAttempt(runtimeCwd, spec, taskWithAcceptance, candidate, detachedAwareOptions, {
+    let candidate = modelsToTry[i], outputSnapshot = captureSingleOutputSnapshot(options.outputPath), usageBeforeAttempt = parseSessionUsage(options.sessionFile ?? options.sessionDir), result3 = await runSingleAttempt(runtimeCwd, spec, taskWithAcceptance, candidate, detachedAwareOptions, {
       sessionEnabled,
       systemPrompt,
       resolvedSkillNames: resolvedSkills.length > 0 ? resolvedSkills.map((skill) => skill.name) : void 0,
@@ -2316,8 +2409,8 @@ Acceptance evaluation failed: ${message}` : `Acceptance evaluation failed: ${mes
       attemptNotes,
       outputSnapshot,
       originalTask: task
-    });
-    lastResult = result3, result3.model ? attemptedModels.push(result3.model) : candidate && attemptedModels.push(candidate), sumUsage(aggregateUsage, result3.usage), totalToolCount += result3.progressSummary?.toolCount ?? 0, totalDurationMs += result3.progressSummary?.durationMs ?? 0;
+    }), persistedUsage = parseSessionUsage(options.sessionFile ?? options.sessionDir ?? result3.sessionFile);
+    persistedUsage && (result3.usage = sessionUsageDelta(persistedUsage, usageBeforeAttempt)), lastResult = result3, result3.model ? attemptedModels.push(result3.model) : candidate && attemptedModels.push(candidate), sumUsage(aggregateUsage, result3.usage), totalToolCount += result3.progressSummary?.toolCount ?? 0, totalDurationMs += result3.progressSummary?.durationMs ?? 0;
     let attemptSucceeded = result3.exitCode === 0 && !result3.error, attempt = {
       model: result3.model ?? candidate ?? spec.model ?? "default",
       success: attemptSucceeded,
@@ -2339,10 +2432,10 @@ Acceptance evaluation failed: ${message}` : `Acceptance evaluation failed: ${mes
     messages: [],
     usage: emptyUsage(),
     error: "Subagent did not produce a result."
-  };
-  if (result2.usage = aggregateUsage, result2.attemptedModels = attemptedModels.length > 0 ? attemptedModels : void 0, result2.modelAttempts = modelAttempts.length > 0 ? modelAttempts : void 0, result2.progressSummary = {
+  }, cumulativeResumeUsage = options.sessionFile ? parseSessionUsage(options.sessionFile) : null;
+  if (result2.usage = cumulativeResumeUsage ?? aggregateUsage, result2.usageRequests = parseSessionRequests(options.sessionFile ?? options.sessionDir ?? result2.sessionFile).filter((request) => !!options.sessionFile || !priorRequestIds.has(request.id)), result2.usageRequests.length === 0 && (result2.usageRequests = void 0), result2.attemptedModels = attemptedModels.length > 0 ? attemptedModels : void 0, result2.modelAttempts = modelAttempts.length > 0 ? modelAttempts : void 0, result2.progressSummary = {
     toolCount: totalToolCount,
-    tokens: aggregateUsage.input + aggregateUsage.output,
+    tokens: result2.usage.input + result2.usage.output + result2.usage.cacheRead + result2.usage.cacheWrite,
     durationMs: totalDurationMs
   }, attemptNotes.length > 0 && result2.progress && (result2.progress.recentOutput = [...attemptNotes, ...result2.progress.recentOutput], result2.progress.recentOutput.length > 50 && result2.progress.recentOutput.splice(50)), transcriptWriter && (result2.transcriptPath = artifactPathsResult?.transcriptPath), transcriptWriter?.getError() && (result2.transcriptError = transcriptWriter.getError()), artifactPathsResult && options.artifactConfig?.enabled !== !1) {
     if (result2.artifactPaths = artifactPathsResult, options.artifactConfig?.includeOutput !== !1 && writeArtifact(artifactPathsResult.outputPath, artifactOutputByResult.get(result2) ?? result2.finalOutput ?? ""), options.maxOutput) {
@@ -2372,10 +2465,10 @@ ${acceptanceFailure}` : acceptanceFailure, result2.progress && (result2.progress
 }
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/shared/run-history.js
-import * as fs5 from "node:fs";
-import * as path4 from "node:path";
+import * as fs6 from "node:fs";
+import * as path5 from "node:path";
 function getHistoryPath() {
-  return path4.join(getAgentDir(), "run-history.jsonl");
+  return path5.join(getAgentDir(), "run-history.jsonl");
 }
 function recordRun(agent, task, exitCode, durationMs) {
   try {
@@ -2387,7 +2480,7 @@ function recordRun(agent, task, exitCode, durationMs) {
       duration: durationMs,
       ...exitCode !== 0 ? { exit: exitCode } : {}
     }, historyPath = getHistoryPath();
-    fs5.mkdirSync(path4.dirname(historyPath), { recursive: !0 }), fs5.appendFileSync(historyPath, `${JSON.stringify(entry)}
+    fs6.mkdirSync(path5.dirname(historyPath), { recursive: !0 }), fs6.appendFileSync(historyPath, `${JSON.stringify(entry)}
 `);
   } catch {
   }
@@ -2395,9 +2488,9 @@ function recordRun(agent, task, exitCode, durationMs) {
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/shared/worktree.js
 import { spawnSync } from "node:child_process";
-import * as fs6 from "node:fs";
+import * as fs7 from "node:fs";
 import * as os from "node:os";
-import * as path5 from "node:path";
+import * as path6 from "node:path";
 var DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS = 3e4;
 function runGit(cwd, args) {
   let result2 = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8" });
@@ -2423,9 +2516,9 @@ function resolveRepoState(cwd) {
   return { toplevel, cwdRelative, baseCommit };
 }
 function normalizeComparableCwd(cwd) {
-  let resolved = path5.resolve(cwd);
+  let resolved = path6.resolve(cwd);
   try {
-    return fs6.realpathSync(resolved);
+    return fs7.realpathSync(resolved);
   } catch {
     return resolved;
   }
@@ -2436,7 +2529,7 @@ function findWorktreeTaskCwdConflict(tasks, sharedCwd) {
     let task = tasks[index];
     if (!task.cwd)
       continue;
-    let taskCwd = path5.isAbsolute(task.cwd) ? task.cwd : path5.resolve(sharedCwd, task.cwd);
+    let taskCwd = path6.isAbsolute(task.cwd) ? task.cwd : path6.resolve(sharedCwd, task.cwd);
     if (normalizeComparableCwd(taskCwd) !== normalizedSharedCwd)
       return { index, agent: task.agent, cwd: task.cwd };
   }
@@ -2457,9 +2550,9 @@ function resolveWorktreeBaseDir(configuredBaseDir, repoRoot) {
   let trimmed = rawBaseDir.trim();
   if (!trimmed)
     throw new Error("worktree base directory cannot be empty");
-  let expanded = trimmed.startsWith("~/") ? path5.join(os.homedir(), trimmed.slice(2)) : trimmed, resolved = path5.isAbsolute(expanded) ? expanded : path5.resolve(repoRoot, expanded);
+  let expanded = trimmed.startsWith("~/") ? path6.join(os.homedir(), trimmed.slice(2)) : trimmed, resolved = path6.isAbsolute(expanded) ? expanded : path6.resolve(repoRoot, expanded);
   try {
-    fs6.mkdirSync(resolved, { recursive: !0 });
+    fs7.mkdirSync(resolved, { recursive: !0 });
   } catch (error) {
     let message = error instanceof Error ? error.message : String(error);
     throw new Error(`failed to create worktree base directory ${resolved}: ${message}`);
@@ -2467,25 +2560,25 @@ function resolveWorktreeBaseDir(configuredBaseDir, repoRoot) {
   return resolved;
 }
 function buildWorktreePath(baseDir, runId, index) {
-  return path5.join(baseDir, `pi-worktree-${runId}-${index}`);
+  return path6.join(baseDir, `pi-worktree-${runId}-${index}`);
 }
 function resolveRepoCwdRelative(cwd) {
   let repoCheck = runGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
   if (repoCheck.status !== 0 || repoCheck.stdout.trim() !== "true")
     throw new Error("worktree isolation requires a git repository");
-  let rawPrefix = runGitChecked(cwd, ["rev-parse", "--show-prefix"]).trim(), normalizedPrefix = rawPrefix ? path5.normalize(rawPrefix.replace(/[\\/]+$/, "")) : "";
+  let rawPrefix = runGitChecked(cwd, ["rev-parse", "--show-prefix"]).trim(), normalizedPrefix = rawPrefix ? path6.normalize(rawPrefix.replace(/[\\/]+$/, "")) : "";
   return normalizedPrefix === "." ? "" : normalizedPrefix;
 }
 function resolveExpectedWorktreeAgentCwd(cwd, runId, index, baseDir) {
   let cwdRelative = resolveRepoCwdRelative(cwd), repoRoot = runGitChecked(cwd, ["rev-parse", "--show-toplevel"]).trim(), worktreePath = buildWorktreePath(resolveWorktreeBaseDir(baseDir, repoRoot), runId, index);
-  return cwdRelative ? path5.join(worktreePath, cwdRelative) : worktreePath;
+  return cwdRelative ? path6.join(worktreePath, cwdRelative) : worktreePath;
 }
 function linkNodeModulesIfPresent(toplevel, worktreePath) {
-  let nodeModulesPath = path5.join(toplevel, "node_modules"), nodeModulesLinkPath = path5.join(worktreePath, "node_modules");
-  if (!fs6.existsSync(nodeModulesPath) || fs6.existsSync(nodeModulesLinkPath))
+  let nodeModulesPath = path6.join(toplevel, "node_modules"), nodeModulesLinkPath = path6.join(worktreePath, "node_modules");
+  if (!fs7.existsSync(nodeModulesPath) || fs7.existsSync(nodeModulesLinkPath))
     return !1;
   try {
-    return fs6.symlinkSync(nodeModulesPath, nodeModulesLinkPath), !0;
+    return fs7.symlinkSync(nodeModulesPath, nodeModulesLinkPath), !0;
   } catch {
     return !1;
   }
@@ -2503,16 +2596,16 @@ function resolveWorktreeSetupHook(repoRoot, config) {
   let hookPath = config.hookPath.trim();
   if (!hookPath)
     throw new Error("worktree setup hook path cannot be empty");
-  let expandedHookPath = hookPath.startsWith("~/") ? path5.join(os.homedir(), hookPath.slice(2)) : hookPath, resolvedPath;
-  if (path5.isAbsolute(expandedHookPath))
+  let expandedHookPath = hookPath.startsWith("~/") ? path6.join(os.homedir(), hookPath.slice(2)) : hookPath, resolvedPath;
+  if (path6.isAbsolute(expandedHookPath))
     resolvedPath = expandedHookPath;
   else if (expandedHookPath.includes("/") || expandedHookPath.includes("\\"))
-    resolvedPath = path5.resolve(repoRoot, expandedHookPath);
+    resolvedPath = path6.resolve(repoRoot, expandedHookPath);
   else
     throw new Error("worktree setup hook must be an absolute path or a repo-relative path");
-  if (!fs6.existsSync(resolvedPath))
+  if (!fs7.existsSync(resolvedPath))
     throw new Error(`worktree setup hook not found: ${resolvedPath}`);
-  if (fs6.statSync(resolvedPath).isDirectory())
+  if (fs7.statSync(resolvedPath).isDirectory())
     throw new Error(`worktree setup hook must be a file, got directory: ${resolvedPath}`);
   return {
     hookPath: resolvedPath,
@@ -2523,14 +2616,14 @@ function normalizeSyntheticPath(worktreePath, rawPath) {
   let trimmed = rawPath.trim();
   if (!trimmed)
     throw new Error("synthetic path cannot be empty");
-  if (path5.isAbsolute(trimmed))
+  if (path6.isAbsolute(trimmed))
     throw new Error(`synthetic path must be relative: ${rawPath}`);
-  let resolved = path5.resolve(worktreePath, trimmed), relative2 = path5.relative(worktreePath, resolved);
+  let resolved = path6.resolve(worktreePath, trimmed), relative2 = path6.relative(worktreePath, resolved);
   if (!relative2 || relative2 === ".")
     throw new Error(`synthetic path cannot target the worktree root: ${rawPath}`);
-  if (relative2 === ".." || relative2.startsWith(`..${path5.sep}`) || path5.isAbsolute(relative2))
+  if (relative2 === ".." || relative2.startsWith(`..${path6.sep}`) || path6.isAbsolute(relative2))
     throw new Error(`synthetic path escapes the worktree root: ${rawPath}`);
-  return path5.normalize(relative2);
+  return path6.normalize(relative2);
 }
 function hasTrackedEntries(worktreePath, relativePath) {
   let result2 = runGit(worktreePath, ["ls-files", "--", relativePath]);
@@ -2587,7 +2680,7 @@ function createSingleWorktree(toplevel, cwdRelative, runId, index, baseCommit, s
     let message = add.stderr.trim() || add.stdout.trim() || `failed to create worktree ${worktreePath}`;
     throw new Error(message);
   }
-  let agentCwd = cwdRelative ? path5.join(worktreePath, cwdRelative) : worktreePath;
+  let agentCwd = cwdRelative ? path6.join(worktreePath, cwdRelative) : worktreePath;
   try {
     let nodeModulesLinked = linkNodeModulesIfPresent(toplevel, worktreePath), syntheticPaths = nodeModulesLinked ? ["node_modules"] : [];
     if (setupHook) {
@@ -2625,26 +2718,26 @@ function createSingleWorktree(toplevel, cwdRelative, runId, index, baseCommit, s
   }
 }
 function removeSyntheticPath(worktree, syntheticPath) {
-  let resolved = path5.resolve(worktree.path, syntheticPath), relative2 = path5.relative(worktree.path, resolved);
-  if (!relative2 || relative2 === "." || relative2 === ".." || relative2.startsWith(`..${path5.sep}`) || path5.isAbsolute(relative2))
+  let resolved = path6.resolve(worktree.path, syntheticPath), relative2 = path6.relative(worktree.path, resolved);
+  if (!relative2 || relative2 === "." || relative2 === ".." || relative2.startsWith(`..${path6.sep}`) || path6.isAbsolute(relative2))
     return;
   let stat;
   try {
-    stat = fs6.lstatSync(resolved);
+    stat = fs7.lstatSync(resolved);
   } catch (error) {
     if ((error && typeof error == "object" && "code" in error ? error.code : void 0) === "ENOENT")
       return;
     throw error;
   }
   if (stat.isSymbolicLink()) {
-    fs6.unlinkSync(resolved);
+    fs7.unlinkSync(resolved);
     return;
   }
   if (stat.isDirectory()) {
-    fs6.rmSync(resolved, { recursive: !0, force: !0 });
+    fs7.rmSync(resolved, { recursive: !0, force: !0 });
     return;
   }
-  fs6.rmSync(resolved, { force: !0 });
+  fs7.rmSync(resolved, { force: !0 });
 }
 function removeSyntheticPathsBeforeDiff(worktree) {
   if (worktree.syntheticPaths.length === 0)
@@ -2677,7 +2770,7 @@ function parseNumstat(numstat) {
 function captureWorktreeDiff(setup, worktree, agent, patchPath) {
   removeSyntheticPathsBeforeDiff(worktree), runGitChecked(worktree.path, ["add", "-A"]);
   let diffStat = runGitChecked(worktree.path, ["diff", "--cached", "--stat", setup.baseCommit]).trim(), patch = runGitChecked(worktree.path, ["diff", "--cached", setup.baseCommit]), numstat = runGitChecked(worktree.path, ["diff", "--cached", "--numstat", setup.baseCommit]);
-  if (fs6.writeFileSync(patchPath, patch, "utf-8"), !patch.trim())
+  if (fs7.writeFileSync(patchPath, patch, "utf-8"), !patch.trim())
     return emptyDiff(worktree.index, agent, worktree.branch, patchPath);
   let parsed = parseNumstat(numstat);
   return {
@@ -2693,7 +2786,7 @@ function captureWorktreeDiff(setup, worktree, agent, patchPath) {
 }
 function writeEmptyPatch(patchPath) {
   try {
-    fs6.writeFileSync(patchPath, "", "utf-8");
+    fs7.writeFileSync(patchPath, "", "utf-8");
   } catch {
   }
 }
@@ -2730,13 +2823,13 @@ function createWorktrees(cwd, runId, count, options) {
 }
 function diffWorktrees(setup, agents, diffsDir) {
   try {
-    fs6.mkdirSync(diffsDir, { recursive: !0 });
+    fs7.mkdirSync(diffsDir, { recursive: !0 });
   } catch {
     return [];
   }
   let diffs = [];
   for (let index = 0; index < setup.worktrees.length; index++) {
-    let worktree = setup.worktrees[index], agent = agents[index] ?? `task-${index + 1}`, patchPath = path5.join(diffsDir, `task-${index}-${safePatchAgentName(agent)}.patch`);
+    let worktree = setup.worktrees[index], agent = agents[index] ?? `task-${index + 1}`, patchPath = path6.join(diffsDir, `task-${index}-${safePatchAgentName(agent)}.patch`);
     try {
       diffs.push(captureWorktreeDiff(setup, worktree, agent, patchPath));
     } catch {
@@ -2760,7 +2853,7 @@ function formatWorktreeDiffSummary(diffs) {
   let lines = ["=== Worktree Changes ===", ""];
   for (let diff of changed)
     lines.push(`--- Task ${diff.index + 1} (${diff.agent}): ${diff.filesChanged} files changed, +${diff.insertions} -${diff.deletions} ---`), diff.diffStat.trim().length > 0 && lines.push(diff.diffStat), lines.push("");
-  let patchesDir = path5.dirname(changed[0].patchPath);
+  let patchesDir = path6.dirname(changed[0].patchPath);
   return lines.push(`Full patches: ${patchesDir}`), lines.join(`
 `).trimEnd();
 }
@@ -3325,11 +3418,11 @@ async function runParallelChainTasks(input) {
     let effectiveModel = effectiveModels[taskIndex], maxSubagentDepth = resolveChildMaxSubagentDepth(input.maxSubagentDepth, taskChildConfig?.maxSubagentDepth), toolBudget = resolveChainToolBudget({ stepBudget: task.toolBudget, runBudget: input.toolBudget, agentBudget: taskChildConfig?.toolBudget, configBudget: input.configToolBudget });
     if (toolBudget.error)
       throw new Error(toolBudget.error);
-    let taskCwd = input.worktreeSetup ? input.worktreeSetup.worktrees[taskIndex].agentCwd : resolveChildCwd(input.cwd ?? input.ctx.cwd, task.cwd), outputPath = typeof behavior.output == "string" ? path6.isAbsolute(behavior.output) ? behavior.output : path6.join(input.chainDir, behavior.output) : void 0;
+    let taskCwd = input.worktreeSetup ? input.worktreeSetup.worktrees[taskIndex].agentCwd : resolveChildCwd(input.cwd ?? input.ctx.cwd, task.cwd), outputPath = typeof behavior.output == "string" ? path7.isAbsolute(behavior.output) ? behavior.output : path7.join(input.chainDir, behavior.output) : void 0;
     taskStr = withChainHandoff(injectSingleOutputInstruction(taskStr, outputPath, taskChildConfig), input.stepIndex < input.totalSteps - 1);
     let interruptController = new AbortController();
     input.foregroundControl && (input.foregroundControl.currentAgent = task.description || task.agent, input.foregroundControl.currentChildId = task.agent, input.foregroundControl.currentIndex = input.globalTaskIndex + taskIndex, input.foregroundControl.currentActivityState = void 0, input.foregroundControl.updatedAt = Date.now(), input.foregroundControl.interrupt = () => interruptController.signal.aborted ? !1 : (interruptController.abort(), input.foregroundControl.currentActivityState = void 0, input.foregroundControl.updatedAt = Date.now(), !0));
-    let structuredRuntime = task.outputSchema ? createStructuredOutputRuntime(task.outputSchema, path6.join(input.chainDir, "structured-output")) : void 0, result2 = await runSync(input.ctx.cwd, normalizeChildSpec({
+    let structuredRuntime = task.outputSchema ? createStructuredOutputRuntime(task.outputSchema, path7.join(input.chainDir, "structured-output")) : void 0, result2 = await runSync(input.ctx.cwd, normalizeChildSpec({
       task: taskStr,
       description: task.description,
       permissions: task.permissions,
@@ -3412,7 +3505,17 @@ async function runParallelChainTasks(input) {
       } : void 0
     });
     return input.foregroundControl?.currentIndex === input.globalTaskIndex + taskIndex && (input.foregroundControl.interrupt = void 0, input.foregroundControl.updatedAt = Date.now()), result2.exitCode !== 0 && failFast && (aborted = !0), recordRun(task.agent, cleanTask, result2.exitCode, result2.progressSummary?.durationMs ?? 0), result2;
-  }, input.globalSemaphore);
+  }, input.globalSemaphore, {
+    signal: input.signal,
+    onAbort: (task) => ({
+      agent: task.agent,
+      task: "(cancelled)",
+      exitCode: 1,
+      messages: [],
+      usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
+      error: "Subagent launch cancelled."
+    })
+  });
 }
 async function executeChain(params) {
   let { chain: chainSteps, agents, ctx, signal, runId, cwd, shareEnabled, sessionDirForIndex, sessionFileForIndex, sessionFileForTask, thinkingOverrideForTask, artifactsDir, artifactConfig, includeProgress, clarify, onUpdate, onControlEvent, controlConfig, onDetachedExit, childIntercomTarget, orchestratorIntercomTarget, communicationEnabled, foregroundControl, intercomEvents, chainSkills: chainSkillsParam, chainDir: chainDirBase, modelScope } = params, chainSkills = chainSkillsParam ?? [], results = [], outputs = {}, dynamicChildren = {}, dynamicGroupStatuses = {}, allProgress = [], allArtifactPaths = [], chainAgents = chainSteps.map((step) => isParallelStep(step) ? `[${step.parallel.map((t) => t.description || t.label || t.agent || "child").join("+")}]` : isDynamicParallelStep(step) ? `expand:${step.parallel.description || step.parallel.label || step.parallel.agent || "child"}` : step.description || step.label || step.agent || "child"), totalSteps = chainSteps.length, makeDetailsInput = (overrides = {}) => ({
@@ -3517,7 +3620,7 @@ async function executeChain(params) {
       try {
         let agentNames = step.parallel.map((task) => task.agent), parallelBehaviors = resolveParallelBehaviors(step.parallel, stepIndex, chainSkills).map((behavior, taskIndex) => suppressProgressForReadOnlyTask(behavior, parallelTemplates[taskIndex] ?? step.parallel[taskIndex]?.task, originalTask));
         for (let taskIndex = 0; taskIndex < step.parallel.length; taskIndex++) {
-          let behavior = parallelBehaviors[taskIndex], outputPath = typeof behavior.output == "string" ? path6.isAbsolute(behavior.output) ? behavior.output : path6.join(chainDir, behavior.output) : void 0, validationError = validateFileOnlyOutputMode(behavior.outputMode, outputPath, `Parallel chain step ${stepIndex + 1} task ${taskIndex + 1} (${step.parallel[taskIndex].agent})`);
+          let behavior = parallelBehaviors[taskIndex], outputPath = typeof behavior.output == "string" ? path7.isAbsolute(behavior.output) ? behavior.output : path7.join(chainDir, behavior.output) : void 0, validationError = validateFileOnlyOutputMode(behavior.outputMode, outputPath, `Parallel chain step ${stepIndex + 1} task ${taskIndex + 1} (${step.parallel[taskIndex].agent})`);
           if (validationError)
             return buildChainExecutionErrorResult(validationError, makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: globalTaskIndex + taskIndex }));
         }
@@ -3615,7 +3718,7 @@ ${failureSummary}`;
           outputName && (outputs[outputName] = outputEntryFromResult(parallelResults[taskIndex], stepIndex));
         }
         let taskResults = parallelResults.map((result2, i) => {
-          let outputTarget = parallelBehaviors[i]?.output, outputTargetPath = typeof outputTarget == "string" ? path6.isAbsolute(outputTarget) ? outputTarget : path6.join(chainDir, outputTarget) : void 0;
+          let outputTarget = parallelBehaviors[i]?.output, outputTargetPath = typeof outputTarget == "string" ? path7.isAbsolute(outputTarget) ? outputTarget : path7.join(chainDir, outputTarget) : void 0;
           return {
             agent: result2.agent,
             taskIndex: i,
@@ -3624,10 +3727,10 @@ ${failureSummary}`;
             error: result2.error,
             timedOut: result2.timedOut,
             outputTargetPath,
-            outputTargetExists: outputTargetPath ? fs7.existsSync(outputTargetPath) : void 0
+            outputTargetExists: outputTargetPath ? fs8.existsSync(outputTargetPath) : void 0
           };
         });
-        prev = aggregateParallelOutputs(taskResults), prev = appendParallelWorktreeSummary(prev, worktreeSetup, path6.join(chainDir, "worktree-diffs", `step-${stepIndex}`), agentNames);
+        prev = aggregateParallelOutputs(taskResults), prev = appendParallelWorktreeSummary(prev, worktreeSetup, path7.join(chainDir, "worktree-diffs", `step-${stepIndex}`), agentNames);
       } finally {
         worktreeSetup && cleanupWorktrees(worktreeSetup);
       }
@@ -3689,7 +3792,7 @@ ${failureSummary}`;
         failFast: step.failFast
       }, parallelTemplates = materialized.parallel.map((task) => task.task ?? "{previous}"), parallelBehaviors = resolveParallelBehaviors(dynamicParallelStep.parallel, stepIndex, chainSkills).map((behavior, taskIndex) => suppressProgressForReadOnlyTask(behavior, parallelTemplates[taskIndex] ?? dynamicParallelStep.parallel[taskIndex]?.task, originalTask));
       for (let taskIndex = 0; taskIndex < dynamicParallelStep.parallel.length; taskIndex++) {
-        let behavior = parallelBehaviors[taskIndex], outputPath = typeof behavior.output == "string" ? path6.isAbsolute(behavior.output) ? behavior.output : path6.join(chainDir, behavior.output) : void 0, validationError = validateFileOnlyOutputMode(behavior.outputMode, outputPath, `Dynamic chain step ${stepIndex + 1} item ${taskIndex + 1} (${dynamicParallelStep.parallel[taskIndex].agent})`);
+        let behavior = parallelBehaviors[taskIndex], outputPath = typeof behavior.output == "string" ? path7.isAbsolute(behavior.output) ? behavior.output : path7.join(chainDir, behavior.output) : void 0, validationError = validateFileOnlyOutputMode(behavior.outputMode, outputPath, `Dynamic chain step ${stepIndex + 1} item ${taskIndex + 1} (${dynamicParallelStep.parallel[taskIndex].agent})`);
         if (validationError)
           return dynamicGroupStatuses[stepIndex] = { status: "failed", error: validationError }, buildChainExecutionErrorResult(validationError, makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: globalTaskIndex + taskIndex }));
       }
@@ -3850,14 +3953,14 @@ ${failureSummary}`;
         thinking: seqStep.thinking,
         availableModels,
         preferredProvider: ctx.model?.provider
-      }), outputPath = typeof behavior.output == "string" ? path6.isAbsolute(behavior.output) ? behavior.output : path6.join(chainDir, behavior.output) : void 0;
+      }), outputPath = typeof behavior.output == "string" ? path7.isAbsolute(behavior.output) ? behavior.output : path7.join(chainDir, behavior.output) : void 0;
       stepTask = withChainHandoff(injectSingleOutputInstruction(stepTask, outputPath, agentConfig), stepIndex < totalSteps - 1);
       let validationError = validateFileOnlyOutputMode(behavior.outputMode, outputPath, `Chain step ${stepIndex + 1} (${seqStep.agent})`);
       if (validationError)
         return buildChainExecutionErrorResult(validationError, makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: globalTaskIndex }));
       let maxSubagentDepth = resolveChildMaxSubagentDepth(params.maxSubagentDepth, agentConfig.maxSubagentDepth), childIndex = globalTaskIndex, interruptController = new AbortController();
       foregroundControl && (foregroundControl.currentAgent = seqStep.description || seqStep.agent, foregroundControl.currentChildId = seqStep.agent, foregroundControl.currentIndex = childIndex, foregroundControl.currentActivityState = void 0, foregroundControl.updatedAt = Date.now(), foregroundControl.interrupt = () => interruptController.signal.aborted ? !1 : (interruptController.abort(), foregroundControl.currentActivityState = void 0, foregroundControl.updatedAt = Date.now(), !0));
-      let structuredRuntime = seqStep.outputSchema ? createStructuredOutputRuntime(seqStep.outputSchema, path6.join(chainDir, "structured-output")) : void 0, toolBudget = resolveChainToolBudget({ stepBudget: seqStep.toolBudget, runBudget: params.toolBudget, agentBudget: agentConfig?.toolBudget, configBudget: params.configToolBudget });
+      let structuredRuntime = seqStep.outputSchema ? createStructuredOutputRuntime(seqStep.outputSchema, path7.join(chainDir, "structured-output")) : void 0, toolBudget = resolveChainToolBudget({ stepBudget: seqStep.toolBudget, runBudget: params.toolBudget, agentBudget: agentConfig?.toolBudget, configBudget: params.configToolBudget });
       if (toolBudget.error)
         return buildChainExecutionErrorResult(toolBudget.error, {
           results,
@@ -3978,9 +4081,9 @@ ${failureSummary}`;
         };
       if (behavior.output)
         try {
-          let expectedPath = path6.isAbsolute(behavior.output) ? behavior.output : path6.join(chainDir, behavior.output);
-          if (!fs7.existsSync(expectedPath)) {
-            let mdFiles = fs7.readdirSync(chainDir).filter((file) => file.endsWith(".md") && file !== "progress.md"), warning = mdFiles.length > 0 ? `Agent wrote to different file(s): ${mdFiles.join(", ")} instead of ${behavior.output}` : `Agent did not create expected output file: ${behavior.output}`;
+          let expectedPath = path7.isAbsolute(behavior.output) ? behavior.output : path7.join(chainDir, behavior.output);
+          if (!fs8.existsSync(expectedPath)) {
+            let mdFiles = fs8.readdirSync(chainDir).filter((file) => file.endsWith(".md") && file !== "progress.md"), warning = mdFiles.length > 0 ? `Agent wrote to different file(s): ${mdFiles.join(", ")} instead of ${behavior.output}` : `Agent did not create expected output file: ${behavior.output}`;
             r.error = r.error ? `${r.error}
 ${warning}` : warning;
           }
@@ -3996,37 +4099,37 @@ ${warning}` : warning;
 }
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/extension/doctor.js
-import * as fs9 from "node:fs";
-import * as path8 from "node:path";
+import * as fs10 from "node:fs";
+import * as path9 from "node:path";
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/background/async-execution.js
 import { spawn as spawn2 } from "node:child_process";
-import * as fs8 from "node:fs";
-import * as path7 from "node:path";
+import * as fs9 from "node:fs";
+import * as path8 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { createRequire } from "node:module";
 var require2 = createRequire(new URL("../builtin-extensions/pi-subagents/src/runs/background/async-execution.js", import.meta.url).href), piPackageRoot = resolvePiPackageRoot();
 function resolveJitiCliFromPackageJson(packageJsonPath) {
-  if (!fs8.existsSync(packageJsonPath))
+  if (!fs9.existsSync(packageJsonPath))
     return;
-  let packageRoot = path7.dirname(packageJsonPath), binField = JSON.parse(fs8.readFileSync(packageJsonPath, "utf-8")).bin, candidates = [typeof binField == "string" ? binField : binField?.jiti ?? Object.values(binField ?? {})[0], "lib/jiti-cli.mjs"].filter((candidate) => !!candidate);
+  let packageRoot = path8.dirname(packageJsonPath), binField = JSON.parse(fs9.readFileSync(packageJsonPath, "utf-8")).bin, candidates = [typeof binField == "string" ? binField : binField?.jiti ?? Object.values(binField ?? {})[0], "lib/jiti-cli.mjs"].filter((candidate) => !!candidate);
   for (let candidate of candidates) {
-    let cliPath = path7.resolve(packageRoot, candidate);
-    if (fs8.existsSync(cliPath))
+    let cliPath = path8.resolve(packageRoot, candidate);
+    if (fs9.existsSync(cliPath))
       return cliPath;
   }
 }
 function resolveJitiCliPath() {
   let candidates = [
     () => require2.resolve("jiti/package.json"),
-    () => piPackageRoot ? createRequire(path7.join(piPackageRoot, "package.json")).resolve("jiti/package.json") : void 0,
+    () => piPackageRoot ? createRequire(path8.join(piPackageRoot, "package.json")).resolve("jiti/package.json") : void 0,
     () => {
       if (!process.argv[1])
         return;
-      let piEntry = fs8.realpathSync(process.argv[1]);
+      let piEntry = fs9.realpathSync(process.argv[1]);
       return createRequire(piEntry).resolve("jiti/package.json");
     },
-    () => piPackageRoot ? path7.join(piPackageRoot, "node_modules", "jiti", "package.json") : void 0
+    () => piPackageRoot ? path8.join(piPackageRoot, "node_modules", "jiti", "package.json") : void 0
   ];
   for (let candidate of candidates)
     try {
@@ -4053,12 +4156,12 @@ function isAsyncAvailable() {
   return jitiCliPath !== void 0;
 }
 function isNodeExecutableName(execPath) {
-  let basename3 = path7.basename(execPath).toLowerCase();
+  let basename3 = path8.basename(execPath).toLowerCase();
   return basename3 === "node" || basename3 === "node.exe" || basename3 === "nodejs" || basename3 === "nodejs.exe";
 }
 function canUseCurrentNodeExecutable(execPath) {
   try {
-    return fs8.accessSync(execPath, process.platform === "win32" ? fs8.constants.F_OK : fs8.constants.X_OK), !0;
+    return fs9.accessSync(execPath, process.platform === "win32" ? fs9.constants.F_OK : fs9.constants.X_OK), !0;
   } catch {
     return !1;
   }
@@ -4070,14 +4173,14 @@ function resolveAsyncRunnerLogPaths(cfg) {
   let asyncDir = typeof cfg.asyncDir == "string" ? cfg.asyncDir : void 0;
   if (asyncDir)
     return {
-      stdoutPath: path7.join(asyncDir, "runner.stdout.log"),
-      stderrPath: path7.join(asyncDir, "runner.stderr.log")
+      stdoutPath: path8.join(asyncDir, "runner.stdout.log"),
+      stderrPath: path8.join(asyncDir, "runner.stderr.log")
     };
 }
 function closeFd(fd) {
   if (fd !== void 0)
     try {
-      fs8.closeSync(fd);
+      fs9.closeSync(fd);
     } catch {
     }
 }
@@ -4092,9 +4195,9 @@ function waitForStartupInterval(delayMs = 20) {
     ;
 }
 function readRunnerStartup(startupPath, expectedState, expectedToken) {
-  if (fs8.existsSync(startupPath))
+  if (fs9.existsSync(startupPath))
     try {
-      let payload = JSON.parse(fs8.readFileSync(startupPath, "utf-8"));
+      let payload = JSON.parse(fs9.readFileSync(startupPath, "utf-8"));
       return payload.state === "error" && typeof payload.error == "string" ? { ok: !1, error: payload.error } : payload.state !== expectedState ? void 0 : typeof payload.token != "string" || expectedToken !== void 0 && payload.token !== expectedToken ? { ok: !1, error: `Async runner wrote an invalid ${expectedState} startup handshake: ${startupPath}` } : { ok: !0, token: payload.token };
     } catch (error) {
       return { ok: !1, error: `Failed to read async runner startup handshake '${startupPath}': ${error instanceof Error ? error.message : String(error)}` };
@@ -4116,10 +4219,10 @@ function waitForRunnerStartup(startupPath, expectedState, timeoutMs, expectedTok
 function writeRunnerStartupControl(filePath, payload) {
   let tempPath = `${filePath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    fs8.writeFileSync(tempPath, JSON.stringify(payload), { encoding: "utf-8", mode: 384 }), fs8.renameSync(tempPath, filePath);
+    fs9.writeFileSync(tempPath, JSON.stringify(payload), { encoding: "utf-8", mode: 384 }), fs9.renameSync(tempPath, filePath);
   } catch (error) {
     try {
-      fs8.rmSync(tempPath, { force: !0 });
+      fs9.rmSync(tempPath, { force: !0 });
     } catch {
     }
     throw error;
@@ -4151,19 +4254,19 @@ function spawnRunner(cfg, suffix, cwd) {
   if (!jitiCliPath)
     return { error: "upstream jiti for TypeScript execution could not be found; ensure package dependencies are installed" };
   try {
-    if (!fs8.statSync(cwd).isDirectory())
+    if (!fs9.statSync(cwd).isDirectory())
       return { error: `cwd is not a directory: ${cwd}` };
   } catch {
     return { error: `cwd does not exist: ${cwd}` };
   }
-  fs8.mkdirSync(TEMP_ROOT_DIR, { recursive: !0 });
+  fs9.mkdirSync(TEMP_ROOT_DIR, { recursive: !0 });
   let cfgPath = getAsyncConfigPath(suffix);
-  fs8.writeFileSync(cfgPath, JSON.stringify(cfg));
-  let runnerTsPath = path7.join(path7.dirname(fileURLToPath2(new URL("../builtin-extensions/pi-subagents/src/runs/background/async-execution.js", import.meta.url).href)), "subagent-runner.ts"), runner = fs8.existsSync(runnerTsPath) ? runnerTsPath : runnerTsPath.replace(/\.ts$/, ".js"), nodeCommand = resolveAsyncRunnerNodeCommand(), startupPath = typeof cfg.revivalLease == "object" && typeof cfg.asyncDir == "string" ? path7.join(cfg.asyncDir, "runner-startup.json") : void 0, startupAckPath = startupPath ? path7.join(path7.dirname(startupPath), "runner-startup-ack.json") : void 0, startupProceedPath = startupPath ? path7.join(path7.dirname(startupPath), "runner-startup-proceed.json") : void 0;
-  startupPath && fs8.rmSync(startupPath, { force: !0 }), startupAckPath && fs8.rmSync(startupAckPath, { force: !0 }), startupProceedPath && fs8.rmSync(startupProceedPath, { force: !0 });
+  fs9.writeFileSync(cfgPath, JSON.stringify(cfg));
+  let runnerTsPath = path8.join(path8.dirname(fileURLToPath2(new URL("../builtin-extensions/pi-subagents/src/runs/background/async-execution.js", import.meta.url).href)), "subagent-runner.ts"), runner = fs9.existsSync(runnerTsPath) ? runnerTsPath : runnerTsPath.replace(/\.ts$/, ".js"), nodeCommand = resolveAsyncRunnerNodeCommand(), startupPath = typeof cfg.revivalLease == "object" && typeof cfg.asyncDir == "string" ? path8.join(cfg.asyncDir, "runner-startup.json") : void 0, startupAckPath = startupPath ? path8.join(path8.dirname(startupPath), "runner-startup-ack.json") : void 0, startupProceedPath = startupPath ? path8.join(path8.dirname(startupPath), "runner-startup-proceed.json") : void 0;
+  startupPath && fs9.rmSync(startupPath, { force: !0 }), startupAckPath && fs9.rmSync(startupAckPath, { force: !0 }), startupProceedPath && fs9.rmSync(startupProceedPath, { force: !0 });
   let logPaths = resolveAsyncRunnerLogPaths(cfg), stdoutFd, stderrFd;
   try {
-    logPaths && (fs8.mkdirSync(path7.dirname(logPaths.stdoutPath), { recursive: !0 }), stdoutFd = fs8.openSync(logPaths.stdoutPath, "a"), stderrFd = fs8.openSync(logPaths.stderrPath, "a"));
+    logPaths && (fs9.mkdirSync(path8.dirname(logPaths.stdoutPath), { recursive: !0 }), stdoutFd = fs9.openSync(logPaths.stdoutPath, "a"), stderrFd = fs9.openSync(logPaths.stderrPath, "a"));
     let proc = spawn2(nodeCommand, [jitiCliPath, runner, cfgPath], {
       cwd,
       detached: !0,
@@ -4197,7 +4300,7 @@ function spawnRunner(cfg, suffix, cwd) {
         return terminateRunnerBeforeProceed(proc.pid), { error: `Failed to authorize async runner startup: ${error instanceof Error ? error.message : String(error)}` };
       }
       try {
-        fs8.rmSync(startupPath, { force: !0 });
+        fs9.rmSync(startupPath, { force: !0 });
       } catch {
       }
     }
@@ -4254,10 +4357,10 @@ function buildAsyncRunnerSteps(id, params) {
     }), toolBudgetInput = spec.toolBudget ?? params.toolBudget ?? params.configToolBudget, resolvedToolBudget = validateToolBudgetConfig(toolBudgetInput, spec.toolBudget ? "toolBudget" : "config.toolBudget");
     if (resolvedToolBudget.error)
       throw new AsyncStartValidationError(resolvedToolBudget.error);
-    let stepCwd = resolveChildCwd(runnerCwd, s.cwd), instructionCwd = behaviorCwd ?? stepCwd, behavior = suppressProgressForReadOnlyTask(resolvedBehavior ?? resolveStepBehavior(buildStepOverrides(s), chainSkills), s.task, originalTask), inheritedRelativeParallelOutput = parallelOutputNamespace && s.output === void 0 && typeof behavior.output == "string" && !path7.isAbsolute(behavior.output);
+    let stepCwd = resolveChildCwd(runnerCwd, s.cwd), instructionCwd = behaviorCwd ?? stepCwd, behavior = suppressProgressForReadOnlyTask(resolvedBehavior ?? resolveStepBehavior(buildStepOverrides(s), chainSkills), s.task, originalTask), inheritedRelativeParallelOutput = parallelOutputNamespace && s.output === void 0 && typeof behavior.output == "string" && !path8.isAbsolute(behavior.output);
     inheritedRelativeParallelOutput && parallelOutputNamespace.taskIndex !== void 0 && (behavior = {
       ...behavior,
-      output: path7.join(`parallel-${parallelOutputNamespace.stepIndex}`, String(parallelOutputNamespace.taskIndex), behavior.output)
+      output: path8.join(`parallel-${parallelOutputNamespace.stepIndex}`, String(parallelOutputNamespace.taskIndex), behavior.output)
     });
     let namespaceOutputPath = !!(inheritedRelativeParallelOutput && parallelOutputNamespace.taskIndex === void 0), skillNames = behavior.skills === !1 ? [] : behavior.skills, { resolved: resolvedSkills, missing: missingSkills } = resolveSkillsWithFallback(skillNames, stepCwd, ctx.cwd, void 0, stepCwd);
     if (missingSkills.includes("pi-subagents"))
@@ -4331,7 +4434,7 @@ ${injection}` : injection;
       acceptanceInput: s.acceptance,
       acceptanceRole: spec.effectivePermissions === "read-only" ? "read-only" : "writer",
       ...s.outputSchema ? { structuredOutputSchema: s.outputSchema } : {},
-      ...s.outputSchema ? { structuredOutput: createStructuredOutputRuntime(s.outputSchema, path7.join(asyncDir, "structured-output")) } : {},
+      ...s.outputSchema ? { structuredOutput: createStructuredOutputRuntime(s.outputSchema, path8.join(asyncDir, "structured-output")) } : {},
       ...resolvedToolBudget.budget ? { toolBudget: resolvedToolBudget.budget } : {}
     };
   }, flatStepIndex = 0, nextFlatStep = () => {
@@ -4428,9 +4531,9 @@ ${injection}` : injection;
   }
 }
 function executeAsyncChain(id, params) {
-  let { chain, ctx, cwd, maxOutput, artifactsDir, artifactConfig, shareEnabled, sessionRoot, sessionFilesByFlatIndex, thinkingOverridesByFlatIndex, maxSubagentDepth, worktreeSetupHook, worktreeSetupHookTimeoutMs, worktreeBaseDir, controlConfig, controlIntercomTarget, childIntercomTarget, nestedRoute } = params, resultMode = params.resultMode ?? "chain", inheritedNestedRoute = resolveInheritedNestedRouteFromEnv(), nestedAddress = inheritedNestedRoute ? resolveNestedParentAddressFromEnv() : void 0, asyncDir = inheritedNestedRoute ? path7.join(TEMP_ROOT_DIR, "nested-subagent-runs", inheritedNestedRoute.rootRunId, id) : path7.join(ASYNC_DIR, id);
+  let { chain, ctx, cwd, maxOutput, artifactsDir, artifactConfig, shareEnabled, sessionRoot, sessionFilesByFlatIndex, thinkingOverridesByFlatIndex, maxSubagentDepth, worktreeSetupHook, worktreeSetupHookTimeoutMs, worktreeBaseDir, controlConfig, controlIntercomTarget, childIntercomTarget, nestedRoute } = params, resultMode = params.resultMode ?? "chain", inheritedNestedRoute = resolveInheritedNestedRouteFromEnv(), nestedAddress = inheritedNestedRoute ? resolveNestedParentAddressFromEnv() : void 0, asyncDir = inheritedNestedRoute ? path8.join(TEMP_ROOT_DIR, "nested-subagent-runs", inheritedNestedRoute.rootRunId, id) : path8.join(ASYNC_DIR, id);
   try {
-    fs8.mkdirSync(asyncDir, { recursive: !0 });
+    fs9.mkdirSync(asyncDir, { recursive: !0 });
   } catch (error) {
     let message = error instanceof Error ? error.message : String(error);
     return {
@@ -4450,8 +4553,8 @@ function executeAsyncChain(id, params) {
     chainSkills: params.chainSkills,
     sessionFilesByFlatIndex,
     thinkingOverridesByFlatIndex,
-    progressDir: params.progressDir ?? (artifactsDir ? path7.join(artifactsDir, "progress", id) : resultMode === "parallel" ? path7.join(asyncDir, "progress") : void 0),
-    outputBaseDir: artifactsDir ? path7.join(artifactsDir, "outputs", id) : void 0,
+    progressDir: params.progressDir ?? (artifactsDir ? path8.join(artifactsDir, "progress", id) : resultMode === "parallel" ? path8.join(asyncDir, "progress") : void 0),
+    outputBaseDir: artifactsDir ? path8.join(artifactsDir, "outputs", id) : void 0,
     dynamicFanoutMaxItems: params.dynamicFanoutMaxItems,
     maxSubagentDepth,
     waitToolEnabled: params.waitToolEnabled,
@@ -4462,7 +4565,7 @@ function executeAsyncChain(id, params) {
   });
   if ("error" in built) {
     try {
-      fs8.rmSync(asyncDir, { recursive: !0, force: !0 });
+      fs9.rmSync(asyncDir, { recursive: !0, force: !0 });
     } catch {
     }
     return formatAsyncStartError(resultMode, built.error);
@@ -4472,14 +4575,14 @@ function executeAsyncChain(id, params) {
     spawnResult = spawnRunner({
       id,
       steps,
-      resultPath: inheritedNestedRoute ? nestedResultsPath(inheritedNestedRoute.rootRunId, id) : path7.join(RESULTS_DIR, `${id}.json`),
+      resultPath: inheritedNestedRoute ? nestedResultsPath(inheritedNestedRoute.rootRunId, id) : path8.join(RESULTS_DIR, `${id}.json`),
       cwd: runnerCwd,
       placeholder: "{previous}",
       maxOutput,
       artifactsDir: artifactConfig.enabled ? artifactsDir : void 0,
       artifactConfig,
       share: shareEnabled,
-      sessionDir: sessionRoot ? path7.join(sessionRoot, `async-${id}`) : void 0,
+      sessionDir: sessionRoot ? path8.join(sessionRoot, `async-${id}`) : void 0,
       asyncDir,
       sessionId: ctx.currentSessionId,
       piPackageRoot,
@@ -4603,9 +4706,9 @@ function executeAsyncSingle(id, params) {
 
 ${injection}` : injection;
   }
-  let inheritedNestedRoute = resolveInheritedNestedRouteFromEnv(), nestedAddress = inheritedNestedRoute ? resolveNestedParentAddressFromEnv() : void 0, asyncDir = inheritedNestedRoute ? path7.join(TEMP_ROOT_DIR, "nested-subagent-runs", inheritedNestedRoute.rootRunId, id) : path7.join(ASYNC_DIR, id);
+  let inheritedNestedRoute = resolveInheritedNestedRouteFromEnv(), nestedAddress = inheritedNestedRoute ? resolveNestedParentAddressFromEnv() : void 0, asyncDir = inheritedNestedRoute ? path8.join(TEMP_ROOT_DIR, "nested-subagent-runs", inheritedNestedRoute.rootRunId, id) : path8.join(ASYNC_DIR, id);
   try {
-    fs8.mkdirSync(asyncDir, { recursive: !0 });
+    fs9.mkdirSync(asyncDir, { recursive: !0 });
   } catch (error) {
     let message = error instanceof Error ? error.message : String(error);
     return {
@@ -4614,7 +4717,7 @@ ${injection}` : injection;
       details: { mode: "single", results: [] }
     };
   }
-  let effectiveOutput = normalizeSingleOutputOverride(params.output ?? spec.output, typeof spec.output == "string" ? spec.output : void 0), outputPath = resolveSingleOutputPath(effectiveOutput, ctx.cwd, runnerCwd, params.outputBaseDir ?? (artifactsDir ? path7.join(artifactsDir, "outputs", id) : void 0)), childToolShape = { tools: spec.effectivePermissions === "read-only" ? ["read", "grep", "find", "ls", "bash"] : void 0 };
+  let effectiveOutput = normalizeSingleOutputOverride(params.output ?? spec.output, typeof spec.output == "string" ? spec.output : void 0), outputPath = resolveSingleOutputPath(effectiveOutput, ctx.cwd, runnerCwd, params.outputBaseDir ?? (artifactsDir ? path8.join(artifactsDir, "outputs", id) : void 0)), childToolShape = { tools: spec.effectivePermissions === "read-only" ? ["read", "grep", "find", "ls", "bash"] : void 0 };
   systemPrompt = injectOutputPathSystemPrompt(systemPrompt, outputPath, childToolShape);
   let outputMode = params.outputMode ?? spec.outputMode ?? "inline", validationError = validateFileOnlyOutputMode(outputMode, outputPath, `Async single run (${agent})`);
   if (validationError)
@@ -4632,7 +4735,7 @@ ${injection}` : injection;
   let deadlineAt = params.absoluteDeadlineAt ?? (params.timeoutMs !== void 0 ? Date.now() + params.timeoutMs : void 0), timeoutMs = params.absoluteDeadlineAt !== void 0 && deadlineAt !== void 0 ? deadlineAt - Date.now() : params.timeoutMs;
   if (timeoutMs !== void 0 && timeoutMs <= 0)
     return formatAsyncStartError("single", "The source run's absolute deadline expired before recovery could launch.");
-  let initialTurnBudget = params.turnBudget ? initialTurnBudgetState(params.turnBudget) : void 0, resolvedSessionDir = params.sessionDir ?? (sessionRoot ? path7.join(sessionRoot, `async-${id}`) : void 0), resolvedAcceptance = resolveAsyncSingleAcceptance({
+  let initialTurnBudget = params.turnBudget ? initialTurnBudgetState(params.turnBudget) : void 0, resolvedSessionDir = params.sessionDir ?? (sessionRoot ? path8.join(sessionRoot, `async-${id}`) : void 0), resolvedAcceptance = resolveAsyncSingleAcceptance({
     restoredAcceptance: params.restoredAcceptance,
     launchAcceptance: params.acceptance ?? spec.acceptance,
     agentName: agent,
@@ -4668,7 +4771,7 @@ ${injection}` : injection;
     artifactConfig
   };
   try {
-    writePrivateAtomicJson(path7.join(asyncDir, "recovery-descriptor.json"), recoveryDescriptor);
+    writePrivateAtomicJson(path8.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)}`);
   }
@@ -4705,7 +4808,7 @@ ${injection}` : injection;
           ...resolvedToolBudget.budget ? { toolBudget: resolvedToolBudget.budget } : {}
         }
       ],
-      resultPath: inheritedNestedRoute ? nestedResultsPath(inheritedNestedRoute.rootRunId, id) : path7.join(RESULTS_DIR, `${id}.json`),
+      resultPath: inheritedNestedRoute ? nestedResultsPath(inheritedNestedRoute.rootRunId, id) : path8.join(RESULTS_DIR, `${id}.json`),
       cwd: runnerCwd,
       placeholder: "{previous}",
       maxOutput,
@@ -4825,11 +4928,11 @@ function lineFromCheck(label, check) {
 }
 function formatExistingDirectory(label, dirPath) {
   try {
-    if (!fs9.existsSync(dirPath))
+    if (!fs10.existsSync(dirPath))
       return `- ${label}: missing (${dirPath})`;
-    if (!fs9.statSync(dirPath).isDirectory())
+    if (!fs10.statSync(dirPath).isDirectory())
       throw new Error(`not a directory: ${dirPath}`);
-    return fs9.accessSync(dirPath, fs9.constants.R_OK | fs9.constants.W_OK), `- ${label}: ok (${dirPath})`;
+    return fs10.accessSync(dirPath, fs10.constants.R_OK | fs10.constants.W_OK), `- ${label}: ok (${dirPath})`;
   } catch (error) {
     return `- ${label}: failed (${dirPath}) \u2014 ${errorText(error)}`;
   }
@@ -4852,13 +4955,13 @@ function formatSkillSourceCounts(skills) {
   return parts.length > 0 ? parts.join(", ") : "none";
 }
 function formatConfiguredSessionDir(input) {
-  return input.requestedSessionDir ? path8.resolve(input.expandTilde?.(input.requestedSessionDir) ?? input.requestedSessionDir) : input.config.defaultSessionDir ? path8.resolve(input.expandTilde?.(input.config.defaultSessionDir) ?? input.config.defaultSessionDir) : "not configured";
+  return input.requestedSessionDir ? path9.resolve(input.expandTilde?.(input.requestedSessionDir) ?? input.requestedSessionDir) : input.config.defaultSessionDir ? path9.resolve(input.expandTilde?.(input.config.defaultSessionDir) ?? input.config.defaultSessionDir) : "not configured";
 }
 function formatSessionLines(input) {
   let sessionFile = input.currentSessionFile ?? null, lines = [
     lineFromCheck("configured session dir", () => `- configured session dir: ${formatConfiguredSessionDir(input)}`),
     `- current session file: ${sessionFile ?? "not available"}`,
-    `- current session dir: ${sessionFile ? path8.dirname(sessionFile) : "not available"}`,
+    `- current session dir: ${sessionFile ? path9.dirname(sessionFile) : "not available"}`,
     `- current session id: ${input.currentSessionId ?? input.state.currentSessionId ?? "not available"}`
   ];
   return input.sessionError && lines.push(`- session manager: failed \u2014 ${input.sessionError}`), lines;
@@ -4975,19 +5078,19 @@ var WATCHDOG_TOOL_ACTIONS = ["watchdog.status", "watchdog.check", "watchdog.reco
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/background/chain-append.js
 import { randomUUID } from "node:crypto";
-import * as fs10 from "node:fs";
-import * as path9 from "node:path";
+import * as fs11 from "node:fs";
+import * as path10 from "node:path";
 var APPEND_REQUESTS_DIR = "append-requests";
 function appendDir(asyncDir) {
-  return path9.join(asyncDir, APPEND_REQUESTS_DIR);
+  return path10.join(asyncDir, APPEND_REQUESTS_DIR);
 }
 function appendRequestPath(asyncDir, request) {
-  return path9.join(appendDir(asyncDir), `${request.createdAt}-${request.id}.json`);
+  return path10.join(appendDir(asyncDir), `${request.createdAt}-${request.id}.json`);
 }
 function listAppendRequestFiles(asyncDir) {
   let dir = appendDir(asyncDir);
   try {
-    return fs10.readdirSync(dir).filter((entry) => entry.endsWith(".json")).map((entry) => path9.join(dir, entry)).sort();
+    return fs11.readdirSync(dir).filter((entry) => entry.endsWith(".json")).map((entry) => path10.join(dir, entry)).sort();
   } catch (error) {
     if (error.code === "ENOENT")
       return [];
@@ -5022,9 +5125,9 @@ function enqueueChainAppendRequest(input) {
     createdAt: input.now ?? Date.now(),
     steps: input.steps
   };
-  fs10.mkdirSync(appendDir(input.asyncDir), { recursive: !0 }), writeAtomicJson(appendRequestPath(input.asyncDir, request), request);
-  let pendingCount = countPendingChainAppendRequests(input.asyncDir), statusPath = path9.join(input.asyncDir, "status.json"), updatedStatus = { ...status, pendingAppends: pendingCount, lastUpdate: request.createdAt };
-  return writeAtomicJson(statusPath, updatedStatus), appendJsonl(path9.join(input.asyncDir, "events.jsonl"), JSON.stringify({
+  fs11.mkdirSync(appendDir(input.asyncDir), { recursive: !0 }), writeAtomicJson(appendRequestPath(input.asyncDir, request), request);
+  let pendingCount = countPendingChainAppendRequests(input.asyncDir), statusPath = path10.join(input.asyncDir, "status.json"), updatedStatus = { ...status, pendingAppends: pendingCount, lastUpdate: request.createdAt };
+  return writeAtomicJson(statusPath, updatedStatus), appendJsonl(path10.join(input.asyncDir, "events.jsonl"), JSON.stringify({
     type: "subagent.chain.append.requested",
     ts: request.createdAt,
     runId: input.runId,
@@ -5034,7 +5137,7 @@ function enqueueChainAppendRequest(input) {
   })), { request, pendingCount };
 }
 function readAppendRequest(filePath) {
-  let raw = JSON.parse(fs10.readFileSync(filePath, "utf-8"));
+  let raw = JSON.parse(fs11.readFileSync(filePath, "utf-8"));
   if (!(!raw.id || typeof raw.id != "string") && Number.isFinite(raw.createdAt) && !(!Array.isArray(raw.steps) || raw.steps.length === 0))
     return { id: raw.id, createdAt: raw.createdAt, steps: raw.steps };
 }
@@ -5044,8 +5147,8 @@ function readPendingChainAppendRequests(asyncDir) {
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/shared/fork-context.js
 import { randomUUID as randomUUID2 } from "node:crypto";
-import * as fs11 from "node:fs";
-import * as path10 from "node:path";
+import * as fs12 from "node:fs";
+import * as path11 from "node:path";
 function resolveSubagentContext(value) {
   return value === "fork" ? "fork" : "fresh";
 }
@@ -5099,7 +5202,7 @@ function sanitizeUnsafeThinkingBlocks(entries) {
   return sanitized;
 }
 function readSessionEntries(sessionFile) {
-  return fs11.readFileSync(sessionFile, "utf-8").split(`
+  return fs12.readFileSync(sessionFile, "utf-8").split(`
 `).filter((line) => line.trim().length > 0).map((line, index) => {
     try {
       return JSON.parse(line);
@@ -5128,22 +5231,22 @@ function createForkContextResolver(sessionManager, requestedContext, options = {
     if (cached)
       return cached;
     try {
-      if (!fs11.existsSync(parentSessionFile))
+      if (!fs12.existsSync(parentSessionFile))
         throw new Error(`Parent session file does not exist: ${parentSessionFile}. Pi has not persisted enough history to fork yet.`);
       let sourceManager = openSession(parentSessionFile, sessionDir), sessionFile = sourceManager.createBranchedSession(leafId);
       if (!sessionFile)
         throw new Error("Session manager did not return a forked session file.");
       let forceThinkingOff = (sanitized) => sanitized && (options.forceThinkingOffForIndex?.(index) ?? !0), thinkingOverride;
-      if (fs11.existsSync(sessionFile)) {
+      if (fs12.existsSync(sessionFile)) {
         let entries = readSessionEntries(sessionFile);
-        sanitizeUnsafeThinkingBlocks(entries) && (forceThinkingOff(!0) && (appendThinkingOffEntry(entries), thinkingOverride = "off"), fs11.writeFileSync(sessionFile, `${entries.map((entry) => JSON.stringify(entry)).join(`
+        sanitizeUnsafeThinkingBlocks(entries) && (forceThinkingOff(!0) && (appendThinkingOffEntry(entries), thinkingOverride = "off"), fs12.writeFileSync(sessionFile, `${entries.map((entry) => JSON.stringify(entry)).join(`
 `)}
 `, "utf-8"));
       } else {
         let header = sourceManager.getHeader?.(), entries = sourceManager.getEntries?.();
         if (!header || !entries)
           throw new Error(`Session manager returned a forked session file that does not exist and cannot be persisted by fallback: ${sessionFile}`);
-        forceThinkingOff(sanitizeUnsafeThinkingBlocks(entries)) && (appendThinkingOffEntry(entries), thinkingOverride = "off"), fs11.mkdirSync(path10.dirname(sessionFile), { recursive: !0 }), fs11.writeFileSync(sessionFile, `${[header, ...entries].map((entry) => JSON.stringify(entry)).join(`
+        forceThinkingOff(sanitizeUnsafeThinkingBlocks(entries)) && (appendThinkingOffEntry(entries), thinkingOverride = "off"), fs12.mkdirSync(path11.dirname(sessionFile), { recursive: !0 }), fs12.writeFileSync(sessionFile, `${[header, ...entries].map((entry) => JSON.stringify(entry)).join(`
 `)}
 `, "utf-8");
       }
@@ -5174,8 +5277,8 @@ function lunrContextPolicy(params) {
 }
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/background/steering.js
-import * as fs12 from "node:fs";
-import * as path11 from "node:path";
+import * as fs13 from "node:fs";
+import * as path12 from "node:path";
 function incrementStateCount(status, state) {
   state === "scheduled" ? status.scheduled++ : state === "routed" ? status.pending++ : state === "delivered" || state === "late" ? status.delivered++ : state === "failed" ? status.failed++ : state === "recovered" && status.recovered++;
 }
@@ -5207,29 +5310,29 @@ function steeringActionIsTerminal(result2) {
   return result2?.state === "delivered" || result2?.state === "scheduled" || result2?.state === "partial" || result2?.state === "recovered" || result2?.state === "failed";
 }
 function claimSteeringRecovery(asyncDir, input) {
-  let recoveryDir = path11.join(asyncDir, "control", "steer-recovery");
-  fs12.mkdirSync(recoveryDir, { recursive: !0, mode: 448 });
-  let claimPath = path11.join(recoveryDir, "claim.json"), fd;
+  let recoveryDir = path12.join(asyncDir, "control", "steer-recovery");
+  fs13.mkdirSync(recoveryDir, { recursive: !0, mode: 448 });
+  let claimPath = path12.join(recoveryDir, "claim.json"), fd;
   try {
-    fd = fs12.openSync(claimPath, "wx", 384);
+    fd = fs13.openSync(claimPath, "wx", 384);
   } catch (error) {
     throw error.code === "EEXIST" ? new Error("Another steering recovery is already committed for this source run.") : error;
   }
   let writeError;
   try {
-    fs12.writeFileSync(fd, JSON.stringify({ version: 1, ...input }, null, 2), "utf-8"), fs12.fsyncSync(fd);
+    fs13.writeFileSync(fd, JSON.stringify({ version: 1, ...input }, null, 2), "utf-8"), fs13.fsyncSync(fd);
   } catch (error) {
     writeError = error;
   } finally {
-    fs12.closeSync(fd);
+    fs13.closeSync(fd);
   }
   if (writeError !== void 0)
-    throw fs12.rmSync(claimPath, { force: !0 }), writeError;
-  let markerPath = path11.join(recoveryDir, `${Buffer.from(input.requestId).toString("base64url")}.json`);
+    throw fs13.rmSync(claimPath, { force: !0 }), writeError;
+  let markerPath = path12.join(recoveryDir, `${Buffer.from(input.requestId).toString("base64url")}.json`);
   try {
     writePrivateAtomicJson(markerPath, { version: 1, ...input });
   } catch (error) {
-    throw fs12.rmSync(claimPath, { force: !0 }), error;
+    throw fs13.rmSync(claimPath, { force: !0 }), error;
   }
   return { claimPath, markerPath };
 }
@@ -5280,8 +5383,8 @@ async function waitForSteeringAction(input) {
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/foreground/async-steering-action.js
 import { randomUUID as randomUUID3 } from "node:crypto";
-import * as fs13 from "node:fs";
-import * as path12 from "node:path";
+import * as fs14 from "node:fs";
+import * as path13 from "node:path";
 async function steerAsyncRun(input) {
   if (!input.location.asyncDir)
     return {
@@ -5362,7 +5465,7 @@ async function steerAsyncRun(input) {
   if (status.mode === "single" && status.isNested !== !0 && running.length === 1 && !!finalStatus?.steering && (input.index === void 0 || input.index === 0) && finalResult?.state !== "scheduled" && input.recover) {
     let appendSteeringNotice = (state, message) => {
       try {
-        fs13.appendFileSync(path12.join(asyncDir, "events.jsonl"), `${JSON.stringify({ type: "subagent.steering.notice", ts: Date.now(), runId: status.runId, requestId, state, message, ...status.sessionId ? { currentSessionId: status.sessionId } : {} })}
+        fs14.appendFileSync(path13.join(asyncDir, "events.jsonl"), `${JSON.stringify({ type: "subagent.steering.notice", ts: Date.now(), runId: status.runId, requestId, state, message, ...status.sessionId ? { currentSessionId: status.sessionId } : {} })}
 `);
       } catch {
       }
@@ -5375,11 +5478,11 @@ async function steerAsyncRun(input) {
       input.onRecoveryCommitted?.(requestId, committedAt);
       let preCommitStatus = readStatus(asyncDir), preCommitResult = preCommitStatus?.steering ? actionResultFromSteeringStatus(preCommitStatus.steering, status.runId, requestId) : void 0;
       if (preCommitResult?.state === "delivered" && preCommitResult.targets.every((target) => target.deliveredAt !== void 0 && target.deliveredAt <= committedAt))
-        return fs13.rmSync(markerPath, { force: !0 }), fs13.rmSync(claimPath, { force: !0 }), { content: [{ type: "text", text: `Steering delivered for async run ${status.runId} (request ${requestId}).` }], details: { mode: "management", results: [], steering: preCommitResult } };
+        return fs14.rmSync(markerPath, { force: !0 }), fs14.rmSync(claimPath, { force: !0 }), { content: [{ type: "text", text: `Steering delivered for async run ${status.runId} (request ${requestId}).` }], details: { mode: "management", results: [], steering: preCommitResult } };
       try {
         deliverInterruptRequest({ asyncDir, pid: latest?.pid ?? status.pid, kill: input.kill, source: "steering-recovery" });
       } catch (error) {
-        throw fs13.rmSync(markerPath, { force: !0 }), fs13.rmSync(claimPath, { force: !0 }), new Error(`Failed to commit steering recovery interrupt: ${error instanceof Error ? error.message : String(error)}`);
+        throw fs14.rmSync(markerPath, { force: !0 }), fs14.rmSync(claimPath, { force: !0 }), new Error(`Failed to commit steering recovery interrupt: ${error instanceof Error ? error.message : String(error)}`);
       }
       let pauseDeadline = Date.now() + (input.recoveryTimeoutMs ?? 15e3), paused = null;
       for (; Date.now() <= pauseDeadline && !input.signal?.aborted; ) {
@@ -5401,12 +5504,12 @@ async function steerAsyncRun(input) {
         let stepSteering = paused.steps?.[ack.index]?.steering;
         stepSteering && updateSteeringTarget(stepSteering, ack.requestId, ack.index, state, ack.ts, { reason }), lateAckRecorded = !0;
         try {
-          fs13.appendFileSync(path12.join(asyncDir, "events.jsonl"), `${JSON.stringify({ type: ack.state === "delivered" ? "subagent.steer.delivered" : "subagent.steer.failed", ts: ack.ts, runId: status.runId, requestId: ack.requestId, index: ack.index, late: !0, message: ack.message })}
+          fs14.appendFileSync(path13.join(asyncDir, "events.jsonl"), `${JSON.stringify({ type: ack.state === "delivered" ? "subagent.steer.delivered" : "subagent.steer.failed", ts: ack.ts, runId: status.runId, requestId: ack.requestId, index: ack.index, late: !0, message: ack.message })}
 `);
         } catch {
         }
       }
-      lateAckRecorded && writeAtomicJson(path12.join(asyncDir, "status.json"), paused);
+      lateAckRecorded && writeAtomicJson(path13.join(asyncDir, "status.json"), paused);
       let recoveryTarget;
       try {
         recoveryTarget = resolveAsyncResumeTarget({ id: status.runId }, { kill: input.kill });
@@ -5424,7 +5527,7 @@ async function steerAsyncRun(input) {
       if (sourceStatus?.state === "paused" && sourceStatus.steering && targetIndex >= 0) {
         updateSteeringTarget(sourceStatus.steering, requestId, targetIndex, "recovered", Date.now(), { replacementRunId: revived.details.asyncId });
         let stepSteering = sourceStatus.steps?.[targetIndex]?.steering;
-        stepSteering && updateSteeringTarget(stepSteering, requestId, targetIndex, "recovered", Date.now(), { replacementRunId: revived.details.asyncId }), writeAtomicJson(path12.join(asyncDir, "status.json"), sourceStatus);
+        stepSteering && updateSteeringTarget(stepSteering, requestId, targetIndex, "recovered", Date.now(), { replacementRunId: revived.details.asyncId }), writeAtomicJson(path13.join(asyncDir, "status.json"), sourceStatus);
       }
       let recovered = sourceStatus?.steering ? actionResultFromSteeringStatus(sourceStatus.steering, status.runId, requestId, revived.details.asyncId) : void 0;
       return appendSteeringNotice("recovered", `Steering recovered for run ${status.runId}; replacement ${revived.details.asyncId} launched.`), { content: [{ type: "text", text: `Steering recovered for async run ${status.runId}; replacement ${revived.details.asyncId} launched after the source paused.` }], details: { mode: "management", results: [], steering: recovered ?? { requestId, state: "recovered", sourceRunId: status.runId, replacementRunId: revived.details.asyncId, targets: [{ index: input.index ?? 0, state: "recovered" }] } } };
@@ -5433,7 +5536,7 @@ async function steerAsyncRun(input) {
       if (failedStatus && failedStatus.state !== "running" && failedStatus.state !== "queued" && failedStatus.steering && targetIndex >= 0) {
         updateSteeringTarget(failedStatus.steering, requestId, targetIndex, "failed", Date.now(), { reason });
         let stepSteering = failedStatus.steps?.[targetIndex]?.steering;
-        stepSteering && updateSteeringTarget(stepSteering, requestId, targetIndex, "failed", Date.now(), { reason }), failedStatus.activityState = "needs_attention", writeAtomicJson(path12.join(asyncDir, "status.json"), failedStatus);
+        stepSteering && updateSteeringTarget(stepSteering, requestId, targetIndex, "failed", Date.now(), { reason }), failedStatus.activityState = "needs_attention", writeAtomicJson(path13.join(asyncDir, "status.json"), failedStatus);
       }
       let failed = failedStatus?.steering ? actionResultFromSteeringStatus(failedStatus.steering, status.runId, requestId) : void 0;
       return appendSteeringNotice("failed", `Steering failed for run ${status.runId}: ${reason}`), { content: [{ type: "text", text: `Steering failed for async run ${status.runId} (request ${requestId}): ${reason}` }], isError: !0, details: { mode: "management", results: [], steering: failed ?? { requestId, state: "failed", sourceRunId: status.runId, targets: [{ index: input.index ?? 0, state: "failed", reason }] } } };
@@ -5448,16 +5551,16 @@ async function steerAsyncRun(input) {
 }
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/background/chain-root-attachment.js
-import * as path13 from "node:path";
+import * as path14 from "node:path";
 function resolveAsyncRootResultPath(resultsDir, runId) {
-  return path13.join(resultsDir, `${runId}.json`);
+  return path14.join(resultsDir, `${runId}.json`);
 }
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/background/run-status.js
-import * as fs14 from "node:fs";
-import * as path14 from "node:path";
+import * as fs15 from "node:fs";
+import * as path15 from "node:path";
 function hasExistingSessionFile(value) {
-  return typeof value == "string" && fs14.existsSync(value);
+  return typeof value == "string" && fs15.existsSync(value);
 }
 function formatResumeGuidance(runId, children, fallbackSessionFile, options = {}) {
   if (options.stopped)
@@ -5493,9 +5596,9 @@ function formatSteeringSummary(input) {
 }
 function rememberedForegroundChildOutput(child) {
   let outputPath = child.artifactPaths?.outputPath ?? child.savedOutputPath;
-  if (outputPath && fs14.existsSync(outputPath))
+  if (outputPath && fs15.existsSync(outputPath))
     try {
-      let artifactOutput = fs14.readFileSync(outputPath, "utf-8").trim();
+      let artifactOutput = fs15.readFileSync(outputPath, "utf-8").trim();
       if (artifactOutput)
         return artifactOutput;
     } catch {
@@ -5668,7 +5771,7 @@ function inspectSubagentStatus(params, deps = {}) {
         details: { mode: "single", results: [] }
       };
     }
-    let status = reconciliation.status, effectiveRunId = status?.runId ?? resolvedId ?? "unknown", logPath = path14.join(asyncDir, `subagent-log-${effectiveRunId}.md`), eventsPath = path14.join(asyncDir, "events.jsonl");
+    let status = reconciliation.status, effectiveRunId = status?.runId ?? resolvedId ?? "unknown", logPath = path15.join(asyncDir, `subagent-log-${effectiveRunId}.md`), eventsPath = path15.join(asyncDir, "events.jsonl");
     if (status) {
       if (params.view === "transcript") {
         if (currentSessionId && status.sessionId !== currentSessionId)
@@ -5712,22 +5815,22 @@ function inspectSubagentStatus(params, deps = {}) {
         `Dir: ${asyncDir}`,
         outputPath ? `Output: ${outputPath}` : void 0,
         reconciliation.message ? `Diagnosis: ${reconciliation.message}` : void 0,
-        reconciliation.resultPath && fs14.existsSync(reconciliation.resultPath) ? `Result: ${reconciliation.resultPath}` : void 0
+        reconciliation.resultPath && fs15.existsSync(reconciliation.resultPath) ? `Result: ${reconciliation.resultPath}` : void 0
       ].filter((line) => !!line);
       for (let [index, step] of (status.steps ?? []).entries()) {
         let stepActivityText = step.status === "running" ? formatActivityLabel(step.lastActivityAt, step.activityState) : void 0, modelThinking = formatModelSelection(step.modelSelection, step.model, step.thinking), modelText = modelThinking ? ` (${modelThinking})` : "", steeringText2 = formatSteeringSummary(step), steeringSuffix = steeringText2 ? `, steering: ${steeringText2}` : "", errorText2 = step.error ? `, error: ${step.error}` : "", acceptanceText = step.acceptance?.status ? `, acceptance: ${step.acceptance.status}` : "", budgetText = step.turnBudget ? `, turn budget: ${step.turnBudget.turnCount}/${step.turnBudget.maxTurns}+${step.turnBudget.graceTurns} (${step.turnBudget.outcome})` : "", display = step.label ? `${step.label} (${step.agent})` : step.agent, phase = step.phase ? `[${step.phase}] ` : "";
         lines.push(`${stepLineLabel(status, index)}: ${phase}${display} ${step.status}${modelText}${stepActivityText ? `, ${stepActivityText}` : ""}${steeringSuffix}${acceptanceText}${budgetText}${errorText2}`), lines.push(...formatNestedRunStatusLines(step.children, { indent: "  ", commandHints: !0, maxLines: 20 }));
-        let stepOutputPath = path14.join(asyncDir, `output-${index}.log`);
-        stepOutputPath !== outputPath && fs14.existsSync(stepOutputPath) && lines.push(`  Output: ${stepOutputPath}`), step.status === "running" && (lines.push(`  Intercom target: ${resolveSubagentIntercomTarget(status.runId, step.childId ?? step.agent, index)} (if registered)`), lines.push(`  Steer: subagent({ action: "steer", id: "${status.runId}", index: ${index}, message: "..." })`));
+        let stepOutputPath = path15.join(asyncDir, `output-${index}.log`);
+        stepOutputPath !== outputPath && fs15.existsSync(stepOutputPath) && lines.push(`  Output: ${stepOutputPath}`), step.status === "running" && (lines.push(`  Intercom target: ${resolveSubagentIntercomTarget(status.runId, step.childId ?? step.agent, index)} (if registered)`), lines.push(`  Steer: subagent({ action: "steer", id: "${status.runId}", index: ${index}, message: "..." })`));
       }
       let attached = new Set((status.steps ?? []).flatMap((step) => step.children?.map((child) => child.id) ?? [])), unattached = nestedChildren.filter((child) => !attached.has(child.id));
-      return lines.push(...formatNestedRunStatusLines(unattached, { indent: "", commandHints: !0, maxLines: 20 })), nestedWarning && lines.push(`Warning: ${nestedWarning}`), status.sessionFile && lines.push(`Session: ${status.sessionFile}`), status.state === "running" && lines.push(`Steer running child: subagent({ action: "steer", id: "${status.runId}", message: "..." })`), status.state !== "running" && lines.push(formatResumeGuidance(status.runId, status.steps ?? [], status.sessionFile, { stopped: status.state === "stopped" || status.stopped === !0 })), fs14.existsSync(logPath) && lines.push(`Log: ${logPath}`), fs14.existsSync(eventsPath) && lines.push(`Events: ${eventsPath}`), { content: [{ type: "text", text: lines.join(`
+      return lines.push(...formatNestedRunStatusLines(unattached, { indent: "", commandHints: !0, maxLines: 20 })), nestedWarning && lines.push(`Warning: ${nestedWarning}`), status.sessionFile && lines.push(`Session: ${status.sessionFile}`), status.state === "running" && lines.push(`Steer running child: subagent({ action: "steer", id: "${status.runId}", message: "..." })`), status.state !== "running" && lines.push(formatResumeGuidance(status.runId, status.steps ?? [], status.sessionFile, { stopped: status.state === "stopped" || status.stopped === !0 })), fs15.existsSync(logPath) && lines.push(`Log: ${logPath}`), fs15.existsSync(eventsPath) && lines.push(`Events: ${eventsPath}`), { content: [{ type: "text", text: lines.join(`
 `) }], details: { mode: "single", results: [] } };
     }
   }
   if (resultPath)
     try {
-      let raw = fs14.readFileSync(resultPath, "utf-8"), data = JSON.parse(raw);
+      let raw = fs15.readFileSync(resultPath, "utf-8"), data = JSON.parse(raw);
       if (params.view === "transcript")
         try {
           return { content: [{ type: "text", text: formatAsyncResultTranscript(data, resultPath, { index: params.index, lines: params.lines }) }], details: { mode: "single", results: [] } };
@@ -5754,7 +5857,7 @@ function inspectSubagentStatus(params, deps = {}) {
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/foreground/subagent-executor.js
 var MUTATING_MANAGEMENT_ACTIONS = /* @__PURE__ */ new Set(["create", "update", "delete", "eject", "disable", "enable", "reset"]);
 function resolveRequestedCwd(runtimeCwd, requestedCwd) {
-  return requestedCwd ? path15.resolve(runtimeCwd, requestedCwd) : runtimeCwd;
+  return requestedCwd ? path16.resolve(runtimeCwd, requestedCwd) : runtimeCwd;
 }
 function getForegroundControl(state, runId) {
   if (runId)
@@ -5786,7 +5889,7 @@ function nestedResolutionScopeForExecutor(deps) {
   };
 }
 function trustedSessionRootsForStatus(ctx, deps) {
-  let roots = deps.config.defaultSessionDir ? [path15.resolve(deps.expandTilde(deps.config.defaultSessionDir))] : [], parentSessionFile = ctx.sessionManager.getSessionFile() ?? null;
+  let roots = deps.config.defaultSessionDir ? [path16.resolve(deps.expandTilde(deps.config.defaultSessionDir))] : [], parentSessionFile = ctx.sessionManager.getSessionFile() ?? null;
   return parentSessionFile && roots.push(deps.getSubagentSessionRoot(parentSessionFile)), [...new Set(roots)];
 }
 function reserveSubagentSpawns(input) {
@@ -5908,7 +6011,8 @@ ${output}` : ""}` : output || input.result.error || "Detached child exited witho
     cwd: input.cwd,
     sessionFile: input.result.sessionFile,
     sessionId: input.sessionId,
-    taskIndex: input.index
+    taskIndex: input.index,
+    results: [{ childId: input.result.childId, agent: input.result.agent, sessionFile: input.result.sessionFile, usage: input.result.usage, usageRequests: input.result.usageRequests, success, output: summary }]
   });
 }
 function resolveForegroundResumeTarget(params, state) {
@@ -5933,10 +6037,10 @@ function resolveForegroundResumeTarget(params, state) {
   let 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 (path15.extname(child.sessionFile) !== ".jsonl")
+  if (path16.extname(child.sessionFile) !== ".jsonl")
     throw new Error(`Foreground run '${run.runId}' child ${index} session file must be a .jsonl file: ${child.sessionFile}`);
-  let sessionFile = path15.resolve(child.sessionFile);
-  if (!fs15.existsSync(sessionFile))
+  let sessionFile = path16.resolve(child.sessionFile);
+  if (!fs16.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, state: "complete", agent: child.agent, index, intercomTarget: resolveSubagentIntercomTarget(run.runId, child.agent, index), cwd: run.cwd, sessionFile };
 }
@@ -5988,18 +6092,15 @@ function resolveResumeTarget(params, state, options = {}) {
   }
   throw foregroundError && !isAsyncRunNotFound(asyncError) || foregroundError ? foregroundError : asyncError || new Error("Run not found. Provide id or runId.");
 }
-function getAsyncInterruptTarget(state, runId, location, options = {}) {
+function getAsyncInterruptTarget(state, runId, location) {
   if (location?.asyncDir)
     return {
-      asyncId: location.resolvedId ?? runId ?? path15.basename(location.asyncDir),
+      asyncId: location.resolvedId ?? runId ?? path16.basename(location.asyncDir),
       asyncDir: location.asyncDir
     };
   if (runId) {
     let direct = state.asyncJobs.get(runId);
-    if (direct)
-      return { asyncId: direct.asyncId, asyncDir: direct.asyncDir };
-    if (options.fallbackToNewest === !1)
-      return;
+    return direct ? { asyncId: direct.asyncId, asyncDir: direct.asyncDir } : void 0;
   }
   let newest;
   for (let job of state.asyncJobs.values())
@@ -6026,6 +6127,12 @@ function interruptAsyncRun(state, runId, kill, location) {
   if (!target)
     return null;
   let status = reconcileAsyncRun(target.asyncDir, { kill }).status;
+  if (state.currentSessionId && status?.sessionId !== state.currentSessionId)
+    return {
+      content: [{ type: "text", text: `Async run '${target.asyncId}' was not found in the active session.` }],
+      isError: !0,
+      details: { mode: "management", results: [] }
+    };
   if (!status || status.state !== "running" || typeof status.pid != "number")
     return {
       content: [{ type: "text", text: `No running async run with an interrupt-capable pid was found for '${runId ?? "current"}'.` }],
@@ -6049,7 +6156,7 @@ function interruptAsyncRun(state, runId, kill, location) {
   }
 }
 function stopAsyncRun(state, runId, kill, location) {
-  let target = getAsyncInterruptTarget(state, runId, location, { fallbackToNewest: !1 });
+  let target = getAsyncInterruptTarget(state, runId, location);
   if (!target)
     return null;
   let status = reconcileAsyncRun(target.asyncDir, { kill }).status;
@@ -6256,27 +6363,27 @@ function nestedRunAgent(run) {
   return run.agent ?? run.agents?.[0] ?? (run.steps?.length === 1 ? run.steps[0]?.agent : void 0);
 }
 function pathWithin(base, candidate) {
-  let resolvedBase = path15.resolve(base), resolvedCandidate = path15.resolve(candidate);
-  return resolvedCandidate === resolvedBase || resolvedCandidate.startsWith(`${resolvedBase}${path15.sep}`);
+  let resolvedBase = path16.resolve(base), resolvedCandidate = path16.resolve(candidate);
+  return resolvedCandidate === resolvedBase || resolvedCandidate.startsWith(`${resolvedBase}${path16.sep}`);
 }
 function validateNestedSessionFile(run, trustedSessionRoots) {
   let sessionFile = nestedRunSessionFile(run);
   if (!sessionFile)
     throw new Error(`Nested run '${run.id}' does not have a persisted session file to resume from.`);
-  if (path15.extname(sessionFile) !== ".jsonl")
+  if (path16.extname(sessionFile) !== ".jsonl")
     throw new Error(`Nested run '${run.id}' session file must be a .jsonl file: ${sessionFile}`);
-  let resolved = path15.resolve(sessionFile);
-  if (!path15.isAbsolute(sessionFile))
+  let resolved = path16.resolve(sessionFile);
+  if (!path16.isAbsolute(sessionFile))
     throw new Error(`Nested run '${run.id}' session file must be absolute: ${sessionFile}`);
-  if (!fs15.existsSync(resolved))
+  if (!fs16.existsSync(resolved))
     throw new Error(`Nested run '${run.id}' session file does not exist: ${sessionFile}`);
-  let stat = fs15.lstatSync(resolved);
+  let stat = fs16.lstatSync(resolved);
   if (!stat.isFile() || stat.isSymbolicLink())
     throw new Error(`Nested run '${run.id}' session file is not a regular file: ${sessionFile}`);
-  let realSessionFile = fs15.realpathSync(resolved);
-  if (!trustedSessionRoots.filter((root) => fs15.existsSync(root)).map((root) => fs15.realpathSync(root)).some((root) => pathWithin(root, realSessionFile)))
+  let realSessionFile = fs16.realpathSync(resolved);
+  if (!trustedSessionRoots.filter((root) => fs16.existsSync(root)).map((root) => fs16.realpathSync(root)).some((root) => pathWithin(root, realSessionFile)))
     throw new Error(`Nested run '${run.id}' session file is outside trusted nested session roots: ${sessionFile}`);
-  if (!realSessionFile.split(path15.sep).includes(run.id))
+  if (!realSessionFile.split(path16.sep).includes(run.id))
     throw new Error(`Nested run '${run.id}' session file is not under that nested run's session directory: ${sessionFile}`);
   return realSessionFile;
 }
@@ -6296,7 +6403,7 @@ function resolveNestedResumeTarget(match, trustedSessionRoots) {
     agent,
     index: 0,
     intercomTarget: resolveSubagentIntercomTarget(run.id, agent, 0),
-    cwd: asyncDir ? path15.dirname(asyncDir) : void 0,
+    cwd: asyncDir ? path16.dirname(asyncDir) : void 0,
     sessionFile: validateNestedSessionFile(run, trustedSessionRoots)
   };
 }
@@ -6323,7 +6430,7 @@ function directNestedAsyncInterrupt(target) {
   let run = target.match.run, asyncDir = resolveNestedAsyncDir(target.match.rootRunId, run);
   if (!asyncDir)
     return;
-  let status = reconcileAsyncRun(asyncDir, { resultsDir: path15.join(RESULTS_DIR, "nested", target.match.rootRunId) }).status, pid = typeof status?.pid == "number" && status.pid > 0 ? status.pid : run.pid;
+  let status = reconcileAsyncRun(asyncDir, { resultsDir: path16.join(RESULTS_DIR, "nested", target.match.rootRunId) }).status, pid = typeof status?.pid == "number" && status.pid > 0 ? status.pid : run.pid;
   if (!(!status || status.state !== "running" || typeof pid != "number" || pid <= 0))
     try {
       return deliverInterruptRequest({ asyncDir, pid, source: "nested-interrupt" }), { content: [{ type: "text", text: `Interrupt requested for nested async run ${run.id}.` }], details: { mode: "management", results: [] } };
@@ -6336,7 +6443,7 @@ async function directNestedAsyncSteer(input) {
   let run = input.target.match.run, asyncDir = resolveNestedAsyncDir(input.target.match.rootRunId, run);
   if (!asyncDir)
     return;
-  let status = reconcileAsyncRun(asyncDir, { resultsDir: path15.join(RESULTS_DIR, "nested", input.target.match.rootRunId) }).status;
+  let status = reconcileAsyncRun(asyncDir, { resultsDir: path16.join(RESULTS_DIR, "nested", input.target.match.rootRunId) }).status;
   if (!status || status.state !== "running" && status.state !== "queued")
     return;
   let steps = status.steps ?? [];
@@ -6430,7 +6537,7 @@ async function resumeAsyncRun(input) {
       if (resolved.match.run.state === "running" || resolved.match.run.state === "queued")
         return resumeLiveNestedRun({ target: resolved, message: followUp });
       let trustedSessionRoots = [
-        ...input.deps.config.defaultSessionDir ? [path15.resolve(input.deps.expandTilde(input.deps.config.defaultSessionDir))] : [],
+        ...input.deps.config.defaultSessionDir ? [path16.resolve(input.deps.expandTilde(input.deps.config.defaultSessionDir))] : [],
         ...parentSessionFile ? [input.deps.getSubagentSessionRoot(parentSessionFile)] : []
       ];
       target = resolveNestedResumeTarget(resolved, trustedSessionRoots);
@@ -6496,7 +6603,7 @@ ${followUp}`, 500, { source: "async-resume", runId: target.runId, agent: target.
       goal,
       attachRoot: {
         runId: target.runId,
-        asyncDir: target.asyncDir ?? path15.join(ASYNC_DIR, target.runId),
+        asyncDir: target.asyncDir ?? path16.join(ASYNC_DIR, target.runId),
         resultPath: resolveAsyncRootResultPath(RESULTS_DIR, target.runId),
         index: target.index,
         agent: target.agent,
@@ -7440,7 +7547,7 @@ function buildParallelWorktreeTaskCwdError(tasks, sharedCwd) {
     return formatWorktreeTaskCwdConflict(conflict, sharedCwd);
 }
 function resolveSingleRunOutputBaseDir(deps, artifactsDir, runId) {
-  return deps.config.singleRunOutputBaseDir ? path15.resolve(deps.expandTilde(deps.config.singleRunOutputBaseDir)) : path15.join(artifactsDir, "outputs", runId);
+  return deps.config.singleRunOutputBaseDir ? path16.resolve(deps.expandTilde(deps.config.singleRunOutputBaseDir)) : path16.join(artifactsDir, "outputs", runId);
 }
 function buildChainWorktreeTaskCwdError(chain, sharedCwd) {
   for (let stepIndex = 0; stepIndex < chain.length; stepIndex++) {
@@ -7460,7 +7567,7 @@ function resolveParallelTaskCwd(task, paramsCwd, worktreeSetup, index) {
 function buildParallelWorktreeSuffix(worktreeSetup, artifactsDir, tasks) {
   if (!worktreeSetup)
     return "";
-  let diffsDir = path15.join(artifactsDir, "worktree-diffs"), diffs = diffWorktrees(worktreeSetup, tasks.map((task) => task.agent), diffsDir);
+  let diffsDir = path16.join(artifactsDir, "worktree-diffs"), diffs = diffWorktrees(worktreeSetup, tasks.map((task) => task.agent), diffsDir);
   return formatWorktreeDiffSummary(diffs);
 }
 function findDuplicateParallelOutputPath(input) {
@@ -7559,7 +7666,17 @@ async function runForegroundParallelTasks(input) {
     }).finally(() => {
       input.foregroundControl?.currentIndex === index && (input.foregroundControl.interrupt = void 0, input.foregroundControl.updatedAt = Date.now());
     });
-  }, input.globalSemaphore);
+  }, input.globalSemaphore, {
+    signal: input.signal,
+    onAbort: (task) => ({
+      agent: task.agent,
+      task: task.task ?? "",
+      exitCode: 1,
+      messages: [],
+      usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
+      error: "Subagent launch cancelled."
+    })
+  });
 }
 async function runParallelPath(data, deps) {
   let { params, effectiveCwd, agents, ctx, signal, runId, sessionDirForIndex, sessionFileForIndex, sessionFileForTask, thinkingOverrideForTask, shareEnabled, artifactConfig, artifactsDir, backgroundRequestedWhileClarifying, onUpdate, sessionRoot, controlConfig, contextPolicy } = data, onControlEvent = createForegroundControlNotifier(data, deps), childIntercomTarget = data.intercomBridge.active ? resolveSubagentIntercomTarget : void 0, allProgress = [], allArtifactPaths = [], tasks = params.tasks, maxParallelTasks = resolveTopLevelParallelMaxTasks(deps.config.parallel?.maxTasks), parallelConcurrency = resolveTopLevelParallelConcurrency(params.concurrency, deps.config.parallel?.concurrency);
@@ -7684,7 +7801,7 @@ async function runParallelPath(data, deps) {
   if (errorResult)
     return errorResult;
   try {
-    let outputBaseDir = path15.join(artifactsDir, "outputs", runId), duplicateOutputError = findDuplicateParallelOutputPath({
+    let outputBaseDir = path16.join(artifactsDir, "outputs", runId), duplicateOutputError = findDuplicateParallelOutputPath({
       tasks,
       behaviors,
       paramsCwd: effectiveCwd,
@@ -7699,7 +7816,7 @@ async function runParallelPath(data, deps) {
       if (validationError)
         return buildParallelModeError(validationError);
     }
-    let parallelProgressPrecreated = firstProgressIndex !== -1, parallelProgressDir = path15.join(artifactsDir, "progress", runId);
+    let parallelProgressPrecreated = firstProgressIndex !== -1, parallelProgressDir = path16.join(artifactsDir, "progress", runId);
     parallelProgressPrecreated && writeInitialProgressFile(parallelProgressDir);
     for (let i = 0; i < taskTexts.length; i++)
       shouldForkAgent(contextPolicy, tasks[i].agent) && (taskTexts[i] = wrapForkTask(taskTexts[i]));
@@ -8122,7 +8239,7 @@ function createSubagentExecutor(deps) {
         let targetRunId = paramsWithResolvedCwd.runId ?? paramsWithResolvedCwd.id;
         if (paramsWithResolvedCwd.dir)
           try {
-            let location = resolveAsyncRunLocation(paramsWithResolvedCwd, ASYNC_DIR, RESULTS_DIR), runId2 = location.resolvedId ?? targetRunId ?? path15.basename(location.asyncDir ?? paramsWithResolvedCwd.dir);
+            let location = resolveAsyncRunLocation(paramsWithResolvedCwd, ASYNC_DIR, RESULTS_DIR), runId2 = location.resolvedId ?? targetRunId ?? path16.basename(location.asyncDir ?? paramsWithResolvedCwd.dir);
             return steerAsyncRun({ state: deps.state, runId: runId2, message, index: paramsWithResolvedCwd.index, kill: deps.kill, location, signal, recover: ({ absoluteDeadlineAt, ...limits }) => resumeAsyncRun({ params: { ...limits, action: "resume", id: runId2, message }, requestCwd, ctx, deps, absoluteDeadlineAt }) });
           } catch (error) {
             return { content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: !0, details: { mode: "management", results: [] } };
@@ -8150,7 +8267,7 @@ function createSubagentExecutor(deps) {
         if (paramsWithResolvedCwd.dir)
           try {
             let location = resolveAsyncRunLocation(paramsWithResolvedCwd, ASYNC_DIR, RESULTS_DIR);
-            return stopAsyncRun(deps.state, location.resolvedId ?? targetRunId ?? path15.basename(location.asyncDir ?? paramsWithResolvedCwd.dir), deps.kill, location);
+            return stopAsyncRun(deps.state, location.resolvedId ?? targetRunId ?? path16.basename(location.asyncDir ?? paramsWithResolvedCwd.dir), deps.kill, location);
           } catch (error) {
             return { content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: !0, details: { mode: "management", results: [] } };
           }
@@ -8173,7 +8290,14 @@ function createSubagentExecutor(deps) {
         };
       }
       if (action === "interrupt") {
-        let targetRunId = paramsWithResolvedCwd.runId ?? paramsWithResolvedCwd.id, resolved;
+        let targetRunId = paramsWithResolvedCwd.runId ?? paramsWithResolvedCwd.id;
+        if (targetRunId !== void 0 && !targetRunId.trim())
+          return {
+            content: [{ type: "text", text: "Explicit interrupt id must be non-empty." }],
+            isError: !0,
+            details: { mode: "management", results: [] }
+          };
+        let resolved;
         if (targetRunId)
           try {
             resolved = resolveSubagentRunId(targetRunId, { state: deps.state, nested: nestedResolutionScopeForExecutor(deps) });
@@ -8277,18 +8401,18 @@ function createSubagentExecutor(deps) {
       enabled: effectiveParams.artifacts !== !1
     }, artifactsDir = getArtifactsDir(parentSessionFile, effectiveCwd), sessionRoot;
     if (effectiveParams.sessionDir)
-      sessionRoot = path15.resolve(deps.expandTilde(effectiveParams.sessionDir));
+      sessionRoot = path16.resolve(deps.expandTilde(effectiveParams.sessionDir));
     else {
-      let baseSessionRoot = deps.config.defaultSessionDir ? path15.resolve(deps.expandTilde(deps.config.defaultSessionDir)) : deps.getSubagentSessionRoot(parentSessionFile);
-      sessionRoot = path15.join(baseSessionRoot, runId);
+      let baseSessionRoot = deps.config.defaultSessionDir ? path16.resolve(deps.expandTilde(deps.config.defaultSessionDir)) : deps.getSubagentSessionRoot(parentSessionFile);
+      sessionRoot = path16.join(baseSessionRoot, runId);
     }
     try {
-      fs15.mkdirSync(sessionRoot, { recursive: !0 });
+      fs16.mkdirSync(sessionRoot, { recursive: !0 });
     } catch (error) {
       let message = error instanceof Error ? error.message : String(error);
       return toExecutionErrorResult(effectiveParams, new Error(`Failed to create session directory '${sessionRoot}': ${message}`));
     }
-    let sessionDirForIndex = (idx) => path15.join(sessionRoot, `run-${idx ?? 0}`), forkSessionFileForTask = (agentName, idx = 0, modelOverride) => {
+    let sessionDirForIndex = (idx) => path16.join(sessionRoot, `run-${idx ?? 0}`), forkSessionFileForTask = (agentName, idx = 0, modelOverride) => {
       if (shouldForkAgent(contextPolicy, agentName))
         return prepareForkThinking(agentName, idx, modelOverride), forkSessionFileForIndex(idx);
     }, forkThinkingOverrideForTask = (agentName, idx = 0, modelOverride) => {
@@ -8297,7 +8421,7 @@ function createSubagentExecutor(deps) {
       prepareForkThinking(agentName, idx, modelOverride);
       let override = forkThinkingOverrideForIndex(idx);
       return override === "off" && forkThinkingDowngrades.set(idx, agentName), override;
-    }, childSessionFileForTask = (agentName, idx, modelOverride) => forkSessionFileForTask(agentName, idx, modelOverride) ?? path15.join(sessionDirForIndex(idx), "session.jsonl"), childSessionFileForIndex = (idx) => path15.join(sessionDirForIndex(idx), "session.jsonl");
+    }, childSessionFileForTask = (agentName, idx, modelOverride) => forkSessionFileForTask(agentName, idx, modelOverride) ?? path16.join(sessionDirForIndex(idx), "session.jsonl"), childSessionFileForIndex = (idx) => path16.join(sessionDirForIndex(idx), "session.jsonl");
     try {
       effectiveParams.clarify === !0 && ctx.hasUI || preflightForkSessionsForStaticTasks(effectiveParams, contextPolicy, forkSessionFileForTask, deps.config.chain?.dynamicFanout?.maxItems);
     } catch (error) {