trace-mcp 1.22.0 → 1.23.0

package/dist/index.js

@@ -10,10 +10,10 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-var __glob = (map) => (path66) => {
-  var fn2 = map[path66];
+var __glob = (map) => (path67) => {
+  var fn2 = map[path67];
   if (fn2) return fn2();
-  throw new Error("Module not found in bundle: " + path66);
+  throw new Error("Module not found in bundle: " + path67);
 };
 var __esm = (fn2, res) => function __init() {
   return fn2 && (res = (0, fn2[__getOwnPropNames(fn2)[0]])(fn2 = 0)), res;
@@ -2637,27 +2637,27 @@ var require_process = __commonJS({
 var require_filesystem = __commonJS({
   "node_modules/detect-libc/lib/filesystem.js"(exports, module) {
     "use strict";
-    var fs56 = __require("fs");
+    var fs57 = __require("fs");
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
-    var readFileSync10 = (path66) => {
-      const fd = fs56.openSync(path66, "r");
+    var readFileSync11 = (path67) => {
+      const fd = fs57.openSync(path67, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
-      const bytesRead = fs56.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-      fs56.close(fd, () => {
+      const bytesRead = fs57.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+      fs57.close(fd, () => {
       });
       return buffer.subarray(0, bytesRead);
     };
-    var readFile = (path66) => new Promise((resolve3, reject) => {
-      fs56.open(path66, "r", (err14, fd) => {
+    var readFile = (path67) => new Promise((resolve3, reject) => {
+      fs57.open(path67, "r", (err14, fd) => {
         if (err14) {
           reject(err14);
         } else {
           const buffer = Buffer.alloc(MAX_LENGTH);
-          fs56.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+          fs57.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
             resolve3(buffer.subarray(0, bytesRead));
-            fs56.close(fd, () => {
+            fs57.close(fd, () => {
             });
           });
         }
@@ -2666,7 +2666,7 @@ var require_filesystem = __commonJS({
     module.exports = {
       LDD_PATH,
       SELF_PATH,
-      readFileSync: readFileSync10,
+      readFileSync: readFileSync11,
       readFile
     };
   }
@@ -2715,7 +2715,7 @@ var require_detect_libc = __commonJS({
     "use strict";
     var childProcess = __require("child_process");
     var { isLinux, getReport } = require_process();
-    var { LDD_PATH, SELF_PATH, readFile, readFileSync: readFileSync10 } = require_filesystem();
+    var { LDD_PATH, SELF_PATH, readFile, readFileSync: readFileSync11 } = require_filesystem();
     var { interpreterPath } = require_elf();
     var cachedFamilyInterpreter;
     var cachedFamilyFilesystem;
@@ -2769,11 +2769,11 @@ var require_detect_libc = __commonJS({
       }
       return null;
     };
-    var familyFromInterpreterPath = (path66) => {
-      if (path66) {
-        if (path66.includes("/ld-musl-")) {
+    var familyFromInterpreterPath = (path67) => {
+      if (path67) {
+        if (path67.includes("/ld-musl-")) {
           return MUSL;
-        } else if (path66.includes("/ld-linux-")) {
+        } else if (path67.includes("/ld-linux-")) {
           return GLIBC;
         }
       }
@@ -2807,7 +2807,7 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyFilesystem = null;
       try {
-        const lddContent = readFileSync10(LDD_PATH);
+        const lddContent = readFileSync11(LDD_PATH);
         cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
       } catch (e) {
       }
@@ -2820,8 +2820,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = await readFile(SELF_PATH);
-        const path66 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path66);
+        const path67 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path67);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -2832,9 +2832,9 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyInterpreter = null;
       try {
-        const selfContent = readFileSync10(SELF_PATH);
-        const path66 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path66);
+        const selfContent = readFileSync11(SELF_PATH);
+        const path67 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path67);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -2896,7 +2896,7 @@ var require_detect_libc = __commonJS({
       }
       cachedVersionFilesystem = null;
       try {
-        const lddContent = readFileSync10(LDD_PATH);
+        const lddContent = readFileSync11(LDD_PATH);
         const versionMatch = lddContent.match(RE_GLIBC_VERSION);
         if (versionMatch) {
           cachedVersionFilesystem = versionMatch[1];
@@ -4553,18 +4553,18 @@ var require_sharp = __commonJS({
       `@img/sharp-${runtimePlatform}/sharp.node`,
       "@img/sharp-wasm32/sharp.node"
     ];
-    var path66;
+    var path67;
     var sharp2;
     var errors = [];
-    for (path66 of paths) {
+    for (path67 of paths) {
       try {
-        sharp2 = __require(path66);
+        sharp2 = __require(path67);
         break;
       } catch (err14) {
         errors.push(err14);
       }
     }
-    if (sharp2 && path66.startsWith("@img/sharp-linux-x64") && !sharp2._isUsingX64V2()) {
+    if (sharp2 && path67.startsWith("@img/sharp-linux-x64") && !sharp2._isUsingX64V2()) {
       const err14 = new Error("Prebuilt binaries for linux-x64 require v2 microarchitecture");
       err14.code = "Unsupported CPU";
       errors.push(err14);
@@ -7475,15 +7475,15 @@ var require_color = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path66 = [graph[toModel].parent, toModel];
+      const path67 = [graph[toModel].parent, toModel];
       let fn2 = conversions_default[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path66.unshift(graph[cur].parent);
+        path67.unshift(graph[cur].parent);
         fn2 = link(conversions_default[graph[cur].parent][cur], fn2);
         cur = graph[cur].parent;
       }
-      fn2.conversion = path66;
+      fn2.conversion = path67;
       return fn2;
     }
     function route(fromModel) {
@@ -8100,7 +8100,7 @@ var require_channel = __commonJS({
 var require_output = __commonJS({
   "node_modules/sharp/lib/output.js"(exports, module) {
     "use strict";
-    var path66 = __require("path");
+    var path67 = __require("path");
     var is2 = require_is();
     var sharp2 = require_sharp();
     var formats = /* @__PURE__ */ new Map([
@@ -8131,9 +8131,9 @@ var require_output = __commonJS({
       let err14;
       if (!is2.string(fileOut)) {
         err14 = new Error("Missing output file path");
-      } else if (is2.string(this.options.input.file) && path66.resolve(this.options.input.file) === path66.resolve(fileOut)) {
+      } else if (is2.string(this.options.input.file) && path67.resolve(this.options.input.file) === path67.resolve(fileOut)) {
         err14 = new Error("Cannot use same file for input and output");
-      } else if (jp2Regex.test(path66.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
+      } else if (jp2Regex.test(path67.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
         err14 = errJp2Save();
       }
       if (err14) {
@@ -42840,9 +42840,9 @@ ${this.boa_token}${this.audio_token.repeat(this._compute_audio_num_tokens(audio_
 });
 
 // src/lsp/config.ts
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import { execSync } from "child_process";
-import { join } from "path";
+import { join as join2 } from "path";
 function fileLanguageToLspLanguage(fileLanguage) {
   if (!fileLanguage) return null;
   const map = {
@@ -42913,7 +42913,7 @@ var init_config = __esm({
         language: "typescript",
         command: "npx",
         args: ["typescript-language-server", "--stdio"],
-        detect: (root) => existsSync(join(root, "tsconfig.json")) || existsSync(join(root, "package.json")),
+        detect: (root) => existsSync2(join2(root, "tsconfig.json")) || existsSync2(join2(root, "package.json")),
         initializationOptions: {
           preferences: { includeInlayParameterNameHints: "none" }
         }
@@ -42922,19 +42922,19 @@ var init_config = __esm({
         language: "python",
         command: "pyright-langserver",
         args: ["--stdio"],
-        detect: (root) => existsSync(join(root, "pyproject.toml")) || existsSync(join(root, "requirements.txt")) || existsSync(join(root, "setup.py"))
+        detect: (root) => existsSync2(join2(root, "pyproject.toml")) || existsSync2(join2(root, "requirements.txt")) || existsSync2(join2(root, "setup.py"))
       },
       {
         language: "go",
         command: "gopls",
         args: ["serve"],
-        detect: (root) => existsSync(join(root, "go.mod"))
+        detect: (root) => existsSync2(join2(root, "go.mod"))
       },
       {
         language: "rust",
         command: "rust-analyzer",
         args: [],
-        detect: (root) => existsSync(join(root, "Cargo.toml"))
+        detect: (root) => existsSync2(join2(root, "Cargo.toml"))
       }
     ];
     EXTENSION_TO_LANGUAGE = {
@@ -43328,7 +43328,7 @@ var init_mappers = __esm({
 });
 
 // src/lsp/enrichment.ts
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import { resolve as resolve2 } from "path";
 import { pathToFileURL as pathToFileURL3 } from "url";
 var CALL_EDGE_TYPES, LspEnrichmentPass;
@@ -43447,7 +43447,7 @@ var init_enrichment = __esm({
               const uri = pathToFileURL3(absPath).href;
               if (!openedFiles.has(uri)) {
                 try {
-                  const content = readFileSync(absPath, "utf-8");
+                  const content = readFileSync2(absPath, "utf-8");
                   const langId = getLanguageId(file.path) ?? language;
                   await client.openDocument(uri, langId, content);
                   openedFiles.add(uri);
@@ -43976,8 +43976,8 @@ var init_layer_violations = __esm({
 });
 
 // src/tools/refactoring/pack-context.ts
-import fs48 from "fs";
-import path56 from "path";
+import fs49 from "fs";
+import path57 from "path";
 function estimateTokens2(text) {
   return Math.ceil(text.length / 4);
 }
@@ -44084,11 +44084,11 @@ ${outlineLines.join("\n")}
     let sourceFilesIncluded = 0;
     let sourceTruncated = false;
     for (const f of files) {
-      const absPath = path56.join(projectRoot, f.path);
-      if (!fs48.existsSync(absPath)) continue;
+      const absPath = path57.join(projectRoot, f.path);
+      if (!fs49.existsSync(absPath)) continue;
       let content;
       try {
-        content = fs48.readFileSync(absPath, "utf-8");
+        content = fs49.readFileSync(absPath, "utf-8");
       } catch {
         continue;
       }
@@ -44267,7 +44267,7 @@ function buildFileTree(paths) {
   for (const p of sorted.slice(0, 200)) {
     const depth = p.split("/").length - 1;
     const indent = "  ".repeat(Math.min(depth, 6));
-    lines.push(`${indent}${path56.basename(p)}`);
+    lines.push(`${indent}${path57.basename(p)}`);
   }
   if (sorted.length > 200) {
     lines.push(`  ... and ${sorted.length - 200} more files`);
@@ -44497,6 +44497,35 @@ async function* parseOpenAIStream(body) {
     reader.releaseLock();
   }
 }
+async function* parseAnthropicStream(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop();
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || !trimmed.startsWith("data: ")) continue;
+        const payload = trimmed.slice(6);
+        try {
+          const event = JSON.parse(payload);
+          if (event.type === "content_block_delta" && event.delta?.text) {
+            yield event.delta.text;
+          }
+          if (event.type === "message_stop") return;
+        } catch {
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
 async function* parseOllamaChatStream(body) {
   const reader = body.getReader();
   const decoder = new TextDecoder();
@@ -44911,6 +44940,278 @@ var OnnxProvider = class {
   }
 };
 
+// src/ai/gemini.ts
+init_logger();
+var BASE_URL = "https://generativelanguage.googleapis.com";
+var GeminiEmbeddingService = class {
+  constructor(apiKey, model, dims) {
+    this.apiKey = apiKey;
+    this.model = model;
+    this.dims = dims;
+  }
+  apiKey;
+  model;
+  dims;
+  async embed(text) {
+    const results = await this.embedBatch([text]);
+    return results[0] ?? [];
+  }
+  async embedBatch(texts) {
+    return withRetry(async () => {
+      const requests = texts.map((text) => ({
+        model: `models/${this.model}`,
+        content: { parts: [{ text }] },
+        outputDimensionality: this.dims
+      }));
+      const resp = await fetch(
+        `${BASE_URL}/v1beta/models/${this.model}:batchEmbedContents?key=${this.apiKey}`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ requests }),
+          signal: AbortSignal.timeout(3e4)
+        }
+      );
+      if (!resp.ok) {
+        const body = await resp.text().catch(() => "");
+        const safeBody = body.length > 200 ? body.slice(0, 200) + "\u2026" : body;
+        throw new Error(`Gemini embeddings failed: ${resp.status} ${resp.statusText} \u2014 ${safeBody}`);
+      }
+      const data = await resp.json();
+      return data.embeddings.map((e) => e.values);
+    }, { label: "Gemini embeddings" });
+  }
+  dimensions() {
+    return this.dims;
+  }
+};
+var GeminiInferenceService = class {
+  constructor(apiKey, model) {
+    this.apiKey = apiKey;
+    this.model = model;
+  }
+  apiKey;
+  model;
+  async generate(prompt, options) {
+    return withRetry(async () => {
+      const resp = await fetch(
+        `${BASE_URL}/v1beta/models/${this.model}:generateContent?key=${this.apiKey}`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            contents: [{ parts: [{ text: prompt }] }],
+            generationConfig: {
+              ...options?.maxTokens ? { maxOutputTokens: options.maxTokens } : {},
+              ...options?.temperature !== void 0 ? { temperature: options.temperature } : {}
+            }
+          }),
+          signal: AbortSignal.timeout(6e4)
+        }
+      );
+      if (!resp.ok) {
+        const body = await resp.text().catch(() => "");
+        const safeBody = body.length > 200 ? body.slice(0, 200) + "\u2026" : body;
+        throw new Error(`Gemini generate failed: ${resp.status} ${resp.statusText} \u2014 ${safeBody}`);
+      }
+      const data = await resp.json();
+      return data.candidates?.[0]?.content?.parts?.[0]?.text ?? "";
+    }, { label: "Gemini generate" });
+  }
+  async *generateStream(messages, options) {
+    const contents = messages.map((m) => ({
+      role: m.role === "assistant" ? "model" : "user",
+      parts: [{ text: m.content }]
+    }));
+    const resp = await fetch(
+      `${BASE_URL}/v1beta/models/${this.model}:streamGenerateContent?alt=sse&key=${this.apiKey}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          contents,
+          generationConfig: {
+            ...options?.maxTokens ? { maxOutputTokens: options.maxTokens } : {},
+            ...options?.temperature !== void 0 ? { temperature: options.temperature } : {}
+          }
+        }),
+        signal: AbortSignal.timeout(12e4)
+      }
+    );
+    if (!resp.ok) {
+      const body = await resp.text().catch(() => "");
+      const safeBody = body.length > 200 ? body.slice(0, 200) + "\u2026" : body;
+      throw new Error(`Gemini stream failed: ${resp.status} ${resp.statusText} \u2014 ${safeBody}`);
+    }
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    let buf = "";
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      const lines = buf.split("\n");
+      buf = lines.pop();
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        const json = line.slice(6).trim();
+        if (!json || json === "[DONE]") continue;
+        try {
+          const chunk2 = JSON.parse(json);
+          const text = chunk2.candidates?.[0]?.content?.parts?.[0]?.text;
+          if (text) yield text;
+        } catch {
+        }
+      }
+    }
+  }
+};
+var GeminiProvider = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async isAvailable() {
+    try {
+      const resp = await fetch(
+        `${BASE_URL}/v1beta/models?key=${this.config.apiKey}`,
+        { signal: AbortSignal.timeout(3e3) }
+      );
+      return resp.ok;
+    } catch {
+      logger.debug("Gemini not available");
+      return false;
+    }
+  }
+  embedding() {
+    return new GeminiEmbeddingService(
+      this.config.apiKey,
+      this.config.embeddingModel,
+      this.config.embeddingDimensions
+    );
+  }
+  inference() {
+    return new GeminiInferenceService(this.config.apiKey, this.config.inferenceModel);
+  }
+  fastInference() {
+    return new GeminiInferenceService(this.config.apiKey, this.config.fastModel);
+  }
+};
+
+// src/ai/anthropic.ts
+init_logger();
+var BASE_URL2 = "https://api.anthropic.com";
+var NoEmbeddingService = class {
+  async embed(_text) {
+    return [];
+  }
+  async embedBatch(_texts) {
+    return [];
+  }
+  dimensions() {
+    return 0;
+  }
+};
+var AnthropicInferenceService = class {
+  constructor(apiKey, model) {
+    this.apiKey = apiKey;
+    this.model = model;
+  }
+  apiKey;
+  model;
+  async generate(prompt, options) {
+    return withRetry(async () => {
+      const resp = await fetch(`${BASE_URL2}/v1/messages`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": this.apiKey,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify({
+          model: this.model,
+          max_tokens: options?.maxTokens ?? 4096,
+          messages: [{ role: "user", content: prompt }],
+          ...options?.temperature !== void 0 ? { temperature: options.temperature } : {}
+        }),
+        signal: AbortSignal.timeout(6e4)
+      });
+      if (!resp.ok) {
+        const body = await resp.text().catch(() => "");
+        const safeBody = body.length > 200 ? body.slice(0, 200) + "\u2026" : body;
+        throw new Error(`Anthropic API error: ${resp.status} ${resp.statusText} \u2014 ${safeBody}`);
+      }
+      const data = await resp.json();
+      return data.content?.find((c) => c.type === "text")?.text ?? "";
+    }, { label: "Anthropic generate" });
+  }
+  async *generateStream(messages, options) {
+    const systemMsg = messages.find((m) => m.role === "system");
+    const nonSystemMsgs = messages.filter((m) => m.role !== "system");
+    const resp = await fetch(`${BASE_URL2}/v1/messages`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model: this.model,
+        max_tokens: options?.maxTokens ?? 4096,
+        stream: true,
+        ...systemMsg ? { system: systemMsg.content } : {},
+        ...options?.temperature !== void 0 ? { temperature: options.temperature } : {},
+        messages: nonSystemMsgs.map((m) => ({ role: m.role, content: m.content }))
+      }),
+      signal: AbortSignal.timeout(12e4)
+    });
+    if (!resp.ok) {
+      const body = await resp.text().catch(() => "");
+      const safeBody = body.length > 200 ? body.slice(0, 200) + "\u2026" : body;
+      throw new Error(`Anthropic stream error: ${resp.status} ${resp.statusText} \u2014 ${safeBody}`);
+    }
+    yield* parseAnthropicStream(resp.body);
+  }
+};
+var AnthropicProvider = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async isAvailable() {
+    try {
+      const resp = await fetch(`${BASE_URL2}/v1/messages`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": this.config.apiKey,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify({
+          model: this.config.inferenceModel,
+          max_tokens: 1,
+          messages: [{ role: "user", content: "ping" }]
+        }),
+        signal: AbortSignal.timeout(5e3)
+      });
+      return resp.ok || resp.status === 400;
+    } catch {
+      logger.debug("Anthropic not available");
+      return false;
+    }
+  }
+  embedding() {
+    logger.warn("Anthropic does not provide embeddings \u2014 use a separate embedding provider (ONNX, Ollama, or OpenAI)");
+    return new NoEmbeddingService();
+  }
+  inference() {
+    return new AnthropicInferenceService(this.config.apiKey, this.config.inferenceModel);
+  }
+  fastInference() {
+    return new AnthropicInferenceService(this.config.apiKey, this.config.fastModel);
+  }
+};
+
 // src/ai/index.ts
 init_logger();
 
@@ -45400,32 +45701,76 @@ var LLMReranker = class {
 };
 
 // src/ai/index.ts
+var OPENAI_COMPAT_DEFAULTS = {
+  openai: {
+    baseUrl: "https://api.openai.com/v1",
+    embeddingModel: "text-embedding-3-small",
+    embeddingDimensions: 1536,
+    inferenceModel: "gpt-4o-mini",
+    fastModel: "gpt-4o-mini",
+    envKey: "OPENAI_API_KEY"
+  },
+  lmstudio: {
+    baseUrl: "http://localhost:1234/v1",
+    embeddingModel: "nomic-embed-text-v1.5",
+    embeddingDimensions: 768,
+    inferenceModel: "qwen2.5-coder-7b-instruct",
+    fastModel: "qwen2.5-coder-7b-instruct",
+    envKey: "LMSTUDIO_API_KEY"
+  },
+  groq: {
+    baseUrl: "https://api.groq.com/openai/v1",
+    embeddingModel: "nomic-embed-text-v1.5",
+    embeddingDimensions: 768,
+    inferenceModel: "llama-3.3-70b-versatile",
+    fastModel: "llama-3.1-8b-instant",
+    envKey: "GROQ_API_KEY"
+  },
+  together: {
+    baseUrl: "https://api.together.xyz/v1",
+    embeddingModel: "togethercomputer/m2-bert-80M-8k-retrieval",
+    embeddingDimensions: 768,
+    inferenceModel: "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+    fastModel: "meta-llama/Llama-3.1-8B-Instruct-Turbo",
+    envKey: "TOGETHER_API_KEY"
+  },
+  deepseek: {
+    baseUrl: "https://api.deepseek.com/v1",
+    embeddingModel: "deepseek-chat",
+    embeddingDimensions: 1536,
+    inferenceModel: "deepseek-chat",
+    fastModel: "deepseek-chat",
+    envKey: "DEEPSEEK_API_KEY"
+  },
+  mistral: {
+    baseUrl: "https://api.mistral.ai/v1",
+    embeddingModel: "mistral-embed",
+    embeddingDimensions: 1024,
+    inferenceModel: "mistral-small-latest",
+    fastModel: "mistral-small-latest",
+    envKey: "MISTRAL_API_KEY"
+  },
+  xai: {
+    baseUrl: "https://api.x.ai/v1",
+    embeddingModel: "grok-2",
+    embeddingDimensions: 1536,
+    inferenceModel: "grok-2",
+    fastModel: "grok-2",
+    envKey: "XAI_API_KEY"
+  }
+};
 function createAIProvider(config) {
   if (!config.ai?.enabled) {
     return new FallbackProvider();
   }
-  if (config.ai.provider === "onnx") {
+  const provider = config.ai.provider;
+  if (provider === "onnx") {
     return new OnnxProvider({
       model: config.ai.embedding_model,
       dimensions: config.ai.embedding_dimensions
     });
   }
-  if (config.ai.provider === "openai") {
-    const apiKey = config.ai.api_key ?? process.env.OPENAI_API_KEY ?? "";
-    if (!apiKey) {
-      logger.warn("OpenAI provider selected but no api_key configured \u2014 falling back to FallbackProvider");
-      return new FallbackProvider();
-    }
-    return new OpenAIProvider({
-      apiKey,
-      baseUrl: config.ai.base_url ?? "https://api.openai.com/v1",
-      embeddingModel: config.ai.embedding_model ?? "text-embedding-3-small",
-      embeddingDimensions: config.ai.embedding_dimensions ?? 1536,
-      inferenceModel: config.ai.inference_model ?? "gpt-4o-mini",
-      fastModel: config.ai.fast_model ?? "gpt-4o-mini"
-    });
-  }
-  if (config.ai.provider === "ollama") {
+  if (provider === "ollama") {
     return new OllamaProvider({
       baseUrl: config.ai.base_url ?? "http://localhost:11434",
       embeddingModel: config.ai.embedding_model ?? "qwen3-embedding:0.6b",
@@ -45434,6 +45779,48 @@ function createAIProvider(config) {
       embeddingDimensions: config.ai.embedding_dimensions
     });
   }
+  if (provider === "gemini") {
+    const apiKey = config.ai.api_key ?? process.env.GEMINI_API_KEY ?? "";
+    if (!apiKey) {
+      logger.warn("Gemini provider selected but no api_key configured \u2014 falling back");
+      return new FallbackProvider();
+    }
+    return new GeminiProvider({
+      apiKey,
+      embeddingModel: config.ai.embedding_model ?? "text-embedding-004",
+      embeddingDimensions: config.ai.embedding_dimensions ?? 768,
+      inferenceModel: config.ai.inference_model ?? "gemini-2.0-flash",
+      fastModel: config.ai.fast_model ?? "gemini-2.0-flash"
+    });
+  }
+  if (provider === "anthropic") {
+    const apiKey = config.ai.api_key ?? process.env.ANTHROPIC_API_KEY ?? "";
+    if (!apiKey) {
+      logger.warn("Anthropic provider selected but no api_key configured \u2014 falling back");
+      return new FallbackProvider();
+    }
+    return new AnthropicProvider({
+      apiKey,
+      inferenceModel: config.ai.inference_model ?? "claude-sonnet-4-20250514",
+      fastModel: config.ai.fast_model ?? "claude-haiku-4-5-20251001"
+    });
+  }
+  const defaults = OPENAI_COMPAT_DEFAULTS[provider];
+  if (defaults) {
+    const apiKey = config.ai.api_key ?? process.env[defaults.envKey] ?? "";
+    if (!apiKey && provider !== "lmstudio") {
+      logger.warn(`${provider} provider selected but no api_key configured \u2014 falling back`);
+      return new FallbackProvider();
+    }
+    return new OpenAIProvider({
+      apiKey,
+      baseUrl: config.ai.base_url ?? defaults.baseUrl,
+      embeddingModel: config.ai.embedding_model ?? defaults.embeddingModel,
+      embeddingDimensions: config.ai.embedding_dimensions ?? defaults.embeddingDimensions,
+      inferenceModel: config.ai.inference_model ?? defaults.inferenceModel,
+      fastModel: config.ai.fast_model ?? defaults.fastModel
+    });
+  }
   return new FallbackProvider();
 }
 
@@ -46337,8 +46724,8 @@ var SessionJournal = class _SessionJournal {
     };
     this.entries.push(entry);
     if (tool === "get_symbol" || tool === "get_outline") {
-      const path66 = params.path ?? params.file_path ?? "";
-      if (path66) this.filesRead.add(path66);
+      const path67 = params.path ?? params.file_path ?? "";
+      if (path67) this.filesRead.add(path67);
     }
     if (resultCount === 0 && this.isSearchTool(tool)) {
       this.zeroResultQueries.set(hash, summary);
@@ -47781,8 +48168,8 @@ init_logger();
 import { z as z2 } from "zod";
 
 // src/indexer/pipeline.ts
-import fs21 from "fs";
-import path20 from "path";
+import fs23 from "fs";
+import path21 from "path";
 import { cpus } from "os";
 import fg3 from "fast-glob";
 init_logger();
@@ -50262,7 +50649,7 @@ var FilePersister = class {
 };
 
 // src/indexer/edge-resolver.ts
-import path17 from "path";
+import path18 from "path";
 
 // src/plugin-api/executor.ts
 init_logger();
@@ -51419,6 +51806,251 @@ function buildFromPendingImports(state) {
   return result;
 }
 
+// src/indexer/edge-resolvers/php-imports.ts
+import * as path17 from "path";
+import * as fs18 from "fs";
+
+// src/indexer/resolvers/psr4.ts
+import { readFileSync } from "fs";
+var Psr4Resolver = class _Psr4Resolver {
+  constructor(mappings, rootPath) {
+    this.rootPath = rootPath;
+    this.mappings = /* @__PURE__ */ new Map();
+    for (const [prefix, dir] of mappings) {
+      const normPrefix = prefix.endsWith("\\") ? prefix : prefix + "\\";
+      const normDir = dir.endsWith("/") ? dir : dir + "/";
+      this.mappings.set(normPrefix, normDir);
+    }
+  }
+  rootPath;
+  /** namespace prefix (with trailing backslash) → directory (with trailing slash) */
+  mappings;
+  /**
+   * Create a Psr4Resolver from a composer.json file.
+   * Reads both autoload.psr-4 and autoload-dev.psr-4 sections.
+   */
+  static fromComposerJson(composerJsonPath, rootPath) {
+    try {
+      const raw = readFileSync(composerJsonPath, "utf-8");
+      const json = JSON.parse(raw);
+      const mappings = /* @__PURE__ */ new Map();
+      const extractPsr4 = (section) => {
+        if (section && typeof section === "object" && !Array.isArray(section)) {
+          const psr4 = section["psr-4"];
+          if (psr4 && typeof psr4 === "object" && !Array.isArray(psr4)) {
+            for (const [prefix, dir] of Object.entries(psr4)) {
+              if (typeof dir === "string") {
+                mappings.set(prefix, dir);
+              }
+              if (Array.isArray(dir)) {
+                for (const d of dir) {
+                  if (typeof d === "string") {
+                    mappings.set(prefix, d);
+                  }
+                }
+              }
+            }
+          }
+        }
+      };
+      extractPsr4(json["autoload"]);
+      extractPsr4(json["autoload-dev"]);
+      if (mappings.size === 0) return void 0;
+      return new _Psr4Resolver(mappings, rootPath);
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Resolve a fully qualified class name to a relative file path.
+   * Matches the longest prefix first.
+   *
+   * Example: "App\Models\User" → "app/Models/User.php"
+   */
+  resolve(fqn) {
+    let bestPrefix = "";
+    let bestDir = "";
+    for (const [prefix, dir] of this.mappings) {
+      if (fqn.startsWith(prefix) && prefix.length > bestPrefix.length) {
+        bestPrefix = prefix;
+        bestDir = dir;
+      }
+      const prefixNoSlash = prefix.slice(0, -1);
+      if (fqn === prefixNoSlash && prefix.length > bestPrefix.length) {
+        bestPrefix = prefix;
+        bestDir = dir;
+      }
+    }
+    if (!bestPrefix) return void 0;
+    const remainder = fqn.substring(bestPrefix.length);
+    const relativePath = remainder.replace(/\\/g, "/");
+    return bestDir + relativePath + ".php";
+  }
+  /**
+   * Reverse-resolve a relative file path to a fully qualified class name.
+   *
+   * Example: "app/Models/User.php" → "App\Models\User"
+   */
+  resolveToFqn(filePath) {
+    let normalised = filePath.replace(/\\/g, "/");
+    const rootNorm = this.rootPath.replace(/\\/g, "/").replace(/\/$/, "") + "/";
+    if (normalised.startsWith(rootNorm)) {
+      normalised = normalised.substring(rootNorm.length);
+    }
+    if (!normalised.endsWith(".php")) return void 0;
+    const withoutExt = normalised.slice(0, -4);
+    let bestPrefix = "";
+    let bestDir = "";
+    for (const [prefix, dir] of this.mappings) {
+      if (withoutExt.startsWith(dir) && dir.length > bestDir.length) {
+        bestPrefix = prefix;
+        bestDir = dir;
+      }
+      const dirNoSlash = dir.replace(/\/$/, "");
+      if (withoutExt.startsWith(dirNoSlash + "/") && dir.length > bestDir.length) {
+        bestPrefix = prefix;
+        bestDir = dir;
+      }
+    }
+    if (!bestDir) return void 0;
+    const remainder = withoutExt.substring(bestDir.length);
+    const fqnSuffix = remainder.replace(/\//g, "\\");
+    return bestPrefix + fqnSuffix;
+  }
+  /** Get all registered mappings (for debugging / inspection). */
+  getMappings() {
+    return this.mappings;
+  }
+};
+
+// src/indexer/edge-resolvers/php-imports.ts
+init_logger();
+function resolvePhpImportEdges(state) {
+  const { store } = state;
+  if (state.pendingImports.size === 0) return;
+  const allPhpFiles = store.db.prepare(
+    `SELECT id, path, workspace FROM files WHERE language = 'php'`
+  ).all();
+  if (allPhpFiles.length === 0) return;
+  const fqnToFile = /* @__PURE__ */ new Map();
+  const fqnRows = store.db.prepare(
+    `SELECT s.fqn, f.id, f.path, f.workspace FROM symbols s
+     JOIN files f ON s.file_id = f.id
+     WHERE s.fqn IS NOT NULL AND f.language = 'php'
+       AND s.kind IN ('class', 'interface', 'trait', 'enum')`
+  ).all();
+  for (const row of fqnRows) {
+    const key = `${row.workspace ?? ""}\0${row.fqn}`;
+    fqnToFile.set(key, { id: row.id, path: row.path, workspace: row.workspace });
+  }
+  const psr4Resolvers = /* @__PURE__ */ new Map();
+  const workspacePaths = /* @__PURE__ */ new Set();
+  for (const f of allPhpFiles) {
+    if (f.workspace) workspacePaths.add(f.workspace);
+  }
+  for (const wsPath of workspacePaths) {
+    const wsRoot = path17.join(state.rootPath, wsPath);
+    const composerPath = path17.join(wsRoot, "composer.json");
+    if (fs18.existsSync(composerPath)) {
+      const resolver = Psr4Resolver.fromComposerJson(composerPath, wsRoot);
+      if (resolver) psr4Resolvers.set(wsPath, resolver);
+    }
+  }
+  const rootComposer = path17.join(state.rootPath, "composer.json");
+  if (fs18.existsSync(rootComposer)) {
+    const resolver = Psr4Resolver.fromComposerJson(rootComposer, state.rootPath);
+    if (resolver) psr4Resolvers.set("", resolver);
+  }
+  const pathToFile = /* @__PURE__ */ new Map();
+  for (const f of allPhpFiles) {
+    pathToFile.set(f.path, f);
+  }
+  const fileNodeMap = /* @__PURE__ */ new Map();
+  const allFileIds = allPhpFiles.map((f) => f.id);
+  const CHUNK = 500;
+  for (let i = 0; i < allFileIds.length; i += CHUNK) {
+    for (const [k2, v] of store.getNodeIdsBatch("file", allFileIds.slice(i, i + CHUNK))) {
+      fileNodeMap.set(k2, v);
+    }
+  }
+  const importsEdgeType = store.db.prepare(
+    `SELECT id FROM edge_types WHERE name = ?`
+  ).get("imports");
+  if (!importsEdgeType) return;
+  const insertStmt = store.db.prepare(
+    `INSERT INTO edges (source_node_id, target_node_id, edge_type_id, resolved, metadata, is_cross_ws)
+     VALUES (?, ?, ?, 1, ?, ?)
+     ON CONFLICT(source_node_id, target_node_id, edge_type_id)
+     DO UPDATE SET metadata = excluded.metadata`
+  );
+  const pendingFileIds = Array.from(state.pendingImports.keys());
+  const fileMap = store.getFilesByIds(pendingFileIds);
+  const fileWorkspace = /* @__PURE__ */ new Map();
+  for (const f of allPhpFiles) {
+    fileWorkspace.set(f.id, f.workspace);
+  }
+  for (let i = 0; i < pendingFileIds.length; i += CHUNK) {
+    for (const [k2, v] of store.getNodeIdsBatch("file", pendingFileIds.slice(i, i + CHUNK))) {
+      fileNodeMap.set(k2, v);
+    }
+  }
+  let created = 0;
+  store.db.transaction(() => {
+    for (const [fileId, imports] of state.pendingImports) {
+      const file = fileMap.get(fileId);
+      if (!file || file.language !== "php") continue;
+      const sourceNodeId = fileNodeMap.get(fileId);
+      if (sourceNodeId == null) continue;
+      const sourceWs = fileWorkspace.get(fileId) ?? null;
+      const consolidated = /* @__PURE__ */ new Map();
+      for (const { from, specifiers } of imports) {
+        const existing = consolidated.get(from);
+        if (existing) existing.push(...specifiers);
+        else consolidated.set(from, [...specifiers]);
+      }
+      for (const [fqn, specifiers] of consolidated) {
+        const target = resolvePhpFqn(fqn, sourceWs, fqnToFile, psr4Resolvers, pathToFile, state.rootPath);
+        if (!target) continue;
+        const targetNodeId = fileNodeMap.get(target.id);
+        if (targetNodeId == null) continue;
+        if (sourceNodeId === targetNodeId) continue;
+        const isCrossWs = sourceWs !== target.workspace ? 1 : 0;
+        insertStmt.run(
+          sourceNodeId,
+          targetNodeId,
+          importsEdgeType.id,
+          JSON.stringify({ from: fqn, specifiers }),
+          isCrossWs
+        );
+        created++;
+      }
+    }
+  })();
+  if (created > 0) {
+    logger.info({ edges: created }, "PHP import edges resolved");
+  }
+}
+function resolvePhpFqn(fqn, sourceWorkspace, fqnIndex, psr4Resolvers, pathIndex, rootPath) {
+  if (!fqn) return null;
+  const wsKey = sourceWorkspace ?? "";
+  const sameWs = fqnIndex.get(`${wsKey}\0${fqn}`);
+  if (sameWs) return sameWs;
+  const psr4 = psr4Resolvers.get(wsKey);
+  if (psr4) {
+    const resolved = psr4.resolve(fqn);
+    if (resolved) {
+      const projectRelative = sourceWorkspace ? `${sourceWorkspace}/${resolved}` : resolved;
+      const fromPath = pathIndex.get(projectRelative);
+      if (fromPath) return fromPath;
+    }
+  }
+  if (sourceWorkspace) {
+    const noWs = fqnIndex.get(`\0${fqn}`);
+    if (noWs) return noWs;
+  }
+  return null;
+}
+
 // src/indexer/edge-resolvers/tests.ts
 init_logger();
 var TEST_PATH_RE = /\.(test|spec)\.[jt]sx?$|__tests__\/|(?:^|[/\\])test_[^/\\]+\.py$|(?:^|[/\\])[^/\\]+_test\.py$|conftest\.py$/;
@@ -51521,7 +52153,7 @@ var EdgeResolver = class {
       for (const p of activeResult.value) seen.add(p.manifest.name);
     }
     for (const ws2 of this.state.workspaces) {
-      const wsRoot = path17.join(this.state.rootPath, ws2.path);
+      const wsRoot = path18.join(this.state.rootPath, ws2.path);
       const wsCtx = buildProjectContext(wsRoot);
       const wsPlugins = this.state.registry.getAllFrameworkPlugins().filter((p) => !seen.has(p.manifest.name) && p.detect(wsCtx));
       if (wsPlugins.length === 0) continue;
@@ -51558,6 +52190,10 @@ var EdgeResolver = class {
   resolvePythonImportEdges() {
     resolvePythonImportEdges(this.state);
   }
+  /** Pass 2e2: PHP import edges (PSR-4 use statements). */
+  resolvePhpImportEdges() {
+    resolvePhpImportEdges(this.state);
+  }
   /** Pass 2f: Python heritage edges (class inheritance). */
   resolvePythonHeritageEdges() {
     resolvePythonHeritageEdges(this.state);
@@ -51730,12 +52366,12 @@ var EdgeResolver = class {
 };
 
 // src/indexer/file-extractor.ts
-import fs19 from "fs";
-import path18 from "path";
+import fs20 from "fs";
+import path19 from "path";
 
 // src/utils/hasher.ts
 import crypto5 from "crypto";
-import fs18 from "fs";
+import fs19 from "fs";
 function hashContent(content) {
   return crypto5.createHash("md5").update(content).digest("hex");
 }
@@ -51749,7 +52385,7 @@ var FileExtractor = class {
   ctx;
   async extract(relPath, force) {
     const { store, registry, rootPath } = this.ctx;
-    const absPath = path18.resolve(rootPath, relPath);
+    const absPath = path19.resolve(rootPath, relPath);
     const pathCheck = validatePath(relPath, rootPath);
     if (pathCheck.isErr()) {
       logger.warn({ file: relPath }, "Path traversal blocked");
@@ -51757,7 +52393,7 @@ var FileExtractor = class {
     }
     let fileMtimeMs = null;
     try {
-      const stat = fs19.lstatSync(absPath);
+      const stat = fs20.lstatSync(absPath);
       if (stat.isSymbolicLink()) {
         logger.warn({ file: relPath }, "Symlink skipped");
         return "error";
@@ -51775,7 +52411,7 @@ var FileExtractor = class {
     }
     let content;
     try {
-      content = fs19.readFileSync(absPath);
+      content = fs20.readFileSync(absPath);
     } catch {
       logger.warn({ file: relPath }, "Cannot read file");
       return "error";
@@ -51812,7 +52448,7 @@ var FileExtractor = class {
     const importEdges = [];
     if (parsed.edges?.length) {
       for (const edge of parsed.edges) {
-        const isImportEdge = (edge.edgeType === "imports" || edge.edgeType === "py_imports") && !edge.sourceNodeType && !edge.sourceSymbolId;
+        const isImportEdge = (edge.edgeType === "imports" || edge.edgeType === "py_imports" || edge.edgeType === "php_imports") && !edge.sourceNodeType && !edge.sourceSymbolId;
         if (isImportEdge) {
           importEdges.push({
             from: edge.metadata?.["from"] ?? "",
@@ -51881,7 +52517,7 @@ var FileExtractor = class {
     if (wsPath) {
       let cached = this.wsPluginCache.get(wsPath);
       if (cached === void 0) {
-        const wsRoot = path18.join(this.ctx.rootPath, wsPath);
+        const wsRoot = path19.join(this.ctx.rootPath, wsPath);
         const wsCtx = buildProjectContext(wsRoot);
         cached = this.ctx.registry.getAllFrameworkPlugins().filter((p) => p.detect(wsCtx));
         this.wsPluginCache.set(wsPath, cached);
@@ -51918,7 +52554,7 @@ var FileExtractor = class {
     return null;
   }
   detectLanguage(filePath) {
-    const ext = path18.extname(filePath).slice(1);
+    const ext = path19.extname(filePath).slice(1);
     const map = {
       php: "php",
       ts: "typescript",
@@ -51934,8 +52570,8 @@ var FileExtractor = class {
 };
 
 // src/indexer/env-indexer.ts
-import fs20 from "fs";
-import path19 from "path";
+import fs21 from "fs";
+import path20 from "path";
 import fg2 from "fast-glob";
 
 // src/utils/env-parser.ts
@@ -52066,12 +52702,12 @@ var EnvIndexer = class {
         logger.debug({ file: relPath }, ".env file skipped by .traceignore");
         continue;
       }
-      const absPath = path19.resolve(this.rootPath, relPath);
+      const absPath = path20.resolve(this.rootPath, relPath);
       const pathCheck = validatePath(relPath, this.rootPath);
       if (pathCheck.isErr()) continue;
       let content;
       try {
-        content = fs20.readFileSync(absPath, "utf-8");
+        content = fs21.readFileSync(absPath, "utf-8");
       } catch {
         logger.warn({ file: relPath }, "Cannot read .env file");
         continue;
@@ -52165,7 +52801,7 @@ var IndexingPipeline = class _IndexingPipeline {
     if (filePaths.length === 0) return;
     this.store.db.transaction(() => {
       for (const fp of filePaths) {
-        const relPath = path20.isAbsolute(fp) ? path20.relative(this.rootPath, fp) : fp;
+        const relPath = path21.isAbsolute(fp) ? path21.relative(this.rootPath, fp) : fp;
         const file = this.store.getFile(relPath);
         if (file) {
           this.store.deleteFile(file.id);
@@ -52180,7 +52816,7 @@ var IndexingPipeline = class _IndexingPipeline {
       const start = Date.now();
       const relPaths = [];
       for (const fp of filePaths) {
-        const rel = path20.isAbsolute(fp) ? path20.relative(this.rootPath, fp) : fp;
+        const rel = path21.isAbsolute(fp) ? path21.relative(this.rootPath, fp) : fp;
         const check = validatePath(rel, this.rootPath);
         if (check.isErr()) {
           logger.warn({ file: fp }, "Path traversal blocked in indexFiles");
@@ -52298,6 +52934,7 @@ var IndexingPipeline = class _IndexingPipeline {
     edgeResolver.resolveTypeScriptHeritageEdges();
     edgeResolver.resolveEsmImportEdges();
     edgeResolver.resolvePythonImportEdges();
+    edgeResolver.resolvePhpImportEdges();
     edgeResolver.resolvePythonHeritageEdges();
     edgeResolver.resolvePythonCallEdges();
     edgeResolver.resolveTestCoversEdges();
@@ -52343,7 +52980,7 @@ var IndexingPipeline = class _IndexingPipeline {
     const activeResult = this.registry.getActiveFrameworkPlugins(ctx);
     if (activeResult.isOk()) registerSchema(activeResult.value);
     for (const ws2 of this.workspaces) {
-      const wsRoot = path20.join(this.rootPath, ws2.path);
+      const wsRoot = path21.join(this.rootPath, ws2.path);
       const wsCtx = buildProjectContext(wsRoot);
       const wsPlugins = this.registry.getAllFrameworkPlugins().filter((p) => p.detect(wsCtx));
       registerSchema(wsPlugins);
@@ -52378,7 +53015,7 @@ var IndexingPipeline = class _IndexingPipeline {
         const cached = this._fileContentCache.get(relPath);
         if (cached !== void 0) return cached;
         try {
-          return fs21.readFileSync(path20.resolve(this.rootPath, relPath), "utf-8");
+          return fs23.readFileSync(path21.resolve(this.rootPath, relPath), "utf-8");
         } catch {
           return void 0;
         }
@@ -52734,28 +53371,28 @@ function registerCoreTools(server, ctx) {
 import { z as z3 } from "zod";
 
 // src/tools/navigation/navigation.ts
-import path23 from "path";
+import path24 from "path";
 
 // src/utils/source-reader.ts
-import fs23 from "fs";
-import path21 from "path";
+import fs24 from "fs";
+import path23 from "path";
 var GITIGNORED_NOTICE = "[content hidden \u2014 file is gitignored]";
 function readByteRange(filePath, byteStart, byteEnd, gitignored) {
   if (gitignored && !isEnvFile(filePath)) return GITIGNORED_NOTICE;
   if (byteEnd <= byteStart || byteStart < 0) return "";
-  const fd = fs23.openSync(filePath, "r");
+  const fd = fs24.openSync(filePath, "r");
   try {
     const length = byteEnd - byteStart;
     const buffer = Buffer.alloc(length);
-    const bytesRead = fs23.readSync(fd, buffer, 0, length, byteStart);
+    const bytesRead = fs24.readSync(fd, buffer, 0, length, byteStart);
     return buffer.subarray(0, bytesRead).toString("utf8");
   } finally {
-    fs23.closeSync(fd);
+    fs24.closeSync(fd);
   }
 }
 var ENV_BASENAME_RE = /^\.env(\..+)?$/;
 function isEnvFile(filePath) {
-  return ENV_BASENAME_RE.test(path21.basename(filePath));
+  return ENV_BASENAME_RE.test(path23.basename(filePath));
 }
 
 // src/scoring/signal-fusion.ts
@@ -52910,7 +53547,7 @@ function getSymbol(store, rootPath, opts) {
   if (!file) {
     return err3(notFound(`file:${symbol.file_id}`));
   }
-  const absPath = path23.resolve(rootPath, file.path);
+  const absPath = path24.resolve(rootPath, file.path);
   let source;
   let truncated;
   try {
@@ -53797,9 +54434,9 @@ function deduplicateByFile(rawDeps) {
     }
   }
   const result = [];
-  for (const [path66, entry] of fileMap) {
+  for (const [path67, entry] of fileMap) {
     const dep = {
-      path: path66,
+      path: path67,
       edgeTypes: [...entry.edgeTypes],
       depth: entry.depth
     };
@@ -53992,7 +54629,7 @@ function getPennantImpact(store, name) {
 }
 
 // src/tools/navigation/context.ts
-import path24 from "path";
+import path25 from "path";
 
 // src/utils/token-counter.ts
 function estimateTokens(text) {
@@ -54252,7 +54889,7 @@ function getFeatureContext(store, rootPath, description, tokenBudget = 4e3) {
     const meta = `[${item.symbol.kind}] ${item.symbol.fqn ?? item.symbol.name} (${item.file.path})`;
     let source;
     try {
-      const absPath = path24.resolve(rootPath, item.file.path);
+      const absPath = path25.resolve(rootPath, item.file.path);
       source = readByteRange(absPath, item.symbol.byte_start, item.symbol.byte_end, !!item.file.gitignored);
     } catch {
     }
@@ -54288,7 +54925,7 @@ function getFeatureContext(store, rootPath, description, tokenBudget = 4e3) {
 }
 
 // src/tools/navigation/context-bundle.ts
-import path25 from "path";
+import path26 from "path";
 import { ok as ok3, err as err4 } from "neverthrow";
 
 // src/scoring/structured-assembly.ts
@@ -54376,9 +55013,9 @@ var FileReadCache = class {
     let buf = this.cache.get(file.id);
     if (buf === void 0) {
       try {
-        const absPath = path25.resolve(this.rootPath, file.path);
-        const fs56 = __require("fs");
-        buf = fs56.readFileSync(absPath);
+        const absPath = path26.resolve(this.rootPath, file.path);
+        const fs57 = __require("fs");
+        buf = fs57.readFileSync(absPath);
       } catch {
         buf = null;
       }
@@ -54536,7 +55173,7 @@ function getContextBundle(store, rootPath, opts) {
 }
 
 // src/tools/navigation/task-context.ts
-import path26 from "path";
+import path27 from "path";
 var INTENT_PATTERNS = [
   [/\b(fix|bug|error|crash(?:es|ed|ing)?|broken|issue|fail(?:ing|s|ed)?|wrong|regression|debug|patch|hotfix)\b/i, "bugfix"],
   [/\b(add|create|new|implement|build|introduce|feature|setup|integrate|wire|connect)\b/i, "new_feature"],
@@ -54763,7 +55400,7 @@ async function getTaskContext(store, rootPath, opts, ai) {
     const meta = `[${entry.symbol.kind}] ${entry.symbol.fqn ?? entry.symbol.name} (${entry.file.path})`;
     let source;
     try {
-      const absPath = path26.resolve(rootPath, entry.file.path);
+      const absPath = path27.resolve(rootPath, entry.file.path);
       source = readByteRange(absPath, entry.symbol.byte_start, entry.symbol.byte_end, !!entry.file.gitignored);
     } catch {
     }
@@ -55132,8 +55769,8 @@ function buildNegativeEvidence(filesOrOpts, indexedSymbols, queryExpanded, toolN
 }
 
 // src/tools/navigation/search-text.ts
-import fs24 from "fs";
-import path27 from "path";
+import fs25 from "fs";
+import path28 from "path";
 import picomatch from "picomatch";
 function searchText(store, projectRoot, opts) {
   const {
@@ -55177,14 +55814,14 @@ function searchText(store, projectRoot, opts) {
       truncated = true;
       break;
     }
-    const absPath = path27.resolve(projectRoot, file.path);
+    const absPath = path28.resolve(projectRoot, file.path);
     const pathCheck = validatePath(file.path, projectRoot);
     if (pathCheck.isErr()) continue;
     let content;
     try {
-      const stat = fs24.statSync(absPath);
+      const stat = fs25.statSync(absPath);
       if (stat.size > 1048576) continue;
-      content = fs24.readFileSync(absPath, "utf-8");
+      content = fs25.readFileSync(absPath, "utf-8");
     } catch {
       continue;
     }
@@ -55232,8 +55869,8 @@ function escapeRegex(str2) {
 
 // src/tools/navigation/zero-index.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { readFileSync as readFileSync2, readdirSync, statSync } from "fs";
-import path28 from "path";
+import { readFileSync as readFileSync3, readdirSync, statSync } from "fs";
+import path29 from "path";
 var RG_ARGS_BASE = [
   "--json",
   "--max-count=200",
@@ -55264,7 +55901,7 @@ function searchWithRipgrep(projectRoot, query, opts) {
         const parsed = JSON.parse(line);
         if (parsed.type !== "match") continue;
         const data = parsed.data;
-        const relPath = path28.relative(projectRoot, data.path.text);
+        const relPath = path29.relative(projectRoot, data.path.text);
         matches.push({
           file: relPath,
           line: data.line_number,
@@ -55300,7 +55937,7 @@ function manualSearch(projectRoot, query, opts) {
     for (const entry of entries) {
       if (matches.length >= limit) return;
       if (traceignore.isSkippedDir(entry)) continue;
-      const full2 = path28.join(dir, entry);
+      const full2 = path29.join(dir, entry);
       let stat;
       try {
         stat = statSync(full2);
@@ -55310,17 +55947,17 @@ function manualSearch(projectRoot, query, opts) {
       if (stat.isDirectory()) {
         walk(full2);
       } else if (stat.isFile() && stat.size < 512 * 1024) {
-        const rel = path28.relative(projectRoot, full2);
+        const rel = path29.relative(projectRoot, full2);
         if (traceignore.isIgnored(rel)) continue;
         try {
-          const content = readFileSync2(full2, "utf-8");
+          const content = readFileSync3(full2, "utf-8");
           const lines = content.split("\n");
           for (let i = 0; i < lines.length; i++) {
             regex.lastIndex = 0;
             const m = regex.exec(lines[i]);
             if (m) {
               matches.push({
-                file: path28.relative(projectRoot, full2),
+                file: path29.relative(projectRoot, full2),
                 line: i + 1,
                 column: m.index + 1,
                 text: lines[i].trimEnd()
@@ -55387,7 +56024,7 @@ SYMBOL_PATTERNS["tsx"] = SYMBOL_PATTERNS["typescript"];
 SYMBOL_PATTERNS["jsx"] = SYMBOL_PATTERNS["javascript"];
 SYMBOL_PATTERNS["kotlin"] = SYMBOL_PATTERNS["java"];
 function detectLanguage(filePath) {
-  const ext = path28.extname(filePath).toLowerCase();
+  const ext = path29.extname(filePath).toLowerCase();
   const map = {
     ".ts": "typescript",
     ".tsx": "typescript",
@@ -55438,8 +56075,8 @@ function fallbackSearch(projectRoot, query, opts = {}) {
   };
 }
 function fallbackOutline(projectRoot, filePath) {
-  const absPath = path28.resolve(projectRoot, filePath);
-  const content = readFileSync2(absPath, "utf-8");
+  const absPath = path29.resolve(projectRoot, filePath);
+  const content = readFileSync3(absPath, "utf-8");
   const language = detectLanguage(filePath);
   const symbols = extractSymbolsFromContent(content, language);
   return {
@@ -55495,13 +56132,13 @@ function computeAdaptiveBudget(toolName, state, userBudget) {
 }
 
 // src/subproject/manager.ts
-import path33 from "path";
-import fs30 from "fs";
+import path34 from "path";
+import fs31 from "fs";
 
 // src/topology/contract-parser.ts
 init_logger();
-import fs25 from "fs";
-import path29 from "path";
+import fs26 from "fs";
+import path30 from "path";
 import Database2 from "better-sqlite3";
 var EXCLUDE_DIRS = ["node_modules", "vendor", ".git", "dist", "build", "__pycache__"];
 function parseContracts(repoRoot) {
@@ -55509,8 +56146,8 @@ function parseContracts(repoRoot) {
   const specFiles = findSpecFiles(repoRoot);
   for (const { filePath, type } of specFiles) {
     try {
-      const content = fs25.readFileSync(filePath, "utf-8");
-      const relPath = path29.relative(repoRoot, filePath);
+      const content = fs26.readFileSync(filePath, "utf-8");
+      const relPath = path30.relative(repoRoot, filePath);
       let contract = null;
       switch (type) {
         case "openapi":
@@ -55683,13 +56320,13 @@ function findSpecFiles(root) {
     if (depth > 5) return;
     let entries;
     try {
-      entries = fs25.readdirSync(dir, { withFileTypes: true });
+      entries = fs26.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (EXCLUDE_DIRS.includes(entry.name)) continue;
-      const fullPath = path29.join(dir, entry.name);
+      const fullPath = path30.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath, depth + 1);
       } else if (entry.isFile()) {
@@ -55707,8 +56344,9 @@ function findSpecFiles(root) {
   walk(root, 0);
   return results;
 }
+var HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "ANY"]);
 function extractRoutesFromDb(dbPath, pathPrefix) {
-  if (!fs25.existsSync(dbPath)) return null;
+  if (!fs26.existsSync(dbPath)) return null;
   try {
     const db = new Database2(dbPath, { readonly: true });
     try {
@@ -55727,6 +56365,7 @@ function extractRoutesFromDb(dbPath, pathPrefix) {
           "SELECT method, uri, name FROM routes ORDER BY uri"
         ).all();
       }
+      rows = rows.filter((r) => HTTP_METHODS.has(r.method));
       if (rows.length === 0) return null;
       const endpoints = rows.map((r) => ({
         method: r.method === "ANY" ? null : r.method,
@@ -55752,12 +56391,12 @@ function extractRoutesFromDb(dbPath, pathPrefix) {
 
 // src/topology/service-detector.ts
 init_logger();
-import fs27 from "fs";
-import path31 from "path";
+import fs28 from "fs";
+import path32 from "path";
 
 // src/project-root.ts
-import fs26 from "fs";
-import path30 from "path";
+import fs27 from "fs";
+import path31 from "path";
 var ROOT_MARKERS = [
   // VCS
   ".git",
@@ -55821,7 +56460,7 @@ var SKIP_DIRS2 = /* @__PURE__ */ new Set([".git", "node_modules", "vendor", ".sv
 function detectServices(repoRoots) {
   const services = [];
   for (const root of repoRoots) {
-    const absRoot = path31.resolve(root);
+    const absRoot = path32.resolve(root);
     const composeServices = detectFromDockerCompose(absRoot);
     if (composeServices.length > 0) {
       services.push(...composeServices);
@@ -55833,7 +56472,7 @@ function detectServices(repoRoots) {
       continue;
     }
     services.push({
-      name: path31.basename(absRoot),
+      name: path32.basename(absRoot),
       repoRoot: absRoot,
       serviceType: "monolith",
       detectionSource: "workspace"
@@ -55844,7 +56483,7 @@ function detectServices(repoRoots) {
 function detectFromWorkspaceStructure(root) {
   let entries;
   try {
-    entries = fs27.readdirSync(root, { withFileTypes: true });
+    entries = fs28.readdirSync(root, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -55853,7 +56492,7 @@ function detectFromWorkspaceStructure(root) {
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (entry.name.startsWith(".") || SKIP_DIRS2.has(entry.name)) continue;
-    const childDir = path31.join(root, entry.name);
+    const childDir = path32.join(root, entry.name);
     if (hasRootMarker(childDir)) {
       flatServices.push({
         name: entry.name,
@@ -55873,14 +56512,14 @@ function detectFromWorkspaceStructure(root) {
   for (const { name: groupName, dir: groupDir } of dirsWithoutMarker) {
     let childEntries;
     try {
-      childEntries = fs27.readdirSync(groupDir, { withFileTypes: true });
+      childEntries = fs28.readdirSync(groupDir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const childEntry of childEntries) {
       if (!childEntry.isDirectory()) continue;
       if (childEntry.name.startsWith(".") || SKIP_DIRS2.has(childEntry.name)) continue;
-      const childDir = path31.join(groupDir, childEntry.name);
+      const childDir = path32.join(groupDir, childEntry.name);
       if (hasRootMarker(childDir)) {
         groupedServices.push({
           name: `${groupName}/${childEntry.name}`,
@@ -55901,7 +56540,7 @@ function detectFromWorkspaceStructure(root) {
 }
 function hasRootMarker(dir) {
   for (const marker of ROOT_MARKERS) {
-    if (fs27.existsSync(path31.join(dir, marker))) return true;
+    if (fs28.existsSync(path32.join(dir, marker))) return true;
   }
   return false;
 }
@@ -55909,15 +56548,15 @@ function detectFromDockerCompose(root) {
   const composeFiles = ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"];
   let composePath;
   for (const f of composeFiles) {
-    const p = path31.join(root, f);
-    if (fs27.existsSync(p)) {
+    const p = path32.join(root, f);
+    if (fs28.existsSync(p)) {
       composePath = p;
       break;
     }
   }
   if (!composePath) return [];
   try {
-    const content = fs27.readFileSync(composePath, "utf-8");
+    const content = fs28.readFileSync(composePath, "utf-8");
     const services = [];
     const lines = content.split("\n");
     let inServices = false;
@@ -55964,8 +56603,8 @@ function detectFromDockerCompose(root) {
 
 // src/subproject/scanner.ts
 init_logger();
-import fs28 from "fs";
-import path32 from "path";
+import fs29 from "fs";
+import path33 from "path";
 var CALL_PATTERNS = [
   // fetch('url') / fetch(`url`)
   {
@@ -56092,19 +56731,19 @@ function walkAndScan(dir, repoRoot, results, depth) {
   if (depth > 10) return;
   let entries;
   try {
-    entries = fs28.readdirSync(dir, { withFileTypes: true });
+    entries = fs29.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
     if (EXCLUDE_DIRS2.has(entry.name)) continue;
-    const fullPath = path32.join(dir, entry.name);
+    const fullPath = path33.join(dir, entry.name);
     if (entry.isDirectory()) {
       walkAndScan(fullPath, repoRoot, results, depth + 1);
-    } else if (entry.isFile() && CODE_EXTENSIONS.has(path32.extname(entry.name).toLowerCase())) {
+    } else if (entry.isFile() && CODE_EXTENSIONS.has(path33.extname(entry.name).toLowerCase())) {
       try {
-        const content = fs28.readFileSync(fullPath, "utf-8");
-        const relPath = path32.relative(repoRoot, fullPath);
+        const content = fs29.readFileSync(fullPath, "utf-8");
+        const relPath = path33.relative(repoRoot, fullPath);
         scanFileContent(relPath, content, results);
       } catch {
       }
@@ -56144,7 +56783,7 @@ function scanFileContent(filePath, content, results) {
 init_logger();
 
 // src/subproject/subproject-search.ts
-import fs29 from "fs";
+import fs30 from "fs";
 import Database3 from "better-sqlite3";
 init_logger();
 function subprojectSearch(topoStore, query, filters, limit = 20, excludeRoot) {
@@ -56153,7 +56792,7 @@ function subprojectSearch(topoStore, query, filters, limit = 20, excludeRoot) {
   let reposSearched = 0;
   const normalizedExclude = excludeRoot?.replace(/\/+$/, "");
   for (const repo of repos) {
-    if (!repo.db_path || !fs29.existsSync(repo.db_path)) continue;
+    if (!repo.db_path || !fs30.existsSync(repo.db_path)) continue;
     if (normalizedExclude && repo.repo_root.replace(/\/+$/, "") === normalizedExclude) continue;
     let db = null;
     try {
@@ -56462,18 +57101,18 @@ var SubprojectManager = class {
    * @param opts - optional name, contract paths
    */
   add(repoRoot, projectRoot, opts) {
-    const absRoot = path33.resolve(repoRoot);
-    const absProjectRoot = path33.resolve(projectRoot);
-    if (!fs30.existsSync(absRoot)) {
+    const absRoot = path34.resolve(repoRoot);
+    const absProjectRoot = path34.resolve(projectRoot);
+    if (!fs31.existsSync(absRoot)) {
       throw new Error(`Repository path does not exist: ${absRoot}`);
     }
-    const repoName = opts?.name ?? path33.basename(absRoot);
+    const repoName = opts?.name ?? path34.basename(absRoot);
     const dbPath = getDbPath(absRoot);
     const repoId = this.topoStore.upsertSubproject({
       name: repoName,
       repoRoot: absRoot,
       projectRoot: absProjectRoot,
-      dbPath: fs30.existsSync(dbPath) ? dbPath : void 0,
+      dbPath: fs31.existsSync(dbPath) ? dbPath : void 0,
       contractPaths: opts?.contractPaths
     });
     const detected = detectServices([absRoot]);
@@ -56487,6 +57126,7 @@ var SubprojectManager = class {
         projectGroup: svc.projectGroup,
         metadata: svc.metadata
       });
+      this.topoStore.deleteContractsByService(serviceId);
       this.registerContracts(serviceId, svc.repoRoot, absRoot, opts?.contractPaths);
     }
     const clientCalls = this.scanAndLinkClientCalls(repoId, absRoot);
@@ -56509,8 +57149,8 @@ var SubprojectManager = class {
    * sub-services (from docker-compose, workspace structure, or root markers).
    */
   autoDiscoverSubprojects(projectRoot, opts) {
-    const absProjectRoot = path33.resolve(projectRoot);
-    if (!fs30.existsSync(absProjectRoot)) {
+    const absProjectRoot = path34.resolve(projectRoot);
+    if (!fs31.existsSync(absProjectRoot)) {
       throw new Error(`Project path does not exist: ${absProjectRoot}`);
     }
     const detected = detectServices([absProjectRoot]);
@@ -56522,7 +57162,7 @@ var SubprojectManager = class {
         name: repoName,
         repoRoot: svc.repoRoot,
         projectRoot: absProjectRoot,
-        dbPath: fs30.existsSync(dbPath) ? dbPath : void 0,
+        dbPath: fs31.existsSync(dbPath) ? dbPath : void 0,
         contractPaths: opts?.contractPaths
       });
       const serviceId = this.topoStore.upsertService({
@@ -56534,6 +57174,7 @@ var SubprojectManager = class {
         projectGroup: svc.projectGroup,
         metadata: svc.metadata
       });
+      this.topoStore.deleteContractsByService(serviceId);
       this.registerContracts(serviceId, svc.repoRoot, svc.repoRoot, opts?.contractPaths);
       const clientCalls = this.scanAndLinkClientCalls(repoId, svc.repoRoot);
       this.topoStore.updateSubprojectSyncTime(repoId);
@@ -56636,7 +57277,7 @@ var SubprojectManager = class {
     let endpointsUpdated = 0;
     let clientCallsScanned = 0;
     for (const repo of repos) {
-      if (!fs30.existsSync(repo.repo_root)) {
+      if (!fs31.existsSync(repo.repo_root)) {
         logger.warn({ repo: repo.name, root: repo.repo_root }, "Subproject repo no longer exists, skipping");
         continue;
       }
@@ -56712,11 +57353,11 @@ var SubprojectManager = class {
     const contracts = parseContracts(serviceRoot);
     if (explicitPaths && repoRoot) {
       for (const cp of explicitPaths) {
-        const absContract = path33.resolve(repoRoot, cp);
-        if (fs30.existsSync(absContract)) {
-          const additional = parseContracts(path33.dirname(absContract));
+        const absContract = path34.resolve(repoRoot, cp);
+        if (fs31.existsSync(absContract)) {
+          const additional = parseContracts(path34.dirname(absContract));
           contracts.push(...additional.filter(
-            (c) => path33.resolve(repoRoot, c.specPath) === absContract
+            (c) => path34.resolve(repoRoot, c.specPath) === absContract
           ));
         }
       }
@@ -56817,7 +57458,7 @@ var SubprojectManager = class {
     for (const [repoName, calls] of byRepo) {
       const repo = this.topoStore.getSubproject(repoName);
       for (const call of calls) {
-        const symbols = repo?.db_path && fs30.existsSync(repo.db_path) ? resolveSymbolsAtLocation(repo.db_path, call.file_path, call.line) : [];
+        const symbols = repo?.db_path && fs31.existsSync(repo.db_path) ? resolveSymbolsAtLocation(repo.db_path, call.file_path, call.line) : [];
         clients.push({
           repo: repoName,
           filePath: call.file_path,
@@ -57583,8 +58224,8 @@ function splitControllerRef(ref) {
 }
 
 // src/tools/framework/middleware-chain.ts
-import fs31 from "fs";
-import path34 from "path";
+import fs32 from "fs";
+import path35 from "path";
 function getMiddlewareChain(store, rootPath, url2) {
   const allRoutes = store.getAllRoutes();
   const matchingRoute = allRoutes.find((r) => {
@@ -57633,7 +58274,7 @@ function detectFramework(allFiles) {
 }
 function readSource(rootPath, filePath) {
   try {
-    return fs31.readFileSync(path34.resolve(rootPath, filePath), "utf-8");
+    return fs32.readFileSync(path35.resolve(rootPath, filePath), "utf-8");
   } catch {
     return void 0;
   }
@@ -57791,12 +58432,12 @@ function buildDjangoChain(store, rootPath, allFiles, chain) {
 }
 
 // src/tools/analysis/module-graph.ts
-import fs33 from "fs";
-import path36 from "path";
+import fs34 from "fs";
+import path37 from "path";
 
 // src/indexer/plugins/integration/framework/nestjs/index.ts
-import fs32 from "fs";
-import path35 from "path";
+import fs33 from "fs";
+import path36 from "path";
 var MODULE_RE = /@Module\(\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}\s*\)/s;
 function extractModuleArray(body, prop) {
   const re = new RegExp(`${escapeRegExp(prop)}\\s*:\\s*\\[([^\\]]*?)\\]`, "s");
@@ -57827,14 +58468,14 @@ function getModuleGraph(store, rootPath, moduleName) {
   for (const file of moduleFiles) {
     let source;
     try {
-      source = fs33.readFileSync(path36.resolve(rootPath, file.path), "utf-8");
+      source = fs34.readFileSync(path37.resolve(rootPath, file.path), "utf-8");
     } catch {
       continue;
     }
     const info = extractModuleInfo(source);
     if (!info) continue;
     const classMatch = source.match(/export\s+class\s+(\w+)/);
-    const name = classMatch?.[1] ?? path36.basename(file.path, path36.extname(file.path));
+    const name = classMatch?.[1] ?? path37.basename(file.path, path37.extname(file.path));
     moduleMap.set(name, {
       name,
       file: file.path,
@@ -58915,7 +59556,7 @@ function findNovaSymbol(store, name) {
 }
 
 // src/tools/framework/tests.ts
-import path37 from "path";
+import path38 from "path";
 import { ok as ok8, err as err9 } from "neverthrow";
 function getTestsFor(store, opts) {
   let targetFile;
@@ -58969,14 +59610,14 @@ function getTestsFor(store, opts) {
     }
   }
   if (targetFile) {
-    const baseName = path37.basename(targetFile, path37.extname(targetFile));
+    const baseName = path38.basename(targetFile, path38.extname(targetFile));
     const normalized = baseName.replace(/([A-Z])/g, (m) => `-${m.toLowerCase()}`).replace(/^-/, "").toLowerCase();
     const variants = [baseName.toLowerCase(), normalized];
     const allFiles = store.getAllFiles();
     for (const f of allFiles) {
       if (seen.has(f.path)) continue;
       if (!isTestFile(f.path)) continue;
-      const testBase = path37.basename(f.path).toLowerCase();
+      const testBase = path38.basename(f.path).toLowerCase();
       if (variants.some((v) => testBase.includes(v))) {
         seen.add(f.path);
         tests.push({ test_file: f.path, edge_type: "heuristic_path" });
@@ -60485,8 +61126,8 @@ import { z as z6 } from "zod";
 
 // src/tools/refactoring/dead-code.ts
 init_logger();
-import fs34 from "fs";
-import path38 from "path";
+import fs35 from "fs";
+import path39 from "path";
 var DECORATOR_DRIVEN_FRAMEWORKS = /* @__PURE__ */ new Set([
   "nestjs",
   "laravel",
@@ -60521,7 +61162,7 @@ var BARREL_PATTERNS = [
   /^main\.[jt]sx?$/
 ];
 function isBarrelFile(filePath) {
-  const base = path38.basename(filePath);
+  const base = path39.basename(filePath);
   return BARREL_PATTERNS.some((p) => p.test(base));
 }
 function buildImportedNamesSet(store) {
@@ -60721,12 +61362,12 @@ function readPackageEntries(projectRoot) {
   const paths = /* @__PURE__ */ new Set();
   const sources = {};
   if (!projectRoot) return { paths, sources };
-  const pkgPath = path38.join(projectRoot, "package.json");
-  if (!fs34.existsSync(pkgPath)) return { paths, sources };
+  const pkgPath = path39.join(projectRoot, "package.json");
+  if (!fs35.existsSync(pkgPath)) return { paths, sources };
   try {
-    const pkg = JSON.parse(fs34.readFileSync(pkgPath, "utf-8"));
+    const pkg = JSON.parse(fs35.readFileSync(pkgPath, "utf-8"));
     const add = (rel, src) => {
-      const norm = path38.normalize(rel).replace(/\\/g, "/");
+      const norm = path39.normalize(rel).replace(/\\/g, "/");
       paths.add(norm);
       sources[norm] = src;
     };
@@ -60944,8 +61585,8 @@ function getDeadCodeReachability(store, options = {}) {
 }
 
 // src/tools/quality/security-scan.ts
-import { readFileSync as readFileSync3 } from "fs";
-import path39 from "path";
+import { readFileSync as readFileSync4 } from "fs";
+import path40 from "path";
 var ALL_LANGUAGES = /* @__PURE__ */ new Set([
   "typescript",
   "javascript",
@@ -61227,10 +61868,10 @@ function scanSecurity(store, projectRoot, opts) {
     const batch = files.slice(i, i + BATCH_SIZE);
     for (const file of batch) {
       if (/\.(?:test|spec)\.|__tests__|\/tests?\//i.test(file.path)) continue;
-      const absPath = path39.resolve(projectRoot, file.path);
+      const absPath = path40.resolve(projectRoot, file.path);
       let content;
       try {
-        const buf = readFileSync3(absPath);
+        const buf = readFileSync4(absPath);
         if (buf.length > MAX_FILE_SIZE) continue;
         content = buf.toString("utf-8");
       } catch {
@@ -61925,8 +62566,8 @@ function detectAntipatterns(store, _projectRoot, opts = {}) {
 }
 
 // src/tools/quality/code-smells.ts
-import { readFileSync as readFileSync4 } from "fs";
-import path40 from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import path41 from "path";
 var ALL_CATEGORIES2 = [
   "todo_comment",
   "empty_function",
@@ -62181,10 +62822,10 @@ function scanCodeSmells(store, projectRoot, opts = {}) {
     const batch = files.slice(i, i + BATCH_SIZE2);
     for (const file of batch) {
       if (!includeTests && /\.(?:test|spec)\.|__tests__|\/tests?\//i.test(file.path)) continue;
-      const absPath = path40.resolve(projectRoot, file.path);
+      const absPath = path41.resolve(projectRoot, file.path);
       let content;
       try {
-        const buf = readFileSync4(absPath);
+        const buf = readFileSync5(absPath);
         if (buf.length > MAX_FILE_SIZE2) continue;
         content = buf.toString("utf-8");
       } catch {
@@ -62237,8 +62878,8 @@ function scanCodeSmells(store, projectRoot, opts = {}) {
 }
 
 // src/tools/quality/taint-analysis.ts
-import { readFileSync as readFileSync5 } from "fs";
-import path41 from "path";
+import { readFileSync as readFileSync6 } from "fs";
+import path42 from "path";
 var JS_TS2 = /* @__PURE__ */ new Set(["typescript", "javascript"]);
 var PY2 = /* @__PURE__ */ new Set(["python"]);
 var PHP2 = /* @__PURE__ */ new Set(["php"]);
@@ -62594,10 +63235,10 @@ function interProceduralAnalysis(store, projectRoot, perFileResults, limit) {
   for (const [filePath, fileData] of perFileResults) {
     if (crossFileFlows.length >= limit) break;
     if (fileData.sources.length === 0) continue;
-    const absPath = path41.join(projectRoot, filePath);
+    const absPath = path42.join(projectRoot, filePath);
     let content;
     try {
-      content = readFileSync5(absPath, "utf-8");
+      content = readFileSync6(absPath, "utf-8");
     } catch {
       continue;
     }
@@ -62616,10 +63257,10 @@ function interProceduralAnalysis(store, projectRoot, perFileResults, limit) {
       ).all(call.funcName, filePath);
       for (const sym of symbols) {
         if (crossFileFlows.length >= limit) break;
-        const targetPath = path41.join(projectRoot, sym.file_path);
+        const targetPath = path42.join(projectRoot, sym.file_path);
         let targetContent;
         try {
-          targetContent = readFileSync5(targetPath, "utf-8");
+          targetContent = readFileSync6(targetPath, "utf-8");
         } catch {
           continue;
         }
@@ -62677,10 +63318,10 @@ function taintAnalysis(store, projectRoot, opts = {}) {
   const perFileData = /* @__PURE__ */ new Map();
   for (const file of sourceFiles) {
     if (allFlows.length >= limit) break;
-    const absPath = path41.join(projectRoot, file.path);
+    const absPath = path42.join(projectRoot, file.path);
     let content;
     try {
-      content = readFileSync5(absPath, "utf-8");
+      content = readFileSync6(absPath, "utf-8");
     } catch {
       continue;
     }
@@ -62762,8 +63403,8 @@ function taintAnalysis(store, projectRoot, opts = {}) {
 }
 
 // src/tools/project/sbom.ts
-import { readFileSync as readFileSync6, existsSync as existsSync2 } from "fs";
-import path42 from "path";
+import { readFileSync as readFileSync7, existsSync as existsSync3 } from "fs";
+import path43 from "path";
 var COPYLEFT_LICENSES = /* @__PURE__ */ new Set([
   "GPL-2.0",
   "GPL-2.0-only",
@@ -62798,21 +63439,21 @@ function checkLicenseWarning(name, version2, license) {
 }
 function readJson(filePath) {
   try {
-    return JSON.parse(readFileSync6(filePath, "utf-8"));
+    return JSON.parse(readFileSync7(filePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function readLines(filePath) {
   try {
-    return readFileSync6(filePath, "utf-8").split("\n");
+    return readFileSync7(filePath, "utf-8").split("\n");
   } catch {
     return [];
   }
 }
 function parseNpm(root, includeDev, includeTransitive) {
-  const pkgPath = path42.join(root, "package.json");
-  const lockPath = path42.join(root, "package-lock.json");
+  const pkgPath = path43.join(root, "package.json");
+  const lockPath = path43.join(root, "package-lock.json");
   const pkg = readJson(pkgPath);
   if (!pkg) return [];
   const deps = pkg.dependencies ?? {};
@@ -62852,8 +63493,8 @@ function parseNpm(root, includeDev, includeTransitive) {
   return components;
 }
 function parseComposer(root, includeDev, includeTransitive) {
-  const lockPath = path42.join(root, "composer.lock");
-  const manifestPath = path42.join(root, "composer.json");
+  const lockPath = path43.join(root, "composer.lock");
+  const manifestPath = path43.join(root, "composer.json");
   const manifest = readJson(manifestPath);
   const directNames = /* @__PURE__ */ new Set();
   if (manifest) {
@@ -62896,8 +63537,8 @@ function parseComposer(root, includeDev, includeTransitive) {
 }
 function parsePip(root, includeDev, includeTransitive) {
   const components = [];
-  const reqPath = path42.join(root, "requirements.txt");
-  if (existsSync2(reqPath)) {
+  const reqPath = path43.join(root, "requirements.txt");
+  if (existsSync3(reqPath)) {
     for (const line of readLines(reqPath)) {
       const trimmed = line.trim();
       if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("-")) continue;
@@ -62912,9 +63553,9 @@ function parsePip(root, includeDev, includeTransitive) {
       }
     }
   }
-  const poetryLock = path42.join(root, "poetry.lock");
-  if (existsSync2(poetryLock) && includeTransitive) {
-    const content = readFileSync6(poetryLock, "utf-8");
+  const poetryLock = path43.join(root, "poetry.lock");
+  if (existsSync3(poetryLock) && includeTransitive) {
+    const content = readFileSync7(poetryLock, "utf-8");
     const directNames = new Set(components.map((c) => c.name.toLowerCase()));
     let currentName = "";
     let currentVersion = "";
@@ -62943,8 +63584,8 @@ function parsePip(root, includeDev, includeTransitive) {
   return components;
 }
 function parseGo(root, _includeDev, includeTransitive) {
-  const modPath = path42.join(root, "go.mod");
-  if (!existsSync2(modPath)) return [];
+  const modPath = path43.join(root, "go.mod");
+  if (!existsSync3(modPath)) return [];
   const components = [];
   const directNames = /* @__PURE__ */ new Set();
   let inRequire = false;
@@ -62976,10 +63617,10 @@ function parseGo(root, _includeDev, includeTransitive) {
   return components;
 }
 function parseCargo(root, _includeDev, includeTransitive) {
-  const lockPath = path42.join(root, "Cargo.lock");
-  if (!existsSync2(lockPath)) {
-    const tomlPath = path42.join(root, "Cargo.toml");
-    if (!existsSync2(tomlPath)) return [];
+  const lockPath = path43.join(root, "Cargo.lock");
+  if (!existsSync3(lockPath)) {
+    const tomlPath = path43.join(root, "Cargo.toml");
+    if (!existsSync3(tomlPath)) return [];
     const components2 = [];
     let inDeps = false;
     for (const line of readLines(tomlPath)) {
@@ -63043,8 +63684,8 @@ function parseCargo(root, _includeDev, includeTransitive) {
     });
   }
   if (!includeTransitive) {
-    const tomlPath = path42.join(root, "Cargo.toml");
-    if (existsSync2(tomlPath)) {
+    const tomlPath = path43.join(root, "Cargo.toml");
+    if (existsSync3(tomlPath)) {
       const directNames = /* @__PURE__ */ new Set();
       let inDeps = false;
       for (const line of readLines(tomlPath)) {
@@ -63068,8 +63709,8 @@ function parseCargo(root, _includeDev, includeTransitive) {
   return components;
 }
 function parseBundler(root, _includeDev, includeTransitive) {
-  const lockPath = path42.join(root, "Gemfile.lock");
-  if (!existsSync2(lockPath)) return [];
+  const lockPath = path43.join(root, "Gemfile.lock");
+  if (!existsSync3(lockPath)) return [];
   const components = [];
   let inSpecs = false;
   for (const line of readLines(lockPath)) {
@@ -63107,9 +63748,9 @@ function parseBundler(root, _includeDev, includeTransitive) {
   return components;
 }
 function parseMaven(root, _includeDev, _includeTransitive) {
-  const pomPath = path42.join(root, "pom.xml");
-  if (!existsSync2(pomPath)) return [];
-  const content = readFileSync6(pomPath, "utf-8");
+  const pomPath = path43.join(root, "pom.xml");
+  if (!existsSync3(pomPath)) return [];
+  const content = readFileSync7(pomPath, "utf-8");
   const components = [];
   const depRegex = /<dependency>\s*<groupId>([^<]+)<\/groupId>\s*<artifactId>([^<]+)<\/artifactId>\s*(?:<version>([^<]+)<\/version>)?/gs;
   let match;
@@ -63946,13 +64587,13 @@ function registerGitTools(server, ctx) {
 import { z as z7 } from "zod";
 
 // src/tools/refactoring/refactor.ts
-import fs37 from "fs";
-import path45 from "path";
+import fs38 from "fs";
+import path46 from "path";
 import fg5 from "fast-glob";
 
 // src/tools/refactoring/shared.ts
-import fs35 from "fs";
-import path43 from "path";
+import fs36 from "fs";
+import path44 from "path";
 var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".png",
   ".jpg",
@@ -63995,10 +64636,10 @@ var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
 ]);
 var SKIP_DIRS3 = ["node_modules", ".git", "dist", "build", "vendor", "__pycache__", ".next", ".nuxt"];
 function readLines2(filePath) {
-  return fs35.readFileSync(filePath, "utf-8").split("\n");
+  return fs36.readFileSync(filePath, "utf-8").split("\n");
 }
 function writeLines(filePath, lines) {
-  fs35.writeFileSync(filePath, lines.join("\n"), "utf-8");
+  fs36.writeFileSync(filePath, lines.join("\n"), "utf-8");
 }
 function buildRenameRegex(name) {
   const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -64024,7 +64665,7 @@ function getImportingFiles(store, fileId, projectRoot) {
       seen.add(importFileId);
       const file = store.getFileById(importFileId);
       if (file) {
-        importingFiles.push({ filePath: path43.resolve(projectRoot, file.path), fileId: importFileId });
+        importingFiles.push({ filePath: path44.resolve(projectRoot, file.path), fileId: importFileId });
       }
     }
   }
@@ -64216,8 +64857,8 @@ function getIndent(line) {
 }
 
 // src/tools/refactoring/non-code-scanner.ts
-import fs36 from "fs";
-import path44 from "path";
+import fs37 from "fs";
+import path45 from "path";
 import fg4 from "fast-glob";
 var NON_CODE_PATTERNS = [
   "**/*.yaml",
@@ -64260,14 +64901,14 @@ function scanNonCodeFiles(projectRoot, oldName, newName) {
   } catch {
     return mentions;
   }
-  files = files.filter((f) => !SKIP_FILES.has(path44.basename(f)));
+  files = files.filter((f) => !SKIP_FILES.has(path45.basename(f)));
   for (const relPath of files) {
-    const absPath = path44.resolve(projectRoot, relPath);
+    const absPath = path45.resolve(projectRoot, relPath);
     let content;
     try {
-      const stat = fs36.statSync(absPath);
+      const stat = fs37.statSync(absPath);
       if (stat.size > 1e6) continue;
-      content = fs36.readFileSync(absPath, "utf-8");
+      content = fs37.readFileSync(absPath, "utf-8");
     } catch {
       continue;
     }
@@ -64322,7 +64963,7 @@ function applyRename(store, projectRoot, symbolId, newName, dryRun = false) {
     result.error = `File not found for symbol ${symbolId}`;
     return result;
   }
-  const definitionFilePath = path45.resolve(projectRoot, symbolFile.path);
+  const definitionFilePath = path46.resolve(projectRoot, symbolFile.path);
   const importingFiles = getImportingFiles(store, symbol.file_id, projectRoot);
   const allFiles = [
     { filePath: definitionFilePath, fileId: symbol.file_id },
@@ -64331,7 +64972,7 @@ function applyRename(store, projectRoot, symbolId, newName, dryRun = false) {
   const regex = buildRenameRegex(oldName);
   const modifiedFiles = /* @__PURE__ */ new Set();
   for (const { filePath } of allFiles) {
-    if (!fs37.existsSync(filePath)) {
+    if (!fs38.existsSync(filePath)) {
       result.warnings.push(`File not found on disk: ${filePath}`);
       continue;
     }
@@ -64344,7 +64985,7 @@ function applyRename(store, projectRoot, symbolId, newName, dryRun = false) {
         regex.lastIndex = 0;
         if (newLine !== line) {
           result.edits.push({
-            file: path45.relative(projectRoot, filePath),
+            file: path46.relative(projectRoot, filePath),
             original_line: i + 1,
             original_text: line.trimStart(),
             new_text: newLine.trimStart()
@@ -64359,7 +65000,7 @@ function applyRename(store, projectRoot, symbolId, newName, dryRun = false) {
       if (!dryRun) {
         writeLines(filePath, lines);
       }
-      modifiedFiles.add(path45.relative(projectRoot, filePath));
+      modifiedFiles.add(path46.relative(projectRoot, filePath));
     }
   }
   result.success = true;
@@ -64420,8 +65061,8 @@ function removeDeadCode(store, projectRoot, symbolId, dryRun = false) {
     result.error = `Symbol "${symbol.name}" has no line range \u2014 cannot remove`;
     return result;
   }
-  const filePath = path45.resolve(projectRoot, symbolFile.path);
-  if (!fs37.existsSync(filePath)) {
+  const filePath = path46.resolve(projectRoot, symbolFile.path);
+  if (!fs38.existsSync(filePath)) {
     result.error = `File not found on disk: ${filePath}`;
     return result;
   }
@@ -64473,7 +65114,7 @@ function removeDeadCode(store, projectRoot, symbolId, dryRun = false) {
     const importers = getImportingFiles(store, symbol.file_id, projectRoot);
     if (importers.length > 0) {
       result.warnings.push(
-        `Removed the last exported symbol from ${symbolFile.path}. ${importers.length} file(s) still import from it \u2014 review for unused imports: ` + importers.map((f) => path45.relative(projectRoot, f.filePath)).join(", ")
+        `Removed the last exported symbol from ${symbolFile.path}. ${importers.length} file(s) still import from it \u2014 review for unused imports: ` + importers.map((f) => path46.relative(projectRoot, f.filePath)).join(", ")
       );
     }
   }
@@ -64489,8 +65130,8 @@ function extractFunction(store, projectRoot, filePath, startLine, endLine, funct
     files_modified: [],
     warnings: []
   };
-  const absPath = path45.resolve(projectRoot, filePath);
-  if (!fs37.existsSync(absPath)) {
+  const absPath = path46.resolve(projectRoot, filePath);
+  if (!fs38.existsSync(absPath)) {
     result.error = `File not found: ${filePath}`;
     return result;
   }
@@ -64499,7 +65140,7 @@ function extractFunction(store, projectRoot, filePath, startLine, endLine, funct
     result.error = `Invalid line range ${startLine}-${endLine} (file has ${lines.length} lines)`;
     return result;
   }
-  const ext = path45.extname(filePath).toLowerCase();
+  const ext = path46.extname(filePath).toLowerCase();
   const lang = detectLanguage2(ext);
   const extractedLines = lines.slice(startLine - 1, endLine);
   const extractedText = extractedLines.join("\n");
@@ -64637,7 +65278,7 @@ function applyCodemod(projectRoot, pattern, replacement, filePattern, options) {
     result.error = `Invalid file pattern: ${e.message}`;
     return result;
   }
-  files = files.filter((f) => !BINARY_EXTENSIONS.has(path45.extname(f).toLowerCase()));
+  files = files.filter((f) => !BINARY_EXTENSIONS.has(path46.extname(f).toLowerCase()));
   if (files.length === 0) {
     result.error = `No files matched pattern: ${filePattern}`;
     return result;
@@ -64645,11 +65286,11 @@ function applyCodemod(projectRoot, pattern, replacement, filePattern, options) {
   const allMatches = [];
   const filesWithMatches = /* @__PURE__ */ new Set();
   for (const relPath of files) {
-    const absPath = path45.resolve(projectRoot, relPath);
-    if (!fs37.existsSync(absPath)) continue;
+    const absPath = path46.resolve(projectRoot, relPath);
+    if (!fs38.existsSync(absPath)) continue;
     let content;
     try {
-      content = fs37.readFileSync(absPath, "utf-8");
+      content = fs38.readFileSync(absPath, "utf-8");
     } catch {
       result.warnings.push(`Could not read: ${relPath}`);
       continue;
@@ -64731,14 +65372,14 @@ function applyCodemod(projectRoot, pattern, replacement, filePattern, options) {
     return result;
   }
   for (const relPath of filesWithMatches) {
-    const absPath = path45.resolve(projectRoot, relPath);
+    const absPath = path46.resolve(projectRoot, relPath);
     try {
-      const content = fs37.readFileSync(absPath, "utf-8");
+      const content = fs38.readFileSync(absPath, "utf-8");
       const flags = options.multiline ? "gms" : "gm";
       const freshRegex = new RegExp(pattern, flags);
       const newContent = content.replace(freshRegex, replacement);
       if (newContent !== content) {
-        fs37.writeFileSync(absPath, newContent, "utf-8");
+        fs38.writeFileSync(absPath, newContent, "utf-8");
         result.files_modified.push(relPath);
       }
     } catch (e) {
@@ -64751,12 +65392,12 @@ function applyCodemod(projectRoot, pattern, replacement, filePattern, options) {
 }
 
 // src/tools/refactoring/move.ts
-import fs39 from "fs";
-import path47 from "path";
+import fs40 from "fs";
+import path48 from "path";
 
 // src/tools/refactoring/import-rewriter.ts
-import fs38 from "fs";
-import path46 from "path";
+import fs39 from "fs";
+import path47 from "path";
 var STRIP_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"]);
 var IMPORT_PATTERNS = [
   // import ... from 'specifier'
@@ -64776,8 +65417,8 @@ function computeNewImportSpecifier(importingFilePath, oldSpecifier, newTargetAbs
       const oldSuffix = oldSpecifier.slice(aliasPrefix.length);
       const resolved = resolver.resolve(aliasPrefix, importingFilePath);
       if (resolved) {
-        const aliasRoot = path46.dirname(resolved);
-        const newRelToAlias = path46.relative(aliasRoot, newTargetAbsPath);
+        const aliasRoot = path47.dirname(resolved);
+        const newRelToAlias = path47.relative(aliasRoot, newTargetAbsPath);
         if (!newRelToAlias.startsWith("..")) {
           const newSpecifier = aliasPrefix + "/" + stripExtension(newRelToAlias);
           const check = resolver.resolve(newSpecifier, importingFilePath);
@@ -64791,8 +65432,8 @@ function computeNewImportSpecifier(importingFilePath, oldSpecifier, newTargetAbs
   return computeRelativeSpecifier(importingFilePath, newTargetAbsPath);
 }
 function computeRelativeSpecifier(fromFile, toFile) {
-  const fromDir = path46.dirname(fromFile);
-  let rel = path46.relative(fromDir, toFile);
+  const fromDir = path47.dirname(fromFile);
+  let rel = path47.relative(fromDir, toFile);
   rel = stripExtension(rel);
   if (rel.endsWith("/index") || rel === "index") {
     rel = rel === "index" ? "." : rel.slice(0, -6);
@@ -64803,22 +65444,22 @@ function computeRelativeSpecifier(fromFile, toFile) {
   return rel.replace(/\\/g, "/");
 }
 function stripExtension(filePath) {
-  const ext = path46.extname(filePath);
+  const ext = path47.extname(filePath);
   if (STRIP_EXTENSIONS.has(ext)) {
     return filePath.slice(0, -ext.length);
   }
   return filePath;
 }
 function normalizePath(p) {
-  return path46.resolve(p).replace(/\\/g, "/");
+  return path47.resolve(p).replace(/\\/g, "/");
 }
 function rewriteImportSpecifiers(filePath, projectRoot, oldSpecifier, newSpecifier, dryRun) {
   const edits = [];
-  if (!fs38.existsSync(filePath)) {
+  if (!fs39.existsSync(filePath)) {
     return { edits, lines: [] };
   }
   const lines = readLines2(filePath);
-  const relPath = path46.relative(projectRoot, filePath);
+  const relPath = path47.relative(projectRoot, filePath);
   let modified = false;
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
@@ -64850,7 +65491,7 @@ function rewriteImportSpecifiers(filePath, projectRoot, oldSpecifier, newSpecifi
   return { edits, lines };
 }
 function findImportSpecifier(sourceFilePath, targetAbsPath, projectRoot, resolver) {
-  if (!fs38.existsSync(sourceFilePath)) return void 0;
+  if (!fs39.existsSync(sourceFilePath)) return void 0;
   const lines = readLines2(sourceFilePath);
   const fullText = lines.join("\n");
   for (const pattern of IMPORT_PATTERNS) {
@@ -64864,11 +65505,11 @@ function findImportSpecifier(sourceFilePath, targetAbsPath, projectRoot, resolve
         resolvedPath = resolver.resolve(specifier, sourceFilePath);
       }
       if (!resolvedPath && (specifier.startsWith(".") || specifier.startsWith("/"))) {
-        const fromDir = path46.dirname(sourceFilePath);
-        const candidate = path46.resolve(fromDir, specifier);
+        const fromDir = path47.dirname(sourceFilePath);
+        const candidate = path47.resolve(fromDir, specifier);
         for (const ext of ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.js"]) {
           const full2 = candidate + ext;
-          if (fs38.existsSync(full2)) {
+          if (fs39.existsSync(full2)) {
             resolvedPath = full2;
             break;
           }
@@ -64932,13 +65573,13 @@ function moveSymbol(store, projectRoot, params, resolver) {
     result.error = `Source file not found for symbol ${params.symbol_id}`;
     return result;
   }
-  const sourceAbsPath = path47.resolve(projectRoot, sourceFile.path);
-  const targetAbsPath = path47.resolve(projectRoot, params.target_file);
-  if (!fs39.existsSync(sourceAbsPath)) {
+  const sourceAbsPath = path48.resolve(projectRoot, sourceFile.path);
+  const targetAbsPath = path48.resolve(projectRoot, params.target_file);
+  if (!fs40.existsSync(sourceAbsPath)) {
     result.error = `Source file not found on disk: ${sourceFile.path}`;
     return result;
   }
-  if (fs39.existsSync(targetAbsPath)) {
+  if (fs40.existsSync(targetAbsPath)) {
     const targetFile = store.getFile(params.target_file);
     if (targetFile) {
       const targetSymbols = store.getSymbolsByFile(targetFile.id);
@@ -64965,7 +65606,7 @@ function moveSymbol(store, projectRoot, params, resolver) {
   const meta = symbol.metadata ? typeof symbol.metadata === "string" ? JSON.parse(symbol.metadata) : symbol.metadata : {};
   const isExported = !!meta?.exported;
   let targetLines;
-  const targetExists = fs39.existsSync(targetAbsPath);
+  const targetExists = fs40.existsSync(targetAbsPath);
   if (targetExists) {
     targetLines = readLines2(targetAbsPath);
   } else {
@@ -65011,7 +65652,7 @@ function moveSymbol(store, projectRoot, params, resolver) {
   if (isExported) {
     const importingFiles = getImportingFiles(store, symbol.file_id, projectRoot);
     for (const { filePath: importerAbsPath } of importingFiles) {
-      if (!fs39.existsSync(importerAbsPath)) continue;
+      if (!fs40.existsSync(importerAbsPath)) continue;
       const importerLines = readLines2(importerAbsPath);
       const importerContent = importerLines.join("\n");
       const nameRegex = new RegExp(`\\b${escapeRegex3(symbol.name)}\\b`);
@@ -65027,7 +65668,7 @@ function moveSymbol(store, projectRoot, params, resolver) {
       );
       result.edits.push(...importEdits);
       if (importEdits.length > 0) {
-        result.files_modified.push(path47.relative(projectRoot, importerAbsPath));
+        result.files_modified.push(path48.relative(projectRoot, importerAbsPath));
       }
     }
     const remainingExports = fileSymbols.filter((s) => {
@@ -65055,9 +65696,9 @@ function moveSymbol(store, projectRoot, params, resolver) {
       tLines.splice(insertIdx, 0, ...insertLines);
       writeLines(targetAbsPath, tLines);
     } else {
-      const targetDir = path47.dirname(targetAbsPath);
-      if (!fs39.existsSync(targetDir)) {
-        fs39.mkdirSync(targetDir, { recursive: true });
+      const targetDir = path48.dirname(targetAbsPath);
+      if (!fs40.existsSync(targetDir)) {
+        fs40.mkdirSync(targetDir, { recursive: true });
       }
       writeLines(targetAbsPath, insertLines);
     }
@@ -65077,13 +65718,13 @@ function moveFile(store, projectRoot, params, resolver) {
     files_modified: [],
     warnings: []
   };
-  const sourceAbsPath = path47.resolve(projectRoot, params.source_file);
-  const targetAbsPath = path47.resolve(projectRoot, params.new_path);
-  if (!fs39.existsSync(sourceAbsPath)) {
+  const sourceAbsPath = path48.resolve(projectRoot, params.source_file);
+  const targetAbsPath = path48.resolve(projectRoot, params.new_path);
+  if (!fs40.existsSync(sourceAbsPath)) {
     result.error = `Source file not found: ${params.source_file}`;
     return result;
   }
-  if (fs39.existsSync(targetAbsPath)) {
+  if (fs40.existsSync(targetAbsPath)) {
     result.error = `Target path already exists: ${params.new_path}`;
     return result;
   }
@@ -65094,7 +65735,7 @@ function moveFile(store, projectRoot, params, resolver) {
   }
   const importingFiles = getImportingFiles(store, fileRow.id, projectRoot);
   for (const { filePath: importerAbsPath } of importingFiles) {
-    if (!fs39.existsSync(importerAbsPath)) continue;
+    if (!fs40.existsSync(importerAbsPath)) continue;
     const edits = rewriteImportForMovedTarget(
       importerAbsPath,
       sourceAbsPath,
@@ -65105,7 +65746,7 @@ function moveFile(store, projectRoot, params, resolver) {
     );
     result.edits.push(...edits);
     if (edits.length > 0) {
-      result.files_modified.push(path47.relative(projectRoot, importerAbsPath));
+      result.files_modified.push(path48.relative(projectRoot, importerAbsPath));
     }
   }
   const selfEdits = rewriteOwnImports(
@@ -65124,14 +65765,14 @@ function moveFile(store, projectRoot, params, resolver) {
     new_text: `(moved to ${params.new_path})`
   });
   if (!dryRun) {
-    const targetDir = path47.dirname(targetAbsPath);
-    if (!fs39.existsSync(targetDir)) {
-      fs39.mkdirSync(targetDir, { recursive: true });
+    const targetDir = path48.dirname(targetAbsPath);
+    if (!fs40.existsSync(targetDir)) {
+      fs40.mkdirSync(targetDir, { recursive: true });
     }
     if (selfEdits.length > 0) {
-      fs39.renameSync(sourceAbsPath, targetAbsPath);
+      fs40.renameSync(sourceAbsPath, targetAbsPath);
     } else {
-      fs39.renameSync(sourceAbsPath, targetAbsPath);
+      fs40.renameSync(sourceAbsPath, targetAbsPath);
     }
   }
   result.files_modified.push(params.source_file, params.new_path);
@@ -65141,9 +65782,9 @@ function moveFile(store, projectRoot, params, resolver) {
 function rewriteOwnImports(currentAbsPath, newAbsPath, projectRoot, store, dryRun, resolver) {
   const lines = readLines2(currentAbsPath);
   const edits = [];
-  const relPath = path47.relative(projectRoot, currentAbsPath);
-  const currentDir = path47.dirname(currentAbsPath);
-  const newDir = path47.dirname(newAbsPath);
+  const relPath = path48.relative(projectRoot, currentAbsPath);
+  const currentDir = path48.dirname(currentAbsPath);
+  const newDir = path48.dirname(newAbsPath);
   if (currentDir === newDir) return edits;
   let modified = false;
   for (let i = 0; i < lines.length; i++) {
@@ -65181,11 +65822,11 @@ function extractSpecifierFromLine(line) {
   return void 0;
 }
 function resolveRelativeSpecifier(fromDir, specifier) {
-  const candidate = path47.resolve(fromDir, specifier);
+  const candidate = path48.resolve(fromDir, specifier);
   const extensions = ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.js"];
   for (const ext of extensions) {
     const full2 = candidate + ext;
-    if (fs39.existsSync(full2)) {
+    if (fs40.existsSync(full2)) {
       return full2;
     }
   }
@@ -65194,8 +65835,8 @@ function resolveRelativeSpecifier(fromDir, specifier) {
 function rewriteSymbolImport(importerAbsPath, sourceAbsPath, targetAbsPath, symbolName, projectRoot, dryRun, resolver) {
   const edits = [];
   const lines = readLines2(importerAbsPath);
-  const relPath = path47.relative(projectRoot, importerAbsPath);
-  const importerDir = path47.dirname(importerAbsPath);
+  const relPath = path48.relative(projectRoot, importerAbsPath);
+  const importerDir = path48.dirname(importerAbsPath);
   let modified = false;
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
@@ -65203,8 +65844,8 @@ function rewriteSymbolImport(importerAbsPath, sourceAbsPath, targetAbsPath, symb
     if (!specifier) continue;
     const resolvedAbs = resolver ? resolver.resolve(specifier, importerAbsPath) : resolveRelativeSpecifier(importerDir, specifier);
     if (!resolvedAbs) continue;
-    const normalizedResolved = path47.resolve(resolvedAbs).replace(/\\/g, "/");
-    const normalizedSource = path47.resolve(sourceAbsPath).replace(/\\/g, "/");
+    const normalizedResolved = path48.resolve(resolvedAbs).replace(/\\/g, "/");
+    const normalizedSource = path48.resolve(sourceAbsPath).replace(/\\/g, "/");
     if (normalizedResolved !== normalizedSource) continue;
     const nameRegex = new RegExp(`\\b${escapeRegex3(symbolName)}\\b`);
     if (!nameRegex.test(line)) continue;
@@ -65281,8 +65922,8 @@ function escapeRegex3(str2) {
 }
 
 // src/tools/refactoring/change-signature.ts
-import fs40 from "fs";
-import path48 from "path";
+import fs41 from "fs";
+import path49 from "path";
 function changeSignature(store, projectRoot, symbolId, changes, dryRun = true) {
   const result = {
     success: false,
@@ -65314,12 +65955,12 @@ function changeSignature(store, projectRoot, symbolId, changes, dryRun = true) {
     result.error = `File not found for symbol ${symbolId}`;
     return result;
   }
-  const filePath = path48.resolve(projectRoot, symbolFile.path);
-  if (!fs40.existsSync(filePath)) {
+  const filePath = path49.resolve(projectRoot, symbolFile.path);
+  if (!fs41.existsSync(filePath)) {
     result.error = `File not found on disk: ${symbolFile.path}`;
     return result;
   }
-  const ext = path48.extname(symbolFile.path).toLowerCase();
+  const ext = path49.extname(symbolFile.path).toLowerCase();
   const lang = detectLanguage2(ext);
   const lines = readLines2(filePath);
   const defStartIdx = symbol.line_start - 1;
@@ -65573,8 +66214,8 @@ function updateCallSites(store, projectRoot, symbol, oldParams, newParams, chang
   for (const fileId of fileIds) {
     const file = store.getFileById(fileId);
     if (!file) continue;
-    const filePath = path48.resolve(projectRoot, file.path);
-    if (!fs40.existsSync(filePath)) continue;
+    const filePath = path49.resolve(projectRoot, file.path);
+    if (!fs41.existsSync(filePath)) continue;
     const lines = readLines2(filePath);
     let fileModified = false;
     const callPattern = new RegExp(`\\b${escapeRegex4(symbol.name)}\\s*\\(`, "g");
@@ -66352,8 +66993,8 @@ function getContractVersions(topoStore, opts) {
 }
 
 // src/tools/advanced/claude-sessions.ts
-import fs41 from "fs";
-import path49 from "path";
+import fs42 from "fs";
+import path50 from "path";
 import os6 from "os";
 import { err as err11, ok as ok9 } from "neverthrow";
 init_logger();
@@ -66366,9 +67007,9 @@ function decodeClaudeProjectName(name) {
   while (i < tokens.length) {
     let entries = [];
     try {
-      entries = fs41.readdirSync(current);
+      entries = fs42.readdirSync(current);
     } catch {
-      return current === "/" ? "/" + tokens.slice(i).join("/") : path49.join(current, tokens.slice(i).join("/"));
+      return current === "/" ? "/" + tokens.slice(i).join("/") : path50.join(current, tokens.slice(i).join("/"));
     }
     const entrySet = new Set(entries);
     let matched = -1;
@@ -66376,12 +67017,12 @@ function decodeClaudeProjectName(name) {
       const candidate = tokens.slice(i, j3).join("-");
       if (entrySet.has(candidate)) {
         matched = j3;
-        current = current === "/" ? "/" + candidate : path49.join(current, candidate);
+        current = current === "/" ? "/" + candidate : path50.join(current, candidate);
         break;
       }
     }
     if (matched === -1) {
-      return current === "/" ? "/" + tokens.slice(i).join("/") : path49.join(current, tokens.slice(i).join("/"));
+      return current === "/" ? "/" + tokens.slice(i).join("/") : path50.join(current, tokens.slice(i).join("/"));
     }
     i = matched;
   }
@@ -66389,7 +67030,7 @@ function decodeClaudeProjectName(name) {
 }
 function countSessionFiles(dir) {
   try {
-    const entries = fs41.readdirSync(dir, { withFileTypes: true });
+    const entries = fs42.readdirSync(dir, { withFileTypes: true });
     return entries.filter((e) => e.isFile() && (e.name.endsWith(".jsonl") || e.name.endsWith(".json"))).length;
   } catch {
     return 0;
@@ -66397,19 +67038,19 @@ function countSessionFiles(dir) {
 }
 function dirMtime(dir) {
   try {
-    return fs41.statSync(dir).mtimeMs;
+    return fs42.statSync(dir).mtimeMs;
   } catch {
     return null;
   }
 }
 function discoverClaudeSessions(opts = {}) {
-  const scanRoot = opts.scanRoot ?? path49.join(os6.homedir(), ".claude", "projects");
-  if (!fs41.existsSync(scanRoot)) {
+  const scanRoot = opts.scanRoot ?? path50.join(os6.homedir(), ".claude", "projects");
+  if (!fs42.existsSync(scanRoot)) {
     return err11(validationError(`Claude projects root not found: ${scanRoot}`));
   }
   let entries;
   try {
-    entries = fs41.readdirSync(scanRoot, { withFileTypes: true });
+    entries = fs42.readdirSync(scanRoot, { withFileTypes: true });
   } catch (e) {
     return err11(validationError(`Failed to read ${scanRoot}: ${e.message}`));
   }
@@ -66421,17 +67062,17 @@ function discoverClaudeSessions(opts = {}) {
     if (opts.excludePrefix && decoded === opts.excludePrefix) continue;
     let exists = false;
     try {
-      exists = fs41.statSync(decoded).isDirectory();
+      exists = fs42.statSync(decoded).isDirectory();
     } catch {
       exists = false;
     }
     if (opts.onlyExisting && !exists) continue;
-    const projectStateDir = path49.join(scanRoot, entry.name);
+    const projectStateDir = path50.join(scanRoot, entry.name);
     sessions.push({
       projectPath: decoded,
       exists,
       sessionFiles: countSessionFiles(projectStateDir),
-      hasMemory: fs41.existsSync(path49.join(projectStateDir, "memory")),
+      hasMemory: fs42.existsSync(path50.join(projectStateDir, "memory")),
       lastActiveMs: dirMtime(projectStateDir)
     });
   }
@@ -66456,7 +67097,7 @@ function discoverAndRegisterSubprojects(topoStore, opts = {}) {
       const totalEndpoints = services.reduce((sum, s) => sum + s.endpoints, 0);
       added.push({
         repo: session.projectPath,
-        name: path49.basename(session.projectPath),
+        name: path50.basename(session.projectPath),
         services: services.length,
         endpoints: totalEndpoints
       });
@@ -68101,16 +68742,16 @@ function findShortestPath(store, startNodeId, endNodeId, maxDepth) {
         parent.set(nodeId, { from, edgeType: edge.edge_type_name });
         nextFrontier.push(nodeId);
         if (nodeId === endNodeId) {
-          const path66 = [endNodeId];
+          const path67 = [endNodeId];
           const edgeTypes = [];
           let cur = endNodeId;
           while (cur !== startNodeId) {
             const p = parent.get(cur);
-            path66.unshift(p.from);
+            path67.unshift(p.from);
             edgeTypes.unshift(p.edgeType);
             cur = p.from;
           }
-          return { path: path66, edgeTypes };
+          return { path: path67, edgeTypes };
         }
       }
     }
@@ -68304,8 +68945,8 @@ function graphQuery(store, query, options = {}) {
 }
 
 // src/tools/analysis/dataflow.ts
-import fs42 from "fs";
-import path50 from "path";
+import fs43 from "fs";
+import path51 from "path";
 function getDataflow(store, projectRoot, opts) {
   const symbol = opts.symbolId ? store.getSymbolBySymbolId(opts.symbolId) : opts.fqn ? store.getSymbolByFqn(opts.fqn) : void 0;
   if (!symbol) {
@@ -68316,10 +68957,10 @@ function getDataflow(store, projectRoot, opts) {
   }
   const file = store.getFileById(symbol.file_id);
   if (!file) return err(notFound(`file for ${symbol.symbol_id}`));
-  const absPath = path50.resolve(projectRoot, file.path);
+  const absPath = path51.resolve(projectRoot, file.path);
   let content;
   try {
-    content = fs42.readFileSync(absPath, "utf-8");
+    content = fs43.readFileSync(absPath, "utf-8");
   } catch {
     return err(validationError(`Cannot read file: ${file.path}`));
   }
@@ -68472,8 +69113,8 @@ function escapeRegex5(str2) {
 }
 
 // src/tools/analysis/visualize.ts
-import fs43 from "fs";
-import path51 from "path";
+import fs44 from "fs";
+import path52 from "path";
 
 // src/db/repositories/file-repository.ts
 var FileRepository = class {
@@ -68499,14 +69140,14 @@ var FileRepository = class {
   }
   db;
   _stmts;
-  insertFile(path66, language, contentHash, byteLength, workspace, mtimeMs, createNode) {
-    const result = this._stmts.insertFile.run(path66, language, contentHash, byteLength, workspace, mtimeMs);
+  insertFile(path67, language, contentHash, byteLength, workspace, mtimeMs, createNode) {
+    const result = this._stmts.insertFile.run(path67, language, contentHash, byteLength, workspace, mtimeMs);
     const fileId = Number(result.lastInsertRowid);
     createNode("file", fileId);
     return fileId;
   }
-  getFile(path66) {
-    return this._stmts.getFile.get(path66);
+  getFile(path67) {
+    return this._stmts.getFile.get(path67);
   }
   getFileById(id) {
     return this._stmts.getFileById.get(id);
@@ -69364,9 +70005,9 @@ var Store = class {
   domain;
   analytics;
   // --- Files (delegates to FileRepository) ---
-  insertFile(path66, language, contentHash, byteLength, workspace, mtimeMs) {
+  insertFile(path67, language, contentHash, byteLength, workspace, mtimeMs) {
     return this.files.insertFile(
-      path66,
+      path67,
       language,
       contentHash,
       byteLength,
@@ -69375,8 +70016,8 @@ var Store = class {
       (nodeType, refId) => this.graph.createNode(nodeType, refId)
     );
   }
-  getFile(path66) {
-    return this.files.getFile(path66);
+  getFile(path67) {
+    return this.files.getFile(path67);
   }
   getFileById(id) {
     return this.files.getFileById(id);
@@ -69756,14 +70397,14 @@ function buildSubprojectGraph(mainStore, opts) {
     opts.granularity ?? "file",
     opts.hideIsolated === true
   );
-  const mainPrefix = allRepos.find((r) => r.repo_root === projectRoot)?.name ?? path51.basename(projectRoot);
+  const mainPrefix = allRepos.find((r) => r.repo_root === projectRoot)?.name ?? path52.basename(projectRoot);
   for (const n of mainResult.nodes) {
     n.repo = mainPrefix;
     allNodes.push(n);
   }
   allEdges.push(...mainResult.edges);
   for (const repo of repos) {
-    if (!repo.db_path || !fs43.existsSync(repo.db_path)) continue;
+    if (!repo.db_path || !fs44.existsSync(repo.db_path)) continue;
     let db = null;
     try {
       db = initializeDatabase(repo.db_path);
@@ -69892,7 +70533,7 @@ function buildFileGraph2(store, seedFiles, depth, edgeFilter, hideIsolated, opts
     if (isExcludedPath(file.path)) continue;
     vizNodeMap.set(file.path, {
       id: file.path,
-      label: path51.basename(file.path),
+      label: path52.basename(file.path),
       type: "file",
       language: file.language,
       framework_role: file.framework_role,
@@ -71161,8 +71802,8 @@ function visualizeGraph(store, opts) {
   }
   const layout = opts.layout ?? "force";
   const html = generateHtml(nodes, edges, communities, layout, { highlightDepth: opts.highlightDepth });
-  const outputPath = opts.output ?? path51.join(process.env.TMPDIR ?? "/tmp", "trace-mcp-graph.html");
-  fs43.writeFileSync(outputPath, html, "utf-8");
+  const outputPath = opts.output ?? path52.join(process.env.TMPDIR ?? "/tmp", "trace-mcp-graph.html");
+  fs44.writeFileSync(outputPath, html, "utf-8");
   return ok({
     outputPath,
     nodes: nodes.length,
@@ -71212,8 +71853,8 @@ function getDependencyDiagram(store, opts) {
 }
 
 // src/tools/analysis/visualize-subproject.ts
-import fs44 from "fs";
-import path52 from "path";
+import fs45 from "fs";
+import path53 from "path";
 function buildSubprojectData(topoStore) {
   const services = topoStore.getAllServices();
   const allEndpoints = topoStore.getAllEndpoints();
@@ -71471,8 +72112,8 @@ function visualizeSubprojectTopology(topoStore, opts) {
   }
   const layout = opts?.layout ?? "force";
   const html = generateSubprojectHtml(nodes, edges, layout);
-  const outputPath = opts?.output ?? path52.join(process.env.TMPDIR ?? "/tmp", "trace-mcp-subproject-topology.html");
-  fs44.writeFileSync(outputPath, html, "utf-8");
+  const outputPath = opts?.output ?? path53.join(process.env.TMPDIR ?? "/tmp", "trace-mcp-subproject-topology.html");
+  fs45.writeFileSync(outputPath, html, "utf-8");
   return ok({
     outputPath,
     services: nodes.length,
@@ -73453,8 +74094,8 @@ function getCommunityDetail(store, communityId) {
 }
 
 // src/tools/quality/audit-config.ts
-import fs45 from "fs";
-import path53 from "path";
+import fs46 from "fs";
+import path54 from "path";
 var CONFIG_PATTERNS = [
   "CLAUDE.md",
   ".claude/CLAUDE.md",
@@ -73482,9 +74123,9 @@ function auditConfig(store, projectRoot, options = {}) {
   const fileContents = /* @__PURE__ */ new Map();
   for (const file of configFiles) {
     const absPath = resolveConfigPath(file, projectRoot);
-    if (!fs45.existsSync(absPath)) continue;
+    if (!fs46.existsSync(absPath)) continue;
     try {
-      const content = fs45.readFileSync(absPath, "utf-8");
+      const content = fs46.readFileSync(absPath, "utf-8");
       fileContents.set(file, { content, lines: content.split("\n") });
       totalTokens += Math.ceil(content.length / 4);
     } catch {
@@ -73496,8 +74137,8 @@ function auditConfig(store, projectRoot, options = {}) {
       const pathMatches = line.match(/(?:src|lib|app|routes|tests?|components?|pages?)\/[\w/.-]+\.\w+/g);
       if (pathMatches) {
         for (const ref of pathMatches) {
-          const refPath = path53.join(projectRoot, ref);
-          if (!fs45.existsSync(refPath) && !store.getFile(ref)) {
+          const refPath = path54.join(projectRoot, ref);
+          if (!fs46.existsSync(refPath) && !store.getFile(ref)) {
             issues.push({
               file,
               line: i + 1,
@@ -73609,19 +74250,19 @@ function checkSymbol(store, name, file, line, fixSuggestions, issues) {
 function findConfigFiles(projectRoot) {
   const found = [];
   for (const pattern of CONFIG_PATTERNS) {
-    const absPath = path53.join(projectRoot, pattern);
-    if (fs45.existsSync(absPath)) found.push(pattern);
+    const absPath = path54.join(projectRoot, pattern);
+    if (fs46.existsSync(absPath)) found.push(pattern);
   }
   for (const pattern of GLOBAL_CONFIG_PATTERNS) {
     const absPath = pattern.replace("~", process.env.HOME ?? "");
-    if (fs45.existsSync(absPath)) found.push(pattern);
+    if (fs46.existsSync(absPath)) found.push(pattern);
   }
   return found;
 }
 function resolveConfigPath(file, projectRoot) {
   if (file.startsWith("~")) return file.replace("~", process.env.HOME ?? "");
-  if (path53.isAbsolute(file)) return file;
-  return path53.join(projectRoot, file);
+  if (path54.isAbsolute(file)) return file;
+  return path54.join(projectRoot, file);
 }
 function isGlobalConfig(file) {
   return file.startsWith("~") || file.includes(".claude/CLAUDE.md") || file.includes(".claw/settings.json");
@@ -73876,8 +74517,8 @@ function cfgToAscii(cfg) {
 }
 
 // src/tools/analysis/control-flow.ts
-import fs46 from "fs";
-import path54 from "path";
+import fs47 from "fs";
+import path55 from "path";
 function getControlFlow(store, projectRoot, options) {
   const { symbolId, fqn, format: format2, simplify } = options;
   let symbol = null;
@@ -73900,11 +74541,11 @@ function getControlFlow(store, projectRoot, options) {
   if (!file) {
     return err(notFound(`file for symbol`));
   }
-  const absPath = path54.isAbsolute(file.path) ? file.path : path54.join(projectRoot, file.path);
-  if (!fs46.existsSync(absPath)) {
+  const absPath = path55.isAbsolute(file.path) ? file.path : path55.join(projectRoot, file.path);
+  if (!fs47.existsSync(absPath)) {
     return err(validationError(`File not on disk: ${file.path}`));
   }
-  const content = fs46.readFileSync(absPath, "utf-8");
+  const content = fs47.readFileSync(absPath, "utf-8");
   const lines = content.split("\n");
   const startLine = symbol.line_start ?? 1;
   const endLine = symbol.line_end ?? lines.length;
@@ -73965,12 +74606,12 @@ function simplifyCFG(cfg) {
 }
 
 // src/tools/project/package-deps.ts
-import fs47 from "fs";
-import path55 from "path";
+import fs48 from "fs";
+import path56 from "path";
 function loadRegistry() {
-  if (!fs47.existsSync(REGISTRY_PATH)) return {};
+  if (!fs48.existsSync(REGISTRY_PATH)) return {};
   try {
-    const raw = JSON.parse(fs47.readFileSync(REGISTRY_PATH, "utf-8"));
+    const raw = JSON.parse(fs48.readFileSync(REGISTRY_PATH, "utf-8"));
     return raw.projects ?? raw ?? {};
   } catch {
     return {};
@@ -73978,10 +74619,10 @@ function loadRegistry() {
 }
 function readManifest(repoPath) {
   const result = { name: void 0, deps: /* @__PURE__ */ new Map(), publishes: [] };
-  const pkgJsonPath = path55.join(repoPath, "package.json");
-  if (fs47.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path56.join(repoPath, "package.json");
+  if (fs48.existsSync(pkgJsonPath)) {
     try {
-      const pkg = JSON.parse(fs47.readFileSync(pkgJsonPath, "utf-8"));
+      const pkg = JSON.parse(fs48.readFileSync(pkgJsonPath, "utf-8"));
       result.name = pkg.name;
       if (pkg.name) result.publishes.push(pkg.name);
       for (const [dep, ver] of Object.entries(pkg.dependencies ?? {})) {
@@ -73993,10 +74634,10 @@ function readManifest(repoPath) {
     } catch {
     }
   }
-  const composerPath = path55.join(repoPath, "composer.json");
-  if (fs47.existsSync(composerPath)) {
+  const composerPath = path56.join(repoPath, "composer.json");
+  if (fs48.existsSync(composerPath)) {
     try {
-      const composer = JSON.parse(fs47.readFileSync(composerPath, "utf-8"));
+      const composer = JSON.parse(fs48.readFileSync(composerPath, "utf-8"));
       if (composer.name) {
         result.name ??= composer.name;
         result.publishes.push(composer.name);
@@ -74011,10 +74652,10 @@ function readManifest(repoPath) {
     } catch {
     }
   }
-  const pyprojectPath = path55.join(repoPath, "pyproject.toml");
-  if (fs47.existsSync(pyprojectPath)) {
+  const pyprojectPath = path56.join(repoPath, "pyproject.toml");
+  if (fs48.existsSync(pyprojectPath)) {
     try {
-      const content = fs47.readFileSync(pyprojectPath, "utf-8");
+      const content = fs48.readFileSync(pyprojectPath, "utf-8");
       const nameMatch = content.match(/^name\s*=\s*"([^"]+)"/m);
       if (nameMatch) {
         result.name ??= nameMatch[1];
@@ -74039,12 +74680,12 @@ function getPackageDeps(options) {
   const publishMap = /* @__PURE__ */ new Map();
   for (const [repoPath, entry] of Object.entries(registry)) {
     const absPath = repoPath;
-    if (!fs47.existsSync(absPath)) continue;
+    if (!fs48.existsSync(absPath)) continue;
     const manifest = readManifest(absPath);
     repoManifests.set(repoPath, manifest);
     const allPublishes = [...entry.publishes ?? [], ...manifest.publishes];
     for (const p of new Set(allPublishes)) {
-      publishMap.set(p, { repo: entry.name ?? path55.basename(repoPath), repoPath });
+      publishMap.set(p, { repo: entry.name ?? path56.basename(repoPath), repoPath });
     }
   }
   const results = [];
@@ -74054,7 +74695,7 @@ function getPackageDeps(options) {
   } else if (project) {
     for (const [repoPath, manifest] of repoManifests) {
       const entry = registry[repoPath];
-      if (entry?.name === project || path55.basename(repoPath) === project) {
+      if (entry?.name === project || path56.basename(repoPath) === project) {
         for (const p of manifest.publishes) {
           targetPackages.add(p);
         }
@@ -74073,7 +74714,7 @@ function getPackageDeps(options) {
   if (direction === "dependents" || direction === "both") {
     for (const [repoPath, manifest] of repoManifests) {
       const entry = registry[repoPath];
-      const repoName = entry?.name ?? path55.basename(repoPath);
+      const repoName = entry?.name ?? path56.basename(repoPath);
       for (const targetPkg of targetPackages) {
         const dep = manifest.deps.get(targetPkg);
         if (dep) {
@@ -74092,7 +74733,7 @@ function getPackageDeps(options) {
   if (direction === "dependencies" || direction === "both") {
     for (const [repoPath, manifest] of repoManifests) {
       const entry = registry[repoPath];
-      const repoName = entry?.name ?? path55.basename(repoPath);
+      const repoName = entry?.name ?? path56.basename(repoPath);
       const isTarget = manifest.publishes.some((p) => targetPackages.has(p));
       if (!isTarget && targetPackages.size > 0) continue;
       for (const [dep, info] of manifest.deps) {
@@ -74589,8 +75230,8 @@ function evaluateQualityGates(store, projectRoot, gatesConfig, options = {}) {
 }
 
 // src/tools/quality/security-context-export.ts
-import { readFileSync as readFileSync7 } from "fs";
-import path57 from "path";
+import { readFileSync as readFileSync8 } from "fs";
+import path58 from "path";
 import { ok as ok10 } from "neverthrow";
 var CATEGORY_PATTERNS = [
   // file_read
@@ -74759,9 +75400,9 @@ function scanInlineHandler(source, toolCallIndex, filePath, store, projectRoot,
     }
     const file = sym.file_id ? store.getFileById(sym.file_id) : null;
     if (file && sym.line_start && sym.line_end) {
-      const symAbsPath = path57.resolve(projectRoot, file.path);
+      const symAbsPath = path58.resolve(projectRoot, file.path);
       try {
-        const symSource = readFileSync7(symAbsPath, "utf-8");
+        const symSource = readFileSync8(symAbsPath, "utf-8");
         const lines = symSource.split("\n");
         const symBody = lines.slice(sym.line_start - 1, sym.line_end).join("\n");
         scanSourceForSecurityCalls(symBody, file.path, sym.line_start, results);
@@ -74788,7 +75429,7 @@ function scanSourceForSecurityCalls(body, filePath, startLine, results) {
     results.push({ function: "process.env", file: filePath, line: lineOffset, category: "env_read" });
   }
 }
-var PKG_VERSION = true ? "1.22.0" : "0.0.0-dev";
+var PKG_VERSION = true ? "1.23.0" : "0.0.0-dev";
 function exportSecurityContext(store, projectRoot, opts = {}) {
   const depth = Math.min(opts.depth ?? 3, 5);
   const warnings = [];
@@ -74803,10 +75444,10 @@ function exportSecurityContext(store, projectRoot, opts = {}) {
     const fileRow = route.file_id ? store.getFileById(route.file_id) : null;
     if (!fileRow) continue;
     if (opts.scope && !fileRow.path.startsWith(opts.scope)) continue;
-    const absPath = path57.resolve(projectRoot, fileRow.path);
+    const absPath = path58.resolve(projectRoot, fileRow.path);
     let source;
     try {
-      source = readFileSync7(absPath, "utf-8");
+      source = readFileSync8(absPath, "utf-8");
     } catch {
       continue;
     }
@@ -74847,7 +75488,7 @@ function exportSecurityContext(store, projectRoot, opts = {}) {
   const sensitiveFlows = [];
   const mcpServerFiles = new Set(toolRegistrations.map((t) => t.file));
   if (mcpServerFiles.size > 0) {
-    const mcpDirs = [...new Set([...mcpServerFiles].map((f) => path57.dirname(f)))];
+    const mcpDirs = [...new Set([...mcpServerFiles].map((f) => path58.dirname(f)))];
     for (const dir of mcpDirs) {
       const taintResult = taintAnalysis(store, projectRoot, {
         scope: dir,
@@ -75110,7 +75751,7 @@ import { z as z13 } from "zod";
 
 // src/tools/ai/ai-tools.ts
 import { z as z11 } from "zod";
-import path58 from "path";
+import path59 from "path";
 function j(value) {
   return JSON.stringify(value);
 }
@@ -75126,7 +75767,7 @@ function symbolToContextItem(sym, file, projectRoot, score = 1) {
 }
 function readSourceSafe(filePath, byteStart, byteEnd, projectRoot, gitignored) {
   try {
-    const absPath = path58.resolve(projectRoot, filePath);
+    const absPath = path59.resolve(projectRoot, filePath);
     return readByteRange(absPath, byteStart, byteEnd, gitignored);
   } catch {
     return null;
@@ -75442,22 +76083,22 @@ function registerAITools(server, ctx) {
 // src/bundles.ts
 init_logger();
 import Database5 from "better-sqlite3";
-import path59 from "path";
-import fs49 from "fs";
+import path60 from "path";
+import fs50 from "fs";
 import crypto6 from "crypto";
-var BUNDLES_DIR = path59.join(TRACE_MCP_HOME, "bundles");
+var BUNDLES_DIR = path60.join(TRACE_MCP_HOME, "bundles");
 function getBundlePath(packageName, version2) {
   const safeName = packageName.replace(/[^a-zA-Z0-9._-]/g, "_");
-  return path59.join(BUNDLES_DIR, `${safeName}-${version2}.bundle.db`);
+  return path60.join(BUNDLES_DIR, `${safeName}-${version2}.bundle.db`);
 }
 function getManifestPath() {
-  return path59.join(BUNDLES_DIR, "manifest.json");
+  return path60.join(BUNDLES_DIR, "manifest.json");
 }
 function loadManifest() {
   const p = getManifestPath();
-  if (!fs49.existsSync(p)) return { bundles: [] };
+  if (!fs50.existsSync(p)) return { bundles: [] };
   try {
-    return JSON.parse(fs49.readFileSync(p, "utf-8"));
+    return JSON.parse(fs50.readFileSync(p, "utf-8"));
   } catch {
     return { bundles: [] };
   }
@@ -75467,7 +76108,7 @@ function listBundles() {
 }
 function loadBundle(packageName, version2) {
   const bundlePath = getBundlePath(packageName, version2);
-  if (!fs49.existsSync(bundlePath)) return null;
+  if (!fs50.existsSync(bundlePath)) return null;
   try {
     const db = new Database5(bundlePath, { readonly: true });
     return { package: packageName, version: version2, db };
@@ -75521,8 +76162,8 @@ function searchBundles(bundles, query, opts = {}) {
 
 // src/analytics/analytics-store.ts
 import Database6 from "better-sqlite3";
-import path60 from "path";
-var ANALYTICS_DB_PATH = path60.join(TRACE_MCP_HOME, "analytics.db");
+import path61 from "path";
+var ANALYTICS_DB_PATH = path61.join(TRACE_MCP_HOME, "analytics.db");
 var SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS sessions (
   id TEXT PRIMARY KEY,
@@ -75754,10 +76395,10 @@ var AnalyticsStore = class {
 
 // src/analytics/log-parser.ts
 init_logger();
-import fs50 from "fs";
-import path61 from "path";
+import fs51 from "fs";
+import path62 from "path";
 import os7 from "os";
-var CLAUDE_PROJECTS_DIR = path61.join(os7.homedir(), ".claude", "projects");
+var CLAUDE_PROJECTS_DIR = path62.join(os7.homedir(), ".claude", "projects");
 var CLAW_SESSIONS_DIR_NAME = ".claw/sessions";
 function parseToolName(fullName) {
   const match = fullName.match(/^mcp__([^_]+)__(.+)$/);
@@ -75832,9 +76473,9 @@ function processToolResult(item, toolResults) {
 }
 function parseSessionFile(filePath, projectPath) {
   try {
-    const content = fs50.readFileSync(filePath, "utf-8");
+    const content = fs51.readFileSync(filePath, "utf-8");
     const lines = content.split("\n").filter((l) => l.trim());
-    const sessionId = path61.basename(filePath, ".jsonl");
+    const sessionId = path62.basename(filePath, ".jsonl");
     const toolCalls = [];
     const toolResults = /* @__PURE__ */ new Map();
     let model = "";
@@ -75924,7 +76565,7 @@ function decodeDirName(dirName) {
     const seg = parts[i];
     const candidate = base + "/" + (tail ? tail + "-" + seg : seg);
     try {
-      if (fs50.statSync(candidate).isDirectory()) {
+      if (fs51.statSync(candidate).isDirectory()) {
         base = candidate;
         tail = "";
         continue;
@@ -75934,7 +76575,7 @@ function decodeDirName(dirName) {
     if (tail) {
       const slashCandidate = base + "/" + tail;
       try {
-        if (fs50.statSync(slashCandidate).isDirectory()) {
+        if (fs51.statSync(slashCandidate).isDirectory()) {
           base = slashCandidate;
           tail = seg;
           continue;
@@ -75947,20 +76588,20 @@ function decodeDirName(dirName) {
   return tail ? base + "/" + tail : base;
 }
 function listProjectDirs() {
-  if (!fs50.existsSync(CLAUDE_PROJECTS_DIR)) return [];
-  const entries = fs50.readdirSync(CLAUDE_PROJECTS_DIR, { withFileTypes: true });
+  if (!fs51.existsSync(CLAUDE_PROJECTS_DIR)) return [];
+  const entries = fs51.readdirSync(CLAUDE_PROJECTS_DIR, { withFileTypes: true });
   return entries.filter((e) => e.isDirectory()).map((e) => ({
     dirName: e.name,
     projectPath: decodeDirName(e.name)
   }));
 }
 function listSessionFiles(projectDirName) {
-  const dir = path61.join(CLAUDE_PROJECTS_DIR, projectDirName);
-  if (!fs50.existsSync(dir)) return [];
-  const entries = fs50.readdirSync(dir, { withFileTypes: true });
+  const dir = path62.join(CLAUDE_PROJECTS_DIR, projectDirName);
+  if (!fs51.existsSync(dir)) return [];
+  const entries = fs51.readdirSync(dir, { withFileTypes: true });
   return entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => {
-    const filePath = path61.join(dir, e.name);
-    const stat = fs50.statSync(filePath);
+    const filePath = path62.join(dir, e.name);
+    const stat = fs51.statSync(filePath);
     return { filePath, mtime: stat.mtimeMs };
   });
 }
@@ -75973,15 +76614,15 @@ function listAllSessions() {
   }
   const clawProjectPaths = discoverClawProjects();
   for (const projectPath of clawProjectPaths) {
-    const sessionsDir = path61.join(projectPath, CLAW_SESSIONS_DIR_NAME);
-    if (!fs50.existsSync(sessionsDir)) continue;
+    const sessionsDir = path62.join(projectPath, CLAW_SESSIONS_DIR_NAME);
+    if (!fs51.existsSync(sessionsDir)) continue;
     try {
-      const entries = fs50.readdirSync(sessionsDir, { withFileTypes: true });
+      const entries = fs51.readdirSync(sessionsDir, { withFileTypes: true });
       for (const e of entries) {
         if (!e.isFile() || !e.name.endsWith(".jsonl")) continue;
-        const filePath = path61.join(sessionsDir, e.name);
+        const filePath = path62.join(sessionsDir, e.name);
         try {
-          const stat = fs50.statSync(filePath);
+          const stat = fs51.statSync(filePath);
           results.push({ filePath, projectPath, client: "claw-code", mtime: stat.mtimeMs });
         } catch {
         }
@@ -75994,25 +76635,25 @@ function listAllSessions() {
 function discoverClawProjects() {
   const paths = /* @__PURE__ */ new Set();
   for (const { projectPath } of listProjectDirs()) {
-    if (fs50.existsSync(path61.join(projectPath, CLAW_SESSIONS_DIR_NAME))) {
+    if (fs51.existsSync(path62.join(projectPath, CLAW_SESSIONS_DIR_NAME))) {
       paths.add(projectPath);
     }
   }
   const cwd = process.cwd();
-  if (fs50.existsSync(path61.join(cwd, CLAW_SESSIONS_DIR_NAME))) {
+  if (fs51.existsSync(path62.join(cwd, CLAW_SESSIONS_DIR_NAME))) {
     paths.add(cwd);
   }
   const home = os7.homedir();
   const commonRoots = ["Projects", "projects", "dev", "workspace", "code", "PhpstormProjects", "WebstormProjects", "src"];
   for (const root of commonRoots) {
-    const rootDir = path61.join(home, root);
-    if (!fs50.existsSync(rootDir)) continue;
+    const rootDir = path62.join(home, root);
+    if (!fs51.existsSync(rootDir)) continue;
     try {
-      const entries = fs50.readdirSync(rootDir, { withFileTypes: true });
+      const entries = fs51.readdirSync(rootDir, { withFileTypes: true });
       for (const e of entries) {
         if (!e.isDirectory()) continue;
-        const projectDir = path61.join(rootDir, e.name);
-        if (fs50.existsSync(path61.join(projectDir, CLAW_SESSIONS_DIR_NAME))) {
+        const projectDir = path62.join(rootDir, e.name);
+        if (fs51.existsSync(path62.join(projectDir, CLAW_SESSIONS_DIR_NAME))) {
           paths.add(projectDir);
         }
       }
@@ -76717,8 +77358,8 @@ function formatBenchmarkMarkdown(result) {
 }
 
 // src/analytics/tech-detector.ts
-import fs51 from "fs";
-import path62 from "path";
+import fs52 from "fs";
+import path63 from "path";
 
 // src/analytics/known-packages.ts
 var KNOWN_PACKAGES = {
@@ -78229,7 +78870,7 @@ var KNOWN_PACKAGES = {
 // src/analytics/tech-detector.ts
 function parsePackageJson(filePath) {
   try {
-    const pkg = JSON.parse(fs51.readFileSync(filePath, "utf-8"));
+    const pkg = JSON.parse(fs52.readFileSync(filePath, "utf-8"));
     const deps = [];
     for (const [name, version2] of Object.entries(pkg.dependencies ?? {})) {
       deps.push({ name, version: String(version2), isDev: false });
@@ -78244,7 +78885,7 @@ function parsePackageJson(filePath) {
 }
 function parseComposerJson(filePath) {
   try {
-    const pkg = JSON.parse(fs51.readFileSync(filePath, "utf-8"));
+    const pkg = JSON.parse(fs52.readFileSync(filePath, "utf-8"));
     const deps = [];
     for (const [name, version2] of Object.entries(pkg.require ?? {})) {
       if (name === "php" || name.startsWith("ext-")) continue;
@@ -78260,7 +78901,7 @@ function parseComposerJson(filePath) {
 }
 function parseRequirementsTxt(filePath) {
   try {
-    const content = fs51.readFileSync(filePath, "utf-8");
+    const content = fs52.readFileSync(filePath, "utf-8");
     const deps = [];
     for (const line of content.split("\n")) {
       const trimmed = line.trim();
@@ -78277,7 +78918,7 @@ function parseRequirementsTxt(filePath) {
 }
 function parsePyprojectToml(filePath) {
   try {
-    const content = fs51.readFileSync(filePath, "utf-8");
+    const content = fs52.readFileSync(filePath, "utf-8");
     const deps = [];
     const depSection = content.match(/\[project\][\s\S]*?dependencies\s*=\s*\[([\s\S]*?)\]/);
     if (depSection) {
@@ -78293,7 +78934,7 @@ function parsePyprojectToml(filePath) {
 }
 function parseGoMod(filePath) {
   try {
-    const content = fs51.readFileSync(filePath, "utf-8");
+    const content = fs52.readFileSync(filePath, "utf-8");
     const deps = [];
     const requireBlock = content.match(/require\s*\(([\s\S]*?)\)/);
     if (requireBlock) {
@@ -78313,7 +78954,7 @@ function parseGoMod(filePath) {
 }
 function parseGemfile(filePath) {
   try {
-    const content = fs51.readFileSync(filePath, "utf-8");
+    const content = fs52.readFileSync(filePath, "utf-8");
     const deps = [];
     for (const line of content.split("\n")) {
       const m = line.match(/gem\s+['"]([^'"]+)['"]\s*(?:,\s*['"]([^'"]*)['""])?/);
@@ -78382,8 +79023,8 @@ function detectCoverage(projectRoot, opts = {}) {
   const manifestsFound = [];
   const allDeps = [];
   for (const { file, ecosystem, parser } of MANIFEST_PARSERS) {
-    const filePath = path62.join(projectRoot, file);
-    if (!fs51.existsSync(filePath)) continue;
+    const filePath = path63.join(projectRoot, file);
+    if (!fs52.existsSync(filePath)) continue;
     manifestsFound.push(file);
     const rawDeps = parser(filePath);
     for (const raw of rawDeps) {
@@ -79872,8 +80513,8 @@ function registerSessionTools(server, ctx) {
 import { z as z14 } from "zod";
 
 // src/memory/conversation-miner.ts
-import * as fs52 from "fs";
-import * as path63 from "path";
+import * as fs53 from "fs";
+import * as path64 from "path";
 init_logger();
 var DECISION_PATTERNS = [
   // Architecture decisions: "decided to", "we'll use", "going with", "chose X over Y"
@@ -79948,7 +80589,7 @@ function truncateTitle(s) {
   return clean.slice(0, 77) + "...";
 }
 function parseConversationTurns(filePath) {
-  const content = fs52.readFileSync(filePath, "utf-8");
+  const content = fs53.readFileSync(filePath, "utf-8");
   const lines = content.split("\n").filter((l) => l.trim());
   const turns = [];
   for (const line of lines) {
@@ -80101,7 +80742,7 @@ function mineSessions(decisionStore, opts = {}) {
           file_path: d.file_path,
           tags: d.tags,
           valid_from: d.timestamp,
-          session_id: path63.basename(session.filePath, ".jsonl"),
+          session_id: path64.basename(session.filePath, ".jsonl"),
           source: "mined",
           confidence: d.confidence
         }));
@@ -80126,8 +80767,8 @@ function mineSessions(decisionStore, opts = {}) {
 }
 
 // src/memory/session-indexer.ts
-import * as fs53 from "fs";
-import * as path64 from "path";
+import * as fs54 from "fs";
+import * as path65 from "path";
 init_logger();
 var MAX_CHUNK_CHARS = 2e3;
 var MIN_MESSAGE_CHARS = 50;
@@ -80166,9 +80807,9 @@ function truncateChunk(text) {
   return truncated + "...";
 }
 function indexSessionFile(filePath, projectPath, decisionStore) {
-  const content = fs53.readFileSync(filePath, "utf-8");
+  const content = fs54.readFileSync(filePath, "utf-8");
   const lines = content.split("\n").filter((l) => l.trim());
-  const sessionId = path64.basename(filePath, ".jsonl");
+  const sessionId = path65.basename(filePath, ".jsonl");
   const chunks = [];
   let chunkIndex = 0;
   for (const line of lines) {
@@ -80219,7 +80860,7 @@ function indexSessions(decisionStore, opts = {}) {
       skipped++;
       continue;
     }
-    const sessionId = path64.basename(session.filePath, ".jsonl");
+    const sessionId = path65.basename(session.filePath, ".jsonl");
     if (!opts.force && decisionStore.isSessionIndexed(sessionId)) {
       skipped++;
       continue;
@@ -80244,7 +80885,7 @@ function indexSessions(decisionStore, opts = {}) {
 }
 
 // src/memory/wake-up.ts
-import * as path65 from "path";
+import * as path66 from "path";
 function compactDecision(d) {
   const entry = {
     id: d.id,
@@ -80268,7 +80909,7 @@ function assembleWakeUp(decisionStore, projectRoot, opts = {}) {
   const indexedSessions = decisionStore.getIndexedSessionIds(projectRoot);
   const result = {
     project: {
-      name: path65.basename(projectRoot),
+      name: path66.basename(projectRoot),
       root: projectRoot
     },
     decisions: {
@@ -80715,6 +81356,45 @@ var TopologyStore = class {
       `);
       logger.info("Migration: rebuilt subprojects with project_root column, old data cleared");
     }
+    this.runOnce("clean_duplicate_contracts_v1", () => {
+      const services = this.db.prepare(
+        `SELECT DISTINCT service_id FROM api_contracts WHERE contract_type = 'framework_routes'`
+      ).all();
+      let deletedContracts = 0;
+      let deletedEndpoints = 0;
+      for (const { service_id } of services) {
+        const latest = this.db.prepare(
+          `SELECT id FROM api_contracts WHERE service_id = ? AND contract_type = 'framework_routes' ORDER BY id DESC LIMIT 1`
+        ).get(service_id);
+        if (!latest) continue;
+        const result = this.db.prepare(
+          `DELETE FROM api_contracts WHERE service_id = ? AND contract_type = 'framework_routes' AND id != ?`
+        ).run(service_id, latest.id);
+        deletedContracts += result.changes;
+        const httpMethods = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "ANY"];
+        const placeholders = httpMethods.map(() => "?").join(",");
+        const epResult = this.db.prepare(
+          `DELETE FROM api_endpoints WHERE contract_id = ? AND method IS NOT NULL AND method NOT IN (${placeholders})`
+        ).run(latest.id, ...httpMethods);
+        deletedEndpoints += epResult.changes;
+      }
+      if (deletedContracts > 0 || deletedEndpoints > 0) {
+        logger.info({ deletedContracts, deletedEndpoints }, "Migration: cleaned duplicate contracts and non-HTTP endpoints");
+      }
+    });
+    this.runOnce("rebuild_cross_service_edges_v1", () => {
+      const result = this.db.prepare("DELETE FROM cross_service_edges").run();
+      if (result.changes > 0) {
+        logger.info({ deleted: result.changes }, "Migration: cleared stale cross-service edges for rebuild");
+      }
+    });
+  }
+  /** Run a migration block exactly once, tracked by key in topology_meta. */
+  runOnce(key, fn2) {
+    const existing = this.db.prepare("SELECT value FROM topology_meta WHERE key = ?").get(key);
+    if (existing) return;
+    fn2();
+    this.db.prepare("INSERT OR REPLACE INTO topology_meta (key, value) VALUES (?, ?)").run(key, (/* @__PURE__ */ new Date()).toISOString());
   }
   close() {
     this.db.close();
@@ -80760,6 +81440,15 @@ var TopologyStore = class {
   getAllServices() {
     return this.db.prepare("SELECT * FROM services ORDER BY name").all();
   }
+  updateServiceGroup(serviceId, projectGroup) {
+    this.db.prepare("UPDATE services SET project_group = ? WHERE id = ?").run(projectGroup, serviceId);
+  }
+  getServicesWithEndpointCounts() {
+    return this.db.prepare(`
+      SELECT s.*, (SELECT COUNT(*) FROM api_endpoints WHERE service_id = s.id) as endpoint_count
+      FROM services s ORDER BY s.project_group NULLS LAST, s.name
+    `).all();
+  }
   deleteService(id) {
     this.db.prepare("DELETE FROM services WHERE id = ?").run(id);
   }
@@ -81038,13 +81727,29 @@ var TopologyStore = class {
       "SELECT * FROM client_calls WHERE matched_endpoint_id IS NULL"
     ).all();
     const endpoints = this.getAllEndpoints();
+    const services = this.getAllServices();
+    const serviceGroup = /* @__PURE__ */ new Map();
+    for (const svc of services) {
+      serviceGroup.set(svc.id, svc.project_group ?? null);
+    }
+    const repoGroup = /* @__PURE__ */ new Map();
+    const allRepos2 = this.getAllSubprojects();
+    for (const repo of allRepos2) {
+      const svc = services.find((s) => s.repo_root === repo.repo_root);
+      repoGroup.set(repo.id, svc?.project_group ?? null);
+    }
     let linked = 0;
     const updateStmt = this.db.prepare(
       "UPDATE client_calls SET matched_endpoint_id = ?, target_repo_id = ?, confidence = ? WHERE id = ?"
     );
     this.db.transaction(() => {
       for (const call of unlinked) {
-        const match = findBestEndpointMatch(call.url_pattern, call.method, endpoints);
+        const sourceGroup = repoGroup.get(call.source_repo_id);
+        const candidateEndpoints = sourceGroup ? endpoints.filter((ep) => {
+          const epGroup = serviceGroup.get(ep.service_id);
+          return epGroup === sourceGroup || !epGroup || !sourceGroup;
+        }) : endpoints;
+        const match = findBestEndpointMatch(call.url_pattern, call.method, candidateEndpoints);
         if (match) {
           const svc = this.db.prepare("SELECT repo_root FROM services WHERE id = ?").get(match.service_id);
           const targetRepo = svc ? this.db.prepare("SELECT id FROM subprojects WHERE repo_root = ?").get(svc.repo_root) : void 0;
@@ -81466,7 +82171,7 @@ var DecisionStore = class {
 };
 
 // src/server/server.ts
-var PKG_VERSION2 = true ? "1.22.0" : "0.0.0-dev";
+var PKG_VERSION2 = true ? "1.23.0" : "0.0.0-dev";
 function j2(value) {
   return JSON.stringify(value, (_key, val) => val === null || val === void 0 ? void 0 : val);
 }
@@ -81891,11 +82596,11 @@ var PluginRegistry = class {
 // src/config.ts
 import { cosmiconfig } from "cosmiconfig";
 import { z as z15 } from "zod";
-import fs55 from "fs";
+import fs56 from "fs";
 init_logger();
 
 // src/config-jsonc.ts
-import fs54 from "fs";
+import fs55 from "fs";
 import { modify, applyEdits, parse as parse2 } from "jsonc-parser";
 init_logger();
 
@@ -81917,7 +82622,7 @@ var FrameworkConfigSchema = z15.object({
 }).optional();
 var AiConfigSchema = z15.object({
   enabled: z15.boolean().default(false),
-  provider: z15.enum(["onnx", "ollama", "openai"]).default("onnx"),
+  provider: z15.enum(["onnx", "ollama", "openai", "anthropic", "lmstudio", "gemini", "mistral", "deepseek", "groq", "together", "xai"]).default("onnx"),
   base_url: z15.string().optional(),
   api_key: z15.string().optional(),
   inference_model: z15.string().optional(),
@@ -82129,9 +82834,9 @@ var TraceMcpConfigSchema = z15.object({
   children: z15.array(z15.string()).optional()
 });
 function loadGlobalConfigRaw() {
-  if (!fs55.existsSync(GLOBAL_CONFIG_PATH)) return {};
+  if (!fs56.existsSync(GLOBAL_CONFIG_PATH)) return {};
   try {
-    return JSON.parse(stripJsonComments(fs55.readFileSync(GLOBAL_CONFIG_PATH, "utf-8")));
+    return JSON.parse(stripJsonComments(fs56.readFileSync(GLOBAL_CONFIG_PATH, "utf-8")));
   } catch {
     return {};
   }