openclaw-plugin-memory-engine 3.1.1 → 4.0.0

package/dist/ui-contract.js

@@ -0,0 +1,80 @@
+import { Type } from "typebox";
+import { defineFeatureContract } from "openclaw/plugin-sdk/feature-contract";
+export const contract = defineFeatureContract({
+    pluginId: "memory-engine",
+    operations: {
+        status: {
+            kind: "query",
+            description: "Cognitive health metrics for the memory graph.",
+            input: Type.Object({}, { additionalProperties: false }),
+            output: Type.Object({ atoms_active: Type.Integer(), durable_atoms: Type.Integer(), bonds: Type.Integer(), isolated: Type.Integer(), pending: Type.Integer(), missing_compact: Type.Integer(), by_type: Type.Record(Type.String(), Type.Integer()), recommendations: Type.Array(Type.String()) }, { additionalProperties: true }),
+        },
+        search: {
+            kind: "query",
+            description: "FTS search over memory atoms with optional type/domain filters.",
+            input: Type.Object({ query: Type.String({ maxLength: 500, minLength: 1 }), limit: Type.Optional(Type.Integer({ maximum: 100 })), type: Type.Optional(Type.String({ maxLength: 40 })), domain: Type.Optional(Type.String({ maxLength: 200 })) }, { additionalProperties: false }),
+            output: Type.Object({ results: Type.Array(Type.Object({ id: Type.String(), title: Type.String(), domain: Type.Optional(Type.String()), type: Type.Optional(Type.String()) })) }, { additionalProperties: true }),
+        },
+        atom: {
+            kind: "query",
+            description: "Full atom detail with bonds.",
+            input: Type.Object({ id: Type.String({ maxLength: 200 }) }, { additionalProperties: false }),
+            output: Type.Object({}, { additionalProperties: true }),
+        },
+        domains: {
+            kind: "query",
+            description: "List distinct domains with atom counts.",
+            input: Type.Object({}, { additionalProperties: false }),
+            output: Type.Object({ domains: Type.Array(Type.Object({ domain: Type.String(), count: Type.Integer() })) }, { additionalProperties: true }),
+        },
+        curator_dry: {
+            kind: "action",
+            description: "Run curator in dry-run mode.",
+            input: Type.Object({ max_atoms: Type.Optional(Type.Integer({ maximum: 200 })) }, { additionalProperties: false }),
+            output: Type.Object({}, { additionalProperties: true }),
+        },
+        curator_apply: {
+            kind: "action",
+            description: "Run curator with auto_apply (safe actions only).",
+            input: Type.Object({ max_atoms: Type.Optional(Type.Integer({ maximum: 200 })) }, { additionalProperties: false }),
+            output: Type.Object({}, { additionalProperties: true }),
+        },
+        backups_list: {
+            kind: "query",
+            description: "List available backups.",
+            input: Type.Object({}, { additionalProperties: false }),
+            output: Type.Object({ backups: Type.Array(Type.Object({ file: Type.String(), size_bytes: Type.Integer(), created: Type.String() })) }, { additionalProperties: true }),
+        },
+        backup_now: {
+            kind: "action",
+            description: "Create a database backup now.",
+            input: Type.Object({}, { additionalProperties: false }),
+            output: Type.Object({}, { additionalProperties: true }),
+        },
+        questions_list: {
+            kind: "query",
+            description: "List pending human questions.",
+            input: Type.Object({ limit: Type.Optional(Type.Integer({ maximum: 50 })) }, { additionalProperties: false }),
+            output: Type.Object({ questions: Type.Array(Type.Object({ id: Type.String(), question: Type.String(), question_type: Type.Optional(Type.String()), status: Type.String() })) }, { additionalProperties: true }),
+        },
+        question_answer: {
+            kind: "action",
+            description: "Answer a pending question (resolve, optionally archive atom).",
+            input: Type.Object({ question_id: Type.String({ maxLength: 200 }), answer: Type.String({ maxLength: 2000 }), action: Type.Optional(Type.String({ maxLength: 40 })) }, { additionalProperties: false }),
+            output: Type.Object({}, { additionalProperties: true }),
+        },
+        atom_soft_delete: {
+            kind: "action",
+            description: "Soft-delete an atom (status='deleted', reversible).",
+            input: Type.Object({ id: Type.String({ maxLength: 200 }) }, { additionalProperties: false }),
+            output: Type.Object({}, { additionalProperties: true }),
+        },
+        atom_update_domain: {
+            kind: "action",
+            description: "Move an atom to a different domain.",
+            input: Type.Object({ id: Type.String({ maxLength: 200 }), new_domain: Type.String({ maxLength: 200 }) }, { additionalProperties: false }),
+            output: Type.Object({}, { additionalProperties: true }),
+        },
+    },
+    events: {},
+});

