@sun-asterisk/sungen 3.2.33 → 3.2.34

package/src/generators/test-generator/adapters/playwright/templates/steps/actions/click-select-action.hbs

@@ -1,2 +1,2 @@
 await {{> locator}}.click();
-await page.getByText('{{selectValue}}', { exact: true }).first().click();
+{{> pick-option}}

package/src/generators/test-generator/adapters/playwright/templates/steps/actions/select-action.hbs

@@ -9,7 +9,7 @@ if ((await el.evaluate((n) => n.tagName.toLowerCase())) === 'select') {
 await el.selectOption('{{selectValue}}');
 } else {
 await el.click();
-await page.getByText('{{selectValue}}', { exact: true }).first().click();
+{{> pick-option}}
 }
 }
 {{~else~}}

package/src/generators/test-generator/adapters/playwright/templates/steps/partials/pick-option.hbs

@@ -0,0 +1,13 @@
+{{!-- #847 — pick the value in an OPENED custom listbox (Radix/shadcn, MUI, Headless UI).
+      The popup portals to the end of <body>, so a page-wide getByText(…).first() resolved to
+      any EARLIER element with the same text (a badge showing the current choice, a result
+      card) — and the open popup blocks clicks outside it, so the step timed out every time,
+      looking like a race. The ARIA option lives only in the open listbox: wait briefly for it
+      (a count() right after opening would race the popup animation), and fall back to the old
+      text match only for a widget that exposes no listbox roles. --}}
+{ const __opt = page.getByRole('option', { name: '{{selectValue}}', exact: true }).first();
+if (await __opt.waitFor({ state: 'visible', timeout: 3000 }).then(() => true, () => false)) {
+await __opt.click();
+} else {
+await page.getByText('{{selectValue}}', { exact: true }).first().click();
+} }

package/src/generators/test-generator/adapters/playwright/templates/test-file.hbs

