@plur-ai/mcp 0.20.0 → 0.21.0

package/dist/{chunk-CYXWRLDH.js → chunk-WA3JKTZ7.js}

@@ -1,5 +1,5 @@
 // src/version.ts
-var VERSION = "0.20.0";
+var VERSION = "0.21.0";
 
 export {
   VERSION

package/dist/index.d.ts

@@ -27,5 +27,49 @@ declare function compareSemver(a: string, b: string): number;
  * anchors to start-of-line so a leading space breaks the match.
  */
 declare function extractManifestVersion(skillMdPath: string): string | null;
+/**
+ * Hook set for `plur-mcp init`. Mirrors `buildInjectionHooks` in
+ * @plur-ai/cli's init.ts, which this package cannot import. The rehydrate
+ * entry must stay identical to the cli's; test/init-hooks.test.ts fails if
+ * the two diverge (#1279).
+ */
+declare function buildPlurHooks(cli: string): Record<string, HookEntry[]>;
+interface Settings {
+    hooks?: Record<string, HookEntry[]>;
+    [key: string]: unknown;
+}
+interface HookEntry {
+    matcher?: string;
+    hooks: Array<{
+        type: string;
+        command: string;
+        args?: string[];
+        timeout?: number;
+        async?: boolean;
+    }>;
+}
+/**
+ * Merge PLUR hooks into Claude Code settings (#1279). No I/O apart from
+ * reading plur-hook.meta.json for the exec-form check.
+ * A hook is PLUR's only when isPlurHookSpec says so: the whole command is
+ * PLUR's launcher (the shim, with any slash direction or quoting, or the npx
+ * fallback, or on Windows the exec form `plur init` writes) followed by a
+ * `hook-*` subcommand and plain arguments (decisions H2, F4).
+ * - No PLUR hook present: append the full set ('installed').
+ * - PLUR hooks present: remove PLUR's hooks from PostCompact, which cannot
+ *   carry context (#1274), one hook at a time, dropping an entry only when
+ *   it has no hooks left. If a PLUR rehydrate was among them, add the
+ *   SessionStart(compact) entry unless one is there ('healed'). A file with
+ *   PLUR hooks but no rehydrate (the global file `plur init --project` writes) gets
+ *   none added. Nothing else changes, so a fuller
+ *   `plur init` install is not replaced by this smaller set.
+ * - Otherwise 'already', and the settings come back unchanged.
+ * User hooks are never removed or reordered, including a user hook that
+ * shares an entry with a PLUR hook.
+ */
+declare function applyPlurHooks(settings: Settings, hooksMap: Record<string, HookEntry[]>): {
+    settings: Settings;
+    status: 'installed' | 'healed' | 'already';
+};
 
-export { compareSemver, extractManifestVersion };
+export { type HookEntry, type Settings, applyPlurHooks, buildPlurHooks, compareSemver, extractManifestVersion };

package/dist/index.js

@@ -1,13 +1,72 @@
 #!/usr/bin/env node
 import {
   VERSION
-} from "./chunk-CYXWRLDH.js";
+} from "./chunk-WA3JKTZ7.js";
 
 // src/index.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from "fs";
-import { join } from "path";
+import { existsSync, readFileSync as readFileSync2, writeFileSync, mkdirSync, readdirSync, statSync } from "fs";
+import { join as join2 } from "path";
 import { fileURLToPath } from "url";
-import { homedir, platform } from "os";
+import { homedir as homedir2, platform } from "os";
+
+// src/hook-command.ts
+import { homedir } from "os";
+import { readFileSync } from "fs";
+import { join } from "path";
+function isPlurHookSpec(spec) {
+  const command = typeof spec.command === "string" ? spec.command : "";
+  const args = Array.isArray(spec.args) ? spec.args.filter((a) => typeof a === "string") : [];
+  if (args.length === 0) return isPlurHookCommand(command);
+  const norm = (p) => p.replace(/\\/g, "/").replace(/"/g, "").toLowerCase();
+  const cmd = norm(command);
+  if (/(^|\/)cmd(\.exe)?$/.test(cmd)) return isPlurHookCommand(args.filter((a) => a.toLowerCase() !== "/c").join(" "));
+  if (!/(^|\/)node(\.exe)?$/.test(cmd)) return false;
+  if (!/^hook-[a-z0-9][a-z0-9-]*$/.test(args[1] ?? "")) return false;
+  const target = normEntry(args[0]);
+  return recordedCliEntries().some((e) => normEntry(e) === target);
+}
+function normEntry(p) {
+  return p.replace(/\\/g, "/").replace(/"/g, "").toLowerCase();
+}
+function entriesOf(meta) {
+  if (!meta || typeof meta !== "object") return [];
+  const m = meta;
+  if (Array.isArray(m.entrypoints)) return m.entrypoints.filter((e) => typeof e === "string" && e.length > 0);
+  return typeof m.entrypoint === "string" && m.entrypoint.length > 0 ? [m.entrypoint] : [];
+}
+function recordedCliEntries() {
+  try {
+    return entriesOf(JSON.parse(readFileSync(join(homedir(), ".plur", "bin", "plur-hook.meta.json"), "utf8")));
+  } catch {
+    return [];
+  }
+}
+var PLAIN = "[^\\s\"'`$&;|<>()]";
+var HOOK_TAIL = `[ \\t]+hook-[a-z0-9][a-z0-9-]*(?:[ \\t]+${PLAIN}+)*[ \\t]*$`;
+var SHIM_FILE = "(?:plur-hook(?:\\.cmd)?|(?<=/(?:\\.plur|plur~\\d+)/bin/)plur-h~\\d+\\.cmd)";
+var SHIM_PATH = [
+  `(?:${PLAIN}*/)?${SHIM_FILE}`,
+  `"(?:[^"]*/)?${SHIM_FILE}"`
+].join("|");
+var SHIM_FORM = new RegExp(`^(?:&[ \\t]+)?(?:${SHIM_PATH})${HOOK_TAIL}`);
+var NPX_FORM = new RegExp(`^npx(?:[ \\t]+-y)?[ \\t]+@plur-ai/cli(?:@${PLAIN}+)?${HOOK_TAIL}`);
+var HOME_SHIM_TAIL = new RegExp(`^${HOOK_TAIL}`);
+function homeShimPaths() {
+  const bin = `${homedir().replace(/\\/g, "/").toLowerCase().replace(/\/+$/, "")}/.plur/bin/`;
+  if (/[\r\n]/.test(bin)) return [];
+  return [`${bin}plur-hook.cmd`, `${bin}plur-hook`];
+}
+var MAX_HOOK_COMMAND_LENGTH = 8192;
+function isPlurHookCommand(command) {
+  return command.length <= MAX_HOOK_COMMAND_LENGTH && matchesPlurHookLauncher(command);
+}
+function matchesPlurHookLauncher(command) {
+  const normalised = command.trim().replace(/\\/g, "/").toLowerCase();
+  if (SHIM_FORM.test(normalised) || NPX_FORM.test(normalised)) return true;
+  return homeShimPaths().some((p) => normalised.startsWith(p) && HOME_SHIM_TAIL.test(normalised.slice(p.length)));
+}
+
+// src/index.ts
 var HELP = `plur-mcp v${VERSION} \u2014 persistent memory for AI agents
 
 Usage:
@@ -49,7 +108,7 @@ function compareSemver(a, b) {
 }
 function extractManifestVersion(skillMdPath) {
   try {
-    const content = readFileSync(skillMdPath, "utf8");
+    const content = readFileSync2(skillMdPath, "utf8");
     const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---/m);
     if (!fmMatch) return null;
     const versionMatch = fmMatch[1].match(/^version:\s*"?([^"\n]+)"?\s*$/m);
@@ -59,40 +118,57 @@ function extractManifestVersion(skillMdPath) {
   }
 }
 var _shimName = platform() === "win32" ? "plur-hook.cmd" : "plur-hook";
-var _shimCandidate = join(homedir(), ".plur", "bin", _shimName);
+var _shimCandidate = join2(homedir2(), ".plur", "bin", _shimName);
 var CLI = existsSync(_shimCandidate) ? _shimCandidate : "npx @plur-ai/cli";
-var PLUR_HOOKS = {
-  // --- Session lifecycle ---
-  UserPromptSubmit: [{
-    hooks: [{ type: "command", command: `${CLI} hook-inject`, timeout: 15 }]
-  }],
-  PostCompact: [{
-    matcher: "auto|manual",
-    hooks: [{ type: "command", command: `${CLI} hook-inject --rehydrate`, timeout: 15 }]
-  }],
-  // Auto-close the memory lifecycle at session end (Claude Code SessionEnd,
-  // shipped v1.0.85) — captures a closing episode and cleans up the session
-  // checkpoint even if the agent forgot to call plur_session_end (#217).
-  SessionEnd: [{
-    hooks: [{ type: "command", command: `${CLI} hook-session-end`, timeout: 5 }]
-  }],
-  // --- Contextual injection ---
-  PreToolUse: [
-    { matcher: "EnterPlanMode", hooks: [{ type: "command", command: `${CLI} hook-inject --event plan_mode`, timeout: 10 }] },
-    { matcher: "Skill", hooks: [{ type: "command", command: `${CLI} hook-inject --event skill`, timeout: 10 }] },
-    { matcher: "Agent", hooks: [{ type: "command", command: `${CLI} hook-inject --event agent`, timeout: 10 }] },
-    { matcher: "Bash|Edit|Write|Agent", hooks: [{ type: "command", command: `${CLI} hook-observe`, timeout: 3 }] }
-  ],
-  PostToolUse: [
-    { matcher: "Bash|Edit|Write|Agent", hooks: [{ type: "command", command: `${CLI} hook-observe --post`, timeout: 3 }] }
-  ],
-  SubagentStart: [
-    { matcher: ".*", hooks: [{ type: "command", command: `${CLI} hook-inject --event subagent`, timeout: 10 }] }
-  ],
-  Stop: [
-    { matcher: "*", hooks: [{ type: "command", command: `${CLI} hook-learn-check`, timeout: 2 }] }
-  ]
-};
+function buildPlurHooks(cli) {
+  return {
+    // --- Session lifecycle ---
+    // Sync with a 20s budget, like `plur init` (#1313): async context reaches
+    // Claude Code only at the next safe point, so a first reply without tool
+    // calls had no memory. hook-inject exits by itself after 15s, so the
+    // timeout sits above that. Keep in step with CLAUDE_INJECT_TIMEOUT_S in
+    // @plur-ai/cli's lib/claude-inject-budget.ts.
+    UserPromptSubmit: [{
+      hooks: [{ type: "command", command: `${cli} hook-inject`, timeout: 20 }]
+    }],
+    // Re-inject after compaction. SessionStart with matcher "compact" fires
+    // right after compaction and can carry context; PostCompact cannot
+    // (#1274, #1279). Re-running init moves an old PostCompact entry here.
+    SessionStart: [{
+      matcher: "compact",
+      hooks: [{ type: "command", command: `${cli} hook-inject --rehydrate`, timeout: 20 }]
+    }, {
+      // `claude --resume` keeps the session id, and SessionEnd below deleted
+      // its folder-question nonces: the resumed session is asked again with a
+      // fresh nonce (#1347, option C). Identical to `plur init`'s entry.
+      matcher: "resume",
+      hooks: [{ type: "command", command: `${cli} hook-session-resume`, timeout: 3 }]
+    }],
+    // Auto-close the memory lifecycle at session end (Claude Code SessionEnd,
+    // shipped v1.0.85) — captures a closing episode and cleans up the session
+    // checkpoint even if the agent forgot to call plur_session_end (#217).
+    SessionEnd: [{
+      hooks: [{ type: "command", command: `${cli} hook-session-end`, timeout: 5 }]
+    }],
+    // --- Contextual injection ---
+    PreToolUse: [
+      { matcher: "EnterPlanMode", hooks: [{ type: "command", command: `${cli} hook-inject --event plan_mode`, timeout: 10 }] },
+      { matcher: "Skill", hooks: [{ type: "command", command: `${cli} hook-inject --event skill`, timeout: 10 }] },
+      { matcher: "Agent", hooks: [{ type: "command", command: `${cli} hook-inject --event agent`, timeout: 10 }] },
+      { matcher: "Bash|Edit|Write|Agent", hooks: [{ type: "command", command: `${cli} hook-observe`, timeout: 3 }] }
+    ],
+    PostToolUse: [
+      { matcher: "Bash|Edit|Write|Agent", hooks: [{ type: "command", command: `${cli} hook-observe --post`, timeout: 3 }] }
+    ],
+    SubagentStart: [
+      { matcher: ".*", hooks: [{ type: "command", command: `${cli} hook-inject --event subagent`, timeout: 10 }] }
+    ],
+    Stop: [
+      { matcher: "*", hooks: [{ type: "command", command: `${cli} hook-learn-check`, timeout: 2 }] }
+    ]
+  };
+}
+var PLUR_HOOKS = buildPlurHooks(CLI);
 var CLAUDE_MD_SECTION = `## PLUR Memory
 
 You have persistent memory via PLUR. Corrections, preferences, and conventions persist across sessions as engrams.
@@ -122,11 +198,11 @@ When the user corrects you ("no, use X not Y", "that's wrong"):
 `;
 function installClaudeMd() {
   const marker = "## PLUR Memory";
-  const projectClaudeMd = join(process.cwd(), "CLAUDE.md");
-  const globalClaudeMd = join(homedir(), "CLAUDE.md");
+  const projectClaudeMd = join2(process.cwd(), "CLAUDE.md");
+  const globalClaudeMd = join2(homedir2(), "CLAUDE.md");
   const claudeMdPath = existsSync(projectClaudeMd) ? projectClaudeMd : existsSync(globalClaudeMd) ? globalClaudeMd : projectClaudeMd;
   if (existsSync(claudeMdPath)) {
-    const content = readFileSync(claudeMdPath, "utf8");
+    const content = readFileSync2(claudeMdPath, "utf8");
     if (content.includes(marker)) {
       return `already in ${claudeMdPath}`;
     }
@@ -139,16 +215,16 @@ ${CLAUDE_MD_SECTION}`);
   return `created ${claudeMdPath}`;
 }
 function findMcpConfig() {
-  const projectMcp = join(process.cwd(), ".mcp.json");
+  const projectMcp = join2(process.cwd(), ".mcp.json");
   if (existsSync(projectMcp)) return projectMcp;
-  const globalMcp = join(homedir(), ".claude", "mcp.json");
+  const globalMcp = join2(homedir2(), ".claude", "mcp.json");
   if (existsSync(globalMcp)) return globalMcp;
   return projectMcp;
 }
 function readJsonObjectForWrite(path) {
   if (!existsSync(path)) return { data: {}, ok: true };
   try {
-    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return { data: parsed, ok: true };
     }
@@ -180,40 +256,89 @@ function writeMcpConfig(configPath) {
   }
   servers.plur = MCP_SERVER_CONFIG;
   config.mcpServers = servers;
-  const dir = join(configPath, "..");
+  const dir = join2(configPath, "..");
   mkdirSync(dir, { recursive: true });
   writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
   return `added to ${configPath}`;
 }
