boost-skill-cli 1.2.30__tar.gz → 1.2.31__tar.gz

{boost_skill_cli-1.2.30 → boost_skill_cli-1.2.31}/CLAUDE.md

@@ -339,6 +339,25 @@ for code you write:
   stale-link sweeps, coverage counts). `agents.enabled_agents()` is still right
   for rules and workflows, which materialize into `~/.gemini/` like any other
   agent's dotdir. `agents.native_store_agents()` is the complement, for reporting.
+- **Boost not linking there does not mean nothing else does**, and the warning
+  costs the user the same either way. `store.duplicate_discovery()` walks
+  `native_store_agents()` for entries that resolve back into the canonical
+  store — one skill in two of that agent's discovery tiers, whoever wrote it.
+  On a real machine 24 of the 25 entries in `~/.gemini/skills` led to
+  `~/.claude/skills` directories boost does not manage, and one resolved into
+  the store, so the test is **topology, not ownership**: a sweep of "boost's
+  stale links" would have deleted two dozen files belonging to another tool.
+  `boost doctor` counts each hit as an issue; `boost heal` names them and
+  removes nothing; `boost heal --prune-duplicates` removes them, re-checking at
+  the point of deletion that the entry is still a symlink still resolving into
+  the store. A real directory is never touched.
+- **`points_into_store` and `resolves_into_store` answer different questions.**
+  The first reads one `readlink()` because it judges *broken* links, where
+  there is nothing to resolve. The second follows the whole chain, because the
+  live shape is `~/.gemini/skills/x -> ../../.claude/skills/x -> the store` and
+  one hop lands in another agent's dir. It resolves **both sides**: on macOS a
+  `$HOME` under `/var/folders` resolves to `/private/var/...`, so resolving
+  only the target compares a real path against a nominal one and never matches.
 - Per-agent *formats* differ and are pure functions in `core/`: `rules.CONTEXT_FILES`
   maps an agent with no rules dir to its context file (`claude-code` → CLAUDE.md /
   CLAUDE.local.md, `gemini` → GEMINI.md for both scopes), and
@@ -350,6 +369,39 @@ for code you write:
   Gemini disagree on name position, the `--` separator, and whether unregister
   needs an explicit scope — all three verified against the real CLIs and pinned
   by `tests/unit/test_mcphost.py`. Don't "simplify" them into one shape.
+- **`core/hookhost.py` is the same idea for hooks, and two hosts have them.**
+  `boost hooks` writes Claude Code's `~/.claude/settings.json` (the default,
+  unchanged) or, behind `--host gemini`, the `~/.gemini/settings.json` that
+  Gemini CLI reads;
+  `core/claude_settings.py` takes `host=` throughout and asks the table for the
+  differences. The `hooks` key and the `{matcher, hooks: [{type, command,
+  timeout}]}` block shape are *identical* between them, which is exactly what
+  makes the three real differences easy to ship wrong:
+  - **`timeout` units.** Claude's is **seconds**; Gemini's is **milliseconds**
+    (`DEFAULT_HOOK_TIMEOUT = 6e4`, fed straight to `setTimeout`). Callers pass
+    seconds and `hookhost.hook_entry` converts, so boost's `--timeout 10` is ten
+    seconds on both. Gemini's own `hooks migrate --from-claude` copies the number
+    verbatim, which turns a 10-second Claude hook into a 10-**millisecond**
+    Gemini one; don't copy that.
+  - **Event names.** Only `SessionStart`, `SessionEnd` and `Notification` are
+    spelled alike. `CLAUDE_TO_GEMINI` maps all ten Claude events explicitly and
+    `tests/unit/test_hookhost.py` fails if one is missing. `SubagentStop` and
+    `SubagentStart` map to **`None`** — Gemini has no sub-agents, so boost
+    refuses the hook and says why. (The upstream `EVENT_MAPPING` means to fold
+    them into `AfterAgent` but keys `SubAgentStop`, a spelling Claude never
+    emits, so `migrate` writes an event Gemini can never fire.)
+  - **The `name` field.** Gemini's hook config takes one — it is what
+    `/hooks panel` shows and `/hooks enable <name>` targets — and Claude's does
+    not. The `# boost:<name>` command marker stays the ownership mechanism for
+    both; `name` is added on top for Gemini, never instead.
+  A `matcher` is **not** translated: `boost hooks add` is not porting a config,
+  so it stays host-native — for a Gemini tool event it is a regular expression
+  over *Gemini* tool names like `run_shell_command`, and for a lifecycle event
+  it is an exact string. All of this was established against Gemini CLI
+  0.57.0's own bundle — the `docs/hooks/` it ships, the `HookEventName` list and
+  `EVENT_MAPPING` in the bundled JS, and an observed `migrate` run — and those
+  sources are named at the top of `hookhost.py` so the next person can re-check
+  them against a newer release.
 
 `core/catalog.scan_dir` walks a tap's clone and classifies each file into one
 of the three item kinds (see Non-obvious rules above); `core/store.py` owns

