@sun-asterisk/sungen 3.2.16-beta.1 → 3.2.16-beta.11

package/dist/orchestrator/templates/ai-src/commands/delivery.md

@@ -1,7 +1,7 @@
 ---
 name: delivery
 description: "Export the Test Case & Coverage Matrix (review/manual/customer deliverable) from Gherkin + Playwright results. --legacy exports the classic per-scenario CSV/XLSX."
-argument-hint: "[name...] [--env <locale>] [--legacy] (omit names for all; --env for locale-specific export)"
+argument-hint: "[name...] [--format csv] [--env <locale>] [--legacy] (omit names for all)"
 order: 50
 claude-tools: "Bash, Read, Write, AskUserQuestion"
 copilot-tools: "[read, execute, edit, vscode/askQuestions]"
@@ -26,7 +26,14 @@ review → approve → official render.
 ## Parameters
 
 Parse from `$ARGUMENTS`:
-- **names** — zero or more screen/flow/api names. Empty → all targets.
+- **names** — zero or more screen/flow/api names. Empty → **a sweep of every unit**.
+  Strictness follows the scope: a **named** unit that is not ready aborts the run (the user asked
+  for that unit); a **sweep** exports every ready unit and skips the rest with an accounted
+  "Not exported" list, succeeding as long as something was written. So `/sungen:delivery` with no
+  argument is safe in a work-in-progress project — scaffolded units (added but `create-test` not
+  run) no longer block the units that are ready.
+- **`--format <xlsx|csv|both>`** — output format. **Default `xlsx` — one artifact only.** Pass
+  `--format csv` when the user wants the flat CSV (pipelines/diffing), `--format both` for both.
 - **`--env <locale>`** — sets `SUNGEN_ENV=<locale>` for the run (accept `--locale` as alias).
 - **`--legacy` / `--full`** — pass through to the CLI and skip the map flow entirely.
 
@@ -37,14 +44,19 @@ Parse from `$ARGUMENTS`:
 ```bash
 [ -x ./bin/sungen.js ] && ./bin/sungen.js delivery <names> || npx sungen delivery <names>
 ```
-(prepend `SUNGEN_ENV=<locale>` when `--env` was given; append `--legacy` when requested — then skip
-to step 5.)
+(prepend `SUNGEN_ENV=<locale>` when `--env` was given; append `--format <fmt>` when the user asked
+for a non-default format; append `--legacy` when requested — then skip to step 5.)
 
 Three outcomes per target:
 - **Rendered** → done, go to step 5.
 - **"no delivery map"** → go to step 2 (propose it).
 - **Gate findings / "not approved"** → go to step 4 (review & approve).
 
+On a sweep, read the **"Not exported"** list at the end: units marked *not authored yet* need
+`/sungen:create-test` first, the others each printed their own reason above (missing map, gate
+errors, or awaiting approval). Handle them one unit at a time — do not re-run the sweep expecting
+a different result.
+
 ### 2. Propose the Delivery Map (only when missing or the user asks to regroup)
 
 Read the unit's `.feature` (and `requirements/spec.md` for target naming). Write
@@ -58,27 +70,97 @@ groups:
     target: login.email            # ONE target: field/component dot-path, flow phrase, or METHOD /path
     intent: <one behavior/rule this item verifies>
     oracle: <the shared observable Pass/Fail statement>
-    category: normal | abnormal | security | nfr
+    dimensions: violated rule — required ×3 · format ×10 · full-width ×2   # see below
+    category: normal | abnormal | security | nfr   # see the rule below
     review: proposed               # ALWAYS proposed — only QA approval flips it
