@massa-ai/tools-api 1.25.0 → 1.26.0

package/dist/index.js

@@ -6998,10 +6998,460 @@ var init_utils = __esm(() => {
   init_rate_limiter();
 });
 
+// ../../packages/shared/dist/profile-switch/hosts.js
+import os3 from "os";
+import path6 from "path";
+function isHost(v) {
+  return typeof v === "string" && HOSTS.includes(v);
+}
+function fileLayout(host, activeDir, activeGlob, variantsRoot) {
+  return {
+    host,
+    route: "files",
+    activeDir,
+    activeGlob,
+    variantsRoot,
+    variantDir: (profile) => path6.join(variantsRoot, profile)
+  };
+}
+function resolveHostLayout(host, opts = {}) {
+  const targetHome = opts.targetHome ?? os3.homedir();
+  const override = opts.projectRoot?.[host];
+  switch (host) {
+    case "cursor":
+      return { host, route: "skip", reason: CURSOR_SKIP_REASON };
+    case "claude": {
+      const root = override ?? path6.join(targetHome, ".claude");
+      return fileLayout(host, path6.join(root, "agents"), "massa-ai-*.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"));
+    }
+    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"));
+    }
+  }
+}
+function detectRoute(platform) {
+  const route = platform?.installRoute;
+  if (route === "file")
+    return { kind: "proceed" };
+  if (route === "marketplace") {
+    return {
+      kind: "refuse",
+      reason: "claude/codex marketplace-route installs are refused (in-place bundle rewrite would dirty a checkout " + "and break the drift gate) \u2014 use the dev path: MASSA_AI_MODEL_PROFILE + regenerate."
+    };
+  }
+  return {
+    kind: "refuse",
+    reason: "no install route recorded \u2014 re-run the installer to record the install route"
+  };
+}
+var HOSTS, CURSOR_SKIP_REASON = "all tiers inherit \u2014 Cursor publishes no resolvable model IDs";
+var init_hosts = __esm(() => {
+  HOSTS = ["claude", "codex", "cursor", "opencode"];
+});
+
+// ../../packages/shared/dist/profile-switch/state.js
+import fs3 from "fs";
+import path7 from "path";
+function namedError(name, message) {
+  const err = new InstallStateError(message);
+  err.name = name;
+  return err;
+}
+function isPlainObject2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function validateShape(raw2, filePath) {
+  if (!isPlainObject2(raw2)) {
+    throw CorruptInstallStateError(filePath, "root is not a JSON object");
+  }
+  if (raw2.platforms !== undefined && !isPlainObject2(raw2.platforms)) {
+    throw CorruptInstallStateError(filePath, '"platforms" is present but not an object');
+  }
+  const platforms = isPlainObject2(raw2.platforms) ? raw2.platforms : {};
+  return {
+    ...raw2,
+    version: typeof raw2.version === "number" ? raw2.version : 2,
+    platforms
+  };
+}
+function readInstallState(filePath) {
+  let text;
+  try {
+    text = fs3.readFileSync(filePath, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT")
+      return DEFAULT_STATE();
+    throw CorruptInstallStateError(filePath, `could not read file: ${err.message}`);
+  }
+  let raw2;
+  try {
+    raw2 = JSON.parse(text);
+  } catch (err) {
+    throw CorruptInstallStateError(filePath, `invalid JSON: ${err.message}`);
+  }
+  return validateShape(raw2, filePath);
+}
+function writeInstallState(filePath, state) {
+  const validated = validateShape(state, filePath);
+  const text = `${JSON.stringify(validated, null, 2)}
+`;
+  try {
+    fs3.mkdirSync(path7.dirname(filePath), { recursive: true });
+    fs3.writeFileSync(filePath, text);
+  } catch (err) {
+    throw UnwritableInstallStateError(filePath, err.message);
+  }
+}
+function updatePlatform(filePath, host, patch) {
+  const state = readInstallState(filePath);
+  const existing = isPlainObject2(state.platforms[host]) ? state.platforms[host] : { root: "", skills: [], skillsOwner: "plugin" };
+  const merged = { ...existing, ...patch };
+  const next = {
+    ...state,
+    platforms: { ...state.platforms, [host]: merged }
+  };
+  writeInstallState(filePath, next);
+  return next;
+}
+var InstallStateError, CorruptInstallStateError = (filePath, cause) => namedError("CorruptInstallStateError", `install-state.json at ${filePath} is corrupt: ${cause}`), UnwritableInstallStateError = (filePath, cause) => namedError("UnwritableInstallStateError", `could not write install-state.json at ${filePath}: ${cause}`), DEFAULT_STATE = () => ({ version: 2, platforms: {} });
+var init_state = __esm(() => {
+  InstallStateError = class InstallStateError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "InstallStateError";
+    }
+  };
+});
+
+// ../../packages/shared/dist/profile-switch/lock.js
+import fs4 from "fs";
+import path8 from "path";
+import os4 from "os";
+import crypto4 from "crypto";
+import { execFileSync } from "child_process";
+function namedError2(name, message) {
+  const err = new LockError(message);
+  err.name = name;
+  return err;
+}
+function readOwner(ownerPath) {
+  let raw2;
+  try {
+    raw2 = JSON.parse(fs4.readFileSync(ownerPath, "utf-8"));
+  } catch {
+    return null;
+  }
+  if (typeof raw2 !== "object" || raw2 === null)
+    return null;
+  const r2 = raw2;
+  if (typeof r2.host === "string" && typeof r2.pid === "number" && typeof r2.processStart === "string" && typeof r2.token === "string" && typeof r2.timestamp === "number") {
+    return r2;
+  }
+  return null;
+}
+function releaseIfOwned(lockDir, ownerPath, token) {
+  const owner = readOwner(ownerPath);
+  if (owner === null || owner.token !== token)
+    return;
+  fs4.rmSync(lockDir, { recursive: true, force: true });
+}
+function acquireLock(stateFilePath, options = {}) {
+  const lockDir = `${stateFilePath}.switch.lock`;
+  const ownerPath = path8.join(lockDir, "owner.json");
+  const clock = options.clock ?? DEFAULT_CLOCK;
+  const identity = options.identity ?? DEFAULT_IDENTITY;
+  const staleAfterMs = options.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
+  const createFresh = () => {
+    fs4.mkdirSync(lockDir);
+    const pid = identity.pid();
+    const startedAt = identity.processStart(pid);
+    if (startedAt == null) {
+      fs4.rmSync(lockDir, { recursive: true, force: true });
+      throw LockAcquireError(lockDir, "could not determine this process's start-time identity");
+    }
+    const token = crypto4.randomUUID();
+    const record = {
+      host: identity.hostname(),
+      pid,
+      processStart: startedAt,
+      token,
+      timestamp: clock.now()
+    };
+    fs4.mkdirSync(path8.dirname(ownerPath), { recursive: true });
+    fs4.writeFileSync(ownerPath, JSON.stringify(record));
+    return { lockDir, release: () => releaseIfOwned(lockDir, ownerPath, token) };
+  };
+  try {
+    return createFresh();
+  } catch (err) {
+    if (err.code !== "EEXIST")
+      throw err;
+  }
+  const owner = readOwner(ownerPath);
+  const provenDead = owner !== null && clock.now() - owner.timestamp >= staleAfterMs && identity.processStart(owner.pid) !== owner.processStart;
+  if (!provenDead)
+    throw LockHeldError(lockDir);
+  const reclaimDir = `${lockDir}.reclaim.${owner.token}`;
+  try {
+    fs4.renameSync(lockDir, reclaimDir);
+  } catch {
+    throw LockHeldError(lockDir);
+  }
+  fs4.rmSync(reclaimDir, { recursive: true, force: true });
+  try {
+    return createFresh();
+  } catch {
+    throw LockHeldError(lockDir);
+  }
+}
+var LockError, LockHeldError = (lockDir) => namedError2("LockHeldError", `another switch is running (lock held at ${lockDir})`), LockAcquireError = (lockDir, cause) => namedError2("LockAcquireError", `could not acquire switch lock at ${lockDir}: ${cause}`), DEFAULT_STALE_AFTER_MS, DEFAULT_CLOCK, DEFAULT_IDENTITY;
+var init_lock = __esm(() => {
+  LockError = class LockError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "LockError";
+    }
+  };
+  DEFAULT_STALE_AFTER_MS = 5 * 60 * 1000;
+  DEFAULT_CLOCK = { now: () => Date.now() };
+  DEFAULT_IDENTITY = {
+    pid: () => process.pid,
+    hostname: () => os4.hostname(),
+    processStart: (pid) => {
+      try {
+        const out = execFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
+          encoding: "utf-8"
+        }).trim();
+        return out.length > 0 ? out : null;
+      } catch {
+        return null;
+      }
+    }
+  };
+});
+
+// ../../packages/shared/dist/profile-switch/engine.js
+import fs5 from "fs";
+import path9 from "path";
+import os5 from "os";
+import crypto5 from "crypto";
+function namedError3(name, message) {
+  const err = new SwitchEngineError(message);
+  err.name = name;
+  return err;
+}
+function defaultStatePath(targetHome) {
+  return path9.join(targetHome, ".config", "massa-ai", "install-state.json");
+}
+function resolveCommon(opts) {
+  const targetHome = opts.targetHome ?? os5.homedir();
+  const stateFilePath = opts.stateFilePath ?? defaultStatePath(targetHome);
+  return { targetHome, stateFilePath };
+}
+function listProfiles(opts = {}) {
+  const { targetHome, stateFilePath } = resolveCommon(opts);
+  const state = readInstallState(stateFilePath);
+  const universe = opts.hosts ?? HOSTS;
+  const hosts = universe.map((host) => {
+    const layout = resolveHostLayout(host, { targetHome, projectRoot: opts.projectRoot });
+    if (layout.route === "skip") {
+      return {
+        host,
+        installed: false,
+        skipped: true,
+        skipReason: layout.reason,
+        activeProfile: null,
+        bundleVersion: null,
+        availableProfiles: []
+      };
+    }
+    const installed = fs5.existsSync(layout.activeDir);
+    const availableProfiles = listVariantProfiles(layout);
+    const platform = state.platforms[host];
+    return {
+      host,
+      installed,
+      skipped: false,
+      skipReason: null,
+      activeProfile: platform?.modelProfile?.profile ?? "balanced",
+      bundleVersion: platform?.plugin?.version ?? null,
+      availableProfiles
+    };
+  });
+  return { hosts };
+}
+function listVariantProfiles(layout) {
+  if (!fs5.existsSync(layout.variantsRoot))
+    return [];
+  return fs5.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 assertStateWritable(stateFilePath) {
+  const dir = path9.dirname(stateFilePath);
+  try {
+    fs5.mkdirSync(dir, { recursive: true });
+  } catch (err) {
+    throw UnwritableInstallStateError(stateFilePath, err.message);
+  }
+  const checkPath = fs5.existsSync(stateFilePath) ? stateFilePath : dir;
+  try {
+    fs5.accessSync(checkPath, fs5.constants.W_OK);
+  } catch (err) {
+    throw UnwritableInstallStateError(stateFilePath, err.message);
+  }
+}
+function copyFileRouteVariant(layout, variantDir) {
+  fs5.mkdirSync(layout.activeDir, { recursive: true });
+  let changed = 0;
+  for (const entry of fs5.readdirSync(variantDir, { withFileTypes: true })) {
+    if (!entry.isFile() || !matchesGlob(entry.name, layout.activeGlob))
+      continue;
+    fs5.copyFileSync(path9.join(variantDir, entry.name), path9.join(layout.activeDir, entry.name));
+    changed++;
+  }
+  return changed;
+}
+function repointOpencodeVariant(layout, variantDir) {
+  fs5.mkdirSync(layout.activeDir, { recursive: true });
+  let changed = 0;
+  for (const entry of fs5.readdirSync(variantDir, { withFileTypes: true })) {
+    if (!entry.isFile() || !matchesGlob(entry.name, layout.activeGlob))
+      continue;
+    const dest = path9.join(layout.activeDir, entry.name);
+    const target = path9.resolve(path9.join(variantDir, entry.name));
+    let destExists = true;
+    let destIsSymlink = false;
+    try {
+      destIsSymlink = fs5.lstatSync(dest).isSymbolicLink();
+    } catch {
+      destExists = false;
+    }
+    if (destExists && !destIsSymlink)
+      continue;
+    const tmp = `${dest}.massa-ai-switch.${crypto5.randomUUID()}`;
+    fs5.symlinkSync(target, tmp);
+    fs5.renameSync(tmp, dest);
+    changed++;
+  }
+  return changed;
+}
+function copyVariant(host, layout, variantDir) {
+  return host === "opencode" ? repointOpencodeVariant(layout, variantDir) : copyFileRouteVariant(layout, variantDir);
+}
+function switchProfile(opts) {
+  const { targetHome, stateFilePath } = resolveCommon(opts);
+  const dryRun = opts.dryRun ?? false;
+  const requested = opts.host ? [opts.host] : opts.hosts ?? HOSTS;
+  const universe = HOSTS.filter((h) => requested.includes(h));
+  const state = readInstallState(stateFilePath);
+  if (!dryRun)
+    assertStateWritable(stateFilePath);
+  const layouts = universe.map((host) => ({ host, layout: resolveHostLayout(host, { targetHome, projectRoot: opts.projectRoot }) }));
+  const skipRows = layouts.filter((l2) => l2.layout.route === "skip").map((l2) => ({ host: l2.host, status: "skipped", reason: l2.layout.reason }));
+  const fileHosts = layouts.filter((l2) => l2.layout.route === "files");
+  if (fileHosts.length === 0) {
+    return { profile: opts.profile, dryRun, hosts: orderRows(universe, skipRows), restartRequired: false };
+  }
+  const installedFileHosts = fileHosts.filter((h) => fs5.existsSync(h.layout.activeDir));
+  if (installedFileHosts.length === 0)
+    throw NoHostsDetectedError();
+  const withAvailability = fileHosts.map((h) => {
+    const variantsRootExists = fs5.existsSync(h.layout.variantsRoot);
+    const variantDir = h.layout.variantDir(opts.profile);
+    const available = variantsRootExists && fs5.existsSync(variantDir) && fs5.statSync(variantDir).isDirectory();
+    return { ...h, variantsRootExists, variantDir, available };
+  });
+  if (!withAvailability.some((h) => h.available)) {
+    const known = new Set;
+    for (const h of withAvailability) {
+      if (!h.variantsRootExists)
+        continue;
+      for (const name of listVariantProfiles(h.layout))
+        known.add(name);
+    }
+    throw UnknownProfileError(opts.profile, [...known].sort());
+  }
+  const lock = dryRun ? null : acquireLock(stateFilePath, opts.lock);
+  try {
+    const rows = [...skipRows];
+    for (const h of withAvailability) {
+      if (!h.variantsRootExists) {
+        rows.push({ host: h.host, status: "unsupported", reason: "bundle has no variants \u2014 upgrade plugin" });
+        continue;
+      }
+      if (!h.available) {
+        const supported = listVariantProfiles(h.layout);
+        rows.push({
+          host: h.host,
+          status: "unsupported",
+          reason: `profile "${opts.profile}" not supported on ${h.host} (supports: ${supported.join(", ") || "none"})`
+        });
+        continue;
+      }
+      const route = detectRoute(state.platforms[h.host]);
+      if (route.kind === "refuse") {
+        rows.push({ host: h.host, status: "failed", reason: route.reason });
+        continue;
+      }
+      if (dryRun) {
+        rows.push({ host: h.host, status: "switched" });
+        continue;
+      }
+      try {
+        const filesChanged = copyVariant(h.host, h.layout, h.variantDir);
+        updatePlatform(stateFilePath, h.host, {
+          modelProfile: { profile: opts.profile, switchedAt: new Date().toISOString() }
+        });
+        rows.push({ host: h.host, status: "switched", filesChanged });
+      } catch (err) {
+        rows.push({ host: h.host, status: "failed", reason: err.message });
+      }
+    }
+    const ordered = orderRows(universe, rows);
+    const restartRequired = !dryRun && ordered.some((r2) => r2.status === "switched");
+    return { profile: opts.profile, dryRun, hosts: ordered, restartRequired };
+  } finally {
+    lock?.release();
+  }
+}
+function orderRows(universe, rows) {
+  const byHost = new Map(rows.map((r2) => [r2.host, r2]));
+  return HOSTS.filter((h) => universe.includes(h) && byHost.has(h)).map((h) => byHost.get(h));
+}
+var SwitchEngineError, UnknownProfileError = (profile, known) => namedError3("UnknownProfileError", `unknown profile "${profile}" \u2014 installed: ${known.length > 0 ? known.join(", ") : "none"}`), NoHostsDetectedError = () => namedError3("NoHostsDetectedError", "no installed hosts found");
+var init_engine = __esm(() => {
+  init_hosts();
+  init_state();
+  init_lock();
+  SwitchEngineError = class SwitchEngineError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "SwitchEngineError";
+    }
+  };
+});
 // ../../packages/shared/dist/index.js
 var init_dist = __esm(() => {
   init_env();
   init_config();
+  init_hosts();
+  init_state();
+  init_lock();
+  init_engine();
   init_types();
   init_interfaces();
   init_utils();
@@ -8523,7 +8973,7 @@ var import_brace_expansion, minimatch = (p, pattern, options = {}) => {
 }, qmarksTestNoExtDot = ([$0]) => {
   const len = $0.length;
   return (f) => f.length === len && f !== "." && f !== "..";
-}, defaultPlatform, path6, sep, GLOBSTAR, qmark2 = "[^/]", star2, twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?", filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options), ext = (a12, b = {}) => Object.assign({}, a12, b), defaults = (def) => {
+}, defaultPlatform, path10, sep, GLOBSTAR, qmark2 = "[^/]", star2, twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?", filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options), ext = (a12, b = {}) => Object.assign({}, a12, b), defaults = (def) => {
   if (!def || typeof def !== "object" || !Object.keys(def).length) {
     return minimatch;
   }
@@ -8581,11 +9031,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";
-  path6 = {
+  path10 = {
     win32: { sep: "\\" },
     posix: { sep: "/" }
   };
-  sep = defaultPlatform === "win32" ? path6.win32.sep : path6.posix.sep;
+  sep = defaultPlatform === "win32" ? path10.win32.sep : path10.posix.sep;
   minimatch.sep = sep;
   GLOBSTAR = Symbol("globstar **");
   minimatch.GLOBSTAR = GLOBSTAR;
@@ -10551,12 +11001,12 @@ var init_esm4 = __esm(() => {
     childrenCache() {
       return this.#children;
     }
-    resolve(path7) {
-      if (!path7) {
+    resolve(path11) {
+      if (!path11) {
         return this;
       }
-      const rootPath = this.getRootString(path7);
-      const dir = path7.substring(rootPath.length);
+      const rootPath = this.getRootString(path11);
+      const dir = path11.substring(rootPath.length);
       const dirParts = dir.split(this.splitSep);
       const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
       return result;
@@ -11084,8 +11534,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(path7) {
-      return win32.parse(path7).root;
+    getRootString(path11) {
+      return win32.parse(path11).root;
     }
     getRoot(rootPath) {
       rootPath = uncToDrive(rootPath.toUpperCase());
@@ -11110,8 +11560,8 @@ var init_esm4 = __esm(() => {
     constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
       super(name, type, root, roots, nocase, children, opts);
     }
-    getRootString(path7) {
-      return path7.startsWith("/") ? "/" : "";
+    getRootString(path11) {
+      return path11.startsWith("/") ? "/" : "";
     }
     getRoot(_rootPath) {
       return this.root;
@@ -11130,8 +11580,8 @@ var init_esm4 = __esm(() => {
     #children;
     nocase;
     #fs;
-    constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs3 = defaultFS } = {}) {
-      this.#fs = fsFromOption(fs3);
+    constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs6 = defaultFS } = {}) {
+      this.#fs = fsFromOption(fs6);
       if (cwd instanceof URL || cwd.startsWith("file://")) {
         cwd = fileURLToPath(cwd);
       }
@@ -11167,11 +11617,11 @@ var init_esm4 = __esm(() => {
       }
       this.cwd = prev;
     }
-    depth(path7 = this.cwd) {
-      if (typeof path7 === "string") {
-        path7 = this.cwd.resolve(path7);
+    depth(path11 = this.cwd) {
+      if (typeof path11 === "string") {
+        path11 = this.cwd.resolve(path11);
       }
-      return path7.depth();
+      return path11.depth();
     }
     childrenCache() {
       return this.#children;
@@ -11587,9 +12037,9 @@ var init_esm4 = __esm(() => {
       process2();
       return results;
     }
-    chdir(path7 = this.cwd) {
+    chdir(path11 = this.cwd) {
       const oldCwd = this.cwd;
-      this.cwd = typeof path7 === "string" ? this.cwd.resolve(path7) : path7;
+      this.cwd = typeof path11 === "string" ? this.cwd.resolve(path11) : path11;
       this.cwd[setAsCwd](oldCwd);
     }
   };
@@ -11606,8 +12056,8 @@ var init_esm4 = __esm(() => {
     parseRootPath(dir) {
       return win32.parse(dir).root.toUpperCase();
     }
-    newRoot(fs3) {
-      return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs3 });
+    newRoot(fs6) {
+      return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
     }
     isAbsolute(p) {
       return p.startsWith("/") || p.startsWith("\\") || /^[a-z]:(\/|\\)/i.test(p);
@@ -11623,8 +12073,8 @@ var init_esm4 = __esm(() => {
     parseRootPath(_dir) {
       return "/";
     }
-    newRoot(fs3) {
-      return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs3 });
+    newRoot(fs6) {
+      return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
     }
     isAbsolute(p) {
       return p.startsWith("/");
@@ -11881,8 +12331,8 @@ class MatchRecord {
     this.store.set(target, current === undefined ? n2 : n2 & current);
   }
   entries() {
-    return [...this.store.entries()].map(([path7, n2]) => [
-      path7,
+    return [...this.store.entries()].map(([path11, n2]) => [
+      path11,
       !!(n2 & 2),
       !!(n2 & 1)
     ]);
@@ -12086,9 +12536,9 @@ class GlobUtil {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path7, opts) {
+  constructor(patterns, path11, opts) {
     this.patterns = patterns;
-    this.path = path7;
+    this.path = path11;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -12107,11 +12557,11 @@ class GlobUtil {
       });
     }
   }
-  #ignored(path7) {
-    return this.seen.has(path7) || !!this.#ignore?.ignored?.(path7);
+  #ignored(path11) {
+    return this.seen.has(path11) || !!this.#ignore?.ignored?.(path11);
   }
-  #childrenIgnored(path7) {
-    return !!this.#ignore?.childrenIgnored?.(path7);
+  #childrenIgnored(path11) {
+    return !!this.#ignore?.childrenIgnored?.(path11);
   }
   pause() {
     this.paused = true;
@@ -12328,8 +12778,8 @@ var init_walker = __esm(() => {
   init_processor();
   GlobWalker = class GlobWalker extends GlobUtil {
     matches = new Set;
-    constructor(patterns, path7, opts) {
-      super(patterns, path7, opts);
+    constructor(patterns, path11, opts) {
+      super(patterns, path11, opts);
     }
     matchEmit(e) {
       this.matches.add(e);
@@ -12366,8 +12816,8 @@ var init_walker = __esm(() => {
   };
   GlobStream = class GlobStream extends GlobUtil {
     results;
-    constructor(patterns, path7, opts) {
-      super(patterns, path7, opts);
+    constructor(patterns, path11, opts) {
+      super(patterns, path11, opts);
       this.results = new Minipass({
         signal: this.signal,
         objectMode: true
@@ -12795,20 +13245,20 @@ var require_ignore = __commonJS((exports, module) => {
   var throwError = (message, Ctor) => {
     throw new Ctor(message);
   };
-  var checkPath = (path7, originalPath, doThrow) => {
-    if (!isString(path7)) {
+  var checkPath = (path11, originalPath, doThrow) => {
+    if (!isString(path11)) {
       return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
     }
-    if (!path7) {
+    if (!path11) {
       return doThrow(`path must not be empty`, TypeError);
     }
-    if (checkPath.isNotRelative(path7)) {
+    if (checkPath.isNotRelative(path11)) {
       const r2 = "`path.relative()`d";
       return doThrow(`path should be a ${r2} string, but got "${originalPath}"`, RangeError);
     }
     return true;
   };
-  var isNotRelative = (path7) => REGEX_TEST_INVALID_PATH.test(path7);
+  var isNotRelative = (path11) => REGEX_TEST_INVALID_PATH.test(path11);
   checkPath.isNotRelative = isNotRelative;
   checkPath.convert = (p) => p;
 
@@ -12851,7 +13301,7 @@ var require_ignore = __commonJS((exports, module) => {
     addPattern(pattern) {
       return this.add(pattern);
     }
-    _testOne(path7, checkUnignored) {
+    _testOne(path11, checkUnignored) {
       let ignored = false;
       let unignored = false;
       this._rules.forEach((rule) => {
@@ -12859,7 +13309,7 @@ var require_ignore = __commonJS((exports, module) => {
         if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
           return;
         }
-        const matched = rule.regex.test(path7);
+        const matched = rule.regex.test(path11);
         if (matched) {
           ignored = !negative;
           unignored = negative;
@@ -12871,39 +13321,39 @@ var require_ignore = __commonJS((exports, module) => {
       };
     }
     _test(originalPath, cache, checkUnignored, slices) {
-      const path7 = originalPath && checkPath.convert(originalPath);
-      checkPath(path7, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
-      return this._t(path7, cache, checkUnignored, slices);
+      const path11 = originalPath && checkPath.convert(originalPath);
+      checkPath(path11, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
+      return this._t(path11, cache, checkUnignored, slices);
     }
-    _t(path7, cache, checkUnignored, slices) {
-      if (path7 in cache) {
-        return cache[path7];
+    _t(path11, cache, checkUnignored, slices) {
+      if (path11 in cache) {
+        return cache[path11];
       }
       if (!slices) {
-        slices = path7.split(SLASH);
+        slices = path11.split(SLASH);
       }
       slices.pop();
       if (!slices.length) {
-        return cache[path7] = this._testOne(path7, checkUnignored);
+        return cache[path11] = this._testOne(path11, checkUnignored);
       }
       const parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices);
-      return cache[path7] = parent.ignored ? parent : this._testOne(path7, checkUnignored);
+      return cache[path11] = parent.ignored ? parent : this._testOne(path11, checkUnignored);
     }
-    ignores(path7) {
-      return this._test(path7, this._ignoreCache, false).ignored;
+    ignores(path11) {
+      return this._test(path11, this._ignoreCache, false).ignored;
     }
     createFilter() {
-      return (path7) => !this.ignores(path7);
+      return (path11) => !this.ignores(path11);
     }
     filter(paths) {
       return makeArray(paths).filter(this.createFilter());
     }
-    test(path7) {
-      return this._test(path7, this._testCache, true);
+    test(path11) {
+      return this._test(path11, this._testCache, true);
     }
   }
   var factory = (options) => new Ignore2(options);
-  var isPathValid = (path7) => checkPath(path7 && checkPath.convert(path7), path7, RETURN_FALSE);
+  var isPathValid = (path11) => checkPath(path11 && checkPath.convert(path11), path11, RETURN_FALSE);
   factory.isPathValid = isPathValid;
   factory.default = factory;
   module.exports = factory;
@@ -12911,7 +13361,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 = (path7) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path7) || isNotRelative(path7);
+    checkPath.isNotRelative = (path11) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path11) || isNotRelative(path11);
   }
 });
 
@@ -12973,18 +13423,18 @@ function validatePolicy(policy, opts = {}) {
     }
   }
 }
-function matchesGlob(path7, pattern) {
+function matchesGlob2(path11, pattern) {
   let re = regexCache.get(pattern);
   if (!re) {
     re = globToRegex(pattern);
     regexCache.set(pattern, re);
   }
-  return re.test(path7);
+  return re.test(path11);
 }
 var MAX_MATCH_WORK = 1e5, MAX_IGNORE_PATTERNS2 = 1024, DEFAULT_POLICY, applyPolicy = (filePath, policy) => {
   const normalized = filePath.trim();
   for (const rule of policy.rules) {
-    if (matchesGlob(normalized, rule.pattern))
+    if (matchesGlob2(normalized, rule.pattern))
       return rule.disposition;
   }
   return "Keep";
@@ -13030,8 +13480,8 @@ var init_capture_policy = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/ignore-patterns.js
-import fs3 from "fs/promises";
-import path7 from "path";
+import fs6 from "fs/promises";
+import path11 from "path";
 function buildExtensionGlob(extensions2) {
   return extensions2.map((ext2) => `**/*${ext2}`);
 }
@@ -13054,8 +13504,8 @@ async function loadProjectIgnore(projectPath) {
   const ig = ignore();
   ig.add(DEFAULT_IGNORES);
   try {
-    const gitignorePath = path7.join(projectPath, ".gitignore");
-    const gitignoreContent = await fs3.readFile(gitignorePath, "utf8");
+    const gitignorePath = path11.join(projectPath, ".gitignore");
+    const gitignoreContent = await fs6.readFile(gitignorePath, "utf8");
     const rules = gitignoreContent.split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
     ig.add(rules);
@@ -13224,8 +13674,8 @@ var init_alias_resolver = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/index-manager.js
-import fs4 from "fs";
-import path8 from "path";
+import fs7 from "fs";
+import path12 from "path";
 
 class IndexManager {
   metadataCache = new Map;
@@ -13318,9 +13768,9 @@ class IndexManager {
       const fileMetadata = {};
       let totalSize = 0;
       for (const filePath of indexedFiles) {
-        const fullPath = path8.join(projectPath, filePath);
+        const fullPath = path12.join(projectPath, filePath);
         try {
-          const stat2 = await fs4.promises.stat(fullPath);
+          const stat2 = await fs7.promises.stat(fullPath);
           fileMetadata[filePath] = {
             path: filePath,
             mtime: stat2.mtimeMs,
@@ -13371,9 +13821,9 @@ class IndexManager {
         if (ig.ignores(match2)) {
           continue;
         }
-        const fullPath = path8.join(projectPath, match2);
+        const fullPath = path12.join(projectPath, match2);
         try {
-          const stat2 = await fs4.promises.stat(fullPath);
+          const stat2 = await fs7.promises.stat(fullPath);
           files.set(match2, {
             path: match2,
             mtime: stat2.mtimeMs,
@@ -13692,7 +14142,7 @@ __export(exports_util, {
   jsonStringifyReplacer: () => jsonStringifyReplacer,
   joinValues: () => joinValues,
   issue: () => issue,
-  isPlainObject: () => isPlainObject2,
+  isPlainObject: () => isPlainObject3,
   isObject: () => isObject2,
   hexToUint8Array: () => hexToUint8Array,
   getSizableOrigin: () => getSizableOrigin,
@@ -13824,10 +14274,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path9) {
-  if (!path9)
+function getElementAtPath(obj, path13) {
+  if (!path13)
     return obj;
-  return path9.reduce((acc, key) => acc?.[key], obj);
+  return path13.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -13857,7 +14307,7 @@ function slugify(input) {
 function isObject2(data) {
   return typeof data === "object" && data !== null && !Array.isArray(data);
 }
-function isPlainObject2(o) {
+function isPlainObject3(o) {
   if (isObject2(o) === false)
     return false;
   const ctor = o.constructor;
@@ -13874,7 +14324,7 @@ function isPlainObject2(o) {
   return true;
 }
 function shallowClone(o) {
-  if (isPlainObject2(o))
+  if (isPlainObject3(o))
     return { ...o };
   if (Array.isArray(o))
     return [...o];
@@ -14014,7 +14464,7 @@ function omit(schema, mask) {
   return clone2(schema, def);
 }
 function extend(schema, shape) {
-  if (!isPlainObject2(shape)) {
+  if (!isPlainObject3(shape)) {
     throw new Error("Invalid input to extend: expected a plain object");
   }
   const checks = schema._zod.def.checks;
@@ -14037,7 +14487,7 @@ function extend(schema, shape) {
   return clone2(schema, def);
 }
 function safeExtend(schema, shape) {
-  if (!isPlainObject2(shape)) {
+  if (!isPlainObject3(shape)) {
     throw new Error("Invalid input to safeExtend: expected a plain object");
   }
   const def = mergeDefs(schema._zod.def, {
@@ -14155,11 +14605,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path9, issues) {
+function prefixIssues(path13, issues) {
   return issues.map((iss) => {
     var _a4;
     (_a4 = iss).path ?? (_a4.path = []);
-    iss.path.unshift(path9);
+    iss.path.unshift(path13);
     return iss;
   });
 }
@@ -14372,16 +14822,16 @@ function flattenError(error, mapper = (issue2) => issue2.message) {
 }
 function formatError(error, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error2, path9 = []) => {
+  const processError = (error2, path13 = []) => {
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path9, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path13, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path13, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path13, ...issue2.path]);
       } else {
-        const fullpath = [...path9, ...issue2.path];
+        const fullpath = [...path13, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -14408,17 +14858,17 @@ function formatError(error, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error2, path9 = []) => {
+  const processError = (error2, path13 = []) => {
     var _a4, _b;
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path9, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path13, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path13, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path13, ...issue2.path]);
       } else {
-        const fullpath = [...path9, ...issue2.path];
+        const fullpath = [...path13, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -14450,8 +14900,8 @@ function treeifyError(error, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path9 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path9) {
+  const path13 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path13) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -15520,7 +15970,7 @@ function mergeValues2(a12, b) {
   if (a12 instanceof Date && b instanceof Date && +a12 === +b) {
     return { valid: true, data: a12 };
   }
-  if (isPlainObject2(a12) && isPlainObject2(b)) {
+  if (isPlainObject3(a12) && isPlainObject3(b)) {
     const bKeys = Object.keys(b);
     const sharedKeys = Object.keys(a12).filter((key) => bKeys.indexOf(key) !== -1);
     const newObj = { ...a12, ...b };
@@ -16777,7 +17227,7 @@ var init_schemas = __esm(() => {
     $ZodType.init(inst, def);
     inst._zod.parse = (payload, ctx) => {
       const input = payload.value;
-      if (!isPlainObject2(input)) {
+      if (!isPlainObject3(input)) {
         payload.issues.push({
           expected: "record",
           code: "invalid_type",
@@ -27454,13 +27904,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path9 = ref.slice(1).split("/").filter(Boolean);
-  if (path9.length === 0) {
+  const path13 = ref.slice(1).split("/").filter(Boolean);
+  if (path13.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path9[0] === defsKey) {
-    const key = path9[1];
+  if (path13[0] === defsKey) {
+    const key = path13[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -28949,8 +29399,8 @@ class ParseStatus2 {
   }
 }
 var makeIssue2 = (params) => {
-  const { data, path: path9, errorMaps, issueData } = params;
-  const fullPath = [...path9, ...issueData.path || []];
+  const { data, path: path13, errorMaps, issueData } = params;
+  const fullPath = [...path13, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -28995,11 +29445,11 @@ var init_errorUtil = __esm(() => {
 
 // ../../node_modules/zod/v3/types.js
 class ParseInputLazyPath2 {
-  constructor(parent, value, path9, key) {
+  constructor(parent, value, path13, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path9;
+    this._path = path13;
     this._key = key;
   }
   get path() {
@@ -35064,23 +35514,23 @@ var require_auth_config = __commonJS((exports, module) => {
     writeAuthConfig: () => writeAuthConfig
   });
   module.exports = __toCommonJS2(auth_config_exports);
-  var fs5 = __toESM2(__require("fs"));
-  var path9 = __toESM2(__require("path"));
+  var fs8 = __toESM2(__require("fs"));
+  var path13 = __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 path9.join(dataDir, "auth.json");
+    return path13.join(dataDir, "auth.json");
   }
   function readAuthConfig() {
     try {
       const authPath = getAuthConfigPath();
-      if (!fs5.existsSync(authPath)) {
+      if (!fs8.existsSync(authPath)) {
         return null;
       }
-      const content = fs5.readFileSync(authPath, "utf8");
+      const content = fs8.readFileSync(authPath, "utf8");
       if (!content) {
         return null;
       }
@@ -35091,11 +35541,11 @@ var require_auth_config = __commonJS((exports, module) => {
   }
   function writeAuthConfig(config3) {
     const authPath = getAuthConfigPath();
-    const authDir = path9.dirname(authPath);
-    if (!fs5.existsSync(authDir)) {
-      fs5.mkdirSync(authDir, { mode: 504, recursive: true });
+    const authDir = path13.dirname(authPath);
+    if (!fs8.existsSync(authDir)) {
+      fs8.mkdirSync(authDir, { mode: 504, recursive: true });
     }
-    fs5.writeFileSync(authPath, JSON.stringify(config3, null, 2), { mode: 384 });
+    fs8.writeFileSync(authPath, JSON.stringify(config3, null, 2), { mode: 384 });
   }
   function isValidAccessToken(authConfig, expirationBufferMs = 0) {
     if (!authConfig.token)
@@ -35270,8 +35720,8 @@ var require_token_util = __commonJS((exports, module) => {
     saveToken: () => saveToken
   });
   module.exports = __toCommonJS2(token_util_exports);
-  var path9 = __toESM2(__require("path"));
-  var fs5 = __toESM2(__require("fs"));
+  var path13 = __toESM2(__require("path"));
+  var fs8 = __toESM2(__require("fs"));
   var import_token_error = require_token_error();
   var import_token_io = require_token_io();
   var import_auth_config = require_auth_config();
@@ -35283,7 +35733,7 @@ var require_token_util = __commonJS((exports, module) => {
     if (!dataDir) {
       return null;
     }
-    return path9.join(dataDir, vercelFolder);
+    return path13.join(dataDir, vercelFolder);
   }
   async function getVercelToken2(options) {
     const authConfig = (0, import_auth_config.readAuthConfig)();
@@ -35351,11 +35801,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 = path9.join(dir, ".vercel", "project.json");
-    if (!fs5.existsSync(prjPath)) {
+    const prjPath = path13.join(dir, ".vercel", "project.json");
+    if (!fs8.existsSync(prjPath)) {
       throw new import_token_error.VercelOidcTokenError("project.json not found, have you linked your project with `vc link?`");
     }
-    const prj = JSON.parse(fs5.readFileSync(prjPath, "utf8"));
+    const prj = JSON.parse(fs8.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.");
     }
@@ -35366,11 +35816,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 = path9.join(dir, "com.vercel.token", `${projectId}.json`);
+    const tokenPath = path13.join(dir, "com.vercel.token", `${projectId}.json`);
     const tokenJson = JSON.stringify(token);
-    fs5.mkdirSync(path9.dirname(tokenPath), { mode: 504, recursive: true });
-    fs5.writeFileSync(tokenPath, tokenJson);
-    fs5.chmodSync(tokenPath, 432);
+    fs8.mkdirSync(path13.dirname(tokenPath), { mode: 504, recursive: true });
+    fs8.writeFileSync(tokenPath, tokenJson);
+    fs8.chmodSync(tokenPath, 432);
     return;
   }
   function loadToken(projectId) {
@@ -35378,11 +35828,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 = path9.join(dir, "com.vercel.token", `${projectId}.json`);
-    if (!fs5.existsSync(tokenPath)) {
+    const tokenPath = path13.join(dir, "com.vercel.token", `${projectId}.json`);
+    if (!fs8.existsSync(tokenPath)) {
       return null;
     }
-    const token = JSON.parse(fs5.readFileSync(tokenPath, "utf8"));
+    const token = JSON.parse(fs8.readFileSync(tokenPath, "utf8"));
     assertVercelOidcTokenResponse(token);
     return token;
   }
@@ -46224,37 +46674,37 @@ function createOpenAI(options = {}) {
   }, `ai-sdk/openai/${VERSION4}`);
   const createChatModel = (modelId) => new OpenAIChatLanguageModel(modelId, {
     provider: `${providerName}.chat`,
-    url: ({ path: path9 }) => `${baseURL}${path9}`,
+    url: ({ path: path13 }) => `${baseURL}${path13}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createCompletionModel = (modelId) => new OpenAICompletionLanguageModel(modelId, {
     provider: `${providerName}.completion`,
-    url: ({ path: path9 }) => `${baseURL}${path9}`,
+    url: ({ path: path13 }) => `${baseURL}${path13}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createEmbeddingModel = (modelId) => new OpenAIEmbeddingModel(modelId, {
     provider: `${providerName}.embedding`,
-    url: ({ path: path9 }) => `${baseURL}${path9}`,
+    url: ({ path: path13 }) => `${baseURL}${path13}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createImageModel = (modelId) => new OpenAIImageModel(modelId, {
     provider: `${providerName}.image`,
-    url: ({ path: path9 }) => `${baseURL}${path9}`,
+    url: ({ path: path13 }) => `${baseURL}${path13}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createTranscriptionModel = (modelId) => new OpenAITranscriptionModel(modelId, {
     provider: `${providerName}.transcription`,
-    url: ({ path: path9 }) => `${baseURL}${path9}`,
+    url: ({ path: path13 }) => `${baseURL}${path13}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createSpeechModel = (modelId) => new OpenAISpeechModel(modelId, {
     provider: `${providerName}.speech`,
-    url: ({ path: path9 }) => `${baseURL}${path9}`,
+    url: ({ path: path13 }) => `${baseURL}${path13}`,
     headers: getHeaders,
     fetch: options.fetch
   });
@@ -46267,7 +46717,7 @@ function createOpenAI(options = {}) {
   const createResponsesModel = (modelId) => {
     return new OpenAIResponsesLanguageModel(modelId, {
       provider: `${providerName}.responses`,
-      url: ({ path: path9 }) => `${baseURL}${path9}`,
+      url: ({ path: path13 }) => `${baseURL}${path13}`,
       headers: getHeaders,
       fetch: options.fetch,
       fileIdPrefixes: ["file-"]
@@ -62800,26 +63250,26 @@ var require_process = __commonJS((exports, module) => {
 
 // ../../node_modules/detect-libc/lib/filesystem.js
 var require_filesystem = __commonJS((exports, module) => {
-  var fs5 = __require("fs");
+  var fs8 = __require("fs");
   var LDD_PATH = "/usr/bin/ldd";
   var SELF_PATH = "/proc/self/exe";
   var MAX_LENGTH = 2048;
-  var readFileSync2 = (path9) => {
-    const fd = fs5.openSync(path9, "r");
+  var readFileSync2 = (path13) => {
+    const fd = fs8.openSync(path13, "r");
     const buffer = Buffer.alloc(MAX_LENGTH);
-    const bytesRead = fs5.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-    fs5.close(fd, () => {});
+    const bytesRead = fs8.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+    fs8.close(fd, () => {});
     return buffer.subarray(0, bytesRead);
   };
-  var readFile = (path9) => new Promise((resolve4, reject) => {
-    fs5.open(path9, "r", (err, fd) => {
+  var readFile = (path13) => new Promise((resolve4, reject) => {
+    fs8.open(path13, "r", (err, fd) => {
       if (err) {
         reject(err);
       } else {
         const buffer = Buffer.alloc(MAX_LENGTH);
-        fs5.read(fd, buffer, 0, MAX_LENGTH, 0, (_2, bytesRead) => {
+        fs8.read(fd, buffer, 0, MAX_LENGTH, 0, (_2, bytesRead) => {
           resolve4(buffer.subarray(0, bytesRead));
-          fs5.close(fd, () => {});
+          fs8.close(fd, () => {});
         });
       }
     });
@@ -62924,11 +63374,11 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     return null;
   };
-  var familyFromInterpreterPath = (path9) => {
-    if (path9) {
-      if (path9.includes("/ld-musl-")) {
+  var familyFromInterpreterPath = (path13) => {
+    if (path13) {
+      if (path13.includes("/ld-musl-")) {
         return MUSL;
-      } else if (path9.includes("/ld-linux-")) {
+      } else if (path13.includes("/ld-linux-")) {
         return GLIBC;
       }
     }
@@ -62973,8 +63423,8 @@ var require_detect_libc = __commonJS((exports, module) => {
     cachedFamilyInterpreter = null;
     try {
       const selfContent = await readFile(SELF_PATH);
-      const path9 = interpreterPath(selfContent);
-      cachedFamilyInterpreter = familyFromInterpreterPath(path9);
+      const path13 = interpreterPath(selfContent);
+      cachedFamilyInterpreter = familyFromInterpreterPath(path13);
     } catch (e) {}
     return cachedFamilyInterpreter;
   };
@@ -62985,8 +63435,8 @@ var require_detect_libc = __commonJS((exports, module) => {
     cachedFamilyInterpreter = null;
     try {
       const selfContent = readFileSync2(SELF_PATH);
-      const path9 = interpreterPath(selfContent);
-      cachedFamilyInterpreter = familyFromInterpreterPath(path9);
+      const path13 = interpreterPath(selfContent);
+      cachedFamilyInterpreter = familyFromInterpreterPath(path13);
     } catch (e) {}
     return cachedFamilyInterpreter;
   };
@@ -64648,18 +65098,18 @@ var require_sharp = __commonJS((exports, module) => {
     `@img/sharp-${runtimePlatform}/sharp.node`,
     "@img/sharp-wasm32/sharp.node"
   ];
-  var path9;
+  var path13;
   var sharp;
   var errors5 = [];
-  for (path9 of paths) {
+  for (path13 of paths) {
     try {
-      sharp = __require(path9);
+      sharp = __require(path13);
       break;
     } catch (err) {
       errors5.push(err);
     }
   }
-  if (sharp && path9.startsWith("@img/sharp-linux-x64") && !sharp._isUsingX64V2()) {
+  if (sharp && path13.startsWith("@img/sharp-linux-x64") && !sharp._isUsingX64V2()) {
     const err = new Error("Prebuilt binaries for linux-x64 require v2 microarchitecture");
     err.code = "Unsupported CPU";
     errors5.push(err);
@@ -64668,7 +65118,7 @@ var require_sharp = __commonJS((exports, module) => {
   if (sharp) {
     module.exports = sharp;
   } else {
-    const [isLinux, isMacOs, isWindows] = ["linux", "darwin", "win32"].map((os3) => runtimePlatform.startsWith(os3));
+    const [isLinux, isMacOs, isWindows] = ["linux", "darwin", "win32"].map((os6) => runtimePlatform.startsWith(os6));
     const help = [`Could not load the "sharp" module using the ${runtimePlatform} runtime`];
     errors5.forEach((err) => {
       if (err.code !== "MODULE_NOT_FOUND") {
@@ -64681,9 +65131,9 @@ var require_sharp = __commonJS((exports, module) => {
       const { found, expected } = isUnsupportedNodeRuntime();
       help.push("- Please upgrade Node.js:", `    Found ${found}`, `    Requires ${expected}`);
     } else if (prebuiltPlatforms.includes(runtimePlatform)) {
-      const [os3, cpu] = runtimePlatform.split("-");
-      const libc = os3.endsWith("musl") ? " --libc=musl" : "";
-      help.push("- Ensure optional dependencies can be installed:", "    npm install --include=optional sharp", "- Ensure your package manager supports multi-platform installation:", "    See https://sharp.pixelplumbing.com/install#cross-platform", "- Add platform-specific dependencies:", `    npm install --os=${os3.replace("musl", "")}${libc} --cpu=${cpu} sharp`);
+      const [os6, cpu] = runtimePlatform.split("-");
+      const libc = os6.endsWith("musl") ? " --libc=musl" : "";
+      help.push("- Ensure optional dependencies can be installed:", "    npm install --include=optional sharp", "- Ensure your package manager supports multi-platform installation:", "    See https://sharp.pixelplumbing.com/install#cross-platform", "- Add platform-specific dependencies:", `    npm install --os=${os6.replace("musl", "")}${libc} --cpu=${cpu} sharp`);
     } else {
       help.push(`- Manually install libvips >= ${minimumLibvipsVersion}`, "- Add experimental WebAssembly-based dependencies:", "    npm install --cpu=wasm32 sharp", "    npm install @img/sharp-wasm32");
     }
@@ -67521,15 +67971,15 @@ var require_color = __commonJS((exports, module) => {
     };
   }
   function wrapConversion(toModel, graph) {
-    const path9 = [graph[toModel].parent, toModel];
+    const path13 = [graph[toModel].parent, toModel];
     let fn = conversions_default[graph[toModel].parent][toModel];
     let cur = graph[toModel].parent;
     while (graph[cur].parent) {
-      path9.unshift(graph[cur].parent);
+      path13.unshift(graph[cur].parent);
       fn = link(conversions_default[graph[cur].parent][cur], fn);
       cur = graph[cur].parent;
     }
-    fn.conversion = path9;
+    fn.conversion = path13;
     return fn;
   }
   function route(fromModel) {
@@ -68134,7 +68584,7 @@ var require_output = __commonJS((exports, module) => {
     Copyright 2013 Lovell Fuller and others.
     SPDX-License-Identifier: Apache-2.0
   */
-  var path9 = __require("path");
+  var path13 = __require("path");
   var is = require_is();
   var sharp = require_sharp();
   var formats = new Map([
@@ -68165,9 +68615,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) && path9.resolve(this.options.input.file) === path9.resolve(fileOut)) {
+    } else if (is.string(this.options.input.file) && path13.resolve(this.options.input.file) === path13.resolve(fileOut)) {
       err = new Error("Cannot use same file for input and output");
-    } else if (jp2Regex.test(path9.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
+    } else if (jp2Regex.test(path13.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
       err = errJp2Save();
     }
     if (err) {
@@ -75414,11 +75864,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 path9 = `${baseName}_data${i === 0 ? "" : "_" + i}`;
-            const fullPath = `${options.subfolder ?? ""}/${path9}`;
+            const path13 = `${baseName}_data${i === 0 ? "" : "_" + i}`;
+            const fullPath = `${options.subfolder ?? ""}/${path13}`;
             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: path9, data } : path9);
+              resolve4(data instanceof Uint8Array ? { path: path13, data } : path13);
             }));
           }
         } else if (session_options.externalData !== undefined) {
@@ -88482,7 +88932,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(path9) {
+        async save(path13) {
           let fn;
           if (_env_js__WEBPACK_IMPORTED_MODULE_3__.apis.IS_BROWSER_ENV) {
             if (_env_js__WEBPACK_IMPORTED_MODULE_3__.apis.IS_WEBWORKER_ENV) {
@@ -88490,14 +88940,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 (path10, blob) => {
+            fn = async (path14, blob) => {
               let buffer = await blob.arrayBuffer();
-              node_fs__WEBPACK_IMPORTED_MODULE_5__["default"].writeFileSync(path10, Buffer.from(buffer));
+              node_fs__WEBPACK_IMPORTED_MODULE_5__["default"].writeFileSync(path14, Buffer.from(buffer));
             };
           } else {
             throw new Error("Unable to save because filesystem is disabled in this environment.");
           }
-          await fn(path9, this.toBlob());
+          await fn(path13, this.toBlob());
         }
       }
     },
@@ -88593,11 +89043,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(path9, blob) {
+      function saveBlob(path13, blob) {
         const dataURL = URL.createObjectURL(blob);
         const downloadLink = document.createElement("a");
         downloadLink.href = dataURL;
-        downloadLink.download = path9;
+        downloadLink.download = path13;
         downloadLink.click();
         downloadLink.remove();
         URL.revokeObjectURL(dataURL);
@@ -89198,8 +89648,8 @@ ${fake_token_around_image}` + `${global_img_token}` + image_token.repeat(image_s
       }
 
       class FileCache {
-        constructor(path9) {
-          this.path = path9;
+        constructor(path13) {
+          this.path = path13;
         }
         async match(request) {
           let filePath = node_path__WEBPACK_IMPORTED_MODULE_1__["default"].join(this.path, request);
@@ -89955,20 +90405,20 @@ ${fake_token_around_image}` + `${global_img_token}` + image_token.repeat(image_s
           }
           return this;
         }
-        async save(path9) {
+        async save(path13) {
           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 = path9.split(".").pop().toLowerCase();
+            const extension = path13.split(".").pop().toLowerCase();
             const mime2 = CONTENT_TYPE_MAP.get(extension) ?? "image/png";
             const blob = await this.toBlob(mime2);
-            (0, _core_js__WEBPACK_IMPORTED_MODULE_0__.saveBlob)(path9, blob);
+            (0, _core_js__WEBPACK_IMPORTED_MODULE_0__.saveBlob)(path13, 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(path9);
+            return await img.toFile(path13);
           }
         }
         toSharp() {
@@ -99173,7 +99623,7 @@ Note that ${s.bold("include")} statements only accept relation fields.`, a12;
   function ns(e = Yo, t2 = Yo) {
     return (r2) => e(t2(r2));
   }
-  function os3({ dataPath: e, modelName: t2, args: r2, runtimeDataModel: n2 }) {
+  function os6({ dataPath: e, modelName: t2, args: r2, runtimeDataModel: n2 }) {
     let i = { modelName: t2, args: r2 ?? {} }, o = dp(e);
     if (!o || o.length === 0)
       return i;
@@ -99478,10 +99928,10 @@ Note that ${s.bold("include")} statements only accept relation fields.`, a12;
       super(t2, "P2023", r2);
     }
   };
-  var fs5 = new WeakMap;
+  var fs8 = new WeakMap;
   function Ep(e) {
-    let t2 = fs5.get(e);
-    return t2 || (t2 = Object.entries(e), fs5.set(e, t2)), t2;
+    let t2 = fs8.get(e);
+    return t2 || (t2 = Object.entries(e), fs8.set(e, t2)), t2;
   }
   function hs(e, t2, r2) {
     switch (t2.type) {
@@ -103046,7 +103496,7 @@ new PrismaClient({
           let m2 = await es(this, d);
           if (!d.model)
             return m2;
-          let g = os3({ dataPath: d.dataPath, modelName: d.model, args: d.args, runtimeDataModel: this._runtimeDataModel });
+          let g = os6({ dataPath: d.dataPath, modelName: d.model, args: d.args, runtimeDataModel: this._runtimeDataModel });
           return Wo({ result: m2, modelName: g.modelName, args: g.args, extensions: this._extensions, runtimeDataModel: this._runtimeDataModel, globalOmit: this._globalOmit });
         };
         return this._tracingHelper.runInChildSpan(s.operation, () => new zl.AsyncResource("prisma-client-request").runInAsyncScope(() => a12(o)));
@@ -103449,7 +103899,7 @@ var require_prisma = __commonJS((exports) => {
   Prisma.JsonNull = JsonNull2;
   Prisma.AnyNull = AnyNull2;
   Prisma.NullTypes = NullTypes2;
-  var path9 = __require("path");
+  var path13 = __require("path");
   exports.Prisma.TransactionIsolationLevel = makeStrictEnum2({
     ReadUncommitted: "ReadUncommitted",
     ReadCommitted: "ReadCommitted",
@@ -108044,7 +108494,7 @@ var init_vector_store_factory = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/search-cache-pg.js
-import crypto4 from "crypto";
+import crypto6 from "crypto";
 
 class SearchCachePg {
   pool = null;
@@ -108101,7 +108551,7 @@ class SearchCachePg {
       projectId,
       options: this.normalizeOptions(options)
     });
-    return crypto4.createHash("sha256").update(payload).digest("hex");
+    return crypto6.createHash("sha256").update(payload).digest("hex");
   }
   normalizeOptions(options) {
     const searchAffectingParams = [
@@ -114830,10 +115280,10 @@ var init_chunker_code = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/smart-chunker.js
-import path9 from "path";
+import path13 from "path";
 function smartChunk(content, filePath, config3 = {}) {
   const cfg = { ...DEFAULT_CONFIG, ...config3 };
-  const ext2 = path9.extname(filePath).toLowerCase();
+  const ext2 = path13.extname(filePath).toLowerCase();
   const relativePath = filePath;
   const fileImports = isCodeFile(ext2) ? extractFileImports(content, ext2) : undefined;
   let chunks;
@@ -115140,8 +115590,8 @@ var init_managed_run_repository_pg = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/project-indexer.js
-import fs5 from "fs/promises";
-import path10 from "path";
+import fs8 from "fs/promises";
+import path14 from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 async function runWithIndexLock(lockMap, projectId, work) {
   const prevLock = lockMap.get(projectId);
@@ -115184,7 +115634,7 @@ async function indexProjectInternal(deps, projectPath, projectId, options = {})
       dot: false
     });
     const filteredFiles = files.filter((file3) => {
-      const relativePath = path10.relative(projectPath, file3);
+      const relativePath = path14.relative(projectPath, file3);
       const shouldIgnore = ig.ignores(relativePath);
       if (shouldIgnore) {
         logger.debug("Ignoring file per .gitignore during indexing", {
@@ -115224,7 +115674,7 @@ async function indexProjectInternal(deps, projectPath, projectId, options = {})
         });
       }
     }
-    const indexedFilesList = filteredFiles.map((f) => path10.relative(projectPath, f));
+    const indexedFilesList = filteredFiles.map((f) => path14.relative(projectPath, f));
     await deps.indexManager.updateIndexMetadata(projectId, projectPath, indexedFilesList);
     logger.info("Project indexing completed", {
       projectId,
@@ -115349,7 +115799,7 @@ async function ensureFreshIndex(deps, projectId, projectPath, options = {}) {
   let errors5 = 0;
   for (const relativeFilePath of filesToReindex) {
     try {
-      const fullPath = path10.join(projectPath, relativeFilePath);
+      const fullPath = path14.join(projectPath, relativeFilePath);
       const result = await deps.indexFile(fullPath, projectId, projectPath, centralityMap);
       filesIndexed++;
       chunksIndexed += result.chunks;
@@ -115400,8 +115850,8 @@ async function checkSearchAdmission(deps, projectId, projectPath) {
 }
 async function indexFile(deps, filePath, projectId, projectRoot, centralityMap) {
   projectId = await getProjectIdentityAliasResolver().resolve(projectId);
-  const content = await fs5.readFile(filePath, "utf-8");
-  const relativePath = path10.relative(projectRoot, filePath);
+  const content = await fs8.readFile(filePath, "utf-8");
+  const relativePath = path14.relative(projectRoot, filePath);
   const maxFileSize = config.get("security").maxFileSize || 1024 * 1024;
   if (content.length > maxFileSize) {
     logger.warn("File too large, skipping", {
@@ -115421,7 +115871,7 @@ async function indexFile(deps, filePath, projectId, projectRoot, centralityMap)
       chunkIndex: i,
       totalChunks: chunks.length,
       type: chunk.type,
-      language: path10.extname(filePath).slice(1),
+      language: path14.extname(filePath).slice(1),
       lineStart: chunk.lineStart,
       lineEnd: chunk.lineEnd,
       label: chunk.label,
@@ -116260,8 +116710,8 @@ var init_index_job_tracker = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/discover.js
-import fs6 from "fs/promises";
-import path11 from "path";
+import fs9 from "fs/promises";
+import path15 from "path";
 import { createHash as createHash5 } from "crypto";
 
 class DiscoverStage {
@@ -116287,7 +116737,7 @@ class DiscoverStage {
         dot: false,
         absolute: false
       });
-      relPaths = found.map((p) => path11.isAbsolute(p) ? path11.relative(ctx.projectPath, p) : p).filter((p) => !ig.ignores(p) && applyPolicy(p, policy) !== "Drop");
+      relPaths = found.map((p) => path15.isAbsolute(p) ? path15.relative(ctx.projectPath, p) : p).filter((p) => !ig.ignores(p) && applyPolicy(p, policy) !== "Drop");
     }
     if (ctx.resumeCursor?.path) {
       const cursorPath = ctx.resumeCursor.path;
@@ -116346,10 +116796,10 @@ class DiscoverStage {
     return discovered;
   }
   async processFile(ctx, relativePath, forceReindex) {
-    const absolutePath = path11.join(ctx.projectPath, relativePath);
+    const absolutePath = path15.join(ctx.projectPath, relativePath);
     try {
-      const stat2 = await fs6.stat(absolutePath);
-      const content = await fs6.readFile(absolutePath, "utf-8");
+      const stat2 = await fs9.stat(absolutePath);
+      const content = await fs9.readFile(absolutePath, "utf-8");
       const contentHash = createHash5("sha256").update(content).digest("hex");
       let needsReparse = forceReindex;
       if (!forceReindex) {
@@ -116392,8 +116842,8 @@ class DiscoverStage {
       ig.add(pattern);
     }
     try {
-      const gitignorePath = path11.join(projectPath, ".gitignore");
-      const gitignoreContent = await fs6.readFile(gitignorePath, "utf8");
+      const gitignorePath = path15.join(projectPath, ".gitignore");
+      const gitignoreContent = await fs9.readFile(gitignorePath, "utf8");
       const rules = gitignoreContent.split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
       ig.add(rules);
@@ -117748,8 +118198,8 @@ function rustUseLeaves(node2, source, prefix = []) {
   }
   if (node2.type === "use_wildcard")
     return [{ path: [...prefix, "*"], glob: true }];
-  const path12 = rustPathSegments(node2, source);
-  return path12.length ? [{ path: [...prefix, ...path12] }] : [];
+  const path16 = rustPathSegments(node2, source);
+  return path16.length ? [{ path: [...prefix, ...path16] }] : [];
 }
 function functionalCaptures(captures, source, family) {
   if (family !== "clojure")
@@ -118721,8 +119171,8 @@ var init_structural_runtime = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/parse.js
-import path12 from "path";
-import fs7 from "fs/promises";
+import path16 from "path";
+import fs10 from "fs/promises";
 function resolveChunkerMaxChars() {
   const global2 = Number(process.env.EMBEDDING_MAX_CHARS);
   if (Number.isFinite(global2) && global2 > 0)
@@ -118750,8 +119200,8 @@ class ParseStage {
     const results = new Map;
     let processed = 0;
     const phases = [
-      files.filter((file3) => path12.extname(file3.relativePath).toLowerCase() !== ".h"),
-      files.filter((file3) => path12.extname(file3.relativePath).toLowerCase() === ".h")
+      files.filter((file3) => path16.extname(file3.relativePath).toLowerCase() !== ".h"),
+      files.filter((file3) => path16.extname(file3.relativePath).toLowerCase() === ".h")
     ];
     const batches = phases.flatMap((phase) => Array.from({ length: Math.ceil(phase.length / BATCH_SIZE) }, (_2, index) => phase.slice(index * BATCH_SIZE, (index + 1) * BATCH_SIZE)));
     for (const batch of batches) {
@@ -118789,19 +119239,19 @@ class ParseStage {
     return files.map((file3) => results.get(file3.relativePath));
   }
   recordHeaderImporterEvidence(ctx, files, parsedFiles) {
-    const knownHeaders = new Set(files.filter((file3) => path12.extname(file3.relativePath).toLowerCase() === ".h").map((file3) => path12.posix.normalize(file3.relativePath)));
+    const knownHeaders = new Set(files.filter((file3) => path16.extname(file3.relativePath).toLowerCase() === ".h").map((file3) => path16.posix.normalize(file3.relativePath)));
     const mutable = {
       ...ctx.structuralHeaderEvidenceByFile
     };
     for (const parsed of parsedFiles) {
-      const extension = path12.extname(parsed.file.relativePath).toLowerCase();
+      const extension = path16.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 = path12.posix.normalize(path12.posix.join(path12.posix.dirname(parsed.file.relativePath), imported.specifier));
+        const header = path16.posix.normalize(path16.posix.join(path16.posix.dirname(parsed.file.relativePath), imported.specifier));
         if (!knownHeaders.has(header))
           continue;
         const existing = mutable[header] ?? {};
@@ -118812,9 +119262,9 @@ class ParseStage {
   }
   async parseFile(ctx, file3) {
     if (!file3.needsReparse) {
-      const extension = path12.extname(file3.relativePath).toLowerCase();
+      const extension = path16.extname(file3.relativePath).toLowerCase();
       if ([".c", ".cpp", ".hpp"].includes(extension)) {
-        const content = file3.snapshotContent ?? await fs7.readFile(file3.absolutePath, "utf8");
+        const content = file3.snapshotContent ?? await fs10.readFile(file3.absolutePath, "utf8");
         const outcome = await this.runtime.parse({ extension, source: Buffer.from(content) });
         if (outcome.status === "failed")
           throw new StructuralEtlParseError(file3.relativePath, outcome.failureKind, `Structural evidence parse failed (${outcome.failureKind})`, outcome.diagnosticCount, outcome.diagnostics.slice(0, 10));
@@ -118826,8 +119276,8 @@ class ParseStage {
       return { file: file3, chunks: [], symbols: [], rawImports: [], rawEdges: [] };
     }
     try {
-      const content = file3.snapshotContent ?? await fs7.readFile(file3.absolutePath, "utf-8");
-      const ext2 = path12.extname(file3.relativePath).toLowerCase();
+      const content = file3.snapshotContent ?? await fs10.readFile(file3.absolutePath, "utf-8");
+      const ext2 = path16.extname(file3.relativePath).toLowerCase();
       const chunkerMaxChars = resolveChunkerMaxChars();
       const chunks = smartChunk(content, file3.relativePath, chunkerMaxChars ? { maxChunkChars: chunkerMaxChars } : {});
       let symbols;
@@ -119381,7 +119831,7 @@ var init_resolver = __esm(() => {
 });
 
 // ../../packages/core/dist/services/structural/resolvers/typescript.js
-import path13 from "path";
+import path17 from "path";
 function candidates(identities) {
   return Object.freeze(identities.map((identity) => Object.freeze({
     fqn: identity.fqn,
@@ -119476,7 +119926,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 = path13.posix.normalize(`${candidateBase}${suffix}`);
+      const value = path17.posix.normalize(`${candidateBase}${suffix}`);
       if (!value.startsWith("../") && value !== ".." && known.has(value))
         return value;
     }
@@ -119485,7 +119935,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(path13.posix.join(path13.posix.dirname(fromFile), specifier), known, dialect);
+    return probe(path17.posix.join(path17.posix.dirname(fromFile), specifier), known, dialect);
   }
   const aliases = build.pathAliasesByFile?.[normalizeStructuralFile(fromFile)] ?? build.pathAliases ?? [];
   for (const alias of aliases) {
@@ -119749,7 +120199,7 @@ var init_scripting2 = __esm(() => {
 });
 
 // ../../packages/core/dist/services/structural/resolvers/systems.js
-import path14 from "path";
+import path18 from "path";
 var DIALECTS, SYSTEMS_LANGUAGE_RESOLVER;
 var init_systems2 = __esm(() => {
   init_typescript2();
@@ -119768,7 +120218,7 @@ var init_systems2 = __esm(() => {
           const bindings = item.bindings.map((binding) => binding.imported === "*" && binding.local === "*" && unresolvedTarget && !unresolvedTarget.qualifier ? { ...binding, imported: unresolvedTarget.name, local: unresolvedTarget.name } : binding);
           if (item.specifier === "crate" || item.specifier.startsWith("crate/")) {
             const crateRoot = file3.file.startsWith("src/") ? "src" : "";
-            return { ...item, bindings, specifier: `./${path14.posix.relative(path14.posix.dirname(file3.file), path14.posix.join(crateRoot, item.specifier.replace(/^crate\/?/u, "")))}` };
+            return { ...item, bindings, specifier: `./${path18.posix.relative(path18.posix.dirname(file3.file), path18.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, "")}` };
@@ -119866,8 +120316,8 @@ var init_data_document2 = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/resolve.js
-import path15 from "path";
-import fs8 from "fs";
+import path19 from "path";
+import fs11 from "fs";
 
 class ResolveStage {
   symbolRepository;
@@ -119891,7 +120341,7 @@ class ResolveStage {
     const structuralDocuments = files.flatMap((file3) => {
       if (!file3.structure)
         return [];
-      const language = resolveStructuralLanguage(path15.extname(file3.file.relativePath));
+      const language = resolveStructuralLanguage(path19.extname(file3.file.relativePath));
       if (language.status !== "supported")
         throw new Error(`structural_manifest_missing:${file3.file.relativePath}`);
       return [{
@@ -119903,13 +120353,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(path15.extname(item.file.relativePath).toLowerCase())).map((item) => item.file.relativePath));
+    const skippedStructuralFiles = new Set(files.filter((item) => !item.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path19.extname(item.file.relativePath).toLowerCase())).map((item) => item.file.relativePath));
     const pathAliasesByFile = Object.fromEntries([...knownRelPaths].map((file3) => [
       file3,
       this.structuralAliasesFor(file3, rootAliases, monorepoPackages)
     ]));
     const buildMetadata = { knownFiles: [...knownRelPaths], pathAliasesByFile };
-    const seedRows = repositoryDefinitions.filter((definition) => STRUCTURAL_SEED_EXTENSIONS.has(path15.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(path19.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))
@@ -120002,7 +120452,7 @@ class ResolveStage {
     if (parsed.file !== definition.file_path) {
       throw new Error(`structural_repository_seed_file_mismatch:${definition.id}`);
     }
-    const language = resolveStructuralLanguage(path15.extname(definition.file_path));
+    const language = resolveStructuralLanguage(path19.extname(definition.file_path));
     if (language.status !== "supported")
       throw new Error(`structural_repository_seed_language:${definition.id}`);
     let identity;
@@ -120054,7 +120504,7 @@ class ResolveStage {
     });
   }
   resolveFile(parsed, projectPath, knownRelPaths, rootAliases, monorepoPackages, symbolIndex, knownFqns) {
-    const fromDir = path15.dirname(path15.join(projectPath, parsed.file.relativePath));
+    const fromDir = path19.dirname(path19.join(projectPath, parsed.file.relativePath));
     const packageAliases = this.getPackageAliases(parsed.file.relativePath, monorepoPackages);
     const allAliases = [...packageAliases, ...rootAliases];
     const resolvedImports = parsed.rawImports.map((raw2) => {
@@ -120125,7 +120575,7 @@ class ResolveStage {
         index.set(def.name, `${def.file_path}#${def.name}`);
       }
     } catch (err) {
-      const skippedStructural = files.some((file3) => !file3.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path15.extname(file3.file.relativePath).toLowerCase()));
+      const skippedStructural = files.some((file3) => !file3.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path19.extname(file3.file.relativePath).toLowerCase()));
       if (skippedStructural)
         throw new Error("structural_repository_seed_failed", { cause: err });
       logger.warn("buildSymbolIndex: repo seed failed, in-batch only", {
@@ -120149,7 +120599,7 @@ class ResolveStage {
   }
   resolveSpecifier(specifier, fromDir, projectPath, knownRelPaths, aliases) {
     if (specifier.startsWith("./") || specifier.startsWith("../")) {
-      const resolved = this.probeExtensions(path15.resolve(fromDir, specifier), projectPath, knownRelPaths);
+      const resolved = this.probeExtensions(path19.resolve(fromDir, specifier), projectPath, knownRelPaths);
       return { resolvedPath: resolved, external: false };
     }
     for (const alias of aliases) {
@@ -120157,8 +120607,8 @@ class ResolveStage {
         const suffix = specifier.slice(alias.prefix.length);
         for (const target of alias.targets) {
           const cleanTarget = target.replace(/\/\*$/, "");
-          const basePath = alias.packagePath ? path15.join(projectPath, alias.packagePath) : projectPath;
-          const absPath = path15.join(basePath, cleanTarget + suffix);
+          const basePath = alias.packagePath ? path19.join(projectPath, alias.packagePath) : projectPath;
+          const absPath = path19.join(basePath, cleanTarget + suffix);
           const resolved = this.probeExtensions(absPath, projectPath, knownRelPaths);
           if (resolved)
             return { resolvedPath: resolved, external: false };
@@ -120174,7 +120624,7 @@ class ResolveStage {
       ...TS_EXTENSIONS.map((ext2) => absPath.replace(/\.[^.]+$/, ext2))
     ];
     for (const candidate2 of candidates2) {
-      const rel = path15.relative(projectPath, candidate2).replace(/\\/g, "/");
+      const rel = path19.relative(projectPath, candidate2).replace(/\\/g, "/");
       if (knownRelPaths.has(rel))
         return rel;
     }
@@ -120182,9 +120632,9 @@ class ResolveStage {
   }
   loadTsConfigPaths(projectPath, packageBase) {
     const aliases = [];
-    const tsconfigPath = path15.join(projectPath, "tsconfig.json");
+    const tsconfigPath = path19.join(projectPath, "tsconfig.json");
     try {
-      const raw2 = fs8.readFileSync(tsconfigPath, "utf-8");
+      const raw2 = fs11.readFileSync(tsconfigPath, "utf-8");
       const stripped = raw2.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
       const tsconfig = JSON.parse(stripped);
       const paths = tsconfig?.compilerOptions?.paths ?? {};
@@ -120213,7 +120663,7 @@ class ResolveStage {
       }
     }
     for (const packageRelPath of packagePaths) {
-      const absPackagePath = path15.join(projectPath, packageRelPath);
+      const absPackagePath = path19.join(projectPath, packageRelPath);
       const aliases = this.loadTsConfigPaths(absPackagePath, packageRelPath);
       if (aliases.length > 0) {
         packages.push({
@@ -120243,7 +120693,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 ? path15.posix.join(alias.packagePath, target) : target)
+      targets: alias.targets.map((target) => alias.packagePath ? path19.posix.join(alias.packagePath, target) : target)
     }));
   }
 }
@@ -120307,7 +120757,7 @@ var init_with_deadlock_retry = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/load.js
-import path16 from "path";
+import path20 from "path";
 function formatDuration(ms) {
   const totalSec = Math.max(0, Math.round(ms / 1000));
   if (totalSec < 60)
@@ -120577,7 +121027,7 @@ class LoadStage {
     const filePath = file3.file.relativePath;
     const batch = buildSymbolPersistenceBatch(ctx.projectId, file3);
     if (ctx.graphGenerationLease) {
-      const manifest = getLanguageManifestEntry(path16.extname(filePath));
+      const manifest = getLanguageManifestEntry(path20.extname(filePath));
       const diagnostics2 = (file3.structuralDiagnostics ?? []).slice(0, 10).map((diagnostic2) => ({
         code: diagnostic2.code,
         severity: diagnostic2.severity,
@@ -121033,9 +121483,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 path17 from "path";
+import path21 from "path";
 function buildHeaderLanguageEvidence(files) {
-  const headers = new Set(files.filter((file3) => path17.posix.extname(file3.relativePath).toLowerCase() === ".h").map((file3) => path17.posix.normalize(file3.relativePath)));
+  const headers = new Set(files.filter((file3) => path21.posix.extname(file3.relativePath).toLowerCase() === ".h").map((file3) => path21.posix.normalize(file3.relativePath)));
   const mutable = new Map;
   const entry2 = (header) => {
     let value = mutable.get(header);
@@ -121046,7 +121496,7 @@ function buildHeaderLanguageEvidence(files) {
     return value;
   };
   for (const file3 of files) {
-    if (path17.posix.basename(file3.relativePath) !== "compile_commands.json" || file3.snapshotContent === undefined)
+    if (path21.posix.basename(file3.relativePath) !== "compile_commands.json" || file3.snapshotContent === undefined)
       continue;
     let commands;
     try {
@@ -121062,11 +121512,11 @@ function buildHeaderLanguageEvidence(files) {
       const record2 = command;
       if (typeof record2.file !== "string")
         continue;
-      const projectRoot = path17.resolve(file3.absolutePath, ...file3.relativePath.split("/").map(() => ".."));
-      const commandDirectory = typeof record2.directory === "string" ? path17.resolve(projectRoot, record2.directory) : projectRoot;
-      const absoluteInput = path17.resolve(commandDirectory, record2.file);
-      const relative2 = path17.relative(projectRoot, absoluteInput);
-      const header = path17.posix.normalize(relative2.replaceAll(path17.sep, "/"));
+      const projectRoot = path21.resolve(file3.absolutePath, ...file3.relativePath.split("/").map(() => ".."));
+      const commandDirectory = typeof record2.directory === "string" ? path21.resolve(projectRoot, record2.directory) : projectRoot;
+      const absoluteInput = path21.resolve(commandDirectory, record2.file);
+      const relative2 = path21.relative(projectRoot, absoluteInput);
+      const header = path21.posix.normalize(relative2.replaceAll(path21.sep, "/"));
       if (!headers.has(header))
         continue;
       const invocation = typeof record2.command === "string" ? record2.command : Array.isArray(record2.arguments) ? record2.arguments.join(" ") : "";
@@ -122218,16 +122668,16 @@ function detectRoutes(httpEdges, defs, opts = {}) {
   const seen = new Set;
   const out = [];
   for (const e of httpEdges) {
-    const path19 = e.route;
-    if (!path19)
+    const path23 = e.route;
+    if (!path23)
       continue;
     const method = (e.method ?? "ANY").toUpperCase();
-    const key = method + " " + path19;
+    const key = method + " " + path23;
     if (seen.has(key))
       continue;
     seen.add(key);
     out.push({
-      path: path19,
+      path: path23,
       method: e.method,
       file: e.fromFile,
       handler: e.targetFqn ?? e.symbolName
@@ -122238,12 +122688,12 @@ function detectRoutes(httpEdges, defs, opts = {}) {
       continue;
     const parsed = parseRouteName(d.name);
     const method = parsed?.method ?? "ANY";
-    const path19 = parsed?.path ?? d.name;
-    const key = method + " " + path19;
+    const path23 = parsed?.path ?? d.name;
+    const key = method + " " + path23;
     if (seen.has(key))
       continue;
     seen.add(key);
-    out.push({ path: path19, method: parsed?.method, file: d.filePath, handler: d.name });
+    out.push({ path: path23, method: parsed?.method, file: d.filePath, handler: d.name });
   }
   for (const d of defs) {
     const parsed = parseRouteName(d.name);
@@ -122464,8 +122914,8 @@ __export(exports_symbol_graph_service, {
   symbolGraphService: () => symbolGraphService,
   SymbolGraphService: () => SymbolGraphService
 });
-import path19 from "path";
-import fs9 from "fs/promises";
+import path23 from "path";
+import fs12 from "fs/promises";
 
 class SymbolGraphService {
   identityLookup;
@@ -122793,7 +123243,7 @@ class SymbolGraphService {
   async readSnippet(relativePath, lineStart, lineEnd, projectId) {
     try {
       const absolutePath = await this.resolveToAbsolute(relativePath, projectId);
-      const content = await fs9.readFile(absolutePath, "utf-8");
+      const content = await fs12.readFile(absolutePath, "utf-8");
       const lines = content.split(`
 `);
       return lines.slice(Math.max(0, lineStart - 1), Math.min(lines.length, lineEnd)).join(`
@@ -122805,7 +123255,7 @@ class SymbolGraphService {
   async readContext(relativePath, lineNumber, contextLines, projectId) {
     try {
       const absolutePath = await this.resolveToAbsolute(relativePath, projectId);
-      const content = await fs9.readFile(absolutePath, "utf-8");
+      const content = await fs12.readFile(absolutePath, "utf-8");
       const lines = content.split(`
 `);
       const start = Math.max(0, lineNumber - contextLines - 1);
@@ -122818,7 +123268,7 @@ class SymbolGraphService {
   }
   async resolveToAbsolute(relativePath, projectId) {
     const root = await this.getProjectRoot(projectId);
-    return root ? path19.resolve(root, relativePath) : relativePath;
+    return root ? path23.resolve(root, relativePath) : relativePath;
   }
   async getProjectRoot(projectId) {
     const cached2 = this.projectRootCache.get(projectId);
@@ -126808,31 +127258,31 @@ class TracePathService {
     const chains = [];
     const seen = new Set;
     let walks = 0;
-    const walk = (fqn, path22) => {
+    const walk = (fqn, path26) => {
       if (chains.length >= CHAIN_CAP)
         return;
       if (walks >= MAX_WALKS)
         return;
       walks++;
-      const key = path22.join("\u2192");
+      const key = path26.join("\u2192");
       if (seen.has(key))
         return;
       seen.add(key);
       const next = adj.get(fqn);
       if (!next || next.length === 0 || !whoHasChild.has(fqn)) {
-        if (path22.length > 1)
-          chains.push(path22.map((n2) => this.fqnToName(n2)).join(" \u2192 "));
+        if (path26.length > 1)
+          chains.push(path26.map((n2) => this.fqnToName(n2)).join(" \u2192 "));
         return;
       }
       for (const child of next) {
         if (chains.length >= CHAIN_CAP || walks >= MAX_WALKS)
           return;
-        if (path22.includes(child)) {
-          const cycled = [...path22, `${this.fqnToName(child)}\u21BA`];
+        if (path26.includes(child)) {
+          const cycled = [...path26, `${this.fqnToName(child)}\u21BA`];
           chains.push(cycled.map((n2) => n2).join(" \u2192 "));
           continue;
         }
-        walk(child, [...path22, child]);
+        walk(child, [...path26, child]);
       }
     };
     for (const seed of seeds) {
@@ -126874,7 +127324,7 @@ var init_git_ref_validation = __esm(() => {
 });
 
 // ../../packages/core/dist/services/symbol/impact-analysis.js
-import { execFileSync } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
 function readBfsCteFlag() {
   try {
     return Boolean(config.get("impact")?.bfsCteEnabled);
@@ -127200,19 +127650,19 @@ function defaultDiffRunner(projectPath2, scope, baseBranch, since) {
     let diffRange;
     if (since) {
       try {
-        ref = execFileSync("git", ["-C", projectPath2, "rev-parse", "--verify", `${since}^{commit}`], {
+        ref = execFileSync2("git", ["-C", projectPath2, "rev-parse", "--verify", `${since}^{commit}`], {
           cwd: projectPath2,
           encoding: "utf-8",
           stdio: ["ignore", "pipe", "pipe"]
         }).trim();
       } catch {
-        ref = execFileSync("git", ["-C", projectPath2, "rev-list", "-1", `--before=${since}`, "HEAD"], {
+        ref = execFileSync2("git", ["-C", projectPath2, "rev-list", "-1", `--before=${since}`, "HEAD"], {
           cwd: projectPath2,
           encoding: "utf-8",
           stdio: ["ignore", "pipe", "pipe"]
         }).trim();
         if (!ref) {
-          const emptyTree = execFileSync("git", ["hash-object", "-t", "tree", "--stdin"], {
+          const emptyTree = execFileSync2("git", ["hash-object", "-t", "tree", "--stdin"], {
             cwd: projectPath2,
             encoding: "utf-8",
             input: "",
@@ -127224,7 +127674,7 @@ function defaultDiffRunner(projectPath2, scope, baseBranch, since) {
     }
     args.push(diffRange ?? `${ref}...HEAD`);
   }
-  const out = execFileSync("git", args, {
+  const out = execFileSync2("git", args, {
     cwd: projectPath2,
     encoding: "utf-8",
     stdio: ["ignore", "pipe", "pipe"],
@@ -127236,7 +127686,7 @@ function defaultDiffRunner(projectPath2, scope, baseBranch, since) {
   let untrackedFiltered = 0;
   const merged = new Set(tracked);
   if (includeUntracked) {
-    const untracked = execFileSync("git", ["-C", projectPath2, "ls-files", "--others", "--exclude-standard"], {
+    const untracked = execFileSync2("git", ["-C", projectPath2, "ls-files", "--others", "--exclude-standard"], {
       cwd: projectPath2,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"],
@@ -127274,7 +127724,7 @@ var init_impact_analysis = __esm(() => {
 });
 
 // ../../packages/core/dist/services/executor/runtime.js
-import { execFileSync as execFileSync2, execSync } from "child_process";
+import { execFileSync as execFileSync3, execSync } from "child_process";
 function commandExists(cmd) {
   try {
     const check3 = isWindows ? `where ${cmd}` : `command -v ${cmd}`;
@@ -127307,7 +127757,7 @@ function getVersion(cmd, args = ["--version"], deps) {
         timeout: 5000
       }).trim().split(/\r?\n/)[0];
     }
-    return execFileSync2(cmd, args, {
+    return execFileSync3(cmd, args, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5000
@@ -127448,12 +127898,12 @@ var init_runtime = __esm(() => {
 
 // ../../packages/core/dist/services/executor/sandbox.js
 import { realpathSync as realpathSync2 } from "fs";
-import { execFileSync as execFileSync3 } from "child_process";
+import { execFileSync as execFileSync4 } from "child_process";
 function isDockerAvailable() {
   if (_dockerAvailable !== null)
     return _dockerAvailable;
   try {
-    execFileSync3("docker", ["--version"], { stdio: "pipe", timeout: 5000 });
+    execFileSync4("docker", ["--version"], { stdio: "pipe", timeout: 5000 });
     _dockerAvailable = true;
   } catch {
     _dockerAvailable = false;
@@ -127464,7 +127914,7 @@ function isSeatbeltAvailable() {
   if (_seatbeltAvailable !== null)
     return _seatbeltAvailable;
   try {
-    execFileSync3("sandbox-exec", ["--version"], { stdio: "pipe", timeout: 5000 });
+    execFileSync4("sandbox-exec", ["--version"], { stdio: "pipe", timeout: 5000 });
     _seatbeltAvailable = true;
   } catch {
     _seatbeltAvailable = false;
@@ -127569,7 +128019,7 @@ var init_sandbox = __esm(() => {
 });
 
 // ../../packages/core/dist/services/executor/executor.js
-import { spawn, execSync as execSync2, execFileSync as execFileSync4 } from "child_process";
+import { spawn, execSync as execSync2, execFileSync as execFileSync5 } from "child_process";
 import { mkdtempSync, writeFileSync as writeFileSync2, rmSync, realpathSync as realpathSync3 } from "fs";
 import { join as join3, resolve as resolve5, isAbsolute, relative as relative2 } from "path";
 import { tmpdir } from "os";
@@ -127772,7 +128222,7 @@ ${body}`;
     const binPath = srcPath.replace(/\.rs$/, isWin ? ".exe" : "");
     try {
       try {
-        execFileSync4("rustc", [srcPath, "-o", binPath], {
+        execFileSync5("rustc", [srcPath, "-o", binPath], {
           cwd,
           timeout: Math.min(timeout, 60000),
           encoding: "utf-8",
@@ -129974,9 +130424,9 @@ var init_l1_memory_cache = __esm(() => {
 });
 
 // ../../packages/core/dist/services/health/local-health-checker.js
-import fs12 from "fs/promises";
+import fs15 from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import path24 from "path";
+import path28 from "path";
 
 class LocalHealthChecker {
   ollamaBaseUrl = process.env.OLLAMA_BASE_URL || "http://localhost:11434";
@@ -130010,10 +130460,10 @@ class LocalHealthChecker {
     const start = Date.now();
     try {
       if (!existsSync3(this.dataDir))
-        await fs12.mkdir(this.dataDir, { recursive: true });
-      const probe2 = path24.join(this.dataDir, ".health-check-test");
-      await fs12.writeFile(probe2, "ok");
-      await fs12.unlink(probe2);
+        await fs15.mkdir(this.dataDir, { recursive: true });
+      const probe2 = path28.join(this.dataDir, ".health-check-test");
+      await fs15.writeFile(probe2, "ok");
+      await fs15.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}` };
@@ -131923,9 +132373,9 @@ var init_scheduler2 = __esm(() => {
 });
 
 // ../../packages/core/dist/services/pricing/models-dev-client.js
-import fs13 from "fs/promises";
+import fs16 from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import path25 from "path";
+import path29 from "path";
 function getModelsDevClient() {
   if (!clientInstance) {
     clientInstance = new ModelsDevClient;
@@ -131945,7 +132395,7 @@ var init_models_dev_client = __esm(() => {
     memoryCacheTimestamp = 0;
     getLocalCachePath() {
       const dataDir = config.get("dataDir");
-      return path25.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
+      return path29.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
     }
     async loadLocalCache() {
       const cachePath = this.getLocalCachePath();
@@ -131953,7 +132403,7 @@ var init_models_dev_client = __esm(() => {
         if (!existsSync4(cachePath)) {
           return null;
         }
-        const content = await fs13.readFile(cachePath, "utf-8");
+        const content = await fs16.readFile(cachePath, "utf-8");
         const data = JSON.parse(content);
         const age = Date.now() - data.timestamp;
         if (age > ModelsDevClient.LOCAL_CACHE_TTL) {
@@ -131980,14 +132430,14 @@ var init_models_dev_client = __esm(() => {
     async saveLocalCache(models) {
       const cachePath = this.getLocalCachePath();
       try {
-        const dir = path25.dirname(cachePath);
-        await fs13.mkdir(dir, { recursive: true });
+        const dir = path29.dirname(cachePath);
+        await fs16.mkdir(dir, { recursive: true });
         const data = {
           timestamp: Date.now(),
           version: "1.0.0",
           models: Object.fromEntries(models)
         };
-        await fs13.writeFile(cachePath, JSON.stringify(data), "utf-8");
+        await fs16.writeFile(cachePath, JSON.stringify(data), "utf-8");
         logger.debug("Saved pricing to local cache", {
           models: models.size,
           path: cachePath
@@ -132316,7 +132766,7 @@ var init_models_dev_client = __esm(() => {
       const cachePath = this.getLocalCachePath();
       try {
         if (existsSync4(cachePath)) {
-          await fs13.unlink(cachePath);
+          await fs16.unlink(cachePath);
           logger.debug("Local pricing cache file deleted");
         }
       } catch (error51) {
@@ -137871,33 +138321,33 @@ var require_URL = __commonJS((exports, module) => {
         else
           return basepath.substring(0, lastslash + 1) + refpath;
       }
-      function remove_dot_segments(path26) {
-        if (!path26)
-          return path26;
+      function remove_dot_segments(path30) {
+        if (!path30)
+          return path30;
         var output = "";
-        while (path26.length > 0) {
-          if (path26 === "." || path26 === "..") {
-            path26 = "";
+        while (path30.length > 0) {
+          if (path30 === "." || path30 === "..") {
+            path30 = "";
             break;
           }
-          var twochars = path26.substring(0, 2);
-          var threechars = path26.substring(0, 3);
-          var fourchars = path26.substring(0, 4);
+          var twochars = path30.substring(0, 2);
+          var threechars = path30.substring(0, 3);
+          var fourchars = path30.substring(0, 4);
           if (threechars === "../") {
-            path26 = path26.substring(3);
+            path30 = path30.substring(3);
           } else if (twochars === "./") {
-            path26 = path26.substring(2);
+            path30 = path30.substring(2);
           } else if (threechars === "/./") {
-            path26 = "/" + path26.substring(3);
-          } else if (twochars === "/." && path26.length === 2) {
-            path26 = "/";
-          } else if (fourchars === "/../" || threechars === "/.." && path26.length === 3) {
-            path26 = "/" + path26.substring(4);
+            path30 = "/" + path30.substring(3);
+          } else if (twochars === "/." && path30.length === 2) {
+            path30 = "/";
+          } else if (fourchars === "/../" || threechars === "/.." && path30.length === 3) {
+            path30 = "/" + path30.substring(4);
             output = output.replace(/\/?[^\/]*$/, "");
           } else {
-            var segment = path26.match(/(\/?([^\/]*))/)[0];
+            var segment = path30.match(/(\/?([^\/]*))/)[0];
             output += segment;
-            path26 = path26.substring(segment.length);
+            path30 = path30.substring(segment.length);
           }
         }
         return output;
@@ -149967,21 +150417,21 @@ function jsonToKeyPathChunks(value, label = "$") {
   walk(value, label, out);
   return out;
 }
-function walk(val, path26, out) {
+function walk(val, path30, out) {
   if (val === null || val === undefined)
     return;
   if (Array.isArray(val)) {
     if (val.length === 0) {
-      out.push({ path: path26, content: `**${path26}** = _[]_` });
+      out.push({ path: path30, content: `**${path30}** = _[]_` });
       return;
     }
     if (val.every((v) => v !== null && typeof v === "object")) {
-      val.forEach((v, i) => walk(v, `${path26}[${i}]`, out));
+      val.forEach((v, i) => walk(v, `${path30}[${i}]`, out));
       return;
     }
     const items = val.map((v) => `- \`${String(v)}\``).join(`
 `);
-    out.push({ path: path26, content: `**${path26}**
+    out.push({ path: path30, content: `**${path30}**
 
 ${items}` });
     return;
@@ -149989,16 +150439,16 @@ ${items}` });
   if (typeof val === "object") {
     const entries = Object.entries(val);
     if (entries.length === 0) {
-      out.push({ path: path26, content: `**${path26}** = _{}_` });
+      out.push({ path: path30, content: `**${path30}** = _{}_` });
       return;
     }
     for (const [k2, v] of entries) {
       const safeKey = /^[A-Za-z_$][\w$]*$/.test(k2) ? k2 : JSON.stringify(k2);
-      walk(v, `${path26}.${safeKey}`, out);
+      walk(v, `${path30}.${safeKey}`, out);
     }
     return;
   }
-  out.push({ path: path26, content: `**${path26}** = \`${String(val)}\`` });
+  out.push({ path: path30, content: `**${path30}** = \`${String(val)}\`` });
 }
 var gfm, STRIP_SELECTORS, tdCache = null;
 var init_html_to_md = __esm(() => {
@@ -172986,9 +173436,9 @@ async function acquireIndexingLease(request) {
 
 // ../../packages/core/dist/services/project-identity/project-root-identity.js
 import { realpath as realpath2 } from "fs/promises";
-import path18 from "path";
+import path22 from "path";
 async function canonicalizeProjectRoot(projectPath, canonicalize = realpath2) {
-  return canonicalize(path18.resolve(projectPath));
+  return canonicalize(path22.resolve(projectPath));
 }
 async function assertProjectRootReuse(options) {
   if (!options.storedProjectPath || options.forceReindex)
@@ -172996,9 +173446,9 @@ async function assertProjectRootReuse(options) {
   const canonicalize = options.canonicalize ?? realpath2;
   let storedCanonical;
   try {
-    storedCanonical = await canonicalize(path18.resolve(options.storedProjectPath));
+    storedCanonical = await canonicalize(path22.resolve(options.storedProjectPath));
   } catch {
-    storedCanonical = path18.resolve(options.storedProjectPath);
+    storedCanonical = path22.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");
@@ -173008,7 +173458,7 @@ async function assertProjectRootReuse(options) {
 // ../../packages/core/dist/tools/index_project.js
 init_workspace_manager();
 init_parser_readiness();
-import path20 from "path";
+import path24 from "path";
 
 class IndexProjectTool {
   name = "index_project";
@@ -173056,7 +173506,7 @@ class IndexProjectTool {
     try {
       await assertParserReadyForIndexing();
       const canonicalProjectPath = await canonicalizeProjectRoot(projectPath);
-      const finalProjectId = projectId || path20.basename(canonicalProjectPath) || "default";
+      const finalProjectId = projectId || path24.basename(canonicalProjectPath) || "default";
       const existing = await workspaceManager.getWorkspace(finalProjectId);
       await assertProjectRootReuse({
         projectId: finalProjectId,
@@ -173234,7 +173684,7 @@ function normalizeValue(value) {
     return Array.from(value).map(normalizeValue);
   if (value instanceof Map)
     return Object.fromEntries(Array.from(value, ([k2, v]) => [String(k2), normalizeValue(v)]));
-  if (isPlainObject3(value)) {
+  if (isPlainObject4(value)) {
     const encodedValues = {};
     for (const key in value)
       if (Object.hasOwn(value, key))
@@ -173255,7 +173705,7 @@ function isJsonObject(value) {
 function isEmptyObject(value) {
   return Object.keys(value).length === 0;
 }
-function isPlainObject3(value) {
+function isPlainObject4(value) {
   if (value === null || typeof value !== "object")
     return false;
   const prototype = Object.getPrototypeOf(value);
@@ -173610,17 +174060,17 @@ function applyReplacer(root, replacer) {
     return transformChildren(root, replacer, []);
   return transformChildren(normalizeValue(replacedRoot), replacer, []);
 }
-function transformChildren(value, replacer, path21) {
+function transformChildren(value, replacer, path25) {
   if (isJsonObject(value))
-    return transformObject(value, replacer, path21);
+    return transformObject(value, replacer, path25);
   if (isJsonArray(value))
-    return transformArray(value, replacer, path21);
+    return transformArray(value, replacer, path25);
   return value;
 }
-function transformObject(obj, replacer, path21) {
+function transformObject(obj, replacer, path25) {
   const result = {};
   for (const [key, value] of Object.entries(obj)) {
-    const childPath = [...path21, key];
+    const childPath = [...path25, key];
     const replacedValue = replacer(key, value, childPath);
     if (replacedValue === undefined)
       continue;
@@ -173628,11 +174078,11 @@ function transformObject(obj, replacer, path21) {
   }
   return result;
 }
-function transformArray(arr, replacer, path21) {
+function transformArray(arr, replacer, path25) {
   const result = [];
   for (let i = 0;i < arr.length; i++) {
     const value = arr[i];
-    const childPath = [...path21, i];
+    const childPath = [...path25, i];
     const replacedValue = replacer(String(i), value, childPath);
     if (replacedValue === undefined)
       continue;
@@ -175012,9 +175462,9 @@ init_compaction_snapshot_service();
 init_dist();
 init_db_connection();
 init_alias_resolver();
-import fs10 from "fs";
-import os3 from "os";
-import path21 from "path";
+import fs13 from "fs";
+import os6 from "os";
+import path25 from "path";
 
 // ../../packages/core/dist/services/hooks/session-pin-store.js
 var DEFAULT_MAX_SIZE = 1000;
@@ -175115,8 +175565,8 @@ class AttributionResolver {
     this.aliasResolver = options.aliasResolver ?? getProjectIdentityAliasResolver();
     this.pins = options.pins ?? new SessionPinStore;
     this.canonicalize = options.canonicalize ?? defaultCanonicalize;
-    this.homedir = options.homedir ?? os3.homedir;
-    this.fsRoot = options.fsRoot ?? (() => path21.parse(path21.sep).root);
+    this.homedir = options.homedir ?? os6.homedir;
+    this.fsRoot = options.fsRoot ?? (() => path25.parse(path25.sep).root);
   }
   async resolve(input) {
     const caller = input.callerProjectId;
@@ -175169,7 +175619,7 @@ class AttributionResolver {
     }
     let bestPath = null;
     for (const candidate2 of byPath.keys()) {
-      if (canonicalCwd === candidate2 || canonicalCwd.startsWith(candidate2.endsWith(path21.sep) ? candidate2 : candidate2 + path21.sep)) {
+      if (canonicalCwd === candidate2 || canonicalCwd.startsWith(candidate2.endsWith(path25.sep) ? candidate2 : candidate2 + path25.sep)) {
         if (bestPath === null || candidate2.length > bestPath.length) {
           bestPath = candidate2;
         }
@@ -175192,7 +175642,7 @@ class AttributionResolver {
       return projectPath2;
     const fsRoot = this.fsRoot();
     let normalized = projectPath2;
-    while (normalized.length > fsRoot.length && normalized.endsWith(path21.sep)) {
+    while (normalized.length > fsRoot.length && normalized.endsWith(path25.sep)) {
       normalized = normalized.slice(0, -1);
     }
     return normalized;
@@ -175200,10 +175650,10 @@ class AttributionResolver {
 }
 function defaultCanonicalize(cwd) {
   try {
-    return fs10.realpathSync(cwd);
+    return fs13.realpathSync(cwd);
   } catch {
     try {
-      return path21.resolve(cwd);
+      return path25.resolve(cwd);
     } catch {
       return;
     }
@@ -175801,7 +176251,7 @@ init_code_compressor();
 
 // ../../packages/core/dist/services/file-read/file-content-cache.js
 init_dist();
-import fs11 from "fs/promises";
+import fs14 from "fs/promises";
 
 class FileContentCache {
   extractMetadata;
@@ -175834,7 +176284,7 @@ class FileContentCache {
         metadata: cached2.metadata
       };
     }
-    const content = await fs11.readFile(filePath, "utf-8");
+    const content = await fs14.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, {
@@ -175849,7 +176299,7 @@ class FileContentCache {
 
 // ../../packages/core/dist/services/file-read/file-metadata.js
 init_dist();
-import path22 from "path";
+import path26 from "path";
 
 class FileMetadataExtractor {
   symbolGraph;
@@ -175885,7 +176335,7 @@ class FileMetadataExtractor {
     return metadata;
   }
   detectLanguage(filePath) {
-    const ext2 = path22.extname(filePath).toLowerCase();
+    const ext2 = path26.extname(filePath).toLowerCase();
     const languageMap2 = {
       ".ts": "TypeScript",
       ".tsx": "TypeScript",
@@ -176002,7 +176452,7 @@ function selectLines(lines, range) {
 
 // ../../packages/core/dist/services/file-read/path-containment.js
 init_dist();
-import path23 from "path";
+import path27 from "path";
 
 class PathContainment {
   projectRoots;
@@ -176010,14 +176460,14 @@ class PathContainment {
     this.projectRoots = projectRoots;
   }
   async resolveFilePath(filePath, projectId) {
-    if (path23.isAbsolute(filePath)) {
-      return path23.resolve(filePath);
+    if (path27.isAbsolute(filePath)) {
+      return path27.resolve(filePath);
     }
     if (projectId) {
       const root = await this.projectRoots.getProjectRoot(projectId);
       if (root) {
         const cleaned = sanitizeFilePath(filePath);
-        return path23.resolve(root, cleaned);
+        return path27.resolve(root, cleaned);
       }
       return null;
     }
@@ -176028,17 +176478,17 @@ class PathContainment {
     if (projectId) {
       const root = await this.projectRoots.getProjectRoot(projectId);
       if (root)
-        roots.push(path23.resolve(root));
+        roots.push(path27.resolve(root));
     }
-    roots.push(path23.resolve(process.cwd()));
+    roots.push(path27.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(path23.resolve(extra));
+      roots.push(path27.resolve(extra));
     }
-    const target = path23.resolve(absoluteFilePath);
+    const target = path27.resolve(absoluteFilePath);
     for (const root of roots) {
-      const rel = path23.relative(root, target);
-      if (rel !== "" && !rel.startsWith("..") && !path23.isAbsolute(rel)) {
+      const rel = path27.relative(root, target);
+      if (rel !== "" && !rel.startsWith("..") && !path27.isAbsolute(rel)) {
         return { allowed: true };
       }
       if (rel === "")
@@ -176873,8 +177323,8 @@ init_event_bus();
 init_llm_client();
 init_symbol_graph_service();
 import { randomUUID as randomUUID9 } from "crypto";
-import fs14 from "fs";
-import path26 from "path";
+import fs17 from "fs";
+import path30 from "path";
 import { spawn as spawn2 } from "child_process";
 var FALLBACK_BOOTSTRAP = {
   enabled: true,
@@ -177058,9 +177508,9 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
   }
   try {
     for (const name26 of README_CANDIDATES) {
-      const p = path26.join(projectRoot, name26);
-      if (fs14.existsSync(p) && fs14.statSync(p).isFile()) {
-        const buf = fs14.readFileSync(p);
+      const p = path30.join(projectRoot, name26);
+      if (fs17.existsSync(p) && fs17.statSync(p).isFile()) {
+        const buf = fs17.readFileSync(p);
         signals.readme = buf.slice(0, MAX_README_BYTES).toString("utf8");
         break;
       }
@@ -177069,14 +177519,14 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
     logger.debug("bootstrap scan: README read failed", { error: e.message });
   }
   try {
-    const docsDir = path26.join(projectRoot, "docs");
-    if (fs14.existsSync(docsDir) && fs14.statSync(docsDir).isDirectory()) {
+    const docsDir = path30.join(projectRoot, "docs");
+    if (fs17.existsSync(docsDir) && fs17.statSync(docsDir).isDirectory()) {
       const entries = walkMarkdown(docsDir).slice(0, MAX_DOCS);
       for (const rel of entries) {
         try {
-          const buf = fs14.readFileSync(rel);
+          const buf = fs17.readFileSync(rel);
           signals.docs.push({
-            path: path26.relative(projectRoot, rel),
+            path: path30.relative(projectRoot, rel),
             snippet: buf.slice(0, MAX_DOC_BYTES).toString("utf8")
           });
         } catch {}
@@ -177087,10 +177537,10 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
   }
   try {
     for (const name26 of MANIFEST_FILES) {
-      const p = path26.join(projectRoot, name26);
-      if (!fs14.existsSync(p) || !fs14.statSync(p).isFile())
+      const p = path30.join(projectRoot, name26);
+      if (!fs17.existsSync(p) || !fs17.statSync(p).isFile())
         continue;
-      const raw2 = fs14.readFileSync(p).slice(0, MAX_MANIFEST_BYTES).toString("utf8");
+      const raw2 = fs17.readFileSync(p).slice(0, MAX_MANIFEST_BYTES).toString("utf8");
       const kind = name26;
       if (name26 === "package.json") {
         try {
@@ -177130,12 +177580,12 @@ function walkMarkdown(dir) {
     const cur = stack.pop();
     let entries;
     try {
-      entries = fs14.readdirSync(cur, { withFileTypes: true });
+      entries = fs17.readdirSync(cur, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const e of entries) {
-      const full = path26.join(cur, e.name);
+      const full = path30.join(cur, e.name);
       if (e.isDirectory()) {
         if (e.name === "node_modules" || e.name.startsWith("."))
           continue;
@@ -178168,8 +178618,8 @@ var checkpointRoutes = new Elysia({ prefix: "/api/v1/checkpoints" }).post("/list
 
 // src/routes/project.ts
 init_dist();
-import fs15 from "fs/promises";
-import path27 from "path";
+import fs18 from "fs/promises";
+import path31 from "path";
 var indexProjectTool = null;
 var indexStatusTool = null;
 var projectIdentityService = null;
@@ -178378,22 +178828,22 @@ var projectRoutes = new Elysia({ prefix: "/api/v1/project" }).get("/list", async
 }).post("/upload-and-index", async ({ body }) => {
   const rawBase = body.projectId || body.projectPath.replace(/\\/g, "/").split("/").filter(Boolean).pop() || "default";
   const finalProjectId = rawBase.replace(/[^a-zA-Z0-9_.-]/g, "_").slice(0, 128);
-  const uploadRoot = process.env.MASSA_AI_UPLOAD_DIR || path27.join(getGlobalDataDir(), "uploads");
-  const stagingDir = path27.resolve(uploadRoot, finalProjectId);
-  await fs15.rm(stagingDir, { recursive: true, force: true });
-  await fs15.mkdir(stagingDir, { recursive: true });
+  const uploadRoot = process.env.MASSA_AI_UPLOAD_DIR || path31.join(getGlobalDataDir(), "uploads");
+  const stagingDir = path31.resolve(uploadRoot, finalProjectId);
+  await fs18.rm(stagingDir, { recursive: true, force: true });
+  await fs18.mkdir(stagingDir, { recursive: true });
   const WRITE_BATCH = 20;
   for (let i = 0;i < body.files.length; i += WRITE_BATCH) {
     await Promise.all(body.files.slice(i, i + WRITE_BATCH).map(async (file3) => {
-      if (path27.isAbsolute(file3.relativePath) || file3.relativePath.includes("..")) {
+      if (path31.isAbsolute(file3.relativePath) || file3.relativePath.includes("..")) {
         throw new Error(`Invalid file path: ${file3.relativePath}`);
       }
-      const dest = path27.resolve(stagingDir, file3.relativePath.replace(/\//g, path27.sep));
-      if (!dest.startsWith(stagingDir + path27.sep)) {
+      const dest = path31.resolve(stagingDir, file3.relativePath.replace(/\//g, path31.sep));
+      if (!dest.startsWith(stagingDir + path31.sep)) {
         throw new Error(`Path escapes staging directory: ${file3.relativePath}`);
       }
-      await fs15.mkdir(path27.dirname(dest), { recursive: true });
-      await fs15.writeFile(dest, file3.content, "utf-8");
+      await fs18.mkdir(path31.dirname(dest), { recursive: true });
+      await fs18.writeFile(dest, file3.content, "utf-8");
     }));
   }
   return await getIndexProjectTool().handle({
@@ -178547,9 +178997,9 @@ var analyticsRoutes = new Elysia({ prefix: "/api/v1/analytics" }).post("/", asyn
 
 // src/routes/system.ts
 init_dist();
-import path28 from "path";
-import fs16 from "fs";
-import os4 from "os";
+import path32 from "path";
+import fs19 from "fs";
+import os7 from "os";
 function databaseUrlParts() {
   const url2 = new URL(process.env.DATABASE_URL);
   return {
@@ -178580,13 +179030,13 @@ var systemRoutes = new Elysia({ prefix: "/api/v1/system" }).get("/info", async (
     version: "1.0.0",
     service: "massa-ai-tools-api",
     node: process.version,
-    platform: os4.platform(),
-    arch: os4.arch(),
+    platform: os7.platform(),
+    arch: os7.arch(),
     uptime: process.uptime(),
     memory: {
-      total: os4.totalmem(),
-      free: os4.freemem(),
-      used: os4.totalmem() - os4.freemem(),
+      total: os7.totalmem(),
+      free: os7.freemem(),
+      used: os7.totalmem() - os7.freemem(),
       process: process.memoryUsage()
     },
     dataDir: config.get("dataDir"),
@@ -178622,11 +179072,11 @@ var systemRoutes = new Elysia({ prefix: "/api/v1/system" }).get("/info", async (
     description: "Check PostgreSQL, pgvector, Ollama, and local artifact directory health"
   }
 }).get("/metrics", async () => {
-  const metricsPath = path28.join(process.cwd(), "data", "metrics.json");
+  const metricsPath = path32.join(process.cwd(), "data", "metrics.json");
   let metrics2 = {};
-  if (fs16.existsSync(metricsPath)) {
+  if (fs19.existsSync(metricsPath)) {
     try {
-      metrics2 = JSON.parse(fs16.readFileSync(metricsPath, "utf-8"));
+      metrics2 = JSON.parse(fs19.readFileSync(metricsPath, "utf-8"));
     } catch {}
   }
   const database = await getDatabaseInfo();
@@ -178776,8 +179226,8 @@ var eventsRoutes = new Elysia({ prefix: "/api/v1" }).get("/events", async ({ que
 });
 
 // src/routes/workspace.ts
-import fs17 from "fs/promises";
-import path29 from "path";
+import fs20 from "fs/promises";
+import path33 from "path";
 import { realpathSync as realpathSync4 } from "fs";
 var indexProjectTool2 = null;
 function getIndexProjectTool2() {
@@ -178819,7 +179269,7 @@ function realpathSafe(p) {
   try {
     return realpathSync4(p);
   } catch {
-    return path29.resolve(p);
+    return path33.resolve(p);
   }
 }
 var graphController = null;
@@ -179170,8 +179620,8 @@ var workspaceRoutes = new Elysia({ prefix: "/api/v1" }).get("/workspace/list", a
     }
     const registeredRoot = realpathSafe(workspace.project_path);
     const callerRoot = realpathSafe(projectPath2);
-    const rel = path29.relative(registeredRoot, callerRoot);
-    const escapes = rel.startsWith("..") || path29.isAbsolute(rel);
+    const rel = path33.relative(registeredRoot, callerRoot);
+    const escapes = rel.startsWith("..") || path33.isAbsolute(rel);
     if (registeredRoot !== callerRoot && escapes) {
       return {
         success: false,
@@ -179301,8 +179751,8 @@ var workspaceRoutes = new Elysia({ prefix: "/api/v1" }).get("/workspace/list", a
     } else {
       end = start + 20;
     }
-    const absolutePath = path29.join(workspace.project_path, file3);
-    const content = await fs17.readFile(absolutePath, "utf-8");
+    const absolutePath = path33.join(workspace.project_path, file3);
+    const content = await fs20.readFile(absolutePath, "utf-8");
     const lines = content.split(/\r?\n/);
     const slice = lines.slice(start - 1, Math.min(lines.length, end));
     const formatted = slice.map((text3, idx) => ({
@@ -180217,8 +180667,8 @@ var webRoutes = new Elysia({ prefix: "/api/v1/web" }).post("/fetch_and_index", a
 });
 
 // src/routes/web-ui.ts
-import fs18 from "fs/promises";
-import path30 from "path";
+import fs21 from "fs/promises";
+import path34 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/web-ui-trust.ts
@@ -180262,9 +180712,9 @@ function buildStaticDirCandidates(moduleDir, cwd) {
   for (const root2 of [moduleDir, cwd]) {
     let dir = root2;
     for (let i = 0;i < 10; i++) {
-      candidates2.push(path30.resolve(dir, "apps/web-ui/src/static"));
-      candidates2.push(path30.resolve(dir, "web-ui/src/static"));
-      const parent = path30.dirname(dir);
+      candidates2.push(path34.resolve(dir, "apps/web-ui/src/static"));
+      candidates2.push(path34.resolve(dir, "web-ui/src/static"));
+      const parent = path34.dirname(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -180272,11 +180722,11 @@ function buildStaticDirCandidates(moduleDir, cwd) {
   }
   return [...new Set(candidates2)];
 }
-var STATIC_DIR_CANDIDATES = buildStaticDirCandidates(path30.dirname(fileURLToPath3(import.meta.url)), process.cwd());
+var STATIC_DIR_CANDIDATES = buildStaticDirCandidates(path34.dirname(fileURLToPath3(import.meta.url)), process.cwd());
 async function resolveStaticDir() {
   for (const dir of STATIC_DIR_CANDIDATES) {
     try {
-      const st = await fs18.stat(dir);
+      const st = await fs21.stat(dir);
       if (st.isDirectory())
         return dir;
     } catch {}
@@ -180297,7 +180747,7 @@ var CONTENT_TYPES = {
   ".woff2": "font/woff2"
 };
 function contentTypeFor(filePath) {
-  const ext2 = path30.extname(filePath).toLowerCase();
+  const ext2 = path34.extname(filePath).toLowerCase();
   return CONTENT_TYPES[ext2] ?? "application/octet-stream";
 }
 function webUiDisabled() {
@@ -180308,13 +180758,13 @@ function webUiDisabled() {
 }
 async function resolveSafePath(staticDir, sub) {
   const cleaned = sub.replace(/^\/+/, "");
-  const abs = path30.resolve(staticDir, cleaned);
-  const rel = path30.relative(staticDir, abs);
-  if (rel.startsWith("..") || path30.isAbsolute(rel)) {
+  const abs = path34.resolve(staticDir, cleaned);
+  const rel = path34.relative(staticDir, abs);
+  if (rel.startsWith("..") || path34.isAbsolute(rel)) {
     return null;
   }
   try {
-    await fs18.stat(abs);
+    await fs21.stat(abs);
     return { abs, exists: true };
   } catch {
     return { abs, exists: false };
@@ -180337,7 +180787,7 @@ function injectAccessMarkup(html, apiKey, trusted) {
   return out;
 }
 async function readShell(indexPath, remoteAddress) {
-  const raw2 = await fs18.readFile(indexPath, "utf-8");
+  const raw2 = await fs21.readFile(indexPath, "utf-8");
   const trusted = isTrustedWebUiCaller(remoteAddress);
   return Buffer.from(injectAccessMarkup(raw2, getConfiguredApiKey(), trusted), "utf-8");
 }
@@ -180354,7 +180804,7 @@ var webUiRoutes = new Elysia().get("/ui", async ({ set: set3, request }) => {
     set3.status = 500;
     return { status: 500, error: "web ui static dir not found" };
   }
-  const indexPath = path30.join(dir, "index.html");
+  const indexPath = path34.join(dir, "index.html");
   try {
     const body = await readShell(indexPath, remoteAddressOf(request));
     set3.headers["content-type"] = contentTypeFor(indexPath);
@@ -180387,7 +180837,7 @@ var webUiRoutes = new Elysia().get("/ui", async ({ set: set3, request }) => {
   }
   if (resolved.exists) {
     try {
-      const body = await fs18.readFile(resolved.abs);
+      const body = await fs21.readFile(resolved.abs);
       set3.headers["content-type"] = contentTypeFor(resolved.abs);
       return body;
     } catch {
@@ -180396,7 +180846,7 @@ var webUiRoutes = new Elysia().get("/ui", async ({ set: set3, request }) => {
     }
   }
   try {
-    const body = await readShell(path30.join(dir, "index.html"), remoteAddressOf(request));
+    const body = await readShell(path34.join(dir, "index.html"), remoteAddressOf(request));
     set3.headers["content-type"] = "text/html; charset=utf-8";
     return body;
   } catch {
@@ -180539,6 +180989,89 @@ var dashboardRoutes = new Elysia({ prefix: "/api/v1" }).get("/scheduler/status",
   }
 });
 
+// src/routes/profiles.ts
+init_dist();
+var PROFILE_DETAIL = {
+  tags: ["profiles"]
+};
+function isNamedError(e) {
+  return e instanceof Error && typeof e.name === "string";
+}
+function statusFor(err) {
+  switch (err.name) {
+    case "UnknownProfileError":
+      return 400;
+    case "NoHostsDetectedError":
+      return 404;
+    default:
+      break;
+  }
+  if (err instanceof LockError)
+    return 409;
+  if (err instanceof InstallStateError)
+    return 500;
+  return 500;
+}
+function errorBody(err) {
+  return { success: false, error: { code: err.name, message: err.message } };
+}
+function validHost(value) {
+  if (value === undefined)
+    return;
+  if (typeof value === "string" && isHost(value))
+    return value;
+  return;
+}
+var profileRoutes = new Elysia({ prefix: "/api/v1/profiles" }).get("/", ({ query, set: set3 }) => {
+  const hostParam = query.host;
+  if (hostParam !== undefined && !isHost(hostParam)) {
+    set3.status = 400;
+    return { success: false, error: { code: "InvalidHostError", message: `unknown host "${hostParam}"` } };
+  }
+  try {
+    const inventory = listProfiles(hostParam ? { hosts: [hostParam] } : {});
+    set3.status = 200;
+    return { success: true, data: inventory };
+  } catch (e) {
+    const err = isNamedError(e) ? e : { name: "Error", message: String(e) };
+    set3.status = statusFor(err);
+    return errorBody(err);
+  }
+}, {
+  query: t.Object({ host: t.Optional(t.String()) }),
+  detail: {
+    ...PROFILE_DETAIL,
+    summary: "List shipped profiles + per-host active profile",
+    description: "Returns the shipped profile names, per-host active profile (from recorded state; 'balanced' shown when unrecorded), and per-host bundle version. Offline \u2014 reads on-disk variant directories only, never the registry."
+  }
+}).post("/switch", ({ body, set: set3 }) => {
+  const { profile, host, dryRun } = body;
+  if (host !== undefined && !isHost(host)) {
+    set3.status = 400;
+    return { success: false, error: { code: "InvalidHostError", message: `unknown host "${host}"` } };
+  }
+  try {
+    const report = switchProfile({ profile, host: validHost(host), dryRun });
+    set3.status = 200;
+    return { success: true, data: report };
+  } catch (e) {
+    const err = isNamedError(e) ? e : { name: "Error", message: String(e) };
+    set3.status = statusFor(err);
+    return errorBody(err);
+  }
+}, {
+  body: t.Object({
+    profile: t.String({ description: "Target profile name" }),
+    host: t.Optional(t.String({ description: "Limit the switch to a single host" })),
+    dryRun: t.Optional(t.Boolean({ description: "Print the per-host plan; change nothing" }))
+  }),
+  detail: {
+    ...PROFILE_DETAIL,
+    summary: "Switch installed agents to a profile",
+    description: "Mutates the machine this server runs on: replaces the active installed agent files for every detected, supported host with the chosen profile's variant, and reports per host: switched / skipped (reason) / failed (reason). A session restart is required for the change to take effect. Local trust model \u2014 same as the executor routes."
+  }
+});
+
 // src/middleware/error.ts
 var errorHandler = new Elysia({ name: "error-handler" }).onError(({ code, error: error51, set: set3 }) => {
   console.error("[massa-ai-api] Request failed", {
@@ -180633,7 +181166,8 @@ var app = new Elysia({ adapter: node() }).use(cors(buildCorsOptions(config.get("
       { name: "proposals", description: "Auto-improvement proposal list/approve/reject" },
       { name: "executor", description: "Polyglot sandbox: execute code, run code over files, batch shell commands" },
       { name: "web", description: "SSRF-guarded web fetch + HTML\u2192md + index (fetch_and_index)" },
-      { name: "webUi", description: "Read-only memory/search web browser (Phase 8)" }
+      { name: "webUi", description: "Read-only memory/search web browser (Phase 8)" },
+      { name: "profiles", description: "Model-profile switch: list shipped profiles, switch installed agents" }
     ],
     components: {
       securitySchemes: {
@@ -180647,7 +181181,7 @@ var app = new Elysia({ adapter: node() }).use(cors(buildCorsOptions(config.get("
     },
     security: [{ ApiKeyAuth: [] }]
   }
-})).use(errorHandler).use(authMiddleware).use(searchRoutes).use(memoryRoutes).use(checkpointRoutes).use(projectRoutes).use(contextRoutes).use(analyticsRoutes).use(systemRoutes).use(eventsRoutes).use(workspaceRoutes).use(fileRoutes).use(synapseRoutes).use(hookRoutes).use(bootstrapRoutes).use(handoffRoutes).use(proposalRoutes).use(executorRoutes).use(webRoutes).use(webUiRoutes).use(architectureRoutes).use(dashboardRoutes).get("/health", () => buildHealthResponse(getParserReadiness()));
+})).use(errorHandler).use(authMiddleware).use(searchRoutes).use(memoryRoutes).use(checkpointRoutes).use(projectRoutes).use(contextRoutes).use(analyticsRoutes).use(systemRoutes).use(eventsRoutes).use(workspaceRoutes).use(fileRoutes).use(synapseRoutes).use(hookRoutes).use(bootstrapRoutes).use(handoffRoutes).use(proposalRoutes).use(executorRoutes).use(webRoutes).use(webUiRoutes).use(architectureRoutes).use(dashboardRoutes).use(profileRoutes).get("/health", () => buildHealthResponse(getParserReadiness()));
 initAuthOrExit();
 warnIfTrustOverrideEnabled();
 await listenAfterParserValidation({