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

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

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

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

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

@@ -117,7 +117,7 @@ def cmd_bmad(argv) -> int:
     if args.action == "off":
         return _autopilot_off(args.scope)
     if args.action == "route":
-        return _route(args.value, args.plain)
+        return _route(args.value, args.plain, args.scope)
     if args.action == "personas":
         return _personas(args.scope)
     if args.action == "install":
@@ -255,6 +255,9 @@ def _autopilot_on(scope) -> int:
     """
     scope = scope or "global"
     agents = _agents_dir(scope)
+    # Asked before writing: whether this run *creates* the directory decides
+    # what running sessions can see (see the restart line below).
+    fresh = not agents.is_dir()
     _written, skipped = core.write_personas(agents)
     # A skipped (edited) persona file is still on disk and Claude Code still
     # loads it — only the ones neither written nor present at all are truly
@@ -267,7 +270,7 @@ def _autopilot_on(scope) -> int:
         scope, _ORIENT_HOOK,
         _never_fails("%s bmad orient --scope %s" % (launcher, scope)))
     _add_hook_everywhere(scope, _ROUTE_HOOK,
-                         _never_fails("%s bmad route" % launcher))
+                         _never_fails("%s bmad route --scope %s" % (launcher, scope)))
     _set_scope_state(scope, autopilot=True, startup=True, personas=present,
                      enabled_at=util.now_iso())
     journal.log("bmad-autopilot", "on", scope=scope, personas=present)
@@ -286,9 +289,13 @@ def _autopilot_on(scope) -> int:
                    hookhost.translate(host, "UserPromptSubmit")))
     out.dim("  every substantive prompt now names its lead persona and its "
             "definition of done; trivial asks are left alone")
-    # Claude Code only watches an agents dir that existed when the session
-    # started, so a first-ever install is invisible until the next launch.
-    out.info("restart your agent session to pick up the new subagents")
+    # Hook edits reach open sessions through the settings watcher, but Claude
+    # Code only watches an agents dir that existed when the session started. So
+    # a run that creates the dir starts banners before their personas can load;
+    # one that finds it already there is picked up live and needs no restart.
+    if fresh:
+        out.info("routing banners can start in open sessions now; restart "
+                 "them to use the new subagents")
     out.dim("  full BMAD workflow skills (needs Node): boost bmad install")
     return 0
 
@@ -328,20 +335,33 @@ def _read_hook_stdin() -> dict:
     return data if isinstance(data, dict) else {"prompt": raw}
 
 
-def _route(prompt, plain) -> int:
+def _route(prompt, plain, scope=None) -> int:
     """UserPromptSubmit hook target: classify, then emit the routing banner.
 
     This runs on every single prompt, so it has exactly one hard rule: **always
     exit 0**. On UserPromptSubmit an exit code of 2 blocks the prompt and erases
     it from the transcript — a crash here would eat the user's message. Every
     failure mode therefore degrades to silence.
+
+    Run as a hook (no positional prompt, no ``--plain``) it speaks only while
+    the autopilot is on, the same rule `_orient` applies. `off` works by
+    deleting the hook, so without this any copy it missed kept routing: a
+    committed `.claude/settings.json` in a second checkout, or a settings
+    snapshot restored from boost's own history. A human asking what a prompt
+    would route to gets the answer whatever the state.
     """
     try:
         payload = {} if prompt else _read_hook_stdin()
         text = prompt or str(payload.get("prompt") or "")
         cwd = payload.get("cwd")
         root = Path(cwd) if cwd else Path.cwd()
-        banner = core.route_context(text, root)
+        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"))
+        else:
+            return 0
     except Exception:                     # a hook must never break the session
         return 0
     if not banner:
@@ -689,15 +709,28 @@ def _state_write(d: dict) -> None:
     _state_path().write_text(json.dumps(d, indent=2) + "\n", encoding="utf-8")
 
 
-def _proj_key() -> str:
-    return str(Path.cwd().resolve())
+def _proj_key(project=None) -> str:
+    return str(Path(project or Path.cwd()).resolve())
 
 
-def _get_scope_state(scope) -> dict:
+def _get_scope_state(scope, project=None) -> dict:
     d = _state_read()
     if scope == "global":
         return d["global"]
-    return d["projects"].get(_proj_key(), {})
+    return d["projects"].get(_proj_key(project), {})
+
+
+def _autopilot_live(scope, root) -> bool:
+    """Whether the router hook for ``scope`` may speak in the repo at ``root``.
+
+    Project state is keyed by the exact checkout path, the key `_orient` uses. A
+    nearest-parent lookup would route in a worktree nested under the repo while
+    the briefing stayed silent — the disagreement this check exists to end. A
+    hook with no ``--scope`` (every install before this one wrote it that way)
+    accepts either scope until the next `boost bmad on` rewrites it.
+    """
+    scopes = (scope,) if scope else ("global", "project")
+    return any(_get_scope_state(sc, root).get("autopilot") for sc in scopes)
 
 
 def _set_scope_state(scope, **patch) -> None:

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

@@ -575,11 +575,18 @@ def done_checklist(signals: dict) -> list[str]:
 
 # --------------------------------------------------------------------- routing
 
-def route_lines(prompt: str, root: Path | None = None) -> list[str]:
+def route_lines(prompt: str, root: Path | None = None,
+                agents_dirs: tuple[Path, ...] | None = None) -> list[str]:
     """The banner for one prompt: `[]` when the prompt is not a unit of work.
 
     Kept to a handful of lines on purpose — this is prepended to *every*
     substantive prompt, so its cost is paid on each turn of every session.
