boost-skill-cli 1.2.21__tar.gz → 1.2.22__tar.gz

{boost_skill_cli-1.2.21 → boost_skill_cli-1.2.22}/.vale/styles/config/vocabularies/boost/accept.txt

@@ -5,6 +5,8 @@ allowlisted
 argparse
 Arize
 Attio
+backtick
+backticks
 Bagisto
 bmad
 bookended

{boost_skill_cli-1.2.21 → boost_skill_cli-1.2.22}/CLAUDE.md

@@ -212,6 +212,24 @@ line coverage. Target `boost_cli/core` behavior with assertions, not just import
   a workflow is rendered per agent (TOML for Gemini, see
   `workflows.TOML_COMMAND_AGENTS`). Installing a rule therefore edits a file the
   user reads every session — treat it as more invasive than a skill, not less.
+- **A long line is either chrome or data, and only chrome may be wrapped.**
+  `out.wrap()` folds prose to the pane, and the emitters take it opt-in —
+  `warn`/`info`/`dim`/`kv` accept `wrap=True` and each pays for its own prefix,
+  so continuations align under the message rather than folding to column zero.
+  It is opt-in because always-on wrapping would fold the lines that must stay
+  long: `pulse`'s `source=` paths and `fingerprint`'s 64-character hash are the
+  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
+  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
+  splitting after leaves line one unterminated and line two plain. And
+  budget the emitter's own indent — wrapping to the full `term_width()` and
+  then letting `out.info` add two spaces is what put `boost search`'s hint one
+  column past the pane it had just been fitted to.
+
 - **Sub-actions of one action repo move in lockstep.** `github/codeql-action/{init,
   analyze,upload-sarif}` and `actions/cache{,/save,/restore}` are each *one repo at
   one commit*, but Dependabot tracks one `uses:` path as one dependency and raises a

{boost_skill_cli-1.2.21 → boost_skill_cli-1.2.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.21
+Version: 1.2.22
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.2.21 → boost_skill_cli-1.2.22}/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.21'
-__version_tuple__ = version_tuple = (1, 2, 21)
+__version__ = version = '1.2.22'
+__version_tuple__ = version_tuple = (1, 2, 22)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.21 → boost_skill_cli-1.2.22}/boost_cli/commands/discovery.py

@@ -12,7 +12,6 @@ import re
 import shutil
 import subprocess
 import sys
-import textwrap
 import threading
 import time
 import urllib.parse
@@ -152,7 +151,7 @@ def cmd_search(argv):
             if reranked:
                 scored, ranker = reranked, "Claude Haiku relevance"
         else:
-            out.warn(ai.fallback_note())
+            out.warn(ai.fallback_note(), wrap=True)
     shown = scored[:args.limit]
     # The dot marks "a skill by this name is installed" — a name match, with
     # the known homonym caveat (13 real skills share `code-reviewer`). A lock
@@ -228,8 +227,12 @@ def _hint_semantic_search(engine: str) -> None:
     # runnable — a copy-pasteable `pip install ...` matters more than a hard
     # clamp, and _FIX is tested to hold no token long enough to overflow.
     msg = "semantic search is off — %s" % dense.fix_hint(st.get("reason", ""), st)
-    for line in textwrap.wrap(msg, max(out.term_width(), 20),
-                              break_long_words=False, break_on_hyphens=False):
+    # `- 2` pays for the indent `out.info` adds: wrapping to the full width and
+    # then indenting is what put this hint one column over the pane. Wrap
+    # first, colour each line after — `out.role` brackets its argument with a
+    # start code and a reset, so colouring first and splitting after leaves the
+    # first line unterminated and the second uncoloured.
+    for line in out.wrap(msg, max(out.term_width() - 2, 20)):
         out.info(out.role(line, "muted"))
 
 
@@ -315,7 +318,8 @@ def cmd_reindex(argv):
                           ", ".join(stats["reindexed"]) or "none"), "muted"))
     if args.dense:
         if dense_stats is None:
