boost-skill-cli 1.2.74__tar.gz → 1.2.76__tar.gz

{boost_skill_cli-1.2.74 → boost_skill_cli-1.2.76}/.gitignore

@@ -235,6 +235,7 @@ _bmad-output/
 # these are only this repo's project-scoped copies.
 .boost/
 .claude/skills/
+.claude/worktrees/
 .cursor/
 .gemini/
 .windsurf/

{boost_skill_cli-1.2.74/boost_skill_cli.egg-info → boost_skill_cli-1.2.76}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.74
+Version: 1.2.76
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0
@@ -291,6 +291,11 @@ because they rebuild in seconds, and vectors because they are only valid inside
 the embedding space that made them. Import merges, so it never drops taps the
 receiving machine already had.
 
+A tap sourced from a local directory is bundled with its sender-machine path
+as its URL — the catalogue still searches fine on the receiving machine, but
+`boost update` on that tap will fail once that path is gone. `--import` names
+which taps this applies to.
+
 ## Under the hood
 
 ```text

{boost_skill_cli-1.2.74 → boost_skill_cli-1.2.76}/README.md

@@ -249,6 +249,11 @@ because they rebuild in seconds, and vectors because they are only valid inside
 the embedding space that made them. Import merges, so it never drops taps the
 receiving machine already had.
 
+A tap sourced from a local directory is bundled with its sender-machine path
+as its URL — the catalogue still searches fine on the receiving machine, but
+`boost update` on that tap will fail once that path is gone. `--import` names
+which taps this applies to.
+
 ## Under the hood
 
 ```text

{boost_skill_cli-1.2.74 → boost_skill_cli-1.2.76}/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.74'
-__version_tuple__ = version_tuple = (1, 2, 74)
+__version__ = version = '1.2.76'
+__version_tuple__ = version_tuple = (1, 2, 76)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.74 → boost_skill_cli-1.2.76}/boost_cli/commands/_common.py

@@ -8,7 +8,7 @@ place lets the modules split without either importing back into the other.
 """
 from __future__ import annotations
 
-from ..core import lockfile
+from ..core import lockfile, store
 from ..errors import BoostError
 
 
@@ -17,6 +17,34 @@ def _s(n: int) -> str:
     return "" if n == 1 else "s"
 
 
+def _require_lock_integrity() -> None:
+    """Fail loudly, before iterating, if the lock file itself is broken.
+
+    `lockfile.read()` collapses a missing/corrupt/wrong-schema lock into an
+    empty skeleton so ordinary reads degrade cleanly — but that means
+    `cmd_verify`/`cmd_drift` would iterate zero entries and report "nothing
+    installed" for exactly the state they exist to catch: a store with real
+    skills in it and no record of them. A missing lock over an empty store is
+    a fresh install, not a fault, so only that combination passes silently;
+    corrupt or wrong-schema is always reported, store empty or not, matching
+    `boost doctor`'s wording so the two commands never disagree.
+    """
+    integ = lockfile.check()
+    if integ.ok:
+        return
+    if integ.problem == "missing":
+        if not store.has_content():
+            return
+        raise BoostError(
+            "lock file missing — the store has skills but nothing is recorded",
+            hint="run `boost sync`")
+    if integ.problem == "corrupt":
+        raise BoostError("lock file is corrupt — restore with `boost replay`")
+    raise BoostError(
+        "lock file schema is v%s, expected v%d" % (integ.version, lockfile.SCHEMA_VERSION),
+        hint="restore with `boost replay`")
+
+
 def _iter_installed(names: list[str] | None = None) -> list[tuple[str, dict]]:
     """[(name, lock_entry)] — all installed skills, or the given names.
 

{boost_skill_cli-1.2.74 → boost_skill_cli-1.2.76}/boost_cli/commands/configuration.py

@@ -75,7 +75,11 @@ def cmd_config(argv) -> int:
         cfg = config.load()
         print(json.dumps(cfg, indent=2))
         if not args.json:
