@zigrivers/scaffold 3.10.1 → 3.12.0

package/content/tools/post-implementation-review.md

@@ -208,17 +208,27 @@ Severity:
 Return ONLY valid JSON. No markdown, no explanation outside the JSON object.
 ```
 
+**Foreground only:** Always run Codex and Gemini CLI commands as foreground Bash calls. Never use `run_in_background`, `&`, or `nohup`. Background execution produces empty output.
+
 #### Channel 1: Codex CLI
 
-**Auth check first** (tokens expire — always re-verify):
+**Installation check first:**
+
+```bash
+command -v codex >/dev/null 2>&1 || echo "Codex not installed"
+```
+
+If not installed: queue a compensating pass (implementation correctness, security, API contracts, labeled `[compensating: Codex-equivalent]`). Skip to Channel 2.
+
+**Auth check** (tokens expire — always re-verify):
 
 ```bash
 codex login status 2>/dev/null && echo "codex authenticated" || echo "codex NOT authenticated"
 ```
 
-If not authenticated: tell the user "Codex auth expired. Run: `! codex login`".
-Do NOT silently skip. Retry after user re-authenticates.
-If Codex is not installed: skip this channel and note it in the report.
+If not authenticated: tell the user "Codex auth expired. Run: `! codex login`". Do NOT silently skip. Wait for re-auth and retry once. If auth cannot be recovered (auth_timeout or user declines): queue a compensating pass (implementation correctness, security, API contracts, labeled `[compensating: Codex-equivalent]`).
+
+If Codex fails during execution (non-zero exit, malformed output, timeout): queue a compensating pass with the same focus and label.
 
 **Run the review:**
 
@@ -230,15 +240,23 @@ Store the JSON output as `CODEX_PHASE1_FINDINGS`.
 
 #### Channel 2: Gemini CLI
 
-**Auth check first:**
+**Installation check first:**
+
+```bash
+command -v gemini >/dev/null 2>&1 || echo "Gemini not installed"
+```
+
+If not installed: queue a compensating pass (architectural patterns, design reasoning, broad context, labeled `[compensating: Gemini-equivalent]`). Skip to Channel 3.
+
+**Auth check:**
 
 ```bash
 NO_BROWSER=true gemini -p "respond with ok" -o json 2>&1
 ```
 
-If exit code is 41: tell the user "Gemini auth expired. Run: `! gemini -p \"hello\"`".
-Do NOT silently skip.
-If Gemini is not installed: skip this channel and note it in the report.
+If exit code is 41: tell the user "Gemini auth expired. Run: `! gemini -p \"hello\"`". Do NOT silently skip. Wait for re-auth and retry once. If auth cannot be recovered (auth_timeout or user declines): queue a compensating pass (architectural patterns, design reasoning, broad context, labeled `[compensating: Gemini-equivalent]`).
+
+If Gemini fails during execution (non-zero exit, malformed output, timeout): queue a compensating pass with the same focus and label.
 
 **Run the review (independent — do NOT include Codex output in this prompt):**
 
@@ -248,6 +266,8 @@ NO_BROWSER=true gemini -p "[PHASE 1 REVIEW PROMPT]" --output-format json --appro
 
 Store as `GEMINI_PHASE1_FINDINGS`.
 
+**After all Phase 1 channels:** Run any queued compensating passes. Record which channels were real, compensating, or skipped. This availability map is used for Phase 2.
+
 #### Channel 3: Superpowers Code-Reviewer
 
 Dispatch the `superpowers:code-reviewer` subagent. This channel always runs.
@@ -349,13 +369,21 @@ Acceptance Criteria:
 Run all three review channels. Each runs independently — do NOT share one channel's
 output with another.
 
