boost-skill-cli 1.2.134__tar.gz → 1.2.136__tar.gz

{boost_skill_cli-1.2.134 → boost_skill_cli-1.2.136}/CLAUDE.md

@@ -301,7 +301,7 @@ line coverage. Target `boost_cli/core` behavior with assertions, not just import
   information the line exists to carry, and a hash split across two lines
   cannot be compared by eye. **A backtick span is one atomic token**, spaces
   and all — `doctor` and `search` both interpolate `dense.fix_hint()`, whose
-  answers end in `pip install 'boost-skill-cli[rag]'`, and a wrap that splits
+  answers end in `pip install "boost-skill-cli[rag]"`, and a wrap that splits
   that hands the user a command which does not run. A token wider than the pane
   overflows whole rather than breaking. Wrap *before* adding color: `out.role`
   brackets its argument with a start code and a reset, so coloring first and
@@ -645,10 +645,12 @@ attempt for an hour (`RETRY_AFTER`): measured on a 5-chunk store, each search
 paid one failed fetch (~3.6 s against 0.1 s) while doctor said "active".
 `boost reindex --dense` retries at once, because it is the remedy the hint
 names. `dense.ready()` still answers for the store alone. `dense.fix_hint()` maps
-whichever state it is to the one next action — `boost doctor`, `boost search`,
-the MCP `SEARCH ENGINE` line and both shard surfaces (`reindex --fetch-shards`,
-`update --shards`) all read that same table, so they can't give contradictory
-advice.
+whichever state it is to the one next action — `boost doctor`, `boost search`
+and the MCP `SEARCH ENGINE` line all read that same table, so they can't give
+contradictory advice. The shard surfaces (`reindex --fetch-shards`, `update
+--shards`, `quickstart` and the vector refresh in `boost update`) answer a refused
+manifest through `shards.remedy()`, which hands back to that table, with the
+whole status, whenever the store or a missing provider is the real answer.
 
 **The dense store ranks twice, and `vec0` is why.** `sqlite-vec` has no ANN
 index: a float32 `MATCH` scores *every* vector in the store, which on a real

{boost_skill_cli-1.2.134/boost_skill_cli.egg-info → boost_skill_cli-1.2.136}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.134
+Version: 1.2.136
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0
@@ -186,7 +186,9 @@ boost quickstart                                     # downloads prebuilt vector
 
 `boost quickstart` is the fast path: it taps the starter registries **pinned to
 the commits the published vectors were built from**, then downloads and imports
-those vectors. Embedding is ~1.2 s/chunk on CPU — hours for a real corpus —
+those vectors. It pins them even before the extra is installed, so running it
+again once the extra is in place picks up the vectors; `--no-vectors` leaves the
+taps unpinned, following their branch. Embedding is ~1.2 s/chunk on CPU — hours for a real corpus —
 and importing the same rows takes 0.12 s, so the difference between the two is
 the difference between semantic search being available and being reachable.
 
@@ -216,20 +218,22 @@ tap to the commit the published vectors describe. Two different targets, so
 they are separate modes rather than one pass, and `--shards --taps-only` is
 refused rather than silently picking one.
 
