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

{boost_skill_cli-1.2.37 → boost_skill_cli-1.2.39}/.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.39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.37
+Version: 1.2.39
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE
@@ -1000,9 +1000,14 @@ the C4 diagrams in [`docs/architecture/`](docs/architecture/README.md).
 | Team & Collaboration | cohort · profile · protocol · pulse · replay · who |
 
 The AI-assisted commands (`search --smart`, `explain`, `distill`, `infer`,
-`absorb`, `evolve`, `simulate`) call the `claude` CLI when it is on your PATH,
-or use `ANTHROPIC_API_KEY`, and fall back to plain heuristics when neither is
-available.
+`absorb`, `evolve`, `simulate`) use whichever assistant CLI you already have —
+`claude` first, then `gemini` — or `ANTHROPIC_API_KEY`, and fall back to plain
+heuristics when none is available. boost handles the differences: Gemini takes
+no separate system prompt, so it is folded into the message, and a model id
+belonging to another vendor is never passed through.
+
+The retrieval and faithfulness evals were measured against Claude, so treat
+those floors as Claude-measured rather than a claim about every backend.
 
 ## boost as an MCP server
 

{boost_skill_cli-1.2.37 → boost_skill_cli-1.2.39}/README.md

@@ -282,9 +282,14 @@ the C4 diagrams in [`docs/architecture/`](docs/architecture/README.md).
 | Team & Collaboration | cohort · profile · protocol · pulse · replay · who |
 
 The AI-assisted commands (`search --smart`, `explain`, `distill`, `infer`,
-`absorb`, `evolve`, `simulate`) call the `claude` CLI when it is on your PATH,
-or use `ANTHROPIC_API_KEY`, and fall back to plain heuristics when neither is
-available.
+`absorb`, `evolve`, `simulate`) use whichever assistant CLI you already have —
+`claude` first, then `gemini` — or `ANTHROPIC_API_KEY`, and fall back to plain
+heuristics when none is available. boost handles the differences: Gemini takes
+no separate system prompt, so it is folded into the message, and a model id
+belonging to another vendor is never passed through.
+
+The retrieval and faithfulness evals were measured against Claude, so treat
+those floors as Claude-measured rather than a claim about every backend.
 
 ## boost as an MCP server
 

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

{boost_skill_cli-1.2.37 → boost_skill_cli-1.2.39}/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.39}/boost_cli/core/ai.py

@@ -2,9 +2,21 @@
 # SPDX-License-Identifier: GPL-3.0-only
 """Optional AI bridge for the Intelligence commands and --smart ranking.
 
-Strategy: prefer the `claude` CLI if on PATH, else the Anthropic API via
-urllib when ANTHROPIC_API_KEY is set, else return None so every caller
-degrades to its non-AI fallback.
+Strategy: use the first assistant CLI on PATH that `core/aihost.py` knows —
+Claude first, then Gemini — else the Anthropic API via urllib when
+ANTHROPIC_API_KEY is set, else return None so every caller degrades to its
+non-AI fallback.
+
+The second CLI is why `aihost` exists. Before it, a user running Gemini got the
+heuristic fallback from every AI-assisted command even with a perfectly good
+assistant installed, because this module only ever spelled "claude". The
+per-backend differences that would otherwise be bugs — Gemini has no
+`--append-system-prompt`, and `ai.model` holds a Claude id that `gemini -m`
+would reject — are handled there, as data.
+
+The direct-API path stays Anthropic-only. Someone using Gemini CLI has the
+binary by definition, so the CLI route is the one that matters; a second HTTP
+client is a separate change with its own wire format and error taxonomy.
 """
 from __future__ import annotations
 
@@ -15,7 +27,7 @@ import subprocess
 import urllib.error
 import urllib.request
 
-from . import config, logs, nethttp
+from . import aihost, config, logs, nethttp
 
 API_URL = "https://api.anthropic.com/v1/messages"
 
@@ -30,22 +42,33 @@ def enabled() -> bool:
 
 
 def available() -> bool:
-    """Return True when AI is enabled and a backend exists: the `claude`
-
-    CLI on PATH or ANTHROPIC_API_KEY set.
-    """
+    """Return True when AI is enabled and some backend exists."""
     return enabled() and (has_cli() or bool(os.environ.get("ANTHROPIC_API_KEY")))
 
 
+def cli_backend() -> str | None:
+    """The first assistant CLI on PATH, in `aihost` preference order."""
+    for name in aihost.backends():
+        if shutil.which(aihost.cli(name)):
+            return name
+    return None
+
+
 def has_cli() -> bool:
-    """Return True when the `claude` CLI is on PATH."""
-    return shutil.which("claude") is not None
+    """Return True when any assistant CLI `aihost` knows is on PATH."""
+    return cli_backend() is not None
 
 
 def fallback_note() -> str:
-    """Return the one-line hint shown when a command degrades to heuristics."""
-    return ("AI features need the `claude` CLI on PATH or ANTHROPIC_API_KEY set "
-            "— using the heuristic fallback")
+    """Return the one-line hint shown when a command degrades to heuristics.
+
+    Names every CLI that would work, not just Claude's — telling a Gemini user
+    to install Claude is a worse answer than telling them boost could not find
+    either.
+    """
+    clis = " or ".join("`%s`" % aihost.cli(n) for n in aihost.backends())
+    return ("AI features need one of %s on PATH, or ANTHROPIC_API_KEY set "
+            "— using the heuristic fallback" % clis)
 
 
 def ask(prompt: str, system: str | None = None, model: str | None = None,
@@ -54,8 +77,9 @@ def ask(prompt: str, system: str | None = None, model: str | None = None,
     if not enabled():
         return None
     model = model or str(config.get("ai.model"))
-    if has_cli():
-        text = _ask_cli(prompt, system, model, timeout)
+    backend = cli_backend()
+    if backend:
+        text = _ask_cli(backend, prompt, system, model, timeout)
         if text:
             return text
     if os.environ.get("ANTHROPIC_API_KEY"):
@@ -88,26 +112,27 @@ def _stderr_excerpt(text: str | None) -> str:
     return (s[:STDERR_LOG_CHARS] + "...") if len(s) > STDERR_LOG_CHARS else s
 
 
-def _ask_cli(prompt: str, system: str | None, model: str,
+def _ask_cli(backend: str, prompt: str, system: str | None, model: str,
              timeout: int) -> str | None:
-    cmd = ["claude", "-p", "--model", model, "--output-format", "text"]
-    if system:
-        cmd += ["--append-system-prompt", system]
+    cmd = aihost.argv(backend, model, system)
+    # A backend with no system flag takes the text folded into the prompt.
+    body = aihost.fold_system(backend, system, prompt)
+    who = "%s CLI" % aihost.cli(backend)
     try:
-        proc = subprocess.run(cmd, input=prompt, capture_output=True,
+        proc = subprocess.run(cmd, input=body, capture_output=True,
                               text=True, timeout=timeout)
     except (subprocess.TimeoutExpired, OSError) as e:
         # The exception TYPE only, never str(e): TimeoutExpired stringifies the
-        # whole argv, which carries the --append-system-prompt text with it.
-        _log_failure("claude CLI", type(e).__name__)
+        # whole argv, which carries the system-prompt text with it.
+        _log_failure(who, type(e).__name__)
         return None
     if proc.returncode != 0:
-        _log_failure("claude CLI", "exit %d: %s"
+        _log_failure(who, "exit %d: %s"
                      % (proc.returncode, _stderr_excerpt(proc.stderr)))
         return None
     out = proc.stdout.strip()
     if not out:
-        _log_failure("claude CLI", "empty reply")
+        _log_failure(who, "empty reply")
         return None
     return out
 

boost_skill_cli-1.2.39/boost_cli/core/aihost.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+# Copyright the boost contributors.
+# SPDX-License-Identifier: GPL-3.0-only
+"""Per-assistant-CLI facts for the AI bridge — a pure table, like `hookhost`.
+
+`core/ai.py` knew exactly one backend: the `claude` CLI, or the Anthropic API
+via ANTHROPIC_API_KEY. Every AI-assisted command therefore degraded to its
+heuristic fallback for a user running Gemini CLI, even though Gemini exposes
+the same headless contract. Skills, MCP, rules, workflows and hooks all fan out
+across hosts; this was the last surface that did not, and it is the one a user
+notices, because the fallback is visibly worse prose.
+
+Three per-backend facts do the work, and each is a difference that would
+otherwise be a bug:
+
+* **The system prompt.** Claude takes `--append-system-prompt`. Gemini has no
+  equivalent, so the system text has to be folded into the prompt body. Passing
+  an unknown flag would make every call fail with a usage error rather than
+  degrade — the one outcome worse than having no AI at all.
+* **The model id.** `ai.model` defaults to a Claude model name, and handing
+  that to `gemini -m` is an error, not a fallback. A backend only receives a
+  model id it owns; otherwise the flag is omitted and the CLI picks its own
+  default.
+* **Order.** Claude is first, and that is behaviour rather than taste: someone
+  with both CLIs installed had Claude answering before this table existed, and
+  reordering would silently change every result they get.
+
+The direct-API path in `ai.py` stays Anthropic-only. A user of Gemini CLI has
+the `gemini` binary by definition, so the CLI route is the one that matters
+here; a second HTTP client is a separate, larger change with its own wire
+format and error taxonomy.
+"""
+from __future__ import annotations
+
+from ..errors import BoostError
+
+CLAUDE = "claude"
+GEMINI = "gemini"
+
+#: Ordered: the first installed backend wins. See the module docstring on why
+#: Claude must stay at the front.
+BACKENDS: dict[str, dict] = {
+    CLAUDE: {
+        "cli": "claude",
+        "label": "Claude Code",
+        "prompt_flag": "-p",
+        "model_flag": "--model",
+        # Model ids this backend accepts. `ai.model` is a Claude id today, so
+        # this is what keeps it from being handed to another CLI.
+        "model_prefixes": ("claude", "sonnet", "opus", "haiku"),
+        "output_flags": ("--output-format", "text"),
+        "system_flag": "--append-system-prompt",
+        "key_env": "ANTHROPIC_API_KEY",
+    },
+    GEMINI: {
+        "cli": "gemini",
+        "label": "Gemini CLI",
+        "prompt_flag": "-p",
+        "model_flag": "-m",
+        "model_prefixes": ("gemini",),
+        "output_flags": ("-o", "text"),
+        # No equivalent flag. `fold_system` puts the text in the prompt.
+        "system_flag": "",
+        "key_env": "GEMINI_API_KEY",
+    },
+}
+
+
+def backends() -> list[str]:
+    """Known backend ids, in preference order."""
+    return list(BACKENDS)
+
+
+def spec(name: str) -> dict:
+    """The table row for ``name``, or a BoostError naming the alternatives."""
+    try:
+        return BACKENDS[name]
+    except KeyError:
+        raise BoostError(
+            "unknown AI backend %r" % name,
+            hint="use one of: %s" % ", ".join(backends())) from None
+
+
+def cli(name: str) -> str:
+    """The executable to run for ``name``."""
+    return str(spec(name)["cli"])
+
+
+def label(name: str) -> str:
+    """Display name for ``name`` (``gemini`` -> "Gemini CLI")."""
+    return str(spec(name)["label"])
+
+
+def key_env(name: str) -> str:
+    """The API-key environment variable ``name`` reads."""
+    return str(spec(name)["key_env"])
+
+
+def takes_system_flag(name: str) -> bool:
+    """Whether ``name`` accepts a separate system prompt."""
+    return bool(spec(name)["system_flag"])
+
+
+def owns_model(name: str, model: str | None) -> bool:
+    """Whether ``model`` is an id ``name`` clearly owns."""
+    if not model:
+        return False
+    return model.lower().startswith(tuple(spec(name)["model_prefixes"]))
+
+
+def accepts_model(name: str, model: str | None) -> bool:
+    """Whether to hand ``model`` to ``name``.
+
+    The rule is "not another vendor's", not "one of mine". An id that no
+    backend claims — a custom alias, a pinned snapshot, anything a user passes
+    to `--model` — goes through untouched, because refusing it would silently
+    drop an override the user asked for. Only an id another backend plainly
+    owns is withheld: `ai.model` defaults to a Claude name, and `gemini -m
+    claude-sonnet-4-5` is an error rather than a fallback.
+    """
+    if not model:
+        return False
+    if owns_model(name, model):
+        return True
+    return not any(owns_model(other, model)
+                   for other in backends() if other != name)
+
+
+def fold_system(name: str, system: str | None, prompt: str) -> str:
+    """The prompt to send, with ``system`` folded in when there is no flag.
+
+    Returned unchanged for a backend that takes a system flag, so Claude's
+    request is byte-for-byte what it has always been.
+    """
+    if not system or takes_system_flag(name):
+        return prompt
+    return "%s\n\n%s" % (system, prompt)
+
+
+def argv(name: str, model: str | None, system: str | None) -> list[str]:
+    """The command line for ``name``, minus the prompt (which goes on stdin).
+
+    ``model`` is passed unless another backend plainly owns the id (see
+    `accepts_model`), and ``system`` only when this backend has a flag for one
+    — `fold_system` handles the other case.
+    """
+    row = spec(name)
+    cmd = [str(row["cli"]), str(row["prompt_flag"])]
+    if accepts_model(name, model):
+        cmd += [str(row["model_flag"]), str(model)]
+    cmd += [str(x) for x in row["output_flags"]]
+    if system and row["system_flag"]:
+        cmd += [str(row["system_flag"]), system]
+    return cmd

{boost_skill_cli-1.2.37 → boost_skill_cli-1.2.39/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.39
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE
@@ -1000,9 +1000,14 @@ the C4 diagrams in [`docs/architecture/`](docs/architecture/README.md).
 | Team & Collaboration | cohort · profile · protocol · pulse · replay · who |
 
 The AI-assisted commands (`search --smart`, `explain`, `distill`, `infer`,
-`absorb`, `evolve`, `simulate`) call the `claude` CLI when it is on your PATH,
-or use `ANTHROPIC_API_KEY`, and fall back to plain heuristics when neither is
-available.
+`absorb`, `evolve`, `simulate`) use whichever assistant CLI you already have —
+`claude` first, then `gemini` — or `ANTHROPIC_API_KEY`, and fall back to plain
+heuristics when none is available. boost handles the differences: Gemini takes
+no separate system prompt, so it is folded into the message, and a model id
+belonging to another vendor is never passed through.
+
+The retrieval and faithfulness evals were measured against Claude, so treat
+those floors as Claude-measured rather than a claim about every backend.
 
 ## boost as an MCP server
 

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

@@ -56,6 +56,7 @@ boost_cli/core/__init__.py
 boost_cli/core/adapters.py
 boost_cli/core/agents.py
 boost_cli/core/ai.py
+boost_cli/core/aihost.py
 boost_cli/core/bmad.py
 boost_cli/core/bootstrap.py
 boost_cli/core/browse.py
@@ -202,6 +203,7 @@ docs/roadmap/items/accessibility-audit-pa11y-ci-axe-core.md
 docs/roadmap/items/actionlint-skips-shellcheck-silently.md
 docs/roadmap/items/adapter-conformance-langgraph-leg-never-ran.md
 docs/roadmap/items/agents-field-records-the-request-not-the-links.md
+docs/roadmap/items/ai-backend-fanout.md
 docs/roadmap/items/ai-bridge-silent-failure-logging.md
 docs/roadmap/items/ambiguous-tap-short-name-resolution.md
 docs/roadmap/items/atomic-corruption-safe-lock-file-writes.md
@@ -210,6 +212,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 +577,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
@@ -635,6 +639,7 @@ tests/unit/test_adapters_multi.py
 tests/unit/test_adapters_runner.py
 tests/unit/test_agents.py
 tests/unit/test_ai.py
+tests/unit/test_aihost.py
 tests/unit/test_bmad_core.py
 tests/unit/test_boost_first_offer.py
 tests/unit/test_bootstrap.py

{boost_skill_cli-1.2.37 → boost_skill_cli-1.2.39}/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