@sun-asterisk/sungen 2.4.5 → 2.5.0

package/dist/orchestrator/templates/ai-instructions/claude-cmd-delivery.md

@@ -0,0 +1,71 @@
+---
+name: delivery
+description: 'Export Gherkin scenarios + Playwright results to CSV test case file for QA delivery.'
+argument-hint: "[screen-name...] (omit for all screens)"
+allowed-tools: Bash, Read, AskUserQuestion
+---
+
+## Role
+
+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 **screens** from `$ARGUMENTS`:
+- If empty → CLI will process **all** screens in `qa/screens/`
+- If provided → pass them through to the CLI
+
+## Steps
+
+### 1. Invoke the CLI
+
+Run via Bash (single command, no extra parsing):
+
+```bash
+npx sungen delivery <screens>
+```
+
+- If no screen args → just run `npx sungen delivery`
+- If screen args → pass them as positional arguments
+
+The CLI handles:
+- Scope detection (all screens vs specific)
+- Pre-flight source checks with colorful output
+- Parsing `.feature`, `.spec.ts`, `test-data.yaml`, `test-results/results.json`
+- Generating CSV at `qa/deliverables/<screen>-testcases.csv`
+- Printing summary table
+
+### 2. Handle pre-flight failures (if CLI exits non-zero)
+
+If the CLI exits with blocking issues, it will have already printed a clear table showing exactly what's missing per screen.
+
+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`.
+- **Continue with available screens** — Re-run as `npx sungen delivery <screens> --continue-on-missing` to skip screens with blocking issues.
+- **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.
+- **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>`.
+- **Done** — Exit.
+
+## Important notes
+
+- **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
+
+```
+sungen delivery [screens...]
+  [--skip-preflight]          Skip pre-flight checks (not recommended)
+  [--continue-on-missing]     Skip screens with blocking misses
+```

package/dist/orchestrator/templates/ai-instructions/claude-cmd-run-test.md

@@ -18,7 +18,7 @@ Parse **screen** from `$ARGUMENTS`. If missing, ask the user.
 1. Verify `qa/screens/<screen>/` has `.feature` + `test-data.yaml`.
 2. **Phase 0 — Selector Pre-gen**: if `selectors.yaml` is missing/empty or doesn't cover the feature file's `[Reference]`s, run Phase 0 from `sungen-selector-fix` — confirm with user, `browser_navigate` → one `browser_snapshot` → merge YAML entries.
 3. **Phase 0.5 — Auth Persistence**: if the feature has `@auth:<role>` tags and `specs/.auth/<role>.json` is missing/expired, run Phase 0.5 from `sungen-selector-fix` — user logs in manually in MCP browser → `browser_storage_state` → `specs/.auth/<role>.json`. Offer `sungen makeauth <role>` as CLI fallback only if `browser_storage_state` isn't available in this MCP version.
-4. Compile: `sungen generate --screen <screen>`.
+4. Compile: `sungen generate --screen <screen>` (default: runtime data loading from YAML). Use `--inline-data` only if user requests compile-time hardcoded values.
 
 ## Run & Fix (phased — per `sungen-selector-fix` skill)
 
@@ -27,6 +27,33 @@ Parse **screen** from `$ARGUMENTS`. If missing, ask the user.
 7. **Phase 3 — Full Run**: Run all tests. Fix only **new** failures (elements unique to `@normal`/`@low`). Max 1 attempt. Don't loop on low-priority failures.
 8. **Phase 4 — Regression**: One final full run. Report results. No more fix loops.
 
+## Playwright command guidelines
+
+**Per-screen JSON results** — each run must write its JSON report to a dedicated path co-located with the `.spec.ts`, so `sungen delivery` can read the correct results per screen:
+
+```bash
+# ✅ Correct — per-screen output file via env var
+PLAYWRIGHT_JSON_OUTPUT_NAME=specs/generated/<screen>/<screen>-test-result.json \
+  npx playwright test specs/generated/<screen>/<screen>.spec.ts
+```
+
+Output: `specs/generated/<screen>/<screen>-test-result.json`
+
+**DO NOT** pass `--reporter=...` flag — it overrides the reporters from `playwright.config.ts` and disables the JSON reporter that `sungen delivery` depends on.
+
+```bash
+# ❌ Wrong — --reporter flag disables the config's JSON reporter
+npx playwright test specs/generated/<screen>/<screen>.spec.ts --reporter=list
+
+# ❌ Wrong — no env var → writes to default test-results/results.json
+# (overwritten on every screen run, loses per-screen tracking)
+npx playwright test specs/generated/<screen>/<screen>.spec.ts
+```
+
+If you want to filter scenarios, use `-g "<pattern>"` instead of a reporter override.
+
+`sungen delivery` reads the per-screen file first, falls back to the global `test-results/results.json` if missing.
+
 ## Next steps
 
 After showing results, use `AskUserQuestion` to offer next steps:

