boost-skill-cli 1.0.349__tar.gz → 1.0.351__tar.gz

{boost_skill_cli-1.0.349 → boost_skill_cli-1.0.351}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.349
+Version: 1.0.351
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.0.349 → boost_skill_cli-1.0.351}/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.349'
-__version_tuple__ = version_tuple = (1, 0, 349)
+__version__ = version = '1.0.351'
+__version_tuple__ = version_tuple = (1, 0, 351)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.349 → boost_skill_cli-1.0.351}/boost_cli/cli.py

@@ -198,6 +198,21 @@ def _unknown(name: str) -> int:
     return 2
 
 
+def _complete_candidates(argv: List[str]) -> int:
+    """`boost __complete <words…>` — one candidate per line, for a shell.
+
+    Runs on every TAB, so it never fails loudly: core.complete swallows its own
+    errors and a traceback here would land in the line the user is typing.
+    """
+    from .core import complete
+    for candidate in complete.candidates(argv.copy(), COMMANDS):
+        print(candidate)
+    return 0
+
+
+_PLUMBING = {"__complete": _complete_candidates}
+
+
 def _dispatch(name: str, argv: List[str], soft: bool = False) -> int:
     _group, module, _summary = _BY_NAME[name]
     mod = importlib.import_module("boost_cli.commands.%s" % module)
@@ -248,6 +263,11 @@ def main(argv: List[str] | None = None) -> int:
         print_help()
         return 0
     name, rest = argv[0], argv[1:]
+    if name in _PLUMBING:
+        # Before the _BY_NAME guard (it is not a command) and before
+        # log_invocation: this runs on every TAB, and logging a line per
+        # keystroke would bury the diagnostic log in completion noise.
+        return _PLUMBING[name](rest)
     if name not in _BY_NAME:
         return _unknown(name)
     logs.log_invocation([name, *rest])

{boost_skill_cli-1.0.349 → boost_skill_cli-1.0.351}/boost_cli/commands/configuration.py

