@sun-asterisk/sungen 3.2.35 → 3.3.0-alpha.10

package/dist/orchestrator/templates/ai-src/partials/waiting-for-you.codex.md

@@ -0,0 +1,11 @@
+<!-- sungen:waiting-for-you v1 -->
+## Waiting for you — the commands only the QA runs
+
+Right before the hand-back list, run `sungen next {{unitArg}}` and quote its **⏳ Waiting for you**
+block **verbatim** — every command exactly as printed, each with its reason. Those commands approve,
+sign off, waive, classify a red, accept in-run decisions or re-run once the environment is up: they are
+the QA's alone, and most refuse without a person typing a confirmation. Tell the QA to run each one
+themselves, in their own terminal (a slash command is typed as is). **Never run them yourself**, and
+never pipe or type a confirmation into them. When `sungen next` prints no such block, say that nothing
+is waiting for the QA.
+<!-- /sungen:waiting-for-you -->

package/dist/orchestrator/templates/ai-src/partials/waiting-for-you.copilot.md

@@ -0,0 +1,11 @@
+<!-- sungen:waiting-for-you v1 -->
+## Waiting for you — the commands only the QA runs
+
+Right before the hand-back list, run `sungen next {{unitArg}}` and quote its **⏳ Waiting for you**
+block **verbatim** — every command exactly as printed, each with its reason. Those commands approve,
+sign off, waive, classify a red, accept in-run decisions or re-run once the environment is up: they are
+the QA's alone, and most refuse without a person typing a confirmation. Tell the QA to run each one
+themselves, in their own terminal (a slash command is typed as is). **Never run them yourself**, and
+never pipe or type a confirmation into them. When `sungen next` prints no such block, say that nothing
+is waiting for the QA.
+<!-- /sungen:waiting-for-you -->

package/dist/orchestrator/templates/ai-src/skills/sungen-delivery/SKILL.md

@@ -126,8 +126,7 @@ exist in test-data, so Gate D does not ask for them: the capture step renders as
 are resolved by TestDataLoader at execution time — including when nested inside a test-data value
 (`seed: "Summary intro {{$timestamp}}"`). They have no static value to print, so the report names
 them instead: `<unique timestamp>`, `<unique id>`, `<random 1-100>`, `<today's date>`,
-`<current date-time>`, and `{{$date:+1d}}` reads `<today's date + 1 day>`. An unknown `{{$foo}}` (or an
-argument the runtime does not support, e.g. `{{$date:tz=…}}`) is left raw on purpose — it is a typo and Gate D says so.
+`<current date-time>`. An unknown `{{$foo}}` is left raw on purpose — it is a typo and Gate D says so.
 
 **Data fidelity**: invisible test data is made visible, never normalized — `''` → `(empty)`,
 whitespace-only → `(5 spaces)`, padded → `" value "` quoted verbatim. A trim/collapse here would

package/dist/orchestrator/templates/ai-src/skills/sungen-error-mapping/SKILL.md

@@ -124,9 +124,9 @@ reason comment); the Given/When/Then stay **exactly** as QA approved them:
 | `SG-W012` | A mock-install step written AFTER a navigation step in the same block — `page.route()` registered after `goto()` misses every request fired during page load | Move the mock-install step before the navigation, or into `Background` |
 | `SG-W013` | A page step (`see [X] page` / `is on [X] page` / `wait for [X] page`) whose `[Ref]` has no `type: page` selector entry (or collides with a non-page entry) — the step falls back to the feature's own path (or `/<ref>/`) instead of `X`'s real URL, so the anchored match can never reach it: the assertion always fails, the wait can only time out | Declare a `type: page` entry for `[Ref]` with its real URL; if the key collides with another type, disambiguate with a `--type` suffix (`sungen-selector-keys` § Collision rule) |
 | `SG-W014` | `[X] page with {{v}}` where `{{v}}`'s base test-data value carries no query and no fragment — the step checks the PATH only, asserting less than it reads as | Informational — pass a value like `?q=…` if you meant to assert a query, or drop `with {{v}}` for a bare page |
