boost-skill-cli 1.2.37__tar.gz → 1.2.38__tar.gz

{boost_skill_cli-1.2.37 → boost_skill_cli-1.2.38}/.vale/styles/config/vocabularies/boost/accept.txt

@@ -79,6 +79,8 @@ lookups
 lowercasing
 Magento
 maintainer's
+Matchers
+matchers
 mcp
 mergeable
 minisign

{boost_skill_cli-1.2.37/boost_skill_cli.egg-info → boost_skill_cli-1.2.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.37
+Version: 1.2.38
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.2.37 → boost_skill_cli-1.2.38}/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.37'
-__version_tuple__ = version_tuple = (1, 2, 37)
+__version__ = version = '1.2.38'
+__version_tuple__ = version_tuple = (1, 2, 38)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.37 → boost_skill_cli-1.2.38}/boost_cli/commands/bmad.py

@@ -38,11 +38,25 @@ stage the installer in a temp dir and copy only the `bmad-*` skills into
 ~/.claude/skills, so $HOME never gets a stray `_bmad/`; the runtime is
 per-project by design.
 
-Both surfaces are **Claude Code only**, and deliberately so: subagent
-definitions and `SessionStart`/`UserPromptSubmit` hooks are Claude Code
-contracts with no equivalent in the other three agents boost targets, and BMAD's
-own installer likewise takes `--tools claude-code`. This is the one part of
-boost that does not fan out over `agents.enabled_agents()`.
+The **hooks fan out; the personas do not**, and the split is not arbitrary.
+
+A subagent definition is a Claude Code contract, and BMAD's own installer takes
+`--tools claude-code`, so personas stay in `~/.claude/agents/`. Copying them
+into Gemini's `agents/` slot would also ship files its schema rejects — that
+slot validates, and a Claude-dialect persona fails it.
+
+The hooks are a different case, and an earlier version of this docstring got it
+wrong by lumping them together: it claimed `SessionStart` and
+`UserPromptSubmit` had "no equivalent in the other three agents", which stopped
+being true when `core/hookhost.py` learned Gemini's vocabulary. They map to
+`SessionStart` and `BeforeAgent`, so `bmad on` now installs them on every host
+with evidence of use, translating the event names and the timeout units on the
+way. Matchers are *not* translated — `hookhost` passes them through
+host-native — so Claude's `startup|resume|clear` source matcher is applied only
+on Claude.
+
+What that buys on a second host is prompt shaping, not full parity: the routing
+banner names personas Gemini cannot spawn.
 """
 from __future__ import annotations
 
@@ -61,7 +75,7 @@ from pathlib import Path
 from .. import cliparse
 from ..core import bmad as core
 from ..core import claude_settings as cs
-from ..core import journal, paths, util
+from ..core import hookhost, journal, paths, util
 from ..core import output as out
 from ..errors import BoostError
 
@@ -148,6 +162,74 @@ def _never_fails(command: str) -> str:
     return command + " || true"
 
 
+def _hook_hosts(scope: str) -> list[str]:
+    """Hosts to write hooks into: Claude always, others on evidence of use.
+
+    Claude is unconditional. It is boost's primary host and the behaviour every
+    release before this one had, and the check cannot be `shutil.which` the way
+    `boost mcp register`'s is: that command *shells out* to `claude mcp add` and
+    genuinely cannot work without the binary, while this one only writes a
+    settings.json. A user running inside Claude Code whose launcher is not on
+    boost's PATH would otherwise silently get no hooks at all.
+
+    A second host earns its hooks by evidence that it is actually in use —
+    its CLI on PATH, or its dotdir already present. Writing into
+    `~/.gemini/settings.json` for someone who has never run Gemini is litter in
+    a file boost does not own. A host that appears later is picked up by the
+    next `boost bmad on`, which is idempotent.
+    """
+    chosen = [hookhost.CLAUDE]
+    for host in hookhost.hosts():
+        if host == hookhost.CLAUDE:
+            continue
+        dotdir = cs.settings_path(scope, host=host).parent
+        if shutil.which(hookhost.cli(host)) or dotdir.is_dir():
+            chosen.append(host)
+    return chosen
+
+
+#: (Claude event, hook name, matcher). The matcher is Claude's own
+#: `SessionStart` source vocabulary, and `hookhost` deliberately does not
+#: translate matchers — they pass through host-native — so it is applied only
+#: on the host it was written for. Omitting it elsewhere means "every start",
+#: which is what a session briefing wants anyway.
+_ORIENT_HOOK = ("SessionStart", HOOK_NAME, HOOK_MATCHER)
+_ROUTE_HOOK = ("UserPromptSubmit", ROUTE_HOOK_NAME, None)
+
+
+def _add_hook_everywhere(scope: str, spec: tuple, command: str) -> list[str]:
+    """Install one hook on every installed host. Returns the hosts written."""
+    event, name, matcher = spec
+    written = []
+    for host in _hook_hosts(scope):
+        target = hookhost.translate(host, event)
+        if target is None:
+            # Refused out loud rather than dropped: a hook the user asked for
+            # and silently never got is worse than one that cannot exist.
+            out.warn("%s has no counterpart for %s — skipped"
+                     % (hookhost.label(host), event))
+            continue
+        cs.add_hook(scope, target, name, command,
+                    matcher=matcher if host == hookhost.CLAUDE else None,
+                    host=host)
+        written.append(host)
+    return written
+
+
+def _remove_hook_everywhere(scope: str, *specs: tuple) -> None:
+    """Remove hooks from every host, installed or not.
+
+    Unlike install this does not filter on `shutil.which`: someone who removed
+    an agent CLI still wants boost's hooks gone from its settings.json, and
+    `remove_hook` against a file that was never written is a no-op.
+    """
+    for host in hookhost.hosts():
+        for event, name, _matcher in specs:
+            target = hookhost.translate(host, event)
+            if target is not None:
+                cs.remove_hook(scope, target, name, host=host)
+
+
 def _autopilot_on(scope) -> int:
     """The one command. Personas + orientation + router, in one idempotent pass.
 
