crbro-memory 2.8.0 → 2.9.0

package/dist/engine/cortex.js

@@ -13,6 +13,7 @@ const ids_js_1 = require("../utils/ids.js");
 const hash_js_1 = require("../utils/hash.js");
 const ops_js_1 = require("../sync/ops.js");
 const secrets_js_1 = require("./secrets.js");
+const shelf_js_1 = require("./shelf.js");
 const TYPE_PREFIX_RE = /^(project_|tech_|lang_|person_|domain_|process_|protocol_)/;
 /**
  * Similarity above which a new fact is flagged as a near-duplicate of one
@@ -360,6 +361,14 @@ function unionNeuron(target, source) {
             hit.keys = keys;
         else
             delete hit.keys;
+        // The later check is the newer evidence; the more volatile explicit class
+        // wins, as in a team space (a needless warning is cheaper than a missing one).
+        const verificado = (0, shelf_js_1.latestOf)(hit.verified, sf.verified);
+        if (verificado)
+            hit.verified = verificado;
+        const vida = (0, shelf_js_1.mostVolatile)(hit.shelf_life, sf.shelf_life);
+        if (vida)
+            hit.shelf_life = vida;
     }
     // ── Decisions: by normalised text, the target's rationale wins ──
     const decisions = target.decisions.map(d => ({ ...d }));
@@ -435,6 +444,22 @@ function unionNeuron(target, source) {
         neuron.entry_status = estadosVivos;
     else
         delete neuron.entry_status;
+    const verificadas = { ...(source.entry_verified || {}) };
+    for (const [k, v] of Object.entries(target.entry_verified || {})) {
+        const l = (0, shelf_js_1.latestOf)(verificadas[k], v);
+        if (l)
+            verificadas[k] = l;
+        else if (!verificadas[k])
+            verificadas[k] = v;
+    }
+    const verificadasVivas = {};
+    for (const k of Object.keys(verificadas).sort())
+        if (vivos.has(k))
+            verificadasVivas[k] = verificadas[k];
+    if (Object.keys(verificadasVivas).length)
+        neuron.entry_verified = verificadasVivas;
+    else
+        delete neuron.entry_verified;
     const origenes = { ...(source.entry_source || {}), ...(target.entry_source || {}) };
     const origenesVivos = {};
     for (const k of Object.keys(origenes).sort())
@@ -750,6 +775,11 @@ class Cortex {
         let duplicate = false;
         let updatedInPlace = false;
         let confirmations;
+        let shelf;
+        let reconfirmed = false;
+        let shelfLengthened = false;
+        let verificar = null;
+        const vidaPedida = (0, shelf_js_1.isShelfLife)(options?.shelfLife) ? options.shelfLife : undefined;
         let skippedRetired = null;
         // A retired decision, pattern, error or debt must not come back through
         // learn: the sidecar says so, and the index already hides it.
@@ -822,6 +852,16 @@ class Cortex {
                             vistos.add(testigo);
                         confirmations = existente.confirmations ?? 1;
                         let cambiado = false;
+                        if (vidaPedida && vidaPedida !== existente.shelf_life) {
+                            // Lengthening an explicit class (volatile → durable, say). On a
+                            // shared neuron the more volatile value comes back from the
+                            // log on the next sync; the server warns about it.
+                            if (existente.shelf_life && (0, shelf_js_1.mostVolatile)(existente.shelf_life, vidaPedida) === existente.shelf_life) {
+                                shelfLengthened = true;
+                            }
+                            existente.shelf_life = vidaPedida;
+                            cambiado = true;
+                        }
                         if (options?.confidence !== undefined && options.confidence !== existente.confidence) {
                             existente.confidence = options.confidence;
                             cambiado = true;
@@ -843,6 +883,24 @@ class Cortex {
                                 cambiado = true;
                             }
                         }
+                        // Saying the same line again, and nothing else, is a check
+                        // (shelf life): the clock restarts. Not when the call also
+                        // brings keywords, a confidence or a class — that is editing the
+                        // line, and the server itself asks for exactly that re-learn to
+                        // add keywords, so counting it would mark an unchecked line as
+                        // checked. Not for the miner either: re-reading an old
+                        // transcript is not looking at the source.
+                        if (options?.source !== 'miner' && !cambiado) {
+                            existente.verified = (0, fs_js_1.now)();
+                            reconfirmed = true;
+                            // One op per line per session: a retry or the re-save after a
+                            // compaction must not add a line to the team's log each time.
+                            const yaVerificadas = (this.tally.verifiedEmitted ??= new Set());
+                            if (!yaVerificadas.has(testigo)) {
+                                yaVerificadas.add(testigo);
+                                verificar = { eid: existente.id || (0, hash_js_1.factId)(existente.text), at: existente.verified };
+                            }
+                        }
                         if (cambiado) {
                             // Note for shared neurons: materialize takes max(conf) and
                             // unions keys, so lowering confidence or dropping an alias
@@ -850,8 +908,11 @@ class Cortex {
                             updatedInPlace = true;
                             this.tally.topics.add(n.id);
                             emitir = { kind: 'fact', text: existente.text, fid: existente.id || id,
-                                conf: existente.confidence ?? 1, at: existente.added, src: existente.source, keys: existente.keys };
+                                conf: existente.confidence ?? 1, at: existente.added, src: existente.source, keys: existente.keys,
+                                ...(existente.shelf_life ? { shelf: existente.shelf_life } : {}) };
                         }
+                        const sv = (0, shelf_js_1.shelfOfFact)(existente);
+                        shelf = { shelf_life: sv.shelf, inferred: sv.inferred, ...(sv.reason ? { reason: sv.reason } : {}) };
                     }
                     if (!isDuplicate) {
                         if (options?.supersedes?.length) {
@@ -876,13 +937,18 @@ class Cortex {
                             fact.supersedes = options.supersedes;
                         if (keys.length)
                             fact.keys = keys;
+                        if (vidaPedida)
+                            fact.shelf_life = vidaPedida;
+                        const sv = (0, shelf_js_1.shelfOfFact)(fact);
+                        shelf = { shelf_life: sv.shelf, inferred: sv.inferred, ...(sv.reason ? { reason: sv.reason } : {}) };
                         n.facts.push(fact);
                         if (fact.source !== 'miner')
                             (this.tally.witnessed ??= new Set()).add(`${n.id}|${id}`);
                         this.tally.facts++;
                         this.tally.topics.add(n.id);
                         emitir = { kind: 'fact', text: content, fid: id,
-                            conf: fact.confidence, at: fact.added, src: fact.source, keys: fact.keys };
+                            conf: fact.confidence, at: fact.added, src: fact.source, keys: fact.keys,
+                            ...(fact.shelf_life ? { shelf: fact.shelf_life } : {}) };
                     }
                     break;
                 }
@@ -970,11 +1036,18 @@ class Cortex {
         // key and the least likely to be worth sharing.
         if (emitir)
             await this.emit(final.id, emitir);
+        // A reconfirming re-learn reaches the team as a check: the latest wins.
+        const v = verificar;
+        if (v)
+            await this.emit(final.id, { kind: 'verify', eid: v.eid, ekind: 'fact', at: v.at });
         return {
             neuron: final, action, superseded, supersedes_unmatched: supersedesUnmatched,
             near_duplicates: nearDuplicates, redacted: limpio.found,
             duplicate, updated_in_place: updatedInPlace, skipped_retired: null,
             ...(confirmations !== undefined ? { confirmations } : {}),
+            ...(shelf ? { shelf } : {}),
+            ...(reconfirmed ? { reconfirmed } : {}),
+            ...(shelfLengthened ? { shelf_lengthened: true } : {}),
         };
     }
     /**
@@ -1025,6 +1098,93 @@ class Cortex {
         }
         return { neuron: (actualizada || neuron), revised, unmatched };
     }
+    /**
+     * Reconfirm: the caller checked these lines against their source and they
+     * still hold, so their shelf-life clock restarts now.
+     *
+     * `facts` match ACTIVE facts by id or exact text (trimmed, case-insensitive);
+     * `entries` match live decisions and patterns by entry id or exact text —
+     * the two kinds whose class is durable. A retired fact or entry is not
+     * verifiable: it comes back in `retired` with its status (reactivate it with
+     * status active first, if it holds again), and in `unmatched` like any miss.
+     * Preferences, errors and debts never go stale, so there is nothing to
+     * reconfirm on them; they are unmatched.
+     *
+     * Each stamp is emitted as a verify op, so on a shared neuron a teammate's
+     * clock restarts too: the fact is shared, and so is the world it describes.
+     */
+    async verify(neuronRef, targets) {
+        const facts = (targets.facts || []).filter(t => typeof t === 'string');
+        const entries = (targets.entries || []).filter(t => typeof t === 'string');
+        const neuron = (await this.peek(neuronRef)) || (await this.findByName(neuronRef));
+        if (!neuron)
+            return { neuron: null, verified: [], unmatched: [...facts, ...entries], retired: [] };
+        const verified = [];
+        let unmatched = [];
+        let retired = [];
+        const emitir = [];
+        const actualizada = await (0, fs_js_1.updateJSON)(this.brain.paths.neuron(neuron.id), current => {
+            const n = current || neuron;
+            const cuando = (0, fs_js_1.now)();
+            verified.length = 0;
+            unmatched = [];
+            retired = [];
+            emitir.length = 0;
+            for (const t of facts) {
+                const w = t.trim().toLowerCase();
+                const hits = n.facts.filter(f => (f.id || (0, hash_js_1.factId)(f.text)).toLowerCase() === w || f.text.trim().toLowerCase() === w);
+                const vivos = hits.filter(f => f.status !== 'superseded' && f.status !== 'retracted');
+                if (vivos.length === 0) {
+                    const r = hits.find(f => f.status === 'superseded' || f.status === 'retracted');
+                    if (r)
+                        retired.push({ target: t, id: r.id || (0, hash_js_1.factId)(r.text), status: r.status });
+                    unmatched.push(t);
+                    continue;
+                }
+                for (const f of vivos) {
+                    f.id = f.id || (0, hash_js_1.factId)(f.text);
+                    f.verified = cuando;
+                    if (!verified.includes(f.id))
+                        verified.push(f.id);
+                    emitir.push({ eid: f.id, ekind: 'fact', at: cuando });
+                }
+            }
+            const candidatas = [
+                ...n.decisions.map(d => ({ text: d.text || '', ids: [(0, ops_js_1.entryId)(d.text || ''), ...(d.id ? [d.id] : [])] })),
+                ...n.patterns.map(p => ({ text: p, ids: [(0, ops_js_1.entryId)(p)] })),
+            ];
+            for (const t of entries) {
+                const w = (0, ops_js_1.normalizeText)(t).toLowerCase();
+                const hits = candidatas.filter(c => c.ids.some(i => i.toLowerCase() === w) || (0, ops_js_1.normalizeText)(c.text).toLowerCase() === w);
+                const vivas = hits.filter(c => !n.entry_status?.[(0, ops_js_1.entryId)(c.text)]);
+                if (vivas.length === 0) {
+                    const r = hits[0];
+                    const est = r ? n.entry_status?.[(0, ops_js_1.entryId)(r.text)] : undefined;
+                    if (r && est)
+                        retired.push({ target: t, id: (0, ops_js_1.entryId)(r.text), status: est.status });
+                    unmatched.push(t);
+                    continue;
+                }
+                for (const c of vivas) {
+                    const k = (0, ops_js_1.entryId)(c.text);
+                    (n.entry_verified ||= {})[k] = cuando;
+                    if (!verified.includes(k))
+                        verified.push(k);
+                    emitir.push({ eid: k, ekind: 'entry', at: cuando });
+                }
+            }
+            if (verified.length === 0)
+                return null;
+            n.last_accessed = cuando;
+            return n;
+        });
+        const final = (actualizada || neuron);
+        // No reindex: neither the text nor the indexed date changed. `since`
+        // filters on when a line was recorded, not on when it was last checked.
+        for (const e of emitir)
+            await this.emit(final.id, { kind: 'verify', ...e });
+        return { neuron: final, verified: [...verified], unmatched, retired };
+    }
     /**
      * Which active facts does this text closely resemble?
      *
@@ -1438,6 +1598,16 @@ class Cortex {
                 if (Object.keys(current.entry_status).length === 0)
                     delete current.entry_status;
             }
+            // Verifications go with their entry too.
+            if (current.entry_verified) {
+                const vivos = liveEntryKeys(current);
+                for (const k of Object.keys(current.entry_verified)) {
+                    if (!vivos.has(k))
+                        delete current.entry_verified[k];
+                }
+                if (Object.keys(current.entry_verified).length === 0)
+                    delete current.entry_verified;
+            }
             // And for provenance: a forgotten teammate line that comes back through
             // a sync replay must be labelled by that replay, not by a stale key.
             if (current.entry_source) {
@@ -1627,7 +1797,10 @@ class Cortex {
             const fid = f.id || (0, hash_js_1.factId)(f.text);
             if (teniaFact.has(fid))
                 continue;
-            await this.emit(final.id, { kind: 'fact', text: f.text, fid, conf: f.confidence ?? 1, at: f.added, src: f.source, keys: f.keys });
+            await this.emit(final.id, { kind: 'fact', text: f.text, fid, conf: f.confidence ?? 1, at: f.added, src: f.source, keys: f.keys,
+                ...(f.shelf_life ? { shelf: f.shelf_life } : {}) });
+            if (f.verified)
+                await this.emit(final.id, { kind: 'verify', eid: fid, ekind: 'fact', at: f.verified });
             // A moved fact that was already retired must arrive retired, or the
             // teammates would see as current what the source had superseded.
             if (f.status === 'superseded' || f.status === 'retracted') {
@@ -1656,6 +1829,12 @@ class Cortex {
             if (!teniaDebt.has((0, ops_js_1.normalizeText)(d)))
                 await this.emit(final.id, { kind: 'debt', text: d, at: fecha(d) });
         }
+        // Checks of decisions and patterns that arrived with them, or are newer than the target's.
+        for (const [k, at] of Object.entries(final.entry_verified || {})) {
+            if (antes.entry_verified?.[k] === at)
+                continue;
+            await this.emit(final.id, { kind: 'verify', eid: k, ekind: 'entry', at });
+        }
         // Preferences are never emitted, here as in learn.
     }
     /**
@@ -1700,6 +1879,7 @@ class Cortex {
             tags: [], connections: [], summary: '', heat: 0, access_count: 0,
             entry_dates: { ...(from.entry_dates || {}) },
             entry_status: { ...(from.entry_status || {}) },
+            entry_verified: { ...(from.entry_verified || {}) },
         };
         delete parte.map;
         const textos = [