@sun-asterisk/sungen 3.2.16-beta.2 → 3.2.16-beta.4

package/src/exporters/matrix/render-xlsx.ts

@@ -54,6 +54,15 @@ function dataCell(c: ExcelJS.Cell, value: ExcelJS.CellValue, opts?: { bold?: boo
   if (opts?.fill) c.fill = { type: 'pattern', pattern: 'solid', fgColor: opts.fill };
 }
 
+/** Mode is a coverage dimension: mixed items show both counts. */
+export function itemModeLabel(item: DeliveryItem): string {
+  if (item.mode === 'mixed') {
+    const auto = item.variants.filter((v) => v.mode === 'auto').length;
+    return `Auto ${auto} · Manual ${item.variants.length - auto}`;
+  }
+  return item.mode === 'manual' ? 'Manual' : 'Auto';
+}
+
 export function itemResultLabel(item: DeliveryItem): string {
   const { passed, failed, blocked, notRun } = item.resultCounts;
   const total = item.variants.length;
@@ -111,7 +120,7 @@ function draftBanner(ws: ExcelJS.Worksheet, model: MatrixModel): void {
 const MATRIX_HEADERS = [
   'ID', 'Target', 'Test Intent / Condition', 'Category', 'Priority', 'Precondition',
   'Coverage / Test Data', 'Action / Trigger', 'Expected Result', 'Mode', 'Trace',
-  'Result', 'Executed Date', 'Executor', 'Note\n(Evidence, DefectID)',
+  'Result', 'Executed Date', 'Executor', 'Note / Evidence', 'Defect ID',
 ];
 const RESULT_COL = 13; // column M
 
@@ -135,25 +144,35 @@ function addMatrixSheet(wb: ExcelJS.Workbook, model: MatrixModel, sungenVersion?
     { width: 22 }, // M Result
     { width: 12 }, // N Executed
     { width: 13 }, // O Executor
-    { width: 24 }, // P Note
+    { width: 22 }, // P Note / Evidence
+    { width: 12 }, // Q Defect ID
   ];
 
   renderReportHeaderBand(wb, ws, `${model.unit.toUpperCase()} TEST CASE & COVERAGE MATRIX`, sungenVersion, model.formNo);
   draftBanner(ws, model);
 
-  // Summary band (row 6) — items vs variants stay separate metrics by design (I8):
-  // the ITEM count is reviewer workload, the VARIANT count is execution workload.
+  // Summary band (row 6) — items vs variants stay separate metrics by design (I8).
+  // The execution counters are LIVE formulas over the variant Result cells, so
+  // hand-entered results update the totals (review GAP-06). Variant cells hold the
+  // exact state words; parent cells hold composed labels — exact-match COUNTIF
+  // therefore counts variants only.
   const passed = model.items.reduce((a, i) => a + i.resultCounts.passed, 0);
   const failed = model.items.reduce((a, i) => a + i.resultCounts.failed, 0);
   const notRun = model.items.reduce((a, i) => a + i.resultCounts.notRun + i.resultCounts.blocked, 0);
+  const RANGE = 'M9:M10000';
   const band = ws.getRow(6);
-  [
-    `Delivery items: ${model.manifest.itemCount}`,
-    `Coverage variants: ${model.manifest.variantCount}`,
-    `Passed: ${passed}`, `Failed: ${failed}`, `Pending: ${notRun}`,
-  ].forEach((label, i) => {
+  const bandCells: Array<[string, ExcelJS.CellValue]> = [
+    ['items', `Delivery items: ${model.manifest.itemCount}`],
+    ['variants', `Coverage variants: ${model.manifest.variantCount}`],
+    ['passed', { formula: `"Passed: "&COUNTIF(${RANGE},"Passed")`, result: `Passed: ${passed}` } as ExcelJS.CellValue],
+    ['failed', { formula: `"Failed: "&COUNTIF(${RANGE},"Failed")`, result: `Failed: ${failed}` } as ExcelJS.CellValue],
+    ['blocked', { formula: `"Blocked: "&COUNTIF(${RANGE},"Blocked")`, result: 'Blocked: 0' } as ExcelJS.CellValue],
+    ['pending', { formula: `"Pending: "&COUNTIF(${RANGE},"Pending")`, result: `Pending: ${notRun}` } as ExcelJS.CellValue],
+    ['na', { formula: `"N/A: "&COUNTIF(${RANGE},"N/A")`, result: 'N/A: 0' } as ExcelJS.CellValue],
+  ];
+  bandCells.forEach(([, v], i) => {
     const c = band.getCell(2 + i);
-    dataCell(c, label, { bold: true, fill: SOFT_BLUE, center: true });
+    dataCell(c, v, { bold: true, fill: SOFT_BLUE, center: true });
   });
 
   const HEADER_ROW = 8;
@@ -169,16 +188,25 @@ function addMatrixSheet(wb: ExcelJS.Workbook, model: MatrixModel, sungenVersion?
     // Every item gets sub-rows — the sub-row is where the source scenario id, the
     // resolved data, and the manual result/evidence entry live (review B-05).
     const firstChild = rowIdx;
+    // Delta-only sub-rows (review GAP-01): content identical across the whole
+    // item lives ONCE on the parent — a child repeats only what distinguishes it.
+    // The child's Expected Result is always kept: it is the precise source
+    // oracle (the semantic anchor), not a repetition of the parent's summary.
+    const commonPre = new Set(item.precondition);
+    const triggerTextsAll = new Set(item.variants.map((v) => v.trigger.join('\n')));
+    const triggerIsCommon = triggerTextsAll.size === 1;
     for (const v of item.variants) {
       const vr = ws.getRow(rowIdx++);
       vr.outlineLevel = 1;
+      const preDelta = v.precondition.filter((line) => !commonPre.has(line));
       const vValues: ExcelJS.CellValue[] = [
         v.ref,
         '',
         v.condition,
-        '', '', '',
+        '', '',
+        numbered(preDelta),
         numbered(v.data),
-        numbered(v.trigger),
+        triggerIsCommon ? '' : numbered(v.trigger),
         expectedWithVerification(v.oracle, v.verification),
         v.mode === 'manual' ? `Manual${v.manualReason ? ` (${v.manualReason})` : ''}` : 'Auto',
         v.traces.join(', '),
@@ -186,6 +214,7 @@ function addMatrixSheet(wb: ExcelJS.Workbook, model: MatrixModel, sungenVersion?
         isoDate(v.result?.startTime),
         '',
         v.result?.error ? String(v.result.error).slice(0, 200) : '',
+        '',
       ];
       vValues.forEach((val, i) => dataCell(vr.getCell(2 + i), val, { center: i === 9 }));
       // Manual-execution entry: constrain the Result cell to the known states.
@@ -198,19 +227,21 @@ function addMatrixSheet(wb: ExcelJS.Workbook, model: MatrixModel, sungenVersion?
     // --- Parent row: only values that are genuinely COMMON to the whole item
     // (review M-04); everything variant-specific stays on the sub-rows.
     const pr = ws.getRow(parentRowIdx);
-    const triggerTexts = new Set(item.variants.map((v) => v.trigger.join('\n')));
-    const commonTrigger = triggerTexts.size === 1 ? item.variants[0].trigger : null;
+    const commonTrigger = triggerIsCommon ? item.variants[0].trigger : null;
     const coverage = `${item.variants.length} variant(s): ${item.variants.map((v) => v.condition).join(' · ')}`;
 
-    // Live roll-up: derived from the child Result cells so hand-entered results
-    // recompute the parent — precedence failed → blocked → pending → partial → passed.
+    // Live roll-up derived from the child Result cells — precedence
+    // failed → blocked → pending → partial → passed. N/A variants leave the
+    // denominator (review GAP-06): eff = n − COUNTIF(N/A); all-N/A → "N/A".
     const rng = `M${firstChild}:M${lastChild}`;
     const n = item.variants.length;
+    const EFF = `(${n}-COUNTIF(${rng},"N/A"))`;
     const rollUpFormula =
-      `IF(COUNTIF(${rng},"Failed")>0,COUNTIF(${rng},"Passed")&"/${n} Passed · "&COUNTIF(${rng},"Failed")&" Failed",` +
-      `IF(COUNTIF(${rng},"Blocked")>0,"Blocked",` +
-      `IF(COUNTIF(${rng},"Passed")=${n},"${n}/${n} Passed",` +
-      `IF(COUNTIF(${rng},"Passed")=0,"Pending",COUNTIF(${rng},"Passed")&"/${n} Passed · pending"))))`;
+      `IF(COUNTIF(${rng},"Failed")>0,COUNTIF(${rng},"Passed")&"/"&${EFF}&" Passed · "&COUNTIF(${rng},"Failed")&" Failed",` +
+      `IF(COUNTIF(${rng},"Blocked")>0,COUNTIF(${rng},"Passed")&"/"&${EFF}&" Passed · "&COUNTIF(${rng},"Blocked")&" Blocked",` +
+      `IF(${EFF}=0,"N/A",` +
+      `IF(COUNTIF(${rng},"Passed")=${EFF},${EFF}&"/"&${EFF}&" Passed",` +
+      `IF(COUNTIF(${rng},"Passed")=0,"Pending",COUNTIF(${rng},"Passed")&"/"&${EFF}&" Passed · pending")))))`;
 
     const values: ExcelJS.CellValue[] = [
       item.id,
@@ -220,14 +251,16 @@ function addMatrixSheet(wb: ExcelJS.Workbook, model: MatrixModel, sungenVersion?
       item.priority,
       numbered(item.precondition),
       coverage,
-      commonTrigger ? numbered(commonTrigger) : '(differs per variant — see sub-rows)',
+      // No placeholder text: when triggers differ the sub-rows carry them (GAP-01).
+      commonTrigger ? numbered(commonTrigger) : '',
       item.oracle,
-      item.mode === 'manual' ? 'Manual' : 'Auto',
+      itemModeLabel(item),
       item.traces.join(', '),
       { formula: rollUpFormula, result: itemResultLabel(item) } as ExcelJS.CellValue,
       '',
       '',
       item.review === 'proposed' ? 'REVIEW REQUIRED' : '',
+      '',
     ];
     values.forEach((v, i) => dataCell(pr.getCell(2 + i), v, {
       bold: true,
@@ -237,9 +270,18 @@ function addMatrixSheet(wb: ExcelJS.Workbook, model: MatrixModel, sungenVersion?
     }));
   }
 
-  ws.autoFilter = { from: { row: HEADER_ROW, column: 2 }, to: { row: rowIdx - 1, column: 16 } };
+  ws.autoFilter = { from: { row: HEADER_ROW, column: 2 }, to: { row: rowIdx - 1, column: 17 } };
   // Freeze the header band AND the ID + Target columns (review §9).
   ws.views = [{ state: 'frozen', xSplit: 3, ySplit: HEADER_ROW }];
+  // Print: landscape, fit width only (never squash all rows into one page),
+  // repeat the masthead + header rows on every page (review GAP-08).
+  ws.pageSetup = {
+    orientation: 'landscape',
+    fitToPage: true,
+    fitToWidth: 1,
+    fitToHeight: 0,
+    printTitlesRow: '1:8',
+  };
 }
 
 // ---------------------------------------------------------------------------
@@ -261,8 +303,14 @@ function addCoverageSheet(wb: ExcelJS.Workbook, model: MatrixModel, sungenVersio
   if (model.requirements.length > 0) {
     dataCell(ws.getRow(rowIdx).getCell(2), 'Requirement coverage — every id has an explicit status', { bold: true });
     rowIdx += 1;
-    const rh = ws.getRow(rowIdx++);
-    ['Requirement', 'Status', 'Delivery items', 'Variants', 'Note'].forEach((l, i) => headerCell(rh.getCell(2 + i), l));
+    const rh = ws.getRow(rowIdx);
+    ws.mergeCells(rowIdx, 4, rowIdx, 6);
+    headerCell(rh.getCell(2), 'Requirement');
+    headerCell(rh.getCell(3), 'Status');
+    headerCell(rh.getCell(4), 'Delivery items');
+    headerCell(rh.getCell(7), 'Variants');
+    headerCell(rh.getCell(8), 'Note');
+    rowIdx += 1;
     for (const r of model.requirements) {
       const row = ws.getRow(rowIdx++);
       dataCell(row.getCell(2), r.id, { bold: true });

package/src/exporters/matrix/types.ts

@@ -57,7 +57,9 @@ export interface DeliveryMap {
   /** Requirement-id → reviewed status override (partially_covered / not_applicable / …).
    *  Without an override a requirement is `covered` when a variant traces to it, else `gap`. */
   requirements: Record<string, RequirementOverride>;
-  /** VP-id → scenario fingerprint stamped at approval time (drift detector input). */
+  /** VP-id → scenario fingerprint stamped at approval time (drift detector input).
+   *  The reserved key `__map__` holds the fingerprint of the map's own semantic
+   *  content (groups + dispositions) so edited wording re-opens review (GAP-09). */
   fingerprints: Record<string, string>;
 }
 
@@ -126,8 +128,11 @@ export interface DeliveryItem {
   oracle: string;
   category: MapCategory;
   review: ReviewState;
+  /** Highest priority among the variants (per-variant priorities stay on the sub-rows). */
   priority: string;
-  mode: 'auto' | 'manual';
+  /** Execution mode is a coverage dimension, not a split — 'mixed' when auto and
+   *  manual variants share one intent (e.g. account states needing seeded data). */
+  mode: 'auto' | 'manual' | 'mixed';
   layers: MatrixLayer[];
   /** Union of variant traces (exact per-variant traces stay on the variants). */
   traces: string[];
@@ -198,5 +203,5 @@ export interface MatrixModel {
   manifest: MatrixManifest;
 }
 
-/** Complexity warning threshold (rules draft Gate I) — echoed in the manifest. */
-export const MAX_VARIANTS_PER_ITEM = 12;
+/** Complexity warning threshold (rules draft Gate I; raised for compact grouping) — echoed in the manifest. */
+export const MAX_VARIANTS_PER_ITEM = 20;

package/src/exporters/matrix/wording.ts

@@ -19,10 +19,13 @@ function deRef(text: string): string {
 }
 
 function sentence(text: string): string {
-  let s = text.trim().replace(/\s+/g, ' ');
+  // Trim the ENDS only — internal whitespace may be the test data itself
+  // (a padded email, a spaces-only value); collapsing it would silently
+  // change what the tester types (review GAP-04).
+  let s = text.trim();
   if (!s) return s;
   s = s.charAt(0).toUpperCase() + s.slice(1);
-  if (!/[.!?…]$/.test(s)) s += '.';
+  if (!/[.!?…"]$/.test(s)) s += '.';
   return s;
 }
 
@@ -42,7 +45,7 @@ export function renderAction(raw: string): string {
     // click [X] <type>
     [/^clicks? \[([^\]]+)\]\s*(\w+)?$/i, (m) => `Click the ${m[1]}${m[2] ? ` ${m[2]}` : ''}`],
     // press <Key> at/in [X] field
-    [/^press(?:es)? (.+?) (?:at|in|inside) \[([^\]]+)\](?: field)?$/i, (m) => `Press ${m[1]} in the ${m[2]} field`],
+    [/^press(?:es)? (.+?) (?:at|in|on|inside) \[([^\]]+)\](?: field)?$/i, (m) => `Press ${m[1]} in the ${m[2]} field`],
     [/^press(?:es)? (.+)$/i, (m) => `Press ${m[1]}`],
     // select V in/from [X] dropdown
     [/^selects? (.+?) (?:in|from) \[([^\]]+)\]\s*(\w+)?$/i, (m) => `Select ${m[1]} in the ${m[2]}${m[3] ? ` ${m[3]}` : ''}`],
@@ -103,9 +106,23 @@ export function renderPrecondition(raw: string): string {
   const s = raw.trim().replace(/^(User|The user)\s+/i, '');
   const m = s.match(/^is on \[([^\]]+)\] page(.*)$/i);
   if (m) return sentence(`The user is on the ${m[1]} page${m[2] ?? ''}`);
+  // "wait for [X] <type> (is) visible" is a STATE once established, not an action.
+  const w = s.match(/^waits? for \[([^\]]+)\]\s*(\w+)?(?: is)?(?: visible)?$/i);
+  if (w) return sentence(`The ${w[1]}${w[2] ? ` ${w[2]}` : ''} is visible`);
+  const auth = s.match(/^is (signed|logged) (in|out)(.*)$/i);
+  if (auth) return sentence(`The user is ${auth[1]} ${auth[2]}${auth[3] ?? ''}`);
   return sentence(deRef(`The user ${s.charAt(0).toLowerCase()}${s.slice(1)}`));
 }
 
+/**
+ * A manual `Setup:` line is an INSTRUCTION the tester performs to establish the
+ * state — imperative reads correctly ("Seed the locked account."), while
+ * "The user seed …" is broken grammar (review GAP-08).
+ */
+export function renderSetupInstruction(raw: string): string {
+  return renderAction(raw);
+}
+
 // ---------------------------------------------------------------------------
 // Manual `# Tester verifies:` comment classification (structured, label-free)
 // ---------------------------------------------------------------------------

package/src/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]"
@@ -27,6 +27,8 @@ review → approve → official render.
 
 Parse from `$ARGUMENTS`:
 - **names** — zero or more screen/flow/api names. Empty → all targets.
+- **`--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,8 +39,8 @@ 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.
@@ -66,18 +68,28 @@ dispositions:                      # scenarios intentionally NOT delivered as te
   # 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. **Different risk classes never merge** — XSS and SQL injection are
-  separate items even though both are "injection on the same field" (different risk, action,
-  and oracle family); a component's visibility rule and its action/revalidation rule are two
-  intents, not one.
+**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.
+- 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`.
@@ -141,6 +153,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**
 
@@ -158,7 +171,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)
@@ -166,5 +180,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/src/orchestrator/templates/ai-src/skills/sungen-delivery/SKILL.md

@@ -29,12 +29,15 @@ 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+
+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
-(fingerprint mismatch → back to review) · G review state (proposed groups block the official
+(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) · R requirement coverage (spec FR/TR/NFR ids with
 no trace and no `requirements:` status → warning) · W wording lint (map intent/oracle containing
 tokens, `[Selector]` refs, DSL phrasing, or generator labels → warning).
@@ -49,17 +52,33 @@ Precondition, `Action:` → Action, `Observable:` → Expected Result, `Oracle:`
 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.
+
 **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). Collapse outline for the customer view, expand to execute. Variant Result
-cells have a dropdown (Passed/Failed/Blocked/Pending/N/A) and the parent Result is a **live Excel
-formula** over its children (failed→blocked→pending→partial→passed, e.g. `2/3 Passed · 1 Failed`)
-— a parent can never contradict its variants, even after manual edits. ID + Target columns are
-frozen; dates are ISO (`2026-08-04`). `Coverage` sheet — requirement coverage table (every FR/TR/
-NFR id with an explicit status), target × category grid with explicit `—` gaps, dispositions,
-manifest. CSV is flat with a `Level` column (`item`/`variant`) + a requirement-coverage appendix.
+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' — variant-specific setup stays on
+the variant, so no variant inherits a wrong start state. Variant Result cells have a dropdown
+(Passed/Failed/Blocked/Pending/N/A) and the parent Result is a **live Excel formula** over its
+children (failed→blocked→pending→partial→passed; **`N/A` leaves the denominator**, all-`N/A` →
+`N/A`). The summary band counts results with live formulas too. 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.
 
+**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`),