smartmemory-core 1.4.26__tar.gz → 1.4.28__tar.gz

{smartmemory_core-1.4.26 → smartmemory_core-1.4.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smartmemory-core
-Version: 1.4.26
+Version: 1.4.28
 Summary: Multi-layered AI memory system with graph databases, vector stores, and intelligent processing pipelines
 Author: SmartMemory Team
 License-Expression: AGPL-3.0-or-later
@@ -415,6 +415,16 @@ Key environment variables:
 - `REDIS_HOST`: Redis server host (default: localhost)
 - `REDIS_PORT`: Redis server port (default: 9012)
 
+**Dedicated vector domains (optional, default off):** SmartMemory can route a domain's
+embeddings into its own vector collection + embedder instead of the shared `semantic_memory`
+collection. Each flag is read at registry-build time; flip it on only after the collection is
+populated, so dev/CI never load the specialized model.
+- `SMARTMEMORY_CODE_VECTOR_NAMESPACE`: code → `semantic_code` (CodeRankEmbed, 768-dim).
+- `SMARTMEMORY_ENTERPRISE_VECTOR_NAMESPACE`: enterprise docs → `semantic_enterprise` (bge-large, 1024-dim).
+
+When a flag is on, an unscoped `search()` automatically fans out to that collection and
+RRF-merges its hits with the base results (scoped/`memory_type=` queries are unaffected).
+
 ```bash
 # Lite mode — only API key needed (optional, enables LLM extraction)
 export OPENAI_API_KEY=your-api-key-here

{smartmemory_core-1.4.26 → smartmemory_core-1.4.28}/README.md

@@ -323,6 +323,16 @@ Key environment variables:
 - `REDIS_HOST`: Redis server host (default: localhost)
 - `REDIS_PORT`: Redis server port (default: 9012)
 
+**Dedicated vector domains (optional, default off):** SmartMemory can route a domain's
+embeddings into its own vector collection + embedder instead of the shared `semantic_memory`
+collection. Each flag is read at registry-build time; flip it on only after the collection is
+populated, so dev/CI never load the specialized model.
+- `SMARTMEMORY_CODE_VECTOR_NAMESPACE`: code → `semantic_code` (CodeRankEmbed, 768-dim).
+- `SMARTMEMORY_ENTERPRISE_VECTOR_NAMESPACE`: enterprise docs → `semantic_enterprise` (bge-large, 1024-dim).
+
+When a flag is on, an unscoped `search()` automatically fans out to that collection and
+RRF-merges its hits with the base results (scoped/`memory_type=` queries are unaffected).
+
 ```bash
 # Lite mode — only API key needed (optional, enables LLM extraction)
 export OPENAI_API_KEY=your-api-key-here

smartmemory_core-1.4.28/VERSION

@@ -0,0 +1 @@
+1.4.28

{smartmemory_core-1.4.26 → smartmemory_core-1.4.28}/benchmarks/ontology_constrain_perf.py

@@ -6,15 +6,17 @@ p50 / p95 / p99 per leg + a mean delta, and asserts the no-LLM-on-stage
 invariant for ontology_constrain.
 
 Per smart-memory-docs/docs/features/ONTO-RECONCILE-1/phase-6-verification/
-design.md §Task 15 (Codex round 2 reshape):
+design.md §Task 15, as amended by CORE-ONTOLOGY-PERF-GATE-1 (2026-06-07):
 
 - 100 docs per leg (20 warmup + 80 measured); warmup discarded
 - Construction must NOT pass ontology_store= (force-enables the stage
   regardless of the flag, per smart_memory.py:234-238)
-- Mean total duration_ms is the gated metric; ≤ 5% delta passes
-- p99 reported but not gated (small-sample noise dominates)
-- Stage-level: ontology_constrain duration_ms reported; LLM tokens MUST
-  be zero on every ontology_constrain StageTrace row
+- GATED metric: ontology_constrain stage mean ≤ STAGE_BUDGET_MS (graph-bound,
+  stable). The old "mean total duration_ms delta ≤ 5%" gate was retired —
+  total ingest is LLM-network-dominated, so the cross-leg delta was flaky.
+- Total mean/delta, p99, non_llm mean, and ontology_overhead_pct are reported
+  for visibility but NOT gated (small-sample / network noise dominates them)
+- Stage-level: LLM tokens MUST be zero on every ontology_constrain StageTrace row
 
 Run standalone:
     cd smart-memory-core && python benchmarks/ontology_constrain_perf.py
@@ -35,6 +37,13 @@ from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional
 from uuid import uuid4
 
+# CORE-ONTOLOGY-PERF-GATE-1: the deterministic gate. The ontology_constrain stage is graph-bound
+# (no-LLM invariant) and empirically stable (~24–30ms across a 14× swing in total ingest
+# wall-time); the old |mean total delta| ≤ 5% gate was LLM-network-dominated and flaky. ~3× the
+# observed mean → tolerates slower hardware / warmup variance, catches a ≥3× stage regression.
+# Single source of truth — the pytest gate imports this. Dev-box budget (test is not in CI).
+STAGE_BUDGET_MS = 75.0
+
 
 # Fixed corpus — 100 short documents in the style of
 # tests/integration/golden/test_migration_roundtrip.py:21-27. Mix of
@@ -123,6 +132,10 @@ class LegStats:
                 round(self.ontology_constrain_p99, 2) if self.ontology_constrain_p99 is not None else None
             ),
             "llm_extract_mean_ms": (round(self.llm_extract_mean, 2) if self.llm_extract_mean is not None else None),
