boost-skill-cli 1.0.7__tar.gz → 1.0.15__tar.gz

{boost_skill_cli-1.0.7 → boost_skill_cli-1.0.15}/.gitignore

@@ -219,3 +219,8 @@ __marimo__/
 
 # setuptools-scm generated version file
 boost_cli/_version.py
+
+# BMAD Method — generated artifacts (provisioned via `boost bmad`, not source)
+_bmad/
+_bmad-output/
+.claude/skills/bmad-*/

{boost_skill_cli-1.0.7 → boost_skill_cli-1.0.15}/CLAUDE.md

@@ -50,6 +50,28 @@ line coverage. Target `boost_cli/core` behavior with assertions, not just import
   `workflow` (commands/agents/workflows Markdown). **Only `skill` installs** —
   `store.install` refuses non-skill kinds; rules/workflows are search/tap-only.
 
+## Parallel work & concurrent loops
+
+More than one agent (or `/loop` session) may be working this repo at once. To
+keep them from clobbering each other:
+
+- **Never edit a checkout that has someone else's branch checked out.** The user
+  works live in `~/boost`; long-running loops use a separate `git worktree`
+  (e.g. `~/boost-loop`, which needs its **own** `.venv` because mutmut wants an
+  editable `pip install -e .` pointed at that tree). Run `git worktree list` and
+  `git status` before touching a tree — staged or unstaged changes mean another
+  agent is mid-edit there, so pick a different worktree.
+- **Branch off `origin/main`, one topic per branch.** `git fetch origin main`
+  then `git checkout -B loop/<topic> origin/main`. Keep changes additive and
+  file-scoped so parallel branches merge without conflicts.
+- **Coordinate through PRs, not the working tree.** `gh pr merge` is server-side
+  and won't touch anyone's local checkout. Before committing a file, inspect
+  `git status` / `git diff` — if another session has it staged or dirty, leave
+  it to that owner rather than committing over their in-flight work.
+- **Every merge to `main` cuts a PyPI release.** Land one coherent change per PR,
+  never merge onto a red release, and after merging confirm the publish workflow
+  goes green — not just the PR checks.
+
 ## Layout
 
 - `boost_cli/commands/` — CLI command groups   · `boost_cli/core/` — engine (the mutation-gated code)

