@sun-asterisk/sungen 2.6.11 → 2.6.14

package/src/cli/commands/delivery.ts

@@ -11,6 +11,7 @@ import { parse as parseYaml } from 'yaml';
 import { parseFeatureMetadata } from '../../exporters/feature-parser';
 import { parseSpecFile } from '../../exporters/spec-parser';
 import { loadTestData } from '../../exporters/test-data-resolver';
+import { loadSelectorKeyMap } from '../../exporters/selector-key-resolver';
 import { loadPlaywrightReport } from '../../exporters/playwright-report-parser';
 import { mergeFeatureAndSpec } from '../../exporters/scenario-merger';
 import {
@@ -19,8 +20,8 @@ import {
   renderCsv,
   writeCsv,
 } from '../../exporters/csv-exporter';
-import { renderXlsx, writeXlsx } from '../../exporters/xlsx-exporter';
-import { EnvironmentInfo, PreflightCheck, ScreenSummary } from '../../exporters/types';
+import { renderXlsx, renderXlsxMultiSheet, writeXlsx } from '../../exporters/xlsx-exporter';
+import { EnvironmentInfo, PreflightCheck, ScreenSummary, TestCaseRow } from '../../exporters/types';
 
 const COLOR = {
   reset: '\x1b[0m',
@@ -40,46 +41,95 @@ function log(msg: string): void {
 // Discovery
 // ----------------------------------------------------------------------------
 
+/**
+ * A single feature file inside a screen/flow. One DeliveryTarget = one CSV/XLSX.
+ *
+ * `screen` is the parent directory name under qa/screens or qa/flows.
+ * `featureBaseName` is the .feature file basename without extension — typically
+ * either `<screen>` (the main feature) or `<screen>-<sub>` (sub-features like
+ * `home-modal`). All co-located YAML/spec/result files share this basename.
+ *
+ * `name` is kept as an alias of `featureBaseName` so existing callers/labels
+ * (preflight table, summary) read naturally — every visible row is per-feature.
+ */
 interface DeliveryTarget {
+  screen: string;
+  featureBaseName: string;
+  /** Alias of `featureBaseName` — preserves the old `target.name` call sites. */
   name: string;
   isFlow: boolean;
 }
 
+function makeTarget(screen: string, featureBaseName: string, isFlow: boolean): DeliveryTarget {
+  return { screen, featureBaseName, name: featureBaseName, isFlow };
+}
+
+/**
+ * List all `.feature` files inside a screen/flow as separate targets.
+ * Returns empty array when the directory has no features yet.
+ */
+function listFeatureTargets(cwd: string, screen: string, isFlow: boolean): DeliveryTarget[] {
+  const featuresDir = path.join(cwd, 'qa', isFlow ? 'flows' : 'screens', screen, 'features');
+  if (!fs.existsSync(featuresDir)) return [];
+  return fs.readdirSync(featuresDir)
+    .filter((f) => f.endsWith('.feature'))
+    .map((f) => makeTarget(screen, f.slice(0, -'.feature'.length), isFlow))
+    .sort((a, b) => a.featureBaseName.localeCompare(b.featureBaseName));
+}
+
 function listAllTargets(cwd: string): DeliveryTarget[] {
   const targets: DeliveryTarget[] = [];
 
   const screensDir = path.join(cwd, 'qa', 'screens');
   if (fs.existsSync(screensDir)) {
     for (const d of fs.readdirSync(screensDir, { withFileTypes: true })) {
-      if (d.isDirectory()) targets.push({ name: d.name, isFlow: false });
+      if (d.isDirectory()) targets.push(...listFeatureTargets(cwd, d.name, false));
     }
   }
 
   const flowsDir = path.join(cwd, 'qa', 'flows');
   if (fs.existsSync(flowsDir)) {
     for (const d of fs.readdirSync(flowsDir, { withFileTypes: true })) {
-      if (d.isDirectory()) targets.push({ name: d.name, isFlow: true });
+      if (d.isDirectory()) targets.push(...listFeatureTargets(cwd, d.name, true));
     }
   }
 
-  return targets.sort((a, b) => a.name.localeCompare(b.name));
+  return targets.sort((a, b) => a.featureBaseName.localeCompare(b.featureBaseName));
 }
 
-function resolveTargetType(cwd: string, name: string): DeliveryTarget {
+/**
+ * Resolve a positional CLI argument to one or more delivery targets.
+ *
+ * The argument can be EITHER:
+ *  - A screen / flow name (e.g. `home`)  → all features inside that screen
+ *  - A specific feature basename (`home-modal`) → just that feature
+ *
+ * We detect by checking for a directory match first; if none, we search for a
+ * feature file with the basename across all screens & flows.
+ */
+function resolveTargetsFromArg(cwd: string, name: string): DeliveryTarget[] {
   if (fs.existsSync(path.join(cwd, 'qa', 'flows', name))) {
-    return { name, isFlow: true };
+    return listFeatureTargets(cwd, name, true);
   }
-  return { name, isFlow: false };
+  if (fs.existsSync(path.join(cwd, 'qa', 'screens', name))) {
+    return listFeatureTargets(cwd, name, false);
+  }
+  // Treat as feature basename — find the parent screen/flow that hosts it.
+  const candidates = listAllTargets(cwd).filter((t) => t.featureBaseName === name);
+  if (candidates.length > 0) return candidates;
+  // Fallback: treat as screen name even if directory missing (lets preflight
+  // surface the "feature file missing" error with the right path).
+  return [makeTarget(name, name, false)];
 }
 
 function qaDir(cwd: string, target: DeliveryTarget): string {
-  return path.join(cwd, 'qa', target.isFlow ? 'flows' : 'screens', target.name);
+  return path.join(cwd, 'qa', target.isFlow ? 'flows' : 'screens', target.screen);
 }
 
 function generatedDir(cwd: string, target: DeliveryTarget): string {
   return target.isFlow
-    ? path.join(cwd, 'specs', 'generated', 'flows', target.name)
-    : path.join(cwd, 'specs', 'generated', target.name);
+    ? path.join(cwd, 'specs', 'generated', 'flows', target.screen)
+    : path.join(cwd, 'specs', 'generated', target.screen);
 }
 
 // ----------------------------------------------------------------------------
@@ -88,19 +138,96 @@ function generatedDir(cwd: string, target: DeliveryTarget): string {
 
 /**
  * Resolve the results file path for a target.
- * Prefer the per-target co-located file, fall back to the global `test-results/results.json`.
+ *
+ * Lookup order (first existing wins):
+ *   1. Per-target env-specific:  `<gen>/<name>-test-result.<SUNGEN_ENV>.json`
+ *   2. Per-target base:          `<gen>/<name>-test-result.json`
+ *   3. Global env-specific:      `test-results/results.<SUNGEN_ENV>.json`
+ *   4. Global base:              `test-results/results.json`
+ *
+ * The env-suffixed names mirror what `playwright.config.ts` writes when
+ * `SUNGEN_ENV` is set, so each locale run keeps its own results file.
  */
 function resolveResultsPath(cwd: string, target: DeliveryTarget): string | null {
   const genDir = generatedDir(cwd, target);
-  const perTarget = path.join(genDir, `${target.name}-test-result.json`);
-  if (fs.existsSync(perTarget)) return perTarget;
-  const global = path.join(cwd, 'test-results', 'results.json');
-  if (fs.existsSync(global)) return global;
+  const env = process.env.SUNGEN_ENV;
+  const candidates: string[] = [];
+  if (env) candidates.push(path.join(genDir, `${target.featureBaseName}-test-result.${env}.json`));
+  candidates.push(path.join(genDir, `${target.featureBaseName}-test-result.json`));
+  if (env) candidates.push(path.join(cwd, 'test-results', `results.${env}.json`));
+  candidates.push(path.join(cwd, 'test-results', 'results.json'));
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c;
+  }
   return null;
 }
 
+/**
+ * A single locale variant of a delivery target.
+ *
+ * `locale === ''` denotes the base locale (file `<name>-test-result.json`,
+ * test-data without overlay). Non-empty values come from
+ * `<name>-test-result.<locale>.json` files found in the generated directory.
+ *
+ * `displayCode` is what we show in sheet names — `BASE_LOCALE.toUpperCase()`
+ * for base, the locale code uppercased otherwise (e.g. `EN`, `JA`, `EN-US`).
+ */
+interface LocaleVariant {
+  locale: string;          // '' for base, 'en' / 'ja' / 'staging-ja' for variants
+  displayCode: string;     // 'VI' / 'EN' / 'JA' — used in sheet name
+  resultsPath: string | null;
+}
+
+/**
+ * Base locale assumed when no `SUNGEN_ENV` and no explicit override.
+ * Configurable later via `qa/.sungen-config.yaml` or similar — currently
+ * hardcoded since every existing sungen project uses Vietnamese as the
+ * source-of-truth `test-data/<feature>.yaml`.
+ */
+const DEFAULT_BASE_LOCALE = 'vi';
+
+/**
+ * Discover every locale variant available for a feature by scanning the
+ * generated directory for `<featureBaseName>-test-result*.json` files.
+ *
+ * Result always includes the base (locale = '') as the first entry — even if
+ * `<name>-test-result.json` doesn't exist, callers still need somewhere to
+ * fall back to (Pending status). Variants follow alphabetically by locale
+ * code, so the sheet order is deterministic across runs.
+ */
+function discoverLocaleVariants(cwd: string, target: DeliveryTarget): LocaleVariant[] {
+  const genDir = generatedDir(cwd, target);
+  const prefix = `${target.featureBaseName}-test-result`;
+  const variants: LocaleVariant[] = [];
+
+  const basePath = path.join(genDir, `${prefix}.json`);
+  variants.push({
+    locale: '',
+    displayCode: DEFAULT_BASE_LOCALE.toUpperCase(),
+    resultsPath: fs.existsSync(basePath) ? basePath : null,
+  });
+
+  if (fs.existsSync(genDir)) {
+    const localeFiles = fs.readdirSync(genDir)
+      .filter((f) => f.startsWith(`${prefix}.`) && f.endsWith('.json') && f !== `${prefix}.json`)
+      .sort();
+    for (const f of localeFiles) {
+      // Strip prefix + '.' on the left, '.json' on the right → locale code.
+      const locale = f.slice(prefix.length + 1, -'.json'.length);
+      if (!locale) continue;
+      variants.push({
+        locale,
+        displayCode: locale.toUpperCase(),
+        resultsPath: path.join(genDir, f),
+      });
+    }
+  }
+
+  return variants;
+}
+
 function resolveTestDataPathForTarget(cwd: string, target: DeliveryTarget): string {
-  return path.join(qaDir(cwd, target), 'test-data', `${target.name}.yaml`);
+  return path.join(qaDir(cwd, target), 'test-data', `${target.featureBaseName}.yaml`);
 }
 
 /**
@@ -126,42 +253,45 @@ function readFlowPagePath(selectorsFile: string): string | undefined {
 function runPreflight(cwd: string, target: DeliveryTarget): PreflightCheck {
   const base = qaDir(cwd, target);
   const genBase = generatedDir(cwd, target);
-  const featureFile = path.join(base, 'features', `${target.name}.feature`);
+  const featureFile = path.join(base, 'features', `${target.featureBaseName}.feature`);
   const testDataFile = resolveTestDataPathForTarget(cwd, target);
-  const selectorsFile = path.join(base, 'selectors', `${target.name}.yaml`);
-  const specFile = path.join(genBase, `${target.name}.spec.ts`);
+  const selectorsFile = path.join(base, 'selectors', `${target.featureBaseName}.yaml`);
+  const specFile = path.join(genBase, `${target.featureBaseName}.spec.ts`);
   const resultsFile = resolveResultsPath(cwd, target);
 
   const featureOk = checkFeatureReal(featureFile);
   const testDataOk = checkTestDataHasVars(testDataFile);
-  const selectorsOk = checkSelectorsHasEntries(selectorsFile, target.name);
+  const selectorsOk = checkSelectorsHasEntries(selectorsFile, target.featureBaseName);
   const specOk = fs.existsSync(specFile);
   const resultsOk = resultsFile !== null;
 
-  const label = target.isFlow ? `flow/${target.name}` : target.name;
+  const label = target.isFlow ? `flow/${target.featureBaseName}` : target.featureBaseName;
   const missing: string[] = [];
   const suggestions: string[] = [];
 
   if (!featureOk) {
     missing.push(`feature file missing/empty: ${path.relative(cwd, featureFile)}`);
-    suggestions.push(`/sungen:create-test ${target.name}`);
+    suggestions.push(`/sungen:create-test ${target.screen}`);
   }
   if (!testDataOk) {
     missing.push(`test-data.yaml has no variables: ${path.relative(cwd, testDataFile)}`);
-    suggestions.push(`/sungen:create-test ${target.name}`);
+    suggestions.push(`/sungen:create-test ${target.screen}`);
   }
   if (!selectorsOk) {
     missing.push(`selectors.yaml missing entries: ${path.relative(cwd, selectorsFile)}`);
-    suggestions.push(`/sungen:run-test ${target.name}`);
+    suggestions.push(`/sungen:run-test ${target.screen}`);
   }
   if (!specOk) {
     missing.push(`compiled .spec.ts missing: ${path.relative(cwd, specFile)}`);
-    suggestions.push(target.isFlow ? `sungen generate --flow ${target.name}` : `sungen generate --screen ${target.name}`);
+    suggestions.push(target.isFlow ? `sungen generate --flow ${target.screen}` : `sungen generate --screen ${target.screen}`);
   }
   if (!resultsOk) {
-    missing.push(`test-result.json missing (optional)`);
+    const env = process.env.SUNGEN_ENV;
+    const envSuffix = env ? `.${env}` : '';
+    missing.push(`test-result${envSuffix}.json missing (optional)`);
     const genRel = path.relative(cwd, genBase);
-    suggestions.push(`PLAYWRIGHT_JSON_OUTPUT_NAME=${genRel}/${target.name}-test-result.json npx playwright test ${genRel}/${target.name}.spec.ts`);
+    const envPrefix = env ? `SUNGEN_ENV=${env} ` : '';
+    suggestions.push(`${envPrefix}PLAYWRIGHT_JSON_OUTPUT_NAME=${genRel}/${target.featureBaseName}-test-result.json npx playwright test ${genRel}/${target.featureBaseName}.spec.ts`);
   }
 
   return {
@@ -247,45 +377,102 @@ async function exportTarget(
 ): Promise<ScreenSummary | null> {
   const base = qaDir(cwd, target);
   const genBase = generatedDir(cwd, target);
-  const featureFile = path.join(base, 'features', `${target.name}.feature`);
+  const featureFile = path.join(base, 'features', `${target.featureBaseName}.feature`);
   const testDataFile = resolveTestDataPathForTarget(cwd, target);
-  const specFile = path.join(genBase, `${target.name}.spec.ts`);
-  const resultsFile = resolveResultsPath(cwd, target);
+  const specFile = path.join(genBase, `${target.featureBaseName}.spec.ts`);
   const specMdFile = path.join(base, 'requirements', 'spec.md');
-  const label = target.isFlow ? `flow/${target.name}` : target.name;
+  const label = target.isFlow ? `flow/${target.featureBaseName}` : target.featureBaseName;
 
   try {
     const feature = parseFeatureMetadata(featureFile);
     const spec = parseSpecFile(specFile);
-    const testData = loadTestData(testDataFile);
-    const results = resultsFile ? loadPlaywrightReport(resultsFile) : null;
 
     const merged = mergeFeatureAndSpec(feature, spec);
     // Screens get their URL path from the .feature file directly. Flows record
-    // it in selectors/<name>.yaml under the page-selector block — fall back to
-    // that so the Environment column shows a full URL for flows too.
+    // it in selectors/<feature>.yaml under the page-selector block — fall back
+    // to that so the Environment column shows a full URL for flows too.
     let featurePath = feature.featurePath;
+    const selectorsFile = path.join(base, 'selectors', `${target.featureBaseName}.yaml`);
     if (!featurePath && target.isFlow) {
-      const selectorsFile = path.join(base, 'selectors', `${target.name}.yaml`);
       featurePath = readFlowPagePath(selectorsFile);
     }
-    const rows = buildTestCaseRows({
-      screen: label,
-      featureName: feature.featureName,
-      featurePath,
-      merged,
-      testData,
-      results,
-      env,
-    });
+    const selectorKeyMap = loadSelectorKeyMap(selectorsFile);
 
     const specLink = fs.existsSync(specMdFile) ? path.relative(cwd, specMdFile) : '';
-    const tempSummary = buildSummary(label, rows, '');
-    const csv = renderCsv(tempSummary, rows, specLink);
-    const csvPath = writeCsv(cwd, target.name, csv);
-    const wb = renderXlsx(tempSummary, rows, specLink);
-    await writeXlsx(cwd, target.name, wb);
-    return buildSummary(label, rows, path.relative(cwd, csvPath));
+    const explicitEnv = process.env.SUNGEN_ENV;
+
+    // Decide between single-locale and aggregated multi-locale flows.
+    //   • SUNGEN_ENV set → single locale (existing behaviour, no change)
+    //   • SUNGEN_ENV unset → discover every *-test-result*.json variant.
+    //     2+ variants → XLSX with one sheet per locale (`<feature>-<LOCALE>`),
+    //                   one CSV per locale (CSV has no sheet concept).
+    //     <2 variants → single-sheet XLSX with the canonical 'Testcases' sheet.
+    if (explicitEnv) {
+      const rows = buildTestCaseRows({
+        screen: label,
+        featureName: feature.featureName,
+        featurePath,
+        merged,
+        testData: loadTestData(testDataFile),
+        results: resolveResultsPath(cwd, target) ? loadPlaywrightReport(resolveResultsPath(cwd, target)!) : null,
+        env,
+        selectorKeyMap,
+      });
+      const tempSummary = buildSummary(label, rows, '');
+      const csv = renderCsv(tempSummary, rows, specLink);
+      const csvPath = writeCsv(cwd, target.featureBaseName, csv);
+      const wb = renderXlsx(tempSummary, rows, specLink);
+      await writeXlsx(cwd, target.featureBaseName, wb);
+      return buildSummary(label, rows, path.relative(cwd, csvPath));
+    }
+
+    const variants = discoverLocaleVariants(cwd, target);
+    let primarySummary: ScreenSummary | null = null;
+    let primaryCsvPath = '';
+    const sheets: { sheetName: string; summary: ScreenSummary; rows: TestCaseRow[]; specLink: string }[] = [];
+
+    for (const variant of variants) {
+      // For the base variant the overlay merge is skipped (`locale: null`);
+      // for locale variants the matching `<feature>.<locale>.yaml` is merged.
+      const variantTestData = loadTestData(testDataFile, variant.locale || null);
+      const variantResults = variant.resultsPath ? loadPlaywrightReport(variant.resultsPath) : null;
+      const variantRows = buildTestCaseRows({
+        screen: label,
+        featureName: feature.featureName,
+        featurePath,
+        merged,
+        testData: variantTestData,
+        results: variantResults,
+        env,
+        selectorKeyMap,
+      });
+      const variantSummary = buildSummary(label, variantRows, '');
+
+      // CSV: always one file per locale (CSV has no sheet concept).
+      const csvLocale = variant.locale || null; // '' or 'en' → '' / 'en'
+      const csv = renderCsv(variantSummary, variantRows, specLink);
+      const csvPath = writeCsv(cwd, target.featureBaseName, csv, csvLocale);
+
+      sheets.push({
+        sheetName: `${target.featureBaseName}-${variant.displayCode}`,
+        summary: variantSummary,
+        rows: variantRows,
+        specLink,
+      });
+
+      // Use the base variant's summary as the "primary" return value so the
+      // top-level reporter rolls up base-locale numbers.
+      if (variant.locale === '') {
+        primarySummary = buildSummary(label, variantRows, path.relative(cwd, csvPath));
+        primaryCsvPath = csvPath;
+      }
+    }
+
+    // XLSX: single-sheet when only base, multi-sheet when 2+ locales found.
+    const wb = sheets.length >= 2 ? renderXlsxMultiSheet(sheets) : renderXlsx(sheets[0].summary, sheets[0].rows, specLink);
+    await writeXlsx(cwd, target.featureBaseName, wb);
+
+    return primarySummary ?? buildSummary(label, sheets[0].rows, primaryCsvPath);
   } catch (err) {
     console.error(`${COLOR.red}Error exporting ${label}:${COLOR.reset} ${err instanceof Error ? err.message : err}`);
     return null;
@@ -301,10 +488,11 @@ function printPreflightTable(checks: PreflightCheck[]): void {
   log(`${COLOR.gray}Columns: feature | test-data | selectors | .spec.ts | test-result.json${COLOR.reset}\n`);
 
   const ok = (b: boolean) => (b ? `${COLOR.green}✓${COLOR.reset}` : `${COLOR.red}✗${COLOR.reset}`);
+  const colWidth = Math.max(20, ...checks.map((c) => c.screen.length)) + 2;
 
   for (const c of checks) {
     log(
-      `  ${c.screen.padEnd(20)} ${ok(c.featureOk)}  ${ok(c.testDataOk)}  ${ok(c.selectorsOk)}  ${ok(c.specOk)}  ${ok(c.resultsOk)}`
+      `  ${c.screen.padEnd(colWidth)}${ok(c.featureOk)}  ${ok(c.testDataOk)}  ${ok(c.selectorsOk)}  ${ok(c.specOk)}  ${ok(c.resultsOk)}`
     );
   }
   log('');
@@ -335,11 +523,12 @@ function printPreflightTable(checks: PreflightCheck[]): void {
 function printSummaryTable(summaries: ScreenSummary[]): void {
   log(`\n${COLOR.bold}Delivery export complete${COLOR.reset}`);
   log('');
-  log('  Screen               TCs  Passed  Failed  Pending  N/A  File');
-  log('  ' + '-'.repeat(80));
+  const colWidth = Math.max(20, ...summaries.map((s) => s.screen.length)) + 1;
+  log(`  ${'Feature'.padEnd(colWidth)}TCs  Passed  Failed  Pending  N/A  File`);
+  log('  ' + '-'.repeat(colWidth + 60));
   for (const s of summaries) {
     log(
-      `  ${s.screen.padEnd(20)} ${String(s.total).padStart(3)}  ${String(s.passed).padStart(6)}  ${String(s.failed).padStart(6)}  ${String(s.pending).padStart(7)}  ${String(s.na).padStart(3)}  ${s.outputFile}`
+      `  ${s.screen.padEnd(colWidth)}${String(s.total).padStart(3)}  ${String(s.passed).padStart(6)}  ${String(s.failed).padStart(6)}  ${String(s.pending).padStart(7)}  ${String(s.na).padStart(3)}  ${s.outputFile}`
     );
   }
   log('');
@@ -365,20 +554,22 @@ export function registerDeliveryCommand(program: Command): void {
       try {
         const cwd = process.cwd();
 
-        // 1. Scope detection
+        // 1. Scope detection — each positional name expands into one target
+        //    per `.feature` file inside that screen/flow. Passing a specific
+        //    feature basename (e.g. `home-modal`) narrows to that one file.
         let targets: DeliveryTarget[];
         if (names && names.length > 0) {
-          targets = names.map((n) => resolveTargetType(cwd, n));
+          targets = names.flatMap((n) => resolveTargetsFromArg(cwd, n));
         } else {
           targets = listAllTargets(cwd);
-          if (targets.length === 0) {
-            console.error(`${COLOR.red}No screens or flows found in qa/screens/ or qa/flows/${COLOR.reset}`);
-            process.exit(1);
-          }
+        }
+        if (targets.length === 0) {
+          console.error(`${COLOR.red}No .feature files found in qa/screens/ or qa/flows/${COLOR.reset}`);
+          process.exit(1);
         }
 
-        const labels = targets.map((t) => t.isFlow ? `flow/${t.name}` : t.name);
-        log(`${COLOR.bold}sungen delivery${COLOR.reset} — exporting ${targets.length} target(s): ${labels.join(', ')}\n`);
+        const labels = targets.map((t) => t.isFlow ? `flow/${t.featureBaseName}` : t.featureBaseName);
+        log(`${COLOR.bold}sungen delivery${COLOR.reset} — exporting ${targets.length} feature(s): ${labels.join(', ')}\n`);
 
         // 2. Pre-flight
         let toExport: DeliveryTarget[];
@@ -395,7 +586,7 @@ export function registerDeliveryCommand(program: Command): void {
                 checks.filter((c) => !hasBlockingMissing(c)).map((c) => c.screen)
               );
               toExport = targets.filter((t) => {
-                const label = t.isFlow ? `flow/${t.name}` : t.name;
+                const label = t.isFlow ? `flow/${t.featureBaseName}` : t.featureBaseName;
                 return passedScreens.has(label);
               });
               log(`${COLOR.yellow}Continuing with ${toExport.length} ready target(s).${COLOR.reset}\n`);

package/src/cli/index.ts

@@ -21,7 +21,7 @@ async function main() {
   program
     .name('sungen')
     .description('Deterministic E2E Test Compiler — Gherkin + Selectors → Playwright')
-    .version('2.6.11');
+    .version('2.6.14');
 
   // Global options
   program