boost-skill-cli 1.0.342__tar.gz → 1.0.344__tar.gz

{boost_skill_cli-1.0.342 → boost_skill_cli-1.0.344}/CLAUDE.md

@@ -181,7 +181,7 @@ for both — edit items, run `build_roadmap.py`, never touch the HTML by hand.
 ## Architecture
 
 **CLI dispatch.** `boost_cli/cli.py` holds `COMMANDS`, the single
-source-of-truth list of `(name, group, module, summary)` for all 78 commands.
+source-of-truth list of `(name, group, module, summary)` for all 79 commands.
 Each command is implemented as `def cmd_<name_with_underscores>(argv) -> int`
 inside `boost_cli/commands/<module>.py`, and `_dispatch` imports that module
 lazily on invocation — so `boost --help` stays instant and command modules are

{boost_skill_cli-1.0.342/boost_skill_cli.egg-info → boost_skill_cli-1.0.344}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.342
+Version: 1.0.344
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE
@@ -927,7 +927,7 @@ boost doctor               # sanity check: broken links, lock drift, stale taps
 boost bundle dump > Boostfile     # everyone else runs: boost bundle install
 ```
 
-## 78 commands, organized into 8 groups
+## 79 commands, organized into 8 groups
 
 `boost --help` prints the full grouped command list; for a visual tour see
 [`docs/index.html`](docs/index.html), and for every flag of every command see
@@ -1082,7 +1082,7 @@ Four layers, all enforced (`make check` runs the full set; CI runs the same thin
 
 | Layer | What it does | Gate |
 |---|---|---|
-| `make test` | pytest across `tests/unit/` (every core module) and `tests/functional/` (drives all 78 commands in-process against sandboxed homes) | **≥80% line coverage** of `boost_cli` (`fail_under` in pyproject.toml) |
+| `make test` | pytest across `tests/unit/` (every core module) and `tests/functional/` (drives all 79 commands in-process against sandboxed homes) | **≥80% line coverage** of `boost_cli` (`fail_under` in pyproject.toml) |
 | `make smoke` | `tests/smoke.sh` — 170 checks run through the actual `./boost` shim (`--online` also hits real registries) | all pass |
 | `make mutation` | [mutmut] mutates `boost_cli/core` (~9,900 mutants) and reruns the unit suite against each one | **≥80% killed** (`scripts/mutation_gate.py`) |
 | `make evals` | scores the search ranker on a graded golden set — recall@5/@10, MRR, nDCG@5/@10 | **metric floors + no statistically significant regression** (`scripts/eval_gate.py`) |

{boost_skill_cli-1.0.342 → boost_skill_cli-1.0.344}/README.md

@@ -209,7 +209,7 @@ boost doctor               # sanity check: broken links, lock drift, stale taps
 boost bundle dump > Boostfile     # everyone else runs: boost bundle install
 ```
 
-## 78 commands, organized into 8 groups
+## 79 commands, organized into 8 groups
 
 `boost --help` prints the full grouped command list; for a visual tour see
 [`docs/index.html`](docs/index.html), and for every flag of every command see
@@ -364,7 +364,7 @@ Four layers, all enforced (`make check` runs the full set; CI runs the same thin
 
 | Layer | What it does | Gate |
 |---|---|---|
-| `make test` | pytest across `tests/unit/` (every core module) and `tests/functional/` (drives all 78 commands in-process against sandboxed homes) | **≥80% line coverage** of `boost_cli` (`fail_under` in pyproject.toml) |
+| `make test` | pytest across `tests/unit/` (every core module) and `tests/functional/` (drives all 79 commands in-process against sandboxed homes) | **≥80% line coverage** of `boost_cli` (`fail_under` in pyproject.toml) |
 | `make smoke` | `tests/smoke.sh` — 170 checks run through the actual `./boost` shim (`--online` also hits real registries) | all pass |
 | `make mutation` | [mutmut] mutates `boost_cli/core` (~9,900 mutants) and reruns the unit suite against each one | **≥80% killed** (`scripts/mutation_gate.py`) |
 | `make evals` | scores the search ranker on a graded golden set — recall@5/@10, MRR, nDCG@5/@10 | **metric floors + no statistically significant regression** (`scripts/eval_gate.py`) |

{boost_skill_cli-1.0.342 → boost_skill_cli-1.0.344}/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.342'
-__version_tuple__ = version_tuple = (1, 0, 342)
+__version__ = version = '1.0.344'
+__version_tuple__ = version_tuple = (1, 0, 344)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.342 → boost_skill_cli-1.0.344}/boost_cli/cli.py

