crbro-memory 2.9.1 → 2.11.0

package/dist/sync/space.js

@@ -29,12 +29,58 @@ exports.syncAll = syncAll;
 exports.attachSync = attachSync;
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = require("node:crypto");
 const fs_js_1 = require("../utils/fs.js");
+const lock_js_1 = require("../utils/lock.js");
 const hash_js_1 = require("../utils/hash.js");
 const secrets_js_1 = require("../engine/secrets.js");
-const materialize_js_1 = require("./materialize.js");
+const evidence_js_1 = require("../engine/evidence.js");
 const ops_js_1 = require("./ops.js");
 const git_js_1 = require("./git.js");
+const validate_js_1 = require("./validate.js");
+// Fuera de shared/: el bloqueo debe sobrevivir al traslado de un espacio.
+// Orden: shared-state -> shared-outbox-state -> JSON. Nunca a la inversa.
+// Git retiene shared-state, pero NUNCA shared-outbox-state. Los emisores de
+// Cortex llegan después de soltar la neurona y solo toman el segundo.
+function withSharedState(brain, fn) {
+    return (0, lock_js_1.withLock)(node_path_1.default.join(brain.paths.root, 'shared-state'), fn);
+}
+function withOutboxState(brain, fn) {
+    return (0, lock_js_1.withLock)(node_path_1.default.join(brain.paths.root, 'shared-outbox-state'), fn);
+}
+function outboxDir(brain, space) {
+    return node_path_1.default.join(brain.paths.root, 'shared-outbox', space);
+}
+/** Con outbox-state adquirido y sin Git concurrente sobre este repositorio. */
+async function drainOutboxUnlocked(brain, space) {
+    const pendingDir = outboxDir(brain, space);
+    let files;
+    try {
+        files = await node_fs_1.promises.readdir(pendingDir);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return 0;
+        throw err;
+    }
+    let drained = 0;
+    for (const file of files.filter(f => f.endsWith('.json')).sort()) {
+        const pending = node_path_1.default.join(pendingDir, file);
+        const record = await (0, fs_js_1.readJSON)(pending);
+        if (!record)
+            continue;
+        if (!(await readSpace(brain, space)))
+            throw new Error('Cannot deliver pending notes: space is missing.');
+        const abs = node_path_1.default.join(spaceDir(brain, space), (0, ops_js_1.opsRelPath)(record.neuronId, record.identity.author, record.identity.device));
+        await node_fs_1.promises.mkdir(node_path_1.default.dirname(abs), { recursive: true });
+        // La línea inicial aísla un posible append truncado por caída del proceso.
+        // Si cayó tras append pero antes de unlink se repite: applyOps es idempotente.
+        await node_fs_1.promises.appendFile(abs, '\n' + record.ops.map(ops_js_1.encodeOp).join('\n') + '\n', 'utf-8');
+        await node_fs_1.promises.unlink(pending);
+        drained += record.ops.length;
+    }
+    return drained;
+}
 /**
  * Who this machine is. Not a security claim — anyone with push access to the
  * repository can write any name — just a label so a fact says where it came
@@ -52,16 +98,24 @@ async function getIdentity(brain, author) {
     await (0, fs_js_1.writeJSON)(p, id);
     return id;
 }
+/**
+ * The folder of a space. Throws for a name that is not a plain slug or that
+ * would resolve outside shared/: with "..", create used to run `git add -A`
+ * and push the whole brain to whatever remote it was given (G1).
+ */
 function spaceDir(brain, name) {
-    return node_path_1.default.join(brain.paths.shared, name);
+    return (0, validate_js_1.safeSpaceDir)(brain.paths.shared, name);
 }
