@plur-ai/mcp 0.13.0 → 0.15.0

package/README.md

@@ -46,25 +46,23 @@ Knowledge is stored as **engrams** — small assertions that strengthen with use
 
 ## Tools
 
-Your agent gets these tools automatically:
+By default (lean profile), your agent gets 11 tools. Everything else is reachable through `plur_admin`:
 
 | Tool | What it does |
 |------|-------------|
 | `plur_session_start` | Start a session — injects relevant engrams for your task |
 | `plur_learn` | Store a memory — correction, preference, convention, or decision |
 | `plur_recall_hybrid` | **Best default** — BM25 + embeddings merged via RRF. Zero cost. |
-| `plur_recall` | Keyword search (BM25 only, instant) |
-| `plur_inject_hybrid` | Load relevant memories for the current task |
 | `plur_feedback` | Rate a memory — trains relevance over time |
 | `plur_forget` | Retire a memory (history preserved) |
 | `plur_session_end` | End a session — captures summary and new learnings |
-| `plur_capture` | Record a session event |
-| `plur_timeline` | Query session history |
-| `plur_ingest` | Extract learnings from text |
-| `plur_sync` | Sync memory across machines via git |
-| `plur_packs_install` | Install a shareable memory pack |
-| `plur_packs_list` | List installed packs |
 | `plur_status` | System health |
+| `plur_doctor` | Diagnose embedder, hybrid search, and remote-store auth |
+| `plur_packs_uninstall` | Remove an installed pack |
+| `plur_tensions_purge` | Clear stale/resolved tensions |
+| `plur_admin` | Dispatch to any other tool: `{ action: "plur_packs_install", args: {...} }` |
+
+Less commonly needed tools (`plur_recall`, `plur_inject_hybrid`, `plur_learn_batch`, `plur_ingest`, `plur_sync`, `plur_packs_install`, `plur_packs_list`, `plur_capture`, `plur_timeline`, and more) are all reachable via `plur_admin`. Set `PLUR_TOOL_PROFILE=full` to expose all 40 tools directly.
 
 ## Sync across machines
 
@@ -101,11 +99,9 @@ Default: `~/.plur/`. Everything is plain YAML — open it, read it, edit it.
 
 ## Benchmark
 
-| Metric | Score |
-|--------|-------|
-| LongMemEval overall | **86.7%** |
-| A/B win rate vs no memory | 89% |
-| House rules accuracy | 100% |
+**Retrieval** (LongMemEval R@5): **76.7%** out-of-the-box · **97.0%** with openai-3-large embeddings
+
+**Agent task impact:** Haiku + PLUR outperforms Opus *without* memory at ~10× less cost. House rules: **12–0** across Haiku, Sonnet, Opus. A/B win rate: **89%**.
 
 [Full methodology →](https://plur.ai/benchmark.html)
 

package/dist/index.js

@@ -5,14 +5,17 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSy
 import { join } from "path";
 import { fileURLToPath } from "url";
 import { homedir, platform } from "os";
-var VERSION = "0.13.0";
+var VERSION = "0.15.0";
 var HELP = `plur-mcp v${VERSION} \u2014 persistent memory for AI agents
 
 Usage:
-  plur-mcp              Start the MCP server (stdio transport)
-  plur-mcp init         Set up PLUR: storage + MCP config + hooks + CLAUDE.md
-  plur-mcp --help       Show this help message
-  plur-mcp --version    Show version
+  plur-mcp                           Start the MCP server (stdio transport)
+  plur-mcp init                      Set up PLUR: storage + MCP config + hooks + CLAUDE.md
+  plur-mcp packs install <path>      Install a knowledge pack from a local directory
+  plur-mcp packs list                List installed knowledge packs
+  plur-mcp packs uninstall <name>    Uninstall a knowledge pack by name
+  plur-mcp --help                    Show this help message
+  plur-mcp --version                 Show version
 
 Environment:
   PLUR_PATH             Storage location (default: ~/.plur/)
@@ -65,6 +68,12 @@ var PLUR_HOOKS = {
     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 }] },
@@ -98,7 +107,7 @@ Hooks inject engrams automatically on every first message \u2014 you do not need
 2. **Learn**: When corrected or discovering something new, call \`plur_learn\` immediately
 3. **Recall**: Before answering factual questions, call \`plur_recall_hybrid\` \u2014 check memory first
 4. **Feedback**: Rate injected engrams with \`plur_feedback\` (positive/negative) \u2014 trains relevance
-5. **End**: Call \`plur_session_end\` with summary + engram_suggestions
+5. **End**: Call \`plur_session_end\` with summary + engram_suggestions \u2014 a SessionEnd hook auto-closes the lifecycle if you forget, but calling it yourself captures higher-quality learnings
 
 Do not ask permission to use these tools \u2014 they are your memory system.
 
@@ -264,6 +273,65 @@ async function runInit() {
 `);
   }
 }
