boost-skill-cli 1.2.50__tar.gz → 1.2.52__tar.gz

{boost_skill_cli-1.2.50 → boost_skill_cli-1.2.52}/.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.50 → boost_skill_cli-1.2.52}/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.
@@ -534,6 +556,18 @@ Consequences for code you write here:
   the measured trade is **3.40 GB → 3.87 GB (+14%), in 1360 s**, peaking at
   ~2× while both copies coexist. Don't describe it as size-neutral — an earlier
   draft of this section did, from prediction rather than measurement.
+- **Embedding reports progress and commits as it goes.** `dense.build` takes
+  `on_progress(done, total)` and `_embed_and_store` commits every
+  `_COMMIT_EVERY` rows. Both are bug fixes, not polish: a full catalogue is
+  tens of thousands of distinct chunks under one fixed spinner label, which a
+  user reported as a hang after hours; and every row used to land in a single
+  transaction that committed after the last one, so an interrupt threw away the
+  whole build. Periodic commits are safe because `build` deletes each changed
+  tap's rows *before* re-inserting, so a partial store is replaced rather than
+  doubled. The total counts **distinct** texts, not rows — 42.9% of chunks on a
+  real install are repeats and are embedded once — so a progress total taken
+  from row count would over-report the work.
+
 - **Nothing on the search path may count `chunks`.** `SELECT COUNT(*)` scans the
   `chunks_tap` covering index — 8,419 pages / 34.5 MB, measured 1.94 s — and
   both `ready()` and `status()` did it on every search, the latter only to word

{boost_skill_cli-1.2.50/boost_skill_cli.egg-info → boost_skill_cli-1.2.52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.50
+Version: 1.2.52
 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.50 → boost_skill_cli-1.2.52}/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.50 → boost_skill_cli-1.2.52}/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.50'
-__version_tuple__ = version_tuple = (1, 2, 50)
+__version__ = version = '1.2.52'
+__version_tuple__ = version_tuple = (1, 2, 52)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.50 → boost_skill_cli-1.2.52}/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.50 → boost_skill_cli-1.2.52}/boost_cli/commands/discovery.py

@@ -388,8 +388,8 @@ def cmd_reindex(argv):
         # holds — count, stats, trending, plain search. See the import-budget
         # gate (scripts/import_budget.py).
         from ..core import embed
-        with spin.Spinner("embedding chunks into the dense store"):
-            dense_stats = _reindex_dense(args.force)
+        with spin.Spinner("embedding chunks into the dense store") as sp:
+            dense_stats = _reindex_dense(args.force, spinner=sp)
     if args.as_json:
         print(json.dumps({"bm25": stats, "dense": dense_stats}
                          if args.dense else stats))
@@ -434,7 +434,44 @@ def cmd_reindex(argv):
     return 0
 
 
-def _reindex_dense(force):
+def _embed_progress(spinner):
+    """A callback that rewrites the spinner's label with real numbers.
+
+    Embedding is the longest thing boost does — tens of thousands of distinct
+    chunks at roughly a second each for a full catalogue — and it ran under a
+    fixed label for hours. "embedding chunks into the dense store" is
+    indistinguishable from a hang, which is exactly how it was reported.
+
+    The rate comes from this run rather than a constant, because the two
+    backends differ by an order of magnitude and a local model's throughput
+    depends on the machine. Until a batch has finished there is nothing to
+    estimate from, so it says the total and nothing else rather than guessing.
+    """
+    started = time.monotonic()
+
+    def report(done: int, total: int) -> None:
+        if spinner is None or not total:
+            return
+        pct = 100.0 * done / total
+        # The bar first, because it is the part that answers the question the
+        # user actually has — "is this moving?" — at a glance, before any of
+        # the digits are read. `spin.bar` is the same determinate bar the rest
+        # of the CLI draws, so this looks like boost rather than like a
+        # second progress convention.
+        label = "embedding %s %d%% · %s/%s chunks" % (
+            spin.bar(done, total, width=16), int(pct),
+            format(done, ","), format(total, ","))
+        elapsed = time.monotonic() - started
+        if done and elapsed > 1:
+            remaining = (total - done) * (elapsed / done)
+            if remaining >= 1:
+                label += " · ~%s left" % util.human_duration(remaining)
+        spinner.label = label
+
+    return report
+
+
+def _reindex_dense(force, spinner=None):
     """Build the dense vector store; returns stats or None when unavailable."""
     # Local import: the dense/embedding engines are opt-in (`search --dense`),
     # so they stay out of startup for every other command in this module.
