diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json
index fca6c06..ead6795 100644
--- a/.claude-plugin/marketplace.json
+++ b/.claude-plugin/marketplace.json
@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "vstack",
-      "version": "1.46.0",
+      "version": "1.47.0",
       "source": "./claude",
       "description": "28 skills that fire without a slash command, 14 agents, 15 commands, and the session hook that routes situations to skills. Most skills are ported from pstack and Superpowers — see claude/skills/ATTRIBUTION.md for per-skill source and license.",
       "category": "workflow"
diff --git a/.claude/verify.sh b/.claude/verify.sh
index 6a7d300..ec841aa 100755
--- a/.claude/verify.sh
+++ b/.claude/verify.sh
@@ -1088,9 +1088,25 @@ if command -v jq >/dev/null; then
   # remote's default branch, not this checkout's path or branch, so it does not vary with either
   # and is left out of the normalization on purpose. A fork whose remote default branch has an
   # unusually long name is a real, separate source of noise this does not cover.)
+  # Mirrors the hook's own resolution exactly, fallbacks included (inject-session-context.sh
+  # around the `symbolic-ref ... origin/HEAD` line): whatever the hook would splice is what has
+  # to be subtracted back out, or the correction is for a different string than the one in the
+  # output being measured.
+  _base_of(){ # dir -> the $base string the hook would splice, post-sanitization
+    _bb=$(git -C "$1" symbolic-ref --quiet --short refs/remotes/origin/HEAD 2>/dev/null \
+          | tr -cd 'A-Za-z0-9._/-' | head -c 80)
+    if [ -z "$_bb" ]; then
+      for _bc in origin/main origin/master; do
+        git -C "$1" rev-parse --verify --quiet "$_bc" >/dev/null 2>&1 && { _bb="$_bc"; break; }
+      done
+    fi
+    [ -n "$_bb" ] || _bb="origin/main"
+    printf '%s' "$_bb"
+  }
   _root_now=$(git -C "$PWD" rev-parse --show-toplevel 2>/dev/null | tr -cd 'A-Za-z0-9 ._/-' | head -c 160)
   _branch_now=$(git -C "$PWD" branch --show-current 2>/dev/null | tr -cd 'A-Za-z0-9._/-' | head -c 80)
   [ -n "$_branch_now" ] || _branch_now='<detached>'
+  _base_now=$(_base_of "$PWD")
   _baseline_raw=$(probe SessionStart '' '')
   # Floor stays on the raw byte count -- "did the hook say anything at all" does not depend on
   # checkout path, and this never fires from trimming a sentence.
@@ -1099,16 +1115,22 @@ if command -v jq >/dev/null; then
   # Worst-case normalized bytes: this checkout's raw measurement, with its own root/branch
   # contribution removed and the hook's documented worst case (root padded to 160, branch to 80)
   # added back. Identical regardless of where the repo sits on disk or what the branch is called.
-  _baseline_worst=$(awk -v raw="$_baseline_raw" -v rl="${#_root_now}" -v bl="${#_branch_now}" \
-    'BEGIN{print raw - 2*rl - bl + 2*160 + 80}')
-  # Cap derived, not chosen: worst-case measured 4423 B on this commit (invariant text 4023 B +
-  # the hook's own 320+80 B worst-case root/branch padding), +25% headroom to match the
-  # philosophy stated at the top of this check. 5632 is that number rounded up to a clean
+  # Two derived numbers, one subtraction. _baseline_inv is the raw count with EVERY
+  # environment-dependent splice removed -- $root twice, $branch once, $base three times -- so it
+  # is the same integer on every machine and is the only count fit to compare against a published
+  # figure. _baseline_worst adds back the hook's documented truncation ceilings (160/80/80) to
+  # give the cap something invariant to bound.
+  _baseline_inv=$(awk -v raw="$_baseline_raw" -v rl="${#_root_now}" -v bl="${#_branch_now}" \
+    -v gl="${#_base_now}" 'BEGIN{print raw - 2*rl - bl - 3*gl}')
+  _baseline_worst=$(awk -v inv="$_baseline_inv" 'BEGIN{print inv + 2*160 + 80 + 3*80}')
+  # Cap derived, not chosen: worst-case measured 4630 B on this commit (invariant text 3990 B +
+  # the hook's own 320+80+240 B worst-case root/branch/base padding), +25% headroom to match the
+  # philosophy stated at the top of this check. 5888 is that number rounded up to a clean
   # multiple of 128. Recompute _baseline_worst by hand if this ever needs re-deriving -- it is
   # not a magic constant, it is this formula's output on the day it was set. Below this cap: the
   # WORKSPACE CONVENTIONS block's structural text is bounded. Above it: something added prose
-  # there, on every checkout, regardless of path length.
-  _baseline_cap=5632
+  # there, on every checkout, regardless of path length or remote default branch.
+  _baseline_cap=5888
   [ "$_baseline_worst" -le "$_baseline_cap" ] \
     || errs="$errs\nsession baseline: normalized $_baseline_worst bytes (raw $_baseline_raw B at this checkout) exceeds the $_baseline_cap byte worst-case cap"
 
@@ -1125,9 +1147,19 @@ if command -v jq >/dev/null; then
   _inv_short="$_inv_root/a"
   _inv_long="$_inv_root/a-much-longer-directory-name-chosen-to-move-the-prefix-by-a-lot"
   mkdir -p "$_inv_short" "$_inv_long"
+  # The two repos differ in path length AND in remote default branch name. $base is spliced
+  # three times into the same block, so a checkout whose origin/HEAD is `origin/a-long-name`
+  # carries ~60 more bytes than one on `origin/main` -- environment text this normalization used
+  # to ignore on the stated grounds that it "does not vary with this checkout." It varies with
+  # the remote, which is no less environmental. Vary both here so neither source can rot unproven.
+  _inv_i=0
   for _id in "$_inv_short" "$_inv_long"; do
     git -C "$_id" init -q >/dev/null 2>&1
     git -C "$_id" symbolic-ref HEAD refs/heads/main >/dev/null 2>&1
+    _inv_i=$((_inv_i + 1))
+    if [ "$_inv_i" = 1 ]; then _inv_b=main
+    else _inv_b=a-deliberately-long-default-branch-name-to-move-the-base-splice; fi
+    git -C "$_id" symbolic-ref refs/remotes/origin/HEAD "refs/remotes/origin/$_inv_b" >/dev/null 2>&1
   done
   _inv_worst(){ # dir -> worst-case normalized byte count for a SessionStart probe run there
     _wd="$1"
@@ -1137,13 +1169,15 @@ if command -v jq >/dev/null; then
     _wr=$(git -C "$_wd" rev-parse --show-toplevel 2>/dev/null | tr -cd 'A-Za-z0-9 ._/-' | head -c 160)
     _wb=$(git -C "$_wd" branch --show-current 2>/dev/null | tr -cd 'A-Za-z0-9._/-' | head -c 80)
     [ -n "$_wb" ] || _wb='<detached>'
-    awk -v raw="$_wraw" -v rl="${#_wr}" -v bl="${#_wb}" 'BEGIN{print raw - 2*rl - bl + 2*160 + 80}'
+    _wg=$(_base_of "$_wd")
+    awk -v raw="$_wraw" -v rl="${#_wr}" -v bl="${#_wb}" -v gl="${#_wg}" \
+      'BEGIN{print raw - 2*rl - bl - 3*gl + 2*160 + 80 + 3*80}'
   }
   _wc_short=$(_inv_worst "$_inv_short")
   _wc_long=$(_inv_worst "$_inv_long")
   rm -rf "$_inv_root"
   [ "$_wc_short" = "$_wc_long" ] \
-    || errs="$errs\npath invariance: normalized byte count disagreed by checkout path length ($_wc_short B at a short prefix vs $_wc_long B at a long one) -- the normalization above is not honest until these agree"
+    || errs="$errs\npath invariance: normalized byte count disagreed by checkout path length and remote default branch ($_wc_short B at a short prefix on origin/main vs $_wc_long B at a long one on a long default branch) -- the normalization above is not honest until these agree"
 
   chk "skills profile"         "$(probe SessionStart skills 1)"  512 2560
   # The README publishes these byte counts as the cost column of its comparison table. A number
@@ -1163,7 +1197,14 @@ if command -v jq >/dev/null; then
   # Three outcomes, three messages. The row missing and the row present with an unparseable
   # value are different repairs, and conflating them sends the next reader looking for a row
   # that is sitting in front of them.
-  _full=$_baseline_raw
+  # The INVARIANT count, not the raw one. Comparing a published figure against a raw measurement
+  # made the README's number a property of the author's directory: this repo measured 4077 B in
+  # a 25-character checkout path on `main` and 4163 B in a clone three characters longer whose
+  # origin/HEAD pointed at a 24-character branch, which is 3.9 KB and 4.1 KB against a 0.15 KB
+  # tolerance. The cap lane above was fixed for exactly this and the figure lane was left reading
+  # raw, so the check passed on one machine and failed everywhere else -- a green that was a
+  # property of where it ran. A published number has to be one a reader can reproduce.
+  _full=$_baseline_inv
   _sk=$(probe SessionStart skills 1)
   _label='Context spent per session'
   _row=$(grep -F "| $_label " README.md 2>/dev/null | head -1)
@@ -1187,7 +1228,7 @@ if command -v jq >/dev/null; then
       || errs="$errs\nREADME quotes ~$_qs KB for the plugin session cost; live is ~$_ls KB"
   fi
   [ -z "$errs" ] \
-    && ok "injected context bounded (digest $(probe UserPromptSubmit '' 1) B, baseline $_full B raw / $_baseline_worst B worst-case)" \
+    && ok "injected context bounded (digest $(probe UserPromptSubmit '' 1) B, baseline $_baseline_raw B raw / $_baseline_inv B invariant / $_baseline_worst B worst-case)" \
     || bad "injected context bounded" "$(printf '%b' "$errs")"
 else
   skip "injected context bounded" "jq not installed"
@@ -3320,6 +3361,192 @@ else
   skip "inventory contract matches the tree" "jq not installed"
 fi
 
