boost-skill-cli 1.2.117__tar.gz → 1.2.119__tar.gz

{boost_skill_cli-1.2.117/boost_skill_cli.egg-info → boost_skill_cli-1.2.119}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.117
+Version: 1.2.119
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0

{boost_skill_cli-1.2.117 → boost_skill_cli-1.2.119}/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.117'
-__version_tuple__ = version_tuple = (1, 2, 117)
+__version__ = version = '1.2.119'
+__version_tuple__ = version_tuple = (1, 2, 119)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.117 → boost_skill_cli-1.2.119}/boost_cli/commands/bmad.py

@@ -11,13 +11,14 @@ and no network: it writes the seven BMAD persona subagents into
 carrying the persona that should lead it, the support personas to spawn
 alongside, the BMAD skill for that track, and a definition of done read off the
 repo in front of it (its test dir, its docs, its roadmap items, its gate
-command). Trivial asks get nothing, so the router costs a question nothing. All
+command). Trivial asks get no banner. All
 of the thinking lives in :mod:`boost_cli.core.bmad`; this module is glue.
 
     boost bmad on                          # <- the one command. global.
     boost bmad off                         # remove hooks + boost-written personas
     boost bmad personas                    # the roster + whether installed, both scopes
     boost bmad route [PROMPT] [--plain]    # hook target; pipeable for debugging
+    boost bmad on --host claude            # hooks for one host, not every one in use
 
 **The full method** is `boost bmad install`, unchanged: it delegates to the
 canonical `npx bmad-method install` (Node.js 20.12+) for the `bmad-*` workflow