-            out.warn("dense index skipped — %s" % embed.fallback_note())
+            out.warn("dense index skipped — %s" % embed.fallback_note(),
+                     wrap=True)
         else:
             failed = dense_stats.get("failed") or []
             if failed:

{boost_skill_cli-1.2.21 → boost_skill_cli-1.2.22}/boost_cli/commands/info.py

@@ -694,7 +694,7 @@ def cmd_explain(argv):
                      "extractive summary instead"
                      % ", ".join(faithfulness.ungrounded_terms(reply, text)[:4]))
     else:
-        out.warn(ai.fallback_note())
+        out.warn(ai.fallback_note(), wrap=True)
     meta, body = frontmatter.parse(text)
     desc = str(meta.get("description") or "").strip()
     if desc:

{boost_skill_cli-1.2.21 → boost_skill_cli-1.2.22}/boost_cli/commands/intelligence.py

@@ -46,7 +46,7 @@ def _note_fallback() -> None:
     """Warn once per invocation that the AI path is unavailable."""
     global _warned_fallback
     if not _warned_fallback:
-        out.warn(ai.fallback_note())
+        out.warn(ai.fallback_note(), wrap=True)
         _warned_fallback = True
 
 
@@ -279,8 +279,12 @@ def cmd_simulate(argv: list[str]) -> int:
         out.info("  • (no imperative rules found in the skill body)")
     desc = str(meta.get("description") or "").strip()
     if desc:
-        out.info(out.role('likely triggers when the task involves: "%s"'
-                       % desc[:100], "muted"))
+        # Clipped to 100 characters, which is a length and not a width: at
+        # 80 columns the quoted description ran seven past the pane. Wrapping
+        # shows the same clipped text and fits it.
+        trigger = 'likely triggers when the task involves: "%s"' % desc[:100]
+        for line in out.wrap(trigger, max(out.term_width() - 2, 20)):
+            out.info(out.role(line, "muted"))
     return 0
 
 
@@ -1191,8 +1195,10 @@ def _chat_session(args) -> int:
     if not ai.available():
         # Worth saying up front rather than letting every answer look terse for
         # an unexplained reason.
-        out.info(out.role("no AI configured — answers are the grounded matches "
-                          "themselves (%s)" % ai.fallback_note(), "muted"))
+        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"))
     history: list[chat_engine.Turn] = []
     while True:

{boost_skill_cli-1.2.21 → boost_skill_cli-1.2.22}/boost_cli/commands/quality.py

@@ -364,10 +364,10 @@ def cmd_doctor(argv):
 
     out.heading("boost doctor")
 
-    def bad(msg):
+    def bad(msg, wrap=False):
         nonlocal issues
         issues += 1
-        out.warn(msg)
+        out.warn(msg, wrap=wrap)
 
     if gitutil.has_git():
         out.ok("git on PATH")
@@ -633,11 +633,12 @@ def _report_search_engine(bad) -> None:
         elif st["reason"] == "empty":
             detail += " but holds no vectors"
         bad("semantic search silently off — %d-chunk vector store %s; "
-            "searches are using BM25. %s" % (st["chunks"], detail, fix))
+            "searches are using BM25. %s" % (st["chunks"], detail, fix),
+            wrap=True)
         return
 
     out.info("semantic search not configured — using the full-content BM25 "
-             "engine (%s)" % fix)
+             "engine (%s)" % fix, wrap=True)
 
 
 def _print_skipped(skipped: list[dict]) -> None:
@@ -1010,7 +1011,7 @@ def cmd_conflict(argv):
                 if i in confirmed:
                     p["kind"] = "ai-confirmed"
     elif heuristic and not args.json:
-        out.warn(ai.fallback_note())
+        out.warn(ai.fallback_note(), wrap=True)
 
     if args.json:
         print(json.dumps({"pairs": pairs}))
