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

{boost_skill_cli-1.2.116/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.116
+Version: 1.2.117
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0

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

{boost_skill_cli-1.2.116 → 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, ...] = (
@@ -680,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")
@@ -711,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
@@ -756,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)."""
@@ -793,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
@@ -870,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.116 → 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.116
+Version: 1.2.117
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0

{boost_skill_cli-1.2.116 → 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,6 +73,16 @@ 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
 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

{boost_skill_cli-1.2.116 → 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.116 → boost_skill_cli-1.2.117}/docs/roadmap.html

@@ -7588,68 +7588,9 @@ its own pass rather than a bolt-on inside this PR. Left <code>inflight</code> ra
       </article>
 
       <article class="cap rcard" id="bmad-done-contract-ignores-the-track">
-        <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><code>boost bmad</code> gives every track the build contract, so a review is told to finish a change</h3>
-        <p><code>route_lines</code> (<code>core/bmad.py:523</code>) takes the first four banner lines from the track
-and the last two ignore it: <code>done_checklist(signals)</code> (<code>:483</code>) has no
-track parameter, and the autonomy sentence (<code>:551</code>) is a literal. One prompt per track against
-one fixture repo gave <b>one distinct pair of closing lines across all 9 tracks</b>:<br>
-<code>Done means: tests: add or update coverage under `tests/`, and run them · docs: update `README.md` / `docs/` wherever the change shows · gate: `make check` green, with real output · `CLAUDE.md` is binding</code><br>
-<code>Work autonomously through to a finished, verified change; stop to ask only when a choice would change what gets delivered.</code>
-
-<b>Repro</b> (throwaway repo with <code>tests/</code>, <code>docs/</code>, <code>README.md</code>,
-<code>CLAUDE.md</code>, and a <code>Makefile</code> with <code>check:</code>).
-<code>boost bmad route "review the changes on this branch and tell me what could break" --plain</code>
-names Murat (<code>bmad-tea</code>) as lead with <code>bmad-code-review</code>, then defines done as new
-coverage, updated docs and a finished, verified change. <code>"compare the two caching options and recommend one"</code>,
-<code>"write the PRD for the policy engine"</code> and <code>"prioritize the backlog for next sprint"</code>
-get the same two lines. In an empty repo the comparison is told <code>tests: cover the change … docs: write down what changed</code>, but nothing changed.
-The shared lines are 48% of the fixture's review banner (326 of 673 chars) and 41% in the empty repo.
-
-<b>Against real prompts the clause seldom fits.</b> Replaying the origin/main classifier over one
-profile's history (417 ordinary prompts over 6 active days, roughly half from tooling repos): 147 (35%)
-would get a banner, or 109 if pasted text is not in the hook's <code>prompt</code> field (not yet
-checked). A <em>single judge</em> (an agent) labelled 41 routed banners, sampled by track: <code>Done means</code>
-fit <b>5 of 41</b> (11 counting partial fits).
-
-<b>The same contract appears in three places, and one was a deliberate choice.</b> The autopilot item
-made tests and docs unconditional (&ldquo;no doc change needed&rdquo; is a conclusion to reach), and
-<code>tests/unit/test_bmad_core.py:331</code> enforces that. It is right for a change and wrong for an
-answer. Every persona file repeats the contract (<code>_persona_text</code>,
-<code>core/bmad.py:663&ndash;667</code>: &ldquo;tests updated and actually run, documentation left true …&rdquo;),
-so the <code>bmad-analyst</code> a discovery banner hands off to brings it back. The SessionStart
-briefing says to follow the banner (<code>:576</code>) and ends on a tests-docs-item house rule
-(<code>:586</code>).
-
-<b>The autonomy line competes with approval gates users add on purpose</b>, such as the
-<code>HARD-GATE</code> in superpowers' <code>brainstorming</code> skill (no implementation until the user
-approves) or a team rule requiring confirmation before a change that affects production. The banner is
-<code>UserPromptSubmit</code> <code>additionalContext</code> (<code>commands/bmad.py:354</code>), added
-again on every routed prompt. <b>Untested:</b> which instruction a model follows when they
-conflict. Softening the line to defer to the repo guide would not cover this: the <code>is binding</code>
-clause only appears when a guide file exists (<code>core/bmad.py:514&ndash;516</code>), and a plugin skill is not a guide file.
-
-<b>Fix: store the kind of done on <code>Track</code></b> (<code>core/bmad.py:75</code>) and pass it to
-<code>done_checklist(signals, done)</code>. <i>change</i> (build, quality, docs, ux): today's clauses,
-unchanged. <i>findings</i> (review, discovery): &ldquo;findings with evidence, no edits unless
-asked&rdquo;. The &ldquo;unless asked&rdquo; matters because the tie-break sends <code>"fix the lint
-errors in the scanner"</code> to review and <code>"investigate why the export crashes and fix it"</code>
-to discovery. <i>artifact</i> (product, planning, architecture): &ldquo;a written artifact, no
-code&rdquo;, keeping the roadmap and guide clauses. Drop the autonomy line from
-findings and artifact tracks. On change tracks, replace it with wording that does not depend on a
-guide file: finish and verify, and still honour any approval step that the guide or a loaded skill
-requires. <code>_persona_text</code> should state the contract for each kind, since
-<code>bmad-tea</code> leads both quality and review. The house rule should name all three kinds.
-
-<b>Tests go in <code>tests/unit/test_bmad_core.py</code>.</b> Assert every <code>TRACKS</code> entry
-declares a kind, and that no findings or artifact banner has a <code>tests:</code> clause.
-Add verbatim review and discovery banners next to <code>test_the_whole_banner_is_exactly_this</code>
-(<code>:396</code>), whose build pin keeps its <code>Done means</code> line and takes the new closing line.
-Limit <code>:331</code> to change tracks. <code>:376</code> pins <code>autonom</code> on one build banner:
-move it to the new wording and assert the line is absent from findings and artifact banners.
-<code>:688</code> only checks that each persona file mentions tests and docs, so pin the per-kind persona
-contract directly. Out of scope: router accuracy (same single judge: track or lead clearly wrong on
-21 of 41) is a separate defect.</p>
+        <p class="cardbody"><a class="writeup" href="https://github.com/jonnyeclectic/boost/blob/main/docs/roadmap/items/bmad-done-contract-ignores-the-track.md">Write-up &middot; bmad-done-contract-ignores-the-track.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.116 → boost_skill_cli-1.2.117}/tests/unit/test_bmad_core.py

@@ -654,11 +654,70 @@ class TestDoneChecklist:
             "docs: write down what changed for the next reader",
         ]
 
-    def test_always_demands_tests_and_docs_even_in_a_bare_repo(self, tmp_path):
-        line = " ".join(bmad.done_checklist(bmad.project_signals(tmp_path)))
+    def test_a_change_always_demands_tests_and_docs_even_in_a_bare_repo(
+            self, tmp_path):
+        line = " ".join(bmad.done_checklist(bmad.project_signals(tmp_path),
+                                            "change"))
         assert "test" in line.lower()
         assert "doc" in line.lower()
 
+    def _full_repo(self, root):
+        (root / "tests").mkdir()
+        (root / "docs" / "roadmap" / "items").mkdir(parents=True)
+        (root / "CLAUDE.md").write_text("rules", encoding="utf-8")
+        (root / "Makefile").write_text("check:\n\ttrue\n", encoding="utf-8")
+        return bmad.project_signals(root)
+
+    def test_findings_are_evidence_and_no_edits_unless_asked(self, tmp_path):
+        """"fix the lint errors in the scanner" routes to review, hence "unless"."""
+        assert bmad.done_checklist(self._full_repo(tmp_path), "findings") == [
+            "findings: each with its evidence (file:line, output or source)",
+            "no edits unless asked; an edit gets tests and `make check` like "
+            "any change",
+            "`CLAUDE.md` is binding",
+        ]
+
+    def test_findings_in_a_bare_repo_name_no_gate(self, tmp_path):
+        assert bmad.done_checklist(bmad.project_signals(tmp_path), "findings") == [
+            "findings: each with its evidence (file:line, output or source)",
+            "no edits unless asked; an edit gets tests like any change",
+        ]
+
+    def test_an_artifact_is_written_not_coded_and_keeps_the_roadmap(self, tmp_path):
+        assert bmad.done_checklist(self._full_repo(tmp_path), "artifact") == [
+            "a written artifact; no code unless the prompt asks for a change, "
+            "which then gets the change contract",
+            "roadmap: create or claim the item under `docs/roadmap/items/`",
+            "`CLAUDE.md` is binding",
+        ]
+
+    def test_an_artifact_in_a_bare_repo_is_just_the_artifact(self, tmp_path):
+        assert bmad.done_checklist(bmad.project_signals(tmp_path), "artifact") == [
+            "a written artifact; no code unless the prompt asks for a change, "
+            "which then gets the change contract"]
+
+    @pytest.mark.parametrize("kind", ["findings", "artifact"])
+    def test_neither_kind_refuses_work_that_was_asked_for(self, tmp_path, kind):
+        """The tie-break sends real change requests onto both kinds: "fix the
+        lint errors in the scanner" is review, "implement the spec in
+        specs/retry.md" is product. A flat "no code" contradicts the prompt."""
+        line = " ".join(bmad.done_checklist(bmad.project_signals(tmp_path), kind))
+        assert "unless" in line and ("asked" in line or "asks" in line)
+
+    def test_an_edit_request_that_tie_breaks_onto_product_is_not_told_no_code(
+            self, tmp_path):
+        assert bmad.classify("implement the spec in specs/retry.md",
+                             tmp_path) == "product"
+        done = next(ln for ln in
+                    bmad.route_lines("implement the spec in specs/retry.md", tmp_path)
+                    if ln.startswith("Done means:"))
+        assert "no code unless the prompt asks for a change" in done
+
+    def test_the_default_kind_is_a_change(self, tmp_path):
+        signals = self._full_repo(tmp_path)
+        assert bmad.done_checklist(signals) == bmad.done_checklist(signals,
+                                                                   "change")
+
     def test_no_roadmap_means_no_roadmap_clause(self, tmp_path):
         line = " ".join(bmad.done_checklist(bmad.project_signals(tmp_path)))
         assert "roadmap" not in line.lower()
@@ -699,9 +758,44 @@ class TestRouteContext:
         assert len(bmad.route_lines("implement the new export command", tmp_path)) <= 8
         assert len(text) < 1200
 
-    def test_it_tells_the_agent_not_to_wait_for_a_human(self, tmp_path):
-        text = bmad.route_context("fix the crash in store.install", tmp_path)
-        assert "autonom" in text.lower()
+    def test_a_change_is_finished_but_approval_steps_still_hold(self, tmp_path):
+        """Not "work autonomously": that line competed with approval gates a
+        user adds on purpose, such as a brainstorming skill's HARD-GATE."""
+        lines = bmad.route_lines("fix the crash in store.install", tmp_path)
+        assert lines[-1] == bmad.CHANGE_CLOSE
+        assert "approval step" in bmad.CHANGE_CLOSE
+        assert "autonom" not in bmad.route_context(
+            "fix the crash in store.install", tmp_path).lower()
+
+    @pytest.mark.parametrize("prompt,kind", [
+        ("review the changes on this branch and tell me what could break",
+         "findings"),
+        ("compare the two caching options and recommend one", "findings"),
+        ("write the PRD for the policy engine", "artifact"),
+        ("prioritize the backlog for next sprint", "artifact"),
+        ("design the schema for the pulse feed", "artifact"),
+    ])
+    def test_findings_and_artifacts_get_no_build_contract(
+            self, tmp_path, prompt, kind):
+        (tmp_path / "tests").mkdir()
+        (tmp_path / "README.md").write_text("x", encoding="utf-8")
+        (tmp_path / "Makefile").write_text("check:\n\ttrue\n", encoding="utf-8")
+        track = bmad.classify(prompt, tmp_path)
+        assert bmad.TRACKS[track].done == kind
+        lines = bmad.route_lines(prompt, tmp_path)
+        done = next(line for line in lines if line.startswith("Done means:"))
+        assert "tests:" not in done and "docs:" not in done
+        assert bmad.CHANGE_CLOSE not in lines
+        assert lines[-1] == done
+
+    def test_every_track_declares_what_it_delivers(self):
+        assert {name: t.done for name, t in bmad.TRACKS.items()} == {
+            "build": "change", "quality": "change", "docs": "change",
+            "ux": "change", "review": "findings", "discovery": "findings",
+            "product": "artifact", "planning": "artifact",
+            "architecture": "artifact",
+        }
+        assert set(bmad.DONE_KINDS) == {t.done for t in bmad.TRACKS.values()}
 
     def test_quality_prompts_lead_with_the_test_architect(self, tmp_path):
         text = bmad.route_context("add tests for catalog.scan_dir", tmp_path)
@@ -742,8 +836,39 @@ class TestRouteContext:
             "Done means: tests: add or update coverage under `tests/`, and run "
             "them · docs: update `README.md` wherever the change shows · "
             "gate: `make check` green, with real output",
-            "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.",
+        ]
+
+    def test_the_whole_review_banner_is_exactly_this(self, tmp_path):
+        (tmp_path / "tests").mkdir()
+        (tmp_path / "Makefile").write_text("check:\n\ttrue\n", encoding="utf-8")
+        assert bmad.route_lines("review the changes on this branch", tmp_path) == [
+            "[BMAD autopilot] track: review",
+            "Lead: `bmad-tea` subagent — Murat, Master Test Architect. "
+            "Find the failure, not the style nit.",
+            "Support: `bmad-architect` (Winston) — spawn them with the Agent "
+            "tool, in parallel where the work is independent.",
+            "BMAD skill: `bmad-code-review` — invoke it if it is installed; "
+            "otherwise the persona's own playbook stands.",
+            "Done means: findings: each with its evidence (file:line, output or "
+            "source) · no edits unless asked; an edit gets tests and "
+            "`make check` like any change",
+        ]
+
+    def test_the_whole_discovery_banner_is_exactly_this(self, tmp_path):
+        assert bmad.route_lines("research how other CLIs pin their toolchains",
+                                tmp_path) == [
+            "[BMAD autopilot] track: discovery",
+            "Lead: `bmad-analyst` subagent — Mary, Business Analyst. "
+            "Ground it in sources before recommending.",
+            "Support: `bmad-pm` (John) — spawn them with the Agent tool, in "
+            "parallel where the work is independent.",
+            "BMAD skill: `bmad-deep-recon` — invoke it if it is installed; "
+            "otherwise the persona's own playbook stands.",
+            "Done means: findings: each with its evidence (file:line, output or "
+            "source) · no edits unless asked; an edit gets tests like any change",
         ]
 
     def test_no_persona_file_anywhere_means_no_subagent_is_named(self, tmp_path):
