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

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

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

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

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

{boost_skill_cli-1.2.36 → boost_skill_cli-1.2.38}/boost_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.2.36'
-__version_tuple__ = version_tuple = (1, 2, 36)
+__version__ = version = '1.2.38'
+__version_tuple__ = version_tuple = (1, 2, 38)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.36 → boost_skill_cli-1.2.38}/boost_cli/cli.py

@@ -199,7 +199,12 @@ def print_help() -> None:
         else:
             print(head)
         for n, s in cmds:
-            print("  " + out.c(n.ljust(width + 2), out.CYAN)
+            # accent, not a raw 16-color CYAN: every other command-name
+            # surface (search rows, info badges) resolves through this same
+            # semantic role, which is Aurora truecolor cyan with the correct
+            # 16-color/plain degradation — a raw CYAN here painted a visibly
+            # different cyan on any truecolor terminal.
+            print("  " + out.role(n.ljust(width + 2), "accent")
                   + out.truncate(s, max(0, cols - width - 4)))
     print()
     print(out.c("%d commands · %d groups" % (len(COMMANDS), len(GROUPS)), out.DIM))

boost_skill_cli-1.2.38/boost_cli/cliparse.py

@@ -0,0 +1,66 @@
+# Copyright the boost contributors.
+# SPDX-License-Identifier: GPL-3.0-only
+"""A branded ArgumentParser.
+
+Argparse's default failure output is a raw, unstyled ``usage:`` block with a
+bare ``prog: error: …`` line — nothing like boost's branded top-level dispatch
+(which routes through :func:`output.err` and offers a "did you mean"). This
+subclass routes a parser's own errors through the same Aurora output layer, so
+a wrong invocation looks as designed as a right one.
+
+Adopt it via :func:`parser` in place of ``argparse.ArgumentParser``. Sub-parsers
+created with ``add_subparsers()`` inherit this class automatically, so a single
+top-level swap brands a command's whole tree.
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+
+from .core import output as out
+
+
+class _BoostHelpFormatter(argparse.HelpFormatter):
+    """Wraps help/description text the way :func:`output.wrap` does,
+    keeping a backtick-quoted command atomic instead of splitting it across
+    lines — the same rule every other long line in this CLI follows.
+
+    argparse's own ``HelpFormatter`` wraps with plain ``textwrap``, which
+    knows nothing about a backtick span (``doctor``/``search`` interpolate
+    hints ending in a pasteable ``pip install '...'``-style command; several
+    ``help=`` strings quote a ``boost`` invocation the same way) — so a
+    narrow terminal could split one across two lines, handing the user a
+    command that does not run. Only the two text-filling hooks are
+    overridden; ``_format_usage``'s own line-splitting already treats a
+    metavar as one atomic part and is left alone.
+    """
+
+    def _split_lines(self, text: str, width: int) -> list[str]:
+        text = self._whitespace_matcher.sub(" ", text).strip()
+        return out.wrap(text, width) or [text]
+
+    def _fill_text(self, text: str, width: int, indent: str) -> str:
+        text = self._whitespace_matcher.sub(" ", text).strip()
+        lines = out.wrap(text, max(width - len(indent), 1)) or [text]
+        return "\n".join(indent + ln for ln in lines)
+
+
+class BoostArgumentParser(argparse.ArgumentParser):
+    def __init__(self, *args, **kwargs):
+        # add_subparsers() creates each sub-parser via type(self)(**kwargs)
+        # without forwarding formatter_class, so defaulting it here (rather
+        # than in parser() below) is what brands every subcommand's --help
+        # too, not just the top-level one.
+        kwargs.setdefault("formatter_class", _BoostHelpFormatter)
+        super().__init__(*args, **kwargs)
+
+    def error(self, message: str):
+        """Print a branded error + dimmed usage, then exit 2 (argparse's code)."""
+        out.err(message)
+        sys.stderr.write(out.c(self.format_usage(), out.DIM))
+        self.exit(2)
+
+
+def parser(*args, **kwargs) -> BoostArgumentParser:
+    """Drop-in replacement for ``argparse.ArgumentParser(...)``."""
+    return BoostArgumentParser(*args, **kwargs)

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

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

{boost_skill_cli-1.2.36 → boost_skill_cli-1.2.38}/boost_cli/commands/discovery.py

@@ -1630,7 +1630,7 @@ def cmd_stats(argv):
         else:
             out.kv("latest", "%s %s" % (latest, out.role("(up to date)", "muted")))
     if upstream:
-        out.kv("upstream", upstream)
+        out.kv("upstream", upstream, wrap=True)
     return 0
 
 

{boost_skill_cli-1.2.36 → boost_skill_cli-1.2.38}/boost_cli/commands/info.py

@@ -13,7 +13,6 @@ import re
 import shlex
 import subprocess
 import sys
-import textwrap
 import webbrowser
 from itertools import chain
 from pathlib import Path
@@ -197,9 +196,12 @@ def _mark(installed: bool) -> str:
 
 
 def _print_wrapped(text: str) -> None:
+    """Wrap prose to the *real* pane via out.wrap(), not a hardcoded width —
+    a fixed textwrap width=76 neither shrank for a narrow terminal nor grew
+    for a wide one, and did not know a backtick span must stay whole."""
     paras = [p for p in re.split(r"\n\s*\n", text.strip()) if p.strip()]
     for i, para in enumerate(paras):
-        for line in textwrap.wrap(" ".join(para.split()), width=76):
+        for line in out.wrap(" ".join(para.split()), out.term_width() - 2):
             out.info(line)
         if i < len(paras) - 1:
             print()
@@ -471,10 +473,11 @@ def cmd_info(argv):
     if badges:
         out.info(" ".join(badges))
     if desc:
-        lines = textwrap.wrap(desc, width=62)
-        out.kv("description", lines[0])
-        for ln in lines[1:]:
-            print(" " * 16 + ln)
+        # kv's own wrap=True already folds to the real terminal width and
+        # aligns continuations under the value — the hand-rolled version this
+        # replaced hardcoded width=62 (a hand copy of kv's default 16-column
+        # lead against a fixed 78-column pane) and ignored COLUMNS entirely.
+        out.kv("description", desc, wrap=True)
     if lock:
         inst_v = str(lock.get("version", "?"))
         out.kv("version", inst_v)
@@ -630,9 +633,19 @@ def _render_markdown(body: str) -> None:
             continue
         m = re.match(r"^(\s*)[-*]\s+(.*)$", line)
         if m:
-            print("%s • %s" % (m.group(1), _inline(m.group(2))))
+            prefix = "%s • " % m.group(1)
+            # Wrap the raw markdown first, THEN colorize each wrapped chunk —
+            # coloring before wrapping (the old behavior for the plain-prose
+            # branch below) would either split an inline `code` span or leave
+            # line 1's color code unterminated. A backtick span is one atomic
+            # token either way, via out.wrap().
+            wrapped = out.wrap(m.group(2), out.term_width() - len(prefix)) or [""]
+            for i, chunk in enumerate(wrapped):
+                lead = prefix if i == 0 else " " * len(prefix)
+                print(lead + _inline(chunk))
             continue
-        print(_inline(line))
+        for chunk in out.wrap(line, out.term_width()) or [""]:
+            print(_inline(chunk))
 
 
 def cmd_preview(argv):

{boost_skill_cli-1.2.36 → boost_skill_cli-1.2.38}/boost_cli/commands/intelligence.py

@@ -772,8 +772,10 @@ _CONTEXT_DEFAULT = {"enabled": False, "rules": []}
 def cmd_context(argv: list[str]) -> int:
     ap = cliparse.parser(
         prog="boost context", description="Branch-aware skill activation")
-    sub = ap.add_subparsers(dest="action",
-                            metavar="status|enable|disable|map|unmap|apply")
+    # metavar="ACTION": the full "status|enable|disable|map|unmap|apply"
+    # spelling is one unbreakable token that overflowed the usage line at 60
+    # columns. Each subcommand still lists its own help= below.
+    sub = ap.add_subparsers(dest="action", metavar="ACTION")
     sp = sub.add_parser("status", help="show rules, enabled flag & branch")
     sp.add_argument("--json", action="store_true")
     sub.add_parser("enable", help="turn on branch-aware activation (runs apply)")
@@ -873,7 +875,8 @@ def _context_status(state: dict, as_json: bool) -> int:
     out.kv("branch", branch or "(not in a git repository)")
     rules = state.get("rules", [])
     if not rules:
-        out.info("no rules — add one with `boost context map 'feature/*' skill1,skill2`")
+        out.info("no rules — add one with `boost context map 'feature/*' "
+                "skill1,skill2`", wrap=True)
         return 0
     rows = [(r.get("pattern", "?"), ", ".join(r.get("skills", [])),
              "*" if branch and fnmatch.fnmatch(branch, r.get("pattern", "")) else "")

{boost_skill_cli-1.2.36 → boost_skill_cli-1.2.38}/boost_cli/commands/team.py

@@ -128,7 +128,7 @@ def cmd_cohort(argv) -> int:
             raise BoostError("no cohort named %s" % args.name,
                             hint="list cohorts with `boost cohort list`")
         if not targets:
-            out.info("no cohorts defined")
+            print(out.empty_state("no cohorts defined"))
             return 0
         applied = skipped = 0
         for cname in targets:
@@ -174,8 +174,11 @@ def cmd_cohort(argv) -> int:
         print(json.dumps(data, indent=2))
         return 0
     if not rows:
-        out.info("no cohorts defined")
-        out.info(out.role("create one: `boost cohort create pilot --skills tdd-workflow --percent 50`", "muted"))
+        print(out.empty_state(
+            "no cohorts defined",
+            hint="create one: `boost cohort create pilot --skills "
+                 "tdd-workflow --percent 50`",
+            wrap=True))
         return 0
     out.table(rows, headers=("COHORT", "SKILLS", "ROLLOUT", "YOU"))
     print()
@@ -518,7 +521,9 @@ def cmd_pulse(argv) -> int:
         print(json.dumps(events, indent=2))
         return 0
     if not events:
-        out.info("no activity yet — events appear as you install and manage skills")
+        print(out.empty_state(
+            "no activity yet — events appear as you install and manage skills",
+            wrap=True))
         return 0
     for e in events:
         action = e.get("action", "?")
@@ -557,7 +562,9 @@ def cmd_replay(argv) -> int:
             print(json.dumps(history, indent=2))
             return 0
         if not history:
-            out.info("no lock history yet — every install/uninstall snapshots the lock file")
+            print(out.empty_state(
+                "no lock history yet — every install/uninstall snapshots "
+                "the lock file", wrap=True))
             return 0
         rows = []
         prev_items = None
@@ -693,8 +700,9 @@ def cmd_who(argv) -> int:
 
     events = journal.events(subject=args.skill) if args.skill else journal.events()
     if not events:
-        out.info("no journal activity yet — expertise builds as people install, "
-                 "edit, and evolve skills")
+        print(out.empty_state(
+            "no journal activity yet — expertise builds as people install, "
+            "edit, and evolve skills", wrap=True))
         return 0
 
     if args.skill:

{boost_skill_cli-1.2.36 → boost_skill_cli-1.2.38}/boost_cli/core/output.py

@@ -16,6 +16,7 @@ import os
 import re
 import shutil
 import sys
+import unicodedata
 from collections.abc import Sequence
 from dataclasses import dataclass
 
@@ -336,9 +337,30 @@ def badge(label: str, hue: str = "cyan") -> str:
 _ANSI_RE = re.compile(r"\033\[[0-9;]*m")
 
 
+def _char_width(ch: str) -> int:
+    """Terminal display width of one character: 2 for wide/fullwidth CJK and
+    most emoji, 0 for a combining mark, 1 otherwise.
+
+    A pure-stdlib approximation of wcwidth via ``unicodedata`` — no dependency
+    to earn just for column math, and the two classes it distinguishes
+    (``unicodedata.east_asian_width`` returning "W"/"F") are exactly the ones
+    that render two columns wide in every terminal this CLI targets.
+    """
+    if unicodedata.combining(ch):
+        return 0
+    return 2 if unicodedata.east_asian_width(ch) in ("W", "F") else 1
+
+
 def visible_len(s: str) -> int:
-    """Length of a string ignoring ANSI color escapes — its column width."""
-    return len(_ANSI_RE.sub("", s))
+    """Column width of a string: ANSI escapes cost nothing, a wide character
+    (CJK, most emoji) costs 2, everything else costs 1.
+
+    ``len()`` alone undercounts any string holding a double-width character,
+    which is what silently misaligned a table the moment a cell held an emoji
+    or CJK text — the column budget was measured a codepoint short of what
+    the terminal actually draws.
+    """
+    return sum(_char_width(ch) for ch in _ANSI_RE.sub("", s))
 
 
 _CODE_SPAN_RE = re.compile(r"`[^`]*`")
@@ -457,13 +479,26 @@ _TRAFFIC = ((0xff, 0x5f, 0x57, RED), (0xfe, 0xbc, 0x2e, YELLOW),
             (0x28, 0xc8, 0x40, GREEN))
 
 
-def empty_state(message: str, hint: str | None = None) -> str:
+def empty_state(message: str, hint: str | None = None, wrap: bool = False) -> str:
     """A standardized empty-state: a muted ○ bullet + message, with an optional
     dim → hint on the next line. One affordance so 'nothing here' always reads
-    the same across commands."""
-    out_lines = ["  " + c("○ " + message, DIM)]
+    the same across commands.
+
+    ``wrap`` as in :func:`warn`: opt-in, folding each block to the pane rather
+    than always-on, so a call site with an atomic backtick-quoted command
+    (e.g. cohort's create hint) still gets that command whole rather than
+    split across lines. Both markers ("○ " / "→ ") are two visible columns,
+    matching the module's other 4-column-lead emitters (2-space indent + a
+    2-wide marker), so message and hint wrap to the same budget.
+    """
+    def _block(marker: str, text: str) -> list[str]:
+        body = _wrap_lines(text, 4) if wrap else [text]
+        return (["  " + c(marker + body[0], DIM)]
+                + ["    " + c(ln, DIM) for ln in body[1:]])
+
+    out_lines = _block("○ ", message)
     if hint:
-        out_lines.append("  " + c("→ " + hint, DIM))
+        out_lines += _block("→ ", hint)
     return "\n".join(out_lines)
 
 
@@ -676,8 +711,11 @@ def _clip_visible(s: str, width: int, ellipsis: str = "…") -> str:
             had_escape = True
             i = m.end()
             continue
+        w = _char_width(s[i])
+        if vis + w > keep:
+            break  # a wide character never gets cut in half for the ellipsis
         out_chars.append(s[i])
-        vis += 1
+        vis += w
         i += 1
     result = "".join(out_chars) + ellipsis
     if had_escape and not result.endswith(RESET):

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

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

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

@@ -196,6 +196,7 @@ docs/roadmap/items/BOOST-D23.md
 docs/roadmap/items/BOOST-D24.md
 docs/roadmap/items/BOOST-D25.md
 docs/roadmap/items/BOOST-D26.md
+docs/roadmap/items/BOOST-D27.md
 docs/roadmap/items/a11y-sweep-flakes-on-color-contrast.md
 docs/roadmap/items/accessibility-audit-pa11y-ci-axe-core.md
 docs/roadmap/items/actionlint-skips-shellcheck-silently.md
@@ -209,6 +210,7 @@ docs/roadmap/items/autonomous-ship-workflow-and-isolated-worktree.md
 docs/roadmap/items/bm25-has-no-stemming.md
 docs/roadmap/items/bm25-index-is-one-json-blob.md
 docs/roadmap/items/bmad-autopilot-one-command-persona-routing.md
+docs/roadmap/items/bmad-hooks-all-hosts.md
 docs/roadmap/items/boost-first-carried-the-losing-trigger.md
 docs/roadmap/items/boost-first-rule.md
 docs/roadmap/items/boost-langchain-publishing.md
@@ -573,6 +575,7 @@ tests/eval/golden.jsonl
 tests/eval/recommend.jsonl
 tests/eval/taps-scale.txt
 tests/eval/taps.txt
+tests/functional/test_bmad_all_hosts.py
 tests/functional/test_capabilities_policy.py
 tests/functional/test_cli_adapt.py
 tests/functional/test_cli_bmad.py

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

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