@desplega.ai/agent-swarm 1.171.0 → 1.172.0

package/dist/{cli-s9y81s7j.js → cli-bt8k5h3s.js}

@@ -1,24 +1,248 @@
 import {
-  VisualLinePreview,
-  getTextOutput,
-  replaceTabs,
-  str
-} from "./cli-rhy7z1rp.js";
+  sanitizeBinaryOutput
+} from "./cli-ev91t6xp.js";
 import {
   Container,
   Spacer,
   Text,
-  getDocsPath,
+  getCapabilities,
+  getImageDimensions,
   highlightCode,
-  keyHint
-} from "./cli-5t5my0h8.js";
+  hyperlink,
+  imageFallback,
+  keyHint,
+  truncateToWidth
+} from "./cli-qybkr9n3.js";
+import {
+  getDocsPath,
+  resolvePath
+} from "./cli-hd27d2md.js";
 import {
+  DEFAULT_MAX_AGENT_RETRY_DELAY_MS,
   exports_typebox
-} from "./cli-rb9m6rpe.js";
+} from "./cli-h6vtvt5c.js";
 import {
   __require
 } from "./cli-bc05qbss.js";
 
+// 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}`);
+}
+async function writeOutputFile(prefix, extension, data) {
+  const path = createOutputFilePath(prefix, extension);
+  await writeFile(path, data, { mode: OUTPUT_FILE_MODE, flag: "wx" });
+  return path;
+}
+function createOutputFileStream(prefix, extension) {
+  const path = createOutputFilePath(prefix, extension);
+  return { path, stream: createWriteStream(path, { mode: OUTPUT_FILE_MODE, flags: "wx" }) };
+}
+
+// node_modules/@earendil-works/pi-coding-agent/dist/core/tools/truncate.js
+var DEFAULT_MAX_LINES = 2000;
+var DEFAULT_MAX_BYTES = 50 * 1024;
+var GREP_MAX_LINE_LENGTH = 500;
+function splitLinesForCounting(content) {
+  if (content.length === 0) {
+    return [];
+  }
+  const lines = content.split(`
+`);
+  if (content.endsWith(`
+`)) {
+    lines.pop();
+  }
+  return lines;
+}
+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`;
+  }
+}
+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(`
+`);
+  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
+  };
+}
+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(`
+`);
+  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
+  };
+}
+function truncateStringToBytesFromEnd(str, maxBytes) {
+  const buf = Buffer.from(str, "utf-8");
+  if (buf.length <= maxBytes) {
+    return str;
+  }
+  let start = buf.length - maxBytes;
+  while (start < buf.length && (buf[start] & 192) === 128) {
+    start++;
+  }
+  return buf.slice(start).toString("utf-8");
+}
+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 };
+}
+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 = (index) => index >= buf.length || (buf[index] & 192) !== 128;
+  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}…${removedChars} chars truncated…${tail}`,
+    truncated: true,
+    removedChars,
+    totalBytes: buf.length,
+    totalLines
+  };
+}
+
 // node_modules/@earendil-works/pi-coding-agent/dist/core/usage-totals.js
 function createUsageTotals() {
   return {
@@ -103,82 +327,23 @@ var IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 var INDENT = "  ";
 var DEFAULT_INPUT_SCHEMA_MAX_CHARS = 16000;
 var MAX_REF_EXPANSIONS = 32;
-var MCP_TYPESCRIPT_PREAMBLE = `type Role = "user" | "assistant";
-type MetaObject = Record<string, unknown>;
-type Annotations = {
-  audience?: Role[];
-  priority?: number;
-  lastModified?: string;
-};
-type Icon = {
-  src: string;
-  mimeType?: string;
-  sizes?: string[];
-  theme?: "light" | "dark";
-};
-type TextResourceContents = {
-  uri: string;
-  mimeType?: string;
-  _meta?: MetaObject;
-  text: string;
-};
-type BlobResourceContents = {
-  uri: string;
-  mimeType?: string;
-  _meta?: MetaObject;
-  blob: string;
-};
-type TextContent = {
-  type: "text";
-  text: string;
-  annotations?: Annotations;
-  _meta?: MetaObject;
-};
-type ImageContent = {
-  type: "image";
-  data: string;
-  mimeType: string;
-  annotations?: Annotations;
-  _meta?: MetaObject;
-};
-type AudioContent = {
-  type: "audio";
-  data: string;
-  mimeType: string;
-  annotations?: Annotations;
-  _meta?: MetaObject;
-};
-type ResourceLink = {
-  icons?: Icon[];
-  name: string;
-  title?: string;
-  uri: string;
-  description?: string;
-  mimeType?: string;
-  annotations?: Annotations;
-  size?: number;
-  _meta?: MetaObject;
-  type: "resource_link";
-};
-type EmbeddedResource = {
-  type: "resource";
-  resource: TextResourceContents | BlobResourceContents;
-  annotations?: Annotations;
-  _meta?: MetaObject;
-};
-type ContentBlock =
-  | TextContent
-  | ImageContent
-  | AudioContent
-  | ResourceLink
-  | EmbeddedResource;
-type CallToolResult<TStructured = { [key: string]: unknown }> = {
-  _meta?: MetaObject;
-  content: ContentBlock[];
-  isError?: boolean;
-  structuredContent?: TStructured;
-  [key: string]: unknown;
-};`;
+var TAG_KEYWORDS = [
+  "minimum",
+  "exclusiveMinimum",
+  "maximum",
+  "exclusiveMaximum",
+  "multipleOf",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "format",
+  "minItems",
+  "maxItems"
+];
+var LOWER_BOUNDS = new Set(["minimum", "exclusiveMinimum", "minLength", "minItems"]);
+var UPPER_BOUNDS = 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 === undefined ? "unknown" : schemaToType(tool.inputSchema, { maxChars: options.inputMaxChars ?? DEFAULT_INPUT_SCHEMA_MAX_CHARS });
   return `${toCodemodeIdentifier(tool.name)}(args: ${input}): Promise<${renderToolOutputType(tool.outputSchema)}>;`;
@@ -192,31 +357,12 @@ codemode tool declaration:
 ${declaration}
 \`\`\``;
 }
-function mcpStructuredContentSchema(schema) {
-  if (!isObject(schema) || !isObject(schema.properties))
-    return;
-  const { content, isError, _meta, structuredContent } = schema.properties;
-  if (!isObject(content) || content.type !== "array" || !isObject(content.items) || content.items.type !== "object") {
-    return;
-  }
-  if (!isObject(isError) || isError.type !== "boolean" || !isObject(_meta) || _meta.type !== "object")
-    return;
-  return isObject(structuredContent) || typeof structuredContent === "boolean" ? structuredContent : true;
-}
 function renderToolOutputType(schema) {
-  const structured = mcpStructuredContentSchema(schema);
-  if (structured !== undefined) {
-    const type = schemaToType(structured);
-    return type === "unknown" ? "CallToolResult" : `CallToolResult<${type}>`;
-  }
   return schema === undefined ? "unknown" : schemaToType(schema);
 }
 function propertyKey(name) {
   return IDENTIFIER.test(name) ? name : JSON.stringify(name);
 }
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function union(types) {
   const unique = [...new Set(types)];
   if (unique.includes("unknown"))
@@ -224,8 +370,12 @@ function union(types) {
   return unique.length === 0 ? "never" : unique.join(" | ");
 }
 function schemaToType(schema, options = {}) {
-  const type = toType(schema, { root: schema, resolving: new Set, expansions: 0 });
-  return options.maxChars !== undefined && type.length > options.maxChars ? "unknown" : type;
+  const render = (tags) => toType(schema, { root: schema, resolving: new Set, expansions: 0, tags });
+  const type = render(true);
+  if (options.maxChars === undefined || type.length <= options.maxChars)
+    return type;
+  const untagged = render(false);
+  return untagged.length <= options.maxChars ? untagged : "unknown";
 }
 function resolveRef(ref, root) {
   if (ref !== "#" && !ref.startsWith("#/"))
@@ -233,18 +383,21 @@ function resolveRef(ref, root) {
   let current = root;
   for (const segment of ref.slice(2).split("/").filter(Boolean)) {
     const key = decodeURIComponent(segment).replaceAll("~1", "/").replaceAll("~0", "~");
-    if (!isObject(current) || !(key in current))
+    if (typeof current !== "object" || current === null || Array.isArray(current) || !(key in current)) {
       return;
+    }
     current = current[key];
   }
-  return typeof current === "boolean" || isObject(current) ? current : undefined;
+  if (typeof current === "boolean")
+    return current;
+  return typeof current === "object" && current !== null && !Array.isArray(current) ? current : undefined;
 }
 function toType(schema, context) {
   if (schema === true)
     return "unknown";
   if (schema === false)
     return "never";
-  if (!isObject(schema))
+  if (typeof schema !== "object" || schema === null || Array.isArray(schema))
     return "unknown";
   if (typeof schema.$ref === "string") {
     const ref = schema.$ref;
@@ -310,10 +463,51 @@ function arrayType(schema, context) {
   return "unknown[]";
 }
 function descriptionOf(property) {
-  return isObject(property) && typeof property.description === "string" ? property.description.trim() : "";
+  const description = property?.description;
+  return typeof description === "string" ? description.trim() : "";
+}
+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] : undefined;
+  const branches = typeof branch === "object" && branch !== null && !Array.isArray(branch) ? [property, branch] : [property];
+  const schemas = branches.map((schema2) => ({
+    ...schema2,
+    ...schema2.exclusiveMinimum === true ? { minimum: undefined, exclusiveMinimum: schema2.minimum } : {},
+    ...schema2.exclusiveMaximum === true ? { maximum: undefined, exclusiveMaximum: schema2.maximum } : {}
+  }));
+  const tags = [];
+  const isInteger = (type) => type === "integer" || Array.isArray(type) && type.includes("integer");
+  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 !== undefined && 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(" ");
 }
 function objectType(schema, context) {
-  const properties = isObject(schema.properties) ? schema.properties : {};
+  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) => {
@@ -329,14 +523,17 @@ function objectType(schema, context) {
   }
   if (members.length === 0)
     return "{}";
-  if (!names.some((name) => descriptionOf(properties[name])))
+  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 = ["{"];
-  names.forEach((name, index) => {
-    for (const line of descriptionOf(properties[name]).split(/\r?\n/)) {
-      if (line.trim())
-        lines.push(`${INDENT}// ${line.trim()}`);
-    }
+  comments.forEach((comment, index) => {
+    for (const line of comment)
+      lines.push(`${INDENT}// ${line}`);
     lines.push(`${INDENT}${members[index].replaceAll(`
 `, `
 ${INDENT}`)}`);
@@ -411,9 +608,15 @@ 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(`
+`);
+  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(`
 `);
-  const firstLine = (newline === -1 ? input : input.slice(0, newline)).replace(/\r$/, "");
+  const firstLine = lines[0].replace(/\r$/, "");
   const trimmed = firstLine.trimStart();
   if (!trimmed.startsWith(CODEMODE_OPTIONS_PREFIX))
     return { code: input, options: {} };
@@ -462,15 +665,15 @@ function stem(term) {
 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);
 }
-function isObject2(value) {
+function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function schemaText(schema, parts) {
-  if (!isObject2(schema))
+  if (!isObject(schema))
     return;
   if (typeof schema.description === "string")
     parts.push(schema.description);
-  if (isObject2(schema.properties)) {
+  if (isObject(schema.properties)) {
     for (const [name, property] of Object.entries(schema.properties)) {
       parts.push(name);
       schemaText(property, parts);
@@ -535,9 +738,6 @@ var toolSearchSchema = exports_typebox.Object({
   query: exports_typebox.String({ description: "Search query for deferred tools." }),
   limit: exports_typebox.Optional(exports_typebox.Number({ description: `Maximum number of tools to return. Defaults to ${DEFAULT_TOOL_SEARCH_LIMIT}.` }))
 });
-function isToolSearchTool(tool) {
-  return tool.name === TOOL_SEARCH_TOOL_NAME && tool.parameters === toolSearchSchema;
-}
 function isSearchable(exposure) {
   return exposure === "codemode" || exposure === "deferred";
 }
@@ -566,6 +766,7 @@ function createToolSearchToolDefinition(options = {}) {
     promptSnippet: "Search for tools that are not loaded yet and load the matches",
     parameters: toolSearchSchema,
     exposure: "model-only",
+    reachesTools: () => "all",
     async execute(_toolCallId, { query, limit }) {
       if (query.trim() === "")
         throw new Error("query must not be empty");
@@ -582,7 +783,72 @@ ${tools.map((tool) => `- ${tool.name}: ${tool.description.trim().split(/\r?\n/)[
 }
 
 // node_modules/@earendil-works/pi-coding-agent/dist/extensions/codemode/tool.js
-import { join } from "node:path";
+import { join as join2 } from "node:path";
+
+// node_modules/@earendil-works/pi-coding-agent/dist/core/settings-defaults.js
+var SETTINGS_DEFAULTS = {
+  transport: "auto",
+  steeringMode: "one-at-a-time",
+  followUpMode: "one-at-a-time",
+  compaction: {
+    enabled: true,
+    reserveTokens: 16384,
+    keepRecentTokens: 20000
+  },
+  branchSummary: {
+    reserveTokens: 16384,
+    skipPrompt: false
+  },
+  retry: {
+    enabled: true,
+    maxRetries: 3,
+    baseDelayMs: 2000,
+    maxAgentDelayMs: DEFAULT_MAX_AGENT_RETRY_DELAY_MS,
+    provider: {
+      maxRetryDelayMs: 60000
+    }
+  },
+  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: 3000
+  },
+  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) {
@@ -613,13 +879,211 @@ function createToolDefinitionFromAgentTool(tool) {
 }
 
 // node_modules/@earendil-works/pi-coding-agent/dist/extensions/codemode/execute.lazy.js
-var loadCodemodeExecutor = () => import("./execute-h4jgevyw.js");
+var loadCodemodeExecutor = () => import("./execute-107xtsp1.js");
+
+// 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("›")) {
+    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) };
+}
+function stripAnsi(value) {
+  if (typeof value !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof value}\``);
+  }
+  if (!value.includes("\x1B") && !value.includes("›")) {
+    return value;
+  }
+  return value.replace(ansiRegex, "");
+}
+
+// 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;
+}
+function linkPath(styledText, rawPath, cwd) {
+  if (!getCapabilities().hyperlinks)
+    return styledText;
+  const absolutePath = resolvePath(rawPath, cwd);
+  return hyperlink(styledText, pathToFileURL(absolutePath).href);
+}
+function str(value) {
+  if (typeof value === "string")
+    return value;
+  if (value == null)
+    return "";
+  return null;
+}
+function replaceTabs(text) {
+  return text.replace(/\t/g, "   ");
+}
+function normalizeDisplayText(text) {
+  return text.replace(/\r/g, "");
+}
+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(`
+`);
+  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) ?? undefined : undefined;
+      return imageFallback(mimeType, dims);
+    }).join(`
+`);
+    output = output ? `${output}
+${imageIndicators}` : imageIndicators;
+  }
+  return output;
+}
+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(`
+`).join(`
+    `)}`;
+    });
+    return `${header}
+${theme.fg("muted", lines.join(`
+`))}`;
+  }
+  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)}`;
+}
+function formatToolDuration(ms) {
+  const seconds = ms / 1000;
+  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`;
+}
+function startToolTimer(context) {
+  const state = context.state;
+  if (context.executionStarted && state.startedAt === undefined) {
+    state.startedAt = Date.now();
+    state.endedAt = undefined;
+  }
+}
+function toolTimerText(context, isPartial) {
+  const state = context.state;
+  if (state.startedAt !== undefined && isPartial && !state.interval) {
+    state.interval = setInterval(() => context.invalidate(), 1000);
+  }
+  if (!isPartial || context.isError) {
+    state.endedAt ??= Date.now();
+    if (state.interval) {
+      clearInterval(state.interval);
+      state.interval = undefined;
+    }
+  }
+  if (!isPartial && context.durationMs !== undefined)
+    return `Took ${formatToolDuration(context.durationMs)}`;
+  if (state.startedAt === undefined)
+    return;
+  const endTime = state.endedAt ?? Date.now();
+  return `${isPartial ? "Elapsed" : "Took"} ${formatToolDuration(endTime - state.startedAt)}`;
+}
+function invalidArgText(theme) {
+  return theme.fg("error", "[invalid arg]");
+}
+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);
+}
+
+// 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 };
+}
+
+class VisualLinePreview {
+  options;
+  cachedWidth;
+  cachedLines;
+  constructor(options) {
+    this.options = options;
+  }
+  render(width) {
+    if (this.cachedLines === undefined || 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 = undefined;
+    this.cachedLines = undefined;
+  }
+}
 
 // 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_CHARS = 80;
+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", ")")}`;
@@ -645,7 +1109,7 @@ function statusIcon(call, theme) {
   }
 }
 function formatCall(call, theme, expanded) {
-  const args = !expanded && call.args.length > COLLAPSED_ARGS_CHARS ? `${call.args.slice(0, COLLAPSED_ARGS_CHARS - 3)}...` : call.args;
+  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)
@@ -663,6 +1127,7 @@ function formatCall(call, theme, expanded) {
 }
 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;
@@ -685,6 +1150,7 @@ var codemodeRenderers = {
     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 ?? [];
@@ -726,6 +1192,10 @@ var codemodeRenderers = {
           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;
   }
 };
@@ -739,18 +1209,15 @@ var codemodeSchema = exports_typebox.Object({
     description: "Raw JavaScript source."
   })
 });
-function isCodemodeTool(tool) {
-  return tool.name === CODEMODE_TOOL_NAME && tool.parameters === codemodeSchema;
-}
 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 = join(getDocsPath(), "codemode.md");
+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. Calls still running when the script ends are cancelled.
+- \`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 = [
@@ -765,7 +1232,7 @@ function describeGlobals(models) {
   return lines.join(`
 `);
 }
-var DEFAULT_CODEMODE_INLINE_BUDGET = 3000;
+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()}`] : []);
@@ -822,12 +1289,6 @@ function createCodemodeDescription(tools, options = {}) {
   const ordered = [...groups.values()].sort((a, b) => a.namespace === undefined ? -1 : b.namespace === undefined ? 1 : a.namespace.name.localeCompare(b.namespace.name));
   const shown = selectCatalog(ordered, options.inlineBudget);
   const sections = [DESCRIPTION_INTRO, describeGlobals(options.models === true)];
-  if (declarations.some((declaration) => shown.has(declaration.name) && mcpStructuredContentSchema(declaration.outputSchema) !== undefined)) {
-    sections.push(`Shared MCP Types:
-\`\`\`ts
-${MCP_TYPESCRIPT_PREAMBLE}
-\`\`\``);
-  }
   if (declarations.length === 0)
     return sections.join(`
 
@@ -851,18 +1312,25 @@ ${description}` : ""}`);
 
 `);
 }