@@ -816,6 +941,12 @@ class TestOrientation:
     def test_it_names_the_command_that_turns_it_off(self):
         assert "boost bmad off" in bmad.orientation()
 
+    def test_the_house_rule_names_all_three_kinds_of_done(self):
+        rule = bmad.orientation().split("House rule:")[1]
+        assert "a change is done when its tests, its docs and its tracked item" in rule
+        assert "findings are done when each carries its evidence" in rule
+        assert "an artifact is done when it is\nwritten down and tracked" in rule
+
 
 # -------------------------------------------------------------------- personas
 
@@ -1042,11 +1173,18 @@ class TestOwnershipStamp:
             p.slug for p in bmad.PERSONAS if p.slug != "bmad-dev")
         assert (tmp_path / "bmad-dev.md").exists()
 
-    def test_every_persona_body_carries_the_done_contract(self):
+    CONTRACT = """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."""
+
+    def test_every_persona_body_states_the_contract_for_each_kind(self):
+        """`bmad-tea` leads quality (a change) and review (findings), so a
+        persona cannot carry one kind's contract."""
         for p in bmad.PERSONAS:
-            md = bmad.persona_markdown(p)
-            low = md.lower()
-            assert "test" in low and "doc" in low
+            assert self.CONTRACT in bmad.persona_markdown(p), p.slug
 
     def test_persona_descriptions_are_delegation_triggers(self):
         """Claude picks a subagent off `description`; it must say when to use it."""