enhance(#1279): project check_violation_fixture scalar — #1278 locate + #1279 proof compose end-to-end (#1346)

Delivers option (a) from the #1314 maintainer review: thread a fourth flat
scalar check_violation_fixture through the projection so a prohibition authored
at spec-phase machine-proves fail-first and greens through the deterministic
path alone — zero hand-authoring at verify time.

- src/probe-core.cts: Prohibition gains check_violation_fixture?; projectProhibitions
  emits it (both kinds) ONLY for a well-formed descriptor and ONLY when non-empty
  (blank/absent -> projects absent -> producer hard-gates, never a partial green).
- src/prohibition-enforcement.cts: descriptorFromProjection reads it back into
  violationFixture via the same numeric-coercion-safe scalar() normalizer.
- Tests (RED-first, proven non-vacuous by reverting both src edits): CHK-02(#1346)
  projection emit, CHK-08(#1346) read-back, CHK-03(D) example round-trip, the
  fast-check round-trip property extended to the 4th scalar (the contract trek-e
  blocked #1301 on), and a real-subprocess COMPOSE capstone greening end-to-end
  through project -> descriptorFromProjection -> default prover+runner.
- Docs flipped from 'hard-gates until #1346' to 'composes end-to-end': verify-phase.md,
  prohibition-probe.md, spec-phase.md authoring, ADR-550 addendum, changeset.
  #1346 now tracks only the node-test causation residual.

190 affected-suite tests green; eslint + tsc clean; size baseline regenerated.

src/probe-core.cts

@@ -299,6 +299,10 @@ export interface Prohibition {
   check_kind?: 'node-test' | 'lint-rule';
   check_target?: string;
   check_rule?: string;
+  // Optional 4th flat scalar (#1346): the path to a KNOWN-BAD subject the #1279 prover runs the check
+  // against to MACHINE-PROVE fail-first. Projected only alongside a well-formed descriptor; absent ->
+  // the producer hard-gates (green requires a fixture). Mirrors `CheckDescriptor.violationFixture`.
+  check_violation_fixture?: string;
 }
 
 /**
@@ -376,6 +380,13 @@ export function projectProhibitions(
       if (kind === 'lint-rule' && typeof p.check_rule === 'string' && p.check_rule.trim() !== '') {
         entry.check_rule = String(p.check_rule);
       }
+      // `check_violation_fixture` (#1346) rides BOTH kinds — it's what the #1279 prover machine-proves
+      // fail-first against. Emit ONLY a non-empty fixture (a blank one projects absent so green still
+      // hard-gates downstream — never a partial green); meaningless without the descriptor, so it lives
+      // inside this well-formed-descriptor branch.
+      if (typeof p.check_violation_fixture === 'string' && p.check_violation_fixture.trim() !== '') {
+        entry.check_violation_fixture = String(p.check_violation_fixture);
+      }
     }
     out.push(entry);
   }

src/prohibition-enforcement.cts

@@ -90,7 +90,8 @@ export interface CheckDescriptor {
  *   - `null`/`undefined`/non-object input -> `null`.
  *   - `check_kind` ABSENT -> `null` (no descriptor -> producer locates nothing -> fail-closed).
  *   - `check_kind` present -> `{ kind: check_kind, target: check_target }`, adding `rule: check_rule`
- *     ONLY when `check_rule` is a non-empty string.
+ *     ONLY when `check_rule` is a non-empty string, and `violationFixture: check_violation_fixture`
+ *     ONLY when that scalar is a non-empty string (#1346 — composes #1278 locate with #1279 proof).
  *   - `failFirst` is NEVER sourced from the projection — it stays a verify-time caller attestation
  *     (#1279 machine-proves it; out of scope here). The returned descriptor carries no `failFirst`.
  *   - The adapter does NOT strictly validate kind/target/rule: it faithfully reconstructs whatever
@@ -121,6 +122,12 @@ export function descriptorFromProjection(
     const rule = scalar(projected.check_rule);
     if (rule.trim().length > 0) descriptor.rule = rule;
   }
+  // `violationFixture` (#1346) rides BOTH kinds — reconstruct it from `check_violation_fixture` so the
+  // deterministic #1278 locate path and the #1279 machine-proof COMPOSE: a projected fixture lets the
+  // default prover green end-to-end with zero hand-authoring. Absent/blank -> no fixture -> the prover
+  // hard-gates (fail-closed; green requires a fixture), never fabricated.
+  const fixture = scalar(projected.check_violation_fixture);
+  if (fixture.trim().length > 0) descriptor.violationFixture = fixture;
   return descriptor;
 }