kimiflare 0.15.0 → 0.17.0

package/dist/index.js

@@ -37,6 +37,8 @@ async function loadConfig() {
   const envCoauthor = readCoauthorEnv();
   const envCacheStable = process.env.KIMIFLARE_CACHE_STABLE_PROMPTS;
   const cacheStablePrompts = envCacheStable === "0" || envCacheStable === "false" ? false : true;
+  const envCompiled = process.env.KIMIFLARE_COMPILED_CONTEXT;
+  const compiledContext = envCompiled === "1" || envCompiled === "true" ? true : false;
   if (envAccount && envToken) {
     return {
       accountId: envAccount,
@@ -47,7 +49,8 @@ async function loadConfig() {
       coauthor: envCoauthor?.enabled ?? true,
       coauthorName: envCoauthor?.name,
       coauthorEmail: envCoauthor?.email,
-      cacheStablePrompts
+      cacheStablePrompts,
+      compiledContext
     };
   }
   try {
@@ -64,7 +67,8 @@ async function loadConfig() {
         coauthorName: envCoauthor?.name ?? parsed.coauthorName,
         coauthorEmail: envCoauthor?.email ?? parsed.coauthorEmail,
         mcpServers: parsed.mcpServers,
-        cacheStablePrompts: parsed.cacheStablePrompts ?? cacheStablePrompts
+        cacheStablePrompts: parsed.cacheStablePrompts ?? cacheStablePrompts,
+        compiledContext: parsed.compiledContext ?? compiledContext
       };
     }
   } catch {
@@ -406,16 +410,107 @@ var init_registry = __esm({
   }
 });
 
+// src/storage-limits.ts
+import { readdir, stat, unlink } from "fs/promises";
+import { join as join2 } from "path";
+async function listFilesByMtime(dir, pattern = /.*/) {
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const name of entries) {
+    if (!pattern.test(name)) continue;
+    const p = join2(dir, name);
+    try {
+      const s = await stat(p);
+      if (s.isFile()) files.push({ path: p, mtime: s.mtime });
+    } catch {
+    }
+  }
+  files.sort((a, b) => b.mtime < a.mtime ? -1 : 1);
+  return files;
+}
+async function pruneFiles(files, maxAgeDays, maxCount) {
+  const cutoff = new Date(Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3);
+  let removed = 0;
+  for (const f of files) {
+    if (f.mtime < cutoff) {
+      try {
+        await unlink(f.path);
+        removed++;
+      } catch {
+      }
+    }
+  }
+  const remaining = files.filter((f) => {
+    return f.mtime >= cutoff;
+  });
+  if (remaining.length > maxCount) {
+    const toDelete = remaining.slice(maxCount);
+    for (const f of toDelete) {
+      try {
+        await unlink(f.path);
+        removed++;
+      } catch {
+      }
+    }
+  }
+  return removed;
+}
+async function rotateJsonl(path, maxBytes, rotations) {
+  const { rename } = await import("fs/promises");
+  let s;
+  try {
+    s = await stat(path);
+  } catch {
+    return;
+  }
+  if (s.size <= maxBytes) return;
+  for (let i = rotations - 1; i >= 1; i--) {
+    const src = i === 1 ? path : `${path}.${i - 1}`;
+    const dst = `${path}.${i}`;
+    try {
+      await rename(src, dst);
+    } catch {
+    }
+  }
+}
+var RETENTION;
+var init_storage_limits = __esm({
+  "src/storage-limits.ts"() {
+    "use strict";
+    RETENTION = {
+      /** Session files older than this (days) are pruned. */
+      sessionMaxAgeDays: 30,
+      /** Max number of session files to keep. */
+      sessionMaxCount: 100,
+      /** Usage log day entries older than this (days) are pruned. */
+      usageDayMaxAgeDays: 90,
+      /** Usage log session entries older than this (days) are pruned. */
+      usageSessionMaxAgeDays: 30,
+      /** Max number of session entries in usage log. */
+      usageSessionMaxCount: 200,
+      /** Max size of cost-debug JSONL before rotation (bytes). */
+      costDebugMaxBytes: 5 * 1024 * 1024,
+      /** Number of rotated cost-debug files to keep. */
+      costDebugRotations: 2
+    };
+  }
+});
+
 // src/cost-debug.ts
 import { appendFile, mkdir as mkdir2 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 function debugDir() {
-  const xdg = process.env.XDG_DATA_HOME || join2(homedir2(), ".local", "share");
-  return join2(xdg, "kimiflare");
+  const xdg = process.env.XDG_DATA_HOME || join3(homedir2(), ".local", "share");
+  return join3(xdg, "kimiflare");
 }
 function debugPath() {
-  return join2(debugDir(), "cost-debug.jsonl");
+  return join3(debugDir(), "cost-debug.jsonl");
 }
 function now() {
   return (/* @__PURE__ */ new Date()).toISOString();
@@ -471,6 +566,7 @@ function buildToolStats(results) {
 }
 async function logCostDebug(entry) {
   await mkdir2(debugDir(), { recursive: true });
+  await rotateJsonl(debugPath(), RETENTION.costDebugMaxBytes, RETENTION.costDebugRotations);
   await appendFile(debugPath(), JSON.stringify(entry) + "\n", "utf8");
 }
 function serializePrefix(messages) {
@@ -556,13 +652,15 @@ async function logTurnDebug(ctx) {
     toolTotalRawBytes: toolTotalRaw,
     toolTotalReducedBytes: toolTotalReduced,
     toolSavingsPct: toolTotalRaw > 0 ? Math.round((toolTotalRaw - toolTotalReduced) / toolTotalRaw * 100) : 0,
-    cacheDiagnostics
+    cacheDiagnostics,
+    compaction: ctx.compaction
   });
 }
 var LOG_VERSION;
 var init_cost_debug = __esm({
   "src/cost-debug.ts"() {
     "use strict";
+    init_storage_limits();
     LOG_VERSION = 1;
   }
 });
@@ -774,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";
@@ -860,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",
@@ -892,42 +978,16 @@ 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)
-    };
   }
 });
 
 // src/agent/system-prompt.ts
 import { platform, release, homedir as homedir3 } from "os";
