th-memory-mcp 1.2.2 → 2.0.0

package/dist/core/lifecycle-engine.js

@@ -0,0 +1,76 @@
+import { db, nowISO } from "../db/index.js";
+import { getMemoryById, setStatus } from "../db/repositories/memories.js";
+const TRANSITIONS = {
+    new: ["active", "deleted"],
+    active: ["reinforced", "stale", "superseded", "archived", "deleted"],
+    reinforced: ["active", "stale", "superseded", "archived", "deleted"],
+    stale: ["active", "archived", "deleted"],
+    superseded: ["archived", "deleted"],
+    archived: ["deleted"],
+    deleted: [],
+};
+export class LifecycleError extends Error {
+}
+export function canTransition(from, to) {
+    return TRANSITIONS[from]?.includes(to) ?? false;
+}
+export function transitionStatus(id, to) {
+    const mem = getMemoryById(id);
+    if (!mem)
+        throw new LifecycleError(`memory ${id} not found`);
+    if (!canTransition(mem.status, to)) {
+        throw new LifecycleError(`illegal transition ${mem.status} -> ${to} for memory ${id}`);
+    }
+    setStatus(id, to);
+    return getMemoryById(id);
+}
+export function reinforce(id) {
+    const mem = getMemoryById(id);
+    if (!mem)
+        throw new LifecycleError(`memory ${id} not found`);
+    if (mem.status === "deleted" || mem.status === "archived") {
+        throw new LifecycleError(`cannot reinforce memory in state ${mem.status}`);
+    }
+    const ts = nowISO();
+    db.prepare(`UPDATE memories
+     SET status = 'active',
+         confidence = MIN(1.0, confidence + 0.05),
+         updated_at = ?,
+         access_count = access_count + 1,
+         last_accessed_at = ?
+     WHERE id = ?`).run(ts, ts, id);
+    return getMemoryById(id);
+}
+export function touch(id) {
+    const ts = nowISO();
+    db.prepare(`UPDATE memories SET access_count = access_count + 1, last_accessed_at = ? WHERE id = ?`).run(ts, id);
+}
+// old memory becomes superseded; new memory becomes active and points to old.
+export function supersede(oldId, newId) {
+    const oldM = getMemoryById(oldId);
+    const newM = getMemoryById(newId);
+    if (!oldM)
+        throw new LifecycleError(`old memory ${oldId} not found`);
+    if (!newM)
+        throw new LifecycleError(`new memory ${newId} not found`);
+    const ts = nowISO();
+    const tx = db.transaction(() => {
+        db.prepare(`UPDATE memories SET status = 'superseded', updated_at = ? WHERE id = ?`).run(ts, oldId);
+        db.prepare(`UPDATE memories SET status = 'active', supersedes_id = ?, updated_at = ? WHERE id = ?`).run(oldId, ts, newId);
+        db.prepare(`INSERT INTO memory_links (source_memory_id, relation, target_memory_id, confidence, created_at)
+       VALUES (?, 'supersedes', ?, 0.9, ?)
+       ON CONFLICT(source_memory_id, relation, target_memory_id) DO UPDATE SET confidence = 0.9`).run(newId, oldId, ts);
+    });
+    tx();
+}
+export function archive(id) {
+    const mem = getMemoryById(id);
+    if (!mem)
+        throw new LifecycleError(`memory ${id} not found`);
+    if (mem.status === "deleted")
+        throw new LifecycleError(`cannot archive deleted memory ${id}`);
+    return transitionStatus(id, "archived");
+}
+export function softDelete(id) {
+    return transitionStatus(id, "deleted");
+}

package/dist/core/retrieval-engine.js