-Because vectors are keyed to a registry's commit, `quickstart` **pins** each tap
-it fetches vectors for, and `boost update` skips a pinned tap rather than moving
-it out from under them (`--force` moves it anyway and drops the pin). A pinned
-tap with *no* clone is not skipped — there is nothing to hold still, so it is
-cloned and checked out at its pin; if that pin cannot be reached the clone is
-removed rather than left on HEAD with a pin that no longer describes it, and
-`compact --reclone` follows the same rule. When a tap does move, boost checks whether a newer shard exists for the new commit and
-imports it; if none does, it says so instead of leaving stale vectors looking
-fresh. `boost search` never refreshes taps behind your back, and never checks
-the manifest either — acting on that answer means moving taps and downloading
-hundreds of megabytes, which cannot happen inside a sub-second search. It prints
-one line when the taps or the prebuilt vectors are more than two weeks old and
-leaves the fetching to `boost update --taps-only` or `boost update --shards`.
-Every download is checked against the sha256 in the manifest and refused on a
+Because vectors are keyed to a registry's commit, `quickstart` **pins** every
+registry that has published vectors, even when the `[rag]` extra is missing and
+the vectors cannot load yet, and `boost update` skips a pinned tap rather than
+moving it out from under them (`--force` moves it anyway and drops the pin). A
+pinned tap with *no* clone is not skipped — there is nothing to hold still, so
+it is cloned and checked out at its pin; if that pin cannot be reached the
+clone is removed rather than left on HEAD with a pin that no longer describes
+it, and `compact --reclone` follows the same rule. When a tap does move, boost
+checks whether a newer shard exists for the new commit and imports it; if none
+does, it says so instead of leaving stale vectors looking fresh. `boost search`
+never refreshes taps behind your back, and never checks the manifest either —
+acting on that answer means moving taps and downloading hundreds of megabytes,
+which cannot happen inside a sub-second search. It prints one line when the
+taps or the prebuilt vectors are more than two weeks old and leaves the
+fetching to `boost update --taps-only` or `boost update --shards`. Every
+download is checked against the sha256 in the manifest and refused on a
 mismatch, and shards for a registry that has moved since publication are
 refused rather than merged — stale vectors would otherwise look fresh forever.
 

{boost_skill_cli-1.2.134 → boost_skill_cli-1.2.136}/README.md

@@ -144,7 +144,9 @@ boost quickstart                                     # downloads prebuilt vector
 
 `boost quickstart` is the fast path: it taps the starter registries **pinned to
 the commits the published vectors were built from**, then downloads and imports
-those vectors. Embedding is ~1.2 s/chunk on CPU — hours for a real corpus —
+those vectors. It pins them even before the extra is installed, so running it
+again once the extra is in place picks up the vectors; `--no-vectors` leaves the
+taps unpinned, following their branch. Embedding is ~1.2 s/chunk on CPU — hours for a real corpus —
 and importing the same rows takes 0.12 s, so the difference between the two is
 the difference between semantic search being available and being reachable.
 
@@ -174,20 +176,22 @@ tap to the commit the published vectors describe. Two different targets, so
 they are separate modes rather than one pass, and `--shards --taps-only` is
 refused rather than silently picking one.
 
-Because vectors are keyed to a registry's commit, `quickstart` **pins** each tap
-it fetches vectors for, and `boost update` skips a pinned tap rather than moving
-it out from under them (`--force` moves it anyway and drops the pin). A pinned
-tap with *no* clone is not skipped — there is nothing to hold still, so it is
-cloned and checked out at its pin; if that pin cannot be reached the clone is
-removed rather than left on HEAD with a pin that no longer describes it, and
-`compact --reclone` follows the same rule. When a tap does move, boost checks whether a newer shard exists for the new commit and
-imports it; if none does, it says so instead of leaving stale vectors looking
-fresh. `boost search` never refreshes taps behind your back, and never checks
-the manifest either — acting on that answer means moving taps and downloading
-hundreds of megabytes, which cannot happen inside a sub-second search. It prints
-one line when the taps or the prebuilt vectors are more than two weeks old and
-leaves the fetching to `boost update --taps-only` or `boost update --shards`.
-Every download is checked against the sha256 in the manifest and refused on a
+Because vectors are keyed to a registry's commit, `quickstart` **pins** every
+registry that has published vectors, even when the `[rag]` extra is missing and
+the vectors cannot load yet, and `boost update` skips a pinned tap rather than
+moving it out from under them (`--force` moves it anyway and drops the pin). A
+pinned tap with *no* clone is not skipped — there is nothing to hold still, so
+it is cloned and checked out at its pin; if that pin cannot be reached the
+clone is removed rather than left on HEAD with a pin that no longer describes
+it, and `compact --reclone` follows the same rule. When a tap does move, boost
+checks whether a newer shard exists for the new commit and imports it; if none
+does, it says so instead of leaving stale vectors looking fresh. `boost search`
+never refreshes taps behind your back, and never checks the manifest either —
+acting on that answer means moving taps and downloading hundreds of megabytes,
+which cannot happen inside a sub-second search. It prints one line when the
+taps or the prebuilt vectors are more than two weeks old and leaves the
+fetching to `boost update --taps-only` or `boost update --shards`. Every
+download is checked against the sha256 in the manifest and refused on a
 mismatch, and shards for a registry that has moved since publication are
 refused rather than merged — stale vectors would otherwise look fresh forever.
 

