boost-skill-cli 1.2.91__tar.gz → 1.2.92__tar.gz

{boost_skill_cli-1.2.91/boost_skill_cli.egg-info → boost_skill_cli-1.2.92}/PKG-INFO

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

{boost_skill_cli-1.2.91 → boost_skill_cli-1.2.92}/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.91'
-__version_tuple__ = version_tuple = (1, 2, 91)
+__version__ = version = '1.2.92'
+__version_tuple__ = version_tuple = (1, 2, 92)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.91 → boost_skill_cli-1.2.92}/boost_cli/cli.py

@@ -70,7 +70,7 @@ COMMANDS = [
     ("recommend",   "find", "discovery", "Suggest skills based on your project's tech stack"),
     ("browse",      "find", "discovery", "Interactive full-screen TUI with fuzzy search"),
     ("index",       "find", "discovery", "Build the discovery registry via GitHub Code Search"),
-    ("trending",    "find", "discovery", "Show trending skills by install count"),
+    ("trending",    "find", "discovery", "Show trending items by install count"),
     ("stats",       "find", "discovery", "Install statistics & trend for a single skill"),
     ("count",       "find", "discovery", "Quick summary of installed / available / taps"),
     # Skill Information (10)
@@ -156,6 +156,10 @@ def print_version() -> None:
 # Aurora palette so each command group carries its own brand color.
 _GROUP_HUES = ("cyan", "violet", "pink", "green", "yellow")
 
+# The width to lay out against when there is no pane at all: wider than any
+# line boost composes, so every fit test passes and nothing is truncated.
+_UNPANED = 10 ** 6
+
 
 def print_help() -> None:
     """The command index, fitted to the pane.
@@ -165,8 +169,12 @@ def print_help() -> None:
     at every width and wrapped mid-word for anyone not running a wide
     terminal. Names are never clipped, because the help's whole job is to be
     an index you can copy a command out of; summaries are.
+
+    A pipe has no pane, so nothing is fitted to one: `boost --help | grep
+    install` must see the whole summary, not one clipped to an assumed 80
+    columns.
     """
-    cols = out.term_width()
+    cols = out.pane_width() or _UNPANED
 
     title_line = out.gradient(PRODUCT) + " — Homebrew for AI coding skills"
     stamp = "%s · v%s" % (TAGLINE, __version__)

{boost_skill_cli-1.2.91 → boost_skill_cli-1.2.92}/boost_cli/commands/bmad.py

@@ -503,7 +503,7 @@ def _uninstall(scope, yes) -> int:
             "Remove BMAD (%s)? deletes bmad-* skills%s" % (
                 scope, " + _bmad/, _bmad-output/" if scope == "project" else ""))):
         out.info("aborted")
-        return 0
+        return 1
     _remove_hook_everywhere(scope, _ORIENT_HOOK, _ROUTE_HOOK)
     removed = _rm_skills(_skills_dir(scope))
     removed += len(core.remove_personas(_agents_dir(scope)))

{boost_skill_cli-1.2.91 → boost_skill_cli-1.2.92}/boost_cli/commands/configuration.py

@@ -145,6 +145,8 @@ def cmd_clean(argv) -> int:
                    help="show what would be removed without touching anything")
     p.add_argument("--deep", action="store_true",
                    help="also remove snapshots older than 90 days")
+    p.add_argument("-y", "--yes", action="store_true",
+                   help="skip the --deep confirmation prompt")
     args = p.parse_args(argv)
 
     items: list[tuple[Path, str, int]] = []  # (path, kind, bytes)
@@ -188,19 +190,26 @@ def cmd_clean(argv) -> int:
             elif pth.name == ".DS_Store" and pth.is_file():
                 items.append((pth, ".DS_Store", pth.stat().st_size))
 
+    declined = False
     if args.deep and paths.snapshots_dir().is_dir():
         cutoff = time.time() - 90 * 86400
         old_snaps = [s for s in sorted(paths.snapshots_dir().iterdir())
                      if s.lstat().st_mtime < cutoff]
