@plur-ai/core 0.5.2 → 0.7.0

package/dist/index.d.ts

@@ -545,13 +545,60 @@ declare const PackManifestSchema: z.ZodObject<{
 }>;
 type PackManifest = z.infer<typeof PackManifestSchema>;
 
+interface InstallResult {
+    installed: number;
+    name: string;
+    conflicts: ConflictItem[];
+}
+interface ConflictItem {
+    pack_engram_id: string;
+    pack_statement: string;
+    existing_engram_id: string;
+    existing_statement: string;
+    type: 'contradiction' | 'duplicate';
+}
+declare function installPack(packsDir: string, source: string, existingEngrams?: Engram[]): InstallResult;
+interface UninstallResult {
+    name: string;
+    removed: boolean;
+    engram_count: number;
+}
+declare function uninstallPack(packsDir: string, name: string): UninstallResult;
 interface PackInfo {
     name: string;
     path: string;
     engram_count: number;
     manifest?: PackManifest;
+    integrity?: string;
 }
 declare function listPacks(packsDir: string): PackInfo[];
+interface ExportOptions {
+    name: string;
+    version: string;
+    description?: string;
+    creator?: string;
+    domain?: string;
+    scope?: string;
+    tags?: string[];
+    type?: string;
+}
+interface PrivacyScanResult {
+    clean: boolean;
+    issues: PrivacyIssue[];
+}
+interface PrivacyIssue {
+    engram_id: string;
+    type: 'secret' | 'private_visibility' | 'personal_path' | 'email' | 'ip_address';
+    detail: string;
+}
+interface ExportResult {
+    path: string;
+    engram_count: number;
+    privacy: PrivacyScanResult;
+    match_terms: string[];
+    integrity: string;
+}
+declare function exportPack(engrams: Engram[], outputDir: string, manifest: ExportOptions): ExportResult;
 
 interface SyncStatus {
     initialized: boolean;
@@ -804,14 +851,14 @@ declare const StructuralTemplateSchema: z.ZodObject<{
     goal_type: string;
     constraint_type: string;
     outcome_type: string;
-    structure_type: "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "recursive" | "tradeoff" | "freeform";
+    structure_type: "recursive" | "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "tradeoff" | "freeform";
     freeform_structure?: string | undefined;
 }, {
     template: string;
     goal_type: string;
     constraint_type: string;
     outcome_type: string;
-    structure_type?: "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "recursive" | "tradeoff" | "freeform" | undefined;
+    structure_type?: "recursive" | "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "tradeoff" | "freeform" | undefined;
     freeform_structure?: string | undefined;
 }>;
 declare const EvidenceEntrySchema: z.ZodObject<{
@@ -904,14 +951,14 @@ declare const MetaFieldSchema: z.ZodObject<{
         goal_type: string;
         constraint_type: string;
         outcome_type: string;
-        structure_type: "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "recursive" | "tradeoff" | "freeform";
+        structure_type: "recursive" | "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "tradeoff" | "freeform";
         freeform_structure?: string | undefined;
     }, {
         template: string;
         goal_type: string;
         constraint_type: string;
         outcome_type: string;
-        structure_type?: "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "recursive" | "tradeoff" | "freeform" | undefined;
+        structure_type?: "recursive" | "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "tradeoff" | "freeform" | undefined;
         freeform_structure?: string | undefined;
     }>;
     evidence: z.ZodArray<z.ZodObject<{
@@ -1003,7 +1050,7 @@ declare const MetaFieldSchema: z.ZodObject<{
         goal_type: string;
         constraint_type: string;
         outcome_type: string;
-        structure_type: "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "recursive" | "tradeoff" | "freeform";
+        structure_type: "recursive" | "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "tradeoff" | "freeform";
         freeform_structure?: string | undefined;
     };
     evidence: {
@@ -1042,7 +1089,7 @@ declare const MetaFieldSchema: z.ZodObject<{
         goal_type: string;
         constraint_type: string;
         outcome_type: string;
-        structure_type?: "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "recursive" | "tradeoff" | "freeform" | undefined;
+        structure_type?: "recursive" | "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "tradeoff" | "freeform" | undefined;
         freeform_structure?: string | undefined;
     };
     evidence: {
@@ -1234,8 +1281,9 @@ declare function detectPlurStorage(explicitPath?: string): PlurPaths;
 declare class IndexedStorage {
     private dbPath;
     private engramsPath;
+    private stores;
     private db;
-    constructor(engramsPath: string, dbPath: string);
+    constructor(engramsPath: string, dbPath: string, stores?: StoreEntry[]);
     private getDb;
     /** Load all engrams from SQLite index. Auto-rebuilds if db missing. */
     loadAll(): Engram[];
@@ -1249,7 +1297,7 @@ declare class IndexedStorage {
     count(filter?: {
         status?: string;
     }): number;
-    /** Sync SQLite index from YAML source of truth. */
+    /** Sync SQLite index from YAML source of truth (primary + all stores). */
     syncFromYaml(): void;
     /** Drop and rebuild the entire index from YAML. */
     reindex(): void;
@@ -1303,9 +1351,20 @@ declare class Plur {
     private paths;
     private config;
     private indexedStorage;
+    private _engramCache;
     constructor(options?: {
         path?: string;
     });
+    /**
+     * Load engrams from primary store + all configured stores, with mtime-based caching.
+     * Store engram IDs get namespaced: ENG-2026-0401-001 → ENG-DF-2026-0401-001.
+     * Primary engrams are returned unchanged.
+     */
+    private _loadAllEngrams;
+    /** Load engrams from a path with mtime-based caching */
+    private _loadCached;
+    /** Find which store owns an engram by ID. For namespaced IDs, strips prefix to find in store. */
+    private _findEngramStore;
     /** Create engram, detect conflicts, save. Returns the created engram. */
     learn(statement: string, context?: LearnContext): Engram;
     /**
@@ -1328,7 +1387,7 @@ declare class Plur {
     recallExpanded(query: string, options: RecallOptions & {
         llm: LlmFunction;
     }): Promise<Engram[]>;
-    /** Get a single engram by ID, regardless of status. Returns null if not found. */
+    /** Get a single engram by ID, regardless of status. Searches primary + all stores. */
     getById(id: string): Engram | null;
     /** List all active engrams, optionally filtered by scope/domain. No search — returns all matches. */
     list(options?: {
@@ -1345,7 +1404,7 @@ declare class Plur {
     /** Scored injection with embedding boost when available. Falls back to BM25 if embeddings not installed. */
     injectHybrid(task: string, options?: InjectOptions): Promise<InjectionResult>;
     private _formatInjection;
-    /** Update feedback_signals and adjust retrieval_strength. Searches packs if not found in personal engrams. */
+    /** Update feedback_signals and adjust retrieval_strength. Searches primary, stores, then packs. */
     feedback(id: string, signal: 'positive' | 'negative' | 'neutral'): void;
     /** Save extracted meta-engrams to the engram store. Skips IDs that already exist. */
     saveMetaEngrams(metas: Engram[]): {
@@ -1354,7 +1413,7 @@ declare class Plur {
     };
     /** Update an existing engram in the store by ID. Returns true if found and updated. */
     updateEngram(updated: Engram): boolean;
-    /** Set engram status to 'retired'. */
+    /** Set engram status to 'retired'. Supports primary and store engrams. */
     forget(id: string, reason?: string): void;
     /** Remove retired engrams from storage. Returns count of removed and remaining. */
     compact(): {
@@ -1373,22 +1432,18 @@ declare class Plur {
     timeline(query?: TimelineQuery): Episode[];
     /** Rule-based extraction of engram candidates from content. */
     ingest(content: string, options?: IngestOptions): IngestCandidate[];
-    /** Install a pack from a source path. */
-    installPack(source: string): {
-        installed: number;
-        name: string;
-    };
-    /** Export engrams as a shareable pack. */
+    /** Install a pack from a source path. Detects conflicts with existing engrams. */
+    installPack(source: string): ReturnType<typeof installPack>;
+    /** Uninstall a pack by name. */
+    uninstallPack(name: string): ReturnType<typeof uninstallPack>;
+    /** Export engrams as a shareable pack with privacy scanning and integrity hash. */
     exportPack(engrams: Engram[], outputDir: string, manifest: {
         name: string;
         version: string;
         description?: string;
         creator?: string;
-    }): {
-        path: string;
-        engram_count: number;
-    };
-    /** List all installed packs. */
+    }): ReturnType<typeof exportPack>;
+    /** List all installed packs (with integrity hashes). */
     listPacks(): ReturnType<typeof listPacks>;
     /** Sync engrams to git. Initializes repo on first call, commits + push/pull on subsequent calls. */
     sync(remote?: string): SyncResult;

package/dist/index.js

@@ -295,6 +295,16 @@ function loadAllPacks(packsDir) {
   }
   return packs;
 }
+function storePrefix(scope) {
+  const parts = scope.split(/[:\-_./]/).filter(Boolean);
+  if (parts.length >= 2) {
+    const p2 = parts[1];
+    return (parts[0][0] + p2[0] + (p2[1] || p2[0])).toUpperCase();
+  }
+  const w = parts[0] || scope;
+  if (w.length >= 3) return (w[0] + w[Math.floor(w.length / 2)] + w[w.length - 1]).toUpperCase();
+  return (w[0] + (w[1] || w[0]) + (w[2] || w[0])).toUpperCase();
+}
 function generateEngramId(existing) {
   const now = /* @__PURE__ */ new Date();
   const date = now.toISOString().slice(0, 10).replace(/-/g, "");
@@ -322,10 +332,12 @@ function getDatabase() {
 var IndexedStorage = class {
   dbPath;
   engramsPath;
+  stores;
   db = null;
-  constructor(engramsPath, dbPath) {
+  constructor(engramsPath, dbPath, stores) {
     this.engramsPath = engramsPath;
     this.dbPath = dbPath;
+    this.stores = stores ?? [];
   }
   getDb() {
     if (!this.db) {
@@ -345,6 +357,11 @@ var IndexedStorage = class {
         CREATE INDEX IF NOT EXISTS idx_scope ON engrams(scope);
         CREATE INDEX IF NOT EXISTS idx_domain ON engrams(domain);
       `);
+      try {
+        this.db.exec("ALTER TABLE engrams ADD COLUMN source TEXT NOT NULL DEFAULT 'primary'");
+      } catch {
+      }
+      this.db.exec("CREATE INDEX IF NOT EXISTS idx_source ON engrams(source)");
     }
     return this.db;
   }
@@ -392,25 +409,41 @@ var IndexedStorage = class {
     }
     return db.prepare("SELECT COUNT(*) as c FROM engrams").get().c;
   }
-  /** Sync SQLite index from YAML source of truth. */
+  /** Sync SQLite index from YAML source of truth (primary + all stores). */
   syncFromYaml() {
-    const engrams = loadEngrams(this.engramsPath);
     const db = this.getDb();
     const upsert = db.prepare(`
-      INSERT OR REPLACE INTO engrams (id, status, scope, domain, last_accessed, data)
-      VALUES (?, ?, ?, ?, ?, ?)
+      INSERT OR REPLACE INTO engrams (id, status, scope, domain, last_accessed, data, source)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
     `);
-    const deleteStmt = db.prepare("DELETE FROM engrams WHERE id = ?");
-    const yamlIds = new Set(engrams.map((e) => e.id));
-    const dbIds = new Set(
-      db.prepare("SELECT id FROM engrams").all().map((r) => r.id)
-    );
+    const allSyncedIds = /* @__PURE__ */ new Set();
+    const validSources = /* @__PURE__ */ new Set(["primary"]);
     const tx = db.transaction(() => {
-      for (const e of engrams) {
-        upsert.run(e.id, e.status, e.scope, e.domain ?? null, e.activation.last_accessed, JSON.stringify(e));
+      const primaryEngrams = loadEngrams(this.engramsPath);
+      for (const e of primaryEngrams) {
+        upsert.run(e.id, e.status, e.scope, e.domain ?? null, e.activation.last_accessed, JSON.stringify(e), "primary");
+        allSyncedIds.add(e.id);
+      }
+      for (const store of this.stores) {
+        validSources.add(store.path);
+        const storeEngrams = loadEngrams(store.path);
+        const prefix = storePrefix(store.scope);
+        for (const e of storeEngrams) {
+          if (e.scope !== "global" && e.scope !== store.scope && !e.scope.startsWith(store.scope)) {
+            continue;
+          }
+          const nsId = e.id.replace(/^(ENG|ABS|META)-/, `$1-${prefix}-`);
+          const scope = e.scope === "global" ? store.scope : e.scope;
+          upsert.run(nsId, e.status, scope, e.domain ?? null, e.activation.last_accessed, JSON.stringify({ ...e, id: nsId, scope }), store.path);
+          allSyncedIds.add(nsId);
+        }
       }
-      for (const id of dbIds) {
-        if (!yamlIds.has(id)) deleteStmt.run(id);
+      const dbRows = db.prepare("SELECT id, source FROM engrams").all();
+      const deleteStmt = db.prepare("DELETE FROM engrams WHERE id = ?");
+      for (const row of dbRows) {
+        if (!allSyncedIds.has(row.id)) {
+          deleteStmt.run(row.id);
+        }
       }
     });
     tx();
@@ -456,7 +489,7 @@ var PlurConfigSchema = z3.object({
     co_access: z3.boolean().default(true)
   }).default({}),
   allow_secrets: z3.boolean().default(false),
-  index: z3.boolean().default(false),
+  index: z3.boolean().default(true),
   stores: z3.array(StoreEntrySchema).default([])
 }).partial();
 
@@ -1029,25 +1062,110 @@ async function expandedSearch(engrams, query, limit, llm, storagePath) {
 // src/packs.ts
 import * as fs2 from "fs";
 import * as path from "path";
+import * as crypto from "crypto";
 import yaml4 from "js-yaml";
-function installPack(packsDir, source) {
+
+// src/secrets.ts
+var SECRET_PATTERNS = [
+  { name: "aws_access_key", regex: /AKIA[0-9A-Z]{16}/ },
+  { name: "aws_secret_key", regex: /(?:aws_secret_access_key|secret_access_key)\s*[=:]\s*[A-Za-z0-9/+=]{40}/i },
+  { name: "generic_api_key", regex: /(?:^|[^a-z])(sk|pk)[-_][a-z0-9]{20,}/i },
+  { name: "api_key_assignment", regex: /(?:api[_-]?key|api[_-]?secret|secret[_-]?key)\s*[=:]\s*\S{20,}/i },
+  { name: "password_assignment", regex: /password\s*[=:]\s*\S{8,}/i },
+  { name: "connection_string", regex: /(?:postgres|mysql|mongodb|redis):\/\/\S+/ },
+  { name: "jwt", regex: /eyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}/ },
+  { name: "private_key", regex: /-----BEGIN\s+\S+\s+PRIVATE KEY-----/ },
+  { name: "bearer_token", regex: /Bearer\s+[A-Za-z0-9._~+/=-]{20,}/ }
+];
+function detectSecrets(text) {
+  const matches = [];
+  for (const { name, regex } of SECRET_PATTERNS) {
+    const m = text.match(regex);
+    if (m) {
+      matches.push({ pattern: name, match: m[0].slice(0, 20) + "..." });
+    }
+  }
+  return matches;
+}
+
+// src/packs.ts
+function detectConflicts2(newEngrams, existingEngrams) {
+  const conflicts = [];
+  for (const ne of newEngrams) {
+    for (const ee of existingEngrams) {
+      const nNorm = ne.statement.toLowerCase().replace(/\s+/g, " ").trim();
+      const eNorm = ee.statement.toLowerCase().replace(/\s+/g, " ").trim();
+      if (nNorm === eNorm) {
+        conflicts.push({
+          pack_engram_id: ne.id,
+          pack_statement: ne.statement.slice(0, 120),
+          existing_engram_id: ee.id,
+          existing_statement: ee.statement.slice(0, 120),
+          type: "duplicate"
+        });
+        continue;
+      }
+      if (ne.domain && ee.domain && ne.domain === ee.domain) {
+        const nHasNever = /\b(never|don't|do not|avoid|stop)\b/i.test(ne.statement);
+        const eHasNever = /\b(never|don't|do not|avoid|stop)\b/i.test(ee.statement);
+        const nHasAlways = /\b(always|must|should|prefer|use)\b/i.test(ne.statement);
+        const eHasAlways = /\b(always|must|should|prefer|use)\b/i.test(ee.statement);
+        if (nHasNever && eHasAlways || nHasAlways && eHasNever) {
+          const nWords = new Set(nNorm.split(" ").filter((w) => w.length > 4));
+          const eWords = new Set(eNorm.split(" ").filter((w) => w.length > 4));
+          const overlap = [...nWords].filter((w) => eWords.has(w));
+          if (overlap.length >= 2) {
+            conflicts.push({
+              pack_engram_id: ne.id,
+              pack_statement: ne.statement.slice(0, 120),
+              existing_engram_id: ee.id,
+              existing_statement: ee.statement.slice(0, 120),
+              type: "contradiction"
+            });
+          }
+        }
+      }
+    }
+  }
+  return conflicts;
+}
+function installPack(packsDir, source, existingEngrams) {
   if (!fs2.existsSync(source)) throw new Error(`Pack source not found: ${source}`);
   const sourceName = path.basename(source);
   const destDir = path.join(packsDir, sourceName);
   if (!fs2.existsSync(destDir)) fs2.mkdirSync(destDir, { recursive: true });
   const files = fs2.readdirSync(source);
-  let copied = 0;
   for (const file of files) {
     const srcPath = path.join(source, file);
     const destPath = path.join(destDir, file);
     if (fs2.statSync(srcPath).isFile()) {
       fs2.copyFileSync(srcPath, destPath);
-      copied++;
     }
   }
   const engramsPath = path.join(destDir, "engrams.yaml");
-  const engrams = fs2.existsSync(engramsPath) ? loadEngrams(engramsPath) : [];
-  return { installed: engrams.length, name: sourceName };
+  const newEngrams = fs2.existsSync(engramsPath) ? loadEngrams(engramsPath) : [];
+  const conflicts = existingEngrams ? detectConflicts2(newEngrams, existingEngrams) : [];
+  return { installed: newEngrams.length, name: sourceName, conflicts };
+}
+function uninstallPack(packsDir, name) {
+  let packDir = path.join(packsDir, name);
+  if (!fs2.existsSync(packDir)) {
+    const entries = fs2.existsSync(packsDir) ? fs2.readdirSync(packsDir) : [];
+    const match = entries.find((e) => e.toLowerCase() === name.toLowerCase());
+    if (match) {
+      packDir = path.join(packsDir, match);
+    } else {
+      throw new Error(`Pack not found: ${name}. Use 'plur packs list' to see installed packs.`);
+    }
+  }
+  const engramsPath = path.join(packDir, "engrams.yaml");
+  let count = 0;
+  try {
+    count = loadEngrams(engramsPath).length;
+  } catch {
+  }
+  fs2.rmSync(packDir, { recursive: true, force: true });
+  return { name, removed: true, engram_count: count };
 }
 function listPacks(packsDir) {
   if (!fs2.existsSync(packsDir)) return [];
@@ -1061,7 +1179,8 @@ function listPacks(packsDir) {
         name: pack.manifest.name,
         path: packDir,
         engram_count: pack.engrams.length,
-        manifest: pack.manifest
+        manifest: pack.manifest,
+        integrity: computePackHash(packDir)
       });
     } catch {
       const engramsPath = path.join(packDir, "engrams.yaml");
@@ -1075,7 +1194,83 @@ function listPacks(packsDir) {
   }
   return result;
 }
+var PERSONAL_PATH_RE = /(?:\/Users\/\w+|\/home\/\w+|~\/|C:\\Users\\\w+)/;
+var EMAIL_RE = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/;
+var IP_RE = /\b(?:10|172\.(?:1[6-9]|2\d|3[01])|192\.168)\.\d{1,3}\.\d{1,3}\b/;
+function scanPrivacy(engrams) {
+  const issues = [];
+  for (const e of engrams) {
+    if (e.visibility === "private") {
+      issues.push({
+        engram_id: e.id,
+        type: "private_visibility",
+        detail: `Engram marked as private \u2014 skipped from export`
+      });
+      continue;
+    }
+    const text = `${e.statement} ${e.rationale ?? ""} ${e.source ?? ""}`;
+    const secrets = detectSecrets(text);
+    for (const s of secrets) {
+      issues.push({
+        engram_id: e.id,
+        type: "secret",
+        detail: `${s.pattern}: ${s.match}`
+      });
+    }
+    if (PERSONAL_PATH_RE.test(text)) {
+      issues.push({
+        engram_id: e.id,
+        type: "personal_path",
+        detail: `Contains personal path: ${text.match(PERSONAL_PATH_RE)?.[0]}`
+      });
+    }
+    const emailMatch = text.match(EMAIL_RE);
+    if (emailMatch) {
+      issues.push({
+        engram_id: e.id,
+        type: "email",
+        detail: `Contains email: ${emailMatch[0]}`
+      });
+    }
+    const ipMatch = text.match(IP_RE);
+    if (ipMatch) {
+      issues.push({
+        engram_id: e.id,
+        type: "ip_address",
+        detail: `Contains private IP: ${ipMatch[0]}`
+      });
+    }
+  }
+  return { clean: issues.length === 0, issues };
+}
+function deriveMatchTerms(engrams) {
+  const termCounts = /* @__PURE__ */ new Map();
+  for (const e of engrams) {
+    if (e.tags) {
+      for (const t of e.tags) {
+        termCounts.set(t, (termCounts.get(t) || 0) + 1);
+      }
+    }
+    if (e.domain) {
+      for (const part of e.domain.split(".")) {
+        if (part.length > 2) {
+          termCounts.set(part, (termCounts.get(part) || 0) + 1);
+        }
+      }
+    }
+    if (e.type) {
+      termCounts.set(e.type, (termCounts.get(e.type) || 0) + 1);
+    }
+  }
+  return [...termCounts.entries()].filter(([, count]) => count >= 2).sort((a, b) => b[1] - a[1]).slice(0, 20).map(([term]) => term);
+}
 function exportPack(engrams, outputDir, manifest) {
+  const allPrivacy = scanPrivacy(engrams);
+  const blockedIds = new Set(
+    allPrivacy.issues.filter((i) => i.type === "secret" || i.type === "private_visibility").map((i) => i.engram_id)
+  );
+  const safeEngrams = engrams.filter((e) => !blockedIds.has(e.id));
+  const matchTerms = deriveMatchTerms(safeEngrams);
   if (!fs2.existsSync(outputDir)) fs2.mkdirSync(outputDir, { recursive: true });
   const frontmatter = yaml4.dump({
     name: manifest.name,
@@ -1084,8 +1279,8 @@ function exportPack(engrams, outputDir, manifest) {
     creator: manifest.creator,
     metadata: {
       injection_policy: "on_match",
-      match_terms: [],
-      engram_count: engrams.length
+      match_terms: matchTerms,
+      engram_count: safeEngrams.length
     }
   });
   fs2.writeFileSync(
@@ -1098,32 +1293,60 @@ ${frontmatter}---
 ${manifest.description || ""}
 `
   );
-  const content = yaml4.dump({ engrams }, { lineWidth: 120, noRefs: true, quotingType: '"' });
+  const exportEngrams = safeEngrams.map((e) => {
+    const cleaned = { ...e };
+    if (cleaned.relations) {
+      cleaned.relations = {
+        ...cleaned.relations,
+        conflicts: [],
+        related: []
+      };
+    }
+    if (cleaned.associations) {
+      cleaned.associations = [];
+    }
+    if (cleaned.knowledge_anchors) {
+      cleaned.knowledge_anchors = [];
+    }
+    if (cleaned.activation) {
+      cleaned.activation = {
+        ...cleaned.activation,
+        frequency: 0,
+        retrieval_strength: 0.7
+      };
+    }
+    if (cleaned.feedback_signals) {
+      cleaned.feedback_signals = { positive: 0, negative: 0, neutral: 0 };
+    }
+    return cleaned;
+  });
+  const content = yaml4.dump({ engrams: exportEngrams }, { lineWidth: 120, noRefs: true, quotingType: '"' });
   fs2.writeFileSync(path.join(outputDir, "engrams.yaml"), content);
-  return { path: outputDir, engram_count: engrams.length };
+  const integrity = computePackHash(outputDir);
+  fs2.writeFileSync(path.join(outputDir, "INTEGRITY"), `sha256:${integrity}
+`);
+  return {
+    path: outputDir,
+    engram_count: safeEngrams.length,
+    privacy: allPrivacy,
+    match_terms: matchTerms,
+    integrity: `sha256:${integrity}`
+  };
 }
-
-// src/secrets.ts
-var SECRET_PATTERNS = [
-  { name: "aws_access_key", regex: /AKIA[0-9A-Z]{16}/ },
-  { name: "aws_secret_key", regex: /(?:aws_secret_access_key|secret_access_key)\s*[=:]\s*[A-Za-z0-9/+=]{40}/i },
-  { name: "generic_api_key", regex: /(?:^|[^a-z])(sk|pk)[-_][a-z0-9]{20,}/i },
-  { name: "api_key_assignment", regex: /(?:api[_-]?key|api[_-]?secret|secret[_-]?key)\s*[=:]\s*\S{20,}/i },
-  { name: "password_assignment", regex: /password\s*[=:]\s*\S{8,}/i },
-  { name: "connection_string", regex: /(?:postgres|mysql|mongodb|redis):\/\/\S+/ },
-  { name: "jwt", regex: /eyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}/ },
-  { name: "private_key", regex: /-----BEGIN\s+\S+\s+PRIVATE KEY-----/ },
-  { name: "bearer_token", regex: /Bearer\s+[A-Za-z0-9._~+/=-]{20,}/ }
-];
-function detectSecrets(text) {
-  const matches = [];
-  for (const { name, regex } of SECRET_PATTERNS) {
-    const m = text.match(regex);
-    if (m) {
-      matches.push({ pattern: name, match: m[0].slice(0, 20) + "..." });
-    }
+function computePackHash(packDir) {
+  const hash = crypto.createHash("sha256");
+  const skillMd = path.join(packDir, "SKILL.md");
+  const manifestYaml = path.join(packDir, "manifest.yaml");
+  if (fs2.existsSync(skillMd)) {
+    hash.update(fs2.readFileSync(skillMd));
+  } else if (fs2.existsSync(manifestYaml)) {
+    hash.update(fs2.readFileSync(manifestYaml));
   }
-  return matches;
+  const engramsPath = path.join(packDir, "engrams.yaml");
+  if (fs2.existsSync(engramsPath)) {
+    hash.update(fs2.readFileSync(engramsPath));
+  }
+  return hash.digest("hex");
 }
 
 // src/meta/sanitize.ts
@@ -1978,13 +2201,79 @@ var Plur = class {
   paths;
   config;
   indexedStorage = null;
+  _engramCache = /* @__PURE__ */ new Map();
   constructor(options) {
     this.paths = detectPlurStorage(options?.path);
     this.config = loadConfig(this.paths.config);
     if (this.config.index) {
-      this.indexedStorage = new IndexedStorage(this.paths.engrams, this.paths.db);
+      this.indexedStorage = new IndexedStorage(this.paths.engrams, this.paths.db, this.config.stores);
     }
   }
+  /**
+   * Load engrams from primary store + all configured stores, with mtime-based caching.
+   * Store engram IDs get namespaced: ENG-2026-0401-001 → ENG-DF-2026-0401-001.
+   * Primary engrams are returned unchanged.
+   */
+  _loadAllEngrams() {
+    const primary = this._loadCached(this.paths.engrams);
+    const stores = this.config.stores ?? [];
+    if (stores.length === 0) return primary;
+    const all = [...primary];
+    for (const store of stores) {
+      const storeEngrams = this._loadCached(store.path);
+      const prefix = storePrefix(store.scope);
+      for (const e of storeEngrams) {
+        if (e.scope !== "global" && e.scope !== store.scope && !e.scope.startsWith(store.scope)) {
+          logger.debug(`Skipping engram ${e.id} from store ${store.scope}: scope mismatch (${e.scope})`);
+          continue;
+        }
+        const cloned = { ...e };
+        if (cloned.scope === "global") {
+          cloned.scope = store.scope;
+        }
+        const originalId = cloned.id;
+        cloned.id = cloned.id.replace(/^(ENG|ABS|META)-/, `$1-${prefix}-`);
+        cloned._originalId = originalId;
+        cloned._storeScope = store.scope;
+        all.push(cloned);
+      }
+    }
+    return all;
+  }
+  /** Load engrams from a path with mtime-based caching */
+  _loadCached(path2) {
+    let mtime = 0;
+    try {
+      mtime = fs3.statSync(path2).mtimeMs;
+    } catch {
+      return [];
+    }
+    const cached = this._engramCache.get(path2);
+    if (cached && cached.mtime === mtime) return cached.engrams;
+    const engrams = loadEngrams(path2);
+    this._engramCache.set(path2, { mtime, engrams });
+    return engrams;
+  }
+  /** Find which store owns an engram by ID. For namespaced IDs, strips prefix to find in store. */
+  _findEngramStore(id) {
+    const primaryEngrams = this._loadCached(this.paths.engrams);
+    if (primaryEngrams.find((e) => e.id === id)) {
+      return { path: this.paths.engrams, readonly: false, originalId: id };
+    }
+    const stores = this.config.stores ?? [];
+    for (const store of stores) {
+      const prefix = storePrefix(store.scope);
+      const nsPattern = new RegExp(`^(ENG|ABS|META)-${prefix}-`);
+      if (nsPattern.test(id)) {
+        const originalId = id.replace(nsPattern, "$1-");
+        const storeEngrams = this._loadCached(store.path);
+        if (storeEngrams.find((e) => e.id === originalId)) {
+          return { path: store.path, readonly: store.readonly ?? false, originalId };
+        }
+      }
+    }
+    return null;
+  }
   /** Create engram, detect conflicts, save. Returns the created engram. */
   learn(statement, context) {
     if (!this.config.allow_secrets) {
@@ -1995,10 +2284,11 @@ var Plur = class {
     }
     return withLock(this.paths.engrams, () => {
       const engrams = loadEngrams(this.paths.engrams);
-      const id = generateEngramId(engrams);
+      const allEngrams = this._loadAllEngrams();
+      const id = generateEngramId(allEngrams);
       const scope = context?.scope ?? "global";
       const now = (/* @__PURE__ */ new Date()).toISOString();
-      const conflictingEngrams = detectConflicts({ statement, scope }, engrams);
+      const conflictingEngrams = detectConflicts({ statement, scope }, allEngrams);
       const conflictIds = conflictingEngrams.map((e) => e.id);
       const engram = {
         id,
@@ -2091,9 +2381,9 @@ var Plur = class {
     this._reactivateResults(results);
     return results;
   }
-  /** Get a single engram by ID, regardless of status. Returns null if not found. */
+  /** Get a single engram by ID, regardless of status. Searches primary + all stores. */
   getById(id) {
-    const engrams = loadEngrams(this.paths.engrams);
+    const engrams = this._loadAllEngrams();
     return engrams.find((e) => e.id === id) ?? null;
   }
   /** List all active engrams, optionally filtered by scope/domain. No search — returns all matches. */
@@ -2110,7 +2400,7 @@ var Plur = class {
         domain: options?.domain
       });
     } else {
-      engrams = loadEngrams(this.paths.engrams);
+      engrams = this._loadAllEngrams();
       engrams = engrams.filter((e) => e.status === "active");
       if (options?.domain) {
         engrams = engrams.filter((e) => e.domain?.startsWith(options.domain));
@@ -2136,9 +2426,12 @@ var Plur = class {
   /** Reactivate accessed engrams and update co-access associations */
   _reactivateResults(results) {
     if (results.length === 0) return;
+    const isStoreEngram = (e) => e._originalId || /^(ENG|ABS|META)-[A-Z]{3}-/.test(e.id);
+    const primaryResults = results.filter((e) => !isStoreEngram(e));
+    if (primaryResults.length === 0) return;
     withLock(this.paths.engrams, () => {
       const allEngrams = loadEngrams(this.paths.engrams);
-      const resultIds = new Set(results.map((e) => e.id));
+      const resultIds = new Set(primaryResults.map((e) => e.id));
       const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       let modified = false;
       for (const e of allEngrams) {
@@ -2194,7 +2487,7 @@ var Plur = class {
   async injectHybrid(task, options) {
     let embeddingBoosts;
     try {
-      const engrams = loadEngrams(this.paths.engrams).filter((e) => e.status === "active");
+      const engrams = this._loadAllEngrams().filter((e) => e.status === "active");
       const results = await embeddingSearch(engrams, task, engrams.length, this.paths.root);
       if (results.length > 0) {
         embeddingBoosts = /* @__PURE__ */ new Map();
@@ -2207,7 +2500,7 @@ var Plur = class {
     return this._formatInjection(task, options, embeddingBoosts);
   }
   _formatInjection(task, options, embeddingBoosts) {
-    const engrams = loadEngrams(this.paths.engrams);
+    const engrams = this._loadAllEngrams();
     const packs = loadAllPacks(this.paths.packs);
     const budget = options?.budget ?? this.config.injection_budget ?? 2e3;
     const result = selectAndSpread(
@@ -2247,7 +2540,7 @@ var Plur = class {
       injected_ids
     };
   }
-  /** Update feedback_signals and adjust retrieval_strength. Searches packs if not found in personal engrams. */
+  /** Update feedback_signals and adjust retrieval_strength. Searches primary, stores, then packs. */
   feedback(id, signal) {
     const found = withLock(this.paths.engrams, () => {
       const engrams = loadEngrams(this.paths.engrams);
@@ -2267,6 +2560,29 @@ var Plur = class {
       return true;
     });
     if (found) return;
+    const storeInfo = this._findEngramStore(id);
+    if (storeInfo && storeInfo.path !== this.paths.engrams) {
+      if (storeInfo.readonly) {
+        throw new Error("Engram is in a readonly store");
+      }
+      const storeEngrams = loadEngrams(storeInfo.path);
+      const engram = storeEngrams.find((e) => e.id === storeInfo.originalId);
+      if (engram) {
+        if (!engram.feedback_signals) {
+          engram.feedback_signals = { positive: 0, negative: 0, neutral: 0 };
+        }
+        engram.feedback_signals[signal] += 1;
+        if (signal === "positive") {
+          engram.activation.retrieval_strength = Math.min(1, engram.activation.retrieval_strength + 0.05);
+        } else if (signal === "negative") {
+          engram.activation.retrieval_strength = Math.max(0, engram.activation.retrieval_strength - 0.1);
+        }
+        saveEngrams(storeInfo.path, storeEngrams);
+        this._engramCache.delete(storeInfo.path);
+        this._syncIndex();
+        return;
+      }
+    }
     this._feedbackPack(id, signal);
   }
   /** Save extracted meta-engrams to the engram store. Skips IDs that already exist. */
@@ -2303,19 +2619,40 @@ var Plur = class {
       return true;
     });
   }
-  /** Set engram status to 'retired'. */
+  /** Set engram status to 'retired'. Supports primary and store engrams. */
   forget(id, reason) {
-    withLock(this.paths.engrams, () => {
+    const foundInPrimary = withLock(this.paths.engrams, () => {
       const engrams = loadEngrams(this.paths.engrams);
       const engram = engrams.find((e) => e.id === id);
-      if (!engram) throw new Error(`Engram not found: ${id}`);
+      if (!engram) return false;
       engram.status = "retired";
       if (reason && !engram.rationale) {
         engram.rationale = `Retired: ${reason}`;
       }
       saveEngrams(this.paths.engrams, engrams);
       this._syncIndex();
+      return true;
     });
+    if (foundInPrimary) return;
+    const storeInfo = this._findEngramStore(id);
+    if (storeInfo && storeInfo.path !== this.paths.engrams) {
+      if (storeInfo.readonly) {
+        throw new Error("Cannot retire engram from readonly store");
+      }
+      const storeEngrams = loadEngrams(storeInfo.path);
+      const engram = storeEngrams.find((e) => e.id === storeInfo.originalId);
+      if (engram) {
+        engram.status = "retired";
+        if (reason && !engram.rationale) {
+          engram.rationale = `Retired: ${reason}`;
+        }
+        saveEngrams(storeInfo.path, storeEngrams);
+        this._engramCache.delete(storeInfo.path);
+        this._syncIndex();
+        return;
+      }
+    }
+    throw new Error(`Engram not found: ${id}`);
   }
   /** Remove retired engrams from storage. Returns count of removed and remaining. */
   compact() {
@@ -2333,7 +2670,7 @@ var Plur = class {
   /** Rebuild SQLite index from YAML source of truth. Only works when index: true. */
   reindex() {
     if (!this.indexedStorage) {
-      this.indexedStorage = new IndexedStorage(this.paths.engrams, this.paths.db);
+      this.indexedStorage = new IndexedStorage(this.paths.engrams, this.paths.db, this.config.stores);
     }
     this.indexedStorage.reindex();
   }
@@ -2408,15 +2745,20 @@ var Plur = class {
     }
     return candidates;
   }
-  /** Install a pack from a source path. */
+  /** Install a pack from a source path. Detects conflicts with existing engrams. */
   installPack(source) {
-    return installPack(this.paths.packs, source);
+    const existing = this._loadAllEngrams();
+    return installPack(this.paths.packs, source, existing);
+  }
+  /** Uninstall a pack by name. */
+  uninstallPack(name) {
+    return uninstallPack(this.paths.packs, name);
   }
-  /** Export engrams as a shareable pack. */
+  /** Export engrams as a shareable pack with privacy scanning and integrity hash. */
   exportPack(engrams, outputDir, manifest) {
     return exportPack(engrams, outputDir, manifest);
   }
-  /** List all installed packs. */
+  /** List all installed packs (with integrity hashes). */
   listPacks() {
     return listPacks(this.paths.packs);
   }
@@ -2430,7 +2772,7 @@ var Plur = class {
   }
   /** Return system health info. */
   status() {
-    const engrams = loadEngrams(this.paths.engrams);
+    const engrams = this._loadAllEngrams();
     const episodes = queryTimeline(this.paths.episodes);
     const packs = listPacks(this.paths.packs);
     return {
@@ -2470,12 +2812,12 @@ var Plur = class {
       scope: "global",
       shared: false,
       readonly: false,
-      engram_count: loadEngrams(this.paths.engrams).filter((e) => e.status !== "retired").length
+      engram_count: this._loadCached(this.paths.engrams).filter((e) => e.status !== "retired").length
     };
     const additional = stores.map((s) => {
       let count = 0;
       try {
-        count = loadEngrams(s.path).filter((e) => e.status !== "retired").length;
+        count = this._loadCached(s.path).filter((e) => e.status !== "retired").length;
       } catch {
       }
       return { ...s, engram_count: count };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plur-ai/core",
-  "version": "0.5.2",
+  "version": "0.7.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",