@wazionapps/openclaw-memory-nexo-brain 1.0.0

package/README.md

@@ -0,0 +1,92 @@
+# @wazionapps/openclaw-memory-nexo-brain
+
+Native OpenClaw memory plugin powered by [NEXO Brain](https://github.com/wazionapps/nexo) — a cognitive memory system modeled after human cognition.
+
+## What It Does
+
+Replaces OpenClaw's default memory with a full cognitive architecture:
+
+- **Atkinson-Shiffrin Memory Model** — Sensory register → Short-term → Long-term, with natural decay
+- **Semantic RAG** — Finds memories by meaning, not keywords (fastembed, 384-dim vectors)
+- **Trust Scoring** — Calibrates verification rigor based on alignment history
+- **Guard System** — Checks past errors before every code change
+- **Cognitive Dissonance** — Detects conflicts between new instructions and established knowledge
+- **Session Continuity** — Resumes from where the last session left off via session diaries
+
+## Install
+
+```bash
+# 1. Install NEXO Brain cognitive engine
+npx nexo-brain
+
+# 2. Install the OpenClaw plugin
+npm install @wazionapps/openclaw-memory-nexo-brain
+```
+
+## Configure
+
+In `~/.openclaw/openclaw.json`:
+
+```json
+{
+  "plugins": {
+    "slots": {
+      "memory": "memory-nexo-brain"
+    },
+    "memory-nexo-brain": {
+      "nexoHome": "~/.nexo",
+      "autoRecall": true,
+      "autoCapture": true,
+      "guardEnabled": true,
+      "trustScoring": true
+    }
+  }
+}
+```
+
+## Tools Provided
+
+| Tool | Description |
+|------|------------|
+| `memory_recall` | Semantic search across all memories |
+| `memory_store` | Store error patterns and lessons learned |
+| `memory_guard` | Check past errors before editing code |
+| `memory_trust` | Update trust score based on user feedback |
+| `memory_dissonance` | Detect conflicts with established knowledge |
+| `memory_sentiment` | Analyze user's emotional state |
+| `memory_diary_write` | Write session summary for continuity |
+| `memory_diary_read` | Read recent diaries to resume context |
+| `memory_startup` | Register a new session |
+| `memory_heartbeat` | Update session task, check inbox |
+
+## CLI Commands
+
+```bash
+openclaw nexo-status    # Show cognitive memory statistics
+openclaw nexo-recall "deployment issues"  # Semantic search
+```
+
+## Architecture
+
+```
+OpenClaw Agent
+    ↓ (tool calls)
+TypeScript Adapter (this plugin)
+    ↓ (JSON-RPC over stdio)
+Python MCP Server (NEXO Brain)
+    ↓
+SQLite (nexo.db + cognitive.db)
+    ↓
+fastembed vectors (BAAI/bge-small-en-v1.5, CPU)
+```
+
+## Requirements
+
+- macOS (Linux planned)
+- Python 3 with fastembed
+- OpenClaw >= 2026.3.22
+- Run `npx nexo-brain` first to install the cognitive engine
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * NEXO Brain — Native OpenClaw Memory Plugin
+ *
+ * Replaces OpenClaw's default memory system with NEXO's full cognitive architecture:
+ * Atkinson-Shiffrin memory model, semantic RAG, trust scoring, guard system,
+ * cognitive dissonance detection, and session continuity.
+ *
+ * Architecture: TypeScript adapter → MCP Bridge (stdio) → Python NEXO server
+ */
+declare const _default: import("openclaw/plugin-sdk/plugin-entry").PluginEntryOptions;
+export default _default;

package/dist/index.js

@@ -0,0 +1,178 @@
+/**
+ * NEXO Brain — Native OpenClaw Memory Plugin
+ *
+ * Replaces OpenClaw's default memory system with NEXO's full cognitive architecture:
+ * Atkinson-Shiffrin memory model, semantic RAG, trust scoring, guard system,
+ * cognitive dissonance detection, and session continuity.
+ *
+ * Architecture: TypeScript adapter → MCP Bridge (stdio) → Python NEXO server
+ */
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { McpBridge } from "./mcp-bridge.js";
+import { COGNITIVE_TOOLS } from "./tools.js";
+let bridge = null;
+let sessionId = null;
+export default definePluginEntry({
+    id: "memory-nexo-brain",
+    name: "NEXO Brain",
+    description: "Cognitive memory system — Atkinson-Shiffrin model, semantic RAG, trust scoring, and metacognitive guard.",
+    kind: "memory",
+    register(api) {
+        const config = api.pluginConfig;
+        const nexoHome = api.resolvePath(config.nexoHome || "~/.nexo");
+        const pythonPath = config.pythonPath || "python3";
+        const autoRecall = config.autoRecall !== false;
+        const autoCapture = config.autoCapture !== false;
+        const guardEnabled = config.guardEnabled !== false;
+        bridge = new McpBridge({ nexoHome, pythonPath });
+        // Register the system prompt section that tells the agent about NEXO
+        api.registerMemoryPromptSection(({ availableTools }) => {
+            const sections = [
+                "## Cognitive Memory (NEXO Brain)",
+                "",
+                "You have access to a persistent cognitive memory system. Key behaviors:",
+                "",
+                "- **Before editing code**: Call `memory_guard` to check for past errors in the files you're about to modify.",
+                "- **After resolving errors**: Call `memory_store` to prevent recurrence.",
+                "- **When user feedback is positive/negative**: Call `memory_trust` to calibrate your verification rigor.",
+                "- **When instructions conflict with past behavior**: Call `memory_dissonance` to surface the conflict.",
+                "- **At session end**: Call `memory_diary_write` to enable continuity for the next session.",
+                "",
+                "Memory decays naturally over time (Ebbinghaus curves). Frequently accessed memories get stronger.",
+                "Semantic search finds memories by meaning, not just keywords.",
+            ];
+            if (guardEnabled) {
+                sections.push("", "**GUARD SYSTEM ACTIVE**: Always check `memory_guard` before code changes. It will surface known pitfalls.");
+            }
+            return sections;
+        });
+        // Register all cognitive tools
+        for (const tool of COGNITIVE_TOOLS) {
+            api.registerTool({
+                name: tool.name,
+                label: tool.label,
+                description: tool.description,
+                parameters: tool.parameters,
+                async execute(_toolCallId, params) {
+                    try {
+                        const result = await bridge.callTool(tool.nexoName, params);
+                        return {
+                            content: [{ type: "text", text: result }],
+                            details: { nexoTool: tool.nexoName },
+                        };
+                    }
+                    catch (err) {
+                        const message = err instanceof Error ? err.message : String(err);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Error calling ${tool.nexoName}: ${message}`,
+                                },
+                            ],
+                            details: { error: true },
+                        };
+                    }
+                },
+            }, { name: tool.name });
+        }
+        // Lifecycle: auto-recall at session start
+        if (autoRecall) {
+            api.on("before_agent_start", async (event) => {
+                try {
+                    await bridge.start();
+                    // Register session
+                    const startupResult = await bridge.callTool("nexo_startup", {
+                        task: "OpenClaw session",
+                    });
+                    const sidMatch = startupResult.match(/SID:\s*(\S+)/);
+                    if (sidMatch) {
+                        sessionId = sidMatch[1];
+                    }
+                    // Read recent session diary for context
+                    const diary = await bridge.callTool("nexo_session_diary_read", {
+                        last_day: true,
+                    });
+                    // Retrieve cognitive context
+                    const cognitive = await bridge.callTool("nexo_cognitive_retrieve", {
+                        query: "session context recent work",
+                        top_k: 5,
+                    });
+                    const context = [
+                        "<nexo-memory-context>",
+                        diary ? `## Recent Session Context\n${diary}` : "",
+                        cognitive
+                            ? `## Relevant Cognitive Memories\n${cognitive}`
+                            : "",
+                        "</nexo-memory-context>",
+                    ]
+                        .filter(Boolean)
+                        .join("\n");
+                    return { prependContext: context };
+                }
+                catch (err) {
+                    api.logger.warn(`NEXO auto-recall failed: ${err instanceof Error ? err.message : err}`);
+                    return {};
+                }
+            });
+        }
+        // Lifecycle: auto-capture at session end
+        if (autoCapture) {
+            api.on("agent_end", async (event) => {
+                try {
+                    if (bridge && sessionId) {
+                        await bridge.callTool("nexo_session_diary_write", {
+                            summary: "Auto-captured session via OpenClaw memory-nexo-brain plugin.",
+                            domain: "openclaw",
+                        });
+                    }
+                }
+                catch {
+                    // Best-effort — don't block session end
+                }
+            });
+        }
+        // CLI commands
+        api.registerCli(({ program }) => {
+            program
+                .command("nexo-status")
+                .description("Show NEXO Brain cognitive memory status")
+                .action(async () => {
+                try {
+                    await bridge.start();
+                    const stats = await bridge.callTool("nexo_cognitive_stats", {});
+                    console.log(stats);
+                }
+                catch (err) {
+                    console.error(`Failed to get NEXO status: ${err instanceof Error ? err.message : err}`);
+                }
+            });
+            program
+                .command("nexo-recall")
+                .description("Search cognitive memory by meaning")
+                .argument("<query>", "Semantic search query")
+                .action(async (query) => {
+                try {
+                    await bridge.start();
+                    const result = await bridge.callTool("nexo_cognitive_retrieve", { query, top_k: 10 });
+                    console.log(result);
+                }
+                catch (err) {
+                    console.error(`Failed to recall: ${err instanceof Error ? err.message : err}`);
+                }
+            });
+        }, { commands: ["nexo-status", "nexo-recall"] });
+        // Service lifecycle
+        api.registerService({
+            id: "memory-nexo-brain",
+            start: async () => {
+                await bridge.start();
+                api.logger.info("NEXO Brain cognitive engine started");
+            },
+            stop: async () => {
+                await bridge.stop();
+                api.logger.info("NEXO Brain cognitive engine stopped");
+            },
+        });
+    },
+});

package/dist/mcp-bridge.d.ts

@@ -0,0 +1,29 @@
+/**
+ * MCP Bridge — Communicates with the NEXO Brain MCP server via stdio JSON-RPC.
+ *
+ * Spawns the Python MCP server as a child process and sends/receives
+ * JSON-RPC 2.0 messages over stdin/stdout.
+ */
+export interface NexoConfig {
+    nexoHome: string;
+    pythonPath: string;
+}
+export declare class McpBridge {
+    private process;
+    private requestId;
+    private pending;
+    private buffer;
+    private initialized;
+    private config;
+    constructor(config: NexoConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    callTool(name: string, args?: Record<string, unknown>): Promise<string>;
+    listTools(): Promise<Array<{
+        name: string;
+        description: string;
+        inputSchema: unknown;
+    }>>;
+    private send;
+    private processBuffer;
+}

package/dist/mcp-bridge.js

@@ -0,0 +1,147 @@
+/**
+ * MCP Bridge — Communicates with the NEXO Brain MCP server via stdio JSON-RPC.
+ *
+ * Spawns the Python MCP server as a child process and sends/receives
+ * JSON-RPC 2.0 messages over stdin/stdout.
+ */
+import { spawn } from "node:child_process";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+export class McpBridge {
+    process = null;
+    requestId = 0;
+    pending = new Map();
+    buffer = "";
+    initialized = false;
+    config;
+    constructor(config) {
+        this.config = {
+            nexoHome: config.nexoHome.replace("~", homedir()),
+            pythonPath: config.pythonPath,
+        };
+    }
+    async start() {
+        if (this.process)
+            return;
+        const serverPath = resolve(this.config.nexoHome, "src", "server.py");
+        const nodeProcess = globalThis.process;
+        this.process = spawn(this.config.pythonPath, [serverPath], {
+            env: {
+                ...nodeProcess.env,
+                NEXO_HOME: this.config.nexoHome,
+            },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.process.stdout.on("data", (chunk) => {
+            this.buffer += chunk.toString();
+            this.processBuffer();
+        });
+        this.process.stderr.on("data", (chunk) => {
+            // MCP servers may log to stderr — ignore gracefully
+        });
+        this.process.on("exit", (code) => {
+            this.process = null;
+            this.initialized = false;
+            for (const [, p] of this.pending) {
+                p.reject(new Error(`NEXO MCP server exited with code ${code}`));
+            }
+            this.pending.clear();
+        });
+        // Initialize MCP protocol
+        await this.send("initialize", {
+            protocolVersion: "2024-11-05",
+            capabilities: {},
+            clientInfo: { name: "openclaw-memory-nexo-brain", version: "1.0.0" },
+        });
+        await this.send("notifications/initialized", {});
+        this.initialized = true;
+    }
+    async stop() {
+        if (this.process) {
+            this.process.kill("SIGTERM");
+            this.process = null;
+            this.initialized = false;
+        }
+    }
+    async callTool(name, args = {}) {
+        if (!this.initialized) {
+            await this.start();
+        }
+        const result = await this.send("tools/call", { name, arguments: args });
+        if (result?.content) {
+            return result.content
+                .filter((c) => c.type === "text" && c.text)
+                .map((c) => c.text)
+                .join("\n");
+        }
+        return JSON.stringify(result);
+    }
+    async listTools() {
+        if (!this.initialized) {
+            await this.start();
+        }
+        const result = await this.send("tools/list", {});
+        return result?.tools ?? [];
+    }
+    send(method, params) {
+        return new Promise((resolvePromise, reject) => {
+            if (!this.process?.stdin) {
+                reject(new Error("MCP server not running"));
+                return;
+            }
+            const id = ++this.requestId;
+            const request = {
+                jsonrpc: "2.0",
+                id,
+                method,
+                params,
+            };
+            this.pending.set(id, { resolve: resolvePromise, reject });
+            const message = JSON.stringify(request);
+            const header = `Content-Length: ${Buffer.byteLength(message)}\r\n\r\n`;
+            this.process.stdin.write(header + message);
+            // Timeout after 30s
+            setTimeout(() => {
+                if (this.pending.has(id)) {
+                    this.pending.delete(id);
+                    reject(new Error(`Timeout calling ${method}`));
+                }
+            }, 30000);
+        });
+    }
+    processBuffer() {
+        while (true) {
+            const headerEnd = this.buffer.indexOf("\r\n\r\n");
+            if (headerEnd === -1)
+                break;
+            const header = this.buffer.slice(0, headerEnd);
+            const match = header.match(/Content-Length:\s*(\d+)/i);
+            if (!match) {
+                this.buffer = this.buffer.slice(headerEnd + 4);
+                continue;
+            }
+            const contentLength = parseInt(match[1], 10);
+            const contentStart = headerEnd + 4;
+            if (this.buffer.length < contentStart + contentLength)
+                break;
+            const content = this.buffer.slice(contentStart, contentStart + contentLength);
+            this.buffer = this.buffer.slice(contentStart + contentLength);
+            try {
+                const response = JSON.parse(content);
+                if (response.id != null && this.pending.has(response.id)) {
+                    const p = this.pending.get(response.id);
+                    this.pending.delete(response.id);
+                    if (response.error) {
+                        p.reject(new Error(response.error.message));
+                    }
+                    else {
+                        p.resolve(response.result);
+                    }
+                }
+            }
+            catch {
+                // Malformed JSON — skip
+            }
+        }
+    }
+}

package/dist/tools.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Tool definitions for the NEXO Brain OpenClaw memory plugin.
+ *
+ * Exposes cognitive memory tools as native OpenClaw tools via TypeBox schemas.
+ */
+import { type TObject } from "@sinclair/typebox";
+interface ToolDef {
+    name: string;
+    nexoName: string;
+    label: string;
+    description: string;
+    parameters: TObject;
+}
+export declare const COGNITIVE_TOOLS: ToolDef[];
+export declare const ALL_TOOL_NAMES: string[];
+export {};

package/dist/tools.js

@@ -0,0 +1,125 @@
+/**
+ * Tool definitions for the NEXO Brain OpenClaw memory plugin.
+ *
+ * Exposes cognitive memory tools as native OpenClaw tools via TypeBox schemas.
+ */
+import { Type } from "@sinclair/typebox";
+export const COGNITIVE_TOOLS = [
+    {
+        name: "memory_recall",
+        nexoName: "nexo_cognitive_retrieve",
+        label: "Recall Memory",
+        description: "Semantic search across all memories (STM + LTM). Finds memories by meaning, not keywords. Use this to check context before acting.",
+        parameters: Type.Object({
+            query: Type.String({ description: "What to search for (semantic)" }),
+            top_k: Type.Optional(Type.Integer({ default: 10, description: "Max results" })),
+            min_score: Type.Optional(Type.Number({ default: 0.5, description: "Minimum relevance (0-1)" })),
+            domain: Type.Optional(Type.String({ description: "Filter by domain (e.g. project name)" })),
+        }),
+    },
+    {
+        name: "memory_store",
+        nexoName: "nexo_learning_add",
+        label: "Store Learning",
+        description: "Store an error pattern or lesson learned. Prevents the same mistake from recurring. The guard system checks these before every code change.",
+        parameters: Type.Object({
+            category: Type.String({
+                description: "Area (e.g. wazion, infrastructure, shopify)",
+            }),
+            error: Type.String({ description: "What went wrong" }),
+            solution: Type.String({ description: "How it was fixed" }),
+            reasoning: Type.Optional(Type.String({ description: "Why this solution works" })),
+        }),
+    },
+    {
+        name: "memory_guard",
+        nexoName: "nexo_guard_check",
+        label: "Guard Check",
+        description: "Check past errors and learnings before editing code. Returns relevant warnings, known issues, and DB schemas for the files/area you're about to modify.",
+        parameters: Type.Object({
+            files: Type.Optional(Type.String({ description: "Comma-separated file paths to check" })),
+            area: Type.Optional(Type.String({ description: "System area (e.g. wazion, shopify)" })),
+        }),
+    },
+    {
+        name: "memory_trust",
+        nexoName: "nexo_cognitive_trust",
+        label: "Update Trust Score",
+        description: "Adjust alignment score based on user feedback. Higher trust = fewer redundant checks. Events: explicit_thanks (+3), delegation (+2), correction (-3), repeated_error (-7).",
+        parameters: Type.Object({
+            event: Type.String({
+                description: "Event type: explicit_thanks, delegation, correction, repeated_error, sibling_detected, proactive_action, override, forgot_followup",
+            }),
+            context: Type.Optional(Type.String({ description: "Brief context for the event" })),
+        }),
+    },
+    {
+        name: "memory_dissonance",
+        nexoName: "nexo_cognitive_dissonance",
+        label: "Check Cognitive Dissonance",
+        description: "Detect conflicts between a new instruction and established memories. Use when the user gives an instruction that seems to contradict past behavior.",
+        parameters: Type.Object({
+            instruction: Type.String({
+                description: "The new instruction to check against existing memories",
+            }),
+        }),
+    },
+    {
+        name: "memory_sentiment",
+        nexoName: "nexo_cognitive_sentiment",
+        label: "Analyze Sentiment",
+        description: "Analyze the user's current tone and emotional state from recent messages. Adapts agent behavior: frustrated → ultra-concise, flow → suggest backlog items.",
+        parameters: Type.Object({
+            text: Type.String({ description: "Recent user messages to analyze" }),
+        }),
+    },
+    {
+        name: "memory_diary_write",
+        nexoName: "nexo_session_diary_write",
+        label: "Write Session Diary",
+        description: "Write a session summary for continuity. The next session reads this to resume context. Include: what was done, decisions made, pending items, mental state.",
+        parameters: Type.Object({
+            summary: Type.String({ description: "What happened this session" }),
+            decisions: Type.Optional(Type.String({ description: "Key decisions and reasoning" })),
+            pending: Type.Optional(Type.String({ description: "What's left to do" })),
+            mental_state: Type.Optional(Type.String({
+                description: "Internal state in first person — thread of thought, observations, momentum",
+            })),
+            domain: Type.Optional(Type.String({ description: "Project/domain for multi-session context" })),
+        }),
+    },
+    {
+        name: "memory_diary_read",
+        nexoName: "nexo_session_diary_read",
+        label: "Read Session Diary",
+        description: "Read recent session diaries for context continuity. Use at session start to resume where the last session left off.",
+        parameters: Type.Object({
+            last_n: Type.Optional(Type.Integer({ default: 3, description: "Number of diaries to read" })),
+            last_day: Type.Optional(Type.Boolean({
+                default: false,
+                description: "Read all diaries from last active day",
+            })),
+            domain: Type.Optional(Type.String({ description: "Filter by domain" })),
+        }),
+    },
+    {
+        name: "memory_startup",
+        nexoName: "nexo_startup",
+        label: "Session Startup",
+        description: "Register a new session. Call once at the start of every conversation. Returns session ID and active sessions.",
+        parameters: Type.Object({
+            task: Type.Optional(Type.String({ default: "Startup", description: "Initial task" })),
+        }),
+    },
+    {
+        name: "memory_heartbeat",
+        nexoName: "nexo_heartbeat",
+        label: "Session Heartbeat",
+        description: "Update session task and check for messages from other sessions. Call at the start of every user interaction.",
+        parameters: Type.Object({
+            sid: Type.String({ description: "Session ID from startup" }),
+            task: Type.String({ description: "Current task (5-10 words)" }),
+        }),
+    },
+];
+export const ALL_TOOL_NAMES = COGNITIVE_TOOLS.map((t) => t.name);

package/openclaw.plugin.json

@@ -0,0 +1,70 @@
+{
+  "id": "memory-nexo-brain",
+  "kind": "memory",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "nexoHome": {
+        "type": "string",
+        "default": "~/.nexo",
+        "description": "Path to NEXO data directory"
+      },
+      "pythonPath": {
+        "type": "string",
+        "default": "python3",
+        "description": "Path to Python 3 interpreter"
+      },
+      "autoRecall": {
+        "type": "boolean",
+        "default": true,
+        "description": "Automatically retrieve relevant memories at session start"
+      },
+      "autoCapture": {
+        "type": "boolean",
+        "default": true,
+        "description": "Automatically capture session diary at session end"
+      },
+      "trustScoring": {
+        "type": "boolean",
+        "default": true,
+        "description": "Enable trust score tracking (calibrates verification rigor)"
+      },
+      "guardEnabled": {
+        "type": "boolean",
+        "default": true,
+        "description": "Enable metacognitive guard (checks past errors before code changes)"
+      }
+    }
+  },
+  "uiHints": {
+    "nexoHome": {
+      "label": "NEXO Home Directory",
+      "sensitive": false,
+      "placeholder": "~/.nexo",
+      "help": "Where NEXO stores its SQLite databases and plugins"
+    },
+    "pythonPath": {
+      "label": "Python Path",
+      "sensitive": false,
+      "placeholder": "python3",
+      "help": "Python 3 interpreter used to run the cognitive engine"
+    },
+    "autoRecall": {
+      "label": "Auto-Recall",
+      "help": "Retrieve relevant memories automatically when a session starts"
+    },
+    "autoCapture": {
+      "label": "Auto-Capture",
+      "help": "Write session diary automatically when a session ends"
+    },
+    "trustScoring": {
+      "label": "Trust Scoring",
+      "help": "Track alignment via trust score — higher score = fewer redundant checks"
+    },
+    "guardEnabled": {
+      "label": "Guard System",
+      "help": "Check past errors and learnings before every code change"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@wazionapps/openclaw-memory-nexo-brain",
+  "version": "1.0.0",
+  "description": "OpenClaw native memory plugin powered by NEXO Brain — Atkinson-Shiffrin cognitive memory, semantic RAG, trust scoring, and metacognitive guard.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@sinclair/typebox": "^0.34.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "typescript": "^5.7.0"
+  },
+  "peerDependencies": {
+    "openclaw": ">=2026.3.22"
+  },
+  "openclaw": {
+    "extensions": [
+      "./dist/index.js"
+    ],
+    "install": {
+      "npmSpec": "@wazionapps/openclaw-memory-nexo-brain",
+      "defaultChoice": "npm",
+      "minHostVersion": ">=2026.3.22"
+    },
+    "release": {
+      "publishToNpm": true
+    }
+  },
+  "keywords": [
+    "openclaw",
+    "openclaw-plugin",
+    "memory",
+    "cognitive",
+    "nexo",
+    "mcp",
+    "ai-memory",
+    "vector-search"
+  ],
+  "author": "WAzion <hello@wazion.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wazionapps/nexo.git",
+    "directory": "openclaw-plugin"
+  },
+  "homepage": "https://github.com/wazionapps/nexo#openclaw-integration"
+}