@sun-asterisk/sungen 3.2.34 → 3.2.35

package/src/exporters/playwright-report-parser.ts

@@ -161,6 +161,7 @@ export function loadPlaywrightReport(reportPath: string): Map<string, Playwright
       errorMessages: distinct.length > 0 ? distinct : undefined,
       tracePath: trace,
       projectName: test?.projectName,
+      attempts: results.length || undefined,
     });
   }
   return result;

package/src/exporters/scenario-merger.ts

@@ -9,7 +9,7 @@
  */
 
 import { FeatureMetadata, OrderedStep, ScenarioMetadata, SpecFileData, SpecTest } from './types';
-import { isStepsBaseScenario, isSampleScaffoldScenario, extractTestcaseType } from './feature-parser';
+import { isStepsBaseScenario, isSampleScaffoldScenario, isHookScenario, extractTestcaseType } from './feature-parser';
 import { SCENARIO_ID } from './feature-parser';
 import { extractUnlabeledOracle, onlyPresenceAssertions } from './manual-hybrid-oracle';
 
@@ -139,6 +139,7 @@ export function mergeFeatureAndSpec(
   for (const scenario of feature.scenarios) {
     if (isStepsBaseScenario(scenario)) continue;       // skip @steps base scenarios
     if (isSampleScaffoldScenario(scenario)) continue;  // skip default sample
+    if (isHookScenario(scenario)) continue;            // skip @beforeAll/@afterEach/@afterAll hooks
 
     const specTest = findMatchingSpecTest(scenario, spec.tests, feature.scenarios);
     const base = scenario.extendsName ? stepsBaseByName.get(scenario.extendsName) : undefined;

package/src/exporters/test-data-resolver.ts

@@ -183,8 +183,16 @@ export function renderDynamicTokens(text: string): string {
         const [min, max] = (args || '1:9999').split(':');
         return `<random ${min}-${max}>`;
       }
-      case 'date': return "<today's date>";
-      case 'datetime': return '<current date-time>';
+      case 'date': {
+        if (!args) return "<today's date>";
+        // Same argument grammar as the runtime resolver (specs-test-data.ts), which leaves anything
+        // else raw — so a raw token here is what the tester would see too, and Gate D flags it.
+        const off = /^([+-]\d{1,5})d$/.exec(args.trim());
+        if (!off) return m;
+        const n = Number(off[1]);
+        return `<today's date ${n < 0 ? '-' : '+'} ${Math.abs(n)} day${Math.abs(n) === 1 ? '' : 's'}>`;
+      }
+      case 'datetime': return args ? m : '<current date-time>';
       default: return m;
     }
   });

package/src/exporters/types.ts