@@ -17,6 +17,7 @@ from .. import __version__, cliparse
 from ..core import (
     agents,
     catalog,
+    complete,
     config,
     frontmatter,
     gitutil,
@@ -537,33 +538,15 @@ def cmd_completions(argv) -> int:
     p.add_argument("shell", nargs="?", choices=("bash", "zsh", "fish"),
                    default=None, help="target shell (default: from $SHELL)")
     args = p.parse_args(argv)
-    from ..cli import COMMANDS
 
     shell = args.shell or Path(os.environ.get("SHELL", "")).name
     if shell not in ("bash", "zsh", "fish"):
         shell = "bash"
-
-    names = [n for n, _g, _m, _s in COMMANDS]
-    if shell == "bash":
-        lines = ["# boost bash completion",
-                 'complete -W "%s" boost' % " ".join(names)]
-        hint = "boost completions bash >> ~/.bashrc"
-    elif shell == "zsh":
-        lines = ["#compdef boost", "", "_boost() {", "  local -a _boost_commands",
-                 "  _boost_commands=("]
-        lines += ["    '%s:%s'" % (n, _sq(s)) for n, _g, _m, s in COMMANDS]
-        lines += ["  )", "  if (( CURRENT == 2 )); then",
-                  "    _describe -t commands 'boost command' _boost_commands",
-                  "  else", "    _files", "  fi", "}", "", '_boost "$@"']
-        hint = "boost completions zsh > ~/.zfunc/_boost   (with fpath+=~/.zfunc before compinit)"
-    else:
-        lines = ["# boost fish completion"]
-        lines += ["complete -c boost -n __fish_use_subcommand -a %s -d '%s'"
-                  % (n, s.replace("\\", "\\\\").replace("'", "\\'"))
-                  for n, _g, _m, s in COMMANDS]
-        hint = "boost completions fish > ~/.config/fish/completions/boost.fish"
-    print("\n".join(lines))
-    out.dim("# install: " + hint)
+    # The script is a thin shim that calls `boost __complete`; the candidate
+    # rules live in core/complete.py so all three shells share one tested
+    # implementation instead of three hand-maintained static lists.
+    print(complete.script(shell).rstrip())
+    out.dim("# install: " + complete.INSTALL_HINT[shell])
     return 0
 
 

boost_skill_cli-1.0.351/boost_cli/core/complete.py

@@ -0,0 +1,199 @@
+"""What a shell offers at TAB, decided in Python rather than in shell.
+
+WHY THIS EXISTS. `boost completions` used to emit a static list of command names
+per shell and nothing else, so `boost install <TAB>` — the single most useful
+completion a package manager has — re-offered command names in bash, offered
+local *filenames* in zsh, and offered nothing in fish. Each failed structurally:
+a bash `-W` wordlist is position-independent by definition, zsh guarded on
+`(( CURRENT == 2 ))` and fell through to `_files`, and fish registered every
+completion under `__fish_use_subcommand`.
+
+The fix is one completer here and three thin shims that call it, so the context
+rules are written once, in a language that can test them, instead of three times
+in three shell dialects that cannot share a test.
+
+TWO CONSTRAINTS SHAPE EVERYTHING BELOW.
+
+*It runs on a keystroke.* `catalog.all_entries()` measured **423 ms** for 71,655
+entries on a real install — four times over any reasonable TAB budget, before
+interpreter start. So names come from a flat cache rebuilt from the tap caches:
+the same question answered in **1.9 ms**, a 220x difference, which is what makes
+argument completion affordable at all.
+
+*It must never fail loudly.* A traceback printed into a live prompt is worse than
+no completion, so every public entry point swallows exceptions and returns
+nothing. Silence degrades; a stack trace corrupts the line the user is typing.
+"""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Callable, Dict, List, Optional, Sequence, Tuple
+
+from . import catalog, paths, registry, store
+
+# cli.COMMANDS rows: (name, group, module, summary). Typed here rather than
+# imported so `core` stays the bottom layer.
+Registry = Sequence[Tuple[str, str, str, str]]
+
+# Commands whose first argument is a catalogue item, an installed item, or a tap.
+# Anything absent completes nothing rather than guessing: a wrong candidate list
+# actively teaches the wrong thing, which is worse than an empty one.
+_CATALOG_ARG = ("install", "info", "cat", "preview", "explain", "why",
+                "distill", "adapt", "absorb")
+_INSTALLED_ARG = ("uninstall", "reinstall", "pin", "unpin", "edit", "verify")
+_TAP_ARG = ("untap",)
+
+def names_file() -> Path:
+    """Flat newline-delimited catalogue names, one per line."""
+    return paths.cache_dir() / "_names.txt"
+
+
+def _command_names(commands: Registry) -> List[str]:
+    # No hidden-name filter here: `__complete` is dispatched in cli.main()
+    # without a COMMANDS row precisely so it stays out of --help, the generated
+    # docs, the counts *and* this list. One mechanism, not two.
+    return [n for n, _g, _m, _s in commands]
+
+
+def refresh_names() -> int:
+    """Rebuild the names cache from the tap caches. Returns the count written.
+
+    Called after anything that changes the catalogue (tap, untap, update), and
+    lazily by :func:`_cached_names` when the file is missing, so a user who
+    never runs those still gets completion on their first TAB.
+    """
+    names = sorted({str(e.get("name", "")) for e in catalog.all_entries()
+                    if e.get("name")})
+    paths.ensure_dirs()
+    names_file().write_text("\n".join(names), encoding="utf-8")
+    return len(names)
+
+
+def _cached_names() -> List[str]:
+    path = names_file()
+    if not path.exists():
+        refresh_names()
+    # errors="replace" rather than a raise: a cache corrupted by a half-written
+    # file must degrade to whatever is readable, not break the prompt.
+    text = path.read_text(encoding="utf-8", errors="replace")
+    return [line for line in text.split("\n") if line]
+
+
+def _installed_names() -> List[str]:
+    return sorted(store.installed())
+
+
+def _tap_names() -> List[str]:
+    return sorted(t.name for t in registry.list_taps())
+
+
+# Long flags a command documents, read from its own parser rather than a shared
+# list — a global flag list would offer flags the command rejects.
+def _flags_for(command: str, commands: Registry) -> List[str]:
+    row = next((r for r in commands if r[0] == command), None)
+    if row is None:
+        return []
+    module = __import__("boost_cli.commands." + row[2], fromlist=["x"])
+    func = getattr(module, "cmd_" + command.replace("-", "_"), None)
+    if func is None:
+        return []
+    # The parser is built inside the command function, so there is no object to
+    # interrogate without running it. The docstring/source is the cheap,
+    # dependency-free source of truth for what it accepts.
+    import inspect
+    try:
+        src = inspect.getsource(func)
+    except (OSError, TypeError):
+        return []
+    return sorted(set(re.findall(r'"(--[a-z][a-z0-9-]*)"', src)))
+
+
+def _source_for(command: str) -> Optional[Callable[[], List[str]]]:
+    table: Dict[str, Callable[[], List[str]]] = {}
+    for name in _CATALOG_ARG:
+        table[name] = _cached_names
+    for name in _INSTALLED_ARG:
+        table[name] = _installed_names
+    for name in _TAP_ARG:
+        table[name] = _tap_names
+    return table.get(command)
+
+
+def candidates(words: List[str], commands: Registry) -> List[str]:
+    """Completions for ``words``, where the last element is the partial word.
+
+    ``words`` is the command line as the shell split it, including ``boost``
+    itself — so ``["boost", "install", "code"]`` is a user who has typed
+    ``boost install code<TAB>``.
+
+    ``commands`` is ``cli.COMMANDS``, passed in rather than imported: ``core``
+    is the bottom layer and must not reach up into ``cli`` (the import-linter
+    contract enforces it), so the registry arrives as data.
+    """
+    try:
+        if len(words) < 2:
+            return []
+        current = words[-1]
+        if len(words) == 2:                     # completing the command itself
+            return [c for c in _command_names(commands) if c.startswith(current)]
+        command = words[1]
+        if current.startswith("-"):
+            return [f for f in _flags_for(command, commands) if f.startswith(current)]
+        source = _source_for(command)
+        if source is None:
+            return []
+        return [c for c in source() if c.startswith(current)]
+    except Exception:
+        # Deliberately broad. Anything raised here would otherwise land in the
+        # middle of the line the user is typing.
+        return []
+
+
+_BASH = """# boost bash completion — delegates to `boost __complete`, so the
+# candidate rules live in Python and cannot drift from the CLI.
+_boost_complete() {
+  local IFS=$'\\n'
+  COMPREPLY=( $(boost __complete "${COMP_WORDS[@]:0:$((COMP_CWORD+1))}" 2>/dev/null) )
+}
+complete -F _boost_complete boost
+"""
+
+_ZSH = """#compdef boost
+# Delegates to `boost __complete` rather than embedding a static list, so
+# arguments complete too — the previous version fell through to _files, which
+# offered local filenames where a skill name belongs.
+_boost() {
+  local -a reply
+  # "${(@)...}" preserves the EMPTY current word. Unquoted, zsh drops it,
+  # so `boost install <TAB>` arrives as two words and completes command
+  # names instead of skills — the exact bug this rewrite is fixing.
+  reply=( ${(f)"$(boost __complete "${(@)words[1,$CURRENT]}" 2>/dev/null)"} )
+  compadd -- $reply
+}
+_boost "$@"
+"""
+
+_FISH = """# boost fish completion — delegates to `boost __complete`.
+# `-f` disables fish's filename fallback, which is what it offered previously
+# once the subcommand was typed.
+function __boost_complete
+  boost __complete (commandline -opc) (commandline -ct) 2>/dev/null
+end
+complete -c boost -f -a '(__boost_complete)'
+"""
+
+_SCRIPTS = {"bash": _BASH, "zsh": _ZSH, "fish": _FISH}
+
+
+def script(shell: str) -> str:
+    """The completion script for ``shell``. Unknown shells get bash's."""
+    return _SCRIPTS.get(shell, _BASH)
+
+
+INSTALL_HINT = {
+    "bash": "boost completions bash >> ~/.bashrc",
+    "zsh": "boost completions zsh > ~/.zfunc/_boost   "
+           "(with fpath+=~/.zfunc before compinit)",
+    "fish": "boost completions fish > ~/.config/fish/completions/boost.fish",
+}

{boost_skill_cli-1.0.349 → boost_skill_cli-1.0.351}/boost_skill_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.349
+Version: 1.0.351
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.0.349 → boost_skill_cli-1.0.351}/boost_skill_cli.egg-info/SOURCES.txt