package/dist/orchestrator/templates/ai-instructions/claude-config.md

@@ -15,8 +15,12 @@ You generate 3 files for sungen — a Gherkin compiler that produces Playwright
 | `sungen-viewpoint` | 10 UI patterns x 4 viewpoints — coverage checklists |
 | `sungen-selector-keys` | YAML key generation from `[Reference]` names, suffixes, lookup priority |
 | `sungen-selector-fix` | Selector generation from live page, auto-fix strategy |
+| `sungen-delivery` | Export Gherkin + Playwright results → CSV test case deliverable |
+| `sungen-capture-figma` | Fetch design context + PNG from a Figma frame URL via Figma Dev Mode MCP |
+| `sungen-capture-local` | Load existing UI assets (screenshots, mockups, Figma exports) from `requirements/ui/` |
+| `sungen-capture-live` | Capture a live running page via Playwright MCP (snapshot + screenshot) |
 
-## Workflow (4 AI commands)
+## Workflow (5 AI commands)
 
 | Command | What it does |
 |---|---|
@@ -24,8 +28,9 @@ You generate 3 files for sungen — a Gherkin compiler that produces Playwright
 | `/sungen:create-test <name>` | Generate `.feature` + `test-data.yaml` (no selectors) |
 | `/sungen:review <name>` | Score syntax, coverage, viewpoint quality (60% threshold) |
 | `/sungen:run-test <name>` | Generate `selectors.yaml` from live page, compile, run, auto-fix |
+| `/sungen:delivery [name...]` | Export test cases → CSV for QA delivery (all screens if no arg) |
 
-**Order:** add-screen → create-test → review → run-test.
+**Order:** add-screen → create-test → review → run-test → delivery.
 
 After each command completes, use `AskUserQuestion` to present the next actions as selectable options. Never just print text — always give clickable choices so the user can continue the workflow seamlessly.
 
@@ -35,17 +40,31 @@ After each command completes, use `AskUserQuestion` to present the next actions
 qa/screens/<screen-name>/
 ├── features/<screen>.feature      # Gherkin scenarios
 ├── selectors/<screen>.yaml        # Element locators (generated during run-test)
-├── test-data/<screen>.yaml        # Test data variables
+├── test-data/<screen>.yaml        # Test data variables (loaded at runtime)
+├── test-data/<screen>.staging.yaml    # Environment override (optional)
+├── test-data/<screen>.production.yaml # Environment override (optional)
 └── requirements/
     ├── spec.md                    # Screen specification (primary source)
     └── ui/                        # Screenshots, mockups
+
+qa/deliverables/<screen>-testcases.csv  # Exported test cases (from /sungen:delivery)
+qa/deliverables/<screen>-testcases.xlsx # Styled workbook for client hand-off
 ```
 
+## Test Data
+
+`{{variable}}` references in `.feature` map to keys in `test-data/<screen>.yaml`. Data is loaded **at runtime** — the same generated `.spec.ts` works across environments without recompiling.
+
+**Environment overrides**: `SUNGEN_ENV=staging npx playwright test` merges `<screen>.staging.yaml` on top of `<screen>.yaml`. Create `<screen>.<env>.yaml` for environment-specific values (different credentials, URLs, test users).
+
 ## CLI Commands
 
 ```bash
 sungen add --screen <name> --path <url-path>               # Scaffold screen directories
 sungen add --screen <name> --path <path> --feature <name>   # Scaffold with sub-feature
-sungen generate --screen <name>                              # Compile .feature → .spec.ts
+sungen generate --screen <name>                              # Compile .feature → .spec.ts (runtime data)
+sungen generate --screen <name> --inline-data                # Compile with hardcoded data (legacy)
 sungen generate --all                                        # Compile all screens