@@ -0,0 +1,40 @@
+import { db } from "../db/index.js";
+import { ftsSearch } from "../retrieval/fts.js";
+import { vectorSearch } from "../retrieval/vector.js";
+import { rrfFuse } from "../retrieval/fusion.js";
+import { finalScore, scopeFactorFor } from "../retrieval/scorer.js";
+import { recencyFactorFor } from "../memory/decay.js";
+// Hybrid retrieval pipeline (spec §13): FTS + vector -> RRF fusion -> scoring/rerank -> filter -> topK
+export function retrieve(query, opts = {}) {
+    const limit = Math.min(Math.max(opts.limit ?? 10, 1), 50);
+    const fts = ftsSearch(query, opts);
+    const vecRaw = vectorSearch(query, opts);
+    const vec = vecRaw.map((r, i) => ({
+        id: r.id,
+        rank: i + 1,
+    }));
+    const fused = rrfFuse([fts, vec]);
+    const now = new Date();
+    const out = [];
+    for (const [id, rrf] of fused.entries()) {
+        const mem = db
+            .prepare("SELECT * FROM memories WHERE id = ?")
+            .get(id);
+        if (!mem)
+            continue;
+        if (!opts.includeArchived &&
+            (mem.status === "deleted" || mem.status === "archived"))
+            continue;
+        const recency = recencyFactorFor(mem.type, mem.updated_at, now);
+        const scope = scopeFactorFor(mem, opts.projectId);
+        const fs = finalScore({
+            rrf,
+            confidence: mem.confidence,
+            importance: mem.importance,
+            recency,
+            scopeFactor: scope,
+        });
+        out.push({ ...mem, rrf, final_score: fs });
+    }
+    return out.sort((a, b) => b.final_score - a.final_score).slice(0, limit);
+}

package/dist/core/temporal-engine.js

@@ -0,0 +1,73 @@
+import { db } from "../db/index.js";
+import { getMemoryById } from "../db/repositories/memories.js";
+export function setValidity(id, validFrom, validUntil) {
+    const mem = getMemoryById(id);
+    if (!mem)
+        throw new Error(`memory ${id} not found`);
+    db.prepare(`UPDATE memories SET valid_from = ?, valid_until = ?, updated_at = ? WHERE id = ?`).run(validFrom, validUntil, new Date().toISOString(), id);
+    return getMemoryById(id);
+}
+// Memories that were valid at time T (inclusive). Excludes logically deleted.
+export function memoriesValidAt(isoTs, opts = {}) {
+    const limit = Math.min(Math.max(opts.limit ?? 50, 1), 200);
+    const clauses = [
+        "(valid_from IS NULL OR valid_from <= @t)",
+        "(valid_until IS NULL OR valid_until >= @t)",
+        "status != 'deleted'",
+    ];
+    const params = { t: isoTs, limit };
+    if (opts.projectId) {
+        clauses.push("(project_id = @projectId OR project_id IS NULL)");
+        params.projectId = opts.projectId;
+    }
+    if (opts.types && opts.types.length) {
+        const ph = opts.types.map((_, i) => `@type${i}`).join(",");
+        clauses.push(`type IN (${ph})`);
+        opts.types.forEach((t, i) => (params[`type${i}`] = t));
+    }
+    return db
+        .prepare(`SELECT * FROM memories WHERE ${clauses.join(" AND ")} ORDER BY updated_at DESC LIMIT @limit`)
+        .all(params);
+}
+// Walk the supersession chain: oldest -> newest, centered on the given memory.
+export function supersessionChain(id) {
+    const start = getMemoryById(id);
+    if (!start)
+        return [];
+    const seen = new Set();
+    // backward: follow supersedes_id to the root (oldest)
+    const backward = [];
+    let cur = start;
+    while (cur && cur.supersedes_id != null && !seen.has(cur.id)) {
+        seen.add(cur.id);
+        const prev = getMemoryById(cur.supersedes_id);
+        if (!prev)
+            break;
+        backward.unshift(prev);
+        cur = prev;
+    }
+    // forward: find memories whose supersedes_id == current newest
+    const forward = [];
+    cur = start;
+    seen.clear();
+    while (cur && !seen.has(cur.id)) {
+        seen.add(cur.id);
+        forward.push(cur);
+        const next = db
+            .prepare("SELECT id FROM memories WHERE supersedes_id = ? LIMIT 1")
+            .get(cur.id);
+        if (!next)
+            break;
+        cur = getMemoryById(next.id);
+    }
+    return [...backward, ...forward];
+}
+// Change detection: memories created or updated within [t1, t2].
+export function changesBetween(t1, t2, limit = 100) {
+    return db
+        .prepare(`SELECT * FROM memories
+       WHERE updated_at >= @t1 AND updated_at <= @t2 AND status != 'deleted'
+       ORDER BY updated_at DESC
+       LIMIT @limit`)
+        .all({ t1, t2, limit });
+}

package/dist/db/index.js

