th-memory-mcp 2.0.0 → 2.2.0

package/dist/memory/conflict-resolver.js

@@ -21,6 +21,14 @@ const NEGATION = [
     /เลิก/i,
     /อย่า/i,
 ];
+// Opposite-value lexicon for ambiguous preference conflicts (preserve, don't
+// silently supersede). A pair is contradictory when each side names a different
+// antonym from this set.
+const ANTONYMS = new Set([
+    "tabs", "spaces", "vim", "emacs", "light", "dark",
+    "mysql", "postgres", "windows", "mac", "linux",
+    "react", "vue", "ios", "android",
+]);
 export function isContradiction(a, b) {
     const na = NEGATION.some((re) => re.test(a));
     const nb = NEGATION.some((re) => re.test(b));
@@ -34,6 +42,22 @@ export function isContradiction(a, b) {
             overlap++;
     return overlap >= 2;
 }
+// True when the two texts each name a *different* antonym from ANTONYMS
+// (e.g. "Prefer tabs" vs "Prefer spaces"). Used to preserve ambiguous
+// conflicts as contradictions instead of destructively superseding them.
+export function hasAntonymPair(a, b) {
+    const ta = tokenSet(a);
+    const tb = tokenSet(b);
+    let aAnt;
+    let bAnt;
+    for (const t of ta)
+        if (ANTONYMS.has(t))
+            aAnt = t;
+    for (const t of tb)
+        if (ANTONYMS.has(t))
+            bAnt = t;
+    return !!aAnt && !!bAnt && aAnt !== bAnt;
+}
 function tokenSet(s) {
     return new Set(s.toLowerCase().match(/[a-z0-9ก-์]+/gi) ?? []);
 }
@@ -47,12 +71,24 @@ export function classifyRelationship(candidate, relatedId) {
     if (!relVecRow)
         return "unrelated";
     const score = cosine(embed(candidate.content), deserialize(relVecRow.vec));
+    const ta = tokenSet(candidate.content);
+    const tb = tokenSet(rel.content);
+    let overlap = 0;
+    for (const t of ta)
+        if (tb.has(t))
+            overlap++;
+    const jac = overlap / (ta.size + tb.size - overlap || 1);
     if (score >= SIM_DUP)
         return "duplicate";
     if (isContradiction(candidate.content, rel.content) && score >= SIM_CONTRA) {
         return "contradiction";
     }
-    if (score >= SIM_UPDATE)
+    if (hasAntonymPair(candidate.content, rel.content)) {
+        return "contradiction";
+    }
+    if (score >= 0.6 && jac >= 0.5)
+        return "duplicate";
+    if (score >= SIM_UPDATE && jac >= 0.25)
         return "update";
     return "unrelated";
 }

package/dist/retrieval/scorer.js

@@ -8,12 +8,41 @@ export function finalScore(input) {
         clamp01(input.recency) *
         clamp01(input.scopeFactor));
 }