@@ -447,7 +484,7 @@ def _reindex_dense(force):
     # only what changed. Doing it after would quantize, then write float32 rows
     # into a store that no longer has a float32 table.
     migrated = dense.quantize()
-    stats = dense.build(force=force)
+    stats = dense.build(force=force, on_progress=_embed_progress(spinner))
     if migrated and isinstance(stats, dict):
         stats = stats | {"quantized": migrated["chunks"]}
     return stats

{boost_skill_cli-1.2.50 → boost_skill_cli-1.2.52}/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.50 → boost_skill_cli-1.2.52}/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.50 → boost_skill_cli-1.2.52}/boost_cli/core/dense.py

@@ -25,6 +25,11 @@ from .rag import Hit, chunk, entry_key, read_body
 
 INDEX_VERSION = 2
 _BATCH = 128            # texts per embedding request
+
+#: Rows between commits while storing vectors. Small enough that an interrupted
+#: build keeps almost everything it embedded, large enough that the commits are
+#: not the cost — on a 750k-chunk store this is ~150 commits.
+_COMMIT_EVERY = 5000
 _POOL = 8              # chunk over-fetch factor for KNN before per-entry reduce
 
 
@@ -462,12 +467,20 @@ def ready() -> bool:
         con.close()
 
 
-def build(entries: list[dict] | None = None,
-          force: bool = False) -> dict | None:
+def build(entries: list[dict] | None = None, force: bool = False,
+          on_progress=None) -> dict | None:
     """(Re)embed and store chunk vectors, reusing unchanged taps.
 
     Returns stats, or ``None`` if the backend or an embeddings provider is
     unavailable (nothing is written in that case).
+
+    ``on_progress(done, total)`` is called before the first batch and after
+    each one. It exists because this is the longest-running thing boost does —
+    a full catalogue is tens of thousands of distinct chunks at roughly a
+    second each — and it used to run under a bare spinner that said "embedding
+    chunks into the dense store" for hours without a number. A user cannot
+    tell that apart from a hang, and the honest fix is to say how many there
+    are and how far in we got.
     """
     from .rag import _tap_commits, _tap_paths
     if not have_backend() or not embed.available():
