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

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

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: brigade-cli
-Version: 0.10.3
+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
@@ -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,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.
@@ -140,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 |
 
@@ -150,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).
@@ -188,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.3 → 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
@@ -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.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.
@@ -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.3 → brigade_cli-0.11.0}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "brigade-cli"
-version = "0.10.3"
+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",
@@ -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.11.0}/src/brigade/__init__.py

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

{brigade_cli-0.10.3 → brigade_cli-0.11.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,
             }

{brigade_cli-0.10.3 → brigade_cli-0.11.0}/src/brigade/agents.py

@@ -97,6 +97,21 @@ def _openhands_argv(prompt: str, read_only: bool, sandbox: str | None) -> List[s
     return ["openhands", "--headless", "-t", task]
 
 
+def _grok_argv(prompt: str, read_only: bool, sandbox: str | None) -> List[str]:
+    task = _read_only_prompt(prompt) if read_only or sandbox == "read-only" else prompt
+    return ["grok", "--prompt", task]
+
+
+def _amp_argv(prompt: str, read_only: bool, sandbox: str | None) -> List[str]:
+    task = _read_only_prompt(prompt) if read_only or sandbox == "read-only" else prompt
+    return ["amp", "--prompt", task]
+
+
+def _crush_argv(prompt: str, read_only: bool, sandbox: str | None) -> List[str]:
+    task = _read_only_prompt(prompt) if read_only or sandbox == "read-only" else prompt
+    return ["crush", "--prompt", task]
+
+
 _ADAPTERS: dict[str, Callable[[str, bool, str | None], List[str]]] = {
     "claude": _claude_argv,
     "codex": _codex_argv,
@@ -112,6 +127,9 @@ _ADAPTERS: dict[str, Callable[[str, bool, str | None], List[str]]] = {
     "kimi": _kimi_argv,
     "adal": _adal_argv,
     "openhands": _openhands_argv,
+    "grok": _grok_argv,
+    "amp": _amp_argv,
+    "crush": _crush_argv,
 }
 
 
@@ -138,26 +156,42 @@ def command_for(cli_ref: str) -> str:
     return cli_ref
 
 
+def _with_model(cli_ref: str, argv: List[str], model: str) -> List[str]:
+    if cli_ref == "claude":
+        # claude --model <id> -p <prompt>
+        return [argv[0], "--model", model, *argv[1:]]
+    if cli_ref == "codex":
+        # codex exec [--sandbox <mode>] -m <id> <prompt>
+        return [*argv[:-1], "-m", model, argv[-1]]
+    raise ValueError(f"{cli_ref!r} does not support model pinning (supported: claude, codex)")
+
+
 def build_argv(
     cli_ref: str,
     prompt: str,
     read_only: bool = False,
     sandbox: str | None = None,
+    model: str | None = None,
 ) -> List[str]:
     if cli_ref.startswith(_OLLAMA_PREFIX):
-        model = cli_ref[len(_OLLAMA_PREFIX) :]
-        if not model:
+        ollama_model = cli_ref[len(_OLLAMA_PREFIX) :]
+        if not ollama_model:
             raise ValueError(f"ollama reference needs a model: {cli_ref!r}")
-        return ["ollama", "run", model, prompt]
+        if model is not None:
+            raise ValueError(f"{cli_ref!r} already names a model; drop the separate model setting")
+        return ["ollama", "run", ollama_model, prompt]
 
     builder = _ADAPTERS.get(cli_ref)
     if builder is None:
         raise ValueError(
             f"unknown agent cli: {cli_ref!r} "
             "(known: claude, codex, opencode, antigravity, pi, cursor, aider, goose, continue, "
-            "copilot, qwen, kimi, adal, openhands, ollama:<model>)"
+            "copilot, qwen, kimi, adal, openhands, grok, amp, crush, ollama:<model>)"
         )
-    return builder(prompt, read_only, sandbox)
+    argv = builder(prompt, read_only, sandbox)
+    if model is not None:
+        argv = _with_model(cli_ref, argv, model)
+    return argv
 
 
 def detect(cli_ref: str) -> bool:
@@ -171,11 +205,16 @@ def run_agent(
     cwd: Path | None = None,
     read_only: bool = False,
     sandbox: str | None = None,
+    model: str | None = None,
 ) -> AgentResult:
     if not detect(cli_ref):
         return AgentResult(text="", ok=False, detail=f"{command_for(cli_ref)} not installed")
 
-    result = proc.run(build_argv(cli_ref, prompt, read_only=read_only, sandbox=sandbox), timeout=timeout, cwd=cwd)
+    result = proc.run(
+        build_argv(cli_ref, prompt, read_only=read_only, sandbox=sandbox, model=model),
+        timeout=timeout,
+        cwd=cwd,
+    )
     text = result.stdout.strip()
     if result.code != 0:
         detail = result.stderr.strip() or f"exit {result.code}"

{brigade_cli-0.10.3 → brigade_cli-0.11.0}/src/brigade/center_cmd.py

@@ -34,6 +34,7 @@ from . import (
     work_cmd,
 )
 from .localio import (
+    parse_iso_datetime,
     read_json_dict as _read_json,
     read_jsonl_dicts as _read_jsonl,
     utc_now as _now,
@@ -2632,7 +2633,7 @@ def report_review(*, target: Path, report_id: str = "latest", json_output: bool
 def _receipt_newer_than_report(receipt: dict[str, Any] | None, report_created: datetime | None) -> bool:
     if receipt is None or report_created is None:
         return False
-    stamp = work_cmd._parse_iso_datetime(
+    stamp = parse_iso_datetime(
         receipt.get("completed_at")
         or receipt.get("created_at")
         or receipt.get("started_at")
@@ -2850,7 +2851,7 @@ def report_compare(*, target: Path, report_id: str = "latest", json_output: bool
     ):
         if _receipt_newer_than_report(receipt if isinstance(receipt, dict) else None, report_created):
             issues.append({"status": "warn", "name": name, "detail": str((receipt or {}).get(key))})
-    security_generated = work_cmd._parse_iso_datetime(
+    security_generated = parse_iso_datetime(
         (latest_security or {}).get("generated_at") if isinstance(latest_security, dict) else None
     )
     if report_created and security_generated and security_generated > report_created: