@plur-ai/mcp 0.14.0 → 0.15.0

package/README.md

@@ -46,26 +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_learn_batch` | Store many memories in one call — same dedup + policy as `plur_learn`, with per-item failure isolation |
 | `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
 
@@ -102,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,7 +5,7 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSy
 import { join } from "path";
 import { fileURLToPath } from "url";
 import { homedir, platform } from "os";
-var VERSION = "0.14.0";
+var VERSION = "0.15.0";
 var HELP = `plur-mcp v${VERSION} \u2014 persistent memory for AI agents
 
 Usage:
@@ -351,7 +351,7 @@ if (arg === "packs") {
   process.exit(0);
 }
 if (arg === "serve" || arg === void 0) {
-  const { runStdio } = await import("./server-LAXRBVKA.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-LAXRBVKA.js → server-7JVOIBJV.js}

@@ -1,16 +1,6 @@
 // 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";
@@ -20,7 +10,7 @@ import { Plur as Plur2, checkForUpdate } from "@plur-ai/core";
 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";
@@ -34,7 +24,7 @@ function recordTelemetry(event) {
 }
 
 // src/version.ts
-var VERSION = "0.14.0";
+var VERSION = "0.15.0";
 
 // src/tools.ts
 import { z } from "zod";
@@ -208,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"
@@ -240,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) {
@@ -254,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 [
     {
@@ -319,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 {
@@ -344,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.` } : {}
@@ -362,6 +381,7 @@ 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.`
           };
@@ -433,6 +453,17 @@ function getAllToolDefinitions() {
         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) => ({
@@ -445,6 +476,7 @@ function getAllToolDefinitions() {
             ...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.` } : {}
         };
       }
@@ -589,7 +621,9 @@ 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 {
@@ -619,7 +653,9 @@ 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 {
@@ -970,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;
@@ -1206,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).',
@@ -1456,8 +1516,9 @@ 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) {
@@ -1470,7 +1531,8 @@ 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) {
@@ -1512,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);
@@ -1527,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 ?? ""));
@@ -1541,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 {
           }
@@ -1753,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",
@@ -2237,6 +2303,8 @@ var INSTRUCTIONS = `PLUR is your persistent memory. Corrections, preferences, an
 
 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.
@@ -2291,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
@@ -2331,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
 
@@ -2352,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`);
@@ -2370,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,
@@ -2378,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
@@ -2418,7 +2499,7 @@ async function createServer(plur, options) {
       };
     }
   });
-  server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+  server.setRequestHandler("resources/list", async () => ({
     resources: [
       {
         uri: "plur://guide",
@@ -2434,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",
@@ -2466,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",
@@ -2484,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();
@@ -2529,12 +2610,13 @@ 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 {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@plur-ai/mcp",
   "mcpName": "io.github.plur-ai/plur",
-  "version": "0.14.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.14.0"
+    "@plur-ai/core": "0.15.0"
   },
   "devDependencies": {
     "@types/node": "^25.5.0"