@@ -160,11 +242,11 @@ def _autopilot_on(scope) -> int:
     slugs, skipped = core.write_personas(agents)
 
     launcher = shlex.quote(str(paths.launcher()))
-    cs.add_hook(scope, "SessionStart", HOOK_NAME,
-                _never_fails("%s bmad orient --scope %s" % (launcher, scope)),
-                matcher=HOOK_MATCHER)
-    cs.add_hook(scope, "UserPromptSubmit", ROUTE_HOOK_NAME,
-                _never_fails("%s bmad route" % launcher))
+    hosts = _add_hook_everywhere(
+        scope, _ORIENT_HOOK,
+        _never_fails("%s bmad orient --scope %s" % (launcher, scope)))
+    _add_hook_everywhere(scope, _ROUTE_HOOK,
+                         _never_fails("%s bmad route" % launcher))
     _set_scope_state(scope, autopilot=True, startup=True, personas=len(slugs),
                      enabled_at=util.now_iso())
     journal.log("bmad-autopilot", "on", scope=scope, personas=len(slugs))
@@ -176,8 +258,11 @@ def _autopilot_on(scope) -> int:
                  % (len(skipped), ", ".join(skipped)))
         out.dim("  delete the file to let `boost bmad on` restore the stock version")
     out.dim("  personas → %s" % paths.tilde(agents))
-    out.dim("  hooks    → %s (SessionStart + UserPromptSubmit)"
-            % paths.tilde(cs.settings_path(scope)))
+    for host in hosts:
+        out.dim("  hooks    → %s (%s + %s)"
+                % (paths.tilde(cs.settings_path(scope, host=host)),
+                   hookhost.translate(host, "SessionStart"),
+                   hookhost.translate(host, "UserPromptSubmit")))
     out.dim("  every substantive prompt now names its lead persona and its "
             "definition of done; trivial asks are left alone")
     # Claude Code only watches an agents dir that existed when the session
