guardrails-review
Skill2 starsChanged 2 months agoMITView on GitHub
Adversarial second pass over a generated (and possibly human-edited) Guardrails task folder: per task, find the cheapest WRONG implementation that would pass all its guardrails. Use when the user says "review this task folder", "run guardrail review on <folder>", or after /plan-breakdown produces a draft. Read-only critique by default — applies fixes only with per-finding approval, and never deletes a human-added guardrail without naming it first.
In this repository5 other files it gives its agents.
- cut-releaseSkill
- guardrails-dev-knowledgeSkill
- guardrails-domain-knowledgeSkill
- plan-breakdownSkill
- uber-reportSkill
The file
We split this skill into the rules it gives an agent
8 rules. About 0 are common, 5 are distinctive, and 3 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈5
Distinctive · estimate
This author's own choices. Worth a look.
3
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 20
If such an output exists, that's a finding.
- Very specific: line 26
Read guardrails.json, every task.json, every action and guardrail file.
- Very specific: line 29
Run guardrails plan <folder> to see the waves.
- Distinctive: line 98
If the same agent authored the breakdown, it already answered that question implicitly, and answered it in the affirmative.
- Very specific: line 159
ALWAYS 0 at guardrail time.
- Distinctive: line 389
One interaction to name so the fix is not over-applied: After the split, the red census may legitimately need to EXEMPT one test: the …
- Distinctive: line 1032
Trigger set: Every guardrail clause asserting *"file X contains / references / does Y"* where Y is a
- Distinctive: line 1057
Does the carrier already expose what Y needs, on that tree?: If yes → reachable; stop.
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Guardrail Review
The plan-breakdown skill (and the human after it) decided what the guardrails are. This skill attacks them. Its one question, asked per task:
"What is the cheapest action output that passes ALL these guardrails while not actually doing the task?"
If such an output exists, that's a finding. An empty findings list backed by evidence ("attempted to game tasks 1–5 as follows; couldn't") is a valid outcome — don't pad.
Procedure
1. Inventory
Read guardrails.json, every task.json, every action and guardrail file. Build the
DAG mentally. Run guardrails validate <folder> first — never hand-check what the
tool checks (schema, refs, cycles, zero-guardrail tasks, missing promptRunners).
Run guardrails plan <folder> to see the waves.
Then run guardrails graph <folder> --check. diagram.md is a deterministic
projection of the folder; the human and earlier passes edit guardrails between
breakdown and review, so a stale or missing diagram means the DAG changed since it
was drawn. Branch on the exit code:
- exit 2 (stale or missing) → regenerate with
guardrails graph <folder>and note in the Step 6 report that the diagram was refreshed to match the current folder. - exit 1 (a load/validate error) → do NOT regenerate; surface the error in the
report —
--checkcouldn't even load the plan, so the folder has a deeper problem. - exit 0 (fresh) → nothing to do.
While reading each guardrail script during this pass, flag any that pattern-match a
specific tool's PRINTED console output (a Select-String/regex on a build or test
tool's summary/error text) rather than just its exit code or a file it wrote — Step 2's
adversarial pass runs that tool once against the real workspace to check the pattern
against genuine output (see "Pattern-matching guardrail not verified against real
output" below). Also flag every .sh/.ps1/.py guardrail that RENDERS or EXECUTES
the task's own output (writes a throwaway workspace / rendered fixture, runs an
--input-type/-e block, parses --json) — Step 2's adversarial pass EXECUTES those
against hand-synthesized valid + invalid samples to prove the SCRIPT'S OWN correctness
(see "Script guardrail not smoke-tested against a valid + invalid sample" below, the
#302 probe — distinct from the #248 tool-output probe). Also flag three more sets while
you are already reading: (a) every guardrail asserting a property of implementation
source — §2's demotion probe asks whether a test could have carried it (#468); and
(b) every guardrail carrying BOTH a require-present and a forbid-present clause, or a
forbid-present clause of any kind — Probe C reconciles those pairs, and the collision they
can form is satisfiable by no file at all (#470); and (c) every clause requiring a datum — a value
that must ARRIVE from somewhere — in a named file, which §2's Unreachable-outcome probe traces to its
carrier (#474). Noting all five candidate sets here avoids re-reading every script during the pass.
Read the PLAN-level and WAVE-level gate scripts in this same sweep (<plan>/guardrails/,
<plan>/preflights/, and each <plan>/<wave>/ pair) — they are checks with dependencies, not
infrastructure, and treating them as scenery is precisely what let a BLOCKER through validate,
graph --check and a full review pass (#474; §4 has the mechanics).
And while you read each ACTION PROMPT, build a list of every structural claim it makes about the
codebase (#578) — an enumeration ("there are N sites", "the sites are A and B"), a routing claim
("A funnels through B"), an exclusivity claim ("the only caller"), or a named location
("File.cs:123", "the Foo method in Bar.cs"). §2's #578 probe EXECUTES that list one command at a
time; collecting it here costs nothing beyond the read you are already doing, and rebuilding it afterwards
means re-reading every prompt in the plan.
Get the breakdown report's Seam ledger (#382) in front of you NOW, before the pass — §2's
passing-but-blind probe audits it row by row and then re-derives it from the folder, and there is no
validate check behind it. It lives in the Step 7.4 breakdown report, not in the plan folder, so in a
fresh session you have to ask for it; asking after you have already read every action prompt spends the
pass twice. If it cannot be produced, the probe still runs from the folder alone (its check 7) and the
Step 6 report says the ledger was unavailable — which is not the same finding as a ledger whose heading
is missing.
Waved plan? Review wave-by-wave (#254). A plan is waved when it has no root tasks/ and ≥1
wave-NN-<slug>/ subdir (SSOT §14; plan-breakdown Step 9). Each wave is a mini-plan — its own
preflights//guardrails//tasks/ and its own WaveDefinitionHash-keyed review marker. guardrails
validate/plan/graph are already wave-aware; run them on the whole plan as usual. Then run the
adversarial pass (§2) per task WITHIN each wave, and give each wave's entry/exit gates the
four-folder treatment (§2 "Four-folder gap" probe, applied at wave granularity). Two review modes:
- Whole waved plan — review every authored wave, wave by wave, then
guardrails mark-reviewed <folder>(or per wave). - A single freshly-authored wave (the JIT flow) — plan-breakdown's JIT staged mode authors a
downstream wave AFTER its upstream ran (against the materialized integration worktree), so you review
just that wave:
<folder>/wave-NN-<slug>is a mini-plan folder — run the same adversarial pass on its tasks + entry/exit gates, thenguardrails mark-reviewed <folder>/wave-NN-<slug>. Do the waved-specific probes below (the "#254 — waved plans" block in §2) in either mode.
1b. If you AUTHORED this folder, do not run the adversarial pass alone (#467)
This pass rests on one question — "what is the cheapest action output that passes ALL these guardrails while not actually doing the task?" — and on the reviewer not already having an answer.
If the same agent authored the breakdown, it already answered that question implicitly, and answered it in
the affirmative. It chose the test class names, the --filter scopes, the regexes, the writeScopes, and
believed each correct at the moment it wrote them. A self-review re-reads those choices carrying the same
model of what they mean. That is not laziness or lack of rigour — it is that the reviewer and the
author share a prior, so the failures this pass exists to catch are exactly the ones invisible from it.
Delegate the adversarial pass to independent agents and compare results. Hand them the folder cold — the plan, the design of record, the charter — and deliberately WITHHOLD your own findings, so their pass is independent rather than a confirmation of yours. Reconcile afterwards: agreement is evidence, disagreement is signal, and a finding only one pass produced is the one most worth reading.
Two supporting rules, learned in practice:
- Diverse lenses, not redundant copies. Two agents asked the same question mostly agree with each
other. Pair the adversarial lens (
guardrails-devils-advocate— "what wrong implementation passes?") with a CONTRACT lens (guardrails-architect— "does this encode the design of record and the harness contracts?"). Those find different classes of defect. - The author is the worst judge of their own answer to a maintainer's ruling. Where the breakdown implements something the human explicitly asked for, the authoring agent has the strongest incentive to see it as adequate — so NAME that specific artifact to the independent reviewer as a thing to attack.
The evidence, two incidents in one session. A structural guardrail asserted a resolver delegates to its
selection entry point with if ($code -notmatch 'SelectCandidate\s*\('). That pattern is satisfied by
the method's OWN DECLARATION, so an implementation that stopped delegating entirely still passed. It was
authored, then read again during review, and looked right both times — caught only by EXECUTING it
against a mutated sample (§2b's #302 step). Separately, a change widened a task's writeScope and narrowed
its gate filter; they were treated as alternatives when they were complements, since narrowing the gate
removed the very obligation widening the scope had enabled. The authoring agent reviewed its own change and
missed it; an INDEPENDENT agent found it.
Two things this is not. It is not a claim that self-review is worthless — a self-pass catches plenty, and it produced the first incident above via the execution step this skill already mandates. The claim is narrower: self-review is systematically blind to ASSUMPTION-level defects, and that is the class this skill exists to catch. And it is not a gate. #366 settled the doctrine for this surface — the marker is audit hygiene, not enforcement, and nothing in a plain-file model is unforgeable, since an agent that can author the plan can author a matching attestation. A "the author may not review" hard check would inherit all of that weakness and add a bypass incentive. This is an instruction you follow, and at most a recorded fact for later audit — never a refusal.
When you cannot delegate — no agent tooling in the session, or the user has asked you to work alone — say so in the report, in one line, and name it as a limitation of the pass rather than proceeding silently. A review that was structurally unable to see one class of defect should not read like one that looked and found nothing.
2. Adversarial pass per task (the heart)
Role-play a lazy or wrong implementer. Concrete probes (mirror of the catalogue's
anti-pattern list — .claude/skills/plan-breakdown/references/guardrail-catalogue.md):
- Tautology: does any guardrail check something the action itself writes to satisfy it? (Action controls the evidence.)
- Echo-judge: does a prompt-judge read the action's claims (summary, report about the work) instead of the raw artifact?
- Replay-the-action: does a guardrail re-run the action's own command (a full
dotnet build; dotnet test) when the postcondition is expressible from recorded output — a produced artifact or a runner-written TRX (GUARDRAILS_ACTION_RESULT/_STDOUT, SSOT §5.1)? If so, suggest verify-recorded-action-result (#9): assert the artifact / parse the TRX instead of replaying. (Counter-check: a replay is the HONEST gate when no recorded GOOD target carries the postcondition — don't flag it then.) - Action-exit-code tautology / echo-judge on action stdout: does a guardrail test
GUARDRAILS_ACTION_RESULT.exitCode -ne 0(a tautology — the recorded exit code is ALWAYS 0 at guardrail time; a non-zero action failed the attempt before guardrails ran), or grepGUARDRAILS_ACTION_STDOUTfor the action's own success word ("Passed!","Build succeeded"— an echo-judge, also SDK-version-brittle)? Fix: read a runner-written structured result (TRX) or a produced artifact, never the self-report. - Hollow output assertion (#73): for a terminal/e2e guardrail whose task claims a
non-empty quantity of output (migration moved-count, items written, rows produced,
entities created), does the assertion green-light a zero/null result? Tells: a
keyword-presence regex
Assert.*\([^)]*(Moved|Written|Count|Entities)(matchesAssert.Equal(0, writer.Count)), a bareAssert.NotNull(...), or anexit 0with no positive-value check. "It didn't error" / "the keyword is present" is a structural no-op for "did anything get produced?" — a run that moved ZERO entities passes. Fix: require a strictly positive value ((>\s*0|>=\s*1|NotEmpty\s*\(|True\s*\([^)]*Count\s*>\s*0)), or read the runner-recorded count / state key and assert> 0. (Catalogue → positive-effect / non-hollow assertion.) BLOCKER — a zero-effect run goes green. - Judge-where-deterministic-possible: for every
.prompt.mdguardrail, name the deterministic archetype that could replace it, or confirm none can (the 4-question demotion gate). - Over-broad: "all tests pass" anywhere except the terminal
<plan>/guardrails/folder. Judge the filter's SCOPE, not its presence (#455). A--filterdoes not make a guardrail narrow — a task-level filter keyed on a plan-wide selector (the trait every new test class in the plan carries, a whole test project, a bare namespace) IS this anti-pattern wearing a filter, and it reads perfectly well in isolation. That is how it survived a review pass. Resolve every task-level test filter to the actual SET of tests it selects and compare that set against the tests the task's own pair owns; the full two-direction probe is in §2 below (deadlock / tautology). - Model named but unservable — the pre-run availability check (#224 ·
model-tiering-stage-1charter D): walk the task folder you are reviewing and collect every model a task names statically, then assert each one resolves to a runnerguardrails.jsonactually configures. Reports, never rewrites — the pass names the task and the model and leaves the fix to the human, exactly as it does for a weak guardrail; it never edits apromptRunnersblock or anaction.modelto make its own check pass. Why this belongs to the REVIEW and not the harness:PromptRunnerRegistry.FromConfigalready refuses a config it cannot serve — but by then the run is IN FLIGHT: a wave may have committed work, and the operator meets a config problem as a mid-run halt instead of as a review finding. Registry construction is the backstop; this probe is the gate. Everything decidable from the plan plus the config gets decided BEFORErun.- What to collect — statically named = written in the folder or the config, readable without
running anything: (1) each task's
action.model; (2) each surviving prompt-judge guardrail's configured model — a judge's.prompt.mdfrontmatter names only arunner, never a model, so read the block it resolves to:guardrailOverrides.modelwhen present, else that block'smodel(SSOT §2/§9); (3) eachpromptRunners.<name>.modelitself, which is what every prompt on that block gets when no task overrides it. Surviving = the judges still standing after the demotion gate above — do not chase a judge you are already recommending be replaced by a deterministic check. - Which runner will carry it (SSOT §3/§9):
action.runner> the prompt file's frontmatterrunnerpromptRunners.default(only when it names a declared block) > the sole declared block when exactly one exists > nothing resolves.action.modeldoes NOT select a runner — there is no model→runner routing in the harness; a model is an OVERRIDE applied to whatever runner the task already resolves to (the Stage 2 tier resolver, #226, is the first thing that will route). So check each model against the ONE block that will carry it, never against the union of every declared block. - Unservable, in three shapes. (a) Nothing resolves — ≥2 declared blocks, no (or a dangling)
promptRunners.default, and neither the task nor the judge names one; the registry throws "No prompt runner specified and no default is configured" → BLOCKER. (b) The carrying block'skindhas no concrete runner in this harness version —codex/openrouter/local, of which onlyclaudeis real today (SSOT §9) → BLOCKER, and the shape that reads green everywhere else: such a config LOADS AND VALIDATES CLEAN by design (declaring a kind is legal — deliberately no diagnostic) and then fails registry construction with anInvalidOperationExceptionnaming the kind, soguardrails validatewill never tell you and this probe is the only pre-run signal. (c) Provider-family mismatch — the id plainly belongs to a different provider than the carrying block'skind→ WEAK, and a judgement call: a model identifier has no enumerable valid set (exactly why GR2030 checks only its SHAPE) andproviders initnever fabricates one, so there is no catalogue to look it up in. Report what you observed and why it looks wrong; never claim the model does not exist. - Do not re-report what
validatealready says — GR2004 (a runner name no block declares), GR2008 (prompts but nopromptRunners), GR2030 (a malformedmodelstring), GR2009 (acommandnot on PATH, a WARNING since the plan may run on another machine). This probe covers precisely what those miss: a well-formed model on a resolvable runner the harness cannot construct. - A judge whose model is resolved JUST-IN-TIME is OUT OF SCOPE here — and must NOT be silently
skipped. JIT judge resolution (the model chosen at judging time rather than written in the folder)
is deferred to #223, where a judge can actually resolve to a non-Claude model and the check has
more than one case to verify; by construction that resolution happens AFTER the work it judges is
done, so a failure there has already been paid for. Until #223 fills the socket, the Step 6 report
NAMES each judge this pass could not check and why, so the gap is visible rather than assumed
covered — a review listing only what it verified reads as coverage it does not have. Keep that
distinct from the ordinary no model named case (
modelnull at both sites, so the runner is simply never passed--model): nothing is named, nothing is deferred, and there is nothing to check.
- What to collect — statically named = written in the folder or the config, readable without
running anything: (1) each task's
- Model-appropriateness — the tag-quality net (#229 ·
model-tiering-stage-3charter §C): the third advisory surface of the tiering work, and the only one that fires at ZERO SPEND — the other two (the startup preflight line and the per-attempt JIT re-check) fire during a run, so a mis-tag they surface has already been paid for. Two findings of deliberately different character: one is a fact about the folder, the other is a model's opinion about difficulty, and folding them together would let the opinion borrow the fact's authority. Both are ADVISORY, at this skill's existing severity conventions (§6), and neither is ever a silent auto-fix. Reports, never rewrites — like the #224 probe above it names the task or the judge and leaves the fix to the human; it never edits atask.jsontag, a judge's frontmatter block or apromptRunnersblock to make its own check pass.- The gate, and the silence behind it. Run this probe ONLY when tiering is CONFIGURED — at
least one
promptRunners.<name>.routingblock, or a top-leveltieringblock, in the config that governs this plan. On a plan generated before tiering shipped this probe produces NOTHING AT ALL — no finding, no unchecked-gap line, and no note saying it was skipped. The third of those is the one a careful reviewer breaks by being helpful, and the charter states why it must not be broken. A check that fires on every legacy plan gets muted within a week, and a muted check is indistinguishable from the absence this stage exists to fix. (Invariant 7's review-time counterpart: with nothing routing, every rung is inert, so there is nothing for a tag to be appropriate to.) - Missing classification (deterministic — a fact about the folder): a prompt-action task, or a
surviving judge guardrail, with neither a difficulty tag nor an explicit
action.model/action.effortpin. - What to walk, and what discharges it. Two populations, both readable straight off the folder
without running anything. (1) Tasks — every task whose action is a PROMPT: its own
action.tier(easy/medium/hard, SSOT §3) discharges it, and so does an explicitaction.modeloraction.effortpin, because a task that names its route by hand has classified itself (GR2053 already reports the pin-plus-tier overlap — do not re-report that as this finding). (2) Judges — every SURVIVING prompt-judge guardrail, i.e. the ones still standing after the demotion gate above, in every folder one can live in: each task'sguardrails/andpreflights/, the plan-root<plan>/guardrails/+<plan>/preflights/pair, and each wave's pair. A script action and a script guardrail are not subjects at all — they run no model, so there is nothing to classify. Severity WEAK (the plan runs, but on a rung nobody chose); NIT for one trivial task in an otherwise fully tagged plan; never a BLOCKER, since no wrong implementation passes on account of a rung. - What does NOT discharge it — the trap that would empty this half. A plan-wide
tiering.defaultTierdoes NOT discharge it: the loader resolves that default into every untagged task, so a probe that read the RESOLVED tier would report every configured plan as fully classified. A plan carryingtiering.defaultTier: "medium"has a non-null resolved tier on every task, including the one a human hand-added after breakdown that nobody ever classified — which is precisely the case this net exists for, because with the runtime ladder (#228) deferred there is no backstop and a mis-tag is caught here or not at all. Read the task's own declaration —TierOrigin.Taskis the value that survives the?? defaultTiercollapse (DoR §12.4). - The judge half's inheritance rule, which is what keeps it from being noise. A surviving
prompt-judge guardrail carries its own
tierin FRONTMATTER (SSOT §4.2), and an absent key means its rung FOLLOWS THE ACTOR it guards — so it is unclassified only when that task is unclassified too, or when it guards no task at all (a plan-root or wave-root gate). An untagged judge over a CLASSIFIED task is correct and is not a finding; flag every untagged judge instead and this half fires on nearly every configured plan, which is how a check gets muted. - Mismatched tier (judgment — a model's opinion about difficulty): a high-risk task tagged for a
weak tier, or a mechanical one tagged frontier-only. Say in the finding what it is — an opinion,
which is exactly why it is kept separate from the deterministic half rather than folded into it. Two
shapes are worth naming: a HIGH-RISK task (a composition-root wiring, a cross-cutting output shape,
an unfamiliar-SDK integration) tagged
easy, and a MECHANICAL one (a rename, a config edit at a named key, a seeded directory) taggedhard. The guard rail on this half: Difficulty maps to a candidate SET, not to a single model strength — a tier names a RUNG and the resolver picks from the set that rung admits, so a finding phrased as this should run on<model>is arguing with the design rather than applying it. Name the rung and the reason, and leave the model to the resolver. WEAK at most, NIT where the disagreement is one rung on a task that could defensibly sit either side. - Two boundaries — no code, and no second opinion on the config. Neither finding gets a GR code: a
GR code is a thing that can fail a build, and the harness does not block on a model-quality opinion
(DoR §12.6). Do not propose one, and do not propose a
guardrails validatecheck to carry either half; that ruling is settled and this pass does not reopen it. And, as with the #224 probe, do not re-report whatvalidatealready says — a plan with tags and noroutingblock anywhere is GR2049's business, not this probe's, and a used tier with no candidate at or above it is GR2048's. This probe covers precisely what those miss: a CONFIGURED plan whose subjects were never classified at all, or were classified at a rung that does not match the work.
- The gate, and the silence behind it. Run this probe ONLY when tiering is CONFIGURED — at
least one
- Missing / malformed positive-baseline (preflight) on a brownfield plan (#181): does the plan
build onto existing code that already has tests in the touched area (a brownfield plan — it modifies
project(s) with existing test coverage), yet carry no
<plan>/preflights/01-baseline-<area>-tests-greencheck? Without it, a work task'stests-passguardrail can fail from PRE-EXISTING breakage (misattributed → wasted retries → lateneedsHuman), and a new test's "red" is ambiguous (missing-behavior vs already-broken). Under the four-folder model the baseline is a positive check FILE in the plan-root<plan>/preflights/folder (a Full Flight Check evaluated once, before the DAG, against the starting repo) — NOT a no-op ROOT task. It runs the EXISTING area tests via--filterand asserts they PASS on the current code (area-scoped, deduped one-per-area, using the #179 re-emit form); it needs nodependsOnand no wired-in work-task edges (the preflight phase implicitly gates the whole DAG — "never build on red"). Check, if a baseline preflight IS present:- (a) Targets only the PRE-EXISTING tests via
--filter— NOT the about-to-be-authored red tests (it runs before the DAG on the starting state — a baseline that would run a siblingauthor-teststask's failing tests is mis-scoped), and NOT the whole suite/project. A whole-projectdotnet testin the preflight hits the #165/#176 compile-coupling trap (a mid-TDD project does not compile → false red no work task can fix). A whole-suite-scoped baseline is a BLOCKER. - (b) It is a
<plan>/preflights/FILE, not a task — a lingering no-op ROOT baseline TASK (the retired00-baseline-*exit 0-action +dependsOn:[]model) is a finding: re-home it to the preflight folder. There is no action to no-op — the preflight file IS the verification. - (c) Deduped one-per-area — one preflight file per distinct touched test project, each scoped to its area, NOT one global whole-repo preflight.
- (d) Distinct from the terminal gate (green START before the DAG via
<plan>/preflights/vs green END on the merged HEAD via<plan>/guardrails/— a plan needs both). - (e) The worth-it gate held — target pre-exists, MODIFIES-not-creates, deterministic + cheap (a
bounded, filtered command — a filtered
dotnet testis fine; no live-service boot/poll), strictly narrower than the terminal gate, ≥2 work tasks build on the area. The inverse error: a vacuous baseline on a GREENFIELD plan (adotnet testover a project with zero tests, which trivially passes) — it certifies nothing while looking like a gate; greenfield must have NO baseline preflight. A RED baseline preflight halts the run before the DAG (the general Full-Flight-Check semantics), and #179 (re-emit form) makes its WHY reach the halt feedback. The negative "not yet present" baseline is NOT a separate archetype — it already IStests-fail-on-current-code/tests-fail-on-stubs(do not expect, or flag the absence of, a parallel "negative preflight" archetype; when emitted at plan level it is likewise a<plan>/preflights/assert-absent check). WEAK when the area is plausibly green at the start and only the baseline is missing; BLOCKER when there is concrete reason the area's existing tests are already red (every work task then mis-fails), or when a present baseline is whole-suite-scoped or is a lingering no-op ROOT task. (Catalogue → "Baseline-green / start-from-green (preflight)";stacks/dotnet.md §21. plan-breakdown Step 5 adds the matching insertion rule.)
- (a) Targets only the PRE-EXISTING tests via
- Coverage gap: the action's stated completion criteria exceed what guardrails verify — name the unverified criterion. (E.g. action says "sorted by category"; no guardrail checks sorting.)
- Stale coverage check (#157): the inverse of the coverage gap — here a
covers-key-behaviorsguardrail requires MORE than the action prompt asks for, so a CORRECT implementation following the prompt can never satisfy it. For everycovers-key-behaviorsguardrail (oneif ($content -match "<token>")/-notmatch … exit 1per behavior, or a$hits -lt Nthreshold), verify each required token is named — directly or via an obvious synonym — somewhere in the SAME task's action prompt. A token the guardrail'smatchrequires but the prompt's scenario list does NOT mention → BLOCKER with the message: "guardrail requires<token>but action prompt does not mention it — the task will fail every attempt." (Mechanism: the implementation follows the prompt, the guardrail keeps demanding the removed token, every attempt gets contradictory "need<token>" retry feedback and the task dead-ends atneedsHuman.) This is the human-judgement complement to the deterministic GR2026 warningguardrails validatealready emits (SSOT §4.4): the lint is a conservative keyword-presence heuristic (it stays silent on a synonym or a regex-shaped token); the reviewer resolves the cases the lint can't — confirm a flagged token really is stale (the prompt dropped the scenario) vs named only via a synonym (a false positive to clear), and catch a stale token the lint skipped because it was regex-shaped. Cross-checkvalidate's GR2026 output against this pass; don't merely re-report it. - Tests gameable: implementation tasks whose tests can be edited by the same
action — the implementation task's
writeScopemust EXCLUDE the test files its upstream test-author task owns (the deterministic write-scope test-exclusion, SSOT §3.4), so an edit to a test file fails the harness's read-only write-scope check. An implementation task with nowriteScope, or one whose scope covers the test files, is gameable. Inserted test tasks missing the TDD "red" guardrail for their type (#155): a BEHAVIORAL-type test-author task missing thebuild-passes+tests-fail-on-stubspair (a lone non-zero-exit red passes on a non-compiling garbage test file — BLOCKER); a data-model task split without a structural[Fact]/[Theory]covers-key-behaviors check.- The task authors BOTH its tests AND the implementation those tests exercise (#521) — the case the
rule above is vacuous on, which is why it needs asking separately. That rule says the
implementation task's
writeScopemust exclude the test files its upstream test-author task owns; where one task does both there IS no upstream test-author task, nothing to exclude, and the rule passes while checking nothing. Ask it of every task, not only the ones that look TDD-shaped: does this task write the test and also the code that test drives? If yes it has (a) no TDD-red half — with no red side to census against, its census can only be FORWARD (each pinned test observed-ne 'Passed'→ fail, over the runner's own result file), and a forward census cannot see a hollow body, because a hollow body passes; and (b) no write-scope test-protection gate, since there is no upstream owner to protect the file from. The strongest anti-tautology proof this skill has (#155's red-then-green) is therefore absent entirely rather than weakened, which is exactly what makes it invisible to a structural read. Measured, and it survivedguardrails validate,guardrails graph --checkand an entire structural review pass: a composition-root wiring task authored its own tests and its own implementation; a test file carrying all five pinned method names — fourAssert.True(true)bodies and one real call — exited 0. The one real call proved nothing either: the production method returns early for the fixture's shape, so it passed against a completely unwired implementation. This is the #120 built-but-unwired false green arriving through a door neither the #120 probe nor the write-scope rule is watching. Severity: BLOCKER when the task is a composition-root / production path; WEAK on its own, rising to BLOCKER wherever the only compensating control is a source-shape grep Probe B can game (#521). The fix is the SPLIT — anauthor-teststask upstream of animplementtask, which restores both halves at once (plan-breakdown Step 5 carries the insertion rule and the report's named-exception form; do not restate it here, cite it). It is never a tighter source-shape regex over the test body: reaching for the regex is the #468 archetype error — the finding is the archetype, not the clause — and §2b says in three lines why a rejection-shaped one is worse than absent (#375). One interaction to name so the fix is not over-applied. After the split, the red census may legitimately need to EXEMPT one test: the discriminator a correct implementation leaves green. In the measured case that is "a sound input does NOT halt", which passes against the unwired code precisely because of the early return — so demanding it beFailedon the stub tree would red a correct plan. A declared exemption carrying its structural reason in the script header is correct and is not a finding; a manifest row silently dropped is the finding. Grade the declaration, not the intent — A₂'s rule (§2b), applied to a census row.
- The task authors BOTH its tests AND the implementation those tests exercise (#521) — the case the
rule above is vacuous on, which is why it needs asking separately. That rule says the
implementation task's
- Missing scope-boundary warning (#154): for any test-author task (
author-tests-*/ a task whose deliverable is a test file), check thataction.prompt.mdcontains an explicit harness-enforcement paragraph — it must name the allowed path(s) (test file AND, under #155, any stub file thewriteScopecovers), the post-actiongit diffmembership check, the retry consequence of an out-of-scope edit, and the{"needsHuman": …}redirect for an upstream missing-symbol compile error. Absence is a WEAK finding — the harness injectswriteScopeat run time, but without the consequence the agent may still drift on a compile error and fix a neighbouring file (an out-of-scope edit that burns a retry). Fix: add the Scope boundary paragraph (plan-breakdown Step 6 has the verbatim shape). - Missing
.claude/needsHarnessWriteinstruction (#313): for any PROMPT task whose primary deliverable is a file under.claude/(.claude/skills/,.claude/commands/,.claude/hooks/,.claude/agents/,.claude/contexts/— NEW or EXISTING file), check thataction.prompt.mdcarries theneedsHarnessWriteescape-hatch instruction — and that it is the STRAIGHT-TO-HATCH form: the agent is told to emit{"needsHarnessWrite": …}to the state-out path FIRST, WITHOUT a directWrite/Editprobe to the.claude/path (plan-breakdown Step 5b has the verbatim shape; the older reactive "if a direct write is refused, then emit …" phrasing is stale — a probe wastes a turn and, per #321, populates the permission-wall tracker). A Claude Code subprocess CANNOT write under.claude/— the tool-permission layer refuses it unconditionally (SSOT §9.3; the old.claude/settings.jsongrant is dead per #273), so a prompt that writes the file directly hits the wall on attempt 1 and the task dead-ends atneeds-humanbefore any guardrail runs. Absence is a BLOCKER — unlike the #154 scope-boundary paragraph (WEAK, a risk of drift), this is a certain dead-end: the wall is structural and deterministic, so the task as authored cannot complete autonomously. This is the doctrine gap that let the originaldfd-threagilebreakdown pass review and then hit the wall at run time. Fix: inject the verbatim straight-to-hatchneedsHarnessWriteheader (Step 5b). Exemptions (not a finding): a SCRIPT action writing.claude/(the harness runs it directly, off the tool-permission layer), and a task that declaresstagingOutputsfor its.claude/deliverable (it writes a staging path, not.claude/directly — SSOT §3.5). Carve-out (#321) — a DIFFERENT finding: a task whose primary deliverable IS a permission-granting settings file (.claude/settings.json/.claude/settings.local.json) cannot useneedsHarnessWriteat all — the harness REJECTS writing those on an agent's behalf (a human must author them). Do NOT flag it for a missing header; flag it as needing a human author for that deliverable. - Unactionable failures: guardrails that fail without printing a usable reason (retry feedback quality).
- Failure detail lost to the tail (#179): for every guardrail that asserts a test suite
PASSES (a
tests-pass/all-tests-pass/specific-tests-pass, or a test driving a production seam), check it re-emits the failure DETAIL at the END of stdout. The harness feeds back only the tail of a failed guardrail's stdout (last ~60 lines / 4000 chars); defaultdotnet testprints each failure's assertion/exception text mid-run and ends with only[FAIL] <name>+ a count. A baredotnet test … ; if ($LASTEXITCODE -ne 0) { Write-Output "…"; exit 1 }therefore tails out the test NAMES only — the next attempt sees WHAT failed, not WHY, and retries blind (plan-0009 burned 12 attempts toneedsHuman). Tell: no re-emit of the failure BLOCK after thedotnet testcall. Fix: the capture → emit-full-log → re-emit-at-the-end pattern (catalogue → "Failure detail must reach the retry tail";stacks/dotnet.md §4.2). WEAK (the run still passes/fails correctly; it degrades retry feedback, costing attempts). A re-emit that IS present but allowlist-shaped — aSelect-StringorWhere-Objectover[FAIL]/Error Message:/Assert./Expected:/Actual:/Stack Trace:— is the weaker legacy form and is worth its own WEAK note: measured, it drops aDoesNotContainfailure'sString:/Found:payload and every stack frame, and a hand-copied variant missing theAssert./Exceptionbranches also drops the assertion headline and a thrown test's only detail line, soError Message:tails out followed by nothing (#608). Fix by switching to the block capture rather than by adding another branch to the alternation. Do NOT flag the INVERSEtests-fail-on-stubs/tests-fail-on-current-codechecks — a non-zero exit is their success, so there is no failure detail to feed back. Second tell — a QUIET flag on the test command (-v q/-v quietondotnet test) defeats the rule even when the re-emit is present: measured,-v qsuppresses the wholeError Message:/Expected:/Actual:/Stack Trace:block and leaves only[FAIL] <name>, so theSelect-Stringre-emits test NAMES and nothing else. Flag it WEAK (BLOCKER where the plan's own doctrine leans on the re-emit for a hard-to-diagnose task); fix by dropping the flag from the test command — quiet belongs ondotnet build, notdotnet test. - Grep-scope contamination: a file-content guardrail that greps the project tree
(
Get-ChildItem -Recurse | Select-String) instead of the one file the task owns — a same-wave sibling sharing the term can satisfy it. (Catalogue anti-pattern.) - Keyword-not-structural: an "implements/extends/declares" check matching a bare
type name (
Select-String "IFoo") that a comment,using, or local copy satisfies — it should match the declaration construct (stack file's structural regex). Also flag an accessor-order-sensitive structural regex (#112): a property "declared/removed" check keyed on a fixed leading accessor —\{\s*getor\{\s*set(e.g.public\s+\S+\s+NAME\s*\{\s*get) — is itself a finding. C# accessor order is free ({ get; init; }≡{ init; get; }), so it false-passes a removal check when the field survives as{ init; get; }(an incomplete refactor ships green) and false-fails a declared check symmetrically. Fix: match up to the brace (public\s+TYPE\s+NAME\s*\{), order-insensitive; if accessor presence matters, test(get|set|init)anywhere inside the block. (Catalogue → member-order insensitivity;stacks/dotnet.md §3.1.) BLOCKER on a removal check — a lingering field reads as gone. - Comment-blind forbidden-keyword scan (#97, #98): a guardrail that scans a source file
for banned constructs (read-only
MERGE/EXEC/xp_cmdshell, no-shell, no-eval, no-console.log) by matching the raw file including comments —Get-Content $f -Rawthen a banned-keyword-matchwith no comment-stripping. It false-POSITIVES on a comment, a string literal, or disabled code that names the banned thing. The poison case to hunt: the same task both (a) tells the action to write a safety-header comment naming the banned constructs AND (b) greps for them without stripping comments — a guaranteed false positive that whack-a-moles a CORRECT read-only artifact toneeds-human(each retry strips one mention, exposes the next). Tell: aGet-Content -Rawkeyword check on a source file with no/* */+--(or//) strip upstream of the match. Fix: strip the source language's comments before matching (blank-in-place for line-number-reporting checks); and don't pair a header-documenting prompt with a comment-blind grep. Neutralize string literals BEFORE stripping comments (#561) — stripping comments is not the whole of the preparation: a/*spelled inside a string literal opens a phantom block comment running to the next*/in a later literal, blanking everything between, which fails both closed (a required-present clause over the blanked region false-REDs) and open (a forbidden-present clause over it false-PASSES). Measured: 29 of the 31 committed guardrails that do both operations do them in the defective order. BLOCKER — a correct implementation fails permanently. (Catalogue → comment-blind keyword scan;stacks/dotnet.md §11.) - Rendered-vs-stored phrase match (#428): a guardrail clause matches a phrase as it reads
rather than as it is stored — the rendered form is not the stored form, and when the target text
is emitted across two or more source-line literals (wrapped
AppendLinecalls composing prompt or feedback prose, a concatenated message) a single-line regex for the whole sentence can never match. The guardrail then silently passes — the expensive direction: a false-RED halts a correct run and is fixed in minutes, but a false-PASS certifies work that was never done. Tell: a-match/Select-Stringliteral carrying a long, space-separated phrase, over a source file that composes text rather than storing it whole. Fix: prefer a distinctive fragment that sits on ONE source line; normalize whitespace or use[\s\S]when the whole phrase matters; and verify the fragment against the real file, never against the rendered text. Live instance:RetryPolicy.cscomposes its retry-feedback prose acrossAppendLinecalls split by a six-line comment and anifboundary — about 400 characters, bisected mid-phrase — so neither a single-line regex nor a bounded dotall window can match it. Recorded instances: four, most recently62c59db3. No mechanical gate carries this (design 38 §6 — the expressible lint is heuristic in both directions); this probe is #428's only enforcement, so treat a hit as a BLOCKER on the reviewed task. (Catalogue → rendered vs. stored / phrase-across-literals, sibling to grep-scope contamination and structural-vs-keyword.) - Hollow / incomplete derived corpus (#99): a task whose deliverable is derived artifacts
over a set of inputs (doc mining, codegen-from-spec, crawl→one-output-per-page, dataset import)
whose guardrails verify only shape —
file-exists+ a marker line — so a green run ships an empty or partial corpus (worse than a hard failure: it looks done). Three tells: a one-line stub passes a marker check (F1); an index naming only 1 of N outputs "resolves" (F2); a crawl capturing 2 of N pages passes because the checks verify "what I listed exists," never "I listed enough" (F3 — look for guardrails iterating the outputs rather than the inputs). Fix: require the four completeness/substance guardrails — input→output coverage, per-output substance floor (anti-stub), index completeness (produced ⊆ indexed), ingestion lower bound. Name them as lower bounds, not faithfulness checks (the semantic residual is a human pass or a demotion-gated judge — never a judge alone). BLOCKER — a green run ships a hollow/partial corpus. (Catalogue → corpus / aggregation completeness.) - Terminal-postcondition at integration scope (#125): a
scope:"integration"guardrail that asserts a terminal postcondition — "the final combined output exists", "the sink wrote its aggregate", "all N contributors present" — instead of a union-safe invariant. Per SSOT §4.3 the integration set re-runs at every union point (every fan-in / non-FF integration, §5.3 case B), on partial merges where downstream tasks have not run yet — so a terminal postcondition spuriously fails at an intermediate union and escalates a healthy partial merge toneeds-human(surfaced live byparallel-hello). Decision test per integration guardrail: "would this pass on a partial merge with a downstream task unsettled?" Evaluate that test against every union point that can occur anywhere in the plan before the guardrail's own task has run — not only unions structurally upstream of that task in the DAG.scope:"integration"re-verifies at every fan-in plan-wide (SSOT §4.3, "no per-task or per-colliding-sibling guardrail selection at a union"), so a merge by a completely unrelated parallel sibling counts just as much as one that feeds the guardrail's own ancestor chain. "Does a union feed into MY task's ancestors?" is the too-narrow version of this question, and it will miss exactly that case — two siblings with zero dependency on the guardrail's task, each merging back onto the plan branch before that task has even started (#250: this is precisely what happened to a composition-root wiring guardrail live in review — see the catalogue's composition-root section for the matching gotcha). If no, it is a terminal postcondition wearing an integration scope. Fix: keep the integration gate to an invariant true of any valid intermediate union ("any produced file present is non-empty + conflict-marker-free"); move the terminal assertion to alocalguardrail on the sink (runs in-attempt on the sink's segment). BLOCKER on a parallel plan with unions — it spuriously red-halts a correct run. (Catalogue → union-safe integration section; SSOT §4.3/§5.3.) - Overlapping writeScopes with no integration union-guardrail (#132): when two or more tasks
have OVERLAPPING
writeScopes on a shared file/path (colliding siblings that can both write the same file — AI-merge territory at the union), verify at least onescope:"integration"guardrail (on the integration / fan-in task) asserts the UNION invariant on that shared file. The v1 union re-verify runs the integration set ONLY (SSOT §4.3) — it does NOT re-run a colliding sibling's per-attemptlocalguardrails (running them at the union false-fails: fragment-readers checkingGUARDRAILS_STATE_FRAGMENT, anti-tautologytests-fail-on-current-code, not-yet-run tasks). So a hunk an AI-merge silently DROPS on the shared file is re-verified at the union only by an integration-scoped guardrail; a drop catchable solely by a sibling'slocalguardrail is NOT re-verified there (it surfaces at the terminal gate, or not at all). If noscope:"integration"guardrail asserts the shared-file union invariant → emit a finding WEAK: recommend adding one (as the texttools showcase does withcomponents-union-verified— assert the merged shared file still holds every sibling's contribution, union-safe per #125). This is an authoring nudge, not a harness bug: the integration-set-only union re-verify is an accepted v1 design (#132). (Catalogue → overlapping-writeScope union-guardrail; SSOT §4.3 "Accepted residual".)- Duplicate-definition sub-check on a shared CODE file (#175): tighten the above when the shared
overlapping-
writeScopefile is a CODE file and both colliding tasks could ADD a type/member DEFINITION to it (each writes aclass/record/interface/enum/method the other doesn't). A 3-way / AI-merge of two branches that each appended the SAME new definition to different regions of the file produces no textual conflict marker — git keeps both copies — so a conflict-marker check passes while the merged file holds a duplicate definition (the CS0101 that red-halted plan-0009's terminal gate, #175). Require thescope:"integration"union-guardrail to carry a duplicate-definition count check for each definition both siblings could add — count occurrences and fail when >1 ([regex]::Matches($content,'class\s+<Name>').Count -gt 1in .NET), naming the AI-merge duplicate. Keep it union-safe/conditional (#165) — run it only inside the existing file-present gate, so it passes trivially at a union where the file hasn't landed. A conflict-marker / contribution-present union-guardrail with no duplicate-definition count on a shared code file two tasks both define into → WEAK (the silent semantic-duplicate residual the harness can only attribute at the gate, not prevent, SSOT §3.3). (Catalogue → overlapping-writeScope union-guardrail;stacks/dotnet.md §19; SSOT §3.3 / §4.3 "Accepted residual".)
- Duplicate-definition sub-check on a shared CODE file (#175): tighten the above when the shared
overlapping-
- Union guardrail ancestor staleness (#159): for every
scope:"integration"union guardrail on a fan-in / integration task, identify each expected-contribution token (the string itmatch/notmatch-checks for in the shared file), and for each token identify which task(s) would produce it (the task whose action /writeScopewrites that marker). Then verify every producing task is in the ancestor set of the integration task — there is a directed path producer → fan-in in the DAG. If a producing task is NOT an ancestor — a disconnected leaf or a side branch with no path to the fan-in — flag it WEAK: "Union guardrail checks for<token>contributed by task<N>, but task<N>is not an ancestor of the integration task. If task<N>is later removed, this guardrail will fail spuriously. Either add a DAG edge (<N>→ fan-in task) to make the dependency explicit, or remove the<token>check from the union guardrail." The trap is silent: a disconnected producer still runs (the harness executes every task), so the guardrail passes today — but the integration gate now implicitly requires a task no edge declares it depends on, and the day that task is deferred/removed the gate red-halts with a confusing "shared file is missing<token>" that reads as a merge failure but is a stale guardrail. This is the run-time-fragility analogue of the #132 nudge above — there the residual is a dropped hunk on a shared file; here it is a contribution check whose producer fell out of the ancestor set. (Relates to #132/#125; the plan-breakdown side adds the matching rule on dependency-edge removal, Step 4.) - Unregistered module: a task adds a module/project to a build descriptor (
.csproj→.slnx) but no guardrail checks the DESCRIPTOR names it — a descriptor build passes with the project unregistered. (Stack file → build-descriptor registration.) - Unreferenced abstraction: a task creates an abstraction a later task must consume,
but no guardrail checks the consumer's project file has a
<ProjectReference>— builds pass independently, so a local copy of the interface slips through. (Stack file → cross-module reference.) - Built-but-unwired component (#120 — the recurring lesson): the plan adds an
IFoo/FooImplpair (or any collaborator a production assembler must construct + inject), the component tasks build + unit-test it through an injected constructor seam — but no task constructsFooImpland injects it at the production composition root (factory /Program.cs/ DI /RunCommand), and no guardrail drives the REAL assembler with the new mode active. Every check is green while the feature is inert (reachable only from xUnit, which injects the seam itself); the terminal whole-suite gate does NOT cover this. Also flag the inverse: a wiring guardrail that constructs + injectsFooImplitself then asserts it works — it proves the component, never the wiring; the guardrail must go through the production assembler (drive the real factory + assert observable output, or reflect on the constructed object for the non-null collaborator with a contrast case — theFactory_Wires*shape). Missing wiring task OR a seam-injecting guardrail OR reliance on whole-suite green to cover wiring = BLOCKER. (Catalogue → composition-root section,stacks/dotnet.md §10.) The inverse flag has one carve-out, and it is the one you will meet (D12): a #382 real-seam test is NOT this finding. Same verb, different SLOT — #120 forbids hand-injecting into the assembler's slot; #382 requires hand-injecting the real seam into the component-under-test's own constructor. The tell is what the test calls: a composition-root guardrail drivesSchedulerFactory.Create, a real-seam test never does. See the D12 note in the passing-but-blind probe below before flagging. Passing-but-blind faked seam (#382) — audit the SEAM LEDGER, then re-derive it: the review question is what real path does this fake stand in for, and who proves that path? The breakdown's answer is the seam ledger — the six-column table the Step 7.4 report prints under a bolded
Seam ledger (#382)line, one row per in-process seam the tests substitute (plan-breakdown Step 4 rule 6 is its format contract; the catalogue's "drive-the-real-seam" section is the guardrail's shape). A component certified green solely against a fake of the seam the run exercises is a green light over a broken wire — theCriticalityJudgeescalated 100% of the time through the realClaudePromptRunner; the executor's realTransientBackoffnever recordedblocker-retried; both green on fakes, in the same wave. This probe is the only gate on any of it. #382 ships novalidatelint by design — the substitution lives in a test file the run has not written yet, so there is nothing for a lint to read — which means a row that is missing, mis-bucketed or mis-placed is caught here or not at all. Work the checks in order; every one of them is decidable from the folder, on paper, without running the plan.0. Obtain the ledger — and key the absence finding on the missing HEADING, never a missing table. The heading is emitted UNCONDITIONALLY: a plan that fakes nothing prints the bolded line plus
_No in-process seam is substituted by this breakdown's tests._and no table. That zero-row form is a claim, not an absence — checks 6 and 7 still apply to it (1–5 are simply vacuous with no rows), and check 7 is the one that falsifies a false claim. An absent heading is a different animal: evidence the Step 4 analysis never ran, so no seam in this plan has been placed at all → BLOCKER, whose fix is to re-run the analysis, never to hand-write a table after the fact. If the report is not in this session, ask for it before concluding anything — "not produced to this pass" is an unchecked gap for the Step 6 report, NOT an absent heading, and reporting one as the other manufactures a BLOCKER out of a missing attachment. With no report at all, skip checks 1–5 — those read ledger cells — and still run 6 and 7, which read the folder and are where most of the value is anyway.1. Every
bucketcell is exactly one ofN1N2N3N4ECU. Blank, a bareN, prose, or anything off that list is a finding in its own right — the cell is parseable precisely so this check has a target, and an unparseable bucket makes checks 2–5 unrunnable. Same pass, same row: theproofcell is a path relative to the PLAN folder (tasks/<T*>/guardrails/NN-….ps1), so a path whose task segment disagrees with theT*cell is a self-inconsistent row — one of the two is wrong; say which you believe and why.production typeis—on anyN*row, andT*on anN*row readsexempt.2. REJECT an
Nclassification for anything off the four-item enumeration. N is a closed list — N1 a clock / time source, N2 a randomness source (an RNG, a GUID factory), N3 an ambient environment reader (env vars, machine name, current directory, an OS probe), N4 a wait primitive (a sleep / delay / timer). It is not a category and "it felt like non-determinism" is not an argument. A seam classified N that is not literally one of those four is E, C or U, it owes proof, and it takes the severity rubric below — an accepted N row is a permanently exempted seam, and nothing downstream will ever ask about it again.The N4 trap is the highest-yield row on the table: fake the WAIT, never the WAITER. If the substitute contains a DECISION, it is not N4. Substituting the sleep so a backoff test finishes in milliseconds is N4 and exempt. Substituting the policy object that decides whether to retry — and that owes a recorded
blocker-retrieddecision — is C, and it owes proof. Concretely:RetryLoop → IDelayis N4;RetryLoop → ITransientBackoffis C. Read the substitute's own surface, not its name: any branch, threshold, budget, classification or recorded decision inside the thing being faked disqualifies N4. This exact conflation shipped a silently-swallowed transient on a fully green wave — the class-(b) resolution that never recorded the decision its design required, because no test drove the executor's real backoff.3. Recompute T* for every E and C row from the DAG — do not accept the cell. T* is the earliest task at which BOTH the component's production type and the seam's production type exist, and a type exists at a task when that task's
writeScope(or an ancestor's) contains the file declaring it. So T* is computable by you, without running anything — that computability is the whole reason the rule could replace "where feasible", and skipping the recomputation gives the column back to the author who wrote it. A proof placed later than T* is a finding even when the proof exists and passes: it surfaces the bug in a task whosewriteScopecannot fix it, which is theneedsHumanthis doctrine exists to remove. The report owes a line naming T* and why the proof could not live there — an unnamed late placement is the finding; a named one is a decision you can argue with on its merits.4. An E row may NEVER invoke the construction bound (D11). The #120(b) reflection-plus-contrast degradation is available to bucket C only. What sits beneath an E seam is a process / network / disk boundary, and faking that is the one substitution this rule has always permitted — so constructing a real E adapter cannot force a second real level. "I could not construct it" on an E row is therefore a review finding, not a legitimate degradation: the answer is the real adapter over a stub binary, a fake
HttpMessageHandler, or a temp directory. This is the escape hatch an author reaches for first, so check it explicitly rather than reading past it. A C row that does degrade owes the constructor chain that forced it, named in the report; an unnamed degradation is a finding as well.5. U rows name a receiving TASK that exists, and the terminal sink is rarely it. A U row's proof is RELOCATED, not waived.
T*is a task folder name — under Step 9 waves, a receiving wave folder is legal when that wave is not broken down yet, and that is the only non-task name the column permits — andproofreadsdeferred to T*, named. A U row pointing at the terminal sink is legitimate only when the production type genuinely first exists there; otherwise the row is mis-placed and the finding is the placement, not the bucket. Check the named task actually exists in the DAG: a U row naming a folder nothing matches defers the proof to nowhere, which reads on the page like compliance.6. The terminal proof is a JOIN-CHECK — make it name a defect that SURVIVES the upstream proofs. For the #120 wiring task and for every
<plan>/guardrails/guardrail, read the# catches:and ask whether the defect it names could still occur with every upstream real-seam proof passing. "The factory never hands the judge to the scheduler" survives — that is assembly, and assembly is what the join-check owns. "This seam is exercised for the first time here" does not survive: it means a ledger row is mis-placed, and the fix is upstream, never a widerwriteScopehere. A join-check that can name no surviving defect is redundant — say so and propose deleting it, rather than leaving a gate that certifies nothing. Flag too the same row's proof emitted twice, once at T* and again in the sink: the duplicate is the concentration this rule exists to remove.7. Re-derive the ledger from the folder — it cannot report a fake nobody declared. This is the check that makes the others worth running, because a declaration-only audit has its floor at the honesty of the author it grades. Walk every
author-tests-*task'saction.prompt.mdand its paired implement task: wherever the prompt directs a fake / stub / mock / test double of an in-process collaborator the production run resolves (anIPromptRunner, the executor, the scheduler, a factory, a policy object), there must be a row. A substitution the tests make with no row is the shipped bug's own shape, and the ledger is silent on it by construction. Conversely, process seams are NOT rows — a child process, a CLI, a socket, an HTTP endpoint, a database, the filesystem — and flagging one is a false positive that teaches the next reader to skim the table, which costs more than the row was worth.Then audit the archetype's SHAPE wherever a proof does exist (the catalogue's FORBIDDEN list for "drive-the-real-seam" is what this mirrors): the proof is a test — rung 1, with no rung-3 source-grep form available, since a regex proving the test file mentions
new ClaudePromptRunner(certifies vocabulary and is satisfied by a commented-out line; it asserts an effect only the production implementation emits (the stream-log FILE appears on disk, the journal holds ablocker-retriedDECISION, the verdict'sSourceis not the catch-and-safe-default) — "the collaborator was called" is not an assertion, and a recording double / call count /Verifyis the passing-but-blind shape wearing a real-seam name; it isscope: "local"with the key omitted, because "this component works through the real seam" cannot be true before its own task's action has run — tagging itscope: "integration"because "it drives the real thing" is the #250 mistake, measured live at two unrelated parallel siblings rolled back; and its RED half is real (#155 — the red must COMPILE and fail, so the test-author task also writes whatever stub the real-seam test needs to compile). Probe B operator 20 (§2b) is the mechanical half of this audit and reading is the weak half: a test that satisfies a…RealSeam…filter while constructing the fake is textually indistinguishable from the real thing at this altitude.Do NOT flag a correct real-seam test as a #120 violation (D12). The #120 probe above forbids a guardrail that constructs
FooImplitself and injects it; this probe requires exactly that verb — in a different slot. #120 forbids injecting the collaborator into the assembler's slot, which bypasses the production assembler so the wiring is never proven. #382 requires injecting the real seam into the component-under-test's own constructor, which proves the component through its collaborator and claims nothing about the assembler. Operationally: a real-seam test never callsSchedulerFactory.Create; a composition-root test never hand-injects; if one test does both, it is two tests, and that is the finding. Flagging the mandated shape as the forbidden one is a false BLOCKER against the doctrine's own output — the most expensive mistake this probe can make, because it tells an author to delete the proof.Severity — one rubric for every finding that leaves a SEAM UNPROVEN (checks 2–5 and 7): BLOCKER when the un-proven seam is a composition-root / production path; WEAK when a thin terminal join-check exists but the per-component real-seam proof is missing (the proof is deferred to one sink, not absent). Name the concrete seam and the task that should carry the proof — T*, computed, not the terminal sink, which re-creates the #378 over-scope. Two findings sit OUTSIDE that rubric and must not be inflated to fit it: a check-1 malformed or self-inconsistent row takes the severity of what it conceals — WEAK while the intended row is still readable, BLOCKER when the bucket cannot be determined at all (an undeterminable bucket is an unaudited seam); and a check-6 redundant join-check is WEAK (it certifies nothing, but it also blocks nothing) unless the only defect it can name is "first exercise here", which is a mis-placed row and takes the rubric above. Shares a root with the Over-scoped-task probe (§3): that sink is over-scoped because it concentrates this deferred proof. (Catalogue → "drive-the-real-seam";
stacks/dotnet.md §10e.)The #378 boundary — inherit this rule, do not renegotiate it. #378 owns the size and shape of a task: it reads
writeScopecardinality,action.maxTurnsanddependsOnfan-in, its mechanism is GR2042, and its verdict is "this task is too big." #382 owns the placement of proof: it reads which seam a test substitutes and where the real-seam proof lives, its mechanism is the ledger plus the archetype audited here, and its verdict is "this proof is in the wrong task." Therefore — #382 NEVER derives a SIZE verdict fromwriteScope,action.maxTurnsordependsOn— and #378 NEVER adds a rule about what a guardrail PROVES. The boundary is about which VERDICT a check derives, not which FIELD it reads (doc 18 §6, corrected 2026-08-20: the field-exclusivity form was already false — GR2041MissingWriteScopereadswriteScopeand is not GR2042). So readingwriteScopeas a lookup (check 3: where is this type declared?) or as a coverage set (does any task claim this path?, §4's missing-insertion check and the Unreachable-outcome probe) is allowed and always was; what neither may do is rule on how BIG a task is, suggest narrowing a scope for size, or readaction.maxTurns/dependsOnfan-in as size evidence. When both fire on one task, report both, each from its own evidence; never let one stand in for the other, and never grow a third half-overlapping check in the gap between them. Where they meet: told "this task is over-scoped", the reflex is to chop thewriteScope, which for a fan-in sink yields N small tasks that still contain the first exercise of every real path — the concentration survives the split. Relocating the proof to T* is the fix; narrowingwriteScopealone is not.- Wrong-implementation swap (#158): the next failure past #120 — given the dispatch IS wired,
is the right concrete type paired with the right mode? For a dispatch / wiring task that routes
≥2 enum (or discriminated) values to ≥2 concrete types AND whose dispatch tests use
seam-injection (
RecordingImporter/FakeHandlerpatterns that replace the real impl via DI and assert only that an importer was called), verify a per-pairing proximity check exists — one guardrail per pairing asserting<EnumValue>sits within a bounded window ([\s\S]{0,300}, multiline-dotall, both orders) of<ConcreteType>in the dispatch file. The swap to hunt: an agent routes Mode B → the wrong importer and Mode C → the other; the build passes (either type satisfies the interface in either branch), the seam-injected dispatch tests pass (they never check which concrete type was registered), and a bare keyword check that all enum values AND all type names appear somewhere passes too (all present regardless of pairing) — the feature ships inverted on a fully green suite. Flag WEAK if the per-pairing check is missing; BLOCKER if the only concrete check istests-passwith seam-injection tests (nothing binds enum to type, so a swap is fully invisible). Do NOT flag when the dispatch tests already assert the concrete TYPE NAME (Assert.IsType<TcApiLocalImporter>on the resolved object) — the test catches the swap and the proximity check is redundant (the catalogue's decision gate). Distinct from #120 (built-but-unwired): there nothing wires the impl at all; here it is wired but possibly to the wrong mode. (Catalogue → "Dispatch / factory wiring";stacks/dotnet.md §10d; relates to #120.) - Vacuous
writeScope: a task declareswriteScope: ["**"], a bare top-level dir, or any over-broad surface that owns everything — the write-scope check (SSOT §3.4) then discriminates nothing and is theater (validatewarns GR2020). Flag every**/over-broad scope as WEAK and propose a real surface (the specific directories/files it writes) — or, if the task genuinely writes NOTHING to the repo,"writeScope": []. Do NOT propose omitting the field: since #389, omission is a GR2041 error, so "omit it" is never the fix ([]is). - Tests not excluded from an implementation scope: an implementation task with an
upstream test-author task whose own
writeScopecovers (or fails to exclude) those test files — the deterministic "implementation may not write the tests" boundary is open, so the implementation can edit the tests to force a tests-pass guardrail green. The implementation task'swriteScopemust EXCLUDE every test file the test-author task owns. (BLOCKER — it is the TDD test-protection gate.) - ABSENT
writeScope— always a BLOCKER (#389):writeScopeis now REQUIRED on every task, so a task that OMITS the field entirely is a BLOCKER (and a hardvalidateerror, GR2041) — drop the old "genuinely repo-wide ⇒ omission is OK" exemption entirely: a terminal whole-suite gate or a sweeping cross-cutting change must declare its broad surface EXPLICITLY (name the directories), never omit. An absent scope gets NO write-scope check, so an out-of-scope escape (including an implementation editing the tests) goes uncaught. Fix: name the real surface, or"writeScope": []if the task writes nothing to the repo. CRITICAL —writeScope: []is a FIRST-CLASS VALID declaration, NOT a finding. An empty scope is the correct, deliberate "writes nothing to the repo" form for a configure-a-database task, a verification/read-only check, or a state-only task (its only output is aGUARDRAILS_STATE_OUTfragment, which is not a repo write). Do NOT flag[]— it is not "missing" and not "vacuous"; flag ONLY a TRULY ABSENT field. (Sanity-check that a[]-declaring task genuinely writes nothing — a task that DOES write to the repo but declares[]will fail its own write-scope check at run time, which is a different, correctly-caught error.) - Four-folder gap — missing/empty/tautological plan-level or task-level folder (deliverable 9):
the terminal integration-gate TASK (
integrationGate: true) is RETIRED — a plan still declaring it gets a hard validation error (GR2029), no coexistence window. The replacement is four first-class folders at fixed locations (SSOT §1/§3.3): plan-level<plan>/preflights/("Full Flight Checks", evaluated once BEFORE the DAG against the starting repo) and<plan>/guardrails/("Terminal Gate", evaluated once on the merged HEAD AFTER the DAG drains green) — both siblings oftasks/,guardrails.json,state/at the plan root — plus task-leveltasks/<id>/preflights/(JIT dependency-delivery, a sibling of the existingtasks/<id>/guardrails/, evaluated per task BEFORE its attempt loop). Probe each folder the plan's shape requires and treat a required-but-missing folder/check as a BLOCKER:- Missing or empty terminal folder on a multi-leaf/fan-in plan —
<plan>/guardrails/absent, or present with zero guardrail files, on a plan with ≥2 leaf tasks or any fan-in task → BLOCKER.validatealready enforces this in worktree mode (GR2028); call it out with the concrete leaf/fan-in shape that triggers the obligation. - Tautological terminal folder (the re-homed GR2018 obligation) —
<plan>/guardrails/present and non-empty but every file is a no-op (exit 0, a bareecho, a comment that only NAMES a build command, a prompt-judge with nothing to verify) rather than ≥1 real integration-set re-run — a genuine whole-repo build/test/suite invocation (dotnet test,dotnet build,npm test,pytest,cargo test, …) or a union invariant → BLOCKER. A folder that merely EXISTS or merely contains a file certifies nothing; GR2018's content teeth survive the move from task to folder — "non-empty" is not the bar, "re-runs the integration set" is. - A lingering
integrationGate: truetask — flag it and point the author at the<plan>/guardrails/folder replacement; do not accept a plan whose terminal check still depends on the retired sink kind. (The one narrow exception: a plan's own committed, documented bootstrap exemption for a harness version that predates the loader — name it explicitly if the plan claims one, don't accept it silently.) - Missing plan-level preflight on a brownfield plan — the existing-tests-green positive
baseline now lives as a
<plan>/preflights/positive check (not a no-op ROOT task); its absence on a brownfield plan is the same WEAK→BLOCKER call as the baseline probe above (§2), just relocated to the folder. - Missing task-level preflight where a
dependsOnedge delivers a JIT dependency — a consumer task that depends on a producer for a type/route/symbol/artifact it needs inside its OWN segment worktree attaskBase, with notasks/<id>/preflights/check confirming the producer's contribution actually landed before the attempt loop spends a turn building against possibly-absent bytes → WEAK (flag BLOCKER when the delivery is genuinely uncertain — e.g. the producer is a same-wave sibling rather than a settled ancestor). scope: "integration"itself is UNCHANGED — it remains the per-union tag driving the §4.3 per-union re-verify; only the terminal-sink task is retired. Do not flag ascope: "integration"guardrail elsewhere in the DAG as if it were the retired mechanism.
- Missing or empty terminal folder on a multi-leaf/fan-in plan —
- Live-probe used where a flake-free check would do — ADVISORY WARN, never a BLOCK (deliverable
9): a check placed in ANY of the four folders that reaches outside the committed bytes under
review — a network call, a polling loop, a spawned daemon/live service, anything whose outcome
depends on more than the repo's own build/test tooling — trades determinism for flake risk.
This is authoring guidance the review emits as a WARN, never a BLOCKER; the harness itself
enforces NOTHING here —
guardrails validate/runneither warns nor blocks on a live probe — so do not escalate this past a WARN no matter how bad the probe looks.- Plan-level (
<plan>/preflights//<plan>/guardrails/): a fulldotnet test/dotnet buildover the committed bytes (the starting repo for preflights, the merged HEAD for guardrails) is FINE — that IS the canonical Full Flight Check / Terminal Gate shape, not a live probe. WARN only on a network/poll/daemon/live-service call there — a flake halts the entire run (plan-level has the maximal blast radius). - Task-level (
tasks/<id>/preflights/, andtasks/<id>/guardrails/by the same logic): prefer a byte/exit check (file exists, grep, a build/test scoped to the task's segment); WARN on a network/poll probe here too — smaller blast radius than plan-level (blocks one cone, not the whole run) but still a flake risk this early in the attempt loop. - The property under review is FLAKE-FREEDOM, not process-count — a
dotnet testis a process start and stays fine; the WARN targets non-repeatable outcomes (network, timing, external services), not process spawning itself.
- Plan-level (
The three probes immediately below are SUPERSEDED by the four-folder model above — they describe the RETIRED
integrationGate: truetask mechanism (now a hard validation error, GR2029) and apply only when reviewing a pre-migration plan or a named bootstrap exemption. For a plan authored under the four-folder model, use the terminal-folder probe above instead of the "exactly oneintegrationGate: truetask" framing below.scope: "integration"itself did NOT change — only the terminal-sink TASK kind was retired.
- Integration gate missing or empty: in a plan with ≥2 leaf tasks or any fan-in, confirm
exactly one task declares
integrationGate: true(the terminal whole-repo sink, SSOT §3.3) and that sink carries at least onescope: "integration"guardrail — an empty gate verifies nothing. Zero gates on a multi-leaf/fan-in plan, two-or-more gates, or a gate with no integration-scoped guardrail is a BLOCKER (validateenforces GR2017/GR2018, but call it out with the missing/empty sink named). - Full build / whole suite marked
scope: "integration"on the terminal gate (#165 — BLOCKER): a whole-repo build (dotnet build <solution>) or full test suite (dotnet testwith no filter) guardrail on the terminal integration gate that declaresscope: "integration"is the #125 terminal-postcondition anti-pattern. The integration set re-runs at EVERY union point (SSOT §4.3), and a full build/suite is a terminal postcondition, not a union-safe invariant: at an intermediate union in a TDD plan the merged bytes contain test files referencing types whose implementation task has not run yet, so the build/suite FAILS there and the harness rolls the whole wave back — even though every per-task guardrail passed (decision test: "would this pass on a partial merge with a downstream task unsettled?" — a full build/suite answers no). Flag it BLOCKER (it red-halts correct intermediate unions). Fix: drop thescopekey (make the full build/suite LOCAL — it then runs only at the terminal gate's own attempt, the correct moment), and ensure the gate still carries a separatescope: "integration"union-safe guardrail to satisfy GR2018 (next check). (Catalogue → "Ascope:"integration"guardrail MUST be UNION-SAFE"; SSOT §4.3/§5.3.) - Terminal gate's integration-scoped guardrail not union-safe / missing (#165, GR2018 — BLOCKER):
the gate sink must carry ≥1
scope: "integration"guardrail (GR2018), and that guardrail must be a union-safe CONDITIONAL invariant — conflict-marker-free / non-empty, or "IF contribution X is present, verify it's real" (gate-then-verify), so it passes trivially before a contributing task has run. The full build/suite does NOT qualify (previous check). If the gate's ONLY integration-scoped guardrail is the build/suite, or its union guardrail is written unconditionally (if ($content -notmatch "<token>") { exit 1 }— requires a contribution that a partial merge may not hold yet), flag BLOCKER: it either leaves the gate with no real union coverage or red-halts a healthy partial merge. Fix: author a conditional union invariant (theparallel-hello01-whole-repo-greetingtemplate; the overlapping-writeScope union-guardrail, #132). (Catalogue → union-safe CONDITIONAL form; SSOT §4.3.) - Over-scoped task (#111 — is this too coarse to land in one session / retry cheaply?): a task
trips the plan-breakdown Step 2 split-trigger — (a) it bundles multiple distinct deliverables
("do X and Y and Z"); (b) it has a wide blast radius (deletes ≥3 source files, or
touches ≳10 files / test references in one action); (c) it maps 1:1 to a design milestone / phase;
or (d) a single failed-guardrail retry re-runs an hour of work (a multi-deletion, a 100+-ref
re-baseline). An over-scoped task thrashes at run time — every guardrail miss re-runs the whole
oversized action — and is the most likely
needs-humanin a run. Flag it WEAK (its retry is expensive; it is mis-sized) and propose the split: name the deliverables it bundles and the smaller tasks they should become, each with its test re-baseline scoped to that piece. This is the inverse of the missing-insertion check (§4): there a deliverable maps to NO task; here ONE task carries too many deliverables. Objective teeth — read the emitted JSON, don't judge the description (#378). The (a)–(d) triggers above are description-level and an author/reviewer can rationalize past them for the fan-in-sink / composition-root-wiring archetype ("it's just wiring"). So ALSO read the emittedtask.json:writeScopecardinality +action.maxTurns+dependsOnfan-in. Flag BLOCKER (a certain thrash, not a mere risk) on the co-occurring fingerprint —maxTurnsnear the ceiling ANDwriteScope≥ ~4, ORdependsOnfan-in ≥ ~5 with a multi-filewriteScope— naming the proposed split: one task per collaborator wiring (factory registration, scheduler call-site, CLI plumbing), with the turn-expensive composition-root proof (drive the REAL factory, #120) isolated to a thin sink. This is the same signalguardrails validateemits as a GR2042 WARN: cross-check it and RESOLVE it (propose the concrete split), don't merely re-report the warning. Distinct from the passing-but-blind probe (#382) below — that one shares this root (the sink is over-scoped because it concentrates deferred integration proof) but asks a different question (which real path is unproven).
<!-- BEGIN ADDED PROBES #74/#75/#76/#96 -->- Keyword-not-structural for a METHOD CALL (#76): a "file calls
B.Method()" guardrail that greps a bare method name —RunAsync\s*\(— passes on a comment (// RunAsync(scope)), a local stub of the same name (private void RunAsync(...)), or any unrelated same-named method, none of which invoke the real library method. The call-site sibling of the keyword-not-structural type/member trap. Fix: require two sequential checks — the type is referenced (MigrationRunner, rules out a local stub) AND the dotted call (\.RunAsync\s*\(, rules out comments + standalone definitions). Apply to any "task A must callB.Method()" on a specific type in another project. (Catalogue → method-call anchoring;stacks/dotnet.md §15.) BLOCKER on a wiring guardrail — a local/commented stub reads as wired. - Library bypasses its injected interface (#74): a task extracts a library that must write
through an injected
IInterface; it is registered + builds + tests pass — but no guardrail checks the library's internals don't call the CONCRETE method directly, bypassing the abstraction. Tell: an "extract … must go throughIInterface" / "must NOT callXdirectly" task with only registration + build + tests-pass guardrails and no forbidden-direct-call scan of the library folder. Fix: a comment-stripped (#97/#98), dot-anchored (#76) forbidden-call scan of the library project's.csonly (excludebin/obj). Also flag the inverse mistake: a bare-name bypass grep with no comment-strip — it false-REDs a correct library on a comment (whack-a-mole toneeds-human). (Catalogue → no-direct-bypass;stacks/dotnet.md §16.) BLOCKER — a bypass ships green. - Enumerated behaviors unverified (#75): a test-author task whose action prompt lists ≥3 named
behaviors to encode but whose guardrails are only
tests-exist+tests-fail-on-current-code— neither verifies the named behaviors are present, so one trivially-failing stub satisfies both while behaviors 2–N are never encoded (the coverage-gap anti-pattern, made concrete). Fix: acovers-key-behaviorscheck for 2–3 distinctive terms (domain type / enum / method name — never generic words) from the list, scoped to the one test file; name it a lower bound (a term present ≠ the behavior asserted) and report which enumerated behaviors went unchecked. (Catalogue → covers-key-behaviors;stacks/dotnet.md §17.) WEAK→BLOCKER depending on how load-bearing the unverified behaviors are (it is the coverage-gap probe, sharpened for enumerated lists). - Enumerated behaviors pinned only by NAMES — no per-test red census (#375): the task above, one
level down. It now has a
covers-key-behaviorsfloor (or a manifest over--list-tests), and both are naming lower bounds: a test named for the behaviour with anAssert.True(true)body satisfies them. Its red guardrail does not catch that either, becausetests-fail-on-stubsis a suite exit code — non-zero fires if any selected test fails, so the hollow test passes on the stub tree and hides behind its genuinely-failing siblings. Measured on a security wave:covers-security-matrix.ps1exited 0 over a file naming every wire token with hollow bodies, and five load-bearing invariants were pinned by nothing. This matters most where the review cannot see the tests at all — the JIT flow authors them at run time. Fix: the per-test red census — every enumerated behaviour bound to a pinned test method name and observedFailedin the runner's own result file (catalogue → the per-test red census;stacks/dotnet.md §4.4). Probe B operator 21 (§2b) is the mechanical half: write the hollow sample and run the guardrail against it. BLOCKER when the tests are run-authored and the invariants are security- or safety-load-bearing; WEAK otherwise. Never propose a rejection-shaped source regex as the fix — §2b says why in three lines. - Name-convention seam unverified (#96): task A produces artifacts a consumer (task B / a runtime
component) resolves by a derived or mapped name (url→embedded resource, step id→filename, key→file,
route→handler, message-type→schema) — and
file-exists/file-containson A plus content checks on B both pass while the naming contract is never exercised. B derives a name A never produced (case / separator / single special-case drift) and 404s/silently-falls-back at runtime on a 100%-green suite — invisible until the first real run. Tell: a derived-name consumer (fetch-by-name, embedded-resource/reflection lookup, convention file-map, route resolution) with only per-side file-exists/content checks and no end-to-end lookup over the whole set. Fix: a consumer-driven integration guardrail on a both-sides-present task that parses the consumer's real map (never a hard-coded contract copy), drives the lookup for every item, and asserts 200 + a per-item marker (not a fallback body);scope:"integration"and union-safe (#125 — "every present artifact resolves"). Also flag the weak forms: a sampled check (not every item — the drift hides in the one special case) and a hard-coded name list in the test (a copy hides a consumer-side drift). (Catalogue → name-convention seam;stacks/dotnet.md §18.) BLOCKER on a UI/transport/convention-heavy plan — the failure is invisible to the whole suite.
<!-- END ADDED PROBES #74/#75/#76/#96 --><!-- BEGIN ADDED PROBES #176 — transitive compilation dependency · negative-assertion gap -->- Transitive compilation dependency — a test-author ancestor references a non-ancestor's type (#176):
the §3 "missing edge" check applied at the IMPLICIT COMPILATION level, not just the direct-artifact
level. For each task B whose verification step runs
dotnet build/dotnet test(it compiles a test project): identify B's ancestor test-author tasks (ancestors that write.cstest files — those files are in the test project B compiles). For each such test file, consider the types its action prompt's scenarios / deliverables ALLOW it to reference (the enumerated scenarios, the named collaborators — not every type imaginable). If any of those types is PRODUCED by an implementation task C that is NOT in B's ancestor set, flag the missing edge B←C. The decision rule, stated verbatim: "Task B's verification compiles the output of ancestor test-author task A. A's prompt allows referencing types produced by task C. C is not in B's ancestor set → missing edge B←C (addCto B'sdependsOn, or the agent will be trapped — it can't fix a compile error in a file outside its writeScope, and may compensate by redefining the type in its own scope → a duplicate-definition merge collision)." This is the exact failure chain of plan-0009: task 09'sdotnet test --filtercompiled the test project holding task 08'sMigrateDispatchTests.cs, which referencedCommanderRestImporterproduced by task 07 — and 07 was NOT in 09's ancestor set, so 09 hit an unfixable compile error and redefined the class in its own writeScope (Launcher.cs), colliding with 07's copy at the AI-merge (CS0101, #175/#174). Severity: WEAK when the trap merely risks a wasted retry /needsHuman; BLOCKER when the test file's scenarios plainly reference the non-ancestor type (the compile failure is certain). Fix: add the producing implementation task to B'sdependsOnso its output is present in B's working tree. (Distinct from the direct-artifact missing-edge check, §3 — there B reads C's FILE; here B COMPILES a file that references C's TYPE.) (plan-breakdown Step 3 adds the matching authoring rule.) - Negative-assertion gap — a prompt excludes a scenario but no guardrail forbids it (#176): when a
task's action prompt EXPLICITLY EXCLUDES a scenario/keyword ("Mode C /
CommanderRestis wizard-blocked — do NOT include it in the dispatch tests"; "the importer must NOT callXdirectly"), the corresponding guardrail must carry a NEGATIVE assertion verifying the excluded keyword is ABSENT —if ($content -match "CommanderRest") { Write-Output "…"; exit 1 }(fail-on-present). Without it, the agent is free to include the removed scenario undetected: the positivecovers-key-behaviorsonly checks PRESENCE of the kept scenarios, so a stray excluded scenario sails through (exactly what slipped past plan-0009's task 08 and fed the #176 compile trap). For every test-author / implementation task whose prompt names an excluded scenario, confirm a fail-on-present guardrail exists for that keyword; if absent, flag WEAK (the exclusion is unenforced) — BLOCKER when the excluded scenario is the very thing that traps a downstream compile (the #176 case). Fix: add a fail-on-present negative-assertion guardrail (catalogue → negative assertion;stacks/dotnet.md §20), paired with the positivecovers-key-behaviors. Note it is correct thatguardrails validate's GR2026 stays SILENT on this guardrail's keyword (post-#177 GR2026 flags only POSITIVE require-present coverage tokens, SSOT §4.4) — a GR2026 warning on a negative assertion would be the #177 false positive, not a signal to remove the guardrail. (plan-breakdown Step 4 adds the matching authoring rule.)
<!-- END ADDED PROBES #176 -->Unreachable outcome — the target file IS in scope but the VALUE has no in-scope route to it (#474): the data-path sibling of the transitive-compilation probe above. #176 is the compile axis (B compiles a file that references a non-ancestor's type). This is the data axis: the target file sits in the task's
writeScope, and the value it must carry has nowhere in-scope to come from. A shallow "is the file in thewriteScope?" check passes — which is exactly why the measured instance survivedvalidate,graph --checkand a full review pass, and dead-ended atneedsHuman.Trigger set. Every guardrail clause asserting "file X contains / references / does Y" where Y is a datum — a value that has to ARRIVE from somewhere — rather than a shape X can declare on its own. The test that separates the two, and it is the one that generalises: to satisfy this clause HONESTLY, must X read something it does not itself declare? "X declares
sealed record Foo" is a shape — X owns it outright, so the clause is reachable by construction. "AttemptJournaler.csreferencesUsage" is a datum — the token is free to type, but the value has to arrive on an object the file receives, and the gap between those two is the whole defect.Ask the question in the target FILE, not in the guardrail. It is phrased so the guardrail cannot answer it:
If the agent edits only the files it is allowed to, is there anything for the target file to read?
Five steps, in order. The habit they replace is a single
writeScopemembership check on the target file — which passes on the measured instance, because the target file was never the problem:- Open X on the tree this task actually runs against (the plan baseline plus every ancestor's merged
output). Find the statement that would carry Y — the assignment or initializer where Y gets written —
and name the expression it must read from: the parameter, field, or local. That is the carrier.
X does not exist yet? The probe still runs: read the task's
action.prompt.mdfor what X will be handed (the type it receives, the call site that constructs it). A file yet to be written still has a carrier, and a prompt that names none is itself the finding — nobody has decided where the value comes from. - Resolve the carrier's declaring type and the file that declares it. Reuse the seam-ledger audit's
check-3 lookup (a type exists at a task when that task's
writeScope, or an ancestor's, contains the file declaring it) — do not re-derive it. - Does the carrier already expose what Y needs, on that tree? If yes → reachable; stop.
- If not, the member must be ADDED to the carrier. Is the file declaring the carrier in this task's
writeScope? → reachable. In an ancestor'swriteScopeand that ancestor's action prompt actually requires adding the member? → reachable, but confirm the ancestor carries its own guardrail for it: a merged FILE is not a present VALUE. Owned by a non-ancestor, by a later task, or by no task at all → BLOCKER. - If the required text is an ARGUMENT IN A CALL, the carrier is not the answer — the CALLEE is.
Name the member being called and open its declaration. Does its parameter list already accept
what the clause requires? If not, the requirement is "widen this signature," and the file
declaring that member must be in this task's
writeScopeor an ancestor's. Not the file the call is written in — the file the member is declared in. For a call dispatched through an interface, that is the interface, not the concrete type: a cast to the concrete type compiles, satisfies the clause, and journals nothing — the false green this step exists to catch.
The one-grep shortcut, and the fastest way to run steps 1–3: follow the sibling datum. Find the nearest existing datum that already makes the whole trip and grep it; every file it passes through must be in the scope. (plan-breakdown Step 2 carries the matching authoring rule — the sibling-datum trace.)
The measured instance, worked.
model-tiering-stage-2, task 13,writeScope=[ClaudeStreamParser.cs, ClaudePromptRunner.cs, AttemptJournaler.cs]; guardrail:AttemptJournaler.csmust referenceUsage. The membership check passes —AttemptJournaler.csis right there in the scope, and that is the wrong file to be looking at. Step 1 says why:AttemptJournalerdoes not buildAttemptRecordfrom aPromptResult, it builds it from anActionRun(AttemptJournaler.cs:36takesActionRun action;:74builds the record;:81readsCostUsd = action.CostUsd). Step 2:ActionRunis declared inActionRunner.cs:347— in task 07'swriteScope, an already-merged sibling. Step 3: it carriesCostUsdand noUsagesibling. Step 4:ActionRunner.csis in no ancestor that was ever asked to add one → BLOCKER. The sibling shortcut lands in the same place in one grep:CostUsdmakes the whole trip, it passes throughActionRunner.cs, and the scope does not contain that file.Name the severed link — and name the false green it invites. The finding is a three-part sentence: "X can only read Y from
<carrier type>;<carrier type>is declared in<file>, which this task may not write (owned by<task | nobody>); the agent's only in-scope moves are an honest halt or a token that satisfies the pattern and carries nothing." State that second half explicitly — it is what makes this a BLOCKER and not a scoping nit. The measured agent chose the halt and said so; the same clause with a laxer regex buys a false green instead, and nothing downstream would ever have asked again.Fixes, in preference order: (1) add the producer file to this task's
writeScope, and its work to the prompt; (2) move the unreachable hop to the task that already owns the producer file, moving the clause with it and adding the edge; (3) split the hop out as its own task downstream of both (what the measured plan did). All three are reachability moves. This probe never says "this task is too big", never countswriteScopeentries, and never readsaction.maxTurns— if a widened scope then trips the over-size split-trigger, that is §2's Over-scoped-task probe firing on its own evidence, reported separately (the "#378 boundary" paragraph above governs: the rule is about which verdict a check derives, not which field it reads).Its relatives, so you don't run one and think you ran another. #176 = compile axis; this = data axis. §3's missing-edge check asks whether B reads C's file; this asks whether a value has a route into a file B already owns. §4's missing-insertion check asks the coverage question one level up — does any task claim this path? — while this one assumes coverage holds and asks whether the datum can travel. GR2026 (#157) is the same shape keyed on prompt vocabulary, not on reachability. No
validatecheck sees this one, and none is planned: deciding it needs semantic analysis over a tree the run has not finished writing. This probe is the gate.- Open X on the tree this task actually runs against (the plan baseline plus every ancestor's merged
output). Find the statement that would carry Y — the assignment or initializer where Y gets written —
and name the expression it must read from: the parameter, field, or local. That is the carrier.
X does not exist yet? The probe still runs: read the task's
<!-- BEGIN ADDED PROBE #221 — prose-only prohibition with no structural backing -->- Prose-only prohibition, no structural backing (#221): for every explicit "do NOT …" statement
in a task's action prompt ("do NOT wrap this in a retry loop," "do NOT weaken this assertion to
tolerate fewer than N arrivals," "do NOT use approach X"), verify a guardrail exists that would catch
the forbidden shortcut. A prohibition backed by nothing but prose is free for an adversarial — or
merely lazy — implementer to ignore; this probe mirrors exactly how the pattern was found (a real
dogfood, not a synthesized example): a flaky-concurrency-test hardening plan forbade weakening
Assert.Equal(3, …)toAssert.True(… >= 2)and forbade a retry-until-pass wrapper, and neither prohibition had a backing guardrail — both are the cheapest wrong implementation for their task. Check the forbidden behavior against structural checkability (a regex/count/shape test on the file the task modifies) before flagging: if it IS checkable and no guardrail enforces it, that's the finding; if it genuinely is NOT checkable (a judgment call with no mechanical proxy), confirm the breakdown report says so explicitly rather than treating the gap as covered. Escalate to BLOCKER when the task's OTHER guardrail is empirical/statistical (a "run N times, assert it always passes" flake check) — the forbidden shortcut can make THAT guardrail easier to pass, not harder (a weakened assertion tolerates the very race the empirical check exists to catch), so the guardrail suite as a whole rewards the shortcut instead of merely missing it. WEAK when the guardrail suite is otherwise deterministic and simply silent on the prohibition. Fix: add the missing structural guardrail (a negative assertion, #176, for an excluded keyword/scenario; a regex-lock on load-bearing text surviving verbatim, or a call-count + forbidden-construct scan for a banned approach/shape) — or, if genuinely not checkable, require the breakdown report to name it as an accepted, unguarded judgment call. (Catalogue → "Prose-only prohibition, no structural backing"; plan-breakdown Step 6 adds the matching authoring rule.)
<!-- END ADDED PROBE #221 --><!-- BEGIN ADDED PROBE #203/#204 — stale line-number pointer / unhedged sibling-architecture claim -->- Stale line-number pointer / unhedged architecture claim about a not-yet-run sibling (#203/#204):
for every task whose action prompt references code belonging to another task in the same plan,
check the DAG wave placement first — is the referenced task in an earlier wave than this one (it
will run and commit its own edits before this task's attempt starts)? If so, scan this task's prompt
for two violations:
- A line number pointing into a file the earlier-wave task will modify (
~231-253, "around line N", "lines X-Y") — by construction the earlier task's edits land before this task runs, so the pointer is stale on arrival, not merely at risk of going stale. Flag WEAK, BLOCKER when the cited file is exactly the earlier task's ownwriteScope(the collision is certain, not merely plausible) — name the file and the earlier task. - An unhedged "here's how it currently works" claim about the earlier task's implementation
("this REPLACES/extends the same
<X>path", "task N built<Y>this way") stated as settled fact rather than a caveated hypothesis. Flag WEAK; BLOCKER when the plan gives no other reason to believe the claim holds (nothing else in the plan constrains HOW the earlier task must implement its deliverable, so the claim is a guess dressed as fact). This is the exact plan-0009-lineage failure (issue #202): a later-wave task's prompt citedScheduler.cs ~231-253and asserted a sibling task "extends the same Scheduler path" — the sibling actually built a standalonePlanPreflightPhase.cs, and the line numbers had shifted by the time the later task ran, costing 60-170+ turns of pure re-discovery (one attempt fully exhausted its turn budget touching zero of its own deliverables). Fix: replace the line number with a durable, structure-stable marker (a distinctive comment string, a method/class/type name, a grep-able symbol), and rephrase the architecture claim as a checkable hypothesis — "this reflects the plan-authoring-time state, before task N had actually run — verify it's still accurate before assuming the same shape applies here" (catalogue → stale line-number pointer / unhedged architecture claim; SKILL.md Step 6). Cross-checkmaxTurns: a task that trips this probe usually also needs themaxTurns: 75bump for the fourth turn-expensive archetype (SKILL.md Step 4a / catalogue "maxTurns budgeting (#94)") — if the prompt text is hedged/de-staled but the task is still left at the default budget (or vice versa), flag it as a half-applied fix: the two are companions for the same re-discovery risk, not independent bullets, so fixing only one leaves the other half of the risk unaddressed.
- A line number pointing into a file the earlier-wave task will modify (
<!-- END ADDED PROBE #203/#204 --><!-- BEGIN ADDED PROBE #578 — unverified structural claim a prompt makes about the codebase -->Unverified structural claim about the codebase (#578): an action prompt routinely asserts FACTS about the tree it is about to change, and nothing in the harness can check one. The claim is prose; the code it describes sits outside every guardrail's subject; and when the claim is wrong the task is implemented faithfully against a false map, every guardrail passes, and the defect ships green. Measured across plans 30, 31 and 32 this is the dominant failure mode — every halt and near-miss was a defect in the instructions, not in the checks, and six of seven were invisible to every guardrail in the plan. No
validatediagnostic backs it and none is proposed — deliberately, because nothing here is statically decidable and a mechanical gate would look rigorous while certifying nothing. So this probe is the only gate, alongsideplan-breakdown's authoring rule upstream of it.Take the §1 claim list and EXECUTE it, claim by claim. The reason this is a probe rather than advice is that these claims are almost always one command from falsifiable:
Shape Reads like Executed by Enumeration "there are N sites", "the sites are AandB"grep -c/rg -nfor the construct — then COUNT, don't skimRouting " Afunnels throughB", "everything goes viaX"grep the construct Bsupposedly owns; a funnel means one site and every other path calling into itExclusivity "the only caller", "the single construction site", "nothing else does this" the same grep, read for the second hit Location " File.cs:123", "around line N", "theFoomethod inBar.cs"sed -n '123p'/ open the symbolThe three measured instances cost one command each: plan 30's was
grep -c 'new AttemptRecord', which returns 9 against a prompt calling one of them "the shared failure recorder that the other outcome methods funnel through"; plan 31's wassed -n '1383p', and the cited line called something else entirely; plan 32's was adotnet build. That last one is a fifth shape worth naming — a prompt that DICTATES a construct rather than describing one ("mirrorX", "declare it in namespaceN") makes a claim the language decides, and compiling the shape the prompt dictates is how you execute it. Plan 32's instructed namespace shadowed a production one and could not compile; the sibling file the prompt named as the model documented that hazard verbatim in its own header.Record a verdict per claim. All three are reportable outcomes:
- verified — you ran the command and it agrees. Name the command in the Step 6 report. A claim marked verified with no command beside it is a claim someone re-read.
- corrected — the command disagrees. This is a finding in the §6 table like any other, subject
to the same per-finding approval — the pass does not quietly edit prompts. Its fix column carries
the rewrite into the executable form (
plan-breakdownStep 6, #578) — "grep this file forXand cover every hit", ready to paste — and not a fresher list: replacing "the sites are A and B" with "the sites are A, B and C" re-arms the same trap on the next edit to that file. - unverifiable-and-reworded — the claim is about a state that does not exist yet (a sibling's
not-yet-run output, a service that isn't up) or costs more to settle than the task is worth. It then
must not stand as a fact, and the fix column carries it reworded as a pointer the run-time agent
resolves ("grep for
Xto establish the caller set before you change its signature"). Reword, never delete — the pointer is the useful half, and deleting it sends the agent in blind.
Severity. BLOCKER when the claim is load-bearing for the deliverable and no guardrail in the plan can see it wrong — the plan-30 shape exactly: a prompt naming 2 of 9 recorders, an implementation faithful to it, a
--filterselecting only that task's own tests, a green terminal gate, andturns/segmentsshipped null on precisely the failure outcomes the metric exists to compare. WEAK when the claim is merely navigational and the agent's first grep corrects it — still report the correction: the correction costs turns, and a regeneration re-emits the same false sentence.This probe's own commands are subject to §2b's zero-match rule (#500). A
grep -cthat returns 0 or 1 because it never opened the file is byte-identical to one that read every byte, and you will write the result down as verified. Before trusting a count, run the same invocation against the same subject for a literal you have already read out of that file and confirm the hit. The failure generalises past zero matches, which is why the control and not the flag is the rule: a checker that printsokon input it never parsed, and a mutation whosesedanchor matched nothing, both come back green while doing nothing. (This clause is scoped to this probe's own commands. The general form — an ad-hoc verification is not reportable until its negative case has been observed to bite — is #580, filed, not yet doctrine; do not read it as already binding on the rest of the pass.)Relation to the #203/#204 probe above — the same defect on a different clock. #203 covers a claim that was TRUE when written and goes stale because an earlier-wave sibling edits the file first; it keys on wave placement. This probe covers a claim that was FALSE when written, about code that already exists and that no task in the plan touches — so wave placement gates nothing and #203's trigger never fires. Run this one on every prompt, in a flat plan as much as a waved one. The location shape is where the two overlap, and there #203's durable-marker fix is the right fix.
<!-- END ADDED PROBE #578 --><!-- BEGIN ADDED PROBE #193 — orphaned pre-existing golden swept in by a broad tests-pass filter -->Orphaned golden swept in by a broad
tests-pass--filter(#193): the runtime analogue of the #176 transitive-compilation probe. There the trap is compile-time (a test compiles a type a non-ancestor produces); here it is a runtime assertion — a code-change task'stests-passguardrail uses a broad name-substring--filter(--filter "FullyQualifiedName~Renderer",~Serializer,~Golden,~Snapshot, a bare namespace substring) that, beyond the task's own new tests, also matches PRE-EXISTING tests the task did not author. For each code-change task whosetests-passguardrail carries such a broad--filter, enumerate the pre-existing tests the substring matches that are NOT authored by an ancestor test-author task (grep the repo's existing test tree for the filter substring; the matches that already exist at plan start are the orphans). For each orphan, ask: does this task's change plausibly alter a pinned literal / golden file / snapshot / approved output that orphan test asserts against? (a task that touches a renderer, a hash/serializer, a formatter, a message schema, any cross-cutting OUTPUT shape is the high-risk case — it shifts bytes every golden downstream of it pins). If yes AND that test + its golden fixture are outside the task'swriteScopeAND no other task owns re-baselining them → BLOCKER: the task is required to make a pre-existing test pass whose pinned golden its own change invalidates, and it cannot edit the golden (write-scope check red-halts the fix) — every attempt fails on an orphan it can't own and dead-ends atneedsHuman. This is the runtime sibling of #176's "can't fix a compile error outside its writeScope" trap (there the agent redefines the type and collides; here it simply cannot converge). Fix, in order of preference: (a) narrow the--filterto the task's own tests (a class-name / trait filter, not a broad substring) so the orphan is never swept in; or (b) widen the task'swriteScopeto OWN the golden fixture + its pinned test, so the re-baseline is in-scope; or (c) add a dedicated re-baseline task (ancestor of this one) that owns and regenerates the affected golden, with this task depending on it. Severity: BLOCKER when the change certainly shifts the pinned output; WEAK when the collision is plausible but not certain (the filter is broad and an orphan pins a literal the change might touch). (Catalogue → orphaned-golden / broad-filter trap; relates to #176 transitive-compilation and the write-scope test-protection gate. plan-breakdown Step 4 adds the matching cross-cutting-output re-baseline authoring rule.)The filter is the WRONG search space, and narrowing filters makes it worse (#541). Everything above asks "which orphans does this filter sweep in?" — so it only ever looks inside the tests some task filter selects. #455 pushes those filters narrow, which is right; the consequence is that the narrower the filters, the more of the suite falls outside every one of them, and the class of test most likely to break — a cross-cutting OUTPUT golden — is precisely the class no task-level filter selects.
Measured.
27-operator-visibilityhalted at its Integration baseline preflight after tasks 01–07 had merged green, on one test:LogSiteHaltBannerTests.NoHalt_PlanIndex_IsByteForBytePreBannerOutput Expected: …<th>Description</th></tr></thead>… Actual: …<th>Description</th><th>Model</th></tr></thead…Task 07 shipped a Model column on the exported log site. That test pins the page byte-for-byte and says so in its own comment — "ANY change to the page skeleton, the insertion points, or the emitted rows fails here". It fired correctly; the golden was legitimately stale. Nobody owned the re-baseline — that file appears in no task's
writeScopein the plan. The review pass ran this probe and cleared it HONESTLY, examining the classes the task filters actually select and finding no exact golden in them.LogSiteHaltBannerTestsis selected by no filter in the plan, so the probe never looked at it. Its narrow filters were correct by #455, and that correctness is what hid the orphan.So ask the other question too, keyed on the COMPONENT rather than on the filter:
This task changes a cross-cutting OUTPUT. Which tests anywhere in the suite pin that output byte-for-byte, and does any task own re-baselining them?
Mechanically approachable from
writeScopealone. For a task touching a renderer, serializer, formatter or schema, grep the WHOLE test tree for exact-match assertions against that component's output — anAssert.Equalon a multi-line string literal, an approved/golden file, a name carryingByteForByte/Golden/Snapshot/Verbatim/Approved— and check each hit against the UNION of every task'swriteScope. A hit no task owns is the finding, whether or not any filter selects it. In the measured plan the tell was in the test's own name and its own comment, both saying it was a tripwire on the exact page task 07 was rewriting.And a THIRD question, keyed on the CHANGED TEXT (#754). Both searches above still need a COMPONENT to key on, so both stay blind to the commonest case of all: a task told to reword user-visible text — a banner, a halt message, a CLI option description, a diagnostic string — in ordinary command code that is no renderer, serializer, formatter or schema. So ask:
This task's prompt changes a user-visible string literal. Which tests assert that literal verbatim, and does any task own updating them?
Grep the repo for the LITERAL being changed, not for a component name, and check each hit against the UNION of every task's
writeScope. Measured (plan 41):16-implement-halt-text-and-interlock-wordingcorrectly reworded the undelivered-work banner, butUndeliveredWorkWarningTests.csasserts that banner verbatim in two places and sat in no task'swriteScope. All 20 tasks went green, the whole DAG was spent, and the run halted at the terminal gate on the merged HEAD — where nothing downstream could repair it.Same severities as above: BLOCKER when the change certainly shifts the pinned output and no task owns the golden; WEAK when plausible. And say WHICH search you ran — "no orphan swept in by a filter", "no golden over this component anywhere" and "no test pins the text this task rewords" are THREE different clearances, and reporting any one of them as though it were another is how both of these were missed.
<!-- END ADDED PROBE #193 --><!-- BEGIN ADDED PROBE #248 — pattern-matching guardrail not verified against real output -->- Pattern-matching guardrail not verified against real output (#248): any guardrail that
pattern-matches/regexes against a specific tool's printed console output — a
Select-String/regex check ondotnet test's summary line, a grep on a build tool's error format, anything parsing text a tool PRINTS rather than just checking its exit code or a file it wrote — carries an unstated assumption about that tool's exact output format. Reading the script and judging whether the regex "looks plausible" is a different question from "does it actually match what the tool prints," and a purely textual review cannot tell them apart. For every such guardrail, run the underlying tool once against the existing repo/workspace (it already has a buildable/runnable state — this costs one invocation of the real tool, not a purpose-built repro of the guardrail's specific scenario) and check the pattern against the real output. Tell: aSelect-String/ regex / grep on a tool's stdout whose pattern encodes field order or exact wording the review has not confirmed against a real run. The motivating case (#248): atests-fail-on-stubsguardrail'sSelect-String -Pattern "Passed:\s*\d+,\s*Failed:\s*[1-9]", stacked on top of an already-sufficient exit-code check, assumed xUnit's summary line reads "Passed: N, Failed: M" — it's always "Failed: N, Passed: M" — so the regex could never match and the guardrail failed UNCONDITIONALLY regardless of what the agent did. The same bug existed identically in four scripts in one plan; a purely textual read of all four missed it because the regex reads as plausible without a realdotnet testrun to check it against. Scope this narrowly — do not run the tool for guardrails with no output-format assumption to verify (Test-Path, agit diff, a bare exit-code check): there is nothing there a tool invocation would confirm. Fix: run the tool, observe its real output, and confirm the pattern matches; once confirmed either way, the usual fix is to DROP the pattern-match entirely and rely on the exit code alone (the catalogue's stub-based-TDD form already does this correctly,stacks/dotnet.md §4.1— this is a review-side gap, not a doctrine gap). BLOCKER when the pattern can be shown to never match the real output (the guardrail fails unconditionally, dead-ending every attempt atneedsHuman); WEAK when it matches today but rests on a fragile, unconfirmed format assumption (SDK/framework version, locale, verbosity level) that could silently break later.
<!-- END ADDED PROBE #248 --><!-- BEGIN ADDED PROBE #302 — script guardrail not smoke-tested against valid + invalid samples -->- Script guardrail not smoke-tested against a valid + invalid sample (#302): EXTENDS #248 but is
DISTINCT. #248 runs the underlying tool once to confirm a guardrail's assumption about that
tool's PRINTED output; #302 EXECUTES the guardrail script itself (
.sh/.ps1/.py, in any of the four folders) against hand-synthesized samples to prove the SCRIPT's OWN correctness — does it run at all, PASS a valid artifact, and REJECT an invalid one. The motivating bug had no tool-output assumption: a LikeC4 single-quote nested inside a bash-e '...'block was silently quote-stripped, corrupting the throwaway fixture on EVERY attempt regardless of the task's output — so #248's "run the tool once" probe did not cover it, and a purely textual read of the script missed it (the quote-stripping is syntactically valid bash; only EXECUTION reveals the corruption). For every script guardrail that is runnable-at-author-time — idempotent (no persistent workspace side effects; a temp dir cleaned viatrap/finallyis fine) AND its input is in-repo or hand-synthesizable AND it needs no live external dependency (no server boot, no network, not the full merged HEAD) — do the two-sided execution:bash -n/sh -n(or apwsh -NoProfileparse) as a cheap FIRST pass, then run it against (a) a hand-written representative VALID sample of the checked artifact (expect exit 0) and (b) a deliberately INVALID one (expect non-zero). The highest-value target is a guardrail that RENDERS or EXECUTES the task's own not-yet-authored output (a throwaway workspace, a rendered fixture, an--input-typeblock): its real input does not exist until the task runs, so its first real execution is deferred to runtime today, and that is exactly where its own harness/fixture bugs (bash quoting, path handling,--jsonparsing) hide — hand-synthesize the sample and run it. Severity: BLOCKER when the script FAILS the valid sample (a false-red no correct implementation can satisfy → every attempt dead-ends atneedsHuman, blocking downstream) or PASSES the invalid sample (a toothless / tautological check); WEAK when it is runnable-at-author-time but simply was not smoke-tested (a latent script bug the review should close now). Not runnable-at-author-time (needs a live service / the built binary / the full merged HEAD) → do NOT block: run the syntax pass, reason about correctness, and note in the report that the guardrail could not be author-time-executed and why (an honest deferral). Scope narrowly — aTest-Path/ bare exit-code /git diffguardrail with no rendering, parsing, or fixture step has little a run would reveal that a read does not; spend the execution budget on the render/execute-the- output scripts. (Doctrine:guardrails-domain-knowledge→ author-time smoke-test gate; plan-breakdown Step 7.0d adds the matching authoring rule.)
<!-- END ADDED PROBE #302 --><!-- BEGIN ADDED PROBE #455 — task-level test filter scoped past the task's own tests -->Task-level test filter reaches a SIBLING's tests — deadlock (forward) or tautology (inverse) (#455): the concrete instance of §2's "Over-broad: 'all tests pass' anywhere except the terminal
<plan>/guardrails/folder" rule, wearing a--filterso it does not look over-broad. A task-leveltests-pass/tests-fail-on-stubswhose filter is a plan-wide selector (a category/trait/tag every new test class in the plan carries, a whole test project, a bare namespace) asserts the state of every test in the plan rather than the ones its own task pair owns.Why the existing probes cannot find this, and what that demands of you. Both of this skill's other executed probes evaluate a guardrail in isolation — #248 runs the underlying TOOL once to check an output-format assumption, #302 executes the guardrail SCRIPT against synthesized samples. Read alone, a
dotnet test <proj> --filter "Category=ModelTieringStage1"guardrail is flawless: correct syntax, correct polarity, real teeth, runs clean. The defect exists only in the relationship between that filter's SCOPE and the DAG's dependency EDGES. A probe you can satisfy by looking at one guardrail will fail exactly the way the pass that missed #455 failed. Do this cross-referencing explicitly, and write the table down — it is the evidence that the probe actually ran:task guardrail (polarity) filter test classes the filter SELECTS who authors each who makes each green Fill it by (1) listing, per task, the test class(es) its
writeScopeand action prompt say it AUTHORS; (2) for each task-level guardrail carrying a test filter, resolving which of those classes the filter selects — a trait/category filter selects every class carrying the trait, including classes other tasks author; then ask both directions.Resolve the filter's scope against the corpus — do not assume it selects what it was meant to select. The lazy way to fill column 4 is to copy column 1, which reproduces the exact blind spot this probe exists to close. Two honest ways to fill it: (a) when the test classes already exist (a regeneration, a partially-run plan, a brownfield target), ENUMERATE what the filter selects —
dotnet test <proj> --filter "<the guardrail's filter>" --list-testsnames them without running anything, which is both cheaper and more legible than a count, and immune to the localization trap below. Any listed test the task's own pair does not own is the finding, in hand, without reasoning. (b) when the classes do not exist yet, resolve on paper against the class names the plan's action prompts PIN. If the prompts do not pin their test class names, that is itself a BLOCKER: neither the author nor you can determine what any task-level filter selects, and an author who cannot name the class falls back on the plan-wide trait — which is how this defect is born (plan-breakdownstacks/dotnet.md §4.3requires the prompt to pin file + class).- Forward — does the filter select tests that only a DOWNSTREAM task can make green? For a guardrail
where exit 0 is the pass, take each selected class authored by another task and find the task that
turns it green. If that task is a descendant of this one (it
dependsOnthis task, directly or transitively) → BLOCKER: deadlock. This task cannot go green until a task that depends on it has run. Note explicitly thatguardrails validateandguardrails graph --checkboth PASS on this — the cycle is between a task and a sibling's test corpus, not between tasks, and no DAG check models it, so their green tells you nothing here. Observed cost: 4 attempts and ~$20 toneeds-human, with the task's deliverable complete and its own tests green the whole time. - Forward, third mode — a CONCURRENT sibling with no edge either way. When the task that makes a swept-in class green is neither an ancestor nor a descendant but a parallel sibling, the guardrail is not deadlocked — it is nondeterministic: it passes or fails on merge order, which is the property that made #455 look intermittent and let a third task ride through green. Flag it WEAK (BLOCKER when the plan runs those tasks in the same wave, where the race is not hypothetical), with the same narrowing fix. Do not record "no deadlock" as "no finding".
- Inverse — can a SIBLING's tests satisfy the red check? For a guardrail where NON-zero is the pass
(
tests-fail-on-stubs/tests-fail-on-current-code), ask whether the filter selects any test class this task's pair does not own. If yes → BLOCKER: tautology. The check needs only some matching test red, so once any sibling's intended-red tests are on the base it passes whether or not this pair's own tests fail — the TDD-red proof (#155) degrades into merge-order luck. Treat this as the more serious half: the forward deadlock fails loudly, this one goes green while certifying nothing (it did, three times, in the run that produced this probe).
Do not be reassured by a task that currently passes. Which of the two modes bites is decided by merge timing, not correctness — in the motivating run a third task carried the identical over-broad filter and passed only because it branched before the sibling's red tests reached its base. Flag every task carrying the shape, not only the one that failed.
Fix: scope the filter to the test class that task pair owns —
--filter "Category=<PlanTrait>&FullyQualifiedName~<ThisTaskPairsTestClass>"— on both halves of the pair, copied verbatim so they cannot drift. The class term is MANDATORY and the trait is an OPTIONAL conjunct — the trait ALONE belongs in exactly one place, the #181 baseline preflight's!=exclusion. (Do not read this as "the trait is banned": it is the correct first term above.)Two sub-checks on the fixed form, both WEAK on their own (BLOCKER when they reinstate the defect above):
- Non-discriminating substring.
FullyQualifiedName~is a substring match, so a class name that is a prefix of a sibling's re-widens the filter silently (~Dispatchalso selectsDispatchRouterTests). The cheap mechanical check isdotnet test <proj> --filter "<the filter>" --list-tests— it enumerates exactly what the filter selects without running anything, so it works on a built repo even when the plan's own tests do not exist yet. The fix is the namespace-qualified name. A zero-match guard that is missing, or present but inert. A
--filtermatching nothing — or one that is malformed (\|instead of|: VSTest reportsIncorrect format for TestCaseFilterand runs zero tests) — exits 0, so a typo'd class name turns atests-passinto a green no-op and makes atests-fail-on-stubsreport a misleading "tautological tests" failure. Every narrowed filter must assert ≥1 test actually EXECUTED. Read the guard's key, because four spellings look right and are not — flag each BLOCKER, since a guard that cannot fire is worse than none (it buys false confidence):- keyed on the
No test matches…string → verbosity-dependent, absent under-v q, so it is written, executed, and never fires. #248 in its purest form; - keyed on
Total:→Total:counts[Skip]ped tests, so a fully-skipped class passes a guard that is supposed to prove tests ran. The executed count isPassed:+Failed:; - keyed on any English summary token without pinning
$env:DOTNET_CLI_UI_LANGUAGE = 'en'→ the summary is LOCALIZED (a German-culture box printsgesamt:, noTotal:), so on such a machine the guard fires on every run and the guardrail fails unconditionally; - keyed on a TRX census that counts an ARRAY-WRAPPED
$null→ the shape a reviewer is most likely to read as correct, because it is the idiomatic PowerShell array-wrap:$recorded = @($xml.TestRun.Results.UnitTestResult)followed byif ($recorded.Count -lt 1). When zero tests run the TRX has no<Results>element at all, so$xml.TestRun.Resultsis$nulland@($null).Countis1— the guard never fires. Measured on both shapes of results file:<Results>-less → count 1; one<UnitTestResult>→ count 1; the two are indistinguishable. Observed consequence on a TRX-reading census: the guardrail exited 1 while emitting 11 misdirected findings naming every pinned behaviour as unbound — pointing the retry agent at the one artifact it is allowed to edit (the test file) and away from the empty run that actually caused it, while the script's own header declared this guard prevented exactly that. Fix: drop the nulls before counting —@($xml.TestRun.Results.UnitTestResult | Where-Object { $null -ne $_ }).Count, measured 0 on a<Results>-less TRX and 1 on a one-result TRX.
A guard is not verified by READING it — construct the zero case and prove it fires. All four spellings above read correctly in place, and the fourth was written by an author who documented the defence in the header directly above it. A guard is a claim about behaviour under an input the plan has not produced yet, and the only way to grade that claim is to manufacture the input and run the guardrail against it: for a TRX-reading census, a results file with no
<Results>element; for a filter-based guard, a filter that matches nothing (--filter "FullyQualifiedName~ZzNoSuchTestClass"). Require a non-zero exit that names the empty run — anything else, including a red for some other reason, leaves the guard ungraded. This is Probe A's method (§2b) narrowed to one clause, and it costs one file. A guard you accepted on a read is an unchecked gap for the Step 6 report, not a verified one; the header above it is the authoring agent's belief, and A₂'s declared-claim rule (§2b) is the general form of why that is not evidence.Also check the ordering, which is polarity-dependent: a forward check must test the exit code BEFORE the guard (a crashed/never-started test host exits non-zero with no summary; guard-first misreports it as "the filter matched zero tests" and sends the retry agent to rename a correctly-named test class — the one file inside its
writeScope); an inverse check must run the guard FIRST (a crash exits non-zero, which is that check's success condition, so guard-second certifies "TDD red" over a run that executed nothing). Wrong order → WEAK, BLOCKER on the inverse (it certifies nothing). (Doctrine: catalogue → "Its SCOPE decides whether it proves anything";stacks/dotnet.md §4.3; plan-breakdown Step 4 carries the matching emission rule.)- keyed on the
- Forward — does the filter select tests that only a DOWNSTREAM task can make green? For a guardrail
where exit 0 is the pass, take each selected class authored by another task and find the task that
turns it green. If that task is a descendant of this one (it
<!-- END ADDED PROBE #455 --><!-- BEGIN ADDED PROBES #254 — waved plans (nested layout) -->- Cross-wave
dependsOnedge (#254): in a waved plan,dependsOnis intra-wave only — a task edge naming a task in another wave is a hard error (GR2034,validatecatches it). Beyond the lint, flag the shape it signals: a wave-2 task that "depends on" a wave-1 artifact should express that dependency as the wave-2 ENTRY gate ("the prior wave's outputs materialized") plus the action reading the real path — the wave barrier already orders the stages. A cross-wave edge (or an attempt to fake cross-wave ordering with a duplicated task) is a BLOCKER: name the offending edge and the entry-gate rewrite. - Wave-qualified state key (#254 / #164 one level up): for every state-writing prompt action in a
waved plan, the single top-level fragment key must be the wave-qualified id
<waveDir>/<taskFolder>(e.g.wave-02-provision/01-author-tests), NOT the bare folder name and NOT thestableId. A bare or wrong-wave key is rejected as foreign on every attempt (the #164 loop, one level up) →needsHuman. Cross-check the harness-contract header example, the## Taskfragment example, and the state-output guardrail's index ($fragment.'wave-02-provision/01-author-tests'.<key>) — all three must use the same wave-qualified id. A mismatch is a BLOCKER. - Missing / wrong-polarity wave ENTRY gate (#254 / #181 at the wave boundary): for each wave ≥ 2,
confirm
<plan>/<wave>/preflights/carries a POSITIVE "the prior wave's outputs materialized" check — the artifacts this wave builds on (real files/symbols/binary the prior wave produced) are present and non-empty before this wave's DAG runs (the #181 positive-baseline archetype at the wave boundary). It must be positive-monotone-safe (assert-present, never "not yet present" — a negative "absent" check at a wave-2 entry gate flips false the instant an unrelated file lands, a false-RED). A downstream wave whose tasks plainly build on upstream artifacts but whose entry gate is missing → WEAK (the run wastes a turn building against possibly-absent bytes, or misattributes an upstream-materialization failure to this wave's tasks); a negative-polarity wave-2+ entry gate → BLOCKER (it will false-RED). (Wave 1's entry gate is the ordinary plan-start baseline — a brownfield green-start or a negative fresh-start — reviewed by the §2 baseline probe.) - Wave EXIT gate — GR2028 per wave + intermediate-wave union-safety (#254 / #125 / #165): the
four-folder gap and union-safe probes (§2) apply to each wave's
<plan>/<wave>/guardrails/:- A multi-leaf / fan-in wave whose exit gate is absent, empty, or tautological (
exit 0) → same BLOCKER as the flat terminal-folder probe, but per wave (GR2028 applies per wave): the exit gate needs ≥1 real integration re-run (build/suite or a union invariant). - ANY wave's exit gate carrying
scope:"integration"— whole-suite or not — is a finding, and not for the #125 reason. The tag is INERT at a wave root (validatewarns GR2059, #459): the per-union re-verify set is the task<task>/guardrails/folders plus the PLAN-root<plan>/guardrails/folder only (SSOT §4.3), so the file runs exactly once, on the merged HEAD at its own wave's exit (SSOT §14.3), tagged or not. It therefore cannot red-halt a correct partial merge; the defect is the mirror image — the per-union invariant the author believed they authored does not exist, and the plan merely LOOKS union-guarded. Severity: WEAK when the file is a genuine wave-exit postcondition carrying a dead tag (fix = drop thescopekey; behaviour-identical); BLOCKER when thecatches:line, the breakdown report, or the topology relies on per-union protection — the real union invariant is MISSING and must be authored at<plan>/guardrails/, keepingscope:"integration"there and made union-safe/CONDITIONAL (#125/#165). Never propose relocating a wave-exit gate to the plan root (that changes WHEN it runs), and do not pre-empt the open #459 contract question. A whole-build/suite check is LOCAL wherever it lives, and only the LAST wave's exit gate (which runs on the fully-merged HEAD) is the right home for a whole-suite LOCALtests-pass— the whole-plan terminal boundary. Flag a plan-root<plan>/guardrails/that merely DUPLICATES the last wave's exit gate as a NIT (it is optional-additive, not a second terminal gate).
- A multi-leaf / fan-in wave whose exit gate is absent, empty, or tautological (
- Later-wave prompt references earlier-wave code (#254 / #203): apply the "#203/#204 stale
line-number / unhedged architecture claim" probe with wave placement as the earlier/later
discriminator — a wave-2 prompt describing wave-1's not-yet-run output is the canonical case. The
stronger fix here is the JIT staged-breakdown flow (author the later wave against the materialized
integration worktree, so nothing is guessed); if the plan authored a downstream wave up front with
guessed paths/line-numbers where JIT was available, flag it WEAK and recommend the JIT flow +
durable markers + the
maxTurns: 75companion bump. - JIT stub wave (#254): a declared-but-empty
wave-NN-<slug>/with an emptytasks/is not a finding — it is the intended JIT staging (the run will honest-halt there, author the wave against the materialized workspace, review it, resume). Do NOT flag an empty downstream wave as "missing tasks"; confirm the breakdown report documents the JIT workflow for it. (Only an authored wave gets the full adversarial pass; a stub is reviewed when it is later filled.)
<!-- END ADDED PROBES #254 --><!-- BEGIN ADDED PROBES #468 — source-shape demotion, sample pair, count floor (auto-merge friendly) -->- Source-shape regex where a TEST was available (#468): for every guardrail asserting a property of
implementation source, ask the demotion question — is this a claim about what the code DOES at
runtime, or a structural fact about the build/wiring graph? Behaviour → a test could have carried it
and did not. Recommend the demotion and name the test; do not merely tighten the regex. This is the
measured base rate, not a stylistic preference: over three review rounds and five agents on one
breakdown the test layer was never broken by any agent in any round while every blocker lived in
the source-shape layer (including 5 regressions introduced while fixing earlier rounds), and against
a tree with the type declarations and no wiring at all a 14-clause grep manifest went 10/14
green. A grep manifest measures vocabulary, not capability.
- Two named sub-shapes worth calling out by name. "X must USE Y" (must consume / go through / share / not diverge from a predicate, policy, formatter) → recommend an AGREEMENT property test: assert the two sides agree over the input domain, which passes on an equivalent inlined copy today and fails the moment it drifts. Three successive regexes failed on the measured case; no regex can express it. And a grep manifest of N clauses over declarations → ask how many clauses a declarations-only tree satisfies, and report that number.
- Do NOT flag the legitimate ones. Build-descriptor registration, cross-module reference chains, entry-point wiring (#64), the #120 grep fallback, and #176 negative assertions are structural facts with no runtime proxy and held up fine across the same rounds. The finding is reaching for a regex to prove something a test could prove better, never source-shape as such.
- Severity: BLOCKER when the check can false-red a correct implementation (apply the #479 test — can a correct implementation be written that this rejects?); WEAK when it merely certifies vocabulary a test should have certified. Also a finding when the breakdown report carries no line saying why no test could carry it — the report owes one per surviving source-shape check. (Catalogue → "The source-shape demotion gate"; the 13-shape taxonomy table is the named battery Probe B works down.)
- Source-shape guardrail with no committed two-sided sample pair (#468/#302): a
file-containscheck over implementation code shipped withouttasks/<id>/samples/NN-check.valid.<ext>/.invalid.<ext>. #302 requires the two-sided execution at author time; this makes it durable — every defect in the taxonomy was one execution away from discovery, and what was missing was that the execution had to be re-run after every edit, which is how a raw-vs-stripped fix from round 1 was re-broken by round 3's rewrite of the same file. Re-run the whole pair yourself, not just the clause you are examining. The valid half is the one that pays: it is the only half that can expose a clause that never matches (a\bcollapsed to a literal0x08by the authoring pipeline), a false-red on legitimate brace style, or a case mismatch — under the invalid half everything is failing anyway. Check the valid sample is complete, not a fragment: an incomplete one produces a different failure and masks the real defect. Do NOT raise this for a DOCUMENTATION deliverable — no meaningful invalid sample of a design doc exists, the exemption is legitimate, and the substitute is the PRECEDENT check (does every demanded token have a sibling precedent in that same document?). There, the finding is a missing precedent, or a report that took the exemption silently. WEAK; BLOCKER when running the pair reveals a false-red.- And check WHERE the samples live — a misplaced one is its own BLOCKER. A sample inside
guardrails/orpreflights/is loaded as a guardrail: the loader enumerates every non-.jsonfile there with no extension allowlist, so a.valid.csfixture intasks/<id>/guardrails/loads clean, counts toward GR2003 (a fixture satisfying "this task has a guardrail"), and is executed at run time; in the catches-enforced folders it is a GR2027 load error instead. The samples belong in atasks/<id>/samples/sibling, which the loader does not enumerate.
- And check WHERE the samples live — a misplaced one is its own BLOCKER. A sample inside
- A filtered
dotnet testguardrail in a repo whose RUNNER is MTP (#439): any guardrail whose scope comes fromdotnet test --filter, on a repo wheredotnet testdrives Microsoft.Testing.Platform rather than VSTest. Under MTP the filter is silently ignored and the WHOLE SUITE runs — measured on SDK 10.0.204 with a filter matching nothing: VSTest ran 0 tests and said so, MTP ran all of them and exited 0 with anMTP0001warning buried in BUILD output (stacks/dotnet.md§6a). Run the §6a detection; do not read it off the framework. Both of its clauses are required: the property /global.jsongrep, AND the negative signal — a test project carrying a framework reference but NO VSTest adapter, which is on its framework's native MTP host and which no grep FOR MTP will ever surface. One clause alone gets this wrong in both directions. Why this outruns the guards already in place. §4.3's zero-match guard fires on the executed count being ZERO; MTP fails in the opposite direction, so a correctly-authored filter widens to everything at RUN time and the guard passes on a large count. Probe A/A₂ cannot see it either — the widening happens after the command is emitted, andMTP0001comes from the BUILD, so a--no-buildguardrail (which §4.2/§4.3 emit) never prints it. Executing the guardrail here proves nothing, which is exactly why it needs a probe of its own rather than a line in §2b. The finding is that the guardrail's# catches:claim — the tests THIS pair owns — is false as written. Do not accept "widen the claim to the whole suite" as the repair: that is §4.3's deadlock (a task asserting a sibling's test corpus) with extra steps. BLOCKER on an MTP repo (the guardrail certifies a scope it does not have); on a VSTest repo, not a finding at all — and say WHICH you measured, because "no MTP signal found" and "did not look" read identically in a report. - A task whose
writeScopemixes WRITE MECHANISMS (#540): both a.claude/**path and a non-.claude/**path in onewriteScope. The.claude/half can only be delivered throughneedsHarnessWrite(the tool-permission layer refuses a direct write, SSOT §9.3); the other half is written directly. One atomic attempt has to get BOTH right simultaneously. Why every other probe in this pass walks past it. Two paths,dependsOnfan-in of 1, nomaxTurnsbump — the task is SMALL by every measure the split-triggers and GR2042 read, and in prose it is arguably one deliverable ("record the new surfaces in the SSOT and the skill"). A full review pass on the plan that produced this found two BLOCKERs and did not see it, because every probe here evaluates guardrail strength or DAG edges; none asks "can one attempt deliver all of this through the paths available to it?" What it costs. A failed attempt is rolled back whole, so the task can never BANK the half it got right. Measured: 12 attempts, ~$4.66, never green, on the last task of a plan whose other seven passed in 8 attempts total. Attempt 7 wrote one half correctly and lost it with the rollback; by attempt 10 that same half was failing again. Fix: split, one mechanism per task.validatewarns (GR2073), so an existing plan carrying this shape reports itself — but a plan authored before that code, or run with an older tool, does not. BLOCKER: the task cannot be completed as written by any number of retries. - A committed sample pair whose guardrail ignores
GR_SUBJECT, or a sample that is an ORPHAN (#559): the pre-DAG gate hands a sampled guardrail its subject asargv[0]AND asGR_SUBJECT. A guardrail that hardcodes its target instead scans the untouched repo for BOTH halves, so both exit the same way and the gate reportsValidHalfFailed— halting the run before task one, which is the most expensive place to learn it. Read every sampled guardrail for the override, and for a MULTI-subject guardrail check thatGR_SUBJECTreplaces the WHOLE subject list rather than being appended to it. Then check the file names: the verifier keys on the SECOND extension being exactly.valid/.invalid, so an extra case must readX.invalid-<qualifier>.cs;X.<qualifier>.invalid.csparses as a lone half and is anOrphanSample. Why a reading pass finds this and the author's own verification did not.plan-breakdownused to prescribe author-time verification as "execute the guardrail against a hand-written valid sample", which an author naturally does by STAGING the sample into the real target path — proving the clauses and never touching theGR_SUBJECTpath. The prescribed method passed while the enforced contract failed. Measured: plan 31 committed eight pairs, every one broken the same way, 11 findings at the gate. Cheapest confirmation, and the one to prefer over reading: runguardrails samples verify <folder>. BLOCKER — the run cannot start. - A TEST that synthesises a two-sided pair, with no distinctness assertion (#530): an
author-teststask whose tests build their own fixture — a guardrail body plus a valid and an invalid sample — and then assert on the subject without first proving the two halves produce different exit codes. Read the body and the two halves together, and grade the OPERATOR, not the intent. The measured case:-match 'DEFECT'against a.validhalf reading "a clean artifact, no defect here" — PowerShell-matchis case-INSENSITIVE, both halves exited 1, the pair discriminated nothing, and four tests could never pass. Its bash mirror is the opposite hazard:grep -qis case-sensitive, so the same fixture written both ways can discriminate on Linux and not on Windows. What makes this a review finding rather than a run-time one is that no gate downstream can see it. The task's own red census demands the tests be observedFailed— which a test that can never pass satisfies perfectly, red being the census's success condition — so the run goes green here and haltsneeds-humanon the NEXT task, after the implementation agent has spent its retry budget on production code that was already correct. GR2055 (a guardrail that cannot pass for any input, #484) lints that shape in a guardrail; nothing lints it inside a test's own fixture, and this probe is the only place it is looked for. Fix: the fixture asserts distinctness — different exit codes, not the right ones; polarity belongs to the test's own assertions, and a fixture that inverts its pair on purpose is legitimate. Bind the subject the way the run binds it (GR_SUBJECT+argv[0]for a task pair,GUARDRAILS_WORKSPACE+ cwd for a plan-root pair), or every body takes its no-subject early exit and the proof passes anything. BLOCKER — it costs a downstream halt and misdirects the agent that hits it. (Catalogue → "A test that SYNTHESISES a two-sided pair PROVES it discriminates"; the census's own boundary line isstacks/dotnet.md §4.4.) - Executed-test COUNT used as an adequacy floor (#468): a guardrail asserting "at least N tests
executed" as a coverage proxy. The runner counts theory data rows, not behaviours — one
[Theory]with N[InlineData]rows clears it while proving one behaviour, and raising N does not fix it. Fix: a behaviour manifest — one clause per required behaviour, which ratchets as later waves land the behaviour. Recommend the census predicate, not name discovery (#375): each manifested behaviour observedFailedon the stub tree, then observedPassedafter, read from the runner's own result file. A manifest over--filter … --list-testsoutput asks only "does a test with this name exist?", which a hollow body satisfies exactly as a comment satisfies a token floor — recommend it only where there is no stub tree, and then name it a lower bound. Not the #455 zero-match guard (>= 1test executed), which proves the filter selected something and is legitimate — do not flag that. BLOCKER (it certifies adequacy it cannot certify).
<!-- END ADDED PROBES #468 -->2b. EXECUTE the guardrails — the phase that catches what reading cannot (#479)
Everything above reads scripts and reasons about them. That reasoning runs against a mental model of the target tree, and the mental model is exactly where the errors live — which is why this phase exists and why it is not optional. Measured over one plan: every blocker that reached a live run was found by running something, and none by reading.
Run all three probes. They catch different failures and none subsumes another. A and B execute; C reconciles the pairs execution reports as healthy — it lives here because it is the residual the other two provably cannot see, not because it runs anything. A comes in two resolutions: A gives one bit per SCRIPT, and A₂ refines it to one bit per CLAUSE, which is the only resolution at which a pre-satisfied clause is visible at all (#478).
And before that: YOUR OWN probe is an instrument, and an instrument is calibrated (#580). Probes A,
A₂ and C are commands this pass runs and then reports on. Nothing downstream reads them — they reach a
human only as a sentence saying the probe was clean — so the rule this section applies to the plan's
guardrails applies first to its own commands: an ad-hoc verification is not reportable until its
NEGATIVE case has been observed to bite. Run it against an input you know is bad and confirm it says so.
Measured, from one authoring session: SIX verifications came back green while doing nothing — a parse
checker that printed ok on a broken file (it never parsed), a control-character scan whose class omitted
the \r it was hunting, a mutation whose sed anchors matched zero bytes and then "passed", and a
guardrail clause that read correctly and could not fire. Every one was caught by forcing the negative
case to bite; none by re-reading, which is the whole argument for this section.
This is broader than the #500 paragraph below and does not replace it. #500 is about a probe reporting
no matches — one reading of one shape. #580 covers the positive-result probe that was vacuous: a
count that came back large from a search that never read the file, a mutation that edited nothing, a
tool whose success line prints whatever the input. The full battery — including the stale-artifact
(--no-build ran yesterday's binary), clobbered-exit-code ($(...) resets $? before you read it) and
matched-ITSELF (a leak scan whose pattern matches its own command line) shapes — is
guardrails-domain-knowledge → "The same rule, turned on the AGENT'S OWN instrument". Where a probe's
negative case genuinely cannot be constructed, say so in the report and mark the finding UNVERIFIED
rather than clean: a deferral a reader can see beats a measurement that never happened.
Before any of them: a zero-match probe has TWO readings, and only one of them passes (#500). The mechanical checks in this phase report health as no matches — A₂'s census (a required-present clause is honest only at 0 on the baseline), A₂'s ancestor-token grep, Probe C's de-regexed literal × forbidden pattern sweep — and so do most of §2's token probes. But "no matches" means either the string is absent or the tool never looked at the file, and the output is byte-identical either way. A search that silently skipped its subject returns the same clean as one that read every byte, and you will write it down as verified.
Measured in this repo: rg -c "Adversarial second pass over a generated" . exits 1, no output —
while that exact sentence sits in .claude/skills/guardrails-review/SKILL.md, tracked and not
gitignored. Default ripgrep skips dot-prefixed paths, and every skill this repo ships lives under
.claude/. The same defect shipped inside #500's own filing, which asserts a set of Charter literals
"appear zero times across Guardrails' src, docs, and skills — verified by grep": they appear in
charter/references/handoff.md, which that grep never opened. The false clean was written in the same
paragraph faulting Charter for documenting unverified behaviour, and it reached another team; only a second,
independent grep running beside it caught the disagreement.
Rule: a probe whose PASS condition is "no matches" is not reported until the search is proven to have REACHED its subject. Two moves, and the first alone is not enough:
- Widen the tool —
rg --no-ignore --hidden(or-uuu),Get-ChildItem -Force,git grepfor tracked files. Measured: neitherrgflag alone suffices —--no-ignorealone still misses.claude/…(hidden),--hiddenalone still misses the copies under a gitignoredbin/(ignored), and several probes here deliberately target generated or ignored trees. Widening only closes the skip list you already knew about. - Run a POSITIVE CONTROL — before trusting the zero, search the same subject with the same
invocation for a literal you have already read out of that file, and confirm the expected hit.
This is the half that generalises: it also catches a typo'd path, the wrong working directory, a
--globthat selects nothing, a file the tool judged binary, and the flag you did not know you needed. A control that returns nothing means the zero you were about to trust was never a measurement.
Do not reduce this to a flag checklist — which flag rescues you is tool-specific, and the assumption is
what is wrong. Measured on this box, Get-ChildItem -Recurse reaches .claude/ without -Force (a
dot prefix is not the Windows hidden ATTRIBUTE), so the rule that saves rg is inert for PowerShell and
vice versa. The control is the part that holds across tools.
Carry it into the folder as a finding only where it bites. A guardrail whose PASS is a zero match over a
tree it walks itself — a forbidden-token scan, an assert-absent preflight — has the same two readings, and
that green is the plan's rather than yours. Flag it when the asserted-absent subject plausibly sits under a
path the guardrail's own tool skips by default (BLOCKER where it provably does — an rg-based .sh
guardrail asserting nothing under .claude/ matches a banned pattern certifies a directory it cannot see);
otherwise it is not a finding, and inventing one on every grep teaches the next reviewer to skim. This is
the negative-assertion doctrine (#470 / Probe C) at the instrument layer instead of the clause layer:
there two individually-correct clauses collided; here one correct clause gets a manufactured reading. And it
is #510's shape exactly — proof that is 100% prompt, 0% gate: nothing executes the search that
certifies the absence, so the certification is a claim about a command someone believes ran.
Probe A — baseline (cheap, universal, no author effort). Execute each task's guardrails from the plan's starting workspace and record exit code AND stderr.
- Expect RED. A guardrail that is GREEN before its task runs certifies nothing — every clause is already satisfied, so the task is passable by doing nothing.
- Read stderr, not just the exit code. With
$ErrorActionPreference = 'Continue'an exception is non-fatal: a broken regex in a comment/string-stripping step silently skips the strip and changes what the guardrail means. One such defect made a guardrail unsatisfiable on every attempt while still exiting 1 for a plausible-looking reason. - A script that fails to parse is a dead-end no retry can fix (#473) — the guardrail script is not in
the task's write scope, so the agent cannot repair it and the task burns its whole budget to
needs-human. So is one that crashes on a missing path, or whose--filtermatches nothing. A mechanicalvalidatelint backstops this: GR2056 asks the language's own interpreter to PARSE the file (never to run it, sovalidatestays read-only and CI-safe). Silence is not proof: an absent interpreter or an unsupported language reports nothing at all — so a greenvalidatedoes not retire this probe, and a.shguardrail on a box with nobashwas never checked. - Cost: run the pure-script guardrails first — they take seconds. The ones that invoke
dotnet build/dotnet testare minutes each; run them only when the plan is small or on request, and name the ones you skipped in the Step 6 report so the gap is visible rather than assumed covered.
Probe A₂ — the baseline CLAUSE census (#478). Resolution, not a second opinion. Probe A yields one bit per SCRIPT; the defect is per CLAUSE. Measured: run as authored against the real tree, every pure-script guardrail of the motivating wave exited 1 — and two of them each carried a clause that was already satisfied on arrival, hidden behind its siblings' failures. Probe A reported that wave clean. Never treat a red baseline as a pass.
Census only the clause kinds that have a defect here. A required-present clause (-cnotmatch 'X'
→ fail) must be 0 matches on the baseline; a numeric floor (-lt N) must be below N. A
forbidden-present clause is supposed to be green before its task — do not flag a ban for being
green on arrival; a ban that is RED on arrival is Probe C's #470 collision. Roughly a third of the
corpus's clauses are bans, so inverting this cries wolf on every correctly-authored prohibition. Decide
polarity by what the failure branch DOES, not by the operator alone — GR2057's rule, because
if ($c -match 'x') { $ok = $true } is a REQUIREMENT wearing -match.
Two ways to get a clause's baseline verdict. Take the fast path where the shape allows; census the rest.
- Fast path — read Probe A's own stdout. Where the guardrail uses the house accumulator
(
$failures += …) and the baseline run REACHED the dump, A already printed the list of clauses that fired. Every required-present clause of that script must appear in that list; one missing is pre-satisfied. Free, but partial — on the committed corpus the accumulator is present in 97 of the 237 multi-clause guardrails (the other 140 are early-exit chains), and even there three shapes fall through to the census:- a precondition early-exit fired before the clause block — 87 of those 97 carry one, and on a greenfield baseline it is exactly what fires;
- the clause sits in a cost stage gated behind the dump (the house pattern runs
dotnet testonly after the structural clauses pass, so on a baseline it never executes); - the clause is inside a loop, where no message means "the loop found nothing to complain about" — not the same as pre-satisfied.
- Census — one grep per clause, universal. Lift the clause's pattern and its subject out of the script
TEXT and run them against the baseline tree:
Select-String -Path <subject> -Pattern <pattern>, with-CaseSensitiveiff the operator was-cmatch/-cnotmatch. Record the count. Shape-independent — it works on early-exit chains, on staged scripts, on clauses that never execute, and on a script that does not parse (#473). Census the SAME text the clause reads, or you will manufacture a false finding. Under the two-variable rule a required-present clause matches$code(comments stripped) and a forbidden one matches$scan(comments and string literals stripped) — butSelect-Stringreads the file raw. So for each hit, check where it lives: hits that are entirely inside comments do not pre-satisfy a$codeclause. A raw count of 3 that is 3 comment mentions is zero. (Neither of the motivating instances was excused this way —action.prompt.mdandCriticalityJudgewere both live code.)
Re-MEASURE every declared count; never read one. The catalogue requires each required-present clause to
record its measured baseline count. That number came from the same mental model that wrote the clause — the
motivating instance carried # … appears nowhere else above a token appearing twice in that exact file.
A declared count that disagrees with your census is a BLOCKER on the guardrail, whichever number is more
convenient. A missing declaration is not a finding on its own; it just means you census that clause.
And a script does not only declare COUNTS — it declares BEHAVIOUR about itself, which is a claim to be
TESTED, exactly like a count. Headers state what the script's own guards and preconditions DO: "this
precondition prevents X", "this subsumes Y", "the guard fires when Z", "this check is the reason a
zero-test run cannot pass here". Measured: three such claims were false in one plan, each written in a
header sitting directly above the code it described. The fourth zero-match spelling in §2's #455
sub-check is one of this shape — its header declared the guard prevented precisely the failure the
guardrail then produced. A header comment is the authoring agent's belief, not evidence, and it was
written by the same reasoning that wrote the bug; A₂ exists because a review that re-reads that reasoning
is not a second measurement. So: where the claim is cheap to test, TEST it — construct the input the
claim is about and observe what the script does (§2's #455 sub-check gives the two constructions for a
zero-match guard: a <Results>-less results file, a filter matching nothing). Where it is not cheap,
record it in the Step 6 report as an UNCHECKED GAP — never as verified, and never absorbed into "A₂
applied". Verdict rule is the counts' rule: a declared claim your construction contradicts is a
BLOCKER on the guardrail; a header carrying no behavioural claim is not a finding, it simply leaves
nothing for this rule to grade. This does not soften the exception rule below: a declaration is still
necessary for a pre-satisfied clause to be excused. It is simply never sufficient as proof that a
guard does what its header says.
Verdict — a pre-satisfied required-present clause is a BLOCKER, even beside strong siblings: clause
strength does not compose, because the task only has to satisfy the clauses that are red. The legitimate
exceptions are real — a positive-baseline / wave-entry preflight, a tests-untouched regression clause, the
"if X is present" half of a union-safe conditional (#125/#165), a ratcheting behaviour-manifest clause on
a plan REGENERATED against a partially-landed tree — but an exception counts only if the script DECLARES
it, and the ratchet exception counts only when the regeneration condition actually holds (a fresh plan has
no ratchet to be working; a nonzero manifest clause there is simply pre-satisfied). You are grading the
declaration, not inferring the intent.
What A₂ still does not see. Report these; never let "census applied" absorb them.
- A runtime-composed pattern — built from a variable, an interpolation, or
[char]codes (the corpus has one assembled from[char]92) — cannot be lifted out of the text. Execute that clause in isolation, or record it NOT RUN with the reason. Never as passed. - A clause red on arrival that goes green as a SIDE EFFECT of satisfying a sibling — the census sees red and is content. That is taxonomy 10 at the clause-set level; Probe B op 18 is the check.
- A clause whose subject does not exist on the baseline — trivially red, so the census is vacuous. The ambient-vocabulary test (taxonomy 9), applied to the file the task will create, is all you have.
- A non-pattern clause (
Test-Path, a JSON-shape assertion, a sub-tool's exit code). Ask the same question by hand; there is no mechanical form, and the verdict is still declare-or-flag. - The tree you census is the PLAN's baseline, not the TASK's. A task with ancestors runs against a tree
those ancestors already wrote into, so a clause measured 0 today can be pre-satisfied by the time its own
task starts — and that tree does not exist at review time. This is the deepest hole left, and it is
unclosable by measurement here. The cheap partial: for each required-present clause on a non-root
task, grep the ancestor tasks' prompts and
writeScopes for the same token. An ancestor instructed to write it is a WEAK finding naming both tasks; an ancestor whose deliverable makes it near-certain is a BLOCKER. Report the residual for every task where you did not do this. - Red on arrival and red forever → Probe C. Red on arrival and cheaply gameable → Probe B. A₂ and B are independent, and neither implies the other: the motivating clause was both pre-satisfied and gameable by a one-const append, and each probe is blind to the other's half.
Probe B — the minimal-gaming mutation (the one with teeth). For each task, apply the cheapest edit that satisfies the guardrail's literal text without delivering the capability, then re-run. Expect RED. If it goes GREEN, the task is passable by that edit and the guardrail is the finding.
Measured example: appending internal static class Marker { public const string k = "prompt"; } — one
unused constant, zero capability — took a task's guardrail from 1 finding to exit 0.
The operator set is small and enumerable, which is what makes this mechanical rather than a test of how inventive you feel that day. Work down it:
| # | operator | dies against |
| 1 | append an unused type/const containing the required token | a dotted call, not a bare name (#76) |
| 2 | put the token in a comment — in SOURCE, and, on a documentation target, in an HTML comment (<!-- … -->), which renders as nothing | comment-stripping — including <!-- … --> when the subject is .md/.html (#468; the doc form has its own note below) |
| 3 | put the token in a string literal | string-stripping |
| 4 | satisfy a proximity regex across a statement boundary | keying on the outcome, not adjacency |
| 5 | one omnibus method name satisfying several substring markers | full pinned names, anchored |
| 6 | declare the method instead of forwarding/calling it | requiring _inner.<name>( — the forward itself |
| 7 | assign the member to null or an empty object | excluding = null, requiring the payload |
| 8 | compute the value and discard it (_ = x with { … }) | requiring the assignment back, or the destination |
| 9 | reference the type via nameof in a dead field | a dotted call |
| 10 | name an event/local after the class the clause wants called | a dotted call, again |
| 11 | create the required file empty / a method with the pinned name and an empty body | requiring an emit or any call inside the body |
| 12 | satisfy a --filter with a [Skip]ped test, or let it match nothing | the zero-match guard (#455) |
| 13 | write the token in a form the artifact never uses | see the PRECEDENT check in the catalogue |
| 14 | flip the case of the required identifier (JudgeTier → judgeTier) | -cmatch / (?-i) — PowerShell -match is case-INsensitive, C#/Java/Go identifiers are not (#468) |
| 15 | brace the ifs in the method body, or nest a block inside it | never brace-matching a body in a regex — a (?ms) extractor stops at the first nested close, so brace STYLE decides the verdict (#468) |
| 16 | add or drop a modifier before the declaration (sealed record vs record, async, partial) | the part the language FIXES — the declaration keyword through the name (#468, generalising #112) |
| 17 | write the banned thing in a form the ban never enumerated (non-defaulted, nullable, async, an options object) | banning the CONSTRUCT — the enum member, the type position, the destination — not one spelling (#468) |
| 18 | satisfy every token of a multi-token coverage check with ONE line of real code (var unused = new { r.A, r.B, r.C };) | distinct constructs the outcome implies (a [Fact] per behaviour, a dotted call per collaborator) — comment-stripping is irrelevant here (#468) |
| 19 | clear a "≥ N tests executed" floor with one [Theory] and N [InlineData] rows | a behaviour manifest, never a count (#468) — read with the census predicate (observed Failed, then Passed), since name discovery falls to operator 21 (#375) |
| 20 | satisfy a real-seam / composition-root --filter with a test that constructs the FAKE — same class, same …RealSeam… name, a substituted seam | the test asserting an effect only the production implementation emits (a stream-log FILE on disk, a journal blocker-retried DECISION), never merely that the collaborator was called (#382) |
| 21 | satisfy a covers-* token floor or a name manifest with a test NAMED for the behaviour whose body is a tautology — Assert.True(true), Assert.NotNull on a value the test itself constructed, any assertion that never invokes the subject | the per-test red census — each manifested behaviour's test observed Failed in the runner's own result file on the stub tree, never merely discovered by name (#375). Never a rejection-shaped source regex: a correct Assert.Equal(RejectedStale, r.Outcome) has none of those tokens |
Three patterns generalise and are worth applying before the table: anchor on a USE, not a mention (kills 1, 6, 9, 10, 11), anchor on the DESTINATION, not the value (kills 7 and 8), and anchor on what the LANGUAGE fixes, not on what the author may freely vary (kills 14, 15, 16 — case-sensitivity, brace style, modifier order).
Operator 2 has a DOCUMENTATION-target form, and it is the one that gets missed (#468). Read as "put
the token in a comment", the operator points a reviewer at source files and comment-stripping; a guardrail
whose subject is a .md document reads as immune to it, so the mutation is never tried. It is not immune.
Measured: a guardrail requiring two tokens — one in a large SSOT document, one in a SKILL.md — went
from exit 1 to exit 0 when a single line was appended:
<!-- TODO: document `samples verify` and SampleVerifier here -->An HTML comment renders as nothing. The token is in the file and invisible on the page, so the claim
"the contract is documented" is discharged by a TODO no reader can ever see. Same mechanism as
#97/#98's comment-blind scan at the opposite polarity: there a comment falsely REDS a correct file,
here a comment falsely GREENS an empty claim. Run operator 2 in this form against every
guardrail whose subject is a documentation file, and where it goes green the fix is to strip HTML comments
before matching: $prose = [regex]::Replace($raw, '(?s)<!--.*?-->', '') — measured, that takes the TODO
above to 0 matches while leaving the rest of the document intact.
The counter-rule, because the obvious over-correction is itself a false-red: do NOT flag a FENCED code
block the same way. A fence renders, and documenting a CLI verb or a schema key inside a usage fence
is legitimate house style, not a hidden token. Measured on the real SSOT: 2 of its 36 PlanDefinition
occurrences sit inside one of its 26 fenced blocks — so a "fix" that stripped fences as well would reject
a correct document written in its own voice — the same BLOCKER wearing the other polarity, and Probe C's
two-level stripping rule in a documentation register: strip only as far as the thing a reader cannot see.
Strip <!-- … -->; leave fenced blocks standing.
Operators 20 and 21 are outside all three patterns, and 20 is the only operator that can be
INAPPLICABLE (#382). Outside, because 1–19 all ask what TEXT satisfies the clause, while 20 asks
which OBJECT the test constructs and 21 asks whether the test BODY can fail at all — anchoring on a
use, a destination, or what the language fixes does nothing against either, which is why nothing already
in the table can game a real-seam guardrail or a hollow-bodied test. The mutation is literal: in the
test the guardrail's --filter selects, swap the real seam out of the component's constructor for the fake
its sibling unit test already uses, keep the class and method names, re-run the filter. GREEN means the
filter is selecting a NAME, not a behaviour — the guardrail is the finding (BLOCKER on a
composition-root / production path), and the fix is the archetype's assertion requirement (an effect
only the production implementation emits), never a narrower filter, which only renames the same hole.
Find the proofs by their DECLARATION, never by recognising them (#382 residual). Before operator 20
runs at all, the audit has to know which guardrails ARE real-seam proofs. It used to have only accidental
tells — a filename that appeared as an example in two ledger rows, and (passing-but-blind) inside a
# catches: template — so a correct proof spelled any other reasonable way was invisible, and a review
that found nothing reported the same clean as a review that had nothing to find. Every real-seam proof
now carries both halves of a mandated marker: real-seam in the guardrail basename, and a
# real-seam: <Component> -> <Dependency> bucket=<E|C|U> line in its header (catalogue → "drive-the-real-seam").
Audit it as REFERENTIAL INTEGRITY, both directions — this is the half that runs on a greenfield review. The ledger and the folder are two independent statements of the same fact, so cross them:
- a ledger row whose
proofcolumn names a file that carries no# real-seam:line (or is absent) — the analysis was reported but not emitted; - a guardrail declaring a seam no ledger row carries — a proof placed without the analysis that justifies it, and the row that should have driven T* is missing;
- a declaration whose component/dependency disagree with its row's — recompute T* from the declaration and say which one you believe.
None of that needs the test to exist, which is why it is the greenfield-runnable half of this audit and
why the marker is GR2061's precondition: a lint cannot relate a folder to a ledger while the folder
declares neither which guardrails are proofs nor what they prove. A missing marker is a finding, never a
silent pass — WEAK on its own (the proof may be correct and merely undeclared), BLOCKER when it leaves a
composition-root or production-path seam with no locatable proof at all.
Inapplicable, and reported that way. Probe B mutates the target tree at review time, so operator 20 needs the test to already exist. It applies to a plan being re-reviewed against an existing implementation — a resumed or regenerated plan, an amendment to a landed wave. On a greenfield first review the test has not been written yet, so record the operator as NOT RUN, with that reason — never as passed. A probe that reports "passed" when it could not execute is the exact false green #382 exists to remove, and it is worse than no probe because it consumes the doubt that would otherwise drive a read. The reporting rule above (name the probes you skipped) already covers it; Step 6 carries the line, and "Probe B applied" must not silently absorb an operator that never ran.
Operator 21 is the one you MANUFACTURE, and that is why it works on a greenfield review (#375).
Where 20 asks which OBJECT the test constructs, 21 asks whether the test body can FAIL at all. It is
aimed at the artifact this review cannot see: in the JIT flow the tests are authored at run time, so
the assertions whose correctness matters most do not exist when you read the folder. Operator 20 needs
the test to already exist and is therefore INAPPLICABLE on a first review; 21 has the opposite
posture — you write the mutant yourself. Take the task's enumerated behaviours, author a sample test
file that names every one of them with Assert.True(true) / Assert.NotNull bodies that never touch
the subject, and run the task's covers-* guardrail against it. That is exactly the execution that
produced #375's evidence: on a security wave, covers-security-matrix.ps1 exited 0 against a file
naming every wire token with hollow bodies, and the five load-bearing invariants were pinned by nothing.
GREEN means the floor is a naming lower bound, and the fix is the per-test red census — every
manifested behaviour observed Failed in the runner's own result file on the stub tree (catalogue →
"The per-test red census"; stacks/dotnet.md §4.4). BLOCKER when the task's tests are authored at
run time and pin a security- or safety-load-bearing invariant; otherwise a finding naming the census.
Do NOT recommend a rejection-shaped source regex (Assert\.Throws / Assert\.False /
NotEqual("consumed")) — it is the obvious fix, it was tried as an interim mitigation, and it is worse
than absent. Three reasons, and carry them into the finding so the next reviewer does not re-propose it:
a correct implementation it rejects is trivial (Assert.Equal(AnswerOutcome.RejectedStale, result.Outcome)
is a specific, discriminating security test with none of those tokens); the guardrail is the grader,
so its retry feedback teaches the agent to rewrite a typed-outcome API as a throwing one — a style
mandate that degrades the design it grades; and its false-green side is one line anyway
(Assert.Throws<NotImplementedException>(() => sut.Consume(x)) is perfectly rejection-shaped and
perfectly tautological, plus taxonomy 1/9/18 all apply). The error is promoting a FINDER into a
CERTIFIER: as a review operator the question is exactly right; as a guardrail it certifies a lie.
Operator 21 and Probe A₂ are close relatives — do not conflate them, and run both. Both are per-item censuses that exist because an aggregate exit code hides a pre-satisfied item behind its siblings' failures (#478/#479 for a clause; #375 for a test). They differ in subject and in tree:
| asks about | against | when | |
| Probe A₂ | a guardrail CLAUSE — is it already satisfied before its task runs? | the plan's baseline tree, which exists | now, by reading or grepping |
| Operator 21 | a TEST BODY the run has not authored yet — can it fail at all? | a hollow sample you write, run through the task's own covers-* guardrail | now, by manufacturing the mutant |
Neither implies the other: a clause can be honestly red on the baseline and still be cleared by a hollow test, and a hollow-satisfiable floor can be perfectly red on arrival. Report them separately.
When Probe B keeps landing, the finding is the ARCHETYPE, not the clause (#468). If a task's guardrail asserts a property of implementation source and two or more operators above go GREEN against it, stop patching clauses and ask whether a test could carry the property — that is the demotion gate, and it is the fix. Measured over three review rounds on one breakdown: the test layer was never broken by any agent in any round, every blocker lived in the source-shape layer, and three patch rounds did not converge — round 3 found more blockers than round 2 because each fix landed beside a fresh regression in the same file. A fourth round of clause repair is the wrong move; recommend the demotion.
Probe C — reconcile the clause PAIRS execution cannot separate. A guardrail that is red before and red forever is indistinguishable from a correct red to both probes above: A expects red and gets it, B mutates and it stays red. Both report "healthy". So this probe is read-and-reconcile, not execute — and it is not optional, because each shape below is a certain dead-end, not a weakness. In every measured case the two colliding clauses sat 30–40 lines apart and were edited at different times, and each was individually correct — which is exactly why reading the script top-to-bottom does not find them. Write the pairs down side by side.
| pair to reconcile | the dead-end | verdict |
| every required-present literal × every forbidden-present pattern in the same file (#470) | the required text trips the forbidden pattern, so no file can satisfy both — every attempt fails identically with coherent, actionable, wrong feedback | BLOCKER |
every forbidden-present token × the task's own action.prompt.md (#470) | the prompt uses the banned word, inviting the agent to write the very thing that reds it. Satisfiable, but it cost a full attempt when measured | WEAK (BLOCKER if the prompt hands the agent the token as required vocabulary) |
| every numeric floor × its own filter's cardinality (#484) | an arithmetic dead-end — a zero-match floor exceeding what the filter can ever select | BLOCKER. A mechanical validate lint backstops the provable slice: GR2055 fires when the counted collection is demonstrably the one feeding the filter. It is deliberately CONSERVATIVE — an unrelated array or an unrelated threshold in the same script is not credited — so a green validate clears the provable case only, and the reconciliation is still yours |
every asserted outcome × the task's writeScope (#474) | the guardrail demands something the task is not permitted to write. The membership reading is only half of it — in the measured instance the target file WAS in scope and the value had no route to it; run §2's Unreachable-outcome probe for that half rather than re-deriving it here | BLOCKER |
For the first row, do it mechanically: take each required clause's literal text de-regexed and match
it against each forbidden pattern in the same file. The measured instance was a required
[Trait("Category", "TierResolution")] whose own string literal carried the token a later clause
forbade — its blast radius was three downstream tasks. Fix for both #470 rows: run the forbidden scan
over STRIPPED source (comments and string literals — #97/#98 covers only comments) and anchor the
ban on a USE, not a mention (#76). Check the fix does not create the mirror dead-end: strip in
two levels, not one — required clauses read the comment-stripped text (so a token that legitimately
lives in an attribute or message string can still satisfy them), forbidden clauses read the
literal-stripped text. A "fix" that strips literals for every clause makes the required one
unsatisfiable, which is the same BLOCKER wearing the other polarity. Do not read this as a revert of
#177: GR2026 fires when a guardrail
REQUIRES a token the prompt never mentions; this fires when it FORBIDS a token the prompt DOES use —
opposite polarities, each silent in the other's healthy case. (Catalogue → "A forbidden token must not
collide with what the task REQUIRES".) A mechanical validate lint now backstops the narrowest slice of
this — GR2057 fires when one subject variable carries both a required-present literal and a
forbidden-present pattern that the literal trips. Still run this probe: GR2057 is deliberately silent
wherever it cannot PROVE the collision, and every one of those gaps is yours — clauses over DIFFERENT
subjects (the two-variable $code/$scan fix, which it must not flag), compound -and/-or conditions,
interpolated or composed patterns, anchored forbidden patterns, .sh guardrails, and both the cross-file
and prompt↔guardrail axes. A green validate means the provable case is clear, not that the pair agrees.
3. DAG soundness
- Every edge justified (artifact, guardrail, or explicit ordering — not prose order).
- Missing edges: task B reads a state key or file only task A produces, with no
path A→B. Apply this at the IMPLICIT COMPILATION level too (#176): if B's verification
compiles a test project containing an ancestor test-author task's
.csfile that references a type produced by a non-ancestor implementation task, that is a missing edge — see the "Transitive compilation dependency" probe in §2. - False edges serializing genuinely parallel work.
- A terminal task aggregates (suite green / e2e) so the run has a meaningful end.
- Terminal
<plan>/guardrails/folder on a parallel plan (NOT anintegrationGatesink). A plan with ≥2 leaf tasks or any fan-in (the shape a parallel run produces) MUST carry a non-empty plan-root<plan>/guardrails/folder (the terminal gate run once on the merged plan-branch HEAD, SSOT §3.3) with ≥1 real integration-set re-run — see the four-folder gap probe in §2 for the content bar (GR2028). The retiredintegrationGate: truesink TASK is a GR2029 hard error: a lingering one is the BLOCKER, not its absence. A single linear chain with no fan-in needs no terminal folder. - Waved plan — the DAG is PER WAVE (#254). In a waved plan each wave's
tasks/is a self-contained DAG; check acyclicity, missing edges, and false edges within each wave. Cross-wave ordering is the barrier, not a task edge (a cross-wavedependsOnis GR2034 — see the §2 waved probe). "A terminal task aggregates" becomes per wave: each multi-leaf/fan-in wave's EXIT gate is its aggregation point, and the LAST wave's exit gate is the whole-plan end.
4. Missing-insertion check
Re-apply plan-breakdown Step 5: any guardrail referencing an artifact no ancestor produces and the repo doesn't already contain → a missing guardrail-enabling task.
Point it at the GATE folders too, not just tasks/*/guardrails/ (#474). The subject of this check
is every guardrail in all six folder instances (SSOT §14.3): tasks/*/preflights/,
tasks/*/guardrails/, <plan>/preflights/, <plan>/guardrails/, and on a waved plan
<plan>/<wave>/preflights/ and <plan>/<wave>/guardrails/. Say why out loud, because the
reason is the whole lesson: a gate is a check with dependencies, and it reads as infrastructure.
Measured, on model-tiering-stage-2 — the probe that would have caught the terminal gate's
tierSource clause already existed, right here, and was simply never pointed at the gate. The
clause required a literal in docs/plans/02-schemas-and-contracts.md; no task in any wave declared
that path in any writeScope; it passed validate, graph --check and a full review pass as a
BLOCKER nobody had a reason to open, and the run spent its whole DAG before finding out. Read every
gate script the way you read a task guardrail — as a check whose inputs somebody has to produce.
Mechanically, the producer set widens with the folder, and nothing else about the check changes:
| the guardrail lives in | when it runs | its producer set is |
tasks/<T>/preflights/ | before T's action | T's ancestors — not T |
tasks/<T>/guardrails/ | after T's action | T's ancestors + T — the current reading |
<plan>/<wave-NN>/preflights/ (entry gate) | before the wave's tasks | every task in earlier waves — not this wave's |
<plan>/<wave-NN>/guardrails/ (exit gate) | after the wave's tasks | every task in wave NN and every earlier wave |
<plan>/preflights/ (Full Flight Check) | ONCE before the DAG, against the run's STARTING bytes | nobody — the empty set |
<plan>/guardrails/ (terminal gate) | once at run end, on the merged HEAD | every task in the plan, all waves |
A task is a producer of path P when its writeScope covers P (glob and directory-prefix entries
count — the same membership the harness enforces at write time), or when it stages P as a
stagingOutputs target. If no task in the producer set claims P and the repo does not already
contain the required content today, the gate can never go green: BLOCKER. The fix is give some
task that file in its writeScope, and the work of writing it — or move the clause to the wave whose
tasks own it — or the requirement does not belong in this plan. Never propose deleting the clause
first; a gate that demands the right thing from a plan that cannot deliver it is a planning defect,
and the clause is the only surviving statement of what was wanted.
The preflights/ rows are where this check earns its second finding, and it is the sharper one: a
preflight requiring something the plan itself will build is red at t=0 no matter who declares it —
<plan>/preflights/ halts the run before a single task is scheduled (plan-preflight-failed, SSOT §7),
and a wave entry gate requiring its own wave's output halts that wave at the barrier. A producer
existing later does not help a check that already ran. Verdict BLOCKER, and the fix is a phase
move — the requirement belongs in the matching guardrails/ folder, not a wider scope anywhere.
Two path classes are not findings here, and firing on them is how this check earns a reputation
for noise. (a) Anything under the plan folder — state/, logs/, the journal, diagram.md are
harness-written and appear in no writeScope by design (SSOT: the harness is the single writer of
merged state). (b) Generated, untracked build output — a gate grepping TestResults/*.trx,
artifacts/, bin/, obj/ names something no author would ever put in a writeScope; the producer
there is the toolchain, not a task.
Closure — on a waved plan, check whether you are even allowed to conclude "nobody can write this."
The verdict above is sound only over a closed declaration set: one where every task that will ever
exist in this plan has already declared its writeScope. A plan carrying a declared-but-empty
wave-NN-<slug>/ stub (the JIT one-ahead shape, §2's "JIT stub wave" probe) is open — wave N+1 may
own the file, and "no task can write it" is unprovable. In that case do not file a BLOCKER: record
the requirement as an inherited obligation on the un-authored wave, name the clause and the path in
the Step 6 report, and say that the JIT breakdown of that wave owes it. Conversely, when every declared
wave is authored, the set is closed and the BLOCKER stands. And note the residual honestly: nothing in
a plan folder records how many waves the plan intended, so a plan that lost a wave stub is
byte-indistinguishable from a finished plan (#477) — if your verdict depended on the plan being
finished, say in the report that you assumed it. This caveat does not reach the preflights/ rows: a
future wave's producer cannot help a check that has already run, so a preflight finding stands on an open
plan exactly as it does on a closed one.
The boundary — this is a COVERAGE question, never a size verdict (#378/GR2042). Reading
writeScope as a coverage set — "does any task claim this path?" — is allowed and is what GR2041
already does one level down. What this check must never do is derive "this task is too big" from
writeScope cardinality, or read action.maxTurns or dependsOn fan-in as evidence. That verdict
belongs to §2's Over-scoped-task probe, from its own evidence; when both fire, report both separately
(the §2 "#378 boundary" paragraph governs, and its rule is about which verdict a check derives, not
which field it touches).
No lint backstops this today. GR2041 proves every task declared a scope; nothing in validate
compares a gate's requirements against the union of those scopes. Do not skip a gate because validate
was green — on the measured instance it was.
5. State-contract lint
- Every prompt action carries the harness-contract header block.
- Every state key consumed downstream is produced upstream (or seeded).
- Every state key consumed downstream has a fragment-key-present guardrail on its
producer (reads
GUARDRAILS_STATE_FRAGMENT, asserts non-null/non-empty) — otherwise the action can skip writing the key and the consumer runs with null. (Catalogue state-output leaf.) - State-out key MUST be the task FOLDER NAME, never the
stableId(#164). For every state-writing prompt, read the fragment example/instruction in the## Taskbody and the harness-contract header. The single top-level key must be this task's folder name (the directory thetask.jsonlives in). A fragment example keyed by anything else — most often the task'sstableId(a^[a-z0-9][a-z0-9._-]*$token likej9hf6ythat is NOT the folder name), a foreign task's folder name, or an arbitrary shared key — is a BLOCKER: the harness rejects it as a foreign/unowned key on every attempt (single-writer-per-key, SSOT §6.2), rolling back file writes and dead-ending the task atneedsHuman(the #164 failure loop). Cross-check that the producer's state-output guardrail indexes the same folder name ($fragment.'<folder-name>'.<key>); a mismatch between the prompt's key and the guardrail's index is the same BLOCKER. Fix: rewrite the fragment example to{ "<this-task-folder-name>": { … } }and align the guardrail's index. promptRunnerspresent iff prompts exist;allowedToolsscoped, not blanket. On a multi-task plan (≥2 tasks joined bydependsOn), flag anallowedToolsthat carries stack-specific commands but no read-only git inspection (Bash(git log*),Bash(git diff*),Bash(git show*),Bash(git status*)) — a MINOR finding, not a blocker (plan-breakdown Step 6, #252): without it a downstream task's prompt cannot cheaply inspect what an ancestor task already committed and falls back to broadGrep/Globsweeps. Still do not suggest adding a state-mutating git command (restore,reset,checkout,push,commit,stash) — the read-only default is the right thing to AUTHOR, because on a clean box or in CI the plan's list IS the whole grant. But do not read the omission as a restriction:allowedToolsis a floor, not a ceiling — Claude Code MERGES the harness's--allowedToolswith the operator's~/.claude/settings.json, so a plan's list can only GRANT a capability, never WITHHOLD one. On a box whose settings already allowBash(git checkout:*), a task's prompt can rungit checkouteven though the plan lists no git at all. So never raise — or dismiss — a finding on the premise that leaving a verb out ofallowedToolsmakes it unavailable.- Every statically named model resolves to a runner the config can actually construct — the §2
model-availability probe from the config side: each
promptRunners.<name>.model/guardrailOverrides.modelsits on a block whosekindhas a concrete runner (onlyclaudedoes today, SSOT §9), andpromptRunners.defaultnames a declared block whenever two or more are declared. Report, never rewrite — and report a JIT-resolved judge model as UNCHECKED (#223) rather than passing over it.
6. Report
| Task | Guardrail | Severity | What wrong implementation slips through | Concrete fix |
Severities: BLOCKER (a wrong implementation passes) · WEAK (gameable, nondeterministic-where-deterministic-possible, or unactionable) · NIT. For WEAK prompt-judges, the fix column contains the replacement deterministic guardrail — ideally as ready-to-paste script text.
The report also states what the pass could NOT check — as explicit lines, never silent omissions: an unchecked gap that goes unmentioned is indistinguishable from a verified one. At minimum:
- the model-availability probe's JIT-resolved judge models, deferred to #223;
- the model-appropriateness probe's classification census (#229) — ON A TIERING-CONFIGURED PLAN ONLY: name every prompt-action task and every surviving judge this pass found with no classification of its own, and say plainly that the mismatched-tier half is an OPINION about difficulty rather than a checked fact — a plan with no mismatch finding is not a plan whose rungs were verified. On an unconfigured plan this line is ABSENT — the graceful skip is silence, not a line saying it was silent.
- which guardrails Step 2b actually EXECUTED, and which it skipped — name the toolchain-invoking ones you did not run, and say whether Probe B (the minimal-gaming mutation) was applied per task or only to a sample;
- the classes EXECUTION cannot see (#470 require-and-forbid, #474 unreachable-outcome, #484 arithmetic dead-ends). These are red before AND red forever, so a baseline cannot distinguish them from a correct red. If you hand-checked them, say so; if you did not, say that. For #474 specifically, name the datum clauses you ran §2's Unreachable-outcome probe against and the carrier type you resolved for each — "no datum clauses in this plan" is a fine answer, "Probe C row 4 covered it" is not.
- whether the §4 missing-insertion check was pointed at the GATE folders (#474) —
<plan>/guardrails/,<plan>/preflights/, and each<plan>/<wave>/…pair — as a separate line from thetasks/*/sweep. Not pointing it there is the exact omission that shipped the measured BLOCKER, so "ran over tasks" on its own is an unchecked gap, not a clean gate. On an open plan (a declared-but-empty wave stub), list the gate requirements you recorded as inherited obligations on the un-authored wave, and say that the coverage verdict was withheld rather than passed. - how far the A₂ clause census got, per task (#478) — for each guardrail, whether its required-present
clauses were resolved by the fast path (an accumulator list Probe A actually printed) or by a hand
census, and name every clause left unmeasured with its reason: a runtime-composed pattern, a subject
absent from the baseline, a non-pattern clause, a cost stage that never executed. A red Probe A plus an
unmeasured clause set is not a clean task, and must not be reported as one — that conflation is the
whole of #478. State separately that the censused tree is the PLAN's baseline, not each task's — a
non-root task's clause can be pre-satisfied by an ancestor's output, and no review-time measurement can
see that tree; say whether the ancestor-prompt/
writeScopetextual check was run in its place. - which declared BEHAVIOURAL claims were TESTED, and which were only read (#478 / #455) — a script's
header claims about its own guards and preconditions ("this precondition prevents X", "the guard fires
when Z") are claims exactly as its declared counts are. Name each one you constructed the input for
and what the script then did (exit code, verbatim), and list the rest as unchecked — in particular
every zero-match guard accepted on a read rather than by manufacturing the zero case (a
<Results>-less TRX, a filter matching nothing). Measured: three declared claims false in one plan, each in a header sitting directly above the code it described. A guard reported present-and-correct from its header is indistinguishable in the transcript from one observed to fire, which is the whole reason this line exists. - which zero-match probes carried a POSITIVE CONTROL (#500) — every check whose pass was "no matches" (an A₂ census count of 0, the ancestor-token grep, Probe C's collision sweep, §2's token greps) either names the control literal that proved the search reached the file, or is listed here as unproven. A zero from a search that may never have opened its subject is an unchecked gap, not a clean clause, and the two are indistinguishable in the transcript.
- whether Probe B operator 20 ran, or was INAPPLICABLE (#382) — on a greenfield first review the real-seam test does not exist yet, so the operator is reported not run, with that reason, and is never folded into a blanket "Probe B applied". Reporting it as passed would be the false green the operator exists to catch.
- whether Probe B operator 21 ran, and against which tasks (#375) — name the tasks whose tests are
authored at run time and pinned only by a
covers-*floor or a name manifest, and for each state that you wrote the hollow sample and what the task's guardrail did with it (exit code, verbatim). Unlike operator 20 this one is never "inapplicable": the mutant is manufactured, so a task with a run-authored test file and no census either has a recorded execution here or has an unchecked gap named as one. Where the guardrail exited 0, the finding names the per-test red census as the fix and says in one line why a rejection-shaped regex is not it. - whether the seam ledger was available to this pass at all (#382). A ledger not produced to the
review is an unchecked gap and says so; a ledger whose bolded
Seam ledger (#382)heading is absent is a finding in the table. Do not report either as the other. - every structural claim a prompt makes about the codebase, WITH the command that settled it (#578) —
one line per claim: the prompt, the claim verbatim, the command you ran, its output, and the verdict
(verified / corrected / unverifiable-and-reworded). The command is a required column, not decoration: a
claim marked verified from a re-read and one settled by a
grep -care indistinguishable in the transcript, and the re-read is what shipped the measured defect. Name any claim you judged too expensive to execute as an unchecked gap, and say whether it was reworded as a pointer. "The prompts in this plan make no structural claims" is a fine answer and is stated; silence is not — this is the pass's only gate on the plan's dominant failure mode.
Then ask: "Apply fixes?" — per-finding approval, never bulk-silent. If a finding
concerns a guardrail the human added or edited (check git log/git diff if the
folder is tracked, else say you cannot tell), name that explicitly before proposing
changes to it.
7. Record the review — leave durable evidence, then stamp (#366)
When the review pass is complete (findings reported; fixes applied or explicitly declined), record it so the harness's review nudge clears and a durable audit trail is left behind. Today the pass leaves nothing on disk but the marker itself, so a real review and a bare stamp are byte-identical (#366 §1). Close that gap in three moves — get the hash → write the report → stamp with the report as evidence:
1. Obtain the plan hash (the skill can't compute it). PlanDefinitionHash is computed by the CLI, so
ask for it:
guardrails plan-hash <folder>It prints a single sha256:… line and writes nothing to disk. Capture it as <planHash>; its first 12
hex characters (after the sha256: prefix) are <planHashShort>.
2. Write the review report — the durable evidence. Home it under the plan's hash-excluded state/
tree at:
<plan>/state/reviews/review-<planHashShort>-<reviewedAtCompact>.md(<reviewedAtCompact> is the review's UTC timestamp with punctuation stripped — e.g. hash 1a2b3c4d5e6f
at 2026-06-22T14:03:11Z → state/reviews/review-1a2b3c4d5e6f-2026-06-22T140311Z.md.) The report is
human-readable — its whole point is that a maintainer can later read what the review found. It
contains:
- the Step 6 findings table + the verdict (which BLOCKERs were addressed vs explicitly declined), and
an embedded plan-hash line the CLI parses (F2a) — on its own line, the full
<planHash>verbatim:Plan-Definition-Hash: sha256:…
state/reviews/ is under the tree PlanDefinitionHash EXCLUDES (SSOT §7.3), so the report cannot
re-stale the marker — the same reason the marker itself lives under state/. It is a committed plan
artifact (like the marker), not per-run runtime state, so it belongs under state/, never logs/ (a
review has no runId, and --fresh would wipe logs/).
3. Stamp the marker, passing the report as evidence:
guardrails mark-reviewed <folder> --evidence <report>mark-reviewed runs the F2 stamp-time checks on the report — (a) plan-binding: it must embed a
Plan-Definition-Hash: equal to the current plan hash; (b) path containment: <report> must resolve
under <plan>/state/reviews/ — and on pass records attestation.source: review-artifact plus the
report's reportDigest. On failure of either check it downgrades to source: bare (it never
fabricates a class it can't substantiate) and never refuses the stamp.
Either path form works (issue #430): a relative <report> is resolved against the current
directory first, as any shell path is — so --evidence docs/plans/<plan>/state/reviews/<report>.md
from a repo root is correct — falling back to plan-relative (--evidence state/reviews/<report>.md)
when you are standing inside the plan folder. Absolute paths work unchanged; / and \ are
interchangeable on Windows.
A downgrade prints a WARNING: --evidence did NOT qualify … DOWNGRADING to source: bare block on
stderr naming the resolved path and the reviews root it was checked against, and the OK: line ends
with DOWNGRADED: …. Never let that scroll past — the stamp still exits 0, so the warning is the
only signal your review was recorded as a bare stamp. An F2a downgrade usually means the plan
changed after you ran plan-hash (re-run from move 1 with the fresh hash); an F2b downgrade means
the resolved path (which the warning prints) isn't under state/reviews/ — compare it with the root in
the warning and re-run with the corrected path.
Evidence classes — recorded for AUDIT, not a gate
The stamp records a deterministic attestation.source (read back at read-time as legacy for a pre-#366
marker that has no attestation block):
source | Meaning (what the CLI verified) | Written when |
review-artifact | A review report for this plan was present and passed the F2 checks; its reportDigest is recorded. The only class backed by a durable report. | mark-reviewed --evidence <report> and F2 passes. |
bare | No valid review report backs the stamp — the unchanged manual "I read it" confirmation, or a --evidence attempt that failed F2 (downgraded). Clears GR2025 exactly as before. | mark-reviewed <folder> with no / invalid --evidence. |
machine | An automated flow stamped it (auto-breakdown / autonomous mode) — honestly labeled, never masquerading as human review. | mark-reviewed <folder> --source machine. |
legacy | Read-time only, never written — a v1 marker with no attestation block. | — |
(--reviewer <id> records a self-reported, non-authoritative actor — a name to ask in an audit,
never a trust signal; label it as self-reported wherever surfaced.)
State plainly what the class is — and is NOT. The recorded class is for humans and tooling to inspect
after the fact; it gates nothing — the Scheduler never reads it, and GR2025 stays an advisory warning
(#366 §6; enforce-mode was considered and dropped). It is not a forgery deterrent and makes no
security claim: the marker is only as strong as write-access to the plan folder, and any agent that can
author the plan can author a matching report — there is no unforgeable option in a plain-file model (not
provenance, not a digest chain, not even a signed commit — the autonomous agent holds the key). And the
harness never writes the marker on a human's behalf to fake a human review — a machine stamp is labeled
machine, and mark-reviewed never fabricates a review-artifact class it can't substantiate. The value
is everyday evidence hygiene + an audit trail — telling a real review pass from a bare stamp,
deterministically and on the record, and preserving what the review found — and nothing more. (Any older
"unforgeable" / "raises forge cost" framing of the review floor is withdrawn.)
Waved plan (#254): each wave is a mini-plan with its own WaveDefinitionHash-keyed marker and
its own review report under <plan>/<wave>/state/reviews/. The key is WaveDefinitionHash, not
PlanDefinitionHash (#488): it folds that wave's task hashes plus its own guardrails/**+preflights/**
and excludes the shared plan-root guardrails.json, which is what stops authoring a downstream wave
from re-staling an upstream wave that is reviewed, run, green and unchanged. Two consequences worth
knowing: editing a wave's brief.md DOES re-stale that wave (accepted — a human edit, erring toward
under-attestation), and a plan-root gate edit re-stales no wave once each wave carries its own marker
(#492). Run the three moves against the wave folder —
guardrails plan-hash <folder>/wave-NN-<slug>, write the report under that wave's state/reviews/, then
guardrails mark-reviewed <folder>/wave-NN-<slug> --evidence <report>. When you reviewed the whole plan
wave-by-wave, do this per wave; when you reviewed a single freshly-authored wave (the JIT flow), stamp
just that wave — its marker is keyed on that wave's hash, so re-authoring or resuming other waves does not
falsely mark this one reviewed (and editing this wave's files re-stales just its marker). Do not mark a wave
reviewed while a BLOCKER in it is open.
The marker mark-reviewed writes is the committed, PlanDefinitionHash-keyed state/guardrails-review.json
(SSOT §13 / §7.3). Until the plan's behavioral definition changes, guardrails validate/run stop emitting
the GR2025 "not reviewed" warning; editing any task.json / guardrails.json, an action.* body, or a
guardrail/preflight body or .json sidecar re-stales the marker and the nudge returns. PlanDefinitionHash
covers guardrail/preflight/action BODIES — not just structure/config like the narrower PlanHash — so
editing a guardrail's LOGIC after review (broadening a grep, dropping an assertion, exit 0-ing a check)
NOW re-stales the marker and re-fires GR2025 (#260); bodies are exactly what the review scrutinizes most. The
marker is COMMITTED as part of the reviewed plan: because it is PlanDefinitionHash-keyed it self-stales
the instant any hash-covered file changes — a staleness guarantee (it can never keep vouching for
changed content), NOT a forgery guarantee (an agent with tree access can always re-stamp; #366 §3).
--fresh does NOT wipe the marker or the report — --fresh clears only genuine runtime state (run.json,
state.json, merge-conflicts.log, logs/, captured/). Do NOT mark a plan reviewed while a BLOCKER
finding remains unaddressed.
Hand over the run command, ready to paste (#431)
Once the stamp is recorded and no BLOCKER is open, running the plan is the immediate next step — so end
the report with the command, not with a description of it. This flow used to stop at mark-reviewed and
emit no run command at all, leaving the human to go and find the plan folder path themselves. Note that the
skill already applies exactly this ergonomic care to the DIAGRAM, whose file:// URI gets a Markdown link
so the reviewer can click it (#249/#256); the command the reviewer needs next is the higher-value of the
two and had none of it.
A fenced block, absolute path, quoted:
guardrails run "<absolute plan folder>" --no-merge-on-successand, below it, the delivering form for when that is what is wanted:
guardrails run "<absolute plan folder>"- The safer form leads, and say why.
mergeOnSuccesshas defaulted ON since preview.40 (#340): a green run DELIVERS to the user's branch. A first run of a freshly-reviewed plan is almost always inspect-first, so the delivering form is offered explicitly rather than arrived at by omission. - Absolute and quoted, because a relative path depends on a cwd that is usually not the repo root, and quoting is what carries a Windows path with spaces through the paste.
- When the plan targets THIS repo, name the launcher: the installed global tool, never the repo's
Release binary — a Release-build run self-locks
Core.dlland fails the01-buildguardrail for reasons that have nothing to do with the plan. - A waved plan runs from the PLAN root, not from the wave you just stamped, even when the JIT flow had you review a single wave — the wave folder is not independently loadable (GR1010).
Quality bar
guardrails validateran first; findings don't duplicate the tool.guardrails graph --checkran; exit 2 (stale/missing) → regenerated and noted; exit 1 (error) → surfaced, not silently regenerated.- Every BLOCKER names the concrete wrong implementation, not a vibe.
- (#431) The report ENDS with the run command as a fenced, copy-pasteable block using the resolved ABSOLUTE quoted path —
--no-merge-on-successfirst with the reason stated (mergeOnSuccess defaults ON since preview.40, so a green run delivers), the delivering form offered explicitly below it, the global-tool launcher named when the plan targets this repo, and the PLAN root as the target for a waved plan. A<folder>template is not a hand-over: the reader has to go and find the path, and for a.charter.mdinput it is not even the filename they started from. - Terminal/e2e tasks claiming an output quantity assert a STRICTLY POSITIVE value (no hollow
Assert.Equal(0,…)/NotNull/ bareexit 0); every structural property check is accessor-order-insensitive (no\{\s*get/\{\s*setanchor). - Every WEAK judge finding names its deterministic replacement (or proves none exists).
- Every statically named model (
action.model; each surviving judge's runner-configuredmodel/guardrailOverrides.model; eachpromptRunners.<name>.model) was checked against the ONE block that will carry it (action.runner> frontmatterrunner>promptRunners.default> the sole declared block —action.modelnever selects a runner), and that block'skindhas a concrete runner in this harness version — a model no configured runner can serve is a FINDING naming the task and the model, not a mid-run registry halt: BLOCKER when nothing resolves or thekindis unimplemented (such a config LOADS AND VALIDATES CLEAN, sovalidatenever catches it), WEAK for a provider-family mismatch (a model id has no enumerable valid set to check against). The probe REPORTS, never rewrites. Every judge whose model is resolved just-in-time is reported as UNCHECKED with the reason, deferred to #223, never silently passed over (#224). - Coverage gaps cite the exact unverified completion criterion.
- Every
covers-key-behaviorsguardrail's required tokens are each named (directly or via synonym) in the SAME task's action prompt; a token the guardrail requires but the prompt never mentions is a BLOCKER ("the task will fail every attempt") — the human-judgement complement to the deterministic GR2026 warning (#157). - Every task declares a
writeScope(#389) — an ABSENT field is a BLOCKER (GR2041);"writeScope": []("writes nothing to the repo") is a FIRST-CLASS VALID declaration and is NOT flagged (flag only a truly absent field). Every TDD implementation task'swriteScopeEXCLUDES its test-author task's test files (but may TARGET the stub file the test-author wrote, #155); no task carries a vacuous**/over-broadwriteScope(propose a real surface or[], never omission). - Every inserted test-author task carries the correct TDD "red" for its type (#155): a BEHAVIORAL type has
build-passes+tests-fail-on-stubs(with minimal stubs in itswriteScope), not a lone non-zero-exit red gameable by non-compiling garbage; a split data-model task has a structural[Fact]/[Theory]covers-key-behaviors check. - (#521 gap 1) Every REQUIRED-present clause whose guardrail's
catches:line claims to prove a CALL, an invocation or wiring is anchored on one —\.Member\s*\(, WITH the trailing paren — not on a bare dotted reference. A dotted mention matchesnameof(Type.Member)in a dead field, an XML doc reference, or a string literal, with ZERO invocations. The doctrine already existed in two places and the guardrail that was gamed was written by an agent with it loaded: the word carrying the rule is "call"; the word that gets remembered is "dotted."validatewarns GR2074; an older tool or plan does not. Measured: anameof-only mutant exited 0 while the committed valid sample still passed. - (#521) Every task was asked whether it authors BOTH its tests AND the implementation those tests exercise — the shape the "tests gameable" rule is VACUOUS on (no upstream test-author task ⇒ nothing to exclude ⇒ #155's red-then-green ABSENT ENTIRELY, not weakened). Such a task has no TDD-red half (its census can only be FORWARD — each pinned test observed
-ne 'Passed'→ fail — and a forward census cannot see a hollow body) and no write-scope test-protection gate. BLOCKER on a composition-root / production path (measured: five pinned method names, fourAssert.True(true)bodies and one real call whose production method returns early — exit 0, throughvalidate,graph --checkand a full structural review pass, against a completely unwired implementation); WEAK on its own, BLOCKER wherever the only compensating control is a source-shape grep Probe B can game. The fix is the SPLIT (author-testsupstream ofimplement, plan-breakdown Step 5), never a tighter source-shape regex over the test body — that is the #468 archetype error. After the split, a DECLARED red-census exemption for the discriminator a correct implementation leaves green ("a sound input does NOT halt", green because of the early return) is correct and not a finding; a silently dropped manifest row is the finding. - Every test-author task's
action.prompt.mdcarries a Scope boundary (harness-enforced) paragraph (allowed path(s) +git diffcheck + retry consequence + theneedsHumanredirect for an upstream missing-symbol compile error); absence is WEAK (#154). - Every PROMPT task whose primary deliverable is a file under
.claude/(new or existing) carries the verbatim STRAIGHT-TO-HATCHneedsHarnessWriteescape-hatch instruction in itsaction.prompt.md(emitneedsHarnessWriteto the state-out path FIRST, no directWrite/Editprobe to the.claude/path); absence is a BLOCKER — the tool-permission layer refuses.claude/writes unconditionally, so the task hits the wall on attempt 1 and dead-ends atneeds-human(SSOT §9.3 / #191 / #313 / #321). Exempt: SCRIPT actions, and tasks that declarestagingOutputsfor the deliverable. A task whose deliverable IS.claude/settings.json/.claude/settings.local.jsoncannot use the hatch (the harness rejects permission-file writes on an agent's behalf, #321) — flag it for a human author instead. - Every state-writing prompt's fragment example/key is the task's FOLDER NAME (never the
stableIdor a foreign/shared key), and the producer's state-output guardrail indexes that same folder name — astableId-shaped or otherwise-unowned key is a BLOCKER (harness rejects it every attempt →needsHumanloop, #164). - A brownfield plan (modifies project(s) with existing tests in the touched area, worth-it gate passing) carries the #181 positive baseline as a
<plan>/preflights/POSITIVE check (the general positive-baseline archetype — e.g.01-baseline-<area>-tests-green), NOT a no-op ROOT task: a plan-level Full Flight Check evaluated ONCE before the DAG against the starting repo, running the EXISTING area tests via--filterand asserting they pass (area-scoped, deduped one-per-area, #179-re-emit form); it targets the PRE-EXISTING tests via--filter, NOT the about-to-be-authored red tests and NOT the whole suite (whole-suite scope hits the #165/#176 compile-coupling trap → BLOCKER); it is DISTINCT from the terminal<plan>/guardrails/gate (green START before the DAG vs green END on the merged HEAD). A greenfield plan (or one failing the worth-it gate) has NO baseline preflight (a vacuousdotnet testover a zero-test project is itself a finding). Missing baseline preflight on brownfield is WEAK (BLOCKER when the area's existing tests are in fact red at start). A RED baseline preflight halts the run before the DAG (the general Full-Flight-Check semantics) (#181). - A parallel plan (≥2 leaf tasks or any fan-in) has NO
integrationGate: truesink task — a lingeringintegrationGate: truein anytask.jsonis the BLOCKER (a GR2029 hard error), not its absence — and instead carries a non-empty<plan>/guardrails/folder (the Terminal Gate) with ≥1 real integration-set re-run (a whole-repo build / full suite / union invariant,validateenforces this as GR2028; a folder that merely exists or holds only a tautologicalexit 0certifies nothing → BLOCKER). Itsscope: "integration"union-guardrail is a union-safe CONDITIONAL invariant (conflict-marker-free / "if X present, verify it"), NOT the full build or whole suite: a full-build or whole-suite guardrail markedscope: "integration"in the terminal folder is the #125 terminal-postcondition anti-pattern → BLOCKER (it red-halts correct intermediate unions where downstream TDD tasks have not run yet); the full build/suite must be LOCAL (#165). (scope: "integration"itself is unchanged — the per-union re-verify tag, SSOT §4.3.) - Every
IFoo/FooImplpair has a wiring task + a composition-root guardrail that drives the REAL assembler (no guardrail that injects into the ASSEMBLER's own slot; whole-suite green does not stand in for wiring) (#120). The prohibition is SLOT-SPECIFIC — a #382 real-seam test injecting into the COMPONENT-UNDER-TEST's own constructor is REQUIRED, not a #120 violation (D12, same verb, different slot). - (#382) The seam ledger was audited. The Step 7.4 report carries the bolded
Seam ledger (#382)HEADING — an ABSENT heading is a BLOCKER (the Step 4 analysis never ran), the zero-row form (_No in-process seam is substituted by this breakdown's tests._) is a CLAIM that gets checked rather than an absence, and a ledger not produced to this pass is an unchecked-gap line in the report, never a finding. Everybucketcell is one ofN1N2N3N4ECU, and an N classification off the four-item enumeration is REJECTED (clock / randomness / ambient env reader / wait primitive) — including the N4 trap: if the substitute contains a DECISION it is C, not N4 (RetryLoop → IDelayis N4;RetryLoop → ITransientBackoffis C). Every E/C row's proof sits at a recomputed T* (a later placement is a finding even when the proof exists and passes, and must name T*); everyproofpath is plan-folder-relative with its task segment agreeing with theT*cell; no E row invokes the construction bound (D11 — the #120(b) degradation is bucket C only, and a degraded C row names the constructor chain that forced it); every U row names a receiving task (or, under waves, a receiving wave) that actually exists. The ledger was re-derived from the folder — everyauthor-tests-*task faking an in-process seam the run drives has a ROW, and process seams (child process, CLI, socket, HTTP, DB, filesystem) have none. Severity: BLOCKER when the un-proven seam is a composition-root/production path, WEAK when only a thin terminal join-check covers it. - (#382) Where a real-seam proof EXISTS, its shape holds: a test (rung 1 — no rung-3 source-grep form), asserting an effect only the production implementation emits (a recording double / call count /
Verify, or "the collaborator was called", IS the passing-but-blind shape), atscope: "local"with the key omitted (scope: "integration"here is the #250 mistake), with a #155-real RED that COMPILES. Every terminal composition proof (the #120 wiring task and each<plan>/guardrails/guardrail) names in its# catches:a defect that survives every upstream real-seam proof passing — one that can name none is redundant (propose deleting it), and one whose only defect is "this seam is exercised for the first time here" means a ledger row is MIS-PLACED, fixed upstream and never by a widerwriteScopehere; no row's proof is emitted twice (at T* and again in the sink). A correct real-seam test is NOT a #120 violation (D12 — same verb, different slot: #120 forbids injecting into the ASSEMBLER's slot, #382 requires injecting into the COMPONENT's own constructor; one test doing both is two tests). The #378 boundary held both ways, in its corrected (verdict-based, not field-based) form: #382 derived no SIZE verdict fromwriteScope/action.maxTurns/dependsOn, and #378 added no rule about what a guardrail PROVES — readingwriteScopeas a lookup or a coverage set is not a boundary crossing (doc 18 §6, corrected). - (#382) Probe B operator 20 was applied, or explicitly recorded as NOT RUN with its reason: satisfy a real-seam / composition-root
--filterwith a test that CONSTRUCTS THE FAKE under the same real-sounding name — GREEN means the filter selects a name, not a behaviour (BLOCKER; the fix is the assertion requirement, not a narrower filter). It is INAPPLICABLE on a greenfield first review (the test does not exist yet) and is then reported not run — never as passed, and never absorbed into a blanket "Probe B applied". - (#375) Probe B operator 21 was applied to every task whose tests are authored at RUN TIME and pinned only by a
covers-*token floor or a name manifest: write the hollow sample (every enumerated behaviour NAMED, bodiesAssert.True(true)/Assert.NotNullthat never invoke the subject) and run the task's own guardrail against it. GREEN means the floor is a naming lower bound and the invariants are pinned by nothing — BLOCKER where the invariant is security- or safety-load-bearing. The fix is the per-test red census (every manifested behaviour observedFailedin the runner's own result file), never a rejection-shaped source regex, which false-reds a correctAssert.Equal(RejectedStale, r.Outcome), teaches the agent to rewrite a typed-outcome API as a throwing one, and is satisfied by one tautologicalAssert.Throws<NotImplementedException>line. Unlike operator 20 it is never inapplicable — the mutant is manufactured. Reported separately from Probe A₂: A₂ censuses a clause against the baseline tree, 21 censuses a test body that does not exist yet. - No task carries the structural over-scope fingerprint (GR2042): a
maxTurns-near-ceiling +writeScope≥ ~4 co-occurrence,writeScope≥ ~6, or adependsOnfan-in ≥ ~5 with a multi-filewriteScope— the fan-in-sink / composition-root-wiring archetype. BLOCKER with the proposed split (one task per collaborator wiring; composition-root proof isolated to a thin sink); resolve theguardrails validateGR2042 WARN, don't merely re-report it (#378). On a fan-in sink, test the relocation remedy FIRST (#382): narrowingwriteScopeyields N small tasks that still hold the first exercise of every real path, so the concentration survives the split — but report the two findings separately, from their own evidence, since neither issue's mechanism may read the other's fields. - Every dispatch task routing ≥2 enum values to ≥2 concrete types whose dispatch tests use seam-injection has a per-pairing proximity check binding
<EnumValue>to<ConcreteType>(WEAK if missing; BLOCKER if the only concrete check istests-pass); omitted only when the tests assert the concrete TYPE NAME (#158). - Every forbidden-keyword scan over a source file strips comments before matching; no task both documents banned constructs in a header comment AND greps for them comment-blind (#97, #98). Neutralize string literals BEFORE stripping comments (#561): a
/*spelled inside a string literal opens a phantom block comment running to the next*/in a later literal, blanking everything between — false-RED closed, false-PASS open; measured, 29 of the 31 committed guardrails that do both operations get the order backwards. - Every derived-corpus task asserts input→output coverage + per-output substance floor + index completeness (
produced ⊆ indexed) + ingestion lower bound, named as lower bounds (no judge alone for faithfulness) (#99). - Every
scope:"integration"guardrail is union-safe (passes the "would this pass on a partial merge with a downstream task unsettled?" test, checked against EVERY union point plan-wide — including a merge by a completely unrelated parallel sibling, not just unions structurally upstream of the guardrail's own task in the DAG, #250); terminal postconditions live in alocalguardrail on the sink (#125). - Every set of ≥2 tasks with OVERLAPPING
writeScopes on a shared file has ≥1scope:"integration"guardrail asserting the shared-file UNION invariant — the union re-verify is integration-set-only (#132), so a sibling'slocal-only coverage is NOT re-run at the union; flag WEAK if missing. When the shared file is a CODE file and both siblings could ADD a type/member definition, that union guardrail also carries a duplicate-definition count check ([regex]::Matches($content,'class\s+<Name>').Count -gt 1, union-safe/conditional) — a 3-way merge keeps both copies with no conflict marker (CS0101), the #175 residual; WEAK if absent. - Every task whose verification runs
dotnet build/dotnet testwas checked for a transitive compilation dependency (#176): an ancestor test-author task's.csfile referencing a type produced by a task NOT in the verifying task's ancestor set is a missing edge — add the producing task todependsOn(WEAK, or BLOCKER when the compile failure is certain). - (#474) Every guardrail clause requiring a datum in a file the task owns went through the Unreachable-outcome probe: the carrier expression was resolved in the target file, its declaring type located, and that declaring file confirmed to be in this task's
writeScope— or in an ancestor's, where that ancestor's prompt actually requires adding the member. "The target file is in thewriteScope" is not the check; the measured instance passed it and still dead-ended atneedsHuman. A carrier owned by a non-ancestor, a later task, or nobody is a BLOCKER that names the severed link and the false green the clause invites (a token that satisfies the pattern and carries nothing). Fixes are reachability moves (widen scope / relocate the hop / split it out), never a size verdict. - (#474) The §4 missing-insertion check was pointed at all six folder instances —
tasks/*/preflights/,tasks/*/guardrails/,<plan>/preflights/,<plan>/guardrails/, and each<plan>/<wave>/pair — with the producer set widening to the wave's (earlier waves included) and the plan's whole task set. A gate requirement that no task'swriteScopecovers and the repo does not already satisfy is a BLOCKER (fix: give a task the file and the work, or relocate the clause, or drop the requirement — never delete the clause first). Exempt: paths under the plan folder (harness-written) and untracked build output. On a plan with a declared-but-empty wave stub the coverage verdict is WITHHELD and recorded as an inherited obligation on that wave, never reported as passed. - (#541) For every task whose
writeScopetouches a cross-cutting OUTPUT component (a renderer, serializer, formatter, schema), the WHOLE test tree was searched for goldens pinning that component's output — exact-match assertions, approved/golden files,ByteForByte/Golden/Snapshot/Verbatim/Approvednames — and every hit checked against the UNION of allwriteScopes. A hit no task owns is the finding, whether or not any filter selects it. This is the complement of the #193 row below, not a restatement: that one searches INSIDE task filters, and #455 correctly pushes filters narrow, so the narrower they get the more of the suite falls outside every one of them. Measured: a byte-for-byte log-site golden that no filter in the plan selected halted the Integration baseline preflight AFTER tasks 01–07 had merged green — the review pass ran the #193 probe and cleared it honestly, because the orphan was nowhere its search space reached. The report says WHICH search was run. - Every code-change task whose
tests-passguardrail uses a broad name-substring--filterwas checked for an orphaned pre-existing golden (#193 — the runtime analogue of #176): the filter sweeps in a PRE-EXISTING test (not authored by an ancestor) whose pinned literal/golden/snapshot the task's change plausibly alters, AND that test+golden is outside the task'swriteScopeAND no other task owns re-baselining it → BLOCKER (the task must pass a test it can't edit →needsHumanloop). Fix: narrow the--filterto the task's own tests, widen thewriteScopeto own the golden+test, or add a dedicated re-baseline ancestor task. WEAK when the collision is plausible but not certain. - Every guardrail that asserts a test suite PASSES (
tests-pass/all-tests-pass/specific-tests-pass, or a production-seam driver) re-emits the failure DETAIL at the END of stdout so it reaches the harness retry tail — not just the[FAIL] <name>summary defaultdotnet testleaves (#179); absence is WEAK (degrades retry feedback, costs attempts). The form must be a BLOCK capture (header → summary), not a line allowlist: an allowlist drops theString:/Found:payload and the stack frames, measured (#608) — an allowlist-shaped re-emit is WEAK on its own. No such guardrail carries a QUIET flag on its TEST command (-v q/-v quietondotnet test): measured, it suppresses the entireError Message:/Expected:/Actual:/Stack Trace:block, so even a correct re-emit tails out test names only — WEAK, and quiet belongs ondotnet build. The INVERSEtests-fail-on-stubs/tests-fail-on-current-codechecks (non-zero exit = success) do NOT re-emit and must not be flagged. - Every action prompt that excludes a scenario/keyword ("do NOT include
CommanderRest") has a matching negative-assertion guardrail (if ($content -match "<keyword>") { … exit 1 }, fail-on-present) verifying the keyword is ABSENT (#176); absence is WEAK (BLOCKER when the excluded scenario traps a downstream compile). GR2026 correctly stays silent on the negative assertion's keyword (post-#177, §4.4) — a GR2026 warning there is the false positive, not a reason to delete the guardrail. - Every explicit "do NOT …" statement in a task's action prompt has a matching structural guardrail (a negative assertion, #176, for an excluded keyword/scenario; a regex-lock on load-bearing text surviving verbatim, or a count/forbidden-construct scan for a banned approach/shape) — or the breakdown report states explicitly that the forbidden behavior is not structurally checkable. WEAK when the prohibition is merely uncovered by an otherwise-deterministic suite; BLOCKER when the task's OTHER guardrail is empirical/statistical (a "run N times, assert it always passes" flake check) and the forbidden shortcut would make THAT guardrail EASIER to pass rather than harder — the perverse-incentive case (#221).
- (#578) Every structural claim an action prompt makes about the codebase was EXECUTED, not read — enumeration ("there are N sites" / "the sites are
AandB"), routing ("Afunnels throughB"), exclusivity ("the only caller"), location (File.cs:123), and a DICTATED construct the language decides ("declare it in namespaceN" → compile it). The report carries one line per claim with the command, its output and a verdict (verified / corrected / unverifiable-and-reworded). BLOCKER when the claim is load-bearing and no guardrail in the plan can see it wrong (the measured case: a prompt naming 2 of 9 recorders, faithfully implemented, whole run green); WEAK when merely navigational. A correction rewrites the prompt into the executable form ("grep forXand cover every hit"), never into a fresher list. Every command carried a POSITIVE CONTROL (#500) — a low or zero count from a search that never opened its subject reads exactly like a verified claim. Distinct from #203/#204, which keys on wave placement and covers a claim that goes stale; this one covers a claim that was false when written. - Every task whose prompt references an earlier-wave sibling's code was checked for a stale line-number pointer and an unhedged "here's how it currently works" claim (#203/#204): a cited line number into a file the earlier task will still modify is WEAK/BLOCKER (durable marker instead); an unhedged architecture claim about the sibling's not-yet-run implementation is WEAK/BLOCKER (caveat it as authoring-time state, verify before relying on it). Cross-check the paired
maxTurns: 75bump (Step 4a's fourth archetype) — flag a half-applied fix if only one of the two companion rules was applied. - Every
scope:"integration"union guardrail's expected-contribution tokens are each produced by a task in the integration task's ANCESTOR set (a directed path producer → fan-in); a token whose only producer is a disconnected leaf / side branch is WEAK ("if task<N>is later removed, this guardrail will fail spuriously — add a DAG edge or drop the check") (#159). - Every task ran through the over-size split-trigger; any task bundling multiple deliverables / wide blast radius / 1:1-to-a-milestone / expensive-retry is flagged WEAK with a proposed split (#111).
<!-- BEGIN ADDED CHECKS #74/#75/#76/#96 -->- Every "task A calls
B.Method()" guardrail anchors on BOTH the type reference and the dotted call (\.Method\s*\(), never a bare method-name grep (#76). - Every "extract a library that must write through
IInterface" task has a forbidden-direct-call scan of the library folder — comment-stripped and dot-anchored, never a bare-name grep that false-REDs on a comment (#74). - Every test-author task whose prompt enumerates ≥3 behaviors has a covers-key-behaviors check (2–3 distinctive terms, scoped to the one test file), named as a lower bound, with the unchecked behaviors reported (#75) — and, where the task has a stub tree, a per-test red census (#375): the enumerated behaviours bound to pinned test method names and observed
Failedin the runner's own result file. A suite-exittests-fail-on-stubsbeside a naming floor leaves a hollow test unproven in BOTH directions and is a finding, not a pass. - Every producer↔consumer derived-name seam has a consumer-driven integration guardrail on a both-sides-present task that drives the real lookup for EVERY item and asserts 200 + a per-item marker — union-safe, no hard-coded name copy, no sampling (#96).
<!-- END ADDED CHECKS #74/#75/#76/#96 -->- Every guardrail that pattern-matches/regexes a tool's PRINTED console output (not just its exit code or a file it wrote) was verified by actually RUNNING that tool once against the real repo/workspace and checking the pattern against the real output — not just reasoning about whether the regex looks plausible; a pattern shown to never match the real output is a BLOCKER (the guardrail fails unconditionally, dead-ending every attempt at
needsHuman), a fragile-but-currently-matching format assumption is WEAK. Does not apply to exit-code-only / file-existence / diff checks — there is no output-format assumption to verify there (#248). - Every TASK-LEVEL guardrail running a test filter was cross-referenced against the DAG's dependency EDGES — not read in isolation, which is why #248/#302 (both single-guardrail probes) cannot see this (#455). The scope×edges table was written out with column 4 RESOLVED (the filter run for a real
Total:count where the classes exist, or resolved on paper against prompt-PINNED class names — prompts that do not pin their test class names are themselves a BLOCKER, since no one can then tell what any filter selects), and BOTH directions asked: forward — a filter selecting tests only a DOWNSTREAM task can make green is a BLOCKER (deadlock;validateandgraph --checkboth PASS, the cycle is task↔sibling-test-corpus, not task↔task); inverse — a red check a SIBLING's tests can satisfy is a BLOCKER (tautology; the #155 red proof degraded to merge-order luck). Every task carrying the shape is flagged, not only the one that failed (merge timing decides which mode bites). A concurrent sibling with no edge either way is nondeterministic, not exempt — WEAK, BLOCKER same-wave. Fix:--filter "Category=<PlanTrait>&FullyQualifiedName~<ThisTaskPairsTestClass>"on both halves of the pair (class term mandatory, trait an optional conjunct; the trait ALONE lives only in the #181 preflight's!=exclusion). Sub-checks: the class substring is discriminating (--list-testsenumerates what it really selects;~Dispatchalso selectsDispatchRouterTests), and each narrowed filter carries a zero-match guard that can actually fire — BLOCKER if keyed on theNo test matches…string (suppressed by-v q), onTotal:(counts[Skip]ped tests), on English tokens without pinning$env:DOTNET_CLI_UI_LANGUAGE='en'(the summary is localized), or on a TRX census counting an array-wrapped$null(@($xml.TestRun.Results.UnitTestResult).Countis 1 on a<Results>-less TRX — measured 1 there and 1 on a one-result TRX, so it never fires; observed cost: exit 1 with 11 misdirected findings naming every pinned behaviour as unbound, under a header declaring this guard prevented exactly that — fix| Where-Object { $null -ne $_ }before counting, measured 0/1); the guard's ORDER matches its polarity (forward: exit-code first; inverse: guard first); and no guard was accepted on a READ — the zero case was CONSTRUCTED (a<Results>-less results file; a filter matching nothing) and the guard observed to exit non-zero naming the empty run, or it is named an unchecked gap in the report, never verified. - Every
.sh/.ps1/.pyguardrail that is runnable-at-author-time (idempotent, input in-repo or hand-synthesizable, no live dependency) was smoke-tested by EXECUTING the guardrail SCRIPT itself against a hand-written VALID sample (exit 0) AND a deliberately INVALID one (non-zero) —bash -n/sh -ntreated as a cheap first pass only; the highest-value target (a guardrail that renders/executes the task's own not-yet-authored output) was run against a synthesized sample. FAILS the valid sample or PASSES the invalid sample = BLOCKER; runnable-but-unrun = WEAK; not-runnable-at-author-time (live service / built binary / merged HEAD) = syntax pass + honest report deferral, never a block. Distinct from #248 (which runs the underlying TOOL, not the guardrail script) (#302). - (#254) A waved plan was reviewed WAVE-BY-WAVE (each wave a mini-plan): the §2 adversarial probes ran per task within each wave, and each wave's entry/exit gates got the four-folder treatment. No cross-wave
dependsOnedge (GR2034 — a wave-2 dependency on a wave-1 artifact is the wave-2 ENTRY gate, not an edge; BLOCKER if present). Every waved-plan prompt's state fragment is keyed by the WAVE-QUALIFIED id<waveDir>/<taskFolder>(header + example + state-output guardrail index agree; a bare/wrong-wave key is a BLOCKER, the #164 loop one level up). - (#254) Each wave ≥ 2 has a POSITIVE, positive-monotone-safe ENTRY gate ("prior wave's outputs materialized"; missing = WEAK, negative-polarity = BLOCKER). Each multi-leaf/fan-in wave's EXIT gate satisfies GR2028 (≥1 real integration re-run — a whole-repo build/suite invocation or a git-conflict-marker union invariant). Every wave-root gate must be LOCAL — no
scopekey on any of them. A wave-rootscope:"integration"guardrail is INERT, andvalidatesays so (GR2059, #459): the per-union re-verify set is built from the task<task>/guardrails/folders plus the PLAN-root<plan>/guardrails/folder only (SSOT §4.3), so a wave-root entry is never in it — it runs exactly once, on the merged HEAD at its own wave's exit (SSOT §14.3). The severity rationale here is the OPPOSITE of the intermediate-wave #125 case: an inert tag cannot red-halt a correct intermediate union, because it never fires at a union at all. The defect is the mirror image — the per-union invariant the author believed they had authored is UNPROTECTED, and the plan merely LOOKS union-guarded. Severity: WEAK when the file is a genuine wave-exit postcondition carrying a dead tag (fix = delete thescopekey; behaviour-identical, the check already runs at wave exit); BLOCKER when thecatches:line, the breakdown report, or the plan's topology relies on per-union protection — the real union invariant is then MISSING and must be authored at<plan>/guardrails/, keepingscope:"integration"there and made union-safe/conditional (#125/#165). Do not resolve it by relocating a wave-exit gate to the plan root (that changes WHEN it runs), and do not pre-empt the open #459 contract question. Only the LAST wave's exit gate carries a whole-suite LOCALtests-pass. A declared-but-empty JIT stub wave is NOT flagged as missing tasks; the JIT workflow for it is documented in the breakdown report.
<!-- BEGIN ADDED CHECKS #468/#470 -->- (#468) Every guardrail asserting a property of IMPLEMENTATION SOURCE was run through the demotion question — behaviour → a test (or an AGREEMENT property test for "X must USE Y"), source-shape only for a structural fact with no runtime proxy. A behavioural claim carried by a regex is a finding NAMING the test that should replace it (BLOCKER when a correct implementation can be written that it rejects, WEAK when it merely certifies vocabulary), and a surviving source-shape check with no report line saying WHY no test could carry it is itself a finding. Legitimate structural facts — build-descriptor registration, cross-module reference chains, entry-point wiring, the #120 grep fallback, #176 negative assertions — are NOT flagged. When ≥2 Probe B operators go green against one source-shape guardrail, the finding is the ARCHETYPE, not the clause: recommend the demotion rather than a fourth round of clause repair (three rounds did not converge).
- (#580) Every probe this pass RAN had its negative case observed to bite before its result was reported — including the positive-result probes, not only the #500 zero-match ones. A count was proven to come from a search that actually read the subject; a mutation was proven to have changed the OBSERVABLE, not merely to have been attempted; nothing was read off a stale build or an exit code an intervening command had clobbered. Where a negative case could not be constructed, the finding is marked UNVERIFIED in the report rather than clean.
- (#382 residual) The real-seam proofs were located by their DECLARED marker —
real-seamin the basename plus a# real-seam: <Component> -> <Dependency> bucket=<E|C|U>header line — not by recognising an accidental tell, and the ledger and the folder were crossed in BOTH directions (a row whose named proof carries no declaration; a declaration naming a seam no row carries; a declaration disagreeing with its row). That cross runs on a greenfield review, where operator 20 cannot. A missing marker is reported as a finding — WEAK alone, BLOCKER when it leaves a composition-root or production-path seam with no locatable proof — never absorbed into a clean "Probe B applied". - (#439) The repo's test RUNNER was MEASURED with the
stacks/dotnet.md§6a probe (both clauses — the property/global.jsongrep AND the no-VSTest-adapter negative signal), and the result is stated in the report rather than left implicit, because "no MTP signal found" and "did not look" read identically. If MTP: no guardrail takes its SCOPE fromdotnet test --filter, since MTP ignores the filter and runs the whole suite — defeating §4.3's zero-match guard from the far side (a large count, not zero) and invisible to Probe A/A₂, which is why executing the guardrail does not settle it. - (#493) Every pair of tasks with NO ordering edge between them (same wave, no
dependsOnpath either direction) was checked forwriteScopeintersection, and the pairing table is in the report — a probe satisfied by reading one task at a time misses this by construction, because each task is correct alone. Three shapes: a declared overlap (a directory scope containing another); a shared SINK under scopes that look disjoint (the SSOT, the domain-knowledge skill — the quiet case, and the likeliest); and a single-owner FILE reached through a directory scope and visible only in the PROMPTS (DiagnosticCodes.cs— the exact Stage 1 failure: a run abort, a corrupted SSOT on master, ~$20). Advisory in general; BLOCKER when the intersection is byte-compared or single-owner, where the union CANNOT succeed — andAiMergeResolverresolvesconflictedFiles[0], so a two-file conflict can never be AI-resolved at all (#458). - (#540) No task's
writeScopemixes a.claude/**path with a non-.claude/**one. That is TWO WRITE MECHANISMS in one atomic attempt — the.claude/half only reachable throughneedsHarnessWrite, the other written directly — and a rolled-back attempt can never bank the half it got right (measured: 12 attempts, ~$4.66, never green, on a task that wrote one half correctly at attempt 7 and was failing that same half at attempt 10). It is invisible to every size-based trigger, because the task is small by all of them.validatewarns GR2073; an older tool or an older plan does not. - (#559) Every committed sample pair was checked against the contract the pre-DAG gate enforces — ideally by RUNNING
guardrails samples verify <folder>: each sampled guardrail honoursGR_SUBJECT/argv[0], a multi-subject guardrail letsGR_SUBJECTreplace the WHOLE subject list, and no sample is an orphan (an extra case readsX.invalid-<qualifier>.cs, neverX.<qualifier>.invalid.cs). BLOCKER: a pair that fails this halts the run before task one. It is invisible to an author who verified by staging the sample into the real target path, which proves the clauses and never exercises the contract — how plan 31 committed eight broken pairs. - (#467) If this session AUTHORED the folder, the adversarial pass was DELEGATED to independent agents — handed the folder cold, with this pass's own findings deliberately withheld — and the results reconciled, with a finding only one pass produced treated as the most worth reading. Diverse lenses, not redundant copies (adversarial + contract). Where the breakdown implements something the maintainer explicitly asked for, that artifact was NAMED to the independent reviewer as a thing to attack. If delegation was not possible, the report SAYS SO and names it as a limitation — a review structurally unable to see assumption-level defects must not read like one that looked and found nothing.
- (#530) No
author-teststask ships a test that SYNTHESISES a two-sided pair (a guardrail body plus a valid and an invalid half) without first asserting the two halves produce DIFFERENT exit codes. The operator was graded, not the intent — PowerShell-matchis case-INSENSITIVE where-cmatchis not, and bashgrep -qis case-sensitive, so one fixture written both ways can discriminate on one OS and not the other. Distinctness, not polarity: a fixture that inverts its pair on purpose is legitimate. The subject is bound the way the RUN binds it (GR_SUBJECT+argv[0]for a task pair;GUARDRAILS_WORKSPACE+ cwd for a plan-root pair), so no body takes its no-subject early exit and returns the same code twice. Nothing downstream covers this: the red census's success condition IS red, so a test that can never pass reads as a test red for the right reason, and the bill arrives as aneeds-humanhalt on the next task. - (#468) Every source-shape guardrail over CODE ships a committed
.valid/.invalidsample pair in atasks/<id>/samples/sibling — NEVER insideguardrails//preflights/, where the loader would treat the fixture as a guardrail (counts toward GR2003, executed at run time, or GR2027) — and BOTH halves were re-run in this pass — the valid half especially, being the only half that can expose a clause that never matches, a false-red on legitimate brace style, or a case mismatch. The valid sample is COMPLETE, not a fragment. DOCUMENTATION deliverables are exempt from the pair (no meaningful invalid sample exists) but NOT from the PRECEDENT check, and the exemption is named in the report rather than taken silently. No guardrail asserts an executed-test COUNT as an adequacy floor (theory rows, not behaviours — use a behaviour manifest, read with the #375 census predicate rather than by name discovery); the #455 zero-match guard is not that and is not flagged. - (#468) Probe B operator 2 was applied in its DOCUMENTATION-target form to every guardrail whose subject is a
.md/doc file — append an HTML comment carrying the required token and re-run. Measured: a two-token doc guardrail (a large SSOT document + aSKILL.md) went from exit 1 to exit 0 on one appended<!-- TODO: … -->line; an HTML comment renders as NOTHING, so "the contract was documented" is discharged by a TODO no reader can see. Fix: strip HTML comments before matching ([regex]::Replace($raw, '(?s)<!--.*?-->', '')). The counter-rule held: a FENCED code block is NOT flagged the same way — a fence renders, and measured on the real SSOT 2 of its 36PlanDefinitionoccurrences sit inside one of its 26 fenced blocks, so banning fences rejects a correct document written in its own voice (the same BLOCKER wearing the other polarity). - (#610) Every test-author prompt's PINNED BEHAVIOUR LIST was read as a SET, not as a list of individually-correct items, and each pair asked: can both hold at once? The shape to hunt is an unconditional guarantee — "X ALWAYS happens to the last/first/only N" — colliding with a sibling that asserts "X NEVER happens to this item" about that same item. Measured on plan 36: sixteen pinned behaviours, four of them individually correct readings of the design, and no implementation could satisfy all four — the terminal phase always rescues
_lastEnqueued, and three zero-attempt assertions each used the LAST emitted row. ~5 attempts, two hittingmaxTurns, then a correctneeds-human. Nothing downstream can recover: the implement task cannot touch the test file (the write-scope gate working as designed) and correctly refuses to weaken the guarantee. This is Probe C's shape one level up — Probe C reconciles clauses inside one guardrail FILE; this reconciles BEHAVIOURS inside one prompt — and it is a judgement call, not a lint, exactly as Probe C's prompt-to-guardrail axis is. NOT statically decidable, so there is deliberately no GR code: a mechanical gate here would look rigorous and certify nothing. - (#601) Probe C's reconciliation was run ACROSS TASKS, not only inside each guardrail file: for every pair of tasks whose guardrails read the SAME file, one task's required-present literal was checked against the other's forbid-present patterns. Whichever runs second fails on work the first was required to do, and cannot fix it without breaking the first. Nothing else in the pipeline has a reading that spans two tasks — Probe C is per-file, #474 traces one datum to its carrier, and the write-scope check asks whether a scope covers a path (on the measured plan, it did).
validatewarns GR2076 where both paths are literal and identical, which is the conservative subset; the pairs it stays silent on (a computed path, a guardrail reading two files) are exactly the ones only a reader can settle. Measured on plan 35 task 13: three attempts and an overwatch intervention on a plan unsatisfiable the moment it was authored. - (#470) Probe C ran: every required-present literal was reconciled against every forbid-present pattern IN THE SAME FILE (a hit is unsatisfiable-by-construction → BLOCKER), and every banned token against the task's own
action.prompt.md(a hit invites the agent to write what reds it → WEAK). Every forbidden scan runs over STRIPPED source — comments AND string literals — and is anchored on a USE, not a mention. Not confused with GR2026/#177, which is the opposite polarity (REQUIRES a token the prompt never mentions).
<!-- END ADDED CHECKS #468/#470 -->- (#478) Probe A₂ ran: every required-present clause and every numeric floor of every guardrail has a BASELINE verdict — resolved by the fast path (an accumulator failure list Probe A actually printed) or by a hand census (
Select-Stringof the clause's own pattern against the clause's own subject, case-sensitive iff the operator was-cmatch/-cnotmatch). A clause already satisfied on the baseline is a BLOCKER (the task is passable without delivering it, and it certifies nothing for the life of the plan) unless the script DECLARES its exception — positive-baseline/wave-entry preflight,tests-untouchedregression, the "if X is present" half of a union-safe conditional, or a ratcheting behaviour manifest on a plan regenerated against a partially-landed tree (the qualifier is part of the exception, not decoration: on a FRESH plan a nonzero manifest clause is not a ratchet, it is a pre-satisfied clause and stays a BLOCKER). Forbidden-present clauses are NOT censused — a ban green on arrival is a correct ban, and a ban RED on arrival is Probe C's #470 collision. Every count a script DECLARES was re-measured, never read (a# … appears nowhere elsecomment sat over a token appearing twice in that exact file); a declared count disagreeing with the census is a BLOCKER. Every BEHAVIOURAL claim a script's own header DECLARES about its guards or preconditions ("this precondition prevents X", "this subsumes Y", "the guard fires when Z") was treated the same way — a claim to TEST, not to read: constructed and observed where cheap (§2's #455 sub-check gives the two constructions), else named in the report as an unchecked gap, never verified from the header. Measured: three such claims false in one plan, each in a header directly above the code it described — a header is the authoring agent's belief, written by the same reasoning that wrote the bug. A claim your construction contradicts is a BLOCKER on the guardrail. Clauses left unmeasured (runtime-composed pattern, subject absent from the baseline, non-pattern clause, ungated cost stage) are NAMED in the report as NOT RUN, never absorbed into a red Probe A. A₂ does not subsume Probe B and B does not subsume A₂ — the motivating clause was both pre-satisfied AND gameable by a one-const append. - No fix applied without explicit approval; human-authored guardrails called out.
- (#229) On a TIERING-CONFIGURED plan — at least one
promptRunners.<name>.routingblock, or a top-leveltieringblock — every prompt-action task and every SURVIVING prompt-judge guardrail (each task'sguardrails/+preflights/, the plan-root pair, each wave's pair) either declares its own rung (action.tier, an explicitaction.model/action.effortpin, or a frontmattertier) or inherits one from a CLASSIFIED actor it guards (SSOT §4.2) — and anything left over is named as an advisory MISSING-CLASSIFICATION finding in the Step 6 report, WEAK/NIT, never a GR code and never a silent auto-fix (DoR §12.6). A plan-widetiering.defaultTierdoes NOT discharge it (readTierOrigin.Task, not the resolved tier — DoR §12.4); script actions and script guardrails are not subjects. Any mismatched-tier finding is labelled an opinion about difficulty and phrased as a RUNG, never as a named model (difficulty maps to a candidate set). On an UNCONFIGURED plan this box is vacuously satisfied and the review says nothing about tiering at all — no finding, no gap line, no note that it was skipped. - The review left durable evidence (#366): the plan hash was obtained via
guardrails plan-hash <folder>(the skill can't compute it), a review report — the Step 6 findings table + verdict + an embeddedPlan-Definition-Hash: sha256:…line (F2a) — was written under the hash-EXCLUDED<plan>/state/reviews/, and the marker was stamped withguardrails mark-reviewed <folder> --evidence <report>(recordingattestation.source: review-artifact, or a downgrade tobareon an F2 failure) — clearing the GR2025 nudge (#79/#131), NOT run while a BLOCKER remained open. The recorded evidence class (review-artifact/bare/machine, read-timelegacy) is for AUDIT, not a gate — the marker is only as strong as write-access to the plan folder, and the harness never writes it on a human's behalf. For a waved plan, run the flow per-wave against<folder>/wave-NN-<slug>(its ownstate/reviews/+ hash) after a single-wave JIT review, or whole-plan after a wave-by-wave pass (#254).
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