@@ -55,8 +56,10 @@ 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.
+What that buys on a second host is prompt shaping, not full parity. Gemini's
+hooks pass `--host gemini`, so `route` and `orient` answer in the JSON Gemini
+adds to the model's context and name the personas as roles rather than
+subagents; `--host` on `on`/`startup` picks the hosts explicitly.
 """
 from __future__ import annotations
 
@@ -110,14 +113,19 @@ def cmd_bmad(argv) -> int:
                    help="enable the startup toggle right after install")
     p.add_argument("--plain", action="store_true",
                    help="route: print the banner as text, not as hook JSON")
+    p.add_argument("--host", metavar="H", default=None,
+                   choices=(*hookhost.hosts(), "auto"),
+                   help="on/startup: hosts to hook (%s; default auto: "
+                        "claude + any in use) · route/orient: output format"
+                        % " | ".join(hookhost.hosts()))
     args = p.parse_args(argv)
 
     if args.action == "on":
-        return _autopilot_on(args.scope)
+        return _autopilot_on(args.scope, args.host)
     if args.action == "off":
         return _autopilot_off(args.scope)
     if args.action == "route":
-        return _route(args.value, args.plain, args.scope)
+        return _route(args.value, args.plain, args.scope, _one_host(args.host))
     if args.action == "personas":
         return _personas(args.scope)
     if args.action == "install":
@@ -125,9 +133,9 @@ def cmd_bmad(argv) -> int:
     if args.action == "init":
         return _init(args.modules, args.startup)
     if args.action == "startup":
-        return _startup(args.value or "status", args.scope)
+        return _startup(args.value or "status", args.scope, args.host)
     if args.action == "orient":
-        return _orient(args.scope)
+        return _orient(args.scope, _one_host(args.host))
     if args.action == "uninstall":
         return _uninstall(args.scope, args.yes)
     if args.action == "disable":
@@ -174,7 +182,12 @@ def _never_fails(command: str) -> str:
     return command + " || true"
 
 
-def _hook_hosts(scope: str) -> list[str]:
+def _one_host(host) -> str:
+    """The host a hook runs under. Hooks written before `--host` are Claude's."""
+    return hookhost.CLAUDE if host in (None, "auto") else host
+
+
+def _hook_hosts(scope: str, requested=None) -> 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
@@ -189,7 +202,13 @@ def _hook_hosts(scope: str) -> list[str]:
     `~/.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.
+
+    ``requested`` (`--host`) overrides the rule: naming one host writes that
+    host only, so Claude-only no longer means hand-editing Gemini's settings
+    after every `on`.
     """
+    if requested not in (None, "auto"):
+        return [requested]
     chosen = [hookhost.CLAUDE]
     for host in hookhost.hosts():
         if host == hookhost.CLAUDE:
@@ -209,11 +228,26 @@ _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."""
+def _host_command(host: str, command: str) -> str:
+    """``command`` as ``host``'s hook runs it, made incapable of failing.
+
+    Claude's bytes are what every earlier release wrote. Another host's hook
+    names its host, so `route`/`orient` answer in the format that host reads,
+    and drops stderr: Gemini shows stderr to the user when stdout is empty, so
+    a launcher too old to know the action printed its usage error into the
+    session despite `|| true`.
+    """
+    if host == hookhost.CLAUDE:
+        return _never_fails(command)
+    return _never_fails("%s --host %s 2>/dev/null" % (command, host))
+
+
+def _add_hook_everywhere(scope: str, spec: tuple, command: str,
+                         requested=None) -> list[str]:
+    """Install one hook on every chosen host. Returns the hosts written."""
     event, name, matcher = spec
     written = []
-    for host in _hook_hosts(scope):
+    for host in _hook_hosts(scope, requested):
         target = hookhost.translate(host, event)
         if target is None:
             # Refused out loud rather than dropped: a hook the user asked for
@@ -221,7 +255,7 @@ def _add_hook_everywhere(scope: str, spec: tuple, command: str) -> list[str]:
             out.warn("%s has no counterpart for %s — skipped"
                      % (hookhost.label(host), event))
             continue
-        cs.add_hook(scope, target, name, command,
+        cs.add_hook(scope, target, name, _host_command(host, command),
                     matcher=matcher if host == hookhost.CLAUDE else None,
                     host=host)
         written.append(host)
@@ -246,7 +280,7 @@ def _remove_hook_everywhere(scope: str, *specs: tuple) -> int:
     return removed
 
 
-def _autopilot_on(scope) -> int:
+def _autopilot_on(scope, requested_host=None) -> int:
     """The one command. Personas + orientation + router, in one idempotent pass.
 
     Global by default: the point of the autopilot is that a task arriving in
@@ -267,10 +301,11 @@ def _autopilot_on(scope) -> int:
 
     launcher = shlex.quote(str(paths.launcher()))
     hosts = _add_hook_everywhere(
-        scope, _ORIENT_HOOK,
-        _never_fails("%s bmad orient --scope %s" % (launcher, scope)))
+        scope, _ORIENT_HOOK, "%s bmad orient --scope %s" % (launcher, scope),
+        requested_host)
     _add_hook_everywhere(scope, _ROUTE_HOOK,
-                         _never_fails("%s bmad route --scope %s" % (launcher, scope)))
+                         "%s bmad route --scope %s" % (launcher, scope),
+                         requested_host)
     _set_scope_state(scope, autopilot=True, startup=True, personas=present,
                      enabled_at=util.now_iso())
     journal.log("bmad-autopilot", "on", scope=scope, personas=present)
@@ -335,7 +370,7 @@ def _read_hook_stdin() -> dict:
     return data if isinstance(data, dict) else {"prompt": raw}
 
 
-def _route(prompt, plain, scope=None) -> int:
+def _route(prompt, plain, scope=None, host=hookhost.CLAUDE) -> int:
     """UserPromptSubmit hook target: classify, then emit the routing banner.
 
     This runs on every single prompt, so it has exactly one hard rule: **always
@@ -356,9 +391,9 @@ def _route(prompt, plain, scope=None) -> int:
         cwd = payload.get("cwd")
         root = Path(cwd) if cwd else Path.cwd()
         if prompt or plain:
-            banner = core.route_context(text, root)
+            banner = core.route_context(text, root, None, host)
         elif _autopilot_live(scope, root):
-            banner = _session_banner(payload, text, root)
+            banner = _session_banner(payload, text, root, host)
         else:
             return 0
     except Exception:                     # a hook must never break the session
@@ -368,14 +403,12 @@ def _route(prompt, plain, scope=None) -> int:
     if plain:
         print(banner)
         return 0
-    print(json.dumps({"hookSpecificOutput": {
-        "hookEventName": "UserPromptSubmit",
-        "additionalContext": banner,
-    }}))
+    print(hookhost.context_output(host, "UserPromptSubmit", banner))
     return 0
 
 
-def _session_banner(payload: dict, text: str, root: Path) -> str:
+def _session_banner(payload: dict, text: str, root: Path,
+                    host: str = hookhost.CLAUDE) -> str:
     """The hook's banner, or ``""`` when this session already holds it.
 
     Keyed by ``session_id``. Gemini's `BeforeAgent` carries one too, but its
@@ -383,7 +416,7 @@ def _session_banner(payload: dict, text: str, root: Path) -> str:
     skipped there would simply be missing; the check applies to Claude alone.
     """
     session = str(payload.get("session_id") or "")
-    if payload.get("hook_event_name") == "BeforeAgent":
+    if host != hookhost.CLAUDE or payload.get("hook_event_name") == "BeforeAgent":
         session = ""
     track = core.classify(text, root)
     if track == core.TRIVIAL:
@@ -393,7 +426,7 @@ def _session_banner(payload: dict, text: str, root: Path) -> str:
                                            str(root)):
         return ""
     banner = core.route_context(
-        text, root, (_agents_dir("global"), root / ".claude" / "agents"))
+        text, root, (_agents_dir("global"), root / ".claude" / "agents"), host)
     if session and banner:
         sessions[session] = {"track": track, "root": str(root),
                              "at": util.now_iso()}
@@ -548,12 +581,12 @@ def _copy_global_skills(modules) -> int:
 
 # ----------------------------------------------------------------------- toggle
 
-def _startup(value, scope) -> int:
+def _startup(value, scope, requested_host=None) -> int:
     scope = scope or "project"
     if value == "on":
-        cmd = _never_fails("%s bmad orient --scope %s" % (
-            shlex.quote(str(paths.launcher())), scope))
-        started = _add_hook_everywhere(scope, _ORIENT_HOOK, cmd)
+        cmd = "%s bmad orient --scope %s" % (
+            shlex.quote(str(paths.launcher())), scope)
+        started = _add_hook_everywhere(scope, _ORIENT_HOOK, cmd, requested_host)
         _set_scope_state(scope, startup=True)
         journal.log("bmad-startup", "on", scope=scope)
         out.ok("BMAD startup ON (%s) — new sessions get orientation" % scope)
@@ -572,7 +605,7 @@ def _startup(value, scope) -> int:
                      hint="use 'on', 'off' or 'status'")
 
 
-def _orient(scope) -> int:
+def _orient(scope, host=hookhost.CLAUDE) -> int:
     """SessionStart hook target: print the briefing iff enabled (else silent).
 
     On `clear` and `compact` it also forgets the session's last routing banner:
@@ -589,17 +622,18 @@ def _orient(scope) -> int:
                 _sessions_write(sessions)
     with suppress(Exception):
         if _get_scope_state(scope).get("startup"):
-            print(core.orientation())
+            print(hookhost.context_output(host, "SessionStart",
+                                          core.orientation(host)))
     return 0
 
 
 def _status(scope) -> int:
     st = _get_scope_state(scope)
-    hook = cs.has_hook(scope, "SessionStart", HOOK_NAME)
+    hosts = _hosts_with(scope, "SessionStart", HOOK_NAME)
     n = _count_skills(_skills_dir(scope))
     out.heading("BMAD startup — %s" % scope)
     out.kv("enabled", str(bool(st.get("startup"))))
-    out.kv("hook", "present" if hook else "absent")
+    out.kv("hook", "present (%s)" % ", ".join(hosts) if hosts else "absent")
     out.kv("skills", str(n))
     out.kv("installed", str(bool(st.get("installed"))))
     return 0
@@ -683,16 +717,18 @@ def _doctor() -> int:
         # managed + edited: an edited persona file is still on disk and
         # Claude Code still loads it, same as core.present_personas().
         personas = len(core.present_personas(agents))
-        router = cs.has_hook(scope, "UserPromptSubmit", ROUTE_HOOK_NAME)
+        router_hosts = _hosts_with(scope, "UserPromptSubmit", ROUTE_HOOK_NAME)
+        briefing_hosts = _hosts_with(scope, "SessionStart", HOOK_NAME)
+        router = bool(router_hosts)
         live = bool(st.get("autopilot")) and router
-        briefing = _on_off(cs.has_hook(scope, "SessionStart", HOOK_NAME))
-        if briefing == "on" and _stale_matcher(scope):
+        briefing = _where(briefing_hosts)
+        if briefing_hosts and _stale_matcher(scope):
             # The matcher lives in the user's settings.json from whenever they
             # last ran `on`, while the code that depends on it ships with the
             # binary — so an old install silently misses newer sources.
             briefing += " (stale matcher: re-run `boost bmad on`)"
         out.kv(scope, "autopilot=%s  %d personas  router=%s  briefing=%s"
-               % (_on_off(live), personas, _on_off(router), briefing))
+               % (_on_off(live), personas, _where(router_hosts), briefing))
         out.kv("  workflows", "skills=%d  installed=%s"
                % (_count_skills(_skills_dir(scope)), _on_off(st.get("installed"))))
     out.dim("  project = %s" % Path.cwd())
@@ -714,6 +750,30 @@ def _stale_matcher(scope) -> bool:
     return any(r.get("matcher") != HOOK_MATCHER for r in rows)
 
 
+def _hosts_with(scope, event: str, name: str) -> list[str]:
+    """Which hosts carry this boost hook, in report order.
+
+    `--host gemini` makes a Claude-less autopilot reachable for the first time,
+    and a report that asks only Claude called that install absent — `doctor`
+    said `autopilot=off router=off` about a router that was about to run.
+    """
+    found = []
+    for host in hookhost.hosts():
+        target = hookhost.translate(host, event)
+        if target is not None and cs.has_hook(scope, target, name, host=host):
+            found.append(host)
+    return found
+
+
+def _where(hosts: list[str]) -> str:
+    """``off``, ``on`` (Claude only) or ``on (gemini)`` — who has the hook."""
+    if not hosts:
+        return "off"
+    if hosts == [hookhost.CLAUDE]:
+        return "on"
+    return "on (%s)" % ", ".join(hosts)
+
+
 def _skills_dir(scope) -> Path:
     base = paths.home() if scope == "global" else Path.cwd()
     return base / ".claude" / "skills"

{boost_skill_cli-1.2.117 → boost_skill_cli-1.2.119}/boost_cli/core/bmad.py

@@ -42,6 +42,8 @@ import re
 from pathlib import Path
 from typing import NamedTuple
 
+from . import hookhost
+
 MARKER = "<!-- boost:bmad-persona"
 """Prefix of the ownership stamp boost writes into every persona file.
 
@@ -752,7 +754,8 @@ def done_checklist(signals: dict, done: str = "change") -> list[str]:
 # --------------------------------------------------------------------- routing
 
 def route_lines(prompt: str, root: Path | None = None,
-                agents_dirs: tuple[Path, ...] | None = None) -> list[str]:
+                agents_dirs: tuple[Path, ...] | None = None,
+                host: str = hookhost.CLAUDE) -> list[str]:
     """The banner for one prompt: `[]` when the prompt is not a unit of work.
 
     Kept to a handful of lines on purpose — this is prepended to *every*
@@ -763,6 +766,11 @@ def route_lines(prompt: str, root: Path | None = None,
     are dropped: naming a subagent the session cannot spawn sends the model
     after something that does not exist. An edited file counts as present —
     it is still a subagent, just no longer boost's.
+
+    On a host other than Claude Code the personas are roles to adopt, not
+    subagents: Gemini's subagent tool is `invoke_agent` and boost writes no
+    personas for it, so its banner names no subagent, no Agent tool and no
+    ``~/.claude`` path.
     """
     root = Path(root) if root is not None else Path.cwd()
     track_name = classify(prompt, root)
@@ -775,15 +783,22 @@ def route_lines(prompt: str, root: Path | None = None,
         persona_state(d, lead) != "absent" for d in agents_dirs)
 
     lines = ["[BMAD autopilot] track: %s" % track_name]
-    if delegate:
+    if host != hookhost.CLAUDE:
+        lines.append("Lead: take the role of %s, %s. %s"
+                     % (lead.character, lead.title, track.note))
+        if track.support:
+            lines.append("Support: bring in the view of %s." % ", ".join(
+                "%s (%s)" % (PERSONA_BY_SLUG[s].character, PERSONA_BY_SLUG[s].title)
+                for s in track.support))
+    elif delegate:
         lines.append("Lead: `%s` subagent — %s, %s. %s"
                      % (lead.slug, lead.character, lead.title, track.note))
-    if delegate and track.support:
-        lines.append(
-            "Support: %s — spawn them with the Agent tool, in parallel where "
-            "the work is independent."
-            % ", ".join("`%s` (%s)" % (s, PERSONA_BY_SLUG[s].character)
-                        for s in track.support))
+        if track.support:
+            lines.append(
+                "Support: %s — spawn them with the Agent tool, in parallel where "
+                "the work is independent."
+                % ", ".join("`%s` (%s)" % (s, PERSONA_BY_SLUG[s].character)
+                            for s in track.support))
     lines.extend((
         "BMAD skill: `%s` — invoke it if it is installed; otherwise the "
         "persona's own playbook stands." % track.skill,
@@ -803,20 +818,31 @@ CHANGE_CLOSE = ("Finish the change and verify it; stop only for a choice that "
 
 
 def route_context(prompt: str, root: Path | None = None,
-                  agents_dirs: tuple[Path, ...] | None = None) -> str:
+                  agents_dirs: tuple[Path, ...] | None = None,
+                  host: str = hookhost.CLAUDE) -> str:
     """:func:`route_lines` as one string (``""`` when there is nothing to say)."""
-    return "\n".join(route_lines(prompt, root, agents_dirs))
+    return "\n".join(route_lines(prompt, root, agents_dirs, host))
 
 
 # ----------------------------------------------------------------- orientation
 
-def orientation() -> str:
-    """The SessionStart briefing: the roster, the phases, and the house rule."""
+_SUBAGENT_INTRO = ("This session routes work through BMAD personas. Persona "
+                   "subagents live in\n~/.claude/agents and are delegated to "
+                   "with the Agent tool:")
+_ROLE_INTRO = ("This session routes work through BMAD personas. A routing banner "
+               "names the\npersona whose role to take on for that prompt:")
+
+
+def orientation(host: str = hookhost.CLAUDE) -> str:
+    """The SessionStart briefing: the roster, the phases, and the house rule.
+
+    Only Claude Code gets persona subagents; elsewhere the roster is a list of
+    roles, for the same reason as :func:`route_lines`.
+    """
     roster = "\n".join(
         "  %-15s %s, %s" % (p.slug, p.character, p.title) for p in PERSONAS)
     return """[BMAD autopilot active]
-This session routes work through BMAD personas. Persona subagents live in
-~/.claude/agents and are delegated to with the Agent tool:
+%s
 
 %s
 
@@ -834,15 +860,26 @@ Full workflow skills need a per-project `_bmad/` runtime — `boost bmad init`.
 
 House rule: a change is done when its tests, its docs and its tracked item are;
 findings are done when each carries its evidence; an artifact is done when it is
-written down and tracked. Turn this off with `boost bmad off`.""" % roster
+written down and tracked. Turn this off with `boost bmad off`.""" % (
+        _SUBAGENT_INTRO if host == hookhost.CLAUDE else _ROLE_INTRO, roster)
 
 
 # ------------------------------------------------------------ persona files
 
 def persona_description(persona: Persona) -> str:
-    """The one-line `description:` Claude reads when choosing a subagent."""
-    return ("%s, %s (BMAD %s). Use PROACTIVELY for %s."
-            % (persona.character, persona.title, persona.module,
+    """The one-line `description:` Claude reads when choosing a subagent.
+
+    Claude Code treats this line as a delegation rule, and its docs recommend
+    "use proactively" to make delegation *more* eager. That wording made the
+    router's silence cosmetic: a prompt the router judged trivial, or marked
+    `no bmad`, got no banner but could still spawn a persona on the strength of
+    its description alone. Tying the trigger to the banner makes the router the
+    one place that decides, while naming the persona by slug keeps delegation
+    working when a banner does name it, or the user does.
+    """
+    return ("%s, %s (BMAD %s). Use when a [BMAD autopilot] routing banner names "
+            "%s, or the user asks for it by name. Covers %s."
+            % (persona.character, persona.title, persona.module, persona.slug,
                persona.triggers))
 
 

{boost_skill_cli-1.2.117 → boost_skill_cli-1.2.119}/boost_cli/core/hookhost.py

@@ -52,6 +52,8 @@ Gemini's tool names, and a lifecycle matcher is an exact string.
 """
 from __future__ import annotations
 
+import json
+
 from ..errors import BoostError
 
 CLAUDE = "claude"
@@ -257,3 +259,27 @@ def resolve(requested: str | None) -> list[str]:
         return hosts()
     _spec(str(requested))
     return [str(requested)]
+
+
+def context_output(host: str, event: str, text: str) -> str:
+    """What a hook prints to hand ``text`` to the model, for a Claude ``event``.
+
+    The two hosts read hook stdout differently, and the difference is silent.
+    Claude Code adds a `SessionStart` hook's plain stdout to the context, and
+    takes `UserPromptSubmit` context from ``hookSpecificOutput``. Gemini CLI
+    turns any non-JSON stdout into ``{decision: "allow", systemMessage: text}``
+    — shown to the *user* — and adds only ``additionalContext`` to the model's
+    history. So boost's session briefing, printed as text, reached Gemini users
+    as a 26-line info message and never reached the model at all (measured
+    against Gemini CLI 0.57.0's hook runner: ``systemMessage`` 1,297 chars,
+    ``additionalContext`` 0).
+
+    Claude's bytes are unchanged. Gemini always gets JSON, under its own name
+    for the event.
+    """
+    if host == CLAUDE and event == "SessionStart":
+        return text
+    return json.dumps({"hookSpecificOutput": {
+        "hookEventName": translate(host, event),
+        "additionalContext": text,
+    }})

{boost_skill_cli-1.2.117 → boost_skill_cli-1.2.119/boost_skill_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.117
+Version: 1.2.119
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0

{boost_skill_cli-1.2.117 → boost_skill_cli-1.2.119}/docs/bmad.md

@@ -83,7 +83,7 @@ puts real change requests on both kinds.
 Only a change gets the closing "finish and verify" line, and that line defers
 to any approval step your repo guide or a loaded skill requires.
 
-The router costs a question nothing. Acknowledgements, slash commands, short
+The router leaves questions alone. Acknowledgements, slash commands, short
 questions ("what does `scan_dir` do?", "are there tests for the parser?"),
 "read X and tell me Y" asks and anything containing `no bmad` produce no banner
 at all. Pasted output is scored on the lines you typed around it, and needs two
@@ -100,6 +100,14 @@ scope, so a copy `boost bmad off` could not reach (a committed project
 `.claude/settings.json` in another checkout, a restored settings snapshot) stays
 silent, and a banner never names a persona whose file is gone.
 
+That silence governs the banner, and the personas are written to follow it.
+Claude Code decides delegation from the `description` line of a subagent, so
+each persona says it applies when a routing banner names it, or when you ask for
+it by name; a silent or `no bmad` prompt has nothing pointing at a persona
+except the session briefing's roster. The final call is Claude Code's, not boost's.
+Personas written by earlier releases said "Use PROACTIVELY" instead: run
+`boost bmad on` again to rewrite the ones you have not edited.
+
 ```bash
 boost bmad personas                            # the roster, and whether it's installed
 boost bmad route "add tests for the scanner" --plain   # what would this route to?
