crbro-memory 2.9.1 → 2.11.0

package/dist/engine/modinstall.js

@@ -42,6 +42,7 @@ exports.modPaths = modPaths;
 exports.pathListSeparator = pathListSeparator;
 exports.sha256 = sha256;
 exports.modFiles = modFiles;
+exports.staleStaging = staleStaging;
 exports.readModState = readModState;
 exports.compareVersions = compareVersions;
 exports.installMod = installMod;
@@ -51,13 +52,17 @@ exports.formatModVerify = formatModVerify;
 exports.modSwitchedOff = modSwitchedOff;
 exports.takeModNotice = takeModNotice;
 exports.autoInstallMod = autoInstallMod;
+exports.hookRefreshSwitchedOff = hookRefreshSwitchedOff;
 exports.startModOnBoot = startModOnBoot;
+exports.takeHooksNotice = takeHooksNotice;
 exports.modNoticeOnBoot = modNoticeOnBoot;
 exports.resetModOnBoot = resetModOnBoot;
 const crypto_1 = require("crypto");
 const fs_1 = require("fs");
 const os_1 = require("os");
 const path_1 = __importDefault(require("path"));
+const installio_js_1 = require("./installio.js");
+const hookrefresh_js_1 = require("./hookrefresh.js");
 exports.MOD_NAME = 'crbro-pending';
 /** The local copy this mod grew out of: a folder in the list holding it is replaced. */
 exports.LEGACY_NAME = 'crbro-pendientes';
@@ -69,8 +74,9 @@ exports.PLUGIN_DIRS_VAR = 'CLAUDE_CODE_PLUGIN_DIRS';
 /** What the package ships but the install leaves out: tests and editor config. */
 const NOT_SHIPPED_TOP = new Set(['test', 'tsconfig.json', '.gitignore', '.npmignore', 'node_modules']);
 const NOT_SHIPPED_DIRS = new Set(['.claude-plugin/types']);
