@psiclawops/hypermem 0.9.2 → 0.9.3

package/INSTALL.md

@@ -51,7 +51,7 @@ No gateway, plugin load path, or OpenClaw config is required in library mode. Op
 
 This guide is deliberately declarative. Follow the steps in order and verify each install state before moving on.
 
-> **Release note:** if the npm package you installed does not contain `hypermem-install`, `install:runtime`, and `hypermem-model-audit`, you are on an older public release. Use the source-clone path in this guide or wait for the next npm release.
+> **Release note:** current releases ship `hypermem-install`, `install:runtime`, and `hypermem-model-audit`. If your installed package does not contain them, upgrade to the latest `@psiclawops/hypermem` before following this guide.
 
 ```bash
 npm install @psiclawops/hypermem
@@ -529,7 +529,7 @@ npm install
 npm run build
 ```
 
-Build both plugins, then install the runtime payload into 's durable plugin directory:
+Build both plugins, then install the runtime payload into OpenClaw's durable plugin directory:
 
 ```bash
 npm --prefix plugin install && npm --prefix plugin run build

package/README.md

@@ -20,13 +20,13 @@ Or via the shell installer:
 curl -fsSL https://raw.githubusercontent.com/PsiClawOps/hypermem/main/install.sh | bash
 ```
 
