@cjhyy/code-shell 0.1.0-alpha.3 → 0.1.6

package/dist/{chunk-ID6EJUHP.js → chunk-PKGRTCCY.js}

@@ -1,9 +1,12 @@
 import {
   ModelPool
-} from "./chunk-F5BS3GUC.js";
+} from "./chunk-BSW22MPA.js";
+import {
+  defaultCacheDir
+} from "./chunk-3OA5G4TM.js";
 import {
   MCPManager
-} from "./chunk-2EUAE7AY.js";
+} from "./chunk-SIHHIQLO.js";
 import {
   applySummaryCompaction,
   applyToolResultBudget,
@@ -15,48 +18,52 @@ import {
   snipCompact,
   truncateToolResult,
   windowCompact
-} from "./chunk-5C5HIOML.js";
+} from "./chunk-7Y6S3OCX.js";
 import {
   MemoryManager
-} from "./chunk-I57ZD5IQ.js";
+} from "./chunk-VIAGTYYW.js";
 import {
   SessionManager
-} from "./chunk-ZLPJJZUW.js";
+} from "./chunk-76HYEPDM.js";
 import {
   SettingsManager
-} from "./chunk-75E4BBFC.js";
+} from "./chunk-3SBSUOWZ.js";
 import {
   FileHistory
-} from "./chunk-SK62UVS6.js";
+} from "./chunk-T6VYG46N.js";
 import {
   webFetchTool,
   webFetchToolDef,
   webSearchTool,
   webSearchToolDef
-} from "./chunk-OUC2DFA7.js";
+} from "./chunk-QARL3IDQ.js";
 import {
   Arena,
   MODEL_PRESETS,
+  buildModelPool,
   createLLMClient,
   createProgressRenderer,
+  detectProviderFromApiKey,
   formatArenaResultForSession,
   getMaxOutputTokens
-} from "./chunk-Y7TSCDF6.js";
+} from "./chunk-BZ5TNE7L.js";
 import {
   ConfigError,
   ContextLimitError,
   ToolExecutionError,
   ToolNotFoundError,
   ToolTimeoutError
-} from "./chunk-FUOKLKR2.js";
+} from "./chunk-SFXHZSRF.js";
 import {
+  getCurrentSid,
   logger
-} from "./chunk-ZRVPCXI7.js";
+} from "./chunk-BXCY2FSE.js";
 import {
+  __dirname,
   __require,
   __toCommonJS,
   init_esm_shims
-} from "./chunk-DI7RDLOS.js";
+} from "./chunk-MD32R22I.js";
 
 // src/tool-system/builtin/task.ts
 init_esm_shims();
