privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-7UOG7POX.mjs

@@ -0,0 +1,1524 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  sanitizeBinaryOutput
+} from "./c-6ZO2SADQ.mjs";
+import {
+  highlightCode,
+  keyHint
+} from "./c-CRBXNKFO.mjs";
+import {
+  getDocsPath,
+  resolvePath
+} from "./c-PTN4S6G2.mjs";
+import {
+  DEFAULT_MAX_AGENT_RETRY_DELAY_MS
+} from "./c-BHNIF2AR.mjs";
+import {
+  Container,
+  Spacer,
+  Text,
+  getCapabilities,
+  getImageDimensions,
+  hyperlink,
+  imageFallback,
+  truncateToWidth
+} from "./c-EQBKXWNX.mjs";
+import {
+  typebox_exports
+} from "./c-RQJJ26T4.mjs";
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/@earendil-works/pi-coding-agent/dist/utils/output-files.js
+import { randomBytes } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+var OUTPUT_FILE_MODE = 384;
+function createOutputFilePath(prefix, extension) {
+  return join(tmpdir(), `${prefix}-${randomBytes(8).toString("hex")}${extension}`);
+}
+__name(createOutputFilePath, "createOutputFilePath");
+async function writeOutputFile(prefix, extension, data) {
+  const path = createOutputFilePath(prefix, extension);
+  await writeFile(path, data, { mode: OUTPUT_FILE_MODE, flag: "wx" });
+  return path;
+}
+__name(writeOutputFile, "writeOutputFile");
+function createOutputFileStream(prefix, extension) {
+  const path = createOutputFilePath(prefix, extension);
+  return { path, stream: createWriteStream(path, { mode: OUTPUT_FILE_MODE, flags: "wx" }) };
+}
+__name(createOutputFileStream, "createOutputFileStream");
+
+// node_modules/@earendil-works/pi-coding-agent/dist/core/tools/truncate.js
+var DEFAULT_MAX_LINES = 2e3;
+var DEFAULT_MAX_BYTES = 50 * 1024;
+var GREP_MAX_LINE_LENGTH = 500;
+function splitLinesForCounting(content) {
+  if (content.length === 0) {
+    return [];
+  }
+  const lines = content.split("\n");
+  if (content.endsWith("\n")) {
+    lines.pop();
+  }
+  return lines;
+}
+__name(splitLinesForCounting, "splitLinesForCounting");
+function formatSize(bytes) {
+  if (bytes < 1024) {
+    return `${bytes}B`;
+  } else if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)}KB`;
+  } else {
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+  }
+}
+__name(formatSize, "formatSize");
+function truncateHead(content, options = {}) {
+  const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+  const totalBytes = Buffer.byteLength(content, "utf-8");
+  const lines = splitLinesForCounting(content);
+  const totalLines = lines.length;
+  if (totalLines <= maxLines && totalBytes <= maxBytes) {
+    return {
+      content,
+      truncated: false,
+      truncatedBy: null,
+      totalLines,
+      totalBytes,
+      outputLines: totalLines,
+      outputBytes: totalBytes,
+      lastLinePartial: false,
+      firstLineExceedsLimit: false,
+      maxLines,
+      maxBytes
+    };
+  }
+  const firstLineBytes = Buffer.byteLength(lines[0], "utf-8");
+  if (firstLineBytes > maxBytes) {
+    return {
+      content: "",
+      truncated: true,
+      truncatedBy: "bytes",
+      totalLines,
+      totalBytes,
+      outputLines: 0,
+      outputBytes: 0,
+      lastLinePartial: false,
+      firstLineExceedsLimit: true,
+      maxLines,
+      maxBytes
+    };
+  }
+  const outputLinesArr = [];
+  let outputBytesCount = 0;
+  let truncatedBy = "lines";
+  for (let i = 0; i < lines.length && i < maxLines; i++) {
+    const line = lines[i];
+    const lineBytes = Buffer.byteLength(line, "utf-8") + (i > 0 ? 1 : 0);
+    if (outputBytesCount + lineBytes > maxBytes) {
+      truncatedBy = "bytes";
+      break;
+    }
+    outputLinesArr.push(line);
+    outputBytesCount += lineBytes;
+  }
+  if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) {
+    truncatedBy = "lines";
+  }
+  const outputContent = outputLinesArr.join("\n");
+  const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
+  return {
+    content: outputContent,
+    truncated: true,
+    truncatedBy,
+    totalLines,
+    totalBytes,
+    outputLines: outputLinesArr.length,
+    outputBytes: finalOutputBytes,
+    lastLinePartial: false,
+    firstLineExceedsLimit: false,
+    maxLines,
+    maxBytes
+  };
+}
+__name(truncateHead, "truncateHead");
+function truncateTail(content, options = {}) {
+  const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+  const totalBytes = Buffer.byteLength(content, "utf-8");
+  const lines = splitLinesForCounting(content);
+  const totalLines = lines.length;
+  if (totalLines <= maxLines && totalBytes <= maxBytes) {
+    return {
+      content,
+      truncated: false,
+      truncatedBy: null,
+      totalLines,
+      totalBytes,
+      outputLines: totalLines,
+      outputBytes: totalBytes,
+      lastLinePartial: false,
+      firstLineExceedsLimit: false,
+      maxLines,
+      maxBytes
+    };
+  }
+  const outputLinesArr = [];
+  let outputBytesCount = 0;
+  let truncatedBy = "lines";
+  let lastLinePartial = false;
+  for (let i = lines.length - 1; i >= 0 && outputLinesArr.length < maxLines; i--) {
+    const line = lines[i];
+    const lineBytes = Buffer.byteLength(line, "utf-8") + (outputLinesArr.length > 0 ? 1 : 0);
+    if (outputBytesCount + lineBytes > maxBytes) {
+      truncatedBy = "bytes";
+      if (outputLinesArr.length === 0) {
+        const truncatedLine = truncateStringToBytesFromEnd(line, maxBytes);
+        outputLinesArr.unshift(truncatedLine);
+        outputBytesCount = Buffer.byteLength(truncatedLine, "utf-8");
+        lastLinePartial = true;
+      }
+      break;
+    }
+    outputLinesArr.unshift(line);
+    outputBytesCount += lineBytes;
+  }
+  if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) {
+    truncatedBy = "lines";
+  }
+  const outputContent = outputLinesArr.join("\n");
+  const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
+  return {
+    content: outputContent,
+    truncated: true,
+    truncatedBy,
+    totalLines,
+    totalBytes,
+    outputLines: outputLinesArr.length,
+    outputBytes: finalOutputBytes,
+    lastLinePartial,
+    firstLineExceedsLimit: false,
+    maxLines,
+    maxBytes
+  };
+}
+__name(truncateTail, "truncateTail");
+function truncateStringToBytesFromEnd(str2, maxBytes) {
+  const buf = Buffer.from(str2, "utf-8");
+  if (buf.length <= maxBytes) {
+    return str2;
+  }
+  let start = buf.length - maxBytes;
+  while (start < buf.length && (buf[start] & 192) === 128) {
+    start++;
+  }
+  return buf.slice(start).toString("utf-8");
+}
+__name(truncateStringToBytesFromEnd, "truncateStringToBytesFromEnd");
+function truncateLine(line, maxChars = GREP_MAX_LINE_LENGTH) {
+  if (line.length <= maxChars) {
+    return { text: line, wasTruncated: false };
+  }
+  return { text: `${line.slice(0, maxChars)}... [truncated]`, wasTruncated: true };
+}
+__name(truncateLine, "truncateLine");
+function truncateMiddle(content, maxBytes) {
+  const buf = Buffer.from(content, "utf-8");
+  const totalLines = splitLinesForCounting(content).length;
+  if (buf.length <= maxBytes) {
+    return { content, truncated: false, removedChars: 0, totalBytes: buf.length, totalLines };
+  }
+  const isBoundary = /* @__PURE__ */ __name((index) => index >= buf.length || (buf[index] & 192) !== 128, "isBoundary");
+  let headEnd = Math.floor(maxBytes / 2);
+  while (headEnd > 0 && !isBoundary(headEnd))
+    headEnd--;
+  let tailStart = buf.length - (maxBytes - Math.floor(maxBytes / 2));
+  while (tailStart < buf.length && !isBoundary(tailStart))
+    tailStart++;
+  const head = buf.subarray(0, headEnd).toString("utf-8");
+  const tail = buf.subarray(tailStart).toString("utf-8");
+  const removedChars = Array.from(buf.subarray(headEnd, tailStart).toString("utf-8")).length;
+  return {
+    content: `${head}\u2026${removedChars} chars truncated\u2026${tail}`,
+    truncated: true,
+    removedChars,
+    totalBytes: buf.length,
+    totalLines
+  };
+}
+__name(truncateMiddle, "truncateMiddle");
+
+// node_modules/@earendil-works/pi-coding-agent/dist/core/usage-totals.js
+function createUsageTotals() {
+  return {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    cost: 0
+  };
+}
+__name(createUsageTotals, "createUsageTotals");
+function addUsageToTotals(totals, usage) {
+  totals.input += usage.input;
+  totals.output += usage.output;
+  totals.cacheRead += usage.cacheRead;
+  totals.cacheWrite += usage.cacheWrite;
+  totals.cost += usage.cost.total;
+}
+__name(addUsageToTotals, "addUsageToTotals");
+function combineUsage(first, second) {
+  return {
+    input: first.input + second.input,
+    output: first.output + second.output,
+    cacheRead: first.cacheRead + second.cacheRead,
+    cacheWrite: first.cacheWrite + second.cacheWrite,
+    ...first.cacheWrite1h !== void 0 || second.cacheWrite1h !== void 0 ? { cacheWrite1h: (first.cacheWrite1h ?? 0) + (second.cacheWrite1h ?? 0) } : {},
+    ...first.reasoning !== void 0 || second.reasoning !== void 0 ? { reasoning: (first.reasoning ?? 0) + (second.reasoning ?? 0) } : {},
+    totalTokens: first.totalTokens + second.totalTokens,
+    cost: {
+      input: first.cost.input + second.cost.input,
+      output: first.cost.output + second.cost.output,
+      cacheRead: first.cost.cacheRead + second.cost.cacheRead,
+      cacheWrite: first.cost.cacheWrite + second.cost.cacheWrite,
+      total: first.cost.total + second.cost.total
+    }
+  };
+}
+__name(combineUsage, "combineUsage");
+function getUsageCostBreakdown(entries) {
+  const totalsByKey = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    let key;
+    let usage;
+    if (entry.type === "message" && entry.message.role === "assistant") {
+      key = `${entry.message.provider}/${entry.message.responseModel ?? entry.message.model}`;
+      usage = entry.message.usage;
+    } else if (entry.type === "usage") {
+      key = `${entry.provider}/${entry.model}`;
+      usage = entry.usage;
+    } else if (entry.type === "message" && entry.message.role === "toolResult" && entry.message.usage) {
+      key = "Tools/summaries";
+      usage = entry.message.usage;
+    } else if ((entry.type === "branch_summary" || entry.type === "compaction") && entry.usage) {
+      key = "Tools/summaries";
+      usage = entry.usage;
+    }
+    if (!key || !usage)
+      continue;
+    let totals = totalsByKey.get(key);
+    if (!totals) {
+      totals = createUsageTotals();
+      totalsByKey.set(key, totals);
+    }
+    addUsageToTotals(totals, usage);
+  }
+  return Array.from(totalsByKey, ([key, totals]) => ({
+    key,
+    cost: totals.cost,
+    tokens: totals.input + totals.output + totals.cacheRead + totals.cacheWrite
+  })).filter((entry) => entry.cost > 0 || entry.tokens > 0).sort((a, b) => b.cost - a.cost);
+}
+__name(getUsageCostBreakdown, "getUsageCostBreakdown");
+
+// node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/components/visual-truncate.js
+function truncateToVisualLines(text, maxVisualLines, width, paddingX = 0, keep = "end") {
+  if (!text) {
+    return { visualLines: [], skippedCount: 0 };
+  }
+  const tempText = new Text(text, paddingX, 0);
+  const allVisualLines = tempText.render(width);
+  if (allVisualLines.length <= maxVisualLines) {
+    return { visualLines: allVisualLines, skippedCount: 0 };
+  }
+  const truncatedLines = keep === "start" ? allVisualLines.slice(0, maxVisualLines) : allVisualLines.slice(-maxVisualLines);
+  const skippedCount = allVisualLines.length - maxVisualLines;
+  return { visualLines: truncatedLines, skippedCount };
+}
+__name(truncateToVisualLines, "truncateToVisualLines");
+var VisualLinePreview = class {
+  static {
+    __name(this, "VisualLinePreview");
+  }
+  options;
+  cachedWidth;
+  cachedLines;
+  constructor(options) {
+    this.options = options;
+  }
+  render(width) {
+    if (this.cachedLines === void 0 || this.cachedWidth !== width) {
+      const { text, maxVisualLines, keep, formatHint } = this.options;
+      const preview = truncateToVisualLines(text, maxVisualLines, width, 0, keep);
+      const lines = preview.visualLines;
+      if (preview.skippedCount > 0) {
+        const hint = truncateToWidth(formatHint(preview.skippedCount), width, "...");
+        this.cachedLines = keep === "start" ? [...lines, hint] : [hint, ...lines];
+      } else {
+        this.cachedLines = lines;
+      }
+      this.cachedWidth = width;
+    }
+    return this.cachedLines;
+  }
+  invalidate() {
+    this.cachedWidth = void 0;
+    this.cachedLines = void 0;
+  }
+};
+
+// node_modules/@earendil-works/pi-coding-agent/dist/core/tools/render-utils.js
+import * as os from "node:os";
+import { pathToFileURL } from "node:url";
+
+// node_modules/@earendil-works/pi-coding-agent/dist/utils/ansi.js
+var ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+var OSC_START = "\\u001B\\]";
+var CSI_START = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?";
+var CSI_FINAL = "[\\dA-PR-TZcf-nq-uy=><~]";
+var ansiRegex = new RegExp(`(?:${OSC_START}[\\s\\S]*?${ST})|${CSI_START}${CSI_FINAL}`, "g");
+var unfinishedAnsiAtEndRegex = new RegExp(`(?:${OSC_START}(?:[^\\u0007\\u009C\\u001B]|\\u001B(?!\\\\))*|${CSI_START})$`);
+var MAX_PENDING_ANSI_LENGTH = 256;
+function splitIncompleteAnsiSuffix(value) {
+  if (!value.includes("\x1B") && !value.includes("\x9B")) {
+    return { complete: value, pending: "" };
+  }
+  const windowStart = Math.max(0, value.length - MAX_PENDING_ANSI_LENGTH);
+  const match = unfinishedAnsiAtEndRegex.exec(value.slice(windowStart));
+  if (!match) {
+    return { complete: value, pending: "" };
+  }
+  const splitAt = windowStart + match.index;
+  return { complete: value.slice(0, splitAt), pending: value.slice(splitAt) };
+}
+__name(splitIncompleteAnsiSuffix, "splitIncompleteAnsiSuffix");
+function stripAnsi(value) {
+  if (typeof value !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof value}\``);
+  }
+  if (!value.includes("\x1B") && !value.includes("\x9B")) {
+    return value;
+  }
+  return value.replace(ansiRegex, "");
+}
+__name(stripAnsi, "stripAnsi");
+
+// node_modules/@earendil-works/pi-coding-agent/dist/core/tools/render-utils.js
+function shortenPath(path) {
+  if (typeof path !== "string")
+    return "";
+  const home = os.homedir();
+  if (path.startsWith(home)) {
+    return `~${path.slice(home.length)}`;
+  }
+  return path;
+}
+__name(shortenPath, "shortenPath");
+function linkPath(styledText, rawPath, cwd) {
+  if (!getCapabilities().hyperlinks)
+    return styledText;
+  const absolutePath = resolvePath(rawPath, cwd);
+  return hyperlink(styledText, pathToFileURL(absolutePath).href);
+}
+__name(linkPath, "linkPath");
+function str(value) {
+  if (typeof value === "string")
+    return value;
+  if (value == null)
+    return "";
+  return null;
+}
+__name(str, "str");
+function parseLineNumber(value) {
+  if (typeof value === "string" && value.trim() !== "")
+    value = Number(value);
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+__name(parseLineNumber, "parseLineNumber");
+function formatReadLineRange(offset, limit) {
+  if (offset == null && limit == null)
+    return "";
+  const start = offset == null ? 1 : parseLineNumber(offset);
+  if (start === void 0)
+    return "";
+  if (limit == null)
+    return `:${start}`;
+  const count = parseLineNumber(limit);
+  if (count === void 0)
+    return "";
+  const end = start + count - 1;
+  return `:${start}${end ? `-${end}` : ""}`;
+}
+__name(formatReadLineRange, "formatReadLineRange");
+function replaceTabs(text) {
+  return text.replace(/\t/g, "   ");
+}
+__name(replaceTabs, "replaceTabs");
+function normalizeDisplayText(text) {
+  return text.replace(/\r/g, "");
+}
+__name(normalizeDisplayText, "normalizeDisplayText");
+function getTextOutput(result, showImages) {
+  if (!result)
+    return "";
+  const textBlocks = result.content.filter((c) => c.type === "text");
+  const imageBlocks = result.content.filter((c) => c.type === "image");
+  let output = textBlocks.map((c) => sanitizeBinaryOutput(stripAnsi(c.text || "")).replace(/\r/g, "")).join("\n");
+  const caps = getCapabilities();
+  if (imageBlocks.length > 0 && (!caps.images || !showImages)) {
+    const imageIndicators = imageBlocks.map((img) => {
+      const mimeType = img.mimeType ?? "image/unknown";
+      const dims = img.data && img.mimeType ? getImageDimensions(img.data, img.mimeType) ?? void 0 : void 0;
+      return imageFallback(mimeType, dims);
+    }).join("\n");
+    output = output ? `${output}
+${imageIndicators}` : imageIndicators;
+  }
+  return output;
+}
+__name(getTextOutput, "getTextOutput");
+var COLLAPSED_ARGS_CHARS = 100;
+function formatToolCallWithArgs(title, args, theme, expanded) {
+  const header = theme.fg("toolTitle", theme.bold(title));
+  if (args == null)
+    return header;
+  const entries = typeof args === "object" && !Array.isArray(args) ? Object.entries(args) : [["args", args]];
+  if (entries.length === 0)
+    return header;
+  if (expanded) {
+    const lines = entries.map(([key, value]) => {
+      const text = typeof value === "string" ? value : JSON.stringify(value, null, 2) ?? String(value);
+      return `  ${key}: ${replaceTabs(text).replace(/\r/g, "").split("\n").join("\n    ")}`;
+    });
+    return `${header}
+${theme.fg("muted", lines.join("\n"))}`;
+  }
+  const pairs = entries.map(([key, value]) => `${key}=${JSON.stringify(value) ?? String(value)}`).join(" ");
+  const preview = pairs.length > COLLAPSED_ARGS_CHARS ? `${pairs.slice(0, COLLAPSED_ARGS_CHARS - 3)}...` : pairs;
+  return `${header} ${theme.fg("muted", preview)}`;
+}
+__name(formatToolCallWithArgs, "formatToolCallWithArgs");
+function formatToolDuration(ms) {
+  const seconds = ms / 1e3;
+  if (seconds < 60)
+    return `${seconds.toFixed(1)}s`;
+  const totalSeconds = Math.floor(seconds);
+  const minutes = Math.floor(totalSeconds / 60);
+  const remainder = totalSeconds % 60;
+  if (minutes < 60)
+    return `${minutes}m ${remainder}s`;
+  return `${Math.floor(minutes / 60)}h ${minutes % 60}m ${remainder}s`;
+}
+__name(formatToolDuration, "formatToolDuration");
+function startToolTimer(context) {
+  const state = context.state;
+  if (context.executionStarted && state.startedAt === void 0) {
+    state.startedAt = Date.now();
+    state.endedAt = void 0;
+  }
+}
+__name(startToolTimer, "startToolTimer");
+function toolTimerText(context, isPartial) {
+  const state = context.state;
+  if (state.startedAt !== void 0 && isPartial && !state.interval) {
+    state.interval = setInterval(() => context.invalidate(), 1e3);
+  }
+  if (!isPartial || context.isError) {
+    state.endedAt ??= Date.now();
+    if (state.interval) {
+      clearInterval(state.interval);
+      state.interval = void 0;
+    }
+  }
+  if (!isPartial && context.durationMs !== void 0)
+    return `Took ${formatToolDuration(context.durationMs)}`;
+  if (state.startedAt === void 0)
+    return void 0;
+  const endTime = state.endedAt ?? Date.now();
+  return `${isPartial ? "Elapsed" : "Took"} ${formatToolDuration(endTime - state.startedAt)}`;
+}
+__name(toolTimerText, "toolTimerText");
+function invalidArgText(theme) {
+  return theme.fg("error", "[invalid arg]");
+}
+__name(invalidArgText, "invalidArgText");
+function renderToolPath(rawPath, theme, cwd, options) {
+  if (rawPath === null)
+    return invalidArgText(theme);
+  const value = rawPath || options?.emptyFallback;
+  if (!value)
+    return theme.fg("toolOutput", "...");
+  return linkPath(theme.fg("accent", shortenPath(value)), value, cwd);
+}
+__name(renderToolPath, "renderToolPath");
+
+// node_modules/@earendil-works/pi-codemode/dist/identifier.js
+function toCodemodeIdentifier(name) {
+  let identifier = "";
+  for (const char of name) {
+    const valid = identifier === "" ? /^[A-Za-z_$]$/.test(char) : /^[A-Za-z0-9_$]$/.test(char);
+    identifier += valid ? char : "_";
+  }
+  return identifier === "" ? "_" : identifier;
+}
+__name(toCodemodeIdentifier, "toCodemodeIdentifier");
+
+// node_modules/@earendil-works/pi-codemode/dist/declarations.js
+var IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var INDENT = "  ";
+var DEFAULT_INPUT_SCHEMA_MAX_CHARS = 16e3;
+var MAX_REF_EXPANSIONS = 32;
+var TAG_KEYWORDS = [
+  "minimum",
+  "exclusiveMinimum",
+  "maximum",
+  "exclusiveMaximum",
+  "multipleOf",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "format",
+  "minItems",
+  "maxItems"
+];
+var LOWER_BOUNDS = /* @__PURE__ */ new Set(["minimum", "exclusiveMinimum", "minLength", "minItems"]);
+var UPPER_BOUNDS = /* @__PURE__ */ new Set(["maximum", "exclusiveMaximum", "maxLength", "maxItems"]);
+var MAX_TAG_CHARS = 80;
+var LINE_TERMINATORS = /[\r\n\u2028\u2029]/g;
+function renderToolSignature(tool, options = {}) {
+  const input = tool.inputSchema === void 0 ? "unknown" : schemaToType(tool.inputSchema, { maxChars: options.inputMaxChars ?? DEFAULT_INPUT_SCHEMA_MAX_CHARS });
+  return `${toCodemodeIdentifier(tool.name)}(args: ${input}): Promise<${renderToolOutputType(tool.outputSchema)}>;`;
+}
+__name(renderToolSignature, "renderToolSignature");
+function renderToolSample(tool, options = {}) {
+  const declaration = `declare const tools: { ${renderToolSignature(tool, options)} };`;
+  return `${tool.description?.trim() ?? ""}
+
+codemode tool declaration:
+\`\`\`ts
+${declaration}
+\`\`\``;
+}
+__name(renderToolSample, "renderToolSample");
+function renderToolOutputType(schema) {
+  return schema === void 0 ? "unknown" : schemaToType(schema);
+}
+__name(renderToolOutputType, "renderToolOutputType");
+function propertyKey(name) {
+  return IDENTIFIER.test(name) ? name : JSON.stringify(name);
+}
+__name(propertyKey, "propertyKey");
+function union(types) {
+  const unique = [...new Set(types)];
+  if (unique.includes("unknown"))
+    return "unknown";
+  return unique.length === 0 ? "never" : unique.join(" | ");
+}
+__name(union, "union");
+function schemaToType(schema, options = {}) {
+  const render = /* @__PURE__ */ __name((tags) => toType(schema, { root: schema, resolving: /* @__PURE__ */ new Set(), expansions: 0, tags }), "render");
+  const type = render(true);
+  if (options.maxChars === void 0 || type.length <= options.maxChars)
+    return type;
+  const untagged = render(false);
+  return untagged.length <= options.maxChars ? untagged : "unknown";
+}
+__name(schemaToType, "schemaToType");
+function resolveRef(ref, root) {
+  if (ref !== "#" && !ref.startsWith("#/"))
+    return void 0;
+  let current = root;
+  for (const segment of ref.slice(2).split("/").filter(Boolean)) {
+    const key = decodeURIComponent(segment).replaceAll("~1", "/").replaceAll("~0", "~");
+    if (typeof current !== "object" || current === null || Array.isArray(current) || !(key in current)) {
+      return void 0;
+    }
+    current = current[key];
+  }
+  if (typeof current === "boolean")
+    return current;
+  return typeof current === "object" && current !== null && !Array.isArray(current) ? current : void 0;
+}
+__name(resolveRef, "resolveRef");
+function toType(schema, context) {
+  if (schema === true)
+    return "unknown";
+  if (schema === false)
+    return "never";
+  if (typeof schema !== "object" || schema === null || Array.isArray(schema))
+    return "unknown";
+  if (typeof schema.$ref === "string") {
+    const ref = schema.$ref;
+    if (context.resolving.has(ref) || context.expansions >= MAX_REF_EXPANSIONS)
+      return "unknown";
+    const target = resolveRef(ref, context.root);
+    if (target === void 0)
+      return "unknown";
+    context.expansions++;
+    context.resolving.add(ref);
+    try {
+      return toType(target, context);
+    } finally {
+      context.resolving.delete(ref);
+    }
+  }
+  if ("const" in schema)
+    return JSON.stringify(schema.const) ?? "unknown";
+  if (Array.isArray(schema.enum))
+    return union(schema.enum.map((value) => JSON.stringify(value) ?? "unknown"));
+  const variants = Array.isArray(schema.anyOf) ? schema.anyOf : Array.isArray(schema.oneOf) ? schema.oneOf : void 0;
+  if (variants)
+    return union(variants.map((variant) => toType(variant, context)));
+  if (Array.isArray(schema.allOf)) {
+    const parts = schema.allOf.map((part) => toType(part, context)).filter((part) => part !== "unknown");
+    return parts.length === 0 ? "unknown" : parts.map((part) => part.includes(" | ") ? `(${part})` : part).join(" & ");
+  }
+  const type = schema.type;
+  if (Array.isArray(type))
+    return union(type.map((entry) => toType({ ...schema, type: entry }, context)));
+  switch (type) {
+    case "string":
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    case "array":
+      return arrayType(schema, context);
+    case "object":
+      return objectType(schema, context);
+    case void 0:
+      if ("properties" in schema || "additionalProperties" in schema || "required" in schema) {
+        return objectType(schema, context);
+      }
+      if ("items" in schema || "prefixItems" in schema)
+        return arrayType(schema, context);
+      return "unknown";
+    default:
+      return "unknown";
+  }
+}
+__name(toType, "toType");
+function arrayType(schema, context) {
+  if (schema.items !== void 0 && !Array.isArray(schema.items)) {
+    return `Array<${toType(schema.items, context)}>`;
+  }
+  const tuple = Array.isArray(schema.prefixItems) ? schema.prefixItems : Array.isArray(schema.items) ? schema.items : [];
+  if (tuple.length > 0)
+    return `[${tuple.map((item) => toType(item, context)).join(", ")}]`;
+  return "unknown[]";
+}
+__name(arrayType, "arrayType");
+function descriptionOf(property) {
+  const description = property?.description;
+  return typeof description === "string" ? description.trim() : "";
+}
+__name(descriptionOf, "descriptionOf");
+function constraintTags(schema) {
+  if (typeof schema !== "object" || schema === null || Array.isArray(schema))
+    return "";
+  const property = schema;
+  const variants = Array.isArray(property.anyOf) ? property.anyOf : property.oneOf;
+  const nonNull = Array.isArray(variants) ? variants.filter((variant) => variant?.type !== "null") : [];
+  const branch = nonNull.length === 1 ? nonNull[0] : void 0;
+  const branches = typeof branch === "object" && branch !== null && !Array.isArray(branch) ? [property, branch] : [property];
+  const schemas = branches.map((schema2) => ({
+    ...schema2,
+    ...schema2.exclusiveMinimum === true ? { minimum: void 0, exclusiveMinimum: schema2.minimum } : {},
+    ...schema2.exclusiveMaximum === true ? { maximum: void 0, exclusiveMaximum: schema2.maximum } : {}
+  }));
+  const tags = [];
+  const isInteger = /* @__PURE__ */ __name((type) => type === "integer" || Array.isArray(type) && type.includes("integer"), "isInteger");
+  if (schemas.some((schema2) => isInteger(schema2.type)))
+    tags.push("@integer");
+  for (const keyword of TAG_KEYWORDS) {
+    const values = schemas.map((schema2) => schema2[keyword]);
+    if (LOWER_BOUNDS.has(keyword) || UPPER_BOUNDS.has(keyword)) {
+      const numbers = values.filter((value) => typeof value === "number");
+      if (numbers.length === 0)
+        continue;
+      tags.push(`@${keyword} ${LOWER_BOUNDS.has(keyword) ? Math.max(...numbers) : Math.min(...numbers)}`);
+      continue;
+    }
+    for (const value of new Set(values)) {
+      if (typeof value === "number" || typeof value === "string")
+        tags.push(`@${keyword} ${value}`);
+    }
+  }
+  if (schemas.some((schema2) => schema2.uniqueItems === true))
+    tags.push("@uniqueItems");
+  if (property.default !== void 0 && property.default !== null) {
+    tags.push(`@default ${JSON.stringify(property.default)}`);
+  }
+  if (property.deprecated === true)
+    tags.push("@deprecated");
+  return tags.filter((tag) => tag.length <= MAX_TAG_CHARS).map((tag) => tag.replace(LINE_TERMINATORS, (char) => `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`)).join(" ");
+}
+__name(constraintTags, "constraintTags");
+function objectType(schema, context) {
+  const properties = typeof schema.properties === "object" && schema.properties !== null && !Array.isArray(schema.properties) ? schema.properties : {};
+  const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+  const names = Object.keys(properties).sort();
+  const members = names.map((name) => {
+    const optional = required.has(name) ? "" : "?";
+    return `${propertyKey(name)}${optional}: ${toType(properties[name], context)};`;
+  });
+  const additional = schema.additionalProperties;
+  if (additional !== void 0 && additional !== false) {
+    const type = additional === true ? "unknown" : toType(additional, context);
+    members.push(`[key: string]: ${type};`);
+  } else if (additional === void 0 && names.length === 0) {
+    members.push("[key: string]: unknown;");
+  }
+  if (members.length === 0)
+    return "{}";
+  const comments = names.map((name) => {
+    const lines2 = descriptionOf(properties[name]).split(LINE_TERMINATORS).map((line) => line.trim()).filter(Boolean);
+    const tags = context.tags ? constraintTags(properties[name]) : "";
+    return tags ? [...lines2, tags] : lines2;
+  });
+  if (!comments.some((comment) => comment.length > 0))
+    return `{ ${members.join(" ")} }`;
+  const lines = ["{"];
+  comments.forEach((comment, index) => {
+    for (const line of comment)
+      lines.push(`${INDENT}// ${line}`);
+    lines.push(`${INDENT}${members[index].replaceAll("\n", `
+${INDENT}`)}`);
+  });
+  for (const member of members.slice(names.length))
+    lines.push(`${INDENT}${member}`);
+  lines.push("}");
+  return lines.join("\n");
+}
+__name(objectType, "objectType");
+
+// node_modules/@earendil-works/pi-codemode/dist/source.js
+var CODEMODE_OPTIONS_PREFIX = "// @options:";
+var SUPPORTED_FIELDS = ["max_output_tokens", "timeout_ms"];
+var SUPPORTED_FIELDS_TEXT = "`max_output_tokens` and `timeout_ms`";
+var MAX_TIMEOUT_MS = 2147483647;
+var CODEMODE_SOURCE_GRAMMAR = String.raw`
+start: options_source | plain_source
+options_source: OPTIONS_LINE NEWLINE SOURCE
+plain_source: SOURCE
+
+OPTIONS_LINE: /[ \t]*\/\/ @options:[^\r\n]*/
+NEWLINE: /\r?\n/
+SOURCE: /[\s\S]+/
+`;
+var CodemodeSourceError = class extends Error {
+  static {
+    __name(this, "CodemodeSourceError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "CodemodeSourceError";
+  }
+};
+function isSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+__name(isSafeInteger, "isSafeInteger");
+function parseOptions(directive) {
+  if (directive === "") {
+    throw new CodemodeSourceError(`@options must be a JSON object with supported fields ${SUPPORTED_FIELDS_TEXT}`);
+  }
+  let value;
+  try {
+    value = JSON.parse(directive);
+  } catch (error) {
+    throw new CodemodeSourceError(`@options must be valid JSON with supported fields ${SUPPORTED_FIELDS_TEXT}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new CodemodeSourceError(`@options must be a JSON object with supported fields ${SUPPORTED_FIELDS_TEXT}`);
+  }
+  const fields = value;
+  for (const key of Object.keys(fields)) {
+    if (!SUPPORTED_FIELDS.includes(key)) {
+      throw new CodemodeSourceError(`@options only supports ${SUPPORTED_FIELDS_TEXT}; got \`${key}\``);
+    }
+  }
+  const options = {};
+  const { max_output_tokens, timeout_ms } = fields;
+  if (max_output_tokens !== void 0) {
+    if (!isSafeInteger(max_output_tokens)) {
+      throw new CodemodeSourceError("@options field `max_output_tokens` must be a non-negative safe integer");
+    }
+    options.maxOutputTokens = max_output_tokens;
+  }
+  if (timeout_ms !== void 0) {
+    if (!isSafeInteger(timeout_ms) || timeout_ms === 0 || timeout_ms > MAX_TIMEOUT_MS) {
+      throw new CodemodeSourceError(`@options field \`timeout_ms\` must be a positive integer up to ${MAX_TIMEOUT_MS}`);
+    }
+    options.timeoutMs = timeout_ms;
+  }
+  return options;
+}
+__name(parseOptions, "parseOptions");
+function parseCodemodeSource(input) {
+  if (input.trim() === "") {
+    throw new CodemodeSourceError('Expected JavaScript source text (non-empty). Provide JS only, optionally with a first line `// @options: {"max_output_tokens": 1000}`.');
+  }
+  const lines = input.split("\n");
+  const misplaced = lines.findIndex((line, index) => index > 0 && line.trimStart().startsWith(CODEMODE_OPTIONS_PREFIX));
+  if (misplaced !== -1) {
+    throw new CodemodeSourceError(`The ${CODEMODE_OPTIONS_PREFIX} line must be the first line of the input; found one on line ${misplaced + 1}`);
+  }
+  const newline = input.indexOf("\n");
+  const firstLine = lines[0].replace(/\r$/, "");
+  const trimmed = firstLine.trimStart();
+  if (!trimmed.startsWith(CODEMODE_OPTIONS_PREFIX))
+    return { code: input, options: {} };
+  const code = newline === -1 ? "" : input.slice(newline);
+  if (code.trim() === "") {
+    throw new CodemodeSourceError("The @options line must be followed by JavaScript source on subsequent lines");
+  }
+  return { code, options: parseOptions(trimmed.slice(CODEMODE_OPTIONS_PREFIX.length).trim()) };
+}
+__name(parseCodemodeSource, "parseCodemodeSource");
+
+// node_modules/@earendil-works/pi-coding-agent/dist/extensions/tool-search/tool.js
+var TOOL_SEARCH_TOOL_NAME = "tool_search";
+var DEFAULT_TOOL_SEARCH_LIMIT = 8;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "by",
+  "for",
+  "from",
+  "in",
+  "is",
+  "it",
+  "of",
+  "on",
+  "or",
+  "that",
+  "the",
+  "this",
+  "to",
+  "with"
+]);
+function stem(term) {
+  if (term.length > 4 && term.endsWith("ies"))
+    return `${term.slice(0, -3)}y`;
+  if (term.length > 4 && /(ches|shes|sses|xes|zes)$/.test(term))
+    return term.slice(0, -2);
+  if (term.length > 3 && term.endsWith("s") && !term.endsWith("ss"))
+    return term.slice(0, -1);
+  return term;
+}
+__name(stem, "stem");
+function tokenize(text) {
+  return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((term) => term.length > 0 && !STOP_WORDS.has(term)).map(stem);
+}
+__name(tokenize, "tokenize");
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isObject, "isObject");
+function schemaText(schema, parts) {
+  if (!isObject(schema))
+    return;
+  if (typeof schema.description === "string")
+    parts.push(schema.description);
+  if (isObject(schema.properties)) {
+    for (const [name, property] of Object.entries(schema.properties)) {
+      parts.push(name);
+      schemaText(property, parts);
+    }
+  }
+  schemaText(schema.items, parts);
+  for (const key of ["anyOf", "oneOf", "allOf"]) {
+    const variants = schema[key];
+    if (Array.isArray(variants))
+      for (const variant of variants)
+        schemaText(variant, parts);
+  }
+}
+__name(schemaText, "schemaText");
+function createToolSearchDocument(tool, namespace) {
+  const parts = [tool.name, tool.name.replaceAll("_", " "), tool.description];
+  schemaText(tool.parameters, parts);
+  if (namespace)
+    parts.push(namespace.name, namespace.description ?? "", namespace.instructions ?? "");
+  return { name: tool.name, text: parts.filter((part) => part.trim()).join(" ") };
+}
+__name(createToolSearchDocument, "createToolSearchDocument");
+var Bm25Ranker = class {
+  static {
+    __name(this, "Bm25Ranker");
+  }
+  k1;
+  b;
+  constructor(options = {}) {
+    this.k1 = options.k1 ?? 1.2;
+    this.b = options.b ?? 0.75;
+  }
+  rank(query, documents, limit) {
+    const queryTerms = [...new Set(tokenize(query))];
+    if (queryTerms.length === 0 || documents.length === 0 || limit <= 0)
+      return [];
+    const termCounts = documents.map((document) => {
+      const counts = /* @__PURE__ */ new Map();
+      for (const term of tokenize(document.text))
+        counts.set(term, (counts.get(term) ?? 0) + 1);
+      return counts;
+    });
+    const lengths = termCounts.map((counts) => [...counts.values()].reduce((sum, count) => sum + count, 0));
+    const averageLength = lengths.reduce((sum, length) => sum + length, 0) / documents.length || 1;
+    const idf = new Map(queryTerms.map((term) => {
+      const frequency = termCounts.filter((counts) => counts.has(term)).length;
+      return [term, Math.log(1 + (documents.length - frequency + 0.5) / (frequency + 0.5))];
+    }));
+    const matches = [];
+    documents.forEach((document, index) => {
+      let score = 0;
+      for (const term of queryTerms) {
+        const count = termCounts[index].get(term);
+        if (!count)
+          continue;
+        const norm = this.k1 * (1 - this.b + this.b * lengths[index] / averageLength);
+        score += (idf.get(term) ?? 0) * (count * (this.k1 + 1) / (count + norm));
+      }
+      if (score > 0)
+        matches.push({ name: document.name, score });
+    });
+    return matches.sort((a, b) => b.score - a.score).slice(0, limit);
+  }
+};
+var toolSearchSchema = typebox_exports.Object({
+  query: typebox_exports.String({ description: "Search query for deferred tools." }),
+  limit: typebox_exports.Optional(typebox_exports.Number({ description: `Maximum number of tools to return. Defaults to ${DEFAULT_TOOL_SEARCH_LIMIT}.` }))
+});
+function isSearchable(exposure) {
+  return exposure === "codemode" || exposure === "deferred";
+}
+__name(isSearchable, "isSearchable");
+function searchAndLoad(tools, query, limit) {
+  const active = tools.getActiveTools();
+  const candidates = tools.getAllTools().filter((tool) => isSearchable(tool.exposure) && !active.includes(tool.name));
+  const documents = candidates.map((tool) => createToolSearchDocument(tool, tool.namespace));
+  const matches = new Bm25Ranker().rank(query, documents, limit);
+  if (matches.length > 0)
+    tools.setActiveTools([...active, ...matches.map((match) => match.name)]);
+  return matches.map((match) => ({
+    name: match.name,
+    description: candidates.find((tool) => tool.name === match.name)?.description ?? ""
+  }));
+}
+__name(searchAndLoad, "searchAndLoad");
+var TOOL_SEARCH_DESCRIPTION = `# Tool discovery
+
+Searches over deferred tool metadata with BM25 and exposes matching tools for the next model call.
+
+Some of the tools, such as tools of MCP servers, may not have been provided to you upfront, and you should use this tool (\`${TOOL_SEARCH_TOOL_NAME}\`) to search for the required tools. For MCP tool discovery, always use \`${TOOL_SEARCH_TOOL_NAME}\`.`;
+function createToolSearchToolDefinition(options = {}) {
+  return {
+    name: TOOL_SEARCH_TOOL_NAME,
+    label: TOOL_SEARCH_TOOL_NAME,
+    description: TOOL_SEARCH_DESCRIPTION,
+    promptSnippet: "Search for tools that are not loaded yet and load the matches",
+    parameters: toolSearchSchema,
+    // Searching is not something scripts need; it changes what the model sees.
+    exposure: "model-only",
+    // A query can match any tool that is not declared yet.
+    reachesTools: /* @__PURE__ */ __name(() => "all", "reachesTools"),
+    async execute(_toolCallId, { query, limit }) {
+      if (query.trim() === "")
+        throw new Error("query must not be empty");
+      const max = limit ?? DEFAULT_TOOL_SEARCH_LIMIT;
+      if (!Number.isInteger(max) || max <= 0)
+        throw new Error("limit must be a positive integer");
+      const tools = options.tools ? searchAndLoad(options.tools, query, max) : [];
+      const text = tools.length === 0 ? "No matching tools found." : `Loaded ${tools.length} tool${tools.length === 1 ? "" : "s"}. They are available from your next call:
+${tools.map((tool) => `- ${tool.name}: ${tool.description.trim().split(/\r?\n/)[0]}`).join("\n")}`;
+      return { content: [{ type: "text", text }], details: { loaded: tools.map((tool) => tool.name) } };
+    }
+  };
+}
+__name(createToolSearchToolDefinition, "createToolSearchToolDefinition");
+
+// node_modules/@earendil-works/pi-coding-agent/dist/extensions/codemode/tool.js
+import { join as join2 } from "node:path";
+
+// node_modules/@earendil-works/pi-coding-agent/dist/core/settings-defaults.js
+var SETTINGS_DEFAULTS = {
+  transport: "auto",
+  sessionShareDestination: "auto",
+  steeringMode: "one-at-a-time",
+  followUpMode: "one-at-a-time",
+  compaction: {
+    enabled: true,
+    reserveTokens: 16384,
+    keepRecentTokens: 2e4
+  },
+  branchSummary: {
+    reserveTokens: 16384,
+    skipPrompt: false
+  },
+  retry: {
+    enabled: true,
+    maxRetries: 3,
+    baseDelayMs: 2e3,
+    maxAgentDelayMs: DEFAULT_MAX_AGENT_RETRY_DELAY_MS,
+    provider: {
+      maxRetryDelayMs: 6e4
+    }
+  },
+  hideThinkingBlock: false,
+  showCacheMissNotices: false,
+  quietStartup: false,
+  defaultProjectTrust: "ask",
+  collapseChangelog: false,
+  enableInstallTelemetry: true,
+  enableAnalytics: false,
+  enableSkillCommands: true,
+  terminal: {
+    showImages: true,
+    imageWidthCells: 60,
+    clearOnShrink: false,
+    showTerminalProgress: false
+  },
+  images: {
+    autoResize: true,
+    blockImages: false
+  },
+  doubleEscapeAction: "tree",
+  treeFilterMode: "default",
+  editorPaddingX: 0,
+  outputPad: 1,
+  autocompleteMaxVisible: 5,
+  markdown: {
+    codeBlockIndent: "  ",
+    mermaid: "streaming"
+  },
+  warnings: {
+    anthropicExtraUsage: true
+  },
+  codemode: {
+    mode: "on",
+    inlineBudget: 3e3
+  },
+  cacheWarming: "streaming",
+  tuiMode: "fullscreen",
+  fullscreenExitOutput: "transcript",
+  fullscreenScrollbar: "auto",
+  fullscreenCopyOnSelect: true,
+  fullscreenWheelScrollLines: "auto"
+};
+
+// node_modules/@earendil-works/pi-coding-agent/dist/core/tools/tool-definition-wrapper.js
+function wrapToolDefinition(definition, ctxFactory) {
+  return {
+    name: definition.name,
+    label: definition.label,
+    description: definition.description,
+    parameters: definition.parameters,
+    outputSchema: definition.outputSchema,
+    constrainedSampling: definition.constrainedSampling,
+    prepareArguments: definition.prepareArguments,
+    executionMode: definition.executionMode,
+    execute: /* @__PURE__ */ __name((toolCallId, params, signal, onUpdate, ctx) => definition.execute(toolCallId, params, signal, onUpdate, ctx ?? ctxFactory?.(toolCallId, signal)), "execute")
+  };
+}
+__name(wrapToolDefinition, "wrapToolDefinition");
+function createToolDefinitionFromAgentTool(tool) {
+  return {
+    name: tool.name,
+    label: tool.label,
+    description: tool.description,
+    parameters: tool.parameters,
+    outputSchema: tool.outputSchema,
+    constrainedSampling: tool.constrainedSampling,
+    prepareArguments: tool.prepareArguments,
+    executionMode: tool.executionMode,
+    execute: /* @__PURE__ */ __name(async (toolCallId, params, signal, onUpdate) => tool.execute(toolCallId, params, signal, onUpdate), "execute")
+  };
+}
+__name(createToolDefinitionFromAgentTool, "createToolDefinitionFromAgentTool");
+
+// node_modules/@earendil-works/pi-coding-agent/dist/extensions/codemode/execute.lazy.js
+var loadCodemodeExecutor = /* @__PURE__ */ __name(() => import("./c-FPCNRL7G.mjs"), "loadCodemodeExecutor");
+
+// node_modules/@earendil-works/pi-coding-agent/dist/extensions/codemode/renderer.js
+var CODE_PREVIEW_LINES = 10;
+var CALL_PREVIEW_COUNT = 8;
+var OUTPUT_PREVIEW_LINES = 5;
+var COLLAPSED_ARGS_CHARS2 = 80;
+var SCRIPT_HEADER = /^Script (completed|failed)\nWall time [\d.]+ seconds\nOutput:\n$/;
+function expandHint(theme, hidden, noun) {
+  return `${theme.fg("muted", `... (${hidden} more ${noun},`)} ${keyHint("app.tools.expand", "to expand")}${theme.fg("muted", ")")}`;
+}
+__name(expandHint, "expandHint");
+function formatDuration(ms) {
+  if (ms === void 0)
+    return "";
+  return ms < 1e3 ? `${Math.round(ms)}ms` : `${(ms / 1e3).toFixed(1)}s`;
+}
+__name(formatDuration, "formatDuration");
+function formatCost(cost) {
+  return `$${cost >= 0.01 ? cost.toFixed(2) : cost.toPrecision(2)}`;
+}
+__name(formatCost, "formatCost");
+function statusIcon(call, theme) {
+  switch (call.status) {
+    case "running":
+      return theme.fg("warning", "\u2026");
+    case "ok":
+      return theme.fg("success", "\u2713");
+    case "error":
+      return theme.fg("error", "\u2717");
+    case "cancelled":
+      return theme.fg("muted", "\u2298");
+  }
+}
+__name(statusIcon, "statusIcon");
+function formatCall(call, theme, expanded) {
+  const args = !expanded && call.args.length > COLLAPSED_ARGS_CHARS2 ? `${call.args.slice(0, COLLAPSED_ARGS_CHARS2 - 3)}...` : call.args;
+  const duration = formatDuration(call.durationMs);
+  let line = `${statusIcon(call, theme)} ${theme.fg("toolTitle", call.name)}`;
+  if (args)
+    line += ` ${theme.fg("muted", args)}`;
+  if (duration)
+    line += ` ${theme.fg("dim", duration)}`;
+  if (call.cost)
+    line += ` ${theme.fg("dim", formatCost(call.cost))}`;
+  if (expanded && call.error)
+    line += `
+    ${theme.fg("error", call.error.split("\n").join("\n    "))}`;
+  return line;
+}
+__name(formatCall, "formatCall");
+var codemodeRenderers = {
+  renderCall(args, theme, context) {
+    startToolTimer(context);
+    const code = str(args?.code);
+    const title = theme.fg("toolTitle", theme.bold("codemode"));
+    const component = context.lastComponent ?? new Container();
+    component.clear();
+    if (code === null) {
+      component.addChild(new Text(`${title} ${theme.fg("error", "[invalid arg]")}`, 0, 0));
+      return component;
+    }
+    component.addChild(new Text(title, 0, 0));
+    if (code) {
+      const highlighted = highlightCode(replaceTabs(code.replace(/\r/g, "").trimEnd()), "javascript").join("\n");
+      component.addChild(context.expanded ? new Text(highlighted, 0, 0) : new VisualLinePreview({
+        text: highlighted,
+        maxVisualLines: CODE_PREVIEW_LINES,
+        keep: "start",
+        formatHint: /* @__PURE__ */ __name((hidden) => expandHint(theme, hidden, "lines"), "formatHint")
+      }));
+    }
+    return component;
+  },
+  renderResult(result, options, theme, context) {
+    const timerText = toolTimerText(context, options.isPartial);
+    const component = context.lastComponent ?? new Container();
+    component.clear();
+    const calls = result.details?.calls ?? [];
+    if (calls.length > 0) {
+      const shown = options.expanded ? calls : calls.slice(-CALL_PREVIEW_COUNT);
+      const lines = shown.map((call) => formatCall(call, theme, options.expanded));
+      if (shown.length < calls.length) {
+        lines.unshift(`${theme.fg("muted", `... (${calls.length - shown.length} earlier calls,`)} ${keyHint("app.tools.expand", "to expand")}${theme.fg("muted", ")")}`);
+      }
+      const priced = calls.filter((call) => call.cost);
+      if (priced.length > 1) {
+        const total = priced.reduce((sum, call) => sum + (call.cost ?? 0), 0);
+        lines.push(theme.fg("muted", `Model calls: ${formatCost(total)}`));
+      }
+      component.addChild(new Spacer(1));
+      component.addChild(new Text(lines.join("\n"), 0, 0));
+    }
+    const [first, ...rest] = result.content;
+    const hasHeader = first?.type === "text" && SCRIPT_HEADER.test(first.text);
+    const output = options.isPartial ? "" : getTextOutput({ ...result, content: hasHeader ? rest : result.content }, context.showImages).trim();
+    if (output) {
+      const color = context.isError ? "error" : "toolOutput";
+      const styled = replaceTabs(output).split("\n").map((line) => theme.fg(color, line)).join("\n");
+      component.addChild(new Spacer(1));
+      if (options.expanded) {
+        component.addChild(new Text(styled, 0, 0));
+      } else {
+        component.addChild(new VisualLinePreview({
+          text: styled,
+          maxVisualLines: OUTPUT_PREVIEW_LINES,
+          keep: "start",
+          formatHint: /* @__PURE__ */ __name((hidden) => expandHint(theme, hidden, "lines"), "formatHint")
+        }));
+        const fullOutputPath = result.details?.fullOutputPath;
+        if (fullOutputPath)
+          component.addChild(new Text(theme.fg("muted", `Full output: ${fullOutputPath}`), 0, 0));
+      }
+    }
+    if (timerText) {
+      component.addChild(new Spacer(1));
+      component.addChild(new Text(theme.fg("muted", timerText), 0, 0));
+    }
+    return component;
+  }
+};
+
+// node_modules/@earendil-works/pi-coding-agent/dist/extensions/codemode/tool.js
+var CODEMODE_TOOL_NAME = "codemode";
+var CODEMODE_STORE_ENTRY_TYPE = "codemode-store";
+var TEXT_OUTPUT_SCHEMA = { type: "string" };
+var codemodeSchema = typebox_exports.Object({
+  code: typebox_exports.String({
+    description: "Raw JavaScript source."
+  })
+});
+var codemodeToolSystemPromptContribution = {
+  snippet: "Run JavaScript that calls other tools",
+  guidelines: [
+    "Use codemode to batch independent tool calls (Promise.allSettled), chain them, or filter large output, instead of many separate calls."
+  ]
+};
+var CODEMODE_DOCS_PATH = join2(getDocsPath(), "codemode.md");
+var DESCRIPTION_INTRO = `Run JavaScript that calls other tools. The input is raw JavaScript (not JSON, no code fence), run as an async function body in a QuickJS sandbox: top-level \`await\` and \`return\` work. No Node, file system, network, or timers.
+- \`await tools.<name>({ ...args })\` resolves to a string, or an object if the tool's declaration says so, and rejects with an Error on failure. A tool whose declaration returns an object resolves on failure too when it returned that object; check its fields. Calls still running when the script ends are cancelled.
+- Optional first line: \`// @options: {"max_output_tokens": 10000, "timeout_ms": 60000}\``;
+function describeGlobals(models) {
+  const lines = [
+    "Globals:",
+    "- `text(value)`, `image(dataUrlOrImageBlock)`, `console.log(...)`, and top-level `return` add output; `exit()` ends the script. With several text items, each starts with a `==> text N/M <==` line, and `console` lines follow the other output in one `<console_output>` block. `image()` also saves the image to a temp file and the result names its path.",
+    "- `store(key, value)` and `load(key)` keep JSON values across codemode calls.",
+    "- `ALL_TOOLS`, `await searchTools(query, { limit?, namespace? })`, `await describeTool(name)`, `await describeNamespace(name)`: find unlisted tools, such as MCP tools."
+  ];
+  if (models) {
+    lines.push(`- \`models\`: classifiers and image generation. Read ${CODEMODE_DOCS_PATH} first.`);
+  }
+  return lines.join("\n");
+}
+__name(describeGlobals, "describeGlobals");
+var DEFAULT_CODEMODE_INLINE_BUDGET = SETTINGS_DEFAULTS.codemode.inlineBudget;
+var CHARS_PER_TOKEN = 4;
+function toCodemodeDeclaration(tool, guidelines = []) {
+  const bullets = guidelines.flatMap((guideline) => guideline.trim() ? [`- ${guideline.trim()}`] : []);
+  return {
+    name: tool.name,
+    description: bullets.length > 0 ? `${tool.description.trim()}
+
+${bullets.join("\n")}` : tool.description,
+    inputSchema: tool.parameters,
+    outputSchema: tool.outputSchema ?? TEXT_OUTPUT_SCHEMA
+  };
+}
+__name(toCodemodeDeclaration, "toCodemodeDeclaration");
+function getCodemodeCallableTools(tools) {
+  return tools.filter((tool) => tool.name !== CODEMODE_TOOL_NAME);
+}
+__name(getCodemodeCallableTools, "getCodemodeCallableTools");
+function renderToolSection(declaration) {
+  const id = toCodemodeIdentifier(declaration.name);
+  const heading = id === declaration.name ? `### \`${id}\`` : `### \`${id}\` (\`${declaration.name}\`)`;
+  return `${heading}
+${renderToolSample(declaration).trim()}`;
+}
+__name(renderToolSection, "renderToolSection");
+function selectCatalog(groups, budget) {
+  if (budget === void 0)
+    return new Set(groups.flatMap((group) => group.entries.map((entry) => entry.name)));
+  const queues = groups.map((group) => [...group.entries].sort((a, b) => a.cost - b.cost));
+  const shown = /* @__PURE__ */ new Set();
+  let remaining = budget;
+  let active = queues.filter((queue) => queue.length > 0);
+  while (active.length > 0) {
+    active = active.filter((queue) => {
+      const next = queue[0];
+      if (next.cost > remaining)
+        return false;
+      remaining -= next.cost;
+      shown.add(next.name);
+      queue.shift();
+      return queue.length > 0;
+    });
+  }
+  return shown;
+}
+__name(selectCatalog, "selectCatalog");
+function createCodemodeDescription(tools, options = {}) {
+  const declarations = getCodemodeCallableTools(tools).filter((tool) => !options.deferred?.has(tool.name)).map((tool) => toCodemodeDeclaration(tool, options.guidelines?.get(tool.name)));
+  const groups = /* @__PURE__ */ new Map([["", { namespace: void 0, entries: [] }]]);
+  for (const declaration of declarations) {
+    const namespace = options.namespaces?.get(declaration.name);
+    const key = namespace ? `ns:${namespace.name}` : "";
+    const group = groups.get(key) ?? { namespace, entries: [] };
+    groups.set(key, group);
+    const section = renderToolSection(declaration);
+    group.entries.push({ name: declaration.name, section, cost: Math.ceil(section.length / CHARS_PER_TOKEN) });
+  }
+  const ordered = [...groups.values()].sort((a, b) => a.namespace === void 0 ? -1 : b.namespace === void 0 ? 1 : a.namespace.name.localeCompare(b.namespace.name));
+  const shown = selectCatalog(ordered, options.inlineBudget);
+  const sections = [DESCRIPTION_INTRO, describeGlobals(options.models === true)];
+  if (declarations.length === 0)
+    return sections.join("\n\n");
+  const toolSections = ["Nested tools:"];
+  for (const { namespace, entries } of ordered) {
+    const visible = entries.filter((entry) => shown.has(entry.name));
+    if (namespace) {
+      const listing = visible.length === entries.length ? "" : visible.length === 0 ? " (tools not listed)" : " (some tools not listed)";
+      const description = namespace.description?.trim();
+      toolSections.push(`## ${namespace.name}${listing}${description ? `
+${description}` : ""}`);
+    }
+    for (const entry of visible)
+      toolSections.push(entry.section);
+  }
+  sections.push(toolSections.join("\n\n"));
+  return sections.join("\n\n");
+}
+__name(createCodemodeDescription, "createCodemodeDescription");
+function describeFields(schema, depth) {
+  if (typeof schema !== "object" || schema === null)
+    return void 0;
+  const { type, properties, required } = schema;
+  if (type !== "object" || typeof properties !== "object" || properties === null)
+    return void 0;
+  const requiredNames = new Set(Array.isArray(required) ? required : []);
+  const fields = Object.entries(properties).map(([name, field]) => {
+    const nested = depth > 0 ? describeFields(field, depth - 1) : void 0;
+    return `${name}${requiredNames.has(name) ? "" : "?"}${nested ? `: ${nested}` : ""}`;
+  });
+  return `{ ${fields.join(", ")} }`;
+}
+__name(describeFields, "describeFields");
+function describeOutput(schema) {
+  const type = renderToolOutputType(schema);
+  if (type === "string")
+    return "a string";
+  const fields = describeFields(schema, 1);
+  return `\`${fields ?? type.replace(/\s+/g, " ")}\``;
+}
+__name(describeOutput, "describeOutput");
+function describeScriptCall(tool) {
+  return `${tool.description.trim()}
+
+Codemode: \`tools.${toCodemodeIdentifier(tool.name)}(args)\` resolves to ${describeOutput(toCodemodeDeclaration(tool).outputSchema)}.`;
+}
+__name(describeScriptCall, "describeScriptCall");
+function prepareCodemodeLoadout(loadout, options) {
+  const mode = options.getMode?.() ?? SETTINGS_DEFAULTS.codemode.mode;
+  const isDirect = /* @__PURE__ */ __name((tool) => loadout.getExposure(tool.name) === "direct", "isDirect");
+  const callable = getCodemodeCallableTools(loadout.callable);
+  const callableNames = new Set(callable.map((tool) => tool.name));
+  const descriptions = {};
+  if (mode === "on") {
+    for (const tool of loadout.declared) {
+      if (callableNames.has(tool.name))
+        descriptions[tool.name] = describeScriptCall(tool);
+    }
+  }
+  const listed = mode === "only" ? callable : callable.filter((tool) => !isDirect(tool));
+  const namespaces = new Map(listed.flatMap((tool) => {
+    const namespace = loadout.getNamespace(tool.name);
+    return namespace ? [[tool.name, namespace]] : [];
+  }));
+  const guidelines = new Map(listed.map((tool) => [tool.name, loadout.getPromptGuidelines(tool.name)]));
+  descriptions[CODEMODE_TOOL_NAME] = createCodemodeDescription(listed, {
+    models: options.models === true,
+    namespaces,
+    guidelines,
+    deferred: new Set(listed.filter((tool) => loadout.getExposure(tool.name) === "deferred").map((tool) => tool.name)),
+    inlineBudget: options.getInlineBudget?.() ?? DEFAULT_CODEMODE_INLINE_BUDGET
+  });
+  const declaredNames = new Set(loadout.declared.map((tool) => tool.name));
+  return {
+    descriptions,
+    hiddenDeclarations: mode === "only" ? callable.filter((tool) => isDirect(tool) && declaredNames.has(tool.name)).map((tool) => tool.name) : []
+  };
+}
+__name(prepareCodemodeLoadout, "prepareCodemodeLoadout");
+var DISCOVERY_GLOBALS = /\b(searchTools|describeNamespace|describeTool|ALL_TOOLS)\b/;
+function getScriptReach(code) {
+  if (typeof code !== "string")
+    return [];
+  return DISCOVERY_GLOBALS.test(code) ? "all" : code.match(/\w+/g) ?? [];
+}
+__name(getScriptReach, "getScriptReach");
+function createCodemodeToolDefinition(options = {}) {
+  return {
+    name: CODEMODE_TOOL_NAME,
+    label: CODEMODE_TOOL_NAME,
+    // Replaced with the declarations of the callable tools when the tool is activated.
+    description: createCodemodeDescription([], { models: options.models === true }),
+    promptSnippet: codemodeToolSystemPromptContribution.snippet,
+    promptGuidelines: [...codemodeToolSystemPromptContribution.guidelines],
+    parameters: codemodeSchema,
+    // Scripts must not start other scripts.
+    exposure: "model-only",
+    prepareLoadout: /* @__PURE__ */ __name((loadout) => prepareCodemodeLoadout(loadout, options), "prepareLoadout"),
+    reachesTools: /* @__PURE__ */ __name((input) => getScriptReach(input.code), "reachesTools"),
+    // Capable models write the script as raw text instead of a JSON-escaped string.
+    constrainedSampling: { type: "grammar", variants: { openai_lark: CODEMODE_SOURCE_GRAMMAR } },
+    // The sandbox (worker, QuickJS wasm) loads on the first call, not at startup.
+    execute: /* @__PURE__ */ __name(async (toolCallId, params, signal, onUpdate, ctx) => (await loadCodemodeExecutor()).executeCodemode(toolCallId, params, signal, onUpdate, ctx, options), "execute"),
+    ...codemodeRenderers
+  };
+}
+__name(createCodemodeToolDefinition, "createCodemodeToolDefinition");
+
+export {
+  SETTINGS_DEFAULTS,
+  splitIncompleteAnsiSuffix,
+  stripAnsi,
+  writeOutputFile,
+  createOutputFileStream,
+  DEFAULT_MAX_LINES,
+  DEFAULT_MAX_BYTES,
+  GREP_MAX_LINE_LENGTH,
+  formatSize,
+  truncateHead,
+  truncateTail,
+  truncateLine,
+  truncateMiddle,
+  createUsageTotals,
+  addUsageToTotals,
+  combineUsage,
+  getUsageCostBreakdown,
+  wrapToolDefinition,
+  createToolDefinitionFromAgentTool,
+  truncateToVisualLines,
+  VisualLinePreview,
+  shortenPath,
+  str,
+  formatReadLineRange,
+  replaceTabs,
+  normalizeDisplayText,
+  getTextOutput,
+  formatToolCallWithArgs,
+  startToolTimer,
+  toolTimerText,
+  invalidArgText,
+  renderToolPath,
+  toCodemodeIdentifier,
+  renderToolSample,
+  parseCodemodeSource,
+  TOOL_SEARCH_TOOL_NAME,
+  DEFAULT_TOOL_SEARCH_LIMIT,
+  createToolSearchDocument,
+  Bm25Ranker,
+  createToolSearchToolDefinition,
+  CODEMODE_TOOL_NAME,
+  CODEMODE_STORE_ENTRY_TYPE,
+  CODEMODE_DOCS_PATH,
+  toCodemodeDeclaration,
+  getCodemodeCallableTools,
+  createCodemodeToolDefinition
+};