{boost_skill_cli-1.2.30 → boost_skill_cli-1.2.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.30
+Version: 1.2.31
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE
@@ -1121,10 +1121,10 @@ as **Connected**. (Gemini only connects stdio servers in a trusted folder; run
 `gemini` once in the directory and accept the trust prompt if it shows
 `Disabled`.)
 
-## Claude Code hooks & the BMAD Method
+## Agent hooks & the BMAD Method
 
-`boost hooks` manages Claude Code hooks in `settings.json` at either scope —
-`--scope project` (`./.claude/settings.json`) or `--scope global`
+`boost hooks` manages hooks in `settings.json` at either scope — `--scope
+project` (`./.claude/settings.json`) or `--scope global`
 (`~/.claude/settings.json`). boost only ever touches hooks it created (tagged
 with a `# boost:<name>` marker in the command), never your own, and snapshots
 the prior file before each write.
@@ -1135,6 +1135,22 @@ boost hooks list
 boost hooks remove -n greet --scope project
 ```
 
+Gemini CLI has hooks too, behind `--host gemini` (`~/.gemini/settings.json`).
+The file shape is the same but two details are not, so boost handles both for
+you: its `timeout` is in milliseconds rather than seconds — `--timeout 10` is
+ten seconds on either host — and most event names differ. Pass whichever
+vocabulary you know and boost translates, saying which name it used:
+
+```bash
+boost hooks add PreToolUse --host gemini -c 'boost check' -n guard
+#   Claude's 'PreToolUse' is Gemini's 'BeforeTool' — using that
+boost hooks list          # both hosts, with a host column
+```
+
+`SubagentStop` and `SubagentStart` have no Gemini counterpart at all — it has
+no sub-agents — so boost refuses those rather than writing a hook that could
+never fire.
+
 ### BMAD autopilot
 
 `boost bmad on` is a one-time, global switch that puts the

{boost_skill_cli-1.2.30 → boost_skill_cli-1.2.31}/README.md

@@ -403,10 +403,10 @@ as **Connected**. (Gemini only connects stdio servers in a trusted folder; run
 `gemini` once in the directory and accept the trust prompt if it shows
 `Disabled`.)
 
-## Claude Code hooks & the BMAD Method
+## Agent hooks & the BMAD Method
 
-`boost hooks` manages Claude Code hooks in `settings.json` at either scope —
-`--scope project` (`./.claude/settings.json`) or `--scope global`
+`boost hooks` manages hooks in `settings.json` at either scope — `--scope
+project` (`./.claude/settings.json`) or `--scope global`
 (`~/.claude/settings.json`). boost only ever touches hooks it created (tagged
 with a `# boost:<name>` marker in the command), never your own, and snapshots
 the prior file before each write.
@@ -417,6 +417,22 @@ boost hooks list
 boost hooks remove -n greet --scope project
 ```
 
+Gemini CLI has hooks too, behind `--host gemini` (`~/.gemini/settings.json`).
+The file shape is the same but two details are not, so boost handles both for
+you: its `timeout` is in milliseconds rather than seconds — `--timeout 10` is
+ten seconds on either host — and most event names differ. Pass whichever
+vocabulary you know and boost translates, saying which name it used:
+
+```bash
+boost hooks add PreToolUse --host gemini -c 'boost check' -n guard
+#   Claude's 'PreToolUse' is Gemini's 'BeforeTool' — using that
+boost hooks list          # both hosts, with a host column
+```
+
+`SubagentStop` and `SubagentStart` have no Gemini counterpart at all — it has
+no sub-agents — so boost refuses those rather than writing a hook that could
+never fire.
+
 ### BMAD autopilot
 
 `boost bmad on` is a one-time, global switch that puts the

{boost_skill_cli-1.2.30 → boost_skill_cli-1.2.31}/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.30'
-__version_tuple__ = version_tuple = (1, 2, 30)
+__version__ = version = '1.2.31'
+__version_tuple__ = version_tuple = (1, 2, 31)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.30 → boost_skill_cli-1.2.31}/boost_cli/cli.py

@@ -125,7 +125,7 @@ COMMANDS = [
     ("schedule",    "cfg", "configuration", "Manage automatic skill-sync scheduling"),
     ("serve",       "cfg", "configuration", "Browse the catalogue in a browser: search, facets and a tap graph"),
     ("mcp",         "cfg", "configuration", "Register boost as an MCP server (Claude Code, Gemini CLI)"),
-    ("hooks",       "cfg", "hooks", "Manage Claude Code hooks (scope-aware) in settings.json"),
+    ("hooks",       "cfg", "hooks", "Manage agent hooks (Claude Code, Gemini CLI) in settings.json"),
     ("bmad",        "cfg", "bmad", "BMAD Method autopilot — `bmad on` routes every task to a persona"),
     ("self-update", "cfg", "configuration", "Update boost itself to the latest version"),
     # Team & Collaboration (6)

{boost_skill_cli-1.2.30 → boost_skill_cli-1.2.31}/boost_cli/commands/configuration.py

@@ -1329,9 +1329,19 @@ REGISTRY.register(
     "what this machine holds, not what exists, and a kind sitting at zero is a "
     "kind nothing here could have loaded. boost_search is what reads the "
     "registries themselves. "
-    "Read-only, instant, installs nothing — so unlike boost_search there is "
-    "no threshold worth applying: call it whenever you are about to plan "
-    "something. Planning from memory while "
+    # The cost clause names its own mechanism. Gemini CLI never delivers
+    # server `instructions` in interactive mode, so INSTRUCTIONS' "boost_list
+    # is free, call it whenever" is absent on that host and this declaration
+    # is the only place left to say it. "Instant" alone is a claim about the
+    # clock that an agent has to take on trust; "a local file read rather
+    # than a search" is the reason for it, checkable against what the tool
+    # obviously does, and it is why no threshold follows. boost_search's
+    # "10-15 seconds" stays out — that is the other tool's price, and this
+    # one does not pay it.
+    "Read-only and it installs nothing: a local file read rather than a "
+    "search, so it is instant and free. Unlike boost_search there is "
+    "therefore no threshold worth applying: call it whenever you are about "
+    "to plan something. Planning from memory while "
     "the answer already sits on disk is the one avoidable mistake here.",
     {"type": "object", "properties": {}},
     _tool_list)

boost_skill_cli-1.2.31/boost_cli/commands/hooks.py

@@ -0,0 +1,156 @@
+"""boost hooks — scope- and host-aware management of agent hooks in settings.json.
+
+    boost hooks add SessionStart --command 'boost bmad orient' --name bmad \
+        --scope global --matcher 'startup|resume|clear'
+    boost hooks add PreToolUse --host gemini -c 'boost check' -n guard
+    boost hooks list
+    boost hooks remove --name bmad
+
+Two hosts have hooks: Claude Code (`~/.claude/settings.json`, the default and
+unchanged) and Gemini CLI (`~/.gemini/settings.json`). What differs between
+them is a pure table in core/hookhost.py; this layer only picks a host, spells
+the event the way that host spells it, and reports what it did.
+
+Event names mostly differ, so `--host gemini` accepts either vocabulary and
+says which translation it applied. Two Claude events — SubagentStop and
+SubagentStart — have no Gemini counterpart at all, and are refused rather than
+silently dropped: a hook that looks installed and never fires is the failure
+mode worth being loud about.
+
+Only hooks boost created (tagged `# boost:<name>`) are ever touched; user hooks
+are left untouched. See core/claude_settings.py.
+"""
+from __future__ import annotations
+
+from .. import cliparse
+from ..core import claude_settings as cs
+from ..core import hookhost, journal
+from ..core import output as out
+from ..errors import BoostError
+
+
+def cmd_hooks(argv) -> int:
+    p = cliparse.parser(
+        prog="boost hooks",
+        description="Manage agent hooks (scope- and host-aware) in settings.json")
+    p.add_argument("action", choices=("add", "remove", "list"),
+                   help="add | remove | list")
+    p.add_argument("event", nargs="?",
+                   help="hook event, e.g. SessionStart (required for add)")
+    p.add_argument("--host", metavar="H", default=None,
+                   choices=(*hookhost.hosts(), "auto"),
+                   help="agent CLI whose settings.json to manage: %s "
+                        "(default: claude for add/remove, all of them for list)"
+                        % ", ".join(hookhost.hosts()))
+    p.add_argument("-c", "--command", help="command the hook runs (add)")
+    p.add_argument("-n", "--name", help="stable name used to tag & find the hook")
+    p.add_argument("-s", "--scope", choices=cs.SCOPES, default=None,
+                   help="settings scope (default: project; list shows both)")
+    p.add_argument("-m", "--matcher",
+                   help="Claude matcher, e.g. 'startup|resume|clear'")
+    p.add_argument("--timeout", type=int, default=10,
+                   help="hook timeout in seconds (default: 10)")
+    args = p.parse_args(argv)
+
+    if args.action == "list":
+        return _list(args.scope, args.host)
+    if args.action == "add":
+        return _add(args)
+    return _remove(args)
+
+
+def _list(scope, host) -> int:
+    rows = cs.list_all_hooks(scope, host=host)
+    if not rows:
+        out.info("no boost-managed hooks" + (" in %s scope" % scope if scope else ""))
+        return 0
+    out.table(
+        [(r["host"], r["scope"], r["event"], r["name"], r["matcher"] or "-",
+          r["command"]) for r in rows],
+        headers=("host", "scope", "event", "name", "matcher", "command"))
+    return 0
+
+
+def _write_host(requested) -> str:
+    """The single host an `add`/`remove` targets. Claude unless told otherwise.
+
+    `auto` is a read-only idea — fanning a write across every installed CLI is
+    not what someone asking for one hook meant — so it is rejected here rather
+    than quietly meaning "claude".
+    """
+    if requested in (None, ""):
+        return hookhost.CLAUDE
+    if requested == "auto":
+        raise BoostError("--host auto only makes sense for `hooks list`",
+                         hint="name one host: %s" % ", ".join(hookhost.hosts()))
+    return requested
+
+
+def _where(host: str, scope: str) -> str:
+    """How a write is named back to the user: "global", or "gemini/global".
+
+    Claude Code is the default host, so its scope stays unqualified — the
+    wording predates there being a second host and there is nothing to
+    disambiguate. A host the user had to ask for by name is worth repeating
+    back, because "removed 1 hook" is only reassuring if it says where from.
+    """
+    return scope if host == hookhost.CLAUDE else "%s/%s" % (host, scope)
+
+
+def _native_event(host: str, event: str) -> str:
+    """`event` as `host` spells it, saying so, or refusing if it cannot."""
+    native = hookhost.translate(host, event)
+    if native is None:
+        raise BoostError(
+            "'%s' has no %s counterpart" % (event, hookhost.label(host)),
+            hint="%s has no sub-agents; its events are: %s"
+                 % (hookhost.label(host), ", ".join(hookhost.events(host))))
+    if native != event:
+        out.info("Claude's '%s' is %s's '%s' — using that"
+                 % (event, hookhost.event_label(host), native))
+    return native
+
+
+def _add(args) -> int:
+    if not args.event:
+        raise BoostError("hooks add needs an EVENT",
+                         hint="e.g. boost hooks add SessionStart -c '<cmd>' -n <name>")
+    if not args.command:
+        raise BoostError("hooks add needs --command",
+                         hint="the shell command Claude should run for this hook")
+    if not args.name:
+        raise BoostError("hooks add needs --name",
+                         hint="a stable name so the hook can be removed later")
+    scope = args.scope or "project"
+    host = _write_host(args.host)
+    event = _native_event(host, args.event)
+    if event not in hookhost.events(host):
+        out.warn("'%s' is not a known %s hook event — adding anyway"
+                 % (event, hookhost.event_label(host)))
+    cs.add_hook(scope, event, args.name, args.command,
+                matcher=args.matcher, timeout=args.timeout, host=host)
+    journal.log("hook-add", args.name, scope=scope, event=event, host=host)
+    out.ok("added %s hook '%s' (%s) → %s"
+           % (event, args.name, _where(host, scope), args.command))
+    out.dim("  settings: %s" % cs.settings_path(scope, host=host))
+    return 0
+
+
+def _remove(args) -> int:
+    if not args.name:
+        raise BoostError("hooks remove needs --name",
+                         hint="the name you gave the hook when adding it")
+    scope = args.scope or "project"
+    host = _write_host(args.host)
+    events = ((_native_event(host, args.event),) if args.event
+              else hookhost.events(host))
+    removed = sum(cs.remove_hook(scope, ev, args.name, host=host)
+                  for ev in events)
+    journal.log("hook-remove", args.name, scope=scope, host=host)
+    if removed:
+        out.ok("removed %d hook(s) named '%s' (%s)"
+               % (removed, args.name, _where(host, scope)))
+    else:
+        out.warn("no boost hook named '%s' in %s scope"
+                 % (args.name, _where(host, scope)))
+    return 0

{boost_skill_cli-1.2.30 → boost_skill_cli-1.2.31}/boost_cli/commands/quality.py

@@ -535,6 +535,19 @@ def cmd_doctor(argv):
                  "left alone; yours to remove or repair"
                  % (len(foreign), _s(len(foreign))))
 
+    for dup in store.duplicate_discovery():
+        # An agent that reads the canonical store natively, holding its own
+        # entry for a skill that store already carries. Boost did not put it
+        # there — it never links into a native-store agent — but the agent
+        # loads the same skill from two discovery tiers and says so on every
+        # session, so a health check that stayed quiet about it would be
+        # describing a machine the user is not looking at.
+        bad("skill %s is discoverable twice by %s — %s leads to %s, which it "
+            "already reads natively; remove the duplicate with "
+            "`boost heal --prune-duplicates`"
+            % (dup.name, agents.display_name(dup.agent), _tilde(dup.path),
+               _tilde(dup.target)), wrap=True)
+
     for adir in enabled.values():
         if adir.is_dir() and not os.access(str(adir), os.W_OK):
             bad("agent dir %s is not writable" % _tilde(adir))
@@ -854,6 +867,9 @@ def cmd_heal(argv):
         description="Self-diagnose & repair the boost environment")
     ap.add_argument("--dry-run", action="store_true",
                     help="show repairs without applying them")
+    ap.add_argument("--prune-duplicates", action="store_true",
+                    help="remove symlinks in a native-store agent's skills dir "
+                         "that lead back into the canonical store")
     args = ap.parse_args(argv)
     dry = args.dry_run
     actions: list[str] = []
@@ -903,6 +919,30 @@ def cmd_heal(argv):
             out.ok(msg.replace(str(paths.home()), "~"))
             actions.append(msg)
 
+    # Opt-in, unlike everything above it. The rest of `heal` repairs what boost
+    # itself created; these entries boost did not create, so deleting one on a
+    # plain `boost heal` would be silently removing another tool's file. Named
+    # every run so the flag is discoverable from the command that would use it.
+    duplicates = store.duplicate_discovery()
+    declined_duplicates = bool(duplicates) and not args.prune_duplicates
+    for dup in duplicates:
+        label = "%s → %s (%s)" % (_tilde(dup.path), _tilde(dup.target), dup.agent)
+        if not args.prune_duplicates:
+            out.info("duplicate skill discovery %s — %s reads the store "
+                     "natively; remove it with `boost heal --prune-duplicates`"
+                     % (label, agents.display_name(dup.agent)), wrap=True)
+        elif dry:
+            out.info("would remove duplicate skill discovery %s" % label)
+            actions.append("duplicate %s" % dup.path)
+        elif store.remove_duplicate_discovery(dup):
+            out.ok("removed duplicate skill discovery %s" % label)
+            actions.append("duplicate %s" % dup.path)
+        else:
+            # Re-gated at the point of deletion, so a real directory or a link
+            # repointed since the scan lands here rather than being removed.
+            out.warn("%s is no longer a symlink into the store — left alone"
+                     % _tilde(dup.path))
+
     for tap in registry.list_taps():
         if not tap.is_cloned:
             out.warn("tap %s not cloned — skipped (run `boost update`)" % tap.name)
@@ -929,7 +969,11 @@ def cmd_heal(argv):
         actions.append("rotate")
 
     if not actions:
-        out.ok("nothing to heal")
+        # A duplicate this run declined to prune is something `heal` saw, can
+        # fix, and deliberately left. A bare "nothing to heal" printed under
+        # the line offering the flag contradicts it.
+        out.ok("nothing to heal automatically"
+               if declined_duplicates else "nothing to heal")
     elif not dry:
         journal.log("heal", "%d actions" % len(actions))
     return 0

{boost_skill_cli-1.2.30 → boost_skill_cli-1.2.31}/boost_cli/core/claude_settings.py

@@ -1,9 +1,17 @@
-"""Scope-aware read/merge/write of Claude Code's settings.json + hook management.
+"""Scope- and host-aware read/merge/write of a settings.json + hook management.
 
 Claude Code reads hooks from a JSON `settings.json` at two scopes:
   global  -> ~/.claude/settings.json
   project -> <project>/.claude/settings.json
 
+Gemini CLI reads the same shape from `~/.gemini/settings.json` and
+`<project>/.gemini/settings.json`. Every function here takes `host=` (default
+`"claude"`, so nothing that predates the second host changed) and gets the
+per-host facts — the dotdir, the event vocabulary, the timeout units — from
+`core/hookhost.py`, which is a pure table. The units are the trap worth naming
+twice: Claude's `timeout` is seconds and Gemini's is milliseconds, so callers
+pass **seconds** and `hookhost.hook_entry` converts.
+
 boost only ever touches hooks it created. Each managed hook's command carries a
 trailing shell comment marker `# boost:<name>` so we can find and remove exactly
 our own entries and never clobber the user's hooks. Every write first snapshots
@@ -25,26 +33,27 @@ import json
 from pathlib import Path
 
 from ..errors import BoostError
-from . import paths, util
+from . import hookhost, paths, util
 
 SCOPES = ("global", "project")
 MARKER = "# boost:"
 HISTORY_KEEP = 50
 
 # Known Claude Code hook events (permissive — validated by callers that care).
-KNOWN_EVENTS = (
-    "SessionStart", "SessionEnd", "UserPromptSubmit", "PreToolUse", "PostToolUse",
-    "Stop", "SubagentStop", "SubagentStart", "PreCompact", "Notification",
-)
+# Kept as an alias so importers that predate the host table still work; the
+# list itself lives in hookhost alongside Gemini's.
+KNOWN_EVENTS = hookhost.CLAUDE_EVENTS
 
 
-def settings_path(scope: str, project_dir: Path | None = None) -> Path:
-    """Absolute path to the settings.json for a scope."""
+def settings_path(scope: str, project_dir: Path | None = None,
+                  host: str = hookhost.CLAUDE) -> Path:
+    """Absolute path to the settings.json for a scope, on a host."""
+    dotdir = hookhost.settings_dir(host)
     if scope == "global":
-        return paths.home() / ".claude" / "settings.json"
+        return paths.home() / dotdir / "settings.json"
     if scope == "project":
         base = Path(project_dir) if project_dir else Path.cwd()
-        return base / ".claude" / "settings.json"
+        return base / dotdir / "settings.json"
     raise BoostError("unknown scope %r" % scope,
                      hint="use 'global' or 'project'")
 
@@ -53,9 +62,10 @@ def _history_dir() -> Path:
     return paths.state_dir() / "claude-settings-history"
 
 
-def load(scope: str, project_dir: Path | None = None) -> dict:
+def load(scope: str, project_dir: Path | None = None,
+         host: str = hookhost.CLAUDE) -> dict:
     """Parse a scope's settings.json ({} if missing or corrupt)."""
-    p = settings_path(scope, project_dir)
+    p = settings_path(scope, project_dir, host)
     if not p.exists():
         return {}
     try:
@@ -65,18 +75,25 @@ def load(scope: str, project_dir: Path | None = None) -> dict:
     return data if isinstance(data, dict) else {}
 
 
-def save(scope: str, data: dict, project_dir: Path | None = None) -> None:
-    """Write a scope's settings.json, snapshotting the prior version first."""
-    p = settings_path(scope, project_dir)
+def save(scope: str, data: dict, project_dir: Path | None = None,
+         host: str = hookhost.CLAUDE) -> None:
+    """Write a scope's settings.json, snapshotting the prior version first.
+
+    Snapshots are named ``<host prefix><scope>-<stamp>.json``. Claude's prefix
+    is empty, so its history filenames are exactly what they always were and a
+    Gemini write cannot land on top of one.
+    """
+    p = settings_path(scope, project_dir, host)
     p.parent.mkdir(parents=True, exist_ok=True)
     if p.exists():
         hist = _history_dir()
         hist.mkdir(parents=True, exist_ok=True)
         stamp = util.now_iso().replace(":", "").replace("-", "")
-        dest = hist / ("%s-%s.json" % (scope, stamp))
+        pre = hookhost.history_prefix(host)
+        dest = hist / ("%s%s-%s.json" % (pre, scope, stamp))
         n = 2
         while dest.exists():
-            dest = hist / ("%s-%s-%d.json" % (scope, stamp, n))
+            dest = hist / ("%s%s-%s-%d.json" % (pre, scope, stamp, n))
             n += 1
         dest.write_text(p.read_text(encoding="utf-8"), encoding="utf-8")
         _prune_history()
@@ -108,28 +125,34 @@ def _hook_name(command: str) -> str | None:
 
 def add_hook(scope: str, event: str, name: str, command: str,
              matcher: str | None = None, timeout: int = 10,
-             project_dir: Path | None = None) -> None:
-    """Idempotently install a boost-managed hook (replaces same-named entry)."""
-    data = load(scope, project_dir)
+             project_dir: Path | None = None,
+             host: str = hookhost.CLAUDE) -> None:
+    """Idempotently install a boost-managed hook (replaces same-named entry).
+
+    ``timeout`` is in **seconds** whatever the host; ``hookhost.hook_entry``
+    converts it to the units that host's settings.json is read in. ``event``
+    must already be spelled the way ``host`` spells it — translating is the
+    command layer's job, because a Claude event with no Gemini counterpart has
+    to be refused out loud rather than silently dropped here.
+    """
+    data = load(scope, project_dir, host)
     event_list = data.setdefault("hooks", {}).setdefault(event, [])
     # Drop any prior entry we own with this name so re-adding is idempotent.
     _strip(event_list, name)
     block: dict = {}
     if matcher:
         block["matcher"] = matcher
