@sun-asterisk/sungen 3.2.34-beta.1 → 3.2.35

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

@@ -1 +1,13 @@
-await {{> locator}}.fill('{{escapeQuotes fillValue}}');
+{{#if guardFillable~}}
+{{!-- A recipe-less date-picker / button / link: Playwright's own "Element is not an <input>" names
+      no fix when the target is a trigger that opens a calendar popup. Keep Playwright's semantics
+      (it also fills a <label>'s control or a contenteditable child) and only re-word that one
+      failure with the way forward (#907). --}}
+try {
+await {{> locator}}.fill('{{escapeQuotes fillValue}}');
+} catch (e) {
+if (!/is not an <input>/.test(String(e))) throw e;
+throw new Error('[sungen] [{{escapeQuotes selectorRef}}] is not a fillable element (a button or popup trigger opens a picker). Declare its choreography as a recipe with a fill intent (and an assertValue intent) in qa/app.yaml and point the selector at it with variant: <recipe>, or widgets.datepicker for every date-picker.');
+}
+{{else~}}
+await {{> locator}}.fill('{{escapeQuotes fillValue}}');{{/if}}

package/src/generators/test-generator/adapters/playwright/templates/steps/assertions/contain-text-assertion.hbs

@@ -1 +1,9 @@
-await expect({{> locator}}).toContainText('{{escapeQuotes expectedText}}');
+{{#if emptyMeansEmpty~}}
+{{!-- toContainText('') passes for ANY text — the empty string is a substring of everything — so an
+      "is empty" check would assert nothing. An empty expected value means the element shows no text (#910). --}}
+{ const __expected = '{{escapeQuotes expectedText}}';
+if (__expected === '') await expect({{> locator}}).toHaveText('');
+else await expect({{> locator}}).toContainText(__expected);
+}
+{{else~}}
+await expect({{> locator}}).toContainText('{{escapeQuotes expectedText}}');{{/if}}

package/src/generators/test-generator/adapters/playwright/templates/steps/assertions/expanded-assertion.hbs

@@ -0,0 +1,12 @@
+{{!-- `see [X] is expanded | is collapsed` (#911). Reads the signal expand-action.hbs drives — a class
+      on a descendant, a declared boolean attribute, else aria-expanded — but with no "only if the
+      element exposes it" escape: an assertion that can skip itself asserts nothing. --}}
+{{#if expanded.class}}
+{{#if (eq direction 'expand')}}
+await expect({{> locator}}.locator('.{{escapeQuotes expanded.class}}')).toBeVisible();
+{{~else~}}
+await expect({{> locator}}.locator('.{{escapeQuotes expanded.class}}')).toHaveCount(0);
+{{~/if}}
+{{~else~}}
+await expect({{> locator}}).toHaveAttribute('{{#if expanded.attribute}}{{escapeQuotes expanded.attribute}}{{else}}aria-expanded{{/if}}', '{{#if (eq direction 'expand')}}true{{else}}false{{/if}}');
+{{~/if}}

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

@@ -1187,9 +1187,9 @@ export class CodeGenerator {
   ): { preconditions: CapabilityPrecondition[]; casesDataset?: string } {
     this.stepMapper.setScenarioContext(stepsToMap);
 
-    // Data-driven (@cases): the scenario's {{col}} refs are dataset *row columns* that
-    // exist only at runtime — register them as captured so they resolve to a runtime
-    // get() (→ rowData.get) instead of compile-time YAML lookup.
+    // Data-driven (@cases): the scenario's {{col}} refs that are dataset *row columns* exist
+    // only at runtime — they resolve to a runtime get() (→ rowData.get) instead of a compile-time
+    // YAML lookup. A plain test-data key stays readable at compile time (#950).
     const casesTag = scenario.tags.find((t) => t.startsWith('@cases:'));
     const casesDataset = casesTag ? casesTag.slice('@cases:'.length).trim() : undefined;
     if (casesDataset) {
@@ -1197,7 +1197,7 @@ export class CodeGenerator {
       for (const st of stepsToMap) {
         for (const m of (st.text || '').matchAll(/\{\{\s*([\w.]+)\s*\}\}/g)) refs.add(m[1]);
       }
-      for (const r of refs) this.stepMapper.registerCaptured(r);
+      this.stepMapper.bindCasesDataset(casesDataset, refs);
     }
 
     const preconditions = this.capabilityPreconditions(scenario);

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

@@ -49,7 +49,8 @@
  *             nothing for the query half to assert, so the step checks the PATH only. Not an
  *             error (the value may legitimately vary per environment), but the step asserts
  *             strictly less than it appears to
- *   SG-W015 — `see [X] card/item with {{n}}` where the value is a bare number: this compiles
+ *   SG-W015 — `see [X] card/item with {{n}}` where the value is a bare number (in @cases: on
+ *             any row), or `see [X] row with {{n}}` whose @cases rows mix numbers and text: this compiles
  *             to a TEXT assertion (toHaveText('3')), NOT a count — an author reaching for
  *             "3 cards are shown" gets an assertion that can only pass if the card's text
  *             IS the digit. Count semantics exist on row/table ("see [T] table with {{n}}",
@@ -67,13 +68,18 @@
  *   SG-E023 — the step carries an assertion clause (`matches "…"`, `contains`, `has text`, a state)
  *             but the generated code is a BARE VISIBILITY check: the clause was swallowed by the
  *             catch-all and the test would pass whatever the element says. Four separate defects
- *             have arrived this way, so the step compiles to a runtime throw instead.
+ *             have arrived this way, so the step compiles to a runtime throw instead. Also a
+ *             trailing `is <word>` / `is not <word>` that is no state (`is on`, `is open`,
+ *             `is not visible`), other than visibility itself (#911).
  *   SG-W017 — a step needs a selector-entry field the entry does not declare, so there is nothing
  *             honest to compile. Today: a table paginate step whose table declares no
- *             `pagination.next`/`.prev` (#712). The mirror of SG-W004 — that one reports a field
+ *             `pagination.next`/`.prev` (#712); `is expanded`/`is collapsed` on an entry declaring
+ *             `expanded.state: none` (#911). The mirror of SG-W004 — that one reports a field
  *             written that nothing reads, this one a field a consumer needs that nobody wrote.
  *             Compiles the step to a loud runtime throw rather than guessing a locator, which is
  *             the #690 failure (a locator no page has, failing far from the cause).
+ *             Also a web `fill [X] date-picker` whose entry locates a `<button>` (a calendar
+ *             trigger) and names no `fill` recipe — `.fill()` cannot type into a button (#907).
  *   SG-W018 — a selectors.yaml entry declares an `nth:` the compiler cannot use (#720). `nth:` was
  *             the one entry field whose VALUE nothing checked: the key is known (SG-W004 quiet) and
  *             the `type:` is valid (SG-E027 quiet), so `nth: -1`, `nth: 'last'`, `nth: 1.5` and

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

@@ -38,6 +38,8 @@ export type StateClause =
   | 'empty'
   | 'loading'
   | 'selected'
+  | 'expanded'
+  | 'collapsed'
   | 'sorted ascending'
   | 'sorted descending';
 

package/src/generators/test-generator/step-mapper.ts

@@ -13,6 +13,9 @@ import { isKnownSelectorType } from './utils/selector-type-validation';
 import { loadAppProfile, ResolvedAppProfile } from './app-profile';
 import { capabilityRegistry } from '../../capabilities/registry';
 
+/** Trailing `is <word>` that a visibility check honestly asserts (SG-E023 lets these through). */
+const VISIBILITY_WORDS = new Set(['visible', 'displayed', 'shown', 'present']);
+
 /**
  * The correction SG-W001 owes a project that gated a platform driver away.
  *
@@ -143,6 +146,10 @@ export class StepMapper {
     this.featurePlatform = featurePlatform;
     this.featurePath = featurePath;
     this.selectorResolver.setFeatureContext(featureName);
+    // Scenario-scoped data state (captured vars, the bound @cases dataset) of the previous feature's
+    // last scenario must not reach this feature's Background, which is mapped before any scenario
+    // resets it: a column `{{k}}` there made a plain `{{k}}` here unreadable (#950).
+    this.dataResolver.clearCaptured();
     // One StepMapper serves every feature in a run, so the step counter that names the
     // generated temporaries (`__t_<n>`) used to carry over between files: a screen's spec
     // then depended on how many steps the PRECEDING files happened to contain — i.e. on
@@ -212,6 +219,23 @@ export class StepMapper {
     this.dataResolver.registerCaptured(name);
   }
 
+  /**
+   * `@cases:<dataset>` — bind the scenario's dataset and register as runtime-only the refs that are
+   * its COLUMNS (each row supplies them). A plain key the base test-data defines stays a normal ref,
+   * so the compiler can still read its value (#950: registering every ref turned
+   * `row with {{rows_per_page}}` into a text assertion). A ref that is neither stays runtime-only,
+   * as before.
+   */
+  bindCasesDataset(dataset: string, refs: Iterable<string>): void {
+    const columns = new Set(this.dataResolver.setCasesDataset(dataset, this.featureName));
+    for (const ref of refs) {
+      const isColumn = columns.has(ref.split(/[.[]/)[0]);
+      if (isColumn || this.dataResolver.peekBaseValue(ref, this.featureName) === undefined) {
+        this.dataResolver.registerCaptured(ref);
+      }
+    }
+  }
+
   /**
    * Register the head of a variable bound by the feature's `@beforeAll` hook. Feature-scoped: it
    * survives setScenarioContext() so every scenario can read `{{head.*}}` as a runtime get().
@@ -291,8 +315,11 @@ export class StepMapper {
         /\bsees?\s+\[/.test(step.text) && /\bwith\b/.test(step.text)) {
       // peekBaseValue reads the literal from test-data even in runtime-data mode,
       // where resolveData returns an opaque marker (never numeric-looking).
+      // Every value the ref takes — a @cases column has one per row (#950).
       let resolvedValue: string | undefined;
-      try { resolvedValue = this.dataResolver.peekBaseValue(step.dataRef, this.featureName); } catch { /* unresolved at compile time → cannot judge */ }
+      try {
+        resolvedValue = this.dataResolver.peekValues(step.dataRef, this.featureName)?.find((v) => /^\d+$/.test(v.trim()));
+      } catch { /* unresolved at compile time → cannot judge */ }
       if (resolvedValue !== undefined && /^\d+$/.test(resolvedValue.trim())) {
         this.diagnostics.add('SG-W015',
           `\`see [${step.selectorRef}] ${step.elementType} with {{${step.dataRef}}}\` compiles to a TEXT assertion toHaveText('${resolvedValue.trim()}'), NOT a count of ${step.elementType}s. For a count use \`see [Ref] row with {{n}}\` / \`see [T] table with {{n}}\` (or a list "should have count"); if '${resolvedValue.trim()}' really is the ${step.elementType}'s text, assert it on a text/label element instead`,
@@ -655,7 +682,8 @@ export class StepMapper {
     if (!/\b(?:urlMatches|expectPage)\(/.test(mapped.code || '')) return;   // both URL-assertion shapes (#662)
     // The base value, never resolveData(): in runtime mode that returns the marker, which carries
     // no query by construction — the diagnostic would then fire on every single step.
-    const value = this.dataResolver.peekBaseValue(step.dataRef, this.featureName);
+    // Any value the ref takes — a @cases column has one per row (#950); the first without a query.
+    const value = this.dataResolver.peekValues(step.dataRef, this.featureName)?.find((v) => !/[?#]/.test(v));
     if (value == null || /[?#]/.test(value)) return;
     this.diagnostics.add('SG-W014',
       `{{${step.dataRef}}} = "${value}" carries no query and no fragment, so this page assertion checks the PATH only. Pass a value like "?q=…" (or drop the "with" and let the step assert a bare page).`,
@@ -856,13 +884,32 @@ export class StepMapper {
       [/\b(?:should\s+have|has)\s+text\b/i, 'has text'],
     ];
     const hit = CLAUSES.find(([re]) => re.test(step.text));
-    if (!hit) return null;
-
-    const reason = `step "${step.text}" carries the clause \`${hit[1]}\` but compiled to a bare `
-      + `visibility check — the clause was dropped, so the assertion would pass whatever the element `
-      + `says. Either the phrasing is not the supported one for that clause (see the `
-      + `sungen-gherkin-syntax reference), or this sungen predates the step: check you are running `
-      + `the project-local compiler (\`npx sungen\`), not an older global one.`;
+    // A trailing `is <word>` that is no state reached a bare visibility check the same way:
+    // `see [Start Date] button is expanded` asserted only that the button was shown, and passed with
+    // the calendar closed (#911); `is not visible` even asserted the OPPOSITE. Known states are
+    // SG-E021's (`step.state` is set). Only what a visibility check honestly asserts passes:
+    // `is visible` and its synonyms, and `is not hidden`. Storage's `is not empty` never gets here —
+    // this guard sees bare visibility code only.
+    let state: string | undefined;
+    if (!hit && !step.state) {
+      const m = maskRefsForMatching(step.text).replace(/\s+/g, ' ').replace(/ ?\.$/, '').toLowerCase()
+        .match(/ (?:is|are)( not| no longer)? ([a-z][\w-]*)$/);
+      const honest = m && (m[1] ? m[2] === 'hidden' : VISIBILITY_WORDS.has(m[2]));
+      if (m && !honest) state = `is${m[1] ?? ''} ${m[2]}`;
+    }
+    if (!hit && !state) return null;
+
+    const reason = state
+      ? `step "${step.text}" ends in \`${state}\`, which is not a sungen state, but compiled to a bare `
+        + `visibility check — the words were dropped, so the step would pass whenever the element is `
+        + `shown. Use a state the compiler asserts (is visible / is hidden / is disabled / is enabled / `
+        + `is checked / is unchecked / is selected / is focused / is empty / is expanded / is collapsed …, `
+        + `see the sungen-gherkin-syntax States list), or tag the scenario @manual.`
+      : `step "${step.text}" carries the clause \`${hit![1]}\` but compiled to a bare `
+        + `visibility check — the clause was dropped, so the assertion would pass whatever the element `
+        + `says. Either the phrasing is not the supported one for that clause (see the `
+        + `sungen-gherkin-syntax reference), or this sungen predates the step: check you are running `
+        + `the project-local compiler (\`npx sungen\`), not an older global one.`;
     this.diagnostics?.add('SG-E023', reason, { feature: this.featureName, step: step.text });
     return {
       code: unsupportedStepCode(reason),

package/src/generators/test-generator/utils/data-resolver.ts

@@ -54,6 +54,7 @@ export class DataResolver {
   /** Clear captured vars — call at the start of each scenario. */
   clearCaptured(): void {
     this.capturedVars.clear();
+    this.casesRows = undefined;
   }
 
   // Vars bound by a `@beforeAll` hook's `@api:`/`@query:` preconditions. The hook runs before every
@@ -131,6 +132,58 @@ export class DataResolver {
     }
   }
 
+  /** The `@cases:<name>` dataset rows of the scenario being compiled (scenario-scoped). */
+  private casesRows?: Array<Record<string, unknown>>;
+
+  /**
+   * Bind the scenario's `@cases` dataset so its values can be judged at compile time, and return its
+   * column names (empty when the dataset cannot be read — the caller then treats every ref as
+   * runtime-only, as before #950).
+   */
+  setCasesDataset(dataset: string | undefined, featureName?: string): string[] {
+    this.casesRows = undefined;
+    if (!dataset || !featureName) return [];
+    try {
+      const rows = this.loadDataFile(featureName, dataset)?.[dataset];
+      if (Array.isArray(rows) && rows.length) {
+        // A scalar row is the `value` column — the runtime cases() wraps it the same way.
+        this.casesRows = rows.map((r) => (r && typeof r === 'object' && !Array.isArray(r) ? r : { value: r }));
+      }
+    } catch {
+      // unreadable dataset → no columns known
+    }
+    return this.casesRows ? [...new Set(this.casesRows.flatMap((r) => Object.keys(r)))] : [];
+  }
+
+  /**
+   * Every value a ref can take at run time, for compile-time judgements: the base value of a plain
+   * key, or — for a column of the scenario's `@cases` dataset — the value on EACH row (a row that
+   * lacks the column falls back to the base key, as `rowData.get()` does). A dataset column used to
+   * be opaque here, so `row with {{n}}` lost its count reading in @cases and the SG-W014 / SG-W015
+   * checks went silent (#950). Undefined when any value cannot be read.
+   */
+  peekValues(dataRef: string, featureName?: string): string[] | undefined {
+    const head = dataRef.split(/[.[]/)[0];
+    if (!this.casesRows?.some((row) => head in row)) {
+      const base = this.peekBaseValue(dataRef, featureName);
+      return base === undefined ? undefined : [base];
+    }
+    const out: string[] = [];
+    for (const row of this.casesRows) {
+      let value: unknown;
+      if (head in row) {
+        value = row;
+        for (const key of dataRef.split('.')) value = value && typeof value === 'object' ? (value as Record<string, unknown>)[key] : undefined;
+      } else {
+        try { value = this.resolveValue(dataRef, featureName); } catch { return undefined; }
+      }
+      if (typeof value === 'number' || typeof value === 'boolean') value = String(value);
+      if (typeof value !== 'string') return undefined;
+      out.push(value);
+    }
+    return out;
+  }
+
   private resolveValue(dataRef: string, featureName?: string): string {
     const { fileName, valuePath } = this.parseDataRef(dataRef, featureName);
     const data = this.loadDataFile(fileName, dataRef);

package/src/generators/test-generator/utils/selector-resolver.ts

@@ -1024,8 +1024,8 @@ export class SelectorResolver {
     // `type: locator` had to be used instead, which no page of the reference says (issue #690).
     //
     // Handled HERE, above the generic `locator:`-field branch below, because that branch returns
-    // strategy 'css' and drops `exact` — putting `upload` in the switch left the two spellings
-    // diverging for any entry that sets `locator:`. `withExtras` still stamps the declared
+    // strategy 'css' — putting `upload` in the switch left the two spellings diverging for any
+    // entry that sets `locator:`. `withExtras` still stamps the declared
     // `selectorType`, so a consumer that needs to tell an upload from a plain locator still can.
     //
     // `exact` is inert for the upload action itself (`setInputFiles` takes no text filter), but it
@@ -1049,6 +1049,7 @@ export class SelectorResolver {
         value: locator,
         locator: locator,
         nth,
+        exact,
       });
     }
 
@@ -1113,11 +1114,18 @@ export class SelectorResolver {
           return resolvedRole;
         }
 
+      // `exact` carries no meaning for getByTestId itself, but text assertions on the entry read it
+      // (`label with {{v}}` → toHaveText vs toContainText). Dropping it here made `exact: true`
+      // inert on a testid entry while working on every other identity strategy (#910).
       case 'testid':
+        // `exact` travels with a testid entry too: the getByTestId locator ignores it, but a step
+        // that compares text (`label with {{v}}`) reads it to pick toHaveText over toContainText.
+        // It used to be dropped here alone, so `exact: true` on a testid entry did nothing (#910).
         return withExtras({
           strategy: 'testid',
           value,
           nth,
+          exact,
         });
 
       case 'label':

package/src/harness/audit.ts

@@ -33,8 +33,6 @@ import { capabilityRegistry } from '../capabilities/registry';
 import { discoverAndRegisterCapabilities } from '../capabilities/discover';
 import { contextRouter } from '../capabilities/context-router';
 import { readTextFile, readViewpointText } from './read-text';
-import { isAiDraft } from './viewpoint-draft-header';
-import { viewpointReviewOpenFindings } from './viewpoint-review-open';
 import { uiInventoryCoverage, uiInventoryFindings, UiInventoryResult } from './ui-inventory';
 import { defectLinkFindings } from './defects';
 
@@ -204,9 +202,6 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   const viewpointBaseline = checkViewpointBaseline(
     projectRootFromScreenDir(screenDir), catalogScreenName, viewpointPath);
   const viewpointText = readViewpointText(viewpointPath);
-  // `drafted-by: ai` — unreviewed until `--accept-viewpoint` removes it. Only a draft that declares ids
-  // has anything to accept; an id-less one is VIEWPOINT-MISSING's to report, not a dead-end finding.
-  const aiDraft = isAiDraft(viewpointText) && viewpointBaseline.status !== 'absent';
   // #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
@@ -356,8 +351,7 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   // so it can only measure what their author already thought of. One field run wrote the file
   // after generating the suite and said so in its own header — and both axes still read 100%,
   // because a first audit records the baseline silently (#622). Untrusted until a human accepts it.
-  // An AI draft rides the same hold: its line is only removed when a human accepts it.
-  const viewpointMoved = viewpointBaseline.status === 'changed' || adoptedPostHoc || aiDraft;
+  const viewpointMoved = viewpointBaseline.status === 'changed' || adoptedPostHoc;
   // #618 — is there a YARDSTICK at all? `atomicLedger` and `traceability` are both measured
   // against test-viewpoint.md, and four more sensors read it (the ledger, the declaration-integrity
   // checks, the browser-gesture check, the continuity check). When the file is absent every one of
@@ -671,12 +665,7 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   } else if (balance.imbalanced && !flowScored) {
     findings.push(`BALANCE: ${balance.note} Stop expanding secondary viewpoints until business-core gaps are filled.`);
   }
-  if (aiDraft) {
-    findings.push(`VIEWPOINT-DRAFT-UNREVIEWED: \`requirements/test-viewpoint.md\` is marked \`drafted-by: ai\` and no QA has accepted it, so it is not recorded as the baseline and \`atomicLedger\` + \`traceability\` are held as unverified — a checklist the AI wrote would otherwise score the suite it generated at 100% by construction. QA: review the claims (add what you care about, delete what you do not), then \`sungen audit --screen ${screenName} --accept-viewpoint\` — it records the baseline and removes the \`drafted-by: ai\` line. A QA decision: an agent presents it and does not run it.`);
-  }
-  // create-test's checklist review of the viewpoint, still waiting for QA — advisory, never scored.
-  findings.push(...viewpointReviewOpenFindings(path.dirname(viewpointPath)));
-  if (adoptedPostHoc && !aiDraft) {   // a draft's own finding already says this and names the accept command
+  if (adoptedPostHoc) {
     findings.push(`VIEWPOINT-ADOPTED-POST-HOC: this is the first audit of \`requirements/test-viewpoint.md\` and the suite ALREADY has ${scenarios.length} scenarios, so the yardstick is being introduced against tests that already exist. A declaration written after the suite can only measure what its author already thought of — and if it was derived FROM the suite, \`atomicLedger\` and \`traceability\` read 100% by construction while anything dropped along the way stops being missing from anything. Both axes are held as unverified until you review the claims (add what you care about, delete what you do not) and confirm: \`sungen audit --screen ${screenName} --accept-viewpoint\` — a QA decision: an agent presents it and does not run it.`);
   }
   if (!hasYardstick) {

package/src/harness/next-step.ts

@@ -20,8 +20,6 @@ import { parse as parseYaml } from 'yaml';
 import { reportSlug, featureFilesFor } from './unit-paths';
 import { readTextFile } from './read-text';
 import { checkAssetsDrift } from '../orchestrator/assets-drift';
-import { viewpointFileIsAiDraft } from './viewpoint-draft-header';
-import { readViewpointDeclaration } from './viewpoint-baseline';
 
 export interface NextStep {
   /** The command to run, as the operator would type it. */
@@ -43,8 +41,6 @@ export interface UnitState {
   kind: 'screen' | 'flow' | 'api';
   hasSpec: boolean;
   hasViewpoint: boolean;
-  /** test-viewpoint.md carries `drafted-by: ai` — written by the AI, not yet accepted by a QA. */
-  viewpointIsAiDraft?: boolean;
   hasContract: boolean;
   hasFlowInventory: boolean;
   scenarioCount: number;
@@ -161,9 +157,6 @@ export function readUnitState(
     unit, kind,
     hasSpec: exists(path.join(req, 'spec.md')),
     hasViewpoint: exists(path.join(req, 'test-viewpoint.md')),
-    // An id-less draft has nothing to accept: only the missing-yardstick step speaks for it.
-    viewpointIsAiDraft: viewpointFileIsAiDraft(path.join(req, 'test-viewpoint.md'))
-      && readViewpointDeclaration(path.join(req, 'test-viewpoint.md')) !== null,
     hasContract: exists(contractPath),
     // A contract WITHOUT `flows:` can only be scored per phase, which is a materially weaker
     // claim — so it is part of the state, not a detail.
@@ -252,15 +245,6 @@ export function deriveSteps(s: UnitState): NextStep[] {
     });
     return out;
   }
-  // Before any generation: the AI drafts the viewpoint and audits it BEFORE it writes scenarios, so
-  // this is exactly where a draft would otherwise be accepted by the process that wrote it.
-  if (s.viewpointIsAiDraft) {
-    out.push({
-      kind: 'decide',
-      command: `sungen audit --screen ${s.unit} --accept-viewpoint`,
-      because: 'test-viewpoint.md is marked `drafted-by: ai` — nobody has reviewed it, so the ledger and traceability axes are held as unverified. A QA reviews the claims (adds what matters, deletes what does not), then accepts; the command records the baseline and removes the marker. A decision, not a step: an agent presents it and does not run it',
-    });
-  }
   if (s.scenarioCount === 0) {
     out.push({ kind: 'do', command: design, because: 'no scenarios exist yet' });
     return out;
@@ -276,7 +260,7 @@ export function deriveSteps(s: UnitState): NextStep[] {
     out.push({ kind: 'do', command: `sungen audit --screen ${s.unit}`, because: 'the suite has never been measured' });
     return out;
   }
-  if (s.audit.viewpointBaselineStatus === 'changed' && !s.viewpointIsAiDraft) {   // the draft's own decide step is already above
+  if (s.audit.viewpointBaselineStatus === 'changed') {
     out.push({
       kind: 'decide',
       command: `sungen audit --screen ${s.unit} --accept-viewpoint`,

package/src/harness/parse.ts

@@ -8,7 +8,6 @@
 import * as fs from 'fs';
 import { GherkinParser, ParsedScenario, ParsedStep } from '../generators/gherkin-parser';
 import { readTextFile, readViewpointText } from './read-text';
-import { parsePriority, toEntryPriority } from './viewpoint-priority';
 import { featureFilesFor } from './unit-paths';
 
 export type Priority = 'high' | 'normal' | 'low' | 'unknown';
@@ -16,7 +15,7 @@ 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` · `med` · `normal` · `low` ·
+  /** 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;
@@ -26,14 +25,14 @@ export interface ViewpointEntry {
 
 /**
  * Whole SECTIONS that declare something ABOUT the checklist rather than listing claims or
- * viewpoints — known issues, spec gaps, traceability indexes, references and appendices, changelogs. Shared by the atomic
+ * 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?|spec gaps?|appendi(?:x|ces)|phụ lục|deferred|out of scope|viewpoint grouping|traceability|metadata|scope|journey phases?|revision history|references?|sources?|changelog)\b)/i;
+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
@@ -41,7 +40,7 @@ export const NON_DECLARATION_SECTION = /^(?:(?:ui patterns?(?: identified)?|(?:h
  * `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|med|normal|low|deferred|skip(?:ped)?|n\\/a|none|not applicable';
+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;
 
@@ -55,7 +54,7 @@ const PRIORITY_HEADER = /^(?:priority|pri|level|severity|優先度?|độ ưu ti
 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 = toEntryPriority(parsePriority(cell));
+  const priority = /high/i.test(cell) ? 'High' : /medium/i.test(cell) ? 'Medium' : /low/i.test(cell) ? 'Low' : 'Unknown';
   return word ? { priority, priorityWord: word } : { priority };
 }
 
@@ -64,9 +63,6 @@ export interface ScenarioInfo {
   vpCode?: string;       // VP-CART-001 style code in the scenario title
   category?: string;     // CART, LIST, VAL, ... (from the code)
   priority: Priority;
-  /** The priority tag as written, lower-cased, without `@` — keeps `critical` / `medium` / `med`, which
-   *  `priority` has no slot for, so PRIORITY-CONTRADICTED can fold it like the declared word (#861). */
-  priorityTag?: string;
   manual: boolean;
   thenCount: number;
   hasDataAssertion: boolean;  // a Then asserts {{data}} / contains / match data
@@ -332,9 +328,6 @@ function classifyScenario(sc: ParsedScenario): ScenarioInfo {
   const requiresCaps = tags.filter((t) => /^@requires:/i.test(t)).map((t) => t.slice('@requires:'.length).trim().toLowerCase()).filter(Boolean);
   let priority: Priority = 'unknown';
   for (const t of tags) if (PRIORITY_TAGS[t]) priority = PRIORITY_TAGS[t];
-  // Deliberately wider than `priority` (every priority word, any case): only PRIORITY-CONTRADICTED reads
-  // it, so `@critical` / `@High` are judged there without moving what select-by-ids or the score see.
-  const priorityTag = [...tags].reverse().find((t) => /^@(?:critical|high|medium|med|normal|low)$/i.test(t))?.slice(1).toLowerCase();
 
   const { vpCode, category } = vpCodeOf(sc.name);
   // Project-scheme ID: the leading token of the title (VP0-001 / MS-HP-001 / VP-LIST-001).
@@ -386,7 +379,6 @@ function classifyScenario(sc: ParsedScenario): ScenarioInfo {
     vpCode,
     category,
     priority,
-    priorityTag,
     manual,
     thenCount,
     hasDataAssertion: hasData,

package/src/harness/sensors.ts

@@ -12,7 +12,6 @@ import { parse as parseYaml } from 'yaml';
 import { ScenarioInfo, ViewpointEntry, idPrefix } from './parse';
 import { readTextFile } from './read-text';
 import { keywordHit, hasKeyword } from './keyword-match';
-import { parsePriority } from './viewpoint-priority';
 import { countedAssertions } from './counted-assertions';
 
 // Business-critical category keywords (matched by CONTAINMENT against the VP category, so a
@@ -1103,6 +1102,8 @@ export function priorityMismatches(
   const declared = new Map<string, string>();
   for (const v of viewpoints) if (v.priorityWord) declared.set(v.id.toUpperCase(), v.priorityWord);
   if (declared.size === 0) return [];
+  // `medium` and `normal` are the same rank under different names in real documents.
+  const rank = (p: string): string => (p === 'medium' ? 'normal' : p);
   const out: Array<{ id: string; declared: string; tagged: string; scenario: string }> = [];
   for (const s of scenarios) {
     const id = (s.vpId ?? '').toUpperCase();
@@ -1110,14 +1111,12 @@ export function priorityMismatches(
     // The most specific declared row that prefixes this id.
     const key = [...declared.keys()].filter((k) => id.startsWith(k)).sort((a, b) => b.length - a.length)[0];
     if (!key) continue;
-    // Both sides fold through the one priority reading (`critical` ≡ high, `medium`/`med` ≡ normal).
-    const want = parsePriority(declared.get(key)!);
-    // `deferred` and `skip` (declared not applicable, #853) have no tag equivalent — nothing to contradict.
-    if (want === 'deferred' || want === 'skip') continue;
-    // An untagged scenario states no priority, so it cannot contradict one (#861).
-    const tagged = s.priorityTag ?? (s.priority === 'unknown' ? undefined : String(s.priority));
-    if (!tagged) continue;
-    if (want !== parsePriority(tagged)) out.push({ id: key, declared: declared.get(key)!, tagged, scenario: s.name });
+    const want = rank(declared.get(key)!);
+    const got = rank(String(s.priority).toLowerCase());
+    // `critical`, `deferred` and `skip` (declared not applicable, #853) have no tag equivalent —
+    // nothing to contradict.
+    if (want === 'critical' || want === 'deferred' || want === 'skip') continue;
+    if (want !== got) out.push({ id: key, declared: declared.get(key)!, tagged: got, scenario: s.name });
   }
   return out;
 }

package/src/harness/viewpoint-baseline.ts

@@ -2,7 +2,6 @@ import * as crypto from 'crypto';
 import * as fs from 'fs';
 import * as path from 'path';
 import { parseViewpointOverview } from './parse';
-import { isAiDraft, removeDraftLine } from './viewpoint-draft-header';
 
 /**
  * Keep the yardstick from moving with the thing it measures.
@@ -90,12 +89,7 @@ function fingerprint(ids: string[]): string {
  */
 function fileFingerprint(viewpointPath: string): string {
   try {
-    const bytes = fs.readFileSync(viewpointPath);
-    // `drafted-by: ai` is provenance that accept REMOVES, so it is not part of what was reviewed:
-    // counted, accepting a draft would read as the declaration changing. Every other byte stays raw.
-    const text = bytes.toString('utf-8');
-    const hashed = isAiDraft(text) ? Buffer.from(removeDraftLine(text), 'utf-8') : bytes;
-    return crypto.createHash('sha1').update(hashed).digest('hex').slice(0, 12);
+    return crypto.createHash('sha1').update(fs.readFileSync(viewpointPath)).digest('hex').slice(0, 12);
   } catch { return ''; }
 }