@lotargo/memory_plugin 1.6.0 → 1.6.2

package/CHANGELOG.md

@@ -5,6 +5,49 @@ All notable changes to `@lotargo/memory_plugin` are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.6.2] - 2026-08-12
+
+### Added
+
+- **Batch retrieval API** (`batch_query_knowledge_base`): execute multiple search queries in a single MCP call. All query embeddings computed in one ONNX pass, queries run in parallel via `Promise.all`. Ideal for cross-document comparisons and multi-part analysis — significantly reduces API overhead vs N separate `query_knowledge_base` calls.
+- **Policy expansion toggle** (`config.policyExpansion`, default: `true`): table summaries and code signatures are automatically expanded to full content for better recall (~+5-10% recall, slight MRR trade-off). Disable per-call or via config for pure micro_chunk precision.
+- **RAG evaluation test** (`tests/unit/rag_evaluation.test.js`): 10 analytical queries with expected-fact verification (100% pass rate on financial reports). Includes raw-question vs optimized-query comparison demonstrating +33% fact retrieval improvement.
+
+### Changed
+
+- `hybridQuery()` accepts `_precomputedVector` internal parameter for batch embedding reuse.
+- `PROMPT_BLOCK` (injected into AGENTS.md/CLAUDE.md) updated with query optimization and batch usage directives.
+- SKILL.md updated with batch query tool and query formulation guidance.
+
+## [1.6.1] - 2026-08-10
+
+### Fixed
+
+- **Cryptic crash on Node.js < 22.5.0** (`No such built-in module: node:sqlite`).
+  ESM static imports are hoisted, so the `node:sqlite` import in `database.js`
+  crashed before any user code could run.  Three layers of protection are now in
+  place:
+  1. **Boot guard** (`boot.js` / `cli_boot.js`): new lightweight entry points
+     that check `process.versions.node` *before* loading the ESM module graph.
+     On incompatible versions they print a clear boxed error with upgrade
+     instructions (`nvm install 22` / `brew install node@22`) and exit.
+  2. **`engine-strict`** (`.npmrc`): `npm install` now **fails** instead of
+     merely warning when `engines.node >= 22.5.0` is not satisfied.
+  3. **Preinstall warning** (`preinstall.js`): a prominent `stderr` message is
+     printed during installation on unsupported Node versions, explaining that
+     the server will not start.
+- Process-kill patterns in `preinstall.js` now match the new `boot.js` entry
+  point in addition to `index.js`, so global updates correctly terminate running
+  server instances.
+
+### Changed
+
+- All `bin` entry points (`memory_plugin`, `memory-agent`, `memory-cli`) now
+  route through `boot.js` / `cli_boot.js` instead of directly to `index.js` /
+  `cli.js`.
+- `.npmrc` is no longer git-ignored; it contains only the project-level
+  `engine-strict=true` setting (npm never publishes `.npmrc` to the tarball).
+
 ## [1.6.0] - 2026-08-10
 
 This release is the outcome of a full five-part audit (publishing, security, code
@@ -105,4 +148,5 @@ a critical retrieval regression introduced after `v1.5.3`.
 - `BENCHMARKS.md` tables were re-derived from the stored JSON artifacts; the
   bge-m3 section had carried e5-small numbers shifted by a column.
 
+[1.6.1]: https://github.com/Lotargo/memory_pugin/releases/tag/v1.6.1
 [1.6.0]: https://github.com/Lotargo/memory_pugin/releases/tag/v1.6.0

package/README.md

@@ -176,6 +176,7 @@ The MCP server registers **14 MCP tools** accessible across all connected AI env
 | :--- | :------------- | :---------- |
 | `ingest_document` | `content`, `type`, `title`, `path`, `generateEmbeddings` | Ingest local files, URLs, or raw text into the 3-tier index (Big/Medium/Small) with ONNX vector embeddings and GraphRAG symbol extraction. |
 | `query_knowledge_base` | `query`, `limit`, `instruction`, `generateEmbeddings` | Perform hybrid search (RSF/RRF BM25 + dense vector similarity) to retrieve candidate document sections with defined code symbols. |
+| `batch_query_knowledge_base` | `queries` (array), `limit`, `instruction`, `generateEmbeddings` | Execute multiple queries in a single batch call. More efficient than separate `query_knowledge_base` calls — all embeddings computed in one ONNX pass, queries run in parallel. Ideal for comparisons and multi-topic analysis. |
 | `manage_knowledge_base` | `action`, `docId`, `snapshotPath` | Inspect DB stats (`stats`), list documents (`list`), read full raw document (`read_document`), delete document (`delete`), or export/import snapshots (`export_snapshot` / `import_snapshot`). |
 | `reindex_knowledge_base` | `model`, `dimension` | Re-embed all stored vectors with the active (or specified) embedding model and vector dimension. Use after switching the embedding model or vector dimension so previously indexed documents remain retrievable. Preserves documents, FTS index, graph edges, and fact links. |
 | `link_knowledge` | `action`, `factText`, `docId`, `scope`, `startLine`, `endLine`, `relationType` | Create, list, or retrieve semantic graph links connecting Notebook facts to Knowledge Base documents, sections, or line ranges. Actions: `link`, `list_links`, `get_doc_links`. |
@@ -319,6 +320,7 @@ The engine is configured through `<memory-dir>/config.json` (created with defaul
 | `onnxThreads` | `0` | ONNX WASM threads: `0` auto-detect, or `1-16` |
 | `executionDevice` | `cpu` | `cpu` or `webgpu` (experimental) |
 | `vectorScanLimit` | `50000` | Max micro-chunks scanned per vector query (`0` = unlimited) |
+| `policyExpansion` | `true` | Expand table_summary/code_signature policy chunks for better recall (slight MRR trade-off). Disable for pure micro_chunk precision. |
 | `injectLimit` | `10` | Max facts injected into the agent's system prompt |
 | `conflictStrategy` | `merge` | Hybrid-sync conflict resolution: `merge`, `cloud-wins`, or `local-wins` |
 | `tursoUrl` | `""` | Primary Turso endpoint URL (set by `login`) |
@@ -334,18 +336,41 @@ The engine is configured through `<memory-dir>/config.json` (created with defaul
 
 ## Testing & Benchmarking
 
-To run the automated test suite and benchmarks locally:
+To run the automated test suite and benchmarks locally, from the repository root:
 
 ```bash
-cd mcp-server
-
-# Run unit and integration tests
+# Unit + integration + cloud suites (12 files) — fast and fully offline
 npm test
 
-# Run search quality & ingestion benchmarks
+# End-to-end smoke test with REAL ONNX embeddings — run before a release
+npm run smoke
+
+# Search quality & ingestion benchmarks
 npm run benchmark
 ```
 
+### Two testing modes, and why both exist
+
+`npm test` runs every suite with `generateEmbeddings: false`. That keeps it fast
+and offline (no model download, no network), but it means the **dense-vector half
+of the engine is never exercised** — retrieval falls back to BM25-only.
+
+`npm run smoke` covers exactly that blind spot: it ingests a document with real
+ONNX vectors and asserts that hybrid retrieval returns a non-zero cosine
+similarity, plus that a Russian query still reaches an English document
+(something BM25 cannot do). It also walks the full user journey — remember →
+recall → ingest → query → link → update → get → forget — and checks the ingest
+path guard.
+
+This split is not academic: a regression in `v1.5.3+` disabled vector search
+entirely (`node:sqlite` returns BLOBs as `Uint8Array`, and a `Buffer.isBuffer()`
+guard discarded every stored vector) while all offline suites stayed green. The
+smoke test exists so that class of failure cannot ship unnoticed again.
+
+The smoke test reuses the model weights already cached in your data directory, so
+it does not re-download them. Point `MEMORY_MODEL_CACHE` at a cache directory to
+override the lookup; without any cache the weights are fetched once.
+
 For complete methodology details and search quality evaluation metrics, see [`docs/BENCHMARKS.md`](./docs/BENCHMARKS.md).
 
 ### Empirical Search Quality Results

package/mcp-server/boot.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+// ── Boot Guard ──────────────────────────────────────────────────────────────
+// This file is the true entry point for both `memory_plugin` and `memory-agent`
+// binaries.  Its sole purpose is to verify the Node.js version BEFORE the ESM
+// module graph is evaluated — because `mcp-server/index.js` transitively
+// imports `node:sqlite` (a built-in available only from Node 22.5.0), and ESM
+// static imports are hoisted, so a version check inside that file would never
+// execute.
+//
+// By keeping this file free of any `node:sqlite` dependency we can print a
+// clear, actionable error message instead of the cryptic
+//   "No such built-in module: node:sqlite"
+// that users on Node 18/20/21 would otherwise see.
+// ─────────────────────────────────────────────────────────────────────────────
+
+const MIN_MAJOR = 22;
+const MIN_MINOR = 5;
+
+const [major, minor] = process.versions.node.split(".").map(Number);
+
+if (major < MIN_MAJOR || (major === MIN_MAJOR && minor < MIN_MINOR)) {
+  process.stderr.write(
+    `\n` +
+    `  ╔══════════════════════════════════════════════════════════════════╗\n` +
+    `  ║  @lotargo/memory_plugin requires Node.js >= 22.5.0             ║\n` +
+    `  ║                                                                ║\n` +
+    `  ║  Detected: Node.js ${process.versions.node.padEnd(44)}║\n` +
+    `  ║                                                                ║\n` +
+    `  ║  The built-in node:sqlite module used by this plugin was       ║\n` +
+    `  ║  introduced in Node.js 22.5.0.  Please upgrade your           ║\n` +
+    `  ║  Node.js installation:                                        ║\n` +
+    `  ║                                                                ║\n` +
+    `  ║    nvm install 22   # or: brew install node@22                 ║\n` +
+    `  ║                                                                ║\n` +
+    `  ╚══════════════════════════════════════════════════════════════════╝\n` +
+    `\n`
+  );
+  process.exit(1);
+}
+
+// Version is OK — hand off to the real entry point.
+import("./index.js");

package/mcp-server/cli_boot.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+// ── CLI Boot Guard ──────────────────────────────────────────────────────────
+// Same version check as boot.js — see that file for the rationale.
+// ─────────────────────────────────────────────────────────────────────────────
+
+const MIN_MAJOR = 22;
+const MIN_MINOR = 5;
+
+const [major, minor] = process.versions.node.split(".").map(Number);
+
+if (major < MIN_MAJOR || (major === MIN_MAJOR && minor < MIN_MINOR)) {
+  process.stderr.write(
+    `\n` +
+    `  ╔══════════════════════════════════════════════════════════════════╗\n` +
+    `  ║  @lotargo/memory_plugin requires Node.js >= 22.5.0             ║\n` +
+    `  ║                                                                ║\n` +
+    `  ║  Detected: Node.js ${process.versions.node.padEnd(44)}║\n` +
+    `  ║                                                                ║\n` +
+    `  ║  The built-in node:sqlite module used by this plugin was       ║\n` +
+    `  ║  introduced in Node.js 22.5.0.  Please upgrade your           ║\n` +
+    `  ║  Node.js installation:                                        ║\n` +
+    `  ║                                                                ║\n` +
+    `  ║    nvm install 22   # or: brew install node@22                 ║\n` +
+    `  ║                                                                ║\n` +
+    `  ╚══════════════════════════════════════════════════════════════════╝\n` +
+    `\n`
+  );
+  process.exit(1);
+}
+
+// Version is OK — hand off to the real CLI.
+import("./cli.js").then(m => {
+  if (process.argv[1] && process.argv[1].includes("cli_boot.js")) {
+    m.runCli().catch((err) => console.error("CLI error:", err));
+  }
+});

package/mcp-server/config/config_manager.js

@@ -25,6 +25,7 @@ export const DEFAULT_CONFIG = {
   username: "",           // Account username from the Turso OAuth profile
   ingestAllowedPaths: [], // Extra directories ingest_document(type:"file") may read from
   ingestAllowAnyPath: false, // Escape hatch: allow reading ANY path from disk (unsafe)
+  policyExpansion: true,    // Expand table_summary/code_signature policy chunks (boosts recall, slight MRR trade-off)
 };
 
 let cachedConfig = null;

package/mcp-server/db/migrations.js

@@ -138,6 +138,21 @@ const MIGRATIONS = [
       `);
     },
   },
+  {
+    version: 5,
+    name: "005_retrieval_policy",
+    up: async (db) => {
+      try {
+        await db.exec(`ALTER TABLE micro_chunks ADD COLUMN retrieval_policy TEXT DEFAULT 'micro_chunk';`);
+      } catch (e) {}
+      try {
+        await db.exec(`ALTER TABLE micro_chunks ADD COLUMN policy_source_id TEXT;`);
+      } catch (e) {}
+      await db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_micro_chunks_retrieval_policy ON micro_chunks(retrieval_policy);
+      `);
+    },
+  },
 ];
 
 export async function runMigrations(db) {

package/mcp-server/ingest/chunker.js

@@ -5,6 +5,159 @@ export function estimateTokens(text) {
   return Math.ceil(text.length / 4);
 }
 
+const CODE_SIGNATURE_REGEX = /^\s*(?:export\s+|async\s+)?(?:function|class|def|pub\s+fn|fn|struct|interface|enum)\s+/;
+
+function _classifyLine(line) {
+  const t = line.trimStart();
+  if (t.startsWith("/**")) return "jsdoc_start";
+  if (t.startsWith("*/")) return "jsdoc_end";
+  if (t.startsWith("*")) return "jsdoc_mid";
+  if (t.startsWith("//")) return "line_comment";
+  if (t.startsWith("#")) return "hash_comment";
+  if (t.startsWith("'''") || t.startsWith('"""')) return "py_docstring";
+  return "code";
+}
+
+export function extractCodeSignatures(codeContent) {
+  const lines = codeContent.split("\n");
+  const signatures = [];
+
+  const fenceMatch = lines[0] && lines[0].match(/^(\s*)(```|~~~)/);
+  const bodyStart = fenceMatch ? 1 : 0
+  const bodyEnd = fenceMatch && (lines[lines.length - 1].startsWith("```") || lines[lines.length - 1].startsWith("~~~")) ? lines.length - 1 : lines.length;
+  const bodyLines = lines.slice(bodyStart, bodyEnd);
+
+  let i = 0;
+  while (i < bodyLines.length) {
+    const line = bodyLines[i];
+    const type = _classifyLine(line);
+
+    if (type === "jsdoc_start") {
+      const jsdocBlock = [line];
+      let j = i + 1;
+      while (j < bodyLines.length) {
+        jsdocBlock.push(bodyLines[j]);
+        if (_classifyLine(bodyLines[j]) === "jsdoc_end") {
+          j++;
+          break;
+        }
+        j++;
+      }
+
+      if (j < bodyLines.length && CODE_SIGNATURE_REGEX.test(bodyLines[j])) {
+        const sigLines = [bodyLines[j]];
+        const pyDocResult = _tryPyDocstring(bodyLines, j + 1);
+        if (pyDocResult.docLines.length > 0) {
+          sigLines.push(...pyDocResult.docLines);
+        }
+        const endIdx = pyDocResult.docLines.length > 0 ? pyDocResult.endIdx : j;
+
+        signatures.push({
+          signature: [...jsdocBlock, ...sigLines].join("\n").trim(),
+          line_number: j + bodyStart + 1,
+        });
+        i = endIdx + 1;
+        continue;
+      }
+
+      i = j;
+      continue;
+    }
+
+    if (type === "line_comment" || type === "hash_comment") {
+      const commentBlock = [line];
+      let j = i + 1;
+      while (j < bodyLines.length && _classifyLine(bodyLines[j]) === type) {
+        commentBlock.push(bodyLines[j]);
+        j++;
+      }
+
+      if (j < bodyLines.length && CODE_SIGNATURE_REGEX.test(bodyLines[j])) {
+        const sigLines = [bodyLines[j]];
+        const pyDocResult = _tryPyDocstring(bodyLines, j + 1);
+        if (pyDocResult.docLines.length > 0) {
+          sigLines.push(...pyDocResult.docLines);
+        }
+        const endIdx = pyDocResult.docLines.length > 0 ? pyDocResult.endIdx : j;
+
+        signatures.push({
+          signature: [...commentBlock, ...sigLines].join("\n").trim(),
+          line_number: j + bodyStart + 1,
+        });
+        i = endIdx + 1;
+        continue;
+      }
+
+      i = j;
+      continue;
+    }
+
+    if (CODE_SIGNATURE_REGEX.test(line)) {
+      const sigLines = [line];
+      const pyDocResult = _tryPyDocstring(bodyLines, i + 1);
+      if (pyDocResult.docLines.length > 0) {
+        sigLines.push(...pyDocResult.docLines);
+      }
+      const endIdx = pyDocResult.docLines.length > 0 ? pyDocResult.endIdx : i;
+
+      signatures.push({
+        signature: sigLines.join("\n").trim(),
+        line_number: i + bodyStart + 1,
+      });
+      i = endIdx + 1;
+      continue;
+    }
+
+    i++;
+  }
+
+  return signatures;
+}
+
+function _tryPyDocstring(bodyLines, startIdx) {
+  let k = startIdx;
+  while (k < bodyLines.length && bodyLines[k].trim() === "") k++;
+  if (k >= bodyLines.length) return { docLines: [], endIdx: startIdx - 1 };
+
+  const line = bodyLines[k];
+  const tripleDouble = /^\s*"""/.test(line);
+  const tripleSingle = /^\s*'''/.test(line);
+  const marker = tripleDouble ? '"""' : tripleSingle ? "'''" : null;
+  if (!marker) return { docLines: [], endIdx: startIdx - 1 };
+
+  const docLines = [line];
+  if (line.includes(marker.repeat(2)) && line.indexOf(marker) !== line.lastIndexOf(marker)) {
+    return { docLines, endIdx: k };
+  }
+
+  for (let m = k + 1; m < bodyLines.length; m++) {
+    docLines.push(bodyLines[m]);
+    if (bodyLines[m].includes(marker)) {
+      return { docLines, endIdx: m };
+    }
+  }
+  return { docLines, endIdx: k };
+}
+
+export function generateTableSummary(tableContent, breadcrumbs = "") {
+  const lines = tableContent.split("\n").filter((l) => l.trim().length > 0);
+  if (lines.length === 0) return null;
+
+  const headerLine = lines[0];
+  const columns = headerLine
+    .split("|")
+    .map((c) => c.trim())
+    .filter((c) => c.length > 0);
+
+  const separatorLine = lines[1] || "";
+  const hasSeparator = /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$/.test(separatorLine);
+  const dataLines = hasSeparator ? lines.slice(2) : lines.slice(1);
+  const rowCount = dataLines.length;
+
+  const contextPart = breadcrumbs ? ` Context: ${breadcrumbs}.` : "";
+  return `Table with columns [${columns.join(", ")}] containing ${rowCount} row${rowCount !== 1 ? "s" : ""}.${contextPart}`;
+}
+
 // 1. BIG LEVEL: Heading & Section Hierarchy Parser
 export function parseSections(markdown, docTitle = "Document") {
   const lines = markdown.split("\n");
@@ -72,7 +225,7 @@ export function extractMediumBlocks(section, sectionId, docId) {
   let blockIndex = 0;
 
   let currentLines = [];
-  let currentBlockType = "paragraph"; // 'paragraph', 'code', 'table', 'list', 'blockquote'
+  let currentBlockType = "paragraph";
 
   function pushCurrentBlock() {
     const blockContent = currentLines.join("\n").trim();
@@ -97,7 +250,6 @@ export function extractMediumBlocks(section, sectionId, docId) {
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
 
-    // Check code fence
     const fenceMatch = line.match(/^(\s*)(```|~~~)/);
     if (fenceMatch) {
       if (!inFencedCode) {
@@ -121,7 +273,6 @@ export function extractMediumBlocks(section, sectionId, docId) {
       continue;
     }
 
-    // Check table line
     const isTableLine = /^\s*\|.*\|\s*$/.test(line);
     if (isTableLine) {
       if (currentBlockType !== "table" && currentLines.length > 0) {
@@ -134,7 +285,6 @@ export function extractMediumBlocks(section, sectionId, docId) {
       pushCurrentBlock();
     }
 
-    // Check list item line
     const isListLine = /^\s*([*+-]|\d+\.)\s+/.test(line);
     if (isListLine) {
       if (currentBlockType !== "list" && currentBlockType !== "paragraph" && currentLines.length > 0) {
@@ -145,7 +295,6 @@ export function extractMediumBlocks(section, sectionId, docId) {
       continue;
     }
 
-    // Check empty line
     if (line.trim().length === 0) {
       if (currentLines.length > 0) {
         pushCurrentBlock();
@@ -169,6 +318,7 @@ export function createSmallChunks(mediumBlock, sectionId, docId) {
 
   function makeChunk(chunkText, extraMeta = {}) {
     if (!chunkText || chunkText.trim().length === 0) return;
+    const { retrieval_policy, policy_source_id, ...rest } = extraMeta;
     smallChunks.push({
       id: `${mediumBlock.id}_s${smallIdx++}`,
       medium_id: mediumBlock.id,
@@ -177,14 +327,24 @@ export function createSmallChunks(mediumBlock, sectionId, docId) {
       content: chunkText.trim(),
       breadcrumbs: mediumBlock.breadcrumbs,
       token_count: estimateTokens(chunkText),
-      ...extraMeta,
+      retrieval_policy: retrieval_policy || "micro_chunk",
+      policy_source_id: policy_source_id || null,
+      ...rest,
     });
   }
 
   // RULE FOR TABLES
   if (mediumBlock.block_type === "table") {
+    const summary = generateTableSummary(content, mediumBlock.breadcrumbs);
+    if (summary) {
+      makeChunk(summary, {
+        retrieval_policy: "table_summary",
+        policy_source_id: mediumBlock.id,
+      });
+    }
+
     if (tokenCount <= 350) {
-      makeChunk(content);
+      makeChunk(content, { retrieval_policy: "micro_chunk" });
       return smallChunks;
     }
 
@@ -205,15 +365,23 @@ export function createSmallChunks(mediumBlock, sectionId, docId) {
     for (let i = 0; i < dataLines.length; i += chunkSize) {
       const rowBatch = dataLines.slice(i, i + chunkSize);
       const tableChunkText = `${headerStr}\n${rowBatch.join("\n")}`;
-      makeChunk(tableChunkText);
+      makeChunk(tableChunkText, { retrieval_policy: "micro_chunk" });
     }
     return smallChunks;
   }
 
   // RULE FOR CODE BLOCKS
   if (mediumBlock.block_type === "code") {
+    const signatures = extractCodeSignatures(content);
+    for (const sig of signatures) {
+      makeChunk(sig.signature, {
+        retrieval_policy: "code_signature",
+        policy_source_id: mediumBlock.id,
+      });
+    }
+
     if (tokenCount <= 350) {
-      makeChunk(content);
+      makeChunk(content, { retrieval_policy: "micro_chunk" });
       return smallChunks;
     }
 
@@ -243,7 +411,7 @@ export function createSmallChunks(mediumBlock, sectionId, docId) {
 
     for (const block of astBlocks) {
       const fullChunk = fenceHeader ? `${fenceHeader}\n${block}\n${fenceFooter}` : block;
-      makeChunk(fullChunk);
+      makeChunk(fullChunk, { retrieval_policy: "micro_chunk" });
     }
     return smallChunks;
   }
@@ -265,8 +433,7 @@ export function createSmallChunks(mediumBlock, sectionId, docId) {
 
     if (currentTokens + sTokens > TARGET_WINDOW_TOKENS && currentWindow.length > 0) {
       makeChunk(currentWindow.join(" "));
-      
-      // Safe Overlap: Keep the last sentence of the previous window if available
+
       const lastSentence = currentWindow[currentWindow.length - 1];
       currentWindow = [lastSentence, sentence];
       currentTokens = estimateTokens(lastSentence) + sTokens;

package/mcp-server/ingest/pipeline.js

@@ -129,8 +129,8 @@ export async function ingestDocument({
     }
 
     const insertMicroStmt = db.prepare(`
-      INSERT INTO micro_chunks (id, section_id, doc_id, content, vector, token_count, medium_id)
-      VALUES (?, ?, ?, ?, ?, ?, ?);
+      INSERT INTO micro_chunks (id, section_id, doc_id, content, vector, token_count, medium_id, retrieval_policy, policy_source_id)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?);
     `);
     const insertFtsStmt = db.prepare(`
       INSERT INTO micro_chunks_fts (id, content, breadcrumbs)
@@ -138,7 +138,7 @@ export async function ingestDocument({
     `);
 
     for (const micro of hierarchy.microChunks) {
-      await insertMicroStmt.run(micro.id, micro.section_id, micro.doc_id, micro.content, micro.vector, micro.token_count, micro.medium_id || null);
+      await insertMicroStmt.run(micro.id, micro.section_id, micro.doc_id, micro.content, micro.vector, micro.token_count, micro.medium_id || null, micro.retrieval_policy || "micro_chunk", micro.policy_source_id || null);
       await insertFtsStmt.run(micro.id, micro.content, micro.breadcrumbs);
     }
 

package/mcp-server/preinstall.js

@@ -5,6 +5,27 @@ if (process.env.CI || process.env.CONTINUOUS_INTEGRATION || process.env.DEBIAN_F
   process.exit(0);
 }
 
+// ── Node version warning ────────────────────────────────────────────────────
+// engines.node >= 22.5.0 is set in package.json but npm only warns by default.
+// Print a loud, actionable message so the user notices before the server crashes.
+{
+  const [major, minor] = process.versions.node.split(".").map(Number);
+  if (major < 22 || (major === 22 && minor < 5)) {
+    console.error(
+      `\n` +
+      `  ⚠️  @lotargo/memory_plugin requires Node.js >= 22.5.0\n` +
+      `     Detected: Node.js ${process.versions.node}\n` +
+      `\n` +
+      `     The built-in node:sqlite module used by this plugin was\n` +
+      `     introduced in Node.js 22.5.0.  The server WILL NOT START\n` +
+      `     on your current version.\n` +
+      `\n` +
+      `     Please upgrade:  nvm install 22   (or: brew install node@22)\n`
+    );
+  }
+}
+
+
 // Only run graceful process termination during explicit global npm updates
 if (process.env.npm_config_global === "true" || process.env.MEMORY_PREINSTALL_FORCE === "true") {
   try {
@@ -13,7 +34,7 @@ if (process.env.npm_config_global === "true" || process.env.MEMORY_PREINSTALL_FO
 
     if (process.platform === "win32") {
       try {
-        const psCmd = `Get-CimInstance Win32_Process | Where-Object { ($_.CommandLine -like '*mcp-server/index.js*' -or $_.CommandLine -like '*mcp-server\\\\index.js*') -and $_.CommandLine -notlike '*install*' -and $_.ProcessId -ne ${currentPid} -and $_.ProcessId -ne ${ppid} } | ForEach-Object { Stop-Process -Id $_.ProcessId -Force }`;
+        const psCmd = `Get-CimInstance Win32_Process | Where-Object { ($_.CommandLine -like '*mcp-server/boot.js*' -or $_.CommandLine -like '*mcp-server\\\\boot.js*' -or $_.CommandLine -like '*mcp-server/index.js*' -or $_.CommandLine -like '*mcp-server\\\\index.js*') -and $_.CommandLine -notlike '*install*' -and $_.ProcessId -ne ${currentPid} -and $_.ProcessId -ne ${ppid} } | ForEach-Object { Stop-Process -Id $_.ProcessId -Force }`;
         execSync(`powershell -NoProfile -NonInteractive -Command "${psCmd}"`, { stdio: "ignore" });
       } catch {}
     } else {
@@ -30,7 +51,7 @@ if (process.env.npm_config_global === "true" || process.env.MEMORY_PREINSTALL_FO
 
           if (!pid || pid === currentPid || pid === ppid || parentPid === currentPid) continue;
 
-          const isServer = cmd.includes("mcp-server/index.js") || cmd.includes("mcp-server/index.js");
+          const isServer = cmd.includes("mcp-server/boot.js") || cmd.includes("mcp-server/index.js");
           const isInstaller = /npm|npx|yarn|pnpm|preinstall|install/i.test(cmd);
 
           if (isServer && !isInstaller) {