-    variants: [VP-VAL-001-B, VP-VAL-001-S]   # VP-ids; bare id on a @cases scenario = all its rows
+    variants: [VP-VAL-001-B, VP-VAL-001-S]   # the scenario ids of THIS project (VP-…, SEC-123, MS-HP-001 —
+                                             # whatever the titles use); a bare id on a @cases scenario = all its rows
 dispositions:                      # scenarios intentionally NOT delivered as test cases
   VP-DATA-000: { as: excluded, reason: data-setup checklist }
   # as: excluded | blocked | covered_elsewhere | accepted_risk
 ```
 
-**Grouping rules (the aggregation signature):**
-- One group = **one target + one intent + one oracle family**. When unsure, keep items separate —
-  the gates and QA decide, never guess-merge.
-- MAY share a group (become coverage dimensions): equivalence partitions, boundary values,
-  different data (`@cases` rows), a different trigger with the same oracle (blur vs submit),
-  locales.
-- MUST split: different target, intent, oracle family, category, execution mode (`@manual` vs
-  auto), test layer (`@api`/`@query`), or priority tag; sequence-sensitive flows (re-Given/When
-  after a Then) stay solo.
+**Grouping rules (the aggregation signature) — group COMPACTLY.** The matrix exists to be
+substantially shorter than the scenario list, so a reviewer can see missing viewpoints at a
+glance. Merge whenever the cases share ALL of: target · test intent/business rule ·
+precondition/condition · trigger or procedure shape · **the way the expected result is
+determined** (its oracle *family*, not its exact message).
+
+- **Oracle family = the determination method, parameterized.** All validation branches of ONE
+  field belong to ONE item — required, format, length, character-class are *expected branches*
+  (parameters) of "the field shows the validation message defined for the violated rule", shown
+  per variant, never separate items.
+- MAY vary inside one item (coverage dimensions, visible on the sub-rows): data values, boundary
+  points, **account states** (a seeded/locked/deleted account next to a wrong-password case),
+  provider/browser/locale, `@cases` rows, a different trigger with the same oracle (blur vs
+  submit), **execution mode** (auto + manual mix — the parent shows `Auto n · Manual m`), and
+  **priority** (the item takes the highest; per-variant priorities stay visible).
+- MUST split: different target, different intent/business rule, different way of determining the
+  expected result (a field-error family ≠ a session-established family), different test layer
+  (`@api`/`@query`), materially different precondition, or a different procedure shape —
+  sequence-sensitive flows (re-Given/When after a Then) stay solo. **Different risk classes never
+  merge**: XSS and SQL injection are separate items (different risk and determination), even on
+  the same field.
+- **Look for these families before settling on a grouping** — they are where under-merging happens:
+  | Family | Merge into one item |
+  |---|---|
+  | Static render | every "element X is visible/has its content on load" scenario of the screen — title, instructions, progress step, buttons present, header/footer |
+  | Field validation branches | all rules of ONE field (required · format · length · character class · full-width) |
+  | Account/entity states | wrong-credentials · locked · deleted · unverified for the same rejection oracle |
+  | Provider / surface sets | the 3 OAuth providers, header+footer, the a11y surfaces of one behaviour |
+  | Lifetime / mode pairs | checked vs unchecked, mobile vs desktop, when the oracle is one rule with two branches |
+  On a 36-scenario screen, four separate one-variant "renders on load" items should have been one.
+- When unsure, keep items separate — the gates and QA decide, never guess-merge.
 - Every scenario must land in exactly one group **or** one disposition (Gate B enforces 100%
   disposition). Data-setup blocks (`@manual:data-setup`) → `excluded`; SPEC-GAP placeholders →
   `blocked`.
 
+**`dimensions:` — the compact coverage digest (required for items with >3 variants).**
+This one short line is what the collapsed parent row shows instead of listing every variant, so a
+reviewer sees *which dimensions* the item covers without expanding it. Name the dimension, then the
+branches with counts:
+- `violated rule — required ×3 · format ×10 · full-width ×2`
+- `account state — wrong password · unregistered · locked · soft-deleted`
+- `submission method — Login button · Enter in Password · Enter in Email`
+
+Keep it ≤120 chars (Gate W warns). **YAML caveat:** a bare `: ` inside the value breaks the parse —
+use ` — ` as the label separator (as above) or quote the whole string.
+
+**`category` is not free choice for two classes (Gate K checks it):** a group whose variants are
+`VP-SEC-*` MUST be `category: security`, and `VP-NFR-*` MUST be `nfr` — otherwise the Coverage
+sheet's security/nfr column renders empty and the grid reports a gap the unit does not have while
+hiding the work it does have. `normal` vs `abnormal` stays your judgement.
+
+**Wording rules for `intent`/`oracle` (customer-facing — Gate W lints these):**
+- Plain product language, present simple, ~10–20 words, one behavior:
+  "A user can sign in with valid credentials and is redirected to the Jobs page."
+- Oracle = the observable outcome as a definite assertion ("The Jobs page is displayed and the
+  Logout link is visible.") — no `should`, no tester actions.
+- NEVER: `{{tokens}}`, `[Selector]` references, DSL phrasing (`User fill/click/see`), generator
+  labels (`Setup:`/`Observable:`/`Oracle:`), or vague verbs (`handles`, `surfaces`) when a precise
+  behavior exists. Use the visible UI label (the Login button, the Email field).
+- **Preserve the source meaning exactly** — never strengthen, weaken, or reinterpret an oracle
+  (a security assertion especially: if the source says "the password appears ONLY in the HTTPS
+  POST body", do not write "no plaintext password on the network").
+
+**Requirement coverage (`requirements:` section, optional):** `sungen delivery` scans
+`requirements/spec.md` for FR-/TR-/NFR- ids; ids traced by `@spec:` tags are `covered`, the rest
+are `gap` (Gate R warning). Record the reviewed status for genuine non-gaps:
+
+```yaml
+requirements:
+  TR-007: { status: planned, note: Performance needs Lighthouse-style tooling }
+  TR-004: { status: partially_covered, note: client-side covered by VP-SEC-003; hashing needs DB verify }
+  # status: covered | partially_covered | covered_elsewhere | planned | gap | not_applicable
+```
+
+**Never write `status: covered` for a requirement no variant traces to** (Gate R flags it). A note
+saying "proven by DI-SEC-CSRF" is prose — nothing detects it when that scenario later changes. If a
+scenario in THIS feature proves the requirement, **add `@spec:<id>` to that scenario** so the trace
+is real, then drop the override (it derives as `covered` on its own). Use `covered_elsewhere` only
+when another suite proves it, and name that suite; `not_applicable` when the spec itself excludes
+the requirement.
+
 Then validate and fix any ERROR findings:
 
 ```bash
@@ -115,6 +197,7 @@ counted in variants, never items**). Then `AskUserQuestion`:
 - **Open the workbook** — inspect `qa/deliverables/<unit>-testcases.xlsx` (Testcases sheet:
   collapse outline level 1 for the customer view; Coverage sheet: target × category grid + gaps).
 - **Run tests to refresh results** — `/sungen:run-test <unit>`, then re-run delivery.
+- **Also export CSV** — `sungen delivery <unit> --format csv` (flat `item`/`variant` rows for pipelines).
 - **Export the legacy workbook too** — `sungen delivery <unit> --legacy`.
 - **Done**
 