+# --- 49. doctor's CI lane answers for the commit you are on, not for the branch ---------------
+# The network call stays in bin/doctor -- this file is offline and hermetic by design, which is
+# why the release-reachability and CI questions live there. What can be gated here is the
+# DECISION, exercised through a `gh` stub with no network and no repository state.
+#
+# Both directions, because the failure this catches was a green: `gh run list --branch main
+# --limit 1` reads a moving reference and takes whatever is newest under it, so a run belonging
+# to an older commit spoke for the one you were standing on. Three of this session's defects
+# reached main because a remote verdict was not read; this is the check that makes the reading
+# itself falsifiable.
+if command -v jq >/dev/null 2>&1 && [ -x bin/doctor ]; then
+  c49_errs=""
+  c49_dir=$(mktemp -d)
+  c49_head=$(git rev-parse HEAD 2>/dev/null)
+  c49_other=0000000000000000000000000000000000000000
+  c49_line(){ # <rows-json> -> doctor's CI line
+    cat > "$c49_dir/gh" <<C49STUB
+#!/bin/sh
+case "\$*" in
+  *"run list"*) printf '%s\n' '$1' ;;
+  *"api"*)      printf '%s\n' '$1' ;;
+  *)            exit 0 ;;
+esac
+C49STUB
+    chmod +x "$c49_dir/gh"
+    # VSTACK_DIR pins doctor to this checkout; resolve_vstack_repo() otherwise prefers the path
+    # install.sh last recorded, and the gate would grade a tree it is not testing.
+    PATH="$c49_dir:$PATH" VSTACK_DIR="$PWD" bash ./bin/doctor 2>&1 | grep -E '^CI' | head -1
+  }
+  c49_row(){ printf '[{"headSha":"%s","name":"verify","status":"%s","conclusion":"%s","displayTitle":"t","databaseId":1}]' "$1" "$2" "$3"; }
+
+  c49_n=0
+  c49_want(){ # <label> <line> <want-glyph-or-none>
+    c49_n=$((c49_n + 1))
+    case "$3" in
+      (green)  case "$2" in (*'✔'*) ;; (*) c49_errs="$c49_errs\n  $1: wanted a green verdict, got: $2" ;; esac ;;
+      (red)    case "$2" in (*'✖'*) ;; (*) c49_errs="$c49_errs\n  $1: wanted a failure verdict, got: $2" ;; esac ;;
+      (none)   case "$2" in (*'✔'*|*'✖'*) c49_errs="$c49_errs\n  $1: wanted no verdict, got: $2" ;; (*) ;; esac ;;
+    esac
+  }
+
+  if [ -z "$c49_head" ]; then
+    skip "doctor's CI lane answers for HEAD" "not a git checkout, so there is no HEAD to answer about"
+  else
+    c49_want "a green run for another commit"      "$(c49_line "$(c49_row "$c49_other" completed success)")" none
+    c49_want "a green run for this commit"         "$(c49_line "$(c49_row "$c49_head"  completed success)")" green
+    c49_want "a failed run for this commit"        "$(c49_line "$(c49_row "$c49_head"  completed failure)")" red
+    c49_want "a run still going for this commit"   "$(c49_line "$(c49_row "$c49_head"  in_progress '')")"    none
+    c49_want "no run for this commit at all"       "$(c49_line '[]')"                                        none
+    [ "$c49_n" -eq 5 ] || c49_errs="$c49_errs\n  only $c49_n of 5 cases were exercised; the case list has collapsed"
+    [ -z "$c49_errs" ] \
+      && ok "doctor's CI lane answers for HEAD ($c49_n cases, both directions, no network)" \
+      || bad "doctor's CI lane answers for HEAD" "$(printf '%b' "$c49_errs")"
+  fi
+  rm -rf "$c49_dir"
+else
+  skip "doctor's CI lane answers for HEAD" "jq not installed or bin/doctor not executable"
+fi
+
+# --- 50. every CI job is a required check, and every required check is a CI job --------------
+# The release gate reads the conclusion of each name in release.yml's REQUIRED_CHECKS. Nothing
+# connected that list to the workflow that produces the jobs, so adding a lane to verify.yml
+# shipped a lane whose verdict no gate ever read: it could be red on every commit and the
+# release would still publish. That is not hypothetical here -- `install-macos` was added, went
+# red on its first run, and the failure was noticed by reading a log by hand.
+#
+# Both directions, because each is a different lie. A job missing from REQUIRED_CHECKS is an
+# unread verdict. A name in REQUIRED_CHECKS with no job behind it never produces a run at all,
+# and require-checks-green.sh reports that as UNDECIDED forever -- a release that can never
+# publish, which is the deadlock this session already fixed once from the other end.
+_c50_wf=.github/workflows/verify.yml
+_c50_rl=.github/workflows/release.yml
+if [ -f "$_c50_wf" ] && [ -f "$_c50_rl" ]; then
+  c50_errs=""
+  # Job keys are the two-space-indented mapping keys inside the top-level `jobs:` block. Scoped
+  # to that block on purpose: `on:` carries `push:` and `pull_request:` at the same indent, and
+  # a selector that only matched indentation would call those two CI jobs.
+  _c50_jobs=$(awk '
+    /^jobs:[[:space:]]*$/ {inj=1; next}
+    inj && /^[^[:space:]#]/ {inj=0}
+    inj && /^  [A-Za-z0-9_-]+:[[:space:]]*$/ {gsub(/[: ]/,""); print}
+  ' "$_c50_wf" | sort)
+  _c50_req=$(sed -n 's/^  REQUIRED_CHECKS:[[:space:]]*//p' "$_c50_rl" | head -1 | tr ' ' '\n' | sed '/^$/d' | sort)
+  # Neither list may be empty: an empty selector makes both comparisons below vacuously true,
+  # which is the exact shape this file catalogues.
+  if [ -z "$_c50_jobs" ]; then
+    c50_errs="$c50_errs\nno jobs parsed out of $_c50_wf -- the selector matched nothing, so the comparison below would pass on any workflow at all"
+  fi
+  if [ -z "$_c50_req" ]; then
+    c50_errs="$c50_errs\nno names parsed out of $_c50_rl's REQUIRED_CHECKS -- the release gate would be comparing against an empty list"
+  fi
+  if [ -n "$_c50_jobs" ] && [ -n "$_c50_req" ]; then
+    _c50_unread=$(comm -23 <(printf '%s\n' "$_c50_jobs") <(printf '%s\n' "$_c50_req"))
+    _c50_phantom=$(comm -13 <(printf '%s\n' "$_c50_jobs") <(printf '%s\n' "$_c50_req"))
+    [ -z "$_c50_unread" ] \
+      || c50_errs="$c50_errs\nCI job(s) no gate reads: $(printf '%s' "$_c50_unread" | tr '\n' ' ') -- add them to REQUIRED_CHECKS in $_c50_rl or the release publishes over their red"
+    [ -z "$_c50_phantom" ] \
+      || c50_errs="$c50_errs\nREQUIRED_CHECKS name(s) with no job behind them: $(printf '%s' "$_c50_phantom" | tr '\n' ' ') -- nothing will ever report for these, so the gate stays UNDECIDED forever"
+  fi
+  _c50_njobs=$(printf '%s' "$_c50_jobs" | grep -c . )
+  [ -z "$c50_errs" ] \
+    && ok "every CI job is a required check ($_c50_njobs jobs, both directions)" \
+    || bad "every CI job is a required check" "$(printf '%b' "$c50_errs")"
+else
+  bad "every CI job is a required check" "$_c50_wf or $_c50_rl is missing -- CI itself is gone, which is a failure and not an environment fact"
+fi
+
+# --- 51. the one destructive step in the release workflow decides correctly -------------------
+# cleanup-on-failed-gate force-deletes a candidate tag from origin. It is the only step in this
+# repository that destroys something a human might not be able to reconstruct, and until now it
+# was also the only step whose decision could not be run: the whole rule lived in a GitHub
+# Actions `if:` expression. It was wrong in production on 2026-08-27 -- it deleted the tag for a
+# gate that was UNDECIDED rather than failed, and since verify cannot go green until the tag is
+# on origin, no tag could survive long enough to earn the green it needed.
+#
+# The rule now lives in .github/scripts/should-delete-candidate-tag.sh and tests/release-cleanup.sh
+# is its truth table. This check runs that table BOTH WAYS: against the real decider, which must
+# pass, and against a copy with the undecided carve-out removed, which must fail. A truth table
+# that cannot go red proves nothing about the decider it points at -- and that is not a
+# hypothetical concern in this file, it is entry after entry in
+# docs/checks-that-inherit-their-answer.md.
+if [ -x tests/release-cleanup.sh ] && [ -f .github/scripts/should-delete-candidate-tag.sh ]; then
+  c51_errs=""
+  ./tests/release-cleanup.sh >/dev/null 2>&1 \
+    || c51_errs="$c51_errs\nthe release-cleanup truth table fails against the real decider: $(./tests/release-cleanup.sh 2>&1 | grep '^FAIL' | head -3 | tr '\n' ' ')"
+  # Positive control. Remove the carve-out that keeps an undecided tag alive; the table must
+  # notice. If it still passes, the table is not reading the decider and nothing above is
+  # evidence of anything.
+  c51_dir=$(mktemp -d)
+  sed 's/if \[ "$gate" = undecided \]; then/if false; then/' \
+    .github/scripts/should-delete-candidate-tag.sh > "$c51_dir/broken.sh"
+  chmod +x "$c51_dir/broken.sh"
+  if cmp -s "$c51_dir/broken.sh" .github/scripts/should-delete-candidate-tag.sh; then
+    c51_errs="$c51_errs\nthe control mutation changed nothing -- the sed pattern no longer matches the decider, so the both-directions claim below is vacuous"
+  elif RELEASE_CLEANUP_SCRIPT="$c51_dir/broken.sh" ./tests/release-cleanup.sh >/dev/null 2>&1; then
+    c51_errs="$c51_errs\nthe truth table passed against a decider with the undecided carve-out deleted -- it is not reading the script it names"
+  fi
+  rm -rf "$c51_dir"
+  [ -z "$c51_errs" ] \
+    && ok "release cleanup decides correctly (truth table both directions)" \
+    || bad "release cleanup decides correctly" "$(printf '%b' "$c51_errs")"
+else
+  bad "release cleanup decides correctly" "tests/release-cleanup.sh is not executable or .github/scripts/should-delete-candidate-tag.sh is missing -- the destructive step is back to having no test, which is a failure and not an environment fact"
+fi
+
+# --- 52. the bin-scripts suite can actually fail ----------------------------------------------
+# tests/bin-scripts.sh prints "38 passed, 0 failed" and nothing had ever asked whether it can
+# print anything else. That is the same question tests/gate-falsifiability.sh asks of every gate
+# check, and this repository's own history says a suite that has never been watched red is a
+# suite nobody has evidence about: bin-scripts itself shipped claiming it never reaches the real
+# `claude` CLI while two of its cases did exactly that, undetected until a poison stub was added.
+#
+# Scoped to the `bg-args` case and to a two-file copy of the tree, which runs in about two
+# seconds. The full suite is 17s and the point here is falsifiability, not coverage -- coverage
+# is what CI's own bin-scripts step is for.
+#
+# NOT COVERED, stated rather than skipped: tests/install-matrix.sh has no equivalent control.
+# Its cheapest single case measured 2m10s, which does not belong in an offline gate, and it is
+# currently red for an unrelated reason (a declared-but-untagged release), so a "must fail when
+# broken" control against it would pass without measuring anything. That gap is real and is
+# named in docs/checks-that-inherit-their-answer.md rather than papered over here.
+if [ -f tests/bin-scripts.sh ] && [ -f bin/claude-bg.sh ]; then
+  c52_errs=""
+  c52_dir=$(mktemp -d)
+  mkdir -p "$c52_dir/bin" "$c52_dir/tests"
+  cp bin/claude-bg.sh bin/claude-task.sh "$c52_dir/bin/" 2>/dev/null
+  cp tests/bin-scripts.sh "$c52_dir/tests/"
+  # Direction one: the suite passes on the tree as it stands. If this fails the suite is telling
+  # the truth about a real defect, and the control below would be meaningless anyway.
+  ( cd "$c52_dir" && bash tests/bin-scripts.sh bg-args >/dev/null 2>&1 ) \
+    || c52_errs="$c52_errs\ntests/bin-scripts.sh bg-args fails against the tree as it stands -- run it directly; either bin/claude-bg.sh has a defect or the suite does"
+  # Direction two: break the argument guard the case is about, and the suite must notice.
+  sed 's/^if \[ $# -eq 0 \]; then/if false; then/' bin/claude-bg.sh > "$c52_dir/bin/claude-bg.sh"
+  if cmp -s "$c52_dir/bin/claude-bg.sh" bin/claude-bg.sh; then
+    c52_errs="$c52_errs\nthe control mutation changed nothing -- the no-args guard in bin/claude-bg.sh was reworded, so this check's falsifiability claim is vacuous until the pattern is repointed"
+  elif ( cd "$c52_dir" && bash tests/bin-scripts.sh bg-args >/dev/null 2>&1 ); then
+    c52_errs="$c52_errs\ntests/bin-scripts.sh passed against a claude-bg.sh whose no-args guard was deleted -- the suite is not reading the script it names"
+  fi
+  rm -rf "$c52_dir"
+  [ -z "$c52_errs" ] \
+    && ok "the bin-scripts suite can actually fail (bg-args, both directions; install-matrix uncovered by design, see the check comment)" \
+    || bad "the bin-scripts suite can actually fail" "$(printf '%b' "$c52_errs")"
+else
+  bad "the bin-scripts suite can actually fail" "tests/bin-scripts.sh or bin/claude-bg.sh is missing -- the suite this check proves falsifiable is gone, which is a failure and not an environment fact"
+fi
+
 echo
 # Accounting. Every declared check must have reported either a result or a skip. A check
 # that throws a shell error mid-body, or is wrapped in a conditional with no else, silently
diff --git a/.github/scripts/should-delete-candidate-tag.sh b/.github/scripts/should-delete-candidate-tag.sh
new file mode 100755
index 0000000..0130143
--- /dev/null
+++ b/.github/scripts/should-delete-candidate-tag.sh
@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+# should-delete-candidate-tag.sh — decides whether a candidate release tag has earned deletion.
+#
+# This decision used to live entirely in a GitHub Actions `if:` expression on the
+# cleanup-on-failed-gate job. An `if:` expression cannot be run, so the one piece of this
+# workflow that destroys something -- it force-deletes a tag from origin -- was the only piece
+# with no test. It has already been wrong once in production: on 2026-08-27 it deleted the tag
+# for a gate that was UNDECIDED rather than failed, which deadlocked releases, because verify
+# cannot go green until the tag is on origin and the tag could not survive long enough for
+# verify to finish.
+#
+# The rule, stated once so both the workflow and its test read the same sentence:
+#
+#   Delete when a required job has DECIDED against this tag. Keep when nothing has decided yet.
+#
+# "Undecided" is the only carve-out and it is deliberately narrow. Every other refusal -- a
+# decided failure, a bad tag name, a commit that is not an ancestor of main, a gate step that
+# died before it could set its verdict -- still deletes, so "a failed required job cannot
+# produce a published tag" holds exactly as it did before the carve-out existed.
+#
+# Usage: should-delete-candidate-tag.sh <resolve-result> <gate-verdict> <matrix-result>
+#   resolve-result  the `needs.resolve.result` string: success | failure | cancelled | skipped
+#   gate-verdict    the `needs.resolve.outputs.gate` string: green | failed | undecided | ""
+#   matrix-result   the `needs.container-matrix.result` string
+#
+# Exit codes, distinct on purpose. 1 is reserved for "this script broke", so a crash can never
+# be mistaken for either verdict:
+#   0   DELETE  -- something decided against this tag
+#   10  KEEP    -- nothing has decided against it yet
+#   2   usage error
+set -euo pipefail
+
+if [ "$#" -ne 3 ]; then
+  echo "usage: should-delete-candidate-tag.sh <resolve-result> <gate-verdict> <matrix-result>" >&2
+  exit 2
+fi
+
+resolve="$1"
+gate="$2"
+matrix="$3"
+
+# The container matrix has no undecided state to carve out: it either ran the images or it did
+# not, and a failure there is a decision. Checked first because it is unconditional.
+if [ "$matrix" = failure ]; then
+  echo "DELETE  container-matrix failed -- the images this tag claims to support did not build"
+  exit 0
+fi
+
+if [ "$resolve" = failure ]; then
+  if [ "$gate" = undecided ]; then
+    # The whole reason this script exists. A gate that has not been answered has not answered NO.
+    echo "KEEP    resolve failed but the gate is undecided -- nothing has decided against this tag, and deleting on 'not yet' deadlocks the release"
+    exit 10
+  fi
+  # Includes gate=failed, gate=green-but-a-later-step-failed, and gate="" for a job that died
+  # before the gate step ran. Conservative direction: anything that is not specifically "not
+  # yet" is treated as a decision.
+  echo "DELETE  resolve failed with gate='${gate:-<unset>}' -- a required check decided against this tag, or the job died before it could say otherwise"
+  exit 0
+fi
+
+echo "KEEP    resolve=${resolve} matrix=${matrix} -- no required job failed"
+exit 10
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 750f330..5240118 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -149,14 +149,38 @@ jobs:
     # Every other refusal -- a decided failure, a bad tag name, a commit that is not an ancestor
     # of main, a gate step that never ran -- still deletes, so "a failed required job cannot
     # produce a tag" holds exactly as before.
-    if: always() && ((needs.resolve.result == 'failure' && needs.resolve.outputs.gate != 'undecided') || needs.container-matrix.result == 'failure')
+    # Deliberately BROADER than the delete rule. This condition only decides whether the job
+    # gets a runner; .github/scripts/should-delete-candidate-tag.sh decides whether anything is
+    # deleted, and check 51 asserts this expression carries no part of that rule. An `if:`
+    # expression cannot be executed by a test, so the one destructive step in this workflow had
+    # the one decision nobody could exercise -- and it was wrong in production on 2026-08-27.
+    # Broad here is safe: a job that runs and then declines to delete costs a runner minute. A
+    # condition narrower than the script would silently skip deletions the rule requires.
+    if: always() && (needs.resolve.result != 'success' || needs.container-matrix.result != 'success')
     runs-on: ubuntu-latest
     permissions:
       contents: write
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
+      - name: Has anything actually decided against this tag?
+        id: decide
+        run: |
+          set +e
+          bash .github/scripts/should-delete-candidate-tag.sh \
+            "${{ needs.resolve.result }}" \
+            "${{ needs.resolve.outputs.gate }}" \
+            "${{ needs.container-matrix.result }}"
+          rc=$?
+          set -e
+          case "$rc" in
+            0)  echo "delete=yes" >> "$GITHUB_OUTPUT" ;;
+            10) echo "delete=no"  >> "$GITHUB_OUTPUT" ;;
+            *)  echo "should-delete-candidate-tag.sh exited $rc, which is neither verdict; refusing to guess"; exit 1 ;;
+          esac
+
       - name: Delete the candidate tag; it did not earn publication
+        if: steps.decide.outputs.delete == 'yes'
         run: |
           set -euo pipefail
           TAG="${{ github.event.inputs.tag || github.ref_name }}"
diff --git a/.github/workflows/verify.yml b/.github/workflows/verify.yml
index 1bd7b83..226f16d 100644
--- a/.github/workflows/verify.yml
+++ b/.github/workflows/verify.yml
@@ -311,8 +311,29 @@ jobs:
       - name: Install matrix on macOS
         run: ./tests/install-matrix.sh
 
+      # check 29 ("shellcheck clean") skips without a validator on PATH, and a skip is not a pass.
+      # macos-latest stopped shipping shellcheck, so this lane silently stopped linting all 71
+      # scripts on the one platform whose BSD tools this job exists to exercise. Installed here
+      # rather than added to the approved-skip list below, for the same reason the alpine lane
+      # installs it: approving the skip would make the check disappear and the lane still green.
+      - name: shellcheck for macOS, or fail naming it
+        run: |
+          brew install shellcheck
+          shellcheck --version
+
+      # NOT piped into tee. Under this workflow's default `bash -e` shell there is no pipefail, so
+      # `verify.sh | tee` returns tee's status and a red gate exits 0. Measured on 2026-08-27:
+      # `bash -e -c 'red-gate | tee f'` exits 0, the same command unpiped exits 1, and the skip
+      # audit below exits 0 on a log full of FAIL lines because it only reads skip lines. A failing
+      # gate on this lane has therefore never failed this job. The redirect keeps the log for the
+      # skip audit, `|| rc=$?` keeps `-e` from exiting before the code is read, and the exit is on
+      # its own line where it can be seen.
       - name: Run the verification gate
-        run: ./.claude/verify.sh | tee "$RUNNER_TEMP/gate-macos.txt"
+        run: |
+          rc=0
+          ./.claude/verify.sh > "$RUNNER_TEMP/gate-macos.txt" 2>&1 || rc=$?
+          cat "$RUNNER_TEMP/gate-macos.txt"
+          exit "$rc"
 
       # This lane declares, out loud, the only two checks it accepts as skips: the CLI is not
       # installed here on purpose (only the ubuntu `verify` job proves check 19 runs, per the
@@ -368,7 +389,13 @@ jobs:
         run: bash ./tests/install-matrix.sh
 
       - name: Run the verification gate
