@sun-asterisk/sungen 3.2.16-beta.7 → 3.2.17

package/src/exporters/spec-parser.ts

@@ -165,7 +165,7 @@ function classifyBlock(block: CodeBlock): 'precondition' | 'step' | 'expectation
  * Try to extract VP ID (e.g., VP-UI-001) from the start of a scenario title.
  */
 function extractVpId(title: string): string | undefined {
-  const match = title.match(/^(VP-[A-Z][A-Z0-9]*-\d+(?:[a-zA-Z]|-[A-Z0-9]+)?)\b/);
+  const match = title.match(/^(VP-[A-Z][A-Z0-9]*-\d+[a-zA-Z]?)\b/);
   return match ? match[1] : undefined;
 }
 

package/src/exporters/xlsx-report-builder.ts

@@ -143,7 +143,6 @@ export function renderReportHeaderBand(
   ws: ExcelJS.Worksheet,
   titleLabel: string,
   sungenVersion?: string,
-  formNo: string = 'BM-2-901-13',
 ): void {
   const issueDate = (() => {
     const d = new Date();
@@ -188,9 +187,9 @@ export function renderReportHeaderBand(
   d1.alignment = { horizontal: 'center', vertical: 'middle', wrapText: true };
   d1.border = allBordersBlack;
 
-  // G1 — No: <form number> (the company ISO form id; configurable via the delivery map)
+  // G1 — No: BM-2-901-13
   const g1 = ws.getCell('G1');
-  g1.value = `No: ${formNo}`;
+  g1.value = 'No: BM-2-901-13';
   g1.font = { size: 12, name: TIMES };
   g1.alignment = { vertical: 'middle' };
   g1.border = { top: thinBlack, left: thinBlack, right: thinBlack };

package/src/generators/test-generator/adapters/playwright/templates/steps/actions/click-action.hbs

@@ -1 +1 @@
-await {{> locator}}.click();
+await {{> locator}}.click({{#if force}}{ force: true }{{/if}});

package/src/generators/test-generator/adapters/playwright/templates/steps/actions/click-element-with-text.hbs

@@ -1 +1 @@
-await {{> locator-base}}.filter({ hasText: {{> has-text-value dataValue=dataValue exact=exact legacyTail=(and (eq strategy "text") (eq value ""))}} }){{> locator-nth}}.click();
+await {{> locator-base}}.filter({ hasText: {{> has-text-value dataValue=dataValue exact=exact legacyTail=(and (eq strategy "text") (eq value ""))}} }){{> locator-nth}}.click({{#if force}}{ force: true }{{/if}});

package/src/generators/test-generator/adapters/playwright/templates/steps/navigation/wait-timeout.hbs

@@ -1 +1 @@
-await page.waitForLoadState('networkidle');
+await page.waitForTimeout({{duration}});

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

@@ -18,30 +18,36 @@ export function transformToRuntimeData(code: string, accessor: string = 'testDat
     (_, indent, before, enc, after) => `${indent}//${before}${decodeKey(enc)}${after}`
   );
 
-  // Pass 1: String literal context — handles both whole-string and embedded markers
-  // 'marker'                    → testData.get('key')
-  // 'prefix__marker__suffix'    → `prefix${testData.get('key')}suffix`
+  // Pass 1: String literal context — a literal may carry SEVERAL markers
+  // ('/{{code}}/car-search?{{prefill}}' compiles to two markers in ONE literal).
+  // Match the whole quoted literal that contains at least one marker, then
+  // interpolate EVERY marker inside it. The old shape (one marker + lazy
+  // prefix/suffix) swallowed trailing markers into its suffix verbatim; they
+  // escaped the quote context (the literal had become a backtick template) and
+  // Pass 3's numeric catch-all emitted them as literal
+  // `Number(testData.get(...))` TEXT inside the template — a compiling spec
+  // navigating to a garbage URL.
+  // 'marker'          → testData.get('key')
+  // 'a__m1__b__m2__c' → `a${testData.get('k1')}b${testData.get('k2')}c`
   code = code.replace(
-    /(['"])((?:(?!\1).)*?)__SUNGEN_TD_([A-Za-z0-9_]+)__((?:(?!\1).)*?)\1/g,
-    (_, _quote, prefix, enc, suffix) => {
-      const key = decodeKey(enc);
-      if (!prefix && !suffix) {
-        return `${accessor}.get('${key}')`;
-      }
-      return `\`${prefix}\${${accessor}.get('${key}')}${suffix}\``;
+    /(['"])((?:(?!\1).)*?__SUNGEN_TD_[A-Za-z0-9_]+__(?:(?!\1).)*)\1/g,
+    (_, _quote, body) => {
+      const whole = /^__SUNGEN_TD_([A-Za-z0-9_]+)__$/.exec(body);
+      if (whole) return `${accessor}.get('${decodeKey(whole[1])}')`;
+      return `\`${interpolateMarkers(body, accessor)}\``;
     }
   );
 
-  // Pass 2: Regex literal context — /prefix__marker__suffix/ → new RegExp(`...`)
-  // Only matches within a single line (no newlines in prefix/suffix)
+  // Pass 2: Regex literal context — /…__marker__…/ → new RegExp(`…`). Same
+  // several-markers-per-literal rule as Pass 1 (/{{min}}-{{max}} items/).
+  // Only matches within a single line (no newlines in the body).
   code = code.replace(
-    /\/((?:[^/\\\n]|\\.)*?)__SUNGEN_TD_([A-Za-z0-9_]+)__((?:[^/\\\n]|\\.)*?)\/([gimsuy]*)/g,
-    (_, prefix, enc, suffix, flags) => {
-      const key = decodeKey(enc);
-      const ref = `${accessor}.get('${key}')`;
+    /\/((?:[^/\\\n]|\\.)*?__SUNGEN_TD_[A-Za-z0-9_]+__(?:[^/\\\n]|\\.)*)\/([gimsuy]*)/g,
+    (_, body, flags) => {
       const flagStr = flags ? `, '${flags}'` : '';
-      if (!prefix && !suffix) return `new RegExp(${ref}${flagStr})`;
-      return `new RegExp(\`${prefix}\${${ref}}${suffix}\`${flagStr})`;
+      const whole = /^__SUNGEN_TD_([A-Za-z0-9_]+)__$/.exec(body);
+      if (whole) return `new RegExp(${accessor}.get('${decodeKey(whole[1])}')${flagStr})`;
+      return `new RegExp(\`${interpolateMarkers(body, accessor)}\`${flagStr})`;
     }
   );
 
@@ -63,3 +69,8 @@ export function hasRuntimeDataMarkers(code: string): boolean {
 function decodeKey(encoded: string): string {
   return encoded.replace(/_D_/g, '.');
 }
+
+/** Replace every marker in a literal's body with a `${accessor.get('key')}` interpolation. */
+function interpolateMarkers(body: string, accessor: string): string {
+  return body.replace(/__SUNGEN_TD_([A-Za-z0-9_]+)__/g, (_, enc) => `\${${accessor}.get('${decodeKey(enc)}')}`);
+}

package/src/ingest/legacy-parser.ts

@@ -30,6 +30,9 @@ export interface LegacyInventory {
   source: { file: string };
   sheets: SheetInfo[];
   testcases: LegacyTestcase[];
+  /** Anti-silence guards: convention mismatches that would otherwise drop data quietly
+   *  (near-miss headers, testcase tab with 0 rows, mandatory column empty on every row). */
+  warnings?: string[];
 }
 
 // ---- quote-aware CSV parser (embedded commas + newlines) ----
@@ -49,7 +52,11 @@ export function parseCSV(text: string): string[][] {
   return rows;
 }
 
-const norm = (s: string | undefined) => (s || '').replace(/\*/g, '').trim().toLowerCase();
+// Strip the "required" decoration `(*)` BEFORE stray asterisks: legacy workbooks
+// mark mandatory columns as `Steps (*)` / `TC ID (*)`. Removing only the `*` left
+// `steps ()` — classification regexes still matched (/steps?|expected/), but the
+// exact-key column lookups missed and every mandatory cell came back '' silently.
+const norm = (s: string | undefined) => (s || '').replace(/\(\s*\*\s*\)/g, '').replace(/\*/g, '').trim().toLowerCase();
 
 function detectSheetType(rows: string[][]): { type: SheetType; headerRow: number } {
   for (let i = 0; i < Math.min(rows.length, 40); i++) {
@@ -109,6 +116,22 @@ function parseTestcaseSheet(rows: string[][], headerRow: number, sheet: string):
   return out;
 }
 
+/**
+ * exceljs's `.text` getter can THROW on a merged cell whose master value is null
+ * (MergeValue.toString() on null) — a `cell.text != null` guard never runs because
+ * READING the property explodes. Field workbook: 25 such cells across 3 tabs
+ * (Google-Sheets-exported merged headers). Guard on `.value` first (safe — merge
+ * slaves delegate to the master's value without stringifying), and keep a
+ * try/catch backstop for values that are non-null yet still un-stringifiable
+ * (e.g. a formula cell whose result is null). Never hand-stringify `.value` —
+ * richText/hyperlink objects would become "[object Object]"; exceljs's own
+ * `.text` stays the single formatter.
+ */
+function safeCellText(cell: any): string {
+  if (cell.value == null) return '';
+  try { return String(cell.text ?? ''); } catch { return ''; }
+}
+
 export interface RawSheet { name: string; rows: string[][] }
 
 /** Load sheets from one input file: CSV (1 sheet), XLSX (all sheets), or a JSON
@@ -137,7 +160,7 @@ async function loadSheets(filePath: string): Promise<RawSheet[]> {
       const rows: string[][] = [];
       ws.eachRow((row: any) => {
         const cells: string[] = [];
-        row.eachCell({ includeEmpty: true }, (cell: any) => { cells.push(cell.text != null ? String(cell.text) : ''); });
+        row.eachCell({ includeEmpty: true }, (cell: any) => { cells.push(safeCellText(cell)); });
         rows.push(cells);
       });
       out.push({ name: ws.name, rows });
@@ -168,7 +191,7 @@ export async function parseLegacyFile(filePaths: string | string[], onlySheets?:
 
   const inv: LegacyInventory = {
     source: { file: files.map((f) => path.basename(f)).join(', ') },
-    sheets: [], testcases: [],
+    sheets: [], testcases: [], warnings: [],
   };
   for (const f of files) {
     for (const s of await loadSheets(f)) {
@@ -176,6 +199,28 @@ export async function parseLegacyFile(filePaths: string | string[], onlySheets?:
       const { type, headerRow } = detectSheetType(s.rows);
       let tcs: LegacyTestcase[] = [];
       if (type === 'testcase' && headerRow >= 0) tcs = parseTestcaseSheet(s.rows, headerRow, s.name);
+      // Anti-silence guards — a convention mismatch must SAY so, never quietly drop data:
+      //  (a) near-miss: a tab that carries a TC-ID-ish header yet classified unknown;
+      //  (b) a testcase tab whose extraction produced ZERO rows;
+      //  (c) rows extracted but a mandatory column resolved empty on EVERY row.
+      if (type === 'unknown') {
+        const loose = (v: string) => v.replace(/[^a-z0-9]/gi, '').toLowerCase();
+        const nearMissRow = s.rows.slice(0, 40).find((r) => r.some((c) => /tcid/.test(loose(c))));
+        if (nearMissRow) {
+          inv.warnings!.push(`sheet "${s.name}": looks like a testcase sheet (TC-ID-like header found) but was NOT classified — header candidates: [${nearMissRow.filter(Boolean).slice(0, 10).join(' | ')}]`);
+        }
+      } else if (type === 'testcase' && headerRow >= 0) {
+        const header = s.rows[headerRow].filter(Boolean).slice(0, 12).join(' | ');
+        if (tcs.length === 0) {
+          inv.warnings!.push(`sheet "${s.name}": classified testcase but 0 rows extracted — column names may not follow the expected convention. Header row: [${header}]`);
+        } else {
+          for (const [field, label] of [['steps', 'Steps'], ['expected', 'Expected results']] as const) {
+            if (tcs.every((t) => !(t as any)[field])) {
+              inv.warnings!.push(`sheet "${s.name}": the "${label}" column resolved EMPTY for all ${tcs.length} extracted row(s) — check its header spelling. Header row: [${header}]`);
+            }
+          }
+        }
+      }
       inv.sheets.push({ name: s.name, type, rows: tcs.length || s.rows.length });
       inv.testcases.push(...tcs);
     }

package/src/orchestrator/templates/ai-src/commands/delivery.md

@@ -1,228 +1,146 @@
 ---
 name: delivery
-description: "Export the Test Case & Coverage Matrix (review/manual/customer deliverable) from Gherkin + Playwright results. --legacy exports the classic per-scenario CSV/XLSX."
-argument-hint: "[name...] [--format csv] [--env <locale>] [--legacy] (omit names for all)"
+description: "Export Gherkin scenarios + Playwright results to CSV test case file for QA delivery."
+argument-hint: "[screen-name...] [--env <locale>] (omit screens for all; --env for locale-specific export)"
 order: 50
-claude-tools: "Bash, Read, Write, AskUserQuestion"
+claude-tools: "Bash, Read, AskUserQuestion"
 copilot-tools: "[read, execute, edit, vscode/askQuestions]"
-codex-trigger: "Run when the user asks to EXPORT or deliver test cases for QA hand-off. Final step. Do NOT use for creating or running tests."
+codex-trigger: "Run when the user asks to EXPORT or deliver test cases to CSV/XLSX for QA hand-off. Final step. Do NOT use for creating or running tests."
 ---
 ## Role
 
-You are a **QA Test Delivery Engineer**. The deterministic `sungen delivery` CLI does all parsing,
-gating, and rendering. Your job is (1) invoking it, (2) **proposing the Delivery Map** when a unit
-does not have one yet — the one semantic step the CLI cannot do — and (3) walking the user through
-review → approve → official render.
-
-## The two delivery modes
-
-- **Matrix (default)** — the Test Case & Coverage Matrix: one row per *delivery item* (one target +
-  one test intent + one oracle family), with each Gherkin scenario / `@cases` row preserved as a
-  collapsible *coverage variant* sub-row. No numbered step dumps. This is the reviewable /
-  manually-executable / customer-facing standard.
-- **Legacy (`--legacy`, alias `--full`)** — the classic per-scenario-steps workbook (BM-2-901-13).
-  Use it when the user asks for the old format or a project is mid-engagement on it.
+You are a **QA Test Delivery Engineer**. Your job is to invoke the deterministic `sungen delivery` CLI that performs all parsing and CSV export. Your role is minimal — just run the CLI and help the user if pre-flight checks fail.
 
 ## Parameters
 
 Parse from `$ARGUMENTS`:
-- **names** — zero or more screen/flow/api names. Empty → **a sweep of every unit**.
-  Strictness follows the scope: a **named** unit that is not ready aborts the run (the user asked
-  for that unit); a **sweep** exports every ready unit and skips the rest with an accounted
-  "Not exported" list, succeeding as long as something was written. So `/sungen:delivery` with no
-  argument is safe in a work-in-progress project — scaffolded units (added but `create-test` not
-  run) no longer block the units that are ready.
-- **`--format <xlsx|csv|both>`** — output format. **Default `xlsx` — one artifact only.** Pass
-  `--format csv` when the user wants the flat CSV (pipelines/diffing), `--format both` for both.
-- **`--env <locale>`** — sets `SUNGEN_ENV=<locale>` for the run (accept `--locale` as alias).
-- **`--legacy` / `--full`** — pass through to the CLI and skip the map flow entirely.
-
-## Steps
-
-### 1. Run the CLI once
-
-```bash
-[ -x ./bin/sungen.js ] && ./bin/sungen.js delivery <names> || npx sungen delivery <names>
-```
-(prepend `SUNGEN_ENV=<locale>` when `--env` was given; append `--format <fmt>` when the user asked
-for a non-default format; append `--legacy` when requested — then skip to step 5.)
-
-Three outcomes per target:
-- **Rendered** → done, go to step 5.
-- **"no delivery map"** → go to step 2 (propose it).
-- **Gate findings / "not approved"** → go to step 4 (review & approve).
-
-On a sweep, read the **"Not exported"** list at the end: units marked *not authored yet* need
-`/sungen:create-test` first, the others each printed their own reason above (missing map, gate
-errors, or awaiting approval). Handle them one unit at a time — do not re-run the sweep expecting
-a different result.
-
-### 2. Propose the Delivery Map (only when missing or the user asks to regroup)
-
-Read the unit's `.feature` (and `requirements/spec.md` for target naming). Write
-`qa/<screens|flows|api>/<unit>/delivery/<unit>.map.yaml`:
-
-```yaml
-version: 1
-unit: <unit>
-groups:
-  - id: DI-<TARGET>-<THEME>        # stable kebab id, never renumbered
-    target: login.email            # ONE target: field/component dot-path, flow phrase, or METHOD /path
-    intent: <one behavior/rule this item verifies>
-    oracle: <the shared observable Pass/Fail statement>
-    dimensions: violated rule — required ×3 · format ×10 · full-width ×2   # see below
-    category: normal | abnormal | security | nfr   # see the rule below
-    review: proposed               # ALWAYS proposed — only QA approval flips it
-    variants: [VP-VAL-001-B, VP-VAL-001-S]   # VP-ids; bare id on a @cases scenario = all its rows
-dispositions:                      # scenarios intentionally NOT delivered as test cases
-  VP-DATA-000: { as: excluded, reason: data-setup checklist }
-  # as: excluded | blocked | covered_elsewhere | accepted_risk
-```
-
-**Grouping rules (the aggregation signature) — group COMPACTLY.** The matrix exists to be
-substantially shorter than the scenario list, so a reviewer can see missing viewpoints at a
-glance. Merge whenever the cases share ALL of: target · test intent/business rule ·
-precondition/condition · trigger or procedure shape · **the way the expected result is
-determined** (its oracle *family*, not its exact message).
-
-- **Oracle family = the determination method, parameterized.** All validation branches of ONE
-  field belong to ONE item — required, format, length, character-class are *expected branches*
-  (parameters) of "the field shows the validation message defined for the violated rule", shown
-  per variant, never separate items.
-- MAY vary inside one item (coverage dimensions, visible on the sub-rows): data values, boundary
-  points, **account states** (a seeded/locked/deleted account next to a wrong-password case),
-  provider/browser/locale, `@cases` rows, a different trigger with the same oracle (blur vs
-  submit), **execution mode** (auto + manual mix — the parent shows `Auto n · Manual m`), and
-  **priority** (the item takes the highest; per-variant priorities stay visible).
-- MUST split: different target, different intent/business rule, different way of determining the
-  expected result (a field-error family ≠ a session-established family), different test layer
-  (`@api`/`@query`), materially different precondition, or a different procedure shape —
-  sequence-sensitive flows (re-Given/When after a Then) stay solo. **Different risk classes never
-  merge**: XSS and SQL injection are separate items (different risk and determination), even on
-  the same field.
-- **Look for these families before settling on a grouping** — they are where under-merging happens:
-  | Family | Merge into one item |
-  |---|---|
-  | Static render | every "element X is visible/has its content on load" scenario of the screen — title, instructions, progress step, buttons present, header/footer |
-  | Field validation branches | all rules of ONE field (required · format · length · character class · full-width) |
-  | Account/entity states | wrong-credentials · locked · deleted · unverified for the same rejection oracle |
-  | Provider / surface sets | the 3 OAuth providers, header+footer, the a11y surfaces of one behaviour |
-  | Lifetime / mode pairs | checked vs unchecked, mobile vs desktop, when the oracle is one rule with two branches |
-  On a 36-scenario screen, four separate one-variant "renders on load" items should have been one.
-- When unsure, keep items separate — the gates and QA decide, never guess-merge.
-- Every scenario must land in exactly one group **or** one disposition (Gate B enforces 100%
-  disposition). Data-setup blocks (`@manual:data-setup`) → `excluded`; SPEC-GAP placeholders →
-  `blocked`.
-
-**`dimensions:` — the compact coverage digest (required for items with >3 variants).**
-This one short line is what the collapsed parent row shows instead of listing every variant, so a
-reviewer sees *which dimensions* the item covers without expanding it. Name the dimension, then the
-branches with counts:
-- `violated rule — required ×3 · format ×10 · full-width ×2`
-- `account state — wrong password · unregistered · locked · soft-deleted`
-- `submission method — Login button · Enter in Password · Enter in Email`
-
-Keep it ≤120 chars (Gate W warns). **YAML caveat:** a bare `: ` inside the value breaks the parse —
-use ` — ` as the label separator (as above) or quote the whole string.
-
-**`category` is not free choice for two classes (Gate K checks it):** a group whose variants are
-`VP-SEC-*` MUST be `category: security`, and `VP-NFR-*` MUST be `nfr` — otherwise the Coverage
-sheet's security/nfr column renders empty and the grid reports a gap the unit does not have while
-hiding the work it does have. `normal` vs `abnormal` stays your judgement.
-
-**Wording rules for `intent`/`oracle` (customer-facing — Gate W lints these):**
-- Plain product language, present simple, ~10–20 words, one behavior:
-  "A user can sign in with valid credentials and is redirected to the Jobs page."
-- Oracle = the observable outcome as a definite assertion ("The Jobs page is displayed and the
-  Logout link is visible.") — no `should`, no tester actions.
-- NEVER: `{{tokens}}`, `[Selector]` references, DSL phrasing (`User fill/click/see`), generator
-  labels (`Setup:`/`Observable:`/`Oracle:`), or vague verbs (`handles`, `surfaces`) when a precise
-  behavior exists. Use the visible UI label (the Login button, the Email field).
-- **Preserve the source meaning exactly** — never strengthen, weaken, or reinterpret an oracle
-  (a security assertion especially: if the source says "the password appears ONLY in the HTTPS
-  POST body", do not write "no plaintext password on the network").
-
-**Requirement coverage (`requirements:` section, optional):** `sungen delivery` scans
-`requirements/spec.md` for FR-/TR-/NFR- ids; ids traced by `@spec:` tags are `covered`, the rest
-are `gap` (Gate R warning). Record the reviewed status for genuine non-gaps:
-
-```yaml
-requirements:
-  TR-007: { status: planned, note: Performance needs Lighthouse-style tooling }
-  TR-004: { status: partially_covered, note: client-side covered by VP-SEC-003; hashing needs DB verify }
-  # status: covered | partially_covered | covered_elsewhere | planned | gap | not_applicable
-```
+{{#cap parallel-subagents}}
+- **screens** — zero or more screen/flow names. Empty → CLI processes all targets in `qa/screens/` + `qa/flows/`.
+{{/cap}}
+{{^cap parallel-subagents}}
+- **names** — zero or more screen/flow names. Empty → CLI processes all targets in `qa/screens/` + `qa/flows/`.
+{{/cap}}
+- **`--env <locale>`** — optional. Sets `SUNGEN_ENV=<locale>` for the run so the CLI merges `<name>.<locale>.yaml` over the base test-data and writes `<name>-testcases.<locale>.csv` / `.xlsx`. Accept `--locale <locale>` as an alias.
 
-**Never write `status: covered` for a requirement no variant traces to** (Gate R flags it). A note
-saying "proven by DI-SEC-CSRF" is prose — nothing detects it when that scenario later changes. If a
-scenario in THIS feature proves the requirement, **add `@spec:<id>` to that scenario** so the trace
-is real, then drop the override (it derives as `covered` on its own). Use `covered_elsewhere` only
-when another suite proves it, and name that suite; `not_applicable` when the spec itself excludes
-the requirement.
+If `--env` is passed but no value follows, ask the user which locale to use.
 
-Then validate and fix any ERROR findings:
-
-```bash
-[ -x ./bin/sungen.js ] && ./bin/sungen.js delivery <unit> --check || npx sungen delivery <unit> --check
-```
-
-### 3. Present the grouping for review
-
-Show the user a compact summary: item count vs variant count, the groups (id · target · intent ·
-variant count), dispositions, and every remaining `review`-level finding (oracle-shape /
-precondition heuristics — these are exactly what QA must confirm). Then `AskUserQuestion`:
+## Steps
 
-- **Approve all groups** (Recommended when the findings look right)
-- **Adjust the grouping** — user names the groups to change; edit the map, re-run `--check`, re-present.
-- **Preview draft first** — `sungen delivery <unit> --preview` (DRAFT watermark), then re-ask.
-- **Cancel**
+### 1. Invoke the CLI
 
-### 4. Approve + official render
+{{#cap parallel-subagents}}
+Run via Bash (single command, no extra parsing). Prefer the local `./bin/sungen.js` when it exists — the sungen monorepo ships local-only features the global npm package doesn't have yet (multi-sheet locale aggregation, `.<env>` filename suffix, locale-aware step rendering). Fall back to `npx sungen` in downstream projects.
+{{/cap}}
+{{^cap parallel-subagents}}
+Run via Bash (single command, no extra parsing):
+{{/cap}}
 
 ```bash
-[ -x ./bin/sungen.js ] && ./bin/sungen.js delivery <unit> --approve || npx sungen delivery <unit> --approve
-[ -x ./bin/sungen.js ] && ./bin/sungen.js delivery <unit> || npx sungen delivery <unit>
+# No env — local-first dispatcher:
+{{#cap parallel-subagents}}
+[ -x ./bin/sungen.js ] && ./bin/sungen.js delivery <screens> || npx sungen delivery <screens>
+{{/cap}}
+{{^cap parallel-subagents}}
+[ -x ./bin/sungen.js ] && ./bin/sungen.js delivery <names> || npx sungen delivery <names>
+{{/cap}}
+
+# Locale-specific:
+{{#cap parallel-subagents}}
+[ -x ./bin/sungen.js ] && SUNGEN_ENV=<locale> ./bin/sungen.js delivery <screens> || SUNGEN_ENV=<locale> npx sungen delivery <screens>
+{{/cap}}
+{{^cap parallel-subagents}}
+[ -x ./bin/sungen.js ] && SUNGEN_ENV=<locale> ./bin/sungen.js delivery <names> || SUNGEN_ENV=<locale> npx sungen delivery <names>
+{{/cap}}
 ```
 
-`--approve` stamps scenario fingerprints into the map — if the `.feature` changes later, Gate E
-flips the affected groups back to review (drift). Approved + unchanged groups render without
-re-asking.
-
-### 5. Show summary + offer next steps
-
-Forward the CLI summary verbatim (Items = review rows; **Variants = execution units — progress is
-counted in variants, never items**). Then `AskUserQuestion`:
-
-- **Open the workbook** — inspect `qa/deliverables/<unit>-testcases.xlsx` (Testcases sheet:
-  collapse outline level 1 for the customer view; Coverage sheet: target × category grid + gaps).
-- **Run tests to refresh results** — `/sungen:run-test <unit>`, then re-run delivery.
-- **Also export CSV** — `sungen delivery <unit> --format csv` (flat `item`/`variant` rows for pipelines).
-- **Export the legacy workbook too** — `sungen delivery <unit> --legacy`.
-- **Done**
+{{#cap parallel-subagents}}
+- If no screen args → omit `<screens>` (CLI processes all targets).
+{{/cap}}
+{{^cap parallel-subagents}}
+- If no name args → omit `<names>` (CLI processes all targets).
+{{/cap}}
+- If `--env <locale>` was provided → prepend `SUNGEN_ENV=<locale>` to the command. Do NOT pass `--env` to the CLI itself — it's not a CLI flag, only a slash-command convenience.
+
+The CLI handles:
+{{#cap parallel-subagents}}
+- Scope detection (all screens + flows vs specific)
+{{/cap}}
+{{^cap parallel-subagents}}
+- Scope detection (all screens + flows vs specific names)
+- Auto-detect: `qa/flows/<name>/` → flow, `qa/screens/<name>/` → screen
+{{/cap}}
+- Pre-flight source checks with colorful output
+- Parsing `.feature`, `.spec.ts`, `test-data.yaml` (+ `<name>.<env>.yaml` overlay when `SUNGEN_ENV` is set), and per-target `<name>-test-result[.<env>].json`
+- Generating CSV/XLSX at `qa/deliverables/<name>-testcases[.<env>].csv` / `.xlsx`
+- Printing summary table
+
+### 2. Handle pre-flight failures (if CLI exits non-zero)
+
+{{#cap parallel-subagents}}
+If the CLI exits with blocking issues, it will have already printed a clear table showing exactly what's missing per screen.
+{{/cap}}
+{{^cap parallel-subagents}}
+If the CLI exits with blocking issues, it will have already printed a clear table showing exactly what's missing per target.
+{{/cap}}
+
+Use `AskUserQuestion` to offer next steps:
+
+**Options:**
+- **Fix missing sources** (Recommended) — Print the suggested commands from CLI output and stop. User will run those commands manually, then re-invoke `/sungen:delivery`.
+{{#cap parallel-subagents}}
+- **Continue with available screens** — Re-run as `npx sungen delivery <screens> --continue-on-missing` to skip screens with blocking issues.
+{{/cap}}
+{{^cap parallel-subagents}}
+- **Continue with available targets** — Re-run as `npx sungen delivery <names> --continue-on-missing` to skip targets with blocking issues.
+{{/cap}}
+- **Cancel** — Exit.
+
+### 3. Show summary + offer next steps (on success)
+
+Forward the CLI's summary table to the user verbatim. Then use `AskUserQuestion`:
+
+- **Open a specific CSV** — Help user inspect one of the exported files with Read tool.
+{{#cap parallel-subagents}}
+- **Run tests to refresh results** — Suggest `/sungen:run-test <screen>` to update `test-results/results.json`, then re-run delivery.
+- **Export another screen** — User can run `/sungen:delivery <other-screen>`.
+{{/cap}}
+{{^cap parallel-subagents}}
+- **Run tests to refresh results** — Suggest `/sungen-run-test <name>` to update test results, then re-run delivery.
+- **Export another target** — User can run `/sungen-delivery <other-name>`.
+{{/cap}}
+- **Done** — Exit.
 
 ## Important notes
 
-- **Do NOT parse/duplicate what the CLI computes** — gates recompute mode/layer/priority/oracle
-  shapes from the `.feature`; the map only carries the semantic fields (target/intent/oracle/
-  category/grouping).
-- **Never write `review: approved` yourself** — only `--approve` after the user agreed. Proposing
-  with `review: approved` defeats the QA review this format exists for.
-- **Do NOT modify feature/test-data files during delivery** — read-only except the map file.
-- The map is committed and stable: adding a group never renumbers others; deleting scenarios →
-  update the map (Gate B lists exactly what's unmapped/stale).
+- **Do NOT parse files yourself** — the CLI is the source of truth for parsing logic. Your job is orchestration + user interaction.
+- **Do NOT modify feature/spec.ts/test-data files** — the delivery is read-only.
+- **The CLI already respects `@manual` tags, skips `@steps:` base scenarios, groups by Category 2, and generates UTF-8 BOM CSV for Excel compatibility with Vietnamese.**
+- **Pre-flight check is built into the CLI** — use `--skip-preflight` only in CI/automated pipelines where checks are done externally.
 
-## CLI reference
+## CLI Reference
 
 ```
-sungen delivery [names...]        # matrix (default; needs the map) → XLSX only
-  --format <xlsx|csv|both>        # output format; default xlsx (one artifact)
-  --check                         # gates only — validate the map, write nothing
-  --approve [DI-a,DI-b]           # flip proposed→approved (+ stamp fingerprints); all groups when bare
-  --preview                       # render despite review findings (DRAFT watermark)
-  --legacy | --full               # classic per-scenario workbook (no map needed)
-  --skip-preflight | --continue-on-missing | --env <env>   # as before
+{{#cap parallel-subagents}}
+sungen delivery [screens...]
+{{/cap}}
+{{^cap parallel-subagents}}
+sungen delivery [names...]
+{{/cap}}
+  [--skip-preflight]          Skip pre-flight checks (not recommended)
+{{#cap parallel-subagents}}
+  [--continue-on-missing]     Skip screens with blocking misses
+{{/cap}}
+{{^cap parallel-subagents}}
+  [--continue-on-missing]     Skip targets with blocking misses
+{{/cap}}
+
+# Locale-aware export (env var, not a CLI flag):
+{{#cap parallel-subagents}}
+SUNGEN_ENV=<locale> sungen delivery [screens...]
+{{/cap}}
+{{^cap parallel-subagents}}
+SUNGEN_ENV=<locale> sungen delivery [names...]
+{{/cap}}
+  → reads <name>.<locale>.yaml overlay, picks <name>-test-result.<locale>.json,
+    writes <name>-testcases.<locale>.csv / .xlsx
 ```
-
-Outputs: `qa/deliverables/<unit>-testcases.xlsx` (Testcases + Coverage sheets) by default;
-`--format csv` writes `<unit>-testcases.csv` instead (flat, `Level` column `item|variant`),
-`--format both` writes both. Legacy mode writes the classic files instead.

package/src/orchestrator/templates/ai-src/config/claude.md

@@ -30,7 +30,7 @@ You generate 3 files for sungen — a Gherkin compiler that produces Playwright
 | `/sungen:create-data-test <name>` | Generate standardized test-data (valid/boundary/invalid + CHK trace) from the Data Factory catalog; no name = all units (asks to confirm) |
 | `/sungen:review <name>` | Score syntax, coverage, viewpoint quality (auto-detects screen or flow) |
 | `/sungen:run-test <name>` | Generate `selectors.yaml`, compile, run, auto-fix (auto-detects screen or flow) |
-| `/sungen:delivery [name...]` | Export the Test Case & Coverage Matrix (review/manual/customer deliverable; `--legacy` = classic CSV; all screens if no arg) |
+| `/sungen:delivery [name...]` | Export test cases → CSV for QA delivery (all screens if no arg) |
 | `/sungen:locale <name> <locale>` | Bootstrap i18n for a screen — audit selectors, detect locale switch, generate overlay (run before `/sungen:run-test --env <locale>`) |
 
 **Screen path:** add-screen → create-test → review → run-test → delivery.

package/src/orchestrator/templates/ai-src/config/copilot.md

@@ -30,7 +30,7 @@ You generate 3 files for sungen — a Gherkin compiler that produces Playwright
 | `/sungen-create-data-test <name>` | Generate standardized test-data (valid/boundary/invalid + CHK trace) from the Data Factory catalog; no name = all units (asks to confirm) |
 | `/sungen-review <name>` | Score syntax, coverage, viewpoint quality (auto-detects screen or flow) |
 | `/sungen-run-test <name>` | Generate `selectors.yaml`, compile, run, auto-fix (auto-detects screen or flow) |
-| `/sungen-delivery [name...]` | Export the Test Case & Coverage Matrix (review/manual/customer deliverable; `--legacy` = classic CSV; all screens if no arg) |
+| `/sungen-delivery [name...]` | Export test cases → CSV for QA delivery (all screens if no arg) |
 | `/sungen-locale <name> <locale>` | Bootstrap i18n for a screen — audit selectors, detect locale switch, generate overlay (run before `/sungen-run-test --env <locale>`) |
 
 **Screen path:** add-screen → create-test → review → run-test → delivery.