@remind_ai/remind 0.1.0 → 0.1.1

package/dist/src/brain/consolidation.js

@@ -13,17 +13,25 @@ const clamp01 = (n) => Math.max(0, Math.min(1, n));
 export async function consolidate(agentId, stores, gate, llm = defaultLlm) {
     const report = { promoted: [], blocked: [], merged: 0 };
     const cache = new Map(); // embeddings reused across the whole cycle
-    // 1. Fresh episodic memories are the raw material of a sleep cycle.
-    const episodic = (await stores.doc.getRecords(agentId, { type: 'episodic' })).filter((r) => r.tier === 'hot' && !r.quarantined);
+    // Every currently-valid memory (beliefs + episodics) in one pass, so the newest statement
+    // can retire any older record it contradicts — fact-vs-fact, fact-vs-event, or event-vs-event.
+    const valid = currentlyValid(await stores.doc.getRecords(agentId, {}));
+    // Latest-wins supersession across the freshly-ingested records: a changed preference or a
+    // corrected detail retires the stale version even when no episodic belief is distilled this
+    // cycle, keeping the bi-temporal record collection — the single source of retrieval truth —
+    // free of superseded content.
+    const retired = await supersedeRecent(valid, stores, llm, cache);
+    // Beliefs still on the books after supersession (for corroboration + salience), embedded once.
+    let existingBeliefs = valid.filter((r) => r.type === 'factual' && !retired.has(r.id));
+    await embedAll(existingBeliefs, cache, llm.embed);
+    // 1. Fresh episodic memories are the raw material of a sleep cycle — minus any just retired.
+    const episodic = valid.filter((r) => r.type === 'episodic' && r.tier === 'hot' && !r.quarantined && !retired.has(r.id));
     if (!episodic.length)
         return report;
     // 2. Drop exact duplicates, then cluster what remains into belief candidates.
     const { canonical } = await dedupe(episodic, cache, llm.embed);
     const clusters = cluster(canonical, cache, MERGE_THRESHOLD);
     report.merged = episodic.length - clusters.length;
-    // 3. Beliefs currently on the books (for supersession + corroboration), embedded once.
-    const existingBeliefs = currentlyValid(await stores.doc.getRecords(agentId, { type: 'factual' }));
-    await embedAll(existingBeliefs, cache, llm.embed);
     // 4. Distill each cluster into a semantic gist, gate it, persist if promoted.
     for (const group of clusters) {
         try {
@@ -56,6 +64,33 @@ export async function consolidate(agentId, stores, gate, llm = defaultLlm) {
     }
     return report;
 }
+/**
+ * Latest-wins supersession across recently-ingested ("hot") memories. Each fresh record,
+ * newest first, retires older still-valid records it contradicts — fact, event, or
+ * preference alike — so a changed preference or corrected detail closes out the stale
+ * version even when no episodic belief is distilled this cycle. The embedding prefilter
+ * inside `supersede` keeps this to O(related): an LLM contradiction check only fires for
+ * topically-similar records. Returns the retired record ids.
+ */
+async function supersedeRecent(records, stores, llm, cache) {
+    const retired = new Set();
+    const fresh = records
+        .filter((r) => r.tier === 'hot')
+        .sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt)); // newest first
+    for (const rec of fresh) {
+        if (retired.has(rec.id))
+            continue;
+        const older = records.filter((r) => r.id !== rec.id && !retired.has(r.id) && Date.parse(r.createdAt) < Date.parse(rec.createdAt));
+        if (!older.length)
+            continue;
+        // These are the user's own recent statements, so widen recall (lower sim gate): a
+        // reworded update ("phone is a Pixel" → "owns an iPhone") should still be compared.
+        const closed = await supersede(rec, older, stores, llm, cache, 0.3);
+        for (const c of closed)
+            retired.add(c.id);
+    }
+    return retired;
+}
 async function offer(candidate, sources, gate, stores, existingBeliefs, report, llm, cache) {
     const verdict = await gate(candidate, sources);
     if (!verdict.promote) {

package/dist/src/brain/temporal.d.ts

@@ -6,4 +6,4 @@ export declare function currentlyValid(records: MemoryRecord[]): MemoryRecord[];
 /** Records whose valid-time window contains the instant `at` (ISO). */
 export declare function activeAt(records: MemoryRecord[], at: string): MemoryRecord[];
 /** Close the valid-time of active beliefs that `newRecord` contradicts. Returns the retired records. */
-export declare function supersede(newRecord: MemoryRecord, existing: MemoryRecord[], stores: Stores, llm?: LlmDeps, cache?: Map<string, Vec>): Promise<MemoryRecord[]>;
+export declare function supersede(newRecord: MemoryRecord, existing: MemoryRecord[], stores: Stores, llm?: LlmDeps, cache?: Map<string, Vec>, minSim?: number): Promise<MemoryRecord[]>;

package/dist/src/brain/temporal.js

@@ -20,24 +20,29 @@ export function activeAt(records, at) {
     });
 }
 /** Close the valid-time of active beliefs that `newRecord` contradicts. Returns the retired records. */
