brigade-cli 0.10.3__tar.gz → 0.12.0__tar.gz

{brigade_cli-0.10.3 → brigade_cli-0.12.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: brigade-cli
-Version: 0.10.3
+Version: 0.12.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
@@ -35,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">
@@ -47,36 +47,47 @@ 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.
 
 So I hand-rolled the fixes, one incident at a time: a slim `MEMORY.md` index pointing at small memory cards instead of one giant file, a handoff note format every harness could write, an ingest cron that filed the good notes into durable memory every 30 minutes, staleness checks so old cards stopped being trusted forever.
 
-Two incidents shaped the design more than anything I planned. First, a nightly "dreaming" job that auto-promoted session fragments bloated `MEMORY.md` to 41KB, way past the 12KB bootstrap budget, so every session started with truncated memory and nobody noticed for weeks. Auto-promotion died that day. Everything goes through review now. Second, I found 195 handoff notes sitting unread across 35 repos because the ingester had a hardcoded three-repo allowlist and nothing warned about the coverage gap. Silence is the failure mode. Every part of Brigade that lints, warns, or writes a receipt exists because something once failed in silence.
+Two incidents shaped the design more than anything I planned. First, a nightly "dreaming" job that promoted raw session fragments straight into memory bloated `MEMORY.md` to 41KB, way past the 12KB bootstrap budget, so every session started with truncated memory and nobody noticed for weeks. Blind auto-promotion died that day. Now nothing reaches memory unlinted: a note has to name a target and clear the guards, the safe ones file themselves, and only the risky few wait for review. Second, I found 195 handoff notes sitting unread across 35 repos because the ingester had a hardcoded three-repo allowlist and nothing warned about the coverage gap. Silence is the failure mode. Every part of Brigade that lints, warns, or writes a receipt exists because something once failed in silence.
 
-That system now runs 482 memory cards and survives daily multi-agent work. But explaining it to anyone meant: clone six repos, write these crons, keep your index slim, watch for staleness, and whatever you do, turn auto-promotion off. Brigade is that setup packaged as one installable CLI. The full production stack is documented in the [solos-cookbook](https://github.com/escoffier-labs/solos-cookbook) if you want to see where it came from.
+That system now runs 482 memory cards and survives daily multi-agent work. But explaining it to anyone meant: clone six repos, write these crons, keep your index slim, watch for staleness, and never let a note reach memory unlinted. Brigade is that setup packaged as one installable CLI. The full production stack is documented in the [solos-cookbook](https://github.com/escoffier-labs/solos-cookbook) if you want to see where it came from.
 
 ## The loop
 
-Writer harnesses leave handoff notes as they work. A memory owner (OpenClaw, Hermes, or just you) ingests the ones worth keeping. Brigade lints, guards, and routes everything in between, and every consequential action lands a receipt in a plain file you can grep, diff, and prune.
+Writer harnesses leave handoff notes as they work. Brigade lints, guards, and classifies each one, then files the safe, targeted notes into durable memory on its own. A memory owner (OpenClaw, Hermes, or just you) only steps in for the ambiguous few. Every consequential action lands a receipt in a plain file you can grep, diff, and prune.
 
 1. agents write handoff notes into their own local inboxes
-2. Brigade lints and scans them before they can become memory
-3. safe targeted notes get filed into durable memory by the owner
-4. ambiguous or risky notes wait for your review
+2. Brigade lints and classifies each one before it can become memory
+3. safe, targeted notes file themselves into durable memory automatically
+4. only the ambiguous or risky few wait for your review
 5. future sessions start with better context, and receipts show what happened
 
 ```mermaid
 flowchart LR
     WRITERS["writer harnesses<br/>Codex · Claude Code · OpenCode · ..."]
-    BRIGADE["Brigade<br/>lint · guard · route · receipts"]
-    REVIEW["operator review<br/>safe · ambiguous · risky"]
+    BRIGADE["Brigade<br/>lint · guard · classify · receipts"]
     OWNER["memory owner<br/>OpenClaw / Hermes / you"]
     MEM["durable memory<br/>MEMORY.md index · memory cards"]
+    REVIEW["review inbox<br/>ambiguous · risky"]
 
-    WRITERS -- handoff notes --> BRIGADE --> REVIEW
-    REVIEW -- safe targeted notes --> OWNER --> MEM
+    WRITERS -- handoff notes --> BRIGADE --> OWNER
+    OWNER -- safe targeted, auto-filed --> MEM
+    OWNER -. ambiguous or risky .-> REVIEW
     MEM -. context .-> WRITERS
 
     classDef brigade fill:#2563eb,stroke:#1d4ed8,color:#fff;
@@ -140,19 +151,24 @@ 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 |
 
-All of them get handoff templates, ingest source coverage, and projected tools/skills. Per-harness details are in the [technical guide](docs/technical-guide.md).
+All of them get handoff templates and ingest source coverage. Most also get projected tools and skills in their native format (some as `rules` or `instructions`, a few not yet); the per-harness matrix is in the [technical guide](docs/technical-guide.md).
 
 ## Beyond memory
 
 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).
@@ -188,6 +204,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.3 → brigade_cli-0.12.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
@@ -43,8 +55,11 @@ Which harnesses do you use? (type numbers separated by space/comma to toggle, en
   [ ] 12. Kimi Code
   [ ] 13. AdaL
   [ ] 14. OpenHands
-  [ ] 15. OpenClaw
-  [ ] 16. Hermes (experimental)
+  [ ] 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)
@@ -58,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

{brigade_cli-0.10.3 → brigade_cli-0.12.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,36 +17,47 @@
 
 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.
 
 So I hand-rolled the fixes, one incident at a time: a slim `MEMORY.md` index pointing at small memory cards instead of one giant file, a handoff note format every harness could write, an ingest cron that filed the good notes into durable memory every 30 minutes, staleness checks so old cards stopped being trusted forever.
 
-Two incidents shaped the design more than anything I planned. First, a nightly "dreaming" job that auto-promoted session fragments bloated `MEMORY.md` to 41KB, way past the 12KB bootstrap budget, so every session started with truncated memory and nobody noticed for weeks. Auto-promotion died that day. Everything goes through review now. Second, I found 195 handoff notes sitting unread across 35 repos because the ingester had a hardcoded three-repo allowlist and nothing warned about the coverage gap. Silence is the failure mode. Every part of Brigade that lints, warns, or writes a receipt exists because something once failed in silence.
+Two incidents shaped the design more than anything I planned. First, a nightly "dreaming" job that promoted raw session fragments straight into memory bloated `MEMORY.md` to 41KB, way past the 12KB bootstrap budget, so every session started with truncated memory and nobody noticed for weeks. Blind auto-promotion died that day. Now nothing reaches memory unlinted: a note has to name a target and clear the guards, the safe ones file themselves, and only the risky few wait for review. Second, I found 195 handoff notes sitting unread across 35 repos because the ingester had a hardcoded three-repo allowlist and nothing warned about the coverage gap. Silence is the failure mode. Every part of Brigade that lints, warns, or writes a receipt exists because something once failed in silence.
 
-That system now runs 482 memory cards and survives daily multi-agent work. But explaining it to anyone meant: clone six repos, write these crons, keep your index slim, watch for staleness, and whatever you do, turn auto-promotion off. Brigade is that setup packaged as one installable CLI. The full production stack is documented in the [solos-cookbook](https://github.com/escoffier-labs/solos-cookbook) if you want to see where it came from.
+That system now runs 482 memory cards and survives daily multi-agent work. But explaining it to anyone meant: clone six repos, write these crons, keep your index slim, watch for staleness, and never let a note reach memory unlinted. Brigade is that setup packaged as one installable CLI. The full production stack is documented in the [solos-cookbook](https://github.com/escoffier-labs/solos-cookbook) if you want to see where it came from.
 
 ## The loop
 
-Writer harnesses leave handoff notes as they work. A memory owner (OpenClaw, Hermes, or just you) ingests the ones worth keeping. Brigade lints, guards, and routes everything in between, and every consequential action lands a receipt in a plain file you can grep, diff, and prune.
+Writer harnesses leave handoff notes as they work. Brigade lints, guards, and classifies each one, then files the safe, targeted notes into durable memory on its own. A memory owner (OpenClaw, Hermes, or just you) only steps in for the ambiguous few. Every consequential action lands a receipt in a plain file you can grep, diff, and prune.
 
 1. agents write handoff notes into their own local inboxes
-2. Brigade lints and scans them before they can become memory
-3. safe targeted notes get filed into durable memory by the owner
-4. ambiguous or risky notes wait for your review
+2. Brigade lints and classifies each one before it can become memory
+3. safe, targeted notes file themselves into durable memory automatically
+4. only the ambiguous or risky few wait for your review
 5. future sessions start with better context, and receipts show what happened
 
 ```mermaid
 flowchart LR
     WRITERS["writer harnesses<br/>Codex · Claude Code · OpenCode · ..."]
-    BRIGADE["Brigade<br/>lint · guard · route · receipts"]
-    REVIEW["operator review<br/>safe · ambiguous · risky"]
+    BRIGADE["Brigade<br/>lint · guard · classify · receipts"]
     OWNER["memory owner<br/>OpenClaw / Hermes / you"]
     MEM["durable memory<br/>MEMORY.md index · memory cards"]
+    REVIEW["review inbox<br/>ambiguous · risky"]
 
-    WRITERS -- handoff notes --> BRIGADE --> REVIEW
-    REVIEW -- safe targeted notes --> OWNER --> MEM
+    WRITERS -- handoff notes --> BRIGADE --> OWNER
+    OWNER -- safe targeted, auto-filed --> MEM
+    OWNER -. ambiguous or risky .-> REVIEW
     MEM -. context .-> WRITERS
 
     classDef brigade fill:#2563eb,stroke:#1d4ed8,color:#fff;
@@ -110,19 +121,24 @@ 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 |
 
-All of them get handoff templates, ingest source coverage, and projected tools/skills. Per-harness details are in the [technical guide](docs/technical-guide.md).
+All of them get handoff templates and ingest source coverage. Most also get projected tools and skills in their native format (some as `rules` or `instructions`, a few not yet); the per-harness matrix is in the [technical guide](docs/technical-guide.md).
 
 ## Beyond memory
 
 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 +174,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.3 → brigade_cli-0.12.0}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "brigade-cli"
-version = "0.10.3"
+version = "0.12.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",
@@ -53,8 +53,8 @@ line-length = 120
 src = ["src", "tests"]
 
 [tool.ruff.lint]
-# Pragmatic initial gate: ruff's default rule set (pyflakes plus the
-# E4/E7/E9 pycodestyle errors). Deferred for later, separate passes:
-# import sorting (I), pyupgrade (UP), bugbear (B), the full pycodestyle
-# E/W set, and any type checking (mypy/pyright).
-select = ["E4", "E7", "E9", "F"]
+# 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.3 → brigade_cli-0.12.0}/src/brigade/__init__.py

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

{brigade_cli-0.10.3 → brigade_cli-0.12.0}/src/brigade/aboyeur.py

@@ -20,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)
@@ -46,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}"
@@ -147,7 +151,10 @@ def write_run_handoff(
         or "- no workers dispatched"
     )
     assignment_summary = (
-        "\n".join(f"- {assignment.worker}: {_one_line(assignment.task)}" for assignment in assignments)
+        "\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"
@@ -232,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(
@@ -302,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)
 
 
@@ -356,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}"
     )
 
@@ -375,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(
@@ -392,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,
@@ -404,25 +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,8 +539,10 @@ def _print_worker_status(results: list[WorkerResult]) -> None:
         print(f"  [{marker}] {result.worker}{detail}")
 
 
-def _assignment_payload(assignments: list[Assignment]) -> list[dict[str, str]]:
-    return [{"worker": assignment.worker, "task": assignment.task} for assignment in assignments]
+def _assignment_payload(assignments: list[Assignment]) -> list[dict[str, object]]:
+    return [
+        {"stage": assignment.stage, "worker": assignment.worker, "task": assignment.task} for assignment in assignments
+    ]
 
 
 def _worker_payload(results: list[WorkerResult]) -> list[dict[str, object]]:
@@ -504,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,
             }