-            out.dim("  " + _tilde(paths.config_path()))
+            cfg_path = paths.config_path()
+            if cfg_path.exists():
+                out.dim("  " + _tilde(cfg_path))
+            else:
+                out.dim("  defaults — %s not created yet" % _tilde(cfg_path))
         return 0
 
     if args.action == "get":
@@ -184,25 +188,31 @@ def cmd_clean(argv) -> int:
         out.ok("nothing to clean")
         return 0
 
-    verb = "would remove" if args.dry_run else "removed"
-    freed = 0
-    for pth, kind, size in items:
-        if not args.dry_run:
-            try:
-                if pth.is_symlink() or pth.is_file():
-                    pth.unlink()
-                elif pth.is_dir():
-                    util.rmtree(pth)
-            except OSError as e:
-                out.warn("could not remove %s: %s" % (_tilde(pth), e))
-                continue
-        freed += size
-        out.info("%s %s %s" % (verb, _tilde(pth), out.role("(%s)" % kind, "muted")))
     if args.dry_run:
+        freed = sum(size for _, _, size in items)
+        for pth, kind, _size in items:
+            out.info("would remove %s %s" % (_tilde(pth), out.role("(%s)" % kind, "muted")))
         out.dim("  %d item(s) · %s would be freed" % (len(items), util.human_size(freed)))
-    else:
-        journal.log("clean", "%d items" % len(items), freed=util.human_size(freed))
-        out.ok("cleaned %d item(s) · %s freed" % (len(items), util.human_size(freed)))
+        return 0
+
+    removed, freed, failures = util.remove_items(items)
+    failed_errors = dict(failures)
+    for pth, kind, _size in items:
+        if pth in failed_errors:
+            out.warn("could not remove %s: %s" % (_tilde(pth), failed_errors[pth]),
+                     stream=sys.stderr)
+        else:
+            out.info("removed %s %s" % (_tilde(pth), out.role("(%s)" % kind, "muted")))
+
+    summary = "cleaned %d item(s)" % removed
+    if failures:
+        summary += ", %d failed" % len(failures)
+    summary += " · %s freed" % util.human_size(freed)
+    journal.log("clean", summary, freed=util.human_size(freed))
+    if failures:
+        out.warn(summary)
+        return 1
+    out.ok(summary)
     return 0
 
 

{boost_skill_cli-1.2.74 → boost_skill_cli-1.2.76}/boost_cli/commands/discovery.py

@@ -94,6 +94,8 @@ def cmd_search(argv):
     p.add_argument("query", nargs="+", help="search terms")
     p.add_argument("--smart", action="store_true",
                    help="rerank the top hits with Claude")
