reasonix 0.46.0 → 0.47.0

package/dist/cli/{chunk-WL6SNQ5T.js → chunk-ICAFSZHS.js}

@@ -3,7 +3,7 @@ import { createRequire as __cr } from 'node:module'; if (typeof globalThis.requi
 import {
   MemoryStore,
   sanitizeMemoryName
-} from "./chunk-JNAQYELD.js";
+} from "./chunk-UDVFBEXC.js";
 import {
   countTokens,
   countTokensBounded,
@@ -12,23 +12,23 @@ import {
 } from "./chunk-6OWJV3YW.js";
 import {
   Usage
-} from "./chunk-V26WPN3J.js";
+} from "./chunk-VNQGCA3Q.js";
 import {
   applyEdit,
   applyMultiEdit,
   pauseGate
-} from "./chunk-RDRC3XDT.js";
+} from "./chunk-GDKB2PPK.js";
 import {
   NEGATIVE_CLAIM_RULE,
   PROJECT_MEMORY_FILES,
   PROJECT_MEMORY_MAX_CHARS,
   TUI_FORMATTING_RULES,
   memoryEnabled
-} from "./chunk-TEUDEGX2.js";
+} from "./chunk-FY4S7TJZ.js";
 import {
   formatHookOutcomeMessage,
   runHooks
-} from "./chunk-A3TSSDS2.js";
+} from "./chunk-BWYVFFKR.js";
 import {
   ignoredByLayers,
   loadGitignoreAt,
@@ -41,25 +41,26 @@ import {
   loadSessionMeta,
   rewriteSession,
   timestampSuffix
-} from "./chunk-5ACMUK4Q.js";
+} from "./chunk-RRXUIPWG.js";
 import {
   DEEPSEEK_CONTEXT_TOKENS,
   DEFAULT_CONTEXT_TOKENS,
   SessionStats
-} from "./chunk-ZZYBBX5N.js";
+} from "./chunk-VJMBISEI.js";
 import {
   t
-} from "./chunk-IJ7JA32V.js";
+} from "./chunk-KDRUEXII.js";
 import {
   DEFAULT_INDEX_EXCLUDES,
   addProjectPathAllowed,
   loadMemoryTypeRegistry,
   loadMetasoApiKey,
   loadProjectPathAllowed,
+  loadTavilyApiKey,
   require_picomatch,
   webSearchEndpoint,
   webSearchEngine
-} from "./chunk-AVFXO2EZ.js";
+} from "./chunk-24A7FHGJ.js";
 import {
   __commonJS,
   __esm,
@@ -6124,11 +6125,42 @@ async function bridgeMcpTools(client, opts = {}) {
   return { ...result, env };
 }
 function flattenMcpResult(result, opts = {}) {
+  validateResultShape(result);
   const parts = result.content.map(blockToString);
   const joined = parts.join("\n").trim();
   const prefixed = result.isError ? `ERROR: ${joined || "(no error message from server)"}` : joined;
   return opts.maxChars ? truncateForModel(prefixed, opts.maxChars) : prefixed;
 }
+function validateResultShape(result) {
+  if (typeof result !== "object" || !result)
+    throw new Error(`MCP server returned non-object result: ${typeof result}`);
+  const { content, isError: _isError } = result;
+  if (!Array.isArray(content))
+    throw new Error(`MCP server returned result with non-array content: ${typeof content}`);
+  for (let i = 0; i < content.length; i++) {
+    const block = content[i];
+    if (typeof block !== "object" || !block)
+      throw new Error(`MCP server returned result.content[${i}] is not an object`);
+    if (block.type !== "text" && block.type !== "image")
+      throw new Error(
+        `MCP server returned result.content[${i}] with unknown type ${JSON.stringify(block.type)}`
+      );
+    if (block.type === "text" && typeof block.text !== "string")
+      throw new Error(
+        `MCP server returned result.content[${i}] with non-string text (${typeof block.text})`
+      );
+    if (block.type === "image") {
+      if (typeof block.data !== "string")
+        throw new Error(
+          `MCP server returned result.content[${i}] with non-string data (${typeof block.data})`
+        );
+      if (typeof block.mimeType !== "string")
+        throw new Error(
+          `MCP server returned result.content[${i}] with non-string mimeType (${typeof block.mimeType})`
+        );
+    }
+  }
+}
 function truncateForModel(s, maxChars) {
   if (s.length <= maxChars) return s;
   const tailBudget = Math.min(1024, Math.floor(maxChars * 0.1));
@@ -6394,6 +6426,12 @@ var ToolRegistry = class {
         });
       }
     }