-Or install manually via `npm install @psiclawops/hypermem` - see [Installation](#installation) for the full declarative plugin path, verification checkpoints, and setup variants.
+Or install manually via `npm install @psiclawops/hypermem`: see [Installation](#installation) for the full declarative plugin path, verification checkpoints, and setup variants.
 
 Release operators should also read:
 
-- [INSTALL.md](./INSTALL.md) - canonical fresh install and upgrade guide
-- [docs/INTEGRATION_VALIDATION.md](./docs/INTEGRATION_VALIDATION.md) - end-to-end integration validation contract
-- [docs/DIAGNOSTICS.md](./docs/DIAGNOSTICS.md) - status, model audit, compose, trim, and release diagnostics
+- [INSTALL.md](./INSTALL.md): canonical fresh install and upgrade guide
+- [docs/INTEGRATION_VALIDATION.md](./docs/INTEGRATION_VALIDATION.md): end-to-end integration validation contract
+- [docs/DIAGNOSTICS.md](./docs/DIAGNOSTICS.md): status, model audit, compose, trim, and release diagnostics
 
 A successful `hypermem-install` only stages the runtime. HyperMem is active only after OpenClaw config is wired, the gateway restarts, and logs show compose activity.
 
@@ -57,7 +57,7 @@ The difference is not intelligence. It is prompt access. Three failure modes fol
 
 ## What OpenClaw provides today
 
-OpenClaw already gives agents a stronger baseline than most stacks. It injects structured guidance into every session:
+OpenClaw already gives agents a strong baseline. It injects structured guidance into every session:
 
 | File | What it contributes | Survives session restart? |
 |---|---|---|
@@ -78,16 +78,16 @@ OpenClaw gives agents a strong starting shape: identity files, user guidance, ta
 
 hypermem closes that gap with four SQLite-backed memory layers that stay local, run in-process, and remain queryable across sessions. No external database service. No retrieval stack to babysit.
 
-| Layer | What it holds | Speed |
+| Layer | What it holds | Representative local read |
 |---|---|---|
-| **L1 SQLite `:memory:`** | What the agent needs right now. Identity, recent history, active state. | 0.08ms |
-| **L2 History** | Every conversation, queryable and concurrent-safe. Per-agent. | 0.13ms |
-| **L3 Semantic** | Finds related content even when the words don't match. | 0.29ms |
-| **L4 Knowledge** | Facts, wiki pages, episodes, preferences. Shared across agents. | 0.09ms |
+| **L1 SQLite `:memory:`** | What the agent needs right now. Identity, recent history, active state. | L1 slot GET: 0.08ms avg |
+| **L2 History** | Every conversation, queryable and concurrent-safe. Per-agent. | L2 history window: 0.13ms avg |
+| **L3 Semantic** | Finds related content even when the words don't match. | async/cached; provider-dependent. See [Speed](#speed) and [Diagnostics](./docs/DIAGNOSTICS.md#memory-access-benchmark). |
+| **L4 Knowledge** | Facts, wiki pages, episodes, preferences. Shared across agents. | L4 knowledge query: 0.09ms avg |
 
 Durable context stays in SQLite and remains queryable across session boundaries. The retry logic decision from last week, the deployment preferences from last month, and the architecture choices from day one can be pulled back in when they matter.
 
-That changes OpenClaw in a few concrete ways. Starts are warm instead of blank because recent history, ranked facts, active topics, and cached semantic state are loaded before the first turn. Recall survives wording drift because FTS5, sqlite-vec, RRF fusion, and an optional reranker can recover the same idea through different phrasing. Time-aware facts can answer “last week” and “before the release” as retrieval problems instead of vague prompt guessing. Shared knowledge stops living in one agent’s scratchpad because `library.db` holds facts, docs, episodes, preferences, fleet state, and output standards with visibility controls.
+That changes OpenClaw in a few concrete ways. Starts are warm instead of blank because recent history, ranked facts, active topics, and cached semantic state are loaded before the first turn. Recall survives wording drift because FTS5, sqlite-vec, RRF fusion, and an optional reranker can recover the same idea through different phrasing. Time-aware facts can answer "last week" and "before the release" as retrieval problems instead of vague prompt guessing. Shared knowledge stops living in one agent’s scratchpad because `library.db` holds facts, docs, episodes, preferences, fleet state, and output standards with visibility controls.
 
 ---
 
@@ -189,11 +189,11 @@ Behavior standards define how your agents write. Anti-sycophancy rules prevent f
 
 ### Model adaptation
 
-Different models have different default behaviors. GPT-5.4 tends toward 2x verbosity and long lists. Claude Opus defaults to hedging and preambles. Gemini produces bulleted summaries where prose would be more direct. Model adaptation corrects for these tendencies per model.
+Different providers and model families have different default answer shapes. Model adaptation applies operator-defined output standards per model so those defaults do not leak into every response.
 
 Adaptation entries are stored in the `model_output_directives` table and matched by model ID using exact match, then glob pattern (longest wins), then wildcard fallback. Each entry contains:
 
-- **Calibration:** known model tendencies and specific adjustments (e.g., "2x verbosity: cut first drafts in half")
+- **Calibration:** known model tendencies and specific adjustments (e.g., "prefer concise first drafts")
 - **Corrections:** hard/medium/soft severity rules applied in order (e.g., "No preamble before the answer")
 - **Task overrides:** per-task-type adjustments
 
@@ -208,7 +208,7 @@ The example below shows the intended effect of `hyperformProfile: "light"`. hype
 ```
 Prompt: "How should I size my context window budget for a long-running agent session?"
 
-WITHOUT hyperform shaping (GPT-5.4 default):
+WITHOUT hyperform shaping (generic verbose default):
 Here are the key factors to consider when sizing your context window budget:
 
 **1. Session depth**
@@ -276,7 +276,7 @@ Reference run, production database: 5,104 facts, 28,441 episodes, 847 knowledge
 | Operation | avg | p50 | p95 |
 |---|---|---|---|
 | L1 slot GET (SQLite in-memory) | 0.08ms | 0.07ms | 0.13ms |
-| L1 history window (100 messages) | 0.13ms | 0.11ms | 0.19ms |
+| L2 history window (100 messages) | 0.13ms | 0.11ms | 0.19ms |
 | L4 facts (top-28, confidence × decay) | 0.28ms | 0.26ms | 0.36ms |
 | L4 facts + agentId filter | 0.31ms | 0.29ms | 0.40ms |
 | L4 FTS5 keyword search | 0.06ms | 0.05ms | 0.08ms |
@@ -357,13 +357,13 @@ Facts are ranked by `confidence × recencyDecay`, where decay is exponential wit
        │
   topic detection ──► scope retrieval to active thread
        │
-  ┌────┴───────────────────────────────────────────────┐
-  │              query 4 layers (parallel)             │
-  │                                                    │
-  │  L1 in-memory  L2 History   L3 Vectors  L4 Library │
-  │  hot state    durable       semantic    facts/wiki │
-  │  0.1ms        0.16ms        0.29ms      0.08ms     │
-  └────┬───────────────────────────────────────────────┘
+  ┌────┴────────────────────────────────────────────────────────────────┐
+  │                 query 4 layers (parallel)                          │
+  │                                                                    │
+  │  L1 in-memory  L2 History        L3 Vectors        L4 Library      │
+  │  hot state     durable history   semantic recall   facts/wiki      │
+  │  0.08ms avg    0.13ms avg        async/cached      0.09ms avg      │
+  └────┬────────────────────────────────────────────────────────────────┘
        │
   budget allocator ──► 10 slots, fixed token cap
        │
@@ -386,7 +386,7 @@ Slot-level budget allocation is shown in the [hypercompositor diagram](#what-the
 
 ## Requirements
 
-**Current release: hypermem 0.9.0.** Changelog: [CHANGELOG.md](./CHANGELOG.md)
+**Current release: hypermem 0.9.2.** Changelog: [CHANGELOG.md](./CHANGELOG.md)
 
 | Requirement | Version | Notes |
 |---|---|---|
@@ -398,7 +398,7 @@ SQLite is a library, not a service. All four layers run in-process with no exter
 **Runtime version constants** (importable from the package):
 ```typescript
 import {
-  ENGINE_VERSION,        // '0.9.0'
+  ENGINE_VERSION,        // '0.9.2'
   MIN_NODE_VERSION,      // '22.0.0'
   SQLITE_VEC_VERSION,    // '0.1.9'
   MAIN_SCHEMA_VERSION,   // 10 (messages.db)

package/memory-plugin/dist/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * HyperMem Memory Plugin
+ *
+ * Thin adapter that bridges HyperMem's retrieval capabilities into
+ * OpenClaw's memory slot contract (`kind: "memory"`).
+ *
+ * The context engine plugin (hypercompositor) owns the full lifecycle:
+ * ingest, assemble, compact, afterTurn, bootstrap, dispose.
+ *
+ * This plugin owns the memory slot contract:
+ * - registerMemoryCapability() with runtime + publicArtifacts
+ * - memory_search tool backing via MemorySearchManager
+ * - Public artifacts for memory-wiki bridge
+ *
+ * Both plugins share the same HyperMem singleton (loaded from repo dist).
+ */
+declare const _default: {
+    id: string;
+    name: string;
+    description: string;
+    configSchema: import("openclaw/plugin-sdk").OpenClawPluginConfigSchema;
+    register: NonNullable<import("openclaw/plugin-sdk/plugin-entry").OpenClawPluginDefinition["register"]>;
+} & Pick<import("openclaw/plugin-sdk/plugin-entry").OpenClawPluginDefinition, "kind" | "reload" | "nodeHostCommands" | "securityAuditCollectors">;
+export default _default;

package/memory-plugin/dist/index.js

@@ -0,0 +1,378 @@
+/**
+ * HyperMem Memory Plugin
+ *
+ * Thin adapter that bridges HyperMem's retrieval capabilities into
+ * OpenClaw's memory slot contract (`kind: "memory"`).
+ *
+ * The context engine plugin (hypercompositor) owns the full lifecycle:
+ * ingest, assemble, compact, afterTurn, bootstrap, dispose.
+ *
+ * This plugin owns the memory slot contract:
+ * - registerMemoryCapability() with runtime + publicArtifacts
+ * - memory_search tool backing via MemorySearchManager
+ * - Public artifacts for memory-wiki bridge
+ *
+ * Both plugins share the same HyperMem singleton (loaded from repo dist).
+ */
+import { definePluginEntry, emptyPluginConfigSchema } from 'openclaw/plugin-sdk/plugin-entry';
+import { matchTriggers, TRIGGER_REGISTRY } from '@psiclawops/hypermem';
+import path from 'path';
+import fs from 'fs/promises';
+import os from 'os';
+import { fileURLToPath } from 'url';
+// ─── HyperMem singleton ────────────────────────────────────────
+// HyperMem.create() in the core package now dedupes per absolute dataDir, so
+// whichever of the two plugins (context-engine, memory) calls create() first
+// owns the instance. To avoid a race where this plugin would otherwise win
+// boot with no embedding config and force defaults onto the shared instance,
+// we load the same user config file the context-engine plugin loads and pass
+// the full embedding/reranker config through to create().
+const __pluginDir = path.dirname(fileURLToPath(import.meta.url));
+async function resolveHyperMemPath() {
+    try {
+        const resolvedUrl = await import.meta.resolve('@psiclawops/hypermem');
+        return resolvedUrl.startsWith('file:') ? fileURLToPath(resolvedUrl) : resolvedUrl;
+    }
+    catch {
+        return path.resolve(__pluginDir, '../../dist/index.js');
+    }
+}
+async function loadFileConfig(dataDir) {
+    const configPath = path.join(dataDir, 'config.json');
+    try {
+        const raw = await fs.readFile(configPath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        if (err.code !== 'ENOENT') {
+            console.warn(`[hypermem-memory] Failed to parse config.json (using defaults):`, err.message);
+        }
+        return {};
+    }
+}
+let _hm = null;
+let _hmInitPromise = null;
+async function getHyperMem() {
+    if (_hm)
+        return _hm;
+    if (_hmInitPromise)
+        return _hmInitPromise;
+    _hmInitPromise = (async () => {
+        const hypermemPath = await resolveHyperMemPath();
+        const mod = await import(hypermemPath);
+        const HyperMem = mod.HyperMem;
+        const dataDir = path.join(os.homedir(), '.openclaw/hypermem');
+        const fileConfig = await loadFileConfig(dataDir);
+        const createConfig = {
+            dataDir,
+            cache: {
+                keyPrefix: 'hm:',
+                sessionTTL: 14400,
+                historyTTL: 86400,
+            },
+        };
+        // Forward embedding + reranker so this plugin's create() call produces
+        // an equivalent instance to the context-engine plugin's. Other config
+        // sections (compositor, indexer, dreaming, etc.) are owned by the
+        // context-engine plugin and only matter when it wins the singleton race.
+        if (fileConfig.embedding)
+            createConfig.embedding = fileConfig.embedding;
+        if (fileConfig.reranker)
+            createConfig.reranker = fileConfig.reranker;
+        const instance = await HyperMem.create(createConfig);
+        _hm = instance;
+        return instance;
+    })();
+    return _hmInitPromise;
+}
+const DOCTRINE_COLLECTIONS = new Set([
+    'governance/policy',
+    'governance/charter',
+    'governance/comms',
+    'operations/agents',
+]);
+function doctrineScore(chunk, rank) {
+    const collectionBoost = chunk.collection.startsWith('governance/') ? 1.25 : 1.1;
+    return collectionBoost - Math.min(rank, 9) * 0.03;
+}
+function docChunkToMemoryResult(chunk, rank) {
+    return {
+        path: chunk.sourcePath,
+        startLine: 0,
+        endLine: 0,
+        score: doctrineScore(chunk, rank),
+        snippet: chunk.content.slice(0, 500),
+        source: 'memory',
+        citation: `[doc:${chunk.collection}:${chunk.sectionPath}]`,
+    };
+}
+/**
+ * Create a MemorySearchManager backed by HyperMem's retrieval pipeline.
+ *
+ * Uses HyperMem's:
+ * - library.db fact search (FTS5 + BM25)
+ * - vector store semantic search (when available)
+ * - message search (full-text across conversations)
+ */
+function createMemorySearchManager(hm, agentId, workspaceDir) {
+    return {
+        async search(query, opts) {
+            const maxResults = opts?.maxResults ?? 10;
+            const minScore = opts?.minScore ?? 0;
+            const results = [];
+            const seenDocChunks = new Set();
+            // 0. Canonical doctrine search. Explicit governance queries should surface
+            // policy, charter, comms, and AGENTS chunks before stale daily-memory folklore.
+            try {
+                const triggers = matchTriggers(query, TRIGGER_REGISTRY)
+                    .filter(trigger => DOCTRINE_COLLECTIONS.has(trigger.collection))
+                    .slice(0, 4);
+                for (const trigger of triggers) {
+                    const chunks = hm.queryDocChunks({
+                        collection: trigger.collection,
+                        agentId,
+                        keyword: query,
+                        limit: Math.max(3, Math.ceil(maxResults / Math.max(1, triggers.length))),
+                    });
+                    chunks.forEach((chunk, rank) => {
+                        const key = `${chunk.sourcePath}:${chunk.sectionPath}:${chunk.sourceHash}`;
+                        if (seenDocChunks.has(key))
+                            return;
+                        seenDocChunks.add(key);
+                        const result = docChunkToMemoryResult(chunk, rank);
+                        if (result.score >= minScore)
+                            results.push(result);
+                    });
+                }
+            }
+            catch {
+                // Doctrine search is a precision boost, not a hard dependency.
+            }
+            // 1. Fact search (FTS5 + BM25 from library.db)
+            try {
+                const facts = hm.getActiveFacts(agentId, { limit: maxResults * 2 });
+                // Simple keyword matching for facts (FTS5 handles this in the DB layer)
+                const queryLower = query.toLowerCase();
+                const queryTerms = queryLower.split(/\s+/).filter(t => t.length > 2);
+                for (const fact of facts) {
+                    const contentLower = fact.content.toLowerCase();
+                    const matchCount = queryTerms.filter(t => contentLower.includes(t)).length;
+                    if (matchCount === 0)
+                        continue;
+                    const score = matchCount / queryTerms.length;
+                    if (score < minScore)
+                        continue;
+                    results.push({
+                        path: `library://facts/${fact.id}`,
+                        startLine: 0,
+                        endLine: 0,
+                        score,
+                        snippet: fact.content.slice(0, 300),
+                        source: 'memory',
+                        citation: fact.domain ? `[fact:${fact.domain}]` : '[fact]',
+                    });
+                }
+            }
+            catch {
+                // Fact search non-fatal
+            }
+            // 2. Vector/semantic search (when available)
+            try {
+                const vectorStore = hm.getVectorStore();
+                if (vectorStore) {
+                    const vectorResults = await hm.semanticSearch(agentId, query, {
+                        limit: maxResults,
+                        maxDistance: 1.5,
+                    });
+                    for (const vr of vectorResults) {
+                        const score = 1.0 - (vr.distance / 2.0); // normalize distance to 0-1 score
+                        if (score < minScore)
+                            continue;
+                        results.push({
+                            path: `vector://${vr.sourceTable}/${vr.sourceId}`,
+                            startLine: 0,
+                            endLine: 0,
+                            score,
+                            snippet: vr.content.slice(0, 300),
+                            source: 'memory',
+                            citation: `[${vr.sourceTable}:${vr.sourceId}]`,
+                        });
+                    }
+                }
+            }
+            catch {
+                // Vector search non-fatal
+            }
+            // 3. Message search (FTS5 across conversations)
+            try {
+                const messageResults = hm.search(agentId, query, maxResults);
+                for (const msg of messageResults) {
+                    const content = msg.textContent ?? '';
+                    results.push({
+                        path: `messages://${msg.conversationId ?? 'unknown'}/${msg.id}`,
+                        startLine: 0,
+                        endLine: 0,
+                        score: 0.5, // message search doesn't return scores, use mid-range
+                        snippet: content.slice(0, 300),
+                        source: 'sessions',
+                        citation: `[message:${msg.id}]`,
+                    });
+                }
+            }
+            catch {
+                // Message search non-fatal
+            }
+            // Deduplicate by content similarity, sort by score, limit
+            results.sort((a, b) => b.score - a.score);
+            return results.slice(0, maxResults);
+        },
+        async readFile(params) {
+            const absPath = path.resolve(workspaceDir, params.relPath);
+            try {
+                const content = await fs.readFile(absPath, 'utf-8');
+                const lines = content.split('\n');
+                const from = params.from ?? 0;
+                const count = params.lines ?? lines.length;
+                const slice = lines.slice(from, from + count);
+                return { text: slice.join('\n'), path: absPath };
+            }
+            catch (err) {
+                return { text: `Error reading ${absPath}: ${err.message}`, path: absPath };
+            }
+        },
+        status() {
+            const vectorStore = hm.getVectorStore();
+            const vectorStats = vectorStore ? hm.getVectorStats(agentId) : null;
+            return {
+                backend: 'builtin',
+                provider: 'hypermem',
+                model: 'hypermem-fts5+vector',
+                workspaceDir,
+                dbPath: path.join(os.homedir(), '.openclaw/hypermem'),
+                sources: ['memory', 'sessions'],
+                fts: {
+                    enabled: true,
+                    available: true,
+                },
+                vector: {
+                    enabled: !!vectorStore,
+                    available: !!vectorStore,
+                    dims: vectorStats?.dimensions
+                        ?? vectorStats?.dims
+                        ?? undefined,
+                },
+                custom: {
+                    vectorStats: vectorStats ?? undefined,
+                    factCount: hm.getActiveFacts(agentId, { limit: 1 }).length > 0 ? 'available' : 'empty',
+                },
+            };
+        },
+        async probeEmbeddingAvailability() {
+            try {
+                const vectorStore = hm.getVectorStore();
+                if (!vectorStore)
+                    return { ok: false, error: 'Vector store not initialized' };
+                return { ok: true };
+            }
+            catch (err) {
+                return { ok: false, error: err.message };
+            }
+        },
+        async probeVectorAvailability() {
+            return !!hm.getVectorStore();
+        },
+    };
+}
+// ─── Manager cache ──────────────────────────────────────────────
+// One manager per agentId; closed on plugin dispose.
+const _managers = new Map();
+// ─── Plugin Entry ───────────────────────────────────────────────
+export default definePluginEntry({
+    id: 'hypermem',
+    name: 'HyperMem Memory',
+    description: 'Bridges HyperMem retrieval (facts, vectors, messages) into the OpenClaw memory slot for memory_search and memory-wiki.',
+    kind: 'memory',
+    configSchema: emptyPluginConfigSchema(),
+    register(api) {
+        api.registerMemoryCapability({
+            runtime: {
+                async getMemorySearchManager(params) {
+                    try {
+                        const hm = await getHyperMem();
+                        const agentId = params.agentId || 'main';
+                        // Cache managers per agent
+                        if (!_managers.has(agentId)) {
+                            // Resolve workspace dir from agent config
+                            const agents = params.cfg?.agents?.list ?? [];
+                            const agentCfg = agents.find((a) => a.id === agentId);
+                            const workspaceDir = agentCfg?.workspace
+                                ?? path.join(os.homedir(), '.openclaw/workspace');
+                            _managers.set(agentId, createMemorySearchManager(hm, agentId, workspaceDir));
+                        }
+                        return { manager: _managers.get(agentId) };
+                    }
+                    catch (err) {
+                        return { manager: null, error: err.message };
+                    }
+                },
+                resolveMemoryBackendConfig(_params) {
+                    return { backend: 'builtin' };
+                },
+                async closeAllMemorySearchManagers() {
+                    _managers.clear();
+                },
+            },
+            publicArtifacts: {
+                async listArtifacts(params) {
+                    const artifacts = [];
+                    // List memory files for each agent
+                    const agents = params.cfg?.agents?.list ?? [];
+                    for (const agent of agents) {
+                        const agentId = agent.id;
+                        if (!agentId)
+                            continue;
+                        const workspace = agent.workspace;
+                        if (!workspace)
+                            continue;
+                        const memoryDir = path.join(workspace, 'memory');
+                        try {
+                            const files = await fs.readdir(memoryDir);
+                            for (const file of files) {
+                                if (!file.endsWith('.md'))
+                                    continue;
+                                artifacts.push({
+                                    kind: 'memory-daily',
+                                    workspaceDir: workspace,
+                                    relativePath: `memory/${file}`,
+                                    absolutePath: path.join(memoryDir, file),
+                                    agentIds: [agentId],
+                                    contentType: 'markdown',
+                                });
+                            }
+                        }
+                        catch {
+                            // No memory dir for this agent — skip
+                        }
+                        // Also expose MEMORY.md index
+                        const memoryIndex = path.join(workspace, 'MEMORY.md');
+                        try {
+                            await fs.access(memoryIndex);
+                            artifacts.push({
+                                kind: 'memory-index',
+                                workspaceDir: workspace,
+                                relativePath: 'MEMORY.md',
+                                absolutePath: memoryIndex,
+                                agentIds: [agentId],
+                                contentType: 'markdown',
+                            });
+                        }
+                        catch {
+                            // No MEMORY.md — skip
+                        }
+                    }
+                    return artifacts;
+                },
+            },
+        });
+    },
+});

package/memory-plugin/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@psiclawops/hypermem-memory",
-  "version": "0.9.2",
-  "description": "HyperMem memory plugin for OpenClaw — bridges HyperMem retrieval into the memory slot",
+  "version": "0.9.3",
+  "description": "HyperMem memory plugin for OpenClaw \u2014 bridges HyperMem retrieval into the memory slot",
   "type": "module",
   "main": "dist/index.js",
   "license": "Apache-2.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@psiclawops/hypermem",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "description": "Agent-centric memory and context composition engine for OpenClaw",
   "type": "module",
   "main": "dist/index.js",
@@ -24,8 +24,8 @@
   },
   "scripts": {
     "build": "tsc",
-    "prepublishOnly": "npm run build",
-    "prepack": "npm run build",
+    "prepublishOnly": "npm run build:all",
+    "prepack": "npm run build:all",
     "health": "node bin/hypermem-status.mjs --master",
     "health:master": "node bin/hypermem-status.mjs --master",
     "install:runtime": "node scripts/install-runtime.mjs",
@@ -44,7 +44,8 @@
     "validate:version-parity": "node scripts/validate-version-parity.mjs",
     "validate:public-surface": "node scripts/validate-public-surface.mjs",
     "bench:memory": "node bench/data-access-bench.mjs --iterations 1000 --warmup 50",
-    "validate:doctor": "node test/doctor-cli.mjs"
+    "validate:doctor": "node test/doctor-cli.mjs",
+    "build:all": "npm run build && npm --prefix plugin install --prefer-offline && npm --prefix plugin run build && npm --prefix memory-plugin install --prefer-offline && npm --prefix memory-plugin run build"
   },
   "dependencies": {
     "sqlite-vec": "^0.1.9",