@@ -132,7 +215,8 @@ counted in variants, never items**). Then `AskUserQuestion`:
 ## CLI reference
 
 ```
-sungen delivery [names...]        # matrix (default; needs the map)
+sungen delivery [names...]        # matrix (default; needs the map) → XLSX only
+  --format <xlsx|csv|both>        # output format; default xlsx (one artifact)
   --check                         # gates only — validate the map, write nothing
   --approve [DI-a,DI-b]           # flip proposed→approved (+ stamp fingerprints); all groups when bare
   --preview                       # render despite review findings (DRAFT watermark)
@@ -140,5 +224,6 @@ sungen delivery [names...]        # matrix (default; needs the map)
   --skip-preflight | --continue-on-missing | --env <env>   # as before
 ```
 
-Outputs: `qa/deliverables/<unit>-testcases.xlsx` (Testcases + Coverage sheets) + `.csv`
-(flat, `Level` column `item|variant`). Legacy mode writes the classic files instead.
+Outputs: `qa/deliverables/<unit>-testcases.xlsx` (Testcases + Coverage sheets) by default;
+`--format csv` writes `<unit>-testcases.csv` instead (flat, `Level` column `item|variant`),
+`--format both` writes both. Legacy mode writes the classic files instead.

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

@@ -29,19 +29,85 @@ fingerprints). Schema + grouping rules live in the delivery command instructions
 spec is `docs/spec/delivery-coverage-matrix-spec.md`.
 
 **Gates** (CLI `--check`): A source (VP-ids unique, oracle present, Background setup-only) ·
-B mapping (every scenario in exactly one group XOR one disposition) · C aggregation (mode/layer/
-priority recomputed and equal within a group — heuristic oracle-shape/precondition mismatches are
-review-level, silenced once approved and unchanged) · D executability (precondition · condition+
-data · trigger · oracle all renderable; every `{{var}}` resolves) · E drift (fingerprint mismatch
-→ back to review) · G review state (proposed groups block the official render; `--preview` renders
-a DRAFT watermark).
-
-**Workbook**: `Testcases` sheet (parent rows + outline-level-1 variant sub-rows — collapse for the
-customer view, expand to execute; result roll-up failed→blocked→not_run→partial→passed, counts like
-`7/8 Passed · 1 Failed`) + `Coverage` sheet (target × category grid with explicit `—` gaps,
-dispositions, generation manifest). CSV is flat with a `Level` column (`item`/`variant`).
+B mapping (every scenario in exactly one group XOR one disposition) · C aggregation (test layer
+recomputed and equal within a group — **execution mode and priority are coverage dimensions, not
+splits**: mixed items show `Auto n · Manual m` and take the highest variant priority; heuristic
+oracle-shape/precondition mismatches are review-level, silenced once approved and unchanged) ·
+D executability (precondition · condition+
+data · trigger · oracle all renderable; every `{{var}}` resolves; **no template token may survive
+into a rendered cell** — test-data cross-references are resolved for display) · E drift
+(scenario fingerprint mismatch → back to review; the map's OWN reviewed
+wording/grouping is fingerprinted as `__map__` too, so post-approval edits re-open review) · G review state (proposed groups block the official
+render; `--preview` renders a DRAFT watermark) · K category class (a `VP-SEC-*` variant outside
+`category: security`, or `VP-NFR-*` outside `nfr` → warning: the Coverage grid's column would render
+empty and report a false gap) · R requirement coverage (spec FR/TR/NFR ids with no trace and no
+`requirements:` status → warning; **and a `status: covered` override that no variant traces to** →
+warning: tag the proving scenario `@spec:<id>` instead of asserting it in prose) · W wording lint (map intent/oracle containing
+tokens, `[Selector]` refs, DSL phrasing, or generator labels → warning).
+
+**Wording normalization (deterministic, after semantic normalization):** DSL steps render as
+controlled manual-test English without changing meaning — actions in the imperative (`User fill
+[Email] field with X` → `Enter X in the Email field.`), expected results as observable assertions
+(`User see [Jobs] page` → `The Jobs page is displayed.`), preconditions as states (`The user is
+signed out.`). Manual `# Tester verifies:` labels become structured fields: `Setup:` →
+Precondition, `Action:` → Action, `Observable:` → Expected Result, `Oracle:` → a separate
+`Verification method:` line. Sequence-sensitive flows keep event order: actions numbered with
+mid-flow assertions inline as `Verify: …`; only the final Then block is the Expected Result.
+Empty test values render as `(empty)`.
+
+**Output format**: **XLSX only by default** (one artifact). `--format csv` writes the flat CSV
+instead; `--format both` writes both.
+
+**Scope decides strictness**: a **named** unit that is not ready aborts with exit 1 (pass
+`--continue-on-missing` to tolerate it); a **no-argument sweep** exports every ready unit, lists
+every unit it did not export with the reason, and exits 0 as long as it wrote something — a
+scaffolded unit never blocks the ready ones.
+
+**Workbook**: `Testcases` sheet — parent rows + outline-level-1 variant sub-rows for **every**
+item (single-variant included: the sub-row carries the source VP-id, resolved data, and the
+result/evidence entry). Sub-rows are **delta-only**: knowledge common to the whole item
+(precondition, trigger) is written ONCE on the parent; a child repeats only what distinguishes it
+(condition/data, precondition delta, trigger when it differs) plus its own precise oracle and
+execution fields. The parent never carries placeholder text — when triggers differ the cell is
+simply empty and the sub-rows carry them.
+
+Parent preconditions are the **intersection** of the variants' and the parent's Action holds the
+**shared leading steps**; each variant renders only its remaining steps, numbered to continue the
+parent's list — so a shared prefix is written once, not repeated on every child. The parent's
+Coverage cell is the map's short `dimensions:` digest (or the variant refs when none is declared),
+never a concatenation of variant titles.
+
+Variant Result cells hold exactly one of `Passed`/`Failed`/`Blocked`/`Pending`/`N/A` (dropdown) —
+that vocabulary is the contract: the parent Result and the summary band are **live Excel formulas**
+counting those words, so a parent label is always a composed `n/m Passed …` string (`All N/A` when
+every variant is N/A) and never a bare state word. **`N/A` leaves the denominator.** Evidence and
+Defect ID are separate columns; ID + Target frozen; ISO dates; landscape print with repeated
+header rows.
+
+`Coverage` sheet — requirement coverage table (every FR/TR/NFR id with an explicit status),
+target × category grid with explicit `—` gaps, dispositions, manifest. CSV mirrors the same model
+flat with a `Level` column (`item`/`variant`) + a requirement-coverage appendix.
 `delivery_item_count` ≠ progress — variants are the execution metric.
 