@@ -1058,8 +1059,10 @@ def cmd_changelog(argv):
     if not lines:
         out.warn("no history found for %s in %s" % (rel, tap.name))
     if len(lines) < 3:
-        print(out.role("  (shallow clone: run `git -C %s fetch --unshallow` "
-                    "for full history)" % _tilde(tap.path), "muted"))
+        note = ("(shallow clone: run `git -C %s fetch --unshallow` "
+                "for full history)" % _tilde(tap.path))
+        for line in out.wrap(note, max(out.term_width() - 2, 20)):
+            print(out.role("  " + line, "muted"))
     return 0
 
 

{boost_skill_cli-1.2.21 → boost_skill_cli-1.2.22}/boost_cli/commands/team.py

@@ -481,8 +481,14 @@ def cmd_protocol(argv) -> int:
     if system == "Linux":
         out.kv("desktop", _tilde(_desktop_file())
                if _desktop_file().exists() else "not registered")
-    out.kv("URL forms", "boost://install/<skill> · boost://install/<tap>:<skill> "
-                        "· boost://tap/<owner>/<repo>")
+    # One form per row rather than a `·`-joined run: the run was 100 columns,
+    # and wrapping it strands a bare `·` at the start of a line, because the
+    # separator is a word to any wrapper. A form per row needs no separator and
+    # reads the same at every width.
+    for i, form in enumerate(("boost://install/<skill>",
+                              "boost://install/<tap>:<skill>",
+                              "boost://tap/<owner>/<repo>")):
+        out.kv("URL forms" if i == 0 else "", form)
     out.dim("  try it: boost protocol open boost://install/brainstorming")
     return 0
 
@@ -713,7 +719,7 @@ def cmd_who(argv) -> int:
         out.table(rows[:20], headers=("WHEN", "USER", "ACTION"))
         print()
         out.dim("based on the local journal — in a team setup, pulse feeds "
-                "aggregate via `boost onboard`")
+                "aggregate via `boost onboard`", wrap=True)
         return 0
 
     users: dict[str, dict] = {}
@@ -738,5 +744,5 @@ def cmd_who(argv) -> int:
     out.table(board, headers=("USER", "EVENTS", "SKILLS", "INSTALLS", "LAST ACTIVE"))
     print()
     out.dim("based on the local journal — in a team setup, pulse feeds aggregate "
-            "via `boost onboard`")
+            "via `boost onboard`", wrap=True)
     return 0

{boost_skill_cli-1.2.21 → boost_skill_cli-1.2.22}/boost_cli/core/output.py

@@ -200,20 +200,38 @@ def gradient(text: str, stream=None) -> str:
     return "".join(out)
 
 
+def _wrap_lines(msg: str, lead: int) -> list[str]:
+    """Wrap `msg` for an emitter whose own prefix costs `lead` columns.
+
+    Returns at least one line so an emitter never silently prints nothing for a
+    message it was given; the emitter decides what its prefix and continuation
+    padding look like.
+    """
+    return wrap(msg, term_width() - lead) or [msg]
+
+
 def ok(msg: str) -> None:
     """Print msg as an indented success line with a green check mark."""
     print("  " + role("✓", "success") + " " + msg)
 
 
-def warn(msg: str, stream=None) -> None:
+def warn(msg: str, stream=None, wrap: bool = False) -> None:
     """Print msg as an indented `!` warning line, all in the warn role.
 
     ``stream`` exists for the commands that also speak JSON on stdout: a notice
     about *which corpus answered* has to survive `--json`, and the old choice
     was between corrupting the JSON and suppressing the notice entirely. Passing
     ``sys.stderr`` keeps both.
+
+    ``wrap`` is opt-in per call site rather than always-on, because not every
+    long line is prose: `pulse`'s `source=` paths and `fingerprint`'s hash are
+    data, and folding those destroys the information the line exists to carry.
+    Prose hints pass it; data lines do not.
     """