@@ -55,6 +55,7 @@ boost_cli/core/capabilities.py
 boost_cli/core/catalog.py
 boost_cli/core/chat.py
 boost_cli/core/claude_settings.py
+boost_cli/core/complete.py
 boost_cli/core/config.py
 boost_cli/core/dense.py
 boost_cli/core/ed25519.py
@@ -211,6 +212,7 @@ docs/roadmap/items/docstring-coverage-interrogate.md
 docs/roadmap/items/doctor-checks-rules-and-workflows.md
 docs/roadmap/items/end-of-options-guard-on-git-commands.md
 docs/roadmap/items/eval-corpus-cannot-see-real-retrieval.md
+docs/roadmap/items/eval-corpus-is-96x-smaller-than-a-real-install.md
 docs/roadmap/items/extension-free-tests-core-dense-py.md
 docs/roadmap/items/extract-mcp-http-servers-out-of-configuration-py.md
 docs/roadmap/items/finish-mutation-hardening-across-core.md
@@ -495,6 +497,7 @@ tests/unit/test_cliparse.py
 tests/unit/test_codeql_analysis_key.py
 tests/unit/test_command_reference_fresh.py
 tests/unit/test_community_health_files.py
+tests/unit/test_complete.py
 tests/unit/test_config.py
 tests/unit/test_content_dedupe.py
 tests/unit/test_dedup_trust.py

