th-memory-mcp 2.2.9 → 2.3.0

package/dist/tools/import_memory.js

@@ -30,6 +30,27 @@ export const importMemoryInput = {
 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;
@@ -104,13 +125,15 @@ export function importMemoryHandler(args) {
         else {
             memoryItems = [];
         }
-        // Restore users FIRST (before memories) so createMemory()->ensureUser reuses
-        // the restored row (with original name/created_at) instead of auto-creating
-        // a bare row. Idempotent via UNIQUE(external_id) + INSERT OR IGNORE.
+        // 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) {
-            const insertUser = db.prepare("INSERT OR IGNORE INTO users (external_id, name, created_at) VALUES (?, ?, ?)");
             for (const u of exportUsers) {
                 const external = typeof u.externalId === "string"
                     ? u.externalId
@@ -132,9 +155,7 @@ export function importMemoryHandler(args) {
                         : null) ?? nowISO();
                 const name = typeof u.name === "string" ? u.name.slice(0, 500) : null;
                 usersImported++;
-                if (args.apply === true) {
-                    insertUser.run(external, name, created);
-                }
+                validUsers.push({ external, name, created });
             }
         }
         let wouldImport = 0;
@@ -142,6 +163,11 @@ export function importMemoryHandler(args) {
         let invalid = 0;
         const log = [];
         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" ||
@@ -210,49 +236,46 @@ export function importMemoryHandler(args) {
                 log.push(`skip duplicate -> existing ${dup.existingId}`);
                 continue;
             }
-            wouldImport++;
-            if (args.apply === true) {
-                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: it.metadata ?? null,
-                });
-                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);
-                }
+            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++;
+            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) {
-                const sourceId = typeof link.sourceId === "number" ? importedIds.get(link.sourceId) : undefined;
-                const targetId = typeof link.targetId === "number" ? importedIds.get(link.targetId) : undefined;
-                if (!sourceId || !targetId || typeof link.relation !== "string" || !LINK_RELATIONS.includes(link.relation) ||
+                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 (args.apply === true) {
-                    db.prepare("INSERT OR IGNORE INTO memory_links (source_memory_id, relation, target_memory_id, confidence, created_at) VALUES (?, ?, ?, ?, ?)").run(sourceId, link.relation, targetId, link.confidence ?? 0.5, nowISO());
+                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.
@@ -263,9 +286,8 @@ export function importMemoryHandler(args) {
         let entitiesImported = 0;
         let entitiesInvalid = 0;
         const importedEntityIds = new Map();
+        const validEntities = [];
         if (exportEntities != null) {
-            const selEntity = db.prepare("SELECT id FROM entities WHERE canonical_name = ?");
-            const insEntity = db.prepare("INSERT INTO entities (name, canonical_name, type, metadata) VALUES (?, ?, ?, ?)");
             for (const e of exportEntities) {
                 const name = typeof e.name === "string" ? e.name : "";
                 const canonical = typeof e.canonicalName === "string"
@@ -278,34 +300,22 @@ export function importMemoryHandler(args) {
                     continue;
                 }
                 entitiesImported++;
-                if (args.apply === true) {
-                    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);
-                    }
-                    if (typeof e.id === "number" && Number.isInteger(e.id))
-                        importedEntityIds.set(e.id, newId);
-                }
+                validEntities.push({ e, name, canonical });
             }
         }
         let relationsImported = 0;
         let relationsInvalid = 0;
+        const validRelations = [];
         if (exportRelations != null) {
-            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 (?, ?, ?, ?, ?, ?, ?, ?)");
+            // 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
@@ -348,61 +358,31 @@ export function importMemoryHandler(args) {
                     relationsInvalid++;
                     continue;
                 }
-                // Remap entity ids: prefer import map, else keep original id if row still exists.
-                let newSource = null;
-                let newTarget = null;
-                if (importedEntityIds.has(oldSource))
-                    newSource = importedEntityIds.get(oldSource);
-                else if (selEntityById.get(oldSource))
-                    newSource = oldSource;
-                if (importedEntityIds.has(oldTarget))
-                    newTarget = importedEntityIds.get(oldTarget);
-                else if (selEntityById.get(oldTarget))
-                    newTarget = oldTarget;
-                if (newSource == null || newTarget == null) {
+                const srcOk = batchEntIds.has(oldSource) || !!selEntExists.get(oldSource);
+                const tgtOk = batchEntIds.has(oldTarget) || !!selEntExists.get(oldTarget);
+                if (!srcOk || !tgtOk) {
                     relationsInvalid++;
                     continue;
                 }
-                // Remap memory id: prefer import map, else keep original if still present, else NULL (orphan-safe).
-                let newMem = null;
-                if (oldMem == null)
-                    newMem = null;
-                else if (importedIds.has(oldMem))
-                    newMem = importedIds.get(oldMem);
-                else if (selMemById.get(oldMem))
-                    newMem = oldMem;
-                else
-                    newMem = null;
                 relationsImported++;
-                if (args.apply === true) {
-                    const dup = selRelation.get(newSource, predicate, newTarget, newMem);
-                    if (dup)
-                        continue;
-                    const meta = r.metadata == null
-                        ? JSON.stringify({})
-                        : typeof r.metadata === "string"
-                            ? r.metadata
-                            : JSON.stringify(r.metadata);
-                    insRelation.run(newSource, predicate, newTarget, conf, vf, vu, newMem, meta);
-                }
+                validRelations.push({ r, oldSource, oldTarget, predicate, conf, vf, vu, oldMem });
             }
         }
-        const graphSuffix = `users ${usersImported} ok ${usersInvalid} invalid; entities ${entitiesImported} ok ${entitiesInvalid} invalid; relations ${relationsImported} ok ${relationsInvalid} invalid`;
-        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" ||
@@ -418,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 ||
@@ -449,23 +415,174 @@ 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; ${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);

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 {

package/dist/tools/recall.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { db, buildFtsMatch, escapeLike, truncate, getAllEmbeddings, ok, err, } from "../db/index.js";
 import { embed, cosine, deserialize } from "../lib/embed.js";
+import { wrapMemoryReference } from "../lib/memory-format.js";
 export const recallInput = {
     topic: z.string().min(1).max(500).describe("Topic to recall from memory"),
     limit: z
@@ -121,7 +122,8 @@ export async function recallHandler(args) {
         if (parts.length === 0) {
             return ok(`no memory found for "${truncate(args.topic, 100)}"`);
         }
-        return ok(truncate(parts.join("\n\n"), RECALL_BUDGET));
+        // Batch B-2: recalled memory is reference data, not instructions.
+        return ok(wrapMemoryReference(truncate(parts.join("\n\n"), RECALL_BUDGET)));
     }
     catch (e) {
         return err(e instanceof Error ? e.message : String(e));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "th-memory-mcp",
-  "version": "2.2.9",
+  "version": "2.3.0",
   "mcpName": "io.github.worakorn-prince/th-memory-mcp",
   "description": "Adaptive Memory MCP server - SQLite-backed memory for OpenCode",
   "author": "worakorn-prince",
@@ -12,7 +12,8 @@
   "type": "module",
   "main": "dist/index.js",
   "bin": {
-    "th-memory-mcp": "dist/index.js"
+    "th-memory-mcp": "dist/index.js",
+    "th-memory": "dist/cli.js"
   },
   "files": [
     "dist",
@@ -29,6 +30,7 @@
     "prepublishOnly": "npm run version:sync && npm run build",
     "version:sync": "node scripts/sync-version.mjs",
     "version:check": "node scripts/sync-version.mjs --check",
+    "check:capture-sync": "node scripts/check-capture-sync.mjs",
     "start": "node dist/index.js",
     "inspect": "npx @modelcontextprotocol/inspector node dist/index.js",
     "test": "npm run build && node --test test/*.test.mjs test/smoke.mjs",