@proxysoul/soulforge 2.18.6 → 2.20.0

package/dist/workers/intelligence.worker.js

@@ -18416,6 +18416,378 @@ var init_file_tree = __esm(() => {
   IGNORED_DIRS = new Set(["node_modules", ".git", "dist", "build", ".next", ".nuxt", "target", "__pycache__", ".cache", ".soulforge", "coverage"]);
 });
 
+// node_modules/ignore/index.js
+var require_ignore = __commonJS((exports, module2) => {
+  function makeArray(subject) {
+    return Array.isArray(subject) ? subject : [subject];
+  }
+  var UNDEFINED = undefined;
+  var EMPTY = "";
+  var SPACE = " ";
+  var ESCAPE = "\\";
+  var REGEX_TEST_BLANK_LINE = /^\s+$/;
+  var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+  var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+  var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+  var REGEX_SPLITALL_CRLF = /\r?\n/g;
+  var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
+  var REGEX_TEST_TRAILING_SLASH = /\/$/;
+  var SLASH = "/";
+  var TMP_KEY_IGNORE = "node-ignore";
+  if (typeof Symbol !== "undefined") {
+    TMP_KEY_IGNORE = Symbol.for("node-ignore");
+  }
+  var KEY_IGNORE = TMP_KEY_IGNORE;
+  var define = (object, key2, value) => {
+    Object.defineProperty(object, key2, { value });
+    return value;
+  };
+  var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+  var RETURN_FALSE = () => false;
+  var sanitizeRange = (range2) => range2.replace(REGEX_REGEXP_RANGE, (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY);
+  var cleanRangeBackSlash = (slashes) => {
+    const { length } = slashes;
+    return slashes.slice(0, length - length % 2);
+  };
+  var REPLACERS = [
+    [
+      /^\uFEFF/,
+      () => EMPTY
+    ],
+    [
+      /((?:\\\\)*?)(\\?\s+)$/,
+      (_3, m1, m22) => m1 + (m22.indexOf("\\") === 0 ? SPACE : EMPTY)
+    ],
+    [
+      /(\\+?)\s/g,
+      (_3, m1) => {
+        const { length } = m1;
+        return m1.slice(0, length - length % 2) + SPACE;
+      }
+    ],
+    [
+      /[\\$.|*+(){^]/g,
+      (match) => `\\${match}`
+    ],
+    [
+      /(?!\\)\?/g,
+      () => "[^/]"
+    ],
+    [
+      /^\//,
+      () => "^"
+    ],
+    [
+      /\//g,
+      () => "\\/"
+    ],
+    [
+      /^\^*\\\*\\\*\\\//,
+      () => "^(?:.*\\/)?"
+    ],
+    [
+      /^(?=[^^])/,
+      function startingReplacer() {
+        return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+      }
+    ],
+    [
+      /\\\/\\\*\\\*(?=\\\/|$)/g,
+      (_3, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+    ],
+    [
+      /(^|[^\\]+)(\\\*)+(?=.+)/g,
+      (_3, p1, p2) => {
+        const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+        return p1 + unescaped;
+      }
+    ],
+    [
+      /\\\\\\(?=[$.|*+(){^])/g,
+      () => ESCAPE
+    ],
+    [
+      /\\\\/g,
+      () => ESCAPE
+    ],
+    [
+      /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+      (match, leadEscape, range2, endEscape, close) => leadEscape === ESCAPE ? `\\[${range2}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range2)}${endEscape}]` : "[]" : "[]"
+    ],
+    [
+      /(?:[^*])$/,
+      (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+    ]
+  ];
+  var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
+  var MODE_IGNORE = "regex";
+  var MODE_CHECK_IGNORE = "checkRegex";
+  var UNDERSCORE = "_";
+  var TRAILING_WILD_CARD_REPLACERS = {
+    [MODE_IGNORE](_3, p1) {
+      const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+      return `${prefix}(?=$|\\/$)`;
+    },
+    [MODE_CHECK_IGNORE](_3, p1) {
+      const prefix = p1 ? `${p1}[^/]*` : "[^/]*";
+      return `${prefix}(?=$|\\/$)`;
+    }
+  };
+  var makeRegexPrefix = (pattern) => REPLACERS.reduce((prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)), pattern);
+  var isString = (subject) => typeof subject === "string";
+  var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+  var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
+
+  class IgnoreRule {
+    constructor(pattern, mark2, body4, ignoreCase, negative, prefix) {
+      this.pattern = pattern;
+      this.mark = mark2;
+      this.negative = negative;
+      define(this, "body", body4);
+      define(this, "ignoreCase", ignoreCase);
+      define(this, "regexPrefix", prefix);
+    }
+    get regex() {
+      const key2 = UNDERSCORE + MODE_IGNORE;
+      if (this[key2]) {
+        return this[key2];
+      }
+      return this._make(MODE_IGNORE, key2);
+    }
+    get checkRegex() {
+      const key2 = UNDERSCORE + MODE_CHECK_IGNORE;
+      if (this[key2]) {
+        return this[key2];
+      }
+      return this._make(MODE_CHECK_IGNORE, key2);
+    }
+    _make(mode, key2) {
+      const str = this.regexPrefix.replace(REGEX_REPLACE_TRAILING_WILDCARD, TRAILING_WILD_CARD_REPLACERS[mode]);
+      const regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
+      return define(this, key2, regex);
+    }
+  }
+  var createRule = ({
+    pattern,
+    mark: mark2
+  }, ignoreCase) => {
+    let negative = false;
+    let body4 = pattern;
+    if (body4.indexOf("!") === 0) {
+      negative = true;
+      body4 = body4.substr(1);
+    }
+    body4 = body4.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+    const regexPrefix = makeRegexPrefix(body4);
+    return new IgnoreRule(pattern, mark2, body4, ignoreCase, negative, regexPrefix);
+  };
+
+  class RuleManager {
+    constructor(ignoreCase) {
+      this._ignoreCase = ignoreCase;
+      this._rules = [];
+    }
+    _add(pattern) {
+      if (pattern && pattern[KEY_IGNORE]) {
+        this._rules = this._rules.concat(pattern._rules._rules);
+        this._added = true;
+        return;
+      }
+      if (isString(pattern)) {
+        pattern = {
+          pattern
+        };
+      }
+      if (checkPattern(pattern.pattern)) {
+        const rule = createRule(pattern, this._ignoreCase);
+        this._added = true;
+        this._rules.push(rule);
+      }
+    }
+    add(pattern) {
+      this._added = false;
+      makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._add, this);
+      return this._added;
+    }
+    test(path, checkUnignored, mode) {
+      let ignored = false;
+      let unignored = false;
+      let matchedRule;
+      this._rules.forEach((rule) => {
+        const { negative } = rule;
+        if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+          return;
+        }
+        const matched = rule[mode].test(path);
+        if (!matched) {
+          return;
+        }
+        ignored = !negative;
+        unignored = negative;
+        matchedRule = negative ? UNDEFINED : rule;
+      });
+      const ret = {
+        ignored,
+        unignored
+      };
+      if (matchedRule) {
+        ret.rule = matchedRule;
+      }
+      return ret;
+    }
+  }
+  var throwError = (message, Ctor) => {
+    throw new Ctor(message);
+  };
+  var checkPath = (path, originalPath, doThrow) => {
+    if (!isString(path)) {
+      return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
+    }
+    if (!path) {
+      return doThrow(`path must not be empty`, TypeError);
+    }
+    if (checkPath.isNotRelative(path)) {
+      const r4 = "`path.relative()`d";
+      return doThrow(`path should be a ${r4} string, but got "${originalPath}"`, RangeError);
+    }
+    return true;
+  };
+  var isNotRelative = (path) => REGEX_TEST_INVALID_PATH.test(path);
+  checkPath.isNotRelative = isNotRelative;
+  checkPath.convert = (p2) => p2;
+
+  class Ignore {
+    constructor({
+      ignorecase = true,
+      ignoreCase = ignorecase,
+      allowRelativePaths = false
+    } = {}) {
+      define(this, KEY_IGNORE, true);
+      this._rules = new RuleManager(ignoreCase);
+      this._strictPathCheck = !allowRelativePaths;
+      this._initCache();
+    }
+    _initCache() {
+      this._ignoreCache = Object.create(null);
+      this._testCache = Object.create(null);
+    }
+    add(pattern) {
+      if (this._rules.add(pattern)) {
+        this._initCache();
+      }
+      return this;
+    }
+    addPattern(pattern) {
+      return this.add(pattern);
+    }
+    _test(originalPath, cache, checkUnignored, slices) {
+      const path = originalPath && checkPath.convert(originalPath);
+      checkPath(path, originalPath, this._strictPathCheck ? throwError : RETURN_FALSE);
+      return this._t(path, cache, checkUnignored, slices);
+    }
+    checkIgnore(path) {
+      if (!REGEX_TEST_TRAILING_SLASH.test(path)) {
+        return this.test(path);
+      }
+      const slices = path.split(SLASH).filter(Boolean);
+      slices.pop();
+      if (slices.length) {
+        const parent = this._t(slices.join(SLASH) + SLASH, this._testCache, true, slices);
+        if (parent.ignored) {
+          return parent;
+        }
+      }
+      return this._rules.test(path, false, MODE_CHECK_IGNORE);
+    }
+    _t(path, cache, checkUnignored, slices) {
+      if (path in cache) {
+        return cache[path];
+      }
+      if (!slices) {
+        slices = path.split(SLASH).filter(Boolean);
+      }
+      slices.pop();
+      if (!slices.length) {
+        return cache[path] = this._rules.test(path, checkUnignored, MODE_IGNORE);
+      }
+      const parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices);
+      return cache[path] = parent.ignored ? parent : this._rules.test(path, checkUnignored, MODE_IGNORE);
+    }
+    ignores(path) {
+      return this._test(path, this._ignoreCache, false).ignored;
+    }
+    createFilter() {
+      return (path) => !this.ignores(path);
+    }
+    filter(paths) {
+      return makeArray(paths).filter(this.createFilter());
+    }
+    test(path) {
+      return this._test(path, this._testCache, true);
+    }
+  }
+  var factory = (options) => new Ignore(options);
+  var isPathValid = (path) => checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
+  var setupWindows = () => {
+    const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+    checkPath.convert = makePosix;
+    const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+    checkPath.isNotRelative = (path) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
+  };
+  if (typeof process !== "undefined" && process.platform === "win32") {
+    setupWindows();
+  }
+  module2.exports = factory;
+  factory.default = factory;
+  module2.exports.isPathValid = isPathValid;
+  define(module2.exports, Symbol.for("setupWindows"), setupWindows);
+});
+
+// src/core/intelligence/ignore.ts
+function parseIgnore(text2) {
+  const out2 = [];
+  for (const line of text2.split(`
+`)) {
+    const s2 = line.trim();
+    if (s2 === "" || s2.startsWith("#"))
+      continue;
+    out2.push(s2);
+  }
+  return out2;
+}
+
+class IgnoreMatcher {
+  ig = import_ignore.default();
+  size;
+  constructor(patterns) {
+    if (patterns.length > 0)
+      this.ig.add(patterns);
+    this.size = patterns.length;
+  }
+  ignores(relPath, isDir) {
+    if (this.size === 0)
+      return false;
+    let p2 = relPath.replace(/\\/g, "/");
+    if (p2.startsWith("/"))
+      p2 = p2.slice(1);
+    if (p2 === "" || p2 === ".")
+      return false;
+    return this.ig.ignores(isDir ? `${p2}/` : p2);
+  }
+}
+function buildIgnoreMatcher(...texts) {
+  const patterns = [];
+  for (const t of texts) {
+    if (t)
+      patterns.push(...parseIgnore(t));
+  }
+  return new IgnoreMatcher(patterns);
+}
+var import_ignore;
+var init_ignore = __esm(() => {
+  import_ignore = __toESM(require_ignore(), 1);
+});
+
 // src/core/intelligence/types.ts
 function detectLanguageFromPath(file) {
   const slash = file.lastIndexOf("/");
@@ -18562,9 +18934,9 @@ var init_types2 = __esm(() => {
 });
 
 // src/core/intelligence/repo-map-utils.ts
-import { readdir, stat } from "fs/promises";
+import { readdir, readFile, stat } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { join as join5, resolve as resolve2 } from "path";
+import { join as join5, relative, resolve as resolve2 } from "path";
 function isIndexablePath(file) {
   return detectLanguageFromPath(file) !== "unknown" || isBareIndexable(file);
 }
@@ -18759,9 +19131,10 @@ async function collectFiles(dir, depth = 0) {
         warning: "Opened in home directory or system root \u2014 no files indexed. Open a project directory instead."
       };
   }
+  const ignore = buildIgnoreMatcher(await readIgnoreFile(join5(dir, ".gitignore")), await readIgnoreFile(join5(dir, ".soulforgeignore")));
   const collected = [];
   let hitCap = false;
-  const walkDone = collectFilesWalk(dir, depth, undefined, collected).then(() => {
+  const walkDone = collectFilesWalk(dir, depth, undefined, collected, dir, ignore).then(() => {
     hitCap = collected.length >= WALK_FILE_CAP;
   });
   const timedOut = await Promise.race([walkDone.then(() => false), new Promise((r4) => setTimeout(() => r4(true), 60000))]);
@@ -18802,7 +19175,8 @@ async function collectFilesViaGit(dir) {
         if (s2.size < MAX_FILE_SIZE)
           files.push({
             path: fullPath,
-            mtimeMs: s2.mtimeMs
+            mtimeMs: s2.mtimeMs,
+            size: s2.size
           });
       } catch {}
       if (files.length % 50 === 0)
@@ -18813,7 +19187,14 @@ async function collectFilesViaGit(dir) {
     return null;
   }
 }
-async function collectFilesWalk(dir, depth, counter, out2) {
+async function readIgnoreFile(path) {
+  try {
+    return await readFile(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function collectFilesWalk(dir, depth, counter, out2, rootDir, ignore) {
   if (depth > MAX_DEPTH)
     return [];
   const ctx = counter ?? {
@@ -18831,20 +19212,24 @@ async function collectFilesWalk(dir, depth, counter, out2) {
           continue;
       }
       const fullPath = join5(dir, entry.name);
+      const rel = relative(rootDir, fullPath);
       if (entry.isDirectory()) {
-        if (!IGNORED_DIRS.has(entry.name)) {
-          await collectFilesWalk(fullPath, depth + 1, ctx, files);
+        if (!IGNORED_DIRS.has(entry.name) && !ignore.ignores(rel, true)) {
+          await collectFilesWalk(fullPath, depth + 1, ctx, files, rootDir, ignore);
         }
       } else if (entry.isFile()) {
         if (isForbidden(fullPath))
           continue;
+        if (ignore.ignores(rel, false))
+          continue;
         if (isIndexablePath(entry.name)) {
           try {
             const s2 = await stat(fullPath);
             if (s2.size < MAX_FILE_SIZE) {
               files.push({
                 path: fullPath,
-                mtimeMs: s2.mtimeMs
+                mtimeMs: s2.mtimeMs,
+                size: s2.size
               });
               ctx.n++;
             }
@@ -18861,6 +19246,7 @@ var INDEXABLE_EXTENSIONS, NON_CODE_LANGUAGES, IMPORT_TRACKABLE_LANGUAGES, BARREL
 var init_repo_map_utils = __esm(() => {
   init_file_tree();
   init_forbidden();
+  init_ignore();
   init_types2();
   INDEXABLE_EXTENSIONS = EXT_TO_LANGUAGE;
   NON_CODE_LANGUAGES = new Set(["unknown", "css", "html", "json", "jsonnet", "toml", "yaml", "xml", "markdown", "mdx", "sql", "graphql", "proto", "properties", "ini", "env", "dockerfile", "makefile", "nix", "hcl", "bazel", "just", "svg", "csv", "ignore", "lockfile"]);
@@ -18881,6 +19267,64 @@ var init_repo_map_utils = __esm(() => {
   WINDOWS_DRIVE_ROOT_RE = /^[A-Za-z]:\\?$/;
 });
 
+// src/core/intelligence/trigram.ts
+function pack(a2, b3, c) {
+  return a2 << 16 | b3 << 8 | c;
+}
+function lower(byte) {
+  return byte >= 65 && byte <= 90 ? byte + 32 : byte;
+}
+function extractContentTrigrams(content) {
+  const out2 = new Set;
+  const len = content.length;
+  if (len < MIN_TRIGRAM_LEN)
+    return out2;
+  for (let i4 = 0;i4 + 2 < len; i4++) {
+    const a2 = lower(content.charCodeAt(i4));
+    const b3 = lower(content.charCodeAt(i4 + 1));
+    const c = lower(content.charCodeAt(i4 + 2));
+    if (isWs(a2) && isWs(b3) && isWs(c))
+      continue;
+    if (a2 > 255 || b3 > 255 || c > 255)
+      continue;
+    out2.add(pack(a2, b3, c));
+  }
+  return out2;
+}
+function isWs(byte) {
+  return byte === 32 || byte === 9 || byte === 10 || byte === 13;
+}
+function extractPatternTrigrams(pattern) {
+  const literal = longestLiteralRun(pattern);
+  if (literal.length < MIN_TRIGRAM_LEN)
+    return null;
+  const set = extractContentTrigrams(literal);
+  if (set.size === 0)
+    return null;
+  return [...set];
+}
+function longestLiteralRun(pattern) {
+  let best = "";
+  let cur = "";
+  for (const ch of pattern) {
+    if (META.has(ch) || ch === " " || ch === "\t" || ch === `
+`) {
+      if (cur.length > best.length)
+        best = cur;
+      cur = "";
+    } else {
+      cur += ch;
+    }
+  }
+  if (cur.length > best.length)
+    best = cur;
+  return best;
+}
+var MAX_POSTINGS_PER_TRIGRAM = 512, MIN_TRIGRAM_LEN = 3, META;
+var init_trigram = __esm(() => {
+  META = new Set([".", "*", "+", "?", "(", ")", "[", "]", "{", "}", "|", "^", "$", "\\"]);
+});
+
 // node_modules/web-tree-sitter/tree-sitter.js
 var exports_tree_sitter = {};
 __export(exports_tree_sitter, {
@@ -22105,7 +22549,7 @@ __export(exports_tree_sitter2, {
   TreeSitterBackend: () => TreeSitterBackend
 });
 import { existsSync as existsSync4 } from "fs";
-import { readFile } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 import { dirname, join as join6, resolve as resolve3 } from "path";
 function extractImportSpecifiers(node, language) {
   const specifiers = [];
@@ -23194,7 +23638,7 @@ var init_tree_sitter2 = __esm(() => {
         const lines = node.endPosition.row - node.startPosition.row + 1;
         if (lines >= TreeSitterBackend.MIN_HASH_LINES) {
           const hasArrow = node.namedChildren.some((c) => {
-            if (!c || c.type !== "variable_declarator")
+            if (c?.type !== "variable_declarator")
               return false;
             return c.namedChildren.some((gc) => gc != null && (gc.type === "arrow_function" || gc.type === "function_expression"));
           });
@@ -23377,7 +23821,7 @@ var init_tree_sitter2 = __esm(() => {
         return this.cache.get(absPath);
       }
       try {
-        return await readFile(absPath, "utf-8");
+        return await readFile2(absPath, "utf-8");
       } catch {
         return null;
       }
@@ -24003,7 +24447,7 @@ __export(exports_repo_map, {
 import { Database } from "bun:sqlite";
 import { chmodSync, existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync3, statSync } from "fs";
 import { stat as statAsync } from "fs/promises";
-import { dirname as dirname2, extname, join as join7, relative, resolve as resolve4 } from "path";
+import { dirname as dirname2, extname, join as join7, relative as relative2, resolve as resolve4 } from "path";
 
 class RepoMap {
   static testFileMatch(alias = "f") {
@@ -24194,6 +24638,21 @@ class RepoMap {
       CREATE INDEX IF NOT EXISTS idx_calls_callee ON calls(callee_symbol_id);
       CREATE INDEX IF NOT EXISTS idx_calls_callee_file ON calls(callee_file_id);
     `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS trigrams (
+        trigram INTEGER NOT NULL,
+        file_id INTEGER NOT NULL REFERENCES files(id) ON DELETE CASCADE,
+        PRIMARY KEY (trigram, file_id)
+      ) WITHOUT ROWID;
+    `);
+    this.db.run("CREATE INDEX IF NOT EXISTS idx_trigrams_file ON trigrams(file_id)");
+    try {
+      this.db.run("ALTER TABLE files ADD COLUMN size_bytes INTEGER NOT NULL DEFAULT 0");
+    } catch {}
+    try {
+      this.db.run("ALTER TABLE symbols ADD COLUMN moniker TEXT");
+    } catch {}
+    this.db.run("CREATE INDEX IF NOT EXISTS idx_symbols_moniker ON symbols(moniker)");
     this.migrateSemanticSource();
     this.migrateSemanticNoCascade();
     this.backfillSummaryPaths();
@@ -24323,26 +24782,28 @@ class RepoMap {
         files = allFiles;
       }
       const existingFiles = new Map;
-      for (const row of this.db.query("SELECT id, path, mtime_ms FROM files").all()) {
+      for (const row of this.db.query("SELECT id, path, mtime_ms, size_bytes FROM files").all()) {
         existingFiles.set(row.path, {
           id: row.id,
-          mtime_ms: row.mtime_ms
+          mtime_ms: row.mtime_ms,
+          size_bytes: row.size_bytes
         });
       }
       const currentPaths = new Set;
       const toIndex = [];
       for (const file of files) {
-        const relPath = relative(this.cwd, file.path);
+        const relPath = relative2(this.cwd, file.path);
         currentPaths.add(relPath);
         const existing = existingFiles.get(relPath);
-        if (existing && existing.mtime_ms === file.mtimeMs)
+        if (existing && existing.mtime_ms === file.mtimeMs && existing.size_bytes === file.size)
           continue;
         const language = detectLanguageFromPath(file.path);
         toIndex.push({
           absPath: file.path,
           relPath,
           mtime: file.mtimeMs,
-          language
+          language,
+          size: file.size
         });
       }
       const stale = [...existingFiles.keys()].filter((p2) => !currentPaths.has(p2));
@@ -24364,7 +24825,7 @@ class RepoMap {
           const file = toIndex[i4];
           if (file) {
             try {
-              await this.indexFile(file.absPath, file.relPath, file.mtime, file.language);
+              await this.indexFile(file.absPath, file.relPath, file.mtime, file.language, file.size);
             } catch (err2) {
               this.indexErrors++;
               if (this.indexErrors <= 5) {
@@ -24442,17 +24903,16 @@ class RepoMap {
         }
       } catch {}
     }
-    const sorted = files.map((f2) => ({
-      path: f2.path,
-      mtimeMs: f2.mtimeMs,
-      gitRank: gitRecency.get(relative(this.cwd, f2.path))
-    })).sort((a2, b3) => {
-      const aGit = a2.gitRank !== undefined;
-      const bGit = b3.gitRank !== undefined;
+    const rankFor = (f2) => gitRecency.get(relative2(this.cwd, f2.path));
+    const sorted = [...files].sort((a2, b3) => {
+      const ra = rankFor(a2);
+      const rb = rankFor(b3);
+      const aGit = ra !== undefined;
+      const bGit = rb !== undefined;
       if (aGit !== bGit)
         return aGit ? -1 : 1;
       if (aGit && bGit)
-        return a2.gitRank - b3.gitRank;
+        return ra - rb;
       return b3.mtimeMs - a2.mtimeMs;
     });
     return sorted.slice(0, this.maxFiles);
@@ -24471,7 +24931,7 @@ class RepoMap {
       this.onError?.(`Tree-sitter init failed: ${err2 instanceof Error ? err2.message : String(err2)} \u2014 indexing without AST symbols`);
     }
   }
-  async indexFile(absPath, relPath, mtime, language) {
+  async indexFile(absPath, relPath, mtime, language, size = 0) {
     const existing = this.db.query("SELECT id FROM files WHERE path = ?").get(relPath);
     if (existing) {
       this.db.transaction(() => {
@@ -24483,6 +24943,7 @@ class RepoMap {
         this.db.query("DELETE FROM shape_hashes WHERE file_id = ?").run(existing.id);
         this.db.query("DELETE FROM token_signatures WHERE file_id = ?").run(existing.id);
         this.db.query("DELETE FROM token_fragments WHERE file_id = ?").run(existing.id);
+        this.db.query("DELETE FROM trigrams WHERE file_id = ?").run(existing.id);
         this.db.query("DELETE FROM edges WHERE source_file_id = ? OR target_file_id = ?").run(existing.id, existing.id);
       })();
     }
@@ -24510,9 +24971,9 @@ class RepoMap {
     }
     const symbolCount = outline?.symbols.length ?? 0;
     if (existing) {
-      this.db.query("UPDATE files SET mtime_ms = ?, language = ?, line_count = ?, symbol_count = ? WHERE id = ?").run(mtime, language, lineCount, symbolCount, existing.id);
+      this.db.query("UPDATE files SET mtime_ms = ?, language = ?, line_count = ?, symbol_count = ?, size_bytes = ? WHERE id = ?").run(mtime, language, lineCount, symbolCount, size, existing.id);
     } else {
-      this.db.query("INSERT INTO files (path, mtime_ms, language, line_count, symbol_count) VALUES (?, ?, ?, ?, ?)").run(relPath, mtime, language, lineCount, symbolCount);
+      this.db.query("INSERT INTO files (path, mtime_ms, language, line_count, symbol_count, size_bytes) VALUES (?, ?, ?, ?, ?, ?)").run(relPath, mtime, language, lineCount, symbolCount, size);
     }
     const fileId = existing?.id ?? this.db.query("SELECT id FROM files WHERE path = ?").get(relPath)?.id;
     if (outline) {
@@ -24566,6 +25027,18 @@ class RepoMap {
           });
           qTx();
         }
+        {
+          const mod = relPath.replace(/\.[^./]+$/, "");
+          const rows = this.db.query("SELECT id, name, kind, qualified_name FROM symbols WHERE file_id = ?").all(fileId);
+          const updateMoniker = this.db.prepare("UPDATE symbols SET moniker = ? WHERE id = ?");
+          const mTx = this.db.transaction(() => {
+            for (const r4 of rows) {
+              const descriptor = r4.qualified_name ?? r4.name;
+              updateMoniker.run(`${mod}#${descriptor}(${r4.kind})`, r4.id);
+            }
+          });
+          mTx();
+        }
       }
       {
         const BARREL_RE2 = /\/(index\.(ts|js|tsx|mts|mjs)|__init__\.py|mod\.rs|lib\.rs)$/;
@@ -24659,6 +25132,9 @@ class RepoMap {
         tx();
       }
     }
+    if (content.length <= TRIGRAM_MAX_FILE_BYTES) {
+      this.indexTrigrams(fileId, content);
+    }
     if (!NON_CODE_LANGUAGES.has(language)) {
       const identifiers = this.extractIdentifiers(content, language);
       for (const id of identifiers) {
@@ -24823,7 +25299,7 @@ class RepoMap {
     }
     if (normalized) {
       const base = resolve4(importerDir, normalized);
-      const relBase = relative(this.cwd, base);
+      const relBase = relative2(this.cwd, base);
       if (relBase.startsWith(".."))
         return null;
       return this.resolveRelPath(relBase);
@@ -24871,7 +25347,7 @@ class RepoMap {
       candidates.push(`${base}.go`);
     }
     for (const candidate of candidates) {
-      const relPath = relative(this.cwd, candidate);
+      const relPath = relative2(this.cwd, candidate);
       if (relPath.startsWith(".."))
         continue;
       const row = this.db.query("SELECT id FROM files WHERE path = ?").get(relPath);
@@ -26034,7 +26510,7 @@ class RepoMap {
     return result;
   }
   onFileChanged(absPath) {
-    const relPath = relative(this.cwd, absPath);
+    const relPath = relative2(this.cwd, absPath);
     if (relPath === "package.json" || relPath === "Cargo.toml" || relPath === "go.mod") {
       this.entryPointsCache = null;
     }
@@ -26064,7 +26540,7 @@ class RepoMap {
       }] of batch) {
         try {
           const st = await statAsync(absPath);
-          this.indexFile(absPath, relPath, st.mtimeMs, language);
+          this.indexFile(absPath, relPath, st.mtimeMs, language, st.size);
         } catch (e) {
           this.onError?.(`reindex failed for ${relPath}: ${e instanceof Error ? e.message : String(e)}`);
         }
@@ -26086,12 +26562,12 @@ class RepoMap {
   recheckModifiedFiles() {
     if (!this.ready)
       return;
-    const files = this.db.query("SELECT path, mtime_ms FROM files").all();
+    const files = this.db.query("SELECT path, mtime_ms, size_bytes FROM files").all();
     for (const f2 of files) {
       const absPath = join7(this.cwd, f2.path);
       try {
         const st = statSync(absPath);
-        if (st.mtimeMs !== f2.mtime_ms) {
+        if (st.mtimeMs !== f2.mtime_ms || st.size !== f2.size_bytes) {
           this.onFileChanged(absPath);
         }
       } catch {}
@@ -26481,9 +26957,9 @@ class RepoMap {
   }
   buildPersonalization(opts) {
     const pv = new Map;
-    const mentionedSet = new Set((opts.mentionedFiles ?? []).map((f2) => relative(this.cwd, f2)));
-    const editedSet = new Set((opts.editedFiles ?? []).map((f2) => relative(this.cwd, f2)));
-    const editorRel = opts.editorFile ? relative(this.cwd, opts.editorFile) : null;
+    const mentionedSet = new Set((opts.mentionedFiles ?? []).map((f2) => relative2(this.cwd, f2)));
+    const editedSet = new Set((opts.editedFiles ?? []).map((f2) => relative2(this.cwd, f2)));
+    const editorRel = opts.editorFile ? relative2(this.cwd, opts.editorFile) : null;
     const entryPoints = new Set(this.getEntryPoints());
     if (mentionedSet.size === 0 && editedSet.size === 0 && !editorRel && entryPoints.size === 0)
       return pv;
@@ -26527,9 +27003,9 @@ class RepoMap {
   }
   rankFiles(opts) {
     const allFiles = this.db.query("SELECT id, path, mtime_ms, language, line_count, symbol_count, pagerank, is_barrel FROM files ORDER BY pagerank DESC").all();
-    const mentionedSet = new Set((opts.mentionedFiles ?? []).map((f2) => relative(this.cwd, f2)));
-    const editedSet = new Set((opts.editedFiles ?? []).map((f2) => relative(this.cwd, f2)));
-    const editorRel = opts.editorFile ? relative(this.cwd, opts.editorFile) : null;
+    const mentionedSet = new Set((opts.mentionedFiles ?? []).map((f2) => relative2(this.cwd, f2)));
+    const editedSet = new Set((opts.editedFiles ?? []).map((f2) => relative2(this.cwd, f2)));
+    const editorRel = opts.editorFile ? relative2(this.cwd, opts.editorFile) : null;
     const neighborFiles = new Set;
     const boostFileIds = new Set;
     for (const f2 of allFiles) {
@@ -26666,7 +27142,7 @@ class RepoMap {
     };
   }
   getFileSymbolRanges(relPath) {
-    return this.db.query(`SELECT s.name, s.qualified_name, s.kind, s.line, s.end_line
+    return this.db.query(`SELECT s.name, s.qualified_name, s.kind, s.line, s.end_line, s.moniker
          FROM symbols s JOIN files f ON f.id = s.file_id
          WHERE f.path = ?
            AND s.kind IN ('interface','type','class','function','enum','method','constant')
@@ -26677,7 +27153,8 @@ class RepoMap {
       qualifiedName: r4.qualified_name,
       kind: r4.kind,
       line: r4.line,
-      endLine: r4.end_line
+      endLine: r4.end_line,
+      moniker: r4.moniker
     }));
   }
   findSymbol(name2) {
@@ -27645,17 +28122,75 @@ class RepoMap {
       return null;
     }
   }
+  getEnclosingSymbols(relPath) {
+    return this.db.query(`SELECT s.name, s.kind, s.line, s.end_line
+         FROM symbols s JOIN files f ON f.id = s.file_id
+         WHERE f.path = ? AND s.end_line >= s.line
+         ORDER BY s.line
+         LIMIT 2000`).all(relPath).map((r4) => ({
+      name: r4.name,
+      kind: r4.kind,
+      line: r4.line,
+      endLine: r4.end_line
+    }));
+  }
+  resolveMoniker(moniker) {
+    const row = this.db.query(`SELECT s.name, s.kind, s.line, s.qualified_name, f.path
+           FROM symbols s JOIN files f ON f.id = s.file_id
+          WHERE s.moniker = ?
+          LIMIT 1`).get(moniker);
+    if (!row)
+      return null;
+    return {
+      name: row.name,
+      kind: row.kind,
+      line: row.line,
+      qualifiedName: row.qualified_name,
+      path: row.path
+    };
+  }
+  indexTrigrams(fileId, content) {
+    const trigrams = extractContentTrigrams(content);
+    if (trigrams.size === 0)
+      return;
+    const insert = this.db.prepare("INSERT OR IGNORE INTO trigrams (trigram, file_id) VALUES (?, ?)");
+    const countFor = this.db.prepare("SELECT COUNT(*) AS c FROM trigrams WHERE trigram = ?");
+    const tx = this.db.transaction(() => {
+      for (const tri of trigrams) {
+        const existing = countFor.get(tri)?.c ?? 0;
+        if (existing >= MAX_POSTINGS_PER_TRIGRAM)
+          continue;
+        insert.run(tri, fileId);
+      }
+    });
+    tx();
+  }
+  searchTrigramCandidates(pattern, limit = 5000) {
+    const tris = extractPatternTrigrams(pattern);
+    if (!tris || tris.length === 0)
+      return null;
+    const hasTrigrams = this.db.query("SELECT 1 AS x FROM trigrams LIMIT 1").get();
+    if (!hasTrigrams)
+      return null;
+    const selects = tris.map(() => "SELECT file_id FROM trigrams WHERE trigram = ?");
+    const sql = `SELECT f.path FROM files f WHERE f.id IN (${selects.join(" INTERSECT ")}) LIMIT ?`;
+    const rows = this.db.query(sql).all(...tris, limit);
+    return rows.map((r4) => r4.path);
+  }
 }
+var TRIGRAM_MAX_FILE_BYTES;
 var init_repo_map = __esm(() => {
   init_ensure_soulforge_dir();
   init_clone_detection();
   init_repo_map_constants();
   init_repo_map_utils();
+  init_trigram();
   init_types2();
+  TRIGRAM_MAX_FILE_BYTES = 256 * 1024;
 });
 
 // src/core/intelligence/cache.ts
-import { readFile as readFile2, stat as stat2 } from "fs/promises";
+import { readFile as readFile3, stat as stat2 } from "fs/promises";
 
 class FileCache {
   entries = new Map;
@@ -27673,7 +28208,7 @@ class FileCache {
         this.entries.set(filePath, cached);
         return cached.content;
       }
-      const content = await readFile2(filePath, "utf-8");
+      const content = await readFile3(filePath, "utf-8");
       this.set(filePath, content, mtime);
       return content;
     } catch {
@@ -28551,6 +29086,15 @@ var init_config = __esm(() => {
   NESTED_KEYS = ["editor", "theme", "editorIntegration", "codeIntelligence", "thinking", "performance", "contextManagement", "agentFeatures", "compaction", "retry", "addons"];
 });
 
+// src/core/cwd.ts
+function getCwd() {
+  return _cwd;
+}
+var _cwd;
+var init_cwd = __esm(() => {
+  _cwd = process.cwd();
+});
+
 // src/core/intelligence/backends/lsp/server-registry.ts
 import { existsSync as existsSync8 } from "fs";
 import { join as join10 } from "path";
@@ -28596,7 +29140,7 @@ function resolveCommand(cmd) {
   return null;
 }
 function isServerDisabled(cmd) {
-  const cwd = process.cwd();
+  const cwd = getCwd();
   const global2 = loadConfig();
   const project = loadProjectConfig(cwd);
   const disabled = project?.disabledLspServers ?? global2.disabledLspServers ?? [];
@@ -28624,6 +29168,7 @@ function findServersForLanguage(language) {
 var SERVER_CANDIDATES, MASON_BIN_DIR, SOULFORGE_BIN_DIR, BIN_SUFFIXES, probeCache;
 var init_server_registry = __esm(() => {
   init_config();
+  init_cwd();
   init_platform();
   SERVER_CANDIDATES = {
     typescript: [{
@@ -29781,7 +30326,7 @@ var init_pid_tracker = __esm(() => {
 
 // src/core/intelligence/backends/lsp/standalone-client.ts
 import { spawn as spawn2 } from "child_process";
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 
 class StandaloneLspClient {
   config;
@@ -29959,7 +30504,7 @@ class StandaloneLspClient {
     const uri = filePathToUri(filePath);
     let text2;
     try {
-      text2 = await readFile3(filePath, "utf-8");
+      text2 = await readFile4(filePath, "utf-8");
     } catch {
       return;
     }
@@ -30429,7 +30974,7 @@ __export(exports_lsp, {
   LspBackend: () => LspBackend
 });
 import { existsSync as existsSync10, readdirSync as readdirSync4 } from "fs";
-import { readdir as readdir2, readFile as readFile4 } from "fs/promises";
+import { readdir as readdir2, readFile as readFile5 } from "fs/promises";
 import { dirname as dirname3, join as join12, resolve as resolve5 } from "path";
 function getNvimBridge() {
   if (_nvimBridge === null) {
@@ -30529,7 +31074,7 @@ class LspBackend {
     const absFile = resolve5(file);
     let content;
     try {
-      content = await readFile4(absFile, "utf-8");
+      content = await readFile5(absFile, "utf-8");
     } catch {
       return null;
     }
@@ -30703,7 +31248,7 @@ class LspBackend {
     const absFile = resolve5(file);
     let content;
     try {
-      content = await readFile4(absFile, "utf-8");
+      content = await readFile5(absFile, "utf-8");
     } catch {
       return null;
     }
@@ -30844,7 +31389,7 @@ class LspBackend {
     const absFile = resolve5(file);
     let content;
     try {
-      content = await readFile4(absFile, "utf-8");
+      content = await readFile5(absFile, "utf-8");
     } catch {
       return null;
     }
@@ -31308,7 +31853,7 @@ class LspBackend {
       };
     }
     try {
-      const content = await readFile4(file, "utf-8");
+      const content = await readFile5(file, "utf-8");
       const fileLines = content.split(`
 `);
       const wordPattern = new RegExp(`\\b${escapeRegex(symbol)}\\b`);
@@ -31524,7 +32069,7 @@ async function workspaceEditToRefactorResult(edit, oldName, newName) {
   for (const [filePath, edits] of fileEdits) {
     let content;
     try {
-      content = await readFile4(filePath, "utf-8");
+      content = await readFile5(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -39749,7 +40294,7 @@ ${lanes.join(`
           writeOutputIsTTY() {
             return process.stdout.isTTY;
           },
-          readFile: readFile5,
+          readFile: readFile6,
           writeFile: writeFile2,
           watchFile: watchFile2,
           watchDirectory,
@@ -39942,7 +40487,7 @@ ${lanes.join(`
         function fsWatchWorker(fileOrDirectory, recursive, callback) {
           return _fs.watch(fileOrDirectory, fsSupportsRecursiveFsWatch ? { persistent: true, recursive: !!recursive } : { persistent: true }, callback);
         }
-        function readFile5(fileName, _encoding) {
+        function readFile6(fileName, _encoding) {
           let buffer;
           try {
             buffer = _fs.readFileSync(fileName);
@@ -40539,11 +41084,11 @@ ${lanes.join(`
         return toComponents;
       }
       const components = toComponents.slice(start2);
-      const relative2 = [];
+      const relative3 = [];
       for (;start2 < fromComponents.length; start2++) {
-        relative2.push("..");
+        relative3.push("..");
       }
-      return ["", ...relative2, ...components];
+      return ["", ...relative3, ...components];
     }
     function getRelativePathFromDirectory(fromDirectory, to, getCanonicalFileNameOrIgnoreCase) {
       Debug.assert(getRootLength(fromDirectory) > 0 === getRootLength(to) > 0, "Paths must either both be absolute or both be relative");
@@ -43018,10 +43563,10 @@ ${lanes.join(`
       if (pos1 === pos2)
         return 0;
       const lineStarts = getLineStarts(sourceFile);
-      const lower = Math.min(pos1, pos2);
-      const isNegative = lower === pos2;
+      const lower2 = Math.min(pos1, pos2);
+      const isNegative = lower2 === pos2;
       const upper = isNegative ? pos1 : pos2;
-      const lowerLine = computeLineOfPosition(lineStarts, lower);
+      const lowerLine = computeLineOfPosition(lineStarts, lower2);
       const upperLine = computeLineOfPosition(lineStarts, upper, lowerLine);
       return isNegative ? lowerLine - upperLine : upperLine - lowerLine;
     }
@@ -71009,7 +71554,7 @@ ${lanes.join(`
       const possibleOption = getSpellingSuggestion(unknownOption, diagnostics.optionDeclarations, getOptionName);
       return possibleOption ? createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics.unknownDidYouMeanDiagnostic, unknownOptionErrorText || unknownOption, possibleOption.name) : createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics.unknownOptionDiagnostic, unknownOptionErrorText || unknownOption);
     }
-    function parseCommandLineWorker(diagnostics, commandLine, readFile5) {
+    function parseCommandLineWorker(diagnostics, commandLine, readFile6) {
       const options = {};
       let watchOptions;
       const fileNames = [];
@@ -71047,7 +71592,7 @@ ${lanes.join(`
         }
       }
       function parseResponseFile(fileName) {
-        const text2 = tryReadFile(fileName, readFile5 || ((fileName2) => sys.readFile(fileName2)));
+        const text2 = tryReadFile(fileName, readFile6 || ((fileName2) => sys.readFile(fileName2)));
         if (!isString(text2)) {
           errors.push(text2);
           return;
@@ -71150,8 +71695,8 @@ ${lanes.join(`
       unknownDidYouMeanDiagnostic: Diagnostics.Unknown_compiler_option_0_Did_you_mean_1,
       optionTypeMismatchDiagnostic: Diagnostics.Compiler_option_0_expects_an_argument
     };
-    function parseCommandLine(commandLine, readFile5) {
-      return parseCommandLineWorker(compilerOptionsDidYouMeanDiagnostics, commandLine, readFile5);
+    function parseCommandLine(commandLine, readFile6) {
+      return parseCommandLineWorker(compilerOptionsDidYouMeanDiagnostics, commandLine, readFile6);
     }
     function getOptionFromName(optionName, allowShort) {
       return getOptionDeclarationFromName(getOptionsNameMap, optionName, allowShort);
@@ -71219,8 +71764,8 @@ ${lanes.join(`
       result.originalFileName = result.fileName;
       return parseJsonSourceFileConfigFileContent(result, host, getNormalizedAbsolutePath(getDirectoryPath(configFileName), cwd), optionsToExtend, getNormalizedAbsolutePath(configFileName, cwd), undefined, extraFileExtensions, extendedConfigCache, watchOptionsToExtend);
     }
-    function readConfigFile(fileName, readFile5) {
-      const textOrDiagnostic = tryReadFile(fileName, readFile5);
+    function readConfigFile(fileName, readFile6) {
+      const textOrDiagnostic = tryReadFile(fileName, readFile6);
       return isString(textOrDiagnostic) ? parseConfigFileTextToJson(fileName, textOrDiagnostic) : { config: {}, error: textOrDiagnostic };
     }
     function parseConfigFileTextToJson(fileName, jsonText) {
@@ -71230,14 +71775,14 @@ ${lanes.join(`
         error: jsonSourceFile.parseDiagnostics.length ? jsonSourceFile.parseDiagnostics[0] : undefined
       };
     }
-    function readJsonConfigFile(fileName, readFile5) {
-      const textOrDiagnostic = tryReadFile(fileName, readFile5);
+    function readJsonConfigFile(fileName, readFile6) {
+      const textOrDiagnostic = tryReadFile(fileName, readFile6);
       return isString(textOrDiagnostic) ? parseJsonText(fileName, textOrDiagnostic) : { fileName, parseDiagnostics: [textOrDiagnostic] };
     }
-    function tryReadFile(fileName, readFile5) {
+    function tryReadFile(fileName, readFile6) {
       let text2;
       try {
-        text2 = readFile5(fileName);
+        text2 = readFile6(fileName);
       } catch (e) {
         return createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, fileName, e.message);
       }
@@ -77916,9 +78461,9 @@ ${lanes.join(`
           if (!startsWithDirectory(target, realPathDirectory, getCanonicalFileName)) {
             return;
           }
-          const relative2 = getRelativePathFromDirectory(realPathDirectory, target, getCanonicalFileName);
+          const relative3 = getRelativePathFromDirectory(realPathDirectory, target, getCanonicalFileName);
           for (const symlinkDirectory of symlinkDirectories) {
-            const option2 = resolvePath(symlinkDirectory, relative2);
+            const option2 = resolvePath(symlinkDirectory, relative3);
             const result2 = cb(option2, target === referenceRedirect);
             shouldFilterIgnoredPaths = true;
             if (result2)
@@ -139132,12 +139677,12 @@ ${lanes.join(`
     function createCompilerHost(options, setParentNodes) {
       return createCompilerHostWorker(options, setParentNodes);
     }
-    function createGetSourceFile(readFile5, setParentNodes) {
+    function createGetSourceFile(readFile6, setParentNodes) {
       return (fileName, languageVersionOrOptions, onError) => {
         let text2;
         try {
           mark2("beforeIORead");
-          text2 = readFile5(fileName);
+          text2 = readFile6(fileName);
           mark2("afterIORead");
           measure("I/O Read", "beforeIORead", "afterIORead");
         } catch (e) {
@@ -139928,7 +140473,7 @@ ${lanes.join(`
         getRedirectFromOutput,
         forEachResolvedProjectReference: forEachResolvedProjectReference2
       });
-      const readFile5 = host.readFile.bind(host);
+      const readFile6 = host.readFile.bind(host);
       (_e = tracing) == null || _e.push(tracing.Phase.Program, "shouldProgramCreateNewSourceFiles", { hasOldProgram: !!oldProgram });
       const shouldCreateNewSourceFile = shouldProgramCreateNewSourceFiles(oldProgram, options);
       (_f = tracing) == null || _f.pop();
@@ -140105,7 +140650,7 @@ ${lanes.join(`
         shouldTransformImportCall,
         emitBuildInfo,
         fileExists,
-        readFile: readFile5,
+        readFile: readFile6,
         directoryExists,
         getSymlinkCache,
         realpath: (_o = host.realpath) == null ? undefined : _o.bind(host),
@@ -202995,7 +203540,7 @@ var require_path_browserify = __commonJS((exports, module2) => {
         return ".";
       return posix.normalize(joined);
     },
-    relative: function relative2(from, to) {
+    relative: function relative3(from, to) {
       assertPath(from);
       assertPath(to);
       if (from === to)
@@ -205817,12 +206362,12 @@ var require_dist2 = __commonJS((exports) => {
     return patterns.length > 0 ? buildCrawler(options, patterns) : [];
   }
   async function glob(globInput, options) {
-    const [crawler, relative2] = getCrawler(globInput, options);
-    return crawler ? formatPaths(await crawler.withPromise(), relative2) : [];
+    const [crawler, relative3] = getCrawler(globInput, options);
+    return crawler ? formatPaths(await crawler.withPromise(), relative3) : [];
   }
   function globSync(globInput, options) {
-    const [crawler, relative2] = getCrawler(globInput, options);
-    return crawler ? formatPaths(crawler.sync(), relative2) : [];
+    const [crawler, relative3] = getCrawler(globInput, options);
+    return crawler ? formatPaths(crawler.sync(), relative3) : [];
   }
   exports.convertPathToPattern = convertPathToPattern;
   exports.escapePath = escapePath;
@@ -280394,7 +280939,7 @@ var exports_regex = {};
 __export(exports_regex, {
   RegexBackend: () => RegexBackend
 });
-import { readFile as readFile5 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 import { resolve as resolve7 } from "path";
 function getPatternsForLanguage(language) {
   switch (language) {
@@ -280469,7 +281014,7 @@ class RegexBackend {
   name = "regex";
   tier = 4;
   cache = null;
-  initialize(_cwd) {
+  initialize(_cwd2) {
     return Promise.resolve();
   }
   setCache(cache) {
@@ -280769,7 +281314,7 @@ class RegexBackend {
       return this.cache.get(resolve7(file));
     }
     try {
-      return await readFile5(resolve7(file), "utf-8");
+      return await readFile6(resolve7(file), "utf-8");
     } catch {
       return null;
     }
@@ -281200,8 +281745,8 @@ var LANG_ALIASES = {
 };
 var SHIKI_LANGS = ["typescript", "javascript", "tsx", "jsx", "python", "rust", "go", "bash", "json", "yaml", "toml", "html", "css", "sql", "markdown", "ruby", "java", "kotlin", "swift", "c", "cpp", "csharp", "php", "lua", "zig", "elixir", "haskell", "ocaml", "scala", "dart", "dockerfile", "graphql", "terraform", "vim", "diff", "ini", "xml"];
 function normalizeLang(lang254) {
-  const lower = lang254.toLowerCase().trim();
-  return LANG_ALIASES[lower] ?? lower;
+  const lower2 = lang254.toLowerCase().trim();
+  return LANG_ALIASES[lower2] ?? lower2;
 }
 async function ensureHighlighter() {
   if (highlighter)
@@ -281278,9 +281823,12 @@ var handlers = {
   findSymbols: (name2) => requireRepoMap().findSymbols(name2),
   findSymbol: (name2) => requireRepoMap().findSymbol(name2),
   searchSymbolsSubstring: (query, limit) => requireRepoMap().searchSymbolsSubstring(query, limit),
+  searchTrigramCandidates: (pattern, limit) => requireRepoMap().searchTrigramCandidates(pattern, limit),
   searchSymbolsFts: (query, limit) => requireRepoMap().searchSymbolsFts(query, limit),
   getFileSymbols: (relPath) => requireRepoMap().getFileSymbols(relPath),
   getFileSymbolRanges: (relPath) => requireRepoMap().getFileSymbolRanges(relPath),
+  getEnclosingSymbols: (relPath) => requireRepoMap().getEnclosingSymbols(relPath),
+  resolveMoniker: (moniker) => requireRepoMap().resolveMoniker(moniker),
   getSymbolSignature: (name2) => requireRepoMap().getSymbolSignature(name2),
   getSymbolsByKind: (kind, limit) => requireRepoMap().getSymbolsByKind(kind, limit),
   matchFiles: (pattern, limit) => requireRepoMap().matchFiles(pattern, limit),