+
+    ``agents_dirs`` are the directories a session loads subagents from. When
+    given, and the lead's file is in none of them, the Lead and Support lines
+    are dropped: naming a subagent the session cannot spawn sends the model
+    after something that does not exist. An edited file counts as present —
+    it is still a subagent, just no longer boost's.
     """
     root = Path(root) if root is not None else Path.cwd()
     track_name = classify(prompt, root)
@@ -588,13 +595,14 @@ def route_lines(prompt: str, root: Path | None = None) -> list[str]:
     track = TRACKS[track_name]
     lead = PERSONA_BY_SLUG[track.lead]
     signals = project_signals(root)
-
-    lines = [
-        "[BMAD autopilot] track: %s" % track_name,
-        "Lead: `%s` subagent — %s, %s. %s"
-        % (lead.slug, lead.character, lead.title, track.note),
-    ]
-    if track.support:
+    delegate = agents_dirs is None or any(
+        persona_state(d, lead) != "absent" for d in agents_dirs)
+
+    lines = ["[BMAD autopilot] track: %s" % track_name]
+    if delegate:
+        lines.append("Lead: `%s` subagent — %s, %s. %s"
+                     % (lead.slug, lead.character, lead.title, track.note))
+    if delegate and track.support:
         lines.append(
             "Support: %s — spawn them with the Agent tool, in parallel where "
             "the work is independent."
@@ -610,9 +618,10 @@ def route_lines(prompt: str, root: Path | None = None) -> list[str]:
     return lines
 
 
-def route_context(prompt: str, root: Path | None = None) -> str:
+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)."""
-    return "\n".join(route_lines(prompt, root))
+    return "\n".join(route_lines(prompt, root, agents_dirs))
 
 
 # ----------------------------------------------------------------- orientation

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

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

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

@@ -81,7 +81,10 @@ only intent is scored: code spans, URLs, `--flags`, tracker IDs such as
 track also ignores paths and verbs aimed at you ("update me when CI finishes").
 Because a `UserPromptSubmit` hook that exits
 non-zero would erase your prompt, it degrades every failure to silence and