+    p.add_argument("--category", default="",
+                   help="only show entries whose category matches (case-insensitive)")
     p.add_argument("--limit", type=util.positive_int, default=15,
                    help="max results (default 15)")
     p.add_argument("--collapse-near-duplicates", action="store_true",
@@ -139,6 +141,9 @@ def cmd_search(argv):
         scored = [(h["entry"], h["score"]) for h in (hits or [])]
     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
@@ -355,9 +360,11 @@ def _fetch_shards(args) -> int:
         raise BoostError("published shards cannot serve this machine — %s" % why,
                         hint=dense.fix_hint(dense.status().get("reason", "")))
     commits = rag._tap_commits()
+    stored = dense.tap_commits()
     by_name = {t.name: commits.get(t.safe_name, "") for t in registry.list_taps()}
+    built = {t.name: stored.get(t.safe_name, "") for t in registry.list_taps()}
     results = shards.sync(
-        list(by_name), by_name, manifest=manifest,
+        list(by_name), by_name, manifest=manifest, built=built,
         # Progress goes to stdout, and so does the JSON: emitting both left
         # `--json` printing "fetching ..." lines ahead of the document, which
         # no parser can read past.
@@ -366,16 +373,26 @@ def _fetch_shards(args) -> int:
         print(json.dumps({"shards": results}, indent=2))
         return 0
     got = [r for r in results if r["status"] == "imported"]
+    current = [r for r in results if r["status"] == "current"]
     total = sum(int(r.get("chunks") or 0) for r in got)
     if got:
         out.ok("imported %d shard(s), %s chunks — no embedding needed"
                % (len(got), format(total, ",")))
-    else:
+    if current:
+        # Nothing to download: the store already holds vectors for exactly
+        # the commit the manifest publishes. Reported alongside `got` rather
+        # than instead of it — a run that imports some shards and finds the
+        # rest already current has two things to say, and an `elif` here said
+        # only the first.
+        out.info(out.role("%d shard(s) already up to date — nothing to fetch"
+                          % len(current), "muted"))
+    if not got and not current:
         # Not a success line. Nothing landed, and saying "imported 0" with a
         # tick reads as a job well done to the one user who most needs to know
         # their vectors are still missing.
         out.warn("no published vectors matched your taps")
-    missing = [r["tap"] for r in results if r["status"] != "imported"]
+    missing = [r["tap"] for r in results
+               if r["status"] not in ("imported", "current")]
     if missing:
         out.info(out.role("%d tap(s) without usable vectors: %s"
                           % (len(missing), ", ".join(missing[:5])
@@ -879,6 +896,8 @@ def cmd_recommend(argv):
         prog="boost recommend",
         description="Suggest skills based on your project's tech stack")
     p.add_argument("--path", default=".", help="project directory (default: cwd)")
+    p.add_argument("--category", default="",
+                   help="only recommend entries whose category matches (case-insensitive)")
     p.add_argument("--limit", type=util.positive_int, default=8,
                    help="max suggestions (default 8)")
     p.add_argument("--json", action="store_true", dest="as_json",
@@ -888,7 +907,12 @@ def cmd_recommend(argv):
     if not target.is_dir():
         raise BoostError("no such directory: %s" % args.path)
     entries = catalog.all_entries()
-    if not entries:
+    if args.category:
+        entries = catalog.filter_by_category(entries, args.category)
+        if not entries:
+            raise BoostError("no entries in category %r" % args.category,
+                            hint="try `boost recommend` with no --category")
+    elif not entries:
         raise BoostError("no skills in any tap to recommend from",
                         hint="add registries with `boost tap --defaults`")
     stack = detect_stack(target)
@@ -957,10 +981,11 @@ def _browse_plain(entries, why: str):
 
 def _tap_categories() -> dict:
     """tap name ('owner/repo') -> curated category, from the bundled registry
-    catalog (data/registries.json) — the only place "category" lives; catalog
-    entries themselves carry no category, only their tap does."""
-    return {e["name"]: e["category"] for e in config.load_registry_catalog()
-            if e.get("category")}
+    catalog (data/registries.json). Fallback only: a catalog entry's own
+    stamped `category` (`catalog.CACHE_FORMAT` 2+) is preferred wherever one is
+    available; this is what `_row_badges` falls back to for a cache written
+    before that field existed."""
+    return config.registry_categories()
 
 
 _KIND_BADGE_KEYS = {"skill": "badge_skill", "rule": "badge_rule",
@@ -973,14 +998,20 @@ def _kind_theme_key(kind: str) -> str:
 
 def _row_badges(e: dict, categories: dict):
     """Ordered (text, theme-key) badges for a browse row: kind, version, tap,
-    and — when the tap is one of the curated registries — its category.
-    Most-important-first, so a narrow terminal drops from the tail without
-    losing the essentials (kind and version survive; category goes first)."""
+    and the item's category, when one is known. Most-important-first, so a
+    narrow terminal drops from the tail without losing the essentials (kind
+    and version survive; category goes first).
+
+    The entry's own stamped `category` (`catalog.CACHE_FORMAT` 2+) is used
+    first — it covers un-bundled taps too, which the old tap-level lookup
+    never could. `categories` (`_tap_categories`) is the fallback for a cache
+    written before that field existed, so an un-rescanned tap doesn't lose its
+    badge outright."""
     badges = [(out.kind_label(e.get("kind", "skill")),
                _kind_theme_key(e.get("kind", "skill"))),
               ("v" + e["version"], "version"),
               ("[%s]" % e["tap"], "tap")]
-    category = categories.get(e["tap"])
+    category = e.get("category") or categories.get(e["tap"])
     if category:
         badges.append(("[%s]" % category, "badge_category"))
     return badges
@@ -1675,9 +1706,16 @@ def cmd_browse(argv):
     p = cliparse.parser(
         prog="boost browse",
         description="Interactive full-screen TUI with fuzzy search")
-    p.parse_args(argv)
+    p.add_argument("--category", default="",
+                   help="only browse entries whose category matches (case-insensitive)")
+    args = p.parse_args(argv)
     entries = sorted(catalog.all_entries(), key=operator.itemgetter("name"))
-    if not entries:
+    if args.category:
+        entries = catalog.filter_by_category(entries, args.category)
+        if not entries:
+            raise BoostError("no entries in category %r" % args.category,
+                            hint="try `boost browse` with no --category to see them all")
+    elif not entries:
         raise BoostError("no skills available to browse",
                         hint="add registries with `boost tap --defaults`")
     if not (sys.stdin.isatty() and sys.stdout.isatty()):

{boost_skill_cli-1.2.74 → boost_skill_cli-1.2.76}/boost_cli/commands/hooks.py

@@ -144,15 +144,13 @@ def _remove(args) -> int:
                          hint="the name you gave the hook when adding it")
     scope = args.scope or "project"
     host = _write_host(args.host)
-    events = ((_native_event(host, args.event),) if args.event
-              else hookhost.events(host))
-    removed = sum(cs.remove_hook(scope, ev, args.name, host=host)
-                  for ev in events)
+    event = _native_event(host, args.event) if args.event else None
+    removed = cs.remove_hook_by_name(scope, args.name, event, host=host)
     journal.log("hook-remove", args.name, scope=scope, host=host)
     if removed:
         out.ok("removed %d hook(s) named '%s' (%s)"
                % (removed, args.name, _where(host, scope)))
-    else:
-        out.warn("no boost hook named '%s' in %s scope"
-                 % (args.name, _where(host, scope)))
-    return 0
+        return 0
+    out.warn("no boost hook named '%s' in %s scope"
+             % (args.name, _where(host, scope)))
+    return 1

{boost_skill_cli-1.2.74 → boost_skill_cli-1.2.76}/boost_cli/commands/info.py

@@ -459,6 +459,7 @@ def cmd_info(argv):
             "mcp_servers": [r["name"] for r in mcp_servers],
             "latest": (cat or {}).get("version"),
             "tap": (lock or plock or cat or {}).get("tap"),
+            "category": (cat or {}).get("category") or None,
             "store": str(sdir) if lock and sdir.is_dir() else None,
             "quality": score, "size": size, "files": files,
         }, indent=2))
@@ -502,6 +503,9 @@ def cmd_info(argv):
     else:
         out.kv("latest", str((cat or {}).get("version", "?")))
     out.kv("tap", (lock or cat or {}).get("tap", "?"))
+    category = (cat or {}).get("category")
+    if category:
+        out.kv("category", category)
     if lock and sdir.is_dir():
         out.kv("store", _tilde(sdir))
     src = lock.get("source_dir") if lock else (cat or {}).get("rel_dir")

{boost_skill_cli-1.2.74 → boost_skill_cli-1.2.76}/boost_cli/commands/intelligence.py

@@ -208,6 +208,21 @@ def _distill_ai(new: str, sources: list[dict]) -> str | None:
     return text if meta.get("name") else None
 
 
+_FENCE_RE = re.compile(r"^`{3,}")
+_STRUCTURAL_LINES = frozenset({"```", "---", "}", ");"})
+_TABLE_RULE_RE = re.compile(r"^-{3,}$|^[\s:|-]*\|[\s:|-]*$")
+
+
+def _is_structural_line(key: str) -> bool:
+    """Pure-syntax lines that must survive a dedupe pass unconditionally.
+
+    A closing fence, a lone brace/paren, an hr, or a table separator row
+    repeats verbatim across sources by construction, not by accident —
+    deduping them corrupts the merged document's structure.
+    """
+    return key in _STRUCTURAL_LINES or bool(_TABLE_RULE_RE.match(key))
+
+
 def _distill_merge(new: str, sources: list[dict]) -> str:
     """Mechanical merge: union tags, dedupe exact-duplicate body lines."""
     tags: list[str] = []
@@ -222,17 +237,27 @@ def _distill_merge(new: str, sources: list[dict]) -> str:
             "version": "1.0.0"}
     if tags:
         meta["tags"] = tags
