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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.115
+Version: 1.2.116
 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.116}/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.116'
+__version_tuple__ = version_tuple = (1, 2, 116)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.115 → boost_skill_cli-1.2.116}/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.116}/boost_cli/core/bmad.py

@@ -341,6 +341,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 +523,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 +540,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__")

{boost_skill_cli-1.2.115 → boost_skill_cli-1.2.116/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.116
 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.116}/docs/bmad.md

@@ -74,8 +74,12 @@ command. Documentation, testing and roadmap bookkeeping travel with the task
 instead of being remembered afterwards.
 
 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.116}/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>)

{boost_skill_cli-1.2.115 → boost_skill_cli-1.2.116}/docs/roadmap.html

@@ -7576,70 +7576,9 @@ its own pass rather than a bolt-on inside this PR. Left <code>inflight</code> ra
       </article>
 
       <article class="cap rcard" id="bmad-router-reads-each-prompt-alone">
-        <div class="head"><span class="pill next">Next</span><span class="cat">Agents · BMAD</span></div>
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Agents · BMAD</span></div>
         <h3>The BMAD router reads each prompt alone, so a pasted log, an &ldquo;ok update both and rerun&rdquo; and a yes/no question all get a banner</h3>
-        <p><b>The hook is handed the conversation and drops it.</b> <code>_route</code> (<code>commands/bmad.py:340</code>&ndash;<code>342</code>)
-reads <code>prompt</code> and <code>cwd</code> from a <code>UserPromptSubmit</code> payload that also carries
-<code>session_id</code>, <code>transcript_path</code> and (v2.1.196+) <code>prompt_id</code>, per Claude Code's hooks reference;
-Gemini's <code>BeforeAgent</code> input has the first two. So <code>classify()</code> (<code>core/bmad.py:392</code>) judges
-every message as if it opened a session, and one keyword buys a ~650-char banner whose last line opens &ldquo;Work autonomously
-through to a finished, verified change&rdquo; (<code>core/bmad.py:551</code>). A misrouted question becomes an invitation to edit.
-
-<b>Measured on one real prompt history, in aggregate.</b> Replaying origin/main's classifier over 669 history records
-from 6 active days: of 417 regular prompts, <b>147 (35%) get a banner</b> &mdash; 109 if the hook's <code>prompt</code>
-excludes pasted-text expansion, which is <em>unverified</em>. Of 318 unique prompts up to 2,000 chars, 60.7% classify
-trivial but 55.7% match no keyword at all, so the gates silence only 5.0 points of prompts that do hit one. And
-89 of the 143 routed unique prompts were decided by exactly one keyword. A <b>single judge</b> (an agent without prior
-turns) labelled 41 banners stratified by track: warranted 20, track or lead clearly wrong 21, <b>any clear failure 29</b>
-(~74% weighted by track size), fully right 3, &ldquo;Done means&rdquo; fit 5 (11 with partial). About half that history
-is the author's own tooling repos.
-
-<b>Four shapes, reproduced on origin/main</b> with synthetic prompts in a throwaway repo (banners 648&ndash;666 chars).
-<i>(a) Pasted output</i>, 4 of 5 routed: a 25-word pytest failure &rarr; <code>quality</code>; a <code>git status</code> paste
-&rarr; <code>build</code> on git's own words (<code>Changes not staged</code>, <code>use "git add &lt;file&gt;..." to update</code>);
-an 80-word npm log &rarr; <code>build</code>, clearing <code>LONG_PROMPT_WORDS</code> (<code>core/bmad.py:374</code>) on two hits,
-the word <code>build</code> and the <code>fix</code> of <code>npm audit fix</code>. The silent one, a Python traceback, just had
-no keyword. <i>(b) Replies</i>, 7 of 10: &ldquo;ok update both and rerun&rdquo; &rarr; <code>build</code>; &ldquo;sure, add a
-test for that too&rdquo; &rarr; <code>quality</code>, handing the lead to Murat mid-task. <i>(c) Yes/no questions</i>, 11 of 11:
-<code>_INFO_QUESTION</code> (<code>core/bmad.py:342</code>) knows only wh-words, so &ldquo;are there any tests for the
-parser?&rdquo; routes and &ldquo;what tests cover the parser?&rdquo; does not. <i>(d) Read-and-tell</i>, 4 of 5, the track
-picked by words inside the URL (<code>/changelog</code>, <code>docs.example.com/guide</code>, <code>api-schema-design</code>).
-
-<b>Fix, stateless, in <code>classify()</code>.</b> (1) An auxiliary opener (<code>is|are|do|does|did|has|have|should|can|could|would|will</code>)
-on a prompt ending in <code>?</code> is a question, except <code>can|could|would|will</code> + <code>you|we</code>, which is a
-request unless the verb is <code>explain|tell|describe|summarize</code>. That exception keeps
-<code>test_a_modal_request_is_not_trivial</code> (<code>tests/unit/test_bmad_core.py:74</code>) green: it pins &ldquo;can you
-fix the crash in store.install?&rdquo; as <code>build</code>. (2) <code>read|skim|look at</code> &hellip; <code>tell me|summarize</code>
-is a question unless a <code>then</code> clause follows; strip URLs before scoring. (3) Paste shape: 3+ lines, at least half
-machine-shaped (<code>$ </code>, <code>Traceback</code>, <code>File "&hellip;", line N</code>, <code>at</code> frames,
-<code>npm ERR!</code>, <code>path:line</code>, timestamps, indented lines); score only the rest and require two hits, the
-argument <code>LONG_PROMPT_WORDS</code> already makes.
-
-<b>Fix, per session, in the hook.</b> Record the last banner per <code>session_id</code> under <code>paths.state_dir()</code>,
-like <code>_state_path</code> (<code>commands/bmad.py:670</code>). A banner is a function of track and root alone, and Claude
-Code inserts <code>additionalContext</code> into the conversation where the hook fired, so a same-track banner in the same
-<code>cwd</code> repeats context the model already holds &mdash; skip it (Gemini's reference appends it &ldquo;for this turn
-only&rdquo;, so there that is unverified). A short reply (<code>yes|ok|sure|no|go ahead</code>, &le;12 words) gets none once
-the session has one. Clear the record on <code>SessionStart</code> <code>clear</code>/<code>compact</code> (the matcher at
-<code>commands/bmad.py:84</code> lacks <code>compact</code>). Reading <code>transcript_path</code> is best-effort: it is written
-asynchronously and may lag.
-
-<b>Prototyped in a scratch copy, not merged.</b> Stateless gates plus a stateless reply gate: all 109 tests in
-<code>test_bmad_core.py</code> pass, the repros route 0/5, 0/10, 0/11, 0/5, and 10 of 12 genuine-task controls still route.
-A first cut that called any auxiliary opener not followed by <code>you</code> a question routed only 4 of 12 further request
-probes (&ldquo;do the migration for the orders table&rdquo; went silent) and still bannered &ldquo;did you update the
-docs?&rdquo;; the rules above route 10 of 12 and silence all 4 question probes. Both lose &ldquo;fix this:&rdquo; over a pytest
-paste (accepted under &ldquo;rather under-route than talk over someone&rdquo;, <code>core/bmad.py:387</code>&ndash;<code>388</code>)
-and, to the reply gate, short replies that carry a task (&ldquo;ok, now implement the export command and add tests for it&rdquo;).
-Behind the session check that loss is mid-session only, where a lead and done-contract stand even if the reply changes the
-track &mdash; an accepted cost, not a solved one.
-
-<b>How to test.</b> A class in <code>tests/unit/test_bmad_core.py</code> beside <code>TestEvidenceScalesWithLength</code>
-(line 110): silence cases for all four shapes, the controls and request probes as must-route cases, the golden banner
-(line 396) unchanged; keep the session decision a pure function in <code>core/bmad.py</code> so this file covers it. The hook
-side extends <code>TestRoute</code> in <code>tests/functional/test_cli_bmad.py</code> (line 473), which already pipes JSON to
-<code>boost bmad route</code> under the <code>sandbox</code> fixture's fake HOME: same <code>session_id</code> twice &rarr; one
-banner, a new id &rarr; banner, corrupt state &rarr; exit 0.</p>
+        <p class="cardbody"><a class="writeup" href="https://github.com/jonnyeclectic/boost/blob/main/docs/roadmap/items/bmad-router-reads-each-prompt-alone.md">Write-up &middot; bmad-router-reads-each-prompt-alone.md</a></p>
         <div class="meta">
           <span class="m">Complexity <b>M</b></span>
           <span class="m hi">Impact <b>High</b></span>

