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

{boost_skill_cli-1.2.118/boost_skill_cli.egg-info → boost_skill_cli-1.2.120}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.118
+Version: 1.2.120
 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.120}/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.120'
+__version_tuple__ = version_tuple = (1, 2, 120)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.118 → boost_skill_cli-1.2.120}/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()}
@@ -457,7 +490,7 @@ def _require_npx() -> None:
 
 
 def _run_installer(directory: Path, modules: str) -> subprocess.CompletedProcess:
-    cmd = ["npx", "--yes", "bmad-method@latest", "install",
+    cmd = ["npx", "--yes", "bmad-method@%s" % core.BMAD_VERSION, "install",
            "--yes", "--directory", str(directory),
            "--tools", "claude-code", "--modules", modules,
            "--user-name", _whoami()]
@@ -490,12 +523,24 @@ def _install(scope, modules, do_startup) -> int:
     scope = scope or "project"
     _require_npx()
     if scope == "global":
-        n = _copy_global_skills(modules)
-        _set_scope_state("global", installed=True, skills=n,
+        before = _get_scope_state("global")
+        ver, names = _copy_global_skills(modules)
+        dropped = _drop_retired_skills(before, names, modules)
+        _set_scope_state("global", installed=True, skills=len(names),
+                         skill_list=names, version=ver,
                          modules=modules.split(","), installed_at=util.now_iso())
-        out.ok("installed %d BMAD skill(s) globally → %s"
-               % (n, _skills_dir("global")))
-        out.dim("  run `boost bmad init` in a project for its _bmad/ workflow runtime")
+        out.ok("installed %d BMAD skill(s) globally → %s (v%s)"
+               % (len(names), _skills_dir("global"), ver))
+        if dropped:
+            out.info("removed %d skill(s) this BMAD release no longer installs: %s"
+                     % (len(dropped), ", ".join(dropped)))
+        needs_runtime = [n for n in core.RUNTIME_SKILLS if n in names]
+        if needs_runtime:
+            out.warn("%s halt without a per-repo _bmad/ runtime — run "
+                     "`boost bmad init` in each repo that uses them"
+                     % " and ".join(needs_runtime))
+        else:
+            out.dim("  run `boost bmad init` in a project for its _bmad/ workflow runtime")
     else:
         ver, n = _install_project_runtime(modules)
         out.ok("installed BMAD in %s (%d skills, v%s)" % (Path.cwd(), n, ver))
@@ -524,15 +569,20 @@ def _install_project_runtime(modules):
     return ver, n
 
 
-def _copy_global_skills(modules) -> int:
-    """Stage the installer in a temp dir; copy only bmad-* skills into ~/.claude."""
+def _copy_global_skills(modules) -> tuple[str, list[str]]:
+    """Stage the installer in a temp dir; copy only bmad-* skills into ~/.claude.
+
+    Returns ``(version, skill names copied)``. The names are recorded so the
+    next global install knows which skills are boost's to retire.
+    """
     stage = Path(tempfile.mkdtemp(prefix="boost-bmad-"))
     try:
-        _run_installer(stage, modules)
+        proc = _run_installer(stage, modules)
+        ver = _parse_version((proc.stdout or "") + (proc.stderr or ""))
         src = stage / ".claude" / "skills"
         dest = _skills_dir("global")
         dest.mkdir(parents=True, exist_ok=True)
-        n = 0
+        names = []
         for d in sorted(src.glob("bmad-*")):
             if not d.is_dir():
                 continue
@@ -540,20 +590,54 @@ def _copy_global_skills(modules) -> int:
             if t.exists():
                 util.rmtree(t)
             shutil.copytree(d, t)
-            n += 1
-        return n
+            names.append(d.name)
+        return ver, names
     finally:
         shutil.rmtree(stage, ignore_errors=True)
 
 
+def _drop_retired_skills(before: dict, installed: list[str],
+                         modules: str) -> list[str]:
+    """Remove skills the last global install recorded and this one did not ship.
+
+    The copy only replaces directories the new stage has, and upstream's own
+    cleanup runs inside the empty stage, never against `~/.claude/skills` — so
+    a skill a release retired (`bmad-document-project` in 6.12.0) survived
+    every reinstall. Only *recorded* names go: another `bmad-*` directory may
+    be the user's own.
+
+    **A narrower module set retires nothing.** `--modules` defaults to `bmm` on
+    every run, so `boost bmad install --scope global` after an earlier
+    `--modules bmm,cis` stages only bmm — and every cis skill would read as
+    "retired by the release" and be deleted. A run can only retire within the
+    modules it actually installed.
+    """
+    previous = before.get("skill_list")
+    if not isinstance(previous, list):
+        return []
+    had = before.get("modules")
+    if isinstance(had, list) and set(had) - set(modules.split(",")):
+        return []
+    dest = _skills_dir("global")
+    dropped = []
+    for name in sorted({n for n in previous if isinstance(n, str)} - set(installed)):
+        # A hand-edited state file must not steer the delete out of the dir.
+        if not (name.startswith("bmad-") and Path(name).name == name):
+            continue
+        if (dest / name).is_dir():
+            util.rmtree(dest / name)
+            dropped.append(name)
+    return dropped
+
+
 # ----------------------------------------------------------------------- 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 +656,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 +673,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 +768,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 +801,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.120}/boost_cli/core/bmad.py

@@ -24,7 +24,8 @@ first time it was assumed rather than checked:
   persona subagents below are boost's to author — they duplicate nothing.
 * **The bmm module ships five personas, not seven.** Mary, John, Sally, Winston
   and Amelia. Murat (test architect) is the separate `tea` module and Paige
-  (technical writer) is a game-dev-studio agent, "on hiatus" in bmm. boost
+  (technical writer) is a game-dev-studio agent, "on hiatus" in bmm — bmm's own
+  `bmad-agent-tech-writer` was retired in v6.11.0 as "generic LLM defaults". boost
   authors all seven anyway, because a routing table with no owner for tests or
   docs cannot honour the done-contract; the two extras are labelled as such.
 
@@ -42,6 +43,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.
 
@@ -57,6 +60,25 @@ statements true: edit the file however you like and boost stops claiming it.
 
 _STAMP_RE = re.compile(r"<!-- boost:bmad-persona ([0-9a-f]{12}) -->")
 
+BMAD_VERSION = "6.12.0"
+"""The bmad-method release `boost bmad install` installs, and the tables name.
+
+It used to install `@latest` while the skill names below were hard-coded, and
+the tests only checked the tables against each other — so when v6.11.0 turned
+`bmad-document-project` into a shim and v6.12.0 stopped installing shims, the
+docs track kept routing at a skill no default install contains, and nothing
+noticed. `tests/unit/data/bmad-skills-<version>.json` is that release's skill
+list; bumping this without regenerating it fails the build.
+"""
+
+RUNTIME_SKILLS: tuple[str, ...] = ("bmad-build", "bmad-build-auto")
+"""Skills that halt without a per-repo `_bmad/` runtime.
+
+They start by running `{project-root}/_bmad/scripts/render_skill.py`, so a
+global install leaves them broken in every repo `boost bmad init` has not
+touched — while reporting every skill installed.
+"""
+
 
 class Persona(NamedTuple):
     """A BMAD persona, rendered as one Claude Code subagent definition."""
@@ -77,7 +99,7 @@ class Track(NamedTuple):
 
     lead: str                  # persona slug
     support: tuple[str, ...]   # persona slugs to run alongside the lead
-    skill: str                 # canonical BMAD v6 skill for this track
+    skill: str | None          # canonical BMAD v6 skill, if one fits
     note: str                  # how the lead should open
     done: str                  # what finished looks like: one of DONE_KINDS
 
@@ -241,8 +263,10 @@ PERSONAS: tuple[Persona, ...] = (
             "never by editing the output; a hand-edit fails the freshness gate.",
             "Write for the reader who arrives at 2am with a broken build: what "
             "it does, how to run it, what breaks it.",
+            "`bmad-project-context` is for the agent-instruction block in "
+            "`AGENTS.md` only; READMEs and guides need no BMAD skill.",
         ),
-        skills=("bmad-document-project",),
+        skills=("bmad-project-context",),
     ),
 )
 
@@ -276,7 +300,11 @@ TRACKS: dict[str, Track] = {
         skill="bmad-qa-generate-e2e-tests",
         note="Assertions that a mutation would fail.", done="change"),
     "docs": Track(
-        lead="bmad-scribe", support=("bmad-dev",), skill="bmad-document-project",
+        # No skill: `bmad-document-project` is a shim since v6.11.0 and not
+        # installed since v6.12.0, and its replacement `bmad-project-context`
+        # manages one block in AGENTS.md — routing every README edit there
+        # would trade a dead pointer for a misroute.
+        lead="bmad-scribe", support=("bmad-dev",), skill=None,
         note="Verify against the code, regenerate what is generated.", done="change"),
     "review": Track(
         lead="bmad-tea", support=("bmad-architect",), skill="bmad-code-review",
@@ -752,7 +780,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 +792,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,20 +809,26 @@ 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))
-    lines.extend((
-        "BMAD skill: `%s` — invoke it if it is installed; otherwise the "
-        "persona's own playbook stands." % track.skill,
-        "Done means: " + " · ".join(done_checklist(signals, track.done)),
-    ))
+        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))
+    if track.skill:
+        lines.append("BMAD skill: `%s` — invoke it if it is installed; otherwise "
+                     "the persona's own playbook stands." % track.skill)
+    lines.append("Done means: " + " · ".join(done_checklist(signals, track.done)))
     if track.done == "change":
         # Not "work autonomously": that competed with approval gates people add
         # on purpose, and the guide clause above only exists when a guide does.
@@ -803,26 +843,37 @@ 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
 
 Every substantive prompt arrives with a one-line routing banner naming the lead
-persona, the support personas, the BMAD skill for that track, and the definition
-of done for this repo. Follow it. Trivial asks get no banner — answer those
+persona, the support personas, the BMAD skill for that track when one fits, and
+the definition of done for this repo. Follow it. Trivial asks get no banner — answer those
 directly and skip the ceremony.
 
 BMAD v6 workflow skills, if installed (`boost bmad install`): plan with
@@ -834,7 +885,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.120}/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,
+    }})