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

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

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

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

@@ -389,7 +389,54 @@ under-route than talk over someone.
 """
 
 
-def classify(prompt: str) -> str:
+_NOT_INTENT = re.compile(
+    r"```.*?```"                           # fenced code
+    r"|`[^`\n]*`"                          # inline code
+    r"|\b(?:https?|ftp)://\S+|\bwww\.\S+"  # URLs
+    r"|(?<!\S)--?[a-z]\S*"                 # --flag, -f, --flag=value
+    r"|\b(?:story|ticket|issue|epic|task|bug|card|pr)\s+"
+    r"(?:[a-z][a-z0-9]*-\d+|#\d+)\b",      # story ABC-123, issue #42
+    re.IGNORECASE | re.DOTALL)
+"""Text that names something rather than asking for anything.
+
+A prompt of up to :data:`LONG_PROMPT_WORDS` routes on one keyword, so one match
+anywhere decided the track — including words nobody meant as intent. "rerun the
+installer with --scope global" went to product on `\\bscope\\b`, a link to
+`https://example.com/docs/...` went to docs, "move story ABC-123 to in progress"
+went to product. These spans are removed before any table is scored.
+"""
+
+_PATH_TOKEN = re.compile(r"\S*/\S*")
+"""A token with a `/` in it: a path, which `build` does not score.
+
+"tail logs/build/server.log" is not a build. The rule is build-only because a
+path is often the object of the ask — "update docs/README.md" must stay docs —
+and build is the catch-all whose single hits are the cheapest.
+"""
+
+_ADDRESSEE = re.compile(r"\b\w+\s+(?:me|us)\b", re.IGNORECASE)
+"""A verb aimed at the user, not the code: "update me when the CI run finishes".
+
+Build-only for the same reason as :data:`_PATH_TOKEN` — every build keyword is
+a verb that also reads as a request to *tell* someone something.
+"""
+
+
+def _intent_text(text: str, root: Path | str | None) -> str:
+    """`text` with everything that is not intent blanked out, for scoring.
+
+    The repo's own directory name goes too, whole-word: in a checkout called
+    `migrations`, "list the last three commits in migrations" is a `git log`,
+    not a migration. The hook already knows the root; this is where it counts.
+    """
+    text = _NOT_INTENT.sub(" ", text)
+    if root is not None and Path(root).name:
+        text = re.sub(r"(?<!\w)%s(?!\w)" % re.escape(Path(root).name), " ",
+                      text, flags=re.IGNORECASE)
+    return text
+
+
+def classify(prompt: str, root: Path | str | None = None) -> str:
     """Name the track a prompt belongs to, or ``"trivial"`` to stay silent.
 
     Silence is the default for anything that is not recognisably a unit of
@@ -397,6 +444,11 @@ def classify(prompt: str) -> str:
     own instructions), a short informational question, an explicit opt-out
     ("no bmad"), a prompt that matches no track at all, or — past
     :data:`LONG_PROMPT_WORDS` — one that matches only a single keyword.
+
+    Only intent is scored (:func:`_intent_text`): code spans, URLs, flags,
+    tracker IDs and the name of ``root`` — the repo the prompt was typed in —
+    never count, and ``build`` additionally ignores paths and verbs addressed
+    to the user. The threshold stays where it is; the evidence got cleaner.
     """
     text = prompt.strip()
     if not text or _SLASH.match(text) or _OPT_OUT.search(text):
@@ -407,9 +459,12 @@ def classify(prompt: str) -> str:
     if (_INFO_QUESTION.match(text) and len(words) <= QUESTION_MAX_WORDS
             and not _SECOND_SENTENCE.search(text)):
         return TRIVIAL
+    intent = _intent_text(text, 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.
-    scores = {t: sum(1 for rx in pats if rx.search(text))
+    scores = {t: sum(1 for rx in pats
+                     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):
@@ -520,25 +575,34 @@ 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.
     """