package/dist/ui-feature.d.ts

@@ -0,0 +1,79 @@
+export declare function createFeatureHandlers(): {
+    status: () => {
+        atoms_active: any;
+        durable_atoms: any;
+        bonds: any;
+        isolated: any;
+        pending: any;
+        missing_compact: any;
+        by_type: any;
+        recommendations: any;
+    };
+    search: ({ query, limit, type, domain }: any) => {
+        results: any[];
+    };
+    atom: ({ id }: any) => {
+        atom?: undefined;
+        bonds?: undefined;
+        error: string;
+    } | {
+        error?: undefined;
+        atom: any;
+        bonds: any[];
+    };
+    domains: () => {
+        domains: any[];
+    };
+    curator_dry: ({ max_atoms }: any) => {
+        compact: any;
+        bonds_suggested: any;
+        bonds_applied: any;
+        isolated_classified: number;
+        promotions: any;
+        merges: any;
+        status_after: any;
+    };
+    curator_apply: ({ max_atoms }: any) => {
+        compact: any;
+        bonds_suggested: any;
+        bonds_applied: any;
+        isolated_classified: number;
+        promotions: any;
+        merges: any;
+        status_after: any;
+    };
+    backups_list: () => {
+        backups: {
+            file: string;
+            size_bytes: number;
+            created: string;
+        }[];
+    };
+    backup_now: () => {
+        reason?: undefined;
+        ok: boolean;
+        path: string;
+        size_bytes: number;
+    } | {
+        path?: undefined;
+        size_bytes?: undefined;
+        ok: boolean;
+        reason: string;
+    };
+    questions_list: ({ limit }: any) => {
+        questions: any[];
+    };
+    question_answer: ({ question_id, answer, action }: any) => {
+        ok: boolean;
+        reason: string;
+    } | {
+        reason?: undefined;
+        ok: boolean;
+    };
+    atom_soft_delete: ({ id }: any) => {
+        ok: boolean;
+    };
+    atom_update_domain: ({ id, new_domain }: any) => {
+        ok: boolean;
+    };
+};

package/dist/ui-feature.js