{boost_skill_cli-1.0.349 → boost_skill_cli-1.0.351}/docs/roadmap/items/completions-complete-only-command-names.md

@@ -2,12 +2,12 @@
 id: completions-complete-only-command-names
 board: code
 section: dx
-status: planned
+status: shipped
 category: CLI · DX
 complexity: M
 impact: High
 wow: 4
-note: 79 command names complete; 82 flags and every argument do not
+note: arguments and flags now complete; verified in real bash and zsh, not just asserted
 order: 79
 owner:
 pr:
@@ -62,3 +62,40 @@ TAB, so the candidate path must not pay catalog-scan cost — it needs the c
 budget (target &lt;100&nbsp;ms) measured rather than assumed. And <code>__complete</code> must never
 fail loudly: a completer that prints a traceback into the user's prompt is worse than one that
 returns nothing, so it should exit 0 with empty output on any error.
+
+<b>Shipped as <code>core/complete.py</code> plus a hidden <code>boost __complete</code>, with the
+three shell scripts reduced to shims that call it.</b> Verified by driving <b>real bash and real
+zsh</b> rather than by asserting on emitted text &mdash; which is precisely the gap that let this
+survive: <code>boost install &lt;TAB&gt;</code> now offers the catalogue,
+<code>boost uninstall &lt;TAB&gt;</code> offers what is installed, <code>boost untap &lt;TAB&gt;</code>
+offers configured taps, and <code>boost search --&lt;TAB&gt;</code> offers that command's own flags
+(previously <b>zero</b> in every shell).
+
+<b>A measurement decided the architecture.</b> Completion fires on a keystroke, and
+<code>catalog.all_entries()</code> costs <b>423&nbsp;ms</b> for 71,655 entries &mdash; four times
+over the &lt;100&nbsp;ms budget this card set, before interpreter start. A flat names cache answers
+the same question in <b>1.9&nbsp;ms</b>, a <b>220&times;</b> difference, and a test asserts the
+completion path never calls <code>all_entries()</code> at all. Without that number the obvious
+implementation would have shipped a TAB that visibly stalls.
+
+<b>Driving a real shell found a bug that no unit test would have.</b> The zsh shim passed
+<code>${words[1,$CURRENT]}</code> unquoted, and zsh <em>drops an empty trailing word</em> &mdash; so
+<code>boost install &lt;TAB&gt;</code> arrived as two words and completed <em>command names</em>,
+reproducing the exact defect this card exists to fix, in the new code. <code>"${(@)...}"</code>
+preserves it. Bash never showed this because <code>"${COMP_WORDS[@]:0:…}"</code> already preserves
+empty elements. A test now pins the quoting.
+
+<b>The layering got stricter, not looser.</b> <code>completions</code> used to import
+<code>COMMANDS</code> out of <code>cli.py</code> &mdash; the single upward edge the import-linter
+contract allowlisted. The registry is now passed into <code>core.complete</code> as data, so the
+allowlist entry is <b>gone</b> and <code>boost_cli</code> has no exceptions to its
+<code>cli&nbsp;&rarr;&nbsp;commands&nbsp;&rarr;&nbsp;core</code> rule at all. <code>__complete</code>
+is deliberately <em>not</em> a row in <code>COMMANDS</code>: that list generates
+<code>docs/commands.html</code>, <code>--help</code> and the command counts, and plumbing belongs in
+none of them &mdash; so the count stays 79.
+
+<b>The old tests were replaced, not extended.</b> Four tests asserted that the bash wordlist equalled
+<code>COMMANDS</code> and that zsh emitted 79 entries. All four passed for years while the feature
+was broken, because each asked what the generator <em>printed</em> rather than what a shell would
+<em>propose</em>. The replacements pin behaviour and the shim contract.
+

