@narumitw/pi-subagents 2.0.1 → 2.0.3

package/dist/chunks/chunk-DQMN4OYM.ts

@@ -0,0 +1,913 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
+import {
+  resolvePiInvocation
+} from "./chunk-IGAMVWFN.ts";
+import {
+  classifyStructuredOutcome
+} from "./chunk-47SK2QYC.ts";
+import {
+  revokeCapabilityGrant
+} from "./chunk-HKC4ES4B.ts";
+import {
+  buildTimeoutFinalizationPrompt,
+  resolveTimeoutFinalizationMs
+} from "./chunk-G3RSMSXJ.ts";
+import {
+  formatResultFailure,
+  getFinalOutput,
+  getResultFinalOutput,
+  isResultError
+} from "./chunk-AEUYS7JC.ts";
+import {
+  TURN_TERMINATION_VERSION,
+  TimeoutProgressJournal,
+  formatTimeoutCheckpoint,
+  formatTurnTerminationMessage,
+  journalMessages
+} from "./chunk-RTCVYIZA.ts";
+import {
+  TurnBudgetMonitor
+} from "./chunk-ONDTY4EL.ts";
+import {
+  parseAnyStructuredSubagentResult
+} from "./chunk-RSUXZD6S.ts";
+import {
+  DEFAULT_MAX_CONTEXT_BYTES,
+  DEFAULT_MAX_MESSAGES,
+  DEFAULT_MAX_OUTPUT_BYTES,
+  DEFAULT_MAX_STDERR_BYTES,
+  MAX_SUBAGENT_TIMEOUT_MS,
+  appendBounded,
+  truncateUtf8
+} from "./chunk-H3FP6DLR.ts";
+
+// src/protocol.ts
+import { StringDecoder } from "node:string_decoder";
+var DEFAULT_MAX_LINE_BYTES = 256 * 1024;
+var JsonLineDecoder = class {
+  constructor(options) {
+    this.options = options;
+    const maxLineBytes = options.maxLineBytes ?? DEFAULT_MAX_LINE_BYTES;
+    if (!Number.isSafeInteger(maxLineBytes) || maxLineBytes < 1) {
+      throw new Error("JSON line limit must be a positive safe integer");
+    }
+    this.maxLineBytes = maxLineBytes;
+  }
+  options;
+  buffer = "";
+  droppingOversizedLine = false;
+  maxLineBytes;
+  decoder = new StringDecoder("utf8");
+  push(chunk) {
+    this.buffer += typeof chunk === "string" ? chunk : this.decoder.write(chunk);
+    this.drain(false);
+  }
+  finish() {
+    this.buffer += this.decoder.end();
+    this.drain(true);
+    this.buffer = "";
+    this.droppingOversizedLine = false;
+  }
+  drain(flush) {
+    while (true) {
+      const newline = this.buffer.indexOf("\n");
+      if (newline < 0) break;
+      const line = this.buffer.slice(0, newline).replace(/\r$/, "");
+      this.buffer = this.buffer.slice(newline + 1);
+      if (this.droppingOversizedLine) {
+        this.droppingOversizedLine = false;
+        continue;
+      }
+      this.processLine(line);
+    }
+    if (!flush && Buffer.byteLength(this.buffer, "utf8") > this.maxLineBytes) {
+      this.options.onOversized?.(Buffer.byteLength(this.buffer, "utf8"));
+      this.buffer = "";
+      this.droppingOversizedLine = true;
+    }
+    if (flush && this.buffer.length > 0 && !this.droppingOversizedLine) {
+      this.processLine(this.buffer.replace(/\r$/, ""));
+    }
+  }
+  processLine(line) {
+    if (!line.trim()) return;
+    const bytes = Buffer.byteLength(line, "utf8");
+    if (bytes > this.maxLineBytes) {
+      this.options.onOversized?.(bytes);
+      return;
+    }
+    try {
+      this.options.onValue(JSON.parse(line));
+    } catch {
+      this.options.onMalformed?.(line);
+    }
+  }
+};
+
+// src/runner.ts
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+
+// src/pi-args.ts
+function buildPiArgs(options) {
+  const args = ["--mode", "json", "-p", "--no-session"];
+  if (options.model) args.push("--model", options.model);
+  if (options.thinkingLevel) args.push("--thinking", options.thinkingLevel);
+  if (options.disableExtensions) args.push("--no-extensions");
+  for (const extensionPath of options.extensionPaths ?? []) args.push("-e", extensionPath);
+  if (options.disableSkills) args.push("--no-skills");
+  if (options.disablePromptTemplates) args.push("--no-prompt-templates");
+  if (options.disableContextFiles) args.push("--no-context-files");
+  if (options.projectTrust !== void 0) {
+    args.push(options.projectTrust ? "--approve" : "--no-approve");
+  }
+  if (Array.isArray(options.tools)) {
+    if (options.tools.length > 0) args.push("--tools", options.tools.join(","));
+    else args.push("--no-tools");
+  }
+  if (options.baseSystemPromptPath) args.push("--system-prompt", options.baseSystemPromptPath);
+  for (const promptPath of options.appendSystemPromptPaths ?? []) {
+    args.push("--append-system-prompt", promptPath);
+  }
+  if (options.systemPromptPath) args.push("--append-system-prompt", options.systemPromptPath);
+  args.push(`Task: ${options.task}`);
+  return args;
+}
+
+// src/runner-usage.ts
+var MAX_USAGE_VALUE = Number.MAX_SAFE_INTEGER;
+function protocolUsageCount(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : 0;
+}
+function protocolUsageCost(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.min(value, MAX_USAGE_VALUE) : 0;
+}
+function addUsageValue(current, addition) {
+  return Math.min(MAX_USAGE_VALUE, current + addition);
+}
+function mergeUsageStats(target, addition) {
+  for (const key of ["input", "output", "cacheRead", "cacheWrite", "cost", "turns"]) {
+    target[key] = addUsageValue(target[key], addition[key]);
+  }
+  for (const key of [
+    "costInput",
+    "costOutput",
+    "costCacheRead",
+    "costCacheWrite",
+    "totalTokens"
+  ]) {
+    if (addition[key] !== void 0) {
+      target[key] = addUsageValue(target[key] ?? 0, addition[key]);
+    }
+  }
+  target.contextTokens = addition.contextTokens || target.contextTokens;
+}
+
+// src/runner.ts
+var KILL_GRACE_MS = 5e3;
+var MAX_RECENT_ACTIVITY_ITEMS = 10;
+var MAX_RECENT_ACTIVITY_BYTES = 8 * 1024;
+var MAX_RECENT_ACTIVITY_ARGUMENT_BYTES = 1024;
+function boundMessageText(message, maxBytes) {
+  const originalBytes = Buffer.byteLength(JSON.stringify(message), "utf8");
+  if (Number.isSafeInteger(maxBytes) && maxBytes >= 0 && originalBytes <= maxBytes) {
+    return { message, bytes: originalBytes, truncated: false };
+  }
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) return { bytes: 0, truncated: true };
+  const content = [];
+  const bounded = () => ({ ...message, content });
+  const fits = () => Buffer.byteLength(JSON.stringify(bounded()), "utf8") <= maxBytes;
+  const addText = (text, prepend = false) => {
+    if (!text.trim()) return;
+    const part = { type: "text", text: "" };
+    if (prepend) content.unshift(part);
+    else content.push(part);
+    if (!fits()) {
+      content.splice(content.indexOf(part), 1);
+      return;
+    }
+    let low = 0;
+    let high = Buffer.byteLength(text, "utf8");
+    while (low < high) {
+      const middle = Math.ceil((low + high) / 2);
+      part.text = truncateUtf8(text, middle).text;
+      if (fits()) low = middle;
+      else high = middle - 1;
+    }
+    part.text = truncateUtf8(text, low).text;
+    if (!part.text.trim()) content.splice(content.indexOf(part), 1);
+  };
+  const addToolCall = (part) => {
+    const toolCall = {
+      type: "toolCall",
+      id: part.id,
+      name: part.name,
+      arguments: part.arguments
+    };
+    content.unshift(toolCall);
+    if (fits()) return;
+    const arguments_ = {};
+    for (const key of ["command", "path", "file_path", "pattern", "url"]) {
+      const value = part.arguments[key];
+      if (typeof value === "string") arguments_[key] = truncateUtf8(value, 256).text;
+    }
+    toolCall.arguments = arguments_;
+    if (fits()) return;
+    toolCall.arguments = {};
+    if (!fits()) content.shift();
+  };
+  if (message.role === "assistant") {
+    for (let index = message.content.length - 1; index >= 0; index--) {
+      const part = message.content[index];
+      if (part.type === "text") addText(part.text, true);
+      else if (part.type === "toolCall") addToolCall(part);
+    }
+  } else {
+    for (const part of message.content) {
+      if (typeof part === "object" && part && part.type === "text") addText(part.text);
+    }
+  }
+  if (content.length === 0) return { bytes: 0, truncated: true };
+  const result = bounded();
+  const bytes = Buffer.byteLength(JSON.stringify(result), "utf8");
+  return { message: result, bytes, truncated: true };
+}
+function compactRecentActivityArguments(args) {
+  if (Buffer.byteLength(JSON.stringify(args), "utf8") <= MAX_RECENT_ACTIVITY_ARGUMENT_BYTES)
+    return args;
+  const compact = {};
+  for (const key of ["command", "path", "file_path", "pattern", "url", "selector"]) {
+    const value = args[key];
+    if (typeof value === "string") compact[key] = truncateUtf8(value, 256).text;
+    else if (typeof value === "number" || typeof value === "boolean") compact[key] = value;
+  }
+  return compact;
+}
+function appendRecentActivity(result, message) {
+  if (message.role !== "assistant") return;
+  const append = (item) => {
+    result.recentActivity ??= [];
+    result.recentActivityTotal = (result.recentActivityTotal ?? 0) + 1;
+    result.recentActivity.push(item);
+    if (result.recentActivity.length > MAX_RECENT_ACTIVITY_ITEMS) {
+      result.recentActivity.splice(0, result.recentActivity.length - MAX_RECENT_ACTIVITY_ITEMS);
+    }
+    while (Buffer.byteLength(JSON.stringify(result.recentActivity), "utf8") > MAX_RECENT_ACTIVITY_BYTES) {
+      result.recentActivity.shift();
+    }
+  };
+  for (const part of message.content) {
+    if (part.type === "text") {
+      const text = part.text.trim();
+      if (text) append({ type: "text", text: truncateUtf8(text, 1024).text });
+    } else if (part.type === "toolCall") {
+      append({
+        type: "toolCall",
+        name: part.name,
+        args: compactRecentActivityArguments(part.arguments)
+      });
+    }
+  }
+}
+function buildFanInContext(results, maxBytes = DEFAULT_MAX_CONTEXT_BYTES) {
+  const text = results.map((result, index) => {
+    const failed = isResultError(result);
+    const status = result.exitCode === -1 ? "running" : failed ? "failed" : "completed";
+    const output = getResultFinalOutput(result);
+    const error = result.errorMessage || result.stderr.trim();
+    const resultText = failed ? `${error ? "Error" : output ? "Partial output" : "Error"}:
+${formatResultFailure(result)}` : result.structuredResult ? `Structured result:
+${JSON.stringify(result.structuredResult)}` : output ? `Output:
+${output}` : "Output: (no output)";
+    return [
+      `## Result ${index + 1}: ${result.agent} (${status})`,
+      `Task: ${result.task}`,
+      resultText
+    ].join("\n\n");
+  }).join("\n\n---\n\n");
+  return truncateUtf8(text, maxBytes).text;
+}
+async function mapWithConcurrencyLimit(items, concurrency, fn, signal, onSkipped) {
+  if (items.length === 0) return [];
+  const limit = Math.max(1, Math.min(concurrency, items.length));
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  const workers = new Array(limit).fill(null).map(async () => {
+    while (true) {
+      const current = nextIndex++;
+      if (current >= items.length) return;
+      if (signal?.aborted && onSkipped) {
+        results[current] = onSkipped(items[current], current);
+        continue;
+      }
+      results[current] = await fn(items[current], current);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+async function writePromptToTempFile(agentName, prompt) {
+  const tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "pi-subagent-"));
+  const safeName = agentName.replace(/[^\w.-]+/g, "_");
+  const filePath = path.join(tmpDir, `prompt-${safeName}.md`);
+  await withFileMutationQueue(filePath, async () => {
+    await fs.promises.writeFile(filePath, prompt, { encoding: "utf-8", mode: 384 });
+  });
+  return { dir: tmpDir, filePath };
+}
+function signalProcess(proc, signal) {
+  if (process.platform !== "win32" && proc.pid) {
+    try {
+      process.kill(-proc.pid, signal);
+      return;
+    } catch {
+    }
+  }
+  try {
+    proc.kill(signal);
+  } catch {
+  }
+}
+function terminateProcess(proc, graceMs = KILL_GRACE_MS) {
+  const leaderExited = proc.exitCode !== null || proc.signalCode !== null;
+  const capturedOutputClosed = [proc.stdout, proc.stderr].every(
+    (stream) => !stream || stream.readableEnded || stream.destroyed
+  );
+  let closed = leaderExited && capturedOutputClosed;
+  const onClose = () => {
+    closed = true;
+  };
+  proc.once("close", onClose);
+  if (!closed) signalProcess(proc, "SIGTERM");
+  const escalation = setTimeout(() => {
+    if (!closed) signalProcess(proc, "SIGKILL");
+  }, graceMs);
+  escalation.unref();
+  return () => {
+    clearTimeout(escalation);
+    proc.off("close", onClose);
+  };
+}
+async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, thinkingLevel, timeoutMs, onUpdate, makeDetails, invocationOverride, launchPolicy) {
+  const agent = agents.find((a) => a.name === agentName);
+  if (!agent) {
+    const available = agents.map((a) => `"${a.name}"`).join(", ") || "none";
+    return {
+      agent: agentName,
+      agentSource: "unknown",
+      task,
+      exitCode: 1,
+      messages: [],
+      stderr: `Unknown agent: "${agentName}". Available agents: ${available}.`,
+      usage: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        cost: 0,
+        contextTokens: 0,
+        turns: 0
+      },
+      thinkingLevel,
+      step,
+      finalOutput: ""
+    };
+  }
+  const temporaryPrompts = [];
+  let tmpPromptPath = null;
+  let baseSystemPromptPath = null;
+  let latestAssistantOutput = "";
+  let terminalAssistantOutput;
+  const progressJournal = new TimeoutProgressJournal();
+  const currentResult = {
+    agent: agentName,
+    agentSource: agent.source,
+    task: launchPolicy?.displayTask ?? task,
+    exitCode: 0,
+    messages: [],
+    stderr: "",
+    usage: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      cost: 0,
+      contextTokens: 0,
+      turns: 0
+    },
+    model: agent.model ?? void 0,
+    thinkingLevel,
+    step,
+    timeoutMs,
+    contract: launchPolicy?.contract,
+    resultFormat: launchPolicy?.resultFormat,
+    executionPlan: launchPolicy?.executionPlan,
+    capabilityGrant: launchPolicy?.capabilityGrant
+  };
+  const selectedAssistantOutput = () => terminalAssistantOutput !== void 0 ? terminalAssistantOutput : latestAssistantOutput || getFinalOutput(currentResult.messages);
+  const setErrorMessage = (message) => {
+    const bounded = truncateUtf8(message, DEFAULT_MAX_STDERR_BYTES);
+    currentResult.errorMessage = bounded.text;
+    currentResult.truncated ||= bounded.truncated;
+    return bounded.text;
+  };
+  const emitUpdate = () => {
+    const latest = truncateUtf8(selectedAssistantOutput(), DEFAULT_MAX_OUTPUT_BYTES);
+    currentResult.finalOutput = latest.text;
+    currentResult.truncated ||= latest.truncated;
+    if (onUpdate) {
+      onUpdate({
+        content: [{ type: "text", text: currentResult.finalOutput || "(running...)" }],
+        details: makeDetails([currentResult])
+      });
+    }
+  };
+  try {
+    const effectiveCwd = cwd ?? defaultCwd;
+    try {
+      if (!fs.statSync(effectiveCwd).isDirectory()) throw new Error("not a directory");
+    } catch (error) {
+      currentResult.exitCode = 1;
+      currentResult.stopReason = "error";
+      const reason = error instanceof Error ? error.message : String(error);
+      currentResult.stderr = setErrorMessage(`Invalid subagent cwd: ${effectiveCwd} (${reason})`);
+      return currentResult;
+    }
+    if (signal?.aborted) {
+      currentResult.exitCode = 130;
+      currentResult.aborted = true;
+      currentResult.stopReason = "aborted";
+      setErrorMessage("Subagent was aborted before start");
+      return currentResult;
+    }
+    if (!Number.isFinite(timeoutMs) || timeoutMs < 1 || timeoutMs > MAX_SUBAGENT_TIMEOUT_MS) {
+      currentResult.exitCode = 1;
+      currentResult.stopReason = "error";
+      setErrorMessage(
+        `Invalid subagent timeout: expected 1-${MAX_SUBAGENT_TIMEOUT_MS}ms, received ${timeoutMs}`
+      );
+      return currentResult;
+    }
+    if (launchPolicy?.baseSystemPrompt?.trim()) {
+      const tmp = await writePromptToTempFile(`${agent.name}-base`, launchPolicy.baseSystemPrompt);
+      temporaryPrompts.push(tmp);
+      baseSystemPromptPath = tmp.filePath;
+    }
+    if (agent.systemPrompt.trim()) {
+      const tmp = await writePromptToTempFile(agent.name, agent.systemPrompt);
+      temporaryPrompts.push(tmp);
+      tmpPromptPath = tmp.filePath;
+    }
+    if (signal?.aborted) {
+      currentResult.exitCode = 130;
+      currentResult.aborted = true;
+      currentResult.stopReason = "aborted";
+      setErrorMessage("Subagent was aborted before launch");
+      return currentResult;
+    }
+    const effectiveTools = launchPolicy && Object.hasOwn(launchPolicy, "tools") ? launchPolicy.tools : agent.tools;
+    const selectedTools = effectiveTools === void 0 ? void 0 : [.../* @__PURE__ */ new Set([...effectiveTools, ...launchPolicy?.additionalTools ?? []])];
+    const args = buildPiArgs({
+      model: agent.model,
+      thinkingLevel,
+      tools: selectedTools,
+      disableExtensions: launchPolicy?.disableExtensions,
+      disableSkills: launchPolicy?.disableSkills,
+      disablePromptTemplates: launchPolicy?.disablePromptTemplates,
+      disableContextFiles: launchPolicy?.disableContextFiles,
+      projectTrust: launchPolicy?.projectTrust,
+      baseSystemPromptPath: baseSystemPromptPath ?? void 0,
+      appendSystemPromptPaths: launchPolicy?.appendSystemPromptPaths,
+      extensionPaths: launchPolicy?.extensionPaths,
+      systemPromptPath: tmpPromptPath ?? void 0,
+      task
+    });
+    let invocation;
+    try {
+      invocation = invocationOverride ? {
+        command: invocationOverride.command,
+        args: [...invocationOverride.argsPrefix ?? [], ...args]
+      } : resolvePiInvocation(args);
+    } catch (error) {
+      currentResult.launchFailed = true;
+      currentResult.exitCode = 1;
+      currentResult.stderr = setErrorMessage(
+        error instanceof Error ? error.message : String(error)
+      );
+      return currentResult;
+    }
+    let wasAborted = false;
+    let timedOut = false;
+    let budgetStop;
+    const exitCode = await new Promise((resolve) => {
+      let settled = false;
+      let cleanupTermination;
+      let timeout;
+      let terminationDeadline;
+      let abortHandler;
+      let budgetMonitor;
+      const finish = (code) => {
+        if (settled) return;
+        settled = true;
+        if (timeout) clearTimeout(timeout);
+        if (terminationDeadline) clearTimeout(terminationDeadline);
+        cleanupTermination?.();
+        budgetMonitor?.dispose();
+        if (signal && abortHandler) signal.removeEventListener("abort", abortHandler);
+        resolve(code);
+      };
+      let proc;
+      try {
+        proc = spawn(invocation.command, invocation.args, {
+          cwd: effectiveCwd,
+          detached: process.platform !== "win32",
+          shell: false,
+          stdio: ["ignore", "pipe", "pipe"],
+          env: {
+            ...process.env,
+            ...launchPolicy?.env,
+            PI_SUBAGENT_DEPTH: String(
+              (Number.parseInt(process.env.PI_SUBAGENT_DEPTH ?? "0", 10) || 0) + 1
+            )
+          }
+        });
+      } catch (error) {
+        currentResult.launchFailed = true;
+        currentResult.stderr = setErrorMessage(
+          error instanceof Error ? error.message : String(error)
+        );
+        finish(1);
+        return;
+      }
+      const addMessage = (msg) => {
+        const boundedMessage = boundMessageText(msg, DEFAULT_MAX_OUTPUT_BYTES - 2);
+        currentResult.truncated ||= boundedMessage.truncated;
+        if (!boundedMessage.message) return;
+        while (currentResult.messages.length >= DEFAULT_MAX_MESSAGES || Buffer.byteLength(
+          JSON.stringify([...currentResult.messages, boundedMessage.message]),
+          "utf8"
+        ) > DEFAULT_MAX_OUTPUT_BYTES) {
+          const removed = currentResult.messages.shift();
+          if (!removed) break;
+          currentResult.truncated = true;
+        }
+        if (Buffer.byteLength(
+          JSON.stringify([...currentResult.messages, boundedMessage.message]),
+          "utf8"
+        ) > DEFAULT_MAX_OUTPUT_BYTES) {
+          currentResult.truncated = true;
+          return;
+        }
+        currentResult.messages.push(boundedMessage.message);
+      };
+      const processEvent = (raw) => {
+        if (!raw || typeof raw !== "object") return;
+        const event = raw;
+        if (event.type === "message_end" && event.message) {
+          const msg = event.message;
+          journalMessages(progressJournal, [msg]);
+          if (msg.role === "assistant") {
+            const output = truncateUtf8(getFinalOutput([msg]), DEFAULT_MAX_OUTPUT_BYTES);
+            currentResult.truncated ||= output.truncated;
+            if (output.text) latestAssistantOutput = output.text;
+            if (msg.stopReason === "stop" || msg.stopReason === "length") {
+              terminalAssistantOutput = output.text;
+            }
+          }
+          appendRecentActivity(currentResult, msg);
+          addMessage(msg);
+          if (msg.role === "assistant") {
+            currentResult.usage.turns++;
+            budgetMonitor?.recordToolCalls(
+              msg.content.filter((part) => part.type === "toolCall").length
+            );
+            budgetMonitor?.recordAssistantTurn(msg.stopReason);
+            const usage = msg.usage;
+            if (usage && typeof usage === "object") {
+              const input = protocolUsageCount(usage.input);
+              const output = protocolUsageCount(usage.output);
+              const cacheRead = protocolUsageCount(usage.cacheRead);
+              const cacheWrite = protocolUsageCount(usage.cacheWrite);
+              const reportedTotal = protocolUsageCount(usage.totalTokens);
+              const turnTotal = reportedTotal || addUsageValue(addUsageValue(input, output), addUsageValue(cacheRead, cacheWrite));
+              const cost = usage.cost && typeof usage.cost === "object" ? usage.cost : void 0;
+              currentResult.usage.input = addUsageValue(currentResult.usage.input, input);
+              currentResult.usage.output = addUsageValue(currentResult.usage.output, output);
+              currentResult.usage.cacheRead = addUsageValue(
+                currentResult.usage.cacheRead,
+                cacheRead
+              );
+              currentResult.usage.cacheWrite = addUsageValue(
+                currentResult.usage.cacheWrite,
+                cacheWrite
+              );
+              currentResult.usage.cost = addUsageValue(
+                currentResult.usage.cost,
+                protocolUsageCost(cost?.total)
+              );
+              currentResult.usage.costInput = addUsageValue(
+                currentResult.usage.costInput ?? 0,
+                protocolUsageCost(cost?.input)
+              );
+              currentResult.usage.costOutput = addUsageValue(
+                currentResult.usage.costOutput ?? 0,
+                protocolUsageCost(cost?.output)
+              );
+              currentResult.usage.costCacheRead = addUsageValue(
+                currentResult.usage.costCacheRead ?? 0,
+                protocolUsageCost(cost?.cacheRead)
+              );
+              currentResult.usage.costCacheWrite = addUsageValue(
+                currentResult.usage.costCacheWrite ?? 0,
+                protocolUsageCost(cost?.cacheWrite)
+              );
+              currentResult.usage.totalTokens = addUsageValue(
+                currentResult.usage.totalTokens ?? 0,
+                turnTotal
+              );
+              currentResult.usage.contextTokens = turnTotal;
+            }
+            if (typeof msg.provider === "string") currentResult.actualProvider = msg.provider;
+            const actualModel = typeof msg.responseModel === "string" ? msg.responseModel : typeof msg.model === "string" ? msg.model : void 0;
+            if (actualModel) currentResult.actualModel = actualModel;
+            if (typeof msg.stopReason === "string") currentResult.stopReason = msg.stopReason;
+            if (typeof msg.errorMessage === "string") setErrorMessage(msg.errorMessage);
+          }
+          emitUpdate();
+        } else if (event.type === "tool_result_end" && event.message) {
+          journalMessages(progressJournal, [event.message]);
+          budgetMonitor?.recordActivity();
+          addMessage(event.message);
+          emitUpdate();
+        }
+      };
+      const decoder = new JsonLineDecoder({
+        onValue: processEvent,
+        onMalformed: () => {
+          currentResult.malformedEvents = (currentResult.malformedEvents ?? 0) + 1;
+        },
+        onOversized: () => {
+          currentResult.truncated = true;
+        }
+      });
+      const beginTermination = (exitCode2) => {
+        if (cleanupTermination || settled) return;
+        cleanupTermination = terminateProcess(proc);
+        terminationDeadline = setTimeout(() => {
+          decoder.finish();
+          proc.stdin?.destroy();
+          proc.stdout?.destroy();
+          proc.stderr?.destroy();
+          finish(exitCode2);
+        }, KILL_GRACE_MS + 1e3);
+      };
+      const stopForBudget = (stop) => {
+        if (budgetStop || settled || wasAborted) return;
+        budgetStop = stop;
+        timedOut = stop.reason.endsWith("timeout");
+        currentResult.timedOut = timedOut || void 0;
+        currentResult.stopReason = timedOut ? "timeout" : "limit";
+        const message = formatTurnTerminationMessage(stop.reason, stop.limit);
+        setErrorMessage(message);
+        const bounded = appendBounded(
+          currentResult.stderr,
+          `
+${message}.`,
+          DEFAULT_MAX_STDERR_BYTES
+        );
+        currentResult.stderr = bounded.text;
+        currentResult.truncated ||= bounded.truncated;
+        emitUpdate();
+        beginTermination(124);
+      };
+      budgetMonitor = new TurnBudgetMonitor({
+        ...launchPolicy?.turnLimits,
+        onExceeded: stopForBudget
+      });
+      proc.once("spawn", () => {
+        currentResult.processStarted = true;
+        if (settled || budgetStop || wasAborted) return;
+        timeout = setTimeout(() => {
+          stopForBudget({
+            reason: launchPolicy?.workTimeoutReason ?? "work_timeout",
+            limit: launchPolicy?.workTimeoutReportLimit ?? timeoutMs
+          });
+        }, timeoutMs);
+        timeout.unref();
+      });
+      proc.stdout?.on("data", (data) => decoder.push(data));
+      proc.stderr?.on("data", (data) => {
+        const bounded = appendBounded(
+          currentResult.stderr,
+          data.toString(),
+          DEFAULT_MAX_STDERR_BYTES
+        );
+        currentResult.stderr = bounded.text;
+        currentResult.truncated ||= bounded.truncated;
+      });
+      proc.on("close", (code) => {
+        decoder.finish();
+        finish(budgetStop ? 124 : wasAborted ? 130 : code ?? 0);
+      });
+      proc.on("error", (error) => {
+        currentResult.launchFailed = currentResult.processStarted ? void 0 : true;
+        const message = setErrorMessage(error.message);
+        const bounded = appendBounded(
+          currentResult.stderr,
+          `${currentResult.stderr ? "\n" : ""}${message}`,
+          DEFAULT_MAX_STDERR_BYTES
+        );
+        currentResult.stderr = bounded.text;
+        currentResult.truncated ||= bounded.truncated;
+        if (currentResult.processStarted) beginTermination(1);
+        else finish(1);
+      });
+      if (signal) {
+        abortHandler = () => {
+          if (budgetStop || settled) return;
+          wasAborted = true;
+          currentResult.aborted = true;
+          currentResult.stopReason = "aborted";
+          setErrorMessage("Subagent was aborted");
+          beginTermination(130);
+        };
+        if (signal.aborted) abortHandler();
+        else signal.addEventListener("abort", abortHandler, { once: true });
+      }
+    });
+    if (signal?.aborted && budgetStop) {
+      budgetStop = void 0;
+      timedOut = false;
+      currentResult.timedOut = void 0;
+      currentResult.aborted = true;
+      currentResult.stopReason = "aborted";
+      setErrorMessage("Subagent was aborted");
+    }
+    currentResult.exitCode = currentResult.aborted ? 130 : exitCode;
+    const final = truncateUtf8(selectedAssistantOutput(), DEFAULT_MAX_OUTPUT_BYTES);
+    currentResult.finalOutput = final.text;
+    currentResult.truncated ||= final.truncated;
+    if (budgetStop) {
+      currentResult.partialOutput = currentResult.finalOutput || void 0;
+      currentResult.termination = {
+        version: TURN_TERMINATION_VERSION,
+        reason: budgetStop.reason,
+        limit: budgetStop.limit,
+        checkpoint: progressJournal.checkpoint(task, currentResult.partialOutput),
+        finalization: { attempted: false, status: "skipped", durationMs: 0 }
+      };
+    }
+    const remainingFinalizationMs = launchPolicy?.orchestrationDeadlineAt ? Math.floor(launchPolicy.orchestrationDeadlineAt - Date.now()) : void 0;
+    if (budgetStop && budgetStop.reason !== "orchestration_timeout" && launchPolicy?.finalizeOnTimeout !== false && !signal?.aborted && (remainingFinalizationMs === void 0 || remainingFinalizationMs > 0)) {
+      const finalizationStartedAt = Date.now();
+      const requestedFinalizationMs = resolveTimeoutFinalizationMs(
+        timeoutMs,
+        launchPolicy?.timeoutFinalizationMs
+      );
+      const finalizationMs = Math.min(
+        requestedFinalizationMs,
+        remainingFinalizationMs ?? requestedFinalizationMs
+      );
+      const summary = await runSingleAgent(
+        defaultCwd,
+        agents,
+        agentName,
+        buildTimeoutFinalizationPrompt({
+          task,
+          partialOutput: currentResult.partialOutput,
+          recentActivity: currentResult.recentActivity,
+          checkpoint: currentResult.termination?.checkpoint,
+          terminationReason: budgetStop.reason,
+          resultFormat: launchPolicy?.timeoutResultFormat
+        }),
+        cwd,
+        step,
+        signal,
+        thinkingLevel,
+        finalizationMs,
+        void 0,
+        makeDetails,
+        invocationOverride,
+        {
+          ...launchPolicy,
+          tools: [],
+          disableExtensions: true,
+          disableSkills: true,
+          disablePromptTemplates: true,
+          disableContextFiles: true,
+          appendSystemPromptPaths: void 0,
+          finalizeOnTimeout: false,
+          turnLimits: void 0,
+          workTimeoutReason: "work_timeout",
+          workTimeoutReportLimit: finalizationMs,
+          orchestrationDeadlineAt: void 0
+        }
+      );
+      mergeUsageStats(currentResult.usage, summary.usage);
+      const summaryOutput = getResultFinalOutput(summary).trim();
+      if (summary.exitCode === 0 && summaryOutput) {
+        currentResult.timeoutSummary = summaryOutput;
+        currentResult.finalOutput = summaryOutput;
+        if (currentResult.termination) {
+          currentResult.termination.finalization = {
+            attempted: true,
+            status: "completed",
+            durationMs: Date.now() - finalizationStartedAt
+          };
+        }
+      } else {
+        currentResult.timeoutSummaryError = summary.errorMessage || summary.stderr.trim() || "Summary produced no final text";
+        if (currentResult.termination) {
+          currentResult.termination.finalization = {
+            attempted: true,
+            status: summary.timedOut ? "timed_out" : "failed",
+            durationMs: Date.now() - finalizationStartedAt,
+            error: currentResult.timeoutSummaryError
+          };
+        }
+      }
+      currentResult.truncated ||= summary.truncated;
+    }
+    if (currentResult.termination && !currentResult.finalOutput.trim()) {
+      currentResult.finalOutput = formatTimeoutCheckpoint(currentResult.termination.checkpoint);
+    }
+    if (currentResult.exitCode === 0 && launchPolicy?.resultFormat !== void 0) {
+      currentResult.structuredResult = parseAnyStructuredSubagentResult(
+        currentResult.finalOutput ?? "",
+        launchPolicy.resultFormat
+      );
+      currentResult.resultContractInvalid = launchPolicy.resultFormat !== "text" && currentResult.structuredResult === void 0;
+      if (currentResult.structuredResult?.version === "pi-subagents:result:v2" && launchPolicy.executionPlan) {
+        currentResult.structuredResult.provenance = {
+          ...currentResult.structuredResult.provenance,
+          ...launchPolicy.executionPlan.taskId ? { taskId: launchPolicy.executionPlan.taskId } : {},
+          taskGeneration: launchPolicy.executionPlan.taskGeneration,
+          executionPlanId: launchPolicy.executionPlan.id,
+          cancellationLineage: [...launchPolicy.executionPlan.cancellationLineage]
+        };
+      }
+      if (currentResult.structuredResult?.version === "pi-subagents:result:v2") {
+        currentResult.outcome = classifyStructuredOutcome(
+          currentResult.structuredResult.status,
+          currentResult.structuredResult.reasonCode
+        );
+      } else if (currentResult.resultContractInvalid) {
+        currentResult.outcome = classifyStructuredOutcome(
+          "contract-invalid",
+          "malformed-structured-result"
+        );
+      }
+    }
+    if (currentResult.exitCode === 0 && currentResult.stopReason !== "error" && (currentResult.stopReason === "toolUse" || !currentResult.finalOutput.trim())) {
+      currentResult.exitCode = 1;
+      currentResult.stopReason = "error";
+      setErrorMessage("Subagent completed without final text");
+    }
+    if (currentResult.capabilityGrant?.state === "active") {
+      currentResult.capabilityGrant = revokeCapabilityGrant(
+        currentResult.capabilityGrant,
+        "turn-settled",
+        Date.now()
+      );
+    }
+    currentResult.policy = {
+      inherited: ["environment"],
+      overridden: [
+        "cwd",
+        ...agent.model ? ["model"] : [],
+        ...thinkingLevel ? ["thinkingLevel"] : [],
+        ...effectiveTools !== void 0 ? ["tools"] : [],
+        ...launchPolicy?.disableExtensions ? ["extensions"] : [],
+        ...launchPolicy?.disableSkills ? ["skills"] : [],
+        ...launchPolicy?.disablePromptTemplates ? ["promptTemplates"] : [],
+        ...launchPolicy?.disableContextFiles ? ["contextFiles"] : []
+      ],
+      unsupported: ["approvalPolicy", "sandboxProfile", "providerHeaders"]
+    };
+    return currentResult;
+  } finally {
+    for (const temporary of temporaryPrompts.reverse()) {
+      try {
+        fs.unlinkSync(temporary.filePath);
+      } catch {
+      }
+      try {
+        fs.rmdirSync(temporary.dir);
+      } catch {
+      }
+    }
+  }
+}
+
+export {
+  JsonLineDecoder,
+  buildFanInContext,
+  mapWithConcurrencyLimit,
+  terminateProcess,
+  runSingleAgent
+};
+//# sourceMappingURL=chunk-DQMN4OYM.ts.map