crbro-memory 2.9.1 → 2.11.0

package/dist/cli/import.js

@@ -0,0 +1,683 @@
+"use strict";
+// ─── crbro-memory import ─────────────────────────────────────────
+//
+// Bring knowledge in from what already sits on the owner's machine: a
+// CLAUDE.md / AGENTS.md, a Claude Code memory folder, or a CRBRO export (JSON
+// or the Markdown vault, for round trips). Dry run by default.
+//
+// Writes go ONLY through MCP tool calls to a CRBRO server this command spawns
+// over stdio — never into brain files — so a running daemon stays the single
+// writer and learn's validation, redaction and de-duplication all apply.
+// Idempotent: before anything is learned, the target neuron's index is read
+// and every entry whose content id is already there (live or retired) is left
+// alone, so a second run adds nothing and bumps no counter.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportError = exports.IMPORT_HELP = void 0;
+exports.memoryKind = memoryKind;
+exports.memoryProjectName = memoryProjectName;
+exports.documentRootName = documentRootName;
+exports.buildPlan = buildPlan;
+exports.storedId = storedId;
+exports.learnTopicOf = learnTopicOf;
+exports.protocolLost = protocolLost;
+exports.executePlan = executePlan;
+exports.formatReport = formatReport;
+exports.main = main;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = require("node:fs");
+const secrets_js_1 = require("../engine/secrets.js");
+const ops_js_1 = require("../sync/ops.js");
+const hash_js_1 = require("../utils/hash.js");
+const ids_js_1 = require("../utils/ids.js");
+const common_js_1 = require("./common.js");
+const markdown_js_1 = require("./markdown.js");
+const export_js_1 = require("./export.js");
+const mcpclient_js_1 = require("./mcpclient.js");
+exports.IMPORT_HELP = `
+  crbro-memory import <path> [--apply] [--topic <name>] [--type fact|preference|pattern]
+
+  Learn what a file or folder already says. DRY RUN by default: it shows what
+  would be learned and into which neuron, and writes nothing. --apply writes.
+
+  <path> can be:
+    CLAUDE.md, AGENTS.md or any instructions Markdown
+        The single H1 names the document; each H2 becomes a topic
+        "<title> — <H2>" (deeper headings stay in their section and lead
+        their entries); every bullet, paragraph, table or code block becomes
+        one entry, stored as --type (default fact).
+    A Claude Code memory folder (Markdown files with name / description /
+    metadata.type frontmatter; MEMORY.md, the index, is skipped)
+        Every file becomes one entry "<name>: <body>" in one topic,
+        "<project> (Claude Code memory)", by type:
+          user → preference · feedback → pattern · project → fact · reference → fact
+        A body over 1,500 characters is split into its paragraphs.
+    A CRBRO export: crbro-export.json, or a folder exported with --format md
+        Neurons, entries of every kind (map, summary, tags, synapses) come
+        back by name; retired entries are never re-learned.
+
+    --apply            Write. Without it nothing changes.
+    --topic <name>     Markdown sources: put everything into this one topic.
+    --type <kind>      Markdown sources: fact (default), preference or pattern,
+                       overriding the memory-type mapping.
+
+  Writes go through a CRBRO server this command starts (the daemon, when it
+  is on), with the same CRBRO_PATH. Importing the same thing twice adds nothing.
+`;
+const LEARN_KINDS = new Set(['fact', 'decision', 'pattern', 'preference', 'error', 'debt']);
+class ImportError extends Error {
+}
+exports.ImportError = ImportError;
+const MAX_MD_BYTES = 5 * 1024 * 1024;
+const MAX_JSON_BYTES = 512 * 1024 * 1024;
+const SYNAPSE_TYPES = new Set(['dependency', 'causal', 'temporal', 'conceptual', 'hierarchy', 'alternative']);
+const SHELF = new Set(['volatile', 'normal', 'durable', 'permanent']);
+async function readText(file, max) {
+    const st = await node_fs_1.promises.stat(file);
+    if (st.size > max)
+        throw new ImportError(`${file} is ${Math.round(st.size / 1048576)} MB, over the ${Math.round(max / 1048576)} MB this command reads.`);
+    return (await node_fs_1.promises.readFile(file, 'utf8')).replace(/^/, '');
+}
+function cleanReference(r) {
+    if (!r || typeof r !== 'object')
+        return undefined;
+    if (!['file', 'url', 'person'].includes(r.kind) || typeof r.value !== 'string' || !r.value || r.value.length > 2048)
+        return undefined;
+    return {
+        kind: r.kind, value: r.value,
+        ...(typeof r.field === 'string' && r.field.length <= 256 ? { field: r.field } : {}),
+        ...(typeof r.project === 'string' && r.project.length <= 256 ? { project: r.project } : {}),
+    };
+}
+/** A neuron of an export, as topics and entries. Retired entries are counted, not planned. */
+function topicFromNeuron(n, source) {
+    const all = (0, export_js_1.entriesOf)(n, true);
+    const live = all.filter(e => e.status === 'active');
+    return {
+        retired: all.length - live.length,
+        topic: {
+            topic: n.name, exportId: n.id, type: n.type, domain: n.domain || undefined,
+            summary: n.summary || undefined, tags: Array.isArray(n.tags) && n.tags.length ? n.tags : undefined,
+            source,
+            entries: live.map(e => ({
+                kind: e.kind === 'map' ? 'map' : e.kind,
+                text: e.text,
+                ...(e.keywords?.length ? { keywords: e.keywords } : {}),
+                ...(e.rationale ? { rationale: e.rationale } : {}),
+                ...(e.kind === 'fact' && typeof e.confidence === 'number' ? { confidence: e.confidence } : {}),
+                ...(e.kind === 'fact' && e.shelf_life && SHELF.has(e.shelf_life) ? { shelf_life: e.shelf_life } : {}),
+                ...(e.kind === 'fact' && (e.temporal === 'current' || e.temporal === 'historical') ? { temporal: e.temporal } : {}),
+                ...(e.kind === 'fact' && cleanReference(e.reference) ? { reference: cleanReference(e.reference) } : {}),
+            })),
+        },
+    };
+}
+function synapsesFrom(list) {
+    const seen = new Set();
+    const out = [];
+    for (const s of list) {
+        if (!Array.isArray(s.nodes) || s.nodes.length !== 2)
+            continue;
+        const [a, b] = s.nodes.map(String);
+        if (!a || !b || a === b)
+            continue;
+        const key = [a, b].sort().join('|');
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push({
+            from: a, to: b,
+            type: SYNAPSE_TYPES.has(String(s.type)) ? String(s.type) : 'conceptual',
+            strength: typeof s.strength === 'number' && s.strength >= 0 && s.strength <= 1 ? s.strength : 0.5,
+            context: typeof s.context === 'string' ? s.context : '',
+        });
+    }
+    return out;
+}
+async function planFromJson(file) {
+    let data;
+    try {
+        data = JSON.parse(await readText(file, MAX_JSON_BYTES));
+    }
+    catch (err) {
+        if (err instanceof ImportError)
+            throw err;
+        throw new ImportError(`${file} is not valid JSON.`);
+    }
+    if (data?.format !== export_js_1.EXPORT_FORMAT || !Array.isArray(data?.neurons)) {
+        throw new ImportError(`${file} is not a CRBRO export (expected "format": "${export_js_1.EXPORT_FORMAT}").`);
+    }
+    const plan = { sourceKind: 'crbro-json', path: file, topics: [], synapses: [], skippedRetired: 0, warnings: [] };
+    for (const n of data.neurons) {
+        if (!n || typeof n.id !== 'string' || typeof n.name !== 'string') {
+            plan.warnings.push('a neuron without id or name was skipped');
+            continue;
+        }
+        const { topic, retired } = topicFromNeuron(n, file);
+        plan.skippedRetired += retired;
+        if (topic.entries.length || topic.summary)
+            plan.topics.push(topic);
+    }
+    plan.synapses = synapsesFrom(Array.isArray(data.synapses) ? data.synapses : []);
+    return plan;
+}
+const SYNAPSE_LINE = /^- \[\[([^|\]]+)(?:\|[^\]]*)?\]\] — ([a-z]+) · strength ([\d.]+)(?: · (.*))?$/;
+async function planFromVault(dir) {
+    const plan = { sourceKind: 'crbro-md', path: dir, topics: [], synapses: [], skippedRetired: 0, warnings: [] };
+    const neuronsDir = node_path_1.default.join(dir, 'neurons');
+    let names = [];
+    try {
+        names = (await node_fs_1.promises.readdir(neuronsDir)).filter(n => n.endsWith('.md')).sort();
+    }
+    catch {
+        throw new ImportError(`${dir} has no neurons/ folder: not a CRBRO Markdown export.`);
+    }
+    const noteToId = new Map();
+    const rawLinks = [];
+    for (const name of names) {
+        const file = node_path_1.default.join(neuronsDir, name);
+        const fm = (0, markdown_js_1.parseFrontmatter)(await readText(file, MAX_MD_BYTES));
+        if (!fm.present || fm.data.crbro_export === undefined || typeof fm.data.id !== 'string') {
+            plan.warnings.push(`neurons/${name} is not an exported neuron note; skipped`);
+            continue;
+        }
+        const id = fm.data.id;
+        noteToId.set(node_path_1.default.basename(name, '.md'), id);
+        const entries = (0, markdown_js_1.parseVaultEntries)(fm.body);
+        const live = entries.filter(e => e.status === 'active');
+        plan.skippedRetired += entries.length - live.length;
+        // The summary is the quote block right under the title.
+        const summaryLines = [];
+        let afterTitle = false;
+        for (const line of fm.body.replace(/\r\n?/g, '\n').split('\n')) {
+            if (!afterTitle) {
+                if (/^# /.test(line))
+                    afterTitle = true;
+                continue;
+            }
+            if (!line.trim() && !summaryLines.length)
+                continue;
+            if (line.startsWith('> ') || line === '>') {
+                summaryLines.push(line.replace(/^> ?/, ''));
+                continue;
+            }
+            break;
+        }
+        let inSynapses = false;
+        for (const line of fm.body.replace(/\r\n?/g, '\n').split('\n')) {
+            if (/^## /.test(line)) {
+                inSynapses = line.trim() === '## Synapses';
+                continue;
+            }
+            if (!inSynapses)
+                continue;
+            const m = SYNAPSE_LINE.exec(line.trim());
+            if (m)
+                rawLinks.push({ fromId: id, note: m[1], type: m[2], strength: Number(m[3]), context: m[4] || '' });
+        }
+        const topic = {
+            topic: typeof fm.data.name === 'string' && fm.data.name ? fm.data.name : id,
+            exportId: id,
+            type: typeof fm.data.type === 'string' ? fm.data.type : undefined,
+            domain: typeof fm.data.domain === 'string' && fm.data.domain ? fm.data.domain : undefined,
+            summary: summaryLines.join('\n').trim() || undefined,
+            tags: Array.isArray(fm.data.tags) && fm.data.tags.length ? fm.data.tags.map(String) : undefined,
+            source: file,
+            entries: live.map(e => ({
+                kind: (e.kind === 'map' ? 'map' : LEARN_KINDS.has(e.kind) ? e.kind : 'fact'),
+                text: e.text,
+                ...(e.keywords?.length ? { keywords: e.keywords } : {}),
+                ...(e.rationale ? { rationale: e.rationale } : {}),
+            })),
+        };
+        if (topic.entries.length || topic.summary)
+            plan.topics.push(topic);
+    }
+    plan.synapses = synapsesFrom(rawLinks
+        .filter(l => noteToId.has(l.note))
+        .map(l => ({ nodes: [l.fromId, noteToId.get(l.note)], type: l.type, strength: l.strength, context: l.context, id: '', co_access_count: 0, last_co_access: '' })));
+    return plan;
+}
+/** user → preference · feedback → pattern · project, reference and anything else → fact. */
+function memoryKind(type) {
+    switch (String(type ?? '').toLowerCase()) {
+        case 'user': return 'preference';
+        case 'feedback': return 'pattern';
+        default: return 'fact';
+    }
+}
+/** The project a Claude Code memory folder belongs to: …/projects/<encoded cwd>/memory → its last path segment. */
+function memoryProjectName(dir) {
+    const abs = node_path_1.default.resolve(dir);
+    const parent = node_path_1.default.basename(node_path_1.default.dirname(abs));
+    if (node_path_1.default.basename(abs).toLowerCase() === 'memory' && node_path_1.default.basename(node_path_1.default.dirname(node_path_1.default.dirname(abs))).toLowerCase() === 'projects') {
+        const parts = parent.split('-').filter(Boolean);
+        return parts[parts.length - 1] || parent;
+    }
+    return node_path_1.default.basename(abs);
+}
+const MEMORY_SPLIT_CHARS = 1_500;
+async function memoryFiles(dir) {
+    const out = [];
+    let names = [];
+    try {
+        names = (await node_fs_1.promises.readdir(dir)).filter(n => n.toLowerCase().endsWith('.md')).sort();
+    }
+    catch {
+        return out;
+    }
+    for (const n of names) {
+        if (n.toLowerCase() === 'memory.md')
+            continue; // the index of the folder, not a memory
+        const file = node_path_1.default.join(dir, n);
+        try {
+            if (!(await node_fs_1.promises.lstat(file)).isFile())
+                continue;
+            const fm = (0, markdown_js_1.parseFrontmatter)(await readText(file, MAX_MD_BYTES));
+            if (fm.present && (typeof fm.data.name === 'string' || typeof fm.data.description === 'string'))
+                out.push({ file, fm });
+        }
+        catch { /* unreadable: not a memory file */ }
+    }
+    return out;
+}
+async function planFromMemoryFolder(dir, files, opts) {
+    const plan = { sourceKind: 'claude-memory', path: dir, topics: [], synapses: [], skippedRetired: 0, warnings: [] };
+    const topic = { topic: opts.topic || `${memoryProjectName(dir)} (Claude Code memory)`, entries: [], source: dir };
+    for (const { file, fm } of files) {
+        const name = String(fm.data.name || node_path_1.default.basename(file, '.md')).trim();
+        const description = typeof fm.data.description === 'string' ? fm.data.description.trim() : '';
+        const metaType = (fm.data.metadata && typeof fm.data.metadata === 'object' ? fm.data.metadata.type : undefined) ?? fm.data.type;
+        const kind = opts.type ?? memoryKind(metaType);
+        const body = fm.body.trim();
+        if (!body && !description)
+            continue;
+        if (body.length <= MEMORY_SPLIT_CHARS) {
+            topic.entries.push({ kind, text: `${name}: ${body || description}` });
+        }
+        else {
+            for (const section of (0, markdown_js_1.splitInstructions)(body, name)) {
+                for (const e of section.entries)
+                    topic.entries.push({ kind, text: `${name}: ${e}` });
+            }
+        }
+    }
+    if (topic.entries.length)
+        plan.topics.push(topic);
+    else
+        plan.warnings.push('no memory file with content was found');
+    return plan;
+}
+/** The name a document's untitled part goes under: the folder of a CLAUDE.md / AGENTS.md, else the file name. */
+function documentRootName(file) {
+    const stem = node_path_1.default.basename(file, node_path_1.default.extname(file));
+    if (/^(claude|agents|gemini|copilot-instructions)$/i.test(stem)) {
+        const folder = node_path_1.default.basename(node_path_1.default.dirname(node_path_1.default.resolve(file)));
+        return folder && folder !== '.' ? folder : stem;
+    }
+    return stem;
+}
+async function planFromMarkdownFile(file, opts) {
+    const text = await readText(file, MAX_MD_BYTES);
+    const fm = (0, markdown_js_1.parseFrontmatter)(text);
+    const plan = { sourceKind: 'markdown', path: file, topics: [], synapses: [], skippedRetired: 0, warnings: [] };
+    const kind = opts.type ?? 'fact';
+    const sections = (0, markdown_js_1.splitInstructions)(fm.body, documentRootName(file));
+    if (opts.topic) {
+        const all = sections.flatMap(s => s.entries);
+        if (all.length)
+            plan.topics.push({ topic: opts.topic, entries: all.map(t => ({ kind, text: t })), source: file });
+    }
+    else {
+        for (const s of sections)
+            plan.topics.push({ topic: s.topic, entries: s.entries.map(t => ({ kind, text: t })), source: file });
+    }
+    if (!plan.topics.length)
+        plan.warnings.push('the file holds no paragraph, bullet or block to learn');
+    return plan;
+}
+/** Look at `p` and build the plan. Reads only the source; the brain is not involved yet. */
+async function buildPlan(p, opts = {}) {
+    let st;
+    try {
+        st = await node_fs_1.promises.stat(p);
+    }
+    catch {
+        throw new ImportError(`${p} does not exist.`);
+    }
+    const crbroOnly = () => {
+        if (opts.topic || opts.type)
+            throw new ImportError('--topic and --type apply to Markdown sources, not to a CRBRO export: its neurons and kinds are kept.');
+    };
+    if (st.isFile()) {
+        const ext = node_path_1.default.extname(p).toLowerCase();
+        if (ext === '.json') {
+            crbroOnly();
+            return planFromJson(p);
+        }
+        if (ext === '.md' || ext === '.markdown' || ext === '.txt') {
+            const fm = (0, markdown_js_1.parseFrontmatter)(await readText(p, MAX_MD_BYTES));
+            if (fm.present && fm.data.crbro_export !== undefined) {
+                throw new ImportError(`${p} is one note of an exported vault: import the vault folder instead.`);
+            }
+            if (fm.present && typeof fm.data.name === 'string' && (fm.data.metadata?.type || fm.data.type)) {
+                return planFromMemoryFolder(node_path_1.default.dirname(p), [{ file: p, fm }], opts);
+            }
+            return planFromMarkdownFile(p, opts);
+        }
+        throw new ImportError(`${p}: expected a .md, .json or a folder.`);
+    }
+    if (!st.isDirectory())
+        throw new ImportError(`${p} is neither a file nor a folder.`);
+    const has = async (rel) => node_fs_1.promises.stat(node_path_1.default.join(p, rel)).then(() => true, () => false);
+    if (await has('crbro-export.json')) {
+        crbroOnly();
+        return planFromJson(node_path_1.default.join(p, 'crbro-export.json'));
+    }
+    if (await has(export_js_1.VAULT_MARKER) || await has(node_path_1.default.join('neurons'))) {
+        crbroOnly();
+        return planFromVault(p);
+    }
+    const files = await memoryFiles(p);
+    if (files.length)
+        return planFromMemoryFolder(p, files, opts);
+    throw new ImportError(`${p} is not a CRBRO export or a Claude Code memory folder. For a CLAUDE.md, pass the file itself.`);
+}
+/** The id an entry will have once stored: learn trims nothing, so we trim first and redact like it does. */
+function storedId(e) {
+    if (e.kind === 'map')
+        return 'map';
+    const stored = (0, secrets_js_1.redact)(e.text.trim()).text;
+    return e.kind === 'fact' ? (0, hash_js_1.factId)(stored) : (0, ops_js_1.entryId)(stored);
+}
+/**
+ * The topic name learn should create a neuron under. Only protocols matter:
+ * boot injects neurons whose id starts with protocol_, and learn infers the
+ * type from the name, so a protocol whose name does not say so would come
+ * back as a project. Adding the word steers the inference.
+ */
+function learnTopicOf(t) {
+    if (t.type === 'protocol' && (0, ids_js_1.inferNeuronType)(t.topic) !== 'protocol' && (0, ids_js_1.inferNeuronType)(`${t.topic} protocol`) === 'protocol') {
+        return `${t.topic} protocol`;
+    }
+    return t.topic;
+}
+/** A protocol whose name steers the inference elsewhere (a tech or process word in it) cannot come back as one. */
+function protocolLost(t) {
+    return t.type === 'protocol' && (0, ids_js_1.inferNeuronType)(learnTopicOf(t)) !== 'protocol';
+}
+async function readTarget(caller, ref) {
+    const state = { id: '', name: '', summary: '', tags: [], ids: new Set(), hasMap: false, connections: new Set() };
+    let offset = 0;
+    for (let guard = 0; guard < 10_000; guard++) {
+        const r = await caller.call('crbro_inspect', { view: 'neuron', neuron: ref, include_superseded: true, limit: 40, offset });
+        const n = r.data?.neuron ?? r.data;
+        if (!r.ok || !n || typeof n.id !== 'string') {
+            if (offset === 0)
+                return null;
+            throw new Error(`reading ${ref} failed half-way: ${r.text.slice(0, 200)}`);
+        }
+        if (offset === 0) {
+            state.id = n.id;
+            state.name = n.name;
+            state.summary = n.summary || '';
+            state.tags = Array.isArray(n.tags) ? n.tags : [];
+            for (const c of n.connections || [])
+                if (c?.target_id)
+                    state.connections.add(c.target_id);
+        }
+        const rows = Array.isArray(n.entries) ? n.entries : [];
+        for (const row of rows) {
+            if (row.kind === 'map')
+                state.hasMap = true;
+            if (typeof row.id === 'string')
+                state.ids.add(row.id);
+        }
+        if (!n.entries_pagination?.has_more || rows.length === 0)
+            break;
+        offset += rows.length;
+    }
+    return state;
+}
+/** Find the neuron a topic lands in: its export id, then the name learn will use, then its own name. */
+async function resolveTarget(caller, t) {
+    const refs = [t.exportId, learnTopicOf(t), t.topic].filter((x, i, a) => !!x && a.indexOf(x) === i);
+    for (const ref of refs) {
+        const s = await readTarget(caller, ref);
+        if (s)
+            return s;
+    }
+    return null;
+}
+/** Compare the plan with the brain and, with apply, write the difference. */
+async function executePlan(caller, plan, apply) {
+    const report = { plan, applied: apply, topics: [], learned: 0, maps: 0, connected: 0, skippedRetiredByServer: 0, failures: [] };
+    // A brain that was never initialized has no manifest, and learn would leave
+    // half-made neurons behind. Initializing is `init`'s job (or a client's
+    // first boot), not an import side effect: say so before writing anything.
+    const status = await caller.call('crbro_inspect', { view: 'status' });
+    if (!status.ok) {
+        const why = /not initialized/i.test(status.text)
+            ? 'this brain has not been initialized yet. Run `crbro-memory init` (or start any CRBRO client once) first.'
+            : `the CRBRO server could not read the brain: ${status.text.slice(0, 200)}`;
+        if (apply)
+            throw new ImportError(`nothing was written: ${why}`);
+        plan.warnings.push(why);
+    }
+    const idMap = new Map(); // export id → id in this brain
+    const connectionsOf = new Map();
+    for (const t of plan.topics) {
+        const target = await resolveTarget(caller, t);
+        const seen = new Set(target?.ids ?? []);
+        const fresh = [];
+        let present = 0;
+        for (const e of t.entries) {
+            if (!e.text.trim())
+                continue;
+            const id = storedId(e);
+            const already = e.kind === 'map' ? (target?.hasMap || seen.has('map')) : seen.has(id);
+            if (already) {
+                present++;
+                continue;
+            }
+            seen.add(id);
+            fresh.push(e);
+        }
+        const tr = {
+            topic: t.topic, target: target?.id ?? null, fresh, present,
+            summary: !!t.summary && !target?.summary,
+            tags: !!t.tags?.length && !(target?.tags?.length),
+        };
+        report.topics.push(tr);
+        if (!target && fresh.length && protocolLost(t)) {
+            plan.warnings.push(`"${t.topic}" was a protocol in the export, but crbro_learn infers the type from the name and this one ` +
+                `reads as a ${(0, ids_js_1.inferNeuronType)(learnTopicOf(t))}: it comes back as an ordinary neuron, and boot will not inject it. ` +
+                'Recreate it under a name with the word "protocol" and no technology or process word.');
+        }
+        if (target && t.exportId)
+            idMap.set(t.exportId, target.id);
+        if (target)
+            connectionsOf.set(target.id, target.connections);
+        if (!apply)
+            continue;
+        let neuronId = target?.id;
+        const learnTopic = learnTopicOf(t);
+        for (const e of fresh) {
+            if (e.kind === 'map')
+                continue; // after the entries, so the neuron exists with its proper type
+            const args = {
+                topic: learnTopic, type: e.kind, content: e.text.trim(),
+                ...(neuronId ? { neuron_id: neuronId } : {}),
+                ...(t.domain ? { domain: t.domain } : {}),
+                ...(e.kind === 'decision' && e.rationale ? { rationale: e.rationale } : {}),
+                ...(e.kind === 'fact' && e.keywords?.length ? { keywords: e.keywords } : {}),
+                ...(e.kind === 'fact' && typeof e.confidence === 'number' ? { confidence: e.confidence } : {}),
+                ...(e.kind === 'fact' && e.shelf_life ? { shelf_life: e.shelf_life } : {}),
+                ...(e.kind === 'fact' && e.temporal ? { temporal: e.temporal } : {}),
+                ...(e.kind === 'fact' && e.reference ? { reference: e.reference } : {}),
+            };
+            const r = await caller.call('crbro_learn', args);
+            if (!r.ok || !r.data?.neuron_id) {
+                report.failures.push(`${t.topic}: ${e.kind} "${preview((0, secrets_js_1.redact)(e.text).text, 60)}" — ${r.text.slice(0, 200)}`);
+                continue;
+            }
+            neuronId = r.data.neuron_id;
+            if (r.data.action === 'skipped_retired')
+                report.skippedRetiredByServer++;
+            else
+                report.learned++;
+        }
+        const map = fresh.find(e => e.kind === 'map');
+        if (map) {
+            const r = await caller.call('crbro_map', { neuron: neuronId ?? learnTopic, content: map.text.trim(), ...(t.domain ? { domain: t.domain } : {}) });
+            if (r.ok) {
+                report.maps++;
+                if (!neuronId && typeof r.data?.neuron_id === 'string')
+                    neuronId = r.data.neuron_id;
+            }
+            else
+                report.failures.push(`${t.topic}: map — ${r.text.slice(0, 200)}`);
+        }
+        if (!neuronId && (tr.summary || tr.tags)) {
+            // Nothing new to learn but metadata to carry: the neuron must exist first.
+            const s = await readTarget(caller, learnTopic);
+            neuronId = s?.id;
+        }
+        if (neuronId) {
+            const revise = {};
+            if (tr.summary)
+                revise.summary = t.summary;
+            if (tr.tags)
+                revise.tags = t.tags;
+            // A protocol created under "<name> protocol" gets its own name back; the id keeps the prefix boot needs.
+            if (!target && learnTopic !== t.topic)
+                revise.name = t.topic;
+            if (Object.keys(revise).length) {
+                const r = await caller.call('crbro_revise', { neuron: neuronId, ...revise });
+                if (!r.ok)
+                    report.failures.push(`${t.topic}: summary/tags — ${r.text.slice(0, 200)}`);
+            }
+            if (t.exportId)
+                idMap.set(t.exportId, neuronId);
+            if (!connectionsOf.has(neuronId))
+                connectionsOf.set(neuronId, new Set());
+        }
+    }
+    // Synapses, between neurons that both made it.
+    if (apply) {
+        for (const s of plan.synapses) {
+            const a = idMap.get(s.from), b = idMap.get(s.to);
+            if (!a || !b || a === b)
+                continue;
+            if (connectionsOf.get(a)?.has(b) || connectionsOf.get(b)?.has(a))
+                continue;
+            const r = await caller.call('crbro_connect', { from: a, to: b, type: s.type, strength: s.strength, ...(s.context ? { context: s.context } : {}) });
+            if (r.ok) {
+                report.connected++;
+                connectionsOf.get(a)?.add(b);
+                connectionsOf.get(b)?.add(a);
+            }
+            else
+                report.failures.push(`synapse ${a} ↔ ${b} — ${r.text.slice(0, 200)}`);
+        }
+    }
+    return report;
+}
+const preview = (s, n) => {
+    const one = s.replace(/\s+/g, ' ').trim();
+    return one.length > n ? `${one.slice(0, n - 1)}…` : one;
+};
+const SOURCE_LABEL = {
+    'crbro-json': 'CRBRO export (JSON)',
+    'crbro-md': 'CRBRO export (Markdown vault)',
+    'claude-memory': 'Claude Code memory folder',
+    markdown: 'instructions Markdown',
+};
+function formatReport(r, maxLines = 200) {
+    const out = [''];
+    out.push(`  ${r.applied ? 'Import' : 'Dry run'}: ${r.plan.path}  (${SOURCE_LABEL[r.plan.sourceKind]})`);
+    if (!r.applied)
+        out.push('  Nothing is written. Add --apply to write what is listed below.');
+    out.push('');
+    let lines = 0, hidden = 0;
+    for (const t of r.topics) {
+        const where = t.target ? `existing neuron ${t.target}` : 'new neuron';
+        const extras = [t.summary ? 'summary' : '', t.tags ? 'tags' : ''].filter(Boolean).join(', ');
+        out.push(`  → "${t.topic}" (${where}): ${t.fresh.length} new, ${t.present} already there${extras ? ` · sets ${extras}` : ''}`);
+        for (const e of t.fresh) {
+            if (lines >= maxLines) {
+                hidden++;
+                continue;
+            }
+            out.push(`      + ${e.kind}: ${preview((0, secrets_js_1.redact)(e.text).text, 100)}`);
+            lines++;
+        }
+    }
+    if (hidden)
+        out.push(`      … and ${hidden} more`);
+    const fresh = r.topics.reduce((s, t) => s + t.fresh.length, 0);
+    const present = r.topics.reduce((s, t) => s + t.present, 0);
+    const newNeurons = r.topics.filter(t => !t.target && (t.fresh.length || t.summary)).length;
+    out.push('');
+    out.push(`  ${r.applied ? 'Learned' : 'Would learn'} ${r.applied ? r.learned + r.maps : fresh} entr${(r.applied ? r.learned + r.maps : fresh) === 1 ? 'y' : 'ies'} in ${r.topics.filter(t => t.fresh.length).length} topic(s) (${newNeurons} new neuron(s)); ${present} already in the brain.`);
+    if (r.plan.skippedRetired)
+        out.push(`  ${r.plan.skippedRetired} retired entr${r.plan.skippedRetired === 1 ? 'y' : 'ies'} in the source left out: retired knowledge is never re-learned.`);
+    if (r.plan.synapses.length)
+        out.push(`  Synapses in the source: ${r.plan.synapses.length}${r.applied ? `; ${r.connected} connected now` : ' (connected on --apply when both ends exist)'}.`);
+    if (r.skippedRetiredByServer)
+        out.push(`  ${r.skippedRetiredByServer} matched an entry this brain had retired and were not stored.`);
+    for (const w of r.plan.warnings)
+        out.push(`  ⚠️  ${w}`);
+    for (const f of r.failures.slice(0, 20))
+        out.push(`  ❌ ${f}`);
+    if (r.failures.length > 20)
+        out.push(`  ❌ … and ${r.failures.length - 20} more failures`);
+    out.push('');
+    return out.join('\n');
+}
+/** CLI entry: returns the exit code. */
+async function main(argv, deps = {}) {
+    const a = (0, common_js_1.parseArgs)(argv, { apply: 'boolean', topic: 'string', type: 'string' });
+    if (a.flags.help) {
+        console.log(exports.IMPORT_HELP);
+        return 0;
+    }
+    const type = a.flags.type;
+    if (type !== undefined && !['fact', 'preference', 'pattern'].includes(type))
+        a.errors.push('--type must be fact, preference or pattern');
+    const topic = typeof a.flags.topic === 'string' ? a.flags.topic.trim() : undefined;
+    if (a.flags.topic !== undefined && !topic)
+        a.errors.push('--topic needs a name');
+    if (a.positionals.length !== 1)
+        a.errors.push(a.positionals.length ? 'one path at a time' : 'missing <path>');
+    if (a.errors.length) {
+        console.error(`  ❌ ${a.errors.join('; ')}`);
+        console.error('     Usage: crbro-memory import <path> [--apply] [--topic <name>] [--type fact|preference|pattern]   (--help for more)');
+        return 2;
+    }
+    let plan;
+    try {
+        plan = await buildPlan(node_path_1.default.resolve(a.positionals[0]), { topic, type: type });
+    }
+    catch (err) {
+        console.error(`  ❌ import: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    let caller = null;
+    try {
+        caller = await (deps.connect ? deps.connect() : (0, mcpclient_js_1.spawnServer)());
+        const report = await executePlan(caller, plan, !!a.flags.apply);
+        console.log(formatReport(report));
+        return report.failures.length ? 1 : 0;
+    }
+    catch (err) {
+        console.error(`  ❌ import: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        await caller?.close();
+    }
+}
+//# sourceMappingURL=import.js.map