+function describeFields(schema, depth) {
+  if (typeof schema !== "object" || schema === null)
+    return;
+  const { type, properties, required } = schema;
+  if (type !== "object" || typeof properties !== "object" || properties === null)
+    return;
+  const requiredNames = new Set(Array.isArray(required) ? required : []);
+  const fields = Object.entries(properties).map(([name, field]) => {
+    const nested = depth > 0 ? describeFields(field, depth - 1) : undefined;
+    return `${name}${requiredNames.has(name) ? "" : "?"}${nested ? `: ${nested}` : ""}`;
+  });
+  return `{ ${fields.join(", ")} }`;
+}
 function describeOutput(schema) {
   const type = renderToolOutputType(schema);
   if (type === "string")
     return "a string";
-  const object = typeof schema === "object" ? schema : undefined;
-  const properties = object?.properties;
-  if (object?.type === "object" && typeof properties === "object" && properties !== null && mcpStructuredContentSchema(schema) === undefined) {
-    const required = new Set(Array.isArray(object.required) ? object.required : []);
-    const fields = Object.keys(properties).map((name) => required.has(name) ? name : `${name}?`);
-    return `\`{ ${fields.join(", ")} }\``;
-  }
-  return `\`${type.replace(/\s+/g, " ")}\``;
+  const fields = describeFields(schema, 1);
+  return `\`${fields ?? type.replace(/\s+/g, " ")}\``;
 }
 function describeScriptCall(tool) {
   return `${tool.description.trim()}
@@ -870,7 +1338,7 @@ function describeScriptCall(tool) {
 Codemode: \`tools.${toCodemodeIdentifier(tool.name)}(args)\` resolves to ${describeOutput(toCodemodeDeclaration(tool).outputSchema)}.`;
 }
 function prepareCodemodeLoadout(loadout, options) {
-  const mode = options.getMode?.() ?? "on";
+  const mode = options.getMode?.() ?? SETTINGS_DEFAULTS.codemode.mode;
   const isDirect = (tool) => loadout.getExposure(tool.name) === "direct";
   const callable = getCodemodeCallableTools(loadout.callable);
   const callableNames = new Set(callable.map((tool) => tool.name));
@@ -900,6 +1368,12 @@ function prepareCodemodeLoadout(loadout, options) {
     hiddenDeclarations: mode === "only" ? callable.filter((tool) => isDirect(tool) && declaredNames.has(tool.name)).map((tool) => tool.name) : []
   };
 }