@@ -189,8 +274,7 @@ def _autopilot_on(scope) -> int:
 
 def _autopilot_off(scope) -> int:
     scope = scope or "global"
-    cs.remove_hook(scope, "SessionStart", HOOK_NAME)
-    cs.remove_hook(scope, "UserPromptSubmit", ROUTE_HOOK_NAME)
+    _remove_hook_everywhere(scope, _ORIENT_HOOK, _ROUTE_HOOK)
     removed = core.remove_personas(_agents_dir(scope))
     _set_scope_state(scope, autopilot=False, startup=False, personas=0)
     journal.log("bmad-autopilot", "off", scope=scope, personas=len(removed))
@@ -374,14 +458,15 @@ def _startup(value, scope) -> int:
     if value == "on":
         cmd = "%s bmad orient --scope %s" % (
             shlex.quote(str(paths.launcher())), scope)
-        cs.add_hook(scope, "SessionStart", HOOK_NAME, cmd, matcher=HOOK_MATCHER)
+        started = _add_hook_everywhere(scope, _ORIENT_HOOK, cmd)
         _set_scope_state(scope, startup=True)
         journal.log("bmad-startup", "on", scope=scope)
         out.ok("BMAD startup ON (%s) — new sessions get orientation" % scope)
-        out.dim("  hook → %s" % cs.settings_path(scope))
+        for host in started:
+            out.dim("  hook → %s" % cs.settings_path(scope, host=host))
         return 0
     if value == "off":
-        cs.remove_hook(scope, "SessionStart", HOOK_NAME)
+        _remove_hook_everywhere(scope, _ORIENT_HOOK)
         _set_scope_state(scope, startup=False)
         journal.log("bmad-startup", "off", scope=scope)
         out.ok("BMAD startup OFF (%s) — skills stay installed" % scope)
@@ -419,8 +504,7 @@ def _uninstall(scope, yes) -> int:
                 scope, " + _bmad/, _bmad-output/" if scope == "project" else ""))):
         out.info("aborted")
         return 0
-    cs.remove_hook(scope, "SessionStart", HOOK_NAME)
-    cs.remove_hook(scope, "UserPromptSubmit", ROUTE_HOOK_NAME)
+    _remove_hook_everywhere(scope, _ORIENT_HOOK, _ROUTE_HOOK)
     removed = _rm_skills(_skills_dir(scope))
     removed += len(core.remove_personas(_agents_dir(scope)))
     if scope == "project":
@@ -438,7 +522,7 @@ def _uninstall(scope, yes) -> int:
 def _disable(scope) -> int:
     """Quarantine: turn startup off and move skills aside (recoverable)."""
     scope = scope or "project"
-    cs.remove_hook(scope, "SessionStart", HOOK_NAME)
+    _remove_hook_everywhere(scope, _ORIENT_HOOK)
     qdir = _quarantine_dir(scope)
     qdir.mkdir(parents=True, exist_ok=True)
     moved = 0

{boost_skill_cli-1.2.37 → boost_skill_cli-1.2.38/boost_skill_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.37
+Version: 1.2.38
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.2.37 → boost_skill_cli-1.2.38}/boost_skill_cli.egg-info/SOURCES.txt

@@ -210,6 +210,7 @@ docs/roadmap/items/autonomous-ship-workflow-and-isolated-worktree.md
 docs/roadmap/items/bm25-has-no-stemming.md
 docs/roadmap/items/bm25-index-is-one-json-blob.md
 docs/roadmap/items/bmad-autopilot-one-command-persona-routing.md
+docs/roadmap/items/bmad-hooks-all-hosts.md
 docs/roadmap/items/boost-first-carried-the-losing-trigger.md
 docs/roadmap/items/boost-first-rule.md
 docs/roadmap/items/boost-langchain-publishing.md
