memorix 1.8.1 → 1.8.2

package/CHANGELOG.md

@@ -4,6 +4,26 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [1.8.2] - 2026-08-25
+
+### Fixed
+- **Dashboard deduplication initialization (#248)** -- standalone and HTTP
+  maintenance previews now idempotently resolve the selected project's memory
+  LLM from TOML and `.env`, clear stale cross-project configuration, and keep
+  credentials out of responses.
+- **CodeGraph capability fallback (#250)** -- a failed or invalid `context`
+  probe now tries the official `explore` CLI with bounded, shell-free spawning.
+  Only validated paths, symbols, and relationships can select the external
+  provider; separate context/explore diagnostics explain Lite fallback.
+
+### MCP Compatibility
+- **Discovery adapter (#249)** -- the stdio server registers a real low-level
+  `server/discover` handler that returns the required 2026-07-28
+  `DiscoverResult` before `initialize`. Legacy 2025 initialize and versionless
+  `tools/list`/`tools/call` remain supported through the SDK's legacy envelopes.
+  Tasks, subscriptions, and list-response caching remain unsupported and are
+  not advertised.
+
 ## [1.8.1] - 2026-08-24
 
 ### Changed

package/dist/cli/index.js

@@ -3232,7 +3232,7 @@ ${import_picocolors.default.gray(m3)}  ${s4}
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.8.1" : pkg.version;
+  return true ? "1.8.2" : pkg.version;
 }
 var init_version = __esm({
   "src/cli/version.ts"() {
@@ -21630,8 +21630,10 @@ function loadEnvFile(filePath) {
   loadedEnvFiles.push(filePath);
 }
 function loadDotenv(projectRoot, options = {}) {
-  if (dotenvLoaded && dotenvProjectRoot === (projectRoot ?? null)) return;
-  if (dotenvLoaded && dotenvProjectRoot !== (projectRoot ?? null)) {
+  const userHomeDir = options.userHomeDir ?? homedir4();
+  const normalizedProjectRoot = projectRoot ?? null;
+  if (dotenvLoaded && dotenvProjectRoot === normalizedProjectRoot && dotenvHomeDir === userHomeDir) return;
+  if (dotenvLoaded && (dotenvProjectRoot !== normalizedProjectRoot || dotenvHomeDir !== userHomeDir)) {
     resetDotenv();
   }
   loadedEnvFiles.length = 0;
@@ -21640,9 +21642,10 @@ function loadDotenv(projectRoot, options = {}) {
   if (projectRoot) {
     loadEnvFile(getProjectDotenvPath(projectRoot));
   }
-  loadEnvFile(getGlobalDotenvPath(options.userHomeDir ?? homedir4()));
+  loadEnvFile(getGlobalDotenvPath(userHomeDir));
   dotenvLoaded = true;
-  dotenvProjectRoot = projectRoot ?? null;
+  dotenvProjectRoot = normalizedProjectRoot;
+  dotenvHomeDir = userHomeDir;
 }
 function resetDotenv() {
   for (const key of injectedKeys) {
@@ -21651,6 +21654,7 @@ function resetDotenv() {
   injectedKeys.clear();
   dotenvLoaded = false;
   dotenvProjectRoot = null;
+  dotenvHomeDir = null;
   loadedEnvFiles.length = 0;
   loadedEnvKeys.clear();
 }
@@ -21663,7 +21667,7 @@ function getLoadedEnvKeys() {
 function getLoadedEnvValue(key) {
   return loadedEnvValues.get(key);
 }
-var import_dotenv, dotenvLoaded, dotenvProjectRoot, loadedEnvFiles, loadedEnvKeys, loadedEnvValues, injectedKeys;
+var import_dotenv, dotenvLoaded, dotenvProjectRoot, dotenvHomeDir, loadedEnvFiles, loadedEnvKeys, loadedEnvValues, injectedKeys;
 var init_dotenv_loader = __esm({
   "src/config/dotenv-loader.ts"() {
     "use strict";
@@ -21672,6 +21676,7 @@ var init_dotenv_loader = __esm({
     init_config_paths();
     dotenvLoaded = false;
     dotenvProjectRoot = null;
+    dotenvHomeDir = null;
     loadedEnvFiles = [];
     loadedEnvKeys = /* @__PURE__ */ new Set();
     loadedEnvValues = /* @__PURE__ */ new Map();
@@ -22023,33 +22028,33 @@ __export(config_exports, {
   resetConfigCache: () => resetConfigCache,
   resetDotenv: () => resetDotenv
 });
-function getLLMApiKey() {
-  return getResolvedMemoryLane().llm.apiKey;
+function getLLMApiKey(options = {}) {
+  return getResolvedMemoryLane(options).llm.apiKey;
 }
-function getLLMProvider() {
-  const provider2 = getResolvedMemoryLane().llm.provider;
+function getLLMProvider(options = {}) {
+  const provider2 = getResolvedMemoryLane(options).llm.provider;
   if (provider2) return provider2;
   if (process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY) return "anthropic";
   if (process.env.OPENROUTER_API_KEY && !process.env.OPENAI_API_KEY) return "openrouter";
   return "openai";
 }
-function getLLMModel(providerDefault) {
-  return getResolvedMemoryLane().llm.model || providerDefault;
+function getLLMModel(providerDefault, options = {}) {
+  return getResolvedMemoryLane(options).llm.model || providerDefault;
 }
-function getLLMBaseUrl(providerDefault) {
-  return getResolvedMemoryLane().llm.baseUrl || providerDefault;
+function getLLMBaseUrl(providerDefault, options = {}) {
+  return getResolvedMemoryLane(options).llm.baseUrl || providerDefault;
 }
-function getAgentLLMApiKey() {
-  return getResolvedAgentLane().apiKey;
+function getAgentLLMApiKey(options = {}) {
+  return getResolvedAgentLane(options).apiKey;
 }
-function getAgentLLMProvider() {
-  return getResolvedAgentLane().provider || getLLMProvider();
+function getAgentLLMProvider(options = {}) {
+  return getResolvedAgentLane(options).provider || getLLMProvider(options);
 }
-function getAgentLLMModel(providerDefault) {
-  return getResolvedAgentLane().model || getLLMModel(providerDefault);
+function getAgentLLMModel(providerDefault, options = {}) {
+  return getResolvedAgentLane(options).model || getLLMModel(providerDefault, options);
 }
-function getAgentLLMBaseUrl(providerDefault) {
-  return getResolvedAgentLane().baseUrl || getLLMBaseUrl(providerDefault);
+function getAgentLLMBaseUrl(providerDefault, options = {}) {
+  return getResolvedAgentLane(options).baseUrl || getLLMBaseUrl(providerDefault, options);
 }
 function getEmbeddingMode() {
   const provider2 = getResolvedEmbeddingLane().provider?.toLowerCase()?.trim();
@@ -24308,18 +24313,19 @@ async function* callLLMWithToolsStream(messages, tools) {
 }
 function initLLM(options = {}) {
   const scope = options.scope ?? "memory";
-  const apiKey = scope === "agent" ? getAgentLLMApiKey() : getLLMApiKey();
+  const configOptions = { projectRoot: options.projectRoot, homeDir: options.homeDir };
+  const apiKey = scope === "agent" ? getAgentLLMApiKey(configOptions) : getLLMApiKey(configOptions);
   if (!apiKey) {
     currentConfig = null;
     return null;
   }
-  const provider2 = scope === "agent" ? getAgentLLMProvider() : getLLMProvider();
+  const provider2 = scope === "agent" ? getAgentLLMProvider(configOptions) : getLLMProvider(configOptions);
   const defaults2 = PROVIDER_DEFAULTS[provider2] ?? PROVIDER_DEFAULTS.openai;
   currentConfig = {
     provider: provider2,
     apiKey,
-    model: scope === "agent" ? getAgentLLMModel(defaults2.model) : getLLMModel(defaults2.model),
-    baseUrl: scope === "agent" ? getAgentLLMBaseUrl(defaults2.baseUrl) : getLLMBaseUrl(defaults2.baseUrl)
+    model: scope === "agent" ? getAgentLLMModel(defaults2.model, configOptions) : getLLMModel(defaults2.model, configOptions),
+    baseUrl: scope === "agent" ? getAgentLLMBaseUrl(defaults2.baseUrl, configOptions) : getLLMBaseUrl(defaults2.baseUrl, configOptions)
   };
   return currentConfig;
 }
@@ -197170,6 +197176,27 @@ function unavailableHealth(result) {
   if (result.outputLimited) return { state: "invalid", reason: "A local CodeGraph response exceeded the safety limit." };
   return { state: "unavailable", reason: "A local CodeGraph command did not complete." };
 }
+function notAttemptedDiagnostic(command) {
+  return { command, attempted: false, outcome: "not-attempted" };
+}
+function commandDiagnostic(command, result, outcome, reason) {
+  return {
+    command,
+    attempted: true,
+    outcome,
+    ...typeof result.exitCode === "number" ? { exitCode: result.exitCode } : {},
+    ...reason ? { reason: sanitizeCredentials(reason).slice(0, 240) } : {}
+  };
+}
+function failedCommandDiagnostic(command, result) {
+  const outcome = result.timedOut ? "timed-out" : result.outputLimited ? "output-limited" : "failed";
+  return commandDiagnostic(
+    command,
+    result,
+    outcome,
+    result.error || result.stderr || "CodeGraph command did not complete."
+  );
+}
 async function runSafely(runner, input) {
   try {
     return await runner.run(input);
@@ -197319,6 +197346,7 @@ function parseOutline(value, projectRoot, exclude) {
   if (nodes.some((node) => !node)) return void 0;
   const byId = /* @__PURE__ */ new Map();
   for (const node of nodes) {
+    if (byId.has(node.id)) return void 0;
     byId.set(node.id, externalSymbol(node));
   }
   const entryPoints = value.entryPoints.map((item) => parseNode(item, projectRoot, exclude)).filter((node) => Boolean(node)).map(externalSymbol).filter((node, index, items) => items.findIndex((item) => item.id === node.id) === index).slice(0, 5);
@@ -197332,7 +197360,7 @@ function parseOutline(value, projectRoot, exclude) {
     if (!source || !target || !kind || rawEdge.line !== void 0 && (!line || line < 1)) return void 0;
     const from = byId.get(source);
     const to2 = byId.get(target);
-    if (!from || !to2) continue;
+    if (!from || !to2) return void 0;
     relations.push({ from, to: to2, kind, ...line ? { line } : {} });
   }
   const relatedFiles = value.relatedFiles.map((item) => safeRelativePath(projectRoot, item, exclude));
@@ -197350,45 +197378,234 @@ function parseOutline(value, projectRoot, exclude) {
     stats: { nodes: nodeCount, edges: edgeCount, files: fileCount }
   };
 }
+function parseTextLocation(value) {
+  const match2 = value.trim().match(/^(.*?)(?::([1-9]\d*))?$/);
+  if (!match2?.[1]) return void 0;
+  return {
+    filePath: match2[1].trim(),
+    ...match2[2] ? { line: Number(match2[2]) } : {}
+  };
+}
+function parseExploreText(value, projectRoot, exclude) {
+  if (!value.trim() || Buffer.byteLength(value, "utf8") > MAX_EXTERNAL_CODEGRAPH_OUTPUT_BYTES) return void 0;
+  const entryPoints = [];
+  const nodes = [];
+  const relatedFiles = /* @__PURE__ */ new Set();
+  const byName = /* @__PURE__ */ new Map();
+  let section2 = null;
+  let relationKind = "references";
+  const addNode = (node, entry) => {
+    const key = `${node.filePath}\0${node.name}`;
+    const existing = byName.get(key);
+    if (existing) return;
+    byName.set(key, node);
+    relatedFiles.add(node.filePath);
+    (entry ? entryPoints : nodes).push(node);
+  };
+  for (const rawLine of value.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    const fileHeader = line.match(/^\*\*`([^`]+)`\*\*\s+(?:—|-)\s+(.+)$/);
+    if (fileHeader) {
+      const filePath = safeRelativePath(projectRoot, fileHeader[1], exclude);
+      if (!filePath) return void 0;
+      const symbolText = fileHeader[2].split(/\s+·\s+/, 1)[0] ?? "";
+      const symbols = [...symbolText.matchAll(/([^,]+?)\(([^()]+)\)/g)];
+      if (symbols.length === 0) return void 0;
+      const isFirstFile = entryPoints.length === 0 && nodes.length === 0;
+      for (const symbol2 of symbols.slice(0, MAX_EXTERNAL_NODE_COUNT)) {
+        const name = symbol2[1]?.trim();
+        const kind = symbol2[2]?.trim();
+        if (!name || !kind) return void 0;
+        addNode({
+          id: `explore:${filePath}:${name}`,
+          kind,
+          name,
+          filePath
+        }, isFirstFile);
+      }
+      section2 = null;
+      continue;
+    }
+    if (/^#{2,3}\s+Entry Points?\b/i.test(line)) {
+      section2 = "entry";
+      continue;
+    }
+    if (/^#{2,3}\s+Related Symbols?\b/i.test(line)) {
+      section2 = "related";
+      continue;
+    }
+    if (/^\*\*Relationships\*\*$/i.test(line)) {
+      section2 = "relationships";
+      continue;
+    }
+    if (/^\*\*(?:Source Code|Code)\*\*$/i.test(line) || /^#{2,3}\s+/i.test(line)) {
+      section2 = null;
+      continue;
+    }
+    if (section2 === "entry") {
+      const match2 = line.match(/^-\s+\*\*(.+?)\*\*\s+\(([^)]+)\)\s+-\s+(.+)$/);
+      if (!match2) continue;
+      const location = parseTextLocation(match2[3]);
+      if (!location) return void 0;
+      const filePath = safeRelativePath(projectRoot, location.filePath, exclude);
+      if (!filePath) return void 0;
+      addNode({
+        id: `explore:${filePath}:${match2[1]}`,
+        kind: match2[2],
+        name: match2[1],
+        filePath,
+        ...location.line ? { startLine: location.line, endLine: location.line } : {}
+      }, true);
+      continue;
+    }
+    if (section2 === "related") {
+      const match2 = line.match(/^-\s+([^:]+):\s+(.+)$/);
+      if (!match2) continue;
+      const filePath = safeRelativePath(projectRoot, match2[1], exclude);
+      if (!filePath) return void 0;
+      relatedFiles.add(filePath);
+      for (const rawSymbol of match2[2].split(",")) {
+        const symbol2 = rawSymbol.trim().match(/^(.+?)(?::([1-9]\d*))?$/);
+        if (!symbol2?.[1]) return void 0;
+        addNode({
+          id: `explore:${filePath}:${symbol2[1].trim()}`,
+          kind: "unknown",
+          name: symbol2[1].trim(),
+          filePath,
+          ...symbol2[2] ? { startLine: Number(symbol2[2]), endLine: Number(symbol2[2]) } : {}
+        }, false);
+      }
+      continue;
+    }
+    if (section2 === "relationships") {
+      const kind = line.match(/^\*\*([^*]+):\*\*$/);
+      if (kind?.[1]) {
+        relationKind = kind[1].trim();
+        continue;
+      }
+    }
+  }
+  const bySymbolName = /* @__PURE__ */ new Map();
+  for (const node of [...entryPoints, ...nodes]) {
+    if (!bySymbolName.has(node.name)) bySymbolName.set(node.name, node);
+  }
+  const relations = [];
+  if (section2 === "relationships") {
+    for (const rawLine of value.split(/\r?\n/)) {
+      const line = rawLine.trim();
+      const match2 = line.match(/^-\s+(.+?)\s+(?:\u2192|->)\s+(.+)$/);
+      if (!match2) continue;
+      const from = bySymbolName.get(match2[1].trim());
+      const to2 = bySymbolName.get(match2[2].trim());
+      if (!from || !to2) continue;
+      relations.push({
+        from: externalSymbol(from),
+        to: externalSymbol(to2),
+        kind: relationKind
+      });
+    }
+  } else {
+    const relationshipStart = value.split(/\r?\n/).findIndex((line) => /^\s*\*\*Relationships\*\*\s*$/i.test(line));
+    if (relationshipStart >= 0) {
+      const relationshipLines = value.split(/\r?\n/).slice(relationshipStart + 1);
+      for (const rawLine of relationshipLines) {
+        const line = rawLine.trim();
+        if (/^\*\*(?:Source Code|Code)\*\*$/i.test(line) || /^#{2,3}\s+/i.test(line)) break;
+        const kind = line.match(/^\*\*([^*]+):\*\*$/);
+        if (kind?.[1]) {
+          relationKind = kind[1].trim();
+          continue;
+        }
+        const match2 = line.match(/^-\s+(.+?)\s+(?:\u2192|->)\s+(.+)$/);
+        if (!match2) continue;
+        const from = bySymbolName.get(match2[1].trim());
+        const to2 = bySymbolName.get(match2[2].trim());
+        if (from && to2) relations.push({ from: externalSymbol(from), to: externalSymbol(to2), kind: relationKind });
+      }
+    }
+  }
+  const allNodes = [...entryPoints, ...nodes];
+  if (allNodes.length === 0) return void 0;
+  return {
+    provider: "external",
+    entryPoints: entryPoints.map(externalSymbol).slice(0, 5),
+    relations: relations.slice(0, 6),
+    relatedFiles: [...relatedFiles].slice(0, 5),
+    stats: {
+      nodes: allNodes.length,
+      edges: relations.length,
+      files: relatedFiles.size
+    }
+  };
+}
+function parseExplorePayload(value, projectRoot, exclude) {
+  if (typeof value === "string") return parseExploreText(value, projectRoot, exclude);
+  if (isRecord3(value) && isRecord3(value.result)) value = value.result;
+  if (isRecord3(value) && Array.isArray(value.content)) {
+    const text2 = value.content.filter((item) => isRecord3(item) && item.type === "text" && typeof item.text === "string").map((item) => item.text).join("\n");
+    return parseExploreText(text2, projectRoot, exclude);
+  }
+  return parseOutline(value, projectRoot, exclude);
+}
 function fallbackCaution(health) {
   if (health.state === "disabled" || health.state === "not-detected" || health.state === "not-initialized" || health.state === "ready") return void 0;
   return "External semantic CodeGraph is " + health.state + "; using Lite structural evidence for this brief.";
 }
+function queryFallbackCaution(diagnostics) {
+  return `External semantic CodeGraph context was unavailable (context: ${diagnostics.context.outcome}; explore: ${diagnostics.explore.outcome}); using Lite structural evidence.`;
+}
 async function getExternalCodeGraphContext(input) {
   const inspected = await inspectExternalCodeGraph(input);
   if (inspected.health.state !== "ready") {
     return { ...inspected, caution: fallbackCaution(inspected.health) };
   }
   const mode = input.mode ?? "auto";
-  const result = await runSafely(input.runner ?? defaultRunner, {
+  const runner = input.runner ?? defaultRunner;
+  const contextResult = await runSafely(runner, {
     command: input.command,
     args: ["context", "--path", input.projectRoot, "--format", "json", "--max-nodes", "8", "--no-code", input.task],
     cwd: input.projectRoot,
     timeoutMs: boundedTimeout(input.timeoutMs),
     maxOutputBytes: MAX_EXTERNAL_CODEGRAPH_OUTPUT_BYTES
   });
-  if (!result.ok) {
-    const health = unavailableHealth(result);
+  const diagnostics = {
+    context: contextResult.ok ? commandDiagnostic("context", contextResult, "success") : failedCommandDiagnostic("context", contextResult),
+    explore: notAttemptedDiagnostic("explore")
+  };
+  const contextOutline = contextResult.ok ? parseOutline(parseJson2(contextResult.stdout), input.projectRoot, input.exclude) : void 0;
+  if (contextOutline && (contextOutline.entryPoints.length > 0 || contextOutline.relations.length > 0 || contextOutline.relatedFiles.length > 0)) {
     return {
-      health,
-      quality: providerQuality({ mode, health }),
-      caution: fallbackCaution(health)
+      ...inspected,
+      outline: contextOutline,
+      diagnostics,
+      quality: providerQuality({ mode, health: inspected.health, selected: "external" })
     };
   }
-  const outline = parseOutline(parseJson2(result.stdout), input.projectRoot, input.exclude);
-  if (!outline) {
-    const health = { state: "invalid", reason: "The local CodeGraph context payload failed validation." };
+  if (contextResult.ok) diagnostics.context = commandDiagnostic("context", contextResult, "invalid-output", "The context payload failed validation or contained no safe outline.");
+  const exploreResult = await runSafely(runner, {
+    command: input.command,
+    args: ["explore", "--path", input.projectRoot, "--max-files", "4", input.task],
+    cwd: input.projectRoot,
+    timeoutMs: boundedTimeout(input.timeoutMs),
+    maxOutputBytes: MAX_EXTERNAL_CODEGRAPH_OUTPUT_BYTES
+  });
+  diagnostics.explore = exploreResult.ok ? commandDiagnostic("explore", exploreResult, "success") : failedCommandDiagnostic("explore", exploreResult);
+  const exploreOutline = exploreResult.ok ? parseExplorePayload(parseJson2(exploreResult.stdout) ?? exploreResult.stdout, input.projectRoot, input.exclude) : void 0;
+  if (exploreOutline && (exploreOutline.entryPoints.length > 0 || exploreOutline.relations.length > 0 || exploreOutline.relatedFiles.length > 0)) {
     return {
-      health,
-      quality: providerQuality({ mode, health }),
-      caution: fallbackCaution(health)
+      ...inspected,
+      outline: exploreOutline,
+      diagnostics,
+      quality: providerQuality({ mode, health: inspected.health, selected: "external" })
     };
   }
-  const contributes = outline.entryPoints.length > 0 || outline.relations.length > 0 || outline.relatedFiles.length > 0;
+  if (exploreResult.ok) diagnostics.explore = commandDiagnostic("explore", exploreResult, "invalid-output", "The explore payload failed validation or contained no safe outline.");
+  const health = exploreResult.ok ? { state: "invalid", reason: "The local CodeGraph context and explore payloads failed validation." } : unavailableHealth(exploreResult);
   return {
-    ...inspected,
-    ...contributes ? { outline } : {},
-    quality: providerQuality({ mode, health: inspected.health, ...contributes ? { selected: "external" } : {} })
+    health,
+    quality: providerQuality({ mode, health }),
+    diagnostics,
+    caution: queryFallbackCaution(diagnostics)
   };
 }
 var DEFAULT_EXTERNAL_CODEGRAPH_TIMEOUT_MS, MAX_EXTERNAL_CODEGRAPH_TIMEOUT_MS, EXTERNAL_CODEGRAPH_LIFECYCLE_TIMEOUT_MS, MAX_EXTERNAL_CODEGRAPH_OUTPUT_BYTES, MAX_EXTERNAL_NODE_COUNT, MAX_EXTERNAL_EDGE_COUNT, MAX_EXTERNAL_FILE_COUNT, MAX_EXTERNAL_TEXT_LENGTH, LITE_SUPPORTED_LANGUAGES, defaultRunner;
@@ -197399,7 +197616,7 @@ var init_external_provider = __esm({
     init_secret_filter();
     init_exclude3();
     init_ids();
-    DEFAULT_EXTERNAL_CODEGRAPH_TIMEOUT_MS = 1200;
+    DEFAULT_EXTERNAL_CODEGRAPH_TIMEOUT_MS = 3e3;
     MAX_EXTERNAL_CODEGRAPH_TIMEOUT_MS = 5e3;
     EXTERNAL_CODEGRAPH_LIFECYCLE_TIMEOUT_MS = 3e4;
     MAX_EXTERNAL_CODEGRAPH_OUTPUT_BYTES = 256 * 1024;
@@ -218992,6 +219209,51 @@ var init_request_context = __esm({
   }
 });
 
+// src/server/mcp-compat.ts
+function buildMcpDiscoverResult(server, serverInfo) {
+  const getCapabilities = server.server.getCapabilities.bind(server.server);
+  return {
+    resultType: "complete",
+    supportedVersions: [
+      MCP_MODERN_PROTOCOL_VERSION,
+      MCP_LEGACY_PROTOCOL_VERSION,
+      MCP_OLDEST_LEGACY_PROTOCOL_VERSION
+    ],
+    capabilities: getCapabilities(),
+    _meta: {
+      [MCP_SERVER_INFO_META_KEY]: { ...serverInfo }
+    },
+    // v1 has no response-cache negotiation. A zero private TTL is the
+    // conservative result and prevents clients from inventing a shared cache.
+    ttlMs: 0,
+    cacheScope: "private"
+  };
+}
+function registerMcpDiscovery(server, serverInfo) {
+  if (registeredServers.has(server)) return;
+  server.server.setRequestHandler(ServerDiscoverRequestSchema, async () => buildMcpDiscoverResult(server, serverInfo));
+  registeredServers.add(server);
+}
+var MCP_MODERN_PROTOCOL_VERSION, MCP_LEGACY_PROTOCOL_VERSION, MCP_OLDEST_LEGACY_PROTOCOL_VERSION, MCP_SERVER_DISCOVER_METHOD, MCP_SERVER_INFO_META_KEY, ServerDiscoverRequestSchema, registeredServers;
+var init_mcp_compat = __esm({
+  "src/server/mcp-compat.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_types8();
+    init_v4();
+    MCP_MODERN_PROTOCOL_VERSION = "2026-07-28";
+    MCP_LEGACY_PROTOCOL_VERSION = "2025-11-25";
+    MCP_OLDEST_LEGACY_PROTOCOL_VERSION = "2024-11-05";
+    MCP_SERVER_DISCOVER_METHOD = "server/discover";
+    MCP_SERVER_INFO_META_KEY = "io.modelcontextprotocol/serverInfo";
+    ServerDiscoverRequestSchema = RequestSchema.extend({
+      method: external_exports.literal(MCP_SERVER_DISCOVER_METHOD),
+      params: external_exports.looseObject({}).optional()
+    });
+    registeredServers = /* @__PURE__ */ new WeakSet();
+  }
+});
+
 // src/config/behavior.ts
 var behavior_exports = {};
 __export(behavior_exports, {
@@ -219278,6 +219540,7 @@ async function executeCleanup(context, payload, token) {
   return { action: "cleanup", projectId: context.projectId, ...result };
 }
 async function previewDeduplicate(context) {
+  initLLM({ scope: "memory", projectRoot: context.projectRoot });
   if (!isLLMEnabled()) {
     return {
       action: "deduplicate",
@@ -261370,10 +261633,12 @@ The path should point to a directory containing a .git folder.`
       isError: true
     };
   };
-  const server = existingServer ?? new McpServer({
+  const serverInfo = {
     name: "memorix",
-    version: true ? "1.8.1" : "1.0.1"
-  });
+    version: true ? "1.8.2" : "1.0.1"
+  };
+  const server = existingServer ?? new McpServer(serverInfo);
+  registerMcpDiscovery(server, serverInfo);
   const originalRegisterTool = server.registerTool.bind(server);
   server.registerTool = ((name, ...args) => {
     if (!isToolInProfile(name, toolProfile)) {
@@ -265751,6 +266016,7 @@ var init_server4 = __esm({
     init_secret_filter();
     init_surfaced_registry();
     init_request_context();
+    init_mcp_compat();
     FORMATION_TIMEOUT_MS = parseFormationTimeoutMs(process.env.MEMORIX_FORMATION_TIMEOUT_MS);
     COMPACT_ON_WRITE_TIMEOUT_MS = 12e3;
     COMPRESSION_TIMEOUT_MS = 5e3;
@@ -266232,13 +266498,17 @@ function getMcpDiagnostics() {
     protocol: {
       current: CURRENT_MCP_PROTOCOL_VERSION,
       legacy: LEGACY_MCP_PROTOCOL_VERSION,
-      statelessRequests: "supported",
+      discovery: "supported",
+      versionlessRequests: "legacy-compatible",
+      modernResultMetadata: "discovery-only",
+      statelessRequests: "compatibility-only",
       statefulStreamableHttp: "supported"
     },
     capabilities: {
       tasks: "unsupported",
       polling: "unsupported",
-      listCache: "supported",
+      subscriptions: "unsupported",
+      listCache: "unsupported",
       explicitProjectHandle: "supported"
     }
   };
@@ -266249,7 +266519,7 @@ var init_mcp_diagnostics = __esm({
     "use strict";
     init_esm_shims();
     CURRENT_MCP_PROTOCOL_VERSION = "2026-07-28";
-    LEGACY_MCP_PROTOCOL_VERSION = "2024-11-05";
+    LEGACY_MCP_PROTOCOL_VERSION = "2025-11-25";
     MCP_SERVER_NAME = "io.github.AVIDS2/memorix";
   }
 });
@@ -268493,9 +268763,13 @@ __export(serve_http_exports, {
   MCP_SDK_COMPAT_PROTOCOL_VERSION: () => MCP_SDK_COMPAT_PROTOCOL_VERSION,
   _testing: () => _testing2,
   default: () => serve_http_default,
+  isServerDiscoverRequest: () => isServerDiscoverRequest,
   parseSessionTimeoutMs: () => parseSessionTimeoutMs,
   resolveServeHttpDefaults: () => resolveServeHttpDefaults
 });
+function isServerDiscoverRequest(body) {
+  return Boolean(body && typeof body === "object" && !Array.isArray(body) && body.method === "server/discover");
+}
 function parseSessionTimeoutMs(raw) {
   const value = raw?.trim();
   if (!value) return DEFAULT_SESSION_TIMEOUT_MS;
@@ -268776,7 +269050,7 @@ var init_serve_http = __esm({
           }
           const requestedRoot = typeof req.headers["mcp-project-root"] === "string" ? req.headers["mcp-project-root"] : void 0;
           const root = persisted?.projectRoot ?? requestedRoot ?? projectRoot;
-          if (!persisted && !isInitializeRequest2(body)) {
+          if (!persisted && !isInitializeRequest2(body) && !isServerDiscoverRequest(body)) {
             res.writeHead(400, { "Content-Type": "application/json" });
             res.end(JSON.stringify({ jsonrpc: "2.0", error: { code: -32e3, message: "Stateless MCP requests require Mcp-Project-Handle; initialize first." }, id: null }));
             return;
@@ -268840,7 +269114,7 @@ var init_serve_http = __esm({
           const sessionId = req.headers["mcp-session-id"];
           const body = await parseBody(req);
           const requestedProtocol = req.headers["mcp-protocol-version"];
-          const statelessRequested = req.headers["mcp-stateless"] === "true" || requestedProtocol === CURRENT_MCP_PROTOCOL_VERSION;
+          const statelessRequested = req.headers["mcp-stateless"] === "true" || requestedProtocol === CURRENT_MCP_PROTOCOL_VERSION || typeof req.headers["mcp-project-handle"] === "string" || isServerDiscoverRequest(body);
           if (!sessionId && statelessRequested) {
             await handleStatelessPost(req, res, body);
             return;