@plur-ai/core 0.5.1 → 0.6.0

package/dist/index.d.ts

@@ -1234,8 +1234,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 +1250,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 +1304,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 +1340,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 +1357,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 +1366,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(): {

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 id of dbIds) {
-        if (!yamlIds.has(id)) deleteStmt.run(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);
+        }
+      }
+      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();
 
@@ -1978,13 +2011,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 +2094,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 +2191,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 +2210,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 +2236,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 +2297,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 +2310,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 +2350,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 +2370,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 +2429,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 +2480,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();
   }
@@ -2430,7 +2577,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 +2617,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.1",
+  "version": "0.6.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",