memorix 1.8.1 → 1.8.3

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.3" : 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;
@@ -205547,6 +205764,259 @@ var init_tool_profile = __esm({
   }
 });
 
+// src/server/mcp-discovery.ts
+function getMcpServerInfo() {
+  return {
+    name: "memorix",
+    version: true ? "1.8.3" : "1.0.1"
+  };
+}
+function createMcpDiscoverResult(capabilities, serverInfo) {
+  return {
+    resultType: "complete",
+    supportedVersions: [
+      MCP_MODERN_PROTOCOL_VERSION,
+      MCP_LEGACY_PROTOCOL_VERSION,
+      MCP_OLDEST_LEGACY_PROTOCOL_VERSION
+    ],
+    capabilities,
+    _meta: {
+      [MCP_SERVER_INFO_META_KEY]: { ...serverInfo }
+    },
+    // v1 has no response-cache negotiation. A zero private TTL prevents clients
+    // from inventing a shared cache for an implementation that cannot invalidate it.
+    ttlMs: 0,
+    cacheScope: "private"
+  };
+}
+function createMcpStartupDiscoverResult(serverInfo) {
+  return createMcpDiscoverResult({ tools: { listChanged: true } }, serverInfo);
+}
+var MCP_MODERN_PROTOCOL_VERSION, MCP_LEGACY_PROTOCOL_VERSION, MCP_OLDEST_LEGACY_PROTOCOL_VERSION, MCP_SERVER_DISCOVER_METHOD, MCP_SERVER_INFO_META_KEY;
+var init_mcp_discovery = __esm({
+  "src/server/mcp-discovery.ts"() {
+    "use strict";
+    init_esm_shims();
+    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";
+  }
+});
+
+// src/server/stdio-startup-gate.ts
+import { PassThrough as PassThrough3 } from "stream";
+var STDIO_STARTUP_GATE_MAX_BUFFER_SIZE, StdioStartupGate;
+var init_stdio_startup_gate = __esm({
+  "src/server/stdio-startup-gate.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_mcp_discovery();
+    STDIO_STARTUP_GATE_MAX_BUFFER_SIZE = 10 * 1024 * 1024;
+    StdioStartupGate = class {
+      input = new PassThrough3();
+      stdin;
+      stdout;
+      serverInfo;
+      maxBufferSize;
+      onError;
+      onEnd;
+      queuedMessages = [];
+      pendingInput = "";
+      queuedBytes = 0;
+      started = false;
+      ready = false;
+      stopped = false;
+      stdinEnded = false;
+      endNotified = false;
+      onData = (chunk) => {
+        if (this.stopped) return;
+        if (this.ready) {
+          if (Buffer.byteLength(chunk, "utf8") > this.maxBufferSize) {
+            this.fail(new Error(`stdio input chunk exceeded ${this.maxBufferSize} bytes`));
+            return;
+          }
+          this.input.write(chunk);
+          return;
+        }
+        const text2 = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+        if (this.queuedBytes + Buffer.byteLength(this.pendingInput, "utf8") + Buffer.byteLength(text2, "utf8") > this.maxBufferSize) {
+          this.fail(new Error(`stdio startup input exceeded ${this.maxBufferSize} bytes before a complete JSON-RPC line`));
+          return;
+        }
+        this.pendingInput += text2;
+        let newline = this.pendingInput.indexOf("\n");
+        while (newline >= 0 && !this.stopped) {
+          const line = this.pendingInput.slice(0, newline + 1);
+          this.pendingInput = this.pendingInput.slice(newline + 1);
+          this.handleLine(line);
+          newline = this.pendingInput.indexOf("\n");
+        }
+        if (!this.stopped && Buffer.byteLength(this.pendingInput, "utf8") > this.maxBufferSize) {
+          this.fail(new Error(`stdio startup input exceeded ${this.maxBufferSize} bytes`));
+        }
+      };
+      onStdinError = (error40) => {
+        this.fail(error40);
+      };
+      onStdinEnd = () => {
+        this.stdinEnded = true;
+        if (this.ready) this.finishInput();
+      };
+      constructor(options) {
+        this.stdin = options.stdin;
+        this.stdout = options.stdout;
+        this.serverInfo = { ...options.serverInfo };
+        this.maxBufferSize = options.maxBufferSize ?? STDIO_STARTUP_GATE_MAX_BUFFER_SIZE;
+        this.onError = options.onError;
+        this.onEnd = options.onEnd;
+      }
+      start() {
+        if (this.started || this.stopped) return;
+        this.started = true;
+        this.stdin.on("data", this.onData);
+        this.stdin.on("error", this.onStdinError);
+        this.stdin.on("end", this.onStdinEnd);
+      }
+      /** Release queued messages only after StdioServerTransport has installed its listener. */
+      markReady() {
+        if (this.stopped || this.ready) return;
+        this.ready = true;
+        for (const message of this.queuedMessages) this.input.write(message);
+        this.queuedMessages.length = 0;
+        this.queuedBytes = 0;
+        if (this.pendingInput) {
+          this.input.write(this.pendingInput);
+          this.pendingInput = "";
+        }
+        if (this.stdinEnded) this.finishInput();
+      }
+      stop() {
+        if (this.stopped) return;
+        this.stopped = true;
+        this.stdin.off("data", this.onData);
+        this.stdin.off("error", this.onStdinError);
+        this.stdin.off("end", this.onStdinEnd);
+        this.queuedMessages.length = 0;
+        this.pendingInput = "";
+        this.queuedBytes = 0;
+        if (!this.input.destroyed) this.input.end();
+      }
+      handleLine(line) {
+        const parsed = this.parseLine(line);
+        if (!parsed) return;
+        if ("error" in parsed) {
+          this.writeJsonRpcError(null, parsed.error.code, parsed.error.message);
+          return;
+        }
+        if (!this.ready && this.isDiscoveryRequest(parsed.message)) {
+          const response = {
+            jsonrpc: "2.0",
+            id: parsed.message.id,
+            result: createMcpStartupDiscoverResult(this.serverInfo)
+          };
+          try {
+            this.stdout.write(`${JSON.stringify(response)}
+`);
+          } catch (error40) {
+            this.fail(error40 instanceof Error ? error40 : new Error(String(error40)));
+          }
+          return;
+        }
+        if (this.ready) {
+          this.input.write(line);
+          return;
+        }
+        const bytes = Buffer.byteLength(line, "utf8");
+        if (this.queuedBytes + bytes > this.maxBufferSize) {
+          this.fail(new Error(`stdio startup queue exceeded ${this.maxBufferSize} bytes`));
+          return;
+        }
+        this.queuedMessages.push(line);
+        this.queuedBytes += bytes;
+      }
+      parseLine(line) {
+        const trimmed = line.endsWith("\n") ? line.slice(0, -1).replace(/\r$/, "") : line;
+        if (!trimmed.trim()) return null;
+        let value;
+        try {
+          value = JSON.parse(trimmed);
+        } catch {
+          return { error: { code: -32700, message: "Parse error" } };
+        }
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+          return { error: { code: -32600, message: "Invalid Request" } };
+        }
+        const message = value;
+        if (message.jsonrpc !== "2.0") {
+          return { error: { code: -32600, message: "Invalid Request" } };
+        }
+        const hasId = Object.prototype.hasOwnProperty.call(message, "id");
+        const hasMethod = typeof message.method === "string";
+        const hasResult = Object.prototype.hasOwnProperty.call(message, "result");
+        const hasError = Object.prototype.hasOwnProperty.call(message, "error");
+        if (hasMethod && (hasResult || hasError)) {
+          return { error: { code: -32600, message: "Invalid Request" } };
+        }
+        if (!hasMethod && !hasResult && !hasError) {
+          return { error: { code: -32600, message: "Invalid Request" } };
+        }
+        if (hasId && !this.isValidRequestId(message.id)) {
+          return { error: { code: -32600, message: "Invalid Request" } };
+        }
+        if (!hasMethod && !hasId) {
+          return { error: { code: -32600, message: "Invalid Request" } };
+        }
+        return { message };
+      }
+      isDiscoveryRequest(message) {
+        if (message.method !== MCP_SERVER_DISCOVER_METHOD) return false;
+        if (!Object.prototype.hasOwnProperty.call(message, "id")) return false;
+        const params = message.params;
+        return params === void 0 || typeof params === "object" && params !== null && !Array.isArray(params);
+      }
+      isValidRequestId(id) {
+        return id === null || typeof id === "string" || typeof id === "number" && Number.isFinite(id);
+      }
+      writeJsonRpcError(id, code, message) {
+        try {
+          this.stdout.write(`${JSON.stringify({
+            jsonrpc: "2.0",
+            id,
+            error: { code, message }
+          })}
+`);
+        } catch (error40) {
+          this.fail(error40 instanceof Error ? error40 : new Error(String(error40)));
+        }
+      }
+      finishInput() {
+        if (!this.ready || this.input.destroyed || this.input.writableEnded) return;
+        this.input.end();
+        this.input.once("end", () => this.notifyEnd());
+      }
+      notifyEnd() {
+        if (this.endNotified) return;
+        this.endNotified = true;
+        this.onEnd?.();
+      }
+      fail(error40) {
+        if (this.stopped) return;
+        this.stopped = true;
+        this.stdin.off("data", this.onData);
+        this.stdin.off("error", this.onStdinError);
+        this.stdin.off("end", this.onStdinEnd);
+        this.queuedMessages.length = 0;
+        this.pendingInput = "";
+        this.queuedBytes = 0;
+        if (!this.input.destroyed) this.input.destroy();
+        this.onError?.(error40);
+      }
+    };
+  }
+});
+
 // src/cli/mcp-root-path.ts
 import path37 from "path";
 function mcpFileUriToPath(uri, platform2 = process.platform) {
@@ -218992,6 +219462,33 @@ var init_request_context = __esm({
   }
 });
 
+// src/server/mcp-compat.ts
+function buildMcpDiscoverResult(server, serverInfo) {
+  const getCapabilities = server.server.getCapabilities.bind(server.server);
+  return createMcpDiscoverResult(getCapabilities(), serverInfo);
+}
+function registerMcpDiscovery(server, serverInfo) {
+  if (registeredServers.has(server)) return;
+  server.server.setRequestHandler(ServerDiscoverRequestSchema, async () => buildMcpDiscoverResult(server, serverInfo));
+  registeredServers.add(server);
+}
+var ServerDiscoverRequestSchema, registeredServers;
+var init_mcp_compat = __esm({
+  "src/server/mcp-compat.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_types8();
+    init_v4();
+    init_mcp_discovery();
+    init_mcp_discovery();
+    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 +219775,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 +261868,9 @@ The path should point to a directory containing a .git folder.`
       isError: true
     };
   };
-  const server = existingServer ?? new McpServer({
-    name: "memorix",
-    version: true ? "1.8.1" : "1.0.1"
-  });
+  const serverInfo = getMcpServerInfo();
+  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 +266248,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;
@@ -266106,6 +266604,8 @@ var init_serve = __esm({
     init_esm_shims();
     init_dist2();
     init_tool_profile();
+    init_mcp_discovery();
+    init_stdio_startup_gate();
     init_mcp_root_path();
     serve_default = defineCommand({
       meta: {
@@ -266130,15 +266630,25 @@ var init_serve = __esm({
         }
       },
       run: async ({ args }) => {
+        const startupGate = new StdioStartupGate({
+          stdin: process.stdin,
+          stdout: process.stdout,
+          serverInfo: getMcpServerInfo(),
+          onError: (error40) => {
+            console.error(`[memorix] stdio startup gate error: ${error40.message}`);
+            process.exit(1);
+          },
+          onEnd: () => {
+            console.error("[memorix] stdin closed \u2014 exiting");
+            process.exitCode = 0;
+          }
+        });
+        startupGate.start();
         const { StdioServerTransport: StdioServerTransport2 } = await Promise.resolve().then(() => (init_stdio2(), stdio_exports));
         const { createMemorixServer: createMemorixServer2 } = await Promise.resolve().then(() => (init_server4(), server_exports2));
         const { detectProject: detectProject2, findGitInSubdirs: findGitInSubdirs2, isSystemDirectory: isSystemDirectory2 } = await Promise.resolve().then(() => (init_detector(), detector_exports));
         const { homedir: homedir36 } = await import("os");
         const { resolveServeProject: resolveServeProject2 } = await Promise.resolve().then(() => (init_serve_shared(), serve_shared_exports));
-        process.stdin.on("end", () => {
-          console.error("[memorix] stdin closed \u2014 exiting");
-          process.exit(0);
-        });
         let safeCwd;
         try {
           safeCwd = process.cwd();
@@ -266173,8 +266683,9 @@ var init_serve = __esm({
         const toolProfile = resolveToolProfile({ explicit: args.mode, envValue: process.env.MEMORIX_MODE, fallback: "micro" });
         const serverOptions = detected ? { toolProfile, deferProjectRuntimeInit: true } : { allowUntrackedFallback: allowUntracked, deferProjectInitUntilBound: !allowUntracked, deferProjectRuntimeInit: true, toolProfile };
         const { server, projectId, deferredInit, switchProject } = await createMemorixServer2(projectRoot, void 0, void 0, serverOptions);
-        const transport = new StdioServerTransport2();
+        const transport = new StdioServerTransport2(startupGate.input, process.stdout);
         await server.connect(transport);
+        startupGate.markReady();
         console.error(`[memorix] MCP Server running on stdio (project: ${projectId})`);
         console.error(`[memorix] Project root: ${detected?.rootPath ?? projectRoot}`);
         const tryRootsSwitch = async () => {
@@ -266232,13 +266743,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 +266764,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 +269008,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 +269295,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 +269359,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;