@@ -0,0 +1,111 @@
+import Database from "better-sqlite3";
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { truncate } from "../lib/capture-core.js";
+import { serialize } from "../lib/embed.js";
+import { DEFAULT_DB_PATH } from "../lib/config.js";
+import { runMigrations } from "./migrations.js";
+export const DB_PATH = process.env.MEMORY_DB_PATH ?? DEFAULT_DB_PATH;
+function initDb() {
+    try {
+        mkdirSync(dirname(DB_PATH), { recursive: true });
+        return new Database(DB_PATH);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.error(`[th-memory-mcp] cannot open DB at ${DB_PATH}: ${msg}`);
+        process.exit(1);
+    }
+}
+export const db = initDb();
+db.pragma("journal_mode = WAL");
+db.pragma("busy_timeout = 5000");
+db.exec(`
+CREATE TABLE IF NOT EXISTS interactions (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  ts TEXT NOT NULL,
+  session_id TEXT,
+  kind TEXT NOT NULL,
+  content TEXT NOT NULL,
+  meta TEXT
+);
+
+CREATE TABLE IF NOT EXISTS preferences (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  category TEXT NOT NULL,
+  key TEXT NOT NULL,
+  value TEXT NOT NULL,
+  confidence REAL DEFAULT 0.5,
+  source TEXT DEFAULT 'explicit',
+  updated_at TEXT NOT NULL,
+  UNIQUE(category, key)
+);
+
+CREATE TABLE IF NOT EXISTS lessons (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  situation TEXT NOT NULL,
+  mistake TEXT NOT NULL,
+  correction TEXT NOT NULL,
+  created_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS profile (
+  section TEXT PRIMARY KEY,
+  content TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS search_index USING fts5(
+  ref_table, ref_id, title, body
+);
+
+CREATE TABLE IF NOT EXISTS embeddings (
+  ref_table TEXT NOT NULL,
+  ref_id INTEGER NOT NULL,
+  vec BLOB NOT NULL,
+  PRIMARY KEY (ref_table, ref_id)
+);
+`);
+// v2 migration engine (non-destructive: only adds new tables + backfills from v1)
+runMigrations(db);
+export function nowISO() {
+    return new Date().toISOString();
+}
+// re-exported from lib/capture-core.js (single source of truth)
+export { truncate };
+export function escapeLike(text) {
+    return text.replace(/[\\%_]/g, (c) => "\\" + c);
+}
+export function buildFtsMatch(query) {
+    const tokens = query.trim().split(/\s+/).filter(Boolean).slice(0, 8);
+    return tokens.map((t) => `"${t.replace(/"/g, "")}"`).join(" OR ");
+}
+const insertSearchIndex = db.prepare("INSERT INTO search_index (ref_table, ref_id, title, body) VALUES (?, ?, ?, ?)");
+const deleteSearchIndex = db.prepare("DELETE FROM search_index WHERE ref_table = ? AND ref_id = ?");
+export function syncSearchIndex(refTable, refId, title, body) {
+    deleteSearchIndex.run(refTable, refId);
+    insertSearchIndex.run(refTable, refId, title, body);
+}
+export function removeSearchIndex(refTable, refId) {
+    deleteSearchIndex.run(refTable, refId);
+}
+// --- vector embeddings (lightweight local semantic search) ---
+const upsertEmbed = db.prepare(`INSERT INTO embeddings (ref_table, ref_id, vec) VALUES (?, ?, ?)
+   ON CONFLICT(ref_table, ref_id) DO UPDATE SET vec = excluded.vec`);
+const deleteEmbed = db.prepare("DELETE FROM embeddings WHERE ref_table = ? AND ref_id = ?");
+const allEmbeds = db.prepare("SELECT ref_table, ref_id, vec FROM embeddings");
+export function upsertEmbedding(refTable, refId, vec) {
+    upsertEmbed.run(refTable, refId, serialize(vec));
+}
+export function removeEmbedding(refTable, refId) {
+    deleteEmbed.run(refTable, refId);
+}
+export function getAllEmbeddings() {
+    return allEmbeds.all();
+}
+export function ok(text) {
+    return { content: [{ type: "text", text }] };
+}
+export function err(text) {
+    return ok(`error: ${truncate(text, 300)}`);
+}

package/dist/db/migrations.js