{boost_skill_cli-1.2.115 → boost_skill_cli-1.2.116}/tests/functional/test_cli_bmad.py

@@ -110,7 +110,7 @@ class TestStartupToggle:
         # hook command routes back through boost
         block = cs.load("project", proj)["hooks"]["SessionStart"][0]
         assert "bmad orient --scope project" in block["hooks"][0]["command"]
-        assert block["matcher"] == "startup|resume|clear"
+        assert block["matcher"] == "startup|resume|clear|compact"
 
         boost("bmad", "startup", "off")
         assert not cs.has_hook("project", "SessionStart", "bmad", project_dir=proj)
@@ -292,6 +292,17 @@ class TestDoctor:
         assert "autopilot=on" in r.out
         assert "%d personas" % len(core_bmad.PERSONAS) in r.out
 
+    def test_an_old_briefing_hook_is_reported_as_stale(
+            self, boost, sandbox, proj):
+        """The matcher lives in the user's settings.json from their last `on`,
+        so an install from before `compact` never forgets a compacted session."""
+        boost("bmad", "on")
+        assert "stale matcher" not in boost("bmad", "doctor").out
+        cs.add_hook("global", "SessionStart", bmad.HOOK_NAME, "x",
+                    matcher="startup|resume|clear")
+        r = boost("bmad", "doctor")
+        assert "briefing=on (stale matcher: re-run `boost bmad on`)" in r.out
+
     def test_autopilot_reads_as_off_when_the_hook_is_gone(
             self, boost, sandbox, proj):
         """State alone is not the truth — the router hook has to be there."""