boost_skill_cli-1.0.351/docs/roadmap/items/eval-corpus-is-96x-smaller-than-a-real-install.md

@@ -0,0 +1,47 @@
+---
+id: eval-corpus-is-96x-smaller-than-a-real-install
+board: code
+section: internals
+status: planned
+category: Eval · Correctness
+complexity: M
+impact: High
+wow: 4
+note: BM25 hit@1 is 0.340 on the pinned corpus and 0.040 on a real one
+order: 80
+owner:
+pr:
+title: The eval corpus is 96× smaller than a real install, and the floors describe the small one
+---
+<b>The required <code>eval</code> gate measures a catalogue almost nobody has.</b>
+<code>tests/eval/taps.txt</code> pins 20 registries resolving to <b>743</b> entries. A real install
+that has run <code>boost tap</code> a few times is far bigger &mdash; the machine this was measured
+on carries <b>71,655</b> entries across 77 taps, <b>96&times;</b> larger.
+
+<b>The gap changes the answer, not just the margin.</b> Over the same 50 natural-language golden
+queries, BM25 scores <code>hit@1</code> <b>0.340</b> on the pinned corpus (published in
+<code>#373</code>) and <b>0.040</b> on the 71,655-entry one. Both numbers are correct; they are
+measurements of different things. The targets have not gone missing &mdash; all 50 are present, and
+spot-checking puts them at rank <b>7</b>, <b>8</b>, <b>38</b> and <b>163</b> rather than rank 1.
+What changed is the number of plausible distractors competing for the top slot.
+
+<b>Why this matters more than a number moving.</b> The <code>eval</code> gate floors BM25 recall@k
+at 0.85 and passes with wide margin, which reads as &ldquo;retrieval is healthy&rdquo;. It is
+healthy <em>at 743 entries</em>. Every retrieval decision validated against that corpus &mdash;
+blend weights, pool depths, whether a reranker earns its keep &mdash; is being validated at a scale
+users leave behind after their third tap. The near-duplicate card predicted exactly this shape when
+it warned the lift may <em>shrink</em> toward 50k rather than hold; this is that warning arriving
+with a number attached.
+
+<b>What is not being proposed.</b> Not lowering the floor, and not making the corpus enormous:
+<code>ensure_eval_corpus.sh</code> already taps 20 repos over the network inside the
+<code>lint</code> job, and a 77-tap corpus would make the required gate slow and flaky. The useful
+shape is probably a <b>second, larger tier</b> &mdash; scheduled rather than required, floored on
+its own baseline &mdash; so the small corpus keeps gating every PR cheaply while the large one
+catches the scale effects the small one structurally cannot. Measuring <em>where</em> between 743
+and 71,655 the metrics fall off would tell you how large that tier needs to be, and is a smaller
+first step than building it.
+
+<b>Provenance:</b> found while running the spike in
+[[keyless-dense-tier-local-static-embeddings]], where the first sign was BM25 scoring 0.040 in a
+harness that had to be checked for a bug before the number could be believed.

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

@@ -7,7 +7,7 @@ category: Search · Retrieval
 complexity: L
 impact: High
 wow: 5
-note: semantic search with no key, no billing, no deps
+note: spike done: the perf claims were 6-22x conservative, but rerank added +0 at real scale
 order: 73
 owner:
 pr:
@@ -77,3 +77,48 @@ that holds it is a difference of more than an order of magnitude on the doc side
 the cost that makes prebuilt shards mandatory today. Worth measuring the model2vec path directly
 before committing — but the gap it claims to close is now a measured number rather than an
 estimate.
+
+<b>Spike done &mdash; the prerequisites this card set have all shipped, so the measurement it asked
+for was finally runnable.</b> It says &ldquo;do not ship before the eval and dedup items&rdquo;;
+dedup landed in <code>#370</code>, the index format in <code>#367</code>/<code>#371</code>, the
+published eval in <code>#373</code>. What follows is <code>potion-retrieval-32M</code> (MIT, 63,091
+&times; 512 F32 lookup table &mdash; confirmed a single tensor, no transformer) driven by a
+hand-written pure-stdlib loader: WordPiece &rarr; gather rows &rarr; mean-pool &rarr; L2, mmap'd,
+no numpy.
+
+<b>The two unverified performance claims were not just right, they were conservative.</b> Query
+embedding measured <b>0.16&nbsp;ms</b> against the card's <code>~1&nbsp;ms</code>. Document
+embedding measured <b>1.34&nbsp;ms</b> on a synthetic 105-token doc and <b>3.27&nbsp;ms</b> on 300
+real catalogue entries (median 61 tokens), against the card's <code>~29&nbsp;ms</code>.
+
+<b>That reverses one of this card's design arguments.</b> The doc-side cost was the reason prebuilt
+artifacts looked mandatory: &ldquo;29&nbsp;ms/doc in pure Python is ~24&nbsp;min for 50k
+single-core&rdquo;. At the measured 3.27&nbsp;ms it is <b>2.7&nbsp;min</b> &mdash; roughly the time
+a first <code>boost tap --defaults</code> already takes. Local embedding is therefore viable on the
+user's own machine, and shipped shards become a genuine optimisation rather than a requirement. (Not
+to be confused with the ONNX <code>bge-small</code> path measured at ~1.2&nbsp;s/chunk in
+<code>keyless-semantic-search-for-everyone</code>; that number stands, and the gap between them
+<em>is</em> the case for the static model.)
+
+<b>But reranking bought nothing at real scale, which is the result that matters.</b> Over the 50
+natural-language golden queries against a real <b>71,655-entry</b> catalogue, reranking BM25's
+top-200 by cosine scored <code>hit@1</code> <b>2/50</b> &mdash; identical to BM25's own
+<b>2/50</b>, a net change of <b>+0 queries</b> where this card's own statistics note says 6 net
+queries is the smallest win reaching p&lt;0.05. On two hand-checked pairs the ordering was right but
+the margin was thin (related 0.154 vs unrelated 0.097).
+
+<b>Stated limits, because this does not settle the question.</b> The document vector was built from
+<code>name + description</code> truncated to 1,500 characters, not the full body the real dense path
+indexes, so this measures a weaker representation than the one being proposed. No blend was tried
+&mdash; pure rerank, no <code>w_dense</code> &mdash; and this card explicitly asks for a held-out
+blend weight and McNemar. What it does establish is that the <em>cheap</em> version of the idea does
+not pay for itself, so the remaining work is representation and blending, not inference speed.
+
+<b>An unrelated finding fell out of it, and it is the more important one.</b> BM25 scored
+<code>hit@1</code> <b>0.040</b> here against the <b>0.340</b> published in <code>#373</code>. Both
+are correct: the published figure is measured over the pinned 6-tap eval corpus of <b>743</b>
+entries, and this run used a real 77-tap install &mdash; <b>96&times; larger</b>. Golden targets are
+all present and rank 7th, 8th, 38th, 163rd rather than 1st. The eval corpus is not a scale model of
+a real install, and the gate's floors describe a catalogue two orders of magnitude smaller than the
+one users have. Tracked separately in [[eval-corpus-is-96x-smaller-than-a-real-install]].
+