crbro-memory 2.10.0 → 2.11.0

package/dist/engine/doctor.js

@@ -3,7 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BACKUP_FAIL_DAYS = exports.BACKUP_WARN_DAYS = void 0;
 exports.diagnose = diagnose;
+exports.findings = findings;
 exports.formatDoctor = formatDoctor;
 // Diagnóstico observacional: no construye motores, no arranca servidores y no
 // abre el llavero. Las salidas se construyen por lista blanca, nunca volcados.
@@ -17,6 +19,9 @@ const backup_js_1 = require("./backup.js");
 const endpoint_js_1 = require("../daemon/endpoint.js");
 const proxy_js_1 = require("../daemon/proxy.js");
 const version_js_1 = require("../version.js");
+const hookverify_js_1 = require("./hookverify.js");
+const hookrefresh_js_1 = require("./hookrefresh.js");
+const installio_js_1 = require("./installio.js");
 async function readParsed(file) {
     let text;
     try {
@@ -184,6 +189,32 @@ function codexEntries(text) {
         }
         if (!inEnv && key === 'env')
             uncertain = true; // tabla inline no interpretada
+        // Sólo para comprobaciones booleanas (existe, usa npx) y los plazos: nunca se devuelven.
+        if (!inEnv && key === 'command') {
+            const m = /^"((?:\\.|[^"\\])*)"$|^'([^']*)'$/.exec(value);
+            if (m) {
+                try {
+                    current.command = m[2] ?? JSON.parse(`"${m[1]}"`);
+                }
+                catch { /* no interpretado */ }
+            }
+        }
+        if (!inEnv && key === 'args' && value.startsWith('[') && value.endsWith(']')) {
+            current.args = [...value.matchAll(/"((?:\\.|[^"\\])*)"|'([^']*)'/g)].map(x => {
+                try {
+                    return x[2] ?? JSON.parse(`"${x[1]}"`);
+                }
+                catch {
+                    return '';
+                }
+            });
+        }
+        if (!inEnv && (key === 'startup_timeout_sec' || key === 'tool_timeout_sec')) {
+            if (/^\+?\d+(\.\d+)?$/.test(value))
+                current[key] = Number(value);
+            else
+                uncertain = true;
+        }
     }
     return { entries: [...entries.values()], uncertain: uncertain || !!multiline };
 }
