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

package/src/exporters/matrix/gates.ts

@@ -31,9 +31,39 @@ export function runGates(ctx: GateContext): MatrixFinding[] {
   gateEDrift(ctx, findings);
   gateGReviewState(ctx, findings);
   gateWWording(ctx, findings);
+  gateKCategory(ctx, findings);
   return findings;
 }
 
+// --- Gate K — category vs the source viewpoint class -------------------------
+
+/** VP prefixes whose category is not a judgement call — the source decides it. */
+const VP_CATEGORY_RULE: Array<[string, string]> = [
+  ['SEC', 'security'],
+  ['NFR', 'nfr'],
+];
+
+/**
+ * A `VP-SEC-*` scenario filed under `normal`/`abnormal` empties the Coverage
+ * sheet's `security` column — the grid then reports a gap the unit does not
+ * have while hiding the security work it does have. Same for `VP-NFR-*`.
+ * (normal vs abnormal stays a judgement call and is never checked.)
+ */
+function gateKCategory(ctx: GateContext, findings: MatrixFinding[]): void {
+  for (const g of ctx.inputs.map.groups) {
+    const vs = g.variants.flatMap((ref) => expandMapRef(ref, ctx.variantsByVp));
+    for (const [prefix, expected] of VP_CATEGORY_RULE) {
+      const hits = vs.filter((v) => v.vpCategory === prefix);
+      if (hits.length > 0 && g.category !== expected) {
+        findings.push({
+          gate: 'K', severity: 'warning', ref: g.id,
+          message: `group ${g.id} is \`category: ${g.category}\` but ${hits.length}/${vs.length} of its variants are VP-${prefix}-* (${hits.slice(0, 3).map((v) => v.vpId).join(', ')}) — use \`category: ${expected}\` or the Coverage grid's ${expected} column stays empty`,
+        });
+      }
+    }
+  }
+}
+
 // --- Gate A — source quality ------------------------------------------------
 
 function gateASource(ctx: GateContext, findings: MatrixFinding[]): void {
@@ -320,7 +350,22 @@ const WORDING_SMELLS: Array<[RegExp, string]> = [
 
 function gateWWording(ctx: GateContext, findings: MatrixFinding[]): void {
   for (const g of ctx.inputs.map.groups) {
-    for (const [field, text] of [['intent', g.intent], ['oracle', g.oracle]] as const) {
+    const variantCount = g.variants.flatMap((ref) => expandMapRef(ref, ctx.variantsByVp)).length;
+    // Without a digest the parent row can only list variant refs — a reviewer
+    // then has to expand the item to learn which dimensions it covers.
+    if (variantCount > 3 && !g.dimensions) {
+      findings.push({
+        gate: 'W', severity: 'warning', ref: g.id,
+        message: `group ${g.id} has ${variantCount} variants and no \`dimensions:\` digest — add a short one (e.g. "required ×3 · format ×9") so the collapsed view stays informative`,
+      });
+    }
+    if (g.dimensions && g.dimensions.length > 120) {
+      findings.push({
+        gate: 'W', severity: 'warning', ref: g.id,
+        message: `group ${g.id} \`dimensions:\` is ${g.dimensions.length} chars — keep the digest short (≤120)`,
+      });
+    }
+    for (const [field, text] of ([['intent', g.intent], ['oracle', g.oracle], ...(g.dimensions ? [['dimensions', g.dimensions] as const] : [])] as const)) {
       for (const [re, what] of WORDING_SMELLS) {
         if (re.test(text)) {
           findings.push({

package/src/exporters/matrix/map-loader.ts

@@ -78,6 +78,7 @@ export function loadDeliveryMap(file: string): MapLoadResult {
         target: String(grp.target ?? ''),
         intent: String(grp.intent ?? ''),
         oracle: String(grp.oracle ?? ''),
+        ...(grp.dimensions !== undefined ? { dimensions: String(grp.dimensions) } : {}),
         category: grp.category as MapCategory,
         review,
         variants: Array.isArray(variants) ? variants.map(String) : [],
@@ -148,6 +149,7 @@ export function writeDeliveryMap(file: string, map: DeliveryMap): void {
       target: g.target,
       intent: g.intent,
       oracle: g.oracle,
+      ...(g.dimensions !== undefined ? { dimensions: g.dimensions } : {}),
       category: g.category,
       review: g.review,
       variants: g.variants,

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 {
@@ -166,7 +182,7 @@ export interface RequirementCoverage {
 // Gate findings
 // ---------------------------------------------------------------------------
 
-export type GateId = 'A' | 'B' | 'C' | 'D' | 'E' | 'G' | 'R' | 'W';
+export type GateId = 'A' | 'B' | 'C' | 'D' | 'E' | 'G' | 'K' | 'R' | 'W';
 export type FindingSeverity = 'error' | 'review' | 'warning';
 
 export interface MatrixFinding {

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

@@ -60,7 +60,8 @@ 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
 dispositions:                      # scenarios intentionally NOT delivered as test cases
@@ -89,11 +90,36 @@ determined** (its oracle *family*, not its exact message).
   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."
@@ -117,6 +143,13 @@ requirements:
   # 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

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

@@ -38,8 +38,11 @@ data · trigger · oracle all renderable; every `{{var}}` resolves; **no templat
 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) · R requirement coverage (spec FR/TR/NFR ids with
-no trace and no `requirements:` status → warning) · W wording lint (map intent/oracle containing
+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
@@ -63,12 +66,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