@@ -380,7 +387,7 @@ var fileCache = new FileStateCache();
 // src/tool-system/builtin/read.ts
 var readToolDef = {
   name: "Read",
-  description: "Read a file from the local filesystem. Returns the file content with line numbers. By default reads up to 2000 lines from the beginning. Use offset and limit to read specific portions of large files. For large files, consider using Grep first to find the relevant lines.",
+  description: "Read a file from the local filesystem. Returns the file content with line numbers. By default reads up to 2000 lines from the beginning. Use offset and limit to read specific portions of large files. For large files, consider using Grep first to find the relevant lines.\n\nDo NOT re-read a file you just edited to verify \u2014 Edit/Write would have errored if the change failed.\nDo NOT re-read a file (or the same range of a file) you've already read earlier in this conversation. The content is already in your context. If you need a different part of the file, read a different offset; otherwise decide with what you have.",
   inputSchema: {
     type: "object",
     properties: {
@@ -1364,11 +1371,40 @@ ${output}`;
 init_esm_shims();
 var askUserToolDef = {
   name: "AskUserQuestion",
-  description: "Ask the user a question and wait for their response. Use this when you need clarification, confirmation, or additional input from the user. In headless mode this tool will return an error.",
+  description: "Ask the user a question and wait for their response. Use this when you need clarification, confirmation, or additional input from the user. Pass `options` to present a multiple-choice list (recommended when the answer is one of a small known set \u2014 much better UX than free text). Each option needs a short `label` (the choice the user sees) and a `description` (what it means). Lead with the recommended option and append a recommendation marker to its label in the same language as the question (e.g. '(Recommended)' for an English question, '(\u63A8\u8350)' for a Chinese question). Set `multiSelect: true` when more than one choice can apply. ALWAYS write the `question`, every option `label`, every option `description`, and the `header` in the SAME LANGUAGE the user has been writing in. If the user wrote to you in Chinese, write all of these fields in Chinese; if Japanese, in Japanese; etc. The framework's UI chrome (separator hints, the implicit 'Other...' entry) is fixed \u2014 only your fields need to match the user's language. In headless mode this tool will return an error.",
   inputSchema: {
     type: "object",
     properties: {
-      question: { type: "string", description: "The question to ask the user" }
+      question: {
+        type: "string",
+        description: "The question to ask the user \u2014 in the user's language"
+      },
+      header: {
+        type: "string",
+        description: "Optional short label (\u226412 chars) shown as a chip above the question (e.g. 'Language', 'Approach', '\u8BED\u8A00', '\u65B9\u6848'). Use the user's language."
+      },
+      options: {
+        type: "array",
+        description: "Optional 2-4 multiple-choice options. Omit for free-text input. An implicit 'Other...' entry is appended automatically by the framework.",
+        items: {
+          type: "object",
+          properties: {
+            label: {
+              type: "string",
+              description: "Short display text (1-5 words) \u2014 in the user's language"
+            },
+            description: {
+              type: "string",
+              description: "What this option means or implies \u2014 shown next to the label, in the user's language"
+            }
+          },
+          required: ["label", "description"]
+        }
+      },
+      multiSelect: {
+        type: "boolean",
+        description: "If true, the user can select multiple options. Defaults to false (single choice)."
+      }
     },
     required: ["question"]
   }
@@ -1379,13 +1415,28 @@ async function askUserTool(args, ctx) {
   if (!ctx?.askUser) {
     return "Error: AskUserQuestion is not available in headless mode. Make a reasonable assumption and proceed.";
   }
+  const opts = parseOptions(args);
   try {
-    const answer = await ctx.askUser(question);
+    const answer = await ctx.askUser(question, opts);
     return answer || "(user provided empty response)";
   } catch (err) {
     return `Error asking user: ${err.message}`;
   }
 }
+function parseOptions(args) {
+  const rawOptions = args.options;
+  const header = typeof args.header === "string" ? args.header : void 0;
+  const multiSelect = args.multiSelect === true;
+  if (!Array.isArray(rawOptions) || rawOptions.length === 0) {
+    if (header === void 0 && !multiSelect) return void 0;
+    return { header, multiSelect, options: void 0 };
+  }
+  const options = rawOptions.filter((o) => {
+    return typeof o === "object" && o !== null && typeof o.label === "string" && typeof o.description === "string";
+  }).map((o) => ({ label: o.label, description: o.description }));
+  if (options.length === 0) return { header, multiSelect, options: void 0 };
+  return { header, multiSelect, options };
+}
 
 // src/tool-system/builtin/agent.ts
 init_esm_shims();
@@ -2379,8 +2430,8 @@ async function lspTool(args) {
 ${content}`;
       }
       case "getDiagnostics": {
-        const { readFileSync: readFileSync8 } = await import("fs");
-        const text = readFileSync8(filePath, "utf-8");
+        const { readFileSync: readFileSync9 } = await import("fs");
+        const text = readFileSync9(filePath, "utf-8");
         await client.notify("textDocument/didOpen", {
           textDocument: { uri, languageId: serverConfig.language, version: 1, text }
         });
@@ -2695,7 +2746,7 @@ async function mcpToolExecute(args) {
   const tool = args.tool;
   const toolArgs = args.arguments ?? {};
   try {
-    const { MCPManager: MCPManager2 } = await import("./mcp-manager-37GQLFGX.js");
+    const { MCPManager: MCPManager2 } = await import("./mcp-manager-QMKWPBZ4.js");
     const manager = MCPManager2.getInstance();
     const result = await manager.callTool(server, tool, toolArgs);
     return typeof result === "string" ? result : JSON.stringify(result, null, 2);
@@ -2719,7 +2770,7 @@ var listMcpResourcesToolDef = {
 async function listMcpResourcesTool(args) {
   const server = args.server ?? "";
   try {
-    const { MCPManager: MCPManager2 } = await import("./mcp-manager-37GQLFGX.js");
+    const { MCPManager: MCPManager2 } = await import("./mcp-manager-QMKWPBZ4.js");
     const manager = MCPManager2.getInstance();
     const resources = await manager.listResources(server || void 0);
     if (!resources || resources.length === 0) {
@@ -2754,7 +2805,7 @@ async function readMcpResourceTool(args) {
   const server = args.server;
   const uri = args.uri;
   try {
-    const { MCPManager: MCPManager2 } = await import("./mcp-manager-37GQLFGX.js");
+    const { MCPManager: MCPManager2 } = await import("./mcp-manager-QMKWPBZ4.js");
     const manager = MCPManager2.getInstance();
     const content = await manager.readResource(server, uri);
     return typeof content === "string" ? content : JSON.stringify(content, null, 2);
@@ -2792,11 +2843,11 @@ async function remoteTriggerTool(args) {
   const prompt = args.prompt;
   const config = args.config;
   try {
-    const { existsSync: existsSync13, readFileSync: readFileSync8, writeFileSync: writeFileSync5, mkdirSync: mkdirSync3 } = await import("fs");
-    const { join: join10 } = await import("path");
+    const { existsSync: existsSync15, readFileSync: readFileSync9, writeFileSync: writeFileSync7, mkdirSync: mkdirSync6 } = await import("fs");
+    const { join: join12 } = await import("path");
     const { homedir: homedir8 } = await import("os");
-    const triggerDir = join10(homedir8(), ".code-shell", "triggers");
-    mkdirSync3(triggerDir, { recursive: true });
+    const triggerDir = join12(homedir8(), ".code-shell", "triggers");
+    mkdirSync6(triggerDir, { recursive: true });
     const trigger = {
       id: `trigger_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
       name,
@@ -2805,8 +2856,8 @@ async function remoteTriggerTool(args) {
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       status: "pending"
     };
-    const triggerFile = join10(triggerDir, `${trigger.id}.json`);
-    writeFileSync5(triggerFile, JSON.stringify(trigger, null, 2), "utf-8");
+    const triggerFile = join12(triggerDir, `${trigger.id}.json`);
+    writeFileSync7(triggerFile, JSON.stringify(trigger, null, 2), "utf-8");
     return `Remote trigger "${name}" dispatched (ID: ${trigger.id}).
 Stored at: ${triggerFile}`;
   } catch (err) {
@@ -3306,7 +3357,9 @@ var BUILTIN_TOOLS = [
       source: "builtin",
       permissionDefault: "allow",
       isReadOnly: true,
-      isConcurrencySafe: false
+      isConcurrencySafe: false,
+      timeoutMs: 0
+      // 纯等待用户操作 — 不设超时，由用户 Esc/取消
     },
     execute: askUserTool
   },
@@ -3745,6 +3798,209 @@ var ToolRegistry = class {
 // src/tool-system/executor.ts
 init_esm_shims();
 
+// src/logging/session-recorder.ts
+init_esm_shims();
+import {
+  appendFileSync,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync3,
+  rmSync,
+  statSync
+} from "fs";
+import { join as join4 } from "path";
+var RETENTION_DAYS = 7;
+var MAX_RECORD_BYTES = 256 * 1024;
+function clip(s) {
+  if (s === void 0) return void 0;
+  if (s.length <= MAX_RECORD_BYTES) return s;
+  return s.slice(0, MAX_RECORD_BYTES) + `
+\u2026(truncated, ${s.length - MAX_RECORD_BYTES} more bytes)`;
+}
+function isLocalDev() {
+  if (process.env.CODE_SHELL_VERBOSE_LOG === "0") return false;
+  if (process.env.CODE_SHELL_DEV === "1") return true;
+  if (process.argv.includes("--debug") || process.argv.includes("-d")) return true;
+  if (process.argv.some((a) => a.startsWith("--debug="))) return true;
+  if (process.env.NODE_ENV === "test" || process.env.BUN_TEST === "1") return false;
+  const entry = process.argv[1] ?? "";
+  if (entry.includes(`${"/"}src${"/"}`)) return true;
+  return false;
+}
+var ENABLED = isLocalDev();
+function resolveLogDir() {
+  let dir = new URL(".", import.meta.url).pathname;
+  if (dir.endsWith("/")) dir = dir.slice(0, -1);
+  for (let i = 0; i < 8; i++) {
+    if (existsSync8(join4(dir, "package.json"))) return join4(dir, "log");
+    const parent = join4(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return join4(process.cwd(), "log");
+}
+var LOG_ROOT = ENABLED ? resolveLogDir() : "";
+var SENSITIVE_FLAG_RE = /^--?(api[-_]?key|auth[-_]?token|token|password|secret|bearer)(=|$)/i;
+function redactArgv(argv) {
+  const out = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i] ?? "";
+    const m = SENSITIVE_FLAG_RE.exec(a);
+    if (!m) {
+      out.push(a);
+      continue;
+    }
+    if (m[2] === "=") {
+      out.push(`${a.slice(0, a.indexOf("=") + 1)}<redacted>`);
+    } else {
+      out.push(a);
+      if (i + 1 < argv.length) {
+        out.push("<redacted>");
+        i += 1;
+      }
+    }
+  }
+  return out;
+}
+var states = /* @__PURE__ */ new Map();
+var rotated = false;
+function todayStr() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function rotateOnce() {
+  if (rotated || !ENABLED) return;
+  rotated = true;
+  try {
+    if (!existsSync8(LOG_ROOT)) return;
+    const cutoff = Date.now() - RETENTION_DAYS * 24 * 60 * 60 * 1e3;
+    for (const entry of readdirSync3(LOG_ROOT)) {
+      const full = join4(LOG_ROOT, entry);
+      try {
+        const st = statSync(full);
+        if (st.isDirectory() && st.mtimeMs < cutoff) {
+          rmSync(full, { recursive: true, force: true });
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+function ensureState(sid) {
+  if (!ENABLED) return null;
+  rotateOnce();
+  let st = states.get(sid);
+  if (st) return st;
+  const dateStr = todayStr();
+  const dayDir = join4(LOG_ROOT, dateStr);
+  const path = join4(dayDir, `session-${sid}.jsonl`);
+  try {
+    if (!existsSync8(dayDir)) mkdirSync2(dayDir, { recursive: true });
+  } catch {
+    return null;
+  }
+  st = { path, startedAt: Date.now() };
+  states.set(sid, st);
+  return st;
+}
+function write(sid, event) {
+  const st = ensureState(sid);
+  if (!st) return;
+  const record = { t: (/* @__PURE__ */ new Date()).toISOString(), sid, ...event };
+  try {
+    appendFileSync(st.path, JSON.stringify(record) + "\n", "utf-8");
+  } catch {
+  }
+}
+function recordSessionStart(sid, info) {
+  if (!ENABLED) return;
+  write(sid, {
+    type: "session_start",
+    pid: process.pid,
+    argv: redactArgv(process.argv.slice(1)),
+    cwd: info.cwd,
+    model: info.model,
+    provider: info.provider,
+    permissionMode: info.permissionMode,
+    resumed: info.resumed,
+    task: info.task
+  });
+}
+function recordLLMRequest(sid, req, reqId) {
+  if (!ENABLED) return;
+  write(sid, {
+    type: "llm.request",
+    reqId,
+    provider: req.provider,
+    model: req.model,
+    stream: req.stream,
+    temperature: req.temperature,
+    maxTokens: req.maxTokens,
+    toolCount: Array.isArray(req.tools) ? req.tools.length : 0,
+    messageCount: Array.isArray(req.messages) ? req.messages.length : void 0,
+    systemPrompt: req.systemPrompt,
+    tools: req.tools,
+    messages: req.messages
+  });
+}
+function recordLLMResponse(sid, resp, reqId) {
+  if (!ENABLED) return;
+  write(sid, {
+    type: "llm.response",
+    reqId,
+    stopReason: resp.stopReason,
+    durationMs: resp.durationMs,
+    ttftMs: resp.ttftMs,
+    usage: resp.usage,
+    toolCallCount: resp.toolCalls?.length ?? 0,
+    text: resp.text,
+    toolCalls: resp.toolCalls
+  });
+}
+function recordLLMError(sid, reqId, err, durationMs) {
+  if (!ENABLED) return;
+  write(sid, {
+    type: "llm.error",
+    reqId,
+    durationMs,
+    message: err instanceof Error ? err.message : String(err),
+    stack: err instanceof Error ? err.stack : void 0
+  });
+}
+function recordToolCall(sid, call) {
+  if (!ENABLED) return;
+  write(sid, {
+    type: "tool.call",
+    toolCallId: call.id,
+    toolName: call.toolName,
+    args: call.args
+  });
+}
+function recordToolResult(sid, result) {
+  if (!ENABLED) return;
+  write(sid, {
+    type: "tool.result",
+    toolCallId: result.id,
+    toolName: result.toolName,
+    ok: result.ok,
+    durationMs: result.durationMs,
+    chars: (result.output ?? result.error ?? "").length,
+    output: clip(result.output),
+    error: clip(result.error)
+  });
+}
+function recordSessionEnd(sid, info) {
+  if (!ENABLED) return;
+  write(sid, {
+    type: "session_end",
+    reason: info.reason,
+    turns: info.turns,
+    durationMs: info.durationMs,
+    cost: info.cost
+  });
+  states.delete(sid);
+}
+
 // src/tool-system/validation.ts
 init_esm_shims();
 function validateToolArgs(toolName, args, schema) {
@@ -3794,6 +4050,13 @@ var ToolExecutor = class {
    * (tests, ad-hoc tool runs) still write log lines, just without turn tags.
    */
   log = logger;
+  guard;
+  setInvestigationGuard(guard) {
+    this.guard = guard;
+  }
+  getInvestigationGuard() {
+    return this.guard;
+  }
   /** Set the abort signal for cascading cancellation. */
   setSignal(signal) {
     this.signal = signal;
@@ -3867,6 +4130,16 @@ var ToolExecutor = class {
         isError: true
       };
     }
+    const guardDecision = this.guard?.preToolCheck(call);
+    if (guardDecision?.block) {
+      this.log.info("guard.block", { cat: "guard", tool: call.toolName, reason: guardDecision.block.slice(0, 200) });
+      return {
+        id: call.id,
+        toolName: call.toolName,
+        error: guardDecision.block,
+        isError: true
+      };
+    }
     const decision = this.permission.classify(call.toolName, call.args);
     this.log.info("permission.classify", {
       cat: "permission",
@@ -3904,6 +4177,9 @@ var ToolExecutor = class {
       toolCallId: call.id,
       args: JSON.stringify(call.args).slice(0, 2e3)
     });
+    const sid = getCurrentSid();
+    recordToolCall(sid, { id: call.id, toolName: call.toolName, args: call.args });
+    const toolStartedAt = Date.now();
     let result;
     try {
       result = await this.registry.executeTool(call.toolName, call.args, {
@@ -3912,9 +4188,20 @@ var ToolExecutor = class {
       });
     } catch (err) {
       span.fail(err);
+      recordToolResult(sid, {
+        id: call.id,
+        toolName: call.toolName,
+        ok: false,
+        durationMs: Date.now() - toolStartedAt,
+        error: err instanceof Error ? err.stack ?? err.message : String(err)
+      });
       throw err;
     }
     result.id = call.id;
+    if (guardDecision?.prepend && !result.error && result.result) {
+      result.result = `${guardDecision.prepend}
+${result.result}`;
+    }
     const payload = result.result ?? result.error ?? "";
     span.end({
       ok: !result.error,
@@ -3924,6 +4211,14 @@ var ToolExecutor = class {
       // usually contain the message we need.
       ...result.error ? { errorSnippet: payload.slice(0, 500) } : {}
     });
+    recordToolResult(sid, {
+      id: call.id,
+      toolName: call.toolName,
+      ok: !result.error,
+      durationMs: Date.now() - toolStartedAt,
+      output: result.error ? void 0 : result.result,
+      error: result.error
+    });
     await this.hooks.emit("on_tool_end", {
       toolName: call.toolName,
       toolCallId: call.id,
@@ -4503,8 +4798,20 @@ var PermissionClassifier = class {
         const argVal = String(args[key] ?? "");
         if (pattern instanceof RegExp) {
           if (!pattern.test(argVal)) return false;
-        } else {
-          if (!argVal.includes(pattern)) return false;
+        } else if (typeof pattern === "string") {
+          const looksLikeRegex = /[\\^$.*+?()[\]|{}]/.test(pattern);
+          if (looksLikeRegex) {
+            let re;
+            try {
+              re = new RegExp(pattern);
+            } catch {
+              if (!argVal.includes(pattern)) return false;
+              continue;
+            }
+            if (!re.test(argVal)) return false;
+          } else if (!argVal.includes(pattern)) {
+            return false;
+          }
         }
       }
     }
@@ -4606,15 +4913,201 @@ var HookRegistry = class {
   }
 };
 
+// src/context/tool-result-storage.ts
+init_esm_shims();
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3, join as join5 } from "path";
+var DEFAULT_PERSIST_THRESHOLD = 5e4;
+var PER_MESSAGE_AGGREGATE_CAP = 2e5;
+var PREVIEW_SIZE = 2e3;
+var PERSISTED_OPEN = "<persisted-output>";
+var PERSISTED_CLOSE = "</persisted-output>";
+var CLEARED_PREFIX = "[Old tool result cleared";
+function createContentReplacementState() {
+  return { seenIds: /* @__PURE__ */ new Set(), replacements: /* @__PURE__ */ new Map() };
+}
+function reconstructContentReplacementState(messages) {
+  const state = createContentReplacementState();
+  for (const msg of messages) {
+    if (!Array.isArray(msg.content)) continue;
+    for (const block of msg.content) {
+      if (block.type !== "tool_result" || !block.tool_use_id) continue;
+      state.seenIds.add(block.tool_use_id);
+      if (typeof block.content === "string" && block.content.startsWith(PERSISTED_OPEN)) {
+        state.replacements.set(block.tool_use_id, block.content);
+      }
+    }
+  }
+  return state;
+}
+function resolveToolResultsDir(transcriptPath) {
+  return join5(dirname3(transcriptPath), "tool-results");
+}
+function ensureDir(dir) {
+  try {
+    mkdirSync3(dir, { recursive: true });
+  } catch {
+  }
+}
+function persistToFile(dir, toolUseId, content) {
+  ensureDir(dir);
+  const filepath = join5(dir, `${toolUseId}.txt`);
+  try {
+    writeFileSync3(filepath, content, { encoding: "utf-8", flag: "wx" });
+  } catch (err) {
+    const code = err.code;
+    if (code !== "EEXIST") {
+      logger.debug("tool_result.persist_failed", {
+        toolUseId,
+        code,
+        error: err.message
+      });
+      throw err;
+    }
+  }
+  return filepath;
+}
+function buildReplacement(filepath, originalSize, content) {
+  const sizeKb = (originalSize / 1024).toFixed(1);
+  const previewRaw = content.slice(0, PREVIEW_SIZE);
+  const lastNl = previewRaw.lastIndexOf("\n");
+  const preview = lastNl > PREVIEW_SIZE * 0.5 ? previewRaw.slice(0, lastNl) : previewRaw;
+  const hasMore = content.length > preview.length;
+  return `${PERSISTED_OPEN}
+Output too large (${sizeKb} KB). Full output saved to: ${filepath}
+
+Preview (first ${preview.length} chars${hasMore ? ", truncated" : ""}):
+` + preview + (hasMore ? "\n..." : "") + `
+${PERSISTED_CLOSE}`;
+}
+function collectCandidates(msg) {
+  if (!Array.isArray(msg.content)) return [];
+  const out = [];
+  for (const block of msg.content) {
+    if (block.type !== "tool_result" || !block.tool_use_id) continue;
+    if (typeof block.content !== "string") continue;
+    if (block.content.startsWith(PERSISTED_OPEN) || block.content.startsWith(CLEARED_PREFIX))
+      continue;
+    out.push({
+      toolUseId: block.tool_use_id,
+      block,
+      content: block.content,
+      size: block.content.length
+    });
+  }
+  return out;
+}
+function applyToolResultPersistence(messages, options) {
+  const {
+    perResultThreshold = DEFAULT_PERSIST_THRESHOLD,
+    perMessageCap = PER_MESSAGE_AGGREGATE_CAP,
+    toolResultsDir,
+    state,
+    onPersist
+  } = options;
+  const newReplacements = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    if (msg.role !== "user") continue;
+    const candidates = collectCandidates(msg);
+    if (candidates.length === 0) continue;
+    const fresh = [];
+    for (const c of candidates) {
+      if (state.replacements.has(c.toolUseId)) {
+        continue;
+      }
+      if (state.seenIds.has(c.toolUseId)) {
+        continue;
+      }
+      fresh.push(c);
+    }
+    if (fresh.length === 0) continue;
+    const toPersist = /* @__PURE__ */ new Set();
+    for (const c of fresh) {
+      if (c.size > perResultThreshold) {
+        toPersist.add(c.toolUseId);
+      }
+    }
+    const frozenSize = candidates.filter((c) => state.seenIds.has(c.toolUseId) && !state.replacements.has(c.toolUseId)).reduce((s, c) => s + c.size, 0);
+    let projected = frozenSize + fresh.reduce((s, c) => s + (toPersist.has(c.toolUseId) ? 0 : c.size), 0);
+    if (projected > perMessageCap) {
+      const remaining = fresh.filter((c) => !toPersist.has(c.toolUseId)).sort((a, b) => b.size - a.size);
+      for (const c of remaining) {
+        if (projected <= perMessageCap) break;
+        toPersist.add(c.toolUseId);
+        projected -= c.size;
+      }
+    }
+    for (const c of fresh) {
+      if (toPersist.has(c.toolUseId)) {
+        try {
+          const filepath = persistToFile(toolResultsDir, c.toolUseId, c.content);
+          const replacement = buildReplacement(filepath, c.size, c.content);
+          state.replacements.set(c.toolUseId, replacement);
+          newReplacements.set(c.toolUseId, replacement);
+          state.seenIds.add(c.toolUseId);
+          onPersist?.({
+            toolUseId: c.toolUseId,
+            filepath,
+            originalSize: c.size,
+            reason: c.size > perResultThreshold ? "per-result-cap" : "per-message-budget"
+          });
+        } catch {
+          state.seenIds.add(c.toolUseId);
+        }
+      } else {
+        state.seenIds.add(c.toolUseId);
+      }
+    }
+  }
+  if (state.replacements.size === 0) return messages;
+  let mutated = false;
+  const out = messages.map((msg) => {
+    if (msg.role !== "user" || !Array.isArray(msg.content)) return msg;
+    let blockChanged = false;
+    const newContent = msg.content.map((block) => {
+      if (block.type !== "tool_result" || !block.tool_use_id) return block;
+      const replacement = state.replacements.get(block.tool_use_id);
+      if (replacement === void 0) return block;
+      if (block.content === replacement) return block;
+      if (typeof block.content === "string" && block.content.startsWith(CLEARED_PREFIX)) {
+        return block;
+      }
+      blockChanged = true;
+      return { ...block, content: replacement };
+    });
+    if (!blockChanged) return msg;
+    mutated = true;
+    return { ...msg, content: newContent };
+  });
+  if (mutated && newReplacements.size > 0) {
+    logger.info("tool_result.persisted", {
+      count: newReplacements.size,
+      ids: [...newReplacements.keys()]
+    });
+  }
+  return mutated ? out : messages;
+}
+function isPersistedReplacement(s) {
+  return s.startsWith(PERSISTED_OPEN);
+}
+
 // src/context/manager.ts
 init_esm_shims();
 init_compaction();
 var DEFAULT_CONFIG = {
+  // 0.85 ≈ effectiveContextWindow − reserved-output buffer (CC's
+  // autoCompactThreshold pattern: window − 13k buffer − 20k output budget
+  // ≈ 0.83 on a 200k window, 0.97 on 1M). 0.6 was wasting 40% of any model
+  // with a window over ~150k.
   maxTokens: 2e5,
-  compactAtRatio: 0.6,
-  summarizeAtRatio: 0.8,
-  maxToolResultChars: 3e4
+  compactAtRatio: 0.85,
+  summarizeAtRatio: 0.92,
+  maxToolResultChars: 3e4,
+  microcompactFloorRatio: 0.3
 };
+function defaultKeepRecent(maxTokens) {
+  return Math.max(5, Math.floor(maxTokens / 1e5));
+}
 var ContextManager = class {
   config;
   toolCallHashes = /* @__PURE__ */ new Map();
@@ -4627,8 +5120,15 @@ var ContextManager = class {
   lastActualAtMessageCount;
   /** Path to session transcript — passed to summary compaction for on-demand access. */
   transcriptPath;
-  /** Notified whenever a non-trivial compaction tier fires (skips microcompact). */
+  /** Notified whenever any compaction tier fires, including microcompact. */
   onCompact;
+  /**
+   * Tool-result persistence state. Created lazily once we know where to
+   * write files (i.e. once setTranscriptPath has been called).
+   * `null` = persistence has been explicitly disabled.
+   */
+  replacementState;
+  toolResultsDir;
   constructor(config) {
     this.config = { ...DEFAULT_CONFIG, ...config };
   }
@@ -4662,10 +5162,23 @@ var ContextManager = class {
     this.summarizeFn = fn;
   }
   /**
-   * Set the transcript path so compaction can reference it.
+   * Set the transcript path so compaction can reference it. The
+   * tool-results directory lives alongside the transcript file:
+   *   <transcriptDir>/tool-results/<toolUseId>.txt
    */
   setTranscriptPath(path) {
     this.transcriptPath = path;
+    this.toolResultsDir = resolveToolResultsDir(path);
+  }
+  /**
+   * Initialize tool-result-persistence state from already-loaded messages.
+   * Call this once per session, after setTranscriptPath, when resuming so
+   * the manager re-enters the same "frozen decision" state it had on the
+   * previous run. Without this, a resumed session would re-evaluate
+   * every result against the current threshold and might flip choices.
+   */
+  initReplacementStateFromMessages(messages) {
+    this.replacementState = reconstructContentReplacementState(messages);
   }
   /**
    * Apply progressive context management (sync path).
@@ -4673,11 +5186,36 @@ var ContextManager = class {
    */
   manage(messages) {
     let result = messages;
+    result = this.persistLargeToolResults(result);
     result = this.truncateToolResults(result);
     result = applyToolResultBudget(result);
-    result = microcompact(result);
+    const preTier1Tokens = this.estimateTokensHybrid(result);
+    if (preTier1Tokens > this.config.maxTokens * this.config.microcompactFloorRatio) {
+      const keepRecentN = this.config.microcompactKeepRecent ?? defaultKeepRecent(this.config.maxTokens);
+      let clearedInfo = null;
+      result = microcompact(result, {
+        keepRecentN,
+        onClear: (info) => {
+          clearedInfo = info;
+        }
+      });
+      if (clearedInfo) {
+        const after = this.estimateTokensHybrid(result);
+        logger.info("context.microcompact", {
+          before: preTier1Tokens,
+          after,
+          keepRecentN,
+          clearedRounds: clearedInfo.clearedRounds,
+          toolNames: clearedInfo.toolNames
+        });
+        this.onCompact?.({ strategy: "micro", before: preTier1Tokens, after });
+      }
+    }
     let tokens = this.estimateTokensHybrid(result);
-    if (tokens > this.config.maxTokens * this.config.compactAtRatio) {
+    const snipGate = this.config.maxTokens * this.config.compactAtRatio;
+    const windowGate = this.config.maxTokens * (this.config.compactAtRatio + 0.05);
+    const emergencyGate = this.config.maxTokens * this.config.summarizeAtRatio;
+    if (tokens > snipGate) {
       const before = tokens;
       if (this.lastSummary) {
         const keepN = Math.max(8, Math.floor(result.length * 0.3));
@@ -4686,19 +5224,19 @@ var ContextManager = class {
         tokens = this.estimateTokensHybrid(result);
         this.onCompact?.({ strategy: "summary", before, after: tokens });
       } else {
-        const keepN = Math.max(10, Math.floor(result.length * 0.4));
-        result = windowCompact(result, keepN);
+        result = snipCompact(result, 3, 8);
         tokens = this.estimateTokensHybrid(result);
-        this.onCompact?.({ strategy: "window", before, after: tokens });
+        this.onCompact?.({ strategy: "snip", before, after: tokens });
       }
     }
-    if (tokens > this.config.maxTokens * 0.7) {
+    if (tokens > windowGate) {
       const before = tokens;
-      result = snipCompact(result, 3, 8);
+      const keepN = Math.max(10, Math.floor(result.length * 0.4));
+      result = windowCompact(result, keepN);
       tokens = this.estimateTokensHybrid(result);
-      this.onCompact?.({ strategy: "snip", before, after: tokens });
+      this.onCompact?.({ strategy: "window", before, after: tokens });
     }
-    if (tokens > this.config.maxTokens * this.config.summarizeAtRatio) {
+    if (tokens > emergencyGate) {
       const before = tokens;
       result = windowCompact(result, 6);
       tokens = this.estimateTokensHybrid(result);
@@ -4712,9 +5250,31 @@ var ContextManager = class {
    */
   async manageAsync(messages) {
     let result = messages;
+    result = this.persistLargeToolResults(result);
     result = this.truncateToolResults(result);
     result = applyToolResultBudget(result);
-    result = microcompact(result);
+    const preTier1Tokens = this.estimateTokensHybrid(result);
+    if (preTier1Tokens > this.config.maxTokens * this.config.microcompactFloorRatio) {
+      const keepRecentN = this.config.microcompactKeepRecent ?? defaultKeepRecent(this.config.maxTokens);
+      let clearedInfo = null;
+      result = microcompact(result, {
+        keepRecentN,
+        onClear: (info) => {
+          clearedInfo = info;
+        }
+      });
+      if (clearedInfo) {
+        const after = this.estimateTokensHybrid(result);
+        logger.info("context.microcompact", {
+          before: preTier1Tokens,
+          after,
+          keepRecentN,
+          clearedRounds: clearedInfo.clearedRounds,
+          toolNames: clearedInfo.toolNames
+        });
+        this.onCompact?.({ strategy: "micro", before: preTier1Tokens, after });
+      }
+    }
     const tokens = this.estimateTokensHybrid(result);
     const ratio = tokens / this.config.maxTokens;
     if (ratio >= this.config.compactAtRatio && this.summarizeFn && this.consecutiveSummaryFailures < 3) {
@@ -4747,20 +5307,23 @@ var ContextManager = class {
       }
     }
     let live = tokens;
-    if (live > this.config.maxTokens * this.config.compactAtRatio) {
+    const snipGate = this.config.maxTokens * this.config.compactAtRatio;
+    const windowGate = this.config.maxTokens * (this.config.compactAtRatio + 0.05);
+    const emergencyGate = this.config.maxTokens * this.config.summarizeAtRatio;
+    if (live > snipGate) {
       const before = live;
-      const keepN = Math.max(10, Math.floor(result.length * 0.4));
-      result = windowCompact(result, keepN);
+      result = snipCompact(result, 3, 8);
       live = this.estimateTokensHybrid(result);
-      this.onCompact?.({ strategy: "window", before, after: live });
+      this.onCompact?.({ strategy: "snip", before, after: live });
     }
-    if (live > this.config.maxTokens * 0.7) {
+    if (live > windowGate) {
       const before = live;
-      result = snipCompact(result, 3, 8);
+      const keepN = Math.max(10, Math.floor(result.length * 0.4));
+      result = windowCompact(result, keepN);
       live = this.estimateTokensHybrid(result);
-      this.onCompact?.({ strategy: "snip", before, after: live });
+      this.onCompact?.({ strategy: "window", before, after: live });
     }
-    if (live > this.config.maxTokens * this.config.summarizeAtRatio) {
+    if (live > emergencyGate) {
       const before = live;
       result = windowCompact(result, 6);
       live = this.estimateTokensHybrid(result);
@@ -4768,6 +5331,24 @@ var ContextManager = class {
     }
     return result;
   }
+  /**
+   * Persist large tool_result blocks to disk and replace them with a
+   * preview + filepath. No-op when transcript path hasn't been set
+   * (e.g. unit tests that exercise compaction directly without a session).
+   */
+  persistLargeToolResults(messages) {
+    if (!this.toolResultsDir) return messages;
+    if (!this.replacementState) {
+      this.replacementState = createContentReplacementState();
+    }
+    return applyToolResultPersistence(messages, {
+      toolResultsDir: this.toolResultsDir,
+      state: this.replacementState,
+      onPersist: (info) => {
+        logger.info("context.tool_result_persisted", info);
+      }
+    });
+  }
   /**
    * Truncate oversized tool results in messages.
    */
@@ -4797,7 +5378,7 @@ var ContextManager = class {
   shouldReactiveCompact(messages, currentResponseTokens) {
     const msgTokens = this.estimateTokensHybrid(messages);
     const total = msgTokens + currentResponseTokens;
-    return total > this.config.maxTokens * 0.9;
+    return total > this.config.maxTokens * this.config.summarizeAtRatio;
   }
   /**
    * Check if context is approaching limits.
@@ -4879,8 +5460,8 @@ var SectionCache = class {
 
 // src/prompt/instruction-scanner.ts
 init_esm_shims();
-import { readFileSync as readFileSync4, existsSync as existsSync8, readdirSync as readdirSync3, statSync } from "fs";
-import { join as join4, dirname as dirname3, resolve as resolve4 } from "path";
+import { readFileSync as readFileSync4, existsSync as existsSync9, readdirSync as readdirSync4, statSync as statSync2 } from "fs";
+import { join as join6, dirname as dirname4, resolve as resolve4 } from "path";
 import { execSync as execSync5 } from "child_process";
 import { homedir as homedir2 } from "os";
 function scanInstructions(cwd, options = {}) {
@@ -4889,32 +5470,32 @@ function scanInstructions(cwd, options = {}) {
   const allNames = [fileName, ...compatNames];
   const configDirs = [".codeshell", ...options.scanDirs ?? [], ".claude"];
   const entries = [];
-  const homeConfigDir = join4(homedir2(), ".code-shell");
-  const homeCompatDir = join4(homedir2(), ".claude");
+  const homeConfigDir = join6(homedir2(), ".code-shell");
+  const homeCompatDir = join6(homedir2(), ".claude");
   for (const name of allNames) {
-    tryAddFile(join4(homeConfigDir, name), "user", -1, entries);
+    tryAddFile(join6(homeConfigDir, name), "user", -1, entries);
   }
-  tryAddRulesDir(join4(homeConfigDir, "rules"), "user", -1, entries);
+  tryAddRulesDir(join6(homeConfigDir, "rules"), "user", -1, entries);
   for (const name of compatNames) {
-    tryAddFile(join4(homeCompatDir, name), "user", -1, entries);
+    tryAddFile(join6(homeCompatDir, name), "user", -1, entries);
   }
-  tryAddRulesDir(join4(homeCompatDir, "rules"), "user", -1, entries);
+  tryAddRulesDir(join6(homeCompatDir, "rules"), "user", -1, entries);
   const ceiling = options.ignoreGitBoundary ? "/" : findGitRoot2(cwd) ?? "/";
   const dirs = collectDirsDownward(resolve4(cwd), ceiling);
   for (let depth = 0; depth < dirs.length; depth++) {
     const dir = dirs[depth];
     for (const name of allNames) {
-      tryAddFile(join4(dir, name), "project", depth, entries);
+      tryAddFile(join6(dir, name), "project", depth, entries);
     }
     for (const cfgDir of configDirs) {
       for (const name of allNames) {
-        tryAddFile(join4(dir, cfgDir, name), "project", depth, entries);
+        tryAddFile(join6(dir, cfgDir, name), "project", depth, entries);
       }
-      tryAddRulesDir(join4(dir, cfgDir, "rules"), "project", depth, entries);
+      tryAddRulesDir(join6(dir, cfgDir, "rules"), "project", depth, entries);
     }
     for (const name of allNames) {
       const localName = name.replace(/\.md$/, ".local.md");
-      tryAddFile(join4(dir, localName), "local", depth, entries);
+      tryAddFile(join6(dir, localName), "local", depth, entries);
     }
   }
   return dedup(entries);
@@ -4929,9 +5510,9 @@ ${e.content}`;
   }).join("\n\n---\n\n");
 }
 function tryAddFile(path, source, depth, entries) {
-  if (!existsSync8(path)) return;
+  if (!existsSync9(path)) return;
   try {
-    const stat5 = statSync(path);
+    const stat5 = statSync2(path);
     if (!stat5.isFile()) return;
     const content = readFileSync4(path, "utf-8").trim();
     if (content) {
@@ -4941,11 +5522,11 @@ function tryAddFile(path, source, depth, entries) {
   }
 }
 function tryAddRulesDir(dir, source, depth, entries) {
-  if (!existsSync8(dir)) return;
+  if (!existsSync9(dir)) return;
   try {
-    const files = readdirSync3(dir).filter((f) => f.endsWith(".md")).sort();
+    const files = readdirSync4(dir).filter((f) => f.endsWith(".md")).sort();
     for (const file of files) {
-      tryAddFile(join4(dir, file), source, depth, entries);
+      tryAddFile(join6(dir, file), source, depth, entries);
     }
   } catch {
   }
@@ -4970,7 +5551,7 @@ function collectDirsDownward(target, ceiling) {
   while (true) {
     dirs.push(dir);
     if (dir === resolvedCeiling) break;
-    const parent = dirname3(dir);
+    const parent = dirname4(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -4999,28 +5580,33 @@ function sourceLabel(entry) {
 
 // src/skills/scanner.ts
 init_esm_shims();
-import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
-import { join as join5, resolve as resolve5 } from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync5, statSync as statSync3 } from "fs";
+import { dirname as dirname5, join as join7, resolve as resolve5 } from "path";
 import { homedir as homedir3 } from "os";
+import { fileURLToPath } from "url";
 function scanSkills(cwd) {
   const skills = [];
   const seen = /* @__PURE__ */ new Set();
+  const builtin = resolveBuiltinSkillsDir();
   const dirs = [
     // Project-level
-    join5(cwd, ".code-shell", "skills"),
-    join5(cwd, ".claude", "skills"),
+    join7(cwd, ".code-shell", "skills"),
+    join7(cwd, ".claude", "skills"),
     // User-level
-    join5(homedir3(), ".code-shell", "skills"),
-    join5(homedir3(), ".claude", "skills")
+    join7(homedir3(), ".code-shell", "skills"),
+    join7(homedir3(), ".claude", "skills"),
+    // Built-in (shipped inside the npm package). Listed last so user/project
+    // skills with the same filename win deduplication on filePath.
+    ...builtin ? [builtin] : []
   ];
   for (const dir of dirs) {
-    if (!existsSync9(dir)) continue;
+    if (!existsSync10(dir)) continue;
     try {
-      const files = readdirSync4(dir).filter(
-        (f) => f.endsWith(".md") && statSync2(join5(dir, f)).isFile()
+      const files = readdirSync5(dir).filter(
+        (f) => f.endsWith(".md") && statSync3(join7(dir, f)).isFile()
       );
       for (const file of files) {
-        const filePath = resolve5(join5(dir, file));
+        const filePath = resolve5(join7(dir, file));
         if (seen.has(filePath)) continue;
         seen.add(filePath);
         const skill = parseSkillFile(filePath);
@@ -5031,6 +5617,30 @@ function scanSkills(cwd) {
   }
   return skills;
 }
+function resolveBuiltinSkillsDir() {
+  let here;
+  try {
+    here = typeof import.meta !== "undefined" && import.meta.url ? dirname5(fileURLToPath(import.meta.url)) : __dirname;
+  } catch {
+    return null;
+  }
+  let dir = here;
+  for (let i = 0; i < 6; i++) {
+    const pkgPath = join7(dir, "package.json");
+    try {
+      const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+      if (pkg?.name === "@cjhyy/code-shell") {
+        const candidate = join7(dir, "skills-builtin");
+        return existsSync10(candidate) ? candidate : null;
+      }
+    } catch {
+    }
+    const parent = dirname5(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
 function parseSkillFile(filePath) {
   try {
     const raw = readFileSync5(filePath, "utf-8");
@@ -5137,6 +5747,13 @@ The default job in this preset is software engineering in the current working di
  - Do not propose changes to code you haven't read. If a user asks about or wants you to modify a file, read it first. Understand existing code before suggesting modifications.
  - Read code before editing it, prefer modifying existing files, and avoid unrelated refactors.
 
+## Investigation has a budget \u2014 looking is not acting
+ - Read, search, and investigate freely, but treat read-only exploration as a means to action, not an end in itself. After about 3 read-only tool calls (Read/Grep/Glob) on the same question, you should either (a) make a change, (b) run a command with side effects (Bash, debug log, repro), or (c) ask the user a specific question. Continuing to read more files usually means your current strategy isn't working \u2014 change strategy instead.
+ - Never re-read a file (or the same line range of a file) you've already read in this conversation. The content is already in your context. If you've re-derived the same conclusion twice from the same code, the answer isn't in static reading \u2014 switch to runtime verification.
+ - For bug reports where static analysis hasn't pinpointed the cause in 2-3 reads, the right next step is almost always to add a debug log line and ask the user to reproduce, or to inspect runtime state \u2014 not to read more files.
+ - Don't narrate the same code path twice in your reasoning. If you've already traced "input X \u2192 parser Y \u2192 handler Z" once and concluded "this looks correct", stop. Do not re-trace it from a different angle hoping for a different answer. Trust your first analysis and move to verification.
+ - These rules are enforced at runtime by an investigation guard. A second read of the same target prepends a \`<system-reminder>\` to that tool's result; a third read of the same target is hard-blocked with an error. Four or more consecutive read-only calls without a side-effecting action also surface a reminder, and several consecutive turns of read-only work with no text update to the user surface another. When you see one of these reminders, treat it as a signal that your current strategy isn't producing new information \u2014 switch to a side-effecting verification (Bash, debug log, repro, edit) or ask the user a specific question rather than reading more.
+
 ## Code quality discipline
  - Don't add features, refactor code, or make "improvements" beyond what was asked. A bug fix doesn't need surrounding code cleaned up. A simple feature doesn't need extra configurability. Don't add docstrings, comments, or type annotations to code you didn't change. Only add comments where the logic isn't self-evident.
  - Don't add error handling, fallbacks, or validation for scenarios that can't happen. Trust internal code and framework guarantees. Only validate at system boundaries (user input, external APIs). Don't use feature flags or backwards-compatibility shims when you can just change the code.
@@ -5158,6 +5775,7 @@ The default job in this preset is software engineering in the current working di
 // src/prompt/sections/tone.md
 var tone_default = `# Tone and output
  - Only use emojis if the user explicitly requests it.
+ - Match the language of the user's latest message in your reply; keep code, paths, and identifiers in their original form.
  - Be concise, direct, and collaborative. Your responses should be short.
  - Do not use a colon before tool calls. Your tool calls may not be shown directly in the output, so text like "Let me read the file:" followed by a read tool call should just be "Let me read the file." with a period.
  - Lead with the answer or action, not the reasoning. Skip filler words, preamble, and unnecessary transitions. Do not restate what the user said.
@@ -5480,6 +6098,124 @@ ${toolLines.join("\n\n")}`;
 // src/engine/engine.ts
 init_esm_shims();
 
+// src/tool-system/investigation-guard.ts
+init_esm_shims();
+var READ_ONLY_TOOLS = /* @__PURE__ */ new Set(["Read", "Grep", "Glob", "WebFetch", "WebSearch", "ToolSearch"]);
+var READ_BUDGET = 3;
+var SILENT_TURN_BUDGET = 3;
+var DEDUPE_OFFSET_BUCKET = 50;
+var READ_HISTORY_MAX = 512;
+var InvestigationGuard = class {
+  readHistory = /* @__PURE__ */ new Map();
+  consecutiveReads = 0;
+  silentTurns = 0;
+  turnHasText = false;
+  turnHasSideEffect = false;
+  lastReminderSilent = -1;
+  /**
+   * Soft mode replaces hard blocks (3rd-read dedupe) with a stronger
+   * reminder. Used in headless runs (`code-shell run …`) where there is
+   * no human to retry the task, so an unattended automation should not
+   * be killed by the guard — it should still get the signal to change
+   * strategy, but the tool call goes through.
+   */
+  softMode = false;
+  setSoftMode(soft) {
+    this.softMode = soft;
+  }
+  preToolCheck(call) {
+    const tool = call.toolName;
+    if (!READ_ONLY_TOOLS.has(tool)) {
+      if (this.isMutatingTool(tool)) {
+        this.consecutiveReads = 0;
+        this.turnHasSideEffect = true;
+      }
+      return void 0;
+    }
+    const key = this.buildKey(call);
+    if (!key) return void 0;
+    const hits = (this.readHistory.get(key.signature) ?? 0) + 1;
+    this.readHistory.set(key.signature, hits);
+    if (this.readHistory.size > READ_HISTORY_MAX) {
+      const oldest = this.readHistory.keys().next().value;
+      if (oldest !== void 0) this.readHistory.delete(oldest);
+    }
+    this.consecutiveReads += 1;
+    const prependParts = [];
+    if (hits >= 3) {
+      const message = `Investigation guard: ${tool} on this exact target has been called ${hits} times in this session. Re-reading the same content will not produce new information. Switch strategy: run a command with side effects (Bash, debug log, repro), make a code change, or ask the user a specific question. If you genuinely need this content, summarize what you already know about it from prior reads instead of re-fetching.`;
+      if (this.softMode) {
+        prependParts.push(`<system-reminder>${message}</system-reminder>`);
+      } else {
+        return { block: message };
+      }
+    }
+    if (hits === 2) {
+      prependParts.push(
+        `<system-reminder>Investigation guard: you already read this target once in this session. Re-reading rarely yields new information. After this result, change strategy (Bash side-effect, edit, or ask user) rather than reading further.</system-reminder>`
+      );
+    }
+    if (this.consecutiveReads > READ_BUDGET) {
+      prependParts.push(
+        `<system-reminder>Investigation guard: ${this.consecutiveReads} consecutive read-only calls with no action taken. Per coding.md, change strategy now \u2014 make a code change, run a command with side effects, or ask the user.</system-reminder>`
+      );
+    }
+    return prependParts.length ? { prepend: prependParts.join("\n") } : void 0;
+  }
+  noteText(text) {
+    if (text && text.trim().length > 0) this.turnHasText = true;
+  }
+  noteToolResult(_call, _result) {
+  }
+  turnEnded(turnNumber) {
+    if (!this.turnHasText && !this.turnHasSideEffect) {
+      this.silentTurns += 1;
+    } else {
+      this.silentTurns = 0;
+    }
+    const wasSilent = this.silentTurns;
+    this.turnHasText = false;
+    this.turnHasSideEffect = false;
+    if (wasSilent >= SILENT_TURN_BUDGET && turnNumber !== this.lastReminderSilent) {
+      this.lastReminderSilent = turnNumber;
+      return `<system-reminder>Investigation guard: you have taken ${wasSilent} consecutive turns of read-only investigation without any text update to the user or side-effecting action. Either surface a status update (what have you ruled out, what's your current hypothesis?), or change tactic \u2014 verify at runtime (logs, repro, Bash) instead of reading further.</system-reminder>`;
+    }
+    return void 0;
+  }
+  isMutatingTool(name) {
+    if (name === "Bash") return true;
+    if (name === "Edit" || name === "Write" || name === "NotebookEdit") return true;
+    if (name === "AskUserQuestion") return true;
+    if (name === "TaskCreate" || name === "TaskUpdate") return false;
+    return false;
+  }
+  buildKey(call) {
+    const tool = call.toolName;
+    const args = call.args ?? {};
+    if (tool === "Read") {
+      const fp = typeof args.file_path === "string" ? args.file_path : "";
+      if (!fp) return void 0;
+      const off = typeof args.offset === "number" ? args.offset : 0;
+      const bucket = Math.floor(off / DEDUPE_OFFSET_BUCKET);
+      return { tool, signature: `Read::${fp}::${bucket}` };
+    }
+    if (tool === "Grep") {
+      const pat = typeof args.pattern === "string" ? args.pattern : "";
+      const path = typeof args.path === "string" ? args.path : "";
+      const glob2 = typeof args.glob === "string" ? args.glob : "";
+      if (!pat) return void 0;
+      return { tool, signature: `Grep::${pat}::${path}::${glob2}` };
+    }
+    if (tool === "Glob") {
+      const pat = typeof args.pattern === "string" ? args.pattern : "";
+      const path = typeof args.path === "string" ? args.path : "";
+      if (!pat) return void 0;
+      return { tool, signature: `Glob::${pat}::${path}` };
+    }
+    return void 0;
+  }
+};
+
 // src/engine/model-facade.ts
 init_esm_shims();
 
@@ -5521,6 +6257,11 @@ function addOutputTokens(n) {
 }
 
 // src/engine/model-facade.ts
+var _reqSeq = 0;
+function nextReqId() {
+  _reqSeq += 1;
+  return `r${_reqSeq.toString(36)}`;
+}
 var ModelFacade = class {
   constructor(client, transcript) {
     this.client = client;
@@ -5529,34 +6270,54 @@ var ModelFacade = class {
   async call(systemPrompt, messages, tools, onStream, signal) {
     const startMs = Date.now();
     const msgCount = messages.length;
-    const response = await this.client.createMessage({
-      systemPrompt,
-      messages,
-      tools,
-      stream: true,
-      onChunk: (chunk) => {
-        if (!onStream) return;
-        if (chunk.type === "text" && chunk.text) {
-          onStream({ type: "text_delta", text: chunk.text });
-        } else if (chunk.type === "tool_use_start" && chunk.toolCall) {
-          onStream({
-            type: "tool_use_start",
-            toolCall: {
-              id: chunk.toolCall.id ?? "",
-              toolName: chunk.toolCall.toolName ?? "",
-              args: chunk.toolCall.args ?? {}
-            }
-          });
-        } else if (chunk.type === "tool_use_delta" && chunk.toolCall?.id) {
-          onStream({
-            type: "tool_use_args_delta",
-            toolCallId: chunk.toolCall.id,
-            args: chunk.toolCall.args ?? {}
-          });
-        }
+    const sid = getCurrentSid();
+    const reqId = nextReqId();
+    recordLLMRequest(
+      sid,
+      {
+        provider: this.client.provider ?? "?",
+        model: this.client.model ?? "?",
+        stream: true,
+        messages,
+        tools,
+        systemPrompt
       },
-      signal
-    });
+      reqId
+    );
+    let response;
+    try {
+      response = await this.client.createMessage({
+        systemPrompt,
+        messages,
+        tools,
+        stream: true,
+        onChunk: (chunk) => {
+          if (!onStream) return;
+          if (chunk.type === "text" && chunk.text) {
+            onStream({ type: "text_delta", text: chunk.text });
+          } else if (chunk.type === "tool_use_start" && chunk.toolCall) {
+            onStream({
+              type: "tool_use_start",
+              toolCall: {
+                id: chunk.toolCall.id ?? "",
+                toolName: chunk.toolCall.toolName ?? "",
+                args: chunk.toolCall.args ?? {}
+              }
+            });
+          } else if (chunk.type === "tool_use_delta" && chunk.toolCall?.id) {
+            onStream({
+              type: "tool_use_args_delta",
+              toolCallId: chunk.toolCall.id,
+              args: chunk.toolCall.args ?? {}
+            });
+          }
+        },
+        signal
+      });
+    } catch (err) {
+      recordLLMError(sid, reqId, err, Date.now() - startMs);
+      throw err;
+    }
     const latencyMs = Date.now() - startMs;
     logger.info("llm.request", {
       stream: true,
@@ -5567,6 +6328,17 @@ var ModelFacade = class {
       textLen: response.text?.length ?? 0,
       usage: response.usage
     });
+    recordLLMResponse(
+      sid,
+      {
+        text: response.text,
+        toolCalls: response.toolCalls,
+        stopReason: response.stopReason,
+        usage: response.usage,
+        durationMs: latencyMs
+      },
+      reqId
+    );
     this.recordUsage(response, latencyMs);
     this.recordResponse(response);
     return response;
@@ -5577,13 +6349,33 @@ var ModelFacade = class {
   async callWithoutStreaming(systemPrompt, messages, tools, signal) {
     const startMs = Date.now();
     const msgCount = messages.length;
-    const response = await this.client.createMessage({
-      systemPrompt,
-      messages,
-      tools,
-      stream: false,
-      signal
-    });
+    const sid = getCurrentSid();
+    const reqId = nextReqId();
+    recordLLMRequest(
+      sid,
+      {
+        provider: this.client.provider ?? "?",
+        model: this.client.model ?? "?",
+        stream: false,
+        messages,
+        tools,
+        systemPrompt
+      },
+      reqId
+    );
+    let response;
+    try {
+      response = await this.client.createMessage({
+        systemPrompt,
+        messages,
+        tools,
+        stream: false,
+        signal
+      });
+    } catch (err) {
+      recordLLMError(sid, reqId, err, Date.now() - startMs);
+      throw err;
+    }
     const latencyMs = Date.now() - startMs;
     logger.info("llm.request", {
       stream: false,
@@ -5594,6 +6386,17 @@ var ModelFacade = class {
       textLen: response.text?.length ?? 0,
       usage: response.usage
     });
+    recordLLMResponse(
+      sid,
+      {
+        text: response.text,
+        toolCalls: response.toolCalls,
+        stopReason: response.stopReason,
+        usage: response.usage,
+        durationMs: latencyMs
+      },
+      reqId
+    );
     this.recordUsage(response, latencyMs);
     this.recordResponse(response);
     return response;
@@ -5781,7 +6584,7 @@ var TurnLoop = class {
         response = await this.callModelWithFallback(messages);
       } catch (err) {
         if (err instanceof ContextLimitError) {
-          const { dropOldestRounds } = await import("./compaction-YNWCEF7B.js");
+          const { dropOldestRounds } = await import("./compaction-6VU2T643.js");
           let recovered = false;
           for (let retry = 1; retry <= 3; retry++) {
             tlog.warn("turn.ptl_recovery", { cat: "turn", retry, roundsToDrop: retry });
@@ -5811,6 +6614,12 @@ var TurnLoop = class {
           return { text: finalText, reason: "model_error", messages };
         }
       }
+      if (response.usage?.promptTokens !== void 0) {
+        this.config.onStream?.({
+          type: "usage_update",
+          promptTokens: response.usage.promptTokens
+        });
+      }
       if (response.usage?.promptTokens !== void 0) {
         this.deps.contextManager.recordActualUsage(response.usage.promptTokens, messages.length);
       }
@@ -5845,6 +6654,12 @@ var TurnLoop = class {
         }
         response = { ...response, text: combinedText };
       }
+      if (response.usage?.promptTokens !== void 0) {
+        this.config.onStream?.({
+          type: "usage_update",
+          promptTokens: response.usage.promptTokens
+        });
+      }
       if (this.config.signal?.aborted) {
         return { text: finalText, reason: "aborted_streaming", messages };
       }
@@ -5903,7 +6718,7 @@ var TurnLoop = class {
         this.config.onStream?.({ type: "tool_result", result });
       }
       if (this.config.onStream) {
-        import("./tool-summary-2RUFL5QK.js").then(({ generateToolUseSummary }) => {
+        import("./tool-summary-NP5CDBKG.js").then(({ generateToolUseSummary }) => {
           if (!this.deps.model.summarize) return;
           generateToolUseSummary(toolCalls, results, this.deps.model.summarize).then((summary) => {
             if (summary) {
@@ -5938,12 +6753,22 @@ var TurnLoop = class {
           content: "<system-reminder>You are approaching the token budget limit. Please start wrapping up your work and provide a summary.</system-reminder>"
         });
       }
+      const guard = this.deps.toolExecutor.getInvestigationGuard();
+      if (guard) {
+        guard.noteText(response.text);
+        const turnReminder = guard.turnEnded(this.turnCount);
+        if (turnReminder) {
+          messages.push({ role: "user", content: turnReminder });
+          tlog.info("guard.silent_turn", { cat: "guard", turn: this.turnCount });
+        }
+      }
       await this.deps.hooks.emit("on_turn_end", {
         turnNumber: this.turnCount,
         hasToolUse: true,
         toolCallCount: toolCalls.length
       });
       this.deps.transcript.appendTurnBoundary();
+      this.config.onTurnBoundary?.(this.turnCount);
       tlog.info("turn.end", {
         cat: "turn",
         duration_ms: Date.now() - turnStartedAt,
@@ -6112,9 +6937,83 @@ var TurnLoop = class {
   }
 };
 
+// src/llm/provider-catalog.ts
+init_esm_shims();
+var ProviderCatalog = class {
+  byKey = /* @__PURE__ */ new Map();
+  constructor(entries) {
+    for (const e of entries ?? []) this.byKey.set(e.key, e);
+  }
+  list() {
+    return [...this.byKey.values()];
+  }
+  get(key) {
+    return this.byKey.get(key);
+  }
+  has(key) {
+    return this.byKey.has(key);
+  }
+  add(entry) {
+    if (this.byKey.has(entry.key)) {
+      throw new Error(`duplicate provider key: ${entry.key}`);
+    }
+    this.byKey.set(entry.key, entry);
+  }
+  update(key, patch) {
+    const cur = this.byKey.get(key);
+    if (!cur) throw new Error(`no such provider: ${key}`);
+    this.byKey.set(key, { ...cur, ...patch, key: cur.key });
+  }
+  remove(key, opts) {
+    if (opts.referencedBy.length) {
+      throw new Error(
+        `provider ${key} still referenced by models: ${opts.referencedBy.join(", ")}`
+      );
+    }
+    this.byKey.delete(key);
+  }
+  /** Compute an unused key for a new provider, given a desired base. */
+  deriveKey(base) {
+    if (!this.byKey.has(base)) return base;
+    for (let i = 2; ; i++) {
+      const candidate = `${base}-${i}`;
+      if (!this.byKey.has(candidate)) return candidate;
+    }
+  }
+};
+
+// src/utils/task-sanitizer.ts
+init_esm_shims();
+var ANSI_RE = /\x1b\[[0-9;?]*[A-Za-z]/g;
+var BOX_RE = /[─━│┃┌┐└┘├┤┬┴┼╔╗╚╝═║╠╣╦╩╬▀▄█▌▐░▒▓·]+/g;
+function detectPastedNoise(task) {
+  const original = task.length;
+  if (original < 10) return { isNoise: false, reason: "short", cleaned: task };
+  const stripped = task.replace(ANSI_RE, "").replace(BOX_RE, "").replace(/\r/g, "\n").trim();
+  if (stripped.length === 0) {
+    return { isNoise: true, reason: "all ANSI/box chars", cleaned: stripped };
+  }
+  const signalRatio = stripped.length / original;
+  if (signalRatio < 0.3 && original > 100) {
+    return {
+      isNoise: true,
+      reason: `signal/noise ratio ${(signalRatio * 100).toFixed(0)}%`,
+      cleaned: stripped
+    };
+  }
+  return { isNoise: false, reason: "ok", cleaned: stripped };
+}
+
 // src/engine/engine.ts
-import { join as join6 } from "path";
+import { join as join8 } from "path";
 import { homedir as homedir4 } from "os";
+import {
+  existsSync as existsSync11,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync6,
+  renameSync,
+  writeFileSync as writeFileSync4
+} from "fs";
 var Engine = class _Engine {
   constructor(config) {
     this.config = config;
@@ -6132,28 +7031,7 @@ var Engine = class _Engine {
     }
     this.sessionManager = new SessionManager(config.sessionStorageDir);
     this.modelPool = new ModelPool();
-    try {
-      const sm = new SettingsManager(config.cwd);
-      const settings = sm.get();
-      if (settings.models?.length) {
-        for (const m of settings.models) {
-          this.modelPool.register({
-            key: m.key,
-            label: m.label,
-            provider: m.provider,
-            model: m.model,
-            baseUrl: m.baseUrl,
-            apiKey: m.apiKey,
-            maxOutputTokens: m.maxOutputTokens,
-            maxContextTokens: m.maxContextTokens
-          });
-        }
-        const currentModel = config.llm.model;
-        const match = settings.models.find((m) => m.model === currentModel);
-        if (match) this.modelPool.switch(match.key);
-      }
-    } catch {
-    }
+    this.populateModelPoolFromSettings();
   }
   preset;
   toolRegistry;
@@ -6172,10 +7050,99 @@ var Engine = class _Engine {
   lastSessionId;
   compactedMessagesBySession = /* @__PURE__ */ new Map();
   activePermission;
+  /** Public accessor so UI/clients can read the resolved per-model window. */
+  get maxContextTokens() {
+    return this.resolveMaxContextTokens();
+  }
   resolveMaxContextTokens() {
     const modelEntry = this.modelPool.get();
     return modelEntry?.maxContextTokens ?? this.config.maxContextTokens ?? 2e5;
   }
+  /**
+   * Load models[] / providers[] from settings into the active ModelPool and
+   * resync this.config.llm with the matching entry. Called from the ctor and
+   * from reloadModelPool() (e.g. after onboarding writes new entries to disk).
+   */
+  populateModelPoolFromSettings() {
+    try {
+      const sm = this.getSettingsManager();
+      sm.invalidate();
+      const settings = sm.get();
+      if (settings.models?.length) {
+        for (const m of settings.models) {
+          this.modelPool.register({
+            key: m.key,
+            label: m.label,
+            provider: m.provider ?? "",
+            model: m.model,
+            baseUrl: m.baseUrl,
+            apiKey: m.apiKey,
+            maxOutputTokens: m.maxOutputTokens,
+            maxContextTokens: m.maxContextTokens,
+            providerKey: m.providerKey
+          });
+        }
+        if (settings.providers?.length) {
+          this.modelPool.setProviderCatalog(
+            new ProviderCatalog(settings.providers)
+          );
+        }
+        this.modelPool.setCacheDir(defaultCacheDir());
+        this.modelPool.reloadCachedContextWindows();
+        const activeKey = settings.activeKey;
+        let match;
+        if (activeKey) {
+          match = settings.models.find((m) => m.key === activeKey);
+        }
+        if (!match) {
+          const currentModel = this.config.llm.model;
+          match = settings.models.find(
+            (m) => m.model === currentModel || currentModel && m.model?.endsWith(`/${currentModel}`)
+          );
+        }
+        if (match) {
+          const entry = this.modelPool.switch(match.key);
+          this.config = {
+            ...this.config,
+            llm: this.modelPool.toLLMConfig(entry, this.config.llm)
+          };
+        }
+      } else if (this.config.llm.apiKey) {
+        this.autoPopulatePool(this.config.llm.apiKey, this.config.llm.baseUrl);
+      }
+    } catch {
+    }
+  }
+  /**
+   * Re-read settings and refresh the model pool. Used after onboarding /login
+   * writes new providers[] / models[] to disk so the running engine picks them
+   * up without a process restart. Existing pool entries are kept (re-registering
+   * the same key overwrites them), so callers don't need to clear first.
+   */
+  reloadModelPool() {
+    this.populateModelPoolFromSettings();
+  }
+  /**
+   * Auto-populate the model pool when settings.models[] is empty but
+   * the user has configured an API key. Detects the provider from the
+   * key prefix / baseUrl and registers all its known models.
+   */
+  autoPopulatePool(apiKey, baseUrl) {
+    const provider = detectProviderFromApiKey(apiKey, baseUrl);
+    if (!provider) return;
+    const entries = buildModelPool(provider, apiKey);
+    for (const e of entries) {
+      this.modelPool.register(e);
+    }
+    const defaultEntry = provider.defaultModel ? entries.find((e) => e.model === provider.defaultModel) : entries[0];
+    if (defaultEntry) {
+      const entry = this.modelPool.switch(defaultEntry.key);
+      this.config = {
+        ...this.config,
+        llm: this.modelPool.toLLMConfig(entry, this.config.llm)
+      };
+    }
+  }
   /**
    * Register a custom tool (from product adapter) into the tool registry.
    * Must be called before run().
@@ -6196,6 +7163,20 @@ var Engine = class _Engine {
    */
   async run(task, options) {
     const cwd = this.config.cwd ?? process.cwd();
+    const noise = detectPastedNoise(task);
+    if (noise.isNoise) {
+      const hint = `Your input looks like pasted terminal output (${noise.reason}). I didn't start a task. What would you like to ask?` + (noise.cleaned ? `
+
+Extracted text: ${noise.cleaned.slice(0, 200)}` : "");
+      logger.info("engine.run.rejected", { reason: noise.reason, len: task.length });
+      return {
+        text: hint,
+        reason: "completed",
+        sessionId: options?.sessionId ?? "noise-rejected",
+        turnCount: 0,
+        usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 }
+      };
+    }
     const subAgentSpawner = {
       parentStream: options?.onStream,
       describe: () => ({
@@ -6247,6 +7228,7 @@ var Engine = class _Engine {
       const userMsg = { role: "user", content: task };
       messages.push(userMsg);
       session.transcript.appendMessage("user", task);
+      this.sessionManager.saveState(session.state);
     } else {
       session = this.sessionManager.create(cwd, this.config.llm.model, this.config.llm.provider);
       messages = [{ role: "user", content: task }];
@@ -6255,6 +7237,14 @@ var Engine = class _Engine {
       this.sessionManager.saveState(session.state);
     }
     logger.setSid(session.state.sessionId);
+    recordSessionStart(session.state.sessionId, {
+      task,
+      cwd,
+      model: this.config.llm.model,
+      provider: this.config.llm.provider,
+      permissionMode: this.config.permissionMode ?? "acceptEdits",
+      resumed: !!options?.sessionId
+    });
     options?.onStream?.({ type: "session_started", sessionId: session.state.sessionId });
     const llmClientPromise = createLLMClient(this.config.llm);
     const mode = this.config.permissionMode ?? "acceptEdits";
@@ -6268,6 +7258,9 @@ var Engine = class _Engine {
       });
     }
     const toolExecutor = new ToolExecutor(this.toolRegistry, permission, this.hooks);
+    const investigationGuard = new InvestigationGuard();
+    if (this.config.headless) investigationGuard.setSoftMode(true);
+    toolExecutor.setInvestigationGuard(investigationGuard);
     toolExecutor.setSignal(options?.signal);
     toolExecutor.setContext(toolCtx);
     const contextManager = new ContextManager({
@@ -6319,6 +7312,7 @@ var Engine = class _Engine {
     this.lastSessionId = session.state.sessionId;
     this.lastMessages = messages;
     contextManager.setTranscriptPath(session.transcript.getFilePath());
+    contextManager.initReplacementStateFromMessages(messages);
     contextManager.setSummarizeFn(async (prompt) => {
       const summaryResponse = await llmClient.createMessage({
         systemPrompt: "You are a conversation summarizer. Be concise and factual.",
@@ -6338,12 +7332,23 @@ var Engine = class _Engine {
         systemPrompt: sysPrompt,
         messages: [{ role: "user", content: userMsg }],
         tools: [],
-        maxTokens: 256
+        maxTokens: 256,
+        recordUsage: false
+      });
+      logger.debug("summarize.call", {
+        sysPromptLen: sysPrompt.length,
+        userMsgLen: userMsg.length,
+        userMsgPreview: userMsg.slice(0, 300),
+        completionLen: resp.text.length,
+        completionPreview: resp.text.slice(0, 300),
+        stopReason: resp.stopReason,
+        promptTokens: resp.usage?.promptTokens,
+        completionTokens: resp.usage?.completionTokens
       });
       return resp.text;
     };
-    const sessionDir = join6(
-      this.config.sessionStorageDir ?? join6(homedir4(), ".code-shell", "sessions"),
+    const sessionDir = join8(
+      this.config.sessionStorageDir ?? join8(homedir4(), ".code-shell", "sessions"),
       session.state.sessionId
     );
     const fileHistory = FileHistory.loadFromDir(sessionDir);
@@ -6382,7 +7387,24 @@ var Engine = class _Engine {
         maxTurns: this.config.maxTurns ?? 100,
         maxToolCallsPerTurn: this.config.maxToolCallsPerTurn ?? 10,
         onStream: options?.onStream,
-        signal: options?.signal
+        signal: options?.signal,
+        // Heartbeat: flush turnCount + tokens to state.json after every turn
+        // so external observers (other CLI processes, /sid, the session list)
+        // see live progress instead of a stale snapshot from the last
+        // completed run.
+        onTurnBoundary: (turnCount) => {
+          session.state.turnCount = turnCount;
+          const u = modelFacade.getUsage();
+          session.state.tokenUsage = {
+            promptTokens: u.totalPromptTokens,
+            completionTokens: u.totalCompletionTokens,
+            totalTokens: u.totalTokens
+          };
+          if (this.config.costStore) {
+            session.state.costState = this.config.costStore.serialize();
+          }
+          this.sessionManager.saveState(session.state);
+        }
       }
     );
     const result = await turnLoop.run(messages);
@@ -6397,8 +7419,13 @@ var Engine = class _Engine {
       turns: turnLoop.currentTurn,
       tokens: modelFacade.getUsage().totalTokens
     });
+    recordSessionEnd(session.state.sessionId, {
+      reason: result.reason,
+      turns: turnLoop.currentTurn,
+      cost: modelFacade.getUsage()
+    });
     session.state.turnCount = turnLoop.currentTurn;
-    session.state.status = result.reason === "completed" ? "completed" : "errored";
+    session.state.status = result.reason;
     const usage = modelFacade.getUsage();
     session.state.tokenUsage = {
       promptTokens: usage.totalPromptTokens,
@@ -6433,15 +7460,67 @@ var Engine = class _Engine {
   /**
    * Switch the active model by pool key. Takes effect on the next run() call.
    * Returns the new model entry.
+   *
+   * Persists settings.activeKey (and a legacy settings.model.* mirror) so the
+   * next process startup defaults to the same model — without this, switches
+   * only live in memory and every restart reverts to the previously persisted
+   * activeKey.
    */
   switchModel(key) {
     const entry = this.modelPool.switch(key);
-    this.config = {
-      ...this.config,
-      llm: this.modelPool.toLLMConfig(entry, this.config.llm)
-    };
+    const nextLlm = this.modelPool.toLLMConfig(entry, this.config.llm);
+    this.config = { ...this.config, llm: nextLlm };
+    this.persistActiveModel(entry, nextLlm);
     return entry;
   }
+  /**
+   * Write the active model selection to ~/.code-shell/settings.json.
+   *
+   * We mirror into the legacy settings.model.* block (provider/name/apiKey/
+   * baseUrl) because boot paths in cli/main.ts, repl.ts, run.ts still read it.
+   * The mirror uses resolved llm values (not raw entry.*) so credentials that
+   * live on settings.providers[] flow through correctly — entry.apiKey is
+   * undefined when the entry resolves via providerCatalog.
+   */
+  persistActiveModel(entry, llm) {
+    try {
+      const dir = join8(homedir4(), ".code-shell");
+      const file = join8(dir, "settings.json");
+      mkdirSync4(dir, { recursive: true });
+      let existing = {};
+      if (existsSync11(file)) {
+        try {
+          existing = JSON.parse(readFileSync6(file, "utf-8"));
+        } catch {
+          return;
+        }
+      }
+      const prevModel = typeof existing.model === "object" && existing.model ? existing.model : {};
+      const updated = {
+        ...existing,
+        activeKey: entry.key,
+        model: {
+          ...prevModel,
+          provider: llm.provider,
+          name: entry.model,
+          apiKey: llm.apiKey,
+          baseUrl: llm.baseUrl
+        }
+      };
+      const tmp = `${file}.${process.pid}.tmp`;
+      const payload = JSON.stringify(updated, null, 2) + "\n";
+      writeFileSync4(tmp, payload, "utf-8");
+      try {
+        renameSync(tmp, file);
+      } catch {
+        writeFileSync4(file, payload, "utf-8");
+      }
+    } catch (err) {
+      logger.warn(
+        `persistActiveModel failed: ${err.message}`
+      );
+    }
+  }
   /** Get the model pool. */
   getModelPool() {
     return this.modelPool;
@@ -6463,10 +7542,18 @@ var Engine = class _Engine {
    * Inject context into a session's transcript without triggering a LLM turn.
    * The injected content appears as an assistant message so the LLM can see it
    * in subsequent conversations. The transcript auto-flushes to disk.
+   *
+   * Also updates the in-memory compacted message cache so the next
+   * engine.run() call for this session picks up the injected content
+   * instead of a stale snapshot from the previous run.
    */
   injectContext(sessionId, content) {
     const session = this.sessionManager.resume(sessionId);
     session.transcript.appendMessage("assistant", content);
+    const cached = this.compactedMessagesBySession.get(sessionId);
+    if (cached) {
+      cached.push({ role: "assistant", content });
+    }
   }
   /**
    * Force context compaction on the current session.
@@ -6593,83 +7680,83 @@ var VALID_TRANSITIONS = {
 // src/run/FileRunStore.ts
 init_esm_shims();
 import {
-  mkdirSync as mkdirSync2,
-  existsSync as existsSync10,
-  readFileSync as readFileSync6,
-  writeFileSync as writeFileSync3,
-  appendFileSync,
-  readdirSync as readdirSync5,
-  renameSync,
-  rmSync
+  mkdirSync as mkdirSync5,
+  existsSync as existsSync12,
+  readFileSync as readFileSync7,
+  writeFileSync as writeFileSync5,
+  appendFileSync as appendFileSync2,
+  readdirSync as readdirSync6,
+  renameSync as renameSync2,
+  rmSync as rmSync2
 } from "fs";
-import { join as join7 } from "path";
+import { join as join9 } from "path";
 import { homedir as homedir5 } from "os";
 var FileRunStore = class {
   runsDir;
   constructor(storageDir) {
-    this.runsDir = storageDir ?? join7(homedir5(), ".code-shell", "runs");
-    mkdirSync2(this.runsDir, { recursive: true });
+    this.runsDir = storageDir ?? join9(homedir5(), ".code-shell", "runs");
+    mkdirSync5(this.runsDir, { recursive: true });
   }
   // ─── Helpers ───────────────────────────────────────────────────
   runDir(runId) {
-    return join7(this.runsDir, runId);
+    return join9(this.runsDir, runId);
   }
   ensureRunDir(runId) {
     const dir = this.runDir(runId);
-    mkdirSync2(dir, { recursive: true });
-    mkdirSync2(join7(dir, "checkpoints"), { recursive: true });
-    mkdirSync2(join7(dir, "approvals"), { recursive: true });
-    mkdirSync2(join7(dir, "artifacts"), { recursive: true });
+    mkdirSync5(dir, { recursive: true });
+    mkdirSync5(join9(dir, "checkpoints"), { recursive: true });
+    mkdirSync5(join9(dir, "approvals"), { recursive: true });
+    mkdirSync5(join9(dir, "artifacts"), { recursive: true });
     return dir;
   }
   writeJson(filePath, data) {
     const tmp = filePath + ".tmp";
-    writeFileSync3(tmp, JSON.stringify(data, null, 2), "utf-8");
-    renameSync(tmp, filePath);
+    writeFileSync5(tmp, JSON.stringify(data, null, 2), "utf-8");
+    renameSync2(tmp, filePath);
   }
   readJson(filePath) {
-    if (!existsSync10(filePath)) return null;
-    return JSON.parse(readFileSync6(filePath, "utf-8"));
+    if (!existsSync12(filePath)) return null;
+    return JSON.parse(readFileSync7(filePath, "utf-8"));
   }
   /** Serializes concurrent JSONL appends per file path. */
   appendLocks = /* @__PURE__ */ new Map();
   async appendJsonl(filePath, data) {
     const prev = this.appendLocks.get(filePath) ?? Promise.resolve();
     const current = prev.then(() => {
-      appendFileSync(filePath, JSON.stringify(data) + "\n", "utf-8");
+      appendFileSync2(filePath, JSON.stringify(data) + "\n", "utf-8");
     });
     this.appendLocks.set(filePath, current);
     await current;
   }
   readJsonl(filePath) {
-    if (!existsSync10(filePath)) return [];
-    const content = readFileSync6(filePath, "utf-8");
+    if (!existsSync12(filePath)) return [];
+    const content = readFileSync7(filePath, "utf-8");
     if (!content) return [];
     return content.split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
   }
   // ─── Snapshot ──────────────────────────────────────────────────
   async create(snapshot) {
     const dir = this.ensureRunDir(snapshot.runId);
-    this.writeJson(join7(dir, "run.json"), snapshot);
+    this.writeJson(join9(dir, "run.json"), snapshot);
   }
   async update(snapshot) {
     const dir = this.runDir(snapshot.runId);
-    if (!existsSync10(dir)) {
+    if (!existsSync12(dir)) {
       throw new Error(`Run not found: ${snapshot.runId}`);
     }
-    this.writeJson(join7(dir, "run.json"), snapshot);
+    this.writeJson(join9(dir, "run.json"), snapshot);
   }
   async get(runId) {
-    return this.readJson(join7(this.runDir(runId), "run.json"));
+    return this.readJson(join9(this.runDir(runId), "run.json"));
   }
   async list(query) {
-    if (!existsSync10(this.runsDir)) return [];
-    const entries = readdirSync5(this.runsDir, { withFileTypes: true });
+    if (!existsSync12(this.runsDir)) return [];
+    const entries = readdirSync6(this.runsDir, { withFileTypes: true });
     const snapshots = [];
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const snapshot = this.readJson(
-        join7(this.runsDir, entry.name, "run.json")
+        join9(this.runsDir, entry.name, "run.json")
       );
       if (!snapshot) continue;
       if (query?.status) {
@@ -6686,32 +7773,32 @@ var FileRunStore = class {
   }
   async delete(runId) {
     const dir = this.runDir(runId);
-    if (existsSync10(dir)) {
-      rmSync(dir, { recursive: true, force: true });
+    if (existsSync12(dir)) {
+      rmSync2(dir, { recursive: true, force: true });
     }
   }
   // ─── Events ────────────────────────────────────────────────────
   async appendEvent(event) {
     this.ensureRunDir(event.runId);
     const dir = this.runDir(event.runId);
-    await this.appendJsonl(join7(dir, "events.jsonl"), event);
+    await this.appendJsonl(join9(dir, "events.jsonl"), event);
   }
   async listEvents(runId) {
-    return this.readJsonl(join7(this.runDir(runId), "events.jsonl"));
+    return this.readJsonl(join9(this.runDir(runId), "events.jsonl"));
   }
   // ─── Checkpoints ───────────────────────────────────────────────
   async saveCheckpoint(cp) {
     const dir = this.runDir(cp.runId);
-    this.writeJson(join7(dir, "checkpoints", `${cp.checkpointId}.json`), cp);
+    this.writeJson(join9(dir, "checkpoints", `${cp.checkpointId}.json`), cp);
   }
   async getLatestCheckpoint(runId) {
-    const cpDir = join7(this.runDir(runId), "checkpoints");
-    if (!existsSync10(cpDir)) return null;
-    const files = readdirSync5(cpDir).filter((f) => f.endsWith(".json"));
+    const cpDir = join9(this.runDir(runId), "checkpoints");
+    if (!existsSync12(cpDir)) return null;
+    const files = readdirSync6(cpDir).filter((f) => f.endsWith(".json"));
     if (files.length === 0) return null;
     let latest = null;
     for (const file of files) {
-      const cp = this.readJson(join7(cpDir, file));
+      const cp = this.readJson(join9(cpDir, file));
       if (cp && (!latest || cp.createdAt > latest.createdAt)) {
         latest = cp;
       }
@@ -6722,21 +7809,21 @@ var FileRunStore = class {
   async saveApproval(approval) {
     const dir = this.runDir(approval.runId);
     this.writeJson(
-      join7(dir, "approvals", `${approval.approvalId}.json`),
+      join9(dir, "approvals", `${approval.approvalId}.json`),
       approval
     );
   }
   async getApproval(runId, approvalId) {
     return this.readJson(
-      join7(this.runDir(runId), "approvals", `${approvalId}.json`)
+      join9(this.runDir(runId), "approvals", `${approvalId}.json`)
     );
   }
   async getPendingApproval(runId) {
-    const approvalDir = join7(this.runDir(runId), "approvals");
-    if (!existsSync10(approvalDir)) return null;
-    const files = readdirSync5(approvalDir).filter((f) => f.endsWith(".json"));
+    const approvalDir = join9(this.runDir(runId), "approvals");
+    if (!existsSync12(approvalDir)) return null;
+    const files = readdirSync6(approvalDir).filter((f) => f.endsWith(".json"));
     for (const file of files) {
-      const approval = this.readJson(join7(approvalDir, file));
+      const approval = this.readJson(join9(approvalDir, file));
       if (approval?.status === "pending") return approval;
     }
     return null;
@@ -6745,11 +7832,11 @@ var FileRunStore = class {
   async appendArtifactRef(ref) {
     this.ensureRunDir(ref.runId);
     const dir = this.runDir(ref.runId);
-    await this.appendJsonl(join7(dir, "artifacts", "refs.jsonl"), ref);
+    await this.appendJsonl(join9(dir, "artifacts", "refs.jsonl"), ref);
   }
   async listArtifactRefs(runId) {
     return this.readJsonl(
-      join7(this.runDir(runId), "artifacts", "refs.jsonl")
+      join9(this.runDir(runId), "artifacts", "refs.jsonl")
     );
   }
 };
@@ -7116,8 +8203,8 @@ function extractFileName(filePath) {
 
 // src/run/RunLock.ts
 init_esm_shims();
-import { existsSync as existsSync11 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { join as join10 } from "path";
 import { homedir as homedir6 } from "os";
 
 // src/utils/lockfile.ts
@@ -7145,7 +8232,7 @@ var RunLock = class {
   staleMs;
   releaseFns = /* @__PURE__ */ new Map();
   constructor(config) {
-    this.runsDir = config?.runsDir ?? join8(homedir6(), ".code-shell", "runs");
+    this.runsDir = config?.runsDir ?? join10(homedir6(), ".code-shell", "runs");
     this.staleMs = config?.staleMs ?? 6e4;
   }
   /**
@@ -7153,7 +8240,7 @@ var RunLock = class {
    */
   async acquire(runId) {
     const lockTarget = this.lockTarget(runId);
-    if (!existsSync11(lockTarget)) return false;
+    if (!existsSync13(lockTarget)) return false;
     try {
       const release = await lock(lockTarget, {
         stale: this.staleMs,
@@ -7185,7 +8272,7 @@ var RunLock = class {
    */
   async isLocked(runId) {
     const lockTarget = this.lockTarget(runId);
-    if (!existsSync11(lockTarget)) return false;
+    if (!existsSync13(lockTarget)) return false;
     try {
       return await check(lockTarget, { stale: this.staleMs });
     } catch {
@@ -7197,7 +8284,7 @@ var RunLock = class {
    */
   async forceUnlock(runId) {
     const lockTarget = this.lockTarget(runId);
-    if (!existsSync11(lockTarget)) return;
+    if (!existsSync13(lockTarget)) return;
     try {
       await unlock(lockTarget);
       logger.info("run.lock.force_unlocked", { runId });
@@ -7213,21 +8300,21 @@ var RunLock = class {
     }
   }
   lockTarget(runId) {
-    return join8(this.runsDir, runId, "run.json");
+    return join10(this.runsDir, runId, "run.json");
   }
 };
 
 // src/run/Heartbeat.ts
 init_esm_shims();
-import { existsSync as existsSync12, readFileSync as readFileSync7, writeFileSync as writeFileSync4, unlinkSync } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync8, writeFileSync as writeFileSync6, unlinkSync } from "fs";
+import { join as join11 } from "path";
 import { homedir as homedir7 } from "os";
 var Heartbeat = class {
   runsDir;
   intervalMs;
   timers = /* @__PURE__ */ new Map();
   constructor(config) {
-    this.runsDir = config?.runsDir ?? join9(homedir7(), ".code-shell", "runs");
+    this.runsDir = config?.runsDir ?? join11(homedir7(), ".code-shell", "runs");
     this.intervalMs = config?.intervalMs ?? 5e3;
   }
   /**
@@ -7265,9 +8352,9 @@ var Heartbeat = class {
    */
   read(runId) {
     const filePath = this.filePath(runId);
-    if (!existsSync12(filePath)) return null;
+    if (!existsSync14(filePath)) return null;
     try {
-      return JSON.parse(readFileSync7(filePath, "utf-8"));
+      return JSON.parse(readFileSync8(filePath, "utf-8"));
     } catch {
       return null;
     }
@@ -7302,21 +8389,21 @@ var Heartbeat = class {
       runId
     };
     try {
-      writeFileSync4(this.filePath(runId), JSON.stringify(data), "utf-8");
+      writeFileSync6(this.filePath(runId), JSON.stringify(data), "utf-8");
     } catch {
     }
   }
   remove(runId) {
     try {
       const filePath = this.filePath(runId);
-      if (existsSync12(filePath)) {
+      if (existsSync14(filePath)) {
         unlinkSync(filePath);
       }
     } catch {
     }
   }
   filePath(runId) {
-    return join9(this.runsDir, runId, "heartbeat");
+    return join11(this.runsDir, runId, "heartbeat");
   }
 };
 
@@ -7957,6 +9044,14 @@ export {
   setRuntimeBypass,
   PermissionClassifier,
   HookRegistry,
+  DEFAULT_PERSIST_THRESHOLD,
+  PER_MESSAGE_AGGREGATE_CAP,
+  PREVIEW_SIZE,
+  createContentReplacementState,
+  reconstructContentReplacementState,
+  resolveToolResultsDir,
+  applyToolResultPersistence,
+  isPersistedReplacement,
   ContextManager,
   SectionCache,
   scanInstructions,