@@ -194,7 +225,7 @@ async function inspectConfigs(home, env, root, cwd) {
             : node_path_1.default.join(env.XDG_CONFIG_HOME || node_path_1.default.join(home, '.config'), 'Claude', 'claude_desktop_config.json');
     const locations = [
         { client: 'Claude Desktop', file: desktop },
-        { client: 'Claude Code', file: node_path_1.default.join(home, '.claude.json') },
+        { client: 'Claude Code', file: (0, installio_js_1.claudeJson)(home, env) },
         { client: 'Cursor', file: node_path_1.default.join(home, '.cursor', 'mcp.json') },
         { client: 'Codex', file: node_path_1.default.join(env.CODEX_HOME || node_path_1.default.join(home, '.codex'), 'config.toml') },
     ];
@@ -207,7 +238,9 @@ async function inspectConfigs(home, env, root, cwd) {
             continue;
         seen.add(canonical(location.file));
         const row = { client: location.client, path: location.file, exists: await exists(location.file),
-            status: 'unknown', registered: null, enabled: null, brain_paths: [], inherited_brain_path: false, client_autorun: 'unknown' };
+            status: 'unknown', registered: null, enabled: null, brain_paths: [], inherited_brain_path: false, client_autorun: 'unknown',
+            uses_npx: null, command_exists: null, script_exists: null, startup_timeout_sec: null, tool_timeout_sec: null };
+        let problem = false;
         let entries = [], uncertain = false;
         try {
             if (location.file.endsWith('.toml')) {
@@ -245,7 +278,25 @@ async function inspectConfigs(home, env, root, cwd) {
                         uncertain = true;
                 }
             }
-            row.status = uncertain ? 'unknown' : 'ok';
+            // What starts it: booleans only, never the command line (it can carry a token).
+            const first = entries.find(e => e && typeof e === 'object' && !Array.isArray(e));
+            if (first && typeof first.command === 'string') {
+                const command = first.command;
+                const args = Array.isArray(first.args) ? first.args.filter((a) => typeof a === 'string') : [];
+                row.uses_npx = /(^|[\\/])npx(\.cmd|\.exe)?$/i.test(command);
+                row.command_exists = node_path_1.default.isAbsolute(command) ? !!(await exists(command)) : (0, installio_js_1.findOnPath)(command, env) !== null;
+                const script = args.find(a => node_path_1.default.isAbsolute(a) && /\.(mjs|cjs|js)$/i.test(a));
+                row.script_exists = script ? !!(await exists(script)) : null;
+                if (row.command_exists === false || row.script_exists === false)
+                    problem = true;
+            }
+            if (location.file.endsWith('.toml') && first) {
+                row.startup_timeout_sec = typeof first.startup_timeout_sec === 'number' ? first.startup_timeout_sec : null;
+                row.tool_timeout_sec = typeof first.tool_timeout_sec === 'number' ? first.tool_timeout_sec : null;
+                if (row.startup_timeout_sec === null || row.tool_timeout_sec === null)
+                    problem = true;
+            }
+            row.status = uncertain ? 'unknown' : problem ? 'warning' : 'ok';
         }
         catch { /* missing, unreadable or unsupported: unknown, no raw error */ }
         clients.push(row);
@@ -255,7 +306,8 @@ async function inspectConfigs(home, env, root, cwd) {
         for (const file of client.brain_paths)
             paths.set(canonical(file), file);
     const distinct_brain_paths = [...paths.values()].sort();
-    return { status: distinct_brain_paths.length > 1 ? 'warning' : clients.some(c => c.status === 'unknown') ? 'unknown' : 'ok',
+    return { status: distinct_brain_paths.length > 1 || clients.some(c => c.status === 'warning') ? 'warning'
+            : clients.some(c => c.status === 'unknown') ? 'unknown' : 'ok',
         clients, distinct_brain_paths, different_brain_paths: distinct_brain_paths.length > 1,
         inherited_environment: 'unknown' };
 }
@@ -287,16 +339,163 @@ async function inspectSemantic(root, home, env) {
         && m.dtype === (env.CRBRO_SEMANTIC_DTYPE || 'q8') && bytes === m.ids.length * m.dim * 4;
     const index = { status: valid ? 'ok' : meta.status === 'missing' && bytes === null ? 'unknown' : 'warning',
         vectors: valid ? m.ids.length : null, metadata_present: meta.status !== 'missing', data_present: bytes !== null };
-    return { status: index.status === 'warning' ? 'warning' : 'unknown',
+    // A valid index is evidence it works; no index is no evidence (semantic recall not installed), not a fault.
+    return { status: index.status,
         mode, home: semanticHome, runtime_present, model_cache_present, index, operation: 'not_probed' };
 }
-async function inspectBackups(root, env, home) {
+const DAY_MS = 24 * 60 * 60 * 1000;
+/** Newest backup older than this: a warning; older than BACKUP_FAIL_DAYS: an error. */
+exports.BACKUP_WARN_DAYS = 2;
+exports.BACKUP_FAIL_DAYS = 7;
+async function inspectBackups(root, env, home, now) {
     const directory = (0, backup_js_1.resolveBackupDir)(root, env, home);
     const files = await (0, backup_js_1.listBackups)(directory);
-    return { status: files.length ? 'ok' : 'unknown', directory,
-        latest: files[0] ? { path: files[0].path, created: files[0].created, size_bytes: files[0].size_bytes } : null,
+    const latest = files[0] ? { path: files[0].path, created: files[0].created, size_bytes: files[0].size_bytes } : null;
+    const age_days = latest ? Math.max(0, Math.floor((now - Date.parse(latest.created)) / DAY_MS)) : null;
+    const brainThere = await exists(node_path_1.default.join(root, 'manifest.json'));
+    // Automatic copies come from consolidate once a day. A consolidate newer than
+    // the newest copy by more than a day, with them switched on, means they fail.
+    const enabled = !['0', 'off', 'false', 'no'].includes(String(env.CRBRO_AUTOBACKUP ?? '').trim().toLowerCase());
+    const manifest = await readParsed(node_path_1.default.join(root, 'manifest.json'));
+    const lastConsolidation = stamp(manifest.value?.last_consolidation);
+    const failing = !enabled || !lastConsolidation ? null
+        : (latest === null || Date.parse(lastConsolidation) - Date.parse(latest.created) > DAY_MS) && now - Date.parse(lastConsolidation) < exports.BACKUP_FAIL_DAYS * DAY_MS;
+    const status = !brainThere ? 'unknown'
+        : age_days === null ? 'warning'
+            : age_days > exports.BACKUP_FAIL_DAYS ? 'error'
+                : age_days > exports.BACKUP_WARN_DAYS || failing ? 'warning' : 'ok';
+    return { status, directory, latest, age_days, warn_after_days: exports.BACKUP_WARN_DAYS, fail_after_days: exports.BACKUP_FAIL_DAYS,
+        automatic: { enabled, last_consolidation: lastConsolidation, failing },
         integrity: 'not_probed' };
 }
+/** A pid that exists right now (signal 0 checks, it sends nothing). */
+function pidAlive(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return null;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === 'EPERM';
+    }
+}
+async function inspectHooks(home, env) {
+    const pkg = (0, hookrefresh_js_1.packageHooksDir)();
+    // dryRun: compares and reports, writes nothing.
+    const copies = (0, hookrefresh_js_1.refreshHooks)({ home, env, pkgHooks: pkg, dryRun: true });
+    const dirs = [
+        { client: 'claude-code', dir: (0, installio_js_1.claudeDir)(home, env), settings: 'settings.json' },
+        { client: 'codex', dir: (0, installio_js_1.codexHome)(home, env), settings: 'hooks.json' },
+    ];
+    const missing_scripts = [];
+    let settings_unreadable = false;
+    let npx_cache_references = 0;
+    for (const d of dirs) {
+        const settingsPath = node_path_1.default.join(d.dir, d.settings);
+        if (!(await exists(settingsPath)))
+            continue;
+        const v = (0, hookverify_js_1.verifyHooks)({ packageDir: pkg, installedDir: node_path_1.default.join(d.dir, 'crbro-hooks'), settingsPath });
+        missing_scripts.push(...v.missing_scripts);
+        settings_unreadable ||= v.settings_unreadable;
+        const parsed = await readParsed(settingsPath);
+        for (const list of Object.values(parsed.value?.hooks ?? {})) {
+            for (const entry of Array.isArray(list) ? list : []) {
+                for (const h of Array.isArray(entry?.hooks) ? entry.hooks : []) {
+                    const cmd = `${h?.command ?? ''} ${h?.commandWindows ?? ''}`;
+                    if (/crbro/i.test(cmd) && /[\\/]_npx[\\/]/.test(cmd))
+                        npx_cache_references++;
+                }
+            }
+        }
+    }
+    const installed = copies.map(c => ({ client: c.client, file: node_path_1.default.join(c.dir, c.name),
+        state: c.state === 'stale' ? 'older_release' : c.state }));
+    const status = missing_scripts.length || settings_unreadable || npx_cache_references
+        || installed.some(c => c.state === 'older_release' || c.state === 'modified') ? 'warning' : 'ok';
+    return { status, installed, missing_scripts: [...new Set(missing_scripts)].sort(), settings_unreadable, npx_cache_references };
+}
+async function inspectDaemonLeftovers(root, now) {
+    const dir = node_path_1.default.join(root, '.daemon');
+    let names = [];
+    try {
+        names = await node_fs_1.promises.readdir(dir);
+    }
+    catch {
+        return { status: 'ok', directory: dir, descriptors: 0, dead_descriptors: 0, orphan_tmp: 0 };
+    }
+    let descriptors = 0, dead = 0, orphan = 0;
+    for (const n of names) {
+        const file = node_path_1.default.join(dir, n);
+        if (/\.json$/.test(n)) {
+            descriptors++;
+            const st = await readParsed(file);
+            if (st.status === 'ok' && pidAlive(st.value?.pid) === false)
+                dead++;
+        }
+        else if (/\.tmp$/.test(n)) {
+            // A write that never finished: its writer is gone, or it is older than an hour.
+            const pid = Number(/\.(\d+)\.tmp$/.exec(n)?.[1]);
+            let old = false;
+            try {
+                old = now - (await node_fs_1.promises.stat(file)).mtimeMs > 60 * 60 * 1000;
+            }
+            catch {
+                continue;
+            }
+            if (old || pidAlive(pid) === false)
+                orphan++;
+        }
+    }
+    return { status: (dead || orphan ? 'warning' : 'ok'), directory: dir, descriptors, dead_descriptors: dead, orphan_tmp: orphan };
+}
+async function inspectQuarantine(root, env, now) {
+    const dir = node_path_1.default.join(root, '.quarantine');
+    const days = Number(env.CRBRO_QUARANTINE_DAYS ?? 180);
+    const retention_days = Number.isFinite(days) && days >= 0 ? days : 180;
+    let files = 0, bytes = 0, oldest = null;
+    const walk = async (d) => {
+        let entries;
+        try {
+            entries = await node_fs_1.promises.readdir(d, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            const p = node_path_1.default.join(d, e.name);
+            if (e.isDirectory()) {
+                await walk(p);
+                continue;
+            }
+            try {
+                const st = await node_fs_1.promises.stat(p);
+                files++;
+                bytes += st.size;
+                oldest = oldest === null ? st.mtimeMs : Math.min(oldest, st.mtimeMs);
+            }
+            catch { /* gone */ }
+        }
+    };
+    await walk(dir);
+    const oldest_days = oldest === null ? null : Math.floor((now - oldest) / DAY_MS);
+    const status = (retention_days > 0 && oldest_days !== null && oldest_days > retention_days) || bytes > 500 * 1024 * 1024 ? 'warning' : 'ok';
+    return { status, directory: dir, files, bytes, oldest_days, retention_days };
+}
+async function inspectTriggers(root, home, env) {
+    const file = node_path_1.default.join(root, '.search', 'triggers.json');
+    const parsed = await readParsed(file);
+    const settings = await readParsed(node_path_1.default.join((0, installio_js_1.claudeDir)(home, env), 'settings.json'));
+    const guard_wired = /crbro-guard/.test(JSON.stringify(settings.value?.hooks ?? {}));
+    const v = parsed.value;
+    const valid = parsed.status === 'ok' && v && typeof v === 'object' && v.keys && typeof v.keys === 'object' && Array.isArray(v.entries);
+    const version = valid && Number.isSafeInteger(v.v) ? v.v : null;
+    const status = parsed.status === 'invalid' || parsed.status === 'unreadable' ? 'warning'
+        : parsed.status === 'missing' ? (guard_wired ? 'warning' : 'ok')
+            : !valid || ![2, 3].includes(version ?? -1) ? 'warning' : 'ok';
+    return { status, path: file, exists: parsed.status !== 'missing', version, built: valid ? stamp(v.built) : null,
+        entries: valid ? v.entries.length : null, guard_wired };
+}
 function gitRead(dir, args, env) {
     return new Promise(resolve => {
         (0, node_child_process_1.execFile)('git', ['--no-optional-locks', '-c', 'core.fsmonitor=false', '-c', 'core.untrackedCache=false', '-C', dir, ...args], {
@@ -348,19 +547,114 @@ async function diagnose(options = {}) {
     const env = options.env ?? process.env;
     const home = node_path_1.default.resolve(options.homeDir || env.HOME || env.USERPROFILE || node_os_1.default.homedir());
     const root = node_path_1.default.resolve(options.brainDir || (0, brain_js_1.resolveBrainDir)({ ...env, HOME: home }, () => undefined));
-    const [brain, versions, configs, semantic, backups, teams] = await Promise.all([
+    const now = options.now ?? Date.now();
+    const [brain, versions, configs, semantic, backups, teams, hooks, daemon_leftovers, quarantine, triggers] = await Promise.all([
         inspectBrain(root), inspectVersions(root), inspectConfigs(home, env, root, options.cwd),
-        inspectSemantic(root, home, env), inspectBackups(root, env, home), inspectTeams(root, env),
+        inspectSemantic(root, home, env), inspectBackups(root, env, home, now), inspectTeams(root, env),
+        inspectHooks(home, env), inspectDaemonLeftovers(root, now), inspectQuarantine(root, env, now), inspectTriggers(root, home, env),
     ]);
-    const statuses = [brain.status, configs.status, semantic.status, backups.status, teams.status];
+    // A problem anywhere decides; otherwise a brain that reads well is "ok".
+    // What could not be observed (no daemon running, semantic not installed, a
+    // client not installed) is listed as not checked, never as a fault.
+    const statuses = [brain.status, configs.status, semantic.status, backups.status, teams.status,
+        hooks.status, daemon_leftovers.status, quarantine.status, triggers.status];
     const status = statuses.includes('error') ? 'error' : statuses.includes('warning') ? 'warning'
-        : statuses.includes('unknown') || versions.daemon_status === 'unknown' ? 'unknown' : 'ok';
-    return { schema_version: 1, read_only: true, status, versions, brain, configs, semantic, backups, teams };
+        : brain.status === 'ok' ? 'ok' : 'unknown';
+    return { schema_version: 1, read_only: true, status, versions, brain, configs, semantic, backups, teams,
+        hooks, daemon_leftovers, quarantine, triggers };
+}
+/** What the report means, in three lists, each with the command that fixes it. */
+function findings(report) {
+    const out = [];
+    const add = (level, text, action) => out.push({ level, text, action });
+    const b = report.brain;
+    if (b.exists === false)
+        add('unchecked', `no brain at ${b.path} yet`, 'npx crbro-memory init (or start any client: the first boot creates it)');
+    for (const f of b.invalid_json_paths)
+        add('problem', `invalid JSON: ${f}`, 'restore that file from a backup: npx crbro-memory backup list');
+    for (const f of b.unreadable_paths)
+        add('problem', `unreadable: ${f}`, 'check its permissions');
+    const k = report.backups;
+    if (k.status === 'error')
+        add('problem', `the newest backup is ${k.age_days} days old (${k.latest?.path})`, 'npx crbro-memory backup');
+    else if (k.status === 'warning' && k.latest === null)
+        add('warning', 'no backup yet', 'npx crbro-memory backup');
+    else if (k.status === 'warning')
+        add('warning', `the newest backup is ${k.age_days} day(s) old`, 'npx crbro-memory backup');
+    if (k.automatic.failing)
+        add('warning', `automatic backups look like they fail: consolidate ran on ${k.automatic.last_consolidation}, the newest copy is older`, `check that ${k.directory} is writable, then npx crbro-memory backup`);
+    for (const c of report.configs.clients) {
+        if (!c.registered)
+            continue;
+        if (c.command_exists === false)
+            add('warning', `${c.client}: the command its CRBRO registration runs does not exist (${c.path})`, 'npx crbro-memory install');
+        if (c.script_exists === false)
+            add('warning', `${c.client}: the script its CRBRO registration runs does not exist (${c.path})`, 'npx crbro-memory install');
+        if (c.client.startsWith('Codex') && (c.startup_timeout_sec === null || c.tool_timeout_sec === null)) {
+            add('warning', `${c.client}: [mcp_servers.crbro] has no ${c.startup_timeout_sec === null ? 'startup_timeout_sec' : 'tool_timeout_sec'}: a slow start loses the memory (${c.path})`, 'npx crbro-memory install-boot');
+        }
+        if (c.uses_npx)
+            add('unchecked', `${c.client} starts CRBRO through npx (works; a stable engine starts faster and keeps one daemon)`, 'npx crbro-memory install');
+    }
+    if (report.configs.different_brain_paths)
+        add('warning', `clients point at different brains: ${report.configs.distinct_brain_paths.join(', ')}`, 'set the same CRBRO_PATH in every client');
+    const h = report.hooks;
+    for (const c of h.installed) {
+        if (c.state === 'older_release')
+            add('warning', `hook from an older CRBRO: ${c.file}`, 'refreshed at the next crbro_boot, or now: npx crbro-memory install-hooks …');
+        if (c.state === 'modified')
+            add('warning', `hook edited by hand, not refreshed: ${c.file}`, 'keep it, or take this version (backup kept): run the install-hooks you used again');
+    }
+    for (const s of h.missing_scripts)
+        add('warning', `a hook runs ${s}, which does not exist: it fails in every session`, 'npx crbro-memory install-boot, or remove that hook');
+    if (h.npx_cache_references)
+        add('warning', `${h.npx_cache_references} CRBRO hook(s) run out of the npx cache, which disappears when it is cleaned`, 'npx crbro-memory install');
+    if (h.settings_unreadable)
+        add('warning', 'a client settings file with hooks is not valid JSON', 'fix the JSON by hand');
+    const d = report.daemon_leftovers;
+    if (d.dead_descriptors)
+        add('warning', `${d.dead_descriptors} daemon descriptor(s) of processes that are gone in ${d.directory}`, 'npx crbro-memory daemon status (removes them)');
+    if (d.orphan_tmp)
+        add('warning', `${d.orphan_tmp} unfinished temp file(s) in ${d.directory}`, 'safe to delete while no daemon starts');
+    const q = report.quarantine;
+    if (q.status === 'warning')
+        add('warning', `quarantine holds ${q.files} file(s), ${(q.bytes / 1048576).toFixed(1)} MB, the oldest ${q.oldest_days} day(s) old`, `review ${q.directory}`);
+    const t = report.triggers;
+    if (t.status === 'warning')
+        add('warning', t.exists ? `the guard's trigger index (${t.path}) is unreadable or an old format: the guard says nothing` : 'the guard is installed but its trigger index does not exist yet', 'npx crbro-memory guard --rebuild');
+    if (report.semantic.index.status === 'warning')
+        add('warning', 'the semantic vectors do not match their metadata', 'npx crbro-memory semantic build');
+    for (const s of report.teams.spaces)
+        if (s.status === 'warning')
+            add('warning', `team space ${s.path} is ${s.ahead} ahead / ${s.behind} behind`, 'crbro_boot syncs it');
+    if (report.versions.daemon_status !== 'ok')
+        add('unchecked', 'no daemon answered (normal when daemon mode is off or no client is open)');
+    if (report.semantic.index.status === 'unknown')
+        add('unchecked', 'semantic recall: no vectors yet (not installed, or never built)', 'npx crbro-memory semantic status');
+    add('unchecked', 'semantic operation and backup integrity: not_probed (doctor never loads the model or unpacks a backup)');
+    add('unchecked', 'whether each client runs crbro_boot on its own: unknown (doctor reads files, it does not start clients)');
+    return out;
 }
 function formatDoctor(report) {
     const show = (v) => v === null || v === undefined ? 'unknown' : String(v);
+    const list = findings(report);
+    const block = (title, level) => {
+        const items = list.filter(f => f.level === level);
+        if (!items.length)
+            return [];
+        return [title, ...items.map(f => `  • ${f.text}${f.action ? `\n      → ${f.action}` : ''}`), ''];
+    };
+    const verdict = report.status === 'ok' ? 'Everything observed is in order.'
+        : report.status === 'error' ? 'There are problems to fix (below).'
+            : report.status === 'warning' ? 'Working, with warnings (below).' : 'Not enough evidence to say (below).';
     return [
         `CRBRO doctor — read-only — ${report.status}`,
+        verdict,
+        '',
+        ...block('Problems:', 'problem'),
+        ...block('Warnings:', 'warning'),
+        ...block('Not checked:', 'unchecked'),
+        'Details:',
         `Installed: ${show(report.versions.installed)}`,
         `Running daemons: ${report.versions.daemons.map(d => show(d.running_version)).join(', ') || 'unknown'} (authenticated status only)`,
         `Brain: ${report.brain.path} [${report.brain.status}]`,
@@ -370,7 +664,11 @@ function formatDoctor(report) {
         ...report.configs.clients.map(c => `${c.client}: ${c.path} [${c.status}]; registered=${show(c.registered)}; enabled=${show(c.enabled)}; brain=${c.brain_paths.join(', ') || 'unknown (inherited)'}`),
         `Different configured brain paths: ${report.configs.different_brain_paths}`,
         `Semantic: ${report.semantic.mode}; runtime=${show(report.semantic.runtime_present)}; model cache=${show(report.semantic.model_cache_present)}; index=${report.semantic.index.status}; operation=not_probed`,
-        `Latest backup: ${report.backups.latest?.path || 'unknown'}; integrity=not_probed`,
+        `Latest backup: ${report.backups.latest?.path || 'unknown'}${report.backups.age_days !== null ? ` (${report.backups.age_days} day(s) old)` : ''}; integrity=not_probed`,
+        `Hooks: ${report.hooks.installed.map(h => `${node_path_1.default.basename(h.file)} (${h.client}) ${h.state}`).join(', ') || 'none installed'} [${report.hooks.status}]`,
+        `Daemon leftovers: ${report.daemon_leftovers.dead_descriptors} dead descriptor(s), ${report.daemon_leftovers.orphan_tmp} orphan temp file(s) [${report.daemon_leftovers.status}]`,
+        `Quarantine: ${report.quarantine.files} file(s), ${report.quarantine.bytes} bytes, oldest ${show(report.quarantine.oldest_days)} day(s) [${report.quarantine.status}]`,
+        `Trigger index: ${report.triggers.exists ? `v${show(report.triggers.version)}, ${show(report.triggers.entries)} lessons, built ${show(report.triggers.built)}` : 'none'}${report.triggers.guard_wired ? ' (guard wired)' : ''} [${report.triggers.status}]`,
         ...report.teams.spaces.map(s => `Team: ${s.path}; dirty=${show(s.dirty)}; worktree=${s.worktree_state}; ahead=${show(s.ahead)}; behind=${show(s.behind)}; remote=not_fetched`),
         `Team remote state: not_fetched. Unknown values are not evidence of a working integration.`,
     ].join('\n');

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_';
@@ -73,15 +74,25 @@ class Hippocampus {
      * 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);
     }
     /**
@@ -127,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) });