@plur-ai/mcp 0.16.1 → 0.17.0

package/README.md

@@ -42,7 +42,7 @@ Next session starts     →  relevant ones injected →  agent remembers
 You rate the result     →  engram strengthens    →  quality improves
 ```
 
-Knowledge is stored as **engrams** — small assertions that strengthen with use and decay when irrelevant. Search is fully local (BM25 + embeddings), so memory recall costs nothing and works offline. [Benchmark methodology →](https://plur.ai/benchmark.html)
+Knowledge is stored as **engrams** — small assertions that strengthen with use and decay when irrelevant. Search runs locally (BM25 + embeddings); with a PLUR Enterprise store configured, recall also makes one live, timeout-bounded call per relevant remote host and merges the team's engrams in — and tells you, per host, when that leg is degraded instead of failing silently. Without a remote store it is fully local, costs nothing, and works offline. [Benchmark methodology →](https://plur.ai/benchmark.html)
 
 ## Tools
 
@@ -63,7 +63,9 @@ By default (lean profile), your agent gets 12 tools. Everything else is reachabl
 | `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_hybrid`, `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.
+Less commonly needed tools (`plur_recall_hybrid`, `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 42 tools directly.
+
+A `plur_*` name missing from `tools/list` means it moved behind the gateway, not that the server is down. `plur_admin { action: "help" }` returns every action with a one-line description and its argument schema; `plur_doctor` reports the same inventory as `tool_surface`.
 
 ## Sync across machines
 

package/dist/{chunk-27IMBG4G.js → chunk-JRKCEXLE.js}

@@ -10,13 +10,13 @@ function recordTelemetry(event) {
 }
 
 // src/version.ts
-var VERSION = "0.16.1";
+var VERSION = "0.17.0";
 
 // 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, SUGGEST_DISPLAY_MIN_CONFIDENCE } 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, mcpRemoteWarningLine, doctorRemoteRemediation } from "@plur-ai/core";
 import { z } from "zod";
 function makeHttpLlm(baseUrl, apiKey, model = "gpt-4o-mini") {
   return async (prompt) => {
@@ -39,15 +39,38 @@ function makeHttpLlm(baseUrl, apiKey, model = "gpt-4o-mini") {
     return data.choices?.[0]?.message?.content ?? "";
   };
 }
+function attachRemoteStoreDegradation(response, plur) {
+  let status;
+  try {
+    status = plur.remoteStoreStatus();
+  } catch {
+    return;
+  }
+  const degraded = status.filter((s) => s.status !== "ok" || (s.dropped_scopes?.length ?? 0) > 0);
+  if (degraded.length === 0) return;
+  response.remote_stores = degraded.map((s) => ({
+    host: s.host,
+    status: s.status,
+    ...s.dropped_scopes && s.dropped_scopes.length > 0 ? { dropped_scopes: s.dropped_scopes } : {}
+  }));
+  const line = `Remote store degradation \u2014 ${degraded.map((s) => mcpRemoteWarningLine(s)).join(" ")}`;
+  response.warning = typeof response.warning === "string" && response.warning.length > 0 ? `${response.warning} ${line}` : line;
+}
 var recallHandler = async (args, plur) => {
   const mode = args.mode ?? "hybrid";
   if (mode === "keyword") {
     const results = await plur.recall(args.query, {
       scope: args.scope,
       domain: args.domain,
-      limit: args.limit
+      limit: args.limit,
+      remote_timeout_ms: 2e3,
+      // MCP recall remote budget (#776)
+      // #243: session default scope (incl. mid-session plur_session_scope
+      // changes) establishes the remote dialing org context when no explicit
+      // scope filter is passed.
+      session: _resolveInjectionSession(args)
     });
-    return {
+    const response2 = {
       results: results.map((e) => {
         const supersededBy = e.relations?.superseded_by;
         const annotation = supersededBy?.length ? ` [superseded by ${supersededBy.join(", ")}]` : "";
@@ -63,6 +86,8 @@ var recallHandler = async (args, plur) => {
       count: results.length,
       mode: "keyword"
     };
+    attachRemoteStoreDegradation(response2, plur);
+    return response2;
   }
   const budget = args.budget;
   const cap = budget?.max_results ?? args.limit ?? 20;
@@ -70,7 +95,13 @@ var recallHandler = async (args, plur) => {
   const meta = await plur.recallHybridWithMeta(args.query, {
     scope: args.scope,
     domain: args.domain,
-    limit: fetchLimit
+    limit: fetchLimit,
+    remote_timeout_ms: 2e3,
+    // MCP recall remote budget (#776)
+    // #243: session default scope (incl. mid-session plur_session_scope
+    // changes) establishes the remote dialing org context when no explicit
+    // scope filter is passed.
+    session: _resolveInjectionSession(args)
   });
   recordTelemetry("recall");
   const truncatedByCount = budget?.max_results != null && meta.engrams.length > cap;
@@ -125,6 +156,7 @@ var recallHandler = async (args, plur) => {
       response.reranker_warning = `PLUR_RERANKER is set but the reranker did not engage \u2014 results are RRF-only (fusion order, no cross-encoder rerank).${corruptNote} Last error: ${rr.lastError}. Run plur_doctor for diagnosis.`;
     }
   }
+  attachRemoteStoreDegradation(response, plur);
   return response;
 };
 var RECALL_HYBRID_DEPRECATION = "plur_recall_hybrid is deprecated since 0.16 \u2014 use plur_recall (mode defaults to hybrid). This alias will be removed in 0.18.";
@@ -184,17 +216,26 @@ function validateToolArgs(tool, rawArgs) {
     const receivedFields = Object.keys(rawArgs);
     const details = parsed.error.issues.map((i) => `${i.path.join(".") || "root"}: ${i.message}`).join(", ");
     const hasArrayParam = Object.values(schema.properties ?? {}).some((p) => p?.type === "array");
-    const missingArrayParams = parsed.error.issues.filter((i) => i.code === "invalid_type" && i.received === "undefined").map((i) => String(i.path[0] ?? "")).filter((k) => schema.properties?.[k]?.type === "array");
-    const totalDrop = receivedFields.length === 0 && hasArrayParam;
-    const partialDrop = missingArrayParams.length > 0;
-    const arrayBugHint = totalDrop || partialDrop ? " Known client-side bug (plur-ai/plur#297): some MCP clients drop " + (partialDrop ? `array-typed parameters from a large arguments payload while keeping the earlier fields (here: ${missingArrayParams.join(", ")}). This is size-sensitive \u2014 the same call often succeeds with a shorter payload, so shrink the other fields (e.g. a briefer summary) as well. ` : "the entire arguments payload when an array-typed parameter is included. ") + 'Retry passing array parameters as a JSON string (e.g. tags: "[\\"a\\",\\"b\\"]") or a comma-separated string (tags: "a, b") \u2014 the server coerces both back into arrays.' : "";
+    const missingFields = parsed.error.issues.filter((i) => i.code === "invalid_type" && i.received === "undefined").map((i) => String(i.path[0] ?? "")).filter((k) => k.length > 0);
+    const missingArrayParams = missingFields.filter((k) => schema.properties?.[k]?.type === "array");
+    const wholePayloadDrop = receivedFields.length === 0;
+    const partialDrop = !wholePayloadDrop && missingArrayParams.length > 0;
+    let dropHint = "";
+    if (wholePayloadDrop) {
+      dropHint = " Known intermittent client-side issue (plur-ai/plur#772, refines #297): some MCP clients transiently drop the ENTIRE arguments payload \u2014 most often when several tool calls are batched into a single message. Nothing was stored or evaluated. Retry the IDENTICAL call with the full payload, as the ONLY tool call in that message \u2014 identical retries typically succeed. If two identical retries fail the same way, the arguments really are absent from your call \u2014 re-issue it with the intended fields." + (hasArrayParam ? ' If retries keep failing specifically on array parameters, pass them as a JSON string (e.g. tags: "[\\"a\\",\\"b\\"]") or a comma-separated string (tags: "a, b") \u2014 the server coerces both back into arrays.' : "");
+    } else if (partialDrop) {
+      dropHint = ` Known client-side bug (plur-ai/plur#297): some MCP clients drop array-typed parameters from a large arguments payload while keeping the earlier fields (here: ${missingArrayParams.join(", ")}). This is size-sensitive \u2014 the same call often succeeds with a shorter payload, so shrink the other fields (e.g. a briefer summary) as well. Retry passing array parameters as a JSON string (e.g. tags: "[\\"a\\",\\"b\\"]") or a comma-separated string (tags: "a, b") \u2014 the server coerces both back into arrays.`;
+    }
     const receivedNote = receivedFields.length > 0 ? `Received fields: [${receivedFields.join(", ")}].` : "Received no fields (the arguments object was empty).";
+    const disposition = wholePayloadDrop ? "The request reached the server but its arguments did not \u2014 do not abandon the call, and do not rewrite the payload: it was never evaluated. Retry the IDENTICAL call; it usually succeeds. If you issued several tool calls in one message, send them one per message \u2014 batching is the strongest correlate of this drop (#772)." : "The call reached the server \u2014 this is a malformed-arguments error, not a transport failure. Fix the field(s) named above and retry; do not abandon the call.";
     return {
       ok: false,
       errorPayload: {
-        error: `Invalid arguments: ${details}. ${receivedNote} The call reached the server \u2014 this is a malformed-arguments error, not a transport failure. Fix the field(s) named above and retry; do not abandon the call.` + arrayBugHint,
+        error: `Invalid arguments: ${details}. ${receivedNote} ${disposition}${dropHint}`,
         success: false,
         received_fields: receivedFields,
+        missing_fields: missingFields,
+        ...wholePayloadDrop ? { drop: "whole_payload" } : partialDrop ? { drop: "partial" } : {},
         _isError: true
       }
     };
@@ -259,10 +300,16 @@ mcpCanary.expect({
 });
 var _sessionTelemetry = /* @__PURE__ */ new Map();
 var SESSION_TTL_MS = 8 * 60 * 60 * 1e3;
-function _cleanExpiredSessions() {
+function _cleanExpiredSessions(plur) {
   const cutoff = Date.now() - SESSION_TTL_MS;
   for (const [id, state] of _sessionTelemetry) {
-    if (new Date(state.started_at).getTime() < cutoff) _sessionTelemetry.delete(id);
+    if (new Date(state.started_at).getTime() < cutoff) {
+      _sessionTelemetry.delete(id);
+      try {
+        plur?.clearSessionScope({ session: id });
+      } catch {
+      }
+    }
   }
 }
 function _implicitSessionId() {
@@ -275,6 +322,16 @@ function _resolveInjectionSession(args) {
   if (typeof explicit === "string" && explicit.length > 0) return explicit;
   return _implicitSessionId();
 }
+function _resolveScopeSession(args) {
+  const explicit = args.session_id;
+  if (typeof explicit === "string" && explicit.length > 0) {
+    return { session: explicit, ambiguous: false, open: _sessionTelemetry.size };
+  }
+  _cleanExpiredSessions();
+  const open = _sessionTelemetry.size;
+  if (open === 1) return { session: _sessionTelemetry.keys().next().value, ambiguous: false, open };
+  return { session: void 0, ambiguous: open > 1, open };
+}
 function _recordInjectionTelemetry(session_id, injected_packs) {
   if (!session_id) return;
   const state = _sessionTelemetry.get(session_id);
@@ -298,12 +355,39 @@ var CURSOR_CORE_TOOL_NAMES = /* @__PURE__ */ new Set([
   "plur_packs_uninstall",
   "plur_tensions_purge"
 ]);
+function summarizeToolDescription(description) {
+  const line = description.split("\n", 1)[0].trim();
+  if (line.length <= 200) return line;
+  const cut = line.lastIndexOf(". ", 200);
+  return cut > 40 ? line.slice(0, cut + 1) : `${line.slice(0, 199)}\u2026`;
+}
+function describeActionInventory(actions) {
+  const families = /* @__PURE__ */ new Map();
+  for (const name of actions) {
+    const family = name.replace(/^plur_/, "").split("_", 1)[0];
+    families.set(family, [...families.get(family) ?? [], name]);
+  }
+  const sorted = [...families.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+  const grouped = [];
+  const misc = [];
+  for (const [family, members] of sorted) {
+    if (members.length > 1) grouped.push(`${family}: ${members.join(", ")}`);
+    else misc.push(members[0]);
+  }
+  if (misc.length > 0) grouped.push(`other: ${misc.join(", ")}`);
+  const full = `Actions, grouped \u2014 ${grouped.join(" \xB7 ")}.`;
+  if (full.length <= 1500) return full;
+  const counted = sorted.map(([family, members]) => `${family} (${members.length})`).join(", ");
+  return `${actions.length} actions in groups ${counted} \u2014 the full list is in { action: "help" }.`;
+}
 function buildAdminDispatchTool(all) {
   const byName = new Map(all.map((t) => [t.name, t]));
   const adminActions = all.map((t) => t.name).filter((n) => !CURSOR_CORE_TOOL_NAMES.has(n)).sort();
+  const exampleAction = adminActions.includes("plur_recall_hybrid") ? "plur_recall_hybrid" : adminActions[0];
+  const exampleArgs = exampleAction === "plur_recall_hybrid" ? '{ query: "deploy checklist" }' : "{}";
   return {
     name: "plur_admin",
-    description: `Dispatch for less-common PLUR operations (packs, sync, tensions, stores, timeline, ingest, and more), collapsed into one tool so Cursor's ~40-tool-per-workspace limit is not exhausted by PLUR alone. Set "action" to the underlying tool name and "args" to that tool's normal arguments. Valid actions: ${adminActions.join(", ")}.`,
+    description: `Gateway to the ${adminActions.length} PLUR operations that are not top-level tools under the current profile (collapsed into one dispatch tool so Cursor's ~40-tool-per-workspace limit is not exhausted by PLUR alone). A plur_* name missing from tools/list means it moved HERE \u2014 not that the MCP is unavailable. Calling convention: { action: "<tool name>", args: { ...that tool's normal arguments } } \u2014 same arguments, same validation, same result as a direct call. Example: { action: "${exampleAction}", args: ${exampleArgs} }. Send { action: "help" } for every action's one-line description and argument schema. ${describeActionInventory(adminActions)}`,
     annotations: { title: "Admin dispatch", readOnlyHint: false },
     inputSchema: {
       type: "object",
@@ -315,16 +399,27 @@ function buildAdminDispatchTool(all) {
         // CallToolRequestSchema handler's Zod validation would reject
         // unknown actions before this handler's `if (!target)` branch ever
         // ran.
-        action: { type: "string", description: "Which underlying plur_* tool to invoke" },
+        action: { type: "string", description: 'Which underlying plur_* tool to invoke, or "help" to list every action with its description and argument schema' },
         args: { type: "object", description: "Arguments for the chosen action, matching that tool's normal input schema", additionalProperties: true }
       },
       required: ["action"]
     },
     handler: async (args, plur) => {
       const action = args.action;
+      if (action === "help") {
+        return {
+          calling_convention: 'plur_admin { action: "<tool name>", args: { ... } } \u2014 same arguments, same validation, same result as calling that tool directly. A tools/list miss on one of these names means it is consolidated here, NOT that the MCP is unavailable.',
+          actions: adminActions.map((name) => {
+            const t = byName.get(name);
+            return { action: name, description: summarizeToolDescription(t.description), args_schema: t.inputSchema };
+          }),
+          standalone_tools: all.map((t) => t.name).filter((n) => CURSOR_CORE_TOOL_NAMES.has(n)).sort(),
+          standalone_note: "standalone_tools are exposed as top-level tools in every profile \u2014 call them directly, never through plur_admin (destructive ones are refused here so their risk annotations stay visible to your client)."
+        };
+      }
       const target = byName.get(action);
       if (!target) {
-        return { error: `Unknown action "${action}". Valid actions: ${adminActions.join(", ")}`, success: false, _isError: true };
+        return { error: `Unknown action "${action}". Valid actions: help, ${adminActions.join(", ")}`, success: false, _isError: true };
       }
       if (target.annotations?.destructiveHint === true) {
         return {
@@ -347,6 +442,29 @@ function buildAdminDispatchTool(all) {
     }
   };
 }
+function resolveToolProfile(env = process.env) {
+  const v = env.PLUR_TOOL_PROFILE;
+  return v === "full" ? "full" : v === "cursor" ? "cursor" : "lean";
+}
+var activeProfile = null;
+function setActiveToolProfile(profile) {
+  activeProfile = profile;
+}
+function activeToolProfile() {
+  return activeProfile ?? resolveToolProfile();
+}
+function describeToolSurface(profile = activeToolProfile()) {
+  const all = getAllToolDefinitions();
+  const exposed = getToolDefinitions(profile);
+  const standalone = exposed.map((t) => t.name).sort();
+  const admin_actions = profile === "full" ? [] : all.map((t) => t.name).filter((n) => !CURSOR_CORE_TOOL_NAMES.has(n)).sort();
+  return {
+    profile,
+    standalone,
+    admin_actions,
+    note: admin_actions.length === 0 ? "All tools are exposed directly under this profile." : `Only the ${standalone.length} tools in "standalone" are callable by name. Everything in "admin_actions" is reachable as plur_admin { action: "<name>", args: {...} } \u2014 same arguments, same validation, same result. A name-lookup miss on one of those means it moved, NOT that the MCP is unavailable. Call plur_admin { action: "help" } for each action's description and argument schema. Set PLUR_TOOL_PROFILE=full to expose all tools directly.`
+  };
+}
 function getToolDefinitions(profile = "lean") {
   const all = getAllToolDefinitions();
   if (profile === "full") return all;
@@ -386,7 +504,8 @@ function getAllToolDefinitions() {
           locked_reason: { type: "string", description: "Why this engram is locked (only meaningful when commitment=locked)" },
           valid_from: { type: "string", description: "ISO date (YYYY-MM-DD) the knowledge becomes valid \u2014 inject/recall skip the engram before this date (#347)" },
           valid_until: { type: "string", description: 'ISO date (YYYY-MM-DD) the knowledge expires \u2014 inject/recall skip the engram after this date. Set this for any time-bound fact (offers, deadlines, temporary endpoints). When omitted, an explicit expiry phrase in the statement ("valid until 31 May 2026") is auto-parsed and echoed back (#347)' },
-          supersedes: { type: "array", items: { type: "string" }, description: "Engram IDs this statement intentionally replaces (#240). Writes relations.supersedes on the new engram and the reverse superseded_by edge on each local target. Supersedes-linked pairs are skipped by tension scans \u2014 an intentional update is not a contradiction. Use when updating a standing fact (new version, changed rule) rather than contradicting it." }
+          supersedes: { type: "array", items: { type: "string" }, description: "Engram IDs this statement intentionally replaces (#240). Writes relations.supersedes on the new engram and the reverse superseded_by edge on each local target. Supersedes-linked pairs are skipped by tension scans \u2014 an intentional update is not a contradiction. Use when updating a standing fact (new version, changed rule) rather than contradicting it." },
+          session_id: { type: "string", description: "Session this write belongs to (from plur_session_start). Resolves the session default scope (incl. mid-session plur_session_scope changes) when no explicit scope is passed. Optional when one session is open; pass it when several are (#243)." }
         },
         required: ["statement"]
       },
@@ -405,6 +524,11 @@ function getAllToolDefinitions() {
           valid_from: args.valid_from,
           valid_until: args.valid_until,
           supersedes: args.supersedes,
+          // #243: resolve which session's default scope governs this write —
+          // explicit session_id first, else the lone open session. Never
+          // persisted on the engram (LearnContext.session selects a scope, it
+          // is not part of one).
+          session: _resolveInjectionSession(args),
           llm
         };
         const explicitScope = typeof args.scope === "string" && args.scope.length > 0;
@@ -578,7 +702,7 @@ function getAllToolDefinitions() {
     },
     {
       name: "plur_recall",
-      description: 'Search engrams by topic. Default mode is hybrid (BM25 + local embeddings via RRF) \u2014 set mode:"keyword" for BM25-only. No API calls, fully local. 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.',
+      description: 'Search engrams by topic. Default mode is hybrid (BM25 + local embeddings via RRF) \u2014 set mode:"keyword" for BM25-only. Local search plus, when a configured enterprise store is part of the current project/work, one live timeout-bounded recall per remote host merged in (a `remote_stores` block + warning appears when a host is degraded; no host configured or implicated = fully local). 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.',
       annotations: { title: "Recall", readOnlyHint: true, idempotentHint: true },
       inputSchema: {
         type: "object",
@@ -590,7 +714,8 @@ function getAllToolDefinitions() {
           limit: { type: "number", description: "Max results to return (default 20)" },
           budget: { type: "object", description: 'Budget constraints for sub-agents. Hybrid mode only \u2014 ignored when mode:"keyword".', properties: { max_tokens: { type: "number" }, max_results: { type: "number" }, ttl_seconds: { type: "number" } } },
           caller_session_id: { type: "string", description: 'Session ID of calling agent for budget enforcement. Hybrid mode only \u2014 ignored when mode:"keyword".' },
-          include_episodes: { type: "boolean", description: 'If true, include linked episode summaries for each engram (SP2 episodic anchoring). Hybrid mode only \u2014 ignored when mode:"keyword".' }
+          include_episodes: { type: "boolean", description: 'If true, include linked episode summaries for each engram (SP2 episodic anchoring). Hybrid mode only \u2014 ignored when mode:"keyword".' },
+          session_id: { type: "string", description: "Session this recall belongs to (from plur_session_start). Its default scope (incl. mid-session plur_session_scope changes) sets the remote dialing context when no explicit scope filter is passed. Optional when one session is open (#243)." }
         },
         required: ["query"]
       },
@@ -598,7 +723,7 @@ function getAllToolDefinitions() {
     },
     {
       name: "plur_recall_hybrid",
-      description: "[Deprecated since 0.16 \u2014 use plur_recall (mode defaults to hybrid). Alias kept for backwards compatibility; removal earliest 0.18.] Hybrid search \u2014 BM25 + local embeddings merged via Reciprocal Rank Fusion. No API calls, fully local.",
+      description: "[Deprecated since 0.16 \u2014 use plur_recall (mode defaults to hybrid). Alias kept for backwards compatibility; removal earliest 0.18.] Hybrid search \u2014 BM25 + local embeddings merged via Reciprocal Rank Fusion, plus the live enterprise-store recall leg when one is configured and project-relevant.",
       annotations: { title: "Recall (hybrid) [deprecated alias]", readOnlyHint: true, idempotentHint: true },
       inputSchema: {
         type: "object",
@@ -609,7 +734,8 @@ function getAllToolDefinitions() {
           limit: { type: "number", description: "Max results to return (default 20)" },
           budget: { type: "object", description: "Budget constraints for sub-agents", properties: { max_tokens: { type: "number" }, max_results: { type: "number" }, ttl_seconds: { type: "number" } } },
           caller_session_id: { type: "string", description: "Session ID of calling agent for budget enforcement" },
-          include_episodes: { type: "boolean", description: "If true, include linked episode summaries for each engram (SP2 episodic anchoring)" }
+          include_episodes: { type: "boolean", description: "If true, include linked episode summaries for each engram (SP2 episodic anchoring)" },
+          session_id: { type: "string", description: "Session this recall belongs to (from plur_session_start). Its default scope sets the remote dialing context when no explicit scope filter is passed (#243)." }
         },
         required: ["query"]
       },
@@ -678,7 +804,7 @@ function getAllToolDefinitions() {
           session_id
         });
         _recordInjectionTelemetry(session_id, result.injected_packs);
-        return {
+        const response = {
           directives: result.directives,
           consider: result.consider,
           count: result.count,
@@ -688,6 +814,8 @@ function getAllToolDefinitions() {
           // #181: unresolved-tension warnings — flag contradicted context
           ...result.warnings ? { warnings: result.warnings } : {}
         };
+        attachRemoteStoreDegradation(response, plur);
+        return response;
       }
     },
     {
@@ -790,17 +918,17 @@ function getAllToolDefinitions() {
           const engram = await plur.getById(args.id);
           if (engram) {
             if (engram.status === "retired") return { success: false, error: `Already retired: ${args.id}` };
-            await plur.forget(args.id);
+            await plur.forget(args.id, void 0, { force: true });
             return { success: true, retired: { id: engram.id, statement: engram.statement } };
           }
-          await plur.forget(args.id);
+          await plur.forget(args.id, void 0, { force: true });
           return { success: true, retired: { id: args.id } };
         }
         if (args.search) {
-          const matches = await plur.recall(args.search, { limit: 100 });
+          const matches = await plur.recall(args.search, { limit: 100, remote: false });
           if (matches.length === 0) return { success: false, error: `No active engrams matching "${args.search}"` };
           if (matches.length === 1) {
-            await plur.forget(matches[0].id);
+            await plur.forget(matches[0].id, void 0, { force: true });
             return { success: true, retired: { id: matches[0].id, statement: matches[0].statement } };
           }
           return {
@@ -985,6 +1113,11 @@ function getAllToolDefinitions() {
             engram_count: p.engram_count,
             integrity: p.integrity,
             integrity_ok: p.integrity_ok,
+            // 'ok' | 'modified' | 'unverified' (#805, F11). `integrity_ok`
+            // collapses "cannot be checked" into the same `undefined` an absent
+            // field has, so a caller reading only that cannot distinguish a
+            // clean pack from one whose baseline was destroyed.
+            integrity_status: p.integrity_status,
             installed_at: p.installed_at,
             source: p.source
           })),
@@ -1030,7 +1163,7 @@ function getAllToolDefinitions() {
           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."
+            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, and episode/candidate/tension records derived from non-pushed engrams are stripped too (#686). Persist the choice in config.yaml as sync.remote_type instead of passing it per call."
           }
         }
       },
@@ -1245,8 +1378,13 @@ function getAllToolDefinitions() {
           created_after: args.created_after
         });
         const versionCheck = getCachedUpdateCheck("@plur-ai/mcp");
+        const tool_profile = activeToolProfile();
         return {
           version: VERSION,
+          tool_profile,
+          ...tool_profile !== "full" ? {
+            tool_surface_note: `Tool profile "${tool_profile}": most plur_* operations are not top-level tools \u2014 call them as plur_admin { action: "<name>", args: {...} }; send { action: "help" } for the list. A name-lookup miss means a tool moved there, not that the MCP is down.`
+          } : {},
           engram_count: status.engram_count,
           episode_count: status.episode_count,
           pack_count: status.pack_count,
@@ -1264,6 +1402,10 @@ function getAllToolDefinitions() {
           },
           // Last background index/reembed failure (#272) — absent when healthy.
           ...status.index_error ? { index_error: status.index_error } : {},
+          // Artifacts that could not be read (audit 2026-08-03, finding 14).
+          // Core reports these; this hand-built response dropped them, so an
+          // agent asking for status saw a healthy-looking `pack_count: 0`.
+          ...status.store_errors ? { store_errors: status.store_errors } : {},
           // Version check (issue #151)
           ...versionCheck?.updateAvailable && versionCheck.latest ? {
             update_available: {
@@ -1473,6 +1615,28 @@ function getAllToolDefinitions() {
           }
         } catch {
         }
+        try {
+          for (const s of plur.remoteStoreStatus()) {
+            const fix = doctorRemoteRemediation(s);
+            const degraded = s.status !== "ok" || (s.dropped_scopes?.length ?? 0) > 0;
+            checks.push({
+              check: `remote recall: ${s.host}`,
+              ok: !degraded,
+              detail: degraded ? `Last live recall: ${s.status}${s.dropped_scopes?.length ? ` (dropped scopes: ${s.dropped_scopes.join(", ")})` : ""} \u2014 recent recalls served local results only.` : `Last live recall ok (${s.count} row(s) in ${s.ms}ms)`
+            });
+            if (fix) remediation.push(fix);
+          }
+          for (const c of plur.remoteEndpointTokenConflicts()) {
+            checks.push({
+              check: `remote store tokens: ${c.url}`,
+              ok: false,
+              detail: `${c.tokens} distinct tokens configured for this endpoint \u2014 recall dials once per (url, token).`
+            });
+            remediation.push(`Remote ${c.url}: ${c.tokens} distinct tokens are configured across its store entries \u2014 consolidate to one token in ~/.plur/config.yaml so recall dials the host once.`);
+          }
+        } catch {
+        }
+        const tool_surface = describeToolSurface();
         return {
           ok: checks.every((c) => c.ok),
           checks,
@@ -1481,6 +1645,7 @@ function getAllToolDefinitions() {
             after_probe: after
           },
           capabilities: canaryStatuses,
+          tool_surface,
           remediation: remediation.length > 0 ? remediation : ["All checks passed \u2014 PLUR is healthy."]
         };
       }
@@ -1505,7 +1670,7 @@ function getAllToolDefinitions() {
         const session_id = crypto.randomUUID();
         const task = args.task;
         const tags = args.tags;
-        _cleanExpiredSessions();
+        _cleanExpiredSessions(plur);
         _sessionTelemetry.set(session_id, {
           pack_counts: {},
           injection_calls: 0,
@@ -1531,12 +1696,21 @@ function getAllToolDefinitions() {
         const default_scope = explicit_default_scope ?? projectConfig.scope ?? null;
         const scope_source = explicit_default_scope ? "caller" : projectConfig.scope ? "project-config" : "none";
         plur.setSessionScope(default_scope);
-        const status = await plur.status();
+        plur.setSessionScope(default_scope, { session: session_id });
+        {
+          const t = _sessionTelemetry.get(session_id);
+          if (t) {
+            t.default_scope = default_scope;
+            t.default_scope_source = scope_source;
+          }
+        }
+        const status = await plur.status().catch(() => null);
         const store_stats = {
-          engram_count: status.engram_count,
-          episode_count: status.episode_count,
-          pack_count: status.pack_count
+          engram_count: status?.engram_count ?? 0,
+          episode_count: status?.episode_count ?? 0,
+          pack_count: status?.pack_count ?? 0
         };
+        const store_errors = status?.store_errors;
         await plur.warmRemoteCaches().catch(() => {
         });
         let engrams = null;
@@ -1545,7 +1719,9 @@ function getAllToolDefinitions() {
             scope: tags?.length ? `tags:${tags.join(",")}` : void 0,
             session_id,
             // stamped on the co_injection provenance event (#452)
-            source: "session_start"
+            source: "session_start",
+            remote_timeout_ms: 5e3
+            // session_start warm budget (#776)
           });
           _recordInjectionTelemetry(session_id, result.injected_packs);
           if (result.count > 0) {
@@ -1654,10 +1830,17 @@ Remote store scopes available: ${scopeList}. Set scope PER ENGRAM by content: wh
           } catch {
           }
         }
-        return {
+        const session_tool_profile = activeToolProfile();
+        if (session_tool_profile !== "full") {
+          guide += `
+
+Tool profile "${session_tool_profile}": most plur_* tools are not exposed by name \u2014 call them via plur_admin { action: "<tool name>", args: {...} } (send { action: "help" } for the full action list).`;
+        }
+        const sessionResponse = {
           session_id,
           engrams: engrams ?? [],
           store_stats,
+          ...store_errors ? { store_errors } : {},
           guide,
           // Remote scope routing info (#229)
           ...remote_scopes.length > 0 ? { remote_scopes } : {},
@@ -1681,6 +1864,98 @@ Remote store scopes available: ${scopeList}. Set scope PER ENGRAM by content: wh
           // Version staleness warning (issue #151)
           ...version_warning ? { version_warning, version: VERSION } : {}
         };
+        attachRemoteStoreDegradation(sessionResponse, plur);
+        return sessionResponse;
+      }
+    },
+    {
+      name: "plur_session_scope",
+      description: `Adjust or inspect the session default write scope MID-session \u2014 narrow, expand, or switch context without restarting the session (#243). op:"set" replaces the default scope used by unscoped plur_learn calls for the rest of the session AND the org context that decides which enterprise hosts plur_recall dials; op:"show" reports the effective scope and how it was derived (project config, session_start default, or a mid-session set); op:"clear" reverts to the scope the session started with. Use when the conversation genuinely pivots \u2014 a focused bug fix surfacing a team-wide architecture insight, or switching to another org's project. Do NOT oscillate scope call-by-call: for a one-off write to a different scope, pass scope explicitly on that plur_learn instead (explicit per-call scope always beats the session default). Every change is logged as a session_scope_changed history event.`,
+      annotations: { title: "Session scope", destructiveHint: false, idempotentHint: true },
+      inputSchema: {
+        type: "object",
+        properties: {
+          op: {
+            type: "string",
+            enum: ["set", "show", "clear"],
+            description: "set: replace the session default write scope; show: report the effective scope and its derivation; clear: revert to the session-start default."
+          },
+          scope: {
+            type: "string",
+            description: 'New session default scope (op:"set" only), e.g. "project:myapp" or "group:org/team". Must match a configured store scope to route writes to a remote store \u2014 other strings stay local under that namespace.'
+          },
+          reason: {
+            type: "string",
+            description: "Optional one-line explanation of why the scope is changing \u2014 logged on the session_scope_changed event for retrospective debugging."
+          },
+          session_id: {
+            type: "string",
+            description: "Session to target (from plur_session_start). Optional when one session is open; REQUIRED when several are \u2014 a scope change must never decide another session's writes."
+          }
+        },
+        required: ["op"]
+      },
+      handler: async (args, plur) => {
+        const op = args.op;
+        if (op !== "set" && op !== "show" && op !== "clear") {
+          throw new Error(`plur_session_scope: op must be "set", "show" or "clear", got ${JSON.stringify(args.op)}`);
+        }
+        const reason = args.reason;
+        const { session, ambiguous, open } = _resolveScopeSession(args);
+        const record = session ? _sessionTelemetry.get(session) : void 0;
+        const remote_scopes = plur.getWritableRemoteScopes();
+        const withCommon = (body) => ({
+          op,
+          ...body,
+          ...session ? { session_id: session } : {},
+          ...remote_scopes.length > 0 ? { remote_scopes } : {}
+        });
+        if (op === "show") {
+          const scope = plur.getSessionScope({ session });
+          const source = record ? record.scope_adjusted ? "session-adjusted" : record.default_scope_source === "caller" ? "session-start" : record.default_scope_source ?? "none" : scope == null ? "none" : "process-default";
+          return withCommon({
+            scope,
+            source,
+            ...ambiguous ? {
+              warning: `${open} sessions are open \u2014 this is the process-default slot, not a specific session's scope. Pass session_id (from plur_session_start) to inspect one.`
+            } : {},
+            guide: scope == null ? "No session default scope is set: unscoped plur_learn writes auto-route on a confident covers match or land at the unscoped default. Explicit per-call scope always wins." : `Unscoped plur_learn calls this session default to "${scope}"; recall dialing follows the same org context. Explicit per-call scope always wins.`
+          });
+        }
+        if (ambiguous) {
+          throw new Error(
+            `plur_session_scope: ${open} sessions are open on this server \u2014 pass session_id (from plur_session_start) so the scope change targets the right session and cannot bleed into another one.`
+          );
+        }
+        if (op === "set") {
+          const scope = args.scope;
+          if (typeof scope !== "string" || scope.trim().length === 0) {
+            throw new Error('plur_session_scope: op:"set" requires a non-empty string "scope" (use op:"clear" to revert to the session-start default)');
+          }
+          if (!/^\S+$/.test(scope) || scope.length > 200) {
+            throw new Error(`plur_session_scope: invalid scope ${JSON.stringify(scope)} \u2014 a scope is a single token without whitespace (e.g. "project:myapp", "group:org/team"), max 200 chars`);
+          }
+          const { previous: previous2, next: next2 } = plur.adjustSessionScope(scope, { session, reason, trigger: "set" });
+          if (record) record.scope_adjusted = true;
+          const remoteEntry = remote_scopes.find((s) => s.scope === scope);
+          const warning = isSharedScope(scope) ? remoteEntry ? `"${scope}" routes to the shared remote store at ${remoteEntry.url}: every unscoped plur_learn for the rest of this session defaults there, visible to everyone with read access to that scope. The per-write secrets/sensitivity guard still scans each write (offending content is demoted to local), but relevance is your call \u2014 clear or narrow the scope when the conversation leaves team context.` : `"${scope}" is a shared-family scope but matches no configured remote store scope, so writes stay on this machine under that namespace. The write-time sensitivity guard treats it as shared (scans + demotes offending content). If you expected a team store, check the remote_scopes list.` : void 0;
+          return withCommon({
+            previous_scope: previous2,
+            new_scope: next2,
+            ...reason ? { reason } : {},
+            ...warning ? { warning } : {}
+          });
+        }
+        const restored = record !== void 0 ? record.default_scope ?? null : readProjectConfig().scope ?? null;
+        const restored_source = record !== void 0 ? record.default_scope_source === "caller" ? "session-start" : record.default_scope_source ?? "none" : restored != null ? "project-config" : "none";
+        const { previous, next } = plur.adjustSessionScope(restored, { session, reason, trigger: "clear" });
+        if (record) record.scope_adjusted = false;
+        return withCommon({
+          previous_scope: previous,
+          new_scope: next,
+          restored_source,
+          ...reason ? { reason } : {}
+        });
       }
     },
     {
@@ -1759,6 +2034,7 @@ Include at least one engram_suggestion if ANYTHING was learned. An empty suggest
         } : void 0;
         if (session_id) {
           _sessionTelemetry.delete(session_id);
+          plur.clearSessionScope({ session: session_id });
         }
         try {
           const plurDir = process.env.PLUR_PATH ?? join(homedir(), ".plur");
@@ -1824,7 +2100,15 @@ Include at least one engram_suggestion if ANYTHING was learned. An empty suggest
             requested_scope: requestedScope,
             note: `This path is already registered under scope "${result.scope}". A local store is keyed by its path, so the requested scope "${requestedScope}" was NOT added. Use a separate store file for a different scope, or remove the existing entry first.`
           } : {},
-          kind: url ? "remote" : "filesystem"
+          kind: url ? "remote" : "filesystem",
+          // Filesystem stores are read sources — plur_learn writes to the
+          // primary engrams.yaml and carries the scope label there (#766).
+          // Pre-populate the file via plur_packs_export or direct YAML edit
+          // to inject team engrams; plur_learn with this scope will land them
+          // in your primary store tagged with the scope.
+          ...path && !scopeDropped && !url ? {
+            note: `Store initialized at ${path}. plur_learn calls with scope "${result.scope}" are tagged with that scope but stored in your primary engrams.yaml. To share engrams across machines via this file, populate it via plur_packs_export or direct YAML and commit it to your repo.`
+          } : {}
         };
       }
     },
@@ -1912,7 +2196,7 @@ Include at least one engram_suggestion if ANYTHING was learned. An empty suggest
     },
     {
       name: "plur_promote",
-      description: "Activate candidate engrams so they appear in injection results",
+      description: "Activate candidate engrams so they appear in injection results. Status change only \u2014 it does NOT move an engram to another scope; to promote an engram into a team/shared scope use plur_rescope (#676).",
       annotations: { title: "Promote", destructiveHint: false, idempotentHint: true },
       inputSchema: {
         type: "object",
@@ -1944,12 +2228,45 @@ Include at least one engram_suggestion if ANYTHING was learned. An empty suggest
           engram.activation.retrieval_strength = 0.7;
           engram.activation.storage_strength = 1;
           engram.activation.last_accessed = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-          await plur.updateEngram(engram);
+          const written = await plur.updateEngram(engram);
+          if (!written) {
+            errors.push({ id, error: "Not persisted \u2014 the engram may have been removed or its store is read-only" });
+            continue;
+          }
           promoted.push({ id, statement: engram.statement });
         }
         return { promoted, errors, success: errors.length === 0 };
       }
     },
+    {
+      name: "plur_rescope",
+      description: "Move existing engram(s) to a different scope (#676) \u2014 e.g. promote a personal/local engram into a team scope so it reaches the shared store. Bypasses the content-hash dedup that makes a plur_learn re-emit a silent no-op: rescope matches by id and moves the engram. Remote targets (a configured writable store scope): a copy is pushed via the routed write path (the server assigns the id, provenance is kept in the copy's source field) and the local original is soft-retired with a superseded_by link \u2014 set keep_local:true to keep it active. Local targets (local, global, project:*): the scope is rewritten in place, preserving id and activation. The target must be local/global/project:* or a scope with a configured writable store \u2014 anything else fails early (typo protection). Content is re-scanned for secrets/sensitive material before any shared/remote target and a hit blocks the move. Batch via ids; dry_run:true previews every decision without mutating anything. NOT candidate activation \u2014 that is plur_promote.",
+      annotations: { title: "Rescope", destructiveHint: false, idempotentHint: true },
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Single engram ID to move" },
+          ids: { type: "array", items: { type: "string" }, description: "Multiple engram IDs to move to the same target scope (batch)" },
+          target_scope: { type: "string", description: "Destination scope: local, global, project:<name>, or a scope with a configured writable store (e.g. group:org/team)" },
+          keep_local: { type: "boolean", description: "Remote targets only: keep the local original active after the push (default false \u2014 it is retired with a superseded_by link so it stops injecting)" },
+          dry_run: { type: "boolean", description: "Preview the per-engram outcome without mutating anything, local or remote" }
+        },
+        required: ["target_scope"]
+      },
+      handler: async (args, plur) => {
+        const targetIds = args.ids ?? (args.id ? [args.id] : []);
+        if (targetIds.length === 0) throw new Error("Provide id or ids");
+        const { results, success } = await plur.rescope(targetIds, args.target_scope, {
+          keep_local: args.keep_local,
+          dry_run: args.dry_run
+        });
+        return {
+          results,
+          success,
+          ...args.dry_run === true ? { dry_run: true, note: "Dry run \u2014 nothing was changed." } : {}
+        };
+      }
+    },
     {
       name: "plur_tensions",
       description: 'Tension lifecycle (#181). Default: list persisted tension records (unresolved first). scan:true runs an LLM contradiction scan, persists NEW detections as records, and skips already-recorded pairs. Lifecycle actions: action:"confirm" (real conflict), action:"dismiss" (false positive \u2014 pair suppressed from future scans), action:"resolve" + winner:<engram_id> (loser engram retired). Scan requires OPENAI_API_KEY or OPENROUTER_API_KEY env var, or explicit llm_base_url + llm_api_key args.',
@@ -2312,5 +2629,7 @@ export {
   validateToolArgs,
   mcpCanary,
   CURSOR_CORE_TOOL_NAMES,
+  resolveToolProfile,
+  setActiveToolProfile,
   getToolDefinitions
 };

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.16.1";
+var VERSION = "0.17.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-GMXICHML.js");
+  const { runStdio } = await import("./server-GLVXYLB5.js");
   runStdio().catch((err) => {
     console.error("Failed to start PLUR MCP server:", err);
     process.exit(1);

package/dist/{server-GMXICHML.js → server-GLVXYLB5.js}

@@ -4,24 +4,51 @@ import {
   getToolDefinitions,
   mcpCanary,
   registerFlushOnExit,
+  resolveToolProfile,
+  setActiveToolProfile,
   validateToolArgs
-} from "./chunk-27IMBG4G.js";
+} from "./chunk-JRKCEXLE.js";
 
 // src/server.ts
 import { Server, ProtocolError, ProtocolErrorCode } from "@modelcontextprotocol/server";
 import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
-import { existsSync, readFileSync, writeFileSync } from "fs";
-import { join } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join2 } from "path";
 import { homedir } from "os";
-import { Plur, checkForUpdate } from "@plur-ai/core";
+import { Plur, checkForUpdate, VERSION_CHECK_SUCCESS_TTL_MS } from "@plur-ai/core";
+
+// src/drop-log.ts
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { atomicWrite, withLock } from "@plur-ai/core";
+var PAYLOAD_DROP_LOG_MAX_ENTRIES = 100;
+function payloadDropLogPath(storageRoot) {
+  return join(storageRoot, "logs", "payload-drops.jsonl");
+}
+function recordPayloadDrop(storageRoot, record) {
+  try {
+    const path = payloadDropLogPath(storageRoot);
+    mkdirSync(dirname(path), { recursive: true });
+    withLock(path, () => {
+      appendFileSync(path, JSON.stringify(record) + "\n");
+      const lines = readFileSync(path, "utf8").split("\n").filter((l) => l.length > 0);
+      if (lines.length > PAYLOAD_DROP_LOG_MAX_ENTRIES) {
+        atomicWrite(path, lines.slice(-PAYLOAD_DROP_LOG_MAX_ENTRIES).join("\n") + "\n", { durable: false });
+      }
+    });
+  } catch {
+  }
+}
+
+// src/server.ts
 function serverPidPath(baseDir) {
-  return join(baseDir ?? join(homedir(), ".plur"), "server.pid");
+  return join2(baseDir ?? join2(homedir(), ".plur"), "server.pid");
 }
 function readEnterpriseToken(baseDir) {
-  const configPath = join(baseDir ?? join(homedir(), ".plur"), "config.json");
-  if (!existsSync(configPath)) return void 0;
+  const configPath = join2(baseDir ?? join2(homedir(), ".plur"), "config.json");
+  if (!existsSync2(configPath)) return void 0;
   try {
-    const cfg = JSON.parse(readFileSync(configPath, "utf8"));
+    const cfg = JSON.parse(readFileSync2(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 };
@@ -40,7 +67,7 @@ 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.
+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. A plur_* name missing from tools/list means it MOVED behind plur_admin, not that the MCP is down \u2014 never conclude the server is unavailable from a name-lookup miss. Discover the live surface with plur_admin { action: "help" } (every action with description + argument schema) or plur_doctor (tool_surface). 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.
@@ -76,7 +103,7 @@ var GUIDE_RESOURCE = `# PLUR \u2014 Agent Guide
 
 ## What is PLUR?
 
-Persistent memory for AI agents. Corrections, preferences, and conventions are stored as **engrams** \u2014 small assertions that strengthen with use and decay when irrelevant (ACT-R model). Storage is plain YAML on disk. Search is fully local (BM25 + embeddings). Zero API calls.
+Persistent memory for AI agents. Corrections, preferences, and conventions are stored as **engrams** \u2014 small assertions that strengthen with use and decay when irrelevant (ACT-R model). Storage is plain YAML on disk. Search runs locally (BM25 + embeddings); when an enterprise/remote store is configured AND relevant to the current project, recall additionally makes one live timeout-bounded call per remote host and merges the results \u2014 degradation is surfaced per host via a \`remote_stores\` block, never silent. With no remote store configured, search is fully local with zero API calls.
 
 ## Quick Start
 
@@ -110,7 +137,8 @@ Persistent memory for AI agents. Corrections, preferences, and conventions are s
 - **plur_recall** \u2014 hybrid search by default (BM25 + embeddings); pass mode:"keyword" for BM25-only
 - **plur_feedback** \u2014 rate an engram (trains relevance)
 - **plur_forget** \u2014 retire an outdated engram
-- **plur_promote** \u2014 activate a candidate engram
+- **plur_promote** \u2014 activate a candidate engram (status only \u2014 never changes scope)
+- **plur_rescope** \u2014 move an engram to another scope (e.g. promote a local engram into a team store)
 
 ### Context Injection
 - **plur_inject** \u2014 select engrams for a task (BM25)
@@ -156,14 +184,24 @@ Use \`scope\` to namespace engrams per project:
 
 Override with \`PLUR_PATH\` environment variable.
 `;
+var versionRecheckTimer;
 async function createServer(plur, options) {
   const instance = plur ?? new Plur();
-  const tools = getToolDefinitions(options?.profile ?? "lean");
-  checkForUpdate("@plur-ai/mcp", VERSION, (r) => {
+  const profile = options?.profile ?? "lean";
+  setActiveToolProfile(profile);
+  const tools = getToolDefinitions(profile);
+  const announceUpdate = (r) => {
     if (r.updateAvailable) {
       console.error(`[plur] Update available: ${r.current} \u2192 ${r.latest}. Run: npx @plur-ai/mcp@latest`);
     }
-  });
+  };
+  checkForUpdate("@plur-ai/mcp", VERSION, announceUpdate);
+  if (!versionRecheckTimer) {
+    versionRecheckTimer = setInterval(() => {
+      checkForUpdate("@plur-ai/mcp", VERSION, announceUpdate);
+    }, VERSION_CHECK_SUCCESS_TTL_MS);
+    versionRecheckTimer.unref?.();
+  }
   const server = new Server(
     { name: "plur-mcp", version: VERSION },
     {
@@ -205,9 +243,31 @@ async function createServer(plur, options) {
     }
     mcpCanary.tick();
     try {
-      let args = request.params.arguments ?? {};
+      const rawArguments = request.params.arguments;
+      let args = rawArguments ?? {};
       const validated = validateToolArgs(tool, args);
       if (!validated.ok) {
+        const drop = validated.errorPayload.drop;
+        if (drop) {
+          recordPayloadDrop(instance.storageRoot, {
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            tool: request.params.name,
+            arguments_wire: drop === "whole_payload" ? rawArguments === void 0 ? "absent" : "empty_object" : "partial",
+            params_keys: Object.keys(request.params ?? {}),
+            received_fields: validated.errorPayload.received_fields,
+            missing_fields: validated.errorPayload.missing_fields,
+            request_id: request.id,
+            server_version: VERSION
+          });
+          try {
+            void Promise.resolve(server.sendLoggingMessage({
+              level: "warning",
+              data: `Payload drop (#772) on ${request.params.name}: arguments ${rawArguments === void 0 ? "key absent from frame" : `arrived with fields [${validated.errorPayload.received_fields.join(", ")}]`}. Recorded in ${payloadDropLogPath(instance.storageRoot)}.`
+            })).catch(() => {
+            });
+          } catch {
+          }
+        }
         return {
           content: [{ type: "text", text: JSON.stringify(validated.errorPayload) }],
           isError: true
@@ -351,8 +411,7 @@ Please:
   return server;
 }
 async function runStdio() {
-  const envProfile = process.env.PLUR_TOOL_PROFILE;
-  const profile = envProfile === "full" ? "full" : envProfile === "cursor" ? "cursor" : "lean";
+  const profile = resolveToolProfile();
   const server = await createServer(void 0, { profile });
   registerFlushOnExit({});
   try {
@@ -368,6 +427,7 @@ async function runStdio() {
   await server.connect(transport);
 }
 export {
+  GUIDE_RESOURCE,
   INSTRUCTIONS,
   clearPendingReload,
   createServer,

package/dist/tools-export.d.ts

@@ -37,6 +37,8 @@ declare function validateToolArgs(tool: ToolDefinition, rawArgs: Record<string,
         error: string;
         success: false;
         received_fields: string[];
+        missing_fields: string[];
+        drop?: 'whole_payload' | 'partial';
         _isError: true;
     };
 };

package/dist/tools-export.js

@@ -2,7 +2,7 @@ import {
   CURSOR_CORE_TOOL_NAMES,
   getToolDefinitions,
   validateToolArgs
-} from "./chunk-27IMBG4G.js";
+} from "./chunk-JRKCEXLE.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.16.1",
+  "version": "0.17.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.16.1"
+    "@plur-ai/core": "0.17.0"
   },
   "devDependencies": {
     "@types/node": "^25.5.0"