-        run: bash ./.claude/verify.sh | tee "$RUNNER_TEMP/gate-alpine.txt"
+        # Not piped, for the reason spelled out on the macOS lane above: no pipefail under this
+        # shell means `gate | tee` reports tee's status and a red gate passes.
+        run: |
+          rc=0
+          bash ./.claude/verify.sh > "$RUNNER_TEMP/gate-alpine.txt" 2>&1 || rc=$?
+          cat "$RUNNER_TEMP/gate-alpine.txt"
+          exit "$rc"
 
       # Same declaration as the macOS lane: the CLI is deliberately absent here too, and the
       # version-tag check is expected to skip pre-release. shellcheck is no longer on this list
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ab9ad10..d810aca 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,180 @@ Versions follow [semver](https://semver.org). The version lives in two manifests
 `.claude-plugin/marketplace.json` and `claude/.claude-plugin/plugin.json`, and check 13 of
 `.claude/verify.sh` fails when they disagree.
 
+## 1.47.0 — 2026-08-27
+
+### `bin/doctor`'s CI check answered for the branch, not for your commit
+
+    gh run list --branch main --limit 1 --json conclusion,status,displayTitle,databaseId
+
+`--branch main` is a moving reference and `--limit 1` takes whatever is newest under it. The
+projection carried no `headSha`, so nothing downstream could have filtered by commit even if it
+had wanted to. Standing on a commit whose CI had never run, or had failed, printed
+
+    CI (main: an OLDER commit that passed)   ✔
+
+which is a true statement about a different commit. `--limit 1` also picked one workflow
+arbitrarily when several run per commit: this repo runs `verify` and `release`, and on 2026-08-27
+`release` completed with a failure while `verify` was still going, so which one spoke for the
+commit depended on timing.
+
+`.github/workflows/release.yml`'s own header warns against precisely this -- "a moving branch ref
+answers 'is the newest thing on this branch green', which silently drifts to a different commit"
+-- and the check whose job is to stop a release going out over red CI reproduced it. Three
+defects reached `main` in one day because a remote verdict went unread; this is the check that was
+supposed to catch that, reporting green about somebody else's commit.
+
+It now reads every run recorded against `HEAD` and orders the answer: a decided failure outranks
+any number of runs still going, in-progress is a note, and **no run for this commit is a note, not
+a pass**. An unpushed commit has no CI verdict and the newest run on the branch is not a stand-in
+for one.
+
+**Check 49** gates the decision offline, through a `gh` stub, five cases, both directions. The
+network call stays in `bin/doctor` -- `.claude/verify.sh` is hermetic by design, which is why the
+CI and release-reachability questions live there in the first place. What belongs in the gate is
+the decision, and now it is falsifiable: row 49 deletes the commit filter and check 49 goes red.
+Also pinned by `tests/repro/ci-lane-answers-for-head.sh`, which was watched failing on exactly two
+of its five cases before the fix.
+
+
+### Two published measurements had no surviving artifact
+
+`CHANGELOG.md` cited "80 samples" for the skill-collision suppression finding and "a uniform 0/5
+across five fixtures" as the motivation for the 1.43.0 replay log. Neither number can be re-read.
+There is no 80-sample runlog in git history or on this machine; the only collision arm on record
+is 55 samples on `col-11` alone (`tests/README.md:188`), and its instrument was an uncommitted
+edit to `tests/dispatch-fleet.sh` — the fence comment at line 180 of that file already said so.
+Its runlog at `/private/tmp/vstack-dispatch-pilot-col.jsonl` no longer exists. The 0/5 figure is
+worse than unsourced: the harness cannot produce that shape at all, because at
+`tests/dispatch-fleet.sh:678-688` only `kind=="skill"` and `kind=="none"` fixtures receive a
+numeric `k`, so a `CHAIN:` or `AMBIGUOUS:` fixture returns `{k: null}` and never prints a
+fraction. Two of the five fixtures in that arm are exactly those kinds.
+
+This is the repository's own subject applied to its own evidence base. A check that inherits its
+answer returns a true statement about the wrong question; a citation whose artifact is gone is the
+same defect one level up — it reads as measured, and there is nothing left to disagree with. Both
+lines are kept in place with a retraction note attached rather than deleted, which is how
+`tests/evals/RESULTS.md` already handles its retracted pathway run. The direction each arm reported
+stands as what it reported. The n is withdrawn from both.
+
+### Replacement arm, pre-registered before it runs
+
+`tests/evals/collision/PREREGISTRATION.md`. The question is deliberately not "why did those
+fixtures score zero" — that is unanswerable now — but the one a single arm structurally cannot
+answer: when a skill fails to fire on a collision-framed prompt, was it the collision, or does that
+skill not fire under this harness on any prompt? Matched pairs, 5 arms × n=5 = 25 model calls:
+`swarm` and `principle-encode-lessons-in-structure` each on their clean `pos-*` fixture and their
+`col-*` fixture, plus `col-01` ("Tear this apart.") which is a literal trigger string in both
+`grill-me`'s and `interrogate`'s descriptions.
+
+Thresholds, void conditions and named invalidators are fixed in that file before the first sample.
+The fixture file is pinned by `sha256`, not by path, because `~/vstack-dispatch/` is not a git
+repository and the path alone does not identify what ran. `tests/dispatch-fleet.sh` is **not
+edited**: every parameter goes through the committed env overrides, which exist precisely because
+a source edit is what destroyed the previous arm. The runlog is written to a tracked path in the
+repository and committed with the results, and `KEEP_WORKDIRS=1` retains the transcripts.
+
+The arm also bears on H11 at no extra cost. `swarm`'s affordance is the `Agent` tool, which the
+harness's own guard (`dispatch-fleet.sh:195-224`) requires to be denied;
+`principle-encode-lessons-in-structure` produces prose and needs no denied tool. If `swarm` is
+silent on both its fixtures while the prose skill fires on its positive, the fence explains that
+zero and collision does not. This does not discharge the publication gate at
+`dispatch-fleet.sh:277-283`; arm A5 of `tests/evals/build-the-lever/PREREGISTRATION.md` remains its
+named condition, and no fleet-wide figure is derived here.
+
+### The arm reported, and the collision explanation did not survive it
+
+25 samples, every one `subtype=success`, no fence violations, `--score-only` reproduces every figure
+from the committed runlog with no model calls. `tests/evals/collision/RESULTS.md` carries the full
+report; `tests/evals/collision/runlog-2026-08-27.jsonl` is committed beside it.
+
+`swarm` fired 0/5 on its clean positive fixture and 0/5 on its collision fixture.
+`principle-encode-lessons-in-structure` did the same. `col-01`, whose prompt is a literal trigger
+string in two competing skill descriptions, fired `interrogate` once in five and nothing in the
+other four. One `Skill` call in 25 samples. H-C2 falsified for both skills; H-C3 confirmed for both.
+
+`KEEP_WORKDIRS=1` kept all 25 transcripts, which is the thing the lost arm could not do, and they
+name the mechanism. The harness runs every sample in an empty `mktemp -d`, so a prompt that refers
+to a repository, a diff or a prior turn has no referent: all five `pos-19` samples globbed, found no
+packages and asked which repository held them. The fence denies `Write`, so a skill whose action is
+to write a file gets as far as the attempt: all five `pos-11` samples called `Write` and were
+refused. The routing was never missing. The model named `swarm` in prose without calling it in 7 of
+10 `swarm` samples, and named `interrogate` or `grill-me` in 4 of 5 `col-01` samples.
+
+One mechanism therefore explains both arms of the anomaly, and it is the instrument.
+`tests/dispatch-fleet.sh` records `fired=[]` identically for "the dispatcher did not route" and "the
+model asked which repository you meant", and it deleted the transcripts that tell them apart until
+`KEEP_WORKDIRS` existed. Every dispatch rate taken through it inherits that confound.
+
+H11 is confirmed wider than it was registered. The publication gate asks whether denying `Write`
+suppresses skills whose output is an artifact. This arm picked
+`principle-encode-lessons-in-structure` as the fence-immune control because its output is prose, and
+5 of 5 samples disproved that premise by calling `Write`. The gate stays closed and its priority
+goes up.
+
+**H-C1's threshold was mis-specified, in the pre-registration written to prevent that.** It was a
+bare bound on one arm: empty in ≥4/5 confirms suppression. `col-01` returned empty in 4/5, so the
+threshold was met, and it means nothing, because both controls returned empty in 5/5 and empty was
+the modal outcome of every fixture in the run. Written without a control clause, H-C1 returns
+CONFIRM on any run in which nothing fires at all. That is the fourteenth instance of the defect in
+`docs/checks-that-inherit-their-answer.md`, and it is in the instrument written to measure the
+thirteenth. The corrected form is recorded in `tests/evals/collision/RESULTS.md` and is not applied
+retroactively to score this run.
+
+### The whole evidence base, as one document
+
+`docs/research/fake-greens-2026-08.md`. What was measured, what the numbers do not support, and the
+thirteen checks that passed while measuring nothing, each with the path and date it came from.
+Numbers without a surviving artifact are marked unsourced and support nothing.
+
+A `code-reviewer` pass against the tree caught four wrong figures in the draft before it landed:
+`guard-quote-aware-split.sh` is 18/18 and not 15/15, the SWE-bench row is 4 instances and not 3, the
+catalogue grew by six in the 2026-08-26/27 window and not seven, and the "true statement read as the
+answer to a different question" sub-shape covers two entries and not three. The same pass found that
+`docs/research/` is excluded by construction from check 12's doc-count extractor and check 38's
+path-existence scan, so neither gate would have caught any of them. A document about checks that
+measure nothing is not covered by the checks.
+
+### A red gate has never failed CI on macOS or Alpine
+
+Two of the three platform lanes ran the gate as `./.claude/verify.sh | tee "$RUNNER_TEMP/gate.txt"`.
+GitHub's default shell for a `run:` block is `bash -e` with no `pipefail`, so the step's exit status
+is `tee`'s, and `tee` succeeds whatever the gate did. Measured both directions on 2026-08-27 against
+a seeded gate that prints `FAIL` and exits 1: `bash -e -c 'gate | tee f'` exits **0**, the same
+command unpiped exits **1**. The one downstream step that reads the captured log,
+`.github/scripts/require-no-unexpected-skips.sh`, exits **0** on a log full of `FAIL` lines, because
+it only inspects skip lines. So a failing gate on macOS or Alpine passed the job, passed the audit,
+and was never visible.
+
+This is the rule the repository already wrote down after a local `./verify.sh | tail` produced a
+false green, applied everywhere except the two lanes that needed it. Both now redirect to a file,
+capture the status with `|| rc=$?` so `-e` cannot exit before the code is read, print the log, and
+`exit "$rc"` on its own line.
+
+The macOS lane also stopped linting. `macos-latest` no longer ships `shellcheck`, so check 29
+skipped, and the lane's approved-skip list did not cover it. That skip is what the lane's own audit
+caught, and it is the reason this was found at all. Fixed by installing `shellcheck` rather than by
+approving the skip, matching the alpine lane, whose comment already says a check that skips is
+measuring nothing. Approving it would have left 71 scripts unlinted on the one platform whose BSD
+tools this job exists to exercise, with the lane still green.
+
+### v1.46.0 was tagged locally and never pushed
+
+CI had been red on `main` for three commits for one reason: `install-macos` and `install-linux` both
+failed `doctor is green on a clean install` with "v1.46.0 is declared and pinned in the README but is
+not on origin". The tag existed at `cc5bf690`, which is `origin/main`'s own head, so pushing it
+published no commits and turned the lane green. Read from `gh run list --json conclusion`, not from
+a local exit code, which is the only way this class of failure is visible at all.
+
+### Stale counts in `docs/what-this-actually-does.md`
+
+The document stated 44 gate checks and falsifiability totals of `60 declared` and `61 declared`.
+The tree declares 52 checks and 80 falsifiability rows (77 mutation + 3 fixed). The old figures
+were true on their run dates and are now marked as superseded with those dates attached, rather
+than replaced with a number nobody re-ran for this document — the document's own rule is that no
+claim appears without a source and a date.
+
+
 ## 1.46.0 — 2026-08-27
 
 ### claude-mem removed
@@ -23,6 +197,14 @@ read path is a skill, `mem-search`, which would arrive with 18 others — `do`,
 and `find-skills`. Colliding triggers were measured over 80 samples to suppress both skills, not
 one, so the trade was working skills for a store nothing read back.
 
+> **Retraction note added in 1.47.0: the "80 samples" above is unsourced.**
+> No 80-sample runlog exists in git history or on this machine. The only collision arm on record
+> is 55 samples on `col-11` alone (`tests/README.md:188`), produced by an uncommitted edit to
+> `tests/dispatch-fleet.sh` — its own fence comment at line 180 says so — and its runlog at
+> `/private/tmp/vstack-dispatch-pilot-col.jsonl` is gone. The direction of the finding is what
+> that arm reported; its n is withdrawn. Replacement arm pre-registered at
+> `tests/evals/collision/PREREGISTRATION.md`.
+
 Removed from `setup-machine.sh` (the plugin list and the whole `hooks.json` async-flipper),
 `install.sh` (the `enabledPlugins` presence probe; the entry is now deleted unconditionally),
 `bin/doctor` (both checks), `claude/statusline.sh` (the indicator), `README.md` and
@@ -602,6 +784,14 @@ created by any test in this suite. One gap stated rather than left to be discove
 matcher never sees `PostToolUseFailure`, which carries `error` instead of `tool_response`, so a
 dispatch that *failed* is invisible to the replay log. The rows record what ran, not what broke.
 
+> **Retraction note added in 1.47.0: the "uniform 0/5 across five fixtures" above is unsourced.**
+> No runlog, no transcripts and no fixture list survive for that arm, and the harness cannot
+> produce that shape: at `tests/dispatch-fleet.sh:678-688` only `kind=="skill"` and
+> `kind=="none"` fixtures receive a numeric `k`, so a `CHAIN:` or `AMBIGUOUS:` fixture returns
+> `{k: null}` and can never print `0/5`. The defect this paragraph describes is real and the fix
+> shipped; the measurement quoted as its motivation cannot be re-read. Kept with the reason
+> attached rather than deleted, as `tests/evals/RESULTS.md` keeps its retracted run.
+
 ## 1.42.0 — 2026-08-23
 
 **The cloud sandbox gate has never armed, and has shipped inert since v1.30.0.** `overlay.sh`
diff --git a/README.md b/README.md
index 11d3ed3..07598df 100644
--- a/README.md
+++ b/README.md
@@ -23,7 +23,7 @@ Two directory pairs differ only by a leading dot, and the difference is the whol
 | path | what it is |
 |---|---|
 | `claude/` | the **shipped payload** — skills, subagents, commands, hooks, installed to `~/.claude/` |
-| `.claude/verify.sh` | **this repository's own gate**, 48 checks; not shipped to anyone |
+| `.claude/verify.sh` | **this repository's own gate**, 52 checks; not shipped to anyone |
 | `conductor/` | payload copied to `~/.conductor/` |
 | `.conductor/` | this repository's own workspace config |
 | `tests/` | the suites: the falsifiability harness, the install matrix, trigger and baseline tests |
@@ -195,7 +195,7 @@ reaches for `unslop`, reviewing TypeScript reaches for `typescript-best-practice
 
 ## Checks that can fail
 
-The gate is 48 checks (this number moves as checks are added; check 12 fails if this prose
+The gate is 52 checks (this number moves as checks are added; check 12 fails if this prose
 and the tree disagree, so it stays honest by construction rather than by discipline).
 `tests/gate-falsifiability.sh` breaks the repository once per check, at
 least once and more where a check can fail in more than one way, requires the gate to go red
@@ -204,7 +204,7 @@ naming that check, restores the tree byte for byte, and fails if anything was le
 can fail.
 
 ```bash
-./.claude/verify.sh                  # 48 checks
+./.claude/verify.sh                  # 52 checks
 VSTACK_FALSIFY_ROWS=27 ./tests/gate-falsifiability.sh          # one row
 git clone . /tmp/vstack-check && cd /tmp/vstack-check && ./tests/gate-falsifiability.sh
 ```
@@ -336,6 +336,7 @@ true.
 - [How skills fire](docs/how-skills-fire.md) — the routing mechanism and what was measured
 - [Checks that inherit their answer](docs/checks-that-inherit-their-answer.md) — the failure shape behind every fake green found here
 - [What this actually does](docs/what-this-actually-does.md) — every claim sorted into measured, mechanism-only, and unproven, each dated and sourced
+- [Checks that measure nothing](docs/research/fake-greens-2026-08.md) — the whole evidence base in one paper
 - [Do harnesses help?](docs/research/do-harnesses-help.md) — the null result, in full
 - [Harness value: literature](docs/research/harness-value-literature-2026-08.md) — what anyone has actually measured
 - [What we changed, and what we declined](docs/research/what-we-changed-2026-08-22.md)
diff --git a/bin/doctor b/bin/doctor
index 72dd4b9..d4e0a69 100755
--- a/bin/doctor
+++ b/bin/doctor
@@ -1070,10 +1070,27 @@ fi
 [ "${1:-}" = "--mcp" ] && { echo "── mcp ──"; claude mcp list 2>/dev/null | grep -E 'Connected|Failed'; }
 section "CI"
 # GitHub Actions CI health is unverifiable locally — what runs green here may fail in the sandbox.
-# This check reaches GitHub to read the conclusion of the last run on main. If CI is failing, any
-# release built from that commit is unreliable, and any install from that release inherits the
-# unseen breakage. `gh run list` reports both the conclusion (success/failure/cancelled/timed_out)
-# and the status (completed/in_progress/requested/queued/stale); this check handles both.
+# This check reaches GitHub to read the conclusion of every run recorded against THE COMMIT YOU
+# ARE STANDING ON. If CI is failing, any release built from that commit is unreliable, and any
+# install from that release inherits the unseen breakage.
+#
+# It used to ask `gh run list --branch main --limit 1`. `--branch main` is a moving reference and
+# `--limit 1` takes whatever is newest under it; the projection carried no `headSha`, so nothing
+# downstream could have filtered by commit even if it had wanted to. Standing on a commit whose
+# CI had never run, or had failed, still printed
+#
+#   CI (main: an OLDER commit that passed)   ✔
+#
+# a true statement about a different commit. `--limit 1` also picked one workflow arbitrarily
+# when several run per commit: this repo runs `verify` and `release`, and on 2026-08-27 `release`
+# completed with a failure while `verify` was still going, so which one spoke for the commit
+# depended on timing. .github/workflows/release.yml's own header warns against exactly this
+# ("a moving branch ref ... silently drifts to a different commit"), and this check -- the one
+# whose job is to stop a release going out over red CI -- reproduced it.
+#
+# No run recorded for HEAD is a note, never a pass: an unpushed commit has no CI verdict, and the
+# newest run on the branch is not a stand-in for one. In progress is a note for the same reason.
+# Pinned by tests/repro/ci-lane-answers-for-head.sh.
 #
 # Skip honestly: each missing dependency (gh, jq, auth, network, GitHub remote) names itself.
 # A skip is reported as a note, not a pass: the output line appears with the dot notation used
@@ -1101,30 +1118,46 @@ else
     # Timeout chosen at 5s: slow enough for most networks, fast enough that a dead network
     # (blackholed DNS, wrong gateway) does not stall doctor for the underlying transport's 75s+
     # connect timeout. This is the same rationale as the release-reachability check's timeout.
-    _ci_out=$(run_with_timeout 5 gh run list --branch main --limit 1 --json conclusion,status,displayTitle,databaseId 2>&1)
+    _head=$(git -C "$_rr" rev-parse HEAD 2>/dev/null)
+    # 40 is a ceiling, not a page size: several workflows per commit times a few commits of
+    # history. Runs for other commits are filtered out below, so over-fetching costs one query.
+    _ci_out=$(run_with_timeout 5 gh run list --limit 40 \
+      --json headSha,name,conclusion,status,displayTitle,databaseId 2>&1)
     _rc=$?
     if [ "$_rc" -eq 124 ] || [ "$_rc" -eq 143 ]; then
       _ci_skip="gh timed out after 5s"
     elif [ "$_rc" -ne 0 ]; then
       _ci_skip="gh query failed"
     elif [ -z "$_ci_out" ]; then
-      _ci_skip="no runs found for main"
+      _ci_skip="no runs found"
+    elif [ -z "$_head" ]; then
+      _ci_skip="could not resolve HEAD in $_rr"
     else
-      _conclusion=$(printf '%s' "$_ci_out" | jq -r '.[0].conclusion // "null"' 2>/dev/null)
-      _status=$(printf '%s' "$_ci_out" | jq -r '.[0].status // "null"' 2>/dev/null)
-      _title=$(printf '%s' "$_ci_out" | jq -r '.[0].displayTitle // "?"' 2>/dev/null)
-      _id=$(printf '%s' "$_ci_out" | jq -r '.[0].databaseId // "?"' 2>/dev/null)
+      _mine=$(printf '%s' "$_ci_out" | jq -c --arg s "$_head" '[.[] | select(.headSha == $s)]' 2>/dev/null)
+      _n=$(printf '%s' "$_mine" | jq -r 'length' 2>/dev/null)
+      _title=$(printf '%s' "$_mine" | jq -r '.[0].displayTitle // "?"' 2>/dev/null)
+      _short=$(printf '%s' "$_head" | cut -c1-7)
 
-      if [ "$_status" = "null" ] || [ "$_title" = "?" ]; then
-        bad "CI" "could not parse run from gh output"
-      elif [ "$_status" != "completed" ]; then
-        note "CI" "run in progress: $_title"
-      elif [ "$_conclusion" = "success" ]; then
-        ok "CI (main: $_title)"
-      elif [ "$_conclusion" = "failure" ] || [ "$_conclusion" = "cancelled" ] || [ "$_conclusion" = "timed_out" ]; then
-        bad "CI" "$_conclusion on main: $_title (run $_id) — gh run view $_id --log-failed"
+      if [ -z "$_n" ] || [ "$_n" = "null" ]; then
+        bad "CI" "could not parse runs from gh output"
+      elif [ "$_n" = "0" ]; then
+        note "CI" "no run recorded for $_short yet — this commit has no CI verdict, and the newest run on the branch is not one"
       else
-        bad "CI" "unexpected conclusion '$_conclusion' on main: $_title"
+        # Order matters and is the point of the check. A single decided failure outranks any
+        # number of runs still going: one required workflow has answered no.
+        _redn=$(printf '%s' "$_mine" \
+          | jq -r '[.[] | select(.status == "completed") | select(.conclusion != "success")] | length' 2>/dev/null)
+        _pendn=$(printf '%s' "$_mine" | jq -r '[.[] | select(.status != "completed")] | length' 2>/dev/null)
+        if [ "$_redn" != "0" ]; then
+          _red=$(printf '%s' "$_mine" \
+            | jq -r '[.[] | select(.status == "completed") | select(.conclusion != "success")
+                     | "\(.name)=\(.conclusion) (run \(.databaseId))"] | join(", ")' 2>/dev/null)
+          bad "CI" "$_redn of $_n run(s) for $_short did not succeed: $_red — gh run view <id> --log-failed"
+        elif [ "$_pendn" != "0" ]; then
+          note "CI" "$_pendn of $_n run(s) for $_short still going ($_title) — no verdict yet, which is not a pass"
+        else
+          ok "CI ($_short: $_n run(s) green — $_title)"
+        fi
       fi
     fi
   fi
diff --git a/claude/.claude-plugin/plugin.json b/claude/.claude-plugin/plugin.json
index 48aa426..fa17a72 100644
--- a/claude/.claude-plugin/plugin.json
+++ b/claude/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "vstack",
-  "version": "1.46.0",
+  "version": "1.47.0",
   "description": "Skills that fire on the situation instead of a slash command, plus the subagents, commands, and session hook that make them fire. Verification gates, parallel fan-out, code review, and writing discipline.",
   "author": {
     "name": "Vedant Kumar"
diff --git a/claude/inventory.json b/claude/inventory.json
index 1bee19f..70877b8 100644
--- a/claude/inventory.json
+++ b/claude/inventory.json
@@ -11,8 +11,8 @@
     "repository": "https://github.com/itsvedantkumar/vstack"
   },
   "derived_at": {
-    "head": "698bee3a436322801e74a67ae97c67c72c4a41b0",
-    "payload_digest": "d3c0428feef3b40010fca3062f3dd2930a520086df96fd8c12604b2e92ae80d0",
+    "head": "224eef7ea22ca5b7c7c33a875fa013ff8e4176ad",
+    "payload_digest": "ec03bbd729bb1cd03a7704c548989125216a358e4709dc29cb564563cb24b08e",
     "digest_recipe_source": "tests/inventory-contract.sh:payload_digest_compute()",
     "digest_recipe_note": "payload_digest hashes the working-tree BYTES of every payload file -- tracked and untracked-but-not-ignored -- together with its executable bit and path, then hashes that listing. Recompute it with `tests/inventory-contract.sh --print-digest` and nothing else: typing a recipe by hand into a shell is a second implementation. This field used to hold the recipe as an executable string that the validator eval'd, on the reasoning that the two could then never disagree. That made the artifact its own oracle -- editing the recipe and the digest together passed while measuring nothing -- and it also hashed index blob ids plus `git status --porcelain`, which names files and status letters but never their contents, so two different unstaged edits to the same path produced the same digest. Both were confirmed by running them.",
     "staleness_is_the_signal": "This file is a snapshot. When the payload digest no longer matches, the validator regenerates every derived field and diffs. A mismatch is the intended failure, not a maintenance chore: it means a component moved and at least one consumer has not been told.",
@@ -553,7 +553,7 @@
   "verification": {
     "gate": {
       "command": "./.claude/verify.sh",
-      "declared_checks": 48,
+      "declared_checks": 52,
       "check_ids": [
         "0",
         "1",
@@ -602,7 +602,11 @@
         "45",
         "46",
         "47",
-        "48"
+        "48",
+        "49",
+        "50",
+        "51",
+        "52"
       ],
       "accounting_rule": "ran + skipped must equal declared, or the gate fails. A check wrapped in a conditional with no else reports nothing and used to leave no trace.",
       "offline": true,
@@ -623,7 +627,7 @@
         "where": [
           "ci:verify"
         ],
-        "rows": 70,
+        "rows": 77,
         "note": "Mutates the working tree. Run against a throwaway clone. The row total exceeds the declared-check total because some checks can fail in more than one way."
       },
       {
diff --git a/docs/checks-that-inherit-their-answer.md b/docs/checks-that-inherit-their-answer.md
index 3723dad..f40bcb9 100644
--- a/docs/checks-that-inherit-their-answer.md
+++ b/docs/checks-that-inherit-their-answer.md
@@ -9,7 +9,7 @@ Every one printed `ok`. None of them was measuring the thing its label named. Th
 missing check, because a missing check is visible in the census and a green one is an active claim
 that something was verified.
 
-## The thirteen
+## The fifteen
 
 **The anchor a prose edit moved.** Check 18 compares the README's published context cost against a
 live probe of the session hook, guarded by `grep -qE '~[0-9.]+ KB full / ~[0-9.]+ KB plugin'` with
@@ -136,6 +136,39 @@ fourteen hours later. The check worked; nobody read the remote. Pinned by
 copy's *bytes*, because a directory containing a post-overwrite copy is the same lie one level
 down.
 
+**The check that graded a different copy of the thing than the one it set up.** Check 49 stubs
+`gh`, computes this checkout's `HEAD`, and asks `bin/doctor` whether the CI verdict it reports
+belongs to that commit. `resolve_vstack_repo()` prefers `~/.config/agents/vstack-repo` -- wherever
+`install.sh` last ran from -- over the location of `bin/doctor` itself, so doctor answered about the
+installed tree while the harness had stubbed the tree under test. The two agreed for exactly as long
+as they were the same directory. Running the check from an isolated clone separated them and three
+of five cases went red, including both positive controls. Inherited from: which checkout the
+operator happened to have installed. Fixed by pinning `VSTACK_DIR` to the tree under test.
+
+**The published figure compared against a machine-dependent measurement.** Check 18's cap lane was
+fixed once already for exactly this: the session hook splices `$root`, `$branch` and `$base` into
+the block it measures, so a raw byte count is partly a measurement of the operator's directory name.
+The fix normalized `$root` and `$branch` out and explicitly left `$base` in, on the stated grounds
+that the remote's default branch "does not vary with this checkout." It varies with the remote,
+which is no less environmental, and it is spliced three times. Meanwhile the published-figure lane
+was never converted at all and went on comparing the README against the raw count. The result: the
+check passed at 4077 B on the author's directory on `main` (3.9 KB, inside a 0.15 KB tolerance) and
+failed at 4163 B in a clone three characters longer whose `origin/HEAD` named a 24-character branch
+(4.1 KB). A green that was a property of where it ran. Inherited from: the checkout path, the branch
+name, and the remote's default branch. Fixed by subtracting all three and publishing the invariant
+count, which is 3990 B in every checkout tested. Row 18d splices `$base` a fourth time so the
+correction can never again fall behind what the hook adds.
+
+**Not covered, named rather than skipped.** `tests/install-matrix.sh` has no falsifiability
+control. Check 52 gives `tests/bin-scripts.sh` one -- break the argument guard its `bg-args` case
+is about, and the suite must notice -- but the same treatment does not fit the install matrix. Its
+cheapest single case measured 2m10s, which does not belong in an offline gate, and it is red at
+time of writing for an unrelated reason (a declared-but-untagged release), so a "must fail when
+broken" control against it would pass without measuring anything. A vacuous control is worse than
+an absent one, because the absent one is visible in this paragraph and the vacuous one reads as
+coverage. Anyone closing this gap should give install-matrix a scoped mode that can run in seconds
+against a deliberately broken payload, and should confirm the matrix is green first.
+
 ## The test
 
 Before believing any check, ask: **what in the environment could make this print `ok` without
diff --git a/docs/research/fake-greens-2026-08.md b/docs/research/fake-greens-2026-08.md
new file mode 100644
index 0000000..a3d7ca7
--- /dev/null
+++ b/docs/research/fake-greens-2026-08.md
@@ -0,0 +1,288 @@
+# Checks that measure nothing
+
+A check that returns a true statement about the wrong question is worse than no check. It costs
+the same to run, it prints the same word, and it removes the pressure that would otherwise produce
+a real one. This repository was built to test its own configuration and has spent six months
+finding that its checks kept doing exactly that. This document reports what those runs measured.
+
+The claim is narrow and it is not about model quality. Nothing here shows that an agent
+configuration makes a frontier model write better code; the measurements this repository has run
+on that question came back flat, and they are reported below with the rest. The claim is about
+verification: **in a system that checks itself, the dominant failure is not a wrong answer but a
+right answer to a question nobody asked.** Thirteen instances are catalogued. Two of them are in
+this document's own evidence base.
+
+Every number below names the file and the date it came from. Numbers without a surviving artifact
+are marked unsourced and are not used to support anything.
+
+## What the defect looks like
+
+The shape is always the same. A check asserts something true. The truth of that thing does not
+depend on the property the check exists to protect. The check passes forever, including on the day
+the property breaks.
+
+Three instances, each confirmed by running it:
+
+- A statusline read a dispatch counter that no code ever wrote. The reader worked. The number it
+  displayed was the absence of a writer, rendered as zero (`CHANGELOG.md`, 1.41.0).
+- A mandate hook required agents to be named on dispatch, matching on the tool name `Task`. Against
+  a real 15 MB transcript the session contained 70 `Agent` dispatches and zero `Task` matches. The
+  mandate had been structurally unable to fire since it shipped (1.37.0).
+- `doctor --drift` printed `no drift ✔ (74 item(s) compared)`. A new file family had shipped that
+  its globs never matched. The count was 74 before the file existed and 74 after (1.45.1).
+
+The third is the instructive one. The verdict was correct: there was no drift among the items it
+compared. The question it was asked was whether the tree had drifted. Reading the verdict answers
+the first question. Reading the count answers the second, and only the count moved, by staying
+still.
+
+`docs/checks-that-inherit-their-answer.md` catalogues thirteen of these. Six were found on
+2026-08-22 and six more across 2026-08-26 and 2026-08-27. Six plus six is twelve, and the
+catalogue's heading says thirteen. The document does not reconcile its own arithmetic, which is
+recorded here rather than rounded away. The document predicted roughly one a
+month. Its own dates falsify that prediction by about an order of magnitude, which is the honest
+reading of a catalogue that keeps growing under a fixed search.
+
+Two of the entries are a distinct sub-shape and matter more than the rest: a check whose assertion
+is load-bearing and true, attached to a decision it does not govern. No mutation test catches
+these. Mutation testing proves a check notices when its subject changes. It cannot prove
+the subject is the thing you care about.
+
+## How the evidence is produced
+
+Four mechanisms, in the order they were added, each after a failure that the previous three did not
+catch.
+
+**Mutation testing on the gate.** `tests/gate-falsifiability.sh` declares 73 rows (70 mutations
+plus 3 fixed). Each row breaks exactly what one check watches, then requires `.claude/verify.sh` to
+go red **naming that specific check**, not merely to go red. It then restores the file byte for
+byte and refuses to restore over a third party's concurrent write. Two details are load-bearing and
+were both added after the row they protect failed silently:
+
+- If a mutation leaves a file's hash unchanged, the row fails as "mutation changed nothing," not as
+  a pass. Rows 11, 26 and 28 each rotted this way. Their patterns stopped matching after a
+  refactor, and they reported success while mutating nothing.
+- Mutations are anchored on the decision the check asserts, never on a line that happens to be
+  unique. Row 27 mutates `[ -n "$unmet" ] || exit 0` in `claude/hooks/skill-mandate.sh` because
+  that expression *is* the block/no-block decision. Its predecessor was anchored on a nearby
+  bookkeeping line, and one refactor moved that line and disarmed the row.
+
+**Oracle controls that bite in both directions.** `tests/dispatch-fleet.sh` was proved against two
+stubs at zero model cost before it measured anything: an always-firing stub scores 75/75 recall and
+0/24 precision, and a never-firing stub scores the reciprocal. A harness that only reports recall
+gives the always-firing stub a perfect score.
+
+**Pre-registration.** Thresholds are fixed in a committed file before the first sample. Three exist:
+`tests/evals/build-the-lever/PREREGISTRATION.md`, `tests/evals/agent-pilot/PREREGISTRATION.md`,
+`tests/evals/false-done/PREREGISTRATION.md`. Each names its confirm bound, its falsify bound, its
+void conditions, and the moves that would invalidate it. Each states in advance that a null result
+is published as a null result.
+
+**Publication gates.** `tests/dispatch-fleet.sh` refuses to let any fleet-wide recall or precision
+figure be published until one specific arm reports, because that arm tests whether the harness's own
+tool fence suppresses every skill whose output is a file. The gate is a comment in the harness, next
+to the code it restricts.
+
+## Result: guards that decide correctly and enforce nothing
+
+`claude/hooks/guard-destructive.sh` classifies 37 destructive commands across three tiers and is
+correct on all 37, including under a stripped environment. `tests/repro/guard-quote-aware-split.sh`
+passes 18 of 18.
+
+Under `bypassPermissions`, a live probe ran `git reset --hard` with the guard returning `ask`. The
+command executed, returned 0, and produced no prompt and no block. Force-push to `main` was
+enforced; the reset was not. On the same day, four agents lost uncommitted files to a bare `git
+stash` and a fifth to a hard reset.
+
+The check was measuring the decider. Enforcement is a separate system, and nothing was measuring
+the join between them. Two fixes shipped, and they differ in kind. `.claude/verify.sh` now labels that check
+`(decider only, not runtime enforcement)` in its own pass line, so the check keeps its scope and
+stops implying a larger one. Separately, the guard escalates `ask` to `deny` under
+`bypassPermissions` for the commands the probe caught leaking, so that specific hole is closed.
+The label fix is the one that generalises. The escalation only covers commands somebody thought
+to name. `docs/guard-enforcement-gap.md` records the probe and, separately,
+what could not be verified and why.
+
+The general lesson is stronger than the instance. A reader tested against a hand-made fixture passes
+forever while its writer does not exist. Test the join, and grep for the writer.
+
+## Result: skill descriptions behave like a keyword index
+
+Skills are markdown files with a description. The runtime decides which to surface from those
+descriptions. Every number in this section comes from `tests/auto-trigger.sh` at n=10 unless stated,
+and that harness's replication limits are set out under "Threats to validity". They are severe.
+
+- Rewriting `principle-type-system-discipline`'s description around the nouns a user actually types
+  moved it from 1/10 to 9/10, matching its control.
+- The identical method applied to `principle-build-the-lever` did not move it: 2/10 before, 2/10
+  after. The rewrite was reverted rather than shipped, because a change that does not move its
+  metric is not an improvement.
+- `principle-prove-it-works` scored 0/10 on its own fixture and was replaced by a `Stop`-hook check.
+  A skill that never fires is a file, not a mechanism.
+- Removing the routing table from `CLAUDE.md` moved a 9-case subset from 9/9 to 7/9;
+  `technical-writing` and `typescript-best-practices` never fired without it
+  (`docs/how-skills-fire.md`).
+- Across the 60 runs of the review benchmark in `tests/evals/RESULTS.md`, the `Skill` tool was
+  invoked **zero** times in every arm, including the arm with 70 skills loaded.
+
+The standing explanation for the hard cases is registered as H7 in
+`tests/evals/build-the-lever/PREREGISTRATION.md`: the trigger for some skills is a counterfactual
+about the model's own forthcoming plan, not a property of the user's prompt, so a dispatcher scoring
+descriptions against a prompt has nothing to score. H7 has not been tested. Neither have H8 through
+H11. Only Stage 0 has reported, and it is an instrument check: the description reaches the model
+byte-identical, 171 of 171 characters, 3 of 3 samples.
+
+Two byproducts of Stage 0 are worth more than the stage itself. Denying the `Skill` tool removes the
+skill listing from context entirely, so a harness that fences `Skill` measures nothing about skills.
+And on this build, deferred-tool discovery through `ToolSearch` consumed two turns, which is the
+entire budget of a case at the suite default of three.
+
+## Result: no measurable quality gain
+
+`tests/evals/RESULTS.md` records five runs and retracts one, keeping the retracted table with its
+reason attached.
+
+| Run | Design | Result |
+|---|---|---|
+| Review benchmark, 2026-08-21 | 4 fixtures × 5 samples × 3 arms, 60 calls | unconfigured 11/15, vstack 11/15, other bundle 10/15; zero false positives in every arm |
+| Review pathway, 2026-08-22 | 8 fixtures × 2 samples × 3 arms, 48 reviews, n=16 per arm | all three arms 11/14 (79%); precision 92%, 85%, 73%; false positives 1, 2, 4 |
+| SWE-bench Lite | 4 instances × 3 arms | 0/4 for every arm on the first three runs, none of which was a result, because of three separate harness defects |
+
+The 2026-08-22 row is the first run on which all three arms worked, and it is a three-way tie on
+recall with the configured bundle worst on precision. Per-fixture hit vectors were printed to show
+the tie is a tie and not a collapsed harness.
+
+This is the finding the repository exists to report and the one it likes least.
+`docs/what-this-actually-does.md` opens by stating it: there is no evidence this configuration
+improves output quality on a frontier model. The defensible case for a configuration layer is
+safety and reversibility, not output quality, and that case is made by the guard and gate results
+above rather than by any benchmark here.
+
+## Result: instruments that returned NOT EVALUATED
+
+Two instruments were built, run, and reported no result, which is the outcome a harness that always
+produces a number cannot express.
+
+`tests/compaction-effect.sh` found that of 3,134 transcripts on this machine, only 8 contain a
+compaction event. It reported NOT EVALUATED until enough boundaries existed, then reported a real
+null: `is_error` at 1/45 before versus 0/45 after across 3 automatic boundaries, and 5/90 versus
+7/90 across 6 manual ones. Both ratios sit under the 1.5× threshold fixed in advance.
+
+`tests/delegation-drift.sh` had 2 and 3 eligible windows against a floor of 8 and still reports NOT
+EVALUATED. It has never produced a number, which is the correct behaviour and the reason it is
+mentioned here.
+
+Both instruments were also found to be counting per-subagent transcript leaves as sessions: 965 of
+3,292 files under the transcript directory are leaves, and 15 of 51 replayed sessions were leaves of
+two parents. After the fix, neither instrument's printed numbers moved. A contamination that does
+not move the result is still worth fixing, because the next question asked of the same corpus may
+not be so forgiving.
+
+## Result: two of this repository's own numbers had no artifact
+
+The defect generalises past checks, to citations.
+
+`CHANGELOG.md` stated that colliding triggers "were measured over 80 samples to suppress both
+skills, not one." No 80-sample runlog exists in this repository's history or on the machine that
+produced it. The only collision arm on record is 55 samples on a single fixture
+(`tests/README.md`), and its instrument was an uncommitted local edit to `tests/dispatch-fleet.sh`
+. That file's own fence comment already recorded the fact. Its runlog lived under `/private/tmp`
+and is gone.
+
+`CHANGELOG.md` also stated that a session "got a uniform 0/5 across five fixtures," cited as the
+reason for building a per-dispatch replay log. That figure is not merely unsourced: the harness
+cannot produce it. In `tests/dispatch-fleet.sh`, only fixtures of kind `skill` and kind `none`
+receive a numeric score; a `CHAIN:` or `AMBIGUOUS:` fixture returns a null score and a distribution
+instead. Two of the five fixtures in that arm are exactly those kinds, so the fraction attributed to
+them could never have been printed.
+
+Both lines keep their place with a retraction note attached. The direction each arm reported stands
+as what that arm reported; the sample count is withdrawn from both. Deleting them would remove the
+evidence that this happened.
+
+Two mechanisms exist now because of this. `tests/dispatch-fleet.sh` writes a schema=2 runlog header
+recording the model, turn cap, tool fence and fixture path of every arm, and refuses to append
+samples drawn under different parameters rather than mix two arms into one score. And its tool
+fence is environment-overridable, because a literal with no override is what forced the source edit
+that destroyed the instrument.
+
+## Result: the collision claim did not survive a committed instrument
+
+The withdrawn "80 samples" claim was re-measured on 2026-08-27 under thresholds committed before the
+first sample (`tests/evals/collision/PREREGISTRATION.md`) and a harness that was not edited. Five
+fixtures, 5 samples each, 25 calls. Full report in `tests/evals/collision/RESULTS.md`.
+
+Matched pairs, so that a suppressed skill can be told apart from a silent one: `swarm` and
+`principle-encode-lessons-in-structure` each on their clean positive fixture and on their collision
+fixture, plus `col-01` ("Tear this apart."), which is a literal trigger string in both `grill-me`'s
+and `interrogate`'s descriptions.
+
+| Fixture | Expected | Fired |
+|---|---|---|
+| `pos-19` | `swarm` | 0/5 |
+| `col-13` | `swarm` | 0/5 |
+| `pos-11` | `principle-encode-lessons-in-structure` | 0/5 |
+| `col-15` | `principle-encode-lessons-in-structure` | 0/5 |
+| `col-01` | `grill-me` or `interrogate` | 4 none, 1 `interrogate` |
+
+One `Skill` call in 25 samples, every sample `subtype=success`, no fence violations.
+
+The transcripts were kept, which the 2026-08-24 arm could not do, and they show two mechanisms.
+The harness runs every sample in an empty `mktemp -d`, so a prompt that refers to a repository, a
+diff, or a prior turn has no referent: all 5 `pos-19` samples globbed, found no packages, and asked
+which repository held them. And the fence denies `Write`, so a skill whose action is to write a
+file gets as far as the attempt: all 5 `pos-11` samples called `Write` and were refused.
+
+The model knew the routing the whole time. It named `swarm` in prose without calling it in 7 of the
+10 `swarm` samples, and named `interrogate` or `grill-me` in 4 of the 5 `col-01` samples. On
+`pos-11` it named no skill and performed the skill's action directly instead.
+
+So one mechanism explains both arms of the anomaly, and it is the instrument. `fired=[]` is recorded
+identically for "the dispatcher did not route" and "the model asked which repository you meant."
+Every dispatch rate this harness has produced inherits that confound.
+
+Two further consequences. `col-01` fired more often than either uncolliding control, which is weak
+evidence against suppression rather than for it. And H11, the hypothesis that the tool fence
+suppresses skills whose output is an artifact, is confirmed wider than it was registered: this arm
+picked `principle-encode-lessons-in-structure` as the fence-immune control because its output is
+prose, and 5 of 5 samples disproved that premise by calling `Write`.
+
+One more result, and it is the least comfortable in this document. H-C1 was written as a bare bound
+on one arm: empty in 4 of 5 samples confirms suppression. `col-01` returned empty in 4 of 5, so the
+threshold was met. It means nothing, because both controls returned empty in 5 of 5 and empty was
+the modal outcome of every fixture in the run. The threshold lacked a control clause and would
+therefore return CONFIRM on any run in which nothing fired at all. It was written on the morning of
+the run, in a pre-registration whose stated purpose is to prevent exactly this, by the author of the
+catalogue this paper is built on. Thirteen instances in a repository, and the fourteenth is in the
+instrument written to measure the thirteenth.
+
+## Threats to validity
+
+Stated plainly, because the paper is about checks that overstate their scope.
+
+- **Every per-skill dispatch rate above is unreplicable.** `tests/auto-trigger.sh` did not commit
+  its probe script and no per-run output survives. Five commits landed in that harness in one
+  session, touching tool availability and turn budgets, so cross-commit comparison of those rates
+  is not supported by the single n=10 control run afterwards. The 1/10 → 9/10 result is the
+  strongest single effect in this document and it rests on the weakest instrument.
+- **n is small everywhere.** The benchmark arms are n=15 and n=16. A three-way tie at n=16
+  excludes a large effect and nothing finer.
+- **One machine, one operator, one model family.** Nothing here is a claim about other setups.
+- **The harness fences its own subject.** `tests/dispatch-fleet.sh` denies the tools that several
+  skills exist to use. Whether that suppresses those skills is registered as H11 and is untested,
+  which is why the publication gate on fleet-wide figures is still closed.
+- **The fixture labels are an author's judgement** of what should fire, never validated against a
+  live matcher. A miss may be a wrong label.
+- **This document is not falsifiable in the way its subjects are.** No mutation test can turn it
+  red. Treat it as a report on artifacts you can re-run, and re-run them.
+
+## What would change the conclusions
+
+- A benchmark at n large enough to resolve a 5-point difference, on more than one task family,
+  showing the configured arm ahead. Nothing here is designed to detect that; the runs above are
+  sized to detect a large effect and found none.
+- Arm A5 of `tests/evals/build-the-lever/PREREGISTRATION.md` returning k ≥ 8/10, which would mean
+  the tool fence has been depressing every artifact-producing skill and every dispatch figure taken
+  through that harness is wrong in the pessimistic direction by an unknown margin.
+- A month in which `docs/checks-that-inherit-their-answer.md` does not grow under the same search.
+  The catalogue's rate is currently its own strongest finding.
diff --git a/docs/what-this-actually-does.md b/docs/what-this-actually-does.md
index 2f541bf..40c02fc 100644
--- a/docs/what-this-actually-does.md
+++ b/docs/what-this-actually-does.md
@@ -8,6 +8,10 @@ SWE-bench Lite scoring tied all four arms at zero. A false-completion pilot tied
 small, well-specified, single-file tasks a frontier model is already near ceiling, and a ceiling
 leaves no headroom for a config layer to show up in.
 
+`docs/research/fake-greens-2026-08.md` reports the whole evidence base as one document: what
+was measured, what the numbers do not support, and the thirteen checks that passed while
+measuring nothing.
+
 What this repository can show is narrower and checkable. Specific mechanisms do specific things,
 each with the evidence that proves it and the date it was measured. That is what follows, in
 three categories kept strictly apart: a number that exists, a mechanism that runs with no
@@ -24,9 +28,9 @@ A number exists, sourced, dated.
 |---|---|---|
 | The gate declared 44 at v1.41.0 and every one ran green. | `./.claude/verify.sh` prints `checks: 44 declared, 44 ran, 0 skipped` and `VERIFIED`. | Run 2026-08-23 |
 | On 2026-08-26 the gate declared 48 and was **red**: `48 declared, 47 ran, 1 skipped` and `VERIFICATION FAILED`, on `referenced install paths exist`, `inventory contract matches the tree` and `payload_digest`. All three are fixed. | `./.claude/verify.sh`, unpiped, on this branch | Run 2026-08-26 |
-| As of 2026-08-27 both gates are green: `48 declared, 47 ran, 1 skipped` and `VERIFIED`, and `60 declared, 59 passed, 0 failed, 1 skipped` with `FALSIFIABLE`. Run unpiped in an isolated worktree at the candidate commit, exit codes read on their own line. | `./.claude/verify.sh` and `./tests/gate-falsifiability.sh` | Run 2026-08-27 |
+| As of 2026-08-27 both gates are green: `48 declared, 47 ran, 1 skipped` and `VERIFIED`, and falsifiability harness returned `60 declared, 59 passed, 0 failed, 1 skipped` with `FALSIFIABLE` (superseded by rows added in 1.46.0; tree now declares 73 rows, 70 mutation + 3 fixed, not re-run for this document). Run unpiped in an isolated worktree at the candidate commit, exit codes read on their own line. | `./.claude/verify.sh` and `./tests/gate-falsifiability.sh` | Run 2026-08-27 |
 | The one remaining skip in both gates is check 24, and it is the designed state between a version bump and its tag, not a gap. The check's own source says so: it does not demand that HEAD be a release, only that the payload match the tag if one exists with the declared version. **Clearing it by tagging would fabricate the green** — a tag cut at HEAD makes the compared range empty by construction, so the check would report success having compared a commit to itself. The label was narrowed to say that instead. | `.claude/verify.sh` check 24, and its three branches exercised in a scratch clone | Verified 2026-08-27 |
-| Every one of those 44 has a falsifiability row that has been watched going red. `tests/gate-falsifiability.sh` breaks exactly what each check watches, requires the gate to name it, and restores the file byte for byte. Check 16 fails the gate if a check has no such row. | `tests/gate-falsifiability.sh`, `tests/README.md`, README.md "Checks that can fail" | Mechanism as of v1.41.0. Suite not re-run for this document; rows 40 and 44 verified by the scoped-row method only, see note below |
+| At v1.41.0, all 44 of the checks then declared had falsifiability rows. The tree now declares 52 checks and 80 falsifiability rows (77 mutation + 3 fixed), all watched for red under mutation. `tests/gate-falsifiability.sh` breaks exactly what each check watches, requires the gate to name it, and restores the file byte for byte. Check 16 fails the gate if a check has no such row. | `tests/gate-falsifiability.sh`, `tests/README.md`, README.md "Checks that can fail" | v1.41.0 baseline as of 2026-08-23; current counts as of this write. Suite not re-run for this document; rows 40 and 44 verified by the scoped-row method only, see note below |
 | `principle-type-system-discipline` almost never fired: 1/10 at n=10. Rewriting its description around the literal nouns a user types ("a struct, enum, or type can hold an invalid combination of fields") moved it to 9/10, matching the control. The identical rewrite method applied to `principle-build-the-lever` did not move it. That skill scored 2/10 before and after, exactly at the pre-registered falsification floor, and the rewrite was reverted rather than shipped. | CHANGELOG.md, "1.38.0" | 2026-08-23 |
 | `principle-prove-it-works` scored 0/10 on its own fixture prompt, because its trigger condition is about the assistant's own closing claim, not anything a skill matcher can see in the user's prompt. Replaced with a direct Stop-hook check (`prove-it-works`) rather than a rewritten description. | CHANGELOG.md, "1.37.0" | 2026-08-23 |
 | The container matrix's first run against published GitHub tags found two shipped defects. `bin/doctor` exited 1 on a clean Alpine install because its 45-day-cutoff `date` fallback chain covered BSD and GNU but BusyBox understands neither `date -v-45d` nor `date -d '45 days ago'`. And `vstack update`, run by anyone following the README's own documented pin quickstart (`VSTACK_REF=vX.Y.Z bash bootstrap.sh`), reported "already up to date" forever regardless of how far behind `main` the pinned checkout had drifted, because the shallow clone's refspec never fetches `origin/main` and the comparison failed silently with stderr discarded. | CHANGELOG.md, "1.33.0", and `tests/container-matrix.sh` | 2026-08-23 |
@@ -110,7 +114,7 @@ It was run on 2026-08-27, against `c37ce8c` in a detached worktree rather than t
 checkout: **61 declared rows, 60 passed, 0 failed, 1 skipped, `FALSIFIABLE`**, followed by
 `ok restore integrity: no concurrent edits during the run` and `ok tree unchanged by the run`. The
 one skip is check 24, which names its reason (no tag to compare against). 58 of those rows carry a
-mutation; the other 3 are fixed rows that assert the harness's own accounting. The row total
+mutation; the other 3 are fixed rows that assert the harness's own accounting. This run's row count (61) predates rows added in version 1.46.0; the tree now declares 73 rows (70 mutation + 3 fixed), and that count has not been re-run for this document. The row total
 exceeds the 48 declared checks because several checks can fail in more than one way.
 
 Read that as narrowly as it is written. Every row was watched going red under its own mutation and
diff --git a/tests/evals/collision/PREREGISTRATION.md b/tests/evals/collision/PREREGISTRATION.md
new file mode 100644
index 0000000..bc41afc
--- /dev/null
+++ b/tests/evals/collision/PREREGISTRATION.md
@@ -0,0 +1,171 @@
+# Pre-registration: skill-collision arm, matched pairs
+
+Written before the first sample was drawn, and committed before the harness was invoked. The
+instrument this arm replaces was an uncommitted local edit, so the finding it produced cannot be
+rebuilt from git — see "What this arm replaces" below. Committing the thresholds first is the only
+part of that failure this document can prevent.
+
+## The question
+
+Two claims are published in `CHANGELOG.md` and neither has a surviving artifact:
+
+- `CHANGELOG.md:23` — "Colliding triggers were measured over 80 samples to suppress both skills,
+  not one." No 80-sample runlog exists on this machine or in git history. The only collision arm
+  the repository records is **55 samples on `col-11` alone** (`tests/README.md:188`), produced by a
+  local uncommitted edit to `tests/dispatch-fleet.sh` (its own fence comment, line 180, says so).
+- `CHANGELOG.md:572` — "a uniform 0/5 across five fixtures", cited as the motivation for building
+  the per-dispatch replay log in 1.43.0. No runlog, no transcripts, no fixture list.
+
+Both read as measured. Neither can be re-read. That is the same defect this repository catalogues
+in `docs/checks-that-inherit-their-answer.md`, applied to its own evidence base rather than to a
+check.
+
+So the question is not "why did those five fixtures score zero". That question is unanswerable:
+the data is gone, and the harness cannot even produce the shape claimed — at
+`tests/dispatch-fleet.sh:678-688` only `kind=="skill"` and `kind=="none"` fixtures get a numeric
+`k`, so `col-11` (`CHAIN:brainstorming`) and `col-14` (`AMBIGUOUS:...`) return `{k: null}` and can
+never print `0/5`.
+
+The question this arm asks instead:
+
+> When a skill fails to fire on a collision-framed prompt, is that because the collision
+> suppressed it, or because that skill does not fire on any prompt under this harness?
+
+One arm cannot answer that. Matched pairs can.
+
+## Design
+
+Each of two skills is run on **both** its clean positive fixture and its collision fixture, from
+the same frozen fixture file, in one invocation, under one runlog header. A fifth arm reruns the
+strongest form of the collision claim: a prompt that is a literal trigger string in two skill
+descriptions at once.
+
+| Arm | Fixture | Prompt | `expect` | n |
+|---|---|---|---|---|
+| P-swarm | `pos-19` | Audit these six packages for unused deps, all at once. | `swarm` | 5 |
+| C-swarm | `col-13` | Try three different approaches to this and compare. | `swarm` | 5 |
+| P-encode | `pos-11` | That's the second time I've told you to use pnpm not npm. | `principle-encode-lessons-in-structure` | 5 |
+| C-encode | `col-15` | I keep having to remind you to run the tests. | `principle-encode-lessons-in-structure` | 5 |
+| C-literal | `col-01` | Tear this apart. | `AMBIGUOUS:grill-me\|interrogate` | 5 |
+
+**25 model calls. No more without an explicit further authorisation.**
+
+n=5 is a pilot. At n=5 a two-sided 95% Wilson interval on 5/5 is [0.566, 1.000] and on 0/5 is
+[0.000, 0.434]: the intervals do not overlap, so 5/5-versus-0/5 is a real separation and anything
+between them is not. The thresholds below are set accordingly and are not negotiable after the run.
+
+## Instrument
+
+**Zero edits to `tests/dispatch-fleet.sh`.** Every parameter is passed by environment override.
+That override path exists because a source edit is what destroyed the last arm; using it is the
+point. A harness change would also invalidate the harness's prior findings
+(`tests/README.md`: "A harness change invalidates its own prior findings").
+
+```sh
+N=5 MODEL=sonnet MAX_TURNS=20 KEEP_WORKDIRS=1 \
+FIXTURES="$HOME/vstack-dispatch/fixtures.jsonl" \
+RUNLOG=tests/evals/collision/runlog-2026-08-27.jsonl \
+./tests/dispatch-fleet.sh pos-19 col-13 pos-11 col-15 col-01
+```
+
+- `MAX_TURNS=20`, not the suite default of 3: Stage 0 of the build-the-lever pre-registration
+  measured `ToolSearch` deferred-tool discovery consuming 2 turns, which is two thirds of a
+  3-turn budget before the model has decided anything.
+- `DISALLOWED_TOOLS` is left at the committed default. It is recorded in the runlog header either
+  way, and `check_runlog_params()` refuses to append samples drawn under different parameters.
+- `KEEP_WORKDIRS=1`. The transcripts are the thing the lost arm did not have.
+- The runlog is written to a **tracked path inside the repository** and committed with the
+  results. `/private/tmp` is where the last one went and is why there is nothing to read.
+
+**Fixture file pinned by content, not by path.** `~/vstack-dispatch/` is not a git repository and
+carries no checksum, so the path alone does not identify what was run:
+
+```
+sha256  d940b4d37512bdf9085d2ee2184c4e936ac6095b02e455a9b8408c1815be4537
+lines   54
+classes pos 25, neg 8, col 15, var 6
+```
+
+If that digest does not match at run time, the arm is void and the mismatch is published.
+
+## Hypotheses and thresholds, fixed in advance
+
+**H-C1 — a shared literal trigger suppresses both skills.**
+The published claim, in its strongest form. `col-01`'s prompt ("Tear this apart.") is a literal
+string in both `grill-me`'s and `interrogate`'s descriptions.
+- CONFIRM: `fired` is empty in ≥4/5 samples.
+- FALSIFY: `fired` is empty in ≤1/5 samples.
+- INDETERMINATE: 2/5 or 3/5. Reported as indeterminate, not rounded toward the prior.
+
+**H-C2 — the collision framing fails, the skill is reachable.**
+- CONFIRM, per skill: fires ≥4/5 on its `pos-*` fixture and ≤1/5 on its `col-*` fixture.
+- Evaluated separately for `swarm` and `principle-encode-lessons-in-structure`. A split verdict
+  is a result, not a problem.
+
+**H-C3 — the skill does not fire under this harness at all.**
+- CONFIRM, per skill: ≤1/5 on **both** its fixtures. The collision prompt then explains nothing,
+  and any prior zero attributed to collision was attributed wrongly.
+
+H-C2 and H-C3 are mutually exclusive by construction. If neither holds for a skill (e.g. 3/5 and
+3/5), that skill's verdict is INDETERMINATE and is published as such.
+
+**Discriminator for H11 — the tool fence.**
+`tests/dispatch-fleet.sh:277-283` carries a standing publication gate: the fence may be suppressing
+every skill whose expected output is an artifact. This arm was chosen to bear on it at no extra
+cost. `swarm`'s affordance is the `Agent` tool, which the harness's own hard guard **requires** to
+be denied (`dispatch-fleet.sh:195-224` refuses to run if `Agent` or `Workflow` is absent from the
+fence). `principle-encode-lessons-in-structure`'s output is prose and needs no denied tool.
+- If `swarm` is ≤1/5 on both arms while `principle-encode-lessons-in-structure` fires ≥4/5 on
+  `pos-11`, H11 explains `swarm` and only `swarm`, and the fence — not collision — is the
+  mechanism behind at least one prior zero.
+- This does **not** discharge the publication gate. Arm A5 of
+  `tests/evals/build-the-lever/PREREGISTRATION.md` is still the gate's named condition.
+
+## Void conditions
+
+- The fixture digest above does not match at run time.
+- ≥3 of the 5 arms return `subtype` other than `success` (`no_output`, `error_max_turns`) in a
+  majority of their samples. The instrument is then dead and no hypothesis is scored.
+- The runlog does not contain exactly 25 rows, or `--score-only` over the committed runlog does not
+  reproduce the same k/n with zero model calls.
+- Any `fence_violations` entry. The workdir is supposed to be untouched.
+
+A void run is published as void. It is not re-run with different parameters and reported as one
+result.
+
+## Named invalidators
+
+Stated in advance, in the form `~/vstack-dispatch/README.md` uses:
+
+- **Editing a fixture after seeing a score.** The fixture file is frozen by digest above.
+- **Adding an arm after seeing results.** Five arms, 25 calls. A sixth arm is a new
+  pre-registration with its own digest, not an appendix to this one.
+- **Scoring the `AMBIGUOUS` fixture as a pass/fail.** `col-01`'s split *is* the datum. A 50/50
+  split and a 100/0 split are different findings and neither is an error
+  (`dispatch-fleet.sh:831`).
+- **Choosing the threshold after the run.** ≥4/5 and ≤1/5 are fixed here.
+- **Publishing a fleet-wide figure.** This arm publishes **per-fixture** numbers only. No `pos-*`
+  recall or `neg-*` precision figure may be derived from it; the publication gate at
+  `dispatch-fleet.sh:277-283` is untouched by this run.
+- **Reading the exit code instead of the trailer.** The verdict is read off the printed k/n and
+  the retained transcripts, not off `$?`.
+
+## Declared limits
+
+- n=5 per arm. This is a pilot sized to separate 5/5 from 0/5 and nothing finer.
+- Two skills. Whatever it finds about `swarm` and `principle-encode-lessons-in-structure` does not
+  generalise to the other 26 without running them.
+- The visible skill set is whatever is installed under `~/.claude` at run time, since the harness
+  deliberately does not isolate `CLAUDE_CONFIG_DIR` (`dispatch-fleet.sh:83-90`). The installed
+  version is recorded in the results.
+- The fixture labels are an author's judgement of what *should* fire, never validated against a
+  live matcher (`~/vstack-dispatch/README.md`). A miss may be a wrong label.
+- `MODEL=sonnet` matches the parameters the lost arm is recorded as having used, so that this arm
+  is comparable to it in the one respect that record survives. It says nothing about any other
+  model.
+
+## What this arm replaces
+
+Nothing. Both prior claims stay in `CHANGELOG.md` with an annotation naming them unsourced, the
+way `tests/evals/RESULTS.md` keeps its retracted run with the reason attached. A number deleted
+is a number that cannot be argued with later.
diff --git a/tests/evals/collision/RESULTS.md b/tests/evals/collision/RESULTS.md
new file mode 100644
index 0000000..02cd7c5
--- /dev/null
+++ b/tests/evals/collision/RESULTS.md
@@ -0,0 +1,144 @@
+# Results: skill-collision arm, matched pairs
+
+Run 2026-08-27. Thresholds fixed in advance in `PREREGISTRATION.md`, committed at `224eef7`
+before the first sample. Instrument: `tests/dispatch-fleet.sh` at that commit, unedited, driven by
+environment overrides only.
+
+```
+# dispatch-fleet runlog schema=2 model=sonnet max_turns=20
+# tools=Write,Edit,MultiEdit,NotebookEdit,Bash,Agent,Workflow,Explore,Task
+# fixtures=~/vstack-dispatch/fixtures.jsonl  sha256 d940b4d3...be4537
+```
+
+The committed runlog carries one edit and no other: the header's `fixtures=` path was rewritten
+from this machine's absolute home path to `~/`, because `.claude/verify.sh`'s home-path scanner
+refuses a committed absolute `/Users/...`. The file's sha256 before that edit was
+`a79ae7ff97d332efb5f90bf4b84d4e861413b9c632dcd6626b3132e23537ab1b`, recorded here so the redaction is auditable. The path was never the
+instrument's identifier anyway; the fixture digest in `PREREGISTRATION.md` is. The harness should
+write a `$HOME`-relative path and the fixture digest into the header itself, which would remove
+the need for any post-hoc edit. That change is deliberately not made in the same commit as this
+arm's first result.
+
+25 samples, 25 rows plus the header. Every sample returned `subtype=success`. Zero fence
+violations. `--score-only` over the committed runlog reproduces every figure below with no model
+calls.
+
+## What was measured
+
+| Arm | Fixture | Expected | Fired | Skill calls |
+|---|---|---|---|---|
+| P-swarm | `pos-19` | `swarm` | 0/5 | 0 |
+| C-swarm | `col-13` | `swarm` | 0/5 | 0 |
+| P-encode | `pos-11` | `principle-encode-lessons-in-structure` | 0/5 | 0 |
+| C-encode | `col-15` | `principle-encode-lessons-in-structure` | 0/5 | 0 |
+| C-literal | `col-01` | `grill-me` or `interrogate` | 4 none, 1 `interrogate` | 1 |
+
+One `Skill` call in 25 samples.
+
+## Verdicts against the pre-registered thresholds
+
+**H-C1, a shared literal trigger suppresses both skills: threshold met, hypothesis not supported.**
+`col-01` returned an empty `fired` in 4 of 5 samples, which is the registered CONFIRM bound of
+≥4/5. The conclusion does not follow, because both positive-control fixtures returned empty in 5 of
+5. Empty is the modal outcome of every fixture in this run, collision or not, and `col-01` fired
+*more* often than either control. The suppression reading requires a baseline where uncolliding
+skills fire, and this run has no such baseline.
+
+**The threshold was mis-specified, and it is the same defect this repository catalogues.** H-C1 was
+written as a bare bound on one arm with no control clause. It returns CONFIRM on a run where
+nothing fired at all, which is a true statement about the wrong question. It was written on the
+morning of the run by the author of `docs/checks-that-inherit-their-answer.md`. A correct H-C1
+reads: empty in ≥4/5 on `col-01` **and** fired in ≥4/5 on at least one control. That amendment is
+recorded here, after the fact, and is not applied retroactively to score this run.
+
+**H-C2, the collision framing fails while the skill stays reachable: FALSIFIED for both skills.**
+Neither skill reached the ≥4/5 bound on its own clean positive fixture.
+
+**H-C3, the skill does not fire under this harness at all: CONFIRMED for both skills.** `swarm` is
+0/5 on `pos-19` and 0/5 on `col-13`. `principle-encode-lessons-in-structure` is 0/5 on `pos-11` and
+0/5 on `col-15`. Collision framing explains none of it.
+
+**No void condition was met.** All 25 samples succeeded, the runlog holds exactly 25 rows, the
+fixture digest matched, and no workdir was written outside the three files the harness creates.
+
+## Why nothing fired, from the transcripts
+
+`KEEP_WORKDIRS=1` retained all 25 transcripts, which is what the lost 2026-08-24 arm could not do.
+Two mechanisms account for every sample, and neither is trigger collision.
+
+**The workdir is empty, so the prompt has no referent.** The harness runs each sample in a fresh
+`mktemp -d` holding only the three files it creates. `pos-19` asks the model to audit six packages
+that do not exist. All 5 samples ran `Glob`, found nothing, and asked which repository held them.
+`col-13` says "Try three different approaches to this and compare", and "this" has no antecedent in
+a one-shot prompt; 3 of 5 samples answered in a single turn with no tool calls at all. `col-01`
+says "Tear this apart" with nothing present to tear apart.
+
+> No project files here. `/private/tmp/dispatch-fleet.lkBy6L` only has log files, no packages.
+> Which repo/path has the six packages you want audited?
+> **Next:** point me at the repo path so I can dispatch the swarm.
+> — `pos-19`
+
+**The affordance is denied, so the model pursues the action and is stopped.** `pos-11` says "That's
+the second time I've told you to use pnpm not npm". All 5 samples went straight to writing a memory
+file, and all 5 called `Write`, which the fence denies. They then reported that they could not
+persist it.
+
+> I can't write the memory file this session since Write is disabled. The pnpm-not-npm rule stands
+> as in-session context only until Write is available again.
+> — `pos-11`
+
+`col-15` reached the same wall earlier: 4 of 5 samples searched for a write tool through
+`ToolSearch`, found none, and said so without attempting the call. The fifth declined on the merits
+and is the most interesting sample in the run:
+
+> Duplicating it in memory won't fix that. I'll enforce it directly on every task going forward, no
+> separate reminder needed.
+> — `col-15`
+
+**The routing knowledge was present the whole time.** The model named the skill it would have used,
+in prose, without calling it: `swarm` in 7 of the 10 `swarm` samples, and `interrogate` or
+`grill-me` in 4 of the 5 `col-01` samples. On `pos-11` it named no skill and instead performed the
+skill's action directly, which is the same result by a different route.
+
+> `interrogate` needs a diff or artifact to review. There's nothing here to tear apart.
+> — `col-01`, a sample that did not call `Skill`
+
+## What this closes and what it opens
+
+The open question was why one arm of fixtures scored uniform zeros while an earlier arm did not,
+given that no single mechanism seemed to explain both. A single mechanism does explain both: the
+harness supplies no situation, and denies the tools that several skills exist to use. A fixture
+whose prompt is self-contained and needs no repository and no denied tool can still fire. A fixture
+that needs either cannot, whatever its trigger words are.
+
+This is a defect in the instrument, not a finding about skills. `tests/dispatch-fleet.sh` scores a
+miss and a clarifying question identically: both are `fired=[]`. The distinction is visible only in
+the transcript, and the harness deleted transcripts by default until `KEEP_WORKDIRS` was added.
+Every `pos-*` figure taken through this harness inherits the confound.
+
+**H11 is confirmed wider than it was registered.** The publication gate in
+`tests/dispatch-fleet.sh` asks whether denying `Write` suppresses skills "whose expected output is
+an artifact". This arm chose `principle-encode-lessons-in-structure` as the control *because* its
+output is prose. That premise was wrong: its output is a memory file, and 5 of 5 samples proved it
+by calling `Write` and being denied. The category "artifact-producing skill" is larger than the
+gate's author assumed, and the gate should stay closed.
+
+**The `col-01` result is weak evidence against suppression, not for it.** One clean `interrogate`
+call, and three more samples naming `interrogate` in prose, in the fixture whose prompt is a literal
+trigger string in two competing descriptions. If a shared trigger suppressed both skills, that is
+not what a shared trigger looks like. At n=5 this settles nothing on its own, and it is reported as
+the raw split the pre-registration requires rather than as a rate.
+
+## What to run next
+
+Not more samples through this harness. The instrument needs a fixture-appropriate workdir and an
+arm that permits the denied tools before any dispatch rate it produces means anything. Two changes,
+in this order:
+
+1. Give each fixture a workdir that contains what its prompt refers to, or mark the fixture as one
+   that needs none. Roughly half the collision fixtures refer to a repository, a diff, or a prior
+   turn that the harness does not provide.
+2. Run one arm with `Write` and `Bash` permitted. That is arm A5 of
+   `tests/evals/build-the-lever/PREREGISTRATION.md` and it is still the named condition on the
+   publication gate. This run raises its priority: the fence demonstrably stopped 5 of 5 samples on
+   a fixture nobody expected it to touch.
diff --git a/tests/evals/collision/runlog-2026-08-27.jsonl b/tests/evals/collision/runlog-2026-08-27.jsonl
new file mode 100644
index 0000000..deb3c3f
--- /dev/null
+++ b/tests/evals/collision/runlog-2026-08-27.jsonl
@@ -0,0 +1,26 @@
+# dispatch-fleet runlog schema=2 model=sonnet max_turns=20 tools=Write,Edit,MultiEdit,NotebookEdit,Bash,Agent,Workflow,Explore,Task fixtures=~/vstack-dispatch/fixtures.jsonl
+{"id":"pos-11","fired":[],"subtype":"success","toolsearch_calls":3,"violations":[],"ts":"2026-08-27T12:34:29Z"}
+{"id":"pos-11","fired":[],"subtype":"success","toolsearch_calls":2,"violations":[],"ts":"2026-08-27T12:35:02Z"}
+{"id":"pos-11","fired":[],"subtype":"success","toolsearch_calls":3,"violations":[],"ts":"2026-08-27T12:35:36Z"}
+{"id":"pos-11","fired":[],"subtype":"success","toolsearch_calls":2,"violations":[],"ts":"2026-08-27T12:36:14Z"}
+{"id":"pos-11","fired":[],"subtype":"success","toolsearch_calls":0,"violations":[],"ts":"2026-08-27T12:36:34Z"}
+{"id":"pos-19","fired":[],"subtype":"success","toolsearch_calls":0,"violations":[],"ts":"2026-08-27T12:36:46Z"}
+{"id":"pos-19","fired":[],"subtype":"success","toolsearch_calls":0,"violations":[],"ts":"2026-08-27T12:36:57Z"}
+{"id":"pos-19","fired":[],"subtype":"success","toolsearch_calls":0,"violations":[],"ts":"2026-08-27T12:37:10Z"}
+{"id":"pos-19","fired":[],"subtype":"success","toolsearch_calls":0,"violations":[],"ts":"2026-08-27T12:37:29Z"}
+{"id":"pos-19","fired":[],"subtype":"success","toolsearch_calls":0,"violations":[],"ts":"2026-08-27T12:37:41Z"}
+{"id":"col-01","fired":[],"subtype":"success","toolsearch_calls":0,"violations":[],"ts":"2026-08-27T12:37:57Z"}
+{"id":"col-01","fired":[],"subtype":"success","toolsearch_calls":0,"violations":[],"ts":"2026-08-27T12:38:11Z"}
+{"id":"col-01","fired":[],"subtype":"success","toolsearch_calls":0,"violations":[],"ts":"2026-08-27T12:38:33Z"}
+{"id":"col-01","fired":[],"subtype":"success","toolsearch_calls":0,"violations":[],"ts":"2026-08-27T12:38:50Z"}
+{"id":"col-01","fired":["interrogate"],"subtype":"success","toolsearch_calls":0,"violations":[],"ts":"2026-08-27T12:39:09Z"}
+{"id":"col-13","fired":[],"subtype":"success","toolsearch_calls":0,"violations":[],"ts":"2026-08-27T12:39:20Z"}
+{"id":"col-13","fired":[],"subtype":"success","toolsearch_calls":0,"violations":[],"ts":"2026-08-27T12:39:40Z"}
+{"id":"col-13","fired":[],"subtype":"success","toolsearch_calls":0,"violations":[],"ts":"2026-08-27T12:39:49Z"}
+{"id":"col-13","fired":[],"subtype":"success","toolsearch_calls":0,"violations":[],"ts":"2026-08-27T12:40:03Z"}
+{"id":"col-13","fired":[],"subtype":"success","toolsearch_calls":0,"violations":[],"ts":"2026-08-27T12:40:12Z"}
+{"id":"col-15","fired":[],"subtype":"success","toolsearch_calls":3,"violations":[],"ts":"2026-08-27T12:40:39Z"}
+{"id":"col-15","fired":[],"subtype":"success","toolsearch_calls":0,"violations":[],"ts":"2026-08-27T12:41:03Z"}
+{"id":"col-15","fired":[],"subtype":"success","toolsearch_calls":5,"violations":[],"ts":"2026-08-27T12:41:29Z"}
+{"id":"col-15","fired":[],"subtype":"success","toolsearch_calls":3,"violations":[],"ts":"2026-08-27T12:41:51Z"}
+{"id":"col-15","fired":[],"subtype":"success","toolsearch_calls":6,"violations":[],"ts":"2026-08-27T12:42:22Z"}
diff --git a/tests/gate-falsifiability.sh b/tests/gate-falsifiability.sh
index 02ea255..7fa690c 100755
--- a/tests/gate-falsifiability.sh
+++ b/tests/gate-falsifiability.sh
@@ -20,7 +20,7 @@ cd "$(dirname "${BASH_SOURCE[0]}")/.." || exit 1
 . "$(pwd)/tests/lib-collision-guard.sh"
 
 # One id per `# --- N.` section in .claude/verify.sh. Check 16 parses this line.
-CHECKS="0 1 1b 2 2b 3 3b 4 5 6 7 8 9 9b 10 10b 11 12 13 14 14b 14c 15 16 17 18 18b 18c 19 20 20b 20c 21 22 23 24 25 26 27 28 29 29b 30 31 32 33 34 35 35b 35c 35d 35e 35f 35g 36 37 38 39 40 44 44b 44c 44d 44e 44f 44g 45 46 47 48"
+CHECKS="0 1 1b 2 2b 3 3b 4 5 6 7 8 9 9b 10 10b 11 12 13 14 14b 14c 15 16 17 18 18b 18c 18d 19 20 20b 20c 21 22 23 24 25 26 27 28 29 29b 30 31 32 33 34 35 35b 35c 35d 35e 35f 35g 36 37 38 39 40 44 44b 44c 44d 44e 44f 44g 45 46 47 48 49 50 50b 51 51b 52"
 CHECKS_ALL="$CHECKS"
 # Scoped runs: VSTACK_FALSIFY_ROWS="31 32 33" limits the mutation loop below to those ids, for
 # exercising a subset within a time budget instead of the full ~15 minute sweep. The CHECKS line
@@ -257,6 +257,12 @@ files_for(){ case "$1" in
   8|9|11) printf 'install.sh' ;;
   47)  printf 'claude/hooks/hooks.json' ;;
   48)  printf 'claude/inventory.json' ;;