@@ -95,6 +95,9 @@ export interface ScenarioMetadata {
    * as Gherkin steps — the merger parses these into Steps/Expected for the report.
    */
   comments?: string[];
+  /** Set for a `@beforeAll` / `@afterEach` / `@afterAll` scenario — a hook the compiler emits as
+   *  `test.beforeAll()` etc., never a test case (#880). */
+  hookType?: 'beforeAll' | 'afterEach' | 'afterAll';
 }
 
 /**
@@ -134,6 +137,8 @@ export interface PlaywrightResult {
   errorMessages?: string[];
   tracePath?: string;
   projectName?: string;
+  /** How many attempts the test took (retries + 1). A pass with attempts > 1 is flaky. */
+  attempts?: number;
 }
 
 /**

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

@@ -18,6 +18,7 @@ export const STATE_CLAUSES: ReadonlyArray<StateClause> = [
   'sorted ascending', 'sorted descending',
   'unchecked', 'checked',
   'hidden', 'visible', 'disabled', 'enabled', 'focused', 'empty', 'loading', 'selected',
+  'expanded', 'collapsed',
 ];
 
 /**

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

@@ -8,7 +8,8 @@
     ? [await __el.getAttribute('label'), await __el.getAttribute('value')]
     : [await __el.getText(), await __el.getAttribute('content-desc')];
   const __actual = String(__sources.find(s => s && String(s).trim() !== '') ?? '').trim();
-  if (!__actual.includes(__expected)) {
+  {{!-- An empty expected value means "shows no text": includes('') holds for any text (#910). --}}
+  if ({{#if emptyMeansEmpty}}__expected === '' ? __actual !== '' : {{/if}}!__actual.includes(__expected)) {
     throw new Error(`[sungen] Expected text containing "${__expected}" but element reads "${__actual}"`);
   }
 }

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

@@ -0,0 +1,2 @@
+{{!-- aria-expanded has no native-mobile equivalent; the appium expand action is a bare tap. --}}
+throw new Error("[sungen] 'is expanded' / 'is collapsed' (aria-expanded) is web-only and has no native-mobile equivalent. Assert what the open panel shows instead (e.g. see [X] section), or tag this scenario @manual.");

package/src/generators/test-generator/adapters/playwright/templates/steps/actions/date-picker-unsupported.hbs

@@ -0,0 +1,5 @@
+{{!-- A date-picker whose trigger is a <button> (a calendar popover, #907) has no value to type:
+      fill() throws "Element is not an <input>". With no recipe there is no honest compilation, so
+      fail loud and name the way forward — the appium twin of this template does the same for a
+      native picker dialog. --}}
+throw new Error('[sungen] {{escapeQuotes reason}}');

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

@@ -34,6 +34,7 @@ import { discoverAndRegisterCapabilities } from '../capabilities/discover';
 import { contextRouter } from '../capabilities/context-router';
 import { readTextFile, readViewpointText } from './read-text';
 import { uiInventoryCoverage, uiInventoryFindings, UiInventoryResult } from './ui-inventory';
+import { defectLinkFindings } from './defects';
 
 export interface AuditReport {
   screen: string;
@@ -215,9 +216,13 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
     ? { ...catalog, page_types: {} } as Catalog
     : catalog;
   const capGate = scoringCap?.gateProvider as
-    ((i: { scenarios: ScenarioInfo[]; viewpoints: ViewpointEntry[]; catalog: Catalog; focus: typeof intent.focus; cwd: string; screenName: string; threshold: number; businessCriticalMethods?: string[] }) => { gate: GateResult; depth: DepthResult }) | undefined;
-  const provided = capGate?.({ scenarios, viewpoints, catalog: gateCatalog, focus: intent.focus, cwd: projectRootFromScreenDir(screenDir), screenName: catalogScreenName, threshold: depthThresholdFor(intent.focus), businessCriticalMethods: intent.businessCriticalMethods });
-  const gate = provided?.gate ?? viewpointGate(scenarios, viewpoints, gateCatalog, platform === 'mobile', viewpointText);
+    ((i: { scenarios: ScenarioInfo[]; viewpoints: ViewpointEntry[]; catalog: Catalog; focus: typeof intent.focus; cwd: string; screenName: string; threshold: number; businessCriticalMethods?: string[]; isMobile: boolean; viewpointText: string }) => { gate: GateResult; depth: DepthResult }) | undefined;
+  // The capability gate gets the SAME isMobile + viewpoint text as the in-core fallback, or a declared
+  // `page-type:` is ignored wherever driver-ui scores — every web project, and a mobile project whose
+  // CLI cannot resolve driver-mobile (#864).
+  const isMobile = platform === 'mobile';
+  const provided = capGate?.({ scenarios, viewpoints, catalog: gateCatalog, focus: intent.focus, cwd: projectRootFromScreenDir(screenDir), screenName: catalogScreenName, threshold: depthThresholdFor(intent.focus), businessCriticalMethods: intent.businessCriticalMethods, isMobile, viewpointText });
+  const gate = provided?.gate ?? viewpointGate(scenarios, viewpoints, gateCatalog, isMobile, viewpointText);
   const depth = provided?.depth ?? assertionDepth(scenarios, dataThemesFor(gateCatalog, gate.pageType), intent.focus);
 
   // TQ-4 — deferral-aware coverage credit: an inherently cross-screen theme (cart / detail /
@@ -618,9 +623,15 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   // #414 — serial-cascade masking: an @serial suite of independent (re-navigating) scenarios hides
   // failures, because Playwright's describe.serial SKIPS everything after the first red. Isolation is
   // the default, so this only fires when @serial was added to a suite that didn't need it.
-  const cascadeN = serialCascadeRisk(featureText, scenarios.length);
-  if (cascadeN) {
-    findings.push(`SERIAL-CASCADE-RISK: this \`@serial\` suite has ${cascadeN} INDEPENDENT scenarios (each re-navigates via Background) that don't need a shared-page sequence. \`describe.serial\` SKIPS every test after the first failure → one early red MASKS the rest as never-run. **Drop \`@serial\`** — the default per-scenario isolation runs every scenario and isolates failures. Keep \`@serial\` only for a genuinely stateful ordered sequence (where scenario N depends on N-1's state).`);
+  // `@serial` is a property of ONE feature file — only that file compiles to `describe.serial` — so
+  // each file is judged on its own text and its own scenarios. The unit-wide text paired one
+  // feature's @serial with another's navigating Background and counted every scenario of the unit,
+  // telling QA to drop @serial from a genuinely ordered 2-scenario feature (#887).
+  for (const file of featureFiles.filter((f) => fs.existsSync(f))) {
+    const cascadeN = serialCascadeRisk(readTextFile(file), scenarios.filter((s) => s.sourceFile === file).length);
+    if (cascadeN) {
+      findings.push(`SERIAL-CASCADE-RISK: the \`@serial\` suite ${path.basename(file)} has ${cascadeN} INDEPENDENT scenarios (each re-navigates via Background) that don't need a shared-page sequence. \`describe.serial\` SKIPS every test after the first failure → one early red MASKS the rest as never-run. **Drop \`@serial\`** — the default per-scenario isolation runs every scenario and isolates failures. Keep \`@serial\` only for a genuinely stateful ordered sequence (where scenario N depends on N-1's state).`);
+    }
   }
   if (flowDepth.stateful && flowDepth.missing.length) {
     // The advice names the collection the CONTRACT declared. It used to say "the cart" whatever
@@ -647,6 +658,8 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   for (const m of taxonomy.mislabeled) {
     findings.push(`VP-MISLABEL: "${m.name}" is coded VP-${m.current} but reads as ${m.suggested} (signal: "${m.signal}") → re-tag VP-${m.suggested}-NNN so the coverage matrix isn't skewed.`);
   }
+  // Scenario ↔ defect record links (qa/defects/) — advisory, never scored.
+  findings.push(...defectLinkFindings(projectRootFromScreenDir(screenDir), catalogScreenName, featureText, scenarios.map((sc) => sc.name)));
   if (balance.unclassifiedRatio > 0.4) {
     findings.push(`TAXONOMY-UNCLASSIFIED: ${balance.note} → align the VP-<CATEGORY> codes with the catalog (or extend the bucket keywords) so coverage-balance is meaningful.`);
   } else if (balance.imbalanced && !flowScored) {

package/src/harness/counted-assertions.ts

@@ -0,0 +1,33 @@
+/**
+ * How many items a scenario's assertions demonstrate — the denominator of CLAIM-PARTIAL (#622).
+ *
+ * One reading for both places that check a counted claim (the viewpoint ledger and the title-level
+ * `numericClaimGaps`), which used to carry their own copy of the regex.
+ *
+ * Counted, once per distinct assertion:
+ *   - a value: `see [X] … with|contains {{v}}`;
+ *   - a positive state: `see [X] … is checked|selected|enabled|disabled`;
+ *   - an indicator's presence: `see [X] icon|checkbox|toggle|radio|badge|image` (#866) — on mobile a
+ *     ticked item is often observable ONLY as its tick icon, so one per item is the proof.
+ * Not counted: plain visibility of text/headers (it shows a label, not one of N values) and absence
+ * (`is hidden`, `not …`), which proves nothing is there.
+ */
+// The tail stops before the NEXT `see [`, or consecutive assertions would swallow each other.
+const SEE_STEP = /\bsee \[([^\]]+)\]((?:(?!\bsee \[)[^[])*)/g;
+const VALUE = /^[^|]*?\b(?:with|contains) (\{\{[^}]*\}\})/;
+const ABSENT = /^\s*\S*\s*(?:is hidden|is not\b|not\b|does not\b)/;
+const STATE = /^\s*\S*\s*is (checked|selected|enabled|disabled)\b/;
+const INDICATOR = /^\s*(icon|checkbox|toggle|radio|badge|image)\b/;
+
+export function countedAssertions(stepsText: string): number {
+  const seen = new Set<string>();
+  for (const m of stepsText.matchAll(SEE_STEP)) {
+    const [, target, rest] = m;
+    if (ABSENT.test(rest)) continue;
+    // Keyed on the target and WHAT it proves — never on the tail, which runs into the next step, so
+    // the same element asserted before and after an action is still one assertion.
+    const proof = VALUE.exec(rest)?.[1] ?? STATE.exec(rest)?.[1] ?? INDICATOR.exec(rest)?.[1];
+    if (proof) seen.add(`${target}|${proof}`);
+  }
+  return seen.size;
+}

package/src/harness/defect-draft.ts

@@ -0,0 +1,115 @@
+/**
+ * `sungen defect draft` — turn each `product-candidate` row of a unit's last triage into a record
+ * `qa/defects/DEF-NNN-<slug>.md` (see defects.ts for the link checks). Deterministic: Steps come
+ * from the scenario's Gherkin with test-data resolved, Expected/Actual from the assertion, and the
+ * severity is PROPOSED by rule until QA confirms it. Never overwrites a file, and never drafts a
+ * scenario an existing record already names.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { stringify as toYaml } from 'yaml';
+import type { ResolvedUnit } from '../cli/resolve-unit';
+import { redactSecrets } from '../exporters/api-testcase-formatter';
+import { getEnvironment } from '../exporters/run-environment';
+import { parseFeatureMetadata } from '../exporters/feature-parser';
+import { mergeFeatureAndSpec, MergedScenario } from '../exporters/scenario-merger';
+import { maskCredentialValue } from '../exporters/sensitive-key';
+import { parseSpecFile } from '../exporters/spec-parser';
+import { loadTestData, substituteTestDataVars } from '../exporters/test-data-resolver';
+import { readCapabilities } from './capability';
+import { defectsDir, nextDefectId, readDefects } from './defects';
+import type { TriageRow } from './triage';
+import { readTriageReport, unitSecrets } from './triage-unit';
+
+export interface DraftResult {
+  /** `sungen triage` has not run for this unit. */
+  missingTriage?: boolean;
+  written: string[];
+  skipped: Array<{ scenario: string; id: string }>;
+}
+
+/** Blocking actions: a @high scenario that fails on one of these is `major`, otherwise `minor`. */
+const BLOCKING = /\b(?:submit|save|apply|log ?in|sign ?in|sign ?up|register|checkout|pay|confirm|send|navigate|redirect)\b/i;
+
+const slug = (s: string): string =>
+  s.replace(/^\s*(?:VP|FL)-[A-Z0-9-]+\s+/i, '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 50).replace(/-$/, '');
+
+interface UnitScenario { merged: MergedScenario; testData: Record<string, string>; secrets: string[] }
+
+/** Scenario title → its merged Gherkin, test-data (credentials masked) and secret values. */
+function unitScenarios(cwd: string, unit: ResolvedUnit): Map<string, UnitScenario> {
+  const out = new Map<string, UnitScenario>();
+  const featuresDir = path.join(unit.dir, 'features');
+  if (!fs.existsSync(featuresDir)) return out;
+  for (const f of fs.readdirSync(featuresDir).filter((x) => x.endsWith('.feature'))) {
+    const base = f.replace(/\.feature$/, '');
+    const spec = parseSpecFile(path.join(cwd, 'specs', 'generated', unit.unitId, `${base}.spec.ts`));
+    const dataFile = path.join(unit.dir, 'test-data', `${base}.yaml`);
+    const raw = fs.existsSync(dataFile) ? loadTestData(dataFile) : {};
+    const testData = Object.fromEntries(Object.entries(raw).map(([k, v]) => [k, maskCredentialValue(k, String(v))]));
+    const secrets = unitSecrets(raw, cwd);
+    for (const m of mergeFeatureAndSpec(parseFeatureMetadata(path.join(featuresDir, f)), spec)) {
+      out.set(m.feature.name, { merged: m, testData, secrets });
+    }
+  }
+  return out;
+}
+
+function render(cwd: string, unit: ResolvedUnit, id: string, row: TriageRow, sc: UnitScenario | undefined): string {
+  const tags = sc?.merged.feature.tags ?? [];
+  const resolve = (t: string): string => (sc ? substituteTestDataVars(t, sc.testData) : t);
+  const steps = (sc?.merged.resolvedSteps ?? []).map((s) => resolve(s.text));
+  const thens = (sc?.merged.resolvedExpected ?? []).map((s) => resolve(s.text));
+  const high = tags.some((t) => t === '@high' || t === '@critical');
+  const severity = high && BLOCKING.test([row.scenario, ...steps].join(' ')) ? 'major' : 'minor';
+  const specFile = path.join(unit.dir, 'requirements', 'spec.md');
+  const env = getEnvironment(cwd);
+  const front = {
+    id, title: row.scenario, severity, severity_source: 'proposed', status: 'open',
+    units: [unit.unitId], scenarios: [row.scenario], claims: row.ids, legacy: row.legacy,
+    spec: fs.existsSync(specFile) ? path.relative(cwd, specFile) : '',
+    found: {
+      date: new Date().toISOString().slice(0, 10),
+      env: process.env.SUNGEN_ENV || 'default',
+      base_url: env.baseURL,
+      platform: row.variant || readCapabilities(cwd).platform || 'web',
+    },
+    tracker: '',
+  };
+  const body = [
+    '---', toYaml(front).trimEnd(), '---', '',
+    `# ${id}: ${row.scenario}`, '',
+    '## Summary', '', '(to fill: what is wrong, where, and who it affects)', '',
+    '## Steps to reproduce', '', ...(steps.length ? steps.map((s, i) => `${i + 1}. ${s}`) : ['(scenario steps not found — see the feature)']), '',
+    '## Expected', '', ...thens.map((t) => `- ${t}`), ...(row.expected ? [`- Asserted value: ${row.expected}`] : []), '',
+    '## Actual', '', `- ${row.received ? `Received: ${row.received}` : row.evidence}`, '',
+    '## Evidence', '', `- Error: ${row.evidence}`, ...(row.tracePath ? [`- Trace: ${row.tracePath}`] : []), '',
+    '## Notes', '', `- Triage: ${row.class} (${row.ruleId})${row.variant ? ` on ${row.variant}` : ''}`, '',
+  ].join('\n');
+  return redactSecrets(body, sc?.secrets ?? []);
+}
+
+export function draftDefects(cwd: string, unit: ResolvedUnit, opts: { scenario?: string } = {}): DraftResult {
+  const triage = readTriageReport(cwd, unit.unitId);
+  if (!triage) return { missingTriage: true, written: [], skipped: [] };
+  const recorded = new Map<string, string>();
+  for (const r of readDefects(cwd)) if (r.units.includes(unit.unitId)) for (const s of r.scenarios) recorded.set(s, r.id);
+
+  const wanted = triage.rows.filter((r) => r.class === 'product-candidate'
+    && (!opts.scenario || r.scenario.includes(opts.scenario) || r.ids.includes(opts.scenario)));
+  const scenarios = unitScenarios(cwd, unit);
+  const result: DraftResult = { written: [], skipped: [] };
+  const seen = new Set<string>();
+  for (const row of wanted) {
+    if (seen.has(row.scenario)) continue;   // one record per scenario, even across OS variants
+    seen.add(row.scenario);
+    const existing = recorded.get(row.scenario);
+    if (existing) { result.skipped.push({ scenario: row.scenario, id: existing }); continue; }
+    const id = nextDefectId(cwd);
+    const file = path.join(defectsDir(cwd), `${id}-${slug(row.scenario) || 'defect'}.md`);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, render(cwd, unit, id, row, scenarios.get(row.scenario)), { encoding: 'utf-8', flag: 'wx' });
+    result.written.push(path.relative(cwd, file));
+  }
+  return result;
+}