reasonix 0.27.2 → 0.27.3

package/dist/index.js

@@ -116,7 +116,9 @@ var DeepSeekClient = class {
       );
     }
     this.apiKey = apiKey;
-    this.baseUrl = (opts.baseUrl ?? process.env.DEEPSEEK_BASE_URL ?? "https://api.deepseek.com").replace(/\/+$/, "");
+    let url = opts.baseUrl ?? process.env.DEEPSEEK_BASE_URL ?? "https://api.deepseek.com";
+    while (url.endsWith("/")) url = url.slice(0, -1);
+    this.baseUrl = url;
     this.timeoutMs = opts.timeoutMs ?? 66e4;
     this._fetch = opts.fetch ?? globalThis.fetch.bind(globalThis);
     this.retry = opts.retry ?? {};
@@ -456,6 +458,7 @@ var PauseGate = class {
   _nextId = 0;
   _pending = /* @__PURE__ */ new Map();
   _listeners = /* @__PURE__ */ new Set();
+  _auditListener = null;
   /** Block until the user responds. Takes a named options object so the
    *  kind and payload fields don't get confused at the call site. */
   ask(opts) {
@@ -482,8 +485,12 @@ var PauseGate = class {
     const p = this._pending.get(id);
     if (!p) return;
     this._pending.delete(id);
+    this.emitAuditEvent(p.request, data);
     p.resolve(data);
   }
+  setAuditListener(fn) {
+    this._auditListener = fn;
+  }
   /** Subscribe to new pause requests. Returns an unsubscribe function. */
   on(fn) {
     this._listeners.add(fn);
@@ -496,6 +503,43 @@ var PauseGate = class {
     for (const [, p] of this._pending) return p.request;
     return null;
   }
+  emitAuditEvent(request, data) {
+    if (!this._auditListener) return;
+    if (request.kind !== "run_command" && request.kind !== "run_background") return;
+    if (!data || typeof data !== "object") return;
+    const choice = data;
+    try {
+      switch (choice.type) {
+        case "run_once":
+          this._auditListener({
+            type: "tool.confirm.allow",
+            kind: request.kind,
+            payload: request.payload
+          });
+          break;
+        case "deny":
+          this._auditListener({
+            type: "tool.confirm.deny",
+            kind: request.kind,
+            payload: request.payload,
+            denyContext: choice.denyContext
+          });
+          break;
+        case "always_allow":
+          if (typeof choice.prefix !== "string") return;
+          this._auditListener({
+            type: "tool.confirm.always_allow",
+            kind: request.kind,
+            payload: request.payload,
+            prefix: choice.prefix
+          });
+          break;
+        default:
+          break;
+      }
+    } catch {
+    }
+  }
 };
 var pauseGate = new PauseGate();
 
@@ -954,6 +998,7 @@ var ToolRegistry = class {
   _autoFlatten;
   _planMode = false;
   _interceptor = null;
+  _auditListener = null;
   constructor(opts = {}) {
     this._autoFlatten = opts.autoFlatten !== false;
   }
@@ -969,6 +1014,9 @@ var ToolRegistry = class {
   setToolInterceptor(fn) {
     this._interceptor = fn;
   }
+  setAuditListener(fn) {
+    this._auditListener = fn;
+  }
   register(def) {
     if (!def.name) throw new Error("tool requires a name");
     const internal = { ...def };
@@ -1041,6 +1089,10 @@ var ToolRegistry = class {
       }
     }
     try {
+      try {
+        this._auditListener?.({ name, args });
+      } catch {
+      }
       const result = await tool.fn(args, {
         signal: opts.signal,
         confirmationGate: opts.confirmationGate
@@ -1618,169 +1670,513 @@ var ContextManager = class {
   }
 };
 
-// src/memory/runtime.ts
-import { createHash } from "crypto";
-var ImmutablePrefix = class {
-  system;
-  /** Each `addTool` costs one cache-miss turn — DeepSeek's prefix cache is keyed by full tool list. */
-  _toolSpecs;
-  fewShots;
-  /** Invalidated only via `addTool`; bypassing it leaves cache stale → fingerprint diverges from sent prefix. */
-  _fingerprintCache = null;
-  constructor(opts) {
-    this.system = opts.system;
-    this._toolSpecs = [...opts.toolSpecs ?? []];
-    this.fewShots = Object.freeze([...opts.fewShots ?? []]);
-  }
-  get toolSpecs() {
-    return this._toolSpecs;
-  }
-  toMessages() {
-    return [{ role: "system", content: this.system }, ...this.fewShots.map((m) => ({ ...m }))];
+// src/loop/branch.ts
+function summarizeBranch(chosen, samples) {
+  return {
+    budget: samples.length,
+    chosenIndex: chosen.index,
+    uncertainties: samples.map((s) => s.planState.uncertainties.length),
+    temperatures: samples.map((s) => s.temperature)
+  };
+}
+
+// src/loop/errors.ts
+function formatLoopError(err) {
+  const msg = err.message ?? "";
+  if (msg.includes("maximum context length")) {
+    const reqMatch = msg.match(/requested\s+(\d+)\s+tokens/);
+    const requested = reqMatch ? `${Number(reqMatch[1]).toLocaleString()} tokens` : "too many tokens";
+    return `Context overflow (DeepSeek 400): session history is ${requested}, past the model's prompt limit (V4: 1M tokens; legacy chat/reasoner: 131k). Usually a single tool result grew too big. Reasonix caps new tool results at 8k tokens and auto-heals oversized history on session load \u2014 a restart often clears it. If it still overflows, run /forget (delete the session) or /clear (drop the displayed history) to start fresh.`;
   }
-  tools() {
-    return this._toolSpecs.map((t) => structuredClone(t));
+  const m = /^DeepSeek (\d{3}):\s*([\s\S]*)$/.exec(msg);
+  if (!m) return msg;
+  const status = m[1] ?? "";
+  const body = m[2] ?? "";
+  const inner = extractDeepSeekErrorMessage(body);
+  if (status === "401") {
+    return `Authentication failed (DeepSeek 401): ${inner}. Your API key is rejected. Fix with \`reasonix setup\` or \`export DEEPSEEK_API_KEY=sk-...\`. Get one at https://platform.deepseek.com/api_keys.`;
   }
-  addTool(spec) {
-    const name = spec.function?.name;
-    if (!name) return false;
-    if (this._toolSpecs.some((t) => t.function?.name === name)) return false;
-    this._toolSpecs.push(spec);
-    this._fingerprintCache = null;
-    return true;
+  if (status === "402") {
+    return `Out of balance (DeepSeek 402): ${inner}. Top up at https://platform.deepseek.com/top_up \u2014 the panel header shows your balance once it's non-zero.`;
   }
-  /** Mirror of addTool for MCP hot-unbridge. Same cache-miss cost — prefix changes shape. */
-  removeTool(name) {
-    const idx = this._toolSpecs.findIndex((t) => t.function?.name === name);
-    if (idx < 0) return false;
-    this._toolSpecs.splice(idx, 1);
-    this._fingerprintCache = null;
-    return true;
+  if (status === "422") {
+    return `Invalid parameter (DeepSeek 422): ${inner}`;
   }
-  get fingerprint() {
-    if (this._fingerprintCache !== null) return this._fingerprintCache;
-    this._fingerprintCache = this.computeFingerprint();
-    return this._fingerprintCache;
+  if (status === "400") {
+    return `Bad request (DeepSeek 400): ${inner}`;
   }
-  /** Dev/test only — throws on cache drift, which always means a non-`addTool` mutation slipped in. */
-  verifyFingerprint() {
-    const fresh = this.computeFingerprint();
-    if (this._fingerprintCache !== null && this._fingerprintCache !== fresh) {
-      throw new Error(
-        `ImmutablePrefix fingerprint drift: cached=${this._fingerprintCache}, fresh=${fresh}. A mutation path bypassed addTool's cache invalidation \u2014 DeepSeek will see prefix churn that the TUI / transcript log don't know about.`
-      );
-    }
-    this._fingerprintCache = fresh;
-    return fresh;
+  return msg;
+}
+function reasonPrefixFor(reason, iterCap) {
+  if (reason === "aborted") return "[aborted by user (Esc) \u2014 summarizing what I found so far]";
+  if (reason === "context-guard") {
+    return "[context budget running low \u2014 summarizing before the next call would overflow]";
   }
-  computeFingerprint() {
-    const blob = JSON.stringify({
-      system: this.system,
-      tools: this._toolSpecs,
-      shots: this.fewShots
-    });
-    return createHash("sha256").update(blob).digest("hex").slice(0, 16);
+  if (reason === "stuck") {
+    return "[stuck on a repeated tool call \u2014 explaining what was tried and what's blocking progress]";
   }
-};
-var AppendOnlyLog = class {
-  _entries = [];
-  append(message) {
-    if (!message || typeof message !== "object" || !("role" in message)) {
-      throw new Error(`invalid log entry: ${JSON.stringify(message)}`);
+  return `[tool-call budget (${iterCap}) reached \u2014 forcing summary from what I found]`;
+}
+function errorLabelFor(reason, iterCap) {
+  if (reason === "aborted") return "aborted by user";
+  if (reason === "context-guard") return "context-guard triggered (prompt > 80% of window)";
+  if (reason === "stuck") return "stuck (repeated tool call suppressed by storm-breaker)";
+  return `tool-call budget (${iterCap}) reached`;
+}
+function extractDeepSeekErrorMessage(body) {
+  const trimmed = body.trim();
+  if (!trimmed) return "(no message)";
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed && typeof parsed === "object") {
+      const obj = parsed;
+      if (obj.error && typeof obj.error.message === "string") return obj.error.message;
+      if (typeof obj.message === "string") return obj.message;
     }
-    this._entries.push(message);
-  }
-  extend(messages) {
-    for (const m of messages) this.append(m);
-  }
-  /** The one append-only-breaking path — reserved for `/compact` + recovery. Use `append()` otherwise. */
-  compactInPlace(replacement) {
-    this._entries = [...replacement];
-  }
-  get entries() {
-    return this._entries;
-  }
-  toMessages() {
-    return this._entries.map((e) => ({ ...e }));
-  }
-  get length() {
-    return this._entries.length;
-  }
-};
-var VolatileScratch = class {
-  reasoning = null;
-  planState = null;
-  notes = [];
-  reset() {
-    this.reasoning = null;
-    this.planState = null;
-    this.notes = [];
+  } catch {
   }
-};
+  return trimmed;
+}
 
-// src/repair/scavenge.ts
-function scavengeToolCalls(reasoningContent, opts) {
-  if (!reasoningContent) return { calls: [], notes: [] };
-  const max = opts.maxCalls ?? 4;
-  const notes = [];
-  const out = [];
-  for (const invoke of iterateDsmlInvokes(reasoningContent)) {
-    if (out.length >= max) break;
-    if (!opts.allowedNames.has(invoke.name)) continue;
-    out.push({
-      function: {
-        name: invoke.name,
-        arguments: JSON.stringify(invoke.args)
-      }
-    });
-    notes.push(`scavenged DSML call: ${invoke.name}`);
-  }
-  const nonDsml = stripDsmlBlocks(reasoningContent);
-  for (const candidate of iterateJsonObjects(nonDsml)) {
-    if (out.length >= max) break;
-    const call = coerceToToolCall(candidate, opts.allowedNames);
-    if (call) {
-      out.push(call);
-      notes.push(`scavenged call: ${call.function.name}`);
-    }
-  }
-  return { calls: out, notes };
+// src/loop/escalation.ts
+var NEEDS_PRO_MARKER_PREFIX = "<<<NEEDS_PRO";
+var NEEDS_PRO_MARKER_RE = /^<<<NEEDS_PRO(?::\s*([^>]*))?>>>/;
+var NEEDS_PRO_BUFFER_CHARS = 256;
+function parseEscalationMarker(content) {
+  const m = NEEDS_PRO_MARKER_RE.exec(content.trimStart());
+  if (!m) return { matched: false };
+  const reason = m[1]?.trim();
+  return { matched: true, reason: reason || void 0 };
+}
+function isEscalationRequest(content) {
+  return parseEscalationMarker(content).matched;
+}
+function looksLikePartialEscalationMarker(buf) {
+  const t = buf.trimStart();
+  if (t.length === 0) return true;
+  if (t.length <= NEEDS_PRO_MARKER_PREFIX.length) {
+    return NEEDS_PRO_MARKER_PREFIX.startsWith(t);
+  }
+  if (!t.startsWith(NEEDS_PRO_MARKER_PREFIX)) return false;
+  const rest = t.slice(NEEDS_PRO_MARKER_PREFIX.length);
+  if (rest[0] !== ">" && rest[0] !== ":") return false;
+  return true;
 }
-function stripDsmlBlocks(text) {
-  let out = text;
-  out = out.replace(/<[｜|]DSML[｜|]function_calls>[\s\S]*?<\/?[｜|]DSML[｜|]function_calls>/g, "");
-  out = out.replace(/<[｜|]DSML[｜|]invoke\s+[^>]*>[\s\S]*?<\/[｜|]DSML[｜|]invoke>/g, "");
-  return out;
+
+// src/loop/thinking.ts
+function isThinkingModeModel(model) {
+  if (model.includes("reasoner")) return true;
+  if (model === "deepseek-v4-flash" || model === "deepseek-v4-pro") return true;
+  return false;
 }
-function* iterateDsmlInvokes(text) {
-  const INVOKE_RE = /<[｜|]DSML[｜|]invoke\s+name="([^"]+)">([\s\S]*?)<\/[｜|]DSML[｜|]invoke>/g;
-  for (const match of text.matchAll(INVOKE_RE)) {
-    const name = match[1];
-    const body = match[2];
-    if (!name || body === void 0) continue;
-    yield { name, args: parseDsmlParameters(body) };
+function thinkingModeForModel(model) {
+  if (model === "deepseek-chat") return "disabled";
+  if (model.includes("reasoner")) return "enabled";
+  if (model === "deepseek-v4-flash" || model === "deepseek-v4-pro") return "enabled";
+  return void 0;
+}
+function stripHallucinatedToolMarkup(s) {
+  let out = s;
+  out = out.replace(/<｜DSML｜function_calls>[\s\S]*?<\/?｜DSML｜function_calls>/g, "");
+  out = out.replace(/<\|DSML\|function_calls>[\s\S]*?<\/?\|DSML\|function_calls>/g, "");
+  out = out.replace(/<function_calls>[\s\S]*?<\/function_calls>/g, "");
+  out = out.replace(/<｜DSML｜[\s\S]*$/g, "");
+  return out.trim();
+}
+
+// src/loop/messages.ts
+function buildAssistantMessage(content, toolCalls, producingModel, reasoningContent) {
+  const msg = { role: "assistant", content };
+  if (toolCalls.length > 0) msg.tool_calls = toolCalls;
+  if (isThinkingModeModel(producingModel) || reasoningContent && reasoningContent.length > 0) {
+    msg.reasoning_content = reasoningContent ?? "";
   }
+  return msg;
 }
-function parseDsmlParameters(body) {
-  const PARAM_RE = /<[｜|]DSML[｜|]parameter\s+name="([^"]+)"(?:\s+string="(true|false)")?\s*>([\s\S]*?)<\/[｜|]DSML[｜|]parameter>/g;
-  const args = {};
-  for (const m of body.matchAll(PARAM_RE)) {
-    const key = m[1];
-    const stringFlag = m[2];
-    const raw = (m[3] ?? "").trim();
-    if (!key) continue;
-    if (stringFlag === "false") {
-      try {
-        args[key] = JSON.parse(raw);
-        continue;
-      } catch {
-      }
-    }
-    args[key] = raw;
+function buildSyntheticAssistantMessage(content, fallbackModel) {
+  return buildAssistantMessage(content, [], fallbackModel, "");
+}
+
+// src/loop/force-summary.ts
+async function* forceSummaryAfterIterLimit(ctx, opts = { reason: "budget" }) {
+  try {
+    yield { turn: ctx.turn, role: "status", content: "summarizing what was gathered\u2026" };
+    const messages = ctx.buildMessages();
+    messages.push({
+      role: "user",
+      content: "I'm out of tool-call budget for this turn. Summarize in plain prose what you learned from the tool results above. Do NOT emit any tool calls, function-call markup, DSML invocations, or SEARCH/REPLACE edit blocks \u2014 they will be silently discarded. Just plain text."
+    });
+    const summaryModel = "deepseek-v4-flash";
+    const summaryEffort = "high";
+    const resp = await ctx.client.chat({
+      model: summaryModel,
+      messages,
+      signal: ctx.signal,
+      thinking: thinkingModeForModel(summaryModel),
+      reasoningEffort: summaryEffort
+    });
+    const rawContent = resp.content?.trim() ?? "";
+    const cleaned = stripHallucinatedToolMarkup(rawContent);
+    const summary = cleaned || "(model emitted fake tool-call markup instead of a prose summary \u2014 try /retry with a narrower question, or /think to inspect R1's reasoning)";
+    const reasonPrefix = reasonPrefixFor(opts.reason, ctx.maxToolIters);
+    const annotated = `${reasonPrefix}
+
+${summary}`;
+    const summaryStats = ctx.recordStats(summaryModel, resp.usage ?? new Usage());
+    ctx.appendAndPersist(buildAssistantMessage(summary, [], summaryModel, resp.reasoningContent));
+    yield {
+      turn: ctx.turn,
+      role: "assistant_final",
+      content: annotated,
+      stats: summaryStats,
+      forcedSummary: true
+    };
+    yield { turn: ctx.turn, role: "done", content: summary };
+  } catch (err) {
+    const label = errorLabelFor(opts.reason, ctx.maxToolIters);
+    yield {
+      turn: ctx.turn,
+      role: "error",
+      content: "",
+      error: `${label} and the fallback summary call failed: ${err.message}. Run /clear and retry with a narrower question, or raise --max-tool-iters.`
+    };
+    yield { turn: ctx.turn, role: "done", content: "" };
   }
-  return args;
 }
-function* iterateJsonObjects(text) {
+
+// src/loop/shrink.ts
+function looksLikeCompleteJson(s) {
+  if (!s || !s.trim()) return false;
+  try {
+    JSON.parse(s);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function shrinkOversizedToolResults(messages, maxChars) {
+  let healedCount = 0;
+  let healedFrom = 0;
+  const out = messages.map((msg) => {
+    if (msg.role !== "tool") return msg;
+    const content = typeof msg.content === "string" ? msg.content : "";
+    if (content.length <= maxChars) return msg;
+    healedCount += 1;
+    healedFrom += content.length;
+    return { ...msg, content: truncateForModel(content, maxChars) };
+  });
+  return { messages: out, healedCount, healedFrom };
+}
+function shrinkOversizedToolResultsByTokens(messages, maxTokens) {
+  let healedCount = 0;
+  let tokensSaved = 0;
+  let charsSaved = 0;
+  const out = messages.map((msg) => {
+    if (msg.role !== "tool") return msg;
+    const content = typeof msg.content === "string" ? msg.content : "";
+    if (content.length <= maxTokens) return msg;
+    const beforeTokens = countTokens(content);
+    if (beforeTokens <= maxTokens) return msg;
+    const truncated = truncateForModelByTokens(content, maxTokens);
+    const afterTokens = countTokens(truncated);
+    healedCount += 1;
+    tokensSaved += Math.max(0, beforeTokens - afterTokens);
+    charsSaved += Math.max(0, content.length - truncated.length);
+    return { ...msg, content: truncated };
+  });
+  return { messages: out, healedCount, tokensSaved, charsSaved };
+}
+
+// src/loop/healing.ts
+function fixToolCallPairing(messages) {
+  const out = [];
+  let droppedAssistantCalls = 0;
+  let droppedStrayTools = 0;
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
+      const needed = /* @__PURE__ */ new Set();
+      for (const call of msg.tool_calls) {
+        if (call?.id) needed.add(call.id);
+      }
+      const candidates = [];
+      let j = i + 1;
+      while (j < messages.length && needed.size > 0) {
+        const nxt = messages[j];
+        if (nxt.role !== "tool") break;
+        const id = nxt.tool_call_id ?? "";
+        if (!needed.has(id)) break;
+        needed.delete(id);
+        candidates.push(nxt);
+        j++;
+      }
+      if (needed.size === 0) {
+        out.push(msg);
+        for (const r of candidates) out.push(r);
+        i = j - 1;
+      } else {
+        droppedAssistantCalls += 1;
+        droppedStrayTools += candidates.length;
+        i = j - 1;
+      }
+      continue;
+    }
+    if (msg.role === "tool") {
+      droppedStrayTools += 1;
+      continue;
+    }
+    out.push(msg);
+  }
+  return { messages: out, droppedAssistantCalls, droppedStrayTools };
+}
+function healLoadedMessages(messages, maxChars) {
+  const shrunk = shrinkOversizedToolResults(messages, maxChars);
+  const paired = fixToolCallPairing(shrunk.messages);
+  const healedCount = shrunk.healedCount + paired.droppedAssistantCalls + paired.droppedStrayTools;
+  return { messages: paired.messages, healedCount, healedFrom: shrunk.healedFrom };
+}
+function stampMissingReasoningForThinkingMode(messages, model) {
+  if (!isThinkingModeModel(model)) {
+    return { messages, stampedCount: 0 };
+  }
+  let stampedCount = 0;
+  const out = messages.map((msg) => {
+    if (msg.role !== "assistant") return msg;
+    if (Object.hasOwn(msg, "reasoning_content")) return msg;
+    stampedCount += 1;
+    return { ...msg, reasoning_content: "" };
+  });
+  return { messages: out, stampedCount };
+}
+function healLoadedMessagesByTokens(messages, maxTokens) {
+  const shrunk = shrinkOversizedToolResultsByTokens(messages, maxTokens);
+  const paired = fixToolCallPairing(shrunk.messages);
+  const healedCount = shrunk.healedCount + paired.droppedAssistantCalls + paired.droppedStrayTools;
+  return {
+    messages: paired.messages,
+    healedCount,
+    tokensSaved: shrunk.tokensSaved,
+    charsSaved: shrunk.charsSaved
+  };
+}
+
+// src/loop/hook-events.ts
+function safeParseToolArgs(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function* hookWarnings(outcomes, turn) {
+  for (const o of outcomes) {
+    if (o.decision === "pass") continue;
+    yield { turn, role: "warning", content: formatHookOutcomeMessage(o) };
+  }
+}
+
+// src/loop/turn-failure-tracker.ts
+var FAILURE_ESCALATION_THRESHOLD = 3;
+var TurnFailureTracker = class {
+  count = 0;
+  types = {};
+  reset() {
+    this.count = 0;
+    this.types = {};
+  }
+  /** True ONLY on the call where the count crosses FAILURE_ESCALATION_THRESHOLD. */
+  noteAndCrossedThreshold(resultJson, repair) {
+    const before = this.count;
+    const bump = (kind, by = 1) => {
+      this.count += by;
+      this.types[kind] = (this.types[kind] ?? 0) + by;
+    };
+    if (resultJson.includes('"error"') && resultJson.includes("search text not found")) {
+      bump("search-mismatch");
+    }
+    if (repair) {
+      if (repair.scavenged > 0) bump("scavenged", repair.scavenged);
+      if (repair.truncationsFixed > 0) bump("truncated", repair.truncationsFixed);
+      if (repair.stormsBroken > 0) bump("repeat-loop", repair.stormsBroken);
+    }
+    return before < FAILURE_ESCALATION_THRESHOLD && this.count >= FAILURE_ESCALATION_THRESHOLD;
+  }
+  formatBreakdown() {
+    const parts = Object.entries(this.types).filter(([, n]) => n > 0).map(([kind, n]) => `${n}\xD7 ${kind}`);
+    return parts.length > 0 ? parts.join(", ") : `${this.count} repair/error signal(s)`;
+  }
+};
+
+// src/memory/runtime.ts
+import { createHash } from "crypto";
+var ImmutablePrefix = class {
+  system;
+  /** Each `addTool` costs one cache-miss turn — DeepSeek's prefix cache is keyed by full tool list. */
+  _toolSpecs;
+  fewShots;
+  /** Invalidated only via `addTool`; bypassing it leaves cache stale → fingerprint diverges from sent prefix. */
+  _fingerprintCache = null;
+  constructor(opts) {
+    this.system = opts.system;
+    this._toolSpecs = [...opts.toolSpecs ?? []];
+    this.fewShots = Object.freeze([...opts.fewShots ?? []]);
+  }
+  get toolSpecs() {
+    return this._toolSpecs;
+  }
+  toMessages() {
+    return [{ role: "system", content: this.system }, ...this.fewShots.map((m) => ({ ...m }))];
+  }
+  tools() {
+    return this._toolSpecs.map((t) => structuredClone(t));
+  }
+  addTool(spec) {
+    const name = spec.function?.name;
+    if (!name) return false;
+    if (this._toolSpecs.some((t) => t.function?.name === name)) return false;
+    this._toolSpecs.push(spec);
+    this._fingerprintCache = null;
+    return true;
+  }
+  /** Mirror of addTool for MCP hot-unbridge. Same cache-miss cost — prefix changes shape. */
+  removeTool(name) {
+    const idx = this._toolSpecs.findIndex((t) => t.function?.name === name);
+    if (idx < 0) return false;
+    this._toolSpecs.splice(idx, 1);
+    this._fingerprintCache = null;
+    return true;
+  }
+  get fingerprint() {
+    if (this._fingerprintCache !== null) return this._fingerprintCache;
+    this._fingerprintCache = this.computeFingerprint();
+    return this._fingerprintCache;
+  }
+  /** Dev/test only — throws on cache drift, which always means a non-`addTool` mutation slipped in. */
+  verifyFingerprint() {
+    const fresh = this.computeFingerprint();
+    if (this._fingerprintCache !== null && this._fingerprintCache !== fresh) {
+      throw new Error(
+        `ImmutablePrefix fingerprint drift: cached=${this._fingerprintCache}, fresh=${fresh}. A mutation path bypassed addTool's cache invalidation \u2014 DeepSeek will see prefix churn that the TUI / transcript log don't know about.`
+      );
+    }
+    this._fingerprintCache = fresh;
+    return fresh;
+  }
+  computeFingerprint() {
+    const blob = JSON.stringify({
+      system: this.system,
+      tools: this._toolSpecs,
+      shots: this.fewShots
+    });
+    return createHash("sha256").update(blob).digest("hex").slice(0, 16);
+  }
+};
+var AppendOnlyLog = class {
+  _entries = [];
+  append(message) {
+    if (!message || typeof message !== "object" || !("role" in message)) {
+      throw new Error(`invalid log entry: ${JSON.stringify(message)}`);
+    }
+    this._entries.push(message);
+  }
+  extend(messages) {
+    for (const m of messages) this.append(m);
+  }
+  /** The one append-only-breaking path — reserved for `/compact` + recovery. Use `append()` otherwise. */
+  compactInPlace(replacement) {
+    this._entries = [...replacement];
+  }
+  get entries() {
+    return this._entries;
+  }
+  toMessages() {
+    return this._entries.map((e) => ({ ...e }));
+  }
+  get length() {
+    return this._entries.length;
+  }
+};
+var VolatileScratch = class {
+  reasoning = null;
+  planState = null;
+  notes = [];
+  reset() {
+    this.reasoning = null;
+    this.planState = null;
+    this.notes = [];
+  }
+};
+
+// src/repair/scavenge.ts
+var MAX_SCAVENGE_INPUT = 100 * 1024;
+function scavengeToolCalls(reasoningContent, opts) {
+  if (!reasoningContent) return { calls: [], notes: [] };
+  if (reasoningContent.length > MAX_SCAVENGE_INPUT) {
+    return {
+      calls: [],
+      notes: [`scavenge skipped: reasoning_content too large (${reasoningContent.length} chars)`]
+    };
+  }
+  const max = opts.maxCalls ?? 4;
+  const notes = [];
+  const out = [];
+  for (const invoke of iterateDsmlInvokes(reasoningContent)) {
+    if (out.length >= max) break;
+    if (!opts.allowedNames.has(invoke.name)) continue;
+    out.push({
+      function: {
+        name: invoke.name,
+        arguments: JSON.stringify(invoke.args)
+      }
+    });
+    notes.push(`scavenged DSML call: ${invoke.name}`);
+  }
+  const nonDsml = stripDsmlBlocks(reasoningContent);
+  for (const candidate of iterateJsonObjects(nonDsml)) {
+    if (out.length >= max) break;
+    const call = coerceToToolCall(candidate, opts.allowedNames);
+    if (call) {
+      out.push(call);
+      notes.push(`scavenged call: ${call.function.name}`);
+    }
+  }
+  return { calls: out, notes };
+}
+function stripDsmlBlocks(text) {
+  let out = text;
+  out = out.replace(/<[｜|]DSML[｜|]function_calls>[\s\S]*?<\/?[｜|]DSML[｜|]function_calls>/g, "");
+  out = out.replace(/<[｜|]DSML[｜|]invoke\s+[^>]*>[\s\S]*?<\/[｜|]DSML[｜|]invoke>/g, "");
+  return out;
+}
+function* iterateDsmlInvokes(text) {
+  const INVOKE_RE = /<[｜|]DSML[｜|]invoke\s+name="([^"]+)">([\s\S]*?)<\/[｜|]DSML[｜|]invoke>/g;
+  for (const match of text.matchAll(INVOKE_RE)) {
+    const name = match[1];
+    const body = match[2];
+    if (!name || body === void 0) continue;
+    yield { name, args: parseDsmlParameters(body) };
+  }
+}
+function parseDsmlParameters(body) {
+  const PARAM_RE = /<[｜|]DSML[｜|]parameter\s+name="([^"]+)"(?:\s+string="(true|false)")?\s*>([\s\S]*?)<\/[｜|]DSML[｜|]parameter>/g;
+  const args = {};
+  for (const m of body.matchAll(PARAM_RE)) {
+    const key = m[1];
+    const stringFlag = m[2];
+    const raw = (m[3] ?? "").trim();
+    if (!key) continue;
+    if (stringFlag === "false") {
+      try {
+        args[key] = JSON.parse(raw);
+        continue;
+      } catch {
+      }
+    }
+    args[key] = raw;
+  }
+  return args;
+}
+function* iterateJsonObjects(text) {
   for (let i = 0; i < text.length; i++) {
     if (text[i] !== "{") continue;
     let depth = 0;
@@ -2020,11 +2416,7 @@ function signature(call) {
 }
 
 // src/loop.ts
-var FAILURE_ESCALATION_THRESHOLD = 3;
 var ESCALATION_MODEL = "deepseek-v4-pro";
-var NEEDS_PRO_MARKER_PREFIX = "<<<NEEDS_PRO";
-var NEEDS_PRO_MARKER_RE = /^<<<NEEDS_PRO(?::\s*([^>]*))?>>>/;
-var NEEDS_PRO_BUFFER_CHARS = 256;
 var CacheFirstLoop = class {
   client;
   prefix;
@@ -2060,11 +2452,13 @@ var CacheFirstLoop = class {
   _turnAbort = new AbortController();
   _proArmedForNextTurn = false;
   _escalateThisTurn = false;
-  _turnFailureCount = 0;
-  _turnFailureTypes = {};
+  _turnFailures = new TurnFailureTracker();
   _turnSelfCorrected = false;
   _foldedThisTurn = false;
   context;
+  get currentTurn() {
+    return this._turn;
+  }
   constructor(opts) {
     this.client = opts.client;
     this.prefix = opts.prefix;
@@ -2233,60 +2627,18 @@ var CacheFirstLoop = class {
     return this._proArmedForNextTurn;
   }
   /** UI surface — true while the current turn is running on pro (armed or auto-escalated). */
-  get escalatedThisTurn() {
-    return this._escalateThisTurn;
-  }
-  modelForCurrentCall() {
-    return this._escalateThisTurn ? ESCALATION_MODEL : this.model;
-  }
-  /** Anchored to lead — mid-text matches are normal content (user asking about the marker). */
-  parseEscalationMarker(content) {
-    const m = NEEDS_PRO_MARKER_RE.exec(content.trimStart());
-    if (!m) return { matched: false };
-    const reason = m[1]?.trim();
-    return { matched: true, reason: reason || void 0 };
-  }
-  /** Convenience boolean — same gate the streaming path used to call. */
-  isEscalationRequest(content) {
-    return this.parseEscalationMarker(content).matched;
-  }
-  /** Drives streaming flush — while plausibly partial, keep accumulating; else flush. */
-  looksLikePartialEscalationMarker(buf) {
-    const t = buf.trimStart();
-    if (t.length === 0) return true;
-    if (t.length <= NEEDS_PRO_MARKER_PREFIX.length) {
-      return NEEDS_PRO_MARKER_PREFIX.startsWith(t);
-    }
-    if (!t.startsWith(NEEDS_PRO_MARKER_PREFIX)) return false;
-    const rest = t.slice(NEEDS_PRO_MARKER_PREFIX.length);
-    if (rest[0] !== ">" && rest[0] !== ":") return false;
-    return true;
-  }
-  /** Returns true ONLY on the tipping call — caller surfaces a one-shot warning. */
-  noteToolFailureSignal(resultJson, repair) {
-    let bumped = false;
-    const bump = (kind, by = 1) => {
-      this._turnFailureCount += by;
-      this._turnFailureTypes[kind] = (this._turnFailureTypes[kind] ?? 0) + by;
-      bumped = true;
-    };
-    if (resultJson.includes('"error"') && resultJson.includes("search text not found")) {
-      bump("search-mismatch");
-    }
-    if (repair) {
-      if (repair.scavenged > 0) bump("scavenged", repair.scavenged);
-      if (repair.truncationsFixed > 0) bump("truncated", repair.truncationsFixed);
-      if (repair.stormsBroken > 0) bump("repeat-loop", repair.stormsBroken);
-    }
-    if (bumped && !this._escalateThisTurn && this.autoEscalate && this._turnFailureCount >= FAILURE_ESCALATION_THRESHOLD) {
-      this._escalateThisTurn = true;
-      return true;
-    }
-    return false;
+  get escalatedThisTurn() {
+    return this._escalateThisTurn;
+  }
+  modelForCurrentCall() {
+    return this._escalateThisTurn ? ESCALATION_MODEL : this.model;
   }
-  formatFailureBreakdown() {
-    const parts = Object.entries(this._turnFailureTypes).filter(([, n]) => n > 0).map(([kind, n]) => `${n}\xD7 ${kind}`);
-    return parts.length > 0 ? parts.join(", ") : `${this._turnFailureCount} repair/error signal(s)`;
+  /** Returns true ONLY on the tipping call — caller surfaces a one-shot warning. */
+  noteToolFailureSignal(resultJson, repair) {
+    if (!this._turnFailures.noteAndCrossedThreshold(resultJson, repair)) return false;
+    if (this._escalateThisTurn || !this.autoEscalate) return false;
+    this._escalateThisTurn = true;
+    return true;
   }
   buildMessages(pendingUser) {
     const healed = healLoadedMessages(this.log.toMessages(), DEFAULT_MAX_RESULT_CHARS);
@@ -2344,8 +2696,7 @@ var CacheFirstLoop = class {
     this._turn++;
     this.scratch.reset();
     this.repair.resetStorm();
-    this._turnFailureCount = 0;
-    this._turnFailureTypes = {};
+    this._turnFailures.reset();
     this._turnSelfCorrected = false;
     this._escalateThisTurn = false;
     this._foldedThisTurn = false;
@@ -2378,7 +2729,7 @@ var CacheFirstLoop = class {
           content: `aborted at iter ${iter}/${this.maxToolIters} \u2014 stopped without producing a summary (press \u2191 + Enter or /retry to resume)`
         };
         const stoppedMsg = "[aborted by user (Esc) \u2014 no summary produced. Ask again or /retry when ready; prior tool output is still in the log.]";
-        this.appendAndPersist(this.syntheticAssistantMessage(stoppedMsg));
+        this.appendAndPersist(buildSyntheticAssistantMessage(stoppedMsg, this.model));
         yield {
           turn: this._turn,
           role: "assistant_final",
@@ -2540,10 +2891,10 @@ var CacheFirstLoop = class {
               assistantContent += chunk.contentDelta;
               if (bufferForEscalation && !escalationBufFlushed) {
                 escalationBuf += chunk.contentDelta;
-                if (this.isEscalationRequest(escalationBuf)) {
+                if (isEscalationRequest(escalationBuf)) {
                   break;
                 }
-                if (escalationBuf.length >= NEEDS_PRO_BUFFER_CHARS || !this.looksLikePartialEscalationMarker(escalationBuf)) {
+                if (escalationBuf.length >= NEEDS_PRO_BUFFER_CHARS || !looksLikePartialEscalationMarker(escalationBuf)) {
                   escalationBufFlushed = true;
                   yield {
                     turn: this._turn,
@@ -2600,7 +2951,7 @@ var CacheFirstLoop = class {
           }
           toolCalls = [...callBuf.values()];
           if (bufferForEscalation && !escalationBufFlushed && escalationBuf.length > 0) {
-            if (!this.isEscalationRequest(escalationBuf)) {
+            if (!isEscalationRequest(escalationBuf)) {
               yield {
                 turn: this._turn,
                 role: "assistant_delta",
@@ -2637,8 +2988,8 @@ var CacheFirstLoop = class {
         };
         return;
       }
-      if (this.autoEscalate && this.modelForCurrentCall() !== ESCALATION_MODEL && this.isEscalationRequest(assistantContent)) {
-        const { reason } = this.parseEscalationMarker(assistantContent);
+      if (this.autoEscalate && this.modelForCurrentCall() !== ESCALATION_MODEL && isEscalationRequest(assistantContent)) {
+        const { reason } = parseEscalationMarker(assistantContent);
         this._escalateThisTurn = true;
         const reasonSuffix = reason ? ` \u2014 ${reason}` : "";
         yield {
@@ -2679,7 +3030,7 @@ var CacheFirstLoop = class {
         assistantContent || null
       );
       this.appendAndPersist(
-        this.assistantMessage(
+        buildAssistantMessage(
           assistantContent,
           repairedCalls,
           this.modelForCurrentCall(),
@@ -2699,14 +3050,14 @@ var CacheFirstLoop = class {
         yield {
           turn: this._turn,
           role: "warning",
-          content: `\u21E7 auto-escalating to ${ESCALATION_MODEL} for the rest of this turn \u2014 flash hit ${this.formatFailureBreakdown()}. Next turn falls back to ${this.model} unless /pro is armed.`
+          content: `\u21E7 auto-escalating to ${ESCALATION_MODEL} for the rest of this turn \u2014 flash hit ${this._turnFailures.formatBreakdown()}. Next turn falls back to ${this.model} unless /pro is armed.`
         };
       }
       const allSuppressed = report.stormsBroken > 0 && repairedCalls.length === 0 && toolCalls.length > 0;
       if (allSuppressed && !this._turnSelfCorrected) {
         this._turnSelfCorrected = true;
         this.replaceTailAssistantMessage(
-          this.assistantMessage(
+          buildAssistantMessage(
             assistantContent,
             toolCalls,
             this.modelForCurrentCall(),
@@ -2739,7 +3090,7 @@ var CacheFirstLoop = class {
       }
       if (repairedCalls.length === 0) {
         if (allSuppressed) {
-          yield* this.forceSummaryAfterIterLimit({ reason: "stuck" });
+          yield* forceSummaryAfterIterLimit(this.summaryContext(), { reason: "stuck" });
           return;
         }
         yield { turn: this._turn, role: "done", content: assistantContent };
@@ -2758,384 +3109,122 @@ var CacheFirstLoop = class {
         };
         const result = await this.compactHistory({ keepRecentTokens: decision.tailBudget });
         if (result.folded) {
-          yield {
-            turn: this._turn,
-            role: "warning",
-            content: `context ${before.toLocaleString()}/${ctxMax.toLocaleString()} (${Math.round(
-              before / ctxMax * 100
-            )}%) \u2014 ${decision.aggressive ? "aggressively folded" : "folded"} ${result.beforeMessages} messages \u2192 ${result.afterMessages} (summary ${result.summaryChars} chars). Continuing.`
-          };
-        }
-      } else if (decision.kind === "exit-with-summary") {
-        const before = decision.promptTokens;
-        const ctxMax = decision.ctxMax;
-        yield {
-          turn: this._turn,
-          role: "warning",
-          content: `context ${before.toLocaleString()}/${ctxMax.toLocaleString()} (${Math.round(
-            before / ctxMax * 100
-          )}%) \u2014 forcing summary from what was gathered. Run /compact, /clear, or /new to reset.`
-        };
-        this.context.trimTrailingToolCalls();
-        yield* this.forceSummaryAfterIterLimit({ reason: "context-guard" });
-        return;
-      }
-      for (const call of repairedCalls) {
-        const name = call.function?.name ?? "";
-        const args = call.function?.arguments ?? "{}";
-        yield {
-          turn: this._turn,
-          role: "tool_start",
-          content: "",
-          toolName: name,
-          toolArgs: args
-        };
-        const parsedArgs = safeParseToolArgs(args);
-        const preReport = await runHooks({
-          hooks: this.hooks,
-          payload: {
-            event: "PreToolUse",
-            cwd: this.hookCwd,
-            toolName: name,
-            toolArgs: parsedArgs
-          }
-        });
-        for (const w of hookWarnings(preReport.outcomes, this._turn)) yield w;
-        let result;
-        if (preReport.blocked) {
-          const blocking = preReport.outcomes[preReport.outcomes.length - 1];
-          const reason = (blocking?.stderr || blocking?.stdout || "blocked by PreToolUse hook").trim();
-          result = `[hook block] ${blocking?.hook.command ?? "<unknown>"}
-${reason}`;
-        } else {
-          result = await this.tools.dispatch(name, args, {
-            signal,
-            maxResultTokens: DEFAULT_MAX_RESULT_TOKENS,
-            confirmationGate: this.confirmationGate
-          });
-          const postReport = await runHooks({
-            hooks: this.hooks,
-            payload: {
-              event: "PostToolUse",
-              cwd: this.hookCwd,
-              toolName: name,
-              toolArgs: parsedArgs,
-              toolResult: result
-            }
-          });
-          for (const w of hookWarnings(postReport.outcomes, this._turn)) yield w;
-        }
-        this.appendAndPersist({
-          role: "tool",
-          tool_call_id: call.id ?? "",
-          name,
-          content: result
-        });
-        if (this.noteToolFailureSignal(result)) {
-          yield {
-            turn: this._turn,
-            role: "warning",
-            content: `\u21E7 auto-escalating to ${ESCALATION_MODEL} for the rest of this turn \u2014 flash hit ${this.formatFailureBreakdown()}. Next turn falls back to ${this.model} unless /pro is armed.`
-          };
-        }
-        yield {
-          turn: this._turn,
-          role: "tool",
-          content: result,
-          toolName: name,
-          toolArgs: args
-        };
-      }
-    }
-    yield* this.forceSummaryAfterIterLimit({ reason: "budget" });
-  }
-  async *forceSummaryAfterIterLimit(opts = { reason: "budget" }) {
-    try {
-      yield {
-        turn: this._turn,
-        role: "status",
-        content: "summarizing what was gathered\u2026"
-      };
-      const messages = this.buildMessages(null);
-      messages.push({
-        role: "user",
-        content: "I'm out of tool-call budget for this turn. Summarize in plain prose what you learned from the tool results above. Do NOT emit any tool calls, function-call markup, DSML invocations, or SEARCH/REPLACE edit blocks \u2014 they will be silently discarded. Just plain text."
-      });
-      const summaryModel = "deepseek-v4-flash";
-      const summaryEffort = "high";
-      const resp = await this.client.chat({
-        model: summaryModel,
-        messages,
-        // no tools → model is forced to answer in text
-        signal: this._turnAbort.signal,
-        thinking: thinkingModeForModel(summaryModel),
-        reasoningEffort: summaryEffort
-      });
-      const rawContent = resp.content?.trim() ?? "";
-      const cleaned = stripHallucinatedToolMarkup(rawContent);
-      const summary = cleaned || "(model emitted fake tool-call markup instead of a prose summary \u2014 try /retry with a narrower question, or /think to inspect R1's reasoning)";
-      const reasonPrefix = reasonPrefixFor(opts.reason, this.maxToolIters);
-      const annotated = `${reasonPrefix}
-
-${summary}`;
-      const summaryStats = this.stats.record(this._turn, summaryModel, resp.usage ?? new Usage());
-      this.appendAndPersist(
-        this.assistantMessage(summary, [], summaryModel, resp.reasoningContent)
-      );
-      yield {
-        turn: this._turn,
-        role: "assistant_final",
-        content: annotated,
-        stats: summaryStats,
-        forcedSummary: true
-      };
-      yield { turn: this._turn, role: "done", content: summary };
-    } catch (err) {
-      const label = errorLabelFor(opts.reason, this.maxToolIters);
-      yield {
-        turn: this._turn,
-        role: "error",
-        content: "",
-        error: `${label} and the fallback summary call failed: ${err.message}. Run /clear and retry with a narrower question, or raise --max-tool-iters.`
-      };
-      yield { turn: this._turn, role: "done", content: "" };
-    }
-  }
-  async run(userInput, onEvent) {
-    let final = "";
-    for await (const ev of this.step(userInput)) {
-      onEvent?.(ev);
-      if (ev.role === "assistant_final") final = ev.content;
-      if (ev.role === "done") break;
-    }
-    return final;
-  }
-  /** Thinking-mode producer ⇒ reasoning_content MUST be set (even ""), or next call 400s. */
-  assistantMessage(content, toolCalls, producingModel, reasoningContent) {
-    const msg = { role: "assistant", content };
-    if (toolCalls.length > 0) msg.tool_calls = toolCalls;
-    if (isThinkingModeModel(producingModel) || reasoningContent && reasoningContent.length > 0) {
-      msg.reasoning_content = reasoningContent ?? "";
-    }
-    return msg;
-  }
-  /** Abort notices etc — uses this.model as stand-in producer for the thinking-mode stamp. */
-  syntheticAssistantMessage(content) {
-    return this.assistantMessage(content, [], this.model, "");
-  }
-};
-function isThinkingModeModel(model) {
-  if (model.includes("reasoner")) return true;
-  if (model === "deepseek-v4-flash" || model === "deepseek-v4-pro") return true;
-  return false;
-}
-function thinkingModeForModel(model) {
-  if (model === "deepseek-chat") return "disabled";
-  if (model.includes("reasoner")) return "enabled";
-  if (model === "deepseek-v4-flash" || model === "deepseek-v4-pro") return "enabled";
-  return void 0;
-}
-function stripHallucinatedToolMarkup(s) {
-  let out = s;
-  out = out.replace(/<｜DSML｜function_calls>[\s\S]*?<\/?｜DSML｜function_calls>/g, "");
-  out = out.replace(/<\|DSML\|function_calls>[\s\S]*?<\/?\|DSML\|function_calls>/g, "");
-  out = out.replace(/<function_calls>[\s\S]*?<\/function_calls>/g, "");
-  out = out.replace(/<｜DSML｜[\s\S]*$/g, "");
-  return out.trim();
-}
-function parsePositiveIntEnv(raw) {
-  if (!raw) return void 0;
-  const n = Number.parseInt(raw, 10);
-  return Number.isFinite(n) && n > 0 ? n : void 0;
-}
-function safeParseToolArgs(raw) {
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return raw;
-  }
-}
-function looksLikeCompleteJson(s) {
-  if (!s || !s.trim()) return false;
-  try {
-    JSON.parse(s);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function* hookWarnings(outcomes, turn) {
-  for (const o of outcomes) {
-    if (o.decision === "pass") continue;
-    yield { turn, role: "warning", content: formatHookOutcomeMessage(o) };
-  }
-}
-function reasonPrefixFor(reason, iterCap) {
-  if (reason === "aborted") return "[aborted by user (Esc) \u2014 summarizing what I found so far]";
-  if (reason === "context-guard") {
-    return "[context budget running low \u2014 summarizing before the next call would overflow]";
-  }
-  if (reason === "stuck") {
-    return "[stuck on a repeated tool call \u2014 explaining what was tried and what's blocking progress]";
-  }
-  return `[tool-call budget (${iterCap}) reached \u2014 forcing summary from what I found]`;
-}
-function errorLabelFor(reason, iterCap) {
-  if (reason === "aborted") return "aborted by user";
-  if (reason === "context-guard") return "context-guard triggered (prompt > 80% of window)";
-  if (reason === "stuck") return "stuck (repeated tool call suppressed by storm-breaker)";
-  return `tool-call budget (${iterCap}) reached`;
-}
-function summarizeBranch(chosen, samples) {
-  return {
-    budget: samples.length,
-    chosenIndex: chosen.index,
-    uncertainties: samples.map((s) => s.planState.uncertainties.length),
-    temperatures: samples.map((s) => s.temperature)
-  };
-}
-function shrinkOversizedToolResults(messages, maxChars) {
-  let healedCount = 0;
-  let healedFrom = 0;
-  const out = messages.map((msg) => {
-    if (msg.role !== "tool") return msg;
-    const content = typeof msg.content === "string" ? msg.content : "";
-    if (content.length <= maxChars) return msg;
-    healedCount += 1;
-    healedFrom += content.length;
-    return { ...msg, content: truncateForModel(content, maxChars) };
-  });
-  return { messages: out, healedCount, healedFrom };
-}
-function shrinkOversizedToolResultsByTokens(messages, maxTokens) {
-  let healedCount = 0;
-  let tokensSaved = 0;
-  let charsSaved = 0;
-  const out = messages.map((msg) => {
-    if (msg.role !== "tool") return msg;
-    const content = typeof msg.content === "string" ? msg.content : "";
-    if (content.length <= maxTokens) return msg;
-    const beforeTokens = countTokens(content);
-    if (beforeTokens <= maxTokens) return msg;
-    const truncated = truncateForModelByTokens(content, maxTokens);
-    const afterTokens = countTokens(truncated);
-    healedCount += 1;
-    tokensSaved += Math.max(0, beforeTokens - afterTokens);
-    charsSaved += Math.max(0, content.length - truncated.length);
-    return { ...msg, content: truncated };
-  });
-  return { messages: out, healedCount, tokensSaved, charsSaved };
-}
-function fixToolCallPairing(messages) {
-  const out = [];
-  let droppedAssistantCalls = 0;
-  let droppedStrayTools = 0;
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i];
-    if (msg.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
-      const needed = /* @__PURE__ */ new Set();
-      for (const call of msg.tool_calls) {
-        if (call?.id) needed.add(call.id);
-      }
-      const candidates = [];
-      let j = i + 1;
-      while (j < messages.length && needed.size > 0) {
-        const nxt = messages[j];
-        if (nxt.role !== "tool") break;
-        const id = nxt.tool_call_id ?? "";
-        if (!needed.has(id)) break;
-        needed.delete(id);
-        candidates.push(nxt);
-        j++;
+          yield {
+            turn: this._turn,
+            role: "warning",
+            content: `context ${before.toLocaleString()}/${ctxMax.toLocaleString()} (${Math.round(
+              before / ctxMax * 100
+            )}%) \u2014 ${decision.aggressive ? "aggressively folded" : "folded"} ${result.beforeMessages} messages \u2192 ${result.afterMessages} (summary ${result.summaryChars} chars). Continuing.`
+          };
+        }
+      } else if (decision.kind === "exit-with-summary") {
+        const before = decision.promptTokens;
+        const ctxMax = decision.ctxMax;
+        yield {
+          turn: this._turn,
+          role: "warning",
+          content: `context ${before.toLocaleString()}/${ctxMax.toLocaleString()} (${Math.round(
+            before / ctxMax * 100
+          )}%) \u2014 forcing summary from what was gathered. Run /compact, /clear, or /new to reset.`
+        };
+        this.context.trimTrailingToolCalls();
+        yield* forceSummaryAfterIterLimit(this.summaryContext(), { reason: "context-guard" });
+        return;
       }
-      if (needed.size === 0) {
-        out.push(msg);
-        for (const r of candidates) out.push(r);
-        i = j - 1;
-      } else {
-        droppedAssistantCalls += 1;
-        droppedStrayTools += candidates.length;
-        i = j - 1;
+      for (const call of repairedCalls) {
+        const name = call.function?.name ?? "";
+        const args = call.function?.arguments ?? "{}";
+        yield {
+          turn: this._turn,
+          role: "tool_start",
+          content: "",
+          toolName: name,
+          toolArgs: args
+        };
+        const parsedArgs = safeParseToolArgs(args);
+        const preReport = await runHooks({
+          hooks: this.hooks,
+          payload: {
+            event: "PreToolUse",
+            cwd: this.hookCwd,
+            toolName: name,
+            toolArgs: parsedArgs
+          }
+        });
+        for (const w of hookWarnings(preReport.outcomes, this._turn)) yield w;
+        let result;
+        if (preReport.blocked) {
+          const blocking = preReport.outcomes[preReport.outcomes.length - 1];
+          const reason = (blocking?.stderr || blocking?.stdout || "blocked by PreToolUse hook").trim();
+          result = `[hook block] ${blocking?.hook.command ?? "<unknown>"}
+${reason}`;
+        } else {
+          result = await this.tools.dispatch(name, args, {
+            signal,
+            maxResultTokens: DEFAULT_MAX_RESULT_TOKENS,
+            confirmationGate: this.confirmationGate
+          });
+          const postReport = await runHooks({
+            hooks: this.hooks,
+            payload: {
+              event: "PostToolUse",
+              cwd: this.hookCwd,
+              toolName: name,
+              toolArgs: parsedArgs,
+              toolResult: result
+            }
+          });
+          for (const w of hookWarnings(postReport.outcomes, this._turn)) yield w;
+        }
+        this.appendAndPersist({
+          role: "tool",
+          tool_call_id: call.id ?? "",
+          name,
+          content: result
+        });
+        if (this.noteToolFailureSignal(result)) {
+          yield {
+            turn: this._turn,
+            role: "warning",
+            content: `\u21E7 auto-escalating to ${ESCALATION_MODEL} for the rest of this turn \u2014 flash hit ${this._turnFailures.formatBreakdown()}. Next turn falls back to ${this.model} unless /pro is armed.`
+          };
+        }
+        yield {
+          turn: this._turn,
+          role: "tool",
+          content: result,
+          toolName: name,
+          toolArgs: args
+        };
       }
-      continue;
-    }
-    if (msg.role === "tool") {
-      droppedStrayTools += 1;
-      continue;
     }
-    out.push(msg);
-  }
-  return { messages: out, droppedAssistantCalls, droppedStrayTools };
-}
-function healLoadedMessages(messages, maxChars) {
-  const shrunk = shrinkOversizedToolResults(messages, maxChars);
-  const paired = fixToolCallPairing(shrunk.messages);
-  const healedCount = shrunk.healedCount + paired.droppedAssistantCalls + paired.droppedStrayTools;
-  return { messages: paired.messages, healedCount, healedFrom: shrunk.healedFrom };
-}
-function stampMissingReasoningForThinkingMode(messages, model) {
-  if (!isThinkingModeModel(model)) {
-    return { messages, stampedCount: 0 };
-  }
-  let stampedCount = 0;
-  const out = messages.map((msg) => {
-    if (msg.role !== "assistant") return msg;
-    if (Object.hasOwn(msg, "reasoning_content")) return msg;
-    stampedCount += 1;
-    return { ...msg, reasoning_content: "" };
-  });
-  return { messages: out, stampedCount };
-}
-function healLoadedMessagesByTokens(messages, maxTokens) {
-  const shrunk = shrinkOversizedToolResultsByTokens(messages, maxTokens);
-  const paired = fixToolCallPairing(shrunk.messages);
-  const healedCount = shrunk.healedCount + paired.droppedAssistantCalls + paired.droppedStrayTools;
-  return {
-    messages: paired.messages,
-    healedCount,
-    tokensSaved: shrunk.tokensSaved,
-    charsSaved: shrunk.charsSaved
-  };
-}
-function formatLoopError(err) {
-  const msg = err.message ?? "";
-  if (msg.includes("maximum context length")) {
-    const reqMatch = msg.match(/requested\s+(\d+)\s+tokens/);
-    const requested = reqMatch ? `${Number(reqMatch[1]).toLocaleString()} tokens` : "too many tokens";
-    return `Context overflow (DeepSeek 400): session history is ${requested}, past the model's prompt limit (V4: 1M tokens; legacy chat/reasoner: 131k). Usually a single tool result grew too big. Reasonix caps new tool results at 8k tokens and auto-heals oversized history on session load \u2014 a restart often clears it. If it still overflows, run /forget (delete the session) or /clear (drop the displayed history) to start fresh.`;
-  }
-  const m = /^DeepSeek (\d{3}):\s*([\s\S]*)$/.exec(msg);
-  if (!m) return msg;
-  const status = m[1] ?? "";
-  const body = m[2] ?? "";
-  const inner = extractDeepSeekErrorMessage(body);
-  if (status === "401") {
-    return `Authentication failed (DeepSeek 401): ${inner}. Your API key is rejected. Fix with \`reasonix setup\` or \`export DEEPSEEK_API_KEY=sk-...\`. Get one at https://platform.deepseek.com/api_keys.`;
-  }
-  if (status === "402") {
-    return `Out of balance (DeepSeek 402): ${inner}. Top up at https://platform.deepseek.com/top_up \u2014 the panel header shows your balance once it's non-zero.`;
+    yield* forceSummaryAfterIterLimit(this.summaryContext(), { reason: "budget" });
   }
-  if (status === "422") {
-    return `Invalid parameter (DeepSeek 422): ${inner}`;
-  }
-  if (status === "400") {
-    return `Bad request (DeepSeek 400): ${inner}`;
+  summaryContext() {
+    return {
+      client: this.client,
+      signal: this._turnAbort.signal,
+      buildMessages: () => this.buildMessages(null),
+      appendAndPersist: (m) => this.appendAndPersist(m),
+      recordStats: (model, usage) => this.stats.record(this._turn, model, usage),
+      turn: this._turn,
+      maxToolIters: this.maxToolIters
+    };
   }
-  return msg;
-}
-function extractDeepSeekErrorMessage(body) {
-  const trimmed = body.trim();
-  if (!trimmed) return "(no message)";
-  try {
-    const parsed = JSON.parse(trimmed);
-    if (parsed && typeof parsed === "object") {
-      const obj = parsed;
-      if (obj.error && typeof obj.error.message === "string") return obj.error.message;
-      if (typeof obj.message === "string") return obj.message;
+  async run(userInput, onEvent) {
+    let final = "";
+    for await (const ev of this.step(userInput)) {
+      onEvent?.(ev);
+      if (ev.role === "assistant_final") final = ev.content;
+      if (ev.role === "done") break;
     }
-  } catch {
+    return final;
   }
-  return trimmed;
+};
+function parsePositiveIntEnv(raw) {
+  if (!raw) return void 0;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : void 0;
 }
 
 // src/at-mentions.ts
@@ -3356,17 +3445,18 @@ function rankPickerCandidates(files, query, limitOrOpts) {
 var AT_MENTION_PATTERN = /(?<=^|\s)@([a-zA-Z0-9_./\\-]+)/g;
 function expandAtMentions(text, rootDir, opts = {}) {
   const maxBytes = opts.maxBytes ?? DEFAULT_AT_MENTION_MAX_BYTES;
-  const fs2 = opts.fs ?? defaultFs;
+  const fs4 = opts.fs ?? defaultFs;
   const root = resolve(rootDir);
   const seen = /* @__PURE__ */ new Map();
   const expansions = [];
   for (const match of text.matchAll(AT_MENTION_PATTERN)) {
     const rawPath = match[1] ?? "";
-    const cleaned = rawPath.replace(/\.+$/, "");
+    let cleaned = rawPath;
+    while (cleaned.endsWith(".")) cleaned = cleaned.slice(0, -1);
     if (!cleaned) continue;
     const token = `@${cleaned}`;
     if (seen.has(token)) continue;
-    const expansion = resolveMention(cleaned, root, maxBytes, fs2);
+    const expansion = resolveMention(cleaned, root, maxBytes, fs4);
     seen.set(token, expansion);
     expansions.push(expansion);
   }
@@ -3374,7 +3464,7 @@ function expandAtMentions(text, rootDir, opts = {}) {
   const blocks = [];
   for (const ex of expansions) {
     if (ex.ok) {
-      const content = readSafe(root, ex.path, fs2);
+      const content = readSafe(root, ex.path, fs4);
       blocks.push(`<file path="${ex.path}">
 ${content}
 </file>`);
@@ -3388,7 +3478,7 @@ ${content}
 ${blocks.join("\n\n")}`;
   return { text: augmented, expansions };
 }
-function resolveMention(rawPath, root, maxBytes, fs2) {
+function resolveMention(rawPath, root, maxBytes, fs4) {
   if (isAbsolute(rawPath)) {
     return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "escape" };
   }
@@ -3397,22 +3487,22 @@ function resolveMention(rawPath, root, maxBytes, fs2) {
   if (rel.startsWith("..") || isAbsolute(rel)) {
     return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "escape" };
   }
-  if (!fs2.exists(resolved)) {
+  if (!fs4.exists(resolved)) {
     return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "missing" };
   }
-  if (!fs2.isFile(resolved)) {
+  if (!fs4.isFile(resolved)) {
     return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "not-file" };
   }
-  const size = fs2.size(resolved);
+  const size = fs4.size(resolved);
   if (size > maxBytes) {
     return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "too-large", bytes: size };
   }
   return { token: `@${rawPath}`, path: rawPath, ok: true, bytes: size };
 }
-function readSafe(root, rawPath, fs2) {
+function readSafe(root, rawPath, fs4) {
   const resolved = resolve(root, rawPath);
   try {
-    return fs2.read(resolved);
+    return fs4.read(resolved);
   } catch {
     return "(read failed)";
   }
@@ -4161,8 +4251,8 @@ function applyMemoryStack(basePrompt, rootDir) {
 }
 
 // src/tools/filesystem.ts
-import { promises as fs } from "fs";
-import * as pathMod from "path";
+import { promises as fs3 } from "fs";
+import * as pathMod3 from "path";
 import picomatch2 from "picomatch";
 
 // src/index/config.ts
@@ -4250,6 +4340,214 @@ var DEFAULT_INDEX_EXCLUDES = {
 };
 var DEFAULT_MAX_FILE_BYTES = 256 * 1024;
 
+// src/tools/fs/edit.ts
+import { promises as fs } from "fs";
+import * as pathMod from "path";
+function displayRel(rootDir, full) {
+  return pathMod.relative(rootDir, full).replaceAll("\\", "/");
+}
+async function applyEdit(rootDir, abs, args) {
+  if (args.search.length === 0) {
+    throw new Error("edit_file: search cannot be empty");
+  }
+  const before = await fs.readFile(abs, "utf8");
+  const le = before.includes("\r\n") ? "\r\n" : "\n";
+  const adaptedSearch = args.search.replace(/\r?\n/g, le);
+  const adaptedReplace = args.replace.replace(/\r?\n/g, le);
+  const firstIdx = before.indexOf(adaptedSearch);
+  if (firstIdx < 0) {
+    throw new Error(`edit_file: search text not found in ${displayRel(rootDir, abs)}`);
+  }
+  const nextIdx = before.indexOf(adaptedSearch, firstIdx + 1);
+  if (nextIdx >= 0) {
+    throw new Error(
+      `edit_file: search text appears multiple times in ${displayRel(rootDir, abs)} \u2014 include more context to disambiguate`
+    );
+  }
+  const after = before.slice(0, firstIdx) + adaptedReplace + before.slice(firstIdx + adaptedSearch.length);
+  await fs.writeFile(abs, after, "utf8");
+  const rel = displayRel(rootDir, abs);
+  const header = `edited ${rel} (${adaptedSearch.length}\u2192${adaptedReplace.length} chars)`;
+  const startLine = before.slice(0, firstIdx).split(/\r?\n/).length;
+  const diff = renderEditDiff(adaptedSearch, adaptedReplace, startLine);
+  return `${header}
+${diff}`;
+}
+function renderEditDiff(search, replace, startLine) {
+  const a = search.split(/\r?\n/);
+  const b = replace.split(/\r?\n/);
+  const diff = lineDiff(a, b);
+  const hunk = `@@ -${startLine},${a.length} +${startLine},${b.length} @@`;
+  const body = diff.map((d) => `${d.op === " " ? " " : d.op} ${d.line}`).join("\n");
+  return `${hunk}
+${body}`;
+}
+function lineDiff(a, b) {
+  const n = a.length;
+  const m = b.length;
+  const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+  for (let i2 = 1; i2 <= n; i2++) {
+    for (let j2 = 1; j2 <= m; j2++) {
+      if (a[i2 - 1] === b[j2 - 1]) dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
+      else dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+    }
+  }
+  const out = [];
+  let i = n;
+  let j = m;
+  while (i > 0 && j > 0) {
+    if (a[i - 1] === b[j - 1]) {
+      out.unshift({ op: " ", line: a[i - 1] });
+      i--;
+      j--;
+    } else if ((dp[i - 1][j] ?? 0) > (dp[i][j - 1] ?? 0)) {
+      out.unshift({ op: "-", line: a[i - 1] });
+      i--;
+    } else {
+      out.unshift({ op: "+", line: b[j - 1] });
+      j--;
+    }
+  }
+  while (i > 0) {
+    out.unshift({ op: "-", line: a[i - 1] });
+    i--;
+  }
+  while (j > 0) {
+    out.unshift({ op: "+", line: b[j - 1] });
+    j--;
+  }
+  return out;
+}
+
+// src/tools/fs/search.ts
+import { promises as fs2 } from "fs";
+import * as pathMod2 from "path";
+function displayRel2(rootDir, full) {
+  return pathMod2.relative(rootDir, full).replaceAll("\\", "/");
+}
+async function searchFiles(ctx, startAbs, args) {
+  const needle = args.pattern.toLowerCase();
+  const includeDeps = args.include_deps === true;
+  let re = null;
+  try {
+    re = new RegExp(args.pattern, "i");
+  } catch {
+    re = null;
+  }
+  const matches = [];
+  let totalBytes = 0;
+  const walk2 = async (dir) => {
+    let entries;
+    try {
+      entries = await fs2.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const full = pathMod2.join(dir, e.name);
+      const lower = e.name.toLowerCase();
+      const hit = re ? re.test(e.name) : lower.includes(needle);
+      if (hit) {
+        const rel = displayRel2(ctx.rootDir, full);
+        if (totalBytes + rel.length + 1 > ctx.maxListBytes) {
+          matches.push("[\u2026 search truncated \u2014 refine pattern \u2026]");
+          return;
+        }
+        matches.push(rel);
+        totalBytes += rel.length + 1;
+      }
+      if (e.isDirectory()) {
+        if (!includeDeps && ctx.skipDirNames.has(e.name)) continue;
+        await walk2(full);
+      }
+    }
+  };
+  await walk2(startAbs);
+  return matches.length === 0 ? "(no matches)" : matches.join("\n");
+}
+async function searchContent(ctx, startAbs, args) {
+  const caseSensitive = args.case_sensitive === true;
+  const includeDeps = args.include_deps === true;
+  let re = null;
+  try {
+    re = new RegExp(args.pattern, caseSensitive ? "" : "i");
+  } catch {
+    re = null;
+  }
+  const needle = caseSensitive ? args.pattern : args.pattern.toLowerCase();
+  const matches = [];
+  let totalBytes = 0;
+  let scanned = 0;
+  let truncated = false;
+  const walk2 = async (dir) => {
+    if (truncated) return;
+    let entries;
+    try {
+      entries = await fs2.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (truncated) return;
+      if (e.isDirectory()) {
+        if (!includeDeps && ctx.skipDirNames.has(e.name)) continue;
+        await walk2(pathMod2.join(dir, e.name));
+        continue;
+      }
+      if (!e.isFile()) continue;
+      const full = pathMod2.join(dir, e.name);
+      if (ctx.nameMatch && !ctx.nameMatch(e.name, displayRel2(ctx.rootDir, full))) continue;
+      if (ctx.isBinaryByName(e.name)) continue;
+      let fh;
+      try {
+        fh = await fs2.open(full, "r");
+      } catch {
+        continue;
+      }
+      let raw;
+      try {
+        const st = await fh.stat();
+        if (st.size > 2 * 1024 * 1024) {
+          await fh.close();
+          continue;
+        }
+        raw = await fh.readFile();
+      } catch {
+        await fh.close().catch(() => {
+        });
+        continue;
+      }
+      await fh.close();
+      const firstNul = raw.indexOf(0);
+      if (firstNul !== -1 && firstNul < 8 * 1024) continue;
+      const text = raw.toString("utf8");
+      const rel = displayRel2(ctx.rootDir, full);
+      const lines = text.split(/\r?\n/);
+      for (let li = 0; li < lines.length; li++) {
+        const line = lines[li];
+        const lineForCheck = caseSensitive ? line : line.toLowerCase();
+        const hit = re ? re.test(line) : lineForCheck.includes(needle);
+        if (!hit) continue;
+        const display = line.length > 200 ? `${line.slice(0, 200)}\u2026` : line;
+        const out = `${rel}:${li + 1}: ${display}`;
+        if (totalBytes + out.length + 1 > ctx.maxListBytes) {
+          matches.push(`[\u2026 truncated at ${ctx.maxListBytes} bytes \u2014 refine pattern or path \u2026]`);
+          truncated = true;
+          return;
+        }
+        matches.push(out);
+        totalBytes += out.length + 1;
+      }
+      scanned++;
+    }
+  };
+  await walk2(startAbs);
+  if (matches.length === 0) {
+    return scanned === 0 ? "(no files scanned \u2014 path empty or all files filtered out)" : `(no matches across ${scanned} file${scanned === 1 ? "" : "s"})`;
+  }
+  return matches.join("\n");
+}
+
 // src/tools/filesystem.ts
 var DEFAULT_MAX_READ_BYTES = 2 * 1024 * 1024;
 var DEFAULT_MAX_LIST_BYTES = 256 * 1024;
@@ -4258,8 +4556,8 @@ var AUTO_PREVIEW_HEAD_LINES = 80;
 var AUTO_PREVIEW_TAIL_LINES = 40;
 var SKIP_DIR_NAMES = new Set(DEFAULT_INDEX_EXCLUDES.dirs);
 var BINARY_EXTENSIONS = new Set(DEFAULT_INDEX_EXCLUDES.exts);
-function displayRel(rootDir, full) {
-  return pathMod.relative(rootDir, full).replaceAll("\\", "/");
+function displayRel3(rootDir, full) {
+  return pathMod3.relative(rootDir, full).replaceAll("\\", "/");
 }
 var GLOB_METACHARS = /[*?{[]/;
 function compileNameFilter(filter) {
@@ -4278,7 +4576,7 @@ function isLikelyBinaryByName(name) {
   return BINARY_EXTENSIONS.has(name.slice(dot).toLowerCase());
 }
 function registerFilesystemTools(registry, opts) {
-  const rootDir = pathMod.resolve(opts.rootDir);
+  const rootDir = pathMod3.resolve(opts.rootDir);
   const allowWriting = opts.allowWriting !== false;
   const maxReadBytes = opts.maxReadBytes ?? DEFAULT_MAX_READ_BYTES;
   const maxListBytes = opts.maxListBytes ?? DEFAULT_MAX_LIST_BYTES;
@@ -4291,10 +4589,10 @@ function registerFilesystemTools(registry, opts) {
       normalized = normalized.slice(1);
     }
     if (normalized.length === 0) normalized = ".";
-    const resolved = pathMod.resolve(rootDir, normalized);
-    const normRoot = pathMod.resolve(rootDir);
-    const rel = pathMod.relative(normRoot, resolved);
-    if (rel.startsWith("..") || pathMod.isAbsolute(rel)) {
+    const resolved = pathMod3.resolve(rootDir, normalized);
+    const normRoot = pathMod3.resolve(rootDir);
+    const rel = pathMod3.relative(normRoot, resolved);
+    if (rel.startsWith("..") || pathMod3.isAbsolute(rel)) {
       throw new Error(`path escapes sandbox root (${normRoot}): ${raw}`);
     }
     return resolved;
@@ -4322,11 +4620,17 @@ When none of these is given AND the file is longer than ${DEFAULT_AUTO_PREVIEW_L
     },
     fn: async (args) => {
       const abs = safePath(args.path);
-      const stat2 = await fs.stat(abs);
-      if (stat2.isDirectory()) {
-        throw new Error(`not a file: ${args.path} (it's a directory)`);
+      const fh = await fs3.open(abs, "r");
+      let raw;
+      try {
+        const stat2 = await fh.stat();
+        if (stat2.isDirectory()) {
+          throw new Error(`not a file: ${args.path} (it's a directory)`);
+        }
+        raw = await fh.readFile();
+      } finally {
+        await fh.close();
       }
-      const raw = await fs.readFile(abs);
       if (raw.length > maxReadBytes) {
         const headBytes = raw.slice(0, maxReadBytes).toString("utf8");
         return `${headBytes}
@@ -4388,7 +4692,7 @@ ${slice.join("\n")}`;
     },
     fn: async (args) => {
       const abs = safePath(args.path ?? ".");
-      const entries = await fs.readdir(abs, { withFileTypes: true });
+      const entries = await fs3.readdir(abs, { withFileTypes: true });
       const lines = [];
       for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
         lines.push(e.isDirectory() ? `${e.name}/` : e.name);
@@ -4431,7 +4735,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
         if (depth > maxDepth) return;
         let entries;
         try {
-          entries = await fs.readdir(dir, { withFileTypes: true });
+          entries = await fs3.readdir(dir, { withFileTypes: true });
         } catch {
           return;
         }
@@ -4466,7 +4770,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
           lines.push(line);
           emitted++;
           if (e.isDirectory() && !skip) {
-            await walk2(pathMod.join(dir, e.name), depth + 1);
+            await walk2(pathMod3.join(dir, e.name), depth + 1);
           }
         }
       };
@@ -4493,47 +4797,11 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
       },
       required: ["pattern"]
     },
-    fn: async (args) => {
-      const startAbs = safePath(args.path ?? ".");
-      const needle = args.pattern.toLowerCase();
-      const includeDeps = args.include_deps === true;
-      let re = null;
-      try {
-        re = new RegExp(args.pattern, "i");
-      } catch {
-        re = null;
-      }
-      const matches = [];
-      let totalBytes = 0;
-      const walk2 = async (dir) => {
-        let entries;
-        try {
-          entries = await fs.readdir(dir, { withFileTypes: true });
-        } catch {
-          return;
-        }
-        for (const e of entries) {
-          const full = pathMod.join(dir, e.name);
-          const lower = e.name.toLowerCase();
-          const hit = re ? re.test(e.name) : lower.includes(needle);
-          if (hit) {
-            const rel = displayRel(rootDir, full);
-            if (totalBytes + rel.length + 1 > maxListBytes) {
-              matches.push("[\u2026 search truncated \u2014 refine pattern \u2026]");
-              return;
-            }
-            matches.push(rel);
-            totalBytes += rel.length + 1;
-          }
-          if (e.isDirectory()) {
-            if (!includeDeps && SKIP_DIR_NAMES.has(e.name)) continue;
-            await walk2(full);
-          }
-        }
-      };
-      await walk2(startAbs);
-      return matches.length === 0 ? "(no matches)" : matches.join("\n");
-    }
+    fn: async (args) => searchFiles(
+      { rootDir, maxListBytes, skipDirNames: SKIP_DIR_NAMES },
+      safePath(args.path ?? "."),
+      args
+    )
   });
   registry.register({
     name: "search_content",
@@ -4565,83 +4833,17 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
       },
       required: ["pattern"]
     },
-    fn: async (args) => {
-      const startAbs = safePath(args.path ?? ".");
-      const caseSensitive = args.case_sensitive === true;
-      const includeDeps = args.include_deps === true;
-      const nameMatch = compileNameFilter(typeof args.glob === "string" ? args.glob : null);
-      let re = null;
-      try {
-        re = new RegExp(args.pattern, caseSensitive ? "" : "i");
-      } catch {
-        re = null;
-      }
-      const needle = caseSensitive ? args.pattern : args.pattern.toLowerCase();
-      const matches = [];
-      let totalBytes = 0;
-      let scanned = 0;
-      let truncated = false;
-      const walk2 = async (dir) => {
-        if (truncated) return;
-        let entries;
-        try {
-          entries = await fs.readdir(dir, { withFileTypes: true });
-        } catch {
-          return;
-        }
-        for (const e of entries) {
-          if (truncated) return;
-          if (e.isDirectory()) {
-            if (!includeDeps && SKIP_DIR_NAMES.has(e.name)) continue;
-            await walk2(pathMod.join(dir, e.name));
-            continue;
-          }
-          if (!e.isFile()) continue;
-          const full = pathMod.join(dir, e.name);
-          if (nameMatch && !nameMatch(e.name, displayRel(rootDir, full))) continue;
-          if (isLikelyBinaryByName(e.name)) continue;
-          let stat2;
-          try {
-            stat2 = await fs.stat(full);
-          } catch {
-            continue;
-          }
-          if (stat2.size > 2 * 1024 * 1024) continue;
-          let raw;
-          try {
-            raw = await fs.readFile(full);
-          } catch {
-            continue;
-          }
-          const firstNul = raw.indexOf(0);
-          if (firstNul !== -1 && firstNul < 8 * 1024) continue;
-          const text = raw.toString("utf8");
-          const rel = displayRel(rootDir, full);
-          const lines = text.split(/\r?\n/);
-          for (let li = 0; li < lines.length; li++) {
-            const line = lines[li];
-            const lineForCheck = caseSensitive ? line : line.toLowerCase();
-            const hit = re ? re.test(line) : lineForCheck.includes(needle);
-            if (!hit) continue;
-            const display = line.length > 200 ? `${line.slice(0, 200)}\u2026` : line;
-            const out = `${rel}:${li + 1}: ${display}`;
-            if (totalBytes + out.length + 1 > maxListBytes) {
-              matches.push(`[\u2026 truncated at ${maxListBytes} bytes \u2014 refine pattern or path \u2026]`);
-              truncated = true;
-              return;
-            }
-            matches.push(out);
-            totalBytes += out.length + 1;
-          }
-          scanned++;
-        }
-      };
-      await walk2(startAbs);
-      if (matches.length === 0) {
-        return scanned === 0 ? "(no files scanned \u2014 path empty or all files filtered out)" : `(no matches across ${scanned} file${scanned === 1 ? "" : "s"})`;
-      }
-      return matches.join("\n");
-    }
+    fn: async (args) => searchContent(
+      {
+        rootDir,
+        maxListBytes,
+        skipDirNames: SKIP_DIR_NAMES,
+        isBinaryByName: isLikelyBinaryByName,
+        nameMatch: compileNameFilter(typeof args.glob === "string" ? args.glob : null)
+      },
+      safePath(args.path ?? "."),
+      args
+    )
   });
   registry.register({
     name: "get_file_info",
@@ -4656,7 +4858,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
     },
     fn: async (args) => {
       const abs = safePath(args.path);
-      const st = await fs.lstat(abs);
+      const st = await fs3.lstat(abs);
       const type = st.isDirectory() ? "directory" : st.isSymbolicLink() ? "symlink" : "file";
       return JSON.stringify({
         type,
@@ -4679,9 +4881,9 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
     },
     fn: async (args) => {
       const abs = safePath(args.path);
-      await fs.mkdir(pathMod.dirname(abs), { recursive: true });
-      await fs.writeFile(abs, args.content, "utf8");
-      return `wrote ${args.content.length} chars to ${displayRel(rootDir, abs)}`;
+      await fs3.mkdir(pathMod3.dirname(abs), { recursive: true });
+      await fs3.writeFile(abs, args.content, "utf8");
+      return `wrote ${args.content.length} chars to ${displayRel3(rootDir, abs)}`;
     }
   });
   registry.register({
@@ -4696,34 +4898,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
       },
       required: ["path", "search", "replace"]
     },
-    fn: async (args) => {
-      const abs = safePath(args.path);
-      const before = await fs.readFile(abs, "utf8");
-      if (args.search.length === 0) {
-        throw new Error("edit_file: search cannot be empty");
-      }
-      const le = before.includes("\r\n") ? "\r\n" : "\n";
-      const adaptedSearch = args.search.replace(/\r?\n/g, le);
-      const adaptedReplace = args.replace.replace(/\r?\n/g, le);
-      const firstIdx = before.indexOf(adaptedSearch);
-      if (firstIdx < 0) {
-        throw new Error(`edit_file: search text not found in ${displayRel(rootDir, abs)}`);
-      }
-      const nextIdx = before.indexOf(adaptedSearch, firstIdx + 1);
-      if (nextIdx >= 0) {
-        throw new Error(
-          `edit_file: search text appears multiple times in ${displayRel(rootDir, abs)} \u2014 include more context to disambiguate`
-        );
-      }
-      const after = before.slice(0, firstIdx) + adaptedReplace + before.slice(firstIdx + adaptedSearch.length);
-      await fs.writeFile(abs, after, "utf8");
-      const rel = displayRel(rootDir, abs);
-      const header = `edited ${rel} (${adaptedSearch.length}\u2192${adaptedReplace.length} chars)`;
-      const startLine = before.slice(0, firstIdx).split(/\r?\n/).length;
-      const diff = renderEditDiff(adaptedSearch, adaptedReplace, startLine);
-      return `${header}
-${diff}`;
-    }
+    fn: async (args) => applyEdit(rootDir, safePath(args.path), args)
   });
   registry.register({
     name: "create_directory",
@@ -4735,8 +4910,8 @@ ${diff}`;
     },
     fn: async (args) => {
       const abs = safePath(args.path);
-      await fs.mkdir(abs, { recursive: true });
-      return `created ${displayRel(rootDir, abs)}/`;
+      await fs3.mkdir(abs, { recursive: true });
+      return `created ${displayRel3(rootDir, abs)}/`;
     }
   });
   registry.register({
@@ -4753,58 +4928,13 @@ ${diff}`;
     fn: async (args) => {
       const src = safePath(args.source);
       const dst = safePath(args.destination);
-      await fs.mkdir(pathMod.dirname(dst), { recursive: true });
-      await fs.rename(src, dst);
-      return `moved ${displayRel(rootDir, src)} \u2192 ${displayRel(rootDir, dst)}`;
+      await fs3.mkdir(pathMod3.dirname(dst), { recursive: true });
+      await fs3.rename(src, dst);
+      return `moved ${displayRel3(rootDir, src)} \u2192 ${displayRel3(rootDir, dst)}`;
     }
   });
   return registry;
 }
-function renderEditDiff(search, replace, startLine) {
-  const a = search.split(/\r?\n/);
-  const b = replace.split(/\r?\n/);
-  const diff = lineDiff(a, b);
-  const hunk = `@@ -${startLine},${a.length} +${startLine},${b.length} @@`;
-  const body = diff.map((d) => `${d.op === " " ? " " : d.op} ${d.line}`).join("\n");
-  return `${hunk}
-${body}`;
-}
-function lineDiff(a, b) {
-  const n = a.length;
-  const m = b.length;
-  const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
-  for (let i2 = 1; i2 <= n; i2++) {
-    for (let j2 = 1; j2 <= m; j2++) {
-      if (a[i2 - 1] === b[j2 - 1]) dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
-      else dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
-    }
-  }
-  const out = [];
-  let i = n;
-  let j = m;
-  while (i > 0 && j > 0) {
-    if (a[i - 1] === b[j - 1]) {
-      out.unshift({ op: " ", line: a[i - 1] });
-      i--;
-      j--;
-    } else if ((dp[i - 1][j] ?? 0) > (dp[i][j - 1] ?? 0)) {
-      out.unshift({ op: "-", line: a[i - 1] });
-      i--;
-    } else {
-      out.unshift({ op: "+", line: b[j - 1] });
-      j--;
-    }
-  }
-  while (i > 0) {
-    out.unshift({ op: "-", line: a[i - 1] });
-    i--;
-  }
-  while (j > 0) {
-    out.unshift({ op: "+", line: b[j - 1] });
-    j--;
-  }
-  return out;
-}
 
 // src/tools/memory.ts
 function registerMemoryTools(registry, opts = {}) {
@@ -5522,16 +5652,14 @@ function forkRegistryExcluding(parent, exclude) {
 }
 
 // src/tools/shell.ts
-import { spawn as spawn4, spawnSync } from "child_process";
-import { existsSync as existsSync8, statSync as statSync4 } from "fs";
-import * as pathMod4 from "path";
+import * as pathMod7 from "path";
 
 // src/config.ts
 import { chmodSync as chmodSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync9, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir5 } from "os";
-import { dirname as dirname4, join as join9 } from "path";
+import { dirname as dirname4, join as join10 } from "path";
 function defaultConfigPath() {
-  return join9(homedir5(), ".reasonix", "config.json");
+  return join10(homedir5(), ".reasonix", "config.json");
 }
 function readConfig(path2 = defaultConfigPath()) {
   try {
@@ -5582,7 +5710,7 @@ function redactKey(key) {
 
 // src/tools/jobs.ts
 import { spawn as spawn2 } from "child_process";
-import * as pathMod2 from "path";
+import * as pathMod4 from "path";
 function killProcessTree(pid, signal) {
   if (process.platform === "win32") {
     const args = ["/pid", String(pid), "/T"];
@@ -5642,7 +5770,7 @@ var JobRegistry = class {
     const maxBytes = opts.maxBufferBytes ?? DEFAULT_OUTPUT_CAP_BYTES;
     const { bin, args, spawnOverrides } = prepareSpawn(argv);
     const spawnOpts = {
-      cwd: pathMod2.resolve(opts.cwd),
+      cwd: pathMod4.resolve(opts.cwd),
       shell: false,
       windowsHide: true,
       env: process.env,
@@ -5673,6 +5801,9 @@ var JobRegistry = class {
         child: null,
         readyPromise: Promise.resolve(),
         signalReady: () => {
+        },
+        closedPromise: Promise.resolve(),
+        signalClosed: () => {
         }
       };
       this.jobs.set(id2, job2);
@@ -5691,6 +5822,11 @@ var JobRegistry = class {
     const readyPromise = new Promise((res) => {
       readyResolve = res;
     });
+    let closedResolve = () => {
+    };
+    const closedPromise = new Promise((res) => {
+      closedResolve = res;
+    });
     const job = {
       id,
       command: trimmed,
@@ -5702,7 +5838,9 @@ var JobRegistry = class {
       running: true,
       child,
       readyPromise,
-      signalReady: readyResolve
+      signalReady: readyResolve,
+      closedPromise,
+      signalClosed: closedResolve
     };
     this.jobs.set(id, job);
     let readyMatched = false;
@@ -5736,11 +5874,13 @@ ${job.output.slice(start)}`;
       job.running = false;
       job.spawnError = err.message;
       job.signalReady();
+      job.signalClosed();
     });
     child.on("close", (code) => {
       job.running = false;
       job.exitCode = code;
       job.signalReady();
+      job.signalClosed();
     });
     const onAbort = () => this.stop(id, { graceMs: 100 });
     if (opts.signal?.aborted) {
@@ -5802,7 +5942,7 @@ ${job.output.slice(start)}`;
       } catch {
       }
     }
-    await Promise.race([job.readyPromise, new Promise((res) => setTimeout(res, graceMs))]);
+    await Promise.race([job.closedPromise, new Promise((res) => setTimeout(res, graceMs))]);
     if (job.running) {
       if (job.pid !== null) {
         killProcessTree(job.pid, "SIGKILL");
@@ -5812,7 +5952,7 @@ ${job.output.slice(start)}`;
         } catch {
         }
       }
-      await new Promise((res) => setTimeout(res, 800));
+      await Promise.race([job.closedPromise, new Promise((res) => setTimeout(res, 5e3))]);
     }
     return snapshot(job);
   }
@@ -5868,10 +6008,15 @@ function snapshot(job) {
   };
 }
 
+// src/tools/shell/exec.ts
+import { spawn as spawn4, spawnSync } from "child_process";
+import { existsSync as existsSync8, statSync as statSync4 } from "fs";
+import * as pathMod6 from "path";
+
 // src/tools/shell-chain.ts
 import { spawn as spawn3 } from "child_process";
 import { closeSync, openSync } from "fs";
-import * as pathMod3 from "path";
+import * as pathMod5 from "path";
 var UnsupportedSyntaxError = class extends Error {
   constructor(detail) {
     super(`run_command: ${detail}`);
@@ -6138,7 +6283,7 @@ function openRedirects(redirects, cwd) {
   let bothFd = null;
   const toClose = [];
   const open = (target, flags) => {
-    const resolved = pathMod3.resolve(cwd, target);
+    const resolved = pathMod5.resolve(cwd, target);
     const fd = openSync(resolved, flags);
     toClose.push(fd);
     return fd;
@@ -6287,31 +6432,7 @@ var OutputBuffer = class {
   }
 };
 
-// src/tools/shell.ts
-function killProcessTree2(child) {
-  if (!child.pid || child.killed) return;
-  if (process.platform === "win32") {
-    try {
-      spawnSync("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
-        stdio: "ignore",
-        windowsHide: true
-      });
-      return;
-    } catch {
-    }
-  }
-  try {
-    process.kill(-child.pid, "SIGKILL");
-    return;
-  } catch {
-  }
-  try {
-    child.kill("SIGKILL");
-  } catch {
-  }
-}
-var DEFAULT_TIMEOUT_SEC = 60;
-var DEFAULT_MAX_OUTPUT_CHARS = 32e3;
+// src/tools/shell/parse.ts
 var BUILTIN_ALLOWLIST = [
   // Repo inspection
   "git status",
@@ -6524,6 +6645,32 @@ function isCommandAllowed(cmd, extra = []) {
   if (chain === null) return isAllowed(cmd, extra);
   return chainAllowed(chain, (seg) => isAllowed(seg, extra));
 }
+
+// src/tools/shell/exec.ts
+var DEFAULT_TIMEOUT_SEC = 60;
+var DEFAULT_MAX_OUTPUT_CHARS = 32e3;
+function killProcessTree2(child) {
+  if (!child.pid || child.killed) return;
+  if (process.platform === "win32") {
+    try {
+      spawnSync("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+        stdio: "ignore",
+        windowsHide: true
+      });
+      return;
+    } catch {
+    }
+  }
+  try {
+    process.kill(-child.pid, "SIGKILL");
+    return;
+  } catch {
+  }
+  try {
+    child.kill("SIGKILL");
+  } catch {
+  }
+}
 async function runCommand(cmd, opts) {
   const timeoutSec = opts.timeoutSec ?? DEFAULT_TIMEOUT_SEC;
   const maxChars = opts.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
@@ -6632,16 +6779,16 @@ function resolveExecutable(cmd, opts = {}) {
   const platform = opts.platform ?? process.platform;
   if (platform !== "win32") return cmd;
   if (!cmd) return cmd;
-  if (cmd.includes("/") || cmd.includes("\\") || pathMod4.isAbsolute(cmd)) return cmd;
-  if (pathMod4.extname(cmd)) return cmd;
+  if (cmd.includes("/") || cmd.includes("\\") || pathMod6.isAbsolute(cmd)) return cmd;
+  if (pathMod6.extname(cmd)) return cmd;
   const env = opts.env ?? process.env;
   const pathExt = (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").map((e) => e.trim()).filter(Boolean);
-  const delimiter2 = opts.pathDelimiter ?? (platform === "win32" ? ";" : pathMod4.delimiter);
+  const delimiter2 = opts.pathDelimiter ?? (platform === "win32" ? ";" : pathMod6.delimiter);
   const pathDirs = (env.PATH ?? "").split(delimiter2).filter(Boolean);
   const isFile = opts.isFile ?? defaultIsFile;
   for (const dir of pathDirs) {
     for (const ext of pathExt) {
-      const full = pathMod4.win32.join(dir, cmd + ext);
+      const full = pathMod6.win32.join(dir, cmd + ext);
       if (isFile(full)) return full;
     }
   }
@@ -6711,8 +6858,8 @@ function withUtf8Codepage(cmdline) {
 function isBareWindowsName(s) {
   if (!s) return false;
   if (s.includes("/") || s.includes("\\")) return false;
-  if (pathMod4.isAbsolute(s)) return false;
-  if (pathMod4.extname(s)) return false;
+  if (pathMod6.isAbsolute(s)) return false;
+  if (pathMod6.extname(s)) return false;
   return true;
 }
 function quoteForCmdExe(arg) {
@@ -6720,6 +6867,8 @@ function quoteForCmdExe(arg) {
   if (!/[\s"&|<>^%(),;!]/.test(arg)) return arg;
   return `"${arg.replace(/"/g, '""')}"`;
 }
+
+// src/tools/shell.ts
 var NeedsConfirmationError = class extends Error {
   command;
   constructor(command) {
@@ -6731,7 +6880,7 @@ var NeedsConfirmationError = class extends Error {
   }
 };
 function registerShellTools(registry, opts) {
-  const rootDir = pathMod4.resolve(opts.rootDir);
+  const rootDir = pathMod7.resolve(opts.rootDir);
   const timeoutSec = opts.timeoutSec ?? DEFAULT_TIMEOUT_SEC;
   const maxOutputChars = opts.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
   const jobs = opts.jobs ?? new JobRegistry();
@@ -6930,6 +7079,7 @@ ${r.output}` : header;
 }
 
 // src/tools/web.ts
+import { parse as parseHtml } from "node-html-parser";
 var DEFAULT_FETCH_MAX_CHARS = 32e3;
 var DEFAULT_FETCH_TIMEOUT_MS = 15e3;
 var DEFAULT_TOPK = 5;
@@ -7059,28 +7209,70 @@ async function readBodyCapped(resp, maxBytes) {
   }
   return out;
 }
+var MAX_HTML_INPUT = 5 * 1024 * 1024;
+var STRIP_BLOCK_TAGS = "script, style, noscript, nav, footer, aside, svg";
+var BLOCK_BREAK_TAGS = /* @__PURE__ */ new Set([
+  "p",
+  "div",
+  "br",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "li",
+  "tr",
+  "section",
+  "article"
+]);
 function htmlToText(html) {
-  let s = html;
-  s = s.replace(/<script[\s\S]*?<\/script>/gi, "");
-  s = s.replace(/<style[\s\S]*?<\/style>/gi, "");
-  s = s.replace(/<noscript[\s\S]*?<\/noscript>/gi, "");
-  s = s.replace(/<nav[\s\S]*?<\/nav>/gi, "");
-  s = s.replace(/<footer[\s\S]*?<\/footer>/gi, "");
-  s = s.replace(/<aside[\s\S]*?<\/aside>/gi, "");
-  s = s.replace(/<svg[\s\S]*?<\/svg>/gi, "");
-  s = s.replace(/<\/?(p|div|br|h[1-6]|li|tr|section|article)\b[^>]*>/gi, "\n");
-  s = s.replace(/<[^>]+>/g, "");
+  const input = html.length > MAX_HTML_INPUT ? html.slice(0, MAX_HTML_INPUT) : html;
+  const root = parseHtml(input);
+  for (const node of root.querySelectorAll(STRIP_BLOCK_TAGS)) node.remove();
+  const out = [];
+  walkExtract(root, out);
+  let s = out.join("");
   s = decodeHtmlEntities(s);
   s = s.replace(/[ \t]+/g, " ");
   s = s.replace(/\n[ \t]+/g, "\n");
   s = s.replace(/\n{3,}/g, "\n\n");
   return s.trim();
 }
-function stripHtml(s) {
-  return s.replace(/<[^>]+>/g, "");
+function walkExtract(node, out) {
+  if (node.nodeType === 3) {
+    out.push(node.rawText ?? node.text ?? "");
+    return;
+  }
+  const tag = node.rawTagName?.toLowerCase();
+  const isBreak = tag !== void 0 && BLOCK_BREAK_TAGS.has(tag);
+  if (isBreak) out.push("\n");
+  for (const child of node.childNodes) walkExtract(child, out);
+  if (isBreak) out.push("\n");
 }
+function stripHtml(s) {
+  return parseHtml(s).text;
+}
+var HTML_ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: " "
+};
 function decodeHtmlEntities(s) {
-  return s.replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+  return s.replace(/&(#\d+|#x[0-9a-fA-F]+|\w+);/g, (raw, name) => {
+    if (name.startsWith("#x") || name.startsWith("#X")) {
+      const code = Number.parseInt(name.slice(2), 16);
+      return Number.isFinite(code) ? String.fromCodePoint(code) : raw;
+    }
+    if (name.startsWith("#")) {
+      const code = Number.parseInt(name.slice(1), 10);
+      return Number.isFinite(code) ? String.fromCodePoint(code) : raw;
+    }
+    return HTML_ENTITIES[name.toLowerCase()] ?? raw;
+  });
 }
 function extractTitle(html) {
   const m = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
@@ -7675,7 +7867,7 @@ function truncate(s, n) {
 // src/version.ts
 import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync12, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir6 } from "os";
-import { dirname as dirname5, join as join10 } from "path";
+import { dirname as dirname5, join as join11 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var REGISTRY_URL = "https://registry.npmjs.org/reasonix/latest";
 var LATEST_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
@@ -7684,7 +7876,7 @@ function readPackageVersion() {
   try {
     let dir = dirname5(fileURLToPath2(import.meta.url));
     for (let i = 0; i < 6; i++) {
-      const p = join10(dir, "package.json");
+      const p = join11(dir, "package.json");
       if (existsSync9(p)) {
         const pkg = JSON.parse(readFileSync12(p, "utf8"));
         if (pkg?.name === "reasonix" && typeof pkg.version === "string") {
@@ -7701,7 +7893,7 @@ function readPackageVersion() {
 }
 var VERSION = readPackageVersion();
 function cachePath(homeDirOverride) {
-  return join10(homeDirOverride ?? homedir6(), ".reasonix", "version-cache.json");
+  return join11(homeDirOverride ?? homedir6(), ".reasonix", "version-cache.json");
 }
 function readCache(homeDirOverride) {
   try {
@@ -8517,7 +8709,19 @@ async function trySection(load) {
 }
 
 // src/code/edit-blocks.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync13, unlinkSync as unlinkSync3, writeFileSync as writeFileSync5 } from "fs";
+import {
+  closeSync as closeSync2,
+  existsSync as existsSync10,
+  fstatSync,
+  ftruncateSync,
+  mkdirSync as mkdirSync5,
+  openSync as openSync2,
+  readFileSync as readFileSync13,
+  readSync,
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync5,
+  writeSync
+} from "fs";
 import { dirname as dirname6, resolve as resolve9 } from "path";
 var BLOCK_RE = /^(\S[^\n]*)\n<{7} SEARCH\n([\s\S]*?)\n?={7}\n([\s\S]*?)\n?>{7} REPLACE/gm;
 function parseEditBlocks(text) {
@@ -8546,42 +8750,76 @@ function applyEditBlock(block, rootDir) {
     };
   }
   const searchEmpty = block.search.length === 0;
-  const exists = existsSync10(absTarget);
+  if (searchEmpty) {
+    try {
+      mkdirSync5(dirname6(absTarget), { recursive: true });
+      const fd = openSync2(absTarget, "wx");
+      try {
+        writeSync(fd, block.replace);
+      } finally {
+        closeSync2(fd);
+      }
+      return { path: block.path, status: "created" };
+    } catch (err) {
+      const e = err;
+      if (e.code === "EEXIST") {
+        return {
+          path: block.path,
+          status: "not-found",
+          message: "empty SEARCH only creates new files \u2014 this file already exists"
+        };
+      }
+      return { path: block.path, status: "error", message: e.message };
+    }
+  }
   try {
-    if (!exists) {
-      if (!searchEmpty) {
+    let fd;
+    try {
+      fd = openSync2(absTarget, "r+");
+    } catch (err) {
+      if (err.code === "ENOENT") {
         return {
           path: block.path,
           status: "file-missing",
           message: "file does not exist; to create it, use an empty SEARCH block"
         };
       }
-      mkdirSync5(dirname6(absTarget), { recursive: true });
-      writeFileSync5(absTarget, block.replace, "utf8");
-      return { path: block.path, status: "created" };
-    }
-    const content = readFileSync13(absTarget, "utf8");
-    if (searchEmpty) {
-      return {
-        path: block.path,
-        status: "not-found",
-        message: "empty SEARCH only creates new files \u2014 this file already exists"
-      };
+      throw err;
     }
-    const le = lineEndingOf(content);
-    const adaptedSearch = block.search.replace(/\r?\n/g, le);
-    const adaptedReplace = block.replace.replace(/\r?\n/g, le);
-    const idx = content.indexOf(adaptedSearch);
-    if (idx === -1) {
-      return {
-        path: block.path,
-        status: "not-found",
-        message: "SEARCH text does not match the current file content exactly"
-      };
+    try {
+      const stat2 = fstatSync(fd);
+      const inBuf = Buffer.alloc(stat2.size);
+      let readBytes = 0;
+      while (readBytes < stat2.size) {
+        const n = readSync(fd, inBuf, readBytes, stat2.size - readBytes, readBytes);
+        if (n <= 0) break;
+        readBytes += n;
+      }
+      const content = inBuf.toString("utf8", 0, readBytes);
+      const le = lineEndingOf(content);
+      const adaptedSearch = block.search.replace(/\r?\n/g, le);
+      const adaptedReplace = block.replace.replace(/\r?\n/g, le);
+      const idx = content.indexOf(adaptedSearch);
+      if (idx === -1) {
+        return {
+          path: block.path,
+          status: "not-found",
+          message: "SEARCH text does not match the current file content exactly"
+        };
+      }
+      const replaced = `${content.slice(0, idx)}${adaptedReplace}${content.slice(idx + adaptedSearch.length)}`;
+      const outBuf = Buffer.from(replaced, "utf8");
+      ftruncateSync(fd, outBuf.length);
+      let written = 0;
+      while (written < outBuf.length) {
+        const n = writeSync(fd, outBuf, written, outBuf.length - written, written);
+        if (n <= 0) break;
+        written += n;
+      }
+      return { path: block.path, status: "applied" };
+    } finally {
+      closeSync2(fd);
     }
-    const replaced = `${content.slice(0, idx)}${adaptedReplace}${content.slice(idx + adaptedSearch.length)}`;
-    writeFileSync5(absTarget, replaced, "utf8");
-    return { path: block.path, status: "applied" };
   } catch (err) {
     return { path: block.path, status: "error", message: err.message };
   }
@@ -8649,7 +8887,7 @@ function lineEndingOf(text) {
 
 // src/code/prompt.ts
 import { existsSync as existsSync11, readFileSync as readFileSync14 } from "fs";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 var CODE_SYSTEM_PROMPT = `You are Reasonix Code, a coding assistant. You have filesystem tools (read_file, write_file, edit_file, list_directory, directory_tree, search_files, search_content, get_file_info) rooted at the user's working directory, plus run_command / run_background for shell.
 
 # Cite or shut up \u2014 non-negotiable
@@ -8851,7 +9089,7 @@ If \`semantic_search\` returns nothing useful (low scores, off-topic), THEN fall
 function codeSystemPrompt(rootDir, opts = {}) {
   const base = opts.hasSemanticSearch ? `${CODE_SYSTEM_PROMPT}${SEMANTIC_SEARCH_ROUTING}` : CODE_SYSTEM_PROMPT;
   const withMemory = applyMemoryStack(base, rootDir);
-  const gitignorePath = join11(rootDir, ".gitignore");
+  const gitignorePath = join12(rootDir, ".gitignore");
   let result = withMemory;
   if (existsSync11(gitignorePath)) {
     let content;
@@ -8889,34 +9127,47 @@ ${appendParts.join("\n\n")}`;
 // src/telemetry/usage.ts
 import {
   appendFileSync as appendFileSync2,
+  closeSync as closeSync3,
   existsSync as existsSync12,
+  fstatSync as fstatSync2,
   mkdirSync as mkdirSync6,
+  openSync as openSync3,
   readFileSync as readFileSync15,
+  readSync as readSync2,
+  renameSync as renameSync2,
   statSync as statSync5,
+  unlinkSync as unlinkSync4,
   writeFileSync as writeFileSync6
 } from "fs";
 import { homedir as homedir7 } from "os";
-import { dirname as dirname7, join as join12 } from "path";
+import { dirname as dirname7, join as join13 } from "path";
 function defaultUsageLogPath(homeDirOverride) {
-  return join12(homeDirOverride ?? homedir7(), ".reasonix", "usage.jsonl");
+  return join13(homeDirOverride ?? homedir7(), ".reasonix", "usage.jsonl");
 }
 var USAGE_COMPACTION_THRESHOLD_BYTES = 5 * 1024 * 1024;
 var USAGE_RETENTION_DAYS = 365;
 function compactUsageLogIfLarge(path2, now) {
-  let size;
-  try {
-    size = statSync5(path2).size;
-  } catch {
-    return;
-  }
-  if (size < USAGE_COMPACTION_THRESHOLD_BYTES) return;
-  const cutoff = now - USAGE_RETENTION_DAYS * 24 * 60 * 60 * 1e3;
   let raw;
   try {
-    raw = readFileSync15(path2, "utf8");
+    const fd = openSync3(path2, "r");
+    try {
+      const stat2 = fstatSync2(fd);
+      if (stat2.size < USAGE_COMPACTION_THRESHOLD_BYTES) return;
+      const buf = Buffer.alloc(stat2.size);
+      let read = 0;
+      while (read < stat2.size) {
+        const n = readSync2(fd, buf, read, stat2.size - read, read);
+        if (n <= 0) break;
+        read += n;
+      }
+      raw = buf.toString("utf8", 0, read);
+    } finally {
+      closeSync3(fd);
+    }
   } catch {
     return;
   }
+  const cutoff = now - USAGE_RETENTION_DAYS * 24 * 60 * 60 * 1e3;
   const lines = raw.split(/\r?\n/);
   const kept = [];
   for (const line of lines) {
@@ -8928,10 +9179,16 @@ function compactUsageLogIfLarge(path2, now) {
     }
   }
   if (kept.length === lines.filter((l) => l.trim()).length) return;
+  const tmp = `${path2}.compacting`;
   try {
-    writeFileSync6(path2, kept.length > 0 ? `${kept.join("\n")}
+    writeFileSync6(tmp, kept.length > 0 ? `${kept.join("\n")}
 ` : "", "utf8");
+    renameSync2(tmp, path2);
   } catch {
+    try {
+      unlinkSync4(tmp);
+    } catch {
+    }
   }
 }
 function appendUsage(input) {