enhance(verify-phase): deterministic auto-locate of the prohibition check descriptor (#1278) (#1301)

* test(1278): RED-first descriptor parity + fail-closed guards + CHK-07 byte-stability (wave 1)

- CHK-03 (RED): extend PROB-14 parity in prohibition-probe.schema.test.cjs to carry the flat
  check_kind/check_target/check_rule scalars through project->write->parseMustHavesBlock; the
  non-droppable check_kind-presence assertion is the load-bearing RED trigger (fails because
  projectProhibitions strips check_* on the current build).
- CHK-07 (GREEN forward-guard): probe-core.test.cjs pins descriptor-less byte-stability +
  dispositionForProhibition fail-closed policy, with a t.todo marker forward-locking plan 01-02.
- CHK-06 (RED): prohibition-enforcement.test.cjs asserts descriptorFromProjection export +
  fail-closed on absent/partial/unknown descriptors via the projection adapter (RED until 01-03).
- No src/*.cts or .cjs edits; no new test files; lint-test-file-count clean.

* feat(1278): add optional flat-scalar check descriptor fields to Prohibition interface (wave 2)

- check_kind?/check_target?/check_rule? mirror CheckDescriptor.kind/target/rule (minus caller-attested failFirst, #1279)
- optional so existing Prohibition consumers compile unchanged

* feat(1278): project check descriptor as flat scalars in projectProhibitions (wave 2)

- emit check_kind/check_target (+ check_rule only for lint-rule with a rule) when descriptor well-formed
- under-specified/descriptor-less items project byte-identically (CHK-07); flat scalars ride existing parseMustHavesBlock continuation-KV path (no parser rewrite)
- add CHK-02 probe-core unit cases pinning the projection
- turns CHK-03 parity test GREEN; dispositionForProhibition untouched

* feat(1278): descriptorFromProjection read-back adapter feeds fail-closed locate (wave 3)

- Add descriptorFromProjection(projected) -> CheckDescriptor | null to
  src/prohibition-enforcement.cts: renames the projected flat scalars
  check_kind/check_target/check_rule -> {kind,target,rule?}, or null when
  the descriptor is absent/non-object (no check_kind key).
- failFirst is NEVER sourced from the projection (stays caller-attested; #1279).
- rule is set only when check_rule is a non-empty string; the adapter does NOT
  re-validate kind/target/rule — an under-specified descriptor reconstructs to
  one the EXISTING runProhibitionEnforcement LOCATE guard rejects (located:false,
  never green). The merged #1259 guard stays the single source of fail-closed truth.
- Turns the RED CHK-06 fail-closed tests (plan 01-01) GREEN end-to-end; CHK-03 /
  CHK-07 stay green. CheckDescriptor type, locate guard, dispositionForProhibition,
  and parseMustHavesBlock are unchanged (additive +36/-0).

* feat(1278): verify-phase locates prohibition check from projected descriptor (wave 3)

- request.check kind/target/rule sourced from projected check_kind/check_target/check_rule via descriptorFromProjection, not verifier invention (CHK-05)
- replaces the #1278 author-supplied / tracked-follow-up note with the delivered deterministic-locate behavior
- preserves fail-closed routing: absent/partial descriptor -> never green, hard-gate in both modes
- failFirst stays a verify-time caller attestation; #1279 bounds the remaining fail-first proof

* feat(1278): spec-phase captures wired-check descriptor on test-tier resolution (wave 3)

- Step 5.6 'Keep it' / verification: test path captures check_kind/check_target/check_rule, projected onto must_haves.prohibitions for verify-phase deterministic locate (CHK-04)
- SOFT capture: a test-tier prohibition without a descriptor is still allowed (no hard authoring block); stays fail-closed/flagged downstream
- --auto captures only an unambiguous descriptor, never fabricates a check path
- failFirst NOT captured at spec-phase (verify-time attestation; #1279)
- PROB-06 soft-gate + text-mode (PROB-09) behavior unchanged

* chore(1278): re-baseline workflow size for grown verify-phase + spec-phase prose (wave 3)

- spec-phase.md 28438 -> 30343 (+1905), verify-phase.md 35362 -> 36498 (+1136)
- regenerated via npm run size:baseline (no hand-picked numbers); growth is the #1278 deterministic-locate + descriptor-capture prose
- workflow-size-budget guard green (122/122)

* docs(1278): ratify optional check descriptor in dated ADR-550 addendum + type:Changed changeset

- Append dated 2026-06-15 ADR-550 addendum ratifying the D3 prohibition-item
  shape extension (optional flat-scalar check_kind/check_target/check_rule)
- Document flat-scalar rationale, deterministic projection/read-back,
  fail-closed on partial/invalid/absent, #1279/policy out-of-scope
- Add .changeset/1278-prohibition-check-descriptor.md (type: Changed)

* docs(1278): document optional check descriptor in prohibition-probe reference + FEATURES

- Add 'Optional wired-check descriptor (deterministic locate, #1278)' section
  to the prohibition-probe reference (flat-scalar keys, projection/read-back,
  fail-closed + backward-compat, failFirst stays attested)
- Add deterministic prohibition-check descriptor source entry to FEATURES.md
- No CONTEXT.md glossary change: descriptor reuses existing wired-check /
  verification:test vocabulary, no new glossary term introduced

* fix(1278): pass packaging gates — changeset pr field + retired slash-form fix

- Add required pr: 1278 to changeset (lint:changeset MISSING_PR hard requirement;
  plan's 'omit if unknown' was inaccurate — issue number per #1259 convention,
  updated to real PR number when opened) [Rule 3 - blocking]
- Fix retired /gsd-spec-phase -> /gsd:spec-phase at verify-phase.md:83 (wave-3
  prose; caught by slash-namespace invariant #3443/bug-2543, blocked CHK-09
  full-suite-green) [Rule 1 - bug]
- size:baseline + INVENTORY manifest verified in-sync post-build (no diff)

* docs(1278): add check descriptor + descriptorFromProjection to CONTEXT.md prohibition glossary

* fix(1278): harden descriptorFromProjection round-trip (numeric-coercion + stray-rule) per review

- MD-01/LW-01: narrow projected scalars to primitives + String()-coerce, so a
  numeric-looking check_target (parseMustHavesBlock coerces ^\d+$ to number)
  reconstructs as a string and locates instead of silently un-locating; no
  as-string type-lie, satisfies no-base-to-string.
- LW-02: attach rule only for the lint-rule kind (drop a stray node-test rule).
- LW-03: document the optional check_* keys in the reference Output schema.
RED->GREEN tests added in prohibition-enforcement.test.cjs.

* chore(1278): set changeset pr to 1301

* test(1278): add fast-check property for the check-descriptor round-trip + fail-closed (trek-e review)

RULESET.TESTS.property-based-testing: the projectProhibitions -> render ->
parseMustHavesBlock -> descriptorFromProjection chain is a bijective/transformation
contract. Adds 2 fc properties to tests/probe-core.property.test.cjs (no new file;
ratchet stays at 2 for probe-core):
- well-formed descriptors survive the round-trip across the full string domain
  incl. the numeric-coercion case (target/rule reconstruct as strings);
- under-specified/invalid descriptors (absent / target-less / rule-less /
  unknown-kind) are always fail-closed (never green, flagged, unlocated).
Stability is asserted at the descriptorFromProjection layer (the raw parse step is
intentionally lossy for numeric scalars; the shared parser is unchanged).

---------

Co-authored-by: Tom Boucher <trekkie@nomorestars.com>

src/probe-core.cts

@@ -290,6 +290,15 @@ export interface Prohibition {
   resolution: string | null;
   reason: string | null;
   statement: string;
+  // Optional flat-scalar wired-check descriptor (#1278). A resolved test-tier prohibition may carry
+  // these before projection; `projectProhibitions` emits them as the LOCKED flat scalar keys
+  // `check_kind`/`check_target`/`check_rule` that round-trip the EXISTING flat `parseMustHavesBlock`
+  // (a nested `check:{}` object is rejected per IMPL-SCOPING §3 — it flattens through the shared
+  // parser). These mirror `CheckDescriptor.kind/target/rule` (prohibition-enforcement.cts:62) MINUS
+  // the caller-attested `failFirst`, which is deliberately NOT a Prohibition field (#1279).
+  check_kind?: 'node-test' | 'lint-rule';
+  check_target?: string;
+  check_rule?: string;
 }
 
 /**
@@ -329,6 +338,15 @@ export function validateProhibitionResolution(resolution: Resolution<Prohibition
  * and are intentionally NOT projected into the plan block (which is keyed on the must-NOT
  * statement, not the source requirement). A non-array input projects to `[]` (fail-soft on the
  * empty/zero-prohibition case), never a throw.
+ *
+ * An OPTIONAL wired-check descriptor (#1278) projects as the LOCKED flat scalar keys
+ * `check_kind`/`check_target`/`check_rule` (NEVER a nested `check:{}` object; `failFirst` is never
+ * projected). These ride the EXISTING continuation-KV path of `parseMustHavesBlock`
+ * (src/frontmatter.cts:344) with NO shared-parser rewrite (IMPL-SCOPING §3 Option 1). The keys are
+ * emitted ONLY for a well-formed descriptor (valid `check_kind` + non-empty `check_target`; plus
+ * `check_rule` only for a lint-rule that carries one); a descriptor-less or under-specified item is
+ * byte-identical to today (CHK-07), so an under-specified descriptor projects absent and fails closed
+ * at the producer downstream (CHK-06), never as a partial-but-locatable green.
  */
 export function projectProhibitions(
   items: unknown,
@@ -345,6 +363,20 @@ export function projectProhibitions(
     };
     if (p.verification != null) entry.verification = String(p.verification);
     if (p.reason != null && String(p.reason).trim()) entry.reason = String(p.reason);
+    // Optional wired-check descriptor (#1278): emit flat scalars ONLY when well-formed. A valid kind
+    // plus a non-empty target is the minimum; under that bar nothing is emitted (CHK-07 byte-identity,
+    // and the producer fails closed on the absent descriptor — CHK-06).
+    const kind = p.check_kind;
+    const targetOk = typeof p.check_target === 'string' && p.check_target.trim() !== '';
+    if ((kind === 'node-test' || kind === 'lint-rule') && targetOk) {
+      entry.check_kind = kind;
+      entry.check_target = String(p.check_target);
+      // `check_rule` rides only the lint-rule path (node-test never carries one); a lint-rule missing
+      // its rule leaves check_rule absent so the producer's fail-closed locate rejects it (CHK-06).
+      if (kind === 'lint-rule' && typeof p.check_rule === 'string' && p.check_rule.trim() !== '') {
+        entry.check_rule = String(p.check_rule);
+      }
+    }
     out.push(entry);
   }
   return out;

src/prohibition-enforcement.cts

@@ -66,6 +66,52 @@ export interface CheckDescriptor {
   failFirst?: boolean;
 }
 
+/**
+ * READ-BACK ADAPTER (#1278, plan 01-03): reconstruct a `CheckDescriptor` from the flat scalar keys
+ * `projectProhibitions` emits onto a prohibition item (`check_kind` / `check_target` / `check_rule`,
+ * src/probe-core.cts). This is the deterministic bridge from the projected descriptor back into the
+ * merged #1259 producer request — the verify-phase caller reads the projected scalars, this rebuilds
+ * the `{ kind, target, rule? }` request, and `runProhibitionEnforcement`'s EXISTING fail-closed LOCATE
+ * guard (validKind/validTarget/validRule, below) is the single source of fail-closed truth.
+ *
+ * Contract:
+ *   - `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.
+ *   - `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
+ *     scalars are present (e.g. `{check_kind:'lint-rule', check_target:'src/'}` with no `check_rule`
+ *     reconstructs to `{kind:'lint-rule', target:'src/'}`), letting the existing LOCATE guard reject
+ *     an under-specified descriptor (located:false, never green). It does NOT re-implement that guard.
+ *   - Pure, deterministic, no-throw.
+ */
+export function descriptorFromProjection(
+  projected: Record<string, unknown> | null | undefined,
+): CheckDescriptor | null {
+  if (!projected || typeof projected !== 'object') return null;
+  if (!('check_kind' in projected)) return null;
+  // The shared `parseMustHavesBlock` (src/frontmatter.cts) coerces /^\d+$/ scalar values to NUMBERS on
+  // round-trip, so a numeric-looking check_kind/check_target/check_rule arrives here as a number. Normalize
+  // ONLY string|number scalars back to string — a non-scalar (object/array/bool) or absent value yields ''
+  // (never an `[object Object]` stringification, no `as string` lie over a number). This keeps the
+  // descriptor honestly typed and the round-trip lossless across the full string domain; an under-specified
+  // '' target/kind is rejected by the producer's locate guard (fail-closed; never green).
+  const scalar = (v: unknown): string =>
+    typeof v === 'string' ? v : typeof v === 'number' ? String(v) : '';
+  const kind = scalar(projected.check_kind) as CheckKind;
+  const target = scalar(projected.check_target);
+  const descriptor: CheckDescriptor = { kind, target };
+  // `rule` belongs only to the lint-rule kind; a stray check_rule on a node-test descriptor is dropped
+  // (the projector never emits one there — defense in depth). failFirst is NOT sourced here (#1279).
+  if (kind === 'lint-rule') {
+    const rule = scalar(projected.check_rule);
+    if (rule.trim().length > 0) descriptor.rule = rule;
+  }
+  return descriptor;
+}
+
 /**
  * The result a check-runner returns: whether the check genuinely, non-vacuously PASSED. The runner
  * reports only what it can OBSERVE (a real pass) — it does NOT determine fail-first. Whether the