-    print("  " + role("!", "warn") + " " + role(msg, "warn"), file=stream)
+    body = _wrap_lines(msg, 4) if wrap else [msg]
+    for i, line in enumerate(body):
+        lead = "  " + role("!", "warn") + " " if i == 0 else "    "
+        print(lead + role(line, "warn"), file=stream)
 
 
 def err(msg: str, hint: str | None = None) -> None:
@@ -223,11 +241,17 @@ def err(msg: str, hint: str | None = None) -> None:
         print(c("  hint: " + hint, DIM), file=sys.stderr)
 
 
-def info(msg: str = "", stream=None) -> None:
+def info(msg: str = "", stream=None, wrap: bool = False) -> None:
     """Print msg indented two spaces; a blank line when msg is empty.
 
     ``stream`` as in :func:`warn` — so a hint can accompany a stderr notice.
+    ``wrap`` as in :func:`warn`, and it never turns the empty message into no
+    output at all: a caller printing a blank spacer still gets its blank line.
     """
+    if wrap and msg:
+        for line in _wrap_lines(msg, 2):
+            print("  " + line, file=stream)
+        return
     print("  " + msg if msg else "", file=stream)
 
 
@@ -252,9 +276,14 @@ def plain(text: object) -> str:
     return _CONTROL_RE.sub("", str(text))
 
 
-def dim(msg: str) -> None:
-    """Print msg in the muted role (dim when color is on)."""
-    print(role(msg, "muted"))
+def dim(msg: str, wrap: bool = False) -> None:
+    """Print msg in the muted role (dim when color is on).
+
+    ``wrap`` as in :func:`warn`. `dim` prints flush left, so the wrapped
+    continuations are flush left too — there is no marker to align under.
+    """
+    for line in (_wrap_lines(msg, 0) if wrap else [msg]):
+        print(role(line, "muted"))
 
 
 def heading(msg: str) -> None:
@@ -310,6 +339,80 @@ def visible_len(s: str) -> int:
     return len(_ANSI_RE.sub("", s))
 
 
