cozo-memory 1.2.6 → 1.2.10

package/dist/index.js

@@ -24,6 +24,7 @@ const emotional_salience_1 = require("./emotional-salience");
 const proactive_suggestions_1 = require("./proactive-suggestions");
 const spreading_activation_1 = require("./spreading-activation");
 const temporal_conflict_resolution_1 = require("./temporal-conflict-resolution");
+const explainable_retrieval_1 = require("./explainable-retrieval");
 exports.DB_PATH = path_1.default.resolve(__dirname, "..", "memory_db.cozo");
 const DB_ENGINE = process.env.DB_ENGINE || "sqlite"; // "sqlite" or "rocksdb"
 exports.USER_ENTITY_ID = "global_user_profile";
@@ -48,6 +49,7 @@ class MemoryServer {
     logicalEdgesService = null;
     hierarchicalMemoryService = null;
     queryAwareTraversal = null;
+    explainableService = null;
     // Metrics tracking
     metrics = {
         operations: {
@@ -245,6 +247,12 @@ class MemoryServer {
         }
         return this.queryAwareTraversal;
     }
+    getExplainableService() {
+        if (!this.explainableService) {
+            this.explainableService = new explainable_retrieval_1.ExplainableRetrievalService(this.db, this.embeddingService);
+        }
+        return this.explainableService;
+    }
     async janitorCleanup(args) {
         await this.initPromise;
         console.error(`[Janitor] Starting cleanup (auto-compressing sessions first)...`);
@@ -3158,13 +3166,13 @@ Format MUST start with "ExecutiveSummary: " followed by the consolidated content
     async exportMemory(args) {
         await this.initPromise;
         const dbService = { run: (query, params) => this.db.run(query, params) };
-        const exportService = new export_import_service_1.ExportImportService(dbService);
+        const exportService = new export_import_service_1.ExportImportService(dbService, this.embeddingService.getDimensions());
         return exportService.exportMemory(args);
     }
     async importMemory(args) {
         await this.initPromise;
         const dbService = { run: (query, params) => this.db.run(query, params) };
-        const exportService = new export_import_service_1.ExportImportService(dbService);
+        const exportService = new export_import_service_1.ExportImportService(dbService, this.embeddingService.getDimensions());
         return exportService.importMemory(args.data, {
             sourceFormat: args.sourceFormat,
             mergeStrategy: args.mergeStrategy,
@@ -3229,6 +3237,609 @@ Format MUST start with "ExecutiveSummary: " followed by the consolidated content
             };
         }
     }
+    // ===========================================================================
+    // Agent Features (query/mutation convenience actions)
+    // ===========================================================================
+    /** Feature 1: List entities with filtering, sorting and pagination. */
+    async listEntities(args) {
+        await this.initPromise;
+        try {
+            const limit = Math.min(Math.max(args.limit ?? 20, 1), 1000);
+            const offset = Math.max(args.offset ?? 0, 0);
+            const sortBy = args.sort_by ?? "created_at";
+            const sortOrder = args.sort_order ?? "desc";
+            const res = await this.db.run(`?[id, name, type, metadata, ts] := *entity{id, name, type, metadata, created_at, @ "NOW"}, ts = to_int(created_at)`);
+            let rows = res.rows.map((r) => ({
+                id: r[0],
+                name: r[1],
+                type: r[2],
+                metadata: (r[3] || {}),
+                created_at_us: r[4],
+            }));
+            // Filters (applied in JS for robustness across value types)
+            if (args.type)
+                rows = rows.filter((e) => e.type === args.type);
+            if (args.types && args.types.length > 0) {
+                const set = new Set(args.types);
+                rows = rows.filter((e) => set.has(e.type));
+            }
+            if (args.name_contains) {
+                const needle = args.name_contains.toLowerCase();
+                rows = rows.filter((e) => String(e.name).toLowerCase().includes(needle));
+            }
+            if (args.tags && args.tags.length > 0) {
+                const want = args.tags;
+                rows = rows.filter((e) => {
+                    const t = Array.isArray(e.metadata?.tags) ? e.metadata.tags : [];
+                    return want.every((tag) => t.includes(tag));
+                });
+            }
+            const total = rows.length;
+            rows.sort((a, b) => {
+                let cmp = 0;
+                if (sortBy === "name")
+                    cmp = String(a.name).localeCompare(String(b.name));
+                else
+                    cmp = a.created_at_us - b.created_at_us; // created_at / updated_at both track the validity timestamp
+                return sortOrder === "asc" ? cmp : -cmp;
+            });
+            const page = rows.slice(offset, offset + limit);
+            // Count maps (one query each, regardless of page size)
+            const obsCount = new Map();
+            const obsRes = await this.db.run('?[eid, count(oid)] := *observation{id: oid, entity_id: eid, @ "NOW"}');
+            obsRes.rows.forEach((r) => obsCount.set(r[0], Number(r[1])));
+            const relCount = new Map();
+            const relOutRes = await this.db.run('?[eid, count(t)] := *relationship{from_id: eid, to_id: t, @ "NOW"}');
+            relOutRes.rows.forEach((r) => relCount.set(r[0], Number(r[1])));
+            const relInRes = await this.db.run('?[eid, count(f)] := *relationship{from_id: f, to_id: eid, @ "NOW"}');
+            relInRes.rows.forEach((r) => relCount.set(r[0], (relCount.get(r[0]) || 0) + Number(r[1])));
+            const entities = page.map((e) => ({
+                id: e.id,
+                name: e.name,
+                type: e.type,
+                metadata: e.metadata,
+                tags: Array.isArray(e.metadata?.tags) ? e.metadata.tags : [],
+                created_at: new Date(Math.floor(e.created_at_us / 1000)).toISOString(),
+                observation_count: obsCount.get(e.id) || 0,
+                relation_count: relCount.get(e.id) || 0,
+            }));
+            return { entities, total, offset, limit };
+        }
+        catch (error) {
+            return { error: "Failed to list entities", message: error.message };
+        }
+    }
+    /** Feature 2: Aggregate statistics overview. */
+    async getStats() {
+        await this.initPromise;
+        try {
+            const [eRes, oRes, rRes] = await Promise.all([
+                this.db.run('?[id, type, ts] := *entity{id, type, created_at, @ "NOW"}, ts = to_int(created_at)'),
+                this.db.run('?[count(id)] := *observation{id, @ "NOW"}'),
+                this.db.run('?[count(f)] := *relationship{from_id: f, to_id, @ "NOW"}'),
+            ]);
+            const entities = eRes.rows.map((r) => ({ type: r[1], ts: r[2] }));
+            const total_entities = entities.length;
+            const total_observations = Number(oRes.rows[0]?.[0] || 0);
+            const total_relations = Number(rRes.rows[0]?.[0] || 0);
+            const typeMap = new Map();
+            entities.forEach((e) => typeMap.set(e.type, (typeMap.get(e.type) || 0) + 1));
+            const by_type = [...typeMap.entries()]
+                .map(([type, count]) => ({ type, count }))
+                .sort((a, b) => b.count - a.count);
+            const tss = entities.map((e) => e.ts).filter((n) => typeof n === "number");
+            const nowUs = Date.now() * 1000;
+            const dayUs = 24 * 3600 * 1000 * 1000;
+            const oldest = tss.length ? Math.min(...tss) : null;
+            const newest = tss.length ? Math.max(...tss) : null;
+            return {
+                overview: { total_entities, total_observations, total_relations },
+                by_type,
+                timeline: {
+                    oldest_entity: oldest !== null ? new Date(Math.floor(oldest / 1000)).toISOString() : null,
+                    newest_entity: newest !== null ? new Date(Math.floor(newest / 1000)).toISOString() : null,
+                    entities_last_24h: tss.filter((t) => t >= nowUs - dayUs).length,
+                    entities_last_7d: tss.filter((t) => t >= nowUs - 7 * dayUs).length,
+                },
+                activity: {
+                    total_operations: this.metrics.performance.total_operations,
+                    top_types: by_type.slice(0, 5),
+                },
+            };
+        }
+        catch (error) {
+            return { error: "Failed to compute stats", message: error.message };
+        }
+    }
+    /** Feature 6: Update an observation's text and/or metadata (validity-preserving). */
+    async updateObservation(args) {
+        await this.initPromise;
+        const startTime = Date.now();
+        try {
+            const existing = await this.db.run(`?[oid, eid, sid, tid, txt, emb, meta] := *observation{id: oid, entity_id: eid, session_id: sid, task_id: tid, text: txt, embedding: emb, metadata: meta, @ "NOW"}, oid = $id`, { id: args.observation_id });
+            if (existing.rows.length === 0)
+                return { error: "Observation not found" };
+            const row = existing.rows[0];
+            const prevText = row[4];
+            const newText = args.text !== undefined && args.text !== null ? args.text : prevText;
+            let newMeta;
+            if (args.metadata !== undefined) {
+                newMeta = args.merge_metadata ? { ...(row[6] || {}), ...args.metadata } : args.metadata;
+            }
+            else {
+                newMeta = row[6] || {};
+            }
+            let embedding = row[5];
+            if (args.text !== undefined && args.text !== prevText) {
+                embedding = await this.embeddingService.embed(newText);
+            }
+            const now = Date.now() * 1000;
+            await this.db.run(`
+        ?[id, created_at, entity_id, session_id, task_id, text, embedding, metadata] <- [[$id, $v, $entity_id, $session_id, $task_id, $text, $embedding, $metadata]]
+        :put observation {id, created_at => entity_id, session_id, task_id, text, embedding, metadata}
+      `, {
+                id: row[0],
+                v: [now, true],
+                entity_id: row[1],
+                session_id: row[2],
+                task_id: row[3],
+                text: newText,
+                embedding,
+                metadata: newMeta,
+            });
+            this.trackOperation('update_observation', startTime);
+            return {
+                status: "updated",
+                observation: {
+                    id: row[0],
+                    entity_id: row[1],
+                    text: newText,
+                    metadata: newMeta,
+                    updated_at: new Date(Math.floor(now / 1000)).toISOString(),
+                    previous_text: prevText,
+                },
+            };
+        }
+        catch (error) {
+            this.trackError('update_observation');
+            return { error: "Update failed", message: error.message };
+        }
+    }
+    /** Feature 4: Aggregate full entity detail (observations, relations, optional community/timeline). */
+    async getEntityDetail(args) {
+        await this.initPromise;
+        try {
+            const incObs = args.include_observations !== false;
+            const incRel = args.include_relations !== false;
+            const incCom = args.include_community === true;
+            const incTl = args.include_timeline === true;
+            const entRes = await this.db.run(`?[name, type, metadata, ts] := *entity{id: $id, name, type, metadata, created_at, @ "NOW"}, ts = to_int(created_at)`, { id: args.entity_id });
+            if (entRes.rows.length === 0)
+                return { error: "Entity not found" };
+            const e = entRes.rows[0];
+            const metadata = (e[2] || {});
+            const created_at_us = e[3];
+            const result = {
+                entity: {
+                    id: args.entity_id,
+                    name: e[0],
+                    type: e[1],
+                    metadata,
+                    tags: Array.isArray(metadata.tags) ? metadata.tags : [],
+                    created_at: new Date(Math.floor(created_at_us / 1000)).toISOString(),
+                },
+            };
+            if (incObs) {
+                const obsRes = await this.db.run(`?[oid, text, metadata, ts] := *observation{id: oid, entity_id: $id, text, metadata, created_at, @ "NOW"}, ts = to_int(created_at) :order ts`, { id: args.entity_id });
+                result.observations = obsRes.rows.map((r) => ({
+                    id: r[0],
+                    text: r[1],
+                    metadata: r[2],
+                    created_at: new Date(Math.floor(r[3] / 1000)).toISOString(),
+                }));
+            }
+            if (incRel) {
+                const outRes = await this.db.run(`?[tid, tname, ttype, rtype, strength, metadata] := *relationship{from_id: $id, to_id: tid, relation_type: rtype, strength, metadata, @ "NOW"}, *entity{id: tid, name: tname, type: ttype, @ "NOW"}`, { id: args.entity_id });
+                const inRes = await this.db.run(`?[sid, sname, stype, rtype, strength, metadata] := *relationship{from_id: sid, to_id: $id, relation_type: rtype, strength, metadata, @ "NOW"}, *entity{id: sid, name: sname, type: stype, @ "NOW"}`, { id: args.entity_id });
+                result.relations = {
+                    outgoing: outRes.rows.map((r) => ({
+                        target_id: r[0],
+                        target_name: r[1],
+                        target_type: r[2],
+                        relation_type: r[3],
+                        strength: r[4],
+                        metadata: r[5],
+                    })),
+                    incoming: inRes.rows.map((r) => ({
+                        source_id: r[0],
+                        source_name: r[1],
+                        source_type: r[2],
+                        relation_type: r[3],
+                        strength: r[4],
+                        metadata: r[5],
+                    })),
+                };
+            }
+            if (incCom) {
+                try {
+                    const comRes = await this.db.run(`?[cid] := *entity_community{entity_id: $id, community_id: cid}`, { id: args.entity_id });
+                    if (comRes.rows.length > 0) {
+                        const cid = comRes.rows[0][0];
+                        const memRes = await this.db.run(`?[mid, name, type] := *entity_community{entity_id: mid, community_id: $cid}, *entity{id: mid, name, type, @ "NOW"}`, { cid });
+                        result.community = {
+                            id: cid,
+                            members: memRes.rows.map((r) => ({ id: r[0], name: r[1], type: r[2] })),
+                        };
+                    }
+                    else {
+                        result.community = null;
+                    }
+                }
+                catch {
+                    result.community = null;
+                }
+            }
+            if (incTl) {
+                const timeline = [
+                    {
+                        timestamp: new Date(Math.floor(created_at_us / 1000)).toISOString(),
+                        action: "created",
+                        detail: `Entity '${e[0]}' created`,
+                    },
+                ];
+                const obsT = await this.db.run(`?[text, ts, asserted] := *observation{entity_id: $id, text, created_at}, ts = to_int(created_at), asserted = to_bool(created_at)`, { id: args.entity_id });
+                obsT.rows.forEach((r) => {
+                    if (r[2]) {
+                        timeline.push({
+                            timestamp: new Date(Math.floor(r[1] / 1000)).toISOString(),
+                            action: "observation_added",
+                            detail: String(r[0]).slice(0, 80),
+                        });
+                    }
+                });
+                const relT = await this.db.run(`?[rtype, tid, ts, asserted] := *relationship{from_id: $id, to_id: tid, relation_type: rtype, created_at}, ts = to_int(created_at), asserted = to_bool(created_at)`, { id: args.entity_id });
+                relT.rows.forEach((r) => {
+                    if (r[3]) {
+                        timeline.push({
+                            timestamp: new Date(Math.floor(r[2] / 1000)).toISOString(),
+                            action: "relation_added",
+                            detail: `${r[0]} -> ${r[1]}`,
+                        });
+                    }
+                });
+                timeline.sort((a, b) => (a.timestamp < b.timestamp ? -1 : a.timestamp > b.timestamp ? 1 : 0));
+                result.timeline = timeline;
+            }
+            return result;
+        }
+        catch (error) {
+            return { error: "Failed to get entity detail", message: error.message };
+        }
+    }
+    /** Feature 3: Delete multiple entities by explicit IDs or by filter, with dry-run support. */
+    async batchDeleteEntities(args) {
+        await this.initPromise;
+        try {
+            const dryRun = args.dry_run === true;
+            let targetIds = [];
+            if (args.entity_ids && args.entity_ids.length > 0) {
+                targetIds = [...args.entity_ids];
+            }
+            else if (args.filter) {
+                const f = args.filter;
+                const all = await this.db.run(`?[id, name, type, metadata, ts] := *entity{id, name, type, metadata, created_at, @ "NOW"}, ts = to_int(created_at)`);
+                const beforeUs = f.created_before ? Date.parse(f.created_before) * 1000 : null;
+                const afterUs = f.created_after ? Date.parse(f.created_after) * 1000 : null;
+                targetIds = all.rows
+                    .filter((r) => {
+                    const [, name, type, meta, ts] = r;
+                    if (f.type && type !== f.type)
+                        return false;
+                    if (f.name_contains && !String(name).toLowerCase().includes(f.name_contains.toLowerCase()))
+                        return false;
+                    if (beforeUs !== null && !(ts < beforeUs))
+                        return false;
+                    if (afterUs !== null && !(ts > afterUs))
+                        return false;
+                    if (f.metadata) {
+                        for (const [k, v] of Object.entries(f.metadata)) {
+                            if (JSON.stringify((meta || {})[k]) !== JSON.stringify(v))
+                                return false;
+                        }
+                    }
+                    if (f.tags && f.tags.length > 0) {
+                        const t = Array.isArray(meta?.tags) ? meta.tags : [];
+                        if (!f.tags.every((tag) => t.includes(tag)))
+                            return false;
+                    }
+                    return true;
+                })
+                    .map((r) => r[0]);
+            }
+            else {
+                return { error: "Either entity_ids or filter is required" };
+            }
+            targetIds = [...new Set(targetIds)];
+            let deleted_observations = 0;
+            let deleted_relations = 0;
+            const deleted_entities = [];
+            const errors = [];
+            for (const id of targetIds) {
+                const exists = await this.db.run('?[name] := *entity{id: $id, name, @ "NOW"}', { id });
+                if (exists.rows.length === 0) {
+                    errors.push({ id, error: "Entity not found" });
+                    continue;
+                }
+                if (dryRun) {
+                    const obsC = await this.db.run('?[count(oid)] := *observation{id: oid, entity_id: $id, @ "NOW"}', { id });
+                    const relOutC = await this.db.run('?[count(t)] := *relationship{from_id: $id, to_id: t, @ "NOW"}', { id });
+                    const relInC = await this.db.run('?[count(f)] := *relationship{from_id: f, to_id: $id, @ "NOW"}', { id });
+                    deleted_observations += Number(obsC.rows[0]?.[0] || 0);
+                    deleted_relations += Number(relOutC.rows[0]?.[0] || 0) + Number(relInC.rows[0]?.[0] || 0);
+                    deleted_entities.push(id);
+                }
+                else {
+                    const res = await this.deleteEntity({ entity_id: id });
+                    if (res.error) {
+                        errors.push({ id, error: res.message || res.error });
+                        continue;
+                    }
+                    deleted_observations += Number(res.deleted?.observations || 0);
+                    deleted_relations += Number(res.deleted?.outgoing_relations || 0) + Number(res.deleted?.incoming_relations || 0);
+                    deleted_entities.push(id);
+                }
+            }
+            return {
+                status: dryRun ? "dry_run" : "deleted",
+                deleted_count: deleted_entities.length,
+                deleted_entities,
+                deleted_observations,
+                deleted_relations,
+                ...(errors.length ? { errors } : {}),
+            };
+        }
+        catch (error) {
+            return { error: "Batch delete failed", message: error.message };
+        }
+    }
+    /** Feature 5: Lightweight tag management stored in metadata.tags. */
+    async manageTags(args) {
+        await this.initPromise;
+        try {
+            const op = args.operation;
+            if (op === "search") {
+                if (!args.search_tag)
+                    return { error: "search_tag is required for search" };
+                const all = await this.db.run(`?[id, name, type, metadata] := *entity{id, name, type, metadata, @ "NOW"}`);
+                const entities = all.rows
+                    .filter((r) => Array.isArray(r[3]?.tags) && r[3].tags.includes(args.search_tag))
+                    .map((r) => ({ id: r[0], name: r[1], type: r[2] }));
+                return { tag: args.search_tag, entities, count: entities.length };
+            }
+            if (op === "list") {
+                if (args.entity_id) {
+                    const res = await this.db.run(`?[metadata] := *entity{id: $id, metadata, @ "NOW"}`, { id: args.entity_id });
+                    if (res.rows.length === 0)
+                        return { error: "Entity not found" };
+                    const t = Array.isArray(res.rows[0][0]?.tags) ? res.rows[0][0].tags : [];
+                    return { entity_id: args.entity_id, tags: t };
+                }
+                const all = await this.db.run(`?[metadata] := *entity{metadata, @ "NOW"}`);
+                const counts = new Map();
+                all.rows.forEach((r) => {
+                    const t = Array.isArray(r[0]?.tags) ? r[0].tags : [];
+                    t.forEach((tag) => counts.set(tag, (counts.get(tag) || 0) + 1));
+                });
+                return {
+                    tags: [...counts.entries()].map(([tag, count]) => ({ tag, count })).sort((a, b) => b.count - a.count),
+                };
+            }
+            // add / remove / set
+            if (!args.entity_id)
+                return { error: "entity_id is required" };
+            const tags = args.tags || [];
+            const res = await this.db.run(`?[metadata] := *entity{id: $id, metadata, @ "NOW"}`, { id: args.entity_id });
+            if (res.rows.length === 0)
+                return { error: "Entity not found" };
+            const meta = res.rows[0][0] || {};
+            const current = Array.isArray(meta.tags) ? meta.tags : [];
+            let next;
+            if (op === "add")
+                next = [...new Set([...current, ...tags])];
+            else if (op === "remove")
+                next = current.filter((t) => !tags.includes(t));
+            else if (op === "set")
+                next = [...new Set(tags)];
+            else
+                return { error: `Invalid operation: ${op}` };
+            // Replace metadata.tags fully. updateEntity uses `++` which concatenates
+            // arrays (producing duplicates), so write metadata directly instead.
+            const newMeta = { ...meta, tags: next };
+            await this.db.run(`?[id, created_at, metadata] := *entity{id, created_at, @ "NOW"}, id = $id, metadata = $meta :update entity {id, created_at, metadata}`, { id: args.entity_id, meta: newMeta });
+            return { status: "tags_updated", entity_id: args.entity_id, operation: op, tags: next };
+        }
+        catch (error) {
+            return { error: "Tag operation failed", message: error.message };
+        }
+    }
+    /** Feature 7: Execute a sequence of mutation operations (transactional or best-effort). */
+    async executeBatch(args) {
+        await this.initPromise;
+        try {
+            const ops = args.operations || [];
+            if (ops.length === 0)
+                return { error: "No operations provided" };
+            const transactional = args.transactional !== false; // default: true (all-or-nothing)
+            const continueOnError = args.continue_on_error === true;
+            const opParams = (op) => {
+                if (op.params !== undefined)
+                    return op.params;
+                const { action, ...rest } = op;
+                return rest;
+            };
+            if (transactional) {
+                const mapped = ops.map((op) => ({ action: op.action, params: opParams(op) }));
+                const txn = await this.runTransaction({ operations: mapped });
+                if (txn.error) {
+                    return {
+                        status: "failed",
+                        results: ops.map((op, i) => ({ index: i, action: op.action, status: "error", error: txn.error })),
+                        summary: { total: ops.length, succeeded: 0, failed: ops.length },
+                        error: txn.error,
+                        message: txn.message,
+                    };
+                }
+                return {
+                    status: "completed",
+                    results: ops.map((op, i) => ({ index: i, action: op.action, status: "success" })),
+                    summary: { total: ops.length, succeeded: ops.length, failed: 0 },
+                    transaction: txn,
+                };
+            }
+            const results = [];
+            let succeeded = 0;
+            let failed = 0;
+            for (let i = 0; i < ops.length; i++) {
+                const op = ops[i];
+                const params = opParams(op);
+                try {
+                    let r;
+                    if (op.action === "create_entity")
+                        r = await this.createEntity(params);
+                    else if (op.action === "add_observation")
+                        r = await this.addObservation(params);
+                    else if (op.action === "create_relation")
+                        r = await this.createRelation(params);
+                    else if (op.action === "delete_entity")
+                        r = await this.deleteEntity({ entity_id: params.entity_id });
+                    else if (op.action === "update_observation")
+                        r = await this.updateObservation(params);
+                    else
+                        r = { error: `Unsupported batch action: ${op.action}` };
+                    if (r && r.error) {
+                        failed++;
+                        results.push({ index: i, action: op.action, status: "error", error: r.message || r.error });
+                        if (!continueOnError)
+                            break;
+                    }
+                    else {
+                        succeeded++;
+                        results.push({ index: i, action: op.action, status: "success", result: r });
+                    }
+                }
+                catch (e) {
+                    failed++;
+                    results.push({ index: i, action: op.action, status: "error", error: e.message || String(e) });
+                    if (!continueOnError)
+                        break;
+                }
+            }
+            const status = failed === 0 ? "completed" : succeeded === 0 ? "failed" : "partial";
+            return { status, results, summary: { total: ops.length, succeeded, failed } };
+        }
+        catch (error) {
+            return { error: "Batch execution failed", message: error.message };
+        }
+    }
+    /** Feature 8: Retrieve the context (observations/entities/timeline) of a session. */
+    async getSessionContext(args) {
+        await this.initPromise;
+        try {
+            const incObs = args.include_observations !== false;
+            const incEnt = args.include_entities === true;
+            const incTl = args.include_timeline === true;
+            const limit = Math.min(Math.max(args.limit ?? 50, 1), 1000);
+            let sessionId = args.session_id;
+            if (!sessionId) {
+                const latest = await this.db.run(`?[sid, la] := *session_state{session_id: sid, last_active: la} :order -la :limit 1`);
+                if (latest.rows.length === 0)
+                    return { error: "No sessions found" };
+                sessionId = latest.rows[0][0];
+            }
+            const ss = await this.db.run(`?[la, status, meta] := *session_state{session_id: $sid, last_active: la, status, metadata: meta}`, { sid: sessionId });
+            const obsRes = await this.db.run(`?[oid, eid, text, metadata, ts] := *observation{id: oid, entity_id: eid, session_id: $sid, text, metadata, created_at, @ "NOW"}, ts = to_int(created_at) :order -ts`, { sid: sessionId });
+            const obsRows = obsRes.rows;
+            const entityIds = [...new Set(obsRows.map((r) => r[1]))];
+            const nameMap = new Map();
+            if (entityIds.length) {
+                const entRes = await this.db.run(`?[id, name, type, ts] := *entity{id, name, type, created_at, @ "NOW"}, ts = to_int(created_at)`);
+                entRes.rows.forEach((r) => nameMap.set(r[0], { name: r[1], type: r[2], ts: r[3] }));
+            }
+            const tss = obsRows.map((r) => r[4]);
+            const created_at = tss.length ? new Date(Math.floor(Math.min(...tss) / 1000)).toISOString() : null;
+            const session_metadata = {
+                observation_count: obsRows.length,
+                entity_count: entityIds.length,
+                created_at,
+            };
+            if (ss.rows.length > 0) {
+                session_metadata.last_active = ss.rows[0][0];
+                session_metadata.status = ss.rows[0][1];
+                session_metadata.metadata = ss.rows[0][2];
+            }
+            const result = { session_id: sessionId, session_metadata };
+            if (incObs) {
+                result.observations = obsRows.slice(0, limit).map((r) => ({
+                    id: r[0],
+                    text: r[2],
+                    entity_id: r[1],
+                    entity_name: nameMap.get(r[1])?.name ?? null,
+                    created_at: new Date(Math.floor(r[4] / 1000)).toISOString(),
+                    metadata: r[3],
+                }));
+            }
+            if (incEnt) {
+                result.entities = entityIds.map((id) => {
+                    const info = nameMap.get(id);
+                    return {
+                        id,
+                        name: info?.name ?? null,
+                        type: info?.type ?? null,
+                        created_at: info?.ts ? new Date(Math.floor(info.ts / 1000)).toISOString() : null,
+                    };
+                });
+            }
+            if (incTl) {
+                result.timeline = obsRows
+                    .slice()
+                    .sort((a, b) => a[4] - b[4])
+                    .map((r) => ({
+                    timestamp: new Date(Math.floor(r[4] / 1000)).toISOString(),
+                    action: "observation_added",
+                    detail: String(r[2]).slice(0, 80),
+                }));
+            }
+            return result;
+        }
+        catch (error) {
+            return { error: "Failed to get session context", message: error.message };
+        }
+    }
+    /** Feature 8: List known sessions with activity metadata. */
+    async listSessions(args) {
+        await this.initPromise;
+        try {
+            const limit = Math.min(Math.max(args.limit ?? 50, 1), 1000);
+            const res = await this.db.run(`?[sid, la, status, meta] := *session_state{session_id: sid, last_active: la, status, metadata: meta} :order -la`);
+            let rows = res.rows;
+            if (args.active_only)
+                rows = rows.filter((r) => r[2] === "active");
+            const obsMap = new Map();
+            const obsRes = await this.db.run(`?[sid, count(oid)] := *observation{id: oid, session_id: sid, @ "NOW"}, sid != ""`);
+            obsRes.rows.forEach((r) => obsMap.set(r[0], Number(r[1])));
+            const sessions = rows.slice(0, limit).map((r) => ({
+                session_id: r[0],
+                last_active: r[1],
+                status: r[2],
+                metadata: r[3],
+                observation_count: obsMap.get(r[0]) || 0,
+            }));
+            return { sessions, total: rows.length };
+        }
+        catch (error) {
+            return { error: "Failed to list sessions", message: error.message };
+        }
+    }
     registerTools() {
         const MetadataSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.any());
         const MutateMemorySchema = zod_1.z.discriminatedUnion("action", [
@@ -3401,10 +4012,49 @@ Format MUST start with "ExecutiveSummary: " followed by the consolidated content
                 entity_id: zod_1.z.string().describe("Entity ID to resolve conflicts for"),
                 auto_resolve: zod_1.z.boolean().optional().default(false).describe("Automatically resolve all conflicts"),
             }),
+            zod_1.z.object({
+                action: zod_1.z.literal("update_observation"),
+                observation_id: zod_1.z.string().describe("ID of the observation to update"),
+                text: zod_1.z.string().optional().describe("New observation text (re-embedded if changed)"),
+                metadata: MetadataSchema.optional().describe("New metadata"),
+                merge_metadata: zod_1.z.boolean().optional().default(false).describe("Merge with existing metadata instead of replacing"),
+            }).passthrough(),
+            zod_1.z.object({
+                action: zod_1.z.literal("batch_delete"),
+                entity_ids: zod_1.z.array(zod_1.z.string()).optional().describe("Explicit list of entity IDs to delete"),
+                filter: zod_1.z.object({
+                    type: zod_1.z.string().optional().describe("Delete all entities of this type"),
+                    name_contains: zod_1.z.string().optional().describe("Name contains (case-insensitive)"),
+                    created_before: zod_1.z.string().optional().describe("ISO date, only entities created before"),
+                    created_after: zod_1.z.string().optional().describe("ISO date, only entities created after"),
+                    metadata: MetadataSchema.optional().describe("Metadata exact-match filter"),
+                    tags: zod_1.z.array(zod_1.z.string()).optional().describe("Only entities having all of these tags (metadata.tags)"),
+                }).optional().describe("Filter criteria (alternative to entity_ids)"),
+                dry_run: zod_1.z.boolean().optional().default(false).describe("If true, only count without deleting"),
+            }).passthrough().refine((v) => Boolean(v.entity_ids) || Boolean(v.filter), {
+                message: "entity_ids or filter is required",
+                path: ["entity_ids"],
+            }),
+            zod_1.z.object({
+                action: zod_1.z.literal("manage_tags"),
+                operation: zod_1.z.enum(["add", "remove", "set", "list", "search"]).describe("Tag operation"),
+                entity_id: zod_1.z.string().optional().describe("Required for add/remove/set; optional for list"),
+                tags: zod_1.z.array(zod_1.z.string()).optional().describe("Tag list for add/remove/set"),
+                search_tag: zod_1.z.string().optional().describe("Tag to search for (operation=search)"),
+            }).passthrough(),
+            zod_1.z.object({
+                action: zod_1.z.literal("batch"),
+                operations: zod_1.z.array(zod_1.z.object({
+                    action: zod_1.z.enum(["create_entity", "add_observation", "create_relation", "delete_entity", "update_observation"]),
+                    params: zod_1.z.any().optional().describe("Parameters for the operation (object); flat fields also accepted"),
+                }).passthrough()).describe("List of operations to execute"),
+                continue_on_error: zod_1.z.boolean().optional().default(false).describe("Keep going after a failed operation (non-transactional)"),
+                transactional: zod_1.z.boolean().optional().default(true).describe("All-or-nothing execution (default true)"),
+            }).passthrough(),
         ]);
         const MutateMemoryParameters = zod_1.z.object({
             action: zod_1.z
-                .enum(["create_entity", "update_entity", "delete_entity", "add_observation", "create_relation", "run_transaction", "add_inference_rule", "ingest_file", "start_session", "stop_session", "start_task", "stop_task", "invalidate_observation", "invalidate_relation", "enrich_observation", "record_memory_access", "prune_weak_memories", "detect_conflicts", "resolve_conflicts"])
+                .enum(["create_entity", "update_entity", "delete_entity", "add_observation", "create_relation", "run_transaction", "add_inference_rule", "ingest_file", "start_session", "stop_session", "start_task", "stop_task", "invalidate_observation", "invalidate_relation", "enrich_observation", "record_memory_access", "prune_weak_memories", "detect_conflicts", "resolve_conflicts", "update_observation", "batch_delete", "manage_tags", "batch"])
                 .describe("Action (determines which fields are required)"),
             name: zod_1.z.string().optional().describe("For create_entity (required) or add_inference_rule (required)"),
             type: zod_1.z.string().optional().describe("For create_entity (required)"),
@@ -3426,12 +4076,22 @@ Format MUST start with "ExecutiveSummary: " followed by the consolidated content
             relation_type: zod_1.z.string().optional().describe("For create_relation (required)"),
             strength: zod_1.z.number().min(0).max(1).optional().describe("Optional for create_relation"),
             metadata: MetadataSchema.optional().describe("Optional for create_entity/update_entity/add_observation/create_relation/ingest_file"),
-            observation_id: zod_1.z.string().optional().describe("For invalidate_observation (required) or enrich_observation (required) or record_memory_access (required)"),
-            dry_run: zod_1.z.boolean().optional().describe("For prune_weak_memories: if true, only shows candidates"),
+            observation_id: zod_1.z.string().optional().describe("For invalidate_observation (required) or enrich_observation (required) or record_memory_access (required) or update_observation (required)"),
+            session_id: zod_1.z.string().optional().describe("For add_observation/start_task: associate the observation/task with a session"),
+            task_id: zod_1.z.string().optional().describe("For add_observation: associate the observation with a task"),
+            dry_run: zod_1.z.boolean().optional().describe("For prune_weak_memories/batch_delete: if true, only shows candidates"),
             operations: zod_1.z.array(zod_1.z.object({
-                action: zod_1.z.enum(["create_entity", "add_observation", "create_relation", "delete_entity"]),
+                action: zod_1.z.enum(["create_entity", "add_observation", "create_relation", "delete_entity", "update_observation"]),
                 params: zod_1.z.any().describe("Parameters for the operation as an object")
-            })).optional().describe("For run_transaction: List of operations to be executed atomically"),
+            })).optional().describe("For run_transaction/batch: List of operations to be executed"),
+            merge_metadata: zod_1.z.boolean().optional().describe("For update_observation: merge instead of replace metadata"),
+            entity_ids: zod_1.z.array(zod_1.z.string()).optional().describe("For batch_delete: explicit entity IDs"),
+            filter: zod_1.z.any().optional().describe("For batch_delete: filter criteria (type, name_contains, created_before/after, metadata, tags)"),
+            operation: zod_1.z.enum(["add", "remove", "set", "list", "search"]).optional().describe("For manage_tags"),
+            tags: zod_1.z.array(zod_1.z.string()).optional().describe("For manage_tags (add/remove/set)"),
+            search_tag: zod_1.z.string().optional().describe("For manage_tags (operation=search)"),
+            continue_on_error: zod_1.z.boolean().optional().describe("For batch: continue after failures (non-transactional)"),
+            transactional: zod_1.z.boolean().optional().describe("For batch: all-or-nothing (default true)"),
         });
         this.mcp.addTool({
             name: "mutate_memory",
@@ -3599,6 +4259,14 @@ Note: Inference rules must return exactly 5 columns: [from_id, to_id, relation_t
                         });
                     }
                 }
