memorix 1.8.4 → 1.8.5

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.4" : pkg.version;
+  return true ? "1.8.5" : pkg.version;
 }
 var init_version = __esm({
   "src/cli/version.ts"() {
@@ -38645,8 +38645,8 @@ var init_uploads = __esm({
     init_shims();
     checkFileSupport = () => {
       if (typeof File === "undefined") {
-        const { process: process3 } = globalThis;
-        const isOldNode = typeof process3?.versions?.node === "string" && parseInt(process3.versions.node.split(".")) < 20;
+        const { process: process2 } = globalThis;
+        const isOldNode = typeof process2?.versions?.node === "string" && parseInt(process2.versions.node.split(".")) < 20;
         throw new Error("`File` is not defined as a global, which is required for file uploads." + (isOldNode ? " Update to Node 20 LTS or newer, or set `globalThis.File` to `import('node:buffer').File`." : ""));
       }
     };
@@ -65035,8 +65035,8 @@ var init_uploads4 = __esm({
     init_shims2();
     checkFileSupport2 = () => {
       if (typeof File === "undefined") {
-        const { process: process3 } = globalThis;
-        const isOldNode = typeof process3?.versions?.node === "string" && parseInt(process3.versions.node.split(".")) < 20;
+        const { process: process2 } = globalThis;
+        const isOldNode = typeof process2?.versions?.node === "string" && parseInt(process2.versions.node.split(".")) < 20;
         throw new Error("`File` is not defined as a global, which is required for file uploads." + (isOldNode ? " Update to Node 20 LTS or newer, or set `globalThis.File` to `import('node:buffer').File`." : ""));
       }
     };
@@ -79311,15 +79311,15 @@ var require_streams = __commonJS({
     var POOL_SIZE2 = 65536;
     if (!globalThis.ReadableStream) {
       try {
-        const process3 = __require("process");
-        const { emitWarning } = process3;
+        const process2 = __require("process");
+        const { emitWarning } = process2;
         try {
-          process3.emitWarning = () => {
+          process2.emitWarning = () => {
           };
           Object.assign(globalThis, __require("stream/web"));
-          process3.emitWarning = emitWarning;
+          process2.emitWarning = emitWarning;
         } catch (error40) {
-          process3.emitWarning = emitWarning;
+          process2.emitWarning = emitWarning;
           throw error40;
         }
       } catch (error40) {
@@ -83960,7 +83960,7 @@ var require_logging_utils = __commonJS({
     exports.setBackend = setBackend;
     exports.log = log;
     var events_1 = __require("events");
-    var process3 = __importStar(__require("process"));
+    var process2 = __importStar(__require("process"));
     var util2 = __importStar(__require("util"));
     var colours_1 = require_colours();
     var LogSeverity;
@@ -84017,7 +84017,7 @@ var require_logging_utils = __commonJS({
         this.cached = /* @__PURE__ */ new Map();
         this.filters = [];
         this.filtersSet = false;
-        let nodeFlag = (_a6 = process3.env[exports.env.nodeEnables]) !== null && _a6 !== void 0 ? _a6 : "*";
+        let nodeFlag = (_a6 = process2.env[exports.env.nodeEnables]) !== null && _a6 !== void 0 ? _a6 : "*";
         if (nodeFlag === "all") {
           nodeFlag = "*";
         }
@@ -84057,7 +84057,7 @@ var require_logging_utils = __commonJS({
         return (fields, ...args) => {
           var _a6;
           const nscolour = `${colours_1.Colours.green}${namespace}${colours_1.Colours.reset}`;
-          const pid = `${colours_1.Colours.yellow}${process3.pid}${colours_1.Colours.reset}`;
+          const pid = `${colours_1.Colours.yellow}${process2.pid}${colours_1.Colours.reset}`;
           let level;
           switch (fields.severity) {
             case LogSeverity.ERROR:
@@ -84105,8 +84105,8 @@ var require_logging_utils = __commonJS({
       }
       setFilters() {
         var _a6;
-        const existingFilters = (_a6 = process3.env["NODE_DEBUG"]) !== null && _a6 !== void 0 ? _a6 : "";
-        process3.env["NODE_DEBUG"] = `${existingFilters}${existingFilters ? "," : ""}${this.filters.join(",")}`;
+        const existingFilters = (_a6 = process2.env["NODE_DEBUG"]) !== null && _a6 !== void 0 ? _a6 : "";
+        process2.env["NODE_DEBUG"] = `${existingFilters}${existingFilters ? "," : ""}${this.filters.join(",")}`;
       }
     };
     function getDebugBackend(debugPkg) {
@@ -84159,7 +84159,7 @@ var require_logging_utils = __commonJS({
     }
     function log(namespace, parent) {
       if (!cachedBackend) {
-        const enablesFlag = process3.env[exports.env.nodeEnables];
+        const enablesFlag = process2.env[exports.env.nodeEnables];
         if (!enablesFlag) {
           return exports.placeholder;
         }
@@ -111728,8 +111728,8 @@ var init_node = __esm({
     checkFileSupport3 = () => {
       var _a6;
       if (typeof File === "undefined") {
-        const { process: process3 } = globalThis;
-        const isOldNode = typeof ((_a6 = process3 === null || process3 === void 0 ? void 0 : process3.versions) === null || _a6 === void 0 ? void 0 : _a6.node) === "string" && parseInt(process3.versions.node.split(".")) < 20;
+        const { process: process2 } = globalThis;
+        const isOldNode = typeof ((_a6 = process2 === null || process2 === void 0 ? void 0 : process2.versions) === null || _a6 === void 0 ? void 0 : _a6.node) === "string" && parseInt(process2.versions.node.split(".")) < 20;
         throw new Error("`File` is not defined as a global, which is required for file uploads." + (isOldNode ? " Update to Node 20 LTS or newer, or set `globalThis.File` to `import('node:buffer').File`." : ""));
       }
     };
@@ -192804,6 +192804,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>` |",
           "",
@@ -192934,6 +192937,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 |",
@@ -192969,15 +192974,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.",
@@ -194141,7 +194148,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) {
@@ -205684,16 +205694,24 @@ function resolveToolProfile(opts) {
   return normalize(opts.explicit) ?? normalize(opts.envValue) ?? opts.fallback;
 }
 function describeProfile(profile) {
+  const count3 = countToolsInProfile(profile);
   switch (profile) {
     case "micro":
-      return "micro (agent-ready context + bounded recovery/media, ~9 tools)";
+      return `micro (agent-ready context + bounded recovery/media, ${count3} tools)`;
     case "lite":
-      return "lite (core memory + sessions, ~18 tools)";
+      return `lite (core memory + sessions, ${count3} tools)`;
     case "team":
-      return "team (lite + coordination tools + dashboard + knowledge workspace, ~26 tools)";
+      return `team (lite + coordination tools + dashboard + knowledge workspace, ${count3} tools)`;
     case "full":
-      return "full (all tools including advanced / KG-compat)";
+      return `full (all tools including advanced / KG-compat, ${count3} tools)`;
+  }
+}
+function countToolsInProfile(profile) {
+  let n3 = 0;
+  for (const name of Object.keys(TOOL_PROFILES)) {
+    if (isToolInProfile(name, profile)) n3++;
   }
+  return n3;
 }
 var TOOL_PROFILES;
 var init_tool_profile = __esm({
@@ -205768,7 +205786,7 @@ var init_tool_profile = __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) {
@@ -205835,7 +205853,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");
@@ -205934,6 +205962,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 (error40) {
+            this.fail(error40 instanceof Error ? error40 : new Error(String(error40)));
+          }
+          return;
+        }
+        this.input.write(line);
+      }
       parseLine(line) {
         const trimmed = line.endsWith("\n") ? line.slice(0, -1).replace(/\r$/, "") : line;
         if (!trimmed.trim()) return null;
@@ -205972,7 +206018,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);
@@ -206051,6 +206098,297 @@ var init_mcp_root_path = __esm({
   }
 });
 
+// node_modules/zod/v4/mini/parse.js
+var init_parse8 = __esm({
+  "node_modules/zod/v4/mini/parse.js"() {
+    "use strict";
+    init_esm_shims();
+    init_core3();
+  }
+});
+
+// node_modules/zod/v4/mini/schemas.js
+function object2(shape, params) {
+  const def = {
+    type: "object",
+    get shape() {
+      util_exports.assignProp(this, "shape", { ...shape });
+      return this.shape;
+    },
+    ...util_exports.normalizeParams(params)
+  };
+  return new ZodMiniObject(def);
+}
+var ZodMiniType, ZodMiniObject;
+var init_schemas4 = __esm({
+  "node_modules/zod/v4/mini/schemas.js"() {
+    "use strict";
+    init_esm_shims();
+    init_core3();
+    init_core3();
+    init_parse8();
+    ZodMiniType = /* @__PURE__ */ $constructor("ZodMiniType", (inst, def) => {
+      if (!inst._zod)
+        throw new Error("Uninitialized schema in ZodMiniType.");
+      $ZodType.init(inst, def);
+      inst.def = def;
+      inst.parse = (data, params) => parse2(inst, data, params, { callee: inst.parse });
+      inst.safeParse = (data, params) => safeParse(inst, data, params);
+      inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
+      inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
+      inst.check = (...checks) => {
+        return inst.clone(
+          {
+            ...def,
+            checks: [
+              ...def.checks ?? [],
+              ...checks.map((ch2) => typeof ch2 === "function" ? { _zod: { check: ch2, def: { check: "custom" }, onattach: [] } } : ch2)
+            ]
+          }
+          // { parent: true }
+        );
+      };
+      inst.clone = (_def, params) => clone2(inst, _def, params);
+      inst.brand = () => inst;
+      inst.register = ((reg, meta) => {
+        reg.add(inst, meta);
+        return inst;
+      });
+    });
+    ZodMiniObject = /* @__PURE__ */ $constructor("ZodMiniObject", (inst, def) => {
+      $ZodObject.init(inst, def);
+      ZodMiniType.init(inst, def);
+      util_exports.defineLazy(inst, "shape", () => def.shape);
+    });
+  }
+});
+
+// node_modules/zod/v4/mini/checks.js
+var init_checks3 = __esm({
+  "node_modules/zod/v4/mini/checks.js"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// node_modules/zod/v4/mini/iso.js
+var init_iso2 = __esm({
+  "node_modules/zod/v4/mini/iso.js"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// node_modules/zod/v4/mini/coerce.js
+var init_coerce2 = __esm({
+  "node_modules/zod/v4/mini/coerce.js"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// node_modules/zod/v4/mini/external.js
+var init_external3 = __esm({
+  "node_modules/zod/v4/mini/external.js"() {
+    "use strict";
+    init_esm_shims();
+    init_core3();
+    init_parse8();
+    init_schemas4();
+    init_checks3();
+    init_core3();
+    init_locales();
+    init_iso2();
+    init_coerce2();
+  }
+});
+
+// node_modules/zod/v4/mini/index.js
+var init_mini = __esm({
+  "node_modules/zod/v4/mini/index.js"() {
+    "use strict";
+    init_esm_shims();
+    init_external3();
+  }
+});
+
+// node_modules/zod/v4-mini/index.js
+var init_v4_mini = __esm({
+  "node_modules/zod/v4-mini/index.js"() {
+    "use strict";
+    init_esm_shims();
+    init_mini();
+  }
+});
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
+function isZ4Schema(s4) {
+  const schema = s4;
+  return !!schema._zod;
+}
+function objectFromShape(shape) {
+  const values = Object.values(shape);
+  if (values.length === 0)
+    return object2({});
+  const allV4 = values.every(isZ4Schema);
+  const allV3 = values.every((s4) => !isZ4Schema(s4));
+  if (allV4)
+    return object2(shape);
+  if (allV3)
+    return objectType(shape);
+  throw new Error("Mixed Zod versions detected in object shape.");
+}
+function safeParse4(schema, data) {
+  if (isZ4Schema(schema)) {
+    const result2 = safeParse(schema, data);
+    return result2;
+  }
+  const v3Schema = schema;
+  const result = v3Schema.safeParse(data);
+  return result;
+}
+async function safeParseAsync3(schema, data) {
+  if (isZ4Schema(schema)) {
+    const result2 = await safeParseAsync(schema, data);
+    return result2;
+  }
+  const v3Schema = schema;
+  const result = await v3Schema.safeParseAsync(data);
+  return result;
+}
+function getObjectShape(schema) {
+  if (!schema)
+    return void 0;
+  let rawShape;
+  if (isZ4Schema(schema)) {
+    const v4Schema = schema;
+    rawShape = v4Schema._zod?.def?.shape;
+  } else {
+    const v3Schema = schema;
+    rawShape = v3Schema.shape;
+  }
+  if (!rawShape)
+    return void 0;
+  if (typeof rawShape === "function") {
+    try {
+      return rawShape();
+    } catch {
+      return void 0;
+    }
+  }
+  return rawShape;
+}
+function normalizeObjectSchema(schema) {
+  if (!schema)
+    return void 0;
+  if (typeof schema === "object") {
+    const asV3 = schema;
+    const asV4 = schema;
+    if (!asV3._def && !asV4._zod) {
+      const values = Object.values(schema);
+      if (values.length > 0 && values.every((v6) => typeof v6 === "object" && v6 !== null && (v6._def !== void 0 || v6._zod !== void 0 || typeof v6.parse === "function"))) {
+        return objectFromShape(schema);
+      }
+    }
+  }
+  if (isZ4Schema(schema)) {
+    const v4Schema = schema;
+    const def = v4Schema._zod?.def;
+    if (def && (def.type === "object" || def.shape !== void 0)) {
+      return schema;
+    }
+  } else {
+    const v3Schema = schema;
+    if (v3Schema.shape !== void 0) {
+      return schema;
+    }
+  }
+  return void 0;
+}
+function getDotPath(path48) {
+  if (path48.length === 0) {
+    return "object root";
+  }
+  return path48.reduce((acc, seg, index) => {
+    if (index === 0) {
+      return String(seg);
+    }
+    if (typeof seg === "number") {
+      return `${acc}[${seg}]`;
+    }
+    return `${acc}.${seg}`;
+  }, "");
+}
+function getParseErrorMessage(error40) {
+  if (error40 && typeof error40 === "object") {
+    if ("issues" in error40 && Array.isArray(error40.issues) && error40.issues.length > 0) {
+      return error40.issues.map((i4) => {
+        if (!i4.path?.length) {
+          return i4.message;
+        }
+        return `${i4.message} at ${getDotPath(i4.path)}`;
+      }).join("\n");
+    }
+    if ("message" in error40 && typeof error40.message === "string") {
+      return error40.message;
+    }
+    try {
+      return JSON.stringify(error40);
+    } catch {
+      return String(error40);
+    }
+  }
+  return String(error40);
+}
+function getSchemaDescription(schema) {
+  return schema.description;
+}
+function isSchemaOptional(schema) {
+  if (isZ4Schema(schema)) {
+    const v4Schema = schema;
+    return v4Schema._zod?.def?.type === "optional";
+  }
+  const v3Schema = schema;
+  if (typeof schema.isOptional === "function") {
+    return schema.isOptional();
+  }
+  return v3Schema._def?.typeName === "ZodOptional";
+}
+function getLiteralValue(schema) {
+  if (isZ4Schema(schema)) {
+    const v4Schema = schema;
+    const def2 = v4Schema._zod?.def;
+    if (def2) {
+      if (def2.value !== void 0)
+        return def2.value;
+      if (Array.isArray(def2.values) && def2.values.length > 0) {
+        return def2.values[0];
+      }
+    }
+  }
+  const v3Schema = schema;
+  const def = v3Schema._def;
+  if (def) {
+    if (def.value !== void 0)
+      return def.value;
+    if (Array.isArray(def.values) && def.values.length > 0) {
+      return def.values[0];
+    }
+  }
+  const directValue = schema.value;
+  if (directValue !== void 0)
+    return directValue;
+  return void 0;
+}
+var init_zod_compat = __esm({
+  "node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js"() {
+    "use strict";
+    init_esm_shims();
+    init_v3();
+    init_v4_mini();
+  }
+});
+
 // node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
 var types_exports3 = {};
 __export(types_exports3, {
@@ -207770,422 +208108,6 @@ var init_types8 = __esm({
   }
 });
 
-// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
-function deserializeMessage(line) {
-  return JSONRPCMessageSchema.parse(JSON.parse(line));
-}
-function serializeMessage(message) {
-  return JSON.stringify(message) + "\n";
-}
-var STDIO_DEFAULT_MAX_BUFFER_SIZE, ReadBuffer;
-var init_stdio = __esm({
-  "node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js"() {
-    "use strict";
-    init_esm_shims();
-    init_types8();
-    STDIO_DEFAULT_MAX_BUFFER_SIZE = 10 * 1024 * 1024;
-    ReadBuffer = class {
-      constructor(options) {
-        this._maxBufferSize = options?.maxBufferSize ?? STDIO_DEFAULT_MAX_BUFFER_SIZE;
-      }
-      append(chunk) {
-        const newSize = (this._buffer?.length ?? 0) + chunk.length;
-        if (newSize > this._maxBufferSize) {
-          this.clear();
-          throw new Error(`ReadBuffer exceeded maximum size of ${this._maxBufferSize} bytes`);
-        }
-        this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
-      }
-      readMessage() {
-        if (!this._buffer) {
-          return null;
-        }
-        const index = this._buffer.indexOf("\n");
-        if (index === -1) {
-          return null;
-        }
-        const line = this._buffer.toString("utf8", 0, index).replace(/\r$/, "");
-        this._buffer = this._buffer.subarray(index + 1);
-        return deserializeMessage(line);
-      }
-      clear() {
-        this._buffer = void 0;
-      }
-    };
-  }
-});
-
-// node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
-var stdio_exports = {};
-__export(stdio_exports, {
-  StdioServerTransport: () => StdioServerTransport
-});
-import process2 from "process";
-var StdioServerTransport;
-var init_stdio2 = __esm({
-  "node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js"() {
-    "use strict";
-    init_esm_shims();
-    init_stdio();
-    StdioServerTransport = class {
-      constructor(_stdin = process2.stdin, _stdout = process2.stdout, options) {
-        this._stdin = _stdin;
-        this._stdout = _stdout;
-        this._started = false;
-        this._ondata = (chunk) => {
-          try {
-            this._readBuffer.append(chunk);
-            this.processReadBuffer();
-          } catch (error40) {
-            this.onerror?.(error40);
-            this.close().catch(() => {
-            });
-          }
-        };
-        this._onerror = (error40) => {
-          this.onerror?.(error40);
-        };
-        this._readBuffer = new ReadBuffer({ maxBufferSize: options?.maxBufferSize });
-      }
-      /**
-       * Starts listening for messages on stdin.
-       */
-      async start() {
-        if (this._started) {
-          throw new Error("StdioServerTransport already started! If using Server class, note that connect() calls start() automatically.");
-        }
-        this._started = true;
-        this._stdin.on("data", this._ondata);
-        this._stdin.on("error", this._onerror);
-      }
-      processReadBuffer() {
-        while (true) {
-          try {
-            const message = this._readBuffer.readMessage();
-            if (message === null) {
-              break;
-            }
-            this.onmessage?.(message);
-          } catch (error40) {
-            this.onerror?.(error40);
-          }
-        }
-      }
-      async close() {
-        this._stdin.off("data", this._ondata);
-        this._stdin.off("error", this._onerror);
-        const remainingDataListeners = this._stdin.listenerCount("data");
-        if (remainingDataListeners === 0) {
-          this._stdin.pause();
-        }
-        this._readBuffer.clear();
-        this.onclose?.();
-      }
-      send(message) {
-        return new Promise((resolve6) => {
-          const json4 = serializeMessage(message);
-          if (this._stdout.write(json4)) {
-            resolve6();
-          } else {
-            this._stdout.once("drain", resolve6);
-          }
-        });
-      }
-    };
-  }
-});
-
-// node_modules/zod/v4/mini/parse.js
-var init_parse8 = __esm({
-  "node_modules/zod/v4/mini/parse.js"() {
-    "use strict";
-    init_esm_shims();
-    init_core3();
-  }
-});
-
-// node_modules/zod/v4/mini/schemas.js
-function object2(shape, params) {
-  const def = {
-    type: "object",
-    get shape() {
-      util_exports.assignProp(this, "shape", { ...shape });
-      return this.shape;
-    },
-    ...util_exports.normalizeParams(params)
-  };
-  return new ZodMiniObject(def);
-}
-var ZodMiniType, ZodMiniObject;
-var init_schemas4 = __esm({
-  "node_modules/zod/v4/mini/schemas.js"() {
-    "use strict";
-    init_esm_shims();
-    init_core3();
-    init_core3();
-    init_parse8();
-    ZodMiniType = /* @__PURE__ */ $constructor("ZodMiniType", (inst, def) => {
-      if (!inst._zod)
-        throw new Error("Uninitialized schema in ZodMiniType.");
-      $ZodType.init(inst, def);
-      inst.def = def;
-      inst.parse = (data, params) => parse2(inst, data, params, { callee: inst.parse });
-      inst.safeParse = (data, params) => safeParse(inst, data, params);
-      inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
-      inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
-      inst.check = (...checks) => {
-        return inst.clone(
-          {
-            ...def,
-            checks: [
-              ...def.checks ?? [],
-              ...checks.map((ch2) => typeof ch2 === "function" ? { _zod: { check: ch2, def: { check: "custom" }, onattach: [] } } : ch2)
-            ]
-          }
-          // { parent: true }
-        );
-      };
-      inst.clone = (_def, params) => clone2(inst, _def, params);
-      inst.brand = () => inst;
-      inst.register = ((reg, meta) => {
-        reg.add(inst, meta);
-        return inst;
-      });
-    });
-    ZodMiniObject = /* @__PURE__ */ $constructor("ZodMiniObject", (inst, def) => {
-      $ZodObject.init(inst, def);
-      ZodMiniType.init(inst, def);
-      util_exports.defineLazy(inst, "shape", () => def.shape);
-    });
-  }
-});
-
-// node_modules/zod/v4/mini/checks.js
-var init_checks3 = __esm({
-  "node_modules/zod/v4/mini/checks.js"() {
-    "use strict";
-    init_esm_shims();
-  }
-});
-
-// node_modules/zod/v4/mini/iso.js
-var init_iso2 = __esm({
-  "node_modules/zod/v4/mini/iso.js"() {
-    "use strict";
-    init_esm_shims();
-  }
-});
-
-// node_modules/zod/v4/mini/coerce.js
-var init_coerce2 = __esm({
-  "node_modules/zod/v4/mini/coerce.js"() {
-    "use strict";
-    init_esm_shims();
-  }
-});
-
-// node_modules/zod/v4/mini/external.js
-var init_external3 = __esm({
-  "node_modules/zod/v4/mini/external.js"() {
-    "use strict";
-    init_esm_shims();
-    init_core3();
-    init_parse8();
-    init_schemas4();
-    init_checks3();
-    init_core3();
-    init_locales();
-    init_iso2();
-    init_coerce2();
-  }
-});
-
-// node_modules/zod/v4/mini/index.js
-var init_mini = __esm({
-  "node_modules/zod/v4/mini/index.js"() {
-    "use strict";
-    init_esm_shims();
-    init_external3();
-  }
-});
-
-// node_modules/zod/v4-mini/index.js
-var init_v4_mini = __esm({
-  "node_modules/zod/v4-mini/index.js"() {
-    "use strict";
-    init_esm_shims();
-    init_mini();
-  }
-});
-
-// node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
-function isZ4Schema(s4) {
-  const schema = s4;
-  return !!schema._zod;
-}
-function objectFromShape(shape) {
-  const values = Object.values(shape);
-  if (values.length === 0)
-    return object2({});
-  const allV4 = values.every(isZ4Schema);
-  const allV3 = values.every((s4) => !isZ4Schema(s4));
-  if (allV4)
-    return object2(shape);
-  if (allV3)
-    return objectType(shape);
-  throw new Error("Mixed Zod versions detected in object shape.");
-}
-function safeParse4(schema, data) {
-  if (isZ4Schema(schema)) {
-    const result2 = safeParse(schema, data);
-    return result2;
-  }
-  const v3Schema = schema;
-  const result = v3Schema.safeParse(data);
-  return result;
-}
-async function safeParseAsync3(schema, data) {
-  if (isZ4Schema(schema)) {
-    const result2 = await safeParseAsync(schema, data);
-    return result2;
-  }
-  const v3Schema = schema;
-  const result = await v3Schema.safeParseAsync(data);
-  return result;
-}
-function getObjectShape(schema) {
-  if (!schema)
-    return void 0;
-  let rawShape;
-  if (isZ4Schema(schema)) {
-    const v4Schema = schema;
-    rawShape = v4Schema._zod?.def?.shape;
-  } else {
-    const v3Schema = schema;
-    rawShape = v3Schema.shape;
-  }
-  if (!rawShape)
-    return void 0;
-  if (typeof rawShape === "function") {
-    try {
-      return rawShape();
-    } catch {
-      return void 0;
-    }
-  }
-  return rawShape;
-}
-function normalizeObjectSchema(schema) {
-  if (!schema)
-    return void 0;
-  if (typeof schema === "object") {
-    const asV3 = schema;
-    const asV4 = schema;
-    if (!asV3._def && !asV4._zod) {
-      const values = Object.values(schema);
-      if (values.length > 0 && values.every((v6) => typeof v6 === "object" && v6 !== null && (v6._def !== void 0 || v6._zod !== void 0 || typeof v6.parse === "function"))) {
-        return objectFromShape(schema);
-      }
-    }
-  }
-  if (isZ4Schema(schema)) {
-    const v4Schema = schema;
-    const def = v4Schema._zod?.def;
-    if (def && (def.type === "object" || def.shape !== void 0)) {
-      return schema;
-    }
-  } else {
-    const v3Schema = schema;
-    if (v3Schema.shape !== void 0) {
-      return schema;
-    }
-  }
-  return void 0;
-}
-function getDotPath(path48) {
-  if (path48.length === 0) {
-    return "object root";
-  }
-  return path48.reduce((acc, seg, index) => {
-    if (index === 0) {
-      return String(seg);
-    }
-    if (typeof seg === "number") {
-      return `${acc}[${seg}]`;
-    }
-    return `${acc}.${seg}`;
-  }, "");
-}
-function getParseErrorMessage(error40) {
-  if (error40 && typeof error40 === "object") {
-    if ("issues" in error40 && Array.isArray(error40.issues) && error40.issues.length > 0) {
-      return error40.issues.map((i4) => {
-        if (!i4.path?.length) {
-          return i4.message;
-        }
-        return `${i4.message} at ${getDotPath(i4.path)}`;
-      }).join("\n");
-    }
-    if ("message" in error40 && typeof error40.message === "string") {
-      return error40.message;
-    }
-    try {
-      return JSON.stringify(error40);
-    } catch {
-      return String(error40);
-    }
-  }
-  return String(error40);
-}
-function getSchemaDescription(schema) {
-  return schema.description;
-}
-function isSchemaOptional(schema) {
-  if (isZ4Schema(schema)) {
-    const v4Schema = schema;
-    return v4Schema._zod?.def?.type === "optional";
-  }
-  const v3Schema = schema;
-  if (typeof schema.isOptional === "function") {
-    return schema.isOptional();
-  }
-  return v3Schema._def?.typeName === "ZodOptional";
-}
-function getLiteralValue(schema) {
-  if (isZ4Schema(schema)) {
-    const v4Schema = schema;
-    const def2 = v4Schema._zod?.def;
-    if (def2) {
-      if (def2.value !== void 0)
-        return def2.value;
-      if (Array.isArray(def2.values) && def2.values.length > 0) {
-        return def2.values[0];
-      }
-    }
-  }
-  const v3Schema = schema;
-  const def = v3Schema._def;
-  if (def) {
-    if (def.value !== void 0)
-      return def.value;
-    if (Array.isArray(def.values) && def.values.length > 0) {
-      return def.values[0];
-    }
-  }
-  const directValue = schema.value;
-  if (directValue !== void 0)
-    return directValue;
-  return void 0;
-}
-var init_zod_compat = __esm({
-  "node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js"() {
-    "use strict";
-    init_esm_shims();
-    init_v3();
-    init_v4_mini();
-  }
-});
-
 // node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js
 function isTerminal(status) {
   return status === "completed" || status === "failed" || status === "cancelled";
@@ -216239,6 +216161,783 @@ var init_ajv_provider = __esm({
   }
 });
 
+// node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/client.js
+var ExperimentalClientTasks;
+var init_client3 = __esm({
+  "node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/client.js"() {
+    "use strict";
+    init_esm_shims();
+    init_types8();
+    ExperimentalClientTasks = class {
+      constructor(_client) {
+        this._client = _client;
+      }
+      /**
+       * Calls a tool and returns an AsyncGenerator that yields response messages.
+       * The generator is guaranteed to end with either a 'result' or 'error' message.
+       *
+       * This method provides streaming access to tool execution, allowing you to
+       * observe intermediate task status updates for long-running tool calls.
+       * Automatically validates structured output if the tool has an outputSchema.
+       *
+       * @example
+       * ```typescript
+       * const stream = client.experimental.tasks.callToolStream({ name: 'myTool', arguments: {} });
+       * for await (const message of stream) {
+       *   switch (message.type) {
+       *     case 'taskCreated':
+       *       console.log('Tool execution started:', message.task.taskId);
+       *       break;
+       *     case 'taskStatus':
+       *       console.log('Tool status:', message.task.status);
+       *       break;
+       *     case 'result':
+       *       console.log('Tool result:', message.result);
+       *       break;
+       *     case 'error':
+       *       console.error('Tool error:', message.error);
+       *       break;
+       *   }
+       * }
+       * ```
+       *
+       * @param params - Tool call parameters (name and arguments)
+       * @param resultSchema - Zod schema for validating the result (defaults to CallToolResultSchema)
+       * @param options - Optional request options (timeout, signal, task creation params, etc.)
+       * @returns AsyncGenerator that yields ResponseMessage objects
+       *
+       * @experimental
+       */
+      async *callToolStream(params, resultSchema = CallToolResultSchema, options) {
+        const clientInternal = this._client;
+        const optionsWithTask = {
+          ...options,
+          // We check if the tool is known to be a task during auto-configuration, but assume
+          // the caller knows what they're doing if they pass this explicitly
+          task: options?.task ?? (clientInternal.isToolTask(params.name) ? {} : void 0)
+        };
+        const stream2 = clientInternal.requestStream({ method: "tools/call", params }, resultSchema, optionsWithTask);
+        const validator = clientInternal.getToolOutputValidator(params.name);
+        for await (const message of stream2) {
+          if (message.type === "result" && validator) {
+            const result = message.result;
+            if (!result.structuredContent && !result.isError) {
+              yield {
+                type: "error",
+                error: new McpError(ErrorCode.InvalidRequest, `Tool ${params.name} has an output schema but did not return structured content`)
+              };
+              return;
+            }
+            if (result.structuredContent) {
+              try {
+                const validationResult = validator(result.structuredContent);
+                if (!validationResult.valid) {
+                  yield {
+                    type: "error",
+                    error: new McpError(ErrorCode.InvalidParams, `Structured content does not match the tool's output schema: ${validationResult.errorMessage}`)
+                  };
+                  return;
+                }
+              } catch (error40) {
+                if (error40 instanceof McpError) {
+                  yield { type: "error", error: error40 };
+                  return;
+                }
+                yield {
+                  type: "error",
+                  error: new McpError(ErrorCode.InvalidParams, `Failed to validate structured content: ${error40 instanceof Error ? error40.message : String(error40)}`)
+                };
+                return;
+              }
+            }
+          }
+          yield message;
+        }
+      }
+      /**
+       * Gets the current status of a task.
+       *
+       * @param taskId - The task identifier
+       * @param options - Optional request options
+       * @returns The task status
+       *
+       * @experimental
+       */
+      async getTask(taskId, options) {
+        return this._client.getTask({ taskId }, options);
+      }
+      /**
+       * Retrieves the result of a completed task.
+       *
+       * @param taskId - The task identifier
+       * @param resultSchema - Zod schema for validating the result
+       * @param options - Optional request options
+       * @returns The task result
+       *
+       * @experimental
+       */
+      async getTaskResult(taskId, resultSchema, options) {
+        return this._client.getTaskResult({ taskId }, resultSchema, options);
+      }
+      /**
+       * Lists tasks with optional pagination.
+       *
+       * @param cursor - Optional pagination cursor
+       * @param options - Optional request options
+       * @returns List of tasks with optional next cursor
+       *
+       * @experimental
+       */
+      async listTasks(cursor, options) {
+        return this._client.listTasks(cursor ? { cursor } : void 0, options);
+      }
+      /**
+       * Cancels a running task.
+       *
+       * @param taskId - The task identifier
+       * @param options - Optional request options
+       *
+       * @experimental
+       */
+      async cancelTask(taskId, options) {
+        return this._client.cancelTask({ taskId }, options);
+      }
+      /**
+       * Sends a request and returns an AsyncGenerator that yields response messages.
+       * The generator is guaranteed to end with either a 'result' or 'error' message.
+       *
+       * This method provides streaming access to request processing, allowing you to
+       * observe intermediate task status updates for task-augmented requests.
+       *
+       * @param request - The request to send
+       * @param resultSchema - Zod schema for validating the result
+       * @param options - Optional request options (timeout, signal, task creation params, etc.)
+       * @returns AsyncGenerator that yields ResponseMessage objects
+       *
+       * @experimental
+       */
+      requestStream(request, resultSchema, options) {
+        return this._client.requestStream(request, resultSchema, options);
+      }
+    };
+  }
+});
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
+function assertToolsCallTaskCapability(requests, method, entityName) {
+  if (!requests) {
+    throw new Error(`${entityName} does not support task creation (required for ${method})`);
+  }
+  switch (method) {
+    case "tools/call":
+      if (!requests.tools?.call) {
+        throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
+      }
+      break;
+    default:
+      break;
+  }
+}
+function assertClientRequestTaskCapability(requests, method, entityName) {
+  if (!requests) {
+    throw new Error(`${entityName} does not support task creation (required for ${method})`);
+  }
+  switch (method) {
+    case "sampling/createMessage":
+      if (!requests.sampling?.createMessage) {
+        throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
+      }
+      break;
+    case "elicitation/create":
+      if (!requests.elicitation?.create) {
+        throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
+      }
+      break;
+    default:
+      break;
+  }
+}
+var init_helpers2 = __esm({
+  "node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/client/index.js
+function applyElicitationDefaults(schema, data) {
+  if (!schema || data === null || typeof data !== "object")
+    return;
+  if (schema.type === "object" && schema.properties && typeof schema.properties === "object") {
+    const obj = data;
+    const props = schema.properties;
+    for (const key of Object.keys(props)) {
+      const propSchema = props[key];
+      if (obj[key] === void 0 && Object.prototype.hasOwnProperty.call(propSchema, "default")) {
+        obj[key] = propSchema.default;
+      }
+      if (obj[key] !== void 0) {
+        applyElicitationDefaults(propSchema, obj[key]);
+      }
+    }
+  }
+  if (Array.isArray(schema.anyOf)) {
+    for (const sub of schema.anyOf) {
+      if (typeof sub !== "boolean") {
+        applyElicitationDefaults(sub, data);
+      }
+    }
+  }
+  if (Array.isArray(schema.oneOf)) {
+    for (const sub of schema.oneOf) {
+      if (typeof sub !== "boolean") {
+        applyElicitationDefaults(sub, data);
+      }
+    }
+  }
+}
+function getSupportedElicitationModes(capabilities) {
+  if (!capabilities) {
+    return { supportsFormMode: false, supportsUrlMode: false };
+  }
+  const hasFormCapability = capabilities.form !== void 0;
+  const hasUrlCapability = capabilities.url !== void 0;
+  const supportsFormMode = hasFormCapability || !hasFormCapability && !hasUrlCapability;
+  const supportsUrlMode = hasUrlCapability;
+  return { supportsFormMode, supportsUrlMode };
+}
+var Client;
+var init_client4 = __esm({
+  "node_modules/@modelcontextprotocol/sdk/dist/esm/client/index.js"() {
+    "use strict";
+    init_esm_shims();
+    init_protocol();
+    init_types8();
+    init_ajv_provider();
+    init_zod_compat();
+    init_client3();
+    init_helpers2();
+    Client = class extends Protocol {
+      /**
+       * Initializes this client with the given name and version information.
+       */
+      constructor(_clientInfo, options) {
+        super(options);
+        this._clientInfo = _clientInfo;
+        this._cachedToolOutputValidators = /* @__PURE__ */ new Map();
+        this._cachedKnownTaskTools = /* @__PURE__ */ new Set();
+        this._cachedRequiredTaskTools = /* @__PURE__ */ new Set();
+        this._listChangedDebounceTimers = /* @__PURE__ */ new Map();
+        this._capabilities = options?.capabilities ?? {};
+        this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator();
+        if (options?.listChanged) {
+          this._pendingListChangedConfig = options.listChanged;
+        }
+      }
+      /**
+       * Set up handlers for list changed notifications based on config and server capabilities.
+       * This should only be called after initialization when server capabilities are known.
+       * Handlers are silently skipped if the server doesn't advertise the corresponding listChanged capability.
+       * @internal
+       */
+      _setupListChangedHandlers(config2) {
+        if (config2.tools && this._serverCapabilities?.tools?.listChanged) {
+          this._setupListChangedHandler("tools", ToolListChangedNotificationSchema, config2.tools, async () => {
+            const result = await this.listTools();
+            return result.tools;
+          });
+        }
+        if (config2.prompts && this._serverCapabilities?.prompts?.listChanged) {
+          this._setupListChangedHandler("prompts", PromptListChangedNotificationSchema, config2.prompts, async () => {
+            const result = await this.listPrompts();
+            return result.prompts;
+          });
+        }
+        if (config2.resources && this._serverCapabilities?.resources?.listChanged) {
+          this._setupListChangedHandler("resources", ResourceListChangedNotificationSchema, config2.resources, async () => {
+            const result = await this.listResources();
+            return result.resources;
+          });
+        }
+      }
+      /**
+       * Access experimental features.
+       *
+       * WARNING: These APIs are experimental and may change without notice.
+       *
+       * @experimental
+       */
+      get experimental() {
+        if (!this._experimental) {
+          this._experimental = {
+            tasks: new ExperimentalClientTasks(this)
+          };
+        }
+        return this._experimental;
+      }
+      /**
+       * Registers new capabilities. This can only be called before connecting to a transport.
+       *
+       * The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization).
+       */
+      registerCapabilities(capabilities) {
+        if (this.transport) {
+          throw new Error("Cannot register capabilities after connecting to transport");
+        }
+        this._capabilities = mergeCapabilities(this._capabilities, capabilities);
+      }
+      /**
+       * Override request handler registration to enforce client-side validation for elicitation.
+       */
+      setRequestHandler(requestSchema, handler) {
+        const shape = getObjectShape(requestSchema);
+        const methodSchema = shape?.method;
+        if (!methodSchema) {
+          throw new Error("Schema is missing a method literal");
+        }
+        const methodValue = getLiteralValue(methodSchema);
+        if (typeof methodValue !== "string") {
+          throw new Error("Schema method literal must be a string");
+        }
+        const method = methodValue;
+        if (method === "elicitation/create") {
+          const wrappedHandler = async (request, extra) => {
+            const validatedRequest = safeParse4(ElicitRequestSchema, request);
+            if (!validatedRequest.success) {
+              const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+              throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation request: ${errorMessage}`);
+            }
+            const { params } = validatedRequest.data;
+            params.mode = params.mode ?? "form";
+            const { supportsFormMode, supportsUrlMode } = getSupportedElicitationModes(this._capabilities.elicitation);
+            if (params.mode === "form" && !supportsFormMode) {
+              throw new McpError(ErrorCode.InvalidParams, "Client does not support form-mode elicitation requests");
+            }
+            if (params.mode === "url" && !supportsUrlMode) {
+              throw new McpError(ErrorCode.InvalidParams, "Client does not support URL-mode elicitation requests");
+            }
+            const result = await Promise.resolve(handler(request, extra));
+            if (params.task) {
+              const taskValidationResult = safeParse4(CreateTaskResultSchema, result);
+              if (!taskValidationResult.success) {
+                const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+                throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+              }
+              return taskValidationResult.data;
+            }
+            const validationResult = safeParse4(ElicitResultSchema, result);
+            if (!validationResult.success) {
+              const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+              throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation result: ${errorMessage}`);
+            }
+            const validatedResult = validationResult.data;
+            const requestedSchema = params.mode === "form" ? params.requestedSchema : void 0;
+            if (params.mode === "form" && validatedResult.action === "accept" && validatedResult.content && requestedSchema) {
+              if (this._capabilities.elicitation?.form?.applyDefaults) {
+                try {
+                  applyElicitationDefaults(requestedSchema, validatedResult.content);
+                } catch {
+                }
+              }
+            }
+            return validatedResult;
+          };
+          return super.setRequestHandler(requestSchema, wrappedHandler);
+        }
+        if (method === "sampling/createMessage") {
+          const wrappedHandler = async (request, extra) => {
+            const validatedRequest = safeParse4(CreateMessageRequestSchema, request);
+            if (!validatedRequest.success) {
+              const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+              throw new McpError(ErrorCode.InvalidParams, `Invalid sampling request: ${errorMessage}`);
+            }
+            const { params } = validatedRequest.data;
+            const result = await Promise.resolve(handler(request, extra));
+            if (params.task) {
+              const taskValidationResult = safeParse4(CreateTaskResultSchema, result);
+              if (!taskValidationResult.success) {
+                const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+                throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+              }
+              return taskValidationResult.data;
+            }
+            const hasTools = params.tools || params.toolChoice;
+            const resultSchema = hasTools ? CreateMessageResultWithToolsSchema : CreateMessageResultSchema;
+            const validationResult = safeParse4(resultSchema, result);
+            if (!validationResult.success) {
+              const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+              throw new McpError(ErrorCode.InvalidParams, `Invalid sampling result: ${errorMessage}`);
+            }
+            return validationResult.data;
+          };
+          return super.setRequestHandler(requestSchema, wrappedHandler);
+        }
+        return super.setRequestHandler(requestSchema, handler);
+      }
+      assertCapability(capability, method) {
+        if (!this._serverCapabilities?.[capability]) {
+          throw new Error(`Server does not support ${capability} (required for ${method})`);
+        }
+      }
+      async connect(transport, options) {
+        await super.connect(transport);
+        if (transport.sessionId !== void 0) {
+          return;
+        }
+        try {
+          const result = await this.request({
+            method: "initialize",
+            params: {
+              protocolVersion: LATEST_PROTOCOL_VERSION,
+              capabilities: this._capabilities,
+              clientInfo: this._clientInfo
+            }
+          }, InitializeResultSchema, options);
+          if (result === void 0) {
+            throw new Error(`Server sent invalid initialize result: ${result}`);
+          }
+          if (!SUPPORTED_PROTOCOL_VERSIONS.includes(result.protocolVersion)) {
+            throw new Error(`Server's protocol version is not supported: ${result.protocolVersion}`);
+          }
+          this._serverCapabilities = result.capabilities;
+          this._serverVersion = result.serverInfo;
+          if (transport.setProtocolVersion) {
+            transport.setProtocolVersion(result.protocolVersion);
+          }
+          this._instructions = result.instructions;
+          await this.notification({
+            method: "notifications/initialized"
+          });
+          if (this._pendingListChangedConfig) {
+            this._setupListChangedHandlers(this._pendingListChangedConfig);
+            this._pendingListChangedConfig = void 0;
+          }
+        } catch (error40) {
+          void this.close();
+          throw error40;
+        }
+      }
+      /**
+       * After initialization has completed, this will be populated with the server's reported capabilities.
+       */
+      getServerCapabilities() {
+        return this._serverCapabilities;
+      }
+      /**
+       * After initialization has completed, this will be populated with information about the server's name and version.
+       */
+      getServerVersion() {
+        return this._serverVersion;
+      }
+      /**
+       * After initialization has completed, this may be populated with information about the server's instructions.
+       */
+      getInstructions() {
+        return this._instructions;
+      }
+      assertCapabilityForMethod(method) {
+        switch (method) {
+          case "logging/setLevel":
+            if (!this._serverCapabilities?.logging) {
+              throw new Error(`Server does not support logging (required for ${method})`);
+            }
+            break;
+          case "prompts/get":
+          case "prompts/list":
+            if (!this._serverCapabilities?.prompts) {
+              throw new Error(`Server does not support prompts (required for ${method})`);
+            }
+            break;
+          case "resources/list":
+          case "resources/templates/list":
+          case "resources/read":
+          case "resources/subscribe":
+          case "resources/unsubscribe":
+            if (!this._serverCapabilities?.resources) {
+              throw new Error(`Server does not support resources (required for ${method})`);
+            }
+            if (method === "resources/subscribe" && !this._serverCapabilities.resources.subscribe) {
+              throw new Error(`Server does not support resource subscriptions (required for ${method})`);
+            }
+            break;
+          case "tools/call":
+          case "tools/list":
+            if (!this._serverCapabilities?.tools) {
+              throw new Error(`Server does not support tools (required for ${method})`);
+            }
+            break;
+          case "completion/complete":
+            if (!this._serverCapabilities?.completions) {
+              throw new Error(`Server does not support completions (required for ${method})`);
+            }
+            break;
+          case "initialize":
+            break;
+          case "ping":
+            break;
+        }
+      }
+      assertNotificationCapability(method) {
+        switch (method) {
+          case "notifications/roots/list_changed":
+            if (!this._capabilities.roots?.listChanged) {
+              throw new Error(`Client does not support roots list changed notifications (required for ${method})`);
+            }
+            break;
+          case "notifications/initialized":
+            break;
+          case "notifications/cancelled":
+            break;
+          case "notifications/progress":
+            break;
+        }
+      }
+      assertRequestHandlerCapability(method) {
+        if (!this._capabilities) {
+          return;
+        }
+        switch (method) {
+          case "sampling/createMessage":
+            if (!this._capabilities.sampling) {
+              throw new Error(`Client does not support sampling capability (required for ${method})`);
+            }
+            break;
+          case "elicitation/create":
+            if (!this._capabilities.elicitation) {
+              throw new Error(`Client does not support elicitation capability (required for ${method})`);
+            }
+            break;
+          case "roots/list":
+            if (!this._capabilities.roots) {
+              throw new Error(`Client does not support roots capability (required for ${method})`);
+            }
+            break;
+          case "tasks/get":
+          case "tasks/list":
+          case "tasks/result":
+          case "tasks/cancel":
+            if (!this._capabilities.tasks) {
+              throw new Error(`Client does not support tasks capability (required for ${method})`);
+            }
+            break;
+          case "ping":
+            break;
+        }
+      }
+      assertTaskCapability(method) {
+        assertToolsCallTaskCapability(this._serverCapabilities?.tasks?.requests, method, "Server");
+      }
+      assertTaskHandlerCapability(method) {
+        if (!this._capabilities) {
+          return;
+        }
+        assertClientRequestTaskCapability(this._capabilities.tasks?.requests, method, "Client");
+      }
+      async ping(options) {
+        return this.request({ method: "ping" }, EmptyResultSchema, options);
+      }
+      async complete(params, options) {
+        return this.request({ method: "completion/complete", params }, CompleteResultSchema, options);
+      }
+      async setLoggingLevel(level, options) {
+        return this.request({ method: "logging/setLevel", params: { level } }, EmptyResultSchema, options);
+      }
+      async getPrompt(params, options) {
+        return this.request({ method: "prompts/get", params }, GetPromptResultSchema, options);
+      }
+      async listPrompts(params, options) {
+        return this.request({ method: "prompts/list", params }, ListPromptsResultSchema, options);
+      }
+      async listResources(params, options) {
+        return this.request({ method: "resources/list", params }, ListResourcesResultSchema, options);
+      }
+      async listResourceTemplates(params, options) {
+        return this.request({ method: "resources/templates/list", params }, ListResourceTemplatesResultSchema, options);
+      }
+      async readResource(params, options) {
+        return this.request({ method: "resources/read", params }, ReadResourceResultSchema, options);
+      }
+      async subscribeResource(params, options) {
+        return this.request({ method: "resources/subscribe", params }, EmptyResultSchema, options);
+      }
+      async unsubscribeResource(params, options) {
+        return this.request({ method: "resources/unsubscribe", params }, EmptyResultSchema, options);
+      }
+      /**
+       * Calls a tool and waits for the result. Automatically validates structured output if the tool has an outputSchema.
+       *
+       * For task-based execution with streaming behavior, use client.experimental.tasks.callToolStream() instead.
+       */
+      async callTool(params, resultSchema = CallToolResultSchema, options) {
+        if (this.isToolTaskRequired(params.name)) {
+          throw new McpError(ErrorCode.InvalidRequest, `Tool "${params.name}" requires task-based execution. Use client.experimental.tasks.callToolStream() instead.`);
+        }
+        const result = await this.request({ method: "tools/call", params }, resultSchema, options);
+        const validator = this.getToolOutputValidator(params.name);
+        if (validator) {
+          if (!result.structuredContent && !result.isError) {
+            throw new McpError(ErrorCode.InvalidRequest, `Tool ${params.name} has an output schema but did not return structured content`);
+          }
+          if (result.structuredContent) {
+            try {
+              const validationResult = validator(result.structuredContent);
+              if (!validationResult.valid) {
+                throw new McpError(ErrorCode.InvalidParams, `Structured content does not match the tool's output schema: ${validationResult.errorMessage}`);
+              }
+            } catch (error40) {
+              if (error40 instanceof McpError) {
+                throw error40;
+              }
+              throw new McpError(ErrorCode.InvalidParams, `Failed to validate structured content: ${error40 instanceof Error ? error40.message : String(error40)}`);
+            }
+          }
+        }
+        return result;
+      }
+      isToolTask(toolName) {
+        if (!this._serverCapabilities?.tasks?.requests?.tools?.call) {
+          return false;
+        }
+        return this._cachedKnownTaskTools.has(toolName);
+      }
+      /**
+       * Check if a tool requires task-based execution.
+       * Unlike isToolTask which includes 'optional' tools, this only checks for 'required'.
+       */
+      isToolTaskRequired(toolName) {
+        return this._cachedRequiredTaskTools.has(toolName);
+      }
+      /**
+       * Cache validators for tool output schemas.
+       * Called after listTools() to pre-compile validators for better performance.
+       */
+      cacheToolMetadata(tools) {
+        this._cachedToolOutputValidators.clear();
+        this._cachedKnownTaskTools.clear();
+        this._cachedRequiredTaskTools.clear();
+        for (const tool of tools) {
+          if (tool.outputSchema) {
+            const toolValidator = this._jsonSchemaValidator.getValidator(tool.outputSchema);
+            this._cachedToolOutputValidators.set(tool.name, toolValidator);
+          }
+          const taskSupport = tool.execution?.taskSupport;
+          if (taskSupport === "required" || taskSupport === "optional") {
+            this._cachedKnownTaskTools.add(tool.name);
+          }
+          if (taskSupport === "required") {
+            this._cachedRequiredTaskTools.add(tool.name);
+          }
+        }
+      }
+      /**
+       * Get cached validator for a tool
+       */
+      getToolOutputValidator(toolName) {
+        return this._cachedToolOutputValidators.get(toolName);
+      }
+      async listTools(params, options) {
+        const result = await this.request({ method: "tools/list", params }, ListToolsResultSchema, options);
+        this.cacheToolMetadata(result.tools);
+        return result;
+      }
+      /**
+       * Set up a single list changed handler.
+       * @internal
+       */
+      _setupListChangedHandler(listType, notificationSchema, options, fetcher) {
+        const parseResult = ListChangedOptionsBaseSchema.safeParse(options);
+        if (!parseResult.success) {
+          throw new Error(`Invalid ${listType} listChanged options: ${parseResult.error.message}`);
+        }
+        if (typeof options.onChanged !== "function") {
+          throw new Error(`Invalid ${listType} listChanged options: onChanged must be a function`);
+        }
+        const { autoRefresh, debounceMs } = parseResult.data;
+        const { onChanged } = options;
+        const refresh = async () => {
+          if (!autoRefresh) {
+            onChanged(null, null);
+            return;
+          }
+          try {
+            const items = await fetcher();
+            onChanged(null, items);
+          } catch (e5) {
+            const error40 = e5 instanceof Error ? e5 : new Error(String(e5));
+            onChanged(error40, null);
+          }
+        };
+        const handler = () => {
+          if (debounceMs) {
+            const existingTimer = this._listChangedDebounceTimers.get(listType);
+            if (existingTimer) {
+              clearTimeout(existingTimer);
+            }
+            const timer = setTimeout(refresh, debounceMs);
+            this._listChangedDebounceTimers.set(listType, timer);
+          } else {
+            refresh();
+          }
+        };
+        this.setNotificationHandler(notificationSchema, handler);
+      }
+      async sendRootsListChanged() {
+        return this.notification({ method: "notifications/roots/list_changed" });
+      }
+    };
+  }
+});
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/inMemory.js
+var InMemoryTransport;
+var init_inMemory = __esm({
+  "node_modules/@modelcontextprotocol/sdk/dist/esm/inMemory.js"() {
+    "use strict";
+    init_esm_shims();
+    InMemoryTransport = class _InMemoryTransport {
+      constructor() {
+        this._messageQueue = [];
+      }
+      /**
+       * Creates a pair of linked in-memory transports that can communicate with each other. One should be passed to a Client and one to a Server.
+       */
+      static createLinkedPair() {
+        const clientTransport = new _InMemoryTransport();
+        const serverTransport = new _InMemoryTransport();
+        clientTransport._otherTransport = serverTransport;
+        serverTransport._otherTransport = clientTransport;
+        return [clientTransport, serverTransport];
+      }
+      async start() {
+        while (this._messageQueue.length > 0) {
+          const queuedMessage = this._messageQueue.shift();
+          this.onmessage?.(queuedMessage.message, queuedMessage.extra);
+        }
+      }
+      async close() {
+        const other = this._otherTransport;
+        this._otherTransport = void 0;
+        await other?.close();
+        this.onclose?.();
+      }
+      /**
+       * Sends a message with optional auth info.
+       * This is useful for testing authentication scenarios.
+       */
+      async send(message, options) {
+        if (!this._otherTransport) {
+          throw new Error("Not connected");
+        }
+        if (this._otherTransport.onmessage) {
+          this._otherTransport.onmessage(message, { authInfo: options?.authInfo });
+        } else {
+          this._otherTransport._messageQueue.push({ message, extra: { authInfo: options?.authInfo } });
+        }
+      }
+    };
+  }
+});
+
 // node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js
 var ExperimentalServerTasks;
 var init_server = __esm({
@@ -216460,47 +217159,6 @@ var init_server = __esm({
   }
 });
 
-// node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
-function assertToolsCallTaskCapability(requests, method, entityName) {
-  if (!requests) {
-    throw new Error(`${entityName} does not support task creation (required for ${method})`);
-  }
-  switch (method) {
-    case "tools/call":
-      if (!requests.tools?.call) {
-        throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
-      }
-      break;
-    default:
-      break;
-  }
-}
-function assertClientRequestTaskCapability(requests, method, entityName) {
-  if (!requests) {
-    throw new Error(`${entityName} does not support task creation (required for ${method})`);
-  }
-  switch (method) {
-    case "sampling/createMessage":
-      if (!requests.sampling?.createMessage) {
-        throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
-      }
-      break;
-    case "elicitation/create":
-      if (!requests.elicitation?.create) {
-        throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
-      }
-      break;
-    default:
-      break;
-  }
-}
-var init_helpers2 = __esm({
-  "node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js"() {
-    "use strict";
-    init_esm_shims();
-  }
-});
-
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
 var Server;
 var init_server2 = __esm({
@@ -266275,6 +266933,81 @@ var init_server4 = __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";
+async function createModernMcpBridge(options) {
+  const { createMemorixServer: createMemorixServer2 } = await Promise.resolve().then(() => (init_server4(), 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] = InMemoryTransport.createLinkedPair();
+  const legacyClient = new Client({
+    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_client4();
+    init_inMemory();
+    init_mcp_discovery();
+  }
+});
+
 // src/cli/commands/serve-shared.ts
 var serve_shared_exports = {};
 __export(serve_shared_exports, {
@@ -266628,6 +267361,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: homedir36 } = 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,
@@ -266637,16 +267378,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((error40) => {
+                console.error(`[memorix] stdio close error: ${error40 instanceof Error ? error40.message : String(error40)}`);
+              });
+            } else {
+              stdinEndedBeforeHandle = true;
+            }
           }
         });
         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));
         let safeCwd;
         try {
           safeCwd = process.cwd();
@@ -266663,70 +267405,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 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 () => {
-          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 toolProfile = resolveToolProfile({
+          explicit: args.mode,
+          envValue: process.env.MEMORIX_MODE,
+          fallback: "micro"
+        });
+        const transport = new StdioServerTransport(startupGate.input, process.stdout);
+        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 (error40) {
+              console.error(`[memorix] MCP roots not available (${error40 instanceof Error ? error40.message : "unsupported"})`);
             }
-          } catch (err) {
-            console.error(`[memorix] MCP roots not available (${err.message ?? "unsupported"})`);
-          }
-        };
-        try {
-          const { RootsListChangedNotificationSchema: RootsListChangedNotificationSchema2 } = await Promise.resolve().then(() => (init_types8(), types_exports3));
-          server.server.setNotificationHandler(RootsListChangedNotificationSchema2, 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((error40) => {
+              console.error(`[memorix] Deferred init error: ${error40 instanceof Error ? error40.message : String(error40)}`);
+            });
+          }, 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: (error40) => console.error(`[memorix] stdio MCP error: ${error40.message}`)
+        });
+        startupGate.markReady();
+        if (stdinEndedBeforeHandle) {
+          void stdioHandle.close().catch((error40) => {
+            console.error(`[memorix] stdio close error: ${error40 instanceof Error ? error40.message : String(error40)}`);
+          });
         }
-        const deferredInitTimer = setTimeout(() => {
-          deferredInit().catch((e5) => console.error(`[memorix] Deferred init error:`, e5));
-        }, 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((m6) => m6.checkForUpdates()).catch(() => {
         });
       }
@@ -266743,15 +267497,17 @@ function getMcpDiagnostics() {
       legacy: LEGACY_MCP_PROTOCOL_VERSION,
       discovery: "supported",
       versionlessRequests: "legacy-compatible",
-      modernResultMetadata: "discovery-only",
-      statelessRequests: "compatibility-only",
+      modernResultMetadata: "supported",
+      statelessRequests: "supported",
       statefulStreamableHttp: "supported"
     },
     capabilities: {
       tasks: "unsupported",
       polling: "unsupported",
-      subscriptions: "unsupported",
-      listCache: "unsupported",
+      subscriptions: "supported",
+      // The protocol envelope is emitted, but TTL is intentionally zero until
+      // Memorix can invalidate a durable per-project list cache correctly.
+      listCache: "protocol-hints-only",
       explicitProjectHandle: "supported"
     }
   };
@@ -269040,6 +269796,7 @@ var init_serve_http = __esm({
     init_retention();
     init_visibility();
     init_mcp_diagnostics();
+    init_mcp_discovery();
     init_port();
     init_mcp_root_path();
     DEFAULT_SESSION_TIMEOUT_MS = 12 * 60 * 60 * 1e3;
@@ -269084,6 +269841,9 @@ var init_serve_http = __esm({
         const { homedir: homedir36 } = await import("os");
         const { McpBindingStore: McpBindingStore2 } = await Promise.resolve().then(() => (init_mcp_binding_store(), mcp_binding_store_exports));
         const { MemoryFeedbackStore: MemoryFeedbackStore2 } = await Promise.resolve().then(() => (init_feedback(), feedback_exports));
+        const { createModernMcpBridge: createModernMcpBridge2 } = await Promise.resolve().then(() => (init_modern_mcp_bridge(), modern_mcp_bridge_exports));
+        const { createMcpHandler } = await import("@modelcontextprotocol/server");
+        const { toNodeHandler } = await import("@modelcontextprotocol/node");
         let configuredDefaults = {};
         try {
           const { getServerConfig: getServerConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -269138,6 +269898,27 @@ var init_serve_http = __esm({
         }
         const statelessBindingStore = new McpBindingStore2();
         await statelessBindingStore.init(persistMod.getBaseDataDir());
+        const modernMcpHandler = createMcpHandler(async ({ requestInfo }) => {
+          const handleId = requestInfo?.headers.get("mcp-project-handle") ?? void 0;
+          const persisted = handleId ? statelessBindingStore.touch(handleId) : void 0;
+          const requestedRoot = requestInfo?.headers.get("mcp-project-root") ?? void 0;
+          const root = persisted?.projectRoot ?? requestedRoot ?? projectRoot;
+          return createModernMcpBridge2({
+            projectRoot: root,
+            allowUntrackedFallback: false,
+            deferProjectInitUntilBound: true,
+            deferProjectRuntimeInit: true,
+            dashboardMode: "control-plane",
+            dashboardPort: port,
+            toolProfile
+          });
+        }, {
+          // Legacy requests are routed to the existing sessionful implementation
+          // below; this handler is strict modern-only by construction.
+          legacy: "reject",
+          responseMode: "auto"
+        });
+        const modernNodeHandler = toNodeHandler(modernMcpHandler);
         const sessions = /* @__PURE__ */ new Map();
         const sessionLastActivity = /* @__PURE__ */ new Map();
         const expiredSessions = /* @__PURE__ */ new Map();
@@ -269283,78 +270064,34 @@ var init_serve_http = __esm({
           res.setHeader("Mcp-Method", req.method || "UNKNOWN");
           res.setHeader("Mcp-Name", MCP_SERVER_NAME);
         }
-        async function handleStatelessPost(req, res, body) {
-          const handleId = typeof req.headers["mcp-project-handle"] === "string" ? req.headers["mcp-project-handle"] : void 0;
-          const persisted = handleId ? statelessBindingStore.touch(handleId) : void 0;
-          if (handleId && !persisted) {
-            res.writeHead(404, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ jsonrpc: "2.0", error: { code: -32001, message: "MCP project handle not found or expired; initialize again." }, id: null }));
-            return;
-          }
-          const requestedRoot = typeof req.headers["mcp-project-root"] === "string" ? req.headers["mcp-project-root"] : void 0;
-          const root = persisted?.projectRoot ?? requestedRoot ?? projectRoot;
-          const { createMemorixServer: createMemorixServer3 } = await Promise.resolve().then(() => (init_server4(), server_exports2));
-          const { createProjectBindingController: createProjectBindingController3 } = await Promise.resolve().then(() => (init_request_context(), request_context_exports));
-          const binding = createProjectBindingController3(root);
-          const { server, projectId, handleTransportClose } = await createMemorixServer3(
-            root,
-            void 0,
-            void 0,
-            {
-              allowUntrackedFallback: false,
-              deferProjectInitUntilBound: true,
-              deferProjectRuntimeInit: true,
-              dashboardMode: "control-plane",
-              dashboardPort: port,
-              toolProfile,
-              projectBinding: binding
-            }
-          );
-          const transport = new StreamableHTTPServerTransport2({
-            // No Mcp-Session-Id: the protocol state is carried by our explicit
-            // durable project handle and reconstructed on every request.
-            sessionIdGenerator: void 0,
-            enableJsonResponse: true
-          });
-          try {
-            await server.connect(transport);
-            let effectiveHandle = persisted;
-            if (!effectiveHandle && projectId !== "__unresolved__" && isInitializeRequest2(body)) {
-              effectiveHandle = statelessBindingStore.create({
-                projectId,
-                projectRoot: root,
-                dataDir: await persistMod.getProjectDataDir(projectId)
-              });
-            }
-            if (effectiveHandle) res.setHeader("Mcp-Project-Handle", effectiveHandle.handleId);
-            const sdkBody = body && typeof body === "object" ? JSON.parse(JSON.stringify(body)) : body;
-            const sdkRequest = sdkBody;
-            if (sdkRequest && typeof sdkRequest === "object" && sdkRequest.method === "initialize" && sdkRequest.params) {
-              sdkRequest.params.protocolVersion = MCP_SDK_COMPAT_PROTOCOL_VERSION;
-            }
-            if (req.headers["mcp-protocol-version"]) {
-              req.headers["mcp-protocol-version"] = MCP_SDK_COMPAT_PROTOCOL_VERSION;
-              for (let i4 = 0; i4 < req.rawHeaders.length; i4 += 2) {
-                if (req.rawHeaders[i4].toLowerCase() === "mcp-protocol-version") {
-                  req.rawHeaders[i4 + 1] = MCP_SDK_COMPAT_PROTOCOL_VERSION;
-                  break;
-                }
-              }
-            }
-            patchMcpResponse(res);
-            await transport.handleRequest(req, res, sdkBody);
-          } finally {
-            handleTransportClose();
-            await transport.close().catch(() => void 0);
-          }
-        }
         async function handlePost(req, res) {
           const sessionId = req.headers["mcp-session-id"];
           const body = await parseBody(req);
+          const params = body && typeof body === "object" && !Array.isArray(body) ? body.params : void 0;
+          const claimlessDiscovery = !sessionId && isServerDiscoverRequest(body) && !req.headers["mcp-protocol-version"] && !req.headers["mcp-method"] && req.headers["mcp-stateless"] !== "true" && (params === void 0 || typeof params === "object" && params !== null && !Array.isArray(params) && !Object.prototype.hasOwnProperty.call(params, "_meta"));
+          if (claimlessDiscovery) {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+              jsonrpc: "2.0",
+              id: body.id ?? null,
+              result: createMcpStartupDiscoverResult(getMcpServerInfo())
+            }));
+            return;
+          }
           const requestedProtocol = req.headers["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);
+            const handleId = typeof req.headers["mcp-project-handle"] === "string" ? req.headers["mcp-project-handle"] : void 0;
+            if (handleId && !statelessBindingStore.touch(handleId)) {
+              res.writeHead(404, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({
+                jsonrpc: "2.0",
+                error: { code: -32001, message: "MCP project handle not found or expired; initialize again." },
+                id: null
+              }));
+              return;
+            }
+            await modernNodeHandler(req, res, body);
             return;
           }
           if (sessionId && sessions.has(sessionId)) {
@@ -270316,6 +271053,7 @@ var init_serve_http = __esm({
             sendJson2({ error: err instanceof Error ? err.message : "Unknown error" }, 500);
           }
         }
+        let httpReadyAt = null;
         const httpServer = createServer3(async (req, res) => {
           setCorsHeaders(req, res);
           if (req.method === "OPTIONS") {
@@ -270330,9 +271068,13 @@ var init_serve_http = __esm({
             res.end(JSON.stringify({
               status: "ok",
               mode: "control-plane",
+              profile: toolProfile,
               port,
               uptime: Math.round(process.uptime()),
               pid: process.pid,
+              projectId: defaultProject?.id ?? "__unresolved__",
+              projectName: defaultProject?.name ?? null,
+              readyAt: httpReadyAt,
               embedding: getEmbeddingRuntimeHealth2()
             }));
             return;
@@ -270399,6 +271141,7 @@ var init_serve_http = __esm({
         httpServer.keepAliveTimeout = 6e4;
         httpServer.headersTimeout = 65e3;
         httpServer.listen(port, host, () => {
+          httpReadyAt = (/* @__PURE__ */ new Date()).toISOString();
           try {
             const memorixDir = (process.env.HOME || process.env.USERPROFILE || "").replace(/\\/g, "/") + "/.memorix";
             mkdirSync12(memorixDir, { recursive: true });
@@ -275000,6 +275743,9 @@ function getStateFilePath() {
 function getLogFilePath() {
   return getMemorixDir() + "/background.log";
 }
+function getBackgroundLockPath() {
+  return getMemorixDir() + "/background.lock";
+}
 function parseBoundedPositiveInteger(value, fallback, label, maximum) {
   const raw = value ?? String(fallback);
   if (!/^[0-9]+$/u.test(raw)) {
@@ -275163,25 +275909,82 @@ async function startWindowsBackgroundService(options) {
   });
 }
 async function healthCheck(port, timeoutMs = 3e3) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
     const res = await fetch(`http://127.0.0.1:${port}/health`, {
       signal: controller.signal
     });
-    clearTimeout(timer);
     if (!res.ok) return { ok: false, error: `HTTP ${res.status}` };
     const data = await res.json();
     return { ok: true, data };
   } catch (err) {
     return { ok: false, error: err instanceof Error ? err.message : "Unknown error" };
+  } finally {
+    clearTimeout(timer);
   }
 }
 async function isPortInUse(port) {
   const health = await healthCheck(port, 1500);
   return health.ok;
 }
-async function doStart(port) {
+async function acquireBackgroundLock(lockPath, staleMs = BACKGROUND_LOCK_STALE_MS, timeoutMs = BACKGROUND_LOCK_ACQUIRE_TIMEOUT_MS) {
+  const lockDir = path44.dirname(lockPath);
+  if (!fs26.existsSync(lockDir)) fs26.mkdirSync(lockDir, { recursive: true });
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const fd = fs26.openSync(lockPath, "wx");
+      const token = `${process.pid}:${randomBytes2(12).toString("hex")}`;
+      fs26.writeSync(fd, JSON.stringify({ pid: process.pid, acquiredAt: Date.now(), token }));
+      const heartbeat = setInterval(() => {
+        try {
+          const now3 = /* @__PURE__ */ new Date();
+          fs26.futimesSync(fd, now3, now3);
+        } catch {
+        }
+      }, BACKGROUND_LOCK_HEARTBEAT_MS);
+      heartbeat.unref();
+      return { fd, acquired: true, path: lockPath, token, heartbeat };
+    } catch (err) {
+      if (!(err && err.code === "EEXIST")) throw err;
+      try {
+        if (Date.now() - fs26.statSync(lockPath).mtimeMs > staleMs) {
+          let ownerAlive = false;
+          try {
+            const raw = fs26.readFileSync(lockPath, "utf8");
+            const owner = JSON.parse(raw);
+            ownerAlive = typeof owner.pid === "number" && owner.pid > 0 && isProcessRunning(owner.pid);
+          } catch {
+          }
+          if (!ownerAlive) {
+            fs26.unlinkSync(lockPath);
+            continue;
+          }
+        }
+      } catch {
+      }
+      await new Promise((resolve6) => setTimeout(resolve6, 200));
+    }
+  }
+  throw new Error(
+    `Another Memorix background start is still in progress (${lockPath}). Wait a few seconds and retry; no second control plane was started.`
+  );
+}
+function releaseBackgroundLock(lock) {
+  if (!lock.acquired) return;
+  if (lock.heartbeat) clearInterval(lock.heartbeat);
+  try {
+    if (lock.fd !== null) fs26.closeSync(lock.fd);
+  } catch {
+  }
+  try {
+    const current = JSON.parse(fs26.readFileSync(lock.path, "utf8"));
+    if (current.token === lock.token) fs26.unlinkSync(lock.path);
+  } catch {
+  }
+}
+async function doStartUnlocked(port) {
   const state = loadState();
   if (state) {
     if (isProcessRunning(state.pid)) {
@@ -275334,6 +276137,14 @@ async function doStart(port) {
   ].join("\n");
   process.stderr.write(footer + "\n");
 }
+async function doStart(port) {
+  const lock = await acquireBackgroundLock(getBackgroundLockPath());
+  try {
+    await doStartUnlocked(port);
+  } finally {
+    releaseBackgroundLock(lock);
+  }
+}
 async function doStop() {
   const state = loadState();
   if (!state) {
@@ -275393,11 +276204,22 @@ async function doStop() {
   }
   console.log("[OK] Control plane stopped.");
 }
-async function doStatus() {
+async function doStatus(asJson = false) {
   const state = loadState();
   if (!state) {
     const portHealth = await healthCheck(3211, 2e3);
     if (portHealth.ok) {
+      if (asJson) {
+        console.log(JSON.stringify({
+          status: "unmanaged",
+          managed: false,
+          port: 3211,
+          dashboard: "http://127.0.0.1:3211/",
+          mcp: "http://127.0.0.1:3211/mcp",
+          health: portHealth.data ?? null
+        }, null, 2));
+        return;
+      }
       console.log("");
       console.log("No background control plane is registered,");
       console.log('but a Memorix instance IS running on port 3211 (likely a foreground "memorix serve-http").');
@@ -275417,6 +276239,10 @@ async function doStatus() {
       console.log('    2. Run "memorix background start"');
       console.log("");
     } else {
+      if (asJson) {
+        console.log(JSON.stringify({ status: "stopped", managed: false, port: 3211 }, null, 2));
+        return;
+      }
       console.log("No background control plane is registered.");
       console.log("");
       console.log("Start one with:  memorix background start");
@@ -275427,6 +276253,30 @@ async function doStatus() {
   const health = running ? await healthCheck(state.port) : { ok: false, error: "Process not running" };
   const pidMismatch = health.ok && health.data?.pid && health.data.pid !== state.pid;
   const probablyReused = running && !health.ok;
+  const status = health.ok && !pidMismatch ? "running" : pidMismatch ? "pid-mismatch" : probablyReused ? "pid-reused" : running ? "starting" : "stopped";
+  if (asJson) {
+    if (pidMismatch || probablyReused || !running) {
+      clearState();
+      try {
+        fs26.unlinkSync(getMemorixDir() + "/background.ready");
+      } catch {
+      }
+    }
+    console.log(JSON.stringify({
+      status,
+      managed: true,
+      pid: state.pid,
+      port: state.port,
+      startedAt: state.startedAt,
+      instance: state.instanceToken ? `${state.instanceToken.slice(0, 8)}\u2026` : null,
+      dashboard: `http://127.0.0.1:${state.port}/`,
+      mcp: `http://127.0.0.1:${state.port}/mcp`,
+      logFile: normalizePath3(state.logFile),
+      health: health.ok ? health.data ?? null : null,
+      error: health.ok ? null : health.error ?? (running ? "Health check failed" : "Process not running")
+    }, null, 2));
+    return;
+  }
   console.log("");
   console.log("Memorix Background Control Plane");
   console.log("================================");
@@ -275446,6 +276296,9 @@ async function doStatus() {
     console.log(`    PID:        ${d4.pid ?? "unknown"}`);
     console.log(`    Uptime:     ${d4.uptime ?? 0}s`);
     console.log(`    Mode:       ${d4.mode ?? "unknown"}`);
+    console.log(`    Profile:    ${d4.profile ?? "unknown"}`);
+    console.log(`    Project:    ${d4.projectId ?? "unresolved"}${d4.projectName ? ` (${d4.projectName})` : ""}`);
+    console.log(`    Ready at:   ${d4.readyAt ?? "unknown"}`);
   }
   if (pidMismatch) {
     console.log("");
@@ -275539,7 +276392,7 @@ function doLogs(follow, lines) {
     console.log(tail.join("\n"));
   }
 }
-var background_default, _testing3;
+var BACKGROUND_LOCK_STALE_MS, BACKGROUND_LOCK_ACQUIRE_TIMEOUT_MS, BACKGROUND_LOCK_HEARTBEAT_MS, background_default, _testing3;
 var init_background = __esm({
   "src/cli/commands/background.ts"() {
     "use strict";
@@ -275547,6 +276400,9 @@ var init_background = __esm({
     init_dist2();
     init_port();
     init_launch_root();
+    BACKGROUND_LOCK_STALE_MS = 15e3;
+    BACKGROUND_LOCK_ACQUIRE_TIMEOUT_MS = 1e4;
+    BACKGROUND_LOCK_HEARTBEAT_MS = 2e3;
     background_default = defineCommand({
       meta: {
         name: "background",
@@ -275569,6 +276425,11 @@ var init_background = __esm({
           alias: "n",
           description: "Number of log lines to show (default: 50)",
           required: false
+        },
+        json: {
+          type: "boolean",
+          description: "Emit a machine-readable status receipt",
+          required: false
         }
       },
       run: async ({ args }) => {
@@ -275583,7 +276444,7 @@ var init_background = __esm({
               await doStop();
               break;
             case "status":
-              await doStatus();
+              await doStatus(!!args.json);
               break;
             case "restart":
               await doRestart(port);
@@ -275609,6 +276470,7 @@ var init_background = __esm({
               console.log("  --port <port>   HTTP port (default: 3211)");
               console.log('  --follow, -f    Follow log output in real-time (for "logs")');
               console.log("  --lines, -n     Number of log lines to show (default: 50)");
+              console.log('  --json          Emit a machine-readable status receipt (for "status")');
               console.log("");
               console.log("Mode distinction:");
               console.log("  Quick Mode       = stdio / single project / zero friction");
@@ -275630,7 +276492,10 @@ var init_background = __esm({
       formatBackgroundCommandError,
       resolveBackgroundCliEntry,
       resolveBackgroundCliEntryFrom,
-      resolveBackgroundCwd
+      resolveBackgroundCwd,
+      acquireBackgroundLock,
+      releaseBackgroundLock,
+      getBackgroundLockPath
     };
   }
 });
@@ -285996,6 +286861,10 @@ var GUIDES = {
     usage: [
       "memorix codegraph status",
       "memorix codegraph refresh",
+      "memorix codegraph init",
+      "memorix codegraph sync",
+      "memorix codegraph diff [--from <snapshot>] [--to <snapshot>]",
+      "memorix codegraph impact --path <relative-source-path>",
       'memorix codegraph context-pack --task "trace the auth flow" [--limit 20]'
     ]
   },
@@ -286014,10 +286883,57 @@ var GUIDES = {
     usage: [
       "memorix knowledge init [--mode local|versioned]",
       "memorix knowledge status",
+      "memorix knowledge claims",
+      'memorix knowledge review --id <claim-id> --review approved|rejected --detail "..."',
       "memorix knowledge compile",
       "memorix knowledge lint",
-      "memorix knowledge workflow list"
-    ]
+      "memorix knowledge apply --proposal <id> [--force]",
+      "memorix knowledge workflow import|list",
+      'memorix knowledge workflow select --task "prepare a release"',
+      "memorix knowledge workflow preview|apply --id <workflow-id> --agent codex",
+      'memorix knowledge workflow run --id <workflow-id> --task "..." --outcome passed'
+    ],
+    notes: ["Claims need source review before they can become maintained Knowledge Workspace pages."]
+  },
+  evidence: {
+    summary: "Inspect the source, freshness, and verification state behind project memories.",
+    usage: [
+      'memorix evidence list [--query "auth"] [--limit 20]',
+      "memorix evidence get --id 42",
+      "memorix evidence sync",
+      'memorix evidence stale --paths src/server.ts,tests/server.test.ts --reason "source changed"',
+      "memorix evidence events --id 42"
+    ],
+    notes: ["Evidence cards point back to observations and source files; they are not a second memory store."]
+  },
+  feedback: {
+    summary: "Record and inspect whether a memory helped, conflicted, or was corrected.",
+    usage: [
+      "memorix feedback record --id 42 --signal verification-success --source test:run-1",
+      "memorix feedback show --id 42",
+      "memorix feedback audit --id 42 [--limit 100]"
+    ],
+    notes: ["Feedback changes the candidate score through an auditable event; it does not rewrite the original memory."]
+  },
+  formation: {
+    summary: "Inspect Memory Formation quality metrics collected by the runtime.",
+    usage: ["memorix formation metrics"],
+    notes: ["Metrics are empty until the formation pipeline has processed observations."]
+  },
+  media: {
+    summary: "Import, inspect, derive, embed, and clean controlled local media assets.",
+    usage: [
+      "memorix media import --path ./diagram.png",
+      'memorix media attach --asset <asset-id> --title "Architecture diagram"',
+      "memorix media list --kind image",
+      "memorix media show --asset <asset-id>",
+      "memorix media derive-pdf|derive-audio --asset <asset-id> [--attach]",
+      "memorix media embed|similar --asset <asset-id>",
+      'memorix media generate image|video --prompt "..."',
+      "memorix media status|cancel --job <media-job-id>",
+      "memorix media cleanup [--max-bytes <limit>]"
+    ],
+    notes: ["Media generation is explicit and provider-gated; importing a file does not automatically send it to a model."]
   },
   reasoning: {
     summary: "Capture and retrieve engineering decision rationale.",
@@ -286510,7 +287426,7 @@ var main2 = defineCommand({
       console.error("  integrate  Install one IDE integration into the current repo");
       console.error("  status     Show project info + stats");
       console.error("  dashboard  Open standalone dashboard (read-mostly)");
-      console.error("  hooks      Open legacy hook installer menu");
+      console.error("  hooks      Install, inspect, or remove agent hooks");
       console.error("  cleanup    Remove old memories");
       console.error("  purge      Retire all memories (project by default, --all for everything)");
       console.error("  sync       Rules/workspace sync plus interactive wizard");