tooling(pm): pin the tenth DECLARED-NARROWER worklist row to its gate's declaration, and require a spelling on that verdict (#15314)

* tooling(pm): give the tenth DECLARED-NARROWER row a spelling, and make that verdict require one

The declaration pin holds a DECLARED-NARROWER record SET-EQUAL to its gate's own
declared hint array, read from the gate source. It reached nine of the ten such
rows: `check-driver-conformance DRIVERS_DIR packages` carried no `spelling`, so
there was no recorded set to compare and the pin skipped it by its own scoping
rule -- while that gate does declare a hint at that root. The row named the
subtree in prose, and nothing held the prose to the array.

Both terms are re-measured together on one tree (commit 2200f8e, tree
b8ebad2), against the gate's own walk driven under an fs recorder rather than
reproduced by hand: 344 of 379 tracked files under the declared subtree are
opened, five manifests are statted, and the declaration errs WIDE by the 30 it
names and the gate never touches. The direction is recorded in the row.

The floor that stops the class growing back: the requirement to carry a spelling
now extends from SPELLABLE-UNDECLARED to DECLARED-NARROWER -- a verdict whose
whole content is a claim about a declaration may not decline to record the set
that claim is about. The self-test asserts it on the live map and on fixture
records, so the rule is proved able to fail.

The gate is not edited: it is correct, and the map recorded less than it judged.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019RfFHiRCSs3JXLK4cwcfox

* tooling(pm): name the offending row when the spelling requirement reds

A bare every() verdict told the next author that some record is unspelled and
not which one. The failure text now names the rows and states the remedy in the
map's own terms: record the population and point the row at it, or the verdict
is one of the two refusals.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019RfFHiRCSs3JXLK4cwcfox

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: claude[bot]

scripts/pm/bare-root-worklist.mjs

