fix: default dogfood handoffs to codex

Author: solomonneas

CHANGELOG.md

@@ -37,6 +37,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `brigade run --read-only` prompt policy for planning and review runs that should inspect and recommend only, with native `codex exec --sandbox read-only` enforcement for Codex agents.
 
 ### Changed
+- Dogfood handoff defaults now use `.codex/memory-handoffs/` for new Codex-driven local configs while preserving explicit configured inbox paths such as `.claude/memory-handoffs/`.
 - Dogfood runs now default to a 600 second per-agent timeout for practical daily repo reviews.
 - The managed gitignore block now treats `.brigade/dogfood.toml` and `.brigade/runs/` as local state.
 - Live smoke docs now keep Codex agent execution in a trusted repo cwd while writing temporary roster, artifacts, and handoff output under `/tmp`.

README.md

@@ -35,7 +35,7 @@ The cookbook explains the why. This package gives you the kitchen.
 
 - sanitized bootstrap files for agent behavior, safety, tools, identity, and memory
 - a canonical memory layout where one configured owner holds durable knowledge
-- a shared `.claude/memory-handoffs/` inbox for Claude Code, Codex, and other side harnesses
+- writer-specific Memory Handoff inboxes, such as `.claude/memory-handoffs/` for Claude Code and `.codex/memory-handoffs/` for Codex
 - starter memory cards and routing rules
 - multi-workspace handoff patterns for people administering more than one agent setup
 - memory-care staleness checks so durable cards do not quietly rot
@@ -146,7 +146,7 @@ brigade work recap --since 2026-05-26
 
 `--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. 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. Use `brigade dogfood latest` to show the latest configured dogfood run, and `brigade dogfood next` to print the latest extracted next step. Dogfood writes a `summary.md` beside each run's JSON artifacts with the final answer and extracted next step when present. 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. New dogfood configs default the handoff inbox to `.codex/memory-handoffs/` under the target because the dogfood roster is Codex-driven; pass `--handoff-inbox` if your memory owner ingests a different path, including existing `.claude/memory-handoffs/` setups. 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. Use `brigade dogfood latest` to show the latest configured dogfood run, and `brigade dogfood next` to print the latest extracted next step. Dogfood writes a `summary.md` beside each run's JSON artifacts with the final answer and extracted next step when present. 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:
 
@@ -175,7 +175,7 @@ brigade runs latest --cwd /path/to/repo
 brigade runs show .brigade/runs/<run-id>
 ```
 
-Use `--handoff` to bridge a completed run back into the memory system. By default it writes a reviewable handoff to `.claude/memory-handoffs/` under `--cwd`; override with `--handoff-inbox <path>`. The handoff targets `.learnings/LEARNINGS.md` as a `no-card` document update, so the normal `brigade ingest` route can review or ingest it. If handoff writing fails after synthesis, Brigade still prints the final answer and keeps the final artifacts, but exits nonzero and marks `run.json` as `handoff-failed`. `--handoff` is not allowed with `--dry-run` because dry runs have no final answer.
+Use `--handoff` to bridge a completed run back into the memory system. By default it writes a reviewable handoff to `.claude/memory-handoffs/` under `--cwd`; override with `--handoff-inbox <path>` for Codex, OpenCode, GPT, Hermes, OpenClaw, or any other non-Claude writer inbox. The handoff targets `.learnings/LEARNINGS.md` as a `no-card` document update, so the normal `brigade ingest` route can review or ingest it. If handoff writing fails after synthesis, Brigade still prints the final answer and keeps the final artifacts, but exits nonzero and marks `run.json` as `handoff-failed`. `--handoff` is not allowed with `--dry-run` because dry runs have no final answer.
 
 Live smoke test, using a temporary Codex-only roster:
 

src/brigade/cli.py

@@ -95,7 +95,7 @@ def _build_parser() -> argparse.ArgumentParser:
         "--handoff-inbox",
         type=Path,
         default=None,
-        help="Memory Handoff inbox. Defaults to .claude/memory-handoffs under --target.",
+        help="Memory Handoff inbox. Defaults to .codex/memory-handoffs under the effective target.",
     )
     p_dogfood.add_argument("--force", action="store_true", help="Overwrite an existing dogfood config during init.")
     p_dogfood.add_argument("--no-handoff", action="store_true", help="Do not write a Memory Handoff.")