-    block["hooks"] = [{
-        "type": "command",
-        "command": _tag(command, name),
-        "timeout": timeout,
-    }]
+    block["hooks"] = [hookhost.hook_entry(host, _tag(command, name), timeout,
+                                          name=name)]
     event_list.append(block)
-    save(scope, data, project_dir)
+    save(scope, data, project_dir, host)
 
 
 def remove_hook(scope: str, event: str, name: str,
-                project_dir: Path | None = None) -> int:
+                project_dir: Path | None = None,
+                host: str = hookhost.CLAUDE) -> int:
     """Remove boost-managed hooks matching name; return how many were removed."""
-    data = load(scope, project_dir)
+    data = load(scope, project_dir, host)
     hooks = data.get("hooks")
     if not isinstance(hooks, dict) or event not in hooks:
         return 0
@@ -140,7 +163,7 @@ def remove_hook(scope: str, event: str, name: str,
         del hooks[event]
     if not hooks:
         del data["hooks"]
-    save(scope, data, project_dir)
+    save(scope, data, project_dir, host)
     return removed
 
 
@@ -165,8 +188,9 @@ def _strip(event_list: list, name: str) -> int:
 
 
 def has_hook(scope: str, event: str, name: str,
-             project_dir: Path | None = None) -> bool:
-    data = load(scope, project_dir)
+             project_dir: Path | None = None,
+             host: str = hookhost.CLAUDE) -> bool:
+    data = load(scope, project_dir, host)
     for block in data.get("hooks", {}).get(event, []) or []:
         for h in (block.get("hooks") or []) if isinstance(block, dict) else []:
             if _hook_name(str(h.get("command", ""))) == name:
@@ -175,12 +199,13 @@ def has_hook(scope: str, event: str, name: str,
 
 
 def list_hooks(scope: str | None = None,
-               project_dir: Path | None = None) -> list[dict]:
-    """All boost-managed hooks: [{scope, event, name, command, matcher}]."""
+               project_dir: Path | None = None,
+               host: str = hookhost.CLAUDE) -> list[dict]:
+    """One host's boost-managed hooks: [{scope, event, name, command, matcher}]."""
     scopes = (scope,) if scope else SCOPES
     rows: list[dict] = []
     for sc in scopes:
-        data = load(sc, project_dir)
+        data = load(sc, project_dir, host)
         for event, blocks in (data.get("hooks") or {}).items():
             for block in blocks or []:
                 if not isinstance(block, dict):
@@ -198,3 +223,19 @@ def list_hooks(scope: str | None = None,
                         "matcher": block.get("matcher", ""),
                     })
     return rows
+
+
+def list_all_hooks(scope: str | None = None,
+                   project_dir: Path | None = None,
+                   host: str | None = None) -> list[dict]:
+    """:func:`list_hooks` across hosts, each row tagged with the host it is in.
+
+    ``host=None`` means every known host, which is what ``boost hooks list``
+    wants: a hook boost installed into a CLI the user has since stopped naming
+    is exactly the one they need shown. Kept separate from :func:`list_hooks`
+    rather than folded into it because that function's row shape is what
+    callers already destructure.
+    """
+    return [{"host": hs} | row
+            for hs in hookhost.resolve(host)
+            for row in list_hooks(scope, project_dir, hs)]