reasonix 0.50.0 → 0.51.0

package/dist/cli/{chunk-GPUH2BNM.js → chunk-K4YQFULP.js}

@@ -7,32 +7,39 @@ import {
   decodeFileBuffer,
   encodeFile,
   pauseGate
-} from "./chunk-6IUMTRFP.js";
+} from "./chunk-UMZ6KHTS.js";
 import {
-  MemoryStore,
-  sanitizeMemoryName
-} from "./chunk-I6FBSTTR.js";
+  DEEPSEEK_CONTEXT_TOKENS,
+  DEFAULT_CONTEXT_TOKENS,
+  SessionStats
+} from "./chunk-BA5R6BAE.js";
 import {
+  MemoryStore,
   NEGATIVE_CLAIM_RULE,
   PROJECT_MEMORY_FILES,
   PROJECT_MEMORY_MAX_CHARS,
   TUI_FORMATTING_RULES,
-  memoryEnabled
-} from "./chunk-ENFBF6HI.js";
+  memoryEnabled,
+  sanitizeMemoryName
+} from "./chunk-N4SEBLU4.js";
 import {
   countTokens,
   countTokensBounded,
   estimateRequestTokens
-} from "./chunk-CAGKEGNE.js";
+} from "./chunk-BOWSNGQC.js";
+import {
+  Usage
+} from "./chunk-C2MRSJTV.js";
 import {
   formatHookOutcomeMessage,
   runHooks
-} from "./chunk-AJIZ5KFK.js";
+} from "./chunk-2WUEAI2I.js";
 import {
+  TtlLruCache,
   ignoredByLayers,
   loadGitignoreAt,
   loadGitignoreAtSync
-} from "./chunk-S4XVGLRW.js";
+} from "./chunk-6UNHNVJR.js";
 import {
   appendSessionMessage,
   archiveSession,
@@ -41,18 +48,10 @@ import {
   patchSessionMeta,
   rewriteSession,
   timestampSuffix
-} from "./chunk-IK6WWRIX.js";
-import {
-  Usage
-} from "./chunk-EZ57UEZQ.js";
-import {
-  DEEPSEEK_CONTEXT_TOKENS,
-  DEFAULT_CONTEXT_TOKENS,
-  SessionStats
-} from "./chunk-FQSQFCBI.js";
+} from "./chunk-6XWXIVQ3.js";
 import {
   t
-} from "./chunk-PYIZZAVQ.js";
+} from "./chunk-DVD67FXQ.js";
 import {
   DEFAULT_INDEX_EXCLUDES,
   ToolRateLimiter,
@@ -67,7 +66,7 @@ import {
   require_picomatch,
   webSearchEndpoint,
   webSearchEngine
-} from "./chunk-MXWPAPZW.js";
+} from "./chunk-A5PBEIJ7.js";
 import {
   __commonJS,
   __esm,
@@ -2604,10 +2603,10 @@ var require_helpers = __commonJS({
         return !arr.includes(node, i + 1);
       });
       nodes.sort(function(a, b) {
-        var relative7 = compareDocumentPosition(a, b);
-        if (relative7 & DocumentPosition.PRECEDING) {
+        var relative8 = compareDocumentPosition(a, b);
+        if (relative8 & DocumentPosition.PRECEDING) {
           return -1;
-        } else if (relative7 & DocumentPosition.FOLLOWING) {
+        } else if (relative8 & DocumentPosition.FOLLOWING) {
           return 1;
         }
         return 0;
@@ -6057,12 +6056,12 @@ async function waitForReady(ready, timeoutMs, serverName, signal) {
   let timer;
   let onAbort;
   try {
-    await new Promise((resolve6, reject) => {
+    await new Promise((resolve7, reject) => {
       ready.then(
         () => {
           if (settled) return;
           settled = true;
-          resolve6();
+          resolve7();
         },
         (err) => {
           if (settled) return;
@@ -6168,25 +6167,30 @@ function validateResultShape(result) {
     }
   }
 }
-function truncateForModel(s, maxChars) {
+function truncateForModel(s, maxChars, extraNote) {
   if (s.length <= maxChars) return s;
   const tailBudget = Math.min(1024, Math.floor(maxChars * 0.1));
   const headBudget = Math.max(0, maxChars - tailBudget);
   const head = s.slice(0, headBudget);
   const tail = s.slice(-tailBudget);
   const dropped = s.length - head.length - tail.length;
+  const note = extraNote ? ` \u2014 ${extraNote}` : "";
   return `${head}
 
-[\u2026truncated ${dropped} chars \u2014 raise BridgeOptions.maxResultChars, or call the tool with a narrower scope (filter, head, pagination)\u2026]
+[\u2026truncated ${dropped} chars \u2014 raise BridgeOptions.maxResultChars, or call the tool with a narrower scope (filter, head, pagination)${note}\u2026]
 
 ${tail}`;
 }
-function truncateForModelByTokens(s, maxTokens) {
+function truncateForModelByTokens(s, maxTokens, extraNote) {
   if (maxTokens <= 0) return "";
   if (s.length <= maxTokens) return s;
   if (s.length <= maxTokens * 4) {
-    const tokens = countTokens(s);
-    if (tokens <= maxTokens) return s;
+    const est = countTokensBounded(s);
+    if (Math.ceil(est * 1.15) <= maxTokens) return s;
+    if (est <= maxTokens) {
+      const tokens = countTokens(s);
+      if (tokens <= maxTokens) return s;
+    }
   }
   const markerOverhead = 48;
   const contentBudget = Math.max(0, maxTokens - markerOverhead);
@@ -6202,9 +6206,10 @@ function truncateForModelByTokens(s, maxTokens) {
   const ratio = sampleChars > 0 ? sampleTokens / sampleChars : 0.3;
   const estTotalTokens = Math.ceil(s.length * ratio);
   const droppedTokens = Math.max(0, estTotalTokens - sampleTokens);
+  const note = extraNote ? ` \u2014 ${extraNote}` : "";
   return `${head}
 
-[\u2026truncated ~${droppedTokens} tokens (${droppedChars} chars) \u2014 raise BridgeOptions.maxResultTokens, or call the tool with a narrower scope (filter, head, pagination)\u2026]
+[\u2026truncated ~${droppedTokens} tokens (${droppedChars} chars) \u2014 raise BridgeOptions.maxResultTokens, or call the tool with a narrower scope (filter, head, pagination)${note}\u2026]
 
 ${tail}`;
 }
@@ -6310,6 +6315,81 @@ function setByPath(target, path, value) {
   cur[path[path.length - 1]] = value;
 }
 
+// src/tools/truncated-result-saver.ts
+import { randomUUID } from "crypto";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { join, relative, resolve } from "path";
+var TRUNCATED_DIR = "truncated-results";
+var DEFAULT_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+function sanitizeToolName(name) {
+  return name.replace(/[^\w\-]/g, "_").slice(0, 48) || "unknown";
+}
+function storageDir(rootDir) {
+  const base = rootDir ? join(resolve(rootDir), ".reasonix") : join(homedir(), ".reasonix");
+  return join(base, TRUNCATED_DIR);
+}
+function resultFilename(toolName) {
+  const ts = Date.now().toString();
+  const suffix = randomUUID().slice(0, 8);
+  const safeName = sanitizeToolName(toolName);
+  return `${ts}-${suffix}-${safeName}.txt`;
+}
+function saveTruncatedResult(content, toolName, rootDir) {
+  cleanupOldResults(rootDir);
+  const dir = storageDir(rootDir);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const filename = resultFilename(toolName);
+  const absPath = join(dir, filename);
+  writeFileSync(absPath, content, "utf-8");
+  try {
+    chmodSync(absPath, 384);
+  } catch {
+  }
+  if (rootDir) {
+    const absRoot = resolve(rootDir);
+    return relative(absRoot, absPath).replaceAll("\\", "/");
+  }
+  return absPath.replaceAll("\\", "/");
+}
+function cleanupOldResults(rootDir, maxAgeMs = DEFAULT_MAX_AGE_MS) {
+  const dir = storageDir(rootDir);
+  if (!existsSync(dir)) return;
+  const cutoff = Date.now() - maxAgeMs;
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.endsWith(".txt")) continue;
+    const abs = join(dir, entry);
+    try {
+      const st = statSync(abs);
+      if (st.isFile() && st.mtimeMs < cutoff) {
+        rmSync(abs);
+      }
+    } catch {
+    }
+  }
+}
+function shouldSkipSave(toolName, skipTruncationSave) {
+  if (skipTruncationSave) return true;
+  const alwaysSkip = /* @__PURE__ */ new Set(["get_env", "everything_get-env"]);
+  return alwaysSkip.has(toolName);
+}
+
 // src/tools.ts
 var ToolRegistry = class {
   _tools = /* @__PURE__ */ new Map();
@@ -6487,7 +6567,20 @@ var ToolRegistry = class {
       if (opts.maxResultChars !== void 0) {
         clipped = truncateForModel(clipped, opts.maxResultChars);
       }
-      finalResult = clipped;
+      if (clipped !== str && !shouldSkipSave(name, tool?.skipTruncationSave)) {
+        const relPath = saveTruncatedResult(str, name, opts.rootDir ?? process.cwd());
+        const note = `Full result saved at: ${relPath}`;
+        let annotated = str;
+        if (opts.maxResultTokens !== void 0) {
+          annotated = truncateForModelByTokens(annotated, opts.maxResultTokens, note);
+        }
+        if (opts.maxResultChars !== void 0) {
+          annotated = truncateForModel(annotated, opts.maxResultChars, note);
+        }
+        finalResult = annotated;
+      } else {
+        finalResult = clipped;
+      }
     } catch (err) {
       const e = err;
       if (typeof e.toToolResult === "function") {
@@ -7054,8 +7147,88 @@ var InflightSet = class {
   }
 };
 
+// src/loop/dispatch.ts
+function readParallelMax() {
+  const raw = Number.parseInt(process.env.REASONIX_PARALLEL_MAX ?? "", 10);
+  return Number.isFinite(raw) && raw >= 1 ? Math.min(raw, 16) : 3;
+}
+function readDispatchSerial() {
+  return (process.env.REASONIX_TOOL_DISPATCH ?? "auto").toLowerCase() === "serial";
+}
+async function* dispatchToolCallsChunked(repairedCalls, ctx) {
+  const dispatchSerial = readDispatchSerial();
+  const parallelMax = readParallelMax();
+  let callIdx = 0;
+  while (callIdx < repairedCalls.length) {
+    const chunk = [];
+    if (!dispatchSerial) {
+      while (callIdx < repairedCalls.length && chunk.length < parallelMax && ctx.isParallelSafe(repairedCalls[callIdx]?.function?.name ?? "")) {
+        chunk.push(repairedCalls[callIdx++]);
+      }
+    }
+    if (chunk.length === 0) {
+      chunk.push(repairedCalls[callIdx++]);
+    }
+    for (const call of chunk) {
+      const callId = ctx.inflightIdFor(call);
+      ctx.inflightAdd(callId);
+      yield {
+        turn: ctx.turn,
+        role: "tool_start",
+        content: "",
+        toolName: call.function?.name ?? "",
+        toolArgs: call.function?.arguments ?? "{}",
+        callId
+      };
+    }
+    const settled = await Promise.allSettled(chunk.map((c) => ctx.runOne(c, ctx.signal)));
+    for (let k = 0; k < chunk.length; k++) {
+      const call = chunk[k];
+      const name = call.function?.name ?? "";
+      const args = call.function?.arguments ?? "{}";
+      const s = settled[k];
+      let result;
+      let preWarnings = [];
+      let postWarnings = [];
+      if (s.status === "fulfilled") {
+        preWarnings = s.value.preWarnings;
+        postWarnings = s.value.postWarnings;
+        result = s.value.result;
+      } else {
+        const err = s.reason instanceof Error ? s.reason : new Error(String(s.reason));
+        result = JSON.stringify({ error: `${err.name}: ${err.message}` });
+      }
+      for (const w of preWarnings) yield w;
+      for (const w of postWarnings) yield w;
+      const rateLimited = parseRateLimitedToolResult(result);
+      if (rateLimited && !ctx.rateLimitState.shown) {
+        ctx.rateLimitState.shown = true;
+        yield {
+          turn: ctx.turn,
+          role: "warning",
+          content: rateLimited.message
+        };
+      }
+      ctx.appendAndPersist({
+        role: "tool",
+        tool_call_id: call.id ?? "",
+        name,
+        content: result
+      });
+      yield {
+        turn: ctx.turn,
+        role: "tool",
+        content: result,
+        toolName: name,
+        toolArgs: args,
+        callId: ctx.inflightIdFor(call)
+      };
+    }
+  }
+}
+
 // src/loop/errors.ts
-function formatLoopError(err, probe) {
+function formatLoopError(err, probe, opts) {
   const msg = err.message ?? "";
   if (msg.includes("maximum context length")) {
     const reqMatch = msg.match(/requested\s+(\d+)\s+tokens/);
@@ -7072,7 +7245,7 @@ function formatLoopError(err, probe) {
   if (status === "422") return t("errors.badparam422", { inner });
   if (status === "400") return t("errors.badrequest400", { inner });
   if (status === "429") return t("errors.concurrency429", { inner });
-  if (is5xxStatus(status)) return formatDeepSeek5xx(status, probe);
+  if (is5xxStatus(status)) return format5xx(status, probe, opts?.upstreamHost);
   return msg;
 }
 function is5xxError(err) {
@@ -7084,15 +7257,40 @@ async function probeDeepSeekReachable(client, timeoutMs = 1500) {
   const balance = await client.getBalance({ signal: AbortSignal.timeout(timeoutMs) });
   return { reachable: balance !== null };
 }
+function isDeepSeekHost(baseUrl) {
+  if (!baseUrl) return false;
+  try {
+    const host = new URL(baseUrl).hostname.toLowerCase();
+    return host === "api.deepseek.com";
+  } catch {
+    return false;
+  }
+}
 function is5xxStatus(status) {
   return status === "500" || status === "502" || status === "503" || status === "504";
 }
+function format5xx(status, probe, upstreamHost) {
+  if (upstreamHost !== void 0 && !isDeepSeekHost(upstreamHost)) {
+    return formatUpstream5xx(status, upstreamHost);
+  }
+  return formatDeepSeek5xx(status, probe);
+}
 function formatDeepSeek5xx(status, probe) {
   const head = t("errors.deepseek5xxHead", { status });
   const probeNote = probe === void 0 ? "" : probe.reachable ? t("errors.deepseek5xxReachable") : t("errors.deepseek5xxUnreachable");
   const action = probe?.reachable === false ? t("errors.deepseek5xxActionNetwork") : t("errors.deepseek5xxActionRetry");
   return `${head}${probeNote}${action}`;
 }
+function formatUpstream5xx(status, baseUrl) {
+  let host = baseUrl;
+  try {
+    host = new URL(baseUrl).host || baseUrl;
+  } catch {
+  }
+  const head = t("errors.upstream5xxHead", { status, host });
+  const action = t("errors.upstream5xxActionRetry");
+  return `${head}${action}`;
+}
 function reasonPrefixFor(reason) {
   if (reason === "aborted") return t("errors.reasonAborted");
   if (reason === "context-guard") return t("errors.reasonContextGuard");
@@ -7205,6 +7403,56 @@ function shrinkOversizedToolResultsByTokens(messages, maxTokens) {
   });
   return { messages: out, healedCount, tokensSaved, charsSaved };
 }
+function shrinkOversizedToolCallArgsByTokens(messages, maxTokens) {
+  let healedCount = 0;
+  let tokensSaved = 0;
+  let charsSaved = 0;
+  const out = messages.map((msg) => {
+    if (msg.role !== "assistant" || !Array.isArray(msg.tool_calls)) return msg;
+    let changed = false;
+    const newCalls = msg.tool_calls.map((call) => {
+      const args = call.function?.arguments;
+      if (typeof args !== "string" || args.length <= maxTokens) return call;
+      const beforeTokens = countTokensBounded(args);
+      if (beforeTokens <= maxTokens) return call;
+      const shrunk = shrinkJsonLongStrings(args);
+      const afterTokens = countTokens(shrunk);
+      if (afterTokens >= beforeTokens) return call;
+      changed = true;
+      healedCount += 1;
+      tokensSaved += beforeTokens - afterTokens;
+      charsSaved += args.length - shrunk.length;
+      return { ...call, function: { ...call.function, arguments: shrunk } };
+    });
+    if (!changed) return msg;
+    return { ...msg, tool_calls: newCalls };
+  });
+  return { messages: out, healedCount, tokensSaved, charsSaved };
+}
+function shrinkJsonLongStrings(jsonStr) {
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonStr);
+  } catch {
+    const head = jsonStr.slice(0, 200);
+    return `${head}\u2026[shrunk: ${jsonStr.length} chars, unparsed]`;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return jsonStr;
+  }
+  const LONG_THRESHOLD = 300;
+  const input = parsed;
+  const output = {};
+  for (const [k, v] of Object.entries(input)) {
+    if (typeof v === "string" && v.length > LONG_THRESHOLD) {
+      const newlines = v.match(/\n/g)?.length ?? 0;
+      output[k] = `[\u2026shrunk: ${v.length} chars, ${newlines} lines \u2014 tool already responded, see result]`;
+    } else {
+      output[k] = v;
+    }
+  }
+  return JSON.stringify(output);
+}
 
 // src/loop/healing.ts
 var _stampSeq = 0;
@@ -7275,12 +7523,13 @@ function stampMissingReasoningForThinkingMode(messages, model) {
 function healLoadedMessagesByTokens(messages, maxTokens) {
   const shrunk = shrinkOversizedToolResultsByTokens(messages, maxTokens);
   const paired = fixToolCallPairing(shrunk.messages);
-  const healedCount = shrunk.healedCount + paired.droppedAssistantCalls + paired.droppedStrayTools;
+  const argsShrunk = shrinkOversizedToolCallArgsByTokens(paired.messages, maxTokens);
+  const healedCount = shrunk.healedCount + argsShrunk.healedCount + paired.droppedAssistantCalls + paired.droppedStrayTools;
   return {
-    messages: paired.messages,
+    messages: argsShrunk.messages,
     healedCount,
-    tokensSaved: shrunk.tokensSaved,
-    charsSaved: shrunk.charsSaved
+    tokensSaved: shrunk.tokensSaved + argsShrunk.tokensSaved,
+    charsSaved: shrunk.charsSaved + argsShrunk.charsSaved
   };
 }
 
@@ -7299,6 +7548,112 @@ function* hookWarnings(outcomes, turn) {
   }
 }
 
+// src/loop/reasoning-retention.ts
+function hasToolCalls(msg) {
+  return Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0;
+}
+function stripDroppableReasoningContent(messages) {
+  let lastUser = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "user") {
+      lastUser = i;
+      break;
+    }
+  }
+  if (lastUser < 0) {
+    return { messages, prunedCount: 0, charsDropped: 0 };
+  }
+  let next = null;
+  let prunedCount = 0;
+  let charsDropped = 0;
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role !== "assistant" || i > lastUser || hasToolCalls(msg) || !Object.hasOwn(msg, "reasoning_content")) {
+      continue;
+    }
+    if (next === null) next = messages.slice();
+    const { reasoning_content: dropped, ...replacement } = msg;
+    if (typeof dropped === "string") charsDropped += dropped.length;
+    next[i] = replacement;
+    prunedCount += 1;
+  }
+  return {
+    messages: next ?? messages,
+    prunedCount,
+    charsDropped
+  };
+}
+
+// src/loop/streaming.ts
+async function* streamModelResponse(opts) {
+  const { client, model, messages, toolSpecs, signal, reasoningEffort, turn } = opts;
+  let assistantContent = "";
+  let reasoningContent = "";
+  let usage = null;
+  const callBuf = /* @__PURE__ */ new Map();
+  const readyIndices = /* @__PURE__ */ new Set();
+  for await (const chunk of client.stream({
+    model,
+    messages,
+    tools: toolSpecs.length ? toolSpecs : void 0,
+    signal,
+    thinking: thinkingModeForModel(model),
+    reasoningEffort
+  })) {
+    if (chunk.reasoningDelta) {
+      reasoningContent += chunk.reasoningDelta;
+      yield {
+        turn,
+        role: "assistant_delta",
+        content: "",
+        reasoningDelta: chunk.reasoningDelta
+      };
+    }
+    if (chunk.contentDelta) {
+      assistantContent += chunk.contentDelta;
+      yield {
+        turn,
+        role: "assistant_delta",
+        content: chunk.contentDelta
+      };
+    }
+    if (chunk.toolCallDelta) {
+      const d = chunk.toolCallDelta;
+      const cur = callBuf.get(d.index) ?? {
+        id: d.id,
+        type: "function",
+        function: { name: "", arguments: "" }
+      };
+      if (d.id) cur.id = d.id;
+      if (d.name) cur.function.name = (cur.function.name ?? "") + d.name;
+      if (d.argumentsDelta)
+        cur.function.arguments = (cur.function.arguments ?? "") + d.argumentsDelta;
+      callBuf.set(d.index, cur);
+      if (!readyIndices.has(d.index) && cur.function.name && looksLikeCompleteJson(cur.function.arguments ?? "")) {
+        readyIndices.add(d.index);
+      }
+      if (cur.function.name) {
+        yield {
+          turn,
+          role: "tool_call_delta",
+          content: "",
+          toolName: cur.function.name,
+          toolCallArgsChars: (cur.function.arguments ?? "").length,
+          toolCallIndex: d.index,
+          toolCallReadyCount: readyIndices.size
+        };
+      }
+    }
+    if (chunk.usage) usage = chunk.usage;
+  }
+  return {
+    assistantContent,
+    reasoningContent,
+    toolCalls: [...callBuf.values()],
+    usage
+  };
+}
+
 // src/repair/scavenge.ts
 var MAX_SCAVENGE_INPUT = 100 * 1024;
 function scavengeToolCalls(reasoningContent, opts) {
@@ -7656,6 +8011,10 @@ var MID_TURN_STEER_WRAPPER = "[Mid-turn steer queued by the user. Do not treat t
 function formatSteerUserMessage(content) {
   return [MID_TURN_STEER_WRAPPER, content].join("\n");
 }
+function shrinkMessageForRetention(message) {
+  if (message.role !== "assistant" || !Array.isArray(message.tool_calls)) return message;
+  return shrinkOversizedToolCallArgsByTokens([message], DEFAULT_MAX_RESULT_TOKENS).messages[0] ?? message;
+}
 var CacheFirstLoop = class {
   client;
   prefix;
@@ -7749,7 +8108,8 @@ var CacheFirstLoop = class {
       const prior = loadSessionMessages(this.sessionName);
       const shrunk = healLoadedMessagesByTokens(prior, DEFAULT_MAX_RESULT_TOKENS);
       const stamped = stampMissingReasoningForThinkingMode(shrunk.messages, this.model);
-      const messages = stamped.messages;
+      const pruned = stripDroppableReasoningContent(stamped.messages);
+      const messages = pruned.messages;
       const healedCount = shrunk.healedCount + stamped.stampedCount;
       const tokensSaved = shrunk.tokensSaved;
       for (const msg of messages) this.log.append(msg);
@@ -7766,15 +8126,17 @@ var CacheFirstLoop = class {
           lastPromptTokens: meta.lastPromptTokens
         });
       }
-      if (healedCount > 0) {
+      if (healedCount > 0 || pruned.prunedCount > 0) {
         try {
           rewriteSession(this.sessionName, messages);
         } catch {
         }
-        process.stderr.write(
-          `\u25B8 session "${this.sessionName}": healed ${healedCount} entr${healedCount === 1 ? "y" : "ies"}${tokensSaved > 0 ? ` (shrunk ${tokensSaved.toLocaleString()} tokens of oversized tool output)` : " (dropped dangling tool_calls tail)"}. Rewrote session file.
+        if (healedCount > 0) {
+          process.stderr.write(
+            `\u25B8 session "${this.sessionName}": healed ${healedCount} entr${healedCount === 1 ? "y" : "ies"}${tokensSaved > 0 ? ` (shrunk ${tokensSaved.toLocaleString()} tokens of oversized tool output/arguments)` : " (dropped dangling tool_calls tail)"}. Rewrote session file.
 `
-        );
+          );
+        }
       }
     } else {
       this.resumedMessageCount = 0;
@@ -7801,21 +8163,23 @@ var CacheFirstLoop = class {
     return this.context.getLogTokens();
   }
   appendAndPersist(message) {
-    this.log.append(message);
+    const retained = shrinkMessageForRetention(message);
+    this.log.append(retained);
     if (this.sessionName) {
       try {
-        appendSessionMessage(this.sessionName, message);
+        appendSessionMessage(this.sessionName, retained);
       } catch {
       }
     }
   }
   /** Swap the just-appended assistant entry — used by self-correction to restore the original tool_calls without dropping reasoning_content. */
   replaceTailAssistantMessage(message) {
+    const retained = shrinkMessageForRetention(message);
     const entries = this.log.entries;
     const tail = entries[entries.length - 1];
     if (!tail || tail.role !== "assistant") return;
     const kept = entries.slice(0, -1);
-    kept.push(message);
+    kept.push(retained);
     this.log.compactInPlace(kept);
     if (this.sessionName) {
       try {
@@ -7841,6 +8205,8 @@ var CacheFirstLoop = class {
     this.stats.reset();
     this._turn = 0;
     this._budgetWarned = false;
+    this._steerQueue.length = 0;
+    this._steerConsumed = false;
     let systemRebuilt = false;
     if (this._rebuildSystem) {
       try {
@@ -7864,6 +8230,8 @@ var CacheFirstLoop = class {
     this.log.compactInPlace([]);
     this.scratch.reset();
     this._inflight.clear();
+    this._steerQueue.length = 0;
+    this._steerConsumed = false;
     this.sessionName = opts.sessionName;
     if (this._rebuildSystem) {
       try {
@@ -7941,7 +8309,8 @@ ${reason}`
         signal,
         maxResultTokens: DEFAULT_MAX_RESULT_TOKENS,
         confirmationGate: this.confirmationGate,
-        readTracker: this.readTracker
+        readTracker: this.readTracker,
+        rootDir: this.hookCwd
       });
       const postReport = await runHooks({
         hooks: this.hooks,
@@ -7976,15 +8345,22 @@ ${reason}`
   healActiveLogBeforeSend() {
     const current = this.log.toMessages();
     const healed = healLoadedMessages(current, DEFAULT_MAX_RESULT_CHARS);
-    if (healed.healedCount === 0) return current;
-    this.log.compactInPlace(healed.messages);
+    const argsShrunk = shrinkOversizedToolCallArgsByTokens(
+      healed.messages,
+      DEFAULT_MAX_RESULT_TOKENS
+    );
+    const pruned = stripDroppableReasoningContent(argsShrunk.messages);
+    if (healed.healedCount === 0 && argsShrunk.healedCount === 0 && pruned.prunedCount === 0) {
+      return current;
+    }
+    this.log.compactInPlace(pruned.messages);
     if (this.sessionName) {
       try {
-        rewriteSession(this.sessionName, healed.messages);
+        rewriteSession(this.sessionName, pruned.messages);
       } catch {
       }
     }
-    return healed.messages;
+    return pruned.messages;
   }
   abort(opts = {}) {
     if (opts.discardCurrentTurn) this._discardAbortRequested = true;
@@ -8094,7 +8470,7 @@ ${reason}`
     const turnStartLogIndex = this.log.length;
     this.appendAndPersist({ role: "user", content: userInput });
     const toolSpecs = this.prefix.tools();
-    let rateLimitWarningShown = false;
+    const rateLimitState = { shown: false };
     {
       const turnStart = this.context.estimateTurnStart(
         this.buildMessages(),
@@ -8107,7 +8483,9 @@ ${reason}`
           role: "status",
           content: t("loop.turnStartFoldStatus")
         };
-        const result = await this.context.fold(this.model, { requireTailBoundary: true });
+        const result = await this.context.fold(this.model, {
+          requireTailBoundary: true
+        });
         if (result.folded) {
           this._foldedThisTurn = true;
           yield {
@@ -8175,64 +8553,19 @@ ${reason}`
       let usage = null;
       try {
         if (this.stream) {
-          const callBuf = /* @__PURE__ */ new Map();
-          const readyIndices = /* @__PURE__ */ new Set();
-          const callModel = this.model;
-          for await (const chunk of this.client.stream({
-            model: callModel,
+          const result = yield* streamModelResponse({
+            client: this.client,
+            model: this.model,
             messages,
-            tools: toolSpecs.length ? toolSpecs : void 0,
+            toolSpecs,
             signal,
-            thinking: thinkingModeForModel(callModel),
-            reasoningEffort: this.reasoningEffort
-          })) {
-            if (chunk.reasoningDelta) {
-              reasoningContent += chunk.reasoningDelta;
-              yield {
-                turn: this._turn,
-                role: "assistant_delta",
-                content: "",
-                reasoningDelta: chunk.reasoningDelta
-              };
-            }
-            if (chunk.contentDelta) {
-              assistantContent += chunk.contentDelta;
-              yield {
-                turn: this._turn,
-                role: "assistant_delta",
-                content: chunk.contentDelta
-              };
-            }
-            if (chunk.toolCallDelta) {
-              const d = chunk.toolCallDelta;
-              const cur = callBuf.get(d.index) ?? {
-                id: d.id,
-                type: "function",
-                function: { name: "", arguments: "" }
-              };
-              if (d.id) cur.id = d.id;
-              if (d.name) cur.function.name = (cur.function.name ?? "") + d.name;
-              if (d.argumentsDelta)
-                cur.function.arguments = (cur.function.arguments ?? "") + d.argumentsDelta;
-              callBuf.set(d.index, cur);
-              if (!readyIndices.has(d.index) && cur.function.name && looksLikeCompleteJson(cur.function.arguments ?? "")) {
-                readyIndices.add(d.index);
-              }
-              if (cur.function.name) {
-                yield {
-                  turn: this._turn,
-                  role: "tool_call_delta",
-                  content: "",
-                  toolName: cur.function.name,
-                  toolCallArgsChars: (cur.function.arguments ?? "").length,
-                  toolCallIndex: d.index,
-                  toolCallReadyCount: readyIndices.size
-                };
-              }
-            }
-            if (chunk.usage) usage = chunk.usage;
-          }
-          toolCalls = [...callBuf.values()];
+            reasoningEffort: this.reasoningEffort,
+            turn: this._turn
+          });
+          assistantContent = result.assistantContent;
+          reasoningContent = result.reasoningContent;
+          toolCalls = result.toolCalls;
+          usage = result.usage;
         } else {
           const callModel = this.model;
           const resp = await this.client.chat({
@@ -8259,12 +8592,14 @@ ${reason}`
           this._steerQueue.length = 0;
           return;
         }
-        const probe = is5xxError(err) ? await probeDeepSeekReachable(this.client) : void 0;
+        const upstreamHost = this.client.baseUrl;
+        const dsHost = isDeepSeekHost(upstreamHost);
+        const probe = is5xxError(err) && dsHost ? await probeDeepSeekReachable(this.client) : void 0;
         yield {
           turn: this._turn,
           role: "error",
           content: "",
-          error: formatLoopError(err, probe)
+          error: formatLoopError(err, probe, { upstreamHost })
         };
         this._steerQueue.length = 0;
         return;
@@ -8390,76 +8725,16 @@ ${reason}`
         this._steerQueue.length = 0;
         return;
       }
-      const dispatchSerial = (process.env.REASONIX_TOOL_DISPATCH ?? "auto").toLowerCase() === "serial";
-      const parallelMaxParsed = Number.parseInt(process.env.REASONIX_PARALLEL_MAX ?? "", 10);
-      const parallelMax = Number.isFinite(parallelMaxParsed) && parallelMaxParsed >= 1 ? Math.min(parallelMaxParsed, 16) : 3;
-      let callIdx = 0;
-      while (callIdx < repairedCalls.length) {
-        const chunk = [];
-        if (!dispatchSerial) {
-          while (callIdx < repairedCalls.length && chunk.length < parallelMax && this.tools.isParallelSafe(repairedCalls[callIdx]?.function?.name ?? "")) {
-            chunk.push(repairedCalls[callIdx++]);
-          }
-        }
-        if (chunk.length === 0) {
-          chunk.push(repairedCalls[callIdx++]);
-        }
-        for (const call of chunk) {
-          const callId = this.inflightIdFor(call);
-          this._inflight.add(callId);
-          yield {
-            turn: this._turn,
-            role: "tool_start",
-            content: "",
-            toolName: call.function?.name ?? "",
-            toolArgs: call.function?.arguments ?? "{}",
-            callId
-          };
-        }
-        const settled = await Promise.allSettled(chunk.map((c) => this.runOneToolCall(c, signal)));
-        for (let k = 0; k < chunk.length; k++) {
-          const call = chunk[k];
-          const name = call.function?.name ?? "";
-          const args = call.function?.arguments ?? "{}";
-          const s = settled[k];
-          let result;
-          let preWarnings = [];
-          let postWarnings = [];
-          if (s.status === "fulfilled") {
-            preWarnings = s.value.preWarnings;
-            postWarnings = s.value.postWarnings;
-            result = s.value.result;
-          } else {
-            const err = s.reason instanceof Error ? s.reason : new Error(String(s.reason));
-            result = JSON.stringify({ error: `${err.name}: ${err.message}` });
-          }
-          for (const w of preWarnings) yield w;
-          for (const w of postWarnings) yield w;
-          const rateLimited = parseRateLimitedToolResult(result);
-          if (rateLimited && !rateLimitWarningShown) {
-            rateLimitWarningShown = true;
-            yield {
-              turn: this._turn,
-              role: "warning",
-              content: rateLimited.message
-            };
-          }
-          this.appendAndPersist({
-            role: "tool",
-            tool_call_id: call.id ?? "",
-            name,
-            content: result
-          });
-          yield {
-            turn: this._turn,
-            role: "tool",
-            content: result,
-            toolName: name,
-            toolArgs: args,
-            callId: this.inflightIdFor(call)
-          };
-        }
-      }
+      yield* dispatchToolCallsChunked(repairedCalls, {
+        turn: this._turn,
+        signal,
+        isParallelSafe: (name) => this.tools.isParallelSafe(name),
+        inflightIdFor: (call) => this.inflightIdFor(call),
+        inflightAdd: (id) => this._inflight.add(id),
+        runOne: (call, sig) => this.runOneToolCall(call, sig),
+        appendAndPersist: (m) => this.appendAndPersist(m),
+        rateLimitState
+      });
     }
   }
   summaryContext() {
@@ -8489,9 +8764,9 @@ function parsePositiveIntEnv(raw) {
 }
 
 // src/at-mentions.ts
-import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { existsSync as existsSync2, readFileSync, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import { readdir, stat } from "fs/promises";
-import { isAbsolute, join, relative, resolve as resolve2 } from "path";
+import { isAbsolute, join as join2, relative as relative2, resolve as resolve3 } from "path";
 
 // src/at-mentions-url.ts
 var AT_URL_PATTERN = /(?<=^|\s)@(https?:\/\/\S+)/g;
@@ -8622,7 +8897,7 @@ function listFilesSync(root, opts = {}) {
 function listFilesWithStatsSync(root, opts = {}) {
   const maxResults = Math.max(1, opts.maxResults ?? 2e3);
   const ignoreDirs = new Set(opts.ignoreDirs ?? DEFAULT_PICKER_IGNORE_DIRS);
-  const rootAbs = resolve2(root);
+  const rootAbs = resolve3(root);
   const respectGi = opts.respectGitignore !== false;
   const out = [];
   const walk2 = (dirAbs, dirRel, layers) => {
@@ -8634,7 +8909,7 @@ function listFilesWithStatsSync(root, opts = {}) {
     }
     let entries;
     try {
-      entries = readdirSync(dirAbs, { withFileTypes: true });
+      entries = readdirSync2(dirAbs, { withFileTypes: true });
     } catch {
       return;
     }
@@ -8642,7 +8917,7 @@ function listFilesWithStatsSync(root, opts = {}) {
     for (const ent of entries) {
       if (out.length >= maxResults) return;
       const relPath = dirRel ? `${dirRel}/${ent.name}` : ent.name;
-      const absPath = join(dirAbs, ent.name);
+      const absPath = join2(dirAbs, ent.name);
       if (ent.isDirectory()) {
         if (ent.name.startsWith(".") || ignoreDirs.has(ent.name)) continue;
         if (ignoredByLayers(effectiveLayers, absPath, true)) continue;
@@ -8651,14 +8926,14 @@ function listFilesWithStatsSync(root, opts = {}) {
         if (ignoredByLayers(effectiveLayers, absPath, false)) continue;
         let mtimeMs = 0;
         try {
-          mtimeMs = statSync(absPath).mtimeMs;
+          mtimeMs = statSync2(absPath).mtimeMs;
         } catch {
         }
         out.push({ path: relPath, mtimeMs });
       } else if (ent.isSymbolicLink()) {
         let target = null;
         try {
-          target = statSync(absPath);
+          target = statSync2(absPath);
         } catch {
           continue;
         }
@@ -8686,7 +8961,7 @@ async function listFilesWithStatsAsync(root, opts = {}) {
 async function walkFilesStream(root, opts) {
   const ignoreDirs = new Set(opts.ignoreDirs ?? DEFAULT_PICKER_IGNORE_DIRS);
   const respectGi = opts.respectGitignore !== false;
-  const rootAbs = resolve2(root);
+  const rootAbs = resolve3(root);
   const progressGap = Math.max(0, opts.progressIntervalMs ?? 100);
   let scanned = 0;
   let halted = false;
@@ -8722,7 +8997,7 @@ async function walkFilesStream(root, opts) {
     const fileEnts = [];
     for (const ent of entries) {
       if (halted || opts.signal?.aborted) break;
-      const absPath = join(dirAbs, ent.name);
+      const absPath = join2(dirAbs, ent.name);
       if (ent.isDirectory()) {
         if (ent.name.startsWith(".") || ignoreDirs.has(ent.name)) continue;
         if (ignoredByLayers(effectiveLayers, absPath, true)) continue;
@@ -8745,10 +9020,10 @@ async function walkFilesStream(root, opts) {
   return { scanned, cancelled: !!opts.signal?.aborted };
 }
 async function flushFiles(ents, dirAbs, dirRel, layers, emit) {
-  const accepted = ents.filter((e) => !ignoredByLayers(layers, join(dirAbs, e.name), false));
+  const accepted = ents.filter((e) => !ignoredByLayers(layers, join2(dirAbs, e.name), false));
   const stats = await Promise.all(
     accepted.map(
-      (e) => stat(join(dirAbs, e.name)).then((s) => ({ mtimeMs: s.mtimeMs, isFile: s.isFile() })).catch(() => null)
+      (e) => stat(join2(dirAbs, e.name)).then((s) => ({ mtimeMs: s.mtimeMs, isFile: s.isFile() })).catch(() => null)
     )
   );
   for (let i = 0; i < accepted.length; i++) {
@@ -8761,13 +9036,17 @@ async function flushFiles(ents, dirAbs, dirRel, layers, emit) {
     });
   }
 }
+var listDirectoryCache = new TtlLruCache(64, 5e3);
 async function listDirectory(root, relDir, opts = {}) {
   const ignoreDirs = new Set(opts.ignoreDirs ?? DEFAULT_PICKER_IGNORE_DIRS);
   const respectGi = opts.respectGitignore !== false;
-  const rootAbs = resolve2(root);
-  const dirAbs = resolve2(rootAbs, relDir);
-  const rel = relative(rootAbs, dirAbs);
+  const rootAbs = resolve3(root);
+  const dirAbs = resolve3(rootAbs, relDir);
+  const rel = relative2(rootAbs, dirAbs);
   if (rel.startsWith("..") || isAbsolute(rel)) return [];
+  const cacheKey = `${dirAbs}\0${respectGi ? "g" : ""}\0${[...ignoreDirs].sort().join(",")}`;
+  const cached = listDirectoryCache.get(cacheKey);
+  if (cached) return cached;
   const layers = [];
   if (respectGi) {
     const segs = rel ? rel.split(/[\\/]/) : [];
@@ -8775,7 +9054,7 @@ async function listDirectory(root, relDir, opts = {}) {
     const ig = await loadGitignoreAt(cursor);
     if (ig) layers.push({ dirAbs: cursor, ig });
     for (const seg of segs) {
-      cursor = join(cursor, seg);
+      cursor = join2(cursor, seg);
       const igSeg = await loadGitignoreAt(cursor);
       if (igSeg) layers.push({ dirAbs: cursor, ig: igSeg });
     }
@@ -8790,7 +9069,7 @@ async function listDirectory(root, relDir, opts = {}) {
   const dirs = [];
   const files = [];
   for (const ent of raw) {
-    const absPath = join(dirAbs, ent.name);
+    const absPath = join2(dirAbs, ent.name);
     if (ent.isDirectory()) {
       if (ent.name.startsWith(".") || ignoreDirs.has(ent.name)) continue;
       if (ignoredByLayers(layers, absPath, true)) continue;
@@ -8807,7 +9086,7 @@ async function listDirectory(root, relDir, opts = {}) {
   }
   const stats = await Promise.all(
     files.map(
-      (e) => stat(join(dirAbs, e.name)).then((s) => ({ mtimeMs: s.mtimeMs, isFile: s.isFile() })).catch(() => null)
+      (e) => stat(join2(dirAbs, e.name)).then((s) => ({ mtimeMs: s.mtimeMs, isFile: s.isFile() })).catch(() => null)
     )
   );
   const fileEntries = [];
@@ -8824,7 +9103,9 @@ async function listDirectory(root, relDir, opts = {}) {
   }
   dirs.sort((a, b) => a.name.localeCompare(b.name));
   fileEntries.sort((a, b) => a.name.localeCompare(b.name));
-  return [...dirs, ...fileEntries];
+  const result = [...dirs, ...fileEntries];
+  listDirectoryCache.set(cacheKey, result);
+  return result;
 }
 function parseAtQuery(query) {
   const normalized = query.replace(/\\/g, "/");
@@ -8930,7 +9211,7 @@ function expandAtMentions(text, rootDir, opts = {}) {
   const maxBytes = opts.maxBytes ?? DEFAULT_AT_MENTION_MAX_BYTES;
   const maxDirEntries = Math.max(1, opts.maxDirEntries ?? DEFAULT_AT_DIR_MAX_ENTRIES);
   const fs4 = opts.fs ?? defaultFs;
-  const root = resolve2(rootDir);
+  const root = resolve3(rootDir);
   const seen = /* @__PURE__ */ new Map();
   const expansions = [];
   const dirListings = /* @__PURE__ */ new Map();
@@ -8977,8 +9258,8 @@ function resolveMention(rawPath, root, maxBytes, maxDirEntries, fs4, dirListings
   if (isAbsolute(rawPath)) {
     return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "escape" };
   }
-  const resolved = resolve2(root, rawPath);
-  const rel = relative(root, resolved);
+  const resolved = resolve3(root, rawPath);
+  const rel = relative2(root, resolved);
   if (rel.startsWith("..") || isAbsolute(rel)) {
     return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "escape" };
   }
@@ -9007,7 +9288,7 @@ function resolveMention(rawPath, root, maxBytes, maxDirEntries, fs4, dirListings
   return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "not-file" };
 }
 function readSafe(root, rawPath, fs4) {
-  const resolved = resolve2(root, rawPath);
+  const resolved = resolve3(root, rawPath);
   try {
     return fs4.read(resolved);
   } catch {
@@ -9015,23 +9296,23 @@ function readSafe(root, rawPath, fs4) {
   }
 }
 var defaultFs = {
-  exists: (p) => existsSync(p),
+  exists: (p) => existsSync2(p),
   isFile: (p) => {
     try {
-      return statSync(p).isFile();
+      return statSync2(p).isFile();
     } catch {
       return false;
     }
   },
   isDir: (p) => {
     try {
-      return statSync(p).isDirectory();
+      return statSync2(p).isDirectory();
     } catch {
       return false;
     }
   },
   listDir: (dirAbs, root, max) => {
-    const dirRel = relative(root, dirAbs).split(/[\\/]/).join("/");
+    const dirRel = relative2(root, dirAbs).split(/[\\/]/).join("/");
     const walkCap = Math.max(max * 4, 5e3);
     const all = listFilesSync(root, { maxResults: walkCap });
     const prefix = dirRel ? `${dirRel}/` : "";
@@ -9043,7 +9324,7 @@ var defaultFs = {
   },
   size: (p) => {
     try {
-      return statSync(p).size;
+      return statSync2(p).size;
     } catch {
       return 0;
     }
@@ -9976,21 +10257,21 @@ import { promises as fs3 } from "fs";
 import * as pathMod5 from "path";
 
 // src/memory/subdir.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { dirname, join as join2, relative as relative2, resolve as resolve3 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { dirname, join as join3, relative as relative3, resolve as resolve4 } from "path";
 function findDirMemory(absDir, rootDir) {
-  const root = resolve3(rootDir);
-  const target = resolve3(absDir);
-  const rel = relative2(root, target);
+  const root = resolve4(rootDir);
+  const target = resolve4(absDir);
+  const rel = relative3(root, target);
   if (rel.startsWith("..")) return [];
   const found = [];
   let cur = target;
   while (cur !== root) {
-    const r = relative2(root, cur);
+    const r = relative3(root, cur);
     if (!r || r.startsWith("..")) break;
     for (const name of PROJECT_MEMORY_FILES) {
-      const path = join2(cur, name);
-      if (existsSync2(path)) {
+      const path = join3(cur, name);
+      if (existsSync3(path)) {
         found.push(path);
         break;
       }
@@ -10002,7 +10283,7 @@ function findDirMemory(absDir, rootDir) {
   return found;
 }
 function findSubdirMemoryAncestors(absPath, rootDir) {
-  return findDirMemory(dirname(resolve3(absPath)), rootDir);
+  return findDirMemory(dirname(resolve4(absPath)), rootDir);
 }
 function readSubdirMemoryContent(path) {
   let raw;
@@ -10304,7 +10585,7 @@ var RegexRunner = class {
     this.defaultTimeoutMs = opts.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS;
   }
   testLines(text, source, flags, opts = {}) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       if (opts.signal?.aborted) {
         reject(new Error("regex evaluation aborted"));
         return;
@@ -10317,7 +10598,7 @@ var RegexRunner = class {
         this.killWorker();
         reject(new Error(`regex evaluation exceeded ${timeoutMs}ms`));
       }, timeoutMs);
-      const entry = { resolve: resolve6, reject, timer };
+      const entry = { resolve: resolve7, reject, timer };
       if (opts.signal) {
         entry.signal = opts.signal;
         entry.onAbort = () => {
@@ -10448,6 +10729,7 @@ async function searchFiles(ctx, startAbs, args) {
 var MAX_HITS_PER_FILE = 30;
 var SUMMARY_MODE_TRIGGER_RATIO = 0.8;
 var WALK_DEADLINE_MS = 12e4;
+var REGEX_METACHARS = /[\\.+*?()[\]{}|^$]/;
 async function searchContent(ctx, startAbs, args) {
   throwIfAborted(args.signal);
   const caseSensitive = args.case_sensitive === true;
@@ -10455,12 +10737,15 @@ async function searchContent(ctx, startAbs, args) {
   const ctxLines = Math.max(0, Math.min(20, Math.floor(args.context ?? 0)));
   const summaryOnly = args.summary_only === true;
   const reFlags = caseSensitive ? "" : "i";
+  const hasMeta = REGEX_METACHARS.test(args.pattern);
   let reSource = null;
-  try {
-    new RegExp(args.pattern, reFlags);
-    reSource = args.pattern;
-  } catch {
-    reSource = null;
+  if (hasMeta) {
+    try {
+      new RegExp(args.pattern, reFlags);
+      reSource = args.pattern;
+    } catch {
+      reSource = null;
+    }
   }
   const needle = caseSensitive ? args.pattern : args.pattern.toLowerCase();
   const matches = [];
@@ -10549,9 +10834,10 @@ async function searchContent(ctx, startAbs, args) {
       if (firstNul !== -1 && firstNul < 8 * 1024) continue;
       const text = raw.toString("utf8");
       const rel = displayRel2(ctx.rootDir, full);
-      const lines = text.split(/\r?\n/);
       let hits;
+      let lines;
       if (reSource !== null) {
+        lines = text.split(/\r?\n/);
         try {
           hits = await getRegexRunner().testLines(text, reSource, reFlags, {
             signal: args.signal
@@ -10563,9 +10849,14 @@ async function searchContent(ctx, startAbs, args) {
           continue;
         }
       } else {
+        const haystack = caseSensitive ? text : text.toLowerCase();
+        if (haystack.indexOf(needle) === -1) {
+          scanned++;
+          continue;
+        }
+        lines = text.split(/\r?\n/);
         hits = [];
         for (let li = 0; li < lines.length; li++) {
-          throwIfAborted(args.signal);
           const lineForCheck = caseSensitive ? lines[li] : lines[li].toLowerCase();
           if (lineForCheck.includes(needle)) hits.push(li);
         }
@@ -10773,6 +11064,7 @@ ${body}`;
   registry.register({
     name: "read_file",
     parallelSafe: true,
+    skipTruncationSave: true,
     description: `Read a file under the sandbox root. Default returns FULL CONTENT for files \u2264 ${Math.round(DEFAULT_OUTLINE_THRESHOLD_BYTES / 1024)} KiB. Optional scoping: head/tail (N lines), range "A-B" (1-indexed inclusive). Larger files auto-switch to outline mode (metadata + head + symbol outline for TS/JS/Python/Go/Rust/Markdown/Protobuf/text) \u2014 drill in with range or search_content. Files over ${Math.round(HARD_MAX_FILE_BYTES / (1024 * 1024))} MiB and binaries are refused \u2014 use get_file_info for stat.`,
     readOnly: true,
     stormExempt: true,
@@ -10870,6 +11162,7 @@ ${slice.join("\n")}`);
   registry.register({
     name: "list_directory",
     parallelSafe: true,
+    skipTruncationSave: true,
     description: "List entries in a directory under the sandbox root. Returns one line per entry, marking directories with a trailing slash. Not recursive \u2014 use directory_tree for that.",
     readOnly: true,
     stormExempt: true,
@@ -10892,6 +11185,7 @@ ${slice.join("\n")}`);
   registry.register({
     name: "directory_tree",
     parallelSafe: true,
+    skipTruncationSave: true,
     description: `Recursively list entries with indented tree structure (dirs marked '/'). Budget-aware: maxDepth defaults to 2, large subtrees (>50 children) auto-collapse to "[N hidden \u2014 list_directory to inspect]", and ${[...SKIP_DIR_NAMES].sort().join(" / ")} are skipped unless include_deps:true. For single-level use list_directory; for path lookups use search_files; for code lookups use search_content.`,
     readOnly: true,
     parameters: {
@@ -10967,6 +11261,7 @@ ${slice.join("\n")}`);
   registry.register({
     name: "search_files",
     parallelSafe: true,
+    skipTruncationSave: true,
     description: "Find files whose NAME matches a substring or regex. Case-insensitive. Walks the directory recursively under the sandbox root. Returns one path per line. Skips dependency / VCS / build directories (node_modules, .git, dist, build, .next, target, .venv) by default.",
     readOnly: true,
     parameters: {
@@ -10993,6 +11288,7 @@ ${slice.join("\n")}`);
   registry.register({
     name: "search_content",
     parallelSafe: true,
+    skipTruncationSave: true,
     description: "Recursively grep file CONTENTS for a substring or regex \u2014 'where is X called', 'what files contain Y'. Returns one match per line as `path:line: text`. Per-file hit cap 30; when the byte budget is mostly spent, remaining files switch to a `rel: N matches` histogram. Pass `summary_only:true` for just the histogram. Skips dependency / VCS / build dirs and binary files. For file NAMES use search_files.",
     readOnly: true,
     parameters: {
@@ -11044,6 +11340,7 @@ ${slice.join("\n")}`);
   registry.register({
     name: "glob",
     parallelSafe: true,
+    skipTruncationSave: true,
     description: "List files matching a glob pattern, sorted by mtime (most-recently-modified first) by default. Use this for 'what changed lately', 'find all *.test.ts', 'all configs under src/'. Glob syntax matches the cross-tool standard: `*` (any chars in one segment), `**` (any segments), `?` (one char), `{a,b}` (alternation). Pattern matches against the path RELATIVE to the search root (e.g. 'src/**/*.ts' from project root). Skips node_modules / .git / dist / build / etc by default. Default limit 200; raise via `limit` (max 1000). Different from `search_files` (substring on basename) and `search_content` (matches inside file contents).",
     readOnly: true,
     parameters: {
@@ -11082,6 +11379,7 @@ ${slice.join("\n")}`);
   registry.register({
     name: "get_file_info",
     parallelSafe: true,
+    skipTruncationSave: true,
     description: "Stat a path under the sandbox root. Returns type (file|directory|symlink), size in bytes, mtime in ISO-8601.",
     readOnly: true,
     parameters: {
@@ -12017,19 +12315,22 @@ function forkRegistryWithAllowList(parent, allow, alsoExclude) {
 
 // src/code/edit-blocks.ts
 import {
+  chmodSync as chmodSync2,
   closeSync,
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   fstatSync,
-  ftruncateSync,
-  mkdirSync,
+  fsyncSync,
+  mkdirSync as mkdirSync2,
   openSync,
   readFileSync as readFileSync3,
   readSync,
+  realpathSync,
+  renameSync,
   unlinkSync,
-  writeFileSync,
+  writeFileSync as writeFileSync2,
   writeSync
 } from "fs";
-import { dirname as dirname3, isAbsolute as isAbsolute3, relative as relative6, resolve as resolve5 } from "path";
+import { dirname as dirname3, isAbsolute as isAbsolute3, relative as relative7, resolve as resolve6 } 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) {
   const out = [];
@@ -12047,15 +12348,15 @@ function parseEditBlocks(text) {
   return out;
 }
 function resolveEditPath(rootDir, rawPath) {
-  const absRoot = resolve5(rootDir);
+  const absRoot = resolve6(rootDir);
   if (/^[A-Za-z]:[\\/]/.test(rawPath) || looksLikeAbsoluteSystemPath2(rawPath)) {
-    return resolve5(rawPath);
+    return resolve6(rawPath);
   }
   let rooted = rawPath;
   while (rooted.startsWith("/") || rooted.startsWith("\\")) {
     rooted = rooted.slice(1);
   }
-  return resolve5(absRoot, rooted || ".");
+  return resolve6(absRoot, rooted || ".");
 }
 function looksLikeAbsoluteSystemPath2(rawPath) {
   return /^\/(?:home|Users|etc|var|opt|tmp|usr|mnt|Library|Volumes|proc|sys|dev|run|srv|media|Applications|System|root|boot|private)(?:[/\\]|$)/.test(
@@ -12063,11 +12364,59 @@ function looksLikeAbsoluteSystemPath2(rawPath) {
   );
 }
 function pathIsUnder2(child, parent) {
-  const rel = relative6(parent, child);
+  const rel = relative7(parent, child);
   return rel === "" || !rel.startsWith("..") && !isAbsolute3(rel);
 }
+function writeAllSync(fd, buf) {
+  let written = 0;
+  while (written < buf.length) {
+    const n = writeSync(fd, buf, written, buf.length - written, written);
+    if (n <= 0) throw new Error("write returned 0 bytes before completing");
+    written += n;
+  }
+}
+function fsyncDirectoryBestEffort(path) {
+  let fd;
+  try {
+    fd = openSync(path, "r");
+    fsyncSync(fd);
+  } catch {
+  } finally {
+    if (fd !== void 0) closeSync(fd);
+  }
+}
+function atomicReplaceFileSync(path, buf, mode) {
+  const tmp = `${path}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+  const permissions = mode & 4095;
+  let fd;
+  try {
+    fd = openSync(tmp, "wx", permissions);
+    writeAllSync(fd, buf);
+    try {
+      chmodSync2(tmp, permissions);
+    } catch {
+    }
+    fsyncSync(fd);
+    closeSync(fd);
+    fd = void 0;
+    renameSync(tmp, path);
+    fsyncDirectoryBestEffort(dirname3(path));
+  } catch (err) {
+    if (fd !== void 0) {
+      try {
+        closeSync(fd);
+      } catch {
+      }
+    }
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
 function applyEditBlock(block, rootDir) {
-  const absRoot = resolve5(rootDir);
+  const absRoot = resolve6(rootDir);
   const absTarget = resolveEditPath(rootDir, block.path);
   if (!pathIsUnder2(absTarget, absRoot)) {
     return {
@@ -12079,7 +12428,7 @@ function applyEditBlock(block, rootDir) {
   const searchEmpty = block.search.length === 0;
   if (searchEmpty) {
     try {
-      mkdirSync(dirname3(absTarget), { recursive: true });
+      mkdirSync2(dirname3(absTarget), { recursive: true });
       const fd = openSync(absTarget, "wx");
       try {
         writeSync(fd, block.replace);
@@ -12100,9 +12449,22 @@ function applyEditBlock(block, rootDir) {
     }
   }
   try {
+    let writeTarget;
+    try {
+      writeTarget = realpathSync(absTarget);
+    } 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"
+        };
+      }
+      throw err;
+    }
     let fd;
     try {
-      fd = openSync(absTarget, "r+");
+      fd = openSync(writeTarget, "r+");
     } catch (err) {
       if (err.code === "ENOENT") {
         return {
@@ -12143,17 +12505,12 @@ function applyEditBlock(block, rootDir) {
         };
       }
       const replaced = `${content.slice(0, idx)}${adaptedReplace}${content.slice(idx + adaptedSearch.length)}`;
-      const outBuf = encodeFile(replaced, encoding);
-      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;
-      }
+      closeSync(fd);
+      fd = void 0;
+      atomicReplaceFileSync(writeTarget, encodeFile(replaced, encoding), stat2.mode);
       return { path: block.path, status: "applied" };
     } finally {
-      closeSync(fd);
+      if (fd !== void 0) closeSync(fd);
     }
   } catch (err) {
     return { path: block.path, status: "error", message: err.message };
@@ -12165,7 +12522,7 @@ function applyEditBlocks(blocks, rootDir) {
 function toWholeFileEditBlock(path, content, rootDir) {
   const abs = resolveEditPath(rootDir, path);
   let search = "";
-  if (existsSync3(abs)) {
+  if (existsSync4(abs)) {
     try {
       search = decodeFileBuffer(readFileSync3(abs)).text;
     } catch {
@@ -12175,7 +12532,7 @@ function toWholeFileEditBlock(path, content, rootDir) {
   return { path, search, replace: content, offset: 0 };
 }
 function snapshotBeforeEdits(blocks, rootDir) {
-  const absRoot = resolve5(rootDir);
+  const absRoot = resolve6(rootDir);
   const seen = /* @__PURE__ */ new Set();
   const snapshots = [];
   for (const b of blocks) {
@@ -12183,7 +12540,7 @@ function snapshotBeforeEdits(blocks, rootDir) {
     if (!pathIsUnder2(abs, absRoot)) continue;
     if (seen.has(abs)) continue;
     seen.add(abs);
-    if (!existsSync3(abs)) {
+    if (!existsSync4(abs)) {
       snapshots.push({ path: b.path, prevContent: null });
       continue;
     }
@@ -12197,7 +12554,7 @@ function snapshotBeforeEdits(blocks, rootDir) {
   return snapshots;
 }
 function restoreSnapshots(snapshots, rootDir) {
-  const absRoot = resolve5(rootDir);
+  const absRoot = resolve6(rootDir);
   return snapshots.map((snap) => {
     const abs = resolveEditPath(rootDir, snap.path);
     if (!pathIsUnder2(abs, absRoot)) {
@@ -12209,14 +12566,14 @@ function restoreSnapshots(snapshots, rootDir) {
     }
     try {
       if (snap.prevContent === null) {
-        if (existsSync3(abs)) unlinkSync(abs);
+        if (existsSync4(abs)) unlinkSync(abs);
         return {
           path: snap.path,
           status: "applied",
           message: "removed (the edit had created it)"
         };
       }
-      writeFileSync(abs, encodeFile(snap.prevContent, snap.prevEncoding ?? "utf8"));
+      writeFileSync2(abs, encodeFile(snap.prevContent, snap.prevEncoding ?? "utf8"));
       return {
         path: snap.path,
         status: "applied",
@@ -12235,6 +12592,7 @@ export {
   ToolRegistry,
   registerSingleMcpTool,
   bridgeMcpTools,
+  isDeepSeekHost,
   ImmutablePrefix,
   CacheFirstLoop,
   expandAtUrls,
@@ -12268,4 +12626,4 @@ export {
 he/he.js:
   (*! https://mths.be/he v1.2.0 by @mathias | MIT license *)
 */
-//# sourceMappingURL=chunk-GPUH2BNM.js.map
+//# sourceMappingURL=chunk-K4YQFULP.js.map