-    track_name = classify(prompt)
+    root = Path(root) if root is not None else Path.cwd()
+    track_name = classify(prompt, root)
     if track_name == TRIVIAL:
         return []
     track = TRACKS[track_name]
     lead = PERSONA_BY_SLUG[track.lead]
-    signals = project_signals(Path(root) if root is not None else Path.cwd())
-
-    lines = [
-        "[BMAD autopilot] track: %s" % track_name,
-        "Lead: `%s` subagent — %s, %s. %s"
-        % (lead.slug, lead.character, lead.title, track.note),
-    ]
-    if track.support:
+    signals = project_signals(root)
+    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."
@@ -554,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.113 → 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.113
+Version: 1.2.115
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0

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

@@ -75,9 +75,16 @@ 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. Because a `UserPromptSubmit` hook that exits
+`no bmad` produce no banner at all. 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").
+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.113 → 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.113 → boost_skill_cli-1.2.115}/docs/roadmap/items/bmad-router-one-keyword-decides-the-track.md

@@ -2,15 +2,15 @@
 id: bmad-router-one-keyword-decides-the-track
 board: code
 section: dx
-status: next
+status: shipped
 category: Agents · BMAD
 complexity: S
 impact: High
 wow: 3
 note: 89 of 143 routed prompts rode on a single keyword
 order: 319
-owner:
-pr:
+owner: loop/bmad-incidental-keywords
+pr: 861
 title: One incidental keyword decides the <code>boost bmad</code> track
 ---
 <code>classify</code> counts distinct keyword patterns per track over the raw prompt and routes on

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