@@ -124,8 +124,18 @@ const POPULATION_CONSTANT = /^(?:[A-Z0-9_]*_ROOTS?|[A-Z0-9_]*_DIRS?|POPULATION|[
  *                      than the bare word. The row stays in the sweep because
  *                      the bare root is still not covered — which is correct,
  *                      not outstanding debt.
- *                      ⛔ A record carrying a `spelling` is pinned against the
- *                      DECLARATION as well as the tree: `--self-test` reads the
+ *                      ⛔ Every record MUST carry a `spelling` naming a
+ *                      `SPELLINGS` entry, for the reason this verdict is the
+ *                      one where the requirement bites hardest: its whole
+ *                      content is a claim about a DECLARATION, and a record
+ *                      naming no set records nothing for the declaration pin
+ *                      to compare — it sits outside that pin by construction,
+ *                      not by oversight, keeping its verdict while the gate
+ *                      moves under it. Measured, at the one row that did:
+ *                      #15270. The requirement is held by `--self-test`, the
+ *                      same way it is held for SPELLABLE-UNDECLARED below.
+ *                      ⛔ That record is then pinned against the DECLARATION
+ *                      as well as the tree: `--self-test` reads the
  *                      gate's own hint array out of its source and holds the
  *                      recorded spelling SET-EQUAL to it at this row's root,
  *                      with any deliberate omission NAMED in `omits` and
@@ -272,6 +282,21 @@ const POPULATION_CONSTANT = /^(?:[A-Z0-9_]*_ROOTS?|[A-Z0-9_]*_DIRS?|POPULATION|[
  * (see that verdict's definition above). ⛔ The gate itself is NOT edited from
  * here: it is correct, and the map is what went stale.
  *
+ * ⭐ The TENTH DECLARED-NARROWER row was brought INSIDE that pin on 2026-09-04
+ * (#15270), and it is a repair rather than a re-decision: the verdict is the one
+ * it has carried since it was written and no authorisation sentence is claimed
+ * for it. `check-driver-conformance DRIVERS_DIR packages` carried no `spelling`,
+ * so the declaration pin skipped it by its own scoping rule — while its gate DID
+ * declare a hint at that root, which the row named in PROSE and nothing held to
+ * the array. Both terms are re-measured together on one tree in the row itself,
+ * against the gate's own walk driven under an fs recorder rather than reproduced
+ * by hand. What changes here is the FLOOR: the requirement to carry a spelling
+ * now extends from SPELLABLE-UNDECLARED to DECLARED-NARROWER, so a record whose
+ * whole content is a claim about a declaration may no longer decline to record
+ * the set that claim is about, and the class cannot grow back one unspelled row
+ * at a time. ⛔ The gate is not edited from here either: it is correct, and what
+ * went stale is the MAP, which recorded less than it judged.
+ *
  * ⚠️ One row of that seventeen was re-measured into a DIFFERENT population, not
  * merely fresher digits: #12392 (PR #12423, `69d0e18`) made
  * `check-skills-token-ratchet`'s walk RECURSIVE over whole skill directories, so
@@ -371,6 +396,17 @@ const SPELLINGS = new Map([
     claim: "every file inside a skill's references folder, at any depth",
     holds: (s) => s[0] === 'skills' && s.length >= 4 && s[2] === 'references',
   }],
+  ['driver package files', {
+    // The WHOLE subtree, which is what the gate declares -- and the widest of
+    // the entries here for that reason. Its row's `why` records the direction
+    // that declaration errs in, measured against the gate's own walk: it names
+    // 30 files the gate neither opens nor stats. Recording anything narrower
+    // here would be a claim about a declaration nobody made, which the pin
+    // below refuses in both directions.
+    segments: ['packages', 'drivers', '**'],
+    claim: 'every file at any depth under the drivers directory of the packages root',
+    holds: (s) => s[0] === 'packages' && s[1] === 'drivers' && s.length >= 3,
+  }],
   // ── Multi-hint entries (#14233) — a gate whose declared population is more
   // than one glob at the same root. `holds` accepts whatever any member hint
   // covers; see `hintsOf` and the pin loop below for how the union is asked.
@@ -446,8 +482,37 @@ const TRIAGE = new Map([
   // ── Taken: a strictly narrower subtree ────────────────────────────────────
   ['scripts/check-driver-conformance.mjs DRIVERS_DIR packages', {
     verdict: 'DECLARED-NARROWER',
-    why: 'the literal is a join() component; the real population is the driver subtree, declared '
-      + 'there at 259 of 291 files (89%) instead of 259 of 4903 (5.3%) at the bare root',
+    spelling: 'driver package files',
+    why: 'the literal is a join() component: the gate assembles its scan root from bare '
+      + 'single-segment words, so the extractor sees the top-level word and nothing else, and the '
+      + 'real population is the driver subtree, declared there beside the constant under the '
+      + 'ROOT_DIR_WATCH_HINTS idiom. RE-MEASURED 2026-09-04 (#15270) at commit 2200f8ec, tree '
+      + 'b8ebad25 — both terms together on one tree, never refreshed apart — and the previous '
+      + 'reading (259 of 291, against 4903 at the bare root) is superseded WHOLE, neither term '
+      + 'carried forward. The walk was driven under an fs recorder rather than reproduced by hand, '
+      + 'this gate exporting none of it: discovery takes the immediate children of the drivers '
+      + 'root that carry a manifest and the driver- prefix (five packages today), and every `.ts` '
+      + "file at any depth under each package's src directory is OPENED, node_modules and dist "
+      + 'skipped — 344 of the 379 tracked files under the declared subtree, 90.8%, against 5979 '
+      + 'tracked under the bare root, 5.8%. The five per-package manifests are STATTED rather than '
+      + 'opened, as the existence test that admits a package to the matrix, so 349 of 379 are '
+      + 'reached one way or the other. ⚠️ The DIRECTION the declaration errs is stated rather than '
+      + 'left to the ratio: it errs WIDE, naming 30 files the gate neither opens nor stats — 11 '
+      + 'markdown, 6 tsconfig JSON, 6 config `.ts` sitting beside the manifests rather than under '
+      + 'src, 5 LICENSE, one `.mjs` and one dotfile — and it is nevertheless the only spellable '
+      + 'claim, since collapseHint can express a SUBTREE and not "the src trees inside it". ⛔ The '
+      + 'record is what the gate SPELLS and is not narrowed to the walk: the pin holds it against '
+      + 'the DECLARATION, so a spelling narrower than the array would be a claim about a '
+      + 'declaration nobody made. Until 2026-09-04 this row named that subtree in PROSE only and '
+      + 'was the one DECLARED-NARROWER record with no spelling, so it sat outside the declaration '
+      + 'pin #15201 landed — the gate could widen or drop the hint with every pin in this file '
+      + 'green — which is why the spelling requirement now extends to this verdict. The other '
+      + 'root this gate reads, the case-set directory under the spec package (8 files), stays '
+      + 'deliberately undeclared on its own docblock reasoning: that is a population absent from '
+      + 'the array, not a declared hint the record passes over, so this row carries no `omits`. '
+      + '⛔ The gate is NOT edited from here. The row STAYS in the sweep because the bare root is '
+      + 'still not covered — no arbitrary file at the top of packages/ is reached — which is what '
+      + 'this verdict says and is correct, not outstanding debt',
   }],
   ['scripts/check-logger-receiver-detach.mjs SCAN_ROOTS packages', {
     verdict: 'DECLARED-NARROWER',
@@ -1648,9 +1713,31 @@ function selfTest() {
   // describing the tree. ⛔ The remedy is to re-measure the ROW, never to relax
   // `holds` until it agrees again.
   const spellingRows = [...TRIAGE.entries()].filter(([, v]) => v.spelling);
-  t('every SPELLABLE-UNDECLARED record names a spelling — the verdict is DEFINED only with one, '
-    + 'and the ruling that created it rejects the whole option on an unpinned value',
-    [...TRIAGE.values()].every((v) => v.verdict !== 'SPELLABLE-UNDECLARED' || Boolean(v.spelling)));
+  // The two verdicts whose whole content is a claim only a spelling records, so
+  // a record without one records nothing for the pins to hold. SPELLABLE-
+  // UNDECLARED says a precise live spelling EXISTS, unpinnable while unspoken;
+  // DECLARED-NARROWER says the GATE DECLARES one, which the declaration pin
+  // below can compare only against a recorded set. #15270 measured what the
+  // second gap costs: the tenth DECLARED-NARROWER record named its subtree in
+  // PROSE only, so it sat outside that pin by construction while its gate did
+  // declare a hint at that very root — and nothing in this file reddened.
+  const SPELLING_REQUIRED = new Set(['SPELLABLE-UNDECLARED', 'DECLARED-NARROWER']);
+  const spellingHeld = (v) => !SPELLING_REQUIRED.has(v.verdict) || Boolean(v.spelling);
+  const unspelled = [...TRIAGE.entries()].filter(([, v]) => !spellingHeld(v)).map(([k]) => k);
+  t('every SPELLABLE-UNDECLARED and every DECLARED-NARROWER record names a spelling — both '
+    + 'verdicts are DEFINED only with one, and the ruling that created the first rejects the '
+    + `whole option on an unpinned value${unspelled.length
+      ? ` — UNSPELLED: ${unspelled.join(' · ')}. Record the population as a SPELLINGS entry and `
+        + 'point the row at it, re-measuring BOTH terms on one tree; a row that cannot be spelled '
+        + 'is a row whose verdict is one of the two refusals.' : ''}`,
+    unspelled.length === 0);
+  t('…and that rule can FAIL, asked of FIXTURE records rather than of the map it judges: a '
+    + 'record carrying either verdict and no spelling is REFUSED, while the two refusals — which '
+    + 'have no spelling to record — are not',
+    !spellingHeld({ verdict: 'DECLARED-NARROWER' })
+      && !spellingHeld({ verdict: 'SPELLABLE-UNDECLARED' })
+      && spellingHeld({ verdict: 'REFUSE-WIDE' })
+      && spellingHeld({ verdict: 'REFUSE-UNSPELLABLE' }));
   t('every recorded spelling names a SPELLINGS entry',
     spellingRows.every(([, v]) => SPELLINGS.has(v.spelling)));
   t('the pins below judge something — at least one record carries a spelling',
@@ -1709,11 +1796,13 @@ function selfTest() {
   //                          every run: an omission the gate stopped declaring
   //                          reds exactly as loudly as one it started.
   //
-  // ⛔ Only DECLARED-NARROWER rows carrying a `spelling` are asked, and that is
-  // a definition rather than an exemption: a SPELLABLE-UNDECLARED row IS the
-  // row whose gate declares nothing for that population, so the comparison
-  // there has its answer built into the verdict, and a row with no spelling
-  // records no set to compare. ⛔ When this reds the remedy is to re-measure
+  // ⛔ Only DECLARED-NARROWER rows are asked, and that is a definition rather
+  // than an exemption: a SPELLABLE-UNDECLARED row IS the row whose gate
+  // declares nothing for that population, so the comparison there has its
+  // answer built into the verdict. The `spelling` test in the loop is belt to
+  // the braces above, which now REFUSE such a record rather than let it pass
+  // over this pin unjudged (#15270) — reaching it would mean that rule had
+  // been removed. ⛔ When this reds the remedy is to re-measure
   // the ROW -- never to extend `omits` until it agrees again, which is the same
   // move as relaxing `holds`, refused above in as many words.
   const declaredHintsAt = (file, root) => {