@sun-asterisk/sungen 2.7.0-beta.1 → 3.0.0-beta.72

package/src/cli/commands/generate.ts

@@ -2,6 +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
@@ -78,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 {
@@ -121,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,
@@ -137,6 +164,24 @@ export function registerGenerateCommand(program: Command): void {
         );
 
         console.log(`\n${results.length} test file(s) generated.`);
+
+        // Security S0 — warn (never block) if test-data looks to hold a real secret.
+        const scanDirs: string[] = [];
+        if (screenName) scanDirs.push(path.join(process.cwd(), 'qa', 'screens', screenName));
+        else if (flowName) scanDirs.push(path.join(process.cwd(), 'qa', 'flows', flowName));
+        else {
+          for (const base of ['screens', 'flows']) {
+            const d = path.join(process.cwd(), 'qa', base);
+            if (fs.existsSync(d)) for (const n of fs.readdirSync(d)) scanDirs.push(path.join(d, n));
+          }
+        }
+        const secretHits = scanDirs.flatMap((d) => scanTestDataSecrets(d));
+        if (secretHits.length) {
+          console.log(`\n⚠️  Possible secret(s) in committed test-data (review — do NOT commit real credentials):`);
+          for (const h of secretHits.slice(0, 10)) console.log(`   ${h.file}:${h.line} — ${h.reason}`);
+          console.log(`   Move real secrets to an env overlay / CI secret; keep test-data placeholders only.`);
+        }
+
         console.log(`Next step: npx playwright test --ui\n`);
       } catch (error) {
         console.error('Error:', error instanceof Error ? error.message : error);

package/src/cli/commands/ledger.ts

@@ -0,0 +1,61 @@
+import { Command } from 'commander';
+import { recordEvent, buildReport } from '../../harness/ledger';
+
+export function registerLedgerCommand(program: Command): void {
+  const ledger = program
+    .command('ledger')
+    .description('Usage ledger: record AI resource per step + report efficiency');
+
+  ledger
+    .command('record')
+    .description('Append a step event to the ledger')
+    .requiredOption('-s, --screen <name>', 'Screen or flow name')
+    .requiredOption('--step <name>', 'Step name (discovery | viewpoint | gherkin | audit | repair:1 ...)')
+    .option('--run <id>', 'Run id — groups all phases of one create-test invocation (else auto-segmented by time gap)')
+    .option('--model <id>', 'Model id')
+    .option('--tokens-in <n>', 'Input tokens', (v) => parseInt(v, 10))
+    .option('--tokens-out <n>', 'Output tokens', (v) => parseInt(v, 10))
+    .option('--ms <n>', 'Duration in ms', (v) => parseInt(v, 10))
+    .option('--note <text>', 'Free note')
+    .action((o) => {
+      try {
+        recordEvent(o.screen, {
+          step: o.step, runId: o.run, model: o.model, tokensIn: o.tokensIn, tokensOut: o.tokensOut, ms: o.ms, note: o.note,
+        });
+        console.log(`✓ ledger: ${o.screen} · ${o.step}`);
+      } catch (e) {
+        console.error('Error:', e instanceof Error ? e.message : e);
+        process.exit(1);
+      }
+    });
+
+  ledger
+    .command('report')
+    .description('Summarise ledger + efficiency verdicts (pulls audit score if present)')
+    .requiredOption('-s, --screen <name>', 'Screen or flow name')
+    .option('--all-runs', 'Aggregate ALL runs (default: latest run only)')
+    .option('--json', 'Output raw JSON')
+    .action((o) => {
+      try {
+        const r = buildReport(o.screen, { allRuns: o.allRuns });
+        if (o.json) { console.log(JSON.stringify(r, null, 2)); return; }
+        const scope = r.runScope === 'all' ? `all ${r.runs} runs` : `latest run${r.runs > 1 ? ` of ${r.runs}` : ''}`;
+        console.log(`\n━━━ Usage Ledger: ${r.screen} (${r.events} events · ${scope}) ━━━`);
+        if (r.runScope === 'latest' && r.runs > 1) console.log(`  (${r.runs} runs on file — use --all-runs to aggregate)`);
+        console.log(`  total tokens: ${r.totalTokens}   total time: ${(r.totalMs / 1000).toFixed(1)}s   repair rounds: ${r.repairRounds}`);
+        if (r.totalTokens) console.log(`  repair token share: ${(r.repairTokenPct * 100).toFixed(0)}%`);
+        if (r.tokensPerCoveredCritical != null) console.log(`  tokens / covered-critical-viewpoint: ${r.tokensPerCoveredCritical}`);
+        if (r.tokensPerScenario != null) console.log(`  tokens / scenario: ${r.tokensPerScenario}`);
+        console.log('  by step:');
+        for (const [step, v] of Object.entries(r.byStep)) {
+          console.log(`    ${step.padEnd(14)} tokens=${v.tokens}  ms=${v.ms}  events=${v.count}`);
+        }
+        console.log('  verdict:');
+        for (const v of r.verdicts) console.log(`    • ${v}`);
+        console.log('');
+      } catch (e) {
+        console.error('Error:', e instanceof Error ? e.message : e);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/commands/manifest.ts

@@ -0,0 +1,55 @@
+import { Command } from 'commander';
+import * as path from 'path';
+import * as fs from 'fs';
+import { buildManifest, diffManifest, loadManifest, saveManifest } from '../../harness/manifest';
+
+function findScreenDir(name: string): string | null {
+  const screen = path.join(process.cwd(), 'qa', 'screens', name);
+  if (fs.existsSync(screen)) return screen;
+  const flow = path.join(process.cwd(), 'qa', 'flows', name);
+  if (fs.existsSync(flow)) return flow;
+  return null;
+}
+
+export function registerManifestCommand(program: Command): void {
+  program
+    .command('manifest')
+    .description('Spec-fingerprint manifest: build a scenario↔spec-section map, or diff to plan keep/regenerate/retire')
+    .option('-s, --screen <name>', 'Screen or flow name')
+    .option('--diff', 'Compare current spec vs stored manifest → change plan')
+    .option('--json', 'Output raw JSON')
+    .action((options) => {
+      try {
+        const name = options.screen;
+        if (!name) throw new Error('Provide --screen <name>');
+        const dir = findScreenDir(name);
+        if (!dir) throw new Error(`Screen/flow not found: ${name}`);
+
+        if (options.diff) {
+          const manifest = loadManifest(name);
+          if (!manifest) throw new Error(`No manifest for "${name}". Run \`sungen manifest --screen ${name}\` first.`);
+          const plan = diffManifest(dir, name, manifest);
+          if (options.json) { console.log(JSON.stringify(plan, null, 2)); process.exit(0); }
+          console.log(`\n━━━ Spec-change plan: ${name} ━━━`);
+          console.log(`  keep=${plan.summary.keep}  regenerate=${plan.summary.regenerate}  retire=${plan.summary.retire}  newSections=${plan.summary.newSections}\n`);
+          for (const s of plan.scenarios.filter((x) => x.change !== 'keep')) {
+            console.log(`  ${s.change === 'regenerate' ? '↻ REGENERATE' : '✗ RETIRE'}: ${s.scenario}`);
+            console.log(`      ${s.reason}`);
+          }
+          if (plan.newSections.length) console.log(`\n  ✚ NEW spec sections (no scenario yet): ${plan.newSections.join(', ')}`);
+          if (plan.summary.regenerate + plan.summary.retire + plan.summary.newSections === 0) console.log('  ✓ Spec unchanged — all scenarios still reflect the spec.');
+          console.log('');
+          return;
+        }
+
+        const manifest = buildManifest(dir, name);
+        const out = saveManifest(manifest);
+        if (options.json) { console.log(JSON.stringify(manifest, null, 2)); return; }
+        console.log(`\n✓ Manifest built: ${manifest.entries.length} scenarios across ${Object.keys(manifest.specSections).length} spec sections`);
+        console.log(`  ${path.relative(process.cwd(), out)}\n`);
+      } catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    });
+}

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

@@ -0,0 +1,50 @@
+import { Command } from 'commander';
+import * as path from 'path';
+import * as fs from 'fs';
+import { runScriptCheck } from '../../harness/script-check';
+
+export function registerScriptCheckCommand(program: Command): void {
+  program
+    .command('script-check')
+    .description('Verify the generated Playwright spec is a faithful 1:1 of the Gherkin feature (no hand-edit / stale drift)')
+    .option('-s, --screen <name>', 'Screen or flow name')
+    .option('--json', 'Output raw JSON')
+    .action(async (options) => {
+      try {
+        const name = options.screen;
+        if (!name) throw new Error('Provide --screen <name>');
+        const screen = path.join(process.cwd(), 'qa', 'screens', name);
+        const flow = path.join(process.cwd(), 'qa', 'flows', name);
+        const flowMode = !fs.existsSync(screen) && fs.existsSync(flow);
+        const dir = fs.existsSync(screen) ? screen : (fs.existsSync(flow) ? flow : null);
+        if (!dir) throw new Error(`Screen/flow not found: ${name}`);
+
+        const r = await runScriptCheck(dir, name, flowMode);
+
+        const outDir = path.join(process.cwd(), '.sungen', 'reports');
+        fs.mkdirSync(outDir, { recursive: true });
+        fs.writeFileSync(path.join(outDir, `${name}-script-check.json`), JSON.stringify(r, null, 2), 'utf-8');
+
+        if (options.json) { console.log(JSON.stringify(r, null, 2)); process.exit(r.status === 'OK' ? 0 : 2); }
+
+        const L = console.log;
+        L('');
+        L(`━━━ Script-check: ${name} — Gherkin ↔ Playwright 1:1 ━━━`);
+        L('');
+        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); }
+        L('');
+        if (r.findings.length) { L('  findings:'); for (const f of r.findings) L(`    • ${f}`); }
+        else L('  ✓ The test code faithfully reflects the Gherkin (1:1).');
+        L('');
+        if (r.drift === 'drift') L('  → Fix: re-run `sungen generate --screen ' + name + '` (or /sungen:run-test) so the spec matches the feature. Never hand-edit generated specs.');
+        L('');
+        process.exit(r.status === 'OK' ? 0 : 2);
+      } catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/commands/trace.ts

@@ -0,0 +1,60 @@
+import { Command } from 'commander';
+import * as path from 'path';
+import * as fs from 'fs';
+import { buildTrace } from '../../harness/trace';
+
+export function registerTraceCommand(program: Command): void {
+  program
+    .command('trace')
+    .description('Visualise the executed test-design process (workflow/skill steps, repair loops), find bottlenecks, and show where to focus human review')
+    .option('-s, --screen <name>', 'Screen or flow name')
+    .option('--json', 'Output raw JSON')
+    .option('--mermaid', 'Print only the Mermaid flowchart')
+    .action((options) => {
+      try {
+        const name = options.screen;
+        if (!name) throw new Error('Provide --screen <name>');
+        const screen = path.join(process.cwd(), 'qa', 'screens', name);
+        const flow = path.join(process.cwd(), 'qa', 'flows', name);
+        const dir = fs.existsSync(screen) ? screen : (fs.existsSync(flow) ? flow : null);
+        if (!dir) throw new Error(`Screen/flow not found: ${name}`);
+
+        const r = buildTrace(dir, name);
+        if (options.json) { console.log(JSON.stringify(r, null, 2)); return; }
+        if (options.mermaid) { console.log(r.mermaid); return; }
+
+        const L = console.log;
+        L('');
+        L(`━━━ Process Trace: ${name} ━━━`);
+        L('');
+        L(`  ① Executed process (from ledger${r.runs > 1 ? ` — latest of ${r.runs} runs` : ''})`);
+        if (r.ledger.length) {
+          for (const e of r.ledger) L(`     → ${e.step.padEnd(12)} ${e.ms}ms`);
+          L(`     repair rounds: ${r.repairRounds}   total recorded: ${(r.totalMs / 1000).toFixed(1)}s`);
+        } else {
+          L('     (ledger empty — process not instrumented this run)');
+        }
+        if (r.missingSteps.length) L(`     ⚠ phases not recorded: ${r.missingSteps.join(', ')}`);
+        L('');
+        L('  ② Quality signals');
+        if (r.audit) L(`     audit score=${r.audit.score}/10  gate=${r.audit.gate}  weakest=${r.audit.weakest}  findings=${r.audit.findings}`);
+        else L('     (no audit report — run `sungen audit`)');
+        L(`     script-check drift: ${r.drift ?? '(not run)'}`);
+        L('');
+        L('  ③ Bottlenecks / weak points');
+        for (const b of r.bottlenecks) L(`     • ${b}`);
+        L('');
+        L('  ④ HUMAN-LOOP FOCUS — where you (the QA) must look');
+        for (const h of r.humanFocus) L(`     ${h.startsWith('   ') ? h : '• ' + h}`);
+        L('');
+        L('  ⑤ Visual map (Mermaid — paste into mermaid.live or a Markdown viewer)');
+        L('  ```mermaid');
+        for (const line of r.mermaid.split('\n')) L('  ' + line);
+        L('  ```');
+        L('');
+      } catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/commands/update.ts

@@ -27,22 +27,35 @@ export function registerUpdateCommand(program: Command): void {
   program
     .command('update')
     .description(
-      'Reinstall @sun-asterisk/sungen@latest + refresh AI rules, commands, and skills',
+      'Reinstall @sun-asterisk/sungen (stable by default, --beta for prerelease) + refresh AI rules, commands, skills',
     )
     .option('--dry-run', 'Show what would be updated without making changes')
+    .option(
+      '--beta',
+      'Switch to the BETA channel (installs @beta — prerelease builds for testing)',
+      false,
+    )
+    .option(
+      '--tag <dist-tag>',
+      'Install a specific npm dist-tag (e.g. latest, beta, next). Overrides --beta.',
+    )
     .option(
       '--skip-npm-install',
-      'Skip the `npm install -g @sun-asterisk/sungen@latest` step (refresh project AI assets only)',
+      'Skip the npm install step (refresh project AI assets only)',
       false,
     )
-    .action(async (options: { dryRun?: boolean; skipNpmInstall?: boolean }) => {
+    .action(async (options: { dryRun?: boolean; beta?: boolean; tag?: string; skipNpmInstall?: boolean }) => {
       try {
         const skipNpm =
           Boolean(options.skipNpmInstall) || process.env[SKIP_NPM_ENV] === '1';
 
+        // Channel resolution via npm dist-tags. Default `latest` = official/stable.
+        // `--beta` → beta channel; running plain `sungen update` later switches back to stable.
+        const channel = options.tag || (options.beta ? 'beta' : 'latest');
+
         if (!skipNpm) {
-          reinstallLatestSungen();
-          printCurrentVersion();
+          reinstallSungen(channel);
+          printCurrentVersion(channel);
           reExecUpdateForAIAssets(options.dryRun ?? false);
           return;
         }
@@ -57,22 +70,29 @@ export function registerUpdateCommand(program: Command): void {
     });
 }
 
-function reinstallLatestSungen(): void {
-  console.log('📦 Installing @sun-asterisk/sungen@latest...');
-  const result = spawnSync('npm', ['install', '-g', '@sun-asterisk/sungen@latest'], {
+function reinstallSungen(channel: string): void {
+  const spec = `@sun-asterisk/sungen@${channel}`;
+  const label = channel === 'latest' ? 'stable (latest)' : `${channel} channel`;
+  console.log(`📦 Installing ${spec}  →  ${label}...`);
+  const result = spawnSync('npm', ['install', '-g', spec], {
     stdio: 'inherit',
     shell: true,
   });
   if (result.status !== 0) {
     throw new Error(
-      'npm install -g @sun-asterisk/sungen@latest failed. Run it manually or check your npm setup.',
+      `npm install -g ${spec} failed. Run it manually or check your npm setup.`,
     );
   }
 }
 
-function printCurrentVersion(): void {
+function printCurrentVersion(channel: string): void {
   console.log('\n🔎 Installed version:');
   spawnSync('sungen', ['--version'], { stdio: 'inherit', shell: true });
+  if (channel === 'latest') {
+    console.log('   Channel: stable. To try prereleases:  sungen update --beta');
+  } else {
+    console.log(`   Channel: ${channel} (prerelease). To return to stable:  sungen update`);
+  }
   console.log('');
 }
 

package/src/cli/index.ts

@@ -14,6 +14,16 @@ import { registerDeliveryCommand } from './commands/delivery';
 import { registerFigmaCommand } from './commands/figma';
 import { registerAddFlowCommand } from './commands/add-flow';
 import { registerDashboardCommand } from './commands/dashboard';
+import { registerAuditCommand } from './commands/audit';
+import { registerManifestCommand } from './commands/manifest';
+import { registerLedgerCommand } from './commands/ledger';
+import { registerFeedbackCommand } from './commands/feedback';
+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 };
@@ -40,6 +50,16 @@ async function main() {
   registerFigmaCommand(program);
   registerAddFlowCommand(program);
   registerDashboardCommand(program);
+  registerAuditCommand(program);
+  registerManifestCommand(program);
+  registerLedgerCommand(program);
+  registerFeedbackCommand(program);
+  registerScriptCheckCommand(program);
+  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/steps/actions/capture-variable.hbs

@@ -0,0 +1 @@
+testData.set('{{varName}}', ((await {{> locator}}.{{capture}}()) ?? '').trim());

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

@@ -0,0 +1,7 @@
+{
+    const __items_{{stepCounter}} = await {{> locator}}.allInnerTexts();
+    expect(__items_{{stepCounter}}.length, 'Expected at least one [{{selectorRef}}]').toBeGreaterThan(0);
+    for (const __t_{{stepCounter}} of __items_{{stepCounter}}) {
+      expect(__t_{{stepCounter}}).toContain('{{expectedText}}');
+    }
+  }

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/capture-patterns.ts

@@ -0,0 +1,59 @@
+import { ParsedStep } from '../../gherkin-parser';
+import { StepPattern, StepTemplateData } from './types';
+
+/**
+ * Capture & collection patterns (P5) — enable cross-screen data consistency and
+ * filter-result correctness that plain single-element assertions can't express.
+ *
+ *  1. Capture:  `User remember [Product Name] text as {{selected_product_name}}`
+ *               → stores the element's text/value into a runtime variable so a
+ *               later step (on another screen) can assert against it.
+ *               REQUIRES runtime data mode (default) — emits `testData.set(...)`.
+ *
+ *  2. List:     `User see all [Product Name] contain {{selected_category}}`
+ *               → asserts EVERY matching element's text contains the value
+ *               (e.g. all products belong to the selected category/brand).
+ */
+export const capturePatterns: StepPattern[] = [
+  {
+    name: 'capture-variable',
+    matcher: (step: ParsedStep) =>
+      /\bremember\b/i.test(step.text) && /\bas\b/i.test(step.text) && !!step.selectorRef && !!step.dataRef,
+    resolver: (step, context): StepTemplateData => {
+      const resolved = context.selectorResolver.resolveSelector(
+        step.selectorRef!, undefined, step.elementType, step.nth,
+      );
+      const varName = step.dataRef!;
+      const isValue = /\bvalue\b/i.test(step.text);
+      // Register so later `{{varName}}` references resolve to testData.get(varName)
+      // and skip YAML validation.
+      context.dataResolver.registerCaptured(varName);
+      return {
+        templateName: 'capture-variable',
+        data: { ...resolved, varName, capture: isValue ? 'inputValue' : 'textContent' },
+        comment: `Remember ${step.selectorRef} ${isValue ? 'value' : 'text'} as ${varName}`,
+      };
+    },
+    priority: 35,
+  },
+  {
+    name: 'all-contain-assertion',
+    matcher: (step: ParsedStep) =>
+      /\b(see|sees)\b/i.test(step.text) &&
+      /\ball\b/i.test(step.text) &&
+      /(contain|contains|match|matches|belong)/i.test(step.text) &&
+      !!step.selectorRef && !!(step.value || step.dataRef),
+    resolver: (step, context): StepTemplateData => {
+      const resolved = context.selectorResolver.resolveSelector(
+        step.selectorRef!, undefined, step.elementType, step.nth,
+      );
+      const expectedText = step.value || context.dataResolver.resolveData(step.dataRef!, context.featureName);
+      return {
+        templateName: 'all-contain-assertion',
+        data: { ...resolved, expectedText, selectorRef: step.selectorRef, stepCounter: context.stepCounter },
+        comment: `Assert all ${step.selectorRef} contain "${step.value || step.dataRef}"`,
+      };
+    },
+    priority: 34,
+  },
+];

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/patterns/index.ts

@@ -10,6 +10,7 @@ import { keyboardPatterns } from './keyboard-patterns';
 import { scrollPatterns } from './scroll-patterns';
 import { scopePatterns } from './scope-patterns';
 import { tablePatterns } from './table-patterns';
+import { capturePatterns } from './capture-patterns';
 
 /**
  * Pattern Registry - manages all step patterns
@@ -34,6 +35,7 @@ export class PatternRegistry {
     this.patterns.push(...scrollPatterns);
     this.patterns.push(...scopePatterns);
     this.patterns.push(...tablePatterns);
+    this.patterns.push(...capturePatterns);
 
     // Sort by priority (higher first)
     this.patterns.sort((a, b) => (b.priority || 0) - (a.priority || 0));

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

@@ -90,6 +90,7 @@ export class StepMapper {
     this.inRowScope = false;
     this.rowScopeTable = '';
     this.lastPrimaryKeyword = 'Given';
+    this.dataResolver.clearCaptured(); // captured vars are scenario-scoped
     this.templateEngine.resetBaseContext();
   }