boost-skill-cli 1.0.419__tar.gz → 1.0.421__tar.gz

{boost_skill_cli-1.0.419/boost_skill_cli.egg-info → boost_skill_cli-1.0.421}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.419
+Version: 1.0.421
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE
@@ -1016,29 +1016,79 @@ boost hooks list
 boost hooks remove -n greet --scope project
 ```
 
-`boost bmad` installs and manages the [BMAD Method](https://bmadcode.com/)
-(agentic Analyst / PM / Architect / Dev / QA personas + workflows) as a
-scope-aware, toggleable startup experience. Provisioning is delegated to the
-canonical `npx bmad-method install` (needs Node.js 20.12+); boost owns scope,
-the startup toggle, and teardown.
+### BMAD autopilot
+
+`boost bmad on` is a one-time, global switch that puts the
+[BMAD Method](https://bmadcode.com/)'s personas in charge of every task that
+arrives, without you having to invoke anything. No Node, no network, one
+command:
+
+```bash
+boost bmad on      # ← that's it
+```
+
+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:
+
+```text
+[BMAD autopilot] track: build
+Lead: `bmad-dev` subagent — Amelia, Senior Software Engineer. Ship it complete and verified.
+Support: `bmad-tea` (Murat), `bmad-scribe` (Paige) — spawn them with the Agent tool…
+BMAD skill: `bmad-build` — invoke it if it is installed; otherwise the persona's own playbook stands.
+Done means: tests: add or update coverage under `tests/`, and run them · docs: update
+`README.md` / `docs/` wherever the change shows · roadmap: create or claim the item under
+`docs/roadmap/items/` · gate: `make check` green, with real output · `CLAUDE.md` is binding
+Work autonomously through to a finished, verified change; stop to ask only when a choice
+would change what gets delivered.
+```
+
+Nine tracks (`build`, `quality`, `docs`, `planning`, `product`, `architecture`,
+`ux`, `discovery`, `review`) each name a lead persona, the support personas to
+spawn alongside it, and the canonical BMAD v6 skill for that kind of work.
+**That last line is the point**: the definition of done is read off the repo in
+front of you — your test directory, your docs, your roadmap items, your gate
+command — so documentation, testing and roadmap bookkeeping travel with the task
+instead of being remembered afterwards.
+
+The router costs a question nothing. Acknowledgements, slash commands, short
+informational questions ("what does `scan_dir` do?") and anything containing
+`no bmad` produce **no banner at all** — and because a `UserPromptSubmit` hook
+that exits non-zero would erase your prompt, it degrades every failure to
+silence and always exits 0.
+
+```bash
+boost bmad personas                            # the roster, and whether it's installed
+boost bmad route "add tests for the scanner" --plain   # what would this route to?
+boost bmad doctor                              # autopilot + workflow state, both scopes
+boost bmad off                                 # remove the hooks and the personas
+boost bmad on --scope project                  # or keep it to one repo
+```
+
+Every persona file carries an ownership stamp containing a digest of its own
+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.
+
+**The full method** is still a separate, heavier install. `boost bmad install`
+delegates to the canonical `npx bmad-method install` (needs Node.js 20.12+) for
+the `bmad-*` workflow skills and the per-project `_bmad/` runtime they read on
+activation:
 
 ```bash
 boost bmad install --scope project   # skills + per-project _bmad/ runtime
 boost bmad install --scope global    # skills into ~/.claude/skills for every session
 boost bmad init                      # add the _bmad/ runtime to the current repo
-boost bmad startup on                # inject light BMAD orientation on session start
-boost bmad startup off               # stop injecting it (skills stay installed)
+boost bmad startup on|off            # just the SessionStart briefing
 boost bmad disable / enable          # quarantine / restore skills (recoverable)
 boost bmad uninstall                 # delete skills + _bmad/ for a scope