-        if old_snaps and not args.dry_run and not out.confirm(
-                "remove %d snapshot(s) older than 90 days?" % len(old_snaps)):
+        if old_snaps and not args.dry_run and not (args.yes or out.confirm(
+                "remove %d snapshot(s) older than 90 days?" % len(old_snaps))):
             out.info("keeping old snapshots")
+            declined = True
             old_snaps = []
         for s in old_snaps:
             size = util.dir_size(s) if s.is_dir() else s.lstat().st_size
             items.append((s, "old snapshot", size))
 
     if not items:
+        # `declined` means the only candidate was the --deep snapshot purge
+        # and the user said no — "nothing to clean" would claim there was
+        # nothing to do when there was, and the user just declined doing it.
+        if declined:
+            return 1
         out.ok("nothing to clean")
         return 0
 
@@ -303,6 +312,18 @@ def cmd_compact(argv) -> int:
             if args.reclone:
                 util.rmtree(tap.path)
                 gitutil.clone_shallow(tap.url, tap.path)
+                if tap.pin:
+                    # A pinned tap re-clones at the default branch like any
+                    # other — nothing about `--reclone` consults the pin — so
+                    # without this the clone silently lands on HEAD while
+                    # config.json, the catalog cache and `boost taps` keep
+                    # naming the old commit. checkout_commit's own BoostError
+                    # (unresolvable pin) surfaces through the except below.
+                    gitutil.checkout_commit(tap.path, tap.pin)
+                # The re-clone can change what's on disk even when the byte
+                # count doesn't (a pinned tap's tree is identical, but the
+                # cache's recorded commit and mtime are now stale either way).
+                catalog.rebuild_tap(tap)
             else:
                 gitutil.narrow(tap.path)
             for rel in keep.get(tap.name, []):
@@ -311,9 +332,12 @@ def cmd_compact(argv) -> int:
             out.warn("could not compact %s: %s" % (tap.name, e))
             continue
         after = util.dir_size(tap.path)
-        if after < before:
+        # A re-clone did real work — refreshed the clone, possibly moved it
+        # back onto its pin — even when it doesn't shrink the tap, so it must
+        # never be silently absorbed into "every tap is already compact".
+        if args.reclone or after < before:
             changed += 1
-            freed += before - after
+            freed += max(before - after, 0)
             out.info("%s  %s → %s" % (tap.name, util.human_size(before),
                                       util.human_size(after)))
 

{boost_skill_cli-1.2.91 → boost_skill_cli-1.2.92}/boost_cli/commands/discovery.py

@@ -1757,10 +1757,11 @@ def cmd_browse(argv):
 
 
 def cmd_trending(argv):
-    """Rank skills by local install events from the journal."""
+    """Rank items (skills, rules, workflows) by local install events from
+    the journal."""
     p = cliparse.parser(
         prog="boost trending",
-        description="Show trending skills by install count")
+        description="Show trending items by install count")
     p.add_argument("--limit", type=util.positive_int, default=10,
                    help="max rows (default 10)")
     args = p.parse_args(argv)
@@ -1772,10 +1773,12 @@ def cmd_trending(argv):
         if not curated:
             out.info("no curated skills available — add taps with `boost tap --defaults`")
             return 0
-        descw = max(out.term_width() - 24, 24)  # reserve name + version columns
-        out.table([(e["name"], "v" + e["version"],
+        # reserve name/version/kind columns
+        descw = max(out.term_width() - 34, 24)
+        out.table([(e["name"], "v" + e["version"], e.get("kind", "skill"),
                     out.truncate(e["description"], descw))
-                   for e in sorted(curated, key=operator.itemgetter("name"))[:args.limit]])
+                   for e in sorted(curated, key=operator.itemgetter("name"))[:args.limit]],
+                  headers=("name", "version", "kind", "description"))
         return 0
     agg: dict[str, Any] = {}
     for ev in evs:  # most-recent-first, so first ts per subject is the latest
@@ -1783,11 +1786,13 @@ def cmd_trending(argv):
         rec = agg.setdefault(name, {"count": 0, "last": ev.get("ts", "")})
         rec["count"] += 1
     ranked = sorted(agg.items(), key=lambda kv: (-kv[1]["count"], kv[0]))
-    descw = max(out.term_width() - 44, 24)  # reserve name/installs/last columns
+    # reserve name/installs/last/kind columns
+    descw = max(out.term_width() - 54, 24)
     out.table([(name, str(rec["count"]), util.rel_time(rec["last"]),
+                by_name.get(name, {}).get("kind", "skill"),
                 out.truncate(by_name.get(name, {}).get("description", ""), descw))
                for name, rec in ranked[:args.limit]],
-              headers=("name", "installs", "last", "description"))
+              headers=("name", "installs", "last", "kind", "description"))
     out.info(out.role("based on local install activity", "muted"))
     return 0
 
