boost-skill-cli 1.2.98__tar.gz → 1.2.100__tar.gz

{boost_skill_cli-1.2.98/boost_skill_cli.egg-info → boost_skill_cli-1.2.100}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.98
+Version: 1.2.100
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0
@@ -468,6 +468,7 @@ is the whole setup.
 boost mcp register                 # every installed host (default: --host auto)
 boost mcp register --host gemini   # just one
 boost mcp register --no-seed       # register only; tap nothing
+boost mcp register --dry-run       # print the resolved command per host; change nothing
 boost mcp unregister               # same host selection, in reverse
 ```
 
@@ -479,6 +480,7 @@ purely local operation, for CI images and air-gapped machines.
 |------|-----|---------------|
 | Claude Code | `claude` | `claude mcp add` → its user-scope MCP config |
 | Gemini CLI | `gemini` | `gemini mcp add -s user` → `~/.gemini/settings.json` |
+| Antigravity CLI | `agy` | `agy mcp add` → `~/.gemini/config/mcp_config.json` |
 
 Seven tools are exposed: `boost_search`, `boost_list`, `boost_info`,
 `boost_read`, `boost_install`, `boost_doctor` and

{boost_skill_cli-1.2.98 → boost_skill_cli-1.2.100}/README.md

@@ -426,6 +426,7 @@ is the whole setup.
 boost mcp register                 # every installed host (default: --host auto)
 boost mcp register --host gemini   # just one
 boost mcp register --no-seed       # register only; tap nothing
+boost mcp register --dry-run       # print the resolved command per host; change nothing
 boost mcp unregister               # same host selection, in reverse
 ```
 
@@ -437,6 +438,7 @@ purely local operation, for CI images and air-gapped machines.
 |------|-----|---------------|
 | Claude Code | `claude` | `claude mcp add` → its user-scope MCP config |
 | Gemini CLI | `gemini` | `gemini mcp add -s user` → `~/.gemini/settings.json` |
+| Antigravity CLI | `agy` | `agy mcp add` → `~/.gemini/config/mcp_config.json` |
 
 Seven tools are exposed: `boost_search`, `boost_list`, `boost_info`,
 `boost_read`, `boost_install`, `boost_doctor` and

{boost_skill_cli-1.2.98 → boost_skill_cli-1.2.100}/boost

@@ -2,7 +2,7 @@
 # Copyright the boost contributors.
 # SPDX-License-Identifier: Apache-2.0
 # boost — Homebrew for AI coding skills.
-# Thin shim: finds Python 3.9+, runs the boost_cli package that lives
+# Thin shim: finds Python 3.12+, runs the boost_cli package that lives
 # next to this script (resolving symlinks, so `ln -s .../boost ~/bin/boost`
 # just works). No PyPI, no Artifactory — stdlib only.
 set -euo pipefail
@@ -24,7 +24,7 @@ fi
 find_python() {
   for py in python3 python; do
     if command -v "$py" >/dev/null 2>&1; then
-      if "$py" -c 'import sys; sys.exit(0 if sys.version_info >= (3, 9) else 1)' 2>/dev/null; then
+      if "$py" -c 'import sys; sys.exit(0 if sys.version_info >= (3, 12) else 1)' 2>/dev/null; then
         echo "$py"
         return 0
       fi
@@ -34,7 +34,7 @@ find_python() {
 }
 
 PY="$(find_python)" || {
-  echo "boost: Python 3.9+ is required but was not found on PATH" >&2
+  echo "boost: Python 3.12+ is required but was not found on PATH" >&2
   echo "  hint: brew install python3" >&2
   exit 1
 }

{boost_skill_cli-1.2.98 → boost_skill_cli-1.2.100}/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.98'
-__version_tuple__ = version_tuple = (1, 2, 98)
+__version__ = version = '1.2.100'
+__version_tuple__ = version_tuple = (1, 2, 100)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.98 → boost_skill_cli-1.2.100}/boost_cli/cli.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 import contextlib
 import difflib
 import importlib
+import os
 import sys
 import time
 
