@tikoci/centrs 0.1.4 → 0.1.6

package/commands/explain/README.md

@@ -9,20 +9,13 @@ a path, with completion-style candidates for building the right command.
 validation): the cheap, safe knowledge tier in front of the runners
 (`execute` / `api` / `retrieve`).
 
-Status: `designed` over `rest-api` and `native-api` — the transports the live
-inspection probes ride; every other cell is `—`. The offline mode is
-protocol-connection-less, and **`centrs explain '<input>'` runs today** (issues #202b
-and #202c): the row stays `designed` because the grid tracks protocol cells and
-offline occupies none. See `docs/MATRIX.md` for the row. A first design round
-(2026-07-19, recorded in #90) settled the surface shape and the offline model;
-the **phase-0 canonicalization grounding lab (#185) is complete and this spec
-is now ratified** — every ratification-gating question was answered with cited
-evidence (see [Phase-0 ratification](#phase-0-ratification-185)). The findings
-folded in below; a few of them **amend** the surface (tristate `containsWrite`,
-an `ambiguous` canonicalizer verdict, a defect-region diagnostics contract, a
-byte-count-preserving coordinate rule, the native-api `:parse` readout). Flag
-names and sizing thresholds stay provisional — those are implementation opens,
-not ratification blockers.
+Status: offline baseline `verified`; live probes over `rest-api` and `native-api`
+`designed`. **`centrs explain '<input>'` runs today**, without a router or CDB.
+[`docs/MATRIX.md`](../../docs/MATRIX.md#offline-analysis) tracks these separately;
+[#90](https://github.com/tikoci/centrs/issues/90) indexes the remaining tasks.
+The spec is ratified on the [phase-0 grounding lab](#phase-0-ratification-185).
+The current finish line is [Offline baseline acceptance](#offline-baseline-acceptance),
+not completion of the live protocol cells.
 Load-bearing rules — envelope, errors, settings precedence, identity,
 validation, protocol selection — live in
 [`docs/CONSTITUTION.md`](../../docs/CONSTITUTION.md).
@@ -62,6 +55,10 @@ validation, protocol selection — live in
 
 ## Where `explain` sits
 
+- **Shared analysis across transports.** The offline result is independently
+  useful to libraries, agents, and editors. Its facts can later accompany
+  other commands' envelopes, irrespective of their transport; the rich
+  analysis is not currently applied as a runner policy gate.
 - **Never executes, never mutates.** All live probes (`/console/inspect`
   highlight/completion/syntax/child and `:put [:parse …]`) are read-only
   inspection. Execution-based probes (required-argument discovery via
@@ -84,6 +81,16 @@ validation, protocol selection — live in
   to **support one**: hover, diagnostics, completion, and semantic-token needs
   of `lsp-routeros-ts`/tikbook are first-class consumers of the export shape.
 
+Normalized source structure is the foundation for possible configuration
+checks. Preserve command order, selectors, source locations, literal/computed
+value distinctions, and unknowns; an input fragment does not establish final
+device state. Script-variable bindings are not yet an object-reference model
+for interfaces, bridges, or other configuration entities. Security advice,
+rule collections, and a browser/Monaco inspector are possible consumers, not
+new requirements to implement those products during the offline baseline.
+quickchr owns the CHR provisioning/test machinery; rosetta supplies docs and
+reference knowledge. This direction adds no runtime dependency on either.
+
 ## Canonicalization is the core
 
 The engine is a **grown `canonicalizeExecuteCommand`** (decision: grow the
@@ -165,16 +172,16 @@ today's path/verb/args split and script-vs-structured gate:
   The *container* half of that pair is since decidable. `src/explain/menus.ts`
   (#207) bakes only the menu-vs-command node type — not a schema — and it is
   version-less because the pinned trees show no `dir`↔`cmd` flip across
-  7.10.2 → 7.24rc2 or across architectures. So `/ip/route` now resolves as
+  7.10.2 → 7.25beta3 or across architectures. So `/ip/route` now resolves as
   `navigation` (#210). The floor is unmoved: the table is deliberately
   incomplete, absence from it decides nothing, and every rule above it still
   refuses rather than guesses.
 
   The *command* half is what #228 addressed, by adding a second first-order
   source rather than a schema. MikroTik's CLI Reference is generated from the
-  definition structs, and measured against the same four pinned trees it has
-  **zero navigation-vs-command contradictions** across 968 exactly-matching
-  paths, three RouterOS versions and two architectures; all but one of the 102
+  definition structs, and measured against the same six pinned trees it has
+  **zero navigation-vs-command contradictions** across 959 exactly-matching
+  paths, four RouterOS versions and two architectures; all but one of the 94
   published paths absent from every tree carry a `package`/`conditions`/`syscap`
   gate — their own or an ancestor's — that predicts the absence.
   `src/explain/catalog.ts` unions the two with per-entry provenance, which is
@@ -198,6 +205,22 @@ today's path/verb/args split and script-vs-structured gate:
   inventory reshape fails loudly instead of shrinking the table (#285,
   tikoci/rosetta#137).
 
+  **Source refresh (#335, accepted 2026-09-13).** The inspect pins retain the
+  7.10.2 and 7.16 history anchors, then pair x86 and arm64 for both current
+  stable 7.24.2 and prerelease 7.25beta3. Pairing architectures makes additions
+  attributable to version rather than to an architecture swap while preserving
+  the hardware-only menu floor. Reviewed independently, the inspect union moves
+  from 615 to 617 menus: 7.24.2 removes `/ip/ipsec/key/qkd`, and 7.25beta3 adds
+  `/interface/ethernet/pon`, `/interface/xfrm`, and `/ip/ssh/known-hosts`.
+  Separately, the current CLI Reference moves from 1,070 pages / 1,077 entries
+  to 1,053 / 1,060: it adds
+  `/interface/ethernet/switch/rule/reset-counters`, removes the five
+  `/interface/bridge/msrp` paths plus `/root`, moves 12 paths from `both` to
+  `inspect`, and changes 16 published gate strings. Those current-only
+  publication changes are accepted: none introduces a kind contradiction. The
+  coherent generated catalog has 1,120 paths: 959 `both`, 67 `inspect`, and 94
+  `published`; it still reports zero navigation-vs-command contradictions.
+
 There are real unknowns in how far offline parsing can go (expression
 grammar, scope fidelity vs `:parse`, `[]`-nesting corner cases). Grounding
 those unknowns was **phase 0** (#185); its findings are folded in throughout
@@ -262,7 +285,10 @@ command accepts.
 Offline mode does ship two generated **structure** tables, baked at build time
 from pinned sources and read as ordinary closed lists. They may say whether a
 path is navigation or a command; they never describe what a command accepts.
-Absence from either abstains and never rejects.
+Absence from either abstains and never rejects. Regenerate with
+`bun run explain:menus` / `bun run explain:catalog`; `--check` drift-gates both
+in QA. Do not hand-edit them — each file's header carries its source pin and
+rationale.
 
 - `src/explain/menus.ts` (#207) — container paths from pinned restraml
   `/console/inspect` trees. **Read today** to confirm navigation, on its own by
@@ -499,7 +525,8 @@ Standard envelope (constitution: result envelope); `data` sketch:
   severity channels. **Malformed input carries a defect *region*** (Q14): each
   diagnostic points at the byte span of its defect, and the detectable classes
   are {unbalanced delimiter, unterminated string, invalid escape, invalid sigil,
-  invalid unquoted hash, BOM, non-ASCII, over-depth nesting}. **Two classes named
+  invalid unquoted hash, invalid apostrophe (#355), BOM, non-ASCII,
+  over-depth nesting}. **Two classes named
   in the phase-0 draft
   of this list are deliberately deferred** (maintainer decision, #192), because
   each would require offline to assert something it cannot prove:
@@ -570,19 +597,24 @@ and its phase is named below.
     all: a `[…]`/`(…)`/`$x`/`{…}` value, an escape this phase does not decode, a
     left-hand side that is not a RouterOS name, a token split by a continuation.
     Never partially read, because a dropped argument silently changes what a
-    rendered `curl` DOES. Two refusals are not lexical at all, but
-    places where centrs's two readers disagree about an **unquoted** value: a
-    `'`, which RouterOS treats as an ordinary character and the locked execute
-    gate treats as a quote (`comment=it's` is `it's` here and `its` to the
-    gate); and a `\f`/`\v`, which the gate splits tokens on (JavaScript `\s`)
-    and every explain module does not (ASCII whitespace). The device-correct
-    reading is the analysis's in both, but the gate cannot be corrected — so
-    phase 1 publishes neither rather than putting two confident values in one
-    result. Inside a `"…"` run the two agree and nothing is refused. The
-    advisory value-anchor view is intentionally wider only for exact array
+    rendered `curl` DOES. One refusal is not lexical at all, but a place where
+    centrs's two readers disagree about an **unquoted** value: a `\f`/`\v`,
+    which the retired execute gate split tokens on (JavaScript `\s`) and every
+    explain module does not (ASCII whitespace). The device-correct reading is
+    the analysis's, but that gate could not be corrected — so phase 1 publishes
+    neither rather than putting two confident values in one result. Inside a
+    `"…"` run the two agree and nothing is refused.
+
+    The advisory value-anchor view is intentionally wider only for exact array
     literals: a non-empty `{…}` value or a parenthesized run with a depth-zero
     comma is locatable and hints `array`, while the strict REST view continues
     to refuse the whole list.
+
+    An unquoted `'` used to be a second such disagreement, described here as a
+    character RouterOS treats as ordinary and the gate treats as a quote. That
+    reading was wrong on both halves and #355 settled it: `'` is not a RouterOS
+    token at all, so `comment=it's` is REJECTED by the device rather than
+    carrying either value, and the quote-counting gate that disagreed is gone.
   - **A token is read but carries no `value`** — the list still reads. The token
     is delimited and classified; only its literal value is unknowable, as for
     the positional in `:log info "result: $[…]"`. **`value` absent means there
@@ -882,11 +914,11 @@ and its phase is named below.
   `bun run explain:value-census:readme` and gated against it by
   `bun run explain:value-census:readme:check`; the fixture itself is gated
   against a fresh corpus run by `bun run explain:value-census:check`. Of the
-  13,168 emitted values in a statement the strict argument lexer ALSO read, 0
+  13,161 emitted values in a statement the strict argument lexer ALSO read, 0
   disagree with it on half-open byte span or decoded text, while the
-  prefix-safe scan retains a further 6,540 values across 569 statements whose
-  strict REST reading abstains. Of 19,708 emitted occurrences, 5,636 are array
-  members (529 keyed, 1,147 nested inside another member) and 813 are arrays;
+  prefix-safe scan retains a further 6,538 values across 568 statements whose
+  strict REST reading abstains. Of 19,699 emitted occurrences, 5,636 are array
+  members (529 keyed, 1,147 nested inside another member) and 808 are arrays;
   the corpus holds no source-literal `id` example. The three structural
   counters — spans addressing bytes outside their own source, members naming a
   container that does not exist, members escaping the container they name —
@@ -1003,7 +1035,9 @@ navigated, so the context stays as unknown as it already was.
     (string-internal unknown/lowercase-hex/truncated — CHR `highlight` `error`
       `:parse` `expected message value`, grounded stable+testing #247),
     `bad-sigil`,
-    `invalid-hash`. Seven classes the device itself rejects.
+    `invalid-hash`, `invalid-apostrophe` (#355, below),
+    `missing-statement-separator` (#311, below). Nine classes
+    the device itself rejects.
   - `warning` — `over-depth`, because it is centrs's own resource bound and says
     nothing about whether the input is legal; and an `ambiguous`/`unknown`
     resolution, never an error, so the default `--fail-on error` cannot fail a
@@ -1013,6 +1047,386 @@ navigated, so the context stays as unknown as it already was.
     fail), and `context-lost`, which reports a reading that is correct while the
     document's menu context was already gone.
 
+### The missing statement separator (#311)
+
+Two commands written with no `;` or newline between them used to read as one
+command with extra operands, and offline reported `pass`: `/ip/address add
+interface=ether1 /ip/route add gateway=192.168.88.1` published `gateway` as an
+attribute of `/ip/address add`. The rule that closes it is a known **menu path**
+in operand position followed by a console **verb** — never "a `/` after the
+verb", because a slash-shaped operand is legal and `/file remove
+/flash/skins/foo.html` lowers cleanly to `numbers=/flash/skins/foo.html`. The
+menu spelling may be slashed, spaced, or mixed (Q3 R4); the device rejects
+`/ip route add` exactly as it rejects `/ip/route add`.
+
+**The device evidence is not what the report said, and the correction widened
+the rule.** #311 gave the error byte as the `=` of the trailing attribute
+(`expected end of command (line 1 column 55)`). That byte is an artefact of that
+head: `add` abbreviates `/ip/address/add`'s own `address=` argument, so the
+console reads `add gateway` as `address=gateway` and only complains at the `=`
+after it. Change the head so the second verb abbreviates nothing and the answer
+changes shape — `/system/note set note=hello /ip/route add gateway=1.2.3.4` is
+no hard reject at all; `:parse` returns IL carrying `bad parameter /ip/route
+(line 1 column 38)`, naming the second **path**. Both are refusals, and which
+one appears depends on per-menu argument names, which offline does not have. So
+the grounded claim is the negative one: across every probed spelling on CHR
+7.24.2 and 7.23.5, RouterOS answers `bad parameter <path>` or `expected end of
+command`, and never accepts the shape. A trailing attribute is therefore **not**
+required, which #311's own example had made it look like.
+
+The head-dependence goes one step further than "which wording", and it bounds
+what the diagnostic may say. On a head whose own value slot takes a bare
+positional, the second path is absorbed into that slot and the device refuses
+the **verb** instead: `:put /ip/route print` lowers to `/putmessage=/ip/route`
+and answers `bad parameter print`, and `:local a /ip/route add` lowers to
+`/localname=$a;value=/ip/route` and answers `bad parameter add`. Both are still
+refusals — `/system/script/run /ip/route`, the same shape with no verb after
+the path, lowers cleanly to `number=/ip/route` — so the offline `error` stands.
+But the message says the bytes **read as** a second command, which is centrs's
+heuristic reading, and never that the device starts one there or which token it
+will name. Every row above is pinned in
+`test/integration/explain-separator.test.ts`.
+
+**The contradicted reading is withdrawn, not patched.** The statement stays
+`resolved` — `/ip/address add` really is the head, and `highlight` agrees. What
+is withdrawn is withdrawn by three separate gates, each with its own trigger:
+
+1. **The argument list.** `withoutSeparatedArguments` drops `command.args` and
+   sets `arguments.read` to `false`. This is the same all-or-nothing move
+   `enforceGateParity` makes for a gate/analysis disagreement, but it is a
+   distinct gate on a distinct trigger — the two never consult each other. The
+   device says the move is right rather than merely cautious:
+   `… /ip/route add placeholder` lowers to
+   `address=placeholder;;interface=ether1`, a phantom attribute the source never
+   wrote, because the second run's words can abbreviate the HEAD's argument
+   names.
+2. **The invocation.** `rejectedBySeparator(runs)` sets the new
+   `ExplainTransportInput.rejected`, which `classifyExplainTransport` honours
+   ahead of every mapping rule and answers `unknown`. Without it the degraded
+   `arguments` would fall through to `execute` and print a ready-to-paste
+   `centrs execute '<router>' '<the malformed text>'` for bytes the same result
+   calls a syntax error. **Unread is not rejected** — an unread argument list
+   still legitimately rides the raw CLI surface, and that path is unchanged.
+3. **The value facts from the run onward.** `values.occurrences` is an axis of
+   its own, not a projection of `arguments` — the value census above pins how
+   many values it retains in statements whose strict REST reading abstains — so
+   gate 1 does not reach it and a cut is needed. The cut is the run's first byte, and
+   the device draws the line in the same place: `:parse` reads `gateway` as the
+   VALUE of `/ip/address/add`'s own `address=`, never as an attribute NAME,
+   while the head's `interface=ether1` survives into the IL (as `note=hello`
+   does in the `/system/note set` row). Values before the cut therefore stay;
+   values reaching into or past it are dropped, and with them the `value` token
+   class over those bytes.
+
+**Abstentions, stated.** A menu path with no verb after it (`… /ip/route`) and a
+bare operand a menu does not accept (`… placeholder`, `/file remove a b`) also draw
+`bad parameter`, but that is the generic "no such positional" complaint;
+deciding it needs the per-menu positional list, which `catalog.ts` deliberately
+is not, and a separator is not necessarily the fix. Both abstain. The shape
+filter over a candidate path does admit a leading digit, because
+`/interface/6to4` is a real menu in both structure tables; presence in those
+tables, never the filter, is what decides. Over the 948-script pinned corpus the
+rule fires **0 times**, so no published census figure moves; the 38 corpus
+scripts the device answers `expected end of command` for are all other causes
+(line continuations, `<tab>`/`<VALUE>` placeholders, pasted shell and Python,
+stray parens), which is #203's genre bias showing.
+
+**The reach limit is closed (#316).** This rule used to read
+`statement.arguments.tokens`, the all-or-nothing strict reading, so a statement
+holding a variable carried no tokens and the run in it was missed:
+`/ip/address add interface=ether1 /ip/route add gateway=$g` reported `pass`
+where its literal twin reported the separator. It now reads the skip-tolerant
+token stream described below, and both spellings report the separator — as does
+`/ip/address add interface=$x /ip/route add gateway=1.1.1.1`, where the
+undecodable token comes FIRST and a prefix-only reading would still have missed
+it. The corpus count is unchanged at **0** for the same reason it always was
+(#203's genre bias), so this buys reach rather than a number. What still stops
+the rule is an unterminated string or an unbalanced delimiter, because neither
+walk can find a boundary to resume from.
+
+### The token stream a rule reads (#316)
+
+`lexArguments` is all-or-nothing by design: its consumer renders a runnable REST
+request, and a partially-read argument list changes what the rendered command
+DOES. That is the right reading for a renderer and the wrong one for a rule —
+the first token it declines discards every token already decoded, which put
+**48.2%** of the corpus's argument-bearing statements out of reach of every
+token-level rule and of the `arg` token fill.
+
+`lexArgumentTokens` is a third reading over the same walk — alongside strict
+`lexArguments` and the prefix-safe `lexValueAnchors` values already use. Same
+text, same `from`, the same boundary rules and the same refusal strings,
+differing only in what a refusal does. Where the strict reading discards the list, this one publishes the token
+it could not decode with its bytes located, `undecided` set to that same reason
+and **no `value`**, then carries on to the next token. `statement.arguments` is
+unchanged and still strict; nothing that renders a command gained reach.
+
+**Skip-and-continue, measured against stop-at-first-refusal.** #316 named two
+designs and said the fork was load-bearing rather than cosmetic. It is. Both are
+priced by `bun run explain:arg-reach` over the 948-script pinned corpus, from
+one implementation — design A is the tolerant token list truncated at its first
+`undecided` token, which is exactly the prefix the strict walk discards:
+
+| | strict | A — prefix | B — skip |
+| --- | ---: | ---: | ---: |
+| statements reached, of 14,267 | 7,385 (51.8%) | 10,754 (75.4%) | 14,267 (100.0%) |
+| argument tokens | 16,652 | 20,481 | 31,310 |
+| missing-separator runs found | 0 | 0 | 0 |
+
+A further 58 statements sit outside every column because their bytes are not
+addressable (normalized, or a span widened to the enclosing statement); the
+sweep counts them rather than dropping them silently, since `explain.ts` refuses
+those too and lexing them here would measure a reading the product does not
+offer.
+
+A recovers 3,369 statements; the 3,513 statements whose FIRST interesting token
+is the undecodable one have an empty prefix and are reached only by B — so the
+cheaper design leaves slightly more behind than it recovers. The separator row
+is 0 across all three and is reported rather than buried: on this corpus neither
+design finds a run the strict reading missed, which is what #203's genre bias
+predicts for a typo class published scripts do not carry. The sweep also asserts
+what makes the A column trustworthy — that the strict tokens are the tolerant
+walk's prefix byte for byte, and that both walks name the same refusal reason —
+and fails if any statement disagrees (0 do).
+
+**Where both walks still stop.** An unterminated string and an unbalanced
+`(`/`[`/`{` have no knowable end, so there is no boundary to resume from. A `;`
+is a third and deliberately so: it is a statement boundary the segmenter owns,
+and resuming after it would read the next statement's bytes as this one's
+arguments. No corpus statement reaches any of the three, and that is a property
+of the pipeline rather than luck: an unterminated string and an unbalanced
+delimiter are document defects the segmenter and resolver answer first, so no
+addressable statement with an argument list is produced at all, and a `;` is
+split into two statements before any argument is lexed. The unbalanced case is
+also the one place the two readings name a different reason, and it follows from
+what each needed: the strict walk refuses a `[…]` on sight and never asks where
+it ends, while the tolerant walk asks — because the answer is what it would
+resume from — and says `an unclosed structured argument value` when there is
+none.
+
+**What it moved, including the cost.** The `arg` fill now paints the `name=` run
+of a token whose value only the device knows, so classified bytes go 69.77% →
+**71.73%** (`arg` tokens 11,438 → 16,526). On the device-agreement slice the
+bytes where the device decided and centrs abstained drop 5,540 → 4,158, and two
+whole cells (`unclassified` → `arg-dot`, `unclassified` → `arg-scope`) empty
+out. Against that, projection disagreements rise 143 → 360, and **every one of
+the 217 new bytes is the `=` of an attribute**: `arg` → `syntax-meta`, one cell,
+358 runs. That is not a new wrong assertion. It is #293's provisional
+vocabulary — one `arg` class for both the name bytes and the `=` — meeting the
+device's context-dependent answer over 2.5x as many bytes as before, and it
+gave #264 B5 a concrete, counted reason to split the `=` into its own class.
+It did, and the relabel moved no byte coverage at all: disagreements fell
+360 → 2 and the classified-byte census did not change by a digit.
+
+**The one residue, sized so it is not mistaken for a defect.** A `\<newline>`
+continuation inside an argument leaves its token `undecided`, because the bytes
+of a continued value are not contiguous and a `valueSpan` over them would be a
+lie (`args.ts` → *What it refuses*). The conservative case is a token whose
+value is already complete BEFORE the continuation, which is then withheld
+needlessly. Measured on the 948-script corpus: 109 statements make the strict
+lexer refuse for this reason, the tolerant walk reaches 114 statements carrying
+138 such tokens, and **all 138 put the continuation immediately after the `=`**
+— the value really does live on the next line. Exactly **one** token
+(`mode=none\<newline>`) has a complete value in front of its continuation. So
+narrowing the rule would recover one token, and deciding it correctly needs the
+device-grounded answer for what a continuation does to a value's INTERIOR, which
+is #225's probe-matrix territory rather than a lexer tweak. Recorded there; not
+carried as pending work here.
+
+**What the public surface gained, and what it did not.** The package root
+exports the reading itself — `lexExplainArgumentTokens` and
+`ExplainArgumentTokenReading` — for the same reason `lexExplainValueAnchors` is
+exported: a consumer building its own token-level rule needs the reading a rule
+wants, not the one a renderer wants. What did NOT change is the *envelope*:
+`explainCommand`'s `structure.statements[].arguments` is still the strict
+reading, `ExplainArgumentToken` carries no `undecided` field, and `undecided`
+never appears on an `ExplainArguments` reading, because the strict lexer
+publishes no token it could not decide. Whether the tolerant stream should reach
+the envelope in its own right — so a browser consumer reading `explainCommand`'s
+result can see a located `gateway=` whose value is a runtime expression — was
+left to #264 B5, which decided it reaches the envelope **as the token
+partition** and nowhere else: naming the `=` `arg-sep` locates the argument
+without loosening `arguments`, and `undecided` stays off the envelope. See
+[The vocabulary](#the-vocabulary-and-what-earns-a-class-264-b5).
+
+### The menu path with arguments (#324)
+
+A run that is nothing but a **known menu**, with arguments after it and no
+verb, used to come back `resolved` with a verb the analyzer made up.
+`/ip/firewall/address-list name=ytkids timeout=1h` reported path
+`/ip/firewall`, verb `address-list`; the spaced spelling
+`/ip firewall address-list name=x` promoted `firewall`, one level higher
+still. The punctuation half of the ratified Q6 rule is what fires — "no space
+token, arguments follow, so the last run token is the verb", or "the first
+space token is the verb" — and neither premise it needs was ever checked:
+
+```text
+isKnownMenuPath(/ip/firewall/address-list)  ->  true      (it is a menu)
+VERBS.has("address-list")                   ->  false     (it is not a verb)
+```
+
+This is the **symmetric half of R9**. R9 (#211 B1) made `pathresolve`'s
+`menuNavPath` consult `VERBS` so it could not claim navigation where
+`verbsplit` had decided a verb; this makes `resolveVerb` consult the menu
+tables so it cannot claim a verb where the whole run names a menu and the
+segment it would promote is not a verb. The reading degrades to **`ambiguous`**
+with the standard located `explain/canonicalizer/ambiguous-statement` warning,
+naming both premises. The adjacent readings are untouched —
+`/ip/firewall/address-list add name=x` resolves, the bare path is navigation,
+`/system/reboot` is a command — which is what makes this a seam rather than a
+parser limit.
+
+**It abstains; it does not reject.** Offline knows it cannot name a verb here,
+and that needs no device evidence. Whether RouterOS refuses the shape outright
+is a *device* claim, so unlike #311's CHR-grounded `error` this stays a
+warning and the statement carries no verdict about acceptance.
+
+**Four exclusions, each for its own reason.** A frozen-vocabulary hit is
+excluded by the `VERBS` premise itself (a vocabulary split promotes a `VERBS`
+member by construction). A **published command** is excluded by `catalogAt`:
+first-order evidence about that exact path outranks a container listing of its
+prefix, which is what keeps `/system/gps/monitor once` resolved. A scripting
+**directive** is excluded by R10, which is measured. And a `{` after the run is
+excluded by shape: that is a menu *container* body (`/system {identity print}`,
+H7) where the run legitimately names a menu and no verb is missing —
+abstaining there would drop the `invalid-command-brace` error the statement
+after it carries.
+
+**Priced before landing, as #211 B2 asks.** Over the frozen dev/holdout
+partition (948-script corpus, 17,212 statements) **10 statements flip, all
+`resolved` → `ambiguous`**: 1 dev, 9 holdout. **None is a genuine no-verb
+command.** Three are real RouterOS missing a verb —
+`/ip/firewall/address-list name=ytkids …`, `/interface bridge [find]
+vlan-filtering=yes`, `/user-manager user [find …] attributes=…` — and seven
+are pasted non-RouterOS prose: five Python traceback `File "…"` lines,
+`User ID: 506`, and `port 80`. Those seven reach the rule at all because
+`/file`, `/user` and `/port` are real menus and the table lookup folds case,
+which is #203's genre bias arriving through a second door. Every one of the
+ten was a fabrication, so the abstention has no measured false-positive cost
+on this corpus.
+
+**The execute gate is unmoved**, as the constitution requires: `canonical`
+still reports `mode: "structured"`, path `/ip/firewall`, verb `address-list`
+for this input, because that is what `canonicalizeExecuteCommand` decides and
+an explain-only abstention may not reinterpret it. `enforceGateParity` is
+about the argument *list* of a `kind: "command"` reading, so it does not fire
+on a statement that carries no reading at all — the gate and the analysis are
+two answers to two questions, and only one of them changed.
+
+The invariant this closes — `pathresolve` and `verbsplit` never contradict
+each other on one statement — is asserted in
+`test/unit/explain-pathresolve.test.ts` beside R9's own cases. Presence in the
+shipped structure tables still narrows a reading and absence still decides
+nothing (#207/#228), so an unlisted menu spelled `…/address-list` is read
+exactly as before.
+
+### Two spellings the device accepts and offline used to reject (#347, #348)
+
+Both were found the same way, and the method is worth keeping: run the analyzer
+over all 948 corpus scripts and compare its verdict to that build's own `:parse`
+verdict, which the corpus already stores. The number that matters is the **false
+reject** — a script the device ACCEPTS that offline analysis fails — because
+that is validation blocking input RouterOS is happy with. It was 4, identical on
+7.23.5, 7.24.2 and 7.25beta3; it is now 1.
+
+The converse count is not a parser score and is not quoted as one: the corpus is
+whole forum posts including prose output, so most of what the device rejects and
+offline passes is #203's genre bias rather than a gap.
+
+**The `=` is optional on a scope slot (#347).** `:if (…) do={…} else={…}`,
+`:if (…) do={…} else {…}` and `:if (…) do {…} else {…}` are the same construct:
+`:parse` lowers all three to byte-identical IL (`…;do=;(evl …);else=;(evl …)`)
+on CHR 7.21.5, 7.23.5, 7.24.2 and 7.25beta3. The MikroTik manual documents only
+the `else={…}` spelling, so this is a real-but-undocumented form. The rule is
+deliberately narrower than "any word before a brace": only the four
+`SCOPE_ARG_NAMES` members may drop the `=`, and the word may not be the
+statement's own leading directive — otherwise `:local z {1;2}` would stop
+reading its brace as an array, and `:do {` would have its slot renamed away from
+the `command` the IL uses. A COLON also disqualifies the word: the device parses
+`:if (1=1) do {…}` but refuses `:if (1=1) :do {…}` with `expected end of command`
+on 7.21.5 and 7.24.2, because a colon makes it a directive and a directive
+cannot occupy an argument slot. The control is `elsy {`, rejected on all four
+builds, which is what makes the acceptance a device fact rather than a probe
+artefact.
+
+**A relative menu-scope block composes the path (#348).** `/ip { address {
+print } }` is `(evl (evl (evl /ip/address/print)))` on device and
+`/interface { ethernet { print } }` the same way; the ABSOLUTE spelling
+`/ip/address { print }` already passed offline, and only the nested relative
+form failed. A menu block's body is a statement list, so it may open with a
+submenu, with one of the thirteen frozen CRUD verbs (`verbs.ts`), with a
+catalog-named command, with a `:` scripting directive, or with an absolute
+command — corpus 521 is the directive case, `ethernet { :put … }`.
+
+That last rule is bounded by what a STATEMENT can start with, which is what
+keeps `{1;2}` an array literal: an array member opens with a digit or a quote
+and never reaches the identifier branch. It is also deliberately not widened
+into a claim of existence. Menu-scope resolution is schema-dependent —
+`/ip { zzznotamenu { print } }` is a `syntax error` on device — and offline has
+no schema, so a catalog MISS abstains rather than being decided either way.
+That is the catalog's own "a hit is decisive, a miss says nothing" contract, and
+turning such a miss into an acceptance would be the mirror-image defect of the
+one being fixed here.
+
+### `'` is not a RouterOS token (#355)
+
+`'` (U+0027) is not a string delimiter and not a legal bare byte. Only `"` opens
+a string. `:parse` rejects every spelling of a bare apostrophe byte-identically
+on CHR 7.21.5, 7.23.5, 7.24.2 and 7.25beta3:
+
+| input | device `:parse` | offline span |
+| --- | --- | --- |
+| `/system/identity/set name=don't` | `expected end of command (line 1 column 30)` | 29 |
+| `/system/identity/set name=don't'` | `expected end of command (line 1 column 30)` | 29 |
+| `/system/identity/set name='abc'` | `syntax error (line 1 column 27)` | 26 |
+| `:put 'abc'` | `syntax error (line 1 column 6)` | 5 |
+
+The device's column is 1-based, so each offline span is the device's own byte.
+The accepting controls — `comment="it's here"` and a `# don't` comment line —
+parse cleanly on all four builds, which is what makes the rejection a device
+fact rather than a probe artefact. Rows 2–4 carry BALANCED apostrophes and are
+rejected anyway: this is a lexical rule, not a quote-balance one, and the remedy
+is always `"`, never a matching `'`.
+
+Only the FIRST apostrophe is recorded, **document-wide**, the same way the hard
+`#` is: the device reports one column and it is the first one (row 2 reports
+column 30, not the trailing apostrophe), because classification stops there. A
+nested scope body is a separate scan (`segmentScopeBody`), so per-scan
+suppression is not enough on its own and the collapse to the earliest occurrence
+happens where the diagnostics are composed — which keeps each segmenter call
+pure. Apostrophes inside a `"`-string or a comment never reach the rule at all —
+both runs are consumed whole by the scan before it — so no special case is
+needed for either.
+
+Symbol resolution stops at the apostrophe too, exactly as it stops at a
+malformed escape: the device classes nothing after a hard reject, so
+`:put 'abc'; :put $after` must not publish an occurrence for `$after`.
+Occurrences BEFORE the defect stand, which is the lab's X1 rule.
+
+**This was a false ACCEPT, which the corpus join cannot see.** The false-reject
+measurement scores one direction only, so the analyzer passing all four forms
+with zero diagnostics never appeared in it. Over the pinned corpus the rule
+fires on 40 of the 7.24.2 scripts and **every one of them is a script the device
+rejects** — none of the 617 it accepts. It moves the false-reject count not at
+all (still 1, the extra `}` of corpus 228) while taking the caught count from 62
+to 93.
+
+The token census moves, and only in the direction the fail-closed symbol stop
+predicts: 68 fewer `variable-*` tokens and their 306 bytes returning to
+`unclassified` (classified 1,023,413 → 1,023,107). Those are variable references
+sitting after a bare apostrophe, which the device never reaches and centrs
+therefore stops naming. The value, operator and bracket-equals censuses and
+`explain:arg-reach` are all unchanged.
+
+**It also retires a wrong rule.** `execute` carried a private
+`hasUnbalancedQuotes` preflight that modelled `'` as a delimiter, moved into the
+offline gate by #354. It had no comment awareness, so `# don't` opened a quote
+it never closed: over the same corpus it false-rejected **51** of the 617
+device-accepted scripts. Deleting it costs 21 catches — all of them scripts the
+device rejects anyway, where the device stage is still the backstop — and takes
+the gate's false rejects from 52 to 1. A false reject blocks input RouterOS
+accepts, which is the figure that matters.
+
 ### String escape validation (#247, #252)
 
 The accepted set is the **device's**, not the manual's. The
@@ -1061,8 +1475,9 @@ for the three issue rows `:put "\q"` / `:put "\x0a"` / `:put "\0a"` vs
 - Scoring a defect rule against the corpus needs the right oracle.
   `parseil_results.ok` is **not** one: `:parse` never throws, it returns a
   diagnostic *value*, so the capture records `ok=1 / status="ok"` for scripts
-  the device rejected (only 3 of 2739 rows are `ok=0`, and those are capture
-  failures). The verdict is in `il_text` — plain prose such as
+  the device rejected (only 5 of 4635 rows are `ok=0`, and those are capture
+  failures — one `edge-cases/oversize-32k.rsc` REST `413` per captured
+  version). The verdict is in `il_text` — plain prose such as
   `expected input value (line 7 column 49)` means rejected, IL means accepted.
 
 ### The operator surface (#255)
@@ -1071,14 +1486,62 @@ Grounded, not transcribed, for the same reason the escape set above is: the
 [manual's operator list](https://manual.mikrotik.com/docs/developer-guides/scripting/index.md#operators)
 is a lower bound. `bun run explain:probe:operators` sweeps the manual's list
 **plus** plausible non-operators (`not`, `..`, `xor`, `mod`, `is`, `div`, …)
-**plus** every IL head the corpus census saw, on CHR 7.23.3 stable, 7.24rc4
-testing and 7.21.5 long-term — one build per release channel, so a claim about
-any channel is evidence rather than an assumption. Re-cut the fixture with
+**plus** every IL head the corpus census saw, on CHR 7.24.2 stable, 7.23.5
+long-term and 7.25beta3 development — the same three builds the pinned corpus
+classes `complete`, so the operator axis and the token partition are finally
+scored on the same firmware (#342) — plus 7.21.5 as an **age anchor**, which is
+not a channel claim but the only live evidence that the surface behaves the same
+on a pre-7.23 branch. Re-cut the fixture with
 `bun run explain:operator-slice`; the table
 below is generated from `src/explain/operators.ts` by
 `bun run explain:operator-readme` and gated by
 `bun run explain:operator-readme:check`.
 
+**The census is a candidate generator, and boilerplate defeats its own
+tie-breaker.** `scripts/explain-operator-census.ts` reports every head-position
+token in the device IL, tagged by shape, because IL is a debug rendering that
+does not quote strings: a string literal is emitted bare, so string content is
+indistinguishable from a node head. Its stated honesty rule is that
+`distinctScripts` beats frequency — "a head seen in one script is one author's
+string, a head seen in three hundred is a language feature". Only the complete
+builds carry parseIL for the 35-script `tangentsoft` device-`/export` stratum,
+and that stratum showed the rule has a blind spot, because a stock string
+replicated across a whole stratum of device exports looks exactly like a
+language feature by script count:
+
+| word-shaped head | scripts, partial builds → complete | what it actually is |
+| ---------------- | ---------------------------------: | ------------------- |
+| `for` | 2 → 22 | the defconf comment `accept to local loopback (for CAPsMAN)` — in 20 of the 35 device exports, plus the 2 forum scripts that already carried it |
+| `line` | 53 → 84 | device diagnostic prose, `bad parameter hw-offload (line 33 column 147)` |
+
+Those arrows are a **coverage** step, not a version step: the left column is
+what a 913-script capture could see, the right what a 948-script one sees.
+
+Neither is an operator, and both are `word`-shaped — the same bucket #255's
+`not` would have appeared in. So the sweep, not the census, still decides; a
+head that arrives with a whole stratum at once is boilerplate until the device
+says otherwise. The two heads that stratum added outright,
+`configuration.mode=` and `[system`, are `other`-shaped and are the documented
+string-noise class: a dotted wifi property name emitted bare, and text inside
+an embedded `/system script add source=` value.
+
+**The census counts only the complete builds; a separate axis dates heads.**
+Occurrences are summed across versions, so admitting a partial capture would
+scale every figure by what happened to be captured — on this snapshot, letting
+all six builds in inflated the headline by ~20% while `distinctScripts`, the
+column that actually carries the argument, did not move at all. So
+`headOccurrences` / `headVersions` / `headArities` read
+`coverage_class = 'complete'` only, and the census states its version set in
+`versions` so a gate cannot silently compare two different universes.
+
+Presence, unlike frequency, *is* monotone in coverage — a 913-of-948 capture
+that shows a head proves that build had it — so the partial builds keep one
+job: `headFirstSeen` dates each head against every captured build. That is what
+still grounds the `any` claim below at 7.20.8, a build the counting side no
+longer reads. Read a *late* first-seen as "not captured before here", never as
+"new in": the only two heads that do not reach 7.20.8 are the `tangentsoft`
+pair above, which no partial build could have seen.
+
 **`:parse` IL is the oracle, and `highlight` cannot be.** IL is prefix form with
 the operator as its node's head, so it names the operator and shows its
 operands. `highlight`'s `syntax-meta` is the device's *residual structure*
@@ -1103,7 +1566,7 @@ Five things the device says that the manual does not:
 3. **`$`, `[`, `]` are syntax, not operator heads.** `$x` stays an atom in the
    IL and `[:tostr 1]` lowers to an `evl` node. Those bytes belong to the
    substitution axis.
-4. **`any` is an operator** (prefix, arity 1) and is not in the manual's list — a **nil-check**: `:typeof (any x)` is `bool`, `false` only for `nil`/`nothing` (the value of an undefined `:local` and of `[:nothing]`), `true` for everything else including `0`, `""` and `false`.  It is the idiom `:if (any $x) ...` to test a variable that may be `nil`; `(true any false)` is not infix at all but juxtaposition `(  true (any false))`, and `(1 . any [:nothing])` is concat `1`+`false`.  Present since at least 7.20.8 (corpus `any|7.20.8:2`, and swept live on 7.21.5 long-term, 7.23.3 stable and 7.24rc4 testing with no difference between them).
+4. **`any` is an operator** (prefix, arity 1) and is not in the manual's list — a **nil-check**: `:typeof (any x)` is `bool`, `false` only for `nil`/`nothing` (the value of an undefined `:local` and of `[:nothing]`), `true` for everything else including `0`, `""` and `false`.  It is the idiom `:if (any $x) ...` to test a variable that may be `nil`; `(true any false)` is not infix at all but juxtaposition `(  true (any false))`, and `(1 . any [:nothing])` is concat `1`+`false`.  Present since at least 7.20.8 (corpus `headFirstSeen[any] = 7.20.8`, the oldest captured build, and swept live on 7.21.5 and 7.23.5 long-term, 7.24.2 stable and 7.25beta3 development with no difference between them).
 5. **`&&` and `||` are spellings**, lowering to the `and` and `or` nodes.
 
 The `(>…)` and `<%%` forms are in the table on the same footing as `+`.
@@ -1119,7 +1582,7 @@ their `precedence` is honestly `null`. That is "unmeasured", not "unknown": the
 sweep asks them separately, every `(U 1 B 2)` and `(1 B U 2)` for
 `U`∈`!`,`any`,`~`,`-`,`>` against all 24 binaries — 240 probes, recorded in the
 fixture's `unary` block. All 240 are accepted and the **binary is outer in every
-one**, on all three versions, so each prefix operator binds tighter than every
+one**, on all four swept builds, so each prefix operator binds tighter than every
 binary including `->` (14) and `<%%` (13). The table stores one `precedence` per
 spelling, which is the binary level; `~`, `-` and `>` are here because their
 unary reading has no other record.
@@ -1131,8 +1594,14 @@ not concat at all** — `1.` lexes as a *variable name* and the row comes back a
 juxtaposition, `(  $1. 2)`. A rule that claims every `.` byte for the operator
 emits a span the device does not have.
 
-Everything in the sweep is identical across 7.21.5, 7.23.3 and 7.24rc4 except
-one runtime row: `:put ({2;1} > {1;2;3})` evaluates to `true` only on 7.24rc4.
+Everything in the sweep is identical across all four builds except one runtime
+row: `:put ({2;1} > {1;2;3})` evaluates to `true` on 7.24.2 and 7.25beta3 and
+errors on both long-term builds. **Array comparison is not fixed on current
+long-term** — 7.23.5 is newer than the 7.23.3 this was first measured on and
+still errors — so the change rode the 7.24 line and was not backported. The two
+errors also differ: 7.23.5 says `cannot compare if array is more than array`,
+7.21.5 says `cannot compare if nothing is more than nothing`, so on 7.21.5 the
+operands did not survive to the comparison at all.
 Identical is measured, not assumed — the slice diffs verdict, arity, precedence,
 associativity, `highlight` run, unary placement and op-axis per version. So the
 operator table needs no version gate; anything reporting what a comparison
@@ -1231,49 +1700,64 @@ And the grounded complement — asked, and refused:
   `bun run explain:token-census:readme` and gated against it by
   `bun run explain:token-census:readme:check`; the fixture itself is gated
   against a fresh corpus run by `bun run explain:token-census:check`. Of
-  1,426,731 analyzed bytes, 990,840 are classified (69.45%), the remaining
-  435,891 are `unclassified`. The census emits 205,072 tokens (avg 216.3 per
+  1,426,731 analyzed bytes, 1,023,107 are classified (71.71%), the remaining
+  403,624 are `unclassified`. The census emits 241,539 tokens (avg 254.8 per
   script). Every byte belongs to exactly one token — sorted by `start`, no
-  gaps, no overlaps, `join(slice) === input` — and the `class` field is
-  provisional until #264 B5. Each B2 fill should move the classified
+  gaps, no overlaps, `join(slice) === input` — and the `class` field is the
+  vocabulary #264 B5 settled. Each B2 fill should move the classified
   percentage.
   <!-- END GENERATED token-census -->
 
 B1's `data.tokens[]` is live behind `--tokens` — a total, gapless byte
-partition whose `class` is provisional until #264 B5 (every unclaimed byte is
-`unclassified`). Since B1 its only fill source was `data.spans[]` (comment runs
+partition whose `class` draws on the vocabulary #264 B5 settled (every unclaimed
+byte is `unclassified`). Since B1 its only fill source was `data.spans[]` (comment runs
 and resolved variable occurrences); **the path fill claims resolved menu and
 command-name bytes as provisional `dir` / `cmd` tokens**, including valid path
 slashes and nested command substitutions, while ambiguous, malformed, and
-source-unmapped runs stay unclassified. **`#293`'s arg fill** in
-`src/explain/arg-tokens.ts` then claims argument names and
-their `=` (name run
-`[span.start, valueSpan.start - 1)` plus the single `=` byte at
-`valueSpan.start - 1`) on the residual left by spans, before operators see it
+source-unmapped runs stay unclassified. A substitution's bytes are located by
+the resolution's published **`innerSpan`**, never by arithmetic on its `span`:
+`span` covers `[…]` for a bare substitution but `$[…]` for one interpolated
+inside a string (the sigil is part of it), and `inner` is trimmed on top of
+that, so `span.start + 1` was one byte early in a string and two bytes wrong
+for `[ … ]`. Both refused the fill's slice check and fell through to the
+string fill, which is how a command `structure.subcommands` had already
+resolved came back as opaque `string` bytes (#325). The check itself stays:
+where `Loc` widens the resolution to its statement, the slice no longer equals
+`inner` and the bytes are left unclaimed rather than landed on the wrong
+place. **`#293`'s arg fill** in
+`src/explain/arg-tokens.ts` then claims argument names as `arg` (name run
+`[span.start, valueSpan.start - 1)`) and the single `=` byte at
+`valueSpan.start - 1` as `arg-sep` (#264 B5) on the residual left by spans,
+before operators see it
 — and **`#295`'s value fill follows it** — `src/explain/value-tokens.ts`
 claims argument value bytes and leaf array-literal members
 (`data.values.occurrences`, leaves only via `parent` containment,
-quotes-included) on the residual left by `spans`+`path`+`arg`, before the
+quotes-included) on the residual left by `spans`+`path`+`arg`+`escaped`, before the
 **B3 string/brace fills** see it — `src/explain/string-tokens.ts` claims
-quoted-string runs (delimiters included) and `src/explain/brace-tokens.ts`
+quoted-string runs (delimiters included, escapes already taken) and `src/explain/brace-tokens.ts`
 claims every residual brace delimiter (`{`/`}`), including delimiters from
 invalid braced references, on the residual left by
-`spans`+`path`+`arg`+`value`, and finally `operator` sees only what none of
+`spans`+`path`+`arg`+`escaped`+`value`, and finally `operator` sees only what none of
 them wanted — which is why the operator fill can abstain on `, / = -` outside
 `( )`, on bytes glued after an argument `=`, and on bytes glued into an
-argument name without a smarter operator scanner. Fill order is enforced by
+argument name without a smarter operator scanner. **`src/explain/escape-tokens.ts`
+claims valid string-internal escapes as `escaped`** between `arg` and `value`:
+an escape is interior to a quoted run, so it has to claim before the two fills
+that would otherwise swallow it whole, and it splits their runs into fragments
+around it the same way a `variable-*` span already did. Fill order is enforced by
 argument order to `buildTokens` ([#290 design decision 1](../../src/explain.ts)):
-`spans` claims first, then `path`, `arg`, `value`, `string`, `brace`, and
-finally `operator`.
+`spans` claims first, then `path`, `arg`, `escaped`, `value`, `string`, `brace`,
+and finally `operator`.
 `ExplainTokenClass` is
-`ExplainSpanClass | "dir" | "cmd" | "operator" | "arg" | "value" | "string" |
-"brace" | "unclassified"` — one
-provisional `operator` class for all 26 spellings + 2 aliases, one provisional
-`arg` class for both the name bytes and the `=` separator, one provisional
-`value` class for every leaf value span, plus provisional `string` (quoted
-runs) and `brace` (scope delimiters) — emit first, name later (whether the `=`
-or per-shape `value` later deserve their own classes is #264 B5 and does not
-move the byte coverage), not per-operator/per-category/shape (`#264` B5).
+`ExplainSpanClass | "dir" | "cmd" | "operator" | "arg" | "arg-sep" | "value" |
+"string" | "escaped" | "brace" | "unclassified"` — one `operator` class for all 26
+spellings + 2 aliases, `arg` for an argument's name bytes and `arg-sep` for the
+single `=` that binds it to its value, one `value` class for every leaf value
+span, plus `string` (quoted runs minus their escapes), `escaped` (one valid
+string-internal escape sequence) and `brace` (scope delimiters). #264
+settled which of those merges keep their name and which do not, on a stated
+rule rather than taste — see
+[The vocabulary](#the-vocabulary-and-what-earns-a-class-264-b5).
 `ExplainSpanClass` and `data.spans[]` stay proof-only; `src/explain/operators.ts`
 remains data plus accessors, and the operator table above is its source. The
 `centrs → highlight` projection is B4 and reads both.
@@ -1289,11 +1773,413 @@ each grounded on the corpus device oracle (`parseil_results.il_text`):
 | A spelling glued immediately after an argument `=`. | `in-interface-list=!LAN`, `.id=*2`, `oid=.1.3.6.1.2.1` — the byte after an argument `=` starts the value. |
 | A spelling glued into an argument **name**. | `:foreach x in=$list` is `/foreach counter=$x` with no `(in …)` node anywhere; the IL keeps `security.authentication-types=wpa2-psk` as one name and renders `.id` as the single symbol `$.id`, never `(. …)`. |
 
-The first abstention has a measured cost: `find where name="x"` inside `[ … ]`
-*does* lower to a real `(= $name x)` node, so 224 of the corpus's 1,259
-bracket-interior `=` bytes are genuine comparisons that now stay
-`unclassified` — against 1,035 that were plain `arg=value`. A `where`-aware
-fill can take them back later; claiming all 1,259 would be 82% wrong.
+The first abstention has a measured cost, and it is now generated rather than
+asserted. The figures below were prose with no script behind them and no gate
+on them for three releases, quoting a `224` / `1,259` / `1,035` split that no
+universe reproduces (#341). The abstention itself is as wide as it ever was —
+what was wrong was the accounting of it. They are re-derived by
+`bun run explain:bracket-equals` and gated by
+`bun run explain:bracket-equals:readme:check`.
+
+<!-- BEGIN GENERATED bracket-equals — regenerate with `bun run explain:bracket-equals:readme` -->
+Measured by `bun run explain:bracket-equals` over the pinned corpus:
+**1,079** `=` bytes sit inside `[ … ]`, across
+263 of 948 scripts, and **1,067** of them come back
+`unclassified` — the operator fill abstains on essentially all of it. No
+later fill rescues them: the `arg` fill claims **0**, because it offers only
+the `=` its own located argument token names and a `[ … ]` substitution is
+not where it locates arguments.
+
+Of those 1,067, **448** are governed by a `find`/`where` query and are
+genuine comparisons — the device lowers `[find address=$IP]` to
+`(= $address $IP)` — against **619** plain `arg=value`. So abstaining is
+42.0% wrong and claiming the lot would be 58.0% wrong; a `where`-aware
+fill can take the query half later. For contrast the fill does claim
+**1,402** `=` bytes whose innermost opener is `(`.
+
+The query reading is the device's, not a guess: on 7.24.2, 93 of the
+137 scripts carrying one have IL with at least as many `(= …)` nodes.
+Of the rest, 28 are scripts the console refused outright — their IL is prose,
+with no nodes of any kind — and 16 use a menu the capture build could not
+resolve (a forum snippet on `/interface wireless` answers `bad command name
+wireless`), so the device never reached the query to lower it. Neither is a
+counter-example to the reading. Whole-corpus `(= …)` head nodes, which also
+count expression comparisons the fill already claims:
+7.23.5 1,233, 7.24.2 1,240, 7.25beta3 1,240.
+<!-- END GENERATED bracket-equals -->
+
+### Device agreement for the token partition (#264 B4, #263)
+
+The census above counts what offline analysis *claimed*. This counts what the
+device *agreed with*. The oracle is the committed stratified slice of the Q13
+`/console/inspect request=highlight` captures
+([`test/fixtures/explain/highlight-streams.slice.json`](../../test/fixtures/explain/highlight-streams.slice.json)),
+so the scorer needs no router, no corpus and no network, and gates in the unit
+suite rather than in the corpus job. Both oracles must see the same bytes, so
+the source text is reconstructed from the device's own run-length pairs — never
+from the corpus row, which still holds the non-ASCII the capture replaced
+(the #269 rule, one layer up).
+
+**`highlight` is not one oracle; it is four kinds of answer.** Scoring a byte
+means first knowing what kind of answer came back, because three of the four
+are not judgments about syntax at all:
+
+| Kind | Classes | Why it cannot be scored as agreement |
+| ---- | ------- | ------------------------------------ |
+| syntax | `cmd` `dir` `arg` `arg-dot` `arg-scope` `comment` `escaped` `syntax-meta` `variable-local` `variable-global` `variable-auto` `variable-parameter` | — this is the region that can be scored |
+| non-syntax | `obj-inactive` `obj-dynamic` `obj-disabled` `variable-undefined` `syntax-obsolete` | The source text alone does not decide these. centrs has no class for most of them at all — `ExplainSymbolClass` deliberately excludes `undefined` — and where it *does* claim the byte (an `arg` the device calls `obj-inactive`) it is the **scorer** that abstains, because the device was not making a syntax judgement there. *Why* each one is out of reach is a second question, answered per byte rather than per class; see applicability below. |
+| silence | `none` | The device's abstention, not a class named "none". Agreeing with silence is not agreement. |
+| parser-stop | `error` | The device gives up here — see below. |
+
+**Applicability is a second axis, and it is not the class name.** #263's four
+categories — offline-decidable, schema-dependent, state-dependent,
+version-dependent — are assigned from the *pair* (what centrs read the byte as,
+what the device called it) plus whether the two captures even agreed, because
+one highlight class carries more than one category. Version disagreement is
+checked first, ahead even of the device's own silence: a byte one build
+classifies and the next leaves `none` is a version difference, not an absence.
+`obj-inactive` on an argument name means the menu's schema has no such field
+(**schema** — `default-vlan-id`, under an `/interface ethernet switch port` a
+CHR does not have); the same class on a menu or command name means the package
+is not installed on this box (**state**: `/zerotier`, `/user-manager`,
+`/container`). `obj-dynamic` on the routing table `main` is a live object
+(**state**).
+`syntax-obsolete` is this version's deprecation table talking, landing on the
+whitespace where modern syntax wants `=` (`} else {`, `:foreach conn in
+$conns`) — **version**. And `variable-undefined` is deliberately left
+**uncategorized**: an undefined reference may be an external global, a
+query/filter field name or a lexical spelling, nothing committed here separates
+the three, and an absent binding in *this* document is not evidence of a
+runtime undefined variable either. Leaving it explicit is the answer, not a gap
+to be filled by assumption.
+
+**The device stops classifying at its first `error`, and mostly does not
+recover.** Measured over the slice, `error` appears **at most once per script
+and is always exactly one byte wide**, and on long-term 7.23.5 every byte after
+it comes back `none`. Most of the slice sits in that tail. A percentage computed
+over the whole stream therefore measures the device giving up, not the parser,
+which is why the tail is its own outcome and is never folded into agreement. The
+rule is not absolute across versions, so the report does not assert it: stable
+7.24.2 and development 7.25beta3 classify again after the `error` in one run and
+stop on fewer scripts, and
+`parser-recovered` in the table below is the figure that says by how much —
+zero would have been the claim, and it is not zero. Both counts are generated,
+not quoted here, so neither can go stale against the fixture.
+
+**The projection is declared, never fitted.** `src/explain/highlight-projection.ts`
+maps each centrs token class to the device classes it predicts, justified by
+what the class was *defined* to mean rather than by where it happened to land.
+A projection tuned to the measurement would make the measurement circular. So a
+class whose intent has no single device counterpart — `string`, which spans a
+delimiter the device calls `syntax-meta`, escapes it calls `escaped` and an
+interior it declines to classify, and `value`, for which the device has no class
+at all — projects nowhere, and its bytes are counted as `unprojected` with the
+device's own answers tabulated beside them. That table is the evidence #264 B5
+needs in order to decide which provisional merge deserves to be split; it is not
+a score.
+
+<!-- cspell:disable — the example table quotes corpus script paths verbatim, forum-thread typos included -->
+<!-- BEGIN GENERATED highlight-agreement — regenerate with `bun run explain:highlight-agreement:readme` -->
+The agreement report is re-derivable with
+`bun run explain:highlight-agreement` and needs no router and no corpus: it
+scores the token partition against
+`test/fixtures/explain/highlight-streams.slice.json`, 70 stratified scripts of
+committed `/console/inspect request=highlight` output. The figures below are
+generated from `test/fixtures/explain/highlight-agreement.json` by
+`bun run explain:highlight-agreement:readme`, gated against it by
+`bun run explain:highlight-agreement:readme:check`, and the fixture itself is
+gated against a fresh measurement by
+`test/unit/explain-highlight-agreement.test.ts`. Of 85,529 bytes at 7.24.2,
+27,974 are bytes **both** sides decided a syntax class for, and 99.99% of
+those agree (dev 99.99%, holdout 100.00%). Set `comment` aside — it is 65.63%
+of that decided region and mostly the corpus's harness-injected `# Source:`
+banner (#203) — and the remaining 9,615 bytes agree 99.98%. The device stops
+classifying at its one-byte `error`: 36 of 70 scripts carry one, and the
+41,968 bytes from there on are not a judgment about anything. The oracle
+itself moves between captures: 36 stop at 7.24.2 and 43 stop at 7.23.5 and 36
+stop at 7.25beta3, and 27 of the 70 streams differ between them. **This is a
+trend line, not a pass gate** — the slice is a per-(split, class) quota over a
+corpus that is 96.8% two authors, so the percentage describes this slice.
+
+| centrs class | projects to | agree | disagree | unprojected | of decided |
+| ------------ | ----------- | ----: | -------: | ----------: | ---------: |
+| `comment` | `comment` | 18,359 | 0 | 0 | 100.00% |
+| `variable-local` | `variable-local` | 1,123 | 0 | 0 | 100.00% |
+| `variable-global` | `variable-global` | 582 | 0 | 0 | 100.00% |
+| `variable-auto` | `variable-auto` | 92 | 0 | 0 | 100.00% |
+| `variable-parameter` | `variable-parameter` | 459 | 0 | 0 | 100.00% |
+| `dir` | `dir` | 1,677 | 0 | 0 | 100.00% |
+| `cmd` | `cmd` | 2,244 | 0 | 0 | 100.00% |
+| `arg` | `arg`, `arg-dot`, `arg-scope` | 2,188 | 0 | 0 | 100.00% |
+| `arg-sep` | `syntax-meta` | 382 | 0 | 0 | 100.00% |
+| `operator` | `syntax-meta` | 237 | 2 | 0 | 99.16% |
+| `brace` | `syntax-meta` | 211 | 0 | 0 | 100.00% |
+| `string` | *abstains* | 0 | 0 | 499 | — |
+| `escaped` | `escaped` | 418 | 0 | 0 | 100.00% |
+| `value` | *abstains* | 0 | 0 | 144 | — |
+
+| outcome | bytes @7.24.2 | bytes @7.23.5 | bytes @7.25beta3 |
+| ------- | ----: | ----: | ----: |
+| agree — both decided, projection accepts | 27,972 | 27,218 | 27,972 |
+| disagree — both decided, projection rejects | 2 | 2 | 2 |
+| unprojected — no declared projection covers the pair | 643 | 633 | 643 |
+| offline-silent — device decided, centrs abstained | 4,300 | 4,150 | 4,300 |
+| non-syntax — the device answered something syntax cannot decide | 847 | 733 | 847 |
+| device-silent — centrs decided, device said `none` | 5,815 | 5,674 | 5,815 |
+| both-silent | 3,886 | 3,702 | 3,886 |
+| parser-stopped — at/after the device's `error` byte, and silent from there | 41,968 | 43,417 | 41,968 |
+| parser-recovered — past that `error`, and the device classified anyway | 96 | 0 | 96 |
+
+Where the device decided and offline analysis did not (4,300 bytes at 7.24.2,
+the next fill's target list): `syntax-meta` 3,122, `comment` 355,
+`variable-local` 326, `arg` 197, `escaped` 145, `dir` 66, 89 across the rest.
+Most of the `syntax-meta` share is whitespace the device merged into an
+adjacent structure run rather than a token centrs missed.
+
+**Applicability** is the second axis (#263): of the bytes the device did
+answer, what kind of fact was it answering? Assigned from the pair — what
+centrs read the byte as and what the device called it — plus whether the
+captures agreed, never by assigning a whole class to one category. It covers
+every measured byte, the post-`error` tail included: where one capture stops
+parsing and the next does not, that tail IS the version disagreement, which is
+why it dominates the category.
+
+| applicability @7.24.2 | bytes | leading cells |
+| ---------------------------- | ----: | ------------- |
+| offline-decidable | 32,002 | `comment` → `comment` 18,006, `unclassified` → `syntax-meta` 2,999, `cmd` → `cmd` 2,132 |
+| schema-dependent | 326 | `arg` → `obj-inactive` 326 |
+| state-dependent | 168 | `dir` → `obj-inactive` 120, `cmd` → `obj-inactive` 21, `unclassified` → `obj-dynamic` 20 |
+| version-dependent | 1,158 | `comment` → `comment` 353, `unclassified` → `obj-inactive` 159, `unclassified` → `syntax-meta` 123 |
+| uncategorized | 213 | `unclassified` → `obj-inactive` 90, `unclassified` → `variable-undefined` 75, `value` → `variable-undefined` 21 |
+| no-device-answer | 51,662 | `none` where the captures agree, wherever it falls |
+
+One representative run per cell, so B5 reads a fragment rather than a count.
+`runs` is how often that exact fragment occurs; the location is a slice script
+and a byte offset into the stream the device saw.
+
+| outcome | cell | fragment | runs | first at |
+| ------- | ---- | -------- | ---: | -------- |
+| disagree | `operator` → `arg` | `"in"` | 1 | `forum/amm0/topic-169456-having-the-where-filter-in-scripting-signifantly-increases-the-execution-time-an/post-0006-snippet-01.rsc` @615 |
+| unprojected | `string` → `syntax-meta` | `"\""` | 311 | `eworm/ppp-on-up.rsc` @435 |
+| unprojected | `value` → `syntax-meta` | `"\""` | 88 | `forum/amm0/topic-153357-using-wifiwave2-to-bridge-two-audience-wirelessly-thoughts-4-address-mode/post-0001-snippet-01.rsc` @1436 |
+| unprojected | `string` → `arg` | `"as-value"` | 1 | `forum/amm0/topic-266499-how-to-condense-variables-passed-through-to-function/post-0020-snippet-01.rsc` @279 |
+| unprojected | `string` → `cmd` | `"len"` | 1 | `forum/amm0/topic-155978-zerotier-on-mikrotik-a-rosetta-stone-v7-1-1/post-0001-snippet-01.rsc` @1794 |
+| unprojected | `string` → `dir` | `":"` | 1 | `forum/amm0/topic-155978-zerotier-on-mikrotik-a-rosetta-stone-v7-1-1/post-0001-snippet-01.rsc` @1793 |
+<!-- END GENERATED highlight-agreement -->
+<!-- cspell:enable -->
+
+**What the disagreements are.** Two cells carry all of them, and neither is a
+lexing accident:
+
+- `arg` → `syntax-meta`: the `=` byte the `arg` class merges in. The device
+  reads a separator as structure. This is the measured cost of the merge the
+  token-census block already flags, and it is the single largest reason `arg`
+  scores below the other name-coincident classes.
+- `operator` → `arg`: the space-separated `in` of `:foreach conn in $conns`,
+  which the device reads as the argument **name** `in`. The two oracles
+  genuinely differ here — `:parse` IL carries `in` in the operator set, and the
+  operator-abstention table above already records that `:foreach x in=$list`
+  lowers with no `(in …)` node.
+
+The third cell is gone. `cmd` → `dir` was the whole of #324 — a known menu path
+carrying arguments and no verb, where `verbsplit` promoted the last segment;
+those 12 bytes now abstain instead of disagreeing, and the 14 `dir` bytes the
+same statements contributed to `agree` abstain with them. That is the price,
+and [the fix states it](#the-menu-path-with-arguments-324): withdrawing a
+fabricated verb also withdraws the menu reading it was built on.
+
+The `unprojected` residue is what #264 B5 read to decide which merges to
+split — [The vocabulary](#the-vocabulary-and-what-earns-a-class-264-b5) records
+the verdict on each. It was also where #325 lived:
+a quoted string claimed any `$[…]` substitution inside it, so bytes the device
+resolves to `cmd` or `dir` came back as one opaque `string` run even though
+`structure.subcommands` had already resolved that same span. Those cells have
+largely emptied (`string` → `cmd` 42 → 3, `string` → `dir` 19 → 1, with the
+same fix recovering padded bare brackets `[ … ]` from `offline-silent`), and
+the two residues left are stated rather than fixed:
+
+- `$(…)` — a **parenthesized** interpolation carrying a bracket, as in
+  `apikey-len=$([:len $apikey])`. Only `$[` is scanned inside a string, so the
+  inner command is not resolved there in the first place; this is a parser
+  reach, not a fill-order question (4 bytes on the slice).
+- a bare-word **argument** inside a substitution — `as-value` in
+  `:put "$[/ip address print as-value]"`. The path fill claims the path and
+  verb; the argument fill reads `statements[].arguments`, and a substitution is
+  not a statement, so it has no candidate to claim (8 bytes).
+
+The `$` sigil and the `[` / `]` delimiters stay `string`, and `value` bytes
+are, to the device, simply unclassified — both settled by
+[The vocabulary](#the-vocabulary-and-what-earns-a-class-264-b5) below.
+
+### The vocabulary, and what earns a class (#264 B5)
+
+`data.tokens[]` shipped with its `class` marked provisional from B1 onward —
+emit first, name later (#293 design decision 2). This is the "name later", and
+the vocabulary below is what `@tikoci/centrs/explain` offers a consumer. It is
+no longer provisional.
+
+**The rule a class has to pass.** A merged class is split when both hold, and
+stays merged otherwise:
+
+1. **A consumer needs the distinction** — it changes what that consumer renders
+   or decides, not just how a token dump reads.
+2. **The envelope cannot already supply it** — the distinction is not
+   recoverable by joining `tokens[]` to another published surface on byte
+   offsets.
+
+The second test is the one that does the work. A class that restates a fact
+`structure`, `symbols` or `values` already publishes is a second place for that
+fact to go stale, and the two copies can then disagree about the same bytes. So
+the question is never "would a name here be nice"; it is "what would a consumer
+have to do without it". Applied to the five merges the fills carried, exactly
+one passes:
+
+| merge | what a consumer would do without it | verdict |
+| ----- | ----------------------------------- | ------- |
+| `arg` — the name bytes **and** the `=` | subtract one from `arguments[].valueSpan.start`, which exists only where the STRICT reading read. **5,088 of the 16,526 `=` runs the fill paints (30.8%, in 436 of 948 corpus scripts) sit in a statement whose `arguments` refused** — led by `do=` (2,393), `else=` (328) and `in=` (212), the block binder of every `:if`, `:foreach` and `:while`. For those there is nothing to subtract from. | **split** → `arg-sep` |
+| `operator` — 26 spellings + 2 aliases | slice the input at the token's span: the spelling *is* the bytes, and `src/explain/operators.ts` maps it to its IL node | keep |
+| `value` — every leaf, whatever its shape | join `data.values.occurrences[]` on the offset; #225's three axes (shape, observed, schema) live there, and a class per shape would be a fourth copy free to contradict them | keep |
+| `brace` — scope and array delimiters | `structure.blocks[]` locates every scope block; an array container is the `values.occurrences[]` entry that is some other occurrence's `parent` | keep |
+| `string` — delimiters, escapes, interior | the opening delimiter is the run's first byte and, where the run is closed, the last is its partner (an unterminated one is already a located defect). The **escapes were a different answer** — see below | **partly split** → `escaped`; delimiters and interior stay merged |
+
+Re-derive the `arg-sep` figures with `bun run explain:arg-reach`, which prices
+the same gap it prices the reach fork with.
+
+**What the split cost.** Nothing, which was the claim and is now the
+measurement. Classified bytes are identical — 1,023,405 of 1,426,731 (71.73%),
+equal to the last recorded decimal before and after — and `arg` gave up exactly
+the 16,526 bytes `arg-sep` claims, one per attribute. Token count rises 214,503
+→ 231,026 because one run became two. **This is a retag.**
+
+(Those totals are the corpus as it stood for THIS measurement. The classified
+total is 1,023,107 today: #347/#348 later classified 8 further bytes, and #355's
+fail-closed symbol stop then unclaimed 306 of them — variable bytes sitting
+after a bare apostrophe, which the device never reaches. The identity being
+claimed here is between the two sides of the split, not with any later total —
+restating it against today's figure would credit this retag with a movement a
+different change made. The generated block above carries the current numbers.)
+
+One count is not a clean split: `arg`'s own run count falls 16,526 → 16,523.
+Three attributes lost their name run entirely, because an earlier `variable-*`
+span had already claimed the name bytes — `set $ifcId ssid=$ssid`, and two
+`on-error=` in one snippet — leaving only the `=` on the residual. Before the
+split those three emitted a token *called* `arg` that contained nothing but an
+`=`. That is the merge in miniature, and it is why the number goes down.
+
+**The agreement number moved a long way, and it is still not a score.** Against
+the committed device slice, projection disagreements fall **360 → 2** and the
+decided region goes 98.66% → 99.99% (`arg` alone 85.50% → 100.00%). Read that
+as the withdrawal of a wrong assertion, not as a parser that got better: centrs
+stopped calling a separator a name over the 358 runs the device had been
+reading as `syntax-meta` all along, and not one byte changed which analyzer
+found it. The two survivors are the `operator` → `arg` `in` of
+`:foreach conn in $conns`, where the two oracles genuinely differ.
+
+The projection entry was **declared before the measurement, never fitted to
+it**: `arg-sep` predicts `syntax-meta` because a separator is structure
+punctuation, the same reason `brace` and `operator` predict it. The slice then
+put 358 of 358 there.
+
+**Where the tolerant reading reaches the envelope (#316's open decision).** It
+reaches it *as the token partition*, and that is the only place it should.
+`structure.statements[].arguments` stays the strict all-or-nothing reading,
+because its consumer renders a runnable request and a half-read argument list
+changes what the rendered command does. But with the `=` named, `tokens[]`
+locates the argument on its own:
+
+```text
+/ip route add dst-address=1.1.1.1 gateway=$gw
+  arguments: { read: false, why: "a variable value" }
+  tokens:    … arg("gateway") arg-sep("=") unclassified("$") variable-parameter("gw")
+
+:if ($x = 1) do={ :put "hi" }
+  arguments: { read: false, why: "a substitution or expression value" }
+  tokens:    … operator("=") … arg("do") arg-sep("=") brace("{") …
+```
+
+Neither statement publishes a single argument, and in both a browser consumer
+can still see a located `gateway=` / `do=`. The second line is the
+discrimination working as well: the same `=` byte is `operator` inside
+`($x = 1)` and `arg-sep` in `do=`, decided by fill order and meaning rather
+than by a byte scan.
+
+What `tokens[]` still does **not** carry is the *reason* a value was not
+decoded. `undecided` stays off `ExplainArgumentToken` and out of the
+envelope: the envelope's value-fact surface is `data.values.occurrences[]`,
+where absence at an offset already *is* the abstention, and a second spelling
+of the same abstention would be free to disagree with it. A consumer that needs
+the reason imports `lexExplainArgumentTokens` from the package root — which is
+why that export exists.
+
+**The second split the rule admits, now made: `escaped`.** A *valid* string
+escape is recoverable from nothing. Only INVALID ones surface elsewhere, as
+`bad-string-escape` diagnostics, so a consumer holding `tokens[]` has no
+published surface to join against to find the valid ones — and the device does
+class them, as one of the 19 highlight classes. Both halves of the rule hold,
+so the class is earned.
+
+Unlike `arg-sep` this is a **fill change** rather than a pure relabel of one
+analyzer's own output: the escape grammar (uppercase-hex `\XX`, the whitespace
+continuation, the twelve single-character forms) has to be walked, and the
+bytes come out of two fills at once rather than one.
+`src/explain/escape-tokens.ts` runs between `arg` and `value`.
+
+**The walk is not new, and deliberately not a second one.**
+[String escape validation](#string-escape-validation-247-252) already owned this
+grammar for `bad-string-escape`. `walkStringEscapes` now returns *both* halves
+of that one reading — the valid escapes and the first invalid one — so an
+`escaped` token and a `bad-string-escape` diagnostic cannot disagree about which
+bytes are an escape. Deriving them from two walks would have made that
+disagreement possible, and the document is walked once rather than twice. The
+walk stops at the first invalid escape, so `escaped` is the prefix the validator
+vouched for: past a malformed escape the string boundaries are themselves in
+doubt, and painting there would be a claim the walk cannot support.
+
+**What the split cost: nothing, and the census proves it.** On the corpus
+`escaped` claims **19,960 bytes over 7,408 tokens**, and every one of those
+bytes came from a fill that already held it — `string` gives up 17,672 and
+`value` 2,288, which is exactly 19,960. Classified bytes are **identical to the
+last decimal**, 1,023,405 of 1,426,731 (71.73076073906013%), so in byte terms
+this is a retag even though it took a new walk to make — again, the identity is
+between this change's own before and after, and the corpus total has since moved
+to 1,023,107 / 241,539 tokens under #347/#348 and #355. Only the token count
+moves, 231,026 → 241,663: the 7,408 new `escaped` tokens plus the 3,229
+fragments they leave behind when they split a run they sit inside (`string`
++2,643, `value` +586). That second number is well under one per escape because
+escapes cluster — adjacent ones like `\C3\BD`, and ones flush against a
+delimiter, add no fragment at all.
+
+**What it bought.** Against the committed device slice `escaped` claims **418
+bytes on 100.00% agreement, 0 disagreements** — the 53 `string` → `escaped`
+runs and the 1 `value` → `escaped` that were `unprojected` before, scored for
+the first time. Total `unprojected` falls **1,051 → 633 bytes** (−39.8%) and the
+both-decided region grows 26,794 → 27,212. No byte changed which analyzer found
+it and no disagreement was introduced.
+
+The projection entry was again **declared before it was measured**: `escaped`
+predicts `escaped` because the class means one valid string-internal escape and
+that is the run the device gives the same name. `escaped` was already listed in
+`DEVICE_CLASS_KIND` as a syntax class; the agreement report's `unprojected`
+table showed the bytes were being merged away, it did not pick the target.
+
+**The residue this does not claim, sized.** 145 bytes across 24 runs in 4 slice
+scripts stay `unclassified` where the device says `escaped`, and every one of
+them is the same shape: a `\`-newline **line continuation in code**, outside any
+string (`… != true) \<newline>      do={`). The device's run there swallows the
+next line's indentation too, so the 145 bytes are 48 of `\`+terminator and 97 of
+trailing whitespace. That is a different claim from a string escape — centrs has
+no continuation token, and matching the device would mean deciding how much
+following whitespace a continuation owns — so it is **not** folded in here. It
+belongs with the continuation question #225 already owns (what a continuation
+does to a value's interior); this paragraph is its size, not a plan.
+
+Delimiters are the near miss that shows the rule discriminates rather than
+rubber-stamps: `"` bytes are 311 `string` → `syntax-meta` runs and 88
+`value` → `syntax-meta`, the device classes them too, and they stay merged
+anyway, because a consumer can find them by looking at the run's own first and
+last byte. The `$` sigil and the `[` / `]` of a substitution stay `string` on
+the same ground — `structure.subcommands` already publishes the resolution, and
+its `innerSpan` locates the brackets around it.
 
 ### Designed, not implemented (the CLI surface, #202b)
 
@@ -1314,12 +2200,11 @@ That is the difference — an accepted flag must do something observable.
 
 ## MCP and library surfaces
 
-- **The cross-project handoff is the structure layer, not the token layer.**
-  `explain`'s data is three layers: byte ranges and their classes
-  (`spans`, and `tokens` when #264 lands) — centrs-owned, and nothing outside
-  centrs consumes them; the resolved reading (`structure`, `symbols`,
-  `values`) — path, verb, argument names, value spans; and doc/version
-  enrichment, which is rosetta's (#175). A consumer that wants enrichment takes
+- **Consumers use the layer that answers their question.** Byte ranges and
+  their classes (`spans` and the shipped `tokens` facet) serve editor/token
+  consumers; the resolved reading (`structure`, `symbols`, `values`) carries
+  path, verb, arguments, and value facts; doc/version enrichment belongs to
+  rosetta (#175). A consumer that wants enrichment takes
   the **middle** layer: given `{path, verb, args}` plus a version it does its
   own lookups, whereas handing it tokens would make it re-derive from bytes a
   path centrs already resolved. So #223 is a decision about the structure
@@ -1350,8 +2235,102 @@ That is the difference — an accepted flag must do something observable.
   shapes. `lsp-routeros-ts` and
   tikbook are the intended external consumers (hover/diagnostics/completion/
   semantic tokens over these calls); an LSP *protocol* surface on centrs
-  stays out of scope (#90) — but the export shape is validated against a real
-  LSP consumption spike before it hardens (staging phase 4).
+  stays out of scope (#90). A bounded offline browser/editor consumption check
+  now precedes vocabulary stabilization (#264 B5); full live LSP integration
+  remains later work. The entry is `@tikoci/centrs/explain` and it is browser-verified —
+  see [The offline package entry](#the-offline-package-entry-312).
+
+### The offline package entry (#312)
+
+**`@tikoci/centrs/explain` -> `src/explain.ts`** is the documented public entry for
+offline analysis. It is a real boundary, not a naming convention: the module
+graph reachable from it opens no connection, reads no CDB, and touches no
+filesystem, so it bundles and runs in a browser, a Worker, or an editor host.
+
+```sh
+bun run explain:browser-consumer          # boundary + executed consumer report
+bun run explain:browser-consumer --json   # machine-readable
+```
+
+Both halves are gated in the unit suite by
+`test/unit/explain-browser-entry.test.ts`, so neither needs a router or the
+corpus.
+
+**Why a gate and not a note.** The entry reached the transport stack until this
+landed, for two *pure* helpers: `toYaml` (from `retrieve.ts`) and
+`canonicalizeExecuteCommand`/`isWriteShaped` (from `execute.ts`). Importing
+either dragged in `mac-telnet` (`node:dgram`, `node:os`), `native-api`
+(`node:crypto`) and `ssh`. Both now live in `src/core/` — `src/core/yaml.ts` and
+`src/core/execute-command.ts` — moved character for character, with `execute.ts`
+re-exporting the gate because it remains that gate's documented public home.
+**Nothing about the script-vs-structured gate moved with them**; the locked
+contract table in `test/unit/execute-canonicalize-contract.test.ts` still imports
+from `execute` and still passes.
+
+That coupling was re-introduced once already by a one-line import, which is why
+the static half of the check names the offending **edge** (`explain.ts ->
+execute.ts -> mac-telnet-console.ts -> mac-telnet.ts`) rather than leaving a
+reader with the bundler's polyfill complaint four modules downstream.
+
+**What "runs in a browser" is proven by.** Compilation is not the proof. A
+bundler silently substitutes browser polyfills, so the check bundles a worker
+entry around the module with `--target browser`, wraps the output in a function
+that shadows every host global (`Bun`, `process`, `require`, `module`,
+`exports`, `__dirname`, `__filename`), and **spawns that bundle as the Worker**.
+`Bun` is a non-configurable global — `delete globalThis.Bun` throws — so
+shadowing, not deletion, is what makes the absence real, and doing it in the
+bundler's banner keeps the harness free of `eval`/`new Function` while making
+the bundle text on disk the artifact that carries the claim.
+
+It then compares the whole `ExplainData` against the Bun-native run, field for
+field: structure, diagnostics, tokens, spans, `canonical`, and
+`runtimeAcceptance`. Fourteen cases, covering normal and write-shaped commands,
+multi-statement and nested input, three malformed classes, Unicode, astral, a
+leading BOM, IPv6, empty input, and the facets switched off. All fourteen are
+byte-identical today.
+
+Two things the bundle deliberately exercises rather than bypasses. It imports
+through the **published subpath** `@tikoci/centrs/explain`, not
+`../src/explain.ts`, so a typo in `package.json`'s `exports` map fails the gate
+instead of leaving it green while every real consumer breaks (the graph walk
+additionally asserts that the `exports` entry and the measured file are the same
+path). And it calls `resolveExplainFormat(undefined)`, whose `env` default is
+the `typeof`-guarded `hostEnv()` — nothing else reaches that parameter, so
+without this a regression to a bare `Bun.env` would pass every case here while a
+browser caller of that exported function got a `TypeError`.
+
+The shadowing is **measured from inside the bundle**, not assumed: the worker
+reports which host globals it could still see, and an empty list is part of the
+gate. Without it, a wrapper that silently stopped being emitted would leave
+every "identical" above produced with host APIs in reach, proving nothing. Only
+`Bun` and `process` are probed, because they are the only two of the seven a
+bundle can honestly observe — Bun constant-folds `typeof require` to
+`"function"` at build time, mentioning `__dirname`/`__filename` makes it inject
+the build machine's absolute paths as local constants (the probe would cause
+what it reports), and mentioning `module`/`exports` reclassifies the entry as
+CommonJS, whose top-level `export default` is a syntax error inside the wrapper.
+All seven stay shadowed regardless.
+
+The one tolerated host builtin is **`node:net`**, for `isIP` in
+`src/explain/values.ts` — a pure predicate with no socket in it. A bundler
+replaces it with a regex pair, so the browser build genuinely runs a *different*
+`isIP` than Bun does; the two IPv6 cases exist to price that substitution, which
+is the only place its verdict is observable. A builtin that polyfills to a stub
+(`node:fs`) or throws (`node:dgram`) could not be checked this way, so the
+allowlist is a boundary, not a list to extend.
+
+**What it does not claim.** Not that the `centrs` package works in a browser —
+it does not, and is not meant to. Not DOM integration, no real browser engine.
+And these cases are a boundary corpus, not a parser-coverage corpus; measured
+parser evidence stays in the censuses and
+[Device agreement](#device-agreement-for-the-token-partition-264-b4-263).
+
+**What this hands #264 B5.** The comparison serializes the entire public result,
+so it pins the vocabulary a consumer actually depends on: every `tokens[]` class
+name, every span pair, and the `ExplainData` key set are now load-bearing across
+a process boundary. A B5 rename is therefore a visible break here rather than a
+silent one — which is the point of settling the vocabulary before an external
+consumer commits to it.
 
 ## Non-goals
 
@@ -1418,7 +2397,8 @@ of 913). The ratified answers hold for what was measured; they are **not**
 evidence of coverage over device configuration, which is the genre most likely
 to be handed to `explain` and the one that concentrates Q4 path context and
 Q6's bare-path ambiguity. Quote phase-0 numbers per genre, never as one blended
-figure. #203 tracks the capture and the re-score.
+figure. #203 records the capture decision and caveat; #336 owns the current
+corpus repin and remeasurement.
 
 Those figures are re-derivable, not eyeballed: `bun run explain:corpus-census`
 (`scripts/explain-corpus-census.ts`) reproduces the whole genre table from
@@ -1430,8 +2410,33 @@ literals, and DHCP client-ids as `:` directives, which under-counts exactly the
 config genre in question). Since phase 0 the corpus has grown to 948 with a
 `tangentsoft` stratum of 35 genuine `/export … terse` device captures, taking
 export-banner share to 4.6%; **that stratum is not part of any phase-0 figure
-above**, and no promoted module has been scored against it yet (#203
-deliverable 2).
+above**. Current whole-corpus offline censuses include its source text.
+
+The pinned snapshot carries **three complete builds** — long-term `7.23.5`,
+stable `7.24.2` and development `7.25beta3` — each with *both* oracles over all
+948 scripts, alongside six partial captures (parseIL at 7.20.8, 7.22.1,
+7.23rc1; highlight at 7.9.2, 7.23.2, 7.24rc2) that cover only 913. Schema v4
+names that split rather than leaving it to be discovered by hand: the
+`v_version_coverage` view classifies each build, and
+`coverage_class = 'complete'` is the filter every version-comparable query uses.
+`source_scripts` is byte-identical across both repins that reached this
+snapshot, so every text-derived report — the token and value censuses,
+`explain:arg-reach`, the browser-consumer proof — is unchanged by construction,
+and only the IL-derived operator census moved.
+
+**The three complete builds do not agree with each other, and that is the
+finding.** Scored over all 948 scripts:
+
+| oracle | long-term 7.23.5 ↔ stable 7.24.2 | stable 7.24.2 ↔ development 7.25beta3 |
+| ------ | -------------------------------: | ------------------------------------: |
+| `:parse` IL (`il_sha256`) | 87 scripts differ | 11 |
+| `highlight` (count + class set) | 33 | 0 |
+
+Stable and development are the same build for these purposes; long-term is the
+one that moves. So an operator-axis or token-partition figure is a claim *about
+a channel*, not about RouterOS — which is why the census reports its builds as
+separate columns and states its version set, rather than collapsing them to one
+number. Long-term is also the channel a real device most likely runs.
 
 The corpus itself is not in this repo and is not moving here — `lsp-routeros-ts`
 owns producing snapshots, centrs owns which snapshot it measures against.
@@ -1553,75 +2558,106 @@ validity check: `.scratch/q203-blocker-validity.ts`.
 **Non-blocking / deferred (not ratification-gating):** Q5 expression depth, Q7
 tokenizer corners, Q9 potential-command taxonomy, Q12 span-vocabulary draft —
 these refine the surface during implementation but did not gate ratification.
-They keep their homes in staging: **Q7** is now concrete as #201 (lexical
-boundaries — sigil spellings, escape validity, statement-start eligibility)
-and #199 (the shared scanner's `$[…]`-in-string blind spot), both raised by the
-Q13 promotion and both spanning already-promoted modules; **Q5** and **Q9** are
-phase-1 measurements; **Q12** is spec open item 2 and hardens in phase 4. The
+Two of the four have since closed. **Q7** became #201 (lexical boundaries —
+sigil spellings, escape validity, statement-start eligibility) and #199 (the
+shared scanner's `$[…]`-in-string blind spot), both raised by the Q13 promotion
+and both now closed. **#199**'s fix is the one shared scanner,
+`src/explain/quoted-string.ts`, which is what keeps the segmenter, the brace
+classifier and the block scan from drifting on where a string ends; **#201** is
+the wider one, spanning statement context, sigil/escape reading and defect
+detection across several already-promoted modules.
+**Q12** closed with #264: the vocabulary is settled on a stated rule and is no
+longer provisional — see
+[The vocabulary](#the-vocabulary-and-what-earns-a-class-264-b5). **Q5** and
+**Q9** remain phase-1 measurements. The
 probe framework's disposition (reuse of the mutation suite, coordinate
 fixtures, and adversarial generators as product test fixtures) is tracked in
 issue #186 rather than carried into mainline.
 
 ## Definition of done and staging
 
-`designed` on the strength of this README. When implementation starts, offline
-examples gate via unit/fixture tests and each live cell advances to
-`CHR-passed` only when its `examples.md` entries run green via
-`bun run test:integration` (constitution: done definition). Suggested staging
-(sequence, not schedule):
-
-- **Phase 0 — canonicalization grounding lab — COMPLETE (#185).** Experiments (corpus +
-   CHR cross-checks against `:parse`/highlight) established what offline parsing
-   can actually achieve: statement segmentation, block/scope resolution,
-   sub-command path re-constitution, stateful-per-document path context, symbol
-   scope, transport classification, write-shape, malformed-input recovery,
-   coordinates, and stress invariants. Every ratification-gating question was
-   answered with cited evidence; the findings are folded into the surface above
-   and summarized in [Phase-0 ratification](#phase-0-ratification-185). This
-   spec is ratified on that basis.
-- **Phase 0.5 — product contract fixtures — SUBSTANTIALLY COMPLETE (#186).**
-   Promote a minimal, reviewed subset of the lab into product-owned tests; do
-   not import or execute `.scratch/` code. One vertical-slice PR per lab suite,
-   each landing an exported module under `src/explain/` plus frozen fixtures
-   under `test/fixtures/explain/`. Shipped: Q15 coordinates (#188 →
-   `coordinates.ts`), Q1 segmentation (#189 → `segment.ts`), Q2–Q4 path
-   resolution (#191 → `pathresolve.ts`), Q17 single-pass container walker
-   (#194 → `blocks.ts`, closing #190), Q6 verb/menu boundary (#193 →
-   `verbsplit.ts`), Q16 write-shape tristate (#195 → `write.ts`), Q14 cascade /
-   context-certainty (#197), Q13 symbol scope (#200 → `symbols.ts`). These pin
-   the ratified thresholds: no confident command invented after a defect, zero
-   false negatives on statically obvious writes, 100% coordinate invariants,
-   deterministic/well-formed spans, bounded depth, no throw, and roughly linear
-   scaling. **Remaining:** #192 (Q14 defect-*region* spans and the
-   `ambiguous`/`unknown` verdict vocabulary — the verdict half wants the phase-1
-   envelope). The lab framework and its two ~7.5 MB per-character highlight
-   captures stay out of mainline (#186). What durable files CITE does not stay
-   out: the frozen dev/holdout split, the Q8 REST probe capture, a stratified
-   slice of the highlight streams, and the three device re-derivation probes
-   are committed under `test/fixtures/explain/` and `scripts/probes/`.
-- **Phase 1 — offline core** — the grown canonicalizer: structure + gate
-   verdict + per-statement resolution and transport classification +
-   diagnostics (+ `--curl` rendering), and the CLI/MCP surface over it. Phase
-   0.5 shipped the analysis modules as library exports only; phase 1 composes
-   them behind one entry point, adds the envelope and `src/cli/explain.ts`, and
-   turns `examples.md` green. **Landing in four PRs:** #192a defect regions
-   (#222), #202a composition + envelope (#224), **#202b the CLI surface + the
-   offline examples**, then #202c-1 argument reading and #202c-2 transport
-   classification + `--curl`, which close #202. Carried in with it: the lexical-boundary
-   hardening (#201) and the shared-scanner substitution blind spot (#199), both
-   found during Q13 and both spanning modules already promoted; plus the
-   deferred lab questions Q5 (expression depth) and Q9 (potential-command
-   taxonomy), which become focused tests as this surface hardens.
-- **Phase 2 — live probes** — highlight + `:parse` (+
-   completion/child/syntax facets) over rest-api/native-api with the safety rules
-   above, including the
-   broad-query describe ladder, smart sizing, and CHR-backed anchors for Q6,
-   Q8, Q10, and Q11.
-- **Phase 3 — facet polish** — `--complete`/`--schema` ergonomics, truncation
-   counts/hints, `--full`.
-- **Phase 4 — library/LSP alignment** — export shape hardened against a real
-   lsp-routeros-ts consumption spike (semantic tokens via the centrs span
-   vocabulary + color map).
+Verification follows the [constitution](../../docs/CONSTITUTION.md#done-definition).
+The phase-0 grounding and promoted phase-1 CLI/library core (#185/#202) are
+already in the product. The remaining task graph is maintained in #90; issue
+closure for an earlier slice does not establish the baseline below.
+
+### Offline baseline acceptance
+
+The offline capability can advance from `coded` to `verified` when:
+
+- **Examples and diagnostics:** the offline examples and focused analysis/CLI
+  contract tests pass. Known false confident readings in the baseline task
+  list, starting with #311's missing separator, are fixed with source-located
+  diagnostics and accepted/malformed controls. Unknown or ambiguous input
+  remains explicit; no fabricated statements, paths, values, or runtime acceptance.
+- **Bounded execution:** the existing public `explainCommand` performance,
+  coordinate, depth, no-throw, and determinism contracts pass. A reproduced
+  performance failure is investigated before changing its threshold (#313). Cost
+  must grow with input size and no faster: a wall-clock budget on a thermally
+  throttled machine measures the machine, so the growth **shape** is pinned by a
+  ratio between two sizes timed back to back, and an absolute threshold is never
+  raised in place of finding the growing term. One input shape is not enough —
+  #313's separator-free input carries no symbols, so it never reaches the
+  symbol/value machinery where the next growth term was hiding (#317), and
+  neither of those carries a `do={…}`, which is where the third one was (#320).
+  A guarded shape is only guarded for the analyzers it actually runs, so a new
+  growth guard states which analyzers its input reaches and is mutation-tested
+  against the term it removed. **Met:** #322's fixed-size depth guard grows
+  nesting 16× (depth 4 → 64) under the public token/curl path and stays below
+  the 6× bound; deterministic companion guards cover colon-led, bare-directive,
+  retry, array/substitution, bracket, and string-interpolation shapes and fail
+  when child-scope traversal is restored.
+- **Measured token surface:** the total, gapless `--tokens` partition and
+  generated censuses remain reproducible; #264 B4 / #263's projection and
+  device-agreement report are in
+  [Device agreement](#device-agreement-for-the-token-partition-264-b4-263),
+  re-derivable without a router or the corpus. Report decided errors,
+  abstentions, version/state differences, and corpus bias separately — the
+  report's outcome buckets and its four applicability categories are that
+  separation. Classified-byte percentage is not syntax coverage, and agreement
+  is a trend, not a new numerical pass gate. A token-level rule and a token fill
+  read the skip-tolerant argument stream, never the strict REST reading (#316);
+  the two share one boundary walk, the strict reading's reach is unchanged, and
+  the skip-vs-prefix fork is priced rather than assumed —
+  [The token stream a rule reads](#the-token-stream-a-rule-reads-316). That
+  stream reaches the envelope as the token partition and nowhere else, which is
+  what makes the `=` boundary visible to a consumer whose statement published
+  no arguments at all (#264 B5).
+- **Usable library contract:** one bounded browser/editor consumer imports a
+  documented public offline entry point, runs analysis without transport/CDB
+  dependencies, and verifies structure, diagnostics, tokens, and source-position
+  mapping against the CLI/library result (#312). **Met** by `@tikoci/centrs/explain` and
+  `bun run explain:browser-consumer` — see
+  [The offline package entry](#the-offline-package-entry-312); the boundary is a
+  module-graph gate and the consumer proof executes the browser bundle rather
+  than only compiling it. The token vocabulary that consumer reads is settled by
+  #264 — [The vocabulary](#the-vocabulary-and-what-earns-a-class-264-b5) —
+  on a stated rule, with the two splits it makes (`arg-sep`, then `escaped`)
+  and the merges it keeps each recorded there with the surface that already
+  carries the distinction. A complete editor, LSP server, palette
+  reproduction, or SCIP implementation is not required to prove this contract.
+- **Reachable evidence and explicit residue:** changed RouterOS semantic claims
+  have committed CHR-grounded controls and a reproducible capture/replay path.
+  Every remaining issue has a stated scope and dependency; #225 distinguishes
+  offline value work from live types, #272 owns evidence reachability, and #211's
+  unlisted-path decision retains the current abstention until separately decided.
+
+Retain the existing checks: `bun run lint`, `bun run test`, `bun run build`, and
+`bun run lint:ci`, plus the affected CHR grounding/integration procedure from
+the constitution. Add the consumer and agreement checks with their implementation.
+No new rules engine, schema snapshot, final-state interpreter, or network-behavior
+test framework is part of this baseline.
+
+### Current and following capabilities
+
+- **Current — live probes (#236, phase 2):** highlight + `:parse` and
+  completion/child/syntax over rest-api/native-api. B4's projection/agreement
+  informs this work; each live cell requires its own CHR-passing examples.
+- **MCP alignment (#223):** the deliberate flat-to-rich response migration,
+  coordinated with rosetta. Independent of the offline token vocabulary.
+- **Facet polish (phase 3):** live sizing, `--full`, completion/schema ergonomics.
+- **Full LSP integration (phase 4):** consume live and offline results in
+  `lsp-routeros-ts`, building on the earlier offline consumer check.
 
 ## Decisions (2026-07-19 round) and remaining opens
 
@@ -1689,13 +2725,17 @@ Still open (implementation opens — none block ratification):
 
 1. Final flag names (`--full`, `--curl`, facet names) and the smart-sizing
    thresholds (what counts as "cheap", what triggers truncation).
-2. The centrs span vocabulary itself: class list, mapping table from RouterOS
-   highlight classes (and their colors), and how unknown/new upstream classes
-   degrade. Phase 0 pinned the raw inputs (Q13's per-occurrence highlight-class
-   corpus; the observed 19 classes on 7.23.2 plus drift on 7.24rc2) but the
-   centrs-owned class list and color map are a **draft** (lab question Q12,
-   non-ratification-gating); they harden in staging phase 4 against the real
-   lsp-routeros-ts consumption spike.
+2. The mapping table from RouterOS highlight classes to **colors**, and how
+   unknown/new upstream classes degrade. Phase 0 pinned the raw inputs (Q13's
+   per-occurrence highlight-class corpus; the observed 19 classes on 7.23.2 plus
+   drift on 7.24rc2). The centrs-owned **class list is no longer open**: #264 B5
+   settled it on a stated rule and `data.tokens[].class` is no longer provisional
+   ([The vocabulary](#the-vocabulary-and-what-earns-a-class-264-b5)), and the
+   projection onto the device's own classes is reported by
+   `bun run explain:highlight-agreement`
+   ([Device agreement](#device-agreement-for-the-token-partition-264-b4-263)).
+   What stays open here is the color map and the drift policy. Live mappings
+   and full LSP integration follow separately.
 3. Whether the live describe ladder needs result caching per target+version
    (probe cost vs freshness) — deferred to implementation evidence.