@@ -0,0 +1,110 @@
+import { DatabaseSync } from "node:sqlite";
+import { Curator } from "./curator.js";
+import { Engine } from "./engine.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+export function createFeatureHandlers() {
+    const dbPath = process.env.MEMORY_DB_PATH ?? "/data/memory.db";
+    const db = new DatabaseSync(dbPath);
+    const engine = new Engine(db, {});
+    const curator = new Curator(db, engine, {});
+    const q = (sql, ...p) => db.prepare(sql).all(...p);
+    const q1 = (sql, ...p) => db.prepare(sql).get(...p);
+    const x = (sql, ...p) => db.prepare(sql).run(...p);
+    const curatorReport = (report) => ({
+        compact: report.actions.filter((a) => a.kind === "compact").length,
+        bonds_suggested: report.actions.find((a) => a.kind === "bond_pass")?.suggestions ?? 0,
+        bonds_applied: report.actions.find((a) => a.kind === "bond_pass")?.bonds_applied ?? 0,
+        isolated_classified: (() => { const iso = report.actions.find((a) => a.kind === "isolated_classification"); return iso ? Number(Object.values(iso.counts).reduce((n, v) => Number(n) + Number(v), 0)) : 0; })(),
+        promotions: report.actions.filter((a) => a.kind === "promotion_candidate").length,
+        merges: report.actions.filter((a) => a.kind === "merge_candidate").length,
+        status_after: report.status_after,
+    });
+    return {
+        status: () => {
+            const st = curator.status();
+            return { atoms_active: st.atoms_active, durable_atoms: st.durable_atoms, bonds: st.bonds, isolated: st.isolated_durable_atoms, pending: st.pending_questions, missing_compact: st.long_atoms_missing_compact, by_type: st.by_type, recommendations: st.recommendations };
+        },
+        search: ({ query, limit, type, domain }) => {
+            const clean = String(query).replace(/[^a-zA-Z0-9àèéìòù ]/g, " ").trim();
+            if (!clean)
+                return { results: [] };
+            const words = clean.split(/\s+/).filter((w) => w.length > 1).map((w) => '"' + w + '"');
+            if (!words.length)
+                return { results: [] };
+            let rows = [];
+            try {
+                rows = db.prepare("SELECT a.id, a.title, a.domain, a.type FROM atoms_fts JOIN atoms a ON atoms_fts.rowid = a.rowid WHERE atoms_fts MATCH ? AND a.status='active' LIMIT 200").all(words.join(" OR "));
+            }
+            catch {
+                rows = [];
+            }
+            if (type)
+                rows = rows.filter((r) => r.type === type);
+            if (domain)
+                rows = rows.filter((r) => String(r.domain || "").startsWith(domain));
+            return { results: rows.slice(0, limit ?? 30) };
+        },
+        atom: ({ id }) => {
+            const atom = q1("SELECT * FROM atoms WHERE id=?", id);
+            if (!atom)
+                return { error: "not found" };
+            const bonds = q("SELECT * FROM bonds WHERE from_id=? OR to_id=?", id, id);
+            return { atom, bonds };
+        },
+        domains: () => ({
+            domains: q("SELECT domain, COUNT(*) as count FROM atoms WHERE status='active' GROUP BY domain ORDER BY count DESC LIMIT 50"),
+        }),
+        curator_dry: ({ max_atoms }) => curatorReport(curator.run(true, false, max_atoms ?? 40)),
+        curator_apply: ({ max_atoms }) => curatorReport(curator.run(false, true, max_atoms ?? 40)),
+        backups_list: () => {
+            const backupDir = path.join(path.dirname(dbPath), "backups");
+            if (!fs.existsSync(backupDir))
+                return { backups: [] };
+            const backups = fs.readdirSync(backupDir).filter((f) => f.endsWith(".db")).map((f) => {
+                const st = fs.statSync(path.join(backupDir, f));
+                return { file: f, size_bytes: st.size, created: st.mtime.toISOString() };
+            }).sort((a, b) => b.created.localeCompare(a.created)).slice(0, 20);
+            return { backups };
+        },
+        backup_now: () => {
+            try {
+                const backupDir = path.join(path.dirname(dbPath), "backups");
+                fs.mkdirSync(backupDir, { recursive: true });
+                const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+                const dest = path.join(backupDir, "memory-backup-" + ts + ".db");
+                db.prepare("VACUUM INTO ?").run(dest);
+                return { ok: true, path: dest, size_bytes: fs.statSync(dest).size };
+            }
+            catch (e) {
+                return { ok: false, reason: String(e) };
+            }
+        },
+        questions_list: ({ limit }) => ({
+            questions: q("SELECT id, question, question_type, status, atom_ids FROM human_questions WHERE status='pending' ORDER BY created_at DESC LIMIT ?", limit ?? 20),
+        }),
+        question_answer: ({ question_id, answer, action }) => {
+            const row = q1("SELECT * FROM human_questions WHERE id=? AND status='pending'", question_id);
+            if (!row)
+                return { ok: false, reason: "question not found or not pending" };
+            x("UPDATE human_questions SET status='answered', answer=?, answered_at=unixepoch() WHERE id=?", answer, question_id);
+            if (action === "archive_atom" && row.atom_ids) {
+                try {
+                    const ids = JSON.parse(row.atom_ids);
+                    for (const aid of ids)
+                        x("UPDATE atoms SET status='archived', updated_at=unixepoch() WHERE id=?", aid);
+                }
+                catch { }
+            }
+            return { ok: true };
+        },
+        atom_soft_delete: ({ id }) => {
+            const r = x("UPDATE atoms SET status='deleted', updated_at=unixepoch() WHERE id=? AND status='active'", id);
+            return { ok: r.changes > 0 };
+        },
+        atom_update_domain: ({ id, new_domain }) => {
+            const r = x("UPDATE atoms SET domain=?, updated_at=unixepoch() WHERE id=?", new_domain, id);
+            return { ok: r.changes > 0 };
+        },
+    };
+}