{boost_skill_cli-1.2.134 → boost_skill_cli-1.2.136}/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.134'
-__version_tuple__ = version_tuple = (1, 2, 134)
+__version__ = version = '1.2.136'
+__version_tuple__ = version_tuple = (1, 2, 136)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.134 → boost_skill_cli-1.2.136}/boost_cli/commands/configuration.py

@@ -563,6 +563,8 @@ def cmd_create(argv) -> int:
         out.ok("%s %s → %s" % ("replaced" if owner else "installed", name, _tilde(res.dest)))
         if res.linked:
             out.info("linked: " + ", ".join(agents.display_name(a) for a in res.linked))
+        from .pkg import _warn_unwritable
+        _warn_unwritable(res)
     else:
         out.dim("  next: edit it, then `boost import %s`" % _tilde(target))
     return 0
@@ -767,7 +769,7 @@ def cmd_policy(argv) -> int:
         out.dim("  not checked: %s" % note)
     if violations:
         out.table([(label, v) for _n, _k, label, v in violations],
-                  headers=("ITEM", "VIOLATION"))
+                  headers=("ITEM", "VIOLATION"), whole=("ITEM",))  # `uninstall`
         print()
         out.err("%d policy violation(s) across %d installed item(s)"
                 % (len(violations), total),
@@ -1594,9 +1596,14 @@ def _tool_install(args: dict):
     if res.conflicts:
         lines.append("conflicts (left in place): %s" % ", ".join(res.conflicts))
     if res.unwritable:
-        lines.append("not linked, directory not writable: %s — ask the user to "
+        lines.append("not %s, directory not writable: %s — ask the user to "
                      "`chmod u+w` it, then `boost sync`"
-                     % ", ".join(res.unwritable))
+                     % ("linked" if res.kind == "skill" else "written",
+                        ", ".join(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",
+                        *store.link_refusal(adir, block)))
     # The same prompt-injection and secret scan `boost install` runs. This path
     # needs it more, not less: nobody is watching a terminal here, and the skill
     # was chosen and installed by an agent acting on its own. The install still
@@ -2059,13 +2066,26 @@ def _offer_boost_first(hosts: list[str]) -> None:
     try:
         builtin.ensure_tap()
         catalog.rebuild_tap(registry.get(builtin.BUILTIN_TAP))
-        store.install(catalog.resolve_one(builtin.BUILTIN_RULES[0]),
-                     only_agents=[a for a in scoped_agents if a])
+        res = store.install(catalog.resolve_one(builtin.BUILTIN_RULES[0]),
+                            only_agents=[a for a in scoped_agents if a])
     except (BoostError, OSError) as exc:
         out.warn("could not install %s: %s" % (builtin.BUILTIN_RULES[0], exc))
         return
-    out.ok("installed %s — remove it with `boost uninstall %s`"
-           % (builtin.BUILTIN_RULES[0], builtin.BUILTIN_RULES[0]))
+    from .pkg import _warn_unwritable
+    if not res.linked:
+        # Every file it was offered for refused the write. The lock records
+        # the refusal so `boost sync` can finish it, but "installed" would be
+        # a success nothing on disk backs.
+        # The reversal is named here too: the docstring promises it on every
+        # branch, and this is the one where it went missing.
+        out.warn("%s was not written anywhere yet — `boost sync` finishes it "
+                 "once the files allow it, or `boost uninstall %s` drops it"
+                 % (builtin.BUILTIN_RULES[0], builtin.BUILTIN_RULES[0]),
+                 wrap=True)
+    else:
+        out.ok("installed %s — remove it with `boost uninstall %s`"
+               % (builtin.BUILTIN_RULES[0], builtin.BUILTIN_RULES[0]))
+    _warn_unwritable(res)
 
 
 def cmd_mcp(argv) -> int:

{boost_skill_cli-1.2.134 → boost_skill_cli-1.2.136}/boost_cli/commands/discovery.py

@@ -109,7 +109,7 @@ def cmd_search(argv):
                    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,
+    p.add_argument("-k", "--limit", type=util.positive_int, default=15,
                    help="max results (default 15)")
     p.add_argument("--collapse-near-duplicates", action="store_true",
                    dest="collapse_dupes",
@@ -985,7 +985,7 @@ def _discover_live(args, tokens):
                 + (" (%d)" % it["files"] if it.get("files", 1) > 1 else ""),
                 out.plain(it.get("path", "")),
                 out.role(out.plain(it.get("url", "")), "muted")) for it in rows],
-              headers=("repo", "path", "url"))
+              headers=("repo", "path", "url"), whole=("repo",))  # `boost tap`
     # "(N)" counts files in THIS page, not the repo's skills — say so, rather
     # than letting a capped sample read as a total.
     out.info(out.role("%d repo(s) across the top %d code-search hits · live "
@@ -1082,7 +1082,7 @@ def cmd_discover(argv):
                 + (" (%d)" % it["files"] if it.get("files", 1) > 1 else ""),
                 out.plain(it.get("path", "")),
                 out.role(out.plain(it.get("url", "")), "muted")) for it in repo_rows],