@@ -517,7 +530,8 @@ def build(entries: list[dict] | None = None,
         removed_taps = sorted(_indexed_taps(con) - {e["tap"] for e in entries})
         _delete_taps(con, changed_taps + removed_taps)
 
-        added, failed_taps = _embed_and_store(con, fresh, tap_paths)
+        added, failed_taps = _embed_and_store(con, fresh, tap_paths,
+                                             on_progress=on_progress)
         # Only record a commit for a tap whose chunks actually landed. Recording
         # one for a tap that stored nothing makes every later non-forced run
         # treat it as already built and skip it — one transient rate limit would
@@ -743,8 +757,8 @@ def _delete_taps(con: sqlite3.Connection, taps: list[str]) -> None:
 
 
 def _embed_and_store(con: sqlite3.Connection, entries: list[dict],
-                     tap_paths: dict[str, Path] | None
-                     ) -> tuple[int, set]:
+                     tap_paths: dict[str, Path] | None,
+                     on_progress=None) -> tuple[int, set]:
     """Embed every chunk of ``entries``; returns ``(added, failed_taps)``.
 
     A batch the provider rejects (rate limit, quota, oversized input) yields no
@@ -778,15 +792,31 @@ def _embed_and_store(con: sqlite3.Connection, entries: list[dict],
             order.append(text)
 
     vec_of: dict[str, object] = {}
+    if on_progress is not None:
+        # Reported before the first request, so the size of the job is known
+        # up front rather than inferred from how long it has already taken.
+        on_progress(0, len(order))
     for start in range(0, len(order), _BATCH):
         batch = order[start:start + _BATCH]
         vecs = embed.embed(batch, input_type="document")
-        if not vecs or len(vecs) != len(batch):
-            continue     # taps are attributed per row below, not per batch
-        vec_of.update(zip(batch, vecs, strict=True))
+        if vecs and len(vecs) == len(batch):
+            vec_of.update(zip(batch, vecs, strict=True))
+        # else: taps are attributed per row below, not per batch — but the
+        # progress count still advances, or a run with a few rejected batches
+        # would appear to stall.
+        if on_progress is not None:
+            on_progress(min(start + _BATCH, len(order)), len(order))
 
     added = 0
     failed_taps: set = set()
+    # Durability, not speed. Every row used to land in one transaction that
+    # committed only after the last one, so interrupting a three-hour build —
+    # or losing the machine to a sleep or an OOM — threw away every vector it
+    # had paid for. Committing as the rows accumulate keeps the work, and
+    # re-running is still correct because `_delete_taps` has already removed
+    # each changed tap's old rows, so a partial store is replaced rather than
+    # doubled.
+    since_commit = 0
     for e, ci, text in rows:
         vec = vec_of.get(text)
         if vec is None:
@@ -801,6 +831,11 @@ def _embed_and_store(con: sqlite3.Connection, entries: list[dict],
              e.get("kind", "skill"), ci, text[:200].strip()))
         _store_vector(con, cur.lastrowid, mod.serialize_float32(vec))
         added += 1
+        since_commit += 1
+        if since_commit >= _COMMIT_EVERY:
+            con.commit()
+            since_commit = 0
+    con.commit()
     return added, failed_taps
 
 

{boost_skill_cli-1.2.50 → boost_skill_cli-1.2.52}/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.50 → boost_skill_cli-1.2.52}/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.50 → boost_skill_cli-1.2.52}/boost_cli/core/util.py

@@ -168,6 +168,23 @@ def rel_time(iso: str) -> str:
     return then.strftime("%Y-%m-%d")
 
 
+def human_duration(seconds: float) -> str:
+    """A short, honest duration: ``'45s'``, ``'12m'``, ``'2h 5m'``.
+
+    Coarse on purpose. This labels an estimate that is extrapolated from a
+    partial run, so seconds of precision on a two-hour figure would claim an
+    accuracy the number does not have.
+    """
+    seconds = max(0, int(seconds))
+    if seconds < 60:
+        return "%ds" % seconds
+    minutes = seconds // 60
+    if minutes < 60:
+        return "%dm" % minutes
+    hours, minutes = divmod(minutes, 60)
+    return "%dh %dm" % (hours, minutes) if minutes else "%dh" % hours
+
+
 def human_size(n: int) -> str:
     """Format a byte count for humans: ``1536`` -> ``'1.5KB'``.
 

{boost_skill_cli-1.2.50 → boost_skill_cli-1.2.52/boost_skill_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.50
+Version: 1.2.52
 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.50 → boost_skill_cli-1.2.52}/boost_skill_cli.egg-info/SOURCES.txt

@@ -682,6 +682,7 @@ tests/unit/test_dense.py
 tests/unit/test_dense_embed_dedupe.py
 tests/unit/test_dense_fallback.py
 tests/unit/test_dense_fix_hint.py
+tests/unit/test_dense_progress.py
 tests/unit/test_dense_quantized.py
 tests/unit/test_dense_ready_order.py
 tests/unit/test_dense_shard_real_schema.py

{boost_skill_cli-1.2.50 → boost_skill_cli-1.2.52}/docs/commands.html

@@ -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>