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

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

@@ -5,8 +5,8 @@
  * and result), so downstream pipelines can re-derive both views from one file.
  */
 
-import { statusToTestResult } from '../playwright-report-parser';
-import { itemModeLabel, itemResultLabel } from './render-xlsx';
+import { variantState } from './build';
+import { coverageSummary, itemModeLabel, itemResultLabel } from './render-xlsx';
 import { MatrixModel } from './types';
 
 const HEADERS = [
@@ -35,9 +35,6 @@ export function renderMatrixCsv(model: MatrixModel): string {
   lines.push(HEADERS.map(esc).join(','));
 
   for (const item of model.items) {
-    const triggerTexts = new Set(item.variants.map((v) => v.trigger.join('\n')));
-    const triggerIsCommon = triggerTexts.size === 1;
-    const commonPre = new Set(item.precondition);
     lines.push([
       'item',
       item.id,
@@ -46,9 +43,9 @@ export function renderMatrixCsv(model: MatrixModel): string {
       item.category,
       item.priority,
       item.precondition.join('\n'),
-      `${item.variants.length} variant(s): ${item.variants.map((v) => v.condition).join(' · ')}`,
-      // No placeholder text: when triggers differ the variant rows carry them (GAP-01).
-      triggerIsCommon ? item.variants[0].trigger.join('\n') : '',
+      coverageSummary(item),
+      // Shared leading steps only; each variant row carries its remaining steps.
+      item.trigger.join('\n'),
       item.oracle,
       itemModeLabel(item),
       item.traces.join(' '),
@@ -69,13 +66,14 @@ export function renderMatrixCsv(model: MatrixModel): string {
         v.condition,
         '', '',
         // Precondition DELTA — variant-specific setup only (review GAP-03).
-        v.precondition.filter((line) => !commonPre.has(line)).join('\n'),
+        (item.preconditionDeltas[v.ref] ?? []).join('\n'),
         v.data.join('\n'),
-        triggerIsCommon ? '' : v.trigger.join('\n'),
+        // Steps after the parent's shared prefix only.
+        (item.triggerDeltas[v.ref] ?? []).join('\n'),
         expected,
         v.mode === 'manual' ? 'Manual' : 'Auto',
         v.traces.join(' '),
-        v.result ? statusToTestResult(v.result.status) : 'Pending',
+        variantState(v),
         isoDate(v.result?.startTime),
         v.result?.error ? String(v.result.error).slice(0, 200) : '',
         '',

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

@@ -27,8 +27,8 @@ import {
   BLACK,
   LAVENDER,
 } from '../xlsx-report-builder';
-import { statusToTestResult } from '../playwright-report-parser';
-import { CoverageVariant, DeliveryItem, ItemResult, MatrixModel, MapCategory } from './types';
+import { variantState } from './build';
+import { DeliveryItem, MatrixModel, MapCategory } from './types';
 
 const CATEGORY_ORDER: MapCategory[] = ['normal', 'abnormal', 'security', 'nfr'];
 const SOFT_BLUE = { argb: 'FFDCE6F1' };
@@ -63,22 +63,21 @@ export function itemModeLabel(item: DeliveryItem): string {
   return item.mode === 'manual' ? 'Manual' : 'Auto';
 }
 
+/**
+ * Parent roll-up label. It must NEVER be exactly one of the variant state words
+ * (`Passed`/`Failed`/`Blocked`/`Pending`/`N/A`) — the summary band counts the
+ * Result column with exact-match COUNTIF over parent AND child rows, so a parent
+ * reading plain "Pending" was counted as an extra pending variant (109 instead
+ * of 77 on st-login).
+ */
 export function itemResultLabel(item: DeliveryItem): string {
-  const { passed, failed, blocked, notRun } = item.resultCounts;
-  const total = item.variants.length;
-  const map: Record<ItemResult, string> = {
-    passed: `${passed}/${total} Passed`,
-    failed: `${passed}/${total} Passed · ${failed} Failed`,
-    blocked: `${blocked} Blocked`,
-    partial: `${passed}/${total} Passed · ${notRun} not run`,
-    not_run: 'Pending',
-  };
-  return map[item.result];
-}
-
-function variantResultLabel(v: CoverageVariant): string {
-  if (!v.result) return 'Pending';
-  return statusToTestResult(v.result.status);
+  const { passed, failed, blocked, na } = item.resultCounts;
+  const eff = item.variants.length - na;
+  const suffix = na > 0 ? ` · ${na} N/A` : '';
+  if (item.result === 'na') return 'All N/A';
+  if (item.result === 'failed') return `${passed}/${eff} Passed · ${failed} Failed${suffix}`;
+  if (item.result === 'blocked') return `${passed}/${eff} Passed · ${blocked} Blocked${suffix}`;
+  return `${passed}/${eff} Passed${suffix}`;
 }
 
 /** ISO date (2026-08-04) — unambiguous across locales (review §9). */
@@ -89,10 +88,24 @@ function isoDate(startTime: string | undefined): string {
   return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
 }
 
-function numbered(lines: string[]): string {
+function numbered(lines: string[], start = 1): string {
   if (lines.length === 0) return '';
-  if (lines.length === 1) return lines[0];
-  return lines.map((l, i) => `${i + 1}. ${l}`).join('\n');
+  if (lines.length === 1 && start === 1) return lines[0];
+  return lines.map((l, i) => `${start + i}. ${l}`).join('\n');
+}
+
+/**
+ * Compact coverage summary for the parent row. A declared `dimensions:` digest
+ * wins ("15 variants — required ×3 · format ×9 …"); otherwise a single variant
+ * shows its condition and a group falls back to its variant REFS. Concatenating
+ * every variant's full title turned this cell into an 800-character paragraph.
+ */
+export function coverageSummary(item: DeliveryItem): string {
+  const n = item.variants.length;
+  const head = `${n} variant${n === 1 ? '' : 's'}:`;
+  if (item.dimensions) return `${head} ${item.dimensions}`;
+  if (n === 1) return `${head} ${item.variants[0].condition}`;
+  return `${head} ${item.variants.map((v) => v.ref).join(' · ')}`;
 }
 
 /** Expected cell = observable outcomes; the HOW moves under a separate heading. */
@@ -154,11 +167,16 @@ function addMatrixSheet(wb: ExcelJS.Workbook, model: MatrixModel, sungenVersion?
   // 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);
+  // exact state words and parent cells NEVER do (itemResultLabel + the roll-up
+  // formula always compose a "n/m Passed …" label), so exact-match COUNTIF over
+  // the whole column counts variants only.
+  const sum = (k: 'passed' | 'failed' | 'blocked' | 'notRun' | 'na'): number =>
+    model.items.reduce((a, i) => a + i.resultCounts[k], 0);
+  const passed = sum('passed');
+  const failed = sum('failed');
+  const blocked = sum('blocked');
+  const notRun = sum('notRun');
+  const na = sum('na');
   const RANGE = 'M9:M10000';
   const band = ws.getRow(6);
   const bandCells: Array<[string, ExcelJS.CellValue]> = [
@@ -166,9 +184,9 @@ function addMatrixSheet(wb: ExcelJS.Workbook, model: MatrixModel, sungenVersion?
     ['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],
+    ['blocked', { formula: `"Blocked: "&COUNTIF(${RANGE},"Blocked")`, result: `Blocked: ${blocked}` } 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],
+    ['na', { formula: `"N/A: "&COUNTIF(${RANGE},"N/A")`, result: `N/A: ${na}` } as ExcelJS.CellValue],
   ];
   bandCells.forEach(([, v], i) => {
     const c = band.getCell(2 + i);
@@ -192,25 +210,23 @@ function addMatrixSheet(wb: ExcelJS.Workbook, model: MatrixModel, sungenVersion?
     // 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(item.preconditionDeltas[v.ref] ?? []),
         numbered(v.data),
-        triggerIsCommon ? '' : numbered(v.trigger),
+        // Only the steps after the parent's shared prefix, numbered so the
+        // parent's steps + these read as one continuous procedure.
+        numbered(item.triggerDeltas[v.ref] ?? [], item.trigger.length + 1),
         expectedWithVerification(v.oracle, v.verification),
         v.mode === 'manual' ? `Manual${v.manualReason ? ` (${v.manualReason})` : ''}` : 'Auto',
         v.traces.join(', '),
-        variantResultLabel(v),
+        variantState(v),
         isoDate(v.result?.startTime),
         '',
         v.result?.error ? String(v.result.error).slice(0, 200) : '',
@@ -227,8 +243,7 @@ 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 commonTrigger = triggerIsCommon ? item.variants[0].trigger : null;
-    const coverage = `${item.variants.length} variant(s): ${item.variants.map((v) => v.condition).join(' · ')}`;
+    const coverage = coverageSummary(item);
 
     // Live roll-up derived from the child Result cells — precedence
     // failed → blocked → pending → partial → passed. N/A variants leave the
@@ -236,12 +251,13 @@ function addMatrixSheet(wb: ExcelJS.Workbook, model: MatrixModel, sungenVersion?
     const rng = `M${firstChild}:M${lastChild}`;
     const n = item.variants.length;
     const EFF = `(${n}-COUNTIF(${rng},"N/A"))`;
+    const NA = `IF(COUNTIF(${rng},"N/A")>0," · "&COUNTIF(${rng},"N/A")&" N/A","")`;
+    // Mirrors itemResultLabel exactly — and never yields a bare state word.
     const rollUpFormula =
-      `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")))))`;
+      `IF(COUNTIF(${rng},"Failed")>0,COUNTIF(${rng},"Passed")&"/"&${EFF}&" Passed · "&COUNTIF(${rng},"Failed")&" Failed"&${NA},` +
+      `IF(COUNTIF(${rng},"Blocked")>0,COUNTIF(${rng},"Passed")&"/"&${EFF}&" Passed · "&COUNTIF(${rng},"Blocked")&" Blocked"&${NA},` +
+      `IF(${EFF}=0,"All N/A",` +
+      `COUNTIF(${rng},"Passed")&"/"&${EFF}&" Passed"&${NA})))`;
 
     const values: ExcelJS.CellValue[] = [
       item.id,
@@ -251,8 +267,8 @@ function addMatrixSheet(wb: ExcelJS.Workbook, model: MatrixModel, sungenVersion?
       item.priority,
       numbered(item.precondition),
       coverage,
-      // No placeholder text: when triggers differ the sub-rows carry them (GAP-01).
-      commonTrigger ? numbered(commonTrigger) : '',
+      // The shared leading steps; each variant's remaining steps sit on its sub-row.
+      numbered(item.trigger),
       item.oracle,
       itemModeLabel(item),
       item.traces.join(', '),

package/src/exporters/matrix/types.ts

@@ -29,6 +29,10 @@ export interface MapGroup {
   oracle: string;
   category: MapCategory;
   review: ReviewState;
+  /** Optional short digest of the coverage dimensions this item varies over
+   *  (e.g. "required ×3 · format ×9 · full-width ×2"). Rendered on the parent row
+   *  instead of concatenating every variant's title — the compact review view. */
+  dimensions?: string;
   /** Variant refs: `VP-ID` (all @cases rows when the scenario has a dataset) or `VP-ID#label`. */
   variants: string[];
 }
@@ -118,7 +122,11 @@ export interface CoverageVariant {
   result?: PlaywrightResult;
 }
 
-export type ItemResult = 'passed' | 'failed' | 'blocked' | 'partial' | 'not_run';
+export type ItemResult = 'passed' | 'failed' | 'blocked' | 'partial' | 'not_run' | 'na';
+
+/** The exact word rendered in a variant's Result cell — the single vocabulary the
+ *  parent's roll-up formula counts (COUNTIF is exact-match). */
+export type VariantState = 'Passed' | 'Failed' | 'Blocked' | 'Pending' | 'N/A';
 
 /** One summarized row in the matrix — a group of variants sharing the signature. */
 export interface DeliveryItem {
@@ -126,6 +134,8 @@ export interface DeliveryItem {
   target: string;
   intent: string;
   oracle: string;
+  /** Short coverage-dimension digest from the map (compact parent view). */
+  dimensions?: string;
   category: MapCategory;
   review: ReviewState;
   /** Highest priority among the variants (per-variant priorities stay on the sub-rows). */
@@ -136,13 +146,19 @@ export interface DeliveryItem {
   layers: MatrixLayer[];
   /** Union of variant traces (exact per-variant traces stay on the variants). */
   traces: string[];
+  /** Preconditions shared by EVERY variant (the intersection) — written once here. */
   precondition: string[];
-  /** Common trigger when all variants share one shape, else '(per variant)'. */
+  /** Leading trigger steps shared by every variant — written once here; each
+   *  variant renders only its remaining steps (`triggerDeltas`). */
   trigger: string[];
   variants: CoverageVariant[];
+  /** variant ref → its precondition lines that are not on the parent. */
+  preconditionDeltas: Record<string, string[]>;
+  /** variant ref → its trigger steps after the shared prefix. */
+  triggerDeltas: Record<string, string[]>;
   /** Derived roll-up — never entered independently (Gate F). */
   result: ItemResult;
-  resultCounts: { passed: number; failed: number; blocked: number; notRun: number };
+  resultCounts: { passed: number; failed: number; blocked: number; notRun: number; na: number };
 }
 
 export interface MatrixDisposition {

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

@@ -60,6 +60,7 @@ 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>
+    dimensions: violated rule — required ×3 · format ×10 · full-width ×2   # see below
     category: normal | abnormal | security | nfr
     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
@@ -94,6 +95,17 @@ determined** (its oracle *family*, not its exact message).
   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.
+
 **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."

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

@@ -63,12 +63,18 @@ result/evidence entry). Sub-rows are **delta-only**: knowledge common to the who
 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.
+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