@@ -7564,67 +7564,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-one-keyword-decides-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>One incidental keyword decides the <code>boost bmad</code> track</h3>
-        <p><code>classify</code> counts distinct keyword patterns per track over the raw prompt and routes on
-the best score (<code>core/bmad.py:412</code>&ndash;<code>417</code>). Two hits are required only
-past <code>LONG_PROMPT_WORDS</code> (60, #630; <code>:415</code>), so any prompt of up to 60 words
-that clears the question and slash gates <b>routes on one match anywhere</b> &mdash; including
-words nobody meant as intent: a URL, a path, a flag, a ticket reference, the repo's own name.
-Replaying the origin/main classifier over one real prompt history (417 prompts, 348 unique, 6
-active days): <b>89 of 143 routed unique prompts were decided by exactly one keyword</b>. A single
-judge labelling 41 routed banners found the track or lead clearly wrong in <b>21 of 41</b>.
-
-<b>A wrong route costs more than silence.</b> The banner names a lead, asks for support subagents,
-sets a done-contract (tests, docs, and the gate when there is one) and says to work autonomously
-(<code>:536</code>&ndash;<code>553</code>). In a repo directory named <code>migrations</code>,
-&ldquo;list the last three commits in migrations&rdquo; gets a 643-char build banner &mdash; Amelia
-leads, Murat and Paige to be spawned, <code>make check</code> green &mdash; for a
-<code>git log</code>. The module already chose: it &ldquo;would rather under-route than talk over
-someone&rdquo; (<code>:387</code>&ndash;<code>388</code>).
-
-<b>Five collision classes, all single hits, reproduced on origin/main with synthetic prompts</b>
-(three spot-checked on the installed v1.2.112): <i>repo name</i> &mdash; &ldquo;list the last three
-commits in migrations&rdquo; in <code>migrations/</code> &rarr; build, &ldquo;list the new notebooks
-in benchmarks&rdquo; in <code>benchmarks/</code> &rarr; discovery; <i>flags</i> &mdash; &ldquo;rerun
-the installer with <code>--scope</code> global&hellip;&rdquo; &rarr; product; <i>URLs, paths,
-code</i> &mdash; <code>https://example.com/docs/&hellip;</code> &rarr; docs, <code>tail
-logs/build/server.log</code> &rarr; build, <code>`npm run build`</code> &rarr; build; <i>tracker
-words</i> &mdash; &ldquo;move story ABC-123 to in progress&rdquo; &rarr; product; <i>generic
-verbs</i> &mdash; &ldquo;update me when the CI run finishes&rdquo; &rarr; build. The hook already
-has the repo &mdash; <code>cwd</code> becomes <code>root</code>
-(<code>commands/bmad.py:342</code>&ndash;<code>344</code>) &mdash; but <code>route_lines</code>
-calls <code>classify(prompt)</code> bare (<code>core/bmad.py:529</code>).
-
-<b>Fix: stop scoring text that is not intent; do not raise the threshold.</b> Before scoring,
-<i>(1)</i> drop URLs, backtick spans, <code>--flag</code>/<code>-f</code> tokens and tracker-noun +
-ID pairs (<code>story ABC-123</code>); <i>(2)</i> a token containing <code>/</code> stops scoring
-for <code>build</code> but still counts for every other table, so <code>docs/README.md</code>
-stays docs; <i>(3)</i> <code>classify(prompt, root=None)</code>, fed by <code>route_lines</code>,
-drops whole-word matches of <code>Path(root).name</code>; <i>(4)</i> a build verb followed by
-<em>me</em>/<em>us</em> does not score. On a stdlib prototype: all <b>46</b> distinct prompts
-<code>test_bmad_core.py</code> sends through <code>classify</code> keep their verdict; <b>16 of
-18</b> synthetic misroutes go silent; build asks still route &mdash; 12/12 verb-first, 8/8 not
-(&ldquo;we need to fix the crash&hellip;&rdquo;), 4/4 late-verb &mdash; and 5/5 path-object asks
-keep their track. Small hand-written sets: they show which rule does the work, not a rate.
-
-<b>Threshold rules measured and declined.</b> Layered on <i>(1)</i>&ndash;<i>(4)</i>: two build hits
-or a head verb silences neither of the 2 left but routes <b>2 of 8</b> non-head and <b>0 of 4</b>
-late-verb asks; a verb in a clause's first six words routes <b>0 of 4</b> late-verb asks; making
-<code>add</code>/<code>update</code>/<code>create</code>-class verbs need a second hit silences one
-more but keeps only <b>6 of 12</b> short build asks and breaks <code>"update the flag"</code>
-(<code>test_bmad_core.py:142</code>). Stripping paths outright flips 3 of 5 path-object asks.
-<b>Residue:</b> &ldquo;add the meeting notes to my summary&rdquo; stays build; &ldquo;pull the
-comments on story ABC-123&hellip;&rdquo; goes docs on <code>\bcomments?\b</code>; a sibling repo's
-name still routes; and a cwd named after a keyword loses that word &mdash; in <code>tests/</code>,
-&ldquo;add tests for catalog.scan_dir&rdquo; flips quality &rarr; build.
-
-<b>Tests:</b> add <code>TestIncidentalKeywords</code> beside <code>TestClassifyTracks</code>
-(<code>tests/unit/test_bmad_core.py:173</code>): one <code>(prompt, repo_dirname, expected)</code>
-table with every repro as <code>trivial</code> except the two residues (pinned at today's track,
-so a later fix shows as a diff), the non-head, late-verb and path-object asks at their tracks,
-plus a <code>route_lines</code> case rooted at <code>tmp_path / "migrations"</code> so the name
-must reach <code>classify</code>.</p>
+        <p class="cardbody"><a class="writeup" href="https://github.com/jonnyeclectic/boost/blob/main/docs/roadmap/items/bmad-router-one-keyword-decides-the-track.md">Write-up &middot; bmad-router-one-keyword-decides-the-track.md</a></p>
         <div class="meta">
           <span class="m">Complexity <b>S</b></span>
           <span class="m hi">Impact <b>High</b></span>
@@ -7778,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>