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/config-cli.js CHANGED Viewed

@@ -552,6 +552,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,
@@ -636,15 +637,17 @@ function migrateDataDirOnce() {
 function __resetMigrationForTests() {
   migrationAttempted = false;
 }
-function saveConfig(config) {
-  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(config, null, 2));
-    fs.renameSync(tempFile, CONFIG_FILE);
+    fs.writeFileSync(tempFile, content, { mode: 384 });
+    fs.chmodSync(tempFile, 384);
+    fs.renameSync(tempFile, targetPath);
   } catch (error) {
     try {
       fs.unlinkSync(tempFile);
@@ -652,6 +655,9 @@ function saveConfig(config) {
     throw error;
   }
 }
+function saveConfig(config) {
+  writeFileAtomically(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
 function initConfig() {
   if (!fs.existsSync(CONFIG_FILE)) {
     saveConfig(defaultMassaAiConfig);
@@ -2018,7 +2024,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
     };
@@ -2188,6 +2194,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 (error) {
+    try {
+      fs6.unlinkSync(tempFile);
+    } catch {}
+    throw error;
+  }
+}
+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();
@@ -2196,6 +2310,8 @@ var init_dist = __esm(() => {
   init_state();
   init_lock();
   init_engine();
+  init_variant_sync();
+  init_repo_root();
   init_types();
   init_interfaces();
   init_utils();
@@ -3717,7 +3833,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;
   }
@@ -3775,11 +3891,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;
@@ -5745,12 +5861,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;
@@ -6278,8 +6394,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());
@@ -6304,8 +6420,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;
@@ -6324,8 +6440,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);
       }
@@ -6361,11 +6477,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;
@@ -6781,9 +6897,9 @@ var init_esm4 = __esm(() => {
       process2();
       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);
     }
   };
@@ -6800,8 +6916,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);
@@ -6817,8 +6933,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("/");
@@ -7075,8 +7191,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)
     ]);
@@ -7280,9 +7396,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;
@@ -7301,11 +7417,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;
@@ -7522,8 +7638,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);
@@ -7560,8 +7676,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
@@ -7989,20 +8105,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;
@@ -8045,7 +8161,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) => {
@@ -8053,7 +8169,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;
@@ -8065,39 +8181,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;
@@ -8105,7 +8221,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);
   }
 });
@@ -8167,13 +8283,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();
@@ -8224,8 +8340,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}`);
 }
@@ -8248,8 +8364,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);
@@ -9577,7 +9693,7 @@ var require_cert_signatures = __commonJS((exports, module) => {
 // ../../node_modules/pg/lib/crypto/sasl.js
 var require_sasl = __commonJS((exports, module) => {
-  var crypto5 = require_utils2();
+  var crypto6 = require_utils2();
   var { signatureAlgorithmHashFromCertificate } = require_cert_signatures();
   function saslprep(password) {
     const nonAsciiSpace = /[\u00A0\u1680\u2000-\u200B\u202F\u205F\u3000]/g;
@@ -9596,7 +9712,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,
@@ -9637,20 +9753,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;
@@ -9845,15 +9961,15 @@ var require_pg_connection_string = __commonJS((exports, module) => {
     if (config2.sslnegotiation === "direct" && config2.ssl === undefined) {
       config2.ssl = true;
     }
-    const fs7 = config2.sslcert || config2.sslkey || config2.sslrootcert ? __require("fs") : null;
+    const fs9 = config2.sslcert || config2.sslkey || config2.sslrootcert ? __require("fs") : null;
     if (config2.sslcert) {
-      config2.ssl.cert = fs7.readFileSync(config2.sslcert).toString();
+      config2.ssl.cert = fs9.readFileSync(config2.sslcert).toString();
     }
     if (config2.sslkey) {
-      config2.ssl.key = fs7.readFileSync(config2.sslkey).toString();
+      config2.ssl.key = fs9.readFileSync(config2.sslkey).toString();
     }
     if (config2.sslrootcert) {
-      config2.ssl.ca = fs7.readFileSync(config2.sslrootcert).toString();
+      config2.ssl.ca = fs9.readFileSync(config2.sslrootcert).toString();
     }
     if (options.useLibpqCompat && config2.uselibpqcompat) {
       throw new Error("Both useLibpqCompat and uselibpqcompat are set. Please use only one of them.");
@@ -11567,7 +11683,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 util = __require("util");
@@ -11607,7 +11723,7 @@ var require_helper = __commonJS((exports, module) => {
   };
   exports.getFileName = function(rawEnv) {
     var env = rawEnv || process.env;
-    var file = env.PGPASSFILE || (isWin ? path11.join(env.APPDATA || "./", "postgresql", "pgpass.conf") : path11.join(env.HOME || "./", ".pgpass"));
+    var file = env.PGPASSFILE || (isWin ? path13.join(env.APPDATA || "./", "postgresql", "pgpass.conf") : path13.join(env.HOME || "./", ".pgpass"));
     return file;
   };
   exports.usePgPass = function(stats, fname) {
@@ -11731,16 +11847,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 file = helper.getFileName();
-    fs7.stat(file, function(err, stat) {
+    fs9.stat(file, function(err, stat) {
       if (err || !helper.usePgPass(stat, file)) {
         return cb(undefined);
       }
-      var st = fs7.createReadStream(file);
+      var st = fs9.createReadStream(file);
       helper.getPassword(connInfo, st, cb);
     });
   };
@@ -11758,7 +11874,7 @@ var require_client = __commonJS((exports, module) => {
   var Query = require_query();
   var defaults2 = require_defaults();
   var Connection = require_connection();
-  var crypto5 = require_utils2();
+  var crypto6 = require_utils2();
   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.");
@@ -11990,7 +12106,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);
@@ -13439,8 +13555,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;
@@ -13533,9 +13649,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,
@@ -13586,9 +13702,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,
@@ -14039,10 +14155,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path12) {
-  if (!path12)
+function getElementAtPath(obj, path14) {
+  if (!path14)
     return obj;
-  return path12.reduce((acc, key) => acc?.[key], obj);
+  return path14.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -14370,11 +14486,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path12, issues) {
+function prefixIssues(path14, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path12);
+    iss.path.unshift(path14);
     return iss;
   });
 }
@@ -14587,16 +14703,16 @@ function flattenError(error, mapper = (issue2) => issue2.message) {
 }
 function formatError(error, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error2, path12 = []) => {
+  const processError = (error2, path14 = []) => {
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path12, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path14, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
       } else {
-        const fullpath = [...path12, ...issue2.path];
+        const fullpath = [...path14, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -14623,17 +14739,17 @@ function formatError(error, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error2, path12 = []) => {
+  const processError = (error2, path14 = []) => {
     var _a3, _b;
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path12, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path14, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
       } else {
-        const fullpath = [...path12, ...issue2.path];
+        const fullpath = [...path14, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -14665,8 +14781,8 @@ function treeifyError(error, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path12 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path12) {
+  const path14 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path14) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -27669,13 +27785,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path12 = ref.slice(1).split("/").filter(Boolean);
-  if (path12.length === 0) {
+  const path14 = ref.slice(1).split("/").filter(Boolean);
+  if (path14.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path12[0] === defsKey) {
-    const key = path12[1];
+  if (path14[0] === defsKey) {
+    const key = path14[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -29164,8 +29280,8 @@ class ParseStatus {
   }
 }
 var makeIssue = (params) => {
-  const { data, path: path12, errorMaps, issueData } = params;
-  const fullPath = [...path12, ...issueData.path || []];
+  const { data, path: path14, errorMaps, issueData } = params;
+  const fullPath = [...path14, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -29210,11 +29326,11 @@ var init_errorUtil = __esm(() => {
 // ../../node_modules/zod/v3/types.js
 class ParseInputLazyPath {
-  constructor(parent, value, path12, key) {
+  constructor(parent, value, path14, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path12;
+    this._path = path14;
     this._key = key;
   }
   get path() {
@@ -35279,23 +35395,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;
       }
@@ -35306,11 +35422,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)
@@ -35485,8 +35601,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();
@@ -35498,7 +35614,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)();
@@ -35566,11 +35682,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.");
     }
@@ -35581,11 +35697,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) {
@@ -35593,11 +35709,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;
   }
@@ -46439,37 +46555,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
   });
@@ -46482,7 +46598,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-"]
@@ -63027,26 +63143,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, () => {});
         });
       }
     });
@@ -63151,11 +63267,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;
       }
     }
@@ -63200,8 +63316,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;
   };
@@ -63212,8 +63328,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;
   };
@@ -64875,18 +64991,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);
@@ -67748,15 +67864,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) {
@@ -68361,7 +68477,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([
@@ -68392,9 +68508,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) {
@@ -75641,11 +75757,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) {
@@ -88709,7 +88825,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) {
@@ -88717,14 +88833,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());
         }
       }
     },
@@ -88820,11 +88936,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);
@@ -89425,8 +89541,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);
@@ -90182,20 +90298,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() {
@@ -99726,10 +99842,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) {
@@ -103697,7 +103813,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",
@@ -109241,9 +109357,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 = {
@@ -109252,7 +109366,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 {
@@ -109640,6 +109759,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);
@@ -109731,7 +109887,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;
@@ -109788,7 +109944,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 = [
@@ -116524,10 +116680,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;
@@ -116834,8 +116990,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);
@@ -116878,7 +117034,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", {
@@ -116918,7 +117074,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,
@@ -117043,7 +117199,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;
@@ -117094,8 +117250,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 = config.get("security").maxFileSize || 1024 * 1024;
   if (content.length > maxFileSize) {
     logger.warn("File too large, skipping", {
@@ -117115,7 +117271,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,
@@ -120446,16 +120602,16 @@ function detectRoutes(httpEdges, defs, opts = {}) {
   const seen = new Set;
   const out = [];
   for (const e of httpEdges) {
-    const path14 = e.route;
-    if (!path14)
+    const path16 = e.route;
+    if (!path16)
       continue;
     const method = (e.method ?? "ANY").toUpperCase();
-    const key = method + " " + path14;
+    const key = method + " " + path16;
     if (seen.has(key))
       continue;
     seen.add(key);
     out.push({
-      path: path14,
+      path: path16,
       method: e.method,
       file: e.fromFile,
       handler: e.targetFqn ?? e.symbolName
@@ -120466,12 +120622,12 @@ function detectRoutes(httpEdges, defs, opts = {}) {
       continue;
     const parsed = parseRouteName(d.name);
     const method = parsed?.method ?? "ANY";
-    const path14 = parsed?.path ?? d.name;
-    const key = method + " " + path14;
+    const path16 = parsed?.path ?? d.name;
+    const key = method + " " + path16;
     if (seen.has(key))
       continue;
     seen.add(key);
-    out.push({ path: path14, method: parsed?.method, file: d.filePath, handler: d.name });
+    out.push({ path: path16, method: parsed?.method, file: d.filePath, handler: d.name });
   }
   for (const d of defs) {
     const parsed = parseRouteName(d.name);
@@ -120692,8 +120848,8 @@ __export(exports_symbol_graph_service, {
   symbolGraphService: () => symbolGraphService,
   SymbolGraphService: () => SymbolGraphService
 });
-import path14 from "path";
-import fs9 from "fs/promises";
+import path16 from "path";
+import fs11 from "fs/promises";
 class SymbolGraphService {
   identityLookup;
@@ -121021,7 +121177,7 @@ class SymbolGraphService {
   async readSnippet(relativePath, lineStart, lineEnd, projectId) {
     try {
       const absolutePath = await this.resolveToAbsolute(relativePath, projectId);
-      const content = await fs9.readFile(absolutePath, "utf-8");
+      const content = await fs11.readFile(absolutePath, "utf-8");
       const lines = content.split(`
 `);
       return lines.slice(Math.max(0, lineStart - 1), Math.min(lines.length, lineEnd)).join(`