@@ -0,0 +1,160 @@
+import { embed, serialize } from "../lib/embed.js";
+const M001_schema_meta = {
+    id: "001_schema_meta",
+    up(db) {
+        db.exec(`CREATE TABLE IF NOT EXISTS schema_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);`);
+        const existing = db
+            .prepare("SELECT value FROM schema_meta WHERE key = 'schema_version'")
+            .get();
+        if (!existing) {
+            db.prepare("INSERT INTO schema_meta (key, value) VALUES ('schema_version', '2')").run();
+        }
+    },
+};
+const M002_memories = {
+    id: "002_memories",
+    up(db) {
+        db.exec(`CREATE TABLE IF NOT EXISTS memories (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      type TEXT NOT NULL,
+      content TEXT NOT NULL,
+      summary TEXT,
+      status TEXT NOT NULL DEFAULT 'active',
+      source TEXT NOT NULL DEFAULT 'explicit',
+      confidence REAL NOT NULL DEFAULT 0.5,
+      importance REAL NOT NULL DEFAULT 0.5,
+      salience REAL NOT NULL DEFAULT 0.5,
+      project_id TEXT,
+      session_id TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      last_accessed_at TEXT,
+      access_count INTEGER NOT NULL DEFAULT 0,
+      valid_from TEXT,
+      valid_until TEXT,
+      supersedes_id INTEGER,
+      metadata TEXT,
+      FOREIGN KEY (supersedes_id) REFERENCES memories(id)
+    );`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_type_status ON memories(type, status);`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_project_status ON memories(project_id, status);`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_updated ON memories(updated_at);`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_validity ON memories(valid_from, valid_until);`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_supersedes ON memories(supersedes_id);`);
+    },
+};
+const M003_entities_relations = {
+    id: "003_entities_relations",
+    up(db) {
+        db.exec(`CREATE TABLE IF NOT EXISTS entities (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      canonical_name TEXT NOT NULL,
+      type TEXT,
+      metadata TEXT
+    );`);
+        db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_entities_canonical ON entities(canonical_name);`);
+        db.exec(`CREATE TABLE IF NOT EXISTS relations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      source_entity_id INTEGER NOT NULL,
+      relation TEXT NOT NULL,
+      target_entity_id INTEGER NOT NULL,
+      confidence REAL NOT NULL DEFAULT 0.5,
+      valid_from TEXT,
+      valid_until TEXT,
+      source_memory_id INTEGER,
+      metadata TEXT,
+      FOREIGN KEY (source_entity_id) REFERENCES entities(id),
+      FOREIGN KEY (target_entity_id) REFERENCES entities(id),
+      FOREIGN KEY (source_memory_id) REFERENCES memories(id)
+    );`);
+    },
+};
+const M004_memory_links = {
+    id: "004_memory_links",
+    up(db) {
+        db.exec(`CREATE TABLE IF NOT EXISTS memory_links (
+      source_memory_id INTEGER NOT NULL,
+      relation TEXT NOT NULL,
+      target_memory_id INTEGER NOT NULL,
+      confidence REAL NOT NULL DEFAULT 0.5,
+      created_at TEXT NOT NULL,
+      PRIMARY KEY (source_memory_id, relation, target_memory_id),
+      FOREIGN KEY (source_memory_id) REFERENCES memories(id),
+      FOREIGN KEY (target_memory_id) REFERENCES memories(id)
+    );`);
+    },
+};
+const M005_backfill_v1 = {
+    id: "005_backfill_v1",
+    up(db) {
+        const done = db
+            .prepare("SELECT value FROM schema_meta WHERE key = 'v1_backfilled'")
+            .get();
+        if (done)
+            return;
+        const memCount = db.prepare("SELECT COUNT(*) AS c FROM memories").get().c;
+        if (memCount > 0) {
+            db.prepare("INSERT INTO schema_meta (key, value) VALUES ('v1_backfilled', '1') ON CONFLICT(key) DO UPDATE SET value = '1'").run();
+            return;
+        }
+        const now = new Date().toISOString();
+        const insertSearch = db.prepare("INSERT INTO search_index (ref_table, ref_id, title, body) VALUES ('memories', ?, ?, ?)");
+        const insertEmbed = db.prepare("INSERT INTO embeddings (ref_table, ref_id, vec) VALUES ('memories', ?, ?) ON CONFLICT(ref_table, ref_id) DO UPDATE SET vec = excluded.vec");
+        const insPref = db.prepare(`INSERT INTO memories (type, content, status, source, confidence, project_id, created_at, updated_at, metadata)
+       VALUES ('PREFERENCE', @content, 'active', @source, @confidence, NULL, @ts, @ts, NULL)`);
+        const insLes = db.prepare(`INSERT INTO memories (type, content, status, source, confidence, project_id, created_at, updated_at, metadata)
+       VALUES ('LESSON', @content, 'active', 'corrected', 0.95, NULL, @ts, @ts, NULL)`);
+        const tx = db.transaction(() => {
+            const prefs = db
+                .prepare("SELECT category, key, value, source, confidence, updated_at FROM preferences")
+                .all();
+            for (const p of prefs) {
+                const content = `[${p.category}] ${p.key} = ${p.value}`;
+                const info = insPref.run({
+                    content,
+                    source: p.source ?? "explicit",
+                    confidence: p.confidence ?? 0.5,
+                    ts: p.updated_at ?? now,
+                });
+                const id = Number(info.lastInsertRowid);
+                insertSearch.run(id, p.category, content);
+                insertEmbed.run(id, serialize(embed(content)));
+            }
+            const lessons = db
+                .prepare("SELECT situation, mistake, correction, created_at FROM lessons")
+                .all();
+            for (const l of lessons) {
+                const content = `Situation: ${l.situation} | Mistake: ${l.mistake} | Correction: ${l.correction}`;
+                const info = insLes.run({ content, ts: l.created_at ?? now });
+                const id = Number(info.lastInsertRowid);
+                insertSearch.run(id, "LESSON", content);
+                insertEmbed.run(id, serialize(embed(content)));
+            }
+        });
+        tx();
+        db.prepare("INSERT INTO schema_meta (key, value) VALUES ('v1_backfilled', '1') ON CONFLICT(key) DO UPDATE SET value = '1'").run();
+    },
+};
+export const MIGRATIONS = [
+    M001_schema_meta,
+    M002_memories,
+    M003_entities_relations,
+    M004_memory_links,
+    M005_backfill_v1,
+];
+export function runMigrations(db) {
+    db.exec(`CREATE TABLE IF NOT EXISTS schema_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);`);
+    for (const m of MIGRATIONS) {
+        const applied = db
+            .prepare("SELECT value FROM schema_meta WHERE key = ?")
+            .get(m.id);
+        if (applied)
+            continue;
+        const tx = db.transaction(() => {
+            m.up(db);
+            db.prepare("INSERT INTO schema_meta (key, value) VALUES (?, '1') ON CONFLICT(key) DO UPDATE SET value = '1'").run(m.id);
+        });
+        tx();
+    }
+}

