kimiflare 0.16.0 → 0.17.0

package/dist/index.js

@@ -872,22 +872,18 @@ function isReadOnlyBash(command) {
         return false;
     }
   }
-  const argCheck = COMMANDS_NEEDING_ARG_CHECK[cmd];
-  if (argCheck) {
-    return argCheck(args);
-  }
   return READONLY_COMMANDS.has(cmd);
 }
 function systemPromptForMode(m) {
   if (m === "plan") {
-    return "\n\nPLAN MODE is active. The user wants you to investigate and produce a plan WITHOUT making any changes. Do not call write, edit, or mutating bash commands. You may use read-only bash commands (e.g., git log, git diff, ls, cat) along with read/glob/grep/web-fetch. At the end, present a concise plan (bullets, files to change, approach). The user will review and then exit plan mode to execute.";
+    return "\n\nPLAN MODE is active. The user wants you to investigate and produce a plan WITHOUT making any changes. Do not call write, edit, or mutating bash commands. You may use read-only bash commands (e.g., git log, git diff, ls, cat, grep) along with read/glob/grep/web-fetch. Scripting interpreters (node, python3, ruby, perl, awk) and build/package tools (npm, cargo, go, tsc, jest, etc.) are blocked in plan mode. At the end, present a concise plan (bullets, files to change, approach). The user will review and then exit plan mode to execute.";
   }
   if (m === "auto") {
     return "\n\nAUTO MODE is active. The user has opted into autonomous execution \u2014 every tool call will be auto-approved. Work efficiently, but do not take irreversible destructive actions (rm -rf, git push --force, dropping tables, etc.) without pausing to describe them in chat first. Prefer smaller reversible steps.";
   }
   return "";
 }
