@seanyao/roll 2026.517.2 → 2026.517.4

package/skills/roll-build/SKILL.md

@@ -302,6 +302,13 @@ When any signal appears, **do not stop — flag it**:
 
 Then continue implementing the current Story normally.
 
+**Event emission** — after all TCR micro-steps for a Story complete, emit a `build` event so the cycle event stream reflects the work done:
+
+```bash
+# _tcr_count = number of "tcr:" prefix commits made during this Story
+_loop_event build "$US_ID" "${_tcr_count} commits" "" 2>/dev/null || true
+```
+
 ### Phase 5.5: E2E Deposit
 
 After TCR micro-steps pass, deposit an E2E test for this Story's core user flow.
@@ -371,33 +378,51 @@ EOF
 chmod +x .git/hooks/pre-push
 ```
 
-### Phase 7: Pre-Push Code Review
+### Phase 7: Pre-Push Code Review (Three-Axis Deep Review)
+
+This phase runs **once per Story** (not per micro-step) on the full accumulated diff.
+Per-micro-step review uses `$roll-.review staged` inline checklist (zero extra cost).
+
+**Phase 3.5 vs Phase 7 split**: Phase 3.5 (Peer Review) focuses on architectural direction
+and approach before coding begins. Phase 7 focuses on implementation quality after all
+micro-steps are done — catching issues that only appear at diff scale (parameter sprawl
+across files, copy-paste patterns, cross-file N+1, etc.).
 
 ```bash
-$roll-.review staged
+# Capture full Story diff
+git diff main...HEAD
 ```
 
-**Review output:**
+**Launch three review agents in parallel** (each receives the full diff):
+
 ```
-🔍 Self Review Report
-├── Scope: X files (+Y/-Z lines)
-├── 🔴 Critical: N issues (must fix)
-├── 🟡 Warnings: N issues (should fix)
-├── 🟢 Suggestions: N items (optional)
-└── ✅ Passed dimensions: [Quality, Design, Scope, ...]
+Agent 1: Reuse Review
+  → Search for existing utilities / helpers the new code could use instead
+  → Flag any new function that duplicates existing functionality
+  → Flag inline logic replaceable by existing tools
+
+Agent 2: Quality Review
+  → Redundant state, Parameter sprawl, Copy-paste near-duplicate,
+     Leaky abstraction, Stringly-typed, JSX nesting,
+     Nested conditionals ≥3 deep, Unnecessary comments
+
+Agent 3: Efficiency Review
+  → Redundant computation / N+1, Missed concurrency,
+     Hot-path bloat, Loop no-op updates, TOCTOU existence pre-check,
+     Memory leaks, Overly broad operations
 ```
 
-**Review dimensions** (correctness guaranteed by TCR):
-- 🎯 **Quality**: Naming clarity, DRY, function size, readability
-- 📐 **Design**: Architecture, abstraction level, separation of concerns
-- ⚠️ **Scope**: No opportunistic changes
-- 📝 **Documentation**: Comments where needed
+Wait for all three agents to complete. Aggregate findings → fix each issue
+(false positives: note and skip, no debate) → summarize what was fixed.
+
+**Fallback**: If parallel agent invocation fails, run `$roll-.review staged` on
+the full diff as a single-pass fallback — do not skip review entirely.
 
 **Decision:**
 ```
 🔴 Critical > 0 → Fix via new TCR cycle → Re-review
 🟡 Warnings > 0 → Fix if quick (< 5 min) or document
-🟢 Suggestions / ✅ All clear → Proceed to push
+🟢 Suggestions / ✅ All clear → Proceed to Phase 8
 ```
 
 ### Phase 8: Commit & Push

package/skills/roll-loop/SKILL.md

@@ -96,7 +96,7 @@ fi
 
 ### Step 1.5 — Pre-run CI Health Check
 
-Call `_loop_precheck_ci` before scanning BACKLOG. This is a **defensive gate**
+Call `roll loop precheck-ci` before scanning BACKLOG. This is a **defensive gate**
 against building on a broken base — if the most recent commit on the branch
 has red CI, the loop must not stack new commits on top (which would create the
 exact stuck-red state FIX-026 traces to).
@@ -105,7 +105,7 @@ exact stuck-red state FIX-026 traces to).
 - HEAD CI red → write ALERT, **do not pick up any stories this cycle**,
   exit cleanly. The next cycle will retry; the human must fix CI manually
   (typically by reverting or pushing a green commit) before the loop resumes.
-- `gh` missing or repo unparseable → graceful skip (`_loop_precheck_ci`
+- `gh` missing or repo unparseable → graceful skip (`roll loop precheck-ci`
   returns 0); the post-build `_loop_enforce_ci` remains the strict gate.
 
 ### Step 1.6 — PR Inbox (US-AUTO-034)
@@ -195,6 +195,13 @@ For each item, **before invoking the executor skill**, mark the story 🔨 In Pr
 
 This commit is what makes the work visible — without it, tcr micro-commits during execution are invisible to `roll-brief`.
 
+选定故事后，调用 `_loop_event` 发出 story 事件，让 monitor 和 attach 能渲染当前进度：
+
+```bash
+# 选定故事后立即 emit（在调用 executor skill 之前）
+_loop_event story "$US_ID" "$story_title" ""
+```
+
 Then invoke the executor:
 
 ```
@@ -222,7 +229,7 @@ run_id: loop-20260510-0200
 
 After each item completes:
 