@@ -144,8 +152,18 @@ 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.
+persona would be rejected. What a second host gets is prompt shaping. Gemini's
+hooks run `bmad route --host gemini` and `bmad orient --host gemini`, which
+answer in the JSON Gemini adds to the model's context (plain stdout on Gemini is
+shown to you instead, and never reaches the model), and name the lead persona as
+a role to take on rather than a subagent to spawn.
+
+Pass `--host claude`, `--host gemini` or `--host auto` (the default, the rule
+above) to `boost bmad on` or `boost bmad startup on` to choose for yourself:
+
+```bash
+boost bmad on --host claude     # never touch ~/.gemini/settings.json
+```
 
 ## The full BMAD method
 

{boost_skill_cli-1.2.117 → boost_skill_cli-1.2.119}/docs/commands.html

@@ -192,7 +192,7 @@
       <a class="cmd-link" href="#cmd-serve" data-search="serve browse the catalogue in a browser: search, facets and a tap graph  --port port --host host">serve</a>
       <a class="cmd-link" href="#cmd-mcp" data-search="mcp register boost as an mcp server (claude code, gemini cli, antigravity cli) register boost as an mcp server for your agent clis --host h --stdio --dry-run --seed --no-seed {register,unregister}">mcp</a>
       <a class="cmd-link" href="#cmd-hooks" data-search="hooks manage agent hooks (claude code, gemini cli) in settings.json manage agent hooks (scope- and host-aware) in settings.json --host h -c, --command command -n, --name name -s, --scope {global,project} -m, --matcher matcher --timeout timeout --json {add,remove,list} event">hooks</a>