-always exits 0.
+always exits 0. The hook also speaks only while the autopilot is on for its
+scope, so a copy `boost bmad off` could not reach (a committed project
+`.claude/settings.json` in another checkout, a restored settings snapshot) stays
+silent, and a banner never names a persona whose file is gone.
 
 ```bash
 boost bmad personas                            # the roster, and whether it's installed

{boost_skill_cli-1.2.114 → boost_skill_cli-1.2.115}/docs/roadmap/items/bmad-route-ignores-autopilot-state.md

@@ -2,15 +2,15 @@
 id: bmad-route-ignores-autopilot-state
 board: code
 section: dx
-status: next
+status: shipped
 category: Agents · BMAD
 complexity: S
 impact: Med
 wow: 2
 note: the briefing hook checks state, the router never does
 order: 322
-owner:
-pr:
+owner: loop/bmad-route-state
+pr: 862
 title: <code>bmad route</code> never checks autopilot state, so any hook <code>off</code> missed keeps routing
 ---
 The two autopilot hooks disagree about what decides whether they speak. <code>_orient</code>

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

@@ -7720,69 +7720,9 @@ contract directly. Out of scope: router accuracy (same single judge: track or le
       </article>
 
       <article class="cap rcard" id="bmad-route-ignores-autopilot-state">
-        <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>bmad route</code> never checks autopilot state, so any hook <code>off</code> missed keeps routing</h3>
-        <p>The two autopilot hooks disagree about what decides whether they speak. <code>_orient</code>
-(<code>boost_cli/commands/bmad.py:525-531</code>) prints only when its scope's state says so, and its hook names the
-scope (<code>:266-268</code>). <code>_route</code> (<code>:331-356</code>) reads the prompt and the payload
-<code>cwd</code> and nothing else, and its hook is a bare <code>&lt;launcher&gt; bmad route || true</code>
-(<code>:269-270</code>). Only <code>status</code> reads the <code>autopilot</code> flag, and it already applies the
-right rule: on means state <em>and</em> hook (<code>:625</code>, pinned by
-<code>test_autopilot_reads_as_off_when_the_hook_is_gone</code>). <code>off</code> works only because it deletes the
-hook, so any copy it misses keeps routing. Replayed once over one real prompt history, the router bannered <b>147 of
-417</b> regular prompts (35%; 109 if pasted text is not part of the hook's <code>prompt</code> field, which was not
-checked), averaging ~163 tokens.
-
-<b>Copies it misses are ordinary. Two were reproduced in a throwaway HOME.</b> <i>(1) A worktree or second
-checkout.</i> <code>on --scope project</code> writes the hook into <code>.claude/settings.json</code>, which Claude
-Code's docs tell teams to commit, but keys state by the absolute checkout path (<code>:692-693</code>). In a copy of
-the checkout, <code>status</code> reads <code>project autopilot=off 7 personas router=on briefing=on</code>,
-<code>orient</code> prints <b>0 bytes</b> and <code>route</code> prints <b>711 bytes</b> of hook JSON.
-<i>(2) The restore net.</i> Every hook write that changes the file snapshots the prior version into
-<code>claude-settings-history/</code> (<code>boost_cli/core/claude_settings.py:19-21, 88-124</code>). <code>off</code>
-removes the two hooks in two saves, so the last snapshot it writes holds <em>only</em> the router. Copy it back and
-state says <code>autopilot:false</code>, no personas are on disk, the hook still sends a <b>594-char</b> banner, and
-<code>status</code> suggests turning the autopilot on (<code>commands/bmad.py:632-633</code>).
-
-<b>The first <code>on</code> reaches running sessions before its personas can.</b> The hooks docs say edits to hooks
-in settings files &ldquo;are normally picked up automatically by the file watcher&rdquo;. The sub-agents docs say
-the agents-directory watcher &ldquo;covers only directories that existed when the session started&rdquo;, and
-<code>write_personas</code> creates <code>~/.claude/agents</code> when it is absent (<code>core/bmad.py:680</code>).
-Read together (inferred from the docs, not observed in a live session), a first install that creates the directory
-can start banners in open sessions before any restart, naming a lead subagent and support personas those sessions
-cannot load. The command only says &ldquo;restart your agent session to pick up the new subagents&rdquo;
-(<code>commands/bmad.py:289-291</code>), not that the banners are already live.
-
-<b>Fix.</b> <i>(1)</i> Install <code>&lt;launcher&gt; bmad route --scope &lt;scope&gt; || true</code> and pass
-<code>args.scope</code> through (<code>commands/bmad.py:120</code>). When <code>_route</code> runs as a hook (no
-positional prompt, no <code>--plain</code>), it returns 0 silently inside its existing <code>try</code> unless that
-scope's state has <code>autopilot</code>. Project scope looks up the payload <code>cwd</code> with the same exact
-key <code>_orient</code> uses (<code>:692-693</code>). A nearest-parent lookup would route in a worktree nested under
-the repo while the briefing stays silent, which is this defect again. A hook with no <code>--scope</code>, as on
-every current install, accepts either scope until the next <code>on</code> replaces it. A corrupt state file reads as
-empty, so the router stays silent. <i>(2)</i> For a live autopilot whose persona files are gone, drop the Lead and Support lines when the
-lead's <code>.md</code> is in neither <code>~/.claude/agents</code> nor the project's. Check with
-<code>persona_state()</code> (<code>core/bmad.py:707-720</code>), not <code>installed_personas()</code>
-(<code>:693-704</code>), which requires an unedited digest and would drop the lead for anyone who hand-edited
-<code>bmad-dev.md</code>. <i>(3)</i>
-<code>on</code> checks <code>agents.is_dir()</code> before writing. If the directory is new, say that banners can
-start in open sessions immediately and a restart is needed to use the personas. If it already existed, drop the
-restart line.
-
-<b>Checked and left alone.</b> <code>off</code> leaves an empty agents directory. Keep it, because it lets the
-<em>next</em> <code>on</code> reach running sessions without a restart.
-
-<b>Tests.</b> In <code>tests/functional/test_cli_bmad.py</code>,
-<code>TestRoute.test_emits_the_hook_json_contract</code> and
-<code>test_uses_the_cwd_the_hook_reports_not_its_own</code> assert a banner where <code>on</code> never ran. They
-pin the defect, so they should run <code>on</code> first. So should
-<code>test_trivial_prompts_produce_no_output_at_all</code> and <code>test_a_project_signal_failure_still_exits_zero</code>,
-which would otherwise pass vacuously once state gates the router. Add <code>TestRoute</code> cases for state off
-(empty stdout, exit 0), the second-checkout repro, a corrupt state file (as in
-<code>TestOrient.test_a_broken_state_file_never_breaks_the_session</code>), and positional or <code>--plain</code>
-input still printing. <code>TestAutopilotOn</code> should check <code>--scope global</code> on the route hook and
-split its <code>"restart"</code> assertion by whether the directory existed. Also add a personas-absent case to
-<code>TestRouteContext</code> in <code>tests/unit/test_bmad_core.py</code>.</p>
+        <p class="cardbody"><a class="writeup" href="https://github.com/jonnyeclectic/boost/blob/main/docs/roadmap/items/bmad-route-ignores-autopilot-state.md">Write-up &middot; bmad-route-ignores-autopilot-state.md</a></p>
         <div class="meta">
           <span class="m">Complexity <b>S</b></span>
           <span class="m">Impact <b>Med</b></span>

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

@@ -357,7 +357,8 @@ class TestAutopilotOn:
             p.slug for p in core_bmad.PERSONAS)
         assert cs.has_hook("global", "SessionStart", "bmad")
         assert cs.has_hook("global", "UserPromptSubmit", "bmad-route")
-        assert "bmad route" in _hook_cmd("global", "UserPromptSubmit", "bmad-route")
+        assert "bmad route --scope global" in _hook_cmd(
+            "global", "UserPromptSubmit", "bmad-route")
         assert "bmad orient --scope global" in _hook_cmd(
             "global", "SessionStart", "bmad")
 
@@ -368,6 +369,13 @@ class TestAutopilotOn:
         # the agents dir is only watched if it existed at launch
         assert "restart" in r.out.lower()
 
+    def test_no_restart_is_asked_for_when_the_agents_dir_already_existed(
+            self, boost, sandbox, proj):
+        """An agents dir open sessions already watch picks new files up live."""
+        (sandbox / ".claude" / "agents").mkdir(parents=True)
+        r = boost("bmad", "on")
+        assert "restart" not in r.out.lower()
+
     def test_both_hooks_cannot_report_failure(self, boost, sandbox, proj):
         """A boost older than this change does not know `bmad route` and exits
         2 — which on UserPromptSubmit erases the user's prompt. The hook is
@@ -401,6 +409,8 @@ class TestAutopilotOn:
         assert not (sandbox / ".claude" / "agents").exists()
         assert cs.has_hook("project", "UserPromptSubmit", "bmad-route",
                            project_dir=proj)
+        assert "bmad route --scope project" in _hook_cmd(
+            "project", "UserPromptSubmit", "bmad-route", project_dir=proj)
 
     def test_does_not_disturb_a_users_own_hooks(self, boost, sandbox, proj):
         boost("hooks", "add", "UserPromptSubmit", "-c", "echo hi", "-n", "mine",
@@ -478,6 +488,7 @@ class TestRoute:
         monkeypatch.setattr(sys, "stdin", io.StringIO(payload))
 
     def test_emits_the_hook_json_contract(self, boost, sandbox, monkeypatch, proj):
+        boost("bmad", "on")
         (proj / "tests").mkdir()
         (proj / "Makefile").write_text("check:\n\ttrue\n", encoding="utf-8")
         self._pipe(monkeypatch, json.dumps({
@@ -496,6 +507,7 @@ class TestRoute:
     def test_uses_the_cwd_the_hook_reports_not_its_own(
             self, boost, sandbox, monkeypatch, tmp_path, proj):
         """The hook may run anywhere; `cwd` from stdin is the project."""
+        boost("bmad", "on")
         elsewhere = tmp_path / "elsewhere"
         (elsewhere / "spec").mkdir(parents=True)
         self._pipe(monkeypatch, json.dumps({
@@ -505,6 +517,7 @@ class TestRoute:
 
     def test_trivial_prompts_produce_no_output_at_all(
             self, boost, sandbox, monkeypatch, proj):
+        boost("bmad", "on")
         self._pipe(monkeypatch, json.dumps({"prompt": "what is a tap?"}))
         r = boost("bmad", "route")
         assert r.out == "" and r.rc == 0
@@ -572,11 +585,118 @@ class TestRoute:
 
     def test_a_project_signal_failure_still_exits_zero(
             self, boost, sandbox, monkeypatch, proj):
-        monkeypatch.setattr(core_bmad, "project_signals",
-                            lambda _root: (_ for _ in ()).throw(RuntimeError("nope")))
+        boost("bmad", "on")
+        called = []
+
+        def explode(_root):
+            called.append("signals")
+            raise RuntimeError("nope")
+
+        monkeypatch.setattr(core_bmad, "project_signals", explode)
         self._pipe(monkeypatch, json.dumps({"prompt": "implement the thing"}))
         r = boost("bmad", "route", expect=None)
-        assert r.rc == 0
+        assert called == ["signals"]       # the gate let it get that far
+        assert r.rc == 0 and r.out == ""
+
+
+class TestRouteFollowsAutopilotState:
+    """The router hook speaks only while the autopilot is on, like the briefing.
+
+    `off` used to be the only thing silencing it, and `off` works by deleting
+    the hook — so any copy it missed kept routing with the autopilot reading as
+    off everywhere else.
+    """
+
+    PROMPT = "implement the new export command"
+
+    def _hook(self, boost, monkeypatch, cwd, *argv):
+        monkeypatch.setattr(sys, "stdin", io.StringIO(json.dumps(
+            {"prompt": self.PROMPT, "cwd": str(cwd)})))
+        return boost("bmad", "route", *argv, expect=None)
+
+    def test_a_hook_is_silent_while_the_autopilot_is_off(
+            self, boost, sandbox, monkeypatch, proj):
+        r = self._hook(boost, monkeypatch, proj)
+        assert r.rc == 0 and r.out == ""
+
+    def test_a_hook_that_off_missed_stays_silent(
+            self, boost, sandbox, monkeypatch, proj):
+        """The restore-net repro: a settings snapshot holding only the router."""
+        boost("bmad", "on")
+        boost("bmad", "off")
+        r = self._hook(boost, monkeypatch, proj, "--scope", "global")
+        assert r.rc == 0 and r.out == ""
+
+    def test_a_second_checkout_does_not_route_on_the_first_ones_state(
+            self, boost, sandbox, monkeypatch, tmp_path, proj):
+        """A committed project hook, run in a copy whose state was never set."""
+        boost("bmad", "on", "--scope", "project")
+        copy = tmp_path / "copy"
+        copy.mkdir()
+        assert self._hook(boost, monkeypatch, copy, "--scope", "project").out == ""
+        r = self._hook(boost, monkeypatch, proj, "--scope", "project")
+        assert "bmad-dev" in r.out
+
+    def test_project_state_is_keyed_by_the_hook_cwd_not_the_process_cwd(
+            self, boost, sandbox, monkeypatch, tmp_path, proj):
+        boost("bmad", "on", "--scope", "project")
+        elsewhere = tmp_path / "elsewhere"
+        elsewhere.mkdir()
+        monkeypatch.chdir(elsewhere)
+        r = self._hook(boost, monkeypatch, proj, "--scope", "project")
+        assert "bmad-dev" in r.out
+
+    def test_a_scoped_hook_ignores_the_other_scope(
+            self, boost, sandbox, monkeypatch, proj):
+        boost("bmad", "on")
+        assert self._hook(boost, monkeypatch, proj, "--scope", "project").out == ""
+        assert "bmad-dev" in self._hook(
+            boost, monkeypatch, proj, "--scope", "global").out
+
+    @pytest.mark.parametrize("scope", ["global", "project"])
+    def test_an_unscoped_hook_accepts_either_scope(
+            self, boost, sandbox, monkeypatch, proj, scope):
+        """Every install before this change wrote the hook without --scope."""
+        boost("bmad", "on", "--scope", scope)
+        assert "bmad-dev" in self._hook(boost, monkeypatch, proj).out
+
+    def test_a_corrupt_state_file_reads_as_off(
+            self, boost, sandbox, monkeypatch, proj):
+        boost("bmad", "on")
+        bmad._state_path().write_text("{{{", encoding="utf-8")
+        r = self._hook(boost, monkeypatch, proj)
+        assert r.rc == 0 and r.out == ""
+
+    def test_a_state_file_of_the_wrong_shape_reads_as_off(
+            self, boost, sandbox, monkeypatch, proj):
+        boost("bmad", "on")
+        bmad._state_path().write_text("[]", encoding="utf-8")
+        r = self._hook(boost, monkeypatch, proj)
+        assert r.rc == 0 and r.out == ""
+
+    def test_asking_by_hand_answers_whatever_the_state(
+            self, boost, sandbox, monkeypatch, proj):
+        assert "bmad-dev" in boost("bmad", "route", self.PROMPT).out
+        monkeypatch.setattr(sys, "stdin", io.StringIO(self.PROMPT))
+        assert "bmad-dev" in boost("bmad", "route", "--plain").out
+
+    def test_a_live_autopilot_whose_personas_are_gone_names_no_subagent(
+            self, boost, sandbox, monkeypatch, proj):
+        boost("bmad", "on")
+        for f in (sandbox / ".claude" / "agents").glob("*.md"):
+            f.unlink()
+        ctx = json.loads(self._hook(boost, monkeypatch, proj).out)[
+            "hookSpecificOutput"]["additionalContext"]
+        assert "Lead:" not in ctx and "Support:" not in ctx
+        assert "Done means" in ctx
+
+    def test_project_personas_count_for_a_global_hook(
+            self, boost, sandbox, monkeypatch, proj):
+        boost("bmad", "on")
+        boost("bmad", "on", "--scope", "project")
+        for f in (sandbox / ".claude" / "agents").glob("*.md"):
+            f.unlink()
+        assert "Lead: `bmad-dev`" in self._hook(boost, monkeypatch, proj).out
 
 
 class TestPersonas:

{boost_skill_cli-1.2.114 → boost_skill_cli-1.2.115}/tests/unit/test_bmad_core.py

@@ -507,6 +507,37 @@ class TestRouteContext:
             "ask only when a choice would change what gets delivered.",
         ]
 
+    def test_no_persona_file_anywhere_means_no_subagent_is_named(self, tmp_path):
+        """A banner must not send the model after a subagent it cannot spawn."""
+        dirs = (tmp_path / "home-agents", tmp_path / "repo-agents")
+        lines = bmad.route_lines("implement the new export command", tmp_path, dirs)
+        assert lines[0] == "[BMAD autopilot] track: build"
+        assert not any(line.startswith(("Lead:", "Support:")) for line in lines)
+        assert any(line.startswith("Done means:") for line in lines)
+        assert "bmad-build" in lines[1]
+        assert "Lead:" not in bmad.route_context(
+            "implement the new export command", tmp_path, dirs)
+
+    def test_an_edited_lead_in_either_dir_still_counts(self, tmp_path):
+        """Edited is not absent: the session still loads that subagent."""
+        home, repo = tmp_path / "home-agents", tmp_path / "repo-agents"
+        repo.mkdir()
+        (repo / "bmad-dev.md").write_text("my own Amelia", encoding="utf-8")
+        lines = bmad.route_lines("implement the new export command", tmp_path,
+                                 (home, repo))
+        assert lines[1].startswith("Lead: `bmad-dev`")
+        assert lines[2].startswith("Support:")
+        assert bmad.route_context("implement the new export command", tmp_path,
+                                  (home, repo)) == "\n".join(lines)
+
+    def test_only_the_lead_decides_not_a_support_persona(self, tmp_path):
+        agents = tmp_path / "agents"
+        agents.mkdir()
+        (agents / "bmad-tea.md").write_text("x", encoding="utf-8")
+        lines = bmad.route_lines("implement the new export command", tmp_path,
+                                 (agents,))
+        assert not any(line.startswith("Lead:") for line in lines)
+
     def test_route_context_joins_the_lines_with_newlines(self, tmp_path):
         lines = bmad.route_lines("implement the export command", tmp_path)
         assert bmad.route_context("implement the export command", tmp_path) == (