-1. **TCR 硬校验** — call `_loop_enforce_tcr <story_id> <started_at>`:
+1. **TCR 硬校验** — call `roll loop enforce-tcr <story_id> <started_at>`:
    - Count `tcr:` prefix commits since `started_at` via `git log --oneline --since=<started_at>`
    - Count == 0 → revert story status in BACKLOG.md from ✅ Done → 📋 Todo; write ALERT to `~/.shared/roll/loop/ALERT.md` with story ID, time, reason "zero tcr: commits since story start", and suggested actions (`roll loop now` / `$roll-build <id>` / `roll loop reset`)
    - Count > 0 → continue normally
@@ -239,34 +246,36 @@ After each item completes:
      (return 0). Any other `gh` error is **not** "gh unavailable" — it is a
      hard failure and must block the gate.
 
-   **CI self-heal (US-AUTO-041)** — bounded auto-fix before ALERT:
-
-   ```
-   shell: _loop_self_heal_ci <story_id>
-     ├── exit 0 → heal attempt allowed (counter incremented)
-     │   1. Capture failure summary:
-     │      gh run view --log-failed --repo <slug> $(gh run list --commit HEAD \
-     │        --json databaseId,conclusion -L 5 | jq -r '.[] | select(.conclusion=="failure") | .databaseId' | head -1) \
-     │        2>/dev/null | head -200 > /tmp/roll-heal-<story_id>.log
-     │   2. Invoke Skill("roll-fix") with brief:
-     │      "CI red after <story_id>. Failing run logs at /tmp/roll-heal-<story_id>.log.
-     │       Diagnose root cause, fix via TCR, commit, push. Do NOT change <story_id>'s
-     │       BACKLOG status — it stays ✅ Done. The fix is a follow-up."
-     │   3. After roll-fix completes, return to step 2 (CI Gate) — re-run
-     │      `roll ci --wait`. The counter prevents infinite loops.
-     │
-     └── exit 1 → heal exhausted (>=ROLL_LOOP_HEAL_MAX, default 2) or disabled
-                  (ROLL_LOOP_NO_HEAL=1):
-         1. Keep story as ✅ Done (commits are already on main — CI red is a
-            follow-up problem, not a story-failure)
-         2. Write ALERT to `~/.shared/roll/loop/ALERT.md` with:
-            - story ID, time, commit SHA
-            - heal attempts made (read counter from
-              `${ROLL_LOOP_DIR:-~/.shared/roll/loop}/heal/<story_id>.count`)
-            - last failure summary (head of /tmp/roll-heal-<story_id>.log)
-            - suggested actions: `$roll-fix` manually / inspect CI / `roll loop reset`
-         3. Skip to next story.
-   ```
+   **CI self-heal (US-AUTO-041)** — bounded auto-fix before ALERT.
+
+   Call `_loop_self_heal_ci <story_id>` to check if another attempt is permitted.
+
+   **Path A — attempt allowed (exit 0, counter incremented in `state.yaml`):**
+
+   1. Capture failure summary:
+      ```
+      gh run view --log-failed --repo <slug> \
+        $(gh run list --commit HEAD --json databaseId,conclusion -L 5 \
+          | jq -r '.[] | select(.conclusion=="failure") | .databaseId' | head -1) \
+        2>/dev/null | head -200 > /tmp/roll-heal-<story_id>.log
+      ```
+   2. Invoke `Skill("roll-fix")` with brief:
+      `"CI red after <story_id>. Failing run logs at /tmp/roll-heal-<story_id>.log.
+      Diagnose root cause, fix via TCR, commit, push. Do NOT change <story_id>'s
+      BACKLOG status — it stays ✅ Done. The fix is a follow-up."`
+   3. After `roll-fix` completes, return to step 2 (CI Gate) — re-run `roll ci --wait`.
+      The counter in `state.yaml` prevents infinite loops.
+
+   **Path B — heal exhausted (≥`ROLL_LOOP_HEAL_MAX`, default 2) or disabled (`ROLL_LOOP_NO_HEAL=1`) (exit 1):**
+
+   1. Keep story as ✅ Done — commits are already on main; CI red is a follow-up
+      problem, not a story failure.
+   2. Write ALERT to `~/.shared/roll/loop/ALERT.md` with:
+      - story ID, time, commit SHA
+      - heal attempts made (read `heal_count:` from `state.yaml`)
+      - last failure summary (head of `/tmp/roll-heal-<story_id>.log`)
+      - suggested actions: `$roll-fix` manually / inspect CI / `roll loop reset`
+   3. Skip to next story.
 
    **Bypass for debugging / cost control:** set `ROLL_LOOP_NO_HEAL=1` to restore
    pre-US-AUTO-041 fail-fast behaviour.
@@ -276,6 +285,11 @@ After each item completes:
 
 ### Step 5 — Write Run Summary
 
+> **FIX-044**: The inner runner script (`_write_loop_runner_script` in `bin/roll`)
+> now appends this record deterministically at cycle end. The shell write is the
+> authoritative record; the agent should still emit a run summary in the cycle's
+> final report for `cron.log` visibility.
+
 After all items in this cycle:
 
 ```yaml

package/skills/roll-peer/SKILL.md

@@ -65,6 +65,14 @@ Allowed states only. No invented words.
 - **OBJECT**: The proposal is wrong. Provide an alternative. Proceed to next round.
 - **ESCALATE**: Round 3 reached without AGREE, or a round fails due to API/token error. Hand off to the human user.
 
+After each round decision, emit a `peer` event to the cycle event stream:
+
+```bash
+# $round = current round number, $total = max rounds, $verdict = AGREE/REFINE/OBJECT/ESCALATE
+# $agents = e.g. "claude→deepseek"
+_loop_event peer "${round}/${total}" "$verdict" "$agents" 2>/dev/null || true
+```
+
 If information is insufficient:
 ```
 REFINE: Need to confirm X/Y/Z with the user first.