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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: brigade-cli
-Version: 0.11.0
+Version: 0.12.0
 Summary: AI agent memory, handoffs, and local guardrails for Codex, Claude Code, OpenCode, Hermes, and OpenClaw.
 Author-email: Solomon Neas <me@solomonneas.dev>
 License: MIT
@@ -63,30 +63,31 @@ I run an always-on OpenClaw agent next to daily Codex and Claude Code sessions,
 
 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;
@@ -156,7 +157,7 @@ Each writer gets its own local inbox; one canonical owner ingests. Brigade keeps
 | 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
 

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

@@ -33,30 +33,31 @@ I run an always-on OpenClaw agent next to daily Codex and Claude Code sessions,
 
 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;
@@ -126,7 +127,7 @@ Each writer gets its own local inbox; one canonical owner ingests. Brigade keeps
 | 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
 

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "brigade-cli"
-version = "0.11.0"
+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"

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

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

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

@@ -133,6 +133,40 @@ _ADAPTERS: dict[str, Callable[[str, bool, str | None], List[str]]] = {
 }
 
 
+# How strongly each adapter enforces a read-only run:
+#   hard - a native sandbox or tool allowlist the model cannot escape
+#   soft - read-only is only a prompt instruction the model may ignore
+#   none - read_only is not applied to this CLI at all
+# Brigade is "loud about exceptions", so `brigade run --read-only` warns when an
+# assigned harness is soft or none rather than implying a guarantee it cannot make.
+READ_ONLY_ENFORCEMENT: dict[str, str] = {
+    "codex": "hard",
+    "antigravity": "hard",
+    "pi": "hard",
+    "cursor": "hard",
+    "aider": "hard",
+    "continue": "hard",
+    "qwen": "hard",
+    "kimi": "hard",
+    "goose": "soft",
+    "copilot": "soft",
+    "adal": "soft",
+    "openhands": "soft",
+    "grok": "soft",
+    "amp": "soft",
+    "crush": "soft",
+    "claude": "none",
+    "opencode": "none",
+}
+
+
+def read_only_enforcement(cli_ref: str) -> str:
+    """Return how strongly cli_ref enforces read-only: 'hard', 'soft', or 'none'."""
+    if cli_ref.startswith(_OLLAMA_PREFIX):
+        return "none"
+    return READ_ONLY_ENFORCEMENT.get(cli_ref, "none")
+
+
 @dataclass(frozen=True)
 class AgentResult:
     text: str

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

@@ -60,6 +60,7 @@ from . import (
     openclaw_fragments as _openclaw_fragments_group,
     hermes_fragments as _hermes_fragments_group,
     reconfigure as _reconfigure_group,
+    completions as _completions_group,
 )
 
 
@@ -115,6 +116,7 @@ def _build_parser() -> argparse.ArgumentParser:
     _openclaw_fragments_group.register(sub)
     _hermes_fragments_group.register(sub)
     _reconfigure_group.register(sub)
+    _completions_group.register(sub)
 
     parser.epilog = _grouped_epilog(sub)
     return parser

{brigade_cli-0.11.0 → brigade_cli-0.12.0}/src/brigade/cli/_common.py

@@ -19,7 +19,10 @@ COMMAND_GROUPS: list[tuple[str, list[str]]] = [
         "Review, security, and research",
         ["security", "scrub", "untrusted", "research", "learn", "chat", "context", "projects"],
     ),
