Feat/cesar verification suite

.kern/self-coverage-baseline.json

@@ -13,7 +13,7 @@
     "blockedHandlers": 620
   },
   "blockerMaximums": {
-    "comments-present": 185,
+    "comments-present": 186,
     "foreign-missing-reason": 70,
     "var-bad-expr": 62,
     "for-stmt": 61,

README.md

@@ -295,10 +295,24 @@ agon review branch:feat-x --base main        # feat-x's commits vs main, regardl
 agon review range:main...feat-x              # fully explicit two-ref scope
 ```
 
-Diff scope is deliberate, never implicit: `--base <ref>` pins the base for `uncommitted`/`branch:` targets, and `range:BASE...TARGET` names both ends. A failed reviewer seat (timeout / hard error) is auto-retried once at half the wall clock before it's reported — and every failure is named in the run summary, never silently folded into a smaller panel. The same retry + loud `panel degraded:` banner applies to brainstorm, tribunal, and council seats.
+Diff scope is deliberate, never implicit: `--base <ref>` pins the base for `uncommitted`/`branch:` targets, and `range:BASE...TARGET` names both ends. One convenience: reviewing the branch you are currently **on** (where "branch vs itself" would be an empty diff) auto-bases against the repository's default branch — labelled `(auto-base)` in the run header so the scope is never silent. A failed reviewer seat (timeout / hard error) is auto-retried once at half the wall clock before it's reported — and every failure is named in the run summary, never silently folded into a smaller panel. The same retry + loud `panel degraded:` banner applies to brainstorm, tribunal, and council seats.
 
 Standard Review deliberately uses the full active panel even when the legacy `reviewDefaultEngine` preference is configured. Narrowing requires `--engine` or `--engines`. Explicit subsets are strict: an unknown, unavailable, or removed engine aborts the request instead of silently changing the committee.
 
+#### Role-lens review
+
+`/review role` (REPL) and `agon review --roles` (CLI) run the **same** parallel panel, but each engine reviews through a focused lens — `security`, `correctness`, `dryness`, `performance` — plus an `overall` generalist backstop so coverage is never partitioned away. Roles narrow each reviewer's *attention* only: the diff, repo grounding, machine findings block, consensus merge, and results pager are byte-identical to a standard review, and a reviewer who spots a blocking issue outside its role must still flag it.
+
+```bash
+/review role                                    # REPL: deal the default role roster
+/review role security,correctness uncommitted   # REPL: explicit roles, zipped per engine
+agon review --roles auto --risk auto            # CLI: roles composed with risk routing
+agon review --roles security,overall -e claude,codex
+agon call review uncommitted --roles auto       # external-CLI bridge (Claude Code, Codex, CI)
+```
+
+With `--roles auto` the fixed roster is dealt onto the selected panel in order and every extra engine lands on `overall`; an explicit comma list is zipped engine-by-engine (unknown role ids fall back to `overall`). Roles compose with `--risk`/`--primary-engine` routing — they change what each seat looks *at*, never how many seats there are.
+
 ### Agent
 An autonomous agent loop that can operate solo or in shadow mode, automatically routed to the best engine by Cesar based on task requirements.
 
@@ -410,6 +424,14 @@ When Cesar finishes a turn that edited files, Agon doesn't take "done" on faith.
 
 Note the posture semantics: a gate command classified read-only (like plain `npm test`) auto-runs in **every** mode, because the resolver lets read-only commands run freely — the same command Cesar could already execute unprompted. Mutating gate commands (compound `&&` gates, scripts the classifier can't clear) auto-run only in `auto` mode or under a covering allow rule; gates with output redirection are additionally refused outside `auto`. Everything else falls back to the previous behavior: a one-time nudge asking Cesar to verify. Tune with `cesarGateAutoRun` (on by default), `cesarGateAutoRunLimit`, `cesarGateTimeoutSec`, and `cesarGateOutputTailChars`.
 
+#### Cesar self-inspection tools
+
+Beyond the gate, Cesar has three built-in tools for verifying its *own* surface and dispatch reliability — so "does the UI actually render what I claimed?" and "which engine keeps failing me?" are answerable in-turn instead of taken on faith:
+
+- **RenderProbe** — renders a registered Ink component (`StatusBar`, `TodoList`, `ChromeBar`, …) off-screen at a given width/height and returns the final frame as text. Pure in-process render; no side effects.
+- **TuiProbe** — boots a real `agon` instance inside a pseudo-terminal (via `pyte` screen-state emulation, so the result is the **final composed grid**, not a stream of ANSI artifacts), optionally sends one safelisted input (`/help`, `/status`, `/todos`, `/plans`, `/checkpoints`), and returns the rendered screen. Fully isolated: throwaway `AGON_HOME`, temp cwd, single-line control-character-rejecting input filter. Requires `python3` with `pyte` installed.
+- **EngineReliability** — a per-engine reliability digest with two honestly separated sections: Cesar's **own-turn** tool outcomes, and the **delegated dispatch ledger** (`~/.agon/runs/delegate-tool-ledger.jsonl`), which records every delegate dispatch per engine × backend (`api-loop`, `cli-print`, `companion`) with native-vs-heuristic provenance — a dispatch that *failed* is recorded as `dispatchFailed`, never blurred into "unknown".
+
 **Example Session:**
 ```text
 $ agon

packages/cli/package.json

@@ -41,6 +41,7 @@
   },
   "files": [
     "dist",
+    "py",
     "README.md",
     "LICENSE"
   ],