@plur-ai/core 0.8.2 → 0.9.0

package/dist/{chunk-GRDNBUIJ.js → chunk-3ZPTRZE3.js}

@@ -1,6 +1,6 @@
 import {
   atomicWrite
-} from "./chunk-MY4XVDCE.js";
+} from "./chunk-PRK3B7WR.js";
 
 // src/logger.ts
 var level = process.env.PLUR_LOG_LEVEL || "warning";

package/dist/{chunk-UETCDULF.js → chunk-MW5EPL7G.js}

@@ -1,6 +1,6 @@
 import {
   atomicWrite
-} from "./chunk-MY4XVDCE.js";
+} from "./chunk-PRK3B7WR.js";
 
 // src/fts.ts
 var STOP_WORDS = /* @__PURE__ */ new Set([
@@ -183,6 +183,38 @@ async function embeddingSearch(engrams, query, limit, storagePath) {
   similarities.sort((a, b) => b.score - a.score);
   return similarities.slice(0, limit).map((s) => s.engram);
 }
+async function embeddingSearchWithScores(engrams, query, limit, storagePath) {
+  if (engrams.length === 0) return [];
+  const cachePath = storagePath ? join(storagePath, ".embeddings-cache.json") : ".embeddings-cache.json";
+  const cache = loadCache(cachePath);
+  const queryEmbedding = await embed(query);
+  if (!queryEmbedding) {
+    return [];
+  }
+  const similarities = [];
+  for (const engram of engrams) {
+    const searchText = engramSearchText(engram);
+    const hash = hashStatement(searchText);
+    let engramEmbedding;
+    if (cache[engram.id]?.hash === hash) {
+      engramEmbedding = new Float32Array(cache[engram.id].embedding);
+    } else {
+      const emb = await embed(searchText);
+      if (!emb) return [];
+      engramEmbedding = emb;
+      cache[engram.id] = {
+        hash,
+        embedding: Array.from(engramEmbedding)
+      };
+    }
+    const rawScore = cosineSimilarity(queryEmbedding, engramEmbedding);
+    const score = Math.max(0, Math.min(1, rawScore));
+    similarities.push({ engram, score });
+  }
+  saveCache(cachePath, cache);
+  similarities.sort((a, b) => b.score - a.score);
+  return similarities.slice(0, limit);
+}
 
 export {
   ftsTokenize,
@@ -192,5 +224,6 @@ export {
   searchEngrams,
   embed,
   cosineSimilarity,
-  embeddingSearch
+  embeddingSearch,
+  embeddingSearchWithScores
 };

package/dist/{chunk-MY4XVDCE.js → chunk-PRK3B7WR.js}

@@ -80,10 +80,11 @@ function hasConflictMarkers(root) {
   return result !== null && result.length > 0;
 }
 function pullRebase(root) {
-  const result = gitSafe(["pull", "--rebase", "origin", "main"], root);
+  const branch = gitSafe(["rev-parse", "--abbrev-ref", "HEAD"], root) || "main";
+  const result = gitSafe(["pull", "--rebase", "origin", branch], root);
   if (result !== null) return true;
   gitSafe(["rebase", "--abort"], root);
-  const mergeResult = gitSafe(["pull", "origin", "main", "--no-edit"], root);
+  const mergeResult = gitSafe(["pull", "origin", branch, "--no-edit"], root);
   if (mergeResult !== null) return true;
   if (hasConflictMarkers(root)) {
     gitSafe(["merge", "--abort"], root);

package/dist/embeddings-VXK2E2IF.js

@@ -0,0 +1,14 @@
+import {
+  cosineSimilarity,
+  embed,
+  embeddingSearch,
+  embeddingSearchWithScores
+} from "./chunk-MW5EPL7G.js";
+import "./chunk-PRK3B7WR.js";
+import "./chunk-2ZDO52B4.js";
+export {
+  cosineSimilarity,
+  embed,
+  embeddingSearch,
+  embeddingSearchWithScores
+};

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 
 interface HistoryEvent {
-    event: 'engram_created' | 'engram_updated' | 'engram_merged' | 'feedback_received' | 'engram_retired' | 'engram_promoted' | 'failure_reported' | 'procedure_evolved';
+    event: 'engram_created' | 'engram_updated' | 'engram_merged' | 'feedback_received' | 'engram_retired' | 'engram_promoted' | 'failure_reported' | 'procedure_evolved' | 'recurrence_detected' | 'contradiction_detected' | 'scope_promoted' | 'buffer_pruned' | 'weekly_review';
     engram_id: string;
     timestamp: string;
     data: Record<string, unknown>;
@@ -536,6 +536,43 @@ type KnowledgeAnchor = z.infer<typeof KnowledgeAnchorSchema>;
 type Association = z.infer<typeof AssociationSchema>;
 type PreviousVersionRef = z.infer<typeof PreviousVersionRefSchema>;
 
+/** Map retrieval strength to a human-readable status label. */
+declare function strengthToStatus(strength: number): string;
+interface DecayTransition {
+    engram_id: string;
+    old_strength: number;
+    new_strength: number;
+    old_status: string;
+    new_status: string;
+}
+interface BatchDecayResult {
+    total: number;
+    decayed: number;
+    skipped: number;
+    transitions: DecayTransition[];
+}
+interface BatchDecayOptions {
+    contextScope?: string;
+    lambda?: number;
+    now?: Date;
+}
+/**
+ * Apply ACT-R decay to a batch of engrams.
+ * Scope-matched engrams are skipped (they never decay).
+ * Status transitions are logged to history.
+ * Returns the result summary and the list of engrams that were modified.
+ */
+declare function applyBatchDecay(engrams: Engram[], historyRoot: string, options?: BatchDecayOptions): {
+    result: BatchDecayResult;
+    modified: Engram[];
+};
+
+/** Result with cosine similarity score attached. */
+interface SimilarityResult {
+    engram: Engram;
+    score: number;
+}
+
 declare const EpisodeSchema: z.ZodObject<{
     id: z.ZodString;
     summary: z.ZodString;
@@ -1850,6 +1887,18 @@ declare class Plur {
     private _loadAllEngrams;
     /** Load engrams from a path with mtime-based caching */
     private _loadCached;
+    /**
+     * Write engrams to disk and invalidate the cache for that path.
+     *
+     * Why: `_loadCached` uses mtime-based invalidation, but on CI tmpfs
+     * (ubuntu-latest runners) mtime resolution can be coarse enough that a
+     * stat() taken before and after a write returns the same mtime. When that
+     * happens the cache serves a pre-write snapshot and a subsequent `getById`
+     * returns `undefined` for an engram that `learn()` just created. Explicit
+     * invalidation on write removes the filesystem as a source of cache
+     * freshness and closes the race. See issue #25.
+     */
+    private _writeEngrams;
     /** Find which store owns an engram by ID. For namespaced IDs, strips prefix to find in store. */
     private _findEngramStore;
     /** Content hash fast-path dedup. */
@@ -1886,6 +1935,12 @@ declare class Plur {
     recallSemantic(query: string, options?: Omit<RecallOptions, 'mode' | 'llm'>): Promise<Engram[]>;
     /** Hybrid search: BM25 + embeddings merged via Reciprocal Rank Fusion. Async, no API calls. */
     recallHybrid(query: string, options?: Omit<RecallOptions, 'mode' | 'llm'>): Promise<Engram[]>;
+    /** Embedding search returning {engram, score}[] with cosine similarity scores. Async, no API calls. */
+    similaritySearch(query: string, options?: {
+        limit?: number;
+        scope?: string;
+        domain?: string;
+    }): Promise<SimilarityResult[]>;
     /** Expanded search: LLM query expansion + hybrid search + RRF merge. Opt-in, requires LLM function. */
     recallExpanded(query: string, options: RecallOptions & {
         llm: LlmFunction;
@@ -1924,6 +1979,16 @@ declare class Plur {
         removed: number;
         remaining: number;
     };
+    /**
+     * Apply ACT-R decay to all primary store engrams.
+     * Scope-matched engrams are skipped, status transitions logged to history.
+     * Modified engrams are saved back to the store.
+     */
+    batchDecay(options?: {
+        contextScope?: string;
+        lambda?: number;
+        now?: Date;
+    }): BatchDecayResult;
     /** Rebuild SQLite index from YAML source of truth. Only works when index: true. */
     reindex(): void;
     /** Sync SQLite index after YAML write (no-op if index disabled) */
@@ -1995,4 +2060,4 @@ declare class Plur {
     }>;
 }
 
-export { ALL_MIGRATIONS, type AlignmentResult, type Association, type AutoSearchResult, type BoundedRecallResult, COMMITMENT_MULTIPLIER, CURRENT_SCHEMA_VERSION, type CaptureContext, type DedupConfig, type DedupDecision, type DomainCoverage, DomainCoverageSchema, type Engram, type EngramCluster, type EngramStore, type Episode, type EvidenceEntry, EvidenceEntrySchema, type ExtractOptions, type ExtractionResult, type Falsification, FalsificationSchema, type HierarchyPosition, HierarchyPositionSchema, type HistoryEvent, IndexedStorage, type IngestCandidate, type IngestOptions, type InjectOptions, type InjectionLayer, type InjectionResult, type KnowledgeAnchor, type LearnAsyncContext, type LearnAsyncResult, type LearnBatchResult, type LearnContext, type LlmFunction, type LlmTierConfig, type MemberAlignment, type MetaConfidence, MetaConfidenceSchema, type MetaField, MetaFieldSchema, type Migration, type MigrationResult, type ModelTier, PLATITUDE_PATTERNS, type PackManifest, Plur, type PlurConfig, type PlurPaths, type PreviewResult, type PreviousVersionRef, type PrivacyIssue, type PrivacyScanResult, type ProfileCache, type RecallBudget, type RecallOptions, type RegistryEntry, type RelationalAnalysis, type RelationalTriple, type SearchStrategy, SessionBreadcrumbs, SqliteStore, type StatusResult, type StorageBackend, type StorageConfig, type StoreEntry, type StructuralTemplate, StructuralTemplateSchema, type SyncResult, type SyncStatus, type TimelineQuery, type TypedRole, type ValidationResult, type VersionCheckResult, YamlStore, alignCluster, analyzeStructure, appendHistory, assignLayer, asyncAtomicWrite, autoSummary, buildBatchDedupPrompt, buildDedupPrompt, checkForUpdate, classifyPolarity, clearVersionCache, clusterByStructure, computeConfidence, computeContentHash, computeMetaConfidence, confidenceBand, createStore, detectPlurStorage, detectSecrets, engramSearchText, extractMetaEngrams, formatLayer1, formatLayer2, formatLayer3, formatWithLayer, formulateMetaEngram, freshTailBoost, generateEventId, generateGuardrails, generateProfile, generateSummary, getCachedUpdateCheck, getProfileForInjection, getSchemaVersion, isPlatitude, listHistoryMonths, loadProfileCache, markProfileDirty, migrateStore, needsSummary, normalizeStatement, organizeHierarchy, parseDedupResponse, profileNeedsRegeneration, readHistory, readHistoryForEngram, recallAuto, resolveOperationTier, rollbackMigrations, runMigrations, saveProfileCache, selectModel, selectModelForOperation, setSchemaVersion, tokenSimilarity, validateMetaEngram, withAsyncLock };
+export { ALL_MIGRATIONS, type AlignmentResult, type Association, type AutoSearchResult, type BatchDecayOptions, type BatchDecayResult, type BoundedRecallResult, COMMITMENT_MULTIPLIER, CURRENT_SCHEMA_VERSION, type CaptureContext, type DecayTransition, type DedupConfig, type DedupDecision, type DomainCoverage, DomainCoverageSchema, type Engram, type EngramCluster, type EngramStore, type Episode, type EvidenceEntry, EvidenceEntrySchema, type ExtractOptions, type ExtractionResult, type Falsification, FalsificationSchema, type HierarchyPosition, HierarchyPositionSchema, type HistoryEvent, IndexedStorage, type IngestCandidate, type IngestOptions, type InjectOptions, type InjectionLayer, type InjectionResult, type KnowledgeAnchor, type LearnAsyncContext, type LearnAsyncResult, type LearnBatchResult, type LearnContext, type LlmFunction, type LlmTierConfig, type MemberAlignment, type MetaConfidence, MetaConfidenceSchema, type MetaField, MetaFieldSchema, type Migration, type MigrationResult, type ModelTier, PLATITUDE_PATTERNS, type PackManifest, Plur, type PlurConfig, type PlurPaths, type PreviewResult, type PreviousVersionRef, type PrivacyIssue, type PrivacyScanResult, type ProfileCache, type RecallBudget, type RecallOptions, type RegistryEntry, type RelationalAnalysis, type RelationalTriple, type SearchStrategy, SessionBreadcrumbs, type SimilarityResult, SqliteStore, type StatusResult, type StorageBackend, type StorageConfig, type StoreEntry, type StructuralTemplate, StructuralTemplateSchema, type SyncResult, type SyncStatus, type TimelineQuery, type TypedRole, type ValidationResult, type VersionCheckResult, YamlStore, alignCluster, analyzeStructure, appendHistory, applyBatchDecay, assignLayer, asyncAtomicWrite, autoSummary, buildBatchDedupPrompt, buildDedupPrompt, checkForUpdate, classifyPolarity, clearVersionCache, clusterByStructure, computeConfidence, computeContentHash, computeMetaConfidence, confidenceBand, createStore, detectPlurStorage, detectSecrets, engramSearchText, extractMetaEngrams, formatLayer1, formatLayer2, formatLayer3, formatWithLayer, formulateMetaEngram, freshTailBoost, generateEventId, generateGuardrails, generateProfile, generateSummary, getCachedUpdateCheck, getProfileForInjection, getSchemaVersion, isPlatitude, listHistoryMonths, loadProfileCache, markProfileDirty, migrateStore, needsSummary, normalizeStatement, organizeHierarchy, parseDedupResponse, profileNeedsRegeneration, readHistory, readHistoryForEngram, recallAuto, resolveOperationTier, rollbackMigrations, runMigrations, saveProfileCache, selectModel, selectModelForOperation, setSchemaVersion, strengthToStatus, tokenSimilarity, validateMetaEngram, withAsyncLock };

package/dist/index.js

@@ -1,11 +1,12 @@
 import {
   computeIdf,
   embeddingSearch,
+  embeddingSearchWithScores,
   engramSearchText,
   ftsScore,
   ftsTokenize,
   searchEngrams
-} from "./chunk-UETCDULF.js";
+} from "./chunk-MW5EPL7G.js";
 import {
   EngramSchemaPassthrough,
   appendHistory,
@@ -25,13 +26,13 @@ import {
   readHistoryForEngram,
   saveEngrams,
   storePrefix
-} from "./chunk-GRDNBUIJ.js";
+} from "./chunk-3ZPTRZE3.js";
 import {
   atomicWrite,
   getSyncStatus,
   sync,
   withLock
-} from "./chunk-MY4XVDCE.js";
+} from "./chunk-PRK3B7WR.js";
 import "./chunk-2ZDO52B4.js";
 
 // src/index.ts
@@ -316,6 +317,72 @@ function confidenceDecay(retrievalStrength, lastPositiveFeedbackDate, commitment
   const decayed = retrievalStrength * multiplier;
   return Math.max(CONFIDENCE_DECAY_FLOOR, decayed);
 }
+function strengthToStatus(strength) {
+  if (strength > 0.5) return "active";
+  if (strength > 0.3) return "fading";
+  if (strength > 0.1) return "dormant";
+  return "retirement_candidate";
+}
+function applyBatchDecay(engrams, historyRoot, options) {
+  const now = options?.now ?? /* @__PURE__ */ new Date();
+  const lambda = options?.lambda ?? DECAY_RATE;
+  const contextScope = options?.contextScope;
+  const active = engrams.filter((e) => e.status === "active");
+  const transitions = [];
+  const modified = [];
+  let decayed = 0;
+  let skipped = 0;
+  for (const engram of active) {
+    if (contextScope && isScopeMatched(engram.scope, contextScope)) {
+      skipped++;
+      continue;
+    }
+    const days = daysSince(engram.activation.last_accessed, now);
+    if (days === 0) continue;
+    const emotionalWeight = engram.episodic?.emotional_weight ?? 5;
+    const effectiveLambda = lambda * (1 - emotionalWeight / 20);
+    const oldStrength = engram.activation.retrieval_strength;
+    const newStrength = decayedStrength(oldStrength, days, effectiveLambda);
+    if (Math.abs(newStrength - oldStrength) < 1e-10) continue;
+    const oldStatus = strengthToStatus(oldStrength);
+    const newStatus = strengthToStatus(newStrength);
+    engram.activation.retrieval_strength = newStrength;
+    modified.push(engram);
+    decayed++;
+    if (oldStatus !== newStatus) {
+      const transition = {
+        engram_id: engram.id,
+        old_strength: oldStrength,
+        new_strength: newStrength,
+        old_status: oldStatus,
+        new_status: newStatus
+      };
+      transitions.push(transition);
+      const event = {
+        event: "engram_updated",
+        engram_id: engram.id,
+        timestamp: now.toISOString(),
+        data: {
+          reason: "decay_status_transition",
+          old_strength: oldStrength,
+          new_strength: newStrength,
+          old_status: oldStatus,
+          new_status: newStatus
+        }
+      };
+      appendHistory(historyRoot, event);
+    }
+  }
+  return {
+    result: { total: active.length, decayed, skipped, transitions },
+    modified
+  };
+}
+function isScopeMatched(engramScope, contextScope) {
+  if (engramScope === contextScope) return true;
+  if (engramScope.startsWith(contextScope + "/")) return true;
+  return false;
+}
 
 // src/polarity.ts
 var DONT_PATTERNS = [
@@ -1516,7 +1583,7 @@ async function computeSimilarityMatrix(templates) {
   const n = templates.length;
   const matrix = Array.from({ length: n }, () => Array(n).fill(0));
   try {
-    const { embed, cosineSimilarity } = await import("./embeddings-EX7QPXJS.js");
+    const { embed, cosineSimilarity } = await import("./embeddings-VXK2E2IF.js");
     const embeddings = [];
     for (const t of templates) {
       embeddings.push(await embed(t));
@@ -2601,7 +2668,7 @@ async function withAsyncLock(filePath, fn, options) {
       if (attempt === maxRetries) {
         throw new Error(`Failed to acquire lock on ${filePath} after ${maxRetries} retries`);
       }
-      const delay = baseDelay * Math.pow(2, attempt);
+      const delay = Math.min(baseDelay * Math.pow(2, attempt), 5e3);
       await sleep(delay);
     }
   }
@@ -2942,9 +3009,9 @@ var Plur = class {
   }
   /** Load engrams from a path with mtime-based caching */
   _loadCached(path3) {
-    let mtime = 0;
+    let mtime;
     try {
-      mtime = fs4.statSync(path3).mtimeMs;
+      mtime = fs4.statSync(path3, { bigint: true }).mtimeNs;
     } catch {
       return [];
     }
@@ -2954,6 +3021,21 @@ var Plur = class {
     this._engramCache.set(path3, { mtime, engrams });
     return engrams;
   }
+  /**
+   * Write engrams to disk and invalidate the cache for that path.
+   *
+   * Why: `_loadCached` uses mtime-based invalidation, but on CI tmpfs
+   * (ubuntu-latest runners) mtime resolution can be coarse enough that a
+   * stat() taken before and after a write returns the same mtime. When that
+   * happens the cache serves a pre-write snapshot and a subsequent `getById`
+   * returns `undefined` for an engram that `learn()` just created. Explicit
+   * invalidation on write removes the filesystem as a source of cache
+   * freshness and closes the race. See issue #25.
+   */
+  _writeEngrams(path3, engrams) {
+    saveEngrams(path3, engrams);
+    this._engramCache.delete(path3);
+  }
   /** 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);
@@ -3083,7 +3165,7 @@ var Plur = class {
         } : void 0
       };
       engrams.push(engram);
-      saveEngrams(this.paths.engrams, engrams);
+      this._writeEngrams(this.paths.engrams, engrams);
       this._syncIndex();
       appendHistory(this.paths.root, {
         event: "engram_created",
@@ -3113,12 +3195,12 @@ var Plur = class {
   }
   /** Async learn with LLM-driven deduplication (Ideas 1+2+19). */
   async learnAsync(statement, context) {
-    const { learnAsync: learnAsyncImpl } = await import("./learn-async-VXBH3TYE.js");
+    const { learnAsync: learnAsyncImpl } = await import("./learn-async-UZAPPQK4.js");
     return learnAsyncImpl(this._learnAsyncDeps(), statement, context);
   }
   /** Batch learn with LLM dedup. */
   async learnBatch(statements, llm) {
-    const { learnBatch: learnBatchImpl } = await import("./learn-async-VXBH3TYE.js");
+    const { learnBatch: learnBatchImpl } = await import("./learn-async-UZAPPQK4.js");
     return learnBatchImpl(this._learnAsyncDeps(), statements, llm);
   }
   /**
@@ -3159,6 +3241,12 @@ var Plur = class {
     this._reactivateResults(results);
     return results;
   }
+  /** Embedding search returning {engram, score}[] with cosine similarity scores. Async, no API calls. */
+  async similaritySearch(query, options) {
+    const filtered = this._filterEngrams(options);
+    const limit = options?.limit ?? 20;
+    return embeddingSearchWithScores(filtered, query, limit, this.paths.root);
+  }
   /** Expanded search: LLM query expansion + hybrid search + RRF merge. Opt-in, requires LLM function. */
   async recallExpanded(query, options) {
     const filtered = this._filterEngrams(options);
@@ -3267,7 +3355,7 @@ var Plur = class {
         }
       }
       if (modified) {
-        saveEngrams(this.paths.engrams, allEngrams);
+        this._writeEngrams(this.paths.engrams, allEngrams);
         this._syncIndex();
       }
     });
@@ -3347,7 +3435,7 @@ var Plur = class {
       } else if (signal === "negative") {
         engram.activation.retrieval_strength = Math.max(0, engram.activation.retrieval_strength - 0.1);
       }
-      saveEngrams(this.paths.engrams, engrams);
+      this._writeEngrams(this.paths.engrams, engrams);
       this._syncIndex();
       appendHistory(this.paths.root, {
         event: "feedback_received",
@@ -3375,8 +3463,7 @@ var Plur = class {
         } 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._writeEngrams(storeInfo.path, storeEngrams);
         this._syncIndex();
         return;
       }
@@ -3399,7 +3486,7 @@ var Plur = class {
         }
       }
       if (saved > 0) {
-        saveEngrams(this.paths.engrams, engrams);
+        this._writeEngrams(this.paths.engrams, engrams);
         this._syncIndex();
       }
       return { saved, skipped };
@@ -3412,7 +3499,7 @@ var Plur = class {
       const idx = engrams.findIndex((e) => e.id === updated.id);
       if (idx === -1) return false;
       engrams[idx] = updated;
-      saveEngrams(this.paths.engrams, engrams);
+      this._writeEngrams(this.paths.engrams, engrams);
       this._syncIndex();
       return true;
     });
@@ -3427,7 +3514,7 @@ var Plur = class {
       if (reason && !engram.rationale) {
         engram.rationale = `Retired: ${reason}`;
       }
-      saveEngrams(this.paths.engrams, engrams);
+      this._writeEngrams(this.paths.engrams, engrams);
       this._syncIndex();
       appendHistory(this.paths.root, {
         event: "engram_retired",
@@ -3450,8 +3537,7 @@ var Plur = class {
         if (reason && !engram.rationale) {
           engram.rationale = `Retired: ${reason}`;
         }
-        saveEngrams(storeInfo.path, storeEngrams);
-        this._engramCache.delete(storeInfo.path);
+        this._writeEngrams(storeInfo.path, storeEngrams);
         this._syncIndex();
         return;
       }
@@ -3465,12 +3551,28 @@ var Plur = class {
       const active = engrams.filter((e) => e.status !== "retired");
       const removed = engrams.length - active.length;
       if (removed > 0) {
-        saveEngrams(this.paths.engrams, active);
+        this._writeEngrams(this.paths.engrams, active);
         this._syncIndex();
       }
       return { removed, remaining: active.length };
     });
   }
+  /**
+   * Apply ACT-R decay to all primary store engrams.
+   * Scope-matched engrams are skipped, status transitions logged to history.
+   * Modified engrams are saved back to the store.
+   */
+  batchDecay(options) {
+    return withLock(this.paths.engrams, () => {
+      const engrams = loadEngrams(this.paths.engrams);
+      const { result, modified } = applyBatchDecay(engrams, this.paths.root, options);
+      if (result.transitions.length > 0) {
+        this._writeEngrams(this.paths.engrams, modified);
+        this._syncIndex();
+      }
+      return result;
+    });
+  }
   /** Rebuild SQLite index from YAML source of truth. Only works when index: true. */
   reindex() {
     if (!this.indexedStorage) {
@@ -3672,7 +3774,7 @@ Generate an improved version of the procedure that prevents this failure. Return
             raw.previous_version_ref = { event_id: eventId, changed_at: now };
             if (!raw.episode_ids) raw.episode_ids = [];
             raw.episode_ids.push(episode.id);
-            saveEngrams(this.paths.engrams, engrams);
+            this._writeEngrams(this.paths.engrams, engrams);
             this._syncIndex();
             appendHistory(this.paths.root, {
               event: "procedure_evolved",
@@ -3702,7 +3804,7 @@ Generate an improved version of the procedure that prevents this failure. Return
         const raw = engrams[idx];
         if (!raw.episode_ids) raw.episode_ids = [];
         raw.episode_ids.push(episode.id);
-        saveEngrams(this.paths.engrams, engrams);
+        this._writeEngrams(this.paths.engrams, engrams);
         this._syncIndex();
       }
     });
@@ -3800,6 +3902,7 @@ export {
   alignCluster,
   analyzeStructure,
   appendHistory,
+  applyBatchDecay,
   assignLayer,
   asyncAtomicWrite,
   autoSummary,
@@ -3851,6 +3954,7 @@ export {
   selectModel,
   selectModelForOperation,
   setSchemaVersion,
+  strengthToStatus,
   tokenSimilarity,
   validateMetaEngram,
   withAsyncLock

package/dist/{learn-async-VXBH3TYE.js → learn-async-UZAPPQK4.js}

@@ -6,10 +6,10 @@ import {
   logger,
   parseDedupResponse,
   saveEngrams
-} from "./chunk-GRDNBUIJ.js";
+} from "./chunk-3ZPTRZE3.js";
 import {
   withLock
-} from "./chunk-MY4XVDCE.js";
+} from "./chunk-PRK3B7WR.js";
 import "./chunk-2ZDO52B4.js";
 
 // src/learn-async.ts

package/package.json

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

package/dist/embeddings-EX7QPXJS.js

@@ -1,12 +0,0 @@
-import {
-  cosineSimilarity,
-  embed,
-  embeddingSearch
-} from "./chunk-UETCDULF.js";
-import "./chunk-MY4XVDCE.js";
-import "./chunk-2ZDO52B4.js";
-export {
-  cosineSimilarity,
-  embed,
-  embeddingSearch
-};