th-memory-mcp 2.2.8 → 2.3.0

package/dist/tools/import_memory.js

@@ -4,8 +4,9 @@ import { join, dirname, resolve, sep } from "node:path";
 import { db, DB_PATH, nowISO, syncSearchIndex, upsertEmbedding, ok, err, } from "../db/index.js";
 import { createMemory } from "../db/repositories/memories.js";
 import { deduplicate } from "../memory/deduplicator.js";
-import { MEMORY_TYPES, SOURCE_TYPES } from "../memory/types.js";
+import { MEMORY_TYPES, SOURCE_TYPES, LIFECYCLE_STATES, LINK_RELATIONS } from "../memory/types.js";
 import { EXPORTS_DIRNAME } from "../lib/config.js";
+import { isIsoDateString } from "../lib/iso.js";
 import { embed } from "../lib/embed.js";
 export const importMemoryInput = {
     file: z
@@ -26,23 +27,30 @@ export const importMemoryInput = {
         .optional()
         .describe("Scope imported memories to a user (USER scope)"),
 };
-function isIsoDateString(s) {
-    if (typeof s !== "string")
-        return false;
-    const d = Date.parse(s);
-    if (Number.isNaN(d))
-        return false;
-    try {
-        const iso = new Date(s).toISOString();
-        return iso.length >= 10;
-    }
-    catch {
-        return false;
-    }
-}
 function isValidSource(s) {
     return SOURCE_TYPES.includes(s);
 }
+// Batch A-2: normalize the per-item trust marker. Accepts boolean true,
+// "trusted"/"trust"/"yes"/"1" strings as trusted; everything else (including
+// missing) defaults to untrusted (false). No schema change — the flag is
+// carried inside memory metadata as { trusted: boolean } for team B delimiters.
+function parseTrustedFlag(v) {
+    // Strict: only a boolean true marks a source trusted. String aliases
+    // ("yes"/"true"/"1") are NOT accepted — otherwise a caller could pass
+    // trusted:"yes" and bypass the untrusted-import label.
+    return v === true;
+}
+function withTrustedFlag(meta, trusted) {
+    const flag = parseTrustedFlag(trusted);
+    if (meta == null)
+        return { trusted: flag };
+    if (typeof meta === "object" && !Array.isArray(meta)) {
+        return { ...meta, trusted: flag };
+    }
+    // Non-object legacy metadata cannot carry a field — wrap it so the
+    // contract metadata.trusted stays readable without altering the DB schema.
+    return { value: meta, trusted: flag };
+}
 export function importMemoryHandler(args) {
     try {
         let raw;
@@ -86,19 +94,15 @@ export function importMemoryHandler(args) {
         let exportPrefs = null;
         let exportLessons = null;
         let exportProfile = null;
+        let exportLinks = null;
+        // Batch A: additive backup fields (may be absent in legacy v2 files -> null = backward compat).
+        let exportUsers = null;
+        let exportEntities = null;
+        let exportRelations = null;
         if (Array.isArray(parsed)) {
             memoryItems = parsed;
         }
-        else if (parsed &&
-            typeof parsed === "object" &&
-            Array.isArray(parsed.memories)) {
-            memoryItems = parsed.memories;
-        }
-        else if (parsed &&
-            typeof parsed === "object" &&
-            ("preferences" in parsed ||
-                "lessons" in parsed ||
-                "profile" in parsed)) {
+        else if (parsed && typeof parsed === "object") {
             const p = parsed;
             if (Array.isArray(p.preferences))
                 exportPrefs = p.preferences;
@@ -108,15 +112,63 @@ export function importMemoryHandler(args) {
                 exportProfile = p.profile;
             if (Array.isArray(p.memories))
                 memoryItems = p.memories;
+            if (Array.isArray(p.memoryLinks))
+                exportLinks = p.memoryLinks;
+            // Accept both new keys and legacy absence (missing => null => skip, still pass).
+            if (Array.isArray(p.users))
+                exportUsers = p.users;
+            if (Array.isArray(p.entities))
+                exportEntities = p.entities;
+            if (Array.isArray(p.relations))
+                exportRelations = p.relations;
         }
         else {
             memoryItems = [];
         }
+        // Batch A-2 phase 1: parse + validate everything first (no DB writes).
+        // Phase 2 (below) applies all validated rows inside ONE db.transaction,
+        // so a mid-way error rolls back everything. Users are validated here and
+        // restored first inside the transaction so createMemory()->ensureUser
+        // reuses the restored row. Idempotent via UNIQUE(external_id).
+        let usersImported = 0;
+        let usersInvalid = 0;
+        const validUsers = [];
+        if (exportUsers != null) {
+            for (const u of exportUsers) {
+                const external = typeof u.externalId === "string"
+                    ? u.externalId
+                    : typeof u.external_id === "string"
+                        ? u.external_id
+                        : null;
+                if (!u ||
+                    !external ||
+                    external.length === 0 ||
+                    external.length > 200 ||
+                    /[\x00-\x1f]/.test(external)) {
+                    usersInvalid++;
+                    continue;
+                }
+                const created = (typeof u.createdAt === "string" && isIsoDateString(u.createdAt)
+                    ? u.createdAt
+                    : typeof u.created_at === "string" && isIsoDateString(u.created_at)
+                        ? u.created_at
+                        : null) ?? nowISO();
+                const name = typeof u.name === "string" ? u.name.slice(0, 500) : null;
+                usersImported++;
+                validUsers.push({ external, name, created });
+            }
+        }
         let wouldImport = 0;
         let skipped = 0;
         let invalid = 0;
         const log = [];
-        for (const it of memoryItems) {
+        const importedIds = new Map();
+        // Phase-1 validated memory payloads (applied in the single transaction).
+        const validMemories = [];
+        // Intra-batch exact-dupe guard: deduplicate() only sees committed rows,
+        // so track normalized type+content accepted in THIS batch as well.
+        const batchSeen = new Set();
+        for (const [idx, it] of memoryItems.entries()) {
             if (!it ||
                 typeof it.content !== "string" ||
                 it.content.length === 0 ||
@@ -141,6 +193,14 @@ export function importMemoryHandler(args) {
                 invalid++;
                 continue;
             }
+            if (it.salience != null && (typeof it.salience !== "number" || it.salience < 0 || it.salience > 1)) {
+                invalid++;
+                continue;
+            }
+            if (it.status != null && (typeof it.status !== "string" || !LIFECYCLE_STATES.includes(it.status))) {
+                invalid++;
+                continue;
+            }
             if (it.projectId != null && (typeof it.projectId !== "string" || it.projectId.length === 0 || it.projectId.length > 200)) {
                 invalid++;
                 continue;
@@ -155,10 +215,19 @@ export function importMemoryHandler(args) {
             }
             if (it.validFrom != null && (typeof it.validFrom !== "string" || !isIsoDateString(it.validFrom))) {
                 invalid++;
+                log.push(`invalid row ${idx}: validFrom '${String(it.validFrom)}' rejected — must be a full ISO datetime with timezone offset (e.g. 2024-01-01T00:00:00.000Z), date-only '2024-01-01' is not accepted`);
                 continue;
             }
             if (it.validUntil != null && (typeof it.validUntil !== "string" || !isIsoDateString(it.validUntil))) {
                 invalid++;
+                log.push(`invalid row ${idx}: validUntil '${String(it.validUntil)}' rejected — must be a full ISO datetime with timezone offset (e.g. 2024-01-01T00:00:00.000Z), date-only '2024-01-01' is not accepted`);
+                continue;
+            }
+            if (typeof it.validFrom === "string" &&
+                typeof it.validUntil === "string" &&
+                new Date(it.validFrom) > new Date(it.validUntil)) {
+                invalid++;
+                log.push(`invalid row ${idx}: validFrom (${it.validFrom}) must not be later than validUntil (${it.validUntil})`);
                 continue;
             }
             const dup = deduplicate(it.type, it.content);
@@ -167,43 +236,153 @@ export function importMemoryHandler(args) {
                 log.push(`skip duplicate -> existing ${dup.existingId}`);
                 continue;
             }
+            const batchKey = `${it.type}::${it.content.toLowerCase().trim()}`;
+            if (batchSeen.has(batchKey)) {
+                skipped++;
+                log.push(`skip duplicate -> duplicate within import batch (row ${idx})`);
+                continue;
+            }
+            batchSeen.add(batchKey);
             wouldImport++;
-            if (args.apply === true) {
-                createMemory({
-                    type: it.type,
-                    content: it.content,
-                    summary: typeof it.summary === "string" ? it.summary : null,
-                    source: it.source ?? "imported",
-                    confidence: typeof it.confidence === "number" ? it.confidence : 0.7,
-                    importance: typeof it.importance === "number" ? it.importance : 0.5,
-                    projectId: typeof it.projectId === "string" ? it.projectId : null,
-                    sessionId: typeof it.sessionId === "string" ? it.sessionId : null,
-                    userId: typeof it.userId === "string"
-                        ? it.userId
-                        : typeof args.userId === "string"
-                            ? args.userId
-                            : null,
-                    validFrom: typeof it.validFrom === "string" ? it.validFrom : null,
-                    validUntil: typeof it.validUntil === "string" ? it.validUntil : null,
-                    metadata: it.metadata ?? null,
-                });
+            validMemories.push({ idx, it });
+        }
+        let linksImported = 0;
+        let linksInvalid = 0;
+        const validLinks = [];
+        if (exportLinks != null) {
+            // Phase-1 remap precheck (no writes): a link is resolvable in phase 2
+            // iff both old ids belong to memories validated in THIS batch
+            // (mirrors the original importedIds-only rule, but works for dry-run too —
+            // the old code always reported links invalid on dry-run because the map
+            // was still empty at validate time).
+            const batchMemIds = new Set();
+            for (const { it } of validMemories) {
+                if (typeof it.id === "number" && Number.isInteger(it.id))
+                    batchMemIds.add(it.id);
+            }
+            for (const link of exportLinks) {
+                if (typeof link.sourceId !== "number" ||
+                    typeof link.targetId !== "number" ||
+                    typeof link.relation !== "string" ||
+                    !LINK_RELATIONS.includes(link.relation) ||
+                    (link.confidence != null && (typeof link.confidence !== "number" || link.confidence < 0 || link.confidence > 1))) {
+                    linksInvalid++;
+                    continue;
+                }
+                if (!batchMemIds.has(link.sourceId) || !batchMemIds.has(link.targetId)) {
+                    linksInvalid++;
+                    log.push(`invalid link ${link.sourceId}->${link.targetId}: unresolvable memory id`);
+                    continue;
+                }
+                linksImported++;
+                validLinks.push({ sourceId: link.sourceId, targetId: link.targetId, relation: link.relation, confidence: link.confidence });
+            }
+        }
+        // Batch A: restore M003 entities/relations idempotently.
+        // - entities: dedupe by UNIQUE(canonical_name); keep oldId->newId map for relations.
+        // - relations: `relation` is free-form (e.g. co_occurs) so do NOT check LINK_RELATIONS
+        //   here (that check stays only for memory_links above). Keep ISO validation as-is;
+        //   another team will unify validation later. Missing arrays (legacy v2) => skip, still pass.
+        let entitiesImported = 0;
+        let entitiesInvalid = 0;
+        const importedEntityIds = new Map();
+        const validEntities = [];
+        if (exportEntities != null) {
+            for (const e of exportEntities) {
+                const name = typeof e.name === "string" ? e.name : "";
+                const canonical = typeof e.canonicalName === "string"
+                    ? e.canonicalName
+                    : typeof e.canonical_name === "string"
+                        ? e.canonical_name
+                        : "";
+                if (!e || name.length === 0 || name.length > 500 || canonical.length === 0 || canonical.length > 500) {
+                    entitiesInvalid++;
+                    continue;
+                }
+                entitiesImported++;
+                validEntities.push({ e, name, canonical });
+            }
+        }
+        let relationsImported = 0;
+        let relationsInvalid = 0;
+        const validRelations = [];
+        if (exportRelations != null) {
+            // Phase-1 entity-existence precheck (read-only): an old entity id is
+            // resolvable in phase 2 iff it is shipped in THIS batch (validEntities)
+            // or still exists in the DB. oldMem stays orphan-safe (NULL fallback).
+            const batchEntIds = new Set();
+            for (const { e } of validEntities) {
+                if (typeof e.id === "number" && Number.isInteger(e.id))
+                    batchEntIds.add(e.id);
+            }
+            const selEntExists = db.prepare("SELECT id FROM entities WHERE id = ?");
+            for (const r of exportRelations) {
+                const oldSource = typeof r.sourceEntityId === "number"
+                    ? r.sourceEntityId
+                    : typeof r.source_entity_id === "number"
+                        ? r.source_entity_id
+                        : null;
+                const oldTarget = typeof r.targetEntityId === "number"
+                    ? r.targetEntityId
+                    : typeof r.target_entity_id === "number"
+                        ? r.target_entity_id
+                        : null;
+                const predicate = typeof r.relation === "string" ? r.relation : "";
+                const conf = r.confidence == null ? 0.5 : r.confidence;
+                const vf = typeof r.validFrom === "string"
+                    ? r.validFrom
+                    : typeof r.valid_from === "string"
+                        ? r.valid_from
+                        : null;
+                const vu = typeof r.validUntil === "string"
+                    ? r.validUntil
+                    : typeof r.valid_until === "string"
+                        ? r.valid_until
+                        : null;
+                const oldMem = typeof r.sourceMemoryId === "number"
+                    ? r.sourceMemoryId
+                    : typeof r.source_memory_id === "number"
+                        ? r.source_memory_id
+                        : null;
+                if (!r ||
+                    oldSource == null ||
+                    oldTarget == null ||
+                    predicate.length === 0 ||
+                    predicate.length > 200 ||
+                    typeof conf !== "number" ||
+                    conf < 0 ||
+                    conf > 1 ||
+                    (vf != null && !isIsoDateString(vf)) ||
+                    (vu != null && !isIsoDateString(vu)) ||
+                    (vf != null && vu != null && new Date(vf) > new Date(vu))) {
+                    relationsInvalid++;
+                    continue;
+                }
+                const srcOk = batchEntIds.has(oldSource) || !!selEntExists.get(oldSource);
+                const tgtOk = batchEntIds.has(oldTarget) || !!selEntExists.get(oldTarget);
+                if (!srcOk || !tgtOk) {
+                    relationsInvalid++;
+                    continue;
+                }
+                relationsImported++;
+                validRelations.push({ r, oldSource, oldTarget, predicate, conf, vf, vu, oldMem });
             }
         }
-        if (exportPrefs != null || exportLessons != null || exportProfile != null) {
-            const prefArr = Array.isArray(exportPrefs) ? exportPrefs : [];
-            const lessonArr = Array.isArray(exportLessons) ? exportLessons : [];
-            const profileArr = Array.isArray(exportProfile) ? exportProfile : [];
-            const validCat = new Set(["work_style", "coding_pref", "language", "domain", "other"]);
-            let prefOk = 0;
-            let prefInvalid = 0;
-            let lessonOk = 0;
-            let lessonInvalid = 0;
-            let profileOk = 0;
-            const selectPref = db.prepare("SELECT id FROM preferences WHERE category = ? AND key = ?");
-            const insertPref = db.prepare("INSERT INTO preferences (category, key, value, confidence, source, updated_at) VALUES (?, ?, ?, ?, ?, ?)");
-            const updatePref = db.prepare("UPDATE preferences SET value = ?, confidence = ?, source = ?, updated_at = ? WHERE category = ? AND key = ?");
-            const insertLesson = db.prepare("INSERT INTO lessons (situation, mistake, correction, created_at) VALUES (?, ?, ?, ?)");
-            const upsertProfile = db.prepare("INSERT INTO profile (section, content, updated_at) VALUES (?, ?, ?) ON CONFLICT(section) DO UPDATE SET content = excluded.content, updated_at = excluded.updated_at");
+        // Phase-1 validation for prefs/lessons/profile (no writes yet).
+        const prefArr = Array.isArray(exportPrefs) ? exportPrefs : [];
+        const lessonArr = Array.isArray(exportLessons) ? exportLessons : [];
+        const profileArr = Array.isArray(exportProfile) ? exportProfile : [];
+        const hasAux = exportPrefs != null || exportLessons != null || exportProfile != null;
+        const validCat = new Set(["work_style", "coding_pref", "language", "domain", "other"]);
+        let prefOk = 0;
+        let prefInvalid = 0;
+        let lessonOk = 0;
+        let lessonInvalid = 0;
+        let profileOk = 0;
+        const validPrefs = [];
+        const validLessons = [];
+        const validProfiles = [];
+        if (hasAux) {
             for (const p of prefArr) {
                 if (!p ||
                     typeof p.category !== "string" ||
@@ -219,21 +398,7 @@ export function importMemoryHandler(args) {
                     continue;
                 }
                 prefOk++;
-                if (args.apply === true) {
-                    const existing = selectPref.get(p.category, p.key);
-                    const conf = typeof p.confidence === "number" ? p.confidence : 0.5;
-                    const src = typeof p.source === "string" ? p.source : "imported";
-                    const ts = typeof p.updated_at === "string" && isIsoDateString(p.updated_at) ? p.updated_at : nowISO();
-                    if (existing)
-                        updatePref.run(p.value, conf, src, ts, p.category, p.key);
-                    else
-                        insertPref.run(p.category, p.key, p.value, conf, src, ts);
-                    const row = db.prepare("SELECT id FROM preferences WHERE category = ? AND key = ?").get(p.category, p.key);
-                    if (row) {
-                        syncSearchIndex("preferences", row.id, `${p.category}/${p.key}`, `${p.key}: ${p.value}`);
-                        upsertEmbedding("preferences", row.id, embed(`${p.category} ${p.key} ${p.value}`));
-                    }
-                }
+                validPrefs.push(p);
             }
             for (const l of lessonArr) {
                 if (!l ||
@@ -250,29 +415,180 @@ export function importMemoryHandler(args) {
                     continue;
                 }
                 lessonOk++;
-                if (args.apply === true) {
-                    const ts = typeof l.created_at === "string" && isIsoDateString(l.created_at) ? l.created_at : nowISO();
-                    const res = insertLesson.run(l.situation, l.mistake, l.correction, ts);
-                    const id = Number(res.lastInsertRowid);
-                    syncSearchIndex("lessons", id, l.situation.slice(0, 80), `${l.situation} | mistake: ${l.mistake} -> correction: ${l.correction}`);
-                    upsertEmbedding("lessons", id, embed(`${l.situation} ${l.mistake} ${l.correction}`));
-                }
+                validLessons.push(l);
             }
             for (const pr of profileArr) {
                 if (!pr || typeof pr.section !== "string" || pr.section.length === 0 || typeof pr.content !== "string" || pr.content.length === 0)
                     continue;
                 profileOk++;
-                if (args.apply === true) {
-                    const ts = typeof pr.updated_at === "string" && isIsoDateString(pr.updated_at) ? pr.updated_at : nowISO();
-                    upsertProfile.run(pr.section, pr.content, ts);
-                }
+                validProfiles.push(pr);
+            }
+        }
+        // Batch A-2 phase 2: single-transaction apply. All validated rows go in
+        // together; any mid-way throw rolls back EVERYTHING (atomic import).
+        if (args.apply === true) {
+            try {
+                const applyAll = db.transaction(() => {
+                    const insertUser = db.prepare("INSERT OR IGNORE INTO users (external_id, name, created_at) VALUES (?, ?, ?)");
+                    for (const u of validUsers)
+                        insertUser.run(u.external, u.name, u.created);
+                    for (const { it } of validMemories) {
+                        const newId = createMemory({
+                            type: it.type,
+                            content: it.content,
+                            summary: typeof it.summary === "string" ? it.summary : null,
+                            source: it.source ?? "imported",
+                            confidence: typeof it.confidence === "number" ? it.confidence : 0.7,
+                            importance: typeof it.importance === "number" ? it.importance : 0.5,
+                            salience: typeof it.salience === "number" ? it.salience : 0.5,
+                            projectId: typeof it.projectId === "string" ? it.projectId : null,
+                            sessionId: typeof it.sessionId === "string" ? it.sessionId : null,
+                            userId: typeof it.userId === "string"
+                                ? it.userId
+                                : typeof args.userId === "string"
+                                    ? args.userId
+                                    : null,
+                            validFrom: typeof it.validFrom === "string" ? it.validFrom : null,
+                            validUntil: typeof it.validUntil === "string" ? it.validUntil : null,
+                            metadata: withTrustedFlag(it.metadata, it.trusted),
+                        });
+                        if (typeof it.id === "number" && Number.isInteger(it.id))
+                            importedIds.set(it.id, newId);
+                        if (typeof it.status === "string" && it.status !== "active") {
+                            db.prepare("UPDATE memories SET status = ? WHERE id = ?").run(it.status, newId);
+                        }
+                    }
+                    // Entities first (relations remap needs importedEntityIds).
+                    const selEntity = db.prepare("SELECT id FROM entities WHERE canonical_name = ?");
+                    const insEntity = db.prepare("INSERT INTO entities (name, canonical_name, type, metadata) VALUES (?, ?, ?, ?)");
+                    const batchCanonical = new Map();
+                    for (const { e, name, canonical } of validEntities) {
+                        if (batchCanonical.has(canonical)) {
+                            if (typeof e.id === "number" && Number.isInteger(e.id))
+                                importedEntityIds.set(e.id, batchCanonical.get(canonical));
+                            continue;
+                        }
+                        const existing = selEntity.get(canonical);
+                        let newId;
+                        if (existing) {
+                            newId = existing.id;
+                        }
+                        else {
+                            const type = typeof e.type === "string" ? e.type.slice(0, 200) : "concept";
+                            const meta = e.metadata == null
+                                ? JSON.stringify({})
+                                : typeof e.metadata === "string"
+                                    ? e.metadata
+                                    : JSON.stringify(e.metadata);
+                            const res = insEntity.run(name.slice(0, 500), canonical, type, meta);
+                            newId = Number(res.lastInsertRowid);
+                        }
+                        batchCanonical.set(canonical, newId);
+                        if (typeof e.id === "number" && Number.isInteger(e.id))
+                            importedEntityIds.set(e.id, newId);
+                    }
+                    const insLink = db.prepare("INSERT OR IGNORE INTO memory_links (source_memory_id, relation, target_memory_id, confidence, created_at) VALUES (?, ?, ?, ?, ?)");
+                    for (const link of validLinks) {
+                        const sourceId = importedIds.get(link.sourceId);
+                        const targetId = importedIds.get(link.targetId);
+                        if (!sourceId || !targetId) {
+                            // Old id has no remapped row (points outside this import and
+                            // the row is gone): reclassify as invalid, keep counts honest.
+                            linksImported--;
+                            linksInvalid++;
+                            log.push(`invalid link ${link.sourceId}->${link.targetId}: unresolvable memory id`);
+                            continue;
+                        }
+                        insLink.run(sourceId, link.relation, targetId, link.confidence ?? 0.5, nowISO());
+                    }
+                    const selEntityById = db.prepare("SELECT id FROM entities WHERE id = ?");
+                    const selMemById = db.prepare("SELECT id FROM memories WHERE id = ?");
+                    const selRelation = db.prepare("SELECT id FROM relations WHERE source_entity_id = ? AND relation = ? AND target_entity_id = ? AND COALESCE(source_memory_id, -1) = COALESCE(?, -1)");
+                    const insRelation = db.prepare("INSERT INTO relations (source_entity_id, relation, target_entity_id, confidence, valid_from, valid_until, source_memory_id, metadata) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
+                    for (const v of validRelations) {
+                        let newSource = null;
+                        let newTarget = null;
+                        if (importedEntityIds.has(v.oldSource))
+                            newSource = importedEntityIds.get(v.oldSource);
+                        else if (selEntityById.get(v.oldSource))
+                            newSource = v.oldSource;
+                        if (importedEntityIds.has(v.oldTarget))
+                            newTarget = importedEntityIds.get(v.oldTarget);
+                        else if (selEntityById.get(v.oldTarget))
+                            newTarget = v.oldTarget;
+                        if (newSource == null || newTarget == null) {
+                            relationsImported--;
+                            relationsInvalid++;
+                            continue;
+                        }
+                        let newMem = null;
+                        if (v.oldMem == null)
+                            newMem = null;
+                        else if (importedIds.has(v.oldMem))
+                            newMem = importedIds.get(v.oldMem);
+                        else if (selMemById.get(v.oldMem))
+                            newMem = v.oldMem;
+                        else
+                            newMem = null;
+                        const dup = selRelation.get(newSource, v.predicate, newTarget, newMem);
+                        if (dup)
+                            continue;
+                        const meta = v.r.metadata == null
+                            ? JSON.stringify({})
+                            : typeof v.r.metadata === "string"
+                                ? v.r.metadata
+                                : JSON.stringify(v.r.metadata);
+                        insRelation.run(newSource, v.predicate, newTarget, v.conf, v.vf, v.vu, newMem, meta);
+                    }
+                    if (hasAux) {
+                        const selectPref = db.prepare("SELECT id FROM preferences WHERE category = ? AND key = ?");
+                        const insertPref = db.prepare("INSERT INTO preferences (category, key, value, confidence, source, updated_at) VALUES (?, ?, ?, ?, ?, ?)");
+                        const updatePref = db.prepare("UPDATE preferences SET value = ?, confidence = ?, source = ?, updated_at = ? WHERE category = ? AND key = ?");
+                        const insertLesson = db.prepare("INSERT INTO lessons (situation, mistake, correction, created_at) VALUES (?, ?, ?, ?)");
+                        const upsertProfile = db.prepare("INSERT INTO profile (section, content, updated_at) VALUES (?, ?, ?) ON CONFLICT(section) DO UPDATE SET content = excluded.content, updated_at = excluded.updated_at");
+                        for (const p of validPrefs) {
+                            const existing = selectPref.get(p.category, p.key);
+                            const conf = typeof p.confidence === "number" ? p.confidence : 0.5;
+                            const src = typeof p.source === "string" ? p.source : "imported";
+                            const ts = typeof p.updated_at === "string" && isIsoDateString(p.updated_at) ? p.updated_at : nowISO();
+                            if (existing)
+                                updatePref.run(p.value, conf, src, ts, p.category, p.key);
+                            else
+                                insertPref.run(p.category, p.key, p.value, conf, src, ts);
+                            const row = db.prepare("SELECT id FROM preferences WHERE category = ? AND key = ?").get(p.category, p.key);
+                            if (row) {
+                                syncSearchIndex("preferences", row.id, `${p.category}/${p.key}`, `${p.key}: ${p.value}`);
+                                upsertEmbedding("preferences", row.id, embed(`${p.category} ${p.key} ${p.value}`));
+                            }
+                        }
+                        for (const l of validLessons) {
+                            const ts = typeof l.created_at === "string" && isIsoDateString(l.created_at) ? l.created_at : nowISO();
+                            const res = insertLesson.run(l.situation, l.mistake, l.correction, ts);
+                            const id = Number(res.lastInsertRowid);
+                            syncSearchIndex("lessons", id, (l.situation ?? "").slice(0, 80), `${l.situation} | mistake: ${l.mistake} -> correction: ${l.correction}`);
+                            upsertEmbedding("lessons", id, embed(`${l.situation} ${l.mistake} ${l.correction}`));
+                        }
+                        for (const pr of validProfiles) {
+                            const ts = typeof pr.updated_at === "string" && isIsoDateString(pr.updated_at) ? pr.updated_at : nowISO();
+                            upsertProfile.run(pr.section, pr.content, ts);
+                        }
+                    }
+                });
+                applyAll();
+            }
+            catch (e) {
+                const reason = e instanceof Error ? e.message : String(e);
+                return err(`import failed and rolled back: ${reason} (validated ${wouldImport} memories, ${linksImported} links, ${entitiesImported} entities, ${relationsImported} relations; nothing was written)`);
             }
+        }
+        const graphSuffix = `users ${usersImported} ok ${usersInvalid} invalid; entities ${entitiesImported} ok ${entitiesInvalid} invalid; relations ${relationsImported} ok ${relationsInvalid} invalid`;
+        if (hasAux) {
             const mode = args.apply === true ? "applied" : "dry-run";
-            const summary = `import ${mode}: ${wouldImport} memories to import, ${skipped} duplicate(s) skipped, ${invalid} invalid memories; preferences ${prefOk} ok ${prefInvalid} invalid; lessons ${lessonOk} ok ${lessonInvalid} invalid; profile ${profileOk} ok`;
+            const summary = `import ${mode}: ${wouldImport} memories to import, ${skipped} duplicate(s) skipped, ${invalid} invalid memories; ${linksImported} link(s) imported, ${linksInvalid} invalid link(s); preferences ${prefOk} ok ${prefInvalid} invalid; lessons ${lessonOk} ok ${lessonInvalid} invalid; profile ${profileOk} ok; ${graphSuffix}`;
             return ok(summary);
         }
         const mode = args.apply === true ? "applied" : "dry-run";
-        const summary = `import ${mode}: ${wouldImport} to import, ${skipped} duplicate(s) skipped, ${invalid} invalid`;
+        const summary = `import ${mode}: ${wouldImport} to import, ${skipped} duplicate(s) skipped, ${invalid} invalid, ${linksImported} link(s) imported, ${linksInvalid} invalid link(s); ${graphSuffix}`;
         return ok(log.length ? `${summary}\n${log.join("\n")}` : summary);
     }
     catch (e) {

package/dist/tools/merge_memory.js

@@ -39,6 +39,20 @@ export function mergeMemoryHandler(args) {
             return err("cannot merge a memory into itself");
         if (src.status === "deleted" || tgt.status === "deleted")
             return err("cannot merge deleted memories");
+        // Batch B-3 (defense-in-depth, mirrors link_memory): refuse to merge
+        // across scope boundaries. Note: userId/sessionId/projectId are
+        // caller-supplied with no auth layer (single-user local process) — these
+        // checks are only as trustworthy as the caller (see README/SECURITY).
+        if ((src.scope === "USER" || tgt.scope === "USER") &&
+            src.user_id !== tgt.user_id)
+            return err("cannot merge memories across different users");
+        if ((src.scope === "SESSION" || tgt.scope === "SESSION") &&
+            src.session_id !== tgt.session_id)
+            return err("cannot merge memories across different sessions");
+        if (src.scope === "PROJECT" &&
+            tgt.scope === "PROJECT" &&
+            src.project_id !== tgt.project_id)
+            return err("cannot merge memories across different projects");
         db.prepare("UPDATE memories SET metadata = ?, updated_at = ? WHERE id = ?").run(mergeMetadata(tgt.metadata, src.id), nowISO(), tgt.id);
         supersede(src.id, tgt.id);
         return ok(`merged memory ${src.id} into ${tgt.id} (source superseded, provenance recorded in metadata.merged_from)`);

package/dist/tools/profile.js

@@ -1,4 +1,5 @@
 import { db, truncate, ok, err, } from "../db/index.js";
+import { MEMORY_REF_CLOSE, MEMORY_REF_GUIDANCE, MEMORY_REF_OPEN, UNTRUSTED_NOTE, UNTRUSTED_TAG, isUntrustedMetadata, } from "../lib/memory-format.js";
 export const PROFILE_BUDGET = 3000;
 const PROFILE_SECTION_MAX = 400;
 const PREF_CATEGORY_MAX = 30;
@@ -9,7 +10,7 @@ const LESSON_CORRECTION_MAX = 150;
 const profileRows = db.prepare("SELECT section, content FROM profile");
 const topPrefs = db.prepare("SELECT category, key, value, confidence FROM preferences ORDER BY confidence DESC, updated_at DESC LIMIT 15");
 const recentLessons = db.prepare("SELECT situation, mistake, correction FROM lessons ORDER BY created_at DESC, id DESC LIMIT 5");
-const topMemories = db.prepare("SELECT type, content, importance, confidence FROM memories WHERE status = 'active' ORDER BY importance * confidence DESC, updated_at DESC LIMIT 15");
+const topMemories = db.prepare("SELECT type, content, importance, confidence, metadata FROM memories WHERE status = 'active' ORDER BY importance * confidence DESC, updated_at DESC LIMIT 15");
 export function buildProfileText() {
     const parts = [];
     const prof = profileRows.all();
@@ -40,11 +41,23 @@ export function buildProfileText() {
     if (mems.length > 0) {
         let block = "[memories]";
         for (const m of mems) {
-            block += `\n- (${m.type} c${m.confidence.toFixed(2)}) ${truncate(m.content, 200)}`;
+            // Batch B-2: label untrusted imports (metadata.trusted=false) inline.
+            const tag = isUntrustedMetadata(m.metadata)
+                ? ` ${UNTRUSTED_TAG} (${UNTRUSTED_NOTE})`
+                : "";
+            block += `\n- (${m.type} c${m.confidence.toFixed(2)})${tag} ${truncate(m.content, 200)}`;
         }
         parts.push(block);
     }
-    return truncate(parts.join("\n\n"), PROFILE_BUDGET);
+    // Batch B-2: profile/memory text is reference data, not instructions —
+    // wrap with delimiters. Reserve wrapper overhead inside PROFILE_BUDGET so
+    // the wrapped output still fits the 3000-char contract.
+    const overhead = MEMORY_REF_GUIDANCE.length +
+        MEMORY_REF_OPEN.length +
+        MEMORY_REF_CLOSE.length +
+        8;
+    const inner = truncate(parts.join("\n\n"), Math.max(0, PROFILE_BUDGET - overhead));
+    return `${MEMORY_REF_GUIDANCE}\n${MEMORY_REF_OPEN}\n${inner}\n${MEMORY_REF_CLOSE}`;
 }
 export async function getProfileHandler() {
     try {