boost-skill-cli 1.2.186__tar.gz → 1.2.188__tar.gz

{boost_skill_cli-1.2.186 → boost_skill_cli-1.2.188}/PKG-INFO

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

{boost_skill_cli-1.2.186 → boost_skill_cli-1.2.188}/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.186'
-__version_tuple__ = version_tuple = (1, 2, 186)
+__version__ = version = '1.2.188'
+__version_tuple__ = version_tuple = (1, 2, 188)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.186 → boost_skill_cli-1.2.188}/boost_cli/commands/bmad.py

@@ -370,7 +370,7 @@ def _autopilot_on(scope, requested_host=None, force: bool = False) -> int:
     if skipped:
         out.warn("kept your edits to %d persona(s): %s"
                  % (len(skipped), ", ".join(skipped)))
-        out.dim("  delete the file to let `boost bmad on` restore the stock version")
+        out.dim("  delete the file to let `boost bmad on` restore the stock version", wrap=True)
     out.dim("  personas → %s" % paths.tilde(agents))
     for host in hosts:
         out.dim("  hooks    → %s (%s + %s)"
@@ -378,7 +378,7 @@ def _autopilot_on(scope, requested_host=None, force: bool = False) -> int:
                    hookhost.translate(host, "SessionStart"),
                    hookhost.translate(host, "UserPromptSubmit")))
     out.dim("  every substantive prompt now names its lead persona and its "
-            "definition of done; trivial asks are left alone")
+            "definition of done; trivial asks are left alone", wrap=True)
     # Hook edits reach open sessions through the settings watcher, but Claude
     # Code only watches an agents dir that existed when the session started. So
     # a run that creates the dir starts banners before their personas can load;
@@ -399,7 +399,7 @@ def _autopilot_off(scope, force: bool = False) -> int:
     journal.log("bmad-autopilot", "off", scope=scope, personas=len(removed))
     out.ok("BMAD autopilot OFF (%s) — removed %d persona(s) and %d hook(s)"
            % (scope, len(removed), hooks_removed))
-    out.dim("  hand-edited personas were left in place")
+    out.dim("  hand-edited personas were left in place", wrap=True)
     return 0
 
 
@@ -542,7 +542,7 @@ def _personas_scope(scope) -> None:
                % (p.character, p.title, p.module, mark), width=16)
     out.dim("  → %s" % paths.tilde(agents))
     if all(state == "absent" for state in states.values()):
-        out.dim("  install them with `boost bmad on`")
+        out.dim("  install them with `boost bmad on`", wrap=True)
 
 
 # ------------------------------------------------------------------- provisioning
@@ -605,7 +605,7 @@ def _install(scope, modules, do_startup) -> int:
                      "`boost bmad init` in each repo that uses them"
                      % " and ".join(needs_runtime))
         else:
-            out.dim("  run `boost bmad init` in a project for its _bmad/ workflow runtime")
+            out.dim("  run `boost bmad init` in a project for its _bmad/ workflow runtime", wrap=True)
     else:
         ver, n = _install_project_runtime(modules)
         out.ok("installed BMAD in %s (%d skills, v%s)" % (Path.cwd(), n, ver))
@@ -794,7 +794,7 @@ def _disable(scope, force: bool = False) -> int:
     _set_scope_state(scope, startup=False, disabled=True)
     journal.log("bmad-disable", scope, count=moved)
     out.ok("quarantined %d BMAD skill(s) (%s)" % (moved, scope))
-    out.dim("  restore with `boost bmad enable --scope %s`" % scope)
+    out.dim("  restore with `boost bmad enable --scope %s`" % scope, wrap=True)
     return 0
 
 
@@ -847,7 +847,7 @@ def _doctor() -> int:
                % (_count_skills(_skills_dir(scope)), _on_off(st.get("installed"))))
     out.dim("  project = %s" % Path.cwd())
     if not any(_get_scope_state(s).get("autopilot") for s in ("global", "project")):
-        out.dim("  turn it on with `boost bmad on`")
+        out.dim("  turn it on with `boost bmad on`", wrap=True)
     return 0
 
 

{boost_skill_cli-1.2.186 → boost_skill_cli-1.2.188}/boost_cli/commands/configuration.py

