boost-skill-cli 1.2.95__tar.gz → 1.2.96__tar.gz

{boost_skill_cli-1.2.95/boost_skill_cli.egg-info → boost_skill_cli-1.2.96}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.95
+Version: 1.2.96
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0

{boost_skill_cli-1.2.95 → boost_skill_cli-1.2.96}/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.95'
-__version_tuple__ = version_tuple = (1, 2, 95)
+__version__ = version = '1.2.96'
+__version_tuple__ = version_tuple = (1, 2, 96)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.95 → boost_skill_cli-1.2.96}/boost_cli/commands/bmad.py

@@ -138,6 +138,17 @@ def cmd_bmad(argv) -> int:
 
 # ------------------------------------------------------------------- autopilot
 
+def _on_off(value) -> str:
+    """Render any truthy/falsy value as ``"on"``/``"off"``.
+
+    `doctor` used to format some booleans as ``on``/``off`` and others as
+    Python's ``True``/``False`` in the same block of output — "installed=False"
+    printed right beside "autopilot=off". One helper keeps every boolean field
+    in one vocabulary.
+    """
+    return "on" if value else "off"
+
+
 def _agents_dir(scope) -> Path:
     """Where Claude Code reads subagent definitions for a scope."""
     base = paths.home() if scope == "global" else Path.cwd()
@@ -216,18 +227,22 @@ def _add_hook_everywhere(scope: str, spec: tuple, command: str) -> list[str]:
     return written
 
 
-def _remove_hook_everywhere(scope: str, *specs: tuple) -> None:
-    """Remove hooks from every host, installed or not.
+def _remove_hook_everywhere(scope: str, *specs: tuple) -> int:
+    """Remove hooks from every host, installed or not. Returns how many were.
 
     Unlike install this does not filter on `shutil.which`: someone who removed
     an agent CLI still wants boost's hooks gone from its settings.json, and
-    `remove_hook` against a file that was never written is a no-op.
+    `remove_hook` against a file that was never written is a no-op — which is
+    exactly why the count matters: a caller that hardcodes "both hooks" in its
+    report is claiming work that a second, no-op `off` never did.
     """
+    removed = 0
     for host in hookhost.hosts():
         for event, name, _matcher in specs:
             target = hookhost.translate(host, event)
             if target is not None:
-                cs.remove_hook(scope, target, name, host=host)
+                removed += cs.remove_hook(scope, target, name, host=host)
+    return removed
 
 
 def _autopilot_on(scope) -> int:
@@ -239,7 +254,12 @@ def _autopilot_on(scope) -> int:
     """
     scope = scope or "global"
     agents = _agents_dir(scope)
-    slugs, skipped = core.write_personas(agents)
+    _written, skipped = core.write_personas(agents)
+    # A skipped (edited) persona file is still on disk and Claude Code still
+    # loads it — only the ones neither written nor present at all are truly
+    # "not installed", so the reported count is managed + edited, not just
+    # what this run happened to (re)write.
+    present = len(core.present_personas(agents))
 
     launcher = shlex.quote(str(paths.launcher()))
     hosts = _add_hook_everywhere(
@@ -247,12 +267,12 @@ def _autopilot_on(scope) -> int:
         _never_fails("%s bmad orient --scope %s" % (launcher, scope)))
     _add_hook_everywhere(scope, _ROUTE_HOOK,
                          _never_fails("%s bmad route" % launcher))
-    _set_scope_state(scope, autopilot=True, startup=True, personas=len(slugs),
+    _set_scope_state(scope, autopilot=True, startup=True, personas=present,
                      enabled_at=util.now_iso())
-    journal.log("bmad-autopilot", "on", scope=scope, personas=len(slugs))
+    journal.log("bmad-autopilot", "on", scope=scope, personas=present)
 
     out.ok("BMAD autopilot ON (%s) — %d persona subagent(s) + prompt router"
-           % (scope, len(slugs)))
+           % (scope, present))
     if skipped:
         out.warn("kept your edits to %d persona(s): %s"
                  % (len(skipped), ", ".join(skipped)))
@@ -274,12 +294,12 @@ def _autopilot_on(scope) -> int:
 
 def _autopilot_off(scope) -> int:
     scope = scope or "global"