-    ("Wiring and advanced", ["release", "roadmap", "repos", "reconfigure", "openclaw-fragments", "hermes-fragments"]),
+    (
+        "Wiring and advanced",
+        ["release", "roadmap", "repos", "reconfigure", "completions", "openclaw-fragments", "hermes-fragments"],
+    ),
 ]
 
 _START_HERE = """Brigade: run your agent brigade. Operator-system CLI for agent workspaces.

brigade_cli-0.12.0/src/brigade/cli/completions.py

@@ -0,0 +1,17 @@
+"""brigade completions command group."""
+
+from __future__ import annotations
+
+import argparse
+
+
+def register(sub: argparse._SubParsersAction) -> None:
+    p = sub.add_parser("completions", help="Print a shell completion script (bash, zsh, or fish).")
+    p.add_argument("shell", choices=["bash", "zsh", "fish"], help="Shell to generate completions for.")
+    p.set_defaults(func=dispatch)
+
+
+def dispatch(args) -> int:
+    from .. import completions as completions_mod
+
+    return completions_mod.emit(shell=args.shell)

{brigade_cli-0.11.0 → brigade_cli-0.12.0}/src/brigade/cli/doctor.py

@@ -15,10 +15,11 @@ def register(sub: argparse._SubParsersAction) -> None:
         choices=["generic", "openclaw", "hermes"],
         default="generic",
     )
+    p_doctor.add_argument("--json", action="store_true", help="Emit machine-readable JSON instead of text.")
     p_doctor.set_defaults(func=dispatch)
 
 
 def dispatch(args) -> int:
     from .. import doctor as doctor_mod
 
-    return doctor_mod.run(target=args.target, harness=args.harness)
+    return doctor_mod.run(target=args.target, harness=args.harness, json_output=args.json)

{brigade_cli-0.11.0 → brigade_cli-0.12.0}/src/brigade/cli/friction.py

@@ -51,6 +51,14 @@ def register(sub: argparse._SubParsersAction) -> None:
     p_friction_add.add_argument("--json", action="store_true", help="Print machine-readable JSON.")
     p_friction_add.set_defaults(func=dispatch)
 
+    p_friction_show = friction_sub.add_parser("show", help="Show the latest friction scan results.")
+    p_friction_show.add_argument("--target", "-t", type=Path, default=Path("."), help="Repo or workspace to inspect.")
+    p_friction_show.add_argument(
+        "--severity", choices=["low", "medium", "high"], default=None, help="Only show this severity."
+    )
+    p_friction_show.add_argument("--json", action="store_true", help="Print machine-readable JSON.")
+    p_friction_show.set_defaults(func=dispatch)
+
 
 def dispatch(args) -> int:
     from .. import friction_cmd
@@ -68,6 +76,8 @@ def dispatch(args) -> int:
             dry_run=args.dry_run,
             json_output=args.json,
         )
+    if args.friction_command == "show":
+        return friction_cmd.show(target=args.target, severity=args.severity, json_output=args.json)
     if args.friction_command == "add":
         return friction_cmd.add(
             target=args.target,

{brigade_cli-0.11.0 → brigade_cli-0.12.0}/src/brigade/cli/init.py

@@ -24,6 +24,12 @@ def register(sub: argparse._SubParsersAction) -> None:
         default=True,
         help="Do not create or update the target's .gitignore.",
     )
+    p_init.add_argument(
+        "--git-exclude",
+        action="store_true",
+        help="Write Brigade ignores to .git/info/exclude (local-only) instead of the tracked .gitignore. "
+        "Use this in a third-party clone you do not want to commit Brigade ignores into.",
+    )
     p_init.add_argument("--dry-run", action="store_true", help="Show what would happen.")
     p_init.add_argument(
         "--depth",
@@ -81,6 +87,8 @@ def dispatch(args) -> int:
             force=getattr(args, "force", False),
             dry_run=getattr(args, "dry_run", False),
             allow_home=getattr(args, "allow_home", False),
+            use_git_exclude=getattr(args, "git_exclude", False),
+            update_gitignore=getattr(args, "update_gitignore", True),
         )
 
     # No selection flags: interactive prompt.
@@ -99,4 +107,6 @@ def dispatch(args) -> int:
         force=getattr(args, "force", False),
         dry_run=getattr(args, "dry_run", False),
         allow_home=getattr(args, "allow_home", False),
+        use_git_exclude=getattr(args, "git_exclude", False),
+        update_gitignore=getattr(args, "update_gitignore", True),
     )

{brigade_cli-0.11.0 → brigade_cli-0.12.0}/src/brigade/cli/memory.py

@@ -67,6 +67,21 @@ def register(sub: argparse._SubParsersAction) -> None:
         "--defer", action="store_true", help="Mark current queue deferred instead of reviewed."
     )
     p_memory_care_closeout.add_argument("--json", action="store_true", help="Print machine-readable JSON.")
+    p_memory_search = memory_sub.add_parser("search", help="Keyword-search local memory cards.")
+    p_memory_search.add_argument("query", help="Search terms (matched against title, tags, summary, and body).")
+    p_memory_search.add_argument("--target", "-t", type=Path, default=Path("."), help="Repo or workspace to search.")
+    p_memory_search.add_argument("--limit", type=int, default=20, help="Maximum matches to show.")
+    p_memory_search.add_argument("--json", action="store_true", help="Print machine-readable JSON.")
+    p_memory_serve_mcp = memory_sub.add_parser(
+        "serve-mcp", help="Expose memory cards over a read-only MCP stdio server (card:// scheme)."
+    )
+    p_memory_serve_mcp.add_argument(
+        "--target", "-t", type=Path, default=Path("."), help="Repo or workspace whose cards to serve."
+    )
+    p_memory_serve_mcp.add_argument(
+        "--stdio", action="store_true", help="Run the JSON-RPC stdio server (otherwise print the contract)."
+    )
+    p_memory_serve_mcp.add_argument("--json", action="store_true", help="Print the contract as JSON.")
     p_memory.set_defaults(func=dispatch)
 
 
@@ -105,5 +120,9 @@ def dispatch(args) -> int:
             )
         args._brigade_parser.error(f"unknown memory care command: {args.memory_care_command}")
         return 2
+    if args.memory_command == "search":
+        return memory_cmd.search(target=args.target, query=args.query, limit=args.limit, json_output=args.json)
+    if args.memory_command == "serve-mcp":
+        return memory_cmd.serve_mcp(target=args.target, stdio=args.stdio, json_output=args.json)
     args._brigade_parser.error(f"unknown memory command: {args.memory_command}")
     return 2

{brigade_cli-0.11.0 → brigade_cli-0.12.0}/src/brigade/cli/operator.py

@@ -213,6 +213,19 @@ def register(sub: argparse._SubParsersAction) -> None:
         help="Operator profile to inspect.",
     )
     p_operator_doctor.add_argument("--json", action="store_true", help="Print machine-readable JSON.")
+    p_operator_checkup = operator_sub.add_parser(
+        "checkup", help="Run every read-only first-run doctor at once and roll up the verdict."
+    )
+    p_operator_checkup.add_argument(
+        "--target", "-t", type=Path, default=Path("."), help="Repo or workspace to inspect."
+    )
+    p_operator_checkup.add_argument(
+        "--profile",
+        choices=["local-operator", "internal-dogfood"],
+        default="internal-dogfood",
+        help="Operator profile to inspect.",
+    )
+    p_operator_checkup.add_argument("--json", action="store_true", help="Print machine-readable JSON.")
     p_operator_verify_harness = operator_sub.add_parser(
         "verify-harness", help="Verify repo-local wiring for one harness."
     )
@@ -373,6 +386,8 @@ def dispatch(args) -> int:
         return operator_cmd.status(target=args.target, profile=args.profile, json_output=args.json)
     if args.operator_command == "doctor":
         return operator_cmd.doctor(target=args.target, profile=args.profile, json_output=args.json)
+    if args.operator_command == "checkup":
+        return operator_cmd.checkup(target=args.target, profile=args.profile, json_output=args.json)
     if args.operator_command == "verify-harness":
         return operator_cmd.verify_harness(target=args.target, harness=args.harness, json_output=args.json)
     if args.operator_command == "sync-tools":

{brigade_cli-0.11.0 → brigade_cli-0.12.0}/src/brigade/cli/projects.py

@@ -16,6 +16,9 @@ def register(sub: argparse._SubParsersAction) -> None:
     p_projects_audit = projects_sub.add_parser("audit", help="Audit configured project consolidation records.")
     p_projects_audit.add_argument("--target", "-t", type=Path, default=Path("."), help="Repo or workspace to inspect.")
     p_projects_audit.add_argument("--json", action="store_true", help="Print machine-readable JSON.")
+    p_projects_doctor = projects_sub.add_parser("doctor", help="Check local project consolidation health.")
+    p_projects_doctor.add_argument("--target", "-t", type=Path, default=Path("."), help="Repo or workspace to inspect.")
+    p_projects_doctor.add_argument("--json", action="store_true", help="Print machine-readable JSON.")
     p_projects_import = projects_sub.add_parser(
         "import-issues", help="Import project consolidation issues into the work inbox."
     )
@@ -91,6 +94,8 @@ def dispatch(args) -> int:
 
     if args.projects_command == "audit":
         return projects_cmd.audit(target=args.target, json_output=args.json)
+    if args.projects_command == "doctor":
+        return projects_cmd.doctor(target=args.target, json_output=args.json)
     if args.projects_command == "import-issues":
         return projects_cmd.import_issues(target=args.target, dry_run=args.dry_run, json_output=args.json)
     if args.projects_command == "closeout":

{brigade_cli-0.11.0 → brigade_cli-0.12.0}/src/brigade/cli/repos.py

@@ -31,6 +31,11 @@ def register(sub: argparse._SubParsersAction) -> None:
     p_repos_doctor = repos_sub.add_parser("doctor", help="Report repo fleet health.")
     p_repos_doctor.add_argument("--target", "-t", type=Path, default=Path("."), help="Repo or workspace to inspect.")
     p_repos_doctor.add_argument("--json", action="store_true", help="Print machine-readable JSON.")
+    p_repos_doctor.add_argument(
+        "--deep",
+        action="store_true",
+        help="Run the operator checkup (every first-run doctor) in each enabled repo and aggregate.",
+    )
     p_repos_import = repos_sub.add_parser("import-issues", help="Import repo fleet health issues into the work inbox.")
     p_repos_import.add_argument("--target", "-t", type=Path, default=Path("."), help="Repo or workspace to inspect.")
     p_repos_import.add_argument("--dry-run", action="store_true", help="Show counts without writing imports.")
@@ -562,7 +567,7 @@ def dispatch(args) -> int:
     if args.repos_command == "scan":
         return repos_cmd.scan(target=args.target, json_output=args.json)
     if args.repos_command == "doctor":
-        return repos_cmd.doctor(target=args.target, json_output=args.json)
+        return repos_cmd.doctor(target=args.target, json_output=args.json, deep=args.deep)
     if args.repos_command == "import-issues":
         return repos_cmd.import_issues(target=args.target, dry_run=args.dry_run, json_output=args.json)
     if args.repos_command == "first-run":

{brigade_cli-0.11.0 → brigade_cli-0.12.0}/src/brigade/cli/run.py

@@ -135,6 +135,23 @@ def dispatch(args) -> int:
     if args.handoff:
         handoff_inbox = args.handoff_inbox or (run_cwd / ".claude" / "memory-handoffs")
     effective_sandbox = args.sandbox if args.sandbox is not None else loaded_roster.sandbox
+    if args.read_only:
+        advisory = _read_only_advisory(loaded_roster, effective_sandbox)
+        if advisory:
+            print("warning: --read-only is best-effort for some agents in this run:", file=sys.stderr)
+            for line in advisory:
+                print(f"  - {line}", file=sys.stderr)
+            print(
+                "  brigade cannot guarantee these agents leave the tree untouched; review the run output.",
+                file=sys.stderr,
+            )
+            if output_dir is not None:
+                from .. import localio
+
+                localio.write_json(
+                    output_dir / "read-only-enforcement.json",
+                    {"read_only": True, "sandbox": effective_sandbox, "best_effort_agents": advisory},
+                )
     # The dirty guard protects write runs from mixing agent edits with uncommitted
     # work. Dry, read-only, and worktree runs never edit the tree, so reviewing
     # uncommitted changes stays possible without --allow-dirty.
@@ -193,3 +210,29 @@ def dispatch(args) -> int:
 def _worktree_checkout_path(repo_root: Path, output_dir: Path) -> Path:
     run_id = output_dir.expanduser().resolve().name
     return Path.home() / ".cache" / "brigade" / "worktrees" / f"{repo_root.name}-{run_id}"
+
+
+def _read_only_advisory(roster, effective_sandbox) -> list[str]:
+    """Lines describing which worker agents do not hard-enforce read-only.
+
+    A writable --sandbox override downgrades even natively-sandboxed CLIs to
+    prompt-only, so the advisory reflects the sandbox actually in effect.
+    """
+    from .. import agents as agents_mod
+    from .. import roster as roster_mod
+
+    sandbox_overrides_native = effective_sandbox in ("workspace-write", "danger-full-access")
+    lines: list[str] = []
+    # The orchestrator runs too (it plans), so include it alongside the workers.
+    orchestrator = roster.agents.get(roster.orchestrator)
+    agents_to_check = [orchestrator, *roster_mod.workers(roster)] if orchestrator else roster_mod.workers(roster)
+    for agent in agents_to_check:
+        cli = agent.cli or ""
+        enforcement = agents_mod.read_only_enforcement(cli)
+        if sandbox_overrides_native and enforcement == "hard":
+            enforcement = "soft"
+        if enforcement == "hard":
+            continue
+        how = "prompt-only (the model may ignore it)" if enforcement == "soft" else "not applied for this CLI"
+        lines.append(f"{agent.name} ({cli or 'unknown'}): read-only is {how}")
+    return lines

{brigade_cli-0.11.0 → brigade_cli-0.12.0}/src/brigade/cli/runbook.py

@@ -37,6 +37,15 @@ def register(sub: argparse._SubParsersAction) -> None:
         "--status", choices=["reviewed", "deferred", "blocked", "archived"], default="reviewed"
     )
     p_runbook_closeout.add_argument("--reason", default=None, help="Closeout reason.")
+    p_runbook_closeout.add_argument(
+        "--import-issues",
+        dest="import_issues",
+        action="store_true",
+        help="Route each failed step into the work import inbox for review.",
+    )
+    p_runbook_closeout.add_argument(
+        "--dry-run", action="store_true", help="With --import-issues, report records without writing imports."
+    )
     p_runbook_closeout.add_argument("--json", action="store_true", help="Print machine-readable JSON.")
     p_runbook.set_defaults(func=dispatch)
 
@@ -69,7 +78,13 @@ def dispatch(args) -> int:
         return runbook_cmd.resume(target=args.target, run_id=args.run_id, json_output=args.json)
     if args.runbook_command == "closeout":
         return runbook_cmd.closeout(
-            target=args.target, run_id=args.run_id, status=args.status, reason=args.reason, json_output=args.json
+            target=args.target,
+            run_id=args.run_id,
+            status=args.status,
+            reason=args.reason,
+            import_issues=args.import_issues,
+            dry_run=args.dry_run,
+            json_output=args.json,
         )
     args._brigade_parser.error(f"unknown runbook command: {args.runbook_command}")
     return 2

{brigade_cli-0.11.0 → brigade_cli-0.12.0}/src/brigade/cli/scrub.py

@@ -16,10 +16,20 @@ def register(sub: argparse._SubParsersAction) -> None:
         help="Policy file name (looks under .brigade/policies, then content-guard/policies) or path.",
     )
     p_scrub.add_argument("--dry-run", action="store_true")
+    p_scrub.add_argument("--json", action="store_true", help="Print a machine-readable summary (no matched snippets).")
+    p_scrub.add_argument(
+        "--no-receipt", action="store_true", help="Do not write the .brigade/scrub/latest.json receipt."
+    )
     p_scrub.set_defaults(func=dispatch)
 
 
 def dispatch(args) -> int:
     from .. import scrub as scrub_mod
 
-    return scrub_mod.run(target=args.target, policy=args.policy, dry_run=args.dry_run)
+    return scrub_mod.run(
+        target=args.target,
+        policy=args.policy,
+        dry_run=args.dry_run,
+        json_output=args.json,
+        write_receipt=not args.no_receipt,
+    )

{brigade_cli-0.11.0 → brigade_cli-0.12.0}/src/brigade/cli/security.py

@@ -42,6 +42,23 @@ def register(sub: argparse._SubParsersAction) -> None:
         "--output-dir", type=Path, default=None, help="Security evidence bundle directory."
     )
     p_security_findings.add_argument("--json", action="store_true", help="Print machine-readable JSON.")
+    p_security_diff = security_sub.add_parser(
+        "diff", help="Compare two security reports (new/resolved/persisting findings)."
+    )
+    p_security_diff.add_argument(
+        "--target", "-t", type=Path, default=Path("."), help="Repo or workspace for config and the default --against."
+    )
+    p_security_diff.add_argument(
+        "--base", dest="base_dir", type=Path, required=True, help="Baseline security evidence bundle directory."
+    )
+    p_security_diff.add_argument(
+        "--against",
+        dest="against_dir",
+        type=Path,
+        default=None,
+        help="Bundle to compare against. Defaults to .brigade/security/latest.",
+    )
+    p_security_diff.add_argument("--json", action="store_true", help="Print machine-readable JSON.")
     p_security_sarif = security_sub.add_parser("sarif", help="Write SARIF for an existing security report.")
     p_security_sarif.add_argument("--target", "-t", type=Path, default=Path("."), help="Repo or workspace to review.")
     p_security_sarif.add_argument("--output-dir", type=Path, default=None, help="Security evidence bundle directory.")
@@ -82,11 +99,13 @@ def register(sub: argparse._SubParsersAction) -> None:
         "--target", "-t", type=Path, default=Path("."), help="Repo or workspace to update."
     )
     p_security_suppress.add_argument("--reason", required=True, help="Required suppression reason.")
+    p_security_suppress.add_argument("--json", action="store_true", help="Print machine-readable JSON.")
     p_security_unsuppress = security_sub.add_parser("unsuppress", help="Remove a security finding suppression.")
     p_security_unsuppress.add_argument("fingerprint", help="Finding id, id prefix, or fingerprint to unsuppress.")
     p_security_unsuppress.add_argument(
         "--target", "-t", type=Path, default=Path("."), help="Repo or workspace to update."
     )
+    p_security_unsuppress.add_argument("--json", action="store_true", help="Print machine-readable JSON.")
     p_security_closeout = security_sub.add_parser("closeout", help="Write local security review closeout metadata.")
     p_security_closeout.add_argument(
         "--target", "-t", type=Path, default=Path("."), help="Repo or workspace to update."
@@ -158,6 +177,13 @@ def dispatch(args) -> int:
         return security_cmd.review(target=args.target, output_dir=args.output_dir, json_output=args.json)
     if args.security_command == "findings":
         return security_cmd.findings(target=args.target, output_dir=args.output_dir, json_output=args.json)
+    if args.security_command == "diff":
+        return security_cmd.diff(
+            target=args.target,
+            base_dir=args.base_dir,
+            against_dir=args.against_dir,
+            json_output=args.json,
+        )
     if args.security_command == "sarif":
         return security_cmd.sarif(
             target=args.target, output_dir=args.output_dir, output_path=args.output_path, json_output=args.json
@@ -178,9 +204,11 @@ def dispatch(args) -> int:
             json_output=args.json,
         )
     if args.security_command == "suppress":
-        return security_cmd.suppress(target=args.target, fingerprint=args.fingerprint, reason=args.reason)
+        return security_cmd.suppress(
+            target=args.target, fingerprint=args.fingerprint, reason=args.reason, json_output=args.json
+        )
     if args.security_command == "unsuppress":
-        return security_cmd.unsuppress(target=args.target, fingerprint=args.fingerprint)
+        return security_cmd.unsuppress(target=args.target, fingerprint=args.fingerprint, json_output=args.json)
     if args.security_command == "closeout":
         return security_cmd.closeout(
             target=args.target,

{brigade_cli-0.11.0 → brigade_cli-0.12.0}/src/brigade/cli/skills.py

@@ -59,6 +59,11 @@ def register(sub: argparse._SubParsersAction) -> None:
     p_skills_diff.add_argument("--target", "-t", type=Path, default=Path("."), help="Workspace registry to inspect.")
     p_skills_diff.add_argument("--harness", required=True, help="Harness target to compare.")
     p_skills_diff.add_argument("--json", action="store_true", help="Print machine-readable JSON.")
+    p_skills_uninstall = skills_sub.add_parser("uninstall", help="Remove an installed skill from one or all harnesses.")
+    p_skills_uninstall.add_argument("skill", help="Installed skill id.")
+    p_skills_uninstall.add_argument("--workspace", type=Path, default=Path("."), help="Workspace to update.")
+    p_skills_uninstall.add_argument("--target", dest="install_target", required=True, help="Harness target or all.")
+    p_skills_uninstall.add_argument("--json", action="store_true", help="Print machine-readable JSON.")
     p_skills_rollback = skills_sub.add_parser(
         "rollback", help="Rollback one installed skill target to the latest snapshot."
     )
@@ -194,6 +199,13 @@ def dispatch(args) -> int:
             force=args.force,
             json_output=args.json,
         )
+    if args.skills_command == "uninstall":
+        return skills_cmd.uninstall(
+            workspace=args.workspace,
+            skill=args.skill,
+            harness=args.install_target,
+            json_output=args.json,
+        )
     if args.skills_command == "compatibility":
         return skills_cmd.compatibility(target=args.target, skill=args.skill, json_output=args.json)
     if args.skills_command == "history":

{brigade_cli-0.11.0 → brigade_cli-0.12.0}/src/brigade/cli/status.py

@@ -10,10 +10,11 @@ def register(sub: argparse._SubParsersAction) -> None:
     # status
     p_status = sub.add_parser("status", help="Show which stations are present and healthy.")
     p_status.add_argument("--target", "-t", type=Path, default=Path("."))
+    p_status.add_argument("--json", action="store_true", help="Emit machine-readable JSON instead of text.")
     p_status.set_defaults(func=dispatch)
 
 
 def dispatch(args) -> int:
     from .. import status as status_mod
 
-    return status_mod.run(target=args.target)
+    return status_mod.run(target=args.target, json_output=args.json)