+                if (action === "update_observation")
+                    return JSON.stringify(await this.updateObservation(rest));
+                if (action === "batch_delete")
+                    return JSON.stringify(await this.batchDeleteEntities(rest));
+                if (action === "manage_tags")
+                    return JSON.stringify(await this.manageTags(rest));
+                if (action === "batch")
+                    return JSON.stringify(await this.executeBatch(rest));
                 return JSON.stringify({ error: "Unknown action" });
             },
         });
@@ -3762,10 +4430,42 @@ Note: Inference rules must return exactly 5 columns: [from_id, to_id, relation_t
                 levels: zod_1.z.array(zod_1.z.number().min(0).max(3)).optional().describe("Memory levels to query (0-3)"),
                 limit: zod_1.z.number().optional().default(10).describe("Maximum number of results"),
             }),
+            zod_1.z.object({
+                action: zod_1.z.literal("list_entities"),
+                type: zod_1.z.string().optional().describe("Filter by a single entity type"),
+                types: zod_1.z.array(zod_1.z.string()).optional().describe("Filter by multiple entity types"),
+                limit: zod_1.z.number().min(1).max(1000).optional().default(20).describe("Page size (default 20, max 1000)"),
+                offset: zod_1.z.number().min(0).optional().default(0).describe("Pagination offset"),
+                sort_by: zod_1.z.enum(["name", "created_at", "updated_at"]).optional().default("created_at").describe("Sort field"),
+                sort_order: zod_1.z.enum(["asc", "desc"]).optional().default("desc").describe("Sort order"),
+                name_contains: zod_1.z.string().optional().describe("Case-insensitive substring filter on name"),
+                tags: zod_1.z.array(zod_1.z.string()).optional().describe("Only entities having all of these tags (metadata.tags)"),
+            }),
+            zod_1.z.object({
+                action: zod_1.z.literal("get_entity_detail"),
+                entity_id: zod_1.z.string().describe("ID of the entity"),
+                include_observations: zod_1.z.boolean().optional().default(true).describe("Include observations"),
+                include_relations: zod_1.z.boolean().optional().default(true).describe("Include outgoing/incoming relations"),
+                include_community: zod_1.z.boolean().optional().default(false).describe("Include community membership"),
+                include_timeline: zod_1.z.boolean().optional().default(false).describe("Include a chronological timeline"),
+            }),
+            zod_1.z.object({
+                action: zod_1.z.literal("get_session_context"),
+                session_id: zod_1.z.string().optional().describe("Session ID (defaults to the most recently active session)"),
+                include_observations: zod_1.z.boolean().optional().default(true).describe("Include observations"),
+                include_entities: zod_1.z.boolean().optional().default(false).describe("Include referenced entities"),
+                include_timeline: zod_1.z.boolean().optional().default(false).describe("Include a chronological timeline"),
+                limit: zod_1.z.number().min(1).max(1000).optional().default(50).describe("Max observations"),
+            }),
+            zod_1.z.object({
+                action: zod_1.z.literal("list_sessions"),
+                active_only: zod_1.z.boolean().optional().default(false).describe("Only sessions with status 'active'"),
+                limit: zod_1.z.number().min(1).max(1000).optional().default(50).describe("Max sessions"),
+            }),
         ]);
         const QueryMemoryParameters = zod_1.z.object({
             action: zod_1.z
-                .enum(["search", "advancedSearch", "context", "entity_details", "history", "graph_rag", "graph_walking", "agentic_search", "dynamic_fusion", "adaptive_retrieval", "get_zettelkasten_stats", "get_activation_stats", "get_salience_stats", "suggest_connections", "spreading_activation", "qafd_search", "hierarchical_memory_query"])
+                .enum(["search", "advancedSearch", "context", "entity_details", "history", "graph_rag", "graph_walking", "agentic_search", "dynamic_fusion", "adaptive_retrieval", "get_zettelkasten_stats", "get_activation_stats", "get_salience_stats", "suggest_connections", "spreading_activation", "qafd_search", "hierarchical_memory_query", "explain_results", "list_entities", "get_entity_detail", "get_session_context", "list_sessions"])
                 .describe("Retrieval strategy - use 'search' for simple queries, 'adaptive_retrieval' for auto-optimization, 'context' for exploration"),
             query: zod_1.z.string().optional().describe("Search query text (required for most actions)"),
             limit: zod_1.z.number().optional().describe("Maximum number of results to return (default: 10)"),
@@ -3785,6 +4485,17 @@ Note: Inference rules must return exactly 5 columns: [from_id, to_id, relation_t
             start_entity_id: zod_1.z.string().optional().describe("For graph_walking: Starting entity for traversal"),
             rerank: zod_1.z.boolean().optional().describe("For search/advancedSearch: Enable Cross-Encoder reranking for higher precision"),
             config: zod_1.z.any().optional().describe("For dynamic_fusion: Fine-tune vector/sparse/FTS/graph weights and fusion strategy"),
+            type: zod_1.z.string().optional().describe("For list_entities: filter by a single entity type"),
+            types: zod_1.z.array(zod_1.z.string()).optional().describe("For list_entities: filter by multiple entity types"),
+            offset: zod_1.z.number().optional().describe("For list_entities: pagination offset"),
+            sort_by: zod_1.z.enum(["name", "created_at", "updated_at"]).optional().describe("For list_entities: sort field"),
+            sort_order: zod_1.z.enum(["asc", "desc"]).optional().describe("For list_entities: sort order"),
+            name_contains: zod_1.z.string().optional().describe("For list_entities: case-insensitive substring filter on name"),
+            tags: zod_1.z.array(zod_1.z.string()).optional().describe("For list_entities: only entities having all of these tags"),
+            include_relations: zod_1.z.boolean().optional().describe("For get_entity_detail: include relations (default true)"),
+            include_community: zod_1.z.boolean().optional().describe("For get_entity_detail: include community (default false)"),
+            include_timeline: zod_1.z.boolean().optional().describe("For get_entity_detail/get_session_context: include timeline"),
+            active_only: zod_1.z.boolean().optional().describe("For list_sessions: only active sessions"),
         });
         this.mcp.addTool({
             name: "query_memory",
@@ -4370,6 +5081,62 @@ Note: User profile observations (entity_id='global_user_profile') are automatica
                         },
                     });
                 }