@@ -1801,14 +1806,19 @@ def cmd_stats(argv):
     p.add_argument("--json", action="store_true", dest="as_json",
                    help="machine-readable output")
     args = p.parse_args(argv)
-    name = args.name
-    # find_any: a rule's lock facts are the answer, not "no skill named X".
-    found = lockfile.find_any(name)
-    kind, lock = found if found is not None else ("skill", None)
-    matches = catalog.find(name)
+    # `args.name` may be tap-qualified (`owner/repo:skill`); resolve to the
+    # bare name the lock, journal and store dir key on, honoring the
+    # qualifier against the installed tap — `store.skill_store_dir` rejects
+    # the qualified string outright since ":" is not a safe path component.
+    # `find_any`-backed resolution: a rule's lock facts are the answer, not
+    # "no skill named X". `catalog.find` keeps the original string so a
+    # qualifier still narrows a not-yet-installed lookup.
+    name, kind, lock = store.resolve_lock_entry(args.name)
+    kind = kind or "skill"
+    matches = catalog.find(args.name)
     cat = matches[0] if matches else None
     if not lock and not cat:
-        raise BoostError("no skill named %r installed or in any tap" % name,
+        raise BoostError("no skill named %r installed or in any tap" % args.name,
                         hint="try `boost search %s`" % name)
     acts = {a: len(journal.events(action=a, subject=name))
             for a in ("install", "update", "uninstall")}

{boost_skill_cli-1.2.91 → boost_skill_cli-1.2.92}/boost_cli/commands/hooks.py

@@ -69,7 +69,10 @@ def _list(scope, host) -> int:
     out.table(
         [(r["host"], r["scope"], r["event"], r["name"], r["matcher"] or "-",
           r["command"]) for r in rows],
-        headers=("host", "scope", "event", "name", "matcher", "command"))
+        headers=("host", "scope", "event", "name", "matcher", "command"),
+        # A hook's command is what the user came to read — a clipped one
+        # cannot be compared against what they registered, or copied back.
+        keep=("command",))
     return 0
 
 

{boost_skill_cli-1.2.91 → boost_skill_cli-1.2.92}/boost_cli/commands/info.py

@@ -234,17 +234,26 @@ def _kind_table(heading, items, extra=None):
     ``(column, key)`` pair for a per-kind column (e.g. a workflow's slot); the
     count line reuses the heading's trailing noun (`installed rules` -> `rule`)."""
     out.heading(heading)
-    headers: tuple = ("NAME", "VERSION", "TAP", "AGENTS")  # `extra` adds a 5th
-    rows: list[tuple] = []   # 4 columns, or 5 when `extra` adds one
+    # FLAGS mirrors the skills table so a quarantined or pinned rule/workflow
+    # doesn't render byte-identical to a healthy one — `update`/`cat` treat
+    # them differently and a reader needs to see that here, not just in --json.
+    headers: tuple = ("NAME", "VERSION", "TAP", "AGENTS", "FLAGS")
+    rows: list[tuple] = []
     for name in sorted(items):
         e = items[name]
+        quarantined = bool(e.get("quarantined"))
+        agents_cell = "—" if quarantined else _materialized_agents(e)
+        flags = ([out.aurora("pinned", "yellow")] if e.get("pinned") else []) + \
+                ([out.aurora("quarantined", "pink")] if quarantined else [])
         row = [name, e.get("version", "?"), e.get("tap", "?"),
-               _materialized_agents(e)]
+               agents_cell]
         if extra:
             row.append(str(e.get(extra[1], "") or ""))