@@ -574,6 +575,7 @@ tests/eval/golden.jsonl
 tests/eval/recommend.jsonl
 tests/eval/taps-scale.txt
 tests/eval/taps.txt
+tests/functional/test_bmad_all_hosts.py
 tests/functional/test_capabilities_policy.py
 tests/functional/test_cli_adapt.py
 tests/functional/test_cli_bmad.py

{boost_skill_cli-1.2.37 → boost_skill_cli-1.2.38}/docs/bmad.md

@@ -48,9 +48,9 @@ boost bmad on
 ```
 
 It writes seven BMAD persona subagents into `~/.claude/agents/` and installs two
-hooks. A `SessionStart` hook briefs the session on the roster. A
-`UserPromptSubmit` hook classifies each incoming prompt and prefixes it with a
-short routing banner:
+hooks on every host it finds. A `SessionStart` hook briefs the session on the
+roster. A `UserPromptSubmit` hook classifies each incoming prompt and prefixes
+it with a short routing banner:
 
 ```text
 [BMAD autopilot] track: build
@@ -92,6 +92,33 @@ contents, so the moment you edit one it stops being boost's. `boost bmad on`
 reports it as kept rather than overwriting it, and `boost bmad off` leaves it
 alone. Delete the file if you want the stock version back.
 
+### Which hosts get the hooks
+
+`boost bmad on` writes its two hooks into every host it has evidence you use,
+and re-running it changes nothing that is already correct.
+
+- **Claude always.** It is boost's primary host, and the check deliberately is
+  not "is the `claude` binary on `PATH`" — `bmad on` only writes a
+  settings.json, so someone running inside Claude Code whose launcher is not on
+  boost's `PATH` would otherwise silently get no hooks. (`boost mcp register`
+  does gate on the binary, because it shells out to `claude mcp add` and
+  genuinely cannot work without it.)
+- **Any other host on evidence of use** — its CLI on `PATH`, or its dotdir
+  already there. Writing into `~/.gemini/settings.json` for someone who has
+  never run Gemini is litter in a file boost does not own. Install that agent
+  later and the next `boost bmad on` picks it up.
+
+boost translates on the way in. `UserPromptSubmit` is written as Gemini's
+`BeforeAgent`, and `--timeout 10` means ten seconds on both hosts even though
+Gemini's field is milliseconds. Matchers are **not** translated — they pass
+through host-native — so Claude's `startup|resume|clear` source matcher is
+applied only on Claude, where that vocabulary exists.
+
+**The personas stay Claude-only.** A subagent definition is a Claude Code
+contract, and Gemini's `agents/` slot validates its input, so a Claude-dialect
+persona would be rejected. What a second host gets is prompt shaping: the
+routing banner arrives and names a lead persona, but Gemini cannot spawn it.
+
 ## The full BMAD method
 
 The method itself is a separate, heavier install. `boost bmad install` delegates

boost_skill_cli-1.2.38/docs/roadmap/items/bmad-hooks-all-hosts.md

