boost-skill-cli 1.0.308__tar.gz → 1.0.309__tar.gz

{boost_skill_cli-1.0.308 → boost_skill_cli-1.0.309}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.308
+Version: 1.0.309
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE
@@ -702,6 +702,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: rag
 Requires-Dist: sqlite-vec>=0.1.6; extra == "rag"
+Requires-Dist: onnxruntime>=1.17; extra == "rag"
+Requires-Dist: tokenizers>=0.15; extra == "rag"
 Provides-Extra: eval
 Requires-Dist: ranx>=0.3.20; extra == "eval"
 Requires-Dist: ragas<0.3,>=0.2; extra == "eval"

{boost_skill_cli-1.0.308 → boost_skill_cli-1.0.309}/boost_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.308'
-__version_tuple__ = version_tuple = (1, 0, 308)
+__version__ = version = '1.0.309'
+__version_tuple__ = version_tuple = (1, 0, 309)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.308 → boost_skill_cli-1.0.309}/boost_cli/commands/quality.py

@@ -412,7 +412,12 @@ def cmd_doctor(argv):
 # first missing link is ever reported, so these never chain.
 _DENSE_FIX = {
     "no-backend": "install the extra: `pip install 'boost-skill-cli[rag]'`",
-    "no-key": "set VOYAGE_API_KEY or OPENAI_API_KEY",
+    # Names the keyless remedy first: since the [rag] extra carries a local
+    # embedding model, an API key is the quality ceiling, not the entry fee.
+    # This reason now means "no key AND no local backend", which in practice is
+    # a partial install or BOOST_NO_EMBED.
+    "no-key": ("reinstall the extra: `pip install 'boost-skill-cli[rag]'` "
+               "(or set VOYAGE_API_KEY / OPENAI_API_KEY for a larger model)"),
     "no-store": "build it: `boost reindex --dense`",
     "version-changed": "rebuild it: `boost reindex --dense --force`",
     "provider-changed": "rebuild it: `boost reindex --dense --force`",

boost_skill_cli-1.0.309/boost_cli/core/embed.py

@@ -0,0 +1,270 @@
+"""Optional dense-embedding bridge for RAG Phase 2.
+
+Strategy mirrors ``core.ai``: prefer Voyage AI when ``VOYAGE_API_KEY`` is set,
+else OpenAI when ``OPENAI_API_KEY`` is set, else a **local** ONNX model when the
+``[rag]`` extra is installed, else return ``None`` so every caller degrades to
+the always-on BM25 engine. The API embeddings come over ``urllib`` — pure
+stdlib, no client library. Anthropic exposes no embeddings endpoint, hence
+Voyage (its recommended partner) and OpenAI.
+
+Why a local provider exists
+---------------------------
+Without one, dense search needed an account and a key, so in practice every
+keyless user got BM25 — and BM25 answers "my app is slow" with bioinformatics
+packages, because nothing in that query shares vocabulary with the docs. The
+vector *store* was never the gated part: vectors already live on the user's own
+machine in sqlite-vec, keyed on each tap's commit. The only API-bound step is
+turning text into vectors.
+
+That also rules out the obvious shortcut of shipping a prebuilt index instead:
+answering a query means embedding *the query*, so a downloaded index is useless
+without something local to embed with. A local model is the prerequisite, not
+an alternative.
+
+The chain order is load-bearing. Local is tried **last**, so a user who has
+configured Voyage keeps voyage-4 rather than being silently downgraded to a
+384-dim local model. And because ``dense.py`` rebuilds whenever ``model`` or
+``dim`` changes, switching providers can never mix two embedding spaces in one
+index.
+
+``BOOST_NO_EMBED=1`` is a hard kill-switch for all three, matching
+``BOOST_NO_AI``.
+"""
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+import urllib.error
+import urllib.request
+from typing import Any, List, Optional
+
+from . import nethttp
+
+VOYAGE_URL = "https://api.voyageai.com/v1/embeddings"
+OPENAI_URL = "https://api.openai.com/v1/embeddings"
+
+# model -> output dimension. Stored in the vector index so a provider/model
+# switch is detected and forces a clean rebuild instead of mixing spaces.
+# voyage-4 over voyage-3: same 1024-d default and same $/token, but the
+# voyage-4 generation carries a 200M-token complimentary allowance where
+# voyage-3 has none — so a full index build of a large corpus is free.
+VOYAGE_MODEL = "voyage-4"
+OPENAI_MODEL = "text-embedding-3-small"
+
+# The keyless path. Small on purpose: skill docs are short and keyword-dense, so
+# a 384-dim model closes most of the gap to a paid API and runs on CPU. Named
+# with its full hub id because that is what ends up recorded in the index
+# metadata — a bare "bge-small-en-v1.5" would collide with any other vendor's
+# rebuild of it, and a rebuild produces different vectors. See core.localembed
+# for the pinned revision and the (133 MB, not 30 MB) download it implies.
+LOCAL_MODEL = "BAAI/bge-small-en-v1.5"
+LOCAL_DIM = 384
+
+_DIMS = {VOYAGE_MODEL: 1024, OPENAI_MODEL: 1536, LOCAL_MODEL: LOCAL_DIM}
+
+# Cached backend class and model instance. Loading an ONNX model is expensive
+# enough that doing it per query would make the local path unusable, and the
+# import itself is retried-on-miss rather than repeated: `provider()` runs on
+# effectively every retrieval call.
+_BACKEND_MISSING = object()
+# Deliberately untyped: the backend is core.localembed, imported lazily, so
+# naming its type here would defeat the point of the lazy import.
+_backend_cache: Any = None
+_model_instance: Any = None
+
+
+def enabled() -> bool:
+    """True unless the ``BOOST_NO_EMBED`` kill-switch is set."""
+    return not os.environ.get("BOOST_NO_EMBED")
+
+
+def _load_backend():
+    """The local embedding class, or None when the ``[rag]`` extra is absent.
+
+    ``localembed`` keeps its own imports lazy for the import budget; this is the
+    seam the tests stub, so the unit suite passes with the extra uninstalled.
+    """
+    from . import localembed
+    return localembed if localembed.available() else None
+
+
+def _backend() -> Any:
+    """``_load_backend`` memoised, including the negative result."""
+    global _backend_cache
+    if _backend_cache is None:
+        _backend_cache = _load_backend() or _BACKEND_MISSING
+    return None if _backend_cache is _BACKEND_MISSING else _backend_cache
+
+
+def reset_local_cache() -> None:
+    """Drop the cached backend and model. For tests, and for a provider switch."""
+    global _backend_cache, _model_instance
+    _backend_cache = None
+    _model_instance = None
+    # Nothing to reset when the extra is absent.
+    with contextlib.suppress(Exception):
+        from . import localembed
+        localembed.reset()
+
+
+def local_available() -> bool:
+    """True when the local embedding backend can be imported."""
+    return _backend() is not None
+
+
+def provider() -> Optional[str]:
+    """The active provider, preferring a configured key, or None when nothing works.
+
+    Order matters: local comes **last** so configuring Voyage keeps voyage-4.
+    A fallback that preempted a paid key would silently downgrade every existing
+    keyed install to a smaller model.
+    """
+    if not enabled():
+        return None
+    if os.environ.get("VOYAGE_API_KEY"):
+        return "voyage"
+    if os.environ.get("OPENAI_API_KEY"):
+        return "openai"
+    if local_available():
+        return "local"
+    return None
+
+
+def available() -> bool:
+    """True when embeddings are enabled and a provider key is present."""
+    return provider() is not None
+
+
+def model() -> Optional[str]:
+    """The active provider's model name, or None when unconfigured."""
+    p = provider()
+    if p == "voyage":
+        return VOYAGE_MODEL
+    if p == "openai":
+        return OPENAI_MODEL
+    if p == "local":
+        return LOCAL_MODEL
+    return None
+
+
+def dimension() -> Optional[int]:
+    """Output vector dimension of the active model, or None when
+
+    unconfigured. Stored in the index so a model switch forces a rebuild.
+    """
+    m = model()
+    return _DIMS.get(m) if m is not None else None
+
+
+def fallback_note() -> str:
+    """The one-line hint shown when dense search degrades to BM25.
+
+    No longer asks for a key: with a local model in the ``[rag]`` extra the
+    extra alone is enough, and telling a user they need an API account when
+    they do not is worse than saying nothing.
+    """
+    if not enabled():
+        return "dense search is off (BOOST_NO_EMBED) — using the BM25 engine"
+    return ("dense search needs the `[rag]` extra — `pip install "
+            "boost-skill-cli[rag]`; using the BM25 full-content engine")
+
+
+def embed(texts: List[str], input_type: Optional[str] = None,
+          timeout: int = 60) -> Optional[List[List[float]]]:
+    """Embed a batch of texts.
+
+    Returns one vector per input, ``[]`` for an empty batch, or ``None`` when no
+    provider is configured or the call fails (so callers degrade cleanly).
+    ``input_type`` ("query"/"document") is honored by Voyage and ignored by
+    OpenAI.
+    """
+    p = provider()
+    if p is None:
+        return None
+    if not texts:
+        return []
+    if p == "local":
+        return _embed_local(texts)
+    if p == "voyage":
+        body = {"input": texts.copy(), "model": VOYAGE_MODEL}
+        if input_type:
+            body["input_type"] = input_type
+        return _vectors(_post(VOYAGE_URL, os.environ["VOYAGE_API_KEY"],
+                              body, timeout), len(texts))
+    body = {"input": texts.copy(), "model": OPENAI_MODEL}
+    return _vectors(_post(OPENAI_URL, os.environ["OPENAI_API_KEY"],
+                          body, timeout), len(texts))
+
+
+def _local_model():
+    """The loaded local model, or None if it cannot be built.
+
+    First use downloads the pinned weights and caches them under
+    ``~/.boost/cache/models``, so this can fail on a machine with no network.
+    That is a degrade, not an error: the caller floors to BM25 exactly as it
+    does when no key is set.
+    """
+    return _backend()
+
+
+def _embed_local(texts: List[str]) -> Optional[List[List[float]]]:
+    """Embed locally. None on any failure, so the caller degrades to BM25.
+
+    Validated as strictly as the API path: a short batch would misalign vectors
+    against their chunks — every hit past the gap pointing at the wrong skill —
+    and a wrong-width row would either error inside sqlite-vec or quietly
+    corrupt the space, so both are rejected rather than stored.
+    """
+    backend = _local_model()
+    if backend is None:
+        return None
+    try:
+        rows = backend.encode(texts.copy())
+    except Exception:      # inference failure degrades, never raises
+        return None
+    if rows is None or len(rows) != len(texts):
+        return None
+    out: List[List[float]] = []
+    for row in rows:
+        try:
+            vec = [float(x) for x in row]
+        except (TypeError, ValueError):
+            return None
+        if len(vec) != LOCAL_DIM:
+            return None
+        out.append(vec)
+    return out
+
+
+def _post(url: str, key: str, payload: dict, timeout: int) -> Optional[dict]:
+    data = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(url, data=data, headers={  # noqa: S310  url is a hardcoded VOYAGE_URL/OPENAI_URL constant
+        "Authorization": "Bearer %s" % key,
+        "Content-Type": "application/json",
+    })
+    try:
+        with nethttp.urlopen(req, timeout=timeout) as resp:
+            return json.loads(resp.read())
+    except (urllib.error.URLError, OSError, ValueError):
+        return None
+
+
+def _vectors(obj: Optional[dict], n: int) -> Optional[List[List[float]]]:
+    """Pull ``data[].embedding`` out of an OpenAI-shaped response.
+
+    Both Voyage and OpenAI return ``{"data": [{"embedding": [...]}, ...]}``.
+    Returns None unless exactly ``n`` numeric vectors come back.
+    """
+    if not isinstance(obj, dict):
+        return None
+    data = obj.get("data")
+    if not isinstance(data, list) or len(data) != n:
+        return None
+    out: List[List[float]] = []
+    for item in data:
+        vec = item.get("embedding") if isinstance(item, dict) else None
+        if not isinstance(vec, list) or not vec:
+            return None
+        out.append([float(x) for x in vec])
+    return out

boost_skill_cli-1.0.309/boost_cli/core/localembed.py

@@ -0,0 +1,245 @@
+"""The keyless local embedding backend: ONNX Runtime over a pinned BGE model.
+
+``core.embed`` owns the provider chain; this owns the one thing that chain was
+missing — a way to turn text into vectors with no API key. It is reached only
+through ``embed.provider() == "local"`` and, like every other optional path in
+this codebase, returns ``None`` rather than raising so the caller floors to
+BM25.
+
+Why the model is fetched rather than vendored
+---------------------------------------------
+The weights are 133 MB — far too large to ship in a wheel for a CLI whose whole
+runtime is stdlib. So they are downloaded once, on first use, and cached under
+``~/.boost/cache/models``. That download is the one part of boost that reaches
+for something big at runtime, so it is pinned the same way the toolchain lock
+is: a fixed repository *revision*, an expected byte length, and a **sha256 that
+is verified before the file is used**. A mismatch deletes the download and
+degrades rather than loading whatever arrived.
+
+(For the record, because the number circulates: the "~30 MB" figure often
+quoted for bge-small is the *quantized* rebuild third parties publish, not
+BAAI's own export. This uses the authoritative one — a signed-supply-chain
+repo has no business pulling model weights from a re-uploader to save a
+one-time download. Quantization is a later optimisation, and it changes the
+vectors, so it would need its own eval.)
+
+Pooling
+-------
+BGE is a CLS-pooled model: the sentence embedding is the first token's hidden
+state, L2-normalised — *not* a mean over tokens. Using mean pooling here would
+still produce 384 plausible-looking floats and quietly worse retrieval, which
+is the kind of bug an eval catches and a unit test does not, so the choice is
+stated here and asserted against a known-good pair in the tests.
+"""
+from __future__ import annotations
+
+import hashlib
+import shutil
+from pathlib import Path
+from typing import List, Optional
+
+from . import paths
+
+# Pinned to a revision, not a branch: `main` moving would silently change every
+# vector in every user's index, and the index only rebuilds when the *model
+# name* changes — which it would not.
+MODEL_REPO = "BAAI/bge-small-en-v1.5"
+MODEL_REV = "5c38ec7c405ec4b44b94cc5a9bb96e735b38267a"
+_BASE = "https://huggingface.co/%s/resolve/%s/" % (MODEL_REPO, MODEL_REV)
+
+# path -> (bytes, sha256). Verified after download and again on every load, so
+# a truncated or tampered cache cannot be used.
+FILES = {
+    "onnx/model.onnx": (
+        133093490,
+        "828e1496d7fabb79cfa4dcd84fa38625c0d3d21da474a00f08db0f559940cf35"),
+    "tokenizer.json": (
+        711396,
+        "d241a60d5e8f04cc1b2b3e9ef7a4921b27bf526d9f6050ab90f9267a1f9e5c66"),
+}
+
+# BGE caps at 512 tokens; longer input is truncated rather than rejected, which
+# matches how the chunker already feeds this.
+MAX_TOKENS = 512
+
+_session = None
+_tokenizer = None
+
+
+def _deps():
+    """(onnxruntime, tokenizers) or (None, None) when the extra is absent.
+
+    Imported inside the function: ``scripts/import_budget.py`` gates CLI
+    startup, and an ONNX runtime at module import would charge `boost --help`
+    for a feature it never uses.
+    """
+    try:
+        import onnxruntime
+        import tokenizers
+    except Exception:      # any import failure means "no backend"
+        return None, None
+    return onnxruntime, tokenizers
+
+
+def available() -> bool:
+    """True when the runtime and tokenizer libraries are importable."""
+    return _deps()[0] is not None
+
+
+def model_dir() -> Path:
+    """Where the pinned weights are cached, keyed by revision."""
+    return paths.cache_dir() / "models" / MODEL_REV
+
+
+def _verified(path: Path, size: int, digest: str) -> bool:
+    """True when `path` matches the pinned length and hash.
+
+    Length first because it is free and rules out the common case (a truncated
+    download) without reading 133 MB.
+    """
+    try:
+        if path.stat().st_size != size:
+            return False
+        h = hashlib.sha256()
+        with path.open("rb") as fh:
+            for block in iter(lambda: fh.read(1 << 20), b""):
+                h.update(block)
+        return h.hexdigest() == digest
+    except OSError:
+        return False
+
+
+def _fetch(rel: str, dest: Path, size: int, digest: str) -> bool:
+    """Download one pinned file. False on any failure, leaving nothing behind.
+
+    Downloads to a temporary name and only renames after the hash matches, so
+    an interrupted fetch can never be mistaken for a complete one on the next
+    run.
+    """
+    from . import nethttp
+    tmp = dest.with_suffix(dest.suffix + ".part")
+    try:
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        with nethttp.urlopen(_BASE + rel, timeout=600) as resp, \
+                tmp.open("wb") as out:
+            shutil.copyfileobj(resp, out, 1 << 20)
+    except Exception:      # network/disk failure degrades to BM25
+        tmp.unlink(missing_ok=True)
+        return False
+    if not _verified(tmp, size, digest):
+        tmp.unlink(missing_ok=True)
+        return False
+    try:
+        tmp.replace(dest)
+    except OSError:
+        tmp.unlink(missing_ok=True)
+        return False
+    return True
+
+
+def ensure_model() -> Optional[Path]:
+    """The verified model directory, downloading it once if needed, or None."""
+    root = model_dir()
+    for rel, (size, digest) in FILES.items():
+        dest = root / rel
+        if _verified(dest, size, digest):
+            continue
+        if not _fetch(rel, dest, size, digest):
+            return None
+    return root
+
+
+def _load():
+    """Build and cache the session and tokenizer. False when unavailable."""
+    global _session, _tokenizer
+    if _session is not None and _tokenizer is not None:
+        return True
+    onnxruntime, tokenizers = _deps()
+    # Both, not just the first: they are returned as a pair and a partial
+    # install (onnxruntime present, tokenizers missing) would otherwise reach
+    # `tokenizers.Tokenizer` on a None.
+    if onnxruntime is None or tokenizers is None:
+        return False
+    root = ensure_model()
+    if root is None:
+        return False
+    try:
+        opts = onnxruntime.SessionOptions()
+        # A CLI embedding a handful of chunks gains nothing from spawning a
+        # thread per core, and an unbounded pool inside a `boost search` is a
+        # surprise on a shared machine.
+        opts.intra_op_num_threads = 1
+        opts.inter_op_num_threads = 1
+        session = onnxruntime.InferenceSession(
+            str(root / "onnx/model.onnx"), opts,
+            providers=["CPUExecutionProvider"])
+        tok = tokenizers.Tokenizer.from_file(str(root / "tokenizer.json"))
+        tok.enable_truncation(max_length=MAX_TOKENS)
+        tok.enable_padding()
+    except Exception:      # a broken model degrades, never raises
+        return False
+    _session, _tokenizer = session, tok
+    return True
+
+
+def reset() -> None:
+    """Drop the cached session and tokenizer. For tests."""
+    global _session, _tokenizer
+    _session = None
+    _tokenizer = None
+
+
+def encode(texts: List[str]) -> Optional[List[List[float]]]:
+    """Embed `texts`, or None on any failure.
+
+    CLS pooling plus L2 normalisation, which is what BGE was trained for.
+    """
+    if not texts:
+        return []
+    if not _load():
+        return None
+    session, tok = _session, _tokenizer
+    if session is None or tok is None:      # unreachable after _load(); for type narrowing
+        return None
+    try:
+        encoded = tok.encode_batch(texts.copy())
+        feed = {}
+        wanted = {i.name for i in session.get_inputs()}
+        cols = {
+            "input_ids": [e.ids for e in encoded],
+            "attention_mask": [e.attention_mask for e in encoded],
+            "token_type_ids": [e.type_ids for e in encoded],
+        }
+        for name, col in cols.items():
+            if name in wanted:
+                feed[name] = _as_i64(col)
+        return cls_pool(session.run(None, feed)[0])
+    except Exception:      # inference failure degrades to BM25
+        return None
+
+
+def cls_pool(out) -> List[List[float]]:
+    """Last hidden state -> one L2-normalised CLS vector per row.
+
+    Kept pure and separate from :func:`encode` so the part that decides *what a
+    sentence embedding is* can be tested without an ONNX runtime — it is the
+    step most likely to be silently wrong, since taking the mean instead of the
+    first token still yields plausible-looking vectors of the right width.
+
+    ``out`` is (batch, tokens, hidden); ``row[0]`` is the [CLS] token.
+    """
+    return [_normalise([float(x) for x in row[0]]) for row in out]
+
+
+def _as_i64(rows):
+    """Token id matrix as the int64 array onnxruntime expects."""
+    import numpy
+    return numpy.array(rows, dtype=numpy.int64)
+
+
+def _normalise(vec: List[float]) -> List[float]:
+    """L2-normalise, leaving an all-zero vector alone rather than dividing by 0."""
+    norm = sum(x * x for x in vec) ** 0.5
+    if not norm:
+        return vec
+    return [x / norm for x in vec]

{boost_skill_cli-1.0.308 → boost_skill_cli-1.0.309}/boost_skill_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.308
+Version: 1.0.309
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE
@@ -702,6 +702,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: rag
 Requires-Dist: sqlite-vec>=0.1.6; extra == "rag"
+Requires-Dist: onnxruntime>=1.17; extra == "rag"
+Requires-Dist: tokenizers>=0.15; extra == "rag"
 Provides-Extra: eval
 Requires-Dist: ranx>=0.3.20; extra == "eval"
 Requires-Dist: ragas<0.3,>=0.2; extra == "eval"

{boost_skill_cli-1.0.308 → boost_skill_cli-1.0.309}/boost_skill_cli.egg-info/SOURCES.txt

@@ -66,6 +66,7 @@ boost_cli/core/injectscan.py
 boost_cli/core/installscan.py
 boost_cli/core/integrity.py
 boost_cli/core/journal.py
+boost_cli/core/localembed.py
 boost_cli/core/lockfile.py
 boost_cli/core/logs.py
 boost_cli/core/mcp.py
@@ -228,7 +229,7 @@ docs/roadmap/items/internal-architecture-diagrams.md
 docs/roadmap/items/invocation-pid-logging-for-crash-correlation.md
 docs/roadmap/items/journal-rotation-race-and-handle-leak.md
 docs/roadmap/items/keyless-dense-tier-local-static-embeddings.md
-docs/roadmap/items/keyless-item.md
+docs/roadmap/items/keyless-semantic-search-for-everyone.md
 docs/roadmap/items/layering-guard-import-linter.md
 docs/roadmap/items/license-compliance-scanning.md
 docs/roadmap/items/lighthouse-ci-on-the-pages-site.md
@@ -488,6 +489,7 @@ tests/unit/test_docs_pages_linked.py
 tests/unit/test_docsite_chrome.py
 tests/unit/test_ed25519.py
 tests/unit/test_embed.py
+tests/unit/test_embed_local.py
 tests/unit/test_errors_and_cli_table.py
 tests/unit/test_eval_faithfulness.py
 tests/unit/test_eval_gate.py
@@ -504,6 +506,7 @@ tests/unit/test_injectscan.py
 tests/unit/test_installscan.py
 tests/unit/test_integrity.py
 tests/unit/test_journal.py
+tests/unit/test_localembed.py
 tests/unit/test_lockfile.py
 tests/unit/test_logs.py
 tests/unit/test_marketing_counts.py

{boost_skill_cli-1.0.308 → boost_skill_cli-1.0.309}/boost_skill_cli.egg-info/requires.txt

@@ -14,3 +14,5 @@ pytest-benchmark>=4.0
 
 [rag]
 sqlite-vec>=0.1.6
+onnxruntime>=1.17
+tokenizers>=0.15

{boost_skill_cli-1.0.308 → boost_skill_cli-1.0.309}/docs/roadmap/items/keyless-dense-tier-local-static-embeddings.md

@@ -56,3 +56,12 @@ cannot go in the default wheel — the shipped runtime is 0.79 MB and every merg
 to main cuts a release, so +17.4 MB × ~24 releases/day exhausts PyPI's 10 GB
 project quota in under a month; it needs a separate, rarely-released data
 package behind an extra.
+<b>Related, and partly overtaken:</b> [[keyless-semantic-search-for-everyone]] shipped a keyless
+path using a <i>transformer</i> (BGE via ONNX Runtime, in the <code>[rag]</code> extra) while this
+item was open. That does not settle the question this card asks &mdash; a static lookup table is
+still far cheaper, and this card's discipline about not shipping a retrieval claim before the eval
+still stands. What it does change is the baseline: "keyless" is no longer the differentiator, so the
+case for a static model now rests on <b>cost</b> (~1&nbsp;ms and no runtime dependency, against a
+measured 233&nbsp;ms cold and 34&nbsp;MB of wheels) rather than on availability. Status left alone
+deliberately &mdash; this is another loop's item to own.
+