@@ -90,6 +90,7 @@ COMMANDS = [
     ("taps",        "tap", "taps", "List all configured registry taps"),
     ("outdated",    "tap", "taps", "Show skills with available updates"),
     # Intelligence (8)
+    ("chat",        "ai", "intelligence", "Ask about skills in plain language (RAG-grounded)"),
     ("distill",     "ai", "intelligence", "Merge multiple skills into one deduplicated skill"),
     ("simulate",    "ai", "intelligence", "Preview how a skill would change Claude's behavior"),
     ("infer",       "ai", "intelligence", "Generate a SKILL.md from your codebase patterns"),

{boost_skill_cli-1.0.342 → boost_skill_cli-1.0.344}/boost_cli/commands/intelligence.py

@@ -28,9 +28,13 @@ from ..core import (
     journal,
     lockfile,
     paths,
+    registry,
     store,
     util,
 )
+from ..core import (
+    chat as chat_engine,
+)
 from ..core import output as out
 from ..errors import BoostError
 
@@ -1035,3 +1039,98 @@ def _repo_activity(since: str) -> Tuple[Optional[int], Optional[int]]:
     if proc.returncode == 0:
         files = len({ln.strip() for ln in proc.stdout.splitlines() if ln.strip()})
     return commits, files
+
+
+def _print_reply(reply: chat_engine.Reply, show_sources: bool) -> None:
+    """Render one answer: the prose, then where it came from.
+
+    Citations are not decoration here. The next thing a user does with an answer
+    is install code that runs inside their agent, so every recommendation has to
+    be checkable against a real catalogue entry.
+    """
+    for line in reply.text.splitlines():
+        out.info(line)
+    if show_sources and reply.skills:
+        out.info("")
+        out.info(out.role("sources · ranked by %s" % reply.engine, "muted"))
+        for cite in chat_engine.citations(reply.skills):
+            out.info(out.role("  %s  %s  (%s)"
+                              % (cite["name"], cite["kind"], cite["tap"]), "muted"))
+    if reply.source == "extractive" and not reply.grounded:
+        # The model answered and was rejected. Saying so beats silently showing
+        # a downgraded answer that looks identical to a confident one.
+        out.warn("the AI reply named something outside the retrieved skills — "
+                 "showing the grounded matches instead")
+
+
+def cmd_chat(argv: List[str]) -> int:
+    """Ask about skills in plain language; answers are grounded in retrieval."""
+    ap = cliparse.parser(
+        prog="boost chat",
+        description="Ask about skills in plain language")
+    ap.add_argument("question", nargs="*", metavar="QUESTION",
+                    help="ask once and exit; omit for an interactive session")
+    ap.add_argument("-k", "--limit", type=int, default=chat_engine.TOP_K,
+                    metavar="N", help="candidate skills to consider (default %d)"
+                                      % chat_engine.TOP_K)
+    ap.add_argument("--no-sources", action="store_true",
+                    help="hide the citation block under each answer")
+    ap.add_argument("--json", action="store_true", dest="as_json",
+                    help="machine-readable answer (implies one-shot)")
+    args = ap.parse_args(argv)
+
+    if not registry.list_taps():
+        raise BoostError("no taps configured — nothing to chat about",
+                        hint="add the recommended registries with `boost tap --defaults`")
+
+    question = " ".join(args.question).strip()
+    if args.as_json:
+        if not question:
+            raise BoostError("--json needs a question",
+                            hint='try: boost chat --json "how do I review a diff?"')
+        reply = chat_engine.answer(question, k=args.limit)
+        print(json.dumps({
+            "question": question,
+            "answer": reply.text,
+            "engine": reply.engine,
+            "source": reply.source,
+            "grounded": reply.grounded,
+            "skills": chat_engine.citations(reply.skills),
+        }))
+        return 0
+
+    if question:
+        _print_reply(chat_engine.answer(question, k=args.limit), not args.no_sources)
+        return 0
+
+    return _chat_session(args)
+
+
+def _chat_session(args) -> int:
+    """The interactive loop. Kept separate so cmd_chat stays a dispatcher.
+
+    History is bounded by chat_engine.HISTORY_TURNS — this is a lookup
+    assistant, and a long transcript encourages answering from the conversation
+    rather than from what retrieval actually returned.
+    """
+    if not ai.available():
+        # Worth saying up front rather than letting every answer look terse for
+        # an unexplained reason.
+        out.info(out.role("no AI configured — answers are the grounded matches "
+                          "themselves (%s)" % ai.fallback_note(), "muted"))
+    out.info(out.role("ask about skills; blank line or Ctrl-D to exit", "muted"))
+    history: List[chat_engine.Turn] = []
+    while True:
+        try:
+            question = input("\n> ").strip()
+        except (EOFError, KeyboardInterrupt):
+            out.info("")
+            return 0
+        if not question:
+            return 0
+        reply = chat_engine.answer(question, history=history, k=args.limit)
+        out.info("")
+        _print_reply(reply, not args.no_sources)
+        history.append(chat_engine.Turn(question, reply.text))
+        for follow in chat_engine.suggest_followups(reply.skills)[:2]:
+            out.info(out.role("  try: %s" % follow, "muted"))

boost_skill_cli-1.0.344/boost_cli/core/chat.py

@@ -0,0 +1,242 @@
+"""Conversational search over the tapped catalogue.
+
+``boost chat`` sits on top of machinery that already exists — ``rag.retrieve_any``
+for finding candidates, ``ai.ask`` for prose, ``faithfulness.score`` for checking
+that prose against its source — and adds the one thing they do not do together:
+turn a question into an answer that names specific skills and says why.
+
+THE FAILURE THIS IS BUILT AROUND. boost is a package manager. A chatbot that
+invents a plausible-sounding skill name is not a cosmetic bug: the user goes
+looking for ``docker-compose-expert``, does not find it, and either concludes the
+catalogue is broken or — worse — installs something adjacent from an untrusted
+tap. Typosquatting is a real hazard in this ecosystem (``core/typosquat.py``
+exists for it), so an assistant that manufactures names is actively dangerous
+rather than merely unhelpful.
+
+Two defences, in order:
+
+* **Retrieval decides what may be discussed.** The model is never asked "what
+  skill does X?" — it is asked to summarise a specific, retrieved set. Nothing
+  outside that set can be recommended because nothing outside it is in the
+  prompt.
+* **The reply is checked before it is shown.** Every skill name in the answer
+  must appear in the retrieved set (:func:`ungrounded_names`), and the prose as a
+  whole must score against the source text (:func:`faithfulness.score`, the same
+  gate ``boost explain`` uses). A reply that fails either is discarded, not
+  patched — and the extractive answer below is shown instead.
+
+Degrading rather than failing is the house contract: with ``BOOST_NO_AI=1``, no
+API key, or no ``claude`` CLI, :func:`answer` still returns a useful grounded
+answer assembled from the retrieved descriptions. The AI path improves the prose;
+it is never load-bearing for correctness.
+"""
+from __future__ import annotations
+
+import re
+from typing import Dict, List, NamedTuple, Optional, Sequence, Tuple
+
+from . import ai, catalog, faithfulness, rag
+
+# How many candidates reach the prompt. Small on purpose: the model summarises
+# rather than searches, and a long tail of weak hits invites it to reach for
+# whichever one sounds closest to the question rather than the one that ranked.
+TOP_K = 5
+
+# Minimum groundedness for AI prose, matching `boost explain`'s default. Below
+# this the reply names specifics its sources never did, which is the observable
+# shape of a fabricated capability.
+MIN_FAITHFULNESS = 0.60
+
+# A conversation is kept this short deliberately. `chat` is a lookup assistant,
+# not an agent: more history means more chances for the model to answer from the
+# conversation instead of from what retrieval actually returned.
+HISTORY_TURNS = 4
+
+_SYSTEM = (
+    "You help a developer pick an AI coding-agent skill from a catalogue. "
+    "Answer ONLY from the numbered skills provided. Never invent a skill name. "
+    "If none fit, say so plainly. Be concrete and brief: 3-5 sentences, no "
+    "markdown, no bullet lists. Name the skills you recommend exactly as given."
+)
+
+
+class Turn(NamedTuple):
+    """One exchange, kept so a follow-up can refer back to it."""
+
+    question: str
+    answer: str
+
+
+class Reply(NamedTuple):
+    """What :func:`answer` produces.
+
+    ``grounded`` is False only when the AI path was tried and rejected — the
+    caller may want to say so, since a silently downgraded answer looks the same
+    as a confident one.
+    """
+
+    text: str
+    skills: List[dict]      # the catalogue entries the answer draws on
+    engine: str             # which retrieval engine ran, for attribution
+    source: str             # "ai" | "extractive"
+    grounded: bool
+
+
+def _history_context(history: Sequence[Turn]) -> str:
+    """Recent turns, oldest first, as plain text for the prompt."""
+    recent = list(history)[-HISTORY_TURNS:]
+    if not recent:
+        return ""
+    lines = ["Earlier in this conversation:"]
+    for turn in recent:
+        lines.extend(("Q: %s" % turn.question, "A: %s" % turn.answer))
+    return "\n".join(lines) + "\n\n"
+
+
+def expand_query(question: str, history: Sequence[Turn]) -> str:
+    """The string actually sent to retrieval.
+
+    A follow-up like "what about the second one?" carries almost no searchable
+    terms, so retrieving on it alone returns noise. Appending the previous
+    question restores the subject without needing the model to rewrite it — a
+    rewrite would be another place for the assistant to drift off-topic.
+
+    Only the immediately preceding question is used: two turns back is usually a
+    different subject, and blending them retrieves for neither.
+    """
+    question = question.strip()
+    if not history:
+        return question
+    # Long questions carry their own context; short ones are the follow-ups.
+    if len(question.split()) > 6:
+        return question
+    return "%s %s" % (history[-1].question, question)
+
+
+def retrieve(question: str, history: Sequence[Turn] = (),
+             k: int = TOP_K) -> Tuple[List[dict], str]:
+    """Candidate catalogue entries for ``question``, best first.
+
+    Returns ``(entries, engine_label)``. Uses :func:`rag.retrieve_any` so chat
+    gets whatever the machine has — hybrid, dense, or BM25 — rather than pinning
+    an engine of its own, and falls back to the frontmatter scan when no index
+    exists at all so a fresh install still answers.
+    """
+    query = expand_query(question, history)
+    entries = catalog.all_entries()
+    hits, engine = rag.retrieve_any(query, k=k, entries=entries)
+    if hits is None:
+        # No index of any kind: catalog.search is the documented floor.
+        scored = catalog.search(query)
+        return [e for e, _score in scored[:k]], "frontmatter scan"
+    return [h["entry"] for h in hits[:k]], engine
+
+
+def _describe(entry: dict) -> str:
+    """One catalogue entry as a line of prompt/answer text."""
+    return "%s (%s) — %s" % (entry.get("name", "?"), entry.get("tap", "?"),
+                             (entry.get("description") or "").strip() or "no description")
+
+
+def source_text(entries: Sequence[dict]) -> str:
+    """The numbered candidate list the model is allowed to answer from."""
+    return "\n".join("%d. %s" % (i, _describe(e)) for i, e in enumerate(entries, 1))
+
+
+def ungrounded_names(reply: str, entries: Sequence[dict]) -> List[str]:
+    """Skill-shaped tokens in ``reply`` that name nothing in ``entries``.
+
+    Catalogue names are lowercase hyphenated words (``code-reviewer``,
+    ``pdf``), which is a distinctive enough shape to spot in prose. Anything
+    matching that shape and not present in the candidate set is a name the model
+    supplied itself — the exact failure that sends a user hunting for a skill
+    that does not exist.
+
+    Deliberately narrow: it only flags *hyphenated* tokens. A single ordinary
+    word cannot be told apart from prose, so this under-reports rather than
+    firing on innocent sentences, and the faithfulness score covers the rest.
+    """
+    known = {str(e.get("name", "")).lower() for e in entries}
+    candidates = set(re.findall(r"\b[a-z][a-z0-9]*(?:-[a-z0-9]+)+\b", reply.lower()))
+    return sorted(c for c in candidates if c not in known)
+
+
+def _extractive(question: str, entries: Sequence[dict]) -> str:
+    """A grounded answer with no model involved.
+
+    This is what every keyless, offline or AI-disabled install gets, so it has to
+    be genuinely useful rather than an apology: the top candidates with their
+    descriptions and where they came from, which is the information the user
+    needs to decide.
+    """
+    if not entries:
+        return ("Nothing in the tapped catalogue matches that. Try `boost tap "
+                "--defaults` for more registries, or rephrase with the concrete "
+                "terms you would expect in the skill's own description.")
+    lines = ["Closest matches in your tapped catalogue:"]
+    lines.extend("  " + _describe(entry) for entry in entries)
+    lines.extend(("", "Run `boost info <name>` for the full skill, or "
+                      "`boost install <name>` to add it."))
+    return "\n".join(lines)
+
+
+def answer(question: str, history: Sequence[Turn] = (),
+           k: int = TOP_K) -> Reply:
+    """Answer ``question`` from the tapped catalogue.
+
+    The AI path is attempted only when :func:`ai.available`; its reply is used
+    only when it passes both grounding checks. Otherwise the extractive answer is
+    returned, which is the same information in a plainer shape.
+    """
+    entries, engine = retrieve(question, history, k=k)
+    extractive = _extractive(question, entries)
+    if not entries or not ai.available():
+        return Reply(extractive, entries.copy(), engine, "extractive", True)
+
+    source = source_text(entries)
+    prompt = "%s%s\n\nCandidate skills:\n%s\n\nQuestion: %s" % (
+        _history_context(history),
+        "Answer the question using only the numbered skills below.",
+        source, question)
+    reply = ai.ask(prompt, system=_SYSTEM)
+    if not reply:
+        return Reply(extractive, entries.copy(), engine, "extractive", True)
+
+    reply = reply.strip()
+    invented = ungrounded_names(reply, entries)
+    if invented:
+        # A manufactured name is unrecoverable — there is no honest way to show
+        # prose that points at a skill which does not exist.
+        return Reply(extractive, entries.copy(), engine, "extractive", False)
+    if faithfulness.score(reply, source) < MIN_FAITHFULNESS:
+        return Reply(extractive, entries.copy(), engine, "extractive", False)
+    return Reply(reply, entries.copy(), engine, "ai", True)
+
+
+def citations(entries: Sequence[dict]) -> List[Dict[str, str]]:
+    """Name/tap pairs for the entries an answer drew on.
+
+    Shown under every answer so a claim can be checked against the source, which
+    matters more here than in an ordinary chatbot: the next step is installing
+    code that will run inside the user's agent.
+    """
+    return [{"name": str(e.get("name", "")), "tap": str(e.get("tap", "")),
+             "kind": str(e.get("kind", "skill"))} for e in entries]
+
+
+def suggest_followups(entries: Sequence[dict]) -> List[str]:
+    """Concrete next questions, drawn from what was actually retrieved.
+
+    Generic prompts ("ask me anything!") teach nothing; naming a real retrieved
+    skill shows the user the shape of a question that works.
+    """
+    if not entries:
+        return ["what skills do I have installed?"]
+    top: Optional[dict] = entries[0]
+    name = str(top.get("name", "")) if top else ""
+    out: List[str] = []
+    if name:
+        out.extend(("what does %s actually do?" % name,
+                    "how is %s different from the others?" % name))
+    out.append("which of these should I install first?")
+    return out

{boost_skill_cli-1.0.342 → boost_skill_cli-1.0.344/boost_skill_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.342
+Version: 1.0.344
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE
@@ -927,7 +927,7 @@ boost doctor               # sanity check: broken links, lock drift, stale taps
 boost bundle dump > Boostfile     # everyone else runs: boost bundle install
 ```
 
-## 78 commands, organized into 8 groups
+## 79 commands, organized into 8 groups
 
 `boost --help` prints the full grouped command list; for a visual tour see
 [`docs/index.html`](docs/index.html), and for every flag of every command see
@@ -1082,7 +1082,7 @@ Four layers, all enforced (`make check` runs the full set; CI runs the same thin
 
 | Layer | What it does | Gate |
 |---|---|---|
-| `make test` | pytest across `tests/unit/` (every core module) and `tests/functional/` (drives all 78 commands in-process against sandboxed homes) | **≥80% line coverage** of `boost_cli` (`fail_under` in pyproject.toml) |
+| `make test` | pytest across `tests/unit/` (every core module) and `tests/functional/` (drives all 79 commands in-process against sandboxed homes) | **≥80% line coverage** of `boost_cli` (`fail_under` in pyproject.toml) |
 | `make smoke` | `tests/smoke.sh` — 170 checks run through the actual `./boost` shim (`--online` also hits real registries) | all pass |
 | `make mutation` | [mutmut] mutates `boost_cli/core` (~9,900 mutants) and reruns the unit suite against each one | **≥80% killed** (`scripts/mutation_gate.py`) |
 | `make evals` | scores the search ranker on a graded golden set — recall@5/@10, MRR, nDCG@5/@10 | **metric floors + no statistically significant regression** (`scripts/eval_gate.py`) |

{boost_skill_cli-1.0.342 → boost_skill_cli-1.0.344}/boost_skill_cli.egg-info/SOURCES.txt

@@ -53,6 +53,7 @@ boost_cli/core/agents.py
 boost_cli/core/ai.py
 boost_cli/core/capabilities.py
 boost_cli/core/catalog.py
+boost_cli/core/chat.py
 boost_cli/core/claude_settings.py
 boost_cli/core/config.py
 boost_cli/core/dense.py
@@ -105,8 +106,11 @@ boost_skill_cli.egg-info/top_level.txt
 docs/DEBUGGING.md
 docs/adapters.html
 docs/carousel.html
+docs/chat.html
 docs/commands.html
+docs/demo-index.json
 docs/demo.gif
+docs/demo.html
 docs/demo.tape
 docs/design-roadmap.html
 docs/eval.html
@@ -179,6 +183,7 @@ docs/roadmap/items/browse-crashes-selecting-a-rule-or-workflow.md
 docs/roadmap/items/build-provenance-slsa-attestations.md
 docs/roadmap/items/cache-the-catalog-entry-set-across-rag-queries.md
 docs/roadmap/items/capability-manifest-and-least-privilege-policy.md
+docs/roadmap/items/chat-command-grounded-conversational-search.md
 docs/roadmap/items/ci-job-timeout-minutes.md
 docs/roadmap/items/ci-summary-step-fails-itself.md
 docs/roadmap/items/ci-time-is-now-runner-queueing.md
@@ -379,6 +384,7 @@ requirements/test-tools.txt
 scripts/a11y_check.py
 scripts/bench_cli.sh
 scripts/build_command_reference.py
+scripts/build_demo_index.py
 scripts/build_registries.py
 scripts/build_roadmap.py
 scripts/check_anchors.py
@@ -431,6 +437,7 @@ tests/eval/taps.txt
 tests/functional/test_capabilities_policy.py
 tests/functional/test_cli_adapt.py
 tests/functional/test_cli_bmad.py
+tests/functional/test_cli_chat.py
 tests/functional/test_cli_configuration.py
 tests/functional/test_cli_discovery.py
 tests/functional/test_cli_hooks.py
@@ -478,6 +485,7 @@ tests/unit/test_agents.py
 tests/unit/test_ai.py
 tests/unit/test_capabilities.py
 tests/unit/test_catalog.py
+tests/unit/test_chat.py
 tests/unit/test_check_anchors.py
 tests/unit/test_check_licenses.py
 tests/unit/test_claude_settings.py
@@ -488,6 +496,7 @@ tests/unit/test_community_health_files.py
 tests/unit/test_config.py
 tests/unit/test_content_dedupe.py
 tests/unit/test_dedup_trust.py
+tests/unit/test_demo_index.py
 tests/unit/test_dense.py
 tests/unit/test_dense_fallback.py
 tests/unit/test_dense_fix_hint.py

{boost_skill_cli-1.0.342 → boost_skill_cli-1.0.344}/docs/carousel.html

@@ -115,7 +115,7 @@
   <div class="wrap hero">
     <p class="crumbs"><a href="index.html">boost</a> / docs / carousel</p>
     <span class="badge">8 command groups · recorded live with VHS</span>
-    <h1>78 commands. <span class="grad-text">One flagship each.</span></h1>
+    <h1>79 commands. <span class="grad-text">One flagship each.</span></h1>
     <p class="lede">boost's command surface spans 8 groups, from package management to team
       collaboration. Rather than 78 near-identical recordings, this page tours <b>one
       representative command per group</b> — the one that shows what that group is actually
@@ -275,7 +275,7 @@
                     <code>simulate</code><code>infer</code><code>absorb</code><code>evolve</code>
                     <code>context</code><code>focus</code><code>impact</code>
                   </div>
-                  <p class="group-note">8 commands in this group.</p>
+                  <p class="group-note">9 commands in this group.</p>
                   <p class="regen">regenerate: <code>vhs docs/carousel/tapes/distill.tape</code></p>
                 </div>
               </div>