package/dist/db/repositories/memories.js

@@ -0,0 +1,52 @@
+import { db, syncSearchIndex, removeSearchIndex, upsertEmbedding, removeEmbedding, nowISO, } from "../../db/index.js";
+import { embed } from "../../lib/embed.js";
+import { retrieve } from "../../core/retrieval-engine.js";
+export function createMemory(input) {
+    const ts = nowISO();
+    const info = db
+        .prepare(`INSERT INTO memories
+       (type, content, summary, status, source, confidence, importance, salience,
+        project_id, session_id, created_at, updated_at, last_accessed_at, access_count,
+        valid_from, valid_until, metadata)
+       VALUES (@type, @content, @summary, @status, @source, @confidence, @importance, @salience,
+        @projectId, @sessionId, @ts, @ts, NULL, 0, @validFrom, @validUntil, @metadata)`)
+        .run({
+        type: input.type,
+        content: input.content,
+        summary: input.summary ?? null,
+        status: input.status ?? "active",
+        source: input.source ?? "explicit",
+        confidence: input.confidence ?? 0.5,
+        importance: input.importance ?? 0.5,
+        salience: input.salience ?? 0.5,
+        projectId: input.projectId ?? null,
+        sessionId: input.sessionId ?? null,
+        ts,
+        validFrom: input.validFrom ?? null,
+        validUntil: input.validUntil ?? null,
+        metadata: input.metadata != null ? JSON.stringify(input.metadata) : null,
+    });
+    const id = Number(info.lastInsertRowid);
+    syncMemoryIndex(id, input.type, input.content);
+    return id;
+}
+export function syncMemoryIndex(id, title, body) {
+    syncSearchIndex("memories", id, title, body);
+    upsertEmbedding("memories", id, embed(body));
+}
+export function getMemoryById(id) {
+    return db.prepare("SELECT * FROM memories WHERE id = ?").get(id);
+}
+export function setStatus(id, status) {
+    db.prepare("UPDATE memories SET status = ?, updated_at = ? WHERE id = ?").run(status, nowISO(), id);
+}
+export function softDelete(id) {
+    setStatus(id, "deleted");
+}
+export function removeMemoryIndex(id) {
+    removeSearchIndex("memories", id);
+    removeEmbedding("memories", id);
+}
+export function searchMemories(query, opts = {}) {
+    return retrieve(query, opts);
+}

