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

{boost_skill_cli-1.2.51 → 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.51 → 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.

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

{boost_skill_cli-1.2.51 → 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.51 → 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.51 → 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.51 → 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.51 → 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.51 → 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.51
+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.51 → 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>

{boost_skill_cli-1.2.51 → boost_skill_cli-1.2.52}/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.51 → boost_skill_cli-1.2.52}/tests/bdd/features/mcp.feature

@@ -1,18 +1,19 @@
 Feature: boost mcp
   Register boost as an MCP server with every agent CLI that speaks MCP —
-  Claude Code and Gemini CLI. Never shells out to a real CLI in these
-  scenarios: shutil.which/subprocess.run are mocked.
+  Claude Code, Gemini CLI and Antigravity CLI. Never shells out to a real CLI
+  in these scenarios: shutil.which/subprocess.run are mocked.
 
   Background:
     Given a fresh boost environment
 
-  Scenario: registering with no agent CLI installed prints both manual commands
+  Scenario: registering with no agent CLI installed prints every manual command
     Given no agent CLI is on PATH
     When I run "boost mcp register"
     Then the exit code should be 0
-    And the output should contain "no agent CLI found (looked for: claude, gemini)"
+    And the output should contain "no agent CLI found (looked for: claude, gemini, agy)"
     And the output should contain "claude mcp add boost --scope user"
     And the output should contain "gemini mcp add --scope user"
+    And the output should contain "agy mcp add"
 
   Scenario: registering with only the claude CLI present succeeds
     Given the "claude" CLI is on PATH and succeeds
@@ -47,7 +48,7 @@ Feature: boost mcp
     When I run "boost mcp register --host bogus"
     Then the exit code should be 1
     And the output should contain "unknown MCP host 'bogus'"
-    And the output should contain "known hosts: claude, gemini"
+    And the output should contain "known hosts: claude, gemini, agy"
 
   Scenario: a claude mcp add failure surfaces the error
     Given the "claude" CLI is on PATH but fails with "no auth"

{boost_skill_cli-1.2.51 → boost_skill_cli-1.2.52}/tests/functional/test_cli_configuration.py

@@ -1344,12 +1344,14 @@ class TestMcp:
         assert "GitHub code search failed" in text
 
     # ── mcp register / unregister ────────────────────────────────────────
-    # boost registers itself with every agent CLI that speaks MCP, and the two
+    # boost registers itself with every agent CLI that speaks MCP, and the
     # grammars disagree on almost every detail: Claude wants
     # `add <name> [options] -- <command>` (its `-e` is variadic, so a name
     # placed after it is swallowed as another env var); Gemini wants
     # `add [options] <name> <commandOrUrl> [args...]` with no `--` (which its
-    # trailing variadic would capture and hand to boost as a literal argument).
+    # trailing variadic would capture and hand to boost as a literal argument);
+    # agy wants flags before the name, a `--` before the command, and has no
+    # scope flag at all (one global file).
     # Every test below captures the argv the fake CLI receives — an argv that
     # is merely plausible fails silently, on someone else's machine.
 
@@ -1389,6 +1391,15 @@ class TestMcp:
                 "-e", "no_proxy=*",
                 "boost", self._shim(), "mcp", "--stdio"]
 
+    def _agy_add(self):
+        # agy wants `add [flags] <name> [args...]`: flags must precede the
+        # name, and `--` must precede a command whose own args start with `-`,
+        # or `--stdio` is eaten as an agy flag. No scope flag — one global file.
+        return ["agy", "mcp", "add",
+                "-e", "OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES",
+                "-e", "no_proxy=*",
+                "boost", "--", self._shim(), "mcp", "--stdio"]
+
     def test_register_seeds_the_catalog_on_an_empty_machine(
             self, boost, sandbox, monkeypatch):
         # The point of the whole change: `boost mcp` is the only command a new
@@ -1616,14 +1627,16 @@ class TestMcp:
         calls = self._fake_clis(monkeypatch)          # no agent CLI on PATH
         r = boost("mcp", "register")
         assert calls == []                            # nothing was run
-        assert "no agent CLI found (looked for: claude, gemini)" in r.out
+        assert "no agent CLI found (looked for: claude, gemini, agy)" in r.out
         assert " ".join(self._claude_add()) in r.out
         assert " ".join(self._gemini_add()) in r.out
+        assert " ".join(self._agy_add()) in r.out
         assert journal.events(action="mcp")[0]["hosts"] == ""
 
         r = boost("mcp", "unregister")
         assert "claude mcp remove boost" in r.out
         assert "gemini mcp remove --scope user boost" in r.out
+        assert "agy mcp remove boost" in r.out
         assert journal.events(action="mcp")[0]["subject"] == "unregister"
 
     def test_explicit_host_registers_only_that_host(self, boost, sandbox,
@@ -1659,12 +1672,14 @@ class TestMcp:
                 "(scope: user)") in r.out
         assert "`gemini` CLI not found — run this yourself:" in r.out
         assert " ".join(self._gemini_add()) in r.out
+        assert "`agy` CLI not found — run this yourself:" in r.out
+        assert " ".join(self._agy_add()) in r.out
 
     def test_unknown_host_rc1(self, boost, sandbox, monkeypatch):
         self._fake_clis(monkeypatch, "claude", "gemini")
         r = boost("mcp", "register", "--host", "bogus", expect=1)
         assert "unknown MCP host 'bogus'" in r.err
