@sun-asterisk/sungen 3.2.18 → 3.2.20

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

@@ -56,6 +56,23 @@ interface SelectorEntry {
   };
 }
 
+/**
+ * Roles whose accessible name comes from their own CONTENT, not from a label — so a name the
+ * compiler invented from the `[Reference]` text can never match a real element.
+ *
+ * The `name:` key is defaulted to the Gherkin reference when an entry omits it, which is right for
+ * label-named roles (button/link/textbox) and wrong for these. Left unchecked it compiles to
+ * `getByRole('option', { name: 'Shop Item' })` — zero elements — and `toBeHidden()` PASSES on an
+ * empty locator, so the scenario goes green without ever testing anything.
+ *
+ * The rule lives HERE, at the point the name is invented, rather than in each consumer: it used to
+ * be enforced in exactly one of the branches that read `resolved.name`, and every other branch
+ * (`is hidden`, `is disabled`) silently kept the bogus filter.
+ *
+ * An EXPLICIT `name:` in selectors.yaml is always honoured — the user knows their DOM.
+ */
+export const LIST_MEMBER_ROLES = new Set(['listitem', 'option', 'cell']);
+
 // New selector file structure: flat key-value pairs
 type SelectorFile = Record<string, SelectorEntry>;
 
@@ -275,7 +292,9 @@ export class SelectorResolver {
       'list': () => ({ strategy: 'role', role: 'list', name: label, value: 'list' }),
       'listitem': () => ({ strategy: 'role', role: 'listitem', value: 'listitem' }),
       'searchbox': () => ({ strategy: 'role', role: 'searchbox', name: label, value: 'searchbox' }),
-      'option': () => ({ strategy: 'role', role: 'option', name: label, value: 'option' }),
+      // no `name` — a list-member role names itself from its content (see LIST_MEMBER_ROLES);
+      // `listitem` already omitted it, `option`/`cell` used to disagree.
+      'option': () => ({ strategy: 'role', role: 'option', value: 'option' }),
       'slider': () => ({ strategy: 'role', role: 'slider', name: label, value: 'slider' }),
       'switch': () => ({ strategy: 'role', role: 'switch', name: label, value: 'switch' }),
       'tab': () => ({ strategy: 'role', role: 'tab', name: label, value: 'tab' }),
@@ -286,7 +305,7 @@ export class SelectorResolver {
       'progressbar': () => ({ strategy: 'role', role: 'progressbar', name: label, value: 'progressbar' }),
       'region': () => ({ strategy: 'role', role: 'region', name: label, value: 'region' }),
       'article': () => ({ strategy: 'role', role: 'article', name: label, value: 'article' }),
-      'cell': () => ({ strategy: 'role', role: 'cell', name: label, value: 'cell' }),
+      'cell': () => ({ strategy: 'role', role: 'cell', value: 'cell' }),
       'status': () => ({ strategy: 'role', role: 'status', name: label, value: 'status' }),
       'navigation': () => ({ strategy: 'role', role: 'navigation', name: label, value: 'navigation' }),
     };
@@ -491,8 +510,8 @@ export class SelectorResolver {
    * Replace {{variable}} references in selector values with runtime data markers.
    * This enables i18n: selectors can reference locale-dependent text from test-data.
    *
-   * "{{lbl_submit}}" → "__SUNGEN_TD_lbl_submit__"
-   * "Hello {{name}}" → "Hello __SUNGEN_TD_name__"
+   * "{{lbl_submit}}" → "__SUNGEN_TD$lbl_submit$__"
+   * "Hello {{name}}" → "Hello __SUNGEN_TD$name$__"
    * "No variables"   → "No variables" (unchanged)
    */
   private static resolveTemplateVars(value: string): string {
@@ -517,7 +536,12 @@ export class SelectorResolver {
     // Explicit `name: null` in YAML is a deliberate opt-out (e.g. a role selector that must NOT
     // filter by accessible name); it must not be conflated with "unset". The role template omits
     // `{ name }` when this resolves to a falsy value.
-    const rawName = entry.name === undefined ? originalLabel : (entry.name ?? '');
+    // A list-member role gets NO defaulted name — see LIST_MEMBER_ROLES. `type` is the entry's
+    // declared kind and `rawValue` the role, so the check reads the entry, not a resolved shape.
+    const defaultsNameFromLabel = !(type === 'role' && LIST_MEMBER_ROLES.has(String(rawValue)));
+    const rawName = entry.name === undefined
+      ? (defaultsNameFromLabel ? originalLabel : '')
+      : (entry.name ?? '');
     const value = SelectorResolver.resolveTemplateVars(rawValue);
     const name = SelectorResolver.resolveTemplateVars(rawName);
     const nth = entry.nth !== undefined && entry.nth !== null ? entry.nth : undefined;

package/src/harness/audit.ts

@@ -8,9 +8,9 @@
  */
 import * as path from 'path';
 import * as fs from 'fs';
-import { loadScenarios, parseViewpointOverview, ScenarioInfo, ViewpointEntry } from './parse';
+import { loadUnitScenarios, readUnitFeatureText, parseViewpointOverview, ScenarioInfo, ViewpointEntry } from './parse';
 import { checkViewpointBaseline, ViewpointBaseline } from './viewpoint-baseline';
-import { featureBasename } from './unit-paths';
+import { featureFilesFor } from './unit-paths';
 import {
   loadCatalog, viewpointGate, assertionDepth, dataThemesFor, depthThresholdFor, coverageBalance, duplicateClusters, traceability, claimProof, taxonomyLint,
   automatableManual, flowCoveredThemes, flowRegressionDepth, oracleStrength,
@@ -117,9 +117,10 @@ export function seniorBandedOverall(
 }
 
 export function runAudit(screenDir: string, screenName: string): AuditReport {
-  // The feature filename is the unit's LAST segment — an api flow (`flows/<flow>`) lives at
-  // `<dir>/features/<flow>.feature`, not `features/flows/<flow>.feature` (which found 0 scenarios).
-  const featurePath = path.join(screenDir, 'features', `${featureBasename(screenName)}.feature`);
+  // A unit is a DIRECTORY of features — `add --feature` puts sub-features beside the canonical
+  // one, and they all count. `featureFiles[0]` is that canonical `<basename>.feature` (an api
+  // flow `flows/<flow>` lives at `<dir>/features/<flow>.feature`, not `features/flows/…`).
+  const featureFiles = featureFilesFor(screenDir, screenName);
   const viewpointPath = path.join(screenDir, 'requirements', 'test-viewpoint.md');
   // Catalog-resolution id (for the @api/@query gate sensors): the unit's path relative to qa/ —
   // `flows/<flow>`, `api/<area>`, `api/flows/<flow>`, else the bare screen. A bare screen matches
@@ -127,9 +128,9 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   const catalogScreenName = catalogIdFromScreenDir(screenDir);
 
   const specPath = path.join(screenDir, 'requirements', 'spec.md');
-  const featureText = fs.existsSync(featurePath) ? readTextFile(featurePath) : '';
+  const featureText = readUnitFeatureText(screenDir, screenName);
 
-  const scenarios: ScenarioInfo[] = loadScenarios(featurePath);
+  const scenarios: ScenarioInfo[] = loadUnitScenarios(screenDir, screenName);
   const viewpoints: ViewpointEntry[] = parseViewpointOverview(viewpointPath);
   // AO-1 — capability-routed scoring: the viewpoint catalog + score-bearing gate are owned by the
   // unit's capability, resolved from the unit id (`api/<area>` → `api`; screen/flow → the default
@@ -390,14 +391,14 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   }
   // TQ-9 — manual reason-code mismatch: an explicit @manual:Mx that disagrees with the reason
   // text makes the capability planner recommend the wrong driver. Surface it so the code is fixed.
-  for (const mm of manualReasonMismatches(featurePath).slice(0, 8)) {
+  for (const mm of featureFiles.flatMap(manualReasonMismatches).slice(0, 8)) {
     const label = MANUAL_REASONS[mm.inferred]?.label ?? (mm.inferred === 'XS' ? 'Cross-screen (→ flow)' : mm.inferred);
     findings.push(`MANUAL-REASON-MISMATCH: "${mm.scenario}" is tagged @manual:${mm.explicit} but its reason reads as ${mm.inferred} (${label}) → fix the code so \`sungen capability plan\` recommends the right driver to automate it.`);
   }
   // TQ-10 — surface the Capability Planner recommendation (recommend-only; never installs). Silenced
   // by `capability_suggestions: off` in qa/context.md. Reuses the planner (trustworthy after TQ-9).
   if (intent.capabilitySuggestions) {
-    const plan = buildPlan(screenDir, featureBasename(screenName));
+    const plan = buildPlan(screenDir, screenName);
     if (plan.recommendations.length) {
       const recs = plan.recommendations.map((r) => `\`sungen capability add ${r.driver}\` (automates ${r.count})`).join(' · ');
       findings.push(`CAPABILITY-SUGGESTION: ${plan.capabilityManual} @manual scenario(s) are capability-manual (a driver could automate them) — ${recs}. Recommend-only: nothing is installed automatically; the ${plan.judgmentManual} judgment-manual (M6/M8/M9) correctly stay manual.`);

package/src/harness/capability-plan.ts

@@ -10,6 +10,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { loadDriverCatalog } from './capability';
 import { readTextFile } from './read-text';
+import { featureFilesFor } from './unit-paths';
 
 export type ReasonClass = 'capability' | 'keep' | 'flow';
 export interface ReasonDef { code: string; label: string; cls: ReasonClass; drivers: string[] }
@@ -193,8 +194,7 @@ export interface CapabilityPlan {
 }
 
 export function buildPlan(screenDir: string, screenName: string): CapabilityPlan {
-  const featurePath = path.join(screenDir, 'features', `${screenName}.feature`);
-  const scenarios = parseScenarios(featurePath);
+  const scenarios = featureFilesFor(screenDir, screenName).flatMap(parseScenarios);
   const catalog = loadDriverCatalog();
 
   const modes: Record<string, number> = {};

package/src/harness/catalog/drivers.yaml

@@ -58,7 +58,7 @@ drivers:
   mock:
     kind: capability
     package: "@sungen/driver-mock"
-    status: planned
+    status: shipped
     capabilities: ["@mock", "@network"]
     unblocks: [M3]
   mail-file:

package/src/harness/challenge.ts

@@ -18,7 +18,7 @@
  * The AI agent layer adds the semantic + novelty judgement on top of this spine.
  */
 import * as path from 'path';
-import { loadScenarios, ScenarioInfo } from './parse';
+import { loadUnitScenarios, ScenarioInfo } from './parse';
 import { runAudit } from './audit';
 
 export interface ChallengeFinding {
@@ -63,8 +63,7 @@ const NOVELTY_LENSES = [
 ];
 
 export function buildChallenge(screenDir: string, screenName: string): ChallengeReport {
-  const featurePath = path.join(screenDir, 'features', `${screenName}.feature`);
-  const scenarios: ScenarioInfo[] = loadScenarios(featurePath);
+  const scenarios: ScenarioInfo[] = loadUnitScenarios(screenDir, screenName);
   const audit = runAudit(screenDir, screenName);
 
   // 1. Coverage critic — over-covered buckets (secondary >> business-core) + shallow themes.

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

@@ -8,6 +8,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import { featureFilesFor } from './unit-paths';
 import { parse as parseYaml } from 'yaml';
 import { GherkinParser, ParsedScenario } from '../generators/gherkin-parser';
 import { resolveQuery, lintCatalog } from './query-catalog';
@@ -44,15 +45,18 @@ export function lintDataDriven(screenDir: string, cwd: string = process.cwd()):
   const base = path.basename(screenDir);
   const isFlow = path.basename(path.dirname(screenDir)) === 'flows';
   const screenName = isFlow ? `flows/${base}` : base;
-  const featurePath = path.join(screenDir, 'features', `${base}.feature`);
-  if (!fs.existsSync(featurePath)) return [];
-
-  let scenarios: ParsedScenario[];
-  try {
-    scenarios = new GherkinParser().parseFeatureFile(featurePath).scenarios || [];
-  } catch {
-    return [];
-  }
+  // 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[] = featureFilesFor(screenDir, base)
+    .filter((p) => fs.existsSync(p))
+    .flatMap((p) => {
+      try {
+        return new GherkinParser().parseFeatureFile(p).scenarios || [];
+      } catch {
+        return [];
+      }
+    });
+  if (scenarios.length === 0) return [];
 
   const tdPath = path.join(screenDir, 'test-data', `${base}.yaml`);
   const td: Record<string, any> = tdPath && fs.existsSync(tdPath) ? parseYaml(fs.readFileSync(tdPath, 'utf8')) || {} : {};

package/src/harness/depth-lint.ts

@@ -13,7 +13,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import { loadScenarios, parseViewpointOverview, ScenarioInfo, ViewpointEntry } from './parse';
+import { loadUnitScenarios, parseViewpointOverview, ScenarioInfo, ViewpointEntry } from './parse';
 import { loadCatalog, viewpointGate, assertionDepth, dataThemesFor, CatalogTheme } from './sensors';
 
 export type DepthAction = 'deepen' | 'defer';
@@ -50,11 +50,9 @@ function matchTheme(s: ScenarioInfo, dataThemes: CatalogTheme[]): CatalogTheme |
 }
 
 export function runDepthLint(screenDir: string, screenName: string, focus = 'functional'): DepthLintReport {
-  const last = screenName.split('/').pop() || screenName;
-  const featurePath = path.join(screenDir, 'features', `${last}.feature`);
   const viewpointPath = path.join(screenDir, 'requirements', 'test-viewpoint.md');
 
-  const scenarios: ScenarioInfo[] = loadScenarios(featurePath);
+  const scenarios: ScenarioInfo[] = loadUnitScenarios(screenDir, screenName);
   const viewpoints: ViewpointEntry[] = parseViewpointOverview(viewpointPath);
   const catalog = loadCatalog();
   const gate = viewpointGate(scenarios, viewpoints, catalog);

package/src/harness/flow-check.ts

@@ -11,6 +11,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import { featureFilesFor } from './unit-paths';
 import { loadScenarios } from './parse';
 import { parseScenarios } from './capability-plan';
 import { readTextFile } from './read-text';
@@ -29,8 +30,9 @@ export interface FlowCheckReport {
 function listDirs(p: string): string[] {
   return fs.existsSync(p) ? fs.readdirSync(p, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name) : [];
 }
-function featurePath(base: string, kind: 'screens' | 'flows', name: string): string {
-  return path.join(base, 'qa', kind, name, 'features', `${name}.feature`);
+/** Every `.feature` of the unit — a unit is a directory, so a sub-feature counts too. */
+function featurePaths(base: string, kind: 'screens' | 'flows', name: string): string[] {
+  return featureFilesFor(path.join(base, 'qa', kind, name), name);
 }
 function featureTags(fp: string): string[] {
   if (!fs.existsSync(fp)) return [];
@@ -57,7 +59,7 @@ export interface FlowScenario { flow: string; name: string; haystack: string; de
 export function loadFlowScenarios(cwd: string): FlowScenario[] {
   const out: FlowScenario[] = [];
   for (const f of listDirs(path.join(cwd, 'qa', 'flows'))) {
-    for (const s of loadScenarios(featurePath(cwd, 'flows', f))) {
+    for (const s of featurePaths(cwd, 'flows', f).flatMap(loadScenarios)) {
       out.push({ flow: f, name: s.name, haystack: s.haystack, deep: s.hasDataAssertion });
     }
   }
@@ -74,7 +76,7 @@ export function buildFlowCheck(cwd: string, onlyFlow?: string): FlowCheckReport
   // A. Deferral integrity (screens).
   const deferrals: Deferral[] = [];
   for (const sc of screens) {
-    for (const s of parseScenarios(featurePath(cwd, 'screens', sc))) {
+    for (const s of featurePaths(cwd, 'screens', sc).flatMap(parseScenarios)) {
       // A deferral is the first-class `@deferred:flow` tag (H6) OR the legacy `@manual` + a
       // "deferred to a flow" comment (back-compat). Either marks a cross-screen case owned by a flow.
       const isDeferral = s.deferredToFlow || (s.manual && /deferred to a flow/i.test(s.reason));
@@ -98,9 +100,9 @@ export function buildFlowCheck(cwd: string, onlyFlow?: string): FlowCheckReport
   // B. Run-test contract (per flow).
   const contracts: Contract[] = [];
   for (const f of flows) {
-    const fp = featurePath(cwd, 'flows', f);
-    const parallel = featureTags(fp).some((t) => /^@parallel$/i.test(t));
-    const scs = loadScenarios(fp);
+    const fps = featurePaths(cwd, 'flows', f);
+    const parallel = fps.flatMap(featureTags).some((t) => /^@parallel$/i.test(t));
+    const scs = fps.flatMap(loadScenarios);
     let cartStateCount = 0;
     for (const s of scs) {
       const h = s.haystack;

package/src/harness/flow-plan.ts

@@ -9,6 +9,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import { featureFilesFor } from './unit-paths';
 import { parse as parseYaml } from 'yaml';
 import { MANUAL_REASONS, inferReasonCode } from './capability-plan';
 import { buildFlowCheck, Contract } from './flow-check';
@@ -78,9 +79,9 @@ export interface FlowPlan {
 }
 
 export function buildFlowPlan(cwd: string, flow: string): FlowPlan {
-  const featurePath = path.join(cwd, 'qa', 'flows', flow, 'features', `${flow}.feature`);
-  const selectorsPath = path.join(cwd, 'qa', 'flows', flow, 'selectors', `${flow}.yaml`);
-  const scenarios = parseFlowScenarios(featurePath);
+  const flowDir = path.join(cwd, 'qa', 'flows', flow);
+  const selectorsPath = path.join(flowDir, 'selectors', `${flow}.yaml`);
+  const scenarios = featureFilesFor(flowDir, flow).flatMap(parseFlowScenarios);
   const keys = selectorKeys(selectorsPath);
 
   // Legs = distinct screen namespaces.

package/src/harness/manifest.ts

@@ -11,7 +11,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { createHash } from 'crypto';
-import { featureBasename, reportSlug } from './unit-paths';
+import { featureFilesFor, reportSlug } from './unit-paths';
 import { readTextFile } from './read-text';
 
 export interface SpecSection { name: string; hash: string }
@@ -99,13 +99,13 @@ function parseFeatureSections(featurePath: string): { scenario: string; vpCode?:
 
 export function buildManifest(screenDir: string, screenName: string): Manifest {
   const specPath = path.join(screenDir, 'requirements', 'spec.md');
-  const featurePath = path.join(screenDir, 'features', `${featureBasename(screenName)}.feature`);
+  const featureFiles = featureFilesFor(screenDir, screenName);
   const specSections = parseSpecSections(specPath);
   const specMap: Record<string, string> = {};
   for (const s of specSections) specMap[s.name] = s.hash;
 
   const specNames = Object.keys(specMap);
-  const featScenarios = parseFeatureSections(featurePath);
+  const featScenarios = featureFiles.flatMap(parseFeatureSections);
   const entries: ManifestEntry[] = featScenarios.map((f) => {
     const matched = matchSection(f.section, specNames);
     return {

package/src/harness/parse.ts

@@ -8,6 +8,7 @@
 import * as fs from 'fs';
 import { GherkinParser, ParsedScenario, ParsedStep } from '../generators/gherkin-parser';
 import { readTextFile } from './read-text';
+import { featureFilesFor } from './unit-paths';
 
 export type Priority = 'high' | 'normal' | 'low' | 'unknown';
 
@@ -175,7 +176,12 @@ function classifyScenario(sc: ParsedScenario): ScenarioInfo {
 
     if (last === 'Then') {
       thenCount++;
-      if (/\{\{|contains|match data|toHaveText/i.test(step.text)) hasData = true;
+      // Storage assertions count as data-bearing: 4 of the 5 shapes carry no {{ref}}
+      // (`exists`, `does not exist`, `is not empty`, `key matching "…"`), yet they
+      // assert persisted state — without this they'd be scored `shallow`, penalizing
+      // exactly the checks the review encourages. `tab order` is a STRUCTURAL
+      // assertion (a data table of focus stops) with the same no-{{ref}} property.
+      if (/\{\{|contains|match data|toHaveText|in (local|session) storage|tab order/i.test(step.text)) hasData = true;
     }
   }
 
@@ -211,3 +217,24 @@ export function loadScenarios(featurePath: string): ScenarioInfo[] {
     .filter((s) => !s.stepsName && !s.hookType) // skip @steps/@hook blocks
     .map(classifyScenario);
 }
+
+/**
+ * Scenarios of a WHOLE unit — every `.feature` in its features/ directory, not just the
+ * canonical one. Sub-features created by `add --feature` used to be invisible to every
+ * sensor; the score they produced was a subset presented as the whole.
+ */
+export function loadUnitScenarios(unitDir: string, unit: string): ScenarioInfo[] {
+  return featureFilesFor(unitDir, unit).flatMap(loadScenarios);
+}
+
+/**
+ * Raw Gherkin of a WHOLE unit, concatenated in `featureFilesFor` order — the input for the
+ * text-level sensors (isolation risk, serial cascade, manual oracle, …). Missing files
+ * contribute nothing, so a unit with no features yields '' exactly as before.
+ */
+export function readUnitFeatureText(unitDir: string, unit: string): string {
+  return featureFilesFor(unitDir, unit)
+    .filter((p) => fs.existsSync(p))
+    .map((p) => readTextFile(p))
+    .join('\n');
+}

package/src/harness/script-check.ts

@@ -15,8 +15,8 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-import { loadScenarios, ScenarioInfo } from './parse';
-import { featureBasename } from './unit-paths';
+import { loadUnitScenarios, ScenarioInfo } from './parse';
+import { featureFilesFor } from './unit-paths';
 import { readTextFile } from './read-text';
 
 export interface ScriptCheckResult {
@@ -57,7 +57,15 @@ export function extractTestBlocks(specSrc: string): { title: string; body: strin
   return blocks;
 }
 
-const CODE_LINE = /\b(await|expect|testData|page\.)\b|=\s*[^=]/;
+// A line counts as executable code when it interacts with the page/assertions/data,
+// assigns, OR is a standalone call expression (`mock.setPassthrough(page);`,
+// `driver.enable(...)`). The call branch is what keeps capability helpers from
+// reading as hollow: a sync void call after its step comment matched none of the
+// original alternatives (no await/expect/testData, `page` only as a bare argument,
+// no `=`), so @mock:passthrough scenarios were flagged BYPASS (field report) — on
+// sungen's own mock-route golden fixture, no less. Comment lines are step markers
+// (never inside a scanned region), so `identifier(` cannot false-match non-code.
+const CODE_LINE = /\b(await|expect|testData|page\.)\b|=\s*[^=]|[\w$]\s*\(/;
 
 /**
  * Faithfulness / anti-bypass: a non-@manual test that performs actions but proves
@@ -120,7 +128,12 @@ function specSubdir(dir: string, name: string, kind: UnitKind): string {
   return kind === 'flow' ? path.join(dir, 'flows', name) : kind === 'api' ? path.join(dir, 'api', name) : path.join(dir, name);
 }
 
-function findSpec(dir: string, name: string, kind: UnitKind): string | null {
+/**
+ * EVERY compiled spec of the unit. A unit compiles to one `.spec.ts` per `.feature`, so
+ * taking only the first hit checked a multi-feature screen against a fraction of its own
+ * compiled output — every sub-feature scenario then read as MISSING in spec.
+ */
+function findSpecs(dir: string, name: string, kind: UnitKind): string[] {
   // Screens compile to  <dir>/<name>/<feature>.spec.ts
   // Flows   compile to  <dir>/flows/<name>/<feature>.spec.ts
   // Api     compile to  <dir>/api/<name>/<feature>.spec.ts
@@ -137,37 +150,45 @@ function findSpec(dir: string, name: string, kind: UnitKind): string | null {
     }
   };
   const scoped = specSubdir(dir, name, kind);
-  if (!fs.existsSync(scoped)) return null; // no spec for this target (e.g. not compiled yet)
+  if (!fs.existsSync(scoped)) return []; // no spec for this target (e.g. not compiled yet)
   walk(scoped);
-  return hits[0] ?? null;
+  return hits.sort((a, b) => a.localeCompare(b, 'en'));
 }
 
 export async function runScriptCheck(screenDir: string, screenName: string, kind: UnitKind): Promise<ScriptCheckResult> {
-  const featurePath = path.join(screenDir, 'features', `${featureBasename(screenName)}.feature`);
-  const scenarios = loadScenarios(featurePath);
+  const featureFiles = featureFilesFor(screenDir, screenName);
+  const scenarios = loadUnitScenarios(screenDir, screenName);
   const automated = scenarios.filter((s) => !s.manual);
   const manual = scenarios.filter((s) => s.manual);
 
-  const committedSpec = findSpec(path.join(process.cwd(), 'specs', 'generated'), screenName, kind);
+  const committedSpecs = findSpecs(path.join(process.cwd(), 'specs', 'generated'), screenName, kind);
+  // Representative path for the report; the checks below read ALL of them.
+  const committedSpec = committedSpecs[0] ?? null;
 
   const findings: string[] = [];
   let specTitles: string[] = [];
   let specSrc = '';
   if (committedSpec) {
-    specSrc = readTextFile(committedSpec);
-    specTitles = extractTestTitles(specSrc);
+    specSrc = committedSpecs.map((p) => readTextFile(p)).join('\n');
+    specTitles = committedSpecs.flatMap((p) => extractTestTitles(readTextFile(p)));
   } else {
     findings.push('No generated spec found under specs/generated/ — run `sungen generate` / `/sungen:run-test` first.');
   }
 
   // A. Structural 1:1
-  // A @cases scenario emits ONE source test() inside a per-row loop, titled
-  // `<name> — ${__row.__label}` — match that literal title, not the bare name.
-  const expectedTitle = (s: ScenarioInfo) => (s.casesDataset ? `${s.name} — ${'${'}__row.__label}` : s.name);
-  const specTitleSet = new Set(specTitles);
-  const expectedSet = new Set(automated.map(expectedTitle));
-  const missingInSpec = automated.filter((s) => !specTitleSet.has(expectedTitle(s))).map((s) => s.name);
-  const extraInSpec = specTitles.filter((t) => !expectedSet.has(t));
+  // A @cases scenario emits ONE source test() inside a per-row loop. Its title
+  // appears in the spec as `'<name> — ' + __row.__label` (CONCAT — what
+  // scenario.hbs emits today; the extracted literal is `<name> —`) or as the
+  // legacy template form `<name> — ${__row.__label}`. This check used to expect
+  // ONLY the template form, so on the current codegen every @cases scenario was
+  // reported MISSING (+ its test EXTRA) despite compiling and running fine.
+  // Canonicalize the extracted title to the bare scenario name so both shapes
+  // (and plain titles) compare on the same footing.
+  const canonSpecTitle = (t: string) => t.replace(/\s*—(\s*\$\{__row\.__label\})?$/, '');
+  const specTitleSet = new Set(specTitles.map(canonSpecTitle));
+  const expectedSet = new Set(automated.map((s) => s.name));
+  const missingInSpec = automated.filter((s) => !specTitleSet.has(s.name)).map((s) => s.name);
+  const extraInSpec = specTitles.filter((t) => !expectedSet.has(canonSpecTitle(t)));
   const countMatch = committedSpec ? automated.length === specTitles.length : false;
   if (committedSpec && !countMatch) {
     findings.push(`Count mismatch: ${automated.length} automated scenarios vs ${specTitles.length} test() blocks.`);
@@ -192,25 +213,32 @@ export async function runScriptCheck(screenDir: string, screenName: string, kind
       const gen = kind === 'api'
         ? new CodeGenerator({ framework, runtimeData: true })
         : new CodeGenerator({ framework, screenName, runtimeData: true, flowMode: kind === 'flow' });
-      await gen.generateAllTests(qaSourceDir, tmp, [featurePath]);
-      const fresh = findSpec(tmp, screenName, kind);
-      if (fresh) {
-        const a = normalize(specSrc);
+      await gen.generateAllTests(qaSourceDir, tmp, featureFiles);
+      // Pair each committed spec with its regenerated twin by filename — one `.feature`
+      // compiles to one `.spec.ts`, so a multi-feature unit has several of each.
+      const freshByName = new Map(findSpecs(tmp, screenName, kind).map((p) => [path.basename(p), p]));
+      const multi = committedSpecs.length > 1;
+      for (const committed of committedSpecs) {
+        const fresh = freshByName.get(path.basename(committed));
+        if (!fresh) continue;
+        const a = normalize(readTextFile(committed));
         const b = normalize(readTextFile(fresh));
-        if (a !== b) {
-          drift = 'drift';
-          // collect a few differing lines
-          const al = a.split('\n'), bl = b.split('\n');
-          const max = Math.max(al.length, bl.length);
-          for (let i = 0, shown = 0; i < max && shown < 6; i++) {
-            if (al[i] !== bl[i]) {
-              driftHunks.push(`  L${i + 1}\n    committed: ${(al[i] ?? '∅').trim().slice(0, 100)}\n    expected : ${(bl[i] ?? '∅').trim().slice(0, 100)}`);
-              shown++;
-            }
+        if (a === b) continue;
+        drift = 'drift';
+        // collect a few differing lines
+        const al = a.split('\n'), bl = b.split('\n');
+        const max = Math.max(al.length, bl.length);
+        const where = multi ? `${path.basename(committed)} ` : '';
+        for (let i = 0, shown = 0; i < max && shown < 6 && driftHunks.length < 6; i++) {
+          if (al[i] !== bl[i]) {
+            driftHunks.push(`  ${where}L${i + 1}\n    committed: ${(al[i] ?? '∅').trim().slice(0, 100)}\n    expected : ${(bl[i] ?? '∅').trim().slice(0, 100)}`);
+            shown++;
           }
-          findings.push('DRIFT: committed spec differs from a fresh regenerate → spec was hand-edited or the .feature changed without `sungen generate`. The test code no longer reflects the Gherkin.');
         }
       }
+      if (drift === 'drift') {
+        findings.push('DRIFT: committed spec differs from a fresh regenerate → spec was hand-edited or the .feature changed without `sungen generate`. The test code no longer reflects the Gherkin.');
+      }
       fs.rmSync(tmp, { recursive: true, force: true });
     } catch (e) {
       findings.push(`Drift check skipped (regenerate failed): ${e instanceof Error ? e.message : e}`);

package/src/harness/secret-scan.ts

@@ -27,7 +27,18 @@ function scanText(text: string, file: string): SecretHit[] {
     }
     const m = raw.match(SECRET_KEY);
     if (m) {
-      const val = m[2].trim().replace(/^["']|["']$/g, '');
+      // Take only the FIRST scalar after the key. The old `(.+)$` capture swallowed
+      // the rest of the line, so in an inline-map @cases row
+      //   - { …, password: "${QA_X}", expected_status: 201 }
+      // the "value" included `, expected_status: 201 }` — whose digits + length
+      // pushed EVERY such row over the threshold regardless of the actual value
+      // (field report: ${QA_*} refs and a deliberate wrong_password all warned).
+      const tail = m[2].trim();
+      const quoted = tail.match(/^(["'])((?:\\.|(?!\1).)*)\1/);
+      const val = (quoted ? quoted[2] : tail.split(/[,}\s]/, 1)[0]).trim();
+      // A ${VAR} env ref IS the recommended practice (.env.qa overlays) — never
+      // warn on it, or the gate teaches users the opposite of the convention.
+      if (/^\$\{[A-Za-z_][A-Za-z0-9_]*\}$/.test(val)) return;
       // Long, high-entropy-ish, not an obvious placeholder/test value.
       if (val.length >= 20 && !PLACEHOLDERish.test(raw) && /[A-Za-z]/.test(val) && /[0-9]/.test(val)) {
         hits.push({ file, line, reason: `secret-named key "${m[1]}" with a long literal value` });
@@ -37,15 +48,19 @@ function scanText(text: string, file: string): SecretHit[] {
   return hits;
 }
 
-/** Scan a screen/flow dir's test-data/*.yaml for likely real secrets. */
+/** Scan a unit dir's committed yaml sinks for likely real secrets: test-data/*.yaml,
+ *  mock/*.yaml (mock response bodies are a credential magnet — pasted DevTools
+ *  responses carry real tokens), and api/*.yaml (endpoint catalogs carry headers). */
 export function scanTestDataSecrets(baseDir: string): SecretHit[] {
-  const tdDir = path.join(baseDir, 'test-data');
-  if (!fs.existsSync(tdDir)) return [];
   const hits: SecretHit[] = [];
-  for (const f of fs.readdirSync(tdDir)) {
-    if (!/\.ya?ml$/i.test(f)) continue;
-    const p = path.join(tdDir, f);
-    try { hits.push(...scanText(fs.readFileSync(p, 'utf-8'), path.join('test-data', f))); } catch { /* ignore */ }
+  for (const sub of ['test-data', 'mock', 'api']) {
+    const dir = path.join(baseDir, sub);
+    if (!fs.existsSync(dir)) continue;
+    for (const f of fs.readdirSync(dir)) {
+      if (!/\.ya?ml$/i.test(f)) continue;
+      const p = path.join(dir, f);
+      try { hits.push(...scanText(fs.readFileSync(p, 'utf-8'), path.join(sub, f))); } catch { /* ignore */ }
+    }
   }
   return hits;
 }

package/src/harness/sensors.ts

@@ -279,8 +279,12 @@ export interface AutomatableManualResult {
 
 // Genuine-judgment markers (M6/M8/M9 territory): visual/responsive/a11y/mock/network/
 // external/empty-state — these legitimately stay @manual (or need a future driver).
+// `focus order` is no longer a judgment marker — `Then User see tab order:` automates
+// it deterministically. `keyboard` is NARROWED (keyboard-only navigation / focus traps
+// still need a human or AT), not removed: a scenario merely mentioning the keyboard is
+// automatable, a keyboard-ONLY audit is not.
 const JUDGMENT_MARKER =
-  /\b(visual|responsive|layout|breakpoint|mobile|tablet|viewport|accessib|a11y|keyboard|screen reader|focus order|\baria\b|empty[- ]?(state|product|list|category|cart)|no[- ]?result|missing (image|product|data)|placeholder|fallback|slow|failing|offline|network|loading|spinner|external|new tab|video tutorial|email|mailbox|download|payment gateway|exploratory|not worth)\b/;
+  /\b(visual|responsive|layout|breakpoint|mobile|tablet|viewport|accessib|a11y|keyboard[- ]only|keyboard trap|screen reader|\baria\b|empty[- ]?(state|product|list|category|cart)|no[- ]?result|missing (image|product|data)|placeholder|fallback|slow|failing|offline|network|loading|spinner|external|new tab|video tutorial|email|mailbox|download|payment gateway|exploratory|not worth)\b/;
 
 /**
  * Automatable-@manual (TQ-2) — a `@manual` scenario whose steps are fully DSL-expressible
@@ -637,7 +641,10 @@ const CLAIM_RULES: ClaimRule[] = [
   {
     claim: 'independent/separate',
     title: /\b(independent|separate|isolat(ed|es)|per[- ]tab|two tabs|each tab)\b/,
-    proof: /\bcontext\b|tab a|tab b|second (tab|context)/,
+    // A storage `does not exist` check on the OTHER tenant's key proves isolation
+    // ("the other shop's token is not exposed"). Only the absence shape counts — a
+    // positive `exists` check looks the same whether or not the claim holds.
+    proof: /\bcontext\b|tab a|tab b|second (tab|context)|does not exist/,
     need: 'a multi-context proof (tab A vs tab B)',
     hint: 'independence across tabs/contexts is rarely DSL-expressible — mark @manual with a clear setup/action/oracle.',
     severity: 'warn',
@@ -653,7 +660,7 @@ const CLAIM_RULES: ClaimRule[] = [
   {
     claim: 'announces/aria',
     title: /\b(announce[sd]?|aria|screen[- ]reader|programmatically associated)\b/,
-    proof: /aria|role|@manual|describedby|is focused/,
+    proof: /aria|role|@manual|describedby|is focused|tab order/,
     need: 'an aria/role assertion (or @manual with a screen-reader oracle)',
     hint: 'ARIA announcement is usually not DSL-expressible — assert aria attributes if possible, else @manual with an NVDA/VoiceOver oracle.',
     severity: 'warn',
@@ -668,7 +675,11 @@ const CLAIM_RULES: ClaimRule[] = [
     // authoritative recall layer for the residue this can't judge structurally.
     claim: 'negative-claim/absence',
     title: /(\bno\b|\bnot\b|n['’]t\b|\bnever\b|\bwithout\b|\bcannot\b|prevent|block|avoid|reject|disabl|\bdeny\b|denies|\bkhông\b|\bchưa\b)/i,
-    proof: /is hidden|are hidden|is empty|no longer|not complete|disabl|invalid|rejected|\berror\b|\bcount\b|row with \{\{|table with|\bremember\b|\bexactly\b|tohavecount/i,
+    // `does not exist` covers the storage-absence shape — the broad "any storage
+    // assertion" alternative would let a positive `exists` silence a negative claim.
+    // `tab order` proves "focus never lands on X"-style claims (the table enumerates
+    // exactly where focus goes).
+    proof: /is hidden|are hidden|is empty|no longer|not complete|disabl|invalid|rejected|\berror\b|\bcount\b|row with \{\{|table with|\bremember\b|\bexactly\b|tohavecount|does not exist|tab order/i,
     need: 'a proof of the ABSENCE — a contrast/empty/hidden/error/count assertion, or @manual with an oracle',
     hint: 'a negative claim ("no / not / không …") is not proven by a positive `see [X]` that looks the same whether or not the claim holds. Assert the contrast (state hidden/empty, error shown, count unchanged), or mark @manual.',
     severity: 'warn',