@@ -39,6 +39,7 @@ from ..core import (
     rag,
     registry,
     rules,
+    scopes,
     selfupdate,
     serve,
     store,
@@ -477,7 +478,7 @@ def cmd_compact(argv) -> int:
     out.ok("compacted %d tap(s) · %s freed" % (changed, util.human_size(freed)))
     if not args.reclone:
         out.dim("  `boost compact --reclone` also drops already-downloaded "
-                "git objects")
+                "git objects", wrap=True)
     return rc
 
 
@@ -557,7 +558,7 @@ def cmd_create(argv) -> int:
         if owner and not out.confirm(
                 "%s is already installed from %s — replace it?" % (name, owner)):
             out.warn("not installed: %s is already installed from %s" % (name, owner))
-            out.dim("  next: edit it, then `boost import %s`" % _tilde(target))
+            out.dim("  next: edit it, then `boost import %s`" % _tilde(target), wrap=True)
             return 0
         res = store.install_from_path(target, name=name)
         out.ok("%s %s → %s" % ("replaced" if owner else "installed", name, _tilde(res.dest)))
@@ -566,7 +567,7 @@ def cmd_create(argv) -> int:
         from .pkg import _warn_unwritable
         _warn_unwritable(res)
     else:
-        out.dim("  next: edit it, then `boost import %s`" % _tilde(target))
+        out.dim("  next: edit it, then `boost import %s`" % _tilde(target), wrap=True)
     return 0
 
 
@@ -596,7 +597,7 @@ def _warn_invalid_policy_values() -> None:
         out.warn("ignoring %s = %s in policy.json — expects %s"
                  % (key, json.dumps(value), expected))
         out.dim("  using the default; fix it with `boost policy set %s <%s>`"
-                % (key, policy.spec_for(key)))
+                % (key, policy.spec_for(key)), wrap=True)
 
 
 def cmd_policy(argv) -> int:
@@ -767,7 +768,7 @@ def cmd_policy(argv) -> int:
                  + (" (%d unpinned item(s): %s)"
                     % (len(unpinned), ", ".join(unpinned)) if unpinned else ""))
     for note in sorted(not_checked):
-        out.dim("  not checked: %s" % note)
+        out.dim("  not checked: %s" % note, wrap=True)
     if violations:
         out.table([(label, v) for _n, _k, label, v in violations],
                   headers=("ITEM", "VIOLATION"), whole=("ITEM",))  # `uninstall`
@@ -1013,7 +1014,7 @@ def _report_rc_plan(plan, install: bool, shell: str) -> None:
     out.info(verb % _tilde(plan.path))
     for line in _rc_plan_diff(plan):
         out.dim("  " + line)
-    out.dim("  re-run without --dry-run to apply")
+    out.dim("  re-run without --dry-run to apply", wrap=True)
 
 
 def _rc_plan_diff(plan) -> list[str]:
@@ -1087,7 +1088,7 @@ def cmd_completions(argv) -> int:
                   "into" if args.install else "from", _tilde(plan.path)))
         if args.install:
             out.dim("  restart your shell (or run `exec %s`) to pick it up"
-                    % detected)
+                    % detected, wrap=True)
         return 0
 
     shell = detected if detected in ("bash", "zsh", "fish") else "bash"
@@ -1262,7 +1263,7 @@ def cmd_schedule(argv) -> int:
             out.kv("next run", next_run.strftime("%Y-%m-%d %H:%M (approx)")
                    if next_run else "unknown")
         else:
-            out.dim("  enable with `boost schedule enable --interval 6h|12h|daily`")
+            out.dim("  enable with `boost schedule enable --interval 6h|12h|daily`", wrap=True)
         return 0
 
     if args.action == "enable":
@@ -1518,13 +1519,10 @@ def _tool_info(args: dict):
     if src.get("description"):
         lines.append("description: %s" % src["description"])
     if entry:
-        if kind == "skill":
-            agents_s = ", ".join(entry.get("agents") or []) or "none"
-        else:
-            # Materialized kinds record their reach per materialization.
-            agents_s = ", ".join(sorted(
-                {m.get("agent", "?")
-                 for m in entry.get("materializations") or []})) or "none"
+        # Only the agents boost still writes for: a recorded row whose agent
+        # was disabled is kept for uninstall, not reached (same as `info`).
+        agents_s = ", ".join(
+            integrity.written_agent_names(kind, entry)) or "none"
         lines.extend(("installed: yes (%s)" % entry.get("installed_at", "?"),
                       "agents: %s" % agents_s))
         if entry.get("pinned"):
