boost-skill-cli 1.0.293__tar.gz → 1.0.294__tar.gz

{boost_skill_cli-1.0.293 → boost_skill_cli-1.0.294}/.vale/styles/config/vocabularies/boost/accept.txt

@@ -4,6 +4,7 @@ argparse
 bmad
 bookended
 CI's
+CLIs
 Codecov
 codespell
 config
@@ -13,6 +14,7 @@ Dependabot
 deps
 Dev
 docsite
+dotdir
 DSPy
 else's
 env
@@ -67,6 +69,7 @@ toolkits
 traceback
 tracebacks
 unkilled
+unregister
 unstaged
 untap
 vendored

{boost_skill_cli-1.0.293 → boost_skill_cli-1.0.294}/CLAUDE.md

@@ -186,8 +186,33 @@ work in tests and the dev loop:
 ~/.agents/skills/                canonical store — single source of truth for installed skills
 ~/.agents/skills/.skill-lock.json   v3 lock file
 ~/.claude/skills/  ~/.windsurf/skills/  ~/.cursor/skills/   symlinked out from the canonical store
+~/.gemini/                       rules (GEMINI.md) + workflows only — see below
 ```
 
+**Four agent targets, but only three get 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
+the `.agents` alias out-ranks whatever we linked, costing the user a "Skill
+conflict detected" line per skill per session and buying nothing. Consequences
+for code you write:
+
+- Iterate `agents.linking_agents()` for anything symlink-shaped (link, unlink,
+  stale-link sweeps, coverage counts). `agents.enabled_agents()` is still right
+  for rules and workflows, which materialize into `~/.gemini/` like any other
+  agent's dotdir. `agents.native_store_agents()` is the complement, for reporting.
+- 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
+  `workflows.TOML_COMMAND_AGENTS` marks agents whose slash commands are TOML.
+  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
+  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.
+
 `core/catalog.scan_dir` walks a tap's clone and classifies each file into one
 of the three item kinds (see Non-obvious rules above); `core/store.py` owns
 install, uninstall and sync — copying into the canonical store, symlinking into

{boost_skill_cli-1.0.293/boost_skill_cli.egg-info → boost_skill_cli-1.0.294}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.293
+Version: 1.0.294
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE
@@ -726,7 +726,7 @@ 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, and Cursor** in a single pass.
+Windsurf, Cursor, and Gemini CLI** in a single pass.
 
 ```bash
 pipx install boost-skill-cli
@@ -735,7 +735,7 @@ boost search tdd              # full-content BM25 over every skill
 boost install tdd-workflow    # → every agent, version-pinned, one lock file
 ```
 
-No more copying `SKILL.md` into three agent folders and forgetting which one is
+No more copying `SKILL.md` into four agent folders and forgetting which one is
 stale. The default install is **zero-dependency** — pure stdlib, no build step.
 
 <p align="center">
@@ -838,6 +838,13 @@ GitHub registries  ──boost update──▶  ~/.boost/repos/    (shallow clon
                    ────symlinks───▶  ~/.claude/skills/  ~/.windsurf/skills/  ~/.cursor/skills/
 ```
 
+Gemini CLI is the one agent that needs no symlink: it implements the
+[Agent Skills](https://agentskills.io) standard and discovers `~/.agents/skills`
+— boost's canonical store — directly. Linking into `~/.gemini/skills` as well
+would put the same skill in two of its discovery tiers, so boost deliberately
+doesn't (`agents.gemini.links_skills` is `false`; flip it to `true` if you ever
+need the copy). Rules and workflows still materialize under `~/.gemini/`.
+
 ### User scope vs project scope
 
 That's the default — **user scope**, the skills you want everywhere. The other
@@ -912,6 +919,37 @@ available on your PATH (or `ANTHROPIC_API_KEY` is set), and fall back to
 plain heuristics when it isn't — so the tool still works without an API key,
 just less cleverly.
 