@@ -0,0 +1,42 @@
+---
+id: bmad-hooks-all-hosts
+board: code
+section: shipped
+status: shipped
+category: Agents · Parity
+complexity: S
+impact: Med
+wow: 3
+note: the autopilot wrote hooks to Claude and nowhere else, long after boost knew a second host
+order: 12
+owner: loop/bmad-all-hosts
+pr:
+title: bmad on knew about a second host and wrote to one anyway
+---
+<code>boost bmad on</code> installed its two hooks into Claude's
+<code>settings.json</code> and nowhere else — not because of a decision, but because
+<code>_autopilot_on</code> called <code>claude_settings.add_hook</code> without a
+<code>host=</code> and took the default. That kept being true after
+<code>core/hookhost.py</code> taught boost Gemini's event vocabulary and timeout units. The
+capability was there; six call sites never used it.
+<b>Six, not two.</b> <code>bmad on</code> and <code>off</code> were the obvious pair, but
+<code>startup on|off</code>, <code>uninstall</code> and <code>disable</code> all manage the same
+hooks, and a fan-out that fixed only the first two would have left
+<code>boost bmad off</code> unable to remove what <code>boost bmad on</code> wrote.
+<b>An existing test caught a real design error.</b> The first version chose hosts the way
+<code>boost mcp register</code> does — <code>shutil.which</code> on the agent's CLI — and a test
+that stubs <code>which</code> to <code>None</code> went red. It was right to. <code>mcp
+register</code> <i>shells out</i> to <code>claude mcp add</code> and genuinely cannot work
+without the binary; <code>bmad on</code> only writes a settings file. Gating on the binary
+would have left a user running inside Claude Code with no hooks whenever the launcher was not
+on boost's <code>PATH</code>. The rule is now <b>Claude unconditionally, any other host on
+evidence of use</b> — its CLI on <code>PATH</code>, or its dotdir already present — so boost
+never litters <code>~/.gemini/</code> for someone who has never run Gemini.
+<b>What fans out and what does not.</b> Hooks do, translated: <code>UserPromptSubmit</code> is
+written as Gemini's <code>BeforeAgent</code>, and ten seconds is written as
+<code>10000</code> because Gemini's field is milliseconds. Matchers are not translated —
+<code>hookhost</code> passes them through host-native — so Claude's
+<code>startup|resume|clear</code> is applied only on Claude. The personas stay Claude-only: a
+subagent is a Claude contract and Gemini's <code>agents/</code> slot would reject the dialect.
+The module docstring claimed those events had "no equivalent in the other three agents", which
+had quietly stopped being true; it says what is actually so now.

{boost_skill_cli-1.2.37 → boost_skill_cli-1.2.38}/docs/roadmap.html

@@ -130,10 +130,10 @@
   <section class="block reveal">
     <div class="stats">
       <!-- ROADMAP:stats -->
-      <div class="stat"><b>17</b><span>Shipped</span></div>
+      <div class="stat"><b>18</b><span>Shipped</span></div>
       <div class="stat"><b>1</b><span>Next up</span></div>
       <div class="stat"><b>7</b><span>Planned</span></div>
-      <div class="stat"><b>280</b><span>Loop finds</span></div>
+      <div class="stat"><b>281</b><span>Loop finds</span></div>
       <!-- /ROADMAP:stats -->
     </div>
   </section>
@@ -426,6 +426,45 @@ by new unit tests covering every branch.</p></details>
         </div>
       </article>
 