@@ -599,6 +610,129 @@ class TestRoute:
         assert r.rc == 0 and r.out == ""
 
 
+class TestRouteRemembersTheSession:
+    """A banner the session already holds is not sent again.
+
+    The hook is handed `session_id` and used to drop it, so every prompt was
+    judged as if it opened a session: a same-track follow-up re-sent ~650 chars
+    the model already had, and "sure, add a test for that too" handed the lead
+    to Murat mid-task.
+    """
+
+    def _hook(self, boost, monkeypatch, proj, prompt, session="s1", **extra):
+        payload = {"prompt": prompt, "cwd": str(proj), "session_id": session}
+        payload.update(extra)
+        monkeypatch.setattr(sys, "stdin", io.StringIO(json.dumps(payload)))
+        return boost("bmad", "route", expect=None).out
+
+    def test_the_same_track_twice_in_one_session_is_one_banner(
+            self, boost, sandbox, monkeypatch, proj):
+        boost("bmad", "on")
+        assert "track: build" in self._hook(
+            boost, monkeypatch, proj, "implement the export command")
+        assert self._hook(boost, monkeypatch, proj,
+                          "refactor the export command too") == ""
+
+    def test_a_new_session_gets_its_own_banner(
+            self, boost, sandbox, monkeypatch, proj):
+        boost("bmad", "on")
+        self._hook(boost, monkeypatch, proj, "implement the export command")
+        assert "track: build" in self._hook(
+            boost, monkeypatch, proj, "implement the export command", "s2")
+
+    def test_a_new_track_is_news(self, boost, sandbox, monkeypatch, proj):
+        boost("bmad", "on")
+        self._hook(boost, monkeypatch, proj, "implement the export command")
+        assert "track: quality" in self._hook(
+            boost, monkeypatch, proj, "add tests for the export command")
+
+    def test_a_reply_continues_the_task_it_answers(
+            self, boost, sandbox, monkeypatch, proj):
+        boost("bmad", "on")
+        self._hook(boost, monkeypatch, proj, "implement the export command")
+        assert self._hook(boost, monkeypatch, proj,
+                          "sure, add a test for that too") == ""
+
+    def test_a_trivial_prompt_leaves_no_record(
+            self, boost, sandbox, monkeypatch, proj):
+        boost("bmad", "on")
+        self._hook(boost, monkeypatch, proj, "what is a tap?")
+        assert "track: build" in self._hook(
+            boost, monkeypatch, proj, "ok update both and rerun")
+
+    @pytest.mark.parametrize("source", ["clear", "compact"])
+    def test_clear_and_compact_forget_the_banner(
+            self, boost, sandbox, monkeypatch, proj, source):
+        boost("bmad", "on")
+        self._hook(boost, monkeypatch, proj, "implement the export command")
+        monkeypatch.setattr(sys, "stdin", io.StringIO(json.dumps(
+            {"session_id": "s1", "source": source})))
+        boost("bmad", "orient", "--scope", "global")
+        assert "track: build" in self._hook(
+            boost, monkeypatch, proj, "refactor the export command too")
+
+    def test_resume_keeps_it(self, boost, sandbox, monkeypatch, proj):
+        boost("bmad", "on")
+        self._hook(boost, monkeypatch, proj, "implement the export command")
+        monkeypatch.setattr(sys, "stdin", io.StringIO(json.dumps(
+            {"session_id": "s1", "source": "resume"})))
+        assert "BMAD autopilot active" in boost(
+            "bmad", "orient", "--scope", "global").out
+        assert self._hook(boost, monkeypatch, proj,
+                          "refactor the export command too") == ""
+
+    def test_gemini_gets_the_banner_every_turn(
+            self, boost, sandbox, monkeypatch, proj):
+        """Gemini appends hook context for one turn only."""
+        boost("bmad", "on")
+        for _ in range(2):
+            assert "track: build" in self._hook(
+                boost, monkeypatch, proj, "implement the export command",
+                hook_event_name="BeforeAgent")
+
+    @pytest.mark.parametrize("junk", ["{{{", "[]"])
+    def test_an_unreadable_record_file_costs_one_banner_not_the_hook(
+            self, boost, sandbox, monkeypatch, proj, junk):
+        boost("bmad", "on")
+        path = bmad._sessions_path()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(junk, encoding="utf-8")
+        assert "track: build" in self._hook(
+            boost, monkeypatch, proj, "implement the export command")
+        assert json.loads(path.read_text(encoding="utf-8"))["s1"]["track"] == "build"
+
+    def test_an_unwritable_state_dir_costs_a_banner_not_the_router(
+            self, boost, sandbox, monkeypatch, proj):
+        """The record is written after the banner is built, so an escaping
+        OSError silenced every banner instead of repeating one."""
+        boost("bmad", "on")
+        monkeypatch.setattr(bmad.util, "atomic_write_text",
+                            lambda *a, **k: (_ for _ in ()).throw(OSError("full")))
+        for _ in range(2):
+            assert "track: build" in self._hook(
+                boost, monkeypatch, proj, "implement the export command")
+
+    def test_the_record_file_stays_bounded(
+            self, boost, sandbox, monkeypatch, proj):
+        boost("bmad", "on")
+        old = {"old%03d" % i: {"track": "build", "root": "/x",
+                               "at": "2020-01-01T00:00:%02dZ" % (i % 60)}
+               for i in range(bmad.SESSIONS_KEPT)}
+        bmad._sessions_write(old)
+        self._hook(boost, monkeypatch, proj, "implement the export command", "new")
+        kept = json.loads(bmad._sessions_path().read_text(encoding="utf-8"))
+        assert len(kept) == bmad.SESSIONS_KEPT and "new" in kept
+
+    def test_the_oldest_record_is_the_one_dropped(self, sandbox):
+        records = {"b": {"at": "2026-01-02"}, "a": {"at": "2026-01-01"},
+                   "junk": "not a record"}
+        records.update({"k%03d" % i: {"at": "2026-02-%02d" % (i % 28 + 1)}
+                        for i in range(bmad.SESSIONS_KEPT - 1)})
+        bmad._sessions_write(records)
+        kept = json.loads(bmad._sessions_path().read_text(encoding="utf-8"))
+        assert "junk" not in kept and "a" not in kept and "b" in kept
+
+
 class TestRouteFollowsAutopilotState:
     """The router hook speaks only while the autopilot is on, like the briefing.