-    seen = set()
+    seen: set[str] = set()
     sections = ["# %s\n\nDistilled from: %s."
                 % (new, ", ".join(s["name"] for s in sources))]
     for s in sources:
         kept = []
+        in_fence = False
         for raw in s["body"].splitlines():
             key = raw.strip()
-            if key:
-                if key in seen:
-                    continue
-                seen.add(key)
+            if not key:
+                kept.append(raw)
+                continue
+            if _FENCE_RE.match(key):
+                in_fence = not in_fence
+                kept.append(raw)
+                continue
+            if in_fence or _is_structural_line(key):
+                kept.append(raw)
+                continue
+            if key in seen:
+                continue
+            seen.add(key)
             kept.append(raw)
         sections.append("## From %s\n\n%s" % (s["name"], "\n".join(kept).strip()))
     body = re.sub(r"\n{3,}", "\n\n", "\n\n".join(sections))
@@ -575,6 +600,7 @@ def cmd_absorb(argv: list[str]) -> int:
         _install_generated(name, text)
     else:
         print(text, end="" if text.endswith("\n") else "\n")
+    journal.log("absorb", name, patterns=len(patterns), files=len(files))
     return 0
 
 

{boost_skill_cli-1.2.74 → boost_skill_cli-1.2.76}/boost_cli/commands/pkg.py