+async function runPacks() {
+  const sub = process.argv[3];
+  const plurPath = process.env.PLUR_PATH ?? join(homedir(), ".plur");
+  const { Plur } = await import("@plur-ai/core");
+  const plur = new Plur({ path: plurPath });
+  if (sub === "install") {
+    const source = process.argv[4];
+    if (!source) {
+      process.stderr.write("Usage: plur-mcp packs install <path>\n");
+      process.exit(1);
+    }
+    try {
+      const result = plur.installPack(source);
+      process.stdout.write(`Installed pack '${result.name}' (${result.installed} engrams)
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err.message}
+`);
+      process.exit(1);
+    }
+  } else if (sub === "list") {
+    const packs = plur.listPacks();
+    if (packs.length === 0) {
+      process.stdout.write("No packs installed.\n");
+    } else {
+      for (const pack of packs) {
+        const version = pack.manifest?.version ? ` v${pack.manifest.version}` : "";
+        process.stdout.write(`${pack.name}${version} (${pack.engram_count} engrams)
+`);
+      }
+    }
+  } else if (sub === "uninstall") {
+    const name = process.argv[4];
+    if (!name) {
+      process.stderr.write("Usage: plur-mcp packs uninstall <name>\n");
+      process.exit(1);
+    }
+    try {
+      const result = plur.uninstallPack(name);
+      if (result.removed) {
+        process.stdout.write(`Uninstalled pack '${result.name}' (${result.engram_count} engrams removed)
+`);
+      } else {
+        process.stderr.write(`Pack '${name}' not found.
+`);
+        process.exit(1);
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err.message}
+`);
+      process.exit(1);
+    }
+  } else {
+    process.stderr.write(`Unknown packs subcommand: ${sub ?? "(none)"}
+Available: install, list, uninstall
+`);
+    process.exit(1);
+  }
+}
 var arg = process.argv[2];
 if (arg === "--help" || arg === "-h") {
   process.stdout.write(HELP);
@@ -278,8 +346,12 @@ if (arg === "init") {
   await runInit();
   process.exit(0);
 }
+if (arg === "packs") {
+  await runPacks();
+  process.exit(0);
+}
 if (arg === "serve" || arg === void 0) {
-  const { runStdio } = await import("./server-B6OJN4ZX.js");
+  const { runStdio } = await import("./server-7JVOIBJV.js");
   runStdio().catch((err) => {
     console.error("Failed to start PLUR MCP server:", err);
     process.exit(1);

package/dist/{server-B6OJN4ZX.js → server-7JVOIBJV.js}

@@ -1,23 +1,16 @@
 // src/server.ts
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  ListToolsRequestSchema,
-  CallToolRequestSchema,
-  ListResourcesRequestSchema,
-  ReadResourceRequestSchema,
-  ListPromptsRequestSchema,
-  GetPromptRequestSchema,
-  ErrorCode,
-  McpError
-} from "@modelcontextprotocol/sdk/types.js";
+import { Server, ProtocolError, ProtocolErrorCode } from "@modelcontextprotocol/server";
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
+import { existsSync as existsSync2, readFileSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
 import { Plur as Plur2, checkForUpdate } from "@plur-ai/core";
 
 // src/tools.ts
 import { existsSync, unlinkSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
-import { extractMetaEngrams, validateMetaEngram, confidenceBand, generateProfile, getProfileForInjection, selectModelForOperation, getCachedUpdateCheck, minorVersionsBehind, scanForTensions, CapabilityCanary, readProjectConfig, isSharedScope, resolveRerankerName, getReranker, classifyRerankerFailure, hfCacheDirName } from "@plur-ai/core";
+import { extractMetaEngrams, validateMetaEngram, confidenceBand, generateProfile, getProfileForInjection, selectModelForOperation, getCachedUpdateCheck, minorVersionsBehind, scanForTensions, CapabilityCanary, readProjectConfig, isSharedScope, resolveRerankerName, getReranker, classifyRerankerFailure, hfCacheDirName, SUGGEST_DISPLAY_MIN_CONFIDENCE } from "@plur-ai/core";
 
 // src/telemetry.ts
 import { recordEvent, flushIfNeeded, registerFlushOnExit } from "@plur-ai/core";
@@ -31,7 +24,7 @@ function recordTelemetry(event) {
 }
 
 // src/version.ts
-var VERSION = "0.13.0";
+var VERSION = "0.15.0";
 
 // src/tools.ts
 import { z } from "zod";
@@ -179,6 +172,24 @@ mcpCanary.expect({
   description: "Learning from corrections",
   fix: "Call plur_learn when corrected. If using hooks, verify they are installed."
 });
+var _sessionTelemetry = /* @__PURE__ */ new Map();
+var SESSION_TTL_MS = 8 * 60 * 60 * 1e3;
+function _cleanExpiredSessions() {
+  const cutoff = Date.now() - SESSION_TTL_MS;
+  for (const [id, state] of _sessionTelemetry) {
+    if (new Date(state.started_at).getTime() < cutoff) _sessionTelemetry.delete(id);
+  }
+}
+var _activeSessionId;
+function _recordInjectionTelemetry(session_id, injected_packs) {
+  if (!session_id || !injected_packs) return;
+  const state = _sessionTelemetry.get(session_id);
+  if (!state) return;
+  state.injection_calls++;
+  for (const [pack, count] of Object.entries(injected_packs)) {
+    state.pack_counts[pack] = (state.pack_counts[pack] ?? 0) + count;
+  }
+}
 var CURSOR_CORE_TOOL_NAMES = /* @__PURE__ */ new Set([
   "plur_session_start",
   "plur_session_end",
@@ -187,6 +198,7 @@ var CURSOR_CORE_TOOL_NAMES = /* @__PURE__ */ new Set([
   "plur_feedback",
   "plur_forget",
   "plur_status",
+  "plur_receipt",
   "plur_doctor",
   "plur_packs_uninstall",
   "plur_tensions_purge"
@@ -219,6 +231,13 @@ function buildAdminDispatchTool(all) {
       if (!target) {
         return { error: `Unknown action "${action}". Valid actions: ${adminActions.join(", ")}`, success: false, _isError: true };
       }
+      if (target.annotations?.destructiveHint === true) {
+        return {
+          error: `"${action}" is a destructive operation and cannot be dispatched via plur_admin \u2014 call the ${action} tool directly (it is exposed in every profile) so your client sees its destructiveHint annotation.`,
+          success: false,
+          _isError: true
+        };
+      }
       const innerArgs = args.args ?? {};
       const validated = validateToolArgs(target, innerArgs);
       if (!validated.ok) {
@@ -233,12 +252,20 @@ function buildAdminDispatchTool(all) {
     }
   };
 }
-function getToolDefinitions(profile = "full") {
+function getToolDefinitions(profile = "lean") {
   const all = getAllToolDefinitions();
-  if (profile !== "cursor") return all;
+  if (profile === "full") return all;
   const core = all.filter((t) => CURSOR_CORE_TOOL_NAMES.has(t.name));
   return [...core, buildAdminDispatchTool(all)];
 }
+function receiptSummary(r) {
+  if (r.coverage.source === "none") {
+    return r.window.windowed ? `No retrievals recorded in the last ${r.window.requested_days} days.` : "No retrieval history yet \u2014 logging begins once memory is used.";
+  }
+  const since = r.window.windowed ? `the last ${r.window.requested_days} days` : `${r.coverage.complete_from}`;
+  const pct = Math.round(r.retrieved.activation_rate * 100);
+  return `Since ${since}, ${r.retrieved.taught_pairs} times a memory the user taught was retrieved into context (across ${r.retrieved.retrievals} retrievals in ${r.window.sessions} sessions; ${r.retrieved.engrams} distinct engrams). Activation ${pct}% is store COVERAGE over the logging window, not a quality score \u2014 it is expected to be low and to fall as more engrams are added.`;
+}
 function getAllToolDefinitions() {
   return [
     {
@@ -298,6 +325,18 @@ function getAllToolDefinitions() {
           const scopes = remote.map((s) => `"${s.scope}"`).join(", ");
           return { scope_hint: `Stored at "${engramScope}" because no scope was passed, but a team store is configured (${scopes}). If this is team/engineering knowledge, re-learn it with an explicit scope so it reaches the shared store; keep genuinely personal notes at the default scope.` };
         };
+        const domainHint = (wasRouted) => {
+          if (typeof args.domain === "string" && args.domain.length > 0) return {};
+          if (explicitScope || wasRouted) return {};
+          let coversScopes = [];
+          try {
+            coversScopes = plur.listScopeMetadata().filter((md) => (md.covers?.length ?? 0) > 0).map((md) => md.scope);
+          } catch {
+            return {};
+          }
+          if (coversScopes.length === 0) return {};
+          return { domain_hint: `No domain set \u2014 without a dotted domain this engram cannot auto-route to a covers-declaring scope (${coversScopes.join(", ")}) and is harder to re-scope later. Set domain on every plur_learn, shape "<org>.<team>.<area>" (e.g. "plur.engineering.mcp") \u2014 see the domain convention in CLAUDE.md.` };
+        };
         const temporalEcho = (engram) => {
           const extracted = engram.structured_data?._expiry_extracted;
           return {
@@ -323,6 +362,7 @@ function getAllToolDefinitions() {
             decision: "ADD",
             ...temporalEcho(engram),
             ...scopeHint(engram.scope, !!routed),
+            ...domainHint(!!routed),
             ...isOutbox ? { outbox: true, warning: "Remote write failed; engram queued locally for retry on next session start or plur_sync." } : {},
             ...demoted ? { demoted: true, requested_scope: demoted.from, warning: `Sensitive content (${demoted.patterns}) detected \u2014 stored at "${demoted.to}"/private instead of the requested shared scope "${demoted.from}". If this is a false positive, re-scope deliberately.` } : {},
             ...routed ? { routed: { scope: routed.scope, confidence: routed.confidence, reason: routed.reason }, info: `No scope was provided; auto-routed to "${routed.scope}" (confidence ${routed.confidence}) because its content matched that scope's covers. Pass an explicit scope to override.` } : {}
@@ -341,12 +381,106 @@ function getAllToolDefinitions() {
             decision: "ADD",
             ...temporalEcho(engram),
             ...scopeHint(engram.scope, !!routedFallback),
+            ...domainHint(!!routedFallback),
             ...isOutbox ? { outbox: true } : {},
             warning: `Remote write failed (${err.message}); engram queued for retry.`
           };
         }
       }
     },