-boost bmad doctor                    # what's installed where
 ```
 
-When startup is on, a `SessionStart` hook runs `boost bmad orient`, which prints
-a short orientation into the session only while the toggle is enabled. That
-orientation sets a **default bias**: build/fix/change/refactor requests go
-straight to the `bmad-quick-dev` skill (clarify → plan → implement → review),
-skipping the full brief → PRD → architecture ceremony unless you ask for full
-planning. Global installs stage the installer in a temp dir and copy only the
+The two compose. The autopilot routes at `bmad-build`, `bmad-prd` and friends
+whether or not they are installed and says which case you're in — with the
+skills present you get BMAD's full workflow, without them the persona's own
+playbook. Global installs stage the installer in a temp dir and copy only the
 `bmad-*` skills, so `$HOME` never gets a stray `_bmad/` — the workflow runtime
 stays per-project.
 

{boost_skill_cli-1.0.419 → boost_skill_cli-1.0.421}/README.md

@@ -298,29 +298,79 @@ boost hooks list
 boost hooks remove -n greet --scope project
 ```
 
-`boost bmad` installs and manages the [BMAD Method](https://bmadcode.com/)
-(agentic Analyst / PM / Architect / Dev / QA personas + workflows) as a
-scope-aware, toggleable startup experience. Provisioning is delegated to the
-canonical `npx bmad-method install` (needs Node.js 20.12+); boost owns scope,
-the startup toggle, and teardown.
+### BMAD autopilot
+
+`boost bmad on` is a one-time, global switch that puts the
+[BMAD Method](https://bmadcode.com/)'s personas in charge of every task that
+arrives, without you having to invoke anything. No Node, no network, one
+command:
+
+```bash
+boost bmad on      # ← that's it
+```
+
+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:
+
+```text
+[BMAD autopilot] track: build
+Lead: `bmad-dev` subagent — Amelia, Senior Software Engineer. Ship it complete and verified.
+Support: `bmad-tea` (Murat), `bmad-scribe` (Paige) — spawn them with the Agent tool…
+BMAD skill: `bmad-build` — invoke it if it is installed; otherwise the persona's own playbook stands.
+Done means: tests: add or update coverage under `tests/`, and run them · docs: update
+`README.md` / `docs/` wherever the change shows · roadmap: create or claim the item under
+`docs/roadmap/items/` · gate: `make check` green, with real output · `CLAUDE.md` is binding
+Work autonomously through to a finished, verified change; stop to ask only when a choice
+would change what gets delivered.
+```
+
+Nine tracks (`build`, `quality`, `docs`, `planning`, `product`, `architecture`,
+`ux`, `discovery`, `review`) each name a lead persona, the support personas to
+spawn alongside it, and the canonical BMAD v6 skill for that kind of work.
+**That last line is the point**: the definition of done is read off the repo in
+front of you — your test directory, your docs, your roadmap items, your gate
+command — so documentation, testing and roadmap bookkeeping travel with the task
+instead of being remembered afterwards.
+
+The router costs a question nothing. Acknowledgements, slash commands, short
+informational questions ("what does `scan_dir` do?") and anything containing
+`no bmad` produce **no banner at all** — and because a `UserPromptSubmit` hook
+that exits non-zero would erase your prompt, it degrades every failure to
+silence and always exits 0.
+
+```bash
+boost bmad personas                            # the roster, and whether it's installed
+boost bmad route "add tests for the scanner" --plain   # what would this route to?
+boost bmad doctor                              # autopilot + workflow state, both scopes
+boost bmad off                                 # remove the hooks and the personas
+boost bmad on --scope project                  # or keep it to one repo
+```
+
+Every persona file carries an ownership stamp containing a digest of its own
+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.
+
+**The full method** is still a separate, heavier install. `boost bmad install`
+delegates to the canonical `npx bmad-method install` (needs Node.js 20.12+) for
+the `bmad-*` workflow skills and the per-project `_bmad/` runtime they read on
+activation:
 
 ```bash
 boost bmad install --scope project   # skills + per-project _bmad/ runtime
 boost bmad install --scope global    # skills into ~/.claude/skills for every session
 boost bmad init                      # add the _bmad/ runtime to the current repo
-boost bmad startup on                # inject light BMAD orientation on session start
-boost bmad startup off               # stop injecting it (skills stay installed)
+boost bmad startup on|off            # just the SessionStart briefing
 boost bmad disable / enable          # quarantine / restore skills (recoverable)
 boost bmad uninstall                 # delete skills + _bmad/ for a scope
-boost bmad doctor                    # what's installed where
 ```
 
-When startup is on, a `SessionStart` hook runs `boost bmad orient`, which prints
-a short orientation into the session only while the toggle is enabled. That
-orientation sets a **default bias**: build/fix/change/refactor requests go
-straight to the `bmad-quick-dev` skill (clarify → plan → implement → review),
-skipping the full brief → PRD → architecture ceremony unless you ask for full
-planning. Global installs stage the installer in a temp dir and copy only the
+The two compose. The autopilot routes at `bmad-build`, `bmad-prd` and friends
+whether or not they are installed and says which case you're in — with the
+skills present you get BMAD's full workflow, without them the persona's own
+playbook. Global installs stage the installer in a temp dir and copy only the
 `bmad-*` skills, so `$HOME` never gets a stray `_bmad/` — the workflow runtime
 stays per-project.
 

{boost_skill_cli-1.0.419 → boost_skill_cli-1.0.421}/boost_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.419'
-__version_tuple__ = version_tuple = (1, 0, 419)
+__version__ = version = '1.0.421'
+__version_tuple__ = version_tuple = (1, 0, 421)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.419 → boost_skill_cli-1.0.421}/boost_cli/cli.py

@@ -124,7 +124,7 @@ COMMANDS = [
     ("serve",       "cfg", "configuration", "Serve the skill catalog over HTTP (port 8787)"),
     ("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"),
-    ("bmad",        "cfg", "bmad", "Install & manage the BMAD Method (scope-aware, toggleable)"),
+    ("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)
     ("cohort",      "team", "team", "Controlled skill rollouts & team A/B testing"),

{boost_skill_cli-1.0.419 → boost_skill_cli-1.0.421}/boost_cli/commands/bmad.py

@@ -1,21 +1,46 @@
-"""boost bmad — install & manage the BMAD Method, scope-aware and toggleable.
+"""boost bmad — the BMAD Method as a one-command, global autopilot.
 
-BMAD ships as Claude Code skills PLUS a per-project `_bmad/` config/runtime that
-the skills read on activation. boost owns scope, the startup toggle, and teardown;
-full provisioning is delegated to the canonical `npx bmad-method install`.
+There are two surfaces here, and the split is the whole design.
+
+**The autopilot** is `boost bmad on`. One command, global by default, no Node
+and no network: it writes the seven BMAD persona subagents into
+`~/.claude/agents/`, and installs two hooks — a `SessionStart` briefing and a
+`UserPromptSubmit` router. After that, every substantive prompt arrives already
+carrying the persona that should lead it, the support personas to spawn
+alongside, the BMAD skill for that track, and a definition of done read off the
+repo in front of it (its test dir, its docs, its roadmap items, its gate
+command). Trivial asks get nothing, so the router costs a question nothing. All
+of the thinking lives in :mod:`boost_cli.core.bmad`; this module is glue.
+
+    boost bmad on                          # <- the one command. global.
+    boost bmad off                         # remove hooks + boost-written personas
+    boost bmad personas                    # the roster, and whether it is installed
+    boost bmad route [PROMPT] [--plain]    # hook target; pipeable for debugging
+
+**The full method** is `boost bmad install`, unchanged: it delegates to the
+canonical `npx bmad-method install` (Node.js 20.12+) for the `bmad-*` workflow
+skills and the per-project `_bmad/` runtime they read on activation.
 
     boost bmad install --scope project     # skills + _bmad/ runtime in this repo
-    boost bmad install --scope global      # skills into ~/.claude/skills (+ toggle)
+    boost bmad install --scope global      # skills into ~/.claude/skills
     boost bmad init                        # add _bmad/ runtime to the current repo
-    boost bmad startup on|off|status       # toggle the SessionStart orientation
-                                           # (biases build/fix/change work to bmad-quick-dev)
+    boost bmad startup on|off|status       # just the SessionStart briefing
     boost bmad disable / enable            # quarantine / restore skills (recoverable)
     boost bmad uninstall                   # delete skills + _bmad/ for a scope
     boost bmad doctor                      # what's installed where
 
-Global installs stage the installer in a temp dir and copy only the `bmad-*`
-skills into ~/.claude/skills, so $HOME never gets a stray `_bmad/`. The `_bmad/`
-runtime is per-project (`boost bmad init`).
+The two compose: the autopilot routes at `bmad-build` and friends whether or
+not they are installed, and says so — with the skills present you get BMAD's
+full workflow, without them you get the persona's own playbook. Global installs
+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()`.
 """
 from __future__ import annotations
 
@@ -26,11 +51,13 @@ import re
 import shlex
 import shutil
 import subprocess
+import sys
 import tempfile
 from contextlib import suppress
 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 output as out
@@ -39,51 +66,39 @@ from ..errors import BoostError
 DEFAULT_MODULES = "bmm"
 HOOK_NAME = "bmad"
 HOOK_MATCHER = "startup|resume|clear"
+ROUTE_HOOK_NAME = "bmad-route"
 
-ORIENT = """[BMAD MODE ACTIVE — light orientation]
-This environment has the BMAD Method installed as Claude Code skills. Be
-BMAD-aware without hijacking simple requests: use the workflow when the user is
-planning or building a feature; answer trivial one-off asks directly.
-
-Entry point: invoke the `bmad-help` skill to assess state and recommend a step.
-
-Persona agents (skills): bmad-agent-analyst (Mary, research/brief),
-bmad-agent-pm (John, PRD), bmad-agent-architect (Winston, architecture),
-bmad-agent-ux-designer (Sally), bmad-agent-dev (Amelia, implementation),
-bmad-agent-tech-writer (Paige).
-
-Phases: Analysis (bmad-brainstorming -> bmad-product-brief -> research) ->
-Planning (bmad-prd -> bmad-architecture -> bmad-create-epics-and-stories) ->
-Build (bmad-sprint-planning -> bmad-create-story -> bmad-dev-story ->
-bmad-code-review -> bmad-qa-generate-e2e-tests -> bmad-retrospective).
-
-Default bias: for a build, fix, change, or refactor request, go straight to the
-`bmad-quick-dev` skill (clarify -> plan -> implement -> review) — skip the full
-brief -> PRD -> architecture ceremony unless the user asks for full planning.
-
-Full workflows need a per-project `_bmad/` runtime — run `boost bmad init` in a
-repo if it isn't there yet. Turn this orientation off with `boost bmad startup off`."""
-
-_ACTIONS = ("install", "init", "startup", "orient", "uninstall",
-            "disable", "enable", "doctor", "status")
+_ACTIONS = ("on", "off", "route", "personas", "install", "init", "startup",
+            "orient", "uninstall", "disable", "enable", "doctor", "status")
 
 
 def cmd_bmad(argv) -> int:
     p = cliparse.parser(
         prog="boost bmad",
-        description="Install & manage the BMAD Method (scope-aware, toggleable)")
+        description="BMAD Method autopilot: personas, prompt routing, workflows")
     p.add_argument("action", choices=_ACTIONS, help=" | ".join(_ACTIONS))
-    p.add_argument("value", nargs="?", help="for startup: on | off | status")
+    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,
-                   help="target scope (default: project)")
+                   help="target scope (on/off default: global; others: project)")
     p.add_argument("--modules", default=DEFAULT_MODULES,
                    help="BMAD modules to install (default: %s)" % DEFAULT_MODULES)
     p.add_argument("-y", "--yes", action="store_true",
                    help="skip confirmation prompts")
     p.add_argument("--startup", action="store_true",
                    help="enable the startup toggle right after install")
+    p.add_argument("--plain", action="store_true",
+                   help="route: print the banner as text, not as hook JSON")
     args = p.parse_args(argv)
 
+    if args.action == "on":
+        return _autopilot_on(args.scope)
+    if args.action == "off":
+        return _autopilot_off(args.scope)
+    if args.action == "route":
+        return _route(args.value, args.plain)
+    if args.action == "personas":
+        return _personas(args.scope)
     if args.action == "install":
         return _install(args.scope, args.modules, args.startup)
     if args.action == "init":
@@ -101,6 +116,152 @@ def cmd_bmad(argv) -> int:
     return _doctor()  # doctor | status
 
 
+# ------------------------------------------------------------------- autopilot
+
+def _agents_dir(scope) -> Path:
+    """Where Claude Code reads subagent definitions for a scope."""
+    base = paths.home() if scope == "global" else Path.cwd()
+    return base / ".claude" / "agents"
+
+
+def _never_fails(command: str) -> str:
+    """Make a hook command structurally incapable of reporting failure.
+
+    `_route` is careful to always exit 0 — but argparse never gets that far. The
+    hook is installed against :func:`paths.launcher`, i.e. whatever `boost` is on
+    PATH, which is not necessarily the build that wrote the hook: a stale pipx
+    install, or a later downgrade, reaches `bmad route`, does not recognise the
+    action, and exits **2**. On UserPromptSubmit exit 2 does not merely log — it
+    blocks the prompt and erases it from the transcript, so every message the
+    user typed would vanish until they found the hook.
+
+    `|| true` closes that at the shell, outside any version of boost. The
+    `# boost:<name>` ownership marker `claude_settings` appends still parses as a
+    trailing comment.
+    """
+    return command + " || true"
+
+
+def _autopilot_on(scope) -> int:
+    """The one command. Personas + orientation + router, in one idempotent pass.
+
+    Global by default: the point of the autopilot is that a task arriving in
+    *any* repo already knows which persona owns it, and per-project setup would
+    make that a per-repo chore.
+    """
+    scope = scope or "global"
+    agents = _agents_dir(scope)
+    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))
+    _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))
+
+    out.ok("BMAD autopilot ON (%s) — %d persona subagent(s) + prompt router"
+           % (scope, len(slugs)))
+    if skipped:
+        out.warn("kept your edits to %d persona(s): %s"
+                 % (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)))
+    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
+    # started, so a first-ever install is invisible until the next launch.
+    out.info("restart your agent session to pick up the new subagents")
+    out.dim("  full BMAD workflow skills (needs Node): boost bmad install")
+    return 0
+
+
+def _autopilot_off(scope) -> int:
+    scope = scope or "global"
+    cs.remove_hook(scope, "SessionStart", HOOK_NAME)
+    cs.remove_hook(scope, "UserPromptSubmit", ROUTE_HOOK_NAME)
+    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))
+    out.ok("BMAD autopilot OFF (%s) — removed %d persona(s) and both hooks"
+           % (scope, len(removed)))
+    out.dim("  hand-edited personas were left in place")
+    return 0
+
+
+def _read_hook_stdin() -> dict:
+    """Claude Code's UserPromptSubmit payload, or {} for anything unreadable.
+
+    Accepts plain text too, so `echo "add tests for the scanner" | boost bmad
+    route` works for a human debugging the routing table. (Give it a real
+    prompt: anything under `core.MIN_WORDS` words classifies as trivial and
+    prints nothing, which reads like a broken install.)
+    """
+    try:
+        if sys.stdin.isatty():
+            return {}       # interactive: don't block waiting for an EOF
+        raw = sys.stdin.read().strip()
+    except (OSError, ValueError, UnicodeDecodeError):
+        return {}
+    if not raw:
+        return {}
+    try:
+        data = json.loads(raw)
+    except ValueError:
+        return {"prompt": raw}
+    return data if isinstance(data, dict) else {"prompt": raw}
+
+
+def _route(prompt, plain) -> int:
+    """UserPromptSubmit hook target: classify, then emit the routing banner.
+
+    This runs on every single prompt, so it has exactly one hard rule: **always
+    exit 0**. On UserPromptSubmit an exit code of 2 blocks the prompt and erases
+    it from the transcript — a crash here would eat the user's message. Every
+    failure mode therefore degrades to silence.
+    """
+    try:
+        payload = {} if prompt else _read_hook_stdin()
+        text = prompt or str(payload.get("prompt") or "")
+        cwd = payload.get("cwd")
+        root = Path(cwd) if cwd else Path.cwd()
+        banner = core.route_context(text, root)
+    except Exception:                     # a hook must never break the session
+        return 0
+    if not banner:
+        return 0
+    if plain:
+        print(banner)
+        return 0
+    print(json.dumps({"hookSpecificOutput": {
+        "hookEventName": "UserPromptSubmit",
+        "additionalContext": banner,
+    }}))
+    return 0
+
+
+def _personas(scope) -> int:
+    scope = scope or "global"
+    agents = _agents_dir(scope)
+    live = set(core.installed_personas(agents))
+    out.heading("BMAD personas — %s" % scope)
+    for p in core.PERSONAS:
+        mark = "installed" if p.slug in live else "not installed"
+        # width 16: `bmad-architect` is exactly the default 14, which leaves no
+        # gap between the key and the value.
+        out.kv(p.slug, "%s, %s (%s) — %s"
+               % (p.character, p.title, p.module, mark), width=16)
+    out.dim("  → %s" % paths.tilde(agents))
+    if not live:
+        out.dim("  install them with `boost bmad on`")
+    return 0
+
+
 # ------------------------------------------------------------------- provisioning
 
 def _require_npx() -> None:
@@ -223,11 +384,11 @@ def _startup(value, scope) -> int:
 
 
 def _orient(scope) -> int:
-    """SessionStart hook target: print orientation iff enabled (else silent)."""
+    """SessionStart hook target: print the briefing iff enabled (else silent)."""
     scope = scope or "project"
     with suppress(Exception):  # a hook must never break the session
         if _get_scope_state(scope).get("startup"):
-            print(ORIENT)
+            print(core.orientation())
     return 0
 
 
@@ -253,7 +414,9 @@ def _uninstall(scope, yes) -> int:
         out.info("aborted")
         return 0
     cs.remove_hook(scope, "SessionStart", HOOK_NAME)
+    cs.remove_hook(scope, "UserPromptSubmit", ROUTE_HOOK_NAME)
     removed = _rm_skills(_skills_dir(scope))
+    removed += len(core.remove_personas(_agents_dir(scope)))
     if scope == "project":
         for extra in ("_bmad", "_bmad-output"):
             pth = Path.cwd() / extra
@@ -310,15 +473,25 @@ def _enable(scope) -> int:
 
 def _doctor() -> int:
     out.heading("BMAD status")
-    out.kv("npx", shutil.which("npx") or "MISSING")
-    out.kv("node", shutil.which("node") or "MISSING")
+    # Node is only needed by `install`/`init`; the autopilot never shells out,
+    # so MISSING here is a limitation, not a fault.
+    out.kv("npx", shutil.which("npx") or "MISSING (only `install` needs it)")
+    out.kv("node", shutil.which("node") or "MISSING (only `install` needs it)")
     for scope in ("global", "project"):
         st = _get_scope_state(scope)
-        n = _count_skills(_skills_dir(scope))
-        hook = cs.has_hook(scope, "SessionStart", HOOK_NAME)
-        out.kv(scope, "skills=%d  startup=%s  hook=%s  installed=%s"
-               % (n, bool(st.get("startup")), hook, bool(st.get("installed"))))
+        agents = _agents_dir(scope)
+        personas = len(core.installed_personas(agents))
+        router = cs.has_hook(scope, "UserPromptSubmit", ROUTE_HOOK_NAME)
+        live = bool(st.get("autopilot")) and router
+        out.kv(scope, "autopilot=%s  %d personas  router=%s  briefing=%s"
+               % ("on" if live else "off", personas,
+                  "on" if router else "off",
+                  "on" if cs.has_hook(scope, "SessionStart", HOOK_NAME) else "off"))
+        out.kv("  workflows", "skills=%d  installed=%s"
+               % (_count_skills(_skills_dir(scope)), bool(st.get("installed"))))
     out.dim("  project = %s" % Path.cwd())
+    if not any(_get_scope_state(s).get("autopilot") for s in ("global", "project")):
+        out.dim("  turn it on with `boost bmad on`")
     return 0