@@ -46,6 +46,10 @@ test.describe('{{featureName}}', () => {
   test.describe('{{authRole}}', () => {
     test.use({ storageState: 'specs/.auth/{{authRole}}.json' });
 
+{{#if afterEach}}
+{{indent afterEach 2}}
+
+{{/if}}
 {{#each scenarios}}
 {{indent this 2}}
 
@@ -63,6 +67,18 @@ test.describe('{{featureName}}', () => {
 {{#each scenarios}}
 {{indent this 2}}
 
+{{/each}}
+  });
+
+{{else if afterEach}}
+{{!-- The un-tagged group next to a `@no-auth` one (#815): an ANONYMOUS describe scopes the hook to
+     these tests without adding a title segment, so test titles (and delivery fingerprints) stay put. --}}
+  test.describe(() => {
+{{indent afterEach 2}}
+
+{{#each scenarios}}
+{{indent this 2}}
+
 {{/each}}
   });
 

package/src/generators/test-generator/code-generator.ts

@@ -10,6 +10,7 @@ import { capabilityRegistry } from '../../capabilities/registry';
 import { discoverAndRegisterCapabilities } from '../../capabilities/discover';
 import { readCapabilities } from '../../harness/capability';
 import { parseManualComments } from '../../exporters/scenario-merger';
+import { isPresencePlaceholderHybrid } from '../../exporters/manual-hybrid-oracle';
 import { findSyntaxError } from './utils/spec-syntax-check';
 
 /** One capability-injected precondition statement (`@api:`/`@query:` → `testData.bind(name, …)`). */
@@ -790,11 +791,18 @@ export class CodeGenerator {
         //    labeled `Observable:`/`Oracle:`/`Expected:` line (parseManualComments — the
         //    SAME parser delivery uses). Field finding (student-site, 87 scenarios): prose
         //    paragraphs and rationale-only comments exported EMPTY Steps + Expected cells.
+        //  • HAS a Then, but every assertion is a bare presence placeholder while the real oracle
+        //    sits in the comments (#810) — the same banned hybrid wearing a Then: the deliverable
+        //    reads "See [X] table" and a tester ticking it Passed records a check nobody made.
         const isStructured = scenario.steps.length > 0;
         if (isStructured && !hasThenStep(scenario)) {
           this.diagnostics.add('SG-W008',
             `@manual scenario "${scenario.name}" has Gherkin steps but no Then — a When without Then is invalid Gherkin. Add the Then step, or remove the steps and write the full procedure (action steps, then "Observable:"/"Oracle:" lines) in its \`# Tester verifies:\` block`,
             { feature: feature.name, step: scenario.name });
+        } else if (isStructured && isPresencePlaceholderHybrid(scenario.steps, scenario.comments ?? [])) {
+          this.diagnostics.add('SG-W008',
+            `@manual scenario "${scenario.name}" asserts only presence (e.g. "User see [X] table") while its real oracle sits in the \`# Tester verifies:\` comment — the deliverable's Expected would not say what the case checks. Write the oracle as the Then step (e.g. \`table match data:\`), or remove the steps and write the full numbered procedure ("1. <action>" … "N. Observable: <what>")`,
+            { feature: feature.name, step: scenario.name });
         } else if (!isStructured) {
           const parsed = parseManualComments(scenario.comments ?? []);
           if (!parsed.steps.length || !parsed.expected.length) {
@@ -880,7 +888,7 @@ export class CodeGenerator {
       authGroupMap.get(key)!.push(code);
     }
 
-    const authGroups = groupOrder.map(key => ({
+    const authGroups = groupOrder.map((key): { authRole?: string; noAuth: boolean; scenarios: string[]; afterEach?: string } => ({
       authRole: key === NO_AUTH_GROUP_KEY ? undefined : (key || undefined),
       noAuth: key === NO_AUTH_GROUP_KEY,
       scenarios: authGroupMap.get(key)!,
@@ -923,6 +931,19 @@ export class CodeGenerator {
     }
     const scenarios = renderedScenarios.map(s => s.code);
 
+    // #815 — a feature-level `@afterEach` used to sit in the outermost describe, so it also ran after
+    // every `@no-auth` test, on an EMPTY session: a hook that needs the signed-in page (`Given User is
+    // on [probe] page` → redirected to /login) failed an anonymous test whose own steps passed. When
+    // the feature mixes `@no-auth` with any other group, the hook moves INTO each other group and the
+    // no-auth group runs without it. A feature that is anonymous throughout keeps the hook — it was
+    // written for those tests.
+    // (A no-auth group beside another one means ≥2 groups, so `renderAuthBlocks` is already true.)
+    const afterEachInGroups = !!afterEach
+      && authGroups.some(g => g.noAuth) && authGroups.some(g => !g.noAuth);
+    if (afterEachInGroups) {
+      for (const g of authGroups) if (!g.noAuth) g.afterEach = afterEach;
+    }
+
     // For single group, extract the auth role to put test.use at describe level. Keyed on
     // `renderAuthBlocks`, not `needsGrouping`: a lone `@no-auth` group now renders its own block, so
     // hoisting anything to the feature describe would double up. Its authRole is undefined anyway.
@@ -1019,7 +1040,7 @@ export class CodeGenerator {
       featureDescription: feature.description,
       background,
       beforeAll,
-      afterEach,
+      afterEach: afterEachInGroups ? undefined : afterEach,
       afterAll,
       cleanupConfig,
       screenshotOnFailure,

package/src/generators/test-generator/diagnostics.ts

@@ -24,7 +24,9 @@
  *   SG-W008 — @manual scenario is incomplete in either direction: Gherkin steps without a
  *             Then (invalid Gherkin; comments cannot substitute), or a documentation-style
  *             manual (no steps) whose comments lack the extractable procedure — ≥1 numbered
- *             action line + ≥1 labeled Observable:/Oracle:/Expected: line
+ *             action line + ≥1 labeled Observable:/Oracle:/Expected: line — or a Then that
+ *             asserts only presence while the real oracle sits in a `# Tester verifies:`
+ *             comment (#810)
  *   SG-W009 — test-data references a `${QA_*}` secret that is declared in neither .env.qa
  *             nor .env.qa.example — the test will throw "not set" the moment the key is used
  *   SG-W010 — a row step's [Ref] looks POSITIONAL (First/Last/Top/…) but has no selectors.yaml

package/src/harness/audit.ts

@@ -32,7 +32,8 @@ const MULTI_SCREEN_RISK_COUNT = MULTI_SCREEN_RISKS.length;
 import { capabilityRegistry } from '../capabilities/registry';
 import { discoverAndRegisterCapabilities } from '../capabilities/discover';
 import { contextRouter } from '../capabilities/context-router';
-import { readTextFile } from './read-text';
+import { readTextFile, readViewpointText } from './read-text';
+import { uiInventoryCoverage, uiInventoryFindings, UiInventoryResult } from './ui-inventory';
 
 export interface AuditReport {
   screen: string;
@@ -57,6 +58,8 @@ export interface AuditReport {
   flowQuality?: FlowQualityResult;      // #569 — flow contract verification (flows only)
   /** #595 — coverage per DECLARED FLOW; absent when the contract declares no `flows:`. */
   flowInventory?: InventoryResult;
+  /** #811 — design items vs the suite; present only when the unit holds design sources. */
+  uiInventory?: UiInventoryResult;
   calibration: {                // #8 — multi-axis score so a high overall can't hide a weak axis
     axes: Record<string, number>;
     weakest: { axis: string; value: number };
@@ -185,6 +188,7 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   const scoringCap = scoringCapId ? capabilityRegistry.get(scoringCapId) : undefined;
   const catalog = (scoringCap?.viewpoints?.() as Catalog | undefined) || loadCatalog();
   const spec = specCoverage(specPath, scenarios, featureText);
+  const uiInv = uiInventoryCoverage(path.join(screenDir, 'requirements'), featureText);
 
   // P3 — intent profile from qa/context.md drives the depth threshold (focus).
   const intent = readIntent(projectRootFromScreenDir(screenDir));
@@ -196,7 +200,7 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   // Is the declaration this suite is measured against still the one a human accepted?
   const viewpointBaseline = checkViewpointBaseline(
     projectRootFromScreenDir(screenDir), catalogScreenName, viewpointPath);
-  const viewpointText = fs.existsSync(viewpointPath) ? readTextFile(viewpointPath) : '';
+  const viewpointText = readViewpointText(viewpointPath);
   // #569 — a flow WITH a contract is measured against ITS declaration, not a screen's.
   // Keyword page-type detection force-fit flows into screen checklists (a registration
   // flow judged as a `form` screen scored coverage 0%), so for contract-holding flows the
@@ -373,7 +377,7 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
     { key: 'atomicLedger', value: ledger.ratio, weight: 0.13, applicable: ledger.hasViewpoint && ledger.total > 0 && !viewpointMoved, critical: true, withheld: viewpointMoved && ledger.hasViewpoint && ledger.total > 0 },
     { key: 'businessDepth', value: businessDepth, weight: 0.20, applicable: true, critical: true },
     { key: 'claimProof', value: claim.ratio, weight: 0.15, applicable: claim.withClaims > 0, critical: true },
-    { key: 'traceability', value: traceScore, weight: 0.09, applicable: viewpoints.length > 0 && !viewpointMoved, critical: false, withheld: viewpointMoved && viewpoints.length > 0 },
+    { key: 'traceability', value: traceScore, weight: 0.09, applicable: viewpoints.length > 0 && scenarios.length > 0 && !viewpointMoved, critical: false, withheld: viewpointMoved && viewpoints.length > 0 && scenarios.length > 0 },
     // A use-case decomposition is EF-heavy by construction (1 basic flow, N alternates, N
     // exceptions) — that is the shape of a well-decomposed use case, not neglected business
     // core. `flowCoverage` already measures whether the journey's phases are covered, so
@@ -585,7 +589,7 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
     findings.push(`COVERED-VIA-FLOW: critical theme "${c.theme}" is not covered on this screen but is deeply covered by flow "${c.flow}" — cross-screen depth correctly owned by the flow, so it is credited (not a screen gap). Verify with \`sungen flow-check\`.`);
   }
   // Verification-scope (advisory): API/DB verification the project's recorded test type never asked for.
-  for (const v of verificationScopeFindings(featureText, fs.existsSync(viewpointPath) ? readTextFile(viewpointPath) : '', capProfile)) {
+  for (const v of verificationScopeFindings(featureText, viewpointText, capProfile)) {
     findings.push(`VERIFICATION-OUT-OF-SCOPE (${v.layer}): this unit ${v.message}`);
   }
   for (const g of gate.gaps) {
@@ -657,7 +661,8 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
       ...(unsourced.length ? [`${unsourced.length} scenario(s) could not be traced to a source`] : []),
     ];
     findings.push(`VIEWPOINT-MISSING: \`requirements/test-viewpoint.md\` ${ledger.hasViewpoint ? 'declares no viewpoints' : 'does not exist'}, so this unit has no yardstick. Two scored axes are excluded (atomicLedger, traceability) and four sensors cannot run: the atomic ledger, the declaration-integrity checks (reused ids, dangling refs, uniform priority), the browser-gesture check and the two-way continuity check. Nothing here is a pass — it is unmeasured [${lost.join(', ')}]. A flow contract does NOT substitute: the contract declares the use case, the viewpoint declares the CLAIMS the suite is scored against, and only the second is independent of what was generated. Author it (\`sungen add-flow\` scaffolds a template), then \`sungen audit --screen ${screenName} --accept-viewpoint\`.`);
-  } else if (trace.mappedRatio < 0.5) {
+  } else if (scenarios.length > 0 && trace.mappedRatio < 0.5) {
+    // No scenario yet is not a traceability gap — the axis is n/a, like coverage and claimProof (#852).
     findings.push(`TRACE: ${trace.note}`);
   }
   // (UNIVERSAL viewpoint-gap finding now emitted by the `ui` gate sensor — see the gate block below.)
@@ -698,8 +703,10 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   for (const d of downstream.underCovered) {
     findings.push(`DOWNSTREAM-SCOPE-MISSING: "${d.route}" is a navigation target but is covered only by a page-nav assertion — cover its content/guards, or scaffold it (\`sungen add --screen ${d.slug}\`).`);
   }
+  // #811 — design inventory (advisory): never moves the score or the gate.
+  findings.push(...uiInventoryFindings(uiInv));
   for (const m of manualOracleResult.insufficient.slice(0, 8)) {
-    findings.push(`MANUAL-STEPS-INSUFFICIENT: "${m}" — @manual is incomplete: either Gherkin steps without a Then (invalid Gherkin; comments can't substitute), or a documentation manual whose comments lack numbered action steps + a labeled Observable:/Oracle: line. Write \`# Tester verifies:\` as "1. <action>" … "N. Observable: <what>" / "Oracle: <tool>" — that is what the delivery parser extracts into Steps/Expected.`);
+    findings.push(`MANUAL-STEPS-INSUFFICIENT: "${m}" — @manual is incomplete: either Gherkin steps without a Then (invalid Gherkin; comments can't substitute), a Then that only asserts presence (\`see [X] table\`) while the real oracle sits in a \`# Tester verifies:\` comment (the deliverable's Expected would not say what is checked), or a documentation manual whose comments lack numbered action steps + a labeled Observable:/Oracle: line. Write \`# Tester verifies:\` as "1. <action>" … "N. Observable: <what>" / "Oracle: <tool>" — that is what the delivery parser extracts into Steps/Expected.`);
   }
   // TQ-2 — automatable @manual: deferred (usually cross-screen) but fully DSL-expressible.
   for (const m of autoManual.scenarios.slice(0, 8)) {
@@ -797,7 +804,7 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   // #622 — the priority table is where release selection comes from; a tag that contradicts it
   // means nobody can tell which of the two was the decision.
   {
-    const pm = priorityMismatches(hasYardstick ? (readText(viewpointPath) ?? '') : '', scenarios);
+    const pm = priorityMismatches(hasYardstick ? viewpoints : [], scenarios);
     const byId = new Map<string, { declared: string; tagged: string; n: number }>();
     for (const m of pm) {
       const cur = byId.get(m.id) ?? { declared: m.declared, tagged: m.tagged, n: 0 };
@@ -870,8 +877,11 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   axes.manualOracle = Math.round(manualCompleteness * 100) / 100;
   // Only a real mismatch scores 0. Without a yardstick `trace.mappedRatio` is 0 because there is
   // nothing to map to, and reporting that as the weakest axis sent authors to "raise taxonomy" —
-  // an axis that was never measured.
-  if (hasYardstick) axes.taxonomy = taxonomyMismatch ? 0 : Math.round(trace.mappedRatio * 100) / 100;
+  // an axis that was never measured. The same holds for a yardstick the ledger can read but that
+  // declares no viewpoint ID traceability can read (per-axis tables only, #832): the ledger has
+  // items, so `hasYardstick` is true, yet there is still nothing to map to. Same condition as the
+  // `traceability` score axis (`applicable: viewpoints.length > 0`).
+  if (hasYardstick && viewpoints.length > 0 && scenarios.length > 0) axes.taxonomy = taxonomyMismatch ? 0 : Math.round(trace.mappedRatio * 100) / 100;
   const notApplicable = axisDefs.filter((a) => !a.applicable).map((a) => a.key);
   const weakestEntry = Object.entries(axes).sort((a, b) => a[1] - b[1])[0];
   const weakest = { axis: weakestEntry[0], value: weakestEntry[1] };
@@ -899,6 +909,7 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
     gate, depth, claim, taxonomy, balance, duplicates, trace, spec,
     taxonomyMismatch, reusedScenarioIds: reusedIds, downstream, manualOracle: manualOracleResult, automatableManual: autoManual, flowDepth, oracle, ledger, viewpointBaseline, calibration,
     ...(isUiFlow ? { flowQuality: flowQ, flowInventory: inventory ?? undefined } : {}),
+    ...(uiInv.designSources.length ? { uiInventory: uiInv } : {}),
     score: {
       overall: Math.round(overall * 10) / 10,
       coverage: Math.round(coverage * 100) / 100,

package/src/harness/data-driven-lint.ts

@@ -155,29 +155,100 @@ function overrideKeys(raw?: string): Set<string> {
   return out;
 }
 
+interface FeatureUnderLint {
+  /** Feature file basename — names the test-data file the runtime loads for it. */
+  name: string;
+  scenarios: ParsedScenario[];
+  tags: string[];
+}
+
+/** What every feature of a unit shares: unit-level refs and the @api catalog. */
+interface UnitLintContext {
+  screenDir: string;
+  screenName: string;
+  cwd: string;
+  fileRefs: Set<string>;
+  apiParams: Map<string, string[]>;
+}
+
 /** Lint the @cases/@query usage of one screen/flow directory. Returns advisory warnings. */
 export function lintDataDriven(screenDir: string, cwd: string = process.cwd()): DataDrivenWarning[] {
   const base = path.basename(screenDir);
   const screenName = unitIdOf(screenDir);
   // Every `.feature` of the unit — `add --feature` sub-features lint too. A file that
   // fails to parse contributes nothing rather than voiding the whole unit's lint.
-  const scenarios: ParsedScenario[] = [];
-  const featureTags: string[] = [];
-  for (const p of featureFilesFor(screenDir, base).filter((f) => fs.existsSync(f))) {
+  const features: FeatureUnderLint[] = [];
+  const featureFiles = featureFilesFor(screenDir, base).filter((f) => fs.existsSync(f));
+  for (const p of featureFiles) {
     try {
       const feature = new GherkinParser().parseFeatureFile(p);
-      scenarios.push(...(feature.scenarios || []));
-      featureTags.push(...(feature.tags || []));
+      features.push({ name: path.basename(p, '.feature'), scenarios: feature.scenarios || [], tags: feature.tags || [] });
     } catch {
       /* a file that fails to parse contributes nothing */
     }
   }
-  if (scenarios.length === 0) return [];
+  if (!features.some((f) => f.scenarios.length > 0)) return [];
+
+  const ctx: UnitLintContext = {
+    screenDir, screenName, cwd,
+    // `{{key}}` refs carried by the unit's selectors (i18n) and mock catalog are live too.
+    fileRefs: refsInUnitFiles(screenDir),
+    apiParams: apiParamsByName(screenName, cwd),
+  };
+
+  // #839 — each feature against ITS OWN test-data file. The runtime loads
+  // `test-data/<feature file basename>.yaml` (TestDataLoader.load(unit, featureFileName)), with no
+  // fallback and no merging; reading `<unit dir>.yaml` instead found nothing whenever the names
+  // differ — the default for `add --screen x --path /a/b` (→ b.feature) and for `--feature` — so
+  // every key read as missing and no orphan was ever reported. The tables are deliberately NOT
+  // merged: a key in another feature's file compiles to the literal `${key}` here.
+  const warns: DataDrivenWarning[] = [];
+  for (const f of features) if (f.scenarios.length > 0) warns.push(...lintFeature(f, ctx));
+  warns.push(...unloadedTestDataFiles(screenDir, featureFiles.map((f) => path.basename(f, '.feature'))));
+
+  // Catalog-level lint (SELECT-only, params declared/used, datasource present).
+  try {
+    for (const e of lintCatalog(screenName, null, cwd).errors) warns.push({ message: e });
+  } catch {
+    /* no catalog → nothing to lint */
+  }
+  return warns;
+}
+
+/**
+ * A test-data file no feature loads is dead in full: the runtime reads only
+ * `<feature>.yaml` and its `<feature>.<env>.yaml` overlays. Typically a `<unit>.yaml` written by
+ * hand next to a feature `add --path` named after the URL — its keys never reach a test.
+ * Every existing feature file counts (even one that failed to parse), so a parse error never
+ * turns its data into a false "loaded by no feature".
+ */
+function unloadedTestDataFiles(screenDir: string, featureNames: string[]): DataDrivenWarning[] {
+  let files: string[];
+  try {
+    files = fs.readdirSync(path.join(screenDir, 'test-data')).filter((f) => /\.ya?ml$/.test(f) && !f.startsWith('_'));
+  } catch {
+    return [];
+  }
+  const loaded = (stem: string): boolean => featureNames.some((n) => stem === n || stem.startsWith(`${n}.`));
+  return files
+    .filter((f) => !loaded(f.replace(/\.ya?ml$/, '')) || !f.endsWith('.yaml'))
+    .map((f) => ({
+      message: `test-data/${f} is loaded by no feature — the runtime reads test-data/<feature>.yaml (+ <feature>.<env>.yaml) for ${featureNames.map((n) => `${n}.feature`).join(', ')}: move its keys there or remove it.`,
+    }));
+}
 
-  const tdPath = path.join(screenDir, 'test-data', `${base}.yaml`);
-  const td: Record<string, any> = tdPath && fs.existsSync(tdPath) ? parseYaml(fs.readFileSync(tdPath, 'utf8')) || {} : {};
+function lintFeature(feature: FeatureUnderLint, ctx: UnitLintContext): DataDrivenWarning[] {
+  const { screenName, cwd, fileRefs, apiParams } = ctx;
+  const { scenarios, tags: featureTags } = feature;
+  const tdFile = `test-data/${feature.name}.yaml`;
+  const tdPath = path.join(ctx.screenDir, 'test-data', `${feature.name}.yaml`);
+  const td: Record<string, any> = fs.existsSync(tdPath) ? parseYaml(fs.readFileSync(tdPath, 'utf8')) || {} : {};
   const topKeys = new Set(Object.keys(td));
   const warns: DataDrivenWarning[] = [];
+  // H3: an `@extend:<base>` scenario runs the base's steps first — the base's captures bind for it.
+  // Per feature, like the compiler's steps registry: an `@extend` never reaches another file's base.
+  const stepsBase = new Map<string, ParsedScenario>();
+  for (const sc of scenarios) if (sc.stepsName) stepsBase.set(sc.stepsName, sc);
   // Bindings a `@beforeAll` hook's `@api:`/`@query:` preconditions make are readable from EVERY
   // scenario of the feature (the compiler registers them feature-wide). A `remember … as` inside the
   // hook is NOT — it stays hook-local — so only the tag-bound names are exempted here.
@@ -186,18 +257,12 @@ export function lintDataDriven(screenDir: string, cwd: string = process.cwd()):
     if (sc.hookType !== 'beforeAll') continue;
     for (const t of sc.tags || []) { const m = t.match(/^@(?:api|query):([A-Za-z_]\w*)/); if (m) featureBound.add(m[1]); }
   }
-  // H3: an `@extend:<base>` scenario runs the base's steps first — the base's captures bind for it.
-  const stepsBase = new Map<string, ParsedScenario>();
-  for (const sc of scenarios) if (sc.stepsName) stepsBase.set(sc.stepsName, sc);
-  // `{{key}}` refs carried by the unit's selectors (i18n) and mock catalog are live too.
-  const fileRefs = refsInUnitFiles(screenDir);
   // A feature-level `@manual` makes every scenario manual (the whole file is skipped by the compiler).
   const featureManual = featureTags.some((t) => t === '@manual' || t.startsWith('@manual:'));
 
   // What the scenarios bind, collected up front — the @query pass below adds the params it binds by name.
   const usedHeads = new Set<string>();
   const usedDatasets = new Set<string>();
-  const apiParams = apiParamsByName(screenName, cwd);
   for (const h of fileRefs) usedHeads.add(h);
   for (const sc of scenarios) {
     for (const r of collectRefs(sc, featureManual || isManualScenario(sc))) usedHeads.add(r.split(/[.[]/)[0]);
@@ -228,7 +293,7 @@ export function lintDataDriven(screenDir: string, cwd: string = process.cwd()):
       const ds = casesTag.slice('@cases:'.length).trim();
       const rows = td[ds];
       if (!Array.isArray(rows)) {
-        warns.push({ scenario: sc.name, message: `@cases:${ds} → dataset "${ds}" is missing or not a list in test-data.` });
+        warns.push({ scenario: sc.name, message: `@cases:${ds} → dataset "${ds}" is missing or not a list in ${tdFile}.` });
       } else {
         const colSets = rows.map((r) => new Set(Object.keys(r || {}).filter((k) => !ROW_META.has(k))));
         const allCols = new Set<string>();
@@ -256,7 +321,7 @@ export function lintDataDriven(screenDir: string, cwd: string = process.cwd()):
       for (const r of refs) {
         const head = r.split(/[.[]/)[0];
         if (head.startsWith('$') || bound.has(head) || featureBound.has(head) || topKeys.has(head)) continue;
-        warns.push({ scenario: sc.name, message: `{{${r}}} is not a test-data key and nothing binds it at run time — it compiles to the literal text '\${${r}}' (add the key to test-data, or fix the ref).` });
+        warns.push({ scenario: sc.name, message: `{{${r}}} is not a test-data key and nothing binds it at run time — it compiles to the literal text '\${${r}}' (add the key to ${tdFile}, or fix the ref).` });
       }
     }
 
@@ -289,15 +354,8 @@ export function lintDataDriven(screenDir: string, cwd: string = process.cwd()):
   for (const k of topKeys) {
     if (k.startsWith('_')) continue; // Data Factory metadata, not scenario data
     if (!usedHeads.has(k) && !usedDatasets.has(k)) {
-      warns.push({ message: `test-data key "${k}" is defined but never referenced ({{${k}}}, a @cases dataset, or an override) — dead data: bind it into a scenario or remove it.` });
+      warns.push({ message: `test-data key "${k}" is defined but never referenced ({{${k}}}, a @cases dataset, or an override) by ${feature.name}.feature — dead data: bind it into a scenario or remove it from ${tdFile}.` });
     }
   }
-
-  // Catalog-level lint (SELECT-only, params declared/used, datasource present).
-  try {
-    for (const e of lintCatalog(screenName, null, cwd).errors) warns.push({ message: e });
-  } catch {
-    /* no catalog → nothing to lint */
-  }
   return warns;
 }

package/src/harness/next-step.ts

@@ -170,6 +170,7 @@ const REPAIRABLE = [
   'SPEC-RESTATED-UNVERIFIED', 'VIEWPOINT-GESTURE-SUBSTITUTED', 'SPEC-UNCOVERED', 'SPEC-CLAUSE-UNCOVERED',
   'TRIGGER-UNCOVERED', 'PERMISSION-PAIR-MISSING', 'VISIBILITY-PAIR-MISSING',
   'VIEWPOINT-ITEM-MISSING', 'MANUAL-CODE-MISSING', 'MANUAL-AUTOMATABLE', 'DEPTH-DEFERRED',
+  'UI-INVENTORY-MISSING', 'UI-INVENTORY-INCOMPLETE', 'UI-ITEM-UNCOVERED',
 ];
 
 /**

package/src/harness/parse.ts

@@ -7,7 +7,7 @@
  */
 import * as fs from 'fs';
 import { GherkinParser, ParsedScenario, ParsedStep } from '../generators/gherkin-parser';
-import { readTextFile } from './read-text';
+import { readTextFile, readViewpointText } from './read-text';
 import { featureFilesFor } from './unit-paths';
 
 export type Priority = 'high' | 'normal' | 'low' | 'unknown';
@@ -15,10 +15,49 @@ export type Priority = 'high' | 'normal' | 'low' | 'unknown';
 export interface ViewpointEntry {
   id: string;            // e.g. VP-DATA-CONSISTENCY
   priority: 'High' | 'Medium' | 'Low' | 'Unknown';
+  /** The declared priority word as written (`critical` · `high` · `medium` · `normal` · `low` ·
+   *  `deferred` · `skip`, which also stands for skipped / n/a / none / not applicable), kept because `priority` folds several of them together and the
+   *  PRIORITY-CONTRADICTED check needs them apart. Absent when no priority was declared. */
+  priorityWord?: string;
   reason: string;
   group?: 'Required' | 'Recommended' | 'Optional';
 }
 
+/**
+ * Whole SECTIONS that declare something ABOUT the checklist rather than listing claims or
+ * viewpoints — known issues, traceability indexes, references, changelogs. Shared by the atomic
+ * ledger (their rows are not claims to prove, #630) and the viewpoint-overview parser (an id
+ * listed there is a reference, not a declaration, #833). `UI Patterns Identified` is the author's
+ * pick of WHICH sungen-viewpoint patterns apply — a `Skip` row there is not a claim to cover (#841).
+ * A `How to run` / `Procedure` section — that exact heading, optionally naming one id — is a manual
+ * check's steps, not claims of its own (#855); `How to test the login flow` stays a normal section.
+ */
+export const NON_DECLARATION_SECTION = /^(?:(?:ui patterns?(?: identified)?|(?:how to (?:run|test|reproduce|verify)|(?:manual )?procedures?)(?:\s+(?:vp|fl)-[^\s:]+)?)\s*:?$|(?:known issues?|open questions?|deferred|out of scope|viewpoint grouping|traceability|metadata|scope|journey phases?|revision history|references?|sources?|changelog)\b)/i;
+
+/**
+ * Every word a viewpoint row may declare as its priority — ONE list for the overview parser, the
+ * atomic ledger and the integrity checks, which each carried their own copy and all missed the
+ * `Skip` that the `sungen add` / `add-flow` scaffolds themselves suggest (#853). `deferred` and the
+ * not-applicable words are declarations as well: such a row is not a claim to cover.
+ */
+export const PRIORITY_WORDS = 'critical|high|medium|normal|low|deferred|skip(?:ped)?|n\\/a|none|not applicable';
+/** "Declared not applicable" — folded to `skip` so every consumer checks one word. */
+const NOT_APPLICABLE = /^(?:skip(?:ped)?|n\/a|none|not applicable)$/i;
+
+// The whole cell must BE the word (emphasis aside), as the old `| VP-… | high |` scan required:
+// "Low risk" or "Not high" declares no priority.
+const PRIORITY_WORD = new RegExp(`^[\\s*_\`]*(${PRIORITY_WORDS})[\\s*_\`.]*$`, 'i');
+/** Header names of a priority column, in the languages viewpoint files are written in. */
+const PRIORITY_HEADER = /^(?:priority|pri|level|severity|優先度?|độ ưu tiên|ưu tiên)(?:\s|\(|$)/i;
+
+/** A priority cell → the folded level plus the word as written. */
+function priorityOf(cell: string): { priority: ViewpointEntry['priority']; priorityWord?: string } {
+  const raw = cell.match(PRIORITY_WORD)?.[1].toLowerCase();
+  const word = raw && NOT_APPLICABLE.test(raw) ? 'skip' : raw;
+  const priority = /high/i.test(cell) ? 'High' : /medium/i.test(cell) ? 'Medium' : /low/i.test(cell) ? 'Low' : 'Unknown';
+  return word ? { priority, priorityWord: word } : { priority };
+}
+
 export interface ScenarioInfo {
   name: string;
   vpCode?: string;       // VP-CART-001 style code in the scenario title
@@ -39,8 +78,10 @@ export interface ScenarioInfo {
   exploration?: boolean;      // @exploration — a probe outside the official suite, exempt from source tracing
   deferredToFlow?: boolean;   // @deferred:flow — owned by a flow, not automated on this screen (H6)
   ownedByFlow?: string;       // @owned-by:<flow> — the flow that owns this deferred scenario (H6)
+  featureManual?: boolean;    // its Feature is tagged @manual — codegen skips the whole file (#835)
   /** Ordered steps with their resolved bucket (And/But inherit) — flow handoff analysis (#569). */
-  steps?: Array<{ bucket: 'given' | 'when' | 'then'; text: string }>;
+  /** `arg` = the step's data table, normalised (#817) — absent when the step has none. */
+  steps?: Array<{ bucket: 'given' | 'when' | 'then'; text: string; arg?: string }>;
   /**
    * The `.feature` this scenario was read from. A unit may hold several (`add --feature`), and
    * `scenarioIdReuse` scopes its uniqueness check to ONE file — so the sensor needs to know
@@ -106,7 +147,7 @@ function headingParts(line: string): { level: number; text: string } | null {
 
 export function parseViewpointOverview(filePath: string): ViewpointEntry[] {
   if (!fs.existsSync(filePath)) return [];
-  const text = readTextFile(filePath);
+  const text = readViewpointText(filePath);
   const lines = text.split('\n');
 
   const entries = new Map<string, ViewpointEntry>();
@@ -125,8 +166,7 @@ export function parseViewpointOverview(filePath: string): ViewpointEntry[] {
         // and an id read with its emphasis markers still attached matches no scenario tag.
         const id = cells[0].replace(/[*`]/g, '').trim();
         if (isViewpointId(id) && !/^-+$/.test(cells[1])) {
-          const pr = /high/i.test(cells[1]) ? 'High' : /medium/i.test(cells[1]) ? 'Medium' : /low/i.test(cells[1]) ? 'Low' : 'Unknown';
-          entries.set(id.toUpperCase(), { id: id.toUpperCase(), priority: pr as any, reason: cells[2] });
+          entries.set(id.toUpperCase(), { id: id.toUpperCase(), ...priorityOf(cells[1]), reason: cells[2] });
         }
       }
     }
@@ -179,6 +219,52 @@ export function parseViewpointOverview(filePath: string): ViewpointEntry[] {
     }
   }
 
+  // 3) ID-first tables (#833): per-axis tables such as `| ID | Priority | Input | Expected |`.
+  // A row whose FIRST cell is a viewpoint id declares that id — the same rows the
+  // PRIORITY-CONTRADICTED check always read, so the two readers now agree. Kept narrow on purpose,
+  // because a viewpoint file also holds tables that only MENTION ids:
+  //  - the id must be a `VP-`/`FL-` id, or belong to a family this file already declared above
+  //    (`MS-HP` in Priority Viewpoints → `MS-HP-001`); `TC-01`, `FR-001`, `ISO-27001` never are;
+  //  - reference sections (Known Issues, Traceability…) are skipped WITH their subsections, the
+  //    way the ledger inherits the exclusion (#657), and fenced blocks are skipped;
+  //  - the header is the row directly above a `|---|` separator (structure, not guessed words);
+  //    its Priority column (any position, any alias) gives the priority, else column 2 does, as
+  //    the old scan read it;
+  //  - `reason` stays empty: viewpoint reasons feed page-type detection, and these rows were never
+  //    entries before — the page type of an untouched file must not move.
+  const declaredFamilies = [...entries.keys()];
+  const familyOk = (id: string): boolean =>
+    /^(?:VP|FL)-/i.test(id) || declaredFamilies.some((f) => id.startsWith(`${f}-`) || id === f);
+  const isSeparator = (l: string): boolean => /^\|[\s|:-]+\|?$/.test(l) && l.includes('-');
+  let excludedAt: number | null = null;
+  let inFence = false;
+  let priorityCol = 1;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (/^(```|~~~)/.test(line)) { inFence = !inFence; continue; }
+    if (inFence) continue;
+    const head = headingParts(line);
+    if (head) {
+      if (excludedAt !== null && head.level > excludedAt) continue;          // subsection inherits
+      const text = head.text.replace(/[*`]/g, '').trim();
+      excludedAt = /^Priority Viewpoints/i.test(text) || NON_DECLARATION_SECTION.test(text) ? head.level : null;
+      continue;
+    }
+    if (excludedAt !== null || !line.startsWith('|') || isSeparator(line)) continue;
+    const cells = line.split('|').map((c) => c.trim()).filter((_, k, a) => k > 0 && k < a.length - 1);
+    if (isSeparator((lines[i + 1] ?? '').trim())) {                          // header row
+      const col = cells.findIndex((c) => PRIORITY_HEADER.test(c.replace(/[*`]/g, '').trim()));
+      priorityCol = col >= 0 ? col : 1;
+      continue;
+    }
+    const id = (cells[0] ?? '').replace(/[*`]/g, '').trim().toUpperCase();
+    if (!isViewpointId(id) || !familyOk(id)) continue;
+    const declared = priorityOf(cells[priorityCol] ?? '');
+    const existing = entries.get(id);
+    if (!existing) entries.set(id, { id, ...declared, reason: '' });
+    else if (!existing.priorityWord && declared.priorityWord) existing.priorityWord = declared.priorityWord;
+  }
+
   return [...entries.values()];
 }
 
@@ -246,22 +332,20 @@ function classifyScenario(sc: ParsedScenario): ScenarioInfo {
   const skeletonParts: string[] = [];
   const textParts: string[] = [sc.name];
   const stepTextParts: string[] = [];
-  const orderedSteps: Array<{ bucket: 'given' | 'when' | 'then'; text: string }> = [];
+  const orderedSteps: Array<{ bucket: 'given' | 'when' | 'then'; text: string; arg?: 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);
-    orderedSteps.push({ bucket: (kw === 'And' || kw === 'But' ? last : kw).toLowerCase() as 'given' | 'when' | 'then', text: 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
-      .replace(/\{\{[^}]*\}\}/g, '{}')
-      .replace(/"[^"]*"/g, '""')
-      .replace(/\s+/g, ' ')
-      .trim()
-      .toLowerCase();
+    // The data table is part of what a step says (#817): `User see tab order:` with [FieldA]→[Cancel]
+    // and with [Save]→[Close] are different tests, and comparing step text alone called them exact
+    // duplicates and one oracle asserted N times. Kept OUT of `text`, which the claim/keyword sensors
+    // read as prose.
+    const arg = tableArg(step);
+    orderedSteps.push({ bucket: (kw === 'And' || kw === 'But' ? last : kw).toLowerCase() as 'given' | 'when' | 'then', text: step.text, ...(arg ? { arg } : {}) });
+    const skel = skeletonOf(step.text) + (arg ? ` ${skeletonOf(arg)}` : '');
     skeletonParts.push(`${kw === 'And' || kw === 'But' ? last : kw}:${skel}`);
 
     if (last === 'Then') {
@@ -309,9 +393,11 @@ export function loadScenarios(featurePath: string): ScenarioInfo[] {
   if (!fs.existsSync(featurePath)) return [];
   const parser = new GherkinParser();
   const feature = parser.parseFeatureFile(featurePath);
+  // Kept apart from `manual` so the audit's accounting is unchanged; only `select` reads it.
+  const featureManual = (feature.tags || []).some((t: string) => /^@manual\b/i.test(t)) || undefined;
   return (feature.scenarios || [])
     .filter((s) => !s.stepsName && !s.hookType) // skip @steps/@hook blocks
-    .map((s) => ({ ...classifyScenario(withBackground(s, feature.background)), sourceFile: featurePath }));
+    .map((s) => ({ ...classifyScenario(withBackground(s, feature.background)), sourceFile: featurePath, featureManual }));
 }
 
 /**
@@ -334,3 +420,24 @@ export function readUnitFeatureText(unitDir: string, unit: string): string {
     .map((p) => readTextFile(p))
     .join('\n');
 }
+
+/**
+ * Normalised skeleton of step text: keep [refs] (distinct targets = distinct tests), but neutralise
+ * {{vars}} and quoted values so EP/data families collapse.
+ */
+function skeletonOf(text: string): string {
+  return text
+    .replace(/\{\{[^}]*\}\}/g, '{}')
+    .replace(/"[^"]*"/g, '""')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLowerCase();
+}
+
+/** A step's data table as one comparable string — `<h1|h2 / c1|c2 / …>` — or undefined. */
+function tableArg(step: ParsedStep): string | undefined {
+  const t = step.dataTable;
+  if (!t || (!t.headers.length && !t.rows.length)) return undefined;
+  const rows = [t.headers, ...t.rows.map((r) => r.cells)].map((cells) => cells.map((c) => c.trim()).join('|'));
+  return `<${rows.join(' / ')}>`;
+}