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

{boost_skill_cli-1.2.95 → boost_skill_cli-1.2.97}/.vale/styles/config/vocabularies/boost/accept.txt

@@ -37,6 +37,8 @@ CRM
 cron
 crontab
 cyclomatic
+dedupe
+deduped
 Dependabot
 deps
 deserialization

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.95
+Version: 1.2.97
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0
@@ -421,6 +421,13 @@ at least 95% alike, fold into one badged `×5`, with `^D` to show them again.
 Identity is the description and never the name: `code-reviewer` appears 75 times
 with 42 different descriptions, and those are 42 real skills.
 
+Without a real TTY (a pipe, an IDE run console, a terminal curses can't drive)
+`browse` falls back to a plain, deduped table — name, version, tap, kind — with
+a footer breaking the total down by kind and pointing at `boost search` to
+narrow it. The same fallback covers a curses initialization failure, so a
+terminal that merely *claims* `isatty()` degrades gracefully instead of
+crashing mid-draw.
+
 ## 81 commands, organized into 8 groups
 
 `boost --help` prints the full grouped list. For every flag of every command see

{boost_skill_cli-1.2.95 → boost_skill_cli-1.2.97}/README.md

@@ -379,6 +379,13 @@ at least 95% alike, fold into one badged `×5`, with `^D` to show them again.
 Identity is the description and never the name: `code-reviewer` appears 75 times
 with 42 different descriptions, and those are 42 real skills.
 
+Without a real TTY (a pipe, an IDE run console, a terminal curses can't drive)
+`browse` falls back to a plain, deduped table — name, version, tap, kind — with
+a footer breaking the total down by kind and pointing at `boost search` to
+narrow it. The same fallback covers a curses initialization failure, so a
+terminal that merely *claims* `isatty()` degrades gracefully instead of
+crashing mid-draw.
+
 ## 81 commands, organized into 8 groups
 
 `boost --help` prints the full grouped list. For every flag of every command see

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

{boost_skill_cli-1.2.95 → boost_skill_cli-1.2.97}/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.97}/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()
@@ -397,7 +401,7 @@ def cmd_create(argv) -> int:
                    help="install the new skill immediately")
     args = p.parse_args(argv)
 
-    name = util.slugify(args.name)
+    name = util.resolve_slug(args.name)
     parent = paths.expand(args.dir) if args.dir else Path.cwd()
     target = parent / name
     skill_md = target / "SKILL.md"
@@ -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()
@@ -814,6 +823,17 @@ def cmd_completions(argv) -> int:
 
     detected = args.shell or Path(os.environ.get("SHELL", "")).name
 
+    # Fixed once, here, rather than in each branch below: an empty $SHELL
+    # used to fall through silently to the bash script (print path) or to
+    # `_rc_path("")`'s confusing "no one-shot install for  yet" (install
+    # path) — neither ever told the user *why*. Raising here means every
+    # path downstream — print, --install, --uninstall, --dry-run — sees the
+    # same clear error instead of reinventing it.
+    if not detected:
+        raise BoostError(
+            "cannot detect your shell ($SHELL unset)",
+            hint="pass bash, zsh or fish, e.g. `boost completions bash`")
+
     if args.dry_run and not (args.install or args.uninstall):
         p.error("--dry-run qualifies --install or --uninstall; "
                 "pass one of them")
@@ -842,6 +862,15 @@ def cmd_completions(argv) -> int:
         return 0
 
     shell = detected if detected in ("bash", "zsh", "fish") else "bash"
+    if shell != detected:
+        # A real shell boost has no script for (e.g. nu, xonsh) — silently
+        # substituting bash used to look like success while handing the user
+        # a script their shell cannot source. stderr, not stdout: stdout here
+        # is the completion script itself (piped to a file or `eval`'d), and
+        # a warning line mixed into it would corrupt both uses.
+        out.warn("%s is not a supported shell (bash, zsh, fish) — showing "
+                 "bash's completion script instead" % detected,
+                 stream=sys.stderr)
     # The script is a thin shim that calls `boost __complete`; the candidate
     # rules live in core/complete.py so all three shells share one tested
     # implementation instead of three hand-maintained static lists.