package/dist/db.js

@@ -4,6 +4,7 @@ import { dirname } from "node:path";
 import { truncate } from "./lib/capture-core.js";
 import { serialize } from "./lib/embed.js";
 import { DEFAULT_DB_PATH } from "./lib/config.js";
+import { runMigrations } from "./migrations.js";
 export const DB_PATH = process.env.MEMORY_DB_PATH ?? DEFAULT_DB_PATH;
 function initDb() {
     try {
@@ -65,6 +66,8 @@ CREATE TABLE IF NOT EXISTS embeddings (
   PRIMARY KEY (ref_table, ref_id)
 );
 `);
+// v2 migration engine (non-destructive: only adds new tables + backfills from v1)
+runMigrations(db);
 export function nowISO() {
     return new Date().toISOString();
 }

package/dist/index.js

@@ -10,6 +10,8 @@ import { forgetInput, forgetHandler } from "./tools/forget.js";
 import { memoryStatsHandler } from "./tools/memory_stats.js";
 import { recentInteractionsInput, getRecentInteractionsHandler, } from "./tools/recent_interactions.js";
 import { exportMemoryInput, exportMemoryHandler, } from "./tools/export_memory.js";
+import { contextInput, contextHandler } from "./tools/context.js";
+import { consolidateInput, consolidateHandler } from "./tools/consolidate.js";
 import { VERSION } from "./lib/config.js";
 const server = new McpServer({
     name: "th-memory-mcp",
@@ -60,6 +62,16 @@ server.registerTool("export_memory", {
     description: "Export preferences, lessons, profile (and optionally raw interactions) to a JSON file under data/exports/. Only writes inside that directory. Returns the file path, size in bytes and a JSON preview.",
     inputSchema: exportMemoryInput,
 }, (args) => exportMemoryHandler(args));
+server.registerTool("get_context", {
+    title: "Get assembled context",
+    description: "Assemble relevant memories for the current task via hybrid retrieval (+ optional memory-graph expansion), with token budgeting. Use to load memory into context before a task.",
+    inputSchema: contextInput,
+}, (args) => contextHandler(args));
+server.registerTool("consolidate", {
+    title: "Consolidate memories",
+    description: "Cluster similar memories via embedding similarity and optionally create derived/consolidated memories linked via 'derived_from'. Use during periodic consolidation.",
+    inputSchema: consolidateInput,
+}, (args) => consolidateHandler(args));
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/lib/embed.js

@@ -53,13 +53,16 @@ export function cosine(a, b) {
     return dot;
 }
 export function serialize(vec) {
-    const copy = new Float32Array(EMBED_DIM);
-    copy.set(vec);
-    return Buffer.from(copy.buffer);
+    const buf = Buffer.alloc(EMBED_DIM * 4);
+    const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    for (let i = 0; i < EMBED_DIM; i++)
+        dv.setFloat32(i * 4, vec[i] ?? 0, true);
+    return buf;
 }
 export function deserialize(buf) {
     const out = new Float32Array(EMBED_DIM);
-    const ab = Buffer.from(buf).buffer.slice(0, EMBED_DIM * 4);
-    out.set(new Float32Array(ab));
+    const view = new DataView(buf.buffer, buf.byteOffset, Math.min(EMBED_DIM * 4, buf.byteLength));
+    for (let i = 0; i < EMBED_DIM; i++)
+        out[i] = view.getFloat32(i * 4, true);
     return out;
 }