@@ -121033,7 +121189,7 @@ class SymbolGraphService {
   async readContext(relativePath, lineNumber, contextLines, projectId) {
     try {
       const absolutePath = await this.resolveToAbsolute(relativePath, projectId);
-      const content = await fs9.readFile(absolutePath, "utf-8");
+      const content = await fs11.readFile(absolutePath, "utf-8");
       const lines = content.split(`
 `);
       const start = Math.max(0, lineNumber - contextLines - 1);
@@ -121046,7 +121202,7 @@ class SymbolGraphService {
   }
   async resolveToAbsolute(relativePath, projectId) {
     const root = await this.getProjectRoot(projectId);
-    return root ? path14.resolve(root, relativePath) : relativePath;
+    return root ? path16.resolve(root, relativePath) : relativePath;
   }
   async getProjectRoot(projectId) {
     const cached2 = this.projectRootCache.get(projectId);
@@ -122824,31 +122980,31 @@ class TracePathService {
     const chains = [];
     const seen = new Set;
     let walks = 0;
-    const walk = (fqn, path15) => {
+    const walk = (fqn, path17) => {
       if (chains.length >= CHAIN_CAP)
         return;
       if (walks >= MAX_WALKS)
         return;
       walks++;
-      const key = path15.join("\u2192");
+      const key = path17.join("\u2192");
       if (seen.has(key))
         return;
       seen.add(key);
       const next = adj.get(fqn);
       if (!next || next.length === 0 || !whoHasChild.has(fqn)) {
-        if (path15.length > 1)
-          chains.push(path15.map((n) => this.fqnToName(n)).join(" \u2192 "));
+        if (path17.length > 1)
+          chains.push(path17.map((n) => this.fqnToName(n)).join(" \u2192 "));
         return;
       }
       for (const child of next) {
         if (chains.length >= CHAIN_CAP || walks >= MAX_WALKS)
           return;
-        if (path15.includes(child)) {
-          const cycled = [...path15, `${this.fqnToName(child)}\u21BA`];
+        if (path17.includes(child)) {
+          const cycled = [...path17, `${this.fqnToName(child)}\u21BA`];
           chains.push(cycled.map((n) => n).join(" \u2192 "));
           continue;
         }
-        walk(child, [...path15, child]);
+        walk(child, [...path17, child]);
       }
     };
     for (const seed of seeds) {
@@ -124842,9 +124998,9 @@ var init_l1_memory_cache = __esm(() => {
 });
 // ../../packages/core/dist/services/health/local-health-checker.js
-import fs10 from "fs/promises";
+import fs12 from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import path15 from "path";
+import path17 from "path";
 class LocalHealthChecker {
   ollamaBaseUrl = process.env.OLLAMA_BASE_URL || "http://localhost:11434";
@@ -124878,10 +125034,10 @@ class LocalHealthChecker {
     const start = Date.now();
     try {
       if (!existsSync3(this.dataDir))
-        await fs10.mkdir(this.dataDir, { recursive: true });
-      const probe = path15.join(this.dataDir, ".health-check-test");
-      await fs10.writeFile(probe, "ok");
-      await fs10.unlink(probe);
+        await fs12.mkdir(this.dataDir, { recursive: true });
+      const probe = path17.join(this.dataDir, ".health-check-test");
+      await fs12.writeFile(probe, "ok");
+      await fs12.unlink(probe);
       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}` };
@@ -127980,9 +128136,9 @@ var init_scheduler2 = __esm(() => {
 });
 // ../../packages/core/dist/services/pricing/models-dev-client.js
-import fs11 from "fs/promises";
+import fs13 from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import path16 from "path";
+import path18 from "path";
 function getModelsDevClient() {
   if (!clientInstance) {
     clientInstance = new ModelsDevClient;
@@ -128002,7 +128158,7 @@ var init_models_dev_client = __esm(() => {
     memoryCacheTimestamp = 0;
     getLocalCachePath() {
       const dataDir = config.get("dataDir");
-      return path16.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
+      return path18.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
     }
     async loadLocalCache() {
       const cachePath = this.getLocalCachePath();
@@ -128010,7 +128166,7 @@ var init_models_dev_client = __esm(() => {
         if (!existsSync4(cachePath)) {
           return null;
         }
-        const content = await fs11.readFile(cachePath, "utf-8");
+        const content = await fs13.readFile(cachePath, "utf-8");
         const data = JSON.parse(content);
         const age = Date.now() - data.timestamp;
         if (age > ModelsDevClient.LOCAL_CACHE_TTL) {
@@ -128037,14 +128193,14 @@ var init_models_dev_client = __esm(() => {
     async saveLocalCache(models) {
       const cachePath = this.getLocalCachePath();
       try {
-        const dir = path16.dirname(cachePath);
-        await fs11.mkdir(dir, { recursive: true });
+        const dir = path18.dirname(cachePath);
+        await fs13.mkdir(dir, { recursive: true });
         const data = {
           timestamp: Date.now(),
           version: "1.0.0",
           models: Object.fromEntries(models)
         };
-        await fs11.writeFile(cachePath, JSON.stringify(data), "utf-8");
+        await fs13.writeFile(cachePath, JSON.stringify(data), "utf-8");
         logger.debug("Saved pricing to local cache", {
           models: models.size,
           path: cachePath
@@ -128373,7 +128529,7 @@ var init_models_dev_client = __esm(() => {
       const cachePath = this.getLocalCachePath();
       try {
         if (existsSync4(cachePath)) {
-          await fs11.unlink(cachePath);
+          await fs13.unlink(cachePath);
           logger.debug("Local pricing cache file deleted");
         }
       } catch (error51) {
@@ -128976,8 +129132,8 @@ function stripNul(content) {
 }
 // ../../packages/core/dist/services/etl/stages/discover.js
-import fs12 from "fs/promises";
-import path17 from "path";
+import fs14 from "fs/promises";
+import path19 from "path";
 import { createHash as createHash8 } from "crypto";
 class DiscoverStage {
@@ -129003,7 +129159,7 @@ class DiscoverStage {
         dot: false,
         absolute: false
       });
-      relPaths = found.map((p) => path17.isAbsolute(p) ? path17.relative(ctx.projectPath, p) : p).filter((p) => !ig.ignores(p) && applyPolicy(p, policy) !== "Drop");
+      relPaths = found.map((p) => path19.isAbsolute(p) ? path19.relative(ctx.projectPath, p) : p).filter((p) => !ig.ignores(p) && applyPolicy(p, policy) !== "Drop");
     }
     if (ctx.resumeCursor?.path) {
       const cursorPath = ctx.resumeCursor.path;
@@ -129062,10 +129218,10 @@ class DiscoverStage {
     return discovered;
   }
   async processFile(ctx, relativePath, forceReindex) {
-    const absolutePath = path17.join(ctx.projectPath, relativePath);
+    const absolutePath = path19.join(ctx.projectPath, relativePath);
     try {
-      const stat = await fs12.stat(absolutePath);
-      const content = stripNul(await fs12.readFile(absolutePath, "utf-8"));
+      const stat = await fs14.stat(absolutePath);
+      const content = stripNul(await fs14.readFile(absolutePath, "utf-8"));
       const contentHash = createHash8("sha256").update(content).digest("hex");
       let needsReparse = forceReindex;
       if (!forceReindex) {
@@ -129108,8 +129264,8 @@ class DiscoverStage {
       ig.add(pattern);
     }
     try {
-      const gitignorePath = path17.join(projectPath, ".gitignore");
-      const gitignoreContent = await fs12.readFile(gitignorePath, "utf8");
+      const gitignorePath = path19.join(projectPath, ".gitignore");
+      const gitignoreContent = await fs14.readFile(gitignorePath, "utf8");
       const rules = gitignoreContent.split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
       ig.add(rules);
@@ -130464,8 +130620,8 @@ function rustUseLeaves(node, source, prefix = []) {
   }
   if (node.type === "use_wildcard")
     return [{ path: [...prefix, "*"], glob: true }];
-  const path18 = rustPathSegments(node, source);
-  return path18.length ? [{ path: [...prefix, ...path18] }] : [];
+  const path20 = rustPathSegments(node, source);
+  return path20.length ? [{ path: [...prefix, ...path20] }] : [];
 }
 function functionalCaptures(captures, source, family) {
   if (family !== "clojure")
@@ -131437,8 +131593,8 @@ var init_structural_runtime = __esm(() => {
 });
 // ../../packages/core/dist/services/etl/stages/parse.js
-import path18 from "path";
-import fs13 from "fs/promises";
+import path20 from "path";
+import fs15 from "fs/promises";
 function resolveChunkerMaxChars() {
   const global2 = Number(process.env.EMBEDDING_MAX_CHARS);
   if (Number.isFinite(global2) && global2 > 0)
@@ -131466,8 +131622,8 @@ class ParseStage {
     const results = new Map;
     let processed = 0;
     const phases = [
-      files.filter((file2) => path18.extname(file2.relativePath).toLowerCase() !== ".h"),
-      files.filter((file2) => path18.extname(file2.relativePath).toLowerCase() === ".h")
+      files.filter((file2) => path20.extname(file2.relativePath).toLowerCase() !== ".h"),
+      files.filter((file2) => path20.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) {
@@ -131505,19 +131661,19 @@ class ParseStage {
     return files.map((file2) => results.get(file2.relativePath));
   }
   recordHeaderImporterEvidence(ctx, files, parsedFiles) {
-    const knownHeaders = new Set(files.filter((file2) => path18.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path18.posix.normalize(file2.relativePath)));
+    const knownHeaders = new Set(files.filter((file2) => path20.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path20.posix.normalize(file2.relativePath)));
     const mutable = {
       ...ctx.structuralHeaderEvidenceByFile
     };
     for (const parsed of parsedFiles) {
-      const extension = path18.extname(parsed.file.relativePath).toLowerCase();
+      const extension = path20.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 = path18.posix.normalize(path18.posix.join(path18.posix.dirname(parsed.file.relativePath), imported.specifier));
+        const header = path20.posix.normalize(path20.posix.join(path20.posix.dirname(parsed.file.relativePath), imported.specifier));
         if (!knownHeaders.has(header))
           continue;
         const existing = mutable[header] ?? {};
@@ -131528,9 +131684,9 @@ class ParseStage {
   }
   async parseFile(ctx, file2) {
     if (!file2.needsReparse) {
-      const extension = path18.extname(file2.relativePath).toLowerCase();
+      const extension = path20.extname(file2.relativePath).toLowerCase();
       if ([".c", ".cpp", ".hpp"].includes(extension)) {
-        const content = file2.snapshotContent ?? await fs13.readFile(file2.absolutePath, "utf8");
+        const content = file2.snapshotContent ?? await fs15.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));
@@ -131542,8 +131698,8 @@ class ParseStage {
       return { file: file2, chunks: [], symbols: [], rawImports: [], rawEdges: [] };
     }
     try {
-      const content = file2.snapshotContent ?? await fs13.readFile(file2.absolutePath, "utf-8");
-      const ext2 = path18.extname(file2.relativePath).toLowerCase();
+      const content = file2.snapshotContent ?? await fs15.readFile(file2.absolutePath, "utf-8");
+      const ext2 = path20.extname(file2.relativePath).toLowerCase();
       const chunkerMaxChars = resolveChunkerMaxChars();
       const chunks = smartChunk(content, file2.relativePath, chunkerMaxChars ? { maxChunkChars: chunkerMaxChars } : {});
       let symbols;
@@ -132097,7 +132253,7 @@ var init_resolver = __esm(() => {
 });
 // ../../packages/core/dist/services/structural/resolvers/typescript.js
-import path19 from "path";
+import path21 from "path";
 function candidates(identities) {
   return Object.freeze(identities.map((identity) => Object.freeze({
     fqn: identity.fqn,
@@ -132192,7 +132348,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 = path19.posix.normalize(`${candidateBase}${suffix}`);
+      const value = path21.posix.normalize(`${candidateBase}${suffix}`);
       if (!value.startsWith("../") && value !== ".." && known.has(value))
         return value;
     }
@@ -132201,7 +132357,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(path19.posix.join(path19.posix.dirname(fromFile), specifier), known, dialect);
+    return probe(path21.posix.join(path21.posix.dirname(fromFile), specifier), known, dialect);
   }
   const aliases = build.pathAliasesByFile?.[normalizeStructuralFile(fromFile)] ?? build.pathAliases ?? [];
   for (const alias of aliases) {
@@ -132465,7 +132621,7 @@ var init_scripting2 = __esm(() => {
 });
 // ../../packages/core/dist/services/structural/resolvers/systems.js
-import path20 from "path";
+import path22 from "path";
 var DIALECTS, SYSTEMS_LANGUAGE_RESOLVER;
 var init_systems2 = __esm(() => {
   init_typescript2();
@@ -132484,7 +132640,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: `./${path20.posix.relative(path20.posix.dirname(file2.file), path20.posix.join(crateRoot, item.specifier.replace(/^crate\/?/u, "")))}` };
+            return { ...item, bindings, specifier: `./${path22.posix.relative(path22.posix.dirname(file2.file), path22.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, "")}` };
@@ -132582,8 +132738,8 @@ var init_data_document2 = __esm(() => {
 });
 // ../../packages/core/dist/services/etl/stages/resolve.js
-import path21 from "path";
-import fs14 from "fs";
+import path23 from "path";
+import fs16 from "fs";
 class ResolveStage {
   symbolRepository;
@@ -132607,7 +132763,7 @@ class ResolveStage {
     const structuralDocuments = files.flatMap((file2) => {
       if (!file2.structure)
         return [];
-      const language = resolveStructuralLanguage(path21.extname(file2.file.relativePath));
+      const language = resolveStructuralLanguage(path23.extname(file2.file.relativePath));
       if (language.status !== "supported")
         throw new Error(`structural_manifest_missing:${file2.file.relativePath}`);
       return [{
@@ -132619,13 +132775,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(path21.extname(item.file.relativePath).toLowerCase())).map((item) => item.file.relativePath));
+    const skippedStructuralFiles = new Set(files.filter((item) => !item.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path23.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(path21.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(path23.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))
@@ -132718,7 +132874,7 @@ class ResolveStage {
     if (parsed.file !== definition.file_path) {
       throw new Error(`structural_repository_seed_file_mismatch:${definition.id}`);
     }
-    const language = resolveStructuralLanguage(path21.extname(definition.file_path));
+    const language = resolveStructuralLanguage(path23.extname(definition.file_path));
     if (language.status !== "supported")
       throw new Error(`structural_repository_seed_language:${definition.id}`);
     let identity;
@@ -132770,7 +132926,7 @@ class ResolveStage {
     });
   }
   resolveFile(parsed, projectPath, knownRelPaths, rootAliases, monorepoPackages, symbolIndex, knownFqns) {
-    const fromDir = path21.dirname(path21.join(projectPath, parsed.file.relativePath));
+    const fromDir = path23.dirname(path23.join(projectPath, parsed.file.relativePath));
     const packageAliases = this.getPackageAliases(parsed.file.relativePath, monorepoPackages);
     const allAliases = [...packageAliases, ...rootAliases];
     const resolvedImports = parsed.rawImports.map((raw2) => {
@@ -132841,7 +132997,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(path21.extname(file2.file.relativePath).toLowerCase()));
+      const skippedStructural = files.some((file2) => !file2.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path23.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", {
@@ -132865,7 +133021,7 @@ class ResolveStage {
   }
   resolveSpecifier(specifier, fromDir, projectPath, knownRelPaths, aliases) {
     if (specifier.startsWith("./") || specifier.startsWith("../")) {
-      const resolved = this.probeExtensions(path21.resolve(fromDir, specifier), projectPath, knownRelPaths);
+      const resolved = this.probeExtensions(path23.resolve(fromDir, specifier), projectPath, knownRelPaths);
       return { resolvedPath: resolved, external: false };
     }
     for (const alias of aliases) {
@@ -132873,8 +133029,8 @@ class ResolveStage {
         const suffix = specifier.slice(alias.prefix.length);
         for (const target of alias.targets) {
           const cleanTarget = target.replace(/\/\*$/, "");
-          const basePath = alias.packagePath ? path21.join(projectPath, alias.packagePath) : projectPath;
-          const absPath = path21.join(basePath, cleanTarget + suffix);
+          const basePath = alias.packagePath ? path23.join(projectPath, alias.packagePath) : projectPath;
+          const absPath = path23.join(basePath, cleanTarget + suffix);
           const resolved = this.probeExtensions(absPath, projectPath, knownRelPaths);
           if (resolved)
             return { resolvedPath: resolved, external: false };
@@ -132890,7 +133046,7 @@ class ResolveStage {
       ...TS_EXTENSIONS.map((ext2) => absPath.replace(/\.[^.]+$/, ext2))
     ];
     for (const candidate2 of candidates2) {
-      const rel = path21.relative(projectPath, candidate2).replace(/\\/g, "/");
+      const rel = path23.relative(projectPath, candidate2).replace(/\\/g, "/");
       if (knownRelPaths.has(rel))
         return rel;
     }
@@ -132898,9 +133054,9 @@ class ResolveStage {
   }
   loadTsConfigPaths(projectPath, packageBase) {
     const aliases = [];
-    const tsconfigPath = path21.join(projectPath, "tsconfig.json");
+    const tsconfigPath = path23.join(projectPath, "tsconfig.json");
     try {
-      const raw2 = fs14.readFileSync(tsconfigPath, "utf-8");
+      const raw2 = fs16.readFileSync(tsconfigPath, "utf-8");
       const stripped = raw2.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
       const tsconfig = JSON.parse(stripped);
       const paths = tsconfig?.compilerOptions?.paths ?? {};
@@ -132929,7 +133085,7 @@ class ResolveStage {
       }
     }
     for (const packageRelPath of packagePaths) {
-      const absPackagePath = path21.join(projectPath, packageRelPath);
+      const absPackagePath = path23.join(projectPath, packageRelPath);
       const aliases = this.loadTsConfigPaths(absPackagePath, packageRelPath);
       if (aliases.length > 0) {
         packages.push({
@@ -132959,7 +133115,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 ? path21.posix.join(alias.packagePath, target) : target)
+      targets: alias.targets.map((target) => alias.packagePath ? path23.posix.join(alias.packagePath, target) : target)
     }));
   }
 }
@@ -133023,7 +133179,7 @@ var init_with_deadlock_retry = __esm(() => {
 });
 // ../../packages/core/dist/services/etl/stages/load.js
-import path22 from "path";
+import path24 from "path";
 function formatDuration(ms) {
   const totalSec = Math.max(0, Math.round(ms / 1000));
   if (totalSec < 60)
@@ -133300,7 +133456,7 @@ class LoadStage {
     const filePath = file2.file.relativePath;
     const batch = buildSymbolPersistenceBatch(ctx.projectId, file2);
     if (ctx.graphGenerationLease) {
-      const manifest = getLanguageManifestEntry(path22.extname(filePath));
+      const manifest = getLanguageManifestEntry(path24.extname(filePath));
       const diagnostics2 = (file2.structuralDiagnostics ?? []).slice(0, 10).map((diagnostic2) => ({
         code: diagnostic2.code,
         severity: diagnostic2.severity,
@@ -133757,9 +133913,9 @@ var init_graph_generation_coordinator = __esm(() => {
 // ../../packages/core/dist/services/etl/pipeline.js
 import { createHash as createHash10 } from "crypto";
 import { setTimeout as delay2 } from "timers/promises";
-import path23 from "path";
+import path25 from "path";
 function buildHeaderLanguageEvidence(files) {
-  const headers = new Set(files.filter((file2) => path23.posix.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path23.posix.normalize(file2.relativePath)));
+  const headers = new Set(files.filter((file2) => path25.posix.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path25.posix.normalize(file2.relativePath)));
   const mutable = new Map;
   const entry2 = (header) => {
     let value = mutable.get(header);
@@ -133770,7 +133926,7 @@ function buildHeaderLanguageEvidence(files) {
     return value;
   };
   for (const file2 of files) {
-    if (path23.posix.basename(file2.relativePath) !== "compile_commands.json" || file2.snapshotContent === undefined)
+    if (path25.posix.basename(file2.relativePath) !== "compile_commands.json" || file2.snapshotContent === undefined)
       continue;
     let commands;
     try {
@@ -133786,11 +133942,11 @@ function buildHeaderLanguageEvidence(files) {
       const record2 = command;
       if (typeof record2.file !== "string")
         continue;
-      const projectRoot = path23.resolve(file2.absolutePath, ...file2.relativePath.split("/").map(() => ".."));
-      const commandDirectory = typeof record2.directory === "string" ? path23.resolve(projectRoot, record2.directory) : projectRoot;
-      const absoluteInput = path23.resolve(commandDirectory, record2.file);
-      const relative3 = path23.relative(projectRoot, absoluteInput);
-      const header = path23.posix.normalize(relative3.replaceAll(path23.sep, "/"));
+      const projectRoot = path25.resolve(file2.absolutePath, ...file2.relativePath.split("/").map(() => ".."));
+      const commandDirectory = typeof record2.directory === "string" ? path25.resolve(projectRoot, record2.directory) : projectRoot;
+      const absoluteInput = path25.resolve(commandDirectory, record2.file);
+      const relative3 = path25.relative(projectRoot, absoluteInput);
+      const header = path25.posix.normalize(relative3.replaceAll(path25.sep, "/"));
       if (!headers.has(header))
         continue;
       const invocation = typeof record2.command === "string" ? record2.command : Array.isArray(record2.arguments) ? record2.arguments.join(" ") : "";
@@ -139656,33 +139812,33 @@ var require_URL = __commonJS((exports, module) => {
         else
           return basepath.substring(0, lastslash + 1) + refpath;
       }
-      function remove_dot_segments(path24) {
-        if (!path24)
-          return path24;
+      function remove_dot_segments(path26) {
+        if (!path26)
+          return path26;
         var output = "";
-        while (path24.length > 0) {
-          if (path24 === "." || path24 === "..") {
-            path24 = "";
+        while (path26.length > 0) {
+          if (path26 === "." || path26 === "..") {
+            path26 = "";
             break;
           }
-          var twochars = path24.substring(0, 2);
-          var threechars = path24.substring(0, 3);
-          var fourchars = path24.substring(0, 4);
+          var twochars = path26.substring(0, 2);
+          var threechars = path26.substring(0, 3);
+          var fourchars = path26.substring(0, 4);
           if (threechars === "../") {
-            path24 = path24.substring(3);
+            path26 = path26.substring(3);
           } else if (twochars === "./") {
-            path24 = path24.substring(2);
+            path26 = path26.substring(2);
           } else if (threechars === "/./") {
-            path24 = "/" + path24.substring(3);
-          } else if (twochars === "/." && path24.length === 2) {
-            path24 = "/";
-          } else if (fourchars === "/../" || threechars === "/.." && path24.length === 3) {
-            path24 = "/" + path24.substring(4);
+            path26 = "/" + path26.substring(3);
+          } else if (twochars === "/." && path26.length === 2) {
+            path26 = "/";
+          } else if (fourchars === "/../" || threechars === "/.." && path26.length === 3) {
+            path26 = "/" + path26.substring(4);
             output = output.replace(/\/?[^\/]*$/, "");
           } else {
-            var segment = path24.match(/(\/?([^\/]*))/)[0];
+            var segment = path26.match(/(\/?([^\/]*))/)[0];
             output += segment;
-            path24 = path24.substring(segment.length);
+            path26 = path26.substring(segment.length);
           }
         }
         return output;
@@ -151752,21 +151908,21 @@ function jsonToKeyPathChunks(value, label = "$") {
   walk(value, label, out);
   return out;
 }
-function walk(val, path24, out) {
+function walk(val, path26, out) {
   if (val === null || val === undefined)
     return;
   if (Array.isArray(val)) {
     if (val.length === 0) {
-      out.push({ path: path24, content: `**${path24}** = _[]_` });
+      out.push({ path: path26, content: `**${path26}** = _[]_` });
       return;
     }
     if (val.every((v) => v !== null && typeof v === "object")) {
-      val.forEach((v, i) => walk(v, `${path24}[${i}]`, out));
+      val.forEach((v, i) => walk(v, `${path26}[${i}]`, out));
       return;
     }
     const items = val.map((v) => `- \`${String(v)}\``).join(`
 `);
-    out.push({ path: path24, content: `**${path24}**
+    out.push({ path: path26, content: `**${path26}**
 ${items}` });
     return;
@@ -151774,16 +151930,16 @@ ${items}` });
   if (typeof val === "object") {
     const entries = Object.entries(val);
     if (entries.length === 0) {
-      out.push({ path: path24, content: `**${path24}** = _{}_` });
+      out.push({ path: path26, content: `**${path26}** = _{}_` });
       return;
     }
     for (const [k, v] of entries) {
       const safeKey = /^[A-Za-z_$][\w$]*$/.test(k) ? k : JSON.stringify(k);
-      walk(v, `${path24}.${safeKey}`, out);
+      walk(v, `${path26}.${safeKey}`, out);
     }
     return;
   }
-  out.push({ path: path24, content: `**${path24}** = \`${String(val)}\`` });
+  out.push({ path: path26, content: `**${path26}** = \`${String(val)}\`` });
 }
 var gfm, STRIP_SELECTORS, tdCache = null;
 var init_html_to_md = __esm(() => {
@@ -152207,6 +152363,15 @@ var init_recover_project = __esm(() => {
 // src/config-cli.ts
 init_config();
 init_dist();
+var GENERATOR_MARKER = "scripts/generate-subagent-artifacts.ts";
+var GENERATOR_MARKER_MAX_LEVELS = 6;
+function formatVariantSync(results) {
+  for (const r of results) {
+    if (r.status === "synced") {
+      console.log(`  synced ${r.host}: ${r.files} file(s) across ${r.profiles.length} profile(s)`);
+    }
+  }
+}
 function help() {
   console.log(`
 massa-ai-config - Configuration manager for massa-ai
@@ -152451,6 +152616,8 @@ Using defaults:`);
           return 1;
         }
         try {
+          const sourceRoot = findRepoRootWithMarker(import.meta.dirname, GENERATOR_MARKER, GENERATOR_MARKER_MAX_LEVELS);
+          formatVariantSync(syncGeneratedVariants({ sourceRoot }));
           const report = switchProfile({
             profile: name26,
             host: hostOpt,