@@ -939,11 +968,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 +1023,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.97}/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)
@@ -972,11 +994,23 @@ def cmd_recommend(argv):
 
 def _browse_plain(entries, why: str):
     out.warn(why + " — showing the full catalog")
-    out.table([(e["name"], "v" + e["version"], e["tap"],
-                "★" if e.get("curated") else "") for e in entries],
-              headers=("name", "version", "tap", ""))
-    out.info(out.role("%d skills · install with `boost install <name>`"
-                   % len(entries), "muted"))
+    # Same collapse the TUI does: a registry renders one skill into
+    # .claude/, .cursor/, .gemini/ and a plugin root, and this fallback used
+    # to list every copy with nothing to tell them apart.
+    unique = [e for e, _n in browse.dedupe(entries)]
+    show_curated = any(e.get("curated") for e in unique)
+    headers = ["name", "version", "tap", "kind"]
+    rows = [[e["name"], "v" + e["version"], e["tap"],
+             out.kind_label(e.get("kind", "skill"))]
+            for e in unique]
+    if show_curated:
+        headers.append("")
+        for row, e in zip(rows, unique, strict=True):
+            row.append("★" if e.get("curated") else "")
+    out.table([tuple(row) for row in rows], headers=tuple(headers))
+    out.info(out.role(
+        "%s · install with `boost install <name>` · narrow with `boost search <query>`"
+        % browse.plain_footer(unique), "muted"))
     return 0
 
 
@@ -1725,7 +1759,17 @@ def cmd_browse(argv):
         import curses
     except ImportError:
         return _browse_plain(entries, "curses is unavailable on this Python")
-    picked = _browse_tui(curses, entries)
+    try:
+        picked = _browse_tui(curses, entries)
+    except curses.error as e:
+        # An fd that claims isatty() but isn't a real pty (IDE run consoles,
+        # `script`, TERM=dumb) can fail deep inside curses.wrapper's own
+        # setup/teardown rather than at the isatty() check above. wrapper
+        # already ran its finally block (endwin() included), so the screen is
+        # restored by the time this is caught — printing here lands on a
+        # normal terminal, not a hosed one.
+        return _browse_plain(entries,
+                             "the terminal does not support curses (%s)" % e)
     if not picked:
         return 0
     # The browser installs in place now, so anything it hands back is usually

{boost_skill_cli-1.2.95 → boost_skill_cli-1.2.97}/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.97}/boost_cli/commands/info.py

@@ -703,8 +703,18 @@ def cmd_preview(argv):
     args = ap.parse_args(argv)
     text, _kind, lock, cat = _resolve_text(args.name)
     meta, body = frontmatter.parse(text)
+    if not sys.stdout.isatty():
+        # A piped/redirected preview renders nothing — no ANSI, so the
+        # per-chunk `_inline()` substitution would strip `**`/backtick
+        # markers with no styled substitute, and lines with no special-cased
+        # handling (a bare `---`, a wrapped `> quote` continuation) print
+        # mangled rather than as either faithful Markdown or a real render.
+        # `boost cat` already resolves this the same way: raw text through.
+        sys.stdout.write(body if body.endswith("\n") else body + "\n")
+        return 0
+    version = meta.get("version") or (lock or cat or {}).get("version") or "?"
     print(out.titlebar("%s · v%s · %s" % (meta.get("name") or args.name,
-                                          meta.get("version") or "?",
+                                          version,
                                           (lock or cat or {}).get("tap", "local"))))
     print()
     _render_markdown(body)
@@ -849,6 +859,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.97}/boost_cli/commands/intelligence.py

@@ -14,6 +14,7 @@ import difflib
 import fnmatch
 import json
 import re