+_CODE_SPAN_RE = re.compile(r"`[^`]*`")
+
+
+def _wrap_tokens(text: str) -> list[str]:
+    """Split text into wrap units, keeping each `code span` whole.
+
+    A backtick span is one token even though it contains spaces, because the
+    spans in boost's hints are shell commands the user is meant to select and
+    paste — `pip install 'boost-skill-cli[rag]'`. Everything outside a span is
+    split on whitespace, which collapses runs and newlines the way
+    :func:`truncate` does; the span itself is copied verbatim, so a command
+    that legitimately holds two spaces survives.
+
+    An unterminated backtick simply never matches, and its text wraps as
+    ordinary words. That is the right failure: a half-open span is a typo in
+    the message, not a reason to refuse to render it.
+    """
+    parts: list[str] = []
+    pos = 0
+    for m in _CODE_SPAN_RE.finditer(text):
+        parts.extend(text[pos:m.start()].split())
+        parts.append(m.group(0))
+        pos = m.end()
+    parts.extend(text[pos:].split())
+    return parts
+
+
+def wrap(text: str, width: int | None = None, indent: str = "") -> list[str]:
+    """Greedy word-wrap to `width` visible columns, never splitting a code span.
+
+    Returns one string per line: the first bare, the rest prefixed with
+    `indent`, and every one measured with :func:`visible_len` so a coloured
+    message is bounded by what the pane shows rather than by its byte count.
+    ``width`` defaults to the live terminal.
+
+    **A token wider than the line is emitted whole and overflows.** That is
+    deliberate and it is the reason this is not `textwrap.wrap(break_long_words
+    =True)`: the tokens that hit this case are the backticked commands, and a
+    command chopped at column 80 is worse than useless — the user pastes it and
+    it fails. One long line the terminal soft-wraps still yields the right text
+    on a copy.
+
+    Empty (or all-whitespace) text wraps to no lines at all, so a caller can
+    tell "nothing to say" from "one blank line".
+    """
+    width = term_width() if width is None else width
+    tokens = _wrap_tokens(text)
+    if not tokens:
+        return []
+    pad = visible_len(indent)
+    lines: list[str] = []
+    cur = ""
+    for tok in tokens:
+        # The first line spends the full width; every later one pays for the
+        # indent. No floor under the subtraction: a pane narrower than its own
+        # indent yields a limit no token can meet, and each token lands on its
+        # own line — which is the same answer a floor of 1 gives, because the
+        # fit test below is never satisfiable below 3 columns anyway.
+        limit = width if not lines else width - pad
+        if cur and visible_len(cur) + 1 + visible_len(tok) <= limit:
+            cur += " " + tok
+        else:
+            if cur:
+                lines.append(cur)
+            cur = tok
+    lines.append(cur)
+    return [lines[0]] + [indent + ln for ln in lines[1:]]
+
+
+#: Alias for callers that take a ``wrap`` keyword argument of their own, which
+#: would otherwise shadow the function inside their own body.
+wrap_text = wrap
+
+
 def panel(lines, title: str | None = None, hue: str = "cyan") -> str:
     """A rounded box around one or more lines, with an Aurora-tinted border and
     an optional title set into the top rule — the terminal echo of the web
@@ -506,11 +609,23 @@ def format_search_row(name: str, desc: str, kind: str, tap: str, frac: float,
     return row.rstrip()
 
 
-def kv(key: str, value: str, width: int = 14) -> None:
-    """Print an indented key/value line: dim key padded to width, then value."""
+def kv(key: str, value: str, width: int = 14, wrap: bool = False) -> None:
+    """Print an indented key/value line: dim key padded to width, then value.
+
+    ``wrap`` as in :func:`warn`, and the continuations align under the *value*
+    rather than the key — a value folded back to column 0 reads as a new row.
+    """
     # The str() is NOT redundant despite the annotation: callers pass raw ints
     # (e.g. `boost impact` prints files_touched), which would raise TypeError.
-    print("  " + c(key.ljust(width), DIM) + str(value))  # noqa: FURB123
+    text = str(value)  # noqa: FURB123
+    if not wrap:
+        print("  " + c(key.ljust(width), DIM) + text)
+        return
+    lead = 2 + width
+    lines = wrap_text(text, term_width() - lead) or [text]
+    print("  " + c(key.ljust(width), DIM) + lines[0])
+    for line in lines[1:]:
+        print(" " * lead + line)
 
 
 def _pad(cell: str, width: int) -> str:

{boost_skill_cli-1.2.21 → boost_skill_cli-1.2.22}/boost_skill_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.21
+Version: 1.2.22
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.2.21 → boost_skill_cli-1.2.22}/boost_skill_cli.egg-info/SOURCES.txt

@@ -543,6 +543,7 @@ tests/functional/test_cli_discovery.py
 tests/functional/test_cli_hooks.py
 tests/functional/test_cli_info.py
 tests/functional/test_cli_intelligence.py
+tests/functional/test_cli_pane_width.py
 tests/functional/test_cli_pkg.py
 tests/functional/test_cli_quality.py
 tests/functional/test_cli_taps.py

{boost_skill_cli-1.2.21 → boost_skill_cli-1.2.22}/docs/eval-latest.json

@@ -1,7 +1,7 @@
 {
   "schema": 1,
-  "generated": "2026-08-18T06:55:00Z",
-  "commit": "3a28b3f",
+  "generated": "2026-08-25T06:59:06Z",
+  "commit": "1167bcd",
   "engine": "bm25",
   "corpus": {
     "entries": 57,

boost_skill_cli-1.2.22/docs/roadmap/items/long-hints-overflow-narrow-panes.md

@@ -0,0 +1,69 @@
+---
+id: long-hints-overflow-narrow-panes
+board: code
+section: dx
+status: inflight
+category: CLI · Output
+complexity: M
+impact: Low
+wow: 2
+note: a code span is one atomic token, so a hint folds to the pane without splitting the command it tells you to run
+order: 126
+owner: loop/wrap-long-hints
+pr:
+title: The hints still run past the pane, and the worst one is pinned by six test files
+---
+<b>Measured, at <code>COLUMNS=80</code>, over 46 commands.</b> After the box and the help screen
+were fitted, <b>11</b> still emitted a line past 80 columns. Ranked:
+<code>doctor</code>'s semantic-search hint at <b>127</b>; the AI-fallback notice at <b>101</b>,
+which is one shared string surfacing in six places; <code>protocol</code>'s URL forms at 100;
+<code>changelog</code>'s unshallow hint at 93; <code>who</code>'s footer at 87;
+<code>search</code>'s extra hint at 82. A re-measure while claiming this found a twelfth the
+first pass missed — <code>simulate</code>'s quoted trigger line at <b>97</b>, which clips the
+description to 100 <em>characters</em>, a length rather than a width.
+
+<b>Two of them must be left alone.</b> <code>pulse</code>'s <code>source=</code> paths and
+<code>fingerprint</code>'s hash are data, not chrome — clipping them destroys the information the
+line exists to carry, and a hash broken across two lines cannot be compared by eye. So a blanket
+&ldquo;no line exceeds <code>term_width()</code>&rdquo; assertion is the wrong gate: it would
+false-positive on exactly the lines that should be long.
+
+<b>What shipped: a code span is one atomic token.</b> <code>out.wrap()</code> is a greedy word
+wrap in which a backticked span is a single unbreakable unit even though it contains spaces,
+because the spans in these hints are shell commands the user is meant to select and paste. That
+is the whole reason this is not two lines of <code>textwrap</code>: <code>doctor</code> and
+<code>search</code> both interpolate <code>dense.fix_hint()</code>, whose answers end in
+<code>pip install 'boost-skill-cli[rag]'</code>, and a wrap that splits it hands the user a
+command that does not run. A token wider than the pane is emitted whole and overflows — one long
+line the terminal soft-wraps still yields the right text on a copy, which a bisected one does not.
+<code>search</code> already wrapped, with a comment conceding it relied on a test that no
+<code>_FIX</code> entry holds an over-long token; the span rule makes that structural. It also
+wrapped to the <em>full</em> width and then let <code>out.info</code> indent by two, which is
+precisely the 82.
+
+<b>Wrapping is opt-in per call site, and that is the design.</b> <code>warn</code>,
+<code>info</code>, <code>dim</code> and <code>kv</code> take <code>wrap=True</code> and each pays
+for its own prefix — the marker, the indent, the key column — so continuations align under the
+message rather than folding back to column zero. Always-on wrapping would have folded the two
+data lines this item exists to protect.
+
+<b>Two claims in the first draft of this card did not survive measurement.</b> It said the
+101-column offender was pinned by <b>six</b> test files; only <b>one</b> pins it verbatim
+(<code>test_ai_fallback_note_verbatim</code>, the mutant-killer, which wraps at the <em>emission
+site</em> and so was never touched). The other five pin the substring
+<code>using the heuristic fallback</code>, and are re-pinned against whitespace-collapsed output —
+an idiom <code>test_cli_discovery.py</code> had already established, for this exact reason. The
+BDD feature got a separate <code>should contain wrapped</code> step rather than collapsing inside
+<code>the output should contain</code>, which eleven feature files use ~87 times.
+
+<b>Result: eight overflowing lines became two, and the two are the data lines.</b> The gate splits
+the commands by whose words are on the line — <code>search</code>, <code>who</code> and
+<code>protocol</code> compose their whole output and are swept down to 40 columns; commands that
+quote a skill's own rules are swept at 80 and wider, because reflowing someone else's prose is a
+different decision from fitting boost's own hints.
+
+<b>Still open, found by the new gate rather than by this card.</b> At 40 and 60 columns
+<code>doctor</code>'s <code>·</code>-joined status summaries run to 71, and
+<code>protocol</code>'s <code>try it:</code> example is a single 59-column command that cannot
+fold. Neither is in this item's scope — both are recorded here so the next pass does not
+rediscover them as new.

{boost_skill_cli-1.2.21 → boost_skill_cli-1.2.22}/docs/roadmap.html

@@ -9127,36 +9127,67 @@ output change, not a rider on this one. See <code>long-hints-overflow-narrow-pan
       </article>
 
       <article class="cap rcard" id="long-hints-overflow-narrow-panes">
-        <div class="head"><span class="pill next">Next</span><span class="cat">CLI · Output</span></div>
+        <div class="head"><span class="pill inflight">In flight</span><span class="cat">CLI · Output</span></div>
         <h3>The hints still run past the pane, and the worst one is pinned by six test files</h3>
         <p><b>Measured, at <code>COLUMNS=80</code>, over 46 commands.</b> After the box and the help screen
-were fitted, <b>11</b> still emit a line past 80 columns. Ranked:
+were fitted, <b>11</b> still emitted a line past 80 columns. Ranked:
 <code>doctor</code>'s semantic-search hint at <b>127</b>; the AI-fallback notice at <b>101</b>,
-which is one shared string surfacing in <code>explain</code>, <code>impact</code> and
-<code>simulate</code>; <code>protocol</code>'s URL forms at 100; <code>changelog</code>'s
-unshallow hint at 93; <code>who</code>'s footer at 87; <code>search</code>'s extra hint at 82;
-<code>replay</code>'s footer at 81.
+which is one shared string surfacing in six places; <code>protocol</code>'s URL forms at 100;
+<code>changelog</code>'s unshallow hint at 93; <code>who</code>'s footer at 87;
+<code>search</code>'s extra hint at 82. A re-measure while claiming this found a twelfth the
+first pass missed — <code>simulate</code>'s quoted trigger line at <b>97</b>, which clips the
+description to 100 <em>characters</em>, a length rather than a width.
 
-<b>Two of the eleven must be left alone.</b> <code>pulse</code>'s <code>source=</code> paths and
+<b>Two of them must be left alone.</b> <code>pulse</code>'s <code>source=</code> paths and
 <code>fingerprint</code>'s hash are data, not chrome — clipping them destroys the information the
-line exists to carry. So a blanket "no line exceeds <code>term_width()</code>" assertion is the
-wrong gate: it would false-positive on exactly the lines that should be long. Pin the composed
-sites individually.
-
-<b>Why this is not a quick wrap.</b> The 101-column offender contains
-<code>using the heuristic fallback</code>, which is asserted by <b>six</b> test files plus
-<code>tests/bdd/features/explain.feature</code>. Wrapping inserts a newline mid-sentence and
-breaks every one of them; and under pytest <code>term_width()</code> falls back to 80, so the
-wrap fires in the suite rather than only on a narrow terminal. The change is a
-<code>wrap()</code> helper in <code>core/output.py</code> — mutation-gated, so boundary-width
-tests, not coverage — plus re-pinning those assertions. Shortening the strings instead is a
-smaller diff but a voice decision, and the substring pinned by the tests would have to survive
-either way.</p>
+line exists to carry, and a hash broken across two lines cannot be compared by eye. So a blanket
+&ldquo;no line exceeds <code>term_width()</code>&rdquo; assertion is the wrong gate: it would
+false-positive on exactly the lines that should be long.
+
+<b>What shipped: a code span is one atomic token.</b> <code>out.wrap()</code> is a greedy word
+wrap in which a backticked span is a single unbreakable unit even though it contains spaces,
+because the spans in these hints are shell commands the user is meant to select and paste. That
+is the whole reason this is not two lines of <code>textwrap</code>: <code>doctor</code> and
+<code>search</code> both interpolate <code>dense.fix_hint()</code>, whose answers end in
+<code>pip install 'boost-skill-cli[rag]'</code>, and a wrap that splits it hands the user a
+command that does not run. A token wider than the pane is emitted whole and overflows — one long
+line the terminal soft-wraps still yields the right text on a copy, which a bisected one does not.
+<code>search</code> already wrapped, with a comment conceding it relied on a test that no
+<code>_FIX</code> entry holds an over-long token; the span rule makes that structural. It also
+wrapped to the <em>full</em> width and then let <code>out.info</code> indent by two, which is
+precisely the 82.
+
+<b>Wrapping is opt-in per call site, and that is the design.</b> <code>warn</code>,
+<code>info</code>, <code>dim</code> and <code>kv</code> take <code>wrap=True</code> and each pays
+for its own prefix — the marker, the indent, the key column — so continuations align under the
+message rather than folding back to column zero. Always-on wrapping would have folded the two
+data lines this item exists to protect.
+
+<b>Two claims in the first draft of this card did not survive measurement.</b> It said the
+101-column offender was pinned by <b>six</b> test files; only <b>one</b> pins it verbatim
+(<code>test_ai_fallback_note_verbatim</code>, the mutant-killer, which wraps at the <em>emission
+site</em> and so was never touched). The other five pin the substring
+<code>using the heuristic fallback</code>, and are re-pinned against whitespace-collapsed output —
+an idiom <code>test_cli_discovery.py</code> had already established, for this exact reason. The
+BDD feature got a separate <code>should contain wrapped</code> step rather than collapsing inside
+<code>the output should contain</code>, which eleven feature files use ~87 times.
+
+<b>Result: eight overflowing lines became two, and the two are the data lines.</b> The gate splits
+the commands by whose words are on the line — <code>search</code>, <code>who</code> and
+<code>protocol</code> compose their whole output and are swept down to 40 columns; commands that
+quote a skill's own rules are swept at 80 and wider, because reflowing someone else's prose is a
+different decision from fitting boost's own hints.
+
+<b>Still open, found by the new gate rather than by this card.</b> At 40 and 60 columns
+<code>doctor</code>'s <code>·</code>-joined status summaries run to 71, and
+<code>protocol</code>'s <code>try it:</code> example is a single 59-column command that cannot
+fold. Neither is in this item's scope — both are recorded here so the next pass does not
+rediscover them as new.</p>
         <div class="meta">
           <span class="m">Complexity <b>M</b></span>
           <span class="m">Impact <b>Low</b></span>
           <span class="m">Wow <b class="wow">★★</b></span>
-          <span class="m">11 commands still emit prose hints past 80 columns; the worst is one string pinned by six test files</span>
+          <span class="m">a code span is one atomic token, so a hint folds to the pane without splitting the command it tells you to run</span>
         </div>
       </article>
       <!-- /ROADMAP:cards -->

{boost_skill_cli-1.2.21 → boost_skill_cli-1.2.22}/tests/bdd/features/explain.feature

@@ -10,14 +10,14 @@ Feature: boost explain
     Given the "brainstorming" skill is installed
     When I run "boost explain brainstorming"
     Then the exit code should be 0
-    And the output should contain "using the heuristic fallback"
+    And the output should contain wrapped "using the heuristic fallback"
     And the output should contain "Outline:"
     And the output should contain "Key rules:"
 
   Scenario: explaining a skill that is only in a tap (not installed)
     When I run "boost explain jira-integration"
     Then the exit code should be 0
-    And the output should contain "using the heuristic fallback"
+    And the output should contain wrapped "using the heuristic fallback"
 
   Scenario: explaining an unknown skill fails
     When I run "boost explain does-not-exist"