+## boost as an MCP server
+
+boost is itself an MCP server, so an agent can search and install skills mid-task
+instead of waiting for you to shell out. `boost mcp register` wires it into every
+agent CLI it finds on your PATH:
+
+```bash
+boost mcp register                 # every installed host (default: --host auto)
+boost mcp register --host gemini   # just one
+boost mcp unregister               # same host selection, in reverse
+```
+
+| Host | CLI | Registered in |
+|------|-----|---------------|
+| Claude Code | `claude` | `claude mcp add` → its user-scope MCP config |
+| Gemini CLI | `gemini` | `gemini mcp add -s user` → `~/.gemini/settings.json` (`mcpServers`) |
+
+A host whose CLI isn't installed is skipped, not an error — name it explicitly
+(`--host gemini`) to have boost print the command for you to run later.
+
+Six tools are exposed: `boost_search`, `boost_list`, `boost_info`,
+`boost_install`, `boost_doctor`, and `boost_discover_github`. The server also
+returns MCP `instructions`, which both hosts load into the model's context — it
+tells the agent *when* boost is relevant, so a matching skill gets found at the
+start of a task rather than after the work is already reconstructed by hand.
+
+Verify the wiring with `claude mcp list` or `gemini mcp list` — boost should show
+as **Connected**. (Gemini only connects stdio servers in a trusted folder; run
+`gemini` once in the directory and accept the trust prompt if it shows
+`Disabled`.)
+
 ## Claude Code hooks & the BMAD Method
 
 `boost hooks` manages Claude Code hooks in `settings.json` at either scope —

{boost_skill_cli-1.0.293 → boost_skill_cli-1.0.294}/README.md

@@ -10,7 +10,7 @@
 
 **Homebrew for AI coding skills.** boost finds, installs, and version-tracks
 skills from GitHub-hosted registries — and wires each one into **Claude Code,
-Windsurf, and Cursor** in a single pass.
+Windsurf, Cursor, and Gemini CLI** in a single pass.
 
 ```bash
 pipx install boost-skill-cli
@@ -19,7 +19,7 @@ boost search tdd              # full-content BM25 over every skill
 boost install tdd-workflow    # → every agent, version-pinned, one lock file
 ```
 
-No more copying `SKILL.md` into three agent folders and forgetting which one is
+No more copying `SKILL.md` into four agent folders and forgetting which one is
 stale. The default install is **zero-dependency** — pure stdlib, no build step.
 
 <p align="center">
