superlocalmemory 3.7.4 → 3.7.6

package/CHANGELOG.md

@@ -5,6 +5,27 @@ All notable changes to SuperLocalMemory V3 will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.7.6] - 2026-07-19 — Auth, upgrade, and embedding-dimension fixes
+
+### Fixed
+
+- Writes authenticated by the daemon capability or the dashboard install token are no longer rejected once an `api_key` file is configured. The write path ran a redundant second gate that only understood `X-SLM-API-Key`, so capability-authenticated MCP `remember` write-throughs and install-token dashboard writes / config tests returned 401 "Invalid or missing API key" whenever opt-in API-key auth was enabled. The mutation-actor gate — which already accepts the daemon capability, the install token, a matching API key, or an uncredentialed loopback caller — is now the single authoritative write boundary. (#71, #73, #74)
+- Upgrading an install across a benign migration DDL change no longer leaves the daemon permanently `not_ready`. On a `ddl_sha256` mismatch for a migration already marked complete, the runner now consults the migration's `verify()`; when the schema end-state is present it reconciles the log to the current hash instead of failing readiness. Real drift with an absent schema is still surfaced as a failure. (#70)
+- The LanceDB vector backend now follows the configured embedding dimension instead of a hardcoded 768, so custom OpenAI-compatible endpoints (for example 1024-d Qwen3-Embedding) no longer hit a vector-dimension mismatch on initialization. An existing store's on-disk width is always honored, keeping already-materialized data readable after a configuration change. (#72)
+
+### Improved
+
+- `slm setup` skips the local 768-d embedding-model download when a remote/OpenAI-compatible embedding endpoint is configured, instead of forcing an unnecessary model fetch. (#72)
+- Aligned retrieval documentation and docstrings with the shipped architecture: five parallel candidate producers (semantic, BM25, temporal, spreading-activation, Hopfield) feed single-pass RRF fusion, followed by optional cross-encoder rerank and an entity-graph post-fusion score enhancement. The entity graph is not a sixth parallel candidate producer.
+
+## [3.7.5] - 2026-07-18 — Complete Scale Engine projection parity
+
+### Improved
+
+- Scale Engine vector preparation now reads the supported sqlite-vec virtual-table contract and joins vectors through canonical embedding metadata.
+- LanceDB projection imports are profile-scoped, lifecycle-aware, and processed in bounded batches to keep migration memory stable.
+- Scale verification and fingerprints now cover the same canonical vector rows that are written to LanceDB, so a partial vector projection cannot pass parity.
+
 ## [3.7.4] - 2026-07-18 — Scale Engine projection-parity release
 
 ### Fixed

package/README.md

@@ -5,10 +5,10 @@
   </picture>
 </p>
 
-<h1 align="center">SuperLocalMemory V3.7.4</h1>
+<h1 align="center">SuperLocalMemory V3.7.5</h1>
 <p align="center"><strong>Cache. Compress. Remember. Three surfaces — proxy, MCP tools, or skill. Every setup covered.</strong><br/>
 <em>Local-first agent memory with explicit operating modes, auditable retrieval, and optional Optimize tools.</em></p>
-<p align="center"><code>v3.7.4</code> — <strong>Scale Engine projection parity: normalized logical graph edges, durable promotion recovery, and honest runtime status.</strong><br/>
+<p align="center"><code>v3.7.5</code> — <strong>Scale Engine graph and vector projection parity, durable promotion recovery, and honest runtime status.</strong><br/>
 Proxy: <code>slm wrap claude</code> &nbsp;·&nbsp; MCP: add <code>slm_compress</code> to your config &nbsp;·&nbsp; Skill: zero-config</p>
 <p align="center"><strong>3 public research preprints</strong> (arXiv + Zenodo archives) · <a href="https://arxiv.org/abs/2603.02240">arXiv:2603.02240</a> · <a href="https://arxiv.org/abs/2603.14588">arXiv:2603.14588</a> · <a href="https://arxiv.org/abs/2604.04514">arXiv:2604.04514</a></p>
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.7.4",
+  "version": "3.7.6",
   "description": "Local-first agent memory with MCP and an agent-native CLI. Documented clients include Claude Code, Cursor, and Windsurf.",
   "keywords": [
     "ai-memory",

package/plugin/.claude-plugin/plugin.json

@@ -16,5 +16,5 @@
   "mcpServers": "./.mcp.json",
   "name": "superlocalmemory",
   "repository": "https://github.com/qualixar/superlocalmemory",
-  "version": "3.7.4"
+  "version": "3.7.6"
 }

package/plugin/requirements.txt

@@ -1 +1 @@
-superlocalmemory==3.7.4
+superlocalmemory==3.7.6

package/plugin/skills/slm-recall/SKILL.md

@@ -142,9 +142,10 @@ once you have the `fact_id` for full content.
 
 ## How multi-channel retrieval works
 
-`recall` runs four channels in parallel — semantic vector similarity, lexical
-BM25, temporal recency, and structural/graph — then fuses them with Reciprocal
-Rank Fusion (RRF) and applies a reranker. The `channel_weights` field in the
+`recall` runs five candidate producers in parallel — semantic vector similarity,
+lexical BM25, temporal recency, spreading activation, and Hopfield — then fuses
+them with Reciprocal Rank Fusion (RRF), applies a reranker, and layers an
+optional entity-graph post-fusion score enhancement. The `channel_weights` field in the
 response shows how each channel contributed for that query. Weights adapt over
 time based on engagement signals attributed via `session_id`.
 

package/plugin-src/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.7.4",
+  "version": "3.7.6",
   "pluginName": "superlocalmemory",
   "displayName": "SuperLocalMemory",
   "repository": "https://github.com/qualixar/superlocalmemory",

package/plugin-src/requirements.txt

@@ -1 +1 @@
-superlocalmemory==3.7.4
+superlocalmemory==3.7.6

package/plugin-src/skills/slm-recall/SKILL.md

@@ -142,9 +142,10 @@ once you have the `fact_id` for full content.
 
 ## How multi-channel retrieval works
 
-`recall` runs four channels in parallel — semantic vector similarity, lexical
-BM25, temporal recency, and structural/graph — then fuses them with Reciprocal
-Rank Fusion (RRF) and applies a reranker. The `channel_weights` field in the
+`recall` runs five candidate producers in parallel — semantic vector similarity,
+lexical BM25, temporal recency, spreading activation, and Hopfield — then fuses
+them with Reciprocal Rank Fusion (RRF), applies a reranker, and layers an
+optional entity-graph post-fusion score enhancement. The `channel_weights` field in the
 response shows how each channel contributed for that query. Weights adapt over
 time based on engagement signals attributed via `session_id`.
 

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superlocalmemory"
-version = "3.7.4"
+version = "3.7.6"
 description = "Local-first agent memory with auditable hybrid retrieval"
 readme = "README.md"
 license = "AGPL-3.0-or-later"

package/src/superlocalmemory/__init__.py

@@ -32,7 +32,7 @@ if "OMP_NUM_THREADS" not in os.environ:
     os.environ["OMP_NUM_THREADS"] = "2"
 # ---------------------------------------------------------------------------
 
-__version__ = "3.7.4"
+__version__ = "3.7.6"
 
 _REQUIRED_VERSIONS = {
     "sentence_transformers": "5.3.0",

package/src/superlocalmemory/cli/scale_engine_cmd.py

@@ -8,6 +8,7 @@ from argparse import Namespace
 def cmd_db_scale(args: Namespace) -> int:
     from superlocalmemory.core.config import SLMConfig
     from superlocalmemory.core.scale_engine import ScaleEngineError, ScaleEngineManager
+    from superlocalmemory.storage.sqlite_vectors import CanonicalVectorError
 
     action = args.scale_action
     # Scale Engine projections are currently canonical-default-profile data.
@@ -42,7 +43,7 @@ def cmd_db_scale(args: Namespace) -> int:
             result = manager.rollback(args.backup_id)
         else:
             raise ScaleEngineError(f"unknown Scale Engine action: {action}")
-    except ScaleEngineError as exc:
+    except (ScaleEngineError, CanonicalVectorError) as exc:
         print(f"Scale Engine: {exc}")
         return 1
     print(json.dumps(result, indent=2, sort_keys=True))

package/src/superlocalmemory/cli/setup_wizard.py

@@ -22,6 +22,7 @@ import subprocess
 import sys
 import time
 from pathlib import Path
+from typing import Any
 
 
 # ---------------------------------------------------------------------------
@@ -227,6 +228,29 @@ def _download_compressor(model_name: str) -> bool:
         return False
 
 
+# ---------------------------------------------------------------------------
+# Embedding-provider detection (v3.7.6 #72)
+# ---------------------------------------------------------------------------
+
+def _embedding_is_remote(config: Any) -> bool:
+    """True when embeddings come from a remote/OpenAI-compatible endpoint.
+
+    In that case the local sentence-transformers download (768d nomic) is
+    unnecessary and would only waste bandwidth/disk (#72). Detection is by
+    provider name or the presence of a configured HTTP endpoint.
+    """
+    emb = getattr(config, "embedding", None)
+    if emb is None:
+        return False
+    provider = (getattr(emb, "provider", "") or "").strip().lower()
+    endpoint = (
+        getattr(emb, "api_endpoint", "")
+        or getattr(emb, "base_url", "")
+        or ""
+    )
+    return provider in ("openai", "openai-compatible", "remote") or bool(endpoint)
+
+
 # ---------------------------------------------------------------------------
 # Verification
 # ---------------------------------------------------------------------------
@@ -455,7 +479,17 @@ def run_wizard(auto: bool = False) -> None:
     print()
     print("─── Step 4/10: Download Embedding Model ───")
 
-    if not st_ok:
+    if _embedding_is_remote(config):
+        # v3.7.6 (#72): a remote/OpenAI-compatible embedding endpoint supplies
+        # its own vectors (any width, e.g. 1024d Qwen3-Embedding), so pulling the
+        # local 768d nomic model would be wasted bandwidth and could imply a
+        # dimension that does not match the endpoint.
+        emb = config.embedding
+        print("  ✓ Skipped — remote/OpenAI-compatible embedding endpoint configured")
+        print(f"    provider={getattr(emb, 'provider', '?')}, "
+              f"dimension={getattr(emb, 'dimension', '?')}")
+        print("    No local embedding model needed.")
+    elif not st_ok:
         print("  ⚠ Skipped (sentence-transformers not installed)")
         print("    Models will download on first use.")
     else:

package/src/superlocalmemory/core/backend_orchestrator.py

@@ -354,7 +354,12 @@ class BackendOrchestrator:
         try:
             from superlocalmemory.vector.lancedb_backend import LanceDBVectorBackend
             lance_path = self._data_dir / "lance"
-            self._lancedb = LanceDBVectorBackend(str(lance_path))
+            # v3.7.6 (#72): honor the configured embedding width instead of the
+            # hardcoded 768d, so custom endpoints (e.g. 1024d Qwen3-Embedding) work.
+            dimension = getattr(
+                getattr(self._config, "embedding", None), "dimension", None
+            )
+            self._lancedb = LanceDBVectorBackend(str(lance_path), dimension=dimension)
             self._update_status("lancedb", "not_initialized")
             logger.info("LanceDB initialized at %s", lance_path)
         except Exception as exc:

package/src/superlocalmemory/core/config.py

@@ -258,7 +258,7 @@ class RetrievalConfig:
     # Reranking (V3.3.2: ONNX backend enabled for all modes)
     # V3.4.2: Tested gte-reranker-modernbert-base (8K context) — REGRESSED
     # LoCoMo from 68.4% to 64.1%. Reverted to MiniLM-L-12-v2. The 512-token
-    # limit is acceptable because SLM's 6-channel retrieval pre-filters
+    # limit is acceptable because SLM's multi-producer retrieval pre-filters
     # relevant facts before reranking. See bench-v342-locomo.md.
     use_cross_encoder: bool = True
     cross_encoder_model: str = "cross-encoder/ms-marco-MiniLM-L-12-v2"

package/src/superlocalmemory/core/engine.py

@@ -51,8 +51,9 @@ class MemoryEngine:
     """Main orchestrator for the SuperLocalMemory V3 memory system.
 
     Wires encoding (fact extraction, entity resolution, graph building,
-    consolidation) with retrieval (4-channel search, RRF fusion,
-    reranking) and all supporting layers (trust, learning, compliance).
+    consolidation) with retrieval (five candidate producers -> RRF fusion,
+    reranking, entity-graph post-fusion enhancement) and all supporting
+    layers (trust, learning, compliance).
 
     Usage::
 

package/src/superlocalmemory/core/engine_wiring.py

@@ -500,7 +500,9 @@ def init_retrieval(
     trust_scorer: Any,
     vector_store: Any = None,
 ) -> Any:
-    """Create the RetrievalEngine with 6 channels. Returns it."""
+    """Create the RetrievalEngine — five candidate producers (semantic, BM25,
+    temporal, spreading_activation, hopfield) plus the entity graph used for
+    post-fusion score enhancement. Returns it."""
     from superlocalmemory.retrieval.engine import RetrievalEngine
     from superlocalmemory.retrieval.semantic_channel import SemanticChannel
     from superlocalmemory.retrieval.bm25_channel import BM25Channel

package/src/superlocalmemory/core/scale_engine.py

@@ -23,6 +23,12 @@ from pathlib import Path
 from typing import Any, Callable
 
 from superlocalmemory.storage.logical_edges import count_logical_edges, iter_logical_edges
+from superlocalmemory.storage.sqlite_vectors import (
+    CanonicalVectorError,
+    count_canonical_vectors,
+    iter_canonical_vectors,
+    load_sqlite_vec_extension,
+)
 
 
 class ScaleEngineError(RuntimeError):
@@ -272,6 +278,9 @@ class ScaleEngineManager:
             self.config.scale_engine_state = "prepared"
             self._save_config()
             return manifest
+        except CanonicalVectorError as exc:
+            shutil.rmtree(stage_dir, ignore_errors=True)
+            raise ScaleEngineError(f"canonical vector projection failed: {exc}") from exc
         except Exception:
             shutil.rmtree(stage_dir, ignore_errors=True)
             raise
@@ -285,6 +294,8 @@ class ScaleEngineManager:
         try:
             self._recover_interrupted_promotion()
             return self._verify(stage_id)
+        except CanonicalVectorError as exc:
+            raise ScaleEngineError(f"canonical vector projection failed: {exc}") from exc
         finally:
             self._release_lifecycle_lock(lock_path)
 
@@ -301,7 +312,9 @@ class ScaleEngineManager:
                 source_fingerprint = self._projection_fingerprint(conn, canonical)
             observed = self._observed_counts(cozo, lance)
             if manifest["source_fingerprint"] != source_fingerprint:
-                raise ScaleEngineError("canonical SQLite changed after preparation; prepare a new stage")
+                raise ScaleEngineError(
+                    "canonical SQLite changed after preparation; prepare a new stage"
+                )
             if canonical != manifest["canonical"] or observed != canonical:
                 raise ScaleEngineError(
                     f"projection parity failed: canonical={canonical}, observed={observed}"
@@ -321,6 +334,8 @@ class ScaleEngineManager:
         try:
             self._recover_interrupted_promotion()
             return self._promote(stage_id)
+        except CanonicalVectorError as exc:
+            raise ScaleEngineError(f"canonical vector projection failed: {exc}") from exc
         finally:
             self._release_lifecycle_lock(lock_path)
 
@@ -341,7 +356,9 @@ class ScaleEngineManager:
             gate.execute("BEGIN IMMEDIATE")
             canonical = self._canonical_counts(gate)
             if manifest["source_fingerprint"] != self._projection_fingerprint(gate, canonical):
-                raise ScaleEngineError("canonical SQLite changed after verification; prepare a new stage")
+                raise ScaleEngineError(
+                    "canonical SQLite changed after verification; prepare a new stage"
+                )
             self._mkdir_durable(self.backup_root)
             journal = {
                 "schema_version": self.SCHEMA_VERSION,
@@ -368,7 +385,13 @@ class ScaleEngineManager:
                 self._replace_durable(destination, source)
                 move["state"] = "complete"
                 self._write_promotion_journal(journal)
-            manifest.update({"state": "promoted", "promoted_at": _utc_now(), "backup_id": backup_dir.name})
+            manifest.update(
+                {
+                    "state": "promoted",
+                    "promoted_at": _utc_now(),
+                    "backup_id": backup_dir.name,
+                }
+            )
             self._write_manifest(stage_dir, manifest)
             self.config.scale_engine_state = "promoted"
             self.config.graph_backend = "cozo"
@@ -447,7 +470,11 @@ class ScaleEngineManager:
             journal["state"] = "committed"
             self._write_promotion_journal(journal)
             self.promotion_journal_path.unlink(missing_ok=True)
-            return {"state": "local_core", "restored_backup": backup_id, "displaced": displaced.name}
+            return {
+                "state": "local_core",
+                "restored_backup": backup_id,
+                "displaced": displaced.name,
+            }
         except Exception as exc:
             try:
                 self._recover_interrupted_promotion()
@@ -460,11 +487,20 @@ class ScaleEngineManager:
     def _real_backend_factory(self, cozo_dir: Path, lance_dir: Path) -> tuple[Any, Any]:
         from superlocalmemory.graph.cozo_backend import CozoDBGraphBackend
         from superlocalmemory.vector.lancedb_backend import LanceDBVectorBackend
-        return CozoDBGraphBackend(str(cozo_dir / "graph")), LanceDBVectorBackend(str(lance_dir))
+        # v3.7.6 (#72): promote the configured embedding width into the new
+        # LanceDB store so a 1024d (or other) custom endpoint survives promotion.
+        dimension = getattr(
+            getattr(self.config, "embedding", None), "dimension", None
+        )
+        return (
+            CozoDBGraphBackend(str(cozo_dir / "graph")),
+            LanceDBVectorBackend(str(lance_dir), dimension=dimension),
+        )
 
     def _readonly_connection(self) -> sqlite3.Connection:
         conn = sqlite3.connect(f"file:{self.db_path}?mode=ro", uri=True)
         conn.execute("PRAGMA query_only=ON")
+        load_sqlite_vec_extension(conn)
         return conn
 
     def _canonical_counts(self, conn: sqlite3.Connection) -> dict[str, int]:
@@ -473,15 +509,7 @@ class ScaleEngineManager:
             (self.profile_id,),
         ).fetchone()[0]
         edges = count_logical_edges(conn, self.profile_id)
-        try:
-            vectors = conn.execute(
-                "SELECT COUNT(*) FROM fact_embeddings_rowids fer "
-                "JOIN atomic_facts af ON af.fact_id = fer.fact_id "
-                "WHERE af.profile_id = ?",
-                (self.profile_id,),
-            ).fetchone()[0]
-        except sqlite3.OperationalError:
-            vectors = 0
+        vectors = count_canonical_vectors(conn, self.profile_id)
         return {"entities": int(nodes), "edges": int(edges), "vectors": int(vectors)}
 
     def _observed_counts(self, cozo: Any, lance: Any) -> dict[str, int]:
@@ -489,7 +517,11 @@ class ScaleEngineManager:
         vector = lance.health_check()
         if graph.get("status") != "active" or vector.get("status") != "active":
             raise ScaleEngineError(f"projection health failed: cozo={graph}, lancedb={vector}")
-        return {"entities": int(graph["entities"]), "edges": int(graph["edges"]), "vectors": int(vector["vectors"])}
+        return {
+            "entities": int(graph["entities"]),
+            "edges": int(graph["edges"]),
+            "vectors": int(vector["vectors"]),
+        }
 
     def _projection_fingerprint(
         self, conn: sqlite3.Connection, counts: dict[str, int]
@@ -498,7 +530,12 @@ class ScaleEngineManager:
         digest = hashlib.sha256()
         digest.update(json.dumps(counts, sort_keys=True).encode())
         tables = (
-            ("canonical_entities", "entity_id, canonical_name, entity_type, first_seen, last_seen, fact_count, profile_id", "entity_id"),
+            (
+                "canonical_entities",
+                "entity_id, canonical_name, entity_type, first_seen, last_seen, "
+                "fact_count, profile_id",
+                "entity_id",
+            ),
             ("atomic_facts", "fact_id, canonical_entities_json, lifecycle, profile_id", "fact_id"),
         )
         for table, columns, ordering in tables:
@@ -516,18 +553,8 @@ class ScaleEngineManager:
                 self._digest_row(digest, "graph_edges", row)
         except sqlite3.OperationalError as exc:
             raise ScaleEngineError("canonical SQLite missing required graph_edges table") from exc
-        try:
-            rows = conn.execute(
-                "SELECT fer.rowid, fer.fact_id, vec.vector FROM fact_embeddings_rowids fer "
-                "JOIN atomic_facts af ON af.fact_id = fer.fact_id "
-                "LEFT JOIN fact_embeddings_vector_chunks00 vec ON vec.rowid = fer.rowid "
-                "WHERE af.profile_id=? ORDER BY fer.rowid",
-                (self.profile_id,),
-            )
-            for row in rows:
-                self._digest_row(digest, "fact_embeddings_rowids", row)
-        except sqlite3.OperationalError:
-            pass
+        for row in iter_canonical_vectors(conn, self.profile_id):
+            self._digest_row(digest, "fact_embeddings", row)
         return digest.hexdigest()
 
     @staticmethod
@@ -576,7 +603,9 @@ class ScaleEngineManager:
 
     def _require_default_profile(self) -> None:
         if self.profile_id != "default":
-            raise ScaleEngineError("Scale Engine promotion currently supports the default profile only")
+            raise ScaleEngineError(
+                "Scale Engine promotion currently supports the default profile only"
+            )
 
     def _require_canonical_db(self) -> None:
         if not self.db_path.exists():

package/src/superlocalmemory/core/store_pipeline.py

@@ -310,7 +310,7 @@ def run_store(
     # that fact extraction may abstract away (dates, names, specifics).
     # This ensures BM25 and semantic search can always find the original text.
     # V3.3.12: Extract entities from verbatim content so entity channel + temporal
-    # channel can find it (was entities=[] which made 4/6 channels blind).
+    # channel can find it (was entities=[] which blinded the entity-graph and temporal signals).
     # V3.3.20: Stronger verbatim filter — skip greetings, filler, short phrases.
     # Verbatim facts with just "Hey! How are you?" dilute embeddings and add noise.
     _MIN_VERBATIM_WORDS = 8

package/src/superlocalmemory/hooks/before_web_hook.py

@@ -17,7 +17,7 @@ the local memories before committing to the external call.
 
 PERFORMANCE
 ===========
-Cost: ~500-800ms warm (full 4-channel recall via SLM daemon). Fires only on
+Cost: ~500-800ms warm (full recall via SLM daemon). Fires only on
 WebSearch and WebFetch (5-20× per typical session), so per-session overhead
 is ~5-15s in exchange for grounded answers. NOT suitable for UserPromptSubmit
 (too frequent — would be a perf disaster).

package/src/superlocalmemory/hooks/claude_code_hooks.py

@@ -267,7 +267,7 @@ def _hook_definitions(include_gate: bool = False) -> dict[str, list]:
     }
 
     # v3.4.43 — default PreToolUse entry: pre-web recall on WebSearch/WebFetch.
-    # Fires `slm hook before_web` which runs a 4-channel recall on the search
+    # Fires `slm hook before_web` which runs a recall on the search
     # query/URL and injects results as a system-reminder BEFORE the web call.
     # Encourages Claude to consider local memories before paying for new web
     # research. Independent of `include_gate` — this is value-add, not gating.

package/src/superlocalmemory/mcp/tools_active.py

@@ -42,12 +42,13 @@ def _sqlite_emergency_recall(
     native BM25 ranking via ``ORDER BY fts.rank``. This is the Mem0 / Letta
     industry pattern — multi-process safe via SQLite WAL mode.
 
-    Quality degraded vs full 6-channel (no semantic, no entity graph, no
+    Quality degraded vs the full recall path (no semantic, no entity graph, no
     temporal/spreading-activation/Hopfield) but still provides real BM25
     math + age gate. Returns ``degraded_mode=True`` via the caller's flag.
 
     Used ONLY when Tier-1 (full daemon recall) fails completely. Normal
-    path is full 6-channel; this is the fire-alarm.
+    path is the full five-producer fusion + entity-graph enhancement;
+    this is the fire-alarm.
     """
     import re
 
@@ -186,9 +187,11 @@ def register_active_tools(server, get_engine: Callable) -> None:
                 permanently relevant still surface). Default: 30.
                 Set to 0 to disable the age gate entirely.
 
-        Scoring: Uses 6-channel fusion (semantic + BM25 + entity_graph + temporal +
-        spreading_activation + hopfield) with Ebbinghaus exponential recency decay
-        and FSRS stability strengthening by access frequency.
+        Scoring: five candidate producers (semantic + BM25 + temporal +
+        spreading_activation + hopfield) feed RRF fusion; the entity graph then
+        applies an optional post-fusion score enhancement. Combined with
+        Ebbinghaus exponential recency decay and FSRS stability strengthening by
+        access frequency.
         """
         try:
             from superlocalmemory.hooks.rules_engine import RulesEngine
@@ -215,8 +218,9 @@ def register_active_tools(server, get_engine: Callable) -> None:
                 search_query = "recent important decisions"
 
             # 2-tier recall (industry pattern: Hindsight / Zep / Supermemory):
-            # PRIMARY: full 6-channel via daemon (semantic + BM25 + entity + temporal
-            #          + Hopfield + spreading-activation, Fisher-Rao fusion, FSRS decay).
+            # PRIMARY: full recall via daemon — five candidate producers (semantic
+            #          + BM25 + temporal + Hopfield + spreading-activation) into RRF
+            #          fusion, then entity-graph post-fusion enhancement, FSRS decay.
             #          Fast because Ollama embed model is kept warm (keep_alive=-1
             #          + eager pre-warm at daemon boot).
             # EMERGENCY: direct FTS5 BM25 (Mem0 / Letta pattern). Used ONLY when

package/src/superlocalmemory/retrieval/engine.py

@@ -2,10 +2,13 @@
 # Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
-"""SuperLocalMemory V3 — Retrieval Engine (6-Channel Orchestrator).
+"""SuperLocalMemory V3 — retrieval orchestration.
 
-6 channels -> single RRF fusion -> optional cross-encoder rerank.
-Channels: semantic, BM25, entity_graph, temporal, spreading_activation, hopfield.
+Five parallel candidate producers (semantic, BM25, temporal, spreading
+activation, and Hopfield) feed single-pass RRF fusion; optional profile hits
+can join that fusion input. The entity graph may then score and boost fused
+candidates when enabled and within the recall time budget. It is not a sixth
+parallel candidate producer. Optional cross-encoder reranking follows fusion.
 Replaces V1's broken 10-channel triple-re-fusion pipeline.
 
 Part of Qualixar | Author: Varun Pratap Bhardwaj
@@ -54,7 +57,12 @@ class EmbeddingProvider(Protocol):
 
 
 class RetrievalEngine:
-    """Six-channel retrieval orchestrator.
+    """Retrieval orchestrator: five candidate producers -> RRF fusion.
+
+    Five parallel candidate producers (semantic, BM25, temporal,
+    spreading_activation, hopfield) feed single-pass RRF fusion, followed by
+    optional cross-encoder rerank and an optional entity-graph post-fusion
+    score enhancement. Entity graph is not a sixth parallel candidate producer.
 
     Usage::
         engine = RetrievalEngine(db, config, channels, embedder)
@@ -627,10 +635,10 @@ class RetrievalEngine:
         v3.4.53: channels run in PARALLEL via ThreadPoolExecutor. Industry
         standard (EverMemOS, szl-recall, ContentPilot 2026): all channels
         are independent after embedding; running them serially wastes time
-        equal to the sum of all channel latencies. Parallel execution brings
-        total channel time from sum(semantic+bm25+entity+temporal+hopfield+sa)
-        down to max(semantic,bm25,entity,temporal,hopfield,sa) — roughly a
-        3-5x speedup for the channel phase.
+        equal to the sum of all producer latencies. When multiple producers are
+        enabled and healthy, parallel dispatch generally bounds the producer
+        phase by the slowest submitted producer, plus serial embedding and
+        result-collection overhead.
         """
         import os as _os_e
         import time as _time_e

package/src/superlocalmemory/server/recall_health.py

@@ -1,4 +1,4 @@
-"""Runtime recall-health monitor — keep the 6-channel recall path warm,
+"""Runtime recall-health monitor — keep the full recall path warm,
 detect a "warm-but-broken" embedder at runtime, and self-heal it (v3.6.8).
 
 Why this exists

package/src/superlocalmemory/server/routes/chat.py

@@ -4,7 +4,7 @@
 
 """Ask My Memory — SSE chat endpoint.
 
-Flow: query → 6-channel retrieval → format context → LLM stream → SSE
+Flow: query → full recall (five-producer fusion) → format context → LLM stream → SSE
 Mode A: No LLM, returns formatted retrieval results.
 Mode B: Ollama local streaming via /api/chat.
 Mode C: Cloud LLM streaming (OpenAI-compatible).
@@ -315,7 +315,7 @@ async def _stream_openai_compat(
 # ── Retrieval Helper ─────────────────────────────────────────────
 
 def _recall_memories(query: str, limit: int) -> list:
-    """Run 6-channel retrieval via WorkerPool (synchronous, runs in executor)."""
+    """Run full recall via WorkerPool (synchronous, runs in executor)."""
     from superlocalmemory.core.worker_pool import WorkerPool
     pool = WorkerPool.shared()
     result = pool.recall(query, limit=limit)

package/src/superlocalmemory/server/unified_daemon.py

@@ -277,7 +277,7 @@ def _emit_event(
 
 
 # v3.4.53: Limit concurrent full (non-fast) recalls. Without this, N parallel
-# /recall calls spawn N × 6-channel threads → Ollama serialises, reranker
+# /recall calls spawn N × full-recall threads → Ollama serialises, reranker
 # lock queues, and total wall time is N × single-recall-time. 3 concurrent
 # full recalls gives parallelism benefit without resource oversaturation.
 import asyncio as _asyncio
@@ -775,7 +775,7 @@ async def lifespan(application: FastAPI):
         # v3.4.52: Ensure covering indexes for SpreadingActivation queries.
         # SQLite 3.45+ streaming merge (UNION ALL + ORDER BY + LIMIT) uses
         # these to seek directly to top-K rows per subquery, avoiding a
-        # full sort.  Without them full 6-channel recall takes 7-10s on
+        # full sort.  Without them full recall takes 7-10s on
         # >1M edges (the SpreadingActivation 4-UNION query disk-sorts every
         # node's neighbor list on each call).  With them: sub-second.
         try:
@@ -835,7 +835,7 @@ async def lifespan(application: FastAPI):
                 logger.warning("Embedding warmup failed: %s", exc)
 
         def _warmup_recall():
-            """v3.4.62: Fire a full 6-channel recall after embedding warms up.
+            """v3.4.62: Fire a full recall after embedding warms up.
 
             Loads the graph_edges table (347K rows, ~100 MB) into the SQLite
             page cache. Without this, the first user query takes 15-24s because
@@ -853,7 +853,7 @@ async def lifespan(application: FastAPI):
             try:
                 t0 = _t.monotonic()
                 # Fire 2 warmup queries: one to load the graph page cache,
-                # second to warm the reranker subprocess + all 6 channels.
+                # second to warm the reranker subprocess + all producers.
                 # Without this, dashboard POST /api/search hits 11s cold.
                 for wq in ("memory recall performance", "context injection retrieval"):
                     engine.recall(wq, limit=5)
@@ -1710,7 +1710,20 @@ def _register_dashboard_routes(application: FastAPI) -> None:
                             content={"error": str(_identity_exc.detail)},
                         )
                     raise
-            if not check_api_key(headers, is_write=is_write):
+            # v3.7.6 (#71/#73/#74): require_http_mutation_actor above is the
+            # authoritative write-auth boundary — it accepts the daemon
+            # capability, the dashboard install token, a matching X-SLM-API-Key,
+            # or an uncredentialed loopback caller, and fails closed for everyone
+            # else. The legacy check_api_key gate only understands X-SLM-API-Key,
+            # so running it as a second gate 401'd write paths that stage 1 had
+            # already authorized: capability-authenticated daemon write-throughs
+            # (MCP `remember`, #71) and install-token dashboard writes / config
+            # tests (#73/#74) whenever an api_key file exists. Only fall back to
+            # check_api_key when the mutation-actor gate did not run — i.e. for
+            # non-write, non-recall requests, where it is a no-op for reads.
+            if not requires_mutation_actor and not check_api_key(
+                headers, is_write=is_write
+            ):
                 from fastapi.responses import JSONResponse
                 return JSONResponse(
                     status_code=401,

package/src/superlocalmemory/storage/migration_runner.py

@@ -298,6 +298,36 @@ def _apply_single(
         _, _, logged_hash, _, status = existing
         if status == "complete":
             if logged_hash != ddl_hash:
+                # v3.7.6 (#70): a complete migration whose logged DDL hash no
+                # longer matches the current text is only a real failure if the
+                # schema it guarantees is actually absent. Historically-benign
+                # DDL edits (e.g. M002's V3.4.21 <-> S9-W1 variants that build the
+                # identical end-state) would otherwise brick readiness forever on
+                # upgrade. Consult the migration's own verify(); if the schema is
+                # in place, reconcile the log to the current hash and treat as
+                # already-applied instead of failing the daemon into permanent
+                # not_ready. Absent/failing verify keeps the hard failure.
+                mod = _MODULES.get(migration.name)
+                verify_fn = (
+                    getattr(mod, "verify", None) if mod is not None else None
+                )
+                if verify_fn is not None:
+                    try:
+                        if verify_fn(conn):
+                            if not dry_run:
+                                try:
+                                    _upsert_log(
+                                        conn, migration.name, ddl_hash, "complete"
+                                    )
+                                except sqlite3.Error:  # pragma: no cover
+                                    pass
+                            return (
+                                "skipped",
+                                "drift reconciled via verify — schema present, "
+                                "log re-hashed to current DDL",
+                            )
+                    except sqlite3.Error:  # pragma: no cover
+                        pass
                 detail = (
                     f"DDL drift detected for {migration.name}: "
                     f"logged={logged_hash[:8]}... current={ddl_hash[:8]}..."

package/src/superlocalmemory/storage/sqlite_vectors.py

@@ -0,0 +1,169 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+
+"""Canonical sqlite-vec export contract for derived vector projections."""
+
+from __future__ import annotations
+
+import sqlite3
+from collections.abc import Iterator
+from typing import TypeAlias
+
+
+class CanonicalVectorError(RuntimeError):
+    """Canonical sqlite-vec data cannot be read without risking data loss."""
+
+
+CanonicalVector: TypeAlias = tuple[int, str, str, str, bytes]
+
+
+def load_sqlite_vec_extension(conn: sqlite3.Connection) -> None:
+    """Load sqlite-vec for this connection or fail the migration explicitly."""
+    try:
+        import sqlite_vec
+
+        conn.enable_load_extension(True)
+        sqlite_vec.load(conn)
+    except Exception as exc:
+        raise CanonicalVectorError(
+            "sqlite-vec could not be loaded; refusing to treat canonical vectors as empty"
+        ) from exc
+    finally:
+        try:
+            conn.enable_load_extension(False)
+        except (AttributeError, sqlite3.Error):
+            pass
+
+
+def count_canonical_vectors(conn: sqlite3.Connection, profile_id: str) -> int:
+    """Count profile-scoped vectors that have a canonical fact identity."""
+    if not _canonical_vector_table_exists(conn):
+        return 0
+    load_sqlite_vec_extension(conn)
+    return _validate_canonical_vector_contract(conn, profile_id)
+
+
+def iter_canonical_vectors(
+    conn: sqlite3.Connection, profile_id: str
+) -> Iterator[CanonicalVector]:
+    """Yield supported vec0 rows joined to canonical fact identity and lifecycle."""
+    if not _canonical_vector_table_exists(conn):
+        return
+    load_sqlite_vec_extension(conn)
+    _validate_canonical_vector_contract(conn, profile_id)
+    try:
+        rows = conn.execute(
+            "SELECT fe.rowid, em.fact_id, COALESCE(af.lifecycle, 'active'), "
+            "af.profile_id, fe.embedding "
+            "FROM fact_embeddings fe "
+            "JOIN embedding_metadata em ON em.vec_rowid = fe.rowid "
+            "JOIN atomic_facts af ON af.fact_id = em.fact_id "
+            "AND af.profile_id = em.profile_id "
+            "WHERE af.profile_id = ? AND fe.profile_id = af.profile_id "
+            "ORDER BY fe.rowid",
+            (profile_id,),
+        )
+        for rowid, fact_id, lifecycle, row_profile_id, blob in rows:
+            if not isinstance(blob, bytes):
+                raise CanonicalVectorError(
+                    f"canonical vector {rowid} is not a float32 blob"
+                )
+            yield int(rowid), str(fact_id), str(lifecycle), str(row_profile_id), blob
+    except sqlite3.Error as exc:
+        raise CanonicalVectorError(
+            "canonical sqlite-vec rows are unreadable; refusing a partial projection"
+        ) from exc
+
+
+def _validate_canonical_vector_contract(
+    conn: sqlite3.Connection, profile_id: str
+) -> int:
+    """Prove every profile-owned metadata row maps to one vec0 partition row."""
+    try:
+        misowned = int(
+            conn.execute(
+                "SELECT COUNT(*) FROM embedding_metadata em "
+                "LEFT JOIN atomic_facts af ON af.fact_id = em.fact_id "
+                "WHERE (em.profile_id = ? OR af.profile_id = ?) "
+                "AND (af.fact_id IS NULL OR af.profile_id <> em.profile_id)",
+                (profile_id, profile_id),
+            ).fetchone()[0]
+        )
+        expected = int(
+            conn.execute(
+                "SELECT COUNT(*) FROM embedding_metadata em "
+                "JOIN atomic_facts af ON af.fact_id = em.fact_id "
+                "AND af.profile_id = em.profile_id "
+                "WHERE af.profile_id = ?",
+                (profile_id,),
+            ).fetchone()[0]
+        )
+        mapped = int(
+            conn.execute(
+                "SELECT COUNT(*) FROM embedding_metadata em "
+                "JOIN atomic_facts af ON af.fact_id = em.fact_id "
+                "AND af.profile_id = em.profile_id "
+                "JOIN fact_embeddings fe ON fe.rowid = em.vec_rowid "
+                "AND fe.profile_id = af.profile_id "
+                "WHERE af.profile_id = ?",
+                (profile_id,),
+            ).fetchone()[0]
+        )
+    except sqlite3.Error as exc:
+        raise CanonicalVectorError(
+            "canonical vector contract is unreadable; refusing a partial projection"
+        ) from exc
+    if misowned:
+        raise CanonicalVectorError(
+            f"canonical vector ownership mismatch for {misowned} metadata row(s)"
+        )
+    if mapped != expected:
+        raise CanonicalVectorError(
+            "canonical vector mapping is incomplete: "
+            f"metadata={expected}, mapped_vec0={mapped}"
+        )
+    return expected
+
+
+def _canonical_vector_table_exists(conn: sqlite3.Connection) -> bool:
+    row = conn.execute(
+        "SELECT 1 FROM sqlite_master WHERE name='fact_embeddings' "
+        "AND type='table'"
+    ).fetchone()
+    if row is not None:
+        return True
+    metadata = conn.execute(
+        "SELECT 1 FROM sqlite_master WHERE name='embedding_metadata' "
+        "AND type='table'"
+    ).fetchone()
+    if metadata is not None:
+        try:
+            metadata_count = int(
+                conn.execute("SELECT COUNT(*) FROM embedding_metadata").fetchone()[0]
+            )
+        except sqlite3.Error as exc:
+            raise CanonicalVectorError("embedding metadata is unreadable") from exc
+        if metadata_count:
+            raise CanonicalVectorError(
+                "embedding metadata exists but fact_embeddings is missing"
+            )
+    shadow_payload = 0
+    for table in ("fact_embeddings_rowids", "fact_embeddings_vector_chunks00"):
+        exists = conn.execute(
+            "SELECT 1 FROM sqlite_master WHERE name=? AND type='table'",
+            (table,),
+        ).fetchone()
+        if exists is not None:
+            try:
+                shadow_payload += int(
+                    conn.execute(f'SELECT COUNT(*) FROM "{table}"').fetchone()[0]
+                )
+            except sqlite3.Error as exc:
+                raise CanonicalVectorError(
+                    "sqlite-vec shadow payload is unreadable"
+                ) from exc
+    if shadow_payload:
+        raise CanonicalVectorError(
+            "sqlite-vec shadow payload exists without the fact_embeddings virtual table"
+        )
+    return False

package/src/superlocalmemory/ui/js/memory-chat.js

@@ -1,6 +1,6 @@
 // SuperLocalMemory v3.4.1 — Ask My Memory Chat Interface
 // Copyright (c) 2026 Varun Pratap Bhardwaj — AGPL-3.0-or-later
-// SSE streaming chat grounded in 6-channel memory retrieval
+// SSE streaming chat grounded in multi-producer memory retrieval
 
 // ============================================================================
 // STATE
@@ -320,7 +320,7 @@ function _loadChatMode() {
                     + '<i class="bi bi-info-circle"></i> <strong>Mode A</strong> — No LLM connected.<br>'
                     + 'Chat returns raw memory retrieval results.<br>'
                     + 'For AI-powered conversation, switch to <strong>Mode B</strong> (Ollama) or <strong>Mode C</strong> (Cloud) in the <strong>Settings</strong> tab.<br>'
-                    + '<br>You can also use the <strong>Recall Lab</strong> tab for full 6-channel search.'
+                    + '<br>You can also use the <strong>Recall Lab</strong> tab for full recall search.'
                     + '</div>';
             }
         }

package/src/superlocalmemory/vector/lancedb_backend.py

@@ -20,6 +20,8 @@ import struct
 from pathlib import Path
 from typing import Any
 
+from superlocalmemory.storage.sqlite_vectors import iter_canonical_vectors
+
 logger = logging.getLogger(__name__)
 
 # Optional import
@@ -53,7 +55,11 @@ class LanceDBVectorBackend:
     # Valid tier values (F-27: validated before interpolation)
     VALID_TIERS: frozenset[str] = frozenset({"active", "warm", "cold", "archived"})
 
-    def __init__(self, db_path: str) -> None:
+    # Fallback embedding width when neither the caller nor an existing table
+    # specifies one. Matches the bundled nomic-embed-text-v1.5 model (768d).
+    DEFAULT_DIMENSION: int = 768
+
+    def __init__(self, db_path: str, dimension: int | None = None) -> None:
         if not _LANCEDB_AVAILABLE:
             raise LanceDBNotAvailable(
                 "LanceDB not installed. Run: pip install superlocalmemory[lancedb]"
@@ -61,22 +67,54 @@ class LanceDBVectorBackend:
         path = Path(db_path)
         path.mkdir(parents=True, exist_ok=True)
         self._db_path = str(path)
+        # v3.7.6 (#72): the vector width is configurable so custom embedding
+        # endpoints (e.g. Qwen3-Embedding at 1024d) no longer collide with a
+        # hardcoded 768d schema/decode. An existing table's on-disk width always
+        # wins over the requested value to keep already-materialized stores
+        # readable after a config change.
+        self._dimension = int(dimension) if dimension else self.DEFAULT_DIMENSION
         self._db = lancedb.connect(self._db_path)  # type: ignore[union-attr]
         self._table = self._open_or_create_table()
 
+    @property
+    def dimension(self) -> int:
+        """Effective vector width used for this backend's schema and decode."""
+        return self._dimension
+
     def _open_or_create_table(self):
-        """Open existing table or create empty one."""
+        """Open existing table (adopting its width) or create one at self._dimension."""
         try:
-            return self._db.open_table("embeddings")
+            table = self._db.open_table("embeddings")
         except Exception:
             import pyarrow as pa
             schema = pa.schema([
                 pa.field("fact_id", pa.string(), nullable=False),
-                pa.field("vector", pa.list_(pa.float32(), list_size=768), nullable=False),
+                pa.field(
+                    "vector",
+                    pa.list_(pa.float32(), list_size=self._dimension),
+                    nullable=False,
+                ),
                 pa.field("tier", pa.string(), nullable=False),
                 pa.field("profile_id", pa.string(), nullable=False),
             ])
             return self._db.create_table("embeddings", schema=schema)
+        # Adopt the persisted width so decode/validation matches what is stored.
+        existing = self._table_vector_width(table)
+        if existing:
+            self._dimension = existing
+        return table
+
+    @staticmethod
+    def _table_vector_width(table) -> int | None:
+        """Best-effort read of the persisted vector list width, or None."""
+        try:
+            field = table.schema.field("vector")
+            list_size = getattr(field.type, "list_size", None)
+            if isinstance(list_size, int) and list_size > 0:
+                return list_size
+        except Exception:  # pragma: no cover — schema introspection is best-effort
+            logger.debug("Could not read persisted vector width", exc_info=True)
+        return None
 
     def close(self) -> None:
         """Release this backend's native table and connection references."""
@@ -178,80 +216,49 @@ class LanceDBVectorBackend:
     ) -> int:
         """Export embeddings from sqlite-vec → LanceDB.
 
-        sqlite-vec stores vectors as raw float32 little-endian blobs
-        in fact_embeddings_vector_chunks00, with rowid mapping in
-        fact_embeddings_rowids.
+        Reads the supported vec0 virtual table and joins row IDs through
+        ``embedding_metadata``. Shadow-table layouts are sqlite-vec internals
+        and must not be treated as a stable migration API.
 
         Returns number of vectors imported.
         """
-        # Get rowid → fact_id mapping
-        row_map: dict[int, str] = {}
-        try:
-            for row in conn.execute("SELECT rowid, fact_id FROM fact_embeddings_rowids"):
-                row_map[row[0]] = row[1]
-        except sqlite3.OperationalError:
-            logger.warning("fact_embeddings_rowids not found — no vectors to import")
-            return 0
-
-        # Get tiers
-        tier_map: dict[str, str] = {}
-        profile_map: dict[str, str] = {}
-        try:
-            for row in conn.execute(
-                "SELECT fact_id, COALESCE(lifecycle, 'active'), profile_id "
-                "FROM atomic_facts WHERE profile_id = ?",
-                (profile_id,),
-            ):
-                tier_map[row[0]] = row[1]
-                profile_map[row[0]] = row[2] or "default"
-        except sqlite3.OperationalError:
-            pass
-
-        # Read vectors from sqlite-vec
-        try:
-            rows = conn.execute(
-                "SELECT rowid, vector FROM fact_embeddings_vector_chunks00"
-            ).fetchall()
-        except sqlite3.OperationalError:
-            logger.warning("fact_embeddings_vector_chunks00 not found")
-            return 0
-
-        # Reconstruct and batch import
-        data = []
-        for rowid, blob in rows:
-            fact_id = row_map.get(rowid)
-            # The rowid mapping is global, but a staged Scale Engine is
-            # explicitly profile-scoped.  Do not import a foreign profile by
-            # giving it a default tier/profile below.
-            if fact_id is None or fact_id not in profile_map:
-                continue
+        imported = 0
+        batch: list[tuple[str, list[float], str, str]] = []
+        for rowid, fact_id, tier, row_profile_id, blob in iter_canonical_vectors(
+            conn, profile_id
+        ):
             try:
                 vector = self._decode_vector_blob(blob)
             except Exception as exc:
-                logger.warning("Failed to decode vector for rowid %d: %s", rowid, exc)
-                continue
-            tier = tier_map.get(fact_id, "active")
-            data.append({
-                "fact_id": fact_id,
-                "vector": vector,
-                "tier": tier,
-                "profile_id": profile_map.get(fact_id, profile_id),
-            })
-
-        if data:
-            by_profile: dict[str, list[dict[str, Any]]] = {}
-            for item in data:
-                by_profile.setdefault(item["profile_id"], []).append(item)
-            for record_profile_id, records in by_profile.items():
-                self.add_vectors(
-                    [item["fact_id"] for item in records],
-                    [item["vector"] for item in records],
-                    [item["tier"] for item in records],
-                    record_profile_id,
-                )
-
-        logger.info("LanceDB: imported %d vectors from sqlite-vec", len(data))
-        return len(data)
+                raise LanceDBError(
+                    f"Invalid canonical vector for rowid {rowid}: {exc}"
+                ) from exc
+            batch.append((fact_id, vector, tier, row_profile_id))
+            if len(batch) >= 256:
+                imported += self._flush_import_batch(batch)
+                batch.clear()
+        if batch:
+            imported += self._flush_import_batch(batch)
+
+        logger.info("LanceDB: imported %d vectors from sqlite-vec", imported)
+        return imported
+
+    def _flush_import_batch(
+        self, batch: list[tuple[str, list[float], str, str]]
+    ) -> int:
+        """Write one bounded-memory, single-profile canonical vector batch."""
+        by_profile: dict[str, list[tuple[str, list[float], str]]] = {}
+        for fact_id, vector, tier, profile_id in batch:
+            by_profile.setdefault(profile_id, []).append((fact_id, vector, tier))
+        imported = 0
+        for profile_id, records in by_profile.items():
+            imported += self.add_vectors(
+                [item[0] for item in records],
+                [item[1] for item in records],
+                [item[2] for item in records],
+                profile_id,
+            )
+        return imported
 
     def _decode_vector_blob(self, blob: bytes) -> list[float]:
         """Decode sqlite-vec BLOB to list of floats.
@@ -259,13 +266,13 @@ class LanceDBVectorBackend:
         F-33: Validates dimension and L2 norm.
         sqlite-vec stores vectors as raw float32 little-endian bytes.
         """
-        expected_bytes = 768 * 4  # 3072
+        expected_bytes = self._dimension * 4
         if len(blob) != expected_bytes:
             raise ValueError(
                 f"Unexpected vector blob size: {len(blob)} (expected {expected_bytes})"
             )
 
-        vec = list(struct.unpack(f"{768}f", blob))
+        vec = list(struct.unpack(f"{self._dimension}f", blob))
 
         # F-33: Validate non-zero
         norm = sum(v * v for v in vec) ** 0.5