crbro-memory 2.9.1 → 2.11.0

package/dist/engine/evidence.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeReference = sanitizeReference;
+exports.readReference = readReference;
+exports.sanitizeTemporal = sanitizeTemporal;
+exports.makeVerification = makeVerification;
+exports.readVerification = readVerification;
+exports.mergeCheck = mergeCheck;
+exports.mergeFactEvidence = mergeFactEvidence;
+exports.mergeEntryEvidence = mergeEntryEvidence;
+exports.describeEvidence = describeEvidence;
+const secrets_js_1 = require("./secrets.js");
+const shelf_js_1 = require("./shelf.js");
+function safeText(value) {
+    if (typeof value !== 'string' || !value.trim() || value.length > 4096 || /[\u0000-\u001f]/.test(value)) {
+        throw new Error('Invalid source reference text.');
+    }
+    return (0, secrets_js_1.redact)(value.trim()).text;
+}
+/** Solo valida y redacta datos. Nunca abre archivos, URLs ni procesos. */
+function sanitizeReference(value) {
+    if (!value || typeof value !== 'object')
+        throw new Error('Invalid source reference.');
+    const r = value;
+    if (r.kind !== 'file' && r.kind !== 'url' && r.kind !== 'person')
+        throw new Error('Invalid reference kind.');
+    const clean = safeText(r.value);
+    if (r.kind === 'url') {
+        let url;
+        try {
+            url = new URL(String(r.value));
+        }
+        catch {
+            throw new Error('Invalid reference URL.');
+        }
+        const secretKey = /token|secret|password|passwd|api.?key|authorization|credential|signature|^sig$|access.?key/i;
+        const unsafeParams = (params) => [...params].some(([key, value]) => secretKey.test(key) || (0, secrets_js_1.redact)(value).found.length > 0);
+        if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || clean !== String(r.value).trim()
+            || unsafeParams(url.searchParams) || unsafeParams(new URLSearchParams(url.hash.slice(1)))) {
+            throw new Error('Unsafe reference URL: credentials or secret parameters are not allowed.');
+        }
+    }
+    return {
+        kind: r.kind, value: clean,
+        ...(r.field !== undefined ? { field: safeText(r.field) } : {}),
+        ...(r.project !== undefined ? { project: safeText(r.project) } : {}),
+    };
+}
+function readReference(value) {
+    try {
+        return sanitizeReference(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function sanitizeTemporal(value) {
+    if (value === undefined || value === 'current' || value === 'historical')
+        return value;
+    throw new Error('Invalid temporal value.');
+}
+function makeVerification(evidence, at) {
+    if (!Number.isFinite(Date.parse(at)))
+        throw new Error('Invalid verification date.');
+    if (evidence === undefined)
+        return { method: 'unspecified', at };
+    if (!evidence || (evidence.method !== 'source' && evidence.method !== 'user'))
+        throw new Error('Invalid verification method.');
+    const reference = evidence.reference === undefined ? undefined : sanitizeReference(evidence.reference);
+    if (evidence.method === 'source' && !reference)
+        throw new Error('Source verification requires a reference.');
+    return { method: evidence.method, at, ...(reference ? { reference } : {}) };
+}
+function readVerification(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const v = value;
+    if (typeof v.at !== 'string' || !(0, shelf_js_1.latestOf)(undefined, v.at))
+        return undefined;
+    try {
+        if (v.method === 'unspecified')
+            return { method: 'unspecified', at: v.at };
+        return makeVerification(v, v.at);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Fecha y evidencia forman una unidad: una fecha legacy nueva no hereda una fuente vieja. */
+function mergeCheck(a, b) {
+    const invalidated = (0, shelf_js_1.latestOf)(a.verification_invalidated_at, b.verification_invalidated_at);
+    const cutoff = invalidated ? Date.parse(invalidated) : -Infinity;
+    const candidates = [];
+    for (const c of [a, b]) {
+        if (typeof c.verified === 'string' && (0, shelf_js_1.latestOf)(undefined, c.verified))
+            candidates.push({ at: c.verified });
+        const v = readVerification(c.verification);
+        if (v)
+            candidates.push({ at: v.at, verification: v });
+    }
+    candidates.sort((x, y) => Date.parse(x.at) - Date.parse(y.at)
+        || compare(JSON.stringify(x.verification || null), JSON.stringify(y.verification || null))
+        || compare(x.at, y.at));
+    const chosen = candidates.filter(c => Date.parse(c.at) > cutoff).at(-1);
+    return {
+        ...(invalidated ? { verification_invalidated_at: invalidated } : {}),
+        ...(chosen ? { verified: chosen.at, ...(chosen.verification ? { verification: chosen.verification } : {}) } : {}),
+    };
+}
+const compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+/** Unión estable de metadatos sin fecha propia. Current gana para no ocultar caducidad. */
+function mergeFactEvidence(target, other) {
+    const check = mergeCheck(target, other);
+    const resetTime = (f) => Date.parse((0, shelf_js_1.latestOf)(undefined, f.verification_invalidated_at) || '') || 0;
+    const a = resetTime(target), b = resetTime(other);
+    const metadata = a === b ? [target, other] : [a > b ? target : other];
+    const references = metadata.map(f => readReference(f.reference))
+        .filter((r) => !!r).sort((a, b) => compare(JSON.stringify(a), JSON.stringify(b)));
+    if (references.length)
+        target.reference = references.at(-1);
+    else
+        delete target.reference;
+    const temporal = metadata.map(f => f.temporal);
+    if (temporal.includes('current'))
+        target.temporal = 'current';
+    else if (temporal.includes('historical'))
+        target.temporal = 'historical';
+    else
+        delete target.temporal;
+    if (check.verification_invalidated_at)
+        target.verification_invalidated_at = check.verification_invalidated_at;
+    if (check.verified)
+        target.verified = check.verified;
+    else if (check.verification_invalidated_at)
+        delete target.verified;
+    if (check.verification)
+        target.verification = check.verification;
+    else
+        delete target.verification;
+}
+function mergeEntryEvidence(target, source, live) {
+    const dates = {};
+    const evidence = {};
+    for (const k of [...live].sort()) {
+        const check = mergeCheck({ verified: target.entry_verified?.[k], verification: target.entry_verification?.[k] }, { verified: source.entry_verified?.[k], verification: source.entry_verification?.[k] });
+        if (check.verified)
+            dates[k] = check.verified;
+        if (check.verification)
+            evidence[k] = check.verification;
+    }
+    if (Object.keys(dates).length)
+        target.entry_verified = dates;
+    else
+        delete target.entry_verified;
+    if (Object.keys(evidence).length)
+        target.entry_verification = evidence;
+    else
+        delete target.entry_verification;
+}
+/** Proyección para recall/inspect; no modifica el historial ni inventa fuentes legacy. */
+function describeEvidence(neuron, id, kind, text) {
+    const f = kind === 'fact' ? neuron.facts.find(f => f.id === id || f.text === text) : undefined;
+    const check = mergeCheck(f || { verified: neuron.entry_verified?.[id], verification: neuron.entry_verification?.[id] }, {});
+    const reference = readReference(f?.reference);
+    const temporal = f?.temporal === 'current' || f?.temporal === 'historical' ? f.temporal : undefined;
+    return {
+        ...(reference ? { reference } : {}), ...(temporal ? { temporal } : {}),
+        ...(check.verified ? { verification: check.verification || { method: 'unspecified', at: check.verified } } : {}),
+    };
+}
+//# sourceMappingURL=evidence.js.map

package/dist/engine/heat.js

@@ -1,12 +1,19 @@
 "use strict";
 // ─── CRBRO Heat Score Engine ─────────────────────────────────────
 // Calculates relevance score based on frequency, recency, and connectivity
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HeatEngine = void 0;
 exports.recencyScore = recencyScore;
 exports.frequencyScore = frequencyScore;
 exports.connectivityScore = connectivityScore;
 exports.calculateHeat = calculateHeat;
+exports.heatStatePath = heatStatePath;
+exports.readHeatState = readHeatState;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
 const fs_js_1 = require("../utils/fs.js");
 // Weight constants
 const WEIGHT_FREQUENCY = 0.35;
@@ -56,67 +63,104 @@ function calculateHeat(accessCount, lastAccessed, connectionCount, maxAccessCoun
     // Round to 3 decimal places
     return Math.round(heat * 1000) / 1000;
 }
-// ─── Heat Manager ────────────────────────────────────────────────
+function heatStatePath(brain) {
+    return node_path_1.default.join(brain.paths.prefrontal, 'heat_state.json');
+}
+/** The derived heat state, or null when never computed or unreadable (it is rebuilt then). */
+async function readHeatState(brain) {
+    try {
+        const s = await (0, fs_js_1.readJSON)(heatStatePath(brain));
+        return s && s.version === 1 && s.neurons && typeof s.neurons === 'object' ? s : null;
+    }
+    catch {
+        return null;
+    }
+}
 class HeatEngine {
     brain;
     constructor(brain) {
         this.brain = brain;
     }
+    /** Neuron files the last pass could not parse: skipped, never fatal. */
+    lastUnreadable = [];
+    /** How many neuron files the last pass actually read (the rest came from the state). */
+    lastRead = 0;
     /**
      * Recalculate heat scores for all neurons.
      * Returns updated hot topics list.
      */
     async recalculate() {
         const ids = await (0, fs_js_1.listJSONFiles)(this.brain.paths.cortex);
-        // First pass — find maximums for normalization
+        const previo = (await readHeatState(this.brain))?.neurons || {};
+        const entradas = {};
+        const ilegibles = [];
+        let leidas = 0;
+        // First pass — inputs: from the state when the file has not changed,
+        // from the file otherwise.
         let maxAccess = 1;
         let maxConnections = 1;
-        const neurons = [];
         for (const id of ids) {
-            const neuron = await (0, fs_js_1.readJSON)(this.brain.paths.neuron(id));
-            if (!neuron)
+            const file = this.brain.paths.neuron(id);
+            let st;
+            try {
+                st = await node_fs_1.promises.stat(file);
+            }
+            catch {
                 continue;
-            neurons.push(neuron);
-            if (neuron.access_count > maxAccess)
-                maxAccess = neuron.access_count;
-            if (neuron.connections.length > maxConnections)
-                maxConnections = neuron.connections.length;
+            }
+            const antes = previo[id];
+            let e;
+            if (antes && antes.mtime === st.mtimeMs && antes.size === st.size) {
+                e = { ...antes };
+            }
+            else {
+                let neuron;
+                try {
+                    neuron = await (0, fs_js_1.readJSON)(file);
+                }
+                catch {
+                    ilegibles.push(id); // corrupted: skipped, the integrity check names it
+                    continue;
+                }
+                if (!neuron)
+                    continue;
+                leidas++;
+                e = {
+                    heat: 0,
+                    access_count: neuron.access_count || 0,
+                    last_accessed: neuron.last_accessed || neuron.created || '',
+                    connections: (neuron.connections || []).length,
+                    name: neuron.name || id,
+                    domain: neuron.domain || 'general',
+                    size: st.size,
+                    mtime: st.mtimeMs,
+                };
+            }
+            entradas[id] = e;
+            if (e.access_count > maxAccess)
+                maxAccess = e.access_count;
+            if (e.connections > maxConnections)
+                maxConnections = e.connections;
         }
-        // Second pass — calculate and update heat
+        // Second pass — calculate heat
         const hotTopics = [];
-        for (const neuron of neurons) {
-            const heat = calculateHeat(neuron.access_count, neuron.last_accessed, neuron.connections.length, maxAccess, maxConnections);
-            // Only touch the file when the number actually moved. Rewriting all
-            // neurons on every pass was pure churn — between two consecutive runs
-            // not one of them changes — and each rewrite is a window in which a
-            // concurrent write from another client gets clobbered.
-            if (Math.abs((neuron.heat ?? 0) - heat) > 1e-9) {
-                // Under lock and re-reading: heat runs over every neuron, so without
-                // this it would happily overwrite whatever another client just saved.
-                await (0, fs_js_1.updateJSON)(this.brain.paths.neuron(neuron.id), current => {
-                    if (!current)
-                        return null;
-                    current.heat = heat;
-                    return current;
-                });
-            }
-            neuron.heat = heat;
-            hotTopics.push({
-                id: neuron.id,
-                name: neuron.name,
-                heat,
-                last_access: neuron.last_accessed,
-                domain: neuron.domain,
-            });
+        for (const [id, e] of Object.entries(entradas)) {
+            e.heat = calculateHeat(e.access_count, e.last_accessed, e.connections, maxAccess, maxConnections);
+            hotTopics.push({ id, name: e.name, heat: e.heat, last_access: e.last_accessed, domain: e.domain });
         }
         // Sort by heat descending
-        hotTopics.sort((a, b) => b.heat - a.heat);
+        hotTopics.sort((a, b) => b.heat - a.heat || (a.id < b.id ? -1 : 1));
+        const cuando = (0, fs_js_1.now)();
+        const estado = { version: 1, computed_at: cuando, neurons: entradas };
+        await (0, fs_js_1.writeJSON)(heatStatePath(this.brain), estado, { pretty: false });
         // Save hot topics (top 20)
         const result = {
             topics: hotTopics.slice(0, 20),
-            last_recalculated: (0, fs_js_1.now)(),
+            last_recalculated: cuando,
         };
         await (0, fs_js_1.writeJSON)(this.brain.paths.hotTopics(), result);
+        this.lastUnreadable = ilegibles;
+        this.lastRead = leidas;
         return result;
     }
 }

package/dist/engine/hippocampus.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Hippocampus = void 0;
 exports.normalizeSessionId = normalizeSessionId;
 const fs_js_1 = require("../utils/fs.js");
+const quarantine_js_1 = require("./quarantine.js");
 const ids_js_1 = require("../utils/ids.js");
 const secrets_js_1 = require("./secrets.js");
 const SESSION_PREFIX = 'session_';
@@ -35,50 +36,63 @@ class Hippocampus {
         const limpio = (0, secrets_js_1.redact)(data.summary);
         data = { ...data, summary: limpio.text };
         const id = (0, ids_js_1.sessionId)();
-        // Check if session for today already exists — append to it
-        let existing = await (0, fs_js_1.readJSON)(this.brain.paths.session(id));
-        if (existing) {
-            // Append to existing session
-            existing.summary += `\n---\n${data.summary}`;
-            existing.topics_touched = [...new Set([...existing.topics_touched, ...data.topics_touched])];
-            existing.key_facts_added += data.key_facts_added || 0;
-            existing.decisions_made += data.decisions_made || 0;
-            existing.new_neurons_created += data.new_neurons_created || 0;
-            existing.synapses_updated += data.synapses_updated || 0;
-            await (0, fs_js_1.writeJSON)(this.brain.paths.session(id), existing);
-            return { ...existing, redacted: limpio.found };
-        }
-        // Create new session log
-        const session = {
-            session_id: id,
-            date: (0, fs_js_1.today)(),
-            duration_estimate: 'unknown',
-            topics_touched: data.topics_touched,
-            summary: data.summary,
-            key_facts_added: data.key_facts_added || 0,
-            decisions_made: data.decisions_made || 0,
-            new_neurons_created: data.new_neurons_created || 0,
-            synapses_updated: data.synapses_updated || 0,
-        };
-        await (0, fs_js_1.writeJSON)(this.brain.paths.session(id), session);
+        let created = false;
+        const saved = await (0, fs_js_1.updateJSON)(this.brain.paths.session(id), existing => {
+            if (existing) {
+                // Append to existing session
+                existing.summary += `\n---\n${data.summary}`;
+                existing.topics_touched = [...new Set([...existing.topics_touched, ...data.topics_touched])];
+                existing.key_facts_added += data.key_facts_added || 0;
+                existing.decisions_made += data.decisions_made || 0;
+                existing.new_neurons_created += data.new_neurons_created || 0;
+                existing.synapses_updated += data.synapses_updated || 0;
+                return existing;
+            }
+            // Create new session log
+            const session = {
+                session_id: id,
+                date: (0, fs_js_1.today)(),
+                duration_estimate: 'unknown',
+                topics_touched: data.topics_touched,
+                summary: data.summary,
+                key_facts_added: data.key_facts_added || 0,
+                decisions_made: data.decisions_made || 0,
+                new_neurons_created: data.new_neurons_created || 0,
+                synapses_updated: data.synapses_updated || 0,
+            };
+            created = true;
+            return session;
+        });
         // Update manifest
-        const manifest = await this.brain.getManifest();
-        await this.brain.updateManifest({ total_sessions: manifest.total_sessions + 1 });
-        return { ...session, redacted: limpio.found };
+        if (created) {
+            const manifest = await this.brain.getManifest();
+            await this.brain.updateManifest({ total_sessions: manifest.total_sessions + 1 });
+        }
+        return { ...saved, redacted: limpio.found };
     }
     /**
      * List recent sessions.
      */
     async listSessions(limit = 10) {
-        const ids = await (0, fs_js_1.listJSONFiles)(this.brain.paths.hippocampus);
+        // The names are session_YYYY-MM-DD: they sort by day, so only the newest
+        // `limit` files are read (2.11). Boot asks for 3 and used to parse all
+        // 146 logs of the reference brain to keep 3. An unreadable log is skipped.
+        const ids = (await (0, fs_js_1.listJSONFiles)(this.brain.paths.hippocampus)).sort().reverse();
         const sessions = [];
         for (const id of ids) {
-            const session = await (0, fs_js_1.readJSON)(this.brain.paths.session(id));
+            if (sessions.length >= limit)
+                break;
+            let session = null;
+            try {
+                session = await (0, fs_js_1.readJSON)(this.brain.paths.session(id));
+            }
+            catch { /* corrupt: skipped */ }
             if (session)
                 sessions.push(session);
         }
-        // Sort by date descending (newest first)
-        sessions.sort((a, b) => b.date.localeCompare(a.date));
+        // Sort by date descending (newest first): a log whose file name is not a
+        // day id still lands by its own date among the ones read.
+        sessions.sort((a, b) => String(b.date || '').localeCompare(String(a.date || '')));
         return sessions.slice(0, limit);
     }
     /**
@@ -124,9 +138,9 @@ class Hippocampus {
         const log = await (0, fs_js_1.readJSON)(ruta);
         if (!log)
             return { session_id, removed: false, backup: null };
-        const sello = (0, fs_js_1.now)().replace(/[:.]/g, '-');
-        const backup = `${this.brain.paths.quarantine}/${session_id}.${sello}.json`;
-        await (0, fs_js_1.writeJSON)(backup, log);
+        // Same quarantine as the cortex: retention, and sealed when encryption at
+        // rest is on (throws, deleting nothing, when it is on and keyless).
+        const backup = await (0, quarantine_js_1.writeQuarantine)(this.brain.paths.quarantine, session_id, log, 'whole');
         await (0, fs_js_1.deleteJSON)(ruta);
         const manifest = await this.brain.getManifest();
         await this.brain.updateManifest({ total_sessions: Math.max(0, manifest.total_sessions - 1) });