boost-skill-cli 1.2.107__tar.gz → 1.2.109__tar.gz

{boost_skill_cli-1.2.107/boost_skill_cli.egg-info → boost_skill_cli-1.2.109}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.107
+Version: 1.2.109
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0
@@ -217,8 +217,11 @@ refused rather than silently picking one.
 
 Because vectors are keyed to a registry's commit, `quickstart` **pins** each tap
 it fetches vectors for, and `boost update` skips a pinned tap rather than moving
-it out from under them (`--force` moves it anyway and drops the pin). When a tap
-does move, boost checks whether a newer shard exists for the new commit and
+it out from under them (`--force` moves it anyway and drops the pin). A pinned
+tap with *no* clone is not skipped — there is nothing to hold still, so it is
+cloned and checked out at its pin; if that pin cannot be reached the clone is
+removed rather than left on HEAD with a pin that no longer describes it, and
+`compact --reclone` follows the same rule. When a tap does move, boost checks whether a newer shard exists for the new commit and
 imports it; if none does, it says so instead of leaving stale vectors looking
 fresh. `boost search` never refreshes taps behind your back, and never checks
 the manifest either — acting on that answer means moving taps and downloading

{boost_skill_cli-1.2.107 → boost_skill_cli-1.2.109}/README.md

@@ -175,8 +175,11 @@ refused rather than silently picking one.
 
 Because vectors are keyed to a registry's commit, `quickstart` **pins** each tap
 it fetches vectors for, and `boost update` skips a pinned tap rather than moving
-it out from under them (`--force` moves it anyway and drops the pin). When a tap
-does move, boost checks whether a newer shard exists for the new commit and
+it out from under them (`--force` moves it anyway and drops the pin). A pinned
+tap with *no* clone is not skipped — there is nothing to hold still, so it is
+cloned and checked out at its pin; if that pin cannot be reached the clone is
+removed rather than left on HEAD with a pin that no longer describes it, and
+`compact --reclone` follows the same rule. When a tap does move, boost checks whether a newer shard exists for the new commit and
 imports it; if none does, it says so instead of leaving stale vectors looking
 fresh. `boost search` never refreshes taps behind your back, and never checks
 the manifest either — acting on that answer means moving taps and downloading

{boost_skill_cli-1.2.107 → boost_skill_cli-1.2.109}/boost_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.2.107'
-__version_tuple__ = version_tuple = (1, 2, 107)
+__version__ = version = '1.2.109'
+__version_tuple__ = version_tuple = (1, 2, 109)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.107 → boost_skill_cli-1.2.109}/boost_cli/commands/configuration.py

@@ -370,9 +370,26 @@ def cmd_compact(argv) -> int:
                     # other — nothing about `--reclone` consults the pin — so
                     # without this the clone silently lands on HEAD while
                     # config.json, the catalog cache and `boost taps` keep
-                    # naming the old commit. checkout_commit's own BoostError
-                    # (unresolvable pin) surfaces through the except below.
-                    gitutil.checkout_commit(tap.path, tap.pin)
+                    # naming the old commit.
+                    try:
+                        gitutil.checkout_commit(tap.path, tap.pin)
+                    except BoostError:
+                        # `--reclone` removed the clone before making this
+                        # one, so the pinned tree is already gone and there is
+                        # nothing to fall back to. Letting the `except` below
+                        # warn and carry on would leave a clone sitting on
+                        # HEAD with the old pin still recorded beside it, and
+                        # the next `update` reads `is_cloned` true plus a pin
+                        # and answers "pinned at <sha> (skipped)" — forever,
+                        # for a tree that is not on that commit. Remove it
+                        # instead: `doctor` names a tap with no clone (`! tap
+                        # <x> not cloned`, exit 1) and `update` re-clones it
+                        # back onto its pin, so the tap ends in a state
+                        # something reports and something repairs.
+                        # `registry.update` takes the same exit on the same
+                        # failure; this is the path that gets there first.
+                        util.rmtree(tap.path)
+                        raise
                 # The re-clone can change what's on disk even when the byte
                 # count doesn't (a pinned tap's tree is identical, but the
                 # cache's recorded commit and mtime are now stale either way).

{boost_skill_cli-1.2.107 → boost_skill_cli-1.2.109}/boost_cli/commands/discovery.py