+    {
+      name: "plur_learn_batch",
+      description: "Create many engrams in one call \u2014 the batch form of plur_learn. Accepts an array of engram objects and writes them sequentially through the SAME dedup + policy pipeline as plur_learn (content-hash NOOP \u2192 semantic recall \u2192 LLM ADD/UPDATE/MERGE decision). Dedup also applies WITHIN the batch: a statement duplicating an earlier item in the same array resolves to NOOP against it. Returns `ids` aligned 1:1 with the input array (ids[i] is the engram id for input i, or null if input i failed), the per-item decisions (each carrying its input_index), aggregate stats, and any per-item failures (each with its input index) \u2014 a single bad item does not abort the batch. Use this when an orchestration fans out and wants to persist consolidated findings without N separate calls. LLM dedup calls are capped (default 50, override with max_llm_calls) to bound bulk-import cost. Note: unlike plur_learn, batch items take the LOCAL learn path \u2014 remote-scope auto-routing (learnRouted) is not applied per item, so for shared/remote-store writes prefer plur_learn or pass an explicit local scope. See plur-ai/plur#281.",
+      annotations: { title: "Learn (batch)", destructiveHint: false, idempotentHint: false },
+      inputSchema: {
+        type: "object",
+        properties: {
+          engrams: {
+            type: "array",
+            description: "Engram objects to persist. Each requires `statement`; the other fields mirror plur_learn.",
+            items: {
+              type: "object",
+              properties: {
+                statement: { type: "string", description: "The knowledge assertion to store" },
+                type: { type: "string", enum: ["behavioral", "terminological", "procedural", "architectural"], description: "Category of the engram" },
+                scope: { type: "string", description: "Namespace, e.g. global, project:myapp" },
+                domain: { type: "string", description: "Domain tag, e.g. software.deployment" },
+                tags: { type: "array", items: { type: "string" }, description: "Searchable keyword tags \u2014 contribute to BM25/embedding recall" },
+                rationale: { type: "string", description: "Why this knowledge matters \u2014 also enters the search corpus" },
+                source: { type: "string", description: "Origin of this knowledge (URL, conversation ref, etc.)" },
+                pinned: { type: "boolean", description: "Always-load flag. Use sparingly: meta-rules, safety conventions, core principles." },
+                commitment: { type: "string", enum: ["exploring", "leaning", "decided", "locked"], description: "How firmly the user has committed (default: leaning)" },
+                valid_from: { type: "string", description: "ISO date (YYYY-MM-DD) the knowledge becomes valid" },
+                valid_until: { type: "string", description: "ISO date (YYYY-MM-DD) the knowledge expires" }
+              },
+              required: ["statement"]
+            }
+          },
+          max_llm_calls: { type: "number", description: "Max LLM dedup calls across the whole batch (default 50). Once spent, remaining items use the cheap hash/cosine path. Pass a large number to opt out." }
+        },
+        required: ["engrams"]
+      },
+      handler: async (args, plur) => {
+        const llm = getLlmFunction();
+        const raw = Array.isArray(args.engrams) ? args.engrams : [];
+        if (raw.length === 0) {
+          return { ids: [], results: [], stats: { added: 0, updated: 0, merged: 0, noops: 0, failed: 0 }, failures: [], warning: "No engrams provided \u2014 pass a non-empty `engrams` array." };
+        }
+        const items = raw.map((e) => ({
+          statement: sanitizeStatement(e.statement),
+          context: {
+            type: e.type,
+            scope: e.scope,
+            domain: e.domain,
+            source: e.source,
+            tags: e.tags,
+            rationale: e.rationale,
+            commitment: e.commitment,
+            pinned: e.pinned,
+            valid_from: e.valid_from,
+            valid_until: e.valid_until
+          }
+        }));
+        const maxLlmCalls = typeof args.max_llm_calls === "number" ? args.max_llm_calls : void 0;
+        const { results, stats, failures } = await plur.learnBatch(
+          items,
+          llm,
+          maxLlmCalls !== void 0 ? { maxLlmCalls } : void 0
+        );
+        mcpCanary.signal("learn_activity");
+        recordTelemetry("learn");
+        const ids = raw.map(() => null);
+        for (const r of results) {
+          if (r.input_index !== void 0) ids[r.input_index] = r.engram.id;
+        }
+        let batchDomainHint = {};
+        const noDomainCount = raw.filter((e) => !(typeof e.domain === "string" && e.domain.length > 0) && !(typeof e.scope === "string" && e.scope.length > 0)).length;
+        if (noDomainCount > 0) {
+          try {
+            const coversScopes = plur.listScopeMetadata().filter((md) => (md.covers?.length ?? 0) > 0).map((md) => md.scope);
+            if (coversScopes.length > 0) {
+              batchDomainHint = { domain_hint: `${noDomainCount} of ${raw.length} item(s) had no domain and no explicit scope \u2014 they cannot auto-route to a covers-declaring scope (${coversScopes.join(", ")}) and are harder to re-scope later. Set domain on every item, shape "<org>.<team>.<area>" \u2014 see the domain convention in CLAUDE.md.` };
+            }
+          } catch {
+          }
+        }
+        return {
+          ids,
+          results: results.map((r) => ({
+            input_index: r.input_index,
+            id: r.engram.id,
+            statement: r.engram.statement,
+            scope: r.engram.scope,
+            type: r.engram.type,
+            decision: r.decision,
+            ...r.existing_id ? { existing_id: r.existing_id } : {}
+          })),
+          stats,
+          ...batchDomainHint,
+          ...failures.length > 0 ? { failures, warning: `${failures.length} of ${raw.length} engram(s) failed to persist; the rest were written.` } : {}
+        };
+      }
+    },
     {
       name: "plur_recall",
       description: "Query engrams by BM25 keyword matching \u2014 use plur_recall_hybrid for semantic similarity. Note: a project-scope filter also returns personal-family engrams (local, global, user:*, agent:*); an explicit scope=global recall returns ALL personal-family engrams \u2014 wider than scope=global INJECT, which is targeted to the global namespace only.",
@@ -370,14 +504,18 @@ function getAllToolDefinitions() {
           limit: args.limit
         });
         return {
-          results: results.map((e) => ({
-            id: e.id,
-            statement: e.statement,
-            type: e.type,
-            scope: e.scope,
-            domain: e.domain,
-            retrieval_strength: e.activation.retrieval_strength
-          })),
+          results: results.map((e) => {
+            const supersededBy = e.relations?.superseded_by;
+            const annotation = supersededBy?.length ? ` [superseded by ${supersededBy.join(", ")}]` : "";
+            return {
+              id: e.id,
+              statement: e.statement + annotation,
+              type: e.type,
+              scope: e.scope,
+              domain: e.domain,
+              retrieval_strength: e.activation.retrieval_strength
+            };
+          }),
           count: results.length
         };
       }