-var MODES, MUTATING_TOOLS, DANGEROUS_PATTERNS, GIT_READONLY_SUBCOMMANDS, READONLY_COMMANDS, COMMANDS_NEEDING_ARG_CHECK;
+var MODES, MUTATING_TOOLS, DANGEROUS_PATTERNS, GIT_READONLY_SUBCOMMANDS, READONLY_COMMANDS;
 var init_mode = __esm({
   "src/mode.ts"() {
     "use strict";
@@ -958,16 +954,8 @@ var init_mode = __esm({
       "id",
       "whoami",
       "groups",
-      // Dev tools (version/info only)
-      "node",
-      "npx",
-      "python3",
-      "ruby",
-      "perl",
       // Utilities
       "jq",
-      "yq",
-      "awk",
       "cut",
       "tr",
       "base64",
@@ -990,32 +978,6 @@ var init_mode = __esm({
       "ss",
       "lsof"
     ]);
-    COMMANDS_NEEDING_ARG_CHECK = {
-      find: (args) => !args.some((a) => a === "-delete" || a === "-exec"),
-      sed: (args) => !args.some((a) => a === "-i" || a.startsWith("-i")),
-      tar: (args) => args[0] === "-tf" || args[0] === "--list",
-      unzip: (args) => args[0] === "-l",
-      curl: (args) => !args.some((a) => a === "-o" || a === "-O" || a === "-d" || a === "--data" || a.startsWith("-X")),
-      wget: (args) => !args.some((a) => a === "-O" || a === "--output-document" || a.startsWith("--post")),
-      npm: (args) => ["list", "view", "config"].includes(args[0] ?? "") && !(args[0] === "config" && args[1] && !args[1].startsWith("get") && args[1] !== "list"),
-      tsc: (args) => args.every(
-        (a) => ["--noEmit", "--version", "--showConfig", "--help", "-h", "--init"].includes(a)
-      ),
-      eslint: (args) => args.every(
-        (a) => ["--version", "--print-config", "--help", "-h"].includes(a) || !a.startsWith("-")
-      ),
-      prettier: (args) => args.every(
-        (a) => ["--version", "--check", "--help", "-h"].includes(a) || !a.startsWith("-")
-      ),
-      jest: (args) => args.every(
-        (a) => ["--version", "--listTests", "--showConfig", "--help", "-h"].includes(a) || !a.startsWith("-")
-      ),
-      vitest: (args) => args.every(
-        (a) => ["--version", "--help", "-h"].includes(a) || !a.startsWith("-")
-      ),
-      go: (args) => ["version", "env", "list", "mod"].includes(args[0] ?? "") && !(args[0] === "mod" && args[1] && !["graph", "download", "why", "verify"].includes(args[1])),
-      cargo: (args) => ["--version", "-V", "check", "test", "metadata"].includes(args[0] ?? "") && !(args[0] === "test" && args.includes("--no-run") === false)
-    };
   }
 });
 
@@ -1049,7 +1011,12 @@ How to work:
 - You have a 262k-token context window. Read as much of a file as needed rather than guessing.
 - If a request is ambiguous, ask one focused question instead of making large assumptions.
 - When you finish a task, stop. Do not add a closing summary.
-- When creating git commits, you must include \`Co-authored-by: kimiflare <kimiflare@proton.me>\` in the commit message so kimiflare is credited as a contributor. The bash tool will also auto-append this trailer when it detects git commit-creating commands.`;
+- When creating git commits, you must include \`Co-authored-by: kimiflare <kimiflare@proton.me>\` in the commit message so kimiflare is credited as a contributor. The bash tool will also auto-append this trailer when it detects git commit-creating commands.
+
+Tool output reduction:
+- Large tool outputs (grep, read, bash, web_fetch) are reduced to compact summaries by default to preserve context window.
+- When you see "[output reduced]" with an artifact ID, you can call \`expand_artifact\` with that ID to retrieve the full raw output if you need more detail.
+- You can also re-run the original tool with more targeted parameters (e.g. read with offset/limit, grep with output_mode="files") instead of expanding.`;
 }
 function buildSessionPrefix(opts2) {
   const now2 = opts2.now ?? /* @__PURE__ */ new Date();
@@ -1103,11 +1070,6 @@ function resolvePath(cwd, input) {
   }
   return isAbsolute(input) ? input : resolve(cwd, input);
 }
-function truncate(s, n) {
-  if (s.length <= n) return s;
-  return s.slice(0, n) + `
-... [truncated, ${s.length - n} chars omitted]`;
-}
 function collapsePath(input, cwd, maxLen = 40) {
   if (!input) return input;
   let abs;
@@ -1144,7 +1106,7 @@ var init_read = __esm({
     MAX_BYTES = 2 * 1024 * 1024;
     readTool = {
       name: "read",
-      description: "Read a text file from the local filesystem. Supports optional line offset/limit. Refuses files larger than 2MB. Returns contents with 1-indexed line numbers prefixed, cat -n style.",
+      description: "Read a text file from the local filesystem. Supports optional line offset/limit. Refuses files larger than 2MB. Returns contents with 1-indexed line numbers prefixed, cat -n style. When reading a full file without offset/limit, the output is reduced to a compact outline (imports, exports, signatures, preview) by default; use expand_artifact to retrieve the full content or specify offset/limit for a targeted slice.",
       parameters: {
         type: "object",
         properties: {
@@ -1340,26 +1302,23 @@ ${stdout.trimEnd()}`);
 ${stderr.trimEnd()}`);
       if (!stdout && !stderr) parts.push("(no output)");
       const raw = parts.join("\n");
-      const reduced = truncate(raw, OUTPUT_CAP);
       resolve2({
-        content: reduced,
+        content: raw,
         rawBytes: Buffer.byteLength(raw, "utf8"),
-        reducedBytes: Buffer.byteLength(reduced, "utf8")
+        reducedBytes: Buffer.byteLength(raw, "utf8")
       });
     });
   });
 }
-var DEFAULT_TIMEOUT, MAX_TIMEOUT, OUTPUT_CAP, bashTool;
+var DEFAULT_TIMEOUT, MAX_TIMEOUT, bashTool;
 var init_bash = __esm({
   "src/tools/bash.ts"() {
     "use strict";
-    init_paths();
     DEFAULT_TIMEOUT = 12e4;
     MAX_TIMEOUT = 6e5;
-    OUTPUT_CAP = 3e4;
     bashTool = {
       name: "bash",
-      description: "Run a shell command via `bash -lc`. Prompts the user for permission before executing. stdout and stderr are captured, combined, and capped at 30KB.",
+      description: "Run a shell command via `bash -lc`. Prompts the user for permission before executing. stdout and stderr are captured and combined. Large outputs are reduced to a compact summary by default; use expand_artifact to retrieve the full log.",
       parameters: {
         type: "object",
         properties: {
@@ -1444,11 +1403,10 @@ async function runRipgrep(args, root, mode) {
     const { stdout } = await pExecFile("rg", rgArgs, { maxBuffer: 10 * 1024 * 1024 });
     const trimmed = stdout.trim();
     if (!trimmed) return { content: "(no matches)", rawBytes: 0, reducedBytes: 0 };
-    const reduced = truncate(trimmed, 3e4);
     return {
-      content: reduced,
+      content: trimmed,
       rawBytes: Buffer.byteLength(trimmed, "utf8"),
-      reducedBytes: Buffer.byteLength(reduced, "utf8")
+      reducedBytes: Buffer.byteLength(trimmed, "utf8")
     };
   } catch (e) {
     const err = e;
@@ -1487,11 +1445,10 @@ async function runJsFallback(args, root, mode) {
   }
   if (!out.length) return { content: "(no matches)", rawBytes: 0, reducedBytes: 0 };
   const raw = out.join("\n");
-  const reduced = truncate(raw, 3e4);
   return {
-    content: reduced,
+    content: raw,
     rawBytes: Buffer.byteLength(raw, "utf8"),
-    reducedBytes: Buffer.byteLength(reduced, "utf8")
+    reducedBytes: Buffer.byteLength(raw, "utf8")
   };
 }
 var pExecFile, cachedHasRg, grepTool;
@@ -1534,17 +1491,15 @@ var init_grep = __esm({
 
 // src/tools/web-fetch.ts
 import TurndownService from "turndown";
-var MAX_BYTES2, MAX_OUTPUT, TIMEOUT_MS, webFetchTool;
+var MAX_BYTES2, TIMEOUT_MS, webFetchTool;
 var init_web_fetch = __esm({
   "src/tools/web-fetch.ts"() {
     "use strict";
-    init_paths();
     MAX_BYTES2 = 1 * 1024 * 1024;
-    MAX_OUTPUT = 1e5;
     TIMEOUT_MS = 2e4;
     webFetchTool = {
       name: "web_fetch",
-      description: "Fetch a URL over HTTPS and return its content. HTML pages are converted to markdown. Output is capped at ~100KB.",
+      description: "Fetch a URL over HTTPS and return its content. HTML pages are converted to markdown. Large pages are reduced to a summary by default; use expand_artifact to retrieve the full content.",
       parameters: {
         type: "object",
         properties: {
@@ -1578,11 +1533,10 @@ ${td.turndown(bounded)}`;
 
 ${bounded}`;
           }
-          const reduced = truncate(raw, MAX_OUTPUT);
           return {
-            content: reduced,
+            content: raw,
             rawBytes: Buffer.byteLength(raw, "utf8"),
-            reducedBytes: Buffer.byteLength(reduced, "utf8")
+            reducedBytes: Buffer.byteLength(raw, "utf8")
           };
         } finally {
           clearTimeout(timer);
@@ -1674,6 +1628,423 @@ var init_tasks = __esm({
   }
 });
 
+// src/tools/artifact-store.ts
+var ToolArtifactStore;
+var init_artifact_store = __esm({
+  "src/tools/artifact-store.ts"() {
+    "use strict";
+    ToolArtifactStore = class {
+      artifacts = /* @__PURE__ */ new Map();
+      nextId = 0;
+      maxArtifacts;
+      maxTotalChars;
+      constructor(opts2) {
+        this.maxArtifacts = opts2?.maxArtifacts ?? 500;
+        this.maxTotalChars = opts2?.maxTotalChars ?? 2e6;
+      }
+      /** Store raw content and return a stable artifact ID. */
+      store(raw) {
+        const id = `art_${++this.nextId}`;
+        while (this.totalChars() + raw.length > this.maxTotalChars && this.artifacts.size > 0) {
+          this.evictOldest();
+        }
+        while (this.artifacts.size >= this.maxArtifacts && this.artifacts.size > 0) {
+          this.evictOldest();
+        }
+        this.artifacts.set(id, raw);
+        return id;
+      }
+      retrieve(id) {
+        return this.artifacts.get(id);
+      }
+      has(id) {
+        return this.artifacts.has(id);
+      }
+      clear() {
+        this.artifacts.clear();
+        this.nextId = 0;
+      }
+      size() {
+        return this.artifacts.size;
+      }
+      totalChars() {
+        let sum = 0;
+        for (const raw of this.artifacts.values()) {
+          sum += raw.length;
+        }
+        return sum;
+      }
+      evictOldest() {
+        const first = this.artifacts.keys().next().value;
+        if (first !== void 0) {
+          this.artifacts.delete(first);
+        }
+      }
+    };
+  }
+});
+
+// src/tools/reducer.ts
+function reduceToolOutput(toolName, raw, args, store, config = DEFAULT_REDUCER_CONFIG) {
+  const rawBytes = Buffer.byteLength(raw, "utf8");
+  const artifactId = store.store(raw);
+  if (!config.enabled) {
+    return { content: raw, rawBytes, reducedBytes: rawBytes, artifactId };
+  }
+  let reduced;
+  let wasReduced = false;
+  let hint;
+  switch (toolName) {
+    case "grep": {
+      const r = reduceGrep(raw, args, config.grep);
+      reduced = r.body;
+      wasReduced = r.wasReduced;
+      hint = r.hint;
+      break;
+    }
+    case "read": {
+      const r = reduceRead(raw, args, config.read);
+      reduced = r.body;
+      wasReduced = r.wasReduced;
+      hint = r.hint;
+      break;
+    }
+    case "bash": {
+      const r = reduceBash(raw, args, config.bash);
+      reduced = r.body;
+      wasReduced = r.wasReduced;
+      hint = r.hint;
+      break;
+    }
+    case "web_fetch": {
+      const r = reduceWebFetch(raw, args, config.webFetch);
+      reduced = r.body;
+      wasReduced = r.wasReduced;
+      hint = r.hint;
+      break;
+    }
+    default:
+      reduced = raw;
+      break;
+  }
+  if (!wasReduced) {
+    return { content: reduced, rawBytes, reducedBytes: rawBytes, artifactId };
+  }
+  const footer = `[output reduced \u2014 full raw stored as artifact ${artifactId}]`;
+  const content = hint ? `${reduced}
+${footer}
+${hint}` : `${reduced}
+${footer}`;
+  const reducedBytes = Buffer.byteLength(content, "utf8");
+  return { content, rawBytes, reducedBytes, artifactId };
+}
+function parseGrepLines(raw) {
+  const matches = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const m = trimmed.match(/^(.+?):(\d+)?:(.*)$/);
+    if (m) {
+      matches.push({ file: m[1], line: m[2] ? parseInt(m[2], 10) : 0, text: m[3] });
+    } else {
+      matches.push({ file: trimmed, line: 0, text: "" });
+    }
+  }
+  return matches;
+}
+function reduceGrep(raw, args, cfg) {
+  const isFilesMode = args.output_mode === "files";
+  const matches = parseGrepLines(raw);
+  if (matches.length === 0) {
+    return { body: raw, wasReduced: false };
+  }
+  if (isFilesMode) {
+    const files = [...new Set(matches.map((m) => m.file))];
+    const lines2 = [`${files.length} file(s) matched:`, ...files];
+    return {
+      body: lines2.join("\n"),
+      wasReduced: true,
+      hint: 'Re-run with output_mode="content" for match details.'
+    };
+  }
+  const byFile = /* @__PURE__ */ new Map();
+  for (const m of matches) {
+    const list = byFile.get(m.file) ?? [];
+    list.push(m);
+    byFile.set(m.file, list);
+  }
+  const lines = [];
+  let totalShown = 0;
+  const totalHits = matches.length;
+  const fileCount = byFile.size;
+  lines.push(`Matched ${fileCount} file(s) (${totalHits} total hits):`);
+  for (const [file, hits] of byFile) {
+    if (totalShown >= cfg.maxTotalLines) break;
+    lines.push(`  ${file}: ${hits.length} hit(s)`);
+    const toShow = Math.min(hits.length, cfg.maxMatchesPerFile);
+    for (let i = 0; i < toShow; i++) {
+      const h = hits[i];
+      const text = h.text.length > cfg.maxLineLength ? h.text.slice(0, cfg.maxLineLength) + "\u2026" : h.text;
+      const prefix = h.line > 0 ? `    ${h.line}:` : "    ";
+      lines.push(`${prefix}${text}`);
+      totalShown++;
+      if (totalShown >= cfg.maxTotalLines) break;
+    }
+  }
+  if (totalShown < totalHits) {
+    lines.push(`  \u2026 (${totalHits - totalShown} more hits omitted)`);
+  }
+  return {
+    body: lines.join("\n"),
+    wasReduced: totalHits > totalShown || fileCount > 1,
+    hint: 'Use expand_artifact for full matches, or re-run with output_mode="files" for paths only.'
+  };
+}
+function reduceRead(raw, args, cfg) {
+  const hasSlice = typeof args.offset === "number" || typeof args.limit === "number";
+  if (hasSlice) {
+    const lines = raw.split("\n");
+    if (lines.length > cfg.maxSliceLines) {
+      const kept = lines.slice(0, cfg.maxSliceLines).join("\n");
+      return {
+        body: kept,
+        wasReduced: true,
+        hint: `\u2026 (${lines.length - cfg.maxSliceLines} more lines omitted)`
+      };
+    }
+    return { body: raw, wasReduced: false };
+  }
+  const allLines = raw.split("\n");
+  const totalLines = allLines.length;
+  const cleanLines = allLines.map((l) => l.replace(/^\s*\d+\t/, ""));
+  const imports = [];
+  const exports = [];
+  const functions = [];
+  const classes = [];
+  for (let i = 0; i < cleanLines.length; i++) {
+    const line = cleanLines[i];
+    const lineNum = i + 1;
+    if (/^import\s+/.test(line)) {
+      imports.push(`${lineNum}: ${line.trim()}`);
+    } else if (/^(?:export\s+)?class\s+\w+/.test(line)) {
+      classes.push(`${lineNum}: ${line.trim()}`);
+    } else if (/^export\s+/.test(line)) {
+      exports.push(`${lineNum}: ${line.trim()}`);
+    } else if (/^(?:async\s+)?function\s+\w+/.test(line)) {
+      functions.push(`${lineNum}: ${line.trim()}`);
+    }
+  }
+  const parts = [];
+  parts.push(`File: ${totalLines} lines total`);
+  if (imports.length > 0) {
+    parts.push(`
+Imports (${imports.length}):`);
+    parts.push(...imports.slice(0, Math.floor(cfg.maxOutlineLines / 4)));
+  }
+  if (exports.length > 0) {
+    parts.push(`
+Exports (${exports.length}):`);
+    parts.push(...exports.slice(0, Math.floor(cfg.maxOutlineLines / 4)));
+  }
+  if (functions.length > 0) {
+    parts.push(`
+Functions (${functions.length}):`);
+    parts.push(...functions.slice(0, Math.floor(cfg.maxOutlineLines / 4)));
+  }
+  if (classes.length > 0) {
+    parts.push(`
+Classes (${classes.length}):`);
+    parts.push(...classes.slice(0, Math.floor(cfg.maxOutlineLines / 4)));
+  }
+  const previewCount = Math.min(cfg.maxPreviewLines, totalLines);
+  parts.push(`
+Preview (lines 1\u2013${previewCount}):`);
+  parts.push(...allLines.slice(0, previewCount));
+  return {
+    body: parts.join("\n"),
+    wasReduced: true,
+    hint: "Use expand_artifact for full file, or read with offset/limit for a specific slice."
+  };
+}
+function reduceBash(raw, _args, cfg) {
+  const lines = raw.split("\n");
+  if (lines.length <= cfg.maxTotalLines) {
+    return { body: raw, wasReduced: false };
+  }
+  let header = "";
+  let bodyStart = 0;
+  if (lines[0]?.startsWith("exit=") || lines[0]?.startsWith("(timed out")) {
+    header = lines[0];
+    bodyStart = 1;
+  }
+  const body = lines.slice(bodyStart);
+  const isFailure = header.includes("exit=1") || raw.includes("Error:") || raw.includes("error:") || raw.includes("FAIL") || raw.includes("failed");
+  const out = [header];
+  if (isFailure) {
+    const errorIndices = [];
+    for (let i = 0; i < body.length; i++) {
+      const line = body[i];
+      if (/\bError\b/i.test(line) || /\berror\b/i.test(line) || /\bFAIL\b/i.test(line) || /\bfailed\b/i.test(line) || /^\s+at\s+/.test(line) || /\s+Error:\s+/.test(line)) {
+        for (let j = Math.max(0, i - 2); j <= Math.min(body.length - 1, i + 2); j++) {
+          if (!errorIndices.includes(j)) errorIndices.push(j);
+        }
+      }
+    }
+    errorIndices.sort((a, b) => a - b);
+    const cappedError = errorIndices.slice(0, cfg.maxErrorBlockLines);
+    if (cappedError.length > 0) {
+      out.push("--- error block ---");
+      for (const idx of cappedError) {
+        out.push(body[idx]);
+      }
+    }
+    const testNames = [];
+    for (const line of body) {
+      const m = line.match(/(?:✗|✕|×|FAIL)\s+(.+)/) || line.match(/failing\s*\d*\s*:?\s*(.+)/i) || line.match(/Test\s+\w+\s+failed/i);
+      if (m && m[1]) {
+        const name = m[1].trim().slice(0, 120);
+        if (!testNames.includes(name)) testNames.push(name);
+      }
+    }
+    if (testNames.length > 0) {
+      out.push("--- failing tests ---");
+      out.push(...testNames.slice(0, 10));
+    }
+  }
+  const trailing = body.slice(-cfg.maxTrailingLines);
+  out.push("--- last lines ---");
+  out.push(...trailing);
+  let result = out.join("\n");
+  if (cfg.dedupeConsecutiveLines) {
+    result = dedupeConsecutive(result);
+  }
+  return {
+    body: result,
+    wasReduced: true,
+    hint: "Use expand_artifact for full output."
+  };
+}
+function dedupeConsecutive(text) {
+  const lines = text.split("\n");
+  const out = [];
+  let repeatCount = 1;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const next = lines[i + 1];
+    if (next !== void 0 && next === line) {
+      repeatCount++;
+      continue;
+    }
+    if (repeatCount > 2) {
+      out.push(line);
+      out.push(`\u2026 (${repeatCount - 1} identical lines omitted)`);
+    } else {
+      for (let j = 0; j < repeatCount; j++) {
+        out.push(line);
+      }
+    }
+    repeatCount = 1;
+  }
+  return out.join("\n");
+}
+function reduceWebFetch(raw, args, cfg) {
+  const url = typeof args.url === "string" ? args.url : "(unknown URL)";
+  const titleMatch = raw.match(/^#\s+(.+)$/m);
+  const title = titleMatch ? titleMatch[1].trim() : "(no title)";
+  const parts = [];
+  parts.push(`Title: ${title}`);
+  parts.push(`URL: ${url}`);
+  const headings = raw.match(/^#{1,3}\s+.+$/gm) ?? [];
+  if (headings.length > 0) {
+    parts.push("\nSections:");
+    for (const h of headings.slice(0, 10)) {
+      parts.push(`  ${h}`);
+    }
+  }
+  const bodyStart = raw.indexOf("\n\n");
+  const body = bodyStart > 0 ? raw.slice(bodyStart + 2) : raw;
+  const excerpt = body.slice(0, cfg.maxChars).trim();
+  if (excerpt) {
+    parts.push(`
+Excerpt (${excerpt.length} chars):`);
+    parts.push(excerpt);
+  }
+  if (body.length > cfg.maxChars) {
+    parts.push(`
+\u2026 (${body.length - cfg.maxChars} more chars omitted)`);
+  }
+  return {
+    body: parts.join("\n"),
+    wasReduced: true,
+    hint: "Use expand_artifact for full page content."
+  };
+}
+var DEFAULT_REDUCER_CONFIG;
+var init_reducer = __esm({
+  "src/tools/reducer.ts"() {
+    "use strict";
+    DEFAULT_REDUCER_CONFIG = {
+      enabled: true,
+      grep: {
+        maxTotalLines: 50,
+        maxMatchesPerFile: 3,
+        maxLineLength: 200,
+        maxOutputChars: 3e3
+      },
+      read: {
+        maxOutlineLines: 60,
+        maxSliceLines: 200,
+        maxPreviewLines: 30,
+        maxOutputChars: 4e3
+      },
+      bash: {
+        maxTotalLines: 40,
+        maxErrorBlockLines: 20,
+        maxTrailingLines: 20,
+        maxOutputChars: 4e3,
+        dedupeConsecutiveLines: true
+      },
+      webFetch: {
+        maxChars: 2e3,
+        maxHeadingChars: 500
+      }
+    };
+  }
+});
+
+// src/tools/expand-artifact.ts
+function makeExpandArtifactTool(store) {
+  return {
+    name: "expand_artifact",
+    description: "Retrieve the full raw content of a previously reduced tool output by its artifact ID. Use this when the compact summary is insufficient and you need the complete original output.",
+    parameters: {
+      type: "object",
+      properties: {
+        artifact_id: {
+          type: "string",
+          description: "The artifact ID from a reduced tool output footer, e.g. art_42."
+        }
+      },
+      required: ["artifact_id"],
+      additionalProperties: false
+    },
+    needsPermission: false,
+    render: (args) => ({ title: `expand ${args.artifact_id}` }),
+    run: async (args) => {
+      const raw = store.retrieve(args.artifact_id);
+      if (!raw) {
+        return `Artifact "${args.artifact_id}" not found. It may have been evicted from memory. Re-run the original tool to regenerate the output.`;
+      }
+      return raw;
+    }
+  };
+}
+var init_expand_artifact = __esm({
+  "src/tools/expand-artifact.ts"() {
+    "use strict";
+  }
+});
+
 // src/tools/executor.ts
 function normalizeToolOutput(result) {
   if (typeof result === "string") {
@@ -1697,6 +2068,9 @@ var init_executor = __esm({
     init_grep();
     init_web_fetch();
     init_tasks();
+    init_artifact_store();
+    init_reducer();
+    init_expand_artifact();
     ALL_TOOLS = [
       readTool,
       writeTool,
@@ -1710,8 +2084,11 @@ var init_executor = __esm({
     ToolExecutor = class {
       sessionAllowed = /* @__PURE__ */ new Set();
       tools;
+      artifactStore;
       constructor(tools = ALL_TOOLS) {
         this.tools = new Map(tools.map((t) => [t.name, t]));
+        this.artifactStore = new ToolArtifactStore();
+        this.tools.set("expand_artifact", makeExpandArtifactTool(this.artifactStore));
       }
       list() {
         return [...this.tools.values()];
@@ -1725,6 +2102,9 @@ var init_executor = __esm({
       clearSessionPermissions() {
         this.sessionAllowed.clear();
       }
+      clearArtifacts() {
+        this.artifactStore.clear();
+      }
       async run(call, askPermission, ctx) {
         const tool = this.tools.get(call.name);
         if (!tool) {
@@ -1764,13 +2144,21 @@ var init_executor = __esm({
         try {
           const result = await tool.run(args, ctx);
           const normalized = normalizeToolOutput(result);
+          const reduced = reduceToolOutput(
+            call.name,
+            normalized.content,
+            args,
+            this.artifactStore,
+            DEFAULT_REDUCER_CONFIG
+          );
           return {
             tool_call_id: call.id,
             name: call.name,
-            content: normalized.content,
+            content: reduced.content,
             ok: true,
-            rawBytes: normalized.rawBytes,
-            reducedBytes: normalized.reducedBytes
+            rawBytes: reduced.rawBytes,
+            reducedBytes: reduced.reducedBytes,
+            artifactId: reduced.artifactId
           };
         } catch (e) {
           const msg = `Error running ${call.name}: ${e.message ?? String(e)}`;
@@ -2921,7 +3309,7 @@ function buildRightParts(usage, contextLimit) {
     `in ${usage.prompt_tokens}${cached ? ` (${cached} cached)` : ""}`,
     `out ${usage.completion_tokens}`,
     `ctx ${pct}%`,
-    `${cost.total.toFixed(5)}`
+    `$${cost.total.toFixed(5)}`
   ];
 }
 function shortModel(m) {
@@ -5282,6 +5670,7 @@ function App({ initialCfg, initialUpdateResult }) {
         sessionIdRef.current = null;
         sessionStateRef.current = emptySessionState();
         artifactStoreRef.current = new ArtifactStore();
+        executorRef.current.clearArtifacts();
         setEvents([]);
         setUsage(null);
         setTasks([]);