boost-skill-cli 1.2.51__tar.gz → 1.2.53__tar.gz

{boost_skill_cli-1.2.51 → boost_skill_cli-1.2.53}/.vale/styles/config/vocabularies/boost/accept.txt

@@ -1,9 +1,12 @@
 ABM
 agentic
+agy
 Algolia
 allowlist
 allowlisted
 argparse
+args
+argv
 Arize
 ASan
 Attio
@@ -172,6 +175,8 @@ unremediated
 unstaged
 untap
 untrusted
+upsert
+upserts
 uv
 Vaadin
 Valgrind

{boost_skill_cli-1.2.51 → boost_skill_cli-1.2.53}/CLAUDE.md

@@ -363,7 +363,7 @@ work in tests and the dev loop:
 ~/.gemini/                       rules (GEMINI.md) + workflows only — see below
 ```
 
-**Four agent targets, but only three get symlinks.** Gemini CLI implements the
+**Five agent targets, and only Gemini CLI skips symlinks.** Gemini CLI implements the
 Agent Skills standard and discovers `~/.agents/skills` — the canonical store —
 *directly*, so it is configured with `links_skills: false`. Linking into
 `~/.gemini/skills` too would put one skill in two of its discovery tiers, where
@@ -394,6 +394,19 @@ for code you write:
   one hop lands in another agent's dir. It resolves **both sides**: on macOS a
   `$HOME` under `/var/folders` resolves to `/private/var/...`, so resolving
   only the target compares a real path against a nominal one and never matches.
+- **Antigravity CLI (`agy`) is Gemini's successor and is NOT a native-store
+  agent.** It shares the `~/.gemini` tree but reads neither `~/.agents/skills`
+  nor — for CLI scope — the shared `~/.gemini/skills`, so it takes real
+  symlinks, into `~/.gemini/antigravity-cli/skills`. Linking into the *shared*
+  dir instead would be the mistake: Gemini CLI reads that path too and already
+  sees the same skills through the `~/.agents/skills` alias, so every skill
+  would cost a "Skill conflict detected" line per session — the exact failure
+  `links_skills: false` exists to prevent. Its rules arrive through the
+  `gemini` agent, which already writes the `~/.gemini/GEMINI.md` Antigravity
+  reads; its workflow and MCP surfaces are **not** wired up, because their
+  formats have not been verified against the real CLI, and this file does not
+  record guesses (see `hookhost.py` for the standard: name the sources).
+
 - Per-agent *formats* differ and are pure functions in `core/`: `rules.CONTEXT_FILES`
   maps an agent with no rules dir to its context file (`claude-code` → CLAUDE.md /
   CLAUDE.local.md, `gemini` → GEMINI.md for both scopes), and
@@ -401,7 +414,16 @@ for code you write:
   Gemini's `commands/` slot is `.toml` (`workflows.render_gemini_command`); its
   `agents/` slot stays verbatim Markdown. Getting that backwards produces a file
   the agent silently never loads.
-- `core/mcphost.py` holds the per-host `mcp add`/`remove` grammar. Claude and
+- `core/mcphost.py` holds the per-host `mcp add`/`remove` grammar.
+  **Antigravity CLI (`agy`) is the third host**, and its two argv rules both bite: flags must
+  come *before* `<name>` (a flag after it is rejected) and `--` must precede a
+  command whose args start with `-`, or `--stdio` is eaten as an agy flag. It
+  has **no scope** — one global file at `~/.gemini/config/mcp_config.json`,
+  inherited from Gemini CLI, so there is no `~/.antigravity` — which is why
+  `has_scope()` exists and the success line drops "(scope: user)" for it. Its
+  `add` **upserts** where Claude's errors on a duplicate name; that asymmetry
+  is what made `--host auto` abort on a machine already registered with
+  Claude. Claude and
   Gemini disagree on name position, the `--` separator, and whether unregister
   needs an explicit scope — all three verified against the real CLIs and pinned
   by `tests/unit/test_mcphost.py`. Don't "simplify" them into one shape.

{boost_skill_cli-1.2.51/boost_skill_cli.egg-info → boost_skill_cli-1.2.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.51
+Version: 1.2.53
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0
@@ -54,7 +54,11 @@ Dynamic: license-file
 
 **Homebrew for AI coding skills.** boost finds, installs, and version-tracks skills
 from GitHub-hosted registries, and wires each one into Claude Code, Windsurf,
-Cursor and Gemini CLI in a single pass.
+Cursor, Gemini CLI and Antigravity CLI in a single pass.
+
+Antigravity CLI (`agy`) is wired up the same way: skills link into
+`~/.gemini/antigravity-cli/skills`, and `boost mcp register` reaches it through
+`agy mcp add` alongside Claude Code.
 
 ```bash
 pipx install boost-skill-cli
