boost-skill-cli 1.2.207__tar.gz → 1.2.209__tar.gz

{boost_skill_cli-1.2.207 → boost_skill_cli-1.2.209}/PKG-INFO

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

{boost_skill_cli-1.2.207 → boost_skill_cli-1.2.209}/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.207'
-__version_tuple__ = version_tuple = (1, 2, 207)
+__version__ = version = '1.2.209'
+__version_tuple__ = version_tuple = (1, 2, 209)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.207 → boost_skill_cli-1.2.209}/boost_cli/commands/_common.py

@@ -63,8 +63,9 @@ def _require_lock_integrity() -> None:
         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 — %s" % lockfile.remedy(integ))
+    if integ.problem in ("corrupt", "unreadable"):
+        raise BoostError("lock file %s — %s"
+                         % (lockfile.fault(integ), lockfile.remedy(integ)))
     if lockfile.newer(integ):
         raise BoostError("lock file %s" % lockfile.fault(integ),
                          hint=lockfile.remedy(integ))

{boost_skill_cli-1.2.207 → boost_skill_cli-1.2.209}/boost_cli/commands/bmad.py

@@ -579,7 +579,14 @@ def _require_npx() -> None:
             hint="install Node.js 20.12+ (e.g. `brew install node`), then retry")
 
 
-def _run_installer(directory: Path, modules: str) -> subprocess.CompletedProcess:
+def _run_installer(directory: Path, modules: str,
+                   hint: str | None = None) -> subprocess.CompletedProcess:
+    """Run the BMAD installer into `directory`.
+
+    ``hint`` replaces the default "run it yourself" one: a global install
+    stages into a temp dir that is deleted before the error is printed, so a
+    command naming it would install into nothing the user keeps.
+    """
     cmd = ["npx", "--yes", "bmad-method@%s" % core.BMAD_VERSION, "install",
            "--yes", "--directory", str(directory),
            "--tools", "claude-code", "--modules", modules,
@@ -592,15 +599,32 @@ def _run_installer(directory: Path, modules: str) -> subprocess.CompletedProcess
                               timeout=900)
     except (OSError, subprocess.TimeoutExpired) as e:
         raise BoostError("bmad install failed: %s" % e,
-                         hint="run it yourself: " + " ".join(cmd)) from e
+                         hint=hint or _run_it_yourself(cmd)) from e
     if proc.returncode != 0:
         tail = (proc.stderr or proc.stdout or "").strip().splitlines()
         raise BoostError(
             "bmad install failed: %s" % (tail[-1] if tail else "unknown error"),
-            hint="run it yourself: " + " ".join(cmd))
+            hint=hint or _run_it_yourself(cmd))
     return proc
 
 
+def _run_it_yourself(cmd: list[str]) -> str:
+    """The hint naming the installer argv, quoted so it pastes as one command.
+
+    Backticked because the hint folds to the pane and only a backtick span is
+    atomic: a fold at the space inside `'/h/my proj'` pastes as a dangling quote.
+    """
+    return "run it yourself: `%s`" % util.shell_join(cmd)
+
+
+def _global_retry_hint(modules: str) -> str:
+    """What to re-run after a failed global install, whose stage is gone."""
+    argv = ["boost", "bmad", "install", "--scope", "global"]
+    if modules != DEFAULT_MODULES:
+        argv += ["--modules", modules]
+    return "once npx works, re-run `%s`" % util.shell_join(argv)
+
+
 def _whoami() -> str:
     try:
         return getpass.getuser()