-| `SG-W015` | `see [X] card/item with {{n}}` where `{{n}}`'s test-data value is a **bare number** — this compiles to a TEXT assertion (`toHaveText('3')`), NOT a count. An author reaching for "3 cards are shown" gets an assertion that can only pass if the card's TEXT is literally the digit: a wrong test with no error. Scoped to container-ish element types (`card`/`item`/`option` + plurals); a text element asserting a numeric readout (`[Row Quantity] text with 4`) stays silent. In a `@cases` scenario the value is judged on every dataset row; it also fires on `see [X] row with {{n}}` whose rows MIX numbers and text (a row count needs every row numeric, so the step stays a text assertion) | For mixed `@cases` rows: put the counting rows in their own `@cases` scenario. For a COUNT use a form that has count semantics: `see [Ref] row with {{n}}` / `see [T] table with {{n}}`, or a list `should have count`. If the number really is the element's text, assert it on a **text/label** element instead |
+| `SG-W015` | `see [X] card/item with {{n}}` where `{{n}}`'s test-data value is a **bare number** — this compiles to a TEXT assertion (`toHaveText('3')`), NOT a count. An author reaching for "3 cards are shown" gets an assertion that can only pass if the card's TEXT is literally the digit: a wrong test with no error. Scoped to container-ish element types (`card`/`item`/`option` + plurals); a text element asserting a numeric readout (`[Row Quantity] text with 4`) stays silent | For a COUNT use a form that has count semantics: `see [Ref] row with {{n}}` / `see [T] table with {{n}}`, or a list `should have count`. If the number really is the element's text, assert it on a **text/label** element instead |
 | `SG-W016` | A table step on a table located by CSS/testid whose value does not mention `table` and that declares no `rows:` — the table templates find rows by `getByRole('row')`; on a list built from `<div>`s that is 0 rows, so `is hidden`/`is empty` PASS without checking anything and counts/clicks time out (issue #688). A heuristic — the compiler cannot see the DOM — so it warns once per table | Declare the row shape on the TABLE entry (`rows: 'div.job-row'`, relative to the table) — it drives all seven table steps — or locate the table by `role: table` if it really is one. Do not put the shape on a row label's entry: that key positions ONE row |
-| `SG-W017` | A step needs a **selector-entry field the entry does not declare**, so there is nothing honest to compile — today: a table paginate step whose table entry declares no `pagination.next`/`.prev` (#712); a web `fill [X] date-picker` whose entry locates a `<button>` (a calendar trigger) and names no fill recipe (#907). The mirror of `SG-W004`: that one reports a field written that nothing reads, this one a field a consumer needs that nobody wrote. The step compiles to a loud runtime `throw` rather than guessing a locator, which is the #690 failure mode (a locator no page has, failing far from its cause) | Add the missing field to the entry in selectors.yaml — for pagination: `pagination:` with `next:`/`prev:` locators; for a button date-picker: `variant: <recipe>` naming a `qa/app.yaml` recipe with a `fill` intent (and `assertValue` to read it back). This is a selectors.yaml-only fix, allowed inside the run-test auto-fix loop |
+| `SG-W017` | A step needs a **selector-entry field the entry does not declare**, so there is nothing honest to compile — today, a table paginate step whose table entry declares no `pagination.next`/`.prev` (#712). The mirror of `SG-W004`: that one reports a field written that nothing reads, this one a field a consumer needs that nobody wrote. The step compiles to a loud runtime `throw` rather than guessing a locator, which is the #690 failure mode (a locator no page has, failing far from its cause) | Add the missing field to the entry in selectors.yaml — for pagination: `pagination:` with `next:`/`prev:` locators. This is a selectors.yaml-only fix, allowed inside the run-test auto-fix loop |
 | `SG-W018` | A selectors.yaml entry declares an **`nth:` outside the contract** — `nth: -2`, `nth: 'last'`, `nth: 1.5`. `nth:` was the one entry field whose VALUE nothing checked (issue #720), so the web adapter silently DROPPED the filter (identical to deleting the line — the step then hits `strict mode violation: resolved to N elements`, which names the DOM and never the YAML line) while the mobile adapter emitted `$$('~x')[-1]` / `[last]` — `undefined` indexing and a bare identifier. The value is now ignored and reported once per entry | Write an integer `>= 0` for a zero-based index, or `-1` for the last match (`.last()` on web, `.at(-1)` on mobile). There is no keyword form: `'last'` is a string, not an index. This is a selectors.yaml-only fix — allowed inside the run-test auto-fix loop |
 | `SG-E020` | A step matched a pattern, but the **active adapter ships no template** for it (e.g. a web-only step compiled under `platform: mobile`). The feature file still generates — that one step compiles to `throw new Error("[sungen] …")` naming the step, feature, pattern, template and adapter, so the failure is loud and traceable rather than a crashed build | Rephrase to a step the target adapter actually ships (see `sungen-gherkin-syntax` Platform Support section / `sungen-mobile-gestures`), or tag the scenario `@manual` with the platform reason |
 | `SG-E021` | The step carries a trailing **state clause** (`… is hidden`) that the pattern which matched it does not assert — the clause would be SILENTLY DROPPED. Worst shape in this table: it does not weaken an assertion, it can INVERT one. `see [X] page is hidden` matched `page-assertion` (priority 13) ahead of `is-hidden` (11), so the step compiled to `toHaveURL(...)` — asserting the page IS displayed, and passing. Also fires on `wait for [X] is checked` (a wait honours only `hidden`/`visible`/`disabled`/`enabled`; everything else silently fell back to `visible`) and on `row`/`column in [T] table … is <state>` for any state but `hidden` | Move the state onto the element that has it: `Then User see [X] checkbox is checked`. For a page, assert the page you expect (`Then User see [Other] page`) or a marker element (`Then User see [Banner] is hidden`). If sungen cannot express the check, tag the scenario `@manual`. The diagnostic names the pattern that swallowed the clause — that name tells you which form you actually hit |
@@ -139,7 +139,7 @@ reason comment); the Given/When/Then stay **exactly** as QA approved them:
 | `SG-W028` | A trailing **scope clause was DROPPED**, so the step runs against more of the page than its sentence names. Two causes, one code: (1) the word after `in [X]` is not a container type — `in [Job Card] widget`, or a leaf element used as a parent — so the clause matched nothing and the first-`[ref]`/first-`{{data}}` extractors took only the head of the sentence; (2) the by-content form `in [X] <type> with {{v}}` on the **mobile** adapter, where a parent is chained with `$()` and has no content filter. Before this code, both compiled clean and silently widened the assertion to the WHOLE screen — in a list of look-alike cards the test then passes for the wrong reason, findable only by diffing the generated `.spec.ts` against the Gherkin (#667) | For (1) use a real container type: `table` `list` `list-item` `section` `dialog` `modal` `drawer` `overlay` `form` `card` `item` `row` `group` `panel` `region` `container` `tab` `menu`. For (2) give the container an accessibility-id that identifies it and scope by that, or assert on the element the value belongs to |
 | `SG-W029` | A **mobile feature with no usable app-package `Path:`** — the line is missing, or it holds a web-style route (`Path: /applied-jobs`). The compiler then cannot name the app to reset between scenarios, and before this code that was SILENT: the per-scenario `beforeEach` was not emitted at all, so Background fell to Mocha's `before()` — once per FILE. Every scenario shared one continuous app session, so a tab switch or a scroll in one stranded elements off-screen for every later one, and the `@reset:` tier ladder was dropped with it, leaving the tag inert (#669). The spec now always emits the reset machinery and resolves the app id from the session capability instead, throwing a named error at run time if nothing supplies one | Add the package to the feature: `Path: com.example.app/.MainActivity`, or `Path: <androidPkg>/<activity> | <iosBundleId>` for a dual-id feature. A `Path:` starting with `/` is a web route and will not be read as a package. Failing that, set `APP_PACKAGE` (Android) / `IOS_BUNDLE_ID` (iOS) so `wdio.conf` puts the id on the session |
 | `SG-E022` | The **generated spec file itself** is not parseable JS/TS, so NOTHING in it runs — Playwright reports one `SyntaxError` and every scenario in the unit is lost. A compiler self-check (`@babel/parser`) on the emitted code, added after a field report where the runtime-data marker post-processor mis-paired quote delimiters across two literals and the user only found out at `npx playwright test`. Reported, never thrown — the file is still written so you keep the artifact to inspect. **Unlike every other code in this table this one blames the COMPILER, not your `.feature`** | Nothing to fix in the Gherkin — this should be impossible. **Report it** with the `.feature` (and the step) the file was generated from, attaching the unparseable `.spec.ts`. Check first that you are running the project-local compiler (`npx sungen`), not an older global one |
-| `SG-E023` | The step carries an **assertion clause** (`matches "…"`, `contains`, `has text`) but the generated code is a BARE VISIBILITY check — the clause was swallowed by a catch-all and the test would pass whatever the element says. The sibling of `SG-E021`, for the clauses that are not states: `SG-E021` closed the state case declaratively, but a dropped `matches`/`contains`/`has text` still slid through (reproduced live: a `matches "<format>"` step compiled by an older sungen lost the assertion entirely, emitted no warning, and left a `toBeVisible()` that passed whatever the label said). Four separate defects arrived this way, so the step now compiles to a runtime `throw`. Deliberately narrow — fires only on the bare-visibility shape, so a pattern that genuinely consumed the clause (`is-hidden`, `contains`, `matches-format`, the state family, or a `filter({ hasText })` on a list member) is untouched. Also fires on a trailing `is <word>` / `is not <word>` that is no state (`is on`, `is open`, `is active`, `is not visible`) — only `is visible`/`displayed`/`shown`/`present` and `is not hidden` are what a visibility check asserts | For an `is <word>` ending: use a state from the `sungen-gherkin-syntax` States list (`is expanded`/`is collapsed` for a disclosure), or `@manual`. Otherwise, either the phrasing is not the supported one for that clause — check the exact form in `sungen-gherkin-syntax` — or this sungen predates the step: verify you are running the project-local compiler (`npx sungen`), not an older global one |
+| `SG-E023` | The step carries an **assertion clause** (`matches "…"`, `contains`, `has text`) but the generated code is a BARE VISIBILITY check — the clause was swallowed by a catch-all and the test would pass whatever the element says. The sibling of `SG-E021`, for the clauses that are not states: `SG-E021` closed the state case declaratively, but a dropped `matches`/`contains`/`has text` still slid through (reproduced live: a `matches "<format>"` step compiled by an older sungen lost the assertion entirely, emitted no warning, and left a `toBeVisible()` that passed whatever the label said). Four separate defects arrived this way, so the step now compiles to a runtime `throw`. Deliberately narrow — fires only on the bare-visibility shape, so a pattern that genuinely consumed the clause (`is-hidden`, `contains`, `matches-format`, the state family, or a `filter({ hasText })` on a list member) is untouched | Either the phrasing is not the supported one for that clause — check the exact form in `sungen-gherkin-syntax` — or this sungen predates the step: verify you are running the project-local compiler (`npx sungen`), not an older global one |
 | `SG-E024` | A mobile **app-lifecycle** step (`User restart the app` / `User reinstall the app`) in a feature that declares no `Path:` app id. The lifecycle templates resolve the target app through `__resolveAppId()`, a helper the appium test-file template emits ONLY when the id is present, so the spec used to compile clean and then die at runtime with `ReferenceError: __resolveAppId is not defined` — taking the WHOLE spec down, not the one step, because the failure lands in a before hook. (Field case: a mobile unit scaffolded with the nav recipe in `--path` instead of `--reach`, so `Path` never carried an app id.) Now refused at compile time as a `throw` naming the missing line | Add the app id under the `Feature` line: `Path: com.example.app/.MainActivity \| com.example.app`. For a mobile unit `--path` carries the **APP ID** and `--reach` carries the navigation recipe — if the nav recipe ended up in `--path`, that is the mistake |
 | `SG-E025` | A feature tagged `@platform:ios` uses a step the Appium adapter does **not** serve on iOS — the template either throws deep inside a device run (`set-connectivity`, `location-services`, `open-notifications`) or silently does nothing (`hide-keyboard`, a guarded `if (!driver.isIOS …)`). Derived from the template body via the per-OS axis of the step-support matrix, so it cannot disagree with the adapter. Only an explicit `@platform:ios` is gated (`@platform:mobile` picks its OS at run time). Compiles to a loud `throw` | Use a step the matrix marks ✅ for iOS (see `docs/spec/step-support-matrix.md`), tag the feature `@platform:mobile` if it should run on either OS, or tag the scenario `@manual` |
 | `SG-E026` | A **click step names a position** (`at position "top-left"`, `at offset x=…, y=…`) that would not be honoured: the keyword is misspelt or unquoted, a value is outside the grammar (not a number, negative, above 100%, a missing axis, an unknown preset), text follows the position, or another click form claimed the step first (`try to click`, a `with {{v}}` text filter, `… and accept [OK] alert`, `double click`). Each of those would compile to a click on the element's CENTRE and pass — for a backdrop-dismiss overlay that is the one outcome that proves nothing — so the step compiles to a loud `throw` | Write `click [X] <type> at position "top-left\|top-right\|bottom-left\|bottom-right"` or `… at offset x=<n>px\|%, y=<n>px\|%` as the LAST thing in the step, on a plain `click` (no `try to`, no `with {{v}}`, no alert clause). Web only — on mobile tap the control the position targets |
@@ -175,8 +175,7 @@ The scenario uses a SECRET test-data key whose `QA_*` variable is missing in thi
 
 Sungen picks assertion based on element type:
 - **Input** (`field`, `textarea`, `search`, `slider`) → `toHaveValue()`
-- **Dropdown / date-picker** (`dropdown`, `select`, `combobox`, `date-picker`) → the `assertValue` recipe when the entry's `variant:` (or `widgets.select` / `widgets.datepicker`) names one; otherwise a runtime tag probe: `toHaveValue()` on a native `<select>`/input, `toHaveText()` on a `<button role="combobox">` trigger (Radix/shadcn, MUI) or a `<button>` that opens a calendar popover. Pin one branch with `variant: native` or an `assertValue` recipe in `qa/app.yaml`. Any other element with a `variant:` uses its recipe's `assertValue` too.
-- **`SG-W017` on a date-picker fill** (the entry is provably a button: `role: button`, or a css/locator ending in a `button` tag) and, at run time, **`[sungen] [X] is not a fillable element`** (a trigger the compiler could not prove is a button) → the fill target is a calendar / popup trigger. Declare a recipe with `fill` (and `assertValue`) intents in `qa/app.yaml` and set `variant: <recipe>` on the entry, or `widgets.datepicker` for every date-picker. Do not change the step to a click.
+- **Dropdown** (`dropdown`, `select`, `combobox`) → runtime tag probe: `toHaveValue()` on a native `<select>`/input, `toHaveText()` on a `<button role="combobox">` trigger (Radix/shadcn, MUI). Pin one branch with `variant: native` or an `assertValue` recipe in `qa/app.yaml`.
 - **Text** (everything else: `message`, `heading`, `label`, `row`) → `toHaveText()`
 - **Partial** (`contains` keyword) → `toContainText()`
 

package/dist/orchestrator/templates/ai-src/skills/sungen-gherkin-syntax/SKILL.md

@@ -37,7 +37,7 @@ AND    →  inherits from preceding keyword
 
 ```
 User is on [T] page | page with {{v}} | dialog      # {{v}} = query/fragment ("?id=200", "#tab") APPENDED to the page value — a bare "200" onto "/x?id=199" gives "?id=199200"
-User fill [T] field | textarea | search | slider | date-picker with {{v}}   # date-picker: web only unless qa/app.yaml declares widgets.datepicker — appium refuses it; on web a <button> trigger (calendar popover) needs a fill recipe (variant: / widgets.datepicker) or it is refused (SG-W017)
+User fill [T] field | textarea | search | slider | date-picker with {{v}}   # date-picker: web only unless qa/app.yaml declares widgets.datepicker — appium refuses it
 User fill [T] uploader with {{f}}                                    [web]
 User clear [T] field
 User check [T] checkbox | toggle | radio
@@ -145,20 +145,14 @@ two content-filtered queries can hit different rows if the table re-renders in b
 ```
 # 1. Visibility: User see [T] type (NEVER add "is visible") | is hidden
 # 2. Text (toHaveText): User see [T] message | header | label with {{v}}
-#    `label` forks on the entry: declared by IDENTITY (xpath/accessibility-id/testid/id/css/locator)
-#    → toContainText on THAT element; `exact: true` → toHaveText, and an EMPTY {{v}} asserts the
-#    element shows no text (contains '' would pass on anything); no entry, or `type: text` → matches
-#    the caption+value text pair anywhere on screen
+#    `label` forks on the entry: declared by IDENTITY (xpath/accessibility-id/testid/id/css)
+#    → asserts THAT element contains {{v}} (add `exact: true` for a strict match); no entry,
+#    or `type: text` → matches the caption+value text pair anywhere on screen
 # 3. Partial (toContainText): User see [T] text contains {{v}}
 # 3b. Format (shape, not value): User see [T] label matches "yyyy/mm/dd ~ yyyy/mm/dd"
-# 4. Input (toHaveValue): User see [T] field | search | slider with {{v}}
-#    dropdown | select | combobox | date-picker → the entry's `assertValue` recipe if it has one
-#    (variant: / widgets.select / widgets.datepicker), else the tag is probed at runtime
-#    (toHaveValue on a native input/select, toHaveText on a custom trigger such as a <button>).
-#    Any element whose entry has a `variant:` reads back through that recipe's `assertValue`
+# 4. Input (toHaveValue): User see [T] field | date-picker | search | slider with {{v}}
+#    dropdown | select | combobox → tag probed at runtime (toHaveValue native, toHaveText custom trigger)
 # 5. State: User see [T] button is disabled | checkbox is checked | dialog with {{v}} is hidden
-#    open/closed: User see [T] button | section is expanded | is collapsed   [web — reads `expanded:`, else aria-expanded;
-#    an entry with `expanded: { state: none }` has no state to read → refused, SG-W017]
 # 6. Attribute (toHaveAttribute): User see [T] image | link with {{v}}
 #    WHICH attribute comes from the entry's `attribute:` — any name, not just href/src
 # 7. Count: User see [T] row with {{count}}
@@ -507,11 +501,7 @@ zero-match assertion failure, not a platform gap.
 
 ### States
 
-`hidden` `visible` `disabled` `enabled` `checked` `unchecked` `focused` `empty` `loading` `selected` `expanded` `collapsed` `sorted ascending` `sorted descending`
-
-Any other trailing `is <word>` / `is not <word>` (`is on`, `is active`, `is open`, `is not visible`) is
-**not** a state: the compiler refuses it (SG-E023) rather than check only visibility. `is displayed` /
-`is shown` / `is present` read as `is visible`, and `is not hidden` as visible too.
+`hidden` `visible` `disabled` `enabled` `checked` `unchecked` `focused` `empty` `loading` `selected` `sorted ascending` `sorted descending`
 
 ### Element Types
 
@@ -549,18 +539,12 @@ Use `{{$var}}` in test-data YAML for values that must be unique per test run. Re
 
 | Variable | Example | Output |
 |---|---|---|
-| `{{$timestamp}}` | `"User-{{$timestamp}}"` | `"User-1714000000000"` (milliseconds) |
+| `{{$timestamp}}` | `"User-{{$timestamp}}"` | `"User-1714000000"` |
 | `{{$uuid}}` | `"{{$uuid}}"` | `"a1b2c3d4-..."` |
 | `{{$random:min:max}}` | `"{{$random:1:100}}"` | `"42"` |
 | `{{$date}}` | `"{{$date}}"` | `"2026-04-24"` |
-| `{{$date:+Nd}}` / `{{$date:-Nd}}` | `"{{$date:+1d}}"` | `"2026-04-25"` — today shifted by N days |
 | `{{$datetime}}` | `"{{$datetime}}"` | `"2026-04-24T10:30:00.000Z"` |
 
-`{{$date}}` is the LOCAL calendar date of the machine running the tests — the "today" the browser shows
-when `playwright.config.ts` sets no `timezoneId`. If the config pins `timezoneId`, export the same zone as
-`TZ` (e.g. `TZ=Asia/Tokyo npx playwright test`) so both agree. `{{$datetime}}` is a UTC instant (`…Z`). Any `{{$date:…}}` argument other than `±Nd`
-(`tz=…`, a format) and any `{{$datetime:…}}` argument are not supported and stay literal.
-
 **Rules:**
 - `$timestamp` and `$uuid` → same value across all keys in one `load()` call (stable within a test file)
 - `$random` → unique per occurrence (each key gets a different random)

package/dist/orchestrator/templates/ai-src/skills/sungen-tc-generation/SKILL.md

@@ -773,9 +773,8 @@ those namespaces are the **System INTEGRATION** group — keep their oracles abo
 > **Auto-detect**: if path is `qa/flows/<name>/` → use this section. Skip Steps 1–4 above.
 
 **Read `requirements/flow-contract.yaml` FIRST — it is the flow's boundary and the yardstick
-`sungen audit` scores the flow against** (`flowCoverage` axis = the declared flows / phases
-automated; `FLOW-OUTCOME-UNPROVEN`; `FLOW-SCOPE-CREEP`; `FLOW-GUARANTEE-MISSING`;
-`FLOW-INVENTORY-MISSING`). **A filled contract is an INPUT — never rewrite it
+`sungen audit` scores the flow against** (`flowCoverage` axis = journey phases HP/ER/EH automated;
+`FLOW-OUTCOME-UNPROVEN`; `FLOW-SCOPE-CREEP`). **A filled contract is an INPUT — never rewrite it
 to match your output** (same rule as `test-viewpoint.md`).
 
 > **HARD RULE — the contract must be AUTHORED, never merely cited.** If
@@ -797,7 +796,7 @@ to match your output** (same rule as `test-viewpoint.md`).
 | Selector format | `[Element]` | `[Screen:Element]` (namespaced) |
 | Test data keys | `{{variable}}` | `{{phase.variable}}` |
 | Feature tag | `@auto` / `@smoke` etc. | `@flow` (required) |
-| Scenario ids | `VP-<CATEGORY>-NNN` | `FL-<PHASE>-NNN` — use-case phases `BF`/`AF0n`/`EF0n` (see below), or the flat `HP` (happy path) / `ER` (error recovery) / `EH` (guards) / `UI` for a short single-outcome flow — the contract still needs both guarantees and a `flows:` inventory either way |
+| Scenario ids | `VP-<CATEGORY>-NNN` | `FL-<PHASE>-NNN` — use-case phases `BF`/`AF0n`/`EF0n` (see below), or the flat `HP` (happy path) / `ER` (error recovery) / `EH` (guards) / `UI` for a short single-outcome flow |
 
 **Scenarios to generate — every phase demanded by the contract, automated:**
 

package/dist/orchestrator/templates/claude-hooks/sungen-hook.cjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * sungen — Claude Code hook launcher. Written by `sungen init` / `sungen update`; edits are
+ * overwritten. `.claude/settings.json` runs it in exec form (no shell):
+ *   { "command": "node", "args": ["${CLAUDE_PROJECT_DIR}/.claude/hooks/sungen-hook.cjs", "<hook>"] }
+ *
+ * Finds the installed sungen and runs one hook IN-PROCESS (node on dist — no npx — so a hook costs
+ * one Node start). Lookup: $SUNGEN_HOOK_ENTRY when set (exactly that file), else the project's own
+ * dependency, else the global npm prefix.
+ *
+ * FAILS OPEN: kill-switch set, sungen not found, or any error → prints `{}` and exits 0. A hook can
+ * never block or derail a session.
+ *
+ * Off switches: SUNGEN_HOOKS=off (all) · SUNGEN_HOOK_<NAME>=off (one) · qa/sungen.config.yaml `hooks:`.
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const ENTRY = ['@sun-asterisk', 'sungen', 'dist', 'hooks', 'claude-hook-entry.js'];
+
+function noop() {
+  process.stdout.write('{}\n', () => process.exit(0));
+}
+
+function npmrcPrefix() {
+  try {
+    const m = fs.readFileSync(path.join(os.homedir(), '.npmrc'), 'utf8').match(/^\s*prefix\s*=\s*(.+?)\s*$/m);
+    return m ? m[1].replace(/^~(?=$|[\\/])/, os.homedir()) : null;
+  } catch (_) {
+    return null;
+  }
+}
+
+function findEntry() {
+  const override = process.env.SUNGEN_HOOK_ENTRY;
+  if (override) return fs.existsSync(override) ? override : null;
+  const project = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  try {
+    return require.resolve(ENTRY.join('/'), { paths: [project] });
+  } catch (_) { /* not a project dependency — try the global install */ }
+  const bin = path.dirname(process.execPath);
+  const prefixes = [process.env.npm_config_prefix, npmrcPrefix(), path.join(bin, '..'), bin].filter(Boolean);
+  for (const prefix of prefixes) {
+    for (const lib of [path.join(prefix, 'lib', 'node_modules'), path.join(prefix, 'node_modules')]) {
+      const candidate = path.join(lib, ...ENTRY);
+      if (fs.existsSync(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+try {
+  if (/^(?:off|0|false|no|disabled?)$/i.test(String(process.env.SUNGEN_HOOKS || '').trim())) {
+    noop();
+  } else {
+    const entry = findEntry();
+    if (!entry) noop();
+    else Promise.resolve(require(entry).main(process.argv[2] || '')).then(() => process.exit(0), noop);
+  }
+} catch (_) {
+  noop();
+}

package/dist/orchestrator/templates/specs-test-data.ts

@@ -329,19 +329,7 @@ function resolveDynamicVars(data: Record<string, any>): Record<string, any> {
   const ts = String(Date.now());
   const uid = crypto.randomUUID();
   const now = new Date();
-  // `{{$date}}` is the runner's LOCAL calendar date — the "today" the browser sees when
-  // playwright.config sets no `timezoneId`. toISOString() is UTC, so east of Greenwich it named
-  // yesterday until the offset passed (00:00–06:59 at UTC+7). Node reads the `TZ` env var, so a
-  // config that pins `timezoneId` pins this too by exporting the same zone as `TZ`.
-  // `{{$datetime}}` stays an ISO-8601 UTC instant: it names a moment, not a calendar day.
-  const pad = (n: number): string => String(n).padStart(2, '0');
-  // `{{$date:+1d}}` / `{{$date:-7d}}` shift by whole days; built from the local Y/M/D, so it stays
-  // the right calendar day across a DST change.
-  const localDate = (offsetDays: number): string => {
-    const d = new Date(now.getFullYear(), now.getMonth(), now.getDate() + offsetDays);
-    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
-  };
-  const date = localDate(0);
+  const date = now.toISOString().split('T')[0];
   const datetime = now.toISOString();
 
   function resolveValue(value: any): any {
@@ -356,16 +344,10 @@ function resolveDynamicVars(data: Record<string, any>): Record<string, any> {
             const [min, max] = (args || '1:9999').split(':').map(Number);
             return String(Math.floor(Math.random() * (max - min + 1)) + min);
           }
-          case 'date': {
-            // An argument this does not understand stays literal, like an unknown variable — it used
-            // to be ignored, so `{{$date:+1d}}` silently produced today. Up to 5 digits (~270 years):
-            // a typo like +99999999999d would build an Invalid Date.
-            if (!args) return date;
-            const off = /^([+-]\d{1,5})d$/.exec(args.trim());
-            return off ? localDate(Number(off[1])) : match;
-          }
+          case 'date':
+            return date;
           case 'datetime':
-            return args ? match : datetime;
+            return datetime;
           default:
             return match;
         }

package/dist/utils/safe-yaml-parse.d.ts

@@ -0,0 +1,8 @@
+export declare const SAFE_YAML_MAX_ALIAS_COUNT = 10;
+export declare const SAFE_YAML_MAX_BYTES: number;
+export declare class UnsafeYamlError extends Error {
+    readonly source: string;
+    constructor(source: string, detail: string);
+}
+export declare function safeYamlParse(text: string, source?: string): unknown;
+//# sourceMappingURL=safe-yaml-parse.d.ts.map

package/dist/utils/safe-yaml-parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-yaml-parse.d.ts","sourceRoot":"","sources":["../../src/utils/safe-yaml-parse.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAC5C,eAAO,MAAM,mBAAmB,QAAc,CAAC;AAE/C,qBAAa,eAAgB,SAAQ,KAAK;aACZ,MAAM,EAAE,MAAM;gBAAd,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAI3D;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,SAAW,GAAG,OAAO,CAiBtE"}

package/dist/utils/safe-yaml-parse.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsafeYamlError = exports.SAFE_YAML_MAX_BYTES = exports.SAFE_YAML_MAX_ALIAS_COUNT = void 0;
+exports.safeYamlParse = safeYamlParse;
+/**
+ * Parse YAML that a person or an agent wrote into `qa/` — decisions, test-basis, locks — without
+ * letting the file attack the reader (red-team #14, DOS-13.8).
+ *
+ * - `maxAliasCount` small: a "billion laughs" document that multiplies one anchor through nested
+ *   aliases is refused instead of expanding to gigabytes. None of these files has a reason to
+ *   alias at all; a handful is allowed so a hand-written file with one shared block still reads.
+ * - YAML **core** schema and nothing else: `!!binary`, `!!timestamp`, `!!js/…` or any custom tag is
+ *   an error (the library would otherwise resolve "known" extra tags even under core), and yaml-1.1
+ *   merge keys (`<<`) are not merged. `2026-10-21` stays the string it was written as, so a hash
+ *   over the parsed value equals a hash over the text's intent.
+ * - duplicate keys are an error: two `reason:` lines must not let the second silently win.
+ * - a byte cap: these files are a few hundred bytes; a 100 MB one is an attack or an accident.
+ */
+const yaml_1 = require("yaml");
+exports.SAFE_YAML_MAX_ALIAS_COUNT = 10;
+exports.SAFE_YAML_MAX_BYTES = 1024 * 1024;
+class UnsafeYamlError extends Error {
+    constructor(source, detail) {
+        super(`${source}: ${detail}`);
+        this.source = source;
+        this.name = 'UnsafeYamlError';
+    }
+}
+exports.UnsafeYamlError = UnsafeYamlError;
+function safeYamlParse(text, source = '<yaml>') {
+    if (Buffer.byteLength(text, 'utf8') > exports.SAFE_YAML_MAX_BYTES) {
+        throw new UnsafeYamlError(source, `larger than ${exports.SAFE_YAML_MAX_BYTES} bytes`);
+    }
+    let doc;
+    try {
+        doc = (0, yaml_1.parseDocument)(text, { schema: 'core', resolveKnownTags: false, merge: false, uniqueKeys: true, strict: true, prettyErrors: false });
+    }
+    catch (err) {
+        throw new UnsafeYamlError(source, err instanceof Error ? err.message : String(err));
+    }
+    const problem = doc.errors[0] ?? doc.warnings[0]; // an unresolved tag is only a warning to the library
+    if (problem)
+        throw new UnsafeYamlError(source, problem.message);
+    try {
+        return doc.toJS({ maxAliasCount: exports.SAFE_YAML_MAX_ALIAS_COUNT });
+    }
+    catch (err) {
+        throw new UnsafeYamlError(source, err instanceof Error ? err.message : String(err));
+    }
+}
+//# sourceMappingURL=safe-yaml-parse.js.map

package/dist/utils/safe-yaml-parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-yaml-parse.js","sourceRoot":"","sources":["../../src/utils/safe-yaml-parse.ts"],"names":[],"mappings":";;;AA0BA,sCAiBC;AA3CD;;;;;;;;;;;;;GAaG;AACH,+BAAqC;AAExB,QAAA,yBAAyB,GAAG,EAAE,CAAC;AAC/B,QAAA,mBAAmB,GAAG,IAAI,GAAG,IAAI,CAAC;AAE/C,MAAa,eAAgB,SAAQ,KAAK;IACxC,YAA4B,MAAc,EAAE,MAAc;QACxD,KAAK,CAAC,GAAG,MAAM,KAAK,MAAM,EAAE,CAAC,CAAC;QADJ,WAAM,GAAN,MAAM,CAAQ;QAExC,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;IAChC,CAAC;CACF;AALD,0CAKC;AAED,SAAgB,aAAa,CAAC,IAAY,EAAE,MAAM,GAAG,QAAQ;IAC3D,IAAI,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,2BAAmB,EAAE,CAAC;QAC1D,MAAM,IAAI,eAAe,CAAC,MAAM,EAAE,eAAe,2BAAmB,QAAQ,CAAC,CAAC;IAChF,CAAC;IACD,IAAI,GAAqC,CAAC;IAC1C,IAAI,CAAC;QACH,GAAG,GAAG,IAAA,oBAAa,EAAC,IAAI,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC,CAAC;IAC5I,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,IAAI,eAAe,CAAC,MAAM,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;IACtF,CAAC;IACD,MAAM,OAAO,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAG,qDAAqD;IACzG,IAAI,OAAO;QAAE,MAAM,IAAI,eAAe,CAAC,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IAChE,IAAI,CAAC;QACH,OAAO,GAAG,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,iCAAyB,EAAE,CAAC,CAAC;IAChE,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,IAAI,eAAe,CAAC,MAAM,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;IACtF,CAAC;AACH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sun-asterisk/sungen",
-  "version": "3.2.35",
+  "version": "3.3.0-alpha.10",
   "description": "Deterministic E2E Test Compiler - Gherkin + Selectors → Playwright tests",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -40,8 +40,8 @@
     "@babel/types": "^7.28.5",
     "@cucumber/gherkin": "^37.0.0",
     "@cucumber/messages": "^31.0.0",
-    "@sungen/driver-data-factory": "3.2.35",
-    "@sungen/driver-ui": "3.2.35",
+    "@sungen/driver-data-factory": "3.3.0-alpha.10",
+    "@sungen/driver-ui": "3.3.0-alpha.10",
     "chalk": "^5.6.2",
     "commander": "^14.0.2",
     "dotenv": "^17.2.3",

package/src/basis/anchor-grammar.ts

@@ -0,0 +1,83 @@
+/**
+ * Anchor grammar and the shared trace vocabulary (DOS-12.1, DOS-12.2; takumi T7).
+ *
+ * | anchor                     | example                  | label       |
+ * |----------------------------|--------------------------|-------------|
+ * | `<docId>#<itemId>`         | `SPEC-AUTH-001#A-2`      | `EXTRACTED` |
+ * | `<docId>#<itemId>/val`     | `SPEC-AUTH-001#A-2/val`  | `EXTRACTED` |
+ * | `sec-<slug>`               | `sec-login-form`         | `INFERRED`  |
+ * | duplicate id / fuzzy match | —                        | `AMBIGUOUS` |
+ *
+ * docId is the spec frontmatter `id`; itemId is COMPOSED from BM-51 §4.1 (`2.0` under section row
+ * `A` → `A-2`). BM-51 has no `VAL-xx` codes: a Validation row is keyed by its item. `screen_id` is
+ * metadata and never part of an anchor. Every anchor is cited as `repo@SHA:path#Lx-Ly`.
+ */
+import { createHash } from 'crypto';
+
+export type AnchorKind = 'item' | 'validation' | 'section';
+export type AnchorConfidence = 'EXTRACTED' | 'INFERRED' | 'AMBIGUOUS';
+
+/** Score band per label (takumi confidence taxonomy): inclusive lower, inclusive upper. */
+export const CONFIDENCE_BANDS: Record<AnchorConfidence, readonly [number, number]> = {
+  EXTRACTED: [0.9, 1],
+  INFERRED: [0.5, 0.89],
+  AMBIGUOUS: [0, 0.49],
+};
+
+const DOC_ID = '[A-Z][A-Z0-9]*(?:-[A-Z0-9]+)+';
+const ITEM_ID = '[A-Z]+-\\d+(?:\\.\\d+)?';
+const ITEM_ANCHOR_RE = new RegExp(`^(${DOC_ID})#(${ITEM_ID})(/val)?$`);
+const SECTION_ANCHOR_RE = /^sec-[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const CITATION_RE = /^([^@\s]+)@([^:\s]+):([^#\s]+)#L(\d+)-L(\d+)$/;
+
+export interface ParsedAnchorId { kind: AnchorKind; docId?: string; itemId?: string; slug?: string }
+
+export function parseAnchorId(id: string): ParsedAnchorId | null {
+  const item = ITEM_ANCHOR_RE.exec(id);
+  if (item) return { kind: item[3] ? 'validation' : 'item', docId: item[1], itemId: item[2] };
+  if (SECTION_ANCHOR_RE.test(id)) return { kind: 'section', slug: id.slice(4) };
+  return null;
+}
+
+export function isItemAnchorId(id: string): boolean {
+  return ITEM_ANCHOR_RE.test(id);
+}
+
+export function isDocId(id: string): boolean {
+  return new RegExp(`^${DOC_ID}$`).test(id);
+}
+
+export function itemAnchorId(docId: string, itemId: string, validation = false): string {
+  return `${docId}#${itemId}${validation ? '/val' : ''}`;
+}
+
+/**
+ * BM-51 §4.1 numbers items `1.0, 2.0 …` under a bold section row; the composed id drops the `.0`
+ * (`2.0` under `A` → `A-2`) and keeps a real sub-number (`2.1` → `A-2.1`). No section → null.
+ */
+export function composeItemId(section: string | null, itemNumber: string): string | null {
+  if (!section || !/^[A-Z]+$/.test(section)) return null;
+  const n = itemNumber.trim().replace(/\.0+$/, '');
+  return /^\d+(?:\.\d+)?$/.test(n) ? `${section}-${n}` : null;
+}
+
+/** `sec-<slug>` from a heading: accents folded, ASCII kebab-case; a script with no ASCII gets a hash. */
+export function sectionAnchorId(heading: string): string {
+  const slug = heading.normalize('NFKD').replace(/\p{M}/gu, '').replace(/[đĐ]/g, 'd').toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+  return `sec-${slug || createHash('sha1').update(heading).digest('hex').slice(0, 8)}`;
+}
+
+export interface CitationBase { repo: string; sha: string; path: string }
+
+export function formatCitation(base: CitationBase, startLine: number, endLine: number): string {
+  return `${base.repo}@${base.sha}:${base.path.replace(/\\/g, '/')}#L${startLine}-L${endLine}`;
+}
+
+export function parseCitation(s: string): (CitationBase & { start: number; end: number }) | null {
+  const m = CITATION_RE.exec(s);
+  if (!m) return null;
+  const start = Number(m[4]);
+  const end = Number(m[5]);
+  return start >= 1 && end >= start ? { repo: m[1], sha: m[2], path: m[3], start, end } : null;
+}

package/src/basis/anchor-hash.ts

@@ -0,0 +1,27 @@
+/**
+ * Hash by anchor kind (DOS-12.3, red-team #1).
+ *
+ * | anchor kind                  | hash        | why                                                      |
+ * |------------------------------|-------------|----------------------------------------------------------|
+ * | section `sec-<slug>` (legacy) | `sha1-12`   | every manifest already on disk holds these; a new algorithm would read "changed" everywhere |
+ * | item `<docId>#<itemId>`       | `sha256-12` | new in schema 2, so nothing old depends on it            |
+ *
+ * `sectionHash` is the exact computation the manifest has always used: sha1 over the section
+ * body joined with LF and trimmed, first 12 hex. Do not "improve" it.
+ */
+import { createHash } from 'crypto';
+
+export type HashAlgo = 'sha1-12' | 'sha256-12';
+
+export function sectionHash(bodyLines: string[]): string {
+  return createHash('sha1').update(bodyLines.join('\n').trim()).digest('hex').slice(0, 12);
+}
+
+/** One table row as compared: cells trimmed, inner whitespace collapsed, joined by `|`. */
+export function normalizeRow(cells: string[]): string {
+  return cells.map((c) => c.normalize('NFC').replace(/\s+/g, ' ').trim()).join('|');
+}
+
+export function itemRowHash(cells: string[]): string {
+  return createHash('sha256').update(normalizeRow(cells)).digest('hex').slice(0, 12);
+}

package/src/basis/bm51-tables.ts

@@ -0,0 +1,65 @@
+/**
+ * Read the BM-51 screen-spec tables that carry item ids (company standard, DOS-12.0).
+ *
+ * `reports/mng/specs/_templates/BM-2-901-51-screen-specification-template.md`:
+ *   §4.1 Item          `| ID | Item Name | Item Type | Required | Note |`  — bold section row `A`, then `1.0`, `2.0` …
+ *   §4.2 Validation    `| ID | Type | Min | Max | Default | … |`          — rows keyed by the composed id `A-2`
+ *   §4.3 Data Mapping  `| ID | Data Source | API ID | … |`                — same key
+ *   §5   Event         `| ID | Given (Pre-condition) | … |`               — same key, or `-`
+ *
+ * Tables are recognised by their header (first column `ID` plus the second column's name), not by
+ * heading numbers, so a translated heading still reads. Rows keep their 1-based source line.
+ */
+import { composeItemId } from './anchor-grammar';
+
+export type Bm51TableKind = 'item' | 'validation' | 'mapping' | 'event';
+
+export interface Bm51Row { table: Bm51TableKind; cells: string[]; id: string; line: number }
+export interface Bm51ItemRow extends Bm51Row { section: string | null; itemId: string | null }
+export interface Bm51Tables { items: Bm51ItemRow[]; validations: Bm51Row[]; mappings: Bm51Row[]; events: Bm51Row[] }
+
+const SEPARATOR = /^\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)*\|?\s*$/;
+const COMPOSED_ID = /^[A-Z]+-\d+(?:\.\d+)?$/;
+
+function splitRow(line: string): string[] {
+  const body = line.trim().replace(/^\|/, '').replace(/\|$/, '');
+  return body.split(/(?<!\\)\|/).map((c) => c.replace(/\\\|/g, '|').trim());
+}
+const bare = (cell: string): string => cell.replace(/\*\*|__|`/g, '').trim();
+
+function kindOf(header: string[]): Bm51TableKind | null {
+  if (bare(header[0] ?? '').toUpperCase() !== 'ID') return null;
+  const second = bare(header[1] ?? '').toLowerCase();
+  if (second === 'item name') return 'item';
+  if (second === 'type') return 'validation';
+  if (second === 'data source') return 'mapping';
+  if (second.startsWith('given')) return 'event';
+  return null;
+}
+
+/** `lines` are the spec's lines; `firstLine` is the 1-based number of `lines[0]`. */
+export function readBm51Tables(lines: string[], firstLine = 1): Bm51Tables {
+  const out: Bm51Tables = { items: [], validations: [], mappings: [], events: [] };
+  for (let i = 0; i < lines.length - 1; i++) {
+    if (!lines[i].trim().startsWith('|') || !SEPARATOR.test(lines[i + 1].trim())) continue;
+    const kind = kindOf(splitRow(lines[i]));
+    let j = i + 2;
+    let section: string | null = null;
+    for (; j < lines.length && lines[j].trim().startsWith('|'); j++) {
+      if (!kind) continue;
+      const cells = splitRow(lines[j]);
+      const id = bare(cells[0] ?? '');
+      const line = firstLine + j;
+      if (kind === 'item') {
+        if (/^[A-Z]+$/.test(id)) { section = id; continue; }
+        if (!/^\d+(?:\.\d+)?$/.test(id)) continue;
+        out.items.push({ table: kind, cells, id, line, section, itemId: composeItemId(section, id) });
+      } else if (COMPOSED_ID.test(id)) {
+        const row: Bm51Row = { table: kind, cells, id, line };
+        (kind === 'validation' ? out.validations : kind === 'mapping' ? out.mappings : out.events).push(row);
+      }
+    }
+    i = j - 1;
+  }
+  return out;
+}