@@ -122,6 +122,13 @@ GitHub registries  ──boost update──▶  ~/.boost/repos/    (shallow clon
                    ────symlinks───▶  ~/.claude/skills/  ~/.windsurf/skills/  ~/.cursor/skills/
 ```
 
+Gemini CLI is the one agent that needs no symlink: it implements the
+[Agent Skills](https://agentskills.io) standard and discovers `~/.agents/skills`
+— boost's canonical store — directly. Linking into `~/.gemini/skills` as well
+would put the same skill in two of its discovery tiers, so boost deliberately
+doesn't (`agents.gemini.links_skills` is `false`; flip it to `true` if you ever
+need the copy). Rules and workflows still materialize under `~/.gemini/`.
+
 ### User scope vs project scope
 
 That's the default — **user scope**, the skills you want everywhere. The other
@@ -196,6 +203,37 @@ available on your PATH (or `ANTHROPIC_API_KEY` is set), and fall back to
 plain heuristics when it isn't — so the tool still works without an API key,
 just less cleverly.
 
+## boost as an MCP server
+
+boost is itself an MCP server, so an agent can search and install skills mid-task
+instead of waiting for you to shell out. `boost mcp register` wires it into every
+agent CLI it finds on your PATH:
+
+```bash
+boost mcp register                 # every installed host (default: --host auto)
+boost mcp register --host gemini   # just one
+boost mcp unregister               # same host selection, in reverse
+```
+
+| Host | CLI | Registered in |
+|------|-----|---------------|
+| Claude Code | `claude` | `claude mcp add` → its user-scope MCP config |
+| Gemini CLI | `gemini` | `gemini mcp add -s user` → `~/.gemini/settings.json` (`mcpServers`) |
+
+A host whose CLI isn't installed is skipped, not an error — name it explicitly
+(`--host gemini`) to have boost print the command for you to run later.
+
+Six tools are exposed: `boost_search`, `boost_list`, `boost_info`,
+`boost_install`, `boost_doctor`, and `boost_discover_github`. The server also
+returns MCP `instructions`, which both hosts load into the model's context — it
+tells the agent *when* boost is relevant, so a matching skill gets found at the
+start of a task rather than after the work is already reconstructed by hand.
+
+Verify the wiring with `claude mcp list` or `gemini mcp list` — boost should show
+as **Connected**. (Gemini only connects stdio servers in a trusted folder; run
+`gemini` once in the directory and accept the trust prompt if it shows
+`Disabled`.)
+
 ## Claude Code hooks & the BMAD Method
 
 `boost hooks` manages Claude Code hooks in `settings.json` at either scope —

{boost_skill_cli-1.0.293 → boost_skill_cli-1.0.294}/boost_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.293'
-__version_tuple__ = version_tuple = (1, 0, 293)
+__version__ = version = '1.0.294'
+__version_tuple__ = version_tuple = (1, 0, 294)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.293 → boost_skill_cli-1.0.294}/boost_cli/cli.py

@@ -123,7 +123,7 @@ COMMANDS = [
     ("completions", "cfg", "configuration", "Generate shell tab-completion scripts"),
     ("schedule",    "cfg", "configuration", "Manage automatic skill-sync scheduling"),
     ("serve",       "cfg", "configuration", "Serve the skill catalog over HTTP (port 8787)"),
-    ("mcp",         "cfg", "configuration", "Register boost as an MCP server for Claude Code"),
+    ("mcp",         "cfg", "configuration", "Register boost as an MCP server (Claude Code, Gemini CLI)"),
     ("hooks",       "cfg", "hooks", "Manage Claude Code hooks (scope-aware) in settings.json"),
     ("bmad",        "cfg", "bmad", "Install & manage the BMAD Method (scope-aware, toggleable)"),
     ("self-update", "cfg", "configuration", "Update boost itself to the latest version"),

{boost_skill_cli-1.0.293 → boost_skill_cli-1.0.294}/boost_cli/commands/configuration.py

@@ -24,6 +24,7 @@ from ..core import (
     journal,
     lockfile,
     mcp,
+    mcphost,
     paths,
     policy,
     rag,
@@ -870,8 +871,16 @@ def _tool_install(args: dict):
     res = store.install(entry)
     lines = ["installed %s v%s from %s → %s"
              % (res.name, entry.get("version", "?"), entry["tap"], res.dest),
-             "linked agents: %s" % (", ".join(res.linked) or "none"),
-             "quality score: %d/100" % res.score]
+             "linked agents: %s" % (", ".join(res.linked) or "none")]
+    # Without this an agent that reads the canonical store — Gemini CLI — sees
+    # only "linked agents: claude-code, windsurf, cursor", concludes the skill
+    # did not reach *it*, and goes back to reconstructing the work by hand.
+    # That is the exact failure this tool exists to prevent, so the line says
+    # plainly that the skill is already usable.
+    if res.native:
+        lines.append("available without linking (reads %s directly): %s"
+                     % (res.dest.parent, ", ".join(res.native)))
+    lines.append("quality score: %d/100" % res.score)
     if res.conflicts:
         lines.append("conflicts (left in place): %s" % ", ".join(res.conflicts))
     # The same prompt-injection and secret scan `boost install` runs. This path
@@ -1004,59 +1013,89 @@ def _mcp_tool(tool: str, args: dict):
     return REGISTRY.call(tool, args)
 
 
+def _run_mcp_host(host: str, action: str, cmd) -> bool:
+    """Run one host's register/unregister argv. True if it actually ran.
+
+    A host whose CLI is not installed is *not* an error — most machines have
+    one agent CLI, not all of them — so the argv is printed for the user to run
+    later and the caller moves on to the next host. A CLI that is present and
+    fails is a real error and raises.
+    """
+    exe = mcphost.cli(host)
+    if not shutil.which(exe):
+        return False
+    try:
+        proc = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
+    except (OSError, subprocess.TimeoutExpired) as e:
+        raise BoostError("%s mcp %s failed: %s" % (exe, action, e),
+                        hint="run it yourself: " + " ".join(cmd)) from e
+    for ln in (proc.stdout or "").strip().splitlines():
+        out.info(ln)
+    if proc.returncode != 0:
+        tail = (proc.stderr or "").strip().splitlines()
+        raise BoostError("%s mcp %s failed: %s"
+                        % (exe, action, tail[-1] if tail else "unknown error"),
+                        hint="run it yourself: " + " ".join(cmd))
+    return True
+
+
 def cmd_mcp(argv) -> int:
-    """boost mcp [register|unregister] [--stdio]"""
+    """boost mcp [register|unregister] [--host H] [--stdio]"""
     p = cliparse.parser(
         prog="boost mcp",
-        description="Register boost as an MCP server for Claude Code")
+        description="Register boost as an MCP server for your agent CLIs")
     p.add_argument("action", nargs="?", default="register",
                    choices=("register", "unregister"),
                    help="what to do (default: register)")
+    p.add_argument("--host", metavar="H", default="auto",
+                   help="agent CLI to (un)register with: %s, or `auto` "
+                        "(default) for every one that is installed"
+                        % ", ".join(mcphost.hosts()))
     p.add_argument("--stdio", action="store_true",
-                   help="run the MCP server on stdin/stdout (used by Claude Code)")
+                   help="run the MCP server on stdin/stdout (used by the agent)")
     args = p.parse_args(argv)
 
     if args.stdio:
         return mcp.serve_stdio(REGISTRY, version=__version__)
 
-    shim = paths.launcher()
-    if args.action == "register":
-        # Fork-safe launch env: a host that fork()s into `boost mcp --stdio`
-        # on macOS can SIGABRT on the child side *pre-exec* if Obj-C is touched
-        # post-fork (CFPreferences / _scproxy proxy lookup). Disabling the
-        # fork-safety trap and short-circuiting proxy resolution keeps the
-        # host's fork into boost from aborting before our Python ever runs.
-        #
-        # The server name ("boost") MUST come before the `-e` flags: `claude`'s
-        # `-e` is variadic, so a name placed after it is swallowed as another
-        # env var ("Invalid environment variable format: boost"). Order is
-        # `add <name> [options] -- <command>`.
-        cmd = ["claude", "mcp", "add", "boost", "--scope", "user",
-               "-e", "OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES",
-               "-e", "no_proxy=*",
-               "--", str(shim), "mcp", "--stdio"]
-    else:
-        cmd = ["claude", "mcp", "remove", "boost"]
-
-    if shutil.which("claude"):
-        try:
-            proc = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
-        except (OSError, subprocess.TimeoutExpired) as e:
-            raise BoostError("claude mcp %s failed: %s" % (args.action, e),
-                            hint="run it yourself: " + " ".join(cmd)) from e
-        for ln in (proc.stdout or "").strip().splitlines():
-            out.info(ln)
-        if proc.returncode != 0:
-            tail = (proc.stderr or "").strip().splitlines()
-            raise BoostError("claude mcp %s failed: %s"
-                            % (args.action, tail[-1] if tail else "unknown error"),
-                            hint="run it yourself: " + " ".join(cmd))
-        out.ok("%sed boost as an MCP server (scope: user)"
-               % ("register" if args.action == "register" else "unregister"))
-    else:
-        out.warn("`claude` CLI not found — run this yourself:")
-        out.info(" ".join(cmd))
-    journal.log("mcp", args.action)
+    try:
+        targets = mcphost.resolve(args.host)
+    except KeyError as e:
+        raise BoostError("unknown MCP host %r" % args.host,
+                        hint="known hosts: %s" % ", ".join(mcphost.hosts())) from e
+
+    shim = str(paths.launcher())
+    # `auto` skips hosts that are not installed; naming a host explicitly (or
+    # `all`) always reports it, so a user setting up a machine can see the argv
+    # for an agent CLI they have not installed yet.
+    explicit = args.host not in (None, "", "auto")
+    done, missing = [], []
+    for host in targets:
+        cmd = mcphost.argv(host, args.action, shim)
+        if _run_mcp_host(host, args.action, cmd):
+            done.append(host)
+        else:
+            missing.append(host)
+            if explicit:
+                out.warn("`%s` CLI not found — run this yourself:"
+                         % mcphost.cli(host))
+                out.info(" ".join(cmd))
+
+    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)))
+    if not done:
+        # Nothing ran. Under `auto` nothing has been printed yet, so say which
+        # CLIs were looked for rather than exiting silently on success.
+        if not explicit:
+            out.warn("no agent CLI found (looked for: %s)"
+                     % ", ".join(mcphost.cli(h) for h in missing))
+            for host in missing:
+                out.info(" ".join(mcphost.argv(host, args.action, shim)))
+        journal.log("mcp", args.action, hosts="")
+        return 0
+    journal.log("mcp", args.action, hosts=",".join(done))
     return 0
 
 

{boost_skill_cli-1.0.293 → boost_skill_cli-1.0.294}/boost_cli/commands/pkg.py

@@ -112,9 +112,13 @@ def _offer_mcp(res: store.InstallResult, no_mcp: bool = False) -> None:
     is stated at install time, and boost offers to run the registration for the
     servers that came with a runnable spec.
 
-    Advisory, never fatal: a declined prompt, a missing ``claude`` CLI or a failed
+    Advisory, never fatal: a declined prompt, a missing agent CLI or a failed
     registration all leave the skill installed. Suppressed by ``--no-mcp`` (passed
     down as ``no_mcp``) or by exporting ``BOOST_NO_MCP_OFFER``.
+
+    The offer targets whichever agent CLIs are actually installed, so a machine
+    with only Gemini CLI is offered ``gemini mcp add`` rather than a ``claude``
+    command it cannot run.
     """
     rows = res.mcp_servers
     if not rows or no_mcp or os.environ.get("BOOST_NO_MCP_OFFER"):
@@ -132,22 +136,30 @@ def _offer_mcp(res: store.InstallResult, no_mcp: bool = False) -> None:
         # Name-only declarations: boost will not invent a command line.
         out.dim("  install these yourself, then `boost mcp register`")
         return
-    if not out.confirm("register %s with Claude Code now?"
-                       % _plural(len(wirable), "server"), default=False):
-        out.dim("  skipped — `claude mcp add …` when you're ready")
+    from ..core import mcphost
+    # Offer the CLIs that are actually here. With none installed we still fall
+    # back to the full list so the manual command lines get printed.
+    targets = [h for h in mcphost.hosts() if shutil.which(mcphost.cli(h))] \
+        or mcphost.hosts()
+    where = " · ".join(mcphost.label(h) for h in targets)
+    if not out.confirm("register %s with %s now?"
+                       % (_plural(len(wirable), "server"), where), default=False):
+        out.dim("  skipped — `%s mcp add …` when you're ready"
+                % mcphost.cli(targets[0]))
         return
     for row in wirable:
-        _register_mcp_server(row["name"], row["spec"])
+        for host in targets:
+            _register_mcp_server(row["name"], row["spec"], host=host)
 
 
-def _register_mcp_server(name: str, spec: dict) -> None:
-    """Run one `claude mcp add` for a skill-declared server. Never raises."""
+def _register_mcp_server(name: str, spec: dict, host: str = "claude") -> None:
+    """Run one `<host> mcp add` for a skill-declared server. Never raises."""
     import subprocess
 
-    from ..core import mcpdecl
-    argv = mcpdecl.register_argv(name, spec)
-    if not shutil.which("claude"):
-        out.warn("`claude` CLI not found — run this yourself:")
+    from ..core import mcpdecl, mcphost
+    argv = mcpdecl.register_argv(name, spec, host=host)
+    if not shutil.which(mcphost.cli(host)):
+        out.warn("`%s` CLI not found — run this yourself:" % mcphost.cli(host))
         out.info("  " + " ".join(argv))
         return
     try:
@@ -162,8 +174,8 @@ def _register_mcp_server(name: str, spec: dict) -> None:
                  % (name, tail[-1] if tail else "unknown error"))
         out.info("  run it yourself: " + " ".join(argv))
         return
-    out.ok("registered MCP server %s" % name)
-    journal.log("mcp-register", name)
+    out.ok("registered MCP server %s with %s" % (name, mcphost.label(host)))
+    journal.log("mcp-register", name, host=host)
 
 
 def _report_result(res: store.InstallResult, no_mcp: bool = False) -> None:
@@ -191,8 +203,13 @@ def _report_result(res: store.InstallResult, no_mcp: bool = False) -> None:
     out.ok("copied to %s" % _tilde(res.dest))
     if res.linked:
         out.ok("linked → %s" % " · ".join(res.linked))
-    else:
+    elif not res.native:
         out.warn("no agent links created (no enabled agents?)")
+    # Agents that read the canonical store need no link, but saying nothing
+    # would make a Gemini-only install look like it reached no agent at all.
+    if res.native:
+        out.ok("available to %s (reads the store directly)"
+               % " · ".join(agents.display_name(a) for a in res.native))
     for path in res.conflicts:
         out.warn("not linked: %s exists and is not managed by boost" % _tilde(path))
     out.ok("lock updated (.skill-lock.json)")

{boost_skill_cli-1.0.293 → boost_skill_cli-1.0.294}/boost_cli/commands/quality.py

@@ -605,7 +605,9 @@ def cmd_heal(argv):
     dry = args.dry_run
     actions: List[str] = []
 
-    wanted = [paths.boost_home(), paths.repos_dir(), paths.cache_dir(), paths.logs_dir(), paths.state_dir(), paths.snapshots_dir(), paths.lock_history_dir(), paths.profiles_dir(), paths.store_dir(), *list(agents.enabled_agents().values())]
+    # linking_agents, matching agents.ensure_agent_dirs below: a native-store
+    # agent's skills dir is never written to, so it is not a missing directory.
+    wanted = [paths.boost_home(), paths.repos_dir(), paths.cache_dir(), paths.logs_dir(), paths.state_dir(), paths.snapshots_dir(), paths.lock_history_dir(), paths.profiles_dir(), paths.store_dir(), *list(agents.linking_agents().values())]
     missing = [d for d in wanted if not d.is_dir()]
     if missing:
         if dry:
@@ -818,7 +820,7 @@ def cmd_health(argv):
 
     expected = [n for n, e in installed if not e.get("quarantined")]
     coverage_ok = True
-    for agent, adir in agents.enabled_agents().items():
+    for agent, adir in agents.linking_agents().items():
         linked = sum(1 for n in expected
                      if (adir / n).is_symlink() and (adir / n).exists())
         full = linked == len(expected)
@@ -826,6 +828,13 @@ def cmd_health(argv):
         out.kv(agent, "%d/%d %s" % (linked, len(expected),
                                     out.role("✓", "success") if full
                                     else out.role("!", "warn")))
+    # Agents that read the canonical store have no links to count — scoring
+    # them 0/N would report a healthy setup as broken. They are listed anyway,
+    # because an agent silently absent from a health report reads as "boost is
+    # not wired up for it".
+    for agent in agents.native_store_agents():
+        out.kv(agent, "%d/%d %s (reads the store directly)"
+               % (len(expected), len(expected), out.role("✓", "success")))
 
     drift_counts: dict = {}
     for name, entry in installed:

boost_skill_cli-1.0.294/boost_cli/core/agents.py

@@ -0,0 +1,80 @@
+"""AI agent targets: where installed skills get symlinked."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict
+
+from . import config, paths
+
+DISPLAY = {"claude-code": "Claude Code", "windsurf": "Windsurf",
+           "cursor": "Cursor", "gemini": "Gemini CLI"}
+
+
+def known_agents() -> Dict[str, dict]:
+    """{name: {"dir": Path, "enabled": bool, "links_skills": bool}} per agent."""
+    out = {}
+    for name, spec in (config.get("agents") or {}).items():
+        out[name] = {
+            "dir": paths.expand(str(spec.get("dir", ""))),
+            "enabled": bool(spec.get("enabled", True)),
+            # Defaults True: an agent only reads the canonical store if it
+            # 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)),
+        }
+    return out
+
+
+def enabled_agents() -> Dict[str, Path]:
+    """{name: dir Path} for just the agents whose "enabled" flag is true."""
+    return {n: s["dir"] for n, s in known_agents().items() if s["enabled"]}
+
+
+def linking_agents() -> Dict[str, Path]:
+    """The enabled agents that need a skill *symlinked* into their own dir.
+
+    Most agents do: they only look inside their own config directory, so a
+    skill is invisible until boost links it there. Gemini CLI is the exception —
+    it implements the Agent Skills standard and discovers ``~/.agents/skills``
+    directly, which is exactly :func:`paths.store_dir`. Linking for it would put
+    the same skill in two of its discovery tiers, and since the ``.agents``
+    alias out-ranks ``.gemini/skills`` within the user tier, the copy boost
+    linked could never win — it would only make Gemini log a "Skill conflict
+    detected" line per skill, every session.
+
+    So this is the set to iterate for anything symlink-shaped (link, unlink,
+    stale-link sweeps, coverage checks). :func:`enabled_agents` remains the set
+    for everything that materializes *into* an agent's dotdir — rules and
+    workflows — because those have no canonical store to be read from.
+    """
+    return {n: s["dir"] for n, s in known_agents().items()
+            if s["enabled"] and s["links_skills"]}
+
+
+def native_store_agents() -> Dict[str, Path]:
+    """Enabled agents that read the canonical store without a symlink.
+
+    The complement of :func:`linking_agents` within :func:`enabled_agents` —
+    reported at install time so "linked → a · b · c" never reads as "and not
+    the agent you actually use".
+    """
+    return {n: s["dir"] for n, s in known_agents().items()
+            if s["enabled"] and not s["links_skills"]}
+
+
+def display_name(agent: str) -> str:
+    """`claude-code` -> "Claude Code"; unknown names pass through unchanged."""
+    return DISPLAY.get(agent, agent)
+
+
+def ensure_agent_dirs() -> None:
+    """Create every *linking* agent's skills dir (`mkdir -p`, idempotent).
+
+    Not :func:`enabled_agents`: this exists so a skill has somewhere to be
+    linked, and boost never links into a native-store agent's dir. Creating
+    ``~/.gemini/skills`` anyway would leave an empty directory nothing ever
+    writes to, which ``boost heal`` would first report as a missing directory
+    it needed to create.
+    """
+    for d in linking_agents().values():
+        d.mkdir(parents=True, exist_ok=True)

{boost_skill_cli-1.0.293 → boost_skill_cli-1.0.294}/boost_cli/core/config.py

@@ -12,6 +12,20 @@ DEFAULTS = {
         "claude-code": {"dir": "~/.claude/skills", "enabled": True},
         "windsurf": {"dir": "~/.windsurf/skills", "enabled": True},
         "cursor": {"dir": "~/.cursor/skills", "enabled": True},
+        # Gemini CLI discovers boost's canonical store directly: its user tier
+        # reads `~/.gemini/skills` **or the `~/.agents/skills` alias**, and that
+        # alias is exactly paths.store_dir(). So skills need no symlink —
+        # `links_skills: false` — and linking anyway would put the same skill in
+        # two of Gemini's discovery tiers, where the alias out-ranks the dir we
+        # linked into: the link could never win, it would only cost the user a
+        # "Skill conflict detected" line per skill at every session start.
+        #
+        # The dir is still configured because it anchors everything that is NOT
+        # a store symlink: `~/.gemini` is where rules (GEMINI.md) and workflows
+        # (commands/, agents/) materialize. Set links_skills true to restore the
+        # symlink if that alias is ever narrowed.
+        "gemini": {"dir": "~/.gemini/skills", "enabled": True,
+                   "links_skills": False},
     },
     "taps": [],  # [{"name": "owner/repo", "url": "...", "curated": bool}]
     "ai": {