+**Foreground only:** Always run Codex and Gemini CLI commands as foreground Bash calls. Never use `run_in_background`, `&`, or `nohup`. Background execution produces empty output.
+
+**Session-scoped channel availability:** Phase 1 has already probed channel installation and auth. Pass the Phase 1 channel availability results to each Phase 2 subagent. Subagents do NOT re-probe — if Codex was `auth failed` in Phase 1, every Phase 2 subagent treats Codex as unavailable and runs a compensating pass immediately.
+
+Phase 2 compensating passes adapt the focus to story context:
+- Missing Codex → focus compensating pass on implementation correctness and edge cases for this story's acceptance criteria.
+- Missing Gemini → focus compensating pass on design coherence and architectural alignment for this story.
+
 Channel 1 — Codex CLI:
-  Auth: codex login status 2>/dev/null
   Run: codex exec --skip-git-repo-check -s read-only --ephemeral "[PER-STORY PROMPT]" 2>/dev/null
+  (Only if Codex was available in Phase 1. Otherwise run compensating pass immediately.)
 
 Channel 2 — Gemini CLI (independent):
-  Auth: NO_BROWSER=true gemini -p "respond with ok" -o json 2>&1 (exit 41 = auth failure)
   Run: NO_BROWSER=true gemini -p "[PER-STORY PROMPT]" --output-format json --approval-mode yolo 2>/dev/null
+  (Only if Gemini was available in Phase 1. Otherwise run compensating pass immediately.)
 
 Channel 3 — Superpowers code-reviewer:
   Dispatch superpowers:code-reviewer with:
@@ -409,9 +437,14 @@ The per-story review prompt for Codex and Gemini:
 
 Normalize the Superpowers code-reviewer findings to the same JSON shape as
 Codex/Gemini (severity, acceptance_criterion, file, line, description, suggestion)
