@massa-ai/tools-api 1.59.0 → 1.60.1

package/dist/index.js

@@ -487,13 +487,33 @@ var init_inference_providers = __esm(() => {
       },
       knownDimensions: {
         "text-embedding-nomic-embed-text-v1.5": 768,
-        "text-embedding-qwen3-embedding-0.6b": 1024
+        "text-embedding-qwen3-embedding-0.6b": 1024,
+        "qwen3-embedding-0.6b-dwq": 1024
       },
       defaultModels: {
         embedding: "text-embedding-qwen3-embedding-0.6b",
         instruct: "qwen3-vl-8b-instruct",
         coding: "qwen2.5-coder-7b-instruct"
       },
+      mlxModels: {
+        embedding: {
+          repo: "mlx-community/Qwen3-Embedding-0.6B-4bit-DWQ",
+          model: "qwen3-embedding-0.6b-dwq"
+        },
+        instruct: {
+          repo: "mlx-community/Qwen3-VL-8B-Instruct-4bit",
+          model: "qwen3-vl-8b-instruct"
+        },
+        coding: {
+          repo: "mlx-community/Qwen2.5-Coder-7B-Instruct-4bit",
+          model: "qwen2.5-coder-7b-instruct"
+        }
+      },
+      ggufRepos: {
+        embedding: "Qwen/Qwen3-Embedding-0.6B-GGUF",
+        instruct: "lmstudio-community/Qwen3-VL-8B-Instruct-GGUF",
+        coding: "lmstudio-community/Qwen2.5-Coder-7B-Instruct-GGUF"
+      },
       appliesContextPerRequest: false,
       embedBatchSize: 64,
       supportsOllamaVersionProbe: false,
@@ -8313,12 +8333,13 @@ function selectRecord(records) {
   }
   return best ?? pool[pool.length - 1];
 }
