The BOQ Grammar

This document is the single source of truth for three consumers:

Everything here was learned empirically from real tender workbooks (~4,000 items across four bills, reconciled to the printed grand totals to the cent) — none of it is assumed.

The mirror stage has one job: hold in structured form exactly what the Excel file says — no more, no less, no judgement. It does not decide what the bill should contain. A blank tender, a rate-only schedule, a fully priced bill, and a structure-only skeleton are all valid documents whose blanks are facts, not defects.

This foundation is what later makes comparison possible: blank BOQ vs PTE vs multiple bidders (description changes, high/low rate errors) — all consume the same faithful mirror. If the mirror is 100% honest, every later stage is easy; if the mirror flattens or invents anything, every later stage inherits the lie.

Every value cell (Quantity, Rate, Amount) is in exactly one of three states:

The Amount cell carries an explicit amount_state: "number" | "text" | "empty" so the three states survive export and comparison. Numbers stay primary; printed text is collected and considered, never discarded and never allowed to silently become a number.

A cell counts as a number when its raw value is numeric, or when its text — after stripping thousands-commas — matches ^\(?-?\d+(\.\d+)?\)?$ (parentheses mean negative: (1,234.50) = −1234.50). Text-formatted numbers ("2,854" stored as a string) are still numbers in the source. Anything else — "###" overflow, "-", "Incl.", "RATE ONLY", blanks — is text or empty. Because the parser reads cell values, not the printed page, it is immune to ### column-width overflow.

Cell text is read by the same mirror rule in reverse: a text cell contributes its raw string (superscripts survive — m² stays m², never flattened to m2), while a numeric cell contributes its formatted display — that is what the sheet prints, including - for a format-suppressed zero.