+      <article class="cap rcard" id="bmad-hooks-all-hosts">
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Agents · Parity</span></div>
+        <h3>bmad on knew about a second host and wrote to one anyway</h3>
+        <details class="cardbody"><summary>Write-up</summary>
+        <p><code>boost bmad on</code> installed its two hooks into Claude's
+<code>settings.json</code> and nowhere else — not because of a decision, but because
+<code>_autopilot_on</code> called <code>claude_settings.add_hook</code> without a
+<code>host=</code> and took the default. That kept being true after
+<code>core/hookhost.py</code> taught boost Gemini's event vocabulary and timeout units. The
+capability was there; six call sites never used it.
+<b>Six, not two.</b> <code>bmad on</code> and <code>off</code> were the obvious pair, but
+<code>startup on|off</code>, <code>uninstall</code> and <code>disable</code> all manage the same
+hooks, and a fan-out that fixed only the first two would have left
+<code>boost bmad off</code> unable to remove what <code>boost bmad on</code> wrote.
+<b>An existing test caught a real design error.</b> The first version chose hosts the way
+<code>boost mcp register</code> does — <code>shutil.which</code> on the agent's CLI — and a test
+that stubs <code>which</code> to <code>None</code> went red. It was right to. <code>mcp
+register</code> <i>shells out</i> to <code>claude mcp add</code> and genuinely cannot work
+without the binary; <code>bmad on</code> only writes a settings file. Gating on the binary
+would have left a user running inside Claude Code with no hooks whenever the launcher was not
+on boost's <code>PATH</code>. The rule is now <b>Claude unconditionally, any other host on
+evidence of use</b> — its CLI on <code>PATH</code>, or its dotdir already present — so boost
+never litters <code>~/.gemini/</code> for someone who has never run Gemini.
+<b>What fans out and what does not.</b> Hooks do, translated: <code>UserPromptSubmit</code> is
+written as Gemini's <code>BeforeAgent</code>, and ten seconds is written as
+<code>10000</code> because Gemini's field is milliseconds. Matchers are not translated —
+<code>hookhost</code> passes them through host-native — so Claude's
+<code>startup|resume|clear</code> is applied only on Claude. The personas stay Claude-only: a
+subagent is a Claude contract and Gemini's <code>agents/</code> slot would reject the dialect.
+The module docstring claimed those events had "no equivalent in the other three agents", which
+had quietly stopped being true; it says what is actually so now.</p></details>
+        <div class="meta">
+          <span class="m">Complexity <b>S</b></span>
+          <span class="m">Impact <b>Med</b></span>
+          <span class="m">Wow <b class="wow">★★★</b></span>
+          <span class="m">the autopilot wrote hooks to Claude and nowhere else, long after boost knew a second host</span>
+        </div>
+      </article>
+
       <article class="cap rcard" id="reuse-helpers-kill-minor-dead-work">
         <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Tech-debt</span></div>
         <h3>Reuse helpers; kill minor dead work</h3>

boost_skill_cli-1.2.38/tests/functional/test_bmad_all_hosts.py

