@plainconceptsplatform/workflows 1.2.3 → 1.3.0

package/dist/route-processing.js

@@ -10,6 +10,7 @@ const routeCrons = {
 const routeHelperJobs = {
     implement: ["check-implement-pr"],
     triage: ["dispatch-triage"],
+    "merge-gate": ["merge-approved"],
 };
 export function stripRouteFromRouter(yaml, route) {
     let result = yaml;

package/loops/actions/assess-blast-radius/action.yml

@@ -35,6 +35,10 @@ inputs:
     description: Lines changed at or above which the radius is MEDIUM.
     required: false
     default: '200'
+  ignore-paths:
+    description: Extended regular expression. Matching paths count toward neither size nor owner and sensitive paths; protected paths still match them.
+    required: false
+    default: ''
 outputs:
   level:
     description: "low, medium or high."
@@ -64,11 +68,17 @@ outputs:
     description: CODEOWNERS entries covering the changed paths, space separated. Empty when the repository has no CODEOWNERS.
     value: ${{ steps.assess.outputs.required_owners }}
   files_changed:
-    description: Number of files in the diff.
+    description: Number of files that count toward size, ignored paths excluded.
     value: ${{ steps.assess.outputs.files_changed }}
   lines_changed:
-    description: Additions plus deletions.
+    description: Additions plus deletions of the files that count toward size.
     value: ${{ steps.assess.outputs.lines_changed }}
+  files_total:
+    description: Number of files in the whole diff.
+    value: ${{ steps.assess.outputs.files_total }}
+  lines_total:
+    description: Additions plus deletions of the whole diff.
+    value: ${{ steps.assess.outputs.lines_total }}
 runs:
   using: composite
   steps:
@@ -86,22 +96,51 @@ runs:
         HIGH_LINES: ${{ inputs.high-lines }}
         MEDIUM_FILES: ${{ inputs.medium-files }}
         MEDIUM_LINES: ${{ inputs.medium-lines }}
+        IGNORE_PATHS: ${{ inputs.ignore-paths }}
       run: |
         set -euo pipefail
         # One API call. The job this replaced already paid for it to grep PROTECTED_PATHS, and
         # the additions and deletions come back in the same payload, so the diff shape costs
         # nothing extra.
         gh api --paginate "repos/$REPO/pulls/$PR_NUMBER/files?per_page=100" \
-          --jq '[.[] | {filename, additions, deletions}]' > /tmp/blast-files.json
+          --jq '[.[] | {filename, status, additions, deletions, patch}]' | jq -s 'add // []' > /tmp/blast-files.json
+
+        all_files=$(jq -r '.[].filename' /tmp/blast-files.json)
+        files_total=$(jq -r 'length' /tmp/blast-files.json)
+        lines_total=$(jq -r '[.[] | .additions + .deletions] | add // 0' /tmp/blast-files.json)
+
+        # Tests, docs, specs, translations and generated code change no runtime behaviour, so they
+        # do not make a diff bigger. They stay in ALL_PATHS, so a protected path is never ignored.
+        if [ -n "$IGNORE_PATHS" ]; then
+          jq -c --arg re "$IGNORE_PATHS" '[.[] | select(.filename | test($re) | not)]' /tmp/blast-files.json > /tmp/blast-counted.json
+        else
+          cp /tmp/blast-files.json /tmp/blast-counted.json
+        fi
+        files=$(jq -r '.[].filename' /tmp/blast-counted.json)
+        files_changed=$(jq -r 'length' /tmp/blast-counted.json)
+        lines_changed=$(jq -r '[.[] | .additions + .deletions] | add // 0' /tmp/blast-counted.json)
 
-        files=$(jq -r '.[].filename' /tmp/blast-files.json)
-        files_changed=$(jq -r 'length' /tmp/blast-files.json)
-        lines_changed=$(jq -r '[.[] | .additions + .deletions] | add // 0' /tmp/blast-files.json)
+        # A new EF Core migration whose Up() only adds schema. An edited one never qualifies:
+        # changing a migration that may already have run is exactly what needs its owner.
+        additive=""
+        while IFS= read -r candidate; do
+          [ -n "$candidate" ] || continue
+          if jq -r --arg f "$candidate" '.[] | select(.filename == $f) | .patch // ""' /tmp/blast-counted.json |
+             bash "${{ github.action_path }}/migration-is-additive.sh" >/dev/null; then
+            additive="${additive}${additive:+$'\n'}${candidate}"
+          fi
+        done < <(jq -r '.[] | select(.status == "added") | .filename
+                        | select(test("(^|/)[Mm]igrations/[^/]+[.]cs$"))
+                        | select(test("([.]Designer|ModelSnapshot)[.]cs$") | not)' /tmp/blast-counted.json)
 
-        bash "${{ github.action_path }}/assess-blast-radius.sh" \
+        ALL_PATHS="$all_files" ADDITIVE_MIGRATIONS="$additive" \
+        IGNORED_FILES=$((files_total - files_changed)) IGNORED_LINES=$((lines_total - lines_changed)) \
+          bash "${{ github.action_path }}/assess-blast-radius.sh" \
           "$files_changed" "$lines_changed" <<<"$files" > /tmp/blast-out.env
 
         cat /tmp/blast-out.env >> "$GITHUB_OUTPUT"
+        echo "files_total=$files_total" >> "$GITHUB_OUTPUT"
+        echo "lines_total=$lines_total" >> "$GITHUB_OUTPUT"
 
         # CODEOWNERS refines who is asked; it never decides whether anyone is. A repository
         # without the file still gets an owner disposition from OWNER_PATHS, and the comment
@@ -139,7 +178,7 @@ runs:
             esac
             # An unanchored CODEOWNERS pattern matches at any depth, an anchored one only at the root.
             if [ "$anchored" -eq 1 ]; then regex="^${regex}"; else regex="(^|/)${regex}"; fi
-            if printf '%s\n' "$files" | grep -qE "$regex"; then
+            if printf '%s\n' "$all_files" | grep -qE "$regex"; then
               owners="$owners $rest"
             fi
           done < "$candidate"

package/loops/actions/assess-blast-radius/assess-blast-radius.sh

@@ -2,7 +2,9 @@
 # Managed by @plainconceptsplatform/workflows. Source: loops/actions/assess-blast-radius/assess-blast-radius.sh. Update with `workflows update --force`; consumer edits may be overwritten.
 # Classify a pull request's blast radius from its changed paths and diff shape.
 #
-# Reads the changed paths on stdin, one per line. Prints GITHUB_OUTPUT lines on stdout.
+# Reads the changed paths that count toward the diff's size on stdin, one per line. Prints
+# GITHUB_OUTPUT lines on stdout. ALL_PATHS, when set, is every changed path, ignored ones included:
+# protected paths are matched against it, so ignoring a path never unprotects it.
 # Deliberately model-free: the point of this file is that the most consequential input to the
 # merge decision is computed from facts a shell can check, before any agent reads the diff.
 #
@@ -21,8 +23,13 @@ HIGH_FILES="${HIGH_FILES:-20}"
 HIGH_LINES="${HIGH_LINES:-800}"
 MEDIUM_FILES="${MEDIUM_FILES:-5}"
 MEDIUM_LINES="${MEDIUM_LINES:-200}"
+# Added migrations the caller proved only add schema (migration-is-additive.sh), one per line.
+ADDITIVE_MIGRATIONS="${ADDITIVE_MIGRATIONS:-}"
+IGNORED_FILES="${IGNORED_FILES:-0}"
+IGNORED_LINES="${IGNORED_LINES:-0}"
 
 files="$(cat)"
+all_paths="${ALL_PATHS:-$files}"
 
 # An empty regex matches every line in grep -E, which would mark every pull request protected.
 # A list nobody configured must match nothing, not everything.
@@ -34,9 +41,9 @@ files="$(cat)"
 # before any of them is used: a `match` failure cannot report itself, because `match` runs
 # inside a command substitution and anything it sets dies with the subshell.
 match() {
-  local pattern="$1"
+  local pattern="$1" paths="${2-$files}"
   [ -n "$pattern" ] || return 0
-  printf '%s\n' "$files" | grep -E "$pattern" || true
+  printf '%s\n' "$paths" | grep -E "$pattern" || true
 }
 
 # Compile each configured pattern against nothing. grep exits 2 when the regex is bad, which is
@@ -50,14 +57,22 @@ for name in PROTECTED_PATHS OWNER_PATHS SENSITIVE_PATHS; do
   fi
 done
 
-protected_hits="$(match "$PROTECTED_PATHS")"
+protected_hits="$(match "$PROTECTED_PATHS" "$all_paths")"
 owner_hits="$(match "$OWNER_PATHS")"
 sensitive_hits="$(match "$SENSITIVE_PATHS")"
 
+# An additive migration loses no data, so it asks for a second look (medium) rather than its
+# owner. Every other owner path still forces high.
+additive_hits=""
+if [ -n "$ADDITIVE_MIGRATIONS" ] && [ -n "$owner_hits" ]; then
+  additive_hits="$(printf '%s\n' "$owner_hits" | grep -Fxf <(printf '%s\n' "$ADDITIVE_MIGRATIONS") || true)"
+  owner_hits="$(printf '%s\n' "$owner_hits" | grep -vFxf <(printf '%s\n' "$ADDITIVE_MIGRATIONS") || true)"
+fi
+
 # A threshold that is not a number turns its comparison into a shell error that `set -e` does
 # not catch, because the test is an `if` condition: `HIGH_FILES=twenty` printed a diagnostic to
 # stderr and quietly produced `level=low` for a diff of any size.
-for threshold in HIGH_FILES HIGH_LINES MEDIUM_FILES MEDIUM_LINES files_changed lines_changed; do
+for threshold in HIGH_FILES HIGH_LINES MEDIUM_FILES MEDIUM_LINES files_changed lines_changed IGNORED_FILES IGNORED_LINES; do
   case "${!threshold}" in
     ""|*[!0-9]*)
       echo "assess-blast-radius: ${threshold} must be a whole number, got '${!threshold}'" >&2
@@ -92,6 +107,10 @@ if [ "$lines_changed" -ge "$HIGH_LINES" ]; then
 fi
 
 if [ "$level" != high ]; then
+  if [ -n "$additive_hits" ]; then
+    level=medium
+    add_signal "additive migrations, no owner needed ($(printf '%s\n' "$additive_hits" | tr '\n' ' ' | sed 's/ $//'))"
+  fi
   if [ -n "$sensitive_hits" ]; then
     level=medium
     add_signal "sensitive paths touched ($(printf '%s\n' "$sensitive_hits" | tr '\n' ' ' | sed 's/ $//'))"
@@ -107,6 +126,9 @@ if [ "$level" != high ]; then
 fi
 
 [ -n "$signals" ] || signals="no blast-radius signal fired: $files_changed files, $lines_changed lines, no configured path matched"
+if [ "$IGNORED_FILES" -gt 0 ]; then
+  add_signal "not counted toward size: $IGNORED_FILES files, $IGNORED_LINES lines (tests, docs, specs, translations, generated code)"
+fi
 
 # A fixed heredoc delimiter is a fail-open here. Every multi-line value below is built from
 # paths the pull request chose, so a path that is exactly the delimiter closes its block early

package/loops/actions/assess-blast-radius/migration-is-additive.sh

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+# Managed by @plainconceptsplatform/workflows. Source: loops/actions/assess-blast-radius/migration-is-additive.sh. Update with `workflows update --force`; consumer edits may be overwritten.
+# Decide whether a newly added EF Core migration only adds schema. Reads the file's diff patch on
+# stdin; exits 0 and prints "additive" when it does, exits 1 and prints the reason when it does not.
+#
+# Only Up() is read: Down() of an additive migration is all drops by construction. Anything that
+# can lose or rewrite data, or a structure this cannot follow, is not additive.
+
+set -euo pipefail
+
+awk '
+  /^\+/ { line = substr($0, 2) }
+  !/^\+/ { next }
+  line ~ /void[ \t]+Up[ \t]*\(/ { in_up = 1; seen_up = 1; next }
+  line ~ /void[ \t]+Down[ \t]*\(/ { in_up = 0; next }
+  !in_up { next }
+  line ~ /\.(Drop[A-Za-z]*|Rename[A-Za-z]*|Alter[A-Za-z]*|Sql|DeleteData|UpdateData|RestartSequence)[ \t]*[(<]/ {
+    match(line, /\.[A-Za-z]+[ \t]*[(<]/)
+    reason = "Up() calls " substr(line, RSTART + 1, RLENGTH - 1)
+    exit
+  }
+  line ~ /\.AddColumn[ \t]*</ { in_column = 1; column = "" }
+  in_column {
+    column = column " " line
+    if (line ~ /\);/) {
+      in_column = 0
+      if (column ~ /nullable:[ \t]*false/ && column !~ /defaultValue/) {
+        reason = "Up() adds a required column with no default"
+        exit
+      }
+    }
+  }
+  END {
+    if (reason == "" && !seen_up) reason = "no Up() method found in the added lines"
+    if (reason != "") { print reason; exit 1 }
+    print "additive"
+  }
+'

package/loops/actions/classify-route/action.yml

@@ -56,6 +56,7 @@ runs:
         PR_MERGED: ${{ github.event.pull_request.merged }}
         COMMENT_ON_PR: ${{ github.event.issue.pull_request != '' }}
         COMMENT_SENDER_TYPE: ${{ github.event.comment.user.type }}
+        REVIEW_STATE: ${{ github.event.review.state }}
         ACTOR: ${{ github.actor }}
         RUN_PR_NUMBER: ${{ github.event.workflow_run.pull_requests[0].number }}
         RUN_CONCLUSION: ${{ github.event.workflow_run.conclusion }}
@@ -84,7 +85,7 @@ runs:
 
     - name: Resolve the issue the pull request closes
       id: linked-issue
-      if: steps.classify.outputs.route == 'merge-gate' || steps.classify.outputs.route == 'apply-review'
+      if: contains(fromJson('["merge-gate","apply-review","merge-approved"]'), steps.classify.outputs.route)
       shell: bash
       env:
         GH_TOKEN: ${{ inputs.token }}

package/loops/actions/classify-route/classify-route.sh

@@ -135,7 +135,13 @@ classify_route() {
       ;;
 
     pull_request_review_comment | pull_request_review)
-      route="apply-review"
+      # An approval is a decision, not feedback: the router merges the pull request when the
+      # gate had handed it to a person (merge-approved checks the rest).
+      if [ "${EVENT:-}" = "pull_request_review" ] && [ "${REVIEW_STATE:-}" = "approved" ]; then
+        route="merge-approved"
+      else
+        route="apply-review"
+      fi
       pr_number="${EVENT_PR_NUMBER:-}"
       ;;
 

package/loops/actions/verify-route-matrix/verify-route-matrix.sh

@@ -78,7 +78,7 @@ route_field() {
     unset EVENT ACTION LABEL ISSUE_LABELS EVENT_ISSUE_NUMBER EVENT_PR_NUMBER \
       COMMENT_ON_PR COMMENT_SENDER_TYPE RUN_PR_NUMBER RUN_CONCLUSION RUN_ID \
       SCHEDULE OPERATION INPUT_ISSUE_NUMBER INPUT_PR_NUMBER INPUT_MODE \
-      INPUT_CI_CONCLUSION INPUT_CI_RUN_ID INPUT_TRIGGER_KIND PR_MERGED EVIDENCE_ENABLED
+      INPUT_CI_CONCLUSION INPUT_CI_RUN_ID INPUT_TRIGGER_KIND PR_MERGED EVIDENCE_ENABLED REVIEW_STATE
 
     for assignment in "${assignments[@]}"; do
       key="${assignment%%=*}"
@@ -185,6 +185,12 @@ assert_route "a review comment routes to apply-review" apply-review \
   EVENT=pull_request_review_comment EVENT_PR_NUMBER=7
 assert_route "a submitted review routes to apply-review" apply-review \
   EVENT=pull_request_review EVENT_PR_NUMBER=7
+assert_route "a review requesting changes routes to apply-review" apply-review \
+  EVENT=pull_request_review REVIEW_STATE=changes_requested EVENT_PR_NUMBER=7
+assert_route "an approval routes to merge-approved" merge-approved \
+  EVENT=pull_request_review REVIEW_STATE=approved EVENT_PR_NUMBER=7
+assert "merge-approved carries the pull request" 7 \
+  "$(route_field pr-number EVENT=pull_request_review REVIEW_STATE=approved EVENT_PR_NUMBER=7)"
 assert_route "a pull_request_target routes to bot-approve" bot-approve \
   EVENT=pull_request_target ACTION=opened
 assert_route "a merged pull request routes to evidence" evidence \
@@ -704,7 +710,7 @@ if [ "$(count -c 'attempts_so_far' "$ROUTER_YML")" -lt 2 ]; then
   BELT_OK=0; echo "FAIL: dispatch sites must forward attempts_so_far" >&2
 fi
 # A second gate for a pull request whose gate is already queued or running reads the same CI
-# verdict and is cancelled by the single-slot merge-belt queue (two cancellations on 2026-09-06).
+# verdict, and the belt's queue would run it twice.
 if [ "$(count -c 'a merge-gate run is already live' "$ROUTER_YML")" -lt 2 ]; then
   BELT_OK=0; echo "FAIL: both dispatch paths must skip a pull request whose gate is already live" >&2
 fi
@@ -1079,6 +1085,17 @@ for route in "${EXCLUDED_ROUTES[@]}"; do
   fi
 done
 
+# merge-approved serves the gate and leaves with it.
+if worker_installed merge-gate; then
+  if grep -q "route == 'merge-approved'" "$ROUTER_YML"; then PASS=$((PASS + 1)); else
+    FAIL=$((FAIL + 1)); echo "FAIL: work-router.yml has no job for route 'merge-approved'" >&2
+  fi
+elif grep -q "route == 'merge-approved'" "$ROUTER_YML"; then
+  FAIL=$((FAIL + 1)); echo "FAIL: merge-approved is installed without the merge gate" >&2
+else
+  PASS=$((PASS + 1))
+fi
+
 while read -r operation; do
   if grep -q "route == '${operation}'" "$ROUTER_YML"; then
     PASS=$((PASS + 1))
@@ -1415,7 +1432,93 @@ level=low")
     printf '%s\n' "$blast_injection" >&2
   fi
 
+  # Ignored paths leave the size, never the protection: a protected path that only reaches the
+  # script through ALL_PATHS still holds the merge.
+  blast_ignored=$(PROTECTED_PATHS='^\.' OWNER_PATHS='' SENSITIVE_PATHS='' \
+    HIGH_FILES=20 HIGH_LINES=800 MEDIUM_FILES=5 MEDIUM_LINES=200 \
+    ALL_PATHS=$'src/ui/list.tsx\n.github/workflows/ci.yml' IGNORED_FILES=1 IGNORED_LINES=4 \
+    bash "$BLAST_SCRIPT" 1 10 <<<"src/ui/list.tsx")
+  printf '%s\n' "$blast_ignored" | grep -qx 'requires_review=true' ||
+    { BLAST_OK=0; echo "FAIL: a protected path outside the counted files no longer holds the merge" >&2; }
+
+  # An additive migration under an owner path asks for a second look, not its owner. Any other
+  # owner path in the same diff still forces high.
+  blast_additive() {
+    PROTECTED_PATHS='^\.' OWNER_PATHS='(^|/)([Mm]igrations|auth)/' SENSITIVE_PATHS='' \
+      HIGH_FILES=20 HIGH_LINES=800 MEDIUM_FILES=5 MEDIUM_LINES=200 \
+      ADDITIVE_MIGRATIONS="$1" bash "$BLAST_SCRIPT" 2 120 <<<"$2" | sed -n 's/^level=//p'
+  }
+  [ "$(blast_additive 'src/Migrations/1_AddX.cs' $'src/Migrations/1_AddX.cs\nsrc/ui/x.tsx')" = medium ] ||
+    { BLAST_OK=0; echo "FAIL: an additive migration still forces its owner" >&2; }
+  [ "$(blast_additive '' $'src/Migrations/1_AddX.cs\nsrc/ui/x.tsx')" = high ] ||
+    { BLAST_OK=0; echo "FAIL: a migration nobody proved additive no longer needs its owner" >&2; }
+  [ "$(blast_additive 'src/Migrations/1_AddX.cs' $'src/Migrations/1_AddX.cs\nsrc/auth/login.ts')" = high ] ||
+    { BLAST_OK=0; echo "FAIL: an additive migration let another owner path through" >&2; }
+
+  # The shipped ignore list, against paths from real consumer pull requests.
+  ignore_re=$(sed -n "s/^  BLAST_IGNORE_PATHS: '\(.*\)'$/\1/p" "$MERGE_GATE_WORKER_MD")
+  for ignored in tests/Pliny.UnitTests/Agents/SecretRedactorTests.cs apps/api/tests/Numa.UnitTests/QuoteTests.cs \
+                 apps/web/src/views/chat/ui/internals-pane.test.tsx apps/web/src/shared/config/i18n/es.json \
+                 openspec/changes/archive/x/verification-plan.md docs/ARCH.md \
+                 src/Pliny.Infrastructure/Migrations/20261014225437_X.Designer.cs src/Migrations/AppDbContextModelSnapshot.cs; do
+    grep -qE "$ignore_re" <<<"$ignored" ||
+      { BLAST_OK=0; echo "FAIL: BLAST_IGNORE_PATHS counts ${ignored} toward the diff's size" >&2; }
+  done
+  for counted in src/Pliny.Infrastructure/Agents/SecretRedactor.cs apps/web/src/views/chat/ui/internals-pane.tsx \
+                 src/Pliny.Infrastructure/Migrations/20261014225437_X.cs apps/api/src/Numa.Api/appsettings.json; do
+    if grep -qE "$ignore_re" <<<"$counted"; then
+      BLAST_OK=0; echo "FAIL: BLAST_IGNORE_PATHS ignores ${counted}, which ships" >&2
+    fi
+  done
+
   if [ "$BLAST_OK" -eq 1 ]; then PASS=$((PASS + 1)); else FAIL=$((FAIL + 1)); fi
+
+  # A migration is additive only when its Up() creates and adds. Down() is all drops by design,
+  # and a data rewrite or a required column with no default needs the owner.
+  MIGRATION_OK=1
+  MIGRATION_SCRIPT="${HERE}/../assess-blast-radius/migration-is-additive.sh"
+  migration_case() {
+    local name="$1" want="$2" patch="$3" got
+    if bash "$MIGRATION_SCRIPT" <<<"$patch" >/dev/null; then got=additive; else got=owner; fi
+    [ "$got" = "$want" ] || { MIGRATION_OK=0; echo "FAIL: migration '${name}' read as ${got}, expected ${want}" >&2; }
+  }
+  migration_case "a new table, dropped in Down()" additive '+    protected override void Up(MigrationBuilder migrationBuilder)
++    {
++        migrationBuilder.CreateTable(name: "TokenRevocations", columns: table => new { Id = table.Column<Guid>(nullable: false) });
++        migrationBuilder.AddColumn<string>(
++            name: "Note",
++            table: "Quotes",
++            nullable: true);
++    }
++    protected override void Down(MigrationBuilder migrationBuilder)
++    {
++        migrationBuilder.DropTable(name: "TokenRevocations");
++    }'
+  migration_case "a data rewrite" owner '+    protected override void Up(MigrationBuilder migrationBuilder)
++    {
++        migrationBuilder.Sql("UPDATE Bots SET Instructions = NULL");
++    }'
+  migration_case "a renamed column" owner '+    protected override void Up(MigrationBuilder migrationBuilder)
++    {
++        migrationBuilder.RenameColumn(name: "A", table: "T", newName: "B");
++    }'
+  migration_case "a required column with no default" owner '+    protected override void Up(MigrationBuilder migrationBuilder)
++    {
++        migrationBuilder.AddColumn<int>(
++            name: "Level",
++            table: "Quotes",
++            nullable: false);
++    }'
+  migration_case "a required column with a default" additive '+    protected override void Up(MigrationBuilder migrationBuilder)
++    {
++        migrationBuilder.AddColumn<int>(
++            name: "Level",
++            table: "Quotes",
++            nullable: false,
++            defaultValue: 0);
++    }'
+  migration_case "no Up() in the patch" owner '+// generated'
+  if [ "$MIGRATION_OK" -eq 1 ]; then PASS=$((PASS + 1)); else FAIL=$((FAIL + 1)); fi
 fi
 
 # apply-review's validator compares the unresolved review threads on a pull request against the
@@ -1724,6 +1827,28 @@ else
   fi
   ev_absent 'secrets\.' "$EVIDENCE_YML" 'evidence.yml must need no secret; GITHUB_TOKEN is enough'
   ev_absent 'gh (issue|pr) comment.*--attach' "$EVIDENCE_YML" 'gh --attach refuses installation tokens; commit the screenshots beside their plans'
+  # An unmerged pull request's preview goes to its own branch, never to the pull request's branch
+  # (a commit there invalidates the gate's verdict) and never to the default branch.
+  preview_step="$(sed -n '/name: Commit a preview of the screenshots/,/name: Write the evidence comment/p' "$EVIDENCE_YML")"
+  grep -q "if: steps.pr.outputs.merged != 'true'" <<<"$preview_step" ||
+    { EV_OK=0; echo "FAIL: the preview step must run only for an unmerged pull request" >&2; }
+  grep -qF 'git push -q origin "HEAD:refs/heads/$PREVIEW"' <<<"$preview_step" ||
+    { EV_OK=0; echo "FAIL: the preview must be pushed to EVIDENCE_PREVIEW_BRANCH and nowhere else" >&2; }
+  ev '^  EVIDENCE_PREVIEW_BRANCH: ' "$EVIDENCE_YML" 'evidence.yml does not declare EVIDENCE_PREVIEW_BRANCH'
+fi
+
+# The gate replays the plan for a person it hands the pull request to, never on auto-merge: a
+# dispatch next to the merge is the race that sank agent-visual-verify.
+if worker_installed merge-gate; then
+  ev '^  EVIDENCE_BEFORE_REVIEW: ' "$MERGE_GATE_WORKER_MD" 'merge-gate does not declare EVIDENCE_BEFORE_REVIEW'
+  review_dispatch="$(sed -n '/name: Replay the verification plan for the reviewer/,/inputs\[pr-number\]/p' "$MERGE_GATE_WORKER_MD")"
+  if ! grep -q '"human-review","owner-review"' <<<"$review_dispatch" || grep -q 'auto-merge' <<<"$review_dispatch" ||
+     ! grep -q 'inputs\[operation\]=evidence' <<<"$review_dispatch"; then
+    EV_OK=0
+    echo "FAIL: the gate must dispatch evidence for human-review and owner-review only" >&2
+  fi
+  grep -q 'name: Replay the verification plan for the owner' "$MERGE_GATE_WORKER_MD" ||
+    { EV_OK=0; echo "FAIL: a protected-path hold never reaches conclude, so it must dispatch evidence itself" >&2; }
 fi
 
 # The retired worker stays retired: nothing dispatches it and nothing waits for it.
@@ -2366,31 +2491,18 @@ for worker_md in "${WORKFLOWS_DIR}"/agent-*.md; do
 done
 if [ "$INPUT_WIRING_OK" -eq 1 ]; then PASS=$((PASS + 1)); else FAIL=$((FAIL + 1)); fi
 
-# The belt dispatches one gate per tick and stops. The gate's concurrency group holds a single
-# pending run, so GitHub cancels every earlier pending dispatch in it -- `cancel-in-progress:
-# false` only protects a run that has already started. A loop without this `break` dispatched one
-# gate per eligible pull request, ran the last, and discarded the rest with no comment, no
-# recorded attempt, and nothing on the pull request to show it had been skipped. Asserted because
-# removing the break produces no error anywhere: the extra dispatches all return 204.
-BELT_ONE_PER_TICK_OK=1
-belt_dispatch_block=$(awk '
-  /Dispatching Merge Gate for PR/ { found = 1 }
-  found { print }
-  found && /^ *done$/ { exit }
-' "$ROUTER_YML")
-if [ -z "$belt_dispatch_block" ]; then
-  BELT_ONE_PER_TICK_OK=0
-  echo "FAIL: the merge belt's gate dispatch could not be located, so its one-per-tick guard cannot be checked" >&2
-elif ! printf '%s\n' "$belt_dispatch_block" | grep -qE '^ *break$'; then
-  BELT_ONE_PER_TICK_OK=0
-  echo "FAIL: the merge belt dispatches a gate per eligible pull request and never breaks; only the last stays pending and the rest are cancelled in silence" >&2
-fi
-# And the group it relies on must still be the serialising one.
-# Anchored to the whole line: a substring search matched `merge-belt-renamed` and stayed green
-# through a mutation that removed the serialisation the break depends on.
-grep -qE '^ *group: merge-belt *$' "$ROUTER_YML" ||
-  { BELT_ONE_PER_TICK_OK=0; echo "FAIL: the merge gate is no longer serialised on the merge-belt concurrency group" >&2; }
-if [ "$BELT_ONE_PER_TICK_OK" -eq 1 ]; then PASS=$((PASS + 1)); else FAIL=$((FAIL + 1)); fi
+# Several paths dispatch gates at once (the reconcile tick, CI's dispatch-merge-gate, the
+# conflict rescan). Without `queue: max` GitHub keeps one pending run in the group and cancels the
+# rest with no comment and no recorded attempt; every dispatch still returns 204.
+BELT_QUEUE_OK=1
+belt_caller=$(awk '/^  call-merge-gate:/ { found = 1; print; next } found && /^  [a-z]/ { exit } found { print }' "$ROUTER_YML")
+printf '%s
+' "$belt_caller" | grep -qE '^ *group: merge-belt *$' ||
+  { BELT_QUEUE_OK=0; echo "FAIL: the merge gate is no longer serialised on the merge-belt concurrency group" >&2; }
+printf '%s
+' "$belt_caller" | grep -qE '^ *queue: max *$' ||
+  { BELT_QUEUE_OK=0; echo "FAIL: call-merge-gate must queue its waiting gates (queue: max); a single-slot group cancels every gate but the last" >&2; }
+if [ "$BELT_QUEUE_OK" -eq 1 ]; then PASS=$((PASS + 1)); else FAIL=$((FAIL + 1)); fi
 
 # The specific wiring that broke, asserted end to end: the router resolves the run ID, the gate
 # forwards it, and the action seeds from it rather than only from its own lookup.

package/loops/docs/diagrams.md

@@ -282,7 +282,7 @@ flowchart TD
     gateFix("Repair<br/>read the failure, fix, verify.<br/>Empty evidence on a conflicting<br/>PR means the conflict is the fault") --> gatePush
     gatePush(("Pushed<br/>CI runs again, gate re-enters"))
     gateFix -.->|"cannot fix"| gateHuman
-    gateProtected{"protected_changes (rung 4b)<br/>blast radius from paths,<br/>CODEOWNERS and diff shape"}
+    gateProtected{"protected_changes (rung 4b)<br/>blast radius from paths, CODEOWNERS<br/>and the size of the code that ships"}
     gateProtected -.->|"protected path"| gateOwner
     gateProtected -->|"measured low, medium or high"| gateAssess
     gateAssess("Agent (rung 5)<br/>find defects, verify them,<br/>rate recoverability") --> gateDisposition
@@ -294,6 +294,10 @@ flowchart TD
     gateMerge(("AUTO-MERGE<br/>squash, issue closed,<br/>pr-pending removed"))
     gateHuman(("HUMAN REVIEW<br/>review label,<br/>implement label kept"))
     gateOwner(("OWNER REVIEW<br/>review + owner-review,<br/>CODEOWNERS asked when named"))
+    gateHuman --> gatePreview
+    gateOwner --> gatePreview
+    gatePreview("operation=evidence<br/>screenshots of the head<br/>before the person decides") --> gateApproved
+    gateApproved(("Approved by a writer<br/>merge-approved merges<br/>the approved commit"))
     gateBlocked(("BLOCKED<br/>review + blocked,<br/>the belt does not retry"))
     gateIdle(("Idle<br/>not ours, or not open"))
     gateFix -.->|"attempt 6 of 6"| gateBlocked
@@ -305,11 +309,11 @@ flowchart TD
     classDef failure fill:#fff0f0,stroke:#ef2929,stroke-width:2px,color:#8b1a1a
     classDef success fill:#e8f8ec,stroke:#18883c,stroke-width:2px,color:#145a32
     class gateStart start
-    class gateBranch,gateFacts,gateFix,gateAssess action
+    class gateBranch,gateFacts,gateFix,gateAssess,gatePreview action
     class gateSubject,gateCi,gateProtected,gateDisposition decision
     class gateIdle idle
     class gateHuman,gateOwner,gateBlocked failure
-    class gateMerge,gatePush success
+    class gateMerge,gatePush,gateApproved success
 ```
 
 A protected-path match holds the merge but does not stop the repair path: the agent may still fix
@@ -321,6 +325,12 @@ agent ran. A category the diff touches is no longer, on its own, a reason to par
 only a verified high or critical finding, a sensitive path, or a change that would be hard to undo
 sends it to a person.
 
+Size counts only code that ships: tests, docs, specs, translations and generated migration code
+(`BLAST_IGNORE_PATHS`) are left out, and a new EF Core migration whose `Up()` only creates and adds
+is a medium change rather than an owner one. When the gate parks a pull request for a person it
+dispatches `operation=evidence`, so the screenshots arrive before the decision, and an approval
+from anyone with write access merges the approved commit (`merge-approved` in the router).
+
 ---
 
 ## agent-apply-review.md
@@ -628,14 +638,16 @@ Archives what a merged pull request looks like. Not an agent: the plan was writt
 implemented the change (`pc-repo-verify`), and this replays it. The router calls it when a pull
 request merges, and `operation=evidence` runs it by hand. Nothing waits on it. The screenshots are
 committed beside each plan, in an `evidence/` folder on the default branch, so the record stays with
-the change it proves; the comment embeds a manifest that Project Health reads. A pull request that
-is not merged has no plan on the default branch, so its screenshots stay in the run's artifact.
+the change it proves; the comment embeds a manifest that Project Health reads. The merge gate also
+runs it when it hands a pull request to a person: that pull request is not merged, so its
+screenshots go to a preview folder (`pr-<number>/`) on the `evidence-previews` branch, and the
+merge replaces them with the archived ones.
 The capture job runs the pull request's code with a read-only token; only the publish job writes,
 and it runs no repository code.
 
 ```mermaid
 flowchart TD
-    evStart("router: pull request merged<br/>or operation=evidence") --> evPlans
+    evStart("router: pull request merged,<br/>the gate parked it for a person,<br/>or operation=evidence") --> evPlans
     evPlans{"verification-plan.md<br/>in the pull request?"}
     evPlans -.->|"no"| evIdle
     evPlans -->|"yes"| evInspect
@@ -648,8 +660,11 @@ flowchart TD
     evUp -.->|"no, after the timeout"| evUnreached
     evReplay["replay each waypoint<br/>in headless Chromium,<br/>one JPEG per waypoint"] --> evPublish
     evUnreached["record why nothing<br/>was captured"] --> evPublish
-    evPublish["publish (GITHUB_TOKEN)<br/>commit beside each plan,<br/>evidence/ on the default branch,<br/>upsert one comment"] --> evDone
-    evDone(("Archived<br/>beside the plan"))
+    evPublish{"publish (GITHUB_TOKEN)<br/>merged?"}
+    evPublish -->|"yes"| evDone
+    evPublish -->|"not yet"| evPreview
+    evDone(("Archived beside the plan<br/>on the default branch,<br/>one comment upserted"))
+    evPreview(("Preview on evidence-previews<br/>pr-number folder,<br/>same comment"))
     evIdle(("Nothing to capture"))
 
     classDef start fill:#ffffff,stroke:#172033,stroke-width:2px,color:#172033
@@ -658,8 +673,8 @@ flowchart TD
     classDef idle fill:#f4f4f6,stroke:#5b5b66,stroke-width:2px,color:#2b2b33
     classDef success fill:#e8f8ec,stroke:#18883c,stroke-width:2px,color:#145a32
     class evStart start
-    class evApp,evReplay,evUnreached,evPublish action
-    class evPlans,evInspect,evUp decision
+    class evApp,evReplay,evUnreached action
+    class evPlans,evInspect,evUp,evPublish decision
     class evIdle idle
-    class evDone success
+    class evDone,evPreview success
 ```

package/loops/workflows/agent-merge-gate.md

@@ -43,9 +43,16 @@ env:
   BLAST_HIGH_LINES: "800"
   BLAST_MEDIUM_FILES: "5"
   BLAST_MEDIUM_LINES: "200"
+  # Paths that change no runtime behaviour: tests, docs, specs, translations and generated
+  # migration code. They count toward neither size nor owner paths, so a feature's tests do not
+  # double its blast radius. Protected paths are still matched against every file.
+  BLAST_IGNORE_PATHS: '(^|/)([Tt]ests?|__tests__|__snapshots__|e2e)/|(^|/)[^/]+\.[A-Za-z]*Tests?/|\.(test|spec)\.[cm]?[jt]sx?$|\.snap$|\.feature$|(^|/)openspec/|\.md$|(^|/)evidence/|(^|/)(i18n|locales?|translations?)/[^/]*\.json$|\.Designer\.cs$|ModelSnapshot\.cs$'
   # Agent confidence below which the pull request goes to a human. The agent reports the number;
   # this decides what it means.
   CONFIDENCE_THRESHOLD: "0.8"
+  # Replay the verification plan when the gate hands the pull request to a person, so the
+  # reviewer sees the screenshots before deciding. "false" leaves evidence to the merge.
+  EVIDENCE_BEFORE_REVIEW: "true"
   WORKING_LABEL: bot-working
   IMPLEMENT_LABEL: implement
   REVIEW_LABEL: review
@@ -203,6 +210,8 @@ jobs:
       required_owners: ${{ steps.blast.outputs.required_owners }}
       files_changed: ${{ steps.blast.outputs.files_changed }}
       lines_changed: ${{ steps.blast.outputs.lines_changed }}
+      files_total: ${{ steps.blast.outputs.files_total }}
+      lines_total: ${{ steps.blast.outputs.lines_total }}
       owner_hit: ${{ steps.blast.outputs.owner_hit }}
       sensitive_hit: ${{ steps.blast.outputs.sensitive_hit }}
       # The decision, computed once. A protected path holds the merge for a human, but it must
@@ -229,6 +238,7 @@ jobs:
           high-lines: ${{ env.BLAST_HIGH_LINES }}
           medium-files: ${{ env.BLAST_MEDIUM_FILES }}
           medium-lines: ${{ env.BLAST_MEDIUM_LINES }}
+          ignore-paths: ${{ env.BLAST_IGNORE_PATHS }}
 
   review_required:
     needs: [subject, protected_changes]
@@ -291,6 +301,18 @@ jobs:
             Required owners: `${{ needs.protected_changes.outputs.required_owners || 'none configured' }}`
 
             **Verdict:** owner-review
+      - name: Replay the verification plan for the owner
+        if: needs.protected_changes.outputs.holds_review == 'true' && env.EVIDENCE_BEFORE_REVIEW == 'true'
+        continue-on-error: true
+        env:
+          GH_TOKEN: ${{ steps.app-token.outputs.token }}
+          REPO: ${{ github.repository }}
+          PR: ${{ needs.subject.outputs.pr }}
+        run: |
+          set -euo pipefail
+          branch=$(gh api "repos/$REPO" --jq .default_branch)
+          gh api "repos/$REPO/actions/workflows/work-router.yml/dispatches" --method POST \
+            -f ref="$branch" -f "inputs[operation]=evidence" -f "inputs[pr-number]=$PR"
 
   reserve:
     needs: subject
@@ -440,7 +462,7 @@ jobs:
             | Disposition | `${{ needs.validate_output.outputs.outcome }}` |
             | CI | ${{ needs.subject.outputs.conclusion }} |
             | Blast radius | ${{ needs.protected_changes.outputs.level }} |
-            | Files / lines | ${{ needs.protected_changes.outputs.files_changed }} / ${{ needs.protected_changes.outputs.lines_changed }} |
+            | Files / lines | ${{ needs.protected_changes.outputs.files_changed }} / ${{ needs.protected_changes.outputs.lines_changed }} counted, ${{ needs.protected_changes.outputs.files_total }} / ${{ needs.protected_changes.outputs.lines_total }} in the diff |
             | Protected paths | ${{ needs.protected_changes.outputs.requires_review == 'true' && 'yes' || 'no' }} |
             | Owner paths | ${{ needs.protected_changes.outputs.owner_hit == 'true' && 'yes' || 'no' }} |
             ${{ needs.validate_output.outputs.outcome == 'owner-review'
@@ -453,6 +475,7 @@ jobs:
             ```
 
             Findings and verification on the linked issue: #${{ needs.subject.outputs.issue }}. [View this workflow run](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})
+            ${{ env.EVIDENCE_BEFORE_REVIEW == 'true' && contains(fromJson('["human-review","owner-review"]'), needs.validate_output.outputs.outcome) && 'Screenshots of this head follow in their own comment if it carries a verification plan. Approving the pull request merges it.' || '' }}
       - name: Merge approved pull request
         if: needs.validate_output.outputs.outcome == 'auto-merge'
         env:
@@ -512,6 +535,20 @@ jobs:
           token: ${{ steps.app-token.outputs.token }}
           issue-number: ${{ needs.subject.outputs.issue }}
           labels: ${{ env.WORKING_LABEL }}
+      # A person decides this one, so the screenshots come before the decision, in a router run of
+      # their own outside the belt. Never on auto-merge: that dispatch would race the merge.
+      - name: Replay the verification plan for the reviewer
+        if: env.EVIDENCE_BEFORE_REVIEW == 'true' && contains(fromJson('["human-review","owner-review"]'), needs.validate_output.outputs.outcome)
+        continue-on-error: true
+        env:
+          GH_TOKEN: ${{ steps.app-token.outputs.token }}
+          REPO: ${{ github.repository }}
+          PR: ${{ needs.subject.outputs.pr }}
+        run: |
+          set -euo pipefail
+          branch=$(gh api "repos/$REPO" --jq .default_branch)
+          gh api "repos/$REPO/actions/workflows/work-router.yml/dispatches" --method POST \
+            -f ref="$branch" -f "inputs[operation]=evidence" -f "inputs[pr-number]=$PR"
       - name: Clear merged issue labels
         if: needs.validate_output.outputs.outcome == 'auto-merge'
         uses: ./.github/actions/remove-issue-labels

package/loops/workflows/evidence.yml

@@ -38,9 +38,11 @@ env:
   # The SDK when a repository has .NET projects but no global.json to say which.
   EVIDENCE_DOTNET_VERSION: "10.0.x"
   EVIDENCE_MARKER: "<!-- agentic-evidence -->"
-  # How long the run keeps the screenshots it could not archive: a pull request that is not merged
-  # has no plan on the default branch to keep them beside.
+  # How long the run keeps the screenshots it could not commit anywhere.
   EVIDENCE_ARTIFACT_DAYS: "14"
+  # Where an unmerged pull request's screenshots go, under pr-<number>/: its plans are not on the
+  # default branch yet, and a commit to its own branch would invalidate the gate's verdict.
+  EVIDENCE_PREVIEW_BRANCH: "evidence-previews"
   # The capture runs in mcr.microsoft.com/playwright at this tag, pre-pulled by the runner image
   # (runners/versions.env), so the two move together.
   PLAYWRIGHT_VERSION: "1.62.1"
@@ -393,6 +395,72 @@ jobs:
           } >> "$GITHUB_OUTPUT"
           echo "Screenshots kept at ${SERVER}/${REPO}/tree/${sha} beside $(( ${#dirs[@]} - ${#missing[@]} )) plan(s)"
 
+      # The reviewer of a parked pull request needs the screenshots before the merge. One orphan
+      # branch holds every preview, a folder per pull request; GITHUB_TOKEN pushes start no workflow.
+      - name: Commit a preview of the screenshots
+        id: preview
+        if: steps.pr.outputs.merged != 'true'
+        env:
+          TOKEN: ${{ github.token }}
+          REPO: ${{ github.repository }}
+          SERVER: ${{ github.server_url }}
+          PREVIEW: ${{ env.EVIDENCE_PREVIEW_BRANCH }}
+          PR: ${{ inputs.pr-number }}
+        run: |
+          set -euo pipefail
+          src="$RUNNER_TEMP/evidence/files"
+          if [ ! -d "$src" ] || [ -z "$(find "$src" -name '*.jpg' -print -quit)" ]; then
+            echo "base=" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+
+          work="$RUNNER_TEMP/evidence-preview"
+          rm -rf "$work"
+          mkdir -p "$work"
+          cd "$work"
+          auth="AUTHORIZATION: basic $(printf 'x-access-token:%s' "$TOKEN" | base64 -w0)"
+          git init -q
+          git config "http.${SERVER}/.extraheader" "$auth"
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git config core.sparseCheckout true
+          echo "/pr-${PR}/" > .git/info/sparse-checkout
+          git remote add origin "${SERVER}/${REPO}.git"
+
+          pushed=false
+          for attempt in 1 2 3 4 5; do
+            if git fetch -q --depth=1 --filter=blob:none origin "refs/heads/$PREVIEW" 2>/dev/null; then
+              git checkout -q -f -B "$PREVIEW" FETCH_HEAD
+            else
+              # No branch yet: start a fresh orphan each attempt, so a failed push is never
+              # mistaken for one that landed.
+              git checkout -q --orphan "preview-$attempt"
+              git rm -rq --cached . >/dev/null 2>&1 || true
+            fi
+            rm -rf "pr-${PR}"
+            mkdir -p "pr-${PR}"
+            cp -R "$src/." "pr-${PR}/"
+            git add -A "pr-${PR}"
+            if git diff --cached --quiet; then
+              pushed=true
+              break
+            fi
+            git commit -q -m "evidence: preview for #$PR [skip ci]"
+            if git push -q origin "HEAD:refs/heads/$PREVIEW"; then
+              pushed=true
+              break
+            fi
+            echo "$PREVIEW moved before the push (attempt $attempt); retrying on its new tip."
+            sleep $((attempt * 3))
+          done
+          if [ "$pushed" != "true" ]; then
+            echo "::warning::could not push the preview to $PREVIEW after 5 attempts"
+            echo "base=" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+          sha="$(git rev-parse HEAD)"
+          echo "base=${SERVER}/${REPO}/raw/${sha}/pr-${PR}" >> "$GITHUB_OUTPUT"
+
       # GITHUB_TOKEN on purpose: its comment raises no workflow event, so the router does not wake
       # up to read its own record. One comment per pull request, rewritten on a re-run.
       - name: Write the evidence comment
@@ -401,7 +469,9 @@ jobs:
           PR_NUMBER: ${{ inputs.pr-number }}
           MARKER: ${{ env.EVIDENCE_MARKER }}
           MERGED: ${{ steps.pr.outputs.merged }}
-          IMAGE_BASE: ${{ steps.archive.outputs.base }}
+          IMAGE_BASE: ${{ steps.archive.outputs.base || steps.preview.outputs.base }}
+          PREVIEW: ${{ steps.preview.outputs.base != '' && 'true' || 'false' }}
+          PREVIEW_BRANCH: ${{ env.EVIDENCE_PREVIEW_BRANCH }}
           MISSING: ${{ steps.archive.outputs.missing }}
           REASON: ${{ steps.archive.outputs.reason }}
           RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
@@ -421,7 +491,12 @@ jobs:
             // the run's artifact has it instead.
             source = source.replace(/^!\[[^\]]*\]\(__EVIDENCE_BASE__\/([^)]*)\)\n?/gm, (line, file) => (kept(file) ? line : ''));
             const shots = fs.readdirSync(evidence, { recursive: true }).some((name) => String(name).endsWith('.jpg'));
-            if (!base) source = source.replace(/^The screenshots are kept beside each plan.*\n\n?/m, '');
+            if (process.env.PREVIEW === 'true') {
+              source = source.replace(/^The screenshots are kept beside each plan.*$/m,
+                `A preview before the merge: the screenshots are on the \`${process.env.PREVIEW_BRANCH}\` branch for now, and are kept beside each plan once the pull request merges.`);
+            } else if (!base) {
+              source = source.replace(/^The screenshots are kept beside each plan.*\n\n?/m, '');
+            }
             if (shots && (!base || missing.length > 0)) {
               const why = process.env.MERGED !== 'true'
                 ? 'the pull request is not merged, so its plans are not on the default branch'

package/loops/workflows/work-router.yml

@@ -562,12 +562,9 @@ jobs:
   # only changes between gates, every merge re-arms the siblings through
   # detect-pr-conflicts's rescan, and the queue drains one pull request at a time.
   #
-  # `cancel-in-progress: false` protects the RUNNING gate, not the waiting ones: GitHub keeps
-  # exactly one pending run per group and cancels the previously pending one when a new run
-  # arrives. That is fine for the path this belt is built for, where detect-pr-conflicts re-arms
-  # one sibling per merge. It is a trap for a person dispatching by hand: labelling four pull
-  # requests `merge-gate` in one go leaves one running, one pending and two silently cancelled,
-  # with nothing on the pull requests to say so. Dispatch one, let it finish, then the next.
+  # `queue: max` keeps up to 100 gates waiting in order. Without it GitHub keeps one pending run
+  # per group and silently cancels the previous one: in one week Numa cancelled 12 gates and
+  # finished 6, and those pull requests were merged by hand without a verdict.
   call-merge-gate:
     needs: classify
     if: needs.classify.outputs.route == 'merge-gate'
@@ -575,6 +572,7 @@ jobs:
     concurrency:
       group: merge-belt
       cancel-in-progress: false
+      queue: max
     permissions: write-all
     with:
       pr-number: ${{ needs.classify.outputs.pr-number }}
@@ -590,6 +588,94 @@ jobs:
       BOT_PRIVATE_KEY: ${{ secrets.BOT_PRIVATE_KEY }}
       AGENTMEMORY_SECRET: ${{ secrets.AGENTMEMORY_SECRET }}
 
+  # The decision the gate parked for: a person with write access approves a bot pull request the
+  # gate handed to them (human-review or owner-review), and the bot merges the commit they
+  # approved. Re-running the gate would only reproduce the same parked verdict.
+  merge-approved:
+    needs: classify
+    if: needs.classify.outputs.route == 'merge-approved'
+    runs-on: [agents-aw, "affinity-${{ github.repository_id }}-${{ github.run_id }}-${{ github.run_attempt }}"]
+    timeout-minutes: 5
+    concurrency:
+      group: merge-approved-${{ needs.classify.outputs.pr-number }}
+      cancel-in-progress: false
+    permissions:
+      contents: read
+      pull-requests: write
+    steps:
+      - name: Checkout for App token action
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+      - name: Generate App token
+        id: app-token
+        uses: actions/create-github-app-token@bcd2ba49218906704ab6c1aa796996da409d3eb1 # v3.2.0
+        with:
+          app-id: ${{ secrets.BOT_APP_ID }}
+          private-key: ${{ secrets.BOT_PRIVATE_KEY }}
+      - name: Merge the approved commit
+        id: merge
+        env:
+          GH_TOKEN: ${{ steps.app-token.outputs.token }}
+          REPO: ${{ github.repository }}
+          PR: ${{ needs.classify.outputs.pr-number }}
+          ISSUE: ${{ needs.classify.outputs.linked-issue }}
+          REVIEWER: ${{ github.event.review.user.login }}
+          REVIEW_COMMIT: ${{ github.event.review.commit_id }}
+        run: |
+          set -euo pipefail
+          skip() { echo "::notice::Not merging #$PR: $1"; exit 0; }
+
+          permission=$(gh api "repos/$REPO/collaborators/$REVIEWER/permission" --jq '.permission' 2>/dev/null || echo none)
+          case "$permission" in admin|maintain|write) ;; *) skip "$REVIEWER has $permission access" ;; esac
+
+          read -r state author head_sha < <(gh api "repos/$REPO/pulls/$PR" --jq '[.state, .user.login, .head.sha] | @tsv')
+          [ "$state" = open ] || skip "it is $state"
+          case " $TRUSTED_BOTS " in *" $author "*) ;; *) skip "it was opened by $author, not the bot" ;; esac
+          [ "$head_sha" = "$REVIEW_COMMIT" ] || skip "$REVIEWER approved ${REVIEW_COMMIT:0:7}, the head is now ${head_sha:0:7}"
+
+          # Another reviewer's change request still stands.
+          decision=$(gh pr view "$PR" --repo "$REPO" --json reviewDecision --jq '.reviewDecision // ""')
+          [ "$decision" = APPROVED ] || skip "the review decision is '${decision:-none}'"
+
+          # The gate parked it for a person. A protected-path hold comments on the issue rather
+          # than the pull request, so the issue's labels speak for it.
+          verdict=$(gh api --paginate "repos/$REPO/issues/$PR/comments?per_page=100" \
+            --jq '.[] | select((.body | contains("<!-- agent-merge-gate -->")) and (.body | contains("**Verdict:**"))) | .body' |
+            grep -oE '\*\*Verdict:\*\* [a-z-]+' | tail -1 | sed 's/.* //' || true)
+          if [ -z "$verdict" ] && [ -n "$ISSUE" ]; then
+            labels=$(gh api "repos/$REPO/issues/$ISSUE/labels" --jq '[.[].name] | join(" ")')
+            case " $labels " in *" blocked "*) ;; *" owner-review "*) verdict=owner-review ;; esac
+          fi
+          case "$verdict" in human-review|owner-review) ;; *) skip "the gate's verdict is '${verdict:-none}', not a hand-over" ;; esac
+
+          ci=$(gh api "repos/$REPO/actions/runs?head_sha=$head_sha&per_page=100" \
+            --jq '[.workflow_runs[] | select(.name == env.CI_WORKFLOW_NAME)] | sort_by(.created_at) | last | .conclusion // ""')
+          [ "$ci" = success ] || skip "$CI_WORKFLOW_NAME on ${head_sha:0:7} is '${ci:-not run}'"
+
+          gh pr merge "$PR" --repo "$REPO" --squash --match-head-commit "$head_sha"
+          echo "merged=true" >> "$GITHUB_OUTPUT"
+      - name: Clear the issue's labels
+        if: steps.merge.outputs.merged == 'true' && needs.classify.outputs.linked-issue != ''
+        env:
+          GH_TOKEN: ${{ steps.app-token.outputs.token }}
+          REPO: ${{ github.repository }}
+          ISSUE: ${{ needs.classify.outputs.linked-issue }}
+        run: |
+          for label in implement bot-working review owner-review blocked pr-pending; do
+            gh api -X DELETE "repos/$REPO/issues/$ISSUE/labels/$label" >/dev/null 2>&1 || true
+          done
+      # GITHUB_TOKEN: its comment raises no event for the router to read.
+      - name: Say whose approval merged it
+        if: steps.merge.outputs.merged == 'true'
+        env:
+          GH_TOKEN: ${{ github.token }}
+          REPO: ${{ github.repository }}
+          PR: ${{ needs.classify.outputs.pr-number }}
+          REVIEWER: ${{ github.event.review.user.login }}
+          REVIEW_COMMIT: ${{ github.event.review.commit_id }}
+        run: gh pr comment "$PR" --repo "$REPO" --body "Merged on @$REVIEWER's approval of \`${REVIEW_COMMIT:0:7}\`."
+
   # Screenshots of a merged pull request, replayed from the verification plan its implementation
   # wrote and archived beside that plan. Plain YAML with no model, so no secret is passed and the
   # grant is exactly what the publish job writes: one commit of evidence/ folders and one comment. Its capture