-        assert "known hosts: claude, gemini" in r.err
+        assert "known hosts: claude, gemini, agy" in r.err
 
     def test_unregister_uses_each_hosts_grammar(self, boost, sandbox,
                                                 monkeypatch):

{boost_skill_cli-1.2.51 → boost_skill_cli-1.2.52}/tests/functional/test_cli_info.py

@@ -89,7 +89,8 @@ class TestList:
         assert e["tap"] == "fixture-tap"
         # the lock records real symlinks only, so gemini (which reads the
         # canonical store directly) is absent by design
-        assert e["agents"] == ["claude-code", "windsurf", "cursor"]
+        assert e["agents"] == ["claude-code", "windsurf", "cursor",
+                               "antigravity"]
         assert e["pinned"] is False
 
     def test_tag_filter(self, boost, tapped):

{boost_skill_cli-1.2.51 → boost_skill_cli-1.2.52}/tests/functional/test_cli_pkg.py

@@ -96,7 +96,7 @@ class TestInstall:
     def test_exact_report_lines(self, boost, tapped):
         r = boost("install", "brainstorming")
         assert "copied to ~/.agents/skills/brainstorming" in r.out
-        assert "linked → claude-code · windsurf · cursor" in r.out
+        assert "linked → claude-code · windsurf · cursor · antigravity" in r.out
         # gemini reads the canonical store directly: no symlink, but the report
         # must still say the skill reached it
         assert "available to Gemini CLI (reads the store directly)" in r.out
@@ -109,7 +109,8 @@ class TestInstall:
         assert entry["version"] == "1.4.0"
         assert entry["tap"] == "fixture-tap"
         # the lock records real symlinks only — gemini needs none
-        assert entry["agents"] == ["claude-code", "windsurf", "cursor"]
+        assert entry["agents"] == ["claude-code", "windsurf", "cursor",
+                                   "antigravity"]
         assert entry["pinned"] is False and entry["quarantined"] is False
         assert not (paths.home() / ".gemini" / "skills").exists()
 
@@ -201,6 +202,25 @@ class TestInstall:
         assert not (home / ".gemini" / "skills" / "brainstorming").exists()
         assert _lock()["brainstorming"]["agents"] == ["claude-code"]
 
+    def test_antigravity_gets_a_real_symlink(self, boost, tapped):
+        # Antigravity CLI shares Gemini's ~/.gemini tree but does not read the
+        # canonical store, so unlike Gemini it needs the link — into its own
+        # CLI tier, never the shared ~/.gemini/skills that Gemini also reads.
+        boost("install", "brainstorming")
+        home = paths.home()
+        link = home / ".gemini" / "antigravity-cli" / "skills" / "brainstorming"
+        assert link.is_symlink()
+        assert link.resolve() == (paths.store_dir() / "brainstorming").resolve()
+        assert not (home / ".gemini" / "skills" / "brainstorming").exists()
+
+    def test_agent_flag_can_target_antigravity_alone(self, boost, tapped):
+        r = boost("install", "brainstorming", "--agent", "antigravity")
+        assert "linked → antigravity" in r.out
+        home = paths.home()
+        assert (home / ".gemini" / "antigravity-cli" / "skills"
+                / "brainstorming").is_symlink()
+        assert not (home / ".claude" / "skills" / "brainstorming").exists()
+
     def test_unknown_agent_rc1(self, boost, tapped):
         r = boost("install", "brainstorming", "--agent", "emacs", expect=1)
         assert "unknown agent: emacs" in r.err
@@ -1122,9 +1142,10 @@ class TestInstallEdges:
         r = boost("install", "brainstorming")
         assert ("not linked: ~/.claude/skills/brainstorming exists and is "
                 "not managed by boost") in r.out
-        assert "linked → windsurf · cursor" in r.out
+        assert "linked → windsurf · cursor · antigravity" in r.out
         assert "available to Gemini CLI (reads the store directly)" in r.out
-        assert _lock()["brainstorming"]["agents"] == ["windsurf", "cursor"]
+        assert _lock()["brainstorming"]["agents"] == ["windsurf", "cursor",
+                                                      "antigravity"]
         assert blocker.is_dir() and not blocker.is_symlink()
 
     def test_path_picks_between_two_same_named_skills(self, boost, tapped):
@@ -1161,7 +1182,7 @@ class TestInstallEdges:
         cfg = json.loads(paths.config_path().read_text(encoding="utf-8"))
         cfg["agents"] = {a: {"enabled": False}
                          for a in ("claude-code", "windsurf", "cursor",
-                                   "gemini")}
+                                   "gemini", "antigravity")}
         paths.config_path().write_text(json.dumps(cfg), encoding="utf-8")
         r = boost("install", "brainstorming")
         assert "no agent links created (no enabled agents?)" in r.out
@@ -1201,7 +1222,9 @@ class TestSyncJson:
         JSON round-trips the (skill, agent) tuples as lists.
         """
         boost("install", "brainstorming", "--force", "--agent", "cursor")
-        stray = [["brainstorming", "claude-code"], ["brainstorming", "windsurf"]]
+        stray = [["brainstorming", "antigravity"],
+                 ["brainstorming", "claude-code"],
+                 ["brainstorming", "windsurf"]]
 
         plan = json.loads(boost("sync", "--diff", "--json").out)
         assert sorted(plan["out_of_scope_links"]) == stray