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

{boost_skill_cli-1.2.118/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.118
+Version: 1.2.119
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0

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

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

@@ -18,6 +18,7 @@ of the thinking lives in :mod:`boost_cli.core.bmad`; this module is glue.
     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.118 → 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,7 +860,8 @@ 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

{boost_skill_cli-1.2.118 → 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.118 → 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.118
+Version: 1.2.119
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0

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

@@ -152,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.118 → 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.118 → 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.118 → boost_skill_cli-1.2.119}/docs/roadmap.html

@@ -7680,63 +7680,9 @@ would trade a dead pointer for a misroute.</p>
       </article>
 
       <article class="cap rcard" id="bmad-gemini-gets-claude-hook-output">
-        <div class="head"><span class="pill next">Next</span><span class="cat">Agents · BMAD</span></div>
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Agents · BMAD</span></div>
         <h3>On Gemini, the <code>bmad on</code> briefing reaches the user and never the model</h3>
-        <p><code>boost bmad on</code> installs both autopilot hooks on Claude always, and on Gemini whenever
-<code>gemini</code> is on <code>PATH</code> <em>or</em> <code>~/.gemini/</code> exists
-(<code>commands/bmad.py:177</code>). It has no <code>--host</code>
-(<code>:98</code>–<code>112</code>), so Claude-only means hand-editing Gemini's settings, and the
-next <code>bmad on</code> re-adds what was deleted. The <a href="#bmad-hooks-all-hosts">fan-out</a> translated event names and timeout
-units, but left stdout in Claude's format. Checked against <b>Gemini CLI 0.57.0</b>: its bundled
-hook runner was read, then imported and driven against main's hooks in a throwaway
-<code>HOME</code> with only an empty <code>.gemini/</code>.
-
-<b>The router works, so this is narrower than hooks that do nothing.</b> Gemini's
-<code>BeforeAgent</code> input has <code>prompt</code> and <code>cwd</code> under the names
-<code>_route</code> reads (<code>:341</code>–<code>342</code>), and <code>hookEventName</code> is
-never validated, so the hardcoded <code>"UserPromptSubmit"</code> (<code>:353</code>) is harmless.
-Measured: <b><code>outputFormat: json</code>, 643 chars of <code>additionalContext</code></b> for a
-build-track banner.
-
-<b>The briefing never reaches the model.</b> <code>_orient</code> prints plain text
-(<code>:530</code>), which Claude Code adds to context. Gemini turns non-JSON stdout into
-<code>{decision: "allow", systemMessage: text}</code> and adds only <code>additionalContext</code>
-to history. Measured: <b><code>systemMessage</code> 1,297 chars, <code>additionalContext</code>
-0</b>. The 26-line briefing is shown to the user as an info message instead, on
-<code>startup</code>, <code>resume</code> and <code>/clear</code>.
-
-<b>What does reach the model is framed as data, and names tools Gemini lacks.</b> Gemini wraps
-<code>additionalContext</code> in <code>&lt;hook_context&gt;</code>, and its default system prompt
-says to treat that as "<b>read-only data</b> or <b>informational context</b>". The banner is all
-instructions. It names a <code>bmad-dev</code> subagent and spawning support personas with the Agent
-tool (<code>core/bmad.py:538</code>, <code>:543</code>), and the briefing puts the personas in
-<code>~/.claude/agents</code> (<code>:570</code>). Gemini's subagent tool is
-<code>invoke_agent</code>, and boost writes no personas for it. <em>Not measured:</em> whether a
-Gemini model follows the banner anyway, since no live model call was made. <em>Also seen:</em>
-Gemini parses stderr when stdout is empty, so a launcher that rejects the action shows its argparse
-error as a <code>systemMessage</code> despite <code>|| true</code> (simulated once, 330 chars).
-
-<b>Proposed fix.</b> <i>(1)</i> <code>bmad on</code> and <code>startup on</code> take <code>--host
-claude|gemini|auto</code>, the choices <code>boost hooks --host</code> has
-(<code>commands/hooks.py:45</code>), with <code>auto</code> as today's evidence rule. <i>(2)</i>
-Gemini's hooks run <code>bmad route --host gemini</code> and <code>bmad orient … --host
-gemini</code>. Claude's commands stay byte-identical. <i>(3)</i> A pure
-<code>hookhost.context_output(host, event, text)</code> formats stdout: Claude's is unchanged, and
-Gemini always gets JSON, with <code>hookEventName</code> from <code>translate()</code> and the text in
-<code>additionalContext</code>. That reaches the model on startup and resume, not after
-<code>/clear</code>, whose Gemini path reads only <code>systemMessage</code>. <i>(4)</i>
-<code>route_lines</code> and <code>orientation</code> take the host. On Gemini the lead is a role
-to adopt, with no subagent, Agent tool or <code>~/.claude</code> wording.
-
-<b>Tests.</b> <code>tests/unit/test_hookhost.py</code>: for each host and both events, Gemini output
-passes <code>json.loads</code> with the text in <code>additionalContext</code> (plain text is the
-regression), and Claude output matches today's bytes. <code>tests/unit/test_bmad_core.py</code>: the
-Gemini banner and briefing name no subagent, Agent tool or <code>~/.claude</code>. Parametrize
-<code>test_emits_the_hook_json_contract</code> by host
-(<code>tests/functional/test_cli_bmad.py:480</code>, which pins <code>"UserPromptSubmit"</code> at
-<code>:492</code>). In <code>tests/functional/test_bmad_all_hosts.py</code>, assert that Gemini's
-commands carry <code>--host gemini</code> and that <code>--host claude</code> never writes
-<code>~/.gemini/settings.json</code>.</p>
+        <p class="cardbody"><a class="writeup" href="https://github.com/jonnyeclectic/boost/blob/main/docs/roadmap/items/bmad-gemini-gets-claude-hook-output.md">Write-up &middot; bmad-gemini-gets-claude-hook-output.md</a></p>
         <div class="meta">
           <span class="m">Complexity <b>M</b></span>
           <span class="m">Impact <b>Med</b></span>