Merge pull request #12 from escoffier-labs/feat/brigade-dogfood-status

feat: report brigade dogfood status

Author: solomonneas

CHANGELOG.md

@@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `brigade roster init` and `brigade roster doctor` to scaffold a Codex/Ollama starter roster and validate roster syntax plus installed CLI availability.
 - `brigade dogfood` for a built-in Codex-only, prompt-level read-only, inspected run with artifacts and optional handoff.
 - `brigade dogfood init` to persist machine-local dogfood defaults in gitignored `.brigade/dogfood.toml`, enabling a one-command daily `brigade dogfood` path.
+- `brigade dogfood status` to report local dogfood readiness, effective paths, CLI availability, ignore coverage, sandbox mode, and latest run.
 - `brigade run --show-plan` and `--verbose` visibility modes, plus defensive runtime enforcement of roster `allow_models`.
 - `brigade run --inspect` to print a readable artifact summary immediately after a run completes.
 - `brigade run --cwd`, `--output-dir`, and default `.brigade/runs/<id>` artifacts for dogfooding auditable runs.

README.md

@@ -130,13 +130,14 @@ brigade run "review this repo" --handoff
 brigade run "review this repo" --read-only
 brigade run "review this repo" --read-only --inspect
 brigade dogfood init --target /path/to/repo
