openclaw-plugin-memory-engine 3.1.0

package/dist/embeddings.js

@@ -0,0 +1,63 @@
+const OLLAMA = process.env.OLLAMA_HOST ?? "http://ollama:11434";
+const MODEL = process.env.ME_EMBED_MODEL ?? "nomic-embed-text";
+export async function embed(text) {
+    try {
+        const res = await fetch(OLLAMA + "/api/embed", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ model: MODEL, input: text }),
+            signal: AbortSignal.timeout(8000),
+        });
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        const vec = data?.embeddings?.[0] ?? data?.embedding;
+        if (!vec || !vec.length)
+            return null;
+        return new Float32Array(vec);
+    }
+    catch {
+        return null;
+    }
+}
+function cosine(a, b) {
+    let dot = 0, na = 0, nb = 0;
+    const n = Math.min(a.length, b.length);
+    for (let i = 0; i < n; i++) {
+        dot += a[i] * b[i];
+        na += a[i] * a[i];
+        nb += b[i] * b[i];
+    }
+    if (!na || !nb)
+        return 0;
+    return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+export async function semanticSearch(db, query, limit = 10, domain) {
+    const qv = await embed(query);
+    if (!qv)
+        return [];
+    const rows = db
+        .prepare("SELECT e.atom_id as id, e.embedding, a.title, a.domain, a.type, a.status " +
+        "FROM atom_embeddings e JOIN atoms a ON a.id = e.atom_id " +
+        "WHERE a.status = 'active'")
+        .all();
+    const scored = [];
+    for (const r of rows) {
+        if (domain && r.domain !== domain)
+            continue;
+        const v = new Float32Array(r.embedding.buffer, r.embedding.byteOffset, r.embedding.byteLength / 4);
+        scored.push({ id: r.id, title: r.title, domain: r.domain, type: r.type, semantic_score: Math.round(cosine(qv, v) * 10000) / 10000 });
+    }
+    scored.sort((a, b) => b.semantic_score - a.semantic_score);
+    return scored.slice(0, limit);
+}
+export async function embedAtom(db, atomId, text) {
+    const v = await embed(text);
+    if (!v)
+        return false;
+    const buf = Buffer.from(v.buffer, v.byteOffset, v.byteLength);
+    const now = Math.floor(Date.now() / 1000);
+    db.prepare("INSERT INTO atom_embeddings (atom_id, embedding, model, dim, created_at, updated_at) VALUES (?,?,?,?,?,?) " +
+        "ON CONFLICT(atom_id) DO UPDATE SET embedding = excluded.embedding, updated_at = excluded.updated_at").run(atomId, buf, MODEL, v.length, now, now);
+    return true;
+}

package/dist/engine.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Memory Engine TS — F2: engine port (faithful translation of engine.py).
+ * Ranking formula, recall merge/filter and graph expansion are IDENTICAL
+ * to the Python implementation; parity tests are the spec.
+ */
+import { DatabaseSync } from "node:sqlite";
+export interface Row {
+    [k: string]: any;
+}
+export declare class Engine {
+    db: DatabaseSync;
+    config: any;
+    constructor(db: DatabaseSync, config?: any);
+    static INTENT_RULES: Array<[string, string[]]>;
+    static classifyIntent(query: string): Record<string, number>;
+    searchFts(query: string, limit?: number, statuses?: string[], memoryTier?: string): Row[];
+    getRelatedAtoms(atomId: string, limit?: number, minStrength?: number): Row[];
+    rankResults(ftsResults: Row[], query: string): Row[];
+    recall(query: string, limit?: number, opts?: {
+        domain?: string | null;
+        semantic?: boolean;
+        memoryTier?: string;
+        includeSuperseded?: boolean;
+        minWeight?: number;
+    }): Row[];
+    expandGraphContext(ranked: Row[], limit: number, domain: string | null | undefined, minWeight: number, seedLimit: number, neighborLimit: number, graphWeight: number, minStrength: number): Row[];
+}

package/dist/engine.js

@@ -0,0 +1,165 @@
+const DEFAULT_CONFIG = {
+    ranking: {},
+    graph_recall: {},
+};
+function escRe(s) { return s; }
+export class Engine {
+    db;
+    config;
+    constructor(db, config = {}) {
+        this.db = db;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    static INTENT_RULES = [
+        ["preference", ["preferisci", "preferenza", "preferenze", "mi piace", "voglio che", "come devo rispondere", "style", "tone"]],
+        ["decision", ["perche", "perché", "deciso", "scelto", "scelta", "decisione", "motivo", "ramificata", "trade-off"]],
+        ["procedure", ["come si fa", "procedura", "passi", "installare", "configurare", "ripristinare", "deploy", "workflow", "istruzioni"]],
+        ["error", ["errore", "error", "fallito", "fallisce", "problema", "rompe", "bug"]],
+    ];
+    static classifyIntent(query) {
+        const q = (query || "").toLowerCase();
+        const boosts = {};
+        for (const [type, kws] of Engine.INTENT_RULES) {
+            const hits = kws.reduce((n, k) => (q.includes(k) ? n + 1 : n), 0);
+            if (hits)
+                boosts[type] = Math.min(0.15, 0.05 * hits);
+        }
+        return boosts;
+    }
+    searchFts(query, limit = 10, statuses = ["active"], memoryTier) {
+        const clean = query.replace(/["'*:()\-^]/g, " ").trim();
+        if (!clean)
+            return [];
+        const ftsQuery = clean.split(/\s+/).filter((w) => w.length > 1).map((w) => '"' + w + '"*').join(" OR ");
+        if (!ftsQuery)
+            return [];
+        const ph = statuses.map(() => "?").join(",");
+        const params = [ftsQuery, ...statuses];
+        let tier = "";
+        if (memoryTier) {
+            tier = " AND a.memory_tier = ?";
+            params.push(memoryTier);
+        }
+        params.push(limit);
+        const sql = "SELECT a.*, bm25(atoms_fts) as fts_score FROM atoms_fts JOIN atoms a ON atoms_fts.rowid = a.rowid " +
+            "WHERE atoms_fts MATCH ? AND a.status IN (" + ph + ")" + tier +
+            " ORDER BY CASE a.status WHEN 'active' THEN 0 ELSE 1 END, fts_score LIMIT ?";
+        return this.db.prepare(sql).all(...params);
+    }
+    getRelatedAtoms(atomId, limit = 10, minStrength = 0.0) {
+        const sql = "SELECT a.*, b.relation, b.strength, b.evidence, b.from_id, b.to_id, " +
+            "CASE WHEN b.from_id = ? THEN 'out' ELSE 'in' END as direction " +
+            "FROM bonds b JOIN atoms a ON a.id = CASE WHEN b.from_id = ? THEN b.to_id ELSE b.from_id END " +
+            "WHERE (b.from_id = ? OR b.to_id = ?) AND b.strength >= ? AND a.status = 'active' " +
+            "ORDER BY b.strength DESC, a.weight DESC, a.access_count DESC LIMIT ?";
+        return this.db.prepare(sql).all(atomId, atomId, atomId, atomId, minStrength, limit);
+    }
+    rankResults(ftsResults, query) {
+        const cfg = this.config.ranking || {};
+        const wFts = cfg.fts_weight ?? 0.30;
+        const wSem = cfg.semantic_weight ?? 0.30;
+        const wConf = cfg.confidence_weight ?? 0.20;
+        const wRecency = cfg.recency_weight ?? 0.10;
+        const wWeight = cfg.weight_factor ?? 0.10;
+        const tierBoosts = cfg.tier_boosts ?? { semantic: 0.04, procedural: 0.03, episodic: 0.0 };
+        const statusPenalties = cfg.status_penalties ?? { superseded: -0.25, archived: -0.15, stale: -0.10, merged: -0.35 };
+        const expiredPenalty = cfg.expired_penalty ?? -0.30;
+        const intentBoosts = Engine.classifyIntent(query);
+        const now = Math.floor(Date.now() / 1000);
+        const scored = [];
+        for (const row of ftsResults) {
+            const rawFts = row.fts_score;
+            const ftsNorm = rawFts !== null && rawFts !== undefined ? (rawFts ? 1.0 / (1.0 + Math.abs(rawFts)) : 0.5) : 0.0;
+            const semNorm = row.semantic_score ?? 0.0;
+            const conf = row.confidence ?? 0.5;
+            const ageDays = Math.max(0, (now - (row.accessed_at ?? now)) / 86400);
+            const recency = Math.exp(-ageDays / 90.0);
+            const weightNorm = Math.min(1.0, (row.weight ?? 1.0) / 2.0);
+            let tierBoost = tierBoosts[row.memory_tier ?? "semantic"] ?? 0.0;
+            let statusPenalty = statusPenalties[row.status ?? "active"] ?? 0.0;
+            const vuntil = row.valid_until;
+            if (vuntil && now > vuntil)
+                statusPenalty += expiredPenalty;
+            const intentBoost = intentBoosts[row.type ?? ""] ?? 0.0;
+            let score = wFts * ftsNorm + wSem * semNorm + wConf * conf + wRecency * recency +
+                wWeight * weightNorm + tierBoost + statusPenalty + intentBoost;
+            score = Math.max(0.0, Math.min(1.0, score));
+            row.rank_score = Math.round(score * 10000) / 10000;
+            row.rank_breakdown = { final: row.rank_score, intent_boost: Math.round(intentBoost * 1000) / 1000 };
+            scored.push(row);
+        }
+        scored.sort((a, b) => b.rank_score - a.rank_score);
+        return scored;
+    }
+    recall(query, limit = 5, opts = {}) {
+        const { domain, semantic = false, memoryTier, includeSuperseded = false, minWeight = 0.0 } = opts;
+        const g = this.config.graph_recall || {};
+        const graphEnabled = g.enabled ?? true;
+        const seedLimit = Math.max(1, g.seed_limit ?? 3);
+        const neighborLimit = Math.max(0, g.neighbors_per_seed ?? 4);
+        const graphWeight = g.graph_weight ?? 0.55;
+        const minStrength = g.min_strength ?? 0.35;
+        const statuses = includeSuperseded ? ["active", "superseded"] : ["active"];
+        const ftsResults = this.searchFts(query, limit * 3, statuses, memoryTier);
+        const merged = {};
+        for (const r of ftsResults) {
+            r.semantic_score = null;
+            r.match_kind = "direct";
+            merged[r.id] = r;
+        }
+        const filtered = Object.values(merged).filter((r) => {
+            if ((r.weight ?? 1.0) < minWeight)
+                return false;
+            if (domain && r.domain !== domain)
+                return false;
+            if (memoryTier && r.memory_tier !== memoryTier)
+                return false;
+            if (!includeSuperseded && (r.status ?? "active") !== "active")
+                return false;
+            return true;
+        });
+        let ranked = this.rankResults(filtered, query);
+        ranked = this.expandGraphContext(ranked, limit, domain, minWeight, seedLimit, neighborLimit, graphWeight, minStrength);
+        return ranked.slice(0, limit);
+    }
+    expandGraphContext(ranked, limit, domain, minWeight, seedLimit, neighborLimit, graphWeight, minStrength) {
+        if (neighborLimit <= 0 || ranked.length === 0)
+            return ranked;
+        const byId = {};
+        for (const r of ranked)
+            byId[r.id] = r;
+        const expanded = [...ranked];
+        for (const seed of ranked.slice(0, seedLimit)) {
+            const neighbors = this.getRelatedAtoms(seed.id, neighborLimit, minStrength);
+            for (const n of neighbors) {
+                if ((n.weight ?? 1.0) < minWeight)
+                    continue;
+                if (domain && n.domain !== domain)
+                    continue;
+                if ((n.status ?? "active") !== "active")
+                    continue;
+                let rel = seed.rank_score * (n.strength ?? 0.5) * graphWeight;
+                rel *= Math.min(1.0, (n.weight ?? 1.0) / 2.0);
+                rel = Math.round(rel * 10000) / 10000;
+                if (byId[n.id]) {
+                    const ex = byId[n.id];
+                    if (rel > (ex.graph_score ?? 0))
+                        ex.graph_score = rel;
+                    ex.rank_score = Math.round(Math.min(1.0, ex.rank_score + rel * 0.25) * 10000) / 10000;
+                    ex.match_kind = (ex.match_kind ?? "direct") + "+graph";
+                }
+                else {
+                    n.fts_score = null;
+                    n.semantic_score = null;
+                    n.rank_score = rel;
+                    n.match_kind = "graph";
+                    n.graph_score = rel;
+                    expanded.push(n);
+                    byId[n.id] = n;
+                }
+            }
+        }
+        expanded.sort((a, b) => b.rank_score - a.rank_score);
+        return expanded;
+    }
+}

package/dist/entry.d.ts

@@ -0,0 +1,14 @@
+declare const _default: Omit<{
+    id: string;
+    name: string;
+    description: string;
+    kind?: import("openclaw/plugin-sdk/plugin-entry").OpenClawPluginDefinition["kind"];
+    configSchema?: import("openclaw/plugin-sdk/plugin-entry").OpenClawPluginConfigSchema | (() => import("openclaw/plugin-sdk/plugin-entry").OpenClawPluginConfigSchema);
+    reload?: import("openclaw/plugin-sdk/plugin-entry").OpenClawPluginDefinition["reload"];
+    nodeHostCommands?: import("openclaw/plugin-sdk/plugin-entry").OpenClawPluginDefinition["nodeHostCommands"];
+    securityAuditCollectors?: import("openclaw/plugin-sdk/plugin-entry").OpenClawPluginDefinition["securityAuditCollectors"];
+    register: NonNullable<import("openclaw/plugin-sdk/plugin-entry").OpenClawPluginDefinition["register"]>;
+}, "configSchema"> & {
+    configSchema: import("openclaw/plugin-sdk/plugin-entry").OpenClawPluginConfigSchema;
+};
+export default _default;

package/dist/entry.js

@@ -0,0 +1,142 @@
+/**
+ * Memory Engine TS — plugin entry with native hooks.
+ * Tools (17) + periodic session ingest & digest (flush ogni 60s solo se ci sono nuovi messaggi).
+ */
+import { Type } from "typebox";
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { createTools, VERSION } from "./tools.js";
+import { Curator } from "./curator.js";
+import { buildSessionDigest } from "./digest.js";
+import { createHash } from "node:crypto";
+/** Il gateway puo' passare un tool-call id (stringa) come primo argomento:
+ *  i params stanno in uno degli argomenti successivi, o in un envelope. */
+const PARAM_KEYS = ["query", "title", "content", "id", "session_id", "atom_id", "from_id", "to_id", "relation", "task_description", "task_type", "mistake", "correction", "old_atom_id", "limit", "domain", "type", "confidence", "depth", "strength", "token_budget", "body", "reason"];
+function normalizeParams(a, rest = []) {
+    const cands = [a, ...rest].filter((x) => x && typeof x === "object" && !Array.isArray(x));
+    // 1) envelope
+    for (const c of cands) {
+        for (const k of ["arguments", "input", "params", "args"]) {
+            if (c[k] && typeof c[k] === "object" && !Array.isArray(c[k]))
+                return c[k];
+        }
+    }
+    // 2) primo candidato con chiavi param note
+    for (const c of cands) {
+        if (PARAM_KEYS.some((k) => k in c))
+            return c;
+    }
+    // 3) fallback: primo oggetto
+    return cands[0] ?? {};
+}
+const T = Type;
+/** Wrap nel tool-result shape richiesto dal contract "tools" di OpenClaw. */
+function wrapResult(result) {
+    const text = typeof result === "string" ? result : JSON.stringify(result ?? null);
+    return { content: [{ type: "text", text }] };
+}
+export default definePluginEntry({
+    id: "memory-engine",
+    name: "Memory Engine",
+    description: "Memory Engine ported as native OpenClaw tools + periodic session ingest & digest.",
+    register(api) {
+        const dbPath = process.env.MEMORY_DB_PATH ?? "/data/memory.db";
+        const me = createTools(dbPath);
+        const curator = new Curator(me.__db, me.__engine, (api.config ?? {}).curator ?? {});
+        const logger = api.logger ?? console;
+        // ── Tools ─────────────────────────────────────────────
+        const defs = [
+            { name: "memory_version", description: "Memory Engine TS version.", parameters: T.Object({}), execute: () => me.version() },
+            { name: "memory_recall", description: "Smart recall of past memories. Query short and specific.", parameters: T.Object({ query: T.String(), limit: T.Optional(T.Number()), domain: T.Optional(T.String()) }), execute: (a) => me.recall(a.query, a.limit ?? 5, a.domain) },
+            { name: "memory_remember", description: "Save a durable memory (fact, decision, procedure, preference).", parameters: T.Object({ title: T.String(), content: T.String(), type: T.Optional(T.String()), domain: T.Optional(T.String()), confidence: T.Optional(T.Number()) }), execute: (a) => me.remember(a.title, a.content, a.type ?? "fact", a.domain ?? "general", a.confidence ?? 0.8) },
+            { name: "memory_working_set", description: "Task context pack with token budget.", parameters: T.Object({ query: T.String(), domain: T.Optional(T.String()), limit: T.Optional(T.Number()), token_budget: T.Optional(T.Number()) }), execute: (a) => me.working_set(a.query, a.domain, a.limit ?? 8, a.token_budget ?? 2000) },
+            { name: "memory_get_atom", description: "Full atom by id.", parameters: T.Object({ id: T.String() }), execute: (a) => me.get_atom(a.id) },
+            { name: "memory_list_atoms", description: "List atoms by domain/type.", parameters: T.Object({ domain: T.Optional(T.String()), type: T.Optional(T.String()), limit: T.Optional(T.Number()) }), execute: (a) => me.list_atoms(a.domain, a.type, a.limit ?? 50) },
+            { name: "memory_link", description: "Bond two atoms.", parameters: T.Object({ from_id: T.String(), to_id: T.String(), relation: T.String(), strength: T.Optional(T.Number()) }), execute: (a) => me.link(a.from_id, a.to_id, a.relation, a.strength) },
+            { name: "memory_search_graph", description: "BFS graph traversal.", parameters: T.Object({ atom_id: T.String(), depth: T.Optional(T.Number()) }), execute: (a) => me.search_graph(a.atom_id, a.depth ?? 2) },
+            { name: "memory_contradict", description: "New atom supersedes old one.", parameters: T.Object({ old_atom_id: T.String(), title: T.String(), body: T.Optional(T.String()), reason: T.Optional(T.String()) }), execute: (a) => me.memory_contradict(a.old_atom_id, a.title, a.body ?? "", a.reason ?? "") },
+            { name: "memory_impact", description: "What depends on an atom.", parameters: T.Object({ atom_id: T.String(), depth: T.Optional(T.Number()) }), execute: (a) => me.memory_impact(a.atom_id, a.depth ?? 2) },
+            { name: "memory_preference_search", description: "Search stable preferences.", parameters: T.Object({ query: T.Optional(T.String()), limit: T.Optional(T.Number()) }), execute: (a) => me.preference_search(a.query, undefined, a.limit ?? 20) },
+            { name: "memory_error_check", description: "Known errors for a task.", parameters: T.Object({ task_description: T.String() }), execute: (a) => me.error_check(a.task_description) },
+            { name: "memory_error_log", description: "Log mistake + correction.", parameters: T.Object({ task_type: T.String(), mistake: T.String(), correction: T.String() }), execute: (a) => me.error_log(a.task_type, a.mistake, a.correction) },
+            { name: "memory_stats", description: "Memory statistics.", parameters: T.Object({}), execute: () => me.stats() },
+            { name: "memory_session_summary", description: "Digest of a session.", parameters: T.Object({ session_id: T.String() }), execute: (a) => me.session_summary(a.session_id) },
+            { name: "memory_generate_session_digest", description: "Generate digest atom for a session.", parameters: T.Object({ session_id: T.String() }), execute: (a) => me.generate_session_digest(a.session_id) },
+            { name: "memory_admin", description: "Admin jobs pointer.", parameters: T.Object({}), execute: () => me._admin_note() },
+            { name: "memory_curator_run", description: "Conservative curation pass: compact, bonds, isolated classification, promotions, merges. dry_run default true.", parameters: T.Object({ dry_run: T.Optional(T.Boolean()), auto_apply: T.Optional(T.Boolean()), max_atoms: T.Optional(T.Number()) }), execute: (a) => curator.run(a.dry_run ?? true, a.auto_apply ?? false, a.max_atoms) },
+            { name: "memory_cognitive_status", description: "Cognitive health metrics for the memory graph.", parameters: T.Object({}), execute: () => curator.status() },
+        ];
+        for (const d of defs) {
+            api.registerTool({
+                name: d.name,
+                description: d.description,
+                parameters: d.parameters,
+                execute: async (a, ...rest) => {
+                    return wrapResult(await d.execute(normalizeParams(a, rest)));
+                },
+            }, { contract: "tools" });
+        }
+        // ── Periodic ingest + digest (flush solo se cambiato) ──
+        const buffer = new Map();
+        const flushedCount = new Map(); // sid -> numero msg già scritti
+        api.on("message_received", (event) => {
+            try {
+                const sid = String(event?.sessionId ?? event?.sessionKey ?? "").replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 48) || "unknown";
+                const content = String(event?.body ?? event?.text ?? event?.content ?? "").slice(0, 2000);
+                if (!content)
+                    return;
+                const arr = buffer.get(sid) ?? [];
+                arr.push({ sessionId: sid, role: "user", content, ts: new Date().toISOString() });
+                buffer.set(sid, arr);
+            }
+            catch { /* never break inbound */ }
+        });
+        api.on("agent_end", (event) => {
+            try {
+                const sid = String(event?.sessionId ?? event?.sessionKey ?? "").replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 48) || "unknown";
+                const text = String(event?.reply ?? event?.finalMessage ?? event?.text ?? "").slice(0, 1000);
+                if (!text)
+                    return;
+                const arr = buffer.get(sid) ?? [];
+                arr.push({ sessionId: sid, role: "assistant", content: text, ts: new Date().toISOString() });
+                buffer.set(sid, arr);
+            }
+            catch { /* observe only */ }
+        });
+        function flushSession(sid, sidRaw) {
+            const db = me.__db;
+            const now = Math.floor(Date.now() / 1000);
+            const msgs = buffer.get(sid) ?? [];
+            const already = flushedCount.get(sid) ?? 0;
+            if (msgs.length <= already)
+                return; // nessun nuovo messaggio: skip
+            const fresh = msgs.slice(already);
+            // ingest session_msg atoms (dedup via content hash)
+            for (const m of fresh) {
+                const hash = createHash("md5").update(sid + "|" + m.role + "|" + m.content).digest("hex").slice(0, 12);
+                const atomId = "smsg_" + hash;
+                db.prepare("INSERT OR IGNORE INTO atoms (id, type, memory_tier, domain, title, body, confidence, status, source, weight, tags, meta, created_at, updated_at, accessed_at, ttl) VALUES (?,?,?,?,?,?,?,'active','ai',1.0,'[]','{}',?,?,?,?)").run(atomId, "session_msg", "episodic", "session/" + sid, "[" + m.role + "] " + m.content.slice(0, 60), JSON.stringify({ role: m.role, content: m.content, timestamp: m.ts }), 0.7, now, now, now, now + 7 * 86400);
+            }
+            // digest from ingested atoms (uses session_msg domain rows)
+            const draft = buildSessionDigest(db, sid, { ocSessionId: sidRaw });
+            if (draft) {
+                db.prepare("INSERT OR REPLACE INTO atoms (id, type, memory_tier, domain, title, body, confidence, status, source, weight, tags, meta, created_at, updated_at, accessed_at, ttl) VALUES (?,?,?,?,?,?,0.7,'active','ai',1.0,'[]','{}',?,?,?,?)").run(draft.id, "session_digest", "episodic", "session/" + sid, draft.title, draft.body, now, now, now, now + 7 * 86400);
+            }
+            flushedCount.set(sid, msgs.length);
+            logger.info?.("[memory-engine-ts] periodic flush session " + sid + " (" + fresh.length + " new msgs, digest " + (draft ? "ok" : "skip") + ")");
+        }
+        const FLUSH_MS = 60_000;
+        const timer = setInterval(() => {
+            try {
+                for (const [sid, arr] of buffer) {
+                    if (arr.length > (flushedCount.get(sid) ?? 0))
+                        flushSession(sid, sid);
+                }
+            }
+            catch (err) {
+                logger.warn?.("[memory-engine-ts] periodic flush error: " + String(err));
+            }
+        }, FLUSH_MS);
+        timer.unref?.();
+        logger.info?.("[memory-engine-ts] v" + VERSION + " registered: 17 tools + periodic ingest/digest (" + (FLUSH_MS / 1000) + "s)");
+    },
+});

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./entry.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { default } from "./entry.js";

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.test.js

@@ -0,0 +1,8 @@
+import { describe, expect, it } from "vitest";
+import entry from "./index.js";
+import { getToolPluginMetadata } from "openclaw/plugin-sdk/tool-plugin";
+describe("memory-engine-ts", () => {
+    it("declares tool metadata", () => {
+        expect(getToolPluginMetadata(entry)?.tools.map((tool) => tool.name)).toEqual(["echo"]);
+    });
+});

package/dist/tools.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Memory Engine TS — F3: complete tool registry.
+ * Agent-facing tools with full logic; heavy admin jobs stay on the
+ * Python server and are exposed as explicit pointers.
+ */
+import { DatabaseSync } from "node:sqlite";
+export declare const VERSION = "3.1.0";
+export declare function createTools(dbPath: string): {
+    __db: DatabaseSync;
+    version: () => {
+        version: string;
+        note: string;
+    };
+    recall: (query: string, limit?: number, domain?: string) => {
+        id: any;
+        title: any;
+        domain: any;
+        type: any;
+        confidence: any;
+        snippet: string;
+    }[];
+    semantic_search: (query: string, limit?: number, domain?: string) => Promise<{
+        id: string;
+        title: string;
+        domain: string;
+        type: string;
+        semantic_score: number;
+    }[] | {
+        id: any;
+        title: any;
+        semantic_score: null;
+        note: string;
+    }[]>;
+    remember: (title: string, content: string, type?: string, domain?: string, confidence?: number, tags?: string[]) => {
+        id: string;
+        title: string;
+        type: string;
+        domain: string;
+    };
+    get_atom: (id: string) => any;
+    list_atoms: (domain?: string, type?: string, limit?: number) => any[];
+    delete_atom: (id: string) => {
+        deleted: boolean;
+        id: string;
+    };
+    link: (fromId: string, toId: string, relation: string, strength?: number, evidence?: string) => {
+        linked: boolean;
+        from: string;
+        to: string;
+        relation: string;
+    };
+    unlink: (fromId: string, toId: string, relation: string) => {
+        unlinked: boolean;
+    };
+    search_graph: (atomId: string, depth?: number) => {
+        nodes: any[];
+        edges: any[];
+    };
+    working_set: (query: string, domain?: string, limit?: number, tokenBudget?: number | null) => any;
+    memory_contradict: (oldAtomId: string, title: string, body?: string, reason?: string) => {
+        contradiction_id: string;
+        old_atom_id: string;
+        new_atom_id: string;
+    };
+    list_contradictions: (atomId?: string, limit?: number) => any[];
+    memory_impact: (atomId: string, depth?: number) => {
+        nodes: any[];
+        edges: any[];
+        relation_breakdown: Record<string, number>;
+    };
+    preference_search: (query?: string, category?: string, limit?: number) => any[];
+    error_check: (taskDescription: string, limit?: number) => any[];
+    error_log: (taskType: string, mistake: string, correction: string, severity?: string) => {
+        id: string;
+        logged: boolean;
+    };
+    error_list: (resolved?: boolean, limit?: number) => any[];
+    stats: () => {
+        total_atoms: any;
+        active: any;
+        bonds: any;
+        contradictions: any;
+        by_domain: any;
+        by_type: any;
+    };
+    update_domain: (atomIds: string[], newDomain: string) => {
+        updated: string[];
+        new_domain: string;
+    };
+    session_summary: (sessionId: string) => any;
+    generate_session_digest: (sessionId: string) => {
+        created: boolean;
+        note: string;
+    } | {
+        id: string;
+        title: string;
+        body: string;
+        note?: undefined;
+        created: boolean;
+    };
+    _admin_note: () => string;
+};