@plur-ai/mcp 0.17.1 → 0.18.0

package/README.md

@@ -63,7 +63,7 @@ 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 42 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 43 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`.
 

package/dist/{chunk-6N2B7J6A.js → chunk-QEGZYXTD.js}

@@ -10,13 +10,13 @@ function recordTelemetry(event) {
 }
 
 // src/version.ts
-var VERSION = "0.17.1";
+var VERSION = "0.18.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, mcpRemoteWarningLine, doctorRemoteRemediation } 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, normalizeEndpointUrl, REMOTE_STATUS_TTL_MS, PROBE_CLEARABLE_STATES } from "@plur-ai/core";
 import { z } from "zod";
 function makeHttpLlm(baseUrl, apiKey, model = "gpt-4o-mini") {
   return async (prompt) => {
@@ -39,10 +39,21 @@ function makeHttpLlm(baseUrl, apiKey, model = "gpt-4o-mini") {
     return data.choices?.[0]?.message?.content ?? "";
   };
 }
+function formatAge(ageMs) {
+  if (typeof ageMs !== "number" || !Number.isFinite(ageMs)) return "(age unknown)";
+  const s = Math.floor(ageMs / 1e3);
+  if (s < 10) return "just now";
+  if (s < 60) return `${s}s ago`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ago`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h ago`;
+  return `${Math.floor(h / 24)}d ago`;
+}
 function attachRemoteStoreDegradation(response, plur) {
   let status;
   try {
-    status = plur.remoteStoreStatus();
+    status = plur.remoteStoreStatus({ freshOnly: true });
   } catch {
     return;
   }
@@ -74,13 +85,25 @@ var recallHandler = async (args, plur) => {
       results: results.map((e) => {
         const supersededBy = e.relations?.superseded_by;
         const annotation = supersededBy?.length ? ` [superseded by ${supersededBy.join(", ")}]` : "";
+        const raw = e;
+        const measuredUnder = raw.measured_under;
+        const measuredAnnotation = measuredUnder ? " [measured under: " + Object.entries(measuredUnder).filter(([, v]) => v != null).map(([k, v]) => `${k}=${v}`).join(", ") + "]" : "";
         return {
           id: e.id,
-          statement: e.statement + annotation,
+          statement: e.statement + annotation + measuredAnnotation,
           type: e.type,
           scope: e.scope,
           domain: e.domain,
-          retrieval_strength: e.activation.retrieval_strength
+          retrieval_strength: e.activation.retrieval_strength,
+          // SAME FACT, not same record (#852 follow-up). A stable SHA-256 of
+          // the normalized statement: two engrams sharing it assert the same
+          // thing, in different stores or under different ids. Use it to match
+          // across stores and to spot a restatement you already hold — NOT as
+          // an identifier. Statements mutate (UPDATE, MERGE, procedure
+          // evolution), so this changes when the content does; `id` is what
+          // stays fixed.
+          content_hash: e.content_hash,
+          ...measuredUnder ? { measured_under: measuredUnder } : {}
         };
       }),
       count: results.length,
@@ -127,13 +150,19 @@ var recallHandler = async (args, plur) => {
       const raw = e;
       const supersededBy = e.relations?.superseded_by;
       const annotation = supersededBy?.length ? ` [superseded by ${supersededBy.join(", ")}]` : "";
+      const measuredUnder = raw.measured_under;
+      const measuredAnnotation = measuredUnder ? " [measured under: " + Object.entries(measuredUnder).filter(([, v]) => v != null).map(([k, v]) => `${k}=${v}`).join(", ") + "]" : "";
       const base = {
         id: e.id,
-        statement: e.statement + annotation,
+        statement: e.statement + annotation + measuredAnnotation,
         type: e.type,
         scope: e.scope,
         domain: e.domain,
-        retrieval_strength: e.activation.retrieval_strength
+        retrieval_strength: e.activation.retrieval_strength,
+        // Same fact, not same record — see the note on the other recall
+        // formatter. Both shapes carry it or an agent gets it only sometimes.
+        content_hash: raw.content_hash,
+        ...measuredUnder ? { measured_under: measuredUnder } : {}
       };
       if (includeEpisodes && raw.episode_ids?.length > 0) {
         const episodes = plur.timeline({ search: "" });
@@ -219,17 +248,19 @@ function validateToolArgs(tool, rawArgs) {
     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;
+    const partialDrop = !wholePayloadDrop && missingFields.length > 0;
+    const arrayShapedDrop = partialDrop && 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) {
+    } else if (arrayShapedDrop) {
       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,
+      missingArrayParams,
       errorPayload: {
         error: `Invalid arguments: ${details}. ${receivedNote} ${disposition}${dropHint}`,
         success: false,
@@ -483,7 +514,7 @@ function getAllToolDefinitions() {
   return [
     {
       name: "plur_learn",
-      description: "Create an engram \u2014 record a reusable learning, preference, or correction. Multi-agent note: in an orchestration that spawns subagents, have the PARENT session own plur_learn writes \u2014 spawned subagents should return their findings as text for the parent to persist, rather than each calling plur_learn (tool availability is not guaranteed in every subagent context). See plur-ai/plur#281.",
+      description: "Create an engram \u2014 record a reusable learning, preference, or correction. A write is never suppressed by similarity: exact content-hash duplicates NOOP, and anything merely SIMILAR is written and reported back in `dedup.near_duplicates` (closest existing engrams and their cosine scores) so you can supersede or merge deliberately. High similarity is a reason to look, not a decision \u2014 cosine cannot tell a duplicate from a correction of it. Multi-agent note: in an orchestration that spawns subagents, have the PARENT session own plur_learn writes \u2014 spawned subagents should return their findings as text for the parent to persist, rather than each calling plur_learn (tool availability is not guaranteed in every subagent context). See plur-ai/plur#281.",
       annotations: { title: "Learn", destructiveHint: false, idempotentHint: false },
       inputSchema: {
         type: "object",
@@ -500,12 +531,23 @@ function getAllToolDefinitions() {
           rationale: { type: "string", description: "Why this knowledge matters \u2014 also enters the search corpus, helps recall by intent not just statement" },
           source: { type: "string", description: "Origin of this knowledge (URL, conversation ref, etc.)" },
           pinned: { type: "boolean", description: "Always-load flag. If true, this engram bypasses the keyword-relevance gate at injection time. Use sparingly: meta-rules, safety conventions, core operating principles only." },
-          commitment: { type: "string", enum: ["exploring", "leaning", "decided", "locked"], description: "How firmly the user has committed to this belief (default: leaning)" },
+          commitment: { type: "string", enum: ["exploring", "leaning", "decided", "locked", "draft"], description: "How firmly the user has committed to this belief (default: leaning). `draft` marks the engram as pending human approval \u2014 core stores and recalls it normally; enforcement is left to deployments with a review queue." },
           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." },
-          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)." }
+          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)." },
+          measured_under: {
+            type: "object",
+            description: "Measurement context for numeric or benchmark-derived claims (#869). Records the conditions under which the asserted value was measured \u2014 model, source_type, hardware, dataset, date. When present, differing-condition measurements are stored as refinements rather than tensions. Omit for non-numeric engrams.",
+            properties: {
+              model: { type: "string", description: 'Model or system variant (e.g. "claude-opus-4", "gpt-4o")' },
+              source_type: { type: "string", description: 'Source environment type (e.g. "local-git", "gitlab", "bench", "production")' },
+              hardware: { type: "string", description: 'Hardware or runtime tier (e.g. "M3-Pro-36GB", "A100", "CI-runner")' },
+              dataset: { type: "string", description: 'Dataset or workload identifier (e.g. "LongMemEval-S", "plur-bench-2026-Q2")' },
+              date: { type: "string", description: "ISO date (YYYY-MM-DD) the measurement was taken" }
+            }
+          }
         },
         required: ["statement"]
       },
@@ -524,6 +566,7 @@ function getAllToolDefinitions() {
           valid_from: args.valid_from,
           valid_until: args.valid_until,
           supersedes: args.supersedes,
+          measured_under: args.measured_under,
           // #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
@@ -572,13 +615,23 @@ function getAllToolDefinitions() {
           const routed = engram.structured_data?._routed;
           mcpCanary.signal("learn_activity");
           recordTelemetry("learn");
+          const dedup = isOutbox ? void 0 : await plur.nearDuplicates(statement, context, engram.id);
           return {
-            id: engram.id,
+            // #914: report the id in the form plur_recall hands back, so a
+            // caller that records what it just learned and passes it to
+            // plur_feedback / plur_forget is holding an id shape the read side
+            // actually produces. An outbox engram is excluded: it is sitting in
+            // the LOCAL store under a local id until the retry lands, and that
+            // is the id recall returns for it.
+            id: isOutbox ? engram.id : plur.readIdFor(engram),
             statement: engram.statement,
             scope: engram.scope,
             type: engram.type,
             pinned: engram.pinned === true,
+            // See the note on recall results: same fact, not same record.
+            content_hash: engram.content_hash,
             decision: "ADD",
+            ...dedup?.near_duplicates?.length ? { dedup } : {},
             ...temporalEcho(engram),
             ...scopeHint(engram.scope, !!routed),
             ...domainHint(!!routed),
@@ -609,7 +662,7 @@ function getAllToolDefinitions() {
     },
     {
       name: "plur_learn_batch",
-      description: "Create many engrams in one call \u2014 the batch form of plur_learn. Accepts an array of engram objects and writes them sequentially through the SAME dedup + policy pipeline as plur_learn (content-hash NOOP \u2192 semantic recall \u2192 LLM ADD/UPDATE/MERGE decision). Dedup also applies WITHIN the batch: a statement duplicating an earlier item in the same array resolves to NOOP against it. Returns `ids` aligned 1:1 with the input array (ids[i] is the engram id for input i, or null if input i failed), the per-item decisions (each carrying its input_index), aggregate stats, and any per-item failures (each with its input index) \u2014 a single bad item does not abort the batch. Use this when an orchestration fans out and wants to persist consolidated findings without N separate calls. LLM dedup calls are capped (default 50, override with max_llm_calls) to bound bulk-import cost. Note: unlike plur_learn, batch items take the LOCAL learn path \u2014 remote-scope auto-routing (learnRouted) is not applied per item, so for shared/remote-store writes prefer plur_learn or pass an explicit local scope. See plur-ai/plur#281.",
+      description: 'Create many engrams in one call \u2014 the batch form of plur_learn. Accepts an array of engram objects and writes them sequentially through the SAME dedup + policy pipeline as plur_learn (content-hash NOOP \u2192 semantic recall \u2192 LLM ADD/UPDATE/MERGE decision, or local cosine REPORTING when no LLM is configured). Exact-hash dedup also applies WITHIN the batch: a statement duplicating an earlier item in the same array resolves to NOOP against it. Similarity never suppresses a write \u2014 each result carries `dedup.mode` (llm | cosine | hash-only) and, when similarity ran, `dedup.near_duplicates`. Read dedup.mode before trusting an ADD: hash-only means "not identical", NOT "not a duplicate". Returns `ids` aligned 1:1 with the input array (ids[i] is the engram id for input i, or null if input i failed), the per-item decisions (each carrying its input_index), aggregate stats, and any per-item failures (each with its input index) \u2014 a single bad item does not abort the batch. Use this when an orchestration fans out and wants to persist consolidated findings without N separate calls. LLM dedup calls are capped (default 50, override with max_llm_calls) to bound bulk-import cost. Note: unlike plur_learn, batch items take the LOCAL learn path \u2014 remote-scope auto-routing (learnRouted) is not applied per item, so for shared/remote-store writes prefer plur_learn or pass an explicit local scope. See plur-ai/plur#281.',
       annotations: { title: "Learn (batch)", destructiveHint: false, idempotentHint: false },
       inputSchema: {
         type: "object",
@@ -628,14 +681,25 @@ function getAllToolDefinitions() {
                 rationale: { type: "string", description: "Why this knowledge matters \u2014 also enters the search corpus" },
                 source: { type: "string", description: "Origin of this knowledge (URL, conversation ref, etc.)" },
                 pinned: { type: "boolean", description: "Always-load flag. Use sparingly: meta-rules, safety conventions, core principles." },
-                commitment: { type: "string", enum: ["exploring", "leaning", "decided", "locked"], description: "How firmly the user has committed (default: leaning)" },
+                commitment: { type: "string", enum: ["exploring", "leaning", "decided", "locked", "draft"], description: "How firmly the user has committed (default: leaning). `draft` marks the engram as pending human approval \u2014 core stores and recalls it normally; enforcement is left to deployments with a review queue." },
                 valid_from: { type: "string", description: "ISO date (YYYY-MM-DD) the knowledge becomes valid" },
-                valid_until: { type: "string", description: "ISO date (YYYY-MM-DD) the knowledge expires" }
+                valid_until: { type: "string", description: "ISO date (YYYY-MM-DD) the knowledge expires" },
+                measured_under: {
+                  type: "object",
+                  description: "Measurement context for numeric/benchmark claims (#869). Fields: model, source_type, hardware, dataset, date.",
+                  properties: {
+                    model: { type: "string" },
+                    source_type: { type: "string" },
+                    hardware: { type: "string" },
+                    dataset: { type: "string" },
+                    date: { type: "string" }
+                  }
+                }
               },
               required: ["statement"]
             }
           },
-          max_llm_calls: { type: "number", description: "Max LLM dedup calls across the whole batch (default 50). Once spent, remaining items use the cheap hash/cosine path. Pass a large number to opt out." }
+          max_llm_calls: { type: "number", description: "Max LLM dedup calls across the whole batch (default 50). Once spent, remaining items fall back to the local cosine path (no API cost); the dedup.mode on each result says which ran. Pass a large number to opt out." }
         },
         required: ["engrams"]
       },
@@ -657,7 +721,8 @@ function getAllToolDefinitions() {
             commitment: e.commitment,
             pinned: e.pinned,
             valid_from: e.valid_from,
-            valid_until: e.valid_until
+            valid_until: e.valid_until,
+            measured_under: e.measured_under
           }
         }));
         const maxLlmCalls = typeof args.max_llm_calls === "number" ? args.max_llm_calls : void 0;
@@ -673,7 +738,12 @@ function getAllToolDefinitions() {
           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;
+        const routedInputs = /* @__PURE__ */ new Set();
+        for (const r of results) {
+          const routed = r.engram.structured_data?._routed;
+          if (routed !== void 0 && r.input_index !== void 0) routedInputs.add(r.input_index);
+        }
+        const noDomainCount = raw.filter((e, i) => !(typeof e.domain === "string" && e.domain.length > 0) && !(typeof e.scope === "string" && e.scope.length > 0) && !routedInputs.has(i)).length;
         if (noDomainCount > 0) {
           try {
             const coversScopes = plur.listScopeMetadata().filter((md) => (md.covers?.length ?? 0) > 0).map((md) => md.scope);
@@ -692,7 +762,11 @@ function getAllToolDefinitions() {
             scope: r.engram.scope,
             type: r.engram.type,
             decision: r.decision,
-            ...r.existing_id ? { existing_id: r.existing_id } : {}
+            ...r.existing_id ? { existing_id: r.existing_id } : {},
+            // #856 audit: `dedup` was computed and then dropped here, so the
+            // reporting it exists for reached no caller — "anything below the
+            // bar is still reported" was not observable anywhere.
+            ...r.dedup ? { dedup: r.dedup } : {}
           })),
           stats,
           ...batchDomainHint,
@@ -712,7 +786,13 @@ function getAllToolDefinitions() {
           scope: { type: "string", description: "Filter by scope (also includes global)" },
           domain: { type: "string", description: "Filter by domain prefix" },
           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" } } },
+          // `ttl_seconds` was declared here and never read (#703). A schema
+          // field an agent can set and no handler consults is a lie the tool
+          // tells about itself — it reads as "caching is configurable" and
+          // nothing caches. Removed rather than documented: there is no
+          // behaviour to describe, and describing "accepted and ignored"
+          // still costs every caller a decision.
+          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" } } },
           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".' },
           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)." }
@@ -732,7 +812,7 @@ function getAllToolDefinitions() {
           scope: { type: "string", description: "Filter by scope (also includes global)" },
           domain: { type: "string", description: "Filter by domain prefix" },
           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" } } },
+          budget: { type: "object", description: "Budget constraints for sub-agents", properties: { max_tokens: { type: "number" }, max_results: { 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)" },
           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)." }
@@ -831,13 +911,18 @@ function getAllToolDefinitions() {
             enum: ["positive", "negative", "neutral"],
             description: "Feedback signal (single mode)"
           },
+          scope: {
+            type: "string",
+            description: 'Store scope to target directly, e.g. "primary" for the local store or a remote scope like "group:plur/plur-ai/engineering". Required when the same engram ID exists in multiple stores (#850).'
+          },
           signals: {
             type: "array",
             items: {
               type: "object",
               properties: {
                 id: { type: "string", description: "Engram ID" },
-                signal: { type: "string", enum: ["positive", "negative", "neutral"] }
+                signal: { type: "string", enum: ["positive", "negative", "neutral"] },
+                scope: { type: "string", description: "Store scope to target directly (optional, same semantics as top-level scope)." }
               },
               required: ["id", "signal"]
             },
@@ -849,9 +934,9 @@ function getAllToolDefinitions() {
         if (args.signals && Array.isArray(args.signals)) {
           const results = [];
           const summary = { positive: 0, negative: 0, neutral: 0 };
-          for (const { id, signal } of args.signals) {
+          for (const { id, signal, scope } of args.signals) {
             try {
-              await plur.feedback(id, signal);
+              await plur.feedback(id, signal, scope);
               results.push({ id, signal, success: true });
               summary[signal]++;
             } catch (err) {
@@ -861,7 +946,7 @@ function getAllToolDefinitions() {
           return { mode: "batch", results, summary };
         }
         try {
-          await plur.feedback(args.id, args.signal);
+          await plur.feedback(args.id, args.signal, args.scope);
           return { success: true, id: args.id, signal: args.signal };
         } catch (err) {
           if (err.message?.includes("readonly store")) {
@@ -910,19 +995,21 @@ function getAllToolDefinitions() {
         type: "object",
         properties: {
           id: { type: "string", description: "Exact engram ID to retire" },
-          search: { type: "string", description: "Search term to find engram to retire" }
+          search: { type: "string", description: "Search term to find engram to retire" },
+          scope: { type: "string", description: 'Which store holds it (#831). Ids are minted per store, so one id can name several unrelated engrams. Pass "primary" to stay on disk \u2014 the local primary store and any local secondary stores, never a remote \u2014 or a remote scope (e.g. "group:plur/plur-ai/engineering") to target that server. A scope matching no configured store is rejected, not guessed at. Omit it and an id resolving in two places is refused.' }
         }
       },
       handler: async (args, plur) => {
         if (args.id) {
-          const engram = await plur.getById(args.id);
+          const scope = args.scope;
+          const engram = scope ? void 0 : await plur.getById(args.id);
           if (engram) {
             if (engram.status === "retired") return { success: false, error: `Already retired: ${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, void 0, { force: true });