-              headers=("repo", "path", "url"))
+              headers=("repo", "path", "url"), whole=("repo",))  # `boost tap`
     # `github_total` is the match count for the query `boost index` was built
     # with, which since that command took a query is not "all of GitHub".
     scope = (" matching %r" % data["query"]) if data.get("query") else ""
@@ -1226,7 +1226,9 @@ def _browse_plain(entries, why: str):
         headers.append("")
         for row, e in zip(rows, unique, strict=True):
             row.append("★" if e.get("curated") else "")
-    out.table([tuple(row) for row in rows], headers=tuple(headers))
+    # name is what the footer's `boost install <name>` takes.
+    out.table([tuple(row) for row in rows], headers=tuple(headers),
+              whole=("name",))
     out.info(out.role(
         "%s · install with `boost install <name>` · narrow with `boost search <query>`"
         % browse.plain_footer(unique), "muted"))
@@ -1479,6 +1481,7 @@ def _browse_tui(curses, entries, install=None):
     loading: set = set()
     installed_names = set(store.installed())
     do_install = install or store.install
+    from .pkg import _skipped_agent_lines  # imported here: pkg is large
     # Collapse rows that say the same thing. A registry renders one skill into
     # .claude/, .cursor/, .gemini/ and a plugin root, so 37% of a real 60,047
     # entry catalogue is a duplicate of another row. Kept as (entry, copies) so
@@ -1549,7 +1552,12 @@ def _browse_tui(curses, entries, install=None):
                 else:
                     installed_names.add(nm)
                     done.append(item)
-                    status[nm] = (browse.OK, _tilde(getattr(res, "dest", "")))
+                    # An agent the install skipped rides on the message: the
+                    # pane is the only report an in-place install gets, and a
+                    # bare path there read as every agent reached.
+                    conflicts, refused = _skipped_agent_lines(res)
+                    status[nm] = (browse.OK, " · ".join(
+                        [_tilde(getattr(res, "dest", "")), *conflicts, *refused]))
 
         t = threading.Thread(target=worker, daemon=True)
         workers.append(t)
@@ -2017,8 +2025,13 @@ 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 linked: %s is not writable — `chmod u+w %s`, then "
-                     "`boost sync`" % (_tilde(adir), _tilde(adir)))
+            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)))
+        for adir, block in res.blocked:
+            out.warn("not %s: %s — %s, then `boost sync`"
+                     % ("linked" if res.kind == "skill" else "written",
+                        *store.link_refusal(adir, block)), wrap=True)
     return 0
 
 
@@ -2066,7 +2079,8 @@ def cmd_trending(argv):
         out.table([(e["name"], "v" + e["version"], e.get("kind", "skill"),
                     out.truncate(e["description"], descw))
                    for e in curated],
-                  headers=("name", "version", "kind", "description"))
+                  headers=("name", "version", "kind", "description"),
+                  whole=("name",))  # `boost install <name>`
         return 0
     agg: dict[str, Any] = {}
     for ev in evs:  # most-recent-first, so first ts per subject is the latest
