Merge origin/main into feature/prm-full-close-out (board supersedes /wake_up)

# Conflicts:
#	AGENTS.md

Author: Jammy2211

.github/workflows/brain_board.yml

@@ -0,0 +1,78 @@
+name: Brain Board
+
+# Publishes the Brain's operational board — the organism's morning door — to
+# this repo's GitHub Pages URL: the page (index.html), its badge.json (the
+# cross-board headline contract the umbrella router consumes), the raw
+# board.json, and the markdown twin board.md.
+#
+# The board replaces the interactive /wake_up skill: everything that skill
+# assembled by driving doors in sequence (overnight scheduled-run sweep, the
+# Heart's readiness headline, version-stamp consistency, the community scan,
+# resume context from the Mind, the upkeep doors) is collected here on a
+# schedule and rendered with one-tap copy-for-Claude payloads. The renderer is
+# board/_board.py; its vocabulary is config/policy.yaml `board:`.
+#
+# Unlike the Mind dashboard (self-healed into the repo, because its state IS
+# the repo), nothing here is committed: the board's data is time-varying, so
+# it is served from the Pages artifact only — a daily refresh makes no commit
+# noise and can never drift against a repo copy.
+#
+# Cadence: 05:30 UTC daily — after the 02:00 nightly release driver and the
+# Heart's 05:00 heart-health refresh (which rewrites the badge this board
+# reads), before the human's morning. GitHub cron jitters 0–3 h under load,
+# so the page stamps its own generation time and every consumer should trust
+# that stamp over the schedule. workflow_dispatch is the manual refresh
+# (also what a human taps when the board says it is stale).
+
+on:
+  schedule:
+    - cron: "30 5 * * *"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: pages
+  cancel-in-progress: true
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          path: PyAutoBrain
+      # The board composes, it does not recompute: the community scan reads
+      # the body map (repos.yaml) and the resume section reads the registry +
+      # the Mind's own generated dashboard counts, so the Mind is checked out
+      # as a sibling — the same two-repo layout tests.yml uses.
+      - uses: actions/checkout@v4
+        with:
+          repository: ${{ github.repository_owner }}/PyAutoMind
+          path: PyAutoMind
+      - name: render the board
+        env:
+          PYAUTO_ROOT: ${{ github.workspace }}
+        run: |
+          python3 -m pip install --quiet pyyaml
+          python3 PyAutoBrain/board/_board.py --apply --out _site
+      # enablement: true creates the Pages site on first run where the token
+      # may (Mind/Heart precedent); where it may not (the Hands hit "Resource
+      # not accessible by integration"), the site must be created once
+      # out-of-band: gh api -X POST repos/<owner>/PyAutoBrain/pages -f build_type=workflow
+      - uses: actions/configure-pages@v5
+        with:
+          enablement: true
+      - uses: actions/upload-pages-artifact@v3
+        with:
+          path: _site
+      - id: deployment
+        uses: actions/deploy-pages@v4

AGENTS.md

@@ -169,12 +169,19 @@ via `/route`, and it routes to the right agent; normal usage never says
 "PyAutoBrain". A few commands are compositions rather than single agents:
 `/docs` and `/research` route through the dev-flow with their PyAutoMind
 work-type fixed (no dedicated conductor — added only on demonstrated need, never
-for symmetry); `/wake_up` composes sync + `/health` + `/hygiene`; `/prm` composes the
+for symmetry); `/prm` composes the
 end-of-task close-out (CI green → merge → issue closed → Mind `active/` →
 `complete/` → worktree and branches removed); `/brain
 <agent>` is the raw passthrough. Every command routes **through** the Brain;
 none replaces it.
 
+The morning routine is not a command at all: the **Brain board**
+(`board/_board.py`, published to the Brain's GitHub Pages URL each morning by
+`brain_board.yml`) carries what `/wake_up` used to assemble — overnight runs,
+readiness, community, resume, upkeep — as one-tap 📋 payloads, and
+`bin/morning.sh` is the local sync/clean leg you run in a terminal.
+`/wake_up` remains only as the fallback door when the board is unreachable.
+
 The command bodies live in `skills/<verb>/<verb>.md`; thin `SKILL.md` wrappers
 make the same canonical workflows discoverable to skill-aware harnesses.
 `bin/install.sh` installs both surfaces without duplicating their bodies. Shared

README.md

