kimiflare 0.88.2 → 0.88.4

package/dist/index.js

@@ -1363,6 +1363,562 @@ var init_messages = __esm({
   }
 });
 
+// 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 serializeArtifactStore(store) {
+  const MAX_ARTIFACT_CHARS = 5e4;
+  const out = [];
+  for (const a of store.list()) {
+    out.push({
+      id: a.id,
+      type: a.type,
+      summary: a.summary,
+      raw: a.raw.slice(0, MAX_ARTIFACT_CHARS),
+      source: a.source,
+      path: a.path,
+      lineRange: a.lineRange,
+      ts: a.ts
+    });
+  }
+  return out;
+}
+function deserializeArtifactStore(data) {
+  const store = new ArtifactStore();
+  for (const a of data) {
+    store.add({
+      id: a.id,
+      type: a.type,
+      summary: a.summary,
+      raw: a.raw,
+      source: a.source,
+      path: a.path,
+      lineRange: a.lineRange,
+      ts: a.ts
+    });
+  }
+  return store;
+}
+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.evictSizeWeighted();
+        }
+        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);
+      }
+      /** Evict the largest artifact among the oldest quartile (by timestamp).
+       *  Bounded by the oldest quartile so we never evict freshly-added artifacts;
+       *  size-weighted within that window so one big artifact gets dropped instead
+       *  of many small ones. */
+      evictSizeWeighted() {
+        const sorted = [...this.artifacts.values()].sort((a, b) => a.ts < b.ts ? -1 : 1);
+        if (sorted.length === 0) return;
+        const quartile = Math.max(1, Math.ceil(sorted.length / 4));
+        const candidates = sorted.slice(0, quartile);
+        let pick3 = candidates[0];
+        for (const a of candidates) {
+          if (a.raw.length > pick3.raw.length) pick3 = a;
+        }
+        this.artifacts.delete(pick3.id);
+      }
+    };
+  }
+});
+
+// src/agent/artifact-compaction.ts
+function approxTokens(n) {
+  return Math.round(n / 3.5);
+}
+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 approxTokens(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 compactMessagesViaArtifacts(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) continue;
+    const lowerKeyword = keyword.toLowerCase();
+    if (!text.toLowerCase().includes(lowerKeyword)) continue;
+    for (const [id, meta] of Object.entries(state.artifact_index)) {
+      if (meta.source === "bash" && !ids.includes(id) && meta.summary.toLowerCase().includes(lowerKeyword)) {
+        ids.push(id);
+      }
+    }
+  }
+  const uniqueIds = [...new Set(ids)].slice(0, 5);
+  const recalled = store.recall(uniqueIds);
+  return { ids: uniqueIds, recalled };
+}
+var init_artifact_compaction = __esm({
+  "src/agent/artifact-compaction.ts"() {
+    "use strict";
+    init_session_state();
+  }
+});
+
+// src/util/llm-dump.ts
+import { homedir as homedir5 } from "os";
+import { join as join8 } from "path";
+import { mkdirSync as mkdirSync2, appendFileSync, writeFileSync } from "fs";
+function isLlmDumpEnabled() {
+  const raw = process.env.KIMIFLARE_DUMP_LLM;
+  if (raw === void 0) return false;
+  const v = raw.toLowerCase();
+  return v === "1" || v === "true";
+}
+function defaultDumpRoot() {
+  const override = process.env.KIMIFLARE_DUMP_LLM_DIR;
+  if (override && override.trim()) return override;
+  const xdg = process.env.XDG_CONFIG_HOME || join8(homedir5(), ".config");
+  return join8(xdg, "kimiflare", "llm-dumps");
+}
+function dumpDir(sessionId) {
+  return join8(defaultDumpRoot(), sessionId && sessionId.trim() ? sessionId : "nosession");
+}
+function messageChars(m) {
+  let chars = 0;
+  if (typeof m.content === "string") {
+    chars = m.content.length;
+  } else if (Array.isArray(m.content)) {
+    chars = m.content.reduce((a, p) => a + (p.type === "text" ? p.text.length : 0), 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 chars;
+}
+function computeBreakdown(messages, tools) {
+  const perMessage = [];
+  let systemChars = 0;
+  let historyChars = 0;
+  messages.forEach((m, index) => {
+    const chars = messageChars(m);
+    if (m.role === "system") systemChars += chars;
+    else historyChars += chars;
+    perMessage.push({
+      index,
+      role: m.role,
+      ...m.name ? { name: m.name } : {},
+      chars,
+      estTokens: approxTokens(chars),
+      ...m.tool_calls && m.tool_calls.length ? { toolName: m.tool_calls.map((t) => t.function.name).join(",") } : {}
+    });
+  });
+  const toolsChars = tools.reduce(
+    (a, t) => a + t.function.name.length + t.function.description.length + JSON.stringify(t.function.parameters).length,
+    0
+  );
+  const totalChars = systemChars + historyChars + toolsChars;
+  return {
+    totalChars,
+    estTokens: approxTokens(totalChars),
+    messageCount: messages.length,
+    toolCount: tools.length,
+    systemChars,
+    toolsChars,
+    historyChars,
+    perMessage
+  };
+}
+function safeSegment(s) {
+  return s.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 80);
+}
+function writeLlmDump(record) {
+  if (!isLlmDumpEnabled()) return;
+  try {
+    const dir = dumpDir(record.meta.sessionId);
+    mkdirSync2(dir, { recursive: true });
+    const tsPart = safeSegment(record.meta.ts);
+    const turnPart = safeSegment(record.meta.turnId ?? "noturn");
+    const reqPart = safeSegment(record.meta.requestId);
+    const file = join8(dir, `${tsPart}-${turnPart}-${reqPart}.json`);
+    writeFileSync(file, JSON.stringify(record, null, 2));
+    const summary = {
+      ...record.meta,
+      ...record.breakdown,
+      perMessage: void 0,
+      // keep the index line thin
+      finishReason: record.response.finishReason,
+      usage: record.response.usage,
+      file
+    };
+    appendFileSync(join8(dir, "index.jsonl"), JSON.stringify(summary) + "\n");
+  } catch {
+  }
+}
+var init_llm_dump = __esm({
+  "src/util/llm-dump.ts"() {
+    "use strict";
+    init_artifact_compaction();
+  }
+});
+
 // src/models/registry.ts
 function isUnifiedEligible(entry) {
   if (entry.provider === "workers-ai") return false;
@@ -1485,6 +2041,38 @@ async function* runKimi(opts2) {
   if (opts2.reasoningEffort && supportsReasoning) {
     body.reasoning_effort = opts2.reasoningEffort;
   }
+  let dumpRecord = null;
+  if (isLlmDumpEnabled()) {
+    const dumpMessages = body.messages;
+    const dumpTools = body.tools ?? [];
+    const { messages: _m, tools: _t, ...params } = body;
+    const dumpResponse = {
+      text: "",
+      reasoning: "",
+      toolCalls: [],
+      finishReason: null,
+      usage: null
+    };
+    dumpRecord = {
+      meta: {
+        requestId,
+        sessionId: opts2.sessionId ?? getLogSessionId(),
+        turnId: getLogTurnId(),
+        model: opts2.model,
+        url,
+        ts: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      request: {
+        system: dumpMessages.filter((m) => m.role === "system"),
+        messages: dumpMessages,
+        tools: dumpTools,
+        params,
+        rawSerialized: stableStringify(body, jsonReplacer)
+      },
+      breakdown: computeBreakdown(dumpMessages, dumpTools),
+      response: dumpResponse
+    };
+  }
   logger.debug("runKimi:request", { requestId, attempt: 0, model: opts2.model });
   for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
     let res;
@@ -1565,13 +2153,41 @@ async function* runKimi(opts2) {
     const meta = readGatewayMeta(res.headers);
     if (meta) yield { type: "gateway_meta", meta };
     logger.debug("runKimi:stream_start", { requestId });
-    for await (const ev of parseStream(res.body, opts2.signal, opts2.idleTimeoutMs, opts2.postFirstByteIdleTimeoutMs)) {
-      yield ev;
+    try {
+      for await (const ev of parseStream(res.body, opts2.signal, opts2.idleTimeoutMs, opts2.postFirstByteIdleTimeoutMs)) {
+        if (dumpRecord) accumulateDumpResponse(dumpRecord.response, ev);
+        yield ev;
+      }
+    } finally {
+      if (dumpRecord) {
+        dumpRecord.meta.attempt = attempt;
+        writeLlmDump(dumpRecord);
+      }
     }
     logger.debug("runKimi:stream_end", { requestId });
     return;
   }
 }
+function accumulateDumpResponse(resp, ev) {
+  switch (ev.type) {
+    case "text":
+      resp.text += ev.delta;
+      break;
+    case "reasoning":
+      resp.reasoning += ev.delta;
+      break;
+    case "tool_call_complete":
+      resp.toolCalls.push({ name: ev.name, arguments: ev.arguments });
+      break;
+    case "usage":
+      resp.usage = ev.usage;
+      break;
+    case "done":
+      resp.finishReason = ev.finishReason;
+      if (ev.usage) resp.usage = ev.usage;
+      break;
+  }
+}
 function validateModelId(model) {
   if (!model) throw new KimiApiError(`Invalid model ID: ${model}`, 400);
   if (/^@[a-zA-Z0-9_-]+\/[a-zA-Z0-9._-]+(\/[a-zA-Z0-9._-]+)*$/.test(model)) return;
@@ -1823,6 +2439,8 @@ var init_client = __esm({
     init_version();
     init_messages();
     init_logger();
+    init_log_sink();
+    init_llm_dump();
     init_registry();
     RETRYABLE_CODES = /* @__PURE__ */ new Set([3040]);
     MAX_ATTEMPTS = 5;
@@ -1869,20 +2487,45 @@ var init_registry2 = __esm({
   }
 });
 
-// src/storage-limits.ts
-import { readdir as readdir2, stat as stat2, unlink } from "fs/promises";
-import { join as join8 } from "path";
-async function listFilesByMtime(dir, pattern = /.*/) {
-  let entries;
-  try {
-    entries = await readdir2(dir);
+// src/memory/recall-inject.ts
+function hasRecalledMemory(messages) {
+  return messages.some(
+    (m) => m.role === "system" && typeof m.content === "string" && m.content.startsWith(RECALLED_MEMORY_HEADER)
+  );
+}
+function injectRecalledMemoryOnce(messages, text) {
+  if (!text || hasRecalledMemory(messages)) return false;
+  const lastSystemIdx = messages.findLastIndex((m) => m.role === "system");
+  const insertIdx = lastSystemIdx >= 0 ? lastSystemIdx + 1 : messages.length;
+  messages.splice(insertIdx, 0, {
+    role: "system",
+    content: `${RECALLED_MEMORY_HEADER}
+${text}`
+  });
+  return true;
+}
+var RECALLED_MEMORY_HEADER;
+var init_recall_inject = __esm({
+  "src/memory/recall-inject.ts"() {
+    "use strict";
+    RECALLED_MEMORY_HEADER = "[recalled project memory]";
+  }
+});
+
+// src/storage-limits.ts
+import { readdir as readdir2, stat as stat2, unlink } from "fs/promises";
+import { join as join9 } from "path";
+async function listFilesByMtime(dir, pattern = /.*/) {
+  let entries;
+  try {
+    entries = await readdir2(dir);
   } catch {
     return [];
   }
   const files = [];
   for (const name of entries) {
     if (!pattern.test(name)) continue;
-    const p = join8(dir, name);
+    const p = join9(dir, name);
     try {
       const s = await stat2(p);
       if (s.isFile()) files.push({ path: p, mtime: s.mtime });
@@ -1966,19 +2609,19 @@ var init_storage_limits = __esm({
 
 // src/cost-debug.ts
 import { appendFile, mkdir as mkdir5 } from "fs/promises";
-import { homedir as homedir5 } from "os";
-import { join as join9 } from "path";
+import { homedir as homedir6 } from "os";
+import { join as join10 } from "path";
 function debugDir() {
-  const xdg = process.env.XDG_DATA_HOME || join9(homedir5(), ".local", "share");
-  return join9(xdg, "kimiflare");
+  const xdg = process.env.XDG_DATA_HOME || join10(homedir6(), ".local", "share");
+  return join10(xdg, "kimiflare");
 }
 function debugPath() {
-  return join9(debugDir(), "cost-debug.jsonl");
+  return join10(debugDir(), "cost-debug.jsonl");
 }
 function now() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
-function approxTokens(chars) {
+function approxTokens2(chars) {
   return Math.round(chars / 4);
 }
 function analyzePrompt(messages) {
@@ -1994,14 +2637,14 @@ function analyzePrompt(messages) {
     const base = {
       role: m.role,
       chars,
-      approxTokens: approxTokens(chars)
+      approxTokens: approxTokens2(chars)
     };
     if (m.role === "assistant" && m.reasoning_content) {
       sections.push({
         ...base,
-        detail: `content+reasoning (${approxTokens(m.reasoning_content.length)} reasoning tokens)`,
+        detail: `content+reasoning (${approxTokens2(m.reasoning_content.length)} reasoning tokens)`,
         chars: chars + m.reasoning_content.length,
-        approxTokens: approxTokens(chars + m.reasoning_content.length)
+        approxTokens: approxTokens2(chars + m.reasoning_content.length)
       });
     } else if (m.role === "tool") {
       sections.push({
@@ -2110,7 +2753,7 @@ async function logTurnDebug(ctx) {
     usage: ctx.usage,
     promptSections,
     promptTotalChars,
-    promptTotalApproxTokens: approxTokens(promptTotalChars),
+    promptTotalApproxTokens: approxTokens2(promptTotalChars),
     toolStats,
     toolTotalRawBytes: toolTotalRaw,
     toolTotalReducedBytes: toolTotalReduced,
@@ -2634,757 +3277,301 @@ var require_node_gyp_build = __commonJS({
     function compareTags(runtime2) {
       return function(a, b) {
         if (a.runtime !== b.runtime) {
-          return a.runtime === runtime2 ? -1 : 1;
-        } else if (a.abi !== b.abi) {
-          return a.abi ? -1 : 1;
-        } else if (a.specificity !== b.specificity) {
-          return a.specificity > b.specificity ? -1 : 1;
-        } else {
-          return 0;
-        }
-      };
-    }
-    function isNwjs() {
-      return !!(process.versions && process.versions.nw);
-    }
-    function isElectron() {
-      if (process.versions && process.versions.electron) return true;
-      if (process.env.ELECTRON_RUN_AS_NODE) return true;
-      return typeof window !== "undefined" && window.process && window.process.type === "renderer";
-    }
-    function isAlpine(platform9) {
-      return platform9 === "linux" && fs.existsSync("/etc/alpine-release");
-    }
-    load.parseTags = parseTags;
-    load.matchTags = matchTags;
-    load.compareTags = compareTags;
-    load.parseTuple = parseTuple;
-    load.matchTuple = matchTuple;
-    load.compareTuples = compareTuples;
-  }
-});
-
-// node_modules/node-gyp-build/index.js
-var require_node_gyp_build2 = __commonJS({
-  "node_modules/node-gyp-build/index.js"(exports, module) {
-    "use strict";
-    var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
-    if (typeof runtimeRequire.addon === "function") {
-      module.exports = runtimeRequire.addon.bind(runtimeRequire);
-    } else {
-      module.exports = require_node_gyp_build();
-    }
-  }
-});
-
-// node_modules/isolated-vm/isolated-vm.js
-var require_isolated_vm = __commonJS({
-  "node_modules/isolated-vm/isolated-vm.js"(exports, module) {
-    "use strict";
-    module.exports = require_node_gyp_build2()(__dirname).ivm;
-  }
-});
-
-// src/code-mode/sandbox.ts
-import { join as join10, dirname as dirname5 } from "path";
-import { pathToFileURL } from "url";
-function stripTypescript(code) {
-  let js = code;
-  js = js.replace(/interface\s+\w+\s*\{[\s\S]*?\n\}/g, "");
-  js = js.replace(/type\s+\w+\s*=\s*[^;]+;/g, "");
-  js = js.replace(/(\w+)<[^>]+>(\s*\()/g, "$1$2");
-  js = js.replace(/(\b(?:const|let|var)\s+\w+)\s*:\s*[^=;]+/g, "$1");
-  js = js.replace(/(\(|,\s*)(\w+)\s*:\s*[^,)=]+/g, "$1$2");
-  js = js.replace(/(\)[\s]*)\s*:\s*[^{]+(\s*\{)/g, "$1$2");
-  js = js.replace(/(\)[\s]*)\s*:\s*Promise<[^>]+>(\s*\{)/g, "$1$2");
-  js = js.replace(/\s+as\s+\w+(?:\[\])?/g, "");
-  js = js.replace(/(\w+)(\??)!/g, "$1$2");
-  js = js.replace(/import\s+type\s+[^;]+;/g, "");
-  js = js.replace(/declare\s+[^;]+;/g, "");
-  js = js.replace(/\n{3,}/g, "\n\n");
-  return js.trim();
-}
-async function loadTypescript(cwd) {
-  try {
-    const tsPath = await import.meta.resolve("typescript");
-    return await import(tsPath);
-  } catch {
-  }
-  let dir = cwd;
-  while (dir !== dirname5(dir)) {
-    try {
-      const tsPath = join10(dir, "node_modules", "typescript", "lib", "typescript.js");
-      return await import(pathToFileURL(tsPath).href);
-    } catch {
-    }
-    dir = dirname5(dir);
-  }
-  return null;
-}
-async function transpileOrStrip(code, cwd) {
-  const ts = await loadTypescript(cwd);
-  if (ts) {
-    const result = ts.transpileModule(code, {
-      compilerOptions: {
-        module: ts.ModuleKind.ES2022,
-        target: ts.ScriptTarget.ES2022,
-        esModuleInterop: true,
-        isolatedModules: true
-      }
-    });
-    return { js: result.outputText, warnings: [] };
-  }
-  return {
-    js: stripTypescript(code),
-    warnings: ["TypeScript not found in node_modules. Using fallback parser; install typescript for reliable transpilation."]
-  };
-}
-async function runWithIsolatedVm(opts2) {
-  const { Isolate } = await Promise.resolve().then(() => __toESM(require_isolated_vm(), 1));
-  const isolate = new Isolate({ memoryLimit: opts2.memoryLimitMB ?? 128 });
-  const context = await isolate.createContext();
-  const jail = context.global;
-  await jail.set("global", jail.derefInto());
-  const logs = [];
-  const toolCalls = [];
-  await context.evalClosure(
-    `globalThis._log = function(...args) {
-      $0.applySync(undefined, [args.map(String).join(" ")], { arguments: { copy: true } });
-    };`,
-    [(msg) => logs.push(msg)],
-    { arguments: { reference: true } }
-  );
-  await context.eval(`var console = { log: function(...args) { _log(args.map(String).join(" ")); } };`);
-  const toolMap = new Map(opts2.tools.map((t) => [t.name, t]));
-  for (const tool of opts2.tools) {
-    const ref = new (await Promise.resolve().then(() => __toESM(require_isolated_vm(), 1))).Reference(
-      async (argsJson) => {
-        const args = JSON.parse(argsJson);
-        const toolCallId = `code_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-        const result = await opts2.executor.run(
-          { id: toolCallId, name: tool.name, arguments: JSON.stringify(args) },
-          opts2.askPermission,
-          opts2.ctx
-        );
-        toolCalls.push({
-          name: tool.name,
-          args,
-          result: result.content
-        });
-        return result.content;
-      }
-    );
-    await context.evalClosure(
-      `globalThis["_api_${tool.name}"] = function(argsJson) {
-        return $0.applySyncPromise(undefined, [argsJson], { arguments: { copy: true } });
-      };`,
-      [ref],
-      { arguments: { reference: true } }
-    );
-  }
-  const apiMethods = opts2.tools.map((t) => `  ${t.name}: function(input) { return _api_${t.name}(JSON.stringify(input ?? {})); }`).join(",\n");
-  await context.eval(`var api = {
-${apiMethods}
-};`);
-  const { js: jsCode, warnings } = await transpileOrStrip(opts2.code, opts2.ctx.cwd);
-  const wrapped = `(async function() {
-${jsCode}
-})();`;
-  try {
-    const timeout = opts2.timeoutMs ?? 3e4;
-    const script = await isolate.compileScript(wrapped);
-    await script.run(context, { timeout, release: true });
-    await new Promise((r) => setTimeout(r, 10));
-  } catch (err) {
-    const message2 = err instanceof Error ? err.message : String(err);
-    return { output: "", logs, error: message2, toolCalls, warnings };
-  } finally {
-    isolate.dispose();
-  }
-  return { output: logs.join("\n"), logs, toolCalls, warnings };
-}
-async function runWithNodeVm(opts2) {
-  const { runInNewContext } = await import("vm");
-  const logs = [];
-  const toolCalls = [];
-  const sandbox = {
-    console: {
-      log: (...args) => {
-        logs.push(args.map(String).join(" "));
-      }
-    },
-    api: {},
-    setTimeout,
-    clearTimeout,
-    setInterval,
-    clearInterval,
-    Promise,
-    JSON,
-    Math,
-    Date,
-    Array,
-    Object,
-    String,
-    Number,
-    Boolean,
-    RegExp,
-    Error,
-    TypeError,
-    RangeError,
-    SyntaxError,
-    ReferenceError,
-    Map,
-    Set,
-    WeakMap,
-    WeakSet,
-    Symbol,
-    parseInt,
-    parseFloat,
-    isNaN,
-    isFinite,
-    encodeURI,
-    decodeURI,
-    encodeURIComponent,
-    decodeURIComponent,
-    escape,
-    unescape,
-    Infinity: Infinity,
-    NaN: NaN,
-    undefined: void 0
-  };
-  for (const tool of opts2.tools) {
-    sandbox.api[tool.name] = async (input) => {
-      const args = input ?? {};
-      const toolCallId = `code_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-      const result = await opts2.executor.run(
-        { id: toolCallId, name: tool.name, arguments: JSON.stringify(args) },
-        opts2.askPermission,
-        opts2.ctx
-      );
-      toolCalls.push({
-        name: tool.name,
-        args,
-        result: result.content
-      });
-      return result.content;
-    };
-  }
-  const { js: jsCode, warnings } = await transpileOrStrip(opts2.code, opts2.ctx.cwd);
-  const wrapped = `"use strict";
-(async function() {
-${jsCode}
-})();`;
-  try {
-    const timeout = opts2.timeoutMs ?? 3e4;
-    await runInNewContext(wrapped, sandbox, { timeout, displayErrors: true });
-    await new Promise((r) => setTimeout(r, 10));
-  } catch (err) {
-    const message2 = err instanceof Error ? err.message : String(err);
-    return { output: "", logs, error: message2, toolCalls, warnings };
-  }
-  return { output: logs.join("\n"), logs, toolCalls, warnings };
-}
-function buildFallbackWarning(errMessage) {
-  let reason;
-  let fix;
-  if (errMessage.includes("Cannot find module") || errMessage.includes("isolated-vm")) {
-    reason = "The optional dependency `isolated-vm` is not installed.";
-    fix = "Run `npm install isolated-vm` in your project (or `npm install -g isolated-vm` if KimiFlare is installed globally).";
-  } else if (errMessage.includes("bindings") || errMessage.includes(".node")) {
-    reason = "The `isolated-vm` native bindings are incompatible with this Node version or architecture.";
-    fix = "Try `npm rebuild isolated-vm`, or switch to Node 22 LTS if you're on Apple Silicon.";
-  } else {
-    reason = "The secure sandbox (`isolated-vm`) could not be loaded.";
-    fix = "Ensure build tools are installed, then run `npm install isolated-vm`.";
-  }
-  return `Code Mode is using the built-in Node.js sandbox. Tool execution works normally, but without memory limits or full process isolation. ${reason} ${fix}`;
-}
-async function runInSandbox(opts2) {
-  try {
-    return await runWithIsolatedVm(opts2);
-  } catch (err) {
-    const message2 = err instanceof Error ? err.message : String(err);
-    const result = await runWithNodeVm(opts2);
-    const sessionKey = opts2.ctx.sessionId ?? NO_SESSION_KEY;
-    if (!fallbackWarningShownSessions.has(sessionKey)) {
-      fallbackWarningShownSessions.add(sessionKey);
-      const warning = buildFallbackWarning(message2);
-      return { ...result, warnings: [warning, ...result.warnings ?? []] };
-    }
-    return result;
-  }
-}
-var fallbackWarningShownSessions, NO_SESSION_KEY;
-var init_sandbox = __esm({
-  "src/code-mode/sandbox.ts"() {
-    "use strict";
-    fallbackWarningShownSessions = /* @__PURE__ */ new Set();
-    NO_SESSION_KEY = "__no_session__";
-  }
-});
-
-// src/code-mode/index.ts
-var init_code_mode = __esm({
-  "src/code-mode/index.ts"() {
-    "use strict";
-    init_api_generator();
-    init_sandbox();
-  }
-});
-
-// 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 serializeArtifactStore(store) {
-  const MAX_ARTIFACT_CHARS = 5e4;
-  const out = [];
-  for (const a of store.list()) {
-    out.push({
-      id: a.id,
-      type: a.type,
-      summary: a.summary,
-      raw: a.raw.slice(0, MAX_ARTIFACT_CHARS),
-      source: a.source,
-      path: a.path,
-      lineRange: a.lineRange,
-      ts: a.ts
-    });
-  }
-  return out;
-}
-function deserializeArtifactStore(data) {
-  const store = new ArtifactStore();
-  for (const a of data) {
-    store.add({
-      id: a.id,
-      type: a.type,
-      summary: a.summary,
-      raw: a.raw,
-      source: a.source,
-      path: a.path,
-      lineRange: a.lineRange,
-      ts: a.ts
-    });
-  }
-  return store;
-}
-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.evictSizeWeighted();
-        }
-        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);
-      }
-      /** Evict the largest artifact among the oldest quartile (by timestamp).
-       *  Bounded by the oldest quartile so we never evict freshly-added artifacts;
-       *  size-weighted within that window so one big artifact gets dropped instead
-       *  of many small ones. */
-      evictSizeWeighted() {
-        const sorted = [...this.artifacts.values()].sort((a, b) => a.ts < b.ts ? -1 : 1);
-        if (sorted.length === 0) return;
-        const quartile = Math.max(1, Math.ceil(sorted.length / 4));
-        const candidates = sorted.slice(0, quartile);
-        let pick3 = candidates[0];
-        for (const a of candidates) {
-          if (a.raw.length > pick3.raw.length) pick3 = a;
-        }
-        this.artifacts.delete(pick3.id);
-      }
-    };
-  }
-});
-
-// src/agent/artifact-compaction.ts
-function approxTokens2(n) {
-  return Math.round(n / 3.5);
-}
-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";
-      }
+          return a.runtime === runtime2 ? -1 : 1;
+        } else if (a.abi !== b.abi) {
+          return a.abi ? -1 : 1;
+        } else if (a.specificity !== b.specificity) {
+          return a.specificity > b.specificity ? -1 : 1;
+        } else {
+          return 0;
+        }
+      };
     }
-    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)}`);
+    function isNwjs() {
+      return !!(process.versions && process.versions.nw);
+    }
+    function isElectron() {
+      if (process.versions && process.versions.electron) return true;
+      if (process.env.ELECTRON_RUN_AS_NODE) return true;
+      return typeof window !== "undefined" && window.process && window.process.type === "renderer";
+    }
+    function isAlpine(platform9) {
+      return platform9 === "linux" && fs.existsSync("/etc/alpine-release");
     }
+    load.parseTags = parseTags;
+    load.matchTags = matchTags;
+    load.compareTags = compareTags;
+    load.parseTuple = parseTuple;
+    load.matchTuple = matchTuple;
+    load.compareTuples = compareTuples;
   }
-  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);
-        }
-      }
+});
+
+// node_modules/node-gyp-build/index.js
+var require_node_gyp_build2 = __commonJS({
+  "node_modules/node-gyp-build/index.js"(exports, module) {
+    "use strict";
+    var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
+    if (typeof runtimeRequire.addon === "function") {
+      module.exports = runtimeRequire.addon.bind(runtimeRequire);
+    } else {
+      module.exports = require_node_gyp_build();
     }
   }
-  return { artifacts, stateDelta };
+});
+
+// node_modules/isolated-vm/isolated-vm.js
+var require_isolated_vm = __commonJS({
+  "node_modules/isolated-vm/isolated-vm.js"(exports, module) {
+    "use strict";
+    module.exports = require_node_gyp_build2()(__dirname).ivm;
+  }
+});
+
+// src/code-mode/sandbox.ts
+import { join as join11, dirname as dirname5 } from "path";
+import { pathToFileURL } from "url";
+function stripTypescript(code) {
+  let js = code;
+  js = js.replace(/interface\s+\w+\s*\{[\s\S]*?\n\}/g, "");
+  js = js.replace(/type\s+\w+\s*=\s*[^;]+;/g, "");
+  js = js.replace(/(\w+)<[^>]+>(\s*\()/g, "$1$2");
+  js = js.replace(/(\b(?:const|let|var)\s+\w+)\s*:\s*[^=;]+/g, "$1");
+  js = js.replace(/(\(|,\s*)(\w+)\s*:\s*[^,)=]+/g, "$1$2");
+  js = js.replace(/(\)[\s]*)\s*:\s*[^{]+(\s*\{)/g, "$1$2");
+  js = js.replace(/(\)[\s]*)\s*:\s*Promise<[^>]+>(\s*\{)/g, "$1$2");
+  js = js.replace(/\s+as\s+\w+(?:\[\])?/g, "");
+  js = js.replace(/(\w+)(\??)!/g, "$1$2");
+  js = js.replace(/import\s+type\s+[^;]+;/g, "");
+  js = js.replace(/declare\s+[^;]+;/g, "");
+  js = js.replace(/\n{3,}/g, "\n\n");
+  return js.trim();
 }
-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];
-  };
+async function loadTypescript(cwd) {
+  try {
+    const tsPath = await import.meta.resolve("typescript");
+    return await import(tsPath);
+  } catch {
+  }
+  let dir = cwd;
+  while (dir !== dirname5(dir)) {
+    try {
+      const tsPath = join11(dir, "node_modules", "typescript", "lib", "typescript.js");
+      return await import(pathToFileURL(tsPath).href);
+    } catch {
+    }
+    dir = dirname5(dir);
+  }
+  return null;
+}
+async function transpileOrStrip(code, cwd) {
+  const ts = await loadTypescript(cwd);
+  if (ts) {
+    const result = ts.transpileModule(code, {
+      compilerOptions: {
+        module: ts.ModuleKind.ES2022,
+        target: ts.ScriptTarget.ES2022,
+        esModuleInterop: true,
+        isolatedModules: true
+      }
+    });
+    return { js: result.outputText, warnings: [] };
+  }
   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 }
+    js: stripTypescript(code),
+    warnings: ["TypeScript not found in node_modules. Using fallback parser; install typescript for reliable transpilation."]
   };
 }
-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;
+async function runWithIsolatedVm(opts2) {
+  const { Isolate } = await Promise.resolve().then(() => __toESM(require_isolated_vm(), 1));
+  const isolate = new Isolate({ memoryLimit: opts2.memoryLimitMB ?? 128 });
+  const context = await isolate.createContext();
+  const jail = context.global;
+  await jail.set("global", jail.derefInto());
+  const logs = [];
+  const toolCalls = [];
+  await context.evalClosure(
+    `globalThis._log = function(...args) {
+      $0.applySync(undefined, [args.map(String).join(" ")], { arguments: { copy: true } });
+    };`,
+    [(msg) => logs.push(msg)],
+    { arguments: { reference: true } }
+  );
+  await context.eval(`var console = { log: function(...args) { _log(args.map(String).join(" ")); } };`);
+  const toolMap = new Map(opts2.tools.map((t) => [t.name, t]));
+  for (const tool of opts2.tools) {
+    const ref = new (await Promise.resolve().then(() => __toESM(require_isolated_vm(), 1))).Reference(
+      async (argsJson) => {
+        const args = JSON.parse(argsJson);
+        const toolCallId = `code_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        const result = await opts2.executor.run(
+          { id: toolCallId, name: tool.name, arguments: JSON.stringify(args) },
+          opts2.askPermission,
+          opts2.ctx
+        );
+        toolCalls.push({
+          name: tool.name,
+          args,
+          result: result.content
+        });
+        return result.content;
+      }
+    );
+    await context.evalClosure(
+      `globalThis["_api_${tool.name}"] = function(argsJson) {
+        return $0.applySyncPromise(undefined, [argsJson], { arguments: { copy: true } });
+      };`,
+      [ref],
+      { arguments: { reference: true } }
+    );
+  }
+  const apiMethods = opts2.tools.map((t) => `  ${t.name}: function(input) { return _api_${t.name}(JSON.stringify(input ?? {})); }`).join(",\n");
+  await context.eval(`var api = {
+${apiMethods}
+};`);
+  const { js: jsCode, warnings } = await transpileOrStrip(opts2.code, opts2.ctx.cwd);
+  const wrapped = `(async function() {
+${jsCode}
+})();`;
+  try {
+    const timeout = opts2.timeoutMs ?? 3e4;
+    const script = await isolate.compileScript(wrapped);
+    await script.run(context, { timeout, release: true });
+    await new Promise((r) => setTimeout(r, 10));
+  } catch (err) {
+    const message2 = err instanceof Error ? err.message : String(err);
+    return { output: "", logs, error: message2, toolCalls, warnings };
+  } finally {
+    isolate.dispose();
+  }
+  return { output: logs.join("\n"), logs, toolCalls, warnings };
 }
-function compactMessagesViaArtifacts(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
+async function runWithNodeVm(opts2) {
+  const { runInNewContext } = await import("vm");
+  const logs = [];
+  const toolCalls = [];
+  const sandbox = {
+    console: {
+      log: (...args) => {
+        logs.push(args.map(String).join(" "));
       }
+    },
+    api: {},
+    setTimeout,
+    clearTimeout,
+    setInterval,
+    clearInterval,
+    Promise,
+    JSON,
+    Math,
+    Date,
+    Array,
+    Object,
+    String,
+    Number,
+    Boolean,
+    RegExp,
+    Error,
+    TypeError,
+    RangeError,
+    SyntaxError,
+    ReferenceError,
+    Map,
+    Set,
+    WeakMap,
+    WeakSet,
+    Symbol,
+    parseInt,
+    parseFloat,
+    isNaN,
+    isFinite,
+    encodeURI,
+    decodeURI,
+    encodeURIComponent,
+    decodeURIComponent,
+    escape,
+    unescape,
+    Infinity: Infinity,
+    NaN: NaN,
+    undefined: void 0
+  };
+  for (const tool of opts2.tools) {
+    sandbox.api[tool.name] = async (input) => {
+      const args = input ?? {};
+      const toolCallId = `code_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+      const result = await opts2.executor.run(
+        { id: toolCallId, name: tool.name, arguments: JSON.stringify(args) },
+        opts2.askPermission,
+        opts2.ctx
+      );
+      toolCalls.push({
+        name: tool.name,
+        args,
+        result: result.content
+      });
+      return result.content;
     };
   }
-  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 { js: jsCode, warnings } = await transpileOrStrip(opts2.code, opts2.ctx.cwd);
+  const wrapped = `"use strict";
+(async function() {
+${jsCode}
+})();`;
+  try {
+    const timeout = opts2.timeoutMs ?? 3e4;
+    await runInNewContext(wrapped, sandbox, { timeout, displayErrors: true });
+    await new Promise((r) => setTimeout(r, 10));
+  } catch (err) {
+    const message2 = err instanceof Error ? err.message : String(err);
+    return { output: "", logs, error: message2, toolCalls, warnings };
   }
-  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 };
+  return { output: logs.join("\n"), logs, toolCalls, warnings };
 }
-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);
-    }
+function buildFallbackWarning(errMessage) {
+  let reason;
+  let fix;
+  if (errMessage.includes("Cannot find module") || errMessage.includes("isolated-vm")) {
+    reason = "The optional dependency `isolated-vm` is not installed.";
+    fix = "Run `npm install isolated-vm` in your project (or `npm install -g isolated-vm` if KimiFlare is installed globally).";
+  } else if (errMessage.includes("bindings") || errMessage.includes(".node")) {
+    reason = "The `isolated-vm` native bindings are incompatible with this Node version or architecture.";
+    fix = "Try `npm rebuild isolated-vm`, or switch to Node 22 LTS if you're on Apple Silicon.";
+  } else {
+    reason = "The secure sandbox (`isolated-vm`) could not be loaded.";
+    fix = "Ensure build tools are installed, then run `npm install isolated-vm`.";
   }
-  for (const failure of state.recent_failures) {
-    const keyword = failure.split(":")[0];
-    if (!keyword) continue;
-    const lowerKeyword = keyword.toLowerCase();
-    if (!text.toLowerCase().includes(lowerKeyword)) continue;
-    for (const [id, meta] of Object.entries(state.artifact_index)) {
-      if (meta.source === "bash" && !ids.includes(id) && meta.summary.toLowerCase().includes(lowerKeyword)) {
-        ids.push(id);
-      }
+  return `Code Mode is using the built-in Node.js sandbox. Tool execution works normally, but without memory limits or full process isolation. ${reason} ${fix}`;
+}
+async function runInSandbox(opts2) {
+  try {
+    return await runWithIsolatedVm(opts2);
+  } catch (err) {
+    const message2 = err instanceof Error ? err.message : String(err);
+    const result = await runWithNodeVm(opts2);
+    const sessionKey = opts2.ctx.sessionId ?? NO_SESSION_KEY;
+    if (!fallbackWarningShownSessions.has(sessionKey)) {
+      fallbackWarningShownSessions.add(sessionKey);
+      const warning = buildFallbackWarning(message2);
+      return { ...result, warnings: [warning, ...result.warnings ?? []] };
     }
+    return result;
   }
-  const uniqueIds = [...new Set(ids)].slice(0, 5);
-  const recalled = store.recall(uniqueIds);
-  return { ids: uniqueIds, recalled };
 }
-var init_artifact_compaction = __esm({
-  "src/agent/artifact-compaction.ts"() {
+var fallbackWarningShownSessions, NO_SESSION_KEY;
+var init_sandbox = __esm({
+  "src/code-mode/sandbox.ts"() {
     "use strict";
-    init_session_state();
+    fallbackWarningShownSessions = /* @__PURE__ */ new Set();
+    NO_SESSION_KEY = "__no_session__";
+  }
+});
+
+// src/code-mode/index.ts
+var init_code_mode = __esm({
+  "src/code-mode/index.ts"() {
+    "use strict";
+    init_api_generator();
+    init_sandbox();
   }
 });
 
@@ -3987,12 +4174,12 @@ var init_mode = __esm({
 });
 
 // src/agent/system-prompt.ts
-import { platform, release, homedir as homedir6 } from "os";
-import { basename, join as join11 } from "path";
+import { platform, release, homedir as homedir7 } from "os";
+import { basename, join as join12 } from "path";
 import { readFileSync as readFileSync2, statSync as statSync2 } from "fs";
 function loadContextFile(cwd) {
   for (const name of CONTEXT_FILENAMES) {
-    const path = join11(cwd, name);
+    const path = join12(cwd, name);
     try {
       const s = statSync2(path);
       if (!s.isFile() || s.size > MAX_CONTEXT_BYTES) continue;
@@ -4042,7 +4229,7 @@ If the user asks what model you are, answer with exactly: \`${opts2.model}\`. Th
 - Working directory: ${opts2.cwd}
 - Platform: ${platform()} ${release()}
 - Shell: ${shell}
-- Home: ${homedir6()}
+- Home: ${homedir7()}
 - Today: ${date}`;
   const hasLsp = opts2.tools.some((t) => t.name.startsWith("lsp_"));
   const lspBlock = hasLsp ? "\n\nLSP tools are available for semantic code intelligence. Prefer `lsp_definition` over `grep` when looking for the source of a symbol. Prefer `lsp_references` over `grep` when finding usages. Use `lsp_hover` to confirm types before refactoring." : "";
@@ -4118,6 +4305,9 @@ function getSessionWebFetchHistory(sessionId) {
 function isHighSignalMemory(memory) {
   return memory.topicKey === "project_dependencies" || memory.topicKey === "project_tsconfig" || memory.topicKey === "project_entry_point" || memory.category === "instruction" || memory.category === "preference" || memory.category === "event" && memory.importance >= 3;
 }
+function codeModeRedirectMessage(tool) {
+  return `Code Mode is on: \`${tool}\` is not available as a direct tool because its full output would flood your context. Call \`api.${tool}({ ... })\` INSIDE an \`execute_code\` block instead \u2014 only what you \`console.log\` is returned to you. You can batch several reads/greps/commands in a single execute_code call.`;
+}
 function extractLastUserText(messages) {
   const lastUser = [...messages].reverse().find((m) => m.role === "user");
   if (!lastUser) return "";
@@ -4162,7 +4352,7 @@ async function runAgentTurn(opts2) {
   const lastUserPrompt = extractLastUserText(opts2.messages);
   const userPromptPreview = lastUserPrompt.slice(0, 200);
   const skipSkillRouting = opts2.intentClassification?.tier === "light" && lastUserPrompt.length < 40;
-  const recallPromise = opts2.sessionStartRecall && opts2.memoryManager ? (async () => {
+  const recallPromise = opts2.sessionStartRecall && opts2.memoryManager && !hasRecalledMemory(opts2.messages) ? (async () => {
     const results = await opts2.sessionStartRecall;
     if (results.length === 0 || !opts2.memoryManager) return null;
     const text = await opts2.memoryManager.synthesizeRecalled(results, opts2.signal);
@@ -4193,11 +4383,10 @@ async function runAgentTurn(opts2) {
   }
   if (recallSettled.status === "fulfilled" && recallSettled.value) {
     const { text, count } = recallSettled.value;
-    const lastSystemIdx = opts2.messages.findLastIndex((m) => m.role === "system");
-    const insertIdx = lastSystemIdx >= 0 ? lastSystemIdx + 1 : opts2.messages.length;
-    opts2.messages.splice(insertIdx, 0, { role: "system", content: text });
-    memoryRecalledCount = count;
-    opts2.callbacks.onMemoryRecalled?.(count);
+    if (injectRecalledMemoryOnce(opts2.messages, text)) {
+      memoryRecalledCount = count;
+      opts2.callbacks.onMemoryRecalled?.(count);
+    }
   }
   if (skillsSettled.status === "fulfilled" && skillsSettled.value) {
     skillResult = skillsSettled.value;
@@ -4257,7 +4446,9 @@ async function runAgentTurn(opts2) {
 Available APIs:
 ${codeModeApiString}
 
-Use console.log() to return results. Only console.log output will be sent back to you.`,
+Use console.log() to return results. Only console.log output is sent back to you.
+
+IMPORTANT \u2014 explore through code, not direct tools: to read files, run shell commands, grep, or glob, call api.read(...), api.bash(...), api.grep(...), api.glob(...) INSIDE this code block and console.log only what you need. Do NOT call read/bash/grep/glob as separate tools \u2014 their full output floods your context, while here only what you log returns. Batch multiple reads/greps/commands into a single execute_code call.`,
           parameters: {
             type: "object",
             properties: {
@@ -4286,6 +4477,7 @@ Use console.log() to return results. Only console.log output will be sent back t
   const LOOP_THRESHOLD = 2;
   const webFetchHistory = getSessionWebFetchHistory(opts2.sessionId);
   let webFetchesThisTurn = 0;
+  let codeModeRedirects = 0;
   const MAX_WEB_FETCH_PER_TURN = 5;
   const WEB_FETCH_DOMAIN_THRESHOLD = 2;
   let cumulativePromptTokens = 0;
@@ -4542,6 +4734,16 @@ Use console.log() to return results. Only console.log output will be sent back t
           });
           continue;
         }
+        if (codeMode && CODE_MODE_REDIRECT_TOOLS.has(tc.function.name) && codeModeRedirects < MAX_CODE_MODE_REDIRECTS) {
+          codeModeRedirects++;
+          items.push({
+            kind: "blocked",
+            tc,
+            loopSignature,
+            result: { tool_call_id: tc.id, name: tc.function.name, content: codeModeRedirectMessage(tc.function.name), ok: false }
+          });
+          continue;
+        }
         if (tc.function.name === "web_fetch") {
           const args = JSON.parse(tc.function.arguments || "{}");
           const url = args.url || "";
@@ -4906,6 +5108,13 @@ ${sandboxResult.output}` : sandboxResult.output;
           opts2.callbacks.onToolResult?.(result);
           recentToolCalls.push(loopSignature);
           if (recentToolCalls.length > LOOP_WINDOW) recentToolCalls.shift();
+        } else if (codeMode && CODE_MODE_REDIRECT_TOOLS.has(tc.function.name) && codeModeRedirects < MAX_CODE_MODE_REDIRECTS) {
+          codeModeRedirects++;
+          const msg = codeModeRedirectMessage(tc.function.name);
+          const redirectResult = { tool_call_id: tc.id, name: tc.function.name, content: msg, ok: false };
+          toolResults.push(redirectResult);
+          opts2.messages.push({ role: "tool", tool_call_id: tc.id, content: msg, name: tc.function.name });
+          opts2.callbacks.onToolResult?.(redirectResult);
         } else {
           opts2.callbacks.onToolWillExecute?.(tc.id, tc.function.name);
           logger.debug("turn:tool_start", { sessionId: opts2.sessionId, tool: tc.function.name, toolCallId: tc.id });
@@ -5142,13 +5351,14 @@ function validateToolArguments(raw) {
     return "{}";
   }
 }
-var BudgetExhaustedError, AgentLoopError, codeModeApiCache, driftEvents, DRIFT_WINDOW, DRIFT_THRESHOLD, memoryExtractionErrorCounts, sessionWebFetchHistory, SESSION_WEB_FETCH_CAP, DEFAULT_MAX_COMPLETION_TOKENS, BUDGET_SAFETY_MARGIN_TOKENS, MAX_TOOL_CONTENT_CHARS;
+var BudgetExhaustedError, AgentLoopError, codeModeApiCache, driftEvents, DRIFT_WINDOW, DRIFT_THRESHOLD, memoryExtractionErrorCounts, sessionWebFetchHistory, SESSION_WEB_FETCH_CAP, DEFAULT_MAX_COMPLETION_TOKENS, BUDGET_SAFETY_MARGIN_TOKENS, MAX_TOOL_CONTENT_CHARS, CODE_MODE_REDIRECT_TOOLS, MAX_CODE_MODE_REDIRECTS;
 var init_loop = __esm({
   "src/agent/loop.ts"() {
     "use strict";
     init_client();
     init_registry2();
     init_messages();
+    init_recall_inject();
     init_cost_debug();
     init_extractors();
     init_strip_reasoning();
@@ -5180,6 +5390,8 @@ var init_loop = __esm({
     DEFAULT_MAX_COMPLETION_TOKENS = 16384;
     BUDGET_SAFETY_MARGIN_TOKENS = 8192;
     MAX_TOOL_CONTENT_CHARS = 1e4;
+    CODE_MODE_REDIRECT_TOOLS = /* @__PURE__ */ new Set(["read", "bash", "grep", "glob"]);
+    MAX_CODE_MODE_REDIRECTS = 4;
   }
 });
 
@@ -5243,10 +5455,10 @@ var init_tool_error = __esm({
 
 // src/util/paths.ts
 import { resolve, isAbsolute, relative, sep } from "path";
-import { homedir as homedir7 } from "os";
+import { homedir as homedir8 } from "os";
 function resolvePath(cwd, input) {
   if (input.startsWith("~/") || input === "~") {
-    return resolve(homedir7(), input === "~" ? "." : input.slice(2));
+    return resolve(homedir8(), input === "~" ? "." : input.slice(2));
   }
   return isAbsolute(input) ? input : resolve(cwd, input);
 }
@@ -5473,7 +5685,7 @@ var init_edit = __esm({
 // src/tools/bash.ts
 import { spawn } from "child_process";
 import { tmpdir, platform as platform2 } from "os";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 function getShellCommand(override) {
   const raw = override?.trim();
   if (raw && raw !== "auto") {
@@ -5519,7 +5731,7 @@ function injectCoauthor(command, coauthor) {
   const mentionsGit = /\bgit\b/.test(trimmed);
   if (!createsCommit && !isRebaseContinue && !mentionsGit) return command;
   if (movesHeadOnly) return command;
-  const tmpFile = join12(tmpdir(), `kf-coauthor-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+  const tmpFile = join13(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}"
@@ -5635,7 +5847,7 @@ var init_bash = __esm({
 
 // src/util/glob.ts
 import { readdir as readdir3, lstat, realpath } from "fs/promises";
-import { join as join13, relative as relative2, resolve as resolve2 } from "path";
+import { join as join14, relative as relative2, resolve as resolve2 } from "path";
 function parsePattern(pattern) {
   const parts = pattern.split(/\//g);
   return parts.map((p) => {
@@ -5744,7 +5956,7 @@ async function* walk(root, pattern, options) {
         if (!dot && name.startsWith(".")) continue;
         const matched = seg.type === "literal" ? seg.value === name : matchSegment(name, seg.value);
         if (!matched) continue;
-        const childPath = join13(dirPath, name);
+        const childPath = join14(dirPath, name);
         const childRel = [...relativeParts, name];
         const childRelStr = childRel.join("/");
         if (shouldIgnore(childRelStr, ignorePatterns)) continue;
@@ -5769,7 +5981,7 @@ async function* walk(root, pattern, options) {
       if (!dot && name.startsWith(".")) continue;
       const matched = seg.type === "literal" ? seg.value === name : matchSegment(name, seg.value);
       if (!matched) continue;
-      const childPath = join13(dirPath, name);
+      const childPath = join14(dirPath, name);
       const childRel = [...relativeParts, name];
       const childRelStr = childRel.join("/");
       if (shouldIgnore(childRelStr, ignorePatterns)) continue;
@@ -5811,7 +6023,7 @@ async function* walk(root, pattern, options) {
         const name = String(ent.name);
         if (name === "." || name === "..") continue;
         if (!dot && name.startsWith(".")) continue;
-        const childPath = join13(dirPath, name);
+        const childPath = join14(dirPath, name);
         const childRel = [...relativeParts, name];
         const childRelStr = childRel.join("/");
         if (shouldIgnore(childRelStr, ignorePatterns)) continue;
@@ -6497,7 +6709,7 @@ __export(changelog_image_exports, {
 });
 import { readFile as readFile9 } from "fs/promises";
 import { writeFile as writeFile7 } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 import { Resvg } from "@resvg/resvg-js";
 async function githubFetch2(path, token) {
   const controller = new AbortController();
@@ -6529,7 +6741,7 @@ function escapeXml(str) {
 }
 async function loadLogoBase64() {
   try {
-    const buf = await readFile9(join14(process.cwd(), "docs", "logo.png"));
+    const buf = await readFile9(join15(process.cwd(), "docs", "logo.png"));
     return `data:image/png;base64,${buf.toString("base64")}`;
   } catch {
     return null;
@@ -6837,7 +7049,7 @@ Format your response as plain text bullet points, one per line, starting with "\
 // src/tools/browser.ts
 import { mkdir as mkdir7 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join15, dirname as dirname7 } from "path";
+import { join as join16, dirname as dirname7 } from "path";
 async function autoScroll(page) {
   await page.evaluate(async () => {
     await new Promise((resolve8) => {
@@ -6913,7 +7125,7 @@ var init_browser = __esm({
           }
           let screenshotPath;
           if (args.screenshot) {
-            screenshotPath = join15(tmpdir2(), `kimiflare-browser-${Date.now()}.png`);
+            screenshotPath = join16(tmpdir2(), `kimiflare-browser-${Date.now()}.png`);
             await mkdir7(dirname7(screenshotPath), { recursive: true });
             await page.screenshot({ path: screenshotPath, fullPage: true });
           }
@@ -8295,11 +8507,11 @@ __export(sessions_exports, {
   sessionsDir: () => sessionsDir
 });
 import { readFile as readFile10, writeFile as writeFile9, mkdir as mkdir8, readdir as readdir4, stat as stat4 } from "fs/promises";
-import { homedir as homedir8 } from "os";
-import { join as join16 } from "path";
+import { homedir as homedir9 } from "os";
+import { join as join17 } from "path";
 function sessionsDir() {
-  const xdg = process.env.XDG_DATA_HOME || join16(homedir8(), ".local", "share");
-  return join16(xdg, "kimiflare", "sessions");
+  const xdg = process.env.XDG_DATA_HOME || join17(homedir9(), ".local", "share");
+  return join17(xdg, "kimiflare", "sessions");
 }
 function sanitize(text) {
   return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
@@ -8319,7 +8531,7 @@ function makeSessionId(firstPrompt) {
 async function saveSession(file) {
   const dir = sessionsDir();
   await mkdir8(dir, { recursive: true });
-  const path = join16(dir, `${file.id}.json`);
+  const path = join17(dir, `${file.id}.json`);
   await writeFile9(path, JSON.stringify(file, null, 2), "utf8");
   return path;
 }
@@ -8339,7 +8551,7 @@ async function listSessions(limit = 30, cwd) {
   const summaries = [];
   for (const name of entries) {
     if (!name.endsWith(".json")) continue;
-    const path = join16(dir, name);
+    const path = join17(dir, name);
     try {
       const [s, raw] = await Promise.all([stat4(path), readFile10(path, "utf8")]);
       const parsed = JSON.parse(raw);
@@ -8450,7 +8662,7 @@ var init_image = __esm({
 
 // src/permissions-evaluator.ts
 import { resolve as resolve3, relative as relative3 } from "path";
-import { homedir as homedir9 } from "os";
+import { homedir as homedir10 } from "os";
 function evaluatePermissionRules(req, rules) {
   const toolRules = rules[req.tool];
   if (!toolRules) return "ask";
@@ -8466,7 +8678,7 @@ function evaluatePermissionRules(req, rules) {
 }
 function expandHome(path) {
   if (path.startsWith("~/")) {
-    return resolve3(homedir9(), path.slice(2));
+    return resolve3(homedir10(), path.slice(2));
   }
   return path;
 }
@@ -8492,7 +8704,7 @@ function extractTarget(tool, args, cwd) {
 function matchPattern(target, pattern, cwd) {
   let expandedPattern = pattern;
   if (pattern.startsWith("~/")) {
-    expandedPattern = resolve3(homedir9(), pattern.slice(2));
+    expandedPattern = resolve3(homedir10(), pattern.slice(2));
   }
   if (target.startsWith(expandedPattern)) {
     return true;
@@ -8539,16 +8751,16 @@ var init_types = __esm({
 });
 
 // src/hooks/settings.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3, mkdirSync as mkdirSync2, writeFileSync } from "fs";
-import { homedir as homedir10 } from "os";
-import { join as join17, dirname as dirname8 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir11 } from "os";
+import { join as join18, dirname as dirname8 } from "path";
 import { createHash } from "crypto";
 function globalSettingsPath() {
-  const xdg = process.env.XDG_CONFIG_HOME || join17(homedir10(), ".config");
-  return join17(xdg, "kimiflare", "settings.json");
+  const xdg = process.env.XDG_CONFIG_HOME || join18(homedir11(), ".config");
+  return join18(xdg, "kimiflare", "settings.json");
 }
 function projectSettingsPath(cwd) {
-  return join17(cwd, ".kimiflare", "settings.json");
+  return join18(cwd, ".kimiflare", "settings.json");
 }
 function readSettingsFile(path) {
   if (!existsSync2(path)) return null;
@@ -8624,8 +8836,8 @@ function appendHook(scope, cwd, event, hook) {
     return rest;
   });
   existing.hooks = hooks;
-  mkdirSync2(dirname8(path), { recursive: true });
-  writeFileSync(path, JSON.stringify(existing, null, 2) + "\n", "utf8");
+  mkdirSync3(dirname8(path), { recursive: true });
+  writeFileSync2(path, JSON.stringify(existing, null, 2) + "\n", "utf8");
   return path;
 }
 function setHookEnabled(cwd, id, enabled) {
@@ -8650,8 +8862,8 @@ function setHookEnabled(cwd, id, enabled) {
       }
     }
     if (changed) {
-      mkdirSync2(dirname8(path), { recursive: true });
-      writeFileSync(path, JSON.stringify(existing, null, 2) + "\n", "utf8");
+      mkdirSync3(dirname8(path), { recursive: true });
+      writeFileSync2(path, JSON.stringify(existing, null, 2) + "\n", "utf8");
       return path;
     }
     void scope;
@@ -9381,11 +9593,11 @@ var init_heuristic = __esm({
 
 // src/cost-attribution/classify-from-session.ts
 import { readFile as readFile13 } from "fs/promises";
-import { join as join18 } from "path";
-import { homedir as homedir11 } from "os";
+import { join as join19 } from "path";
+import { homedir as homedir12 } from "os";
 function sessionsDir2() {
-  const xdg = process.env.XDG_DATA_HOME || join18(homedir11(), ".local", "share");
-  return join18(xdg, "kimiflare", "sessions");
+  const xdg = process.env.XDG_DATA_HOME || join19(homedir12(), ".local", "share");
+  return join19(xdg, "kimiflare", "sessions");
 }
 function parseToolCalls(calls) {
   return calls.map((c) => {
@@ -9399,7 +9611,7 @@ function parseToolCalls(calls) {
 }
 async function classifyFromSessionFile(sessionId) {
   try {
-    const raw = await readFile13(join18(sessionsDir2(), `${sessionId}.json`), "utf8");
+    const raw = await readFile13(join19(sessionsDir2(), `${sessionId}.json`), "utf8");
     const session = JSON.parse(raw);
     const messages = session.messages ?? [];
     const turns = [];
@@ -9433,14 +9645,14 @@ __export(cli_exports, {
   runCostCommand: () => runCostCommand
 });
 import { readFile as readFile14 } from "fs/promises";
-import { join as join19 } from "path";
-import { homedir as homedir12 } from "os";
+import { join as join20 } from "path";
+import { homedir as homedir13 } from "os";
 function usageDir() {
-  const xdg = process.env.XDG_DATA_HOME || join19(homedir12(), ".local", "share");
-  return join19(xdg, "kimiflare");
+  const xdg = process.env.XDG_DATA_HOME || join20(homedir13(), ".local", "share");
+  return join20(xdg, "kimiflare");
 }
 function usagePath() {
-  return join19(usageDir(), "usage.json");
+  return join20(usageDir(), "usage.json");
 }
 function today() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -10442,7 +10654,7 @@ __export(db_exports, {
 });
 import Database from "better-sqlite3";
 import { dirname as dirname9 } from "path";
-import { mkdirSync as mkdirSync3, statSync as statSync3 } from "fs";
+import { mkdirSync as mkdirSync4, statSync as statSync3 } from "fs";
 function initSchema(db) {
   db.exec(`
     CREATE TABLE IF NOT EXISTS memories (
@@ -10526,7 +10738,7 @@ function openMemoryDb(dbPath) {
   if (dbInstance) {
     dbInstance.close();
   }
-  mkdirSync3(dirname9(dbPath), { recursive: true });
+  mkdirSync4(dirname9(dbPath), { recursive: true });
   dbInstance = new Database(dbPath);
   dbInstance.pragma("journal_mode = WAL");
   dbInstance.pragma("foreign_keys = ON");
@@ -11237,6 +11449,50 @@ Return a JSON array of strings. Example:
         }
         return { id: memory.id, superseded: supersededIds.length > 0 ? supersededIds : void 0 };
       }
+      /**
+       * Store a plan directly under a deterministic topic key.
+       * Skips embedding, verification, and hypothetical queries so it is fast and
+       * deterministic. Supersedes any previous plan stored under the same key.
+       */
+      async rememberPlan(plan, repoPath, sessionId, topicKey = "current_dev_plan") {
+        if (!this.db) throw new Error("Memory DB not open");
+        const safeContent = this.shouldRedact() ? redactSecrets(plan) : plan;
+        if (!safeContent.trim()) {
+          throw new Error("Plan content is empty after redaction");
+        }
+        const normalizedKey = topicKey.trim();
+        if (!normalizedKey) {
+          throw new Error("Plan topic key cannot be empty");
+        }
+        const supersededIds = [];
+        const existing = findMemoriesByTopicKey(this.db, repoPath, normalizedKey);
+        for (const old of existing) {
+          supersedeMemory(this.db, old.id, "pending");
+          supersededIds.push(old.id);
+        }
+        const zeroEmbedding = new Float32Array(DEFAULT_EMBEDDING_DIM);
+        const memory = insertMemory(this.db, {
+          content: safeContent,
+          category: "task",
+          sourceSessionId: sessionId,
+          repoPath,
+          importance: 4,
+          topicKey: normalizedKey
+        }, zeroEmbedding);
+        for (const oldId of supersededIds) {
+          supersedeMemory(this.db, oldId, memory.id);
+        }
+        return { id: memory.id, superseded: supersededIds.length > 0 ? supersededIds : void 0 };
+      }
+      /**
+       * Recall the latest memory for an exact topic key.
+       * Does not use embeddings; returns null if no matching memory exists.
+       */
+      getByTopicKey(repoPath, topicKey) {
+        if (!this.db) return null;
+        const rows = findMemoriesByTopicKey(this.db, repoPath, topicKey);
+        return rows[0] ?? null;
+      }
       /**
        * Count high-signal memories created since the given timestamp.
        * Used for KIMI.md drift detection (Trigger A: session-start check).
@@ -12471,19 +12727,19 @@ var init_pricing = __esm({
 
 // src/usage-tracker.ts
 import { readFile as readFile16, writeFile as writeFile10, mkdir as mkdir9 } from "fs/promises";
-import { homedir as homedir13 } from "os";
-import { join as join21 } from "path";
+import { homedir as homedir14 } from "os";
+import { join as join22 } from "path";
 import { EventEmitter as EventEmitter2 } from "events";
 import { randomUUID } from "crypto";
 function usageDir2() {
-  const xdg = process.env.XDG_DATA_HOME || join21(homedir13(), ".local", "share");
-  return join21(xdg, "kimiflare");
+  const xdg = process.env.XDG_DATA_HOME || join22(homedir14(), ".local", "share");
+  return join22(xdg, "kimiflare");
 }
 function usagePath2() {
-  return join21(usageDir2(), "usage.json");
+  return join22(usageDir2(), "usage.json");
 }
 function historyPath() {
-  return join21(usageDir2(), "history.jsonl");
+  return join22(usageDir2(), "history.jsonl");
 }
 function today2() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -12930,8 +13186,8 @@ var init_permissions = __esm({
 
 // src/sdk/session.ts
 import { resolve as resolve6 } from "path";
-import { homedir as homedir14 } from "os";
-import { join as join22 } from "path";
+import { homedir as homedir15 } from "os";
+import { join as join23 } from "path";
 import { existsSync as existsSync3 } from "fs";
 async function createAgentSession(opts2) {
   const config2 = await resolveSdkConfig(opts2);
@@ -12946,7 +13202,7 @@ async function createAgentSession(opts2) {
   let memoryManager = null;
   const memoryEnabled = opts2.memoryEnabled ?? config2.memoryEnabled ?? false;
   if (memoryEnabled) {
-    const dbPath = config2.memoryDbPath ?? join22(homedir14(), ".local", "share", "kimiflare", "memory.db");
+    const dbPath = config2.memoryDbPath ?? join23(homedir15(), ".local", "share", "kimiflare", "memory.db");
     memoryManager = new MemoryManager({
       dbPath,
       accountId: config2.accountId,
@@ -12977,7 +13233,7 @@ async function createAgentSession(opts2) {
   }
   let sessionFile;
   if (opts2.sessionId) {
-    const filePath = join22(sessionsDir(), `${opts2.sessionId}.json`);
+    const filePath = join23(sessionsDir(), `${opts2.sessionId}.json`);
     try {
       sessionFile = await loadSession(filePath);
     } catch {
@@ -13390,7 +13646,7 @@ var init_session = __esm({
             }
           }
         });
-        if (existsSync3(join22(this.cwd, "KIMI.md"))) {
+        if (existsSync3(join23(this.cwd, "KIMI.md"))) {
           this.messages[0] = {
             role: "system",
             content: buildSystemPrompt({
@@ -13667,7 +13923,7 @@ var init_repo_info = __esm({
 // src/agent/supervisor.ts
 import { readdir as readdir5, readFile as readFile17, stat as stat5 } from "fs/promises";
 import { createHash as createHash2 } from "crypto";
-import { resolve as resolve7, join as join23 } from "path";
+import { resolve as resolve7, join as join24 } from "path";
 async function preReadFilesForWorkers(files, repoRoot, maxChars = DEFAULT_PRE_READ_MAX_CHARS) {
   const results = [];
   const filesRead = [];
@@ -13702,7 +13958,7 @@ ${results.join("\n\n")}`,
 }
 function getPreReadFilesFromMemory(cfg, repoRoot, limit = 10) {
   if (!cfg.memoryEnabled) return [];
-  const dbPath = cfg.memoryDbPath ?? join23(repoRoot, ".kimiflare", "memory.db");
+  const dbPath = cfg.memoryDbPath ?? join24(repoRoot, ".kimiflare", "memory.db");
   try {
     const db = openMemoryDb(dbPath);
     const files = getTopRelatedFiles(db, repoRoot, limit);
@@ -15203,7 +15459,7 @@ var init_attach_mode = __esm({
 import { spawn as spawn4 } from "child_process";
 import { mkdtemp, readFile as readFile18, writeFile as writeFile11, rm } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 async function cfApiFetch(accountId, apiToken, path, init) {
   const url = `${CF_API}/accounts/${encodeURIComponent(accountId)}${path}`;
@@ -15434,8 +15690,8 @@ ${wranglerInstall.stderr.slice(-600)}`,
     ok: true
   };
   yield { message: "Prerequisites ready", ok: true };
-  const tmpRoot = await mkdtemp(join24(tmpdir3(), "kimiflare-commute-"));
-  const repoDir = join24(tmpRoot, "kimiflare-commute");
+  const tmpRoot = await mkdtemp(join25(tmpdir3(), "kimiflare-commute-"));
+  const repoDir = join25(tmpRoot, "kimiflare-commute");
   yield { message: `Fetching worker source from GitHub (${COMMUTE_REPO})\u2026` };
   const clone = await runCmd("git", ["clone", "--depth", "1", "--branch", COMMUTE_BRANCH, COMMUTE_REPO, repoDir], { timeoutMs: 6e4 });
   if (clone.code !== 0) {
@@ -15444,8 +15700,8 @@ ${(clone.stderr || clone.stdout).slice(0, 400)}`, error: true };
     throw new Error("clone failed");
   }
   yield { message: "Source fetched from GitHub", ok: true };
-  const workerDir = join24(repoDir, "remote", "worker");
-  const wranglerToml = join24(workerDir, "wrangler.toml");
+  const workerDir = join25(repoDir, "remote", "worker");
+  const wranglerToml = join25(workerDir, "wrangler.toml");
   yield { message: "Installing Worker dependencies (npm install)\u2026" };
   const install = await runCmd("npm", ["install", "--no-audit", "--no-fund", "--loglevel=error"], {
     cwd: workerDir,
@@ -15787,7 +16043,7 @@ __export(app_helpers_exports, {
 });
 import { execSync as execSync3, spawn as spawn5 } from "child_process";
 import { existsSync as existsSync4, readFileSync as readFileSync4, statSync as statSync4 } from "fs";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 import { platform as platform3 } from "os";
 function buildFilePickerIgnoreList(cwd) {
   const hardcoded = [
@@ -15859,7 +16115,7 @@ function buildFilePickerIgnoreList(cwd) {
   ];
   const gitignorePatterns = [];
   try {
-    const gitignorePath = join25(cwd, ".gitignore");
+    const gitignorePath = join26(cwd, ".gitignore");
     const stats = statSync4(gitignorePath);
     if (stats.size > MAX_GITIGNORE_SIZE) {
       return hardcoded;
@@ -16405,7 +16661,7 @@ var init_frontmatter = __esm({
 
 // src/skills/loader.ts
 import { readFile as readFile19, readdir as readdir6, stat as stat6 } from "fs/promises";
-import { join as join26, extname } from "path";
+import { join as join27, extname } from "path";
 function normalizeManifest(raw, filePath) {
   const name = typeof raw.name === "string" ? raw.name : "";
   const description = typeof raw.description === "string" ? raw.description : "";
@@ -16441,7 +16697,7 @@ async function loadSkillsFromDir(dirPath) {
     const entries = await readdir6(dirPath);
     const files = [];
     for (const entry of entries) {
-      const full = join26(dirPath, entry);
+      const full = join27(dirPath, entry);
       const s = await stat6(full);
       if (s.isFile() && extname(entry) === ".md") {
         files.push(full);
@@ -16470,7 +16726,7 @@ var init_loader = __esm({
 
 // src/skills/discovery.ts
 import { readdir as readdir7, stat as stat7, readFile as readFile20 } from "fs/promises";
-import { join as join27, extname as extname2 } from "path";
+import { join as join28, extname as extname2 } from "path";
 async function dirExists(path) {
   try {
     const s = await stat7(path);
@@ -16494,15 +16750,15 @@ async function scanSkillDir(dirPath, source) {
   for (const entry of entries) {
     if (!entry.isFile()) continue;
     if (!SKILL_EXTENSIONS.has(extname2(entry.name))) continue;
-    files.push({ filePath: join27(dirPath, entry.name), source });
+    files.push({ filePath: join28(dirPath, entry.name), source });
   }
   return files;
 }
 async function discoverSkills(cwd) {
-  const agentsSkills = await scanSkillDir(join27(cwd, ".agents", "skills"), "agents");
-  const agentsMd = await fileExists(join27(cwd, "AGENTS.md")) ? [{ filePath: join27(cwd, "AGENTS.md"), source: "agents-md" }] : [];
-  const githubSkills = await scanSkillDir(join27(cwd, ".github", "skills"), "github");
-  const kimiflareSkills = await scanSkillDir(join27(cwd, ".kimiflare", "skills"), "kimiflare");
+  const agentsSkills = await scanSkillDir(join28(cwd, ".agents", "skills"), "agents");
+  const agentsMd = await fileExists(join28(cwd, "AGENTS.md")) ? [{ filePath: join28(cwd, "AGENTS.md"), source: "agents-md" }] : [];
+  const githubSkills = await scanSkillDir(join28(cwd, ".github", "skills"), "github");
+  const kimiflareSkills = await scanSkillDir(join28(cwd, ".kimiflare", "skills"), "kimiflare");
   const ordered = [...agentsSkills, ...agentsMd, ...githubSkills, ...kimiflareSkills];
   return ordered;
 }
@@ -16823,6 +17079,32 @@ var init_distill = __esm({
   }
 });
 
+// src/agent/plan-resolver.ts
+function resolvePlanForFresh(opts2) {
+  const { mode, messages, sessionPlan, memoryManager, memoryEnabled, repoPath } = opts2;
+  if (mode !== "plan") {
+    return null;
+  }
+  if (sessionPlan) {
+    return sessionPlan;
+  }
+  if (memoryEnabled && memoryManager) {
+    const stored = memoryManager.getByTopicKey(repoPath, PLAN_MEMORY_TOPIC_KEY);
+    if (stored?.content) {
+      return stored.content;
+    }
+  }
+  return distillSessionPlan(messages);
+}
+var PLAN_MEMORY_TOPIC_KEY;
+var init_plan_resolver = __esm({
+  "src/agent/plan-resolver.ts"() {
+    "use strict";
+    init_distill();
+    PLAN_MEMORY_TOPIC_KEY = "current_dev_plan";
+  }
+});
+
 // src/agent/continuation-summary.ts
 import { execSync as execSync4 } from "child_process";
 function extractFirstUserGoal(messages) {
@@ -18015,11 +18297,11 @@ var init_ai_gateway_api = __esm({
 
 // src/skills/manager.ts
 import { mkdir as mkdir10, writeFile as writeFile12, unlink as unlink2, readFile as readFile21 } from "fs/promises";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 function getSkillDirs(cwd) {
   return {
-    projectDir: join28(cwd, ".kimiflare", "skills"),
-    globalDir: join28(process.env.HOME ?? "", ".config", "kimiflare", "skills")
+    projectDir: join29(cwd, ".kimiflare", "skills"),
+    globalDir: join29(process.env.HOME ?? "", ".config", "kimiflare", "skills")
   };
 }
 async function listAllSkills(cwd) {
@@ -18033,7 +18315,7 @@ async function listAllSkills(cwd) {
 async function createSkill(opts2) {
   const dirs = getSkillDirs(opts2.cwd);
   const dir = opts2.scope === "project" ? dirs.projectDir : dirs.globalDir;
-  const filepath = join28(dir, `${opts2.name}.md`);
+  const filepath = join29(dir, `${opts2.name}.md`);
   const frontmatter = {
     name: opts2.name,
     enabled: true,
@@ -18153,14 +18435,14 @@ var init_frontmatter2 = __esm({
 
 // src/commands/loader.ts
 import { open, realpath as realpath2 } from "fs/promises";
-import { homedir as homedir15 } from "os";
-import { join as join29, relative as relative6, sep as sep2 } from "path";
+import { homedir as homedir16 } from "os";
+import { join as join30, relative as relative6, sep as sep2 } from "path";
 function projectCommandsDir(cwd = process.cwd()) {
-  return join29(cwd, ".kimiflare", "commands");
+  return join30(cwd, ".kimiflare", "commands");
 }
 function globalCommandsDir() {
-  const xdg = process.env.XDG_CONFIG_HOME || join29(homedir15(), ".config");
-  return join29(xdg, "kimiflare", "commands");
+  const xdg = process.env.XDG_CONFIG_HOME || join30(homedir16(), ".config");
+  return join30(xdg, "kimiflare", "commands");
 }
 async function loadCustomCommands(cwd = process.cwd()) {
   const warnings = [];
@@ -18531,12 +18813,12 @@ var init_recommended = __esm({
 
 // src/init/context-generator.ts
 import { existsSync as existsSync5, statSync as statSync5 } from "fs";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 function detectFlavor(cwd) {
   for (const [flavor, signatures] of Object.entries(FLAVOR_SIGNATURES)) {
     if (flavor === "generic") continue;
     for (const sig of signatures) {
-      const path = join30(cwd, sig);
+      const path = join31(cwd, sig);
       if (sig.includes("*")) {
         try {
           const parts = sig.split("*");
@@ -18557,14 +18839,14 @@ function detectFlavor(cwd) {
 }
 function findFile(cwd, candidates) {
   for (const c of candidates) {
-    if (existsSync5(join30(cwd, c))) return c;
+    if (existsSync5(join31(cwd, c))) return c;
   }
   return null;
 }
 function findSourceRoots(cwd) {
   const roots = [];
   for (const r of SOURCE_ROOT_CANDIDATES) {
-    const p = join30(cwd, r);
+    const p = join31(cwd, r);
     try {
       const s = statSync5(p);
       if (s.isDirectory()) roots.push(r);
@@ -18575,9 +18857,9 @@ function findSourceRoots(cwd) {
 }
 function findCiConfig(cwd) {
   for (const c of CI_PATHS) {
-    if (existsSync5(join30(cwd, c))) {
+    if (existsSync5(join31(cwd, c))) {
       try {
-        const s = statSync5(join30(cwd, c));
+        const s = statSync5(join31(cwd, c));
         return s.isDirectory() ? c : c;
       } catch {
       }
@@ -18714,7 +18996,7 @@ function analyzeProject(cwd) {
     ciConfig: findCiConfig(cwd),
     readme: findFile(cwd, ["README.md", "README.rst", "README.txt", "Readme.md"]),
     sourceRoots: findSourceRoots(cwd),
-    hasGit: existsSync5(join30(cwd, ".git"))
+    hasGit: existsSync5(join31(cwd, ".git"))
   };
 }
 function bashDiscoveryCommands(profile) {
@@ -18879,7 +19161,7 @@ Aim for 100\u2013200 lines total. Use markdown tables where they save space.
 }
 function buildInitPrompt(cwd) {
   const existingName = ["KIMI.md", "KIMIFLARE.md", "AGENT.md"].find(
-    (n) => existsSync5(join30(cwd, n))
+    (n) => existsSync5(join31(cwd, n))
   );
   const isRefresh = existingName !== void 0;
   const targetFilename = existingName ?? "KIMI.md";
@@ -18968,10 +19250,10 @@ __export(ui_mode_exports, {
   runUiMode: () => runUiMode
 });
 import { execSync as execSync6, spawn as spawn6 } from "child_process";
-import { appendFileSync, mkdirSync as mkdirSync4, openSync } from "fs";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync5, openSync } from "fs";
 import { unlink as unlink4 } from "fs/promises";
-import { join as join31 } from "path";
-import { homedir as homedir16, platform as platform6 } from "os";
+import { join as join32 } from "path";
+import { homedir as homedir17, platform as platform6 } from "os";
 import { randomUUID as randomUUID2 } from "crypto";
 import { readFile as readFile22 } from "fs/promises";
 import QRCode from "qrcode";
@@ -18979,7 +19261,7 @@ function kimiLog(payload) {
   if (!KIMI_LOG_PATH) return;
   try {
     const line = JSON.stringify({ ts: Date.now() / 1e3, ...payload }) + "\n";
-    appendFileSync(KIMI_LOG_PATH, line);
+    appendFileSync2(KIMI_LOG_PATH, line);
   } catch {
   }
 }
@@ -19011,13 +19293,13 @@ function gatewayFromOpts2(opts2) {
 }
 async function runUiMode(opts2) {
   await loadCamouflage();
-  const xdgConfig = process.env.XDG_CONFIG_HOME || join31(homedir16(), ".config");
-  const camoDbDir = join31(xdgConfig, "kimiflare");
+  const xdgConfig = process.env.XDG_CONFIG_HOME || join32(homedir17(), ".config");
+  const camoDbDir = join32(xdgConfig, "kimiflare");
   try {
-    mkdirSync4(camoDbDir, { recursive: true });
+    mkdirSync5(camoDbDir, { recursive: true });
   } catch {
   }
-  const camoDbPath = join31(camoDbDir, "camouflage-sessions.db");
+  const camoDbPath = join32(camoDbDir, "camouflage-sessions.db");
   let cam;
   try {
     cam = await mount({
@@ -19073,7 +19355,7 @@ ${err instanceof Error ? err.message : err}`);
   let mcpInit = false;
   let lspInit = false;
   if (startupCfg?.memoryEnabled) {
-    const dbPath = startupCfg.memoryDbPath ?? join31(process.cwd(), ".kimiflare", "memory.db");
+    const dbPath = startupCfg.memoryDbPath ?? join32(process.cwd(), ".kimiflare", "memory.db");
     memoryManager = new MemoryManager({
       dbPath,
       accountId: opts2.accountId,
@@ -19099,7 +19381,7 @@ ${err instanceof Error ? err.message : err}`);
       }
     });
   }
-  const skillDbPath = startupCfg?.memoryDbPath ?? join31(process.cwd(), ".kimiflare", "memory.db");
+  const skillDbPath = startupCfg?.memoryDbPath ?? join32(process.cwd(), ".kimiflare", "memory.db");
   const skillDb = getMemoryDb() ?? openMemoryDb(skillDbPath);
   initSkillsSchema(skillDb);
   void indexSkills({
@@ -19909,6 +20191,10 @@ Executor opened PR: ${prUrl}` : plan });
         const plan = distillSessionPlan(messages);
         if (plan) {
           sessionPlan = plan;
+          if (startupCfg?.memoryEnabled && memoryManager) {
+            void memoryManager.rememberPlan(plan, process.cwd(), randomUUID2()).catch(() => {
+            });
+          }
         }
       }
       if (planOptionsRef.current && !currentController?.signal.aborted) {
@@ -21655,7 +21941,14 @@ changelog-image failed: ${err instanceof Error ? err.message : String(err)}
           return true;
         }
         void (async () => {
-          const summary = await generateContinuationSummary({
+          const summary = currentMode === "plan" ? resolvePlanForFresh({
+            mode: currentMode,
+            messages,
+            sessionPlan,
+            memoryManager,
+            memoryEnabled: startupCfg?.memoryEnabled,
+            repoPath: process.cwd()
+          }) : await generateContinuationSummary({
             messages,
             mode: currentMode,
             accountId: opts2.accountId,
@@ -21954,6 +22247,7 @@ var init_ui_mode = __esm({
     init_sessions();
     init_llm_summarize();
     init_distill();
+    init_plan_resolver();
     init_continuation_summary();
     init_greetings();
     init_theme();
@@ -26731,10 +27025,10 @@ var init_wcag = __esm({
 
 // src/ui/theme-loader.ts
 import { readFile as readFile23, readdir as readdir9 } from "fs/promises";
-import { join as join32 } from "path";
-import { homedir as homedir17 } from "os";
+import { join as join33 } from "path";
+import { homedir as homedir18 } from "os";
 function projectThemesDir(cwd = process.cwd()) {
-  return join32(cwd, ".kimiflare", "themes");
+  return join33(cwd, ".kimiflare", "themes");
 }
 function isHexColor(c) {
   return /^#[0-9a-fA-F]{6}$/.test(c);
@@ -26823,7 +27117,7 @@ async function loadThemesFromDir(dir, source) {
     return { themes, errors };
   }
   for (const file of files.filter((f) => f.endsWith(".json"))) {
-    const path = join32(dir, file);
+    const path = join33(dir, file);
     let raw;
     try {
       raw = await readFile23(path, "utf-8");
@@ -26972,8 +27266,8 @@ var init_theme_loader = __esm({
     "use strict";
     init_wcag();
     init_theme();
-    USER_THEMES_DIR = join32(
-      process.env.XDG_CONFIG_HOME || join32(homedir17(), ".config"),
+    USER_THEMES_DIR = join33(
+      process.env.XDG_CONFIG_HOME || join33(homedir18(), ".config"),
       "kimiflare",
       "themes"
     );
@@ -31078,9 +31372,7 @@ function useSessionManager(deps) {
             const results = await manager.recall({ text: cwd, repoPath: cwd, limit: 5 });
             if (results.length > 0) {
               const text = await manager.synthesizeRecalled(results);
-              const lastSystemIdx = d.messagesRef.current.findLastIndex((m) => m.role === "system");
-              const insertIdx = lastSystemIdx >= 0 ? lastSystemIdx + 1 : d.messagesRef.current.length;
-              d.messagesRef.current.splice(insertIdx, 0, { role: "system", content: text });
+              injectRecalledMemoryOnce(d.messagesRef.current, text);
             }
           } catch {
           }
@@ -31197,6 +31489,7 @@ var init_use_session_manager = __esm({
     "use strict";
     init_sessions();
     init_session_state();
+    init_recall_inject();
     init_usage_tracker();
     init_log_sink();
     init_app_helpers();
@@ -31350,14 +31643,14 @@ __export(tui_report_exports, {
   getCategoryReportText: () => getCategoryReportText
 });
 import { readFile as readFile24 } from "fs/promises";
-import { join as join33 } from "path";
-import { homedir as homedir18 } from "os";
+import { join as join34 } from "path";
+import { homedir as homedir19 } from "os";
 function usageDir3() {
-  const xdg = process.env.XDG_DATA_HOME || join33(homedir18(), ".local", "share");
-  return join33(xdg, "kimiflare");
+  const xdg = process.env.XDG_DATA_HOME || join34(homedir19(), ".local", "share");
+  return join34(xdg, "kimiflare");
 }
 function usagePath3() {
-  return join33(usageDir3(), "usage.json");
+  return join34(usageDir3(), "usage.json");
 }
 function today3() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -31426,7 +31719,7 @@ var init_tui_report = __esm({
 });
 
 // src/ui/slash-commands.ts
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 import { unlink as unlink5 } from "fs/promises";
 import QRCode2 from "qrcode";
 function executeFreshStart(ctx, planText, overrideMode) {
@@ -31507,6 +31800,7 @@ var init_slash_commands = __esm({
     init_session_store();
     init_deploy();
     init_tui_auth();
+    init_plan_resolver();
     init_continuation_summary();
     init_clipboard();
     handleExit = (ctx) => {
@@ -31559,7 +31853,14 @@ var init_slash_commands = __esm({
         ]);
         return true;
       }
-      const summary = await generateContinuationSummary({
+      const summary = ctx.mode === "plan" ? resolvePlanForFresh({
+        mode: ctx.mode,
+        messages: ctx.messagesRef.current,
+        sessionPlan: ctx.sessionPlanRef.current,
+        memoryManager: ctx.memoryManagerRef.current,
+        memoryEnabled: cfg?.memoryEnabled,
+        repoPath: process.cwd()
+      }) : await generateContinuationSummary({
         messages: ctx.messagesRef.current,
         mode: ctx.mode,
         accountId: cfg?.accountId ?? "",
@@ -32276,7 +32577,7 @@ ${lines.join("\n")}` }]);
         void (async () => {
           try {
             const { sessionsDir: sessionsDir3 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
-            const file = await loadSession(join34(sessionsDir3(), `${currentId}.json`));
+            const file = await loadSession(join35(sessionsDir3(), `${currentId}.json`));
             const cps = file.checkpoints ?? [];
             if (cps.length === 0) {
               setEvents((e) => [...e, { kind: "info", key: mkKey2(), text: "no checkpoints in this session" }]);
@@ -32321,7 +32622,7 @@ ${lines.join("\n")}` }]);
         try {
           ctx.ensureSessionId();
           const { sessionsDir: sessionsDir3 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
-          const filePath = join34(sessionsDir3(), `${ctx.sessionIdRef.current}.json`);
+          const filePath = join35(sessionsDir3(), `${ctx.sessionIdRef.current}.json`);
           await addCheckpoint(filePath, cp);
           setEvents((e) => [...e, { kind: "info", key: mkKey2(), text: `checkpoint saved: "${label}"` }]);
         } catch (e) {
@@ -32956,7 +33257,7 @@ project: ${projectSettingsPath(cwd)}`
 
 // src/init/run-init.ts
 import { existsSync as existsSync6 } from "fs";
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 async function runInit(deps) {
   const {
     cfg,
@@ -33159,7 +33460,7 @@ async function runInit(deps) {
         }
       }
     });
-    if (existsSync6(join35(cwd, "KIMI.md"))) {
+    if (existsSync6(join36(cwd, "KIMI.md"))) {
       if (cacheStableRef.current) {
         messagesRef.current[1] = {
           role: "system",
@@ -33254,7 +33555,7 @@ var init_run_init = __esm({
 
 // src/ui/run-startup-tasks.ts
 import { existsSync as existsSync7 } from "fs";
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 function runStartupTasks(deps) {
   const {
     cfg,
@@ -33275,7 +33576,7 @@ function runStartupTasks(deps) {
     }
   });
   if (cfg.memoryEnabled) {
-    const dbPath = cfg.memoryDbPath ?? join36(process.cwd(), ".kimiflare", "memory.db");
+    const dbPath = cfg.memoryDbPath ?? join37(process.cwd(), ".kimiflare", "memory.db");
     const manager = new MemoryManager({
       dbPath,
       accountId: cfg.accountId,
@@ -33309,7 +33610,7 @@ function runStartupTasks(deps) {
     });
     const cwd = process.cwd();
     sessionStartRecallRef.current = manager.recall({ text: cwd, repoPath: cwd, limit: 5 });
-    if (existsSync7(join36(cwd, "KIMI.md"))) {
+    if (existsSync7(join37(cwd, "KIMI.md"))) {
       const lastRefresh = manager.getLastKimiMdRefreshTime(cwd);
       const driftCount = manager.countHighSignalMemoriesSince(cwd, lastRefresh);
       if (driftCount >= 5) {
@@ -33320,7 +33621,7 @@ function runStartupTasks(deps) {
     memoryManagerRef.current?.close();
     memoryManagerRef.current = null;
   }
-  const skillDbPath = cfg.memoryDbPath ?? join36(process.cwd(), ".kimiflare", "memory.db");
+  const skillDbPath = cfg.memoryDbPath ?? join37(process.cwd(), ".kimiflare", "memory.db");
   const skillDb = getMemoryDb() ?? openMemoryDb(skillDbPath);
   initSkillsSchema(skillDb);
   void indexSkills({
@@ -33784,7 +34085,7 @@ __export(app_exports, {
 import React25, { useState as useState29, useRef as useRef7, useEffect as useEffect11, useCallback as useCallback10, useMemo as useMemo6 } from "react";
 import { Box as Box42, Text as Text43, useApp, useInput as useInput21, render } from "ink";
 import { existsSync as existsSync8 } from "fs";
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 import { jsx as jsx44, jsxs as jsxs42 } from "react/jsx-runtime";
 function App({
   initialCfg,
@@ -34404,18 +34705,17 @@ ${wcagWarnings.join("\n")}` }
             const results = await manager.recall({ text: queryText, repoPath: cwd, limit: 5 });
             if (results.length > 0 && !signal.aborted) {
               const text = await manager.synthesizeRecalled(results);
-              const lastSystemIdx = result.newMessages.findLastIndex((m) => m.role === "system");
-              const insertIdx = lastSystemIdx >= 0 ? lastSystemIdx + 1 : result.newMessages.length;
-              result.newMessages.splice(insertIdx, 0, { role: "system", content: text });
-              setEvents((e) => [
-                ...e,
-                {
-                  kind: "memory",
-                  key: mkKey(),
-                  text: `recalled ${results.length} memory${results.length === 1 ? "" : "ies"} after compaction`
-                }
-              ]);
-              await saveSessionSafe();
+              if (injectRecalledMemoryOnce(result.newMessages, text)) {
+                setEvents((e) => [
+                  ...e,
+                  {
+                    kind: "memory",
+                    key: mkKey(),
+                    text: `recalled ${results.length} memory${results.length === 1 ? "" : "ies"} after compaction`
+                  }
+                ]);
+                await saveSessionSafe();
+              }
             }
           } catch {
           }
@@ -34999,7 +35299,14 @@ ${wcagWarnings.join("\n")}` }
     (picked) => {
       setShowPlanCompletePicker(false);
       if (!picked || picked === "continue") return;
-      const plan = sessionPlanRef.current ?? distillSessionPlan(messagesRef.current);
+      const plan = resolvePlanForFresh({
+        mode: "plan",
+        messages: messagesRef.current,
+        sessionPlan: sessionPlanRef.current,
+        memoryManager: memoryManagerRef.current,
+        memoryEnabled: cfg?.memoryEnabled,
+        repoPath: process.cwd()
+      });
       if (!plan) {
         setEvents((e) => [
           ...e,
@@ -35199,7 +35506,7 @@ ${wcagWarnings.join("\n")}` }
         }
       }
       turnCounterRef.current += 1;
-      if (turnCounterRef.current % 15 === 0 && existsSync8(join37(process.cwd(), "KIMI.md")) && !kimiMdStale) {
+      if (turnCounterRef.current % 15 === 0 && existsSync8(join38(process.cwd(), "KIMI.md")) && !kimiMdStale) {
         setEvents((e) => [
           ...e,
           { kind: "info", key: mkKey(), text: "Tip: Rerunning /init occasionally helps KimiFlare stay accurate as your project evolves." }
@@ -35223,7 +35530,7 @@ ${wcagWarnings.join("\n")}` }
                 };
                 ensureSessionId();
                 const { sessionsDir: sessionsDir3 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
-                const filePath = join37(sessionsDir3(), `${sessionIdRef.current}.json`);
+                const filePath = join38(sessionsDir3(), `${sessionIdRef.current}.json`);
                 await addCheckpoint(filePath, cp);
               }
               const summary = await generateContinuationSummary({
@@ -35679,18 +35986,17 @@ ${conflicts.join("\n")}` }
                       const results = await manager.recall({ text: queryText, repoPath: cwd, limit: 5 });
                       if (results.length > 0) {
                         const text2 = await manager.synthesizeRecalled(results);
-                        const lastSystemIdx = messagesRef.current.findLastIndex((m) => m.role === "system");
-                        const insertIdx = lastSystemIdx >= 0 ? lastSystemIdx + 1 : messagesRef.current.length;
-                        messagesRef.current.splice(insertIdx, 0, { role: "system", content: text2 });
-                        setEvents((e) => [
-                          ...e,
-                          {
-                            kind: "memory",
-                            key: mkKey(),
-                            text: `recalled ${results.length} memory${results.length === 1 ? "" : "ies"} after compaction`
-                          }
-                        ]);
-                        await saveSessionSafe();
+                        if (injectRecalledMemoryOnce(messagesRef.current, text2)) {
+                          setEvents((e) => [
+                            ...e,
+                            {
+                              kind: "memory",
+                              key: mkKey(),
+                              text: `recalled ${results.length} memory${results.length === 1 ? "" : "ies"} after compaction`
+                            }
+                          ]);
+                          await saveSessionSafe();
+                        }
                       }
                     } catch {
                     }
@@ -35703,6 +36009,10 @@ ${conflicts.join("\n")}` }
               const plan = distillSessionPlan(messagesRef.current);
               if (plan) {
                 sessionPlanRef.current = plan;
+                if (cfg?.memoryEnabled && memoryManagerRef.current && sessionIdRef.current) {
+                  void memoryManagerRef.current.rememberPlan(plan, process.cwd(), sessionIdRef.current).catch(() => {
+                  });
+                }
                 setShowPlanCompletePicker(true);
               }
             }
@@ -35872,7 +36182,7 @@ ${conflicts.join("\n")}` }
         onCommandDelete: handleCommandDelete2,
         lspServers: cfg?.lspServers ?? {},
         lspScope,
-        hasProjectDir: existsSync8(join37(process.cwd(), ".kimiflare")),
+        hasProjectDir: existsSync8(join38(process.cwd(), ".kimiflare")),
         onLspSave: handleLspSave2,
         themes: themeList(),
         onPickTheme: handleThemePick,
@@ -36265,6 +36575,7 @@ var init_app = __esm({
     init_sessions();
     init_image();
     init_usage_tracker();
+    init_recall_inject();
     init_loader2();
     init_renderer2();
     init_builtins();
@@ -36291,6 +36602,7 @@ var init_app = __esm({
     init_manager_init();
     init_run_compact();
     init_distill();
+    init_plan_resolver();
     init_command_handlers();
     init_app_helpers();
   }