+                if (input.action === "explain_results") {
+                    try {
+                        console.log('[query_memory] Explaining', input.results.length, 'results for query:', input.query);
+                        const explained = await this.getExplainableService().explainResults(input.results, input.query, input.search_type || 'hybrid', {
+                            includePathVisualization: input.include_path_viz,
+                            includeReasoningSteps: input.include_reasoning,
+                            includeScoreBreakdown: input.include_score_breakdown
+                        });
+                        console.log('[query_memory] Explanation completed for', explained.length, 'results');
+                        return JSON.stringify({
+                            query: input.query,
+                            search_type: input.search_type,
+                            explained_results: explained
+                        });
+                    }
+                    catch (error) {
+                        console.error('[query_memory] Error explaining results:', error);
+                        return JSON.stringify({ error: "Failed to explain results", details: error.message });
+                    }
+                }
+                if (input.action === "list_entities") {
+                    return JSON.stringify(await this.listEntities({
+                        type: input.type,
+                        types: input.types,
+                        limit: input.limit,
+                        offset: input.offset,
+                        sort_by: input.sort_by,
+                        sort_order: input.sort_order,
+                        name_contains: input.name_contains,
+                        tags: input.tags,
+                    }));
+                }
+                if (input.action === "get_entity_detail") {
+                    return JSON.stringify(await this.getEntityDetail({
+                        entity_id: input.entity_id,
+                        include_observations: input.include_observations,
+                        include_relations: input.include_relations,
+                        include_community: input.include_community,
+                        include_timeline: input.include_timeline,
+                    }));
+                }
+                if (input.action === "get_session_context") {
+                    return JSON.stringify(await this.getSessionContext({
+                        session_id: input.session_id,
+                        include_observations: input.include_observations,
+                        include_entities: input.include_entities,
+                        include_timeline: input.include_timeline,
+                        limit: input.limit,
+                    }));
+                }
+                if (input.action === "list_sessions") {
+                    return JSON.stringify(await this.listSessions({
+                        active_only: input.active_only,
+                        limit: input.limit,
+                    }));
+                }
                 return JSON.stringify({ error: "Unknown action" });
             },
         });
