@sun-asterisk/sungen 3.2.32 → 3.2.34

package/src/harness/catalog/universal-viewpoints.yaml

@@ -24,7 +24,7 @@ page_types:
     detect_keywords: [cart, product, checkout, catalog, brand, category, "add to cart"]
     must_cover:
       - theme: list-data
-        keywords: [list, displayed, card, "product card", grid]
+        keywords: ["product list", displayed, card, "product card", grid]
         depth:
           requires: data-assertion
           cross_screen: false
@@ -38,7 +38,7 @@ page_types:
           keywords: ["product detail", "detail page", "same product name", "matching name", "consistency", "same price"]
           template: "User remember [Product Name] text as {{v}} … User see [Detail Product Name] header with {{v}}"
       - theme: cart-correctness
-        keywords: ["cart contains", quantity, "price", subtotal, "in cart", "cart content", "cart product"]
+        keywords: ["cart contains", "cart quantity", "cart price", subtotal, "in cart", "cart content", "cart product"]
         depth:
           requires: data-assertion
           cross_screen: true
@@ -77,7 +77,7 @@ page_types:
           keywords: ["required", "must be", "error message", "validation message"]
           template: "User see [Field Error] message with {{error_text}}"
       - theme: format-boundary
-        keywords: [format, invalid, boundary, length, range]
+        keywords: [format, invalid, boundary, "max length", "min length", range]
         depth:
           requires: data-assertion
           cross_screen: false
@@ -125,10 +125,10 @@ page_types:
   # suite, which is a scoring decision for an owner, not a drive-by. `viewpoint-ledger` already
   # covers the dangerous half by refusing `tap [Back]` as an answer to an OS-back viewpoint item.
   mobile-list:
-    detect_keywords: [feed, "pull to refresh", "infinite scroll", "load more", "list item", "list row"]
+    detect_keywords: ["feed item", "pull to refresh", "infinite scroll", "load more", "list item", "list row"]
     must_cover:
       - theme: list-data
-        keywords: [list, feed, row, "list item", displayed]
+        keywords: ["feed item", row, "list item", displayed]
         depth:
           requires: data-assertion
           cross_screen: false

package/src/harness/config-file.ts

@@ -0,0 +1,66 @@
+/**
+ * Reading a config file has THREE outcomes, not two: absent, parsed, and present-but-unreadable.
+ *
+ * Collapsing the third into the first is the defect class #782 catalogues. The shape recurs because
+ * it looks harmless: an `fs.existsSync` guard already answers absence, so the `catch` below it only
+ * ever fires for CORRUPTION — and returning the absent value there is the one case that must not be
+ * silent. A file that is absent was never written; a file that is broken WAS written, by someone who
+ * believes it is in effect.
+ *
+ * `run-manifest.ts:hashTopLevel` already draws the distinction for its own reader (`__unparseable__`
+ * rather than `{}`); this is that idea as a seam every config reader can share, so the next one does
+ * not have to rediscover it.
+ *
+ * Nothing here throws: the caller owns the consequence, because only the caller knows it. What the
+ * type removes is the option of not deciding.
+ */
+import * as fs from 'fs';
+import { parse as parseYaml } from 'yaml';
+
+export type ConfigRead<T> =
+  | { state: 'absent' }
+  | { state: 'ok'; value: T }
+  | { state: 'unreadable'; error: string };
+
+const message = (e: unknown): string => (e instanceof Error ? e.message.split('\n')[0] : String(e));
+
+/** Read + parse a YAML config. An empty or comment-only file parses to null — that is `ok`, not broken. */
+export function readYamlConfig<T>(file: string): ConfigRead<T> {
+  if (!fs.existsSync(file)) return { state: 'absent' };
+  try {
+    return { state: 'ok', value: (parseYaml(fs.readFileSync(file, 'utf-8')) ?? null) as T };
+  } catch (e) {
+    return { state: 'unreadable', error: message(e) };
+  }
+}
+
+/** Read + parse a JSON config. Unlike YAML, an empty file is NOT valid JSON and reads as unreadable. */
+export function readJsonConfig<T>(file: string): ConfigRead<T> {
+  if (!fs.existsSync(file)) return { state: 'absent' };
+  try {
+    return { state: 'ok', value: JSON.parse(fs.readFileSync(file, 'utf-8')) as T };
+  } catch (e) {
+    return { state: 'unreadable', error: message(e) };
+  }
+}
+
+/**
+ * One line to stderr naming the file, the parse error, and WHAT THE RUN WILL DO INSTEAD — the last
+ * part is the whole point: "capabilities.yaml is broken" leaves the reader guessing; "…so this run
+ * treats the project as web" tells them why their mobile suite just compiled wrong.
+ *
+ * At most once per file per process. `readCapabilities` alone has fifteen call sites, and a warning
+ * repeated fifteen times reads as noise — which is its own way of being ignored.
+ */
+const warned = new Set<string>();
+
+export function warnUnreadableConfig(file: string, error: string, consequence: string): void {
+  if (warned.has(file)) return;
+  warned.add(file);
+  console.error(`⚠️  ${file}: unreadable (${error}) — ${consequence}`);
+}
+
+/** Test seam: the dedup set is process-global, so a suite exercising several cases must clear it. */
+export function resetUnreadableConfigWarnings(): void {
+  warned.clear();
+}

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/depth-lint.ts