+/** The space's config, or null — also for a name that cannot be a space. */
 async function readSpace(brain, name) {
+    if ((0, validate_js_1.spaceNameProblem)(name))
+        return null;
     return (0, fs_js_1.readJSON)(node_path_1.default.join(spaceDir(brain, name), 'space.json'));
 }
 async function listSpaces(brain) {
     try {
         const entries = await node_fs_1.promises.readdir(brain.paths.shared, { withFileTypes: true });
-        return entries.filter(e => e.isDirectory()).map(e => e.name);
+        return entries.filter(e => e.isDirectory() && !(0, validate_js_1.spaceNameProblem)(e.name)).map(e => e.name);
     }
     catch {
         return [];
@@ -69,7 +123,18 @@ async function listSpaces(brain) {
 }
 // ─── Creating and joining ────────────────────────────────────────
 async function createSpace(brain, name, remote, author, branch = 'main') {
-    if (!(0, git_js_1.gitAvailable)()) {
+    return withSharedState(brain, () => createSpaceUnlocked(brain, name, remote, author, branch));
+}
+/** One message for a name, remote or branch that cannot be used. */
+function invalidInput(name, remote, branch) {
+    const problem = (0, validate_js_1.spaceNameProblem)(name) || (0, validate_js_1.remoteProblem)(remote) || (0, validate_js_1.branchProblem)(branch);
+    return problem ? { ok: false, message: `Nothing was created or cloned. ${problem}` } : null;
+}
+async function createSpaceUnlocked(brain, name, remote, author, branch) {
+    const invalido = invalidInput(name, remote, branch);
+    if (invalido)
+        return invalido;
+    if (!(await (0, git_js_1.gitAvailableAsync)())) {
         return { ok: false, message: 'git is not installed, and it is what carries the shared memory. Install it and try again.' };
     }
     const dir = spaceDir(brain, name);
@@ -77,27 +142,33 @@ async function createSpace(brain, name, remote, author, branch = 'main') {
         return { ok: false, message: `The space "${name}" already exists on this machine.` };
     }
     const id = await getIdentity(brain, author);
-    const pushed = await (0, git_js_1.initSpace)(dir, remote, branch);
+    const pushed = await (0, git_js_1.initSpaceAsync)(dir, remote, branch);
     const cfg = { v: 1, name, created_by: id.author, created: (0, fs_js_1.now)(), branch };
     await (0, fs_js_1.writeJSON)(node_path_1.default.join(dir, 'space.json'), cfg);
     await node_fs_1.promises.mkdir(node_path_1.default.join(dir, '.local'), { recursive: true });
-    (0, git_js_1.git)(['add', '-A', '.'], dir);
-    (0, git_js_1.git)(['commit', '-q', '-m', `CRBRO space "${name}"`], dir);
-    const again = (0, git_js_1.git)(['push', 'origin', `HEAD:${branch}`], dir, 30_000);
+    await (0, git_js_1.gitAsync)(['add', '-A', '.'], dir);
+    await (0, git_js_1.gitAsync)(['commit', '-q', '-m', `CRBRO space "${name}"`], dir);
+    const again = await (0, git_js_1.gitAsync)(['push', 'origin', `HEAD:${branch}`], dir, 30_000);
     if (!pushed.ok && !again.ok) {
         return {
             ok: false,
             message: 'The space was created locally but could not reach the remote. Check the URL and that you have push access.',
-            detail: (again.stderr || pushed.stderr).slice(0, 300),
+            detail: (0, secrets_js_1.redact)((again.stderr || pushed.stderr).slice(0, 300)).text,
         };
     }
     return {
         ok: true,
-        message: `Space "${name}" created and pushed. Anyone you invite to ${remote} can now join it.`,
+        message: (0, secrets_js_1.redact)(`Space "${name}" created and pushed. Anyone you invite to ${remote} can now join it.`).text,
     };
 }
 async function joinSpace(brain, name, remote, author, branch = 'main') {
-    if (!(0, git_js_1.gitAvailable)()) {
+    return withSharedState(brain, () => joinSpaceUnlocked(brain, name, remote, author, branch));
+}
+async function joinSpaceUnlocked(brain, name, remote, author, branch) {
+    const invalido = invalidInput(name, remote, branch);
+    if (invalido)
+        return invalido;
+    if (!(await (0, git_js_1.gitAvailableAsync)())) {
         return { ok: false, message: 'git is not installed, and it is what carries the shared memory. Install it and try again.' };
     }
     const dir = spaceDir(brain, name);
@@ -106,14 +177,14 @@ async function joinSpace(brain, name, remote, author, branch = 'main') {
     }
     await getIdentity(brain, author);
     await node_fs_1.promises.mkdir(brain.paths.shared, { recursive: true });
-    const r = (0, git_js_1.cloneSpace)(dir, remote, branch);
+    const r = await (0, git_js_1.cloneSpaceAsync)(dir, remote, branch);
     if (!r.ok) {
         return {
             ok: false,
             message: r.reason === 'auth'
                 ? 'Cloned nothing: no access to that repository. Ask to be added as a collaborator.'
                 : 'Could not clone the space. Check the URL and your connection.',
-            detail: r.stderr.slice(0, 300),
+            detail: (0, secrets_js_1.redact)(r.stderr.slice(0, 300)).text,
         };
     }
     await node_fs_1.promises.mkdir(node_path_1.default.join(dir, '.local'), { recursive: true });
@@ -124,7 +195,7 @@ function neuronOps(neuron, id) {
     const at = (0, fs_js_1.now)();
     const ops = [
         { v: ops_js_1.OPS_VERSION, op: 'neuron', nid: neuron.id, by: id.author, at,
-            name: neuron.name, ntype: neuron.type, domain: neuron.domain },
+            name: (0, secrets_js_1.redact)(neuron.name || '').text, ntype: neuron.type, domain: neuron.domain },
     ];
     for (const f of neuron.facts || []) {
         if (!f.text)
@@ -132,21 +203,25 @@ function neuronOps(neuron, id) {
         const fid = f.id || (0, ops_js_1.entryId)(f.text);
         ops.push({ v: ops_js_1.OPS_VERSION, op: 'fact', nid: neuron.id, by: id.author,
             at: f.added || at, fid, text: f.text, conf: f.confidence ?? 1, src: f.source,
-            ...(f.keys?.length ? { keys: f.keys } : {}),
+            ...(f.reference ? { reference: f.reference } : {}),
+            ...(f.temporal ? { temporal: f.temporal } : {}),
+            ...(f.verification_invalidated_at ? { verification_invalidated_at: f.verification_invalidated_at } : {}),
+            ...(f.keys?.length ? { keys: f.keys.map(k => (0, secrets_js_1.redact)(k).text) } : {}),
             ...(f.shelf_life ? { shelf: f.shelf_life } : {}) });
         if (f.verified) {
-            ops.push({ v: ops_js_1.OPS_VERSION, op: 'verify', nid: neuron.id, by: id.author, at: f.verified, eid: fid, ekind: 'fact' });
+            ops.push({ v: ops_js_1.OPS_VERSION, op: 'verify', nid: neuron.id, by: id.author, at: f.verified, eid: fid, ekind: 'fact',
+                ...(f.verification ? { verification: f.verification } : {}) });
         }
         if (f.status === 'superseded' || f.status === 'retracted') {
             ops.push({ v: ops_js_1.OPS_VERSION, op: 'status', nid: neuron.id, by: id.author,
-                at: f.revised || at, fid, to: f.status, why: f.revision_note });
+                at: f.revised || at, fid, to: f.status, why: f.revision_note ? (0, secrets_js_1.redact)(f.revision_note).text : undefined });
         }
     }
     for (const d of neuron.decisions || []) {
         if (!d.text)
             continue;
         ops.push({ v: ops_js_1.OPS_VERSION, op: 'decision', nid: neuron.id, by: id.author,
-            at: d.date || at, did: (0, ops_js_1.entryId)(d.text), text: d.text, why: d.rationale });
+            at: d.date || at, did: (0, ops_js_1.entryId)(d.text), text: d.text, why: d.rationale ? (0, secrets_js_1.redact)(d.rationale).text : d.rationale });
     }
     // Dated entries carry their own date in `at`, so the team sees when a
     // pattern, error or debt was really recorded, not when it was shared.
@@ -169,7 +244,8 @@ function neuronOps(neuron, id) {
     }
     for (const [k, when] of Object.entries(neuron.entry_verified || {})) {
         if (k && when)
-            ops.push({ v: ops_js_1.OPS_VERSION, op: 'verify', nid: neuron.id, by: id.author, at: when, eid: k, ekind: 'entry' });
+            ops.push({ v: ops_js_1.OPS_VERSION, op: 'verify', nid: neuron.id, by: id.author, at: when, eid: k, ekind: 'entry',
+                ...(neuron.entry_verification?.[k] ? { verification: neuron.entry_verification[k] } : {}) });
     }
     if (neuron.map && neuron.map.text) {
         ops.push({ v: ops_js_1.OPS_VERSION, op: 'map', nid: neuron.id, by: id.author,
@@ -198,8 +274,40 @@ async function prepareShare(brain, cortex, neuronRef, spaceName) {
         for (const kind of (0, secrets_js_1.secretKinds)(text || ''))
             blocked.push({ where, kind });
     };
-    (neuron.facts || []).forEach((f, i) => revisar(`facts[${i}]`, f.text));
-    (neuron.decisions || []).forEach((d, i) => revisar(`decisions[${i}]`, d.text));
+    const revisarReferencia = (where, reference) => {
+        if (reference === undefined)
+            return;
+        try {
+            (0, evidence_js_1.sanitizeReference)(reference);
+            revisar(where, JSON.stringify(reference));
+        }
+        catch {
+            blocked.push({ where, kind: 'unsafe source reference' });
+        }
+    };
+    (neuron.facts || []).forEach((f, i) => {
+        revisar(`facts[${i}]`, f.text);
+        revisarReferencia(`facts[${i}].reference`, f.reference);
+        revisarReferencia(`facts[${i}].verification.reference`, f.verification?.reference);
+    });
+    for (const [k, v] of Object.entries(neuron.entry_verification || {})) {
+        revisarReferencia(`entry_verification[${k}].reference`, v.reference);
+    }
+    (neuron.decisions || []).forEach((d, i) => {
+        revisar(`decisions[${i}]`, d.text);
+        revisar(`decisions[${i}].rationale`, d.rationale);
+    });
+    // Every other field that travels in an op, not only the entry texts (G8):
+    // a credential in a rationale, an alias or a revision note went out while
+    // the dry run reported nothing blocked.
+    (neuron.facts || []).forEach((f, i) => {
+        (f.keys || []).forEach((k, j) => revisar(`facts[${i}].keys[${j}]`, k));
+        if (f.revision_note)
+            revisar(`facts[${i}].revision_note`, f.revision_note);
+    });
+    revisar('name', neuron.name);
+    revisar('summary', neuron.summary);
+    (neuron.tags || []).forEach((t, i) => revisar(`tags[${i}]`, t));
     (neuron.patterns || []).forEach((p, i) => revisar(`patterns[${i}]`, p));
     (neuron.errors || []).forEach((e, i) => revisar(`errors[${i}]`, e));
     (neuron.debts || []).forEach((d, i) => revisar(`debts[${i}]`, d));
@@ -219,6 +327,9 @@ async function prepareShare(brain, cortex, neuronRef, spaceName) {
     };
 }
 async function commitShare(brain, cortex, neuronRef, spaceName, token) {
+    return withSharedState(brain, () => withOutboxState(brain, () => commitShareUnlocked(brain, cortex, neuronRef, spaceName, token)));
+}
+async function commitShareUnlocked(brain, cortex, neuronRef, spaceName, token) {
     const prep = await prepareShare(brain, cortex, neuronRef, spaceName);
     if ('error' in prep)
         return { ok: false, message: prep.error };
@@ -240,7 +351,7 @@ async function commitShare(brain, cortex, neuronRef, spaceName, token) {
     // keep flowing without anyone having to share it again. A neuron that was
     // unshared earlier loses its tombstone here, so re-sharing works.
     await removeUnshared(brain, neuron.id);
-    await markShared(brain, neuron.id, spaceName);
+    await markSharedUnlocked(brain, neuron.id, spaceName);
     return { ok: true, message: `"${neuron.id}" is now shared in "${spaceName}".`, ops: ops.length };
 }
 function sharedMapPath(brain) {
@@ -250,9 +361,10 @@ async function sharedMap(brain) {
     return (await (0, fs_js_1.readJSON)(sharedMapPath(brain))) || {};
 }
 async function markShared(brain, neuronId, space) {
-    const m = await sharedMap(brain);
-    m[neuronId] = space;
-    await (0, fs_js_1.writeJSON)(sharedMapPath(brain), m);
+    await withSharedState(brain, () => withOutboxState(brain, () => markSharedUnlocked(brain, neuronId, space)));
+}
+async function markSharedUnlocked(brain, neuronId, space) {
+    await (0, fs_js_1.updateJSON)(sharedMapPath(brain), current => ({ ...current, [neuronId]: space }));
 }
 // ─── Unsharing ───────────────────────────────────────────────────
 //
@@ -268,16 +380,10 @@ async function unsharedList(brain) {
     return Array.isArray(raw) ? raw.filter((x) => typeof x === 'string') : [];
 }
 async function addUnshared(brain, neuronId) {
-    const lista = await unsharedList(brain);
-    if (!lista.includes(neuronId))
-        lista.push(neuronId);
-    await (0, fs_js_1.writeJSON)(unsharedPath(brain), lista);
+    await (0, fs_js_1.updateJSON)(unsharedPath(brain), current => [...new Set([...(current || []), neuronId])]);
 }
 async function removeUnshared(brain, neuronId) {
-    const lista = await unsharedList(brain);
-    if (!lista.includes(neuronId))
-        return;
-    await (0, fs_js_1.writeJSON)(unsharedPath(brain), lista.filter(id => id !== neuronId));
+    await (0, fs_js_1.updateJSON)(unsharedPath(brain), current => current?.filter(id => id !== neuronId) || null);
 }
 /**
  * Stop following a neuron in its space. Local only: no more notes go out and
@@ -287,6 +393,9 @@ async function removeUnshared(brain, neuronId) {
  * already been forgotten can still be unshared.
  */
 async function unshareNeuron(brain, cortex, neuronRef) {
+    return withSharedState(brain, () => withOutboxState(brain, () => unshareNeuronUnlocked(brain, cortex, neuronRef)));
+}
+async function unshareNeuronUnlocked(brain, cortex, neuronRef) {
     const neuron = (await cortex.peek(neuronRef)) || (await cortex.findByName(neuronRef));
     const id = neuron?.id || neuronRef;
     const m = await sharedMap(brain);
@@ -294,6 +403,8 @@ async function unshareNeuron(brain, cortex, neuronRef) {
     if (!space) {
         return { ok: false, neuron_id: id, space: null, message: `"${id}" is not shared in any space.` };
     }
+    // Lo ya confirmado debe llegar al log antes de dejar de seguir la neurona.
+    await drainOutboxUnlocked(brain, space);
     delete m[id];
     await (0, fs_js_1.writeJSON)(sharedMapPath(brain), m);
     await addUnshared(brain, id);
@@ -307,68 +418,94 @@ async function unshareNeuron(brain, cortex, neuronRef) {
 }
 /**
  * Leave a space: one last sync so pending notes go out, then the local copy
- * of the space is removed and its neurons stop being followed. The local
+ * of the space is archived and its neurons stop being followed. The local
  * neurons and the remote repository are untouched. The ids are NOT
  * tombstoned — re-joining should follow them again.
  */
 async function leaveSpace(brain, cortex, name) {
-    const cfg = await readSpace(brain, name);
-    if (!cfg) {
-        return { ok: false, message: `You are not in a space called "${name}".`, synced_before_leaving: 'skipped', neurons_unshared: 0 };
-    }
-    // Offline or no access are not failures here: the point is to leave, and
-    // what could not be pushed is reported, not blocking.
-    let synced = 'skipped';
-    try {
-        synced = (await syncSpaceNow(brain, cortex, name, 10_000)).state;
-    }
-    catch {
-        synced = 'offline';
-    }
-    // maxRetries: the space is a git repository, and on Windows its pack files
-    // are read-only; Node retries after fixing the mode, but only if asked.
-    await node_fs_1.promises.rm(spaceDir(brain, name), { recursive: true, force: true, maxRetries: 3 });
-    const m = await sharedMap(brain);
-    let neurons_unshared = 0;
-    for (const [nid, space] of Object.entries(m)) {
-        if (space === name) {
-            delete m[nid];
-            neurons_unshared++;
+    return withSharedState(brain, async () => {
+        const cfg = await readSpace(brain, name);
+        if (!cfg) {
+            return { ok: false, message: `You are not in a space called "${name}".`, synced_before_leaving: 'skipped', pushed_before_leaving: false, neurons_unshared: 0 };
         }
-    }
-    if (neurons_unshared > 0)
-        await (0, fs_js_1.writeJSON)(sharedMapPath(brain), m);
-    const aviso = synced === 'ok'
-        ? 'Your pending notes went out first.'
-        : synced === 'offline' || synced === 'auth'
-            ? `Your pending notes could not be pushed (${synced}); they are gone with the local copy.`
-            : 'No final sync was possible.';
-    return {
-        ok: true,
-        message: `Left "${name}". ${aviso} ${neurons_unshared} neuron(s) are no longer followed; ` +
-            'your local copies are untouched and the remote repository was not modified.',
-        synced_before_leaving: synced,
-        neurons_unshared,
-    };
+        // Offline or no access are not failures here: the point is to leave, and
+        // what could not be pushed is reported, not blocking.
+        let synced = 'skipped';
+        let pushed = false;
+        try {
+            const result = await syncSpaceUnlocked(brain, cortex, name, 10_000);
+            synced = result.state;
+            pushed = result.pushed;
+        }
+        catch {
+            synced = 'offline';
+        }
+        return withOutboxState(brain, async () => {
+            // Siempre se conserva TODO el repositorio (incluido .git), incluso tras
+            // enviar: las operaciones y su historial siguen siendo recuperables.
+            const archive = node_path_1.default.join(brain.paths.root, 'shared-archives', `${name}-${(0, node_crypto_1.randomUUID)()}`);
+            try {
+                // También lo confirmado mientras Git o la materialización estaban ocupados.
+                if (await drainOutboxUnlocked(brain, name))
+                    pushed = false;
+                await node_fs_1.promises.mkdir(node_path_1.default.dirname(archive), { recursive: true });
+                await node_fs_1.promises.rename(spaceDir(brain, name), archive);
+            }
+            catch {
+                return {
+                    ok: false, message: `Could not archive "${name}". The space and its logs were kept; you have not left.`,
+                    synced_before_leaving: synced, pushed_before_leaving: pushed, neurons_unshared: 0,
+                };
+            }
+            const m = await sharedMap(brain);
+            let neurons_unshared = 0;
+            for (const [nid, space] of Object.entries(m)) {
+                if (space === name) {
+                    delete m[nid];
+                    neurons_unshared++;
+                }
+            }
+            if (neurons_unshared > 0)
+                await (0, fs_js_1.writeJSON)(sharedMapPath(brain), m);
+            const aviso = pushed
+                ? 'Your pending notes went out first.'
+                : 'The final push was not confirmed; pending notes remain recoverable in the archive.';
+            return {
+                ok: true,
+                message: `Left "${name}". ${aviso} ${neurons_unshared} neuron(s) are no longer followed; ` +
+                    `your local neurons are kept. Recoverable space archive: ${archive}`,
+                synced_before_leaving: synced,
+                pushed_before_leaving: pushed,
+                neurons_unshared,
+                archive_path: archive,
+            };
+        });
+    });
 }
-/** Append one note for a neuron that is already shared. Silent if it is not. */
+/** Registra antes de confirmar. Solo omite una neurona que ya no se comparte. */
 async function emitOps(brain, neuronId, make) {
-    const m = await sharedMap(brain);
-    const space = m[neuronId];
-    if (!space)
-        return;
-    const dir = spaceDir(brain, space);
-    if (!(await (0, fs_js_1.fileExists)(node_path_1.default.join(dir, 'space.json'))))
-        return;
-    const id = await getIdentity(brain);
-    const abs = node_path_1.default.join(dir, (0, ops_js_1.opsRelPath)(neuronId, id.author, id.device));
-    await node_fs_1.promises.mkdir(node_path_1.default.dirname(abs), { recursive: true });
-    const ops = make(id);
-    if (ops.length === 0)
-        return;
-    await node_fs_1.promises.appendFile(abs, ops.map(ops_js_1.encodeOp).join('\n') + '\n', 'utf-8');
+    return withOutboxState(brain, async () => {
+        const m = await sharedMap(brain);
+        const space = m[neuronId];
+        if (!space)
+            return;
+        const id = await getIdentity(brain);
+        const ops = make(id);
+        if (ops.length === 0)
+            return;
+        await (0, fs_js_1.writeJSON)(node_path_1.default.join(outboxDir(brain, space), `${(0, node_crypto_1.randomUUID)()}.json`), { neuronId, identity: id, ops });
+        // Si sync adquiere shared-state después de esta comprobación, debe esperar
+        // nuestro outbox-state antes de empezar Git. No hay ventana de append/Git.
+        if (!(await (0, fs_js_1.fileExists)(node_path_1.default.join(brain.paths.root, 'shared-state.lock')))) {
+            try {
+                await drainOutboxUnlocked(brain, space);
+            }
+            catch { /* Ya persistido: se reintenta en sync/leave, incluso tras reinicio. */ }
+        }
+    });
 }
 // ─── Sync ────────────────────────────────────────────────────────
+const MAX_LOG_BYTES = 32 * 1024 * 1024;
 async function readAllOps(dir, neuronId) {
     const opsDir = node_path_1.default.join(dir, 'neurons', neuronId, 'ops');
     let files;
@@ -383,7 +520,11 @@ async function readAllOps(dir, neuronId) {
         if (!f.endsWith('.jsonl'))
             continue;
         try {
-            const raw = await node_fs_1.promises.readFile(node_path_1.default.join(opsDir, f), 'utf-8');
+            const p = node_path_1.default.join(opsDir, f);
+            // A log that size is not notes; reading it whole would only cost memory.
+            if ((await node_fs_1.promises.stat(p)).size > MAX_LOG_BYTES)
+                continue;
+            const raw = await node_fs_1.promises.readFile(p, 'utf-8');
             all.push(...(0, ops_js_1.decodeOps)(raw).ops);
         }
         catch { /* unreadable log: skip it, keep the rest */ }
@@ -391,17 +532,26 @@ async function readAllOps(dir, neuronId) {
     return all;
 }
 async function syncSpaceNow(brain, cortex, spaceName, timeoutMs = 30_000) {
+    return withSharedState(brain, () => syncSpaceUnlocked(brain, cortex, spaceName, timeoutMs));
+}
+async function syncSpaceUnlocked(brain, cortex, spaceName, timeoutMs) {
     const base = {
         space: spaceName, state: 'ok', neurons_touched: [], merged: [], pushed: false, message: '',
     };
     const cfg = await readSpace(brain, spaceName);
     if (!cfg)
         return { ...base, state: 'not_joined', message: `You are not in a space called "${spaceName}".` };
-    if (!(0, git_js_1.gitAvailable)())
+    await withOutboxState(brain, () => drainOutboxUnlocked(brain, spaceName));
+    if (!(await (0, git_js_1.gitAvailableAsync)()))
         return { ...base, state: 'no_git', message: 'git is not installed on this machine.' };
+    // space.json arrives from the remote: its branch is checked like any input.
+    const branch = cfg.branch || 'main';
+    if ((0, validate_js_1.branchProblem)(branch)) {
+        return { ...base, state: 'conflict', message: 'The space.json of this space names an invalid branch. Nothing was synced.' };
+    }
     const dir = spaceDir(brain, spaceName);
     const id = await getIdentity(brain);
-    const { pulled, pushed } = (0, git_js_1.syncSpace)(dir, id.author, cfg.branch || 'main', timeoutMs);
+    const { pulled, pushed } = await (0, git_js_1.syncSpaceAsync)(dir, id.author, branch, timeoutMs);
     if (!pulled.ok) {
         const state = (pulled.reason === 'offline' || pulled.reason === 'timeout') ? 'offline'
             : pulled.reason === 'auth' ? 'auth'
@@ -425,27 +575,52 @@ async function syncSpaceNow(brain, cortex, spaceName, timeoutMs = 30_000) {
     catch { /* nothing shared yet */ }
     // Neurons this machine stopped following: no merge, no markShared.
     const fuera = new Set(await unsharedList(brain));
+    const mapa = await sharedMap(brain);
+    const intactas = [];
+    let descartadas = 0;
     for (const nid of neuronIds) {
         if (fuera.has(nid))
             continue;
-        const ops = await readAllOps(dir, nid);
+        // A folder name is what becomes a file name in the cortex: only what
+        // CRBRO itself would have written.
+        if (!validate_js_1.NEURON_DIR_RE.test(nid))
+            continue;
+        const owner = mapa[nid];
+        // Followed in another space: that space's sync owns it.
+        if (owner && owner !== spaceName)
+            continue;
+        // A local neuron you never shared here stays yours. Until 2.10 a
+        // teammate could create neurons/<your id>/ and the next sync merged into
+        // it and marked it shared, so everything you learned there went out (G2).
+        if (!owner && await (0, fs_js_1.fileExists)(brain.paths.neuron(nid))) {
+            intactas.push(nid);
+            continue;
+        }
+        const leidas = await readAllOps(dir, nid);
+        const { ops, dropped } = (0, validate_js_1.sanitizeIncomingOps)(nid, leidas);
+        descartadas += dropped;
         if (ops.length === 0)
             continue;
-        const local = await cortex.peek(nid);
-        const { neuron, report } = (0, materialize_js_1.applyOps)(local, ops, { id: nid });
+        const { report, created } = await cortex.mergeFromSync(nid, ops);
         const cambio = report.facts_added + report.facts_retracted + report.facts_superseded +
             report.decisions_added + report.patterns_added + report.tags_added +
             report.errors_added + report.debts_added + report.entries_removed +
-            report.verifications_updated + report.shelf_updated +
+            report.verifications_updated + report.shelf_updated + report.metadata_updated +
             (report.map_updated ? 1 : 0);
-        if (cambio > 0 || !local) {
-            await cortex.replaceFromSync(neuron);
+        if (cambio > 0 || created) {
             base.neurons_touched.push(nid);
             base.merged.push(report);
         }
-        await markShared(brain, nid, spaceName);
+        if (!owner)
+            await markSharedUnlocked(brain, nid, spaceName);
     }
-    base.pushed = !!pushed?.ok;
+    if (intactas.length)
+        base.left_alone = intactas;
+    if (descartadas)
+        base.ops_dropped = descartadas;
+    const pending = await withOutboxState(brain, () => drainOutboxUnlocked(brain, spaceName));
+    // Git solo envió lo que había antes: lo añadido después espera el próximo sync.
+    base.pushed = !!pushed?.ok && pending === 0;
     const nuevos = base.merged.reduce((n, m) => n + m.facts_added, 0);
     base.message = base.neurons_touched.length === 0
         ? 'Up to date. Nothing new from anyone.'
@@ -453,6 +628,12 @@ async function syncSpaceNow(brain, cortex, spaceName, timeoutMs = 30_000) {
     if (!base.pushed && pushed) {
         base.message += ' Your own notes could not be pushed this time; they will go with the next sync.';
     }
+    if (intactas.length) {
+        base.message += ` ${intactas.length} neuron(s) in the space have the id of a private neuron of yours and were left ` +
+            `alone (${intactas.slice(0, 5).join(', ')}${intactas.length > 5 ? ', …' : ''}). To merge one, crbro_share it into "${spaceName}".`;
+    }
+    if (descartadas)
+        base.message += ` ${descartadas} malformed incoming note(s) were ignored.`;
     return base;
 }
 /** Sync every space. Used at boot and at consolidation, with a short budget. */
@@ -484,18 +665,22 @@ function attachSync(brain, cortex) {
             if (change.kind === 'fact') {
                 return [{ ...comun, op: 'fact', fid: change.fid, text: change.text,
                         conf: change.conf, src: change.src,
-                        ...(change.keys?.length ? { keys: change.keys } : {}),
+                        ...(change.reference ? { reference: change.reference } : {}),
+                        ...(change.temporal ? { temporal: change.temporal } : {}),
+                        ...(change.verification_invalidated_at ? { verification_invalidated_at: change.verification_invalidated_at } : {}),
+                        ...(change.keys?.length ? { keys: change.keys.map(k => (0, secrets_js_1.redact)(k).text) } : {}),
                         ...(change.shelf ? { shelf: change.shelf } : {}) }];
             }
             if (change.kind === 'verify') {
-                return [{ ...comun, op: 'verify', eid: change.eid, ekind: change.ekind }];
+                return [{ ...comun, op: 'verify', eid: change.eid, ekind: change.ekind,
+                        ...(change.verification ? { verification: change.verification } : {}) }];
             }
             if (change.kind === 'status') {
-                return [{ ...comun, op: 'status', fid: change.fid, to: change.to, why: change.why }];
+                return [{ ...comun, op: 'status', fid: change.fid, to: change.to, why: change.why ? (0, secrets_js_1.redact)(change.why).text : change.why }];
             }
             if (change.kind === 'decision') {
                 return [{ ...comun, op: 'decision', did: (0, ops_js_1.entryId)(change.text),
-                        text: change.text, why: change.why }];
+                        text: change.text, why: change.why ? (0, secrets_js_1.redact)(change.why).text : change.why }];
             }
             if (change.kind === 'error') {
                 return [{ ...comun, op: 'error', text: change.text }];