memorix 1.8.4 → 1.8.6

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.6" : 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`." : ""));
       }
     };
@@ -183148,6 +183148,15 @@ __export(task_lens_exports, {
   scoreLensSource: () => scoreLensSource,
   shouldShowLensSource: () => shouldShowLensSource
 });
+function hasSubstantiveTask(text2, keyword) {
+  const withoutKeyword = text2.replace(
+    new RegExp(keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "gi"),
+    " "
+  );
+  const residual = withoutKeyword.replace(TASK_FILLER_WORDS, " ").replace(TASK_FILLER_PHRASES, " ").replace(/[\s\p{P}]/gu, "");
+  if (/^(?:任务|工作|一下|一起|接着)$/u.test(residual)) return false;
+  return Array.from(residual).length >= MIN_TASK_SUBSTANCE;
+}
 function normalizePath2(path48) {
   return path48.replace(/\\/g, "/");
 }
@@ -183207,8 +183216,12 @@ function resolveTaskLens(task) {
 }
 function isContinuationTask(task) {
   const normalized = (task ?? "").trim().toLowerCase();
-  return normalized.length > 0 && CONTINUATION_KEYWORDS.some(
-    (keyword) => containsTaskKeyword(normalized, keyword)
+  if (normalized.length === 0) return false;
+  if (EXPLICIT_HANDOFF_KEYWORDS.some((keyword) => containsTaskKeyword(normalized, keyword))) {
+    return true;
+  }
+  return AMBIGUOUS_CONTINUATION_KEYWORDS.some(
+    (keyword) => containsTaskKeyword(normalized, keyword) && hasSubstantiveTask(normalized, keyword)
   );
 }
 function pathKindScore(path48, lens) {
@@ -183354,7 +183367,7 @@ function shouldShowLensSource(source, lens, task) {
   if (lens.id === "onboarding" || lens.id === "release" || lens.id === "docs") return score >= 40;
   return score > 0;
 }
-var STOP_WORDS, LENSES, KEYWORDS, CONTINUATION_KEYWORDS, LENS_PRIORITY;
+var STOP_WORDS, LENSES, KEYWORDS, EXPLICIT_HANDOFF_KEYWORDS, AMBIGUOUS_CONTINUATION_KEYWORDS, TASK_FILLER_WORDS, TASK_FILLER_PHRASES, MIN_TASK_SUBSTANCE, LENS_PRIORITY;
 var init_task_lens = __esm({
   "src/codegraph/task-lens.ts"() {
     "use strict";
@@ -183475,18 +183488,31 @@ var init_task_lens = __esm({
       docs: ["doc", "docs", "readme", "\u6587\u6863", "\u8BF4\u660E"],
       test: ["coverage", "fixture", "smoke", "spec", "test", "tests", "testing", "vitest", "\u6D4B\u8BD5"]
     };
-    CONTINUATION_KEYWORDS = [
+    EXPLICIT_HANDOFF_KEYWORDS = [
+      "handoff",
+      "hand off",
+      "hand over",
+      "previous session",
+      "last session",
+      "pick up where",
+      "\u4EA4\u63A5",
+      // 覆盖「任务交接」「工作交接」
+      "\u63A5\u624B",
+      "\u4E0A\u6B21\u4F1A\u8BDD",
+      "\u4E0A\u6B21\u7684\u4F1A\u8BDD"
+    ];
+    AMBIGUOUS_CONTINUATION_KEYWORDS = [
       "continue",
       "resume",
-      "pick up",
       "carry on",
-      "previous session",
+      "pick up",
       "\u7EE7\u7EED",
-      "\u63A5\u624B",
       "\u6062\u590D",
-      "\u5EF6\u7EED",
-      "\u4E0A\u6B21\u4F1A\u8BDD"
+      "\u5EF6\u7EED"
     ];
+    TASK_FILLER_WORDS = /\b(?:please|task|work|the|a|an)\b/giu;
+    TASK_FILLER_PHRASES = /(?:吧|了|呢|啊|吗|嘛|呀|哦|噢|一下|一起|接着|请|帮我)/gu;
+    MIN_TASK_SUBSTANCE = 2;
     LENS_PRIORITY = [
       "bugfix",
       "release",
@@ -192552,9 +192578,69 @@ var init_dsh = __esm({
   }
 });
 
-// src/workspace/mcp-adapters/codebuddy.ts
+// src/workspace/mcp-adapters/workbuddy.ts
 import { homedir as homedir23 } from "os";
 import { join as join20 } from "path";
+var WorkbuddyMCPAdapter;
+var init_workbuddy = __esm({
+  "src/workspace/mcp-adapters/workbuddy.ts"() {
+    "use strict";
+    init_esm_shims();
+    WorkbuddyMCPAdapter = class {
+      source = "workbuddy";
+      parse(content) {
+        try {
+          const config2 = JSON.parse(content);
+          const servers = config2.mcpServers ?? {};
+          return Object.entries(servers).map(([name, entry]) => ({
+            name,
+            command: entry.command ?? "",
+            args: entry.args ?? [],
+            ...entry.env && Object.keys(entry.env).length > 0 ? { env: entry.env } : {},
+            ...entry.url ? { url: entry.url } : {},
+            ...entry.headers && Object.keys(entry.headers).length > 0 ? { headers: entry.headers } : {},
+            ...entry.disabled === true ? { disabled: true } : {}
+          }));
+        } catch {
+          return [];
+        }
+      }
+      generate(servers) {
+        const mcpServers = {};
+        for (const s4 of servers) {
+          const entry = {};
+          if (s4.url) {
+            entry.url = s4.url;
+            if (s4.headers && Object.keys(s4.headers).length > 0) {
+              entry.headers = s4.headers;
+            }
+          } else {
+            entry.command = s4.command;
+            entry.args = s4.args;
+          }
+          if (s4.env && Object.keys(s4.env).length > 0) {
+            entry.env = s4.env;
+          }
+          if (s4.disabled === true) {
+            entry.disabled = true;
+          }
+          mcpServers[s4.name] = entry;
+        }
+        return JSON.stringify({ mcpServers }, null, 2) + "\n";
+      }
+      getConfigPath(projectRoot) {
+        if (projectRoot) {
+          return join20(projectRoot, ".workbuddy", "mcp.json");
+        }
+        return join20(homedir23(), ".workbuddy", "mcp.json");
+      }
+    };
+  }
+});
+
+// src/workspace/mcp-adapters/codebuddy.ts
+import { homedir as homedir24 } from "os";
+import { join as join21 } from "path";
 var CodeBuddyMCPAdapter;
 var init_codebuddy = __esm({
   "src/workspace/mcp-adapters/codebuddy.ts"() {
@@ -192586,7 +192672,7 @@ var init_codebuddy = __esm({
         return JSON.stringify({ mcpServers }, null, 2);
       }
       getConfigPath(projectRoot) {
-        return projectRoot ? join20(projectRoot, ".mcp.json") : join20(homedir23(), ".codebuddy", ".mcp.json");
+        return projectRoot ? join21(projectRoot, ".mcp.json") : join21(homedir24(), ".codebuddy", ".mcp.json");
       }
     };
   }
@@ -192736,6 +192822,15 @@ var init_registry2 = __esm({
         surfaces: ["MCP", "AGENTS.md", "skills"],
         note: "DeepSeek Harness support writes a @deepseek-ai/dsh-mcp-client row into $DSH_HOME/cordis.patch.yml (default ~/.dsh/cordis.patch.yml), guidance into the harness AGENTS.md, and skills under $DSH_HOME/skills."
       },
+      {
+        agent: "workbuddy",
+        name: "WorkBuddy",
+        entry: "official-config",
+        status: "ready",
+        install: "memorix setup --agent workbuddy",
+        surfaces: ["MCP", "AGENTS.md"],
+        note: "WorkBuddy support writes a memorix MCP server row into ~/.workbuddy/mcp.json (or <project>/.workbuddy/mcp.json for project installs) and guidance into AGENTS.md."
+      },
       {
         agent: "memcode",
         name: "memcode",
@@ -192804,6 +192899,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 +193032,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 +193069,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.",
@@ -193029,9 +193131,9 @@ __export(audit_exports, {
 });
 import * as fs18 from "fs/promises";
 import * as path29 from "path";
-import { homedir as homedir24 } from "os";
+import { homedir as homedir25 } from "os";
 function getAuditFilePath() {
-  return process.env.MEMORIX_AUDIT_FILE || path29.join(homedir24(), ".memorix", "audit.json");
+  return process.env.MEMORIX_AUDIT_FILE || path29.join(homedir25(), ".memorix", "audit.json");
 }
 async function loadAudit() {
   try {
@@ -193592,6 +193694,8 @@ function getProjectConfigPath(agent, projectRoot) {
       return path30.join(projectRoot, ".agents", "hooks.json");
     case "gemini-cli":
       return path30.join(projectRoot, ".gemini", "settings.json");
+    case "workbuddy":
+      return "";
     default:
       return path30.join(projectRoot, ".memorix", "hooks.json");
   }
@@ -193625,6 +193729,8 @@ function getGlobalConfigPath(agent) {
       return path30.join(home, ".trae", "rules", "project_rules.md");
     case "dsh":
       return path30.join(process.env.DSH_HOME?.trim() || path30.join(home, ".dsh"), "AGENTS.md");
+    case "workbuddy":
+      return "";
     default:
       return path30.join(home, ".memorix", "hooks.json");
   }
@@ -193651,6 +193757,8 @@ function getAgentRulesPath(agent, root, global2 = false) {
         return path30.join(root, ".trae", "rules", "project_rules.md");
       case "dsh":
         return path30.join(process.env.DSH_HOME?.trim() || path30.join(root, ".dsh"), "AGENTS.md");
+      case "workbuddy":
+        return "";
       default:
         return path30.join(root, ".agent", "rules", "memorix.md");
     }
@@ -193677,6 +193785,8 @@ function getAgentRulesPath(agent, root, global2 = false) {
       return path30.join(root, ".trae", "rules", "project_rules.md");
     case "dsh":
       return path30.join(root, "AGENTS.md");
+    case "workbuddy":
+      return path30.join(root, "AGENTS.md");
     default:
       return path30.join(root, ".agent", "rules", "memorix.md");
   }
@@ -193765,6 +193875,11 @@ async function detectInstalledAgents() {
     agents.push("dsh");
   } catch {
   }
+  try {
+    await fs19.access(path30.join(home, ".workbuddy"));
+    agents.push("workbuddy");
+  } catch {
+  }
   return agents;
 }
 async function installHooks(agent, projectRoot, global2 = false) {
@@ -193778,6 +193893,16 @@ async function installHooks(agent, projectRoot, global2 = false) {
       }
     };
   }
+  if (agent === "workbuddy" && global2) {
+    return {
+      agent,
+      configPath: "",
+      events: [],
+      generated: {
+        note: "WorkBuddy has no hook system and no user-global guidance file \u2014 MCP only; no global guidance/hooks. Run `memorix setup --agent workbuddy` (without --global) to install project MCP config and AGENTS.md guidance."
+      }
+    };
+  }
   if (global2 && getGlobalConfigPath(agent) === "") {
     return {
       agent,
@@ -193860,6 +193985,17 @@ async function installHooks(agent, projectRoot, global2 = false) {
         }
       };
     }
+    case "workbuddy": {
+      const rulesPath = await installAgentRules(agent, projectRoot, global2);
+      return {
+        agent,
+        configPath: rulesPath,
+        events: [],
+        generated: {
+          note: "WorkBuddy has no hook system \u2014 installed AGENTS.md guidance only; the MCP row is installed by `memorix setup --agent workbuddy`."
+        }
+      };
+    }
     case "opencode": {
       const pluginContent = generateOpenCodePlugin();
       const pluginPath = global2 ? getGlobalConfigPath(agent) : getProjectConfigPath(agent, projectRoot);
@@ -193989,6 +194125,7 @@ async function installHooks(agent, projectRoot, global2 = false) {
   };
 }
 async function installAgentRules(agent, projectRoot, global2 = false) {
+  if (agent === "workbuddy" && global2) return "";
   const rulesContent = getAgentRulesContent(agent, global2 ? "global" : "project");
   const rulesRoot = global2 ? os5.homedir() : projectRoot;
   const rulesPath = getAgentRulesPath(agent, rulesRoot, global2);
@@ -194141,7 +194278,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) {
@@ -194151,6 +194291,9 @@ async function uninstallHooks(agent, projectRoot, global2 = false) {
   if (agent === "pi") {
     return false;
   }
+  if (agent === "workbuddy") {
+    return false;
+  }
   if (global2 && getGlobalConfigPath(agent) === "") {
     return false;
   }
@@ -194334,7 +194477,7 @@ __export(setup_exports, {
 import { spawnSync } from "child_process";
 import { existsSync as existsSync15 } from "fs";
 import { copyFile as copyFile2, mkdir as mkdir6, readFile as readFile6, readdir as readdir3, rm as rm2, writeFile as writeFile7 } from "fs/promises";
-import { homedir as homedir26 } from "os";
+import { homedir as homedir27 } from "os";
 import path31 from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 function getSetupAgentTargets() {
@@ -194496,7 +194639,8 @@ function getMcpAdapter(agent) {
     kiro: new KiroMCPAdapter(),
     opencode: new OpenCodeMCPAdapter(),
     trae: new TraeMCPAdapter(),
-    dsh: new DshMCPAdapter()
+    dsh: new DshMCPAdapter(),
+    workbuddy: new WorkbuddyMCPAdapter()
   };
   return adapters[agent];
 }
@@ -194618,7 +194762,7 @@ function isOwnedLegacyCodexMcp(content) {
   const server = new CodexMCPAdapter().parse(content).find((entry) => entry.name === "memorix");
   return Boolean(server && isLegacyCodexMemorixNodeServer(server));
 }
-async function removeLegacyCodexMemorixMcpConfig(configPath = path31.join(homedir26(), ".codex", "config.toml")) {
+async function removeLegacyCodexMemorixMcpConfig(configPath = path31.join(homedir27(), ".codex", "config.toml")) {
   let existingContent;
   try {
     existingContent = await readFile6(configPath, "utf-8");
@@ -194675,7 +194819,7 @@ async function removeOwnedLegacyCodexPluginFolder(homeDir) {
   }
 }
 async function migrateLegacyCodexIntegration(options = {}) {
-  const homeDir = options.homeDir ?? homedir26();
+  const homeDir = options.homeDir ?? homedir27();
   const projectRoot = options.projectRoot ?? process.cwd();
   const configPath = path31.join(homeDir, ".codex", "config.toml");
   let mcp = "missing";
@@ -194876,7 +195020,7 @@ async function stripCodeBuddyHookCapture(pluginPath) {
   await writeFile7(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
 }
 async function installCodeBuddyPluginPackage(options = {}) {
-  const home = options.homeDir ?? homedir26();
+  const home = options.homeDir ?? homedir27();
   const packageRoot = findPackageRoot();
   const source = path31.join(packageRoot, "plugins", "codebuddy", "memorix");
   if (!existsSync15(source)) throw new Error(`CodeBuddy plugin template not found: ${source}`);
@@ -194896,7 +195040,7 @@ async function installCodeBuddyPluginPackage(options = {}) {
   };
 }
 async function installPluginPackage(options) {
-  const home = options.homeDir ?? homedir26();
+  const home = options.homeDir ?? homedir27();
   const packageRoot = findPackageRoot();
   const source = path31.join(packageRoot, "plugins", options.agent, "memorix");
   const includeHooks = options.includeHooks ?? true;
@@ -194945,7 +195089,7 @@ async function installPluginPackage(options) {
   };
 }
 async function installGeminiExtensionPackage(options = {}) {
-  const home = options.homeDir ?? homedir26();
+  const home = options.homeDir ?? homedir27();
   const packageRoot = findPackageRoot();
   const source = path31.join(packageRoot, "plugins", "gemini", "memorix");
   if (!existsSync15(source)) {
@@ -194965,7 +195109,7 @@ async function installAntigravityPluginPackage(options = {}) {
   if (!existsSync15(source)) {
     throw new Error(`Antigravity plugin template not found: ${source}`);
   }
-  const pluginPath = options.global === false ? path31.join(options.projectRoot ?? process.cwd(), ".agents", "plugins", "memorix") : path31.join(options.homeDir ?? homedir26(), ".gemini", "config", "plugins", "memorix");
+  const pluginPath = options.global === false ? path31.join(options.projectRoot ?? process.cwd(), ".agents", "plugins", "memorix") : path31.join(options.homeDir ?? homedir27(), ".gemini", "config", "plugins", "memorix");
   await copyDir(source, pluginPath);
   if (options.includeHooks === false) {
     await rm2(path31.join(pluginPath, "hooks.json"), { force: true });
@@ -194983,7 +195127,7 @@ async function installPiPackage(options = {}) {
   if (!existsSync15(source)) {
     throw new Error(`Pi package template not found: ${source}`);
   }
-  const defaultRoot = options.global ? path31.join(options.homeDir ?? homedir26(), ".pi", "agent", "packages") : path31.join(process.cwd(), ".pi", "packages");
+  const defaultRoot = options.global ? path31.join(options.homeDir ?? homedir27(), ".pi", "agent", "packages") : path31.join(process.cwd(), ".pi", "packages");
   const packagePath = options.packageDir ?? path31.join(defaultRoot, "memorix");
   await copyDir(source, packagePath);
   await writeOfficialSkills(path31.join(packagePath, "skills"));
@@ -194995,7 +195139,7 @@ async function installPiPackage(options = {}) {
   };
 }
 async function installOpenClawBundlePackage(options = {}) {
-  const home = options.homeDir ?? homedir26();
+  const home = options.homeDir ?? homedir27();
   const packageRoot = findPackageRoot();
   const source = path31.join(packageRoot, "plugins", "openclaw", "memorix");
   if (!existsSync15(source)) {
@@ -195044,7 +195188,7 @@ async function installOmpPackage(options = {}) {
   if (!existsSync15(source)) {
     throw new Error(`Oh-my-Pi package template not found: ${source}`);
   }
-  const defaultRoot = options.global ? path31.join(options.homeDir ?? homedir26(), ".omp", "agent", "packages") : path31.join(process.cwd(), ".omp", "packages");
+  const defaultRoot = options.global ? path31.join(options.homeDir ?? homedir27(), ".omp", "agent", "packages") : path31.join(process.cwd(), ".omp", "packages");
   const packagePath = options.packageDir ?? path31.join(defaultRoot, "memorix");
   await copyDir(source, packagePath);
   await writeOfficialSkills(path31.join(packagePath, "skills"));
@@ -195318,7 +195462,7 @@ ${result.stdout || ""}`.toLowerCase();
 }
 async function installAgentSetup(agent, plan, global2) {
   const { installAgentGuidance: installAgentGuidance2, installHooks: installHooks2 } = await Promise.resolve().then(() => (init_installers(), installers_exports));
-  const targetRoot = global2 ? homedir26() : process.cwd();
+  const targetRoot = global2 ? homedir27() : process.cwd();
   const hasPluginPackage = plan.actions.includes("plugin-package") && PLUGIN_PACKAGE_AGENTS.has(agent);
   const hasExtensionPackage = plan.actions.includes("extension-package") && agent === "gemini-cli";
   const hasPiPackage = plan.actions.includes("pi-package") && agent === "pi";
@@ -195469,7 +195613,14 @@ async function installAgentSetup(agent, plan, global2) {
     }
   } else if (plan.actions.includes("hooks")) {
     const result = await installHooks2(agent, targetRoot, global2);
-    v3.success(`${agent}: integration files -> ${result.configPath}`);
+    const note = result.generated?.note;
+    if (result.configPath) {
+      v3.success(`${agent}: integration files -> ${result.configPath}`);
+    } else if (note) {
+      v3.info(`${agent}: ${note}`);
+    } else {
+      v3.info(`${agent}: no hooks or guidance are available at this scope`);
+    }
   } else if (plan.actions.includes("project-guidance")) {
     const rulesPath = await installAgentGuidance2(agent, targetRoot, global2);
     v3.success(`${agent}: guidance -> ${rulesPath}`);
@@ -195526,6 +195677,7 @@ var init_setup = __esm({
     init_opencode();
     init_trae();
     init_dsh();
+    init_workbuddy();
     init_codebuddy();
     init_registry2();
     init_official_skills();
@@ -195555,6 +195707,7 @@ var init_setup = __esm({
       "kiro",
       "trae",
       "dsh",
+      "workbuddy",
       "pi"
     ];
     getSetupIntegrationRows2 = getSetupIntegrationRows;
@@ -195698,7 +195851,7 @@ var config_path_exports = {};
 __export(config_path_exports, {
   default: () => config_path_default
 });
-import { homedir as homedir27 } from "os";
+import { homedir as homedir28 } from "os";
 var config_path_default;
 var init_config_path = __esm({
   "src/cli/commands/config-path.ts"() {
@@ -195716,7 +195869,7 @@ var init_config_path = __esm({
       run: async () => {
         const project = detectProject(process.cwd());
         ye2([
-          `Global:  ${getGlobalConfigTomlPath(homedir27())}`,
+          `Global:  ${getGlobalConfigTomlPath(homedir28())}`,
           `Project: ${project ? getProjectConfigTomlPath(project.rootPath) : "not inside a git project"}`
         ].join("\n"), "Memorix config");
       }
@@ -195792,7 +195945,7 @@ __export(config_migrate_exports, {
   serializeResolvedConfigToToml: () => serializeResolvedConfigToToml
 });
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir28 } from "os";
+import { homedir as homedir29 } from "os";
 import { dirname as dirname4 } from "path";
 function serializeResolvedConfigToToml(config2, options = {}) {
   const includeSecrets = options.includeSecrets === true;
@@ -195891,7 +196044,7 @@ var init_config_migrate = __esm({
           v3.error("Not inside a git project. Use `memorix config migrate --global` for global config.");
           return;
         }
-        const target = isGlobal ? getGlobalConfigTomlPath(homedir28()) : getProjectConfigTomlPath(project.rootPath);
+        const target = isGlobal ? getGlobalConfigTomlPath(homedir29()) : getProjectConfigTomlPath(project.rootPath);
         const resolved = getResolvedConfig({ projectRoot: project?.rootPath ?? null });
         const content = serializeResolvedConfigToToml(resolved, { includeSecrets: isGlobal });
         mkdirSync3(dirname4(target), { recursive: true });
@@ -195903,8 +196056,8 @@ var init_config_migrate = __esm({
 });
 
 // src/cli/commands/integrate-shared.ts
-import { homedir as homedir29 } from "os";
-function getIntegrationTargetRoot(useGlobalDefaults, cwd, homeDir = homedir29()) {
+import { homedir as homedir30 } from "os";
+function getIntegrationTargetRoot(useGlobalDefaults, cwd, homeDir = homedir30()) {
   return useGlobalDefaults ? homeDir : cwd;
 }
 function getIntegrationScopeLabel(useGlobalDefaults) {
@@ -195942,7 +196095,8 @@ function getAgentLabel(agent) {
     antigravity: "Antigravity",
     "gemini-cli": "Gemini CLI",
     trae: "Trae",
-    dsh: "DeepSeek Harness"
+    dsh: "DeepSeek Harness",
+    workbuddy: "WorkBuddy"
   };
   return labels[agent] || agent;
 }
@@ -195958,7 +196112,8 @@ function getAgentHint(agent) {
     antigravity: "plugin + MCP + hooks + skills",
     "gemini-cli": "settings + GEMINI.md",
     trae: "rules",
-    dsh: "MCP patch + AGENTS.md + skills"
+    dsh: "MCP patch + AGENTS.md + skills",
+    workbuddy: "MCP + AGENTS.md"
   };
   return hints[agent] || "integration files";
 }
@@ -197017,7 +197172,7 @@ __export(external_provider_exports, {
 });
 import { spawn as spawn5 } from "child_process";
 import { existsSync as existsSync17, readFileSync as readFileSync10 } from "fs";
-import { delimiter, dirname as dirname5, extname, isAbsolute as isAbsolute2, join as join23, relative as relative2, resolve as resolve3, sep as sep2 } from "path";
+import { delimiter, dirname as dirname5, extname, isAbsolute as isAbsolute2, join as join24, relative as relative2, resolve as resolve3, sep as sep2 } from "path";
 function boundedTimeout(value) {
   if (!Number.isFinite(value)) return DEFAULT_EXTERNAL_CODEGRAPH_TIMEOUT_MS;
   return Math.max(100, Math.min(Math.floor(value), MAX_EXTERNAL_CODEGRAPH_TIMEOUT_MS));
@@ -197046,10 +197201,10 @@ function resolveCommandCandidates(command) {
   }
   const names = extname(requested) ? [requested] : process.platform === "win32" ? [requested + ".exe", requested + ".cmd", requested + ".js", requested] : [requested];
   const directories = [
-    ...process.platform === "win32" && process.env.LOCALAPPDATA ? [join23(process.env.LOCALAPPDATA, "codegraph", "current", "bin")] : [],
+    ...process.platform === "win32" && process.env.LOCALAPPDATA ? [join24(process.env.LOCALAPPDATA, "codegraph", "current", "bin")] : [],
     ...(process.env.PATH ?? "").split(delimiter).filter(Boolean)
   ];
-  return [...new Set(directories.flatMap((directory) => names.map((name) => join23(directory, name))))];
+  return [...new Set(directories.flatMap((directory) => names.map((name) => join24(directory, name))))];
 }
 function resolveLaunch(command) {
   for (const candidate2 of resolveCommandCandidates(command)) {
@@ -197057,8 +197212,8 @@ function resolveLaunch(command) {
     const extension3 = extname(candidate2).toLowerCase();
     if (extension3 === ".cmd") {
       const bundleRoot = resolve3(dirname5(candidate2), "..");
-      const node = join23(bundleRoot, "node.exe");
-      const entry = join23(bundleRoot, "lib", "dist", "bin", "codegraph.js");
+      const node = join24(bundleRoot, "node.exe");
+      const entry = join24(bundleRoot, "lib", "dist", "bin", "codegraph.js");
       if (existsSync17(node) && existsSync17(entry)) {
         return { executable: node, prefixArgs: ["--liftoff-only", entry] };
       }
@@ -197210,7 +197365,7 @@ async function inspectExternalCodeGraph(input) {
     const health2 = { state: "disabled", reason: "External CodeGraph is disabled by configuration." };
     return { health: health2, quality: providerQuality({ mode, health: health2 }) };
   }
-  if (!existsSync17(join23(input.projectRoot, ".codegraph"))) {
+  if (!existsSync17(join24(input.projectRoot, ".codegraph"))) {
     const health2 = { state: "not-detected", reason: "No local .codegraph index is present for this project." };
     return { health: health2, quality: providerQuality({ mode, health: health2 }) };
   }
@@ -197245,7 +197400,7 @@ async function runExternalCodeGraphLifecycle(input) {
       quality: providerQuality({ mode, health })
     };
   }
-  const indexPath = join23(input.projectRoot, ".codegraph");
+  const indexPath = join24(input.projectRoot, ".codegraph");
   if (input.action === "sync" && !existsSync17(indexPath)) {
     const health = { state: "not-detected", reason: "No local .codegraph index is present for this project." };
     return {
@@ -203053,8 +203208,8 @@ __export(engine_exports2, {
   SkillsEngine: () => SkillsEngine
 });
 import { existsSync as existsSync19, readFileSync as readFileSync11, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, readdirSync as readdirSync3 } from "fs";
-import { join as join24 } from "path";
-import { homedir as homedir30 } from "os";
+import { join as join25 } from "path";
+import { homedir as homedir31 } from "os";
 var SKILLS_DIRS, SKILL_WORTHY_TYPES, MIN_OBS_FOR_SKILL, MIN_SCORE_FOR_SKILL, LOW_SIGNAL_TITLE_PATTERNS, LOW_SIGNAL_ENTITY_PATTERNS, COMMAND_TRACE_PATTERNS2, SkillsEngine;
 var init_engine4 = __esm({
   "src/skills/engine.ts"() {
@@ -203125,12 +203280,12 @@ var init_engine4 = __esm({
       listSkills() {
         const skills = [];
         const seen = /* @__PURE__ */ new Set();
-        const home = homedir30();
+        const home = homedir31();
         for (const [agent, dirs] of Object.entries(SKILLS_DIRS)) {
           for (const dir of dirs) {
-            const paths = [join24(this.projectRoot, dir)];
+            const paths = [join25(this.projectRoot, dir)];
             if (!this.skipGlobal) {
-              paths.push(join24(home, dir));
+              paths.push(join25(home, dir));
             }
             for (const skillsRoot of paths) {
               if (!existsSync19(skillsRoot)) continue;
@@ -203140,7 +203295,7 @@ var init_engine4 = __esm({
                   if (!entry.isDirectory()) continue;
                   const name = entry.name;
                   if (seen.has(name)) continue;
-                  const skillMd = join24(skillsRoot, name, "SKILL.md");
+                  const skillMd = join25(skillsRoot, name, "SKILL.md");
                   if (!existsSync19(skillMd)) continue;
                   try {
                     const content = readFileSync11(skillMd, "utf-8");
@@ -203148,7 +203303,7 @@ var init_engine4 = __esm({
                     skills.push({
                       name,
                       description,
-                      sourcePath: join24(skillsRoot, name),
+                      sourcePath: join25(skillsRoot, name),
                       sourceAgent: agent,
                       content,
                       generated: false
@@ -203191,11 +203346,11 @@ var init_engine4 = __esm({
       writeSkill(skill2, target) {
         const dirs = SKILLS_DIRS[target];
         if (!dirs || dirs.length === 0) return null;
-        const targetDir = join24(this.projectRoot, dirs[0], skill2.name);
+        const targetDir = join25(this.projectRoot, dirs[0], skill2.name);
         try {
           mkdirSync4(targetDir, { recursive: true });
-          writeFileSync4(join24(targetDir, "SKILL.md"), skill2.content, "utf-8");
-          return join24(dirs[0], skill2.name, "SKILL.md");
+          writeFileSync4(join25(targetDir, "SKILL.md"), skill2.content, "utf-8");
+          return join25(dirs[0], skill2.name, "SKILL.md");
         } catch {
           return null;
         }
@@ -204364,7 +204519,7 @@ var init_task_graph = __esm({
 // src/orchestrate/context-collector.ts
 import { execFileSync as execFileSync2 } from "child_process";
 import { readFileSync as readFileSync12, existsSync as existsSync20 } from "fs";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 function normalizeEntryLimit(value, fallback) {
   if (!Number.isSafeInteger(value) || value < 1) return fallback;
   return Math.min(value, 500);
@@ -204439,7 +204594,7 @@ function collectFileTree(projectDir2, maxEntries) {
 }
 function collectDependencies(projectDir2) {
   try {
-    const pkgPath = join25(projectDir2, "package.json");
+    const pkgPath = join26(projectDir2, "package.json");
     if (!existsSync20(pkgPath)) return "";
     const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
     const parts = [];
@@ -205684,16 +205839,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 +205931,7 @@ var init_tool_profile = __esm({
 function getMcpServerInfo() {
   return {
     name: "memorix",
-    version: true ? "1.8.4" : "1.0.1"
+    version: true ? "1.8.6" : "1.0.1"
   };
 }
 function createMcpDiscoverResult(capabilities, serverInfo) {
@@ -205835,7 +205998,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 +206107,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 +206163,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 +206243,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 +208253,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 +216306,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 +217304,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({
@@ -218934,8 +219737,8 @@ __export(engine_exports3, {
   WorkspaceSyncEngine: () => WorkspaceSyncEngine
 });
 import { readFileSync as readFileSync14, readdirSync as readdirSync4, existsSync as existsSync23, cpSync, mkdirSync as mkdirSync6 } from "fs";
-import { join as join27 } from "path";
-import { homedir as homedir31 } from "os";
+import { join as join28 } from "path";
+import { homedir as homedir32 } from "os";
 var WorkspaceSyncEngine;
 var init_engine5 = __esm({
   "src/workspace/engine.ts"() {
@@ -219007,9 +219810,9 @@ var init_engine5 = __esm({
           const globalPath = adapter.getConfigPath();
           const pathsToCheck = [configPath, globalPath];
           if (target === "antigravity") {
-            pathsToCheck.push(join27(this.projectRoot, ".gemini", "settings.json"));
-            pathsToCheck.push(join27(homedir31(), ".gemini", "settings.json"));
-            pathsToCheck.push(join27(homedir31(), ".gemini", "antigravity", "mcp_config.json"));
+            pathsToCheck.push(join28(this.projectRoot, ".gemini", "settings.json"));
+            pathsToCheck.push(join28(homedir32(), ".gemini", "settings.json"));
+            pathsToCheck.push(join28(homedir32(), ".gemini", "antigravity", "mcp_config.json"));
           }
           const merged = /* @__PURE__ */ new Map();
           for (const path48 of pathsToCheck) {
@@ -219126,7 +219929,7 @@ var init_engine5 = __esm({
       getTargetSkillsDir(target) {
         const dirs = _WorkspaceSyncEngine.SKILLS_DIRS[target];
         if (!dirs || dirs.length === 0) return null;
-        return join27(this.projectRoot, dirs[0]);
+        return join28(this.projectRoot, dirs[0]);
       }
       /**
        * Scan all agent skills directories and collect unique skills.
@@ -219135,12 +219938,12 @@ var init_engine5 = __esm({
         const skills = [];
         const conflicts = [];
         const seen = /* @__PURE__ */ new Map();
-        const home = homedir31();
+        const home = homedir32();
         for (const [agent, dirs] of Object.entries(_WorkspaceSyncEngine.SKILLS_DIRS)) {
           for (const dir of dirs) {
             const paths = [
-              join27(this.projectRoot, dir),
-              join27(home, dir)
+              join28(this.projectRoot, dir),
+              join28(home, dir)
             ];
             for (const skillsRoot of paths) {
               if (!existsSync23(skillsRoot)) continue;
@@ -219148,7 +219951,7 @@ var init_engine5 = __esm({
                 const entries = readdirSync4(skillsRoot, { withFileTypes: true });
                 for (const entry of entries) {
                   if (!entry.isDirectory()) continue;
-                  const skillMd = join27(skillsRoot, entry.name, "SKILL.md");
+                  const skillMd = join28(skillsRoot, entry.name, "SKILL.md");
                   if (!existsSync23(skillMd)) continue;
                   let description = "";
                   try {
@@ -219160,7 +219963,7 @@ var init_engine5 = __esm({
                   const newEntry = {
                     name: entry.name,
                     description,
-                    sourcePath: join27(skillsRoot, entry.name),
+                    sourcePath: join28(skillsRoot, entry.name),
                     sourceAgent: agent
                   };
                   const existing = seen.get(entry.name);
@@ -219197,7 +220000,7 @@ var init_engine5 = __esm({
         }
         for (const skill2 of skills) {
           if (skill2.sourceAgent === target) continue;
-          const dest = join27(targetDir, skill2.name);
+          const dest = join28(targetDir, skill2.name);
           if (existsSync23(dest)) {
             skipped.push(`${skill2.name} (already exists in ${target})`);
             continue;
@@ -219213,13 +220016,13 @@ var init_engine5 = __esm({
       }
       scanWorkflows() {
         const workflows = [];
-        const wfDir = join27(this.projectRoot, ".windsurf", "workflows");
+        const wfDir = join28(this.projectRoot, ".windsurf", "workflows");
         if (!existsSync23(wfDir)) return workflows;
         try {
           const files = readdirSync4(wfDir).filter((f7) => f7.endsWith(".md"));
           for (const file2 of files) {
             try {
-              const content = readFileSync14(join27(wfDir, file2), "utf-8");
+              const content = readFileSync14(join28(wfDir, file2), "utf-8");
               workflows.push(this.workflowSyncer.parseWindsurfWorkflow(file2, content));
             } catch {
             }
@@ -219494,7 +220297,7 @@ __export(behavior_exports, {
   resetBehaviorConfigCache: () => resetBehaviorConfigCache
 });
 import { existsSync as existsSync24, readFileSync as readFileSync15 } from "fs";
-import { homedir as homedir32 } from "os";
+import { homedir as homedir33 } from "os";
 function isSessionInject(value) {
   return value === "full" || value === "minimal" || value === "silent";
 }
@@ -219512,7 +220315,7 @@ function legacyBehavior(homeDir) {
   }
 }
 function getBehaviorConfig(options = {}) {
-  const homeDir = options.homeDir ?? homedir32();
+  const homeDir = options.homeDir ?? homedir33();
   const projectRoot = options.projectRoot === void 0 ? detectProject()?.rootPath ?? null : options.projectRoot;
   const cacheKey2 = `${homeDir}\0${projectRoot ?? ""}`;
   const cached2 = cache4.get(cacheKey2);
@@ -220944,7 +221747,7 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
       case "/config": {
         const os9 = await import("os");
         const { existsSync: existsSync34 } = await import("fs");
-        const { join: join34 } = await import("path");
+        const { join: join35 } = await import("path");
         const configProjectRoot = effectiveProjectRoot;
         const resolved = getResolvedConfig({ projectRoot: configProjectRoot });
         const files = {
@@ -220959,13 +221762,13 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
         try {
           const home = os9.homedir();
           const paths = {
-            "project memorix.yml": configProjectRoot ? join34(configProjectRoot, "memorix.yml") : null,
-            "user memorix.yml": join34(home, ".memorix", "memorix.yml"),
-            "project memorix.toml": configProjectRoot ? join34(configProjectRoot, "memorix.toml") : null,
-            "user config.toml": join34(home, ".memorix", "config.toml"),
-            "project .env": configProjectRoot ? join34(configProjectRoot, ".env") : null,
-            "user .env": join34(home, ".memorix", ".env"),
-            "legacy config.json": join34(home, ".memorix", "config.json")
+            "project memorix.yml": configProjectRoot ? join35(configProjectRoot, "memorix.yml") : null,
+            "user memorix.yml": join35(home, ".memorix", "memorix.yml"),
+            "project memorix.toml": configProjectRoot ? join35(configProjectRoot, "memorix.toml") : null,
+            "user config.toml": join35(home, ".memorix", "config.toml"),
+            "project .env": configProjectRoot ? join35(configProjectRoot, ".env") : null,
+            "user .env": join35(home, ".memorix", ".env"),
+            "legacy config.json": join35(home, ".memorix", "config.json")
           };
           for (const [key, fpath] of Object.entries(paths)) {
             if (fpath === null) {
@@ -263891,10 +264694,10 @@ ${Math.max(0, managedIds.size - result.resolved.length)} visible writable observ
   );
   let enableKG = isToolInProfile("create_entities", toolProfile);
   try {
-    const { homedir: homedir36 } = await import("os");
-    const { join: join34 } = await import("path");
+    const { homedir: homedir37 } = await import("os");
+    const { join: join35 } = await import("path");
     const { readFile: readFile10 } = await import("fs/promises");
-    const raw = await readFile10(join34(homedir36(), ".memorix", "settings.json"), "utf-8");
+    const raw = await readFile10(join35(homedir37(), ".memorix", "settings.json"), "utf-8");
     const s4 = JSON.parse(raw);
     if (s4.knowledgeGraph === true) enableKG = true;
   } catch {
@@ -266275,6 +267078,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, {
@@ -266392,8 +267270,8 @@ __export(update_checker_exports, {
 });
 import { execFile as execFile3 } from "child_process";
 import { readFile as readFile7, writeFile as writeFile8, mkdir as mkdir7 } from "fs/promises";
-import { join as join28 } from "path";
-import { homedir as homedir33 } from "os";
+import { join as join29 } from "path";
+import { homedir as homedir34 } from "os";
 function getCurrentVersion() {
   try {
     return getCliVersion();
@@ -266572,8 +267450,8 @@ var init_update_checker = __esm({
     MIN_AUTO_UPDATE_TIMEOUT_MS = 5e3;
     MAX_AUTO_UPDATE_TIMEOUT_MS = 30 * 60 * 1e3;
     REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
-    CACHE_DIR2 = join28(homedir33(), ".memorix");
-    CACHE_FILE2 = join28(CACHE_DIR2, "update-check.json");
+    CACHE_DIR2 = join29(homedir34(), ".memorix");
+    CACHE_FILE2 = join29(CACHE_DIR2, "update-check.json");
     _testing = {
       CACHE_FILE: CACHE_FILE2,
       CHECK_INTERVAL_MS,
@@ -266628,6 +267506,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: homedir37 } = 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,21 +267523,22 @@ 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();
         } catch {
-          safeCwd = homedir36();
+          safeCwd = homedir37();
         }
         const resolution = resolveServeProject2(
           {
@@ -266659,74 +267546,86 @@ var init_serve = __esm({
             envProjectRoot: process.env.MEMORIX_PROJECT_ROOT,
             initCwd: process.env.INIT_CWD,
             processCwd: safeCwd,
-            homeDir: homedir36()
+            homeDir: homedir37()
           },
           { 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 +267642,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 +269941,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;
@@ -269081,9 +269983,12 @@ var init_serve_http = __esm({
         const { createProjectBindingController: createProjectBindingController2 } = await Promise.resolve().then(() => (init_request_context(), request_context_exports));
         const { findGitInSubdirs: findGitInSubdirs2 } = await Promise.resolve().then(() => (init_detector(), detector_exports));
         const { writeFileSync: writeFileSync12, mkdirSync: mkdirSync12 } = await import("fs");
-        const { homedir: homedir36 } = await import("os");
+        const { homedir: homedir37 } = 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));
@@ -269099,7 +270004,7 @@ var init_serve_http = __esm({
         try {
           safeCwd = process.cwd();
         } catch {
-          safeCwd = homedir36();
+          safeCwd = homedir37();
         }
         const { resolveServeProject: resolveServeProject2 } = await Promise.resolve().then(() => (init_serve_shared(), serve_shared_exports));
         const { writeLastProjectRoot: writeLastProjectRoot2 } = await Promise.resolve().then(() => (init_launch_root(), launch_root_exports));
@@ -269110,7 +270015,7 @@ var init_serve_http = __esm({
             cwdArg: args.cwd,
             envProjectRoot: process.env.MEMORIX_PROJECT_ROOT,
             processCwd: safeCwd,
-            homeDir: homedir36()
+            homeDir: homedir37()
           },
           { detectProject: detectorMod.detectProject, findGitInSubdirs: detectorMod.findGitInSubdirs, isSystemDirectory: detectorMod.isSystemDirectory }
         );
@@ -269138,6 +270043,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 +270209,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)) {
@@ -270010,7 +270892,7 @@ var init_serve_http = __esm({
               const { projectId: configProjectId } = await resolveRequestProject(url2);
               const os9 = await import("os");
               const { existsSync: existsSync34 } = await import("fs");
-              const { join: join34 } = await import("path");
+              const { join: join35 } = await import("path");
               const { loadYamlConfig: loadYamlConfig2 } = await Promise.resolve().then(() => (init_yaml_loader(), yaml_loader_exports));
               const { loadFileConfig: loadFileConfig2, loadDotenv: loadDotenv2, getLoadedEnvFiles: getLoadedEnvFiles2 } = await Promise.resolve().then(() => (init_config(), config_exports));
               const isStartupProject = configProjectId === defaultProject.id;
@@ -270024,11 +270906,11 @@ var init_serve_http = __esm({
               const home = os9.homedir();
               if (effectiveRoot) {
                 const paths = {
-                  "project memorix.yml": join34(effectiveRoot, "memorix.yml"),
-                  "user memorix.yml": join34(home, ".memorix", "memorix.yml"),
-                  "project .env": join34(effectiveRoot, ".env"),
-                  "user .env": join34(home, ".memorix", ".env"),
-                  "legacy config.json": join34(home, ".memorix", "config.json")
+                  "project memorix.yml": join35(effectiveRoot, "memorix.yml"),
+                  "user memorix.yml": join35(home, ".memorix", "memorix.yml"),
+                  "project .env": join35(effectiveRoot, ".env"),
+                  "user .env": join35(home, ".memorix", ".env"),
+                  "legacy config.json": join35(home, ".memorix", "config.json")
                 };
                 for (const [key, fpath] of Object.entries(paths)) {
                   files[key] = { exists: existsSync34(fpath), path: fpath };
@@ -270037,9 +270919,9 @@ var init_serve_http = __esm({
                 files["project memorix.yml"] = { exists: false, path: "unavailable", unavailable: true };
                 files["project .env"] = { exists: false, path: "unavailable", unavailable: true };
                 const userPaths = {
-                  "user memorix.yml": join34(home, ".memorix", "memorix.yml"),
-                  "user .env": join34(home, ".memorix", ".env"),
-                  "legacy config.json": join34(home, ".memorix", "config.json")
+                  "user memorix.yml": join35(home, ".memorix", "memorix.yml"),
+                  "user .env": join35(home, ".memorix", ".env"),
+                  "legacy config.json": join35(home, ".memorix", "config.json")
                 };
                 for (const [key, fpath] of Object.entries(userPaths)) {
                   files[key] = { exists: existsSync34(fpath), path: fpath };
@@ -270316,6 +271198,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 +271213,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 +271286,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 });
@@ -272873,6 +273761,7 @@ var init_types9 = __esm({
       opencode: "community",
       trae: "community",
       dsh: "community",
+      workbuddy: "community",
       pi: "community",
       omp: "community",
       antigravity: "community"
@@ -272893,8 +273782,14 @@ async function installSingleAgent2(agent, cwd, global2) {
       cwd,
       global2
     );
-    console.log(`[OK] ${agent}: hooks installed -> ${config2.configPath}`);
+    const note = config2.generated?.note;
+    if (config2.configPath) {
+      console.log(`[OK] ${agent}: hooks installed -> ${config2.configPath}`);
+    } else {
+      console.log(`[OK] ${agent}: no hooks installed at this scope (MCP-only integration)`);
+    }
     console.log(`   Events: ${config2.events.join(", ")}`);
+    if (!config2.configPath && note) console.log(`   Note: ${note}`);
     if (agent === "copilot" && process.platform === "win32") {
       try {
         const { execSync: execSync5 } = await import("child_process");
@@ -272910,7 +273805,6 @@ async function installSingleAgent2(agent, cwd, global2) {
       }
     }
     if (agent === "copilot" && global2) {
-      const note = config2.generated?.note;
       if (note) console.warn(`[WARN]  ${note}`);
     }
   } catch (err) {
@@ -272932,7 +273826,8 @@ function getAgentLabel2(agent) {
     hermes: "Hermes Agent",
     omp: "Oh-my-Pi",
     trae: "Trae",
-    dsh: "DeepSeek Harness"
+    dsh: "DeepSeek Harness",
+    workbuddy: "WorkBuddy"
   };
   return labels[agent] || agent;
 }
@@ -272951,6 +273846,7 @@ function getAgentHint2(agent) {
     omp: "Oh-my-Pi package hooks; use `memorix setup --agent omp`",
     trae: ".trae/rules/project_rules.md (rules only, no hooks system)",
     dsh: "~/.dsh/cordis.patch.yml MCP row via `memorix setup --agent dsh` (no hooks system)",
+    workbuddy: "~/.workbuddy/mcp.json MCP row via `memorix setup --agent workbuddy` (no hooks system)",
     codex: "Codex plugin hooks; use `memorix setup --agent codex`"
   };
   return hints[agent] || "";
@@ -273059,7 +273955,8 @@ function estimateFileSize(agent, configPath) {
     antigravity: "~2KB",
     opencode: "~3KB",
     trae: "~1KB",
-    dsh: "~1KB"
+    dsh: "~1KB",
+    workbuddy: "~1KB"
   };
   return sizes[agent] || "~2KB";
 }
@@ -273079,6 +273976,8 @@ function getRulesPath(agent, cwd, global2) {
         return path42.join(home, ".trae", "rules", "project_rules.md");
       case "dsh":
         return path42.join(process.env.DSH_HOME?.trim() || path42.join(home, ".dsh"), "AGENTS.md");
+      case "workbuddy":
+        return "";
       default:
         return "";
     }
@@ -273096,6 +273995,8 @@ function getRulesPath(agent, cwd, global2) {
         return path42.join(cwd, ".trae", "rules", "project_rules.md");
       case "dsh":
         return path42.join(cwd, "AGENTS.md");
+      case "workbuddy":
+        return path42.join(cwd, "AGENTS.md");
       default:
         return "";
     }
@@ -275000,6 +275901,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 +276067,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 +276295,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 +276362,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 +276397,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 +276411,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 +276454,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 +276550,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 +276558,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 +276583,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 +276602,7 @@ var init_background = __esm({
               await doStop();
               break;
             case "status":
-              await doStatus();
+              await doStatus(!!args.json);
               break;
             case "restart":
               await doRestart(port);
@@ -275609,6 +276628,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 +276650,10 @@ var init_background = __esm({
       formatBackgroundCommandError,
       resolveBackgroundCliEntry,
       resolveBackgroundCliEntryFrom,
-      resolveBackgroundCwd
+      resolveBackgroundCwd,
+      acquireBackgroundLock,
+      releaseBackgroundLock,
+      getBackgroundLockPath
     };
   }
 });
@@ -275648,7 +276671,7 @@ import { spawnSync as spawnSync2 } from "child_process";
 import { existsSync as existsSync29, realpathSync as realpathSync2 } from "fs";
 import { mkdir as mkdir8, readFile as readFile9, writeFile as writeFile9 } from "fs/promises";
 import { basename as basename5, dirname as dirname8, resolve as resolve4 } from "path";
-import { homedir as homedir34 } from "os";
+import { homedir as homedir35 } from "os";
 function requestedAgents(agent) {
   const all = getSetupAgentTargets();
   if (!agent || agent === "all") return all;
@@ -275726,16 +276749,16 @@ function asRecordArray(value) {
   return Array.isArray(value) ? value.map(asRecord3).filter((entry) => entry !== null) : [];
 }
 function codexPluginPath() {
-  return `${homedir34()}/plugins/${CODEX_PLUGIN_NAME}`;
+  return `${homedir35()}/plugins/${CODEX_PLUGIN_NAME}`;
 }
 function codexPluginMcpPath() {
   return `${codexPluginPath()}/.mcp.json`;
 }
 function codexMarketplacePath() {
-  return `${homedir34()}/.agents/plugins/marketplace.json`;
+  return `${homedir35()}/.agents/plugins/marketplace.json`;
 }
 function codexConfigPath() {
-  return `${homedir34()}/.codex/config.toml`;
+  return `${homedir35()}/.codex/config.toml`;
 }
 function normalizeMarketplacePath(value) {
   return value.replace(/\\/g, "/").replace(/^\.\//, "");
@@ -276050,7 +277073,7 @@ function canonicalProjectPath(projectRoot) {
   return canonical.replace(/\\/g, "/");
 }
 function getClaudeLocalConfigPath() {
-  return `${homedir34()}/.claude.json`;
+  return `${homedir35()}/.claude.json`;
 }
 function coerceMcpServer(name, value) {
   const entry = asRecord3(value);
@@ -276309,7 +277332,7 @@ async function inspectGuidance(agent, projectRoot, scope) {
   }
   const checks = [];
   for (const targetScope of requestedGuidanceScopes(scope)) {
-    const root = targetScope === "project" ? projectRoot : homedir34();
+    const root = targetScope === "project" ? projectRoot : homedir35();
     const rulesPath = getAgentRulesPath(agent, root, targetScope === "global");
     if (!existsSync29(rulesPath)) {
       checks.push({
@@ -276526,7 +277549,8 @@ var init_agent_integrations = __esm({
       "kiro",
       "opencode",
       "trae",
-      "dsh"
+      "dsh",
+      "workbuddy"
     ]);
     CODEX_PLUGIN_NAME = "memorix";
     CODEX_PLUGIN_MARKETPLACE = "personal";
@@ -276588,8 +277612,8 @@ var init_doctor = __esm({
           return;
         }
         const { existsSync: existsSync34, readFileSync: readFileSync23 } = await import("fs");
-        const { join: join34, basename: basename7 } = await import("path");
-        const { homedir: homedir36 } = await import("os");
+        const { join: join35, basename: basename7 } = await import("path");
+        const { homedir: homedir37 } = await import("os");
         const { execSync: execSync5 } = await import("child_process");
         const report = {};
         const issues = [];
@@ -276651,8 +277675,8 @@ var init_doctor = __esm({
         }
         lines.push("");
         lines.push("\u250C\u2500 Runtime Mode \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-        const memorixDir = join34(homedir36(), ".memorix");
-        const bgStatePath = join34(memorixDir, "background.json");
+        const memorixDir = join35(homedir37(), ".memorix");
+        const bgStatePath = join35(memorixDir, "background.json");
         let bgRunning = false;
         let bgPort = 0;
         let bgPid = 0;
@@ -276772,7 +277796,7 @@ var init_doctor = __esm({
               }
             }
             try {
-              const cachePath = join34(memorixDir, "embedding-cache.json");
+              const cachePath = join35(memorixDir, "embedding-cache.json");
               if (existsSync34(cachePath)) {
                 const cache5 = JSON.parse(readFileSync23(cachePath, "utf-8"));
                 const cacheCount = Object.keys(cache5).length;
@@ -276966,7 +277990,7 @@ var init_doctor = __esm({
         lines.push("\u250C\u2500 Conflict Check \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
         let conflictsFound = false;
         if (dataDir) {
-          const lockFile = join34(dataDir, ".memorix.lock");
+          const lockFile = join35(dataDir, ".memorix.lock");
           if (existsSync34(lockFile)) {
             try {
               const lockData = JSON.parse(readFileSync23(lockFile, "utf-8"));
@@ -277469,7 +278493,8 @@ var init_purge = __esm({
 // src/cli/commands/uninstall.ts
 var uninstall_exports = {};
 __export(uninstall_exports, {
-  default: () => uninstall_default
+  default: () => uninstall_default,
+  getMCPConfigEntries: () => getMCPConfigEntries
 });
 import * as fs27 from "fs";
 import * as path46 from "path";
@@ -277652,6 +278677,24 @@ function getMCPConfigEntries(home, cwd) {
     detected: checkDshPatch(dshPatchPath),
     note: "Remove the memory-memorix insert row from this patch file."
   });
+  const workbuddyCfg = path46.join(home, ".workbuddy", "mcp.json");
+  entries.push({
+    agent: "WorkBuddy",
+    path: workbuddyCfg,
+    kind: "global",
+    format: "json",
+    detected: checkJSON(workbuddyCfg),
+    note: 'Remove the "memorix" key from mcpServers in this file.'
+  });
+  const workbuddyProjectCfg = path46.join(cwd, ".workbuddy", "mcp.json");
+  entries.push({
+    agent: "WorkBuddy",
+    path: workbuddyProjectCfg,
+    kind: "project",
+    format: "json",
+    detected: checkJSON(workbuddyProjectCfg),
+    note: 'Remove the "memorix" key from mcpServers in this file.'
+  });
   return entries;
 }
 function checkBackground(home) {
@@ -279156,7 +280199,7 @@ var init_pipeline_trace = __esm({
 // src/orchestrate/worktree.ts
 import { execFileSync as execFileSync5 } from "child_process";
 import { existsSync as existsSync31, rmSync as rmSync2 } from "fs";
-import { join as join32, basename as basename6 } from "path";
+import { join as join33, basename as basename6 } from "path";
 function runGit4(cwd, args, timeout = 5e3) {
   return String(execFileSync5("git", args, {
     cwd,
@@ -279195,7 +280238,7 @@ function isManagedWorktreePath(worktreePath, worktreeBase) {
 function createWorktree(projectDir2, taskId, pipelineId) {
   const shortId2 = taskId.slice(0, 8);
   const shortPipeline = pipelineId.slice(0, 8);
-  const worktreeBase = join32(projectDir2, WORKTREE_DIR, `task-${shortId2}`);
+  const worktreeBase = join33(projectDir2, WORKTREE_DIR, `task-${shortId2}`);
   const branchBase = `pipeline/${shortPipeline}/task-${shortId2}`;
   for (let attempt = 1; attempt <= 100; attempt++) {
     const suffix = attempt === 1 ? "" : `-${attempt}`;
@@ -279285,7 +280328,7 @@ function listWorktrees(projectDir2) {
       }
     }
     if (current) worktrees.push(current);
-    const worktreeBase = join32(projectDir2, WORKTREE_DIR);
+    const worktreeBase = join33(projectDir2, WORKTREE_DIR);
     return worktrees.filter((w4) => isManagedWorktreePath(w4.path, worktreeBase));
   } catch {
     return [];
@@ -279707,16 +280750,16 @@ var init_cost_tracker = __esm({
 
 // src/orchestrate/evidence.ts
 import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 function writeTaskEvidence(projectDir2, pipelineId, evidence) {
   try {
-    const dir = join33(projectDir2, ".pipeline", pipelineId, "evidence", evidence.taskId.slice(0, 12));
+    const dir = join34(projectDir2, ".pipeline", pipelineId, "evidence", evidence.taskId.slice(0, 12));
     mkdirSync10(dir, { recursive: true });
     if (evidence.prompt) {
-      safeWrite(join33(dir, "prompt.md"), evidence.prompt);
+      safeWrite(join34(dir, "prompt.md"), evidence.prompt);
     }
     if (evidence.tailOutput) {
-      safeWrite(join33(dir, "output.txt"), evidence.tailOutput);
+      safeWrite(join34(dir, "output.txt"), evidence.tailOutput);
     }
     if (evidence.gateResults) {
       for (const g4 of evidence.gateResults) {
@@ -279725,7 +280768,7 @@ Status: ${g4.passed ? "PASS" : "FAIL"}
 Duration: ${(g4.durationMs / 1e3).toFixed(1)}s
 
 ${g4.output}`;
-        safeWrite(join33(dir, `${g4.gate}.txt`), content);
+        safeWrite(join34(dir, `${g4.gate}.txt`), content);
       }
     }
     const resultJson = {
@@ -279739,7 +280782,7 @@ ${g4.output}`;
       tokenUsage: evidence.tokenUsage,
       costUSD: evidence.costUSD
     };
-    safeWrite(join33(dir, "result.json"), JSON.stringify(resultJson, null, 2));
+    safeWrite(join34(dir, "result.json"), JSON.stringify(resultJson, null, 2));
     return dir;
   } catch {
     return null;
@@ -279747,7 +280790,7 @@ ${g4.output}`;
 }
 function writePipelineSummary(projectDir2, summary) {
   try {
-    const dir = join33(projectDir2, ".pipeline", summary.pipelineId);
+    const dir = join34(projectDir2, ".pipeline", summary.pipelineId);
     mkdirSync10(dir, { recursive: true });
     const elapsed = (summary.elapsedMs / 1e3).toFixed(0);
     const lines = [
@@ -279768,8 +280811,8 @@ function writePipelineSummary(projectDir2, summary) {
       lines.push(`- [${status}] ${t4.taskDescription.slice(0, 80)} \u2014 ${t4.agentName}, ${dur}s${fixes}`);
     }
     const content = lines.join("\n") + "\n";
-    safeWrite(join33(dir, "summary.md"), content);
-    return join33(dir, "summary.md");
+    safeWrite(join34(dir, "summary.md"), content);
+    return join34(dir, "summary.md");
   } catch {
     return null;
   }
@@ -285996,6 +287039,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 +287061,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 +287604,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");