+**Id schemes**: the `VP-<CAT>-<NNN>` convention is a suggestion, not a requirement — a project's own
+scheme (`SEC-123`, `PER-345`, `MS-HP-001`) is addressed the same way, and the category segment
+(`SEC`, `PER`) still drives Gate K. Requirement ids come from the spec's own bolded declarations
+(`- **REQ-12**: …`), so a project that does not use FR/TR/NFR still gets its coverage table.
+
+**Runtime-captured values**: a scenario may produce its own values — `User remember [X] text as
+{{v}}` (compared later) or a capability binding (`@query:`/`@api:`/`@dataFactory:`). These never
+exist in test-data, so Gate D does not ask for them: the capture step renders as an instruction
+(`Note the X text for later (as "v")`) and later references read `the captured v`.
+
+**Data fidelity**: invisible test data is made visible, never normalized — `''` → `(empty)`,
+whitespace-only → `(5 spaces)`, padded → `" value "` quoted verbatim. A trim/collapse here would
+silently break the whitespace tests it describes.
+
+**Authoring guidance the matrix rewards** (create-test side): payload/provider matrices (SQLi
+payload lists, OAuth provider sets) belong in `@cases` datasets so each case is an atomic,
+independently-reportable variant; keep dataset `case:` labels short and stable (`CHK-EMAIL-I1`),
+with descriptions in other columns — the label is part of the variant's identity.
+
 ---
 
 ## Legacy mode (--legacy / --full)

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