@@ -433,9 +571,11 @@ function getAllToolDefinitions() {
         const response = {
           results: boundedResults.map((e) => {
             const raw = e;
+            const supersededBy = e.relations?.superseded_by;
+            const annotation = supersededBy?.length ? ` [superseded by ${supersededBy.join(", ")}]` : "";
             const base = {
               id: e.id,
-              statement: e.statement,
+              statement: e.statement + annotation,
               type: e.type,
               scope: e.scope,
               domain: e.domain,
@@ -481,8 +621,11 @@ function getAllToolDefinitions() {
       handler: async (args, plur) => {
         const result = plur.inject(args.task, {
           budget: args.budget,
-          scope: args.scope
+          scope: args.scope,
+          source: "inject",
+          session_id: _activeSessionId
         });
+        _recordInjectionTelemetry(_activeSessionId, result.injected_packs);
         return {
           directives: result.directives,
           consider: result.consider,
@@ -510,8 +653,11 @@ function getAllToolDefinitions() {
       handler: async (args, plur) => {
         const result = await plur.injectHybrid(args.task, {
           budget: args.budget,
-          scope: args.scope
+          scope: args.scope,
+          source: "inject",
+          session_id: _activeSessionId
         });
+        _recordInjectionTelemetry(_activeSessionId, result.injected_packs);
         return {
           directives: result.directives,
           consider: result.consider,
@@ -860,11 +1006,19 @@ function getAllToolDefinitions() {
           full: {
             type: "boolean",
             description: "Full reindex: drop the derived index (PGLite/SQLite) and rebuild from YAML. YAML is never modified. Use to recover from an out-of-sync index."
+          },
+          remote_type: {
+            type: "string",
+            enum: ["personal", "shared"],
+            description: "What the sync remote is for (#640). personal (default): mirror everything non-local, private included \u2014 a solo user's own backup. shared: push ONLY shared-scope, non-private engrams \u2014 personal-family and private engrams never reach the remote. Persist the choice in config.yaml as sync.remote_type instead of passing it per call."
           }
         }
       },
       handler: async (args, plur) => {
-        const result = plur.sync(args.remote, { full: args.full === true });
+        const result = plur.sync(args.remote, {
+          full: args.full === true,
+          ...args.remote_type === "personal" || args.remote_type === "shared" ? { remoteType: args.remote_type } : {}
+        });
         await plur.waitForIndex();
         const indexError = plur.lastIndexError();
         let outbox_result;
@@ -1050,14 +1204,20 @@ function getAllToolDefinitions() {
     },
     {
       name: "plur_status",
-      description: "Return system health \u2014 running version, engram count, episode count, pack count, storage root",
+      description: "Return system health \u2014 running version, engram count, episode count, pack count, storage root. Optionally filter engram counts by domain prefix and/or creation date.",
       annotations: { title: "Status", readOnlyHint: true, idempotentHint: true },
       inputSchema: {
         type: "object",
-        properties: {}
+        properties: {
+          domain: { type: "string", description: 'Only count engrams whose domain starts with this prefix (e.g. "meridian")' },
+          created_after: { type: "string", description: "ISO-8601 date (YYYY-MM-DD). Only count engrams learned on or after this date." }
+        }
       },
-      handler: async (_args, plur) => {
-        const status = plur.status();
+      handler: async (args, plur) => {
+        const status = plur.status({
+          domain: args.domain,
+          created_after: args.created_after
+        });
         const versionCheck = getCachedUpdateCheck("@plur-ai/mcp");
         return {
           version: VERSION,
@@ -1090,6 +1250,22 @@ function getAllToolDefinitions() {
         };
       }
     },
+    {
+      name: "plur_receipt",
+      description: 'Counted report of what your memory retrieved for you: engrams stored, how many were retrieved and how often, which are most relied on, and how much of the store is dormant. Local and read-only; every figure is directly counted, never estimated. IMPORTANT when relaying to the user: `activation_rate` is COVERAGE over the logging window (\u2248 how much of the store was surfaced), NOT a quality or effectiveness score \u2014 it is naturally low and FALLS as more engrams are added, so never present it as "memory is N% effective". A `summary` line is included; prefer relaying that.',
+      annotations: { title: "Memory receipt", readOnlyHint: true, idempotentHint: true },
+      inputSchema: {
+        type: "object",
+        properties: {
+          days: { type: "number", description: "Restrict to the last N days (integer). Omit for all recorded history." }
+        }
+      },
+      handler: async (args, plur) => {
+        const days = typeof args.days === "number" && Number.isFinite(args.days) && args.days >= 1 ? Math.floor(args.days) : void 0;
+        const receipt = plur.receipt(days ? { days } : void 0);
+        return { summary: receiptSummary(receipt), ...receipt };
+      }
+    },
     {
       name: "plur_doctor",
       description: 'Diagnose the PLUR ENGINE (embedder, hybrid search, remote-store auth) \u2014 not hook/MCP wiring. Reports whether the embedding model loaded, whether hybrid search is fully operational, and \u2014 for any configured enterprise/remote store \u2014 whether its auth is valid (probes /api/v1/me and decodes token expiry), so a dead or soon-to-expire token surfaces instead of hiding behind a "healthy" report. Run this first when recall feels off or team engrams stop syncing. Does NOT check .cursor/mcp.json, .cursor/hooks.json, or the live MCP tool count \u2014 for that, run the `plur doctor` CLI command in a terminal (a different, more thorough check with the same name).',
@@ -1184,6 +1360,23 @@ function getAllToolDefinitions() {
             }
           }
           checks.push({ check: "reranker available", ok: rerankerOk, detail: rerankerDetail });
+          if (rerankerOk) {
+            try {
+              const fitResult = await plur.checkRerankerFit({ rerankerName });
+              const sep = fitResult.separability.toFixed(3);
+              checks.push({
+                check: "reranker domain fit",
+                ok: fitResult.fit,
+                detail: fitResult.n_pairs === 0 ? "Not enough engrams to evaluate fit (< 2) \u2014 assuming fit" : fitResult.fit ? `Good fit \u2014 separability ${sep} on ${fitResult.n_pairs} pairs (threshold \u2265 0.05)` : `Poor fit \u2014 separability ${sep} on ${fitResult.n_pairs} pairs (threshold \u2265 0.05). Reranker may be net-negative on this store's domain mix.`
+              });
+              if (!fitResult.fit && fitResult.n_pairs > 0) {
+                remediation.push(
+                  `Reranker "${rerankerName}" shows poor separability (${sep}) on this store's engrams \u2014 it may be scoring irrelevant pairs higher than relevant ones. Consider unsetting PLUR_RERANKER or switching to a different tier. The fit check compares same-domain vs cross-domain pair scores; low separability means the model lacks signal on your content.`
+                );
+              }
+            } catch {
+            }
+          }
           try {
             let evalStatus;
             let freshlyRun = false;
@@ -1286,6 +1479,13 @@ function getAllToolDefinitions() {
         const session_id = crypto.randomUUID();
         const task = args.task;
         const tags = args.tags;
+        _cleanExpiredSessions();
+        _activeSessionId = session_id;
+        _sessionTelemetry.set(session_id, {
+          pack_counts: {},
+          injection_calls: 0,
+          started_at: (/* @__PURE__ */ new Date()).toISOString()
+        });
         let outbox_result;
         try {
           outbox_result = await plur.flushOutbox();
@@ -1316,9 +1516,11 @@ function getAllToolDefinitions() {
         try {
           const result = await plur.injectHybrid(task, {
             scope: tags?.length ? `tags:${tags.join(",")}` : void 0,
-            session_id
+            session_id,
             // stamped on the co_injection provenance event (#452)
+            source: "session_start"
           });
+          _recordInjectionTelemetry(session_id, result.injected_packs);
           if (result.count > 0) {
             const lines = [];
             if (result.directives) lines.push("## DIRECTIVES\n", result.directives);
@@ -1329,8 +1531,10 @@ function getAllToolDefinitions() {
         } catch {
           const result = plur.inject(task, {
             scope: tags?.length ? `tags:${tags.join(",")}` : void 0,
-            session_id
+            session_id,
+            source: "session_start"
           });
+          _recordInjectionTelemetry(session_id, result.injected_packs);
           if (result.count > 0) {
             const lines = [];
             if (result.directives) lines.push("## DIRECTIVES\n", result.directives);
@@ -1370,7 +1574,7 @@ Auto-detected project scope: "${default_scope}" (from .plur.yaml in the current
         } else if (scope_source === "none") {
           guide += `
 
-\u26A0\uFE0F No project scope detected. plur_learn calls without explicit scope will be tagged "global" and will appear in EVERY project's future sessions. Create a .plur.yaml NOW to prevent this: scope: "project:<your-project-name>". (This is every project's PERSONAL recall context, NOT team shared stores \u2014 use an explicit shared scope like project:/group: to reach a team store.) Note: an explicit scope=global RECALL surfaces all your personal engrams, but scope=global INJECT is targeted to the global namespace only \u2014 don't be surprised if a local engram a global recall finds is absent from a global inject.`;
+\u26A0\uFE0F No project scope detected. plur_learn calls without explicit scope may AUTO-ROUTE to a registered team scope whose covers confidently match the engram's domain/tags (the response reports \`routed\` when that happens); otherwise they land at the unscoped default "global" and will appear in EVERY project's future sessions. Create a .plur.yaml NOW to prevent this: scope: "project:<your-project-name>". (This is every project's PERSONAL recall context, NOT team shared stores \u2014 use an explicit shared scope like project:/group: to reach a team store.) Note: an explicit scope=global RECALL surfaces all your personal engrams, but scope=global INJECT is targeted to the global namespace only \u2014 don't be surprised if a local engram a global recall finds is absent from a global inject.`;
         }
         if (remote_scopes.length > 0) {
           const safe = (x) => String(x ?? "").replace(/\s+/g, " ").trim().slice(0, 200);
@@ -1385,9 +1589,10 @@ Auto-detected project scope: "${default_scope}" (from .plur.yaml in the current
 
 Session default scope is set to "${default_scope}". To route an engram to a remote enterprise store instead, pass scope explicitly to plur_learn (available remote scopes: ${scopeList}).` : `
 
-Remote store scopes available: ${scopeList}. Set scope PER ENGRAM by content: when an engram is relevant to the team (engineering patterns, architecture decisions, project conventions), set scope to the matching remote scope in plur_learn. Personal preferences, local project details, and corrections specific to your workflow can be left unscoped (they land at the unscoped default, "global" \u2014 the cross-project personal namespace). Do NOT let TEAM knowledge fall back to "global" \u2014 without an explicit scope it will, and it will never reach the shared store.`;
+Remote store scopes available: ${scopeList}. Set scope PER ENGRAM by content: when an engram is relevant to the team (engineering patterns, architecture decisions, project conventions), set scope to the matching remote scope in plur_learn. Personal preferences, local project details, and corrections specific to your workflow can be left unscoped \u2014 but note an unscoped write whose domain/tags confidently match a team scope's covers AUTO-ROUTES to that shared team store (the response reports \`routed\` when that happens); otherwise it lands at the unscoped default, "global" \u2014 the cross-project personal namespace. Do NOT rely on auto-routing for TEAM knowledge \u2014 set the matching scope explicitly; a weak or absent covers match falls back to "global" and never reaches the shared store.`;
           try {
             const discoveries = await plur.discoverRemoteScopes({ timeoutMs: 3e3 });
+            plur.persistScopeMetadata(discoveries);
             const failures = discoveries.filter((d) => !d.ok);
             if (failures.length > 0) {
               const authExpired = failures.some((f) => /\b40[13]\b/.test(f.error ?? ""));
@@ -1399,12 +1604,11 @@ Remote store scopes available: ${scopeList}. Set scope PER ENGRAM by content: wh
 
 \u26A0\uFE0F ENTERPRISE STORE UNREACHABLE: ${urls}. Reads fall back to local; team-scoped writes queue in the outbox` + (pending > 0 ? ` (${pending} pending)` : "") + ` until it recovers. Check connectivity/VPN.`;
             }
-            const unregistered = [...new Set(discoveries.filter((d) => d.ok).flatMap((d) => d.unregistered))];
-            if (unregistered.length > 0) {
-              const list = unregistered.map((s) => `"${safe(s)}"`).join(", ");
+            const offerable = [...new Set(discoveries.filter((d) => d.ok).flatMap((d) => d.unregistered))].filter(isSharedScope);
+            if (offerable.length > 0) {
               guide += `
 
-\u{1F50E} Your token is authorized for ${unregistered.length} more scope(s) not yet registered: ${list}. Call plur_scopes_discover with register:true to add them all in one step.`;
+\u{1F50E} ${offerable.length} authorized scope(s) not yet registered. Tell the user they can run \`plur scopes\` to register or dismiss them per-scope (dismissed scopes stop being offered; \`plur scopes --reoffer\` re-surfaces them).`;
             }
           } catch {
           }
@@ -1516,6 +1720,16 @@ Include at least one engram_suggestion if ANYTHING was learned. An empty suggest
           session_id,
           channel: "mcp"
         });
+        const telemetry = session_id ? _sessionTelemetry.get(session_id) : void 0;
+        const injection_summary = telemetry && telemetry.injection_calls > 0 ? {
+          pack_counts: { ...telemetry.pack_counts },
+          total_injections: telemetry.injection_calls,
+          session_duration_ms: Date.now() - new Date(telemetry.started_at).getTime()
+        } : void 0;
+        if (session_id) {
+          _sessionTelemetry.delete(session_id);
+          if (_activeSessionId === session_id) _activeSessionId = void 0;
+        }
         try {
           const plurDir = process.env.PLUR_PATH ?? join(homedir(), ".plur");
           const sessionsDir = join(plurDir, "sessions");
@@ -1534,6 +1748,7 @@ Include at least one engram_suggestion if ANYTHING was learned. An empty suggest
           engrams_created,
           episode_id: episode.id,
           total_engrams: status.engram_count,
+          ...injection_summary ? { injection_summary } : {},
           hint: engrams_created === 0 ? "No engrams captured this session. If any corrections, preferences, or patterns came up, consider calling plur_learn before ending." : void 0
         };
       }
@@ -1600,29 +1815,33 @@ Include at least one engram_suggestion if ANYTHING was learned. An empty suggest
     },
     {
       name: "plur_suggest_scope",
-      description: 'Suggest which registered scope(s) an engram belongs in, ranked by fit. Deterministic \u2014 no LLM, no network. Scores the statement keywords, optional domain (a dotted namespace like "plur.core.security"), and tags against the covers[] each scope declares. ADVISORY ONLY: this does not route or store anything; pass the chosen scope to plur_learn yourself. Returns candidates sorted by confidence (empty when nothing matches).',
+      description: 'Suggest which registered scope(s) an engram belongs in, ranked by fit. Deterministic \u2014 no LLM, no network. Scores the statement keywords, optional domain (a dotted namespace like "plur.core.security"), and tags against the covers[] each scope declares. ADVISORY ONLY: this does not route or store anything; pass the chosen scope to plur_learn yourself. Returns candidates sorted by confidence (empty when nothing matches). Candidates below min_confidence (default: scope_routing.min_confidence config, else 0.15) are suppressed \u2014 a lone coincidental keyword scores \u22480.12 and is noise, not signal (#670); pass min_confidence: 0 to see every scored candidate.',
       annotations: { title: "Suggest scope", readOnlyHint: true, idempotentHint: true },
       inputSchema: {
         type: "object",
         properties: {
           statement: { type: "string", description: "The engram statement to route" },
           domain: { type: "string", description: 'Optional dotted namespace for the engram (e.g. "plur.core.security") \u2014 strongest routing signal' },
-          tags: { type: "array", items: { type: "string" }, description: "Optional tags on the engram" }
+          tags: { type: "array", items: { type: "string" }, description: "Optional tags on the engram" },
+          min_confidence: { type: "number", minimum: 0, maximum: 1, description: "Suppress candidates below this confidence (0-1; out-of-range values are clamped). Default: scope_routing.min_confidence from config, else 0.15 \u2014 clips lone-keyword noise (\u22480.12) while keeping real multi-signal matches. Pass 0 for the unfiltered list." }
         },
         required: ["statement"]
       },
       handler: async (args, plur) => {
+        const raw = args.min_confidence;
+        const explicit = typeof raw === "number" && Number.isFinite(raw) ? Math.min(1, Math.max(0, raw)) : void 0;
+        const minConfidence = explicit ?? plur.getScopeRoutingConfig().min_confidence ?? SUGGEST_DISPLAY_MIN_CONFIDENCE;
         const candidates = plur.suggestScope({
           statement: args.statement,
           domain: args.domain,
           tags: args.tags
-        });
-        return { candidates, count: candidates.length };
+        }, { minConfidence });
+        return { candidates, count: candidates.length, min_confidence: minConfidence };
       }
     },
     {
       name: "plur_scopes_discover",
-      description: "Discover which scopes your remote token is authorized for via the enterprise server (GET /api/v1/me), and which of those are not yet registered locally. Read-only by default; pass register:true to register all authorized-but-unregistered scopes in one step. Only shared-family scopes (group:/project:/space:/team:/org:/public) are auto-registered \u2014 personal-family scopes (global/local/user:*/agent:*) advertised by /me are skipped and surfaced in the result. Use this when you have access to multiple team scopes on one server.",
+      description: "Discover which scopes your remote token is authorized for via the enterprise server (GET /api/v1/me), and which of those are not yet registered locally. Read-only by default; pass register:true to register all authorized-but-unregistered scopes in one step. Only shared-family scopes (group:/project:/space:/team:/org:/public) are auto-registered \u2014 personal-family scopes (global/local/user:*/agent:*) advertised by /me are skipped and surfaced in the result, and scopes the user has dismissed are respected (NOT registered by the batch path; register one individually via the CLI `plur scopes register <scope>` to override, which also clears the dismissal). Use this when you have access to multiple team scopes on one server.",
       annotations: { title: "Discover scopes", readOnlyHint: false, idempotentHint: true },
       inputSchema: {
         type: "object",
@@ -1638,11 +1857,27 @@ Include at least one engram_suggestion if ANYTHING was learned. An empty suggest
         if (discoveries.length === 0) {
           return { discovered: [], note: "No remote stores configured. Register one scope first with plur_stores_add, then discover the rest." };
         }
+        const enrich = (d) => {
+          if (!d.ok) return d;
+          const byScope = new Map(d.metadata.map((m) => [m.scope, m]));
+          const registeredSet = new Set(d.registered);
+          const scopes = d.authorized.map((scope) => {
+            const m = byScope.get(scope);
+            return {
+              scope,
+              registered: registeredSet.has(scope),
+              ...m?.description ? { description: m.description } : {},
+              ...m && m.covers.length ? { covers: m.covers } : {}
+            };
+          });
+          return { ...d, scopes };
+        };
+        const discovered = discoveries.map(enrich);
         if (!register) {
-          return { discovered: discoveries };
+          return { discovered };
         }
         const registered = await plur.registerDiscoveredScopes({ url });
-        return { discovered: discoveries, registered };
+        return { discovered, registered };
       }
     },
     {
@@ -1953,9 +2188,9 @@ Include at least one engram_suggestion if ANYTHING was learned. An empty suggest
         if (filterType) {
           engrams = engrams.filter((e) => e.type === filterType);
         }
-        const { homedir: homedir2 } = await import("os");
-        const { join: join2 } = await import("path");
-        const outputDir = args.output_dir || join2(homedir2(), "plur-packs", name);
+        const { homedir: homedir3 } = await import("os");
+        const { join: join3 } = await import("path");
+        const outputDir = args.output_dir || join3(homedir3(), "plur-packs", name);
         const result = plur.exportPack(engrams, outputDir, {
           name,
           version: "1.0.0",
@@ -2005,23 +2240,6 @@ Include at least one engram_suggestion if ANYTHING was learned. An empty suggest
         };
       }
     },
-    {
-      name: "plur_batch_decay",
-      description: "Apply ACT-R decay to all local engrams. Run weekly. Only decays engrams in the local YAML store \u2014 remote-store engrams are not decayed client-side. Returns status transitions only.",
-      annotations: { title: "Batch decay", destructiveHint: false, idempotentHint: false },
-      inputSchema: {
-        type: "object",
-        properties: {
-          context_scope: { type: "string", description: "Scope to skip during decay (engrams in active scope are not decayed)" }
-        }
-      },
-      handler: async (args, plur) => {
-        const result = plur.batchDecay({
-          contextScope: args.context_scope
-        });
-        return result;
-      }
-    },
     {
       name: "plur_profile",
       description: "Generate or retrieve a cognitive profile \u2014 a narrative summary synthesized from stored engrams. Cached for 24h.",
@@ -2059,10 +2277,34 @@ Include at least one engram_suggestion if ANYTHING was learned. An empty suggest
 }
 
 // src/server.ts
+function serverPidPath(baseDir) {
+  return join2(baseDir ?? join2(homedir2(), ".plur"), "server.pid");
+}
+function readEnterpriseToken(baseDir) {
+  const configPath = join2(baseDir ?? join2(homedir2(), ".plur"), "config.json");
+  if (!existsSync2(configPath)) return void 0;
+  try {
+    const cfg = JSON.parse(readFileSync(configPath, "utf8"));
+    const ent = cfg?.enterprise;
+    if (!ent || typeof ent.url !== "string" || typeof ent.token !== "string") return void 0;
+    return { url: ent.url, token: ent.token, username: ent.username };
+  } catch {
+    return void 0;
+  }
+}
+var _pendingReload = false;
+function isPendingReload() {
+  return _pendingReload;
+}
+function clearPendingReload() {
+  _pendingReload = false;
+}
 var INSTRUCTIONS = `PLUR is your persistent memory. Corrections, preferences, and conventions persist across sessions as engrams.
 
 PLUR is a GLOBAL tool \u2014 one MCP server, one engram store (~/.plur/), available in every project. Multi-project scoping uses domain/scope fields on engrams, not separate installations.
 
+TOOL PROFILE: by default only the core session tools are exposed directly (lean profile). Every other plur_* operation is reachable via plur_admin: { action: "<tool name>", args: {...} } \u2014 same arguments and validation as a direct call. PLUR_TOOL_PROFILE=full exposes everything directly.
+
 SESSION LIFECYCLE:
 - With hooks installed (plur init): engrams are injected automatically on first message. You do NOT need to call plur_session_start \u2014 it happens via hooks. Just call plur_session_end before the conversation ends.
 - Without hooks: call plur_session_start at the start, plur_session_end at the end.
@@ -2117,6 +2359,7 @@ Persistent memory for AI agents. Corrections, preferences, and conventions are s
 | A recalled engram was wrong or irrelevant | \`plur_feedback\` with "negative" |
 | User says "forget X" or a memory is outdated | \`plur_forget\` |
 | You need to check what's stored | \`plur_status\` or \`plur_packs_list\` |
+| User asks what memory did for them / is memory working | \`plur_receipt\` (relay its \`summary\`; activation_rate is coverage, not quality) |
 | End of session | \`plur_session_end\` with summary and suggestions |
 
 ## Tool Categories
@@ -2157,6 +2400,7 @@ Persistent memory for AI agents. Corrections, preferences, and conventions are s
 - **plur_sync** \u2014 sync engrams across devices via git
 - **plur_sync_status** \u2014 check sync state
 - **plur_status** \u2014 system health
+- **plur_receipt** \u2014 counted report of what memory retrieved for the user (local, read-only)
 
 ## Scoping
 
@@ -2178,7 +2422,7 @@ Override with \`PLUR_PATH\` environment variable.
 `;
 async function createServer(plur, options) {
   const instance = plur ?? new Plur2();
-  const tools = getToolDefinitions(options?.profile ?? "full");
+  const tools = getToolDefinitions(options?.profile ?? "lean");
   checkForUpdate("@plur-ai/mcp", VERSION, (r) => {
     if (r.updateAvailable) {
       console.error(`[plur] Update available: ${r.current} \u2192 ${r.latest}. Run: npx @plur-ai/mcp@latest`);
@@ -2196,7 +2440,7 @@ async function createServer(plur, options) {
       instructions: INSTRUCTIONS
     }
   );
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  server.setRequestHandler("tools/list", async () => ({
     tools: tools.map((t) => ({
       name: t.name,
       description: t.description,
@@ -2204,9 +2448,20 @@ async function createServer(plur, options) {
       ...t.annotations && { annotations: t.annotations }
     }))
   }));
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  server.setRequestHandler("tools/call", async (request) => {
     const tool = tools.find((t) => t.name === request.params.name);
     if (!tool) {
+      const hidden = getToolDefinitions("full").find((t) => t.name === request.params.name);
+      if (hidden) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({
+            error: `Tool "${request.params.name}" exists but is not directly callable under the current tool profile.`,
+            success: false,
+            hint: `Call it via plur_admin: { action: "${request.params.name}", args: { ... } } \u2014 same arguments, same validation, same result. To expose all tools directly, set PLUR_TOOL_PROFILE=full.`
+          }) }],
+          isError: true
+        };
+      }
       return {
         content: [{ type: "text", text: JSON.stringify({ error: `Unknown tool: ${request.params.name}`, success: false }) }],
         isError: true
@@ -2244,7 +2499,7 @@ async function createServer(plur, options) {
       };
     }
   });
-  server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+  server.setRequestHandler("resources/list", async () => ({
     resources: [
       {
         uri: "plur://guide",
@@ -2260,14 +2515,14 @@ async function createServer(plur, options) {
       }
     ]
   }));
-  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  server.setRequestHandler("resources/read", async (request) => {
     const uri = request.params.uri;
     if (uri === "plur://guide") {
-      const cursorNote = options?.profile === "cursor" ? `
+      const cursorNote = options?.profile === "cursor" || options?.profile === "lean" || options?.profile == null ? `
 
-## Cursor tool profile
+## Lean tool profile (default)
 
-Most tools above are NOT directly callable in this session \u2014 only ${[...CURSOR_CORE_TOOL_NAMES].join(", ")} are top-level tools here. Everything else in this guide is reachable through **plur_admin**: call it with \`{ action: "<tool name above>", args: {...} }\`.` : "";
+Most tools above are NOT directly callable in this session \u2014 only ${[...CURSOR_CORE_TOOL_NAMES].join(", ")} are top-level tools here. Everything else in this guide is reachable through **plur_admin**: call it with \`{ action: "<tool name above>", args: {...} }\`. Set \`PLUR_TOOL_PROFILE=full\` to expose all ${getToolDefinitions("full").length} tools directly.` : "";
       return {
         contents: [{
           uri: "plur://guide",
@@ -2292,9 +2547,9 @@ Most tools above are NOT directly callable in this session \u2014 only ${[...CUR
         }]
       };
     }
-    throw new McpError(ErrorCode.InvalidRequest, `Unknown resource: ${uri}`);
+    throw new ProtocolError(ProtocolErrorCode.InvalidRequest, `Unknown resource: ${uri}`);
   });
-  server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+  server.setRequestHandler("prompts/list", async () => ({
     prompts: [
       {
         name: "plur-getting-started",
@@ -2310,7 +2565,7 @@ Most tools above are NOT directly callable in this session \u2014 only ${[...CUR
       }
     ]
   }));
-  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+  server.setRequestHandler("prompts/get", async (request) => {
     const name = request.params.name;
     if (name === "plur-getting-started") {
       const status = instance.status();
@@ -2355,19 +2610,33 @@ Please:
         }]
       };
     }
-    throw new McpError(ErrorCode.InvalidRequest, `Unknown prompt: ${name}`);
+    throw new ProtocolError(ProtocolErrorCode.InvalidRequest, `Unknown prompt: ${name}`);
   });
   return server;
 }
 async function runStdio() {
-  const profile = process.env.PLUR_TOOL_PROFILE === "cursor" ? "cursor" : "full";
+  const envProfile = process.env.PLUR_TOOL_PROFILE;
+  const profile = envProfile === "full" ? "full" : envProfile === "cursor" ? "cursor" : "lean";
   const server = await createServer(void 0, { profile });
   registerFlushOnExit({});
+  try {
+    writeFileSync(serverPidPath(), String(process.pid));
+  } catch {
+  }
+  if (process.platform !== "win32") {
+    process.on("SIGUSR1", () => {
+      _pendingReload = true;
+    });
+  }
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
 export {
   INSTRUCTIONS,
+  clearPendingReload,
   createServer,
-  runStdio
+  isPendingReload,
+  readEnterpriseToken,
+  runStdio,
+  serverPidPath
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@plur-ai/mcp",
   "mcpName": "io.github.plur-ai/plur",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "type": "module",
   "bin": {
     "plur-mcp": "dist/index.js"
@@ -12,9 +12,11 @@
     "packs"
   ],
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.0",
+    "@modelcontextprotocol/server": "2.0.0-beta.4",
+    "@modelcontextprotocol/client": "2.0.0-beta.4",
+    "@modelcontextprotocol/core": "2.0.0-beta.4",
     "zod": "^3.23.0",
-    "@plur-ai/core": "0.13.0"
+    "@plur-ai/core": "0.15.0"
   },
   "devDependencies": {
     "@types/node": "^25.5.0"