-    _remove_hook_everywhere(scope, _ORIENT_HOOK, _ROUTE_HOOK)
+    hooks_removed = _remove_hook_everywhere(scope, _ORIENT_HOOK, _ROUTE_HOOK)
     removed = core.remove_personas(_agents_dir(scope))
     _set_scope_state(scope, autopilot=False, startup=False, personas=0)
     journal.log("bmad-autopilot", "off", scope=scope, personas=len(removed))
-    out.ok("BMAD autopilot OFF (%s) — removed %d persona(s) and both hooks"
-           % (scope, len(removed)))
+    out.ok("BMAD autopilot OFF (%s) — removed %d persona(s) and %d hook(s)"
+           % (scope, len(removed), hooks_removed))
     out.dim("  hand-edited personas were left in place")
     return 0
 
@@ -335,19 +355,26 @@ def _route(prompt, plain) -> int:
     return 0
 
 
+_PERSONA_STATE_LABEL = {
+    "managed": "installed",
+    "edited": "installed (edited)",
+    "absent": "not installed",
+}
+
+
 def _personas(scope) -> int:
     scope = scope or "global"
     agents = _agents_dir(scope)
-    live = set(core.installed_personas(agents))
+    states = core.persona_states(agents)
     out.heading("BMAD personas — %s" % scope)
     for p in core.PERSONAS:
-        mark = "installed" if p.slug in live else "not installed"
+        mark = _PERSONA_STATE_LABEL[states[p.slug]]
         # 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:
+    if all(state == "absent" for state in states.values()):
         out.dim("  install them with `boost bmad on`")
     return 0
 
@@ -456,8 +483,8 @@ def _copy_global_skills(modules) -> int:
 def _startup(value, scope) -> int:
     scope = scope or "project"
     if value == "on":
-        cmd = "%s bmad orient --scope %s" % (
-            shlex.quote(str(paths.launcher())), scope)
+        cmd = _never_fails("%s bmad orient --scope %s" % (
+            shlex.quote(str(paths.launcher())), scope))
         started = _add_hook_everywhere(scope, _ORIENT_HOOK, cmd)
         _set_scope_state(scope, startup=True)
         journal.log("bmad-startup", "on", scope=scope)
@@ -471,7 +498,10 @@ def _startup(value, scope) -> int:
         journal.log("bmad-startup", "off", scope=scope)
         out.ok("BMAD startup OFF (%s) — skills stay installed" % scope)
         return 0
-    return _status(scope)
+    if value == "status":
+        return _status(scope)
+    raise BoostError("unknown startup value %r" % value,
+                     hint="use 'on', 'off' or 'status'")
 
 
 def _orient(scope) -> int:
@@ -570,15 +600,16 @@ def _doctor() -> int:
     for scope in ("global", "project"):
         st = _get_scope_state(scope)
         agents = _agents_dir(scope)