@@ -751,7 +837,7 @@ jobs:
           }
 
           # A gate already queued or running for this pull request will read the same CI verdict;
-          # a second dispatch queues behind merge-belt and the single-slot queue cancels it. Same
+          # a second dispatch would wait in the belt's queue and run the same gate twice. Same
           # live-run test as the reconcile belt's stale-reservation sweep, keyed on the exact
           # title run-name gives a gate dispatch.
           gate_is_live() {
@@ -942,7 +1028,7 @@ jobs:
           }
 
           # A gate already queued or running for this pull request will read the same CI verdict;
-          # a second dispatch queues behind merge-belt and the single-slot queue cancels it.
+          # a second dispatch would wait in the belt's queue and run the same gate twice.
           gate_is_live() {
             local pr="$1" status live
             for status in queued in_progress waiting pending; do
@@ -1103,19 +1189,9 @@ jobs:
                 -f "inputs[ci-run-id]=$ci_run_id" \
                 -f "inputs[attempts_so_far]=$attempts"
 
-              # One gate per tick, because that is all the concurrency group can hold. The gate
-              # runs in `merge-belt`, and GitHub keeps only the most recent *pending* run in a
-              # group -- `cancel-in-progress: false` does not change that, it only protects a run
-              # that has already started. A tick that dispatched three gates therefore ran the
-              # last and silently cancelled the other two: no comment, no attempt recorded, and
-              # nothing on the pull request to say it had been passed over. Seen on Pliny-Bot,
-              # where dispatching a gate for PR #135 cancelled the one queued for PR #136.
-              #
-              # Stopping here loses nothing: every pull request eligible this tick is still
-              # eligible next tick, and a run that never started consumes no attempt. The belt
-              # now does one thing and says so, instead of appearing to start work it discarded.
-              echo "One gate dispatched this tick; any other eligible pull request waits for the next one."
-              break
+              # Every eligible pull request in one tick. The belt queues them first in, first out
+              # (`queue: max` on call-merge-gate); before it did, each dispatch cancelled the one
+              # pending ahead of it, so this loop stopped after one and the rest waited an hour.
             done
 
   audit-close:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plainconceptsplatform/workflows",
-  "version": "1.2.3",
+  "version": "1.3.0",
   "description": "Install and update Platform GitHub agentic workflows.",
   "keywords": [
     "github-actions",