Affected Repositories

• PyAutoCortex (primary — the epic's home, cortex.py check rule + REFERENCE.md + the regenerated board)
• PyAutoBrain (agents/conductors/cortex/_cortex.py — the renderer, census, checkin, payloads)

Branch Survey

Suggested branch: feature/cortex-checkin-p3-project-summary — cut from origin/feature/cortex-checkin-p2-the-door in both repos (stacked; PRs --base feature/cortex-checkin-p2-the-door).

Implementation Steps

1. PyAutoBrain/agents/conductors/cortex/_cortex.py — carry the bullets. Extract _where_bullets(mod, ph) from where_paths() (the _where_to_look getter plus the older-checkout fallback), have where_paths() call it, and add "where": _where_bullets(mod, ph) to _phase_row(). Every renderer then has the bullets verbatim without re-reading the tree.
2. census() — add a planned bucket (sorted) so the by-project tree can render the state order the prompt asks for. SECTIONS / section_counts() are untouched: the board's counts strip stays the five it has.
3. The two payloads.
   • _next_phase_payload(r, c) — for awaiting-ruling / pulled / accepted: draft the accept body → cortex.py rule <rel> accept --body <file>, then either move an already-existing phase N+1 on (when the project already holds one — that is the ledger naming it) or cortex.py new <project> <slug> --phase <N+1> --title "<tail>" with the title-prefix rule stated inline (new writes # <Project> — phase N: itself), --epic pre-filled from the phase's own Epic:, then the launch lines.
   • _rerun_payload(r, c) — for awaiting-ruling / pulled / running: rule <rel> rerun --body <file>, move <rel> ready, the project's own submit line, move <rel> submitted --run <jobid> (one run per call).
     Both stay short — a human pastes them into a fresh chat.
4. phase_chips(r, c) — (label, payload) for every prompt a phase's state has; the single place the board, the census tree and the check-in summary agree on which prompts a phase gets.
5. project_groups(key, c) — that project's phases in state order (awaiting → live → ready → gated → planned), with accepted/dropped/rerun folded into the counts line.
6. project_digest() — generalised: paths line, optional pull line (omitted by census), counts, then per phase the health/legs (when scored), the ## Where to look bullets verbatim, and the chips. checkin_summary() keeps using it; emit_by_project(c) prints it for census --by-project.
7. render_dashboard() / render_dashboard_html() — a ## By project section rendered from the same project_groups / phase_chips, placed immediately after the counts table and before ## Awaiting ruling, with a SECTIONS entry (source projects.yaml) so it links its source and joins the counts strip's index.
8. build_parser() — census --by-project; main() dispatches it.
9. PyAutoCortex/scripts/cortex.py — new check rule in phase_problems(): a phase whose State: is not planned must carry at least one ## Where to look bullet that is not the template placeholder. The section is now rendered as the human's "which folder" answer, so a placeholder-only section is a hole exactly where a human is being asked to act.
10. PyAutoCortex/REFERENCE.md — document the ## By project section, the two new prompts and the new check rule.
11. Regenerate dashboard.md / dashboard.html from inside the Cortex worktree with the Brain worktree's _cortex.py (same stacked branch), commit on the Cortex branch, and confirm dashboard --check is current.

Testing

• PyAutoBrain/tests/test_cortex_conductor.py: the ## By project section renders one block per project with its three paths and its where-bullets; census --by-project prints the same tree; _next_phase_payload names phase N+1 (both the "already planned" and the "new" branch, and the title-prefix note); _rerun_payload carries rule → ready → submit → submitted in that order; a phase whose ## Where to look holds only the placeholder renders without a where list and without crashing; the check-in summary carries the new chips.
• PyAutoCortex/tests/test_cortex.py: the new check rule passes on the skeleton and trips when a non-planned phase's ## Where to look is emptied to the placeholder.

Key Files

• PyAutoBrain/agents/conductors/cortex/_cortex.py — renderer, census, checkin, payloads
• PyAutoBrain/tests/test_cortex_conductor.py — contract tests
• PyAutoCortex/scripts/cortex.py — the new check rule
• PyAutoCortex/REFERENCE.md — the section, the prompts, the rule
• PyAutoCortex/dashboard.md + dashboard.html — regenerated

Cortex by project: the "where is everything, which folders" summary and the two missing starting prompts

Type: feature
Target: pyautocortex
Repos:

• PyAutoBrain
• PyAutoCortex
  Themes:
• mind-workflow
  Difficulty: medium
  Autonomy: safe
  Priority: high
  Status: draft
  Consequence: judge
  Witness: the regenerated Cortex dashboard.md has a ## By project section (one block per status: active project, then a folded one-liner for dormant projects) that renders each project's local_path / mirror / ral_root, each non-dropped phase with State + health, the phase's ## Where to look bullets verbatim, and per phase the copy-ready prompt for its state, including two NEW ones: "accept → file and start the next phase" (wraps cortex.py rule <phase> accept --body … then cortex.py new <project> <slug> --phase N+1 with the title-prefix rule from memory) and "rerun this phase" (rule … rerun --body …, move ready, move submitted --run); pyauto-brain cortex checkin prints the same by-project summary and prompts; pyauto-brain cortex census --by-project exists; dashboard --check current; Brain + Cortex tests cover the section, both new payloads and a phase with no ## Where to look
  Review-minutes: 20
  Unattended: ready
  Epic: cortex-checkin
  Phase: 3
  Filed: 2026-09-03

Phase 3 of cortex-checkin. Branch from phase 2's branches if unmerged. Two
PRs (Brain renderer + census + checkin summary; Cortex docs/REFERENCE for the
new section and the two prompts, plus any check rule that ## Where to look
now needs, e.g. "every non-planned phase has at least one bullet").

By-project summary

Today every dashboard section and census are keyed by phase STATE
(SECTIONS in _cortex.py ~L231-253), the Projects table omits
local_path/mirror/ral_root, and ## Where to look is parsed
(where_paths ~L1231) only to locate artefacts, never rendered. Add:

• ## By project in the dashboard (above the state sections or directly
  below the header — pick the one that reads first on a phone and say why):
  per active project, a header with the three paths, then its phases in
  state order (awaiting-ruling, running, submitted, ready, gated, planned;
  accepted/dropped folded into a count), each with health from the last
  scoring, its ## Where to look bullets verbatim, and its prompt.
• census --by-project printing the same tree as text; checkin uses it for
  its closing summary (replace phase 2's minimal version).

The two missing prompts

Dashboard rows already carry _ruling_payload (rule this),
launch_payload (submit + move), _live_payload (check jobs). Add:

• _next_phase_payload for an awaiting-ruling (or freshly accepted)
  phase: "the results are good — file the ruling and open phase N+1": the
  rule … accept --body <file> line with a body stub, then
  cortex.py new <project> <next-slug> --phase <N+1> (honour the title-prefix
  and rerun-flow conventions in memory reference_cortex_new_title_prefix_and_rerun_flow),
  then the launch prompt for the new phase. Where the epic ledger names the
  next phase's title, prefill it.
• _rerun_payload for awaiting-ruling / pulled / running: "rerun
  this": rule … rerun --body <file>, move ready, move submitted --run,
  with the phase's own submit command from launch_payload.

Both render as chips beside the existing rule prompt and appear in the
by-project summary and in checkin's output. Keep the payload text short:
these are things a human pastes into a fresh chat, not scripts.