@@ -2091,7 +2105,8 @@ def cmd_trending(argv):
                 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", "kind", "description"))
+              headers=("name", "installs", "last", "kind", "description"),
+              whole=("name",))  # `boost install <name>`
     out.info(out.role("based on local install activity", "muted"))
     return 0
 

{boost_skill_cli-1.2.134 → boost_skill_cli-1.2.136}/boost_cli/commands/hooks.py

@@ -96,9 +96,12 @@ def _list(scope, host, event=None, as_json=False) -> int:
         headers=("name", "host", "scope", "event", "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.
-        # Only it: protecting `name` too let the two outgrow the pane together
-        # with nothing left to drop.
-        keep=("command",))
+        keep=("command",),
+        # `name` is whole or absent: `bmad-r…` reads like a name and is not
+        # one `hooks remove -n` accepts. Not `keep` — two never-dropped
+        # columns outgrew the pane together with nothing left to drop — so
+        # a narrow pane drops it, last, rather than clipping it.
+        whole=("name",))
     return 0
 
 

{boost_skill_cli-1.2.134 → boost_skill_cli-1.2.136}/boost_cli/commands/info.py

@@ -38,6 +38,7 @@ from ..core import (
     registry,
     rules,
     scopes,
+    staleness,
     store,
     util,
 )
@@ -251,7 +252,8 @@ def _kind_table(heading, items, extra=None):
     if extra:
         headers = (headers[0], headers[1], headers[2], headers[3], extra[0],
                    headers[4])
-    out.table(rows, headers=headers)
+    # 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"),
@@ -334,7 +336,10 @@ def cmd_list(argv):
             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"))
+        # 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"),
+                  whole=("NAME",))
         print("  " + out.aurora("%d skill%s installed%s"
                                 % (len(rows), "" if len(rows) == 1 else "s",
                                    " with tag #%s" % args.tag.lstrip("#")
@@ -344,7 +349,8 @@ def cmd_list(argv):
         rows = [(name, e.get("version", "?"), e.get("tap", "?"),
                  "·".join(a.split("-")[0] for a in e.get("agents") or []))
                 for name, e in sorted(project.items())]
-        out.table(rows, headers=("NAME", "VERSION", "TAP", "AGENTS"))
+        out.table(rows, headers=("NAME", "VERSION", "TAP", "AGENTS"),
+                  whole=("NAME",))
         print("  " + out.role("committed with the repo — %s/%s"
                               % (projectlock.LOCK_DIRNAME,
                                  projectlock.LOCK_FILENAME), "muted"))
@@ -518,6 +524,11 @@ def cmd_info(argv):
     # Identity-card badges: a scannable status strip beneath the name, echoing
     # the web .badge pills. The detailed kv rows below still carry the specifics.
     badges = []
+    # One decision for the badge and the "latest" row, compared as versions:
+    # string inequality called a tap still at 1.4.0 an update to 1.4.1.
+    relation = (staleness.catalog_relation(
+        str(lock.get("version", "?")), str((cat or {}).get("version") or ""))
+        if lock and cat else None)
     if lock:
         badges.append(out.badge("installed", "green"))
         if lock.get("pinned"):
@@ -526,9 +537,10 @@ def cmd_info(argv):
             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", "?")):
+        if relation == staleness.BEHIND:
             badges.append(out.badge("update available", "yellow"))
+        elif relation == staleness.AHEAD:
+            badges.append(out.badge("ahead of tap", "cyan"))
     elif plock:
         badges.append(out.badge("installed in this project", "green"))
     else:
@@ -555,9 +567,14 @@ def cmd_info(argv):
         inst_v = str(lock.get("version", "?"))
         out.kv("version", inst_v)
         latest = str((cat or {}).get("version") or "")
-        if cat and latest != inst_v:
+        if relation == staleness.BEHIND:
             out.kv("latest", out.role(latest, "warn", bold=True)
                    + out.role("  (update available)", "muted"))
+        elif relation == staleness.AHEAD:
+            # Kept short: kv does not wrap by default, and the long form ran
+            # this row to 71 columns, past a 60-column pane.
+            out.kv("latest", latest + out.role("  (older than installed)",
+                                               "muted"))
     else:
         out.kv("latest", str((cat or {}).get("version", "?")))
     out.kv("tap", (lock or cat or {}).get("tap", "?"))
@@ -1255,7 +1272,7 @@ def cmd_tag(argv):
             out.info(out.role("hint: boost tag <skill> +mytag", "muted"))
             return 0
         out.table([("#" + t, ", ".join(mapping[t])) for t in sorted(mapping)],
-                  headers=("TAG", "SKILLS"))
+                  headers=("TAG", "SKILLS"), whole=("TAG",))  # `list --tag`
         return 0
 
     if not args.name:

{boost_skill_cli-1.2.134 → boost_skill_cli-1.2.136}/boost_cli/commands/intelligence.py

@@ -164,6 +164,8 @@ def _install_generated(name: str, text: str, yes: bool = False) -> None:
     out.ok("%s %s → %s" % ("replaced" if owner else "installed", name, _tilde(res.dest)))
     if res.linked:
         out.info(out.role("linked into: %s" % ", ".join(res.linked), "muted"))
+    from .pkg import _warn_unwritable
+    _warn_unwritable(res)
 
 
 def _write_generated(dest: Path, text: str, yes: bool = False) -> bool:
@@ -753,9 +755,11 @@ def cmd_evolve(argv: list[str]) -> int:
         description="Iteratively improve a skill from feedback")
     ap.add_argument("name", metavar="NAME")
     ap.add_argument("--feedback", required=True, metavar="TEXT",
-                    help="what should change, in plain English")
+                    help="what should change, in plain English; `-` reads "
+                         "it from stdin, `@FILE` from a file")
     ap.add_argument("--apply", action="store_true",
-                    help="write the revision to the installed skill")
+                    help="write the revision to the installed skill and pin "
+                         "it, so `boost update` keeps it")
     args = ap.parse_args(argv)
 
     entry = lockfile.get_skill(args.name)
