reasonix 0.40.0 → 0.41.0

package/dist/cli/{chunk-4YV2GBYG.js → chunk-IEA6JOIP.js}

@@ -2,7 +2,7 @@
 import {
   MemoryStore,
   sanitizeMemoryName
-} from "./chunk-R4YTW7PR.js";
+} from "./chunk-ARF3N2SY.js";
 import {
   countTokens,
   estimateConversationTokens,
@@ -10,20 +10,20 @@ import {
 } from "./chunk-DAEAAVDF.js";
 import {
   Usage
-} from "./chunk-KMWKGPFZ.js";
+} from "./chunk-H4OLWRSX.js";
 import {
   applyEdit,
   applyMultiEdit,
   pauseGate
-} from "./chunk-SZH34P45.js";
+} from "./chunk-BYZGO3BX.js";
 import {
   NEGATIVE_CLAIM_RULE,
   TUI_FORMATTING_RULES
-} from "./chunk-7DLHHBGN.js";
+} from "./chunk-CD4SCQL4.js";
 import {
   formatHookOutcomeMessage,
   runHooks
-} from "./chunk-FFNOMR32.js";
+} from "./chunk-WE3YZULK.js";
 import {
   ignoredByLayers,
   loadGitignoreAt,
@@ -35,17 +35,18 @@ import {
   loadSessionMessages,
   loadSessionMeta,
   rewriteSession
-} from "./chunk-XST7BSZJ.js";
+} from "./chunk-YJFKFTAL.js";
 import {
   t
-} from "./chunk-H7PHYVPM.js";
+} from "./chunk-MHGPBJ2T.js";
 import {
   DEFAULT_INDEX_EXCLUDES,
   addProjectPathAllowed,
+  loadMemoryTypeRegistry,
   loadProjectPathAllowed,
   webSearchEndpoint,
   webSearchEngine
-} from "./chunk-CZSJILQP.js";
+} from "./chunk-65Q5HQ26.js";
 import {
   DEEPSEEK_CONTEXT_TOKENS,
   DEFAULT_CONTEXT_TOKENS,
@@ -557,17 +558,25 @@ function missingRequiredParam(schema, args) {
 // src/memory/runtime.ts
 import { createHash } from "crypto";
 var ImmutablePrefix = class {
+  /** Stable across turns; rebuilt only on /new when REASONIX.md changed on disk. */
   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. */
+  /** Invalidated by addTool / removeTool / replaceSystem; bypassing any of those 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 ?? []]);
   }
+  /** Replaces the system prompt; returns true iff the string actually changed. Caller must accept a cache miss on the next turn. */
+  replaceSystem(s) {
+    if (this.system === s) return false;
+    this.system = s;
+    this._fingerprintCache = null;
+    return true;
+  }
   get toolSpecs() {
     return this._toolSpecs;
   }
@@ -1051,6 +1060,10 @@ function shrinkOversizedToolResultsByTokens(messages, maxTokens) {
 }
 
 // src/loop/healing.ts
+var _stampSeq = 0;
+function stampMissingIds(calls) {
+  return calls.map((c) => c.id ? c : { ...c, id: `z-ext-${Date.now()}-${_stampSeq++}` });
+}
 function fixToolCallPairing(messages) {
   const out = [];
   let droppedAssistantCalls = 0;
@@ -1058,9 +1071,10 @@ function fixToolCallPairing(messages) {
   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 calls = stampMissingIds(msg.tool_calls);
       const needed = /* @__PURE__ */ new Set();
-      for (const call of msg.tool_calls) {
-        if (call?.id) needed.add(call.id);
+      for (const call of calls) {
+        if (call.id) needed.add(call.id);
       }
       const candidates = [];
       let j = i + 1;
@@ -1074,7 +1088,7 @@ function fixToolCallPairing(messages) {
         j++;
       }
       if (needed.size === 0) {
-        out.push(msg);
+        out.push({ ...msg, tool_calls: calls });
         for (const r of candidates) out.push(r);
         i = j - 1;
       } else {
@@ -1138,6 +1152,32 @@ function* hookWarnings(outcomes, turn) {
   }
 }
 
+// src/loop/read-only-loop-tracker.ts
+var READONLY_LOOP_ESCALATION_THRESHOLD = 8;
+var ReadOnlyLoopTracker = class {
+  streak = 0;
+  threshold;
+  constructor(threshold = READONLY_LOOP_ESCALATION_THRESHOLD) {
+    this.threshold = Math.max(1, threshold);
+  }
+  reset() {
+    this.streak = 0;
+  }
+  /** True ONLY on the call where the streak crosses the configured threshold. */
+  noteAndCrossedThreshold(isReadOnly) {
+    if (!isReadOnly) {
+      this.streak = 0;
+      return false;
+    }
+    const before = this.streak;
+    this.streak += 1;
+    return before < this.threshold && this.streak >= this.threshold;
+  }
+  get currentStreak() {
+    return this.streak;
+  }
+};
+
 // src/loop/turn-failure-tracker.ts
 var FAILURE_ESCALATION_THRESHOLD = 3;
 var TurnFailureTracker = class {
@@ -1518,6 +1558,7 @@ var CacheFirstLoop = class {
   confirmationGate;
   /** Number of messages that were pre-loaded from the session file. */
   resumedMessageCount;
+  _rebuildSystem;
   _turn = 0;
   _streamPreference;
   /** Threaded through HTTP + every tool dispatch so Esc cancels in-flight work, not after. */
@@ -1527,6 +1568,7 @@ var CacheFirstLoop = class {
   _proArmedForNextTurn = false;
   _escalateThisTurn = false;
   _turnFailures;
+  _readOnlyLoop;
   _turnSelfCorrected = false;
   _foldedThisTurn = false;
   _toolDispatchesThisStep = 0;
@@ -1549,34 +1591,18 @@ var CacheFirstLoop = class {
     this._turnFailures = new TurnFailureTracker(
       resolveFailureThreshold(opts.failureThreshold, FAILURE_ESCALATION_THRESHOLD)
     );
+    this._readOnlyLoop = new ReadOnlyLoopTracker(
+      parsePositiveIntEnv(process.env.REASONIX_READONLY_LOOP_THRESHOLD) ?? READONLY_LOOP_ESCALATION_THRESHOLD
+    );
     this.maxToolIters = opts.maxToolIters ?? 64;
     this.hooks = opts.hooks ?? [];
     this.hookCwd = opts.hookCwd ?? process.cwd();
     this.confirmationGate = opts.confirmationGate ?? pauseGate;
+    this._rebuildSystem = opts.rebuildSystem ?? null;
     this._streamPreference = opts.stream ?? true;
     this.stream = this._streamPreference;
     const allowedNames = /* @__PURE__ */ new Set([...this.prefix.toolSpecs.map((s) => s.function.name)]);
     const registry = this.tools;
-    const isMutating = (call) => {
-      const name = call.function?.name;
-      if (!name) return false;
-      const def = registry.get(name);
-      if (!def) return false;
-      if (def.readOnlyCheck) {
-        let args = {};
-        try {
-          args = JSON.parse(call.function?.arguments ?? "{}") ?? {};
-        } catch {
-        }
-        try {
-          if (def.readOnlyCheck(args)) return false;
-        } catch (err) {
-          process.stderr.write(`readOnlyCheck for ${name} threw: ${err.message}
-`);
-        }
-      }
-      return def.readOnly !== true;
-    };
     const isStormExempt = (call) => {
       const name = call.function?.name;
       if (!name) return false;
@@ -1584,7 +1610,7 @@ var CacheFirstLoop = class {
     };
     this.repair = new ToolCallRepair({
       allowedToolNames: allowedNames,
-      isMutating,
+      isMutating: (call) => this.isMutating(call),
       isStormExempt,
       stormThreshold: parsePositiveIntEnv(process.env.REASONIX_STORM_THRESHOLD),
       stormWindow: parsePositiveIntEnv(process.env.REASONIX_STORM_WINDOW)
@@ -1677,7 +1703,7 @@ var CacheFirstLoop = class {
       }
     }
   }
-  /** "New chat" — drops in-memory messages, archives the on-disk transcript so it survives in Sessions, keeps sessionName so the prefix cache stays warm. */
+  /** "New chat" — drops in-memory messages, archives the on-disk transcript so it survives in Sessions, keeps sessionName so the prefix cache stays warm. Re-runs the system-prompt builder if one was wired (issue #778: REASONIX.md edits otherwise need a restart). */
   clearLog() {
     const dropped = this.log.length;
     this.log.compactInPlace([]);
@@ -1691,7 +1717,14 @@ var CacheFirstLoop = class {
     }
     this.scratch.reset();
     this._inflight.clear();
-    return { dropped, archived };
+    let systemRebuilt = false;
+    if (this._rebuildSystem) {
+      try {
+        systemRebuilt = this.prefix.replaceSystem(this._rebuildSystem());
+      } catch {
+      }
+    }
+    return { dropped, archived, systemRebuilt };
   }
   configure(opts) {
     if (opts.model !== void 0) this.model = opts.model;
@@ -1737,6 +1770,35 @@ var CacheFirstLoop = class {
     this._escalateThisTurn = true;
     return true;
   }
+  /** Returns true ONLY on the call where the read-only streak crosses the threshold (#681). */
+  noteReadOnlyToolCall(call) {
+    const isReadOnly = !this.isMutating(call);
+    if (!this._readOnlyLoop.noteAndCrossedThreshold(isReadOnly)) 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;
+    if (!name) return false;
+    const def = this.tools.get(name);
+    if (!def) return false;
+    if (def.readOnlyCheck) {
+      let args = {};
+      try {
+        args = JSON.parse(call.function?.arguments ?? "{}") ?? {};
+      } catch {
+      }
+      try {
+        if (def.readOnlyCheck(args)) return false;
+      } catch (err) {
+        process.stderr.write(`readOnlyCheck for ${name} threw: ${err.message}
+`);
+      }
+    }
+    return def.readOnly !== true;
+  }
   async runOneToolCall(call, signal) {
     const name = call.function?.name ?? "";
     const args = call.function?.arguments ?? "{}";
@@ -1857,6 +1919,7 @@ ${reason}`
     this.scratch.reset();
     this.repair.resetStorm();
     this._turnFailures.reset();
+    this._readOnlyLoop.reset();
     this._turnSelfCorrected = false;
     this._escalateThisTurn = false;
     this._foldedThisTurn = false;
@@ -2283,6 +2346,17 @@ ${reason}`
               })
             };
           }
+          if (this.noteReadOnlyToolCall(call)) {
+            yield {
+              turn: this._turn,
+              role: "warning",
+              content: t("loop.readOnlyLoopEscalation", {
+                model: ESCALATION_MODEL,
+                n: this._readOnlyLoop.currentStreak,
+                fallback: this.model
+              })
+            };
+          }
           yield {
             turn: this._turn,
             role: "tool",
@@ -2687,7 +2761,7 @@ function parseAtQuery(query) {
     trailingSlash: false
   };
 }
-var AT_PICKER_PREFIX = /(?:^|\s)@([a-zA-Z0-9_./\\-]*)$/;
+var AT_PICKER_PREFIX = /(?:^|\s)@([\p{L}\p{N}_./\\-]*)$/u;
 function detectAtPicker(input) {
   const m = AT_PICKER_PREFIX.exec(input);
   if (!m) return null;
@@ -2773,7 +2847,7 @@ function fuzzySubseqScore(needle, target) {
   const lengthPenalty = Math.floor(target.length / 4);
   return quality + lengthPenalty;
 }
-var AT_MENTION_PATTERN = /(?<=^|\s)@([a-zA-Z0-9_./\\-]+)/g;
+var AT_MENTION_PATTERN = /(?<=^|\s)@([\p{L}\p{N}_./\\-]+)/gu;
 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);
@@ -2903,6 +2977,16 @@ var defaultFs = {
 function registerMemoryTools(registry, opts = {}) {
   const store = new MemoryStore({ homeDir: opts.homeDir, projectRoot: opts.projectRoot });
   const hasProject = store.hasProjectScope();
+  const registry_types = loadMemoryTypeRegistry();
+  const customTypeNames = registry_types.filter((r) => !r.builtin).map((r) => r.name);
+  const typeDescParts = [
+    "'user' = role/skills/prefs; 'feedback' = corrections or confirmed approaches; 'project' = facts/decisions about the current work; 'reference' = pointers to external systems the user uses."
+  ];
+  if (customTypeNames.length > 0) {
+    typeDescParts.push(
+      `Custom types declared in config: ${customTypeNames.join(", ")}. Any string is accepted; unknown types are stored verbatim and treated as 'reference' priority.`
+    );
+  }
   registry.register({
     name: "remember",
     description: "Save a memory for future sessions. Use when the user states a preference, corrects your approach, shares a non-obvious fact about this project, or explicitly asks you to remember something. Don't remember transient task state \u2014 only things worth recalling next session. The memory is written now but won't re-load into the system prompt until the next `/new` or launch.",
@@ -2911,8 +2995,7 @@ function registerMemoryTools(registry, opts = {}) {
       properties: {
         type: {
           type: "string",
-          enum: ["user", "feedback", "project", "reference"],
-          description: "'user' = role/skills/prefs; 'feedback' = corrections or confirmed approaches; 'project' = facts/decisions about the current work; 'reference' = pointers to external systems the user uses."
+          description: typeDescParts.join(" ")
         },
         scope: {
           type: "string",
@@ -2930,6 +3013,16 @@ function registerMemoryTools(registry, opts = {}) {
         content: {
           type: "string",
           description: "Full memory body in markdown. For feedback/project types, structure as: rule/fact, then **Why:** line, then **How to apply:** line."
+        },
+        priority: {
+          type: "string",
+          enum: ["low", "medium", "high"],
+          description: "Optional per-memory priority. `high` injects the entry into a `# HIGH PRIORITY constraints` block at the top of the system prompt \u2014 use sparingly, only for hard rules the model must never violate."
+        },
+        expires: {
+          type: "string",
+          enum: ["project_end"],
+          description: "Optional lifecycle hint. `project_end` causes `/memory clear project` to also remove this entry even when it's stored at global scope."
         }
       },
       required: ["type", "scope", "name", "description", "content"]
@@ -2946,7 +3039,9 @@ function registerMemoryTools(registry, opts = {}) {
           type: args.type,
           scope: args.scope,
           description: args.description,
-          body: args.content
+          body: args.content,
+          ...args.priority ? { priority: args.priority } : {},
+          ...args.expires ? { expires: args.expires } : {}
         });
         const key = sanitizeMemoryName(args.name);
         return [
@@ -3488,7 +3583,7 @@ ${i + 1}. ${r.title}`);
 
 // src/tools/filesystem.ts
 import { promises as fs3 } from "fs";
-import * as pathMod3 from "path";
+import * as pathMod4 from "path";
 import picomatch2 from "picomatch";
 
 // src/tools/fs/glob.ts
@@ -3554,15 +3649,149 @@ async function globFiles(ctx, startAbs, args) {
   return lines.join("\n");
 }
 
+// src/tools/fs/outline.ts
+import * as pathMod2 from "path";
+var OUTLINE_MAX_ENTRIES = 30;
+var OUTLINE_TAIL_KEEP = 5;
+var TS_EXPORT_RE = /^export\s+(?:default\s+)?(?:async\s+)?(function|class|const|let|var|interface|type|enum)\s+\*?\s*(\w+)/;
+var PY_DECL_RE = /^(?:async\s+)?(def|class)\s+(\w+)/;
+var GO_DECL_RE = /^(func|type|var|const)\s+(?:\([^)]+\)\s+)?(\w+)/;
+var RUST_DECL_RE = /^(?:pub(?:\([^)]+\))?\s+)?(?:async\s+)?(?:unsafe\s+)?(fn|struct|enum|trait|mod|type|const|static|union)\s+(\w+)/;
+var RUST_IMPL_RE = /^(?:unsafe\s+)?impl(?:\s*<[^>]+>)?\s+(?:[^{]+\s+for\s+)?(\w+)/;
+var MD_HEADING_RE = /^(#{1,6})\s+(.+?)\s*$/;
+var MD_FENCE_RE = /^```/;
+var EXT_TO_LANG = {
+  ".ts": "ts",
+  ".tsx": "ts",
+  ".mts": "ts",
+  ".cts": "ts",
+  ".js": "ts",
+  ".jsx": "ts",
+  ".mjs": "ts",
+  ".cjs": "ts",
+  ".py": "py",
+  ".pyi": "py",
+  ".go": "go",
+  ".rs": "rust",
+  ".md": "md",
+  ".markdown": "md",
+  ".mdx": "md"
+};
+function extractOutline(filename, lines) {
+  const ext = pathMod2.extname(filename).toLowerCase();
+  const lang = EXT_TO_LANG[ext];
+  if (!lang) return [];
+  switch (lang) {
+    case "ts":
+      return extractTs(lines);
+    case "py":
+      return extractPython(lines);
+    case "go":
+      return extractGo(lines);
+    case "rust":
+      return extractRust(lines);
+    case "md":
+      return extractMarkdown(lines);
+  }
+}
+function extractTs(lines) {
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.startsWith("export ")) continue;
+    const m = TS_EXPORT_RE.exec(line);
+    if (!m) continue;
+    out.push({ line: i + 1, text: `export ${m[1]} ${m[2]}` });
+  }
+  return out;
+}
+function extractPython(lines) {
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith(" ") || line.startsWith("	")) continue;
+    const m = PY_DECL_RE.exec(line);
+    if (!m) continue;
+    out.push({ line: i + 1, text: `${m[1]} ${m[2]}` });
+  }
+  return out;
+}
+function extractGo(lines) {
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith(" ") || line.startsWith("	")) continue;
+    const m = GO_DECL_RE.exec(line);
+    if (!m) continue;
+    out.push({ line: i + 1, text: `${m[1]} ${m[2]}` });
+  }
+  return out;
+}
+function extractRust(lines) {
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith(" ") || line.startsWith("	")) continue;
+    const implMatch = RUST_IMPL_RE.exec(line);
+    if (implMatch) {
+      out.push({ line: i + 1, text: `impl ${implMatch[1]}` });
+      continue;
+    }
+    const m = RUST_DECL_RE.exec(line);
+    if (!m) continue;
+    out.push({ line: i + 1, text: `${m[1]} ${m[2]}` });
+  }
+  return out;
+}
+function extractMarkdown(lines) {
+  const out = [];
+  let inFence = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (MD_FENCE_RE.test(line)) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) continue;
+    const m = MD_HEADING_RE.exec(line);
+    if (!m) continue;
+    out.push({ line: i + 1, text: `${m[1]} ${m[2]}` });
+  }
+  return out;
+}
+function formatOutline(entries) {
+  const total = entries.length;
+  if (total === 0) return "";
+  const lastEntry = entries[total - 1];
+  const width = String(lastEntry.line).length;
+  const fmt = (e) => `  L${String(e.line).padStart(width, " ")}  ${e.text}`;
+  const header = `[outline: ${total} symbol${total === 1 ? "" : "s"}]`;
+  if (total <= OUTLINE_MAX_ENTRIES) {
+    return [header, ...entries.map(fmt)].join("\n");
+  }
+  const headCount = OUTLINE_MAX_ENTRIES - OUTLINE_TAIL_KEEP;
+  const headEntries = entries.slice(0, headCount);
+  const tailEntries = entries.slice(-OUTLINE_TAIL_KEEP);
+  const omitted = total - OUTLINE_MAX_ENTRIES;
+  const gapStart = headEntries[headEntries.length - 1].line;
+  const gapEnd = tailEntries[0].line;
+  return [
+    header,
+    ...headEntries.map(fmt),
+    `  [\u2026 ${omitted} more symbol${omitted === 1 ? "" : "s"} between L${gapStart} and L${gapEnd} \u2026]`,
+    ...tailEntries.map(fmt)
+  ].join("\n");
+}
+
 // src/tools/fs/search.ts
 import { promises as fs2 } from "fs";
-import * as pathMod2 from "path";
+import * as pathMod3 from "path";
 function throwIfAborted(signal) {
   if (!signal?.aborted) return;
   throw new DOMException("search aborted by user", "AbortError");
 }
 function displayRel2(rootDir, full) {
-  return pathMod2.relative(rootDir, full).replaceAll("\\", "/");
+  return pathMod3.relative(rootDir, full).replaceAll("\\", "/");
 }
 async function searchFiles(ctx, startAbs, args) {
   throwIfAborted(args.signal);
@@ -3586,7 +3815,7 @@ async function searchFiles(ctx, startAbs, args) {
     }
     for (const e of entries) {
       throwIfAborted(args.signal);
-      const full = pathMod2.join(dir, e.name);
+      const full = pathMod3.join(dir, e.name);
       const lower = e.name.toLowerCase();
       const hit = re ? re.test(e.name) : lower.includes(needle);
       if (hit) {
@@ -3665,11 +3894,11 @@ async function searchContent(ctx, startAbs, args) {
       throwIfAborted(args.signal);
       if (e.isDirectory()) {
         if (!includeDeps && ctx.skipDirNames.has(e.name)) continue;
-        await walk2(pathMod2.join(dir, e.name));
+        await walk2(pathMod3.join(dir, e.name));
         continue;
       }
       if (!e.isFile()) continue;
-      const full = pathMod2.join(dir, e.name);
+      const full = pathMod3.join(dir, e.name);
       if (ctx.nameMatch && !ctx.nameMatch(e.name, displayRel2(ctx.rootDir, full))) continue;
       if (ctx.isBinaryByName(e.name)) continue;
       let fh;
@@ -3766,47 +3995,11 @@ var DEFAULT_MAX_LIST_BYTES = 256 * 1024;
 var DEFAULT_AUTO_PREVIEW_LINES = 200;
 var AUTO_PREVIEW_HEAD_LINES = 80;
 var AUTO_PREVIEW_TAIL_LINES = 40;
-var OUTLINE_MAX_ENTRIES = 30;
-var OUTLINE_TAIL_KEEP = 5;
-var TS_EXPORT_RE = /^export\s+(?:default\s+)?(?:async\s+)?(function|class|const|let|var|interface|type|enum)\s+\*?\s*(\w+)/;
-function extractTsExportOutline(lines) {
-  const out = [];
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (!line.startsWith("export ")) continue;
-    const m = TS_EXPORT_RE.exec(line);
-    if (!m) continue;
-    out.push({ line: i + 1, kind: m[1], name: m[2] });
-  }
-  return out;
-}
-function formatOutline(entries) {
-  const total = entries.length;
-  if (total === 0) return "";
-  const lastEntry = entries[total - 1];
-  const width = String(lastEntry.line).length;
-  const fmt = (e) => `  L${String(e.line).padStart(width, " ")}  export ${e.kind} ${e.name}`;
-  const header = `[outline: ${total} top-level export${total === 1 ? "" : "s"}]`;
-  if (total <= OUTLINE_MAX_ENTRIES) {
-    return [header, ...entries.map(fmt)].join("\n");
-  }
-  const headCount = OUTLINE_MAX_ENTRIES - OUTLINE_TAIL_KEEP;
-  const headEntries = entries.slice(0, headCount);
-  const tailEntries = entries.slice(-OUTLINE_TAIL_KEEP);
-  const omitted = total - OUTLINE_MAX_ENTRIES;
-  const gapStart = headEntries[headEntries.length - 1].line;
-  const gapEnd = tailEntries[0].line;
-  return [
-    header,
-    ...headEntries.map(fmt),
-    `  [\u2026 ${omitted} more export${omitted === 1 ? "" : "s"} between L${gapStart} and L${gapEnd} \u2026]`,
-    ...tailEntries.map(fmt)
-  ].join("\n");
-}
+var OUTLINE_MAX_ENTRIES2 = 30;
 var SKIP_DIR_NAMES = new Set(DEFAULT_INDEX_EXCLUDES.dirs);
 var BINARY_EXTENSIONS = new Set(DEFAULT_INDEX_EXCLUDES.exts);
 function displayRel3(rootDir, full) {
-  return pathMod3.relative(rootDir, full).replaceAll("\\", "/");
+  return pathMod4.relative(rootDir, full).replaceAll("\\", "/");
 }
 var GLOB_METACHARS = /[*?{[]/;
 function compileNameFilter(filter) {
@@ -3825,16 +4018,16 @@ function isLikelyBinaryByName(name) {
   return BINARY_EXTENSIONS.has(name.slice(dot).toLowerCase());
 }
 function registerFilesystemTools(registry, opts) {
-  const rootDir = pathMod3.resolve(opts.rootDir);
+  const rootDir = pathMod4.resolve(opts.rootDir);
   const allowWriting = opts.allowWriting !== false;
   const maxReadBytes = opts.maxReadBytes ?? DEFAULT_MAX_READ_BYTES;
   const maxListBytes = opts.maxListBytes ?? DEFAULT_MAX_LIST_BYTES;
-  const normRoot = pathMod3.resolve(rootDir);
+  const normRoot = pathMod4.resolve(rootDir);
   const sessionApproved = /* @__PURE__ */ new Set();
   const inflightGate = /* @__PURE__ */ new Map();
   function pathIsUnder(child, parent) {
-    const rel = pathMod3.relative(parent, child);
-    return rel === "" || !rel.startsWith("..") && !pathMod3.isAbsolute(rel);
+    const rel = pathMod4.relative(parent, child);
+    return rel === "" || !rel.startsWith("..") && !pathMod4.isAbsolute(rel);
   }
   function looksLikeAbsoluteSystemPath(raw) {
     if (/^[A-Za-z]:[\\/]/.test(raw)) return true;
@@ -3850,7 +4043,7 @@ function registerFilesystemTools(registry, opts) {
       if (pathIsUnder(abs, dir)) return;
     }
     const stat2 = await safeLstat(abs);
-    const allowPrefix = stat2?.isDirectory() ? abs : pathMod3.dirname(abs);
+    const allowPrefix = stat2?.isDirectory() ? abs : pathMod4.dirname(abs);
     let pending = inflightGate.get(allowPrefix);
     if (!pending) {
       const gate = ctx?.confirmationGate ?? pauseGate;
@@ -3878,7 +4071,7 @@ function registerFilesystemTools(registry, opts) {
       throw new Error("path must be a non-empty string");
     }
     if (looksLikeAbsoluteSystemPath(raw)) {
-      const abs = pathMod3.resolve(raw);
+      const abs = pathMod4.resolve(raw);
       if (pathIsUnder(abs, normRoot)) return abs;
       await ensureOutsideSandboxAllowed(abs, intent, toolName, ctx);
       return abs;
@@ -3888,7 +4081,7 @@ function registerFilesystemTools(registry, opts) {
       normalized = normalized.slice(1);
     }
     if (normalized.length === 0) normalized = ".";
-    const resolved = pathMod3.resolve(rootDir, normalized);
+    const resolved = pathMod4.resolve(rootDir, normalized);
     if (!pathIsUnder(resolved, normRoot)) {
       throw new Error(
         `path escapes sandbox root (${normRoot}): ${raw} \u2014 use an absolute system path like /Users/foo or C:\\Users\\foo to request approved outside-sandbox access`
@@ -3910,7 +4103,7 @@ function registerFilesystemTools(registry, opts) {
   - head: N  \u2192 first N lines (imports, public API, small configs)
   - tail: N  \u2192 last N lines (recently-added code, log tails)
   - range: "A-B"  \u2192 inclusive line range A..B, 1-indexed (e.g. "120-180" around an edit site)
-When none of these is given AND the file is longer than ${DEFAULT_AUTO_PREVIEW_LINES} lines, the tool auto-returns a head+tail preview with an "N lines omitted" marker, plus a top-level export outline (function / class / const / interface / type / enum names with line numbers, capped at ${OUTLINE_MAX_ENTRIES}) so you can pick a smart range without a follow-up grep. If you need the middle, re-call with a range. Prefer search_content to locate a symbol first only when the outline doesn't have what you want \u2014 one scoped read beats three full-file reads.`,
+When none of these is given AND the file is longer than ${DEFAULT_AUTO_PREVIEW_LINES} lines, the tool auto-returns a head+tail preview with an "N lines omitted" marker, plus a top-level symbol outline (TS/JS exports, Python def/class, Go func/type, Rust fn/struct/impl/trait, Markdown headings, with line numbers, capped at ${OUTLINE_MAX_ENTRIES2}) so you can pick a smart range without a follow-up grep. If you need the middle, re-call with a range. Prefer search_content to locate a symbol first only when the outline doesn't have what you want \u2014 one scoped read beats three full-file reads.`,
     readOnly: true,
     stormExempt: true,
     parameters: {
@@ -3978,7 +4171,7 @@ ${slice.join("\n")}`;
       const head = lines.slice(0, AUTO_PREVIEW_HEAD_LINES).join("\n");
       const tail = lines.slice(totalLines - AUTO_PREVIEW_TAIL_LINES).join("\n");
       const omitted = totalLines - AUTO_PREVIEW_HEAD_LINES - AUTO_PREVIEW_TAIL_LINES;
-      const outline = formatOutline(extractTsExportOutline(lines));
+      const outline = formatOutline(extractOutline(abs, lines));
       const parts = [
         `[auto-preview: head ${AUTO_PREVIEW_HEAD_LINES} + tail ${AUTO_PREVIEW_TAIL_LINES} of ${totalLines} lines]`,
         head
@@ -4086,7 +4279,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
           lines.push(line);
           emitted++;
           if (e.isDirectory() && !skip) {
-            await walk2(pathMod3.join(dir, e.name), depth + 1);
+            await walk2(pathMod4.join(dir, e.name), depth + 1);
           }
         }
       };
@@ -4246,7 +4439,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
     },
     fn: async (args, ctx) => {
       const abs = await safePath(args.path, "write_file", ctx, "write");
-      await fs3.mkdir(pathMod3.dirname(abs), { recursive: true });
+      await fs3.mkdir(pathMod4.dirname(abs), { recursive: true });
       await fs3.writeFile(abs, args.content, "utf8");
       return `wrote ${args.content.length} chars to ${displayRel3(rootDir, abs)}`;
     }
@@ -4332,7 +4525,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
     fn: async (args, ctx) => {
       const src = await safePath(args.source, "move_file", ctx, "write");
       const dst = await safePath(args.destination, "move_file", ctx, "write");
-      await fs3.mkdir(pathMod3.dirname(dst), { recursive: true });
+      await fs3.mkdir(pathMod4.dirname(dst), { recursive: true });
       await fs3.rename(src, dst);
       return `moved ${displayRel3(rootDir, src)} \u2192 ${displayRel3(rootDir, dst)}`;
     }
@@ -4400,7 +4593,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
     fn: async (args, ctx) => {
       const src = await safePath(args.source, "copy_file", ctx);
       const dst = await safePath(args.destination, "copy_file", ctx, "write");
-      await fs3.mkdir(pathMod3.dirname(dst), { recursive: true });
+      await fs3.mkdir(pathMod4.dirname(dst), { recursive: true });
       await fs3.cp(src, dst, { recursive: true, force: false, errorOnExist: true });
       return `copied ${displayRel3(rootDir, src)} \u2192 ${displayRel3(rootDir, dst)}`;
     }
@@ -5234,4 +5427,4 @@ export {
   snapshotBeforeEdits,
   restoreSnapshots
 };
-//# sourceMappingURL=chunk-4YV2GBYG.js.map
+//# sourceMappingURL=chunk-IEA6JOIP.js.map