brigade-cli 0.10.2__tar.gz → 0.11.0__tar.gz

{brigade_cli-0.10.2 → brigade_cli-0.11.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: brigade-cli
-Version: 0.10.2
+Version: 0.11.0
 Summary: AI agent memory, handoffs, and local guardrails for Codex, Claude Code, OpenCode, Hermes, and OpenClaw.
-Author-email: Solomon Neas <srneas@gmail.com>
+Author-email: Solomon Neas <me@solomonneas.dev>
 License: MIT
 Project-URL: Homepage, https://brigade.tools
 Project-URL: Repository, https://github.com/escoffier-labs/brigade
@@ -23,6 +23,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: dev
 Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: ruff>=0.15; extra == "dev"
 Provides-Extra: research
 Requires-Dist: playwright>=1.40; extra == "research"
 Dynamic: license-file
@@ -34,7 +35,7 @@ Dynamic: license-file
 <h1 align="center">Brigade CLI</h1>
 
 <p align="center">
-  <strong>AI agent memory, handoffs, and local guardrails for Codex, Claude Code, OpenCode, and a dozen other harnesses.</strong>
+  <strong>AI agent memory, handoffs, and local guardrails for Codex, Claude Code, OpenCode, and over a dozen other harnesses.</strong>
 </p>
 
 <p align="center">
@@ -46,6 +47,16 @@ Dynamic: license-file
 
 Your agents run loops. Brigade keeps the receipts.
 
+## Try it in 60 seconds
+
+```bash
+pipx install brigade-cli
+brigade operator quickstart --target ./my-repo --harnesses codex      # wire one repo
+brigade operator doctor --target ./my-repo --profile local-operator   # verify
+```
+
+That installs the CLI, wires memory, handoffs, and local guardrails into one repo for a single harness, and prints a readiness check. Nothing leaves your machine and no daemon is started. Add `--dry-run` to preview the file-by-file plan before anything is written. More harnesses, workspace setups, and the homegrown-adoption path are under [Install](#install).
+
 ## Why I built this
 
 I run an always-on OpenClaw agent next to daily Codex and Claude Code sessions, and I have since January. Every one of those tools wakes up empty. Whatever a session learned about my machine, my rules, or yesterday's dead ends scattered across tool-specific folders and died there.
@@ -117,7 +128,7 @@ brigade handoff lint --target ./my-repo
 brigade handoff doctor --target ./my-repo
 ```
 
-New here? Start with [docs/first-10-minutes.md](docs/first-10-minutes.md). Already have a homegrown setup with scripts, crons, and handoff folders? Brigade has an adoption path that inventories what you have before changing anything: start with `brigade operator adopt plan` and see the [technical guide](docs/technical-guide.md). Want an agent to set this up for you? Point it at this repo; [AGENTS.md](AGENTS.md) tells it exactly what to do and where to stop.
+New here? Start with [QUICKSTART.md](QUICKSTART.md) for the five-minute install, then [docs/first-10-minutes.md](docs/first-10-minutes.md) for the guided first session. Already have a homegrown setup with scripts, crons, and handoff folders? Brigade has an adoption path that inventories what you have before changing anything: start with `brigade operator adopt plan` and see the [technical guide](docs/technical-guide.md). Want an agent to set this up for you? Point it at this repo; [AGENTS.md](AGENTS.md) tells it exactly what to do and where to stop.
 
 ## Harness support
 
@@ -139,6 +150,9 @@ Each writer gets its own local inbox; one canonical owner ingests. Brigade keeps
 | Kimi Code | `kimi` | `.kimi/memory-handoffs/` |
 | AdaL | `adal` | `.adal/memory-handoffs/` |
 | OpenHands | `openhands` | `.openhands/memory-handoffs/` |
+| Grok CLI | `grok` | `.grok/memory-handoffs/` |
+| Amp | `amp` | `.amp/memory-handoffs/` |
+| Crush | `crush` | `.crush/memory-handoffs/` |
 | Hermes | `hermes` | `.hermes/memory-handoffs/` |
 | OpenClaw | `openclaw` | usually the memory owner, not a writer |
 
@@ -149,9 +163,11 @@ All of them get handoff templates, ingest source coverage, and projected tools/s
 The memory loop is the core. Around it, the same review-and-receipt pattern covers the rest of an operator's day, and you can ignore all of it until you need it:
 
 - **Daily loop**: `brigade work brief` shows pending work, imports, and warnings; `brigade daily status` keeps it bounded and cheap.
+- **Friction logs**: `brigade friction scan --days 30 --import-candidates` mines recent notes, handoffs, session artifacts, and optional local agent logs for reviewable workflow friction.
 - **Security**: `brigade security scan` is a local read-only scanner for agent workspaces (secrets, risky hooks, MCP configs, prompt-injection patterns); `brigade scrub` gates content before it leaves the machine.
 - **Tools and skills**: one reviewed catalog projected into every harness's native format, with approval gates for anything that executes.
 - **Research**: `brigade research run` turns a question into a cited local report and a reviewable memory handoff.
+- **Cross-model runs**: `brigade run "<task>"` plans, dispatches, and synthesizes one bounded task across the agent CLIs in your roster, so an expensive model can think while cheaper ones do the grunt work. Rosters pin a model per agent, plans can stage dependent workers, and `--worktree` runs everything in a detached git checkout that comes back as a reviewable `changes.patch`. A dirty-tree guard and a run lock keep agents away from your work in progress.
 - **Fleet and release**: health evidence across your local repos and release-readiness receipts, with no publish step.
 
 The full tour of every station lives in [docs/overview.md](docs/overview.md).
@@ -187,6 +203,7 @@ That pause is the point. Agent memory should be useful, not noisy.
 - [Handoff promotion](docs/handoff-promotion.md): how notes move toward memory.
 - [Repo fleet](docs/repo-fleet.md) and [Tool catalog](docs/tool-catalog.md).
 - [Command inventory](docs/command-inventory.md): every public CLI command.
+- [Maintainers](MAINTAINERS.md), [Governance](GOVERNANCE.md), [Security](SECURITY.md), and [Contributing](CONTRIBUTING.md).
 - [Roadmap](ROADMAP.md) and [roadmap archive](docs/roadmap-archive.md).
 
 Project identity: GitHub [`escoffier-labs/brigade`](https://github.com/escoffier-labs/brigade), website [brigade.tools](https://brigade.tools), PyPI [`brigade-cli`](https://pypi.org/project/brigade-cli/), command `brigade`. The name comes from the kitchen: a *brigade de cuisine* runs the line, and *mise en place* means the station is prepped before service. Set up the rules, memory, tools, and receipts before the session gets expensive.

{brigade_cli-0.10.2 → brigade_cli-0.11.0}/QUICKSTART.md

@@ -1,6 +1,6 @@
 # Quickstart
 
-Five minutes from clone to a working agent kitchen.
+Five minutes from install to a working agent kitchen.
 
 ## 1. Install
 
@@ -23,7 +23,19 @@ python3 -m pipx ensurepath
 
 ## First install
 
-The fastest path is to run `brigade init` with no flags and answer the prompts:
+The canonical first-run command is `brigade operator quickstart`. It installs the template files, wires the operator config, and runs the health checks in one shot:
+
+```bash
+# Code repo with Codex as the writer
+brigade operator quickstart --target ./my-repo --harnesses codex
+
+# OpenClaw or Hermes workspace instead of a code repo
+brigade operator quickstart --target ~/agent-workspace --depth workspace --harnesses openclaw,hermes --owner openclaw
+```
+
+Pass `--dry-run` first to preview the planned steps without writing anything.
+
+Two commands share this surface: `brigade init` installs the template files only, and `brigade operator quickstart` wraps it (init, then operator config, then doctor). Use `init` when you want the interactive harness picker or just the files:
 
 ```bash
 $ brigade init --target ~/agent-kitchen
@@ -31,8 +43,23 @@ $ brigade init --target ~/agent-kitchen
 Which harnesses do you use? (type numbers separated by space/comma to toggle, enter to confirm)
   [x] 1. Claude Code
   [ ] 2. Codex
-  [ ] 3. OpenClaw
-  [ ] 4. Hermes (experimental)
+  [ ] 3. OpenCode
+  [ ] 4. Antigravity
+  [ ] 5. Pi
+  [ ] 6. Cursor
+  [ ] 7. Aider
+  [ ] 8. Goose
+  [ ] 9. Continue
+  [ ] 10. GitHub Copilot CLI
+  [ ] 11. Qwen Code
+  [ ] 12. Kimi Code
+  [ ] 13. AdaL
+  [ ] 14. OpenHands
+  [ ] 15. Grok CLI
+  [ ] 16. Amp
+  [ ] 17. Crush
+  [ ] 18. OpenClaw
+  [ ] 19. Hermes (experimental)
 
 Depth? (type a number, enter for default)
   * 1. repo       (handoff flow + publish guard)
@@ -46,24 +73,30 @@ Defaults are claude harness, repo depth, no includes. Enter ships the install.
 
 ## CI / scripted install
 
-Pass flags directly to skip the prompt:
+Pass flags directly to skip the prompt. The same flags work on `operator quickstart`:
 
 ```bash
 # Claude Code + Codex + OpenClaw, full workspace
-brigade init --target ~/agent-kitchen \
+brigade operator quickstart --target ~/agent-kitchen \
   --depth workspace \
   --harnesses claude,codex,openclaw
 
 # Codex-only project, minimal install
-brigade init --target ./my-project --depth repo --harnesses codex
+brigade operator quickstart --target ./my-project --depth repo --harnesses codex
 
-# Generic layout, no harness-specific files
+# Template files only, no harness-specific files
 brigade init --target ./my-project --harnesses none
 ```
 
 ## Verifying
 
-After install, `brigade doctor --target <path>` reports the apparent harness shape and checks every configured inbox and adapter:
+After install, check the operator profile:
+
+```bash
+brigade operator doctor --target <path> --profile local-operator
+```
+
+For the file-by-file view, `brigade doctor --target <path>` reports the apparent harness shape and checks every configured inbox and adapter:
 
 ```
 brigade doctor: target /home/you/agent-kitchen
@@ -103,6 +136,6 @@ See the [Solo Cookbook](https://github.com/escoffier-labs/solos-cookbook) for th
 - Read [the cookbook](https://github.com/escoffier-labs/solos-cookbook) for the deep version of every concept here.
 - Customize `USER.md` and `TOOLS.md` with your real preferences and runbooks (kept private; do not commit personal details).
 - Wire the ingester on a cron or a manual end-of-day workflow.
-- Add a memory-care staleness scan when your card set starts to matter. See `memory/cards/memory-care-staleness.md`.
-- If you use TokenJuice, wire Claude Code and Codex hooks deliberately and tell agents what the wrapper means. See `memory/cards/tokenjuice-output-compaction.md`.
+- Add a memory-care staleness scan when your card set starts to matter. See [docs/memory-care.md](docs/memory-care.md).
+- If you use TokenJuice, wire Claude Code and Codex hooks deliberately and tell agents what the wrapper means. See the tokens station in [docs/technical-guide.md](docs/technical-guide.md#managed-stations).
 - Run `brigade work bootstrap` inside active repos when you want the dogfood-backed daily work loop, scanner inbox, and local evidence receipts.

{brigade_cli-0.10.2 → brigade_cli-0.11.0}/README.md

@@ -5,7 +5,7 @@
 <h1 align="center">Brigade CLI</h1>
 
 <p align="center">
-  <strong>AI agent memory, handoffs, and local guardrails for Codex, Claude Code, OpenCode, and a dozen other harnesses.</strong>
+  <strong>AI agent memory, handoffs, and local guardrails for Codex, Claude Code, OpenCode, and over a dozen other harnesses.</strong>
 </p>
 
 <p align="center">
@@ -17,6 +17,16 @@
 
 Your agents run loops. Brigade keeps the receipts.
 
+## Try it in 60 seconds
+
+```bash
+pipx install brigade-cli
+brigade operator quickstart --target ./my-repo --harnesses codex      # wire one repo
+brigade operator doctor --target ./my-repo --profile local-operator   # verify
+```
+
+That installs the CLI, wires memory, handoffs, and local guardrails into one repo for a single harness, and prints a readiness check. Nothing leaves your machine and no daemon is started. Add `--dry-run` to preview the file-by-file plan before anything is written. More harnesses, workspace setups, and the homegrown-adoption path are under [Install](#install).
+
 ## Why I built this
 
 I run an always-on OpenClaw agent next to daily Codex and Claude Code sessions, and I have since January. Every one of those tools wakes up empty. Whatever a session learned about my machine, my rules, or yesterday's dead ends scattered across tool-specific folders and died there.
@@ -88,7 +98,7 @@ brigade handoff lint --target ./my-repo
 brigade handoff doctor --target ./my-repo
 ```
 
-New here? Start with [docs/first-10-minutes.md](docs/first-10-minutes.md). Already have a homegrown setup with scripts, crons, and handoff folders? Brigade has an adoption path that inventories what you have before changing anything: start with `brigade operator adopt plan` and see the [technical guide](docs/technical-guide.md). Want an agent to set this up for you? Point it at this repo; [AGENTS.md](AGENTS.md) tells it exactly what to do and where to stop.
+New here? Start with [QUICKSTART.md](QUICKSTART.md) for the five-minute install, then [docs/first-10-minutes.md](docs/first-10-minutes.md) for the guided first session. Already have a homegrown setup with scripts, crons, and handoff folders? Brigade has an adoption path that inventories what you have before changing anything: start with `brigade operator adopt plan` and see the [technical guide](docs/technical-guide.md). Want an agent to set this up for you? Point it at this repo; [AGENTS.md](AGENTS.md) tells it exactly what to do and where to stop.
 
 ## Harness support
 
@@ -110,6 +120,9 @@ Each writer gets its own local inbox; one canonical owner ingests. Brigade keeps
 | Kimi Code | `kimi` | `.kimi/memory-handoffs/` |
 | AdaL | `adal` | `.adal/memory-handoffs/` |
 | OpenHands | `openhands` | `.openhands/memory-handoffs/` |
+| Grok CLI | `grok` | `.grok/memory-handoffs/` |
+| Amp | `amp` | `.amp/memory-handoffs/` |
+| Crush | `crush` | `.crush/memory-handoffs/` |
 | Hermes | `hermes` | `.hermes/memory-handoffs/` |
 | OpenClaw | `openclaw` | usually the memory owner, not a writer |
 
@@ -120,9 +133,11 @@ All of them get handoff templates, ingest source coverage, and projected tools/s
 The memory loop is the core. Around it, the same review-and-receipt pattern covers the rest of an operator's day, and you can ignore all of it until you need it:
 
 - **Daily loop**: `brigade work brief` shows pending work, imports, and warnings; `brigade daily status` keeps it bounded and cheap.
+- **Friction logs**: `brigade friction scan --days 30 --import-candidates` mines recent notes, handoffs, session artifacts, and optional local agent logs for reviewable workflow friction.
 - **Security**: `brigade security scan` is a local read-only scanner for agent workspaces (secrets, risky hooks, MCP configs, prompt-injection patterns); `brigade scrub` gates content before it leaves the machine.
 - **Tools and skills**: one reviewed catalog projected into every harness's native format, with approval gates for anything that executes.
 - **Research**: `brigade research run` turns a question into a cited local report and a reviewable memory handoff.
+- **Cross-model runs**: `brigade run "<task>"` plans, dispatches, and synthesizes one bounded task across the agent CLIs in your roster, so an expensive model can think while cheaper ones do the grunt work. Rosters pin a model per agent, plans can stage dependent workers, and `--worktree` runs everything in a detached git checkout that comes back as a reviewable `changes.patch`. A dirty-tree guard and a run lock keep agents away from your work in progress.
 - **Fleet and release**: health evidence across your local repos and release-readiness receipts, with no publish step.
 
 The full tour of every station lives in [docs/overview.md](docs/overview.md).
@@ -158,6 +173,7 @@ That pause is the point. Agent memory should be useful, not noisy.
 - [Handoff promotion](docs/handoff-promotion.md): how notes move toward memory.
 - [Repo fleet](docs/repo-fleet.md) and [Tool catalog](docs/tool-catalog.md).
 - [Command inventory](docs/command-inventory.md): every public CLI command.
+- [Maintainers](MAINTAINERS.md), [Governance](GOVERNANCE.md), [Security](SECURITY.md), and [Contributing](CONTRIBUTING.md).
 - [Roadmap](ROADMAP.md) and [roadmap archive](docs/roadmap-archive.md).
 
 Project identity: GitHub [`escoffier-labs/brigade`](https://github.com/escoffier-labs/brigade), website [brigade.tools](https://brigade.tools), PyPI [`brigade-cli`](https://pypi.org/project/brigade-cli/), command `brigade`. The name comes from the kitchen: a *brigade de cuisine* runs the line, and *mise en place* means the station is prepped before service. Set up the rules, memory, tools, and receipts before the session gets expensive.

{brigade_cli-0.10.2 → brigade_cli-0.11.0}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "brigade-cli"
-version = "0.10.2"
+version = "0.11.0"
 description = "AI agent memory, handoffs, and local guardrails for Codex, Claude Code, OpenCode, Hermes, and OpenClaw."
 readme = "README.md"
 requires-python = ">=3.10"
 license = { text = "MIT" }
-authors = [{ name = "Solomon Neas", email = "srneas@gmail.com" }] # content-guard: allow email
+authors = [{ name = "Solomon Neas", email = "me@solomonneas.dev" }] # content-guard: allow email
 keywords = ["agents", "ai-agents", "agent-memory", "agent-handoffs", "ai-memory", "openclaw", "claude-code", "codex", "opencode", "memory", "bootstrap", "brigade", "brigade-cli", "operator", "local-first", "guardrails", "agents-md"]
 classifiers = [
     "Development Status :: 3 - Alpha",
@@ -22,7 +22,7 @@ classifiers = [
 dependencies = []
 
 [project.optional-dependencies]
-dev = ["pytest>=7"]
+dev = ["pytest>=7", "ruff>=0.15"]
 research = ["playwright>=1.40"]
 
 [project.urls]
@@ -47,3 +47,14 @@ brigade = ["py.typed", "templates/**/*"]
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 addopts = "-ra"
+
+[tool.ruff]
+line-length = 120
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+# Pragmatic gate: ruff's default rule set (pyflakes plus the E4/E7/E9
+# pycodestyle errors) plus bugbear (B). Deferred for later, separate
+# passes: import sorting (I), pyupgrade (UP), the full pycodestyle E/W
+# set, and any type checking (mypy/pyright).
+select = ["B", "E4", "E7", "E9", "F"]

{brigade_cli-0.10.2 → brigade_cli-0.11.0}/src/brigade/__init__.py

@@ -1,3 +1,3 @@
 """Brigade: local operator-system CLI for agent workspaces."""
 
-__version__ = "0.10.2"
+__version__ = "0.11.0"

{brigade_cli-0.10.2 → brigade_cli-0.11.0}/src/brigade/__main__.py

@@ -1,4 +1,5 @@
 """Enable `python -m brigade`."""
+
 from .cli import main
 
 if __name__ == "__main__":

{brigade_cli-0.10.2 → brigade_cli-0.11.0}/src/brigade/aboyeur.py

@@ -1,4 +1,5 @@
 """Bounded cross-model orchestration for `brigade run`."""
+
 from __future__ import annotations
 
 import json
@@ -19,6 +20,7 @@ from .roster import Agent, Roster, is_cli_allowed, timeout_for, workers
 class Assignment:
     worker: str
     task: str
+    stage: int = 1
 
 
 @dataclass(frozen=True)
@@ -36,9 +38,7 @@ def build_plan_prompt(
     corrective_note: str | None = None,
     read_only: bool = False,
 ) -> str:
-    worker_lines = "\n".join(
-        f"- {agent.name}: cli={agent.cli}; role={agent.role}" for agent in workers(roster)
-    )
+    worker_lines = "\n".join(f"- {agent.name}: cli={agent.cli}; role={agent.role}" for agent in workers(roster))
     if not worker_lines:
         worker_lines = "- no workers configured"
 
@@ -47,11 +47,14 @@ def build_plan_prompt(
     return (
         "You are the Brigade aboyeur. Split the user's task across the available workers.\n"
         "Return exactly one JSON object, with no prose outside JSON:\n"
-        '{"assignments":[{"worker":"<worker-name>","task":"<specific sub-task>"}]}\n'
+        '{"assignments":[{"stage":1,"worker":"<worker-name>","task":"<specific sub-task>"}]}\n'
         f"{note}\n"
         f"User task:\n{task}\n\n"
         f"Available workers, excluding you:\n{worker_lines}\n\n"
-        f"Rules:\n- Use at most {roster.max_workers} assignments.\n"
+        f"Rules:\n- Use at most {roster.max_workers} assignments per stage.\n"
+        "- Stage must be a positive integer starting at stage 1.\n"
+        "- Assignments in the same stage run in parallel; later stages receive earlier-stage worker results.\n"
+        "- Omit stage only for backwards-compatible stage 1 assignments.\n"
         "- Assign only listed workers.\n"
         "- Use zero assignments only if no worker is useful."
         f"{policy}"
@@ -139,14 +142,21 @@ def write_run_handoff(
     timestamp = (now or datetime.now(timezone.utc)).strftime("%Y-%m-%d-%H%M")
     safe_task = _one_line(task)
     path = inbox / f"{timestamp}-brigade-run-{_slug(safe_task)}.md"
-    worker_summary = "\n".join(
-        f"- {result.worker}: {'ok' if result.ok else 'failed'}"
-        + (f" ({_one_line(result.detail)})" if result.detail else "")
-        for result in worker_results
-    ) or "- no workers dispatched"
-    assignment_summary = "\n".join(
-        f"- {assignment.worker}: {_one_line(assignment.task)}" for assignment in assignments
-    ) or "- no worker assignments"
+    worker_summary = (
+        "\n".join(
+            f"- {result.worker}: {'ok' if result.ok else 'failed'}"
+            + (f" ({_one_line(result.detail)})" if result.detail else "")
+            for result in worker_results
+        )
+        or "- no workers dispatched"
+    )
+    assignment_summary = (
+        "\n".join(
+            f"- stage {assignment.stage} -> {assignment.worker}: {_one_line(assignment.task)}"
+            for assignment in assignments
+        )
+        or "- no worker assignments"
+    )
     artifact_line = f"- artifacts: `{output_dir}`" if output_dir is not None else "- artifacts: none"
     cwd_line = f"- cwd: `{cwd}`" if cwd is not None else "- cwd: not set"
     mode_line = "- mode: read-only" if read_only else "- mode: normal"
@@ -229,30 +239,38 @@ def parse_plan(text: str, roster: Roster) -> list[Assignment]:
     raw_assignments = payload.get("assignments")
     if not isinstance(raw_assignments, list):
         raise ValueError("plan JSON needs an assignments list")
-    if len(raw_assignments) > roster.max_workers:
-        raise ValueError(f"plan has {len(raw_assignments)} assignments, limit is {roster.max_workers}")
 
     assignments: list[Assignment] = []
-    seen: set[tuple[str, str]] = set()
+    seen: set[tuple[int, str, str]] = set()
+    stage_counts: dict[int, int] = {}
     for item in raw_assignments:
         if not isinstance(item, dict):
             raise ValueError("each assignment must be an object")
-        worker = item.get("worker")
+        stage = item.get("stage", 1)
+        if isinstance(stage, bool) or not isinstance(stage, int) or stage < 1:
+            raise ValueError("assignment.stage must be a positive integer")
+        raw_worker = item.get("worker")
         subtask = item.get("task")
-        if not isinstance(worker, str) or not worker.strip():
+        if not isinstance(raw_worker, str) or not raw_worker.strip():
             raise ValueError("assignment.worker must be a non-empty string")
+        worker = raw_worker.strip()
         if worker not in roster.agents:
             raise ValueError(f"assignment references unknown worker: {worker!r}")
         if worker == roster.orchestrator:
             raise ValueError("assignment cannot target the orchestrator")
         if not isinstance(subtask, str) or not subtask.strip():
             raise ValueError("assignment.task must be a non-empty string")
-        assignment = Assignment(worker=worker.strip(), task=subtask.strip())
-        key = (assignment.worker, assignment.task)
+        assignment = Assignment(worker=worker, task=subtask.strip(), stage=stage)
+        key = (assignment.stage, assignment.worker, assignment.task)
         if key not in seen:
             assignments.append(assignment)
             seen.add(key)
-    return assignments
+            stage_counts[assignment.stage] = stage_counts.get(assignment.stage, 0) + 1
+
+    for stage, count in stage_counts.items():
+        if count > roster.max_workers:
+            raise ValueError(f"plan has {count} assignments in stage {stage}, limit is {roster.max_workers}")
+    return sorted(assignments, key=lambda assignment: assignment.stage)
 
 
 def _record_plan_attempt(
@@ -299,6 +317,8 @@ def _run_orchestrator(
     }
     if sandbox is not None:
         kwargs["sandbox"] = sandbox
+    if orchestrator.model is not None:
+        kwargs["model"] = orchestrator.model
     return agents.run_agent(orchestrator.cli, prompt, **kwargs)
 
 
@@ -353,13 +373,39 @@ def plan(
             raise RuntimeError(f"orchestrator returned an invalid plan: {second_exc}") from second_exc
 
 
-def _worker_prompt(agent: Agent, assignment: Assignment, read_only: bool = False) -> str:
+def _render_prior_results(results: list[WorkerResult]) -> str:
+    return "\n\n".join(
+        "\n".join(
+            [
+                f"Worker: {result.worker}",
+                f"Sub-task: {result.task}",
+                f"Status: {'ok' if result.ok else 'failed'}",
+                f"Detail: {result.detail}" if result.detail else "Detail:",
+                "Output:",
+                result.text or "(no output)",
+            ]
+        )
+        for result in results
+    )
+
+
+def _worker_prompt(
+    agent: Agent,
+    assignment: Assignment,
+    *,
+    prior_results: list[WorkerResult] | None = None,
+    read_only: bool = False,
+) -> str:
+    prior_context = ""
+    if prior_results:
+        prior_context = f"\n\nEarlier-stage context:\n{_render_prior_results(prior_results)}"
     policy = f"\n\n{_read_only_rules()}" if read_only else ""
     return (
         f"You are Brigade worker {agent.name}.\n"
         f"Role:\n{agent.role}\n\n"
         f"Sub-task:\n{assignment.task}\n\n"
         "Return a concise, complete result for the orchestrator to synthesize."
+        f"{prior_context}"
         f"{policy}"
     )
 
@@ -372,7 +418,7 @@ def dispatch(
     sandbox_read_only: bool | None = None,
     sandbox: str | None = None,
 ) -> list[WorkerResult]:
-    def run_one(assignment: Assignment) -> WorkerResult:
+    def run_one(assignment: Assignment, prior_results: list[WorkerResult]) -> WorkerResult:
         agent = roster.agents[assignment.worker]
         if not is_cli_allowed(agent.cli, roster):
             return WorkerResult(
@@ -389,7 +435,13 @@ def dispatch(
         }
         if sandbox is not None:
             kwargs["sandbox"] = sandbox
-        result = agents.run_agent(agent.cli, _worker_prompt(agent, assignment, read_only=read_only), **kwargs)
+        if agent.model is not None:
+            kwargs["model"] = agent.model
+        result = agents.run_agent(
+            agent.cli,
+            _worker_prompt(agent, assignment, prior_results=prior_results, read_only=read_only),
+            **kwargs,
+        )
         return WorkerResult(
             worker=assignment.worker,
             task=assignment.task,
@@ -401,28 +453,34 @@ def dispatch(
     if not assignments:
         return []
 
-    results_by_index: dict[int, WorkerResult] = {}
-    max_workers = min(roster.max_workers, len(assignments))
-    with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        future_to_index = {
-            executor.submit(run_one, assignment): index
-            for index, assignment in enumerate(assignments)
-        }
-        for future in as_completed(future_to_index):
-            index = future_to_index[future]
-            try:
-                results_by_index[index] = future.result()
-            except Exception as exc:  # pragma: no cover - defensive boundary
-                assignment = assignments[index]
-                results_by_index[index] = WorkerResult(
-                    worker=assignment.worker,
-                    task=assignment.task,
-                    text="",
-                    ok=False,
-                    detail=str(exc)[:200],
-                )
-
-    return [results_by_index[index] for index in range(len(assignments))]
+    all_results: list[WorkerResult] = []
+    stages = sorted({assignment.stage for assignment in assignments})
+    for stage in stages:
+        stage_assignments = [assignment for assignment in assignments if assignment.stage == stage]
+        stage_results_by_index: dict[int, WorkerResult] = {}
+        prior_results = list(all_results)
+        max_workers = min(roster.max_workers, len(stage_assignments))
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            future_to_index = {
+                executor.submit(run_one, assignment, prior_results): index
+                for index, assignment in enumerate(stage_assignments)
+            }
+            for future in as_completed(future_to_index):
+                index = future_to_index[future]
+                try:
+                    stage_results_by_index[index] = future.result()
+                except Exception as exc:  # pragma: no cover - defensive boundary
+                    assignment = stage_assignments[index]
+                    stage_results_by_index[index] = WorkerResult(
+                        worker=assignment.worker,
+                        task=assignment.task,
+                        text="",
+                        ok=False,
+                        detail=str(exc)[:200],
+                    )
+        all_results.extend(stage_results_by_index[index] for index in range(len(stage_assignments)))
+
+    return all_results
 
 
 def build_synth_prompt(task: str, results: list[WorkerResult], read_only: bool = False) -> str:
@@ -458,8 +516,16 @@ def _print_plan(assignments: list[Assignment]) -> None:
     if not assignments:
         print("  (no worker assignments)")
         return
-    for assignment in assignments:
-        print(f"  -> {assignment.worker}: {assignment.task}")
+    stages = sorted({assignment.stage for assignment in assignments})
+    if len(stages) == 1:
+        for assignment in assignments:
+            print(f"  -> {assignment.worker}: {assignment.task}")
+        return
+    for stage in stages:
+        print(f"  stage {stage}:")
+        for assignment in assignments:
+            if assignment.stage == stage:
+                print(f"    -> {assignment.worker}: {assignment.task}")
 
 
 def _print_worker_status(results: list[WorkerResult]) -> None:
@@ -473,10 +539,9 @@ def _print_worker_status(results: list[WorkerResult]) -> None:
         print(f"  [{marker}] {result.worker}{detail}")
 
 
-def _assignment_payload(assignments: list[Assignment]) -> list[dict[str, str]]:
+def _assignment_payload(assignments: list[Assignment]) -> list[dict[str, object]]:
     return [
-        {"worker": assignment.worker, "task": assignment.task}
-        for assignment in assignments
+        {"stage": assignment.stage, "worker": assignment.worker, "task": assignment.task} for assignment in assignments
     ]
 
 
@@ -507,9 +572,11 @@ def _roster_payload(roster: Roster) -> dict[str, object]:
         "max_workers": roster.max_workers,
         "timeout_seconds": roster.timeout_seconds,
         "allow_models": list(roster.allow_models),
+        "sandbox": roster.sandbox,
         "agents": {
             name: {
                 "cli": agent.cli,
+                "model": agent.model,
                 "role": agent.role,
                 "timeout_seconds": agent.timeout_seconds,
             }

{brigade_cli-0.10.2 → brigade_cli-0.11.0}/src/brigade/actionqueue.py

@@ -11,6 +11,7 @@ The phase-ledger queue in phases_cmd stays local: it stores one JSON file
 per action and stamps `reviewed_at`/`review_reason` instead of the
 `started_at`/`completed_at`/`deferred_at` lifecycle fields below.
 """
+
 from __future__ import annotations
 
 import json

{brigade_cli-0.10.2 → brigade_cli-0.11.0}/src/brigade/add.py

@@ -1,4 +1,5 @@
 """`brigade add <station>` - install and wire a station's managed tools."""
+
 from __future__ import annotations
 
 import sys