crbro-memory 2.9.1 → 2.11.0

package/dist/engine/synapses.js

@@ -3,13 +3,40 @@
 // Connection management between neurons with strength decay
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Synapses = void 0;
+exports.weeklyDecayFactor = weeklyDecayFactor;
+exports.decayedStrength = decayedStrength;
 const fs_js_1 = require("../utils/fs.js");
+const lock_js_1 = require("../utils/lock.js");
 const ids_js_1 = require("../utils/ids.js");
+const quarantine_js_1 = require("./quarantine.js");
 /** Strength is stored in [0, 1] with three decimals, like decay writes it. */
 function clampStrength(value) {
     const v = Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : 0;
     return Math.round(v * 1000) / 1000;
 }
+const DAY_MS = 86_400_000;
+/**
+ * Weekly decay factor by how long the link has been idle. Applied for the
+ * time actually elapsed since the last decay (2.11): until then the same
+ * factor hit on EVERY maintenance run, so a brain maintained daily pruned an
+ * idle link in a week and one maintained monthly in eight months.
+ */
+function weeklyDecayFactor(idleDays) {
+    if (idleDays > 90)
+        return 0.8;
+    if (idleDays > 30)
+        return 0.9;
+    if (idleDays > 7)
+        return 0.95;
+    return 1;
+}
+/** Strength after `elapsedDays` of decay at the rate an `idleDays` idle link gets. */
+function decayedStrength(strength, idleDays, elapsedDays) {
+    const f = weeklyDecayFactor(idleDays);
+    if (f === 1 || elapsedDays <= 0)
+        return strength;
+    return Math.round(strength * Math.pow(f, elapsedDays / 7) * 1000) / 1000;
+}
 class Synapses {
     brain;
     constructor(brain) {
@@ -17,43 +44,51 @@ class Synapses {
     }
     /**
      * Create or strengthen a synapse between two neurons.
+     *
+     * Every write goes through the same locked read-modify-write as the rest of
+     * the brain (2.11). Before, the synapse file and BOTH neurons were read and
+     * rewritten without a lock: a learn landing on a 1 MB neuron while
+     * consolidate linked it lost its fact, silently.
      */
     async connect(fromId, toId, type, context, options) {
         const id = (0, ids_js_1.synapseId)(fromId, toId);
-        let synapse = await (0, fs_js_1.readJSON)(this.brain.paths.synapse(id));
-        let action;
+        let action = 'strengthened';
         const absoluta = typeof options?.strength === 'number' ? clampStrength(options.strength) : undefined;
-        if (synapse) {
-            // Strengthen existing synapse
-            synapse.strength = absoluta !== undefined ? absoluta : Math.min(1.0, synapse.strength + 0.1);
-            synapse.co_access_count += 1;
-            synapse.last_co_access = (0, fs_js_1.now)();
-            if (context && !(options?.keepExistingContext && synapse.context)) {
-                synapse.context = context;
+        const synapse = await (0, fs_js_1.updateJSON)(this.brain.paths.synapse(id), existing => {
+            const cuando = (0, fs_js_1.now)();
+            if (existing) {
+                // Strengthen existing synapse
+                existing.strength = absoluta !== undefined ? absoluta : Math.min(1.0, existing.strength + 0.1);
+                existing.co_access_count += 1;
+                existing.last_co_access = cuando;
+                // A fresh co-access restarts the decay clock.
+                existing.decayed_at = cuando;
+                if (context && !(options?.keepExistingContext && existing.context)) {
+                    existing.context = context;
+                }
+                action = 'strengthened';
+                return existing;
             }
-            action = 'strengthened';
-        }
-        else {
-            // Create new synapse
-            synapse = {
+            action = 'created';
+            return {
                 id,
                 nodes: [fromId, toId],
                 strength: absoluta !== undefined ? absoluta : (options?.initialStrength ?? 0.5),
                 type,
                 context: context || '',
                 co_access_count: 1,
-                last_co_access: (0, fs_js_1.now)(),
+                last_co_access: cuando,
+                decayed_at: cuando,
             };
-            action = 'created';
-            // Update manifest
+        });
+        if (action === 'created') {
             const manifest = await this.brain.getManifest();
             await this.brain.updateManifest({ total_synapses: manifest.total_synapses + 1 });
         }
-        await (0, fs_js_1.writeJSON)(this.brain.paths.synapse(id), synapse);
         // Update neuron connection lists
         await this.addConnectionToNeuron(fromId, toId);
         await this.addConnectionToNeuron(toId, fromId);
-        return { synapse, action };
+        return { synapse: synapse, action };
     }
     /**
      * Remove one synapse and unlink both neurons. Absent → removed:false, no
@@ -61,10 +96,16 @@ class Synapses {
      */
     async disconnect(fromId, toId) {
         const id = (0, ids_js_1.synapseId)(fromId, toId);
-        const synapse = await (0, fs_js_1.readJSON)(this.brain.paths.synapse(id));
+        const file = this.brain.paths.synapse(id);
+        const synapse = await (0, lock_js_1.withLock)(file, async () => {
+            const s = await (0, fs_js_1.readJSON)(file).catch(() => null);
+            if (!s)
+                return null;
+            await (0, fs_js_1.deleteJSON)(file);
+            return s;
+        });
         if (!synapse)
             return { synapse_id: id, removed: false };
-        await (0, fs_js_1.deleteJSON)(this.brain.paths.synapse(id));
         // Remove from neuron connection lists. Use the nodes the file recorded,
         // not the ids the caller passed: the id is order-free and prefix-free, so
         // the caller's spelling may differ from what the neurons hold.
@@ -81,12 +122,15 @@ class Synapses {
      */
     async setStrength(fromId, toId, strength) {
         const id = (0, ids_js_1.synapseId)(fromId, toId);
-        const synapse = await (0, fs_js_1.readJSON)(this.brain.paths.synapse(id));
-        if (!synapse)
-            return null;
-        synapse.strength = clampStrength(strength);
-        await (0, fs_js_1.writeJSON)(this.brain.paths.synapse(id), synapse);
-        return synapse;
+        let found = false;
+        const s = await (0, fs_js_1.updateJSON)(this.brain.paths.synapse(id), current => {
+            if (!current)
+                return null;
+            found = true;
+            current.strength = clampStrength(strength);
+            return current;
+        });
+        return found ? s : null;
     }
     /**
      * Remove every synapse touching a neuron. Returns how many went. Used when
@@ -95,7 +139,7 @@ class Synapses {
     async removeAllFor(neuronId) {
         let removed = 0;
         for (const id of await (0, fs_js_1.listJSONFiles)(this.brain.paths.synapses)) {
-            const synapse = await (0, fs_js_1.readJSON)(this.brain.paths.synapse(id));
+            const synapse = await this.readSynapse(id);
             if (!synapse || !synapse.nodes.includes(neuronId))
                 continue;
             const r = await this.disconnect(synapse.nodes[0], synapse.nodes[1]);
@@ -117,7 +161,7 @@ class Synapses {
         if (fromId === intoId)
             return out;
         for (const id of await (0, fs_js_1.listJSONFiles)(this.brain.paths.synapses)) {
-            const synapse = await (0, fs_js_1.readJSON)(this.brain.paths.synapse(id));
+            const synapse = await this.readSynapse(id);
             if (!synapse || !synapse.nodes.includes(fromId))
                 continue;
             const other = synapse.nodes[0] === fromId ? synapse.nodes[1] : synapse.nodes[0];
@@ -130,24 +174,25 @@ class Synapses {
             const nuevoId = (0, ids_js_1.synapseId)(intoId, other);
             // Ids drop the type prefix, so two neurons differing only by prefix
             // yield the same synapse id: then the file stays, only the nodes move.
-            const existente = nuevoId === id ? null : await (0, fs_js_1.readJSON)(this.brain.paths.synapse(nuevoId));
-            if (existente) {
-                existente.strength = clampStrength(Math.max(existente.strength, synapse.strength));
-                existente.co_access_count = (existente.co_access_count || 0) + (synapse.co_access_count || 0);
-                if ((synapse.last_co_access || '') > (existente.last_co_access || '')) {
-                    existente.last_co_access = synapse.last_co_access;
+            let fusion = false;
+            await (0, fs_js_1.updateJSON)(this.brain.paths.synapse(nuevoId), existente => {
+                if (existente && nuevoId !== id) {
+                    fusion = true;
+                    existente.strength = clampStrength(Math.max(existente.strength, synapse.strength));
+                    existente.co_access_count = (existente.co_access_count || 0) + (synapse.co_access_count || 0);
+                    if ((synapse.last_co_access || '') > (existente.last_co_access || '')) {
+                        existente.last_co_access = synapse.last_co_access;
+                    }
+                    return existente;
                 }
-                await (0, fs_js_1.writeJSON)(this.brain.paths.synapse(nuevoId), existente);
+                return { ...synapse, id: nuevoId, nodes: [intoId, other] };
+            });
+            if (nuevoId !== id)
                 await (0, fs_js_1.deleteJSON)(this.brain.paths.synapse(id));
+            if (fusion)
                 out.merged++;
-            }
-            else {
-                const movido = { ...synapse, id: nuevoId, nodes: [intoId, other] };
-                await (0, fs_js_1.writeJSON)(this.brain.paths.synapse(nuevoId), movido);
-                if (nuevoId !== id)
-                    await (0, fs_js_1.deleteJSON)(this.brain.paths.synapse(id));
+            else
                 out.moved++;
-            }
             await this.removeConnectionFromNeuron(other, fromId);
             await this.addConnectionToNeuron(other, intoId);
             await this.addConnectionToNeuron(intoId, other);
@@ -166,7 +211,7 @@ class Synapses {
         const ids = await (0, fs_js_1.listJSONFiles)(this.brain.paths.synapses);
         const connections = [];
         for (const id of ids) {
-            const synapse = await (0, fs_js_1.readJSON)(this.brain.paths.synapse(id));
+            const synapse = await this.readSynapse(id);
             if (!synapse)
                 continue;
             if (!synapse.nodes.includes(neuronId))
@@ -174,8 +219,12 @@ class Synapses {
             if (minStrength && synapse.strength < minStrength)
                 continue;
             const targetId = synapse.nodes[0] === neuronId ? synapse.nodes[1] : synapse.nodes[0];
-            // Get target neuron name
-            const targetNeuron = await (0, fs_js_1.readJSON)(this.brain.paths.neuron(targetId));
+            // Get target neuron name. An unreadable neighbour shows by its id.
+            let targetNeuron = null;
+            try {
+                targetNeuron = await (0, fs_js_1.readJSON)(this.brain.paths.neuron(targetId));
+            }
+            catch { /* corrupt */ }
             const targetName = targetNeuron?.name || targetId;
             connections.push({
                 target_id: targetId,
@@ -197,36 +246,63 @@ class Synapses {
         return (0, fs_js_1.readJSON)(this.brain.paths.synapse(id));
     }
     /**
-     * Decay all synapses based on time since last co-access.
-     * Returns number of pruned synapses (strength fell below threshold).
+     * Decay all synapses by the time elapsed since each was last decayed, and
+     * prune the ones that fall below the threshold (a quarantine copy first).
+     * Returns how many were pruned — or, with dryRun, how many would be, with
+     * nothing written.
+     *
+     * A synapse written before 2.11 has no decayed_at: the first pass only
+     * stamps it, so upgrading never applies a backlog of decay at once.
      */
-    async decay(pruneThreshold = 0.05) {
+    async decay(pruneThreshold = 0.05, options) {
         const ids = await (0, fs_js_1.listJSONFiles)(this.brain.paths.synapses);
+        const ahora = options?.now ?? new Date();
+        const ahoraIso = ahora.toISOString();
         let pruned = 0;
         for (const id of ids) {
-            const synapse = await (0, fs_js_1.readJSON)(this.brain.paths.synapse(id));
-            if (!synapse)
+            const file = this.brain.paths.synapse(id);
+            const leida = await this.readSynapse(id);
+            if (!leida)
+                continue;
+            // An archived neuron's links wait for it, untouched (2.11).
+            if (options?.skipNodes && leida.nodes.some(n => options.skipNodes.has(n)))
                 continue;
-            // Calculate decay
-            const lastAccess = new Date(synapse.last_co_access).getTime();
-            const diffDays = (Date.now() - lastAccess) / (1000 * 60 * 60 * 24);
-            let decayFactor = 1.0;
-            if (diffDays > 90)
-                decayFactor = 0.8;
-            else if (diffDays > 30)
-                decayFactor = 0.9;
-            else if (diffDays > 7)
-                decayFactor = 0.95;
-            synapse.strength = Math.round(synapse.strength * decayFactor * 1000) / 1000;
-            if (synapse.strength < pruneThreshold) {
-                // Prune weak synapse: same path as an explicit disconnect.
-                const r = await this.disconnect(synapse.nodes[0], synapse.nodes[1]);
+            const idle = (ahora.getTime() - new Date(leida.last_co_access).getTime()) / DAY_MS;
+            const desde = leida.decayed_at ? Date.parse(leida.decayed_at) : NaN;
+            const elapsed = Number.isFinite(desde) ? (ahora.getTime() - desde) / DAY_MS : 0;
+            const nueva = decayedStrength(leida.strength, idle, elapsed);
+            if (nueva < pruneThreshold) {
+                if (options?.dryRun) {
+                    pruned++;
+                    continue;
+                }
+                // Prune weak synapse: same path as an explicit disconnect, after a
+                // copy — a link that took months to build is not deleted outright.
+                await (0, quarantine_js_1.writeQuarantine)(this.brain.paths.quarantine, leida.id || id, { ...leida, strength: nueva, pruned_at: ahoraIso }, 'whole');
+                const r = await this.disconnect(leida.nodes[0], leida.nodes[1]);
                 if (r.removed)
                     pruned++;
+                continue;
             }
-            else {
-                await (0, fs_js_1.writeJSON)(this.brain.paths.synapse(id), synapse);
-            }
+            if (options?.dryRun)
+                continue;
+            // Write only when something changes: the strength, or the first stamp.
+            // Unchanged, decayed_at stays where it was and the elapsed time keeps
+            // accumulating, so slow decay is not rounded away run after run.
+            if (nueva === leida.strength && leida.decayed_at)
+                continue;
+            await (0, fs_js_1.updateJSON)(file, current => {
+                if (!current)
+                    return null;
+                // Re-derived from the fresh read under the lock: a strengthen that
+                // landed meanwhile restarted the clock and is not undone.
+                const idleNow = (ahora.getTime() - new Date(current.last_co_access).getTime()) / DAY_MS;
+                const d = current.decayed_at ? Date.parse(current.decayed_at) : NaN;
+                const el = Number.isFinite(d) ? (ahora.getTime() - d) / DAY_MS : 0;
+                current.strength = Math.max(pruneThreshold, decayedStrength(current.strength, idleNow, el));
+                current.decayed_at = ahoraIso;
+                return current;
+            });
         }
         return pruned;
     }
@@ -238,21 +314,48 @@ class Synapses {
         return ids.length;
     }
     // ─── Private helpers ────────────────────────────────────────────
-    async addConnectionToNeuron(neuronId, connectedId) {
-        const neuron = await (0, fs_js_1.readJSON)(this.brain.paths.neuron(neuronId));
-        if (!neuron)
-            return;
-        if (!neuron.connections.includes(connectedId)) {
-            neuron.connections.push(connectedId);
-            await (0, fs_js_1.writeJSON)(this.brain.paths.neuron(neuronId), neuron);
+    /** A synapse file, or null when absent or unreadable (the integrity check names those). */
+    async readSynapse(id) {
+        try {
+            const s = await (0, fs_js_1.readJSON)(this.brain.paths.synapse(id));
+            return s && Array.isArray(s.nodes) && s.nodes.length === 2 ? s : null;
+        }
+        catch {
+            return null;
         }
     }
+    /**
+     * Locked, and never creating: a neuron deleted meanwhile is not brought
+     * back by a connection list. A corrupt neuron file throws — linking to it
+     * would mean rewriting a file nobody can read.
+     */
+    async addConnectionToNeuron(neuronId, connectedId) {
+        await (0, fs_js_1.updateJSON)(this.brain.paths.neuron(neuronId), current => {
+            if (!current)
+                return null;
+            if (!Array.isArray(current.connections))
+                current.connections = [];
+            if (current.connections.includes(connectedId))
+                return null;
+            current.connections.push(connectedId);
+            return current;
+        });
+    }
+    /** Locked; a missing or unreadable neuron is left alone, never a reason to stop a disconnect. */
     async removeConnectionFromNeuron(neuronId, connectedId) {
-        const neuron = await (0, fs_js_1.readJSON)(this.brain.paths.neuron(neuronId));
-        if (!neuron)
-            return;
-        neuron.connections = neuron.connections.filter(c => c !== connectedId);
-        await (0, fs_js_1.writeJSON)(this.brain.paths.neuron(neuronId), neuron);
+        try {
+            await (0, fs_js_1.updateJSON)(this.brain.paths.neuron(neuronId), current => {
+                if (!current)
+                    return null;
+                const antes = (current.connections || []).length;
+                current.connections = (current.connections || []).filter(c => c !== connectedId);
+                return current.connections.length === antes ? null : current;
+            });
+        }
+        catch (err) {
+            if (!(err instanceof fs_js_1.CorruptJSONError))
+                throw err;
+        }
     }
 }
 exports.Synapses = Synapses;

package/dist/engine/triggers.js

@@ -21,19 +21,36 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MAX_LESSONS = exports.TRIGGER_FILE = exports.TRIGGER_INDEX_VERSION = void 0;
 exports.keysOfCommand = keysOfCommand;
 exports.keysOfEntry = keysOfEntry;
+exports.projectMaps = projectMaps;
 exports.buildTriggerIndex = buildTriggerIndex;
+exports.projectOf = projectOf;
 exports.lessonsFor = lessonsFor;
 exports.triggerIndexPath = triggerIndexPath;
 exports.loadAllNeurons = loadAllNeurons;
 exports.writeTriggerIndex = writeTriggerIndex;
 const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = require("node:fs");
 const fs_js_1 = require("../utils/fs.js");
 const ops_js_1 = require("../sync/ops.js");
-exports.TRIGGER_INDEX_VERSION = 2; // 2: path: keys, so exploring a project wakes its lessons
+// 2: path: keys, so exploring a project wakes its lessons. 3 (2.11): each entry
+// says which projects it belongs to (p) and, when it is not the user's own,
+// where it came from (o); `projects` maps a folder or alias to its project.
+exports.TRIGGER_INDEX_VERSION = 3;
 exports.TRIGGER_FILE = 'triggers.json';
 const PREVIEW = 320;
 /** Lessons handed over per command. More than this is a lecture, and lectures get skimmed. */
 exports.MAX_LESSONS = 3;
+/**
+ * Subcommands that only look: `git status`, `gh repo view`… A lesson that
+ * mentions one in passing ("after git status showed…") is not about running it,
+ * so prose never makes a key of these — only a command in backticks does. They
+ * were most of the guard's noise: `git status` in one repo woke three lessons
+ * about another project because each said "git status" somewhere.
+ */
+const READ_ONLY = new Set(('git status|git log|git branch|git diff|git show|git remote|git config|git rev-parse|git ls-files|git blame|'
+    + 'gh repo view|gh pr view|gh pr list|gh pr status|gh pr checks|gh issue view|gh issue list|gh run list|gh run view|gh release view|gh release list|gh api|'
+    + 'npm ls|npm view|npm list|npm outdated|docker ps|docker images|docker logs|kubectl get|kubectl describe|kubectl logs|'
+    + 'gcloud config|aws sts|node --version|npm --version|python --version').split('|'));
 /** Programs whose next word names the action. Anything else needs backticks or a script name to count. */
 const HEADS = new Set(('git npm npx pnpm yarn bun bunx node deno python python3 py pip pipx uv firebase gcloud gsutil gh docker '
     + 'kubectl helm terraform wp composer php supabase vercel netlify wrangler aws az ssh scp rsync curl wget robocopy '
@@ -163,16 +180,71 @@ function keysOfEntry(text) {
         if (!next || !SUBCOMMAND.test(next) || PROSE.has(next))
             continue;
         const third = word(words[i + 2] || '');
-        keys.add(DEEP.has(`${w} ${next}`) && third && SUBCOMMAND.test(third) && !third.startsWith('-') && !PROSE.has(third) ? `${w} ${next} ${third}` : `${w} ${next}`);
+        const key = DEEP.has(`${w} ${next}`) && third && SUBCOMMAND.test(third) && !third.startsWith('-') && !PROSE.has(third) ? `${w} ${next} ${third}` : `${w} ${next}`;
+        if (READ_ONLY.has(key))
+            continue; // from backticks only
+        keys.add(key);
     }
     // A script is only a trigger as the thing that runs; a program pair needs a known program.
     return [...keys].filter(k => k.startsWith('path:') || (k.includes(' ') ? HEADS.has(k.split(' ')[0]) || WRAPPERS.has(k.split(' ')[0]) : SCRIPT.test(k)));
 }
-function buildTriggerIndex(neurons, builtAt = (0, fs_js_1.now)()) {
+/** "C:\\Work\\Shop-Site" and "shop_site" alike: lower case, every run of other characters one dash. */
+function slug(s) {
+    return s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+}
+/**
+ * Alias → project id, and neuron id → its projects. A neuron belongs to a
+ * project when the registry binds it (crbro_boot project_neurons), or when
+ * its id or name spells the project's folder name as whole words
+ * (`project_shop_site` and the alias `shop-site`). Aliases shorter than four
+ * characters name too much to count by name.
+ */
+function projectMaps(registry, neurons) {
+    const aliases = {};
+    const byNeuron = new Map();
+    const named = [];
+    for (const [key, p] of Object.entries(registry?.projects ?? {})) {
+        const id = typeof p?.id === 'string' ? p.id : key;
+        for (const a of [id, ...(Array.isArray(p?.aliases) ? p.aliases : [])]) {
+            if (typeof a !== 'string' || !a)
+                continue;
+            const lower = a.toLowerCase().replace(/\\/g, '/').replace(/\/+$/, '');
+            aliases[lower] = id;
+            const base = lower.split('/').pop() || lower;
+            aliases[base] ??= id;
+            const token = slug(base);
+            if (token.length >= 4 && !token.startsWith('project-'))
+                named.push({ id, token });
+        }
+        for (const n of Array.isArray(p?.neurons) ? p.neurons : []) {
+            if (!byNeuron.has(n))
+                byNeuron.set(n, new Set());
+            byNeuron.get(n).add(id);
+        }
+    }
+    for (const n of neurons) {
+        if (!n?.id)
+            continue;
+        const words = `-${slug(n.id)}-${slug(n.name || '')}-`;
+        for (const { id, token } of named) {
+            if (words.includes(`-${token}-`)) {
+                if (!byNeuron.has(n.id))
+                    byNeuron.set(n.id, new Set());
+                byNeuron.get(n.id).add(id);
+            }
+        }
+    }
+    return { aliases, byNeuron };
+}
+function buildTriggerIndex(neurons, builtAt = (0, fs_js_1.now)(), registry) {
     const index = { v: exports.TRIGGER_INDEX_VERSION, built: builtAt, keys: {}, entries: [] };
+    const { aliases, byNeuron } = projectMaps(registry, neurons);
+    if (Object.keys(aliases).length)
+        index.projects = aliases;
     for (const n of neurons) {
         if (!n || n.type === 'protocol')
             continue;
+        const projects = [...(byNeuron.get(n.id) ?? [])].sort();
         const lists = [['error', n.errors], ['debt', n.debts], ['pattern', n.patterns]];
         for (const [k, list] of lists) {
             for (const text of list || []) {
@@ -182,10 +254,13 @@ function buildTriggerIndex(neurons, builtAt = (0, fs_js_1.now)()) {
                 if (keys.length === 0)
                     continue;
                 const at = index.entries.length;
+                const origin = n.entry_source?.[(0, ops_js_1.entryId)(text)];
                 index.entries.push({
                     n: n.id, name: n.name, e: (0, ops_js_1.entryId)(text), k,
                     d: (n.entry_dates?.[(0, ops_js_1.entryId)(text)] || '').slice(0, 10),
                     t: text.length > PREVIEW ? `${text.slice(0, PREVIEW).trimEnd()}…` : text,
+                    ...(projects.length ? { p: projects } : {}),
+                    ...(origin ? { o: origin } : {}),
                 });
                 for (const key of keys)
                     (index.keys[key] ||= []).push(at);
@@ -194,15 +269,65 @@ function buildTriggerIndex(neurons, builtAt = (0, fs_js_1.now)()) {
     }
     return index;
 }
-/** What the hook would say for this command: errors first, then newest first, capped. */
-function lessonsFor(index, command, max = exports.MAX_LESSONS) {
-    const hits = new Set();
-    for (const k of keysOfCommand(command))
+/**
+ * The project a working folder belongs to, by the index's alias map: the
+ * folder itself, the repository root it is in, or their names. Mirrored in
+ * hooks/crbro-guard.mjs (tested).
+ */
+function projectOf(index, cwd) {
+    const map = index.projects;
+    if (!map || !cwd)
+        return null;
+    const candidates = [];
+    let dir = node_path_1.default.resolve(cwd);
+    for (let i = 0; i < 12; i++) {
+        candidates.push(dir);
+        if ((0, node_fs_1.existsSync)(node_path_1.default.join(dir, '.git')))
+            break;
+        const up = node_path_1.default.dirname(dir);
+        if (up === dir)
+            break;
+        dir = up;
+    }
+    // The folder and the repository root, by full path first, then by name.
+    const firstAndRoot = candidates.length > 1 ? [candidates[0], candidates[candidates.length - 1]] : candidates;
+    for (const c of firstAndRoot) {
+        const full = c.toLowerCase().replace(/\\/g, '/').replace(/\/+$/, '');
+        if (map[full])
+            return map[full];
+    }
+    for (const c of firstAndRoot) {
+        const name = node_path_1.default.basename(c).toLowerCase();
+        if (map[name])
+            return map[name];
+    }
+    return null;
+}
+/**
+ * What the hook would say for this command: the lessons whose keys it hits,
+ * from this project or from no project — another project's lesson speaks only
+ * when the command walks into that project's folder (a path: key) — never a
+ * teammate's or the miner's unless asked; this project's first, then errors,
+ * debts, patterns, newest first, capped.
+ */
+function lessonsFor(index, command, max = exports.MAX_LESSONS, opts = {}) {
+    const hits = new Map(); // entry → reached through a path: key
+    const walked = new Set(); // projects whose folder the command walks into
+    for (const k of keysOfCommand(command)) {
+        if (k.startsWith('path:') && index.projects?.[k.slice(5)])
+            walked.add(index.projects[k.slice(5)]);
         for (const i of index.keys[k] || [])
-            hits.add(i);
+            hits.set(i, hits.get(i) || k.startsWith('path:'));
+    }
+    const here = projectOf(index, opts.cwd);
     const rank = { error: 0, debt: 1, pattern: 2 };
-    return [...hits].map(i => index.entries[i])
-        .sort((a, b) => rank[a.k] - rank[b.k] || (a.d < b.d ? 1 : a.d > b.d ? -1 : a.e < b.e ? -1 : 1))
+    const mine = (l) => (here && l.p?.includes(here) ? 0 : 1);
+    return [...hits].map(([i, viaPath]) => ({ l: index.entries[i], viaPath }))
+        .filter(({ l, viaPath }) => !!l
+        && (!l.o || !!opts.allOrigins)
+        && (!l.p?.length || (here !== null && l.p.includes(here)) || viaPath || l.p.some(x => walked.has(x))))
+        .map(({ l }) => l)
+        .sort((a, b) => mine(a) - mine(b) || rank[a.k] - rank[b.k] || (a.d < b.d ? 1 : a.d > b.d ? -1 : a.e < b.e ? -1 : 1))
         .slice(0, max);
 }
 function triggerIndexPath(brain) {
@@ -229,7 +354,12 @@ async function loadAllNeurons(brain) {
 async function writeTriggerIndex(brain, preloaded) {
     try {
         const neurons = preloaded ?? await loadAllNeurons(brain);
-        const index = buildTriggerIndex(neurons);
+        let registry = null;
+        try {
+            registry = await (0, fs_js_1.readJSON)(node_path_1.default.join(brain.paths.root, 'projects.json'));
+        }
+        catch { /* no projects yet */ }
+        const index = buildTriggerIndex(neurons, (0, fs_js_1.now)(), registry);
         await (0, fs_js_1.writeJSON)(triggerIndexPath(brain), index, { pretty: false });
         return { entries: index.entries.length, keys: Object.keys(index.keys).length };
     }

package/dist/index.js

@@ -16,26 +16,60 @@ async function main() {
         return;
     }
     const { resolveBrainDir } = await import('./engine/brain.js');
-    const { daemonEnabled } = await import('./daemon/endpoint.js');
+    const { daemonEnabled, buildId } = await import('./daemon/endpoint.js');
+    const { trace, traceStart, TRACE_ON } = await import('./daemon/trace.js');
     const brainRoot = resolveBrainDir();
     if (daemonEnabled(brainRoot)) {
+        traceStart(brainRoot, 'proxy');
         const { runProxy, spawnDetachedDaemon } = await import('./daemon/proxy.js');
+        const { loadSurface } = await import('./daemon/surface.js');
+        const build = buildId();
+        // The answers to initialize and tools/list, from the snapshot the build
+        // wrote; without one (a bare tsc build) the proxy asks a real server here.
+        const surface = loadSurface(build) ?? undefined;
         const proxy = runProxy({
             input: process.stdin,
             output: process.stdout,
             brainRoot,
+            build,
+            surface,
             spawnDaemon: () => spawnDetachedDaemon(brainRoot),
             isEnabled: () => daemonEnabled(brainRoot),
             log: line => process.stderr.write(`[crbro] ${line}\n`), // stdout is the MCP wire
+            trace,
         });
         await proxy.closed;
         process.exit(0);
     }
+    traceStart(brainRoot, 'classic');
     const { StdioServerTransport } = await import('@modelcontextprotocol/sdk/server/stdio.js');
-    const { createServer } = await import('./server.js');
-    const server = createServer();
+    const { createServer, createEngines } = await import('./server.js');
+    const engines = createEngines();
+    const server = createServer(engines);
     const transport = new StdioServerTransport();
     await server.connect(transport);
+    // Classic mode only: write a dirty index before leaving (2.11).
+    const { flushOnExit } = await import('./search/index.js');
+    flushOnExit(engines.searchEngine);
+    trace('engine ready', 'server connected (the index loads at crbro_boot)');
+    if (TRACE_ON) {
+        // Only with the trace on: watch the wire for the two moments that matter.
+        const toolCalls = new Set();
+        const onmessage = transport.onmessage;
+        transport.onmessage = (m) => {
+            if (m?.method === 'tools/call' && m.id !== undefined)
+                toolCalls.add(m.id);
+            onmessage?.(m);
+        };
+        const send = transport.send.bind(transport);
+        transport.send = (m) => {
+            if (m?.result?.serverInfo)
+                trace('initialize answered', 'by the server', true);
+            else if (m?.id !== undefined && toolCalls.delete(m.id))
+                trace('first tool result', '', true);
+            return send(m);
+        };
+    }
 }
 main().catch((err) => {
     console.error('CRBRO Fatal Error:', err);