-before returning. Then return all three channels' findings:
+before returning. Then return all three channels' findings plus channel status:
 {
   "story": "[STORY_TITLE]",
+  "channel_status": {
+    "codex": { "root_cause": "null|not_installed|auth_failed|auth_timeout|failed", "coverage_status": "full|compensating" },
+    "gemini": { "root_cause": "null|not_installed|auth_failed|auth_timeout|failed", "coverage_status": "full|compensating" },
+    "superpowers": { "root_cause": null, "coverage_status": "full" }
+  },
   "codex": { "findings": [...] },
   "gemini": { "findings": [...] },
   "superpowers": { "findings": [...] }
@@ -448,7 +481,9 @@ Create `docs/reviews/` if it does not exist. Write the following to
 
 - **Date:** [YYYY-MM-DD]
 - **Mode:** [Review + Fix | Report Only | Update Mode | Re-review]
-- **Channels:** Codex [completed | skipped — reason] | Gemini [completed | skipped — reason] | Superpowers [completed]
+- **Coverage:** [full-coverage / degraded-coverage / partial-coverage]
+- **Channels (Phase 1):** Codex [completed | compensating | skipped — reason] | Gemini [completed | compensating | skipped — reason] | Superpowers [completed]
+- **Channels (Phase 2):** [N] stories reviewed, [N] with full channels, [N] with compensating passes
 - **Findings:** P0: [N] | P1: [N] | P2: [N] | P3: [N]
 - **Fixed:** [N findings fixed | N/A — report-only]
 
@@ -602,7 +637,9 @@ Output the completion summary:
 ```
 Post-implementation review complete.
 
-Channels: Codex [status] | Gemini [status] | Superpowers [completed]
+Coverage: [full-coverage / degraded-coverage / partial-coverage]
+Channels (Phase 1): Codex [completed|compensating|skipped — reason] | Gemini [completed|compensating|skipped — reason] | Superpowers [completed]
+Channels (Phase 2): [N] stories reviewed, [N] with full channels, [N] with compensating passes
 Findings: P0: [N] | P1: [N] | P2: [N] | P3: [N]
 Fixed: [N] | Remaining: [N]
 
@@ -616,23 +653,29 @@ the user they require manual attention before the project is ready to release.
 
 | Situation | Action |
 |-----------|--------|
-| Codex not installed | Skip Codex in all phases; document as "not installed" in report |
-| Gemini not installed | Skip Gemini in all phases; document as "not installed" in report |
-| Codex auth expired | Tell user: "Codex auth expired. Run: `! codex login`". Do NOT silently skip. Retry after re-auth. |
-| Gemini auth expired (exit 41) | Tell user: "Gemini auth expired. Run: `! gemini -p \"hello\"`". Do NOT silently skip. |
-| Neither CLI installed | Run Superpowers code-reviewer only; warn user that review coverage is reduced |
+| Codex not installed (`command -v` fails) | Queue compensating pass (implementation correctness, security, API contracts, labeled `[compensating: Codex-equivalent]`); document as "not_installed" in report |
+| Gemini not installed (`command -v` fails) | Queue compensating pass (architectural patterns, design reasoning, broad context, labeled `[compensating: Gemini-equivalent]`); document as "not_installed" in report |
+| Codex auth expired — user recovers | Re-run auth check; proceed with full Codex channel |
+| Codex auth expired — user declines or auth_timeout | Queue compensating pass (implementation correctness, security, API contracts, labeled `[compensating: Codex-equivalent]`); document as "auth_failed" or "auth_timeout" in report |
+| Gemini auth expired (exit 41) — user recovers | Re-run auth check; proceed with full Gemini channel |
+| Gemini auth expired — user declines or auth_timeout | Queue compensating pass (architectural patterns, design reasoning, broad context, labeled `[compensating: Gemini-equivalent]`); document as "auth_failed" or "auth_timeout" in report |
+| Channel fails during execution (non-zero exit, malformed output, timeout) | Queue compensating pass for that channel with same focus and label; document root cause in report |
+| Both external CLIs unavailable (any combination of not_installed / auth failure) | Run all compensating passes plus Superpowers code-reviewer; report coverage as "degraded-coverage"; warn user that review coverage is reduced |
+| Superpowers unavailable | Document as "unavailable" in report; proceed with remaining channels; Superpowers is a Claude subagent and should always be available |
 | `docs/user-stories.md` missing | Skip Phase 2; run Phase 1 only; warn user that functional review is incomplete |
 | `docs/coding-standards.md` missing | Proceed without it; note its absence in the report summary |
 
 ## Process Rules
 
-1. **All three channels are mandatory** — skip only when a tool is genuinely not installed, never by choice.
-2. **Auth failures are not silent** — always surface to the user with the exact recovery command.
-3. **Independence** — never share one channel's output with another. Each reviews independently.
-4. **Verify every fix** — run tests (or re-read the file) immediately after each fix before moving on.
-5. **3-round limit** — never attempt to fix the same finding more than 3 times. Surface unresolved findings to the user.
-6. **Document everything** — the report must show which channels ran, which were skipped, and why.
-7. **No auto-merge** — this tool modifies local files only. It never pushes, merges, or creates PRs.
+1. **Foreground only** — Always run Codex and Gemini CLI commands as foreground Bash calls. Never use `run_in_background`, `&`, or `nohup`. Background execution produces empty output.
+2. **All three channels are mandatory** — a channel enters degraded mode (compensating pass) when not installed, auth cannot be recovered, or it fails during execution. Never skip silently by choice.
+3. **Auth failures are not silent** — always surface to the user with the exact recovery command (`! codex login` or `! gemini -p "hello"`). Wait for user response before queuing a compensating pass.
+4. **Independence** — never share one channel's output with another. Each reviews independently.
+5. **Verify every fix** — run tests (or re-read the file) immediately after each fix before moving on.
+6. **3-round limit** — never attempt to fix the same finding more than 3 times. Surface unresolved findings to the user.
+7. **Document everything** — the report must show which channels ran, which were compensating, which were skipped, and the root cause for any degraded channel.
+8. **No auto-merge** — this tool modifies local files only. It never pushes, merges, or creates PRs.
+9. **Dispatch pattern cross-reference** — Phase 2 parallel dispatch uses `superpowers:dispatching-parallel-agents`. Each story subagent dispatches its own `superpowers:code-reviewer` as Channel 3. This two-level nesting is intentional and supported.
 
 ## After This Step
 
@@ -642,7 +685,9 @@ When the review is complete, tell the user:
 **Post-implementation review complete.**
 
 Results:
-- Channels run: [list which ran in Phase 1 and Phase 2]
+- Coverage: [full-coverage / degraded-coverage / partial-coverage]
+- Channels (Phase 1): Codex [completed|compensating|skipped — reason] | Gemini [completed|compensating|skipped — reason] | Superpowers [completed]
+- Channels (Phase 2): [N] stories reviewed, [N] with full channels, [N] with compensating passes
 - Phase 1 (systemic): [N] findings — [N] fixed, [N] remaining
 - Phase 2 (functional): [N] findings across [N] stories — [N] fixed, [N] remaining
 - Report: `docs/reviews/post-implementation-review.md`

package/content/tools/prompt-pipeline.md

@@ -159,6 +159,7 @@ Print the following reference directly. Do not read any files or run any command
 | **Resume (multi)** | `/scaffold:multi-agent-resume <agent-name>` | Resuming a worktree agent after a break |
 | **Version Bump** | `/scaffold:version-bump` | Bump version + changelog (no tag/release) |
 | **Release** | `/scaffold:release` | Project-defined release ceremony with changelog + relevant release artifacts |
+| **Spark** | `/scaffold:spark` | Explore and expand a raw project idea |
 | **Visual Dashboard** | `/scaffold:dashboard` | HTML pipeline overview in browser |
 
 ## Process Rules

package/content/tools/review-code.md

@@ -159,6 +159,8 @@ Format the changed-file context like:
 
 Each channel reviews independently. Do NOT share one channel's output with another.
 
+**Foreground only:** Always run Codex and Gemini CLI commands as foreground Bash calls. Never use `run_in_background`, `&`, or `nohup`. Background execution produces empty output. Multiple foreground calls in a single message are fine.
+
 #### Channel 1: Codex CLI
 
 Check installation and auth:
@@ -168,8 +170,10 @@ command -v codex >/dev/null 2>&1
 codex login status 2>/dev/null
 ```
 
-- If `codex` is not installed: skip this channel and record `skipped (not installed)`
-- If auth fails: tell the user to run `! codex login`, retry after recovery, and if recovery is not possible, record `skipped (auth failed)` and continue with the remaining channels
+- If `codex` is not installed: skip this channel and record root-cause `not_installed`
+- If auth fails: tell the user to run `! codex login`, retry after recovery, and if recovery is not possible, record root-cause `auth_failed` and continue with the remaining channels
+
+If auth cannot be recovered, or if Codex is not installed, queue a compensating Claude self-review pass focused on implementation correctness, security, and API contracts. Label findings as `[compensating: Codex-equivalent]`. If auth check times out (~5s), retry once; if still failing, record `auth timeout` and queue compensating pass. This pass runs after all channel dispatch attempts complete.
 
 Build the prompt in a temporary file and pass it over stdin:
 
@@ -179,6 +183,8 @@ PROMPT_FILE=$(mktemp)
 codex exec --skip-git-repo-check -s read-only --ephemeral - < "$PROMPT_FILE" 2>/dev/null
 ```
 
+If the CLI exits with a non-zero code, produces malformed/unparseable output, or is killed by the tool runner timeout, record root-cause `failed` and queue a compensating pass for that channel.
+
 #### Channel 2: Gemini CLI
 
 Check installation and auth:
@@ -188,8 +194,10 @@ command -v gemini >/dev/null 2>&1
 NO_BROWSER=true gemini -p "respond with ok" -o json 2>&1
 ```
 
-- If `gemini` is not installed: skip this channel and record `skipped (not installed)`
-- If auth fails (including exit 41): tell the user to run `! gemini -p "hello"`, retry after recovery, and if recovery is not possible, record `skipped (auth failed)` and continue with the remaining channels
+- If `gemini` is not installed: skip this channel and record root-cause `not_installed`
+- If auth fails (including exit 41): tell the user to run `! gemini -p "hello"`, retry after recovery, and if recovery is not possible, record root-cause `auth_failed` and continue with the remaining channels
+
+If auth cannot be recovered, or if Gemini is not installed, queue a compensating Claude self-review pass focused on architectural patterns, design reasoning, and broad context. Label findings as `[compensating: Gemini-equivalent]`. If auth check times out (~5s), retry once; if still failing, record `auth timeout` and queue compensating pass. This pass runs after all channel dispatch attempts complete.
 
 Build the prompt in a temporary file and pass it as a single prompt string:
 
@@ -199,6 +207,8 @@ PROMPT_FILE=$(mktemp)
 NO_BROWSER=true gemini -p "$(cat "$PROMPT_FILE")" --output-format json --approval-mode yolo 2>/dev/null
 ```
 
+If the CLI exits with a non-zero code, produces malformed/unparseable output, or is killed by the tool runner timeout, record root-cause `failed` and queue a compensating pass for that channel.
+
 #### Channel 3: Superpowers code-reviewer
 
 Dispatch the `superpowers:code-reviewer` subagent.
@@ -213,6 +223,8 @@ Dispatch the `superpowers:code-reviewer` subagent.
 This channel must review the same local delivery candidate, even when no PR or
 clean ref range exists.
 
+**After all channels:** Run any queued compensating passes as foreground Claude self-review passes. Each compensating pass uses the same review prompt as the missing channel, focusing on that channel's strength area.
+
 ### Step 5: Use This Review Prompt
 
 All channels should receive an equivalent prompt bundle built from the local review scope:
@@ -270,6 +282,7 @@ Use these rules:
 | Any single P2 | Fix unless clearly inapplicable; if disputed, surface to user |
 | All executed channels approve | Candidate passes review |
 | Strong contradiction on a medium-severity issue | Verdict becomes `needs-user-decision` |
+| Compensating-pass P0/P1/P2 finding | Single-source confidence — fix per normal thresholds, but label as compensating in summary |
 
 ### Step 7: Apply Fixes Unless in Report-Only Mode
 
@@ -284,14 +297,18 @@ Otherwise:
 3. Repeat for up to 3 fix rounds
 4. If any finding remains unresolved after 3 rounds, stop with verdict `needs-user-decision`
 
+**Fix cycle channel rule:** Re-run only channels that originally completed or ran as compensating passes. Never retry a channel marked `not installed`, `auth failed`, or `auth timeout` during fix rounds — its availability does not change within a session.
+
 ### Step 8: Final Verdict
 
 Return exactly one verdict:
 
-- `pass` — all available channels ran and no unresolved P0/P1/P2 findings remain
-- `degraded-pass` — at least one channel was skipped because the tool is not installed or auth could not be recovered, but all executed channels passed
-- `blocked` — reviewer execution failure or unresolved mandatory findings
-- `needs-user-decision` — reviewer disagreement or findings still unresolved after 3 fix rounds
+- `pass` — all channels completed with `full` coverage, no unresolved P0/P1/P2
+- `degraded-pass` — at least one channel was skipped/compensated (coverage is not all `full`), but all executed and compensating channels have no unresolved P0/P1/P2
+- `blocked` — unresolved P0/P1/P2 findings remain after 3 fix rounds, OR no reconciled result was possible
+- `needs-user-decision` — reviewer disagreement on a finding, or findings still unresolved after 3 rounds that require human judgment
+
+When compensating passes ran for any channel, the maximum achievable verdict is `degraded-pass` — never `pass`, even if all findings are resolved. When both external channels were compensated, the review summary must note: "All findings are single-model (Claude only)."
 
 ### Step 9: Report Results
 
@@ -304,9 +321,9 @@ Output a concise summary in this format:
 [scope label]
 
 ### Channels Executed
-- Codex CLI — [completed / skipped (not installed) / skipped (auth failed) / error]
-- Gemini CLI — [completed / skipped (not installed) / skipped (auth failed) / error]
-- Superpowers code-reviewer — [completed / error]
+- Codex CLI — root cause: [completed / not installed / auth failed / auth timeout / failed], coverage: [full / compensating (Codex-equivalent)]
+- Gemini CLI — root cause: [completed / not installed / auth failed / auth timeout / failed], coverage: [full / compensating (Gemini-equivalent)]
+- Superpowers code-reviewer — [completed / failed]
 
 ### Findings
 [consensus findings first, then single-source findings]
@@ -317,3 +334,12 @@ Output a concise summary in this format:
 
 If the verdict is `pass` or `degraded-pass`, explicitly say the code is ready
 for the next delivery step (commit, push, or PR creation).
+
+## Process Rules
+
+1. **Foreground only** — Always run Codex and Gemini CLI commands as foreground Bash calls. Never use `run_in_background`, `&`, or `nohup`.
+2. **All 3 channels are mandatory** — skip only when a tool is genuinely not installed, never by choice.
+3. **Auth failures are not silent** — always surface to the user with recovery instructions.
+4. **Independence** — never share one channel's output with another.
+5. **Fix before proceeding** — P0/P1/P2 findings must be resolved before moving to the next task.
+6. **Dispatch pattern** follows `multi-model-review-dispatch` knowledge entry. When modifying channel dispatch in this file, verify consistency with `review-pr.md` and `post-implementation-review.md`.

package/content/tools/review-pr.md

@@ -66,18 +66,28 @@ Read these files for review context (skip any that don't exist):
 
 Run all three channels. Track which ones complete successfully.
 
+**Foreground only:** Always run Codex and Gemini CLI commands as foreground Bash calls. Never use `run_in_background`, `&`, or `nohup`. Background execution produces empty output.
+
 #### Channel 1: Codex CLI
 
+**Installation check:**
+```bash
+command -v codex >/dev/null 2>&1
+```
+- If `codex` is not installed: queue a compensating Claude self-review pass focused on implementation correctness, security, and API contracts. Record root-cause `not_installed`. Skip to next channel.
+
 **Auth check first** (auth tokens expire — always re-verify):
 
 ```bash
 codex login status 2>/dev/null && echo "codex authenticated" || echo "codex NOT authenticated"
 ```
 
-If Codex is not installed, skip this channel and note it in the summary.
 If auth fails, tell the user: "Codex auth expired. Run: `! codex login`" — do NOT
 silently fall back. After the user re-authenticates, retry.
 
+If auth cannot be recovered, queue a compensating pass (same focus as above). Record root-cause `auth_failed`.
+If auth check times out (~5s), retry once. If still failing, record root-cause `auth_timeout` and queue compensating pass.
+
 **Run the review:**
 
 ```bash
@@ -90,8 +100,16 @@ The review prompt must include:
 - Review standards from docs/review-standards.md (if exists)
 - Instruction to report P0/P1/P2 findings as JSON with severity, location (file:line), description, and suggestion
 
+If the CLI exits with a non-zero code, produces malformed/unparseable output, or is killed by the tool runner timeout, record root-cause `failed` and queue a compensating pass for that channel.
+
 #### Channel 2: Gemini CLI
 
+**Installation check:**
+```bash
+command -v gemini >/dev/null 2>&1
+```
+- If `gemini` is not installed: queue a compensating Claude self-review pass focused on architectural patterns, design reasoning, and broad context. Record root-cause `not_installed`. Label findings as `[compensating: Gemini-equivalent]`. Skip to next channel.
+
 **Auth check first:**
 
 ```bash
@@ -104,9 +122,11 @@ elif [ "$GEMINI_EXIT" -eq 41 ]; then
 fi
 ```
 
-If Gemini is not installed, skip this channel and note it in the summary.
 If auth fails (exit 41), tell the user: "Gemini auth expired. Run: `! gemini -p \"hello\"`" — do NOT silently fall back. After the user re-authenticates, retry.
 
+If auth cannot be recovered, queue a compensating pass focused on architectural patterns, design reasoning, and broad context. Record root-cause `auth_failed`. Label findings as `[compensating: Gemini-equivalent]`.
+If auth check times out (~5s), retry once. If still failing, record root-cause `auth_timeout` and queue compensating pass labeled `[compensating: Gemini-equivalent]`.
+
 **Run the review:**
 
 ```bash
@@ -116,6 +136,8 @@ NO_BROWSER=true gemini -p "REVIEW_PROMPT" --output-format json --approval-mode y
 Same review prompt content as Codex. Do NOT share one model's output with the other —
 each reviews independently.
 
+If the CLI exits with a non-zero code, produces malformed/unparseable output, or is killed by the tool runner timeout, record root-cause `failed` and queue a compensating pass for that channel.
+
 #### Channel 3: Superpowers Code-Reviewer Subagent
 
 Dispatch the `superpowers:code-reviewer` subagent. This channel always runs (it uses
@@ -134,6 +156,8 @@ providing:
 - `HEAD_SHA` — head commit
 - `DESCRIPTION` — PR summary
 
+**After all channels:** Run any queued compensating passes as foreground Claude self-review passes. Each uses the same review prompt as the missing channel, focused on that channel's strength area. Label findings as `[compensating: Codex-equivalent]` or `[compensating: Gemini-equivalent]`.
+
 ### Step 4: Reconcile Findings
 
 After all channels complete, reconcile findings:
@@ -145,6 +169,7 @@ After all channels complete, reconcile findings:
 | One channel flags P0, others approve | **High** | Fix it — P0 is critical from any source |
 | One channel flags P1, others approve | **Medium** | Fix it — P1 findings are mandatory regardless of source count |
 | Channels contradict each other | **Low** | Present to user for adjudication |
+| Compensating-pass P0/P1/P2 finding | **Single-source** | Fix per normal thresholds, label as compensating |
 
 ### Step 5: Report Results
 
@@ -154,9 +179,9 @@ Output a review summary in this format:
 ## Code Review Summary — PR #[number]
 
 ### Channels Executed
-- [ ] Codex CLI — [completed / skipped (not installed) / skipped (auth failed) / error]
-- [ ] Gemini CLI — [completed / skipped (not installed) / skipped (auth failed) / error]
-- [ ] Superpowers code-reviewer — [completed / error]
+- [ ] Codex CLI — root cause: [completed / not installed / auth failed / auth timeout / failed], coverage: [full / compensating (Codex-equivalent)]
+- [ ] Gemini CLI — root cause: [completed / not installed / auth failed / auth timeout / failed], coverage: [full / compensating (Gemini-equivalent)]
+- [ ] Superpowers code-reviewer — [completed / failed]
 
 ### Consensus Findings (High Confidence)
 [Findings flagged by 2+ channels]
@@ -168,9 +193,22 @@ Output a review summary in this format:
 [Contradictions between channels]
 
 ### Verdict
-[All channels approve / Fix required (list P0/P1/P2 items) / User adjudication needed]
+[pass / degraded-pass / blocked / needs-user-decision]
 ```
 
+### Step 5a: Final Verdict
+
+Return exactly one verdict:
+
+- `pass` — all channels ran, no unresolved P0/P1/P2
+- `degraded-pass` — channels skipped/compensated, no unresolved P0/P1/P2
+- `blocked` — unresolved P0/P1/P2 after 3 fix rounds
+- `needs-user-decision` — contradictions or unresolvable findings
+
+Verdict precedence: `needs-user-decision` > `blocked` > `degraded-pass` > `pass`.
+
+When compensating passes ran, maximum achievable verdict is `degraded-pass`. When both external channels were compensated, note "All findings are single-model."
+
 ### Step 6: Fix P0/P1/P2 Findings
 
 If any P0, P1, or P2 findings exist:
@@ -179,12 +217,14 @@ If any P0, P1, or P2 findings exist:
 3. Re-run the channels that produced findings to verify fixes
 4. After 3 fix rounds with unresolved P0/P1/P2 findings, stop and ask the user for direction — do NOT merge automatically. Document remaining findings and let the user decide whether to continue fixing, create follow-up issues, or override.
 
+**Fix cycle channel rule:** Re-run only channels that originally completed or ran as compensating passes. Never retry a channel marked `not installed`, `auth failed`, or `auth timeout` during fix rounds — its availability does not change within a session.
+
 ### Step 7: Confirm Completion
 
 After all findings are resolved (or 3 rounds complete), output:
 
 ```
-Code review complete. All 3 channels executed. PR #[number] is ready for merge.
+Code review complete. Verdict: [pass/degraded-pass]. Channels: [N] executed, [N] compensating. PR #[number] is ready for merge.
 ```
 
 Do NOT proceed to the next task or merge until this confirmation is output.
@@ -193,19 +233,24 @@ Do NOT proceed to the next task or merge until this confirmation is output.
 
 | Situation | Action |
 |-----------|--------|
-| Neither Codex nor Gemini installed | Run Superpowers code-reviewer only; document as "single-channel review" |
-| One CLI installed, one not | Run available CLI + Superpowers; document missing channel |
-| CLI auth expired | Surface to user with recovery command; do NOT silently skip |
-| Superpowers plugin not installed | Run both CLIs; warn user to install superpowers plugin |
-| All external channels unavailable | Superpowers code-reviewer only; warn user that review coverage is reduced |
+| Channel not installed | Queue compensating pass, report root-cause `not_installed` |
+| Auth expired, user recovers | Retry dispatch |
+| Auth expired, user declines | Queue compensating pass, report root-cause `auth_failed` |
+| Auth check timeout (after retry) | Queue compensating pass, report root-cause `auth_timeout` |
+| Channel fails during execution | Queue compensating pass, report root-cause `failed` |
+| Both external channels unavailable | Two compensating passes, max verdict: `degraded-pass`, note "All findings single-model" |
+| Superpowers unavailable | Run available CLIs, warn user (Superpowers is always-available Claude — no compensating pass) |
 
 ## Process Rules
 
-1. **All three channels are mandatory** — skip only when the tool is genuinely unavailable (not installed), never by choice.
-2. **Auth failures are not silent** — always surface to the user with recovery instructions.
-3. **Independence** — never share one channel's output with another. Each reviews the diff independently.
-4. **Fix before proceeding** — P0/P1/P2 findings must be resolved before moving to the next task.
-5. **Document everything** — the review summary must show which channels ran and which were skipped, with reasons.
+1. **Foreground only** — Always run Codex and Gemini CLI commands as foreground Bash calls. Never use `run_in_background`, `&`, or `nohup`.
+2. **All three channels are mandatory** — skip only when a tool is genuinely not installed, never by choice.
+3. **Auth failures are not silent** — always surface to the user with the exact recovery command.
+4. **Independence** — never share one channel's output with another. Each reviews the diff independently.
+5. **Fix before proceeding** — P0/P1/P2 findings must be resolved before moving to the next task.
+6. **3-round limit** — never attempt more than 3 fix rounds. Surface unresolved findings to the user.
+7. **Document everything** — the review summary must show which channels ran and which were skipped, with reasons.
+8. **Dispatch pattern** follows `multi-model-review-dispatch` knowledge entry. When modifying channel dispatch in this file, verify consistency with `review-code.md` and `post-implementation-review.md`.
 
 ---
 
@@ -214,16 +259,13 @@ Do NOT proceed to the next task or merge until this confirmation is output.
 When code review is complete, tell the user:
 
 ---
-**Code review complete** — All channels executed for PR #[number].
+**Code review complete** — Verdict: [pass/degraded-pass]. All channels executed for PR #[number].
 
 **Results:**
-- Channels run: [list which of the 3 ran]
+- Channels run: [list which of the 3 ran, noting any compensating]
 - Findings fixed: [count]
 - Remaining: [none / list]
 
-**Next:** Return to the task execution loop — mark the task complete and pick up
-the next unblocked task with `/scaffold:single-agent-start`.
-
-**Pipeline reference:** `/scaffold:prompt-pipeline`
+**Next:** Return to the task execution loop.
 
 ---