O Cérebro do Loop: Lifecycle, Findings e Sumarização

Replace the fail-open stub in `plugins/claudex/hooks/stop-hook.sh`
with the real lifecycle engine. Read `SPEC.md` for the phase table.

Build:

1. **Helpers at the top.** `log()` appends to `.claude/claudex/log`
   with UTC timestamp. `approve(reason)` logs and prints
   `{"decision":"approve"}`. `block(reason)` logs the first 80 chars,
   JSON-escapes the reason via `python3 -c 'import sys, json;
   print(json.dumps(sys.stdin.read()))'` with a sed-based fallback if
   python3 is missing, then prints `{"decision":"block","reason":...}`.

2. **ERR trap unconditional.** First active line of the script.
   Catches anything not explicitly handled and fails open.

3. **Source state-helpers.sh** (or fail-open if it's missing).

4. **Find the active loop.** If none, approve. If the review_id format
   is invalid, remove the bad state file and approve.

5. **Read state fields.** mode, phase, round, max_rounds,
   decision_signal, topic, repo_root, started_at_epoch.

6. **cwd validation.** If `repo_root` differs from current `pwd`,
   fail open with a log line.

7. **Validate numerics.** Garbage `round` or `max_rounds` falls back
   to 1 / max-default.

8. **`write_runner_script` helper.** Builds a self-contained bash script
   at `.claude/claudex/<id>-runner.sh`. The script writes the prompt to
   a heredoc with `<<'PROMPTEOF'` (single quotes — critical: prevents
   shell expansion) then runs
   `codex exec --dangerously-bypass-approvals-and-sandbox < $PROMPT_FILE`.

9. **Plan mode case statement.**
   - `drafting`: if PLAN.md missing → BLOCK. If present → CAS to
     `reviewing`, build round-1 Codex prompt, write runner. BLOCK with
     instructions to run the runner, read findings, and either revise
     PLAN.md or call `mark-done.sh`.
   - `reviewing`: if `decision_signal=no-material-findings` → CAS to
     `done`, cleanup, approve. Otherwise increment round; if new round
     > max_rounds, set `decision_signal=max-reached`, CAS to `done`,
     cleanup, approve. Otherwise: write next-round runner, BLOCK.
   - `done`: cleanup, approve.
   - any other phase: log unknown phase, approve.

10. **Review mode case statement.**
    - `reviewing`: write runner for diff review. CAS to `done`. BLOCK.
    - `done`: cleanup, approve.

11. **`plugins/claudex/scripts/mark-done.sh`.** Takes review_id arg.
    Sets `decision_signal=no-material-findings` and `phase=done`.

12. **Smoke test** at `plugins/claudex/tests/smoke-test.sh`. Spins up
    temp git repo. Fires hook, asserts BLOCK. Asserts state=reviewing.
    Asserts runner written. Fires again, asserts round increment. Asserts
    mark-done + hook fire = approve. Asserts concurrent-loop refusal.

Run both test scripts. Tell me the counts.

**Do NOT actually call Codex in any test.**

Two changes, both additive:

## A. Findings file extraction

Field testing showed Claude was burning context reading 30k+ token
Codex transcripts every round. Have Codex also write a clean small
bullet summary that Claude reads instead.

1. Update the round-N Codex prompt in `stop-hook.sh` to include:

   > CRITICAL OUTPUT REQUIREMENT: After your full analysis, write a
   clean summary of just the findings (severity + one-line description
   + recommendation) to the file `<findings_path>`. Use this exact
   format: `# Round N findings\n\n## High\n- <description>
   (<recommendation>)\n...`. If no material findings, write exactly
   `# Round N findings\n\nNo substantive findings.`

2. The hook constructs the findings path as
   `.claude/claudex/<review_id>/findings-round-<round>.md`.
   Pre-create the per-review subfolder.

3. The BLOCK message tells Claude: "When Codex finishes, read the
   clean findings summary from `<path>`. Skip the full transcript
   unless you need extra context."

4. Add `claudex_findings_severity_counts <file>` to `state-helpers.sh`.
   Returns `high=N medium=N low=N` by counting bullet lines under each
   `## Severity` header. Return `high=0 medium=0 low=0` if missing.

5. On round 2+, prepend a "**Previous round:** high=N medium=N low=N"
   line to the BLOCK so Claude sees the trajectory.

## B. Persona rotation

1. Create `plugins/claudex/scripts/personas.sh`. Two functions:
   - `claudex_persona_for_round <N>` — multi-paragraph stanza.
     Round 1: skeptical senior engineer.
     Round 2: security and data-integrity reviewer.
     Round 3+: ops / SRE reviewer (round 4+ deepens prior angles).
   - `claudex_persona_label_for_round <N>` — one-line label.

2. In `write_runner_script`, source personas.sh and prepend the persona
   stanza to the Codex prompt. Pass the round number through.

3. Update BLOCK headers to: `### Claudex round N of M, <persona-label>`.

## Tests

Update tests to assert persona stanzas differ per round, severity
counts work correctly, and round-2 BLOCK contains "Previous round" line.

Run both test scripts. Send the counts.

Add a new phase between `reviewing` and `done` called `summarizing`.
The job of this phase is to BLOCK once with a final summary so Claude
prints it to the user, then approve on the next fire.

## Hook changes (`stop-hook.sh`)

1. Add a `build_rounds_table <final_round>` helper. Iterates 1..N,
   reads each findings file, calls `claudex_findings_severity_counts`,
   pairs with persona label. Returns lines like:
   - Round 1 (Senior-engineer review): high=2 medium=4 low=1
   - Round 2 (Security and data-integrity review): high=2 medium=2 low=0

2. In the `reviewing` case, when `decision_signal=no-material-findings`:
   - CAS `reviewing → summarizing` (NOT to `done`).
   - Build the summary using `build_rounds_table` and `format_elapsed`.
   - BLOCK with `### Claudex plan loop complete ✓`. Body: rounds run,
     total time, findings table, then "**Print this summary to the user
     so they see the loop landed.** Then end your turn. The Stop hook
     will allow exit cleanly."

3. When round overflow:
   - Set `decision_signal=max-reached`.
   - CAS `reviewing → summarizing`.
   - BLOCK with `### Claudex plan loop stopped at max rounds (round N
     of M)`. Include rounds table and three options: revise manually,
     re-run with `--rounds N` larger, accept as known-incomplete.

4. Add a `summarizing` case:
   - CAS `summarizing → done`.
   - Cleanup runner, prompt file, lockfile.
   - Log elapsed time.
   - Approve.

## `mark-done.sh` change

Change to **only** set `decision_signal=no-material-findings` and
**leave `phase=reviewing`**. The next hook fire will see the signal
and drive the summarizing path.

## Format gotcha

Bash double-quoted heredoc strings interpret backticks as command
substitution. Escape every backtick in the summary BLOCK: `\``.
Test that the JSON output parses cleanly with python3.

Run all tests, send counts.