+function isPlurCommandHook(h) {
+  return typeof h.command === "string" && isPlurHookSpec({ command: h.command, args: h.args });
+}
+function isPlurHook(entry) {
+  return (entry.hooks ?? []).some(isPlurCommandHook);
+}
+var REHYDRATE = /(?:^|\s)hook-inject\s+--rehydrate(?:\s|$)/;
+function launchLine(h) {
+  const args = Array.isArray(h.args) ? h.args.filter((a) => typeof a === "string") : [];
+  return [h.command, ...args].join(" ");
+}
+function isPlurRehydrateHook(h) {
+  return isPlurCommandHook(h) && REHYDRATE.test(launchLine(h).replace(/\\/g, "/").toLowerCase());
+}
+function isPlurRehydrate(entry) {
+  return (entry.hooks ?? []).some(isPlurRehydrateHook);
+}
+function hasPlurSubcommand(entries, subcommand) {
+  const re = new RegExp(`(?:^|\\s)${subcommand}(?:\\s|$)`);
+  return (entries ?? []).some((e) => (e.hooks ?? []).some((h) => isPlurCommandHook(h) && re.test(h.command.replace(/\\/g, "/").toLowerCase())));
+}
+var isResumeEntry = (e) => e.matcher === "resume";
+function stripPlurHooks(entries) {
+  const kept = [];
+  for (const entry of entries) {
+    if (!isPlurHook(entry)) {
+      kept.push(entry);
+      continue;
+    }
+    const rest = entry.hooks.filter((h) => !isPlurCommandHook(h));
+    if (rest.length > 0) kept.push({ ...entry, hooks: rest });
+  }
+  return kept;
+}
+function applyPlurHooks(settings, hooksMap) {
+  const hooks = { ...settings.hooks ?? {} };
+  const installed = Object.values(hooks).some((entries) => (entries ?? []).some(isPlurHook));
+  if (!installed) {
+    for (const [event, entries] of Object.entries(hooksMap)) {
+      hooks[event] = [...hooks[event] ?? [], ...entries];
+    }
+    return { settings: { ...settings, hooks }, status: "installed" };
+  }
+  let changed = false;
+  let movedRehydrate = false;
+  if (hooks.PostCompact?.some(isPlurHook)) {
+    movedRehydrate = hooks.PostCompact.some(isPlurRehydrate);
+    const kept = stripPlurHooks(hooks.PostCompact);
+    if (kept.length > 0) hooks.PostCompact = kept;
+    else delete hooks.PostCompact;
+    changed = true;
+  }
+  if (movedRehydrate && !(hooks.SessionStart ?? []).some(isPlurRehydrate)) {
+    hooks.SessionStart = [...hooks.SessionStart ?? [], ...(hooksMap.SessionStart ?? []).filter((e) => !isResumeEntry(e))];
+    changed = true;
+  }
+  if (hasPlurSubcommand(hooks.SessionEnd, "hook-session-end") && !hasPlurSubcommand(hooks.SessionStart, "hook-session-resume")) {
+    const resume = (hooksMap.SessionStart ?? []).filter(isResumeEntry);
+    if (resume.length > 0) {
+      hooks.SessionStart = [...hooks.SessionStart ?? [], ...resume];
+      changed = true;
+    }
+  }
+  return changed ? { settings: { ...settings, hooks }, status: "healed" } : { settings, status: "already" };
+}
 function installHooks() {
-  const projectSettings = join(process.cwd(), ".claude", "settings.json");
-  const globalSettings = join(homedir(), ".claude", "settings.json");
-  const settingsPath = existsSync(join(process.cwd(), ".claude")) ? projectSettings : globalSettings;
+  const settingsPath = join2(homedir2(), ".claude", "settings.json");
   const settingsRead = readJsonObjectForWrite(settingsPath);
   if (!settingsRead.ok) {
     return `skipped \u2014 ${settingsPath} exists but is not a JSON object; writing would discard your other settings. Fix it by hand, then re-run \`plur-mcp init\``;
   }
   const settings = settingsRead.data;
-  const hooks = settings.hooks ?? {};
-  for (const entries of Object.values(hooks)) {
-    for (const entry of entries) {
-      for (const h of entry.hooks ?? []) {
-        if (h.command.includes("@plur-ai/cli")) {
-          return `already installed in ${settingsPath}`;
-        }
-      }
-    }
-  }
-  const existing = settings.hooks ?? {};
-  const merged = { ...existing };
-  for (const [event, newEntries] of Object.entries(PLUR_HOOKS)) {
-    merged[event] = [...merged[event] ?? [], ...newEntries];
-  }
-  settings.hooks = merged;
-  const dir = join(settingsPath, "..");
+  const { settings: next, status } = applyPlurHooks(settings, PLUR_HOOKS);
+  if (status === "already") return `already installed in ${settingsPath}`;
+  const dir = join2(settingsPath, "..");
   mkdirSync(dir, { recursive: true });
-  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
-  return `installed in ${settingsPath}`;
+  writeFileSync(settingsPath, JSON.stringify(next, null, 2) + "\n");
+  return status === "healed" ? `updated PLUR hooks (SessionStart compact/resume) in ${settingsPath}` : `installed in ${settingsPath}`;
 }
 async function runInit() {
   const results = [];
@@ -240,27 +365,27 @@ async function runInit() {
   results.push(`CLAUDE.md: ${claudeMdStatus}`);
   const { Plur } = await import("@plur-ai/core");
   const plur = new Plur({ path: paths.root });
-  const bundledPacksDir = join(fileURLToPath(import.meta.url), "..", "..", "packs");
+  const bundledPacksDir = join2(fileURLToPath(import.meta.url), "..", "..", "packs");
   let packsStatus = "no bundled packs found";
   if (existsSync(bundledPacksDir)) {
     const installed = plur.listPacks();
     const installedByName = new Map(installed.map((p) => [p.name, p.manifest?.version]));
-    const entries = readdirSync(bundledPacksDir).filter((e) => statSync(join(bundledPacksDir, e)).isDirectory());
+    const entries = readdirSync(bundledPacksDir).filter((e) => statSync(join2(bundledPacksDir, e)).isDirectory());
     const newPacks = [];
     const upgradedPacks = [];
     for (const entry of entries) {
-      const bundledManifestPath = join(bundledPacksDir, entry, "SKILL.md");
+      const bundledManifestPath = join2(bundledPacksDir, entry, "SKILL.md");
       const bundledVersion = existsSync(bundledManifestPath) ? extractManifestVersion(bundledManifestPath) : null;
       const installedVersion = installedByName.get(entry);
       if (!installedByName.has(entry)) {
         try {
-          await plur.installPack(join(bundledPacksDir, entry));
+          await plur.installPack(join2(bundledPacksDir, entry));
           newPacks.push(entry);
         } catch {
         }
       } else if (bundledVersion && (!installedVersion || compareSemver(bundledVersion, installedVersion) > 0)) {
         try {
-          await plur.installPack(join(bundledPacksDir, entry));
+          await plur.installPack(join2(bundledPacksDir, entry));
           upgradedPacks.push(
             `${entry} ${installedVersion ?? "unknown"}\u2192${bundledVersion}`
           );
@@ -295,7 +420,7 @@ async function runInit() {
   }
 }
 async function runPacks() {
-  const plurPath = process.env.PLUR_PATH ?? join(homedir(), ".plur");
+  const plurPath = process.env.PLUR_PATH ?? join2(homedir2(), ".plur");
   const { Plur } = await import("@plur-ai/core");
   const { packsCommand } = await import("./packs-cli-XXZTSBHW.js");
   const plur = new Plur({ path: plurPath });
@@ -323,7 +448,7 @@ if (arg === "packs") {
   process.exit(0);
 }
 if (arg === "serve" || arg === void 0) {
-  const { runStdio } = await import("./server-XTPKBBQN.js");
+  const { runStdio } = await import("./server-EUMEOVXB.js");
   runStdio().catch((err) => {
     console.error("Failed to start PLUR MCP server:", err);
     process.exit(1);
@@ -334,6 +459,8 @@ Run plur-mcp --help for usage.`);
   process.exit(1);
 }
 export {
+  applyPlurHooks,
+  buildPlurHooks,
   compareSemver,
   extractManifestVersion
 };

package/dist/{server-XTPKBBQN.js → server-EUMEOVXB.js}

@@ -6,10 +6,10 @@ import {
   resolveToolProfile,
   setActiveToolProfile,
   validateToolArgs
-} from "./chunk-Z227RPMX.js";
+} from "./chunk-UINIIUBY.js";
 import {
   VERSION
-} from "./chunk-CYXWRLDH.js";
+} from "./chunk-WA3JKTZ7.js";
 
 // src/server.ts
 import { Server, ProtocolError, ProtocolErrorCode } from "@modelcontextprotocol/server";

package/dist/tools-export.js

@@ -2,8 +2,8 @@ import {
   CURSOR_CORE_TOOL_NAMES,
   getToolDefinitions,
   validateToolArgs
-} from "./chunk-Z227RPMX.js";
-import "./chunk-CYXWRLDH.js";
+} from "./chunk-UINIIUBY.js";
+import "./chunk-WA3JKTZ7.js";
 
 // src/tools-export.ts
 function getToolSchemas(profile) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@plur-ai/mcp",
   "mcpName": "io.github.plur-ai/plur",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "type": "module",
   "bin": {
     "plur-mcp": "dist/index.js"
@@ -16,7 +16,7 @@
     "@modelcontextprotocol/client": "2.0.0-beta.4",
     "@modelcontextprotocol/core": "2.0.0-beta.4",
     "zod": "^3.23.0",
-    "@plur-ai/core": "0.20.0"
+    "@plur-ai/core": "0.21.0"
   },
   "devDependencies": {
     "@types/node": "^25.5.0"