@plur-ai/mcp 0.9.2 → 0.9.4

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. **86.7% on LongMemEval** — on par with cloud memory services.
+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)
 
 ## Tools
 

package/dist/index.d.ts

@@ -1 +1,31 @@
 #!/usr/bin/env node
+/**
+ * Compare two semver strings (e.g. "1.0.0" vs "1.1.0"). Returns negative if
+ * a < b, 0 if equal, positive if a > b. Tolerates missing patch segments
+ * (treats "1.0" as "1.0.0"). Strips prerelease suffixes — "1.0.0-rc1" is
+ * compared as "1.0.0", which means a prerelease compares EQUAL to its base
+ * release. Adequate for the controlled pack ecosystem; for prerelease
+ * support add a dedicated semver lib.
+ *
+ * Non-numeric leading segments (e.g. "v1.0.0", "abc.1.0") parse as 0 — so
+ * "v1.0.0" compares as [0,0,0]. This is intentional: we'd rather accept the
+ * pack and treat it as version-zero than throw. The `extractManifestVersion`
+ * regex normally strips the leading `v`; this is a defense-in-depth fallback.
+ *
+ * Calendar versioning (e.g. "2025.04") parses correctly as numeric segments,
+ * but a calendar-versioned pack will compare as far-future against semver-
+ * versioned bundled packs and never receive upgrades. Packs ship semver.
+ */
+declare function compareSemver(a: string, b: string): number;
+/**
+ * Extract the `version` field from a pack's SKILL.md frontmatter without
+ * loading the whole pack. Returns null when SKILL.md is missing, the
+ * frontmatter has no version, or the version is nested under another key.
+ *
+ * Accepts both quoted (`version: "1.0.0"`) and unquoted (`version: 1.0.0`)
+ * forms. Rejects nested keys (`metadata:\n  version: 1.0.0`) — the regex
+ * anchors to start-of-line so a leading space breaks the match.
+ */
+declare function extractManifestVersion(skillMdPath: string): string | null;
+
+export { compareSemver, extractManifestVersion };

package/dist/index.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from "fs";
 import { join } from "path";
+import { fileURLToPath } from "url";
 import { homedir } from "os";
-var VERSION = "0.9.2";
+var VERSION = "0.9.4";
 var HELP = `plur-mcp v${VERSION} \u2014 persistent memory for AI agents
 
 Usage:
@@ -25,6 +26,33 @@ var MCP_SERVER_CONFIG = {
   command: "npx",
   args: ["-y", "@plur-ai/mcp@latest"]
 };
+function compareSemver(a, b) {
+  const stripPrerelease = (v) => v.split("-")[0].split("+")[0];
+  const stripV = (v) => v.replace(/^v/i, "");
+  const parse = (v) => stripV(stripPrerelease(v)).split(".").map((n) => {
+    const parsed = parseInt(n, 10);
+    return Number.isNaN(parsed) ? 0 : parsed;
+  });
+  const pa = parse(a);
+  const pb = parse(b);
+  for (let i = 0; i < Math.max(pa.length, pb.length, 3); i++) {
+    const ai = pa[i] ?? 0;
+    const bi = pb[i] ?? 0;
+    if (ai !== bi) return ai - bi;
+  }
+  return 0;
+}
+function extractManifestVersion(skillMdPath) {
+  try {
+    const content = readFileSync(skillMdPath, "utf8");
+    const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---/m);
+    if (!fmMatch) return null;
+    const versionMatch = fmMatch[1].match(/^version:\s*"?([^"\n]+)"?\s*$/m);
+    return versionMatch ? versionMatch[1].trim() : null;
+  } catch {
+    return null;
+  }
+}
 var CLI = "npx @plur-ai/cli";
 var PLUR_HOOKS = {
   // --- Session lifecycle ---
@@ -178,6 +206,43 @@ async function runInit() {
   results.push(`Hooks:    ${hooksStatus}`);
   const claudeMdStatus = installClaudeMd();
   results.push(`CLAUDE.md: ${claudeMdStatus}`);
+  const { Plur } = await import("@plur-ai/core");
+  const plur = new Plur({ path: paths.root });
+  const bundledPacksDir = join(fileURLToPath(import.meta.url), "..", "..", "packs");
+  let packsStatus = "no bundled packs found";
+  if (existsSync(bundledPacksDir)) {
+    const installed = plur.listPacks();
+    const installedByName = new Map(installed.map((p) => [p.name, p.manifest?.version]));
+    const entries = readdirSync(bundledPacksDir).filter((e) => statSync(join(bundledPacksDir, e)).isDirectory());
+    const newPacks = [];
+    const upgradedPacks = [];
+    for (const entry of entries) {
+      const bundledManifestPath = join(bundledPacksDir, entry, "SKILL.md");
+      const bundledVersion = existsSync(bundledManifestPath) ? extractManifestVersion(bundledManifestPath) : null;
+      const installedVersion = installedByName.get(entry);
+      if (!installedByName.has(entry)) {
+        try {
+          plur.installPack(join(bundledPacksDir, entry));
+          newPacks.push(entry);
+        } catch {
+        }
+      } else if (bundledVersion && (!installedVersion || compareSemver(bundledVersion, installedVersion) > 0)) {
+        try {
+          plur.installPack(join(bundledPacksDir, entry));
+          upgradedPacks.push(
+            `${entry} ${installedVersion ?? "unknown"}\u2192${bundledVersion}`
+          );
+        } catch {
+        }
+      }
+    }
+    const segments = [];
+    if (newPacks.length > 0) segments.push(`installed ${newPacks.join(", ")}`);
+    if (upgradedPacks.length > 0) segments.push(`upgraded ${upgradedPacks.join(", ")}`);
+    if (segments.length === 0) segments.push(`${entries.length} pack(s) already up-to-date`);
+    packsStatus = segments.join("; ");
+  }
+  results.push(`Packs:    ${packsStatus}`);
   process.stdout.write(`PLUR initialized.
 
   Architecture: PLUR is a global tool \u2014 one MCP server, one engram
