Blind-spot fix #1 (classifier): structural-literal divergences GATE, never conceded as a "fuzz frontier limit"

The generative scope≡role net FOUND the self-close `/` bug all along — `node test/generative.ts html`
printed it — but `isGated` classified a `#24` structural-literal→content divergence found via the FUZZ
strategy as "a standing flat-TM frontier limit → report-only", so it never failed CI. That heuristic
baked a PROVEN-limit assumption (the [[feedback-tm-impossible-proof]] anti-pattern) into the test suite:
it conceded a fixable bug by assumption.

Every structural-literal divergence found this session (value-position, flow-in-key, self-close,
mixed-case raw-text, non-first-item compact) was a fixable depth/structure bug, closed by deriving a
region — never a frontier limit. So gating is now by KIND (the bug class), not discovery STRATEGY:
`isGated` gates every `#23` / `#comment` / structural-literal divergence on every strategy including
fuzz. A genuinely-proven TextMate limit, if ever established, would be excluded by an explicit
fingerprint allowlist, not a blanket strategy concession. Green today (0 such divergences after the
3 fixes); it now turns a FUTURE structural mis-paint into a hard failure that forces a fix.

gap-ledger-selftest's `probeDivergence` found its test divergence via `!isGated` (the old report-only
set) — decoupled to find the self-close by token, matching the real ledger (gap-ledger.ts classifies by
the parse5 oracle, not isGated). Added a classifier-lock assertion (the four real-bug kinds all gate).
26/26 gates green.

Author: johnsoncodehk

test/gap-ledger-selftest.ts

@@ -113,6 +113,15 @@ ok(dropProven, 'drop case: at least one real parser-over-accept is parser-accept
 // and the dual: the oracle-VALID minimal repro is KEPT (not dropped) — the keep/drop split is real.
 ok(classifyKeeps('<A A=""/>'), 'keep/drop split: the oracle-VALID `<A A="">`-shape repro is KEPT (not dropped)');
 
+// ── (C) the CLASSIFIER lock: a structural-literal / anchored-marker / comment divergence GATES (the
+// generative scope≡role gate fails on it), NEVER conceded as a report-only "fuzz frontier limit". This
+// is the blind-spot fix that turns a self-close like the one above into a HARD failure that forces a fix,
+// instead of a tracked known-gap. Gating is by KIND (the bug class), not by discovery STRATEGY.
+ok(isGated({ kind: '#24 structural-literal→content' }), 'classifier lock: structural-literal→content GATES (not report-only)');
+ok(isGated({ kind: 'structural-literal→name' }), 'classifier lock: structural-literal→name GATES');
+ok(isGated({ kind: '#23 anchored-marker misfire' }), 'classifier lock: #23 anchored-marker GATES');
+ok(isGated({ kind: '#comment uncolored' }), 'classifier lock: #comment GATES');
+
 // ── (A) determinism of the rendered artifact: two builds byte-identical ──
 console.log('\n  determinism (two full ledger builds)…');
 const run = () => execFileSync('node', ['test/gap-ledger.ts'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 64 * 1024 * 1024 });
@@ -128,6 +137,9 @@ function probeDivergence(p: Probe, text: string): { target: string } | null {
   let toks; try { toks = tmTokenize(p.tm, text); } catch { return null; }
   const leaves = leafRoles(p.grammar, cst, p.roleOf);
   const vs = collectViolations({ input: text, strategy: 'fuzz', cst, toks, leaves, anchored: p.anchored });
-  const v = vs.find((x) => !isGated(x));
+  // The self-close `/` divergence (a structural-literal→content #24). Found by TOKEN, not by `!isGated`:
+  // the real ledger (gap-ledger.ts) classifies by the parse5 oracle, NOT the gate's isGated predicate, and
+  // a structural-literal divergence now GATES (see the isGated lock below) rather than being report-only.
+  const v = vs.find((x) => x.text === '/');
   return v ? { target: sig(v) } : null;
 }

test/generative-detect.ts

@@ -231,11 +231,15 @@ export function collectCommentViolations(args: { grammar: CstGrammar; input: str
 
 // What GATES vs what is a report-only DISCOVERY (generative.ts's exact predicate):
 //  • an ANCHORED-MARKER misfire (#23) ALWAYS gates.
-//  • a STRUCTURAL-LITERAL→content divergence (#24) gates on the STRUCTURED strategies, but is
-//    report-only on FUZZ inputs (a standing flat-TM frontier limit). The gap ledger lists the
-//    DISCOVERED ones (the !isGated set) — the floor-blind divergences a corpus metric is blind to.
-//  • a COMMENT-uncolored divergence ALWAYS gates: a comment (parser-dropped, highlighter-scoped
-//    `comment.*` by construction) painted as a NON-comment is unambiguous — there is no legitimate
-//    "frontier limit" where an injected comment is not a comment (its position is chosen safe + it
-//    round-trips). On today's correct grammars this finds 0; it CATCHES a future scope regression.
-export const isGated = (v: { kind: string; strategy: string }): boolean => v.kind.startsWith('#23') || v.kind.startsWith('#comment') || !v.strategy.startsWith('fuzz');
+//  • a STRUCTURAL-LITERAL divergence (#24 →content, →name) ALWAYS gates, on EVERY strategy
+//    INCLUDING fuzz. The prior "fuzz #24 = a standing flat-TM frontier limit → report-only"
+//    concession was DISPROVEN: every such divergence found (value-position, flow-in-key, self-close,
+//    mixed-case raw-text, non-first-item compact) was a FIXABLE depth/structure bug, closed by
+//    deriving the region — never a frontier limit. A structural literal (a punctuation / keyword the
+//    parser assigns by construction) painted as content/name is a real bug regardless of HOW it was
+//    discovered, so gate it — don't concede it. (A genuinely-proven TextMate limit, if one is ever
+//    established, is excluded by an explicit fingerprint allowlist, never a blanket strategy.)
+//  • a COMMENT-uncolored divergence ALWAYS gates (same reasoning — no legitimate "frontier limit"
+//    where an injected comment is not a comment). On today's correct grammars this finds 0; it
+//    CATCHES a future scope regression. Gating is by KIND (the bug class), NOT discovery STRATEGY.
+export const isGated = (v: { kind: string }): boolean => v.kind.startsWith('#23') || v.kind.startsWith('#comment') || v.kind.includes('structural-literal');

test/generative.ts

@@ -182,7 +182,7 @@ async function runLang(cfg: LangCfg): Promise<{ name: string; ok: boolean; viola
   //    regressions of a known-fixed shape, and #25 is the testing harness, not a fix for every limit.
   const gated = violations.filter(isGated);
   const discovered = violations.filter((v) => !isGated(v));
-  console.log(`  scope≡role: ${checkedTokens} declared-scope tokens checked · ${gated.length} gated inconsistenc${gated.length === 1 ? 'y' : 'ies'} · ${discovered.length} discovered (fuzz frontier-limit, report-only)`);
+  console.log(`  scope≡role: ${checkedTokens} declared-scope tokens checked · ${gated.length} gated inconsistenc${gated.length === 1 ? 'y' : 'ies'} · ${discovered.length} report-only (allowlisted proven-limits — 0 by default; structural divergences GATE)`);
   // comment-witness coverage: how many injected comment spans were graded (was structurally 0 — a comment
   // is a skip token, dropped by the parser, so it never reached the leaf-walking scope≡role check).
   console.log(`  comment witnesses: ${checkedComments} comment span${checkedComments === 1 ? '' : 's'} graded (highlighter must paint COMMENT) · ${violations.filter((v) => v.kind.startsWith('#comment')).length} uncolored`);