-      <a class="cmd-link" href="#cmd-bmad" data-search="bmad bmad method autopilot — `bmad on` routes every task to a persona bmad method autopilot: personas, prompt routing, workflows -s, --scope {project,global} --modules modules -y, --yes --startup --plain action value">bmad</a>
+      <a class="cmd-link" href="#cmd-bmad" data-search="bmad bmad method autopilot — `bmad on` routes every task to a persona bmad method autopilot: personas, prompt routing, workflows -s, --scope {project,global} --modules modules -y, --yes --startup --plain --host h action value">bmad</a>
       <a class="cmd-link" href="#cmd-self-update" data-search="self-update update boost itself to the latest version  --dry-run">self-update</a>
     </div>
     <div class="group" data-group="team">
@@ -1188,10 +1188,10 @@
           <div class="arg"><code>--json</code><span>machine-readable output (list)</span></div>
         </div>
       </section>
-      <section class="cmd" id="cmd-bmad" data-search="bmad bmad method autopilot — `bmad on` routes every task to a persona bmad method autopilot: personas, prompt routing, workflows -s, --scope {project,global} --modules modules -y, --yes --startup --plain action value">
+      <section class="cmd" id="cmd-bmad" data-search="bmad bmad method autopilot — `bmad on` routes every task to a persona bmad method autopilot: personas, prompt routing, workflows -s, --scope {project,global} --modules modules -y, --yes --startup --plain --host h action value">
         <h3><span class="cname">bmad</span><span class="gtag">cfg</span></h3>
         <p class="summary">BMAD Method autopilot — `bmad on` routes every task to a persona</p>