{boost_skill_cli-1.0.7 → boost_skill_cli-1.0.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.7
+Version: 1.0.15
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE
@@ -718,7 +718,11 @@ pulled from GitHub-hosted registries, then hooks them straight into
 skill files into three different agent folders and hoping you remember to
 update all of them, you run one command.
 
-![boost demo](docs/demo.gif)
+<p align="center">
+  <img src="docs/demo.gif" alt="boost demo: tap a registry, search for a skill, install it into every agent, then run doctor" width="820">
+  <br>
+  <sub><em>tap a registry → search → install into every agent → doctor — one flow</em></sub>
+</p>
 
 ## What's a "skill," exactly?
 
@@ -797,7 +801,7 @@ boost doctor               # sanity check: broken links, lock drift, stale taps
 boost bundle dump > Boostfile     # everyone else runs: boost bundle install
 ```
 
-## 72 commands, organized into 8 groups
+## 75 commands, organized into 8 groups
 
 `boost --help` prints the full grouped command list; for a visual tour see
 [`docs/overview.html`](docs/overview.html).
@@ -805,12 +809,12 @@ boost bundle dump > Boostfile     # everyone else runs: boost bundle install
 | Group | Commands |
 |---|---|
 | **Package Management** | install · uninstall · sync · update · reinstall · bundle · import · migrate · pin · unpin · snapshot · export |
-| **Discovery & Search** | search · discover · recommend · browse · index · trending · stats · count |
+| **Discovery & Search** | search · reindex · discover · recommend · browse · index · trending · stats · count |
 | **Skill Information** | list · info · cat · edit · preview · explain · log · home · deps · tag |
 | **Registry (Taps)** | tap · untap · taps · outdated |
 | **Intelligence** | distill · simulate · infer · absorb · evolve · context · focus · impact |
 | **Quality & Health** | doctor · lint · audit · verify · drift · test · fingerprint · quarantine · decay · heal · conflict · changelog · attest · health |
-| **Configuration** | config · clean · create · policy · onboard · completions · schedule · serve · mcp · self-update |
+| **Configuration** | config · clean · create · policy · onboard · completions · schedule · serve · mcp · hooks · bmad · self-update |
 | **Team & Collaboration** | cohort · profile · protocol · pulse · replay · who |
 
 The AI-assisted commands (`search --smart`, `explain`, `distill`, `infer`,
@@ -819,6 +823,53 @@ available on your PATH (or `ANTHROPIC_API_KEY` is set), and fall back to
 plain heuristics when it isn't — so the tool still works without an API key,
 just less cleverly.
 
+## Claude Code hooks & the BMAD Method
+
+`boost hooks` manages Claude Code 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.
+
+```bash
+boost hooks add SessionStart -c 'echo hello' -n greet --scope project
+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.
+
+```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 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. 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.
+
+## The boost style
+
+The visual identity behind the docs and demos ships as a small, dependency-free
+design system in [`style/`](style/) — the *Aurora living-glass* look: a
+cyan → violet → pink triad on a near-black ground, an ambient aurora that drifts
+behind the page, and glass cards that light up under the cursor. Drop
+[`style/boost.css`](style/boost.css) (and the optional
+[`style/boost.js`](style/boost.js)) into any static page; see
+[`style/demo.html`](style/demo.html) for the whole system on one page and
+[`style/README.md`](style/README.md) for the tokens and class reference.
+
 ## Working on boost
 
 ```bash

{boost_skill_cli-1.0.7 → boost_skill_cli-1.0.15}/README.md

@@ -14,7 +14,11 @@ pulled from GitHub-hosted registries, then hooks them straight into
 skill files into three different agent folders and hoping you remember to
 update all of them, you run one command.
 
-![boost demo](docs/demo.gif)
+<p align="center">
+  <img src="docs/demo.gif" alt="boost demo: tap a registry, search for a skill, install it into every agent, then run doctor" width="820">
+  <br>
+  <sub><em>tap a registry → search → install into every agent → doctor — one flow</em></sub>
+</p>
 
 ## What's a "skill," exactly?
 
@@ -93,7 +97,7 @@ boost doctor               # sanity check: broken links, lock drift, stale taps
 boost bundle dump > Boostfile     # everyone else runs: boost bundle install
 ```
 
-## 72 commands, organized into 8 groups
+## 75 commands, organized into 8 groups
 
 `boost --help` prints the full grouped command list; for a visual tour see
 [`docs/overview.html`](docs/overview.html).
@@ -101,12 +105,12 @@ boost bundle dump > Boostfile     # everyone else runs: boost bundle install
 | Group | Commands |
 |---|---|
 | **Package Management** | install · uninstall · sync · update · reinstall · bundle · import · migrate · pin · unpin · snapshot · export |
-| **Discovery & Search** | search · discover · recommend · browse · index · trending · stats · count |
+| **Discovery & Search** | search · reindex · discover · recommend · browse · index · trending · stats · count |
 | **Skill Information** | list · info · cat · edit · preview · explain · log · home · deps · tag |
 | **Registry (Taps)** | tap · untap · taps · outdated |
 | **Intelligence** | distill · simulate · infer · absorb · evolve · context · focus · impact |
 | **Quality & Health** | doctor · lint · audit · verify · drift · test · fingerprint · quarantine · decay · heal · conflict · changelog · attest · health |
-| **Configuration** | config · clean · create · policy · onboard · completions · schedule · serve · mcp · self-update |
+| **Configuration** | config · clean · create · policy · onboard · completions · schedule · serve · mcp · hooks · bmad · self-update |
 | **Team & Collaboration** | cohort · profile · protocol · pulse · replay · who |
 
 The AI-assisted commands (`search --smart`, `explain`, `distill`, `infer`,
@@ -115,6 +119,53 @@ available on your PATH (or `ANTHROPIC_API_KEY` is set), and fall back to
 plain heuristics when it isn't — so the tool still works without an API key,
 just less cleverly.
 
+## Claude Code hooks & the BMAD Method
+
+`boost hooks` manages Claude Code 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.
+
+```bash
+boost hooks add SessionStart -c 'echo hello' -n greet --scope project
+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.
+
+```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 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. 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.
+
+## The boost style
+
+The visual identity behind the docs and demos ships as a small, dependency-free
+design system in [`style/`](style/) — the *Aurora living-glass* look: a
+cyan → violet → pink triad on a near-black ground, an ambient aurora that drifts
+behind the page, and glass cards that light up under the cursor. Drop
+[`style/boost.css`](style/boost.css) (and the optional
+[`style/boost.js`](style/boost.js)) into any static page; see
+[`style/demo.html`](style/demo.html) for the whole system on one page and
+[`style/README.md`](style/README.md) for the tokens and class reference.
+
 ## Working on boost
 
 ```bash

{boost_skill_cli-1.0.7 → boost_skill_cli-1.0.15}/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.7'
-__version_tuple__ = version_tuple = (1, 0, 7)
+__version__ = version = '1.0.15'
+__version_tuple__ = version_tuple = (1, 0, 15)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.7 → boost_skill_cli-1.0.15}/boost_cli/cli.py

