codebyplan 1.10.3 → 1.11.1

package/templates/hooks/cbp-subagent-statusline.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+# @hook: NOT-A-HOOK (subagentStatusLine renderer, invoked via the cbp-subagent-statusline.sh dispatcher)
+# Claude Code Subagent Status Line — python renderer. Byte-identical output to the
+# bash renderer in cbp-subagent-statusline.sh and the node renderer in
+# cbp-subagent-statusline.mjs. Output protocol: one {"id":...,"content":...} JSON
+# line per task. See the .sh file for the full option/env/seam contract.
+# Never throws to stdout.
+
+import json
+import math
+import os
+import sys
+import time
+
+
+def main():
+    raw_input = sys.stdin.read()
+    try:
+        data = json.loads(raw_input)
+    except Exception:
+        data = {}
+    if not isinstance(data, dict):
+        data = {}
+
+    root = os.environ.get("CBP_STATUSLINE_ROOT") or (sys.argv[1] if len(sys.argv) > 1 else "")
+    if not root:
+        root = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", ".."))
+
+    try:
+        columns = math.trunc(float(data.get("columns") or 0))
+    except (TypeError, ValueError):
+        columns = 0
+    tasks = data.get("tasks")
+    if not isinstance(tasks, list):
+        tasks = []
+
+    # ---- Config: no_color from statusline.json -------------------------------
+    cfg_no_color = False
+    try:
+        with open(os.path.join(root, ".codebyplan", "statusline.json"), "r", encoding="utf-8") as fh:
+            parsed = json.load(fh)
+        if isinstance(parsed, dict) and isinstance(parsed.get("no_color"), bool):
+            cfg_no_color = parsed["no_color"]
+    except Exception:
+        pass
+
+    no_color = (
+        (os.environ.get("NO_COLOR") not in (None, ""))
+        or os.environ.get("CBP_SUBAGENT_STATUSLINE_NO_COLOR") == "1"
+        or cfg_no_color is True
+    )
+    if no_color:
+        RST = DIM = BOLD = GREEN = RED = BLUE = ""
+    else:
+        RST = "\x1b[0m"
+        DIM = "\x1b[2m"
+        BOLD = "\x1b[1m"
+        GREEN = "\x1b[32m"
+        RED = "\x1b[31m"
+        BLUE = "\x1b[34m"
+
+    def fmt_k(val):
+        v = float(val)
+        if v >= 1000000:
+            t = math.floor((v + 50000) / 100000)
+            return "%d.%dM" % (t // 10, t % 10)
+        elif v >= 1000:
+            t = math.floor((v + 50) / 100)
+            return "%d.%dK" % (t // 10, t % 10)
+        return str(int(v))
+
+    def cbp_now():
+        nv = os.environ.get("CBP_STATUSLINE_NOW")
+        if nv not in (None, ""):
+            return math.trunc(float(nv))
+        return math.floor(time.time())
+
+    def fmt_age_secs(start):
+        delta = cbp_now() - math.trunc(float(start))
+        if delta < 0:
+            delta = 0
+        if delta >= 3600:
+            return "%dh%dm" % (delta // 3600, (delta % 3600) // 60)
+        if delta >= 60:
+            return "%dm%ds" % (delta // 60, delta % 60)
+        return "%ds" % delta
+
+    def is_ascii_letter(b):
+        return (0x41 <= b <= 0x5A) or (0x61 <= b <= 0x7A)
+
+    def truncate(rendered):
+        # ANSI-aware byte-based truncation — mirrors the bash byte walk exactly.
+        if not (columns > 0):
+            return rendered
+        buf = rendered.encode("utf-8")
+        raw_len = len(buf)
+        target = columns - 3
+        if target < 0:
+            target = 0
+        vis = 0
+        i = 0
+        in_esc = False
+        while i < raw_len and vis < target:
+            b = buf[i]
+            if in_esc:
+                if is_ascii_letter(b):
+                    in_esc = False
+            elif b == 0x1B:
+                in_esc = True
+            else:
+                vis += 1
+            i += 1
+        while i < raw_len:
+            b = buf[i]
+            if in_esc:
+                if is_ascii_letter(b):
+                    in_esc = False
+                i += 1
+            elif b == 0x1B:
+                in_esc = True
+                i += 1
+            else:
+                break
+        if i < raw_len:
+            head = buf[:i]
+            tail = (RST + "...").encode("utf-8")
+            return (head + tail).decode("utf-8", errors="replace")
+        return rendered
+
+    out = []
+    for task in tasks:
+        if not isinstance(task, dict):
+            continue
+        t_id = "" if task.get("id") is None else str(task.get("id"))
+        if t_id == "":
+            continue
+        t_name = "" if task.get("name") is None else str(task.get("name"))
+        t_type = "" if task.get("type") is None else str(task.get("type"))
+        t_status = "" if task.get("status") is None else str(task.get("status"))
+        t_desc = "" if task.get("description") is None else str(task.get("description"))
+        try:
+            t_start = math.trunc(float(task.get("startTime") or 0))
+        except (TypeError, ValueError):
+            t_start = 0
+        try:
+            t_tokens = math.trunc(float(task.get("tokenCount") or 0))
+        except (TypeError, ValueError):
+            t_tokens = 0
+
+        if t_status == "running":
+            icon = "%s●%s" % (GREEN, RST)
+        elif t_status == "pending":
+            icon = "%s○%s" % (DIM, RST)
+        elif t_status == "completed":
+            icon = "%s✓%s" % (BLUE, RST)
+        elif t_status == "failed":
+            icon = "%s✗%s" % (RED, RST)
+        else:
+            icon = "%s•%s" % (DIM, RST)
+
+        row = "%s %s%s%s" % (icon, BOLD, t_name, RST)
+        if t_type:
+            row += " %s(%s)%s" % (DIM, t_type, RST)
+        if os.environ.get("CBP_SUBAGENT_STATUSLINE_HIDE_DESCRIPTION") != "1" and t_desc:
+            row += " %s—%s %s" % (DIM, RST, t_desc)
+        if os.environ.get("CBP_SUBAGENT_STATUSLINE_HIDE_TOKENS") != "1" and t_tokens > 0:
+            row += " %s·%s %stokens:%s%s" % (DIM, RST, DIM, RST, fmt_k(t_tokens))
+        if t_start > 0:
+            row += " %s·%s %sage:%s%s" % (DIM, RST, DIM, RST, fmt_age_secs(t_start))
+
+        rendered = truncate(row)
+        out.append(
+            '{"id":%s,"content":%s}'
+            % (json.dumps(t_id, ensure_ascii=False), json.dumps(rendered, ensure_ascii=False))
+        )
+
+    sys.stdout.write(("\n".join(out) + "\n") if out else "")
+
+
+try:
+    main()
+except Exception:
+    sys.exit(0)

package/templates/hooks/cbp-subagent-statusline.sh

@@ -1,22 +1,65 @@
 #!/bin/bash
 # Portability: bash 3.2+ (macOS default /bin/bash). UTF-8 multibyte chars in
 # user-controlled fields are byte-iterated under 3.2 (over-counts visible width
-# for non-ASCII content); acceptable safe-direction approximation.
-# @hook: NOT-A-HOOK (subagentStatusLine renderer, invoked by settings.json subagentStatusLine.command)
-# Claude Code Subagent Status Line — one JSON line per active subagent
-# Purpose: Renders one row per running subagent. Output protocol per upstream docs:
+# for non-ASCII content); acceptable safe-direction approximation — and the node
+# (.mjs) / python (.py) renderers iterate the SAME UTF-8 bytes so all three agree.
+# @hook: NOT-A-HOOK (subagentStatusLine renderer, invoked via settings.json subagentStatusLine.command)
+# Claude Code Subagent Status Line — multi-runtime dispatcher + bash renderer.
+# One JSON line per active subagent. Output protocol per upstream docs:
 #   {"id": "<task_id>", "content": "<rendered_body>"}
 #   - Omitted tasks keep their default Claude Code rendering
 #   - Empty content strings hide the row
 # NOT a PreToolUse/PostToolUse/Notification hook — do NOT register in hooks[].
 #
-# ENV-VAR TOGGLES — set to 1 to suppress a column / color
+# RENDERER SELECTION (per-device, gitignored .codebyplan/statusline.local.json):
+#   { "renderer": "bash" | "node" | "python" }  — default bash, falls back to bash
+#   when the chosen runtime is unavailable. Set via `codebyplan statusline …`.
+#
+# CONFIG: honours `no_color` from the committed .codebyplan/statusline.json. The six
+#   main-statusline line toggles do NOT apply to subagent rows.
+#
+# ENV-VAR OVERRIDES (env > config > default)
 #   CBP_SUBAGENT_STATUSLINE_HIDE_DESCRIPTION=1   omit DESCRIPTION segment
 #   CBP_SUBAGENT_STATUSLINE_HIDE_TOKENS=1        omit tokens:N segment
 #   CBP_SUBAGENT_STATUSLINE_NO_COLOR=1           strip all ANSI codes (also honoured by $NO_COLOR)
+#
+# TEST SEAMS (no effect in normal use)
+#   CBP_STATUSLINE_ROOT=<dir>   override the .codebyplan/ lookup root (default: repo root)
+#   CBP_STATUSLINE_NOW=<epoch>  override "now" for age rendering (determinism)
+
+# ============================================================
+# DISPATCHER — resolve root + renderer, delegate when possible
+# ============================================================
+CBP_HOOK_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd 2>/dev/null)" || CBP_HOOK_DIR="."
+CBP_ROOT="${CBP_STATUSLINE_ROOT:-}"
+if [ -z "$CBP_ROOT" ]; then
+  CBP_ROOT="$(cd "$CBP_HOOK_DIR/../.." && pwd 2>/dev/null)" || CBP_ROOT="$PWD"
+fi
+
+CBP_RENDERER="bash"
+CBP_LOCAL_CFG="$CBP_ROOT/.codebyplan/statusline.local.json"
+if [ -f "$CBP_LOCAL_CFG" ] && command -v jq >/dev/null 2>&1; then
+  _r="$(jq -r '.renderer // empty' "$CBP_LOCAL_CFG" 2>/dev/null)"
+  case "$_r" in bash|node|python) CBP_RENDERER="$_r" ;; esac
+fi
+
+if [ "$CBP_RENDERER" = "node" ] && command -v node >/dev/null 2>&1 \
+   && [ -f "$CBP_HOOK_DIR/cbp-subagent-statusline.mjs" ]; then
+  CBP_STATUSLINE_ROOT="$CBP_ROOT" exec node "$CBP_HOOK_DIR/cbp-subagent-statusline.mjs"
+fi
+if [ "$CBP_RENDERER" = "python" ] && command -v python3 >/dev/null 2>&1 \
+   && [ -f "$CBP_HOOK_DIR/cbp-subagent-statusline.py" ]; then
+  CBP_STATUSLINE_ROOT="$CBP_ROOT" exec python3 "$CBP_HOOK_DIR/cbp-subagent-statusline.py"
+fi
+# Fall through → inline bash renderer (default + universal fallback).
 
 INPUT=$(cat)
 
+# Byte-deterministic string ops: force the C locale so the truncation walk below
+# counts UTF-8 BYTES (locale-independent), matching the .mjs/.py byte iteration.
+# Output bytes are unaffected (multibyte content passes through verbatim).
+export LC_ALL=C
+
 # One jq pass for base fields (cwd, session_id, columns)
 eval "$(echo "$INPUT" | jq -r '
   @sh "CWD=\(.cwd // "")",
@@ -24,9 +67,17 @@ eval "$(echo "$INPUT" | jq -r '
   @sh "COLUMNS=\(.columns // 0)"
 ')"
 
-# ---- Colour setup ----------------------------------------------------------
+# ---- Config: no_color from .codebyplan/statusline.json -----------------------
+CFG_NO_COLOR=false
+CBP_CFG="$CBP_ROOT/.codebyplan/statusline.json"
+if [ -f "$CBP_CFG" ] && command -v jq >/dev/null 2>&1; then
+  # `== true` (NOT jq `//`): only an explicit true enables no_color.
+  eval "$(jq -r '"CFG_NO_COLOR=\(.no_color == true)"' "$CBP_CFG" 2>/dev/null)"
+fi
+
+# ---- Colour setup (env > config) ---------------------------------------------
 # Only the colours referenced by the render block below are defined here.
-if [ -n "${NO_COLOR:-}" ] || [ "${CBP_SUBAGENT_STATUSLINE_NO_COLOR:-0}" = "1" ]; then
+if [ -n "${NO_COLOR:-}" ] || [ "${CBP_SUBAGENT_STATUSLINE_NO_COLOR:-0}" = "1" ] || [ "$CFG_NO_COLOR" = "true" ]; then
   RST=''; DIM=''; BOLD=''; GREEN=''; RED=''; BLUE=''
 else
   RST='\033[0m'
@@ -37,25 +88,29 @@ else
   BLUE='\033[34m'
 fi
 
-# ---- Token/size formatter K / M (verbatim from cbp-statusline.sh L96-105) ---
+# ---- Token/size formatter K / M — integer round-half-up (cross-runtime) ------
 fmt_k() {
   local val=$1
   if [ "$val" -ge 1000000 ] 2>/dev/null; then
-    printf "%.1fM" "$(echo "$val / 1000000" | bc -l)"
+    local t=$(( (val + 50000) / 100000 ))
+    printf "%d.%dM" $(( t / 10 )) $(( t % 10 ))
   elif [ "$val" -ge 1000 ] 2>/dev/null; then
-    printf "%.1fK" "$(echo "$val / 1000" | bc -l)"
+    local t=$(( (val + 50) / 100 ))
+    printf "%d.%dK" $(( t / 10 )) $(( t % 10 ))
   else
     printf "%d" "$val"
   fi
 }
 
-# ---- Age formatter: epoch seconds → "Xs" / "XmYs" / "XhYm" -----------------
-# NEW helper — cannot reuse fmt_dur (which divides by 1000 for ms input).
-# startTime is a Unix epoch in seconds, same as rate_limits.*.resets_at.
+# ---- "now" with test seam ----------------------------------------------------
+cbp_now() {
+  if [ -n "${CBP_STATUSLINE_NOW:-}" ]; then printf '%s' "$CBP_STATUSLINE_NOW"; else date +%s; fi
+}
+
+# ---- Age formatter: epoch seconds → "Xs" / "XmYs" / "XhYm" ------------------
 fmt_age_secs() {
   local start=$1
-  local now
-  now=$(date +%s)
+  local now; now=$(cbp_now)
   local delta=$(( now - start ))
   [ "$delta" -lt 0 ] && delta=0
   if [ "$delta" -ge 3600 ]; then
@@ -67,18 +122,16 @@ fmt_age_secs() {
   fi
 }
 
-# ---- Strip ANSI codes for visible-length measurement (column truncation) ----
-strip_ansi() {
-  printf '%s' "$1" | sed $'s/\033\\[[0-9;]*m//g'
-}
-
 # ---- JSON-string-escape a bash variable (embed in {"id":..., "content":...}) -
 json_escape() {
   printf '%s' "$1" | jq -Rs '.'
 }
 
-# ---- Per-task render: one jq TSV emission, looped in bash ------------------
-# Single jq pass for tasks[] (locked decision #3 — two jq calls total).
+# ---- Per-task render: one jq US-delimited emission, looped in bash ----------
+# Join with the Unit Separator (U+001F, non-whitespace) rather than @tsv: a tab is
+# IFS-whitespace, so `IFS=$'\t' read` collapses consecutive tabs and an EMPTY field
+# (e.g. blank description) would shift every later field. US is non-whitespace, so
+# empty fields are preserved — matching the .mjs/.py object iteration.
 echo "$INPUT" | jq -r '
   .tasks // [] | .[] | [
     .id // "",
@@ -88,8 +141,8 @@ echo "$INPUT" | jq -r '
     .description // "",
     (.startTime // 0 | tostring),
     (.tokenCount // 0 | tostring)
-  ] | @tsv
-' | while IFS=$'\t' read -r T_ID T_NAME T_TYPE T_STATUS T_DESC T_START T_TOKENS; do
+  ] | join("\u001f")
+' | while IFS=$'\037' read -r T_ID T_NAME T_TYPE T_STATUS T_DESC T_START T_TOKENS; do
   # Skip blank rows (empty tasks[] → no output)
   [ -z "$T_ID" ] && continue
 
@@ -123,14 +176,12 @@ echo "$INPUT" | jq -r '
   # Apply printf to interpret escape sequences, then truncate to $COLUMNS
   RENDERED=$(printf '%b' "$ROW")
   if [ "$COLUMNS" -gt 0 ] 2>/dev/null; then
-    # ANSI-aware iterative truncation: walk RENDERED char-by-char treating
-    # \033[...letter escape sequences as zero-width and ordinary chars as
+    # ANSI-aware iterative truncation: walk RENDERED byte-by-byte treating
+    # \033[...letter escape sequences as zero-width and ordinary bytes as
     # one-width. Stop when the visible counter reaches COLUMNS - 3, then
-    # append RST + ellipsis. Correct under any ANSI-density distribution,
-    # unlike a single OVERHEAD-add formula which assumes uniform spread.
-    # Pure bash (no awk/perl subprocess); byte-based slicing means non-ASCII
-    # multi-byte UTF-8 in user-controlled descriptions counts as multiple
-    # visible units — acceptable approximation for the ASCII-dominant case.
+    # append RST + ellipsis. Byte-based slicing means non-ASCII multi-byte
+    # UTF-8 counts as multiple visible units — the .mjs/.py renderers iterate
+    # the same UTF-8 bytes, so all three stay byte-identical.
     TARGET=$(( COLUMNS - 3 ))
     [ "$TARGET" -lt 0 ] && TARGET=0
     RAW_LEN=${#RENDERED}
@@ -150,12 +201,11 @@ echo "$INPUT" | jq -r '
       fi
       i=$(( i + 1 ))
     done
-    # Post-loop drain: every rendered row ends with a trailing ${RST} from the
-    # last segment. Without this drain, a row whose visible content fits within
-    # COLUMNS still has `i < RAW_LEN` (pointing inside the trailing reset),
-    # which would spuriously trigger truncation. Walk past any in-progress
-    # escape and any further escape sequences until we hit a real visible byte
-    # or end-of-string.
+    # Post-loop drain: every rendered row ends with a trailing ${RST}. Without
+    # this drain a row whose visible content fits within COLUMNS still has
+    # `i < RAW_LEN` (pointing inside the trailing reset), spuriously triggering
+    # truncation. Walk past any in-progress escape and any further escapes until
+    # a real visible byte or end-of-string.
     while [ $i -lt $RAW_LEN ]; do
       ch="${RENDERED:$i:1}"
       if [ "$in_esc" = "1" ]; then
@@ -171,8 +221,6 @@ echo "$INPUT" | jq -r '
       fi
     done
     if [ $i -lt $RAW_LEN ]; then
-      # printf '%b' converts the literal-text RST (`\033[0m`) into an actual
-      # ESC byte sequence, matching the byte semantics of RENDERED's prefix.
       RENDERED="${RENDERED:0:$i}$(printf '%b' "$RST")..."
     fi
   fi

package/templates/skills/cbp-checkpoint-complete/SKILL.md

@@ -76,7 +76,7 @@ Stop here.
 
 Collect QA results from all tasks and rounds. Build checkpoint-level QA summary:
 - Count auto checks passed/failed
-- List user QA items pending review
+- List default-checklist items still pending review
 
 If any critical failures, warn the user but don't block.
 

package/templates/skills/cbp-frontend-ui/SKILL.md

@@ -184,7 +184,7 @@ For each screenshot in `e2e_screenshots[]`:
 
 Populate `screenshot_review` totals.
 
-**Do not attempt to auto-fix `rendered_visual` or `baseline_regression` findings** — they feed into user QA and the fix loop, because the root cause is typically in app code/data, not in the SCSS.
+**Do not attempt to auto-fix `rendered_visual` or `baseline_regression` findings** — they surface as a blocking gate at `/cbp-round-end` Step 7 (accept-or-fix) and feed the fix loop, because the root cause is typically in app code/data, not in the SCSS.
 
 ### Phase 7: Aggregate Findings
 
@@ -258,5 +258,5 @@ Go beyond fixing violations — actively improve visual quality. If spacing coul
 - **Also invoked by**: `/cbp-checkpoint-check` (TASK-2 deliverable, future) with screenshots from a whole-checkpoint e2e run
 - **Consumes**: `e2e_screenshots[]` from `round.context.e2e_output.screenshots` (populated by `test-e2e-agent` at `/cbp-round-execute` Step 5)
 - **Output written to**: `round.context.frontend_ui_review` — when invoked twice per round, the second invocation merges with the first
-- **User-QA construction (downstream)**: this skill emits `findings[]` only — it does NOT construct user_qa items. `/cbp-round-end` Step 3b reads `round.context.frontend_ui_review.findings[]` and aggregates baseline-regression + rendered-visual-critical entries into the round's `user_qa[]`. Single source of truth for the user_qa schema lives at round-end.
+- **Downstream gate**: this skill emits `findings[]` only. Baseline-regression findings surface as a BLOCKING gate at `/cbp-round-end` Step 7 (baselines never auto-accepted); rendered-visual critical findings are surfaced in the Step 7 findings presentation.
 - **Paired with**: `frontend-design` (pre-implementation aesthetic decision), `frontend-ux` (interaction-quality self-review, also Step 3.8)

package/templates/skills/cbp-round-end/SKILL.md

@@ -55,46 +55,26 @@ Build the files list with approval status:
 **claude_approved**: `true` if cbp-testing-qa-agent passed for this file. `false` if issues remain.
 **user_approved**: Always `false` initially. User approves via git staging or web UI.
 
-### Step 3: Collect and Aggregate QA Results
+### Step 3: Collect QA Results
 
 **No QA runs here** — all QA was already executed by per-wave `cbp-testing-qa-agent` inside `/cbp-round-execute` Step 5.
 
-This step is the **canonical user_qa[] construction site**. cbp-testing-qa-agent and cbp-test-e2e-agent are fully independent producers (no cross-read); cross-source user_qa items that combine signals from multiple producers are built here, at the user-facing boundary. Single-source user_qa items (derivable from one producer's data alone) stay with that producer.
+#### 3a — Collect items from agent outputs
 
-#### 3a — Collect single-source items from agent outputs
-
-Collect from round context (all three sources are agent-derived):
+Collect from round context:
 
 - **Auto items**: from `testing_qa_output.auto_qa.items`
-- **User items (single-source)**: from `testing_qa_output.user_qa.items` (Phase 4b.1 design-source comparison + Phase 4b.2 mechanical-sweep spot-check + Phase 4b.0 connection smoke — all derivable from cbp-testing-qa-agent's own data)
 - **Default items**: from `testing_qa_output.default_checklist.items`
 
-#### 3b — Construct cross-source user_qa from frontend_ui_review (NEW)
-
-Read `round.context.frontend_ui_review.findings[]` (populated by the `cbp-frontend-ui` skill at `/cbp-round-execute` Step 5b under `phase: 'screenshot_review'`). For each finding, emit a `user_qa` item per the rules below.
-
-| Finding `category` | Finding `severity` | Emitted user_qa item |
-|--------------------|-------------------|---------------------|
-| `baseline_regression` | any | `{ type: 'user', check: 'Visual baseline regression — {page_or_screen}', status: 'pending', round_number: N, instructions: 'Open the diff PNG at `{screenshot}` (the `-diff.png` sibling shows pixel differences). Pixel-diff was `{baseline_diff_pct}%`. Decide: (a) regression — add a task to fix, OR (b) new rendering is correct — run `pnpm exec playwright test --update-snapshots` in `apps/{app}` and commit the updated baselines. Do NOT proceed until a decision is recorded.' }` |
-| `rendered_visual` | `critical` | `{ type: 'user', check: 'Rendered-visual critical — {page_or_screen}', status: 'pending', round_number: N, instructions: 'Open the screenshot at `{screenshot}`. The cbp-frontend-ui review flagged a critical rendering issue: `{finding.issue}`. Suggested fix: `{finding.suggestion}`. Decide whether this needs a fix-round before proceeding.' }` |
-| `rendered_visual` | `warning` | (no user_qa item; finding stays in `frontend_ui_review.findings` and surfaces via Step 7 findings presentation if relevant) |
-| Other categories | any | (no user_qa item from this step) |
-
-Skip Step 3b entirely when `round.context.frontend_ui_review` is absent (no e2e ran, or screenshot-review phase didn't execute).
-
-This is the required user gate for baseline updates — baselines are NEVER auto-accepted.
-
-#### 3c — Merge
-
-Combine the single-source items (3a) and cross-source items (3b) into a single `user_qa[]` for the round. Merge with previous rounds (supersede items for re-modified files, preserve verified items).
+Merge with previous rounds (supersede items for re-modified files, preserve verified items).
 
 ### Step 4: Update Task Files and QA
 
 Update via MCP:
 
 - `update_task(task_id, files_changed: [...])` — merge with existing
-- `update_round(round_id, files_changed: [...], qa: {items: [...]})` — round-specific
-- `update_task(task_id, qa: {items: [...]})` — aggregated
+- `update_round(round_id, files_changed: [...], qa: {items: [auto_qa items + default_checklist items]})` — round-specific
+- `update_task(task_id, qa: {items: [auto_qa items + default_checklist items]})` — aggregated
 
 ### Step 5: Present Summary
 
@@ -134,6 +114,16 @@ Wait for agent to complete. If the spawn fails for any reason, apply the inline-
 
 ### Step 7: Present Findings
 
+**Baseline-regression blocking gate**: before presenting code-review findings, check `round.context.frontend_ui_review.findings[]` for any entry with `category: 'baseline_regression'` (any severity). When one or more such findings exist, surface them as a BLOCKING decision that MUST be resolved before routing to `/cbp-round-update`:
+
+- Present each regression: screenshot path, `baseline_diff_pct`, affected page/screen.
+- Ask the user via AskUserQuestion to choose:
+  - **(a) Treat as regression** — add a fix-round to address the visual change, OR
+  - **(b) Accept the new baseline** — run `pnpm exec playwright test --update-snapshots` in `apps/{app}` and commit the updated baselines.
+- Do NOT route to `/cbp-round-update` until the decision is recorded. Baselines are NEVER auto-accepted.
+
+`rendered_visual` critical findings from `round.context.frontend_ui_review.findings[]` are surfaced in the normal findings presentation below (not as a separate gate).
+
 **If `status: 'no_findings'`:** show `### Code Review\nNo issues found. Code looks good.` and skip to Step 8.
 
 **If findings exist**, present them grouped by severity (table + per-finding details), then ask the user via AskUserQuestion which to fix: `all`, `1,2` (specific numbers), `none`, or `inline` (only when all findings qualify under the Trivial-Resolution Exception).

package/templates/skills/cbp-round-execute/SKILL.md

@@ -149,13 +149,13 @@ On pass, synthesise `testing_qa_output` inline per the procedure in `reference/i
 
 Input contracts: `cbp-testing-qa-agent` receives `executor_output`, `testing_profile`, `has_ui_work` (see `agents/cbp-testing-qa-agent.md` Input Contract). `cbp-test-e2e-agent` receives `repo_id`, `round_number`, `files_changed`, `prior_round_files_changed` (full task aggregate when round_number ≥ 2), `whole_checkpoint_mode: false`, `test_strategy`, `pages_affected`, `has_auth`, `dev_server_port` (see `agents/cbp-test-e2e-agent.md` Input Contract for the full shape).
 
-**Independence**: neither agent reads the other's output. Cross-source user_qa items (cbp-frontend-ui + agent data) are constructed downstream at `/cbp-round-end` Step 3b. Per-wave spawns MAY run in parallel with the next wave's executor when dependency order allows.
+**Independence**: neither agent reads the other's output. Baseline-regression findings surface as a BLOCKING gate at `/cbp-round-end` Step 7 (an explicit accept-or-fix user decision; baselines are NEVER auto-accepted). Per-wave spawns MAY run in parallel with the next wave's executor when dependency order allows.
 
 ### Step 5b: Post-E2E Screenshot Review (cbp-frontend-ui Phase 6.5)
 
 When `round.context.e2e_output.screenshots[]` is non-empty, invoke the `cbp-frontend-ui` skill with `phase: 'screenshot_review'` (input: `files_changed`, `e2e_screenshots: round.context.e2e_output.screenshots`, `context: { checkpoint_goal, round_requirements }`). Under this phase the skill runs only Phase 6.5 (Rendered-Output Visual Review) + 7 + 8 — Phases 1-6 (style) already ran inline at executor Step 3.8 with `phase: 'style_only'`.
 
-Persist findings to `round.context.frontend_ui_review` (merge with Step 3.8's style-only output if present). `/cbp-round-end` Step 3b emits user_qa items for any `category: 'baseline_regression'` (any severity) and any `category: 'rendered_visual' + severity: 'critical'` — neither auto-fails the round. cbp-testing-qa-agent does NOT read these findings (full independence per Step 5).
+Persist findings to `round.context.frontend_ui_review` (merge with Step 3.8's style-only output if present). Baseline-regression findings surface as a BLOCKING gate at `/cbp-round-end` Step 7 (an explicit accept-or-fix user decision; baselines are NEVER auto-accepted); rendered_visual critical findings are surfaced in the Step 7 findings presentation. Neither auto-fails the round. cbp-testing-qa-agent does NOT read these findings (full independence per Step 5).
 
 **Skip** when `round.context.e2e_output` is absent, `screenshots` is empty, or `testing_profile === 'claude_only'`.