@@ -288,6 +288,7 @@ Options: `nth` `exact` `scope` `match` `variant` `frame` `contenteditable` `colu
 
 | Tag | Effect |
 |---|---|
+| `@spec:<id>` | **Traceability**: this scenario proves requirement `<id>` from `requirements/spec.md` (`@spec:FR-003`). Repeatable — a scenario may prove several. Read by `sungen audit` (requirement coverage) and by delivery (the Coverage sheet's requirement table). Without it the link is only inferred from wording and cannot survive an edit. |
 | `@manual` | Skip in generation |
 | `@auth:role` | Use auth storage state for role |
 | `@no-auth` | Disable inherited auth |

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

@@ -4,6 +4,28 @@ description: 'Use when create-test needs to translate spec.md/Figma/UI into .fea
 user-invocable: false
 ---
 
+
+## Traceability — tag the requirement each scenario proves
+
+Every requirement id in `requirements/spec.md` (`FR-`/`TR-`/`NFR-`) must be reachable from a
+scenario, and the link must be **written down, not inferred**:
+
+```gherkin
+@high @spec:FR-003
+Scenario: VP-VAL-002 An email in an invalid format shows the format error
+```
+
+- Put `@spec:<id>` on the scenario that actually proves the requirement; repeat the tag when one
+  scenario proves several (`@spec:FR-003 @spec:FR-004`).
+- One requirement may be proved by several scenarios — tag each of them.
+- A requirement you deliberately do not cover here (performance budget, i18n suite, server-side
+  concern) needs no tag; record it later in the delivery map's `requirements:` section with a
+  status and reason.
+- Why it matters: `sungen audit` also counts a requirement as covered when its keywords merely
+  resemble a scenario title, and reports `SPEC-TRACE-IMPLICIT` for those. Delivery's requirement
+  table follows **only** the explicit tag — an untagged requirement reads as an uncovered gap in
+  the customer-facing coverage sheet even when a scenario does prove it.
+
 ## ⚠️ Gotchas — read before generating
 
 - **Field-level test-data follows the Data Factory standard — don't hand-invent values.** When the unit has input fields, the field values (valid / boundary / invalid + error codes) come from the **`sungen-data-factory`** catalog via a field-map + `sungen data gen` (create-test step 5.3), not free-form guessing. Weave the standardized boundary/invalid sets into `@cases` with `CHK-*` trace. This skill still owns scenario structure, viewpoints, and non-field oracles.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sun-asterisk/sungen",
-  "version": "3.2.16-beta.1",
+  "version": "3.2.16-beta.11",
   "description": "Deterministic E2E Test Compiler - Gherkin + Selectors → Playwright tests",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -12,7 +12,7 @@
     "copy-templates": "mkdir -p dist/generators/test-generator/adapters/playwright/templates/steps && mkdir -p dist/generators/test-generator/templates && mkdir -p dist/orchestrator/templates && mkdir -p dist/dashboard/templates && cp -r src/generators/test-generator/adapters/playwright/templates/*.hbs dist/generators/test-generator/adapters/playwright/templates/ 2>/dev/null || true && cp -r src/generators/test-generator/adapters/playwright/templates/steps dist/generators/test-generator/adapters/playwright/templates/ && mkdir -p dist/generators/test-generator/adapters/appium/templates/steps && cp -r src/generators/test-generator/adapters/appium/templates/*.hbs dist/generators/test-generator/adapters/appium/templates/ 2>/dev/null || true && cp -r src/generators/test-generator/adapters/appium/templates/steps dist/generators/test-generator/adapters/appium/templates/ && cp src/generators/test-generator/templates/*.hbs dist/generators/test-generator/templates/ 2>/dev/null || true && cp -r src/orchestrator/templates/* dist/orchestrator/templates/ && cp src/dashboard/templates/index.html dist/dashboard/templates/index.html && mkdir -p dist/harness/catalog && cp src/harness/catalog/*.yaml dist/harness/catalog/",
     "build:dashboard": "cd ../../dashboard && npm install --silent && npm run build && cd - && cp ../../dashboard/dist/index.html src/dashboard/templates/index.html",
     "dev": "tsx src/cli/index.ts",
-    "test": "tsx tests/golden/run.ts && tsx tests/audit/run.ts && tsx tests/ingest/run.ts && tsx tests/eval/run.ts && tsx tests/exporter/run.ts && tsx tests/exporter/delivery-matrix.run.ts && tsx tests/exporter/feature-parser-category.run.ts && tsx tests/exporter/api-detail-sheet.run.ts && tsx tests/exporter/overview-sheet.run.ts && tsx tests/exporter/delivery-divider-tcid.run.ts && tsx tests/exporter/note-expected-actual.run.ts && tsx tests/exporter/test-data-vars.run.ts && tsx tests/exporter/mobile-app-id.run.ts && tsx tests/exporter/api-testcase-cells.run.ts && tsx tests/exporter/delivery-cases-result.run.ts && tsx tests/exporter/precondition-auth-role.run.ts && tsx tests/exporter/report-builder-parity.run.ts && tsx tests/exporter/delivery-preflight-testdata.run.ts && tsx tests/exporter/delivery-preflight-selectors.run.ts && tsx tests/exporter/delivery-prerun-overview.run.ts && tsx tests/exporter/delivery-locale-env-discovery.run.ts && tsx tests/exporter/manual-testcase-testdata.run.ts && tsx tests/dashboard/api-flows-discovery.run.ts && tsx tests/dashboard/status-results-fallback.run.ts && tsx tests/codegen/verb-ref-masking.run.ts && tsx tests/codegen/table-aria-hidden-locators.run.ts && tsx tests/codegen/steps-base-not-compiled.run.ts && tsx tests/codegen/manual-oracle-gate.run.ts && tsx tests/codegen/locator-value-qualified-assertions.run.ts && tsx tests/codegen/table-match-data-column-mapping.run.ts && tsx tests/codegen/param-binding-native-type.run.ts && tsx tests/codegen/table-row-scope-redeclaration.run.ts && tsx tests/codegen/table-row-label-resolution.run.ts && tsx tests/api-runtime/base-path-url-join.run.ts && tsx tests/api-runtime/file-upload-multipart.run.ts && tsx tests/api-runtime/schema-assertion.run.ts && tsx tests/runtime/test-data-cross-ref.run.ts && tsx tests/runtime/test-data-array-projection.run.ts && tsx tests/runtime/env-secret-interpolation.run.ts && tsx tests/capabilities/run.ts && tsx tests/openapi/run.ts && tsx tests/api-field-coverage/run.ts && tsx tests/packaging/run.ts && tsx tests/generate-hint/run.ts && tsx tests/template-assertion/run.ts && tsx tests/journey/run.ts && tsx tests/harness/serial-cascade.run.ts && tsx tests/ai-skills/cross-assistant-orphan.run.ts && tsx tests/init/codex-mcp-config.run.ts && tsx src/orchestrator/ai-skills/golden-skills.test.ts && tsx tests/db-runtime/sql-placeholder-rewrite.run.ts && tsx tests/db-runtime/fallback-flow-codified.run.ts && tsx tests/db-runtime/cosmos-engine.run.ts && tsx tests/db-runtime/mongodb-engine.run.ts && tsx tests/db-runtime/dynamodb-engine.run.ts && tsx tests/db-runtime/mysql-integration.opt-in.run.ts && tsx tests/db-runtime/mongodb-integration.opt-in.run.ts && tsx tests/db-runtime/dynamodb-integration.opt-in.run.ts",
+    "test": "tsx tests/golden/run.ts && tsx tests/audit/run.ts && tsx tests/ingest/run.ts && tsx tests/eval/run.ts && tsx tests/exporter/run.ts && tsx tests/exporter/delivery-matrix.run.ts && tsx tests/exporter/delivery-scope-strictness.run.ts && tsx tests/exporter/feature-parser-category.run.ts && tsx tests/exporter/api-detail-sheet.run.ts && tsx tests/exporter/overview-sheet.run.ts && tsx tests/exporter/delivery-divider-tcid.run.ts && tsx tests/exporter/note-expected-actual.run.ts && tsx tests/exporter/test-data-vars.run.ts && tsx tests/exporter/mobile-app-id.run.ts && tsx tests/exporter/api-testcase-cells.run.ts && tsx tests/exporter/delivery-cases-result.run.ts && tsx tests/exporter/precondition-auth-role.run.ts && tsx tests/exporter/report-builder-parity.run.ts && tsx tests/exporter/delivery-preflight-testdata.run.ts && tsx tests/exporter/delivery-preflight-selectors.run.ts && tsx tests/exporter/delivery-prerun-overview.run.ts && tsx tests/exporter/delivery-locale-env-discovery.run.ts && tsx tests/exporter/manual-testcase-testdata.run.ts && tsx tests/dashboard/api-flows-discovery.run.ts && tsx tests/dashboard/status-results-fallback.run.ts && tsx tests/codegen/verb-ref-masking.run.ts && tsx tests/codegen/table-aria-hidden-locators.run.ts && tsx tests/codegen/steps-base-not-compiled.run.ts && tsx tests/codegen/manual-oracle-gate.run.ts && tsx tests/codegen/locator-value-qualified-assertions.run.ts && tsx tests/codegen/table-match-data-column-mapping.run.ts && tsx tests/codegen/param-binding-native-type.run.ts && tsx tests/codegen/table-row-scope-redeclaration.run.ts && tsx tests/codegen/table-row-label-resolution.run.ts && tsx tests/api-runtime/base-path-url-join.run.ts && tsx tests/api-runtime/file-upload-multipart.run.ts && tsx tests/api-runtime/schema-assertion.run.ts && tsx tests/runtime/test-data-cross-ref.run.ts && tsx tests/runtime/test-data-array-projection.run.ts && tsx tests/runtime/env-secret-interpolation.run.ts && tsx tests/capabilities/run.ts && tsx tests/openapi/run.ts && tsx tests/api-field-coverage/run.ts && tsx tests/packaging/run.ts && tsx tests/generate-hint/run.ts && tsx tests/template-assertion/run.ts && tsx tests/journey/run.ts && tsx tests/harness/serial-cascade.run.ts && tsx tests/harness/score-model.run.ts && tsx tests/harness/spec-trace-crlf.run.ts && tsx tests/ai-skills/cross-assistant-orphan.run.ts && tsx tests/init/codex-mcp-config.run.ts && tsx src/orchestrator/ai-skills/golden-skills.test.ts && tsx tests/db-runtime/sql-placeholder-rewrite.run.ts && tsx tests/db-runtime/fallback-flow-codified.run.ts && tsx tests/db-runtime/cosmos-engine.run.ts && tsx tests/db-runtime/mongodb-engine.run.ts && tsx tests/db-runtime/dynamodb-engine.run.ts && tsx tests/db-runtime/mysql-integration.opt-in.run.ts && tsx tests/db-runtime/mongodb-integration.opt-in.run.ts && tsx tests/db-runtime/dynamodb-integration.opt-in.run.ts",
     "test:update": "tsx tests/golden/run.ts --update && tsx tests/audit/run.ts --update && tsx tests/ingest/run.ts --update",
     "prepublishOnly": "npm run build:dashboard && npm run build"
   },
@@ -39,8 +39,8 @@
     "@babel/types": "^7.28.5",
     "@cucumber/gherkin": "^37.0.0",
     "@cucumber/messages": "^31.0.0",
-    "@sungen/driver-data-factory": "3.2.16-beta.1",
-    "@sungen/driver-ui": "3.2.16-beta.1",
+    "@sungen/driver-data-factory": "3.2.16-beta.11",
+    "@sungen/driver-ui": "3.2.16-beta.11",
     "chalk": "^5.6.2",
     "commander": "^14.0.2",
     "dotenv": "^17.2.3",

package/src/cli/commands/audit.ts

@@ -78,7 +78,12 @@ function render(r: AuditReport): void {
   if (r.calibration) {
     const ax = Object.entries(r.calibration.axes).map(([k, v]) => `${k}=${(v * 100).toFixed(0)}%`).join(' · ');
     L(`  ⑨ Calibration — ${ax}`);
+    const na = r.calibration.notApplicable ?? [];
+    if (na.length) L(`      not scored (no evidence in this unit): ${na.join(', ')}`);
     L(`      weakest: ${r.calibration.weakest.axis} ${(r.calibration.weakest.value * 100).toFixed(0)}%${r.calibration.inflated ? '  ⚠ SCORE-INFLATED-BY-BREADTH' : ''}`);
+    if (r.calibration.cappedAt !== undefined) {
+      L(`      ⚠ score held at ${r.calibration.cappedAt.toFixed(1)} by the weakest axis — fix it to lift the number`);
+    }
     L('');
   }
   L('  ── Findings (Repair targets) ──');

package/src/cli/commands/delivery.ts

@@ -31,6 +31,7 @@ import {
   loadMatrixModel,
   approveMatrix,
   writeMatrixDeliverables,
+  MatrixFormat,
   hasErrors,
   hasReview,
 } from '../../exporters/matrix/export';
@@ -621,6 +622,7 @@ function matrixPathsFor(cwd: string, target: DeliveryTarget): MatrixTargetPaths
     featureFile: path.join(base, 'features', `${target.featureBaseName}.feature`),
     testDataFile: resolveTestDataPathForTarget(cwd, target),
     specFile: path.join(genBase, `${target.featureBaseName}.spec.ts`),
+    specMdFile: path.join(base, 'requirements', 'spec.md'),
     resultsPath: resolveResultsPath(cwd, target),
     mapFile: mapFilePath(base, target.featureBaseName),
   };
@@ -650,7 +652,7 @@ interface MatrixRunSummary {
 async function exportMatrixTarget(
   cwd: string,
   target: DeliveryTarget,
-  opts: { check?: boolean; preview?: boolean },
+  opts: { check?: boolean; preview?: boolean; format?: MatrixFormat },
 ): Promise<MatrixRunSummary | null> {
   const paths = matrixPathsFor(cwd, target);
   const { model, mapMissing, mapErrors } = loadMatrixModel(paths);
@@ -688,24 +690,38 @@ async function exportMatrixTarget(
     return null;
   }
 
-  const { csvPath, xlsxPath } = await writeMatrixDeliverables(paths, model);
+  const { csvPath, xlsxPath } = await writeMatrixDeliverables(paths, model, opts.format ?? 'xlsx');
   const passed = model.items.reduce((a, i) => a + i.resultCounts.passed, 0);
   const failed = model.items.reduce((a, i) => a + i.resultCounts.failed, 0);
-  log(`  ${COLOR.green}→ ${path.relative(cwd, xlsxPath)}${COLOR.reset} ${COLOR.gray}(+ ${path.relative(cwd, csvPath)})${COLOR.reset}`);
+  const written = [xlsxPath, csvPath].filter((p): p is string => !!p).map((p) => path.relative(cwd, p));
+  for (const rel of written) log(`  ${COLOR.green}→ ${rel}${COLOR.reset}`);
   return {
     label: paths.label,
     items: model.manifest.itemCount,
     variants: model.manifest.variantCount,
     passed,
     failed,
-    file: path.relative(cwd, xlsxPath),
+    file: written.join(' + '),
   };
 }
 
+/**
+ * One place that accounts for every target the run did NOT write, so a sweep is
+ * never silently partial: scaffolds skipped by preflight and units whose gates /
+ * missing map stopped the export.
+ */
+function printSkipSummary(skipped: string[], notExported: string[]): void {
+  if (skipped.length === 0 && notExported.length === 0) return;
+  log(`${COLOR.gray}Not exported (${skipped.length + notExported.length}):${COLOR.reset}`);
+  for (const s of skipped) log(`  ${COLOR.gray}· ${s}${COLOR.reset}`);
+  for (const n of notExported) log(`  ${COLOR.gray}· ${n} (see the message above)${COLOR.reset}`);
+  log('');
+}
+
 function printMatrixSummaryTable(summaries: MatrixRunSummary[]): void {
   log(`\n${COLOR.bold}Delivery matrix export complete${COLOR.reset}\n`);
   const colWidth = Math.max(20, ...summaries.map((s) => s.label.length)) + 1;
-  log(`  ${'Feature'.padEnd(colWidth)}Items  Variants  Passed  Failed  File`);
+  log(`  ${'Feature'.padEnd(colWidth)}Items  Variants  Passed  Failed  File(s)`);
   log('  ' + '-'.repeat(colWidth + 50));
   for (const s of summaries) {
     log(
@@ -795,9 +811,11 @@ export function registerDeliveryCommand(program: Command): void {
     .option('--check', 'Matrix gates only — validate the delivery map, write nothing')
     .option('--approve [ids]', 'Approve proposed groups (all, or a comma-separated id list) + stamp fingerprints')
     .option('--preview', 'Render the matrix despite review-required findings (DRAFT watermark)')
+    .option('--format <format>', 'Matrix output format: xlsx (default) | csv | both', 'xlsx')
     .action(async (names: string[], options: {
       skipPreflight?: boolean; continueOnMissing?: boolean; env?: string;
       legacy?: boolean; full?: boolean; check?: boolean; approve?: boolean | string; preview?: boolean;
+      format?: string;
     }) => {
       try {
         // Same effect as running with SUNGEN_ENV=<env> — result-file resolution,
@@ -805,11 +823,19 @@ export function registerDeliveryCommand(program: Command): void {
         if (options.env) process.env.SUNGEN_ENV = options.env;
         const cwd = process.cwd();
 
+        // Matrix output format — one artifact by default (xlsx); csv/both on request.
+        const format = (options.format ?? 'xlsx').toLowerCase();
+        if (!['xlsx', 'csv', 'both'].includes(format)) {
+          console.error(`${COLOR.red}Invalid --format "${options.format}"${COLOR.reset} — use xlsx | csv | both`);
+          process.exit(1);
+        }
+
         // 1. Scope detection — each positional name expands into one target
         //    per `.feature` file inside that screen/flow. Passing a specific
         //    feature basename (e.g. `home-modal`) narrows to that one file.
         let targets: DeliveryTarget[];
-        if (names && names.length > 0) {
+        const explicitScope = !!(names && names.length > 0);
+        if (explicitScope) {
           targets = names.flatMap((n) => resolveTargetsFromArg(cwd, n));
         } else {
           targets = listAllTargets(cwd);
@@ -822,8 +848,13 @@ export function registerDeliveryCommand(program: Command): void {
         const labels = targets.map((t) => t.isFlow ? `flow/${t.featureBaseName}` : t.featureBaseName);
         log(`${COLOR.bold}sungen delivery${COLOR.reset} — exporting ${targets.length} feature(s): ${labels.join(', ')}\n`);
 
-        // 2. Pre-flight
+        // 2. Pre-flight — strictness follows the SCOPE. Naming a unit means "I want
+        //    this one" (fail loudly); a no-argument sweep means "export everything
+        //    that is ready", so scaffolded units (added but not yet authored) are
+        //    skipped with a note instead of aborting the whole run — otherwise one
+        //    untouched scaffold in a work-in-progress project produces zero files.
         let toExport: DeliveryTarget[];
+        const skipped: string[] = [];
         if (options.skipPreflight) {
           toExport = targets;
         } else {
@@ -832,22 +863,22 @@ export function registerDeliveryCommand(program: Command): void {
 
           const blockers = checks.filter(hasBlockingMissing);
           if (blockers.length > 0) {
-            if (options.continueOnMissing) {
-              const passedScreens = new Set(
-                checks.filter((c) => !hasBlockingMissing(c)).map((c) => c.screen)
-              );
-              toExport = targets.filter((t) => {
-                const label = t.isFlow ? `flow/${t.featureBaseName}` : t.featureBaseName;
-                return passedScreens.has(label);
-              });
-              log(`${COLOR.yellow}Continuing with ${toExport.length} ready target(s).${COLOR.reset}\n`);
-            } else {
+            if (explicitScope && !options.continueOnMissing) {
               console.error(
-                `${COLOR.red}Aborted:${COLOR.reset} ${blockers.length} target(s) have blocking issues.\n` +
+                `${COLOR.red}Aborted:${COLOR.reset} ${blockers.length} named target(s) have blocking issues.\n` +
                 `Run the suggested commands above, or use ${COLOR.cyan}--continue-on-missing${COLOR.reset} to skip them.`
               );
               process.exit(1);
             }
+            const readyLabels = new Set(
+              checks.filter((c) => !hasBlockingMissing(c)).map((c) => c.screen)
+            );
+            toExport = targets.filter((t) => {
+              const label = t.isFlow ? `flow/${t.featureBaseName}` : t.featureBaseName;
+              return readyLabels.has(label);
+            });
+            for (const b of blockers) skipped.push(`${b.screen} (not authored yet — run /sungen:create-test)`);
+            log(`${COLOR.yellow}Skipping ${blockers.length} target(s) that have no test cases yet; continuing with ${toExport.length}.${COLOR.reset}\n`);
           } else {
             toExport = targets;
           }
@@ -883,14 +914,25 @@ export function registerDeliveryCommand(program: Command): void {
           }
 
           const matrixSummaries: MatrixRunSummary[] = [];
-          let failedTargets = 0;
+          const notExported: string[] = [];
           for (const target of toExport) {
-            const s = await exportMatrixTarget(cwd, target, { check: options.check, preview: options.preview });
+            const s = await exportMatrixTarget(cwd, target, {
+              check: options.check, preview: options.preview, format: format as MatrixFormat,
+            });
             if (s) matrixSummaries.push(s);
-            else failedTargets++;
+            else notExported.push(target.isFlow ? `flow/${target.featureBaseName}` : target.featureBaseName);
           }
           if (matrixSummaries.length > 0 && !options.check) printMatrixSummaryTable(matrixSummaries);
-          if (failedTargets > 0) process.exit(1);
+          printSkipSummary(skipped, notExported);
+          // A named target that produced nothing is a failure. A sweep is a failure
+          // only when it produced nothing at all — units still waiting for a map or
+          // an approval are the normal state of a live project. Preflight skips are
+          // not counted here: reaching this point in an explicit scope means
+          // --continue-on-missing was passed, which IS the opt-in to tolerate them.
+          const failed = explicitScope
+            ? notExported.length > 0
+            : matrixSummaries.length === 0;
+          if (failed) process.exit(1);
           return;
         }
 
@@ -903,6 +945,10 @@ export function registerDeliveryCommand(program: Command): void {
 
         // 4. Summary
         printSummaryTable(summaries);
+        printSkipSummary(skipped, []);
+        // Same rule as the matrix path: every attempted target in an explicit scope
+        // must have produced a file; a sweep only fails when nothing was written.
+        if (explicitScope ? summaries.length < toExport.length : summaries.length === 0) process.exit(1);
       } catch (err) {
         console.error(`${COLOR.red}Fatal:${COLOR.reset} ${err instanceof Error ? err.message : err}`);
         process.exit(1);

package/src/exporters/feature-parser.ts

@@ -172,12 +172,28 @@ export function extractAuthRole(tags: string[]): string | null {
 }
 
 /**
- * Extract VP ID and human-readable name from scenario name like
+ * The leading viewpoint/requirement id of a scenario title.
+ *
+ * The `VP-` prefix is the scheme sungen suggests, NOT a requirement: real projects
+ * bring their own (`SEC-123`, `PER-345`, `MS-HP-001`, `VP0-001`), and the harness
+ * has always been format-tolerant about it. The exporters were not — a project
+ * using `SEC-123` got no id at all, which made every scenario "unaddressable" and
+ * blocked the whole delivery matrix at Gate A.
+ *
+ * Shape: uppercase segments joined by `-`, ending in a number (with an optional
+ * letter or sub-code suffix). Requiring the trailing number is what keeps an
+ * ordinary title word ("A11y check…") from being mistaken for an id.
+ */
+export const SCENARIO_ID = /^([A-Z][A-Z0-9]*(?:-[A-Z0-9]+)*-\d+(?:[a-zA-Z]|-[A-Z0-9]+)?)/;
+
+/**
+ * Extract the id and the human-readable name from a scenario title:
  * "VP-UI-001 Modal displays all required fields" →
  *   { vpId: "VP-UI-001", category1: "Modal displays all required fields" }
+ * "SEC-123 Login is protected" → { vpId: "SEC-123", category1: "Login is protected" }
  */
 export function splitVpAndName(scenarioName: string): { vpId?: string; category1: string } {
-  const match = scenarioName.match(/^(VP-[A-Z][A-Z0-9]*-\d+(?:[a-zA-Z]|-[A-Z0-9]+)?)\s+(.+)$/);
+  const match = scenarioName.match(new RegExp(SCENARIO_ID.source + '\\s+(.+)$'));
   if (match) {
     return { vpId: match[1], category1: match[2] };
   }
@@ -194,6 +210,9 @@ export function splitVpAndName(scenarioName: string): { vpId?: string; category1
  */
 export function mapVpToCategory2(vpId: string | undefined, scenarioName?: string): string {
   if (!vpId) return 'Function';
+  // Compare on the category segment so a project scheme without the `VP-` prefix
+  // (`SEC-123`) classifies the same as `VP-SEC-001`.
+  vpId = /^VP-/.test(vpId) ? vpId : `VP-${vpId}`;
   if (vpId.startsWith('VP-SEC-')) {
     if (scenarioName && /xss|injection/i.test(scenarioName)) return 'Function';
     return 'Accessing';