@@ -0,0 +1,124 @@
+# Copyright the boost contributors.
+# SPDX-License-Identifier: GPL-3.0-only
+"""`boost bmad on` installs its hooks on every installed host, idempotently.
+
+The autopilot's two hooks were written to Claude's settings.json and nowhere
+else, even after `boost hooks` learned about a second host: `_autopilot_on`
+called `claude_settings.add_hook` without a `host=`, so it took the default.
+A user with Gemini CLI installed had to add both by hand, translating the event
+names themselves -- which is the part boost exists to know.
+
+Idempotence is asserted rather than assumed because these hooks are written
+into a file the user owns and may re-run `bmad on` against at any time.
+"""
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from boost_cli.core import hookhost
+
+
+def _settings(home, host, name="settings.json"):
+    p = home / hookhost.settings_dir(host) / name
+    return json.loads(p.read_text(encoding="utf-8")) if p.exists() else {}
+
+
+def _boost_hooks(data):
+    """{event: [names]} for the hooks boost owns, by its `# boost:` marker."""
+    found = {}
+    for event, entries in (data.get("hooks") or {}).items():
+        for block in entries:
+            for h in block.get("hooks", []):
+                if "# boost:" in h.get("command", ""):
+                    found.setdefault(event, []).append(
+                        h["command"].rsplit("# boost:", 1)[1].strip())
+    return found
+
+
+@pytest.fixture()
+def both_hosts(sandbox, monkeypatch):
+    """Pretend every known host's CLI is installed."""
+    monkeypatch.setattr("shutil.which", lambda name: "/usr/bin/" + name)
+    return sandbox
+
+
+class TestAutopilotFansOut:
+    def test_hooks_land_on_every_installed_host(self, both_hosts, boost):
+        boost("bmad", "on", "--scope", "global")
+        home = both_hosts
+        claude = _boost_hooks(_settings(home, hookhost.CLAUDE))
+        gemini = _boost_hooks(_settings(home, hookhost.GEMINI))
+        assert "bmad" in claude.get("SessionStart", [])
+        assert "bmad-route" in claude.get("UserPromptSubmit", [])
+        # Gemini spells them differently; boost must translate, not copy.
+        assert "bmad" in gemini.get("SessionStart", []), gemini
+        assert "bmad-route" in gemini.get("BeforeAgent", []), gemini
+
+    def test_gemini_timeout_is_milliseconds(self, both_hosts, boost):
+        """The unit bug boost exists to absorb: 10s is 10000 on Gemini."""
+        boost("bmad", "on", "--scope", "global")
+        data = _settings(both_hosts, hookhost.GEMINI)
+        entries = [h for blocks in data["hooks"].values()
+                   for b in blocks for h in b.get("hooks", [])]
+        assert entries, data
+        assert all(h["timeout"] == 10000 for h in entries), entries
+
+    def test_running_twice_does_not_duplicate(self, both_hosts, boost):
+        boost("bmad", "on", "--scope", "global")
+        first = _settings(both_hosts, hookhost.GEMINI)
+        boost("bmad", "on", "--scope", "global")
+        assert _settings(both_hosts, hookhost.GEMINI) == first
+
+    def test_off_removes_them_from_every_host(self, both_hosts, boost):
+        boost("bmad", "on", "--scope", "global")
+        boost("bmad", "off", "--scope", "global")
+        for host in (hookhost.CLAUDE, hookhost.GEMINI):
+            assert _boost_hooks(_settings(both_hosts, host)) == {}, host
+
+
+class TestUninstalledHostsAreSkipped:
+    def test_a_host_without_its_cli_gets_no_settings_file(self, sandbox, boost,
+                                                          monkeypatch):
+        """Writing into ~/.gemini for someone who has no Gemini is litter."""
+        monkeypatch.setattr("shutil.which",
+                            lambda name: "/usr/bin/claude" if name == "claude" else None)
+        boost("bmad", "on", "--scope", "global")
+        gem = sandbox / hookhost.settings_dir(hookhost.GEMINI) / "settings.json"
+        assert not gem.exists(), "wrote Gemini settings with no Gemini installed"
+        assert _boost_hooks(_settings(sandbox, hookhost.CLAUDE)), "Claude missed"
+
+
+class TestHostSelectionRule:
+    """Claude unconditionally; a second host on evidence that it is in use.
+
+    The rule is not `boost mcp register`'s. That command shells out to
+    `claude mcp add` and genuinely cannot work without the binary; this one
+    only writes a settings.json. Gating Claude on `shutil.which` would leave a
+    user running inside Claude Code with no hooks whenever the launcher is not
+    on boost's PATH — which is exactly what an existing test caught.
+    """
+
+    def test_claude_gets_hooks_even_with_no_cli_anywhere(self, sandbox, boost,
+                                                         monkeypatch):
+        monkeypatch.setattr("shutil.which", lambda _n: None)
+        boost("bmad", "on", "--scope", "global")
+        assert _boost_hooks(_settings(sandbox, hookhost.CLAUDE)), \
+            "Claude must get hooks regardless of what is on PATH"
+
+    def test_a_dotdir_is_evidence_enough_without_the_cli(self, sandbox, boost,
+                                                         monkeypatch):
+        """Someone who has run Gemini has ~/.gemini, whatever their PATH says."""
+        monkeypatch.setattr("shutil.which", lambda _n: None)
+        (sandbox / hookhost.settings_dir(hookhost.GEMINI)).mkdir(parents=True)
+        boost("bmad", "on", "--scope", "global")
+        assert _boost_hooks(_settings(sandbox, hookhost.GEMINI)), \
+            "an existing dotdir should have earned the hooks"
+
+    def test_no_cli_and_no_dotdir_means_no_file(self, sandbox, boost,
+                                                monkeypatch):
+        monkeypatch.setattr("shutil.which", lambda _n: None)
+        boost("bmad", "on", "--scope", "global")
+        gem = sandbox / hookhost.settings_dir(hookhost.GEMINI) / "settings.json"
+        assert not gem.exists()