+        row.append(" ".join(flags))
         rows.append(tuple(row))
     if extra:
-        headers = (*headers, extra[0])
+        headers = (headers[0], headers[1], headers[2], headers[3], extra[0],
+                   headers[4])
     out.table(rows, headers=headers)
     noun = heading.split()[-1][:-1]  # "installed rules" -> "rule"
     print("  " + out.aurora("%d %s%s installed"
@@ -302,10 +311,14 @@ def cmd_list(argv):
     if not skills and not rules and not workflows and not project:
         # Name the kind that was asked for. "no skills installed" in answer to
         # `--kind rule` sends you looking for a skill that was never the point.
+        # The `boost tap --defaults` half of the hint is itself only useful
+        # when there is nothing tapped yet — with registries already
+        # configured, the fix is `search`+`install`, not tapping more of them.
         print(out.empty_state(
             "no %ss installed" % (args.kind or "skill")
             + (" with tag #%s" % args.tag.lstrip("#") if args.tag else ""),
-            hint="boost tap --defaults && boost search <topic>"))
+            hint=("boost search <topic>" if registry.list_taps()
+                 else "boost tap --defaults && boost search <topic>")))
         return 0
     if skills:
         out.heading("installed skills")
@@ -318,13 +331,17 @@ def cmd_list(argv):
             flags = ([out.aurora("pinned", "yellow")] if e.get("pinned") else []) + \
                     ([out.aurora("quarantined", "pink")] if e.get("quarantined")
                      else []) + \
+                    ([out.role("sidelined:" + e["sidelined_by"], "muted")]
+                     if e.get("sidelined_by") else []) + \
                     [out.role("#" + t, "muted") for t in e.get("tags") or []]
             rows.append((name, e.get("version", "?"), e.get("tap", "?"),
                          "·".join(a.split("-")[0] for a in e.get("agents") or []),
                          " ".join(flags)))
         out.table(rows, headers=("NAME", "VERSION", "TAP", "AGENTS", "FLAGS"))