@@ -1519,7 +1519,13 @@ def _snapshot_save(label: str | None) -> int:
                                   util.human_size(tar_path.stat().st_size)))
     others = _others_installed()
     if others:
-        out.warn("%s not captured — snapshots cover the skill store only" % others)
+        # The lock entry for these IS in the archive (the lock file is a
+        # child of store_dir()) -- what's not captured is the materialized
+        # file (CLAUDE.md block, rendered command) that lives outside the
+        # store, so a restore can only bring one back by re-materializing it
+        # from its tap, not by extracting it from this archive.
+        out.warn("%s tracked but not archived here — their CLAUDE.md/command "
+                "files live outside the skill store" % others)
     out.info("restore with `boost snapshot restore %s`" % snap_id)
     return 0
 
@@ -1569,6 +1575,14 @@ def _snapshot_restore(snap_id: str) -> int:
         out.info("cancelled")
         return 0
     paths.ensure_dirs()
+    # Rules/workflows installed after this snapshot was saved: their lock
+    # entries live in the same file the archive is about to replace, but
+    # their materializations (CLAUDE.md blocks, rendered commands) are
+    # outside the store and untouched by a restore. Capture them before the
+    # store is emptied so they can be added back — see
+    # store.restore_preserve_newer_lock_sections.
+    pre_rules = lockfile.installed_rules().copy()
+    pre_workflows = lockfile.installed_workflows().copy()
     # Read the whole archive BEFORE touching the store, so a corrupt
     # snapshot can never leave us with an emptied environment.
     try:
@@ -1596,14 +1610,28 @@ def _snapshot_restore(snap_id: str) -> int:
             # store (never fetched from a remote), so this legacy-interpreter
             # fallback restores a locally-trusted tar.
             tf.extractall(str(root), members=members)  # noqa: S202
-    for action in store.sync_apply(store.sync_plan()):
+    kept = store.restore_preserve_newer_lock_sections(pre_rules, pre_workflows)
+    actions = store.sync_apply(store.sync_plan())
+    for action in actions:
         out.ok(action)
     journal.log("snapshot-restore", snap_id)
     out.ok("restored %s (%s)" % (snap_id,
                                  _plural(len(lockfile.installed()), "skill")))