Formula error cells (#REF!, #VALUE!, #DIV/0!, …) carry a cached numeric value in the file format, but the sheet prints the error token — so they are text, never numbers: an item amount of #REF! is captured verbatim in amount_printed with state text, counting 0 in the totals. Both engines apply this rule identically.

Accounting formats print zero as - (or blank). A stray =E×C formula can therefore put a hidden numeric 0 under a heading row. The rule that resolves this class of trap: row classification asks what the cell prints — a row is "description-only" when its Qty/Rate/Amount cells display no number (the displayed text does not parse as a number) — while item values keep the stored number: an item whose Amount prints - over a stored 0 still counts 0, exactly as the source's own totals count it. One rule, no format-specific or dash-specific hardcoding, and it covers every zero-suppressing format at once.

The document's nature is detected from content (validate()), with these exact thresholds:

Profile gates judgement: e.g. text amounts on a rate-only schedule are its nature, not per-line surprises (§4, NON_NUMERIC_AMOUNT).

A BOQ worksheet contains one table, located by its header row: the first row (searched within the first 41 rows and 13 columns of the used range — both windows inclusive and relative to where the sheet's data starts, not to A1) that labels, case-insensitively, at least Item (exact word), Description… (prefix), and Amount… (prefix). Quantity/Qty, Unit, and Rate are recognized when present but optional. A sheet with no such header row has no BOQ structure and is rejected (the sheet picker disables it).

Rows above the header row are cover/title material. Every row below it is classified by the row taxonomy (§2.2). A repeated header row (Item in the item column and Description… in the description column) marks a printed-page break and is skipped.

Some books split the quantity across several columns per row — zone/tower quantities plus their total — under headers no word-list can anticipate ("TOTAL QTY" with an embedded line-break, "NET QTY", another language). When no Quantity/Qty header matches but Rate and Amount do, the quantity column is identified arithmetically, never by its header text: it is the unmapped header-labelled column whose value satisfies value × rate = amount across the sheet's rated rows (a numeric rate and a non-zero numeric amount).

Guards, all structural:

Every non-empty row below the header is classified by testing, in this exact order (earlier tests win — an ALL-CAPS row that is note-shaped is a note, never a section title):

Total/collection/brought markers (rows 1–3) are matched against the space-joined text of the first 11 columns of the used range — a marker printed beyond column 11 is not seen (narrower than the 13-column header search; a deliberate bound, stated here so no one is surprised by it). "Description-only" everywhere in this taxonomy means prints no numbers in Qty/Rate/Amount (§1.3b) — a hidden formula-zero under a dash format does not make a heading row an item row.

An item is a row with a printed reference and a description:

The second arm transcribes priced-but-unreferenced rows faithfully; validation then raises MISSING_ITEM_REF (an error), because every priced line must carry its printed reference — this is a real anomaly seen in real bills (including a 14.99M unreferenced line).

An item whose Unit is ITEM and whose Rate holds no number (empty or text — "Incl.", "RATE ONLY") is a lump sum (is_lump_sum); when the rate cell held text, rate_printed still preserves it verbatim.

Header-labelled columns outside the standard six (e.g. a "VE Ref." column carrying "EM-16") are captured verbatim per item into extra_columns — the sheet's own header declared them item data, so the mirror carries them. No column name is special-cased; any labelled header cell not mapped to Item/Description/Qty/Unit/Rate/Amount qualifies — within the same 13-column header window as §2.1 (a labelled column beyond the 13th column of the used range is not seen; stated here so no one is surprised by it).

Each item gets a unique internal id SheetName/blockOrdinal-code; an item with no printed code uses r{ExcelRow} in place of the code (e.g. 2B/3-r57), and when the same printed code repeats within a block, ids get #2, #3… suffixes — printed codes are kept exactly as printed, ids stay unique.

An item's full_description is [section, ...heading_path, own_description] joined with " — ". A QS seeing only this line must know exactly what is being priced. The heading stack rules:

A description-only row (no code, no numbers) that has no lowercase letters, is shorter than 60 characters, and contains no ; is a section title — provided it is not note-shaped or a continuation marker, which are tested first (§2.2 order). "No lowercase letters" is the literal test: a cell holding only digits or symbols ("-", "2019") technically qualifies and resets the heading stack — a known sharp edge, stated so nobody is surprised. Any other description-only row is a governing heading — it governs the items beneath it and enters their names.

A description-only row is a note when it is note-shaped: starts with the word Note followed by : or whitespace ("Note: …" and "Note all dimensions…" both qualify), or is a bare numbered line (1) … / 2. …), or cites drawings/specifications (drawing, specification, refer to) without describing work. A sentence that describes work is a heading even when it cites a drawing — real headings do; "work-shaped" means it contains ; or the words including/includes. Note-shape wins over section-title shape (§2.2): "REFER TO STRUCTURAL DRAWINGS" is a note, not a title.

Notes are preserved verbatim in the block's section_notes[] and shown to the reviewer. They are never folded into item names. Known gap: notes that appear after a sheet's final collection row (trailing end-of-sheet notes with no items after them) currently have no block to attach to and are dropped — a candidate grammar/parser fix (§7).

Some books print their own page reference between items — a bare bill/section/page token (2/F/24) alone on its own row, the footer of the printed page (the same grammar §6.4 documents on summary sheets). These are the addresses that words like "Included in 2/F/24" point at, so the mirror captures them: each item carries printed_page, the first marker at or after its row (footer semantics — a page's items sit above its marker).

Detection is by shape, never position: a marker row carries no item code and no description, and exactly one cell prints the anchored token. " Page 2/B/1" in a summary line never matches (prefixed); a row printing two different tokens is ambiguous and skipped. A book that prints no markers yields no printed_page anywhere — the field is absent, never inferred.

Not every printed page carries items: the Zaabeel main bill prints 500 markers, of which 468 pages hold items — the other 32 are per-section collection-summary pages. In this family the marker row is usually also the block's "To Collection" row (footer and checksum share the line), which is why item-carrying pages coincide with blocks; the grammar still treats pages and blocks as separate facts, because nothing guarantees that coincidence in another book.

A line is not a flat record. Every book nests it, and the app now holds each level as its own fact rather than collapsing them into one string. Five levels, from the outside in:

The naming is a historical accident worth stating plainly, because it misleads on sight: the field called section is not the section. It holds the ALL-CAPS work-group heading the sheet prints — one book carries 75 distinct values of it against 25 real sections — so it is a level below section_ref, not the same thing. It is called the group everywhere a person can see it.

bill_ref and section_ref exist only where the book prints page markers. A book that prints none carries neither, and every check keyed to them reports itself inapplicable (§3.7) rather than guessing.

A section is named from two sources, and the workbook's own summary is senior. A section_ref is an address (2/C), not a name. The title comes from:

Capture rule for the second source: a section-title row (§2.5) that is superseded before any item appears under it is a printed section heading rather than a work-group heading, and it belongs to the section of the first item that follows it in its sheet. COLLECTION and SUMMARY are excluded by name — they are the collection page's own caption, always zero-item, never a title. Where several such headings precede the same first item, the last binds (the nearer heading is the section's; the earlier ones are the previous section's tail). This is mirror data: read from the sheet, never inferred, and absent when the sheet prints nothing.

One assembler, used by both writers. full_description is built by a single function (naming.ts) in the bill's own nesting order:

The parser builds names at import; the workspace rebuilds one when a QS edits a line. Those were two implementations, and the one in the workspace silently dropped the bill and section levels on every edited line — which raised FULL_NAME_MISMATCH on lines nobody had broken, and made "resolve" appear to do nothing (resolving the flag created a fresh one). Two assemblers cannot be kept in step by discipline; there is one.

Some books price every line against several zones (basements, podium, towers) and carry a per-zone amount band beside the Amount column, with the tender's Grand Summary declaring the same split per section. That is a whole extra rung: 25 sections × 6 zones is 150 independent checks on figures the workbook printed for itself.

The band is identified arithmetically, never by column letter or label list — the same discipline §2.1b applies to the quantity column. It is the run of header-labelled captured columns (extra_columns, §2.3) whose values add, row by row, to the line's own amount. That is the identity the bidders write into their own check columns (IF(SUM(M:R)=L,TRUE,FALSE)), so the app re-derives a rule the source states rather than inventing one.

A "To Collection"-style row closes a block, and its printed value is the block's checksum — recorded, never computed. Blocks are the only unit the source itself reconciles, so they are the only unit we reconcile.

source_collection_aed is what the source printed. Reconciliation happens later, in validation, by comparing the printed checksum against the independently summed lines. The parser transcribes; the validator judges; the two never blur (this is the app's own layer-separation law).

A grand-total row (Carried To Summary / Grand Total / Bill Total) is a sheet-level re-statement, not a block checksum — except that real bills print two shapes:

One rule covers both: if a block is still open when a grand row arrives, the block's checksum is the remainder = grand value − running total (adopted only when ≥ 0, else null). Separately, when the grand value matches the running total within 1.00 it is adopted as the sheet's carried-to-summary figure.

The bill ends at its final grand row (v1.4). A valued grand row lying after the sheet's last collection row (grand rows themselves are not collections — the "Carried to Summary" wording overlaps the collection markers and must be excluded from that look-ahead) begins the annex: item-shaped rows after it (elemental cost summaries, analyses — real books append them) are counted as annex rows, never items. A valued grand row with collection rows still ahead is a running re-statement, not the end — one observed sheet carries 11 such re-statements across 468 blocks. Keyed to structure already in the grammar, never to annex wording.

Five figures, each answering a different question. None of them replaces another, and every one of them is disclosed beside the others — a single number labelled "total" is exactly the shape of the lie this section exists to prevent.

arithmeticTotal − billTotal quantifies exactly how much the source's internal line contradictions are worth. arithmeticTotal − arithmeticAsSubmitted quantifies exactly how much of that is the reviewer's own doing. Keeping only the first pair is what allows a reviewer's correction to be quietly attributed to the bidder, which is the dishonesty the pair exists to prevent.

Item references follow a convention detected per collection block (each block's codes are examined independently — there is no sheet-level convention) — single letters (A–Z), plain numbers (1–999), or other (dotted, mixed — no order assumed):

Sheets the parser rejects (covers, flysheets, summaries) are not discarded — they are gold. The workbook's own summary sheet re-states, in its own hand, what each bill sheet should total. That self-declared truth is used two ways: the SUMMARY_ECHO proof (§5) checks our totals appear verbatim in the summary sheets; the Deep Audit's SUMMARY_MAP reconciles the complete summary against the complete import and raises the alarm on unaccounted money — a summary line whose amount matches no imported sheet.

The checks of Parts IV and V are not a flat list. They are a ladder, and each rung closes the money at one level of the bill's own nesting. Every rung compares figures the source printed for itself — never a figure the app invented.

Each rung carries checked — whether the source printed the figures the rung compares — alongside applied, the number of comparisons that actually ran, and a detail sentence saying so in the source's own terms.

This is the whole point of the structure. A book that prints no page markers has no SECTION rung and no ZONE rung; a book that prints no collection rows has no PAGE rung; a bill whose lines carry no rate has no LINE rung. Reporting those as passing would be a lie of exactly the kind that is hardest to catch, because it looks like success. They report as not checked, with the reason: "No line prints both a quantity and a rate, so the line identity cannot be tested on this bill." Six rungs of which four could be checked is a 6-rung ladder with 4 checked, never "4/4 pass".

Every flag the validator can raise, with its exact trigger. Errors never leave the review queue; acknowledged warnings do. Field names use the historical _aed suffix; actual currency comes from document.currency.

A class ruling is a recorded, document-level QS decision: lines whose Amount cell prints this text (normalized: lowercase, collapsed whitespace) are the nature of this bill — accepted. Stored on the document (printed_text_rulings: class, label, decision, timestamp), exported with it, and honored by validation: ruled lines carry the info variant of NON_NUMERIC_AMOUNT — fully visible on every line, never queued. Properties:

Errors block acceptance — unless a QS closes one on their own responsibility with a recorded resolution: a mandatory reason and timestamp stored on the item. The flag remains fully visible (marked resolved); the data is never touched; the resolution is reversible ("Reopen") and travels with the document (exports carry a "QS Resolution" column). Document-level structural errors (block/rollup/summary reconciliation) are not item-resolvable — they indicate the parse or the source arithmetic itself is broken and must be fixed, not waived.

QS practice sometimes carries a whole sheet outside the measured works — most commonly General Requirements / Preliminaries, which the team totals apart from the bills proper. A scope exclusion is a recorded, document-level QS decision: this sheet stays imported, mirrored and reviewable, but its sum is held out of the bill total. Stored on the document (sheet_exclusions: sheet, timestamp), toggled per sheet in the review rail, persisted and exported with the document.

What changes and what does not:

§4.1 rulings key on the words the Amount cell prints. That reaches "By Others" and "Rates Only"; it can never reach a line whose Rate cell is simply empty, because an empty cell prints no class to rule on. One real submission carries 1,801 of those — and nobody clears 1,801 identical questions one line at a time, so the queue was theatre.

A line ruling generalises §4.1 past printed text: a recorded QS determination answering one finding, at whatever scope the evidence supports.

The queue only ever contains open questions. A ruling answers questions; it does not hide them.

A QS may change a quantity or a rate on a line. The change is stored as a FieldOverride carrying from — what the workbook holds — together with to, a mandatory reason, and a timestamp. One entry per field; editing again replaces it.

Where a line's Amount cell prints a figure and its Quantity cell prints 0, a zero cannot be the multiplier that produced that amount. The quantity the bidder's own arithmetic implies is amount ÷ rate, and it is shown — marked ✻, with the footnote stating that the cell itself is unchanged.

This is a reading, not a repair. It is never written to quantity, never entered into a total, and never used by a check. It appears only where a reviewer would otherwise read a printed 0 as a measured zero. LINE_ARITHMETIC surfaces the same figure for the same reason (impliedQ), and neither one moves the mirror.

After every deterministic parse, the verification engine reverse-engineers the result against the raw workbook with independently written logic (it deliberately re-implements row classification rather than importing the parser — an independent pair of eyes, not the same code checking itself). Proofs are pass/fail with detail, shown in the review UI. Fifteen of them, in three families: the transcription against the raw cells (SOURCE_READ … MIRROR), the import against what the workbook declares about itself (SUMMARY_*, SECTION_TIE, ZONE_TIE, TENDER_TIE, AMOUNT_IN_WORDS), and the source confirming us in its own hand (SUMMARY_ECHO).

A proof that could not run passes with a detail sentence saying why, exactly as a ladder rung reports itself unchecked (§3.7) — "This workbook carries no summary sheet, so it declares nothing to check against" is an honest pass; a silent absence would not be.

Learned by inspecting the excluded sheets of three independent tender workbooks (JAVC External Works, Mall Refurbishment Bill 03, EMR Enabling & Piling). The structure is remarkably consistent — it is standard QS practice, not one firm's habit.

A tender workbook is built from repeating units:

Some workbooks give their summary sheet a full Item | Description | Amount header, making it parseable — and importing it double-counts catastrophically (the whole bill re-listed as line items, tender totals included). Detection is data-driven, no label matching: a supported sheet whose item amounts contain the exact totals of ≥ 2 other supported sheets is summary_like. The picker warns and deselects it by default (the human can still override); excluded, it becomes SUMMARY_MAP's verifying gold instead of pollution.

Header row: Item | Description | Page Nr. | Amount (so it has a BOQ-like header but zero priced items — which is exactly why the picker excludes it). Then:

One line per bill: bill title + page ref N/SUM + tri-state amount (each echoing that bill's summary total), closed by "TOTAL CARRIED TO FORM OF TENDER" — the tender figure, equal to the sum of the lines. This completes a two-level chain: BOQ blocks → bill summary → main summary → tender figure, every link printed by the workbook itself.

Printed page refs follow bill/section/page (e.g. 2/B/16, 1/GR/11, 3/PS/2), ranges as start - end, and N/SUM for a bill's summary page. The section token frequently ties to the sheet name (2/B ↔ sheet "2B", 5/PW ↔ "B5 - PW"). Useful as corroboration; never the primary match key.

Observed: a stray second number in an off-column next to a real entry (7,190,900 beside the real 6,831,036 in EMR's Main Summary). Summary parsing reads the amount column identified by the header, and reports stray off-column numbers rather than silently counting or ignoring them.

Deterministic, mirror-faithful reconciliation of the workbook's self-declared truth against the import:

§3.6 and §6.6 treat the summary sheets as a verification input — values to match against. They are now also read at import into a structure the app keeps (declared_summary), because the summary is where a bill states its own sections and their totals, and nothing else in the workbook does.

What is read, all verbatim and all mirror-faithful:

declaredSections() collapses those entries to one row per section, and both of its rules are facts about how these books are printed, not choices:

The cross-section guard. A summary row whose printed page range crosses section boundaries (Page 3/B/1 - 3/R/3) is declaring a bill, not a section. Folding it into the section its range happens to start at hands that section the whole bill's figure and the bill's name — and the "does not tie" mark that inevitably follows is a finding the app invented about a submission that was fine. Such rows are excluded from the section model. The test is structural: more than one distinct bill/section prefix inside the range.

Stated openly — honesty is structural, and the audit agent probes these first:

Fixed in v1.11: a bill-level summary row folded into the section its page range started at, handing that section the whole bill's figure and a false SECTION_COLLECTION (→ §6.6b, the cross-section guard); two full-name assemblers drifting apart, so every QS edit dropped the bill and section levels and raised FULL_NAME_MISMATCH on a line nobody had broken (→ §2.8, one assembler); the collection page's own COLLECTION caption captured as a section title (→ §2.8).

Fixed in v1.1 (found by the first Deep Audit): hidden formula-zeros under dash formats swallowing heading rows (→ §1.3b), units flattened from m² to m2 (→ §1.3), header-labelled columns dropped (→ §2.3 extra_columns), unvalued off-column collection markers read as spacers (→ §2.2 order).

When the grammar parser rejects a sheet, the ladder escalates — free first, AI only on explicit request:

The AI proposes; the engine executes; the proofs judge; the human confirms. A profile is a reviewable claim about structure — never a silent adaptation.

Everything above establishes what the app knows. This Part is how it hands that back — the receipt a reviewer signs off, and the artefact that goes to the bidder's file. It is generated from one registry (report.ts), so the figures on the report and the figures in the workspace cannot drift apart.

Every part of the report resolves to exactly one state:

Progress is stated as met of assessable, where assessable excludes unavailable — the same law as §3.7, applied to the report: a part nobody could assess is never counted as one that passed. The three counts are printed together, so "7 of 8 settled · 1 the source gave us nothing to check" is the whole sentence, never just its first half.

Every figure that can be opened into the lines behind it is openable, and every such line carries its reference, printed page, section, group, full name, source cell, and the findings against it — the report is not a summary of the evidence, it is a door onto it.

The validator names findings the way code names things (UNPRICED_LINE, REF_SEQUENCE_RESET). A quantity surveyor names them the way a bill is discussed. One lookup (findings.ts) maps a rule to the words a person reads, and every surface that shows a finding to a person reads from it — the work list, the line pane, the clarification list, the report — so the same finding is never described two different ways in the same building.

Each entry carries the predicate that completes "1,801 lines …", its singular form, and the ask — what the reviewer is being invited to do about it, in one clause. A rule with no entry falls back to its own name rather than to an invented phrase: a finding described in code terms is honest, a finding described in words the system made up is not.

A report that leaves the building with no bidder, no date and no version is not evidence of anything. Every report carries: the source filename, a SHA-256 fingerprint of the stored workbook, its size, when it was received, when the report was generated, and the grammar version that judged it (§7). Where the source is not stored, the fingerprint reads "source not stored" — the field is never omitted and never filled with something else.

This grammar is versioned. Any change to a trigger, threshold, or row rule bumps the version, and the parser/validator/verifier and the audit agent's skill are updated in the same change. A finding always records which grammar version judged it.

• v1.112026-08-21 the levels, the ladder, and the reviewer's own hand. Sections and groups (§2.8): bill_ref/section_ref read from printed page markers, the field named section stated plainly to be the group (a level below), section titles from the declared summary first and the bill sheet's own printed heading second, one shared full-name assembler. Zones (§2.9): the per-zone amount band identified arithmetically. The reconciliation ladder (§3.7): six rungs, each carrying whether it could be checked — a rung nobody could check is never drawn as one. The totals (§3.4): five figures, including arithmeticAsSubmitted, so the bidder's arithmetic and the arithmetic after review are always separable. Four flags documented that the validator had been raising undocumented since 2026-08-17: SECTION_COLLECTION, ZONE_COLLECTION, LUMP_SUM_PRICED, CODE_MARKER. Seven proofs documented likewise: SUMMARY_DECLARED, SUMMARY_SELF_CHECK, SECTION_TIE, ZONE_TIE, TENDER_TIE, AMOUNT_IN_WORDS, SUMMARY_STRAYS — the catalog had 8 of 15. Scoped QS rulings (§4.4) generalising §4.1 past printed text, four scopes, narrowest-wins, reach counted before it is taken. Figure overrides (§4.5) with the source figure preserved, and the ?? trap that mis-attributes money on every line whose source prints nothing. Implied quantity (§4.6), marked ✻, never written. The declared summary as a structure (§6.6b) with the add-on, echo/conflict and cross-section rules. The digitisation report (Part VIII), its three states, its nine parts, the plain-language layer and report provenance. Also: the header said v1.9 while the changelog said v1.10, and GRAMMAR_VERSION in the code said 1.9 — three versions for one document, stamped onto every finding. Now one.
• v1.102026-08-20 UNPRICED_LINE (§4): a line carrying no money and no rate is flagged, where before it passed silently — the Amount cell's numeric 0 (written by =qty*rate over an empty rate) read as "priced" everywhere, no per-line rule tested for a missing rate, and the unpriced clarification category only ever triggered on a printed-text amount. Observed on a real bill where 1,875 of 2,998 lines (63%) were silently unpriced while the queue showed 139.
• v1.92026-08-13 printed page markers (§2.7): the bill's own bill/section/page footers captured onto items as printed_page, discovered by shape per sheet; groundwork for the Words Gate (WORDS_GATE.md), whose address references resolve against them.
• v1.82026-08-12 split-quantity layouts (§2.1b): the quantity column identified arithmetically (value × rate = amount) when no qty header matches; provenance recorded as an arithmetic parse profile; verifier re-derives independently. From the Zaabeel book's "TOTAL QTY" layout.
• v1.72026-08-12 QS scope exclusions (§4.3): a sheet recorded as held out of the totals (GR practice) while staying imported and fully reviewable; scoped rollup, full-picture summary tie, mandatory disclosure next to the total.
• v1.62026-08-12 marker tokens in the code column (§3.5, CODE_MARKER); data-driven summary-like sheet detection at the picker (§6.1b).
• v1.52026-08-12 assisted parse profiles (Part VII): declarative per-sheet column maps proposed by AI or humans, executed deterministically, judged by proofs, stored on the document.
• v1.42026-08-12 the bill ends at its final grand row: post-summary annex rows (elemental summaries) recognized structurally (valued grand after the last collection row) and excluded from items; look-ahead excludes grand rows from the collection scan; corpus regression harness (npm run test:corpus) guards every known workbook.
• v1.32026-08-11 QS error resolutions (§4.2): recorded, reasoned, reversible closure of item-level errors; queue/accept honor resolutions; structural errors remain non-waivable.
• v1.22026-08-11 QS class rulings (§4.1): document-level accepted printed-text classes; NON_NUMERIC_AMOUNT info variant; born-acknowledged lines; class-homogeneity audit duty.
• v1.12026-08-11 from the first Deep Audit's findings: printed-text classification rule (§1.3b), text cells verbatim incl. superscripts (§1.3), extra_columns capture (§2.3), marker-before-spacer taxonomy order with unvalued-marker handling (§2.2), deterministic identity + currency from covers/flysheets/header band (§6.1).
• v1.0 initial canonical grammar.