-        <pre class="syn">boost bmad [-s {project,global}] [--modules MODULES] [-y] [--startup] [--plain] ACTION [value]</pre>
+        <pre class="syn">boost bmad [-s {project,global}] [--modules MODULES] [-y] [--startup] [--plain] [--host H] ACTION [value]</pre>
         <p class="desc">BMAD Method autopilot: personas, prompt routing, workflows</p>
         <div class="args-h">Arguments</div>
         <div class="args">
@@ -1205,6 +1205,7 @@
           <div class="arg"><code>-y, --yes</code><span>skip confirmation prompts</span></div>
           <div class="arg"><code>--startup</code><span>enable the startup toggle right after install</span></div>
           <div class="arg"><code>--plain</code><span>route: print the banner as text, not as hook JSON</span></div>
+          <div class="arg"><code>--host H</code><span>on/startup: hosts to hook (claude | gemini; default auto: claude + any in use) · route/orient: output format</span></div>
         </div>
       </section>
       <section class="cmd" id="cmd-self-update" data-search="self-update update boost itself to the latest version  --dry-run">

{boost_skill_cli-1.2.117 → boost_skill_cli-1.2.119}/docs/roadmap/items/bmad-gemini-gets-claude-hook-output.md

@@ -2,15 +2,15 @@
 id: bmad-gemini-gets-claude-hook-output
 board: code
 section: dx
-status: next
+status: shipped
 category: "Agents · BMAD"
 complexity: M
 impact: Med
 wow: 2
 note: gemini takes the banner but shows the briefing to the user
 order: 324
-owner:
-pr:
+owner: loop/bmad-gemini-hook-output
+pr: 866
 title: On Gemini, the <code>bmad on</code> briefing reaches the user and never the model
 ---
 <code>boost bmad on</code> installs both autopilot hooks on Claude always, and on Gemini whenever

{boost_skill_cli-1.2.117 → boost_skill_cli-1.2.119}/docs/roadmap/items/bmad-personas-delegate-outside-the-router.md

@@ -2,15 +2,15 @@
 id: bmad-personas-delegate-outside-the-router
 board: code
 section: dx
-status: next
+status: shipped
 category: "Agents · BMAD"
 complexity: S
 impact: Med
 wow: 3
 note: router silence is banner-only, and nobody has counted
 order: 325
-owner:
-pr:
+owner: loop/bmad-persona-triggers
+pr: 865
 title: "Persona descriptions say <code>Use PROACTIVELY</code>, so the router's silence governs only the banner"
 ---
 <code>boost bmad on</code> gives Claude Code two routes to a persona, and only one goes through the router.