@@ -671,7 +695,8 @@ def _copy_global_skills(modules) -> tuple[str, list[str]]:
     """
     stage = Path(tempfile.mkdtemp(prefix="boost-bmad-"))
     try:
-        proc = _run_installer(stage, modules)
+        proc = _run_installer(stage, modules,
+                              hint=_global_retry_hint(modules))
         ver = _parse_version((proc.stdout or "") + (proc.stderr or ""))
         src = stage / ".claude" / "skills"
         dest = _skills_dir("global")
@@ -788,23 +813,47 @@ def _status(scope) -> int:
 
 def _uninstall(scope, yes, force: bool = False) -> int:
     scope = scope or "project"
-    if not (yes or out.confirm(
-            "Remove BMAD (%s)? deletes bmad-* skills%s" % (
-                scope, " + _bmad/, _bmad-output/" if scope == "project" else ""))):
+    skills, kept = core.skill_dirs(_skills_dir(scope))
+    extras: list[Path] = []
+    linked_extras: list[Path] = []
+    for extra in ("_bmad", "_bmad-output") if scope == "project" else ():
+        pth = Path.cwd() / extra
+        if pth.is_symlink():
+            linked_extras.append(pth)    # remove_dirs never follows a link
+        elif pth.is_dir():
+            extras.append(pth)
+    # The confirm names what it deletes: "deletes bmad-* skills" was all a
+    # user approved, which hid both a count of nothing and a symlink the run
+    # then could not remove.
+    doomed = [*skills, *extras]
+    what = ("deletes %s" % ", ".join(paths.tilde(p) for p in doomed)
+            if doomed else "no bmad-* skills to delete")
+    if not (yes or out.confirm("Remove BMAD (%s)? %s" % (scope, what))):
         out.info("aborted")
         return 1
-    _remove_hook_everywhere(scope, _ORIENT_HOOK, _ROUTE_HOOK, force=force)
-    removed = _rm_skills(_skills_dir(scope))
+    hooks = _remove_hook_everywhere(scope, _ORIENT_HOOK, _ROUTE_HOOK,
+                                    force=force)
+    removed = len(core.remove_dirs(skills))
     removed += len(core.remove_personas(_agents_dir(scope)))
-    if scope == "project":
-        for extra in ("_bmad", "_bmad-output"):
-            pth = Path.cwd() / extra
-            if pth.exists():
-                shutil.rmtree(pth, ignore_errors=True)
-                removed += 1
+    removed += len(core.remove_dirs(extras))
+    for entry in kept:
+        out.info(out.role("kept %s — not a BMAD install (a %s); `boost "
+                          "uninstall %s` removes one boost installed"
+                          % (paths.tilde(entry), "symlink" if entry.is_symlink()
+                             else "file", entry.name), "muted"), wrap=True)
+    for entry in linked_extras:
+        # Not a skill, so `boost uninstall <name>` is no answer for it: the
+        # link may well lead to the user's real BMAD runtime elsewhere.
+        out.info(out.role("kept %s — a symlink, and uninstall never deletes "
+                          "through one; remove it yourself if it is BMAD's"
+                          % paths.tilde(entry), "muted"), wrap=True)
     _clear_scope_state(scope)
+    if not (removed or hooks):
+        out.info("nothing of BMAD's to remove (%s)" % scope)
+        return 0
     journal.log("bmad-uninstall", scope, count=removed)
-    out.ok("removed BMAD (%s): %d item(s)" % (scope, removed))
+    out.ok("removed BMAD (%s): %d item(s)%s" % (
+        scope, removed, ", %d hook(s)" % hooks if hooks else ""))
     return 0
 
 
@@ -928,15 +977,6 @@ def _count_skills(skills_dir: Path) -> int:
     return sum(1 for d in skills_dir.glob("bmad-*") if d.is_dir())
 
 
-def _rm_skills(skills_dir: Path) -> int:
-    n = 0
-    if skills_dir.exists():
-        for d in sorted(skills_dir.glob("bmad-*")):
-            shutil.rmtree(d, ignore_errors=True)
-            n += 1
-    return n
-
-
 def _quarantine_dir(scope) -> Path:
     key = "global" if scope == "global" else _fs_slug(str(Path.cwd().resolve()))
     return paths.state_dir() / "bmad-quarantine" / key
@@ -1046,9 +1086,17 @@ def _set_scope_state(scope, **patch) -> None:
 
 
 def _clear_scope_state(scope) -> None:
-    d = _state_read()
+    """Forget ``scope``'s BMAD state, writing nothing when there is none.
+
+    An uninstall on a machine BMAD never touched used to create
+    ``bmad.json`` just to record that nothing was there. A corrupt file is
+    still written through, which is what quarantines it.
+    """
+    d, err = _state_load()
     if scope == "global":
+        held = bool(d["global"])
         d["global"] = {}
     else:
-        d["projects"].pop(_proj_key(), None)
-    _state_write(d)
+        held = d["projects"].pop(_proj_key(), None) is not None
+    if held or err is not None:
+        _state_write(d)

{boost_skill_cli-1.2.207 → boost_skill_cli-1.2.209}/boost_cli/commands/configuration.py

@@ -190,8 +190,9 @@ def cmd_clean(argv) -> int:
     # clean deleted it anyway when it walked `known_agents`. The exception is
     # a native-store dir boost recorded linking into before that agent's
     # `links_skills` went false: what dangles into the store there is boost's.
-    for adir in (*agents.sweep_dirs(),
-                 *(d for _a, d in agents.remembered_native_dirs())):
+    for adir in agents.unique_dirs(
+            [*agents.sweep_dirs(),
+             *(d for _a, d in agents.remembered_native_dirs())]):
         # ``os.path``: ``Path.is_dir`` raises under a dir with no search bit
         # on Python 3.12 and 3.13.
         if not os.path.isdir(adir):  # noqa: FURB146
@@ -207,7 +208,14 @@ def cmd_clean(argv) -> int:
         )
 
     configured = {t.safe_name for t in registry.list_taps()}
-    if paths.cache_dir().is_dir():
+    # With config.json unreadable or corrupt, the tap list is DEFAULTS' empty
+    # one, so every tap's cache read as stale and was deleted — on a file
+    # whose bytes, under a mode-000 config, still list every one of them.
+    cfg_err = config.check()
+    if cfg_err:
+        out.warn("left the tap caches alone: %s" % cfg_err,
+                 stream=sys.stderr, wrap=True)
+    elif paths.cache_dir().is_dir():
         # Skip boost's own derived artifacts. They live in the same directory and
         # end in .json, but no tap is named `rag_index` or `discovery`, so the
         # stem test alone called both stale and deleted them every run — see
@@ -494,8 +502,9 @@ def cmd_compact(argv) -> int:
         except BoostError as e:
             broken += 1
             rows.append({"tap": tap.name, "error": str(e)})
-            out.warn("could not compact %s: %s" % (tap.name, e),
-                     stream=sys.stderr if args.json else None)
+            out.warn("could not compact %s: %s%s"
+                     % (tap.name, e, " — %s" % e.hint if e.hint else ""),
+                     stream=sys.stderr if args.json else None, wrap=True)
             continue
         after = util.dir_size(tap.path)
         # A re-clone did real work — refreshed the clone, possibly moved it
@@ -1737,6 +1746,8 @@ def _tool_list(args: dict):
     if not any(everything.values()) and not project:
         return "nothing installed\n" + footer, False
     lines = []
+    # `[modified]` hashes each installed skill copy, as `boost list` does --
+    # the one cost here beyond the lock reads, 0.2-0.4 ms per fixture skill.
     for kind, section in everything.items():
         for n, e in sorted(section.items()):
             where = scopes.project_label(e) if kind != "skill" else None
@@ -1744,12 +1755,14 @@ def _tool_list(args: dict):
                          % (n, e.get("version", "?"), e.get("tap", "?"),
                             "" if kind == "skill" else " [%s]" % kind,
                             " [project %s]" % where if where else "",
-                            mcp.state_marks(e)))
+                            mcp.state_marks(e, kind == "skill" and integrity
+                                            .locally_edited(kind, n, e))))
     if project:
         lines.append("project skills (%s):" % _tilde(pbase))
         lines.extend("%s v%s (%s) [project]%s"
                      % (n, e.get("version", "?"), e.get("tap", "?"),
-                        mcp.state_marks(e))
+                        mcp.state_marks(e, integrity.locally_edited(
+                            "skill", n, e, base=pbase)))
                      for n, e in sorted(project.items()))
     lines.append(footer)
     return "\n".join(lines), False
@@ -1837,6 +1850,12 @@ def _tool_info(args: dict):
                  else scopes.project_label(entry))
         if where:
             lines.append("scope: project (%s)" % where)
+        if kind == "skill" and integrity.locally_edited(
+                kind, catalog.split_name(name)[1], entry, base=pbase):
+            # Doctor's and verify's check: the body an agent reads next is
+            # not the tap's.
+            lines.append("modified: yes — edited since install; `boost "
+                         "verify` names it")
         if entry.get("pinned"):
             lines.append("pinned: yes")
         if entry.get("quarantined"):
@@ -2576,9 +2595,9 @@ def _seed_catalog_for_mcp(force: bool) -> None:
     # 14-45s of network with nothing to show for it until it finishes — on
     # the one command a first-time user was told to run, silence that long
     # reads as a hang.
-    if bootstrap.will_seed(force=force):
+    if plan := bootstrap.seed_plan(force=force):
         out.info("no registries tapped yet — adding the %d recommended ones "
-                 "(one-time, needs the network)" % len(config.DEFAULT_TAPS))
+                 "(one-time, needs the network)" % len(plan))
     res = bootstrap.seed_catalog(force=force)
     if res.skipped:
         return
@@ -2599,39 +2618,24 @@ def _seed_catalog_for_mcp(force: bool) -> None:
 NO_RULE_ENV = "BOOST_NO_RULE"
 
 
-def _offer_boost_first(hosts: list[str]) -> None:
-    """Offer to install boost's own rule into the agent's standing instructions.
-
-    This is the most invasive thing boost can propose, and the only text it
-    asks to put in a file the user reads every session, in every project — so
-    the consent has to be real rather than procedural. The body is printed in
-    full BEFORE the question, the target paths are named, the answer defaults
-    to NO, and the reversal command is shown whether or not they accept.
-
-    Why it exists at all: Gemini never delivers MCP server `instructions` in
-    interactive mode, and in an untrusted folder — which a brand-new project
-    directory is by default — it does not start the server, so boost has no
-    tools there either. `~/.gemini/GEMINI.md` is loaded unconditionally and is
-    the only boost surface that survives both. Declining is a perfectly good
-    answer; the tool descriptions still carry the trigger on every host that
-    delivers them.
+def _boost_first_targets(hosts: list[str]) -> list[str]:
+    """The files :func:`_offer_boost_first` would offer to write; [] for no offer.
 
-    Non-fatal by construction. The user asked to register an MCP server; a
-    failure to materialise an optional rule must never turn that into an
-    error, so everything below degrades to a warning.
+    Every gate that does not need the registration to have run, in one place,
+    so `boost mcp register --dry-run` names the offer exactly when the real
+    run would make it.
     """
     from ..core import builtin
 
     if typedvalue.env_flag(NO_RULE_ENV, unknown=True):