@@ -66,7 +70,7 @@ boost install tdd-workflow    # → every agent, version-pinned, one lock file
 (No `pipx` yet? macOS ships neither it nor a new enough Python — run the
 [prerequisites check](#prerequisites) first.)
 
-No more copying `SKILL.md` into four agent folders and forgetting which one is
+No more copying `SKILL.md` into five agent folders and forgetting which one is
 stale. The default install is pure stdlib, with no build step and no
 dependencies.
 

{boost_skill_cli-1.2.51 → boost_skill_cli-1.2.53}/README.md

@@ -12,7 +12,11 @@
 
 **Homebrew for AI coding skills.** boost finds, installs, and version-tracks skills
 from GitHub-hosted registries, and wires each one into Claude Code, Windsurf,
-Cursor and Gemini CLI in a single pass.
+Cursor, Gemini CLI and Antigravity CLI in a single pass.
+
+Antigravity CLI (`agy`) is wired up the same way: skills link into
+`~/.gemini/antigravity-cli/skills`, and `boost mcp register` reaches it through
+`agy mcp add` alongside Claude Code.
 
 ```bash
 pipx install boost-skill-cli
@@ -24,7 +28,7 @@ boost install tdd-workflow    # → every agent, version-pinned, one lock file
 (No `pipx` yet? macOS ships neither it nor a new enough Python — run the
 [prerequisites check](#prerequisites) first.)
 
-No more copying `SKILL.md` into four agent folders and forgetting which one is
+No more copying `SKILL.md` into five agent folders and forgetting which one is
 stale. The default install is pure stdlib, with no build step and no
 dependencies.
 

{boost_skill_cli-1.2.51 → boost_skill_cli-1.2.53}/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.51'
-__version_tuple__ = version_tuple = (1, 2, 51)
+__version__ = version = '1.2.53'
+__version_tuple__ = version_tuple = (1, 2, 53)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.51 → boost_skill_cli-1.2.53}/boost_cli/commands/configuration.py

@@ -1664,8 +1664,11 @@ def cmd_mcp(argv) -> int:
 
     verb = "register" if args.action == "register" else "unregister"
     for host in done:
-        out.ok("%sed boost as an MCP server for %s (scope: user)"
-               % (verb, mcphost.label(host)))
+        # agy has no scopes — one global file — so claiming "(scope: user)"
+        # would describe a distinction its CLI does not have.
+        scope_note = " (scope: user)" if mcphost.has_scope(host) else ""
+        out.ok("%sed boost as an MCP server for %s%s"
+               % (verb, mcphost.label(host), scope_note))
     for host in already:
         out.ok("already registered with %s — nothing to do"
                % mcphost.label(host))

{boost_skill_cli-1.2.51 → boost_skill_cli-1.2.53}/boost_cli/commands/taps.py

@@ -51,7 +51,8 @@ def _tap_catalog(args) -> int:
 
 def _tap_all(urls: list[str], jobs: int | None,
              focus: dict[str, str] | None = None,
-             pins: dict[str, str] | None = None) -> int:
+             pins: dict[str, str] | None = None,
+             curated: bool = True) -> int:
     """Clone many registries at once, then scan each one that arrived.
 
     The split is the whole optimisation. Cloning is network latency — 1.6 s per
@@ -60,7 +61,7 @@ def _tap_all(urls: list[str], jobs: int | None,
     its output can be printed in order and its errors belong to one tap.
     """
     focus = focus or {}
-    results = registry.add_many(urls, curated=True, pins=pins, jobs=jobs)
+    results = registry.add_many(urls, curated=curated, pins=pins, jobs=jobs)
     rc = 0
     for res in results:
         name = res["name"]
@@ -106,8 +107,9 @@ def cmd_tap(argv) -> int:
     p = cliparse.parser(
         prog="boost tap",
         description="Add a GitHub repo as a skill registry")
-    p.add_argument("spec", nargs="?",
-                   help="owner/repo, a git URL, or a local directory")
+    p.add_argument("spec", nargs="*",
+                   help="owner/repo, a git URL, or a local directory — several "
+                        "at once clone in parallel")
     p.add_argument("--defaults", action="store_true",
                    help="tap the recommended public registries")
     p.add_argument("--catalog", action="store_true",
@@ -131,8 +133,8 @@ def cmd_tap(argv) -> int:
                         "%d)" % (registry.DEFAULT_TAP_JOBS,
                                  registry.MAX_TAP_JOBS))
     args = p.parse_args(argv)
-    if args.at and not args.spec:
-        p.error("--at pins one registry, so it needs a SPEC")
+    if args.at and len(args.spec) != 1:
+        p.error("--at pins one registry, so it needs exactly one SPEC")
     if not args.spec and not args.defaults and not args.catalog:
         p.error("provide a SPEC, --defaults, or --catalog")
 
@@ -147,13 +149,21 @@ def cmd_tap(argv) -> int:
                        jobs=args.jobs,
                        focus={str(d["name"]): str(d.get("focus", ""))
                               for d in config.DEFAULT_TAPS})
-    if args.spec:
-        with spin.Spinner("cloning %s" % args.spec):
-            tap = registry.add(args.spec, curated=args.curated, at=args.at)
+    if len(args.spec) == 1:
+        with spin.Spinner("cloning %s" % args.spec[0]):
+            tap = registry.add(args.spec[0], curated=args.curated, at=args.at)
             entries = catalog.rebuild_tap(tap)
         journal.log("tap", tap.name)
         pin = " @ %s" % args.at[:7] if args.at else ""
         out.ok("Tapped %s (%d items)%s" % (tap.name, len(entries), pin))
+    elif args.spec:
+        # Several specs clone through the same pool as --defaults/--catalog.
+        # This is not only a convenience: `xargs boost_cli tap < list` hands
+        # every line to ONE invocation, and rejecting the extras is how the
+        # shards workflow tapped nothing — argparse errored, `|| true`
+        # swallowed it, and the job died three steps later on "no taps
+        # configured". A multi-spec surface makes the natural script correct.
+        rc |= _tap_all(list(args.spec), jobs=args.jobs, curated=args.curated)
     # Refresh the TAB-completion name cache so `boost install <TAB>` sees
     # whatever this call just tapped instead of the pre-tap snapshot.
     complete.refresh_names()

{boost_skill_cli-1.2.51 → boost_skill_cli-1.2.53}/boost_cli/core/agents.py

@@ -8,7 +8,8 @@ from pathlib import Path
 from . import config, paths
 
 DISPLAY = {"claude-code": "Claude Code", "windsurf": "Windsurf",
-           "cursor": "Cursor", "gemini": "Gemini CLI"}
+           "cursor": "Cursor", "gemini": "Gemini CLI",
+           "antigravity": "Antigravity CLI"}
 
 
 def known_agents() -> dict[str, dict]:
@@ -22,6 +23,15 @@ def known_agents() -> dict[str, dict]:
             # implements the Agent Skills standard's `~/.agents/skills` path,
             # which most do not, so the symlink is the safe assumption.
             "links_skills": bool(spec.get("links_skills", True)),
+            # Defaults True: nearly every agent reads a repo-local copy of its
+            # own dotdir, so a project install lands in `<repo>/.claude/skills`
+            # and its siblings. False marks an agent whose project layout boost
+            # does not know — see :func:`project_agents`.
+            "project_scope": bool(spec.get("project_scope", True)),
+            # Defaults False: most agents take all three kinds. True marks an
+            # agent where only the skills surface is known — see
+            # :func:`materializing_agents`.
+            "skills_only": bool(spec.get("skills_only", False)),
         }
     return out
 
@@ -52,6 +62,45 @@ def linking_agents() -> dict[str, Path]:
             if s["enabled"] and s["links_skills"]}
 
 
+def project_agents() -> dict[str, Path]:
+    """Enabled agents whose *project* layout boost actually knows.
+
+    Project scope is derived from the agent's own dotdir
+    (``scopes.agent_root``: ``<repo>/.claude/skills/…``), which holds for every
+    agent whose skills dir is one level under a dotdir. Antigravity CLI's is
+    two — ``~/.gemini/antigravity-cli/skills`` — so the derivation would create
+    a dotless ``<repo>/antigravity-cli/`` that nothing reads, and boost would
+    report a coverage it does not have. Its documented project location is
+    inside ``~/.gemini/config/projects/``, which is not a repo-local directory
+    at all; until that is verified against the CLI, the honest answer is to
+    leave it out of project scope rather than invent a path for it.
+    """
+    return {n: s["dir"] for n, s in known_agents().items()
+            if s["enabled"] and s["project_scope"]}
+
+
+def agents_for_scope(base) -> dict[str, Path]:
+    """Enabled agents for user scope (``base is None``) or project scope."""
+    return enabled_agents() if base is None else project_agents()
+
+
+def materializing_agents(base=None) -> dict[str, Path]:
+    """Agents a *rule* or *workflow* may be written into.
+
+    A skill is a directory boost symlinks; a rule and a workflow are files
+    boost writes in a format the agent has to already read — a context file at
+    a known path, or a slash command in a known dir and syntax. So this set is
+    narrower than :func:`agents_for_scope`: an agent whose rule and workflow
+    formats have not been verified is skills-only, and writing a plausible file
+    into its config tree would claim a coverage that does not exist.
+
+    Antigravity CLI is the current case. Its rules arrive anyway, through the
+    ``gemini`` agent, which already writes the ``~/.gemini/GEMINI.md`` it reads.
+    """
+    return {n: d for n, d in agents_for_scope(base).items()
+            if not known_agents()[n]["skills_only"]}
+
+
 def native_store_agents() -> dict[str, Path]:
     """Enabled agents that read the canonical store without a symlink.
 

{boost_skill_cli-1.2.51 → boost_skill_cli-1.2.53}/boost_cli/core/config.py

@@ -28,6 +28,29 @@ DEFAULTS = {
         # symlink if that alias is ever narrowed.
         "gemini": {"dir": "~/.gemini/skills", "enabled": True,
                    "links_skills": False},
+        # Antigravity CLI (`agy`) is Gemini CLI's successor and shares its
+        # `~/.gemini` tree, but it does **not** implement the Agent Skills
+        # standard: it reads neither `~/.agents/skills` nor, for CLI scope,
+        # anything outside `~/.gemini/antigravity-cli/`. So unlike gemini it
+        # needs real symlinks — `links_skills` defaults true and stays true.
+        #
+        # Why the CLI-scoped dir and not the shared `~/.gemini/skills`: that
+        # shared dir is one of *Gemini CLI's* user-tier discovery paths, and
+        # Gemini already reads the same skills through the `~/.agents/skills`
+        # alias. Linking there would put one skill in two of Gemini's tiers and
+        # cost a "Skill conflict detected" line per skill per session — the
+        # exact failure `links_skills: false` exists to avoid. Linking into
+        # `antigravity-cli/skills` is invisible to Gemini and is the tier the
+        # CLI itself reads.
+        # `project_scope: false` — its skills dir is two levels under the
+        # dotdir, so the repo-local derivation would make a dotless
+        # `<repo>/antigravity-cli/` nothing reads. See agents.project_agents.
+        # `skills_only`: its rule and workflow formats are unverified, and a
+        # rule reaches it anyway through the `gemini` entry above, which writes
+        # the ~/.gemini/GEMINI.md Antigravity reads.
+        "antigravity": {"dir": "~/.gemini/antigravity-cli/skills",
+                        "enabled": True, "project_scope": False,
+                        "skills_only": True},
     },
     "taps": [],  # [{"name": "owner/repo", "url": "...", "curated": bool}]
     "ai": {

{boost_skill_cli-1.2.51 → boost_skill_cli-1.2.53}/boost_cli/core/mcphost.py

@@ -10,7 +10,22 @@ and I/O-free (like :mod:`boost_cli.core.mcpdecl`) so every branch is unit
 testable and reachable by the mutation gate; the command layer does the
 ``shutil.which`` probing and the ``subprocess.run``.
 
-The three ways the two grammars differ, all of them load-bearing:
+Antigravity CLI (``agy``) is the third host, and it is Gemini CLI's successor
+rather than a variant of it: Gemini is being deprecated in its favour. Its
+``add`` **upserts** where Claude's errors on a duplicate name, it has **no
+scope** (one global file at ``~/.gemini/config/mcp_config.json`` — it inherited
+Gemini's directory, so there is no ``~/.antigravity``), its off-switch is
+``enable``/``disable`` rather than removal, and it has no per-server ``get``.
+Its two argv rules come from its own help and both bite: **flags must precede
+the name**, and **``--`` must precede a command whose args start with ``-``**,
+or ``--stdio`` is eaten as an agy flag.
+
+That upsert-vs-error asymmetry is also why `boost mcp register --host auto`
+used to abort: Claude rejects the duplicate, and the sweep gave up before
+reaching the next agent. Against agy alone it would never have surfaced.
+
+The three ways the Claude and Gemini grammars differ, all of them
+load-bearing:
 
 * **Name position.** Both CLIs advertise the same usage string —
   ``[options] <name> <commandOrUrl> [args...]`` — so the shape is not the
@@ -68,12 +83,15 @@ LAUNCH_ENV = {
 
 CLAUDE = "claude"
 GEMINI = "gemini"
+AGY = "agy"
 
 # name -> {"cli": executable, "label": display name}. Order is the order hosts
-# are tried and reported in.
+# are tried and reported in; new hosts are appended so the existing order is
+# untouched.
 HOSTS: dict[str, dict] = {
     CLAUDE: {"cli": "claude", "label": "Claude Code"},
     GEMINI: {"cli": "gemini", "label": "Gemini CLI"},
+    AGY: {"cli": "agy", "label": "Antigravity CLI"},
 }
 
 
@@ -92,6 +110,17 @@ def label(host: str) -> str:
     return str(HOSTS[host]["label"])
 
 
+def has_scope(host: str) -> bool:
+    """True when this host's registrations are scoped at all.
+
+    Claude and Gemini keep local/user/project settings; agy keeps one global
+    file. Reporting "(scope: user)" for agy would describe a distinction its
+    CLI does not have — and would send anyone looking for a project-scoped
+    entry after something that cannot exist.
+    """
+    return host != AGY
+
+
 def _env_flags(env: dict[str, str] | None) -> list[str]:
     """``-e KEY=VALUE`` pairs, sorted so the argv is deterministic."""
     if not env:
@@ -113,6 +142,17 @@ def register_argv(host: str, launcher: str, *, scope: str = "user",
     """
     exe = cli(host)
     flags = _env_flags(LAUNCH_ENV if env is None else env)
+    if host == AGY:
+        # [flags] <name> <commandOrUrl> [args...], and both of its rules bite
+        # here. Flags must come BEFORE the name — a flag after it is rejected —
+        # and `--` must precede a command whose own args start with `-`, or
+        # `--stdio` is eaten as an agy flag rather than passed to boost. There
+        # is no scope: agy keeps one global file
+        # (~/.gemini/config/mcp_config.json, inherited from Gemini CLI — there
+        # is no ~/.antigravity), so passing `--scope` would be an error rather
+        # than a no-op.
+        return [exe, "mcp", "add", *flags, name,
+                "--", launcher, "mcp", "--stdio"]
     if host == GEMINI:
         # [options] <name> <commandOrUrl> [args...]. No `--`: yargs
         # `unknown-options-as-args` already carries `--stdio` into [args...],
@@ -135,6 +175,14 @@ def unregister_argv(host: str, *, scope: str = "user",
     exe = cli(host)
     if host == GEMINI:
         return [exe, "mcp", "remove", "--scope", scope, name]
+    if host == AGY:
+        # No scope flag: one global file. NOTE — `add`, `enable` and `disable`
+        # are the subcommands verified from agy's own help; `remove` mirrors
+        # Claude's and is the only shape that matches this command's meaning.
+        # If a release turns out not to have it, the failure is loud and names
+        # the argv, and `agy mcp disable boost` is the documented off-switch
+        # that keeps the entry.
+        return [exe, "mcp", "remove", name]
     return [exe, "mcp", "remove", name]
 
 

{boost_skill_cli-1.2.51 → boost_skill_cli-1.2.53}/boost_cli/core/store.py

@@ -604,8 +604,12 @@ def _install_project_skill(entry: dict, force: bool = False,
     src = source_dir_for(entry)
     _enforce_capability_policy(name, src / "SKILL.md")
     only_agents = preserved_agent_scope(only_agents, existing)
+    # agents_for_scope, not enabled_agents: project scope derives a repo-local
+    # dotdir from the agent's own, which holds for every agent whose skills dir
+    # sits one level under it. Antigravity's sits two, so it is excluded rather
+    # than given an invented `<repo>/antigravity-cli/`.
     targets = [(agent, scopes.skill_target(skills_dir, name, base=resolved_base))
-               for agent, skills_dir in agents.enabled_agents().items()
+               for agent, skills_dir in agents.agents_for_scope(resolved_base).items()
                if not only_agents or agent in only_agents]
 
     # Refuse to write through a symlink that leaves the repo. An agent dir like
@@ -836,7 +840,7 @@ def _install_rule(entry: dict, force: bool = False,
     paths.ensure_dirs()
     materializations: list[dict] = []
     linked: list[str] = []
-    for agent, skills_dir in agents.enabled_agents().items():
+    for agent, skills_dir in agents.materializing_agents(resolved_base).items():
         if only_agents and agent not in only_agents:
             continue
         mode, path = rules.rule_target(agent, skills_dir, name, base=resolved_base)
@@ -1070,7 +1074,7 @@ def _install_workflow(entry: dict, force: bool = False,
     paths.ensure_dirs()
     materializations: list[dict] = []
     linked: list[str] = []
-    for agent, skills_dir in agents.enabled_agents().items():
+    for agent, skills_dir in agents.materializing_agents(resolved_base).items():
         if only_agents and agent not in only_agents:
             continue
         path = workflows.workflow_target(skills_dir, slot, name,

{boost_skill_cli-1.2.51 → boost_skill_cli-1.2.53/boost_skill_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.51
+Version: 1.2.53
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0
@@ -54,7 +54,11 @@ Dynamic: license-file
 
 **Homebrew for AI coding skills.** boost finds, installs, and version-tracks skills
 from GitHub-hosted registries, and wires each one into Claude Code, Windsurf,
-Cursor and Gemini CLI in a single pass.
+Cursor, Gemini CLI and Antigravity CLI in a single pass.
+
+Antigravity CLI (`agy`) is wired up the same way: skills link into
+`~/.gemini/antigravity-cli/skills`, and `boost mcp register` reaches it through
+`agy mcp add` alongside Claude Code.
 
 ```bash
 pipx install boost-skill-cli
@@ -66,7 +70,7 @@ boost install tdd-workflow    # → every agent, version-pinned, one lock file
 (No `pipx` yet? macOS ships neither it nor a new enough Python — run the
 [prerequisites check](#prerequisites) first.)
 
-No more copying `SKILL.md` into four agent folders and forgetting which one is
+No more copying `SKILL.md` into five agent folders and forgetting which one is
 stale. The default install is pure stdlib, with no build step and no
 dependencies.
 

{boost_skill_cli-1.2.51 → boost_skill_cli-1.2.53}/boost_skill_cli.egg-info/SOURCES.txt

@@ -253,6 +253,8 @@ docs/roadmap/items/crash-reports-leak-api-keys.md
 docs/roadmap/items/demo-cannot-open-its-own-pr.md
 docs/roadmap/items/demo-gif-workflow-has-never-succeeded.md
 docs/roadmap/items/demo-workflow-cancels-other-prs.md
+docs/roadmap/items/dense-reindex-has-no-progress-or-durability.md
+docs/roadmap/items/dense-reindex-reuses-whole-taps.md
 docs/roadmap/items/dense-search-fallback-and-stale-tap-pruning.md
 docs/roadmap/items/dense-search-rescans-every-vector.md
 docs/roadmap/items/dependabot-missing-pip-ecosystem.md
@@ -336,6 +338,7 @@ docs/roadmap/items/markdownlint-lints-the-fuzz-corpus.md
 docs/roadmap/items/marketing-crm-domain-had-no-category.md
 docs/roadmap/items/mcp-already-covered-defeater.md
 docs/roadmap/items/mcp-aware-skills.md
+docs/roadmap/items/mcp-cannot-read-a-skill-before-installing.md
 docs/roadmap/items/mcp-check-skills-before-starting-a-task.md
 docs/roadmap/items/mcp-hub-diagram-node-text-overflow.md
 docs/roadmap/items/mcp-install-skips-the-injection-scan.md

{boost_skill_cli-1.2.51 → boost_skill_cli-1.2.53}/docs/commands.html

@@ -628,10 +628,10 @@
       <section class="cmd" id="cmd-tap" data-search="tap add a github repo as a skill registry  --defaults --catalog --type {skill,rule,workflow} --category category --limit n --include-lists --dry-run --curated --at sha --jobs n spec">
         <h3><span class="cname">tap</span><span class="gtag">tap</span></h3>
         <p class="summary">Add a GitHub repo as a skill registry</p>
-        <pre class="syn">boost tap [--defaults] [--catalog] [--type {skill,rule,workflow}] [--category CATEGORY] [--limit N] [--include-lists] [--dry-run] [--curated] [--at SHA] [--jobs N] [spec]</pre>
+        <pre class="syn">boost tap [--defaults] [--catalog] [--type {skill,rule,workflow}] [--category CATEGORY] [--limit N] [--include-lists] [--dry-run] [--curated] [--at SHA] [--jobs N] [spec ...]</pre>
         <div class="args-h">Arguments</div>
         <div class="args">
-          <div class="arg"><code>spec</code><span>owner/repo, a git URL, or a local directory</span></div>
+          <div class="arg"><code>spec</code><span>owner/repo, a git URL, or a local directory — several at once clone in parallel</span></div>
         </div>
         <div class="args-h">Options</div>
         <div class="args">
@@ -1117,7 +1117,7 @@
         </div>
         <div class="args-h">Options</div>
         <div class="args">
-          <div class="arg"><code>--host H</code><span>agent CLI to (un)register with: claude, gemini, or `auto` (default) for every one that is installed</span></div>
+          <div class="arg"><code>--host H</code><span>agent CLI to (un)register with: claude, gemini, agy, or `auto` (default) for every one that is installed</span></div>
           <div class="arg"><code>--stdio</code><span>run the MCP server on stdin/stdout (used by the agent)</span></div>
           <div class="arg"><code>--seed</code><span>top up any missing recommended registries even if others are already tapped (the repair path)</span></div>
           <div class="arg"><code>--no-seed</code><span>register only; do not tap anything</span></div>

{boost_skill_cli-1.2.51 → boost_skill_cli-1.2.53}/docs/index.html

@@ -565,7 +565,7 @@
     <p class="lede">
       Boost is a command-line package manager that <b>searches, installs, and
       manages AI skills</b> from GitHub-hosted registries — then wires
-      them into <b>Claude Code, Windsurf, Cursor and Gemini CLI</b> at once. One command
+      them into <b>Claude Code, Windsurf, Cursor, Gemini CLI and Antigravity CLI</b> at once. One command
       replaces the copy-paste-and-pray dance of setting up AI agent skills by hand.
     </p>
     <p class="lede prereq-note">
@@ -581,7 +581,7 @@
       <div class="stat reveal"><b>70,000+</b><span>Discoverable assets</span></div>
       <div class="stat reveal"><b>81</b><span>Commands · 8 groups</span></div>
       <div class="stat reveal"><b>7</b><span>Pre-tapped registries</span></div>
-      <div class="stat reveal"><b>4</b><span>AI agents supported</span></div>
+      <div class="stat reveal"><b>5</b><span>AI agents supported</span></div>
     </div>
 
     <nav class="jump" aria-label="Sections on this page">
@@ -831,7 +831,7 @@ facilitate structured divergent thinking:
         <div class="cap reveal" style="--ic-bg: rgba(96,165,250,.12); --ic-fg: #93c5fd;">
           <div class="ic">⇄</div>
           <h3>Multi-agent &amp; integration</h3>
-          <p>Install once, land in <b>Claude Code, Windsurf and Cursor</b>.</p>
+          <p>Install once, land in <b>Claude Code, Windsurf, Cursor and Antigravity CLI</b>.</p>
           <ul class="bullets">
             <li>Run as a native <b>MCP server</b>, so the agent can search for itself.</li>
             <li>Register a <code style="color:var(--cyan)">boost://</code> handler for

boost_skill_cli-1.2.53/docs/roadmap/items/dense-reindex-has-no-progress-or-durability.md

@@ -0,0 +1,93 @@
+---
+id: dense-reindex-has-no-progress-or-durability
+board: code
+section: internals
+status: shipped
+category: Observability · UX
+complexity: M
+impact: High
+wow: 3
+note: 5 h 33 m of silence, 18.26 GB RSS, nothing on disk
+order: 125
+owner:
+pr: 603
+title: "<code>reindex --dense</code> runs for hours behind a bare spinner, and a cancel discards all of it"
+---
+A keyless <code>boost reindex --dense</code> on a 465-tap / <b>63,003-entry</b> install ran
+<b>5&nbsp;h&nbsp;33&nbsp;m</b> and emitted exactly one thing the whole time:
+<code>⠏ embedding chunks into the dense store</code>. Nothing on the machine could answer
+&ldquo;how far along is it, and should I cancel?&rdquo; &mdash; three independent reasons, each
+separately fixable.
+
+<b>(1) The loop is holding the numbers and never prints them.</b> <code>_embed_and_store</code>'s
+batch loop (<code>dense.py:781</code>) has <code>start</code> and <code>len(order)</code> in scope
+&mdash; precisely the pair <code>spin.progress(current, total, label)</code> takes.
+That helper already exists in <code>boost_cli/spin.py</code>, is already TTY-gated so piped, CI and
+test output stay clean, and already has a caller <em>one module over</em> at
+<code>discovery.py:478</code>. So this is a one-line call into shipped, exercised code, not new
+machinery.
+
+<b>(2) <code>--debug</code> is a dead end on this path.</b> <code>dense.py</code> never constructs a
+logger, so <code>--debug</code>, <code>BOOST_DEBUG=1</code> and <code>BOOST_LOG_LEVEL=DEBUG</code>
+all produce the same bare spinner. <code>~/.boost/logs/boost.log</code> records <code>invoke:</code>
+and <code>done:</code> and nothing in between &mdash; which for a six-hour command is the one
+interval that matters.
+
+<b>(3) The store cannot serve as a proxy either, and that is the deeper defect.</b>
+<code>_embed_and_store</code> accumulates every vector into the <code>vec_of</code> dict and inserts
+nothing until the final batch returns (<code>dense.py:802</code>); <code>build()</code> then commits
+<b>once</b>, at <code>dense.py:535</code>. Measured across the entire run:
+<code>rag_vectors.sqlite</code> sat at <b>24,924,160 bytes</b> with its mtime unchanged and no
+<code>-journal</code> beside it. A user watching the file sees a dead process.
+
+The only thing that actually worked was reading the live frame:
+<code>sudo py-spy dump --pid &lt;pid&gt; --locals</code> &rarr; <code>start: 361216</code>. The
+<code>--locals</code> is load-bearing; a plain <code>dump</code> gives the function but not the
+position. From that one number: <b>361,216 distinct texts in 20,006 s = 18.1/s</b>, on
+<b>1 of 18 cores</b>, at <b>18.26 GB RSS</b> of 48 GB &mdash; <code>vec_of</code> grows
+monotonically and is never drained.
+
+<b>And <code>start</code> alone is still not an answer, which is the sharpest form of the bug.</b>
+A numerator without its denominator is not progress. <code>len(order)</code> is <em>not</em>
+printable from a py-spy dump, so establishing it meant re-deriving boost's own chunking over all 465
+cached catalogs out-of-process: <b>647,597 chunks spanning 390,978 distinct texts</b> (39.63%
+duplicates) from <b>62,041 entries across 457 fresh taps</b>. Only then does
+<code>start: 361216</code> resolve to <b>92.4% complete, ~27 min remaining</b>. Requiring a user to
+reimplement the chunker to read a percentage is the whole defect in one sentence &mdash; and the
+process already had both numbers in the same stack frame the entire time.
+
+<b>What the opacity actually costs.</b> Because the only commit is at the end, Ctrl-C rolls the whole
+transaction back; and <code>build()</code> records per-tap commits only <em>after</em>
+<code>_embed_and_store</code> returns, so a cancelled run records nothing and a re-run re-embeds from
+zero. The user is therefore asked to bet five and a half hours of CPU on a guess about whether a
+spinner is stuck. That is the real bug &mdash; the missing progress line is how it reaches them.
+
+<b>Fix, smallest first.</b>
+<b>(a)</b> <code>spin.progress(start, len(order), "embedding chunks")</code> in the batch loop.
+<b>(b)</b> A <code>logger.debug</code> per batch, so <code>--debug</code> leaves a trail a bug report
+can carry.
+<b>(c)</b> Stream rather than accumulate &mdash; embed a batch, insert it, commit every N &mdash;
+which bounds peak RSS instead of letting it reach tens of GB, and makes a cancel cost one batch
+rather than the whole run.
+<b>(c) is what makes (a) worth trusting</b>: a progress bar over work that evaporates on Ctrl-C is
+still a bad deal. Note (c) has to keep the current failure semantics &mdash; a tap whose batch the
+provider rejected must still not get a recorded commit, or one transient failure leaves that tap
+permanently marked built and empty.
+
+<b>(a) and (c) shipped in <code>#603</code>.</b> <code>dense.build</code> now takes
+<code>on_progress(done, total)</code>, called once before the first request so the size of the job is
+known up front and again after every batch &mdash; including a rejected one, or a run with a few
+provider errors would appear to stall. <code>discovery.py</code> feeds it into the existing spinner via
+<code>_embed_progress</code>. And <code>_embed_and_store</code> now commits every
+<code>_COMMIT_EVERY = 5000</code> rows instead of once at the end, so an interrupt costs one batch
+rather than the whole run. That is safe precisely because <code>build</code> deletes each changed
+tap's rows <em>before</em> re-inserting, so a partial store is replaced rather than doubled.
+
+<b>One detail worth keeping.</b> The progress total counts <b>distinct</b> texts, not rows. On this
+corpus 657,587 chunks reduce to 396,812 distinct (39.66% repeats, embedded once), so a total taken
+from the row count would over-report the work by two thirds and make the bar crawl.
+
+<b>Still open: (b).</b> <code>dense.py</code> constructs no logger, so <code>--debug</code>,
+<code>BOOST_DEBUG=1</code> and <code>BOOST_LOG_LEVEL=DEBUG</code> still produce no per-batch trail &mdash;
+fine interactively now that the spinner counts, but a piped or CI run still has nothing to attach to a
+bug report, and <code>spin.progress</code> is deliberately silent off a TTY.