-import { basename, join as join3 } from "path";
+import { basename, join as join4 } from "path";
 import { readFileSync, statSync } from "fs";
 function loadContextFile(cwd) {
   for (const name of CONTEXT_FILENAMES) {
-    const path = join3(cwd, name);
+    const path = join4(cwd, name);
     try {
       const s = statSync(path);
       if (!s.isFile() || s.size > MAX_CONTEXT_BYTES) continue;
@@ -951,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();
@@ -1005,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;
@@ -1037,7 +1097,7 @@ var init_paths = __esm({
 });
 
 // src/tools/read.ts
-import { readFile as readFile2, stat } from "fs/promises";
+import { readFile as readFile2, stat as stat2 } from "fs/promises";
 var MAX_BYTES, readTool;
 var init_read = __esm({
   "src/tools/read.ts"() {
@@ -1046,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: {
@@ -1061,7 +1121,7 @@ var init_read = __esm({
       render: ({ path }) => ({ title: `read ${collapsePath(path, process.cwd())}` }),
       async run(args, ctx) {
         const abs = resolvePath(ctx.cwd, args.path);
-        const st = await stat(abs);
+        const st = await stat2(abs);
         if (st.size > MAX_BYTES) throw new Error(`file too large: ${st.size} bytes (max ${MAX_BYTES})`);
         const text = await readFile2(abs, "utf8");
         const lines = text.split("\n");
@@ -1173,7 +1233,7 @@ var init_edit = __esm({
 // src/tools/bash.ts
 import { spawn } from "child_process";
 import { tmpdir } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 function formatBashTitle(raw) {
   let cmd = (raw ?? "").trim();
   const m = cmd.match(/^cd\s+([^\s&;]+)\s*(?:&&|;)\s*(.*)$/);
@@ -1189,7 +1249,7 @@ function injectCoauthor(command, coauthor) {
   const isRebaseContinue = /\bgit\s+rebase\b/.test(trimmed) && !/\b--abort\b|\b--skip\b/.test(trimmed);
   const mentionsGit = /\bgit\b/.test(trimmed);
   if (!createsCommit && !isRebaseContinue && !mentionsGit) return command;
-  const tmpFile = join4(tmpdir(), `kf-coauthor-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+  const tmpFile = join5(tmpdir(), `kf-coauthor-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
   const amendBlock = `
     if ! git log -1 --pretty=%B 2>/dev/null | grep -qF "${trailer}"; then
       git log -1 --pretty=%B | git interpret-trailers --trailer "${trailer}" > "${tmpFile}" && git commit --amend -F "${tmpFile}" --no-edit && rm -f "${tmpFile}"
@@ -1242,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: {
@@ -1346,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;
@@ -1389,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;
@@ -1436,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: {
@@ -1480,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);
@@ -1576,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") {
@@ -1599,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,
@@ -1612,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()];
@@ -1627,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) {
@@ -1666,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)}`;
@@ -1700,16 +2186,16 @@ var init_executor = __esm({
 // src/util/update-check.ts
 import { readFile as readFile6, writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { join as join5, dirname as dirname2 } from "path";
+import { join as join6, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 function cachePath() {
-  const xdg = process.env.XDG_CONFIG_HOME || join5(homedir5(), ".config");
-  return join5(xdg, "kimiflare", "update-check.json");
+  const xdg = process.env.XDG_CONFIG_HOME || join6(homedir5(), ".config");
+  return join6(xdg, "kimiflare", "update-check.json");
 }
 async function findPackageJson(startDir) {
   let dir = startDir;
   while (true) {
-    const candidate = join5(dir, "package.json");
+    const candidate = join6(dir, "package.json");
     try {
       const raw = await readFile6(candidate, "utf8");
       const parsed = JSON.parse(raw);
@@ -1882,6 +2368,413 @@ Do not include speculation. Do not include chat-style pleasantries. Use short bu
   }
 });
 
+// src/agent/session-state.ts
+function emptySessionState(task = "") {
+  return {
+    task,
+    user_constraints: [],
+    repo_facts: [],
+    files_touched: [],
+    files_modified: [],
+    confirmed_findings: [],
+    open_questions: [],
+    recent_failures: [],
+    decisions: [],
+    next_actions: [],
+    artifact_index: {}
+  };
+}
+function formatRecalledArtifacts(recalled) {
+  if (recalled.length === 0) return "";
+  const lines = ["[recalled artifacts]"];
+  for (const { id, artifact } of recalled) {
+    lines.push(`--- artifact:${id} (${artifact.type} from ${artifact.source}) ---`);
+    lines.push(artifact.raw);
+  }
+  return lines.join("\n");
+}
+function serializeSessionState(state) {
+  const lines = [];
+  lines.push(`task: ${state.task || "(none)"}`);
+  if (state.user_constraints.length) lines.push(`constraints:
+${state.user_constraints.map((c) => "  - " + c).join("\n")}`);
+  if (state.repo_facts.length) lines.push(`repo_facts:
+${state.repo_facts.map((f) => "  - " + f).join("\n")}`);
+  if (state.files_touched.length) lines.push(`files_touched: ${state.files_touched.join(", ")}`);
+  if (state.files_modified.length) lines.push(`files_modified: ${state.files_modified.join(", ")}`);
+  if (state.confirmed_findings.length) lines.push(`findings:
+${state.confirmed_findings.map((f) => "  - " + f).join("\n")}`);
+  if (state.open_questions.length) lines.push(`open_questions:
+${state.open_questions.map((q) => "  - " + q).join("\n")}`);
+  if (state.recent_failures.length) lines.push(`recent_failures:
+${state.recent_failures.map((f) => "  - " + f).join("\n")}`);
+  if (state.decisions.length) lines.push(`decisions:
+${state.decisions.map((d) => "  - " + d).join("\n")}`);
+  if (state.next_actions.length) lines.push(`next_actions:
+${state.next_actions.map((a) => "  - " + a).join("\n")}`);
+  if (Object.keys(state.artifact_index).length) {
+    lines.push("artifact_index:");
+    for (const [id, meta] of Object.entries(state.artifact_index)) {
+      lines.push(`  ${id}: [${meta.type}] ${meta.summary}`);
+    }
+  }
+  return lines.join("\n");
+}
+function buildSessionStateMessage(state) {
+  return {
+    role: "system",
+    content: `[compiled session state]
+${serializeSessionState(state)}`
+  };
+}
+var ArtifactStore;
+var init_session_state = __esm({
+  "src/agent/session-state.ts"() {
+    "use strict";
+    ArtifactStore = class {
+      artifacts = /* @__PURE__ */ new Map();
+      maxArtifacts;
+      maxTotalChars;
+      constructor(opts2) {
+        this.maxArtifacts = opts2?.maxArtifacts ?? 200;
+        this.maxTotalChars = opts2?.maxTotalChars ?? 5e5;
+      }
+      add(a) {
+        while (this.totalChars() + a.raw.length > this.maxTotalChars && this.artifacts.size > 0) {
+          this.evictOldest();
+        }
+        while (this.artifacts.size >= this.maxArtifacts) {
+          this.evictOldest();
+        }
+        this.artifacts.set(a.id, a);
+      }
+      get(id) {
+        return this.artifacts.get(id);
+      }
+      has(id) {
+        return this.artifacts.has(id);
+      }
+      list() {
+        return [...this.artifacts.values()].sort((a, b) => a.ts < b.ts ? -1 : 1);
+      }
+      recall(ids) {
+        const out = [];
+        for (const id of ids) {
+          const a = this.artifacts.get(id);
+          if (a) out.push({ id, artifact: a });
+        }
+        return out;
+      }
+      size() {
+        return this.artifacts.size;
+      }
+      totalChars() {
+        let sum = 0;
+        for (const a of this.artifacts.values()) {
+          sum += a.raw.length;
+        }
+        return sum;
+      }
+      evictOldest() {
+        let oldest;
+        for (const a of this.artifacts.values()) {
+          if (!oldest || a.ts < oldest.ts) oldest = a;
+        }
+        if (oldest) this.artifacts.delete(oldest.id);
+      }
+    };
+  }
+});
+
+// src/agent/compaction.ts
+function approxTokens2(n) {
+  return Math.round(n / 4);
+}
+function estimateMessageTokens(m) {
+  let chars = 0;
+  if (typeof m.content === "string") {
+    chars = m.content.length;
+  } else if (Array.isArray(m.content)) {
+    chars = m.content.map((p) => p.type === "text" ? p.text.length : 0).reduce((a, b) => a + b, 0);
+  }
+  if (m.reasoning_content) chars += m.reasoning_content.length;
+  if (m.tool_calls) {
+    for (const tc of m.tool_calls) {
+      chars += tc.function.name.length + tc.function.arguments.length;
+    }
+  }
+  return approxTokens2(chars);
+}
+function estimatePromptTokens(messages) {
+  return messages.reduce((sum, m) => sum + estimateMessageTokens(m), 0);
+}
+function groupIntoTurns(messages) {
+  const prefix = [];
+  let i = 0;
+  while (i < messages.length && messages[i].role === "system") {
+    prefix.push(messages[i]);
+    i++;
+  }
+  const turns = [];
+  while (i < messages.length) {
+    if (messages[i].role !== "user") {
+      i++;
+      continue;
+    }
+    const user = messages[i];
+    i++;
+    if (i >= messages.length || messages[i].role !== "assistant") {
+      continue;
+    }
+    const assistant = messages[i];
+    i++;
+    const tools = [];
+    while (i < messages.length && messages[i].role === "tool") {
+      tools.push(messages[i]);
+      i++;
+    }
+    turns.push({ user, assistant, tools });
+  }
+  return { prefix, turns };
+}
+function makeArtifactId(type, index) {
+  return `${type}_${Date.now()}_${index}`;
+}
+function extractArtifactsFromTurn(turn, startIndex, store) {
+  const artifacts = [];
+  const stateDelta = {
+    files_touched: [],
+    files_modified: [],
+    confirmed_findings: [],
+    recent_failures: [],
+    decisions: [],
+    next_actions: []
+  };
+  const toolCalls = turn.assistant.tool_calls ?? [];
+  for (let ti = 0; ti < turn.tools.length; ti++) {
+    const tm = turn.tools[ti];
+    const tc = toolCalls[ti];
+    const name = tm.name ?? tc?.function.name ?? "unknown";
+    const content = typeof tm.content === "string" ? tm.content : "";
+    let type = "tool_result";
+    let summary = `${name} result`;
+    let path;
+    if (name === "read") {
+      type = "read_slice";
+      try {
+        const args = tc ? JSON.parse(tc.function.arguments) : {};
+        path = args.path;
+        summary = `read ${path ?? "file"}`;
+        if (path && !stateDelta.files_touched.includes(path)) stateDelta.files_touched.push(path);
+      } catch {
+        summary = "read file";
+      }
+    } else if (name === "bash") {
+      type = "bash_log";
+      try {
+        const args = tc ? JSON.parse(tc.function.arguments) : {};
+        const cmd = args.command ?? "";
+        summary = `bash: ${cmd.slice(0, 60)}`;
+        if (content.includes("Error") || content.includes("error") || content.includes("FAIL")) {
+          stateDelta.recent_failures.push(`bash failed: ${cmd.slice(0, 80)}`);
+        }
+      } catch {
+        summary = "bash command";
+      }
+    } else if (name === "grep") {
+      type = "grep_result";
+      summary = `grep results (${content.split("\n").length} lines)`;
+    } else if (name === "web_fetch") {
+      type = "web_fetch";
+      try {
+        const args = tc ? JSON.parse(tc.function.arguments) : {};
+        summary = `web_fetch: ${args.url ?? "url"}`;
+      } catch {
+        summary = "web_fetch";
+      }
+    } else if (name === "write" || name === "edit") {
+      try {
+        const args = tc ? JSON.parse(tc.function.arguments) : {};
+        path = args.path;
+        if (path && !stateDelta.files_modified.includes(path)) stateDelta.files_modified.push(path);
+        if (path && !stateDelta.files_touched.includes(path)) stateDelta.files_touched.push(path);
+      } catch {
+      }
+      continue;
+    } else if (name === "glob") {
+      try {
+        const args = tc ? JSON.parse(tc.function.arguments) : {};
+        summary = `glob: ${args.pattern ?? ""}`;
+      } catch {
+        summary = "glob";
+      }
+    } else if (name === "tasks_set") {
+      try {
+        const args = tc ? JSON.parse(tc.function.arguments) : {};
+        const tasks = args.tasks ?? [];
+        const inProgress = tasks.filter((t) => t.status === "in_progress").map((t) => t.title);
+        const pending = tasks.filter((t) => t.status === "pending").map((t) => t.title);
+        if (inProgress.length) stateDelta.next_actions.push(...inProgress);
+        if (pending.length) stateDelta.next_actions.push(...pending);
+        summary = `tasks_set: ${tasks.length} tasks`;
+      } catch {
+        summary = "tasks_set";
+      }
+    }
+    const maxRaw = 5e4;
+    const raw = content.length > maxRaw ? content.slice(0, maxRaw) + `
+...[${content.length - maxRaw} chars truncated]` : content;
+    const artifact = {
+      id: makeArtifactId(type, startIndex + ti),
+      type,
+      summary,
+      raw,
+      source: name,
+      path,
+      ts: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    artifacts.push(artifact);
+    if (!content.includes("Error") && !content.includes("error") && content.length > 0 && content.length < 2e3) {
+      stateDelta.confirmed_findings.push(`${name}: ${content.slice(0, 200)}`);
+    }
+  }
+  const assistantText = typeof turn.assistant.content === "string" ? turn.assistant.content : "";
+  if (assistantText.length > 0) {
+    const decisionPatterns = [
+      /(?:decided?|will|plan to|going to|should|need to)\s+(.{10,200})/gi,
+      /(?:let's|let us)\s+(.{10,200})/gi
+    ];
+    for (const pattern of decisionPatterns) {
+      let match;
+      while ((match = pattern.exec(assistantText)) !== null) {
+        const decision = match[1].trim().replace(/\.$/, "");
+        if (decision.length > 10 && !stateDelta.decisions.includes(decision)) {
+          stateDelta.decisions.push(decision);
+        }
+      }
+    }
+  }
+  return { artifacts, stateDelta };
+}
+function mergeState(state, delta) {
+  const mergeArr = (a, b) => {
+    if (!b) return a;
+    const set = new Set(a);
+    for (const item of b) set.add(item);
+    return [...set];
+  };
+  return {
+    ...state,
+    task: state.task || delta.task || "",
+    user_constraints: mergeArr(state.user_constraints, delta.user_constraints),
+    repo_facts: mergeArr(state.repo_facts, delta.repo_facts),
+    files_touched: mergeArr(state.files_touched, delta.files_touched),
+    files_modified: mergeArr(state.files_modified, delta.files_modified),
+    confirmed_findings: mergeArr(state.confirmed_findings, delta.confirmed_findings),
+    open_questions: mergeArr(state.open_questions, delta.open_questions),
+    recent_failures: mergeArr(state.recent_failures, delta.recent_failures),
+    decisions: mergeArr(state.decisions, delta.decisions),
+    next_actions: mergeArr(state.next_actions, delta.next_actions),
+    artifact_index: { ...state.artifact_index, ...delta.artifact_index }
+  };
+}
+function shouldCompact(opts2) {
+  const tokenThreshold = opts2.tokenThreshold ?? 8e4;
+  const turnThreshold = opts2.turnThreshold ?? 12;
+  const tokens = estimatePromptTokens(opts2.messages);
+  const { turns } = groupIntoTurns(opts2.messages);
+  return tokens > tokenThreshold || turns.length > turnThreshold;
+}
+function compactMessages2(opts2) {
+  const keepLastTurns = opts2.keepLastTurns ?? 4;
+  const { prefix, turns } = groupIntoTurns(opts2.messages);
+  const tokensBefore = estimatePromptTokens(opts2.messages);
+  if (turns.length <= keepLastTurns) {
+    return {
+      newMessages: opts2.messages,
+      newState: opts2.state,
+      metrics: {
+        estimatedTokensBefore: tokensBefore,
+        estimatedTokensAfter: tokensBefore,
+        archivedArtifacts: 0,
+        recalledArtifacts: 0,
+        rawTurnsRemoved: 0,
+        rawTurnsKept: turns.length
+      }
+    };
+  }
+  const toCompact = turns.slice(0, turns.length - keepLastTurns);
+  const toKeep = turns.slice(turns.length - keepLastTurns);
+  let newState = { ...opts2.state };
+  let archivedCount = 0;
+  for (let i = 0; i < toCompact.length; i++) {
+    const turn = toCompact[i];
+    const { artifacts, stateDelta } = extractArtifactsFromTurn(turn, i, opts2.store);
+    for (const artifact of artifacts) {
+      opts2.store.add(artifact);
+      archivedCount++;
+      newState.artifact_index[artifact.id] = {
+        type: artifact.type,
+        summary: artifact.summary,
+        source: artifact.source,
+        path: artifact.path
+      };
+    }
+    newState = mergeState(newState, stateDelta);
+    if (!newState.task && typeof turn.user.content === "string") {
+      newState.task = turn.user.content.slice(0, 200);
+    }
+  }
+  const workingMemory = [];
+  for (const turn of toKeep) {
+    workingMemory.push(turn.user);
+    workingMemory.push(turn.assistant);
+    for (const tm of turn.tools) {
+      workingMemory.push(tm);
+    }
+  }
+  const stateMsg = buildSessionStateMessage(newState);
+  const newMessages = [...prefix, stateMsg, ...workingMemory];
+  const tokensAfter = estimatePromptTokens(newMessages);
+  const metrics = {
+    estimatedTokensBefore: tokensBefore,
+    estimatedTokensAfter: tokensAfter,
+    archivedArtifacts: archivedCount,
+    recalledArtifacts: 0,
+    rawTurnsRemoved: toCompact.length,
+    rawTurnsKept: toKeep.length
+  };
+  return { newMessages, newState, metrics };
+}
+function recallArtifacts(messages, store, state) {
+  const text = messages.map((m) => typeof m.content === "string" ? m.content : "").join(" ");
+  const ids = [];
+  for (const [id, meta] of Object.entries(state.artifact_index)) {
+    if (meta.path && text.includes(meta.path)) {
+      ids.push(id);
+    }
+  }
+  for (const failure of state.recent_failures) {
+    const keyword = failure.split(":")[0];
+    if (keyword && text.toLowerCase().includes(keyword.toLowerCase())) {
+      for (const [id, meta] of Object.entries(state.artifact_index)) {
+        if (meta.source === "bash" && !ids.includes(id)) {
+          ids.push(id);
+        }
+      }
+    }
+  }
+  const uniqueIds = [...new Set(ids)].slice(0, 5);
+  const recalled = store.recall(uniqueIds);
+  return { ids: uniqueIds, recalled };
+}
+var init_compaction = __esm({
+  "src/agent/compaction.ts"() {
+    "use strict";
+    init_session_state();
+  }
+});
+
 // src/mcp/adapter.ts
 function mcpToolToSpec(serverName, mcpTool, client) {
   const prefix = `mcp_${sanitizeName(serverName)}_`;
@@ -2416,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) {
@@ -3834,12 +4727,20 @@ var init_theme = __esm({
 });
 
 // src/sessions.ts
-import { readFile as readFile7, writeFile as writeFile5, mkdir as mkdir5, readdir, stat as stat2 } from "fs/promises";
+var sessions_exports = {};
+__export(sessions_exports, {
+  listSessions: () => listSessions,
+  loadSession: () => loadSession,
+  makeSessionId: () => makeSessionId,
+  pruneSessions: () => pruneSessions,
+  saveSession: () => saveSession
+});
+import { readFile as readFile7, writeFile as writeFile5, mkdir as mkdir5, readdir as readdir2, stat as stat3 } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 function sessionsDir() {
-  const xdg = process.env.XDG_DATA_HOME || join6(homedir6(), ".local", "share");
-  return join6(xdg, "kimiflare", "sessions");
+  const xdg = process.env.XDG_DATA_HOME || join7(homedir6(), ".local", "share");
+  return join7(xdg, "kimiflare", "sessions");
 }
 function sanitize(text) {
   return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
@@ -3852,24 +4753,29 @@ function makeSessionId(firstPrompt) {
 async function saveSession(file) {
   const dir = sessionsDir();
   await mkdir5(dir, { recursive: true });
-  const path = join6(dir, `${file.id}.json`);
+  const path = join7(dir, `${file.id}.json`);
   await writeFile5(path, JSON.stringify(file, null, 2), "utf8");
   return path;
 }
+async function pruneSessions() {
+  const dir = sessionsDir();
+  const files = await listFilesByMtime(dir, /\.json$/);
+  return pruneFiles(files, RETENTION.sessionMaxAgeDays, RETENTION.sessionMaxCount);
+}
 async function listSessions(limit = 30) {
   const dir = sessionsDir();
   let entries;
   try {
-    entries = await readdir(dir);
+    entries = await readdir2(dir);
   } catch {
     return [];
   }
   const summaries = [];
   for (const name of entries) {
     if (!name.endsWith(".json")) continue;
-    const path = join6(dir, name);
+    const path = join7(dir, name);
     try {
-      const [s, raw] = await Promise.all([stat2(path), readFile7(path, "utf8")]);
+      const [s, raw] = await Promise.all([stat3(path), readFile7(path, "utf8")]);
       const parsed = JSON.parse(raw);
       const firstUser = parsed.messages.find((m) => m.role === "user");
       const firstPrompt = typeof firstUser?.content === "string" ? firstUser.content : firstUser?.content ? firstUser.content.find((p) => p.type === "text")?.text ?? "(no prompt)" : "(no prompt)";
@@ -3894,6 +4800,7 @@ async function loadSession(filePath) {
 var init_sessions = __esm({
   "src/sessions.ts"() {
     "use strict";
+    init_storage_limits();
   }
 });
 
@@ -3939,17 +4846,21 @@ var init_image = __esm({
 // src/usage-tracker.ts
 import { readFile as readFile9, writeFile as writeFile6, mkdir as mkdir6 } from "fs/promises";
 import { homedir as homedir7 } from "os";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 function usageDir() {
-  const xdg = process.env.XDG_DATA_HOME || join7(homedir7(), ".local", "share");
-  return join7(xdg, "kimiflare");
+  const xdg = process.env.XDG_DATA_HOME || join8(homedir7(), ".local", "share");
+  return join8(xdg, "kimiflare");
 }
 function usagePath() {
-  return join7(usageDir(), "usage.json");
+  return join8(usageDir(), "usage.json");
 }
 function today() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 }
+function cutoffDate(daysBack) {
+  const d = new Date(Date.now() - daysBack * 24 * 60 * 60 * 1e3);
+  return d.toISOString().slice(0, 10);
+}
 async function loadLog() {
   try {
     const raw = await readFile9(usagePath(), "utf8");
@@ -3979,8 +4890,18 @@ function getOrCreateSession(log, sessionId, date) {
   }
   return session;
 }
+function pruneUsageLog(log) {
+  const dayCutoff = cutoffDate(RETENTION.usageDayMaxAgeDays);
+  const sessionCutoff = cutoffDate(RETENTION.usageSessionMaxAgeDays);
+  const days = log.days.filter((d) => d.date >= dayCutoff);
+  let sessions = log.sessions.filter((s) => s.date >= sessionCutoff);
+  if (sessions.length > RETENTION.usageSessionMaxCount) {
+    sessions = sessions.sort((a, b) => b.date < a.date ? -1 : b.date > a.date ? 1 : 0).slice(0, RETENTION.usageSessionMaxCount);
+  }
+  return { ...log, days, sessions };
+}
 async function recordUsage(sessionId, usage) {
-  const log = await loadLog();
+  const log = pruneUsageLog(await loadLog());
   const date = today();
   const cost = calculateCost(usage.prompt_tokens, usage.completion_tokens, usage.prompt_tokens_details?.cached_tokens ?? 0);
   const day = getOrCreateDay(log, date);
@@ -3996,7 +4917,7 @@ async function recordUsage(sessionId, usage) {
   await saveLog(log);
 }
 async function getCostReport(sessionId) {
-  const log = await loadLog();
+  const log = pruneUsageLog(await loadLog());
   const date = today();
   const currentMonth = date.slice(0, 7);
   const session = log.sessions.find((s) => s.id === sessionId) ?? { date, promptTokens: 0, completionTokens: 0, cachedTokens: 0, cost: 0 };
@@ -4055,6 +4976,7 @@ var init_usage_tracker = __esm({
   "src/usage-tracker.ts"() {
     "use strict";
     init_pricing();
+    init_storage_limits();
     LOG_VERSION2 = 1;
   }
 });
@@ -4067,8 +4989,8 @@ __export(app_exports, {
 import { useState as useState6, useRef as useRef3, useEffect as useEffect4, useCallback } from "react";
 import { Box as Box12, Text as Text13, useApp, useInput as useInput2, render } from "ink";
 import { existsSync } from "fs";
-import { join as join8 } from "path";
-import { unlink } from "fs/promises";
+import { join as join9 } from "path";
+import { unlink as unlink2 } from "fs/promises";
 import { jsx as jsx13, jsxs as jsxs12 } from "react/jsx-runtime";
 function capEvents(prev) {
   if (prev.length <= MAX_EVENTS) return prev;
@@ -4145,11 +5067,27 @@ function App({ initialCfg, initialUpdateResult }) {
   const tasksRef = useRef3([]);
   const usageRef = useRef3(null);
   const updateCheckedRef = useRef3(false);
+  const sessionStateRef = useRef3(emptySessionState());
+  const artifactStoreRef = useRef3(new ArtifactStore());
+  const compiledContextRef = useRef3(initialCfg?.compiledContext === true);
   const updateNudgedRef = useRef3(false);
   const compactSuggestedRef = useRef3(false);
   const mcpManagerRef = useRef3(new McpManager());
   const mcpToolsRef = useRef3([]);
   const mcpInitRef = useRef3(false);
+  useEffect4(() => {
+    if (!cfg) return;
+    void Promise.resolve().then(() => (init_sessions(), sessions_exports)).then(
+      ({ pruneSessions: pruneSessions2 }) => pruneSessions2().then((removed) => {
+        if (removed > 0) {
+          setEvents((e) => [
+            ...e,
+            { kind: "info", key: mkKey(), text: `pruned ${removed} old session files` }
+          ]);
+        }
+      })
+    );
+  }, [cfg]);
   useEffect4(() => {
     if (!cfg || updateCheckedRef.current) return;
     updateCheckedRef.current = true;
@@ -4351,7 +5289,8 @@ function App({ initialCfg, initialUpdateResult }) {
         model: cfg.model,
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        messages: messagesRef.current
+        messages: messagesRef.current,
+        sessionState: compiledContextRef.current ? sessionStateRef.current : void 0
       });
     } catch {
     }
@@ -4416,29 +5355,55 @@ function App({ initialCfg, initialUpdateResult }) {
     const controller = new AbortController();
     activeControllerRef.current = controller;
     try {
-      const result = await compactMessages({
-        accountId: cfg.accountId,
-        apiToken: cfg.apiToken,
-        model: cfg.model,
-        messages: messagesRef.current,
-        signal: controller.signal
-      });
-      if (result.replacedCount === 0) {
-        setEvents((e) => [
-          ...e,
-          { kind: "info", key: mkKey(), text: "nothing to compact yet" }
-        ]);
+      if (compiledContextRef.current) {
+        const result = compactMessages2({
+          messages: messagesRef.current,
+          state: sessionStateRef.current,
+          store: artifactStoreRef.current
+        });
+        if (result.metrics.rawTurnsRemoved === 0) {
+          setEvents((e) => [
+            ...e,
+            { kind: "info", key: mkKey(), text: "nothing to compact yet" }
+          ]);
+        } else {
+          messagesRef.current = result.newMessages;
+          sessionStateRef.current = result.newState;
+          setEvents((e) => [
+            ...e,
+            {
+              kind: "info",
+              key: mkKey(),
+              text: `compacted ${result.metrics.rawTurnsRemoved} turns \u2192 ${result.metrics.estimatedTokensBefore} \u2192 ${result.metrics.estimatedTokensAfter} tokens, ${result.metrics.archivedArtifacts} artifacts`
+            }
+          ]);
+          await saveSessionSafe();
+        }
       } else {
-        messagesRef.current = result.newMessages;
-        setEvents((e) => [
-          ...e,
-          {
-            kind: "info",
-            key: mkKey(),
-            text: `compacted ${result.replacedCount} messages into a summary`
-          }
-        ]);
-        await saveSessionSafe();
+        const result = await compactMessages({
+          accountId: cfg.accountId,
+          apiToken: cfg.apiToken,
+          model: cfg.model,
+          messages: messagesRef.current,
+          signal: controller.signal
+        });
+        if (result.replacedCount === 0) {
+          setEvents((e) => [
+            ...e,
+            { kind: "info", key: mkKey(), text: "nothing to compact yet" }
+          ]);
+        } else {
+          messagesRef.current = result.newMessages;
+          setEvents((e) => [
+            ...e,
+            {
+              kind: "info",
+              key: mkKey(),
+              text: `compacted ${result.replacedCount} messages into a summary`
+            }
+          ]);
+          await saveSessionSafe();
+        }
       }
     } catch (e) {
       if (e.name !== "AbortError") {
@@ -4465,13 +5430,13 @@ function App({ initialCfg, initialUpdateResult }) {
     }
     const cwd = process.cwd();
     for (const name of ["KIMI.md", "KIMIFLARE.md", "AGENT.md"]) {
-      if (existsSync(join8(cwd, name))) {
+      if (existsSync(join9(cwd, name))) {
         setEvents((e) => [
           ...e,
           {
             kind: "info",
             key: mkKey(),
-            text: `${name} already exists at ${join8(cwd, name)} \u2014 delete it first if you want to regenerate`
+            text: `${name} already exists at ${join9(cwd, name)} \u2014 delete it first if you want to regenerate`
           }
         ]);
         return;
@@ -4588,7 +5553,7 @@ function App({ initialCfg, initialUpdateResult }) {
           })
         }
       });
-      if (existsSync(join8(cwd, "KIMI.md"))) {
+      if (existsSync(join9(cwd, "KIMI.md"))) {
         if (cacheStableRef.current) {
           messagesRef.current[1] = {
             role: "system",
@@ -4637,6 +5602,10 @@ function App({ initialCfg, initialUpdateResult }) {
         const file = await loadSession(picked.filePath);
         messagesRef.current = file.messages;
         sessionIdRef.current = file.id;
+        if (file.sessionState && compiledContextRef.current) {
+          sessionStateRef.current = file.sessionState;
+          artifactStoreRef.current = new ArtifactStore();
+        }
         setEvents([
           {
             kind: "info",
@@ -4699,6 +5668,9 @@ function App({ initialCfg, initialUpdateResult }) {
           messagesRef.current = [messagesRef.current[0]];
         }
         sessionIdRef.current = null;
+        sessionStateRef.current = emptySessionState();
+        artifactStoreRef.current = new ArtifactStore();
+        executorRef.current.clearArtifacts();
         setEvents([]);
         setUsage(null);
         setTasks([]);
@@ -4926,7 +5898,7 @@ use: /thinking low | medium | high`
         return true;
       }
       if (c === "/logout") {
-        unlink(configPath()).catch(() => {
+        unlink2(configPath()).catch(() => {
         });
         setEvents((e) => [
           ...e,
@@ -4987,6 +5959,17 @@ use: /thinking low | medium | high`
       }
       setEvents((e) => [...e, { kind: "user", key: mkKey(), text: display, images: images.length > 0 ? images : void 0 }]);
       messagesRef.current.push({ role: "user", content });
+      if (compiledContextRef.current) {
+        const { ids, recalled } = recallArtifacts(messagesRef.current, artifactStoreRef.current, sessionStateRef.current);
+        if (recalled.length > 0) {
+          const recalledText = formatRecalledArtifacts(recalled);
+          messagesRef.current.push({ role: "system", content: recalledText });
+          sessionStateRef.current = {
+            ...sessionStateRef.current,
+            artifact_index: { ...sessionStateRef.current.artifact_index }
+          };
+        }
+      }
       setBusy(true);
       setTurnStartedAt(Date.now());
       const controller = new AbortController();
@@ -5096,6 +6079,26 @@ use: /thinking low | medium | high`
           }
         });
         await saveSessionSafe();
+        if (compiledContextRef.current && shouldCompact({ messages: messagesRef.current })) {
+          const result = compactMessages2({
+            messages: messagesRef.current,
+            state: sessionStateRef.current,
+            store: artifactStoreRef.current
+          });
+          if (result.metrics.rawTurnsRemoved > 0) {
+            messagesRef.current = result.newMessages;
+            sessionStateRef.current = result.newState;
+            setEvents((e) => [
+              ...e,
+              {
+                kind: "info",
+                key: mkKey(),
+                text: `auto-compacted: ${result.metrics.estimatedTokensBefore} \u2192 ${result.metrics.estimatedTokensAfter} tokens (${result.metrics.archivedArtifacts} artifacts)`
+              }
+            ]);
+            await saveSessionSafe();
+          }
+        }
       } catch (e) {
         if (e.name === "AbortError") {
           setEvents((es) => [...es, { kind: "info", key: mkKey(), text: "(aborted)" }]);
@@ -5292,6 +6295,8 @@ var init_app = __esm({
     init_loop();
     init_system_prompt();
     init_compact();
+    init_compaction();
+    init_session_state();
     init_executor();
     init_manager();
     init_messages();
@@ -5336,11 +6341,11 @@ init_update_check();
 import { Command } from "commander";
 import { readFileSync as readFileSync2 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname3, join as join9 } from "path";
+import { dirname as dirname3, join as join10 } from "path";
 function readPackageVersion() {
   try {
     const here = dirname3(fileURLToPath2(import.meta.url));
-    const pkg = JSON.parse(readFileSync2(join9(here, "..", "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync2(join10(here, "..", "package.json"), "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";