-        return
+        return []
     # Scoped to hosts where boost actually registered a server. Offering it for
     # an agent with no boost tools would install standing text naming
     # `boost_search` to an agent that does not have it.
     if not hosts or not builtin.rule_is_available():
-        return
+        return []
     if lockfile.get_rule(builtin.BUILTIN_RULES[0]):
-        return                      # already installed; do not re-ask
-    body = (builtin.source_dir() / (builtin.BUILTIN_RULES[0] + ".mdc"))
+        return []                   # already installed; do not re-ask
     scoped_agents = {builtin.AGENT_FOR_HOST.get(h) for h in hosts}
     # materializing_agents, not enabled_agents: this is a *rule*, so the
     # preview has to be built from the set the rule install actually writes to,
@@ -2648,12 +2652,40 @@ def _offer_boost_first(hosts: list[str]) -> None:
     # below means the offer is never made and `store.install` never runs. So
     # the failure this prevents is a printed path that no install backs, not a
     # refusal.
-    targets = [str(rules.rule_target(agent, skills_dir,
-                                     builtin.BUILTIN_RULES[0])[1])
-               for agent, skills_dir in agents.materializing_agents().items()
-               if agent in scoped_agents]
+    return [str(rules.rule_target(agent, skills_dir,
+                                  builtin.BUILTIN_RULES[0])[1])
+            for agent, skills_dir in agents.materializing_agents().items()
+            if agent in scoped_agents]
+
+
+def _offer_boost_first(hosts: list[str]) -> None:
+    """Offer to install boost's own rule into the agent's standing instructions.
+
+    This is the most invasive thing boost can propose, and the only text it
+    asks to put in a file the user reads every session, in every project — so
+    the consent has to be real rather than procedural. The body is printed in
+    full BEFORE the question, the target paths are named, the answer defaults
+    to NO, and the reversal command is shown whether or not they accept.
+
+    Why it exists at all: Gemini never delivers MCP server `instructions` in
+    interactive mode, and in an untrusted folder — which a brand-new project
+    directory is by default — it does not start the server, so boost has no
+    tools there either. `~/.gemini/GEMINI.md` is loaded unconditionally and is
+    the only boost surface that survives both. Declining is a perfectly good
+    answer; the tool descriptions still carry the trigger on every host that
+    delivers them.
+
+    Non-fatal by construction. The user asked to register an MCP server; a
+    failure to materialise an optional rule must never turn that into an
+    error, so everything below degrades to a warning.
+    """
+    from ..core import builtin
+
+    targets = _boost_first_targets(hosts)
     if not targets:
         return