-function modPaths(home) {
-    const claudeDir = path_1.default.join(home, '.claude');
+/** Claude Code's folder is CLAUDE_CONFIG_DIR when set, as Claude Code itself reads it; ~/.claude otherwise. */
+function modPaths(home, env = process.env) {
+    const claudeDir = (0, installio_js_1.claudeDir)(home, env);
     return {
         claudeDir,
         settingsPath: path_1.default.join(claudeDir, 'settings.json'),
@@ -212,7 +218,7 @@ function readSettings(settingsPath) {
     return { ok: true, settings, indent, eol, hash };
 }
 /** Thrown by writeAtomic when settings.json changed after it was read: the caller merges again. */
-const SETTINGS_CHANGED = 'ESETTINGSCHANGED';
+const SETTINGS_CHANGED = installio_js_1.FILE_CHANGED;
 /** Errors a later start may well not meet (a file held open, an antivirus scan): never written down as a failure. */
 const TRANSIENT = new Set(['EBUSY', 'EPERM', 'EACCES', 'ENOTEMPTY', 'EEXIST', SETTINGS_CHANGED]);
 /**
@@ -226,43 +232,37 @@ const TRANSIENT = new Set(['EBUSY', 'EPERM', 'EACCES', 'ENOTEMPTY', 'EEXIST', SE
  * inherited ACL, and a hard link to settings.json is not kept.
  */
 function writeAtomic(settingsPath, settings, indent = 2, eol = '\n', expectHash) {
-    let target = settingsPath;
-    try {
-        if ((0, fs_1.lstatSync)(settingsPath).isSymbolicLink())
-            target = (0, fs_1.realpathSync)(settingsPath);
-    }
-    catch {
-        // Not there yet: written as a plain file.
-    }
-    let mode;
-    try {
-        mode = (0, fs_1.statSync)(target).mode & 0o777;
-    }
-    catch {
-        mode = undefined;
-    }
-    const tmp = `${target}.${process.pid}.tmp`;
+    // installio.writeGuarded: the same steps (symlink target, mode, line
+    // endings, hash checked again right before the rename), plus a timestamped
+    // copy of the file as it was, kept beside it (settings.json.crbro-bak-<stamp>).
+    (0, installio_js_1.writeGuarded)(settingsPath, (0, installio_js_1.jsonText)(settings, indent, eol), { expectHash });
+}
+function splitList(value, sep) {
+    return (value ?? '').split(sep).map(s => s.trim()).filter(Boolean);
+}
+const STAGING = /^crbro-pending\.(\d+)\.(tmp|old)$/;
+/**
+ * A staging or set-aside folder another run left behind, safe to remove: its
+ * owner's pid is gone (or it is this process's own). A live pid is another
+ * install under way — install-mod by hand beside a boot — and its folder is
+ * left alone, or that install would fail half way on its rename.
+ */
+function staleStaging(name, isAlive = pidAlive) {
+    const m = STAGING.exec(name);
+    if (!m)
+        return false;
+    const pid = Number(m[1]);
+    return pid === process.pid || !isAlive(pid);
+}
+function pidAlive(pid) {
     try {
-        let text = JSON.stringify(settings, null, indent) + '\n';
-        if (eol !== '\n')
-            text = text.replace(/\n/g, eol);
-        (0, fs_1.writeFileSync)(tmp, text, mode === undefined ? 'utf8' : { encoding: 'utf8', mode });
-        if (expectHash !== undefined && settingsFingerprint(target) !== expectHash) {
-            const changed = new Error(`${settingsPath} changed while it was being written.`);
-            changed.code = SETTINGS_CHANGED;
-            throw changed;
-        }
-        (0, fs_1.renameSync)(tmp, target);
+        process.kill(pid, 0);
+        return true;
     }
     catch (e) {
-        (0, fs_1.rmSync)(tmp, { force: true });
-        throw e;
+        return e.code === 'EPERM';
     }
 }
-function splitList(value, sep) {
-    return (value ?? '').split(sep).map(s => s.trim()).filter(Boolean);
-}
-const STAGING = /^crbro-pending\.\d+\.(tmp|old)$/;
 function copyFailed(installedDir, e) {
     const err = new Error(`could not replace ${installedDir} (${e.message}).\n` +
         '     Close the sessions and terminals using that folder and run it again.');
@@ -280,7 +280,7 @@ function copyMod(packageDir, installedDir) {
     (0, fs_1.mkdirSync)(parent, { recursive: true });
     // A staging or set-aside folder left by a run that failed half way: its pid is gone.
     for (const name of (0, fs_1.readdirSync)(parent)) {
-        if (STAGING.test(name))
+        if (staleStaging(name))
             (0, fs_1.rmSync)(path_1.default.join(parent, name), { recursive: true, force: true, maxRetries: 3 });
     }
     const staging = `${installedDir}.${process.pid}.tmp`;
@@ -326,7 +326,7 @@ async function copyModAsync(packageDir, installedDir) {
     const parent = path_1.default.dirname(installedDir);
     await fs_1.promises.mkdir(parent, { recursive: true });
     for (const name of await fs_1.promises.readdir(parent)) {
-        if (STAGING.test(name))
+        if (staleStaging(name))
             await fs_1.promises.rm(path_1.default.join(parent, name), { recursive: true, force: true, maxRetries: 3 });
     }
     const staging = `${installedDir}.${process.pid}.tmp`;
@@ -1290,33 +1290,67 @@ async function autoInstallMod(opts) {
     }
 }
 let onBoot = null;
+/** The refresh of installed hook copies (hookrefresh.ts), started beside the mod's install, once per process. */
+let hooksOnBoot = null;
+let hooksResult = null;
+let hooksNoticeTaken = false;
+/** CRBRO_HOOK_REFRESH=0 (off, false, no) keeps installed hook copies as they are. */
+function hookRefreshSwitchedOff(env = process.env) {
+    return exports.MOD_OFF_VALUES.has(String(env.CRBRO_HOOK_REFRESH ?? '').trim().toLowerCase());
+}
 /**
  * What crbro_boot calls first: starts the automatic install the first time in
  * this process and returns the function to call once the boot has its answer
  * ready. That function waits for the install until `budgetMs` after the start
  * and takes the notice waiting to be said, or null. Neither throws. A boot
  * that fails never calls it, so it never takes a notice it cannot hand over.
+ *
+ * It also starts, once per process, the refresh of the hook copies CRBRO
+ * installed (hookrefresh.ts): unmodified copies of an older release are
+ * replaced by this one's. That part does not depend on CRBRO_MOD (it never
+ * adds anything, only keeps current what is there); CRBRO_HOOK_REFRESH=0
+ * turns it off. Its notice is taken with takeHooksNotice().
  */
 function startModOnBoot(opts = {}) {
     try {
         const home = opts.home ?? (0, os_1.homedir)();
         const env = opts.env ?? process.env;
-        if (modSwitchedOff(env) || !(0, fs_1.existsSync)(modPaths(home).claudeDir))
-            return async () => null;
-        if (!onBoot) {
-            const packageDir = opts.packageDir ?? path_1.default.join(__dirname, '..', '..', 'mods', exports.MOD_NAME);
-            onBoot = autoInstallMod({ ...opts, home, env, packageDir })
-                .catch(e => ({ action: 'failed', reason: e.message }));
+        if (!hooksOnBoot && !hookRefreshSwitchedOff(env)) {
+            hooksOnBoot = new Promise(resolve => setImmediate(() => {
+                try {
+                    resolve((0, hookrefresh_js_1.refreshHooks)({ home, env }));
+                }
+                catch {
+                    resolve([]);
+                }
+            })).then(copies => { hooksResult = copies; return copies; });
         }
-        const running = onBoot;
+        const hooks = hooksOnBoot ?? Promise.resolve([]);
         let timer;
         const budget = new Promise(resolve => {
             timer = setTimeout(resolve, opts.budgetMs ?? exports.BOOT_BUDGET_MS);
             timer.unref?.();
         });
+        if (modSwitchedOff(env) || !(0, fs_1.existsSync)(modPaths(home, env).claudeDir)) {
+            return async () => {
+                try {
+                    await Promise.race([hooks, budget]);
+                }
+                catch { /* never fails the boot */ }
+                if (timer)
+                    clearTimeout(timer);
+                return null;
+            };
+        }
+        if (!onBoot) {
+            const packageDir = opts.packageDir ?? path_1.default.join(__dirname, '..', '..', 'mods', exports.MOD_NAME);
+            onBoot = autoInstallMod({ ...opts, home, env, packageDir })
+                .catch(e => ({ action: 'failed', reason: e.message }));
+        }
+        const running = onBoot;
         return async () => {
             try {
-                await Promise.race([running, budget]);
+                await Promise.race([Promise.all([running, hooks]), budget]);
                 if (timer)
                     clearTimeout(timer);
                 return takeModNotice(home, opts.now);
@@ -1330,6 +1364,22 @@ function startModOnBoot(opts = {}) {
         return async () => null;
     }
 }
+/**
+ * The boot's notice about installed hooks, once per process, if the refresh
+ * has finished: copies left alone because somebody edited them, or a refresh
+ * that failed. Each edited copy is told once (remembered in its manifest).
+ */
+function takeHooksNotice() {
+    if (hooksNoticeTaken || !hooksResult)
+        return null;
+    hooksNoticeTaken = true;
+    try {
+        return (0, hookrefresh_js_1.hooksNotice)(hooksResult);
+    }
+    catch {
+        return null;
+    }
+}
 /** startModOnBoot and its notice in one call. */
 async function modNoticeOnBoot(opts = {}) {
     return startModOnBoot(opts)();
@@ -1337,6 +1387,9 @@ async function modNoticeOnBoot(opts = {}) {
 /** Tests only: the next boot in this process behaves as the first boot of a new process. */
 function resetModOnBoot() {
     onBoot = null;
+    hooksOnBoot = null;
+    hooksResult = null;
+    hooksNoticeTaken = false;
     handedOver.clear();
 }
 //# sourceMappingURL=modinstall.js.map

package/dist/engine/prefrontal.js

@@ -3,9 +3,11 @@
 // Active context, hot topics, and global map (clustering + bridges)
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Prefrontal = void 0;
+exports.sortOpenItems = sortOpenItems;
 const fs_js_1 = require("../utils/fs.js");
 const hash_js_1 = require("../utils/hash.js");
 const secrets_js_1 = require("./secrets.js");
+const heat_js_1 = require("./heat.js");
 /** How many resolved items to keep around as a reminder. */
 const RECENTLY_CLOSED_CAP = 15;
 /** Normalise a stored entry: v1 brains hold plain strings. */
@@ -15,6 +17,33 @@ function toTask(entry) {
     }
     return entry;
 }
+function normalizeContext(ctx) {
+    return {
+        last_session: '', active_topics: [], last_updated: (0, fs_js_1.now)(), ...ctx,
+        pending_tasks: (ctx?.pending_tasks || []).map(toTask),
+        recently_closed: ctx?.recently_closed || [],
+    };
+}
+/**
+ * The one order open items are read in, whatever the scope: what is due
+ * first, then the newest. A cap applied after it keeps what matters now; the
+ * insertion order kept the oldest, so a boot without a project showed the
+ * twelve items nobody had touched in months.
+ */
+function sortOpenItems(items) {
+    return [...items].sort((a, b) => (a.due || '9999').localeCompare(b.due || '9999') || String(b.added || '').localeCompare(String(a.added || '')));
+}
+function projectView(ctx, project) {
+    if (!project)
+        return ctx;
+    const visible = (t) => !t.project || t.project === project;
+    return {
+        ...ctx, active_topics: ctx.project_topics?.[project] || [],
+        project_topics: ctx.project_topics?.[project] ? { [project]: ctx.project_topics[project] } : {},
+        pending_tasks: sortOpenItems(ctx.pending_tasks.map(toTask).filter(visible)),
+        recently_closed: (ctx.recently_closed || []).filter(visible),
+    };
+}
 class Prefrontal {
     brain;
     constructor(brain) {
@@ -24,21 +53,9 @@ class Prefrontal {
     /**
      * Get the current active context.
      */
-    async getContext() {
+    async getContext(project) {
         const ctx = await (0, fs_js_1.readJSON)(this.brain.paths.activeContext());
-        if (!ctx) {
-            return {
-                last_session: '',
-                active_topics: [],
-                pending_tasks: [],
-                recently_closed: [],
-                last_updated: (0, fs_js_1.now)(),
-            };
-        }
-        // Upgrade v1 string entries in memory; they get written back on next update.
-        ctx.pending_tasks = (ctx.pending_tasks || []).map(toTask);
-        ctx.recently_closed = ctx.recently_closed || [];
-        return ctx;
+        return projectView(normalizeContext(ctx), project);
     }
     /**
      * Update the active context.
@@ -48,76 +65,106 @@ class Prefrontal {
      * timestamp said "changed just now" about a context nobody had changed.
      */
     async updateContext(updates) {
-        const ctx = await this.getContext();
+        if (updates.project && !/^[a-zA-Z0-9_-]{1,100}$/.test(updates.project))
+            throw new Error('Invalid project id.');
+        if (updates.due && (!/^\d{4}-\d{2}-\d{2}$/.test(updates.due) ||
+            !Number.isFinite(Date.parse(updates.due)) || new Date(updates.due).toISOString().slice(0, 10) !== updates.due)) {
+            throw new Error('Invalid due date; use a real YYYY-MM-DD calendar day.');
+        }
         const hayCambio = updates.clear === true ||
             updates.set_topics !== undefined ||
             (updates.add_pending !== undefined && updates.add_pending !== '') ||
             (updates.resolve_pending !== undefined && updates.resolve_pending !== '') ||
             (updates.discard_pending !== undefined && updates.discard_pending !== '');
         if (!hayCambio) {
-            return { ...ctx, resolved: [], discarded: [], written: false };
-        }
-        if (updates.clear) {
-            ctx.active_topics = [];
-            ctx.pending_tasks = [];
-            ctx.recently_closed = [];
+            return { ...await this.getContext(updates.project), resolved: [], discarded: [], written: false };
         }
-        let tasks = ctx.pending_tasks.map(toTask);
         let resolved = [];
         let discarded = [];
         let redacted = [];
-        if (updates.set_topics) {
-            ctx.active_topics = updates.set_topics;
-        }
-        if (updates.add_pending) {
-            // An open item is read back by crbro_boot in every session and copied
-            // into compaction checkpoints: it goes through the same filter as learn.
-            const filtrado = (0, secrets_js_1.redact)(updates.add_pending.trim());
-            redacted = filtrado.found;
-            const text = filtrado.text;
-            const id = (0, hash_js_1.pendingId)(text);
-            if (!tasks.some(t => t.id === id)) {
-                tasks.push({ id, text, added: (0, fs_js_1.now)() });
+        let added;
+        const saved = await (0, fs_js_1.updateJSON)(this.brain.paths.activeContext(), current => {
+            const ctx = normalizeContext(current);
+            if (updates.clear) {
+                if (updates.project) {
+                    delete ctx.project_topics?.[updates.project];
+                    ctx.pending_tasks = ctx.pending_tasks.map(toTask).filter(t => t.project !== updates.project);
+                    ctx.recently_closed = ctx.recently_closed?.filter(t => t.project !== updates.project);
+                }
+                else {
+                    ctx.active_topics = [];
+                    ctx.project_topics = {};
+                    ctx.pending_tasks = [];
+                    ctx.recently_closed = [];
+                }
             }
-        }
-        // Id, exact text, or a case-insensitive substring of at least 8 chars in
-        // either direction — the same predicate for resolving and discarding.
-        const matcher = (needleRaw) => {
-            const needle = needleRaw.trim();
-            const lower = needle.toLowerCase();
-            return (t) => t.id === needle ||
-                t.text === needle ||
-                (lower.length >= 8 &&
-                    (t.text.toLowerCase().includes(lower) || lower.includes(t.text.toLowerCase())));
-        };
-        if (updates.resolve_pending) {
-            const hit = matcher(updates.resolve_pending);
-            resolved = tasks.filter(hit).map(t => ({ ...t, closed: (0, fs_js_1.now)() }));
-            tasks = tasks.filter(t => !hit(t));
-            if (resolved.length > 0) {
-                ctx.recently_closed = [...resolved, ...(ctx.recently_closed || [])]
-                    .slice(0, RECENTLY_CLOSED_CAP);
+            let tasks = ctx.pending_tasks.map(toTask);
+            if (updates.set_topics) {
+                if (updates.project)
+                    (ctx.project_topics ||= {})[updates.project] = updates.set_topics;
+                else
+                    ctx.active_topics = updates.set_topics;
             }
-        }
-        if (updates.discard_pending) {
-            const hit = matcher(updates.discard_pending);
-            discarded = tasks.filter(hit);
-            tasks = tasks.filter(t => !hit(t));
-        }
-        ctx.pending_tasks = tasks;
-        ctx.last_updated = (0, fs_js_1.now)();
-        await (0, fs_js_1.writeJSON)(this.brain.paths.activeContext(), ctx);
-        return { ...ctx, resolved, discarded, written: true, ...(redacted.length ? { redacted } : {}) };
+            if (updates.add_pending) {
+                // An open item is read back by crbro_boot in every session and copied
+                // into compaction checkpoints: it goes through the same filter as learn.
+                const filtrado = (0, secrets_js_1.redact)(updates.add_pending.trim());
+                redacted = filtrado.found;
+                const text = filtrado.text;
+                const id = (0, hash_js_1.pendingId)(updates.project ? `${updates.project}\n${text}` : text);
+                const criterion = updates.done_when ? (0, secrets_js_1.redact)(updates.done_when) : undefined;
+                redacted.push(...(criterion?.found || []));
+                const existing = tasks.find(t => t.id === id);
+                const metadata = {
+                    ...(updates.project ? { project: updates.project } : {}),
+                    ...(updates.due ? { due: updates.due } : {}),
+                    ...(criterion ? { done_when: criterion.text } : {}),
+                };
+                if (existing)
+                    Object.assign(existing, metadata);
+                else
+                    tasks.push({ id, text, added: (0, fs_js_1.now)(), status: 'open', ...metadata });
+                added = { ...(existing ?? tasks[tasks.length - 1]) };
+            }
+            // Id, exact text, or a case-insensitive substring of at least 8 chars in
+            // either direction — the same predicate for resolving and discarding.
+            const matcher = (needleRaw) => {
+                const needle = needleRaw.trim();
+                const lower = needle.toLowerCase();
+                return (t) => (!updates.project || !t.project || t.project === updates.project) && (t.id === needle ||
+                    t.text === needle ||
+                    (lower.length >= 8 &&
+                        (t.text.toLowerCase().includes(lower) || lower.includes(t.text.toLowerCase()))));
+            };
+            if (updates.resolve_pending) {
+                const hit = matcher(updates.resolve_pending);
+                resolved = tasks.filter(hit).map(t => ({ ...t, closed: (0, fs_js_1.now)(), status: 'done' }));
+                tasks = tasks.filter(t => !hit(t));
+                if (resolved.length > 0) {
+                    ctx.recently_closed = [...resolved, ...(ctx.recently_closed || [])]
+                        .slice(0, RECENTLY_CLOSED_CAP);
+                }
+            }
+            if (updates.discard_pending) {
+                const hit = matcher(updates.discard_pending);
+                discarded = tasks.filter(hit);
+                tasks = tasks.filter(t => !hit(t));
+            }
+            ctx.pending_tasks = tasks;
+            ctx.last_updated = (0, fs_js_1.now)();
+            return ctx;
+        });
+        return { ...projectView(saved, updates.project), resolved, discarded, written: true,
+            ...(redacted.length ? { redacted } : {}), ...(added ? { added } : {}) };
     }
     /**
      * Record which session was logged last. Nothing else in the context moves.
      * Before this, nothing ever wrote last_session, so boot reported null forever.
      */
     async setLastSession(sessionId) {
-        const ctx = await this.getContext();
-        ctx.last_session = sessionId;
-        ctx.last_updated = (0, fs_js_1.now)();
-        await (0, fs_js_1.writeJSON)(this.brain.paths.activeContext(), ctx);
+        await (0, fs_js_1.updateJSON)(this.brain.paths.activeContext(), current => ({
+            ...normalizeContext(current), last_session: sessionId, last_updated: (0, fs_js_1.now)(),
+        }));
     }
     // ─── Hot Topics ─────────────────────────────────────────────────
     /**
@@ -147,10 +194,20 @@ class Prefrontal {
     async getGlobalMap() {
         const ids = await (0, fs_js_1.listJSONFiles)(this.brain.paths.cortex);
         const neurons = [];
+        // Heat lives in the derived heat state since 2.11; a neuron file keeps
+        // the value it had when heat stopped being written into it.
+        const calor = (await (0, heat_js_1.readHeatState)(this.brain))?.neurons || {};
         for (const id of ids) {
-            const neuron = await (0, fs_js_1.readJSON)(this.brain.paths.neuron(id));
-            if (neuron)
-                neurons.push(neuron);
+            // 2.11 (C1): an unreadable neuron is skipped, not the end of maintenance or the map.
+            let neuron = null;
+            try {
+                neuron = await (0, fs_js_1.readJSON)(this.brain.paths.neuron(id));
+            }
+            catch { /* corrupt: skipped */ }
+            if (!neuron)
+                continue;
+            const h = calor[neuron.id]?.heat;
+            neurons.push(typeof h === 'number' ? { ...neuron, heat: h } : neuron);
         }
         // Build clusters by domain
         const domainGroups = {};

package/dist/engine/projects.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectRegistry = void 0;
+exports.projectReference = projectReference;
+// Identidad local explícita: un nombre de carpeta no identifica un proyecto.
+const node_path_1 = __importDefault(require("node:path"));
+const hash_js_1 = require("../utils/hash.js");
+const fs_js_1 = require("../utils/fs.js");
+const secrets_js_1 = require("./secrets.js");
+function projectReference(value) {
+    let ref = value.trim().replace(/\\/g, '/').replace(/\/+$/, '');
+    if (!ref || ref.length > 2048 || /[\x00-\x1f]/.test(ref))
+        throw new Error('Invalid project reference.');
+    if ((0, secrets_js_1.secretKinds)(ref).length)
+        throw new Error('Project references must not contain credentials.');
+    if (/^git@[^:]+:/.test(ref))
+        ref = ref.replace(/^git@([^:]+):/, 'https://$1/');
+    if (/^https?:\/\//i.test(ref)) {
+        const url = new URL(ref);
+        if (url.username || url.password || url.search || url.hash) {
+            throw new Error('Project URLs must not contain credentials, query parameters or fragments.');
+        }
+        ref = `${url.host.toLowerCase()}${url.pathname}`;
+    }
+    ref = ref.replace(/\.git$/, '').replace(/\/+$/, '');
+    if (/^[a-z]:\//i.test(ref))
+        ref = node_path_1.default.posix.normalize(ref).toLowerCase();
+    return ref;
+}
+class ProjectRegistry {
+    file;
+    constructor(brain) { this.file = node_path_1.default.join(brain.paths.root, 'projects.json'); }
+    async find(reference) {
+        const ref = projectReference(reference);
+        const data = await (0, fs_js_1.readJSON)(this.file);
+        return Object.values(data?.projects || {}).find(p => p.id === ref || p.aliases.includes(ref)) || null;
+    }
+    async boundNeurons() {
+        const data = await (0, fs_js_1.readJSON)(this.file);
+        return [...new Set(Object.values(data?.projects || {}).flatMap(p => p.neurons))];
+    }
+    async bind(reference, options) {
+        const ref = projectReference(reference);
+        const aliases = [...new Set([ref, ...(options.aliases || []).map(projectReference)])];
+        if (aliases.length > 32)
+            throw new Error('At most 32 project aliases.');
+        if (options.id && !/^[a-zA-Z0-9_-]{1,100}$/.test(options.id))
+            throw new Error('Invalid project id.');
+        if (options.neurons?.some(id => !/^[a-zA-Z0-9_-]{1,200}$/.test(id)))
+            throw new Error('Invalid neuron id.');
+        let result;
+        await (0, fs_js_1.updateJSON)(this.file, current => {
+            const data = current || { version: 1, projects: {} };
+            const existing = Object.values(data.projects).find(p => p.id === ref || p.aliases.includes(ref));
+            const id = options.id || existing?.id || `project_${(0, hash_js_1.contentHash)(ref, 16)}`;
+            for (const p of Object.values(data.projects)) {
+                if (p.id !== id && (aliases.includes(p.id) || p.aliases.includes(id) || p.aliases.some(a => aliases.includes(a)))) {
+                    throw new Error('Project alias already belongs to another project; no assignment changed.');
+                }
+            }
+            const previous = data.projects[id];
+            const mergedAliases = [...new Set([...(previous?.aliases || []), ...aliases])];
+            if (mergedAliases.length > 32)
+                throw new Error('At most 32 project aliases.');
+            result = {
+                id, aliases: mergedAliases,
+                neurons: options.neurons === undefined ? previous?.neurons || [] : [...new Set(options.neurons)],
+                updated: (0, fs_js_1.now)(),
+            };
+            data.projects[id] = result;
+            return data;
+        });
+        return result;
+    }
+}
+exports.ProjectRegistry = ProjectRegistry;
+//# sourceMappingURL=projects.js.map