boost-skill-cli 1.2.115__tar.gz → 1.2.117__tar.gz

{boost_skill_cli-1.2.115/boost_skill_cli.egg-info → boost_skill_cli-1.2.117}/PKG-INFO

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

{boost_skill_cli-1.2.115 → boost_skill_cli-1.2.117}/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.115'
-__version_tuple__ = version_tuple = (1, 2, 115)
+__version__ = version = '1.2.117'
+__version_tuple__ = version_tuple = (1, 2, 117)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.115 → boost_skill_cli-1.2.117}/boost_cli/commands/bmad.py

@@ -81,7 +81,7 @@ from ..errors import BoostError
 
 DEFAULT_MODULES = "bmm"
 HOOK_NAME = "bmad"
-HOOK_MATCHER = "startup|resume|clear"
+HOOK_MATCHER = "startup|resume|clear|compact"
 ROUTE_HOOK_NAME = "bmad-route"
 
 _ACTIONS = ("on", "off", "route", "personas", "install", "init", "startup",
@@ -358,8 +358,7 @@ def _route(prompt, plain, scope=None) -> int:
         if prompt or plain:
             banner = core.route_context(text, root)
         elif _autopilot_live(scope, root):
-            banner = core.route_context(
-                text, root, (_agents_dir("global"), root / ".claude" / "agents"))
+            banner = _session_banner(payload, text, root)
         else:
             return 0
     except Exception:                     # a hook must never break the session
@@ -376,6 +375,37 @@ def _route(prompt, plain, scope=None) -> int:
     return 0
 
 
+def _session_banner(payload: dict, text: str, root: Path) -> str:
+    """The hook's banner, or ``""`` when this session already holds it.
+
+    Keyed by ``session_id``. Gemini's `BeforeAgent` carries one too, but its
+    reference says hook context is appended "for this turn only", so a banner
+    skipped there would simply be missing; the check applies to Claude alone.
+    """
+    session = str(payload.get("session_id") or "")
+    if payload.get("hook_event_name") == "BeforeAgent":
+        session = ""
+    track = core.classify(text, root)
+    if track == core.TRIVIAL:
+        return ""
+    sessions = _sessions_read() if session else {}
+    if session and not core.banner_is_news(sessions.get(session), text, track,
+                                           str(root)):
+        return ""
+    banner = core.route_context(
+        text, root, (_agents_dir("global"), root / ".claude" / "agents"))
+    if session and banner:
+        sessions[session] = {"track": track, "root": str(root),
+                             "at": util.now_iso()}
+        # Best effort: a state dir that cannot be written (full disk, a
+        # root-owned ~/.boost after one `sudo boost`) must cost one repeated
+        # banner, not every banner — the write happens after the banner is
+        # built, so an escaping OSError silenced the router outright.
+        with suppress(OSError):
+            _sessions_write(sessions)
+    return banner
+
+
 _PERSONA_STATE_LABEL = {
     "managed": "installed",
     "edited": "installed (edited)",
@@ -543,9 +573,21 @@ def _startup(value, scope) -> int:
 
 
 def _orient(scope) -> int:
-    """SessionStart hook target: print the briefing iff enabled (else silent)."""
+    """SessionStart hook target: print the briefing iff enabled (else silent).
+
+    On `clear` and `compact` it also forgets the session's last routing banner:
+    the conversation that held it is gone, so the next routed prompt needs it
+    again rather than being skipped as a repeat.
+    """
     scope = scope or "project"
     with suppress(Exception):  # a hook must never break the session
+        payload = _read_hook_stdin()
+        session = str(payload.get("session_id") or "")
+        if session and payload.get("source") in ("clear", "compact"):
+            sessions = _sessions_read()
+            if sessions.pop(session, None) is not None:
+                _sessions_write(sessions)
+    with suppress(Exception):
         if _get_scope_state(scope).get("startup"):
             print(core.orientation())
     return 0
@@ -643,9 +685,14 @@ def _doctor() -> int:
         personas = len(core.present_personas(agents))
         router = cs.has_hook(scope, "UserPromptSubmit", ROUTE_HOOK_NAME)
         live = bool(st.get("autopilot")) and router
+        briefing = _on_off(cs.has_hook(scope, "SessionStart", HOOK_NAME))
+        if briefing == "on" and _stale_matcher(scope):
+            # The matcher lives in the user's settings.json from whenever they
+            # last ran `on`, while the code that depends on it ships with the
+            # binary — so an old install silently misses newer sources.
+            briefing += " (stale matcher: re-run `boost bmad on`)"
         out.kv(scope, "autopilot=%s  %d personas  router=%s  briefing=%s"
-               % (_on_off(live), personas, _on_off(router),
-                  _on_off(cs.has_hook(scope, "SessionStart", HOOK_NAME))))
+               % (_on_off(live), personas, _on_off(router), briefing))
         out.kv("  workflows", "skills=%d  installed=%s"
                % (_count_skills(_skills_dir(scope)), _on_off(st.get("installed"))))
     out.dim("  project = %s" % Path.cwd())
@@ -656,6 +703,17 @@ def _doctor() -> int:
 
 # -------------------------------------------------------------------- helpers
 
+def _stale_matcher(scope) -> bool:
+    """True when the installed briefing hook predates the current matcher.
+
+    `_orient` forgets a session's last banner on `clear` and `compact`, and
+    `compact` only reaches it if the hook was written with today's matcher.
+    """
+    rows = [r for r in cs.list_hooks(scope)
+            if r["event"] == "SessionStart" and r["name"] == HOOK_NAME]
+    return any(r.get("matcher") != HOOK_MATCHER for r in rows)
+
+
 def _skills_dir(scope) -> Path:
     base = paths.home() if scope == "global" else Path.cwd()
     return base / ".claude" / "skills"
@@ -709,6 +767,33 @@ def _state_write(d: dict) -> None:
     _state_path().write_text(json.dumps(d, indent=2) + "\n", encoding="utf-8")
 
 
+SESSIONS_KEPT = 200
+"""Session records kept; the oldest go first. A lost one costs one banner."""
+
+
+def _sessions_path() -> Path:
+    return paths.state_dir() / "bmad-sessions.json"
+
+
+def _sessions_read() -> dict:
+    """``{session_id: {track, root, at}}``; anything unreadable reads as empty."""
+    try:
+        data = json.loads(_sessions_path().read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _sessions_write(sessions: dict) -> None:
+    """Atomically, and bounded: every routed prompt in every session writes it."""
+    def at(item):
+        record = item[1]
+        return str(record.get("at", "")) if isinstance(record, dict) else ""
+
+    kept = dict(sorted(sessions.items(), key=at)[-SESSIONS_KEPT:])
+    util.atomic_write_text(_sessions_path(), json.dumps(kept, indent=1) + "\n")
+
+
 def _proj_key(project=None) -> str:
     return str(Path(project or Path.cwd()).resolve())
 

{boost_skill_cli-1.2.115 → boost_skill_cli-1.2.117}/boost_cli/core/bmad.py

@@ -79,6 +79,22 @@ class Track(NamedTuple):
     support: tuple[str, ...]   # persona slugs to run alongside the lead
     skill: str                 # canonical BMAD v6 skill for this track
     note: str                  # how the lead should open
+    done: str                  # what finished looks like: one of DONE_KINDS
+
+
+DONE_KINDS: tuple[str, ...] = ("change", "findings", "artifact")
+"""What a track delivers, which decides what "done" means for it.
+
+Every track used to get the build contract — new coverage, updated docs, a
+finished and verified change — so "review the changes on this branch" was told
+to add tests and finish a change, and "compare the two caching options" was
+told to document what changed when nothing had. A *change* ends in edited
+source; *findings* (review, discovery) end in an answer with its evidence; an
+*artifact* (product, planning, architecture) ends in a written document. Neither
+of the last two refuses work the prompt asked for: the tie-break sends
+"implement the spec in specs/retry.md" to *product* on the word "spec", and a
+flat "no code" would tell the model not to do what it was just asked to do.
+"""
 
 
 # --------------------------------------------------------------------- personas
@@ -238,33 +254,33 @@ PERSONA_BY_SLUG: dict[str, Persona] = {p.slug: p for p in PERSONAS}
 TRACKS: dict[str, Track] = {
     "discovery": Track(
         lead="bmad-analyst", support=("bmad-pm",), skill="bmad-deep-recon",
-        note="Ground it in sources before recommending."),
+        note="Ground it in sources before recommending.", done="findings"),
     "product": Track(
         lead="bmad-pm", support=("bmad-analyst", "bmad-architect"),
         skill="bmad-prd",
-        note="Write criteria a test could assert."),
+        note="Write criteria a test could assert.", done="artifact"),
     "planning": Track(
         lead="bmad-pm", support=("bmad-architect",), skill="bmad-sprint-planning",
-        note="Keep the tracked items and the work in sync."),
+        note="Keep the tracked items and the work in sync.", done="artifact"),
     "architecture": Track(
         lead="bmad-architect", support=("bmad-dev",), skill="bmad-architecture",
-        note="One recommendation, with the rejected option named."),
+        note="One recommendation, with the rejected option named.", done="artifact"),
     "ux": Track(
         lead="bmad-ux", support=("bmad-dev",), skill="bmad-ux",
-        note="Hierarchy and spacing before colour."),
+        note="Hierarchy and spacing before colour.", done="change"),
     "build": Track(
         lead="bmad-dev", support=("bmad-tea", "bmad-scribe"), skill="bmad-build",
-        note="Ship it complete and verified."),
+        note="Ship it complete and verified.", done="change"),
     "quality": Track(
         lead="bmad-tea", support=("bmad-dev",),
         skill="bmad-qa-generate-e2e-tests",
-        note="Assertions that a mutation would fail."),
+        note="Assertions that a mutation would fail.", done="change"),
     "docs": Track(
         lead="bmad-scribe", support=("bmad-dev",), skill="bmad-document-project",
-        note="Verify against the code, regenerate what is generated."),
+        note="Verify against the code, regenerate what is generated.", done="change"),
     "review": Track(
         lead="bmad-tea", support=("bmad-architect",), skill="bmad-code-review",
-        note="Find the failure, not the style nit."),
+        note="Find the failure, not the style nit.", done="findings"),
 }
 
 TRACK_ORDER: tuple[str, ...] = (
@@ -341,6 +357,73 @@ _SLASH = re.compile(r"^\s*/")
 _OPT_OUT = re.compile(r"\b(no|skip|without|disable)\s+bmad\b", re.IGNORECASE)
 _INFO_QUESTION = re.compile(
     r"^\s*(what|why|how|when|where|which|who|whose|whom)\b", re.IGNORECASE)
+_YES_NO_QUESTION = re.compile(
+    r"^\s*(is|are|do|does|did|has|have|should|can|could|would|will)\b",
+    re.IGNORECASE)
+"""An auxiliary opener: with a closing `?`, a yes/no question.
+
+`_INFO_QUESTION` knew only wh-words, so "what tests cover the parser?" was
+silent and "are there any tests for the parser?" got a quality banner. Replayed
+over real prompts, all 11 synthetic yes/no questions routed.
+"""
+_MODAL_REQUEST = re.compile(
+    r"^\s*(can|could|would|will)\s+(you|we)\b"
+    r"(?!\s+(please\s+)?(explain|tell|describe|summari[sz]e)\b)",
+    re.IGNORECASE)
+""""can you fix the crash?" is a request wearing a question mark.
+
+Unless its verb only asks to be told something: "could you explain the cache?"
+is still a question.
+"""
+_READ_AND_TELL = re.compile(
+    r"^\s*((please|can you|could you)\s+)?(read|skim|look at)\b"
+    r".*?\b(tell me|summari[sz]e)\b",
+    re.IGNORECASE | re.DOTALL)
+""""read X and tell me Y" asks for an answer, whatever words X is made of.
+
+The track used to be picked by words inside the thing to be read — `/changelog`
+in a URL, `api-schema-design` in a doc name. A `then` after the ask is the one
+way it turns back into work (:data:`_THEN`).
+"""
+_THEN = re.compile(r"\bthen\b", re.IGNORECASE)
+_COMPOUND_ASK = re.compile(
+    r"\b(and|then|also)\s+(please\s+|also\s+)?"
+    r"(add|fix|update|create|implement|refactor|rename|remove|delete|build|"
+    r"ship|write|wire|migrate|run)\b", re.IGNORECASE)
+"""A second clause that asks for work, after a clause that asks for an answer.
+
+"read the spec and then implement it" and "can you explain the cache and add a
+test?" are requests with a question attached, not questions. Without this the
+question gates read only the first verb and silenced the work.
+"""
+
+PASTE_MIN_LINES = 3
+"""Below this, a prompt is not shaped like pasted output."""
+
+_FENCE = re.compile(r"```.*?```", re.DOTALL)
+"""A fenced block: pasted *inside* a request, so it is not what the ask is."""
+
+_MACHINE_LINE = re.compile(
+    # Indented and code-shaped. Indentation alone is not enough: a bullet list
+    # and a hanging-indent sentence are indented too, and reading them as
+    # output silenced ordinary multi-line requests ("Do these:\n  - add a test
+    # …") that route fine as one line.
+    r"^\s+(?![-*•]\s|\d+[.)]\s)\S.*[=(){}\[\];|<>]"
+    r"|^\s*(modified|new file|deleted|renamed|both modified):"  # git status
+    r"|^\$\s"                                   # a shell prompt
+    r"|^Traceback \(most recent call last\)"
+    r"|^[A-Za-z_][\w.]*(Error|Exception|Warning)\b"   # its last line
+    r"|^\s*npm\b"                                # npm's own log lines
+    r"|^[>E]\s"                                  # pytest's source and error marks
+    r"|^(FAILED|ERROR|PASSED|SKIPPED)\b"
+    r"|^=+ .* =+$"                               # pytest's section rules
+    r"|^(On branch|Your branch is|Changes not staged|Changes to be committed"
+    r"|Untracked files|nothing to commit|no changes added)\b"  # git status
+    r"|\S:\d+\b"                                # path:line
+    r"|\b\d{4}-\d{2}-\d{2}\b|\b\d{1,2}:\d{2}:\d{2}\b",  # timestamps
+    re.MULTILINE)
+"""A line a program wrote rather than a person."""
+
 _SECOND_SENTENCE = re.compile(r"[.?!]\s+\S")
 """A sentence terminator with more prose after it.
 
@@ -456,10 +539,16 @@ def classify(prompt: str, root: Path | str | None = None) -> str:
     words = text.split()
     if len(words) < MIN_WORDS:
         return TRIVIAL
-    if (_INFO_QUESTION.match(text) and len(words) <= QUESTION_MAX_WORDS
-            and not _SECOND_SENTENCE.search(text)):
+    if _is_question(text, words):
         return TRIVIAL
-    intent = _intent_text(text, root)
+    # A fenced block is pasted material inside a request, so it must not
+    # outvote the request: strip it before deciding whether this is a paste.
+    prose = _paste_prose(_FENCE.sub(" ", text))
+    # A paste gets the long-prompt argument whatever its length: one keyword in
+    # a wall of machine output is incidental, and only the person's own lines
+    # are theirs to score.
+    long_or_paste = prose is not None or len(words) > LONG_PROMPT_WORDS
+    intent = _intent_text(text if prose is None else prose, root)
     build_intent = _ADDRESSEE.sub(" ", _PATH_TOKEN.sub(" ", intent))
     # Distinct patterns matched, not occurrences: saying "update" twenty times
     # is one piece of evidence, which is what keeps a repetitive log quiet.
@@ -467,11 +556,83 @@ def classify(prompt: str, root: Path | str | None = None) -> str:
                      if rx.search(build_intent if t == "build" else intent))
               for t, pats in _COMPILED.items()}
     best = max(scores.values())
-    if best == 0 or (best < 2 and len(words) > LONG_PROMPT_WORDS):
+    if best == 0 or (best < 2 and long_or_paste):
         return TRIVIAL
     return next(t for t in TRACK_ORDER if scores[t] == best)
 
 
+def _is_question(text: str, words: list[str]) -> bool:
+    """A prompt that asks to be told something rather than for work.
+
+    Three shapes: a wh-question, a yes/no question (an auxiliary opener and a
+    closing ``?``, unless it is a modal request), and "read X and tell me".
+    All three stop being questions past :data:`QUESTION_MAX_WORDS`, once
+    another sentence follows, or once a second clause asks for work; the third
+    also stops at a ``then`` after the ask.
+    """
+    if _COMPOUND_ASK.search(text):
+        # "can you explain the cache and add a test for it?" asks for both; the
+        # tell-me verb only decides the question when nothing else is asked.
+        return False
+    if len(words) > QUESTION_MAX_WORDS:
+        # Past this a question is a brief, whatever shape it opens in. The
+        # read-and-tell gate had no cap at all, so a 200-word spec that opened
+        # "read the RFC …" and said "tell me" anywhere went silent.
+        return False
+    if not _SECOND_SENTENCE.search(text):
+        if _INFO_QUESTION.match(text):
+            return True
+        if (text.endswith("?") and _YES_NO_QUESTION.match(text)
+                and not _MODAL_REQUEST.match(text)):
+            return True
+    ask = _READ_AND_TELL.match(text)
+    return ask is not None and not _THEN.search(text, ask.end())
+
+
+def _paste_prose(text: str) -> str | None:
+    """The lines a person typed, when the prompt is mostly pasted output.
+
+    ``None`` when it is not paste-shaped: fewer than :data:`PASTE_MIN_LINES`
+    non-blank lines, or more of them prose than machine output. A `git status`
+    paste routed to build on git's own words ("Changes not staged", "to
+    update"), and an npm log on the `fix` of `npm audit fix`.
+    """
+    lines = [ln for ln in text.splitlines() if ln.strip()]
+    if len(lines) < PASTE_MIN_LINES:
+        return None
+    prose = [ln for ln in lines if not _MACHINE_LINE.search(ln)]
+    if 2 * len(prose) > len(lines):
+        return None
+    return "\n".join(prose)
+
+
+# --------------------------------------------------------------------- sessions
+
+REPLY_MAX_WORDS = 12
+"""Past this, an "ok, …" is carrying a task of its own, not agreeing to one."""
+
+_REPLY = re.compile(r"^\s*(yes|yep|yeah|ok|okay|sure|no|nope|go ahead)\b",
+                    re.IGNORECASE)
+
+
+def banner_is_news(last: dict | None, prompt: str, track: str, root: str) -> bool:
+    """Whether a routed prompt's banner tells the session anything new.
+
+    ``last`` is the record of the banner this session was last given
+    (``{"track", "root"}``), or ``None`` if it has had none. A banner is a
+    function of track and root alone, and Claude Code keeps hook context in the
+    conversation where it fired, so the same track in the same repo repeats
+    what the model already holds. A short reply — "ok update both and rerun",
+    "sure, add a test for that too" — continues the task that banner set up;
+    re-routing it handed the lead to another persona mid-task.
+    """
+    if not isinstance(last, dict):
+        return True
+    if _REPLY.match(prompt) and len(prompt.split()) <= REPLY_MAX_WORDS:
+        return False
+    return (last.get("track"), last.get("root")) != (track, root)
+
+
 # -------------------------------------------------------------- project signals
 
 _TEST_DIRS = ("tests", "test", "spec", "__tests__")
@@ -535,14 +696,33 @@ def project_signals(root: Path) -> dict:
     }
 
 
-def done_checklist(signals: dict) -> list[str]:
-    """The definition of done, in the repo's own vocabulary.
+def done_checklist(signals: dict, done: str = "change") -> list[str]:
+    """The definition of done for one kind of work, in the repo's own vocabulary.
 
-    Tests and docs are unconditional — "no doc change needed" is a conclusion to
-    reach, not a step to skip. Roadmap and gate clauses appear only when the
-    repo actually has one, because an instruction to update a file that does
-    not exist teaches the agent to ignore the whole banner.
+    For a *change*, tests and docs are unconditional — "no doc change needed"
+    is a conclusion to reach, not a step to skip. Roadmap and gate clauses
+    appear only when the repo actually has one, because an instruction to
+    update a file that does not exist teaches the agent to ignore the whole
+    banner. *Findings* and *artifacts* are not changes, so they get no tests or
+    docs clause: they are done when the answer or the document is. Both carry
+    an "unless asked" escape, because the tie-break routes real change requests
+    onto them — "fix the lint errors in the scanner" goes to review, and
+    "implement the spec in specs/retry.md" to product.
     """
+    guide = signals.get("guide")
+    binding = ["`%s` is binding" % guide] if guide else []
+    if done == "findings":
+        gate = signals.get("gate")
+        return ["findings: each with its evidence (file:line, output or source)",
+                "no edits unless asked; an edit gets tests%s like any change"
+                % (" and `%s`" % gate if gate else ""), *binding]
+    if done == "artifact":
+        roadmap = signals.get("roadmap")
+        tracked = (["roadmap: create or claim the item under `%s`" % roadmap]
+                   if roadmap else [])
+        return ["a written artifact; no code unless the prompt asks for a "
+                "change, which then gets the change contract", *tracked, *binding]
+
     items: list[str] = []
 
     tests = signals.get("tests")
@@ -566,11 +746,7 @@ def done_checklist(signals: dict) -> list[str]:
     if gate:
         items.append("gate: `%s` green, with real output" % gate)
 
-    guide = signals.get("guide")
-    if guide:
-        items.append("`%s` is binding" % guide)
-
-    return items
+    return items + binding
 
 
 # --------------------------------------------------------------------- routing
@@ -611,13 +787,21 @@ def route_lines(prompt: str, root: Path | None = None,
     lines.extend((
         "BMAD skill: `%s` — invoke it if it is installed; otherwise the "
         "persona's own playbook stands." % track.skill,
-        "Done means: " + " · ".join(done_checklist(signals)),
-        "Work autonomously through to a finished, verified change; stop to ask "
-        "only when a choice would change what gets delivered.",
+        "Done means: " + " · ".join(done_checklist(signals, track.done)),
     ))
+    if track.done == "change":
+        # Not "work autonomously": that competed with approval gates people add
+        # on purpose, and the guide clause above only exists when a guide does.
+        lines.append(CHANGE_CLOSE)
     return lines
 
 
+CHANGE_CLOSE = ("Finish the change and verify it; stop only for a choice that "
+                "changes what gets delivered, or an approval step a repo guide "
+                "or a loaded skill requires.")
+"""The closing banner line for a change, and only a change."""
+
+
 def route_context(prompt: str, root: Path | None = None,
                   agents_dirs: tuple[Path, ...] | None = None) -> str:
     """:func:`route_lines` as one string (``""`` when there is nothing to say)."""
@@ -648,8 +832,9 @@ bmad-create-epics-and-stories / bmad-sprint-planning; ship with bmad-build
 bmad-qa-generate-e2e-tests / bmad-retrospective; bmad-help lists the rest.
 Full workflow skills need a per-project `_bmad/` runtime — `boost bmad init`.
 
-House rule: no change is done until its tests, its docs and its tracked item
-are done with it. Turn this off with `boost bmad off`.""" % roster
+House rule: a change is done when its tests, its docs and its tracked item are;
+findings are done when each carries its evidence; an artifact is done when it is
+written down and tracked. Turn this off with `boost bmad off`.""" % roster
 
 
 # ------------------------------------------------------------ persona files
@@ -725,11 +910,18 @@ How you work:
 BMAD skills to prefer when they are installed: %s.
 They are not required — when they are absent, the playbook above is the method.
 
-Before you report back, the same contract applies to you as to the session that
-spawned you: tests updated and actually run, documentation left true, any
-tracked roadmap or backlog item moved to match, and the repo's own gate green
-with output you have seen. If you could not finish a part of it, say which part
-and why — do not narrow the task silently.
+Before you report back, meet the contract for the kind of work you were given,
+the same one the session that spawned you works to.
+
+A change: tests updated and actually run, documentation left true, any tracked
+roadmap or backlog item moved to match, and the repo's own gate green with
+output you have seen.
+Findings: each one with its evidence, and no edits unless you were asked.
+An artifact: the written document itself, with any tracked item moved to match —
+no code unless you were asked for a change, which then gets the contract above.
+
+If you could not finish a part of it, say which part and why — do not narrow
+the task silently.
 """ % (persona.slug, json.dumps(persona_description(persona)), persona.color,
        persona.character, persona.title, persona.mission, playbook, skills)
 

{boost_skill_cli-1.2.115 → boost_skill_cli-1.2.117/boost_skill_cli.egg-info}/PKG-INFO

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

{boost_skill_cli-1.2.115 → boost_skill_cli-1.2.117}/docs/bmad.md

@@ -60,8 +60,8 @@ BMAD skill: `bmad-build` — invoke it if it is installed; otherwise the persona
 Done means: tests: add or update coverage under `tests/`, and run them · docs: update
 `README.md` / `docs/` wherever the change shows · roadmap: create or claim the item under
 `docs/roadmap/items/` · gate: `make check` green, with real output · `CLAUDE.md` is binding
-Work autonomously through to a finished, verified change; stop to ask only when a choice
-would change what gets delivered.
+Finish the change and verify it; stop only for a choice that changes what gets delivered,
+or an approval step a repo guide or a loaded skill requires.
 ```
 
 Nine tracks (`build`, `quality`, `docs`, `planning`, `product`, `architecture`,
@@ -73,9 +73,23 @@ in front of you: your test directory, your docs, your roadmap items, your gate
 command. Documentation, testing and roadmap bookkeeping travel with the task
 instead of being remembered afterwards.
 
+What "done" means depends on what the track delivers. `build`, `quality`,
+`docs` and `ux` deliver a **change**, and get the contract above. `review` and
+`discovery` deliver **findings**: each with its evidence, and no edits unless
+the prompt asks for them. `product`, `planning` and `architecture` deliver an
+**artifact**: a written document with the roadmap item kept in step, and no
+code unless the prompt asked for a change. Both escapes matter: the tie-break
+puts real change requests on both kinds.
+Only a change gets the closing "finish and verify" line, and that line defers
+to any approval step your repo guide or a loaded skill requires.
+
 The router costs a question nothing. Acknowledgements, slash commands, short
-informational questions ("what does `scan_dir` do?") and anything containing
-`no bmad` produce no banner at all. A short prompt routes on a single keyword, so
+questions ("what does `scan_dir` do?", "are there tests for the parser?"),
+"read X and tell me Y" asks and anything containing `no bmad` produce no banner
+at all. Pasted output is scored on the lines you typed around it, and needs two
+keyword hits there. Within one Claude Code session a banner is sent once per
+track and repo, and a short reply ("ok, update both and rerun") keeps the lead
+it answers; `/clear` and compaction reset that. A short prompt routes on a single keyword, so
 only intent is scored: code spans, URLs, `--flags`, tracker IDs such as
 `story ABC-123` and the name of the repo you are in never count, and the `build`
 track also ignores paths and verbs aimed at you ("update me when CI finishes").

{boost_skill_cli-1.2.115 → boost_skill_cli-1.2.117}/docs/roadmap/items/bmad-done-contract-ignores-the-track.md

@@ -2,15 +2,15 @@
 id: bmad-done-contract-ignores-the-track
 board: code
 section: dx
-status: next
+status: shipped
 category: "Agents · BMAD"
 complexity: M
 impact: High
 wow: 2
 note: a review or research ask is told to add tests and finish a change
 order: 321
-owner:
-pr:
+owner: loop/bmad-done-contract
+pr: 864
 title: "<code>boost bmad</code> gives every track the build contract, so a review is told to finish a change"
 ---
 <code>route_lines</code> (<code>core/bmad.py:523</code>) takes the first four banner lines from the track

{boost_skill_cli-1.2.115 → boost_skill_cli-1.2.117}/docs/roadmap/items/bmad-router-reads-each-prompt-alone.md

@@ -2,15 +2,15 @@
 id: bmad-router-reads-each-prompt-alone
 board: code
 section: dx
-status: next
+status: shipped
 category: "Agents · BMAD"
 complexity: M
 impact: High
 wow: 3
 note: pastes, follow-up replies and yes/no questions get delegation banners
 order: 320
-owner:
-pr:
+owner: loop/bmad-prompt-context
+pr: 863
 title: "The BMAD router reads each prompt alone, so a pasted log, an “ok update both and rerun” and a yes/no question all get a banner"
 ---
 <b>The hook is handed the conversation and drops it.</b> <code>_route</code> (<code>commands/bmad.py:340</code>&ndash;<code>342</code>)