@parallelclaw/memex-openclaw 0.1.0 → 0.1.1

package/README.md

@@ -9,17 +9,23 @@ Replaces the v0.11.x `memex-sync` file-watcher daemon. Captures via OpenClaw's n
 
 ## What it does
 
-Three lifecycle hooks + one corpus supplement:
+Three lifecycle hooks + two LLM-facing tools:
 
 | Hook | What we do |
 |---|---|
 | `agent_end` | Insert the just-completed turn's user + assistant messages into memex.db, verbatim. Channel comes from `ctx.messageProvider` — no parsing. |
 | `before_compaction` | Save messages that are about to be dropped from active context. They become searchable from memex even after OpenClaw forgets them. |
 | `session_end` | Update conversation last_ts. Safety-net marker. |
-| `registerMemoryCorpusSupplement` | Memex contents are surfaced through OpenClaw's built-in `memory_search` / `memory_get` tools — the model sees memex rows alongside workspace memory in one search result. |
+
+| Tool | What it does |
+|---|---|
+| `memex_search(query, limit?)` | FTS5 lexical search across all captured sources. Returns IDs + 100-char previews (cheap — Tier 1 of progressive disclosure). |
+| `memex_get(ids)` | Full verbatim text by record ID. Use after `memex_search` to read the records that look relevant (Tier 2). |
 
 Storage: `~/.memex/data/memex.db` (override via plugin config `dbPath`). Same SQLite schema as memex-mvp (npm) and memex-hermes (pip) — all three can write to the same DB concurrently.
 
+> **v0.1.0 used `registerMemoryCorpusSupplement` to surface memex content through OpenClaw's built-in `memory_search`.** Turned out that API is not exported to npm-installed (external) plugins in OpenClaw 2026.5.x — only to bundled ones. v0.1.1 switched to standalone tools, which work everywhere.
+
 ## Install
 
 Once published to npm:
@@ -74,6 +80,40 @@ Restart OpenClaw:
 openclaw gateway restart
 ```
 
+### If `MemexStore` fails to open (better-sqlite3 native binary missing)
+
+`openclaw plugins install` may run npm install with `--ignore-scripts`, which skips better-sqlite3's postinstall script that downloads the prebuilt native binary. Result: at runtime the plugin can't open the DB.
+
+Manual fix:
+
+```bash
+cd ~/.openclaw/npm/node_modules/@parallelclaw/memex-openclaw
+npm rebuild better-sqlite3
+# On low-memory VPS where gyp rebuild OOMs, force prebuilt-only:
+#   npm rebuild better-sqlite3 --build-from-source=false
+openclaw gateway restart
+```
+
+### Bug-1 diagnostic (v0.1.1)
+
+If after install the plugin appears `loaded` in `openclaw plugins inspect memex-openclaw` but no rows are captured, check the diagnostic trace file we write at the top of every `register()` invocation:
+
+```bash
+cat /tmp/memex-openclaw-debug.log
+```
+
+A correct sequence looks like:
+
+```
+2026-... module loaded (top-level)
+2026-... register() called — gateway recognised plugin
+2026-... store opened: ~/.memex/data/memex.db, rows=N
+2026-... tools registered: memex_search, memex_get
+2026-... register() returned — hooks active
+```
+
+If only the first line is present and nothing else fires on `openclaw gateway restart`, OpenClaw is not invoking the plugin's `register()` function for external (npm-installed) plugins. Open an issue on the repo with the full diagnostic file content.
+
 ## Conversation routing
 
 | OpenClaw context | memex conversation_id |

package/index.js

@@ -2,34 +2,45 @@
  * memex-openclaw — OpenClaw plugin that captures every turn verbatim
  * into the memex unified SQLite corpus.
  *
- * Replaces the v0.11.x file-watcher daemon approach. This plugin:
- *   • Subscribes to `agent_end` for per-turn capture — no file watching
- *   • Subscribes to `before_compaction` to preserve messages before
- *     they're dropped from active context
- *   • Subscribes to `session_end` as a safety-net flush
- *   • Registers a `MemoryCorpusSupplement` so the model's built-in
- *     `memory_search` tool sees memex content alongside workspace memory
- *
- * Channel detection: zero parsing. OpenClaw 2026.5+ hands us
- * `ctx.messageProvider` (e.g. "telegram") and `ctx.channelId` (e.g.
- * "97592799") directly in the hook context.
- *
- * Storage: ~/.memex/data/memex.db (override via plugin config db_path).
- * Schema parity with memex-mvp (npm) and memex-hermes (pip) — all three
- * write to the same database with the same UNIQUE-constraint dedup.
+ * v0.1.1 changes from 0.1.0:
+ *   • Removed `kind: "memory"` — conflicted with memory-core's exclusive
+ *     memory slot (bug 3 from 2026-05-21 VPS test report).
+ *   • Replaced `registerMemoryCorpusSupplement` with `api.registerTool`
+ *     — corpus supplement API is not exported to external (npm) plugins
+ *     in OpenClaw 2026.5.x (bug 2).
+ *   • Hardened defensive logging: writes to /tmp/memex-openclaw-debug.log
+ *     at the very first line of register() so we can verify register()
+ *     fires at all on gateway restart (bug 1 diagnostic instrumentation).
  *
  * @see openclaw.plugin.json for manifest
  * @see package.json for npm distribution
  */
 
-import {
-  definePluginEntry,
-  registerMemoryCorpusSupplement,
-} from 'openclaw/plugin-sdk/core';
+import { definePluginEntry } from 'openclaw/plugin-sdk/core';
+import { appendFileSync } from 'node:fs';
 
 import { MemexStore } from './lib/store.js';
 import { deriveConvId, deriveMsgId, extractText } from './lib/conv_id.js';
-import { buildCorpusSupplement } from './lib/corpus_supplement.js';
+import { registerMemexTools } from './lib/tools.js';
+
+// v0.1.1 BUG-1 DIAGNOSTIC: trace register() invocations to a file the
+// user can grep. v0.1.0 had a problem where register() was called
+// during `openclaw plugins install` but NOT on `gateway restart` for
+// external (npm-installed) plugins. This trace will tell us if the
+// problem persists in 0.1.1 or got fixed by changes to manifest.
+function traceRegister(msg) {
+  try {
+    appendFileSync(
+      '/tmp/memex-openclaw-debug.log',
+      `[${new Date().toISOString()}] ${msg}\n`,
+      { mode: 0o644 },
+    );
+  } catch {
+    /* /tmp not writable? whatever — diag-only */
+  }
+}
+
+traceRegister('module loaded (top-level)');
 
 export default definePluginEntry({
   id: 'memex-openclaw',
@@ -37,55 +48,66 @@ export default definePluginEntry({
   description:
     'Captures every OpenClaw turn verbatim into the memex unified SQLite corpus. ' +
     'Pair with memex-mvp (npm) to search OpenClaw + Hermes + Claude Code + Telegram from one place.',
-  kind: 'memory',
 
   register(api) {
+    traceRegister('register() called — gateway recognised plugin');
+
     const logger = api.logger;
     const cfg = api.pluginConfig || {};
     let store;
 
     try {
       store = new MemexStore(cfg.dbPath);
-      logger.info(`memex-openclaw: opened ${store.dbPath} (current rows: ${store.count()})`);
+      const initialCount = store.count();
+      logger.info(
+        `memex-openclaw: opened ${store.dbPath} (current rows: ${initialCount})`,
+      );
+      traceRegister(`store opened: ${store.dbPath}, rows=${initialCount}`);
     } catch (err) {
       logger.error(`memex-openclaw: failed to open memex.db: ${err.message}`);
-      return; // can't operate without store
+      traceRegister(`store open FAILED: ${err.message}`);
+      // v0.1.1: do NOT early-return. We still register tools (even if they
+      // fail later) so the user can see the plugin is at least live and
+      // diagnose. Capture hooks will no-op cleanly if store is null.
     }
 
-    // -------------------------------------------------------------
-    // 1. Primary capture — every turn that completes successfully
-    // -------------------------------------------------------------
+    // ------------------------------------------------------------
+    // 1. Primary capture — every successful turn
+    // ------------------------------------------------------------
     api.on('agent_end', async (event, ctx) => {
-      if (!event?.success) return; // failed turns are skipped (LLM error, etc.)
+      if (!store) return;
+      if (!event?.success) return;
       try {
         const platform = ctx?.messageProvider || 'unknown';
         const channelId = ctx?.channelId;
         const sessionId = ctx?.sessionId;
         const agentId = ctx?.agentId || 'main';
-        const convId = deriveConvId({ messageProvider: platform, channelId, sessionId });
+        const convId = deriveConvId({
+          messageProvider: platform,
+          channelId,
+          sessionId,
+        });
 
-        // Capture only the LAST TURN's user + assistant messages —
-        // earlier history was captured by prior agent_end invocations.
-        // (OpenClaw passes full conversation history but most of it is
-        // already in memex.db from previous turns; UNIQUE dedup makes
-        // re-inserting harmless but wasteful.)
+        // Capture only the LAST TURN's user + assistant messages.
+        // OpenClaw passes full history but earlier turns were already
+        // captured by prior agent_end invocations; UNIQUE dedup makes
+        // re-insertion harmless but wasteful.
         const messages = Array.isArray(event.messages) ? event.messages : [];
         const lastTurn = messages.slice(-2);
-
         const baseTs = Math.floor(Date.now() / 1000);
+
         for (let i = 0; i < lastTurn.length; i++) {
           const msg = lastTurn[i];
           if (!msg || (msg.role !== 'user' && msg.role !== 'assistant')) continue;
           const text = extractText(msg);
           if (!text || !text.trim()) continue;
 
-          const msgId = deriveMsgId({ role: msg.role, text, convId });
           store.insertMessage({
             conversationId: convId,
-            msgId,
+            msgId: deriveMsgId({ role: msg.role, text, convId }),
             role: msg.role,
             text,
-            ts: baseTs + i, // tiny offset to preserve order
+            ts: baseTs + i,
             channel: platform,
             metadata: {
               raw_type: 'openclaw-agent-end',
@@ -100,7 +122,6 @@ export default definePluginEntry({
           });
         }
 
-        // Keep conversations.last_ts current.
         store.upsertConversation({
           conversationId: convId,
           title: convId,
@@ -112,10 +133,11 @@ export default definePluginEntry({
       }
     });
 
-    // -------------------------------------------------------------
+    // ------------------------------------------------------------
     // 2. Preserve messages before they're compacted out of context
-    // -------------------------------------------------------------
+    // ------------------------------------------------------------
     api.on('before_compaction', async (event, ctx) => {
+      if (!store) return;
       try {
         const messages = Array.isArray(event?.messages) ? event.messages : [];
         if (messages.length === 0) return;
@@ -123,9 +145,13 @@ export default definePluginEntry({
         const platform = ctx?.messageProvider || 'unknown';
         const channelId = ctx?.channelId;
         const sessionId = ctx?.sessionId;
-        const convId = deriveConvId({ messageProvider: platform, channelId, sessionId });
-
+        const convId = deriveConvId({
+          messageProvider: platform,
+          channelId,
+          sessionId,
+        });
         const baseTs = Math.floor(Date.now() / 1000);
+
         let saved = 0;
         for (let i = 0; i < messages.length; i++) {
           const msg = messages[i];
@@ -158,45 +184,48 @@ export default definePluginEntry({
       }
     });
 
-    // -------------------------------------------------------------
-    // 3. Session-end safety net — flush the full final history
-    // -------------------------------------------------------------
+    // ------------------------------------------------------------
+    // 3. Session-end safety net
+    // ------------------------------------------------------------
     api.on('session_end', async (event, ctx) => {
+      if (!store) return;
       try {
-        // session_end doesn't carry messages[] in OpenClaw 2026.5 —
-        // we have sessionId + sessionKey + reason. The hook serves as
-        // a marker that this conv is "done"; we update conv last_ts
-        // and let agent_end captures already-in-DB stand.
         const platform = ctx?.messageProvider || 'unknown';
         const channelId = ctx?.channelId;
         const sessionId = event?.sessionId || ctx?.sessionId;
-        const convId = deriveConvId({ messageProvider: platform, channelId, sessionId });
+        const convId = deriveConvId({
+          messageProvider: platform,
+          channelId,
+          sessionId,
+        });
         store.upsertConversation({
           conversationId: convId,
           title: convId,
           lastTs: Math.floor(Date.now() / 1000),
         });
-        logger.debug(`memex-openclaw: session_end conv=${convId} reason=${event?.reason}`);
       } catch (err) {
         logger.error(`memex-openclaw: session_end failed: ${err.message}`);
       }
     });
 
-    // -------------------------------------------------------------
-    // 4. Expose memex contents to OpenClaw's built-in memory_search
-    // -------------------------------------------------------------
-    try {
-      const supplement = buildCorpusSupplement(store, logger);
-      registerMemoryCorpusSupplement('memex-openclaw', supplement);
-      logger.info('memex-openclaw: registered as memory corpus supplement');
-    } catch (err) {
-      // Non-fatal — capture still works without supplement registration.
-      logger.warn(
-        `memex-openclaw: could not register corpus supplement: ${err.message} ` +
-        '(capture still active; built-in memory_search will not surface memex rows)',
-      );
+    // ------------------------------------------------------------
+    // 4. Register tools the LLM can call directly
+    //    (v0.1.1: replaces registerMemoryCorpusSupplement which is
+    //    not exported to external plugins in OpenClaw 2026.5.x)
+    // ------------------------------------------------------------
+    if (store) {
+      try {
+        registerMemexTools(api, store, logger);
+        traceRegister('tools registered: memex_search, memex_get');
+      } catch (err) {
+        logger.error(`memex-openclaw: tool registration failed: ${err.message}`);
+        traceRegister(`tool registration FAILED: ${err.message}`);
+      }
+    } else {
+      logger.warn('memex-openclaw: store unavailable, skipping tool registration');
     }
 
-    logger.info('memex-openclaw: plugin activated');
+    logger.info('memex-openclaw: plugin activated (v0.1.1)');
+    traceRegister('register() returned — hooks active');
   },
 });

package/lib/store.js

@@ -14,7 +14,28 @@
  * while we write.
  */
 
-import Database from 'better-sqlite3';
+// v0.1.1: dynamic import + helpful error message for environments where
+// better-sqlite3's native binary failed to install (small-VPS OOM during
+// gyp rebuild, --ignore-scripts during plugin install, etc.). Bug 4 from
+// the 2026-05-21 VPS test report.
+let Database;
+try {
+  Database = (await import('better-sqlite3')).default;
+} catch (err) {
+  const helpful = new Error(
+    'memex-openclaw: failed to load better-sqlite3 native binary.\n' +
+    '  Original error: ' + err.message + '\n' +
+    '  This usually means the prebuilt binary download failed during\n' +
+    '  `openclaw plugins install` (often blocked by --ignore-scripts).\n' +
+    '  Manual fix:\n' +
+    '    cd ~/.openclaw/npm/node_modules/@parallelclaw/memex-openclaw\n' +
+    '    npm rebuild better-sqlite3\n' +
+    '  Then `openclaw gateway restart`.\n' +
+    '  On low-memory VPS where rebuild OOMs: `npm rebuild better-sqlite3 --build-from-source=false` to force prebuilt-only.',
+  );
+  helpful.cause = err;
+  throw helpful;
+}
 import { mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { homedir } from 'node:os';

package/lib/tools.js

@@ -0,0 +1,142 @@
+/**
+ * Memex tool definitions for OpenClaw's `api.registerTool()`.
+ *
+ * v0.1.0 attempted to expose memex contents via OpenClaw's bundled-only
+ * `registerMemoryCorpusSupplement()` — that function turned out NOT to
+ * be exported to external (npm-installed) plugins. v0.1.1 switches to
+ * the universally-available `api.registerTool()` API.
+ *
+ * Trade-off: the model now has TWO distinct tools (memex_search +
+ * memex_get) instead of the OpenClaw-merged memory_search experience.
+ * In exchange we don't depend on internal API surface.
+ *
+ * Progressive disclosure pattern preserved:
+ *   memex_search(query)  → IDs + 100-char previews (cheap, Tier 1)
+ *   memex_get(ids)       → full verbatim text (only when needed, Tier 2)
+ */
+
+/**
+ * Register memex_search + memex_get tools on the OpenClaw plugin API.
+ *
+ * @param {object} api - OpenClaw plugin API (passed to register(api))
+ * @param {object} store - MemexStore instance
+ * @param {object} logger - api.logger
+ */
+export function registerMemexTools(api, store, logger) {
+  // Tool 1: memex_search — Tier 1 (cheap, returns IDs + previews)
+  api.registerTool('memex_search', {
+    description:
+      'Search the memex verbatim corpus across all captured sources (OpenClaw + Hermes + Claude Code + Telegram + etc.). ' +
+      'Returns abbreviated records — id, role, channel, 100-char preview. ' +
+      'Call memex_get(ids) afterwards to fetch full text. ' +
+      'Use this BEFORE memex_get to find what is relevant; rarely call memex_get directly.',
+    parameters: {
+      type: 'object',
+      properties: {
+        query: {
+          type: 'string',
+          description:
+            'FTS5 query. Simple keywords work; phrases use double quotes. ' +
+            'Example: install ffmpeg or "docker compose" production.',
+        },
+        limit: {
+          type: 'integer',
+          description: 'Max results (default 10, max 50).',
+        },
+      },
+      required: ['query'],
+    },
+    handler: async ({ query, limit }) => {
+      try {
+        const rows = store.search(query || '', limit || 10);
+        if (!rows.length) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                results: [],
+                hint: 'No matches. Try different keywords.',
+              }),
+            }],
+          };
+        }
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              results: rows,
+              count: rows.length,
+              hint: 'Call memex_get(ids=[...]) for full verbatim text of records you want to read.',
+            }),
+          }],
+        };
+      } catch (err) {
+        logger?.error?.(`memex_search failed: ${err.message}`);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({ error: err.message }),
+          }],
+        };
+      }
+    },
+  });
+
+  // Tool 2: memex_get — Tier 2 (full text by ID)
+  api.registerTool('memex_get', {
+    description:
+      'Fetch full verbatim text of specific records by ID. ' +
+      'Call this after memex_search to read the records that look relevant. ' +
+      'Returns the original text in full, not a summary.',
+    parameters: {
+      type: 'object',
+      properties: {
+        ids: {
+          type: 'array',
+          items: { type: 'integer' },
+          description: 'Record IDs returned by memex_search.',
+        },
+      },
+      required: ['ids'],
+    },
+    handler: async ({ ids }) => {
+      try {
+        if (!Array.isArray(ids) || ids.length === 0) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ error: 'ids must be a non-empty array of integers' }),
+            }],
+          };
+        }
+        // Cap at 20 to avoid runaway token usage.
+        const capped = ids.slice(0, 20);
+        const truncated = ids.length > capped.length;
+        const records = capped
+          .map((id) => store.getById(id))
+          .filter(Boolean);
+        const out = { records, count: records.length };
+        if (truncated) {
+          out.truncated = true;
+          out.hint = `Capped at 20 records; ${ids.length - 20} more were not fetched.`;
+        }
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(out),
+          }],
+        };
+      } catch (err) {
+        logger?.error?.(`memex_get failed: ${err.message}`);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({ error: err.message }),
+          }],
+        };
+      }
+    },
+  });
+
+  logger?.info?.('memex-openclaw: registered tools memex_search, memex_get');
+}

package/openclaw.plugin.json

@@ -2,13 +2,12 @@
   "id": "memex-openclaw",
   "name": "Memex",
   "description": "Captures every OpenClaw turn verbatim into the memex unified SQLite corpus. Pair with memex-mvp (npm) to search OpenClaw + Hermes + Claude Code + Telegram from one place.",
-  "version": "0.1.0",
-  "kind": "memory",
+  "version": "0.1.1",
   "activation": {
     "onStartup": true
   },
   "contracts": {
-    "memoryCorpusSupplements": ["memex-openclaw"]
+    "tools": ["memex_search", "memex_get"]
   },
   "uiHints": {
     "category": "memory",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parallelclaw/memex-openclaw",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "OpenClaw plugin that captures every turn verbatim into the memex unified SQLite corpus. Pair with memex-mvp for one searchable history across OpenClaw, Hermes, Claude Code, Telegram, and more.",
   "type": "module",
   "main": "index.js",

package/lib/corpus_supplement.js

@@ -1,131 +0,0 @@
-/**
- * MemoryCorpusSupplement adapter — exposes memex contents to OpenClaw's
- * built-in `memory_search` and `memory_get` tools.
- *
- * The OpenClaw runtime ships memory-core, which provides workspace-based
- * memory (MEMORY.md / USER.md / memory/YYYY-MM-DD.md). Plugins can
- * REGISTER A SUPPLEMENT — additional rows that show up in the same tool
- * output, prefixed/labelled so the model knows which corpus a row came
- * from.
- *
- * This is the strategic positioning: memex doesn't REPLACE memory-core,
- * it ADDS to it. The model sees a single `memory_search` tool, gets
- * results from BOTH built-in workspace memory AND memex's verbatim
- * cross-client corpus, in one shot.
- *
- * Multi-plugin coexistence: Mem0, Memoria, memex can all register
- * their own supplements. OpenClaw merges results.
- */
-
-const CORPUS_LABEL = 'memex';
-
-/**
- * Build the supplement object that gets handed to OpenClaw's
- * `registerMemoryCorpusSupplement(pluginId, supplement)` call.
- *
- * Contract (from OpenClaw 2026.5.4 plugin-sdk/memory-state.d.ts):
- *
- *   supplement.search({ query, maxResults, agentSessionKey })
- *     → Promise<MemoryCorpusSearchResult[]>
- *
- *   supplement.get({ lookup, fromLine, lineCount, agentSessionKey })
- *     → Promise<MemoryCorpusGetResult | null>
- */
-export function buildCorpusSupplement(store, logger) {
-  return {
-    async search({ query, maxResults = 10 } = {}) {
-      try {
-        const rows = store.search(query || '', maxResults);
-        return rows.map((r) => toSearchResult(r));
-      } catch (err) {
-        logger?.warn?.(`memex-openclaw: corpus search failed: ${err.message}`);
-        return [];
-      }
-    },
-
-    async get({ lookup }) {
-      // `lookup` is the id we returned in search results' `id` field.
-      // We use the message row id as a string for portability.
-      try {
-        const numericId = parseInt(String(lookup).replace(/^memex:/, ''), 10);
-        if (!Number.isFinite(numericId)) return null;
-        const row = store.getById(numericId);
-        return row ? toGetResult(row) : null;
-      } catch (err) {
-        logger?.warn?.(`memex-openclaw: corpus get failed: ${err.message}`);
-        return null;
-      }
-    },
-  };
-}
-
-/**
- * Map a memex row (from store.search) to OpenClaw's
- * MemoryCorpusSearchResult shape:
- *
- *   { corpus, path, title?, kind?, score, snippet, id?,
- *     startLine?, endLine?, citation?, source?,
- *     provenanceLabel?, sourceType?, sourcePath?, updatedAt? }
- */
-function toSearchResult(row) {
-  const date = row.ts ? new Date(row.ts * 1000).toISOString() : undefined;
-  return {
-    corpus: CORPUS_LABEL,
-    id: `memex:${row.id}`,
-    path: `memex://${row.conversation_id}/#msg-${row.id}`,
-    title: titleFromRow(row),
-    kind: row.channel || 'openclaw',
-    score: 1.0, // memex returns ranked-by-ts; bm25 inside FTS would refine
-    snippet: row.preview || '',
-    source: 'openclaw',
-    provenanceLabel: row.channel
-      ? `memex • ${row.channel}`
-      : 'memex • openclaw',
-    sourceType: 'verbatim',
-    sourcePath: row.conversation_id,
-    updatedAt: date,
-  };
-}
-
-/**
- * Map a memex row (from store.getById) to OpenClaw's
- * MemoryCorpusGetResult shape:
- *
- *   { corpus, path, title?, kind?, content, fromLine, lineCount,
- *     id?, provenanceLabel?, sourceType?, sourcePath?, updatedAt? }
- */
-function toGetResult(row) {
-  const date = row.ts ? new Date(row.ts * 1000).toISOString() : undefined;
-  const lineCount = row.text ? row.text.split('\n').length : 1;
-  return {
-    corpus: CORPUS_LABEL,
-    id: `memex:${row.id}`,
-    path: `memex://${row.conversation_id}/#msg-${row.id}`,
-    title: titleFromRow(row),
-    kind: row.channel || 'openclaw',
-    content: row.text || '',
-    fromLine: 1,
-    lineCount,
-    provenanceLabel: row.channel
-      ? `memex • ${row.channel}`
-      : 'memex • openclaw',
-    sourceType: 'verbatim',
-    sourcePath: row.conversation_id,
-    updatedAt: date,
-  };
-}
-
-function titleFromRow(row) {
-  const role = row.role || '?';
-  const when = row.ts
-    ? new Date(row.ts * 1000).toISOString().slice(0, 10)
-    : '?';
-  // First ~40 chars of text → title-ish
-  const preview = (row.text || row.preview || '')
-    .replace(/\s+/g, ' ')
-    .trim()
-    .slice(0, 40);
-  return preview
-    ? `[${when} ${role}] ${preview}${preview.length === 40 ? '…' : ''}`
-    : `${role} @ ${when}`;
-}