-        print("  " + out.aurora("%d skill%s installed"
-                                % (len(rows), "" if len(rows) == 1 else "s"), "cyan"))
+        print("  " + out.aurora("%d skill%s installed%s"
+                                % (len(rows), "" if len(rows) == 1 else "s",
+                                   " with tag #%s" % args.tag.lstrip("#")
+                                   if args.tag else ""), "cyan"))
     if project:
         out.heading("project skills (%s)" % paths.tilde(pbase))
         rows = [(name, e.get("version", "?"), e.get("tap", "?"),
@@ -379,8 +396,15 @@ def _info_materialized(name: str, kind: str, entry: dict, as_json: bool) -> int:
         out.kv("installed", "%s (%s)" % (ia, util.rel_time(ia)))
     if ua and ua != ia:
         out.kv("updated", "%s (%s)" % (ua, util.rel_time(ua)))
-    agents = [m.get("agent", "?") for m in entry.get("materializations") or []]
-    out.kv("materialized", ", ".join(agents) or "(none)")
+    if entry.get("quarantined"):
+        # `materializations` still names what quarantine stashed and would
+        # restore on release — it is not what's on disk right now, which is
+        # nothing. Printing the stale agent list here reads as a lie about
+        # files that were just removed.
+        out.kv("materialized", "(removed — quarantined)")
+    else:
+        agents = [m.get("agent", "?") for m in entry.get("materializations") or []]
+        out.kv("materialized", ", ".join(agents) or "(none)")
     out.kv("pinned", "yes" if entry.get("pinned") else "no")
     out.kv("quarantined", "yes" if entry.get("quarantined") else "no")
     return 0
@@ -475,6 +499,8 @@ def cmd_info(argv):
             badges.append(out.badge("pinned", "yellow"))
         if lock.get("quarantined"):
             badges.append(out.badge("quarantined", "pink"))
+        if lock.get("sidelined_by"):
+            badges.append(out.badge("sidelined by %s" % lock["sidelined_by"], "cyan"))
         latest = str((cat or {}).get("version") or "")
         if cat and latest != str(lock.get("version", "?")):
             badges.append(out.badge("update available", "yellow"))
@@ -524,6 +550,8 @@ def cmd_info(argv):
         out.kv("agents", ", ".join(lock.get("agents") or []) or "(none)")
         out.kv("pinned", "yes" if lock.get("pinned") else "no")
         out.kv("quarantined", "yes" if lock.get("quarantined") else "no")
+        if lock.get("sidelined_by"):
+            out.kv("sidelined by", str(lock["sidelined_by"]))
         if lock.get("tags"):
             out.kv("tags", " ".join("#" + t for t in lock["tags"]))
     elif _as_list(meta.get("tags")):
@@ -575,22 +603,24 @@ def cmd_edit(argv):
                                  description="Open a skill's SKILL.md in your editor")
     ap.add_argument("name")
     args = ap.parse_args(argv)
-    lock = lockfile.get_skill(args.name)
-    if not lock:
-        found = lockfile.find_any(args.name)
-        if found is not None:
-            # Editing opens a skill's store dir; a rule/workflow has none — it
-            # materializes into shared agent files (e.g. ~/.claude/CLAUDE.md).
-            raise BoostError(
-                "%s is a %s — boost edit applies to skills"
-                % (args.name, found[0]),
-                hint="a %s materializes into shared agent files, not a store "
-                     "dir you can open; read it with `boost cat %s`"
-                     % (found[0], args.name))
+    # `args.name` may be tap-qualified (`owner/repo:skill`); resolve to the
+    # bare name the lock keys on, honoring the qualifier against the
+    # installed tap rather than rejecting the string as an invalid skill name.
+    name, kind, lock = store.resolve_lock_entry(args.name)
+    if lock is None:
         raise BoostError("%s is not installed" % args.name,
                         hint="install it first, or `boost cat %s` to read the tap copy"
                         % args.name)
-    sdir = store.skill_store_dir(args.name)
+    if kind != "skill":
+        # Editing opens a skill's store dir; a rule/workflow has none — it
+        # materializes into shared agent files (e.g. ~/.claude/CLAUDE.md).
+        raise BoostError(
+            "%s is a %s — boost edit applies to skills"
+            % (args.name, kind),
+            hint="a %s materializes into shared agent files, not a store "
+                 "dir you can open; read it with `boost cat %s`"
+                 % (kind, args.name))
+    sdir = store.skill_store_dir(name)
     path = sdir / "SKILL.md"
     if not path.exists():
         raise BoostError("SKILL.md missing from %s" % _tilde(sdir),
@@ -607,8 +637,8 @@ def cmd_edit(argv):
     sha = util.sha256_dir(sdir)
     if sha != lock.get("sha256"):
         lock["sha256"], lock["updated_at"] = sha, util.now_iso()
-        lockfile.set_skill(args.name, lock)
-        journal.log("edit", args.name)
+        lockfile.set_skill(name, lock)
+        journal.log("edit", name)
         out.warn("local edits diverge from the tap source — boost drift will flag this")
     else:
         out.ok("no changes")
@@ -962,7 +992,8 @@ def cmd_deps(argv):
         print(json.dumps({"unmet": unmet, "conflicts": pairs}, indent=2))
         return 1 if unmet or pairs else 0
     if not inst:
-        out.info("no skills installed")
+        print(out.empty_state("no skills installed",
+                              hint="boost install <skill> to start"))
         return 0
     for u in unmet:
         out.info("%s requires %s %s"
@@ -992,12 +1023,27 @@ def cmd_tag(argv):
     # from `+x -x`.
     flag_strings = {"--list", "--json", "-h", "--help"}
     flags = [t for t in argv if t in flag_strings]
-    operands = [t for t in argv if t not in flag_strings]
+    # A long option this command does not know must not silently fall through
+    # as an operand: `tag brainstorming --verbose` used to read as removing
+    # the tag `-verbose`, and `tag --verbose` as `--verbose is not installed`
+    # — every sibling command instead rejects an unrecognized `--flag` with
+    # exit 2. Handing the untouched argv to argparse here raises that same
+    # "unrecognized arguments" error rather than the misleading ones above.
+    unknown_long = [t for t in argv if t.startswith("--") and t not in flag_strings]
+    if unknown_long:
+        ap.parse_args(argv)
+    operands = [t for t in argv if t not in flag_strings and not t.startswith("--")]
     args = ap.parse_args(flags)
     args.name = operands[0] if operands else None
     mods = operands[1:]
 
     if args.list_all:
+        if args.name:
+            # `tag brainstorming --list` used to silently drop the skill name
+            # and list every tag on every skill instead.
+            raise BoostError("--list does not take a skill name",
+                            hint="`boost tag --list` shows every tag; drop %r"
+                                 % args.name)
         mapping: dict[str, list[str]] = {}
         for name, e in sorted(lockfile.installed().items()):
             for t in e.get("tags") or []:
@@ -1016,40 +1062,27 @@ def cmd_tag(argv):
     if not args.name:
         raise BoostError("skill name required",
                         hint="`boost tag NAME +tag -tag`, or `boost tag --list`")
-    entry = lockfile.get_skill(args.name)
-    if not entry:
-        found = lockfile.find_any(args.name)
-        if found is not None:
-            raise BoostError(
-                "%s is a %s — boost tag applies to skills"
-                % (args.name, found[0]),
-                hint="tags are a skill-only label; rules and workflows are "
-                     "governed by pin / quarantine / verify")
+    # `args.name` may be tap-qualified (`owner/repo:skill`); resolve to the
+    # bare name the lock keys on, honoring the qualifier against the
+    # installed tap rather than rejecting the string as an invalid skill name.
+    name, kind, entry = store.resolve_lock_entry(args.name)
+    if entry is None:
         raise BoostError("%s is not installed" % args.name,
                         hint="see what is with `boost list`")
-    tags = list(entry.get("tags") or [])
-    changed = False
-    for tok in mods:
-        if not tok or tok[0] not in "+-":
-            raise BoostError("cannot parse %r" % tok,
-                            hint="prefix tags with + to add or - to remove")
-        t = tok[1:].lstrip("#").strip()
-        if not t:
-            raise BoostError("empty tag in %r" % tok)
-        if tok[0] == "+" and t not in tags:
-            tags.append(t)
-            changed = True
-        elif tok[0] == "-" and t in tags:
-            tags.remove(t)
-            changed = True
+    if kind != "skill":
+        raise BoostError(
+            "%s is a %s — boost tag applies to skills"
+            % (args.name, kind),
+            hint="tags are a skill-only label; rules and workflows are "
+                 "governed by pin / quarantine / verify")
+    tags, changed = lockfile.apply_tag_mods(entry.get("tags") or [], mods)
     if changed:
-        entry["tags"] = sorted(tags)
-        tags = entry["tags"]
-        lockfile.set_skill(args.name, entry)
-        journal.log("tag", args.name, tags=tags)
+        entry["tags"] = tags
+        lockfile.set_skill(name, entry)
+        journal.log("tag", name, tags=tags)
     if args.json:
-        print(json.dumps({"name": args.name, "tags": tags}, indent=2))
+        print(json.dumps({"name": name, "tags": tags}, indent=2))
         return 0
     shown = " ".join(out.role("#" + t, "accent") for t in tags) or out.role("(no tags)", "muted")
-    (out.ok if changed else out.info)("%s  %s" % (args.name, shown))
+    (out.ok if changed else out.info)("%s  %s" % (name, shown))
     return 0

{boost_skill_cli-1.2.91 → boost_skill_cli-1.2.92}/boost_cli/commands/intelligence.py

@@ -125,7 +125,7 @@ def _save_generated_fallback(name: str, text: str, reason: str) -> None:
     out.info("generated skill saved to %s" % _tilde(fallback))
 
 
-def _install_generated(name: str, text: str) -> None:
+def _install_generated(name: str, text: str, yes: bool = False) -> None:
     """Write a generated SKILL.md to a tempdir and install it as `name`.
 
     The tempdir is the only copy of a just-generated skill, so a refused install
@@ -138,10 +138,16 @@ def _install_generated(name: str, text: str) -> None:
     ``boost import``/``reinstall`` path. Ask before doing that here, so
     ``distill``/``infer``/``absorb --install`` don't quietly destroy an
     existing install and relabel its lock provenance ``local``.
+
+    ``yes`` mirrors each caller's own ``-y``/``--yes`` flag: out.confirm()
+    already honours ``--yes``/``-y`` off ``sys.argv`` for a real invocation,
+    but that check can't see an ``argv`` list handed straight to
+    :func:`boost_cli.cli.main` rather than the process's own argv, so the
+    parsed flag is passed through explicitly rather than relied on twice.
     """
     owner = store.existing_skill_owner(name)
-    if owner and not out.confirm(
-            "%s is already installed from %s — replace it?" % (name, owner)):
+    if owner and not (yes or out.confirm(
+            "%s is already installed from %s — replace it?" % (name, owner))):
         _save_generated_fallback(
             name, text, "%s is already installed from %s" % (name, owner))
         return
@@ -159,9 +165,12 @@ def _install_generated(name: str, text: str) -> None:
         out.info(out.role("linked into: %s" % ", ".join(res.linked), "muted"))
 
 
-def _write_generated(dest: Path, text: str) -> bool:
-    """Write a generated file, confirming before overwriting. False = declined."""
-    if dest.exists() and not out.confirm("overwrite %s?" % _tilde(dest)):
+def _write_generated(dest: Path, text: str, yes: bool = False) -> bool:
+    """Write a generated file, confirming before overwriting. False = declined.
+
+    ``yes`` — see :func:`_install_generated`.
+    """
+    if dest.exists() and not (yes or out.confirm("overwrite %s?" % _tilde(dest))):
         out.info("aborted — %s left untouched" % _tilde(dest))
         return False
     try:
@@ -190,6 +199,8 @@ def cmd_distill(argv: list[str]) -> int:
                     help="name for the merged skill (default: <first>-distilled)")
     ap.add_argument("--install", action="store_true",
                     help="install the merged skill instead of writing a file")
+    ap.add_argument("-y", "--yes", action="store_true",
+                    help="skip the overwrite/replace confirmation prompt")
     args = ap.parse_args(argv)
 
     names = list(dict.fromkeys(args.names))
@@ -211,10 +222,10 @@ def cmd_distill(argv: list[str]) -> int:
         merged = _distill_merge(new, sources)
 
     if args.install:
-        _install_generated(new, merged)
+        _install_generated(new, merged, yes=args.yes)
     else:
         dest = Path.cwd() / new / "SKILL.md"
-        if not _write_generated(dest, merged):
+        if not _write_generated(dest, merged, yes=args.yes):
             return 1
         out.info(out.role("install it with `boost import ./%s`" % new, "muted"))
     journal.log("distill", new, sources=names)
@@ -366,6 +377,8 @@ def cmd_infer(argv: list[str]) -> int:
     ap.add_argument("-o", "--output", metavar="FILE", help="write to a file")
     ap.add_argument("--install", action="store_true",
                     help="install the generated skill")
+    ap.add_argument("-y", "--yes", action="store_true",
+                    help="skip the overwrite/replace confirmation prompt")
     args = ap.parse_args(argv)
 
     root = paths.expand(args.path).resolve()
@@ -380,10 +393,10 @@ def cmd_infer(argv: list[str]) -> int:
         text = _infer_template(name, facts)
 
     if args.install:
-        _install_generated(name, text)
+        _install_generated(name, text, yes=args.yes)
         journal.log("infer", name, path=str(root))
     elif args.output:
-        if not _write_generated(paths.expand(args.output), text):
+        if not _write_generated(paths.expand(args.output), text, yes=args.yes):
             return 1
         journal.log("infer", name, path=str(root))
     else:
@@ -593,6 +606,8 @@ def cmd_absorb(argv: list[str]) -> int:
                     help="max patterns to absorb (default: 5)")
     ap.add_argument("--install", action="store_true",
                     help="install the generated skill")
+    ap.add_argument("-y", "--yes", action="store_true",
+                    help="skip the replace confirmation prompt")
     args = ap.parse_args(argv)
 
     if args.history:
@@ -634,7 +649,7 @@ def cmd_absorb(argv: list[str]) -> int:
         _note_fallback()
         text = _absorb_template(name, patterns)
     if args.install:
-        _install_generated(name, text)
+        _install_generated(name, text, yes=args.yes)
     else:
         print(text, end="" if text.endswith("\n") else "\n")
     journal.log("absorb", name, patterns=len(patterns), files=len(files))
@@ -906,11 +921,17 @@ def cmd_context(argv: list[str]) -> int:
             return 0
         return _context_apply(state)
     if action == "disable":
+        # Count only skills `context apply` actually sidelined (`sidelined_by
+        # == "context"`), not every mapped skill with a linking agent enabled
+        # — the old `link_agents(name).linked` check relinks unconditionally
+        # and is truthy for any skill that was never sidelined at all, so a
+        # branch with no matched rule still reported "N skill(s) relinked".
         restored = 0
         inst = lockfile.installed()
         for name in sorted(_mentioned_skills(state)):
             entry = inst.get(name)
-            if entry and not entry.get("quarantined") and store.link_agents(name).linked:
+            if entry and entry.get("sidelined_by") == "context":
+                store.unsideline(name)
                 restored += 1
         state["enabled"] = False
         _save_state(_CONTEXT_STATE, state)
@@ -981,9 +1002,9 @@ def _context_apply(state: dict) -> int:
         if entry.get("quarantined"):
             continue
         if name in active:
-            if store.link_agents(name).linked:
+            if store.unsideline(name).linked:
                 linked.append(name)
-        elif store.unlink_agents(name):
+        elif store.sideline(name, "context"):
             unlinked.append(name)
     out.kv("branch", branch)
     out.kv("matched", ", ".join(r["pattern"] for r in matched) or "(no patterns)")
@@ -1025,15 +1046,24 @@ def cmd_focus(argv: list[str]) -> int:
     if args.clear:
         if args.skills:
             raise BoostError("--clear takes no skill arguments")
+        # `link_agents(name).linked` used to drive both the loop and the
+        # count: it relinks unconditionally and is truthy for any skill with
+        # at least one enabled agent, so a `--clear` with no session at all
+        # still reported "N skill(s) restored". `sidelined_by == "focus"` is
+        # only true of skills THIS session actually unlinked.
+        had_session = state_path.exists()
         restored = 0
         for name, entry in sorted(lockfile.installed().items()):
-            if entry.get("quarantined"):
+            if entry.get("sidelined_by") != "focus":
                 continue
-            if store.link_agents(name).linked:
-                restored += 1
-        if state_path.exists():
+            store.unsideline(name)
+            restored += 1
+        if had_session:
             state_path.unlink()
         journal.log("focus", "clear", restored=restored)
+        if not had_session and not restored:
+            out.info("no focus session")
+            return 0
         out.ok("focus cleared — %d skill(s) restored" % restored)
         return 0
 
@@ -1073,10 +1103,10 @@ def cmd_focus(argv: list[str]) -> int:
     for name, entry in sorted(inst.items()):
         if name in names or entry.get("quarantined"):
             continue
-        if store.unlink_agents(name):
+        if store.sideline(name, "focus"):
             sidelined += 1
     for name in names:
-        store.link_agents(name)
+        store.unsideline(name)
     _save_state(_FOCUS_STATE, {"active": names, "since": util.now_iso()})
     journal.log("focus", ",".join(names))
     out.info("⌁ focus: %s %s"