+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) ?? [];
+}
 function createCodemodeToolDefinition(options = {}) {
   return {
     name: CODEMODE_TOOL_NAME,
@@ -910,10 +1384,11 @@ function createCodemodeToolDefinition(options = {}) {
     parameters: codemodeSchema,
     exposure: "model-only",
     prepareLoadout: (loadout) => prepareCodemodeLoadout(loadout, options),
+    reachesTools: (input) => getScriptReach(input.code),
     constrainedSampling: { type: "grammar", variants: { openai_lark: CODEMODE_SOURCE_GRAMMAR } },
     execute: async (toolCallId, params, signal, onUpdate, ctx) => (await loadCodemodeExecutor()).executeCodemode(toolCallId, params, signal, onUpdate, ctx, options),
     ...codemodeRenderers
   };
 }
 
-export { createUsageTotals, addUsageToTotals, combineUsage, getUsageCostBreakdown, wrapToolDefinition, createToolDefinitionFromAgentTool, toCodemodeIdentifier, renderToolSample, parseCodemodeSource, TOOL_SEARCH_TOOL_NAME, DEFAULT_TOOL_SEARCH_LIMIT, createToolSearchDocument, Bm25Ranker, isToolSearchTool, createToolSearchToolDefinition, CODEMODE_TOOL_NAME, CODEMODE_STORE_ENTRY_TYPE, isCodemodeTool, CODEMODE_DOCS_PATH, toCodemodeDeclaration, getCodemodeCallableTools, 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, 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 };