@sun-asterisk/sungen 3.0.0-beta.71 → 3.0.0-beta.73

package/src/cli/commands/capability.ts

@@ -0,0 +1,160 @@
+import { Command } from 'commander';
+import { spawnSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  readCapabilities, writeCapabilities, loadDriverCatalog, driverMeta,
+} from '../../harness/capability';
+import { buildPlan, MANUAL_REASONS } from '../../harness/capability-plan';
+import { adapterRegistry } from '../../generators/test-generator/adapters';
+
+function findScreenDir(name: string): string | null {
+  const s = path.join(process.cwd(), 'qa', 'screens', name);
+  if (fs.existsSync(s)) return s;
+  const f = path.join(process.cwd(), 'qa', 'flows', name);
+  if (fs.existsSync(f)) return f;
+  return null;
+}
+
+export function registerCapabilityCommand(program: Command): void {
+  const cap = program
+    .command('capability')
+    .description('Manage execution drivers (platform + capability) — opt-in, installed only on consent');
+
+  // ── list ────────────────────────────────────────────────────────────────
+  cap
+    .command('list')
+    .description('Show the project platform + enabled drivers + the available driver catalog')
+    .action(() => {
+      try {
+        const cwd = process.cwd();
+        const profile = readCapabilities(cwd);
+        const catalog = loadDriverCatalog();
+        console.log('\n━━━ Capabilities ━━━');
+        console.log(`  platform: ${profile.platform ?? '(none — run `sungen capability add web|mobile`)'}`);
+        console.log(`  enabled:  ${profile.enabled.length ? profile.enabled.join(', ') : '(none)'}  [${profile.source}]`);
+        console.log('\n  Available drivers (install with `sungen capability add <id>`):');
+        for (const d of Object.values(catalog)) {
+          const on = profile.enabled.includes(d.id) ? '●' : '○';
+          const unblocks = d.unblocks?.length ? `  unblocks ${d.unblocks.join('/')}` : '';
+          console.log(`    ${on} ${d.id.padEnd(13)} [${d.kind}] ${d.package}${unblocks}`);
+        }
+        console.log('');
+      } catch (e) {
+        console.error('Error:', e instanceof Error ? e.message : e);
+        process.exit(1);
+      }
+    });
+
+  // ── plan (Planner — recommend-only, no install) ──────────────────────────
+  cap
+    .command('plan')
+    .description('Capability Planner: classify execution modes + @manual reasons (M1–M9) + recommend drivers (no install)')
+    .requiredOption('-s, --screen <name>', 'Screen or flow name')
+    .option('--json', 'Output the raw plan JSON')
+    .action((o: { screen: string; json?: boolean }) => {
+      try {
+        const dir = findScreenDir(o.screen);
+        if (!dir) throw new Error(`Screen/flow not found: qa/screens/${o.screen} or qa/flows/${o.screen}`);
+        const plan = buildPlan(dir, o.screen);
+
+        const outDir = path.join(process.cwd(), '.sungen', 'reports');
+        fs.mkdirSync(outDir, { recursive: true });
+        const outPath = path.join(outDir, `${o.screen}-plan.json`);
+        fs.writeFileSync(outPath, JSON.stringify(plan, null, 2), 'utf-8');
+        if (o.json) { console.log(JSON.stringify(plan, null, 2)); return; }
+
+        const L = console.log;
+        L(`\n━━━ Capability Plan: ${plan.screen} (${plan.total} scenarios) ━━━`);
+        L(`  Execution modes: ${Object.entries(plan.modes).map(([m, n]) => `${m} ${n}`).join(' · ')}`);
+        const reasons = Object.entries(plan.byReason).sort().map(([c, n]) => `${c}×${n}`).join('  ') || '(no manual)';
+        L(`  Manual by reason: ${reasons}`);
+        if (plan.modes['manual']) {
+          L(`    capability-manual: ${plan.capabilityManual} (${plan.capabilityManualPct}%)   judgment-manual: ${plan.judgmentManual}   cross-screen→flow: ${plan.crossScreen}`);
+        }
+        if (plan.crossScreen) {
+          L(`  Cross-screen (XS×${plan.crossScreen}): automate via a flow — \`/sungen:add-flow\` (not a single-screen driver gap).`);
+        }
+        if (plan.recommendations.length) {
+          L('  Recommendations (recommend-only — install with `sungen capability add`):');
+          for (const r of plan.recommendations) {
+            L(`     • ${r.count} @manual:${r.reason} → enable \`${r.driver}\` (${r.pkg}) → would unblock ${r.count}`);
+          }
+        }
+        if (plan.keep.length) {
+          L(`  Keep manual (judgment floor — do NOT automate): ${plan.keep.map((k) => `${k.code}×${k.count} (${MANUAL_REASONS[k.code].label})`).join(', ')}`);
+        }
+        if (plan.unclassified.length) {
+          L(`  ⚠ Unclassified (add @manual:Mx or a clearer reason): ${plan.unclassified.length}`);
+          for (const u of plan.unclassified.slice(0, 8)) L(`     - ${u.name}`);
+        }
+        L(`\n  Report: ${path.relative(process.cwd(), outPath)}\n`);
+      } catch (e) {
+        console.error('Error:', e instanceof Error ? e.message : e);
+        process.exit(1);
+      }
+    });
+
+  // ── add (the consent action) ─────────────────────────────────────────────
+  cap
+    .command('add <driver>')
+    .description('Enable a driver: install its package (if external) + record it in qa/capabilities.yaml')
+    .option('--skip-install', 'Only record in the profile; do not run npm install')
+    .action((driver: string, o: { skipInstall?: boolean }) => {
+      try {
+        const cwd = process.cwd();
+        const meta = driverMeta(driver);
+        if (!meta) {
+          throw new Error(`Unknown driver "${driver}". Known: ${Object.keys(loadDriverCatalog()).join(', ')}`);
+        }
+        const adapterName = meta.adapter || meta.id;
+        const bundled = adapterRegistry.hasAdapter(adapterName); // e.g. `web` is bundled in Phase 2a
+
+        if (!bundled && !o.skipInstall) {
+          console.log(`📦 Installing ${meta.package} (dev dependency)...`);
+          const r = spawnSync('npm', ['install', '-D', meta.package], { stdio: 'inherit', shell: true });
+          if (r.status !== 0) throw new Error(`npm install -D ${meta.package} failed.`);
+        } else if (bundled) {
+          console.log(`✓ ${driver} is built-in (no install needed).`);
+        }
+
+        // Verify it can load (skip for bundled — already registered).
+        if (!bundled) {
+          adapterRegistry.loadDriver(adapterName, meta.package, cwd); // throws if not loadable
+        }
+
+        const profile = readCapabilities(cwd);
+        const enabled = Array.from(new Set([...profile.enabled, driver]));
+        const platform = meta.kind === 'platform' ? driver : profile.platform;
+        writeCapabilities(cwd, { platform, enabled });
+        console.log(`✓ capability "${driver}" enabled${meta.kind === 'platform' ? ` (platform=${driver})` : ''}.`);
+        console.log('');
+      } catch (e) {
+        console.error('Error:', e instanceof Error ? e.message : e);
+        process.exit(1);
+      }
+    });
+
+  // ── remove ─────────────────────────────────────────────────────────────
+  cap
+    .command('remove <driver>')
+    .description('Disable a driver in qa/capabilities.yaml (optionally uninstall the package)')
+    .option('--uninstall', 'Also run npm uninstall for the driver package')
+    .action((driver: string, o: { uninstall?: boolean }) => {
+      try {
+        const cwd = process.cwd();
+        const profile = readCapabilities(cwd);
+        const enabled = profile.enabled.filter((d) => d !== driver);
+        const platform = profile.platform === driver ? undefined : profile.platform;
+        writeCapabilities(cwd, { platform, enabled });
+        const meta = driverMeta(driver);
+        if (o.uninstall && meta && !adapterRegistry.hasAdapter(meta.adapter || meta.id)) {
+          spawnSync('npm', ['uninstall', meta.package], { stdio: 'inherit', shell: true });
+        }
+        console.log(`✓ capability "${driver}" disabled.`);
+      } catch (e) {
+        console.error('Error:', e instanceof Error ? e.message : e);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/commands/flow-check.ts

@@ -0,0 +1,97 @@
+import { Command } from 'commander';
+import * as fs from 'fs';
+import * as path from 'path';
+import { buildFlowCheck } from '../../harness/flow-check';
+import { buildFlowPlan } from '../../harness/flow-plan';
+
+export function registerFlowCheckCommand(program: Command): void {
+  registerFlowPlan(program);
+  program
+    .command('flow-check')
+    .description('Flow first-class: verify screen→flow deferrals are really covered + surface the run-test contract')
+    .option('--flow <name>', 'Limit the run-test contract checks to one flow')
+    .option('--json', 'Output the raw JSON report')
+    .action((o: { flow?: string; json?: boolean }) => {
+      try {
+        const cwd = process.cwd();
+        const r = buildFlowCheck(cwd, o.flow);
+
+        const outDir = path.join(cwd, '.sungen', 'reports');
+        fs.mkdirSync(outDir, { recursive: true });
+        fs.writeFileSync(path.join(outDir, 'flow-check.json'), JSON.stringify(r, null, 2), 'utf-8');
+        if (o.json) { console.log(JSON.stringify(r, null, 2)); return; }
+
+        const L = console.log;
+        L('\n━━━ Flow Check ━━━');
+        L(`  screens: ${r.screens.join(', ') || '(none)'}   flows: ${r.flows.join(', ') || '(none)'}`);
+
+        L('\n  ① Deferral integrity (screen → flow)');
+        if (!r.deferrals.length) L('     (no "deferred to a flow" @manual scenarios)');
+        for (const d of r.deferrals) {
+          const icon = d.verdict === 'covered' ? '✓' : d.verdict === 'shallow' ? '◐' : '✗';
+          const note = d.verdict === 'missing'
+            ? `NO flow covers "${d.targets.join('/')}" → false deferral (real manual gap)`
+            : `${d.verdict} by ${d.via}`;
+          L(`     ${icon} ${d.screen} · ${d.scenario.slice(0, 60)} → ${note}`);
+        }
+
+        L('\n  ② Run-test contract (cross-screen proofs)');
+        if (!r.contracts.length) L('     (no contract risks detected)');
+        for (const c of r.contracts) {
+          L(`     ⚠ ${c.kind}${c.scenario ? ` · ${c.scenario.slice(0, 55)}` : ` · ${c.flow}`}\n        ${c.message}`);
+        }
+
+        L(`\n  Report: ${path.relative(cwd, path.join(outDir, 'flow-check.json'))}`);
+        if (r.missing > 0) {
+          L(`\n  ✗ ${r.missing} false deferral(s) — these XS scenarios are NOT actually flow-covered. Add a flow or re-classify.\n`);
+          process.exit(2);
+        }
+        L('');
+      } catch (e) {
+        console.error('Error:', e instanceof Error ? e.message : e);
+        process.exit(1);
+      }
+    });
+}
+
+function registerFlowPlan(program: Command): void {
+  program
+    .command('flow-plan')
+    .description('Flow Capability Planner: decompose a flow into legs + selector readiness + contract + run-test plan')
+    .requiredOption('--flow <name>', 'Flow name')
+    .option('--json', 'Output the raw JSON plan')
+    .action((o: { flow: string; json?: boolean }) => {
+      try {
+        const cwd = process.cwd();
+        if (!fs.existsSync(path.join(cwd, 'qa', 'flows', o.flow))) throw new Error(`Flow not found: qa/flows/${o.flow}`);
+        const p = buildFlowPlan(cwd, o.flow);
+
+        const outDir = path.join(cwd, '.sungen', 'reports');
+        fs.mkdirSync(outDir, { recursive: true });
+        const outPath = path.join(outDir, `${o.flow}-flow-plan.json`);
+        fs.writeFileSync(outPath, JSON.stringify(p, null, 2), 'utf-8');
+        if (o.json) { console.log(JSON.stringify(p, null, 2)); return; }
+
+        const L = console.log;
+        L(`\n━━━ Flow Plan: ${p.flow} (${p.total} scenarios) ━━━`);
+        L('  Legs (screen → selector readiness):');
+        for (const leg of p.legs) {
+          const icon = leg.readiness === 'ready' ? '✓' : leg.readiness === 'partial' ? '◐' : '✗';
+          L(`     ${icon} ${leg.screen.padEnd(10)} ${leg.scenarios} scenarios · ${leg.refs.length} refs · selectors ${leg.readiness.toUpperCase()} (${leg.haveKeys}/${leg.refs.length})`);
+        }
+        const reasons = Object.entries(p.byReason).sort().map(([c, n]) => `${c}×${n}`).join('  ') || '(none)';
+        L(`  Manual by reason: ${reasons}   capability-manual ${p.capabilityManual}   judgment ${p.judgmentManual}`);
+        if (p.contracts.length) {
+          L('  Run-test contract:');
+          for (const c of p.contracts) L(`     ⚠ ${c.kind}${c.scenario ? ` · ${c.scenario.slice(0, 50)}` : ''}`);
+        }
+        L(`  Readiness: ${p.readiness === 'ready' ? '✓ READY' : '✗ NOT READY' + (p.missingLegs.length ? ` — missing: ${p.missingLegs.join(', ')}` : '')}`);
+        L('  Plan:');
+        p.plan.forEach((s, i) => L(`     ${i + 1}. ${s}`));
+        L(`\n  Report: ${path.relative(cwd, outPath)}\n`);
+      } catch (e) {
+        console.error('Error:', e instanceof Error ? e.message : e);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/commands/generate.ts

@@ -2,7 +2,9 @@ import { Command } from 'commander';
 import * as path from 'path';
 import * as fs from 'fs';
 import { CodeGenerator } from '../../generators/test-generator/code-generator';
+import { adapterRegistry } from '../../generators/test-generator/adapters';
 import { scanTestDataSecrets } from '../../harness/secret-scan';
+import { readCapabilities, writeCapabilities, driverMeta, loadDriverCatalog } from '../../harness/capability';
 
 /**
  * Find .feature files recursively in a directory
@@ -79,7 +81,7 @@ export function registerGenerateCommand(program: Command): void {
     .option('-s, --screen <name>', 'Generate tests for a specific screen')
     .option('--flow <name>', 'Generate tests for a specific flow')
     .option('--all', 'Generate tests for all screens and flows')
-    .option('--framework <name>', 'Test framework (default: playwright)', 'playwright')
+    .option('--framework <name>', 'Override the platform driver (else read from qa/capabilities.yaml)')
     .option('--inline-data', 'Hardcode test data at compile time instead of runtime loading')
     .action(async (options) => {
       try {
@@ -122,9 +124,33 @@ export function registerGenerateCommand(program: Command): void {
         // Output directory
         const outputDir = path.join(process.cwd(), 'specs', 'generated');
 
+        // Phase 2a — resolve the PLATFORM driver (no silent default to a runtime).
+        // Order: --framework → qa/capabilities.yaml → back-compat web (scaffold + notice).
+        const cwd = process.cwd();
+        let platform = options.framework as string | undefined;
+        if (!platform) {
+          const cap = readCapabilities(cwd);
+          if (cap.platform) {
+            platform = cap.platform;
+          } else {
+            platform = 'web';
+            writeCapabilities(cwd, { platform: 'web', enabled: ['web'] });
+            console.log('ℹ️  No qa/capabilities.yaml — using platform "web" (Playwright) and scaffolding it.');
+            console.log('   Mobile/API projects: see `sungen capability list`.\n');
+          }
+        }
+        // Ensure the platform adapter is available; load an external driver if needed.
+        if (!adapterRegistry.hasAdapter(platform)) {
+          const meta = driverMeta(platform);
+          if (!meta) {
+            throw new Error(`Unknown platform "${platform}". Known: ${Object.keys(loadDriverCatalog()).join(', ')}`);
+          }
+          adapterRegistry.loadDriver(meta.adapter || platform, meta.package, cwd); // throws DriverNotInstalledError if missing
+        }
+
         // Create generator and compile
         const generator = new CodeGenerator({
-          framework: options.framework || 'playwright',
+          framework: platform,
           screenName: screenName || flowName,
           verbose: program.opts().verbose,
           runtimeData: !options.inlineData,

package/src/cli/commands/script-check.ts

@@ -31,7 +31,7 @@ export function registerScriptCheckCommand(program: Command): void {
         L('');
         L(`━━━ Script-check: ${name} — Gherkin ↔ Playwright 1:1 ━━━`);
         L('');
-        L(`  status: ${r.status === 'OK' ? '✓ IN SYNC' : '✗ ' + (r.drift === 'drift' ? 'DRIFT' : 'MISMATCH')}`);
+        L(`  status: ${r.status === 'OK' ? '✓ IN SYNC' : '✗ ' + (r.bypass ? 'BYPASS' : r.drift === 'drift' ? 'DRIFT' : 'MISMATCH')}`);
         L(`  scenarios: ${r.automatedScenarios} automated (+${r.manualScenarios} @manual)   spec test() blocks: ${r.specTestBlocks}   count-match: ${r.countMatch ? '✓' : '✗'}`);
         L(`  drift: ${r.drift}`);
         if (r.driftHunks.length) { L('  differing lines (committed vs fresh regenerate):'); for (const h of r.driftHunks) L(h); }

package/src/cli/index.ts

@@ -22,6 +22,8 @@ import { registerScriptCheckCommand } from './commands/script-check';
 import { registerTraceCommand } from './commands/trace';
 import { registerChallengeCommand } from './commands/challenge';
 import { registerBlindspotCommand } from './commands/blindspot';
+import { registerCapabilityCommand } from './commands/capability';
+import { registerFlowCheckCommand } from './commands/flow-check';
 
 // Read version from package.json so `--version` never drifts from the released version.
 const { version } = require('../../package.json') as { version: string };
@@ -56,6 +58,8 @@ async function main() {
   registerTraceCommand(program);
   registerChallengeCommand(program);
   registerBlindspotCommand(program);
+  registerCapabilityCommand(program);
+  registerFlowCheckCommand(program);
 
   await program.parseAsync(process.argv);
 }

package/src/generators/test-generator/adapters/adapter-interface.ts

@@ -22,6 +22,7 @@ export interface TestFileData {
   screenName?: string; // Screen name for TestDataLoader.load()
   featureFileName?: string; // Feature file name for TestDataLoader.load()
   isParallel?: boolean; // @parallel tag: fresh page per test (opt-out from serial default)
+  flowMode?: boolean;   // flow: cross-screen → longer per-test timeout (bug #243)
   cleanup?: { overlay?: boolean; forms?: boolean; scroll?: boolean; storage?: boolean };
   backgroundSteps?: Array<{ comment?: string; code: string }>; // Raw background steps for serial beforeAll
   scenarios: string[];

package/src/generators/test-generator/adapters/adapter-registry.ts

@@ -1,5 +1,19 @@
+import { createRequire } from 'module';
+import * as path from 'path';
 import { TestGeneratorAdapter } from './adapter-interface';
 
+/** Thrown when a platform/capability driver is selected but its package isn't installed. */
+export class DriverNotInstalledError extends Error {
+  constructor(public adapterName: string, public packageName: string) {
+    super(
+      `No driver for "${adapterName}". Install it for this project:\n` +
+      `    sungen capability add ${adapterName}\n` +
+      `  (installs ${packageName}). Or keep affected scenarios @manual.`,
+    );
+    this.name = 'DriverNotInstalledError';
+  }
+}
+
 /**
  * Adapter Registry
  * Manages available test framework adapters
@@ -50,6 +64,29 @@ export class AdapterRegistry {
   getAvailableAdapters(): string[] {
     return Array.from(this.adapters.keys());
   }
+
+  /**
+   * Load an EXTERNAL driver package (resolved from the PROJECT's node_modules) and
+   * let it register its adapter. Idempotent — a no-op if already registered.
+   * The driver package should export `activate(registry)`; some self-register on import.
+   * @throws DriverNotInstalledError when the package isn't installed in the project.
+   */
+  loadDriver(adapterName: string, packageName: string, cwd: string = process.cwd()): void {
+    const name = adapterName.toLowerCase();
+    if (this.adapters.has(name)) return;
+    const projectRequire = createRequire(path.join(cwd, 'package.json'));
+    let mod: any;
+    try {
+      mod = projectRequire(packageName);
+    } catch {
+      throw new DriverNotInstalledError(adapterName, packageName);
+    }
+    if (typeof mod?.activate === 'function') mod.activate(this);
+    if (!this.adapters.has(name)) {
+      // Package present but didn't register the expected adapter.
+      throw new DriverNotInstalledError(adapterName, packageName);
+    }
+  }
 }
 
 // Singleton instance

package/src/generators/test-generator/adapters/index.ts

@@ -1,5 +1,5 @@
 export { TestGeneratorAdapter, TestFileData, ScenarioData, StepTemplateData, LocatorExpression } from './adapter-interface';
-export { AdapterRegistry, adapterRegistry } from './adapter-registry';
+export { AdapterRegistry, adapterRegistry, DriverNotInstalledError } from './adapter-registry';
 export { PlaywrightAdapter } from './playwright/playwright-adapter';
 
 // Auto-register built-in adapters
@@ -7,3 +7,6 @@ import { adapterRegistry } from './adapter-registry';
 import { PlaywrightAdapter } from './playwright/playwright-adapter';
 
 adapterRegistry.register('playwright', () => new PlaywrightAdapter());
+// Phase 2a: platform alias. `web` is the bundled Playwright adapter (back-compat
+// baseline) until it is externalized to @sungen/driver-web in a later cut.
+adapterRegistry.register('web', () => new PlaywrightAdapter());

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

@@ -13,6 +13,9 @@ const testData = TestDataLoader.load('{{screenName}}', '{{featureFileName}}');
 
 {{#if isParallel}}
 test.describe('{{featureName}}', () => {
+{{#if flowMode}}
+  test.describe.configure({ timeout: 90_000 }); // cross-screen flow — allow for multi-page navigation
+{{/if}}
 {{#if singleAuthRole}}
   test.use({ storageState: 'specs/.auth/{{singleAuthRole}}.json' });
 
@@ -65,6 +68,9 @@ test.describe('{{featureName}}', () => {
 });
 {{else}}
 test.describe.serial('{{featureName}}', () => {
+{{#if flowMode}}
+  test.describe.configure({ timeout: 90_000 }); // cross-screen flow — allow for multi-page navigation
+{{/if}}
   let page: Page;
   let context: BrowserContext;
 

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

@@ -176,8 +176,11 @@ export class CodeGenerator {
     this.options = options;
     this.screenName = options.screenName;
     this.stepMapper = new StepMapper(options);
-    // Get adapter from registry (default: playwright)
-    const frameworkName = options.framework || 'playwright';
+    // Get adapter from registry. Platform comes from the caller (resolved from
+    // qa/capabilities.yaml); default `web` = the bundled Playwright adapter
+    // (back-compat baseline). External platforms (e.g. mobile) are loaded by the
+    // command layer before construction; here we only resolve a registered adapter.
+    const frameworkName = options.framework || 'web';
     this.adapter = adapterRegistry.getAdapter(frameworkName);
     
     if (options.verbose) {
@@ -514,6 +517,7 @@ export class CodeGenerator {
       screenName: isFlowFeature ? `flows/${effectiveScreenName}` : effectiveScreenName,
       featureFileName: featureName,
       isParallel,
+      flowMode: isFlowFeature,
       cleanup,
       backgroundSteps,
       scenarios: needsGrouping ? [] : scenarios,

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

@@ -129,7 +129,9 @@ export const formPatterns: StepPattern[] = [
         data = { ...resolved, selectorRef: step.selectorRef };
       } else {
         const nativeSelectRoles = ['combobox', 'listbox', 'select'];
-        const isNativeSelect = nativeSelectRoles.includes(resolved.role);
+        // A native <select> is detected by its ARIA role, or by an explicit `variant: native`
+        // on the selector entry (lets a CSS/#id-located select opt into .selectOption()).
+        const isNativeSelect = nativeSelectRoles.includes(resolved.role) || resolved.variant === 'native';
 
         if (isNativeSelect) {
           templateName = 'select-action';

package/src/generators/test-generator/utils/runtime-data-transformer.ts

@@ -39,6 +39,14 @@ export function transformToRuntimeData(code: string): string {
     }
   );
 
+  // Pass 3: Bare-identifier context — any marker left after the string/regex passes
+  // sits as a bare token in a numeric position (e.g. `toHaveCount(__marker__)` from the
+  // table/list count templates). testData.get() returns a string, so coerce with Number().
+  code = code.replace(
+    /__SUNGEN_TD_([A-Za-z0-9_]+)__/g,
+    (_, enc) => `Number(testData.get('${decodeKey(enc)}'))`
+  );
+
   return code;
 }
 

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

@@ -312,12 +312,19 @@ export class SelectorResolver {
     const key = SelectorResolver.generateKey(label);
     const selectorFile = this.loadNewSelectorFile(featureName);
 
+    // Flow refs are namespaced "Screen:Element". The namespace is ONLY for selector-key
+    // lookup (key keeps it) — it is NOT part of the DOM accessible name. Strip it for any
+    // name/label fallback (auto-infer or entry without an explicit `name`). Bug #243.
+    const displayLabel = this.flowMode && label.includes(':')
+      ? label.slice(label.indexOf(':') + 1).trim()
+      : label;
+
     // Try nth-suffixed key first: hay.gui.loi.cam.on--3
     if (nth && nth > 0) {
       const nthKey = `${key}--${nth}`;
       const nthEntry = selectorFile[nthKey];
       if (nthEntry) {
-        return this.resolveFromEntry(nthEntry, label);
+        return this.resolveFromEntry(nthEntry, displayLabel);
       }
     }
 
@@ -327,7 +334,7 @@ export class SelectorResolver {
       const typedKey = `${key}--${normalizedType}`;
       const typedEntry = selectorFile[typedKey];
       if (typedEntry) {
-        return this.resolveFromEntry(typedEntry, label);
+        return this.resolveFromEntry(typedEntry, displayLabel);
       }
 
       // If normalized differs from original, also try original as-is
@@ -335,7 +342,7 @@ export class SelectorResolver {
         const originalKey = `${key}--${elementType}`;
         const originalEntry = selectorFile[originalKey];
         if (originalEntry) {
-          return this.resolveFromEntry(originalEntry, label);
+          return this.resolveFromEntry(originalEntry, displayLabel);
         }
       }
     }
@@ -343,12 +350,12 @@ export class SelectorResolver {
     // Fallback to base key
     const entry = selectorFile[key];
     if (entry) {
-      return this.resolveFromEntry(entry, label);
+      return this.resolveFromEntry(entry, displayLabel);
     }
 
     // Auto-infer locator from elementType when no exact YAML entry exists
     if (elementType) {
-      const inferred = SelectorResolver.inferFromElementType(elementType, label);
+      const inferred = SelectorResolver.inferFromElementType(elementType, displayLabel);
       if (inferred) {
         return inferred;
       }
@@ -357,7 +364,7 @@ export class SelectorResolver {
     // Last resort: find any suffixed key matching key--*
     const suffixedKeys = Object.keys(selectorFile).filter(k => k.startsWith(`${key}--`));
     if (suffixedKeys.length > 0) {
-      return this.resolveFromEntry(selectorFile[suffixedKeys[0]], label);
+      return this.resolveFromEntry(selectorFile[suffixedKeys[0]], displayLabel);
     }
 
     const tried: string[] = [];