scope≡role: catch a structural literal painted as a NAME (extends gate-1)

gate-1 flagged a `$punct`/`$keyword` painted as CONTENT (#24). Extend it to also
flag a `$punct` painted as a NAME bucket (entity/variable/support): a `-`/`[`/`:` is
never a named entity, so a flat grammar that leaks a flow region into a block and
paints a sequence `-` as a key name (monogram's YAML explicit-key gap) is caught.
`$keyword` is EXCLUDED from the name class — a keyword legitimately can be a name in
context (the TS `this` parameter is `variable.parameter`), which would false-positive;
content (never valid for a keyword) still flags both. The overlap check already clears
any literal the grammar DECLARES name/content via a scopes-override, so reaching here
means the highlighter invented the class.

Also fix a ledger/check corpus mismatch: gap-ledger.ts generated with the DEFAULT
opts (maxInputs 400) while generative.ts uses GEN_OPTS (1500) — so the ledger could
miss divergences the check reports. The ledger now uses GEN_OPTS (the same corpus).

KNOWN-GAPS.md: 2→3 gaps — the YAML explicit-key divergence now files, ddmin-minimized
to `? a:\n  -` (the `[` was incidental; the real trigger is an explicit-key value's
same-column sequence `-` painted entity.name.tag). 7/7 gated-clean (no $keyword false
positive); deterministic; --check + selftest + agnostic 9/9 green.

Author: johnsoncodehk

KNOWN-GAPS.md

@@ -14,7 +14,29 @@ commits) so the ledger is deterministic and commit-trackable.
 
 Regenerate: `node test/gap-ledger.ts --write` · verify up-to-date: `node test/gap-ledger.ts --check`.
 
-**2 gaps** across 7 grammars · 0 dropped.
+**3 gaps** across 7 grammars · 0 dropped.
+
+## `0b90a1776868` — yaml: structural-literal→name
+
+- **Language:** yaml
+- **Minimal repro:** `? a:\n  -`
+- **Divergent token:** `-` (parser token `$punct`)
+- **Role vs scope:** want **punct**, got **name** (highlighter scope `entity.name.tag.yaml`)
+- **Fingerprint:** `0b90a1776868`
+
+```json
+{
+  "id": "0b90a1776868",
+  "language": "yaml",
+  "kind": "structural-literal→name",
+  "repro": "? a:\n  -",
+  "tokenType": "$punct",
+  "tokenText": "-",
+  "want": "punct",
+  "got": "name",
+  "gotScope": "entity.name.tag.yaml"
+}
+```
 
 ## `525e867dc205` — html: #24 structural-literal→content
 

test/gap-ledger.ts

@@ -52,7 +52,7 @@ import type { CstGrammar } from '../src/types.ts';
 import { generateInputs } from './grammar-gen.ts';
 import {
   type TmTok, type Violation,
-  buildRoleMap, leafRoles, anchoredScopes, collectViolations, isGated,
+  buildRoleMap, leafRoles, anchoredScopes, collectViolations, isGated, GEN_OPTS,
 } from './generative-detect.ts';
 
 // ── language registry — the SAME per-language DATA shape as generative.ts's LANGS, plus an
@@ -247,7 +247,7 @@ async function runLang(cfg: LangCfg): Promise<LangResult> {
   // 1) DISCOVER — generate deterministically, then collect the DISCOVERED (report-only, !isGated)
   //    divergences over the full-document inputs. (The gated ones are generative.ts's hard failures;
   //    on this UNFIXED branch there are none. The ledger files the floor-blind DISCOVERED class.)
-  const inputs = generateInputs(grammar);
+  const inputs = generateInputs(grammar, GEN_OPTS);   // SAME corpus generative.ts checks, or the ledger misses divergences the check reports
   const discoveredVs: Violation[] = [];
   for (const inp of inputs) {
     let cst: CstNode, toks: TmTok[];

test/generative-detect.ts

@@ -153,9 +153,19 @@ export function collectViolations(args: {
     const got = spanBuckets(toks, input, lr.start, lr.end);
     const overlap = [...lr.expected].some((b) => got.has(b));
     if (overlap) continue;                                                  // highlighter painted the declared scope somewhere → consistent
+    // A structural literal (`$punct`/`$keyword`) the parser placed as grammar structure painted as a
+    // CONTENT class (#24) OR as a NAME class (entity/variable/support — a `-` indicator scoped as a key
+    // name when a flat grammar leaks a flow region into a block, monogram's explicit-key `[` gap). Both
+    // are unambiguous: the overlap check above already cleared any literal the grammar DECLARES as
+    // name/content (a scopes-override), so reaching here means the highlighter invented the class.
     const contentGot = [...got].find((b) => CONTENT.has(b));
-    if (lr.lit && contentGot && count < cap) {
-      out.push({ input, strategy, pos: lr.start, text: lr.text, tokenType: lr.tokenType, expected: [...lr.expected].join('|'), got: contentGot, gotScope: innerOf(scopeAt(toks, lr.start)), kind: '#24 structural-literal→content' });
+    // the NAME check is `$punct`-only: a `-`/`[`/`:` is never a named entity, but a `$keyword` legitimately
+    // CAN be (the TS `this` parameter is painted `variable.parameter`, a name) — so keywords are excluded
+    // from the name class to avoid that false positive (content, where a keyword is never valid, stays both).
+    const nameGot = lr.tokenType === '$punct' && got.has('name') ? 'name' as const : undefined;
+    const badGot = contentGot ?? nameGot;
+    if (lr.lit && badGot && count < cap) {
+      out.push({ input, strategy, pos: lr.start, text: lr.text, tokenType: lr.tokenType, expected: [...lr.expected].join('|'), got: badGot, gotScope: innerOf(scopeAt(toks, lr.start)), kind: contentGot ? '#24 structural-literal→content' : 'structural-literal→name' });
       count++;
     }
   }