+    rematerialized = sum(1 for a in actions if a.startswith("re-materialized "))
+    kept_n = len(kept["rules"]) + len(kept["workflows"])
     others = _others_installed()
     if others:
-        out.warn("%s untouched — snapshots cover the skill store only" % others)
+        msg = "%s untouched — snapshots cover the skill store only" % others
+        extra = []
+        if kept_n:
+            extra.append("%s installed after this snapshot kept as-is"
+                         % _plural(kept_n, "entry"))
+        if rematerialized:
+            extra.append("%s re-materialized from its tap"
+                         % _plural(rematerialized, "entry"))
+        if extra:
+            msg += " (%s)" % "; ".join(extra)
+        out.warn(msg)
     return 0
 
 

{boost_skill_cli-1.2.74 → boost_skill_cli-1.2.76}/boost_cli/commands/quality.py

@@ -42,7 +42,7 @@ from ..core import (
 )
 from ..core import output as out
 from ..errors import BoostError
-from ._common import _iter_installed, _iter_installed_all, _s
+from ._common import _iter_installed, _iter_installed_all, _require_lock_integrity, _s
 
 # --- conflict: normative-rule extraction -----------------------------------
 
@@ -405,20 +405,32 @@ def cmd_doctor(argv):
         out.info("no registries tapped — nothing is searchable yet; add the "
                  "recommended ones with `boost tap --defaults`", wrap=True)
 
-    lock_ok = True
-    lp = paths.lockfile_path()
-    if lp.exists():
-        try:
-            raw = json.loads(lp.read_text(encoding="utf-8"))
-            if raw.get("version") != lockfile.SCHEMA_VERSION:
-                bad("lock file schema is v%s, expected v%d"
-                    % (raw.get("version"), lockfile.SCHEMA_VERSION))
-                lock_ok = False
-        except (json.JSONDecodeError, OSError):
-            bad("lock file is corrupt — restore with `boost replay`")
-            lock_ok = False
-    if lock_ok:
+    # lockfile.read() collapses missing/corrupt/wrong-schema into an empty
+    # skeleton so ordinary reads degrade cleanly — but that is exactly why
+    # this used to print "lock file parses (v3)" for a lock file that did not
+    # exist. check() reports the raw state instead, so "parses" is only ever
+    # claimed for a file doctor actually parsed.
+    integ = lockfile.check()
+    if integ.ok:
         out.ok("lock file parses (v%d)" % lockfile.SCHEMA_VERSION)
+        lock_ok = True
+    elif integ.problem == "missing":
+        if store.has_content():
+            n = sum(1 for c in paths.store_dir().iterdir()
+                    if c.is_dir() and not c.name.startswith("."))
+            bad("lock file missing — %d store dir%s unrecorded, run `boost sync`"
+                % (n, _s(n)))
+            lock_ok = False
+        else:
+            out.info("no lock file yet — nothing installed")
+            lock_ok = True
+    elif integ.problem == "corrupt":
+        bad("lock file is corrupt — restore with `boost replay`")
+        lock_ok = False
+    else:  # "schema"
+        bad("lock file schema is v%s, expected v%d"
+            % (integ.version, lockfile.SCHEMA_VERSION))
+        lock_ok = False
 
     skills = lockfile.installed()
     enabled = agents.enabled_agents()
@@ -618,7 +630,11 @@ def cmd_doctor(argv):
     crashes = sorted(paths.logs_dir().glob("crash-*.log")) \
         if paths.logs_dir().is_dir() else []
     if crashes:
-        out.warn("%d crash report%s in %s (newest: %s) — see `boost log --crashes`"
+        # `out.info`, not `bad`/`out.warn`, for the same reason as the foreign
+        # symlinks and hooks above: a crash report is history, not a current
+        # fault, so it must not wear the "!" glyph or verdict a healthy
+        # machine as having an issue that needs attention.
+        out.info("%d crash report%s in %s (newest: %s) — see `boost log --crashes`"
                  % (len(crashes), _s(len(crashes)), _tilde(paths.logs_dir()),
                     crashes[-1].name))
 
@@ -645,8 +661,8 @@ def cmd_doctor(argv):
     else:
         out.verdict(issues == 0,
                     "healthy" if not issues else
-                    "%d issue%s need attention — see the suggestions above"
-                    % (issues, _s(issues)))
+                    "%d issue%s %s attention — see the suggestions above"
+                    % (issues, _s(issues), "needs" if issues == 1 else "need"))
     return 1 if issues else 0
 
 