+    if (opts.signal?.aborted) {
+      return JSON.stringify({
+        error: `${name}: aborted before dispatch (user interrupt)`,
+        rejectedReason: "aborted"
+      });
+    }
     let finalResult;
     try {
       try {
@@ -7180,42 +7218,6 @@ function* hookWarnings(outcomes, turn) {
   }
 }
 
-// src/loop/turn-failure-tracker.ts
-var FAILURE_ESCALATION_THRESHOLD = 3;
-var TurnFailureTracker = class {
-  count = 0;
-  types = {};
-  threshold;
-  constructor(threshold = FAILURE_ESCALATION_THRESHOLD) {
-    this.threshold = threshold;
-  }
-  reset() {
-    this.count = 0;
-    this.types = {};
-  }
-  /** True ONLY on the call where the count crosses the configured 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 < this.threshold && this.count >= this.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/repair/scavenge.ts
 var MAX_SCAVENGE_INPUT = 100 * 1024;
 function scavengeToolCalls(reasoningContent, opts) {
@@ -7595,7 +7597,6 @@ var CacheFirstLoop = class {
   }
   _proArmedForNextTurn = false;
   _escalateThisTurn = false;
-  _turnFailures;
   _turnSelfCorrected = false;
   _foldedThisTurn = false;
   context;
@@ -7614,9 +7615,6 @@ var CacheFirstLoop = class {
     this.reasoningEffort = opts.reasoningEffort ?? "max";
     if (opts.autoEscalate !== void 0) this.autoEscalate = opts.autoEscalate;
     this.budgetUsd = typeof opts.budgetUsd === "number" && opts.budgetUsd > 0 ? opts.budgetUsd : null;
-    this._turnFailures = new TurnFailureTracker(
-      resolveFailureThreshold(opts.failureThreshold, FAILURE_ESCALATION_THRESHOLD)
-    );
     this.hooks = opts.hooks ?? [];
     this.hookCwd = opts.hookCwd ?? process.cwd();
     this.confirmationGate = opts.confirmationGate ?? pauseGate;
@@ -7724,7 +7722,6 @@ var CacheFirstLoop = class {
     this._inflight.clear();
     this.stats.reset();
     this._turn = 0;
-    this._turnFailures.reset();
     this._budgetWarned = false;
     let systemRebuilt = false;
     if (this._rebuildSystem) {
@@ -7795,13 +7792,6 @@ var CacheFirstLoop = class {
   modelForCurrentCall() {
     return this._escalateThisTurn ? ESCALATION_MODEL : this.model;
   }
-  /** 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;
-  }
   /** A call counts as mutating when its definition reports `readOnly !== true` and any dynamic `readOnlyCheck` doesn't override that for these args. */
   isMutating(call) {
     const name = call.function?.name;
@@ -7925,6 +7915,32 @@ ${reason}`
     }
     return userText;
   }
+  /** Rewind to the N-th user turn (0-indexed). Drops that turn + everything after. */
+  rewindToUserTurn(userTurnIndex) {
+    const entries = this.log.entries;
+    let count = 0;
+    let targetIdx = -1;
+    for (let i = 0; i < entries.length; i++) {
+      if (entries[i].role !== "user") continue;
+      if (count === userTurnIndex) {
+        targetIdx = i;
+        break;
+      }
+      count++;
+    }
+    if (targetIdx < 0) return null;
+    const raw = entries[targetIdx].content;
+    const userText = typeof raw === "string" ? raw : "";
+    const preserved = entries.slice(0, targetIdx).map((m) => ({ ...m }));
+    this.log.compactInPlace(preserved);
+    if (this.sessionName) {
+      try {
+        rewriteSession(this.sessionName, preserved);
+      } catch {
+      }
+    }
+    return userText;
+  }
   async *step(userInput) {
     this._steerConsumed = false;
     if (this.budgetUsd !== null) {
@@ -7956,7 +7972,6 @@ ${reason}`
     this._turn++;
     this.scratch.reset();
     this.repair.resetStorm();
-    this._turnFailures.reset();
     this._turnSelfCorrected = false;
     this._escalateThisTurn = false;
     this._foldedThisTurn = false;
@@ -8227,17 +8242,6 @@ ${reason}`
         stats: turnStats,
         repair: report
       };
-      if (this.noteToolFailureSignal("", report)) {
-        yield {
-          turn: this._turn,
-          role: "warning",
-          content: t("loop.autoEscalation", {
-            model: ESCALATION_MODEL,
-            breakdown: this._turnFailures.formatBreakdown(),
-            fallback: this.model
-          })
-        };
-      }
       const allSuppressed = report.stormsBroken > 0 && repairedCalls.length === 0 && toolCalls.length > 0;
       if (allSuppressed && !this._turnSelfCorrected) {
         this._turnSelfCorrected = true;
@@ -8377,17 +8381,6 @@ ${reason}`
             name,
             content: result
           });
-          if (this.noteToolFailureSignal(result)) {
-            yield {
-              turn: this._turn,
-              role: "warning",
-              content: t("loop.autoEscalation", {
-                model: ESCALATION_MODEL,
-                breakdown: this._turnFailures.formatBreakdown(),
-                fallback: this.model
-              })
-            };
-          }
           yield {
             turn: this._turn,
             role: "tool",
@@ -8425,19 +8418,6 @@ function parsePositiveIntEnv(raw) {
   const n = Number.parseInt(raw, 10);
   return Number.isFinite(n) && n > 0 ? n : void 0;
 }
-var FAILURE_THRESHOLD_MIN = 1;
-var FAILURE_THRESHOLD_MAX = 20;
-function resolveFailureThreshold(raw, fallback) {
-  if (raw === void 0) return fallback;
-  if (!Number.isInteger(raw) || raw < FAILURE_THRESHOLD_MIN || raw > FAILURE_THRESHOLD_MAX) {
-    process.stderr.write(
-      `\u25B2 ignoring escalation failureThreshold=${raw} (must be an integer in [${FAILURE_THRESHOLD_MIN},${FAILURE_THRESHOLD_MAX}]) \u2014 using default ${fallback}
-`
-    );
-    return fallback;
-  }
-  return raw;
-}
 
 // src/at-mentions.ts
 import { existsSync, readFileSync, readdirSync, statSync } from "fs";
@@ -9241,6 +9221,7 @@ var FETCH_MAX_BYTES = 10 * 1024 * 1024;
 var USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
 var MOJEEK_ENDPOINT = "https://www.mojeek.com/search";
 var METASO_ENDPOINT = "https://metaso.cn/api/v1";
+var TAVILY_ENDPOINT = "https://api.tavily.com/search";
 function searchStatusError(status) {
   if (status === 429) return t("webErrors.rateLimit429");
   if (status === 403) return t("webErrors.forbidden403");
@@ -9260,6 +9241,9 @@ async function webSearch(query, opts = {}) {
   if (opts.engine === "searxng") {
     return searchSearxng(query, opts);
   }
+  if (opts.engine === "tavily") {
+    return searchTavily(query, opts);
+  }
   return searchMojeek(query, opts);
 }
 async function searchMojeek(query, opts = {}) {
@@ -9394,6 +9378,55 @@ async function searchMetaso(query, opts = {}) {
     snippet: wp.snippet ?? wp.summary ?? ""
   }));
 }
+async function searchTavily(query, opts = {}) {
+  const topK = Math.max(1, Math.min(20, opts.topK ?? DEFAULT_TOPK));
+  const apiKey = loadTavilyApiKey();
+  if (!apiKey) throw new Error(t("webErrors.tavilyMissingKey"));
+  let resp;
+  try {
+    resp = await fetch(TAVILY_ENDPOINT, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify({
+        api_key: apiKey,
+        query,
+        search_depth: "basic",
+        max_results: topK,
+        include_answer: false,
+        include_raw_content: false,
+        include_images: false
+      }),
+      signal: opts.signal
+    });
+  } catch (err) {
+    if (err instanceof TypeError && err.message.includes("fetch")) {
+      throw new Error(t("webErrors.cannotReach", { endpoint: TAVILY_ENDPOINT }));
+    }
+    throw err;
+  }
+  if (!resp.ok) {
+    if (resp.status === 401 || resp.status === 403) {
+      throw new Error(t("webErrors.tavilyUnauthorized"));
+    }
+    if (resp.status === 429) throw new Error(t("webErrors.tavilyRateLimit"));
+    throw new Error(t("webErrors.tavilyServerError", { status: resp.status }));
+  }
+  let data;
+  try {
+    data = await resp.json();
+  } catch {
+    throw new Error(t("webErrors.tavilyParseError", { status: resp.status }));
+  }
+  const results = data.results ?? [];
+  return results.slice(0, topK).map((r) => ({
+    title: r.title,
+    url: r.url,
+    snippet: r.content ?? ""
+  }));
+}
 function parseSearxngHtmlResults(html) {
   const root = (0, import_node_html_parser.parse)(html);
   const results = [];
@@ -9612,7 +9645,7 @@ function registerWebTools(registry, opts = {}) {
   const maxFetchChars = opts.maxFetchChars ?? DEFAULT_FETCH_MAX_CHARS;
   registry.register({
     name: "web_search",
-    description: "Search the public web. Returns ranked results with title, url, and snippet. Call this when the answer's correctness depends on current state \u2014 anything that changes over time (events, prices, releases, status of a thing in the real world). Composing such answers from training memory invents stale numbers; search first, then ground the answer in the results. For evergreen / definitional questions you don't need this. To change the backend, use /search-engine mojeek|searxng|metaso.",
+    description: "Search the public web. Returns ranked results with title, url, and snippet. Call this when the answer's correctness depends on current state \u2014 anything that changes over time (events, prices, releases, status of a thing in the real world). Composing such answers from training memory invents stale numbers; search first, then ground the answer in the results. For evergreen / definitional questions you don't need this. To change the backend, use /search-engine mojeek|searxng|metaso|tavily.",
     readOnly: true,
     parallelSafe: true,
     parameters: {
@@ -9684,13 +9717,13 @@ import * as pathMod4 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 resolve2 } from "path";
-function findSubdirMemoryAncestors(absPath, rootDir) {
+function findDirMemory(absDir, rootDir) {
   const root = resolve2(rootDir);
-  const target = resolve2(absPath);
+  const target = resolve2(absDir);
   const rel = relative2(root, target);
-  if (!rel || rel.startsWith("..")) return [];
+  if (rel.startsWith("..")) return [];
   const found = [];
-  let cur = dirname(target);
+  let cur = target;
   while (cur !== root) {
     const r = relative2(root, cur);
     if (!r || r.startsWith("..")) break;
@@ -9707,6 +9740,9 @@ function findSubdirMemoryAncestors(absPath, rootDir) {
   }
   return found;
 }
+function findSubdirMemoryAncestors(absPath, rootDir) {
+  return findDirMemory(dirname(resolve2(absPath)), rootDir);
+}
 function readSubdirMemoryContent(path) {
   let raw;
   try {
@@ -9975,6 +10011,129 @@ function formatOutline(entries) {
 // src/tools/fs/search.ts
 import { promises as fs2 } from "fs";
 import * as pathMod3 from "path";
+
+// src/tools/fs/regex-runner.ts
+import { Worker } from "worker_threads";
+var WORKER_SOURCE = `
+const { parentPort } = require("node:worker_threads");
+parentPort.on("message", (msg) => {
+  const { id, text, source, flags } = msg;
+  let re;
+  try {
+    re = new RegExp(source, flags);
+  } catch (err) {
+    parentPort.postMessage({ id, error: (err && err.message) ? err.message : String(err) });
+    return;
+  }
+  const lines = text.split(/\\r?\\n/);
+  const hits = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (re.test(lines[i])) hits.push(i);
+  }
+  parentPort.postMessage({ id, hits });
+});
+`;
+var DEFAULT_TIMEOUT_MS = 6e4;
+var RegexRunner = class {
+  worker = null;
+  pending = /* @__PURE__ */ new Map();
+  nextId = 1;
+  defaultTimeoutMs;
+  constructor(opts = {}) {
+    this.defaultTimeoutMs = opts.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+  }
+  testLines(text, source, flags, opts = {}) {
+    return new Promise((resolve5, reject) => {
+      if (opts.signal?.aborted) {
+        reject(new Error("regex evaluation aborted"));
+        return;
+      }
+      if (!this.worker) this.worker = this.spawn();
+      const id = this.nextId++;
+      const timeoutMs = opts.timeoutMs ?? this.defaultTimeoutMs;
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        this.killWorker();
+        reject(new Error(`regex evaluation exceeded ${timeoutMs}ms`));
+      }, timeoutMs);
+      const entry = { resolve: resolve5, reject, timer };
+      if (opts.signal) {
+        entry.signal = opts.signal;
+        entry.onAbort = () => {
+          this.pending.delete(id);
+          clearTimeout(timer);
+          this.killWorker();
+          reject(new Error("regex evaluation aborted"));
+        };
+        opts.signal.addEventListener("abort", entry.onAbort, { once: true });
+      }
+      this.pending.set(id, entry);
+      this.worker.postMessage({ id, text, source, flags });
+    });
+  }
+  async shutdown() {
+    if (this.worker) {
+      const w = this.worker;
+      this.worker = null;
+      await w.terminate();
+    }
+    for (const entry of this.pending.values()) {
+      clearTimeout(entry.timer);
+      if (entry.onAbort && entry.signal) {
+        entry.signal.removeEventListener("abort", entry.onAbort);
+      }
+      entry.reject(new Error("regex runner shut down"));
+    }
+    this.pending.clear();
+  }
+  spawn() {
+    const w = new Worker(WORKER_SOURCE, { eval: true });
+    w.on("message", (msg) => {
+      const entry = this.pending.get(msg.id);
+      if (!entry) return;
+      clearTimeout(entry.timer);
+      if (entry.onAbort && entry.signal) {
+        entry.signal.removeEventListener("abort", entry.onAbort);
+      }
+      this.pending.delete(msg.id);
+      if (msg.error !== void 0) entry.reject(new Error(msg.error));
+      else entry.resolve(msg.hits ?? []);
+    });
+    w.on("error", (err) => {
+      if (this.worker !== w) return;
+      this.failPending(err);
+    });
+    w.on("exit", () => {
+      if (this.worker !== w) return;
+      this.worker = null;
+      if (this.pending.size > 0) this.failPending(new Error("regex worker exited"));
+    });
+    return w;
+  }
+  killWorker() {
+    if (!this.worker) return;
+    const w = this.worker;
+    this.worker = null;
+    void w.terminate();
+  }
+  failPending(err) {
+    for (const entry of this.pending.values()) {
+      clearTimeout(entry.timer);
+      if (entry.onAbort && entry.signal) {
+        entry.signal.removeEventListener("abort", entry.onAbort);
+      }
+      entry.reject(err);
+    }
+    this.pending.clear();
+  }
+};
+var _runner = null;
+function getRegexRunner() {
+  if (!_runner) _runner = new RegexRunner();
+  return _runner;
+}
+
+// src/tools/fs/search.ts
 function throwIfAborted(signal) {
   if (!signal?.aborted) return;
   throw new DOMException("search aborted by user", "AbortError");
@@ -10027,17 +10186,20 @@ async function searchFiles(ctx, startAbs, args) {
 }
 var MAX_HITS_PER_FILE = 30;
 var SUMMARY_MODE_TRIGGER_RATIO = 0.8;
+var WALK_DEADLINE_MS = 12e4;
 async function searchContent(ctx, startAbs, args) {
   throwIfAborted(args.signal);
   const caseSensitive = args.case_sensitive === true;
   const includeDeps = args.include_deps === true;
   const ctxLines = Math.max(0, Math.min(20, Math.floor(args.context ?? 0)));
   const summaryOnly = args.summary_only === true;
-  let re = null;
+  const reFlags = caseSensitive ? "" : "i";
+  let reSource = null;
   try {
-    re = new RegExp(args.pattern, caseSensitive ? "" : "i");
+    new RegExp(args.pattern, reFlags);
+    reSource = args.pattern;
   } catch {
-    re = null;
+    reSource = null;
   }
   const needle = caseSensitive ? args.pattern : args.pattern.toLowerCase();
   const matches = [];
@@ -10047,6 +10209,15 @@ async function searchContent(ctx, startAbs, args) {
   let summaryMode = summaryOnly;
   let summaryNoticeEmitted = false;
   const fileHitCounts = /* @__PURE__ */ new Map();
+  const regexSkippedFiles = [];
+  const t0 = Date.now();
+  const throwIfTimedOut = () => {
+    if (Date.now() - t0 > WALK_DEADLINE_MS) {
+      throw new Error(
+        `search_content exceeded ${WALK_DEADLINE_MS}ms \u2014 narrow the scope (path/glob) or simplify the pattern`
+      );
+    }
+  };
   const pushLine = (out) => {
     if (totalBytes + out.length + 1 > ctx.maxListBytes) {
       matches.push(`[\u2026 truncated at ${ctx.maxListBytes} bytes \u2014 refine pattern or path \u2026]`);
@@ -10081,6 +10252,7 @@ async function searchContent(ctx, startAbs, args) {
     for (const e of entries) {
       if (truncated) return;
       throwIfAborted(args.signal);
+      throwIfTimedOut();
       if (e.isDirectory()) {
         if (!includeDeps && ctx.skipDirNames.has(e.name)) continue;
         await walk2(pathMod3.join(dir, e.name));
@@ -10117,13 +10289,25 @@ async function searchContent(ctx, startAbs, args) {
       const text = raw.toString("utf8");
       const rel = displayRel2(ctx.rootDir, full);
       const lines = text.split(/\r?\n/);
-      const hits = [];
-      for (let li = 0; li < lines.length; li++) {
-        throwIfAborted(args.signal);
-        const line = lines[li];
-        const lineForCheck = caseSensitive ? line : line.toLowerCase();
-        const hit = re ? re.test(line) : lineForCheck.includes(needle);
-        if (hit) hits.push(li);
+      let hits;
+      if (reSource !== null) {
+        try {
+          hits = await getRegexRunner().testLines(text, reSource, reFlags, {
+            signal: args.signal
+          });
+        } catch (err) {
+          const reason = err.message;
+          if (reason.includes("aborted")) throw err;
+          regexSkippedFiles.push({ rel, reason });
+          continue;
+        }
+      } else {
+        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);
+        }
       }
       scanned++;
       if (hits.length === 0) continue;
@@ -10172,6 +10356,11 @@ async function searchContent(ctx, startAbs, args) {
     }
   };
   await walk2(startAbs);
+  if (regexSkippedFiles.length > 0) {
+    pushLine(
+      `[regex timed out on ${regexSkippedFiles.length} file${regexSkippedFiles.length === 1 ? "" : "s"} \u2014 pattern may have catastrophic backtracking; first: ${regexSkippedFiles[0].rel}]`
+    );
+  }
   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"})`;
   }
@@ -10236,11 +10425,15 @@ function registerFilesystemTools(registry, opts) {
   const sessionApproved = /* @__PURE__ */ new Set();
   const shownSubdirMemory = /* @__PURE__ */ new Set();
   function withSubdirMemory(absPath, body) {
-    if (!memoryEnabled()) return body;
-    const ancestors = findSubdirMemoryAncestors(absPath, rootDir);
-    if (ancestors.length === 0) return body;
+    return prependMemorySections(findSubdirMemoryAncestors(absPath, rootDir), body);
+  }
+  function withDirMemory(absDir, body) {
+    return prependMemorySections(findDirMemory(absDir, rootDir), body);
+  }
+  function prependMemorySections(memPaths, body) {
+    if (!memoryEnabled() || memPaths.length === 0) return body;
     const sections = [];
-    for (const memPath of [...ancestors].reverse()) {
+    for (const memPath of [...memPaths].reverse()) {
       if (shownSubdirMemory.has(memPath)) continue;
       const content = readSubdirMemoryContent(memPath);
       if (!content) continue;
@@ -10433,7 +10626,7 @@ ${slice.join("\n")}`);
       for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
         lines.push(e.isDirectory() ? `${e.name}/` : e.name);
       }
-      return lines.join("\n") || "(empty directory)";
+      return withDirMemory(abs, lines.join("\n") || "(empty directory)");
     }
   });
   registry.register({
@@ -11655,4 +11848,4 @@ export {
 he/he.js:
   (*! https://mths.be/he v1.2.0 by @mathias | MIT license *)
 */
-//# sourceMappingURL=chunk-WL6SNQ5T.js.map
+//# sourceMappingURL=chunk-ICAFSZHS.js.map