@@ -212,7 +277,7 @@ if (arg === "init") {
   process.exit(0);
 }
 if (arg === "serve" || arg === void 0) {
-  const { runStdio } = await import("./server-3O37RXPQ.js");
+  const { runStdio } = await import("./server-W73LKOH7.js");
   runStdio().catch((err) => {
     console.error("Failed to start PLUR MCP server:", err);
     process.exit(1);
@@ -222,3 +287,7 @@ if (arg === "serve" || arg === void 0) {
 Run plur-mcp --help for usage.`);
   process.exit(1);
 }
+export {
+  compareSemver,
+  extractManifestVersion
+};

package/dist/{server-3O37RXPQ.js → server-W73LKOH7.js}

@@ -119,7 +119,8 @@ function getToolDefinitions() {
           commitment: { type: "string", enum: ["exploring", "leaning", "decided", "locked"], description: "Commitment level (default: leaning)" },
           locked_reason: { type: "string", description: "Reason for locking (when commitment=locked)" },
           memory_class: { type: "string", enum: ["semantic", "episodic", "procedural", "metacognitive"], description: "Memory classification (auto-set from type if omitted)" },
-          session_episode_id: { type: "string", description: "Link to current session episode for episodic anchoring" }
+          session_episode_id: { type: "string", description: "Link to current session episode for episodic anchoring" },
+          pinned: { type: "boolean", description: "Always-load flag. If true, this engram bypasses the keyword-relevance gate and is eligible for injection on every session, regardless of overlap with the user task. Use sparingly: meta-rules, safety conventions, core operating principles only." }
         },
         required: ["statement"]
       },
@@ -141,6 +142,7 @@ function getToolDefinitions() {
           locked_reason: args.locked_reason,
           memory_class: args.memory_class,
           session_episode_id: args.session_episode_id,
+          pinned: args.pinned,
           llm
         };
         try {
@@ -150,6 +152,7 @@ function getToolDefinitions() {
             statement: result.engram.statement,
             scope: result.engram.scope,
             type: result.engram.type,
+            pinned: result.engram.pinned === true,
             decision: result.decision,
             existing_id: result.existing_id,
             tensions: result.tensions
@@ -218,12 +221,13 @@ function getToolDefinitions() {
       handler: async (args, plur) => {
         const budget = args.budget;
         const effectiveLimit = budget?.max_results ?? args.limit ?? 20;
-        const results = await plur.recallHybrid(args.query, {
+        const meta = await plur.recallHybridWithMeta(args.query, {
           scope: args.scope,
           domain: args.domain,
           limit: effectiveLimit,
           min_strength: args.min_strength
         });
+        const results = meta.engrams;
         let truncated = false;
         let boundedResults = results;
         if (budget?.max_results && results.length > budget.max_results) {
@@ -245,7 +249,7 @@ function getToolDefinitions() {
           boundedResults = withinBudget;
         }
         const includeEpisodes = args.include_episodes === true;
-        return {
+        const response = {
           results: boundedResults.map((e) => {
             const raw = e;
             const base = {
@@ -264,8 +268,12 @@ function getToolDefinitions() {
           }),
           count: boundedResults.length,
           truncated,
-          mode: "hybrid"
+          mode: meta.mode
         };
+        if (meta.mode === "hybrid-degraded") {
+          response.warning = `Embedding layer unavailable \u2014 results are BM25-only. Run plur_doctor for diagnosis. Last error: ${meta.embedderError ?? "unknown"}`;
+        }
+        return response;
       }
     },
     {
@@ -376,6 +384,37 @@ function getToolDefinitions() {
         }
       }
     },
+    {
+      name: "plur_pin",
+      description: "Toggle the always-load (pinned) flag on an engram. Pinned engrams bypass the keyword-relevance gate at injection time and are eligible for loading on every session, regardless of overlap with the user task. Use sparingly \u2014 meta-rules, safety conventions, core operating principles. Pass {id, pinned:true} to pin or {id, pinned:false} to unpin. List current pinned with {list:true}.",
+      annotations: { title: "Pin", destructiveHint: false, idempotentHint: true },
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Engram ID to pin or unpin" },
+          pinned: { type: "boolean", description: "Target value (default true)" },
+          list: { type: "boolean", description: "If true, just return the current set of pinned engrams (no mutation)" }
+        }
+      },
+      handler: async (args, plur) => {
+        if (args.list === true) {
+          const pinned = plur.listPinned();
+          return {
+            count: pinned.length,
+            pinned: pinned.map((e) => ({ id: e.id, statement: e.statement, scope: e.scope, domain: e.domain }))
+          };
+        }
+        if (!args.id) throw new Error("Provide id (or list:true to list pinned)");
+        const target = args.pinned ?? true;
+        const updated = plur.setPinned(args.id, target);
+        if (!updated) throw new Error(`Engram not found: ${args.id}`);
+        return {
+          id: updated.id,
+          statement: updated.statement,
+          pinned: updated.pinned === true
+        };
+      }
+    },
     {
       name: "plur_forget",
       description: "Retire an engram by ID or search term \u2014 marks it as no longer active without deleting history",
@@ -810,6 +849,82 @@ function getToolDefinitions() {
         };
       }
     },
+    {
+      name: "plur_doctor",
+      description: "Diagnose the PLUR install. Reports whether the embedding model loaded, whether hybrid search is fully operational, and what to do if it is degraded. Run this first when recall feels off.",
+      annotations: { title: "Doctor", readOnlyHint: false, idempotentHint: false },
+      inputSchema: {
+        type: "object",
+        properties: {
+          retry: { type: "boolean", description: "If true, reset cached embedder failure state and retry the model load before reporting" }
+        }
+      },
+      handler: async (args, plur) => {
+        if (args.retry === true) {
+          plur.resetEmbedder();
+        }
+        const status = plur.status();
+        const before = plur.embedderStatus();
+        if (!before.disabled) {
+          try {
+            await plur.recallSemantic("plur doctor probe", { limit: 1 });
+          } catch {
+          }
+        }
+        const after = plur.embedderStatus();
+        const checks = [];
+        checks.push({
+          check: "engram store",
+          ok: status.engram_count > 0,
+          detail: `${status.engram_count} engrams across ${status.pack_count} packs at ${status.storage_root}`
+        });
+        if (after.disabled) {
+          checks.push({
+            check: "embedder available",
+            ok: true,
+            detail: `Disabled on purpose \u2014 ${after.disabledReason ?? "embeddings disabled"}`
+          });
+          checks.push({
+            check: "hybrid search operational",
+            ok: true,
+            detail: "Running in BM25-only mode (embeddings opted out)"
+          });
+        } else {
+          checks.push({
+            check: "embedder available",
+            ok: after.available && after.loaded,
+            detail: after.loaded ? "BGE-small-en-v1.5 loaded" : after.lastError ? `Failed to load: ${after.lastError}` : "Not yet loaded \u2014 first call may have raced; try again or use retry:true"
+          });
+          const hybridOk = after.available && after.loaded;
+          checks.push({
+            check: "hybrid search operational",
+            ok: hybridOk,
+            detail: hybridOk ? "Hybrid search will use BM25 + embeddings (fully functional)" : "Hybrid search will silently degrade to BM25-only \u2014 semantic recall disabled"
+          });
+        }
+        const remediation = [];
+        if (!after.disabled && !(after.available && after.loaded)) {
+          remediation.push(
+            "Embedding model is not loaded. Common causes:",
+            "  \u2022 First-run download not yet completed (try: plur_doctor with retry:true)",
+            "  \u2022 Network blocked HuggingFace Hub fetch \u2014 check connectivity to huggingface.co",
+            "  \u2022 pnpm hoisting issue: @huggingface/transformers must resolve onnxruntime-node from the package root, not a workspace package",
+            "  \u2022 Corrupt model cache: a half-completed download leaves a broken cache that fails every subsequent load. Delete `~/.cache/huggingface/hub/models--Xenova--bge-small-en-v1.5/` and retry \u2014 the model will redownload on next call.",
+            "  \u2022 Manual fix: from the @plur-ai/core package directory, run a script that imports @huggingface/transformers and calls pipeline() to trigger the download",
+            "  \u2022 Or opt out: set PLUR_DISABLE_EMBEDDINGS=1, or write `embeddings: { enabled: false }` to ~/.plur/config.yaml \u2014 hybrid search will run BM25-only"
+          );
+        }
+        return {
+          ok: checks.every((c) => c.ok),
+          checks,
+          embedder: {
+            before_probe: before,
+            after_probe: after
+          },
+          remediation: remediation.length > 0 ? remediation : ["All checks passed \u2014 PLUR is healthy."]
+        };
+      }
+    },
     {
       name: "plur_session_start",
       description: "Start a session \u2014 inject relevant engrams for your task. Call at the beginning of every session.",
@@ -1290,7 +1405,7 @@ Include at least one engram_suggestion if ANYTHING was learned. An empty suggest
 
 // src/server.ts
 import { z } from "zod";
-var VERSION = "0.9.2";
+var VERSION = "0.9.4";
 var INSTRUCTIONS = `PLUR is your persistent memory. Corrections, preferences, and conventions persist across sessions as engrams.
 
 PLUR is a GLOBAL tool \u2014 one MCP server, one engram store (~/.plur/), available in every project. Multi-project scoping uses domain/scope fields on engrams, not separate installations.

package/package.json

@@ -1,18 +1,19 @@
 {
   "name": "@plur-ai/mcp",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "type": "module",
   "bin": {
     "plur-mcp": "dist/index.js"
   },
   "main": "dist/index.js",
   "files": [
-    "dist"
+    "dist",
+    "packs"
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
     "zod": "^3.23.0",
-    "@plur-ai/core": "0.9.2"
+    "@plur-ai/core": "0.9.4"
   },
   "devDependencies": {
     "@types/node": "^25.5.0"

package/packs/effective-memory/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: Effective Memory
+description: The essential habits for an AI agent with memory — session bookends, learning triggers, verification, safety, and the operational discipline that turns raw recall into compounding intelligence. Pinned, always-injected.
+version: "1.1.0"
+creator: plur-ai
+license: MIT
+tags: [memory, learning, best-practices, session-management, feedback, safety, verification, discipline, time]
+x-datacore:
+  id: effective-memory
+  injection_policy: on_match
+  match_terms: [memory, learn, remember, session, feedback, engram, forget, correction, preference, recall, verification, safety, plur]
+  domain: plur.best-practices
+  engram_count: 12
+  # Note: every engram in this pack carries `pinned: true` at the engram
+  # level, which is the actual "always-inject" mechanism (introduced in
+  # PLUR 0.9.4). Pack-level injection_policy: pinned is not a recognized
+  # value in 0.9.4 — keep it on_match here so loaders that respect it
+  # behave predictably; the per-engram pinned flags do the work.
+---
+
+# Effective Memory
+
+Your agent has memory. These habits make it actually useful.
+
+Without them, memory is a growing pile of assertions nobody retrieves. With them, memory compounds — each session builds on the last, corrections stick, and the agent gets measurably better over time.
+
+This pack is **pinned** in PLUR 0.9.4+. Engrams here bypass keyword gating and are always eligible for injection at session start. They cover the meta-rules every agent needs regardless of domain: how to capture corrections, when to recall before answering, what "verified" means, how to stay safe with destructive actions, and why never to type a weekday from memory.
+
+## Install
+
+```bash
+npx @plur-ai/cli@0.9.4 packs install effective-memory
+```
+
+(In 0.9.4+, `plur init` auto-installs this pack — manual install is rarely needed.)
+
+## What's inside
+
+12 engrams covering:
+
+- **Capture** — call `plur_learn` immediately on corrections; detect correction-shaped phrases.
+- **Recall** — `plur_recall_hybrid` before factual answers; don't confabulate.
+- **Session lifecycle** — bookend with `plur_session_start` / `plur_session_end`; `plur_feedback` on injected engrams; `plur_timeline` for long-horizon agents.
+- **Verification** — artifact-first; never bulk-mark as done from narrative text.
+- **Safety** — irreversible actions need actual user confirmation and one-item dry-runs.
+- **Discipline** — read before edit; don't ask "want to continue?" mid-task.
+- **Time** — never type a day-of-week from memory.
+
+## Why pinned
+
+Pinned engrams (introduced in PLUR 0.9.4) bypass the keyword-relevance gate in `scoreEngram` and per-pack/per-domain caps in `fillTokenBudget`. They are always eligible for injection regardless of how the user's query keywords overlap with the engram statement. Use this for cross-cutting meta-rules only; pinning everything defeats the purpose.
+
+## Versioning
+
+| Version | Changes |
+|---|---|
+| 1.1.0 | Consolidated `plur-required` meta-rules into this pack. All engrams now `pinned: true`. Added verification, safety, discipline, and time-handling rules. Engram count 8 → 12. |
+| 1.0.0 | Initial pack — 8 engrams covering session bookends, learning triggers, and feedback loops. |

package/packs/effective-memory/engrams.yaml

@@ -0,0 +1,332 @@
+engrams:
+  # === Session lifecycle ===
+
+  - id: ENG-PACK-EM-001
+    version: 2
+    status: active
+    type: procedural
+    scope: global
+    visibility: public
+    pinned: true
+    statement: >-
+      Every session must bookend with plur_session_start (beginning) and
+      plur_session_end (end). Session start injects relevant engrams into
+      context. Session end captures what was learned, what failed, and what
+      to continue. Without bookends, the agent starts every conversation
+      from zero.
+    rationale: >-
+      Session boundaries are the minimum viable memory habit. Everything
+      else builds on them.
+    domain: plur.session
+    tags: [session, lifecycle, start, end]
+    activation: { retrieval_strength: 0.95, storage_strength: 0.95, frequency: 0, last_accessed: "2026-05-04" }
+    dual_coding:
+      example: "User says 'fix the auth bug'. Agent calls plur_session_start('fixing auth bug') — gets injected with 'OAuth tokens expire after 1h, not 24h' from last week's session. Fixes it in 5 minutes instead of rediscovering the issue."
+      analogy: "Like reading your notes before a meeting vs walking in cold every time."
+    pack: effective-memory
+    polarity: do
+    commitment: locked
+
+  # === Capture: corrections and learn-triggers ===
+
+  - id: ENG-PACK-EM-002
+    version: 2
+    status: active
+    type: behavioral
+    scope: global
+    visibility: public
+    pinned: true
+    statement: >-
+      When the user corrects you, call plur_learn IMMEDIATELY — before
+      continuing the task. Acknowledging the correction in prose is not
+      enough; that lesson disappears with context-window compression. Don't
+      batch corrections, don't wait until end of session — capture them the
+      instant they happen.
+    rationale: >-
+      Corrections are the highest-value engrams because they prevent
+      repeated mistakes. Without immediate plur_learn the same correction
+      will need to be given again next session — and self-observation of
+      the correction moment is the primary input gap of memory systems.
+    domain: plur.learning
+    tags: [correction, learn, immediate, capture, plur_learn]
+    activation: { retrieval_strength: 0.95, storage_strength: 0.95, frequency: 0, last_accessed: "2026-05-04" }
+    dual_coding:
+      example: "User: 'No, use snake_case not camelCase in this repo.' Agent immediately calls plur_learn('This repo uses snake_case, not camelCase') before proceeding with the fix."
+    pack: effective-memory
+    polarity: do
+    commitment: locked
+
+  - id: ENG-PACK-EM-003
+    version: 2
+    status: active
+    type: behavioral
+    scope: global
+    visibility: public
+    pinned: true
+    statement: >-
+      Treat correction-shaped phrases as engram triggers. When the user
+      uses "actually", "no, what I meant", "wait", "I want X not Y", "from
+      now on", "the right way is", "you misunderstood", or similar, pause
+      and ask whether the rule belongs in plur_learn before continuing.
+    rationale: >-
+      Many corrections are subtle — they don't say "remember this" but
+      they establish a durable rule. The phrase pattern is a reliable
+      signal that a learnable rule has just been stated.
+    domain: plur.learning
+    tags: [correction-detection, plur_learn, signal, meta]
+    activation: { retrieval_strength: 0.9, storage_strength: 0.9, frequency: 0, last_accessed: "2026-05-04" }
+    pack: effective-memory
+    polarity: do
+    commitment: decided
+
+  # === Recall: don't confabulate ===
+
+  - id: ENG-PACK-EM-004
+    version: 2
+    status: active
+    type: procedural
+    scope: global
+    visibility: public
+    pinned: true
+    statement: >-
+      Before answering factual questions about the user's project, codebase,
+      preferences, infrastructure, or past decisions, call plur_recall_hybrid
+      first. The answer may already be in memory. Do not fabricate or compose
+      answers from prior-conversation context — that context is often stale
+      or invented.
+    rationale: >-
+      Confabulation is the failure mode when memory exists but isn't
+      queried. Recall before reasoning. The most common memory failure
+      is not forgetting — it's not checking.
+    domain: plur.recall
+    tags: [recall, search, before-answering, plur_recall_hybrid, confabulation]
+    activation: { retrieval_strength: 0.95, storage_strength: 0.95, frequency: 0, last_accessed: "2026-05-04" }
+    dual_coding:
+      example: "User asks 'how do we deploy to production?' — call plur_recall_hybrid('deployment production') before answering. You might find 'deploy requires git push to nightshift server, not GitHub' from a previous session."
+      analogy: "Like checking your notes before answering a question in a meeting, instead of guessing."
+    pack: effective-memory
+    polarity: do
+    commitment: locked
+
+  # === Feedback loop ===
+
+  - id: ENG-PACK-EM-005
+    version: 2
+    status: active
+    type: behavioral
+    scope: global
+    visibility: public
+    pinned: true
+    statement: >-
+      Call plur_feedback on injected engrams — positive when helpful,
+      negative when wrong or stale. Feedback trains the injection
+      algorithm. Without it, irrelevant engrams keep appearing and
+      relevant ones get buried. This is how memory gets smarter, not
+      just bigger.
+    rationale: >-
+      Feedback is the training signal for retrieval quality. Memory
+      without feedback is a search engine that never improves its
+      ranking.
+    domain: plur.feedback
+    tags: [feedback, relevance, training, plur_feedback]
+    activation: { retrieval_strength: 0.9, storage_strength: 0.9, frequency: 0, last_accessed: "2026-05-04" }
+    dual_coding:
+      example: "Session starts, 8 engrams injected. 2 were directly useful for the task — call plur_feedback positive. 1 was about a project you finished last month — call plur_feedback negative. The rest fine but unremarkable — skip or neutral."
+    pack: effective-memory
+    polarity: do
+    commitment: locked
+
+  # === Engram quality ===
+
+  - id: ENG-PACK-EM-006
+    version: 2
+    status: active
+    type: behavioral
+    scope: global
+    visibility: public
+    pinned: true
+    statement: >-
+      Learn preferences and durable rules — not trivial facts,
+      session-specific state, or things derivable from the codebase. Good
+      engrams: "this API returns snake_case despite the docs saying
+      camelCase", "user prefers DCA over single entries", "deploy requires
+      VPN connection first". Bad engrams: "the user said hello", "we are
+      working on file X", "function foo is on line 42".
+    rationale: >-
+      Memory quality matters more than quantity. Noisy engrams dilute
+      injection relevance and waste context window. Preferences are the
+      difference between a tool and an assistant that knows you;
+      derivable facts are noise.
+    domain: plur.learning
+    tags: [quality, preference, anti-pattern, noise, personalization]
+    activation: { retrieval_strength: 0.9, storage_strength: 0.9, frequency: 0, last_accessed: "2026-05-04" }
+    dual_coding:
+      example: "User: 'I like terse responses, skip the summaries.' → high-value engram (preference). User: 'okay, sounds good' → no engram (no rule, just acknowledgement)."
+    pack: effective-memory
+    polarity: do
+    commitment: locked
+
+  # === Long-horizon agents ===
+
+  - id: ENG-PACK-EM-007
+    version: 2
+    status: active
+    type: architectural
+    scope: global
+    visibility: public
+    pinned: true
+    statement: >-
+      Long-horizon agents — agents that run repeatedly on the same domain
+      across days or weeks — MUST call plur_timeline at startup to read
+      past episodes. Without timeline context, the agent rediscovers the
+      same blockers, repeats failed approaches, and loses coherence across
+      runs. This is "coherence failure" — distinct from intelligence
+      failure and the dominant failure mode for long-running agents.
+    rationale: >-
+      A doctor with amnesia is competent each visit but never builds on
+      the previous one. Timeline is the patient chart.
+    domain: plur.agents
+    tags: [timeline, long-horizon, coherence, episodic, plur_timeline]
+    activation: { retrieval_strength: 0.9, storage_strength: 0.9, frequency: 0, last_accessed: "2026-05-04" }
+    dual_coding:
+      example: "Project manager agent runs Monday, escalates blocker to teammate, no response. Without timeline: Tuesday it escalates again. With timeline: Tuesday it sees Monday's episode, knows escalation failed, tries different approach."
+      analogy: "Like having a doctor with anterograde amnesia treating the same patient daily — competent each visit but never builds on the previous one."
+    pack: effective-memory
+    polarity: do
+    commitment: locked
+
+  # === Trust observation over stale memory ===
+
+  - id: ENG-PACK-EM-008
+    version: 2
+    status: active
+    type: behavioral
+    scope: global
+    visibility: public
+    pinned: true
+    statement: >-
+      When memory and current reality conflict, trust what you observe
+      now — then update the stale engram. Call plur_learn with the
+      correction and plur_feedback negative on the old engram. Memory
+      is a starting point for reasoning, not a substitute for verification.
+    rationale: >-
+      Stale memory acted on without verification causes worse outcomes
+      than no memory at all.
+    domain: plur.maintenance
+    tags: [staleness, verification, update, conflict]
+    activation: { retrieval_strength: 0.9, storage_strength: 0.9, frequency: 0, last_accessed: "2026-05-04" }
+    dual_coding:
+      example: "Memory says 'deploy to server at 10.0.0.5'. You SSH and it times out. Don't keep trying — the IP changed. Verify, update the engram, then proceed."
+    pack: effective-memory
+    polarity: do
+    commitment: locked
+
+  # === Verification: what "done" means ===
+
+  - id: ENG-PACK-EM-009
+    version: 1
+    status: active
+    type: behavioral
+    scope: global
+    visibility: public
+    pinned: true
+    statement: >-
+      For coding/work tasks, "verify if done" means checking the actual
+      artifact (code, file, deployment, commit, infrastructure), not
+      keyword-matching against narrative text (journals, notes,
+      briefings). Per-item verification against the deliverable. Never
+      bulk-action without per-item artifact-level evidence.
+    rationale: >-
+      Narrative text mentions topics in passing. Bulk action that depends
+      on keyword matches has been observed to mark genuinely-incomplete
+      work as done, hiding state from the user.
+    domain: agent.verification
+    tags: [verification, artifact-first, no-bulk-action]
+    activation: { retrieval_strength: 0.95, storage_strength: 1, frequency: 0, last_accessed: "2026-05-04" }
+    pack: effective-memory
+    polarity: do
+    commitment: locked
+
+  # === Safety: irreversibility & consent ===
+
+  - id: ENG-PACK-EM-010
+    version: 1
+    status: active
+    type: behavioral
+    scope: global
+    visibility: public
+    pinned: true
+    statement: >-
+      "User confirms" steps in plans, sensitive-file actions, and
+      destructive operations require an actual user message in the
+      conversation. Self-authorization, prior-session approval, configured
+      allowlists, or inferred consent do NOT satisfy. Before any
+      irreversible action (delete, force-push, drop table, chmod near
+      $HOME, mass-rename, mass-cancel) run a one-item dry-run first and
+      surface the result for the user.
+    rationale: >-
+      Auto-confirming "user confirms" steps defeats the purpose of having
+      them — they exist precisely for moments where automation should
+      pause. One-item-first turns a potentially catastrophic mistake into
+      a single easy revert.
+    domain: agent.safety
+    tags: [confirmation, consent, safety, sensitive, irreversible, dry-run, bulk]
+    activation: { retrieval_strength: 0.95, storage_strength: 1, frequency: 0, last_accessed: "2026-05-04" }
+    pack: effective-memory
+    polarity: do
+    commitment: locked
+
+  # === Discipline: read first, ask less ===
+
+  - id: ENG-PACK-EM-011
+    version: 1
+    status: active
+    type: behavioral
+    scope: global
+    visibility: public
+    pinned: true
+    statement: >-
+      Read the target file before editing it; don't edit based on imagined
+      content or remembered structure. Read → diff → write. Separately,
+      don't ask the user "want to continue?", "should I proceed?", or
+      "shall I keep going?" mid-task. Keep working until blocked, the task
+      is done, or you hit a genuine decision-point (destructive action,
+      new direction, sensitive choice). The user already said yes by
+      giving the task.
+    rationale: >-
+      Memory of file content drifts during a session — edits to imagined
+      content corrupt the file or introduce silent regressions.
+      "Want to continue?" prompts add friction without information; they
+      train the user to ignore agent prompts, which then bleeds into
+      ignoring the asks that DO matter.
+    domain: agent.discipline
+    tags: [read-before-edit, discipline, flow, prompts, agent-behavior]
+    activation: { retrieval_strength: 0.9, storage_strength: 1, frequency: 0, last_accessed: "2026-05-04" }
+    pack: effective-memory
+    polarity: do
+    commitment: locked
+
+  # === Time: don't hallucinate dates ===
+
+  - id: ENG-PACK-EM-012
+    version: 1
+    status: active
+    type: behavioral
+    scope: global
+    visibility: public
+    pinned: true
+    statement: >-
+      Never type a day-of-week from memory. LLMs systematically
+      hallucinate weekdays for dates outside their training cutoff or for
+      any specific date. Always verify via a date utility (system clock,
+      datacore.date, `date`, or `python -c "from datetime import date;
+      ..."`) before writing a date+weekday into any file or message.
+    rationale: >-
+      Wrong weekdays in calendar entries, journal headers, and scheduled
+      tasks cause real misalignment. The check costs ~50ms.
+    domain: agent.time
+    tags: [dates, weekday, time, hallucination]
+    activation: { retrieval_strength: 0.9, storage_strength: 1, frequency: 0, last_accessed: "2026-05-04" }
+    pack: effective-memory
+    polarity: do
+    commitment: locked