-          return { success: true, retired: { id: args.id } };
+          await plur.forget(args.id, void 0, { force: true, ...scope ? { scope } : {} });
+          return { success: true, retired: { id: args.id, ...scope ? { scope } : {} } };
         }
         if (args.search) {
           const matches = await plur.recall(args.search, { limit: 100, remote: false });
@@ -1147,7 +1234,7 @@ function getAllToolDefinitions() {
     },
     {
       name: "plur_sync",
-      description: "Sync engrams via git AND refresh the derived index from YAML. Initializes repo on first call, commits and pushes/pulls on subsequent calls. Provide a remote URL on first call to enable cross-device sync. Pass full=true to drop-and-rebuild the index from YAML (recovery path; YAML stays untouched).",
+      description: "Sync engrams via git AND refresh the derived index from YAML. Initializes repo on first call, commits and pushes/pulls on subsequent calls. Provide a remote URL on first call to enable cross-device sync. Pass full=true to drop-and-rebuild the index from YAML (recovery path; YAML stays untouched). Also flushes the remote-write outbox \u2014 retries team-scoped writes that were queued while their remote store was unreachable; use plur_outbox to inspect what is queued.",
       annotations: { title: "Sync", openWorldHint: true, destructiveHint: false, idempotentHint: true },
       inputSchema: {
         type: "object",
@@ -1201,6 +1288,31 @@ function getAllToolDefinitions() {
         };
       }
     },
+    {
+      name: "plur_outbox",
+      description: "Inspect the remote-write outbox \u2014 team-scoped writes queued locally because their remote store was unreachable. Read-only by default; pass flush:true to retry them now. Entries never include the target URL or token.",
+      annotations: { title: "Outbox", readOnlyHint: false, idempotentHint: false },
+      inputSchema: {
+        type: "object",
+        properties: {
+          flush: { type: "boolean", description: "Retry every queued write now, instead of only reporting them. Defaults to false." }
+        }
+      },
+      handler: async (args, plur) => {
+        const before = await plur.listOutbox();
+        if (args.flush !== true) {
+          return { pending: before.length, entries: before };
+        }
+        const result = await plur.flushOutbox();
+        return {
+          pending: await plur.outboxCount(),
+          flushed: result.flushed,
+          failed: result.failed,
+          ...result.expired_warnings.length > 0 ? { expired_warnings: result.expired_warnings } : {},
+          attempted: before
+        };
+      }
+    },
     {
       name: "plur_sync_status",
       description: "Check git sync status \u2014 whether repo is initialized, has remote, is dirty, ahead/behind counts",
@@ -1593,9 +1705,11 @@ function getAllToolDefinitions() {
             if (cs.warning) remediation.push(cs.warning);
           }
         }
+        const probedOkHosts = /* @__PURE__ */ new Set();
         try {
           const remotes = await plur.checkRemoteHealth({ timeoutMs: 5e3 });
           for (const h of remotes) {
+            if (h.status === "ok") probedOkHosts.add(normalizeEndpointUrl(h.url));
             const expiresNote = typeof h.tokenExpiresInDays === "number" ? ` \u2014 token ${h.tokenExpiresInDays < 0 ? `expired ${-h.tokenExpiresInDays}d ago` : `expires in ${h.tokenExpiresInDays}d`}` : "";
             if (h.status === "ok") {
               const soon = typeof h.tokenExpiresInDays === "number" && h.tokenExpiresInDays <= 7;
@@ -1617,13 +1731,26 @@ function getAllToolDefinitions() {
         }
         try {
           for (const s of plur.remoteStoreStatus()) {
-            const fix = doctorRemoteRemediation(s);
-            const degraded = s.status !== "ok" || (s.dropped_scopes?.length ?? 0) > 0;
+            const dropped = s.dropped_scopes?.length ? ` (dropped scopes: ${s.dropped_scopes.join(", ")})` : "";
+            const failed = s.status !== "ok" || (s.dropped_scopes?.length ?? 0) > 0;
+            const stale = (s.age_ms ?? 0) > REMOTE_STATUS_TTL_MS;
+            const contradicted = probedOkHosts.has(s.host) && PROBE_CLEARABLE_STATES.has(s.status);
+            const historical = failed && (stale || contradicted);
+            if (historical) {
+              const why = contradicted ? "the /me probe above just reached this host, so this is not the current state" : "older than the status TTL, so this is not the current state";
+              checks.push({
+                check: `remote recall: ${s.host}`,
+                ok: true,
+                detail: `Last live recall: ${s.status}${dropped} ${formatAge(s.age_ms)} \u2014 ${why}. Recalls at that time served local results only.`
+              });
+              continue;
+            }
             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)`
+              ok: !failed,
+              detail: failed ? `Last live recall: ${s.status}${dropped} ${formatAge(s.age_ms)} \u2014 recent recalls served local results only.` : `Last live recall ok (${s.count} row(s) in ${s.ms}ms) ${formatAge(s.age_ms)}`
             });
+            const fix = doctorRemoteRemediation(s);
             if (fix) remediation.push(fix);
           }
           for (const c of plur.remoteEndpointTokenConflicts()) {
@@ -1799,13 +1926,13 @@ Remote store scopes available: ${scopeList}. Set scope PER ENGRAM by content: wh
             const failures = discoveries.filter((d) => !d.ok);
             if (failures.length > 0) {
               const authExpired = failures.some((f) => /\b40[13]\b/.test(f.error ?? ""));
-              const pending = outbox_result?.failed ?? 0;
+              const pending = await plur.outboxCount().catch(() => outbox_result?.failed ?? 0);
               const urls = [...new Set(failures.map((f) => f.url))].join(", ");
               guide += authExpired ? `
 
 \u26A0\uFE0F ENTERPRISE STORE AUTH FAILED (token expired/invalid): ${urls}. Team-scoped engrams are NOT syncing` + (pending > 0 ? ` \u2014 ${pending} queued in the outbox` : "") + `. Reauth: open <host>/auth/github (or <host>/me/api-keys) in a browser, paste the token into ~/.plur/config.yaml, then restart Claude/MCP. Queued engrams flush on the next session_start.` : `
 
-\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.`;
+\u26A0\uFE0F ENTERPRISE STORE UNREACHABLE: ${urls}. Reads fall back to local; team-scoped writes queue in the outbox` + (pending > 0 ? ` (${pending} pending \u2014 inspect with plur_outbox, retry with plur_outbox {flush:true})` : "") + ` until it recovers. Check connectivity/VPN.`;
             }
             const offerable = [...new Set(discoveries.filter((d) => d.ok).flatMap((d) => d.unregistered))].filter(isSharedScope);
             if (offerable.length > 0) {

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.17.1";
+var VERSION = "0.18.0";
 var HELP = `plur-mcp v${VERSION} \u2014 persistent memory for AI agents
 
 Usage:
@@ -274,63 +274,14 @@ async function runInit() {
   }
 }
 async function runPacks() {
-  const sub = process.argv[3];
   const plurPath = process.env.PLUR_PATH ?? join(homedir(), ".plur");
   const { Plur } = await import("@plur-ai/core");
+  const { packsCommand } = await import("./packs-cli-YQTKUTWY.js");
   const plur = new Plur({ path: plurPath });
-  if (sub === "install") {
-    const source = process.argv[4];
-    if (!source) {
-      process.stderr.write("Usage: plur-mcp packs install <path>\n");
-      process.exit(1);
-    }
-    try {
-      const result = await plur.installPack(source);
-      process.stdout.write(`Installed pack '${result.name}' (${result.installed} engrams)
-`);
-    } catch (err) {
-      process.stderr.write(`Error: ${err.message}
-`);
-      process.exit(1);
-    }
-  } else if (sub === "list") {
-    const packs = plur.listPacks();
-    if (packs.length === 0) {
-      process.stdout.write("No packs installed.\n");
-    } else {
-      for (const pack of packs) {
-        const version = pack.manifest?.version ? ` v${pack.manifest.version}` : "";
-        process.stdout.write(`${pack.name}${version} (${pack.engram_count} engrams)
-`);
-      }
-    }
-  } else if (sub === "uninstall") {
-    const name = process.argv[4];
-    if (!name) {
-      process.stderr.write("Usage: plur-mcp packs uninstall <name>\n");
-      process.exit(1);
-    }
-    try {
-      const result = plur.uninstallPack(name);
-      if (result.removed) {
-        process.stdout.write(`Uninstalled pack '${result.name}' (${result.engram_count} engrams removed)
-`);
-      } else {
-        process.stderr.write(`Pack '${name}' not found.
-`);
-        process.exit(1);
-      }
-    } catch (err) {
-      process.stderr.write(`Error: ${err.message}
-`);
-      process.exit(1);
-    }
-  } else {
-    process.stderr.write(`Unknown packs subcommand: ${sub ?? "(none)"}
-Available: install, list, uninstall
-`);
-    process.exit(1);
-  }
+  const result = await packsCommand(process.argv.slice(3), plur);
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  if (result.exitCode !== 0) process.exit(result.exitCode);
 }
 var arg = process.argv[2];
 if (arg === "--help" || arg === "-h") {
@@ -351,7 +302,7 @@ if (arg === "packs") {
   process.exit(0);
 }
 if (arg === "serve" || arg === void 0) {
-  const { runStdio } = await import("./server-JSZAATIC.js");
+  const { runStdio } = await import("./server-AUVPSGTD.js");
   runStdio().catch((err) => {
     console.error("Failed to start PLUR MCP server:", err);
     process.exit(1);

package/dist/packs-cli-YQTKUTWY.js

@@ -0,0 +1,43 @@
+// src/packs-cli.ts
+var ok = (stdout) => ({ stdout, stderr: "", exitCode: 0 });
+var fail = (stderr) => ({ stdout: "", stderr, exitCode: 1 });
+async function packsCommand(args, plur) {
+  const [sub, arg] = args;
+  if (sub === "install") {
+    if (!arg) return fail("Usage: plur-mcp packs install <path>\n");
+    try {
+      const result = await plur.installPack(arg);
+      return ok(`Installed pack '${result.name}' (${result.installed} engrams)
+`);
+    } catch (err) {
+      return fail(`Error: ${err.message}
+`);
+    }
+  }
+  if (sub === "list") {
+    const packs = plur.listPacks();
+    if (packs.length === 0) return ok("No packs installed.\n");
+    return ok(packs.map((p) => {
+      const version = p.manifest?.version ? ` v${p.manifest.version}` : "";
+      return `${p.name}${version} (${p.engram_count} engrams)
+`;
+    }).join(""));
+  }
+  if (sub === "uninstall") {
+    if (!arg) return fail("Usage: plur-mcp packs uninstall <name>\n");
+    try {
+      const result = plur.uninstallPack(arg);
+      return ok(`Uninstalled pack '${result.name}' (${result.engram_count} engrams removed)
+`);
+    } catch (err) {
+      return fail(`Error: ${err.message}
+`);
+    }
+  }
+  return fail(`Unknown packs subcommand: ${sub ?? "(none)"}
+Available: install, list, uninstall
+`);
+}
+export {
+  packsCommand
+};

package/dist/{server-JSZAATIC.js → server-AUVPSGTD.js}

@@ -7,7 +7,7 @@ import {
   resolveToolProfile,
   setActiveToolProfile,
   validateToolArgs
-} from "./chunk-6N2B7J6A.js";
+} from "./chunk-QEGZYXTD.js";
 
 // src/server.ts
 import { Server, ProtocolError, ProtocolErrorCode } from "@modelcontextprotocol/server";
@@ -21,7 +21,7 @@ import { Plur, checkForUpdate, VERSION_CHECK_SUCCESS_TTL_MS } from "@plur-ai/cor
 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;
+var PAYLOAD_DROP_LOG_MAX_ENTRIES = 500;
 function payloadDropLogPath(storageRoot) {
   return join(storageRoot, "logs", "payload-drops.jsonl");
 }
@@ -256,6 +256,7 @@ async function createServer(plur, options) {
             params_keys: Object.keys(request.params ?? {}),
             received_fields: validated.errorPayload.received_fields,
             missing_fields: validated.errorPayload.missing_fields,
+            missing_array_params: validated.missingArrayParams,
             request_id: request.id,
             server_version: VERSION
           });

package/dist/tools-export.d.ts

@@ -33,6 +33,12 @@ declare function validateToolArgs(tool: ToolDefinition, rawArgs: Record<string,
     data: Record<string, unknown>;
 } | {
     ok: false;
+    /**
+     * Missing field NAMES that are array-typed. Sits OUTSIDE `errorPayload` so
+     * the forensic log can separate the #297 array shape from a scalar-only miss
+     * without adding a field to the client-visible error response.
+     */
+    missingArrayParams: string[];
     errorPayload: {
         error: string;
         success: false;

package/dist/tools-export.js

@@ -2,7 +2,7 @@ import {
   CURSOR_CORE_TOOL_NAMES,
   getToolDefinitions,
   validateToolArgs
-} from "./chunk-6N2B7J6A.js";
+} from "./chunk-QEGZYXTD.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.17.1",
+  "version": "0.18.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.17.1"
+    "@plur-ai/core": "0.18.0"
   },
   "devDependencies": {
     "@types/node": "^25.5.0"