@massa-ai/mcp-client 1.61.0 → 1.63.0

package/dist/index.js

@@ -27446,12 +27446,12 @@ import path6 from "path";
 function isHost(v) {
   return typeof v === "string" && HOSTS.includes(v);
 }
-function fileLayout(host, activeDir, activeGlob, variantsRoot) {
+function fileLayout(host, activeDir, activeExt, variantsRoot) {
   return {
     host,
     route: "files",
     activeDir,
-    activeGlob,
+    activeExt,
     variantsRoot,
     variantDir: (profile) => path6.join(variantsRoot, profile)
   };
@@ -27465,19 +27465,19 @@ function resolveHostLayout(host, opts = {}) {
     case "claude": {
       const marketplaceRoot = opts.marketplaceRoot?.claude;
       if (override === undefined && marketplaceRoot !== undefined) {
-        return fileLayout(host, path6.join(marketplaceRoot, "agents"), "massa-ai-*.md", path6.join(marketplaceRoot, "agent-profiles"));
+        return fileLayout(host, path6.join(marketplaceRoot, "agents"), ".md", path6.join(marketplaceRoot, "agent-profiles"));
       }
       const root = override ?? path6.join(targetHome, ".claude");
-      return fileLayout(host, path6.join(root, "agents"), "massa-ai-*.md", path6.join(root, "massa-ai", "agent-profiles"));
+      return fileLayout(host, path6.join(root, "agents"), ".md", path6.join(root, "massa-ai", "agent-profiles"));
     }
     case "codex": {
       const root = override ?? path6.join(targetHome, ".codex");
-      return fileLayout(host, path6.join(root, "agents"), "massa-ai-*.toml", path6.join(root, "massa-ai", "agent-profiles"));
+      return fileLayout(host, path6.join(root, "agents"), ".toml", path6.join(root, "massa-ai", "agent-profiles"));
     }
     case "opencode": {
       const root = override ?? path6.join(targetHome, ".config", "opencode");
       const pluginsDir = path6.join(root, "plugins", "massa-ai");
-      return fileLayout(host, path6.join(root, "agents"), "massa-ai-*.md", path6.join(pluginsDir, "agent-profiles"));
+      return fileLayout(host, path6.join(root, "agents"), ".md", path6.join(pluginsDir, "agent-profiles"));
     }
   }
 }
@@ -27811,6 +27811,90 @@ function readInstalledPluginVersion(opts = {}) {
 var DEFAULT_PLUGIN_KEY = "massa-ai@massa-ai";
 var init_claude_marketplace = () => {};
 
+// ../../packages/shared/dist/profile-switch/ownership.js
+import fs6 from "fs";
+import path10 from "path";
+function isLegacyAgentName(fileName) {
+  const base = path10.basename(fileName).replace(/\.[^.]*$/, "");
+  return base.startsWith("massa-ai-") && LEGACY_AGENT_NAMES.includes(base.slice("massa-ai-".length));
+}
+function hasOwnedMarker(content) {
+  const lines = content.split(`
+`);
+  if (lines[0] !== "---")
+    return false;
+  const close = lines.indexOf("---", 1);
+  return close !== -1 && lines[close + 1] === OWNED_MARKER_MD;
+}
+function isRegularFile(filePath) {
+  try {
+    return fs6.lstatSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+function isOwnedAgentFile(filePath) {
+  if (!isRegularFile(filePath))
+    return false;
+  if (!filePath.endsWith(".toml") && isLegacyAgentName(filePath))
+    return true;
+  let content;
+  try {
+    content = fs6.readFileSync(filePath, "utf8");
+  } catch {
+    return false;
+  }
+  if (filePath.endsWith(".toml"))
+    return content.split(`
+`)[0] === OWNED_MARKER_TOML;
+  return hasOwnedMarker(content);
+}
+function isOwnedAgentLink(linkPath) {
+  try {
+    if (!fs6.lstatSync(linkPath).isSymbolicLink())
+      return false;
+  } catch {
+    return false;
+  }
+  if (isLegacyAgentName(linkPath))
+    return true;
+  const base = path10.basename(linkPath);
+  const target = fs6.readlinkSync(linkPath);
+  if (target.endsWith(`/opencode-plugin/agents/${base}`))
+    return true;
+  const escaped = base.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  if (new RegExp(`/plugins/massa-ai/agent-profiles/.*/${escaped}$`).test(target))
+    return true;
+  try {
+    return fs6.statSync(linkPath).isFile() && hasOwnedMarker(fs6.readFileSync(linkPath, "utf8"));
+  } catch {
+    return false;
+  }
+}
+var OWNED_MARKER_MD = "<!-- massa-ai-owned: true -->", OWNED_MARKER_TOML = "# massa-ai-owned", LEGACY_AGENT_NAMES;
+var init_ownership = __esm(() => {
+  LEGACY_AGENT_NAMES = [
+    "architecture-specialist",
+    "audit-specialist",
+    "builder",
+    "context-curator",
+    "designer",
+    "documentation-agent",
+    "furps-analyst",
+    "investigator",
+    "judge",
+    "meta-judge",
+    "mobile-specialist",
+    "navigator",
+    "plan-critic",
+    "planner",
+    "requirements-analyst",
+    "reviewer",
+    "test-engineer",
+    "verification-agent"
+  ];
+});
+
 // ../../packages/shared/dist/profile-switch/frontmatter.js
 function parseFrontmatter(raw2) {
   const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/.exec(raw2);
@@ -27868,12 +27952,12 @@ function unquoteScalar(s) {
 }
 
 // ../../packages/shared/dist/profile-switch/doctor.js
-import fs6 from "fs";
+import fs7 from "fs";
 import os6 from "os";
-import path10 from "path";
+import path11 from "path";
 function readTextFile(filePath) {
   try {
-    return fs6.readFileSync(filePath, "utf8");
+    return fs7.readFileSync(filePath, "utf8");
   } catch {
     return null;
   }
@@ -27889,7 +27973,7 @@ function readJsonFile(filePath) {
   }
 }
 function readPluginVersion(pluginRoot) {
-  const manifest = readJsonFile(path10.join(pluginRoot, ".claude-plugin", "plugin.json"));
+  const manifest = readJsonFile(path11.join(pluginRoot, ".claude-plugin", "plugin.json"));
   return typeof manifest?.version === "string" ? manifest.version : null;
 }
 function detectEnvOverride(env) {
@@ -27902,19 +27986,19 @@ function detectEnvOverride(env) {
   return null;
 }
 function readRoles(liveRoot, activeProfile) {
-  const agentsDir = path10.join(liveRoot, "agents");
+  const agentsDir = path11.join(liveRoot, "agents");
   let entries;
   try {
-    entries = fs6.readdirSync(agentsDir, { withFileTypes: true });
+    entries = fs7.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")) {
+    if (!entry.name.endsWith(".md") || !isOwnedAgentFile(path11.join(agentsDir, entry.name))) {
       continue;
     }
-    const activeRaw = readTextFile(path10.join(agentsDir, entry.name));
+    const activeRaw = readTextFile(path11.join(agentsDir, entry.name));
     let model = null;
     let effort = null;
     if (activeRaw !== null) {
@@ -27926,7 +28010,7 @@ function readRoles(liveRoot, activeProfile) {
     }
     let staleVariant = false;
     if (activeProfile && activeRaw !== null) {
-      const variantRaw = readTextFile(path10.join(liveRoot, "agent-profiles", activeProfile, entry.name));
+      const variantRaw = readTextFile(path11.join(liveRoot, "agent-profiles", activeProfile, entry.name));
       if (variantRaw !== null) {
         staleVariant = variantRaw !== activeRaw;
       }
@@ -27938,7 +28022,7 @@ function readRoles(liveRoot, activeProfile) {
 function runtimeDriftReport(opts = {}) {
   const targetHome = opts.targetHome ?? os6.homedir();
   const host = opts.host ?? "claude";
-  const stateFilePath = opts.stateFilePath ?? path10.join(targetHome, ".config", "massa-ai", "install-state.json");
+  const stateFilePath = opts.stateFilePath ?? path11.join(targetHome, ".config", "massa-ai", "install-state.json");
   let state = opts.state ?? null;
   if (state === null) {
     try {
@@ -27987,13 +28071,14 @@ function runtimeDriftReport(opts = {}) {
 var ENV_OVERRIDE_VARS;
 var init_doctor = __esm(() => {
   init_claude_marketplace();
+  init_ownership();
   init_state();
   ENV_OVERRIDE_VARS = ["CLAUDE_CODE_SUBAGENT_MODEL"];
 });
 
 // ../../packages/shared/dist/profile-switch/engine.js
-import fs7 from "fs";
-import path11 from "path";
+import fs8 from "fs";
+import path12 from "path";
 import os7 from "os";
 import crypto4 from "crypto";
 import { execFileSync as execFileSync2 } from "child_process";
@@ -28003,7 +28088,7 @@ function namedError3(name, message) {
   return err;
 }
 function defaultStatePath(targetHome) {
-  return path11.join(targetHome, ".config", "massa-ai", "install-state.json");
+  return path12.join(targetHome, ".config", "massa-ai", "install-state.json");
 }
 function resolveCommon(opts) {
   const targetHome = opts.targetHome ?? os7.homedir();
@@ -28014,7 +28099,7 @@ function marketplaceRoots(targetHome, state) {
   return state.platforms.claude?.installRoute === "marketplace" ? { claude: resolveClaudeMarketplaceRoot({ targetHome }) ?? undefined } : {};
 }
 function claudeMarketplaceUnresolvedReason(targetHome) {
-  const registryPath = path11.join(targetHome, ".claude", "plugins", "installed_plugins.json");
+  const registryPath = path12.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 = {}) {
@@ -28055,7 +28140,7 @@ function listProfiles(opts = {}) {
         ...claudeDriftFields(host)
       };
     }
-    const installed = fs7.existsSync(layout.activeDir);
+    const installed = fs8.existsSync(layout.activeDir);
     const availableProfiles = listVariantProfiles(layout);
     const platform = state.platforms[host];
     return {
@@ -28072,20 +28157,20 @@ function listProfiles(opts = {}) {
   return { hosts };
 }
 function listVariantProfiles(layout) {
-  if (!fs7.existsSync(layout.variantsRoot))
+  if (!fs8.existsSync(layout.variantsRoot))
     return [];
-  return fs7.readdirSync(layout.variantsRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  return fs8.readdirSync(layout.variantsRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
 }
-function matchesGlob(filename, glob) {
-  const starIdx = glob.indexOf("*");
-  if (starIdx === -1)
-    return filename === glob;
-  const prefix = glob.slice(0, starIdx);
-  const suffix = glob.slice(starIdx + 1);
-  return filename.length >= prefix.length + suffix.length && filename.startsWith(prefix) && filename.endsWith(suffix);
+function matchingFileNames(dir, ext) {
+  return fs8.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(ext) && !isLegacyAgentName(e.name) && isOwnedAgentFile(path12.join(dir, e.name))).map((e) => e.name);
 }
-function matchingFileNames(dir, glob) {
-  return fs7.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && matchesGlob(e.name, glob)).map((e) => e.name);
+function destIsAbsent(dest) {
+  try {
+    fs8.lstatSync(dest);
+    return false;
+  } catch {
+    return true;
+  }
 }
 function detectGitAvailability(dir) {
   try {
@@ -28111,7 +28196,7 @@ function gitTrackedFileNames(dir, filenames) {
   }
 }
 function checkTrackedPathGuard(activeDir, filenames) {
-  if (filenames.length === 0 || !fs7.existsSync(activeDir))
+  if (filenames.length === 0 || !fs8.existsSync(activeDir))
     return GUARD_PASS;
   const availability = detectGitAvailability(activeDir);
   if (availability === "no-git")
@@ -28122,53 +28207,45 @@ function checkTrackedPathGuard(activeDir, filenames) {
   if (tracked.size === 0)
     return GUARD_PASS;
   const offending = filenames.find((name) => tracked.has(name));
-  return { blocked: true, path: path11.join(activeDir, offending), unchecked: false };
+  return { blocked: true, path: path12.join(activeDir, offending), unchecked: false };
 }
 function assertStateWritable(stateFilePath) {
-  const dir = path11.dirname(stateFilePath);
+  const dir = path12.dirname(stateFilePath);
   try {
-    fs7.mkdirSync(dir, { recursive: true });
+    fs8.mkdirSync(dir, { recursive: true });
   } catch (err) {
     throw UnwritableInstallStateError(stateFilePath, err.message);
   }
-  const checkPath = fs7.existsSync(stateFilePath) ? stateFilePath : dir;
+  const checkPath = fs8.existsSync(stateFilePath) ? stateFilePath : dir;
   try {
-    fs7.accessSync(checkPath, fs7.constants.W_OK);
+    fs8.accessSync(checkPath, fs8.constants.W_OK);
   } catch (err) {
     throw UnwritableInstallStateError(stateFilePath, err.message);
   }
 }
 function copyFileRouteVariant(layout, variantDir) {
-  fs7.mkdirSync(layout.activeDir, { recursive: true });
+  fs8.mkdirSync(layout.activeDir, { recursive: true });
   let changed = 0;
-  for (const entry of fs7.readdirSync(variantDir, { withFileTypes: true })) {
-    if (!entry.isFile() || !matchesGlob(entry.name, layout.activeGlob))
+  for (const name of matchingFileNames(variantDir, layout.activeExt)) {
+    const dest = path12.join(layout.activeDir, name);
+    if (!destIsAbsent(dest) && !isOwnedAgentFile(dest))
       continue;
-    fs7.copyFileSync(path11.join(variantDir, entry.name), path11.join(layout.activeDir, entry.name));
+    fs8.copyFileSync(path12.join(variantDir, name), dest);
     changed++;
   }
   return changed;
 }
 function repointOpencodeVariant(layout, variantDir) {
-  fs7.mkdirSync(layout.activeDir, { recursive: true });
+  fs8.mkdirSync(layout.activeDir, { recursive: true });
   let changed = 0;
-  for (const entry of fs7.readdirSync(variantDir, { withFileTypes: true })) {
-    if (!entry.isFile() || !matchesGlob(entry.name, layout.activeGlob))
-      continue;
-    const dest = path11.join(layout.activeDir, entry.name);
-    const target = path11.resolve(path11.join(variantDir, entry.name));
-    let destExists = true;
-    let destIsSymlink = false;
-    try {
-      destIsSymlink = fs7.lstatSync(dest).isSymbolicLink();
-    } catch {
-      destExists = false;
-    }
-    if (destExists && !destIsSymlink)
+  for (const name of matchingFileNames(variantDir, layout.activeExt)) {
+    const dest = path12.join(layout.activeDir, name);
+    const target = path12.resolve(path12.join(variantDir, name));
+    if (!destIsAbsent(dest) && !isOwnedAgentLink(dest))
       continue;
     const tmp = `${dest}.massa-ai-switch.${crypto4.randomUUID()}`;
-    fs7.symlinkSync(target, tmp);
-    fs7.renameSync(tmp, dest);
+    fs8.symlinkSync(target, tmp);
+    fs8.renameSync(tmp, dest);
     changed++;
   }
   return changed;
@@ -28208,13 +28285,13 @@ function switchProfile(opts) {
   if (fileHosts.length === 0) {
     return { profile: opts.profile, dryRun, hosts: orderRows(universe, skipRows), restartRequired: false };
   }
-  const installedFileHosts = fileHosts.filter((h) => fs7.existsSync(h.layout.activeDir));
+  const installedFileHosts = fileHosts.filter((h) => fs8.existsSync(h.layout.activeDir));
   if (installedFileHosts.length === 0)
     throw NoHostsDetectedError();
   const withAvailability = fileHosts.map((h) => {
-    const variantsRootExists = fs7.existsSync(h.layout.variantsRoot);
+    const variantsRootExists = fs8.existsSync(h.layout.variantsRoot);
     const variantDir = h.layout.variantDir(opts.profile);
-    const available = variantsRootExists && fs7.existsSync(variantDir) && fs7.statSync(variantDir).isDirectory();
+    const available = variantsRootExists && fs8.existsSync(variantDir) && fs8.statSync(variantDir).isDirectory();
     return { ...h, variantsRootExists, variantDir, available };
   });
   if (!withAvailability.some((h) => h.available)) {
@@ -28253,7 +28330,7 @@ function switchProfile(opts) {
         rows.push({ host: h.host, status: "would-switch" });
         continue;
       }
-      const candidateNames = matchingFileNames(h.variantDir, h.layout.activeGlob);
+      const candidateNames = matchingFileNames(h.variantDir, h.layout.activeExt);
       const guard = checkTrackedPathGuard(h.layout.activeDir, candidateNames);
       if (guard.blocked) {
         rows.push({
@@ -28295,6 +28372,7 @@ var init_engine = __esm(() => {
   init_state();
   init_lock();
   init_claude_marketplace();
+  init_ownership();
   init_doctor();
   SwitchEngineError = class SwitchEngineError extends Error {
     constructor(message) {
@@ -28312,25 +28390,25 @@ function reportSucceeded(report) {
 }
 
 // ../../packages/shared/dist/profile-switch/variant-sync.js
-import fs8 from "fs";
-import path12 from "path";
+import fs9 from "fs";
+import path13 from "path";
 import os8 from "os";
 import crypto5 from "crypto";
 function defaultStatePath2(targetHome) {
-  return path12.join(targetHome, ".config", "massa-ai", "install-state.json");
+  return path13.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}.${crypto5.randomBytes(6).toString("hex")}`;
-  const tempFile = path12.join(destDir, `.${destName}.${unique}.tmp`);
+  const tempFile = path13.join(destDir, `.${destName}.${unique}.tmp`);
   try {
-    fs8.writeFileSync(tempFile, content);
-    fs8.renameSync(tempFile, path12.join(destDir, destName));
+    fs9.writeFileSync(tempFile, content);
+    fs9.renameSync(tempFile, path13.join(destDir, destName));
   } catch (error51) {
     try {
-      fs8.unlinkSync(tempFile);
+      fs9.unlinkSync(tempFile);
     } catch {}
     throw error51;
   }
@@ -28338,20 +28416,20 @@ function writeFileIntoDirAtomically(destDir, destName, content) {
 function isSafeDirName(name) {
   if (name === "." || name === "..")
     return false;
-  if (name.includes("/") || name.includes("\\") || name.includes(path12.sep))
+  if (name.includes("/") || name.includes("\\") || name.includes(path13.sep))
     return false;
-  return path12.basename(name) === name;
+  return path13.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 = path12.join(sourceRoot, "apps", `${host}-plugin`, "agent-profiles");
-  if (!fs8.existsSync(srcDir) || !fs8.statSync(srcDir).isDirectory()) {
+  const srcDir = path13.join(sourceRoot, "apps", `${host}-plugin`, "agent-profiles");
+  if (!fs9.existsSync(srcDir) || !fs9.statSync(srcDir).isDirectory()) {
     return { host, status: "skipped", profiles: [], retained: [], files: 0, reason: "no generated variants for this host" };
   }
-  if (!fs8.existsSync(layout.variantsRoot)) {
+  if (!fs9.existsSync(layout.variantsRoot)) {
     return {
       host,
       status: "skipped",
@@ -28363,24 +28441,24 @@ function syncHost(host, sourceRoot, targetHome, marketplaceRoot) {
   }
   const profiles = [];
   let files = 0;
-  for (const entry of fs8.readdirSync(srcDir, { withFileTypes: true })) {
+  for (const entry of fs9.readdirSync(srcDir, { withFileTypes: true })) {
     if (!entry.isDirectory())
       continue;
     if (!isSafeDirName(entry.name))
       continue;
-    const srcProfileDir = path12.join(srcDir, entry.name);
-    const destProfileDir = path12.join(layout.variantsRoot, entry.name);
-    fs8.mkdirSync(destProfileDir, { recursive: true });
-    for (const fileEntry of fs8.readdirSync(srcProfileDir, { withFileTypes: true })) {
+    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 })) {
       if (!fileEntry.isFile())
         continue;
-      const content = fs8.readFileSync(path12.join(srcProfileDir, fileEntry.name));
+      const content = fs9.readFileSync(path13.join(srcProfileDir, fileEntry.name));
       writeFileIntoDirAtomically(destProfileDir, fileEntry.name, content);
       files++;
     }
     profiles.push(entry.name);
   }
-  const retained = fs8.readdirSync(layout.variantsRoot, { withFileTypes: true }).filter((e) => e.isDirectory() && !profiles.includes(e.name)).map((e) => e.name).sort();
+  const retained = fs9.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) {
@@ -28415,14 +28493,14 @@ var init_variant_sync = __esm(() => {
 });
 
 // ../../packages/shared/dist/profile-switch/repo-root.js
-import fs9 from "fs";
-import path13 from "path";
+import fs10 from "fs";
+import path14 from "path";
 function findRepoRootWithMarker(startDir, marker, maxLevels) {
   let dir = startDir;
   for (let i = 0;i <= maxLevels; i++) {
-    if (fs9.existsSync(path13.join(dir, marker)))
+    if (fs10.existsSync(path14.join(dir, marker)))
       return dir;
-    const parent = path13.dirname(dir);
+    const parent = path14.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -28432,6 +28510,9 @@ function findRepoRootWithMarker(startDir, marker, maxLevels) {
 var init_repo_root = () => {};
 
 // ../../packages/shared/dist/bootstrap/rules.js
+function isRetiredRuleId(value) {
+  return RETIRED_RULE_IDS.includes(value);
+}
 function isBootstrapRuleId(value) {
   return typeof value === "string" && BOOTSTRAP_RULE_IDS.includes(value);
 }
@@ -28450,12 +28531,14 @@ function assertKnownRuleId(id) {
   if (!isBootstrapRuleId(id))
     throw UnknownRuleError(id, BOOTSTRAP_RULE_IDS);
 }
-var BOOTSTRAP_RULE_IDS, BOOTSTRAP_RULES, RULES_BY_ID, BootstrapRuleError, UnknownRuleError = (id, known = BOOTSTRAP_RULE_IDS) => namedError4("UnknownRuleError", `unknown bootstrap rule "${id}" \u2014 valid ids: ${known.join(", ")}`);
+var BOOTSTRAP_RULE_IDS, RETIRED_RULE_IDS, BOOTSTRAP_RULES, RULES_BY_ID, BootstrapRuleError, UnknownRuleError = (id, known = BOOTSTRAP_RULE_IDS) => {
+  const what = isRetiredRuleId(id) ? `bootstrap rule "${id}" was retired and can no longer be toggled` : `unknown bootstrap rule "${id}"`;
+  return namedError4("UnknownRuleError", `${what} \u2014 valid ids: ${known.join(", ")}`);
+};
 var init_rules = __esm(() => {
   BOOTSTRAP_RULE_IDS = [
     "caveman",
     "massa-ai-router",
-    "persona-router",
     "dedupe-guardrails",
     "plan-challenge",
     "conversation-feedback",
@@ -28463,6 +28546,7 @@ var init_rules = __esm(() => {
     "english-code",
     "code-comments"
   ];
+  RETIRED_RULE_IDS = ["persona-router"];
   BOOTSTRAP_RULES = [
     {
       id: "caveman",
@@ -28474,11 +28558,6 @@ var init_rules = __esm(() => {
       defaultEnabled: true,
       description: "Load the massa-ai skill as the workflow router before substantive work."
     },
-    {
-      id: "persona-router",
-      defaultEnabled: true,
-      description: "Select one cataloged specialist persona after massa-ai context is available."
-    },
     {
       id: "dedupe-guardrails",
       defaultEnabled: true,
@@ -28520,7 +28599,7 @@ var init_rules = __esm(() => {
 });
 
 // ../../packages/shared/dist/bootstrap/state.js
-import fs10 from "fs";
+import fs11 from "fs";
 function isPlainObject4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -28541,6 +28620,8 @@ function resolveBootstrapState(doc2) {
     return { state, ignoredStateKeys: [BOOTSTRAP_STATE_PATH] };
   }
   for (const [key, value] of Object.entries(rules)) {
+    if (isRetiredRuleId(key))
+      continue;
     if (!isBootstrapRuleId(key) || typeof value !== "boolean") {
       ignored.push(key);
       continue;
@@ -28551,7 +28632,7 @@ function resolveBootstrapState(doc2) {
 }
 function readConfigBytes() {
   try {
-    return fs10.readFileSync(getConfigPath(), "utf-8");
+    return fs11.readFileSync(getConfigPath(), "utf-8");
   } catch (error51) {
     if (error51?.code === "ENOENT")
       return "";
@@ -28606,7 +28687,7 @@ var init_state2 = __esm(() => {
 });
 
 // ../../packages/shared/dist/bootstrap/render.js
-import path14 from "path";
+import path15 from "path";
 function wrapBootstrapBlock(body) {
   return `${BOOTSTRAP_BLOCK_START}
 ${body.replace(/\n+$/, "")}
@@ -28619,19 +28700,19 @@ function ruleMarker(id, suffix) {
 function resolveHostRoot(host, targetHome, hostRoot) {
   requireAbsoluteTargetHome(targetHome);
   if (hostRoot === undefined)
-    return path14.join(targetHome, ...HOST_CONFIG_DIR[host]);
-  const relative = path14.relative(targetHome, hostRoot);
-  if (!path14.isAbsolute(hostRoot) || relative === "" || relative.startsWith("..") || path14.isAbsolute(relative)) {
+    return path15.join(targetHome, ...HOST_CONFIG_DIR[host]);
+  const relative = path15.relative(targetHome, hostRoot);
+  if (!path15.isAbsolute(hostRoot) || relative === "" || relative.startsWith("..") || path15.isAbsolute(relative)) {
     throw new BootstrapRenderError("HostRootOutsideTargetHomeError", `hostRoot must be an absolute directory inside targetHome, got "${hostRoot}" for targetHome "${targetHome}"`, [hostRoot, targetHome]);
   }
   return hostRoot;
 }
 function bootstrapContractPath(host, targetHome, hostRoot) {
-  return path14.join(resolveHostRoot(host, targetHome, hostRoot), CONTRACT_FILENAME);
+  return path15.join(resolveHostRoot(host, targetHome, hostRoot), CONTRACT_FILENAME);
 }
 function bootstrapStateFilePath(targetHome) {
   requireAbsoluteTargetHome(targetHome);
-  return path14.join(targetHome, ".config", "massa-ai", "config.json");
+  return path15.join(targetHome, ".config", "massa-ai", "config.json");
 }
 function renderBootstrap(options) {
   const { source, state, host, targetHome, hostRoot } = options;
@@ -28654,7 +28735,7 @@ ${body}`;
   return { contract, pointer };
 }
 function requireAbsoluteTargetHome(targetHome) {
-  if (!path14.isAbsolute(targetHome)) {
+  if (!path15.isAbsolute(targetHome)) {
     throw new BootstrapRenderError("TargetHomeNotAbsoluteError", `targetHome must be an absolute path, got "${targetHome}"`, [targetHome]);
   }
 }
@@ -28831,14 +28912,14 @@ var init_report = __esm(() => {
 });
 
 // ../../packages/shared/dist/bootstrap/engine.js
-import fs11 from "fs";
-import path15 from "path";
+import fs12 from "fs";
+import path16 from "path";
 function applyBootstrapState(options) {
   const { targetHome } = options;
   const dryRun = options.dryRun ?? false;
   const warn = options.onWarning ?? ((message) => console.warn(message));
   const configPath = bootstrapStateFilePath(targetHome);
-  const installStatePath = path15.join(path15.dirname(configPath), INSTALL_STATE_FILENAME);
+  const installStatePath = path16.join(path16.dirname(configPath), INSTALL_STATE_FILENAME);
   const { platforms } = readInstallState(installStatePath);
   const installed = HOSTS.filter((host) => platforms[host] !== undefined);
   if (installed.length === 0) {
@@ -28931,22 +29012,22 @@ function applyHost(input) {
 }
 function wiringArtifact(host, targetHome, hostRoot) {
   const root = resolveHostRoot(host, targetHome, hostRoot);
-  const contractPath = path15.join(root, CONTRACT_FILENAME);
+  const contractPath = path16.join(root, CONTRACT_FILENAME);
   switch (host) {
     case "claude":
-      return { file: path15.join(root, "CLAUDE.md"), token: `@${CONTRACT_FILENAME}` };
+      return { file: path16.join(root, "CLAUDE.md"), token: `@${CONTRACT_FILENAME}` };
     case "codex":
     case "cursor":
-      return { file: path15.join(root, "AGENTS.md"), token: contractPath };
+      return { file: path16.join(root, "AGENTS.md"), token: contractPath };
     case "opencode":
       return { file: openCodeConfigPath(root), token: `"${contractPath}"` };
   }
 }
 function openCodeConfigPath(root) {
-  const json2 = path15.join(root, "opencode.json");
-  if (fs11.existsSync(json2))
+  const json2 = path16.join(root, "opencode.json");
+  if (fs12.existsSync(json2))
     return json2;
-  return path15.join(root, "opencode.jsonc");
+  return path16.join(root, "opencode.jsonc");
 }
 function isWired(host, targetHome, hostRoot) {
   const artifact = wiringArtifact(host, targetHome, hostRoot);
@@ -28959,7 +29040,7 @@ function notWiredReason(host, targetHome, hostRoot) {
 }
 function readFileOrNull(filePath) {
   try {
-    return fs11.readFileSync(filePath, "utf-8");
+    return fs12.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -29041,6 +29122,7 @@ var init_dist = __esm(() => {
   init_state();
   init_lock();
   init_engine();
+  init_ownership();
   init_variant_sync();
   init_repo_root();
   init_doctor();
@@ -30566,7 +30648,7 @@ var import_brace_expansion, minimatch = (p, pattern, options = {}) => {
 }, qmarksTestNoExtDot = ([$0]) => {
   const len = $0.length;
   return (f) => f.length === len && f !== "." && f !== "..";
-}, defaultPlatform, path16, sep, GLOBSTAR, qmark2 = "[^/]", star2, twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?", filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options), ext = (a, b = {}) => Object.assign({}, a, b), defaults = (def) => {
+}, defaultPlatform, path17, sep, GLOBSTAR, qmark2 = "[^/]", star2, twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?", filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options), ext = (a, b = {}) => Object.assign({}, a, b), defaults = (def) => {
   if (!def || typeof def !== "object" || !Object.keys(def).length) {
     return minimatch;
   }
@@ -30624,11 +30706,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";
-  path16 = {
+  path17 = {
     win32: { sep: "\\" },
     posix: { sep: "/" }
   };
-  sep = defaultPlatform === "win32" ? path16.win32.sep : path16.posix.sep;
+  sep = defaultPlatform === "win32" ? path17.win32.sep : path17.posix.sep;
   minimatch.sep = sep;
   GLOBSTAR = Symbol("globstar **");
   minimatch.GLOBSTAR = GLOBSTAR;
@@ -32594,12 +32676,12 @@ var init_esm4 = __esm(() => {
     childrenCache() {
       return this.#children;
     }
-    resolve(path17) {
-      if (!path17) {
+    resolve(path18) {
+      if (!path18) {
         return this;
       }
-      const rootPath = this.getRootString(path17);
-      const dir = path17.substring(rootPath.length);
+      const rootPath = this.getRootString(path18);
+      const dir = path18.substring(rootPath.length);
       const dirParts = dir.split(this.splitSep);
       const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
       return result;
@@ -33127,8 +33209,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(path17) {
-      return win32.parse(path17).root;
+    getRootString(path18) {
+      return win32.parse(path18).root;
     }
     getRoot(rootPath) {
       rootPath = uncToDrive(rootPath.toUpperCase());
@@ -33153,8 +33235,8 @@ var init_esm4 = __esm(() => {
     constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
       super(name, type, root, roots, nocase, children, opts);
     }
-    getRootString(path17) {
-      return path17.startsWith("/") ? "/" : "";
+    getRootString(path18) {
+      return path18.startsWith("/") ? "/" : "";
     }
     getRoot(_rootPath) {
       return this.root;
@@ -33173,8 +33255,8 @@ var init_esm4 = __esm(() => {
     #children;
     nocase;
     #fs;
-    constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs12 = defaultFS } = {}) {
-      this.#fs = fsFromOption(fs12);
+    constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs13 = defaultFS } = {}) {
+      this.#fs = fsFromOption(fs13);
       if (cwd instanceof URL || cwd.startsWith("file://")) {
         cwd = fileURLToPath(cwd);
       }
@@ -33210,11 +33292,11 @@ var init_esm4 = __esm(() => {
       }
       this.cwd = prev;
     }
-    depth(path17 = this.cwd) {
-      if (typeof path17 === "string") {
-        path17 = this.cwd.resolve(path17);
+    depth(path18 = this.cwd) {
+      if (typeof path18 === "string") {
+        path18 = this.cwd.resolve(path18);
       }
-      return path17.depth();
+      return path18.depth();
     }
     childrenCache() {
       return this.#children;
@@ -33630,9 +33712,9 @@ var init_esm4 = __esm(() => {
       process4();
       return results;
     }
-    chdir(path17 = this.cwd) {
+    chdir(path18 = this.cwd) {
       const oldCwd = this.cwd;
-      this.cwd = typeof path17 === "string" ? this.cwd.resolve(path17) : path17;
+      this.cwd = typeof path18 === "string" ? this.cwd.resolve(path18) : path18;
       this.cwd[setAsCwd](oldCwd);
     }
   };
@@ -33649,8 +33731,8 @@ var init_esm4 = __esm(() => {
     parseRootPath(dir) {
       return win32.parse(dir).root.toUpperCase();
     }
-    newRoot(fs12) {
-      return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs12 });
+    newRoot(fs13) {
+      return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs13 });
     }
     isAbsolute(p) {
       return p.startsWith("/") || p.startsWith("\\") || /^[a-z]:(\/|\\)/i.test(p);
@@ -33666,8 +33748,8 @@ var init_esm4 = __esm(() => {
     parseRootPath(_dir) {
       return "/";
     }
-    newRoot(fs12) {
-      return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs12 });
+    newRoot(fs13) {
+      return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs13 });
     }
     isAbsolute(p) {
       return p.startsWith("/");
@@ -33924,8 +34006,8 @@ class MatchRecord {
     this.store.set(target, current === undefined ? n : n & current);
   }
   entries() {
-    return [...this.store.entries()].map(([path17, n]) => [
-      path17,
+    return [...this.store.entries()].map(([path18, n]) => [
+      path18,
       !!(n & 2),
       !!(n & 1)
     ]);
@@ -34129,9 +34211,9 @@ class GlobUtil {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path17, opts) {
+  constructor(patterns, path18, opts) {
     this.patterns = patterns;
-    this.path = path17;
+    this.path = path18;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -34150,11 +34232,11 @@ class GlobUtil {
       });
     }
   }
-  #ignored(path17) {
-    return this.seen.has(path17) || !!this.#ignore?.ignored?.(path17);
+  #ignored(path18) {
+    return this.seen.has(path18) || !!this.#ignore?.ignored?.(path18);
   }
-  #childrenIgnored(path17) {
-    return !!this.#ignore?.childrenIgnored?.(path17);
+  #childrenIgnored(path18) {
+    return !!this.#ignore?.childrenIgnored?.(path18);
   }
   pause() {
     this.paused = true;
@@ -34371,8 +34453,8 @@ var init_walker = __esm(() => {
   init_processor();
   GlobWalker = class GlobWalker extends GlobUtil {
     matches = new Set;
-    constructor(patterns, path17, opts) {
-      super(patterns, path17, opts);
+    constructor(patterns, path18, opts) {
+      super(patterns, path18, opts);
     }
     matchEmit(e) {
       this.matches.add(e);
@@ -34409,8 +34491,8 @@ var init_walker = __esm(() => {
   };
   GlobStream = class GlobStream extends GlobUtil {
     results;
-    constructor(patterns, path17, opts) {
-      super(patterns, path17, opts);
+    constructor(patterns, path18, opts) {
+      super(patterns, path18, opts);
       this.results = new Minipass({
         signal: this.signal,
         objectMode: true
@@ -34838,20 +34920,20 @@ var require_ignore = __commonJS((exports, module) => {
   var throwError = (message, Ctor) => {
     throw new Ctor(message);
   };
-  var checkPath = (path17, originalPath, doThrow) => {
-    if (!isString(path17)) {
+  var checkPath = (path18, originalPath, doThrow) => {
+    if (!isString(path18)) {
       return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
     }
-    if (!path17) {
+    if (!path18) {
       return doThrow(`path must not be empty`, TypeError);
     }
-    if (checkPath.isNotRelative(path17)) {
+    if (checkPath.isNotRelative(path18)) {
       const r = "`path.relative()`d";
       return doThrow(`path should be a ${r} string, but got "${originalPath}"`, RangeError);
     }
     return true;
   };
-  var isNotRelative = (path17) => REGEX_TEST_INVALID_PATH.test(path17);
+  var isNotRelative = (path18) => REGEX_TEST_INVALID_PATH.test(path18);
   checkPath.isNotRelative = isNotRelative;
   checkPath.convert = (p) => p;
 
@@ -34894,7 +34976,7 @@ var require_ignore = __commonJS((exports, module) => {
     addPattern(pattern) {
       return this.add(pattern);
     }
-    _testOne(path17, checkUnignored) {
+    _testOne(path18, checkUnignored) {
       let ignored = false;
       let unignored = false;
       this._rules.forEach((rule) => {
@@ -34902,7 +34984,7 @@ var require_ignore = __commonJS((exports, module) => {
         if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
           return;
         }
-        const matched = rule.regex.test(path17);
+        const matched = rule.regex.test(path18);
         if (matched) {
           ignored = !negative;
           unignored = negative;
@@ -34914,39 +34996,39 @@ var require_ignore = __commonJS((exports, module) => {
       };
     }
     _test(originalPath, cache, checkUnignored, slices) {
-      const path17 = originalPath && checkPath.convert(originalPath);
-      checkPath(path17, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
-      return this._t(path17, cache, checkUnignored, slices);
+      const path18 = originalPath && checkPath.convert(originalPath);
+      checkPath(path18, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
+      return this._t(path18, cache, checkUnignored, slices);
     }
-    _t(path17, cache, checkUnignored, slices) {
-      if (path17 in cache) {
-        return cache[path17];
+    _t(path18, cache, checkUnignored, slices) {
+      if (path18 in cache) {
+        return cache[path18];
       }
       if (!slices) {
-        slices = path17.split(SLASH2);
+        slices = path18.split(SLASH2);
       }
       slices.pop();
       if (!slices.length) {
-        return cache[path17] = this._testOne(path17, checkUnignored);
+        return cache[path18] = this._testOne(path18, checkUnignored);
       }
       const parent = this._t(slices.join(SLASH2) + SLASH2, cache, checkUnignored, slices);
-      return cache[path17] = parent.ignored ? parent : this._testOne(path17, checkUnignored);
+      return cache[path18] = parent.ignored ? parent : this._testOne(path18, checkUnignored);
     }
-    ignores(path17) {
-      return this._test(path17, this._ignoreCache, false).ignored;
+    ignores(path18) {
+      return this._test(path18, this._ignoreCache, false).ignored;
     }
     createFilter() {
-      return (path17) => !this.ignores(path17);
+      return (path18) => !this.ignores(path18);
     }
     filter(paths) {
       return makeArray(paths).filter(this.createFilter());
     }
-    test(path17) {
-      return this._test(path17, this._testCache, true);
+    test(path18) {
+      return this._test(path18, this._testCache, true);
     }
   }
   var factory = (options) => new Ignore2(options);
-  var isPathValid = (path17) => checkPath(path17 && checkPath.convert(path17), path17, RETURN_FALSE);
+  var isPathValid = (path18) => checkPath(path18 && checkPath.convert(path18), path18, RETURN_FALSE);
   factory.isPathValid = isPathValid;
   factory.default = factory;
   module.exports = factory;
@@ -34954,7 +35036,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 = (path17) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path17) || isNotRelative(path17);
+    checkPath.isNotRelative = (path18) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path18) || isNotRelative(path18);
   }
 });
 
@@ -35016,18 +35098,18 @@ function validatePolicy(policy, opts = {}) {
     }
   }
 }
-function matchesGlob2(path17, pattern) {
+function matchesGlob(path18, pattern) {
   let re = regexCache.get(pattern);
   if (!re) {
     re = globToRegex(pattern);
     regexCache.set(pattern, re);
   }
-  return re.test(path17);
+  return re.test(path18);
 }
 var DEFAULT_POLICY, applyPolicy = (filePath, policy) => {
   const normalized = filePath.trim();
   for (const rule of policy.rules) {
-    if (matchesGlob2(normalized, rule.pattern))
+    if (matchesGlob(normalized, rule.pattern))
       return rule.disposition;
   }
   return "Keep";
@@ -35039,8 +35121,8 @@ var init_capture_policy = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/ignore-patterns.js
-import fs12 from "fs/promises";
-import path17 from "path";
+import fs13 from "fs/promises";
+import path18 from "path";
 function buildExtensionGlob(extensions) {
   return extensions.map((ext2) => `**/*${ext2}`);
 }
@@ -35063,8 +35145,8 @@ async function loadProjectIgnore(projectPath) {
   const ig = ignore();
   ig.add(DEFAULT_IGNORES);
   try {
-    const gitignorePath = path17.join(projectPath, ".gitignore");
-    const gitignoreContent = await fs12.readFile(gitignorePath, "utf8");
+    const gitignorePath = path18.join(projectPath, ".gitignore");
+    const gitignoreContent = await fs13.readFile(gitignorePath, "utf8");
     const rules = gitignoreContent.split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
     ig.add(rules);
@@ -36663,15 +36745,15 @@ var require_pg_connection_string = __commonJS((exports, module) => {
     if (config3.sslnegotiation === "direct" && config3.ssl === undefined) {
       config3.ssl = true;
     }
-    const fs13 = config3.sslcert || config3.sslkey || config3.sslrootcert ? __require("fs") : null;
+    const fs14 = config3.sslcert || config3.sslkey || config3.sslrootcert ? __require("fs") : null;
     if (config3.sslcert) {
-      config3.ssl.cert = fs13.readFileSync(config3.sslcert).toString();
+      config3.ssl.cert = fs14.readFileSync(config3.sslcert).toString();
     }
     if (config3.sslkey) {
-      config3.ssl.key = fs13.readFileSync(config3.sslkey).toString();
+      config3.ssl.key = fs14.readFileSync(config3.sslkey).toString();
     }
     if (config3.sslrootcert) {
-      config3.ssl.ca = fs13.readFileSync(config3.sslrootcert).toString();
+      config3.ssl.ca = fs14.readFileSync(config3.sslrootcert).toString();
     }
     if (options.useLibpqCompat && config3.uselibpqcompat) {
       throw new Error("Both useLibpqCompat and uselibpqcompat are set. Please use only one of them.");
@@ -38385,7 +38467,7 @@ var require_split2 = __commonJS((exports, module) => {
 
 // ../../node_modules/pgpass/lib/helper.js
 var require_helper = __commonJS((exports, module) => {
-  var path18 = __require("path");
+  var path19 = __require("path");
   var Stream2 = __require("stream").Stream;
   var split = require_split2();
   var util3 = __require("util");
@@ -38425,7 +38507,7 @@ var require_helper = __commonJS((exports, module) => {
   };
   exports.getFileName = function(rawEnv) {
     var env = rawEnv || process.env;
-    var file2 = env.PGPASSFILE || (isWin ? path18.join(env.APPDATA || "./", "postgresql", "pgpass.conf") : path18.join(env.HOME || "./", ".pgpass"));
+    var file2 = env.PGPASSFILE || (isWin ? path19.join(env.APPDATA || "./", "postgresql", "pgpass.conf") : path19.join(env.HOME || "./", ".pgpass"));
     return file2;
   };
   exports.usePgPass = function(stats, fname) {
@@ -38549,16 +38631,16 @@ var require_helper = __commonJS((exports, module) => {
 
 // ../../node_modules/pgpass/lib/index.js
 var require_lib = __commonJS((exports, module) => {
-  var path18 = __require("path");
-  var fs13 = __require("fs");
+  var path19 = __require("path");
+  var fs14 = __require("fs");
   var helper = require_helper();
   module.exports = function(connInfo, cb) {
     var file2 = helper.getFileName();
-    fs13.stat(file2, function(err, stat) {
+    fs14.stat(file2, function(err, stat) {
       if (err || !helper.usePgPass(stat, file2)) {
         return cb(undefined);
       }
-      var st = fs13.createReadStream(file2);
+      var st = fs14.createReadStream(file2);
       helper.getPassword(connInfo, st, cb);
     });
   };
@@ -40257,8 +40339,8 @@ var init_alias_resolver = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/index-manager.js
-import fs13 from "fs";
-import path18 from "path";
+import fs14 from "fs";
+import path19 from "path";
 
 class IndexManager {
   metadataCache = new Map;
@@ -40351,9 +40433,9 @@ class IndexManager {
       const fileMetadata = {};
       let totalSize = 0;
       for (const filePath of indexedFiles) {
-        const fullPath = path18.join(projectPath, filePath);
+        const fullPath = path19.join(projectPath, filePath);
         try {
-          const stat = await fs13.promises.stat(fullPath);
+          const stat = await fs14.promises.stat(fullPath);
           fileMetadata[filePath] = {
             path: filePath,
             mtime: stat.mtimeMs,
@@ -40404,9 +40486,9 @@ class IndexManager {
         if (ig.ignores(match2)) {
           continue;
         }
-        const fullPath = path18.join(projectPath, match2);
+        const fullPath = path19.join(projectPath, match2);
         try {
-          const stat = await fs13.promises.stat(fullPath);
+          const stat = await fs14.promises.stat(fullPath);
           files.set(match2, {
             path: match2,
             mtime: stat.mtimeMs,
@@ -43659,23 +43741,23 @@ var require_auth_config = __commonJS((exports, module) => {
     writeAuthConfig: () => writeAuthConfig
   });
   module.exports = __toCommonJS2(auth_config_exports);
-  var fs14 = __toESM2(__require("fs"));
-  var path19 = __toESM2(__require("path"));
+  var fs15 = __toESM2(__require("fs"));
+  var path20 = __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 path19.join(dataDir, "auth.json");
+    return path20.join(dataDir, "auth.json");
   }
   function readAuthConfig() {
     try {
       const authPath = getAuthConfigPath();
-      if (!fs14.existsSync(authPath)) {
+      if (!fs15.existsSync(authPath)) {
         return null;
       }
-      const content = fs14.readFileSync(authPath, "utf8");
+      const content = fs15.readFileSync(authPath, "utf8");
       if (!content) {
         return null;
       }
@@ -43686,11 +43768,11 @@ var require_auth_config = __commonJS((exports, module) => {
   }
   function writeAuthConfig(config3) {
     const authPath = getAuthConfigPath();
-    const authDir = path19.dirname(authPath);
-    if (!fs14.existsSync(authDir)) {
-      fs14.mkdirSync(authDir, { mode: 504, recursive: true });
+    const authDir = path20.dirname(authPath);
+    if (!fs15.existsSync(authDir)) {
+      fs15.mkdirSync(authDir, { mode: 504, recursive: true });
     }
-    fs14.writeFileSync(authPath, JSON.stringify(config3, null, 2), { mode: 384 });
+    fs15.writeFileSync(authPath, JSON.stringify(config3, null, 2), { mode: 384 });
   }
   function isValidAccessToken(authConfig, expirationBufferMs = 0) {
     if (!authConfig.token)
@@ -43865,8 +43947,8 @@ var require_token_util = __commonJS((exports, module) => {
     saveToken: () => saveToken
   });
   module.exports = __toCommonJS2(token_util_exports);
-  var path19 = __toESM2(__require("path"));
-  var fs14 = __toESM2(__require("fs"));
+  var path20 = __toESM2(__require("path"));
+  var fs15 = __toESM2(__require("fs"));
   var import_token_error = require_token_error();
   var import_token_io = require_token_io();
   var import_auth_config = require_auth_config();
@@ -43878,7 +43960,7 @@ var require_token_util = __commonJS((exports, module) => {
     if (!dataDir) {
       return null;
     }
-    return path19.join(dataDir, vercelFolder);
+    return path20.join(dataDir, vercelFolder);
   }
   async function getVercelToken2(options) {
     const authConfig = (0, import_auth_config.readAuthConfig)();
@@ -43946,11 +44028,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 = path19.join(dir, ".vercel", "project.json");
-    if (!fs14.existsSync(prjPath)) {
+    const prjPath = path20.join(dir, ".vercel", "project.json");
+    if (!fs15.existsSync(prjPath)) {
       throw new import_token_error.VercelOidcTokenError("project.json not found, have you linked your project with `vc link?`");
     }
-    const prj = JSON.parse(fs14.readFileSync(prjPath, "utf8"));
+    const prj = JSON.parse(fs15.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.");
     }
@@ -43961,11 +44043,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 = path19.join(dir, "com.vercel.token", `${projectId}.json`);
+    const tokenPath = path20.join(dir, "com.vercel.token", `${projectId}.json`);
     const tokenJson = JSON.stringify(token);
-    fs14.mkdirSync(path19.dirname(tokenPath), { mode: 504, recursive: true });
-    fs14.writeFileSync(tokenPath, tokenJson);
-    fs14.chmodSync(tokenPath, 432);
+    fs15.mkdirSync(path20.dirname(tokenPath), { mode: 504, recursive: true });
+    fs15.writeFileSync(tokenPath, tokenJson);
+    fs15.chmodSync(tokenPath, 432);
     return;
   }
   function loadToken(projectId) {
@@ -43973,11 +44055,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 = path19.join(dir, "com.vercel.token", `${projectId}.json`);
-    if (!fs14.existsSync(tokenPath)) {
+    const tokenPath = path20.join(dir, "com.vercel.token", `${projectId}.json`);
+    if (!fs15.existsSync(tokenPath)) {
       return null;
     }
-    const token = JSON.parse(fs14.readFileSync(tokenPath, "utf8"));
+    const token = JSON.parse(fs15.readFileSync(tokenPath, "utf8"));
     assertVercelOidcTokenResponse(token);
     return token;
   }
@@ -54819,37 +54901,37 @@ function createOpenAI(options = {}) {
   }, `ai-sdk/openai/${VERSION4}`);
   const createChatModel = (modelId) => new OpenAIChatLanguageModel(modelId, {
     provider: `${providerName}.chat`,
-    url: ({ path: path19 }) => `${baseURL}${path19}`,
+    url: ({ path: path20 }) => `${baseURL}${path20}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createCompletionModel = (modelId) => new OpenAICompletionLanguageModel(modelId, {
     provider: `${providerName}.completion`,
-    url: ({ path: path19 }) => `${baseURL}${path19}`,
+    url: ({ path: path20 }) => `${baseURL}${path20}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createEmbeddingModel = (modelId) => new OpenAIEmbeddingModel(modelId, {
     provider: `${providerName}.embedding`,
-    url: ({ path: path19 }) => `${baseURL}${path19}`,
+    url: ({ path: path20 }) => `${baseURL}${path20}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createImageModel = (modelId) => new OpenAIImageModel(modelId, {
     provider: `${providerName}.image`,
-    url: ({ path: path19 }) => `${baseURL}${path19}`,
+    url: ({ path: path20 }) => `${baseURL}${path20}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createTranscriptionModel = (modelId) => new OpenAITranscriptionModel(modelId, {
     provider: `${providerName}.transcription`,
-    url: ({ path: path19 }) => `${baseURL}${path19}`,
+    url: ({ path: path20 }) => `${baseURL}${path20}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createSpeechModel = (modelId) => new OpenAISpeechModel(modelId, {
     provider: `${providerName}.speech`,
-    url: ({ path: path19 }) => `${baseURL}${path19}`,
+    url: ({ path: path20 }) => `${baseURL}${path20}`,
     headers: getHeaders,
     fetch: options.fetch
   });
@@ -54862,7 +54944,7 @@ function createOpenAI(options = {}) {
   const createResponsesModel = (modelId) => {
     return new OpenAIResponsesLanguageModel(modelId, {
       provider: `${providerName}.responses`,
-      url: ({ path: path19 }) => `${baseURL}${path19}`,
+      url: ({ path: path20 }) => `${baseURL}${path20}`,
       headers: getHeaders,
       fetch: options.fetch,
       fileIdPrefixes: ["file-"]
@@ -71517,26 +71599,26 @@ var require_process = __commonJS((exports, module) => {
 
 // ../../node_modules/detect-libc/lib/filesystem.js
 var require_filesystem = __commonJS((exports, module) => {
-  var fs14 = __require("fs");
+  var fs15 = __require("fs");
   var LDD_PATH = "/usr/bin/ldd";
   var SELF_PATH = "/proc/self/exe";
   var MAX_LENGTH = 2048;
-  var readFileSync2 = (path19) => {
-    const fd = fs14.openSync(path19, "r");
+  var readFileSync2 = (path20) => {
+    const fd = fs15.openSync(path20, "r");
     const buffer = Buffer.alloc(MAX_LENGTH);
-    const bytesRead = fs14.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-    fs14.close(fd, () => {});
+    const bytesRead = fs15.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+    fs15.close(fd, () => {});
     return buffer.subarray(0, bytesRead);
   };
-  var readFile = (path19) => new Promise((resolve4, reject) => {
-    fs14.open(path19, "r", (err, fd) => {
+  var readFile = (path20) => new Promise((resolve4, reject) => {
+    fs15.open(path20, "r", (err, fd) => {
       if (err) {
         reject(err);
       } else {
         const buffer = Buffer.alloc(MAX_LENGTH);
-        fs14.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+        fs15.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
           resolve4(buffer.subarray(0, bytesRead));
-          fs14.close(fd, () => {});
+          fs15.close(fd, () => {});
         });
       }
     });
@@ -71641,11 +71723,11 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     return null;
   };
-  var familyFromInterpreterPath = (path19) => {
-    if (path19) {
-      if (path19.includes("/ld-musl-")) {
+  var familyFromInterpreterPath = (path20) => {
+    if (path20) {
+      if (path20.includes("/ld-musl-")) {
         return MUSL;
-      } else if (path19.includes("/ld-linux-")) {
+      } else if (path20.includes("/ld-linux-")) {
         return GLIBC;
       }
     }
@@ -71690,8 +71772,8 @@ var require_detect_libc = __commonJS((exports, module) => {
     cachedFamilyInterpreter = null;
     try {
       const selfContent = await readFile(SELF_PATH);
-      const path19 = interpreterPath(selfContent);
-      cachedFamilyInterpreter = familyFromInterpreterPath(path19);
+      const path20 = interpreterPath(selfContent);
+      cachedFamilyInterpreter = familyFromInterpreterPath(path20);
     } catch (e) {}
     return cachedFamilyInterpreter;
   };
@@ -71702,8 +71784,8 @@ var require_detect_libc = __commonJS((exports, module) => {
     cachedFamilyInterpreter = null;
     try {
       const selfContent = readFileSync2(SELF_PATH);
-      const path19 = interpreterPath(selfContent);
-      cachedFamilyInterpreter = familyFromInterpreterPath(path19);
+      const path20 = interpreterPath(selfContent);
+      cachedFamilyInterpreter = familyFromInterpreterPath(path20);
     } catch (e) {}
     return cachedFamilyInterpreter;
   };
@@ -73365,18 +73447,18 @@ var require_sharp = __commonJS((exports, module) => {
     `@img/sharp-${runtimePlatform}/sharp.node`,
     "@img/sharp-wasm32/sharp.node"
   ];
-  var path19;
+  var path20;
   var sharp;
   var errors4 = [];
-  for (path19 of paths) {
+  for (path20 of paths) {
     try {
-      sharp = __require(path19);
+      sharp = __require(path20);
       break;
     } catch (err) {
       errors4.push(err);
     }
   }
-  if (sharp && path19.startsWith("@img/sharp-linux-x64") && !sharp._isUsingX64V2()) {
+  if (sharp && path20.startsWith("@img/sharp-linux-x64") && !sharp._isUsingX64V2()) {
     const err = new Error("Prebuilt binaries for linux-x64 require v2 microarchitecture");
     err.code = "Unsupported CPU";
     errors4.push(err);
@@ -76238,15 +76320,15 @@ var require_color = __commonJS((exports, module) => {
     };
   }
   function wrapConversion(toModel, graph) {
-    const path19 = [graph[toModel].parent, toModel];
+    const path20 = [graph[toModel].parent, toModel];
     let fn = conversions_default[graph[toModel].parent][toModel];
     let cur = graph[toModel].parent;
     while (graph[cur].parent) {
-      path19.unshift(graph[cur].parent);
+      path20.unshift(graph[cur].parent);
       fn = link(conversions_default[graph[cur].parent][cur], fn);
       cur = graph[cur].parent;
     }
-    fn.conversion = path19;
+    fn.conversion = path20;
     return fn;
   }
   function route(fromModel) {
@@ -76851,7 +76933,7 @@ var require_output = __commonJS((exports, module) => {
     Copyright 2013 Lovell Fuller and others.
     SPDX-License-Identifier: Apache-2.0
   */
-  var path19 = __require("path");
+  var path20 = __require("path");
   var is = require_is();
   var sharp = require_sharp();
   var formats = new Map([
@@ -76882,9 +76964,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) && path19.resolve(this.options.input.file) === path19.resolve(fileOut)) {
+    } else if (is.string(this.options.input.file) && path20.resolve(this.options.input.file) === path20.resolve(fileOut)) {
       err = new Error("Cannot use same file for input and output");
-    } else if (jp2Regex.test(path19.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
+    } else if (jp2Regex.test(path20.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
       err = errJp2Save();
     }
     if (err) {
@@ -84131,11 +84213,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 path19 = `${baseName}_data${i === 0 ? "" : "_" + i}`;
-            const fullPath = `${options.subfolder ?? ""}/${path19}`;
+            const path20 = `${baseName}_data${i === 0 ? "" : "_" + i}`;
+            const fullPath = `${options.subfolder ?? ""}/${path20}`;
             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: path19, data } : path19);
+              resolve4(data instanceof Uint8Array ? { path: path20, data } : path20);
             }));
           }
         } else if (session_options.externalData !== undefined) {
@@ -97199,7 +97281,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(path19) {
+        async save(path20) {
           let fn;
           if (_env_js__WEBPACK_IMPORTED_MODULE_3__.apis.IS_BROWSER_ENV) {
             if (_env_js__WEBPACK_IMPORTED_MODULE_3__.apis.IS_WEBWORKER_ENV) {
@@ -97207,14 +97289,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 (path20, blob) => {
+            fn = async (path21, blob) => {
               let buffer = await blob.arrayBuffer();
-              node_fs__WEBPACK_IMPORTED_MODULE_5__["default"].writeFileSync(path20, Buffer.from(buffer));
+              node_fs__WEBPACK_IMPORTED_MODULE_5__["default"].writeFileSync(path21, Buffer.from(buffer));
             };
           } else {
             throw new Error("Unable to save because filesystem is disabled in this environment.");
           }
-          await fn(path19, this.toBlob());
+          await fn(path20, this.toBlob());
         }
       }
     },
@@ -97310,11 +97392,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(path19, blob) {
+      function saveBlob(path20, blob) {
         const dataURL = URL.createObjectURL(blob);
         const downloadLink = document.createElement("a");
         downloadLink.href = dataURL;
-        downloadLink.download = path19;
+        downloadLink.download = path20;
         downloadLink.click();
         downloadLink.remove();
         URL.revokeObjectURL(dataURL);
@@ -97915,8 +97997,8 @@ ${fake_token_around_image}` + `${global_img_token}` + image_token.repeat(image_s
       }
 
       class FileCache {
-        constructor(path19) {
-          this.path = path19;
+        constructor(path20) {
+          this.path = path20;
         }
         async match(request) {
           let filePath = node_path__WEBPACK_IMPORTED_MODULE_1__["default"].join(this.path, request);
@@ -98672,20 +98754,20 @@ ${fake_token_around_image}` + `${global_img_token}` + image_token.repeat(image_s
           }
           return this;
         }
-        async save(path19) {
+        async save(path20) {
           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 = path19.split(".").pop().toLowerCase();
+            const extension = path20.split(".").pop().toLowerCase();
             const mime = CONTENT_TYPE_MAP.get(extension) ?? "image/png";
             const blob = await this.toBlob(mime);
-            (0, _core_js__WEBPACK_IMPORTED_MODULE_0__.saveBlob)(path19, blob);
+            (0, _core_js__WEBPACK_IMPORTED_MODULE_0__.saveBlob)(path20, 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(path19);
+            return await img.toFile(path20);
           }
         }
         toSharp() {
@@ -108225,10 +108307,10 @@ Note that ${s.bold("include")} statements only accept relation fields.`, a;
       super(t, "P2023", r);
     }
   };
-  var fs14 = new WeakMap;
+  var fs15 = new WeakMap;
   function Ep(e) {
-    let t = fs14.get(e);
-    return t || (t = Object.entries(e), fs14.set(e, t)), t;
+    let t = fs15.get(e);
+    return t || (t = Object.entries(e), fs15.set(e, t)), t;
   }
   function hs(e, t, r) {
     switch (t.type) {
@@ -112196,7 +112278,7 @@ var require_prisma = __commonJS((exports) => {
   Prisma.JsonNull = JsonNull2;
   Prisma.AnyNull = AnyNull2;
   Prisma.NullTypes = NullTypes2;
-  var path19 = __require("path");
+  var path20 = __require("path");
   exports.Prisma.TransactionIsolationLevel = makeStrictEnum2({
     ReadUncommitted: "ReadUncommitted",
     ReadCommitted: "ReadCommitted",
@@ -123918,10 +124000,10 @@ var init_chunker_code = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/smart-chunker.js
-import path19 from "path";
+import path20 from "path";
 function smartChunk(content, filePath, config3 = {}) {
   const cfg = { ...DEFAULT_CONFIG, ...config3 };
-  const ext2 = path19.extname(filePath).toLowerCase();
+  const ext2 = path20.extname(filePath).toLowerCase();
   const relativePath = filePath;
   const fileImports = isCodeFile(ext2) ? extractFileImports(content, ext2) : undefined;
   let chunks;
@@ -124259,8 +124341,8 @@ var init_embedding_freshness = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/project-indexer.js
-import fs14 from "fs/promises";
-import path20 from "path";
+import fs15 from "fs/promises";
+import path21 from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 async function runWithIndexLock(lockMap, projectId, work) {
   const prevLock = lockMap.get(projectId);
@@ -124303,7 +124385,7 @@ async function indexProjectInternal(deps, projectPath, projectId, options = {})
       dot: false
     });
     const filteredFiles = files.filter((file2) => {
-      const relativePath = path20.relative(projectPath, file2);
+      const relativePath = path21.relative(projectPath, file2);
       const shouldIgnore = ig.ignores(relativePath);
       if (shouldIgnore) {
         logger.debug("Ignoring file per .gitignore during indexing", {
@@ -124343,7 +124425,7 @@ async function indexProjectInternal(deps, projectPath, projectId, options = {})
         });
       }
     }
-    const indexedFilesList = filteredFiles.map((f) => path20.relative(projectPath, f));
+    const indexedFilesList = filteredFiles.map((f) => path21.relative(projectPath, f));
     await deps.indexManager.updateIndexMetadata(projectId, projectPath, indexedFilesList);
     logger.info("Project indexing completed", {
       projectId,
@@ -124473,7 +124555,7 @@ async function ensureFreshIndex(deps, projectId, projectPath, options = {}) {
   let errors4 = 0;
   for (const relativeFilePath of filesToReindex) {
     try {
-      const fullPath = path20.join(projectPath, relativeFilePath);
+      const fullPath = path21.join(projectPath, relativeFilePath);
       const result = await deps.indexFile(fullPath, projectId, projectPath, centralityMap);
       filesIndexed++;
       chunksIndexed += result.chunks;
@@ -124533,8 +124615,8 @@ async function checkSearchAdmission(deps, projectId, projectPath) {
 }
 async function indexFile(deps, filePath, projectId, projectRoot, centralityMap) {
   projectId = await getProjectIdentityAliasResolver().resolve(projectId);
-  const content = await fs14.readFile(filePath, "utf-8");
-  const relativePath = path20.relative(projectRoot, filePath);
+  const content = await fs15.readFile(filePath, "utf-8");
+  const relativePath = path21.relative(projectRoot, filePath);
   const maxFileSize = config2.get("security").maxFileSize || 1024 * 1024;
   if (content.length > maxFileSize) {
     logger.warn("File too large, skipping", {
@@ -124554,7 +124636,7 @@ async function indexFile(deps, filePath, projectId, projectRoot, centralityMap)
       chunkIndex: i,
       totalChunks: chunks.length,
       type: chunk.type,
-      language: path20.extname(filePath).slice(1),
+      language: path21.extname(filePath).slice(1),
       lineStart: chunk.lineStart,
       lineEnd: chunk.lineEnd,
       label: chunk.label,
@@ -126625,8 +126707,8 @@ function stripNul(content) {
 }
 
 // ../../packages/core/dist/services/etl/stages/discover.js
-import fs15 from "fs/promises";
-import path21 from "path";
+import fs16 from "fs/promises";
+import path22 from "path";
 import { createHash as createHash5 } from "crypto";
 
 class DiscoverStage {
@@ -126652,7 +126734,7 @@ class DiscoverStage {
         dot: false,
         absolute: false
       });
-      relPaths = found.map((p) => path21.isAbsolute(p) ? path21.relative(ctx.projectPath, p) : p).filter((p) => !ig.ignores(p) && applyPolicy(p, policy) !== "Drop");
+      relPaths = found.map((p) => path22.isAbsolute(p) ? path22.relative(ctx.projectPath, p) : p).filter((p) => !ig.ignores(p) && applyPolicy(p, policy) !== "Drop");
     }
     if (ctx.resumeCursor?.path) {
       const cursorPath = ctx.resumeCursor.path;
@@ -126711,10 +126793,10 @@ class DiscoverStage {
     return discovered;
   }
   async processFile(ctx, relativePath, forceReindex) {
-    const absolutePath = path21.join(ctx.projectPath, relativePath);
+    const absolutePath = path22.join(ctx.projectPath, relativePath);
     try {
-      const stat = await fs15.stat(absolutePath);
-      const content = stripNul(await fs15.readFile(absolutePath, "utf-8"));
+      const stat = await fs16.stat(absolutePath);
+      const content = stripNul(await fs16.readFile(absolutePath, "utf-8"));
       const contentHash = createHash5("sha256").update(content).digest("hex");
       let needsReparse = forceReindex;
       if (!forceReindex) {
@@ -126758,8 +126840,8 @@ class DiscoverStage {
       ig.add(pattern);
     }
     try {
-      const gitignorePath = path21.join(projectPath, ".gitignore");
-      const gitignoreContent = await fs15.readFile(gitignorePath, "utf8");
+      const gitignorePath = path22.join(projectPath, ".gitignore");
+      const gitignoreContent = await fs16.readFile(gitignorePath, "utf8");
       const rules = gitignoreContent.split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
       ig.add(rules);
@@ -128114,8 +128196,8 @@ function rustUseLeaves(node, source, prefix = []) {
   }
   if (node.type === "use_wildcard")
     return [{ path: [...prefix, "*"], glob: true }];
-  const path22 = rustPathSegments(node, source);
-  return path22.length ? [{ path: [...prefix, ...path22] }] : [];
+  const path23 = rustPathSegments(node, source);
+  return path23.length ? [{ path: [...prefix, ...path23] }] : [];
 }
 function functionalCaptures(captures, source, family) {
   if (family !== "clojure")
@@ -129087,8 +129169,8 @@ var init_structural_runtime = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/parse.js
-import path22 from "path";
-import fs16 from "fs/promises";
+import path23 from "path";
+import fs17 from "fs/promises";
 function resolveChunkerMaxChars() {
   const global2 = Number(process.env.EMBEDDING_MAX_CHARS);
   if (Number.isFinite(global2) && global2 > 0)
@@ -129116,8 +129198,8 @@ class ParseStage {
     const results = new Map;
     let processed = 0;
     const phases = [
-      files.filter((file2) => path22.extname(file2.relativePath).toLowerCase() !== ".h"),
-      files.filter((file2) => path22.extname(file2.relativePath).toLowerCase() === ".h")
+      files.filter((file2) => path23.extname(file2.relativePath).toLowerCase() !== ".h"),
+      files.filter((file2) => path23.extname(file2.relativePath).toLowerCase() === ".h")
     ];
     const batches = phases.flatMap((phase) => Array.from({ length: Math.ceil(phase.length / BATCH_SIZE) }, (_, index) => phase.slice(index * BATCH_SIZE, (index + 1) * BATCH_SIZE)));
     for (const batch of batches) {
@@ -129155,19 +129237,19 @@ class ParseStage {
     return files.map((file2) => results.get(file2.relativePath));
   }
   recordHeaderImporterEvidence(ctx, files, parsedFiles) {
-    const knownHeaders = new Set(files.filter((file2) => path22.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path22.posix.normalize(file2.relativePath)));
+    const knownHeaders = new Set(files.filter((file2) => path23.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path23.posix.normalize(file2.relativePath)));
     const mutable = {
       ...ctx.structuralHeaderEvidenceByFile
     };
     for (const parsed of parsedFiles) {
-      const extension = path22.extname(parsed.file.relativePath).toLowerCase();
+      const extension = path23.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 = path22.posix.normalize(path22.posix.join(path22.posix.dirname(parsed.file.relativePath), imported.specifier));
+        const header = path23.posix.normalize(path23.posix.join(path23.posix.dirname(parsed.file.relativePath), imported.specifier));
         if (!knownHeaders.has(header))
           continue;
         const existing = mutable[header] ?? {};
@@ -129178,9 +129260,9 @@ class ParseStage {
   }
   async parseFile(ctx, file2) {
     if (!file2.needsReparse) {
-      const extension = path22.extname(file2.relativePath).toLowerCase();
+      const extension = path23.extname(file2.relativePath).toLowerCase();
       if ([".c", ".cpp", ".hpp"].includes(extension)) {
-        const content = file2.snapshotContent ?? await fs16.readFile(file2.absolutePath, "utf8");
+        const content = file2.snapshotContent ?? await fs17.readFile(file2.absolutePath, "utf8");
         const outcome = await this.runtime.parse({ extension, source: Buffer.from(content) });
         if (outcome.status === "failed")
           throw new StructuralEtlParseError(file2.relativePath, outcome.failureKind, `Structural evidence parse failed (${outcome.failureKind})`, outcome.diagnosticCount, outcome.diagnostics.slice(0, 10));
@@ -129192,8 +129274,8 @@ class ParseStage {
       return { file: file2, chunks: [], symbols: [], rawImports: [], rawEdges: [] };
     }
     try {
-      const content = file2.snapshotContent ?? await fs16.readFile(file2.absolutePath, "utf-8");
-      const ext2 = path22.extname(file2.relativePath).toLowerCase();
+      const content = file2.snapshotContent ?? await fs17.readFile(file2.absolutePath, "utf-8");
+      const ext2 = path23.extname(file2.relativePath).toLowerCase();
       const chunkerMaxChars = resolveChunkerMaxChars();
       const chunks = smartChunk(content, file2.relativePath, chunkerMaxChars ? { maxChunkChars: chunkerMaxChars } : {});
       let symbols;
@@ -129748,7 +129830,7 @@ var init_resolver = __esm(() => {
 });
 
 // ../../packages/core/dist/services/structural/resolvers/typescript.js
-import path23 from "path";
+import path24 from "path";
 function candidates(identities) {
   return Object.freeze(identities.map((identity) => Object.freeze({
     fqn: identity.fqn,
@@ -129843,7 +129925,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 = path23.posix.normalize(`${candidateBase}${suffix}`);
+      const value = path24.posix.normalize(`${candidateBase}${suffix}`);
       if (!value.startsWith("../") && value !== ".." && known.has(value))
         return value;
     }
@@ -129852,7 +129934,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(path23.posix.join(path23.posix.dirname(fromFile), specifier), known, dialect);
+    return probe(path24.posix.join(path24.posix.dirname(fromFile), specifier), known, dialect);
   }
   const aliases = build.pathAliasesByFile?.[normalizeStructuralFile(fromFile)] ?? build.pathAliases ?? [];
   for (const alias of aliases) {
@@ -130116,7 +130198,7 @@ var init_scripting2 = __esm(() => {
 });
 
 // ../../packages/core/dist/services/structural/resolvers/systems.js
-import path24 from "path";
+import path25 from "path";
 var DIALECTS, SYSTEMS_LANGUAGE_RESOLVER;
 var init_systems2 = __esm(() => {
   init_typescript2();
@@ -130135,7 +130217,7 @@ var init_systems2 = __esm(() => {
           const bindings = item.bindings.map((binding) => binding.imported === "*" && binding.local === "*" && unresolvedTarget && !unresolvedTarget.qualifier ? { ...binding, imported: unresolvedTarget.name, local: unresolvedTarget.name } : binding);
           if (item.specifier === "crate" || item.specifier.startsWith("crate/")) {
             const crateRoot = file2.file.startsWith("src/") ? "src" : "";
-            return { ...item, bindings, specifier: `./${path24.posix.relative(path24.posix.dirname(file2.file), path24.posix.join(crateRoot, item.specifier.replace(/^crate\/?/u, "")))}` };
+            return { ...item, bindings, specifier: `./${path25.posix.relative(path25.posix.dirname(file2.file), path25.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, "")}` };
@@ -130233,8 +130315,8 @@ var init_data_document2 = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/resolve.js
-import path25 from "path";
-import fs17 from "fs";
+import path26 from "path";
+import fs18 from "fs";
 
 class ResolveStage {
   symbolRepository;
@@ -130258,7 +130340,7 @@ class ResolveStage {
     const structuralDocuments = files.flatMap((file2) => {
       if (!file2.structure)
         return [];
-      const language = resolveStructuralLanguage(path25.extname(file2.file.relativePath));
+      const language = resolveStructuralLanguage(path26.extname(file2.file.relativePath));
       if (language.status !== "supported")
         throw new Error(`structural_manifest_missing:${file2.file.relativePath}`);
       return [{
@@ -130270,13 +130352,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(path25.extname(item.file.relativePath).toLowerCase())).map((item) => item.file.relativePath));
+    const skippedStructuralFiles = new Set(files.filter((item) => !item.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path26.extname(item.file.relativePath).toLowerCase())).map((item) => item.file.relativePath));
     const pathAliasesByFile = Object.fromEntries([...knownRelPaths].map((file2) => [
       file2,
       this.structuralAliasesFor(file2, rootAliases, monorepoPackages)
     ]));
     const buildMetadata = { knownFiles: [...knownRelPaths], pathAliasesByFile };
-    const seedRows = repositoryDefinitions.filter((definition) => STRUCTURAL_SEED_EXTENSIONS.has(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 seedRows = repositoryDefinitions.filter((definition) => STRUCTURAL_SEED_EXTENSIONS.has(path26.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))
@@ -130369,7 +130451,7 @@ class ResolveStage {
     if (parsed.file !== definition.file_path) {
       throw new Error(`structural_repository_seed_file_mismatch:${definition.id}`);
     }
-    const language = resolveStructuralLanguage(path25.extname(definition.file_path));
+    const language = resolveStructuralLanguage(path26.extname(definition.file_path));
     if (language.status !== "supported")
       throw new Error(`structural_repository_seed_language:${definition.id}`);
     let identity;
@@ -130421,7 +130503,7 @@ class ResolveStage {
     });
   }
   resolveFile(parsed, projectPath, knownRelPaths, rootAliases, monorepoPackages, symbolIndex, knownFqns) {
-    const fromDir = path25.dirname(path25.join(projectPath, parsed.file.relativePath));
+    const fromDir = path26.dirname(path26.join(projectPath, parsed.file.relativePath));
     const packageAliases = this.getPackageAliases(parsed.file.relativePath, monorepoPackages);
     const allAliases = [...packageAliases, ...rootAliases];
     const resolvedImports = parsed.rawImports.map((raw2) => {
@@ -130492,7 +130574,7 @@ class ResolveStage {
         index.set(def.name, `${def.file_path}#${def.name}`);
       }
     } catch (err) {
-      const skippedStructural = files.some((file2) => !file2.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path25.extname(file2.file.relativePath).toLowerCase()));
+      const skippedStructural = files.some((file2) => !file2.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path26.extname(file2.file.relativePath).toLowerCase()));
       if (skippedStructural)
         throw new Error("structural_repository_seed_failed", { cause: err });
       logger.warn("buildSymbolIndex: repo seed failed, in-batch only", {
@@ -130516,7 +130598,7 @@ class ResolveStage {
   }
   resolveSpecifier(specifier, fromDir, projectPath, knownRelPaths, aliases) {
     if (specifier.startsWith("./") || specifier.startsWith("../")) {
-      const resolved = this.probeExtensions(path25.resolve(fromDir, specifier), projectPath, knownRelPaths);
+      const resolved = this.probeExtensions(path26.resolve(fromDir, specifier), projectPath, knownRelPaths);
       return { resolvedPath: resolved, external: false };
     }
     for (const alias of aliases) {
@@ -130524,8 +130606,8 @@ class ResolveStage {
         const suffix = specifier.slice(alias.prefix.length);
         for (const target of alias.targets) {
           const cleanTarget = target.replace(/\/\*$/, "");
-          const basePath = alias.packagePath ? path25.join(projectPath, alias.packagePath) : projectPath;
-          const absPath = path25.join(basePath, cleanTarget + suffix);
+          const basePath = alias.packagePath ? path26.join(projectPath, alias.packagePath) : projectPath;
+          const absPath = path26.join(basePath, cleanTarget + suffix);
           const resolved = this.probeExtensions(absPath, projectPath, knownRelPaths);
           if (resolved)
             return { resolvedPath: resolved, external: false };
@@ -130541,7 +130623,7 @@ class ResolveStage {
       ...TS_EXTENSIONS.map((ext2) => absPath.replace(/\.[^.]+$/, ext2))
     ];
     for (const candidate2 of candidates2) {
-      const rel = path25.relative(projectPath, candidate2).replace(/\\/g, "/");
+      const rel = path26.relative(projectPath, candidate2).replace(/\\/g, "/");
       if (knownRelPaths.has(rel))
         return rel;
     }
@@ -130549,9 +130631,9 @@ class ResolveStage {
   }
   loadTsConfigPaths(projectPath, packageBase) {
     const aliases = [];
-    const tsconfigPath = path25.join(projectPath, "tsconfig.json");
+    const tsconfigPath = path26.join(projectPath, "tsconfig.json");
     try {
-      const raw2 = fs17.readFileSync(tsconfigPath, "utf-8");
+      const raw2 = fs18.readFileSync(tsconfigPath, "utf-8");
       const stripped = raw2.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
       const tsconfig = JSON.parse(stripped);
       const paths = tsconfig?.compilerOptions?.paths ?? {};
@@ -130580,7 +130662,7 @@ class ResolveStage {
       }
     }
     for (const packageRelPath of packagePaths) {
-      const absPackagePath = path25.join(projectPath, packageRelPath);
+      const absPackagePath = path26.join(projectPath, packageRelPath);
       const aliases = this.loadTsConfigPaths(absPackagePath, packageRelPath);
       if (aliases.length > 0) {
         packages.push({
@@ -130610,7 +130692,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 ? path25.posix.join(alias.packagePath, target) : target)
+      targets: alias.targets.map((target) => alias.packagePath ? path26.posix.join(alias.packagePath, target) : target)
     }));
   }
 }
@@ -130674,7 +130756,7 @@ var init_with_deadlock_retry = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/load.js
-import path26 from "path";
+import path27 from "path";
 function formatDuration(ms) {
   const totalSec = Math.max(0, Math.round(ms / 1000));
   if (totalSec < 60)
@@ -130951,7 +131033,7 @@ class LoadStage {
     const filePath = file2.file.relativePath;
     const batch = buildSymbolPersistenceBatch(ctx.projectId, file2);
     if (ctx.graphGenerationLease) {
-      const manifest = getLanguageManifestEntry(path26.extname(filePath));
+      const manifest = getLanguageManifestEntry(path27.extname(filePath));
       const diagnostics2 = (file2.structuralDiagnostics ?? []).slice(0, 10).map((diagnostic2) => ({
         code: diagnostic2.code,
         severity: diagnostic2.severity,
@@ -131408,9 +131490,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 path27 from "path";
+import path28 from "path";
 function buildHeaderLanguageEvidence(files) {
-  const headers = new Set(files.filter((file2) => path27.posix.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path27.posix.normalize(file2.relativePath)));
+  const headers = new Set(files.filter((file2) => path28.posix.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path28.posix.normalize(file2.relativePath)));
   const mutable = new Map;
   const entry2 = (header) => {
     let value = mutable.get(header);
@@ -131421,7 +131503,7 @@ function buildHeaderLanguageEvidence(files) {
     return value;
   };
   for (const file2 of files) {
-    if (path27.posix.basename(file2.relativePath) !== "compile_commands.json" || file2.snapshotContent === undefined)
+    if (path28.posix.basename(file2.relativePath) !== "compile_commands.json" || file2.snapshotContent === undefined)
       continue;
     let commands;
     try {
@@ -131437,11 +131519,11 @@ function buildHeaderLanguageEvidence(files) {
       const record3 = command;
       if (typeof record3.file !== "string")
         continue;
-      const projectRoot = path27.resolve(file2.absolutePath, ...file2.relativePath.split("/").map(() => ".."));
-      const commandDirectory = typeof record3.directory === "string" ? path27.resolve(projectRoot, record3.directory) : projectRoot;
-      const absoluteInput = path27.resolve(commandDirectory, record3.file);
-      const relative2 = path27.relative(projectRoot, absoluteInput);
-      const header = path27.posix.normalize(relative2.replaceAll(path27.sep, "/"));
+      const projectRoot = path28.resolve(file2.absolutePath, ...file2.relativePath.split("/").map(() => ".."));
+      const commandDirectory = typeof record3.directory === "string" ? path28.resolve(projectRoot, record3.directory) : projectRoot;
+      const absoluteInput = path28.resolve(commandDirectory, record3.file);
+      const relative2 = path28.relative(projectRoot, absoluteInput);
+      const header = path28.posix.normalize(relative2.replaceAll(path28.sep, "/"));
       if (!headers.has(header))
         continue;
       const invocation = typeof record3.command === "string" ? record3.command : Array.isArray(record3.arguments) ? record3.arguments.join(" ") : "";
@@ -131988,9 +132070,9 @@ var init_acquire_indexing_lease = __esm(() => {
 
 // ../../packages/core/dist/services/project-identity/project-root-identity.js
 import { realpath as realpath2 } from "fs/promises";
-import path28 from "path";
+import path29 from "path";
 async function canonicalizeProjectRoot(projectPath, canonicalize = realpath2) {
-  return canonicalize(path28.resolve(projectPath));
+  return canonicalize(path29.resolve(projectPath));
 }
 async function assertProjectRootReuse(options) {
   if (!options.storedProjectPath || options.forceReindex)
@@ -131998,9 +132080,9 @@ async function assertProjectRootReuse(options) {
   const canonicalize = options.canonicalize ?? realpath2;
   let storedCanonical;
   try {
-    storedCanonical = await canonicalize(path28.resolve(options.storedProjectPath));
+    storedCanonical = await canonicalize(path29.resolve(options.storedProjectPath));
   } catch {
-    storedCanonical = path28.resolve(options.storedProjectPath);
+    storedCanonical = path29.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");
@@ -132743,16 +132825,16 @@ function detectRoutes(httpEdges, defs, opts = {}) {
   const seen = new Set;
   const out = [];
   for (const e of httpEdges) {
-    const path29 = e.route;
-    if (!path29)
+    const path30 = e.route;
+    if (!path30)
       continue;
     const method = (e.method ?? "ANY").toUpperCase();
-    const key = method + " " + path29;
+    const key = method + " " + path30;
     if (seen.has(key))
       continue;
     seen.add(key);
     out.push({
-      path: path29,
+      path: path30,
       method: e.method,
       file: e.fromFile,
       handler: e.targetFqn ?? e.symbolName
@@ -132763,12 +132845,12 @@ function detectRoutes(httpEdges, defs, opts = {}) {
       continue;
     const parsed = parseRouteName(d.name);
     const method = parsed?.method ?? "ANY";
-    const path29 = parsed?.path ?? d.name;
-    const key = method + " " + path29;
+    const path30 = parsed?.path ?? d.name;
+    const key = method + " " + path30;
     if (seen.has(key))
       continue;
     seen.add(key);
-    out.push({ path: path29, method: parsed?.method, file: d.filePath, handler: d.name });
+    out.push({ path: path30, method: parsed?.method, file: d.filePath, handler: d.name });
   }
   for (const d of defs) {
     const parsed = parseRouteName(d.name);
@@ -132989,8 +133071,8 @@ __export(exports_symbol_graph_service, {
   symbolGraphService: () => symbolGraphService,
   SymbolGraphService: () => SymbolGraphService
 });
-import path29 from "path";
-import fs18 from "fs/promises";
+import path30 from "path";
+import fs19 from "fs/promises";
 
 class SymbolGraphService {
   identityLookup;
@@ -133318,7 +133400,7 @@ class SymbolGraphService {
   async readSnippet(relativePath, lineStart, lineEnd, projectId) {
     try {
       const absolutePath = await this.resolveToAbsolute(relativePath, projectId);
-      const content = await fs18.readFile(absolutePath, "utf-8");
+      const content = await fs19.readFile(absolutePath, "utf-8");
       const lines = content.split(`
 `);
       return lines.slice(Math.max(0, lineStart - 1), Math.min(lines.length, lineEnd)).join(`
@@ -133330,7 +133412,7 @@ class SymbolGraphService {
   async readContext(relativePath, lineNumber, contextLines, projectId) {
     try {
       const absolutePath = await this.resolveToAbsolute(relativePath, projectId);
-      const content = await fs18.readFile(absolutePath, "utf-8");
+      const content = await fs19.readFile(absolutePath, "utf-8");
       const lines = content.split(`
 `);
       const start = Math.max(0, lineNumber - contextLines - 1);
@@ -133343,7 +133425,7 @@ class SymbolGraphService {
   }
   async resolveToAbsolute(relativePath, projectId) {
     const root = await this.getProjectRoot(projectId);
-    return root ? path29.resolve(root, relativePath) : relativePath;
+    return root ? path30.resolve(root, relativePath) : relativePath;
   }
   async getProjectRoot(projectId) {
     const cached2 = this.projectRootCache.get(projectId);
@@ -133486,7 +133568,7 @@ var init_workspace_manager = __esm(() => {
 });
 
 // ../../packages/core/dist/tools/index_project.js
-import path30 from "path";
+import path31 from "path";
 
 class IndexProjectTool {
   name = "index_project";
@@ -133534,7 +133616,7 @@ class IndexProjectTool {
     try {
       await assertParserReadyForIndexing();
       const canonicalProjectPath = await canonicalizeProjectRoot(projectPath);
-      const finalProjectId = projectId || path30.basename(canonicalProjectPath) || "default";
+      const finalProjectId = projectId || path31.basename(canonicalProjectPath) || "default";
       const existing = await workspaceManager.getWorkspace(finalProjectId);
       await assertProjectRootReuse({
         projectId: finalProjectId,
@@ -134087,17 +134169,17 @@ function applyReplacer(root, replacer) {
     return transformChildren(root, replacer, []);
   return transformChildren(normalizeValue(replacedRoot), replacer, []);
 }
-function transformChildren(value, replacer, path31) {
+function transformChildren(value, replacer, path32) {
   if (isJsonObject(value))
-    return transformObject(value, replacer, path31);
+    return transformObject(value, replacer, path32);
   if (isJsonArray(value))
-    return transformArray(value, replacer, path31);
+    return transformArray(value, replacer, path32);
   return value;
 }
-function transformObject(obj, replacer, path31) {
+function transformObject(obj, replacer, path32) {
   const result = {};
   for (const [key, value] of Object.entries(obj)) {
-    const childPath = [...path31, key];
+    const childPath = [...path32, key];
     const replacedValue = replacer(key, value, childPath);
     if (replacedValue === undefined)
       continue;
@@ -134105,11 +134187,11 @@ function transformObject(obj, replacer, path31) {
   }
   return result;
 }
-function transformArray(arr, replacer, path31) {
+function transformArray(arr, replacer, path32) {
   const result = [];
   for (let i = 0;i < arr.length; i++) {
     const value = arr[i];
-    const childPath = [...path31, i];
+    const childPath = [...path32, i];
     const replacedValue = replacer(String(i), value, childPath);
     if (replacedValue === undefined)
       continue;
@@ -138799,7 +138881,7 @@ var TOOL_NAME_NORMALIZE, classifyToolCall = (_source, payload) => {
   if (lowerPrompt.includes("blocked on") || lowerPrompt.includes("waiting on") || lowerPrompt.includes("can't proceed") || lowerPrompt.includes("stuck on")) {
     return "blocked-on";
   }
-  if (lowerPrompt.startsWith("/persona") || lowerPrompt.startsWith("act as") || lowerPrompt.startsWith("you are a")) {
+  if (lowerPrompt.startsWith("act as") || lowerPrompt.startsWith("you are a")) {
     return "role";
   }
   return "user-prompts";
@@ -139200,9 +139282,9 @@ var init_session_pin_store = __esm(() => {
 });
 
 // ../../packages/core/dist/services/hooks/attribution-resolver.js
-import fs19 from "fs";
+import fs20 from "fs";
 import os9 from "os";
-import path31 from "path";
+import path32 from "path";
 
 class PgWorkspaceRootProvider {
   cache = null;
@@ -139252,7 +139334,7 @@ class AttributionResolver {
     this.pins = options.pins ?? new SessionPinStore;
     this.canonicalize = options.canonicalize ?? defaultCanonicalize;
     this.homedir = options.homedir ?? os9.homedir;
-    this.fsRoot = options.fsRoot ?? (() => path31.parse(path31.sep).root);
+    this.fsRoot = options.fsRoot ?? (() => path32.parse(path32.sep).root);
   }
   async resolve(input) {
     const caller = input.callerProjectId;
@@ -139303,7 +139385,7 @@ class AttributionResolver {
     }
     let bestPath = null;
     for (const candidate2 of byPath.keys()) {
-      if (canonicalCwd === candidate2 || canonicalCwd.startsWith(candidate2.endsWith(path31.sep) ? candidate2 : candidate2 + path31.sep)) {
+      if (canonicalCwd === candidate2 || canonicalCwd.startsWith(candidate2.endsWith(path32.sep) ? candidate2 : candidate2 + path32.sep)) {
         if (bestPath === null || candidate2.length > bestPath.length) {
           bestPath = candidate2;
         }
@@ -139326,7 +139408,7 @@ class AttributionResolver {
       return projectPath2;
     const fsRoot = this.fsRoot();
     let normalized = projectPath2;
-    while (normalized.length > fsRoot.length && normalized.endsWith(path31.sep)) {
+    while (normalized.length > fsRoot.length && normalized.endsWith(path32.sep)) {
       normalized = normalized.slice(0, -1);
     }
     return normalized;
@@ -139334,10 +139416,10 @@ class AttributionResolver {
 }
 function defaultCanonicalize(cwd) {
   try {
-    return fs19.realpathSync(cwd);
+    return fs20.realpathSync(cwd);
   } catch {
     try {
-      return path31.resolve(cwd);
+      return path32.resolve(cwd);
     } catch {
       return;
     }
@@ -140086,31 +140168,31 @@ class TracePathService {
     const chains = [];
     const seen = new Set;
     let walks = 0;
-    const walk = (fqn, path32) => {
+    const walk = (fqn, path33) => {
       if (chains.length >= CHAIN_CAP)
         return;
       if (walks >= MAX_WALKS)
         return;
       walks++;
-      const key = path32.join("\u2192");
+      const key = path33.join("\u2192");
       if (seen.has(key))
         return;
       seen.add(key);
       const next = adj.get(fqn);
       if (!next || next.length === 0 || !whoHasChild.has(fqn)) {
-        if (path32.length > 1)
-          chains.push(path32.map((n) => this.fqnToName(n)).join(" \u2192 "));
+        if (path33.length > 1)
+          chains.push(path33.map((n) => this.fqnToName(n)).join(" \u2192 "));
         return;
       }
       for (const child of next) {
         if (chains.length >= CHAIN_CAP || walks >= MAX_WALKS)
           return;
-        if (path32.includes(child)) {
-          const cycled = [...path32, `${this.fqnToName(child)}\u21BA`];
+        if (path33.includes(child)) {
+          const cycled = [...path33, `${this.fqnToName(child)}\u21BA`];
           chains.push(cycled.map((n) => n).join(" \u2192 "));
           continue;
         }
-        walk(child, [...path32, child]);
+        walk(child, [...path33, child]);
       }
     };
     for (const seed of seeds) {
@@ -140943,7 +141025,7 @@ var init_get_architecture = __esm(() => {
 });
 
 // ../../packages/core/dist/services/file-read/file-content-cache.js
-import fs20 from "fs/promises";
+import fs21 from "fs/promises";
 
 class FileContentCache {
   extractMetadata;
@@ -140976,7 +141058,7 @@ class FileContentCache {
         metadata: cached2.metadata
       };
     }
-    const content = await fs20.readFile(filePath, "utf-8");
+    const content = await fs21.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, {
@@ -140993,7 +141075,7 @@ var init_file_content_cache = __esm(() => {
 });
 
 // ../../packages/core/dist/services/file-read/file-metadata.js
-import path32 from "path";
+import path33 from "path";
 
 class FileMetadataExtractor {
   symbolGraph;
@@ -141029,7 +141111,7 @@ class FileMetadataExtractor {
     return metadata;
   }
   detectLanguage(filePath) {
-    const ext2 = path32.extname(filePath).toLowerCase();
+    const ext2 = path33.extname(filePath).toLowerCase();
     const languageMap2 = {
       ".ts": "TypeScript",
       ".tsx": "TypeScript",
@@ -141151,7 +141233,7 @@ var init_line_range = __esm(() => {
 });
 
 // ../../packages/core/dist/services/file-read/path-containment.js
-import path33 from "path";
+import path34 from "path";
 
 class PathContainment {
   projectRoots;
@@ -141159,14 +141241,14 @@ class PathContainment {
     this.projectRoots = projectRoots;
   }
   async resolveFilePath(filePath, projectId) {
-    if (path33.isAbsolute(filePath)) {
-      return path33.resolve(filePath);
+    if (path34.isAbsolute(filePath)) {
+      return path34.resolve(filePath);
     }
     if (projectId) {
       const root = await this.projectRoots.getProjectRoot(projectId);
       if (root) {
         const cleaned = sanitizeFilePath(filePath);
-        return path33.resolve(root, cleaned);
+        return path34.resolve(root, cleaned);
       }
       return null;
     }
@@ -141177,17 +141259,17 @@ class PathContainment {
     if (projectId) {
       const root = await this.projectRoots.getProjectRoot(projectId);
       if (root)
-        roots.push(path33.resolve(root));
+        roots.push(path34.resolve(root));
     }
-    roots.push(path33.resolve(process.cwd()));
+    roots.push(path34.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(path33.resolve(extra));
+      roots.push(path34.resolve(extra));
     }
-    const target = path33.resolve(absoluteFilePath);
+    const target = path34.resolve(absoluteFilePath);
     for (const root of roots) {
-      const rel = path33.relative(root, target);
-      if (rel !== "" && !rel.startsWith("..") && !path33.isAbsolute(rel)) {
+      const rel = path34.relative(root, target);
+      if (rel !== "" && !rel.startsWith("..") && !path34.isAbsolute(rel)) {
         return { allowed: true };
       }
       if (rel === "")
@@ -144433,9 +144515,9 @@ var init_inference_probe = __esm(() => {
 });
 
 // ../../packages/core/dist/services/health/local-health-checker.js
-import fs21 from "fs/promises";
+import fs22 from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import path34 from "path";
+import path35 from "path";
 
 class LocalHealthChecker {
   dataDir = config2.get("dataDir");
@@ -144513,10 +144595,10 @@ class LocalHealthChecker {
     const start = Date.now();
     try {
       if (!existsSync3(this.dataDir))
-        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);
+        await fs22.mkdir(this.dataDir, { recursive: true });
+      const probe2 = path35.join(this.dataDir, ".health-check-test");
+      await fs22.writeFile(probe2, "ok");
+      await fs22.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}` };
@@ -146653,9 +146735,9 @@ var init_scheduler2 = __esm(() => {
 });
 
 // ../../packages/core/dist/services/pricing/models-dev-client.js
-import fs22 from "fs/promises";
+import fs23 from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import path35 from "path";
+import path36 from "path";
 function getModelsDevClient() {
   if (!clientInstance) {
     clientInstance = new ModelsDevClient;
@@ -146675,7 +146757,7 @@ var init_models_dev_client = __esm(() => {
     memoryCacheTimestamp = 0;
     getLocalCachePath() {
       const dataDir = config2.get("dataDir");
-      return path35.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
+      return path36.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
     }
     async loadLocalCache() {
       const cachePath = this.getLocalCachePath();
@@ -146683,7 +146765,7 @@ var init_models_dev_client = __esm(() => {
         if (!existsSync4(cachePath)) {
           return null;
         }
-        const content = await fs22.readFile(cachePath, "utf-8");
+        const content = await fs23.readFile(cachePath, "utf-8");
         const data = JSON.parse(content);
         const age = Date.now() - data.timestamp;
         if (age > ModelsDevClient.LOCAL_CACHE_TTL) {
@@ -146710,14 +146792,14 @@ var init_models_dev_client = __esm(() => {
     async saveLocalCache(models) {
       const cachePath = this.getLocalCachePath();
       try {
-        const dir = path35.dirname(cachePath);
-        await fs22.mkdir(dir, { recursive: true });
+        const dir = path36.dirname(cachePath);
+        await fs23.mkdir(dir, { recursive: true });
         const data = {
           timestamp: Date.now(),
           version: "1.0.0",
           models: Object.fromEntries(models)
         };
-        await fs22.writeFile(cachePath, JSON.stringify(data), "utf-8");
+        await fs23.writeFile(cachePath, JSON.stringify(data), "utf-8");
         logger.debug("Saved pricing to local cache", {
           models: models.size,
           path: cachePath
@@ -147047,7 +147129,7 @@ var init_models_dev_client = __esm(() => {
       const cachePath = this.getLocalCachePath();
       try {
         if (existsSync4(cachePath)) {
-          await fs22.unlink(cachePath);
+          await fs23.unlink(cachePath);
           logger.debug("Local pricing cache file deleted");
         }
       } catch (error51) {
@@ -152606,33 +152688,33 @@ var require_URL = __commonJS((exports, module) => {
         else
           return basepath.substring(0, lastslash + 1) + refpath;
       }
-      function remove_dot_segments(path36) {
-        if (!path36)
-          return path36;
+      function remove_dot_segments(path37) {
+        if (!path37)
+          return path37;
         var output = "";
-        while (path36.length > 0) {
-          if (path36 === "." || path36 === "..") {
-            path36 = "";
+        while (path37.length > 0) {
+          if (path37 === "." || path37 === "..") {
+            path37 = "";
             break;
           }
-          var twochars = path36.substring(0, 2);
-          var threechars = path36.substring(0, 3);
-          var fourchars = path36.substring(0, 4);
+          var twochars = path37.substring(0, 2);
+          var threechars = path37.substring(0, 3);
+          var fourchars = path37.substring(0, 4);
           if (threechars === "../") {
-            path36 = path36.substring(3);
+            path37 = path37.substring(3);
           } else if (twochars === "./") {
-            path36 = path36.substring(2);
+            path37 = path37.substring(2);
           } else if (threechars === "/./") {
-            path36 = "/" + path36.substring(3);
-          } else if (twochars === "/." && path36.length === 2) {
-            path36 = "/";
-          } else if (fourchars === "/../" || threechars === "/.." && path36.length === 3) {
-            path36 = "/" + path36.substring(4);
+            path37 = "/" + path37.substring(3);
+          } else if (twochars === "/." && path37.length === 2) {
+            path37 = "/";
+          } else if (fourchars === "/../" || threechars === "/.." && path37.length === 3) {
+            path37 = "/" + path37.substring(4);
             output = output.replace(/\/?[^\/]*$/, "");
           } else {
-            var segment = path36.match(/(\/?([^\/]*))/)[0];
+            var segment = path37.match(/(\/?([^\/]*))/)[0];
             output += segment;
-            path36 = path36.substring(segment.length);
+            path37 = path37.substring(segment.length);
           }
         }
         return output;
@@ -164702,21 +164784,21 @@ function jsonToKeyPathChunks(value, label = "$") {
   walk(value, label, out);
   return out;
 }
-function walk(val, path36, out) {
+function walk(val, path37, out) {
   if (val === null || val === undefined)
     return;
   if (Array.isArray(val)) {
     if (val.length === 0) {
-      out.push({ path: path36, content: `**${path36}** = _[]_` });
+      out.push({ path: path37, content: `**${path37}** = _[]_` });
       return;
     }
     if (val.every((v) => v !== null && typeof v === "object")) {
-      val.forEach((v, i) => walk(v, `${path36}[${i}]`, out));
+      val.forEach((v, i) => walk(v, `${path37}[${i}]`, out));
       return;
     }
     const items = val.map((v) => `- \`${String(v)}\``).join(`
 `);
-    out.push({ path: path36, content: `**${path36}**
+    out.push({ path: path37, content: `**${path37}**
 
 ${items}` });
     return;
@@ -164724,16 +164806,16 @@ ${items}` });
   if (typeof val === "object") {
     const entries = Object.entries(val);
     if (entries.length === 0) {
-      out.push({ path: path36, content: `**${path36}** = _{}_` });
+      out.push({ path: path37, content: `**${path37}** = _{}_` });
       return;
     }
     for (const [k, v] of entries) {
       const safeKey = /^[A-Za-z_$][\w$]*$/.test(k) ? k : JSON.stringify(k);
-      walk(v, `${path36}.${safeKey}`, out);
+      walk(v, `${path37}.${safeKey}`, out);
     }
     return;
   }
-  out.push({ path: path36, content: `**${path36}** = \`${String(val)}\`` });
+  out.push({ path: path37, content: `**${path37}** = \`${String(val)}\`` });
 }
 var gfm, STRIP_SELECTORS, tdCache = null;
 var init_html_to_md = __esm(() => {
@@ -165500,8 +165582,8 @@ var init_hook_service = __esm(() => {
 
 // ../../packages/core/dist/services/bootstrap/bootstrap-service.js
 import { randomUUID as randomUUID9 } from "crypto";
-import fs23 from "fs";
-import path36 from "path";
+import fs24 from "fs";
+import path37 from "path";
 import { spawn as spawn2 } from "child_process";
 function readBootstrapConfig() {
   try {
@@ -165661,9 +165743,9 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
   }
   try {
     for (const name26 of README_CANDIDATES) {
-      const p = path36.join(projectRoot, name26);
-      if (fs23.existsSync(p) && fs23.statSync(p).isFile()) {
-        const buf = fs23.readFileSync(p);
+      const p = path37.join(projectRoot, name26);
+      if (fs24.existsSync(p) && fs24.statSync(p).isFile()) {
+        const buf = fs24.readFileSync(p);
         signals.readme = buf.slice(0, MAX_README_BYTES).toString("utf8");
         break;
       }
@@ -165672,14 +165754,14 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
     logger.debug("bootstrap scan: README read failed", { error: e.message });
   }
   try {
-    const docsDir = path36.join(projectRoot, "docs");
-    if (fs23.existsSync(docsDir) && fs23.statSync(docsDir).isDirectory()) {
+    const docsDir = path37.join(projectRoot, "docs");
+    if (fs24.existsSync(docsDir) && fs24.statSync(docsDir).isDirectory()) {
       const entries = walkMarkdown(docsDir).slice(0, MAX_DOCS);
       for (const rel of entries) {
         try {
-          const buf = fs23.readFileSync(rel);
+          const buf = fs24.readFileSync(rel);
           signals.docs.push({
-            path: path36.relative(projectRoot, rel),
+            path: path37.relative(projectRoot, rel),
             snippet: buf.slice(0, MAX_DOC_BYTES).toString("utf8")
           });
         } catch {}
@@ -165690,10 +165772,10 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
   }
   try {
     for (const name26 of MANIFEST_FILES) {
-      const p = path36.join(projectRoot, name26);
-      if (!fs23.existsSync(p) || !fs23.statSync(p).isFile())
+      const p = path37.join(projectRoot, name26);
+      if (!fs24.existsSync(p) || !fs24.statSync(p).isFile())
         continue;
-      const raw2 = fs23.readFileSync(p).slice(0, MAX_MANIFEST_BYTES).toString("utf8");
+      const raw2 = fs24.readFileSync(p).slice(0, MAX_MANIFEST_BYTES).toString("utf8");
       const kind = name26;
       if (name26 === "package.json") {
         try {
@@ -165733,12 +165815,12 @@ function walkMarkdown(dir) {
     const cur = stack.pop();
     let entries;
     try {
-      entries = fs23.readdirSync(cur, { withFileTypes: true });
+      entries = fs24.readdirSync(cur, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const e of entries) {
-      const full = path36.join(cur, e.name);
+      const full = path37.join(cur, e.name);
       if (e.isDirectory()) {
         if (e.name === "node_modules" || e.name.startsWith("."))
           continue;
@@ -169268,7 +169350,7 @@ class StdioServerTransport {
 }
 
 // src/index.ts
-import fs26 from "fs/promises";
+import fs27 from "fs/promises";
 
 // src/api-client.ts
 init_config();
@@ -169378,8 +169460,8 @@ init_dist();
 init_dist();
 init_dist15();
 init_dist();
-import fs24 from "fs/promises";
-import path37 from "path";
+import fs25 from "fs/promises";
+import path38 from "path";
 var _indexProjectTool = null;
 function indexProjectTool() {
   if (!_indexProjectTool)
@@ -169682,8 +169764,8 @@ class EmbeddedApiClient {
         } else {
           end = start + 20;
         }
-        const absolutePath = path37.join(workspace.project_path, file2);
-        const content = await fs24.readFile(absolutePath, "utf-8");
+        const absolutePath = path38.join(workspace.project_path, file2);
+        const content = await fs25.readFile(absolutePath, "utf-8");
         const lines = content.split(/\r?\n/);
         const slice = lines.slice(start - 1, Math.min(lines.length, end));
         const formatted = slice.map((text3, idx) => ({ lineNumber: start + idx, content: text3 }));
@@ -169938,22 +170020,22 @@ class EmbeddedApiClient {
   async uploadAndIndex(params) {
     const rawBase = params.projectId || params.projectPath.replace(/\\/g, "/").split("/").filter(Boolean).pop() || "default";
     const finalProjectId = rawBase.replace(/[^a-zA-Z0-9_.-]/g, "_").slice(0, 128);
-    const uploadRoot = process.env.MASSA_AI_UPLOAD_DIR || 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 uploadRoot = process.env.MASSA_AI_UPLOAD_DIR || path38.join(getGlobalDataDir(), "uploads");
+    const stagingDir = path38.resolve(uploadRoot, finalProjectId);
+    await fs25.rm(stagingDir, { recursive: true, force: true });
+    await fs25.mkdir(stagingDir, { recursive: true });
     const WRITE_BATCH = 20;
     for (let i = 0;i < params.files.length; i += WRITE_BATCH) {
       await Promise.all(params.files.slice(i, i + WRITE_BATCH).map(async (file2) => {
-        if (path37.isAbsolute(file2.relativePath) || file2.relativePath.includes("..")) {
+        if (path38.isAbsolute(file2.relativePath) || file2.relativePath.includes("..")) {
           throw new Error(`Invalid file path: ${file2.relativePath}`);
         }
-        const dest = path37.resolve(stagingDir, file2.relativePath.replace(/\//g, path37.sep));
-        if (!dest.startsWith(stagingDir + path37.sep)) {
+        const dest = path38.resolve(stagingDir, file2.relativePath.replace(/\//g, path38.sep));
+        if (!dest.startsWith(stagingDir + path38.sep)) {
           throw new Error(`Path escapes staging directory: ${file2.relativePath}`);
         }
-        await fs24.mkdir(path37.dirname(dest), { recursive: true });
-        await fs24.writeFile(dest, file2.content, "utf-8");
+        await fs25.mkdir(path38.dirname(dest), { recursive: true });
+        await fs25.writeFile(dest, file2.content, "utf-8");
       }));
     }
     return await indexProjectTool().handle({
@@ -170453,8 +170535,8 @@ class EmbeddedApiClient {
 
 // src/file-collector.ts
 init_config();
-import fs25 from "fs/promises";
-import path38 from "path";
+import fs26 from "fs/promises";
+import path39 from "path";
 var SKIP_DIRS = new Set([
   "node_modules",
   ".git",
@@ -170495,7 +170577,7 @@ async function walk2(root2, dir, files, state, allowed) {
     return;
   let entries;
   try {
-    entries = await fs25.readdir(dir, { withFileTypes: true });
+    entries = await fs26.readdir(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -170504,22 +170586,22 @@ async function walk2(root2, dir, files, state, allowed) {
       break;
     if (entry2.isDirectory()) {
       if (!SKIP_DIRS.has(entry2.name) && !entry2.name.startsWith(".")) {
-        await walk2(root2, path38.join(dir, entry2.name), files, state, allowed);
+        await walk2(root2, path39.join(dir, entry2.name), files, state, allowed);
       }
     } else if (entry2.isFile()) {
-      const ext2 = path38.extname(entry2.name).toLowerCase();
+      const ext2 = path39.extname(entry2.name).toLowerCase();
       if (!allowed.has(ext2))
         continue;
-      const fullPath = path38.join(dir, entry2.name);
+      const fullPath = path39.join(dir, entry2.name);
       try {
-        const stat = await fs25.stat(fullPath);
+        const stat = await fs26.stat(fullPath);
         if (stat.size > MAX_FILE_BYTES)
           continue;
         if (state.totalBytes + stat.size > MAX_TOTAL_BYTES)
           continue;
-        const content = await fs25.readFile(fullPath, "utf-8");
+        const content = await fs26.readFile(fullPath, "utf-8");
         state.totalBytes += stat.size;
-        const relativePath = path38.relative(root2, fullPath).split(path38.sep).join("/");
+        const relativePath = path39.relative(root2, fullPath).split(path39.sep).join("/");
         files.push({ relativePath, content });
       } catch {}
     }
@@ -172502,7 +172584,7 @@ class McpProxyServer {
       return textContent(JSON.stringify({ success: false, error: "projectPath is required" }));
     }
     try {
-      if (!(await fs26.stat(projectPath2)).isDirectory()) {
+      if (!(await fs27.stat(projectPath2)).isDirectory()) {
         return textContent(JSON.stringify({ success: false, error: `${projectPath2} is not a directory` }));
       }
     } catch {