+brigade dogfood status
 brigade dogfood
 brigade dogfood --target /path/to/repo
 ```
 
 `--dry-run` prints the planned assignments as JSON and stops before worker dispatch. `--show-plan` prints assignments before a normal run. `--verbose` prints the plan, worker statuses, and synthesis status. `--cwd` sets the working directory for the agent CLI calls and defaults to the current directory. `--handoff` writes a Memory Handoff for a successful non-dry run. `--inspect` prints the same readable artifact summary as `brigade runs show` after the run completes. `--read-only` tells the orchestrator and workers to inspect and recommend only, without modifying files or external state. For `codex` agents, Brigade also passes `codex exec --sandbox read-only`; other adapters receive the prompt policy only. The `cli` values are adapters for installed command-line tools: `codex`, `claude`, and `ollama:<model>`. Pick the ones you already use. Brigade shells out to those tools and keeps no provider keys. `brigade roster doctor` validates the roster syntax and reports which CLIs are present on `PATH`.
 
-`brigade dogfood` is the shortcut for using Brigade on itself or another trusted repo. It uses a built-in Codex-only roster, runs with prompt-level read-only instructions, shows the plan, writes normal run artifacts, writes a Memory Handoff by default, and prints the artifact summary afterward. Run `brigade dogfood init --target /path/to/repo` once to write local defaults to `.brigade/dogfood.toml`; that file is gitignored because it captures machine-local paths and preferences. After that, `brigade dogfood` from the repo is the one-command daily path, and `brigade dogfood "review today's changes"` overrides only the task. Dogfood defaults to a 600 second per-agent timeout because full repo review can exceed short smoke-test limits. By default it passes Codex's `danger-full-access` sandbox setting for trusted-workspace use so repo inspection works on hosts where native read-only sandboxing blocks shell inspection. Use `--no-handoff` or `--no-inspect` to turn off those last two steps. Use `--native-read-only-sandbox` when the host supports Codex's native read-only sandbox and you want that additional enforcement.
+`brigade dogfood` is the shortcut for using Brigade on itself or another trusted repo. It uses a built-in Codex-only roster, runs with prompt-level read-only instructions, shows the plan, writes normal run artifacts, writes a Memory Handoff by default, and prints the artifact summary afterward. Run `brigade dogfood init --target /path/to/repo` once to write local defaults to `.brigade/dogfood.toml`; that file is gitignored because it captures machine-local paths and preferences. After that, `brigade dogfood` from the repo is the one-command daily path, and `brigade dogfood "review today's changes"` overrides only the task. Use `brigade dogfood status` to inspect the effective target, artifact paths, handoff path, sandbox mode, CLI availability, ignore rules, and latest run without starting a new orchestration. Dogfood defaults to a 600 second per-agent timeout because full repo review can exceed short smoke-test limits. By default it passes Codex's `danger-full-access` sandbox setting for trusted-workspace use so repo inspection works on hosts where native read-only sandboxing blocks shell inspection. Use `--no-handoff` or `--no-inspect` to turn off those last two steps. Use `--native-read-only-sandbox` when the host supports Codex's native read-only sandbox and you want that additional enforcement.
 
 CLI runs write artifacts by default under `.brigade/runs/<id>` below `--cwd`; dogfood runs use `.brigade/runs/<id>` below the configured target:
 

src/brigade/cli.py

@@ -334,6 +334,11 @@ def main(argv=None) -> int:
                 native_read_only_sandbox=args.native_read_only_sandbox,
                 timeout_seconds=args.timeout_seconds,
             )
+        if dogfood_args and dogfood_args[0] == "status":
+            if len(dogfood_args) > 1:
+                print("error: dogfood status does not accept a task argument", file=sys.stderr)
+                return 2
+            return dogfood_cmd.status(target=args.target)
         task = " ".join(dogfood_args) if dogfood_args else None
         return dogfood_cmd.run(
             task,

src/brigade/dogfood_cmd.py

@@ -2,9 +2,13 @@
 from __future__ import annotations
 
 import ast
+import json
+import shutil
+import subprocess
 import sys
 from dataclasses import dataclass
 from pathlib import Path
+from typing import Any
 
 from . import aboyeur
 from . import runs_cmd
@@ -134,6 +138,131 @@ def load_config(target: Path) -> DogfoodConfig | None:
     )
 
 
+def _check_git_ignored(repo: Path, path: Path) -> str:
+    try:
+        relative = path.expanduser().resolve().relative_to(repo)
+    except ValueError:
+        return "outside-target"
+    try:
+        result = subprocess.run(
+            ["git", "-C", str(repo), "check-ignore", "-q", str(relative)],
+            check=False,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+    except OSError:
+        return "unknown"
+    if result.returncode == 0:
+        return "yes"
+    if result.returncode == 1:
+        return "no"
+    return "unknown"
+
+
+def _latest_run(runs_dir: Path) -> tuple[Path, dict[str, Any]] | None:
+    if not runs_dir.is_dir():
+        return None
+    latest: tuple[Path, dict[str, Any]] | None = None
+    latest_key = ""
+    for child in runs_dir.iterdir():
+        if not child.is_dir():
+            continue
+        try:
+            payload = json.loads((child / "run.json").read_text())
+        except (OSError, json.JSONDecodeError):
+            continue
+        if not isinstance(payload, dict):
+            continue
+        key = str(payload.get("started_at") or child.name)
+        if latest is None or key > latest_key:
+            latest = (child, payload)
+            latest_key = key
+    return latest
+
+
+def _setting_line(label: str, value: object) -> None:
+    print(f"{label}: {value}")
+
+
+def status(*, target: Path) -> int:
+    target = target.expanduser().resolve()
+    if not target.is_dir():
+        print(f"error: --target is not a directory: {target}", file=sys.stderr)
+        return 2
+
+    path = config_path(target)
+    try:
+        cfg = load_config(target)
+    except ValueError as exc:
+        print(f"error: invalid dogfood config: {exc}", file=sys.stderr)
+        return 2
+
+    effective_target = cfg.target if cfg and cfg.target is not None else target
+    effective_target = effective_target.expanduser().resolve()
+    artifacts_dir = cfg.artifacts_dir if cfg and cfg.artifacts_dir is not None else effective_target / ".brigade" / "runs"
+    handoff = cfg.handoff if cfg else True
+    handoff_inbox = (
+        cfg.handoff_inbox
+        if cfg and cfg.handoff_inbox is not None
+        else effective_target / ".claude" / "memory-handoffs"
+    )
+    inspect = cfg.inspect if cfg else True
+    native = cfg.native_read_only_sandbox if cfg else False
+    timeout = cfg.timeout_seconds if cfg else DEFAULT_TIMEOUT_SECONDS
+
+    codex_path = shutil.which("codex")
+    brigade_path = shutil.which("brigade")
+    blockers: list[str] = []
+    warnings: list[str] = []
+    if cfg is None:
+        warnings.append(f"config missing: run `brigade dogfood init --target {target}`")
+    if not effective_target.is_dir():
+        blockers.append(f"configured target is not a directory: {effective_target}")
+    if codex_path is None:
+        blockers.append("codex CLI not found on PATH")
+    if brigade_path is None:
+        warnings.append("brigade CLI not found on PATH; use the venv command or install the package")
+
+    ready = not blockers
+    print(f"dogfood: {'ready' if ready else 'not ready'}")
+    _setting_line("config", path if path.exists() else f"{path} (missing)")
+    _setting_line("target", effective_target)
+    _setting_line("artifacts_dir", artifacts_dir)
+    _setting_line("handoff", "enabled" if handoff else "disabled")
+    if handoff:
+        _setting_line("handoff_inbox", handoff_inbox)
+    _setting_line("inspect", "enabled" if inspect else "disabled")
+    _setting_line(
+        "sandbox",
+        "native read-only" if native else "prompt read-only + trusted-workspace execution",
+    )
+    _setting_line("timeout_seconds", f"{timeout:g}")
+    _setting_line("codex", codex_path or "missing")
+    _setting_line("brigade", brigade_path or "missing")
+    _setting_line("config_ignored", _check_git_ignored(effective_target, path))
+    _setting_line("artifacts_ignored", _check_git_ignored(effective_target, artifacts_dir))
+    latest = _latest_run(artifacts_dir)
+    if latest is not None:
+        latest_path, latest_meta = latest
+        task = " ".join(str(latest_meta.get("task") or "").split())
+        if len(task) > 80:
+            task = task[:77].rstrip() + "..."
+        _setting_line(
+            "latest_run",
+            f"{latest_meta.get('started_at', latest_path.name)} [{latest_meta.get('status', 'unknown')}] {latest_path}",
+        )
+        if task:
+            _setting_line("latest_task", task)
+    else:
+        _setting_line("latest_run", "none")
+
+    for warning in warnings:
+        print(f"warning: {warning}", file=sys.stderr)
+    for blocker in blockers:
+        print(f"error: {blocker}", file=sys.stderr)
+    return 0 if ready else 1
+
+
 def init(
     *,
     target: Path,

tests/test_dogfood_cmd.py

@@ -173,6 +173,44 @@ def fake_run(
     assert "inspect" not in seen
 
 
+def test_dogfood_status_reports_config_and_latest_run(tmp_path, monkeypatch, capsys):
+    dogfood_cmd.init(target=tmp_path, timeout_seconds=33)
+    run_dir = tmp_path / ".brigade" / "runs" / "20260526-120000-test"
+    run_dir.mkdir(parents=True)
+    (run_dir / "run.json").write_text(
+        '{"started_at":"2026-05-26T12:00:00Z","status":"ok","task":"review the repo"}'
+    )
+
+    monkeypatch.setattr(dogfood_cmd.shutil, "which", lambda name: f"/usr/bin/{name}")
+    monkeypatch.setattr(dogfood_cmd, "_check_git_ignored", lambda repo, path: "yes")
+
+    assert dogfood_cmd.status(target=tmp_path) == 0
+    captured = capsys.readouterr()
+    assert "dogfood: ready" in captured.out
+    assert f"config: {tmp_path / '.brigade' / 'dogfood.toml'}" in captured.out
+    assert f"target: {tmp_path.resolve()}" in captured.out
+    assert "artifacts_ignored: yes" in captured.out
+    assert "codex: /usr/bin/codex" in captured.out
+    assert "brigade: /usr/bin/brigade" in captured.out
+    assert "timeout_seconds: 33" in captured.out
+    assert "latest_run: 2026-05-26T12:00:00Z [ok]" in captured.out
+    assert "latest_task: review the repo" in captured.out
+
+
+def test_dogfood_status_reports_missing_codex(tmp_path, monkeypatch, capsys):
+    monkeypatch.setattr(dogfood_cmd.shutil, "which", lambda name: None)
+    monkeypatch.setattr(dogfood_cmd, "_check_git_ignored", lambda repo, path: "no")
+
+    assert dogfood_cmd.status(target=tmp_path) == 1
+    captured = capsys.readouterr()
+    assert "dogfood: not ready" in captured.out
+    assert "config:" in captured.out
+    assert "(missing)" in captured.out
+    assert "codex: missing" in captured.out
+    assert "warning: config missing" in captured.err
+    assert "error: codex CLI not found on PATH" in captured.err
+
+
 def test_dogfood_rejects_missing_target(tmp_path, capsys):
     assert dogfood_cmd.run(None, target=tmp_path / "missing") == 2
     assert "--target is not a directory" in capsys.readouterr().err
@@ -265,3 +303,16 @@ def fake_init(**kwargs):
         "native_read_only_sandbox": True,
         "timeout_seconds": 12.0,
     }
+
+
+def test_dogfood_cli_status(tmp_path, monkeypatch):
+    seen = {}
+
+    def fake_status(**kwargs):
+        seen.update(kwargs)
+        return 0
+
+    monkeypatch.setattr(dogfood_cmd, "status", fake_status)
+
+    assert cli.main(["dogfood", "status", "--target", str(tmp_path)]) == 0
+    assert seen == {"target": tmp_path}