kimiflare 0.15.0 → 0.16.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;
   }
 });
@@ -923,11 +1021,11 @@ var init_mode = __esm({
 
 // 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;
@@ -1037,7 +1135,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"() {
@@ -1061,7 +1159,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 +1271,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 +1287,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}"
@@ -1700,16 +1798,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 +1980,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)}_`;
@@ -3834,12 +4339,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 +4365,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 +4412,7 @@ async function loadSession(filePath) {
 var init_sessions = __esm({
   "src/sessions.ts"() {
     "use strict";
+    init_storage_limits();
   }
 });
 
@@ -3939,17 +4458,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 +4502,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 +4529,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 +4588,7 @@ var init_usage_tracker = __esm({
   "src/usage-tracker.ts"() {
     "use strict";
     init_pricing();
+    init_storage_limits();
     LOG_VERSION2 = 1;
   }
 });
@@ -4067,8 +4601,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 +4679,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 +4901,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 +4967,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 +5042,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 +5165,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 +5214,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 +5280,8 @@ function App({ initialCfg, initialUpdateResult }) {
           messagesRef.current = [messagesRef.current[0]];
         }
         sessionIdRef.current = null;
+        sessionStateRef.current = emptySessionState();
+        artifactStoreRef.current = new ArtifactStore();
         setEvents([]);
         setUsage(null);
         setTasks([]);
@@ -4926,7 +5509,7 @@ use: /thinking low | medium | high`
         return true;
       }
       if (c === "/logout") {
-        unlink(configPath()).catch(() => {
+        unlink2(configPath()).catch(() => {
         });
         setEvents((e) => [
           ...e,
@@ -4987,6 +5570,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 +5690,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 +5906,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 +5952,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";