@ashx-j/lunr 0.2.27 → 0.2.28

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

@@ -218,12 +218,16 @@ import "./chunk-RYRGL7P4.js";
 import "./chunk-ES6PBSIE.js";
 import {
   SessionManager
-} from "./chunk-EPR2F3GU.js";
+} from "./chunk-PWHTSQC4.js";
 import "./chunk-FVDOXRUD.js";
 import "./chunk-UJOCPOMX.js";
 import "./chunk-IMLCWLPI.js";
 import "./chunk-MNQXDFPV.js";
 import "./chunk-RQ2Q5IYR.js";
+import {
+  collectUsageRequests,
+  totalRequestUsage
+} from "./chunk-SWWHZ2RI.js";
 import "./chunk-RHCGYWO7.js";
 import "./chunk-QW3AAHWN.js";
 import "./chunk-JL4HYQXK.js";
@@ -233,8 +237,8 @@ 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";
@@ -918,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);
@@ -975,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;
     }
@@ -999,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)}`;
   }
@@ -1227,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() {
@@ -1246,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;
   }
@@ -1255,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))
@@ -1273,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 {
@@ -1300,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)
@@ -1310,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 {
@@ -1375,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;
@@ -1392,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;
@@ -1408,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 [
@@ -1456,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,
@@ -1471,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 };
@@ -1481,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) };
   }
@@ -1491,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;
@@ -1503,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,
@@ -1603,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.`;
@@ -1677,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,
@@ -2033,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;
@@ -2100,6 +2160,8 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
       });
       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;
@@ -2334,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,
@@ -2347,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,
@@ -2370,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) {
@@ -2403,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 {
@@ -2418,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 {
   }
@@ -2426,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" });
@@ -2454,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;
   }
@@ -2467,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 };
   }
@@ -2488,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}`);
@@ -2498,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;
   }
@@ -2534,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,
@@ -2554,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]);
@@ -2618,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) {
@@ -2656,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)
@@ -2708,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 {
@@ -2724,7 +2786,7 @@ function captureWorktreeDiff(setup, worktree, agent, patchPath) {
 }
 function writeEmptyPatch(patchPath) {
   try {
-    fs6.writeFileSync(patchPath, "", "utf-8");
+    fs7.writeFileSync(patchPath, "", "utf-8");
   } catch {
   }
 }
@@ -2761,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 {
@@ -2791,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();
 }
@@ -3356,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,
@@ -3558,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 }));
         }
@@ -3656,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,
@@ -3665,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);
       }
@@ -3730,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 }));
       }
@@ -3891,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,
@@ -4019,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;
           }
@@ -4037,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 {
@@ -4094,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;
   }
@@ -4111,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 {
     }
 }
@@ -4133,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)}` };
@@ -4157,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;
@@ -4192,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,
@@ -4238,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 {
       }
     }
@@ -4295,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"))
@@ -4372,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 = () => {
@@ -4469,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 {
@@ -4491,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,
@@ -4503,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);
@@ -4513,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,
@@ -4644,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 {
@@ -4655,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)
@@ -4673,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,
@@ -4709,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)}`);
   }
@@ -4746,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,
@@ -4866,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)}`;
   }
@@ -4893,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;
@@ -5016,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 [];
@@ -5063,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,
@@ -5075,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 };
 }
@@ -5085,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";
 }
@@ -5140,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);
@@ -5169,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");
       }
@@ -5215,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++;
 }
@@ -5248,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 };
 }
@@ -5321,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 {
@@ -5403,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 {
       }
@@ -5416,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; ) {
@@ -5442,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 });
@@ -5465,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" }] } } };
@@ -5474,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 }] } } };
@@ -5489,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)
@@ -5534,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 {
@@ -5709,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)
@@ -5753,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: [] } };
@@ -5795,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)
@@ -5827,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) {
@@ -5949,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) {
@@ -5974,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 };
 }
@@ -6032,7 +6095,7 @@ function resolveResumeTarget(params, state, 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) {
@@ -6300,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;
 }
@@ -6340,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)
   };
 }
@@ -6367,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: [] } };
@@ -6380,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 ?? [];
@@ -6474,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);
@@ -6540,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,
@@ -7484,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++) {
@@ -7504,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) {
@@ -7738,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,
@@ -7753,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]));
@@ -8176,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: [] } };
@@ -8204,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: [] } };
           }
@@ -8338,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) => {
@@ -8358,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) {