+            # CORE-ONTOLOGY-PERF-GATE-1: non-LLM (CPU/graph-bound) portion of mean ingest — the
+            # network-bound `llm_extract` cost removed. This is the stable basis for the gate;
+            # total wall-time is LLM-network-dominated and not a reliable A/B signal.
+            "non_llm_mean_ms": round(self.total_mean - (self.llm_extract_mean or 0.0), 2),
         }
 
 
@@ -260,18 +273,28 @@ def run_benchmark(*, warmup: int = 20, measured: int = 80) -> Dict[str, Any]:
     on_stats = _aggregate("on", on_raw, warmup)
     off_stats = _aggregate("off", off_raw, warmup)
 
-    # Mean total delta as a percentage of the off-leg baseline. We report
-    # the signed delta (positive = on slower than off, which is expected
-    # because the stage runs). The 5% gate is on absolute(delta).
+    # Mean total delta as a percentage of the off-leg baseline. Signed (positive = on slower than
+    # off, expected because the stage runs). CORE-ONTOLOGY-PERF-GATE-1: REPORTED ONLY, not gated —
+    # total ingest is LLM-network-dominated so this delta is flaky (the gate is on the stage mean).
     if off_stats.total_mean > 0:
         mean_delta_pct = (on_stats.total_mean - off_stats.total_mean) / off_stats.total_mean * 100.0
     else:
         mean_delta_pct = 0.0
 
+    # CORE-ONTOLOGY-PERF-GATE-1: informational ratio (NOT gated — the gate is the absolute stage
+    # mean, STAGE_BUDGET_MS). Within the ON leg, the ontology_constrain stage cost as a fraction of
+    # that leg's NON-LLM ingest work. Surfaced for context; its denominator is itself load-noisy.
+    on_non_llm = on_stats.total_mean - (on_stats.llm_extract_mean or 0.0)
+    if on_stats.ontology_constrain_mean is not None and on_non_llm > 0:
+        ontology_overhead_pct = round(on_stats.ontology_constrain_mean / on_non_llm * 100.0, 2)
+    else:
+        ontology_overhead_pct = None
+
     return {
         "on": on_stats.as_dict(),
         "off": off_stats.as_dict(),
-        "mean_delta_pct": round(mean_delta_pct, 2),
+        "mean_delta_pct": round(mean_delta_pct, 2),  # reported, not gated (LLM-network-dominated)
+        "ontology_overhead_pct": ontology_overhead_pct,  # reported, not gated (load-noisy denominator)
         "warmup": warmup,
         "measured": measured,
     }
@@ -290,10 +313,13 @@ def _format_summary(result: Dict[str, Any]) -> str:
         f"  total p95_ms        {on['total_p95_ms']:>10}    {off['total_p95_ms']:>10}\n"
         f"  total p99_ms        {on['total_p99_ms']:>10}    {off['total_p99_ms']:>10}\n"
         f"  llm_extract mean_ms {on['llm_extract_mean_ms']!s:>10}    {off['llm_extract_mean_ms']!s:>10}\n"