@@ -15,6 +15,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { loadUnitScenarios, parseViewpointOverview, ScenarioInfo, ViewpointEntry } from './parse';
 import { loadCatalog, viewpointGate, assertionDepth, dataThemesFor, CatalogTheme } from './sensors';
+import { keywordHit } from './keyword-match';
 
 export type DepthAction = 'deepen' | 'defer';
 
@@ -45,7 +46,7 @@ export interface DepthLintReport {
 function matchTheme(s: ScenarioInfo, dataThemes: CatalogTheme[]): CatalogTheme | undefined {
   return dataThemes.find((t) => {
     const kws = t.depth?.keywords?.length ? t.depth.keywords : t.keywords;
-    return kws.some((k) => s.haystack.includes(k.toLowerCase()));
+    return kws.some((k) => keywordHit(s.haystack, k));
   });
 }
 

package/src/harness/flow-check.ts

@@ -12,6 +12,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { featureFilesFor } from './unit-paths';
+import { keywordHit } from './keyword-match';
 import { loadScenarios } from './parse';
 import { parseScenarios } from './capability-plan';
 import { readTextFile } from './read-text';
@@ -45,7 +46,10 @@ function featureTags(fp: string): string[] {
 }
 function targetsFromHint(hint: string): string[] {
   const h = hint.toLowerCase();
-  const hits = KNOWN_TARGETS.filter((k) => h.includes(k));
+  // Word-aware (#779): every KNOWN_TARGET is an ordinary noun, so a substring test read
+  // `re·order` / `dis·order` as the target `order` and then matched the two to each other —
+  // a deferral about reorder history reported COVERED by a flow scenario about a disorder.
+  const hits = KNOWN_TARGETS.filter((k) => keywordHit(h, k));
   if (hits.length) return hits;
   // fallback: significant words after "->"
   const after = h.split('->').pop() || h;
@@ -87,7 +91,7 @@ export function buildFlowCheck(cwd: string, onlyFlow?: string): FlowCheckReport
       // `@owned-by:<flow>` names the owner explicitly → only that flow's scenarios can cover it
       // (a false @owned-by is then surfaced as missing). Else any flow may cover it (legacy).
       const pool = s.ownedBy ? flowScenarios.filter((fs2) => fs2.flow === s.ownedBy) : flowScenarios;
-      const matches = pool.filter((fs2) => targets.some((t) => fs2.haystack.includes(t)));
+      const matches = pool.filter((fs2) => targets.some((t) => keywordHit(fs2.haystack, t)));
       let verdict: Deferral['verdict'] = 'missing';
       let via: string | undefined;
       if (matches.some((m) => m.deep)) { verdict = 'covered'; via = matches.find((m) => m.deep)!.flow; }

package/src/harness/keyword-match.ts

@@ -0,0 +1,85 @@
+/**
+ * Keyword matching for the audit's coverage sensors — the single rule every "does a scenario
+ * mention this?" question goes through.
+ *
+ * WHY THIS EXISTS (#776). The sensors used to ask `haystack.includes(keyword)`. A substring match
+ * is satisfied by a keyword buried inside an unrelated word, and it fails in the direction that
+ * HIDES problems: a theme nobody tested reads as covered. Measured case — the scenario title
+ * "…five steps from email through to information entry" made `format-boundary` covered on a screen
+ * with no text input at all, because in·format·ion contains `format`. That one word moved the
+ * screen from 7.9 FAIL to 8.9 PASS.
+ *
+ * THE RULE: anchor a word boundary at the START of the keyword, leave the END free.
+ *
+ * Not `\b…\b` at both ends, which is the obvious fix and is wrong. Every collision this defect
+ * produces is a PREFIX collision — the innocent word carries extra letters BEFORE the keyword:
+ *
+ *     format  ← in·format·ion, ·format·ting        range   ← ar·range·ment, o·range
+ *     saved   ← un·saved                           created ← re·created
+ *     success ← un·success·ful                     length  ← wave·length
+ *
+ * The `unsaved` / `unsuccessful` pair is the sharp end: the prefix INVERTS the meaning, so a
+ * scenario asserting a submit FAILED is what marks the submit-SUCCESS theme covered.
+ *
+ * Meanwhile English inflection lives entirely in the SUFFIX, and a trailing `\b` destroys it:
+ * `submit` stops matching "submitted", `success` stops matching "successfully", `valid` stops
+ * matching "validation", `create` stops matching "created". Those are true positives, and a
+ * both-ends boundary turns 4 of 5 of them into false gaps — trading a silent failure for a noisy
+ * one. A leading boundary alone kills all six collisions above and keeps all of them.
+ *
+ * WHAT THIS RULE DOES NOT FIX, stated rather than implied. A free suffix still admits a collision
+ * when the keyword is a true PREFIX of a common unrelated word:
+ *
+ *     feed → "feedback"    list → "listener"    length → "lengthy"
+ *
+ * No boundary rule can separate `feed` from `feedback`, so the cure is a less ambiguous KEYWORD,
+ * which is a catalog decision rather than a matcher one. #778 took it: the shipped catalog no
+ * longer carries any of the three bare forms — `"product list"`, `"feed item"` and
+ * `"max length"` / `"min length"` replaced them, and `cart-correctness` lost bare `price` and
+ * `quantity` (ordinary listing vocabulary that credited a cart theme on a screen with no cart).
+ *
+ * That closes today's instances, not the class. `tests/harness/keyword-word-boundary.run.ts`
+ * section (e) sweeps every single-word ASCII keyword in the catalog — theme `keywords`,
+ * `detect_keywords` and `depth.keywords` alike — so a NEW loose keyword fails the suite instead of
+ * entering silently. Adding one is possible, but only as a conscious act via that file's
+ * `KNOWN_LOOSE` map, which #778 left empty.
+ *
+ * NON-ASCII KEYWORDS fall back to substring, on purpose. JavaScript's `\b` is defined against
+ * `[A-Za-z0-9_]`, so `\bログイン` and `\bđăng nhập` never match anything at all — the anchor would
+ * silently disable the keyword rather than tighten it. Japanese and Chinese have no word
+ * boundaries to anchor to, which is precisely where substring matching is the CORRECT behaviour
+ * and the false-positive risk is low. Today every keyword reaching here is ASCII by construction
+ * (the catalog is English; the ledger and spec sensors extract words with `[a-z]` character
+ * classes), so this branch is a guard against a future non-ASCII catalog entry failing closed.
+ */
+
+/** True when `kw`'s first character can carry a `\b` anchor — i.e. it is an ASCII word character. */
+const anchorable = (kw: string): boolean => /^[a-z0-9_]/i.test(kw);
+
+const cache = new Map<string, RegExp | null>();
+
+/**
+ * Compile `kw` to its matcher, or `null` when the keyword must be compared as a plain substring.
+ * Cached: the sensors re-ask the same handful of catalog keywords once per scenario.
+ */
+function matcherFor(kw: string): RegExp | null {
+  const key = kw.toLowerCase();
+  if (cache.has(key)) return cache.get(key)!;
+  const re = anchorable(key)
+    ? new RegExp(`\\b${key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`)
+    : null;
+  cache.set(key, re);
+  return re;
+}
+
+/** Does `haystack` mention `kw` as a word (not as the tail of a longer one)? */
+export function keywordHit(haystack: string, kw: string): boolean {
+  const h = haystack.toLowerCase();
+  const re = matcherFor(kw);
+  return re ? re.test(h) : h.includes(kw.toLowerCase());
+}
+
+/** Does ANY of `haystacks` mention `kw`? */
+export function hasKeyword(haystacks: string[], kw: string): boolean {
+  return haystacks.some((h) => keywordHit(h, kw));
+}

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(' / ')}>`;
+}