@@ -51,20 +52,20 @@ GROUPS = {
 COMMANDS = [
     # Package Management (13)
     ("install",     "pkg", "pkg", "Install a skill from a tap registry"),
-    ("uninstall",   "pkg", "pkg", "Remove an installed skill, rule, workflow, or config"),
+    ("uninstall",   "pkg", "pkg", "Remove an installed skill, rule, or workflow"),
     ("sync",        "pkg", "pkg", "Reconcile installed skills & symlinks against the lock file"),
     ("update",      "pkg", "pkg", "Sync taps or update installed skills"),
-    ("reinstall",   "pkg", "pkg", "Reinstall a skill or all skills (force)"),
+    ("reinstall",   "pkg", "pkg", "Reinstall a skill, rule or workflow (force)"),
     ("bundle",      "pkg", "pkg", "Export/install skill sets via a Boostfile"),
     ("import",      "pkg", "pkg", "Import skills from a GitHub URL or local path"),
-    ("pin",         "pkg", "pkg", "Pin a skill to its current version"),
-    ("unpin",       "pkg", "pkg", "Allow a pinned skill to update again"),
+    ("pin",         "pkg", "pkg", "Pin a skill, rule or workflow to its current version"),
+    ("unpin",       "pkg", "pkg", "Allow a pinned skill, rule or workflow to update again"),
     ("snapshot",    "pkg", "pkg", "Save & restore whole skill environments"),
     ("export",      "pkg", "pkg", "Package skills as shareable zip/tar archives"),
-    ("adapt",       "pkg", "pkg", "Render a skill as another framework's agent source (CrewAI, Agents SDK)"),
+    ("adapt",       "pkg", "pkg", "Render a skill as another framework's agent source (CrewAI, Agents SDK, LangGraph)"),
     ("run",         "pkg", "run", "Adapt a skill, wire tools & run it as a live agent"),
     # Discovery & Search (9)
-    ("search",      "find", "discovery", "Search skills across tap registries (AI-ranked)"),
+    ("search",      "find", "discovery", "Search skills across tap registries (BM25; --smart reranks with Claude)"),
     ("reindex",     "find", "discovery", "Build/refresh the full-content search index"),
     ("discover",    "find", "discovery", "Search GitHub for skill repos you have not tapped yet"),
     ("recommend",   "find", "discovery", "Suggest skills based on your project's tech stack"),
@@ -85,10 +86,10 @@ COMMANDS = [
     ("deps",        "info", "info", "Show dependency & conflict relationships"),
     ("tag",         "info", "info", "Custom labels for organizing skills"),
     # Registry (Taps) (5)
-    ("tap",         "tap", "taps", "Add a GitHub repo as a skill registry"),
+    ("tap",         "tap", "taps", "Add a git URL, GitHub repo, or local directory as a skill registry"),
     ("untap",       "tap", "taps", "Remove a registry tap"),
     ("taps",        "tap", "taps", "List all configured registry taps"),
-    ("outdated",    "tap", "taps", "Show skills with available updates"),
+    ("outdated",    "tap", "taps", "Show skills, rules & workflows with available updates"),
     ("catalog",     "tap", "taps", "Share the tapped catalogue so others skip the clone"),
     # Intelligence (9)
     ("chat",        "ai", "intelligence", "Ask about skills in plain language (RAG-grounded)"),
@@ -99,7 +100,7 @@ COMMANDS = [
     ("evolve",      "ai", "intelligence", "Iteratively improve a skill from feedback"),
     ("context",     "ai", "intelligence", "Branch-aware skill activation"),
     ("focus",       "ai", "intelligence", "Temporarily prioritize skills for a work session"),
-    ("impact",      "ai", "intelligence", "Measure a skill's influence on code quality"),
+    ("impact",      "ai", "intelligence", "Correlate a skill's install date with repo activity"),
     # Quality & Health (15)
     ("doctor",      "chk", "quality", "Check installation health & report issues"),
     ("lint",        "chk", "quality", "Validate SKILL.md frontmatter & quality"),
@@ -108,7 +109,7 @@ COMMANDS = [
     ("drift",       "chk", "quality", "Detect installed skills diverging from source"),
     ("test",        "chk", "quality", "Validate installed skills against quality checks"),
     ("fingerprint", "chk", "quality", "Deterministic hash of the skill environment"),
-    ("quarantine",  "chk", "safety", "Isolate a problematic skill without uninstalling"),
+    ("quarantine",  "chk", "safety", "Isolate a problematic skill, rule or workflow without uninstalling"),
     ("decay",       "chk", "quality", "Flag skills irrelevant to your current stack"),
     ("heal",        "chk", "quality", "Self-diagnose & repair the boost environment"),
     ("conflict",    "chk", "quality", "Detect contradictory rules between skills"),
@@ -123,11 +124,11 @@ COMMANDS = [
     ("compact",     "cfg", "configuration", "Shrink tap clones to the files boost indexes"),
     ("create",      "cfg", "configuration", "Scaffold a new skill from a template"),
     ("policy",      "cfg", "configuration", "Manage & enforce skill governance policies"),
-    ("onboard",     "cfg", "configuration", "Add skill-tracker telemetry to a repo & open a PR"),
+    ("onboard",     "cfg", "configuration", "Add skill-tracker telemetry to a repo (optionally open a PR with --pr)"),
     ("completions", "cfg", "configuration", "Generate shell tab-completion scripts"),
     ("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)"),
+    ("mcp",         "cfg", "configuration", "Register boost as an MCP server (Claude Code, Gemini CLI, Antigravity CLI)"),
     ("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"),
@@ -195,6 +196,9 @@ def print_help() -> None:
     else:
         print(usage)
         print("  " + detail)
+    print(out.c(
+        "Options:  -V/--version   -v/--verbose   --debug   -q/--quiet",
+        out.DIM))
 
     width = max(len(n) for n, _, _, _ in COMMANDS)
     for idx, (gkey, (_icon, title, desc)) in enumerate(GROUPS.items()):
@@ -220,6 +224,21 @@ def print_help() -> None:
 
 
 def print_command_help(name: str) -> int:
+    # `main`'s own aliases (-h/--help, -V/--version/version, help itself)
+    # never appear in COMMANDS, so `boost help --help` used to fall straight
+    # into `_unknown` and get difflib-guessed at an unrelated command
+    # (`--help` -> "heal", `version` -> "verify"). Resolve them the same way
+    # `main` does before treating the name as an unrecognized command.
+    if name in ("-h", "--help"):
+        print_help()
+        return 0
+    if name in ("-V", "--version", "version"):
+        print_version()
+        return 0
+    if name == "help":
+        print(out.c("boost help [COMMAND]", out.BOLD)
+              + " — show this index, or one command's own --help")
+        return 0
     meta = resolve(name)
     if not meta:
         return _unknown(name)
@@ -237,6 +256,13 @@ def _crash_hint(report) -> str:
 
 
 def _unknown(name: str) -> int:
+    # A dash-prefixed token is a mistyped flag, not a command guess — nothing
+    # in _BY_NAME is a plausible correction for e.g. `--hepl`, and guessing
+    # one anyway ("did you mean: heal?") reads as a wrong command suggestion
+    # rather than what actually happened.
+    if name.startswith("-"):
+        out.err("unknown option: %s" % name, hint="see `boost --help`")
+        return 2
     close = difflib.get_close_matches(name, list(_BY_NAME), n=3)
     out.err("unknown command: %s" % name,
             hint=("did you mean: %s?" % ", ".join(close)) if close
@@ -286,6 +312,102 @@ def _extract_globals(argv: list[str]) -> tuple[dict, list[str]]:
     return opts, argv[i:]
 
 
+def _seal_broken_stdout() -> None:
+    """Stop CPython's own exit-time flush from re-raising BrokenPipeError.
+
+    A downstream reader closing early (``boost --help | head``) does not
+    raise the moment boost prints — small writes fit the pipe's kernel buffer
+    and succeed silently, so the error only surfaces on the next explicit
+    flush. Left unhandled it surfaces on the *interpreter's own* final flush
+    of stdout at shutdown, which happens outside any of boost's try/except
+    blocks: Python prints "Exception ignored on flushing sys.stdout:
+    BrokenPipeError" straight to stderr and the process exits non-zero.
+    Redirecting the fd to devnull means that final flush lands somewhere
+    that cannot raise.
+    """
+    with contextlib.suppress(Exception):
+        sys.stdout.flush()
+    with contextlib.suppress(Exception):
+        devnull = os.open(os.devnull, os.O_WRONLY)
+        try:
+            os.dup2(devnull, sys.stdout.fileno())
+        finally:
+            os.close(devnull)
+
+
+def _route(argv: list[str]) -> int:
+    try:
+        if not argv or argv[0] in ("-h", "--help"):
+            print_help()
+            return 0
+        if argv[0] in ("-V", "--version", "version"):
+            print_version()
+            return 0
+        if argv[0] == "help":
+            if len(argv) > 1:
+                return print_command_help(argv[1])
+            print_help()
+            return 0
+        name, rest = argv[0], argv[1:]
+        if name in _PLUMBING:
+            # Before the _BY_NAME guard (it is not a command) and before
+            # log_invocation: this runs on every TAB, and logging a line per
+            # keystroke would bury the diagnostic log in completion noise.
+            return _PLUMBING[name](rest)
+        if name not in _BY_NAME:
+            return _unknown(name)
+        logs.log_invocation([name, *rest])
+        start = time.perf_counter()
+        rc = 70  # assume the worst until a handler proves otherwise
+        try:
+            rc = _dispatch(name, rest)
+            return rc
+        except BoostError as e:
+            logs.get_logger().info("BoostError: %s", e.message)
+            rc = 1
+            out.err(e.message, hint=e.hint)
+            return rc
+        except KeyboardInterrupt:
+            logs.get_logger().debug("interrupted by user")
+            rc = 130
+            print()
+            return rc
+        except BrokenPipeError:
+            # Reclassify before `except Exception` below can mistake a
+            # closed pipe for a crash and write a spurious crash report.
+            rc = 0
+            return rc
+        except SystemExit as e:
+            # argparse (--help, usage errors) exits via SystemExit, which is
+            # a BaseException and so skips the `except Exception` below
+            # entirely — left uncaught, the trail journaled the preset rc=70
+            # for every benign --help and usage exit instead of the real 0
+            # or 2.
+            code = e.code
+            rc = 0 if code is None else code if isinstance(code, int) else 1
+            raise
+        except Exception as e:
+            report = logs.write_crash_report(e, [name, *rest])
+            if logs.is_debug():
+                raise
+            out.err("boost hit an unexpected error: %s: %s"
+                    % (type(e).__name__, e),
+                    hint=_crash_hint(report))
+            return 70  # EX_SOFTWARE
+        finally:
+            # Bookend every invocation with its exit code + duration, even
+            # when the --debug path re-raises the traceback above.
+            logs.log_completion([name, *rest], rc,
+                                (time.perf_counter() - start) * 1000)
+    finally:
+        # Force any buffered output through now, still inside `main`'s own
+        # BrokenPipeError handler below — a `--help`/`--version`/`count`
+        # write that merely fit the pipe's buffer never raised above, and
+        # would otherwise wait until the unhandled, uncatchable flush at
+        # interpreter shutdown to report the broken pipe.
+        sys.stdout.flush()
+
+
 def main(argv: list[str] | None = None) -> int:
     argv = list(sys.argv[1:] if argv is None else argv)
     out.harden_console_encoding()
@@ -297,64 +419,12 @@ def main(argv: list[str] | None = None) -> int:
     opts, argv = _extract_globals(argv)
     logs.configure(verbose=opts["verbose"], debug=opts["debug"],
                    quiet=opts["quiet"])
-    if not argv or argv[0] in ("-h", "--help"):
-        print_help()
-        return 0
-    if argv[0] in ("-V", "--version", "version"):
-        print_version()
-        return 0
-    if argv[0] == "help":
-        if len(argv) > 1:
-            return print_command_help(argv[1])
-        print_help()
-        return 0
-    name, rest = argv[0], argv[1:]
-    if name in _PLUMBING:
-        # Before the _BY_NAME guard (it is not a command) and before
-        # log_invocation: this runs on every TAB, and logging a line per
-        # keystroke would bury the diagnostic log in completion noise.
-        return _PLUMBING[name](rest)
-    if name not in _BY_NAME:
-        return _unknown(name)
-    logs.log_invocation([name, *rest])
-    start = time.perf_counter()
-    rc = 70  # assume the worst until a handler proves otherwise
     try:
-        rc = _dispatch(name, rest)
-        return rc
-    except BoostError as e:
-        logs.get_logger().info("BoostError: %s", e.message)
-        rc = 1
-        out.err(e.message, hint=e.hint)
-        return rc
-    except KeyboardInterrupt:
-        logs.get_logger().debug("interrupted by user")
-        rc = 130
-        print()
-        return rc
+        return _route(argv)
     except BrokenPipeError:
-        with contextlib.suppress(Exception):
-            sys.stdout.close()
-        rc = 0
-        return rc
-    except SystemExit as e:
-        # argparse (--help, usage errors) exits via SystemExit, which is a
-        # BaseException and so skips the `except Exception` below entirely —
-        # left uncaught, the trail journaled the preset rc=70 for every
-        # benign --help and usage exit instead of the real 0 or 2.
-        code = e.code
-        rc = 0 if code is None else code if isinstance(code, int) else 1
-        raise
-    except Exception as e:
-        report = logs.write_crash_report(e, [name, *rest])
-        if logs.is_debug():
-            raise
-        out.err("boost hit an unexpected error: %s: %s"
-                % (type(e).__name__, e),
-                hint=_crash_hint(report))
-        return 70  # EX_SOFTWARE
-    finally:
-        # Bookend every invocation with its exit code + duration, even when the
-        # --debug path re-raises the traceback above.
-        logs.log_completion([name, *rest], rc,
-                            (time.perf_counter() - start) * 1000)
+        # Covers the early-return paths above (`--help`, `--version`,
+        # `help`, `__complete`) that have no try/except of their own, plus
+        # the final flush in `_route`'s own `finally` surfacing a pipe error
+        # the dispatch path's flush-free writes didn't.
+        _seal_broken_stdout()
+        return 0

{boost_skill_cli-1.2.98 → boost_skill_cli-1.2.100}/boost_cli/commands/_common.py

@@ -80,6 +80,7 @@ def _iter_installed(names: list[str] | None = None) -> list[tuple[str, dict]]:
     """
     skills = lockfile.installed()
     if names:
+        names = list(dict.fromkeys(names))  # order-preserving dedupe
         missing, other_kind = [], []
         for n in names:
             if n in skills:
@@ -118,6 +119,7 @@ def _iter_installed_all(
         names: list[str] | None = None) -> list[tuple[str, str, dict]]:
     """[(kind, name, lock_entry)] across every section, or the given names."""
     if names:
+        names = list(dict.fromkeys(names))  # order-preserving dedupe
         out, missing = [], []
         for n in names:
             found = lockfile.find_any(n)

{boost_skill_cli-1.2.98 → boost_skill_cli-1.2.100}/boost_cli/commands/configuration.py

@@ -125,13 +125,21 @@ def cmd_config(argv) -> int:
                                  "`boost config unset` it first") from e
         val = config.get(args.key)
         journal.log("config", args.key, op="set")
+        if args.json:
+            print(json.dumps({"key": args.key, "value": val}))
+            return 0
         out.ok("set %s = %s"
                % (args.key, val if isinstance(val, str) else json.dumps(val)))
         return 0
 
     # unset
-    if config.unset(args.key):
+    was_set = config.unset(args.key)
+    if was_set:
         journal.log("config", args.key, op="unset")
+    if args.json:
+        print(json.dumps({"key": args.key, "unset": was_set}))
+        return 0
+    if was_set:
         out.ok("unset %s" % args.key)
     else:
         out.info("%s not set" % args.key)
@@ -512,6 +520,9 @@ def cmd_policy(argv) -> int:
         pol[args.key] = _parse_policy_value(args.key, args.value)
         policy.save(pol)
         journal.log("policy", args.key, op="set")
+        if args.json:
+            print(json.dumps({"key": args.key, "value": pol[args.key]}))
+            return 0
         out.ok("set %s = %s" % (args.key, json.dumps(pol[args.key])))
         return 0
 
@@ -520,6 +531,9 @@ def cmd_policy(argv) -> int:
         pol[args.key] = policy.DEFAULTS[args.key]
         policy.save(pol)
         journal.log("policy", args.key, op="unset")
+        if args.json:
+            print(json.dumps({"key": args.key, "value": policy.DEFAULTS[args.key]}))
+            return 0
         out.ok("reset %s to default (%s)"
                % (args.key, json.dumps(policy.DEFAULTS[args.key])))
         return 0
@@ -715,7 +729,7 @@ def cmd_onboard(argv) -> int:
     """boost onboard [--repo DIR] [--pr] [--dry-run] [--force]"""
     p = cliparse.parser(
         prog="boost onboard",
-        description="Add skill-tracker telemetry to a repo & open a PR")
+        description="Add skill-tracker telemetry to a repo (optionally open a PR with --pr)")
     p.add_argument("--repo", default=".", help="repository directory (default: .)")
     p.add_argument("--pr", action="store_true",
                    help="commit on a branch and open a PR with `gh`")
@@ -740,7 +754,8 @@ def cmd_onboard(argv) -> int:
     files = [(_TELEMETRY_REL, telemetry), (_WORKFLOW_REL, _WORKFLOW_YML)]
     if repo != paths.store_dir().resolve():
         files.append((".skill-lock.json",
-                      json.dumps(lockfile.read(), indent=2, sort_keys=True) + "\n"))
+                      json.dumps(lockfile.portable(lockfile.read()),
+                                indent=2, sort_keys=True) + "\n"))
 
     if args.dry_run:
         for rel, content in files:
@@ -1690,29 +1705,26 @@ def _mcp_tool(tool: str, args: dict):
     return REGISTRY.call(tool, args)
 
 
-#: Substrings an agent CLI uses to say "this server is already registered".
-#: Registering twice is not a failure — it is the state the user asked for —
-#: and treating it as one is what made `--host auto` abort on host one and
-#: never reach host two on any machine where boost was already in Claude.
-_ALREADY = ("already exists", "already registered", "already configured")
-
-
 def _run_mcp_host(host: str, action: str, cmd) -> tuple[str, str]:
     """Run one host's register/unregister argv.
 
     Returns ``(status, detail)`` where status is:
 
-    * ``"ran"``      — the CLI ran and succeeded;
-    * ``"already"``  — it reported the server is already in the state asked
-      for, which is success with a different wording;
-    * ``"missing"``  — the CLI is not installed. Not an error: most machines
-      have one agent CLI, not all of them;
-    * ``"failed"``   — it is installed and something else went wrong.
+    * ``"ran"``            — the CLI ran and did what was asked;
+    * ``"already"``        — register reported the server is already in that
+      state, which is success with a different wording;
+    * ``"not_registered"`` — unregister reported there was nothing to remove,
+      likewise success with a different wording;
+    * ``"missing"``        — the CLI is not installed. Not an error: most
+      machines have one agent CLI, not all of them;
+    * ``"failed"``         — it is installed and something else went wrong.
 
     It **returns** rather than raises so one host cannot end the sweep. That
     was the bug: a present CLI exiting non-zero raised straight out of the
     loop, so with boost already registered in Claude, `--host auto` died on
-    "already exists" and never reached the second agent.
+    "already exists" and never reached the second agent. The text
+    classification itself lives in :func:`mcphost.classify_result`, which is
+    pure and mutation-tested without a real agent CLI on PATH.
     """
     exe = mcphost.cli(host)
     if not shutil.which(exe):
@@ -1723,13 +1735,8 @@ def _run_mcp_host(host: str, action: str, cmd) -> tuple[str, str]:
         return "failed", str(e)
     for ln in (proc.stdout or "").strip().splitlines():
         out.info(ln)
-    if proc.returncode == 0:
-        return "ran", ""
-    blob = ((proc.stderr or "") + (proc.stdout or "")).lower()
-    if action == "register" and any(k in blob for k in _ALREADY):
-        return "already", ""
-    tail = (proc.stderr or "").strip().splitlines()
-    return "failed", tail[-1] if tail else "unknown error"
+    return mcphost.classify_result(action, proc.returncode,
+                                   proc.stdout, proc.stderr)
 
 
 def _seed_catalog_for_mcp(force: bool) -> None:
@@ -1838,7 +1845,7 @@ def _offer_boost_first(hosts: list[str]) -> None:
 
 
 def cmd_mcp(argv) -> int:
-    """boost mcp [register|unregister] [--host H] [--stdio] [--seed|--no-seed]"""
+    """boost mcp [register|unregister] [--host H] [--stdio] [--seed|--no-seed] [--dry-run]"""
     p = cliparse.parser(
         prog="boost mcp",
         description="Register boost as an MCP server for your agent CLIs")
@@ -1846,11 +1853,15 @@ def cmd_mcp(argv) -> int:
                    choices=("register", "unregister"),
                    help="what to do (default: register)")
     p.add_argument("--host", metavar="H", default="auto",
-                   help="agent CLI to (un)register with: %s, or `auto` "
-                        "(default) for every one that is installed"
+                   help="agent CLI to (un)register with: %s, `auto` "
+                        "(default) for every one that is installed, or "
+                        "`all` for every known host regardless of install"
                         % ", ".join(mcphost.hosts()))
     p.add_argument("--stdio", action="store_true",
                    help="run the MCP server on stdin/stdout (used by the agent)")
+    p.add_argument("--dry-run", action="store_true",
+                   help="print the resolved command and install status per "
+                        "host; register or tap nothing")
     # Mutually exclusive: `--seed --no-seed` used to resolve silently to the
     # network-touching side, which is the wrong way for an ambiguous pair of
     # explicitly typed flags to break.
@@ -1872,6 +1883,25 @@ def cmd_mcp(argv) -> int:
         raise BoostError("unknown MCP host %r" % args.host,
                         hint="known hosts: %s" % ", ".join(mcphost.hosts())) from e
 
+    shim = str(paths.launcher())
+    verb = "register" if args.action == "register" else "unregister"
+
+    if args.dry_run:
+        # Before seeding and before any subprocess runs — the flag exists so
+        # the argv boost would run is visible in the one case that mattered
+        # (`--host gemini` with `gemini` on PATH), not only the one case that
+        # was already visible for free (the CLI missing entirely).
+        for host in targets:
+            installed = shutil.which(mcphost.cli(host)) is not None
+            cmd = mcphost.argv(host, args.action, shim)
+            out.info("%s %s: %s" % (
+                mcphost.label(host),
+                out.role("(installed)" if installed else "(not installed)",
+                         "muted"),
+                " ".join(cmd)))
+        out.dim("  dry run — nothing was %sed, nothing tapped" % verb)
+        return 0
+
     # After the host name is validated and before anything is registered. The
     # ordering is not cosmetic in either direction: seeding first meant a
     # typo'd `--host` spent 14-45s and half a gigabyte before argparse's own
@@ -1880,12 +1910,14 @@ def cmd_mcp(argv) -> int:
     if args.action == "register" and (args.seed_ok or args.seed):
         _seed_catalog_for_mcp(args.seed)
 
-    shim = str(paths.launcher())
     # `auto` skips hosts that are not installed; naming a host explicitly (or
     # `all`) always reports it, so a user setting up a machine can see the argv
-    # for an agent CLI they have not installed yet.
+    # for an agent CLI they have not installed yet. `named` is narrower than
+    # `explicit`: it excludes `all`, which — like `auto` — deliberately shows
+    # every host's argv without treating "not installed" as a failure.
     explicit = args.host not in (None, "", "auto")
-    done, already, missing, failed = [], [], [], {}
+    named = mcphost.is_named(args.host)
+    done, already, not_registered, missing, failed = [], [], [], [], {}
     for host in targets:
         cmd = mcphost.argv(host, args.action, shim)
         status, detail = _run_mcp_host(host, args.action, cmd)
@@ -1893,6 +1925,8 @@ def cmd_mcp(argv) -> int:
             done.append(host)
         elif status == "already":
             already.append(host)
+        elif status == "not_registered":
+            not_registered.append(host)
         elif status == "failed":
             # Collected, not raised: the next host is a different agent on a
             # different config file and has nothing to do with this failure.
@@ -1904,7 +1938,6 @@ def cmd_mcp(argv) -> int:
                          % mcphost.cli(host))
                 out.info(" ".join(cmd))
 
-    verb = "register" if args.action == "register" else "unregister"
     for host in done:
         # agy has no scopes — one global file — so claiming "(scope: user)"
         # would describe a distinction its CLI does not have.
@@ -1914,6 +1947,8 @@ def cmd_mcp(argv) -> int:
     for host in already:
         out.ok("already registered with %s — nothing to do"
                % mcphost.label(host))
+    for host in not_registered:
+        out.ok("%s: not registered — nothing to do" % mcphost.label(host))
     for host, detail in failed.items():
         out.warn("%s: %s mcp %s failed — %s"
                  % (mcphost.label(host), mcphost.cli(host), args.action,
@@ -1921,7 +1956,7 @@ def cmd_mcp(argv) -> int:
         out.info(out.role("run it yourself: %s"
                           % " ".join(mcphost.argv(host, args.action, shim)),
                           "muted"))
-    settled = done + already
+    settled = done + already + not_registered
     if not settled:
         if failed:
             # Every installed CLI failed. That is a real error — but only after
@@ -1936,7 +1971,10 @@ def cmd_mcp(argv) -> int:
             for host in missing:
                 out.info(" ".join(mcphost.argv(host, args.action, shim)))
         journal.log("mcp", args.action, hosts="")
-        return 0
+        # A single named host whose CLI is missing is a no-op, not a success:
+        # `--host all` and `auto` both tolerate an absent CLI by design (see
+        # `mcphost.is_named`), so only a one-host request fails here.
+        return 1 if named else 0
     if args.action == "register":
         _offer_boost_first(settled)
     journal.log("mcp", args.action, hosts=",".join(settled))