+        f"  non_llm mean_ms     {on['non_llm_mean_ms']!s:>10}    {off['non_llm_mean_ms']!s:>10}\n"
         f"  ontology_constrain mean_ms  {on['ontology_constrain_mean_ms']!s:>10}    (n/a)\n"
         f"  ontology_constrain p99_ms   {on['ontology_constrain_p99_ms']!s:>10}    (n/a)\n"
         f"\n"
-        f"  Mean total delta:  {result['mean_delta_pct']:+.2f}%  (gate: |delta| <= 5%)\n"
+        f"  ontology_constrain mean (GATED):  {on['ontology_constrain_mean_ms']!s} ms\n"
+        f"  ontology overhead (stage / non-LLM): {result['ontology_overhead_pct']!s}%  (reported)\n"
+        f"  Mean total delta:  {result['mean_delta_pct']:+.2f}%  (reported, NOT gated — LLM-network-dominated)\n"
     )
 
 
@@ -309,8 +335,10 @@ def main() -> int:
         print(json.dumps(result, indent=2))
     else:
         print(_format_summary(result))
-    delta = abs(result["mean_delta_pct"])
-    return 0 if delta <= 5.0 else 1
+    # CORE-ONTOLOGY-PERF-GATE-1: exit on the same deterministic gate as the pytest test — the
+    # ontology_constrain stage mean — not the LLM-network-dominated total-delta (which was flaky).
+    stage_mean = result["on"]["ontology_constrain_mean_ms"]
+    return 0 if (stage_mean is not None and stage_mean <= STAGE_BUDGET_MS) else 1
 
 
 if __name__ == "__main__":

smartmemory_core-1.4.28/scripts/backfill_canonical_marker.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""CORE-ONTOLOGY-CANONICAL-MARKER-1 — backfill the `canonical: true` marker.
+
+Stamps the write-once canonical marker onto pre-existing canonical `:OntologyType` governance
+nodes (those carrying a `status`), so the new `MERGE (t:OntologyType {name, canonical: true})`
+writer in `_create_type` matches them instead of forking a duplicate.
+
+Idempotent & re-runnable: the `t.canonical IS NULL` guard makes a second run a no-op. Facets
+(inline/pack, `status IS NULL`) and `:Concept` nodes are never touched.
+
+Usage::
+
+    python scripts/backfill_canonical_marker.py --dry-run                 # default workspace
+    python scripts/backfill_canonical_marker.py --apply --workspace acme
+    python scripts/backfill_canonical_marker.py --apply --all            # every *_ontology graph
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from smartmemory.graph.ontology_graph import OntologyGraph  # noqa: E402
+
+logger = logging.getLogger("backfill_canonical_marker")
+
+# Canonical governance nodes that still lack the marker.
+_COUNT_CYPHER = (
+    "MATCH (t:OntologyType) "
+    "WHERE NOT t:Concept AND t.status IS NOT NULL AND t.canonical IS NULL "
+    "RETURN count(t)"
+)
+_SET_CYPHER = (
+    "MATCH (t:OntologyType) "
+    "WHERE NOT t:Concept AND t.status IS NOT NULL AND t.canonical IS NULL "
+    "SET t.canonical = true "
+    "RETURN count(t)"
+)
+
+
+def _ontology_graphs(any_graph: OntologyGraph) -> list[str]:
+    """All `ws_*_ontology` graph names visible to the FalkorDB instance."""
+    try:
+        names = any_graph._get_backend().db.list_graphs()
+    except Exception as e:  # noqa: BLE001
+        logger.error("Could not list graphs for --all: %s", e)
+        return []
+    return [n for n in names if isinstance(n, str) and n.endswith("_ontology")]
+
+
+def _workspace_from_graph_name(graph_name: str) -> str:
+    # ws_{workspace_id}_ontology  ->  {workspace_id}
+    inner = graph_name[len("ws_"):] if graph_name.startswith("ws_") else graph_name
+    return inner[: -len("_ontology")] if inner.endswith("_ontology") else inner
+
+
+def backfill_workspace(workspace_id: str, *, dry_run: bool) -> int:
+    """Backfill one workspace ontology graph. Returns the number of nodes (to be) stamped."""
+    og = OntologyGraph(workspace_id=workspace_id)
+    backend = og._get_backend()
+    rows = backend.query(_COUNT_CYPHER, graph_name=og._graph_name) or [[0]]  # MIGRATION-EXEMPT
+    pending = int(rows[0][0])
+    if dry_run:
+        logger.info("[dry-run] %s: %d canonical node(s) need the marker", og._graph_name, pending)
+        return pending
+    if pending == 0:
+        logger.info("%s: nothing to backfill (already marked)", og._graph_name)
+        return 0
+    res = backend.query(_SET_CYPHER, graph_name=og._graph_name) or [[0]]  # MIGRATION-EXEMPT
+    stamped = int(res[0][0])
+    logger.info("%s: stamped canonical=true on %d node(s)", og._graph_name, stamped)
+    return stamped
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--dry-run", action="store_true", help="report counts, write nothing (default)")
+    parser.add_argument("--apply", action="store_true", help="apply the backfill")
+    parser.add_argument("--workspace", default="default", help="workspace id (default: 'default')")
+    parser.add_argument("--all", action="store_true", help="every *_ontology graph in the instance")
+    args = parser.parse_args()
+
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")
+    dry_run = not args.apply  # default to dry-run unless --apply is given
+
+    if args.all:
+        graphs = _ontology_graphs(OntologyGraph(workspace_id=args.workspace))
+        if not graphs:
+            logger.warning("--all: no *_ontology graphs found")
+            return 0
+        total = 0
+        for gname in sorted(graphs):
+            total += backfill_workspace(_workspace_from_graph_name(gname), dry_run=dry_run)
+        logger.info("%s total across %d graph(s): %d node(s)",
+                    "[dry-run] " if dry_run else "", len(graphs), total)
+    else:
+        backfill_workspace(args.workspace, dry_run=dry_run)
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{smartmemory_core-1.4.26 → smartmemory_core-1.4.28}/smartmemory/code/indexer.py