+import shlex
 import sys
 import tempfile
 import textwrap
@@ -213,7 +214,8 @@ def cmd_distill(argv: list[str]) -> int:
         meta, body = frontmatter.parse(text)
         sources.append({"name": name, "origin": origin, "text": text,
                         "meta": meta, "body": body})
-    new = args.output or (names[0] + "-distilled")
+    new = util.resolve_slug(args.output, what="output name") if args.output \
+        else names[0] + "-distilled"
 
     out.heading("distilling %s → %s" % (", ".join(names), new))
     merged = _distill_ai(new, sources) if ai.available() else None
@@ -227,7 +229,9 @@ def cmd_distill(argv: list[str]) -> int:
         dest = Path.cwd() / new / "SKILL.md"
         if not _write_generated(dest, merged, yes=args.yes):
             return 1
-        out.info(out.role("install it with `boost import ./%s`" % new, "muted"))
+        out.info(out.role(
+            "install it with `boost import %s`" % shlex.quote("./" + new),
+            "muted"))
     journal.log("distill", new, sources=names)
     return 0
 
@@ -812,16 +816,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.97}/boost_cli/commands/pkg.py

@@ -21,6 +21,7 @@ from .. import cliparse, spin
 from ..core import (
     adapters,
     agents,
+    archive,
     catalog,
     complete,
     config,
@@ -1423,9 +1424,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 +1577,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":
@@ -1766,11 +1770,17 @@ def cmd_export(argv: list[str]) -> int:
                                  "agent config files; reinstall them "
                                  "from their tap")
         if not store.skill_store_dir(name).is_dir():
-            raise BoostError("store dir for %s is missing" % name,
-                            hint="repair with `boost sync`")
+            raise BoostError(
+                "store dir for %s is missing" % name,
+                hint=("repair with `boost reinstall %s`" % name)
+                     if entry.get("tap") == "local"
+                     else "repair with `boost sync`")
         chosen[name] = entry
     stamp = datetime.now(UTC).strftime("%Y%m%d")
-    ext = ".zip" if args.zip else ".tar.gz"
+    use_zip, format_warning = archive.resolve_export_format(args.out, args.zip)
+    if format_warning:
+        out.warn(format_warning)
+    ext = ".zip" if use_zip else ".tar.gz"
     dest = paths.expand(args.out) if args.out else Path(
         "boost-skills-%s%s" % (stamp, ext))
     if dest.exists() and not args.force:
@@ -1779,9 +1789,10 @@ def cmd_export(argv: list[str]) -> int:
                              "different -o path")
     manifest = _boostfile_text(chosen, via="boost export")
     try:
-        if args.zip:
+        if use_zip:
             with zipfile.ZipFile(str(dest), "w", zipfile.ZIP_DEFLATED) as zf:
-                zf.writestr("Boostfile", manifest)
+                zf.writestr(archive.boostfile_zipinfo(
+                    datetime.now(UTC).timetuple()[:6]), manifest)
                 for name in chosen:
                     sdir = store.skill_store_dir(name)
                     for f in sorted(p for p in sdir.rglob("*") if p.is_file()):
@@ -1793,9 +1804,10 @@ def cmd_export(argv: list[str]) -> int:
                 ti.size = len(data)
                 ti.mtime = int(datetime.now(UTC).timestamp())
                 ti.mode = 0o644
-                tf.addfile(ti, io.BytesIO(data))
+                tf.addfile(archive.normalize_tar_member(ti), io.BytesIO(data))
                 for name in chosen:
-                    tf.add(str(store.skill_store_dir(name)), arcname=name)
+                    tf.add(str(store.skill_store_dir(name)), arcname=name,
+                          filter=archive.normalize_tar_member)
     except OSError as e:
         raise BoostError("cannot write %s: %s" % (_tilde(dest), e.strerror or e),
                         hint="check the output path exists and is writable") from e