+    body = (builtin.source_dir() / (builtin.BUILTIN_RULES[0] + ".mdc"))
+    scoped_agents = {builtin.AGENT_FOR_HOST.get(h) for h in hosts}
     out.info("")
     out.info("boost can also add its own rule, `%s`, to your agents' standing "
              "instructions:" % builtin.BUILTIN_RULES[0])
@@ -2738,7 +2770,9 @@ def cmd_mcp(argv) -> int:
     shim = str(paths.launcher())
     verb = "register" if args.action == "register" else "unregister"
 
+    seeding = args.action == "register" and (args.seed_ok or args.seed)
     if args.dry_run:
+        would_settle: list[str] = []
         # Before seeding and before any subprocess runs — the flag exists so
         # the argv boost would run is visible in the one case that mattered
         # (`--host gemini` with `gemini` on PATH), not only the one case that
@@ -2759,6 +2793,20 @@ def cmd_mcp(argv) -> int:
             note = "  — outside this $HOME, refused without --force" \
                 if escape else ""
             out.dim("  writes %s%s" % (cfg, note))
+            if installed and not escape:
+                would_settle.append(host)
+        if seeding and (plan := bootstrap.seed_plan(force=args.seed)):
+            # The real run taps these before it touches any host — 14-45s of
+            # network a preview that stayed quiet about it would hide.
+            out.info("would tap %d recommended %s first (needs the network): "
+                     "%s" % (len(plan), "registry" if len(plan) == 1
+                             else "registries", ", ".join(plan)), wrap=True)
+        if args.action == "register" and (
+                rule_targets := _boost_first_targets(would_settle)):
+            from ..core import builtin
+            out.info("would then offer to add the `%s` rule to %s (asks first)"
+                     % (builtin.BUILTIN_RULES[0], ", ".join(rule_targets)),
+                     wrap=True)
         out.dim("  dry run — nothing was %sed, nothing tapped" % verb, wrap=True)
         return 0
 
