Test Gate — verify before commit, block on red

Overview

Run the project's full Tier-B battery, read the real output, and stop the moment anything is red — never commit a red tree, never claim "passing" you did not watch pass. The strategy this enforces is the project's docs/TESTING.md. Invocation is the authorization — run end-to-end without a confirm prompt.

This is the project's concrete runner, built from its own commands and infra. Closing ritual: test-gate green, then commit, then /generate-pr.

Arguments & modes

• $1 = full (default) — the Tier-B PR-gated battery (what blocks a commit/merge).
• $1 = fast — Tier-A local loop (unit + property + lint), skips Docker/integration for a tight feedback cycle. fast green is not sufficient to commit — run full before committing.

Step 0 — Discover the commands (deterministic — never guess them)

Read the source of truth; do not invent commands:

sed -n '/## Commands/,/^## /p' CLAUDE.md         # the canonical command list
cat docs/TESTING.md                              # tiers, kinds, the Docker infra block, the gate order
ls docker-compose*.y*ml 2>/dev/null              # is there hermetic infra to bring up?

Map what you find to the gate stages and set a shell var per stage from the real discovered command — $LINT, $TYPECHECK, $TEST (the Tier-B suite), $E2E, and $MIGRATE / $SEED for infra. If a stage has no command in this project, leave its var empty, skip it, and say so in the report (an honest "no e2e configured" — never a silent pass). Never read or print .env or secrets: to check a needed var, test presence only ([ -n "$VAR" ] && echo set).

Step 1 — Bring up hermetic infra (only if a compose file exists)

COMPOSE=$(ls docker-compose.test.y*ml docker-compose.y*ml 2>/dev/null | head -1)
if [ -n "$COMPOSE" ]; then
  docker compose -f "$COMPOSE" up -d --wait        # wait for healthchecks; don't race startup
  trap 'docker compose -f "$COMPOSE" down -v' EXIT # ALWAYS tear down + drop volumes, even on failure
  [ -n "$MIGRATE" ] && eval "$MIGRATE"; [ -n "$SEED" ] && eval "$SEED"   # deterministic schema + fixtures
fi

Infra is ephemeral, seeded, isolated — never point integration tests at a shared or staging database. If Docker is unavailable, run unit+property, and report integration as not-run (do not pretend it passed).

Step 2 — Run the battery, fail-fast, reading every output

Order (a red stage stops the rest — fix the earliest failure first):

lint  →  typecheck  →  unit  →  property  →  contract/schema  →  integration  →  e2e (if wired)

Run each present stage with the discovered command; capture and read its output and exit code:

run () { [ -z "$2" ] && { echo "── $1: skipped (no command) ──"; return; }; echo "── $1 ──"; eval "$2"; rc=$?; echo "exit=$rc"; [ $rc -eq 0 ] || { echo "RED at: $1"; exit $rc; }; }
run lint        "$LINT"
run typecheck   "$TYPECHECK"
run tests       "$TEST"          # unit + property + contract + integration per TESTING.md Tier B
run e2e         "$E2E"           # only if configured

• Property tests are what makes the suite total rather than partial — they generate empty, boundary, malformed and adversarial inputs. If the suite has none for a function with a stateable law, flag it as a gap.
• Generative paths (if any): confirm the critic/fallback path is exercised (e.g. FORCE_DEGRADE=1) — ground, generate, verify, degrade — with the fallback actually run.

Step 3 — Report the verdict (honest, evidence-based)

• All green: report each stage with its real result (exit=0), state Tier-B is green, and that it is safe to commit. Only now may a todo item's → verify: be marked passed.
• Any red: report the earliest failing stage with its real output — the failing assertion, the error — and stop there. Do not continue the battery and do not commit. Fix the earliest failure first; a later stage failing because an earlier one did is noise, not a second problem.
• Skipped stages: name them explicitly (integration: skipped — no Docker) — a skipped check is never a passed check.

Hard rules (stop if you catch yourself doing these)

• Claiming "tests pass" / "it's green" without having run the command and read exit=0. → run it; read it.
• Committing, or telling the user to commit, on a red or partially-run gate. → block.
• Reading, cat-ing, echoing, or pasting .env or any secret or log value. → presence-test only.
• Pointing integration tests at a real/shared database instead of ephemeral Docker infra. → compose up/down.
• Leaving infra running after a failure. → the trap … down -v tears it down on every exit.
• Marking a todo item verified off a fast run. → only a green full Tier-B run justifies it.