-        personas = len(core.installed_personas(agents))
+        # managed + edited: an edited persona file is still on disk and
+        # Claude Code still loads it, same as core.present_personas().
+        personas = len(core.present_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"))
+               % (_on_off(live), personas, _on_off(router),
+                  _on_off(cs.has_hook(scope, "SessionStart", HOOK_NAME))))
         out.kv("  workflows", "skills=%d  installed=%s"
-               % (_count_skills(_skills_dir(scope)), bool(st.get("installed"))))
+               % (_count_skills(_skills_dir(scope)), _on_off(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`")

{boost_skill_cli-1.2.95 → boost_skill_cli-1.2.96}/boost_cli/commands/configuration.py

@@ -77,12 +77,16 @@ def cmd_config(argv) -> int:
     p.add_argument("--json", action="store_true",
                    help="machine-readable output")
     args = p.parse_args(argv)
+    if args.action == "list" and (args.key or args.value is not None):
+        p.error("config list takes no KEY/VALUE")
     if args.action in ("get", "set", "unset") and not args.key:
         raise BoostError("config %s requires a KEY" % args.action,
                         hint="e.g. `boost config %s ai.enabled`" % args.action)
     if args.action == "set" and args.value is None:
         raise BoostError("config set requires a VALUE",
                         hint="e.g. `boost config set ai.enabled false`")
+    if args.action in ("get", "unset") and args.value is not None:
+        p.error("config %s takes no VALUE" % args.action)
 
     if args.action == "list":
         cfg = config.load()
@@ -476,6 +480,9 @@ def cmd_policy(argv) -> int:
                    help="machine-readable output")
     args = p.parse_args(argv)
 
+    if args.action in ("list", "check") and (args.key or args.value is not None):
+        p.error("policy %s takes no KEY/VALUE" % args.action)
+
     if args.action in ("set", "unset"):
         if not args.key:
             raise BoostError("policy %s requires a KEY" % args.action,
@@ -483,6 +490,8 @@ def cmd_policy(argv) -> int:
         if args.key not in policy.DEFAULTS:
             raise BoostError("unknown policy key %r" % args.key,
                             hint="keys: " + ", ".join(sorted(policy.DEFAULTS)))
+        if args.action == "unset" and args.value is not None:
+            p.error("policy unset takes no VALUE")
 
     if args.action == "list":
         pol = policy.load()
@@ -939,11 +948,13 @@ def cmd_schedule(argv) -> int:
     p.add_argument("action", nargs="?", default="status",
                    choices=("status", "enable", "disable"),
                    help="what to do (default: status)")
-    p.add_argument("--interval", choices=tuple(_INTERVALS), default="6h",
-                   help="how often to run `boost update` (default: 6h)")
+    p.add_argument("--interval", choices=tuple(_INTERVALS), default=None,
+                   help="how often to run `boost update` (default: 6h; enable only)")
     p.add_argument("--json", action="store_true",
                    help="machine-readable output (status only)")
     args = p.parse_args(argv)
+    if args.interval is not None and args.action != "enable":
+        p.error("--interval only applies to `schedule enable`")
 
     darwin = sys.platform == "darwin"
     shim = paths.launcher()
@@ -992,6 +1003,7 @@ def cmd_schedule(argv) -> int:
         return 0
 
     if args.action == "enable":
+        args.interval = args.interval or "6h"
         seconds = _INTERVALS[args.interval]
         paths.ensure_dirs()
         if darwin:

{boost_skill_cli-1.2.95 → boost_skill_cli-1.2.96}/boost_cli/commands/discovery.py

@@ -132,23 +132,31 @@ def cmd_search(argv):
                           "building the search index (first run)"):
             use_rag = rag.ensure()
     engine = ""
+    hit_cap = False
+    k = 0
     if use_rag:
         # retrieve_any, not retrieve: this picks the dense backend when one is
         # built and floors to BM25 otherwise, so the CLI and the MCP server
         # answer from the same engine instead of the CLI being BM25-only.
+        k = max(60, args.limit * 4)
         hits, engine = rag.retrieve_any(
-            query, k=max(60, args.limit * 4),
-            collapse_near_duplicates=args.collapse_dupes)
-        scored = [(h["entry"], h["score"]) for h in (hits or [])]
+            query, k=k, collapse_near_duplicates=args.collapse_dupes)
+        hits = hits or []
+        # Retrieval never returns more than `k` — hitting that cap means
+        # there may be more matches beyond it, not that there are exactly
+        # `k`. Recorded before the category filter narrows the count further,
+        # because the cap was already in effect at retrieval time either way.
+        hit_cap = len(hits) >= k
+        scored = [(h["entry"], h["score"]) for h in hits]
     else:
         scored = catalog.search(query)
     if args.category:
         scored = [(e, s) for e, s in scored
                  if catalog.matches_category(e, args.category)]
-    if args.as_json:
-        print(json.dumps([e | {"score": s} for e, s in scored[:args.limit]]))
-        return 0
     if not scored:
+        if args.as_json:
+            print(json.dumps([]))
+            return 0
         # The standardized ○/→ empty state, so "nothing here" reads the same
         # as every other command's; both wordings are pinned by tests.
         print(out.empty_state(
@@ -170,7 +178,13 @@ def cmd_search(argv):
             if reranked:
                 scored, ranker = reranked, "Claude Haiku relevance"
         else:
+            # On stderr and unconditional on --json: a script reading stdout
+            # as JSON must still learn --smart silently did nothing.
             out.warn(ai.fallback_note(), wrap=True, stream=sys.stderr)
+    if args.as_json:
+        print(json.dumps([e | {"score": s, "ranker": ranker}
+                          for e, s in scored[:args.limit]]))
+        return 0
     shown = scored[:args.limit]
     # The dot marks "a skill by this name is installed" — a name match, with
     # the known homonym caveat (13 real skills share `code-reviewer`). A lock
@@ -192,8 +206,16 @@ def cmd_search(argv):
             str(e.get("kind") or "skill"), str(e.get("tap") or ""), sc / top,
             curated=bool(e.get("curated")),
             installed=e["name"] in installed, lay=lay))
-    out.info(out.role("%d match%s · ranked by %s"
-                   % (len(scored), "" if len(scored) == 1 else "es", ranker), "muted"))
+    if hit_cap:
+        # `len(scored)` here is the retrieval cap, not a true count — retrieval
+        # stopped at `k` and there may be more matches past it. Say what is
+        # actually known (the cap), not a number that reads as exact but is an
+        # artifact of `k = max(60, limit * 4)`.
+        footer = "top %d of %d+ retrieved · ranked by %s" % (len(shown), k, ranker)
+    else:
+        footer = ("%d match%s · ranked by %s"
+                  % (len(scored), "" if len(scored) == 1 else "es", ranker))
+    out.info(out.role(footer, "muted"))
     if use_rag:
         _note_stem_expansions(query)
     _hint_semantic_search(engine)

{boost_skill_cli-1.2.95 → boost_skill_cli-1.2.96}/boost_cli/commands/hooks.py

@@ -38,7 +38,8 @@ def cmd_hooks(argv) -> int:
     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)")
+                   help="hook event, e.g. SessionStart "
+                        "(required for add; filters remove/list)")
     p.add_argument("--host", metavar="H", default=None,
                    choices=(*hookhost.hosts(), "auto"),
                    help="agent CLI whose settings.json to manage: %s "
@@ -55,16 +56,22 @@ def cmd_hooks(argv) -> int:
     args = p.parse_args(argv)
 
     if args.action == "list":
-        return _list(args.scope, args.host)
+        return _list(args.scope, args.host, args.event)
     if args.action == "add":
         return _add(args)
     return _remove(args)
 
 
-def _list(scope, host) -> int:
+def _list(scope, host, event=None) -> int:
     rows = cs.list_all_hooks(scope, host=host)
+    if event:
+        # Each row is already tagged with its own host, so filter against
+        # that host's native spelling rather than the one the caller typed —
+        # `hooks list` (no --host) mixes Claude and Gemini rows in one table.
+        rows = [r for r in rows if r["event"] == hookhost.translate(r["host"], event)]
     if not rows:
-        out.info("no boost-managed hooks" + (" in %s scope" % scope if scope else ""))
+        out.info("no boost-managed hooks" + (" in %s scope" % scope if scope else "")
+                 + (" for event '%s'" % event if event else ""))
         return 0
     out.table(
         [(r["host"], r["scope"], r["event"], r["name"], r["matcher"] or "-",

{boost_skill_cli-1.2.95 → boost_skill_cli-1.2.96}/boost_cli/commands/info.py

@@ -849,6 +849,8 @@ def cmd_log(argv):
     ap.add_argument("--crashes", action="store_true",
                     help="list recent crash reports")
     args = ap.parse_args(argv)
+    if args.name and (args.crashes or args.diagnostics):
+        ap.error("NAME is not used with --diagnostics/--crashes")
     if args.crashes:
         return _show_crashes(args.limit)
     if args.diagnostics:

{boost_skill_cli-1.2.95 → boost_skill_cli-1.2.96}/boost_cli/commands/intelligence.py

@@ -812,16 +812,23 @@ def _evolve_ai(old: str, old_ver: str, feedback: str) -> str | None:
 
 
 def _evolve_append(old: str, old_ver: str, feedback: str) -> str:
-    """Heuristic revision: feedback appended as a dated rules section."""
-    meta, body = frontmatter.parse(old)
-    meta["version"] = _bump_patch(old_ver)
+    """Heuristic revision: feedback appended as a dated rules section.
+
+    Splices the bumped ``version`` into the original frontmatter text
+    (`frontmatter.set_field`) rather than parsing to a dict and dumping it
+    back — a parse -> dump round trip rewrites every field through dump's
+    own quoting rules, turning a diff that only bumped the version into one
+    that also silently reformats every other line the feedback never
+    touched.
+    """
+    revised = frontmatter.set_field(old, "version", _bump_patch(old_ver))
+    block, body = frontmatter.split(revised)
     bullets = [s.strip().rstrip(".")
                for s in re.split(r"(?<=[.!?])\s+|\n+|;\s*", feedback)
                if s.strip()]
     section = ("## Feedback (%s)\n\n" % util.now_iso()[:10]
                + "\n".join("- %s." % b for b in bullets))
-    return (frontmatter.dump(meta) + "\n\n" + body.strip()
-            + "\n\n" + section + "\n")
+    return "---\n%s\n---\n\n%s\n\n%s\n" % (block, body.strip(), section)
 
 
 def _print_diff(old: str, new: str) -> None:

{boost_skill_cli-1.2.95 → boost_skill_cli-1.2.96}/boost_cli/commands/pkg.py

@@ -1423,9 +1423,10 @@ def cmd_import(argv: list[str]) -> int:
         prog="boost import",
         description="Import skills from a GitHub URL or local path")
     ap.add_argument("source", metavar="URL_OR_PATH")
-    ap.add_argument("--name", metavar="N",
-                    help="skill to pick when several are found (or a rename)")
-    ap.add_argument("--all", action="store_true", help="import every skill found")
+    group = ap.add_mutually_exclusive_group()
+    group.add_argument("--name", metavar="N",
+                       help="skill to pick when several are found (or a rename)")
+    group.add_argument("--all", action="store_true", help="import every skill found")
     ap.add_argument("--agent", action="append", metavar="A",
                     help="link only into this agent (repeatable)")
     args = ap.parse_args(argv)
@@ -1575,6 +1576,8 @@ def cmd_snapshot(argv: list[str]) -> int:
     ap.add_argument("-y", "--yes", action="store_true",
                     help="skip the restore confirmation prompt")
     args = ap.parse_args(argv)
+    if args.action == "list" and args.arg:
+        ap.error("snapshot list takes no LABEL|ID")
     if args.action == "save":
         return _snapshot_save(args.arg)
     if args.action == "list":

{boost_skill_cli-1.2.95 → boost_skill_cli-1.2.96}/boost_cli/commands/quality.py

@@ -1397,6 +1397,13 @@ def cmd_trust(argv) -> int:
     p.add_argument("--json", action="store_true", help="machine-readable output")
     args = p.parse_args(argv)
 
+    if args.action == "list" and (args.name or args.key):
+        p.error("trust list takes no NAME/KEY")
+    if args.action == "remove" and args.key:
+        p.error("trust remove takes no KEY")
+    if args.action == "verify" and args.key:
+        p.error("trust verify takes no KEY")
+
     if args.action == "add":
         if not args.name or not args.key:
             raise BoostError("trust add requires NAME and KEY",

{boost_skill_cli-1.2.95 → boost_skill_cli-1.2.96}/boost_cli/commands/safety.py

@@ -431,7 +431,9 @@ def cmd_verify(argv):
         commit_pin = integrity.commit_status(name, entry)
         results.append({"name": name, "kind": kind, "status": status,
                         "scope": "user", "missing_fields": missing_fields,
-                        "commit_pin": commit_pin})
+                        "commit_pin": commit_pin,
+                        "passed": integrity.verification_passed(
+                            status, missing_fields, commit_pin)})
 
     # Vendored, project-scoped skills live in the repo's own lock, not the user's
     # — and they are exactly the ones worth verifying, since they arrive by PR
@@ -446,11 +448,11 @@ def cmd_verify(argv):
             missing_fields.append("sha256")
         results.append({"name": name, "kind": "skill", "status": status,
                         "scope": "project", "missing_fields": missing_fields,
-                        "commit_pin": None})
+                        "commit_pin": None,
+                        "passed": integrity.verification_passed(
+                            status, missing_fields, None)})
 
-    bad = [r for r in results
-           if r["status"] not in ("ok", "quarantined") or r["missing_fields"]
-           or r["commit_pin"] == integrity.STATUS_MODIFIED]
+    bad = [r for r in results if not r["passed"]]
     if args.json:
         print(json.dumps({"skills": results, "failed": len(bad)}))
         return 1 if bad else 0
@@ -460,8 +462,6 @@ def cmd_verify(argv):
                               hint="boost install <skill> to start"))
         return 0
     width = max(len(r["name"]) for r in results)
-    status_role = {"ok": "success", "modified": "warn", "missing": "danger",
-                   "unlocked": "warn", "quarantined": "muted"}
     for r in results:
         bits = []
         if r.get("kind") not in (None, "skill"):
@@ -476,7 +476,9 @@ def cmd_verify(argv):
             bits.append("commit pin DRIFTED")
         note = ("  " + " · ".join(bits)) if bits else ""
         print("  %s  %s%s" % (r["name"].ljust(width),
-                              out.role(r["status"], status_role.get(r["status"], "warn")),
+                              out.role(r["status"],
+                                       integrity.verification_role(
+                                           r["status"], r["passed"])),
                               out.role(note, "muted")))
     if bad:
         out.warn("%d of %d item%s failed verification"

{boost_skill_cli-1.2.95 → boost_skill_cli-1.2.96}/boost_cli/commands/taps.py

@@ -226,7 +226,13 @@ def cmd_untap(argv) -> int:
 
 
 def _tap_updated(tap: registry.Tap) -> str:
-    """Last-commit date of a tap clone, else the cache's generated age."""
+    """Last-commit date of a tap clone, else the cache's generated date.
+
+    Both branches return the same `YYYY-MM-DD` shape (`util.iso_date`
+    mirrors git's `--date=short`) — the two-format mix this used to produce
+    (git dates for cloned taps, "3h ago" for cache-only ones) is exactly the
+    UPDATED-column inconsistency this function exists to not reintroduce.
+    """
     if tap.is_cloned:
         with suppress(BoostError):
             # --date=short --format=%cd == %cs, but works on git < 2.21 too
@@ -236,7 +242,7 @@ def _tap_updated(tap: registry.Tap) -> str:
                 return proc.stdout.strip()
     try:
         data = json.loads(tap.cache_file.read_text(encoding="utf-8"))
-        return util.rel_time(data.get("generated", ""))
+        return util.iso_date(data.get("generated", ""))
     except (OSError, ValueError):
         return "?"
 
@@ -284,6 +290,8 @@ def cmd_taps(argv) -> int:
               keep=("NAME",))
     print()
     out.dim("%d taps · %d items" % (len(taps), total))
+    if any(t["pin"] for t in taps):
+        out.dim("@sha = pinned; `boost update` skips it")
     return 0
 
 

{boost_skill_cli-1.2.95 → boost_skill_cli-1.2.96}/boost_cli/commands/team.py

@@ -702,24 +702,37 @@ def cmd_replay(argv) -> int:
     if mat_diff:
         out.warn("not rolled back (rollback restores skills only): %s — "
                  "reinstall or uninstall these by hand" % ", ".join(mat_diff))
-    if not (added or removed or changed):
+
+    # A "removed" skill no tap can resolve will never come back through
+    # _resolve_entry, so counting it as pending work promised a restore that
+    # could never land — and because nothing about that ever changes, every
+    # later run repeated the same warning and still claimed "complete". Split
+    # it out up front: it never gates the confirm prompt below, only whether
+    # there is anything else left to do.
+    resolved = {n: _resolve_entry(n, prefer_tap=snap_skills[n].get("tap"))
+               for n in removed}
+    restorable = [n for n in removed if resolved[n] is not None]
+    gone = [n for n in removed if resolved[n] is None]
+
+    if not (added or restorable or changed):
+        for n in gone:
+            out.warn("%s is gone from every tap — cannot restore" % n)
         out.ok("skills already match this snapshot — nothing to do"
                if mat_diff else "already at this snapshot — nothing to do")
         return 0
     out.info("rollback to %s will: uninstall %d, install %d, revisit %d version change(s)"
-             % (args.id, len(added), len(removed), len(changed)))
+             % (args.id, len(added), len(restorable), len(changed)))
     if not out.confirm("proceed?"):
         out.info("cancelled")
         return 1
     for n in added:  # in current, not in snapshot
         store.uninstall(n)
         out.ok("uninstalled %s" % n)
-    for n in removed:  # in snapshot, missing now
+    for n in gone:
+        out.warn("%s is gone from every tap — cannot restore" % n)
+    for n in restorable:  # in snapshot, missing now, resolvable
         want = snap_skills[n]
-        entry = _resolve_entry(n, prefer_tap=want.get("tap"))
-        if entry is None:
-            out.warn("%s is gone from every tap — cannot restore" % n)
-            continue
+        entry = resolved[n]
         res = store.install(entry, force=True)
         if str(entry.get("version")) != str(want.get("version")):
             out.warn("restored %s v%s from current tap state (snapshot had v%s)"
@@ -731,6 +744,10 @@ def cmd_replay(argv) -> int:
                  "their current state; `boost pin` prevents future drift"
                  % (n, snap_skills[n].get("version"), current[n].get("version")))
     journal.log("replay", args.id, op="rollback")
+    if gone:
+        out.warn("finished with %d skill%s not restored: %s"
+                 % (len(gone), _s(len(gone)), ", ".join(gone)))
+        return 1
     out.ok("rollback to %s complete" % args.id)
     return 0
 

{boost_skill_cli-1.2.95 → boost_skill_cli-1.2.96}/boost_cli/core/adapters.py

@@ -563,13 +563,30 @@ def render_runner(name: str, description: str, body: str,
     installed.
     """
     brain = render_agents_sdk(name, description, body, model)
+    tgt = _clean(target or "")
+    # render_agents_sdk's own banner names `boost adapt NAME --to agents-sdk`,
+    # which cannot regenerate this file — it produces a short Agent module,
+    # not the runner (with its tool defs and Runner.run_sync call) built
+    # below. Restamp the inherited first line with the command that actually
+    # regenerates what this function returns.
+    #
+    # A literal newline in `name`/`tgt` would otherwise end the `#` comment
+    # mid-banner and hand the rest of the line to the parser as code — the
+    # same class of bug this function exists to avoid elsewhere (`_py_str`
+    # for the prompt below). A comment tolerates backticks/quotes/`%`
+    # unescaped; only line breaks need neutralizing here.
+    safe_name = name.replace("\n", " ").replace("\r", " ")
+    safe_tgt = tgt.replace("\n", " ").replace("\r", " ")
+    banner = ("# Generated by `boost run %s%s --print`. Do not edit by hand.\n"
+              % (safe_name, " " + safe_tgt if safe_tgt else ""))
+    _, _, rest = brain.partition("\n")
+    brain = banner + rest
     # Capture the adapted agent under a reserved name *before* the tool defs — a
     # skill literally named `grep`/`read-file`/`list-dir` normalizes (_ident) to
     # a tool identifier, and the emitted `def grep(...)` would otherwise rebind
     # (clobber) the brain. `_boost_*` names never collide: _ident strips the
     # leading underscore, so no skill name maps onto them.
     capture = "\n_boost_brain = %s\n" % _ident(name)
-    tgt = _clean(target or "")
     where = "`" + tgt + "`" if tgt else "the current directory (`.`)"
     prompt = ("Apply your instructions to %s. Use the read_file, list_dir, and "
               "grep tools to inspect it, then produce your output." % where)

{boost_skill_cli-1.2.95 → boost_skill_cli-1.2.96}/boost_cli/core/bmad.py

@@ -691,12 +691,49 @@ def write_personas(agents_dir: Path) -> tuple[list[str], list[str]]:
 
 
 def installed_personas(agents_dir: Path) -> list[str]:
-    """The personas on disk that boost still owns (stamp digest still matches)."""
+    """The personas on disk that boost still owns (stamp digest still matches).
+
+    This is the *deletion* set — :func:`remove_personas` must only ever touch
+    files boost still owns. It is the wrong set for a user-facing count: an
+    edited persona file is still on disk and Claude Code still loads it, so
+    counting only the managed ones understates what is actually installed.
+    Use :func:`present_personas` for that.
+    """
     agents_dir = Path(agents_dir)
     return sorted(p.slug for p in PERSONAS
                   if is_managed(_read(agents_dir / ("%s.md" % p.slug))))
 
 
+def persona_state(agents_dir: Path, persona: Persona) -> str:
+    """One of ``"managed"``, ``"edited"`` or ``"absent"`` for one persona file.
+
+    The three states used to collapse to a boolean — "does boost still own
+    this file" — which is right for deciding what `bmad off` may delete and
+    wrong for reporting what is installed: an edited file is not boost's to
+    delete, but it is still on disk and Claude Code loads it same as any
+    other subagent definition.
+    """
+    path = Path(agents_dir) / ("%s.md" % persona.slug)
+    text = _read(path)
+    if not text and not path.is_file():
+        return "absent"
+    return "managed" if is_managed(text) else "edited"
+
+
+def persona_states(agents_dir: Path) -> dict[str, str]:
+    """``{slug: state}`` for every known persona, per :func:`persona_state`."""
+    agents_dir = Path(agents_dir)
+    return {p.slug: persona_state(agents_dir, p) for p in PERSONAS}
+
+
+def present_personas(agents_dir: Path) -> list[str]:
+    """Slugs whose file exists — managed *or* edited — both are real, working
+    subagents from Claude Code's point of view; only "absent" is not installed.
+    """
+    return sorted(slug for slug, state in persona_states(agents_dir).items()
+                  if state != "absent")
+
+
 def remove_personas(agents_dir: Path) -> list[str]:
     """Delete only the persona files boost wrote; return the slugs removed.