memorix 1.8.4 → 1.8.5

package/dist/index.js

@@ -156854,17 +156854,25 @@ function resolveToolProfile(opts) {
   return normalize(opts.explicit) ?? normalize(opts.envValue) ?? opts.fallback;
 }
 function describeProfile(profile) {
+  const count2 = countToolsInProfile(profile);
   switch (profile) {
     case "micro":
-      return "micro (agent-ready context + bounded recovery/media, ~9 tools)";
+      return `micro (agent-ready context + bounded recovery/media, ${count2} tools)`;
     case "lite":
-      return "lite (core memory + sessions, ~18 tools)";
+      return `lite (core memory + sessions, ${count2} tools)`;
     case "team":
-      return "team (lite + coordination tools + dashboard + knowledge workspace, ~26 tools)";
+      return `team (lite + coordination tools + dashboard + knowledge workspace, ${count2} tools)`;
     case "full":
-      return "full (all tools including advanced / KG-compat)";
+      return `full (all tools including advanced / KG-compat, ${count2} tools)`;
   }
 }
+function countToolsInProfile(profile) {
+  let n = 0;
+  for (const name of Object.keys(TOOL_PROFILES)) {
+    if (isToolInProfile(name, profile)) n++;
+  }
+  return n;
+}
 var TOOL_PROFILES;
 var init_tool_profile = __esm({
   "src/server/tool-profile.ts"() {
@@ -158121,7 +158129,7 @@ var init_request_context = __esm({
 function getMcpServerInfo() {
   return {
     name: "memorix",
-    version: true ? "1.8.4" : "1.0.1"
+    version: true ? "1.8.5" : "1.0.1"
   };
 }
 function createMcpDiscoverResult(capabilities, serverInfo) {
@@ -166530,6 +166538,9 @@ var init_official_skills = __esm({
           '| Specific past decision, bug, file, or change | `memorix_search` | `memorix memory search --query "<topic>"` |',
           "| Need the full source for a search hit | `memorix_detail` | `memorix memory detail --id <id>` |",
           "| Need the sequence around one memory | `memorix_timeline` | `memorix memory timeline --id <id>` |",
+          "| Check source and freshness for a memory | `memorix_evidence` | `memorix evidence list|get|events` |",
+          "| Record whether a memory helped, conflicted, or was corrected | `memorix_feedback` | `memorix feedback record|show|audit` |",
+          "| Inspect or import controlled media | `memorix_media` | `memorix media import|attach|list|show|status` |",
           '| Learned reusable project knowledge | `memorix_store` | `memorix memory store --type <type> --entity <name> --title "<title>" "<text>"` |',
           "| Task or bug is complete/outdated | `memorix_resolve` | `memorix memory resolve --ids <ids>` |",
           "",
@@ -166660,6 +166671,8 @@ var init_official_skills = __esm({
           "",
           "Promote memories into mini-skills only when they are reusable instructions, not just historical notes.",
           "",
+          "The standard setup uses the `lite` MCP profile. `memorix_skills` and `memorix_promote` are full-profile tools, so use the CLI fallback unless the current server was explicitly started with `MEMORIX_MODE=full` or `--mode full`. Do not probe hidden MCP tools repeatedly.",
+          "",
           "## Tool Router",
           "",
           "| Situation | Prefer | CLI fallback |",
@@ -166695,15 +166708,17 @@ var init_official_skills = __esm({
           "| Situation | Prefer | CLI fallback |",
           "|---|---|---|",
           '| Run managed subagent execution | CLI | `memorix orchestrate --goal "<goal>" --agents claude:1,codex:1` |',
-          "| Register coordination identity | `team_manage` action `join` | `memorix team join --agentType <agent>` |",
-          "| Create or inspect tasks | `team_task` | `memorix task create|list|claim|complete` |",
-          "| Send or read coordination messages | `team_message` | `memorix message send|broadcast|inbox` |",
-          "| Share structured handoff | `memorix_handoff` | `memorix handoff send` |",
-          "| Avoid file conflicts | `team_file_lock` | `memorix lock lock|unlock|status` |",
-          "| Poll joined coordination state | `memorix_poll` | `memorix poll` |",
+          "| Register coordination identity when team MCP tools are available | `team_manage` action `join` | `memorix team join --agentType <agent>` |",
+          "| Create or inspect tasks when team MCP tools are available | `team_task` | `memorix task create|list|claim|complete` |",
+          "| Send or read coordination messages when team MCP tools are available | `team_message` | `memorix message send|broadcast|inbox` |",
+          "| Share structured handoff when team MCP tools are available | `memorix_handoff` | `memorix handoff send` |",
+          "| Avoid file conflicts when team MCP tools are available | `team_file_lock` | `memorix lock lock|unlock|status` |",
+          "| Poll joined coordination state when team MCP tools are available | `memorix_poll` | `memorix poll` |",
           "",
           "## Boundaries",
           "",
+          "The standard setup uses the `lite` MCP profile. Coordination MCP tools are exposed only by `team` or `full`; use the CLI fallback for ordinary installations, or explicitly start the server with `--mode team`. Do not probe unavailable team tools in a loop.",
+          "",
           "- For ordinary memory, do not join coordination state.",
           "- For production multi-agent execution, prefer `memorix orchestrate` so the main process owns planning, dispatch, retries, and verification gates.",
           "- `memorix orchestrate` uses the current checkout for single-worker runs and task worktrees for parallel runs. Use `--isolated` to force worktree isolation, `--no-worktree` to disable it, `--allow-dirty` to run with uncommitted changes, and `--no-auto-merge` to preserve task worktrees for manual review.",
@@ -167867,7 +167882,10 @@ alwaysApply: true
     "| `memorix_store` | Save something worth persisting |",
     '| `memorix_store_reasoning` | Save the "why" behind a decision |',
     "| `memorix_resolve` | Mark completed/outdated memories |",
-    "| `memorix_session_start` | Load session context (handoff, orchestration coordination) |"
+    "| `memorix_session_start` | Load session context (handoff, orchestration coordination) |",
+    "| `memorix_evidence` | Check a memory source, freshness, and verification state |",
+    "| `memorix_feedback` | Record whether a memory helped, conflicted, or was corrected |",
+    "| `memorix_media` | Inspect or import controlled local media |"
   ].join("\n");
 }
 async function uninstallHooks(agent, projectRoot, global2 = false) {
@@ -172907,7 +172925,17 @@ var init_stdio_startup_gate = __esm({
             this.fail(new Error(`stdio input chunk exceeded ${this.maxBufferSize} bytes`));
             return;
           }
-          this.input.write(chunk);
+          this.pendingInput += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+          let newline2 = this.pendingInput.indexOf("\n");
+          while (newline2 >= 0 && !this.stopped) {
+            const line = this.pendingInput.slice(0, newline2 + 1);
+            this.pendingInput = this.pendingInput.slice(newline2 + 1);
+            this.handleReadyLine(line);
+            newline2 = this.pendingInput.indexOf("\n");
+          }
+          if (!this.stopped && Buffer.byteLength(this.pendingInput, "utf8") > this.maxBufferSize) {
+            this.fail(new Error(`stdio input exceeded ${this.maxBufferSize} bytes`));
+          }
           return;
         }
         const text2 = typeof chunk === "string" ? chunk : chunk.toString("utf8");
@@ -173006,6 +173034,24 @@ var init_stdio_startup_gate = __esm({
         this.queuedMessages.push(line);
         this.queuedBytes += bytes;
       }
+      handleReadyLine(line) {
+        const parsed = this.parseLine(line);
+        if (parsed && !("error" in parsed) && 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;
+        }
+        this.input.write(line);
+      }
       parseLine(line) {
         const trimmed = line.endsWith("\n") ? line.slice(0, -1).replace(/\r$/, "") : line;
         if (!trimmed.trim()) return null;
@@ -173044,7 +173090,8 @@ var init_stdio_startup_gate = __esm({
         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);
+        if (params === void 0) return true;
+        return typeof params === "object" && params !== null && !Array.isArray(params) && !Object.prototype.hasOwnProperty.call(params, "_meta");
       }
       isValidRequestId(id) {
         return id === null || typeof id === "string" || typeof id === "number" && Number.isFinite(id);
@@ -173123,6 +173170,81 @@ var init_mcp_root_path = __esm({
   }
 });
 
+// src/server/modern-mcp-bridge.ts
+var modern_mcp_bridge_exports = {};
+__export(modern_mcp_bridge_exports, {
+  createModernMcpBridge: () => createModernMcpBridge
+});
+import {
+  fromJsonSchema,
+  McpServer as ModernMcpServer
+} from "@modelcontextprotocol/server";
+import { Client as LegacyClient } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport as LegacyInMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+async function createModernMcpBridge(options) {
+  const { createMemorixServer: createMemorixServer2 } = await Promise.resolve().then(() => (init_server2(), server_exports2));
+  const legacy = await createMemorixServer2(
+    options.projectRoot,
+    void 0,
+    void 0,
+    {
+      ...options,
+      allowUntrackedFallback: options.allowUntrackedFallback ?? false,
+      deferProjectInitUntilBound: options.deferProjectInitUntilBound ?? true,
+      deferProjectRuntimeInit: options.deferProjectRuntimeInit ?? true
+    }
+  );
+  const [clientTransport, serverTransport] = LegacyInMemoryTransport.createLinkedPair();
+  const legacyClient = new LegacyClient({
+    name: "memorix-modern-bridge",
+    version: getMcpServerInfo().version
+  });
+  await legacy.server.connect(serverTransport);
+  await legacyClient.connect(clientTransport);
+  const listed = await legacyClient.listTools();
+  const modern = new ModernMcpServer(getMcpServerInfo());
+  for (const tool of listed.tools) {
+    modern.registerTool(
+      tool.name,
+      {
+        ...tool.title ? { title: tool.title } : {},
+        ...tool.description ? { description: tool.description } : {},
+        inputSchema: fromJsonSchema(tool.inputSchema)
+      },
+      async (args) => await legacyClient.callTool({
+        name: tool.name,
+        arguments: args
+      })
+    );
+  }
+  const bridge = modern;
+  bridge.memorix = {
+    projectId: legacy.projectId,
+    deferredInit: legacy.deferredInit,
+    switchProject: legacy.switchProject,
+    isExplicitlyBound: legacy.isExplicitlyBound,
+    handleTransportClose: legacy.handleTransportClose
+  };
+  let closed = false;
+  const modernClose = modern.close.bind(modern);
+  modern.close = async () => {
+    if (closed) return;
+    closed = true;
+    await modernClose();
+    await legacyClient.close().catch(() => void 0);
+    await legacy.server.close().catch(() => void 0);
+    legacy.handleTransportClose();
+  };
+  return bridge;
+}
+var init_modern_mcp_bridge = __esm({
+  "src/server/modern-mcp-bridge.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_mcp_discovery();
+  }
+});
+
 // src/cli/commands/serve-shared.ts
 var serve_shared_exports = {};
 __export(serve_shared_exports, {
@@ -173231,7 +173353,7 @@ var init_serve_shared = __esm({
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.8.4" : pkg.version;
+  return true ? "1.8.5" : pkg.version;
 }
 var init_version3 = __esm({
   "src/cli/version.ts"() {
@@ -173487,6 +173609,14 @@ var init_serve = __esm({
         }
       },
       run: async ({ args }) => {
+        const { serveStdio, StdioServerTransport } = await import("@modelcontextprotocol/server/stdio");
+        const { createModernMcpBridge: createModernMcpBridge2 } = await Promise.resolve().then(() => (init_modern_mcp_bridge(), modern_mcp_bridge_exports));
+        const { detectProject: detectProject2, findGitInSubdirs: findGitInSubdirs2, isSystemDirectory: isSystemDirectory2 } = await Promise.resolve().then(() => (init_detector(), detector_exports));
+        const { homedir: homedir27 } = await import("os");
+        const { writeLastProjectRoot: writeLastProjectRoot2 } = await Promise.resolve().then(() => (init_launch_root(), launch_root_exports));
+        const { resolveServeProject: resolveServeProject2 } = await Promise.resolve().then(() => (init_serve_shared(), serve_shared_exports));
+        let stdioHandle;
+        let stdinEndedBeforeHandle = false;
         const startupGate = new StdioStartupGate({
           stdin: process.stdin,
           stdout: process.stdout,
@@ -173496,16 +173626,17 @@ var init_serve = __esm({
             process.exit(1);
           },
           onEnd: () => {
-            console.error("[memorix] stdin closed \u2014 exiting");
-            process.exitCode = 0;
+            console.error("[memorix] stdin closed - exiting");
+            if (stdioHandle) {
+              void stdioHandle.close().catch((error) => {
+                console.error(`[memorix] stdio close error: ${error instanceof Error ? error.message : String(error)}`);
+              });
+            } else {
+              stdinEndedBeforeHandle = true;
+            }
           }
         });
         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));
         let safeCwd;
         try {
           safeCwd = process.cwd();
@@ -173522,70 +173653,82 @@ var init_serve = __esm({
           },
           { detectProject: detectProject2, findGitInSubdirs: findGitInSubdirs2, isSystemDirectory: isSystemDirectory2 }
         );
-        for (const message of resolution.messages) {
-          console.error(message);
-        }
+        for (const message of resolution.messages) console.error(message);
         if (!resolution.detectedProject) {
           console.error(`[memorix] [WARN] ${resolution.error}`);
-          console.error(`[memorix] Starting in deferred-binding mode \u2014 project will bind via MCP roots or memorix_session_start.`);
-          console.error(`[memorix] For non-git directories, use --allow-untracked to enable untracked/ fallback.`);
+          console.error("[memorix] Starting in deferred-binding mode - bind with memorix_session_start(projectRoot=...) when needed.");
+          console.error("[memorix] For non-git directories, use --allow-untracked to enable untracked/ fallback.");
         }
         const detected = resolution.detectedProject;
         const projectRoot = resolution.projectRoot;
-        if (detected) {
-          const { writeLastProjectRoot: writeLastProjectRoot2 } = await Promise.resolve().then(() => (init_launch_root(), launch_root_exports));
-          writeLastProjectRoot2(detected.rootPath);
-        }
+        if (detected) writeLastProjectRoot2(detected.rootPath);
         const allowUntracked = args["allow-untracked"] ?? false;
-        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 toolProfile = resolveToolProfile({
+          explicit: args.mode,
+          envValue: process.env.MEMORIX_MODE,
+          fallback: "micro"
+        });
         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 () => {
-          try {
-            const { roots } = await server.server.listRoots();
-            if (!roots || roots.length === 0) return;
-            for (const root of roots) {
-              if (!root.uri.startsWith("file://")) continue;
-              const rootPath = mcpFileUriToPath(root.uri);
-              if (!rootPath) continue;
-              const rootDetected = detectProject2(rootPath);
-              if (rootDetected) {
-                const switched = await switchProject(rootPath);
+        const createBridge = async () => {
+          const bridge = await createModernMcpBridge2({
+            projectRoot,
+            allowUntrackedFallback: allowUntracked,
+            deferProjectInitUntilBound: !allowUntracked,
+            deferProjectRuntimeInit: true,
+            toolProfile
+          });
+          const tryRootsSwitch = async () => {
+            try {
+              if (bridge.memorix.isExplicitlyBound()) return;
+              const { roots } = await bridge.server.listRoots();
+              for (const root of roots ?? []) {
+                if (!root.uri.startsWith("file://")) continue;
+                const rootPath = mcpFileUriToPath(root.uri);
+                if (!rootPath) continue;
+                const switched = await bridge.memorix.switchProject(rootPath, "mcp-roots");
                 if (switched) {
-                  console.error(`[memorix] [UPDATED] Project updated via MCP roots: ${rootDetected.id}`);
+                  console.error(`[memorix] [UPDATED] Project updated via MCP roots: ${rootPath}`);
+                  return;
                 }
-                return;
-              }
-              const subGit = findGitInSubdirs2(rootPath);
-              if (subGit) {
-                const switched = await switchProject(subGit);
-                if (switched) {
+                const subGit = findGitInSubdirs2(rootPath);
+                if (subGit && await bridge.memorix.switchProject(subGit, "mcp-roots")) {
                   console.error(`[memorix] [UPDATED] Project updated via MCP roots (subdir): ${subGit}`);
+                  return;
                 }
-                return;
               }
+            } catch (error) {
+              console.error(`[memorix] MCP roots not available (${error instanceof Error ? error.message : "unsupported"})`);
             }
-          } catch (err) {
-            console.error(`[memorix] MCP roots not available (${err.message ?? "unsupported"})`);
-          }
-        };
-        try {
-          const { RootsListChangedNotificationSchema } = await import("@modelcontextprotocol/sdk/types.js");
-          server.server.setNotificationHandler(RootsListChangedNotificationSchema, async () => {
-            console.error(`[memorix] Roots changed \u2014 re-detecting project...`);
+          };
+          bridge.server.setNotificationHandler("notifications/roots/list_changed", async () => {
             await tryRootsSwitch();
           });
-        } catch {
+          const deferredInitTimer = setTimeout(() => {
+            bridge.memorix.deferredInit().catch((error) => {
+              console.error(`[memorix] Deferred init error: ${error instanceof Error ? error.message : String(error)}`);
+            });
+          }, 5e3);
+          deferredInitTimer.unref?.();
+          const originalClose = bridge.close.bind(bridge);
+          bridge.close = async () => {
+            clearTimeout(deferredInitTimer);
+            await originalClose();
+          };
+          return bridge;
+        };
+        stdioHandle = serveStdio(createBridge, {
+          transport,
+          legacy: "serve",
+          onerror: (error) => console.error(`[memorix] stdio MCP error: ${error.message}`)
+        });
+        startupGate.markReady();
+        if (stdinEndedBeforeHandle) {
+          void stdioHandle.close().catch((error) => {
+            console.error(`[memorix] stdio close error: ${error instanceof Error ? error.message : String(error)}`);
+          });
         }
-        const deferredInitTimer = setTimeout(() => {
-          deferredInit().catch((e2) => console.error(`[memorix] Deferred init error:`, e2));
-        }, 5e3);
-        deferredInitTimer.unref?.();
+        console.error(`[memorix] MCP Server running on stdio (profile: ${toolProfile}, project: ${detected?.id ?? "deferred"})`);
+        console.error(`[memorix] Project root: ${detected?.rootPath ?? projectRoot}`);
         Promise.resolve().then(() => (init_update_checker(), update_checker_exports)).then((m2) => m2.checkForUpdates()).catch(() => {
         });
       }