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

package/src/exporters/matrix/gates.ts

@@ -12,6 +12,7 @@
  */
 
 import { splitVpAndName, extractTestcaseType } from '../feature-parser';
+import { mapContentFingerprint } from './fingerprint';
 import { CoverageVariant, MatrixFinding, MAX_VARIANTS_PER_ITEM } from './types';
 import { expandMapRef, BuildInputs } from './build';
 
@@ -29,9 +30,44 @@ export function runGates(ctx: GateContext): MatrixFinding[] {
   gateDExecutability(ctx, findings);
   gateEDrift(ctx, findings);
   gateGReviewState(ctx, findings);
+  gateWWording(ctx, findings);
+  gateKCategory(ctx, findings);
   return findings;
 }
 
+// --- Gate K — category vs the source viewpoint class -------------------------
+
+/**
+ * Viewpoint classes whose delivery category is not a judgement call — the source
+ * decides it. Matched on the id's category segment, so a project scheme without
+ * the `VP-` prefix (`SEC-123`, `PER-345`) classifies the same as `VP-SEC-001`.
+ */
+const VP_CATEGORY_RULE: Array<[RegExp, string, string]> = [
+  [/^(SEC|SECURITY)$/i, 'security', 'SEC'],
+  [/^(NFR|PERF|PER|PERFORMANCE|A11Y|ACCESSIBILITY)$/i, 'nfr', 'NFR/PERF/A11Y'],
+];
+
+/**
+ * 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 [re, expected, label] of VP_CATEGORY_RULE) {
+      const hits = vs.filter((v) => re.test(v.vpCategory));
+      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 ${label} scenarios (${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 {
@@ -155,10 +191,11 @@ function gateCAggregation(ctx: GateContext, findings: MatrixFinding[]): void {
     const heuristicsConfirmed = g.review === 'approved' && !stale;
 
     // Hard signature parts — recomputed, never trusted from the map. ERROR on mismatch.
+    // Execution mode and priority are deliberately NOT here: they are coverage
+    // dimensions (account states may need seeded manual variants next to auto ones;
+    // an item takes the highest variant priority) — shown per variant, never split on.
     const hard: Array<[string, (v: CoverageVariant) => string]> = [
-      ['execution mode', (v) => v.mode],
       ['test layer', (v) => [...v.layers].sort().join('+')],
-      ['priority', (v) => v.priority],
     ];
     for (const [label, keyOf] of hard) {
       const distinct = new Set(vs.map(keyOf));
@@ -231,9 +268,14 @@ function gateDExecutability(ctx: GateContext, findings: MatrixFinding[]): void {
   for (const [vpId, vs] of variantsByVp) {
     const scenario = ctx.inputs.merged.find((m) => splitVpAndName(m.feature.name).vpId === vpId);
     if (!scenario) continue;
+    // Values produced during the run (`remember … as {{v}}`, capability bindings)
+    // are provided by the test itself — demanding a test-data entry for them
+    // blocked 14 scenarios of a real suite that compiles and runs fine.
+    const runtime = new Set(vs.flatMap((v) => v.runtimeVars));
     for (const varName of scenario.feature.referencedVars) {
       const inRows = vs.some((v) => v.caseLabel !== undefined); // dataset rows carry their own columns
-      if (!inRows && (!testData || !(varName in testData))) {
+      const atRuntime = runtime.has(varName) || runtime.has(varName.split(/[.[]/)[0]);
+      if (!inRows && !atRuntime && (!testData || !(varName in testData))) {
         findings.push({
           gate: 'D', severity: 'error', ref: vpId,
           message: `${vpId}: {{${varName}}} does not resolve in test-data — the variant is not reproducible`,
@@ -241,6 +283,21 @@ function gateDExecutability(ctx: GateContext, findings: MatrixFinding[]): void {
       }
     }
   }
+
+  // No template token may survive into a RENDERED cell (review B-04) — this also
+  // catches cross-referencing test-data values the one-level resolver couldn't close.
+  for (const [, vs] of variantsByVp) {
+    for (const v of vs) {
+      const rendered = [...v.precondition, ...v.trigger, ...v.oracle, ...v.verification, ...v.data];
+      const token = rendered.map((t) => t.match(/\{\{[^}]*\}\}/)).find(Boolean);
+      if (token) {
+        findings.push({
+          gate: 'D', severity: 'error', ref: v.ref,
+          message: `${v.ref}: unresolved template token ${token[0]} remains in the rendered output — the export is not deterministic for a tester`,
+        });
+      }
+    }
+  }
 }
 
 // --- Gate E — drift (stale approval) ------------------------------------------
@@ -249,6 +306,25 @@ function gateEDrift(ctx: GateContext, findings: MatrixFinding[]): void {
   const { map } = ctx.inputs;
   const { variantsByVp } = ctx;
 
+  // The map's own semantics (targets/intents/oracles/grouping) are part of what
+  // was approved — an edit after approval must be re-reviewed, not silently
+  // published (review GAP-09).
+  const stampedMap = map.fingerprints.__map__;
+  const liveMap = mapContentFingerprint(map.groups, map.dispositions);
+  if (map.groups.some((g) => g.review === 'approved')) {
+    if (!stampedMap) {
+      findings.push({
+        gate: 'E', severity: 'review',
+        message: 'the delivery map has no stamped content fingerprint — run `sungen delivery --approve` to record the reviewed wording',
+      });
+    } else if (stampedMap !== liveMap) {
+      findings.push({
+        gate: 'E', severity: 'review',
+        message: 'the delivery map wording/grouping changed since approval — re-review, then `sungen delivery --approve`',
+      });
+    }
+  }
+
   for (const g of map.groups) {
     if (g.review !== 'approved') continue; // proposed groups are already under review
     for (const ref of g.variants) {
@@ -271,6 +347,46 @@ function gateEDrift(ctx: GateContext, findings: MatrixFinding[]): void {
   }
 }
 
+// --- Gate W — controlled-language lint on the map's semantic fields --------------
+
+/** Patterns that make customer-facing wording read machine-generated (review §10). */
+const WORDING_SMELLS: Array<[RegExp, string]> = [
+  [/\{\{[^}]*\}\}/, 'an unresolved {{token}}'],
+  [/\b(?:Setup|Observable|Oracle):/, 'a generator label (Setup:/Observable:/Oracle:)'],
+  [/\bUser (?:fill|click|press|see|wait)\b/i, 'DSL phrasing ("User fill/click/see…") — write plain product language'],
+  [/\[[^\]]+\]/, 'a [selector-style] reference — use the visible UI label'],
+];
+
+function gateWWording(ctx: GateContext, findings: MatrixFinding[]): void {
+  for (const g of ctx.inputs.map.groups) {
+    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({
+            gate: 'W', severity: 'warning', ref: g.id,
+            message: `group ${g.id} ${field} contains ${what}`,
+          });
+        }
+      }
+    }
+  }
+}
+
 // --- Gate G — review state -----------------------------------------------------
 
 function gateGReviewState(ctx: GateContext, findings: MatrixFinding[]): void {

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

@@ -9,11 +9,13 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
-import { DeliveryMap, MapCategory, MapDisposition, MapGroup, ReviewState } from './types';
+import { DeliveryMap, MapCategory, MapDisposition, MapGroup, RequirementOverride, RequirementStatus, ReviewState } from './types';
 
 const CATEGORIES: MapCategory[] = ['normal', 'abnormal', 'security', 'nfr'];
 const REVIEW_STATES: ReviewState[] = ['proposed', 'approved'];
 const DISPOSITIONS = ['excluded', 'blocked', 'covered_elsewhere', 'accepted_risk'];
+const REQUIREMENT_STATUSES: RequirementStatus[] =
+  ['covered', 'partially_covered', 'covered_elsewhere', 'planned', 'gap', 'not_applicable'];
 
 export interface MapLoadResult {
   map: DeliveryMap | null;
@@ -76,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) : [],
@@ -98,6 +101,21 @@ export function loadDeliveryMap(file: string): MapLoadResult {
     }
   }
 