+sungen delivery                                              # Export all screens → CSV + XLSX
+sungen delivery <screen>                                     # Export a single screen
 ```

package/dist/orchestrator/templates/ai-instructions/claude-skill-capture-figma.md

@@ -0,0 +1,142 @@
+---
+name: sungen-capture-figma
+description: 'Fetch design context + PNG from a Figma frame URL via Figma Dev Mode MCP. Auto-loaded by create-test when user picks Figma as the visual source.'
+user-invocable: false
+---
+
+## Purpose
+
+Pull **structured design data** (layout, typography, colors, component tree, design tokens) and a **PNG screenshot** from a Figma frame URL, so `sungen-tc-generation` can author Gherkin + test-data before a live domain exists.
+
+Use this when the project is pre-launch, or when Figma is the source of truth and the live build lags the design.
+
+---
+
+## Prerequisites
+
+- **Figma MCP server** (`https://mcp.figma.com/mcp`, HTTP transport) connected in the user's `.mcp.json` — `sungen init` scaffolds this automatically. On first use, Claude Code opens a browser for Figma OAuth. Official tools: `get_design_context`, `get_variable_defs`, `get_screenshot`.
+- Figma account signed in with access to the file. **Dev/Full seats** get per-minute rate limits; **Starter/View seats** get monthly tool-call limits.
+- A Figma URL with both **fileKey** and **nodeId** in it.
+
+If the MCP is not connected, **do not fail silently** — tell the user:
+> "Figma MCP not detected. Run `sungen init` to scaffold the config, or manually add `figma` with `url: https://mcp.figma.com/mcp` to `.mcp.json`. Then sign in when Claude Code prompts."
+
+Then stop.
+
+---
+
+## Steps
+
+### 1. Resolve Figma URL
+
+Prefer in this order:
+
+1. `Figma URL` field in `qa/screens/<screen>/requirements/spec.md` (Overview section)
+2. If empty or missing → `AskUserQuestion`: *"Paste the Figma frame URL"* (free text)
+
+Accept any of these URL shapes:
+
+```
+https://www.figma.com/file/<fileKey>/<title>?node-id=<nodeId>
+https://www.figma.com/design/<fileKey>/<title>?node-id=<nodeId>
+https://www.figma.com/proto/<fileKey>/<title>?node-id=<nodeId>
+```
+
+Parse:
+- `fileKey` = the segment after `/file/`, `/design/`, or `/proto/`
+- `nodeId` = the `node-id` query param (may use `-` or `:` — pass through as-is; MCP accepts both)
+
+If `node-id` is missing, ask the user to select a frame in Figma and copy the **frame URL** specifically (not the file root URL).
+
+### 2. Fetch design context
+
+Call **both** in parallel:
+
+```
+get_design_context({ fileKey, nodeId })
+get_variable_defs({ fileKey, nodeId })
+```
+
+`get_design_context` returns layout, typography, color values, component structure, spacing.
+`get_variable_defs` returns named design tokens (color/spacing/typography variables).
+
+### 3. Fetch screenshot
+
+```
+get_screenshot({ fileKey, nodeId })
+```
+
+Save the returned PNG to:
+
+```
+qa/screens/<screen>/requirements/ui/figma-<sanitized-nodeId>.png
+```
+
+Sanitize `nodeId` for filesystem: replace `:` and `-` with `_`. Example: `42-15` → `figma-42_15.png`.
+
+### 4. Write metadata dump
+
+Combine the design context + variables into a Markdown summary at:
+
+```
+qa/screens/<screen>/requirements/ui/figma-meta.md
+```
+
+Format:
+
+```markdown
+# Figma Capture — <nodeId>
+
+**Source:** <full Figma URL>
+**Captured:** <ISO date>
+
+## Components
+<hierarchical list of component names + variants from get_design_context>
+
+## Typography
+<font families, sizes, weights, line heights>
+
+## Colors
+<color tokens + raw hex values>
+
+## Spacing & Layout
+<spacing tokens, auto-layout specs>
+
+## Text Content
+<visible text strings from the frame — used by tc-generation to populate test-data>
+```
+
+This file is consumed by `sungen-tc-generation` as a secondary source alongside `spec.md`.
+
+### 5. Report back
+
+Output a short summary to the user:
+
+> Captured Figma frame `<nodeId>`:
+> - Components: N
+> - Text strings: M
+> - Design tokens: K
+> - Screenshot: `qa/screens/<screen>/requirements/ui/figma-<nodeId>.png`
+> - Metadata: `requirements/ui/figma-meta.md`
+
+Then hand back to the calling command.
+
+---
+
+## Error handling
+
+| Error | Action |
+|---|---|
+| MCP tool not available | Print setup instructions, stop, do not fall back silently |
+| `fileKey` missing from URL | Ask user to paste a valid frame URL |
+| `nodeId` missing from URL | Ask user to right-click a frame in Figma → *Copy link to selection* |
+| `get_design_context` 403 | Ask user to check Dev Mode seat on that file |
+| `get_screenshot` returns no image | Continue with metadata only; warn user no PNG was captured |
+
+---
+
+## What this skill does NOT do
+
+- Does not generate Gherkin (that's `sungen-tc-generation`)
+- Does not write `selectors.yaml` (that's `/sungen:run-test`)
+- Does not validate the design against live UI (future skill: `sungen-capture-live` can be run afterwards for cross-check)

package/dist/orchestrator/templates/ai-instructions/claude-skill-capture-live.md

@@ -0,0 +1,100 @@
+---
+name: sungen-capture-live
+description: 'Capture a live running page via Playwright MCP — snapshot + screenshot for visual context. Auto-loaded by create-test when user picks Live page scan.'
+user-invocable: false
+---
+
+## Purpose
+
+Navigate a running application, take **one accessibility snapshot** and **one screenshot**, and save them as visual context for test generation. Use when the app is live (dev, staging, or production with read-only access) and you want the tests grounded in the actual rendered UI.
+
+This skill handles auth gracefully: if the page redirects to login, it asks the user to sign in manually rather than injecting cookies.
+
+---
+
+## Prerequisites
+
+- Playwright MCP connected.
+- Dev/staging server reachable (or a public URL).
+- `playwright.config.ts` exists at the project root (for `baseURL` fallback).
+
+---
+
+## Steps
+
+### 1. Resolve target URL
+
+Resolve in this order:
+
+1. `Live URL` field in `qa/screens/<screen>/requirements/spec.md` (Overview section)
+2. `baseURL` from `playwright.config.ts` + `URL Path` from `spec.md`
+3. If neither works → `AskUserQuestion`: *"Paste the full URL for the page to scan"*
+
+### 2. Navigate
+
+`browser_navigate` to the resolved URL.
+
+### 3. Handle auth redirect
+
+If the page redirects to a login route (URL contains `/login`, `/signin`, `/auth`, or the page title/content indicates a login screen):
+
+1. Tell the user which login URL they landed on.
+2. `AskUserQuestion`:
+   - **I'll log in manually** — wait for user confirmation, then re-navigate to the target URL
+   - **Skip live scan** — tell caller to invoke `sungen-capture-local` instead
+   - **Cancel**
+3. **Never** inject cookies or localStorage via `browser_evaluate` or `browser_run_code`. Auth belongs to the user.
+
+### 4. Snapshot
+
+Take **ONE** `browser_snapshot`. This accessibility tree is the primary AI context — it contains roles, names, text, and structure that the tc-generation skill uses to identify sections and fields.
+
+### 5. Screenshot (optional but recommended)
+
+Take **ONE** `browser_take_screenshot` with `fullPage: true`. Save to:
+
+```
+qa/screens/<screen>/requirements/ui/live-<timestamp>.png
+```
+
+Where `<timestamp>` is `YYYYMMDD-HHMM` in local time (e.g. `live-20260421-1430.png`).
+
+This gives users a visual record they can reference later without re-scanning.
+
+### 6. Detect discrepancies vs spec
+
+If `spec.md` exists, briefly cross-check the snapshot against spec sections:
+
+- Fields listed in spec but not in snapshot → flag as *missing in UI*
+- Elements visible in snapshot but not in spec → flag as *missing in spec*
+
+Report findings but **do not** auto-edit `spec.md` — let the user decide.
+
+### 7. Report back
+
+> Captured live page `<URL>`:
+> - Snapshot: <N> interactive elements detected
+> - Screenshot: `requirements/ui/live-<timestamp>.png`
+> - Discrepancies vs spec: <count, or "none">
+
+Hand back to the calling command.
+
+---
+
+## What this skill does NOT do
+
+- Does not run tests
+- Does not generate `selectors.yaml` (that's `/sungen:run-test`)
+- Does not inject auth state (user logs in manually)
+- Does not crawl — scans **exactly one** page per invocation
+- Does not generate Gherkin — that's `sungen-tc-generation`
+
+---
+
+## Relationship to other capture skills
+
+- `sungen-capture-figma` — design source of truth (pre-launch)
+- `sungen-capture-local` — any image the user dropped in `requirements/ui/`
+- `sungen-capture-live` — this skill, verifies/supplements against the running app
+
+All three write to `requirements/ui/` and report back to the caller. They are mutually exclusive per create-test run, but a user can run create-test multiple times with different sources to layer context.

package/dist/orchestrator/templates/ai-instructions/claude-skill-capture-local.md

@@ -0,0 +1,73 @@
+---
+name: sungen-capture-local
+description: 'Load existing UI assets (screenshots, Figma exports, hand-drawn mockups) from requirements/ui/. Auto-loaded by create-test when user picks UI images as the visual source.'
+user-invocable: false
+---
+
+## Purpose
+
+Use **pre-existing images** in `qa/screens/<screen>/requirements/ui/` as visual context for test generation. No network, no MCP, no live site required — works for any design tool (Figma export, Sketch, Penpot, Zeplin, hand-drawn, screenshots of a staging env).
+
+This is the **baseline fallback**: if live domain is down and Figma MCP isn't configured, this always works as long as the user drops images in the folder.
+
+---
+
+## Steps
+
+### 1. List available images
+
+Glob `qa/screens/<screen>/requirements/ui/*.{png,jpg,jpeg,webp,gif}` and report count + filenames.
+
+Filter out metadata files (e.g. `figma-meta.md` written by `sungen-capture-figma`) — those are read by `tc-generation` separately, not treated as images here.
+
+### 2. Handle empty folder
+
+If no images found:
+
+1. Tell the user the folder is empty, with the full path so they can navigate there in Finder.
+2. `AskUserQuestion`:
+   - **I'll drop images now** — wait for user to confirm, then re-glob
+   - **Switch to Figma URL** — tell caller to invoke `sungen-capture-figma` instead
+   - **Switch to live page scan** — tell caller to invoke `sungen-capture-live` instead
+   - **Cancel** — abort create-test
+3. If user picks "drop images now", wait for their confirmation message (e.g. "done") then re-run step 1.
+
+### 3. Read images for context
+
+Use the `Read` tool on each image file — Claude Code can read PNG/JPG/WebP directly as visual context.
+
+For large sets (>10 images), ask the user which are primary and which are states/variants, to avoid loading too much visual context at once.
+
+### 4. Summarize
+
+Output a short summary:
+
+> Loaded N image(s) from `qa/screens/<screen>/requirements/ui/`:
+> - `<filename-1>` — <one-line description of what's visible>
+> - `<filename-2>` — <one-line description>
+> ...
+
+Hand back to the calling command.
+
+---
+
+## File naming hints for users
+
+When this skill reports back, nudge users toward consistent filenames so future runs are self-documenting:
+
+- `<section>-default.png` — baseline state of a section
+- `<section>-error.png` — error state
+- `<section>-loading.png` — loading state
+- `<section>-empty.png` — empty state
+- `full-page.png` / `viewport.png` — whole screen (auto-generated by `sungen add --capture`)
+
+Don't enforce — just suggest if filenames are ambiguous.
+
+---
+
+## What this skill does NOT do
+
+- Does not download images from external URLs
+- Does not generate images (no AI image generation)
+- Does not modify existing images (no crop/resize)
+- Does not generate Gherkin — that's `sungen-tc-generation`

package/dist/orchestrator/templates/ai-instructions/claude-skill-delivery.md

@@ -0,0 +1,103 @@
+---
+name: sungen-delivery
+description: 'Export Gherkin scenarios + Playwright results → CSV test case deliverable. Auto-loaded by delivery command.'
+user-invocable: false
+---
+
+## Purpose
+
+Export test cases from Sungen screens to a standardized CSV file (format BM-2-901-13) for QA delivery.
+
+**This skill delegates all heavy work to the `sungen delivery` CLI.** The CLI is the single source of truth for parsing logic — do NOT re-parse files in AI. Your role is only to:
+
+1. Invoke the CLI
+2. Show its output verbatim
+3. Help the user react to pre-flight failures
+
+---
+
+## Architecture
+
+```
+User → /sungen:delivery [screen...]
+       │
+       ▼
+  sungen delivery CLI  (deterministic — no AI tokens)
+  ├─ Scope detection (no-arg = all screens)
+  ├─ Pre-flight source checks per screen
+  ├─ Parse .feature (metadata)
+  ├─ Parse .spec.ts (resolved Playwright code — source of truth)
+  ├─ Parse test-data.yaml (resolve {{vars}})
+  ├─ Parse test-results/results.json (match test titles)
+  ├─ Merge sources + generate CSV rows
+  └─ Write qa/deliverables/<screen>-testcases.csv
+```
+
+Source modules: `src/exporters/*.ts`
+
+---
+
+## Required sources (CLI pre-flight checks these)
+
+| # | Source | Path | Created by |
+|---|--------|------|------------|
+| 1 | Feature file | `qa/screens/<screen>/features/<screen>.feature` | `/sungen:add-screen` + `/sungen:create-test` |
+| 2 | Test data | `qa/screens/<screen>/test-data/<screen>.yaml` | `/sungen:create-test` |
+| 3 | Selectors | `qa/screens/<screen>/selectors/<screen>.yaml` | `/sungen:run-test` |
+| 4 | Compiled spec | `specs/generated/<screen>/<screen>.spec.ts` | `sungen generate` (during `/sungen:run-test`) |
+| 5 | Test results | `specs/generated/<screen>/<screen>-test-result.json` (per-screen) or `test-results/results.json` (global fallback) | `/sungen:run-test` |
+
+**Sources 1-4 are blocking** — CLI aborts if any is missing.
+**Source 5 is optional** — CSV is still generated but Test Result/Date/Executor/Env columns are empty (all tests show as Pending).
+
+The CLI reads the **per-screen result file first** (co-located with `.spec.ts`), then falls back to the global `test-results/results.json`. Per-screen is preferred because the global file gets OVERWRITTEN each time Playwright runs, losing results from earlier screens.
+
+---
+
+## Column mapping (handled by CLI)
+
+| CSV Column | Source |
+|------------|--------|
+| TC ID | Generated: `<SCREEN_UPPER>-<VP>-<NNN>` |
+| Category 1 | Scenario name with VP prefix stripped |
+| Category 2 | VP group: `VP-SEC`→Accessing, `VP-UI`→GUI, `VP-VAL`/`VP-LOGIC`→Function |
+| Category 3 | Feature name (first line of `.feature`) |
+| Category 4 | Screen name |
+| Pre-condition | Auth tag → "Logged in as X" / "Not authenticated" + Given steps (natural language) |
+| Test Data | `{{vars}}` from scenario resolved via test-data.yaml → `key: value; key2: value2` |
+| Steps | `.spec.ts` code comments for interactions (numbered) |
+| Expected results | `.spec.ts` `expect(...)` comments (numbered) |
+| Priority | Tag: `@critical`/`@high`/`@normal`/`@low` (default: Normal) |
+| Testcase type | `@manual` → Manual, else Auto. Not compiled → "Not compiled" |
+| Test Result | results.json status: passed→Passed, failed/timedOut→Failed, skipped→N/A, else Pending |
+| Executed Date | results.json startTime formatted as `dd/mm/yyyy` |
+| Test Executor | `git config user.name` |
+| Test Environment | `playwright.config.ts` baseURL + project name |
+| Note | Error message + trace path (for failed tests) |
+
+---
+
+## Excluded from CSV
+
+- `@steps:<name>` **base** scenarios — these are setup-only, inlined into `@extend:...` scenarios at compile time
+- Default scaffold `Sample scenario for <screen>` — not a real test
+
+---
+
+## CLI command reference
+
+```bash
+# Export all screens
+sungen delivery
+
+# Export specific screens
+sungen delivery kudos awards
+
+# Skip pre-flight (CI only)
+sungen delivery --skip-preflight
+
+# Skip screens with blocking misses
+sungen delivery --continue-on-missing
+```
+
+Output: `qa/deliverables/<screen>-testcases.csv` (UTF-8 with BOM)