@@ -573,6 +573,35 @@ def cmd_reindex(argv):
                        % (len(stats["reused"]),
                           "" if len(stats["reused"]) == 1 else "s",
                           ", ".join(stats["reindexed"]) or "none"), "muted"))
+    # The line that was missing. `boost catalog --import` restores catalogues
+    # with no repositories cloned, so every entry indexes from its frontmatter
+    # and the count above reads exactly as it does for a full corpus. Say what
+    # the index actually holds, in the share of TEXT rather than of documents —
+    # a document share reads 100% until it reads 0%.
+    #
+    # The share quoted is of the tokens THIS INDEX holds, and the sentence says
+    # so. It used to read "this index holds N% of the searchable text", which
+    # is a share of the corpus — a number nothing here can compute, because the
+    # bodies that were never read have no token count to compare against. Since
+    # a body runs about an order of magnitude longer than the metadata standing
+    # in for it, that reading overstated badly in exactly the partly-cloned case
+    # this warning exists for: a half-cloned index announced itself as 94%
+    # complete, and one unreadable file among a thousand rendered as "100.0% of
+    # the searchable text" inside a warning about missing text.
+    if stats["metadata_only"]:
+        share = rag.index_completeness() or {}
+        tokens = share.get("tokens") or 0
+        meta_tokens = share.get("metadata_only_tokens") or 0
+        # No tokens at all means nothing but metadata got as far as the index,
+        # so 100% is the honest reading rather than a division to protect.
+        meta_pct = (100.0 * meta_tokens / tokens) if tokens else 100.0
+        out.warn("%d of %d indexed items have no body text — their registries "
+                 "are not cloned here, so only their catalog metadata was "
+                 "indexed, and that metadata is %.1f%% of everything this "
+                 "index holds. Clone them with `boost update`, then re-run "
+                 "`boost reindex --force` to index their bodies."
+                 % (stats["metadata_only"], stats["docs"], meta_pct),
+                 wrap=True)
     if args.dense:
         if dense_stats is None:
             out.warn("dense index skipped — %s" % embed.fallback_note(),

{boost_skill_cli-1.2.107 → boost_skill_cli-1.2.109}/boost_cli/core/rag.py

@@ -51,7 +51,7 @@ from . import ai, catalog, config, frontmatter, gitutil, paths, registry, util
 # reach the entries spelling it that way. `build` reuses a tap only when
 # `_load_raw` returned an index, and a version mismatch returns None — so the
 # bump re-indexes every tap rather than half of them.
-INDEX_VERSION = 8
+INDEX_VERSION = 9
 ENGINE = "bm25"
 
 # Chunking defaults (documented in docs/rag-architecture.md §4).
@@ -294,23 +294,51 @@ def entry_path(entry: dict, tap_paths: dict[str, Path] | None = None
     return Path(base) / rel
 
 
-def read_body(entry: dict, tap_paths: dict[str, Path] | None = None) -> str:
-    """Return an item's searchable text: name + description + prose body.
-
-    The frontmatter is stripped (reusing ``frontmatter.parse``); the name and
-    description are prepended so short items keep keyword parity with the old
-    search. Missing files degrade to just the catalog metadata.
+def read_body_full(entry: dict, tap_paths: dict[str, Path] | None = None
+                   ) -> tuple[str, bool]:
+    """Return ``(text, has_body)`` — the searchable text, and whether it is
+    actually the item's body rather than its catalog metadata standing in.
+
+    The degradation itself is unchanged and deliberate: a tap whose clone is
+    absent still contributes its name and description, because a smaller index
+    beats no index. What was missing is that it happened *silently*.
+    ``boost catalog --import`` restores catalogues with zero repositories
+    cloned, so every entry takes this path, and the index it produces is not
+    the full-content index the ``evals`` gate floors — it is a frontmatter
+    index wearing the same file name. Measured over 3,015 real entries,
+    indexed with and then without their clones: 3,041,326 tokens against
+    182,507, or **6.0%** of the searchable text, with nothing in the output
+    saying so.
+
+    ``has_body`` is False in both degrade cases, and they are one answer on
+    purpose: whether the entry names no file or names one that cannot be read,
+    the document carries only metadata, which is the thing a caller needs to
+    know. :func:`build` counts them and :func:`index_completeness` reports the
+    share.
     """
     header = "%s\n%s" % (entry.get("name", ""), entry.get("description", ""))
     src = entry_path(entry, tap_paths)
     if src is None:
-        return header.strip()
+        return header.strip(), False
     try:
         text = src.read_text(encoding="utf-8", errors="replace")
     except OSError:
-        return header.strip()
+        return header.strip(), False
     _meta, body = frontmatter.parse(text)
-    return ("%s\n%s" % (header, body)).strip()
+    return ("%s\n%s" % (header, body)).strip(), True
+
+
+def read_body(entry: dict, tap_paths: dict[str, Path] | None = None) -> str:
+    """An item's searchable text: name + description + prose body.
+
+    The frontmatter is stripped (reusing ``frontmatter.parse``); the name and
+    description are prepended so short items keep keyword parity with the old
+    search. Missing files degrade to just the catalog metadata — ask
+    :func:`read_body_full` when you need to know that it happened. This
+    signature is load-bearing: ``dense`` and ``boost_langchain`` both call it
+    and several tests monkeypatch it.
+    """
+    return read_body_full(entry, tap_paths)[0]
 
 
 # ----------------------------------------------------------------- build
@@ -349,7 +377,7 @@ def _make_docs(entries: list[dict], tap_paths: dict[str, Path]) -> list[dict]:
     """
     docs: list[dict] = []
     for e in entries:
-        body = read_body(e, tap_paths)
+        body, has_body = read_body_full(e, tap_paths)
         # The scanner already hashed this exact text (`catalog._content_digest`
         # assembles name + description + body, the same string `read_body`
         # returns), so an entry from a current cache hands the value over. The
@@ -365,6 +393,13 @@ def _make_docs(entries: list[dict], tap_paths: dict[str, Path]) -> list[dict]:
         docs.append({
             "n": e["name"], "t": e["tap"], "f": e["skill_md"], "h": digest,
             "k": e.get("kind", "skill"),
+            # Written only when the body is MISSING, so a fully cloned corpus
+            # pays nothing for the flag — which matters on an index measured at
+            # 43.7 MB. Absence therefore means "has a body", and that reading
+            # is only safe because INDEX_VERSION moved with it: `_load_raw`
+            # rejects any other version outright, so no document written before
+            # this change can be misread as complete.
+            **({"m": 1} if not has_body else {}),
             "c": 0, "l": sum(tf.values()),
             "snip": body[:SNIP_STORE].strip(),  # windowed at retrieve time
             "tf": dict(tf),  # noqa: FURB123  tf is a defaultdict; .copy() would keep the factory
@@ -428,7 +463,7 @@ def build(entries: list[dict] | None = None, force: bool = False) -> dict:
     if old is not None and reused_safe:
         docs = _kept_docs(old, reused_safe) + docs
 
-    _save(docs, commits)
+    saved = _save(docs, commits)
     reindexed = sorted({e["tap"] for e in fresh})
     # `reindexed` names taps by their real name ("owner/repo"); `reused_safe`
     # is keyed by the safe name ("owner__repo") that `_tap_commits` uses to
@@ -446,6 +481,10 @@ def build(entries: list[dict] | None = None, force: bool = False) -> dict:
         "taps": len(commits),
         "reindexed": reindexed,
         "reused": reused,
+        # Counted over every document written, reused ones included — an
+        # incremental build that reported only what it re-indexed would say
+        # zero on the run after a bundle import.
+        "metadata_only": saved["metadata_only"],
     }
 
 
@@ -640,17 +679,38 @@ def _all_postings() -> dict[str, list[list[int]]]:
     return dict(out)  # noqa: FURB123  out is a defaultdict; .copy() would keep the factory
 
 
-def _save(docs: list[dict], commits: dict[str, str]) -> None:
+def _save(docs: list[dict], commits: dict[str, str]) -> dict:
+    """Persist the index and return the ``stats`` block it wrote.
+
+    Returning the stats rather than recomputing them in :func:`build` keeps one
+    definition of "how much of this index is real body text": the totals are
+    summed here, over the same documents that are being written.
+    """
     postings: dict[str, list[list[int]]] = defaultdict(list)
     meta_docs: list[dict] = []
     total_len = 0
+    metadata_only = 0
+    metadata_only_len = 0
     for doc_id, d in enumerate(docs):
         for term, tf in d["tf"].items():
             postings[term].append([doc_id, tf])
         total_len += d["l"]
+        # `.get`, because a document reused from the previous index carries
+        # whatever it was written with, and a hand-built one (several tests)
+        # carries nothing. Absence is "has a body" — see `_make_docs`.
+        bodyless = bool(d.get("m"))
+        if bodyless:
+            metadata_only += 1
+            metadata_only_len += d["l"]
         meta_docs.append({"n": d["n"], "t": d["t"], "f": d["f"], "k": d["k"],
                           "h": d.get("h", ""),
+                          **({"m": 1} if bodyless else {}),
                           "c": d["c"], "l": d["l"], "snip": d["snip"]})
+    stats: dict = {"docs": len(docs),
+                   "avg_len": (total_len / len(docs)) if docs else 0.0,
+                   "tokens": total_len,
+                   "metadata_only": metadata_only,
+                   "metadata_only_tokens": metadata_only_len}
     payload = {
         "version": INDEX_VERSION,
         "engine": ENGINE,
@@ -658,8 +718,7 @@ def _save(docs: list[dict], commits: dict[str, str]) -> None:
         "commits": commits,
         "params": {"chunk_chars": CHUNK_CHARS, "overlap": OVERLAP,
                    "k1": K1, "b": B},
-        "stats": {"docs": len(docs),
-                  "avg_len": (total_len / len(docs)) if docs else 0.0},
+        "stats": stats,
         "docs": meta_docs,
     }
     paths.ensure_dirs()
@@ -671,6 +730,7 @@ def _save(docs: list[dict], commits: dict[str, str]) -> None:
     # Drop the mtime-keyed cache so a reindex is visible to an immediately
     # following query even when the filesystem mtime granularity is coarse.
     _CACHE.pop(str(p), None)
+    return stats
 
 
 def _now() -> str:
@@ -718,6 +778,54 @@ def ready() -> bool:
     return bool(raw and raw.get("docs") and postings_path().exists())
 
 
+def index_completeness() -> dict | None:
+    """How much of the index on disk is the corpus, and how much is its labels.
+
+    Returns ``None`` when there is no readable index — the same answer
+    :func:`_load_raw` gives, rather than a zeroed dict, because "no index" and
+    "an index carrying no bodies" are different situations with different
+    remedies and must not render alike.
+
+    ``body_share`` is a share of **tokens**, not of documents, and that is the
+    whole point. An entry whose body is missing still produces a document, so a
+    document share sits at 1.0 until the moment it drops to 0.0 and tells a
+    partially-cloned machine nothing.
+
+    It describes **this index**, not the corpus behind it: the fraction of the
+    tokens actually indexed that came from a document carrying a body. The
+    share of the *corpus's* text that made it in is a different number, and it
+    is not computable here — the bodies that were never read have no token
+    count to compare against, by construction. An earlier version of this
+    docstring claimed the value "reproduces the measurement the roadmap card
+    made by hand ... or 6.0% of the searchable text". It does not: for that
+    input every token indexed came from metadata, so it returns **0.0**. The
+    two move in opposite directions, and because a body runs about an order of
+    magnitude longer than the metadata standing in for it, presenting this as
+    corpus completeness overstates a half-cloned machine badly. Callers must
+    say which share they are quoting; :func:`cmd_reindex` quotes
+    ``metadata_only_tokens / tokens`` and names it.
+
+    Reads the persisted totals rather than re-deriving them, so asking is a
+    stat plus a cached parse — nothing walks the corpus.
+    """
+    raw = _load_raw()
+    if raw is None:
+        return None
+    stats = raw.get("stats") or {}
+    tokens = int(stats.get("tokens") or 0)
+    metadata_only_tokens = int(stats.get("metadata_only_tokens") or 0)
+    return {
+        "docs": int(stats.get("docs") or 0),
+        "metadata_only": int(stats.get("metadata_only") or 0),
+        "tokens": tokens,
+        "metadata_only_tokens": metadata_only_tokens,
+        # Guarded on `tokens`, not on `docs`: an index of documents that all
+        # tokenized to nothing would divide by zero, and 0.0 is the honest
+        # answer there — no body text is present.
+        "body_share": (1.0 - metadata_only_tokens / tokens) if tokens else 0.0,
+    }
+
+
 def stale() -> bool:
     """True when the index no longer reflects the taps on disk.
 

{boost_skill_cli-1.2.107 → boost_skill_cli-1.2.109/boost_skill_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.107
+Version: 1.2.109
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0
@@ -217,8 +217,11 @@ refused rather than silently picking one.
 
 Because vectors are keyed to a registry's commit, `quickstart` **pins** each tap
 it fetches vectors for, and `boost update` skips a pinned tap rather than moving
-it out from under them (`--force` moves it anyway and drops the pin). When a tap
-does move, boost checks whether a newer shard exists for the new commit and
+it out from under them (`--force` moves it anyway and drops the pin). A pinned
+tap with *no* clone is not skipped — there is nothing to hold still, so it is
+cloned and checked out at its pin; if that pin cannot be reached the clone is
+removed rather than left on HEAD with a pin that no longer describes it, and
+`compact --reclone` follows the same rule. When a tap does move, boost checks whether a newer shard exists for the new commit and
 imports it; if none does, it says so instead of leaving stale vectors looking
 fresh. `boost search` never refreshes taps behind your back, and never checks
 the manifest either — acting on that answer means moving taps and downloading

{boost_skill_cli-1.2.107 → boost_skill_cli-1.2.109}/boost_skill_cli.egg-info/SOURCES.txt

@@ -207,6 +207,7 @@ docs/roadmap/items/BOOST-D24.md
 docs/roadmap/items/BOOST-D25.md
 docs/roadmap/items/BOOST-D26.md
 docs/roadmap/items/BOOST-D27.md
+docs/roadmap/items/a-new-shipped-card-always-404s-its-own-write-up-link.md
 docs/roadmap/items/a11y-sweep-flakes-on-color-contrast.md
 docs/roadmap/items/accessibility-audit-pa11y-ci-axe-core.md
 docs/roadmap/items/actionlint-skips-shellcheck-silently.md
@@ -357,6 +358,7 @@ docs/roadmap/items/codeql-job-rename-stranded-merge-protection.md
 docs/roadmap/items/cold-search-reads-the-whole-catalogue.md
 docs/roadmap/items/command-carousel-page.md
 docs/roadmap/items/command-reference-docs-site.md
+docs/roadmap/items/compact-answers-a-named-tap-with-a-global-all-clear.md
 docs/roadmap/items/completions-complete-only-command-names.md
 docs/roadmap/items/completions-install-could-eat-your-rc-file.md
 docs/roadmap/items/complexity-and-dead-code-radar-xenon-vulture.md
@@ -455,6 +457,7 @@ docs/roadmap/items/langchain-retriever-metadata-and-k-floor.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
+docs/roadmap/items/lighthouse-flips-on-byte-identical-input.md
 docs/roadmap/items/lighthouse-scored-a-page-nobody-is-served.md
 docs/roadmap/items/lint-tap-misscopes-rule-workflow-entries.md
 docs/roadmap/items/list-rules-and-workflows.md
@@ -548,10 +551,12 @@ docs/roadmap/items/ranx-significance-monitor.md
 docs/roadmap/items/readme-81-command-table-lists-80-omits-quickstart.md
 docs/roadmap/items/readme-hero-installs-a-name-no-starter-registry-ships.md
 docs/roadmap/items/readme-prune-and-search-guide.md
+docs/roadmap/items/reclone-leaves-a-clone-on-head-when-it-cannot-reach-the-pin.md
 docs/roadmap/items/recommend-recomputes-its-columns-per-row.md
 docs/roadmap/items/reconcile-the-theme-drift.md
 docs/roadmap/items/refresh-strands-the-natural-set-baseline.md
 docs/roadmap/items/refresh-the-marketing-surface.md
+docs/roadmap/items/reindex-reported-a-completeness-share-it-could-not-compute.md
 docs/roadmap/items/rel-time-tests-race-the-wall-clock.md
 docs/roadmap/items/release-verifies-the-wrong-commit.md
 docs/roadmap/items/relicence-apache-2.md
@@ -624,6 +629,7 @@ docs/roadmap/items/sync-reported-success-for-a-link-it-refused.md
 docs/roadmap/items/table-fit-widths-floor-destroys-columns-and-still-overflows.md
 docs/roadmap/items/tap-signing-and-provenance-sigstore-minisign.md
 docs/roadmap/items/taps-check-out-freight-they-never-index.md
+docs/roadmap/items/taps-vouches-for-a-clone-that-is-not-there.md
 docs/roadmap/items/the-catalogue-advertised-repos-that-no-longer-exist.md
 docs/roadmap/items/the-scale-corpus-refreshed-the-wrong-rows.md
 docs/roadmap/items/the-shard-job-that-could-not-finish.md
@@ -956,6 +962,7 @@ tests/unit/test_projectlock.py
 tests/unit/test_provenance.py
 tests/unit/test_publish_golden_dataset.py
 tests/unit/test_rag.py
+tests/unit/test_rag_completeness.py
 tests/unit/test_rag_fastpath.py
 tests/unit/test_rag_fusion.py
 tests/unit/test_registries_fresh.py

boost_skill_cli-1.2.109/docs/roadmap/items/a-new-shipped-card-always-404s-its-own-write-up-link.md

@@ -0,0 +1,42 @@
+---
+id: a-new-shipped-card-always-404s-its-own-write-up-link
+board: code
+section: pipeline
+status: planned
+category: CI · Bug
+complexity: S
+impact: Medium
+wow: 3
+note: the links check goes red on every correct PR that files a new card as shipped, and green again on merge
+order: 313
+owner:
+pr:
+title: "A new card filed as <code>shipped</code> always 404s its own write-up link"
+---
+<code>build_roadmap.py</code> renders a settled card's body as a link to the item file on
+<b><code>main</code></b> &mdash; <code>ITEMS_URL</code> (line 206) is
+<code>https://github.com/jonnyeclectic/boost/blob/main/docs/roadmap/items</code>, and
+<code>_body_html</code> emits it for any status in <code>_SETTLED</code>. The
+<code>links</code> job runs on <code>pull_request</code> over
+<code>docs/*.html</code>. So a PR that files a <em>new</em> card at
+<code>status: shipped</code> renders a link to a file that does not exist on
+<code>main</code> yet, and lychee rejects it 404 &mdash; on a PR where nothing is wrong.
+It goes green by itself the moment the PR merges.
+
+Observed on PR <code>#845</code>, whose 22 required checks were all green:
+<em>&ldquo;[404] &lt;&hellip;/blob/main/docs/roadmap/items/reclone-leaves-a-clone-on-head-when-it-cannot-reach-the-pin.md&gt; (at 4125:54) | Rejected status code: 404 Not Found&rdquo;</em>.
+The mechanism is deterministic from the three sources above rather than inferred from that
+one run: any new item file whose first committed status is settled hits it. Cards that were
+already on <code>main</code> and merely change status do not, which is why this went
+unnoticed &mdash; the usual shape is claim-then-ship across two PRs.
+
+It matters because the remedy people reach for is the wrong one: either the card gets
+filed at a status that misdescribes it to keep CI quiet, or a check that is right about
+everything else gets learned as noise. <code>links</code> is advisory rather than
+required, which caps the damage and is also what lets it rot unnoticed. Options, cheapest
+first: resolve the link against the <em>head</em> ref in CI
+(<code>GITHUB_HEAD_REF</code>) and <code>main</code> elsewhere; or let lychee treat a
+<code>blob/main</code> URL whose path exists in the working tree as satisfied; or link the
+raw file relatively and accept that GitHub Pages serves <code>.md</code> as a download
+rather than rendered Markdown &mdash; which is the reason the absolute URL was chosen, so
+that one is a trade, not a fix.

{boost_skill_cli-1.2.107 → boost_skill_cli-1.2.109}/docs/roadmap/items/audit-pinned-taps-silently-moved-to-head-by-update-re-clone-and-co.md

@@ -2,12 +2,12 @@
 id: audit-pinned-taps-silently-moved-to-head-by-update-re-clone-and-co
 board: code
 section: internals
-status: inflight
+status: shipped
 category: Safety · Bug
 complexity: M
 impact: High
 wow: 2
-note: compact --reclone moved a pin to HEAD and printed "every tap is already compact"
+note: three broken paths, three PRs claiming it, and one residual that took a second item to finish
 order: 216
 owner: loop/tap-pin-integrity
 pr: 725
@@ -43,3 +43,14 @@ size-only report at <code>configuration.py:288-292</code> is what hid the move.
 pinned-tap paragraph (lines 176-178) and its <code>compact --reclone</code> line (274); regenerate
 <code>docs/commands.html</code> only if the <code>--force</code> help string changes. Found by the
 2026-08 CLI audit (cluster <code>pinned-tap-integrity</code>); repro in the audit log.
+
+
+<b>Closed 2026-09-10.</b> <code>#725</code> landed the <code>registry.update</code> half
+(both the <code>--force</code> unpin and the re-clone of a pinned tap whose clone had
+vanished, with <code>tests/unit/test_tap_pins.py</code> covering each). The
+<code>compact --reclone</code> half landed in two pieces: the pin checkout, the
+<code>catalog.rebuild_tap</code> and the size-independent report came with
+<code>#725</code>; the unresolvable-pin guard was left behind when three PRs claimed this
+one item and only one could merge, and is its own card &mdash;
+<code>reclone-leaves-a-clone-on-head-when-it-cannot-reach-the-pin</code>. All three paths
+named above are now closed, and README's pinned-tap paragraph says what the code does.

boost_skill_cli-1.2.109/docs/roadmap/items/compact-answers-a-named-tap-with-a-global-all-clear.md

@@ -0,0 +1,36 @@
+---
+id: compact-answers-a-named-tap-with-a-global-all-clear
+board: code
+section: internals
+status: planned
+category: CLI · Bug
+complexity: S
+impact: Medium
+wow: 2
+note: boost compact <tap> on an uncloned tap prints a green "no cloned taps to compact" and exits 0
+order: 311
+owner:
+pr:
+title: "<code>compact &lt;tap&gt;</code> answers a question about one tap with a global all-clear"
+---
+<code>cmd_compact</code> resolves its named taps and then filters
+(<code>taps = [t for t in taps if t.is_cloned]</code>). A tap that is configured but has
+no clone falls out of that list silently, so the empty-list branch fires and prints
+<em>&ldquo;&#10003; no cloned taps to compact&rdquo;</em> with exit 0 &mdash; a green,
+plural, global-sounding all-clear in answer to a question about one specific tap, which
+it never names.
+
+Reproduced on a scratch <code>BOOST_HOME</code>: tap a repo, delete its clone directory,
+then <code>boost compact &lt;that-tap&gt;</code> &rarr; <code>rc=0</code>,
+<em>&ldquo;&#10003; no cloned taps to compact&rdquo;</em>. Meanwhile
+<code>boost doctor</code> exits 1 on the same machine and says
+<em>&ldquo;! tap &lt;x&gt; not cloned &mdash; run <code>boost update</code>&rdquo;</em>,
+so the information exists and this command is the one that withholds it.
+
+This contradicts the convention <code>registry.update</code> states in its own docstring:
+<em>&ldquo;A named tap still raises. <code>boost update sometap</code> is a request about
+that one tap, so its failure is the answer to the question asked.&rdquo;</em> The sweep
+form is right to stay quiet; the named form is not. Fix: when <code>args.tap</code> named
+taps and the filter dropped some, say which and why, and point at
+<code>boost update</code> the way <code>doctor</code> does &mdash; and do not report
+success for a tap nothing was done to.

boost_skill_cli-1.2.109/docs/roadmap/items/lighthouse-flips-on-byte-identical-input.md

@@ -0,0 +1,44 @@
+---
+id: lighthouse-flips-on-byte-identical-input
+board: code
+section: docsite
+status: planned
+category: CI · Bug
+complexity: M
+impact: High
+wow: 4
+note: the same roadmap.html scored 0.78 and passed, then 0.78 and failed — the gate now decides on runner noise
+order: 314
+owner:
+pr:
+title: The performance gate flips on byte-identical input
+---
+<code>lighthouse</code> asserts <code>categories.performance &ge; 0.80</code> on
+<code>docs/roadmap.html</code>. That page now scores <b>0.76&ndash;0.78</b>, so the
+assertion is decided by whichever way runner timing falls, not by the page. <b>Two commits
+on one branch, whose <code>docs/roadmap.html</code> is byte-identical
+(<code>sha256 42bdc4f7&hellip;</code>, 784,560&nbsp;bytes both), got opposite verdicts</b>
+&mdash; <code>c75f4a9f</code> failed, <code>037a2468</code> passed, 60 seconds apart. The
+same oscillation is visible on other branches in the run history:
+<code>loop/missing-json</code> failed at <code>2a5231cb</code> and passed at
+<code>1c949b7d</code>; <code>loop/audit-retrieval-search-onboarding</code> failed twice
+then passed.
+
+Three earlier cards closed real findings here &mdash;
+<code>lighthouse-ci-on-the-pages-site</code> installed the budgets,
+<code>lighthouse-scored-a-page-nobody-is-served</code> fixed a harness sending 3.27x the
+bytes Pages sends, and <code>roadmap-page-weight-grows-without-bound</code> found it was
+<em>never the bytes</em> but 705&nbsp;ms of <code>styleLayout</code>, and bought headroom
+by letting 55.5% of elements skip it. That headroom has since been spent: the board was
+407.6&nbsp;KB when that card was written and is <b>787&nbsp;KB</b> now. So this is not a
+re-file of any of them &mdash; it is what happens after their fix, and the symptom is
+different in kind: a gate that cannot decide rather than a page that is slow.
+
+Why it matters more than two hundredths of a score: a check that fails on input it just
+passed is a check people learn to re-run rather than read, and the next real regression
+arrives looking exactly like the last false one. <code>lighthouse</code> is advisory, not
+required, which is what has let it drift this far unnoticed. Fix &mdash; decide which
+guarantee is wanted, then make the gate express it: assert the median of the three runs
+rather than the worst, or floor at a value the page actually clears and put a separate
+bound on the growth that is eating the margin, so the number that moves is the one being
+regressed. Lowering the floor alone just relocates the coin flip.

{boost_skill_cli-1.2.107 → boost_skill_cli-1.2.109}/docs/roadmap/items/publish-the-keyword-index.md

@@ -2,13 +2,14 @@
 id: publish-the-keyword-index
 board: code
 section: planned
-status: planned
+status: inflight
 category: Search · Performance
 complexity: L
 impact: High
 wow: 4
 note: every machine rebuilds 697 MB of index for a corpus that is byte-identical on all of them
 order: 99
+owner: loop/keyword-index-completeness
 title: publish the keyword index the way vectors are published
 ---
 Dense vectors are built once in CI and downloaded. The BM25 index is not:
@@ -66,3 +67,27 @@ as a match.
 <a href="#shrink-the-published-index">shrink-the-published-index</a>. This card should not ship
 until that one has an answer, because publishing 697&nbsp;MB per refresh to save 65&nbsp;s of CPU
 is not obviously the right trade, and at the compressed sizes measured there it clearly is.
+
+<b>Partly landed, and deliberately still <code>inflight</code> — 2026-09-10.</b> What shipped is
+the half that needed no size decision: <b>the index now records what it is</b>.
+<code>read_body_full</code> returns the text and whether it contains the item's body,
+<code>build()</code> reports <code>metadata_only</code> over every document written (reused ones
+included, or an incremental build reports zero on the run after a bundle import),
+<code>index_completeness()</code> reads the share back off disk, and <code>boost reindex</code>
+says it out loud instead of reporting the same confident count for a 6% index. The share is of
+<b>tokens</b>, not documents: a bodyless entry still produces a document, so a document share sits
+at 1.0 until it drops to 0.0. <code>INDEX_VERSION</code> moved to <b>9</b>, because the flag is
+written only when a body is missing and absence may only be read as "complete" once no older
+document can survive.
+
+<b>What did NOT land:</b> <code>rag.export_shard</code> / <code>rag.import_shard</code>, the
+per-registry assets, and the <code>manifest.json</code> rows — the publishing pipeline itself.
+That half is what the payload-size question governs, and
+<a href="#shrink-the-published-index">shrink-the-published-index</a> still has no answer: its claim
+is <b>stale</b>, not active — branch <code>loop/shrink-postings-index</code> was last touched
+2026-09-02, carries one commit, has no pull request, and is 394 commits behind
+<code>main</code>. Someone should un-claim it. One structural finding for whoever takes it: doc
+ids are positional (<code>_save</code> does <code>enumerate(docs)</code>), so the card's
+"merge by offsetting <code>doc_id</code>" is sound as written — and the shard format should
+serialize <em>logical</em> postings (digest → term → tf) rather than the SQLite layout, so the
+interning that branch was attempting cannot invalidate a published shard.