+  const requirements: Record<string, RequirementOverride> = {};
+  if (doc.requirements !== undefined) {
+    if (!doc.requirements || typeof doc.requirements !== 'object' || Array.isArray(doc.requirements)) {
+      errors.push('`requirements` must be a mapping of requirement-id → { status, note }');
+    } else {
+      for (const [reqId, r] of Object.entries(doc.requirements as Record<string, unknown>)) {
+        const rr = (r && typeof r === 'object' ? r : {}) as Record<string, unknown>;
+        if (!REQUIREMENT_STATUSES.includes(String(rr.status) as RequirementStatus)) {
+          errors.push(`requirements.${reqId}: \`status\` must be one of ${REQUIREMENT_STATUSES.join(' | ')}`);
+        }
+        requirements[reqId] = { status: rr.status as RequirementStatus, note: rr.note ? String(rr.note) : undefined };
+      }
+    }
+  }
+
   const fingerprints: Record<string, string> = {};
   if (doc.fingerprints && typeof doc.fingerprints === 'object' && !Array.isArray(doc.fingerprints)) {
     for (const [k, v] of Object.entries(doc.fingerprints as Record<string, unknown>)) {
@@ -111,6 +129,7 @@ export function loadDeliveryMap(file: string): MapLoadResult {
     formNo: doc.form_no !== undefined ? String(doc.form_no) : undefined,
     groups,
     dispositions,
+    requirements,
     fingerprints,
   };
   return { map: errors.length > 0 ? null : map, errors };
@@ -130,11 +149,13 @@ 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,
     })),
     ...(Object.keys(map.dispositions).length > 0 ? { dispositions: map.dispositions } : {}),