@@ -12,14 +12,21 @@ classifies each task, plans it, and routes it to specialist agents — and it
 delegates everything else: it holds no state (the Mind's job), runs no health
 checks (the Heart's), and never releases anything itself (the Hands').
 
+See the **[PyAutoBrain Dashboard](https://pyautolabs.github.io/PyAutoBrain/)**
+for the organism's morning and general starting point: what ran overnight, the
+Heart's readiness headline, who in the community is waiting on a reply, what
+to resume, and the upkeep doors — each actionable row with a one-tap 📋
+copy-for-Claude command. Regenerated each morning; the local sync/clean leg is
+one terminal command, `bash bin/morning.sh`.
+
+## How PyAutoBrain works
+
 You drive it in plain English, through short slash commands in a Claude Code
 chat: `/intake` to file an idea, `/start_dev` to begin a task, `/health` for a
 check-up — or just `/route <what you want>` and the Brain picks the right
 door. The full command surface (13 conductors + 5 faculties) is the generated
 table in [AGENTS.md](AGENTS.md).
 
-## How PyAutoBrain works
-
 1. **A task arrives.** Usually from the Mind's backlog — pick a task on the
    [PyAutoMind dashboard](https://pyautolabs.github.io/PyAutoMind/) and paste
    its `/start_dev` command — or free-form, via `/route` or any conductor's

agents/conductors/intake/AGENTS.md

@@ -83,11 +83,33 @@ schema — light structure over free-form prose.
 | **classify** | `intake "<text>"` / `intake classify --file P` | classify one raw input; `--apply` writes the prompt |
 | **ideas** | `intake ideas` | scan `ideas.md`, propose one prompt per bullet; `--apply` writes them |
 | **census** | `intake census` | inventory every filed prompt (work-type/target/difficulty/status + hygiene flags); always read-only |
-| **dashboard** | `intake dashboard` | render the census as the Mind **task** page — picks, in flight, parked, planned, backlog; `--apply` writes `PyAutoMind/dashboard.md`, `--check` exits 1 on drift |
+| **dashboard** | `intake dashboard` | render the census as the Mind **task** page — picks, in flight, parked, planned, backlog, recent, epics; `--apply` writes `PyAutoMind/dashboard.md`, `--check` exits 1 on drift |
 | **formalise** | `intake formalise [prefix]` | retroactively header the prompts census flags — derive the missing fields, insert in place, prose untouched; `--apply` writes |
 | **reconcile** | `intake reconcile [prefix]` | rank backlog prompts that look already-shipped (vs the `complete/` records / `active/`); always read-only — retiring stays human |
 | **reconcile --repo** | `intake reconcile --repo <target> [prefix]` | **also** read the target repo's source for identifiers the prompts name — the one signal that sees a prompt with no Mind-side trace. Opt-in; the default path is offline |
 
+**Recent** is the one section laid out by *date* rather than by state: the 50
+newest events on the **work in hand** — issued, parked, filed — merged across
+every live bucket (the `draft/` backlog included, which is most of them:
+150 prompts against a handful of registry rows) and sitting between the Backlog
+and the Epics. Epic members stay out, as they do in every pick list on the
+page — they are worked in order through their epic, and a Recent row hands out
+a standalone `/start_dev`. It *holds* 50
+and *shows* 10 (`RECENT_MAX` / `RECENT_PAGE`): the table is a glance, not a
+log, so the rest is one tap away — a `…` button on the Pages twin, and nested
+`<details>` on the markdown page, which GitHub renders where it strips the
+script. Every other
+section answers "what should I do now?"; recency is orthogonal to state, so
+none of them can answer "what has been happening?". Dates come from the
+registry key that names the event (`issued:` / `parked:` / `filed:`, PyAutoMind
+REFERENCE.md "Task dates") or a prompt's own `Issued:` header.
+
+Shipped work is deliberately **not** in the feed and `complete/` is never
+opened to render it: the ledger is a thousand records deep and takes ~200 a
+month, so including it made the table a list of receipts — twenty things nobody
+can act on, on the page whose whole job is work in hand. `complete/index.md` is
+where shipped work is read.
+
 Census/dashboard are the Mind *backlog* view — deliberately distinct from
 Heart's `/health status` health view (see "must never do"). The prompt-taxonomy
 folder is authoritative for a prompt's work-type/target; header fields are