brindle 0.3.18__tar.gz → 0.3.20__tar.gz

{brindle-0.3.18 → brindle-0.3.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: brindle
-Version: 0.3.18
+Version: 0.3.20
 Summary: Run coding agents in parallel, each on its own git branch, with a supervisor that delegates, reviews, and merges
 Project-URL: Homepage, https://pawdelta.com/brindle/
 Project-URL: Documentation, https://pawdelta.com/brindle/docs/recommended-use
@@ -94,7 +94,7 @@ uv tool install --editable ~/Projects/brindle   # or from a local checkout
 brindle drives Claude Code, so you need that too (`npm install -g @anthropic-ai/claude-code`).
 
 `brindle --version` prints the installed version; the tmux status bar of every brindle
-session shows it too (`brindle 0.3.18`). A session started before an upgrade keeps
+session shows it too (`brindle 0.3.20`). A session started before an upgrade keeps
 running the old code, and shows the old number, until you restart it.
 
 ## Quick start
@@ -215,6 +215,31 @@ brindle pr fix-login                          # push + gh pr create
 brindle rm fix-login                          # deletes the branch only if it's merged (-K keeps it)
 ```
 
+### Choosing the supervisor and workers
+
+The first time you run `brindle` it asks which CLI runs the supervisor (the
+agent that plans the work and hands it out), and remembers your pick. After
+that it starts straight away and prints one line naming the CLI. It asks again
+only when your pick is no longer signed in or no longer allowed.
+
+- `brindle -s` opens the picker; `brindle -s codex` switches directly. Either
+  is remembered.
+- In the picker, `w` opens the workers screen: a model for each task size
+  (light, medium, heavy). Models are grouped by how they run: through a CLI
+  you sign in to, locally with Ollama, or hosted with an API key. Picking one
+  that isn't ready sets it up right there: signing in, installing Ollama and
+  downloading the model after a memory check, or asking for the API key.
+- API keys are checked with the provider before they're stored, and stay in
+  this machine's keychain.
+- The picker and the workers screen list only the CLIs and models you're
+  allowed to use. In an org that means its allowed providers and models for
+  your role, its managed routes, and whether personal API keys are allowed.
+  `-s` with anything else is refused, and saved picks are re-checked at every
+  launch.
+- Without a terminal (scripts, CI), with `--yes`, or in `brindle demo`, nothing
+  asks: brindle uses your last pick, else the supervisor profile's CLI (Claude
+  Code unless you changed it).
+
 ## Recommended use
 
 brindle pays off when work splits into pieces that can proceed in parallel, or
@@ -343,6 +368,7 @@ your own status line prints, so what you see doesn't change.
 | | |
 |---|---|
 | `brindle` | a fresh supervisor chat here, dashboard alongside |
+| `brindle -s [CLI]` | pick the supervisor's CLI (no value: open the picker; `w` there picks worker models); a picker choice is remembered, a named CLI is for this run only |
 | `brindle supervisor` | the same, with `--branch`/`--worktree` to run it in another worktree |
 | `brindle init` | detect setup and test commands, write `.brindle/config.json`, check tools |
 | `brindle demo [--local]` | watch brindle finish a tiny practice repo: parallel workers, reviews, gated merges |
@@ -536,7 +562,7 @@ Autopilot, merge gates and cleanup:
 | `pre_commit` | `true` | run [pre-commit](https://pre-commit.com) over the branch, if the repo uses it |
 | `max_agents` | `4` | workers running at once per session (`0`: no cap) |
 | `check_timeout` | `900` | seconds each check may take |
-| `check_concurrency` | `2` | check runs at once on this machine, across branches; the rest wait their turn (`0`: no cap). A run far past its last duration is reported to the supervisor |
+| `check_concurrency` | `4` | check runs at once on this machine, across branches; the rest wait their turn (`0`: no cap). A run far past its last duration is reported to the supervisor |
 | `fable_escalation` | on, unless the worker runs on a cloud account (Bedrock, Vertex or Foundry) | retry a failed heavy task once on `developer-heavy` before handing it to you; `true` turns it on for a cloud account, `false` off |
 | `usage_limit` | `90` | autopilot stops pushing on at this % of your Claude usage limit |
 | `limit_cooldown_minutes` | `300` for Antigravity | how long a provider that hit its limit counts as unavailable |

{brindle-0.3.18 → brindle-0.3.20}/README.md

@@ -63,7 +63,7 @@ uv tool install --editable ~/Projects/brindle   # or from a local checkout
 brindle drives Claude Code, so you need that too (`npm install -g @anthropic-ai/claude-code`).
 
 `brindle --version` prints the installed version; the tmux status bar of every brindle
-session shows it too (`brindle 0.3.18`). A session started before an upgrade keeps
+session shows it too (`brindle 0.3.20`). A session started before an upgrade keeps
 running the old code, and shows the old number, until you restart it.
 
 ## Quick start
@@ -184,6 +184,31 @@ brindle pr fix-login                          # push + gh pr create
 brindle rm fix-login                          # deletes the branch only if it's merged (-K keeps it)
 ```
 
+### Choosing the supervisor and workers
+
+The first time you run `brindle` it asks which CLI runs the supervisor (the
+agent that plans the work and hands it out), and remembers your pick. After
+that it starts straight away and prints one line naming the CLI. It asks again
+only when your pick is no longer signed in or no longer allowed.
+
+- `brindle -s` opens the picker; `brindle -s codex` switches directly. Either
+  is remembered.
+- In the picker, `w` opens the workers screen: a model for each task size
+  (light, medium, heavy). Models are grouped by how they run: through a CLI
+  you sign in to, locally with Ollama, or hosted with an API key. Picking one
+  that isn't ready sets it up right there: signing in, installing Ollama and
+  downloading the model after a memory check, or asking for the API key.
+- API keys are checked with the provider before they're stored, and stay in
+  this machine's keychain.
+- The picker and the workers screen list only the CLIs and models you're
+  allowed to use. In an org that means its allowed providers and models for
+  your role, its managed routes, and whether personal API keys are allowed.
+  `-s` with anything else is refused, and saved picks are re-checked at every
+  launch.
+- Without a terminal (scripts, CI), with `--yes`, or in `brindle demo`, nothing
+  asks: brindle uses your last pick, else the supervisor profile's CLI (Claude
+  Code unless you changed it).
+
 ## Recommended use
 
 brindle pays off when work splits into pieces that can proceed in parallel, or