@@ -4811,6 +5578,7 @@ For detailed action descriptions and parameters, see docs/USAGE-GUIDE.md.`,
         const ManageSystemSchema = zod_1.z.discriminatedUnion("action", [
             zod_1.z.object({ action: zod_1.z.literal("health") }),
             zod_1.z.object({ action: zod_1.z.literal("metrics") }),
+            zod_1.z.object({ action: zod_1.z.literal("stats") }),
             zod_1.z.object({
                 action: zod_1.z.literal("export_memory"),
                 format: zod_1.z.enum(["json", "markdown", "obsidian"]).describe("Export format"),
@@ -4881,10 +5649,15 @@ For detailed action descriptions and parameters, see docs/USAGE-GUIDE.md.`,
                 action: zod_1.z.literal("analyze_memory_distribution"),
                 entity_id: zod_1.z.string().describe("Entity ID to analyze memory distribution for"),
             }),
+            zod_1.z.object({ action: zod_1.z.literal("list_inference_rules") }),
+            zod_1.z.object({
+                action: zod_1.z.literal("delete_inference_rule"),
+                rule_id: zod_1.z.string().describe("ID of the inference rule to delete"),
+            }),
         ]);
         const ManageSystemParameters = zod_1.z.object({
             action: zod_1.z
-                .enum(["health", "metrics", "export_memory", "import_memory", "snapshot_create", "snapshot_list", "snapshot_diff", "cleanup", "defrag", "reflect", "clear_memory", "summarize_communities", "compact", "compress_memory_levels", "analyze_memory_distribution"])
+                .enum(["health", "metrics", "stats", "export_memory", "import_memory", "snapshot_create", "snapshot_list", "snapshot_diff", "cleanup", "defrag", "reflect", "clear_memory", "summarize_communities", "compact", "compress_memory_levels", "analyze_memory_distribution", "list_inference_rules", "delete_inference_rule"])
                 .describe("Action (determines which fields are required)"),
             format: zod_1.z.enum(["json", "markdown", "obsidian"]).optional().describe("Export format (for export_memory)"),
             includeMetadata: zod_1.z.boolean().optional().describe("Include metadata (for export_memory)"),
@@ -4910,6 +5683,7 @@ For detailed action descriptions and parameters, see docs/USAGE-GUIDE.md.`,
             min_community_size: zod_1.z.number().optional().describe("Optional for summarize_communities"),
             mode: zod_1.z.enum(["summary", "discovery"]).optional().describe("Optional for reflect"),
             level: zod_1.z.number().optional().describe("Required for compress_memory_levels (0-3: L0_RAW, L1_SESSION, L2_WEEKLY, L3_MONTHLY)"),
+            rule_id: zod_1.z.string().optional().describe("Required for delete_inference_rule"),
         });
         this.mcp.addTool({
             name: "manage_system",
@@ -4919,7 +5693,7 @@ Monitoring: health (status check), metrics (detailed stats)
 Data portability: export_memory (JSON/Markdown/Obsidian), import_memory (Mem0/MemGPT/Cozo)
 Backups: snapshot_create, snapshot_list, snapshot_diff
 Optimization: cleanup (LLM consolidation), defrag (merge duplicates), reflect (find contradictions)
-Advanced: summarize_communities, compress_memory_levels, analyze_memory_distribution, compact
+Advanced: summarize_communities, compress_memory_levels, analyze_memory_distribution, compact, list_inference_rules, delete_inference_rule
 
 Important: Use confirm=false for dry-run before cleanup/defrag. clear_memory requires confirm=true.
 
@@ -4978,6 +5752,9 @@ For detailed action descriptions and parameters, see docs/USAGE-GUIDE.md.`,
                         return JSON.stringify({ error: "Failed to retrieve metrics", message: error.message });
                     }
                 }
