@sun-asterisk/sungen 3.0.0-beta.74 → 3.0.0-beta.77

package/src/generators/gherkin-parser/index.ts

@@ -18,6 +18,8 @@ export interface ParsedStep {
   keyword: string; // Given, When, Then, And, But
   text: string; // Original step text
   selectorRef?: string; // Extracted selector reference like [auth-login.email]
+  childRef?: string; // Q2: second [ref] after "contain" — child element for all-card structural assertion
+  childElementType?: string; // Element type after the child [ref], e.g. "button" in "contain [Add To Cart] button"
   dataRef?: string; // Extracted data reference like <valid_user.email>
   value?: string; // Static value if any
   elementType?: string; // Element type after [Selector] e.g., "button", "text", "link", "field"
@@ -173,12 +175,25 @@ export class GherkinParser {
     if (selectorRef) {
       const elementTypeMatch = text.match(/\]\s+([\w-]+)/);
       elementType = elementTypeMatch ? elementTypeMatch[1].toLowerCase() : undefined;
+      // In "see all [Card] contain [Child]" the word after the first `]` is the
+      // connector "contain", not an element type — don't mistake it for one (Q2).
+      if (elementType && /^(contain|contains|include|includes)$/.test(elementType)) elementType = undefined;
     } else {
       // Extract final word if it's a known type (page, button, field, etc)
       const finalWordMatch = text.match(/\b(page|button|field|link|text|checkbox|radio|select|dropdown|modal|dialog|drawer|message|error|warning|success|alert|table|list|list-item|listitem|row|search|option|slider|toggle|tab|breadcrumb|overlay|step|section|card|item|icon|image|header|label|badge|tooltip|tag|menuitem|cell|column|uploader|date-picker|key)\b$/i);
       elementType = finalWordMatch ? finalWordMatch[1].toLowerCase() : undefined;
     }
 
+    // Q2: a second [ref] after "contain"/"include" = the child element every container
+    // must hold, e.g. "see all [Product Card] contain [Add To Cart] button".
+    let childRef: string | undefined;
+    let childElementType: string | undefined;
+    const childMatch = text.match(/\b(?:contain|contains|include|includes)\s+\[([^\]]+)\]\s*([\w-]+)?/i);
+    if (childMatch) {
+      childRef = childMatch[1];
+      childElementType = childMatch[2] ? childMatch[2].toLowerCase() : undefined;
+    }
+
     // Extract positional index from "[Element] field 3", "[Element] button 2", etc.
     let nth = 0;
     if (selectorRef && selectorMatch) {
@@ -202,6 +217,8 @@ export class GherkinParser {
       keyword: step.keyword.trim(),
       text: step.text, // Preserve original text (with parent scoping) for pattern matching
       selectorRef,
+      childRef,
+      childElementType,
       dataRef,
       value,
       elementType,

package/src/generators/test-generator/adapters/playwright/templates/steps/assertions/all-contain-element.hbs

@@ -0,0 +1,8 @@
+{
+    const __cards_{{stepCounter}} = {{> locator}};
+    const __n_{{stepCounter}} = await __cards_{{stepCounter}}.count();
+    expect(__n_{{stepCounter}}, 'Expected at least one [{{selectorRef}}]').toBeGreaterThan(0);
+    for (let __i_{{stepCounter}} = 0; __i_{{stepCounter}} < __n_{{stepCounter}}; __i_{{stepCounter}}++) {
+      await expect({{#with child}}{{> locator}}{{/with}}, 'Every [{{selectorRef}}] must contain [{{childRef}}]').toBeVisible();
+    }
+  }

package/src/generators/test-generator/patterns/capture-patterns.ts

@@ -13,6 +13,11 @@ import { StepPattern, StepTemplateData } from './types';
  *  2. List:     `User see all [Product Name] contain {{selected_category}}`
  *               → asserts EVERY matching element's text contains the value
  *               (e.g. all products belong to the selected category/brand).
+ *
+ *  3. All-card:  `User see all [Product Card] contain [Add To Cart] button`
+ *               → asserts EVERY container element holds the child element
+ *               (structural per-card proof: every card has name/price/action).
+ *               Roadmap Q2 — the fix for "each card exposes X" claims.
  */
 export const capturePatterns: StepPattern[] = [
   {
@@ -56,4 +61,37 @@ export const capturePatterns: StepPattern[] = [
     },
     priority: 34,
   },
+  {
+    // Q2 — all-card structural assertion: every container holds the child element.
+    // Distinguished from `all-contain-assertion` by a second [ref] (childRef) and the
+    // ABSENCE of a value/data (which would make it a text-contains assertion instead).
+    name: 'all-contain-element',
+    matcher: (step: ParsedStep) =>
+      /\b(see|sees)\b/i.test(step.text) &&
+      /\ball\b/i.test(step.text) &&
+      /(contain|contains|include|includes)/i.test(step.text) &&
+      !!step.selectorRef && !!step.childRef && !step.value && !step.dataRef,
+    resolver: (step, context): StepTemplateData => {
+      const container = context.selectorResolver.resolveSelector(
+        step.selectorRef!, undefined, step.elementType, step.nth,
+      );
+      const child = context.selectorResolver.resolveSelector(
+        step.childRef!, undefined, step.childElementType, 0,
+      );
+      const sc = context.stepCounter;
+      return {
+        templateName: 'all-contain-element',
+        data: {
+          ...container,
+          selectorRef: step.selectorRef,
+          childRef: step.childRef,
+          stepCounter: sc,
+          // Render the child RELATIVE to each container row via locator.hbs's parentLocator branch.
+          child: { ...child, parentLocator: `__cards_${sc}.nth(__i_${sc})` },
+        },
+        comment: `Assert all ${step.selectorRef} contain [${step.childRef}]`,
+      };
+    },
+    priority: 36,
+  },
 ];

package/src/harness/audit.ts

@@ -9,16 +9,19 @@
 import * as path from 'path';
 import { loadScenarios, parseViewpointOverview, ScenarioInfo, ViewpointEntry } from './parse';
 import {
-  loadCatalog, viewpointGate, assertionDepth, dataThemesFor, coverageBalance, duplicateClusters, traceability,
-  GateResult, DepthResult, BalanceResult, DuplicateResult, TraceResult,
+  loadCatalog, viewpointGate, assertionDepth, dataThemesFor, coverageBalance, duplicateClusters, traceability, claimProof, taxonomyLint,
+  GateResult, DepthResult, BalanceResult, DuplicateResult, TraceResult, ClaimProofResult, TaxonomyResult,
 } from './sensors';
 import { readIntent, projectRootFromScreenDir, IntentProfile } from './intent';
+import { getProvenance, Provenance } from './provenance';
 
 export interface AuditReport {
   screen: string;
   scenarioCount: number;
   gate: GateResult;
   depth: DepthResult;
+  claim: ClaimProofResult;
+  taxonomy: TaxonomyResult;
   balance: BalanceResult;
   duplicates: DuplicateResult;
   trace: TraceResult;
@@ -33,6 +36,7 @@ export interface AuditReport {
   gateStatus: 'PASS' | 'FAIL';
   findings: string[];           // human-actionable, what the Repair loop would target
   intent: IntentProfile;        // P3 — the intent profile that drove the thresholds
+  provenance: Provenance;       // D1 — sungen version + catalog hash (diagnose cross-user score gaps)
 }
 
 export function runAudit(screenDir: string, screenName: string): AuditReport {
@@ -47,6 +51,8 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   // P3 — intent profile from qa/context.md drives the depth threshold (focus).
   const intent = readIntent(projectRootFromScreenDir(screenDir));
   const depth = assertionDepth(scenarios, dataThemesFor(catalog, gate.pageType), intent.focus);
+  const claim = claimProof(scenarios, intent.focus);
+  const taxonomy = taxonomyLint(scenarios);
   const balance = coverageBalance(scenarios);
   const duplicates = duplicateClusters(scenarios);
   const trace = traceability(scenarios, viewpoints);
@@ -78,6 +84,13 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
       `add data assertions (\`... with {{value}}\`, \`see all ... contain {{v}}\`) or, if cross-screen, defer to a flow with @manual + reason.`,
     );
   }
+  for (const u of claim.unproven) {
+    const tag = u.severity === 'fail' ? 'CLAIM-UNPROVEN' : 'CLAIM-WEAK';
+    findings.push(`${tag}: "${u.name}" — title claims [${u.claim}] but steps lack ${u.need}. ${u.hint}`);
+  }
+  for (const m of taxonomy.mislabeled) {
+    findings.push(`VP-MISLABEL: "${m.name}" is coded VP-${m.current} but reads as ${m.suggested} (signal: "${m.signal}") → re-tag VP-${m.suggested}-NNN so the coverage matrix isn't skewed.`);
+  }
   if (balance.imbalanced) {
     findings.push(`BALANCE: ${balance.note} Stop expanding secondary viewpoints until business-core gaps are filled.`);
   }
@@ -91,12 +104,12 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   // Gate now spans coverage (viewpoint themes) AND depth (data-correctness).
   // A depth 'fail' (below the intent threshold) fails the gate; 'warn' does not.
   const gateStatus: 'PASS' | 'FAIL' =
-    gate.gaps.length === 0 && depth.verdict !== 'fail' ? 'PASS' : 'FAIL';
+    gate.gaps.length === 0 && depth.verdict !== 'fail' && claim.verdict !== 'fail' ? 'PASS' : 'FAIL';
 
   return {
     screen: screenName,
     scenarioCount: scenarios.length,
-    gate, depth, balance, duplicates, trace,
+    gate, depth, claim, taxonomy, balance, duplicates, trace,
     score: {
       overall: Math.round(overall * 10) / 10,
       coverage: Math.round(coverage * 100) / 100,
@@ -108,5 +121,6 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
     gateStatus,
     findings,
     intent,
+    provenance: getProvenance(),
   };
 }

package/src/harness/capability-plan.ts

@@ -43,6 +43,17 @@ const INFER: { code: string; re: RegExp }[] = [
   { code: 'M9', re: /\b(judgment|human|subjective|manual review)\b/i },
 ];
 
+/**
+ * Classify free text (e.g. a legacy testcase's precondition+steps+expected) into a
+ * manual-reason code, or '' when nothing matches (→ UI-automatable). Reuses the same
+ * INFER patterns as the scenario planner so legacy-ingest and the Gherkin planner agree.
+ */
+export function classifyReason(text: string): string {
+  const t = (text || '').toLowerCase();
+  for (const { code, re } of INFER) if (re.test(t)) return code;
+  return '';
+}
+
 interface ParsedScenario { name: string; tags: string[]; manual: boolean; reason: string }
 
 /** Parse scenarios with their tags + the reason comment line above (for @manual). */

package/src/harness/parse.ts

@@ -28,6 +28,7 @@ export interface ScenarioInfo {
   shallow: boolean;           // asserts only visibility/navigation (no data)
   stepSkeleton: string;       // normalized steps for duplicate clustering
   haystack: string;           // lowercase name + steps text (for keyword coverage)
+  stepsText: string;          // lowercase steps ONLY (name excluded) — for claim-proof
 }
 
 // ---------- test-viewpoint.md ----------
@@ -98,11 +99,13 @@ function classifyScenario(sc: ParsedScenario): ScenarioInfo {
   let hasData = false;
   const skeletonParts: string[] = [];
   const textParts: string[] = [sc.name];
+  const stepTextParts: string[] = [];
 
   for (const step of sc.steps as ParsedStep[]) {
     const kw = step.keyword.trim();
     if (kw === 'Given' || kw === 'When' || kw === 'Then') last = kw;
     textParts.push(step.text);
+    stepTextParts.push(step.text);
     // normalized skeleton: keep [refs] (distinct targets = distinct tests),
     // but neutralize {{vars}} and quoted values so EP/data families collapse.
     const skel = step.text
@@ -132,6 +135,7 @@ function classifyScenario(sc: ParsedScenario): ScenarioInfo {
     shallow,
     stepSkeleton: skeletonParts.join(' | '),
     haystack: textParts.join(' ').toLowerCase(),
+    stepsText: stepTextParts.join(' ').toLowerCase(),
   };
 }
 

package/src/harness/provenance.ts

@@ -0,0 +1,33 @@
+/**
+ * Provenance stamp for deterministic reports (score-determinism D1).
+ *
+ * The audit score is a pure function of the project files + the bundled catalog.
+ * Stamping the sungen version + a catalog hash into the report lets two users who
+ * get different scores see IMMEDIATELY whether the cause is a version/catalog
+ * mismatch (the main residual source of cross-user variance) rather than a real
+ * difference in their test design.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+
+export interface Provenance {
+  sungenVersion: string;
+  catalogHash: string; // sha256(universal-viewpoints.yaml), first 12 hex — the catalog that drives the score
+}
+
+export function getProvenance(): Provenance {
+  let sungenVersion = 'unknown';
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', 'package.json'), 'utf-8'));
+    if (pkg && typeof pkg.version === 'string') sungenVersion = pkg.version;
+  } catch { /* version stays 'unknown' */ }
+
+  let catalogHash = 'unknown';
+  try {
+    const cat = fs.readFileSync(path.join(__dirname, 'catalog', 'universal-viewpoints.yaml'), 'utf-8');
+    catalogHash = crypto.createHash('sha256').update(cat).digest('hex').slice(0, 12);
+  } catch { /* hash stays 'unknown' */ }
+
+  return { sungenVersion, catalogHash };
+}

package/src/harness/sensors.ts

@@ -277,3 +277,192 @@ export function traceability(scenarios: ScenarioInfo[], viewpoints: ViewpointEnt
       : 'Traceable.',
   };
 }
+
+// ---------- Claim-Proof (harness-roadmap §0.5 Q1) ----------
+//
+// A scenario's TITLE makes a claim; its STEPS must prove it. This is the
+// design-layer sibling of script-check's anti-bypass (code↔Gherkin): here it is
+// title↔steps. We only measure scenarios whose title carries a claim keyword, so
+// plain visibility/navigation scenarios are never falsely pressured. @manual
+// scenarios are skipped — their claim is deferred to a flow (XS/flow-check owns it).
+
+export interface ClaimUnproven {
+  name: string;
+  claim: string;       // the claim keyword matched in the title
+  need: string;        // the assertion shape the steps must contain
+  hint: string;        // how to fix
+  severity: 'fail' | 'warn';
+}
+
+export interface ClaimProofResult {
+  total: number;        // non-manual scenarios
+  withClaims: number;   // scenarios whose title carries a claim
+  proven: number;
+  unproven: ClaimUnproven[];
+  ratio: number;        // proven / withClaims (1 if withClaims === 0)
+  focus: string;
+  threshold: number;
+  verdict: DepthVerdict;
+}
+
+interface ClaimRule {
+  claim: string;
+  title: RegExp;        // claim keyword(s) in the title
+  proof: RegExp;        // required assertion shape in the steps
+  need: string;
+  hint: string;
+  severity: 'fail' | 'warn';
+  // Optional: even when `proof` matches, if `underproof` also matches the proof is
+  // PARTIAL (the right shape exists but on the wrong/another element) → a warn-level
+  // finding. e.g. an "each card exposes <action>" claim that has a see-all on price
+  // but asserts the actions with singular presence.
+  underproof?: RegExp;
+  underNeed?: string;
+  underHint?: string;
+}
+
+// Ordered by specificity; the first matching rule per scenario wins.
+const CLAIM_RULES: ClaimRule[] = [
+  {
+    claim: 'all/every/each',
+    title: /\b(all|every|each)\b/,
+    proof: /\bsee all\b/,
+    need: 'a `User see all …` assertion (every element, not one)',
+    hint: 'assert across all matched elements — for per-card structure use the all-card DSL (roadmap Q2).',
+    severity: 'fail',
+    // singular action presence under an "each/every" claim = partial proof
+    underproof: /\bsee \[[^\]]+\] (link|button)\b/,
+    underNeed: 'an all-card assertion for the claimed action (not single presence)',
+    underHint: 'the actions are asserted once, not per-card — wrap them with the all-card DSL `User see all [Card] contain [Action]` (roadmap Q2).',
+  },
+  {
+    claim: 'only/belong-to',
+    title: /\b(only|belongs? to|exclusively)\b/,
+    proof: /\bsee all\b[^.]*\bcontain/,
+    need: 'all-match (`User see all … contains …`)',
+    hint: 'all displayed items must match the facet; "no items OUTSIDE" is UI-limited → verify via hybrid API/DB or mark @manual with reason.',
+    severity: 'warn',
+  },
+  {
+    claim: 'single/exactly-one',
+    title: /\b(a single|single|exactly one|just one|only one)\b/,
+    proof: /\bcount\b|\btable with\b|\bexactly\b|tohavecount/,
+    need: 'a count assertion (e.g. count is 1)',
+    hint: 'assert the quantity, not just presence.',
+    severity: 'fail',
+  },
+  {
+    claim: 'correct/matching/identity',
+    title: /\b(correct|matching|the same|same (product|name|price|value|item)|consistency|identity|lands? in|is the (product|item))\b/,
+    proof: /\bremember\b/,
+    need: 'capture + compare (`User remember … as {{v}}` then assert {{v}})',
+    hint: 'remember the value on the source, then assert it on the target (cross-screen → defer to a flow as @manual).',
+    severity: 'fail',
+  },
+  {
+    claim: 'changes/toggles',
+    title: /\b(changes?|toggles?|updates?|reflects?|reopens?)\b/,
+    proof: /\bremember\b|\bis hidden\b/,
+    need: 'a state delta (before ≠ after, or a visible→hidden contrast)',
+    hint: 'capture the before-state and assert the after-state differs, or assert the visible/hidden transition.',
+    severity: 'warn',
+  },
+  {
+    claim: 'hidden/rejected/not-complete',
+    title: /\b(hidden|closed|dismiss(es|ed)?|does not|doesn't|not complete|rejected|inert)\b/,
+    proof: /\bis hidden\b|\bare hidden\b|message is hidden|not complete|\bhidden\b/,
+    need: 'a negative / hidden assertion (`… is hidden`)',
+    hint: 'assert the absence/hidden state that the title claims, not just an unrelated visible element.',
+    severity: 'fail',
+  },
+];
+
+// ---------- Viewpoint taxonomy-lint (harness-roadmap §0.5 Q3) ----------
+//
+// A scenario's VP-code prefix (VP-CART-001 → CART) should match what the title is
+// actually about, or the coverage matrix / per-viewpoint score is skewed. Conservative:
+// flag ONLY when the title carries NO signal for its own category AND exactly one OTHER
+// known category's signal — so a legitimately mixed title (e.g. a LIST card that also
+// mentions an action) is never flagged. LOGIC/UI are flexible lenses → not linted.
+
+export interface TaxonomyFinding {
+  name: string;
+  current: string;   // category from the VP code
+  suggested: string; // category the title signals
+  signal: string;    // the phrase that triggered the suggestion
+}
+
+export interface TaxonomyResult {
+  total: number;
+  checked: number;          // scenarios with a known, lintable category
+  mislabeled: TaxonomyFinding[];
+}
+
+const TAXONOMY_KNOWN = new Set(['LIST', 'PRODUCT', 'CART', 'FILTER', 'NAV', 'VAL', 'SEC']);
+
+const CATEGORY_SIGNALS: { cat: string; re: RegExp }[] = [
+  { cat: 'FILTER', re: /\b(categor(y|ies)|sub-?categor\w*|expand\w*|collaps\w*|\bfacet\b|filter\w*|belongs? to)\b/ },
+  { cat: 'CART', re: /\b(add(ed|ing)? to cart|added (dialog|modal|message|confirmation)|cart (page|table|line|item)|view cart|continue shopping|quantit)\b/ },
+  { cat: 'PRODUCT', re: /\b(product detail|product-detail|view product|product page|same product|product name and price|product identity|detail product)\b/ },
+  { cat: 'LIST', re: /\b(product (list|grid)|featured product|product card|each (featured )?card|every (featured )?card)\b/ },
+  { cat: 'NAV', re: /\b(navigates?|returns the user|redirect\w*|logo returns|menu navigates)\b/ },
+  { cat: 'VAL', re: /\b(valid email|invalid\b|without (a |an )?@|without a domain|empty (email|input|field)|validation|required field)\b/ },
+  { cat: 'SEC', re: /\b(xss|sql|injection|payload|without authentication|unauthenticated|\binert\b|tamper\w*|malformed|url parameter|query param\w*|falls? back|gracefull?y|without a crash|not[- ]found|\b404\b|special character|abuse)\b/ },
+];
+
+export function taxonomyLint(scenarios: ScenarioInfo[]): TaxonomyResult {
+  const mislabeled: TaxonomyFinding[] = [];
+  let checked = 0;
+  for (const s of scenarios) {
+    const cat = s.category;
+    if (!cat || !TAXONOMY_KNOWN.has(cat)) continue;
+    checked++;
+    const title = s.name.toLowerCase();
+    const matched = [...new Set(CATEGORY_SIGNALS.filter((c) => c.re.test(title)).map((c) => c.cat))];
+    if (matched.includes(cat)) continue;             // title supports its own category → fine
+    const others = matched.filter((c) => c !== cat);
+    if (others.length === 1) {                        // unambiguous mismatch
+      const sig = CATEGORY_SIGNALS.find((c) => c.cat === others[0])!;
+      const m = title.match(sig.re);
+      mislabeled.push({ name: s.name, current: cat, suggested: others[0], signal: m ? m[0] : others[0] });
+    }
+  }
+  return { total: scenarios.length, checked, mislabeled };
+}
+
+export function claimProof(scenarios: ScenarioInfo[], focus = 'functional'): ClaimProofResult {
+  const measured = scenarios.filter((s) => !s.manual);
+  const unproven: ClaimUnproven[] = [];
+  let withClaims = 0;
+
+  for (const s of measured) {
+    const title = s.name.toLowerCase();
+    const rule = CLAIM_RULES.find((r) => r.title.test(title));
+    if (!rule) continue;          // no claim → not measured
+    withClaims++;
+    if (!rule.proof.test(s.stepsText)) {
+      // proof shape entirely absent → fail at the rule's severity
+      unproven.push({ name: s.name, claim: rule.claim, need: rule.need, hint: rule.hint, severity: rule.severity });
+    } else if (rule.underproof && rule.underproof.test(s.stepsText)) {
+      // right shape exists but only as a partial proof → warn
+      unproven.push({
+        name: s.name, claim: rule.claim,
+        need: rule.underNeed ?? rule.need,
+        hint: rule.underHint ?? rule.hint,
+        severity: 'warn',
+      });
+    }
+  }
+
+  const proven = withClaims - unproven.length;
+  const ratio = withClaims ? proven / withClaims : 1;
+  const threshold = DEPTH_THRESHOLDS[focus] ?? DEPTH_THRESHOLDS.functional;
+
+  const hasFail = unproven.some((u) => u.severity === 'fail');
+  let verdict: DepthVerdict = 'pass';
+  if (ratio < threshold) {
+    verdict = WARN_ONLY_FOCUS.has(focus) || !hasFail ? 'warn' : 'fail';
+  }
+
+  return { total: measured.length, withClaims, proven, unproven, ratio, focus, threshold, verdict };
+}

package/src/ingest/baseline-audit.ts

@@ -0,0 +1,100 @@
+/**
+ * QA baseline audit over a legacy testcase inventory (P-A). Reuses the harness
+ * duplicate sensor + the capability-plan reason classifier so the legacy view and
+ * the Gherkin view agree. Advisory — evaluates the *existing* manual suite and the
+ * automation/driver opportunity; it does not gate anything.
+ */
+import { LegacyInventory, LegacyTestcase } from './legacy-parser';
+import { duplicateClusters } from '../harness/sensors';
+import { ScenarioInfo } from '../harness/parse';
+import { classifyReason, MANUAL_REASONS } from '../harness/capability-plan';
+
+export interface BaselineReport {
+  total: number;
+  sheets: { name: string; type: string; rows: number }[];
+  byCategory: Record<string, number>;
+  byPriority: Record<string, number>;
+  byResult: Record<string, number>;
+  depthRatio: number;          // % of TC whose Expected asserts a concrete value
+  deepCount: number;
+  duplicateClusters: number;
+  exactDuplicates: number;
+  reasons: {                   // capability-plan style distribution
+    ui: number; crossScreen: number; capabilityManual: number; keepManual: number;
+    byCode: Record<string, number>;
+    driverCandidates: { driver: string; count: number }[];
+  };
+}
+
+/** An Expected that asserts a concrete value (not just "displayed/visible"). */
+function isDeep(tc: LegacyTestcase): boolean {
+  const e = (tc.expected || '').trim().toLowerCase();
+  if (!e) return false;
+  const shallowOnly = /^(.{0,40})(表示される|hiển thị|displayed|shown|is visible|表示)$/.test(e);
+  const hasValue = /(=|equals?|bằng|giá trị|\bvalue\b|"|「|\bmessage\b|エラー|error|\bcount\b|số lượng|\bformat\b|định dạng)/.test(e);
+  return hasValue || (!shallowOnly && e.length > 30);
+}
+
+/** Synthesize a ScenarioInfo-lite so we can reuse harness sensors on the inventory. */
+export function legacyToScenarioInfo(tc: LegacyTestcase): ScenarioInfo {
+  const skeleton = (tc.steps || '')
+    .replace(/\{\{[^}]*\}\}/g, '{}').replace(/"[^"]*"/g, '""')
+    .replace(/\d+/g, 'N').replace(/\s+/g, ' ').trim().toLowerCase();
+  const hay = `${tc.category} ${tc.steps} ${tc.expected}`.toLowerCase();
+  return {
+    name: `${tc.category}: ${tc.id}`,
+    category: (tc.category || '').toUpperCase().replace(/[^A-Z0-9]+/g, '-').slice(0, 16),
+    priority: tc.priority,
+    manual: true,
+    thenCount: tc.expected ? 1 : 0,
+    hasDataAssertion: isDeep(tc),
+    shallow: !isDeep(tc),
+    stepSkeleton: skeleton,
+    haystack: hay,
+  } as ScenarioInfo;
+}
+
+export function baselineAudit(inv: LegacyInventory): BaselineReport {
+  const tcs = inv.testcases;
+  const inc = (m: Record<string, number>, k: string) => { m[k] = (m[k] || 0) + 1; };
+
+  const byCategory: Record<string, number> = {};
+  const byPriority: Record<string, number> = {};
+  const byResult: Record<string, number> = {};
+  let deepCount = 0;
+  const byCode: Record<string, number> = {};
+  let ui = 0, crossScreen = 0, capabilityManual = 0, keepManual = 0;
+  const driverHits: Record<string, number> = {};
+
+  for (const tc of tcs) {
+    inc(byCategory, tc.category || '(uncategorized)');
+    inc(byPriority, tc.priority);
+    inc(byResult, (tc.result || '(not-run)').trim() || '(not-run)');
+    if (isDeep(tc)) deepCount++;
+
+    const code = classifyReason(`${tc.precondition || ''} ${tc.steps} ${tc.expected} ${tc.testData || ''}`);
+    if (!code) { ui++; continue; }
+    inc(byCode, code);
+    if (code === 'XS') { crossScreen++; continue; }
+    const def = MANUAL_REASONS[code];
+    if (def?.cls === 'keep') keepManual++;
+    else { capabilityManual++; for (const d of def?.drivers || []) driverHits[d] = (driverHits[d] || 0) + 1; }
+  }
+
+  const dup = duplicateClusters(tcs.map(legacyToScenarioInfo));
+
+  return {
+    total: tcs.length,
+    sheets: inv.sheets,
+    byCategory, byPriority, byResult,
+    depthRatio: tcs.length ? deepCount / tcs.length : 0,
+    deepCount,
+    duplicateClusters: dup.clusters.length,
+    exactDuplicates: dup.exactDuplicateCount,
+    reasons: {
+      ui, crossScreen, capabilityManual, keepManual, byCode,
+      driverCandidates: Object.entries(driverHits).map(([driver, count]) => ({ driver, count }))
+        .sort((a, b) => b.count - a.count),
+    },
+  };
+}