@@ -2767,7 +2815,7 @@ def cmd_mcp(argv) -> int:
     # typo'd `--host` spent 14-45s and half a gigabyte before argparse's own
     # error, and seeding last would have registered a server the user then
     # watches answer nothing while the clones run.
-    if args.action == "register" and (args.seed_ok or args.seed):
+    if seeding:
         _seed_catalog_for_mcp(args.seed)
 
     # `auto` skips hosts that are not installed; naming a host explicitly (or

{boost_skill_cli-1.2.207 → boost_skill_cli-1.2.209}/boost_cli/commands/discovery.py

@@ -34,6 +34,7 @@ from ..core import (
     installscan,
     integrity,
     journal,
+    jsonstate,
     lockfile,
     paths,
     prereq,
@@ -140,6 +141,12 @@ def cmd_search(argv):
         # query at all, so it gets the same answer and argparse's rc 2.
         p.error("the query is empty — give at least one search term")
     if not registry.list_taps():
+        cfg_err = config.check()
+        if isinstance(cfg_err, jsonstate.Unreadable):
+            # The taps may all be in it; `tap --defaults` is refused over it.
+            raise BoostError("%s — no taps are read, so nothing was searched"
+                             % cfg_err,
+                             hint=jsonstate.read_remedy(cfg_err, paths.tilde))
         raise BoostError("no taps configured — nothing to search",
                         hint="add the recommended registries with `boost tap --defaults`")
     # Full-content (RAG) search is the default: build the index on first use so
@@ -2745,10 +2752,16 @@ def cmd_stats(argv):
     size = util.dir_size(sdir) if sdir and lock and sdir.is_dir() else None
     scope = (scopes.SCOPE_PROJECT if prow is not None
              else scopes.SCOPE_USER if lock else None)
+    # Edited since install, by doctor's and verify's own check, as `list`
+    # and `info` report it.
+    edited = (lock is not None and kind == "skill"
+              and integrity.locally_edited(
+                  "skill", name, lock,
+                  base=prow.base if prow is not None else None))
     if args.as_json:
         print(json.dumps({
             "name": name, "kind": kind, "installed": bool(lock), "lock": lock,
-            "scope": scope,
+            "scope": scope, "modified": edited,
             "size": size, "activity": acts,
             "catalog": ({"latest": latest, "tap": cat["tap"],
                          "description": cat["description"],
@@ -2782,6 +2795,9 @@ def cmd_stats(argv):
         if lock.get("quarantined"):
             out.kv("quarantined", "yes")
         out.kv("sha256", str(lock.get("sha256", ""))[:12])
+        if edited:
+            out.kv("modified", out.role("yes", "warn")
+                   + out.role("  (edited since install)", "muted"))
         if size is not None:
             out.kv("size", util.human_size(size))
         if cat and cat.get("description"):

{boost_skill_cli-1.2.207 → boost_skill_cli-1.2.209}/boost_cli/commands/info.py

@@ -297,8 +297,8 @@ def _print_wrapped(text: str) -> None:
 # ---------------------------------------------------------------- commands
 
 def _materialized_agents(kind, entry):
-    """Abbreviated agent column for a rule/workflow: the agents boost still
-    writes for it, not every recorded row (`integrity.written_agent_names`)."""
+    """Abbreviated agent column for any kind: the agents boost still writes
+    for it, not every recorded row or link (`integrity.written_agent_names`)."""
     return "·".join(a.split("-")[0]
                     for a in integrity.written_agent_names(kind, entry))
 
@@ -410,13 +410,26 @@ def cmd_list(argv):
     # A row whose store dir is gone is a skill no agent can load: doctor says
     # so, and list printed it beside the healthy ones with an empty FLAGS.
     gone = {n for n, e in skills.items() if store.missing_from_store(n, e)}
+    # A copy edited since install, by the check doctor and verify make
+    # (`integrity.locally_edited`): without it a hand-edited skill looked
+    # pristine here while both of them flagged it. It hashes each installed
+    # copy, which is the cost of this command -- measured on the fixture at
+    # 0.2-0.4 ms per skill, so 200 skills add well under 0.1 s; a skill
+    # shipping large assets costs what reading them costs.
+    edited = {n for n, e in skills.items()
+              if n not in gone and integrity.locally_edited("skill", n, e)}
+    pedited = {n for n, e in project.items()
+               if integrity.locally_edited("skill", n, e, base=pbase)}
     if args.json:
         # Marked on a copy, and only when true, so a healthy row is still
         # the lock's row byte for byte.
-        shown = {n: (e | {"missing_from_store": True} if n in gone else e)
+        shown = {n: (e | ({"missing_from_store": True} if n in gone else {})
+                     | ({"modified": True} if n in edited else {}))
                  for n, e in skills.items()}
+        pshown = {n: (e | {"modified": True} if n in pedited else e)
+                  for n, e in project.items()}
         print(json.dumps({"skills": shown, "rules": rules,
-                          "workflows": workflows, "project": project},
+                          "workflows": workflows, "project": pshown},
                          indent=2, sort_keys=True))
         return 0
     # Every row below is a tap's frontmatter by way of the lock (version,
@@ -448,6 +461,7 @@ def cmd_list(argv):
             # colored cells stay in their column: pinned amber, quarantined pink,
             # tags dim.
             flags = ([out.role("missing", "danger")] if name in gone else []) + \
+                    ([out.role("modified", "warn")] if name in edited else []) + \
                     ([out.aurora("pinned", "yellow")] if e.get("pinned") else []) + \
                     ([out.aurora("quarantined", "pink")] if e.get("quarantined")
                      else []) + \
@@ -455,8 +469,7 @@ def cmd_list(argv):
                      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)))
+                         _materialized_agents("skill", e), " ".join(flags)))
         # NAME is what `uninstall`/`update`/`cat` take: `brainstorm…` is not
         # a name any of them accepts, so it is shown whole or dropped.
         out.table(rows, headers=("NAME", "VERSION", "TAP", "AGENTS", "FLAGS"),
@@ -479,8 +492,11 @@ def cmd_list(argv):
         # holds `update` off this row, and a pinned row that looked like any
         # other was visible only in --json.
         rows = [(name, e.get("version", "?"), e.get("tap", "?"),
-                 "·".join(a.split("-")[0] for a in e.get("agents") or []),
-                 out.aurora("pinned", "yellow") if e.get("pinned") else "")
+                 _materialized_agents("skill", e),
+                 " ".join(([out.role("modified", "warn")]
+                           if name in pedited else [])
+                          + ([out.aurora("pinned", "yellow")]
+                             if e.get("pinned") else [])))
                 for name, e in sorted(project.items())]
         out.table(rows, headers=("NAME", "VERSION", "TAP", "AGENTS", "FLAGS"),
                   whole=("NAME",))
@@ -691,9 +707,15 @@ def cmd_info(argv):
     if not (lock or plock) and cat and kind == "skill":
         submodules = store.unfetched_submodules(cat)
 
+    # Edited since install, by doctor's and verify's own check. Either
+    # scope's copy counts: `boost update` refuses to overwrite either one.
+    edited = bool((lock and integrity.locally_edited("skill", name, lock))
+                  or (plock and integrity.locally_edited(
+                      "skill", name, plock, base=pbase)))
     if args.json:
         print(json.dumps({
             "name": name, "kind": kind, "description": desc,
+            "modified": edited,
             "submodules": submodules,
             "upstream_description": upstream or None,
             "installed": lock, "project": plock,
@@ -735,6 +757,8 @@ def cmd_info(argv):
         badges.append(out.badge("installed", "green"))
         if store.missing_from_store(name, lock):
             badges.append(out.badge("missing from store", "pink"))
+        if edited:
+            badges.append(out.badge("modified", "yellow"))
         if lock.get("pinned"):
             badges.append(out.badge("pinned", "yellow"))
         if lock.get("quarantined"):
@@ -747,6 +771,8 @@ def cmd_info(argv):
             badges.append(out.badge("also in this project", "green"))
     elif plock:
         badges.append(out.badge("installed in this project", "green"))
+        if edited:
+            badges.append(out.badge("modified", "yellow"))
         if plock.get("pinned"):
             badges.append(out.badge("pinned", "yellow"))
     else:
@@ -835,7 +861,10 @@ def cmd_info(argv):
             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)))
-        out.kv("agents", ", ".join(entry.get("agents") or []) or "(none)")
+        # Written agents only, as for a rule: a link left in a disabled
+        # agent's dir is kept for uninstall, not one boost still writes.
+        out.kv("agents", ", ".join(
+            integrity.written_agent_names("skill", entry)) or "(none)")
     if plock and not lock:
         # Which copy the rows above describe. Only worth saying when there is
         # no user-scope record to confuse it with.
@@ -962,7 +991,7 @@ def cmd_edit(argv):
         # lock, hiding the edit from `boost drift` (which would then fall
         # through to UPSTREAM_MOVED instead of LOCAL_EDITS). The journal is
         # the record of the edit; drift/attest compare honestly instead.
-        if util.sha256_dir(sdir) == row.get("sha256"):
+        if util.sha256_matches(sdir, row.get("sha256")):
             return False
         row["updated_at"] = util.now_iso()
         return True
@@ -1315,7 +1344,7 @@ def cmd_log(argv):
                 hint="re-tap it with `boost tap`, or see `boost taps`") from None
         if not tap.is_cloned:
             raise BoostError("tap %s is not cloned" % tap.name,
-                            hint="run `boost update %s`" % tap.name)
+                            hint="run `boost update %s`" % util.shell_arg(tap.name))
         if args.as_json:
             # `log_entries`, not a re-split of the display format: the columns
             # there are two-space separated and an author or subject may

{boost_skill_cli-1.2.207 → boost_skill_cli-1.2.209}/boost_cli/commands/intelligence.py

@@ -168,10 +168,9 @@ def _install_generated(name: str, text: str, yes: bool = False) -> bool:
         src = Path(td) / name
         src.mkdir()
         # newline="\n": install_from_path copies this into the canonical
-        # store and records util.sha256_dir over it, which hashes read_bytes.
-        # Every comparison against that hash is local today, so this is
-        # latent rather than live — but the digest it stamps into the lock
-        # would otherwise depend on which OS generated the skill.
+        # store and records util.sha256_dir over it. That hash folds CRLF
+        # now, but the copy itself would still carry whichever line endings
+        # the generating OS wrote.
         (src / "SKILL.md").write_text(text, encoding="utf-8", newline="\n")
         try:
             res = store.install_from_path(src, name=name, tap_label="local")