@@ -1,4 +1,4 @@
-"""boost CLI dispatcher — 72 commands across 8 groups.
+"""boost CLI dispatcher — 75 commands across 8 groups.
 
 Each command lives in boost_cli/commands/<module>.py as
     def cmd_<name_with_underscores>(argv: list[str]) -> int
@@ -60,8 +60,9 @@ COMMANDS = [
     ("unpin",       "pkg", "pkg", "Allow a pinned skill to update again"),
     ("snapshot",    "pkg", "pkg", "Save & restore whole skill environments"),
     ("export",      "pkg", "pkg", "Package skills as shareable zip/tar archives"),
-    # Discovery & Search (8)
+    # Discovery & Search (9)
     ("search",      "find", "discovery", "Search skills across tap registries (AI-ranked)"),
+    ("reindex",     "find", "discovery", "Build/refresh the full-content search index"),
     ("discover",    "find", "discovery", "Browse & search the GitHub-wide skill discovery index"),
     ("recommend",   "find", "discovery", "Suggest skills based on your project's tech stack"),
     ("browse",      "find", "discovery", "Interactive full-screen TUI with fuzzy search"),
@@ -109,7 +110,7 @@ COMMANDS = [
     ("changelog",   "chk", "quality", "Show a skill's upstream change history"),
     ("attest",      "chk", "quality", "Display/verify the install record for skills"),
     ("health",      "chk", "quality", "Dashboard of skill-environment health"),
-    # Configuration (10)
+    # Configuration (12)
     ("config",      "cfg", "configuration", "Display or modify boost configuration"),
     ("clean",       "cfg", "configuration", "Clear stale caches & broken symlinks"),
     ("create",      "cfg", "configuration", "Scaffold a new skill from a template"),
@@ -119,6 +120,8 @@ COMMANDS = [
     ("schedule",    "cfg", "configuration", "Manage automatic skill-sync scheduling"),
     ("serve",       "cfg", "configuration", "Serve the skill catalog over HTTP (port 8787)"),
     ("mcp",         "cfg", "configuration", "Register boost as an MCP server for Claude Code"),
+    ("hooks",       "cfg", "hooks", "Manage Claude Code hooks (scope-aware) in settings.json"),
+    ("bmad",        "cfg", "bmad", "Install & manage the BMAD Method (scope-aware, toggleable)"),
     ("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.15/boost_cli/commands/bmad.py

@@ -0,0 +1,403 @@
+"""boost bmad — install & manage the BMAD Method, scope-aware and toggleable.
+
+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`.
+
+    boost bmad install --scope project     # skills + _bmad/ runtime in this repo
+    boost bmad install --scope global      # skills into ~/.claude/skills (+ toggle)
+    boost bmad init                        # add _bmad/ runtime to the current repo
+    boost bmad startup on|off|status       # toggle the SessionStart orientation
+    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`).
+"""
+from __future__ import annotations
+
+import argparse
+import getpass
+import json
+import os
+import re
+import shlex
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+from ..core import claude_settings as cs
+from ..core import journal
+from ..core import output as out
+from ..core import paths, util
+from ..errors import BoostError
+
+DEFAULT_MODULES = "bmm"
+HOOK_NAME = "bmad"
+HOOK_MATCHER = "startup|resume|clear"
+
+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).
+
+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")
+
+
+def cmd_bmad(argv) -> int:
+    p = argparse.ArgumentParser(
+        prog="boost bmad",
+        description="Install & manage the BMAD Method (scope-aware, toggleable)")
+    p.add_argument("action", choices=_ACTIONS, help=" | ".join(_ACTIONS))
+    p.add_argument("value", nargs="?", help="for startup: on | off | status")
+    p.add_argument("-s", "--scope", choices=("project", "global"), default=None,
+                   help="target scope (default: 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")
+    args = p.parse_args(argv)
+
+    if args.action == "install":
+        return _install(args.scope, args.modules, args.startup)
+    if args.action == "init":
+        return _init(args.modules, args.startup)
+    if args.action == "startup":
+        return _startup(args.value or "status", args.scope)
+    if args.action == "orient":
+        return _orient(args.scope)
+    if args.action == "uninstall":
+        return _uninstall(args.scope, args.yes)
+    if args.action == "disable":
+        return _disable(args.scope)
+    if args.action == "enable":
+        return _enable(args.scope)
+    return _doctor()  # doctor | status
+
+
+# ------------------------------------------------------------------- provisioning
+
+def _require_npx() -> None:
+    if not shutil.which("npx"):
+        raise BoostError(
+            "npx not found — BMAD is provisioned via `npx bmad-method install`",
+            hint="install Node.js 20.12+ (e.g. `brew install node`), then retry")
+
+
+def _run_installer(directory: Path, modules: str) -> "subprocess.CompletedProcess":
+    cmd = ["npx", "--yes", "bmad-method@latest", "install",
+           "--yes", "--directory", str(directory),
+           "--tools", "claude-code", "--modules", modules,
+           "--user-name", _whoami()]
+    try:
+        proc = subprocess.run(cmd, capture_output=True, text=True, timeout=900)
+    except (OSError, subprocess.TimeoutExpired) as e:
+        raise BoostError("bmad install failed: %s" % e,
+                         hint="run it yourself: " + " ".join(cmd))
+    if proc.returncode != 0:
+        tail = (proc.stderr or proc.stdout or "").strip().splitlines()
+        raise BoostError(
+            "bmad install failed: %s" % (tail[-1] if tail else "unknown error"),
+            hint="run it yourself: " + " ".join(cmd))
+    return proc
+
+
+def _whoami() -> str:
+    try:
+        return getpass.getuser()
+    except Exception:
+        return "developer"
+
+
+def _parse_version(text: str) -> str:
+    m = re.search(r"v(\d+\.\d+\.\d+)", text or "")
+    return m.group(1) if m else "unknown"
+
+
+def _install(scope, modules, do_startup) -> int:
+    scope = scope or "project"
+    _require_npx()
+    if scope == "global":
+        n = _copy_global_skills(modules)
+        _set_scope_state("global", installed=True, skills=n,
+                         modules=modules.split(","), installed_at=util.now_iso())
+        out.ok("installed %d BMAD skill(s) globally → %s"
+               % (n, _skills_dir("global")))
+        out.dim("  run `boost bmad init` in a project for its _bmad/ workflow runtime")
+    else:
+        ver, n = _install_project_runtime(modules)
+        out.ok("installed BMAD in %s (%d skills, v%s)" % (Path.cwd(), n, ver))
+    if do_startup:
+        _startup("on", scope)
+    return 0
+
+
+def _init(modules, do_startup) -> int:
+    _require_npx()
+    ver, n = _install_project_runtime(modules)
+    out.ok("BMAD runtime ready in %s (_bmad/, %d skills, v%s)"
+           % (Path.cwd(), n, ver))
+    if do_startup:
+        _startup("on", "project")
+    return 0
+
+
+def _install_project_runtime(modules):
+    target = Path.cwd()
+    proc = _run_installer(target, modules)
+    ver = _parse_version((proc.stdout or "") + (proc.stderr or ""))
+    n = _count_skills(_skills_dir("project"))
+    _set_scope_state("project", installed=True, skills=n, version=ver,
+                     modules=modules.split(","), installed_at=util.now_iso())
+    return ver, n
+
+
+def _copy_global_skills(modules) -> int:
+    """Stage the installer in a temp dir; copy only bmad-* skills into ~/.claude."""
+    stage = Path(tempfile.mkdtemp(prefix="boost-bmad-"))
+    try:
+        _run_installer(stage, modules)
+        src = stage / ".claude" / "skills"
+        dest = _skills_dir("global")
+        dest.mkdir(parents=True, exist_ok=True)
+        n = 0
+        for d in sorted(src.glob("bmad-*")):
+            if not d.is_dir():
+                continue
+            t = dest / d.name
+            if t.exists():
+                shutil.rmtree(t)
+            shutil.copytree(d, t)
+            n += 1
+        return n
+    finally:
+        shutil.rmtree(stage, ignore_errors=True)
+
+
+# ----------------------------------------------------------------------- toggle
+
+def _startup(value, scope) -> int:
+    scope = scope or "project"
+    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)
+        _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))
+        return 0
+    if value == "off":
+        cs.remove_hook(scope, "SessionStart", HOOK_NAME)
+        _set_scope_state(scope, startup=False)
+        journal.log("bmad-startup", "off", scope=scope)
+        out.ok("BMAD startup OFF (%s) — skills stay installed" % scope)
+        return 0
+    return _status(scope)
+
+
+def _orient(scope) -> int:
+    """SessionStart hook target: print orientation iff enabled (else silent)."""
+    scope = scope or "project"
+    try:
+        if _get_scope_state(scope).get("startup"):
+            print(ORIENT)
+    except Exception:
+        pass  # a hook must never break the session
+    return 0
+
+
+def _status(scope) -> int:
+    st = _get_scope_state(scope)
+    hook = cs.has_hook(scope, "SessionStart", HOOK_NAME)
+    n = _count_skills(_skills_dir(scope))
+    out.heading("BMAD startup — %s" % scope)
+    out.kv("enabled", str(bool(st.get("startup"))))
+    out.kv("hook", "present" if hook else "absent")
+    out.kv("skills", str(n))
+    out.kv("installed", str(bool(st.get("installed"))))
+    return 0
+
+
+# ------------------------------------------------------------------- teardown
+
+def _uninstall(scope, yes) -> int:
+    scope = scope or "project"
+    if not (yes or out.confirm(
+            "Remove BMAD (%s)? deletes bmad-* skills%s" % (
+                scope, " + _bmad/, _bmad-output/" if scope == "project" else ""))):
+        out.info("aborted")
+        return 0
+    cs.remove_hook(scope, "SessionStart", HOOK_NAME)
+    removed = _rm_skills(_skills_dir(scope))
+    if scope == "project":
+        for extra in ("_bmad", "_bmad-output"):
+            pth = Path.cwd() / extra
+            if pth.exists():
+                shutil.rmtree(pth, ignore_errors=True)
+                removed += 1
+    _clear_scope_state(scope)
+    journal.log("bmad-uninstall", scope, count=removed)
+    out.ok("removed BMAD (%s): %d item(s)" % (scope, removed))
+    return 0
+
+
+def _disable(scope) -> int:
+    """Quarantine: turn startup off and move skills aside (recoverable)."""
+    scope = scope or "project"
+    cs.remove_hook(scope, "SessionStart", HOOK_NAME)
+    qdir = _quarantine_dir(scope)
+    qdir.mkdir(parents=True, exist_ok=True)
+    moved = 0
+    for d in sorted(_skills_dir(scope).glob("bmad-*")):
+        target = qdir / d.name
+        if target.exists():
+            shutil.rmtree(target)
+        shutil.move(str(d), str(target))
+        moved += 1
+    _set_scope_state(scope, startup=False, disabled=True)
+    journal.log("bmad-disable", scope, count=moved)
+    out.ok("quarantined %d BMAD skill(s) (%s)" % (moved, scope))
+    out.dim("  restore with `boost bmad enable --scope %s`" % scope)
+    return 0
+
+
+def _enable(scope) -> int:
+    scope = scope or "project"
+    qdir = _quarantine_dir(scope)
+    restored = 0
+    if qdir.exists():
+        dest = _skills_dir(scope)
+        dest.mkdir(parents=True, exist_ok=True)
+        for d in sorted(qdir.glob("bmad-*")):
+            target = dest / d.name
+            if target.exists():
+                shutil.rmtree(target)
+            shutil.move(str(d), str(target))
+            restored += 1
+    _set_scope_state(scope, disabled=False)
+    if restored:
+        journal.log("bmad-enable", scope, count=restored)
+        out.ok("restored %d BMAD skill(s) (%s)" % (restored, scope))
+    else:
+        out.warn("nothing quarantined for %s scope" % scope)
+    return 0
+
+
+def _doctor() -> int:
+    out.heading("BMAD status")
+    out.kv("npx", shutil.which("npx") or "MISSING")
+    out.kv("node", shutil.which("node") or "MISSING")
+    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"))))
+    out.dim("  project = %s" % Path.cwd())
+    return 0
+
+
+# -------------------------------------------------------------------- helpers
+
+def _skills_dir(scope) -> Path:
+    base = paths.home() if scope == "global" else Path.cwd()
+    return base / ".claude" / "skills"
+
+
+def _count_skills(skills_dir: Path) -> int:
+    if not skills_dir.exists():
+        return 0
+    return sum(1 for d in skills_dir.glob("bmad-*") if d.is_dir())
+
+
+def _rm_skills(skills_dir: Path) -> int:
+    n = 0
+    if skills_dir.exists():
+        for d in sorted(skills_dir.glob("bmad-*")):
+            shutil.rmtree(d, ignore_errors=True)
+            n += 1
+    return n
+
+
+def _quarantine_dir(scope) -> Path:
+    key = "global" if scope == "global" else _fs_slug(str(Path.cwd().resolve()))
+    return paths.state_dir() / "bmad-quarantine" / key
+
+
+def _fs_slug(p: str) -> str:
+    return p.replace(os.sep, "__").strip("_") or "root"
+
+
+# ---------------------------------------------------------------------- state
+
+def _state_path() -> Path:
+    return paths.state_dir() / "bmad.json"
+
+
+def _state_read() -> dict:
+    p = _state_path()
+    if not p.exists():
+        return {"global": {}, "projects": {}}
+    try:
+        d = json.loads(p.read_text())
+    except (json.JSONDecodeError, OSError):
+        return {"global": {}, "projects": {}}
+    d.setdefault("global", {})
+    d.setdefault("projects", {})
+    return d
+
+
+def _state_write(d: dict) -> None:
+    paths.ensure_dirs()
+    _state_path().write_text(json.dumps(d, indent=2) + "\n")
+
+
+def _proj_key() -> str:
+    return str(Path.cwd().resolve())
+
+
+def _get_scope_state(scope) -> dict:
+    d = _state_read()
+    if scope == "global":
+        return d["global"]
+    return d["projects"].get(_proj_key(), {})
+
+
+def _set_scope_state(scope, **patch) -> None:
+    d = _state_read()
+    if scope == "global":
+        d["global"].update(patch)
+    else:
+        d["projects"].setdefault(_proj_key(), {}).update(patch)
+    _state_write(d)
+
+
+def _clear_scope_state(scope) -> None:
+    d = _state_read()
+    if scope == "global":
+        d["global"] = {}
+    else:
+        d["projects"].pop(_proj_key(), None)
+    _state_write(d)