-export function scopeFactorFor(mem, projectId) {
-    if (!projectId)
-        return 0.8; // global query: project-scoped memories slightly favored
-    if (mem.project_id === projectId)
-        return 1.0;
-    if (mem.project_id === null)
+export function scopeFactorFor(mem, opts = {}) {
+    const { projectId, sessionId, userId } = opts;
+    const memScope = mem.scope ?? "GLOBAL";
+    if (sessionId) {
+        if (memScope === "SESSION" && mem.session_id === sessionId)
+            return 1.0;
+        if (memScope === "PROJECT" && mem.project_id === projectId)
+            return 0.8;
+        if (memScope === "USER" && mem.user_id === userId)
+            return 0.8;
+        if (memScope === "GLOBAL")
+            return 0.6;
+        return 0.2;
+    }
+    if (projectId) {
+        if (memScope === "PROJECT" && mem.project_id === projectId)
+            return 1.0;
+        if (memScope === "USER" && mem.user_id === userId)
+            return 0.8;
+        if (memScope === "GLOBAL")
+            return 0.7;
+        return 0.3;
+    }
+    if (userId) {
+        if (memScope === "USER" && mem.user_id === userId)
+            return 1.0;
+        if (memScope === "GLOBAL")
+            return 0.7;
+        return 0.3;
+    }
+    if (memScope === "GLOBAL")
+        return 0.8;
+    if (memScope === "PROJECT")
         return 0.7;
-    return 0.3; // different project
+    if (memScope === "USER")
+        return 0.6;
+    return 0.4;
 }

package/dist/tools/consolidate.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { clusterMemories, createDerivedMemory, } from "../core/consolidation-engine.js";
+import { linkEntitiesForMemory, linkMemoriesBySharedEntities, } from "../core/entity-extractor.js";
 import { db, ok } from "../db/index.js";
 export const consolidateInput = {
     threshold: z
@@ -38,6 +39,16 @@ export function consolidateHandler(args) {
                 .get(id);
             return `  - [${id}] ${m?.content ?? "?"}`;
         });
+        // Auto entity extraction (item 5): persist entities + co-occurrence, then
+        // link memories in the cluster that share an entity.
+        for (const id of c) {
+            const m = db
+                .prepare("SELECT content FROM memories WHERE id = ?")
+                .get(id);
+            if (m)
+                linkEntitiesForMemory(id, m.content);
+        }
+        linkMemoriesBySharedEntities(c);
         lines.push(`Cluster (${c.length}):\n${contents.join("\n")}`);
         if (args.derive === true) {
             const summary = c

package/dist/tools/context.js

@@ -12,6 +12,11 @@ export const contextInput = {
         .optional()
         .describe("Scope context to a project"),
     sessionId: z.string().nullable().optional(),
+    userId: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("Scope context to a user (USER scope)"),
     limit: z
         .number()
         .int()
@@ -40,6 +45,7 @@ export function contextHandler(args) {
         query: typeof args.query === "string" ? args.query : "",
         projectId: typeof args.projectId === "string" ? args.projectId : null,
         sessionId: typeof args.sessionId === "string" ? args.sessionId : null,
+        userId: typeof args.userId === "string" ? args.userId : null,
         limit: typeof args.limit === "number" ? args.limit : undefined,
         maxTokens: typeof args.maxTokens === "number" ? args.maxTokens : undefined,
         includeHistory: args.includeHistory === true,

package/dist/tools/extract_memories.js

@@ -0,0 +1,96 @@
+import { z } from "zod";
+import { db, ok, err } from "../db/index.js";
+import { createMemory } from "../db/repositories/memories.js";
+import { deduplicate } from "../memory/deduplicator.js";
+// Deterministic, LLM-free intent heuristics (spec §19 "optional extraction").
+// Scans captured interactions and proposes memory candidates. Safe by default:
+// dry-run proposes; pass apply=true to actually create memories (source=captured).
+const INTENT_PATTERNS = [
+    { re: /(?:remember|จำไว้ว่า|บันทึกว่า)\s+(?:that\s+)?(.+)/i, type: "FACT" },
+    {
+        re: /(?:i prefer|my preference is|ผมชอบ|ฉันชอบ|เราชอบ)\s+(.+)/i,
+        type: "PREFERENCE",
+    },
+    {
+        re: /(?:i use|เราใช้|ฉันใช้)\s+([^\s,]+)\s+(?:for|ในการ|เพื่อ)\s+(.+)/i,
+        type: "PREFERENCE",
+    },
+    {
+        re: /(?:don'?t use|ห้ามใช้|อย่าใช้)\s+(.+?)(?:,\s*(?:use|ใช้)\s+(.+))?/i,
+        type: "LESSON",
+    },
+    {
+        re: /(?:instead|use)\s+(.+?)\s+(?:rather than|แทน)\s+(.+)/i,
+        type: "LESSON",
+    },
+];
+export const extractMemoriesInput = {
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(200)
+        .optional()
+        .describe("Max recent interactions to scan (default 50)"),
+    kind: z
+        .enum(["prompt", "tool_call", "error"])
+        .optional()
+        .describe("Interaction kind to scan (default prompt)"),
+    apply: z
+        .boolean()
+        .optional()
+        .describe("Create the proposed memories (default false = propose only)"),
+    userId: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("Scope extracted memories to a user (USER scope)"),
+};
+export function extractMemoriesHandler(args) {
+    try {
+        const limit = args.limit ?? 50;
+        const kind = args.kind ?? "prompt";
+        const rows = db
+            .prepare("SELECT id, content FROM interactions WHERE kind = ? ORDER BY id DESC LIMIT ?")
+            .all(kind, limit);
+        const candidates = [];
+        for (const r of rows) {
+            for (const p of INTENT_PATTERNS) {
+                const m = r.content.match(p.re);
+                if (m) {
+                    const clause = (m[1] || "").trim();
+                    if (clause.length >= 3) {
+                        candidates.push({
+                            interactionId: r.id,
+                            type: p.type,
+                            content: clause,
+                        });
+                    }
+                    break;
+                }
+            }
+        }
+        const distinct = candidates.filter((c) => deduplicate(c.type, c.content).verdict === "distinct");
+        if (args.apply === true) {
+            let n = 0;
+            for (const c of distinct) {
+                createMemory({
+                    type: c.type,
+                    content: c.content,
+                    source: "captured",
+                    userId: typeof args.userId === "string" ? args.userId : null,
+                });
+                n++;
+            }
+            return ok(`extracted and created ${n} memories from interactions (${candidates.length} candidates, ${candidates.length - distinct.length} duplicates skipped)`);
+        }
+        const preview = distinct
+            .slice(0, 20)
+            .map((c) => `[${c.type}] ${c.content}`)
+            .join("\n") || "(no candidates)";
+        return ok(`proposed ${distinct.length} memory candidate(s) from ${rows.length} ${kind} interactions (dry-run; pass apply=true to create):\n${preview}`);
+    }
+    catch (e) {
+        return err(e instanceof Error ? e.message : String(e));
+    }
+}

package/dist/tools/history.js

@@ -14,7 +14,7 @@ const ITEM_BUDGET = 200;
 const searchPrompts = db.prepare("SELECT ts, content FROM interactions WHERE kind = 'prompt' AND content LIKE ? ESCAPE '\\' ORDER BY ts DESC LIMIT ?");
 export async function searchHistoryHandler(args) {
     try {
-        const limit = args.limit;
+        const limit = args.limit ?? 10;
         const like = `%${escapeLike(args.query)}%`;
         const rows = searchPrompts.all(like, limit);
         if (rows.length === 0) {

package/dist/tools/import_memory.js

@@ -0,0 +1,105 @@
+import { z } from "zod";
+import { readFileSync } from "node:fs";
+import { join, dirname, resolve, sep } from "node:path";
+import { DB_PATH, ok, err } from "../db/index.js";
+import { createMemory } from "../db/repositories/memories.js";
+import { deduplicate } from "../memory/deduplicator.js";
+import { MEMORY_TYPES } from "../memory/types.js";
+import { EXPORTS_DIRNAME } from "../lib/config.js";
+export const importMemoryInput = {
+    file: z
+        .string()
+        .optional()
+        .describe("Path to a .json export file (must be inside data/exports/)"),
+    json: z
+        .string()
+        .optional()
+        .describe("Inline JSON: an array of memory objects, or { memories: [...] }"),
+    apply: z
+        .boolean()
+        .optional()
+        .describe("Actually insert memories (default false = dry run, just report)"),
+    userId: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("Scope imported memories to a user (USER scope)"),
+};
+export function importMemoryHandler(args) {
+    try {
+        let raw;
+        if (args.json) {
+            raw = args.json;
+        }
+        else if (args.file) {
+            const exportDir = join(dirname(DB_PATH), EXPORTS_DIRNAME);
+            const full = resolve(args.file);
+            const allowed = resolve(exportDir);
+            if (!full.startsWith(allowed + sep))
+                return err(`file must be inside ${exportDir}`);
+            if (!full.endsWith(".json"))
+                return err("file must end with .json");
+            raw = readFileSync(full, "utf8");
+        }
+        else {
+            return err("provide either file or json");
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return err("invalid JSON");
+        }
+        const items = Array.isArray(parsed)
+            ? parsed
+            : Array.isArray(parsed.memories)
+                ? (parsed.memories)
+                : [];
+        let wouldImport = 0;
+        let skipped = 0;
+        let invalid = 0;
+        const log = [];
+        for (const it of items) {
+            if (!it ||
+                typeof it.content !== "string" ||
+                !MEMORY_TYPES.includes(it.type)) {
+                invalid++;
+                continue;
+            }
+            const dup = deduplicate(it.type, it.content);
+            if (dup.verdict === "duplicate") {
+                skipped++;
+                log.push(`skip duplicate -> existing ${dup.existingId}`);
+                continue;
+            }
+            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,
+                });
+            }
+        }
+        const mode = args.apply === true ? "applied" : "dry-run";
+        const summary = `import ${mode}: ${wouldImport} to import, ${skipped} duplicate(s) skipped, ${invalid} invalid`;
+        return ok(log.length ? `${summary}\n${log.join("\n")}` : summary);
+    }
+    catch (e) {
+        return err(e instanceof Error ? e.message : String(e));
+    }
+}

package/dist/tools/link_memory.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { ok, err } from "../db/index.js";
+import { linkMemories } from "../core/graph-engine.js";
+import { getMemoryById } from "../db/repositories/memories.js";
+import { LINK_RELATIONS } from "../memory/types.js";
+export const linkMemoryInput = {
+    sourceId: z.number().int().describe("Source memory id"),
+    targetId: z.number().int().describe("Target memory id"),
+    relation: z
+        .enum(LINK_RELATIONS)
+        .describe("Link relation (supports/contradicts/supersedes/derived_from/related_to/caused_by/depends_on)"),
+};
+export function linkMemoryHandler(args) {
+    try {
+        const src = getMemoryById(args.sourceId);
+        const tgt = getMemoryById(args.targetId);
+        if (!src)
+            return err(`source memory ${args.sourceId} not found`);
+        if (!tgt)
+            return err(`target memory ${args.targetId} not found`);
+        if (src.status === "deleted" || tgt.status === "deleted")
+            return err("cannot link deleted memories");
+        if (src.id === tgt.id)
+            return err("cannot link a memory to itself");
+        linkMemories(args.sourceId, args.targetId, args.relation);
+        return ok(`linked memory ${args.sourceId} -[${args.relation}]-> ${args.targetId}`);
+    }
+    catch (e) {
+        return err(e instanceof Error ? e.message : String(e));
+    }
+}

package/dist/tools/merge_memory.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { db, nowISO, ok, err } from "../db/index.js";
+import { getMemoryById } from "../db/repositories/memories.js";
+import { supersede } from "../core/lifecycle-engine.js";
+export const mergeMemoryInput = {
+    sourceId: z
+        .number()
+        .int()
+        .describe("Memory to merge away (becomes superseded)"),
+    targetId: z
+        .number()
+        .int()
+        .describe("Canonical memory to keep (becomes active)"),
+};
+function mergeMetadata(existing, mergedId) {
+    let obj = {};
+    if (existing) {
+        try {
+            obj = JSON.parse(existing);
+        }
+        catch {
+            obj = {};
+        }
+    }
+    const from = Array.isArray(obj.merged_from) ? obj.merged_from : [];
+    from.push(mergedId);
+    obj.merged_from = from;
+    return JSON.stringify(obj);
+}
+export function mergeMemoryHandler(args) {
+    try {
+        const src = getMemoryById(args.sourceId);
+        const tgt = getMemoryById(args.targetId);
+        if (!src)
+            return err(`source memory ${args.sourceId} not found`);
+        if (!tgt)
+            return err(`target memory ${args.targetId} not found`);
+        if (src.id === tgt.id)
+            return err("cannot merge a memory into itself");
+        if (src.status === "deleted" || tgt.status === "deleted")
+            return err("cannot merge deleted memories");
+        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)`);
+    }
+    catch (e) {
+        return err(e instanceof Error ? e.message : String(e));
+    }
+}

package/dist/tools/profile.js

@@ -9,6 +9,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");
 export function buildProfileText() {
     const parts = [];
     const prof = profileRows.all();
@@ -34,6 +35,15 @@ export function buildProfileText() {
         }
         parts.push(block);
     }
+    // Auto-projection: surface top memories from the unified store (spec §7 / item 7).
+    const mems = topMemories.all();
+    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)}`;
+        }
+        parts.push(block);
+    }
     return truncate(parts.join("\n\n"), PROFILE_BUDGET);
 }
 export async function getProfileHandler() {

package/dist/tools/recall.js

@@ -32,7 +32,7 @@ function lessonLine(id) {
 }
 export async function recallHandler(args) {
     try {
-        const limit = args.limit;
+        const limit = args.limit ?? 8;
         const parts = [];
         const seen = new Set();
         let prefLines = "";
@@ -41,14 +41,14 @@ export async function recallHandler(args) {
             const rows = searchIndexed.all(buildFtsMatch(args.topic), limit);
             for (const r of rows) {
                 if (r.ref_table === "preferences") {
-                    const line = prefLine(r.ref_id);
+                    const line = prefLine(Number(r.ref_id));
                     if (line) {
                         prefLines += line + "\n";
                         seen.add(`p:${r.ref_id}`);
                     }
                 }
                 else if (r.ref_table === "lessons") {
-                    const line = lessonLine(r.ref_id);
+                    const line = lessonLine(Number(r.ref_id));
                     if (line) {
                         lessonLines += line + "\n";
                         seen.add(`l:${r.ref_id}`);

package/dist/tools/recent_interactions.js

@@ -20,7 +20,7 @@ const selectAny = db.prepare("SELECT id, ts, kind, content FROM interactions ORD
 const selectByKind = db.prepare("SELECT id, ts, kind, content FROM interactions WHERE kind = ? ORDER BY id DESC LIMIT ?");
 export async function getRecentInteractionsHandler(args) {
     try {
-        const limit = args.limit;
+        const limit = args.limit ?? 20;
         const rows = (args.kind
             ? selectByKind.all(args.kind, limit)
             : selectAny.all(limit));

package/dist/tools/update_memory.js

@@ -0,0 +1,98 @@
+import { z } from "zod";
+import { db, nowISO, ok, err, } from "../db/index.js";
+import { getMemoryById, createMemory, syncMemoryIndex, } from "../db/repositories/memories.js";
+import { supersede } from "../core/lifecycle-engine.js";
+export const updateMemoryInput = {
+    id: z.number().int().describe("Memory id to update"),
+    content: z
+        .string()
+        .max(2000)
+        .optional()
+        .describe("New content. When provided, a superseding memory is created (supersede=true) unless supersede=false."),
+    summary: z.string().max(2000).nullable().optional().describe("New summary"),
+    importance: z.number().min(0).max(1).optional(),
+    confidence: z.number().min(0).max(1).optional(),
+    validUntil: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("ISO timestamp or null to clear"),
+    metadata: z.unknown().optional().describe("New metadata object (replaces)"),
+    supersede: z
+        .boolean()
+        .optional()
+        .describe("If content changes, create a superseding memory instead of editing in place (default true)"),
+};
+export function updateMemoryHandler(args) {
+    try {
+        const mem = getMemoryById(args.id);
+        if (!mem)
+            return err(`memory ${args.id} not found`);
+        if (mem.status === "deleted")
+            return err("cannot update a deleted memory");
+        const supersedeContent = args.content !== undefined && (args.supersede ?? true);
+        if (supersedeContent) {
+            const newId = createMemory({
+                type: mem.type,
+                content: args.content,
+                summary: args.summary ?? mem.summary,
+                source: mem.source,
+                confidence: args.confidence ?? mem.confidence,
+                importance: args.importance ?? mem.importance,
+                salience: mem.salience,
+                projectId: mem.project_id,
+                sessionId: mem.session_id,
+                validFrom: mem.valid_from,
+                validUntil: args.validUntil !== undefined ? args.validUntil : mem.valid_until,
+                metadata: args.metadata !== undefined
+                    ? args.metadata
+                    : mem.metadata
+                        ? JSON.parse(mem.metadata)
+                        : null,
+            });
+            supersede(mem.id, newId);
+            return ok(`created superseding memory id=${newId} for old id=${mem.id} (old now superseded)`);
+        }
+        const sets = [];
+        const vals = [];
+        if (args.summary !== undefined) {
+            sets.push("summary = ?");
+            vals.push(args.summary);
+        }
+        if (args.importance !== undefined) {
+            sets.push("importance = ?");
+            vals.push(args.importance);
+        }
+        if (args.confidence !== undefined) {
+            sets.push("confidence = ?");
+            vals.push(args.confidence);
+        }
+        if (args.validUntil !== undefined) {
+            sets.push("valid_until = ?");
+            vals.push(args.validUntil);
+        }
+        if (args.metadata !== undefined) {
+            sets.push("metadata = ?");
+            vals.push(JSON.stringify(args.metadata));
+        }
+        if (args.content !== undefined) {
+            sets.push("content = ?");
+            vals.push(args.content);
+        }
+        if (sets.length === 0)
+            return ok(`no mutable fields provided; memory ${mem.id} unchanged`);
+        sets.push("updated_at = ?");
+        vals.push(nowISO());
+        vals.push(mem.id);
+        db.prepare(`UPDATE memories SET ${sets.join(", ")} WHERE id = ?`).run(...vals);
+        if (args.content !== undefined) {
+            const m = getMemoryById(mem.id);
+            if (m)
+                syncMemoryIndex(m.id, m.type, m.content);
+        }
+        return ok(`updated memory ${mem.id} in place`);
+    }
+    catch (e) {
+        return err(e instanceof Error ? e.message : String(e));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "th-memory-mcp",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "mcpName": "io.github.worakorn-prince/th-memory-mcp",
   "description": "Adaptive Memory MCP server - SQLite-backed memory for OpenCode",
   "author": "worakorn-prince",
@@ -17,6 +17,7 @@
     "dist",
     "README.md",
     "LICENSE",
+    "ARCHITECTURE_v2.md",
     "design.md",
     "opencode.example.json",
     "AGENTS.memory.example.md"
@@ -26,7 +27,7 @@
     "prepublishOnly": "npm run build",
     "start": "node dist/index.js",
     "inspect": "npx @modelcontextprotocol/inspector node dist/index.js",
-    "test": "npm run build && node test/capture.test.mjs && node test/distill.test.mjs && node test/lifecycle.test.mjs && node test/temporal.test.mjs && node test/conflict.test.mjs && node test/retrieval.test.mjs && node test/graph.test.mjs && node test/context.test.mjs && node test/consolidation.test.mjs && node test/benchmark.test.mjs && node test/security.test.mjs && node test/smoke.mjs",
+    "test": "npm run build && node --test test/*.test.mjs",
     "distill": "node dist/distill.js",
     "quickstart": "npm run build && node scripts/quickstart.mjs"
   },