@@ -266,9 +266,10 @@ class CodeIndexer:
             result.errors.append(f"Bulk edge write failed: {e}")
 
         # Generate and store vector embeddings for all entities (CODE-DEV-2/C).
-        # Embeddings land in the same ``semantic_memory`` collection queried by
-        # ``_search_with_vector_embeddings``, so code nodes become searchable
-        # immediately without any changes to the search path.
+        # Embeddings land in the code domain's collection — resolved from the registry
+        # (CORE-VEC-DOMAINS-1): the dedicated ``semantic_code`` collection when the
+        # code-vector-namespace flag is on, else the global collection. The read path
+        # (``semantic_code_search``) resolves the same domain, so writes stay searchable.
         result.embeddings_generated = self._generate_embeddings(all_entities)
 
         # Expose parsed entities on result (used by CODE-DEV-4 pattern seeding
@@ -313,29 +314,31 @@ class CodeIndexer:
             return 0
 
         try:
-            from smartmemory.plugins.embedding import create_embeddings
             from smartmemory.stores.vector.vector_store import VectorStore
-            from smartmemory.code.constants import CODE_VECTOR_COLLECTION, code_vector_namespace_enabled
-            from smartmemory.code.embedding import code_embed, code_embedding_dimension
+            from smartmemory.domains.registry import get_registry
+            from smartmemory.code.constants import CODE_VECTOR_COLLECTION
+            from smartmemory.plugins.embedding import create_embeddings  # noqa: F401  availability probe (embed via registry)
+            from smartmemory.code.embedding import code_embed  # noqa: F401  availability probe (embed via registry)
         except ImportError as exc:
             logger.warning("Embedding dependencies unavailable, skipping embedding generation: %s", exc)
             return 0
 
-        # CODE-VEC-NAMESPACE-1: route code embeddings to the dedicated ``semantic_code``
-        # collection when the flag is on. We pass the graph's real scope provider so the
-        # vector write context (all isolation keys) matches what reads filter on — the
-        # legacy shared-collection path only stamped workspace_id, which would hide code
-        # in TENANT/USER isolation modes (Codex gate finding #2).
-        use_code_ns = code_vector_namespace_enabled()
+        # CORE-VEC-DOMAINS-1a: resolve the code domain. Collection/embedder/dimension come from the
+        # registry; the dedicated-vs-legacy SCOPE handling below is keyed off the resolved collection
+        # (dedicated ⟺ flag-on) and preserved verbatim — the dedicated path passes the graph's real
+        # scope provider so the vector write context (all isolation keys) matches what reads filter
+        # on, while the legacy path stamps workspace_id only (Codex gate finding #2, preserved).
+        code_domain = get_registry().resolve(memory_type="code")
+        is_dedicated_code = code_domain.storage.collection == CODE_VECTOR_COLLECTION
         scope_filters = self.graph.get_scope_filters()
         workspace_id = scope_filters.get("workspace_id")
 