@@ -1596,11 +1594,10 @@ def _tool_install(args: dict):
     lines.append("quality score: %d/100" % res.score)
     if res.conflicts:
         lines.append("conflicts (left in place): %s" % ", ".join(res.conflicts))
-    if res.unwritable:
-        lines.append("not %s, directory not writable: %s — ask the user to "
-                     "`chmod u+w` it, then `boost sync`"
-                     % ("linked" if res.kind == "skill" else "written",
-                        ", ".join(res.unwritable)))
+    lines.extend("not %s: %s — ask the user to run %s, then `boost sync`"
+                 % ("linked" if res.kind == "skill" else "written",
+                    *store.unwritable_refusal(adir))
+                 for adir in res.unwritable)
     for adir, block in res.blocked:
         lines.append("not %s: %s — ask the user to %s, then `boost sync`"
                      % ("linked" if res.kind == "skill" else "written",
@@ -1621,7 +1618,13 @@ def _tool_install(args: dict):
 
 
 def _tool_doctor(args: dict):
-    plan = store.sync_plan()
+    # Same rule as CLI `boost doctor`: one agent whose `dir` cannot resolve
+    # makes `known_agents` raise, and both `sync_plan` and the materialization
+    # digest below reach it. Name the key and skip those two, rather than let
+    # the whole reply become the bare `expand` error, which names a variable
+    # but not the config key the user has to change.
+    agent_errs = agents.check()
+    plan = store.sync_plan() if not agent_errs else {}
     issues = sum(len(v) for v in plan.values())
     # Two different questions, and answering the second with the first is what
     # made this tool disagree with every other one. `taps` is the literal clone
@@ -1658,14 +1661,33 @@ def _tool_doctor(args: dict):
     _MAT_ISSUE_LABEL = {
         integrity.STATUS_MODIFIED: "modified since install",
         integrity.STATUS_UNREACHABLE: "reaches no agent boost writes",
+        # sync_plan skips these (a repair would recreate the deleted repo),
+        # so without a label here this surface would be the one calling it
+        # healthy.
+        integrity.STATUS_STRANDED: "installed --local into a directory that "
+                                   "no longer exists (`boost uninstall` "
+                                   "drops the record)",
     }
     mat_issues = [
         "%s %s: %s" % (kind, n, _MAT_ISSUE_LABEL[st])
         for kind in ("rule", "workflow")
         for n, e in sorted(everything[kind].items())
-        if (st := integrity.materialized_status(n, e, kind)) in _MAT_ISSUE_LABEL]
+        # Stranded is asked first: materialized_status answers "quarantined"
+        # for a quarantined row, and a quarantined row whose repo is gone
+        # cannot be released either -- uninstall is still its one remedy. It
+        # reads only the recorded base, so it stays answerable when an agent
+        # dir does not resolve; every other status needs the agents.
+        if (st := integrity.STATUS_STRANDED if scopes.stranded(e)
+                else None if agent_errs
+                else integrity.materialized_status(n, e, kind))
+        in _MAT_ISSUE_LABEL]
     lines.extend(mat_issues)
-    total = issues + len(mat_issues)
+    agent_lines = ["agents.%s.dir: %s — ask the user to fix it with `boost "
+                   "config set agents.%s.dir <dir>`; link and materialization "
+                   "checks were skipped" % (n, e.message, n)
+                   for n, e in agent_errs]
+    lines.extend(agent_lines)
+    total = issues + len(mat_issues) + len(agent_lines)
     # A machine with no taps has nothing to disagree about, so every check
     # above passes and the old reply called it "healthy" — directly under the
     # line saying `taps: 0 (0 items available)`. That is the one state where
@@ -1695,7 +1717,8 @@ def _tool_doctor(args: dict):
     if total == 0:
         if tapped:
             lines.append("healthy — no issues found")
-    elif mat_issues or cfg_err:
+    elif mat_issues or cfg_err or agent_lines:
+        # Not `boost sync`: an unresolvable agent dir makes sync refuse too.
         lines.append("%d issue(s) — run `boost doctor` for details" % total)
     else:
         lines.append("%d issue(s) — run `boost sync` to fix" % issues)
@@ -2201,7 +2224,7 @@ def cmd_mcp(argv) -> int:
             note = "  — outside this $HOME, refused without --force" \
                 if escape else ""
             out.dim("  writes %s%s" % (cfg, note))
-        out.dim("  dry run — nothing was %sed, nothing tapped" % verb)
+        out.dim("  dry run — nothing was %sed, nothing tapped" % verb, wrap=True)
         return 0
 
     # After the host name is validated and before anything is registered. The

{boost_skill_cli-1.2.186 → boost_skill_cli-1.2.188}/boost_cli/commands/discovery.py

@@ -28,6 +28,7 @@ from ..core import (
     catalog,
     config,
     gitutil,
+    integrity,
     journal,
     lockfile,
     paths,
@@ -525,6 +526,55 @@ def _fetch_shards(args) -> int:
     return 0
 
 
+def _fetch_index(args) -> int:
+    """`--fetch-index`: download the published keyword index for every tap.
+
+    The keyword twin of `--fetch-shards`, and the one every machine can use:
+    a keyword shard needs no embedding backend and no key. It is also the only
+    way a machine restored with `boost catalog --import` — catalogues, no
+    clones — gets an index of item *bodies* rather than of their labels.
+    """
+    from ..core import shards
+    if not registry.list_taps():
+        raise BoostError("no taps configured — nothing to fetch",
+                        hint="add registries with `boost tap --defaults`")
+    manifest = shards.fetch_manifest()
+    why = shards.keyword_incompatible(manifest)
+    if why:
+        raise BoostError("the published keyword index cannot serve this "
+                        "machine — %s" % why,
+                        hint="`boost reindex` builds it locally instead",
+                        wrap=True)
+    commits = rag._tap_commits()
+    by_name = {t.name: commits.get(t.safe_name, "") for t in registry.list_taps()}
+    results = shards.sync_keyword(
+        list(by_name), by_name, manifest=manifest,
+        built=rag.complete_tap_commits(),
+        on_event=None if args.as_json else _shard_event)
+    if args.as_json:
+        print(json.dumps({"keyword": 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"]
+    if got:
+        out.ok("imported the keyword index for %d tap(s), %s items"
+               % (len(got), format(sum(int(r.get("docs") or 0) for r in got),
+                                   ",")))
+    if current:
+        out.info(out.role("%d tap(s) already indexed at the published commit"
+                          % len(current), "muted"))
+    if not got and not current:
+        out.warn("no published keyword index matched your taps")
+    missing = [r["tap"] for r in results
+               if r["status"] not in ("imported", "current")]
+    if missing:
+        out.info(out.role("%d tap(s) without a usable published index: %s"
+                          % (len(missing), ", ".join(missing[:5])
+                             + (" …" if len(missing) > 5 else "")), "muted"))
+        out.info("`boost reindex` indexes those locally")
+    return 0
+
+
 def _shard_event(tap: str, status: str, detail: str) -> None:
     """Progress for one shard, quiet enough to run over forty taps."""
     if status == "downloading":
@@ -555,6 +605,10 @@ def cmd_reindex(argv):
     p.add_argument("--fetch-shards", action="store_true",
                    help="download and import published vectors for every tap "
                         "that has them, instead of embedding locally")
+    p.add_argument("--fetch-index", action="store_true",
+                   help="download and import the published keyword index for "
+                        "every tap at its published commit, instead of "
+                        "building it locally (no key or extra needed)")
     p.add_argument("--json", action="store_true", dest="as_json",
                    help="machine-readable output")
     args = p.parse_args(argv)
@@ -562,6 +616,8 @@ def cmd_reindex(argv):
         return _shard_io(args)
     if args.fetch_shards:
         return _fetch_shards(args)
+    if args.fetch_index:
+        return _fetch_index(args)
     if not registry.list_taps():
         raise BoostError("no taps configured — nothing to index",
                         hint="add the recommended registries with `boost tap --defaults`")
@@ -613,8 +669,9 @@ def cmd_reindex(argv):
         out.warn("%d of %d indexed items have no body text — their registries "
                  "are not cloned here, so only their catalog metadata was "
                  "indexed, and that metadata is %.1f%% of everything this "
-                 "index holds. Clone them with `boost update`, then re-run "
-                 "`boost reindex --force` to index their bodies."
+                 "index holds. `boost reindex --fetch-index` downloads "
+                 "their published index; or clone them with `boost update` "
+                 "and re-run `boost reindex --force`."
                  % (stats["metadata_only"], stats["docs"], meta_pct),
                  wrap=True)
     if args.dense:
@@ -1190,7 +1247,8 @@ def cmd_recommend(argv):
         line += " · also: " + ", ".join(extra_kw)
     out.info(out.role("%s  (%s)" % (line, _tilde(target)), "muted"))
     if not shown:
-        out.info("no recommendations for this stack — try `boost search <keyword>`")
+        print(out.empty_state("no recommendations for this stack",
+                              hint="try `boost search <keyword>`", wrap=True))
         return 0
     if used_curated_fallback:
         out.info("no stack-specific matches — curated picks instead:")
@@ -2056,9 +2114,9 @@ def cmd_browse(argv):
         for conflict in res.conflicts:
             out.warn("conflict: %s exists and is not a symlink" % _tilde(conflict))
         for adir in res.unwritable:
-            out.warn("not %s: %s is not writable — `chmod u+w %s`, then "
-                     "`boost sync`" % ("linked" if res.kind == "skill" else "written",
-                                       _tilde(adir), _tilde(adir)))
+            out.warn("not %s: %s — %s, then `boost sync`"
+                     % ("linked" if res.kind == "skill" else "written",
+                        *store.unwritable_refusal(adir)), wrap=True)
         for adir, block in res.blocked:
             out.warn("not %s: %s — %s, then `boost sync`"
                      % ("linked" if res.kind == "skill" else "written",
@@ -2103,7 +2161,9 @@ def cmd_trending(argv):
             return 0
         out.heading("curated picks (no local install data yet)")
         if not curated:
-            out.info("no curated skills available — add taps with `boost tap --defaults`")
+            print(out.empty_state("no curated skills available",
+                                  hint="add taps with `boost tap --defaults`",
+                                  wrap=True))
             return 0
         # reserve name/version/kind columns
         descw = max(out.term_width() - 34, 24)
@@ -2199,7 +2259,10 @@ def cmd_stats(argv):
         # was sorted and a skill's printed raw lock/install order, which read
         # like two commands disagreeing about the same fact rather than one
         # command describing two kinds of item.
-        out.kv("agents", ", ".join(lockfile.agent_names(kind, lock)) or "none")
+        # Written agents only: a row boost no longer writes is kept so an
+        # uninstall can reverse it, not because the item reaches that agent.
+        out.kv("agents",
+               ", ".join(integrity.written_agent_names(kind, lock)) or "none")
         out.kv("pinned", "yes" if lock.get("pinned") else "no")
         if lock.get("quarantined"):
             out.kv("quarantined", "yes")

{boost_skill_cli-1.2.186 → boost_skill_cli-1.2.188}/boost_cli/commands/hooks.py

@@ -92,8 +92,9 @@ def _list(scope, host, event=None, as_json=False) -> int:
             for r in rows]}, indent=2))
         return 0
     if not rows:
-        out.info("no boost-managed hooks" + (" in %s scope" % scope if scope else "")
-                 + (" for event '%s'" % event if event else ""))
+        print(out.empty_state(
+            "no boost-managed hooks" + (" in %s scope" % scope if scope else "")
+            + (" for event '%s'" % event if event else ""), wrap=True))
         return 0
     out.table(
         [(r["name"], r["host"], r["scope"], r["event"], r["matcher"] or "-",

{boost_skill_cli-1.2.186 → boost_skill_cli-1.2.188}/boost_cli/commands/info.py

@@ -122,6 +122,15 @@ def _materialized_text(name: str, kind: str, entry: dict):
                 hint="inspect with `boost verify %s`, then `boost reinstall "
                      "%s` to restore the locked copy" % (name, name),
                 wrap=True)
+        if st == integrity.STATUS_STRANDED:
+            # Not MISSING's `boost sync` / `reinstall`: both would recreate
+            # the deleted repo. And not a silent fall-through to the tap
+            # copy, which is what an unhandled status here amounted to.
+            raise BoostError(
+                "%s %s was installed --local into %s, which no longer exists"
+                % (kind, name, paths.tilde(Path(entry["base"]))),
+                hint="`boost uninstall %s` drops the record" % name,
+                wrap=True)
         if st == integrity.STATUS_MISSING:
             raise BoostError(
                 "%s %s is in the lock file but its materialized artifacts "
@@ -223,17 +232,38 @@ def _print_wrapped(text: str) -> None:
 
 # ---------------------------------------------------------------- commands
 
-def _materialized_agents(entry):
-    """Abbreviated agent column for a rule/workflow, from its materializations."""
-    agent_names = [m.get("agent", "") for m in entry.get("materializations") or []]
-    return "·".join(a.split("-")[0] for a in agent_names)
+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`)."""
+    return "·".join(a.split("-")[0]
+                    for a in integrity.written_agent_names(kind, entry))
+
+
+def _scope_flag(entry: dict) -> list[str]:
+    """The FLAGS cell's word for a rule/workflow installed ``--local``.
 
+    Those rows live in the user lock beside the user-scope ones, so without
+    this a rule written into another checkout -- or into one since deleted --
+    printed byte-identical to one in ``~/.claude``. ``project:<base>`` names
+    the checkout; ``(gone)`` says the directory no longer exists, which is
+    the case every other surface now reports as ``stranded``.
+    """
+    if (entry.get("scope") != scopes.SCOPE_PROJECT
+            or not scopes.names_a_directory(entry.get("base"))):
+        return []
+    where = "project:" + paths.tilde(Path(entry["base"]))
+    if scopes.stranded(entry):
+        return [out.role(where + " (gone)", "danger")]
+    return [out.role(where, "muted")]
 
-def _kind_table(heading, items, extra=None):
+
+def _kind_table(heading, kind, items, extra=None):
     """Render an installed rule/workflow table. ``extra`` is an optional
     ``(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`)."""
+    count line names ``kind``, which also decides which agents count as
+    written — passed explicitly, so renaming a heading can't change it."""
     out.heading(heading)
+    noun = kind
     # 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.
@@ -242,9 +272,11 @@ def _kind_table(heading, items, extra=None):
     for name in sorted(items):
         e = items[name]
         quarantined = bool(e.get("quarantined"))
-        agents_cell = "—" if quarantined else _materialized_agents(e)
+        agents_cell = ("—" if quarantined
+                       else _materialized_agents(noun, e) or "none")
         flags = ([out.aurora("pinned", "yellow")] if e.get("pinned") else []) + \
-                ([out.aurora("quarantined", "pink")] if quarantined else [])
+                ([out.aurora("quarantined", "pink")] if quarantined else []) + \
+                _scope_flag(e)
         row = [name, e.get("version", "?"), e.get("tap", "?"),
                agents_cell]
         if extra:
@@ -256,7 +288,6 @@ def _kind_table(heading, items, extra=None):
                    headers[4])
     # NAME is what `uninstall`/`update`/`cat` take: shown whole or dropped.
     out.table(rows, headers=headers, whole=("NAME",))
-    noun = heading.split()[-1][:-1]  # "installed rules" -> "rule"
     print("  " + out.aurora("%d %s%s installed"
                             % (len(rows), noun, "" if len(rows) == 1 else "s"),
                             "cyan"))
@@ -370,9 +401,10 @@ def cmd_list(argv):
                               % (projectlock.LOCK_DIRNAME,
                                  projectlock.LOCK_FILENAME), "muted"))
     if rules:
-        _kind_table("installed rules", rules)
+        _kind_table("installed rules", "rule", rules)
     if workflows:
-        _kind_table("installed workflows", workflows, extra=("SLOT", "slot"))
+        _kind_table("installed workflows", "workflow", workflows,
+                    extra=("SLOT", "slot"))
     return 0
 
 
@@ -398,9 +430,10 @@ def _info_materialized(name: str, kind: str, entry: dict, as_json: bool) -> int:
     directory, which these kinds do not have.
     """
     desc = _catalog_description(name, entry.get("tap"))
+    stranded = scopes.stranded(entry)
     if as_json:
         print(json.dumps({"name": name, "kind": kind, "description": desc,
-                         "installed": entry}, indent=2))
+                         "stranded": stranded, "installed": entry}, indent=2))
         return 0
     out.heading(name)
     badges = [out.badge("installed %s" % kind, "green")]
@@ -420,6 +453,12 @@ def _info_materialized(name: str, kind: str, entry: dict, as_json: bool) -> int:
         out.kv("slot", str(entry["slot"]))
     if entry.get("scope"):
         out.kv("scope", str(entry["scope"]))
+    if (entry.get("scope") == scopes.SCOPE_PROJECT
+            and scopes.names_a_directory(entry.get("base"))):
+        # "scope project" alone does not say which checkout -- or that it is
+        # gone, which is the one fact here that changes what to do next.
+        out.kv("base", paths.tilde(Path(entry["base"]))
+               + (" (gone)" if stranded else ""))
     if entry.get("source_file"):
         out.kv("source", str(entry["source_file"]))
     if entry.get("commit"):
@@ -437,11 +476,15 @@ def _info_materialized(name: str, kind: str, entry: dict, as_json: bool) -> int:
         # nothing. Printing the stale agent list here reads as a lie about
         # files that were just removed.
         out.kv("materialized", "(removed — quarantined)")
+    elif stranded:
+        # Every recorded row pointed into the deleted repo, so listing the
+        # agents would describe files that went with it.
+        out.kv("materialized", "(none — its repo no longer exists; "
+               "`boost uninstall %s` drops the record)" % name, wrap=True)
     elif integrity.reaches_no_agent(kind, entry):
-        # `agent_names` lists every recorded row, so the dangerous case
-        # advertised the five agents the rule does not reach while the
-        # harmless no-rows case showed none — the two read backwards from
-        # how a user judges risk.
+        # Every recorded row is unwritten, so the line below would print
+        # "(none)" -- the same words as the harmless no-rows case. Say why
+        # instead, because the two read opposite ways to a user judging risk.
         # Both halves inflect. One row is the commonest shape by far -- most
         # items record exactly one -- so a noun-only plural put the ungrammar
         # on the usual path and hid it on the rare one.
@@ -452,7 +495,8 @@ def _info_materialized(name: str, kind: str, entry: dict, as_json: bool) -> int:
                             "s" if rows == 1 else ""))
     else:
         out.kv("materialized",
-               ", ".join(lockfile.agent_names(kind, entry)) or "(none)")
+               ", ".join(integrity.written_agent_names(kind, entry))
+               or "(none)")
     out.kv("pinned", "yes" if entry.get("pinned") else "no")
     out.kv("quarantined", "yes" if entry.get("quarantined") else "no")
     return 0
@@ -1009,7 +1053,9 @@ def _show_crashes(limit, as_json=False):
             for r in reports[:limit]]}, indent=2))
         return 0
     if not reports:
-        out.info("no crash reports — nothing has blown up (that boost noticed)")
+        print(out.empty_state(
+            "no crash reports — nothing has blown up (that boost noticed)",
+            wrap=True))
         return 0
     out.heading("crash reports in %s" % ldir)
     for r in reports[:limit]:
@@ -1088,7 +1134,7 @@ def cmd_log(argv):
         print(json.dumps({"kind": "activity", "events": events}, indent=2))
         return 0
     if not events:
-        out.info("no activity yet")
+        print(out.empty_state("no activity yet"))
         return 0
     out.heading("activity")
     action_roles = {"install": "success", "uninstall": "danger"}
@@ -1326,8 +1372,8 @@ def cmd_tag(argv):
             print(json.dumps(mapping, indent=2, sort_keys=True))
             return 0
         if not mapping:
-            out.info("no tags yet")
-            out.info(out.role("hint: boost tag <skill> +mytag", "muted"))
+            print(out.empty_state("no tags yet",
+                                  hint="boost tag <skill> +mytag"))
             return 0
         out.table([("#" + t, ", ".join(mapping[t])) for t in sorted(mapping)],
                   headers=("TAG", "SKILLS"), whole=("TAG",))  # `list --tag`