+    ...(Object.keys(map.requirements).length > 0 ? { requirements: map.requirements } : {}),
     ...(Object.keys(map.fingerprints).length > 0 ? { fingerprints: map.fingerprints } : {}),
   };
   fs.mkdirSync(path.dirname(file), { recursive: true });

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

@@ -1,16 +1,18 @@
 /**
  * Flat CSV rendering of the matrix — same model as the workbook, one row per
- * delivery item (`Level: item`) followed by its variant rows (`Level: variant`),
- * so downstream pipelines can re-derive both views from one file.
+ * delivery item (`Level: item`) followed by its variant rows (`Level: variant`;
+ * every item has them — the variant row carries the source scenario id, data,
+ * and result), so downstream pipelines can re-derive both views from one file.
  */
 
-import { statusToTestResult, formatExecutedDate } from '../playwright-report-parser';
+import { variantState } from './build';
+import { coverageSummary, itemModeLabel, itemResultLabel } from './render-xlsx';
 import { MatrixModel } from './types';
 
 const HEADERS = [
   'Level', 'ID', 'Target', 'Test Intent / Condition', 'Category', 'Priority',
-  'Precondition', 'Coverage / Test Data', 'Action / Trigger', 'Expected (Oracle)',
-  'Mode', 'Trace', 'Result', 'Executed Date', 'Note',
+  'Precondition', 'Coverage / Test Data', 'Action / Trigger', 'Expected Result',
+  'Mode', 'Trace', 'Result', 'Executed Date', 'Note / Evidence', 'Defect ID',
 ];
 
 function esc(value: string): string {
@@ -18,6 +20,13 @@ function esc(value: string): string {
   return value;
 }
 
+function isoDate(startTime: string | undefined): string {
+  if (!startTime) return '';
+  const d = new Date(startTime);
+  if (isNaN(d.getTime())) return '';
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+}
+
 export function renderMatrixCsv(model: MatrixModel): string {
   const BOM = '\ufeff'; // Excel compatibility (Vietnamese/Japanese content)
   const lines: string[] = [];
@@ -26,8 +35,6 @@ export function renderMatrixCsv(model: MatrixModel): string {
   lines.push(HEADERS.map(esc).join(','));
 
   for (const item of model.items) {
-    const single = item.variants.length === 1;
-    const only = single ? item.variants[0] : undefined;
     lines.push([
       'item',
       item.id,
@@ -36,35 +43,51 @@ export function renderMatrixCsv(model: MatrixModel): string {
       item.category,
       item.priority,
       item.precondition.join('\n'),
-      single ? only!.data.join('\n') : `${item.variants.length} variants`,
+      coverageSummary(item),
+      // Shared leading steps only; each variant row carries its remaining steps.
       item.trigger.join('\n'),
       item.oracle,
-      item.mode === 'manual' ? 'Manual' : 'Auto',
+      itemModeLabel(item),
       item.traces.join(' '),
-      item.result,
-      single ? formatExecutedDate(only!.result?.startTime) : '',
+      itemResultLabel(item),
+      '',
       item.review === 'proposed' ? 'REVIEW REQUIRED' : '',
+      '',
     ].map(esc).join(','));
 
-    if (!single) {
-      for (const v of item.variants) {
-        lines.push([
-          'variant',
-          v.ref,
-          '',
-          v.condition,
-          '', '',
-          '',
-          v.data.join('\n'),
-          v.trigger.join('\n'),
-          v.oracle.join('\n'),
-          v.mode === 'manual' ? 'Manual' : 'Auto',
-          v.traces.join(' '),
-          v.result ? statusToTestResult(v.result.status) : 'Pending',
-          formatExecutedDate(v.result?.startTime),
-          v.result?.error ? String(v.result.error).slice(0, 200) : '',
-        ].map(esc).join(','));
-      }
+    for (const v of item.variants) {
+      const expected = v.verification.length > 0
+        ? `${v.oracle.join('\n')}\nVerification method: ${v.verification.join(' ')}`
+        : v.oracle.join('\n');
+      lines.push([
+        'variant',
+        v.ref,
+        '',
+        v.condition,
+        '', '',
+        // Precondition DELTA — variant-specific setup only (review GAP-03).
+        (item.preconditionDeltas[v.ref] ?? []).join('\n'),
+        v.data.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(' '),
+        variantState(v),
+        isoDate(v.result?.startTime),
+        v.result?.error ? String(v.result.error).slice(0, 200) : '',
+        '',
+      ].map(esc).join(','));
+    }
+  }
+
+  // Requirement coverage appendix — keeps the CSV self-contained for pipelines.
+  if (model.requirements.length > 0) {
+    lines.push('');
+    lines.push('# Requirement coverage');
+    lines.push(['Requirement', 'Status', 'Delivery items', 'Variants', 'Note'].join(','));
+    for (const r of model.requirements) {
+      lines.push([r.id, r.status, r.items.join(' '), String(r.variantCount), r.note].map(esc).join(','));
     }
   }
   return BOM + lines.join('\n') + '\n';