npm - @massa-ai/mcp-client - Versions diffs - 1.41.0 → 1.43.0 - Mend

@massa-ai/mcp-client 1.41.0 → 1.43.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/index.js CHANGED Viewed

@@ -25549,6 +25549,7 @@ var init_massa_ai_config = __esm(() => {
 // ../../packages/shared/dist/config/config-loader.js
 var exports_config_loader = {};
 __export(exports_config_loader, {
+  writeFileAtomically: () => writeFileAtomically,
   saveConfig: () => saveConfig,
   migrateDataDirOnce: () => migrateDataDirOnce,
   loadConfigSafe: () => loadConfigSafe,
@@ -25633,15 +25634,17 @@ function migrateDataDirOnce() {
 function __resetMigrationForTests() {
   migrationAttempted = false;
 }
-function saveConfig(config2) {
-  if (!fs.existsSync(CONFIG_DIR)) {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+function writeFileAtomically(targetPath, content) {
+  const dir = path3.dirname(targetPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
   }
   const unique = `${process.pid}.${++tempFileCounter}.${crypto2.randomBytes(6).toString("hex")}`;
-  const tempFile = path3.join(CONFIG_DIR, `.config.json.${unique}.tmp`);
+  const tempFile = path3.join(dir, `.${path3.basename(targetPath)}.${unique}.tmp`);
   try {
-    fs.writeFileSync(tempFile, JSON.stringify(config2, null, 2));
-    fs.renameSync(tempFile, CONFIG_FILE);
+    fs.writeFileSync(tempFile, content, { mode: 384 });
+    fs.chmodSync(tempFile, 384);
+    fs.renameSync(tempFile, targetPath);
   } catch (error51) {
     try {
       fs.unlinkSync(tempFile);
@@ -25649,6 +25652,9 @@ function saveConfig(config2) {
     throw error51;
   }
 }
+function saveConfig(config2) {
+  writeFileAtomically(CONFIG_FILE, JSON.stringify(config2, null, 2));
+}
 function initConfig() {
   if (!fs.existsSync(CONFIG_FILE)) {
     saveConfig(defaultMassaAiConfig);
@@ -27015,7 +27021,7 @@ function listProfiles(opts = {}) {
       installed,
       skipped: false,
       skipReason: null,
-      activeProfile: platform?.modelProfile?.profile ?? "balanced",
+      activeProfile: platform?.modelProfile?.profile ?? opts.hostDefaults?.[host] ?? "balanced",
       bundleVersion: platform?.plugin?.version ?? null,
       availableProfiles
     };
@@ -27185,6 +27191,114 @@ function reportSucceeded(report) {
   return report.hosts.every((h) => h.status === "switched" || h.status === "skipped");
 }
+// ../../packages/shared/dist/profile-switch/variant-sync.js
+import fs6 from "fs";
+import path9 from "path";
+import crypto5 from "crypto";
+function writeFileIntoDirAtomically(destDir, destName, content) {
+  const unique = `${process.pid}.${++tempFileCounter2}.${crypto5.randomBytes(6).toString("hex")}`;
+  const tempFile = path9.join(destDir, `.${destName}.${unique}.tmp`);
+  try {
+    fs6.writeFileSync(tempFile, content);
+    fs6.renameSync(tempFile, path9.join(destDir, destName));
+  } catch (error51) {
+    try {
+      fs6.unlinkSync(tempFile);
+    } catch {}
+    throw error51;
+  }
+}
+function isSafeDirName(name) {
+  if (name === "." || name === "..")
+    return false;
+  if (name.includes("/") || name.includes("\\") || name.includes(path9.sep))
+    return false;
+  return path9.basename(name) === name;
+}
+function syncHost(host, sourceRoot, targetHome) {
+  const layout = resolveHostLayout(host, { targetHome });
+  if (layout.route === "skip") {
+    return { host, status: "skipped", profiles: [], retained: [], files: 0, reason: layout.reason };
+  }
+  const srcDir = path9.join(sourceRoot, "apps", `${host}-plugin`, "agent-profiles");
+  if (!fs6.existsSync(srcDir) || !fs6.statSync(srcDir).isDirectory()) {
+    return { host, status: "skipped", profiles: [], retained: [], files: 0, reason: "no generated variants for this host" };
+  }
+  if (!fs6.existsSync(layout.variantsRoot)) {
+    return {
+      host,
+      status: "skipped",
+      profiles: [],
+      retained: [],
+      files: 0,
+      reason: `variant tree not present at ${layout.variantsRoot} \u2014 run the plugin installer ` + "or an initial profile switch"
+    };
+  }
+  const profiles = [];
+  let files = 0;
+  for (const entry of fs6.readdirSync(srcDir, { withFileTypes: true })) {
+    if (!entry.isDirectory())
+      continue;
+    if (!isSafeDirName(entry.name))
+      continue;
+    const srcProfileDir = path9.join(srcDir, entry.name);
+    const destProfileDir = path9.join(layout.variantsRoot, entry.name);
+    fs6.mkdirSync(destProfileDir, { recursive: true });
+    for (const fileEntry of fs6.readdirSync(srcProfileDir, { withFileTypes: true })) {
+      if (!fileEntry.isFile())
+        continue;
+      const content = fs6.readFileSync(path9.join(srcProfileDir, fileEntry.name));
+      writeFileIntoDirAtomically(destProfileDir, fileEntry.name, content);
+      files++;
+    }
+    profiles.push(entry.name);
+  }
+  const retained = fs6.readdirSync(layout.variantsRoot, { withFileTypes: true }).filter((e) => e.isDirectory() && !profiles.includes(e.name)).map((e) => e.name).sort();
+  return { host, status: "synced", profiles: profiles.sort(), retained, files };
+}
+function syncGeneratedVariants(opts) {
+  const hosts = opts.hosts ?? HOSTS;
+  if (!opts.sourceRoot) {
+    return hosts.map((host) => ({
+      host,
+      status: "skipped",
+      profiles: [],
+      retained: [],
+      files: 0,
+      reason: "no source checkout \u2014 nothing to sync"
+    }));
+  }
+  const sourceRoot = opts.sourceRoot;
+  return hosts.map((host) => {
+    try {
+      return syncHost(host, sourceRoot, opts.targetHome);
+    } catch (err) {
+      return { host, status: "failed", profiles: [], retained: [], files: 0, error: err.message };
+    }
+  });
+}
+var tempFileCounter2 = 0;
+var init_variant_sync = __esm(() => {
+  init_hosts();
+});
+// ../../packages/shared/dist/profile-switch/repo-root.js
+import fs7 from "fs";
+import path10 from "path";
+function findRepoRootWithMarker(startDir, marker, maxLevels) {
+  let dir = startDir;
+  for (let i = 0;i <= maxLevels; i++) {
+    if (fs7.existsSync(path10.join(dir, marker)))
+      return dir;
+    const parent = path10.dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+var init_repo_root = () => {};
 // ../../packages/shared/dist/index.js
 var init_dist = __esm(() => {
   init_env();
@@ -27193,6 +27307,8 @@ var init_dist = __esm(() => {
   init_state();
   init_lock();
   init_engine();
+  init_variant_sync();
+  init_repo_root();
   init_types2();
   init_interfaces();
   init_utils();
@@ -28714,7 +28830,7 @@ var import_brace_expansion, minimatch = (p, pattern, options = {}) => {
 }, qmarksTestNoExtDot = ([$0]) => {
   const len = $0.length;
   return (f) => f.length === len && f !== "." && f !== "..";
-}, defaultPlatform, path9, sep, GLOBSTAR, qmark2 = "[^/]", star2, twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?", filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options), ext = (a, b = {}) => Object.assign({}, a, b), defaults = (def) => {
+}, defaultPlatform, path11, sep, GLOBSTAR, qmark2 = "[^/]", star2, twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?", filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options), ext = (a, b = {}) => Object.assign({}, a, b), defaults = (def) => {
   if (!def || typeof def !== "object" || !Object.keys(def).length) {
     return minimatch;
   }
@@ -28772,11 +28888,11 @@ var init_esm = __esm(() => {
   starRE = /^\*+$/;
   qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
   defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-  path9 = {
+  path11 = {
     win32: { sep: "\\" },
     posix: { sep: "/" }
   };
-  sep = defaultPlatform === "win32" ? path9.win32.sep : path9.posix.sep;
+  sep = defaultPlatform === "win32" ? path11.win32.sep : path11.posix.sep;
   minimatch.sep = sep;
   GLOBSTAR = Symbol("globstar **");
   minimatch.GLOBSTAR = GLOBSTAR;
@@ -30742,12 +30858,12 @@ var init_esm4 = __esm(() => {
     childrenCache() {
       return this.#children;
     }
-    resolve(path10) {
-      if (!path10) {
+    resolve(path12) {
+      if (!path12) {
         return this;
       }
-      const rootPath = this.getRootString(path10);
-      const dir = path10.substring(rootPath.length);
+      const rootPath = this.getRootString(path12);
+      const dir = path12.substring(rootPath.length);
       const dirParts = dir.split(this.splitSep);
       const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
       return result;
@@ -31275,8 +31391,8 @@ var init_esm4 = __esm(() => {
     newChild(name, type = UNKNOWN, opts = {}) {
       return new PathWin32(name, type, this.root, this.roots, this.nocase, this.childrenCache(), opts);
     }
-    getRootString(path10) {
-      return win32.parse(path10).root;
+    getRootString(path12) {
+      return win32.parse(path12).root;
     }
     getRoot(rootPath) {
       rootPath = uncToDrive(rootPath.toUpperCase());
@@ -31301,8 +31417,8 @@ var init_esm4 = __esm(() => {
     constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
       super(name, type, root, roots, nocase, children, opts);
     }
-    getRootString(path10) {
-      return path10.startsWith("/") ? "/" : "";
+    getRootString(path12) {
+      return path12.startsWith("/") ? "/" : "";
     }
     getRoot(_rootPath) {
       return this.root;
@@ -31321,8 +31437,8 @@ var init_esm4 = __esm(() => {
     #children;
     nocase;
     #fs;
-    constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs6 = defaultFS } = {}) {
-      this.#fs = fsFromOption(fs6);
+    constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs8 = defaultFS } = {}) {
+      this.#fs = fsFromOption(fs8);
       if (cwd instanceof URL || cwd.startsWith("file://")) {
         cwd = fileURLToPath(cwd);
       }
@@ -31358,11 +31474,11 @@ var init_esm4 = __esm(() => {
       }
       this.cwd = prev;
     }
-    depth(path10 = this.cwd) {
-      if (typeof path10 === "string") {
-        path10 = this.cwd.resolve(path10);
+    depth(path12 = this.cwd) {
+      if (typeof path12 === "string") {
+        path12 = this.cwd.resolve(path12);
       }
-      return path10.depth();
+      return path12.depth();
     }
     childrenCache() {
       return this.#children;
@@ -31778,9 +31894,9 @@ var init_esm4 = __esm(() => {
       process4();
       return results;
     }
-    chdir(path10 = this.cwd) {
+    chdir(path12 = this.cwd) {
       const oldCwd = this.cwd;
-      this.cwd = typeof path10 === "string" ? this.cwd.resolve(path10) : path10;
+      this.cwd = typeof path12 === "string" ? this.cwd.resolve(path12) : path12;
       this.cwd[setAsCwd](oldCwd);
     }
   };
@@ -31797,8 +31913,8 @@ var init_esm4 = __esm(() => {
     parseRootPath(dir) {
       return win32.parse(dir).root.toUpperCase();
     }
-    newRoot(fs6) {
-      return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
+    newRoot(fs8) {
+      return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs8 });
     }
     isAbsolute(p) {
       return p.startsWith("/") || p.startsWith("\\") || /^[a-z]:(\/|\\)/i.test(p);
@@ -31814,8 +31930,8 @@ var init_esm4 = __esm(() => {
     parseRootPath(_dir) {
       return "/";
     }
-    newRoot(fs6) {
-      return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
+    newRoot(fs8) {
+      return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs8 });
     }
     isAbsolute(p) {
       return p.startsWith("/");
@@ -32072,8 +32188,8 @@ class MatchRecord {
     this.store.set(target, current === undefined ? n : n & current);
   }
   entries() {
-    return [...this.store.entries()].map(([path10, n]) => [
-      path10,
+    return [...this.store.entries()].map(([path12, n]) => [
+      path12,
       !!(n & 2),
       !!(n & 1)
     ]);
@@ -32277,9 +32393,9 @@ class GlobUtil {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path10, opts) {
+  constructor(patterns, path12, opts) {
     this.patterns = patterns;
-    this.path = path10;
+    this.path = path12;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -32298,11 +32414,11 @@ class GlobUtil {
       });
     }
   }
-  #ignored(path10) {
-    return this.seen.has(path10) || !!this.#ignore?.ignored?.(path10);
+  #ignored(path12) {
+    return this.seen.has(path12) || !!this.#ignore?.ignored?.(path12);
   }
-  #childrenIgnored(path10) {
-    return !!this.#ignore?.childrenIgnored?.(path10);
+  #childrenIgnored(path12) {
+    return !!this.#ignore?.childrenIgnored?.(path12);
   }
   pause() {
     this.paused = true;
@@ -32519,8 +32635,8 @@ var init_walker = __esm(() => {
   init_processor();
   GlobWalker = class GlobWalker extends GlobUtil {
     matches = new Set;
-    constructor(patterns, path10, opts) {
-      super(patterns, path10, opts);
+    constructor(patterns, path12, opts) {
+      super(patterns, path12, opts);
     }
     matchEmit(e) {
       this.matches.add(e);
@@ -32557,8 +32673,8 @@ var init_walker = __esm(() => {
   };
   GlobStream = class GlobStream extends GlobUtil {
     results;
-    constructor(patterns, path10, opts) {
-      super(patterns, path10, opts);
+    constructor(patterns, path12, opts) {
+      super(patterns, path12, opts);
       this.results = new Minipass({
         signal: this.signal,
         objectMode: true
@@ -32986,20 +33102,20 @@ var require_ignore = __commonJS((exports, module) => {
   var throwError = (message, Ctor) => {
     throw new Ctor(message);
   };
-  var checkPath = (path10, originalPath, doThrow) => {
-    if (!isString(path10)) {
+  var checkPath = (path12, originalPath, doThrow) => {
+    if (!isString(path12)) {
       return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
     }
-    if (!path10) {
+    if (!path12) {
       return doThrow(`path must not be empty`, TypeError);
     }
-    if (checkPath.isNotRelative(path10)) {
+    if (checkPath.isNotRelative(path12)) {
       const r = "`path.relative()`d";
       return doThrow(`path should be a ${r} string, but got "${originalPath}"`, RangeError);
     }
     return true;
   };
-  var isNotRelative = (path10) => REGEX_TEST_INVALID_PATH.test(path10);
+  var isNotRelative = (path12) => REGEX_TEST_INVALID_PATH.test(path12);
   checkPath.isNotRelative = isNotRelative;
   checkPath.convert = (p) => p;
@@ -33042,7 +33158,7 @@ var require_ignore = __commonJS((exports, module) => {
     addPattern(pattern) {
       return this.add(pattern);
     }
-    _testOne(path10, checkUnignored) {
+    _testOne(path12, checkUnignored) {
       let ignored = false;
       let unignored = false;
       this._rules.forEach((rule) => {
@@ -33050,7 +33166,7 @@ var require_ignore = __commonJS((exports, module) => {
         if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
           return;
         }
-        const matched = rule.regex.test(path10);
+        const matched = rule.regex.test(path12);
         if (matched) {
           ignored = !negative;
           unignored = negative;
@@ -33062,39 +33178,39 @@ var require_ignore = __commonJS((exports, module) => {
       };
     }
     _test(originalPath, cache, checkUnignored, slices) {
-      const path10 = originalPath && checkPath.convert(originalPath);
-      checkPath(path10, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
-      return this._t(path10, cache, checkUnignored, slices);
+      const path12 = originalPath && checkPath.convert(originalPath);
+      checkPath(path12, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
+      return this._t(path12, cache, checkUnignored, slices);
     }
-    _t(path10, cache, checkUnignored, slices) {
-      if (path10 in cache) {
-        return cache[path10];
+    _t(path12, cache, checkUnignored, slices) {
+      if (path12 in cache) {
+        return cache[path12];
       }
       if (!slices) {
-        slices = path10.split(SLASH);
+        slices = path12.split(SLASH);
       }
       slices.pop();
       if (!slices.length) {
-        return cache[path10] = this._testOne(path10, checkUnignored);
+        return cache[path12] = this._testOne(path12, checkUnignored);
       }
       const parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices);
-      return cache[path10] = parent.ignored ? parent : this._testOne(path10, checkUnignored);
+      return cache[path12] = parent.ignored ? parent : this._testOne(path12, checkUnignored);
     }
-    ignores(path10) {
-      return this._test(path10, this._ignoreCache, false).ignored;
+    ignores(path12) {
+      return this._test(path12, this._ignoreCache, false).ignored;
     }
     createFilter() {
-      return (path10) => !this.ignores(path10);
+      return (path12) => !this.ignores(path12);
     }
     filter(paths) {
       return makeArray(paths).filter(this.createFilter());
     }
-    test(path10) {
-      return this._test(path10, this._testCache, true);
+    test(path12) {
+      return this._test(path12, this._testCache, true);
     }
   }
   var factory = (options) => new Ignore2(options);
-  var isPathValid = (path10) => checkPath(path10 && checkPath.convert(path10), path10, RETURN_FALSE);
+  var isPathValid = (path12) => checkPath(path12 && checkPath.convert(path12), path12, RETURN_FALSE);
   factory.isPathValid = isPathValid;
   factory.default = factory;
   module.exports = factory;
@@ -33102,7 +33218,7 @@ var require_ignore = __commonJS((exports, module) => {
     const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
     checkPath.convert = makePosix;
     const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-    checkPath.isNotRelative = (path10) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path10) || isNotRelative(path10);
+    checkPath.isNotRelative = (path12) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path12) || isNotRelative(path12);
   }
 });
@@ -33164,13 +33280,13 @@ function validatePolicy(policy, opts = {}) {
     }
   }
 }
-function matchesGlob2(path10, pattern) {
+function matchesGlob2(path12, pattern) {
   let re = regexCache.get(pattern);
   if (!re) {
     re = globToRegex(pattern);
     regexCache.set(pattern, re);
   }
-  return re.test(path10);
+  return re.test(path12);
 }
 var MAX_MATCH_WORK = 1e5, MAX_IGNORE_PATTERNS2 = 1024, DEFAULT_POLICY, applyPolicy = (filePath, policy) => {
   const normalized = filePath.trim();
@@ -33221,8 +33337,8 @@ var init_capture_policy = __esm(() => {
 });
 // ../../packages/core/dist/services/search/ignore-patterns.js
-import fs6 from "fs/promises";
-import path10 from "path";
+import fs8 from "fs/promises";
+import path12 from "path";
 function buildExtensionGlob(extensions) {
   return extensions.map((ext2) => `**/*${ext2}`);
 }
@@ -33245,8 +33361,8 @@ async function loadProjectIgnore(projectPath) {
   const ig = ignore();
   ig.add(DEFAULT_IGNORES);
   try {
-    const gitignorePath = path10.join(projectPath, ".gitignore");
-    const gitignoreContent = await fs6.readFile(gitignorePath, "utf8");
+    const gitignorePath = path12.join(projectPath, ".gitignore");
+    const gitignoreContent = await fs8.readFile(gitignorePath, "utf8");
     const rules = gitignoreContent.split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
     ig.add(rules);
@@ -34574,7 +34690,7 @@ var require_cert_signatures = __commonJS((exports, module) => {
 // ../../node_modules/pg/lib/crypto/sasl.js
 var require_sasl = __commonJS((exports, module) => {
-  var crypto5 = require_utils3();
+  var crypto6 = require_utils3();
   var { signatureAlgorithmHashFromCertificate } = require_cert_signatures();
   function saslprep(password) {
     const nonAsciiSpace = /[\u00A0\u1680\u2000-\u200B\u202F\u205F\u3000]/g;
@@ -34593,7 +34709,7 @@ var require_sasl = __commonJS((exports, module) => {
     if (mechanism === "SCRAM-SHA-256-PLUS" && typeof stream2.getPeerCertificate !== "function") {
       throw new Error("SASL: Mechanism SCRAM-SHA-256-PLUS requires a certificate");
     }
-    const clientNonce = crypto5.randomBytes(18).toString("base64");
+    const clientNonce = crypto6.randomBytes(18).toString("base64");
     const gs2Header = mechanism === "SCRAM-SHA-256-PLUS" ? "p=tls-server-end-point" : stream2 ? "y" : "n";
     return {
       mechanism,
@@ -34634,20 +34750,20 @@ var require_sasl = __commonJS((exports, module) => {
       let hashName = signatureAlgorithmHashFromCertificate(peerCert);
       if (hashName === "MD5" || hashName === "SHA-1")
         hashName = "SHA-256";
-      const certHash = await crypto5.hashByName(hashName, peerCert);
+      const certHash = await crypto6.hashByName(hashName, peerCert);
       const bindingData = Buffer.concat([Buffer.from("p=tls-server-end-point,,"), Buffer.from(certHash)]);
       channelBinding = bindingData.toString("base64");
     }
     const clientFinalMessageWithoutProof = "c=" + channelBinding + ",r=" + sv.nonce;
     const authMessage = clientFirstMessageBare + "," + serverFirstMessage + "," + clientFinalMessageWithoutProof;
     const saltBytes = Buffer.from(sv.salt, "base64");
-    const saltedPassword = await crypto5.deriveKey(saslprep(password), saltBytes, sv.iteration);
-    const clientKey = await crypto5.hmacSha256(saltedPassword, "Client Key");
-    const storedKey = await crypto5.sha256(clientKey);
-    const clientSignature = await crypto5.hmacSha256(storedKey, authMessage);
+    const saltedPassword = await crypto6.deriveKey(saslprep(password), saltBytes, sv.iteration);
+    const clientKey = await crypto6.hmacSha256(saltedPassword, "Client Key");
+    const storedKey = await crypto6.sha256(clientKey);
+    const clientSignature = await crypto6.hmacSha256(storedKey, authMessage);
     const clientProof = xorBuffers(Buffer.from(clientKey), Buffer.from(clientSignature)).toString("base64");
-    const serverKey = await crypto5.hmacSha256(saltedPassword, "Server Key");
-    const serverSignatureBytes = await crypto5.hmacSha256(serverKey, authMessage);
+    const serverKey = await crypto6.hmacSha256(saltedPassword, "Server Key");
+    const serverSignatureBytes = await crypto6.hmacSha256(serverKey, authMessage);
     session.message = "SASLResponse";
     session.serverSignature = Buffer.from(serverSignatureBytes).toString("base64");
     session.response = clientFinalMessageWithoutProof + ",p=" + clientProof;
@@ -34842,15 +34958,15 @@ var require_pg_connection_string = __commonJS((exports, module) => {
     if (config3.sslnegotiation === "direct" && config3.ssl === undefined) {
       config3.ssl = true;
     }
-    const fs7 = config3.sslcert || config3.sslkey || config3.sslrootcert ? __require("fs") : null;
+    const fs9 = config3.sslcert || config3.sslkey || config3.sslrootcert ? __require("fs") : null;
     if (config3.sslcert) {
-      config3.ssl.cert = fs7.readFileSync(config3.sslcert).toString();
+      config3.ssl.cert = fs9.readFileSync(config3.sslcert).toString();
     }
     if (config3.sslkey) {
-      config3.ssl.key = fs7.readFileSync(config3.sslkey).toString();
+      config3.ssl.key = fs9.readFileSync(config3.sslkey).toString();
     }
     if (config3.sslrootcert) {
-      config3.ssl.ca = fs7.readFileSync(config3.sslrootcert).toString();
+      config3.ssl.ca = fs9.readFileSync(config3.sslrootcert).toString();
     }
     if (options.useLibpqCompat && config3.uselibpqcompat) {
       throw new Error("Both useLibpqCompat and uselibpqcompat are set. Please use only one of them.");
@@ -36564,7 +36680,7 @@ var require_split2 = __commonJS((exports, module) => {
 // ../../node_modules/pgpass/lib/helper.js
 var require_helper = __commonJS((exports, module) => {
-  var path11 = __require("path");
+  var path13 = __require("path");
   var Stream2 = __require("stream").Stream;
   var split = require_split2();
   var util3 = __require("util");
@@ -36604,7 +36720,7 @@ var require_helper = __commonJS((exports, module) => {
   };
   exports.getFileName = function(rawEnv) {
     var env = rawEnv || process.env;
-    var file2 = env.PGPASSFILE || (isWin ? path11.join(env.APPDATA || "./", "postgresql", "pgpass.conf") : path11.join(env.HOME || "./", ".pgpass"));
+    var file2 = env.PGPASSFILE || (isWin ? path13.join(env.APPDATA || "./", "postgresql", "pgpass.conf") : path13.join(env.HOME || "./", ".pgpass"));
     return file2;
   };
   exports.usePgPass = function(stats, fname) {
@@ -36728,16 +36844,16 @@ var require_helper = __commonJS((exports, module) => {
 // ../../node_modules/pgpass/lib/index.js
 var require_lib = __commonJS((exports, module) => {
-  var path11 = __require("path");
-  var fs7 = __require("fs");
+  var path13 = __require("path");
+  var fs9 = __require("fs");
   var helper = require_helper();
   module.exports = function(connInfo, cb) {
     var file2 = helper.getFileName();
-    fs7.stat(file2, function(err, stat) {
+    fs9.stat(file2, function(err, stat) {
       if (err || !helper.usePgPass(stat, file2)) {
         return cb(undefined);
       }
-      var st = fs7.createReadStream(file2);
+      var st = fs9.createReadStream(file2);
       helper.getPassword(connInfo, st, cb);
     });
   };
@@ -36755,7 +36871,7 @@ var require_client = __commonJS((exports, module) => {
   var Query = require_query();
   var defaults2 = require_defaults2();
   var Connection = require_connection();
-  var crypto5 = require_utils3();
+  var crypto6 = require_utils3();
   var activeQueryDeprecationNotice = nodeUtils.deprecate(() => {}, "Client.activeQuery is deprecated and will be removed in pg@9.0");
   var queryQueueDeprecationNotice = nodeUtils.deprecate(() => {}, "Client.queryQueue is deprecated and will be removed in pg@9.0.");
   var pgPassDeprecationNotice = nodeUtils.deprecate(() => {}, "pgpass support is deprecated and will be removed in pg@9.0. " + "You can provide an async function as the password property to the Client/Pool constructor that returns a password instead. Within this function you can call the pgpass module in your own code.");
@@ -36987,7 +37103,7 @@ var require_client = __commonJS((exports, module) => {
     _handleAuthMD5Password(msg) {
       this._getPassword(async () => {
         try {
-          const hashedPassword = await crypto5.postgresMd5PasswordHash(this.user, this.password, msg.salt);
+          const hashedPassword = await crypto6.postgresMd5PasswordHash(this.user, this.password, msg.salt);
           this.connection.password(hashedPassword);
         } catch (e) {
           this.emit("error", e);
@@ -38436,8 +38552,8 @@ var init_alias_resolver = __esm(() => {
 });
 // ../../packages/core/dist/services/search/index-manager.js
-import fs7 from "fs";
-import path11 from "path";
+import fs9 from "fs";
+import path13 from "path";
 class IndexManager {
   metadataCache = new Map;
@@ -38530,9 +38646,9 @@ class IndexManager {
       const fileMetadata = {};
       let totalSize = 0;
       for (const filePath of indexedFiles) {
-        const fullPath = path11.join(projectPath, filePath);
+        const fullPath = path13.join(projectPath, filePath);
         try {
-          const stat = await fs7.promises.stat(fullPath);
+          const stat = await fs9.promises.stat(fullPath);
           fileMetadata[filePath] = {
             path: filePath,
             mtime: stat.mtimeMs,
@@ -38583,9 +38699,9 @@ class IndexManager {
         if (ig.ignores(match2)) {
           continue;
         }
-        const fullPath = path11.join(projectPath, match2);
+        const fullPath = path13.join(projectPath, match2);
         try {
-          const stat = await fs7.promises.stat(fullPath);
+          const stat = await fs9.promises.stat(fullPath);
           files.set(match2, {
             path: match2,
             mtime: stat.mtimeMs,
@@ -41838,23 +41954,23 @@ var require_auth_config = __commonJS((exports, module) => {
     writeAuthConfig: () => writeAuthConfig
   });
   module.exports = __toCommonJS2(auth_config_exports);
-  var fs8 = __toESM2(__require("fs"));
-  var path12 = __toESM2(__require("path"));
+  var fs10 = __toESM2(__require("fs"));
+  var path14 = __toESM2(__require("path"));
   var import_token_util = require_token_util();
   function getAuthConfigPath() {
     const dataDir = (0, import_token_util.getVercelDataDir)();
     if (!dataDir) {
       throw new Error(`Unable to find Vercel CLI data directory. Your platform: ${process.platform}. Supported: darwin, linux, win32.`);
     }
-    return path12.join(dataDir, "auth.json");
+    return path14.join(dataDir, "auth.json");
   }
   function readAuthConfig() {
     try {
       const authPath = getAuthConfigPath();
-      if (!fs8.existsSync(authPath)) {
+      if (!fs10.existsSync(authPath)) {
         return null;
       }
-      const content = fs8.readFileSync(authPath, "utf8");
+      const content = fs10.readFileSync(authPath, "utf8");
       if (!content) {
         return null;
       }
@@ -41865,11 +41981,11 @@ var require_auth_config = __commonJS((exports, module) => {
   }
   function writeAuthConfig(config3) {
     const authPath = getAuthConfigPath();
-    const authDir = path12.dirname(authPath);
-    if (!fs8.existsSync(authDir)) {
-      fs8.mkdirSync(authDir, { mode: 504, recursive: true });
+    const authDir = path14.dirname(authPath);
+    if (!fs10.existsSync(authDir)) {
+      fs10.mkdirSync(authDir, { mode: 504, recursive: true });
     }
-    fs8.writeFileSync(authPath, JSON.stringify(config3, null, 2), { mode: 384 });
+    fs10.writeFileSync(authPath, JSON.stringify(config3, null, 2), { mode: 384 });
   }
   function isValidAccessToken(authConfig, expirationBufferMs = 0) {
     if (!authConfig.token)
@@ -42044,8 +42160,8 @@ var require_token_util = __commonJS((exports, module) => {
     saveToken: () => saveToken
   });
   module.exports = __toCommonJS2(token_util_exports);
-  var path12 = __toESM2(__require("path"));
-  var fs8 = __toESM2(__require("fs"));
+  var path14 = __toESM2(__require("path"));
+  var fs10 = __toESM2(__require("fs"));
   var import_token_error = require_token_error();
   var import_token_io = require_token_io();
   var import_auth_config = require_auth_config();
@@ -42057,7 +42173,7 @@ var require_token_util = __commonJS((exports, module) => {
     if (!dataDir) {
       return null;
     }
-    return path12.join(dataDir, vercelFolder);
+    return path14.join(dataDir, vercelFolder);
   }
   async function getVercelToken2(options) {
     const authConfig = (0, import_auth_config.readAuthConfig)();
@@ -42125,11 +42241,11 @@ var require_token_util = __commonJS((exports, module) => {
     if (!dir) {
       throw new import_token_error.VercelOidcTokenError("Unable to find project root directory. Have you linked your project with `vc link?`");
     }
-    const prjPath = path12.join(dir, ".vercel", "project.json");
-    if (!fs8.existsSync(prjPath)) {
+    const prjPath = path14.join(dir, ".vercel", "project.json");
+    if (!fs10.existsSync(prjPath)) {
       throw new import_token_error.VercelOidcTokenError("project.json not found, have you linked your project with `vc link?`");
     }
-    const prj = JSON.parse(fs8.readFileSync(prjPath, "utf8"));
+    const prj = JSON.parse(fs10.readFileSync(prjPath, "utf8"));
     if (typeof prj.projectId !== "string" && typeof prj.orgId !== "string") {
       throw new TypeError("Expected a string-valued projectId property. Try running `vc link` to re-link your project.");
     }
@@ -42140,11 +42256,11 @@ var require_token_util = __commonJS((exports, module) => {
     if (!dir) {
       throw new import_token_error.VercelOidcTokenError("Unable to find user data directory. Please reach out to Vercel support.");
     }
-    const tokenPath = path12.join(dir, "com.vercel.token", `${projectId}.json`);
+    const tokenPath = path14.join(dir, "com.vercel.token", `${projectId}.json`);
     const tokenJson = JSON.stringify(token);
-    fs8.mkdirSync(path12.dirname(tokenPath), { mode: 504, recursive: true });
-    fs8.writeFileSync(tokenPath, tokenJson);
-    fs8.chmodSync(tokenPath, 432);
+    fs10.mkdirSync(path14.dirname(tokenPath), { mode: 504, recursive: true });
+    fs10.writeFileSync(tokenPath, tokenJson);
+    fs10.chmodSync(tokenPath, 432);
     return;
   }
   function loadToken(projectId) {
@@ -42152,11 +42268,11 @@ var require_token_util = __commonJS((exports, module) => {
     if (!dir) {
       throw new import_token_error.VercelOidcTokenError("Unable to find user data directory. Please reach out to Vercel support.");
     }
-    const tokenPath = path12.join(dir, "com.vercel.token", `${projectId}.json`);
-    if (!fs8.existsSync(tokenPath)) {
+    const tokenPath = path14.join(dir, "com.vercel.token", `${projectId}.json`);
+    if (!fs10.existsSync(tokenPath)) {
       return null;
     }
-    const token = JSON.parse(fs8.readFileSync(tokenPath, "utf8"));
+    const token = JSON.parse(fs10.readFileSync(tokenPath, "utf8"));
     assertVercelOidcTokenResponse(token);
     return token;
   }
@@ -52998,37 +53114,37 @@ function createOpenAI(options = {}) {
   }, `ai-sdk/openai/${VERSION4}`);
   const createChatModel = (modelId) => new OpenAIChatLanguageModel(modelId, {
     provider: `${providerName}.chat`,
-    url: ({ path: path12 }) => `${baseURL}${path12}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createCompletionModel = (modelId) => new OpenAICompletionLanguageModel(modelId, {
     provider: `${providerName}.completion`,
-    url: ({ path: path12 }) => `${baseURL}${path12}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createEmbeddingModel = (modelId) => new OpenAIEmbeddingModel(modelId, {
     provider: `${providerName}.embedding`,
-    url: ({ path: path12 }) => `${baseURL}${path12}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createImageModel = (modelId) => new OpenAIImageModel(modelId, {
     provider: `${providerName}.image`,
-    url: ({ path: path12 }) => `${baseURL}${path12}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createTranscriptionModel = (modelId) => new OpenAITranscriptionModel(modelId, {
     provider: `${providerName}.transcription`,
-    url: ({ path: path12 }) => `${baseURL}${path12}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createSpeechModel = (modelId) => new OpenAISpeechModel(modelId, {
     provider: `${providerName}.speech`,
-    url: ({ path: path12 }) => `${baseURL}${path12}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
@@ -53041,7 +53157,7 @@ function createOpenAI(options = {}) {
   const createResponsesModel = (modelId) => {
     return new OpenAIResponsesLanguageModel(modelId, {
       provider: `${providerName}.responses`,
-      url: ({ path: path12 }) => `${baseURL}${path12}`,
+      url: ({ path: path14 }) => `${baseURL}${path14}`,
       headers: getHeaders,
       fetch: options.fetch,
       fileIdPrefixes: ["file-"]
@@ -69586,26 +69702,26 @@ var require_process = __commonJS((exports, module) => {
 // ../../node_modules/detect-libc/lib/filesystem.js
 var require_filesystem = __commonJS((exports, module) => {
-  var fs8 = __require("fs");
+  var fs10 = __require("fs");
   var LDD_PATH = "/usr/bin/ldd";
   var SELF_PATH = "/proc/self/exe";
   var MAX_LENGTH = 2048;
-  var readFileSync2 = (path12) => {
-    const fd = fs8.openSync(path12, "r");
+  var readFileSync2 = (path14) => {
+    const fd = fs10.openSync(path14, "r");
     const buffer = Buffer.alloc(MAX_LENGTH);
-    const bytesRead = fs8.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-    fs8.close(fd, () => {});
+    const bytesRead = fs10.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+    fs10.close(fd, () => {});
     return buffer.subarray(0, bytesRead);
   };
-  var readFile = (path12) => new Promise((resolve4, reject) => {
-    fs8.open(path12, "r", (err, fd) => {
+  var readFile = (path14) => new Promise((resolve4, reject) => {
+    fs10.open(path14, "r", (err, fd) => {
       if (err) {
         reject(err);
       } else {
         const buffer = Buffer.alloc(MAX_LENGTH);
-        fs8.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+        fs10.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
           resolve4(buffer.subarray(0, bytesRead));
-          fs8.close(fd, () => {});
+          fs10.close(fd, () => {});
         });
       }
     });
@@ -69710,11 +69826,11 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     return null;
   };
-  var familyFromInterpreterPath = (path12) => {
-    if (path12) {
-      if (path12.includes("/ld-musl-")) {
+  var familyFromInterpreterPath = (path14) => {
+    if (path14) {
+      if (path14.includes("/ld-musl-")) {
         return MUSL;
-      } else if (path12.includes("/ld-linux-")) {
+      } else if (path14.includes("/ld-linux-")) {
         return GLIBC;
       }
     }
@@ -69759,8 +69875,8 @@ var require_detect_libc = __commonJS((exports, module) => {
     cachedFamilyInterpreter = null;
     try {
       const selfContent = await readFile(SELF_PATH);
-      const path12 = interpreterPath(selfContent);
-      cachedFamilyInterpreter = familyFromInterpreterPath(path12);
+      const path14 = interpreterPath(selfContent);
+      cachedFamilyInterpreter = familyFromInterpreterPath(path14);
     } catch (e) {}
     return cachedFamilyInterpreter;
   };
@@ -69771,8 +69887,8 @@ var require_detect_libc = __commonJS((exports, module) => {
     cachedFamilyInterpreter = null;
     try {
       const selfContent = readFileSync2(SELF_PATH);
-      const path12 = interpreterPath(selfContent);
-      cachedFamilyInterpreter = familyFromInterpreterPath(path12);
+      const path14 = interpreterPath(selfContent);
+      cachedFamilyInterpreter = familyFromInterpreterPath(path14);
     } catch (e) {}
     return cachedFamilyInterpreter;
   };
@@ -71434,18 +71550,18 @@ var require_sharp = __commonJS((exports, module) => {
     `@img/sharp-${runtimePlatform}/sharp.node`,
     "@img/sharp-wasm32/sharp.node"
   ];
-  var path12;
+  var path14;
   var sharp;
   var errors4 = [];
-  for (path12 of paths) {
+  for (path14 of paths) {
     try {
-      sharp = __require(path12);
+      sharp = __require(path14);
       break;
     } catch (err) {
       errors4.push(err);
     }
   }
-  if (sharp && path12.startsWith("@img/sharp-linux-x64") && !sharp._isUsingX64V2()) {
+  if (sharp && path14.startsWith("@img/sharp-linux-x64") && !sharp._isUsingX64V2()) {
     const err = new Error("Prebuilt binaries for linux-x64 require v2 microarchitecture");
     err.code = "Unsupported CPU";
     errors4.push(err);
@@ -74307,15 +74423,15 @@ var require_color = __commonJS((exports, module) => {
     };
   }
   function wrapConversion(toModel, graph) {
-    const path12 = [graph[toModel].parent, toModel];
+    const path14 = [graph[toModel].parent, toModel];
     let fn = conversions_default[graph[toModel].parent][toModel];
     let cur = graph[toModel].parent;
     while (graph[cur].parent) {
-      path12.unshift(graph[cur].parent);
+      path14.unshift(graph[cur].parent);
       fn = link(conversions_default[graph[cur].parent][cur], fn);
       cur = graph[cur].parent;
     }
-    fn.conversion = path12;
+    fn.conversion = path14;
     return fn;
   }
   function route(fromModel) {
@@ -74920,7 +75036,7 @@ var require_output = __commonJS((exports, module) => {
     Copyright 2013 Lovell Fuller and others.
     SPDX-License-Identifier: Apache-2.0
   */
-  var path12 = __require("path");
+  var path14 = __require("path");
   var is = require_is();
   var sharp = require_sharp();
   var formats = new Map([
@@ -74951,9 +75067,9 @@ var require_output = __commonJS((exports, module) => {
     let err;
     if (!is.string(fileOut)) {
       err = new Error("Missing output file path");
-    } else if (is.string(this.options.input.file) && path12.resolve(this.options.input.file) === path12.resolve(fileOut)) {
+    } else if (is.string(this.options.input.file) && path14.resolve(this.options.input.file) === path14.resolve(fileOut)) {
       err = new Error("Cannot use same file for input and output");
-    } else if (jp2Regex.test(path12.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
+    } else if (jp2Regex.test(path14.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
       err = errJp2Save();
     }
     if (err) {
@@ -82200,11 +82316,11 @@ var init_transformers_node = __esm(() => {
             throw new Error(`The number of external data chunks (${num_chunks}) exceeds the maximum allowed value (${_utils_hub_js__WEBPACK_IMPORTED_MODULE_5__.MAX_EXTERNAL_DATA_CHUNKS}).`);
           }
           for (let i = 0;i < num_chunks; ++i) {
-            const path12 = `${baseName}_data${i === 0 ? "" : "_" + i}`;
-            const fullPath = `${options.subfolder ?? ""}/${path12}`;
+            const path14 = `${baseName}_data${i === 0 ? "" : "_" + i}`;
+            const fullPath = `${options.subfolder ?? ""}/${path14}`;
             externalDataPromises.push(new Promise(async (resolve4, reject) => {
               const data = await (0, _utils_hub_js__WEBPACK_IMPORTED_MODULE_5__.getModelFile)(pretrained_model_name_or_path, fullPath, true, options, return_path);
-              resolve4(data instanceof Uint8Array ? { path: path12, data } : path12);
+              resolve4(data instanceof Uint8Array ? { path: path14, data } : path14);
             }));
           }
         } else if (session_options.externalData !== undefined) {
@@ -95268,7 +95384,7 @@ ${fake_token_around_image}` + `${global_img_token}` + image_token.repeat(image_s
           const blob = new Blob([wav], { type: "audio/wav" });
           return blob;
         }
-        async save(path12) {
+        async save(path14) {
           let fn;
           if (_env_js__WEBPACK_IMPORTED_MODULE_3__.apis.IS_BROWSER_ENV) {
             if (_env_js__WEBPACK_IMPORTED_MODULE_3__.apis.IS_WEBWORKER_ENV) {
@@ -95276,14 +95392,14 @@ ${fake_token_around_image}` + `${global_img_token}` + image_token.repeat(image_s
             }
             fn = _core_js__WEBPACK_IMPORTED_MODULE_2__.saveBlob;
           } else if (_env_js__WEBPACK_IMPORTED_MODULE_3__.apis.IS_FS_AVAILABLE) {
-            fn = async (path13, blob) => {
+            fn = async (path15, blob) => {
               let buffer = await blob.arrayBuffer();
-              node_fs__WEBPACK_IMPORTED_MODULE_5__["default"].writeFileSync(path13, Buffer.from(buffer));
+              node_fs__WEBPACK_IMPORTED_MODULE_5__["default"].writeFileSync(path15, Buffer.from(buffer));
             };
           } else {
             throw new Error("Unable to save because filesystem is disabled in this environment.");
           }
-          await fn(path12, this.toBlob());
+          await fn(path14, this.toBlob());
         }
       }
     },
@@ -95379,11 +95495,11 @@ ${fake_token_around_image}` + `${global_img_token}` + image_token.repeat(image_s
       function calculateReflectOffset(i, w) {
         return Math.abs((i + w) % (2 * w) - w);
       }
-      function saveBlob(path12, blob) {
+      function saveBlob(path14, blob) {
         const dataURL = URL.createObjectURL(blob);
         const downloadLink = document.createElement("a");
         downloadLink.href = dataURL;
-        downloadLink.download = path12;
+        downloadLink.download = path14;
         downloadLink.click();
         downloadLink.remove();
         URL.revokeObjectURL(dataURL);
@@ -95984,8 +96100,8 @@ ${fake_token_around_image}` + `${global_img_token}` + image_token.repeat(image_s
       }
       class FileCache {
-        constructor(path12) {
-          this.path = path12;
+        constructor(path14) {
+          this.path = path14;
         }
         async match(request) {
           let filePath = node_path__WEBPACK_IMPORTED_MODULE_1__["default"].join(this.path, request);
@@ -96741,20 +96857,20 @@ ${fake_token_around_image}` + `${global_img_token}` + image_token.repeat(image_s
           }
           return this;
         }
-        async save(path12) {
+        async save(path14) {
           if (IS_BROWSER_OR_WEBWORKER) {
             if (_env_js__WEBPACK_IMPORTED_MODULE_2__.apis.IS_WEBWORKER_ENV) {
               throw new Error("Unable to save an image from a Web Worker.");
             }
-            const extension = path12.split(".").pop().toLowerCase();
+            const extension = path14.split(".").pop().toLowerCase();
             const mime = CONTENT_TYPE_MAP.get(extension) ?? "image/png";
             const blob = await this.toBlob(mime);
-            (0, _core_js__WEBPACK_IMPORTED_MODULE_0__.saveBlob)(path12, blob);
+            (0, _core_js__WEBPACK_IMPORTED_MODULE_0__.saveBlob)(path14, blob);
           } else if (!_env_js__WEBPACK_IMPORTED_MODULE_2__.apis.IS_FS_AVAILABLE) {
             throw new Error("Unable to save the image because filesystem is disabled in this environment.");
           } else {
             const img = this.toSharp();
-            return await img.toFile(path12);
+            return await img.toFile(path14);
           }
         }
         toSharp() {
@@ -106285,10 +106401,10 @@ Note that ${s.bold("include")} statements only accept relation fields.`, a;
       super(t, "P2023", r);
     }
   };
-  var fs8 = new WeakMap;
+  var fs10 = new WeakMap;
   function Ep(e) {
-    let t = fs8.get(e);
-    return t || (t = Object.entries(e), fs8.set(e, t)), t;
+    let t = fs10.get(e);
+    return t || (t = Object.entries(e), fs10.set(e, t)), t;
   }
   function hs(e, t, r) {
     switch (t.type) {
@@ -110256,7 +110372,7 @@ var require_prisma = __commonJS((exports) => {
   Prisma.JsonNull = JsonNull2;
   Prisma.AnyNull = AnyNull2;
   Prisma.NullTypes = NullTypes2;
-  var path12 = __require("path");
+  var path14 = __require("path");
   exports.Prisma.TransactionIsolationLevel = makeStrictEnum2({
     ReadUncommitted: "ReadUncommitted",
     ReadCommitted: "ReadCommitted",
@@ -115800,9 +115916,7 @@ var init_postgres_vector_store = __esm(() => {
     floatsToBit(v) {
       return v.map((x) => x >= 0 ? "1" : "0").join("");
     }
-    async ensureInitialized() {
-      if (this.pool && this.initialized)
-        return this.pool;
+    async createPool() {
       const pg2 = await Promise.resolve().then(() => (init_esm6(), exports_esm));
       const PgPool = pg2.default?.Pool ?? pg2.Pool;
       const poolConfig = {
@@ -115811,7 +115925,12 @@ var init_postgres_vector_store = __esm(() => {
         idleTimeoutMillis: 30000,
         connectionTimeoutMillis: 5000
       };
-      const pool = new PgPool(poolConfig);
+      return new PgPool(poolConfig);
+    }
+    async ensureInitialized() {
+      if (this.pool && this.initialized)
+        return this.pool;
+      const pool = this.pool ?? await this.createPool();
       this.pool = pool;
       const client = await pool.connect();
       try {
@@ -116199,6 +116318,43 @@ var init_postgres_vector_store = __esm(() => {
         lastIndexed: row.last_updated?.toISOString() ?? null
       }));
     }
+    async getPool() {
+      if (this.pool)
+        return this.pool;
+      this.pool = await this.createPool();
+      return this.pool;
+    }
+    async listAllProjectsAcrossDimensions() {
+      const pool = await this.getPool();
+      const { rows: tables } = await pool.query(`
+      SELECT schemaname, tablename FROM pg_tables
+      WHERE schemaname = current_schema()
+        AND (tablename = 'vector_documents' OR tablename ~ '^vector_documents_[0-9]+d$')
+      ORDER BY tablename
+    `);
+      if (tables.length === 0)
+        return [];
+      const unionParts = tables.map((t) => {
+        const qualified = `"${t.schemaname}"."${t.tablename}"`;
+        return `SELECT project_id, COUNT(*)::int AS doc_count, MAX(updated_at) AS last_updated, SUM(LENGTH(content))::bigint AS total_size FROM ${qualified} WHERE id NOT LIKE '_metadata:%' GROUP BY project_id`;
+      }).join(" UNION ALL ");
+      const { rows } = await pool.query(`
+      SELECT project_id,
+             SUM(doc_count)::int AS doc_count,
+             MAX(last_updated) AS last_updated,
+             SUM(total_size)::bigint AS total_size
+      FROM (${unionParts}) AS merged
+      GROUP BY project_id
+      ORDER BY last_updated DESC
+    `);
+      return rows.map((row) => ({
+        projectId: row.project_id,
+        projectPath: null,
+        documentCount: parseInt(row.doc_count),
+        totalSize: parseInt(row.total_size ?? "0"),
+        lastIndexed: row.last_updated?.toISOString() ?? null
+      }));
+    }
     async getCollection(name26) {
       const pool = await this.ensureInitialized();
       return new PostgresVectorCollection(pool, name26, this.tableName, this);
@@ -116290,7 +116446,7 @@ var init_vector_store_factory = __esm(() => {
 });
 // ../../packages/core/dist/services/search/search-cache-pg.js
-import crypto5 from "crypto";
+import crypto6 from "crypto";
 class SearchCachePg {
   pool = null;
@@ -116347,7 +116503,7 @@ class SearchCachePg {
       projectId,
       options: this.normalizeOptions(options)
     });
-    return crypto5.createHash("sha256").update(payload).digest("hex");
+    return crypto6.createHash("sha256").update(payload).digest("hex");
   }
   normalizeOptions(options) {
     const searchAffectingParams = [
@@ -123083,10 +123239,10 @@ var init_chunker_code = __esm(() => {
 });
 // ../../packages/core/dist/services/search/smart-chunker.js
-import path12 from "path";
+import path14 from "path";
 function smartChunk(content, filePath, config3 = {}) {
   const cfg = { ...DEFAULT_CONFIG, ...config3 };
-  const ext2 = path12.extname(filePath).toLowerCase();
+  const ext2 = path14.extname(filePath).toLowerCase();
   const relativePath = filePath;
   const fileImports = isCodeFile(ext2) ? extractFileImports(content, ext2) : undefined;
   let chunks;
@@ -123393,8 +123549,8 @@ var init_managed_run_repository_pg = __esm(() => {
 });
 // ../../packages/core/dist/services/search/project-indexer.js
-import fs8 from "fs/promises";
-import path13 from "path";
+import fs10 from "fs/promises";
+import path15 from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 async function runWithIndexLock(lockMap, projectId, work) {
   const prevLock = lockMap.get(projectId);
@@ -123437,7 +123593,7 @@ async function indexProjectInternal(deps, projectPath, projectId, options = {})
       dot: false
     });
     const filteredFiles = files.filter((file2) => {
-      const relativePath = path13.relative(projectPath, file2);
+      const relativePath = path15.relative(projectPath, file2);
       const shouldIgnore = ig.ignores(relativePath);
       if (shouldIgnore) {
         logger.debug("Ignoring file per .gitignore during indexing", {
@@ -123477,7 +123633,7 @@ async function indexProjectInternal(deps, projectPath, projectId, options = {})
         });
       }
     }
-    const indexedFilesList = filteredFiles.map((f) => path13.relative(projectPath, f));
+    const indexedFilesList = filteredFiles.map((f) => path15.relative(projectPath, f));
     await deps.indexManager.updateIndexMetadata(projectId, projectPath, indexedFilesList);
     logger.info("Project indexing completed", {
       projectId,
@@ -123602,7 +123758,7 @@ async function ensureFreshIndex(deps, projectId, projectPath, options = {}) {
   let errors4 = 0;
   for (const relativeFilePath of filesToReindex) {
     try {
-      const fullPath = path13.join(projectPath, relativeFilePath);
+      const fullPath = path15.join(projectPath, relativeFilePath);
       const result = await deps.indexFile(fullPath, projectId, projectPath, centralityMap);
       filesIndexed++;
       chunksIndexed += result.chunks;
@@ -123653,8 +123809,8 @@ async function checkSearchAdmission(deps, projectId, projectPath) {
 }
 async function indexFile(deps, filePath, projectId, projectRoot, centralityMap) {
   projectId = await getProjectIdentityAliasResolver().resolve(projectId);
-  const content = await fs8.readFile(filePath, "utf-8");
-  const relativePath = path13.relative(projectRoot, filePath);
+  const content = await fs10.readFile(filePath, "utf-8");
+  const relativePath = path15.relative(projectRoot, filePath);
   const maxFileSize = config2.get("security").maxFileSize || 1024 * 1024;
   if (content.length > maxFileSize) {
     logger.warn("File too large, skipping", {
@@ -123674,7 +123830,7 @@ async function indexFile(deps, filePath, projectId, projectRoot, centralityMap)
       chunkIndex: i,
       totalChunks: chunks.length,
       type: chunk.type,
-      language: path13.extname(filePath).slice(1),
+      language: path15.extname(filePath).slice(1),
       lineStart: chunk.lineStart,
       lineEnd: chunk.lineEnd,
       label: chunk.label,
@@ -124519,8 +124675,8 @@ function stripNul(content) {
 }
 // ../../packages/core/dist/services/etl/stages/discover.js
-import fs9 from "fs/promises";
-import path14 from "path";
+import fs11 from "fs/promises";
+import path16 from "path";
 import { createHash as createHash5 } from "crypto";
 class DiscoverStage {
@@ -124546,7 +124702,7 @@ class DiscoverStage {
         dot: false,
         absolute: false
       });
-      relPaths = found.map((p) => path14.isAbsolute(p) ? path14.relative(ctx.projectPath, p) : p).filter((p) => !ig.ignores(p) && applyPolicy(p, policy) !== "Drop");
+      relPaths = found.map((p) => path16.isAbsolute(p) ? path16.relative(ctx.projectPath, p) : p).filter((p) => !ig.ignores(p) && applyPolicy(p, policy) !== "Drop");
     }
     if (ctx.resumeCursor?.path) {
       const cursorPath = ctx.resumeCursor.path;
@@ -124605,10 +124761,10 @@ class DiscoverStage {
     return discovered;
   }
   async processFile(ctx, relativePath, forceReindex) {
-    const absolutePath = path14.join(ctx.projectPath, relativePath);
+    const absolutePath = path16.join(ctx.projectPath, relativePath);
     try {
-      const stat = await fs9.stat(absolutePath);
-      const content = stripNul(await fs9.readFile(absolutePath, "utf-8"));
+      const stat = await fs11.stat(absolutePath);
+      const content = stripNul(await fs11.readFile(absolutePath, "utf-8"));
       const contentHash = createHash5("sha256").update(content).digest("hex");
       let needsReparse = forceReindex;
       if (!forceReindex) {
@@ -124651,8 +124807,8 @@ class DiscoverStage {
       ig.add(pattern);
     }
     try {
-      const gitignorePath = path14.join(projectPath, ".gitignore");
-      const gitignoreContent = await fs9.readFile(gitignorePath, "utf8");
+      const gitignorePath = path16.join(projectPath, ".gitignore");
+      const gitignoreContent = await fs11.readFile(gitignorePath, "utf8");
       const rules = gitignoreContent.split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
       ig.add(rules);
@@ -126007,8 +126163,8 @@ function rustUseLeaves(node, source, prefix = []) {
   }
   if (node.type === "use_wildcard")
     return [{ path: [...prefix, "*"], glob: true }];
-  const path15 = rustPathSegments(node, source);
-  return path15.length ? [{ path: [...prefix, ...path15] }] : [];
+  const path17 = rustPathSegments(node, source);
+  return path17.length ? [{ path: [...prefix, ...path17] }] : [];
 }
 function functionalCaptures(captures, source, family) {
   if (family !== "clojure")
@@ -126980,8 +127136,8 @@ var init_structural_runtime = __esm(() => {
 });
 // ../../packages/core/dist/services/etl/stages/parse.js
-import path15 from "path";
-import fs10 from "fs/promises";
+import path17 from "path";
+import fs12 from "fs/promises";
 function resolveChunkerMaxChars() {
   const global2 = Number(process.env.EMBEDDING_MAX_CHARS);
   if (Number.isFinite(global2) && global2 > 0)
@@ -127009,8 +127165,8 @@ class ParseStage {
     const results = new Map;
     let processed = 0;
     const phases = [
-      files.filter((file2) => path15.extname(file2.relativePath).toLowerCase() !== ".h"),
-      files.filter((file2) => path15.extname(file2.relativePath).toLowerCase() === ".h")
+      files.filter((file2) => path17.extname(file2.relativePath).toLowerCase() !== ".h"),
+      files.filter((file2) => path17.extname(file2.relativePath).toLowerCase() === ".h")
     ];
     const batches = phases.flatMap((phase) => Array.from({ length: Math.ceil(phase.length / BATCH_SIZE) }, (_, index) => phase.slice(index * BATCH_SIZE, (index + 1) * BATCH_SIZE)));
     for (const batch of batches) {
@@ -127048,19 +127204,19 @@ class ParseStage {
     return files.map((file2) => results.get(file2.relativePath));
   }
   recordHeaderImporterEvidence(ctx, files, parsedFiles) {
-    const knownHeaders = new Set(files.filter((file2) => path15.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path15.posix.normalize(file2.relativePath)));
+    const knownHeaders = new Set(files.filter((file2) => path17.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path17.posix.normalize(file2.relativePath)));
     const mutable = {
       ...ctx.structuralHeaderEvidenceByFile
     };
     for (const parsed of parsedFiles) {
-      const extension = path15.extname(parsed.file.relativePath).toLowerCase();
+      const extension = path17.extname(parsed.file.relativePath).toLowerCase();
       const key = extension === ".c" ? "cImporters" : [".cpp", ".hpp"].includes(extension) ? "cppImporters" : undefined;
       if (!key)
         continue;
       for (const imported of parsed.rawImports) {
         if (!["c_include", "cpp_include"].includes(imported.form) || imported.specifier.startsWith("<"))
           continue;
-        const header = path15.posix.normalize(path15.posix.join(path15.posix.dirname(parsed.file.relativePath), imported.specifier));
+        const header = path17.posix.normalize(path17.posix.join(path17.posix.dirname(parsed.file.relativePath), imported.specifier));
         if (!knownHeaders.has(header))
           continue;
         const existing = mutable[header] ?? {};
@@ -127071,9 +127227,9 @@ class ParseStage {
   }
   async parseFile(ctx, file2) {
     if (!file2.needsReparse) {
-      const extension = path15.extname(file2.relativePath).toLowerCase();
+      const extension = path17.extname(file2.relativePath).toLowerCase();
       if ([".c", ".cpp", ".hpp"].includes(extension)) {
-        const content = file2.snapshotContent ?? await fs10.readFile(file2.absolutePath, "utf8");
+        const content = file2.snapshotContent ?? await fs12.readFile(file2.absolutePath, "utf8");
         const outcome = await this.runtime.parse({ extension, source: Buffer.from(content) });
         if (outcome.status === "failed")
           throw new StructuralEtlParseError(file2.relativePath, outcome.failureKind, `Structural evidence parse failed (${outcome.failureKind})`, outcome.diagnosticCount, outcome.diagnostics.slice(0, 10));
@@ -127085,8 +127241,8 @@ class ParseStage {
       return { file: file2, chunks: [], symbols: [], rawImports: [], rawEdges: [] };
     }
     try {
-      const content = file2.snapshotContent ?? await fs10.readFile(file2.absolutePath, "utf-8");
-      const ext2 = path15.extname(file2.relativePath).toLowerCase();
+      const content = file2.snapshotContent ?? await fs12.readFile(file2.absolutePath, "utf-8");
+      const ext2 = path17.extname(file2.relativePath).toLowerCase();
       const chunkerMaxChars = resolveChunkerMaxChars();
       const chunks = smartChunk(content, file2.relativePath, chunkerMaxChars ? { maxChunkChars: chunkerMaxChars } : {});
       let symbols;
@@ -127640,7 +127796,7 @@ var init_resolver = __esm(() => {
 });
 // ../../packages/core/dist/services/structural/resolvers/typescript.js
-import path16 from "path";
+import path18 from "path";
 function candidates(identities) {
   return Object.freeze(identities.map((identity) => Object.freeze({
     fqn: identity.fqn,
@@ -127735,7 +127891,7 @@ function probe(base, known, dialect = "typescript") {
   const bases = /\.[cm]?jsx?$/u.test(base) ? [base.replace(/\.[cm]?jsx?$/u, ".ts"), base.replace(/\.[cm]?jsx?$/u, ".tsx"), base] : [base];
   for (const candidateBase of bases)
     for (const suffix of DIALECT_PROBES[dialect] ?? [""]) {
-      const value = path16.posix.normalize(`${candidateBase}${suffix}`);
+      const value = path18.posix.normalize(`${candidateBase}${suffix}`);
       if (!value.startsWith("../") && value !== ".." && known.has(value))
         return value;
     }
@@ -127744,7 +127900,7 @@ function probe(base, known, dialect = "typescript") {
 function resolveStructuralSpecifier(specifier, fromFile, build, dialect = "typescript") {
   const known = new Set(build.knownFiles.map(normalizeStructuralFile));
   if (specifier.startsWith("./") || specifier.startsWith("../")) {
-    return probe(path16.posix.join(path16.posix.dirname(fromFile), specifier), known, dialect);
+    return probe(path18.posix.join(path18.posix.dirname(fromFile), specifier), known, dialect);
   }
   const aliases = build.pathAliasesByFile?.[normalizeStructuralFile(fromFile)] ?? build.pathAliases ?? [];
   for (const alias of aliases) {
@@ -128008,7 +128164,7 @@ var init_scripting2 = __esm(() => {
 });
 // ../../packages/core/dist/services/structural/resolvers/systems.js
-import path17 from "path";
+import path19 from "path";
 var DIALECTS, SYSTEMS_LANGUAGE_RESOLVER;
 var init_systems2 = __esm(() => {
   init_typescript2();
@@ -128027,7 +128183,7 @@ var init_systems2 = __esm(() => {
           const bindings = item.bindings.map((binding) => binding.imported === "*" && binding.local === "*" && unresolvedTarget && !unresolvedTarget.qualifier ? { ...binding, imported: unresolvedTarget.name, local: unresolvedTarget.name } : binding);
           if (item.specifier === "crate" || item.specifier.startsWith("crate/")) {
             const crateRoot = file2.file.startsWith("src/") ? "src" : "";
-            return { ...item, bindings, specifier: `./${path17.posix.relative(path17.posix.dirname(file2.file), path17.posix.join(crateRoot, item.specifier.replace(/^crate\/?/u, "")))}` };
+            return { ...item, bindings, specifier: `./${path19.posix.relative(path19.posix.dirname(file2.file), path19.posix.join(crateRoot, item.specifier.replace(/^crate\/?/u, "")))}` };
           }
           if (item.specifier === "self" || item.specifier.startsWith("self/"))
             return { ...item, bindings, specifier: `./${item.specifier.replace(/^self\/?/u, "")}` };
@@ -128125,8 +128281,8 @@ var init_data_document2 = __esm(() => {
 });
 // ../../packages/core/dist/services/etl/stages/resolve.js
-import path18 from "path";
-import fs11 from "fs";
+import path20 from "path";
+import fs13 from "fs";
 class ResolveStage {
   symbolRepository;
@@ -128150,7 +128306,7 @@ class ResolveStage {
     const structuralDocuments = files.flatMap((file2) => {
       if (!file2.structure)
         return [];
-      const language = resolveStructuralLanguage(path18.extname(file2.file.relativePath));
+      const language = resolveStructuralLanguage(path20.extname(file2.file.relativePath));
       if (language.status !== "supported")
         throw new Error(`structural_manifest_missing:${file2.file.relativePath}`);
       return [{
@@ -128162,13 +128318,13 @@ class ResolveStage {
       }];
     });
     const currentStructuralFiles = new Set(structuralDocuments.map((document2) => document2.file));
-    const skippedStructuralFiles = new Set(files.filter((item) => !item.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path18.extname(item.file.relativePath).toLowerCase())).map((item) => item.file.relativePath));
+    const skippedStructuralFiles = new Set(files.filter((item) => !item.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path20.extname(item.file.relativePath).toLowerCase())).map((item) => item.file.relativePath));
     const pathAliasesByFile = Object.fromEntries([...knownRelPaths].map((file2) => [
       file2,
       this.structuralAliasesFor(file2, rootAliases, monorepoPackages)
     ]));
     const buildMetadata = { knownFiles: [...knownRelPaths], pathAliasesByFile };
-    const seedRows = repositoryDefinitions.filter((definition) => STRUCTURAL_SEED_EXTENSIONS.has(path18.extname(definition.file_path).toLowerCase())).filter((definition) => knownRelPaths.has(definition.file_path) && skippedStructuralFiles.has(definition.file_path)).filter((definition) => !currentStructuralFiles.has(definition.file_path));
+    const seedRows = repositoryDefinitions.filter((definition) => STRUCTURAL_SEED_EXTENSIONS.has(path20.extname(definition.file_path).toLowerCase())).filter((definition) => knownRelPaths.has(definition.file_path) && skippedStructuralFiles.has(definition.file_path)).filter((definition) => !currentStructuralFiles.has(definition.file_path));
     const seedIds = new Set;
     for (const definition of seedRows) {
       if (seedIds.has(definition.id))
@@ -128261,7 +128417,7 @@ class ResolveStage {
     if (parsed.file !== definition.file_path) {
       throw new Error(`structural_repository_seed_file_mismatch:${definition.id}`);
     }
-    const language = resolveStructuralLanguage(path18.extname(definition.file_path));
+    const language = resolveStructuralLanguage(path20.extname(definition.file_path));
     if (language.status !== "supported")
       throw new Error(`structural_repository_seed_language:${definition.id}`);
     let identity;
@@ -128313,7 +128469,7 @@ class ResolveStage {
     });
   }
   resolveFile(parsed, projectPath, knownRelPaths, rootAliases, monorepoPackages, symbolIndex, knownFqns) {
-    const fromDir = path18.dirname(path18.join(projectPath, parsed.file.relativePath));
+    const fromDir = path20.dirname(path20.join(projectPath, parsed.file.relativePath));
     const packageAliases = this.getPackageAliases(parsed.file.relativePath, monorepoPackages);
     const allAliases = [...packageAliases, ...rootAliases];
     const resolvedImports = parsed.rawImports.map((raw2) => {
@@ -128384,7 +128540,7 @@ class ResolveStage {
         index.set(def.name, `${def.file_path}#${def.name}`);
       }
     } catch (err) {
-      const skippedStructural = files.some((file2) => !file2.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path18.extname(file2.file.relativePath).toLowerCase()));
+      const skippedStructural = files.some((file2) => !file2.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path20.extname(file2.file.relativePath).toLowerCase()));
       if (skippedStructural)
         throw new Error("structural_repository_seed_failed", { cause: err });
       logger.warn("buildSymbolIndex: repo seed failed, in-batch only", {
@@ -128408,7 +128564,7 @@ class ResolveStage {
   }
   resolveSpecifier(specifier, fromDir, projectPath, knownRelPaths, aliases) {
     if (specifier.startsWith("./") || specifier.startsWith("../")) {
-      const resolved = this.probeExtensions(path18.resolve(fromDir, specifier), projectPath, knownRelPaths);
+      const resolved = this.probeExtensions(path20.resolve(fromDir, specifier), projectPath, knownRelPaths);
       return { resolvedPath: resolved, external: false };
     }
     for (const alias of aliases) {
@@ -128416,8 +128572,8 @@ class ResolveStage {
         const suffix = specifier.slice(alias.prefix.length);
         for (const target of alias.targets) {
           const cleanTarget = target.replace(/\/\*$/, "");
-          const basePath = alias.packagePath ? path18.join(projectPath, alias.packagePath) : projectPath;
-          const absPath = path18.join(basePath, cleanTarget + suffix);
+          const basePath = alias.packagePath ? path20.join(projectPath, alias.packagePath) : projectPath;
+          const absPath = path20.join(basePath, cleanTarget + suffix);
           const resolved = this.probeExtensions(absPath, projectPath, knownRelPaths);
           if (resolved)
             return { resolvedPath: resolved, external: false };
@@ -128433,7 +128589,7 @@ class ResolveStage {
       ...TS_EXTENSIONS.map((ext2) => absPath.replace(/\.[^.]+$/, ext2))
     ];
     for (const candidate2 of candidates2) {
-      const rel = path18.relative(projectPath, candidate2).replace(/\\/g, "/");
+      const rel = path20.relative(projectPath, candidate2).replace(/\\/g, "/");
       if (knownRelPaths.has(rel))
         return rel;
     }
@@ -128441,9 +128597,9 @@ class ResolveStage {
   }
   loadTsConfigPaths(projectPath, packageBase) {
     const aliases = [];
-    const tsconfigPath = path18.join(projectPath, "tsconfig.json");
+    const tsconfigPath = path20.join(projectPath, "tsconfig.json");
     try {
-      const raw2 = fs11.readFileSync(tsconfigPath, "utf-8");
+      const raw2 = fs13.readFileSync(tsconfigPath, "utf-8");
       const stripped = raw2.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
       const tsconfig = JSON.parse(stripped);
       const paths = tsconfig?.compilerOptions?.paths ?? {};
@@ -128472,7 +128628,7 @@ class ResolveStage {
       }
     }
     for (const packageRelPath of packagePaths) {
-      const absPackagePath = path18.join(projectPath, packageRelPath);
+      const absPackagePath = path20.join(projectPath, packageRelPath);
       const aliases = this.loadTsConfigPaths(absPackagePath, packageRelPath);
       if (aliases.length > 0) {
         packages.push({
@@ -128502,7 +128658,7 @@ class ResolveStage {
   structuralAliasesFor(filePath, rootAliases, packages) {
     return [...this.getPackageAliases(filePath, packages), ...rootAliases].map((alias) => ({
       pattern: alias.prefix + (alias.targets.some((target) => target.includes("*")) ? "/*" : ""),
-      targets: alias.targets.map((target) => alias.packagePath ? path18.posix.join(alias.packagePath, target) : target)
+      targets: alias.targets.map((target) => alias.packagePath ? path20.posix.join(alias.packagePath, target) : target)
     }));
   }
 }
@@ -128566,7 +128722,7 @@ var init_with_deadlock_retry = __esm(() => {
 });
 // ../../packages/core/dist/services/etl/stages/load.js
-import path19 from "path";
+import path21 from "path";
 function formatDuration(ms) {
   const totalSec = Math.max(0, Math.round(ms / 1000));
   if (totalSec < 60)
@@ -128843,7 +128999,7 @@ class LoadStage {
     const filePath = file2.file.relativePath;
     const batch = buildSymbolPersistenceBatch(ctx.projectId, file2);
     if (ctx.graphGenerationLease) {
-      const manifest = getLanguageManifestEntry(path19.extname(filePath));
+      const manifest = getLanguageManifestEntry(path21.extname(filePath));
       const diagnostics2 = (file2.structuralDiagnostics ?? []).slice(0, 10).map((diagnostic2) => ({
         code: diagnostic2.code,
         severity: diagnostic2.severity,
@@ -129300,9 +129456,9 @@ var init_graph_generation_coordinator = __esm(() => {
 // ../../packages/core/dist/services/etl/pipeline.js
 import { createHash as createHash7 } from "crypto";
 import { setTimeout as delay2 } from "timers/promises";
-import path20 from "path";
+import path22 from "path";
 function buildHeaderLanguageEvidence(files) {
-  const headers = new Set(files.filter((file2) => path20.posix.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path20.posix.normalize(file2.relativePath)));
+  const headers = new Set(files.filter((file2) => path22.posix.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path22.posix.normalize(file2.relativePath)));
   const mutable = new Map;
   const entry2 = (header) => {
     let value = mutable.get(header);
@@ -129313,7 +129469,7 @@ function buildHeaderLanguageEvidence(files) {
     return value;
   };
   for (const file2 of files) {
-    if (path20.posix.basename(file2.relativePath) !== "compile_commands.json" || file2.snapshotContent === undefined)
+    if (path22.posix.basename(file2.relativePath) !== "compile_commands.json" || file2.snapshotContent === undefined)
       continue;
     let commands;
     try {
@@ -129329,11 +129485,11 @@ function buildHeaderLanguageEvidence(files) {
       const record3 = command;
       if (typeof record3.file !== "string")
         continue;
-      const projectRoot = path20.resolve(file2.absolutePath, ...file2.relativePath.split("/").map(() => ".."));
-      const commandDirectory = typeof record3.directory === "string" ? path20.resolve(projectRoot, record3.directory) : projectRoot;
-      const absoluteInput = path20.resolve(commandDirectory, record3.file);
-      const relative2 = path20.relative(projectRoot, absoluteInput);
-      const header = path20.posix.normalize(relative2.replaceAll(path20.sep, "/"));
+      const projectRoot = path22.resolve(file2.absolutePath, ...file2.relativePath.split("/").map(() => ".."));
+      const commandDirectory = typeof record3.directory === "string" ? path22.resolve(projectRoot, record3.directory) : projectRoot;
+      const absoluteInput = path22.resolve(commandDirectory, record3.file);
+      const relative2 = path22.relative(projectRoot, absoluteInput);
+      const header = path22.posix.normalize(relative2.replaceAll(path22.sep, "/"));
       if (!headers.has(header))
         continue;
       const invocation = typeof record3.command === "string" ? record3.command : Array.isArray(record3.arguments) ? record3.arguments.join(" ") : "";
@@ -129864,9 +130020,9 @@ var init_acquire_indexing_lease = __esm(() => {
 // ../../packages/core/dist/services/project-identity/project-root-identity.js
 import { realpath as realpath2 } from "fs/promises";
-import path21 from "path";
+import path23 from "path";
 async function canonicalizeProjectRoot(projectPath, canonicalize = realpath2) {
-  return canonicalize(path21.resolve(projectPath));
+  return canonicalize(path23.resolve(projectPath));
 }
 async function assertProjectRootReuse(options) {
   if (!options.storedProjectPath || options.forceReindex)
@@ -129874,9 +130030,9 @@ async function assertProjectRootReuse(options) {
   const canonicalize = options.canonicalize ?? realpath2;
   let storedCanonical;
   try {
-    storedCanonical = await canonicalize(path21.resolve(options.storedProjectPath));
+    storedCanonical = await canonicalize(path23.resolve(options.storedProjectPath));
   } catch {
-    storedCanonical = path21.resolve(options.storedProjectPath);
+    storedCanonical = path23.resolve(options.storedProjectPath);
   }
   if (storedCanonical !== options.canonicalProjectPath) {
     throw new Error(`Project ID "${options.projectId}" already indexes canonical root ` + `"${storedCanonical}", not "${options.canonicalProjectPath}"; ` + "use forceReindex only after verifying ownership of the existing project");
@@ -130619,16 +130775,16 @@ function detectRoutes(httpEdges, defs, opts = {}) {
   const seen = new Set;
   const out = [];
   for (const e of httpEdges) {
-    const path22 = e.route;
-    if (!path22)
+    const path24 = e.route;
+    if (!path24)
       continue;
     const method = (e.method ?? "ANY").toUpperCase();
-    const key = method + " " + path22;
+    const key = method + " " + path24;
     if (seen.has(key))
       continue;
     seen.add(key);
     out.push({
-      path: path22,
+      path: path24,
       method: e.method,
       file: e.fromFile,
       handler: e.targetFqn ?? e.symbolName
@@ -130639,12 +130795,12 @@ function detectRoutes(httpEdges, defs, opts = {}) {
       continue;
     const parsed = parseRouteName(d.name);
     const method = parsed?.method ?? "ANY";
-    const path22 = parsed?.path ?? d.name;
-    const key = method + " " + path22;
+    const path24 = parsed?.path ?? d.name;
+    const key = method + " " + path24;
     if (seen.has(key))
       continue;
     seen.add(key);
-    out.push({ path: path22, method: parsed?.method, file: d.filePath, handler: d.name });
+    out.push({ path: path24, method: parsed?.method, file: d.filePath, handler: d.name });
   }
   for (const d of defs) {
     const parsed = parseRouteName(d.name);
@@ -130865,8 +131021,8 @@ __export(exports_symbol_graph_service, {
   symbolGraphService: () => symbolGraphService,
   SymbolGraphService: () => SymbolGraphService
 });
-import path22 from "path";
-import fs12 from "fs/promises";
+import path24 from "path";
+import fs14 from "fs/promises";
 class SymbolGraphService {
   identityLookup;
@@ -131194,7 +131350,7 @@ class SymbolGraphService {
   async readSnippet(relativePath, lineStart, lineEnd, projectId) {
     try {
       const absolutePath = await this.resolveToAbsolute(relativePath, projectId);
-      const content = await fs12.readFile(absolutePath, "utf-8");
+      const content = await fs14.readFile(absolutePath, "utf-8");
       const lines = content.split(`
 `);
       return lines.slice(Math.max(0, lineStart - 1), Math.min(lines.length, lineEnd)).join(`
@@ -131206,7 +131362,7 @@ class SymbolGraphService {
   async readContext(relativePath, lineNumber, contextLines, projectId) {
     try {
       const absolutePath = await this.resolveToAbsolute(relativePath, projectId);
-      const content = await fs12.readFile(absolutePath, "utf-8");
+      const content = await fs14.readFile(absolutePath, "utf-8");
       const lines = content.split(`
 `);
       const start = Math.max(0, lineNumber - contextLines - 1);
@@ -131219,7 +131375,7 @@ class SymbolGraphService {
   }
   async resolveToAbsolute(relativePath, projectId) {
     const root = await this.getProjectRoot(projectId);
-    return root ? path22.resolve(root, relativePath) : relativePath;
+    return root ? path24.resolve(root, relativePath) : relativePath;
   }
   async getProjectRoot(projectId) {
     const cached2 = this.projectRootCache.get(projectId);
@@ -131362,7 +131518,7 @@ var init_workspace_manager = __esm(() => {
 });
 // ../../packages/core/dist/tools/index_project.js
-import path23 from "path";
+import path25 from "path";
 class IndexProjectTool {
   name = "index_project";
@@ -131410,7 +131566,7 @@ class IndexProjectTool {
     try {
       await assertParserReadyForIndexing();
       const canonicalProjectPath = await canonicalizeProjectRoot(projectPath);
-      const finalProjectId = projectId || path23.basename(canonicalProjectPath) || "default";
+      const finalProjectId = projectId || path25.basename(canonicalProjectPath) || "default";
       const existing = await workspaceManager.getWorkspace(finalProjectId);
       await assertProjectRootReuse({
         projectId: finalProjectId,
@@ -131963,17 +132119,17 @@ function applyReplacer(root, replacer) {
     return transformChildren(root, replacer, []);
   return transformChildren(normalizeValue(replacedRoot), replacer, []);
 }
-function transformChildren(value, replacer, path24) {
+function transformChildren(value, replacer, path26) {
   if (isJsonObject(value))
-    return transformObject(value, replacer, path24);
+    return transformObject(value, replacer, path26);
   if (isJsonArray(value))
-    return transformArray(value, replacer, path24);
+    return transformArray(value, replacer, path26);
   return value;
 }
-function transformObject(obj, replacer, path24) {
+function transformObject(obj, replacer, path26) {
   const result = {};
   for (const [key, value] of Object.entries(obj)) {
-    const childPath = [...path24, key];
+    const childPath = [...path26, key];
     const replacedValue = replacer(key, value, childPath);
     if (replacedValue === undefined)
       continue;
@@ -131981,11 +132137,11 @@ function transformObject(obj, replacer, path24) {
   }
   return result;
 }
-function transformArray(arr, replacer, path24) {
+function transformArray(arr, replacer, path26) {
   const result = [];
   for (let i = 0;i < arr.length; i++) {
     const value = arr[i];
-    const childPath = [...path24, i];
+    const childPath = [...path26, i];
     const replacedValue = replacer(String(i), value, childPath);
     if (replacedValue === undefined)
       continue;
@@ -137055,9 +137211,9 @@ var init_session_pin_store = __esm(() => {
 });
 // ../../packages/core/dist/services/hooks/attribution-resolver.js
-import fs13 from "fs";
+import fs15 from "fs";
 import os6 from "os";
-import path24 from "path";
+import path26 from "path";
 class PgWorkspaceRootProvider {
   cache = null;
@@ -137107,7 +137263,7 @@ class AttributionResolver {
     this.pins = options.pins ?? new SessionPinStore;
     this.canonicalize = options.canonicalize ?? defaultCanonicalize;
     this.homedir = options.homedir ?? os6.homedir;
-    this.fsRoot = options.fsRoot ?? (() => path24.parse(path24.sep).root);
+    this.fsRoot = options.fsRoot ?? (() => path26.parse(path26.sep).root);
   }
   async resolve(input) {
     const caller = input.callerProjectId;
@@ -137158,7 +137314,7 @@ class AttributionResolver {
     }
     let bestPath = null;
     for (const candidate2 of byPath.keys()) {
-      if (canonicalCwd === candidate2 || canonicalCwd.startsWith(candidate2.endsWith(path24.sep) ? candidate2 : candidate2 + path24.sep)) {
+      if (canonicalCwd === candidate2 || canonicalCwd.startsWith(candidate2.endsWith(path26.sep) ? candidate2 : candidate2 + path26.sep)) {
         if (bestPath === null || candidate2.length > bestPath.length) {
           bestPath = candidate2;
         }
@@ -137181,7 +137337,7 @@ class AttributionResolver {
       return projectPath2;
     const fsRoot = this.fsRoot();
     let normalized = projectPath2;
-    while (normalized.length > fsRoot.length && normalized.endsWith(path24.sep)) {
+    while (normalized.length > fsRoot.length && normalized.endsWith(path26.sep)) {
       normalized = normalized.slice(0, -1);
     }
     return normalized;
@@ -137189,10 +137345,10 @@ class AttributionResolver {
 }
 function defaultCanonicalize(cwd) {
   try {
-    return fs13.realpathSync(cwd);
+    return fs15.realpathSync(cwd);
   } catch {
     try {
-      return path24.resolve(cwd);
+      return path26.resolve(cwd);
     } catch {
       return;
     }
@@ -137940,31 +138096,31 @@ class TracePathService {
     const chains = [];
     const seen = new Set;
     let walks = 0;
-    const walk = (fqn, path25) => {
+    const walk = (fqn, path27) => {
       if (chains.length >= CHAIN_CAP)
         return;
       if (walks >= MAX_WALKS)
         return;
       walks++;
-      const key = path25.join("\u2192");
+      const key = path27.join("\u2192");
       if (seen.has(key))
         return;
       seen.add(key);
       const next = adj.get(fqn);
       if (!next || next.length === 0 || !whoHasChild.has(fqn)) {
-        if (path25.length > 1)
-          chains.push(path25.map((n) => this.fqnToName(n)).join(" \u2192 "));
+        if (path27.length > 1)
+          chains.push(path27.map((n) => this.fqnToName(n)).join(" \u2192 "));
         return;
       }
       for (const child of next) {
         if (chains.length >= CHAIN_CAP || walks >= MAX_WALKS)
           return;
-        if (path25.includes(child)) {
-          const cycled = [...path25, `${this.fqnToName(child)}\u21BA`];
+        if (path27.includes(child)) {
+          const cycled = [...path27, `${this.fqnToName(child)}\u21BA`];
           chains.push(cycled.map((n) => n).join(" \u2192 "));
           continue;
         }
-        walk(child, [...path25, child]);
+        walk(child, [...path27, child]);
       }
     };
     for (const seed of seeds) {
@@ -138797,7 +138953,7 @@ var init_get_architecture = __esm(() => {
 });
 // ../../packages/core/dist/services/file-read/file-content-cache.js
-import fs14 from "fs/promises";
+import fs16 from "fs/promises";
 class FileContentCache {
   extractMetadata;
@@ -138830,7 +138986,7 @@ class FileContentCache {
         metadata: cached2.metadata
       };
     }
-    const content = await fs14.readFile(filePath, "utf-8");
+    const content = await fs16.readFile(filePath, "utf-8");
     const metadata = await this.extractMetadata(content, filePath, options);
     evictOldest(this.fileCache, this.FILE_CACHE_MAX_ENTRIES - 1);
     this.fileCache.set(cacheKey, {
@@ -138847,7 +139003,7 @@ var init_file_content_cache = __esm(() => {
 });
 // ../../packages/core/dist/services/file-read/file-metadata.js
-import path25 from "path";
+import path27 from "path";
 class FileMetadataExtractor {
   symbolGraph;
@@ -138883,7 +139039,7 @@ class FileMetadataExtractor {
     return metadata;
   }
   detectLanguage(filePath) {
-    const ext2 = path25.extname(filePath).toLowerCase();
+    const ext2 = path27.extname(filePath).toLowerCase();
     const languageMap2 = {
       ".ts": "TypeScript",
       ".tsx": "TypeScript",
@@ -139005,7 +139161,7 @@ var init_line_range = __esm(() => {
 });
 // ../../packages/core/dist/services/file-read/path-containment.js
-import path26 from "path";
+import path28 from "path";
 class PathContainment {
   projectRoots;
@@ -139013,14 +139169,14 @@ class PathContainment {
     this.projectRoots = projectRoots;
   }
   async resolveFilePath(filePath, projectId) {
-    if (path26.isAbsolute(filePath)) {
-      return path26.resolve(filePath);
+    if (path28.isAbsolute(filePath)) {
+      return path28.resolve(filePath);
     }
     if (projectId) {
       const root = await this.projectRoots.getProjectRoot(projectId);
       if (root) {
         const cleaned = sanitizeFilePath(filePath);
-        return path26.resolve(root, cleaned);
+        return path28.resolve(root, cleaned);
       }
       return null;
     }
@@ -139031,17 +139187,17 @@ class PathContainment {
     if (projectId) {
       const root = await this.projectRoots.getProjectRoot(projectId);
       if (root)
-        roots.push(path26.resolve(root));
+        roots.push(path28.resolve(root));
     }
-    roots.push(path26.resolve(process.cwd()));
+    roots.push(path28.resolve(process.cwd()));
     const envRoots = (process.env.MASSA_AI_READ_FILE_ROOTS ?? "").split(":").map((s) => s.trim()).filter((s) => s.length > 0);
     for (const extra of envRoots) {
-      roots.push(path26.resolve(extra));
+      roots.push(path28.resolve(extra));
     }
-    const target = path26.resolve(absoluteFilePath);
+    const target = path28.resolve(absoluteFilePath);
     for (const root of roots) {
-      const rel = path26.relative(root, target);
-      if (rel !== "" && !rel.startsWith("..") && !path26.isAbsolute(rel)) {
+      const rel = path28.relative(root, target);
+      if (rel !== "" && !rel.startsWith("..") && !path28.isAbsolute(rel)) {
         return { allowed: true };
       }
       if (rel === "")
@@ -142255,9 +142411,9 @@ var init_l1_memory_cache = __esm(() => {
 });
 // ../../packages/core/dist/services/health/local-health-checker.js
-import fs15 from "fs/promises";
+import fs17 from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import path27 from "path";
+import path29 from "path";
 class LocalHealthChecker {
   ollamaBaseUrl = process.env.OLLAMA_BASE_URL || "http://localhost:11434";
@@ -142291,10 +142447,10 @@ class LocalHealthChecker {
     const start = Date.now();
     try {
       if (!existsSync3(this.dataDir))
-        await fs15.mkdir(this.dataDir, { recursive: true });
-      const probe2 = path27.join(this.dataDir, ".health-check-test");
-      await fs15.writeFile(probe2, "ok");
-      await fs15.unlink(probe2);
+        await fs17.mkdir(this.dataDir, { recursive: true });
+      const probe2 = path29.join(this.dataDir, ".health-check-test");
+      await fs17.writeFile(probe2, "ok");
+      await fs17.unlink(probe2);
       return { available: true, latency: Date.now() - start, details: { path: this.dataDir, writable: true } };
     } catch (error51) {
       return { available: false, latency: Date.now() - start, error: `Data directory error: ${error51.message}` };
@@ -144247,9 +144403,9 @@ var init_scheduler2 = __esm(() => {
 });
 // ../../packages/core/dist/services/pricing/models-dev-client.js
-import fs16 from "fs/promises";
+import fs18 from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import path28 from "path";
+import path30 from "path";
 function getModelsDevClient() {
   if (!clientInstance) {
     clientInstance = new ModelsDevClient;
@@ -144269,7 +144425,7 @@ var init_models_dev_client = __esm(() => {
     memoryCacheTimestamp = 0;
     getLocalCachePath() {
       const dataDir = config2.get("dataDir");
-      return path28.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
+      return path30.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
     }
     async loadLocalCache() {
       const cachePath = this.getLocalCachePath();
@@ -144277,7 +144433,7 @@ var init_models_dev_client = __esm(() => {
         if (!existsSync4(cachePath)) {
           return null;
         }
-        const content = await fs16.readFile(cachePath, "utf-8");
+        const content = await fs18.readFile(cachePath, "utf-8");
         const data = JSON.parse(content);
         const age = Date.now() - data.timestamp;
         if (age > ModelsDevClient.LOCAL_CACHE_TTL) {
@@ -144304,14 +144460,14 @@ var init_models_dev_client = __esm(() => {
     async saveLocalCache(models) {
       const cachePath = this.getLocalCachePath();
       try {
-        const dir = path28.dirname(cachePath);
-        await fs16.mkdir(dir, { recursive: true });
+        const dir = path30.dirname(cachePath);
+        await fs18.mkdir(dir, { recursive: true });
         const data = {
           timestamp: Date.now(),
           version: "1.0.0",
           models: Object.fromEntries(models)
         };
-        await fs16.writeFile(cachePath, JSON.stringify(data), "utf-8");
+        await fs18.writeFile(cachePath, JSON.stringify(data), "utf-8");
         logger.debug("Saved pricing to local cache", {
           models: models.size,
           path: cachePath
@@ -144640,7 +144796,7 @@ var init_models_dev_client = __esm(() => {
       const cachePath = this.getLocalCachePath();
       try {
         if (existsSync4(cachePath)) {
-          await fs16.unlink(cachePath);
+          await fs18.unlink(cachePath);
           logger.debug("Local pricing cache file deleted");
         }
       } catch (error51) {
@@ -150195,33 +150351,33 @@ var require_URL = __commonJS((exports, module) => {
         else
           return basepath.substring(0, lastslash + 1) + refpath;
       }
-      function remove_dot_segments(path29) {
-        if (!path29)
-          return path29;
+      function remove_dot_segments(path31) {
+        if (!path31)
+          return path31;
         var output = "";
-        while (path29.length > 0) {
-          if (path29 === "." || path29 === "..") {
-            path29 = "";
+        while (path31.length > 0) {
+          if (path31 === "." || path31 === "..") {
+            path31 = "";
             break;
           }
-          var twochars = path29.substring(0, 2);
-          var threechars = path29.substring(0, 3);
-          var fourchars = path29.substring(0, 4);
+          var twochars = path31.substring(0, 2);
+          var threechars = path31.substring(0, 3);
+          var fourchars = path31.substring(0, 4);
           if (threechars === "../") {
-            path29 = path29.substring(3);
+            path31 = path31.substring(3);
           } else if (twochars === "./") {
-            path29 = path29.substring(2);
+            path31 = path31.substring(2);
           } else if (threechars === "/./") {
-            path29 = "/" + path29.substring(3);
-          } else if (twochars === "/." && path29.length === 2) {
-            path29 = "/";
-          } else if (fourchars === "/../" || threechars === "/.." && path29.length === 3) {
-            path29 = "/" + path29.substring(4);
+            path31 = "/" + path31.substring(3);
+          } else if (twochars === "/." && path31.length === 2) {
+            path31 = "/";
+          } else if (fourchars === "/../" || threechars === "/.." && path31.length === 3) {
+            path31 = "/" + path31.substring(4);
             output = output.replace(/\/?[^\/]*$/, "");
           } else {
-            var segment = path29.match(/(\/?([^\/]*))/)[0];
+            var segment = path31.match(/(\/?([^\/]*))/)[0];
             output += segment;
-            path29 = path29.substring(segment.length);
+            path31 = path31.substring(segment.length);
           }
         }
         return output;
@@ -162291,21 +162447,21 @@ function jsonToKeyPathChunks(value, label = "$") {
   walk(value, label, out);
   return out;
 }
-function walk(val, path29, out) {
+function walk(val, path31, out) {
   if (val === null || val === undefined)
     return;
   if (Array.isArray(val)) {
     if (val.length === 0) {
-      out.push({ path: path29, content: `**${path29}** = _[]_` });
+      out.push({ path: path31, content: `**${path31}** = _[]_` });
       return;
     }
     if (val.every((v) => v !== null && typeof v === "object")) {
-      val.forEach((v, i) => walk(v, `${path29}[${i}]`, out));
+      val.forEach((v, i) => walk(v, `${path31}[${i}]`, out));
       return;
     }
     const items = val.map((v) => `- \`${String(v)}\``).join(`
 `);
-    out.push({ path: path29, content: `**${path29}**
+    out.push({ path: path31, content: `**${path31}**
 ${items}` });
     return;
@@ -162313,16 +162469,16 @@ ${items}` });
   if (typeof val === "object") {
     const entries = Object.entries(val);
     if (entries.length === 0) {
-      out.push({ path: path29, content: `**${path29}** = _{}_` });
+      out.push({ path: path31, content: `**${path31}** = _{}_` });
       return;
     }
     for (const [k, v] of entries) {
       const safeKey = /^[A-Za-z_$][\w$]*$/.test(k) ? k : JSON.stringify(k);
-      walk(v, `${path29}.${safeKey}`, out);
+      walk(v, `${path31}.${safeKey}`, out);
     }
     return;
   }
-  out.push({ path: path29, content: `**${path29}** = \`${String(val)}\`` });
+  out.push({ path: path31, content: `**${path31}** = \`${String(val)}\`` });
 }
 var gfm, STRIP_SELECTORS, tdCache = null;
 var init_html_to_md = __esm(() => {
@@ -163085,8 +163241,8 @@ var init_hook_service = __esm(() => {
 // ../../packages/core/dist/services/bootstrap/bootstrap-service.js
 import { randomUUID as randomUUID9 } from "crypto";
-import fs17 from "fs";
-import path29 from "path";
+import fs19 from "fs";
+import path31 from "path";
 import { spawn as spawn2 } from "child_process";
 function readBootstrapConfig() {
   try {
@@ -163246,9 +163402,9 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
   }
   try {
     for (const name26 of README_CANDIDATES) {
-      const p = path29.join(projectRoot, name26);
-      if (fs17.existsSync(p) && fs17.statSync(p).isFile()) {
-        const buf = fs17.readFileSync(p);
+      const p = path31.join(projectRoot, name26);
+      if (fs19.existsSync(p) && fs19.statSync(p).isFile()) {
+        const buf = fs19.readFileSync(p);
         signals.readme = buf.slice(0, MAX_README_BYTES).toString("utf8");
         break;
       }
@@ -163257,14 +163413,14 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
     logger.debug("bootstrap scan: README read failed", { error: e.message });
   }
   try {
-    const docsDir = path29.join(projectRoot, "docs");
-    if (fs17.existsSync(docsDir) && fs17.statSync(docsDir).isDirectory()) {
+    const docsDir = path31.join(projectRoot, "docs");
+    if (fs19.existsSync(docsDir) && fs19.statSync(docsDir).isDirectory()) {
       const entries = walkMarkdown(docsDir).slice(0, MAX_DOCS);
       for (const rel of entries) {
         try {
-          const buf = fs17.readFileSync(rel);
+          const buf = fs19.readFileSync(rel);
           signals.docs.push({
-            path: path29.relative(projectRoot, rel),
+            path: path31.relative(projectRoot, rel),
             snippet: buf.slice(0, MAX_DOC_BYTES).toString("utf8")
           });
         } catch {}
@@ -163275,10 +163431,10 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
   }
   try {
     for (const name26 of MANIFEST_FILES) {
-      const p = path29.join(projectRoot, name26);
-      if (!fs17.existsSync(p) || !fs17.statSync(p).isFile())
+      const p = path31.join(projectRoot, name26);
+      if (!fs19.existsSync(p) || !fs19.statSync(p).isFile())
         continue;
-      const raw2 = fs17.readFileSync(p).slice(0, MAX_MANIFEST_BYTES).toString("utf8");
+      const raw2 = fs19.readFileSync(p).slice(0, MAX_MANIFEST_BYTES).toString("utf8");
       const kind = name26;
       if (name26 === "package.json") {
         try {
@@ -163318,12 +163474,12 @@ function walkMarkdown(dir) {
     const cur = stack.pop();
     let entries;
     try {
-      entries = fs17.readdirSync(cur, { withFileTypes: true });
+      entries = fs19.readdirSync(cur, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const e of entries) {
-      const full = path29.join(cur, e.name);
+      const full = path31.join(cur, e.name);
       if (e.isDirectory()) {
         if (e.name === "node_modules" || e.name.startsWith("."))
           continue;
@@ -166735,7 +166891,7 @@ class StdioServerTransport {
 }
 // src/index.ts
-import fs20 from "fs/promises";
+import fs22 from "fs/promises";
 // src/api-client.ts
 init_config();
@@ -166845,8 +167001,8 @@ init_dist();
 init_dist();
 init_dist15();
 init_dist();
-import fs18 from "fs/promises";
-import path30 from "path";
+import fs20 from "fs/promises";
+import path32 from "path";
 var _indexProjectTool = null;
 function indexProjectTool() {
   if (!_indexProjectTool)
@@ -167129,8 +167285,8 @@ class EmbeddedApiClient {
         } else {
           end = start + 20;
         }
-        const absolutePath = path30.join(workspace.project_path, file2);
-        const content = await fs18.readFile(absolutePath, "utf-8");
+        const absolutePath = path32.join(workspace.project_path, file2);
+        const content = await fs20.readFile(absolutePath, "utf-8");
         const lines = content.split(/\r?\n/);
         const slice = lines.slice(start - 1, Math.min(lines.length, end));
         const formatted = slice.map((text3, idx) => ({ lineNumber: start + idx, content: text3 }));
@@ -167367,22 +167523,22 @@ class EmbeddedApiClient {
   async uploadAndIndex(params) {
     const rawBase = params.projectId || params.projectPath.replace(/\\/g, "/").split("/").filter(Boolean).pop() || "default";
     const finalProjectId = rawBase.replace(/[^a-zA-Z0-9_.-]/g, "_").slice(0, 128);
-    const uploadRoot = process.env.MASSA_AI_UPLOAD_DIR || path30.join(getGlobalDataDir(), "uploads");
-    const stagingDir = path30.resolve(uploadRoot, finalProjectId);
-    await fs18.rm(stagingDir, { recursive: true, force: true });
-    await fs18.mkdir(stagingDir, { recursive: true });
+    const uploadRoot = process.env.MASSA_AI_UPLOAD_DIR || path32.join(getGlobalDataDir(), "uploads");
+    const stagingDir = path32.resolve(uploadRoot, finalProjectId);
+    await fs20.rm(stagingDir, { recursive: true, force: true });
+    await fs20.mkdir(stagingDir, { recursive: true });
     const WRITE_BATCH = 20;
     for (let i = 0;i < params.files.length; i += WRITE_BATCH) {
       await Promise.all(params.files.slice(i, i + WRITE_BATCH).map(async (file2) => {
-        if (path30.isAbsolute(file2.relativePath) || file2.relativePath.includes("..")) {
+        if (path32.isAbsolute(file2.relativePath) || file2.relativePath.includes("..")) {
           throw new Error(`Invalid file path: ${file2.relativePath}`);
         }
-        const dest = path30.resolve(stagingDir, file2.relativePath.replace(/\//g, path30.sep));
-        if (!dest.startsWith(stagingDir + path30.sep)) {
+        const dest = path32.resolve(stagingDir, file2.relativePath.replace(/\//g, path32.sep));
+        if (!dest.startsWith(stagingDir + path32.sep)) {
           throw new Error(`Path escapes staging directory: ${file2.relativePath}`);
         }
-        await fs18.mkdir(path30.dirname(dest), { recursive: true });
-        await fs18.writeFile(dest, file2.content, "utf-8");
+        await fs20.mkdir(path32.dirname(dest), { recursive: true });
+        await fs20.writeFile(dest, file2.content, "utf-8");
       }));
     }
     return await indexProjectTool().handle({
@@ -167726,8 +167882,8 @@ class EmbeddedApiClient {
 // src/file-collector.ts
 init_config();
-import fs19 from "fs/promises";
-import path31 from "path";
+import fs21 from "fs/promises";
+import path33 from "path";
 var SKIP_DIRS = new Set([
   "node_modules",
   ".git",
@@ -167768,7 +167924,7 @@ async function walk2(root2, dir, files, state, allowed) {
     return;
   let entries;
   try {
-    entries = await fs19.readdir(dir, { withFileTypes: true });
+    entries = await fs21.readdir(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -167777,22 +167933,22 @@ async function walk2(root2, dir, files, state, allowed) {
       break;
     if (entry2.isDirectory()) {
       if (!SKIP_DIRS.has(entry2.name) && !entry2.name.startsWith(".")) {
-        await walk2(root2, path31.join(dir, entry2.name), files, state, allowed);
+        await walk2(root2, path33.join(dir, entry2.name), files, state, allowed);
       }
     } else if (entry2.isFile()) {
-      const ext2 = path31.extname(entry2.name).toLowerCase();
+      const ext2 = path33.extname(entry2.name).toLowerCase();
       if (!allowed.has(ext2))
         continue;
-      const fullPath = path31.join(dir, entry2.name);
+      const fullPath = path33.join(dir, entry2.name);
       try {
-        const stat = await fs19.stat(fullPath);
+        const stat = await fs21.stat(fullPath);
         if (stat.size > MAX_FILE_BYTES)
           continue;
         if (state.totalBytes + stat.size > MAX_TOTAL_BYTES)
           continue;
-        const content = await fs19.readFile(fullPath, "utf-8");
+        const content = await fs21.readFile(fullPath, "utf-8");
         state.totalBytes += stat.size;
-        const relativePath = path31.relative(root2, fullPath).split(path31.sep).join("/");
+        const relativePath = path33.relative(root2, fullPath).split(path33.sep).join("/");
         files.push({ relativePath, content });
       } catch {}
     }
@@ -169693,7 +169849,7 @@ class McpProxyServer {
       return textContent(JSON.stringify({ success: false, error: "projectPath is required" }));
     }
     try {
-      if (!(await fs20.stat(projectPath2)).isDirectory()) {
+      if (!(await fs22.stat(projectPath2)).isDirectory()) {
         return textContent(JSON.stringify({ success: false, error: `${projectPath2} is not a directory` }));
       }
     } catch {