+                if (input.action === "stats") {
+                    return JSON.stringify(await this.getStats());
+                }
                 if (input.action === "export_memory") {
                     try {
                         const result = await this.exportMemory({
@@ -5251,6 +6028,44 @@ For detailed action descriptions and parameters, see docs/USAGE-GUIDE.md.`,
                         return JSON.stringify({ error: error.message || "Error analyzing memory distribution" });
                     }
                 }
+                if (input.action === "list_inference_rules") {
+                    try {
+                        const res = await this.db.run('?[id, name, datalog, created_at] := *inference_rule{id, name, datalog, created_at}');
+                        const rules = res.rows.map((r) => ({
+                            id: r[0],
+                            name: r[1],
+                            datalog: r[2],
+                            created_at: r[3] ? new Date(Number(r[3])).toISOString() : null,
+                        }));
+                        return JSON.stringify({ count: rules.length, rules });
+                    }
+                    catch (error) {
+                        return JSON.stringify({ error: error.message || "Error listing inference rules" });
+                    }
+                }
+                if (input.action === "delete_inference_rule") {
+                    try {
+                        if (!input.rule_id) {
+                            return JSON.stringify({ error: "rule_id is required for delete_inference_rule" });
+                        }
+                        // Check if rule exists
+                        const existing = await this.db.run('?[id, name] := *inference_rule{id, name}, id = $id', { id: input.rule_id });
+                        if (existing.rows.length === 0) {
+                            return JSON.stringify({ error: `Inference rule with ID '${input.rule_id}' not found` });
+                        }
+                        const ruleName = existing.rows[0][1];
+                        // Delete the rule
+                        await this.db.run('{ ?[id, name, datalog, created_at] := *inference_rule{id, name, datalog, created_at}, id = $id :rm inference_rule {id, name, datalog, created_at} }', { id: input.rule_id });
+                        return JSON.stringify({
+                            status: "deleted",
+                            rule_id: input.rule_id,
+                            name: ruleName,
+                        });
+                    }
+                    catch (error) {
+                        return JSON.stringify({ error: error.message || "Error deleting inference rule" });
+                    }
+                }
                 return JSON.stringify({ error: "Unknown action" });
             },
         });