@gamaze/hicortex 0.7.1 → 0.10.0

package/dist/index.js

@@ -1,238 +1,184 @@
 "use strict";
 /**
- * Hicortex OpenClaw Plugin — Long-term Memory That Learns.
+ * Hicortex OpenClaw Plugin — Long-term Memory That Learns. (0.10.0)
  *
- * Pure in-process plugin: no sidecar, no HTTP. Uses better-sqlite3 + sqlite-vec
- * for storage, @huggingface/transformers for embeddings, and multi-provider LLM
- * for distillation and consolidation.
+ * Thin-client model: the plugin requires a Hicortex server (co-located at
+ * http://127.0.0.1:8787 by default, or a remote URL via `serverUrl` config).
+ * No local database, no local LLM, no embedder, no consolidation scheduler.
+ *
+ * Install once: `openclaw plugins install @gamaze/hicortex`
+ * Run server:   `npx @gamaze/hicortex init`
+ *
+ * Responsibilities (recall-only adapter, like the Hermes plugin):
+ *   - before_agent_start  → GET /lessons (fail-soft, 3s timeout) → inject context
+ *   - Tools               → HTTP proxies to /search, /context, /ingest, /lessons
+ *
+ * CAPTURE IS NOT THIS PLUGIN'S JOB. OpenClaw persists sessions at
+ * ~/.openclaw/agents/<agentId>/sessions/*.jsonl in the Pi v3 format; the
+ * machine's Hicortex nightly reads them via oc-transcript-reader.ts —
+ * canonical nightly-from-logs, same as CC JSONL and Hermes state.db.
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-const node_path_1 = require("node:path");
-const db_js_1 = require("./db.js");
 const features_js_1 = require("./features.js");
 const extensions_js_1 = require("./extensions.js");
 const state_js_1 = require("./state.js");
-const llm_js_1 = require("./llm.js");
 const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 const node_os_1 = require("node:os");
-const embedder_js_1 = require("./embedder.js");
-const storage = __importStar(require("./storage.js"));
-const seed_lesson_js_1 = require("./seed-lesson.js");
-const retrieval = __importStar(require("./retrieval.js"));
-const distiller_js_1 = require("./distiller.js");
-const consolidate_js_1 = require("./consolidate.js");
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const DEFAULT_SERVER_URL = "http://127.0.0.1:8787";
+const LESSONS_TIMEOUT_MS = 3000;
+const HICORTEX_HOME = (0, node_path_1.join)((0, node_os_1.homedir)(), ".hicortex");
 // ---------------------------------------------------------------------------
 // Module state — initialized in registerService.start()
 // ---------------------------------------------------------------------------
-let db = null;
-let llm = null;
-let cancelConsolidation = null;
-let stateDir = "";
+let serverUrl = DEFAULT_SERVER_URL;
+let authToken;
+let hicortexHome = HICORTEX_HOME;
+// ---------------------------------------------------------------------------
+// HTTP helpers
+// ---------------------------------------------------------------------------
+function authHeaders() {
+    return authToken ? { Authorization: `Bearer ${authToken}` } : {};
+}
+async function serverGet(path, timeoutMs) {
+    try {
+        const resp = await fetch(`${serverUrl}${path}`, {
+            headers: authHeaders(),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!resp.ok)
+            return null;
+        return await resp.json();
+    }
+    catch {
+        return null;
+    }
+}
+async function serverPost(path, body, timeoutMs) {
+    try {
+        const resp = await fetch(`${serverUrl}${path}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", ...authHeaders() },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        let data = null;
+        try {
+            data = await resp.json();
+        }
+        catch { /* non-JSON body */ }
+        return { ok: resp.ok, status: resp.status, data };
+    }
+    catch (err) {
+        return { ok: false, status: 0, data: null };
+    }
+}
+// ---------------------------------------------------------------------------
+// Tool result formatter
+// ---------------------------------------------------------------------------
+function formatToolResults(results) {
+    if (results.length === 0) {
+        return { content: [{ type: "text", text: "No memories found." }] };
+    }
+    const text = results
+        .map((r) => `[${r.memory_type}] (score: ${r.score.toFixed(3)}, strength: ${r.effective_strength.toFixed(3)}) ${r.content.slice(0, 500)}`)
+        .join("\n\n");
+    return { content: [{ type: "text", text }] };
+}
 // ---------------------------------------------------------------------------
 // Plugin export
 // ---------------------------------------------------------------------------
 exports.default = {
     id: "hicortex",
-    name: "Hicortex \u2014 Long-term Memory That Learns",
+    name: "Hicortex — Long-term Memory That Learns",
     kind: "lifecycle",
     register(api) {
         // -----------------------------------------------------------------------
-        // Background service: init DB, embedder, LLM, consolidation timer
+        // Background service: resolve config, verify server, init features
         // -----------------------------------------------------------------------
         api.registerService({
             id: "hicortex-service",
             async start(ctx) {
                 const config = (ctx.config ?? {});
-                stateDir = ctx.stateDir ?? (0, node_path_1.join)(process.env.HOME ?? "~", ".hicortex");
                 const log = ctx.logger
                     ? (msg) => ctx.logger.info(msg)
                     : console.log;
-                // Resolve database path (handles migration from legacy OC location)
-                const dbPath = (0, db_js_1.resolveDbPath)(config.dbPath);
-                log(`[hicortex] Initializing database at ${dbPath}`);
-                db = (0, db_js_1.initDb)(dbPath);
-                // Auto-configure LLM: resolve → test → persist
-                const llmConfig = await autoConfigureLlm(config, log);
-                llm = new llm_js_1.LlmClient(llmConfig);
-                log(`[hicortex] LLM: ${llmConfig.provider}/${llmConfig.model} ` +
-                    `(reflect: ${llmConfig.reflectModel})`);
-                // One-time migration of legacy state files (no-op if state.json exists)
-                (0, state_js_1.migrateLegacyState)(stateDir);
-                // License: init feature cache (sync after this returns)
-                await (0, features_js_1.initFeatures)(config.licenseKey, stateDir);
-                // Schedule nightly consolidation
-                const consolidateHour = config.consolidateHour ?? 2;
-                cancelConsolidation = (0, consolidate_js_1.scheduleConsolidation)(db, llm, embedder_js_1.embed, consolidateHour);
-                // Seed the bootstrap lesson on first run
-                await (0, seed_lesson_js_1.injectSeedLesson)(db, log);
-                // Auto-add tools to tools.allow if using a restrictive profile
+                // Resolve server URL and auth token from plugin config
+                serverUrl = (config.serverUrl ?? DEFAULT_SERVER_URL).replace(/\/+$/, "");
+                authToken = config.authToken;
+                // Use stateDir from context so tests can redirect state writes
+                hicortexHome = ctx.stateDir ?? HICORTEX_HOME;
+                log(`[hicortex] Thin-client mode — server: ${serverUrl}`);
+                // License: init feature cache (only needs licenseKey, no DB access)
+                await (0, features_js_1.initFeatures)(config.licenseKey, hicortexHome);
+                // Verify server reachability at startup (non-fatal — warn only)
+                try {
+                    const resp = await fetch(`${serverUrl}/health`, {
+                        signal: AbortSignal.timeout(5000),
+                    });
+                    if (resp.ok) {
+                        const data = await resp.json();
+                        log(`[hicortex] Server OK: v${data.version}, ${data.memories} memories`);
+                    }
+                    else {
+                        log(`[hicortex] Server returned HTTP ${resp.status} — capture and tools may fail`);
+                    }
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    log(`[hicortex] WARNING: Server unreachable at ${serverUrl}: ${msg}. ` +
+                        `Run \`npx @gamaze/hicortex init\` to start the server. ` +
+                        `Capture and tool calls will fail until the server is available.`);
+                }
                 ensureToolsAllowed(log);
-                // Log stats
-                const stats = (0, db_js_1.getStats)(db, dbPath);
-                log(`[hicortex] Ready: ${stats.memories} memories, ${stats.links} links, ` +
-                    `${Math.round(stats.db_size_bytes / 1024)} KB`);
             },
             async stop() {
-                if (cancelConsolidation) {
-                    cancelConsolidation();
-                    cancelConsolidation = null;
-                }
-                if (db) {
-                    db.close();
-                    db = null;
-                }
-                llm = null;
+                // Nothing to clean up — no DB, no LLM, no timer
             },
         });
         // -----------------------------------------------------------------------
-        // Hook: before_agent_start — inject lessons into agent context
+        // Hook: before_agent_start — fetch lessons from server (fail-soft)
         // -----------------------------------------------------------------------
-        api.on("before_agent_start", async (event, ctx) => {
-            if (!db)
-                return {};
+        api.on("before_agent_start", async (_event, ctx) => {
             try {
-                const lessons = storage.getLessons(db, 7, ctx.project);
-                if (lessons.length === 0)
+                // One fetch — build context and check cap from the same response.
+                const data = await serverGet("/lessons", LESSONS_TIMEOUT_MS);
+                if (!data || !data.lessons || data.lessons.length === 0)
                     return {};
                 const maxLessons = (0, features_js_1.lessonsLimit)();
-                const selected = await (0, extensions_js_1.getLessonSelector)().select(lessons, {
+                const state = (0, state_js_1.loadState)(hicortexHome);
+                const moduleIndex = data.moduleIndex ?? state.moduleIndex;
+                const selected = await (0, extensions_js_1.getLessonSelector)().select(data.lessons, {
                     maxLessons,
                     project: ctx.project,
-                    agentId: ctx.agentId,
+                    moduleIndex,
                 });
+                if (selected.length === 0)
+                    return {};
                 const formatted = selected.map((l) => {
-                    // Extract just the lesson text from the structured content
-                    const match = l.content.match(/## Lesson: (.+)/);
-                    return match ? `- ${match[1]}` : `- ${l.content.slice(0, 200)}`;
+                    const titleMatch = l.content.match(/## Lesson: (.+)/);
+                    const typeMatch = l.content.match(/\*\*Type:\*\* (\w+)/);
+                    const severityMatch = l.content.match(/\*\*Severity:\*\* (\w+)/);
+                    const title = titleMatch ? titleMatch[1] : l.content.slice(0, 150);
+                    const meta = [severityMatch?.[1], typeMatch?.[1]].filter(Boolean).join(", ");
+                    return `- ${title}${meta ? ` (${meta})` : ""}`;
                 });
-                let context = `\n\n## Hicortex Lessons (auto-injected from long-term memory)\n` +
+                const context = `\n\n## Hicortex Lessons (auto-injected from long-term memory)\n` +
                     `These are actionable lessons learned from past sessions:\n\n` +
                     formatted.join("\n") +
                     "\n";
-                // Daily friendly reminder when at memory cap
-                const memCount = storage.countMemories(db);
-                if ((0, features_js_1.memoryCapReached)(memCount)) {
-                    context +=
-                        `\n---\nHicortex free tier: ${(0, features_js_1.maxMemoriesAllowed)()} memories stored. ` +
-                            `New memories can no longer be saved, and your agent has stopped learning and self-improving from new sessions. ` +
-                            `Existing memories, lessons, and search still work. ` +
-                            `Upgrade for unlimited usage: https://hicortex.gamaze.com/ ` +
-                            `— after purchase, tell me your key and I'll activate it for you.\n`;
-                }
                 return { appendSystemContext: context };
             }
             catch {
+                // Fail-soft — a broken lessons fetch must not block the agent
                 return {};
             }
         });
         // -----------------------------------------------------------------------
-        // Hook: agent_end — distill conversation into memories
-        // -----------------------------------------------------------------------
-        api.on("agent_end", async (event, ctx) => {
-            if (!db || !llm)
-                return;
-            if (!event.success || event.messages.length < 4)
-                return;
-            try {
-                const transcript = (0, distiller_js_1.extractConversationText)(event.messages);
-                if (transcript.length < 200)
-                    return;
-                const date = new Date().toISOString().slice(0, 10);
-                const projectName = ctx.project ?? "unknown";
-                const sourceAgent = `openclaw/${ctx.agentId ?? "unknown"}`;
-                const entries = await (0, distiller_js_1.distillSession)(llm, transcript, projectName, date);
-                if (entries.length === 0)
-                    return;
-                // Check license cap
-                if ((0, features_js_1.memoryCapReached)(storage.countMemories(db))) {
-                    console.warn(`[hicortex] Free tier limit reached (${(0, features_js_1.maxMemoriesAllowed)()} memories). ` +
-                        `Search and lessons still work, but new memories won't be saved. ` +
-                        `Upgrade for unlimited usage: https://hicortex.gamaze.com/`);
-                    return;
-                }
-                // Embed and ingest each entry
-                for (const entry of entries) {
-                    try {
-                        const embedding = await (0, embedder_js_1.embed)(entry);
-                        storage.insertMemory(db, entry, embedding, {
-                            sourceAgent,
-                            sourceSession: ctx.sessionKey,
-                            project: projectName,
-                            privacy: "WORK",
-                            memoryType: "episode",
-                        });
-                    }
-                    catch (err) {
-                        const msg = err instanceof Error ? err.message : String(err);
-                        console.error(`[hicortex] Failed to ingest entry: ${msg}`);
-                    }
-                }
-            }
-            catch {
-                // Non-fatal — session capture failing shouldn't break the agent
-            }
-        });
-        // -----------------------------------------------------------------------
-        // Hook: session_end — check if consolidation is overdue
-        // -----------------------------------------------------------------------
-        api.on("session_end", async (event, _ctx) => {
-            if (!db || !llm || event.messageCount < 4)
-                return;
-            // Opportunistic consolidation if no nightly run in 48h
-            try {
-                const { readFileSync: readFs } = await import("node:fs");
-                const { join: joinPath } = await import("node:path");
-                const { homedir: homeDir } = await import("node:os");
-                const lastPath = joinPath(homeDir(), ".hicortex", "last-consolidated.txt");
-                const lastTs = readFs(lastPath, "utf-8").trim();
-                const lastDate = new Date(lastTs);
-                const hoursSince = (Date.now() - lastDate.getTime()) / (1000 * 60 * 60);
-                if (hoursSince > 48) {
-                    console.log("[hicortex] Consolidation overdue — triggering now");
-                    (0, consolidate_js_1.runConsolidation)(db, llm, embedder_js_1.embed).catch((err) => {
-                        console.error("[hicortex] Opportunistic consolidation failed:", err);
-                    });
-                }
-            }
-            catch {
-                // No timestamp file — first run, consolidation will happen on schedule
-            }
-        });
-        // -----------------------------------------------------------------------
-        // Tools — registered as factory functions per OC plugin API
+        // Tools — HTTP proxies to server REST API
         // -----------------------------------------------------------------------
         api.registerTool((_ctx) => ({
             name: "hicortex_search",
@@ -247,14 +193,16 @@ exports.default = {
                 required: ["query"],
             },
             async execute(_callId, args, _ctx) {
-                if (!db)
-                    return { error: "Hicortex not initialized" };
                 try {
-                    const results = await retrieval.retrieve(db, embedder_js_1.embed, args.query, {
-                        limit: args.limit,
-                        project: args.project,
-                    });
-                    return formatToolResults(results);
+                    const params = new URLSearchParams({ query: args.query });
+                    if (args.limit)
+                        params.set("limit", String(args.limit));
+                    if (args.project)
+                        params.set("project", args.project);
+                    const data = await serverGet(`/search?${params}`, 10000);
+                    if (!data)
+                        return { error: "Search failed: server unreachable" };
+                    return formatToolResults(data.results ?? []);
                 }
                 catch (err) {
                     return { error: `Search failed: ${err instanceof Error ? err.message : String(err)}` };
@@ -271,15 +219,18 @@ exports.default = {
                     limit: { type: "number", description: "Max results (default 10)" },
                 },
             },
-            execute(_callId, args, _ctx) {
-                if (!db)
-                    return { error: "Hicortex not initialized" };
+            async execute(_callId, args, _ctx) {
                 try {
-                    const results = retrieval.searchContext(db, {
-                        project: args?.project,
-                        limit: args?.limit,
-                    });
-                    return formatToolResults(results);
+                    const params = new URLSearchParams();
+                    if (args?.project)
+                        params.set("project", args.project);
+                    if (args?.limit)
+                        params.set("limit", String(args.limit));
+                    const qs = params.toString();
+                    const data = await serverGet(`/context${qs ? `?${qs}` : ""}`, 10000);
+                    if (!data)
+                        return { error: "Context search failed: server unreachable" };
+                    return formatToolResults(data.results ?? []);
                 }
                 catch (err) {
                     return { error: `Context search failed: ${err instanceof Error ? err.message : String(err)}` };
@@ -303,27 +254,18 @@ exports.default = {
                 required: ["content"],
             },
             async execute(_callId, args, context) {
-                if (!db)
-                    return { error: "Hicortex not initialized" };
-                if ((0, features_js_1.memoryCapReached)(storage.countMemories(db))) {
-                    return {
-                        content: [{
-                                type: "text",
-                                text: `Free tier limit reached (${(0, features_js_1.maxMemoriesAllowed)()} memories). ` +
-                                    `Your existing memories and lessons still work — search and recall are unaffected. ` +
-                                    `New memories won't be saved until you upgrade.\n\n` +
-                                    `Upgrade for unlimited usage: https://hicortex.gamaze.com/`
-                            }],
-                    };
-                }
                 try {
-                    const embedding = await (0, embedder_js_1.embed)(args.content);
-                    const id = storage.insertMemory(db, args.content, embedding, {
-                        sourceAgent: `openclaw/${context?.agentId ?? "manual"}`,
+                    const result = await serverPost("/ingest", {
+                        content: args.content,
+                        source_agent: `openclaw/${context?.agentId ?? "manual"}`,
                         project: args.project,
-                        memoryType: args.memory_type ?? "episode",
+                        memory_type: args.memory_type ?? "episode",
                         privacy: "WORK",
-                    });
+                    }, 15000);
+                    if (!result.ok) {
+                        return { error: `Ingest failed: ${result.data?.error ?? `HTTP ${result.status}`}` };
+                    }
+                    const id = result.data?.id ?? "unknown";
                     return { content: [{ type: "text", text: `Memory stored (id: ${id.slice(0, 8)})` }] };
                 }
                 catch (err) {
@@ -337,17 +279,17 @@ exports.default = {
             parameters: {
                 type: "object",
                 properties: {
-                    days: { type: "number", description: "Look back N days (default 7)" },
-                    project: { type: "string", description: "Filter by project name" },
+                    project: { type: "string", description: "Filter by project name (optional)" },
                 },
             },
-            execute(_callId, args, _ctx) {
-                if (!db)
-                    return { error: "Hicortex not initialized" };
+            async execute(_callId, args, _ctx) {
                 try {
-                    const lessons = storage.getLessons(db, args.days ?? 7, args.project);
+                    const data = await serverGet("/lessons", LESSONS_TIMEOUT_MS);
+                    if (!data)
+                        return { error: "Lessons fetch failed: server unreachable" };
+                    const lessons = data.lessons ?? [];
                     if (lessons.length === 0) {
-                        return { content: [{ type: "text", text: "No lessons found for the specified period." }] };
+                        return { content: [{ type: "text", text: "No lessons found." }] };
                     }
                     const text = lessons.map((l) => `- ${l.content.slice(0, 500)}`).join("\n");
                     return { content: [{ type: "text", text }] };
@@ -357,6 +299,67 @@ exports.default = {
                 }
             },
         }), { name: "hicortex_lessons" });
+        api.registerTool((_ctx) => ({
+            name: "hicortex_index",
+            description: "Get the knowledge domain index — shows what topics and projects are stored in memory, grouped by domain.",
+            parameters: {
+                type: "object",
+                properties: {},
+            },
+            async execute(_callId, _args, _ctx) {
+                try {
+                    const data = await serverGet("/index", 10000);
+                    if (!data)
+                        return { error: "Index fetch failed: server unreachable" };
+                    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+                }
+                catch (err) {
+                    return { error: `Index fetch failed: ${err instanceof Error ? err.message : String(err)}` };
+                }
+            },
+        }), { name: "hicortex_index" });
+        api.registerTool((_ctx) => ({
+            name: "hicortex_graph",
+            description: "Query the memory knowledge graph — find connected memories, hub nodes, or paths between memories.",
+            parameters: {
+                type: "object",
+                properties: {
+                    operation: {
+                        type: "string",
+                        enum: ["neighbors", "hubs", "path"],
+                        description: "Graph operation to perform",
+                    },
+                    id: { type: "string", description: "Memory ID (required for neighbors and path operations)" },
+                    target_id: { type: "string", description: "Target memory ID (required for path operation)" },
+                    limit: { type: "number", description: "Max results (default 10)" },
+                    domain: { type: "string", description: "Filter hubs by domain" },
+                    relationship: { type: "string", description: "Filter neighbors by relationship type (e.g., CONTRADICTS, SUPERSEDES, derives)" },
+                },
+                required: ["operation"],
+            },
+            async execute(_callId, args, _ctx) {
+                try {
+                    const params = new URLSearchParams({ op: args.operation });
+                    if (args.id)
+                        params.set("id", args.id);
+                    if (args.target_id)
+                        params.set("target_id", args.target_id);
+                    if (args.limit)
+                        params.set("limit", String(args.limit));
+                    if (args.domain)
+                        params.set("domain", args.domain);
+                    if (args.relationship)
+                        params.set("relationship", args.relationship);
+                    const data = await serverGet(`/graph?${params}`, 10000);
+                    if (!data)
+                        return { error: "Graph query failed: server unreachable" };
+                    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+                }
+                catch (err) {
+                    return { error: `Graph query failed: ${err instanceof Error ? err.message : String(err)}` };
+                }
+            },
+        }), { name: "hicortex_graph" });
         api.registerTool((_ctx) => ({
             name: "hicortex_update",
             description: "Update an existing memory. Use after searching to fix incorrect information. If content changes, the embedding is re-computed.",
@@ -366,33 +369,30 @@ exports.default = {
                     id: { type: "string", description: "Memory ID (from search results, first 8 chars or full UUID)" },
                     content: { type: "string", description: "New content text" },
                     project: { type: "string", description: "New project name" },
-                    memory_type: { type: "string", enum: ["episode", "lesson", "fact", "decision"], description: "New memory type" },
+                    memory_type: {
+                        type: "string",
+                        enum: ["episode", "lesson", "fact", "decision"],
+                        description: "New memory type",
+                    },
                 },
                 required: ["id"],
             },
             async execute(_callId, args, _ctx) {
-                if (!db)
-                    return { error: "Hicortex not initialized" };
                 try {
-                    const fullId = resolveMemoryId(db, args.id);
-                    if (!fullId)
+                    const result = await serverPost("/update", {
+                        id: args.id,
+                        content: args.content,
+                        project: args.project,
+                        memory_type: args.memory_type,
+                    }, 15000);
+                    if (result.status === 404) {
                         return { error: `Memory not found: ${args.id}` };
-                    const fields = {};
-                    if (args.content !== undefined)
-                        fields.content = args.content;
-                    if (args.project !== undefined)
-                        fields.project = args.project;
-                    if (args.memory_type !== undefined)
-                        fields.memory_type = args.memory_type;
-                    if (Object.keys(fields).length === 0)
-                        return { error: "No fields to update" };
-                    storage.updateMemory(db, fullId, fields);
-                    if (args.content !== undefined) {
-                        const embedding = await (0, embedder_js_1.embed)(args.content);
-                        db.prepare("DELETE FROM memory_vectors WHERE id = ?").run(fullId);
-                        db.prepare("INSERT INTO memory_vectors (id, embedding) VALUES (?, ?)").run(fullId, Buffer.from(embedding.buffer));
                     }
-                    return { content: [{ type: "text", text: `Memory updated (id: ${fullId.slice(0, 8)})` }] };
+                    if (!result.ok) {
+                        return { error: `Update failed: ${result.data?.error ?? `HTTP ${result.status}`}` };
+                    }
+                    const id = result.data?.id ?? args.id;
+                    return { content: [{ type: "text", text: `Memory updated (id: ${String(id).slice(0, 8)})` }] };
                 }
                 catch (err) {
                     return { error: `Update failed: ${err instanceof Error ? err.message : String(err)}` };
@@ -409,15 +409,16 @@ exports.default = {
                 },
                 required: ["id"],
             },
-            execute(_callId, args, _ctx) {
-                if (!db)
-                    return { error: "Hicortex not initialized" };
+            async execute(_callId, args, _ctx) {
                 try {
-                    const fullId = resolveMemoryId(db, args.id);
-                    if (!fullId)
+                    const result = await serverPost("/delete", { id: args.id }, 15000);
+                    if (result.status === 404) {
                         return { error: `Memory not found: ${args.id}` };
-                    storage.deleteMemory(db, fullId);
-                    return { content: [{ type: "text", text: `Memory deleted (id: ${fullId.slice(0, 8)})` }] };
+                    }
+                    if (!result.ok) {
+                        return { error: `Delete failed: ${result.data?.error ?? `HTTP ${result.status}`}` };
+                    }
+                    return { content: [{ type: "text", text: `Memory deleted (id: ${String(args.id).slice(0, 8)})` }] };
                 }
                 catch (err) {
                     return { error: `Delete failed: ${err instanceof Error ? err.message : String(err)}` };
@@ -429,95 +430,13 @@ exports.default = {
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
-function resolveMemoryId(database, idPrefix) {
-    if (idPrefix.length >= 36) {
-        const row = database.prepare("SELECT id FROM memories WHERE id = ?").get(idPrefix);
-        return row?.id ?? null;
-    }
-    const rows = database.prepare("SELECT id FROM memories WHERE id LIKE ?").all(`${idPrefix}%`);
-    if (rows.length === 1)
-        return rows[0].id;
-    return null;
-}
-// ---------------------------------------------------------------------------
-// Auto-configure LLM: resolve config → test connection → persist if new
-// ---------------------------------------------------------------------------
-async function autoConfigureLlm(pluginConfig, log) {
-    // Step 1: Resolve LLM config from all sources
-    const llmConfig = (0, llm_js_1.resolveLlmConfig)({
-        llmBaseUrl: pluginConfig.llmBaseUrl,
-        llmApiKey: pluginConfig.llmApiKey,
-        llmModel: pluginConfig.llmModel,
-        reflectModel: pluginConfig.reflectModel,
-    });
-    // Step 2: Test the connection
-    log(`[hicortex] Testing LLM connection: ${llmConfig.provider}/${llmConfig.model} @ ${llmConfig.baseUrl}`);
-    const testClient = new llm_js_1.LlmClient(llmConfig);
-    try {
-        const response = await testClient.completeFast("Respond with just the word OK", 10);
-        if (response && response.length > 0) {
-            log(`[hicortex] LLM connection verified`);
-            // Step 3: Persist to OC config so future startups skip detection
-            persistProviderConfig(llmConfig, log);
-            return llmConfig;
-        }
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        log(`[hicortex] LLM test failed (${llmConfig.baseUrl}): ${msg}`);
-    }
-    // Step 4: Fall back — return the config anyway, log instructions
-    log(`[hicortex] WARNING: Could not verify LLM connection. ` +
-        `Distillation and consolidation may fail. ` +
-        `To fix: add models.providers.${llmConfig.provider}.baseUrl to ~/.openclaw/openclaw.json ` +
-        `or set llmBaseUrl in the hicortex plugin config.`);
-    return llmConfig;
-}
-/**
- * Persist verified provider config to openclaw.json so future startups
- * skip detection and go straight to the verified URL.
- */
-function persistProviderConfig(llmConfig, log) {
-    try {
-        const configPath = (0, node_path_1.join)((0, node_os_1.homedir)(), ".openclaw", "openclaw.json");
-        const raw = (0, node_fs_1.readFileSync)(configPath, "utf-8");
-        const config = JSON.parse(raw);
-        // Check if baseUrl already stored for this provider
-        const existing = config?.models?.providers?.[llmConfig.provider]?.baseUrl;
-        if (existing === llmConfig.baseUrl)
-            return; // Already persisted
-        // Write the provider config
-        if (!config.models)
-            config.models = {};
-        if (!config.models.providers)
-            config.models.providers = {};
-        if (!config.models.providers[llmConfig.provider]) {
-            config.models.providers[llmConfig.provider] = {};
-        }
-        const prov = config.models.providers[llmConfig.provider];
-        prov.baseUrl = llmConfig.baseUrl;
-        // OC requires a models array — preserve existing or add the active model
-        if (!prov.models || !Array.isArray(prov.models)) {
-            prov.models = [{
-                    id: llmConfig.model,
-                    name: llmConfig.model,
-                    input: ["text"],
-                    contextWindow: 128000,
-                    maxTokens: 8192,
-                }];
-        }
-        (0, node_fs_1.writeFileSync)(configPath, JSON.stringify(config, null, 2));
-        log(`[hicortex] Persisted LLM config: ${llmConfig.provider} → ${llmConfig.baseUrl}`);
-    }
-    catch {
-        // Non-fatal — config works in memory even if we can't persist
-    }
-}
 const HICORTEX_TOOLS = [
     "hicortex_search",
     "hicortex_context",
     "hicortex_ingest",
     "hicortex_lessons",
+    "hicortex_index",
+    "hicortex_graph",
     "hicortex_update",
     "hicortex_delete",
 ];
@@ -542,17 +461,6 @@ function ensureToolsAllowed(log) {
         log(`[hicortex] Added tools to allow list: ${missing.join(", ")}`);
     }
     catch {
-        // Non-fatal
+        // Non-fatal — openclaw.json may not exist in test environments
     }
 }
-function formatToolResults(results) {
-    if (results.length === 0) {
-        return {
-            content: [{ type: "text", text: "No memories found." }],
-        };
-    }
-    const text = results
-        .map((r) => `[${r.memory_type}] (score: ${r.score.toFixed(3)}, strength: ${r.effective_strength.toFixed(3)}) ${r.content.slice(0, 500)}`)
-        .join("\n\n");
-    return { content: [{ type: "text", text }] };
-}