@@ -774,15 +778,19 @@ def cmd_evolve(argv: list[str]) -> int:
     if not skill_md.exists():
         raise BoostError("%s has no SKILL.md in the store" % args.name,
                         hint="repair with `boost sync`")
+    # Resolved before either path runs: an empty value used to reach both,
+    # and the heuristic turned it into an empty "## Feedback" heading plus a
+    # version bump — which `--apply` then wrote to the store and the lock.
+    feedback = util.read_text_arg(args.feedback, "--feedback")
     old = skill_md.read_text(encoding="utf-8", errors="replace")
     old_meta, _ = frontmatter.parse(old)
     old_ver = str(old_meta.get("version") or "0.0.0")
 
     out.heading("evolving %s  %s" % (args.name, out.role("(v%s)" % old_ver, "muted")))
-    new = _evolve_ai(old, old_ver, args.feedback) if ai.available() else None
+    new = _evolve_ai(old, old_ver, feedback) if ai.available() else None
     if new is None:
         _note_fallback()
-        new = _evolve_append(old, old_ver, args.feedback)
+        new = _evolve_append(old, old_ver, feedback)
     _print_diff(old, new)
     new_meta, _ = frontmatter.parse(new)
     new_ver = str(new_meta.get("version") or old_ver)
@@ -794,9 +802,19 @@ def cmd_evolve(argv: list[str]) -> int:
     entry["sha256"] = util.sha256_dir(store.skill_store_dir(args.name))
     entry["updated_at"] = util.now_iso()
     entry["version"] = new_ver
+    # Pinned, because this revision exists nowhere but the store: once the
+    # tap moves, `boost update` sees a source whose bytes differ from the
+    # lock's and reinstalls over it with a plain "refreshed" line.
+    was_pinned = bool(entry.get("pinned"))
+    entry["pinned"] = True
     lockfile.set_skill(args.name, entry)
     journal.log("evolve", args.name, version=new_ver)
     out.ok("evolved %s → v%s" % (args.name, new_ver))