-export async function supersede(newRecord, existing, stores, llm = defaultLlm, cache = new Map()) {
+export async function supersede(newRecord, existing, stores, llm = defaultLlm, cache = new Map(), minSim = SUPERSEDE_SIM_THRESHOLD) {
     if (!newRecord.validFrom)
         newRecord.validFrom = nowIso();
     const candidates = currentlyValid(existing).filter((r) => r.id !== newRecord.id);
     if (!candidates.length)
         return [];
     // Embedding prefilter: only spend an LLM call on beliefs that are topically related,
-    // so this stays O(related) instead of O(every belief).
+    // so this stays O(related) instead of O(every belief). Callers comparing the user's own
+    // handful of recent statements can widen recall by lowering `minSim`.
     await embedAll([newRecord, ...candidates], cache, llm.embed);
     const nv = cache.get(keyOf(newRecord));
     const retired = [];
     for (const old of candidates) {
         const ov = cache.get(keyOf(old));
         const sim = nv && ov ? cosine(nv, ov) : 1; // missing vectors ⇒ fail safe and check
-        if (!sharesSubject(newRecord, old) && sim < SUPERSEDE_SIM_THRESHOLD)
+        if (!sharesSubject(newRecord, old) && sim < minSim)
             continue;
-        const ans = await llm.classify(`OLD belief: "${old.content}"\nNEW belief: "${newRecord.content}"\n` +
-            `Does NEW contradict or replace OLD about the same subject? Answer 'yes' or 'no'.`);
+        const ans = await llm.classify(`You maintain the user's profile, where each attribute (employer, location, phone, ` +
+            `manager, preference, device, etc.) holds a single CURRENT value.\n` +
+            `OLD: "${old.content}"\nNEW: "${newRecord.content}"\n` +
+            `Does NEW contradict or replace OLD — i.e. give a new value for the SAME attribute, so ` +
+            `OLD is no longer the user's current state? Answer 'yes' if NEW updates, replaces, or ` +
+            `contradicts OLD; answer 'no' only if they are independent facts that can both be true at once.`);
         if (ans.startsWith('yes')) {
             const closed = { ...old, validTo: newRecord.validFrom };
             await stores.doc.saveRecord(closed);

package/dist/src/core/retrieval.js

@@ -15,8 +15,15 @@ Query: ${query}`);
 Rewritten query: ${refined}
 Chunks: ${JSON.stringify(first.map((r) => r.content))}`);
     const second = await stores.vector.search(agentId, refined2, 3, sourceId);
-    // 4. Frequency fusion — chunks seen in both passes rank higher.
-    const priority = fuse([...first, ...second]).slice(0, 3);
+    // 4. Frequency fusion — chunks seen in both passes rank higher. A bi-temporal guard
+    // drops any chunk whose record has been superseded (validTo closed), so a stale value a
+    // newer statement replaced never reaches the context even though it lingers in the index.
+    const all = await stores.doc.getRecords(agentId, {});
+    const now = Date.now();
+    const superseded = new Set(all.filter((r) => r.validTo && Date.parse(r.validTo) <= now).map((r) => r.id));
+    const priority = fuse([...first, ...second])
+        .filter((r) => !superseded.has(r.id))
+        .slice(0, 3);
     // 5. Knowledge-graph relations, filtered to what's relevant.
     const graphMap = await stores.graph.fetchGraph(agentId);
     let relations = '';

package/dist/src/core/stores/doc.store.js

@@ -59,8 +59,29 @@ export const docStore = {
     },
     async getFacts(agentId) {
         await connect();
-        const a = await AgentModel.findOne({ agentId }).lean();
-        return a?.facts ?? [];
+        // Single source of truth: derive the user's factual context from the bi-temporal
+        // record collection, excluding any belief whose valid-time window has been closed
+        // by supersession. The validity filter runs in the DB query (indexed on agentId),
+        // so superseded facts never reach retrieval. ISO-8601 UTC strings compare
+        // lexicographically in chronological order, so $gt on `validTo` is correct.
+        const now = new Date().toISOString();
+        const docs = await RecordModel.find({
+            agentId,
+            type: 'factual',
+            $or: [{ validTo: { $exists: false } }, { validTo: null }, { validTo: { $gt: now } }],
+        })
+            .sort({ createdAt: 1 })
+            .lean();
+        const seen = new Set();
+        const facts = [];
+        for (const d of docs) {
+            const c = d.content?.trim();
+            if (c && !seen.has(c.toLowerCase())) {
+                seen.add(c.toLowerCase());
+                facts.push(c);
+            }
+        }
+        return facts;
     },
     async saveRecord(record) {
         await connect();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remind_ai/remind",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Brain-inspired AI-agent memory SDK with the MemGuard security layer.",
   "type": "module",
   "main": "dist/src/index.js",