@@ -158,7 +158,7 @@ def _build_parser() -> argparse.ArgumentParser:
         "--handoff-inbox",
         type=Path,
         default=None,
-        help="Memory Handoff inbox. Defaults to configured dogfood inbox or .claude/memory-handoffs.",
+        help="Memory Handoff inbox. Defaults to configured dogfood inbox or .codex/memory-handoffs.",
     )
 
     # run
@@ -285,7 +285,7 @@ def _build_parser() -> argparse.ArgumentParser:
     )
 
     # ingest
-    p_ing = sub.add_parser("ingest", help="Process .claude/memory-handoffs/*.md into canonical memory.")
+    p_ing = sub.add_parser("ingest", help="Process writer memory-handoff inboxes into canonical memory.")
     p_ing.add_argument("--target", "-t", type=Path, default=Path("."))
     p_ing.add_argument("--dry-run", action="store_true")
     p_ing.add_argument(

src/brigade/dogfood_cmd.py

@@ -17,6 +17,7 @@
 DEFAULT_TASK = "Review this repo and recommend the next implementation slice."
 DEFAULT_TIMEOUT_SECONDS = 600.0
 CONFIG_REL_PATH = ".brigade/dogfood.toml"
+DEFAULT_HANDOFF_INBOX_REL_PATH = ".codex/memory-handoffs"
 NEXT_LABELS = (
     "next practical slice",
     "smallest follow-up slice",
@@ -124,6 +125,10 @@ def config_path(target: Path) -> Path:
     return target / CONFIG_REL_PATH
 
 
+def default_handoff_inbox(target: Path) -> Path:
+    return target / DEFAULT_HANDOFF_INBOX_REL_PATH
+
+
 def load_config(target: Path) -> DogfoodConfig | None:
     target = target.expanduser().resolve()
     path = config_path(target)
@@ -314,7 +319,7 @@ def status(*, target: Path) -> int:
     handoff_inbox = (
         cfg.handoff_inbox
         if cfg and cfg.handoff_inbox is not None
-        else effective_target / ".claude" / "memory-handoffs"
+        else default_handoff_inbox(effective_target)
     )
     inspect = cfg.inspect if cfg else True
     native = cfg.native_read_only_sandbox if cfg else False
@@ -403,7 +408,7 @@ def init(
 
     chosen_artifacts_dir = artifacts_dir.expanduser() if artifacts_dir is not None else target / ".brigade" / "runs"
     chosen_handoff_inbox = (
-        handoff_inbox.expanduser() if handoff_inbox is not None else target / ".claude" / "memory-handoffs"
+        handoff_inbox.expanduser() if handoff_inbox is not None else default_handoff_inbox(target)
     )
     payload = {
         "target": str(target),
@@ -473,7 +478,7 @@ def run(
             if handoff_inbox is not None
             else cfg.handoff_inbox
             if cfg and cfg.handoff_inbox is not None
-            else effective_target / ".claude" / "memory-handoffs"
+            else default_handoff_inbox(effective_target)
         )
 
     rc = aboyeur.run(

src/brigade/ingest.py

@@ -1,10 +1,10 @@
-"""`brigade ingest` - route .claude/memory-handoffs/*.md into canonical memory.
+"""`brigade ingest` - route writer memory handoffs into canonical memory.
 
 Conservative by design:
   - auto-promote handoffs with safe card filenames + YAML frontmatter
   - append-only routing for TOOLS.md, USER.md, rules/*.md, .learnings/*.md
   - everything ambiguous lands in memory/handoff-inbox/ for manual review
-  - processed files move to .claude/memory-handoffs/processed/
+  - processed files move to the writer inbox's processed/ directory
 """
 from __future__ import annotations
 

src/brigade/work_cmd.py

@@ -84,7 +84,11 @@ def _dogfood_snapshot(target: Path) -> dict[str, Any]:
         "config": str(dogfood_cmd.config_path(target)),
         "target": str(effective_target),
         "artifacts_dir": str(artifacts_dir),
-        "handoff_inbox": str(cfg.handoff_inbox) if cfg and cfg.handoff_inbox is not None else None,
+        "handoff_inbox": str(
+            cfg.handoff_inbox
+            if cfg and cfg.handoff_inbox is not None
+            else dogfood_cmd.default_handoff_inbox(effective_target)
+        ),
     }
     if latest is None:
         snapshot["latest_run"] = None
@@ -284,7 +288,7 @@ def _handoff_inbox(target: Path, payload: dict[str, Any], override: Path | None)
     configured = dogfood.get("handoff_inbox")
     if isinstance(configured, str) and configured:
         return Path(configured).expanduser()
-    return target / ".claude" / "memory-handoffs"
+    return dogfood_cmd.default_handoff_inbox(target)
 
 
 def _write_work_handoff(target: Path, session_dir: Path, payload: dict[str, Any], inbox: Path) -> Path:
@@ -666,7 +670,7 @@ def status(*, target: Path, limit: int = 12) -> int:
     print(f"dogfood_artifacts: {artifacts_dir}")
     print(f"codex: {codex_path or 'missing'}")
     if cfg and cfg.handoff:
-        handoff_inbox = cfg.handoff_inbox or effective_target / ".claude" / "memory-handoffs"
+        handoff_inbox = cfg.handoff_inbox or dogfood_cmd.default_handoff_inbox(effective_target)
         print(f"handoff_inbox: {handoff_inbox}")
 
     latest = dogfood_cmd._latest_run(artifacts_dir)

tests/test_dogfood_cmd.py

@@ -51,7 +51,7 @@ def fake_show(run_dir):
     assert seen["show_plan"] is True
     assert seen["cwd"] == tmp_path.resolve()
     assert seen["output_dir"].parent == tmp_path / ".brigade" / "runs"
-    assert seen["handoff_inbox"] == tmp_path / ".claude" / "memory-handoffs"
+    assert seen["handoff_inbox"] == tmp_path / ".codex" / "memory-handoffs"
     assert seen["read_only"] is True
     assert seen["sandbox_read_only"] is None
     assert seen["sandbox"] == "danger-full-access"
@@ -169,6 +169,14 @@ def test_dogfood_init_writes_local_config(tmp_path, capsys):
     assert f"wrote {config}" in capsys.readouterr().out
 
 
+def test_dogfood_init_defaults_handoff_inbox_to_codex_writer(tmp_path):
+    assert dogfood_cmd.init(target=tmp_path) == 0
+
+    loaded = dogfood_cmd.load_config(tmp_path)
+    assert loaded is not None
+    assert loaded.handoff_inbox == tmp_path / ".codex" / "memory-handoffs"
+
+
 def test_dogfood_init_refuses_existing_without_force(tmp_path, capsys):
     assert dogfood_cmd.init(target=tmp_path) == 0
     assert dogfood_cmd.init(target=tmp_path) == 2

tests/test_work_cmd.py

@@ -152,6 +152,23 @@ def test_work_end_can_write_handoff(tmp_path, monkeypatch, capsys):
     assert payload["handoff"] == str(handoffs[0])
 
 
+def test_work_end_defaults_handoff_to_codex_inbox(tmp_path, monkeypatch):
+    _init_git_repo(tmp_path)
+    times = iter(
+        [
+            datetime(2026, 5, 26, 12, 0, 0, tzinfo=timezone.utc),
+            datetime(2026, 5, 26, 13, 0, 0, tzinfo=timezone.utc),
+        ]
+    )
+    monkeypatch.setattr(work_cmd, "_now", lambda: next(times))
+    assert work_cmd.start(target=tmp_path, title="Build Work Loop") == 0
+
+    assert work_cmd.end(target=tmp_path, note="done for now", handoff=True) == 0
+    session_dir = tmp_path / ".brigade" / "work" / "20260526-120000-build-work-loop"
+    payload = json.loads((session_dir / "session.json").read_text())
+    assert payload["handoff"].startswith(str(tmp_path / ".codex" / "memory-handoffs"))
+
+
 def test_work_end_reports_no_active_session(tmp_path, capsys):
     _init_git_repo(tmp_path)