+    if not was_pinned:
+        journal.log("pin", args.name)   # as `boost pin` records it
+        out.info("pinned it so `boost update` keeps this revision; "
+                 "`boost unpin %s` lets the tap replace it" % args.name,
+                 wrap=True)
     return 0
 
 
@@ -996,7 +1014,8 @@ def _context_status(state: dict, as_json: bool) -> int:
     rows = [(r.get("pattern", "?"), ", ".join(r.get("skills", [])),
              "*" if branch and fnmatch.fnmatch(branch, r.get("pattern", "")) else "")
             for r in rules]
-    out.table(rows, headers=("PATTERN", "SKILLS", "MATCH"))
+    out.table(rows, headers=("PATTERN", "SKILLS", "MATCH"),
+              whole=("PATTERN",))  # `context unmap <pattern>`
     return 0
 
 
@@ -1200,7 +1219,8 @@ def cmd_impact(argv: list[str]) -> int:
         print(json.dumps({"note": note, "git": git.has_git, "skills": data}))
         return 0
     out.heading("impact" + ((" of %s" % args.name) if args.name else ""))
-    out.table(rows, headers=("SKILL", "INSTALLED", "COMMITS SINCE", "EVENTS"))
+    out.table(rows, headers=("SKILL", "INSTALLED", "COMMITS SINCE", "EVENTS"),
+              whole=("SKILL",))  # `boost impact <name>`
     if args.name and in_repo and data[0]["files_touched"] is not None:
         out.kv("files touched", data[0]["files_touched"])
     if args.name:
@@ -1294,8 +1314,10 @@ def cmd_chat(argv: list[str]) -> int:
     ap.add_argument("question", nargs="*", metavar="QUESTION",
                     help="ask once and exit; omit for an interactive session")
     ap.add_argument("-k", "--limit", type=util.positive_int, default=chat_engine.TOP_K,
-                    metavar="N", help="candidate skills to consider (default %d)"
-                                      % chat_engine.TOP_K)
+                    metavar="N",
+                    help="candidate skills per search (default %d); a follow-up "
+                         "that points back also keeps the previous list"
+                         % chat_engine.TOP_K)
     ap.add_argument("--no-sources", action="store_true",
                     help="hide the citation block under each answer")
     ap.add_argument("--json", action="store_true", dest="as_json",
@@ -1336,26 +1358,33 @@ def _chat_session(args) -> int:
     assistant, and a long transcript encourages answering from the conversation
     rather than from what retrieval actually returned.
     """
-    if not ai.available():
+    have_ai = ai.available()
+    if not have_ai:
         # Worth saying up front rather than letting every answer look terse for
         # an unexplained reason.
         note = ("no AI configured — answers are the grounded matches "
                 "themselves (%s)" % ai.fallback_note())
         for line in out.wrap(note, max(out.term_width() - 2, 20)):
             out.info(out.role(line, "muted"))
-    out.info(out.role("ask about skills; blank line or Ctrl-D to exit", "muted"))
+    # With stdin piped nobody is typing, so the prompt and the typing hint are
+    # only chrome in the answers a script captures — the same rule
+    # output.confirm applies. A terminal is unchanged.
+    typing = sys.stdin.isatty()
+    if typing:
+        out.info(out.role("ask about skills; blank line or Ctrl-D to exit", "muted"))
     history: list[chat_engine.Turn] = []
     while True:
         try:
-            question = input("\n> ").strip()
+            question = input("\n> " if typing else "").strip()
         except (EOFError, KeyboardInterrupt):
-            out.info("")
+            if typing:
+                out.info("")    # end the prompt line the EOF left open
             return 0
         if not question:
             return 0
         reply = chat_engine.answer(question, history=history, k=args.limit)
         out.info("")
         _print_reply(reply, not args.no_sources)
-        history.append(chat_engine.Turn(question, reply.text))
-        for follow in chat_engine.suggest_followups(reply.skills)[:2]:
+        history.append(chat_engine.Turn(question, reply.text, reply.skills))
+        for follow in chat_engine.suggest_followups(reply.skills, with_ai=have_ai)[:2]:
             out.info(out.role("  try: %s" % follow, "muted"))