Self-check the .feature form before returning. Run the deterministic form check — the check-suite engine (scripts/check-suite.mts in the spec-gate skill), the executable form of sdd:suite-format-governance — scoped to what you just authored:
node "<spec-gate skill>/scripts/check-suite.mts" --files <the authored .feature path(s)>
Exit 0 = form clean; exit 1 prints each ✗ <file>: <reason>. Fix every violation (a non-boolean/hedged Then, leaked rubric lingo in an untagged scenario, a missing Feature/Then, or missing section comments over the sectioning threshold) and re-run until clean before reporting STATUS: complete. Settling this mechanical bar here spends no cold-judge round on a defect a linter catches every time; the same engine runs fail-closed at the gate (../spec-gate/), so an unfixed violation would block there anyway. If node is unavailable, self-review against the suite-format bar by hand.
A clean form check does not clear an entangled Given. The engine reads form, not apparatus — it reports no violation on a Given whose apparatus reuses the artifact's worked examples. Re-read each authored Given against the test-vector bar by hand and rewrite the apparatus before returning STATUS: complete.
A clean form check does not clear a scenario that cannot fail. The engine reads form, not discrimination — a well-formed Then, and a well-formed @rubric block, are both reported clean when no subject can ever fail them. Apply the miss test (sdd:suite-format-governance) to every scenario and every @rubric dimension you authored: name a plausible wrong subject — a memorizer, a copier, a procedure-follower, a single-brancher — and check that it loses. Name none and the scenario is inert; rewrite it. The wrong subject must be plausible — an empty artifact fails everything and clears nothing. Rewrite any dimension grading presence (a line is emitted), restatement (the doctrine's own words), or procedure (the steps, not the judgment). Rewrite the toothless finding — a Then asserting a signal or finding is raised but not its binding consequence (it withholds the pass, blocks the gate, changes the outcome): name the wrong subject that raises the finding and acts on nothing, then rewrite the Then to assert the consequence. Rewrite the process-Then — a Then asserting how the artifact was produced ("co-developed with the code", "written test-first", "refactored before completing", authoring order) rather than its observable behavior or end-state; nothing in the artifact or a run reveals the authoring sequence, so it can never be a Then — rewrite it to assert the observable behavior instead (sdd:suite-format-governance). Before writing any criterion as a dimension, run the substitutability test (sdd:suite-format-governance): a criterion belongs in a @rubric only if you accept that strength elsewhere may pay for weakness here — otherwise it is not in the sum at all, it is a boolean Then. Write the trade down for each dimension you author or revise, in the same record that carries the cut's reason, naming it and what pays for it — an unrecorded trade is an unowned selection nobody can disagree with. The duty is yours alone: no judge reports a missing record, so nothing catches you skipping it. For a @rubric, sum what each named wrong subject banks (never zero a dimension to make a point): that sum sits strictly under the threshold — a tie passes, since the collapsing Then passes a score at least the threshold. How far under is not a constant: it is your judge's noise at the cut (cSEM), measured by scoring the subject more than once, never decreed here. Ground a dimension or its cut on non-author evidence (cold-instrument doctrine). When you justify a @rubric dimension or its cut with a measurement — an ablation Δ, a discrimination count over N runs — it is admissible only if it is not solely your own: it meets the non-author evidence standard the doctrine Strategist states canonically (sdd:doctrine-loop), never re-listed here. Your own instrument silently assumes the property under test, so a cut grounded on your own measurement alone is not grounded — record that it needs non-author or fresh-adversarial evidence. A measurement grounding no dimension or cut is unconstrained; this governs the evidence, not the cut value (that is the miss-test arithmetic above).
In revise mode, run the substitutability test over the standing @rubric dimensions your CR touches, not only the ones you author. A dimension already in the sum that fails the test is a correction, and a correction is not a deletion: removing it changes the attainable maximum, so the cut it leaves behind is un-re-derived whether or not its number still needs to change. Re-derive that cut as a fresh policy call in the same edit and record its reason against the new attainable maximum; raise one clearance per corrected scenario and never let one blanket approval stand in for each scenario's own cut decision. Route it on the removal — never on whether the diff calls the edit mixed, which the in-scenario shape is not. The full procedure is Correcting a standing rubric (sdd:suite-format-governance). A green form check does not clear this: check-suite.mts reports only the vacuous sum(max) < threshold rubric, and a cut nobody re-derived clears that check every time.
Read your authored scenarios against each other. No two scenarios sharing a When may demand opposite verdicts on one constructible snapshot (sdd:suite-format-governance); narrow one Given to exclude the overlap before returning. Overlapping Givens whose Thens agree, and scenarios whose Whens name different operations, are not contradictions — the bar is the contradiction, never the overlap. Specialization is not contradiction: a general scenario and a specific sibling whose narrower Given carves out an exception do not contradict, even when the general Given does not literally exclude it — a contradiction is a pair with no intended winner. When you are authoring the general Given fresh, state the exclusion anyway; it is clearer. Never retrofit it into a frozen scenario — that is a narrowing that fires Clearance.
Check coverage and mirroring before returning. Every outcome and carve-out the node's ## Use Cases / README states — including an exception named only in prose — must have at least one scenario; do not report STATUS: complete while a stated outcome or carve-out has none — add the missing scenario. A duty specified on one node of a mirrored pair (producer/judge, sender/receiver) must be mirrored on the counterpart node; do not report complete while only one side carries the duty — specify it on the counterpart too (sdd:suite-format-governance).
Also self-run referenced-artifact-exists — check-spec-state.mts in scripts/, scoped to
the spec.md/README.md you just authored or touched:
node "<spec-gate skill>/scripts/check-spec-state.mts" --files <the authored spec.md/README.md path(s)>
Exit 0 = every referenced path resolves; exit 1 prints each ✗ <file>: references nonexistent artifact .... Fix every violation the same way — a broken reference to a skill/engine/artifact
that never existed is a content gap, not a typo to shrug at.