-function resolveClaudeMarketplaceRoot(opts = {}) {
+function resolveClaudeMarketplaceInstall(opts = {}) {
   const targetHome = opts.targetHome ?? os5.homedir();
   const pluginKey = opts.pluginKey ?? DEFAULT_PLUGIN_KEY;
   const directoryResult = resolveDirectorySourceRoot(targetHome, pluginKey);
-  if (directoryResult !== undefined)
-    return directoryResult;
+  if (directoryResult !== undefined) {
+    return directoryResult === null ? null : { root: directoryResult, route: "directory-source" };
+  }
   const registryPath = path11.join(targetHome, ".claude", "plugins", "installed_plugins.json");
   let records;
   try {
@@ -8340,15 +8361,197 @@ function resolveClaudeMarketplaceRoot(opts = {}) {
   } catch {
     return null;
   }
-  return installPath;
+  return { root: installPath, route: "registry-cache" };
+}
+function resolveClaudeMarketplaceRoot(opts = {}) {
+  return resolveClaudeMarketplaceInstall(opts)?.root ?? null;
+}
+function readInstalledPluginVersion(opts = {}) {
+  const targetHome = opts.targetHome ?? os5.homedir();
+  const pluginKey = opts.pluginKey ?? DEFAULT_PLUGIN_KEY;
+  const registryPath = path11.join(targetHome, ".claude", "plugins", "installed_plugins.json");
+  let records;
+  try {
+    const parsed = JSON.parse(fs7.readFileSync(registryPath, "utf8"));
+    records = parsed?.plugins?.[pluginKey];
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(records) || records.length === 0)
+    return null;
+  return selectRecord(records)?.version ?? null;
 }
 var DEFAULT_PLUGIN_KEY = "massa-ai@massa-ai";
 var init_claude_marketplace = () => {};
 
-// ../../packages/shared/dist/profile-switch/engine.js
+// ../../packages/shared/dist/profile-switch/frontmatter.js
+function parseFrontmatter(raw2) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/.exec(raw2);
+  if (!match) {
+    throw new Error("charter missing YAML frontmatter (--- ... ---) block");
+  }
+  const yamlText = match[1] ?? "";
+  const body = (match[2] ?? "").replace(/^\r?\n/, "");
+  const frontmatter = parseSimpleYaml(yamlText);
+  return { frontmatter, body };
+}
+function parseSimpleYaml(text) {
+  const result = {};
+  const lines = text.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    if (line.trim() === "" || line.trim().startsWith("#")) {
+      i++;
+      continue;
+    }
+    const m2 = /^([A-Za-z_][A-Za-z0-9_]*):\s*(.*)$/.exec(line);
+    if (!m2) {
+      i++;
+      continue;
+    }
+    const key = m2[1];
+    const rest = (m2[2] ?? "").trim();
+    if (rest !== "") {
+      result[key] = unquoteScalar(rest);
+      i++;
+      continue;
+    }
+    const nested = {};
+    i++;
+    while (i < lines.length) {
+      const nestedLine = lines[i] ?? "";
+      if (/^\s{2,}\S/.test(nestedLine) === false)
+        break;
+      const nm = /^\s{2,}([A-Za-z_][A-Za-z0-9_]*):\s*(.*)$/.exec(nestedLine);
+      if (!nm)
+        break;
+      nested[nm[1]] = unquoteScalar((nm[2] ?? "").trim());
+      i++;
+    }
+    result[key] = nested;
+  }
+  return result;
+}
+function unquoteScalar(s) {
+  if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+
+// ../../packages/shared/dist/profile-switch/doctor.js
 import fs8 from "fs";
-import path12 from "path";
 import os6 from "os";
+import path12 from "path";
+function readTextFile(filePath) {
+  try {
+    return fs8.readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+function readJsonFile(filePath) {
+  const raw2 = readTextFile(filePath);
+  if (raw2 === null)
+    return null;
+  try {
+    return JSON.parse(raw2);
+  } catch {
+    return null;
+  }
+}
+function readPluginVersion(pluginRoot) {
+  const manifest = readJsonFile(path12.join(pluginRoot, ".claude-plugin", "plugin.json"));
+  return typeof manifest?.version === "string" ? manifest.version : null;
+}
+function detectEnvOverride(env3) {
+  for (const name of ENV_OVERRIDE_VARS) {
+    const value = env3[name];
+    if (typeof value === "string" && value.trim()) {
+      return { name, value: value.trim() };
+    }
+  }
+  return null;
+}
+function readRoles(liveRoot, activeProfile) {
+  const agentsDir = path12.join(liveRoot, "agents");
+  let entries;
+  try {
+    entries = fs8.readdirSync(agentsDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const roles = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.startsWith("massa-ai-") || !entry.name.endsWith(".md")) {
+      continue;
+    }
+    const activeRaw = readTextFile(path12.join(agentsDir, entry.name));
+    let model = null;
+    let effort = null;
+    if (activeRaw !== null) {
+      try {
+        const { frontmatter } = parseFrontmatter(activeRaw);
+        model = typeof frontmatter.model === "string" ? frontmatter.model : null;
+        effort = typeof frontmatter.effort === "string" ? frontmatter.effort : null;
+      } catch {}
+    }
+    let staleVariant = false;
+    if (activeProfile && activeRaw !== null) {
+      const variantRaw = readTextFile(path12.join(liveRoot, "agent-profiles", activeProfile, entry.name));
+      if (variantRaw !== null) {
+        staleVariant = variantRaw !== activeRaw;
+      }
+    }
+    roles.push({ name: entry.name, model, effort, staleVariant });
+  }
+  return roles.sort((a12, b) => a12.name.localeCompare(b.name));
+}
+function runtimeDriftReport(opts = {}) {
+  const targetHome = opts.targetHome ?? os6.homedir();
+  const stateFilePath = opts.stateFilePath ?? path12.join(targetHome, ".config", "massa-ai", "install-state.json");
+  let state = opts.state ?? null;
+  if (state === null) {
+    try {
+      state = readInstallState(stateFilePath);
+    } catch {
+      state = null;
+    }
+  }
+  const platform = state?.platforms?.claude;
+  const stateVersion = typeof platform?.plugin?.version === "string" ? platform.plugin.version : null;
+  const activeProfile = platform?.modelProfile?.profile ?? null;
+  const install = resolveClaudeMarketplaceInstall({ targetHome, pluginKey: opts.pluginKey });
+  const liveRoot = install?.root ?? null;
+  const sourceVersion = liveRoot === null ? null : readPluginVersion(liveRoot);
+  const pinnedVersion = readInstalledPluginVersion({ targetHome, pluginKey: opts.pluginKey });
+  const roles = liveRoot === null ? [] : readRoles(liveRoot, activeProfile);
+  return {
+    host: "claude",
+    route: install?.route ?? "unresolved",
+    liveRoot,
+    sourceVersion,
+    stateVersion,
+    pinnedVersion,
+    activeProfile,
+    roles,
+    envOverride: detectEnvOverride(opts.env ?? process.env),
+    versionDrift: sourceVersion !== null && stateVersion !== null && sourceVersion !== stateVersion,
+    profileMaterialized: roles.some((role) => role.staleVariant)
+  };
+}
+var ENV_OVERRIDE_VARS;
+var init_doctor = __esm(() => {
+  init_claude_marketplace();
+  init_state();
+  ENV_OVERRIDE_VARS = ["CLAUDE_CODE_SUBAGENT_MODEL"];
+});
+
+// ../../packages/shared/dist/profile-switch/engine.js
+import fs9 from "fs";
+import path13 from "path";
+import os7 from "os";
 import crypto5 from "crypto";
 import { execFileSync as execFileSync2 } from "child_process";
 function namedError3(name, message) {
@@ -8357,10 +8560,10 @@ function namedError3(name, message) {
   return err;
 }
 function defaultStatePath(targetHome) {
-  return path12.join(targetHome, ".config", "massa-ai", "install-state.json");
+  return path13.join(targetHome, ".config", "massa-ai", "install-state.json");
 }
 function resolveCommon(opts) {
-  const targetHome = opts.targetHome ?? os6.homedir();
+  const targetHome = opts.targetHome ?? os7.homedir();
   const stateFilePath = opts.stateFilePath ?? defaultStatePath(targetHome);
   return { targetHome, stateFilePath };
 }
@@ -8368,7 +8571,7 @@ function marketplaceRoots(targetHome, state) {
   return state.platforms.claude?.installRoute === "marketplace" ? { claude: resolveClaudeMarketplaceRoot({ targetHome }) ?? undefined } : {};
 }
 function claudeMarketplaceUnresolvedReason(targetHome) {
-  const registryPath = path12.join(targetHome, ".claude", "plugins", "installed_plugins.json");
+  const registryPath = path13.join(targetHome, ".claude", "plugins", "installed_plugins.json");
   return `claude installRoute is "marketplace" but no install root could be resolved from ${registryPath} ` + "\u2014 re-run the Claude plugin installer, or verify the plugin registry file";
 }
 function listProfiles(opts = {}) {
@@ -8376,6 +8579,12 @@ function listProfiles(opts = {}) {
   const state = readInstallState(stateFilePath);
   const roots = marketplaceRoots(targetHome, state);
   const universe = opts.hosts ?? HOSTS;
+  const claudeDrift = universe.includes("claude") ? runtimeDriftReport({ targetHome, stateFilePath, state, env: opts.env }) : null;
+  const claudeDriftFields = (host) => host === "claude" && claudeDrift !== null ? {
+    liveRoot: claudeDrift.liveRoot,
+    sourceVersion: claudeDrift.sourceVersion,
+    envOverride: claudeDrift.envOverride ? `${claudeDrift.envOverride.name}=${claudeDrift.envOverride.value}` : null
+  } : { liveRoot: null, sourceVersion: null, envOverride: null };
   const hosts = universe.map((host) => {
     if (host === "claude" && state.platforms.claude?.installRoute === "marketplace" && roots.claude === undefined) {
       const platform2 = state.platforms.claude;
@@ -8386,7 +8595,8 @@ function listProfiles(opts = {}) {
         skipReason: null,
         activeProfile: platform2.modelProfile?.profile ?? opts.hostDefaults?.[host] ?? "balanced",
         bundleVersion: platform2.plugin?.version ?? null,
-        availableProfiles: []
+        availableProfiles: [],
+        ...claudeDriftFields(host)
       };
     }
     const layout = resolveHostLayout(host, { targetHome, projectRoot: opts.projectRoot, marketplaceRoot: roots });
@@ -8398,10 +8608,11 @@ function listProfiles(opts = {}) {
         skipReason: layout.reason,
         activeProfile: null,
         bundleVersion: null,
-        availableProfiles: []
+        availableProfiles: [],
+        ...claudeDriftFields(host)
       };
     }
-    const installed = fs8.existsSync(layout.activeDir);
+    const installed = fs9.existsSync(layout.activeDir);
     const availableProfiles = listVariantProfiles(layout);
     const platform = state.platforms[host];
     return {
@@ -8411,15 +8622,16 @@ function listProfiles(opts = {}) {
       skipReason: null,
       activeProfile: platform?.modelProfile?.profile ?? opts.hostDefaults?.[host] ?? "balanced",
       bundleVersion: platform?.plugin?.version ?? null,
-      availableProfiles
+      availableProfiles,
+      ...claudeDriftFields(host)
     };
   });
   return { hosts };
 }
 function listVariantProfiles(layout) {
-  if (!fs8.existsSync(layout.variantsRoot))
+  if (!fs9.existsSync(layout.variantsRoot))
     return [];
-  return fs8.readdirSync(layout.variantsRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  return fs9.readdirSync(layout.variantsRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
 }
 function matchesGlob(filename, glob) {
   const starIdx = glob.indexOf("*");
@@ -8430,7 +8642,7 @@ function matchesGlob(filename, glob) {
   return filename.length >= prefix.length + suffix.length && filename.startsWith(prefix) && filename.endsWith(suffix);
 }
 function matchingFileNames(dir, glob) {
-  return fs8.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && matchesGlob(e.name, glob)).map((e) => e.name);
+  return fs9.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && matchesGlob(e.name, glob)).map((e) => e.name);
 }
 function detectGitAvailability(dir) {
   try {
@@ -8456,7 +8668,7 @@ function gitTrackedFileNames(dir, filenames) {
   }
 }
 function checkTrackedPathGuard(activeDir, filenames) {
-  if (filenames.length === 0 || !fs8.existsSync(activeDir))
+  if (filenames.length === 0 || !fs9.existsSync(activeDir))
     return GUARD_PASS;
   const availability = detectGitAvailability(activeDir);
   if (availability === "no-git")
@@ -8467,53 +8679,53 @@ function checkTrackedPathGuard(activeDir, filenames) {
   if (tracked.size === 0)
     return GUARD_PASS;
   const offending = filenames.find((name) => tracked.has(name));
-  return { blocked: true, path: path12.join(activeDir, offending), unchecked: false };
+  return { blocked: true, path: path13.join(activeDir, offending), unchecked: false };
 }
 function assertStateWritable(stateFilePath) {
-  const dir = path12.dirname(stateFilePath);
+  const dir = path13.dirname(stateFilePath);
   try {
-    fs8.mkdirSync(dir, { recursive: true });
+    fs9.mkdirSync(dir, { recursive: true });
   } catch (err) {
     throw UnwritableInstallStateError(stateFilePath, err.message);
   }
-  const checkPath = fs8.existsSync(stateFilePath) ? stateFilePath : dir;
+  const checkPath = fs9.existsSync(stateFilePath) ? stateFilePath : dir;
   try {
-    fs8.accessSync(checkPath, fs8.constants.W_OK);
+    fs9.accessSync(checkPath, fs9.constants.W_OK);
   } catch (err) {
     throw UnwritableInstallStateError(stateFilePath, err.message);
   }
 }
 function copyFileRouteVariant(layout, variantDir) {
-  fs8.mkdirSync(layout.activeDir, { recursive: true });
+  fs9.mkdirSync(layout.activeDir, { recursive: true });
   let changed = 0;
-  for (const entry of fs8.readdirSync(variantDir, { withFileTypes: true })) {
+  for (const entry of fs9.readdirSync(variantDir, { withFileTypes: true })) {
     if (!entry.isFile() || !matchesGlob(entry.name, layout.activeGlob))
       continue;
-    fs8.copyFileSync(path12.join(variantDir, entry.name), path12.join(layout.activeDir, entry.name));
+    fs9.copyFileSync(path13.join(variantDir, entry.name), path13.join(layout.activeDir, entry.name));
     changed++;
   }
   return changed;
 }
 function repointOpencodeVariant(layout, variantDir) {
-  fs8.mkdirSync(layout.activeDir, { recursive: true });
+  fs9.mkdirSync(layout.activeDir, { recursive: true });
   let changed = 0;
-  for (const entry of fs8.readdirSync(variantDir, { withFileTypes: true })) {
+  for (const entry of fs9.readdirSync(variantDir, { withFileTypes: true })) {
     if (!entry.isFile() || !matchesGlob(entry.name, layout.activeGlob))
       continue;
-    const dest = path12.join(layout.activeDir, entry.name);
-    const target = path12.resolve(path12.join(variantDir, entry.name));
+    const dest = path13.join(layout.activeDir, entry.name);
+    const target = path13.resolve(path13.join(variantDir, entry.name));
     let destExists = true;
     let destIsSymlink = false;
     try {
-      destIsSymlink = fs8.lstatSync(dest).isSymbolicLink();
+      destIsSymlink = fs9.lstatSync(dest).isSymbolicLink();
     } catch {
       destExists = false;
     }
     if (destExists && !destIsSymlink)
       continue;
     const tmp = `${dest}.massa-ai-switch.${crypto5.randomUUID()}`;
-    fs8.symlinkSync(target, tmp);
-    fs8.renameSync(tmp, dest);
+    fs9.symlinkSync(target, tmp);
+    fs9.renameSync(tmp, dest);
     changed++;
   }
   return changed;
@@ -8553,13 +8765,13 @@ function switchProfile(opts) {
   if (fileHosts.length === 0) {
     return { profile: opts.profile, dryRun, hosts: orderRows(universe, skipRows), restartRequired: false };
   }
-  const installedFileHosts = fileHosts.filter((h) => fs8.existsSync(h.layout.activeDir));
+  const installedFileHosts = fileHosts.filter((h) => fs9.existsSync(h.layout.activeDir));
   if (installedFileHosts.length === 0)
     throw NoHostsDetectedError();
   const withAvailability = fileHosts.map((h) => {
-    const variantsRootExists = fs8.existsSync(h.layout.variantsRoot);
+    const variantsRootExists = fs9.existsSync(h.layout.variantsRoot);
     const variantDir = h.layout.variantDir(opts.profile);
-    const available = variantsRootExists && fs8.existsSync(variantDir) && fs8.statSync(variantDir).isDirectory();
+    const available = variantsRootExists && fs9.existsSync(variantDir) && fs9.statSync(variantDir).isDirectory();
     return { ...h, variantsRootExists, variantDir, available };
   });
   if (!withAvailability.some((h) => h.available)) {
@@ -8595,7 +8807,7 @@ function switchProfile(opts) {
         continue;
       }
       if (dryRun) {
-        rows.push({ host: h.host, status: "switched" });
+        rows.push({ host: h.host, status: "would-switch" });
         continue;
       }
       const candidateNames = matchingFileNames(h.variantDir, h.layout.activeGlob);
@@ -8640,6 +8852,7 @@ var init_engine = __esm(() => {
   init_state();
   init_lock();
   init_claude_marketplace();
+  init_doctor();
   SwitchEngineError = class SwitchEngineError extends Error {
     constructor(message) {
       super(message);
@@ -8652,29 +8865,29 @@ var init_engine = __esm(() => {
 
 // ../../packages/shared/dist/profile-switch/report.js
 function reportSucceeded(report) {
-  return report.hosts.every((h) => h.status === "switched" || h.status === "skipped");
+  return report.hosts.every((h) => h.status === "switched" || h.status === "would-switch" || h.status === "skipped");
 }
 
 // ../../packages/shared/dist/profile-switch/variant-sync.js
-import fs9 from "fs";
-import path13 from "path";
-import os7 from "os";
+import fs10 from "fs";
+import path14 from "path";
+import os8 from "os";
 import crypto6 from "crypto";
 function defaultStatePath2(targetHome) {
-  return path13.join(targetHome, ".config", "massa-ai", "install-state.json");
+  return path14.join(targetHome, ".config", "massa-ai", "install-state.json");
 }
 function marketplaceRoots2(targetHome, state) {
   return state.platforms.claude?.installRoute === "marketplace" ? { claude: resolveClaudeMarketplaceRoot({ targetHome }) ?? undefined } : {};
 }
 function writeFileIntoDirAtomically(destDir, destName, content) {
   const unique = `${process.pid}.${++tempFileCounter2}.${crypto6.randomBytes(6).toString("hex")}`;
-  const tempFile = path13.join(destDir, `.${destName}.${unique}.tmp`);
+  const tempFile = path14.join(destDir, `.${destName}.${unique}.tmp`);
   try {
-    fs9.writeFileSync(tempFile, content);
-    fs9.renameSync(tempFile, path13.join(destDir, destName));
+    fs10.writeFileSync(tempFile, content);
+    fs10.renameSync(tempFile, path14.join(destDir, destName));
   } catch (error) {
     try {
-      fs9.unlinkSync(tempFile);
+      fs10.unlinkSync(tempFile);
     } catch {}
     throw error;
   }
@@ -8682,20 +8895,20 @@ function writeFileIntoDirAtomically(destDir, destName, content) {
 function isSafeDirName(name) {
   if (name === "." || name === "..")
     return false;
-  if (name.includes("/") || name.includes("\\") || name.includes(path13.sep))
+  if (name.includes("/") || name.includes("\\") || name.includes(path14.sep))
     return false;
-  return path13.basename(name) === name;
+  return path14.basename(name) === name;
 }
 function syncHost(host, sourceRoot, targetHome, marketplaceRoot) {
   const layout = resolveHostLayout(host, { targetHome, marketplaceRoot });
   if (layout.route === "skip") {
     return { host, status: "skipped", profiles: [], retained: [], files: 0, reason: layout.reason };
   }
-  const srcDir = path13.join(sourceRoot, "apps", `${host}-plugin`, "agent-profiles");
-  if (!fs9.existsSync(srcDir) || !fs9.statSync(srcDir).isDirectory()) {
+  const srcDir = path14.join(sourceRoot, "apps", `${host}-plugin`, "agent-profiles");
+  if (!fs10.existsSync(srcDir) || !fs10.statSync(srcDir).isDirectory()) {
     return { host, status: "skipped", profiles: [], retained: [], files: 0, reason: "no generated variants for this host" };
   }
-  if (!fs9.existsSync(layout.variantsRoot)) {
+  if (!fs10.existsSync(layout.variantsRoot)) {
     return {
       host,
       status: "skipped",
@@ -8707,24 +8920,24 @@ function syncHost(host, sourceRoot, targetHome, marketplaceRoot) {
   }
   const profiles = [];
   let files = 0;
-  for (const entry of fs9.readdirSync(srcDir, { withFileTypes: true })) {
+  for (const entry of fs10.readdirSync(srcDir, { withFileTypes: true })) {
     if (!entry.isDirectory())
       continue;
     if (!isSafeDirName(entry.name))
       continue;
-    const srcProfileDir = path13.join(srcDir, entry.name);
-    const destProfileDir = path13.join(layout.variantsRoot, entry.name);
-    fs9.mkdirSync(destProfileDir, { recursive: true });
-    for (const fileEntry of fs9.readdirSync(srcProfileDir, { withFileTypes: true })) {
+    const srcProfileDir = path14.join(srcDir, entry.name);
+    const destProfileDir = path14.join(layout.variantsRoot, entry.name);
+    fs10.mkdirSync(destProfileDir, { recursive: true });
+    for (const fileEntry of fs10.readdirSync(srcProfileDir, { withFileTypes: true })) {
       if (!fileEntry.isFile())
         continue;
-      const content = fs9.readFileSync(path13.join(srcProfileDir, fileEntry.name));
+      const content = fs10.readFileSync(path14.join(srcProfileDir, fileEntry.name));
       writeFileIntoDirAtomically(destProfileDir, fileEntry.name, content);
       files++;
     }
     profiles.push(entry.name);
   }
-  const retained = fs9.readdirSync(layout.variantsRoot, { withFileTypes: true }).filter((e) => e.isDirectory() && !profiles.includes(e.name)).map((e) => e.name).sort();
+  const retained = fs10.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) {
@@ -8740,7 +8953,7 @@ function syncGeneratedVariants(opts) {
     }));
   }
   const sourceRoot = opts.sourceRoot;
-  const targetHome = opts.targetHome ?? os7.homedir();
+  const targetHome = opts.targetHome ?? os8.homedir();
   const state = readInstallState(defaultStatePath2(targetHome));
   const roots = marketplaceRoots2(targetHome, state);
   return hosts.map((host) => {
@@ -8759,14 +8972,14 @@ var init_variant_sync = __esm(() => {
 });
 
 // ../../packages/shared/dist/profile-switch/repo-root.js
-import fs10 from "fs";
-import path14 from "path";
+import fs11 from "fs";
+import path15 from "path";
 function findRepoRootWithMarker(startDir, marker, maxLevels) {
   let dir = startDir;
   for (let i = 0;i <= maxLevels; i++) {
-    if (fs10.existsSync(path14.join(dir, marker)))
+    if (fs11.existsSync(path15.join(dir, marker)))
       return dir;
-    const parent = path14.dirname(dir);
+    const parent = path15.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -10406,7 +10619,7 @@ var import_brace_expansion, minimatch = (p, pattern, options = {}) => {
 }, qmarksTestNoExtDot = ([$0]) => {
   const len = $0.length;
   return (f) => f.length === len && f !== "." && f !== "..";
-}, defaultPlatform, path15, sep, GLOBSTAR, qmark2 = "[^/]", star2, twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?", filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options), ext = (a12, b = {}) => Object.assign({}, a12, b), defaults = (def) => {
+}, defaultPlatform, path16, sep, GLOBSTAR, qmark2 = "[^/]", star2, twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?", filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options), ext = (a12, b = {}) => Object.assign({}, a12, b), defaults = (def) => {
   if (!def || typeof def !== "object" || !Object.keys(def).length) {
     return minimatch;
   }
@@ -10464,11 +10677,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";
-  path15 = {
+  path16 = {
     win32: { sep: "\\" },
     posix: { sep: "/" }
   };
-  sep = defaultPlatform === "win32" ? path15.win32.sep : path15.posix.sep;
+  sep = defaultPlatform === "win32" ? path16.win32.sep : path16.posix.sep;
   minimatch.sep = sep;
   GLOBSTAR = Symbol("globstar **");
   minimatch.GLOBSTAR = GLOBSTAR;
@@ -12434,12 +12647,12 @@ var init_esm4 = __esm(() => {
     childrenCache() {
       return this.#children;
     }
-    resolve(path16) {
-      if (!path16) {
+    resolve(path17) {
+      if (!path17) {
         return this;
       }
-      const rootPath = this.getRootString(path16);
-      const dir = path16.substring(rootPath.length);
+      const rootPath = this.getRootString(path17);
+      const dir = path17.substring(rootPath.length);
       const dirParts = dir.split(this.splitSep);
       const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
       return result;
@@ -12967,8 +13180,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(path16) {
-      return win32.parse(path16).root;
+    getRootString(path17) {
+      return win32.parse(path17).root;
     }
     getRoot(rootPath) {
       rootPath = uncToDrive(rootPath.toUpperCase());
@@ -12993,8 +13206,8 @@ var init_esm4 = __esm(() => {
     constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
       super(name, type, root, roots, nocase, children, opts);
     }
-    getRootString(path16) {
-      return path16.startsWith("/") ? "/" : "";
+    getRootString(path17) {
+      return path17.startsWith("/") ? "/" : "";
     }
     getRoot(_rootPath) {
       return this.root;
@@ -13013,8 +13226,8 @@ var init_esm4 = __esm(() => {
     #children;
     nocase;
     #fs;
-    constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs11 = defaultFS } = {}) {
-      this.#fs = fsFromOption(fs11);
+    constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs12 = defaultFS } = {}) {
+      this.#fs = fsFromOption(fs12);
       if (cwd instanceof URL || cwd.startsWith("file://")) {
         cwd = fileURLToPath(cwd);
       }
@@ -13050,11 +13263,11 @@ var init_esm4 = __esm(() => {
       }
       this.cwd = prev;
     }
-    depth(path16 = this.cwd) {
-      if (typeof path16 === "string") {
-        path16 = this.cwd.resolve(path16);
+    depth(path17 = this.cwd) {
+      if (typeof path17 === "string") {
+        path17 = this.cwd.resolve(path17);
       }
-      return path16.depth();
+      return path17.depth();
     }
     childrenCache() {
       return this.#children;
@@ -13470,9 +13683,9 @@ var init_esm4 = __esm(() => {
       process2();
       return results;
     }
-    chdir(path16 = this.cwd) {
+    chdir(path17 = this.cwd) {
       const oldCwd = this.cwd;
-      this.cwd = typeof path16 === "string" ? this.cwd.resolve(path16) : path16;
+      this.cwd = typeof path17 === "string" ? this.cwd.resolve(path17) : path17;
       this.cwd[setAsCwd](oldCwd);
     }
   };
@@ -13489,8 +13702,8 @@ var init_esm4 = __esm(() => {
     parseRootPath(dir) {
       return win32.parse(dir).root.toUpperCase();
     }
-    newRoot(fs11) {
-      return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs11 });
+    newRoot(fs12) {
+      return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs12 });
     }
     isAbsolute(p) {
       return p.startsWith("/") || p.startsWith("\\") || /^[a-z]:(\/|\\)/i.test(p);
@@ -13506,8 +13719,8 @@ var init_esm4 = __esm(() => {
     parseRootPath(_dir) {
       return "/";
     }
-    newRoot(fs11) {
-      return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs11 });
+    newRoot(fs12) {
+      return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs12 });
     }
     isAbsolute(p) {
       return p.startsWith("/");
@@ -13764,8 +13977,8 @@ class MatchRecord {
     this.store.set(target, current === undefined ? n2 : n2 & current);
   }
   entries() {
-    return [...this.store.entries()].map(([path16, n2]) => [
-      path16,
+    return [...this.store.entries()].map(([path17, n2]) => [
+      path17,
       !!(n2 & 2),
       !!(n2 & 1)
     ]);
@@ -13969,9 +14182,9 @@ class GlobUtil {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path16, opts) {
+  constructor(patterns, path17, opts) {
     this.patterns = patterns;
-    this.path = path16;
+    this.path = path17;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -13990,11 +14203,11 @@ class GlobUtil {
       });
     }
   }
-  #ignored(path16) {
-    return this.seen.has(path16) || !!this.#ignore?.ignored?.(path16);
+  #ignored(path17) {
+    return this.seen.has(path17) || !!this.#ignore?.ignored?.(path17);
   }
-  #childrenIgnored(path16) {
-    return !!this.#ignore?.childrenIgnored?.(path16);
+  #childrenIgnored(path17) {
+    return !!this.#ignore?.childrenIgnored?.(path17);
   }
   pause() {
     this.paused = true;
@@ -14211,8 +14424,8 @@ var init_walker = __esm(() => {
   init_processor();
   GlobWalker = class GlobWalker extends GlobUtil {
     matches = new Set;
-    constructor(patterns, path16, opts) {
-      super(patterns, path16, opts);
+    constructor(patterns, path17, opts) {
+      super(patterns, path17, opts);
     }
     matchEmit(e) {
       this.matches.add(e);
@@ -14249,8 +14462,8 @@ var init_walker = __esm(() => {
   };
   GlobStream = class GlobStream extends GlobUtil {
     results;
-    constructor(patterns, path16, opts) {
-      super(patterns, path16, opts);
+    constructor(patterns, path17, opts) {
+      super(patterns, path17, opts);
       this.results = new Minipass({
         signal: this.signal,
         objectMode: true
@@ -14678,20 +14891,20 @@ var require_ignore = __commonJS((exports, module) => {
   var throwError = (message, Ctor) => {
     throw new Ctor(message);
   };
-  var checkPath = (path16, originalPath, doThrow) => {
-    if (!isString(path16)) {
+  var checkPath = (path17, originalPath, doThrow) => {
+    if (!isString(path17)) {
       return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
     }
-    if (!path16) {
+    if (!path17) {
       return doThrow(`path must not be empty`, TypeError);
     }
-    if (checkPath.isNotRelative(path16)) {
+    if (checkPath.isNotRelative(path17)) {
       const r2 = "`path.relative()`d";
       return doThrow(`path should be a ${r2} string, but got "${originalPath}"`, RangeError);
     }
     return true;
   };
-  var isNotRelative = (path16) => REGEX_TEST_INVALID_PATH.test(path16);
+  var isNotRelative = (path17) => REGEX_TEST_INVALID_PATH.test(path17);
   checkPath.isNotRelative = isNotRelative;
   checkPath.convert = (p) => p;
 
@@ -14734,7 +14947,7 @@ var require_ignore = __commonJS((exports, module) => {
     addPattern(pattern) {
       return this.add(pattern);
     }
-    _testOne(path16, checkUnignored) {
+    _testOne(path17, checkUnignored) {
       let ignored = false;
       let unignored = false;
       this._rules.forEach((rule) => {
@@ -14742,7 +14955,7 @@ var require_ignore = __commonJS((exports, module) => {
         if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
           return;
         }
-        const matched = rule.regex.test(path16);
+        const matched = rule.regex.test(path17);
         if (matched) {
           ignored = !negative;
           unignored = negative;
@@ -14754,39 +14967,39 @@ var require_ignore = __commonJS((exports, module) => {
       };
     }
     _test(originalPath, cache, checkUnignored, slices) {
-      const path16 = originalPath && checkPath.convert(originalPath);
-      checkPath(path16, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
-      return this._t(path16, cache, checkUnignored, slices);
+      const path17 = originalPath && checkPath.convert(originalPath);
+      checkPath(path17, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
+      return this._t(path17, cache, checkUnignored, slices);
     }
-    _t(path16, cache, checkUnignored, slices) {
-      if (path16 in cache) {
-        return cache[path16];
+    _t(path17, cache, checkUnignored, slices) {
+      if (path17 in cache) {
+        return cache[path17];
       }
       if (!slices) {
-        slices = path16.split(SLASH);
+        slices = path17.split(SLASH);
       }
       slices.pop();
       if (!slices.length) {
-        return cache[path16] = this._testOne(path16, checkUnignored);
+        return cache[path17] = this._testOne(path17, checkUnignored);
       }
       const parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices);
-      return cache[path16] = parent.ignored ? parent : this._testOne(path16, checkUnignored);
+      return cache[path17] = parent.ignored ? parent : this._testOne(path17, checkUnignored);
     }
-    ignores(path16) {
-      return this._test(path16, this._ignoreCache, false).ignored;
+    ignores(path17) {
+      return this._test(path17, this._ignoreCache, false).ignored;
     }
     createFilter() {
-      return (path16) => !this.ignores(path16);
+      return (path17) => !this.ignores(path17);
     }
     filter(paths) {
       return makeArray(paths).filter(this.createFilter());
     }
-    test(path16) {
-      return this._test(path16, this._testCache, true);
+    test(path17) {
+      return this._test(path17, this._testCache, true);
     }
   }
   var factory = (options) => new Ignore2(options);
-  var isPathValid = (path16) => checkPath(path16 && checkPath.convert(path16), path16, RETURN_FALSE);
+  var isPathValid = (path17) => checkPath(path17 && checkPath.convert(path17), path17, RETURN_FALSE);
   factory.isPathValid = isPathValid;
   factory.default = factory;
   module.exports = factory;
@@ -14794,7 +15007,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 = (path16) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path16) || isNotRelative(path16);
+    checkPath.isNotRelative = (path17) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path17) || isNotRelative(path17);
   }
 });
 
@@ -14856,13 +15069,13 @@ function validatePolicy(policy, opts = {}) {
     }
   }
 }
-function matchesGlob2(path16, pattern) {
+function matchesGlob2(path17, pattern) {
   let re = regexCache.get(pattern);
   if (!re) {
     re = globToRegex(pattern);
     regexCache.set(pattern, re);
   }
-  return re.test(path16);
+  return re.test(path17);
 }
 var DEFAULT_POLICY, applyPolicy = (filePath, policy) => {
   const normalized = filePath.trim();
@@ -14879,8 +15092,8 @@ var init_capture_policy = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/ignore-patterns.js
-import fs11 from "fs/promises";
-import path16 from "path";
+import fs12 from "fs/promises";
+import path17 from "path";
 function buildExtensionGlob(extensions2) {
   return extensions2.map((ext2) => `**/*${ext2}`);
 }
@@ -14903,8 +15116,8 @@ async function loadProjectIgnore(projectPath) {
   const ig = ignore();
   ig.add(DEFAULT_IGNORES);
   try {
-    const gitignorePath = path16.join(projectPath, ".gitignore");
-    const gitignoreContent = await fs11.readFile(gitignorePath, "utf8");
+    const gitignorePath = path17.join(projectPath, ".gitignore");
+    const gitignoreContent = await fs12.readFile(gitignorePath, "utf8");
     const rules = gitignoreContent.split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
     ig.add(rules);
@@ -15158,8 +15371,8 @@ var init_alias_resolver = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/index-manager.js
-import fs12 from "fs";
-import path17 from "path";
+import fs13 from "fs";
+import path18 from "path";
 
 class IndexManager {
   metadataCache = new Map;
@@ -15252,9 +15465,9 @@ class IndexManager {
       const fileMetadata = {};
       let totalSize = 0;
       for (const filePath of indexedFiles) {
-        const fullPath = path17.join(projectPath, filePath);
+        const fullPath = path18.join(projectPath, filePath);
         try {
-          const stat2 = await fs12.promises.stat(fullPath);
+          const stat2 = await fs13.promises.stat(fullPath);
           fileMetadata[filePath] = {
             path: filePath,
             mtime: stat2.mtimeMs,
@@ -15305,9 +15518,9 @@ class IndexManager {
         if (ig.ignores(match2)) {
           continue;
         }
-        const fullPath = path17.join(projectPath, match2);
+        const fullPath = path18.join(projectPath, match2);
         try {
-          const stat2 = await fs12.promises.stat(fullPath);
+          const stat2 = await fs13.promises.stat(fullPath);
           files.set(match2, {
             path: match2,
             mtime: stat2.mtimeMs,
@@ -15758,10 +15971,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path18) {
-  if (!path18)
+function getElementAtPath(obj, path19) {
+  if (!path19)
     return obj;
-  return path18.reduce((acc, key) => acc?.[key], obj);
+  return path19.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -16089,11 +16302,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path18, issues) {
+function prefixIssues(path19, issues) {
   return issues.map((iss) => {
     var _a4;
     (_a4 = iss).path ?? (_a4.path = []);
-    iss.path.unshift(path18);
+    iss.path.unshift(path19);
     return iss;
   });
 }
@@ -16306,16 +16519,16 @@ function flattenError(error, mapper = (issue2) => issue2.message) {
 }
 function formatError(error, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error2, path18 = []) => {
+  const processError = (error2, path19 = []) => {
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path18, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path19, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else {
-        const fullpath = [...path18, ...issue2.path];
+        const fullpath = [...path19, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -16342,17 +16555,17 @@ function formatError(error, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error2, path18 = []) => {
+  const processError = (error2, path19 = []) => {
     var _a4, _b;
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path18, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path19, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else {
-        const fullpath = [...path18, ...issue2.path];
+        const fullpath = [...path19, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -16384,8 +16597,8 @@ function treeifyError(error, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path18 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path18) {
+  const path19 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path19) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -29388,13 +29601,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path18 = ref.slice(1).split("/").filter(Boolean);
-  if (path18.length === 0) {
+  const path19 = ref.slice(1).split("/").filter(Boolean);
+  if (path19.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path18[0] === defsKey) {
-    const key = path18[1];
+  if (path19[0] === defsKey) {
+    const key = path19[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -30883,8 +31096,8 @@ class ParseStatus2 {
   }
 }
 var makeIssue2 = (params) => {
-  const { data, path: path18, errorMaps, issueData } = params;
-  const fullPath = [...path18, ...issueData.path || []];
+  const { data, path: path19, errorMaps, issueData } = params;
+  const fullPath = [...path19, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -30929,11 +31142,11 @@ var init_errorUtil = __esm(() => {
 
 // ../../node_modules/zod/v3/types.js
 class ParseInputLazyPath2 {
-  constructor(parent, value, path18, key) {
+  constructor(parent, value, path19, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path18;
+    this._path = path19;
     this._key = key;
   }
   get path() {
@@ -36998,23 +37211,23 @@ var require_auth_config = __commonJS((exports, module) => {
     writeAuthConfig: () => writeAuthConfig
   });
   module.exports = __toCommonJS2(auth_config_exports);
-  var fs13 = __toESM2(__require("fs"));
-  var path18 = __toESM2(__require("path"));
+  var fs14 = __toESM2(__require("fs"));
+  var path19 = __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 path18.join(dataDir, "auth.json");
+    return path19.join(dataDir, "auth.json");
   }
   function readAuthConfig() {
     try {
       const authPath = getAuthConfigPath();
-      if (!fs13.existsSync(authPath)) {
+      if (!fs14.existsSync(authPath)) {
         return null;
       }
-      const content = fs13.readFileSync(authPath, "utf8");
+      const content = fs14.readFileSync(authPath, "utf8");
       if (!content) {
         return null;
       }
@@ -37025,11 +37238,11 @@ var require_auth_config = __commonJS((exports, module) => {
   }
   function writeAuthConfig(config3) {
     const authPath = getAuthConfigPath();
-    const authDir = path18.dirname(authPath);
-    if (!fs13.existsSync(authDir)) {
-      fs13.mkdirSync(authDir, { mode: 504, recursive: true });
+    const authDir = path19.dirname(authPath);
+    if (!fs14.existsSync(authDir)) {
+      fs14.mkdirSync(authDir, { mode: 504, recursive: true });
     }
-    fs13.writeFileSync(authPath, JSON.stringify(config3, null, 2), { mode: 384 });
+    fs14.writeFileSync(authPath, JSON.stringify(config3, null, 2), { mode: 384 });
   }
   function isValidAccessToken(authConfig, expirationBufferMs = 0) {
     if (!authConfig.token)
@@ -37204,8 +37417,8 @@ var require_token_util = __commonJS((exports, module) => {
     saveToken: () => saveToken
   });
   module.exports = __toCommonJS2(token_util_exports);
-  var path18 = __toESM2(__require("path"));
-  var fs13 = __toESM2(__require("fs"));
+  var path19 = __toESM2(__require("path"));
+  var fs14 = __toESM2(__require("fs"));
   var import_token_error = require_token_error();
   var import_token_io = require_token_io();
   var import_auth_config = require_auth_config();
@@ -37217,7 +37430,7 @@ var require_token_util = __commonJS((exports, module) => {
     if (!dataDir) {
       return null;
     }
-    return path18.join(dataDir, vercelFolder);
+    return path19.join(dataDir, vercelFolder);
   }
   async function getVercelToken2(options) {
     const authConfig = (0, import_auth_config.readAuthConfig)();
@@ -37285,11 +37498,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 = path18.join(dir, ".vercel", "project.json");
-    if (!fs13.existsSync(prjPath)) {
+    const prjPath = path19.join(dir, ".vercel", "project.json");
+    if (!fs14.existsSync(prjPath)) {
       throw new import_token_error.VercelOidcTokenError("project.json not found, have you linked your project with `vc link?`");
     }
-    const prj = JSON.parse(fs13.readFileSync(prjPath, "utf8"));
+    const prj = JSON.parse(fs14.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.");
     }
@@ -37300,11 +37513,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 = path18.join(dir, "com.vercel.token", `${projectId}.json`);
+    const tokenPath = path19.join(dir, "com.vercel.token", `${projectId}.json`);
     const tokenJson = JSON.stringify(token);
-    fs13.mkdirSync(path18.dirname(tokenPath), { mode: 504, recursive: true });
-    fs13.writeFileSync(tokenPath, tokenJson);
-    fs13.chmodSync(tokenPath, 432);
+    fs14.mkdirSync(path19.dirname(tokenPath), { mode: 504, recursive: true });
+    fs14.writeFileSync(tokenPath, tokenJson);
+    fs14.chmodSync(tokenPath, 432);
     return;
   }
   function loadToken(projectId) {
@@ -37312,11 +37525,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 = path18.join(dir, "com.vercel.token", `${projectId}.json`);
-    if (!fs13.existsSync(tokenPath)) {
+    const tokenPath = path19.join(dir, "com.vercel.token", `${projectId}.json`);
+    if (!fs14.existsSync(tokenPath)) {
       return null;
     }
-    const token = JSON.parse(fs13.readFileSync(tokenPath, "utf8"));
+    const token = JSON.parse(fs14.readFileSync(tokenPath, "utf8"));
     assertVercelOidcTokenResponse(token);
     return token;
   }
@@ -48158,37 +48371,37 @@ function createOpenAI(options = {}) {
   }, `ai-sdk/openai/${VERSION4}`);
   const createChatModel = (modelId) => new OpenAIChatLanguageModel(modelId, {
     provider: `${providerName}.chat`,
-    url: ({ path: path18 }) => `${baseURL}${path18}`,
+    url: ({ path: path19 }) => `${baseURL}${path19}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createCompletionModel = (modelId) => new OpenAICompletionLanguageModel(modelId, {
     provider: `${providerName}.completion`,
-    url: ({ path: path18 }) => `${baseURL}${path18}`,
+    url: ({ path: path19 }) => `${baseURL}${path19}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createEmbeddingModel = (modelId) => new OpenAIEmbeddingModel(modelId, {
     provider: `${providerName}.embedding`,
-    url: ({ path: path18 }) => `${baseURL}${path18}`,
+    url: ({ path: path19 }) => `${baseURL}${path19}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createImageModel = (modelId) => new OpenAIImageModel(modelId, {
     provider: `${providerName}.image`,
-    url: ({ path: path18 }) => `${baseURL}${path18}`,
+    url: ({ path: path19 }) => `${baseURL}${path19}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createTranscriptionModel = (modelId) => new OpenAITranscriptionModel(modelId, {
     provider: `${providerName}.transcription`,
-    url: ({ path: path18 }) => `${baseURL}${path18}`,
+    url: ({ path: path19 }) => `${baseURL}${path19}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createSpeechModel = (modelId) => new OpenAISpeechModel(modelId, {
     provider: `${providerName}.speech`,
-    url: ({ path: path18 }) => `${baseURL}${path18}`,
+    url: ({ path: path19 }) => `${baseURL}${path19}`,
     headers: getHeaders,
     fetch: options.fetch
   });
@@ -48201,7 +48414,7 @@ function createOpenAI(options = {}) {
   const createResponsesModel = (modelId) => {
     return new OpenAIResponsesLanguageModel(modelId, {
       provider: `${providerName}.responses`,
-      url: ({ path: path18 }) => `${baseURL}${path18}`,
+      url: ({ path: path19 }) => `${baseURL}${path19}`,
       headers: getHeaders,
       fetch: options.fetch,
       fileIdPrefixes: ["file-"]
@@ -64813,26 +65026,26 @@ var require_process = __commonJS((exports, module) => {
 
 // ../../node_modules/detect-libc/lib/filesystem.js
 var require_filesystem = __commonJS((exports, module) => {
-  var fs13 = __require("fs");
+  var fs14 = __require("fs");
   var LDD_PATH = "/usr/bin/ldd";
   var SELF_PATH = "/proc/self/exe";
   var MAX_LENGTH = 2048;
-  var readFileSync2 = (path18) => {
-    const fd = fs13.openSync(path18, "r");
+  var readFileSync2 = (path19) => {
+    const fd = fs14.openSync(path19, "r");
     const buffer = Buffer.alloc(MAX_LENGTH);
-    const bytesRead = fs13.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-    fs13.close(fd, () => {});
+    const bytesRead = fs14.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+    fs14.close(fd, () => {});
     return buffer.subarray(0, bytesRead);
   };
-  var readFile = (path18) => new Promise((resolve4, reject) => {
-    fs13.open(path18, "r", (err, fd) => {
+  var readFile = (path19) => new Promise((resolve4, reject) => {
+    fs14.open(path19, "r", (err, fd) => {
       if (err) {
         reject(err);
       } else {
         const buffer = Buffer.alloc(MAX_LENGTH);
-        fs13.read(fd, buffer, 0, MAX_LENGTH, 0, (_2, bytesRead) => {
+        fs14.read(fd, buffer, 0, MAX_LENGTH, 0, (_2, bytesRead) => {
           resolve4(buffer.subarray(0, bytesRead));
-          fs13.close(fd, () => {});
+          fs14.close(fd, () => {});
         });
       }
     });
@@ -64937,11 +65150,11 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     return null;
   };
-  var familyFromInterpreterPath = (path18) => {
-    if (path18) {
-      if (path18.includes("/ld-musl-")) {
+  var familyFromInterpreterPath = (path19) => {
+    if (path19) {
+      if (path19.includes("/ld-musl-")) {
         return MUSL;
-      } else if (path18.includes("/ld-linux-")) {
+      } else if (path19.includes("/ld-linux-")) {
         return GLIBC;
       }
     }
@@ -64986,8 +65199,8 @@ var require_detect_libc = __commonJS((exports, module) => {
     cachedFamilyInterpreter = null;
     try {
       const selfContent = await readFile(SELF_PATH);
-      const path18 = interpreterPath(selfContent);
-      cachedFamilyInterpreter = familyFromInterpreterPath(path18);
+      const path19 = interpreterPath(selfContent);
+      cachedFamilyInterpreter = familyFromInterpreterPath(path19);
     } catch (e) {}
     return cachedFamilyInterpreter;
   };
@@ -64998,8 +65211,8 @@ var require_detect_libc = __commonJS((exports, module) => {
     cachedFamilyInterpreter = null;
     try {
       const selfContent = readFileSync2(SELF_PATH);
-      const path18 = interpreterPath(selfContent);
-      cachedFamilyInterpreter = familyFromInterpreterPath(path18);
+      const path19 = interpreterPath(selfContent);
+      cachedFamilyInterpreter = familyFromInterpreterPath(path19);
     } catch (e) {}
     return cachedFamilyInterpreter;
   };
@@ -66661,18 +66874,18 @@ var require_sharp = __commonJS((exports, module) => {
     `@img/sharp-${runtimePlatform}/sharp.node`,
     "@img/sharp-wasm32/sharp.node"
   ];
-  var path18;
+  var path19;
   var sharp;
   var errors5 = [];
-  for (path18 of paths) {
+  for (path19 of paths) {
     try {
-      sharp = __require(path18);
+      sharp = __require(path19);
       break;
     } catch (err) {
       errors5.push(err);
     }
   }
-  if (sharp && path18.startsWith("@img/sharp-linux-x64") && !sharp._isUsingX64V2()) {
+  if (sharp && path19.startsWith("@img/sharp-linux-x64") && !sharp._isUsingX64V2()) {
     const err = new Error("Prebuilt binaries for linux-x64 require v2 microarchitecture");
     err.code = "Unsupported CPU";
     errors5.push(err);
@@ -66681,7 +66894,7 @@ var require_sharp = __commonJS((exports, module) => {
   if (sharp) {
     module.exports = sharp;
   } else {
-    const [isLinux, isMacOs, isWindows] = ["linux", "darwin", "win32"].map((os8) => runtimePlatform.startsWith(os8));
+    const [isLinux, isMacOs, isWindows] = ["linux", "darwin", "win32"].map((os9) => runtimePlatform.startsWith(os9));
     const help = [`Could not load the "sharp" module using the ${runtimePlatform} runtime`];
     errors5.forEach((err) => {
       if (err.code !== "MODULE_NOT_FOUND") {
@@ -66694,9 +66907,9 @@ var require_sharp = __commonJS((exports, module) => {
       const { found, expected } = isUnsupportedNodeRuntime();
       help.push("- Please upgrade Node.js:", `    Found ${found}`, `    Requires ${expected}`);
     } else if (prebuiltPlatforms.includes(runtimePlatform)) {
-      const [os8, cpu] = runtimePlatform.split("-");
-      const libc = os8.endsWith("musl") ? " --libc=musl" : "";
-      help.push("- Ensure optional dependencies can be installed:", "    npm install --include=optional sharp", "- Ensure your package manager supports multi-platform installation:", "    See https://sharp.pixelplumbing.com/install#cross-platform", "- Add platform-specific dependencies:", `    npm install --os=${os8.replace("musl", "")}${libc} --cpu=${cpu} sharp`);
+      const [os9, cpu] = runtimePlatform.split("-");
+      const libc = os9.endsWith("musl") ? " --libc=musl" : "";
+      help.push("- Ensure optional dependencies can be installed:", "    npm install --include=optional sharp", "- Ensure your package manager supports multi-platform installation:", "    See https://sharp.pixelplumbing.com/install#cross-platform", "- Add platform-specific dependencies:", `    npm install --os=${os9.replace("musl", "")}${libc} --cpu=${cpu} sharp`);
     } else {
       help.push(`- Manually install libvips >= ${minimumLibvipsVersion}`, "- Add experimental WebAssembly-based dependencies:", "    npm install --cpu=wasm32 sharp", "    npm install @img/sharp-wasm32");
     }
@@ -69534,15 +69747,15 @@ var require_color = __commonJS((exports, module) => {
     };
   }
   function wrapConversion(toModel, graph) {
-    const path18 = [graph[toModel].parent, toModel];
+    const path19 = [graph[toModel].parent, toModel];
     let fn = conversions_default[graph[toModel].parent][toModel];
     let cur = graph[toModel].parent;
     while (graph[cur].parent) {
-      path18.unshift(graph[cur].parent);
+      path19.unshift(graph[cur].parent);
       fn = link(conversions_default[graph[cur].parent][cur], fn);
       cur = graph[cur].parent;
     }
-    fn.conversion = path18;
+    fn.conversion = path19;
     return fn;
   }
   function route(fromModel) {
@@ -70147,7 +70360,7 @@ var require_output = __commonJS((exports, module) => {
     Copyright 2013 Lovell Fuller and others.
     SPDX-License-Identifier: Apache-2.0
   */
-  var path18 = __require("path");
+  var path19 = __require("path");
   var is = require_is();
   var sharp = require_sharp();
   var formats = new Map([
@@ -70178,9 +70391,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) && path18.resolve(this.options.input.file) === path18.resolve(fileOut)) {
+    } else if (is.string(this.options.input.file) && path19.resolve(this.options.input.file) === path19.resolve(fileOut)) {
       err = new Error("Cannot use same file for input and output");
-    } else if (jp2Regex.test(path18.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
+    } else if (jp2Regex.test(path19.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
       err = errJp2Save();
     }
     if (err) {
@@ -77427,11 +77640,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 path18 = `${baseName}_data${i === 0 ? "" : "_" + i}`;
-            const fullPath = `${options.subfolder ?? ""}/${path18}`;
+            const path19 = `${baseName}_data${i === 0 ? "" : "_" + i}`;
+            const fullPath = `${options.subfolder ?? ""}/${path19}`;
             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: path18, data } : path18);
+              resolve4(data instanceof Uint8Array ? { path: path19, data } : path19);
             }));
           }
         } else if (session_options.externalData !== undefined) {
@@ -90495,7 +90708,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(path18) {
+        async save(path19) {
           let fn;
           if (_env_js__WEBPACK_IMPORTED_MODULE_3__.apis.IS_BROWSER_ENV) {
             if (_env_js__WEBPACK_IMPORTED_MODULE_3__.apis.IS_WEBWORKER_ENV) {
@@ -90503,14 +90716,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 (path19, blob) => {
+            fn = async (path20, blob) => {
               let buffer = await blob.arrayBuffer();
-              node_fs__WEBPACK_IMPORTED_MODULE_5__["default"].writeFileSync(path19, Buffer.from(buffer));
+              node_fs__WEBPACK_IMPORTED_MODULE_5__["default"].writeFileSync(path20, Buffer.from(buffer));
             };
           } else {
             throw new Error("Unable to save because filesystem is disabled in this environment.");
           }
-          await fn(path18, this.toBlob());
+          await fn(path19, this.toBlob());
         }
       }
     },
@@ -90606,11 +90819,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(path18, blob) {
+      function saveBlob(path19, blob) {
         const dataURL = URL.createObjectURL(blob);
         const downloadLink = document.createElement("a");
         downloadLink.href = dataURL;
-        downloadLink.download = path18;
+        downloadLink.download = path19;
         downloadLink.click();
         downloadLink.remove();
         URL.revokeObjectURL(dataURL);
@@ -91211,8 +91424,8 @@ ${fake_token_around_image}` + `${global_img_token}` + image_token.repeat(image_s
       }
 
       class FileCache {
-        constructor(path18) {
-          this.path = path18;
+        constructor(path19) {
+          this.path = path19;
         }
         async match(request) {
           let filePath = node_path__WEBPACK_IMPORTED_MODULE_1__["default"].join(this.path, request);
@@ -91968,20 +92181,20 @@ ${fake_token_around_image}` + `${global_img_token}` + image_token.repeat(image_s
           }
           return this;
         }
-        async save(path18) {
+        async save(path19) {
           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 = path18.split(".").pop().toLowerCase();
+            const extension = path19.split(".").pop().toLowerCase();
             const mime2 = CONTENT_TYPE_MAP.get(extension) ?? "image/png";
             const blob = await this.toBlob(mime2);
-            (0, _core_js__WEBPACK_IMPORTED_MODULE_0__.saveBlob)(path18, blob);
+            (0, _core_js__WEBPACK_IMPORTED_MODULE_0__.saveBlob)(path19, 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(path18);
+            return await img.toFile(path19);
           }
         }
         toSharp() {
@@ -101210,7 +101423,7 @@ Note that ${s.bold("include")} statements only accept relation fields.`, a12;
   function ns(e = Yo, t2 = Yo) {
     return (r2) => e(t2(r2));
   }
-  function os8({ dataPath: e, modelName: t2, args: r2, runtimeDataModel: n2 }) {
+  function os9({ dataPath: e, modelName: t2, args: r2, runtimeDataModel: n2 }) {
     let i = { modelName: t2, args: r2 ?? {} }, o = dp(e);
     if (!o || o.length === 0)
       return i;
@@ -101515,10 +101728,10 @@ Note that ${s.bold("include")} statements only accept relation fields.`, a12;
       super(t2, "P2023", r2);
     }
   };
-  var fs13 = new WeakMap;
+  var fs14 = new WeakMap;
   function Ep(e) {
-    let t2 = fs13.get(e);
-    return t2 || (t2 = Object.entries(e), fs13.set(e, t2)), t2;
+    let t2 = fs14.get(e);
+    return t2 || (t2 = Object.entries(e), fs14.set(e, t2)), t2;
   }
   function hs(e, t2, r2) {
     switch (t2.type) {
@@ -105083,7 +105296,7 @@ new PrismaClient({
           let m2 = await es(this, d);
           if (!d.model)
             return m2;
-          let g = os8({ dataPath: d.dataPath, modelName: d.model, args: d.args, runtimeDataModel: this._runtimeDataModel });
+          let g = os9({ dataPath: d.dataPath, modelName: d.model, args: d.args, runtimeDataModel: this._runtimeDataModel });
           return Wo({ result: m2, modelName: g.modelName, args: g.args, extensions: this._extensions, runtimeDataModel: this._runtimeDataModel, globalOmit: this._globalOmit });
         };
         return this._tracingHelper.runInChildSpan(s.operation, () => new zl.AsyncResource("prisma-client-request").runInAsyncScope(() => a12(o)));
@@ -105486,7 +105699,7 @@ var require_prisma = __commonJS((exports) => {
   Prisma.JsonNull = JsonNull2;
   Prisma.AnyNull = AnyNull2;
   Prisma.NullTypes = NullTypes2;
-  var path18 = __require("path");
+  var path19 = __require("path");
   exports.Prisma.TransactionIsolationLevel = makeStrictEnum2({
     ReadUncommitted: "ReadUncommitted",
     ReadCommitted: "ReadCommitted",
@@ -115819,10 +116032,10 @@ var init_chunker_code = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/smart-chunker.js
-import path18 from "path";
+import path19 from "path";
 function smartChunk(content, filePath, config3 = {}) {
   const cfg = { ...DEFAULT_CONFIG, ...config3 };
-  const ext2 = path18.extname(filePath).toLowerCase();
+  const ext2 = path19.extname(filePath).toLowerCase();
   const relativePath = filePath;
   const fileImports = isCodeFile(ext2) ? extractFileImports(content, ext2) : undefined;
   let chunks;
@@ -116160,8 +116373,8 @@ var init_embedding_freshness = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/project-indexer.js
-import fs13 from "fs/promises";
-import path19 from "path";
+import fs14 from "fs/promises";
+import path20 from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 async function runWithIndexLock(lockMap, projectId, work) {
   const prevLock = lockMap.get(projectId);
@@ -116204,7 +116417,7 @@ async function indexProjectInternal(deps, projectPath, projectId, options = {})
       dot: false
     });
     const filteredFiles = files.filter((file3) => {
-      const relativePath = path19.relative(projectPath, file3);
+      const relativePath = path20.relative(projectPath, file3);
       const shouldIgnore = ig.ignores(relativePath);
       if (shouldIgnore) {
         logger.debug("Ignoring file per .gitignore during indexing", {
@@ -116244,7 +116457,7 @@ async function indexProjectInternal(deps, projectPath, projectId, options = {})
         });
       }
     }
-    const indexedFilesList = filteredFiles.map((f) => path19.relative(projectPath, f));
+    const indexedFilesList = filteredFiles.map((f) => path20.relative(projectPath, f));
     await deps.indexManager.updateIndexMetadata(projectId, projectPath, indexedFilesList);
     logger.info("Project indexing completed", {
       projectId,
@@ -116374,7 +116587,7 @@ async function ensureFreshIndex(deps, projectId, projectPath, options = {}) {
   let errors5 = 0;
   for (const relativeFilePath of filesToReindex) {
     try {
-      const fullPath = path19.join(projectPath, relativeFilePath);
+      const fullPath = path20.join(projectPath, relativeFilePath);
       const result = await deps.indexFile(fullPath, projectId, projectPath, centralityMap);
       filesIndexed++;
       chunksIndexed += result.chunks;
@@ -116434,8 +116647,8 @@ async function checkSearchAdmission(deps, projectId, projectPath) {
 }
 async function indexFile(deps, filePath, projectId, projectRoot, centralityMap) {
   projectId = await getProjectIdentityAliasResolver().resolve(projectId);
-  const content = await fs13.readFile(filePath, "utf-8");
-  const relativePath = path19.relative(projectRoot, filePath);
+  const content = await fs14.readFile(filePath, "utf-8");
+  const relativePath = path20.relative(projectRoot, filePath);
   const maxFileSize = config.get("security").maxFileSize || 1024 * 1024;
   if (content.length > maxFileSize) {
     logger.warn("File too large, skipping", {
@@ -116455,7 +116668,7 @@ async function indexFile(deps, filePath, projectId, projectRoot, centralityMap)
       chunkIndex: i,
       totalChunks: chunks.length,
       type: chunk.type,
-      language: path19.extname(filePath).slice(1),
+      language: path20.extname(filePath).slice(1),
       lineStart: chunk.lineStart,
       lineEnd: chunk.lineEnd,
       label: chunk.label,
@@ -118520,8 +118733,8 @@ function stripNul(content) {
 }
 
 // ../../packages/core/dist/services/etl/stages/discover.js
-import fs14 from "fs/promises";
-import path20 from "path";
+import fs15 from "fs/promises";
+import path21 from "path";
 import { createHash as createHash5 } from "crypto";
 
 class DiscoverStage {
@@ -118547,7 +118760,7 @@ class DiscoverStage {
         dot: false,
         absolute: false
       });
-      relPaths = found.map((p) => path20.isAbsolute(p) ? path20.relative(ctx.projectPath, p) : p).filter((p) => !ig.ignores(p) && applyPolicy(p, policy) !== "Drop");
+      relPaths = found.map((p) => path21.isAbsolute(p) ? path21.relative(ctx.projectPath, p) : p).filter((p) => !ig.ignores(p) && applyPolicy(p, policy) !== "Drop");
     }
     if (ctx.resumeCursor?.path) {
       const cursorPath = ctx.resumeCursor.path;
@@ -118606,10 +118819,10 @@ class DiscoverStage {
     return discovered;
   }
   async processFile(ctx, relativePath, forceReindex) {
-    const absolutePath = path20.join(ctx.projectPath, relativePath);
+    const absolutePath = path21.join(ctx.projectPath, relativePath);
     try {
-      const stat2 = await fs14.stat(absolutePath);
-      const content = stripNul(await fs14.readFile(absolutePath, "utf-8"));
+      const stat2 = await fs15.stat(absolutePath);
+      const content = stripNul(await fs15.readFile(absolutePath, "utf-8"));
       const contentHash = createHash5("sha256").update(content).digest("hex");
       let needsReparse = forceReindex;
       if (!forceReindex) {
@@ -118652,8 +118865,8 @@ class DiscoverStage {
       ig.add(pattern);
     }
     try {
-      const gitignorePath = path20.join(projectPath, ".gitignore");
-      const gitignoreContent = await fs14.readFile(gitignorePath, "utf8");
+      const gitignorePath = path21.join(projectPath, ".gitignore");
+      const gitignoreContent = await fs15.readFile(gitignorePath, "utf8");
       const rules = gitignoreContent.split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
       ig.add(rules);
@@ -120008,8 +120221,8 @@ function rustUseLeaves(node2, source, prefix = []) {
   }
   if (node2.type === "use_wildcard")
     return [{ path: [...prefix, "*"], glob: true }];
-  const path21 = rustPathSegments(node2, source);
-  return path21.length ? [{ path: [...prefix, ...path21] }] : [];
+  const path22 = rustPathSegments(node2, source);
+  return path22.length ? [{ path: [...prefix, ...path22] }] : [];
 }
 function functionalCaptures(captures, source, family) {
   if (family !== "clojure")
@@ -120981,8 +121194,8 @@ var init_structural_runtime = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/parse.js
-import path21 from "path";
-import fs15 from "fs/promises";
+import path22 from "path";
+import fs16 from "fs/promises";
 function resolveChunkerMaxChars() {
   const global2 = Number(process.env.EMBEDDING_MAX_CHARS);
   if (Number.isFinite(global2) && global2 > 0)
@@ -121010,8 +121223,8 @@ class ParseStage {
     const results = new Map;
     let processed = 0;
     const phases = [
-      files.filter((file3) => path21.extname(file3.relativePath).toLowerCase() !== ".h"),
-      files.filter((file3) => path21.extname(file3.relativePath).toLowerCase() === ".h")
+      files.filter((file3) => path22.extname(file3.relativePath).toLowerCase() !== ".h"),
+      files.filter((file3) => path22.extname(file3.relativePath).toLowerCase() === ".h")
     ];
     const batches = phases.flatMap((phase) => Array.from({ length: Math.ceil(phase.length / BATCH_SIZE) }, (_2, index) => phase.slice(index * BATCH_SIZE, (index + 1) * BATCH_SIZE)));
     for (const batch of batches) {
@@ -121049,19 +121262,19 @@ class ParseStage {
     return files.map((file3) => results.get(file3.relativePath));
   }
   recordHeaderImporterEvidence(ctx, files, parsedFiles) {
-    const knownHeaders = new Set(files.filter((file3) => path21.extname(file3.relativePath).toLowerCase() === ".h").map((file3) => path21.posix.normalize(file3.relativePath)));
+    const knownHeaders = new Set(files.filter((file3) => path22.extname(file3.relativePath).toLowerCase() === ".h").map((file3) => path22.posix.normalize(file3.relativePath)));
     const mutable = {
       ...ctx.structuralHeaderEvidenceByFile
     };
     for (const parsed of parsedFiles) {
-      const extension = path21.extname(parsed.file.relativePath).toLowerCase();
+      const extension = path22.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 = path21.posix.normalize(path21.posix.join(path21.posix.dirname(parsed.file.relativePath), imported.specifier));
+        const header = path22.posix.normalize(path22.posix.join(path22.posix.dirname(parsed.file.relativePath), imported.specifier));
         if (!knownHeaders.has(header))
           continue;
         const existing = mutable[header] ?? {};
@@ -121072,9 +121285,9 @@ class ParseStage {
   }
   async parseFile(ctx, file3) {
     if (!file3.needsReparse) {
-      const extension = path21.extname(file3.relativePath).toLowerCase();
+      const extension = path22.extname(file3.relativePath).toLowerCase();
       if ([".c", ".cpp", ".hpp"].includes(extension)) {
-        const content = file3.snapshotContent ?? await fs15.readFile(file3.absolutePath, "utf8");
+        const content = file3.snapshotContent ?? await fs16.readFile(file3.absolutePath, "utf8");
         const outcome = await this.runtime.parse({ extension, source: Buffer.from(content) });
         if (outcome.status === "failed")
           throw new StructuralEtlParseError(file3.relativePath, outcome.failureKind, `Structural evidence parse failed (${outcome.failureKind})`, outcome.diagnosticCount, outcome.diagnostics.slice(0, 10));
@@ -121086,8 +121299,8 @@ class ParseStage {
       return { file: file3, chunks: [], symbols: [], rawImports: [], rawEdges: [] };
     }
     try {
-      const content = file3.snapshotContent ?? await fs15.readFile(file3.absolutePath, "utf-8");
-      const ext2 = path21.extname(file3.relativePath).toLowerCase();
+      const content = file3.snapshotContent ?? await fs16.readFile(file3.absolutePath, "utf-8");
+      const ext2 = path22.extname(file3.relativePath).toLowerCase();
       const chunkerMaxChars = resolveChunkerMaxChars();
       const chunks = smartChunk(content, file3.relativePath, chunkerMaxChars ? { maxChunkChars: chunkerMaxChars } : {});
       let symbols;
@@ -121641,7 +121854,7 @@ var init_resolver = __esm(() => {
 });
 
 // ../../packages/core/dist/services/structural/resolvers/typescript.js
-import path22 from "path";
+import path23 from "path";
 function candidates(identities) {
   return Object.freeze(identities.map((identity) => Object.freeze({
     fqn: identity.fqn,
@@ -121736,7 +121949,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 = path22.posix.normalize(`${candidateBase}${suffix}`);
+      const value = path23.posix.normalize(`${candidateBase}${suffix}`);
       if (!value.startsWith("../") && value !== ".." && known.has(value))
         return value;
     }
@@ -121745,7 +121958,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(path22.posix.join(path22.posix.dirname(fromFile), specifier), known, dialect);
+    return probe(path23.posix.join(path23.posix.dirname(fromFile), specifier), known, dialect);
   }
   const aliases = build.pathAliasesByFile?.[normalizeStructuralFile(fromFile)] ?? build.pathAliases ?? [];
   for (const alias of aliases) {
@@ -122009,7 +122222,7 @@ var init_scripting2 = __esm(() => {
 });
 
 // ../../packages/core/dist/services/structural/resolvers/systems.js
-import path23 from "path";
+import path24 from "path";
 var DIALECTS, SYSTEMS_LANGUAGE_RESOLVER;
 var init_systems2 = __esm(() => {
   init_typescript2();
@@ -122028,7 +122241,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 = file3.file.startsWith("src/") ? "src" : "";
-            return { ...item, bindings, specifier: `./${path23.posix.relative(path23.posix.dirname(file3.file), path23.posix.join(crateRoot, item.specifier.replace(/^crate\/?/u, "")))}` };
+            return { ...item, bindings, specifier: `./${path24.posix.relative(path24.posix.dirname(file3.file), path24.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, "")}` };
@@ -122126,8 +122339,8 @@ var init_data_document2 = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/resolve.js
-import path24 from "path";
-import fs16 from "fs";
+import path25 from "path";
+import fs17 from "fs";
 
 class ResolveStage {
   symbolRepository;
@@ -122151,7 +122364,7 @@ class ResolveStage {
     const structuralDocuments = files.flatMap((file3) => {
       if (!file3.structure)
         return [];
-      const language = resolveStructuralLanguage(path24.extname(file3.file.relativePath));
+      const language = resolveStructuralLanguage(path25.extname(file3.file.relativePath));
       if (language.status !== "supported")
         throw new Error(`structural_manifest_missing:${file3.file.relativePath}`);
       return [{
@@ -122163,13 +122376,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(path24.extname(item.file.relativePath).toLowerCase())).map((item) => item.file.relativePath));
+    const skippedStructuralFiles = new Set(files.filter((item) => !item.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path25.extname(item.file.relativePath).toLowerCase())).map((item) => item.file.relativePath));
     const pathAliasesByFile = Object.fromEntries([...knownRelPaths].map((file3) => [
       file3,
       this.structuralAliasesFor(file3, rootAliases, monorepoPackages)
     ]));
     const buildMetadata = { knownFiles: [...knownRelPaths], pathAliasesByFile };
-    const seedRows = repositoryDefinitions.filter((definition) => STRUCTURAL_SEED_EXTENSIONS.has(path24.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(path25.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))
@@ -122262,7 +122475,7 @@ class ResolveStage {
     if (parsed.file !== definition.file_path) {
       throw new Error(`structural_repository_seed_file_mismatch:${definition.id}`);
     }
-    const language = resolveStructuralLanguage(path24.extname(definition.file_path));
+    const language = resolveStructuralLanguage(path25.extname(definition.file_path));
     if (language.status !== "supported")
       throw new Error(`structural_repository_seed_language:${definition.id}`);
     let identity;
@@ -122314,7 +122527,7 @@ class ResolveStage {
     });
   }
   resolveFile(parsed, projectPath, knownRelPaths, rootAliases, monorepoPackages, symbolIndex, knownFqns) {
-    const fromDir = path24.dirname(path24.join(projectPath, parsed.file.relativePath));
+    const fromDir = path25.dirname(path25.join(projectPath, parsed.file.relativePath));
     const packageAliases = this.getPackageAliases(parsed.file.relativePath, monorepoPackages);
     const allAliases = [...packageAliases, ...rootAliases];
     const resolvedImports = parsed.rawImports.map((raw2) => {
@@ -122385,7 +122598,7 @@ class ResolveStage {
         index.set(def.name, `${def.file_path}#${def.name}`);
       }
     } catch (err) {
-      const skippedStructural = files.some((file3) => !file3.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path24.extname(file3.file.relativePath).toLowerCase()));
+      const skippedStructural = files.some((file3) => !file3.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path25.extname(file3.file.relativePath).toLowerCase()));
       if (skippedStructural)
         throw new Error("structural_repository_seed_failed", { cause: err });
       logger.warn("buildSymbolIndex: repo seed failed, in-batch only", {
@@ -122409,7 +122622,7 @@ class ResolveStage {
   }
   resolveSpecifier(specifier, fromDir, projectPath, knownRelPaths, aliases) {
     if (specifier.startsWith("./") || specifier.startsWith("../")) {
-      const resolved = this.probeExtensions(path24.resolve(fromDir, specifier), projectPath, knownRelPaths);
+      const resolved = this.probeExtensions(path25.resolve(fromDir, specifier), projectPath, knownRelPaths);
       return { resolvedPath: resolved, external: false };
     }
     for (const alias of aliases) {
@@ -122417,8 +122630,8 @@ class ResolveStage {
         const suffix = specifier.slice(alias.prefix.length);
         for (const target of alias.targets) {
           const cleanTarget = target.replace(/\/\*$/, "");
-          const basePath = alias.packagePath ? path24.join(projectPath, alias.packagePath) : projectPath;
-          const absPath = path24.join(basePath, cleanTarget + suffix);
+          const basePath = alias.packagePath ? path25.join(projectPath, alias.packagePath) : projectPath;
+          const absPath = path25.join(basePath, cleanTarget + suffix);
           const resolved = this.probeExtensions(absPath, projectPath, knownRelPaths);
           if (resolved)
             return { resolvedPath: resolved, external: false };
@@ -122434,7 +122647,7 @@ class ResolveStage {
       ...TS_EXTENSIONS.map((ext2) => absPath.replace(/\.[^.]+$/, ext2))
     ];
     for (const candidate2 of candidates2) {
-      const rel = path24.relative(projectPath, candidate2).replace(/\\/g, "/");
+      const rel = path25.relative(projectPath, candidate2).replace(/\\/g, "/");
       if (knownRelPaths.has(rel))
         return rel;
     }
@@ -122442,9 +122655,9 @@ class ResolveStage {
   }
   loadTsConfigPaths(projectPath, packageBase) {
     const aliases = [];
-    const tsconfigPath = path24.join(projectPath, "tsconfig.json");
+    const tsconfigPath = path25.join(projectPath, "tsconfig.json");
     try {
-      const raw2 = fs16.readFileSync(tsconfigPath, "utf-8");
+      const raw2 = fs17.readFileSync(tsconfigPath, "utf-8");
       const stripped = raw2.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
       const tsconfig = JSON.parse(stripped);
       const paths = tsconfig?.compilerOptions?.paths ?? {};
@@ -122473,7 +122686,7 @@ class ResolveStage {
       }
     }
     for (const packageRelPath of packagePaths) {
-      const absPackagePath = path24.join(projectPath, packageRelPath);
+      const absPackagePath = path25.join(projectPath, packageRelPath);
       const aliases = this.loadTsConfigPaths(absPackagePath, packageRelPath);
       if (aliases.length > 0) {
         packages.push({
@@ -122503,7 +122716,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 ? path24.posix.join(alias.packagePath, target) : target)
+      targets: alias.targets.map((target) => alias.packagePath ? path25.posix.join(alias.packagePath, target) : target)
     }));
   }
 }
@@ -122567,7 +122780,7 @@ var init_with_deadlock_retry = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/load.js
-import path25 from "path";
+import path26 from "path";
 function formatDuration(ms) {
   const totalSec = Math.max(0, Math.round(ms / 1000));
   if (totalSec < 60)
@@ -122844,7 +123057,7 @@ class LoadStage {
     const filePath = file3.file.relativePath;
     const batch = buildSymbolPersistenceBatch(ctx.projectId, file3);
     if (ctx.graphGenerationLease) {
-      const manifest = getLanguageManifestEntry(path25.extname(filePath));
+      const manifest = getLanguageManifestEntry(path26.extname(filePath));
       const diagnostics2 = (file3.structuralDiagnostics ?? []).slice(0, 10).map((diagnostic2) => ({
         code: diagnostic2.code,
         severity: diagnostic2.severity,
@@ -123301,9 +123514,9 @@ var init_graph_generation_coordinator = __esm(() => {
 // ../../packages/core/dist/services/etl/pipeline.js
 import { createHash as createHash7 } from "crypto";
 import { setTimeout as delay2 } from "timers/promises";
-import path26 from "path";
+import path27 from "path";
 function buildHeaderLanguageEvidence(files) {
-  const headers = new Set(files.filter((file3) => path26.posix.extname(file3.relativePath).toLowerCase() === ".h").map((file3) => path26.posix.normalize(file3.relativePath)));
+  const headers = new Set(files.filter((file3) => path27.posix.extname(file3.relativePath).toLowerCase() === ".h").map((file3) => path27.posix.normalize(file3.relativePath)));
   const mutable = new Map;
   const entry2 = (header) => {
     let value = mutable.get(header);
@@ -123314,7 +123527,7 @@ function buildHeaderLanguageEvidence(files) {
     return value;
   };
   for (const file3 of files) {
-    if (path26.posix.basename(file3.relativePath) !== "compile_commands.json" || file3.snapshotContent === undefined)
+    if (path27.posix.basename(file3.relativePath) !== "compile_commands.json" || file3.snapshotContent === undefined)
       continue;
     let commands;
     try {
@@ -123330,11 +123543,11 @@ function buildHeaderLanguageEvidence(files) {
       const record2 = command;
       if (typeof record2.file !== "string")
         continue;
-      const projectRoot = path26.resolve(file3.absolutePath, ...file3.relativePath.split("/").map(() => ".."));
-      const commandDirectory = typeof record2.directory === "string" ? path26.resolve(projectRoot, record2.directory) : projectRoot;
-      const absoluteInput = path26.resolve(commandDirectory, record2.file);
-      const relative2 = path26.relative(projectRoot, absoluteInput);
-      const header = path26.posix.normalize(relative2.replaceAll(path26.sep, "/"));
+      const projectRoot = path27.resolve(file3.absolutePath, ...file3.relativePath.split("/").map(() => ".."));
+      const commandDirectory = typeof record2.directory === "string" ? path27.resolve(projectRoot, record2.directory) : projectRoot;
+      const absoluteInput = path27.resolve(commandDirectory, record2.file);
+      const relative2 = path27.relative(projectRoot, absoluteInput);
+      const header = path27.posix.normalize(relative2.replaceAll(path27.sep, "/"));
       if (!headers.has(header))
         continue;
       const invocation = typeof record2.command === "string" ? record2.command : Array.isArray(record2.arguments) ? record2.arguments.join(" ") : "";
@@ -124509,16 +124722,16 @@ function detectRoutes(httpEdges, defs, opts = {}) {
   const seen = new Set;
   const out = [];
   for (const e of httpEdges) {
-    const path28 = e.route;
-    if (!path28)
+    const path29 = e.route;
+    if (!path29)
       continue;
     const method = (e.method ?? "ANY").toUpperCase();
-    const key = method + " " + path28;
+    const key = method + " " + path29;
     if (seen.has(key))
       continue;
     seen.add(key);
     out.push({
-      path: path28,
+      path: path29,
       method: e.method,
       file: e.fromFile,
       handler: e.targetFqn ?? e.symbolName
@@ -124529,12 +124742,12 @@ function detectRoutes(httpEdges, defs, opts = {}) {
       continue;
     const parsed = parseRouteName(d.name);
     const method = parsed?.method ?? "ANY";
-    const path28 = parsed?.path ?? d.name;
-    const key = method + " " + path28;
+    const path29 = parsed?.path ?? d.name;
+    const key = method + " " + path29;
     if (seen.has(key))
       continue;
     seen.add(key);
-    out.push({ path: path28, method: parsed?.method, file: d.filePath, handler: d.name });
+    out.push({ path: path29, method: parsed?.method, file: d.filePath, handler: d.name });
   }
   for (const d of defs) {
     const parsed = parseRouteName(d.name);
@@ -124755,8 +124968,8 @@ __export(exports_symbol_graph_service, {
   symbolGraphService: () => symbolGraphService,
   SymbolGraphService: () => SymbolGraphService
 });
-import path28 from "path";
-import fs17 from "fs/promises";
+import path29 from "path";
+import fs18 from "fs/promises";
 
 class SymbolGraphService {
   identityLookup;
@@ -125084,7 +125297,7 @@ class SymbolGraphService {
   async readSnippet(relativePath, lineStart, lineEnd, projectId) {
     try {
       const absolutePath = await this.resolveToAbsolute(relativePath, projectId);
-      const content = await fs17.readFile(absolutePath, "utf-8");
+      const content = await fs18.readFile(absolutePath, "utf-8");
       const lines = content.split(`
 `);
       return lines.slice(Math.max(0, lineStart - 1), Math.min(lines.length, lineEnd)).join(`
@@ -125096,7 +125309,7 @@ class SymbolGraphService {
   async readContext(relativePath, lineNumber, contextLines, projectId) {
     try {
       const absolutePath = await this.resolveToAbsolute(relativePath, projectId);
-      const content = await fs17.readFile(absolutePath, "utf-8");
+      const content = await fs18.readFile(absolutePath, "utf-8");
       const lines = content.split(`
 `);
       const start = Math.max(0, lineNumber - contextLines - 1);
@@ -125109,7 +125322,7 @@ class SymbolGraphService {
   }
   async resolveToAbsolute(relativePath, projectId) {
     const root = await this.getProjectRoot(projectId);
-    return root ? path28.resolve(root, relativePath) : relativePath;
+    return root ? path29.resolve(root, relativePath) : relativePath;
   }
   async getProjectRoot(projectId) {
     const cached2 = this.projectRootCache.get(projectId);
@@ -128211,6 +128424,7 @@ class PgObservationStore {
   mirror = new Map;
   hydrated = false;
   hydrating = null;
+  inflight = new Map;
   hydrateFailedAt = 0;
   static HYDRATE_RETRY_MS = 30000;
   getClient() {
@@ -128262,46 +128476,53 @@ class PgObservationStore {
     const cachedCanonical = getProjectIdentityAliasResolver().resolveCached(obs.projectId);
     this.mirror.set(obs.id, cachedCanonical && cachedCanonical !== obs.projectId ? { ...obs, projectId: cachedCanonical } : obs);
     this.ensureHydrated();
-    (async () => {
-      try {
-        const prisma2 = this.getClient();
-        const canonicalProjectId = await getProjectIdentityAliasResolver().resolve(obs.projectId);
-        if (canonicalProjectId !== obs.projectId) {
-          this.mirror.set(obs.id, { ...obs, projectId: canonicalProjectId });
-        }
-        await prisma2.$executeRaw`
-          INSERT INTO observations (
-            id, project_id, session_id, source, category, payload_json, importance, created_at, agent_id, attribution_source
-          ) VALUES (
-            ${obs.id},
-            ${canonicalProjectId},
-            ${obs.sessionId},
-            ${obs.source},
-            ${obs.category ?? null},
-            ${obs.payloadJson},
-            ${obs.importance},
-            ${obs.createdAt}::bigint,
-            ${obs.agentId ?? null},
-            ${obs.attributionSource ?? null}
-          )
-          ON CONFLICT (id) DO UPDATE SET
-            project_id       = EXCLUDED.project_id,
-            session_id       = EXCLUDED.session_id,
-            source           = EXCLUDED.source,
-            category         = EXCLUDED.category,
-            payload_json     = EXCLUDED.payload_json,
-            importance       = EXCLUDED.importance,
-            created_at       = EXCLUDED.created_at,
-            agent_id         = EXCLUDED.agent_id,
-            attribution_source = EXCLUDED.attribution_source
-        `;
-      } catch (e) {
-        logger.warn("PgObservationStore.insert failed (best-effort)", {
-          id: obs.id,
-          error: e.message
-        });
+    this.chainWrite(obs.id, async () => {
+      const prisma2 = this.getClient();
+      const canonicalProjectId = await getProjectIdentityAliasResolver().resolve(obs.projectId);
+      if (canonicalProjectId !== obs.projectId) {
+        this.mirror.set(obs.id, { ...obs, projectId: canonicalProjectId });
       }
-    })();
+      await prisma2.$executeRaw`
+        INSERT INTO observations (
+          id, project_id, session_id, source, category, payload_json, importance, created_at, agent_id, attribution_source
+        ) VALUES (
+          ${obs.id},
+          ${canonicalProjectId},
+          ${obs.sessionId},
+          ${obs.source},
+          ${obs.category ?? null},
+          ${obs.payloadJson},
+          ${obs.importance},
+          ${obs.createdAt}::bigint,
+          ${obs.agentId ?? null},
+          ${obs.attributionSource ?? null}
+        )
+        ON CONFLICT (id) DO UPDATE SET
+          project_id       = EXCLUDED.project_id,
+          session_id       = EXCLUDED.session_id,
+          source           = EXCLUDED.source,
+          category         = EXCLUDED.category,
+          payload_json     = EXCLUDED.payload_json,
+          importance       = EXCLUDED.importance,
+          created_at       = EXCLUDED.created_at,
+          agent_id         = EXCLUDED.agent_id,
+          attribution_source = EXCLUDED.attribution_source
+      `;
+    });
+  }
+  chainWrite(key, fn) {
+    const prev = this.inflight.get(key) ?? Promise.resolve();
+    const next = prev.then(fn).catch((e) => {
+      logger.warn("PgObservationStore.insert failed (best-effort)", {
+        id: key,
+        error: e.message
+      });
+    });
+    this.inflight.set(key, next);
+    next.then(() => {
+      if (this.inflight.get(key) === next)
+        this.inflight.delete(key);
+    });
   }
   listRecent(projectId, limit) {
     this.ensureHydrated();
@@ -128328,6 +128549,9 @@ class PgObservationStore {
     await this.ensureHydrated();
   }
   async __drain() {
+    const pending = Array.from(this.inflight.values());
+    if (pending.length > 0)
+      await Promise.allSettled(pending);
     await new Promise((r2) => setTimeout(r2, 10));
   }
 }
@@ -129103,31 +129327,31 @@ class TracePathService {
     const chains = [];
     const seen = new Set;
     let walks = 0;
-    const walk = (fqn, path31) => {
+    const walk = (fqn, path32) => {
       if (chains.length >= CHAIN_CAP)
         return;
       if (walks >= MAX_WALKS)
         return;
       walks++;
-      const key = path31.join("\u2192");
+      const key = path32.join("\u2192");
       if (seen.has(key))
         return;
       seen.add(key);
       const next = adj.get(fqn);
       if (!next || next.length === 0 || !whoHasChild.has(fqn)) {
-        if (path31.length > 1)
-          chains.push(path31.map((n2) => this.fqnToName(n2)).join(" \u2192 "));
+        if (path32.length > 1)
+          chains.push(path32.map((n2) => this.fqnToName(n2)).join(" \u2192 "));
         return;
       }
       for (const child of next) {
         if (chains.length >= CHAIN_CAP || walks >= MAX_WALKS)
           return;
-        if (path31.includes(child)) {
-          const cycled = [...path31, `${this.fqnToName(child)}\u21BA`];
+        if (path32.includes(child)) {
+          const cycled = [...path32, `${this.fqnToName(child)}\u21BA`];
           chains.push(cycled.map((n2) => n2).join(" \u2192 "));
           continue;
         }
-        walk(child, [...path31, child]);
+        walk(child, [...path32, child]);
       }
     };
     for (const seed of seeds) {
@@ -132298,9 +132522,9 @@ var init_inference_probe = __esm(() => {
 });
 
 // ../../packages/core/dist/services/health/local-health-checker.js
-import fs20 from "fs/promises";
+import fs21 from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import path33 from "path";
+import path34 from "path";
 
 class LocalHealthChecker {
   dataDir = config.get("dataDir");
@@ -132378,10 +132602,10 @@ class LocalHealthChecker {
     const start = Date.now();
     try {
       if (!existsSync3(this.dataDir))
-        await fs20.mkdir(this.dataDir, { recursive: true });
-      const probe2 = path33.join(this.dataDir, ".health-check-test");
-      await fs20.writeFile(probe2, "ok");
-      await fs20.unlink(probe2);
+        await fs21.mkdir(this.dataDir, { recursive: true });
+      const probe2 = path34.join(this.dataDir, ".health-check-test");
+      await fs21.writeFile(probe2, "ok");
+      await fs21.unlink(probe2);
       return { available: true, latency: Date.now() - start, details: { path: this.dataDir, writable: true } };
     } catch (error51) {
       return { available: false, latency: Date.now() - start, error: `Data directory error: ${error51.message}` };
@@ -134451,9 +134675,9 @@ var init_scheduler2 = __esm(() => {
 });
 
 // ../../packages/core/dist/services/pricing/models-dev-client.js
-import fs21 from "fs/promises";
+import fs22 from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import path34 from "path";
+import path35 from "path";
 function getModelsDevClient() {
   if (!clientInstance) {
     clientInstance = new ModelsDevClient;
@@ -134473,7 +134697,7 @@ var init_models_dev_client = __esm(() => {
     memoryCacheTimestamp = 0;
     getLocalCachePath() {
       const dataDir = config.get("dataDir");
-      return path34.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
+      return path35.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
     }
     async loadLocalCache() {
       const cachePath = this.getLocalCachePath();
@@ -134481,7 +134705,7 @@ var init_models_dev_client = __esm(() => {
         if (!existsSync4(cachePath)) {
           return null;
         }
-        const content = await fs21.readFile(cachePath, "utf-8");
+        const content = await fs22.readFile(cachePath, "utf-8");
         const data = JSON.parse(content);
         const age = Date.now() - data.timestamp;
         if (age > ModelsDevClient.LOCAL_CACHE_TTL) {
@@ -134508,14 +134732,14 @@ var init_models_dev_client = __esm(() => {
     async saveLocalCache(models) {
       const cachePath = this.getLocalCachePath();
       try {
-        const dir = path34.dirname(cachePath);
-        await fs21.mkdir(dir, { recursive: true });
+        const dir = path35.dirname(cachePath);
+        await fs22.mkdir(dir, { recursive: true });
         const data = {
           timestamp: Date.now(),
           version: "1.0.0",
           models: Object.fromEntries(models)
         };
-        await fs21.writeFile(cachePath, JSON.stringify(data), "utf-8");
+        await fs22.writeFile(cachePath, JSON.stringify(data), "utf-8");
         logger.debug("Saved pricing to local cache", {
           models: models.size,
           path: cachePath
@@ -134844,7 +135068,7 @@ var init_models_dev_client = __esm(() => {
       const cachePath = this.getLocalCachePath();
       try {
         if (existsSync4(cachePath)) {
-          await fs21.unlink(cachePath);
+          await fs22.unlink(cachePath);
           logger.debug("Local pricing cache file deleted");
         }
       } catch (error51) {
@@ -140399,33 +140623,33 @@ var require_URL = __commonJS((exports, module) => {
         else
           return basepath.substring(0, lastslash + 1) + refpath;
       }
-      function remove_dot_segments(path35) {
-        if (!path35)
-          return path35;
+      function remove_dot_segments(path36) {
+        if (!path36)
+          return path36;
         var output = "";
-        while (path35.length > 0) {
-          if (path35 === "." || path35 === "..") {
-            path35 = "";
+        while (path36.length > 0) {
+          if (path36 === "." || path36 === "..") {
+            path36 = "";
             break;
           }
-          var twochars = path35.substring(0, 2);
-          var threechars = path35.substring(0, 3);
-          var fourchars = path35.substring(0, 4);
+          var twochars = path36.substring(0, 2);
+          var threechars = path36.substring(0, 3);
+          var fourchars = path36.substring(0, 4);
           if (threechars === "../") {
-            path35 = path35.substring(3);
+            path36 = path36.substring(3);
           } else if (twochars === "./") {
-            path35 = path35.substring(2);
+            path36 = path36.substring(2);
           } else if (threechars === "/./") {
-            path35 = "/" + path35.substring(3);
-          } else if (twochars === "/." && path35.length === 2) {
-            path35 = "/";
-          } else if (fourchars === "/../" || threechars === "/.." && path35.length === 3) {
-            path35 = "/" + path35.substring(4);
+            path36 = "/" + path36.substring(3);
+          } else if (twochars === "/." && path36.length === 2) {
+            path36 = "/";
+          } else if (fourchars === "/../" || threechars === "/.." && path36.length === 3) {
+            path36 = "/" + path36.substring(4);
             output = output.replace(/\/?[^\/]*$/, "");
           } else {
-            var segment = path35.match(/(\/?([^\/]*))/)[0];
+            var segment = path36.match(/(\/?([^\/]*))/)[0];
             output += segment;
-            path35 = path35.substring(segment.length);
+            path36 = path36.substring(segment.length);
           }
         }
         return output;
@@ -152495,21 +152719,21 @@ function jsonToKeyPathChunks(value, label = "$") {
   walk(value, label, out);
   return out;
 }
-function walk(val, path35, out) {
+function walk(val, path36, out) {
   if (val === null || val === undefined)
     return;
   if (Array.isArray(val)) {
     if (val.length === 0) {
-      out.push({ path: path35, content: `**${path35}** = _[]_` });
+      out.push({ path: path36, content: `**${path36}** = _[]_` });
       return;
     }
     if (val.every((v) => v !== null && typeof v === "object")) {
-      val.forEach((v, i) => walk(v, `${path35}[${i}]`, out));
+      val.forEach((v, i) => walk(v, `${path36}[${i}]`, out));
       return;
     }
     const items = val.map((v) => `- \`${String(v)}\``).join(`
 `);
-    out.push({ path: path35, content: `**${path35}**
+    out.push({ path: path36, content: `**${path36}**
 
 ${items}` });
     return;
@@ -152517,16 +152741,16 @@ ${items}` });
   if (typeof val === "object") {
     const entries = Object.entries(val);
     if (entries.length === 0) {
-      out.push({ path: path35, content: `**${path35}** = _{}_` });
+      out.push({ path: path36, content: `**${path36}** = _{}_` });
       return;
     }
     for (const [k2, v] of entries) {
       const safeKey = /^[A-Za-z_$][\w$]*$/.test(k2) ? k2 : JSON.stringify(k2);
-      walk(v, `${path35}.${safeKey}`, out);
+      walk(v, `${path36}.${safeKey}`, out);
     }
     return;
   }
-  out.push({ path: path35, content: `**${path35}** = \`${String(val)}\`` });
+  out.push({ path: path36, content: `**${path36}** = \`${String(val)}\`` });
 }
 var gfm, STRIP_SELECTORS, tdCache = null;
 var init_html_to_md = __esm(() => {
@@ -175517,9 +175741,9 @@ async function acquireIndexingLease(request) {
 
 // ../../packages/core/dist/services/project-identity/project-root-identity.js
 import { realpath as realpath2 } from "fs/promises";
-import path27 from "path";
+import path28 from "path";
 async function canonicalizeProjectRoot(projectPath, canonicalize = realpath2) {
-  return canonicalize(path27.resolve(projectPath));
+  return canonicalize(path28.resolve(projectPath));
 }
 async function assertProjectRootReuse(options) {
   if (!options.storedProjectPath || options.forceReindex)
@@ -175527,9 +175751,9 @@ async function assertProjectRootReuse(options) {
   const canonicalize = options.canonicalize ?? realpath2;
   let storedCanonical;
   try {
-    storedCanonical = await canonicalize(path27.resolve(options.storedProjectPath));
+    storedCanonical = await canonicalize(path28.resolve(options.storedProjectPath));
   } catch {
-    storedCanonical = path27.resolve(options.storedProjectPath);
+    storedCanonical = path28.resolve(options.storedProjectPath);
   }
   if (storedCanonical !== options.canonicalProjectPath) {
     throw new Error(`Project ID "${options.projectId}" already indexes canonical root ` + `"${storedCanonical}", not "${options.canonicalProjectPath}"; ` + "use forceReindex only after verifying ownership of the existing project");
@@ -175539,7 +175763,7 @@ async function assertProjectRootReuse(options) {
 // ../../packages/core/dist/tools/index_project.js
 init_workspace_manager();
 init_parser_readiness();
-import path29 from "path";
+import path30 from "path";
 
 class IndexProjectTool {
   name = "index_project";
@@ -175587,7 +175811,7 @@ class IndexProjectTool {
     try {
       await assertParserReadyForIndexing();
       const canonicalProjectPath = await canonicalizeProjectRoot(projectPath);
-      const finalProjectId = projectId || path29.basename(canonicalProjectPath) || "default";
+      const finalProjectId = projectId || path30.basename(canonicalProjectPath) || "default";
       const existing = await workspaceManager.getWorkspace(finalProjectId);
       await assertProjectRootReuse({
         projectId: finalProjectId,
@@ -176141,17 +176365,17 @@ function applyReplacer(root, replacer) {
     return transformChildren(root, replacer, []);
   return transformChildren(normalizeValue(replacedRoot), replacer, []);
 }
-function transformChildren(value, replacer, path30) {
+function transformChildren(value, replacer, path31) {
   if (isJsonObject(value))
-    return transformObject(value, replacer, path30);
+    return transformObject(value, replacer, path31);
   if (isJsonArray(value))
-    return transformArray(value, replacer, path30);
+    return transformArray(value, replacer, path31);
   return value;
 }
-function transformObject(obj, replacer, path30) {
+function transformObject(obj, replacer, path31) {
   const result = {};
   for (const [key, value] of Object.entries(obj)) {
-    const childPath = [...path30, key];
+    const childPath = [...path31, key];
     const replacedValue = replacer(key, value, childPath);
     if (replacedValue === undefined)
       continue;
@@ -176159,11 +176383,11 @@ function transformObject(obj, replacer, path30) {
   }
   return result;
 }
-function transformArray(arr, replacer, path30) {
+function transformArray(arr, replacer, path31) {
   const result = [];
   for (let i = 0;i < arr.length; i++) {
     const value = arr[i];
-    const childPath = [...path30, i];
+    const childPath = [...path31, i];
     const replacedValue = replacer(String(i), value, childPath);
     if (replacedValue === undefined)
       continue;
@@ -177544,9 +177768,9 @@ init_dist();
 init_db_connection();
 init_alias_resolver();
 init_safe_error_summary();
-import fs18 from "fs";
-import os8 from "os";
-import path30 from "path";
+import fs19 from "fs";
+import os9 from "os";
+import path31 from "path";
 
 // ../../packages/core/dist/services/hooks/session-pin-store.js
 var DEFAULT_MAX_SIZE = 1000;
@@ -177645,8 +177869,8 @@ class AttributionResolver {
     this.aliasResolver = options.aliasResolver ?? getProjectIdentityAliasResolver();
     this.pins = options.pins ?? new SessionPinStore;
     this.canonicalize = options.canonicalize ?? defaultCanonicalize;
-    this.homedir = options.homedir ?? os8.homedir;
-    this.fsRoot = options.fsRoot ?? (() => path30.parse(path30.sep).root);
+    this.homedir = options.homedir ?? os9.homedir;
+    this.fsRoot = options.fsRoot ?? (() => path31.parse(path31.sep).root);
   }
   async resolve(input) {
     const caller = input.callerProjectId;
@@ -177697,7 +177921,7 @@ class AttributionResolver {
     }
     let bestPath = null;
     for (const candidate2 of byPath.keys()) {
-      if (canonicalCwd === candidate2 || canonicalCwd.startsWith(candidate2.endsWith(path30.sep) ? candidate2 : candidate2 + path30.sep)) {
+      if (canonicalCwd === candidate2 || canonicalCwd.startsWith(candidate2.endsWith(path31.sep) ? candidate2 : candidate2 + path31.sep)) {
         if (bestPath === null || candidate2.length > bestPath.length) {
           bestPath = candidate2;
         }
@@ -177720,7 +177944,7 @@ class AttributionResolver {
       return projectPath2;
     const fsRoot = this.fsRoot();
     let normalized = projectPath2;
-    while (normalized.length > fsRoot.length && normalized.endsWith(path30.sep)) {
+    while (normalized.length > fsRoot.length && normalized.endsWith(path31.sep)) {
       normalized = normalized.slice(0, -1);
     }
     return normalized;
@@ -177728,10 +177952,10 @@ class AttributionResolver {
 }
 function defaultCanonicalize(cwd) {
   try {
-    return fs18.realpathSync(cwd);
+    return fs19.realpathSync(cwd);
   } catch {
     try {
-      return path30.resolve(cwd);
+      return path31.resolve(cwd);
     } catch {
       return;
     }
@@ -178268,7 +178492,7 @@ init_code_compressor();
 
 // ../../packages/core/dist/services/file-read/file-content-cache.js
 init_dist();
-import fs19 from "fs/promises";
+import fs20 from "fs/promises";
 
 class FileContentCache {
   extractMetadata;
@@ -178301,7 +178525,7 @@ class FileContentCache {
         metadata: cached2.metadata
       };
     }
-    const content = await fs19.readFile(filePath, "utf-8");
+    const content = await fs20.readFile(filePath, "utf-8");
     const metadata = await this.extractMetadata(content, filePath, options);
     evictOldest(this.fileCache, this.FILE_CACHE_MAX_ENTRIES - 1);
     this.fileCache.set(cacheKey, {
@@ -178316,7 +178540,7 @@ class FileContentCache {
 
 // ../../packages/core/dist/services/file-read/file-metadata.js
 init_dist();
-import path31 from "path";
+import path32 from "path";
 
 class FileMetadataExtractor {
   symbolGraph;
@@ -178352,7 +178576,7 @@ class FileMetadataExtractor {
     return metadata;
   }
   detectLanguage(filePath) {
-    const ext2 = path31.extname(filePath).toLowerCase();
+    const ext2 = path32.extname(filePath).toLowerCase();
     const languageMap2 = {
       ".ts": "TypeScript",
       ".tsx": "TypeScript",
@@ -178469,7 +178693,7 @@ function selectLines(lines, range) {
 
 // ../../packages/core/dist/services/file-read/path-containment.js
 init_dist();
-import path32 from "path";
+import path33 from "path";
 
 class PathContainment {
   projectRoots;
@@ -178477,14 +178701,14 @@ class PathContainment {
     this.projectRoots = projectRoots;
   }
   async resolveFilePath(filePath, projectId) {
-    if (path32.isAbsolute(filePath)) {
-      return path32.resolve(filePath);
+    if (path33.isAbsolute(filePath)) {
+      return path33.resolve(filePath);
     }
     if (projectId) {
       const root = await this.projectRoots.getProjectRoot(projectId);
       if (root) {
         const cleaned = sanitizeFilePath(filePath);
-        return path32.resolve(root, cleaned);
+        return path33.resolve(root, cleaned);
       }
       return null;
     }
@@ -178495,17 +178719,17 @@ class PathContainment {
     if (projectId) {
       const root = await this.projectRoots.getProjectRoot(projectId);
       if (root)
-        roots.push(path32.resolve(root));
+        roots.push(path33.resolve(root));
     }
-    roots.push(path32.resolve(process.cwd()));
+    roots.push(path33.resolve(process.cwd()));
     const envRoots = (process.env.MASSA_AI_READ_FILE_ROOTS ?? "").split(":").map((s) => s.trim()).filter((s) => s.length > 0);
     for (const extra of envRoots) {
-      roots.push(path32.resolve(extra));
+      roots.push(path33.resolve(extra));
     }
-    const target = path32.resolve(absoluteFilePath);
+    const target = path33.resolve(absoluteFilePath);
     for (const root of roots) {
-      const rel = path32.relative(root, target);
-      if (rel !== "" && !rel.startsWith("..") && !path32.isAbsolute(rel)) {
+      const rel = path33.relative(root, target);
+      if (rel !== "" && !rel.startsWith("..") && !path33.isAbsolute(rel)) {
         return { allowed: true };
       }
       if (rel === "")
@@ -179342,8 +179566,8 @@ init_event_bus();
 init_llm_client();
 init_symbol_graph_service();
 import { randomUUID as randomUUID9 } from "crypto";
-import fs22 from "fs";
-import path35 from "path";
+import fs23 from "fs";
+import path36 from "path";
 import { spawn as spawn2 } from "child_process";
 var FALLBACK_BOOTSTRAP = {
   enabled: true,
@@ -179527,9 +179751,9 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
   }
   try {
     for (const name26 of README_CANDIDATES) {
-      const p = path35.join(projectRoot, name26);
-      if (fs22.existsSync(p) && fs22.statSync(p).isFile()) {
-        const buf = fs22.readFileSync(p);
+      const p = path36.join(projectRoot, name26);
+      if (fs23.existsSync(p) && fs23.statSync(p).isFile()) {
+        const buf = fs23.readFileSync(p);
         signals.readme = buf.slice(0, MAX_README_BYTES).toString("utf8");
         break;
       }
@@ -179538,14 +179762,14 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
     logger.debug("bootstrap scan: README read failed", { error: e.message });
   }
   try {
-    const docsDir = path35.join(projectRoot, "docs");
-    if (fs22.existsSync(docsDir) && fs22.statSync(docsDir).isDirectory()) {
+    const docsDir = path36.join(projectRoot, "docs");
+    if (fs23.existsSync(docsDir) && fs23.statSync(docsDir).isDirectory()) {
       const entries = walkMarkdown(docsDir).slice(0, MAX_DOCS);
       for (const rel of entries) {
         try {
-          const buf = fs22.readFileSync(rel);
+          const buf = fs23.readFileSync(rel);
           signals.docs.push({
-            path: path35.relative(projectRoot, rel),
+            path: path36.relative(projectRoot, rel),
             snippet: buf.slice(0, MAX_DOC_BYTES).toString("utf8")
           });
         } catch {}
@@ -179556,10 +179780,10 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
   }
   try {
     for (const name26 of MANIFEST_FILES) {
-      const p = path35.join(projectRoot, name26);
-      if (!fs22.existsSync(p) || !fs22.statSync(p).isFile())
+      const p = path36.join(projectRoot, name26);
+      if (!fs23.existsSync(p) || !fs23.statSync(p).isFile())
         continue;
-      const raw2 = fs22.readFileSync(p).slice(0, MAX_MANIFEST_BYTES).toString("utf8");
+      const raw2 = fs23.readFileSync(p).slice(0, MAX_MANIFEST_BYTES).toString("utf8");
       const kind = name26;
       if (name26 === "package.json") {
         try {
@@ -179599,12 +179823,12 @@ function walkMarkdown(dir) {
     const cur = stack.pop();
     let entries;
     try {
-      entries = fs22.readdirSync(cur, { withFileTypes: true });
+      entries = fs23.readdirSync(cur, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const e of entries) {
-      const full = path35.join(cur, e.name);
+      const full = path36.join(cur, e.name);
       if (e.isDirectory()) {
         if (e.name === "node_modules" || e.name.startsWith("."))
           continue;
@@ -180765,8 +180989,8 @@ var checkpointRoutes = new Elysia({ prefix: "/api/v1/checkpoints" }).post("/list
 
 // src/routes/project.ts
 init_dist();
-import fs23 from "fs/promises";
-import path36 from "path";
+import fs24 from "fs/promises";
+import path37 from "path";
 function isDimensionMismatchError(error51) {
   const message = error51 instanceof Error ? error51.message : String(error51);
   return /dimension mismatch/i.test(message);
@@ -180986,22 +181210,22 @@ var projectRoutes = new Elysia({ prefix: "/api/v1/project" }).get("/list", async
 }).post("/upload-and-index", async ({ body }) => {
   const rawBase = body.projectId || body.projectPath.replace(/\\/g, "/").split("/").filter(Boolean).pop() || "default";
   const finalProjectId = rawBase.replace(/[^a-zA-Z0-9_.-]/g, "_").slice(0, 128);
-  const uploadRoot = process.env.MASSA_AI_UPLOAD_DIR || path36.join(getGlobalDataDir(), "uploads");
-  const stagingDir = path36.resolve(uploadRoot, finalProjectId);
-  await fs23.rm(stagingDir, { recursive: true, force: true });
-  await fs23.mkdir(stagingDir, { recursive: true });
+  const uploadRoot = process.env.MASSA_AI_UPLOAD_DIR || path37.join(getGlobalDataDir(), "uploads");
+  const stagingDir = path37.resolve(uploadRoot, finalProjectId);
+  await fs24.rm(stagingDir, { recursive: true, force: true });
+  await fs24.mkdir(stagingDir, { recursive: true });
   const WRITE_BATCH = 20;
   for (let i = 0;i < body.files.length; i += WRITE_BATCH) {
     await Promise.all(body.files.slice(i, i + WRITE_BATCH).map(async (file3) => {
-      if (path36.isAbsolute(file3.relativePath) || file3.relativePath.includes("..")) {
+      if (path37.isAbsolute(file3.relativePath) || file3.relativePath.includes("..")) {
         throw new Error(`Invalid file path: ${file3.relativePath}`);
       }
-      const dest = path36.resolve(stagingDir, file3.relativePath.replace(/\//g, path36.sep));
-      if (!dest.startsWith(stagingDir + path36.sep)) {
+      const dest = path37.resolve(stagingDir, file3.relativePath.replace(/\//g, path37.sep));
+      if (!dest.startsWith(stagingDir + path37.sep)) {
         throw new Error(`Path escapes staging directory: ${file3.relativePath}`);
       }
-      await fs23.mkdir(path36.dirname(dest), { recursive: true });
-      await fs23.writeFile(dest, file3.content, "utf-8");
+      await fs24.mkdir(path37.dirname(dest), { recursive: true });
+      await fs24.writeFile(dest, file3.content, "utf-8");
     }));
   }
   return await getIndexProjectTool().handle({
@@ -181157,9 +181381,9 @@ var analyticsRoutes = new Elysia({ prefix: "/api/v1/analytics" }).post("/", asyn
 init_dist();
 init_config();
 init_inference_providers();
-import path37 from "path";
-import fs24 from "fs";
-import os9 from "os";
+import path38 from "path";
+import fs25 from "fs";
+import os10 from "os";
 function resolveConfiguredOllamaEmbeddingModel() {
   return process.env.OLLAMA_EMBEDDING_MODEL || loadRawUserConfig().embedding?.model || INFERENCE_PROVIDERS.ollama.defaultModels.embedding;
 }
@@ -181193,13 +181417,13 @@ var systemRoutes = new Elysia({ prefix: "/api/v1/system" }).get("/info", async (
     version: "1.0.0",
     service: "massa-ai-tools-api",
     node: process.version,
-    platform: os9.platform(),
-    arch: os9.arch(),
+    platform: os10.platform(),
+    arch: os10.arch(),
     uptime: process.uptime(),
     memory: {
-      total: os9.totalmem(),
-      free: os9.freemem(),
-      used: os9.totalmem() - os9.freemem(),
+      total: os10.totalmem(),
+      free: os10.freemem(),
+      used: os10.totalmem() - os10.freemem(),
       process: process.memoryUsage()
     },
     dataDir: config.get("dataDir"),
@@ -181235,11 +181459,11 @@ var systemRoutes = new Elysia({ prefix: "/api/v1/system" }).get("/info", async (
     description: "Check PostgreSQL, pgvector, Ollama, and local artifact directory health"
   }
 }).get("/metrics", async () => {
-  const metricsPath = path37.join(process.cwd(), "data", "metrics.json");
+  const metricsPath = path38.join(process.cwd(), "data", "metrics.json");
   let metrics2 = {};
-  if (fs24.existsSync(metricsPath)) {
+  if (fs25.existsSync(metricsPath)) {
     try {
-      metrics2 = JSON.parse(fs24.readFileSync(metricsPath, "utf-8"));
+      metrics2 = JSON.parse(fs25.readFileSync(metricsPath, "utf-8"));
     } catch {}
   }
   const database = await getDatabaseInfo();
@@ -181433,8 +181657,8 @@ var eventsRoutes = new Elysia({ prefix: "/api/v1" }).get("/events", async ({ que
 });
 
 // src/routes/workspace.ts
-import fs25 from "fs/promises";
-import path38 from "path";
+import fs26 from "fs/promises";
+import path39 from "path";
 import { realpathSync as realpathSync4 } from "fs";
 var indexProjectTool2 = null;
 function getIndexProjectTool2() {
@@ -181476,7 +181700,7 @@ function realpathSafe(p) {
   try {
     return realpathSync4(p);
   } catch {
-    return path38.resolve(p);
+    return path39.resolve(p);
   }
 }
 var graphController = null;
@@ -181827,8 +182051,8 @@ var workspaceRoutes = new Elysia({ prefix: "/api/v1" }).get("/workspace/list", a
     }
     const registeredRoot = realpathSafe(workspace.project_path);
     const callerRoot = realpathSafe(projectPath2);
-    const rel = path38.relative(registeredRoot, callerRoot);
-    const escapes = rel.startsWith("..") || path38.isAbsolute(rel);
+    const rel = path39.relative(registeredRoot, callerRoot);
+    const escapes = rel.startsWith("..") || path39.isAbsolute(rel);
     if (registeredRoot !== callerRoot && escapes) {
       return {
         success: false,
@@ -181958,8 +182182,8 @@ var workspaceRoutes = new Elysia({ prefix: "/api/v1" }).get("/workspace/list", a
     } else {
       end = start + 20;
     }
-    const absolutePath = path38.join(workspace.project_path, file3);
-    const content = await fs25.readFile(absolutePath, "utf-8");
+    const absolutePath = path39.join(workspace.project_path, file3);
+    const content = await fs26.readFile(absolutePath, "utf-8");
     const lines = content.split(/\r?\n/);
     const slice = lines.slice(start - 1, Math.min(lines.length, end));
     const formatted = slice.map((text3, idx) => ({
@@ -183210,8 +183434,8 @@ var webRoutes = new Elysia({ prefix: "/api/v1/web" }).post("/fetch_and_index", a
 });
 
 // src/routes/web-ui.ts
-import fs26 from "fs/promises";
-import path39 from "path";
+import fs27 from "fs/promises";
+import path40 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/web-ui-trust.ts
@@ -183255,9 +183479,9 @@ function buildStaticDirCandidates(moduleDir, cwd) {
   for (const root2 of [moduleDir, cwd]) {
     let dir = root2;
     for (let i = 0;i < 10; i++) {
-      candidates2.push(path39.resolve(dir, "apps/web-ui/dist/static"));
-      candidates2.push(path39.resolve(dir, "web-ui/dist/static"));
-      const parent = path39.dirname(dir);
+      candidates2.push(path40.resolve(dir, "apps/web-ui/dist/static"));
+      candidates2.push(path40.resolve(dir, "web-ui/dist/static"));
+      const parent = path40.dirname(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -183265,11 +183489,11 @@ function buildStaticDirCandidates(moduleDir, cwd) {
   }
   return [...new Set(candidates2)];
 }
-var STATIC_DIR_CANDIDATES = buildStaticDirCandidates(path39.dirname(fileURLToPath3(import.meta.url)), process.cwd());
+var STATIC_DIR_CANDIDATES = buildStaticDirCandidates(path40.dirname(fileURLToPath3(import.meta.url)), process.cwd());
 async function resolveStaticDir() {
   for (const dir of STATIC_DIR_CANDIDATES) {
     try {
-      const st = await fs26.stat(dir);
+      const st = await fs27.stat(dir);
       if (st.isDirectory())
         return dir;
     } catch {}
@@ -183290,7 +183514,7 @@ var CONTENT_TYPES = {
   ".woff2": "font/woff2"
 };
 function contentTypeFor(filePath) {
-  const ext2 = path39.extname(filePath).toLowerCase();
+  const ext2 = path40.extname(filePath).toLowerCase();
   return CONTENT_TYPES[ext2] ?? "application/octet-stream";
 }
 function webUiDisabled() {
@@ -183301,13 +183525,13 @@ function webUiDisabled() {
 }
 async function resolveSafePath(staticDir, sub) {
   const cleaned = sub.replace(/^\/+/, "");
-  const abs = path39.resolve(staticDir, cleaned);
-  const rel = path39.relative(staticDir, abs);
-  if (rel.startsWith("..") || path39.isAbsolute(rel)) {
+  const abs = path40.resolve(staticDir, cleaned);
+  const rel = path40.relative(staticDir, abs);
+  if (rel.startsWith("..") || path40.isAbsolute(rel)) {
     return null;
   }
   try {
-    await fs26.stat(abs);
+    await fs27.stat(abs);
     return { abs, exists: true };
   } catch {
     return { abs, exists: false };
@@ -183330,7 +183554,7 @@ function injectAccessMarkup(html, apiKey, trusted) {
   return out;
 }
 async function readShell(indexPath, remoteAddress) {
-  const raw2 = await fs26.readFile(indexPath, "utf-8");
+  const raw2 = await fs27.readFile(indexPath, "utf-8");
   const trusted = isTrustedWebUiCaller(remoteAddress);
   return Buffer.from(injectAccessMarkup(raw2, getConfiguredApiKey(), trusted), "utf-8");
 }
@@ -183347,7 +183571,7 @@ var webUiRoutes = new Elysia().get("/ui", async ({ set: set3, request }) => {
     set3.status = 500;
     return { status: 500, error: "web ui static dir not found" };
   }
-  const indexPath = path39.join(dir, "index.html");
+  const indexPath = path40.join(dir, "index.html");
   try {
     const body = await readShell(indexPath, remoteAddressOf(request));
     set3.headers["content-type"] = contentTypeFor(indexPath);
@@ -183380,7 +183604,7 @@ var webUiRoutes = new Elysia().get("/ui", async ({ set: set3, request }) => {
   }
   if (resolved.exists) {
     try {
-      const body = await fs26.readFile(resolved.abs);
+      const body = await fs27.readFile(resolved.abs);
       set3.headers["content-type"] = contentTypeFor(resolved.abs);
       return body;
     } catch {
@@ -183389,7 +183613,7 @@ var webUiRoutes = new Elysia().get("/ui", async ({ set: set3, request }) => {
     }
   }
   try {
-    const body = await readShell(path39.join(dir, "index.html"), remoteAddressOf(request));
+    const body = await readShell(path40.join(dir, "index.html"), remoteAddressOf(request));
     set3.headers["content-type"] = "text/html; charset=utf-8";
     return body;
   } catch {
@@ -183537,8 +183761,8 @@ init_dist();
 
 // src/routes/model-registry-deployment.ts
 init_dist();
-import path40 from "path";
-var MARKER = path40.join("scripts", "generate-subagent-artifacts.ts");
+import path41 from "path";
+var MARKER = path41.join("scripts", "generate-subagent-artifacts.ts");
 var MAX_LEVELS2 = 6;
 var cachedRoot;
 function findDeploymentRoot(startDir) {
@@ -183556,8 +183780,8 @@ function deploymentUnavailableMessage(what) {
 
 // src/routes/model-registry.ts
 init_config();
-import fs27 from "fs";
-import path41 from "path";
+import fs28 from "fs";
+import path42 from "path";
 import { spawnSync } from "child_process";
 var _profilesLib = null;
 function profilesLib() {
@@ -183566,7 +183790,7 @@ function profilesLib() {
     if (!root2) {
       throw new Error(deploymentUnavailableMessage("scripts/lib/model-profiles.ts"));
     }
-    const libPath = path41.join(root2, "scripts", "lib", "model-profiles.ts");
+    const libPath = path42.join(root2, "scripts", "lib", "model-profiles.ts");
     _profilesLib = __require(libPath);
   }
   return _profilesLib;
@@ -183591,7 +183815,7 @@ function generatorLib() {
     if (!root2) {
       throw new Error(deploymentUnavailableMessage("scripts/generate-subagent-artifacts.ts"));
     }
-    const libPath = path41.join(root2, "scripts", "generate-subagent-artifacts.ts");
+    const libPath = path42.join(root2, "scripts", "generate-subagent-artifacts.ts");
     _generatorLib = __require(libPath);
   }
   return _generatorLib;
@@ -183608,7 +183832,7 @@ async function loadAgentsInventory() {
 var REGISTRY_DETAIL = {
   tags: ["model-registry"]
 };
-var OVERLAY_PATH = path41.join(configDir("massa-ai"), "model-profiles.json");
+var OVERLAY_PATH = path42.join(configDir("massa-ai"), "model-profiles.json");
 var ZERO_OVERLAY_OVERRIDE_BREAKDOWN = {
   hostDefaults: 0,
   workflowTiers: 0,
@@ -183700,7 +183924,7 @@ var modelRegistryRoutes = new Elysia({ prefix: "/api/v1/model-registry" }).get("
     set3.status = 501;
     return { success: false, error: deploymentUnavailableMessage("scripts/generate-subagent-artifacts.ts") };
   }
-  const generateScript = path41.join(root2, "scripts", "generate-subagent-artifacts.ts");
+  const generateScript = path42.join(root2, "scripts", "generate-subagent-artifacts.ts");
   try {
     const child = spawnSync("bun", [generateScript], {
       env: { ...process.env },
@@ -183739,8 +183963,8 @@ var modelRegistryRoutes = new Elysia({ prefix: "/api/v1/model-registry" }).get("
   }
   const lib = profilesLib();
   try {
-    if (fs27.existsSync(OVERLAY_PATH)) {
-      fs27.unlinkSync(OVERLAY_PATH);
+    if (fs28.existsSync(OVERLAY_PATH)) {
+      fs28.unlinkSync(OVERLAY_PATH);
     }
     const builtin = lib.loadRegistry(lib.DEFAULT_REGISTRY_PATH);
     set3.status = 200;
@@ -183766,17 +183990,17 @@ var modelRegistryRoutes = new Elysia({ prefix: "/api/v1/model-registry" }).get("
   }
 });
 function writeOverlayAtomically(overlayPath, data) {
-  const dir = path41.dirname(overlayPath);
-  if (!fs27.existsSync(dir)) {
-    fs27.mkdirSync(dir, { recursive: true });
+  const dir = path42.dirname(overlayPath);
+  if (!fs28.existsSync(dir)) {
+    fs28.mkdirSync(dir, { recursive: true });
   }
   const tmp = `${overlayPath}.${process.pid}.${Date.now()}.tmp`;
   try {
-    fs27.writeFileSync(tmp, JSON.stringify(data, null, 2));
-    fs27.renameSync(tmp, overlayPath);
+    fs28.writeFileSync(tmp, JSON.stringify(data, null, 2));
+    fs28.renameSync(tmp, overlayPath);
   } catch (e) {
     try {
-      fs27.unlinkSync(tmp);
+      fs28.unlinkSync(tmp);
     } catch {}
     throw e;
   }
@@ -183870,9 +184094,14 @@ var profileRoutes = new Elysia({ prefix: "/api/v1/profiles" }).get("/", ({ query
 
 // src/routes/config.ts
 init_dist();
+init_inference_providers();
 var CONFIG_DETAIL = {
   tags: ["config"]
 };
+function defaultEmbedBatchSize(provider) {
+  const spec = typeof provider === "string" && LOCAL_INFERENCE_IDS.includes(provider) ? INFERENCE_PROVIDERS[provider] : INFERENCE_PROVIDERS.ollama;
+  return spec.embedBatchSize;
+}
 var SENSITIVE_FIELDS = {
   database: ["url"],
   embedding: ["apiKey"],
@@ -183897,7 +184126,15 @@ var configRoutes = new Elysia({ prefix: "/api/v1/config" }).get("/", ({ set: set
   const config3 = loadConfig();
   const masked = maskSensitive(config3);
   const restart = restartNeededSections(config3);
-  const defaults2 = maskSensitive(defaultMassaAiConfig);
+  const shipped = maskSensitive(defaultMassaAiConfig);
+  const defaults2 = {
+    ...shipped,
+    embedding: {
+      ...shipped.embedding,
+      contextWindow: INFERENCE_ROLE_DEFAULTS.embedding.contextWindow,
+      batchSize: defaultEmbedBatchSize(config3.embedding?.provider)
+    }
+  };
   set3.status = 200;
   return {
     success: true,
@@ -183907,7 +184144,7 @@ var configRoutes = new Elysia({ prefix: "/api/v1/config" }).get("/", ({ set: set
   detail: {
     ...CONFIG_DETAIL,
     summary: "Get current config with sensitive fields masked",
-    description: "Returns the current config.json with security.apiKey, llm.apiKey, embedding.apiKey, and database.url masked to '***'. Includes restartNeededSections \u2014 the subset of [database, embedding, llm, security] present in the config \u2014 and defaults, the shipped default config (also masked) the Config tab falls back to for any field the persisted file omits."
+    description: "Returns the current config.json with security.apiKey, llm.apiKey, embedding.apiKey, and database.url masked to '***'. Includes restartNeededSections \u2014 the subset of [database, embedding, llm, security] present in the config \u2014 and defaults, the shipped default config (also masked) the Config tab falls back to for any field the persisted file omits. defaults.embedding.contextWindow and defaults.embedding.batchSize are derived rather than shipped: they come from the role table and the resolved provider's seam entry, because defaultMassaAiConfig deliberately leaves both unset (PDM-12)."
   }
 }).get("/reveal", ({ query, set: set3 }) => {
   const section = query.section;
@@ -183967,8 +184204,8 @@ var configRoutes = new Elysia({ prefix: "/api/v1/config" }).get("/", ({ set: set
 // src/routes/model-registry-stream.ts
 init_config();
 init_dist();
-import fs28 from "fs";
-import path42 from "path";
+import fs29 from "fs";
+import path43 from "path";
 import { spawn as spawn3 } from "child_process";
 var encoder3 = new TextEncoder;
 function sseFrame(data) {
@@ -183980,10 +184217,10 @@ var KNOWN_GENERATOR_FILENAMES = ["generate-skill-artifacts.ts", "generate-subage
 var SH_C_WRAPPER = /^sh -c '(.*)' --$/;
 var GENERATOR_SEGMENT = /^bun\s+(\S+\.ts)(?:\s+"\$@")?$/;
 function deriveGeneratorScripts(root2) {
-  const pkgPath = path42.join(root2, "package.json");
+  const pkgPath = path43.join(root2, "package.json");
   let raw2;
   try {
-    raw2 = fs28.readFileSync(pkgPath, "utf-8");
+    raw2 = fs29.readFileSync(pkgPath, "utf-8");
   } catch (e) {
     throw new Error(`cannot read ${pkgPath}: ${e.message}`);
   }
@@ -184010,7 +184247,7 @@ function deriveGeneratorScripts(root2) {
       throw new Error(`"generate:artifacts" segment does not match the expected "bun <script.ts>" shape: ${JSON.stringify(segment)}`);
     }
     const relPath = match2[1];
-    return { relPath, name: path42.basename(relPath) };
+    return { relPath, name: path43.basename(relPath) };
   });
 }
 function assertGeneratorBackstop(scripts) {
@@ -184162,7 +184399,7 @@ function createRegenerateStreamHandler() {
             return;
           }
           const generator = generatorScripts[index];
-          const scriptPath = path42.join(root2, generator.relPath);
+          const scriptPath = path43.join(root2, generator.relPath);
           try {
             child = spawn3("bun", [scriptPath], {
               env: { ...process.env },
@@ -184320,7 +184557,7 @@ var restartRoutes = new Elysia({ prefix: "/api/v1/system" }).onAfterResponse(()
 
 // src/routes/logs.ts
 init_dist();
-import fs29 from "fs";
+import fs30 from "fs";
 var LOGS_DETAIL = { tags: ["logs"] };
 var MAX_SCAN_BYTES = 64 * 1024 * 1024;
 var MAX_LIMIT = 1000;
@@ -184400,7 +184637,7 @@ function parseLine(line, prevTs) {
 function realReadTail(filePath, maxBytes) {
   let size;
   try {
-    size = fs29.statSync(filePath).size;
+    size = fs30.statSync(filePath).size;
   } catch {
     return { content: "", truncated: false };
   }
@@ -184408,24 +184645,24 @@ function realReadTail(filePath, maxBytes) {
     return { content: "", truncated: false };
   if (size <= maxBytes) {
     try {
-      return { content: fs29.readFileSync(filePath, "utf8"), truncated: false };
+      return { content: fs30.readFileSync(filePath, "utf8"), truncated: false };
     } catch {
       return { content: "", truncated: false };
     }
   }
   try {
-    const fd = fs29.openSync(filePath, "r");
+    const fd = fs30.openSync(filePath, "r");
     try {
       const start = size - maxBytes;
       const buf = Buffer.alloc(maxBytes);
-      fs29.readSync(fd, buf, 0, maxBytes, start);
+      fs30.readSync(fd, buf, 0, maxBytes, start);
       let text3 = buf.toString("utf8");
       const firstNewline = text3.indexOf(`
 `);
       text3 = firstNewline !== -1 ? text3.slice(firstNewline + 1) : "";
       return { content: text3, truncated: true };
     } finally {
-      fs29.closeSync(fd);
+      fs30.closeSync(fd);
     }
   } catch {
     return { content: "", truncated: true };
@@ -184435,7 +184672,7 @@ var realReader = {
   listFiles(filePath, maxFiles) {
     return sinkFiles(filePath, maxFiles).filter((f) => {
       try {
-        fs29.accessSync(f, fs29.constants.R_OK);
+        fs30.accessSync(f, fs30.constants.R_OK);
         return true;
       } catch {
         return false;
@@ -184524,7 +184761,7 @@ function startSinkTail(enqueue) {
   let currentFile = initial[0];
   let offset;
   try {
-    offset = fs29.statSync(currentFile).size;
+    offset = fs30.statSync(currentFile).size;
   } catch {
     return;
   }
@@ -184540,7 +184777,7 @@ function startSinkTail(enqueue) {
         offset = 0;
         carry = "";
       }
-      const size = fs29.statSync(currentFile).size;
+      const size = fs30.statSync(currentFile).size;
       if (size < offset) {
         offset = 0;
         carry = "";
@@ -184549,11 +184786,11 @@ function startSinkTail(enqueue) {
         return;
       const length = Math.min(size - offset, SINK_POLL_MAX_BYTES);
       const buf = Buffer.alloc(length);
-      const fd = fs29.openSync(currentFile, "r");
+      const fd = fs30.openSync(currentFile, "r");
       try {
-        fs29.readSync(fd, buf, 0, length, offset);
+        fs30.readSync(fd, buf, 0, length, offset);
       } finally {
-        fs29.closeSync(fd);
+        fs30.closeSync(fd);
       }
       offset += length;
       const text3 = carry + buf.toString("utf8");
@@ -184753,12 +184990,12 @@ var READ_ONLY_ROUTES = [
     justification: "Clean. apps/tools-api/src/routes/workspace.ts:542-673 calls " + "`getGraphController().analyzeImpact(...)`, which " + "(packages/core/src/services/symbol/graph-controller.ts:189-232) delegates to " + "`impactAnalysisService.analyze(...)` " + "(packages/core/src/services/symbol/impact-analysis.ts). Every git invocation there " + "runs through `execFileSync` for `rev-parse`/`diff`/`status`-class read commands, " + "plus one `hash-object -t tree --stdin` with no `-w` flag (so nothing is written to " + "the git object database) \u2014 no `git commit`, `git add`, or `-w` flag anywhere in " + "the module."
   }
 ];
-function normalizeRoutePath(path43) {
-  return path43.length > 1 && path43.endsWith("/") ? path43.slice(0, -1) : path43;
+function normalizeRoutePath(path44) {
+  return path44.length > 1 && path44.endsWith("/") ? path44.slice(0, -1) : path44;
 }
 var READ_ONLY_INDEX = new Map(READ_ONLY_ROUTES.map((entry2) => [`${entry2.method} ${entry2.path}`, entry2]));
-function findReadOnlyRoute(method, path43) {
-  return READ_ONLY_INDEX.get(`${method.toUpperCase()} ${normalizeRoutePath(path43)}`);
+function findReadOnlyRoute(method, path44) {
+  return READ_ONLY_INDEX.get(`${method.toUpperCase()} ${normalizeRoutePath(path44)}`);
 }
 
 // src/middleware/write-mode.ts
@@ -184777,14 +185014,14 @@ var WRITE_REFUSED = {
   success: false,
   error: "Write refused: read-only mode is active"
 };
-var writeModeMiddleware = new Elysia({ name: "write-mode" }).onBeforeHandle({ as: "global" }, ({ request, path: path43, set: set3, body }) => {
+var writeModeMiddleware = new Elysia({ name: "write-mode" }).onBeforeHandle({ as: "global" }, ({ request, path: path44, set: set3, body }) => {
   if (request.method.toUpperCase() === "GET")
     return;
-  if (isPublicPath(path43))
+  if (isPublicPath(path44))
     return;
   if (!isReadOnlyModeActive())
     return;
-  const entry2 = findReadOnlyRoute(request.method, path43);
+  const entry2 = findReadOnlyRoute(request.method, path44);
   if (entry2) {
     if (entry2.sanitizeBody && body && typeof body === "object") {
       entry2.sanitizeBody(body);
@@ -184797,11 +185034,11 @@ var writeModeMiddleware = new Elysia({ name: "write-mode" }).onBeforeHandle({ as
 
 // src/middleware/error.ts
 init_dist();
-var errorHandler = new Elysia({ name: "error-handler" }).onError(({ code, error: error51, set: set3, path: path43, request }) => {
+var errorHandler = new Elysia({ name: "error-handler" }).onError(({ code, error: error51, set: set3, path: path44, request }) => {
   logger.error("[massa-ai-api] Request failed", undefined, {
     ...safeErrorSummary(error51),
     code,
-    path: path43,
+    path: path44,
     method: request.method
   });
   if (error51 instanceof SearchServiceError) {