@memorycrystal/crystal-memory 0.7.4

package/index.test.js

@@ -0,0 +1,458 @@
+// index.test.js — Integration tests for the crystal-memory plugin (Phase 2)
+// Uses node:test. Run: node --test plugin/index.test.js
+"use strict";
+
+const { test, describe, before, after } = require("node:test");
+const assert = require("node:assert/strict");
+const path = require("node:path");
+const os = require("node:os");
+const fs = require("node:fs");
+const { getPeerId, getChannelKey } = require("./utils/crystal-utils");
+
+// ── Fetch mock ─────────────────────────────────────────────────────────────────
+// Intercepts all HTTP calls made by the plugin (Convex endpoints).
+// Returns { ok: true } for everything so no real network calls go out.
+const fetchResponses = new Map();
+const fetchCalls = [];
+global.fetch = async (url, _opts = {}) => {
+  fetchCalls.push({ url, opts: _opts });
+  const override = fetchResponses.get(url) || { ok: true, json: async () => ({ ok: true, memories: [], messages: [], briefing: "" }) };
+  return {
+    ok: override.ok ?? true,
+    status: override.status ?? 200,
+    statusText: override.statusText ?? "OK",
+    text: async () => JSON.stringify(override.body || {}),
+    json: override.json ?? (async () => override.body ?? { ok: true, memories: [], messages: [] }),
+  };
+};
+
+// ── Minimal api mock ───────────────────────────────────────────────────────────
+function makeApi(config = {}) {
+  const tools = new Map();
+  const hooks = new Map();
+  let contextEngine = null;
+
+  return {
+    id: "crystal-memory",
+    pluginConfig: { apiKey: "test-key-abc", convexUrl: "https://example.convex.site", ...config },
+    logger: {
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+    },
+    on(event, handler, _meta) {
+      hooks.set(event, handler);
+    },
+    registerHook(event, handler, _meta) {
+      hooks.set(event, handler);
+    },
+    registerTool(tool) {
+      tools.set(tool.name, tool);
+    },
+    registerContextEngine(engine) {
+      contextEngine = engine;
+    },
+    // Test helpers
+    _tools: tools,
+    _hooks: hooks,
+    _getEngine: () => contextEngine,
+  };
+}
+
+function makeCtx(overrides = {}) {
+  return { sessionKey: "test-session-abc", channelId: "ch-1", ...overrides };
+}
+
+function makeEvent(overrides = {}) {
+  return { content: "hello world", prompt: "hello world", sessionKey: "test-session-abc", ...overrides };
+}
+
+function makeTmpDbPath() {
+  return path.join(os.tmpdir(), `crystal-plugin-test-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+}
+
+// ── Load plugin ────────────────────────────────────────────────────────────────
+// Re-require fresh for each test suite to avoid shared state contamination.
+function loadPlugin(config) {
+  // Bust require cache so each test gets a fresh module state
+  const pluginPath = path.resolve(__dirname, "index.js");
+  delete require.cache[pluginPath];
+  const utilsPath = path.resolve(__dirname, "utils/crystal-utils.js");
+  delete require.cache[utilsPath];
+  const assemblerPath = path.resolve(__dirname, "compaction/crystal-assembler.js");
+  delete require.cache[assemblerPath];
+  const pluginFactory = require(pluginPath);
+  const api = makeApi(config);
+  pluginFactory(api);
+  return api;
+}
+
+// ── Tests ──────────────────────────────────────────────────────────────────────
+
+describe("crystal-memory plugin — Phase 2 integration", () => {
+  test("1. Plugin loads and registers context engine without crashing", () => {
+    const api = loadPlugin();
+    const engine = api._getEngine();
+    assert.ok(engine, "context engine should be registered");
+    assert.equal(engine.info.name, "crystal-memory");
+    assert.equal(engine.info.ownsCompaction, true);
+    // Core hooks should be registered
+    assert.ok(api._hooks.has("before_agent_start"), "before_agent_start hook");
+    assert.ok(api._hooks.has("message_received"), "message_received hook");
+    assert.ok(api._hooks.has("llm_output"), "llm_output hook");
+    assert.ok(api._hooks.has("message_sent"), "message_sent hook");
+    // Convex tools should be registered
+    const toolNames = [...api._tools.keys()];
+    assert.ok(toolNames.includes("memory_search"), "memory_search tool");
+    assert.ok(toolNames.includes("crystal_recall"), "crystal_recall tool");
+    assert.ok(toolNames.includes("crystal_remember"), "crystal_remember tool");
+    assert.ok(toolNames.includes("crystal_set_scope"), "crystal_set_scope tool");
+    assert.ok(toolNames.includes("crystal_checkpoint"), "crystal_checkpoint tool");
+    assert.ok(toolNames.includes("memory_get"), "memory_get tool");
+  });
+
+  test("2. ingestBatch hook: messages are queued and flushed to Convex", async () => {
+    const api = loadPlugin();
+    const engine = api._getEngine();
+    const ctx = makeCtx();
+    const payload = {
+      sessionKey: "test-session-abc",
+      messages: [
+        { role: "user", content: "What is the capital of France?" },
+        { role: "assistant", content: "Paris is the capital of France." },
+      ],
+    };
+    // Should not throw; returns flushed count
+    const result = await engine.ingestBatch(payload, ctx);
+    assert.ok(result === undefined || typeof result === "object", "ingestBatch returns undefined or object");
+  });
+
+  test("3. assemble hook: returns messages array (with or without system prepend)", async () => {
+    const api = loadPlugin();
+    const engine = api._getEngine();
+    const ctx = makeCtx();
+    const payload = {
+      sessionKey: "test-session-abc",
+      budget: 100000,
+      messages: [
+        { role: "user", content: "What is the capital of France?" },
+      ],
+    };
+    const result = await engine.assemble(payload, ctx);
+    assert.ok(result && typeof result === "object", "assemble returns object");
+    assert.ok(Array.isArray(result.messages), "result.messages is array");
+    assert.ok(result.messages.length >= 1, "at least original message preserved");
+    assert.ok(typeof result.used === "number", "result.used is number");
+    // If a system message is prepended, it must come first
+    if (result.messages.length > 1 && result.messages[0].role === "system") {
+      assert.ok(typeof result.messages[0].content === "string", "system message has string content");
+    }
+  });
+
+  test("4. compact hook: returns status string, does not throw", async () => {
+    const api = loadPlugin();
+    const engine = api._getEngine();
+    const ctx = makeCtx();
+    const payload = {
+      sessionKey: "test-session-abc",
+      reason: "context_window_full",
+      messages: [{ role: "user", content: "Lots of old messages" }],
+    };
+    const result = await engine.compact(payload, ctx);
+    // Should return a string or null — never throw
+    assert.ok(result === null || typeof result === "string", `compact returned: ${typeof result}`);
+    if (typeof result === "string") {
+      assert.ok(result.includes("Memory Crystal") || result.includes("compaction"), "result mentions compaction");
+    }
+  });
+
+  test("4b. compact hook sends sourceSnapshotId as a top-level capture field", async () => {
+    const api = loadPlugin();
+    const engine = api._getEngine();
+    const ctx = makeCtx();
+    fetchCalls.length = 0;
+
+    const snapshotUrl = "https://example.convex.site/api/mcp/snapshot";
+    const captureUrl = "https://example.convex.site/api/mcp/capture";
+
+    fetchResponses.set(snapshotUrl, {
+      ok: true,
+      json: async () => ({ id: "snapshot-123" }),
+    });
+    fetchResponses.set(captureUrl, {
+      ok: true,
+      json: async () => ({ id: "capture-456" }),
+    });
+
+    await engine.compact({
+      sessionKey: "test-session-abc",
+      reason: "context_window_full",
+      messages: [{ role: "user", content: "Lots of old messages" }],
+    }, ctx);
+
+    const captureCall = fetchCalls.find((call) => call.url === captureUrl);
+    assert.ok(captureCall, "capture request should be sent");
+    const payload = JSON.parse(captureCall.opts.body);
+    assert.equal(payload.sourceSnapshotId, "snapshot-123");
+    assert.equal("metadata" in payload, false);
+
+    fetchResponses.delete(snapshotUrl);
+    fetchResponses.delete(captureUrl);
+  });
+
+  test("5. afterTurn hook: completes without error", async () => {
+    const api = loadPlugin();
+    const engine = api._getEngine();
+    const ctx = makeCtx();
+    const payload = { sessionKey: "test-session-abc" };
+    // afterTurn returns undefined — just must not throw
+    await assert.doesNotReject(async () => {
+      await engine.afterTurn(payload, ctx);
+    });
+  });
+
+  test("6. before_agent_start hook: returns prependContext or undefined", async () => {
+    const api = loadPlugin();
+    const hook = api._hooks.get("before_agent_start");
+    assert.ok(typeof hook === "function", "before_agent_start is a function");
+    const event = makeEvent({ prompt: "test query" });
+    const ctx = makeCtx();
+    // Returns object with prependContext or undefined
+    await assert.doesNotReject(async () => {
+      const result = await hook(event, ctx);
+      if (result !== undefined) {
+        assert.ok(typeof result.prependContext === "string", "prependContext is string");
+        assert.ok(result.prependContext.length > 0, "prependContext is non-empty");
+      }
+    });
+  });
+
+  test("7. message_received hook: logs user message without throwing", async () => {
+    const api = loadPlugin();
+    const hook = api._hooks.get("message_received");
+    const event = makeEvent({ content: "What is 2+2?", prompt: "What is 2+2?" });
+    const ctx = makeCtx();
+    await assert.doesNotReject(async () => { await hook(event, ctx); });
+  });
+
+  test("8. dispose: cleans up without throwing", () => {
+    const api = loadPlugin();
+    const engine = api._getEngine();
+    assert.doesNotThrow(() => engine.dispose());
+  });
+
+  test("9. Plugin works with no apiKey (graceful degradation)", async () => {
+    const api = loadPlugin({ apiKey: undefined });
+    const engine = api._getEngine();
+    // assemble with no apiKey should return original messages unchanged
+    const payload = { sessionKey: "s1", budget: 1000, messages: [{ role: "user", content: "hi" }] };
+    const result = await engine.assemble(payload, makeCtx());
+    assert.ok(Array.isArray(result.messages));
+  });
+
+  test("11. assemble hook: messages do not contain [object Object] when localStore has messages", async () => {
+    // This tests the bug where assembleContext returns an array of message objects
+    // and they were being joined as strings, producing "[object Object]" in content.
+    const api = loadPlugin();
+    const engine = api._getEngine();
+    const ctx = makeCtx();
+    const payload = {
+      sessionKey: "test-session-abc",
+      budget: 100000,
+      messages: [
+        { role: "user", content: "Hello from test" },
+      ],
+    };
+    const result = await engine.assemble(payload, ctx);
+    assert.ok(Array.isArray(result.messages), "result.messages is array");
+    // None of the messages should have content containing "[object Object]"
+    for (const msg of result.messages) {
+      assert.ok(typeof msg === "object" && msg !== null, "each message is an object");
+      assert.ok("role" in msg, "each message has role");
+      assert.ok("content" in msg, "each message has content");
+      assert.ok(typeof msg.content === "string", "message content is a string");
+      assert.ok(!msg.content.includes("[object Object]"), `message content must not contain "[object Object]": got "${msg.content.slice(0, 80)}"`);
+    }
+  });
+
+  test("11b. assemble hook respects localSummaryInjection and localSummaryMaxTokens config", async () => {
+    const { checkSqliteAvailability, CrystalLocalStore } = await import(path.resolve(__dirname, "store/crystal-local-store.js"));
+    const avail = checkSqliteAvailability();
+    if (!avail.available) return;
+
+    const dbPath = makeTmpDbPath();
+    try {
+      const seedStore = new CrystalLocalStore();
+      seedStore.init(dbPath);
+      seedStore.insertSummary({
+        summaryId: "sum_cfg_1",
+        sessionKey: "cfg-session",
+        kind: "leaf",
+        depth: 0,
+        content: "Important deployment migration history dashboard",
+        tokenCount: 120,
+      });
+      seedStore.insertSummary({
+        summaryId: "sum_cfg_2",
+        sessionKey: "cfg-session",
+        kind: "leaf",
+        depth: 0,
+        content: "Backup detail about rollback procedures and infra cleanup",
+        tokenCount: 120,
+      });
+      seedStore.addMessage("cfg-session", "user", "deployment migration history dashboard");
+      seedStore.addMessage("cfg-session", "assistant", "Previous deployment migration context was summarized.");
+      seedStore.close();
+
+      let api = loadPlugin({ apiKey: "local", dbPath, localSummaryInjection: false });
+      let engine = api._getEngine();
+      let result = await engine.assemble({
+        sessionKey: "cfg-session",
+        messages: [{ role: "user", content: "deployment migration history dashboard" }],
+      }, makeCtx({ sessionKey: "cfg-session" }));
+      assert.equal(result.messages.some((m) => m.role === "system" && m.content.includes("Relevant context from earlier")), false);
+
+      api = loadPlugin({ apiKey: "local", dbPath, localSummaryInjection: true, localSummaryMaxTokens: 150 });
+      engine = api._getEngine();
+      result = await engine.assemble({
+        sessionKey: "cfg-session",
+        messages: [{ role: "user", content: "deployment migration history dashboard" }],
+      }, makeCtx({ sessionKey: "cfg-session" }));
+      const injected = result.messages.find((m) => m.role === "system" && m.content.includes("Relevant context from earlier"));
+      assert.ok(injected, "config-enabled injection should add a system message");
+      assert.ok(injected.content.includes("Important deployment migration history"), "first relevant summary should be injected");
+      assert.ok(!injected.content.includes("Backup detail about rollback"), "token cap should exclude the second summary");
+    } finally {
+      fs.rmSync(dbPath, { force: true });
+    }
+  });
+
+  test("9d. crystal_preflight does not classify a lesson as both a rule and a lesson", async () => {
+    const api = loadPlugin();
+    const tool = api._tools.get("crystal_preflight");
+    const url = "https://example.convex.site/api/mcp/recall";
+    fetchResponses.set(url, {
+      ok: true,
+      json: async () => ({
+        memories: [
+          { title: "Lesson from procedural memory", store: "procedural", category: "lesson" },
+          { title: "Rule memory", store: "semantic", category: "rule" },
+        ],
+      }),
+    });
+    const result = await tool.execute("id", { action: "deploy config" }, null, null, makeCtx());
+    const text = result.content[0].text;
+    assert.match(text, /"rules": \[\n\s+"Rule memory"\n\s+\]/);
+    assert.match(text, /"lessons": \[\n\s+"Lesson from procedural memory"\n\s+\]/);
+    fetchResponses.delete(url);
+  });
+
+  test("10. Tools: crystal_grep/describe/expand registered when store initializes (lazy)", async () => {
+    // These tools are registered lazily after the local store initializes.
+    // Since better-sqlite3 may not be installed in the test env, local store init
+    // may fail gracefully — so we check that no crash occurred and that Convex tools
+    // are still registered.
+    const api = loadPlugin();
+    // Simulate afterTurn which tries to register local tools
+    const engine = api._getEngine();
+    await engine.afterTurn({ sessionKey: "s1" }, makeCtx()).catch(() => {});
+    // Convex tools must always be present regardless of local store
+    assert.ok(api._tools.has("crystal_recall"), "crystal_recall always present");
+    assert.ok(api._tools.has("memory_search"), "memory_search always present");
+    // Note: crystal_grep etc. may or may not be present depending on whether
+    // better-sqlite3 loaded. Either way no crash should occur.
+  });
+
+  describe("crystal-utils channel scoping", () => {
+    test("getPeerId returns Telegram sender ID from event context", () => {
+      const ctx = {};
+      const event = { metadata: { from: { id: 12345 }, senderId: "ignored" }, context: { from: { id: 999 }, sender_id: "ctx" } };
+      assert.equal(getPeerId(ctx, event), "12345");
+    });
+
+    test("getPeerId falls back to Discord authorId", () => {
+      const ctx = {};
+      const event = { metadata: { guild: { id: 1 } }, context: { authorId: "discord-9" } };
+      assert.equal(getPeerId(ctx, event), "discord-9");
+    });
+
+    test("getPeerId falls back to session key last segment", () => {
+      const ctx = { sessionKey: "agent:openclaw:session:12345" };
+      assert.equal(getPeerId(ctx, {}), "12345");
+    });
+
+    test("getChannelKey with channelScope uses peer namespace", () => {
+      const event = { metadata: { from: { id: 12345 } } };
+      assert.equal(getChannelKey({}, event, "coach"), "coach:12345");
+    });
+
+    test("getChannelKey without channelScope preserves existing channel logic", () => {
+      const event = { context: { chat_id: "channel:coach" } };
+      assert.equal(getChannelKey({}, event), "openclaw:coach");
+    });
+  });
+
+  describe("channelScope for recall tools", () => {
+    const recallToolCases = [
+      { name: "memory_search", args: { query: "search memory" } },
+      { name: "crystal_recall", args: { query: "decision notes", limit: 4 } },
+      { name: "crystal_what_do_i_know", args: { topic: "project memory", limit: 4 } },
+      { name: "crystal_why_did_we", args: { decision: "deploy plan", limit: 4 } },
+    ];
+
+    test("4 recall tools include channel when channelScope is configured", async () => {
+      const api = loadPlugin({ channelScope: "coach" });
+      const ctx = makeCtx({ peerId: "12345" });
+      for (const { name, args } of recallToolCases) {
+        fetchCalls.length = 0;
+        const tool = api._tools.get(name);
+        await tool.execute("id", args, null, null, ctx);
+        const payload = JSON.parse(fetchCalls.at(-1).opts.body);
+        assert.equal(payload.channel, "coach:12345");
+      }
+    });
+
+    test("4 recall tools omit channel when channelScope is not configured", async () => {
+      const api = loadPlugin();
+      const ctx = makeCtx({ peerId: "12345" });
+      for (const { name, args } of recallToolCases) {
+        fetchCalls.length = 0;
+        const tool = api._tools.get(name);
+        await tool.execute("id", args, null, null, ctx);
+        const payload = JSON.parse(fetchCalls.at(-1).opts.body);
+        assert.equal("channel" in payload, false);
+      }
+    });
+
+    test("crystal_set_scope overrides channel scope for the active session and session_end clears it", async () => {
+      const api = loadPlugin({ channelScope: "default-scope" });
+      const ctx = makeCtx({ peerId: "12345", sessionKey: "session-override-1" });
+      const setScopeTool = api._tools.get("crystal_set_scope");
+      const recallTool = api._tools.get("crystal_recall");
+      const wakeTool = api._tools.get("crystal_wake");
+      const sessionEndHook = api._hooks.get("session_end");
+
+      assert.ok(setScopeTool, "crystal_set_scope should be registered");
+      assert.ok(typeof sessionEndHook === "function", "session_end hook should be registered");
+
+      await setScopeTool.execute("id", { scope: "morrow-coach" }, null, null, ctx);
+
+      fetchCalls.length = 0;
+      await recallTool.execute("id", { query: "project memory" }, null, null, ctx);
+      let payload = JSON.parse(fetchCalls.at(-1).opts.body);
+      assert.equal(payload.channel, "morrow-coach:12345");
+
+      fetchCalls.length = 0;
+      await wakeTool.execute("id", {}, null, null, ctx);
+      payload = JSON.parse(fetchCalls.at(-1).opts.body);
+      assert.equal(payload.channel, "morrow-coach:12345");
+
+      await sessionEndHook({ sessionKey: "session-override-1" }, ctx);
+
+      fetchCalls.length = 0;
+      await recallTool.execute("id", { query: "project memory" }, null, null, ctx);
+      payload = JSON.parse(fetchCalls.at(-1).opts.body);
+      assert.equal(payload.channel, "default-scope:12345");
+    });
+  });
+});

package/openclaw-hook.json

@@ -0,0 +1,84 @@
+{
+  "schemaVersion": 1,
+  "id": "crystal",
+  "name": "Memory Crystal",
+  "version": "0.1.0",
+  "description": "Drop-in OpenClaw memory plugin using Convex + MCP tools.",
+  "entry": "./handler.js",
+  "hooks": {
+    "postTurn": {
+      "enabled": false,
+      "description": "Reserved for future memory auto-write flows."
+    },
+    "startup": {
+      "enabled": true,
+      "description": "Load plugin metadata on OpenClaw startup."
+    }
+  },
+  "capabilities": {
+    "tools": [
+      "crystal_remember",
+      "crystal_recall",
+      "crystal_what_do_i_know",
+      "crystal_why_did_we",
+      "crystal_forget",
+      "crystal_stats",
+      "crystal_checkpoint",
+      "crystal_wake"
+    ],
+    "mcpCommand": "/path/to/node",
+    "mcpArgs": [
+      "/path/to/openclaw-crystal/mcp-server/dist/index.js"
+    ]
+  },
+  "commands": {
+    "crystal-capture": {
+      "command": "/path/to/node",
+      "args": [
+        "/path/to/openclaw-crystal/plugin/capture-hook.js"
+      ],
+      "env": {
+        "CONVEX_URL": "https://rightful-mockingbird-389.convex.site",
+        "OPENAI_API_KEY": "${OPENAI_API_KEY}",
+        "EMBEDDING_PROVIDER": "${EMBEDDING_PROVIDER}",
+        "GEMINI_API_KEY": "${GEMINI_API_KEY}",
+        "GEMINI_EMBEDDING_MODEL": "${GEMINI_EMBEDDING_MODEL}",
+        "OBSIDIAN_VAULT_PATH": "/path/to/obsidian-vault",
+        "CRYSTAL_MCP_HOST": "127.0.0.1",
+        "CRYSTAL_MCP_PORT": "8788",
+        "CRYSTAL_ENV_FILE": "/path/to/openclaw-crystal/mcp-server/.env",
+        "CRYSTAL_NODE": "/path/to/node",
+        "CRYSTAL_PLUGIN_DIR": "/path/to/openclaw-crystal/plugin",
+        "CRYSTAL_ROOT": "/path/to/openclaw-crystal",
+        "CRYSTAL_MCP_MODE": "stdio"
+      }
+    },
+    "crystal-recall": {
+      "command": "/path/to/node",
+      "args": [
+        "/path/to/openclaw-crystal/plugin/recall-hook.js"
+      ],
+      "env": {
+        "CONVEX_URL": "https://rightful-mockingbird-389.convex.site",
+        "OPENAI_API_KEY": "${OPENAI_API_KEY}",
+        "EMBEDDING_PROVIDER": "${EMBEDDING_PROVIDER}",
+        "GEMINI_API_KEY": "${GEMINI_API_KEY}",
+        "GEMINI_EMBEDDING_MODEL": "${GEMINI_EMBEDDING_MODEL}",
+        "OBSIDIAN_VAULT_PATH": "/path/to/obsidian-vault",
+        "CRYSTAL_MCP_HOST": "127.0.0.1",
+        "CRYSTAL_MCP_PORT": "8788",
+        "CRYSTAL_ENV_FILE": "/path/to/openclaw-crystal/mcp-server/.env",
+        "CRYSTAL_NODE": "/path/to/node",
+        "CRYSTAL_PLUGIN_DIR": "/path/to/openclaw-crystal/plugin",
+        "CRYSTAL_ROOT": "/path/to/openclaw-crystal",
+        "CRYSTAL_MCP_MODE": "stdio"
+      }
+    }
+  },
+  "env": {
+    "CRYSTAL_MCP_MODE": "sse",
+    "CRYSTAL_MCP_HOST": "127.0.0.1",
+    "CRYSTAL_MCP_PORT": "8788",
+    "CRYSTAL_ENV_FILE": "/path/to/openclaw-crystal/mcp-server/.env"
+  }
+}

package/openclaw.plugin.json

@@ -0,0 +1,61 @@
+{
+  "id": "crystal-memory",
+  "kind": [
+    "memory",
+    "context-engine"
+  ],
+  "name": "Memory Crystal",
+  "description": "Persistent memory for AI agents via Memory Crystal",
+  "version": "0.7.4",
+  "entry": "index.js",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "required": [],
+    "properties": {
+      "apiKey": {
+        "type": "string"
+      },
+      "convexUrl": {
+        "type": "string",
+        "default": "https://rightful-mockingbird-389.convex.site"
+      },
+      "defaultRecallMode": {
+        "type": "string",
+        "enum": [
+          "general",
+          "decision",
+          "project",
+          "people",
+          "workflow",
+          "conversation"
+        ],
+        "description": "Default recall mode for this agent. Controls which memory stores and categories are prioritized.",
+        "default": "general"
+      },
+      "defaultRecallLimit": {
+        "type": "number",
+        "description": "Default number of memories to recall per query.",
+        "default": 8,
+        "minimum": 1,
+        "maximum": 20
+      },
+      "channelScope": {
+        "type": "string",
+        "description": "Optional. When set, all API calls are namespaced as {channelScope}:{peerId}. Use for multi-tenant or per-agent isolation. Example: 'coach'"
+      },
+      "localSummaryInjection": {
+        "type": "boolean",
+        "description": "Enable prompt-aware local summary injection. When true, relevant summaries from the local store are injected into the context window based on the current user query.",
+        "default": true
+      },
+      "localSummaryMaxTokens": {
+        "type": "number",
+        "description": "Maximum tokens to spend on injected relevant local summaries.",
+        "default": 2000,
+        "minimum": 0,
+        "maximum": 8000
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@memorycrystal/crystal-memory",
+  "version": "0.7.4",
+  "description": "Memory Crystal OpenClaw plugin",
+  "license": "MIT",
+  "main": "index.js",
+  "homepage": "https://memorycrystal.ai",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/memorycrystal/memorycrystal"
+  },
+  "bugs": {
+    "url": "https://github.com/memorycrystal/memorycrystal/issues"
+  },
+  "keywords": [
+    "openclaw",
+    "memory",
+    "ai",
+    "plugin",
+    "crystal"
+  ],
+  "files": [
+    "*.js",
+    "*.mjs",
+    "*.cjs",
+    "*.json",
+    "!node_modules"
+  ],
+  "openclaw": {
+    "extensions": [
+      "./index.js"
+    ]
+  },
+  "optionalDependencies": {
+    "better-sqlite3": "^12.8.0"
+  }
+}