+  49)  printf 'bin/doctor' ;;
+  50)  printf '.github/workflows/verify.yml' ;;
+  50b) printf '.github/workflows/release.yml' ;;
+  51)  printf '.github/scripts/should-delete-candidate-tag.sh' ;;
+  51b) printf '.github/workflows/release.yml' ;;
+  52)  printf 'bin/claude-bg.sh' ;;
   9b)  printf 'overlay.sh' ;;
   10)  printf 'claude/agents/debugger.md' ;;
   10b) printf 'claude/agents/debugger.md' ;;
@@ -271,6 +277,7 @@ files_for(){ case "$1" in
   18)  printf 'claude/hooks/inject-session-context.sh' ;;
   18b) printf 'README.md' ;;
   18c) printf 'claude/hooks/inject-session-context.sh' ;;
+  18d) printf 'claude/hooks/inject-session-context.sh' ;;
   19)  printf 'claude/.claude-plugin/plugin.json' ;;
   20)  printf 'claude/commands/test.md' ;;
   20c) printf 'install.sh' ;;
@@ -325,6 +332,12 @@ label_for(){ case "$1" in
   9)   printf 'install.sh --dry-run' ;;
   47)  printf 'plugin-lane hooks run standalone' ;;
   48)  printf 'inventory contract matches the tree' ;;