package/openclaw.plugin.json

@@ -1,16 +1,19 @@
 {
   "id": "memory-engine",
   "name": "Memory Engine",
-  "description": "Native Memory Engine: 19 memory tools (recall, working set, remember, bonds, curator) + periodic session ingest/digest for OpenClaw.",
-  "version": "3.1.0",
+  "description": "Native Memory Engine: 45 memory tools, session ingest/digest, curator and Control UI.",
+  "version": "4.0.0",
   "configSchema": {
     "type": "object",
-    "properties": {},
-    "additionalProperties": false
+    "additionalProperties": false,
+    "properties": {}
   },
   "activation": {
     "onStartup": true
   },
+  "controlUi": {
+    "entry": "dist/control-ui/14e2bd207bb33b0189bdfc2712c6eee0f901d10bca0f92cb7773a4bd0f93e10b/index.js"
+  },
   "contracts": {
     "tools": [
       "memory_version",
@@ -31,7 +34,33 @@
       "memory_generate_session_digest",
       "memory_admin",
       "memory_curator_run",
-      "memory_cognitive_status"
+      "memory_cognitive_status",
+      "memory_summary",
+      "memory_delete_atom",
+      "memory_unlink",
+      "memory_error_list",
+      "memory_list_contradictions",
+      "memory_decay_run",
+      "memory_update_domain",
+      "memory_classify_memory_tier",
+      "memory_cleanup_sessions",
+      "memory_find_similar",
+      "memory_merge_atoms",
+      "memory_cleanup_duplicates",
+      "memory_semantic_search",
+      "memory_reindex_embeddings",
+      "memory_suggest_bonds",
+      "memory_suggest_bonds_all",
+      "memory_backup_database",
+      "memory_restore_database",
+      "memory_list_backups",
+      "memory_export_all",
+      "memory_export_atom",
+      "memory_import_data",
+      "memory_import_markdown",
+      "memory_learning_run",
+      "memory_ask_pending",
+      "memory_answer_human"
     ]
   }
 }

package/package.json

@@ -1,17 +1,18 @@
 {
   "name": "openclaw-plugin-memory-engine",
-  "version": "3.1.1",
+  "version": "4.0.0",
   "type": "module",
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json && openclaw plugins build",
     "plugin:build": "npm run build && openclaw plugins build --entry ./dist/index.js",
     "plugin:validate": "npm run build && openclaw plugins validate --entry ./dist/index.js",
     "test": "vitest run --config ./vitest.config.ts"
   },
   "files": [
+    "README.md",
+    "assets",
     "dist",
-    "openclaw.plugin.json",
-    "README.md"
+    "openclaw.plugin.json"
   ],
   "peerDependencies": {
     "openclaw": ">=2026.5.17"
@@ -22,7 +23,7 @@
   "devDependencies": {
     "openclaw": "latest",
     "typescript": "^7.0.2",
-    "vitest": "^3.2.0"
+    "vitest": "^3.3.0"
   },
   "openclaw": {
     "extensions": [
@@ -33,7 +34,8 @@
     },
     "build": {
       "openclawVersion": "2026.9.7"
-    }
+    },
+    "controlUi": "./src/control-ui.ts"
   },
   "description": "Native Memory Engine for OpenClaw: 19 memory tools + session ingest/digest + curator",
   "license": "MIT",