@@ -312,6 +337,7 @@ your own status line prints, so what you see doesn't change.
 | | |
 |---|---|
 | `brindle` | a fresh supervisor chat here, dashboard alongside |
+| `brindle -s [CLI]` | pick the supervisor's CLI (no value: open the picker; `w` there picks worker models); a picker choice is remembered, a named CLI is for this run only |
 | `brindle supervisor` | the same, with `--branch`/`--worktree` to run it in another worktree |
 | `brindle init` | detect setup and test commands, write `.brindle/config.json`, check tools |
 | `brindle demo [--local]` | watch brindle finish a tiny practice repo: parallel workers, reviews, gated merges |
@@ -505,7 +531,7 @@ Autopilot, merge gates and cleanup:
 | `pre_commit` | `true` | run [pre-commit](https://pre-commit.com) over the branch, if the repo uses it |
 | `max_agents` | `4` | workers running at once per session (`0`: no cap) |
 | `check_timeout` | `900` | seconds each check may take |
-| `check_concurrency` | `2` | check runs at once on this machine, across branches; the rest wait their turn (`0`: no cap). A run far past its last duration is reported to the supervisor |
+| `check_concurrency` | `4` | check runs at once on this machine, across branches; the rest wait their turn (`0`: no cap). A run far past its last duration is reported to the supervisor |
 | `fable_escalation` | on, unless the worker runs on a cloud account (Bedrock, Vertex or Foundry) | retry a failed heavy task once on `developer-heavy` before handing it to you; `true` turns it on for a cloud account, `false` off |
 | `usage_limit` | `90` | autopilot stops pushing on at this % of your Claude usage limit |
 | `limit_cooldown_minutes` | `300` for Antigravity | how long a provider that hit its limit counts as unavailable |

{brindle-0.3.18 → brindle-0.3.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "brindle"
-version = "0.3.18"
+version = "0.3.20"
 description = "Run coding agents in parallel, each on its own git branch, with a supervisor that delegates, reviews, and merges"
 readme = "README.md"
 requires-python = ">=3.11"

{brindle-0.3.18 → brindle-0.3.20}/src/brindle/agents.py

@@ -1418,15 +1418,34 @@ def unread_notice(db: DB, messages: list) -> str:
             f"(from {', '.join(senders)}). Call read_messages.")
 
 
+def one_line(db: DB, message_id: int, body: str, sender_id: str | None) -> str:
+    """A message as the single line a supervisor sees: sender, head line (the
+    first line of ``body``) and how to fetch the rest."""
+    if sender_id:
+        sender = db.get_agent(sender_id)
+        who = f"{sender.profile} {sender_id}" if sender else sender_id
+    else:
+        who = "brindle"
+    head = first_line(body, 300)
+    if not sender_id:
+        head = head.removeprefix("[brindle] ")  # the sender tag already says it
+    return (f"[{who}] {head} "
+            f"(full text: read_messages(message_id={message_id}))")
+
+
+def full_message(db: DB, agent_id: str, message_id: int) -> str:
+    """The whole text of one message to ``agent_id``, as read_messages(message_id=...) returns it."""
+    m = db.get_message(agent_id, message_id)
+    if m is None:
+        return f"No message {message_id}."
+    if m.sender_id:
+        return format_message(db, m.body, m.sender_id)
+    return f"<details><summary>Message from brindle</summary>\n\n{m.body}\n</details>"
+
+
 def render_unread(db: DB, messages: list) -> str:
-    """What read_messages returns: each message with its trust lead line."""
-    parts = []
-    for m in messages:
-        if m.sender_id:
-            parts.append(m.body)  # stored through format_message: sender and reply hint
-        else:
-            parts.append(f"<details><summary>Message from brindle</summary>\n\n{m.body}\n</details>")
-    return "\n\n".join(parts)
+    """What read_messages returns: one line per message."""
+    return "\n".join(one_line(db, m.id, m.body, m.sender_id) for m in messages)
 
 
 def send_message(db: DB, to_id: str, body: str, sender_id: str | None = None,
@@ -1440,20 +1459,25 @@ def send_message(db: DB, to_id: str, body: str, sender_id: str | None = None,
     identity_lock.ensure(agent)
     if not person and runs_process(agent) and is_alive(agent) and pulls_messages(db, agent):
         # Keep the message unread and deliver only a notice, once for everything unread.
-        db.enqueue_held(agent.id, format_message(db, body, sender_id), sender_id)
+        db.enqueue_held(agent.id, body, sender_id)
         claimed = db.claim_notice(agent.id)
         if claimed is None:
             return "queued"
         try:
-            outcome = _send_message(db, agent, unread_notice(db, claimed), None)
+            outcome = _send_message(db, agent, unread_notice(db, claimed), None, notice=True)
         except BaseException:
             db.reset_notice(agent.id)
             raise
         return outcome
-    return _send_message(db, agent, body, sender_id)
+    # A supervisor sees a message from an agent or brindle as one line; the
+    # person's own input is always delivered whole.
+    return _send_message(db, agent, body, sender_id,
+                         condensed=agent.mode == "interactive" and not person
+                         and agent.provider != "shell")
 
 
-def _send_message(db: DB, agent: Agent, body: str, sender_id: str | None) -> str:
+def _send_message(db: DB, agent: Agent, body: str, sender_id: str | None,
+                  condensed: bool = False, notice: bool = False) -> str:
     if not runs_process(agent):
         raise AgentError(
             f"agent {agent.id} is a subagent run by its supervisor's own Agent tool, so brindle "
@@ -1466,8 +1490,14 @@ def _send_message(db: DB, agent: Agent, body: str, sender_id: str | None) -> str
                              "can resume its session with `brindle continue`; the message isn't kept.")
         raise AgentError(f"agent {agent.id} is not running")
     provider = get_provider(agent.provider)
-    text = format_message(db, body, sender_id)
-    if agent.provider == "antigravity":
+    if condensed:
+        # The full text is kept, already read, for read_messages(message_id=...).
+        kept = db.enqueue_held(agent.id, body, sender_id)
+        db.mark_delivered(kept)
+        text = one_line(db, kept, body, sender_id)
+    else:
+        text = format_message(db, body, sender_id)
+    if agent.provider == "antigravity" and not (condensed or notice):
         from brindle.antigravity import format_delivered_message
         text = format_delivered_message(text)
     if agent.headless:
@@ -1479,7 +1509,7 @@ def _send_message(db: DB, agent: Agent, body: str, sender_id: str | None) -> str
         tmux.paste(agent.tmux_window, text, lead=message_lead(db, agent, sender_id),
                    server=server_of(agent))
         return "delivered"
-    message_id = db.enqueue(agent.id, text, sender_id)
+    message_id = db.enqueue(agent.id, text, sender_id, notice=notice)
     from brindle import login_pause
 
     if login_pause.holding(db, agent.id):
@@ -1644,7 +1674,8 @@ def flush(db: DB, agent_id: str) -> bool:
                 delivered = True
                 launch_health.delivered(db, agent, baseline)
             else:
-                db.enqueue(agent_id, msg.body, msg.sender_id)  # back in the queue, for the pane
+                db.enqueue(agent_id, msg.body, msg.sender_id,  # back in the queue, for the pane
+                           notice=msg.noticed_at is not None)
                 break
         if delivered:
             return True
@@ -1743,6 +1774,19 @@ def complete_subagent(db: DB, agent_id: str, result: str) -> Agent:
     return db.get_agent(agent.id) or agent
 
 
+def first_line(text: str, limit: int = 160) -> str:
+    """The first non-empty line of ``text``, cut to ``limit`` characters."""
+    line = next((ln.strip() for ln in text.splitlines() if ln.strip()), "")
+    return line if len(line) <= limit else line[: limit - 1].rstrip() + "…"
+
+
+def condense(head: str, *body: str) -> str:
+    """A message that opens with the one-line ``head`` and keeps the long
+    ``body`` sections inside a collapsible block."""
+    return (f"{head}\n\n<details><summary>Details</summary>\n\n"
+            + "\n\n".join(b for b in body if b) + "\n\n</details>")
+
+
 def report_result(db: DB, agent_id: str, result: str, forward: bool = True,
                   removed: tuple[Agent, Workspace] | None = None) -> str:
     """Record a worker's or reviewer's result. A piped worker's report goes
@@ -1794,7 +1838,7 @@ def report_result(db: DB, agent_id: str, result: str, forward: bool = True,
         where = f" on branch `{ws.branch}` (workspace {ws.id})" if ws else ""
         send_message(
             db, agent.parent_id,
-            f"Assigned task finished{where}.\n\n{forwarded}",
+            condense(f"Assigned task finished{where}: {first_line(result)}", forwarded),
             sender_id=agent.id,
         )
         return "result recorded and sent to your supervisor"
@@ -2712,7 +2756,10 @@ def _stop_decision(db: DB, agent: Agent, payload: dict, via_inbox: bool = False)
         decision = pilot.on_stop(db, agent, payload)
         if decision:
             db.set_status(agent.id, "processing")
-            return decision
+            # Claude Code shows the reason in the chat: one line, like any brindle message.
+            kept = db.enqueue_held(agent.id, decision["reason"], None)
+            db.mark_delivered(kept)
+            return {**decision, "reason": one_line(db, kept, decision["reason"], None)}
     db.set_status(agent.id, "idle")
     return None
 
@@ -2868,7 +2915,11 @@ def handle_hook(db: DB, agent_id: str, event: str, payload: dict) -> dict | None
 
                 decision = pilot.on_stop(db, agent, payload)
                 if decision:
-                    db.enqueue(agent_id, decision["reason"], None)
+                    # Like any message from brindle: one line (or a notice), the rest via read_messages.
+                    try:
+                        send_message(db, agent_id, decision["reason"])
+                    except AgentError:
+                        pass  # gone since its turn ended: nobody to nudge
             if (agent.mode in REPORTING_MODES and agent.result is None
                     and not db.pending_count(agent_id)):
                 # No Stop hook can remind it to report, and no hook says when

{brindle-0.3.18 → brindle-0.3.20}/src/brindle/autopilot.py

@@ -101,6 +101,9 @@ to be asked each step.
   the checks pass, merges it and removes the worktree; you get one message
   per branch: merged, or "needs you" with the details. Don't request_review
   or merge_workspace a reported branch yourself unless brindle says so.
+- Messages reach you as one line each; read_messages(message_id=N) gives the
+  full text only when you need it. Relay worker results to the user in one line.
+  Reply to an agent with send_message(to_agent_id=<sender id>).
 - After merging, call `check_milestone`. Only brindle's check marks a milestone
   done: never claim one is done yourself. When every milestone passes, brindle
   audits the work against the goal; the goal is reached only when that audit
@@ -1293,7 +1296,7 @@ def check_milestones(db: DB, root_id: str, ws: Workspace, position: int | None =
         if m.output and m.status == "failed":
             lines.append(f"\nMilestone {m.position} check output:\n{m.output}")
     if done and audit is None:
-        lines.append("\nEvery milestone's check passes: the goal is reached. Tell the user.")
+        lines.append("\n" + GOAL_REACHED)
         clear_finished_goal(db, root_id)
     elif done:
         lines.append("\n" + AUDIT_HOLD[audit].format(note=(ap.note if ap else None) or ""))
@@ -1307,6 +1310,7 @@ def check_milestones(db: DB, root_id: str, ws: Workspace, position: int | None =
 # adversarial reviewer compares the work with the original goal before the
 # goal counts as reached (``goal_audit`` in .brindle/config.json turns it off).
 
+GOAL_REACHED = "Every milestone's check passes: the goal is reached. Tell the user."
 AUDIT_HOLD = {
     "start": ("Every milestone's check passes. Before the goal counts as reached, an independent "
               "auditor is checking the work against the original goal; its verdict arrives as a "
@@ -1561,6 +1565,35 @@ def progress(db: DB, root_id: str) -> str:
     return "\n".join(lines)
 
 
+def check_summary(db: DB, root_id: str, position: int | None, text: str) -> str:
+    """The one line pushed after a milestone check: the result, how many
+    milestones are verified, and a REGRESSED note. ``text`` is what
+    check_milestones returned; the full progress stays in get_progress."""
+    from brindle.agents import first_line
+
+    ms = db.milestones(root_id)
+    done, total = counts(db, root_id)
+    if not ms:
+        return first_line(text)
+    chosen = [m for m in ms if position is None or m.position == position]
+    parts = []
+    for m in chosen if position is not None else [m for m in ms if m.status == "failed"]:
+        if m.status == "failed":
+            parts.append(f"Milestone {m.position} ✗ failed: {first_line(m.output or 'no output')}")
+        else:
+            parts.append(f"Milestone {m.position} {MARK.get(m.status, '·')} {m.status}")
+    head = "; ".join(parts) or "Milestone check"
+    head += f" ({done} of {total} verified)"
+    first = text.splitlines()[0] if text else ""
+    if first.startswith("REGRESSED:"):
+        head += f". {first}"
+    if GOAL_REACHED in text.splitlines():
+        head += ". Goal reached: tell the user"
+    elif ms and done == total:
+        head += ". Not done yet: completion audit pending, has gaps, or needs a commit"
+    return head
+
+
 # -- workers and the cap ----------------------------------------------------------
 
 

{brindle-0.3.18 → brindle-0.3.20}/src/brindle/cli.py

@@ -34,7 +34,34 @@ class _App(typer.Typer):
             raise SystemExit(1)
 
 
-app = _App(add_completion=False, help="""brindle: run coding agents in parallel, each on its own git branch.
+SUPERVISOR_FLAGS = ("-s", "--supervisor")
+
+
+def _bare_supervisor_flag(args: list[str], commands) -> list[str]:
+    """``args`` with picker.PICK after each ``-s``/``--supervisor`` that has
+    no CLI after it (it's last, or an option or a command follows), so a bare
+    ``brindle -s`` opens the picker: a Typer option can't take an optional
+    value."""
+    from brindle.picker import PICK
+
+    out = []
+    for i, a in enumerate(args):
+        out.append(a)
+        if a == "--":
+            return out + list(args[i + 1:])
+        if a in SUPERVISOR_FLAGS:
+            nxt = args[i + 1] if i + 1 < len(args) else None
+            if nxt is None or nxt.startswith("-") or nxt in commands:
+                out.append(PICK)
+    return out
+
+
+class _PickerGroup(typer.core.TyperGroup):
+    def parse_args(self, ctx, args):
+        return super().parse_args(ctx, _bare_supervisor_flag(args, self.commands))
+
+
+app = _App(cls=_PickerGroup, add_completion=False, help="""brindle: run coding agents in parallel, each on its own git branch.
 
 Run `brindle` with no arguments to open (or reopen) a supervisor chat here, with
 the live dashboard underneath. Outside a git repo it starts a scratch session;
@@ -177,7 +204,7 @@ def demo(
     typer.echo(f"demo repo: {root}")
     os.chdir(root)
     start(prompt=None, provider=None, attach=attach, watch=True,
-          autopilot=True, branch=None, worktree=None)
+          autopilot=True, branch=None, worktree=None, demo=True)
 
 
 @app.command()
@@ -193,6 +220,7 @@ def new(
     no_fetch: bool = typer.Option(False, "--no-fetch", help="Don't fetch the base branch first."),
     no_setup: bool = typer.Option(False, "--no-setup", help="Skip setup commands."),
     attach: bool = typer.Option(False, "--attach", help="Attach to the tmux session afterward."),
+    yes: Annotated[bool, typer.Option("--yes", "-y", help="Don't open the supervisor picker: use your last pick, else the default.")] = False,
     provider_alias: Annotated[Optional[str], typer.Option("--provider", hidden=True)] = None,
 ) -> None:
     """Create a worktree on a new branch and start a supervisor in it."""
@@ -209,6 +237,12 @@ def new(
             _fail("--base can't be combined with --pr (the PR's base branch is used)")
     elif not branch:
         _fail("missing BRANCH (or pass --pr <number>)")
+    if not no_agent:
+        try:
+            root = git.main_repo_root(os.getcwd())
+        except git.GitError:
+            root = None
+        provider = _resolve_supervisor(root, provider, yes=yes)
     db = DB()
     if pr is not None:
         created = _run(workspaces.create_from_pr, db, os.getcwd(), pr, run_setup=not no_setup)
@@ -258,7 +292,9 @@ def start(
     autopilot: Optional[bool] = typer.Option(None, "--autopilot/--no-autopilot", help="The supervisor drives toward a goal until it's verified (default: on, or `autopilot` in .brindle/config.json)."),
     branch: Optional[str] = typer.Option(None, "--branch", "-b", help="Run in the worktree for this branch, creating the branch and worktree if needed."),
     worktree: Optional[str] = typer.Option(None, "--worktree", "-w", help="Run in the worktree at this path (created with --branch if it doesn't exist)."),
+    yes: Annotated[bool, typer.Option("--yes", "-y", help="Don't open the supervisor picker: use your last pick, else the default.")] = False,
     provider_alias: Annotated[Optional[str], typer.Option("--provider", hidden=True)] = None,
+    demo: Annotated[bool, typer.Option("--demo-run", hidden=True)] = False,
 ) -> None:
     """Start a fresh supervisor chat here, with the dashboard alongside. A launch only ever starts a supervisor; it starts the other agents itself.
 
@@ -312,6 +348,7 @@ def start(
     if provider and provider in NOT_SUPERVISOR:
         _fail(f"the {provider} provider can't run the supervisor; use one of: "
               f"{', '.join(SUPERVISOR_PROVIDERS)}")
+    provider = _resolve_supervisor(ws.repo_root, provider, yes=yes, demo=demo)
     _preflight(agents.SUPERVISOR, provider, ws.repo_root)
     _trust_codex_hook(ws.repo_root)
     # Nothing slow before the chat starts: the paused session's leftover
@@ -366,6 +403,72 @@ def _preflight(agent: str, provider: Optional[str], repo_root: str) -> None:
         _fail("brindle can't start yet. `brindle doctor` checks everything else.")
 
 
+def _is_ci_env() -> bool:
+    for key in ("CI", "GITHUB_ACTIONS", "GITLAB_CI", "BUILDKITE", "CIRCLECI", "TF_BUILD", "JENKINS_URL", "BRINDLE_CI"):
+        val = (os.environ.get(key) or "").strip().lower()
+        if val and val not in ("0", "false", "no", "off"):
+            return True
+    return False
+
+
+def _can_prompt(yes: bool = False, demo: bool = False) -> bool:
+    return bool(sys.stdin.isatty() and yes is not True and demo is not True and not _is_ci_env())
+
+
+def _resolve_supervisor(repo_root: str | None, provider: Optional[str], *,
+                        yes: bool = False, demo: bool = False) -> Optional[str]:
+    """The CLI the supervisor runs on (None: its profile's). ``-s CLI`` picks
+    it for this run only; a bare ``-s`` opens the picker, whose choice is
+    remembered. Otherwise the
+    person's last pick, asked again in the picker only on the first launch or
+    when that pick isn't signed in or allowed, and only where brindle may ask.
+    A CLI the org doesn't allow this person is refused, whichever way it came."""
+    from brindle import doctor as doctor_mod, picker
+    from brindle.config import SUPERVISOR_KEY, set_user, supervisor_pick
+    from brindle.pro import team_policy
+
+    acc = team_policy.access(repo_root)
+    pick = supervisor_pick()
+
+    def ask() -> str:
+        chosen = picker.pick_supervisor(acc, pick)
+        if chosen is None:
+            typer.echo("No supervisor picked; nothing was started.")
+            raise typer.Exit(1)
+        return chosen
+
+    from_picker = False
+    if provider == picker.PICK:
+        if not _can_prompt(yes, demo):
+            _fail("`brindle -s` on its own opens the supervisor picker, which needs a terminal; "
+                  "name the CLI instead, e.g. `brindle -s codex`")
+        provider = ask()
+        from_picker = True
+    elif provider:
+        why = acc.refusal(provider)
+        if why:
+            _fail(f"can't run the supervisor on {provider}: {why}")
+        if _can_prompt(yes, demo) and provider not in doctor_mod.signed_in_providers():
+            if not picker.sign_in(provider):
+                raise typer.Exit(1)
+    elif _can_prompt(yes, demo) and not (pick and acc.allows(pick)
+                                         and pick in doctor_mod.signed_in_providers()):
+        provider = ask()
+        from_picker = True
+    elif pick and acc.allows(pick):
+        provider = pick
+    final = provider or _run(load_profile, agents.SUPERVISOR, repo_root).provider
+    why = acc.refusal(final)
+    if why:
+        _fail(f"can't run the supervisor on {final}: {why}. Pick another with `brindle -s`.")
+    if provider:
+        # only the interactive picker saves a choice; a -s flag is this session's override
+        if from_picker and provider != pick:
+            set_user(SUPERVISOR_KEY, provider)
+        typer.echo(f"Supervisor: {provider} ({'your pick' if from_picker else 'this run'}) · brindle -s to change")
+    return provider
+
+
 def _trust_codex_hook(repo_root: str) -> None:
     """With the permission policy on and Codex installed, trust brindle's Codex
     hook if it isn't yet (or brindle moved), and say so in one line, so Codex
@@ -761,6 +864,7 @@ def default(
         None, "--supervisor", "-s", help="Run the supervisor on this CLI instead of Claude Code (codex, antigravity). Workers keep their own profiles' providers.",
     ),
     show_version: bool = typer.Option(False, "--version", help="Print brindle's version and exit."),
+    yes: Annotated[bool, typer.Option("--yes", "-y", help="Don't open the supervisor picker: use your last pick, else the default.")] = False,
     provider_alias: Annotated[Optional[str], typer.Option("--provider", hidden=True)] = None,
 ) -> None:
     """Bare `brindle`: a fresh supervisor chat here (a scratch session outside git)."""
@@ -782,7 +886,7 @@ def default(
             continue_cmd(session_id=None, attach=True)
         else:
             start(prompt=None, provider=provider, attach=True, watch=True,
-                  autopilot=autopilot, branch=None, worktree=None)
+                  autopilot=autopilot, branch=None, worktree=None, yes=yes)
 
 
 @app.command()
@@ -796,12 +900,13 @@ def supervisor(
     autopilot: Optional[bool] = typer.Option(None, "--autopilot/--no-autopilot", help="The supervisor drives toward a goal until it's verified (default: on, or `autopilot` in .brindle/config.json)."),
     branch: Optional[str] = typer.Option(None, "--branch", "-b", help="Run in the worktree for this branch, creating the branch and worktree if needed."),
     worktree: Optional[str] = typer.Option(None, "--worktree", "-w", help="Run in the worktree at this path (created with --branch if it doesn't exist)."),
+    yes: Annotated[bool, typer.Option("--yes", "-y", help="Don't open the supervisor picker: use your last pick, else the default.")] = False,
     provider_alias: Annotated[Optional[str], typer.Option("--provider", hidden=True)] = None,
 ) -> None:
     """Start an explicit supervisor session to coordinate coding agents."""
     provider = provider or provider_alias
     start(prompt=prompt, provider=provider, attach=attach, watch=watch,
-          autopilot=autopilot, branch=branch, worktree=worktree)
+          autopilot=autopilot, branch=branch, worktree=worktree, yes=yes)
 
 
 def _session_root(db: DB) -> str:
@@ -2850,8 +2955,10 @@ def check_milestones_cmd(root_id: str, workspace_id: str,
     try:
         text = autopilot.check_milestones(db, root_id, ws, position)
         record_milestone_changes(db, root_id, ws, before, root, position, text)
+        head = autopilot.check_summary(db, root_id, position, text)
     except Exception as e:  # noqa: BLE001 - the supervisor must hear about it either way
         text = f"The milestone check failed to run: {e}"
+        head = agents.first_line(text)
     try:
         autopilot.start_audit(db, root_id, ws)
     except Exception as e:  # noqa: BLE001
@@ -2863,7 +2970,7 @@ def check_milestones_cmd(root_id: str, workspace_id: str,
         db.update_autopilot(root_id, checking_since=None)
     if db.get_agent(root_id) is None:
         return
-    body = f"[brindle] Milestone check finished.\n\n{text}"
+    body = agents.condense(f"[brindle] {head}", text + "\n\n(The same progress, any time: get_progress.)")
     try:
         agents.send_message(db, root_id, body)
     except (agents.AgentError, tmux.TmuxError):

{brindle-0.3.18 → brindle-0.3.20}/src/brindle/config.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 
 import json
 import os
+import sys
 from dataclasses import dataclass, field
 from pathlib import Path
 
@@ -94,7 +95,7 @@ class RepoConfig:
     pre_commit: bool = True            # run pre-commit (the framework) over a branch before merging
     max_agents: int = 5                # workers running at once per session; 0 means no cap
     check_timeout: int = 900           # seconds allowed for each check command
-    check_concurrency: int = 2         # check runs at once on this machine, across branches; the rest queue (0: no cap)
+    check_concurrency: int = 4         # check runs at once on this machine, across branches; the rest queue (0: no cap)
     usage_limit: int = 90              # autopilot stops pushing on at this % of the Claude usage limit
     limit_cooldown_minutes: int | None = None  # how long a provider that hit its limit counts as unavailable (default 300 for Antigravity)
     graphify: bool | None = None       # point agents at graphify-out/graph.json (None: if it's there)
@@ -267,6 +268,9 @@ def load_repo_config(repo_root: str | Path) -> RepoConfig:
                 if norm_tier in WEIGHTS and isinstance(names, list):
                     cfg.routing[norm_tier] = [n for n in names if isinstance(n, str)]
                     cfg.routing_sources[norm_tier] = str(path)
+    from brindle import worker_models
+
+    worker_models.apply(cfg, user, str(repo_root))   # the models picked on the picker's workers screen
     for source in (shared, local):  # per weight, so a repo can override one and keep the rest
         second = source.get("second_review")
         if isinstance(second, dict):
@@ -311,9 +315,23 @@ def user_settings() -> dict:
     return _read_json(user_config_path())
 
 
+SUPERVISOR_KEY = "supervisor"      # ~/.brindle/config.json: the CLI the person last picked for the supervisor
+
+
+def supervisor_pick() -> str | None:
+    """The supervisor CLI this person last picked (in the picker or with
+    ``-s``), or None before the first pick."""
+    pick = user_settings().get(SUPERVISOR_KEY)
+    return pick if isinstance(pick, str) and pick else None
+
+
 def set_user(key: str, value: object) -> Path:
     """Set one key in ``~/.brindle/config.json`` (other keys are kept)."""
     path = user_config_path()
+    if os.environ.get("BRINDLE_AGENT_ID"):
+        # A brindle agent's CLI call must not change the person's own settings.
+        print("brindle: running as an agent, so ~/.brindle/config.json was not changed", file=sys.stderr)
+        return path
     path.parent.mkdir(parents=True, exist_ok=True)
     data = _read_json(path)
     data[key] = value

{brindle-0.3.18 → brindle-0.3.20}/src/brindle/cull.py

@@ -49,6 +49,9 @@ from brindle.pro import route_health
 
 # An agent this new may not have its window recorded yet.
 LAUNCH_GRACE = 60.0
+# How long a message waits for its normal delivery (a hook, the start-up
+# flush) before a sweep retries it.
+FLUSH_RETRY_AFTER = 30.0
 
 
 def _root(db: DB, a: Agent) -> str:
@@ -202,6 +205,21 @@ def sweep(db: DB, now: float | None = None) -> list[str]:
             done.append(f"closed {'idle' if finished else 'stopped'} worker {a.id} "
                         f"after {int(idle_for // 60)} min")
 
+    # 2b. Messages a flush left queued because the pane wasn't ready (the
+    # person typing, say): an idle agent with no turn-end hook (agy), or one
+    # just waiting, would never get them otherwise. flush itself still waits
+    # for typed input, a held login, and claims the agent before pasting.
+    for a in db.list_agents():
+        oldest = db.oldest_pending(a.id)
+        if (oldest is not None and now - oldest >= FLUSH_RETRY_AFTER and a.status == "idle"
+                and not a.headless and a.dismissed_at is None and agents.runs_process(a)
+                and here(a) and alive(a)):
+            try:
+                if agents.flush(db, a.id):
+                    done.append(f"delivered a queued message to {a.id}")
+            except (agents.AgentError, tmux.TmuxError):
+                pass  # stays queued for the next sweep
+
     # 3. Launches stopped on a startup prompt; workers stuck on a prompt
     # nobody is answering, or gone silent.
     done.extend(settle_startups(db, now, panes))