brigade-cli 0.26.0__tar.gz → 0.26.1__tar.gz

{brigade_cli-0.26.0 → brigade_cli-0.26.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: brigade-cli
-Version: 0.26.0
+Version: 0.26.1
 Summary: Your agents run loops. Brigade keeps the receipts. Local control plane for multi-agent coding: share MCP/tools/memory, remember via handoffs, prove with file receipts, improve by promoting skills only on real exit codes. Claude Code, Codex, Grok, Hermes, OpenClaw, and more. Stations for evidence, code graph, pantry, skills. pipx install brigade-cli.
 Author-email: Solomon Neas <me@solomonneas.dev>
 License: MIT
@@ -50,14 +50,15 @@ Dynamic: license-file
 <h1 align="center">Brigade</h1>
 
 <p align="center">
-  <strong>Your agents run loops. Brigade keeps the receipts.</strong>
+  <strong>One command to start. One command to keep it maintained.</strong>
 </p>
 
 <p align="center">
   <strong>Built for coding agents to run end to end</strong> (install, setup, verify, handoffs), not as a human day-to-day terminal app.
   When an agent says tests passed, you get a file with the real exit code, a <strong>code graph</strong> of what changed (<code>brigade code</code>), and an <strong>evidence log</strong> you can search later (<code>brigade evidence</code>).
   Optional: one MCP and tools catalog across agents, and shared notes with a review gate.
-  Local files. No daemon. No lock-in.
+  Brigade owns the memory-care primitives and runbooks. An external scheduler (cron, systemd, CI, your agent cron) invokes them. Local files. No daemon. No lock-in.
+  Boundary: <a href="docs/execution-model.md">execution model</a>.
 </p>
 
 <p align="center">
@@ -287,7 +288,7 @@ Beyond the daily loop, the same review-and-receipt pattern covers cross-model ru
 - **Native harness memory** is a per-tool silo. It does not cross harnesses, and it writes without review. Brigade gives every tool one shared format and one canonical owner, with a review gate in between.
 - **Already running Hermes, or any self-improving agent?** Keep it. Brigade is the verification layer on top: it promotes a skill only when a real signal confirms it, keeps every learned skill as portable markdown in your git, and runs one loop across your whole fleet.
 - **A plain CLAUDE.md / AGENTS.md** works great until it bloats past the context budget and goes stale. Brigade keeps bootstrap files slim, moves detail into indexed cards, and flags staleness instead of trusting last month's facts forever.
-- **A daemon or hosted service** would be simpler to demo and worse to trust. Brigade writes local files when you run a command, and that is all it does.
+- **A daemon or hosted service** would be simpler to demo and worse to trust. Brigade writes local files when you run a command, and that is all it does. See the [execution model](docs/execution-model.md).
 
 | | Across harnesses | MCP, tools, and memory in one source | Review gate + receipts | Local files, no daemon |
 |---|:---:|:---:|:---:|:---:|
@@ -298,7 +299,7 @@ Beyond the daily loop, the same review-and-receipt pattern covers cross-model ru
 
 ## What Brigade is not
 
-Brigade is not a hosted memory service, a daemon, or an automatic release bot. It does not run in the background or install schedulers (one scoped exception: `brigade tools runtime start` launches a local runtime process, only when you start it, until you stop it). It does not push to GitHub, publish packages, save every note automatically, or skip review for ambiguous, risky, or failed notes. `brigade work brief` and related status surfaces may report notification readiness or suggest installing the notifications station, but Brigade never sends a message unless the operator uses an explicit send action such as `brigade pantry expiry-alert --send`. That pause is the point: agent memory should be useful, not noisy.
+Brigade is not a hosted memory service, a daemon, or an automatic release bot. It does not run in the background. Scheduling stays with the operator (see the [execution model](docs/execution-model.md)). It does not push to GitHub, publish packages, save every note automatically, or skip review for ambiguous, risky, or failed notes. `brigade work brief` and related status surfaces may report notification readiness or suggest installing the notifications station, but Brigade never sends a message unless the operator uses an explicit send action such as `brigade pantry expiry-alert --send`. That pause is the point: agent memory should be useful, not noisy.
 
 And it is not the other projects that share the name. This Brigade is the AI-agent operator CLI from [`escoffier-labs/brigade`](https://github.com/escoffier-labs/brigade), installed with `pipx install brigade-cli`. It is not the CNCF/Microsoft Brigade for Kubernetes event scripting (archived 2022), the Spinabot Brigade agent crew, or the 2017 `brigade` Python package that became Nornir.
 
@@ -334,7 +335,8 @@ Nineteen harnesses get handoff inboxes and ingest coverage, from Codex, Claude C
 ## Docs
 
 - [First 10 minutes](docs/first-10-minutes.md) · [Overview](docs/overview.md) · [Technical guide](docs/technical-guide.md)
-- [MCP sync](docs/mcp-sync.md) · [Security and Content Guard](docs/security.md) · [Handoff promotion](docs/handoff-promotion.md)
+- [Execution model](docs/execution-model.md) · [Memory care](docs/memory-care.md) · [MCP sync](docs/mcp-sync.md)
+- [Security and Content Guard](docs/security.md) · [Handoff promotion](docs/handoff-promotion.md)
 - [Command inventory](docs/command-inventory.md) · [Station contract](docs/station-contract.md)
 - [Maintainers](MAINTAINERS.md) · [Governance](GOVERNANCE.md) · [Security](SECURITY.md) · [Contributing](CONTRIBUTING.md) · [Roadmap](ROADMAP.md)
 

{brigade_cli-0.26.0 → brigade_cli-0.26.1}/README.md

@@ -5,14 +5,15 @@
 <h1 align="center">Brigade</h1>
 
 <p align="center">
-  <strong>Your agents run loops. Brigade keeps the receipts.</strong>
+  <strong>One command to start. One command to keep it maintained.</strong>
 </p>
 
 <p align="center">
   <strong>Built for coding agents to run end to end</strong> (install, setup, verify, handoffs), not as a human day-to-day terminal app.
   When an agent says tests passed, you get a file with the real exit code, a <strong>code graph</strong> of what changed (<code>brigade code</code>), and an <strong>evidence log</strong> you can search later (<code>brigade evidence</code>).
   Optional: one MCP and tools catalog across agents, and shared notes with a review gate.
-  Local files. No daemon. No lock-in.
+  Brigade owns the memory-care primitives and runbooks. An external scheduler (cron, systemd, CI, your agent cron) invokes them. Local files. No daemon. No lock-in.
+  Boundary: <a href="docs/execution-model.md">execution model</a>.
 </p>
 
 <p align="center">
@@ -242,7 +243,7 @@ Beyond the daily loop, the same review-and-receipt pattern covers cross-model ru
 - **Native harness memory** is a per-tool silo. It does not cross harnesses, and it writes without review. Brigade gives every tool one shared format and one canonical owner, with a review gate in between.
 - **Already running Hermes, or any self-improving agent?** Keep it. Brigade is the verification layer on top: it promotes a skill only when a real signal confirms it, keeps every learned skill as portable markdown in your git, and runs one loop across your whole fleet.
 - **A plain CLAUDE.md / AGENTS.md** works great until it bloats past the context budget and goes stale. Brigade keeps bootstrap files slim, moves detail into indexed cards, and flags staleness instead of trusting last month's facts forever.
-- **A daemon or hosted service** would be simpler to demo and worse to trust. Brigade writes local files when you run a command, and that is all it does.
+- **A daemon or hosted service** would be simpler to demo and worse to trust. Brigade writes local files when you run a command, and that is all it does. See the [execution model](docs/execution-model.md).
 
 | | Across harnesses | MCP, tools, and memory in one source | Review gate + receipts | Local files, no daemon |
 |---|:---:|:---:|:---:|:---:|
@@ -253,7 +254,7 @@ Beyond the daily loop, the same review-and-receipt pattern covers cross-model ru
 
 ## What Brigade is not
 
-Brigade is not a hosted memory service, a daemon, or an automatic release bot. It does not run in the background or install schedulers (one scoped exception: `brigade tools runtime start` launches a local runtime process, only when you start it, until you stop it). It does not push to GitHub, publish packages, save every note automatically, or skip review for ambiguous, risky, or failed notes. `brigade work brief` and related status surfaces may report notification readiness or suggest installing the notifications station, but Brigade never sends a message unless the operator uses an explicit send action such as `brigade pantry expiry-alert --send`. That pause is the point: agent memory should be useful, not noisy.
+Brigade is not a hosted memory service, a daemon, or an automatic release bot. It does not run in the background. Scheduling stays with the operator (see the [execution model](docs/execution-model.md)). It does not push to GitHub, publish packages, save every note automatically, or skip review for ambiguous, risky, or failed notes. `brigade work brief` and related status surfaces may report notification readiness or suggest installing the notifications station, but Brigade never sends a message unless the operator uses an explicit send action such as `brigade pantry expiry-alert --send`. That pause is the point: agent memory should be useful, not noisy.
 
 And it is not the other projects that share the name. This Brigade is the AI-agent operator CLI from [`escoffier-labs/brigade`](https://github.com/escoffier-labs/brigade), installed with `pipx install brigade-cli`. It is not the CNCF/Microsoft Brigade for Kubernetes event scripting (archived 2022), the Spinabot Brigade agent crew, or the 2017 `brigade` Python package that became Nornir.
 
@@ -289,7 +290,8 @@ Nineteen harnesses get handoff inboxes and ingest coverage, from Codex, Claude C
 ## Docs
 
 - [First 10 minutes](docs/first-10-minutes.md) · [Overview](docs/overview.md) · [Technical guide](docs/technical-guide.md)
-- [MCP sync](docs/mcp-sync.md) · [Security and Content Guard](docs/security.md) · [Handoff promotion](docs/handoff-promotion.md)
+- [Execution model](docs/execution-model.md) · [Memory care](docs/memory-care.md) · [MCP sync](docs/mcp-sync.md)
+- [Security and Content Guard](docs/security.md) · [Handoff promotion](docs/handoff-promotion.md)
 - [Command inventory](docs/command-inventory.md) · [Station contract](docs/station-contract.md)
 - [Maintainers](MAINTAINERS.md) · [Governance](GOVERNANCE.md) · [Security](SECURITY.md) · [Contributing](CONTRIBUTING.md) · [Roadmap](ROADMAP.md)
 

{brigade_cli-0.26.0 → brigade_cli-0.26.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "brigade-cli"
-version = "0.26.0"
+version = "0.26.1"
 description = "Your agents run loops. Brigade keeps the receipts. Local control plane for multi-agent coding: share MCP/tools/memory, remember via handoffs, prove with file receipts, improve by promoting skills only on real exit codes. Claude Code, Codex, Grok, Hermes, OpenClaw, and more. Stations for evidence, code graph, pantry, skills. pipx install brigade-cli."
 readme = "README.md"
 requires-python = ">=3.10"

{brigade_cli-0.26.0 → brigade_cli-0.26.1}/src/brigade/__init__.py

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

{brigade_cli-0.26.0 → brigade_cli-0.26.1}/src/brigade/aboyeur.py

@@ -44,7 +44,7 @@ from .run_receipts import (
     write_agent_logs as _write_agent_logs,
     write_worker_logs as _write_worker_logs,
 )
-from .run_transport import Assignment, WorkerResult
+from .run_transport import Assignment, WorkerResult, dag_cycle_members
 from .roster import Agent, Roster, is_cli_allowed, read_only_capability_error, timeout_for, workers
 from .route_catalog import RouteBrief, route_brief, uncovered_stages, unknown_covers
 from .route_policy import (
@@ -1329,6 +1329,14 @@ def _unknown_covers(route: RouteBrief | None, assignments: list[Assignment]) ->
     return unknown_covers(route, assignments)
 
 
+def _validate_plan_dependencies(route: RouteBrief | None, assignments: list[Assignment]) -> None:
+    if route is None or not route.attached:
+        return
+    members = dag_cycle_members(assignments, route.dependencies)
+    if members:
+        raise ValueError(f"plan has a dependency cycle involving: {', '.join(members)}")
+
+
 def _orchestrator_hides_write_tools(
     roster: Roster,
     *,
@@ -1394,6 +1402,7 @@ def plan(
         raise RuntimeError(f"orchestrator failed during plan: {first.detail}")
     try:
         assignments = parse_plan(first.text, roster, read_only=read_only, skill_policy=skill_policy)
+        _validate_plan_dependencies(route, assignments)
         _record_plan_attempt(
             attempts,
             stage="initial",
@@ -1433,6 +1442,7 @@ def plan(
             raise RuntimeError(f"orchestrator failed during plan correction: {second.detail}") from exc
         try:
             assignments = parse_plan(second.text, roster, read_only=read_only, skill_policy=skill_policy)
+            _validate_plan_dependencies(route, assignments)
             _record_plan_attempt(
                 attempts,
                 stage="correction",
@@ -1487,6 +1497,7 @@ def plan(
         return assignments
     try:
         revised = parse_plan(revised_result.text, roster, read_only=read_only, skill_policy=skill_policy)
+        _validate_plan_dependencies(route, revised)
     except ValueError as exc:
         _record_plan_attempt(attempts, stage="coverage-correction", result=revised_result, parse_error=str(exc))
         return assignments
@@ -2708,6 +2719,8 @@ def _run_payload(
         payload["run_journal_authority_requested"] = True
     if resolution := _roster_resolution_payload(roster):
         payload["roster"] = resolution
+    if roster.seat_routing:
+        payload["seat_routing"] = [dict(decision) for decision in roster.seat_routing]
     if lock_workspace is not None:
         payload["lock_workspace"] = str(lock_workspace)
     if route is not None:
@@ -3006,6 +3019,7 @@ class OrchestratorHealthRoutingDecision:
     abort_detail: str | None = None
     abort_failure_phase: str = "preflight"
     abort_failure_kind: str = "unclassified"
+    abort_seat: str | None = None
     receipt: dict[str, object] | None = None
 
 
@@ -3030,61 +3044,126 @@ def _seat_health_typed_cause(result: seat_health.SeatHealthResult) -> str:
 def resolve_orchestrator_health_routing(
     roster: Roster,
     results: tuple[seat_health.SeatHealthResult, ...] | None,
+    *,
+    pinned_seats: frozenset[str] = frozenset(),
 ) -> OrchestratorHealthRoutingDecision:
-    """Return the effective roster and any orchestrator fallback or abort action."""
-    orchestrator_result = _seat_health_result_for(results, roster.orchestrator)
-    if orchestrator_result is None or orchestrator_result.status != "unhealthy":
+    """Route unhealthy orchestrator and worker seats to declared fallbacks."""
+    if results is None:
         return OrchestratorHealthRoutingDecision(roster=roster)
 
-    requested = roster.orchestrator
-    typed_cause = _seat_health_typed_cause(orchestrator_result)
-    failure = orchestrator_result.failure
-    rejected: list[dict[str, str]] = []
-
-    for fallback_name in roster.agents[requested].fallback:
-        if fallback_name not in roster.agents:
+    referenced = {name for agent in roster.agents.values() for name in agent.fallback}
+    # Roots are the orchestrator plus seats not referenced as fallbacks by any other role.
+    roots = [name for name in roster.agents if name == roster.orchestrator or name not in referenced]
+    effective_agents = dict(roster.agents)
+    effective_orchestrator = roster.orchestrator
+    decisions: list[dict[str, object]] = []
+    warnings: list[str] = []
+    abort: tuple[str, seat_health.SeatHealthResult, list[dict[str, str]]] | None = None
+
+    for requested in roots:
+        health_result = _seat_health_result_for(results, requested)
+        if health_result is None or health_result.status != "unhealthy":
             continue
-        fallback_result = _seat_health_result_for(results, fallback_name)
-        if fallback_result is not None and fallback_result.status == "healthy":
-            return OrchestratorHealthRoutingDecision(
-                roster=replace(roster, orchestrator=fallback_name),
-                warning=(
+        typed_cause = _seat_health_typed_cause(health_result)
+        rejected: list[dict[str, str]] = []
+        selected: str | None = None
+        for fallback_name in roster.agents[requested].fallback:
+            fallback_result = _seat_health_result_for(results, fallback_name)
+            if fallback_result is not None and fallback_result.status == "healthy":
+                selected = fallback_name
+                break
+            status = fallback_result.status if fallback_result is not None else "missing"
+            cause = _seat_health_typed_cause(fallback_result) if fallback_result is not None else "missing"
+            rejected.append({"seat": fallback_name, "status": status, "cause": cause})
+
+        decision: dict[str, object] = {
+            "requested_seat": requested,
+            "effective_seat": selected,
+            "outcome": "fallback" if selected is not None else "skip",
+            "typed_cause": typed_cause,
+            "rejected_fallbacks": rejected,
+        }
+        decisions.append(decision)
+        if selected is not None:
+            if requested == roster.orchestrator:
+                effective_orchestrator = selected
+                warnings.append(
                     f"warning: orchestrator {requested} is unhealthy [{typed_cause}]; "
-                    f"using declared fallback {fallback_name}"
-                ),
-                receipt={
-                    "schema": "brigade.seat_routing.v1",
-                    "requested_orchestrator": requested,
-                    "effective_orchestrator": fallback_name,
-                    "outcome": "fallback",
-                    "typed_cause": typed_cause,
-                    "rejected_fallbacks": rejected,
-                },
-            )
-        status = fallback_result.status if fallback_result is not None else "missing"
-        cause = _seat_health_typed_cause(fallback_result) if fallback_result is not None else "missing"
-        rejected.append({"seat": fallback_name, "status": status, "cause": cause})
+                    f"using declared fallback {selected}"
+                )
+            else:
+                fallback = roster.agents[selected]
+                requested_agent = roster.agents[requested]
+                effective_agents[requested] = replace(
+                    fallback,
+                    name=requested,
+                    role=requested_agent.role,
+                    purpose=requested_agent.purpose,
+                    fallback=(),
+                )
+                warnings.append(
+                    f"warning: seat {requested} is unhealthy [{typed_cause}]; using declared fallback {selected}"
+                )
+        elif requested == roster.orchestrator or requested in pinned_seats:
+            abort = (requested, health_result, rejected)
+            decision["outcome"] = "abort"
+        else:
+            effective_agents.pop(requested, None)
+            warnings.append(f"warning: skipping unhealthy seat {requested} [{typed_cause}]; no healthy fallback")
+
+    if not decisions:
+        return OrchestratorHealthRoutingDecision(roster=roster)
+
+    effective = replace(
+        roster,
+        agents=effective_agents,
+        orchestrator=effective_orchestrator,
+        seat_routing=tuple(decisions),
+    )
+    receipt: dict[str, object] = {"schema": "brigade.seat_routing.v1", "decisions": decisions}
+    orchestrator_decision = next(
+        (decision for decision in decisions if decision["requested_seat"] == roster.orchestrator), None
+    )
+    if orchestrator_decision is not None:
+        # Preserve the original v1 summary for existing artifact consumers.
+        receipt.update(
+            {
+                "requested_orchestrator": roster.orchestrator,
+                "effective_orchestrator": orchestrator_decision["effective_seat"],
+                "outcome": orchestrator_decision["outcome"],
+                "typed_cause": orchestrator_decision["typed_cause"],
+                "rejected_fallbacks": orchestrator_decision["rejected_fallbacks"],
+            }
+        )
 
+    if abort is None:
+        return OrchestratorHealthRoutingDecision(
+            roster=effective,
+            warning="\n".join(warnings) or None,
+            receipt=receipt,
+        )
+
+    requested, unhealthy_result, rejected = abort
+    typed_cause = _seat_health_typed_cause(unhealthy_result)
     if rejected:
         rejected_detail = "; rejected fallbacks: " + ", ".join(
             f"{entry['seat']} ({entry['status']}[{entry['cause']}])" for entry in rejected
         )
     else:
         rejected_detail = "; no declared fallbacks"
-    detail = f"orchestrator {requested} is unhealthy [{typed_cause}]{rejected_detail}"
+    if requested == roster.orchestrator:
+        detail = f"orchestrator {requested} is unhealthy [{typed_cause}]{rejected_detail}"
+    else:
+        detail = f"seat {requested} is unhealthy [{typed_cause}]{rejected_detail}"
+    failure = unhealthy_result.failure
     return OrchestratorHealthRoutingDecision(
-        roster=roster,
+        roster=effective,
+        warning="\n".join(warnings) or None,
         abort_detail=detail,
         abort_failure_phase=failure.phase.value if failure is not None else "preflight",
         abort_failure_kind=failure.failure_class.value if failure is not None else "unclassified",
-        receipt={
-            "schema": "brigade.seat_routing.v1",
-            "requested_orchestrator": requested,
-            "effective_orchestrator": None,
-            "outcome": "abort",
-            "typed_cause": typed_cause,
-            "rejected_fallbacks": rejected,
-        },
+        abort_seat=requested,
+        receipt=receipt,
     )
 
 
@@ -3286,6 +3365,29 @@ def run(
         print(f"error: {detail}", file=sys.stderr)
         return 2
 
+    def _run_isolation_check() -> str | None:
+        """Detect canonical-checkout escapes after dispatch without per-worker attribution."""
+
+        if lock_workspace == cwd or drift_snapshot is None:
+            return None
+        # Preserve the existing branch/HEAD drift classification. Working-tree
+        # mutations are what this post-dispatch check adds; committed or
+        # branch-moving interference remains caught by the run-level drift
+        # checkpoints.
+        if runguard.detect_branch_head_drift(lock_workspace, drift_snapshot) is not None:
+            return None
+        try:
+            changed, untracked = runguard.changes_relative_to_snapshot(lock_workspace, drift_snapshot)
+        except runguard.RunGuardError as exc:
+            return f"isolation breach: could not verify canonical checkout: {exc}"
+        escaped = sorted(set(changed + untracked))
+        if not escaped:
+            return None
+        shown = ", ".join(escaped[:10])
+        if len(escaped) > 10:
+            shown += f", and {len(escaped) - 10} more"
+        return f"isolation breach: modified files outside assigned worktree: {shown}"
+
     if worker is not None:
         worker_error = _direct_worker_error(worker, roster, read_only=read_only)
         if worker_error is not None:
@@ -3368,7 +3470,11 @@ def run(
         )
         # After the initial run receipt, before planning: a probe failure stays receipted.
         health_results = _write_run_seat_health_receipt(output_dir, roster, cwd=cwd)
-        routing = resolve_orchestrator_health_routing(roster, health_results)
+        routing = resolve_orchestrator_health_routing(
+            roster,
+            health_results,
+            pinned_seats=frozenset({worker}) if worker is not None else frozenset(),
+        )
         roster = routing.roster
         if routing.warning is not None:
             print(routing.warning, file=sys.stderr)
@@ -3377,13 +3483,24 @@ def run(
             routing_receipt["run_id"] = output_dir.name
             _write_seat_routing_receipt(output_dir, routing_receipt)
         if routing.abort_detail is not None:
+            if roster.seat_routing:
+                run_path = output_dir / "run.json"
+                try:
+                    run_payload = json.loads(run_path.read_text())
+                except (OSError, json.JSONDecodeError) as exc:
+                    raise runguard.RetainRunLockError(
+                        f"failed to read run receipt before seat-routing abort: {exc}"
+                    ) from exc
+                if isinstance(run_payload, dict):
+                    run_payload["seat_routing"] = [dict(decision) for decision in roster.seat_routing]
+                    _write_json(run_path, receipt_schema.stamp_run_receipt(run_payload))
             record_run_termination(
                 output_dir,
                 status="failed",
                 failure_phase=routing.abort_failure_phase,
                 failure_kind=routing.abort_failure_kind,
                 detail=routing.abort_detail,
-                seat=roster.orchestrator,
+                seat=routing.abort_seat or roster.orchestrator,
             )
             print(f"error: {routing.abort_detail}", file=sys.stderr)
             return 2
@@ -3891,6 +4008,19 @@ def run(
                 ground_truth=ground_truth,
             ),
         )
+    isolation_detail = _run_isolation_check()
+    if isolation_detail is not None:
+        if output_dir is not None:
+            record_run_termination(
+                output_dir,
+                status="failed",
+                failure_phase="run-isolation",
+                failure_kind="isolation-breach",
+                detail=isolation_detail,
+                seat=roster.orchestrator,
+            )
+        print(f"error: {isolation_detail}", file=sys.stderr)
+        return 2
     if verbose:
         _print_worker_status(worker_results)
         if not direct_worker:

{brigade_cli-0.26.0 → brigade_cli-0.26.1}/src/brigade/agent_skill_format.py

@@ -31,6 +31,39 @@ def _scalar(value: str) -> str:
     return value
 
 
+def _split_allowed_tools(allowed: str) -> tuple[str, ...]:
+    """Split comma/whitespace tool lists while preserving parenthesized scopes.
+
+    Claude-style entries such as ``Bash(brigade handoff list:*)`` must stay one
+    token. A naive ``re.split(r"[\\s,]+")`` shreds them into nonsense.
+    """
+    items: list[str] = []
+    buf: list[str] = []
+    depth = 0
+    for ch in allowed:
+        if ch == "(":
+            depth += 1
+            buf.append(ch)
+            continue
+        if ch == ")":
+            depth = max(0, depth - 1)
+            buf.append(ch)
+            continue
+        if ch in ", \t\r\n" and depth == 0:
+            if buf:
+                item = "".join(buf).strip()
+                if item:
+                    items.append(item)
+                buf = []
+            continue
+        buf.append(ch)
+    if buf:
+        item = "".join(buf).strip()
+        if item:
+            items.append(item)
+    return tuple(items)
+
+
 def _frontmatter(text: str) -> tuple[list[str] | None, str | None]:
     lines = text.splitlines()
     if not lines or lines[0] != "---":
@@ -48,7 +81,7 @@ def validate(skill_dir: Path, *, mode: str) -> Validation:
     path = skill_dir / "SKILL.md"
     if not path.is_file():
         return Validation({}, (f"SKILL.md not found: {path}",), ())
-    lines, framing_error = _frontmatter(path.read_text(errors="replace"))
+    lines, framing_error = _frontmatter(path.read_text(encoding="utf-8", errors="replace"))
     if lines is None:
         if mode == "lenient":
             return Validation({}, (), (framing_error or "invalid frontmatter",))
@@ -121,7 +154,7 @@ def validate(skill_dir: Path, *, mode: str) -> Validation:
         (errors if mode == "strict" else diagnostics).append(message)
     allowed = fields.get("allowed-tools")
     if isinstance(allowed, str):
-        fields["allowed-tools"] = tuple(item for item in re.split(r"[\s,]+", allowed) if item)
+        fields["allowed-tools"] = _split_allowed_tools(allowed)
     elif allowed is not None:
         errors.append("frontmatter allowed-tools must be a string declaration")
     fields.update(unknown)

{brigade_cli-0.26.0 → brigade_cli-0.26.1}/src/brigade/center_cmd/__init__.py

@@ -15,6 +15,7 @@ _MODULE_NAMES = (
     "reports",
     "report_review",
     "actions",
+    "serve",
 )
 _MODULE_ALIASES = {
     "schema": "schema_ops",
@@ -89,6 +90,7 @@ _module_readiness = importlib.import_module(f"{__name__}.readiness")
 _module_reports = importlib.import_module(f"{__name__}.reports")
 _module_report_review = _facade_module("report_review")
 _module_actions = importlib.import_module(f"{__name__}.actions")
+_module_serve = importlib.import_module(f"{__name__}.serve")
 
 from .schema_ops import *
 from .core import *
@@ -96,6 +98,7 @@ from .readiness import *
 from .reports import *
 from .report_review_ops import *
 from .actions import *
+from .serve import *
 
 _MODULES = (
     _module_schema,
@@ -104,6 +107,7 @@ _MODULES = (
     _module_reports,
     _module_report_review,
     _module_actions,
+    _module_serve,
 )
 
 

{brigade_cli-0.26.0 → brigade_cli-0.26.1}/src/brigade/center_cmd/actions.py

@@ -376,7 +376,7 @@ def actions_build(
     review_status = _report_review_status(report)
     if review_status not in {"reviewed", "deferred"} and not allow_unreviewed:
         print(
-            "error: source report must be closed out as reviewed or deferred, or pass --allow-unreviewed",
+            "error: source report must be closed out as reviewed or deferred before building actions",
             file=sys.stderr,
         )
         return 2