memorix 1.8.2 → 1.8.4

package/dist/index.js

@@ -158117,43 +158117,64 @@ var init_request_context = __esm({
   }
 });
 
-// src/server/mcp-compat.ts
-import { RequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { z as z625 } from "zod/v4";
-function buildMcpDiscoverResult(server, serverInfo) {
-  const getCapabilities = server.server.getCapabilities.bind(server.server);
+// src/server/mcp-discovery.ts
+function getMcpServerInfo() {
+  return {
+    name: "memorix",
+    version: true ? "1.8.4" : "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: getCapabilities(),
+    capabilities,
     _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.
+    // 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_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_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/mcp-compat.ts
+import { RequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { z as z625 } from "zod/v4";
+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 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 ServerDiscoverRequestSchema, registeredServers;
 var init_mcp_compat = __esm({
   "src/server/mcp-compat.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";
+    init_mcp_discovery();
+    init_mcp_discovery();
     ServerDiscoverRequestSchema = RequestSchema.extend({
       method: z625.literal(MCP_SERVER_DISCOVER_METHOD),
       params: z625.looseObject({}).optional()
@@ -168447,10 +168468,7 @@ The path should point to a directory containing a .git folder.`
       isError: true
     };
   };
-  const serverInfo = {
-    name: "memorix",
-    version: true ? "1.8.2" : "1.0.1"
-  };
+  const serverInfo = getMcpServerInfo();
   const server = existingServer ?? new McpServer(serverInfo);
   registerMcpDiscovery(server, serverInfo);
   const originalRegisterTool = server.registerTool.bind(server);
@@ -172857,6 +172875,218 @@ var init_server2 = __esm({
   }
 });
 
+// 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 = (error) => {
+        this.fail(error);
+      };
+      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 (error) {
+            this.fail(error instanceof Error ? error : new Error(String(error)));
+          }
+          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 (error) {
+          this.fail(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+      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(error) {
+        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?.(error);
+      }
+    };
+  }
+});
+
 // src/cli/mcp-root-path.ts
 import path35 from "path";
 function mcpFileUriToPath(uri, platform = process.platform) {
@@ -173001,7 +173231,7 @@ var init_serve_shared = __esm({
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.8.2" : pkg.version;
+  return true ? "1.8.4" : pkg.version;
 }
 var init_version3 = __esm({
   "src/cli/version.ts"() {
@@ -173231,6 +173461,8 @@ var init_serve = __esm({
     "use strict";
     init_esm_shims();
     init_tool_profile();
+    init_mcp_discovery();
+    init_stdio_startup_gate();
     init_mcp_root_path();
     serve_default = defineCommand({
       meta: {
@@ -173255,15 +173487,25 @@ var init_serve = __esm({
         }
       },
       run: async ({ args }) => {
+        const startupGate = new StdioStartupGate({
+          stdin: process.stdin,
+          stdout: process.stdout,
+          serverInfo: getMcpServerInfo(),
+          onError: (error) => {
+            console.error(`[memorix] stdio startup gate error: ${error.message}`);
+            process.exit(1);
+          },
+          onEnd: () => {
+            console.error("[memorix] stdin closed \u2014 exiting");
+            process.exitCode = 0;
+          }
+        });
+        startupGate.start();
         const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
         const { createMemorixServer: createMemorixServer2 } = await Promise.resolve().then(() => (init_server2(), server_exports2));
         const { detectProject: detectProject2, findGitInSubdirs: findGitInSubdirs2, isSystemDirectory: isSystemDirectory2 } = await Promise.resolve().then(() => (init_detector(), detector_exports));
         const { homedir: homedir27 } = 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();
@@ -173298,8 +173540,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 StdioServerTransport();
+        const transport = new StdioServerTransport(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 () => {

package/dist/memcode-runtime/CHANGELOG.md

@@ -4,6 +4,41 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [1.8.4] - 2026-08-27
+
+### Fixed
+- **Stateless HTTP MCP requests (#255)** -- clients such as Claude Code that
+  send the current protocol header on every request can list and call tools
+  without echoing a custom project handle. Durable handles are still created
+  on `initialize` and remain available when a client opts into them.
+- **MCP protocol self-description (#257)** -- discovery and HTTP response
+  headers now advertise the legacy revisions implemented by the pinned SDK,
+  instead of claiming complete support for the newer 2026 revision.
+- **MCP stdio smoke contract** -- the release smoke script now checks the
+  truthful advertised revision set after the compatibility fix.
+
+### MCP Compatibility
+- The 1.8.4 line supports legacy stateful MCP, versionless stdio tool calls,
+  pre-initialize discovery, and the narrow stateless HTTP compatibility path.
+  It does not claim full 2026 result metadata, Tasks, subscriptions, or list
+  caching support.
+
+## [1.8.3] - 2026-08-25
+
+### Fixed
+- **Stdio MCP startup gate** -- `memorix serve` now reads and bounds
+  newline-delimited JSON-RPC input before project initialization completes.
+  Early `server/discover` requests receive the complete discovery result, while
+  initialize, notifications, responses, and versionless tool requests replay
+  through the pinned SDK transport in input order without duplicate handling.
+
+### MCP Compatibility
+- **Stable cold-start discovery** -- real stdio CLI startup now supports
+  pre-initialize discovery within the startup window and preserves legacy
+  initialize plus versionless `tools/list`/`tools/call` behavior. Tasks,
+  subscriptions, list-response caching, and modern non-discovery result
+  metadata remain unsupported or partial.
+
 ## [1.8.2] - 2026-08-25
 
 ### Fixed

package/dist/sdk.js

@@ -167806,35 +167806,47 @@ function createProjectBindingController(projectRoot) {
 init_esm_shims();
 import { RequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { z as z625 } from "zod/v4";
-var MCP_MODERN_PROTOCOL_VERSION = "2026-07-28";
+
+// src/server/mcp-discovery.ts
+init_esm_shims();
 var MCP_LEGACY_PROTOCOL_VERSION = "2025-11-25";
 var MCP_OLDEST_LEGACY_PROTOCOL_VERSION = "2024-11-05";
 var MCP_SERVER_DISCOVER_METHOD = "server/discover";
 var MCP_SERVER_INFO_META_KEY = "io.modelcontextprotocol/serverInfo";
-var ServerDiscoverRequestSchema = RequestSchema.extend({
-  method: z625.literal(MCP_SERVER_DISCOVER_METHOD),
-  params: z625.looseObject({}).optional()
-});
-var registeredServers = /* @__PURE__ */ new WeakSet();
-function buildMcpDiscoverResult(server, serverInfo) {
-  const getCapabilities = server.server.getCapabilities.bind(server.server);
+function getMcpServerInfo() {
+  return {
+    name: "memorix",
+    version: true ? "1.8.4" : "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: getCapabilities(),
+    capabilities,
     _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.
+    // 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"
   };
 }
+
+// src/server/mcp-compat.ts
+var ServerDiscoverRequestSchema = RequestSchema.extend({
+  method: z625.literal(MCP_SERVER_DISCOVER_METHOD),
+  params: z625.looseObject({}).optional()
+});
+var registeredServers = /* @__PURE__ */ new WeakSet();
+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));
@@ -168238,10 +168250,7 @@ The path should point to a directory containing a .git folder.`
       isError: true
     };
   };
-  const serverInfo = {
-    name: "memorix",
-    version: true ? "1.8.2" : "1.0.1"
-  };
+  const serverInfo = getMcpServerInfo();
   const server = existingServer ?? new McpServer(serverInfo);
   registerMcpDiscovery(server, serverInfo);
   const originalRegisterTool = server.registerTool.bind(server);

package/docs/1.8.0-RELEASE-CANDIDATE-SPEC.md

@@ -18,12 +18,15 @@ Status: accepted implementation contract for Memorix 1.8.0.
 ## Compatibility Contract
 
 Memorix preserves the legacy 2025-era initialize contract, including stdio and
-stateful Streamable HTTP with `Mcp-Session-Id`. Memorix 1.8.2 also registers a
+stateful Streamable HTTP with `Mcp-Session-Id`. Memorix 1.8.4 also registers a
 low-level `server/discover` compatibility adapter for the 2026-07-28 request.
 Its `DiscoverResult` is complete for the required identity, versions,
 capabilities, and private zero-TTL cache hint. Versionless `tools/list` and
 `tools/call` are accepted by the pinned v1 SDK and retain its legacy result
-envelopes. HTTP stateless project handles remain a compatibility adapter: they
+envelopes. The stdio startup gate reads bounded newline-delimited input before
+project initialization, answers discovery immediately, and replays all other
+messages in order; EOF is deferred until the queued input is released. HTTP
+stateless project handles remain a compatibility adapter: they
 own project routing, but do not turn the v1 SDK into a complete 2026 runtime.
 Tasks, subscriptions, and list-response caching are unsupported and are not
 advertised or simulated.

package/docs/API_REFERENCE.md

@@ -147,14 +147,15 @@ preserved. A memory without explicit feedback keeps the legacy relevance and
 retention score. The first feedback event opts that candidate into the
 feedback projection.
 
-### HTTP MCP Compatibility
-
-Legacy clients use stateful Streamable HTTP with `Mcp-Session-Id`. Current
-Legacy clients use the 2025-era `initialize` handshake and stateful
-`Mcp-Session-Id`. The stdio server also accepts the 2026-07-28
-`server/discover` request before `initialize` and returns the required
-`DiscoverResult`. Versionless `tools/list` and `tools/call` use the pinned
-SDK's legacy result envelopes. HTTP stateless clients may use a durable
+### MCP Compatibility
+
+Legacy clients use stateful Streamable HTTP with `Mcp-Session-Id` and the
+2025-era `initialize` handshake. The 1.8.4 stdio server starts a bounded
+newline-delimited JSON-RPC gate before project initialization: it answers the
+2026-07-28 `server/discover` request before `initialize`, then replays other
+requests, notifications, and responses in order into the pinned SDK transport.
+Versionless `tools/list` and `tools/call` use the SDK's legacy result envelopes.
+HTTP stateless clients may use a durable
 `Mcp-Project-Handle`; `/protocol-diagnostics` labels this as compatibility-only.
 Modern result metadata is discovery-only with a private zero-TTL hint. Tasks,
 subscriptions, and list-response caching are unsupported. When MCP discovery

package/docs/DEVELOPMENT.md

@@ -13,8 +13,8 @@ Memorix is a TypeScript project built around:
 
 ## Current Development Baseline
 
-The current release work targets the **1.8.2 release line** and package metadata
-is kept at `1.8.2` for this release commit.
+The current release work targets the **1.8.4 release line** and package metadata
+is kept at `1.8.4` for this release commit.
 
 Contributors should assume the following areas are part of the current release line:
 
@@ -96,6 +96,7 @@ npm run test:watch
 
 ```bash
 memorix serve
+node scripts/mcp-stdio-smoke.mjs
 memorix background start
 memorix status
 ```

package/docs/README.md

@@ -94,7 +94,7 @@ The public docs are organized by user intent:
 | 1.2 honest Lite and optional semantic CodeGraph provider contract | [1.2 Provider Quality](1.2.0-PROVIDER-QUALITY.md) |
 | 1.3 long-term memory model, source boundary, and lifecycle | [1.3 Memory Architecture](1.3-MEMORY-ARCHITECTURE.md) |
 | Active context-control work | [1.2.2 Memory Control Plane](1.2.2-MEMORY-CONTROL-PLANE.md) |
-| 1.8.2 context-control and compatibility acceptance contract | [1.8.0 Release Specification](1.8.0-RELEASE-CANDIDATE-SPEC.md) |
+| 1.8.4 MCP compatibility acceptance contract | [1.8.0 Release Specification](1.8.0-RELEASE-CANDIDATE-SPEC.md) |
 | Historical cloud sync and multi-agent research | [CLOUD_SYNC_AND_MULTI_AGENT_RESEARCH.md](CLOUD_SYNC_AND_MULTI_AGENT_RESEARCH.md) |
 | Known issues and old roadmap notes | [KNOWN_ISSUES_AND_ROADMAP.md](KNOWN_ISSUES_AND_ROADMAP.md) |
 
@@ -122,7 +122,7 @@ Historical/deep-reference documents may describe older designs. If they conflict
 
 ## Current Product Line
 
-The current product line is **1.8.2**. The authoritative acceptance contract is
+The current product line is **1.8.4**. The authoritative acceptance contract is
 [1.8.0 Release Specification](1.8.0-RELEASE-CANDIDATE-SPEC.md).
 The current baseline has:
 
@@ -141,10 +141,13 @@ The current baseline has:
 - `~/.memorix/config.toml` and project `memorix.toml` are the user-facing configuration model
 - legacy `memorix.yml`, `.env`, and `config.json` files are still read for compatibility, but new setups should use TOML
 
-For MCP compatibility, 1.8.2 preserves legacy 2025-era initialize and
-stateful Streamable HTTP behavior, and adds a tested 2026-07-28
-`server/discover` adapter. Versionless `tools/list` and `tools/call` continue
-through the SDK's legacy result envelopes. Modern result metadata is limited to
-the discovery response (`ttlMs: 0`, private cache scope); Tasks, subscriptions,
-and list-response caching are unsupported. Stateless HTTP project handles are
-a compatibility adapter, not a claim of complete 2026 conformance.
+For MCP compatibility, 1.8.4 preserves legacy 2025-era initialize and
+stateful Streamable HTTP behavior. `memorix serve` starts a bounded stdio
+startup gate: pre-initialize 2026-07-28 `server/discover` is answered with a
+complete discovery result, and other early JSON-RPC messages replay in order
+through the pinned SDK transport. Versionless `tools/list` and `tools/call`
+continue through the SDK's legacy result envelopes. Modern result metadata is
+limited to the discovery response (`ttlMs: 0`, private cache scope); Tasks,
+subscriptions, and list-response caching are unsupported. Stateless HTTP
+project handles are a compatibility adapter, not a claim of complete 2026
+conformance.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "memorix",
   "mcpName": "io.github.AVIDS2/memorix",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "description": "Local-first shared memory layer for AI coding agents across MCP clients, Git history, reasoning context, and project sessions.",
   "type": "module",
   "sideEffects": false,
@@ -62,6 +62,7 @@
     "update-models": "npm --workspace @memorix/ai run update-models",
     "start": "node dist/index.js",
     "test": "vitest run --no-file-parallelism --maxWorkers=1 --minWorkers=1",
+    "test:mcp-stdio-smoke": "node scripts/mcp-stdio-smoke.mjs",
     "test:watch": "vitest",
     "test:llm-live": "MEMORIX_RUN_LIVE_LLM_TESTS=1 vitest run tests/integration/formation-llm-quality.test.ts",
     "test:e2e": "vitest run tests/e2e/",

package/plugins/antigravity/memorix/plugin.json

@@ -1,4 +1,4 @@
 {
   "name": "memorix",
-  "version": "1.8.2"
+  "version": "1.8.4"
 }

package/plugins/claude/memorix/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "memorix",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "description": "Shared workspace memory for Claude Code and other AI coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/codebuddy/memorix/.codebuddy-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "description": "Local-first project memory for CodeBuddy Code and other coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/codex/memorix/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "description": "Shared workspace memory for Codex and other AI coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/copilot/memorix/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "description": "Shared local workspace memory for GitHub Copilot CLI and other AI coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/gemini/memorix/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "mcpServers": {
     "memorix": {
       "command": "memorix",