@@ -698,7 +714,7 @@ def _report_search_engine(bad) -> None:
         elif st["reason"] == "empty":
             detail += " but holds no vectors"
         bad("semantic search silently off — %d-chunk vector store %s; "
-            "searches are using BM25. %s" % (st["chunks"], detail, fix),
+            "searches are using BM25 — %s" % (st["chunks"], detail, fix),
             wrap=True)
         return
 
@@ -718,7 +734,9 @@ def _print_skipped(skipped: list[dict]) -> None:
 def cmd_lint(argv):
     ap = cliparse.parser(
         prog="boost lint", description="Validate SKILL.md frontmatter & quality")
-    ap.add_argument("names", nargs="*", metavar="NAME")
+    ap.add_argument("names", nargs="*", metavar="NAME",
+                    help="installed skill name(s), or a path to a skill "
+                         "directory / its SKILL.md")
     ap.add_argument("--tap", metavar="TAP", help="lint every skill in a tap's clone")
     ap.add_argument("--min", type=int, default=40, dest="min_score", metavar="N",
                     help="minimum passing score (default 40)")
@@ -735,8 +753,15 @@ def cmd_lint(argv):
         targets, skipped = catalog.lint_targets(
             catalog.load_tap(tap), tap.path, args.names or None)
     else:
-        targets = [(n, store.skill_store_dir(n))
-                   for n, _e in _iter_installed(args.names or None)]
+        names = args.names or []
+        path_names = [n for n in names if catalog.is_path_target(n)]
+        other_names = [n for n in names if n not in path_names]
+        for n in path_names:
+            p = catalog.resolve_path_target(n)
+            targets.append((p.name, p))
+        if not names or other_names:
+            targets += [(n, store.skill_store_dir(n))
+                       for n, _e in _iter_installed(other_names or None)]
     if not targets:
         if args.json:
             print(json.dumps({"min": args.min_score, "skills": [],
@@ -751,8 +776,16 @@ def cmd_lint(argv):
         score, notes = util.score_skill(sdir)
         meta, _ = _read_skill(sdir)
         errors = []
-        if not (sdir / "SKILL.md").exists():
+        md = sdir / "SKILL.md"
+        if not md.exists():
             errors.append("missing SKILL.md")
+        elif not meta and frontmatter.unclosed(
+                md.read_text(encoding="utf-8", errors="replace")):
+            # An open `---` with no closing fence parses as no frontmatter at
+            # all, so `name`/`description` both read absent — the same
+            # symptom three separate checks would otherwise each report on
+            # their own. One diagnosis for one cause.
+            errors.append(frontmatter.UNCLOSED_NOTE)
         else:
             if not meta.get("name"):
                 errors.append("missing required field: name")
@@ -760,7 +793,7 @@ def cmd_lint(argv):
                 errors.append("missing required field: description")
         notes = [n for n in notes
                  if "missing `name`" not in n and "missing `description`" not in n
-                 and n != "missing SKILL.md"]
+                 and n != "missing SKILL.md" and n != frontmatter.UNCLOSED_NOTE]
         results.append({"name": name, "score": score, "notes": notes,
                         "errors": errors, "path": str(sdir)})
 
@@ -798,6 +831,10 @@ def cmd_drift(argv):
     ap.add_argument("--json", action="store_true")
     args = ap.parse_args(argv)
 
+    # Same rule as `boost verify`: a missing/corrupt/wrong-schema lock over a
+    # populated store is a fault, not "no skills installed".
+    _require_lock_integrity()
+
     rows = []
     for kind, name, entry in _iter_installed_all(args.names or None):
         status = (_drift_status(name, entry) if kind == "skill"