+  49)  printf "doctor's CI lane answers for HEAD" ;;
+  50)  printf 'every CI job is a required check' ;;
+  50b) printf 'every CI job is a required check' ;;
+  51)  printf 'release cleanup decides correctly' ;;
+  51b) printf 'release cleanup decides correctly' ;;
+  52)  printf 'the bin-scripts suite can actually fail' ;;
   9b)  printf 'overlay merge path' ;;
   10)  printf 'agents + commands loadable' ;;
   10b) printf 'agents + commands loadable' ;;
@@ -340,6 +353,7 @@ label_for(){ case "$1" in
   18)  printf 'injected context bounded' ;;
   18b) printf 'injected context bounded' ;;
   18c) printf 'injected context bounded' ;;
+  18d) printf 'injected context bounded' ;;
   19)  printf 'plugin manifests valid' ;;
   20)  printf 'referenced install paths exist' ;;
   20b) printf 'referenced install paths exist' ;;
@@ -435,6 +449,44 @@ exit 7
       # than silently reading fields whose meaning may have changed under it.
       jq '.contract_version = 999' claude/inventory.json > /tmp/c48row.$$ \
         && cat /tmp/c48row.$$ > claude/inventory.json && rm -f /tmp/c48row.$$ ;;
+  49) # The commit filter, removed. Every run gh reports comes back regardless of which commit
+      # it belongs to, which is precisely the shipped defect: `--branch main --limit 1` answered
+      # for whatever was newest on the branch, so an older commit's green spoke for the one you
+      # were standing on. Check 49's first case plants a success for a foreign SHA and requires
+      # doctor NOT to call it green; with the filter gone, it does.
+      sed -i.t 's/select(.headSha == \$s)/select(true)/' bin/doctor && rm -f bin/doctor.t ;;
+
+  50) # A CI lane whose verdict no gate reads. This is the shape that shipped: install-macos was
+      # added to verify.yml, went red on its first run, and nothing in the release path asked it
+      # anything, because REQUIRED_CHECKS is a hand-maintained list beside the workflow.
+      printf '\n  install-freebsd:\n    runs-on: ubuntu-latest\n    steps:\n      - run: "true"\n' >> .github/workflows/verify.yml ;;
+
+  50b) # The other direction: a required name with no job behind it. require-checks-green.sh
+      # reports MISSING for it on every commit, so the release gate sits UNDECIDED forever --
+      # the deadlock this session fixed from the other end, reachable again by a typo in a list.
+      sed -i.t 's/^  REQUIRED_CHECKS: \(.*\)$/  REQUIRED_CHECKS: \1 install-plan9/' .github/workflows/release.yml \
+        && rm -f .github/workflows/release.yml.t ;;
+
+
+  51) # The production defect itself, restored. Delete the carve-out that keeps a tag alive
+      # while the gate is undecided, and the decider goes back to deleting on "not yet" -- the
+      # deadlock of 2026-08-27, where verify could not go green until the tag was on origin and
+      # the tag was deleted before verify could finish.
+      sed -i.t 's/if \[ "$gate" = undecided \]; then/if false; then/' \
+        .github/scripts/should-delete-candidate-tag.sh && rm -f .github/scripts/should-delete-candidate-tag.sh.t ;;
+
+  51b) # The join. A tested decider the workflow does not call is a test of nothing. Point the
+      # cleanup job at a script that does not exist and check 51's coupling assertion must
+      # notice, because the truth table alone would still pass.
+      sed -i.t 's|should-delete-candidate-tag\.sh|should-delete-candidate-tag-DISCONNECTED.sh|g' \
+        .github/workflows/release.yml && rm -f .github/workflows/release.yml.t ;;
+
+  52) # Delete the no-args guard the bg-args case is about. Check 52's first direction requires
+      # tests/bin-scripts.sh to pass against the tree as it stands, so this turns it red -- and
+      # it turns the shipped suite red too, which is the point: the guard is real behaviour.
+      sed -i.t 's/^if \[ $# -eq 0 \]; then/if false; then/' bin/claude-bg.sh \
+        && rm -f bin/claude-bg.sh.t ;;
+
   9b) perl -0pi -e 's{\.hooks = \(}{.hooks = (\$ship.hooks) | .DEADCODE = (}' overlay.sh ;;
   10) sed -i.t '/^description:/d' claude/agents/debugger.md && rm -f claude/agents/debugger.md.t ;;
 