-        if use_code_ns:
+        if is_dedicated_code:
             graph_sp = getattr(self.graph.backend, "scope_provider", None)
             vector_store = VectorStore(
-                collection_name=CODE_VECTOR_COLLECTION,
+                collection_name=code_domain.storage.collection,
                 scope_provider=graph_sp,
-                dimension=code_embedding_dimension(),
+                dimension=code_domain.storage.dimension,
             )
             # Inject the full isolation keyset via the provider when scoped; global only
             # when there is no scoping at all (OSS/Lite).
@@ -352,7 +355,7 @@ class CodeIndexer:
             if not embed_text:
                 continue
             try:
-                embedding = code_embed(embed_text, is_query=False) if use_code_ns else create_embeddings(embed_text)
+                embedding = code_domain.retrieval.embed_fn(embed_text, is_query=False)
                 if embedding is None:
                     logger.debug("No embedding returned for entity %s", entity.item_id)
                     continue
@@ -368,7 +371,7 @@ class CodeIndexer:
                     metadata["commit_hash"] = entity.commit_hash
                 # Legacy path stamps workspace_id manually; the code-namespace path lets the
                 # scope provider inject the full write context (see is_global above).
-                if not use_code_ns and workspace_id is not None:
+                if not is_dedicated_code and workspace_id is not None:
                     metadata["workspace_id"] = workspace_id
                 vector_store.upsert(
                     item_id=entity.item_id,

{smartmemory_core-1.4.26 → smartmemory_core-1.4.28}/smartmemory/code/search.py

@@ -2,8 +2,10 @@
 
 Provides intent-based search over code entities (classes, functions, modules,
 routes, tests) indexed by ``CodeIndexer``.  Embeddings are generated during
-``ingest_code()`` and stored in the shared ``semantic_memory`` vector collection
-with ``memory_type="code"`` metadata.
+``ingest_code()``. The collection/embedder are resolved from the domain registry
+(CORE-VEC-DOMAINS-1): the dedicated ``semantic_code`` collection + CodeRankEmbed when
+the code-vector-namespace flag is on, else the global collection + embedder. Hits carry
+``memory_type="code"`` metadata.
 
 Works with both FalkorDB (hosted) and usearch (Lite) backends — ``VectorStore``
 resolves the active backend via ContextVar or config.
@@ -127,20 +129,22 @@ def _lexical_code_lookup(
 
     sp = scope_provider or DefaultScopeProvider()
     filters = sp.get_isolation_filters()
-    params: dict[str, Any] = {"ql": q.lower(), "suffix": "." + q.lower()}
-    where = ["(toLower(n.name) = $ql OR toLower(n.name) ENDS WITH $suffix)"]
-    if filters.get("workspace_id"):
-        where.append("n.workspace_id = $ws")
-        params["ws"] = filters["workspace_id"]
+    # workspace_id is INLINE and unconditional in the template (``$ws IS NULL`` keeps the
+    # OSS/unscoped case correct) so the filter both scopes in WORKSPACE mode and stays visible
+    # to the SEC-TENANT-QUERIES-1 coverage scanner, which can't resolve a joined where-list.
+    params: dict[str, Any] = {"ql": q.lower(), "suffix": "." + q.lower(), "ws": filters.get("workspace_id")}
+    extra = []
     if repo:
-        where.append("n.repo = $repo")
+        extra.append("AND n.repo = $repo")
         params["repo"] = repo
     if entity_type:
-        where.append("n.entity_type = $etype")
+        extra.append("AND n.entity_type = $etype")
         params["etype"] = entity_type
+    extra_clause = (" " + " ".join(extra)) if extra else ""
 
     cypher = (
-        f"MATCH (n:Code) WHERE {' AND '.join(where)} "
+        "MATCH (n:Code) WHERE (toLower(n.name) = $ql OR toLower(n.name) ENDS WITH $suffix) "
+        "AND ($ws IS NULL OR n.workspace_id = $ws)" + extra_clause + " "
         f"RETURN n.item_id AS item_id, n.name AS name LIMIT {int(top_k)}"
     )
     try:
@@ -172,9 +176,10 @@ def semantic_code_search(
 ) -> list[dict[str, Any]]:
     """Semantic search over code entities using vector embeddings.
 
-    Generates an embedding for *query*, searches the shared vector collection,
-    post-filters to ``memory_type="code"`` results, and hydrates each hit from
-    the graph backend.
+    Generates an embedding for *query*, searches the code domain's collection
+    (resolved from the registry — dedicated ``semantic_code`` when the flag is on,
+    else the global collection), post-filters to ``memory_type="code"`` results,
+    and hydrates each hit from the graph backend.
 
     Args:
         graph: SmartGraph instance (for fetching full Code node properties).
@@ -196,21 +201,26 @@ def semantic_code_search(
         return []
 
     try:
-        from smartmemory.plugins.embedding import create_embeddings
         from smartmemory.stores.vector.vector_store import VectorStore
-        from smartmemory.code.constants import CODE_VECTOR_COLLECTION, code_vector_namespace_enabled
-        from smartmemory.code.embedding import code_embed, code_embedding_dimension
+        from smartmemory.domains.registry import get_registry
+        from smartmemory.code.constants import CODE_VECTOR_COLLECTION
+        from smartmemory.plugins.embedding import create_embeddings  # noqa: F401  availability probe (embed via registry)
+        from smartmemory.code.embedding import code_embed  # noqa: F401  availability probe (embed via registry)
     except ImportError as exc:
         logger.warning("Embedding dependencies unavailable: %s", exc)
         return []
 
-    # CODE-VEC-NAMESPACE-1: read from the dedicated ``semantic_code`` collection when the
-    # flag is on, using the code embed seam (query side) so a code-specialized embedder's
-    # query prefix (CodeRankEmbed, PROD-1) is applied. Legacy path unchanged when off.
-    use_code_ns = code_vector_namespace_enabled()
-
-    # 1. Embed the query
-    query_embedding = code_embed(query, is_query=True) if use_code_ns else create_embeddings(query)
+    # CORE-VEC-DOMAINS-1a: route via the domain registry. ``resolve(domain="code")`` returns the
+    # code domain's config — flag-on → dedicated ``semantic_code`` collection + CodeRankEmbed
+    # (query prefix applied by the embed seam, PROD-1); flag-off → the default global collection
+    # + embedder. Behavior is identical to the prior flag branch (the registry encodes the same
+    # mapping); the dedicated-collection empty warning keys off the resolved collection.
+    code_domain = get_registry().resolve(domain="code")
+    is_dedicated_code = code_domain.retrieval.collection == CODE_VECTOR_COLLECTION
+
+    # 1. Embed the query (code embedder applies the query-side prefix on is_query=True; the
+    #    default embedder ignores it). The embed seam re-imports its embedder on each call.
+    query_embedding = code_domain.retrieval.embed_fn(query, is_query=True)
     if query_embedding is None:
         logger.warning("Failed to generate query embedding for code search")
         return []
@@ -229,14 +239,13 @@ def semantic_code_search(
     # 2. Vector search — 3x oversampling for the mixed-type collection, times
     #    the rerank multiplier (via candidate_cap) so rerank has a real pool.
     sp = scope_provider or DefaultScopeProvider()
-    if use_code_ns:
-        vector_store = VectorStore(
-            collection_name=CODE_VECTOR_COLLECTION,
-            scope_provider=sp,
-            dimension=code_embedding_dimension(),
-        )
-    else:
-        vector_store = VectorStore(scope_provider=sp)
+    # flag-off: collection="semantic_memory" + dimension=None is equivalent to the prior bare
+    # VectorStore(scope_provider=sp) (config collection_name is unset → "semantic_memory").
+    vector_store = VectorStore(
+        collection_name=code_domain.retrieval.collection,
+        scope_provider=sp,
+        dimension=code_domain.retrieval.dimension,
+    )
     try:
         vector_results = vector_store.search(
             query_embedding,
@@ -250,7 +259,7 @@ def semantic_code_search(
     if not vector_results:
         # CODE-VEC-NAMESPACE-1 (A7): warn once if the flag is on but the code collection
         # looks empty — the classic "flipped the flag before running the backfill" mistake.
-        if use_code_ns and not _CODE_NS_EMPTY_WARNED:
+        if is_dedicated_code and not _CODE_NS_EMPTY_WARNED:
             _warn_code_collection_empty()
         return []