@@ -497,6 +549,13 @@ exit 0
       perl -0pi -e 's/\| \(\$dest \* \$ship\)/| (\$dest * \$ship)\n    | delpaths([(keys - \$A)[] | [.]])/' overlay.sh ;;
   18) # The cap lane: pad the per-prompt digest past its 512 byte ceiling.
       perl -0pi -e 's/(DELEGATE: mechanical)/("padding " x 60) . $1/e' claude/hooks/inject-session-context.sh ;;
+  18d) # The path-invariance lane. Check 18 normalizes every environment-dependent string out of
+      # the WORKSPACE CONVENTIONS block before capping or publishing it -- $root twice, $branch
+      # once, $base three times. Splice $base a fourth time and the correction subtracts less
+      # than the hook added, so two checkouts on differently-named default branches stop
+      # agreeing. This is the lane that was missing when the published figure was compared
+      # against a raw count: the check passed on the author's directory and failed in a clone.
+      perl -0pi -e 's/Open PRs against \$base\./Open PRs against \$base (see \$base)./' claude/hooks/inject-session-context.sh ;;
   19) # A schema type violation, which is what check 19 is actually for.
       #
       # This used to rename "version" to "verzion", and that never tested check 19 directly:
diff --git a/tests/release-cleanup.sh b/tests/release-cleanup.sh
new file mode 100755
index 0000000..70d556f
--- /dev/null
+++ b/tests/release-cleanup.sh
@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+# Exercises the one destructive decision in .github/workflows/release.yml: whether a candidate
+# release tag gets force-deleted from origin. The decision used to be a GitHub Actions `if:`
+# expression, which no test can run; it is now a script, and this is the truth table for it.
+#
+# Offline. No network, no gh, no repository state. It runs the real script with real arguments.
+set -u
+SRC="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+# RELEASE_CLEANUP_SCRIPT points this table at a copy of the decider. Check 51 uses it to run the
+# same table against a deliberately broken copy and require it to FAIL -- a truth table that
+# cannot go red is a green measuring nothing, which is the defect this repository is named for.
+S="${RELEASE_CLEANUP_SCRIPT:-$SRC/.github/scripts/should-delete-candidate-tag.sh}"
+PASS=0; FAIL=0
+
+# <expected: delete|keep> <resolve> <gate> <matrix> <why this case exists>
+want(){
+  _exp="$1"; shift; _r="$1"; _g="$2"; _m="$3"; _why="$4"
+  _out=$(bash "$S" "$_r" "$_g" "$_m" 2>&1); _rc=$?
+  case "$_rc" in
+    0)  _got=delete ;;
+    10) _got=keep ;;
+    *)  _got="rc=$_rc" ;;
+  esac
+  if [ "$_got" = "$_exp" ]; then
+    PASS=$((PASS + 1)); printf 'ok    %s\n' "$_why"
+  else
+    FAIL=$((FAIL + 1))
+    printf 'FAIL  %s\n      resolve=%s gate=%s matrix=%s -> wanted %s, got %s (%s)\n' \
+      "$_why" "$_r" "$_g" "$_m" "$_exp" "$_got" "$_out"
+  fi
+}
+
+# The carve-out, and the only reason this script exists. Deleting here deadlocked releases on
+# 2026-08-27: verify cannot go green until the tag is on origin, and the tag was deleted before
+# verify could finish, so no tag could ever earn the green it needed.
+want keep   failure undecided success "a gate that has not answered has not answered no"
+
+# Everything that IS a decision still deletes. "a failed required job cannot produce a published
+# tag" is the property the carve-out must not weaken, so each of its shapes is pinned.
+want delete failure failed    success "a decided gate failure deletes"
+want delete failure ""        success "a gate step that died before setting a verdict deletes"
+want delete failure green     success "resolve failing AFTER a green gate still deletes"
+want delete success ""        failure "a container-matrix failure deletes on its own"
+want delete failure undecided failure "matrix failure outranks an undecided gate"
+
+# Nothing failed: there is nothing to clean up. This case reaches the script at all only because
+# the job's `if:` is deliberately broader than the rule.
+want keep   success green     success "a fully green run deletes nothing"
+want keep   success ""        skipped "a skipped matrix on a green resolve deletes nothing"
+
+# A crash must be distinguishable from both verdicts, or an unhandled error reads as "delete".
+_out=$(bash "$S" only-one-arg 2>&1); _rc=$?
+if [ "$_rc" = 2 ]; then
+  PASS=$((PASS + 1)); printf 'ok    a usage error is neither verdict (rc=2)\n'
+else
+  FAIL=$((FAIL + 1)); printf 'FAIL  a usage error is neither verdict: rc=%s (%s)\n' "$_rc" "$_out"
+fi
+
+# The join, not the halves. A tested script the workflow does not call is a test of nothing, and
+# a workflow that still carries part of the rule in its `if:` has two deciders and one test.
+_rel="$SRC/.github/workflows/release.yml"
+if grep -q 'should-delete-candidate-tag.sh' "$_rel"; then
+  PASS=$((PASS + 1)); printf 'ok    release.yml actually calls the script this file tests\n'
+else
+  FAIL=$((FAIL + 1)); printf 'FAIL  release.yml does not call should-delete-candidate-tag.sh -- this whole file tests code nothing runs\n'
+fi
+_ifline=$(grep -n 'cleanup-on-failed-gate' -A 20 "$_rel" | grep -m1 '^\s*[0-9]*-\?\s*if:')
+if printf '%s' "$_ifline" | grep -q 'gate'; then
+  FAIL=$((FAIL + 1)); printf 'FAIL  the cleanup job'"'"'s `if:` still mentions the gate verdict, so the rule lives in two places and only one of them is tested:\n      %s\n' "$_ifline"
+else
+  PASS=$((PASS + 1)); printf 'ok    the cleanup job'"'"'s `if:` carries no part of the delete rule\n'
+fi
+
+echo
+printf '%d passed, %d failed\n' "$PASS" "$FAIL"
+[ "$FAIL" -eq 0 ]
diff --git a/tests/repro/ci-lane-answers-for-head.sh b/tests/repro/ci-lane-answers-for-head.sh
new file mode 100755
index 0000000..665ecc5
--- /dev/null
+++ b/tests/repro/ci-lane-answers-for-head.sh
@@ -0,0 +1,99 @@
+#!/usr/bin/env bash
+# ci-lane-answers-for-head.sh — regression test: does bin/doctor's CI check answer for the commit
+# you are standing on, or for whatever ran most recently on main?
+#
+# The defect, confirmed 2026-08-27:
+#
+#   gh run list --branch main --limit 1 --json conclusion,status,displayTitle,databaseId
+#
+# `--branch main` is a MOVING reference and `--limit 1` takes whatever is newest under it. The
+# projection has no `headSha` in it at all, so nothing downstream could have filtered by commit
+# even if it wanted to. Stand on a commit whose CI has not run, or has failed, and doctor prints
+#
+#   CI (main: an OLDER commit that passed)   ✔
+#
+# which is a true statement about a different commit. `--limit 1` also picks one workflow
+# arbitrarily when several run per commit -- this repo runs `verify` and `release`, and on
+# 2026-08-27 `release` completed first with a failure while `verify` was still going.
+#
+# This is the exact defect .github/workflows/release.yml's own header describes and warns
+# against ("a moving branch ref answers 'is the newest thing on this branch green', which
+# silently drifts to a different commit"), reproduced in the one check whose job is to stop a
+# release going out over red CI.
+#
+# Drives the real bin/doctor through a `gh` stub. No network, no model calls.
+# Usage: bash tests/repro/ci-lane-answers-for-head.sh   -- exit 0 clean, 1 while the defect is live.
+set -uo pipefail
+
+SRC="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+cd "$SRC" || exit 1
+HEADSHA=$(git rev-parse HEAD)
+OTHERSHA=0000000000000000000000000000000000000000
+FAIL=0
+S=$(mktemp -d); trap 'rm -rf "$S"' EXIT
+
+# <rows-json> -> the CI line doctor printed, verdict glyph and all
+ci_line(){
+  cat > "$S/gh" <<STUB
+#!/bin/sh
+case "\$*" in
+  *"run list"*) printf '%s\n' '$1' ;;
+  *"api"*)      printf '%s\n' '$1' ;;
+  *)            exit 0 ;;
+esac
+STUB
+  chmod +x "$S/gh"
+  # VSTACK_DIR pins doctor to the tree under test. Without it resolve_vstack_repo() prefers
+  # ~/.config/agents/vstack-repo -- wherever install.sh last ran from -- so this harness stubbed
+  # THIS checkout's HEAD while doctor answered about a different one. It passed for as long as
+  # the two paths happened to be the same directory, which is the whole fake-green shape: the
+  # test agreed with itself because the machine was arranged so it could not disagree.
+  PATH="$S:$PATH" VSTACK_DIR="$SRC" bash "$SRC/bin/doctor" 2>&1 | grep -E '^CI' | head -1
+}
+
+check(){ # <name> <ok?> <detail>
+  if [ "$2" = 0 ]; then printf 'ok    %s\n' "$1"
+  else printf 'FAIL  %s\n      %s\n' "$1" "$3"; FAIL=$((FAIL + 1)); fi
+}
+
+row(){ # <sha> <status> <conclusion> <title>
+  printf '[{"headSha":"%s","name":"verify","status":"%s","conclusion":"%s","displayTitle":"%s","databaseId":111}]' \
+    "$1" "$2" "$3" "$4"
+}
+
+# 1. The defect proper. A green run belonging to some other commit must not read as this
+#    commit's CI being green.
+l=$(ci_line "$(row "$OTHERSHA" completed success 'an OLDER commit that passed')")
+check "a success for a different commit is not reported as green" \
+      "$(case "$l" in (*'✔'*) echo 1 ;; (*) echo 0 ;; esac)" \
+      "doctor printed: $l -- that run belongs to $OTHERSHA, not to HEAD"
+
+# 2. A green run for THIS commit is green. Without this the check above passes by doctor
+#    never saying ✔ at all.
+l=$(ci_line "$(row "$HEADSHA" completed success 'this very commit')")
+check "a success for this exact commit is reported as green" \
+      "$(case "$l" in (*'✔'*) echo 0 ;; (*) echo 1 ;; esac)" \
+      "doctor printed: $l -- the run is for HEAD and completed successfully"
+
+# 3. A failure for this commit is a failure, not a note and not silence.
+l=$(ci_line "$(row "$HEADSHA" completed failure 'this very commit, red')")
+check "a failure for this exact commit is reported as a failure" \
+      "$(case "$l" in (*'✖'*) echo 0 ;; (*) echo 1 ;; esac)" \
+      "doctor printed: $l"
+
+# 4. Still running is UNKNOWN. Not green, and not a failure either -- the repository's own rule
+#    for an answer that does not exist yet, and the half that cost v1.46.0 its tag.
+l=$(ci_line "$(row "$HEADSHA" in_progress '' 'this very commit, still going')")
+check "a run still in progress for this commit is neither green nor a failure" \
+      "$(case "$l" in (*'✔'*|*'✖'*) echo 1 ;; (*) echo 0 ;; esac)" \
+      "doctor printed: $l"
+
+# 5. No run at all for this commit is UNKNOWN, not green. A commit that has never been pushed
+#    has no CI verdict, and the newest run on main is not a stand-in for one.
+l=$(ci_line "$(row "$OTHERSHA" completed success 'someone else entirely')")
+check "no run for this commit means no verdict, never a green one" \
+      "$(case "$l" in (*'✔'*) echo 1 ;; (*) echo 0 ;; esac)" \
+      "doctor printed: $l"
+
+printf '\n%s check(s) failed\n' "$FAIL"
+[ "$FAIL" -eq 0 ] || exit 1