@sun-asterisk/sungen 2.4.1 → 2.4.3

package/dist/orchestrator/templates/ai-instructions/copilot-cmd-add-screen.md

@@ -32,15 +32,10 @@ Ask the user: "Would you like to fill in `requirements/spec.md` now? This helps
 - If they have UI designs (screenshots, Figma exports, mockups) → suggest copying them to `requirements/ui/`.
 - If no → proceed to step 3.
 
-### 3. Create test cases
+### 3. Next steps
 
-Ask the user: "Would you like to create test cases now?"
+Tell the user what was created and offer next steps:
 
-If yes → **tell the user to run `/sungen-create-test ${input:screen}` as a separate command.** Do NOT attempt to generate test cases yourself in this session — the `create-test` command auto-loads the `sungen-gherkin-syntax` and `sungen-tc-generation` skills which contain the full Gherkin syntax rules, pattern shapes, viewpoint checklists, and output format.
-
-### 4. Confirm
-
-If the user declined test case creation, tell them next steps:
-- Fill `requirements/spec.md` with screen specs (if not done)
-- Run `/sungen-create-test` to create test cases
-- Run `/sungen-run-test` to generate selectors, compile, and run tests
+- **`/sungen-create-test ${input:screen}`** — Create test cases from requirements/designs (Recommended)
+- **Fill `requirements/spec.md`** — Write screen specs first for better test quality
+- **Done for now** — I'll come back later

package/dist/orchestrator/templates/ai-instructions/copilot-cmd-create-test.md

@@ -23,15 +23,22 @@ You are a **Senior QA Engineer**. You structure test cases by viewpoint categori
 3. **Read requirements** — check `qa/screens/${input:screen}/requirements/`:
    - If `spec.md` exists → read it as PRIMARY source (sections, fields, validation rules, business rules, states).
    - If `ui/` has images → read them for visual context (layout, element positions, states).
-   - If `notes.md` exists → read for edge cases and additional context.
+   - If `test-viewpoint.md` exists → read it. If it only contains HTML comments (scaffold template), ask:
+     - **1) Fill test-viewpoint.md first** — identify edge cases, known issues, and design decisions before generating tests
+     - **2) Continue without it** — generate tests from spec and other sources only
    - Summarize what you found in requirements and present to the user.
 4. **Screen input** (supplements requirements, or is primary source if no requirements):
    - Ask: "How should I get the screen design? **1) Figma design** (provide Figma URL — recommended), **2) UI images** (screenshots/mockups in `requirements/ui/`), or **3) Live page scan** (optional, via Playwright MCP)?"
    - Recommend Figma or UI images first. Live page scan is optional — useful to verify specs vs actual UI or capture real data.
-   - If live page, explore via #tool:playwright (see [copilot-instructions.md](../../copilot-instructions.md) for MCP rules). If auth needed, ask user to log in manually.
+   - If live page: `browser_navigate` → ONE `browser_snapshot`. If auth redirect → ask user to log in manually. Never use `browser_run_code` or `browser_evaluate` to inject cookies.
    - If exploring, verify and supplement requirements — flag any discrepancies found.
 5. Identify screen sections → ask user which to focus on (per `sungen-tc-generation` skill). When requirements exist, use the "Requirements-Driven Generation" strategy. Present sections as a numbered list and let user pick.
 6. Generate or update `.feature` + `test-data.yaml` following `sungen-gherkin-syntax` and `sungen-tc-generation` skills.
-7. Show summary → next: `/sungen-review ${input:screen}` or `/sungen-run-test ${input:screen}`
+7. Show summary and offer next steps:
+
+- **`/sungen-review ${input:screen}`** — Review syntax, coverage, viewpoint quality (Recommended)
+- **`/sungen-run-test ${input:screen}`** — Skip review, generate selectors and run tests now
+- **`/sungen-create-test ${input:screen}`** — Add more test cases for another section/viewpoint
+- **Done for now** — I'll come back later
 
 **No selectors.yaml** — selectors are generated during `/sungen-run-test`.

package/dist/orchestrator/templates/ai-instructions/copilot-cmd-review.md

@@ -22,3 +22,8 @@ You are a **Senior QA Reviewer**. You evaluate Gherkin test cases using the `sun
 2. Follow the `sungen-tc-review` skill — score 3 dimensions: Syntax (30pts), Coverage (40pts), Viewpoint (30pts). Use `sungen-viewpoint` for pattern checklists.
 3. Output review report per `sungen-tc-review` format. **>= 60%**: PASS. **< 60%**: FAIL with recommendations.
 4. If FAIL and user confirms → update test cases following `sungen-gherkin-syntax` and `sungen-tc-generation` skills, then re-review.
+5. After PASS (or user decides to proceed), offer next steps:
+
+- **`/sungen-run-test ${input:screen}`** — Generate selectors, compile, and run tests (Recommended)
+- **`/sungen-create-test ${input:screen}`** — Add more test cases before running
+- **Done for now** — I'll come back later

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

@@ -16,20 +16,28 @@ You are a **Senior Developer**. Use `sungen-selector-fix`, `sungen-selector-keys
 
 - **screen** — ${input:screen:screen name (e.g., login, dashboard)}
 
-## Phase 1: Compile & Run (no MCP)
+## Compile
 
 1. Verify `qa/screens/${input:screen}/` has `.feature` + `test-data.yaml`
 2. Ensure `selectors.yaml` has page selector. If missing, ask user for URL path
 3. `sungen generate --screen ${input:screen}`
-4. `npx playwright test specs/generated/${input:screen}/*.spec.ts --reporter=line`
-5. If all pass → done
-
-## Phase 2: Targeted Fix (only if failures)
-
-6. Parse failures → group by root cause
-7. Navigate to page ONCE via #tool:playwright → ONE `browser_snapshot`
-8. Fix broken selectors per `sungen-selector-fix` skill
-9. Recompile → re-run only failing tests
-10. Repeat up to 3 attempts
-11. Final full run for regression check
-12. Still failing → ask user
+
+## Run & Fix (phased — per `sungen-selector-fix` skill)
+
+4. **Phase 1 — Smoke Check**: Run first 5 `@critical`/`@high` scenarios only. If failures → diagnose, fix fundamentals (page selector, auth, base @steps), re-run. Max 2 attempts. If still broken → ask user.
+5. **Phase 2 — Priority Wave**: Run all `@critical` + `@high` scenarios. Fix only failures from this wave. Max 2 attempts. Shared selectors fixed here cascade to later phases.
+6. **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.
+7. **Phase 4 — Regression**: One final full run. Report results. No more fix loops.
+
+## Next steps
+
+After showing results, offer next steps:
+
+If all tests **passed**:
+- **`/sungen-create-test ${input:screen}`** — Add more test cases (Recommended)
+- **Done** — All tests passed, I'm finished
+
+If tests **failed** (after retries):
+- **`/sungen-run-test ${input:screen}`** — Re-run after manual fixes
+- **`/sungen-create-test ${input:screen}`** — Revise test cases
+- **Done for now** — I'll fix manually later

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

@@ -10,8 +10,9 @@ You generate 3 files for sungen — a Gherkin compiler that produces Playwright
 | `sungen-gherkin-syntax` | All 70+ step patterns, selector types, YAML key rules, tags, element types |
 | `sungen-error-mapping` | Playwright & sungen error → fix mapping |
 | `sungen-tc-generation` | Test case generation strategy, output format |
+| `sungen-test-design-techniques` | EP, BVA, Decision Table, State Transition — systematic scenario generation |
 | `sungen-tc-review` | Review scoring, quality rules, checklist |
-| `sungen-viewpoint` | 7 UI patterns x 4 viewpoints — coverage checklists |
+| `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 |
 
@@ -26,6 +27,8 @@ You generate 3 files for sungen — a Gherkin compiler that produces Playwright
 
 **Order:** add-screen → create-test → review → run-test.
 
+After each command completes, present the next actions as selectable options. Never just print text — always give clickable choices so the user can continue the workflow seamlessly.
+
 ## File Structure
 
 ```
@@ -38,102 +41,6 @@ qa/screens/<screen-name>/
     └── ui/                        # Screenshots, mockups
 ```
 
-## Complete Example
-
-Given a login page, here are the 3 files you generate:
-
-**qa/screens/login/features/login.feature**
-```gherkin
-@no-auth
-Feature: Login Screen
-
-  Scenario: VP-LOGIC-001 Successful login
-    Given User is on [login] page
-    When User fill [Email] field with {{email}}
-    And User fill [Password] field with {{password}}
-    And User click [Submit] button
-    Then User see [Welcome] heading with {{welcome_text}}
-    And User see [Dashboard] link
-```
-
-**qa/screens/login/selectors/login.yaml**
-```yaml
-login:
-  type: 'page'
-  value: '/login'
-
-email:
-  type: 'placeholder'
-  value: 'Enter your email'
-
-password:
-  type: 'placeholder'
-  value: 'Enter your password'
-
-submit:
-  type: 'role'
-  value: 'button'
-  name: 'Submit'
-
-welcome:
-  type: 'role'
-  value: 'heading'
-  name: 'Welcome'
-
-dashboard:
-  type: 'role'
-  value: 'link'
-  name: 'Dashboard'
-```
-
-**qa/screens/login/test-data/login.yaml**
-```yaml
-email: 'admin@example.com'
-password: 'password123'
-welcome_text: 'Welcome back'
-```
-
-## Critical Gherkin Rules (quick reference)
-
-1. **NEVER write `is visible`** — `User see [T] type` already asserts visibility. Only use `is hidden` to assert absence.
-2. **Use `@no-auth` for pre-login pages** (login, register, forgot-password). Use `@auth:role` for authenticated pages.
-3. **Scenario names use VP prefix** — `VP-UI-001`, `VP-VAL-001`, `VP-LOGIC-001`, `VP-SEC-001`.
-4. **Values use `{{snake_case}}`** — never hardcode data in `.feature`. All values go in `test-data.yaml`.
-5. **Selectors are deferred** — `selectors.yaml` is generated during `/sungen-run-test` from the live page, NOT during `/sungen-create-test`.
-6. **Every `{{variable}}` must exist in `test-data.yaml`** — missing variables cause compile failures.
-7. **Assertion type is determined by element type** — input types (`field`, `textarea`, `search`, `dropdown`, `slider`, `date-picker`) → `toHaveValue()`. Everything else → `toHaveText()`. Wrong type = wrong assertion = test failure.
-
-## Using Playwright MCP to explore pages
-
-When exploring a page to generate test files:
-1. Read `playwright.config.ts` for `baseURL`
-2. Use `browser_navigate` to open `baseURL + /path`
-3. Use `browser_snapshot` to see all elements
-4. Generate the 3 files from the snapshot
-
-### Allowed MCP tools
-
-| Tool | Use for |
-|---|---|
-| `browser_navigate` | Open pages |
-| `browser_snapshot` | Capture all accessible elements |
-| `browser_click` | Interact with elements (open dialogs, dropdowns) |
-| `browser_fill_form` | Fill form fields |
-| `browser_evaluate` | **Read-only DOM queries only** (e.g., detect `data-testid` attributes) |
-
-**NEVER use `browser_run_code`** — fails with `require is not defined`.
-
-### Authentication via MCP
-
-1. `browser_navigate` to `baseURL`
-2. If redirected to login, ask the user to log in manually:
-   > "This page requires login. Please log in using the browser. Confirm when you're done."
-3. Once confirmed, `browser_navigate` to the target page and take `browser_snapshot`
-
-**Never use `sungen makeauth`.** Always let the user log in manually via the MCP browser.
-**NEVER use `browser_evaluate` to inject cookies or localStorage** — causes size limit issues and server 500 errors. Use `browser_evaluate` ONLY for read-only DOM queries.
-**Minimize navigations** — take one snapshot per page, do not navigate repeatedly.
-
 ## CLI Commands
 
 ```bash

package/dist/orchestrator/templates/ai-instructions/github-skill-sungen-gherkin-syntax.md

@@ -1,6 +1,6 @@
 ---
 name: sungen-gherkin-syntax
-description: 'Sungen Gherkin patterns, selector types, and YAML key rules. Use this when writing or editing .feature, selectors.yaml, or test-data.yaml files.'
+description: 'Sungen Gherkin patterns, selector types, and YAML key rules. Auto-loaded when writing .feature, selectors.yaml, or test-data.yaml.'
 user-invocable: false
 ---
 
@@ -27,150 +27,68 @@ AND    →  inherits from preceding keyword
 
 ## Step Patterns (70 patterns)
 
-### Setup
+### Setup / Form / Interaction
 
 ```
-User is on [T] page                              # navigate to page
-User is on [T] page with {{v}}                   # navigate with data (e.g., detail page with ID)
-User is on [T] dialog                            # enter dialog scope
+User is on [T] page | page with {{v}} | dialog
+User fill [T] field | textarea | search | slider | date-picker with {{v}}
+User fill [T] uploader with {{f}}
+User clear [T] field
+User check [T] checkbox | toggle | radio
+User uncheck [T] checkbox | toggle
+User select [T] dropdown with {{v}}
+User click [T] button | tab | column | breadcrumb
+User click [T] row with {{v}}
+User double click [T] element
+User hover [T] icon | row
+User drag [T] to [T2]
+User expand | collapse [T] row
 ```
 
-### Form
+**click + with {{Value}} rule**: NO value for static (`button`, `link`, `icon`, `tab`). WITH value only for dynamic lists (`row`, `item`, `card`, `option`).
 
-```
-User fill [T] field with {{v}}                   # text input
-User fill [T] textarea with {{v}}                # multiline input
-User fill [T] search with {{v}}                  # search input
-User fill [T] slider with {{v}}                  # set slider value
-User fill [T] date picker with {{v}}             # date input
-User clear [T] field                             # clear input
-User check [T] checkbox                          # check
-User check [T] toggle                            # toggle on (same as check)
-User check [T] radio                             # select radio
-User uncheck [T] checkbox                        # uncheck
-User uncheck [T] toggle                          # toggle off
-User select [T] dropdown with {{v}}              # select option
-User fill [T] uploader with {{f}}                # file upload
-```
-
-### Interaction
-
-```
-User click [T] button                            # click (static element, no value)
-User click [T] row with {{v}}                    # click dynamic list item (row/item/card/option)
-User click [T] tab                               # switch tab
-User click [T] column                            # sort column
-User click [T] breadcrumb                        # navigate breadcrumb
-User double click [T] element                    # double click
-User hover [T] icon                              # hover (must have see/click after)
-User hover [T] row                               # hover row for hidden actions
-User drag [T] to [T2]                            # drag and drop
-User expand [T] row                              # expand (aria-expanded)
-User collapse [T] row                            # collapse (aria-expanded)
-```
-
-#### click + with {{Value}} rule
-
-- **NO value** for static elements: `button`, `link`, `icon`, `tab`, `toggle`
-- **WITH value** only for dynamic lists: `row`, `item`, `card`, `option`
-
-### Browser Alert (system dialog)
+### Alert / Keyboard / Wait / Scroll
 
 ```
-User click [OK] alert                            # accept (OK/Accept/Yes/Confirm)
-User click [Cancel] alert                        # dismiss (Cancel/Dismiss/No)
-User fill [T] alert with {{v}}                   # fill prompt + accept
-User see [message text] alert                    # assert dialog message
+User click [OK | Cancel] alert
+User fill [T] alert with {{v}}
+User see [message text] alert
+User press Escape key | Enter on [T] field
+User wait for N seconds | [T] dialog | [T] dialog is STATE | [T] page
+User scroll to [T] section
+User switch to [T] frame | [main] frame
 ```
 
 > Alert steps must appear BEFORE the action that triggers the dialog.
 
-### Keyboard
-
-```
-User press Escape key                            # global key press
-User press Enter on [T] field                    # key on element
-```
-
-### Wait
-
-```
-User wait for N seconds                          # wait timeout
-User wait for [T] dialog                         # wait for element
-User wait for [T] dialog is STATE                # wait for state
-User wait for [T] dialog with {{v}}              # wait for element with text
-User wait for [T] page                           # wait for navigation
-User wait for [T] message                        # wait for toast/feedback
-User wait for [T] button                         # wait for button to appear
-```
-
-### Scroll & Frame
-
-```
-User scroll to [T] section                       # scroll into view
-User switch to [T] frame                         # enter iframe
-User switch to [main] frame                      # exit iframe
-```
-
-### Assertions (8 verify patterns)
+### Assertions (8 patterns → determines Playwright assertion)
 
 ```
-# 1. Visibility
-User see [T] message                             # visible (default — NEVER add "is visible")
-User see [T] modal is hidden                     # hidden
-
-# 2. Text Content (exact full match — toHaveText)
-User see [T] message with {{v}}                  # exact text match
-User see [T] header with {{v}}                   # heading text
-User see [T] label with {{v}}                    # label text
-
-# 3. Partial Text Match (toContainText)
-User see [T] text contains {{v}}                 # partial text match
-
-# 4. Input Value (toHaveValue)
-User see [T] field with {{v}}                    # input value
-User see [T] dropdown with {{v}}                 # selected value
-User see [T] date picker with {{v}}              # date value
-User see [T] search with {{v}}                   # search input value
-User see [T] slider with {{v}}                   # slider value
-
-# 5. Component State
-User see [T] button is disabled                  # state assertion
-User see [T] checkbox is checked                 # checked state
-User see [T] toggle is unchecked                 # unchecked state
-User see [T] dialog with {{v}} is hidden         # text + state combined
-
-# 6. Attribute (toHaveAttribute — when selector YAML has `attribute` field)
-User see [T] image with {{v}}                    # image src
-User see [T] link with {{v}}                     # link href
-
-# 7. Count
-User see [T] row with {{count}}                  # element count
-
-# 8. Page Context
-User see [T] page                                # URL assertion
+# 1. Visibility: User see [T] type (NEVER add "is visible") | is hidden
+# 2. Text (toHaveText): User see [T] message | header | label with {{v}}
+# 3. Partial (toContainText): User see [T] text contains {{v}}
+# 4. Input (toHaveValue): User see [T] field | dropdown | date-picker | search | slider with {{v}}
+# 5. State: User see [T] button is disabled | checkbox is checked | dialog with {{v}} is hidden
+# 6. Attribute (toHaveAttribute): User see [T] image | link with {{v}}
+# 7. Count: User see [T] row with {{count}}
+# 8. Page: User see [T] page
 ```
 
 ### Table
 
 ```
-User see [Col] column in [Table] table                          # column exists
-User see [Ref] row in [Table] table with {{v}}                  # row exists (enters row scope)
-User see [Ref] row in [Table] table with {{v}} is hidden        # row hidden
-User see [Table] table with {{count}}                           # row count
-User see [Table] table is empty                                 # empty table
-User see [Col] column with {{v}}                                # cell value (row scoped)
-User click [Act] button in [Table] table with {{v}}             # action in row
-User see [Table] table match data:                              # exact table match (inline DataTable)
+User see [Col] column in [Table] table
+User see [Ref] row in [Table] table with {{v}}
+User see [Ref] row in [Table] table with {{v}} is hidden
+User see [Table] table with {{count}} | is empty
+User see [Col] column with {{v}}
+User click [Act] button in [Table] table with {{v}}
+User see [Table] table match data:
     | Header1    | Header2    |
     | {{value1}} | {{value2}} |
 ```
 
-**Priority**: Use row scope patterns for single-row verification + actions. Use `table match data` only when verifying multiple rows at once.
-
-Row scope: `see [Ref] row in [Table] table with {{v}}` defines `tableRow`. Subsequent `see [Col] column with {{v}}` checks the cell in that row. With `columns` config → exact `nth(index)`, without → `filter({ hasText })`.
-
-Table match data: `see [Table] table match data:` followed by a Cucumber DataTable. First row = headers, remaining rows = expected data. Uses **filter-based matching** — verifies rows containing expected values exist, resilient to data changes, extra rows, and row reordering. Use `{{variable}}` for cell values.
+Row scope: `see [Ref] row in [Table] table with {{v}}` enters scope. Subsequent `see [Col] column with {{v}}` checks cell in that row. Use `table match data:` for multi-row verification.
 
 ### States
 
@@ -223,6 +141,10 @@ Options: `nth` `exact` `scope` `match` `variant` `frame` `contenteditable` `colu
 | `@auto` | Standard scenario, ready for automation |
 | `@manual` | Skip in generation |
 | `@smoke` / `@regression` | Test suite grouping |
+| `@critical` | Priority: system unusable if fails (login, auth, core CRUD) |
+| `@high` | Priority: major feature broken (required validation, key business rules) |
+| `@normal` | Priority: degraded experience (UI layout, secondary flows) |
+| `@low` | Priority: minor/cosmetic (tooltips, hover states, empty states) |
 | `@auth:role` | Use auth storage state for role |
 | `@no-auth` | Disable inherited auth |
 | `@steps:name` | Define reusable step block (base scenario) |
@@ -232,6 +154,8 @@ Options: `nth` `exact` `scope` `match` `variant` `frame` `contenteditable` `colu
 
 - Tool executes **only Given→When** of `@steps` scenario (skips Then)
 - The `Given` in `@extend` scenario is the **entry assertion** (confirms state after base steps)
+- **Entry assertion MUST use `Given User is on [X] type`** — NEVER `Given User see [X] type`
+- `Given` keyword ONLY allows `is on` action. `see` = `Then` only.
 - If `@steps` scenario fails, `@extend` scenario is **skipped**
 - Name format: `snake_case` or `kebab-case` with module prefix: `@steps:kudos__open_modal`
 
@@ -240,6 +164,8 @@ Options: `nth` `exact` `scope` `match` `variant` `frame` `contenteditable` `colu
 | Error | Wrong | Correct |
 |---|---|---|
 | Wrong keyword | `Given User click [T] button` | `When User click [T] button` |
+| `see` after Given | `Given User see [T] heading with {{v}}` | `Then User see [T] heading with {{v}}` (or `Given User is on [T] page` for entry assertion) |
+| Name ≠ step type | Scenario name says "modal" but step uses `dialog` | Use the **same element type** in both: "...dialog opens" + `[X] dialog` |
 | Wrong action for type | `When User click [T] checkbox` | `When User check [T] checkbox` |
 | press wrong target | `When User press [Submit] button` | `When User press Enter key` |
 | uncheck radio | `When User uncheck [Male] radio` | `When User check [Female] radio` |
@@ -247,3 +173,39 @@ Options: `nth` `exact` `scope` `match` `variant` `frame` `contenteditable` `colu
 | Missing `is` for state | `with {{text}} hidden` | `with {{text}} is hidden` |
 | State as value | `with {{disabled}}` | `is disabled` |
 | Missing target type | `fill [email] with {{v}}` | `fill [email] field with {{v}}` |
+| Using Background | `Background: Given User is on...` | Use `@steps` + `@extend` instead |
+| `is on` after When | `When ... And User is on [X] dialog` | `And User see [X] dialog` or separate Given |
+
+## Background vs @steps/@extend
+
+**Do NOT use `Background:` block.** Use `@steps` + `@extend` instead.
+
+**Why:**
+- `Background` runs before EVERY scenario but cannot set dialog/frame scope correctly
+- `Background` with `When` + `And User is on [X] dialog` creates keyword mismatch (`is on` = Given, not When)
+- `@steps` + `@extend` gives explicit control: base steps run Given→When, extending scenario starts with `Given User is on [X] dialog` (correct scope setup)
+
+**Wrong:**
+```gherkin
+Background:
+  Given User is on [Kudos] page
+  When User click [Open] button
+  And User is on [Modal] dialog    ← keyword mismatch
+
+Scenario: VP-UI-001 Title visible
+  Then User see [Title] heading
+```
+
+**Correct:**
+```gherkin
+@steps:open_modal
+Scenario: Open modal
+  Given User is on [Kudos] page
+  When User click [Open] button
+  Then User see [Modal] dialog
+
+@extend:open_modal
+Scenario: VP-UI-001 Title visible
+  Given User is on [Modal] dialog
+  Then User see [Title] heading
+```

package/dist/orchestrator/templates/ai-instructions/github-skill-sungen-selector-fix.md

@@ -1,20 +1,80 @@
 ---
 name: sungen-selector-fix
-description: 'Selector fixing strategy — diagnose failures, explore live page targeted, fix broken selectors. Auto-loaded by run-test command.'
+description: 'Selector fixing strategy — phased execution, priority-first diagnosis, targeted MCP exploration. Auto-loaded by run-test command.'
 user-invocable: false
 ---
 
-## Strategy: Fix Only What Breaks
+## Strategy: Phased Execution
 
-Most selectors auto-infer from Gherkin element types (see `sungen-selector-keys` skill). Only add YAML entries for selectors that fail during test execution.
+Run tests in priority waves — catch fundamental issues early, fix critical paths first, let shared fixes cascade to lower-priority tests.
 
-**Minimal `selectors.yaml`**: page selectors (required), overrides for elements where auto-infer doesn't work. Never generate a full page catalog upfront.
+**Never run all tests blindly.** Always start with a smoke check.
 
 ---
 
-## Step 1: Diagnose Failures
+## Phase 1: Smoke Check (catch fundamentals)
 
-Parse Playwright error output to categorize failures:
+Run **up to 5 scenarios** — pick the first `@critical` or `@high` scenarios in the feature file.
+
+```bash
+npx playwright test --grep "VP-.*-001|VP-.*-002|VP-.*-003|VP-.*-004|VP-.*-005" --reporter=line
+```
+
+**Purpose:** Detect broken fundamentals before running 50+ tests:
+- Page selector wrong → ALL tests would fail (1 fix, not 50 diagnoses)
+- Auth redirect → need `@no-auth` or user login
+- Base `@steps:` scenario broken → all `@extend:` scenarios would fail
+
+**If all 5 pass** → skip to Phase 2.
+**If failures** → diagnose and fix (see Diagnosis & Fix below), then re-run smoke. Max 2 attempts here.
+
+---
+
+## Phase 2: Priority Wave (@critical + @high)
+
+Run all `@critical` and `@high` scenarios:
+
+```bash
+npx playwright test --grep "@critical|@high" --reporter=line
+```
+
+If your Playwright config doesn't support tag grep, use scenario name grep from the feature file — collect VP IDs of `@critical` and `@high` scenarios.
+
+**Fix only failures from this wave.** Most shared selectors (buttons, headings, navigation) get fixed here because critical/high scenarios exercise them.
+
+Max 2 fix attempts in this phase.
+
+---
+
+## Phase 3: Full Run (@normal + @low)
+
+Run remaining scenarios:
+
+```bash
+npx playwright test --reporter=line
+```
+
+Many selectors already fixed from Phase 2 (shared elements). Only diagnose **new** failures — selectors that only appear in lower-priority scenarios.
+
+Max 1 fix attempt. If `@low` scenarios still fail after fix → **report and move on**, don't loop.
+
+---
+
+## Phase 4: Regression
+
+One final full run to confirm all phases together:
+
+```bash
+npx playwright test --reporter=line
+```
+
+Report results. Do NOT enter another fix loop here.
+
+---
+
+## Diagnosis & Fix (used in each phase)
+
+### Step 1: Parse Failures
 
 | Error pattern | Root cause | Fix target |
 |---|---|---|
@@ -28,9 +88,7 @@ Parse Playwright error output to categorize failures:
 
 **Check `test-results/` first** — Playwright captures failure screenshots automatically. Use these to diagnose before any MCP exploration.
 
----
-
-## Step 2: Targeted MCP Exploration
+### Step 2: Targeted MCP Exploration
 
 Only when `test-results/` screenshots are insufficient:
 
@@ -41,11 +99,7 @@ Only when `test-results/` screenshots are insufficient:
 
 **Never use `sungen makeauth`.** Never use `browser_evaluate` to inject cookies.
 
----
-
-## Step 3: Fix Broken Selectors
-
-For each failed selector, find the correct locator from the snapshot:
+### Step 3: Fix Broken Selectors
 
 Selector priority (use first applicable):
 
@@ -73,9 +127,18 @@ Common fixes:
 - Element in iframe → add `frame` field
 - Dynamic content → use `testid` or structural `role` + `nth`
 
+### Step 4: Recompile After Fix
+
+Always recompile before re-running:
+```bash
+sungen generate --screen <screen>
+```
+
+Then re-run only the current phase's failing tests, not all tests.
+
 ---
 
-## Step 4: Table Selectors
+## Table Selectors
 
 For table patterns, add table selectors with `columns` config:
 
@@ -100,7 +163,7 @@ users:
 
 ---
 
-## Step 5: Detail Screens with Dynamic IDs
+## Detail Screens with Dynamic IDs
 
 For screens like `/admin/users/:id`:
 1. Navigate to list page via MCP to find a real record ID
@@ -114,12 +177,13 @@ user detail:
 
 ---
 
-## Step 6: Fix Loop
+## Attempt Budget Summary
 
-After fixing selectors:
-1. Recompile: `sungen generate --screen <screen>`
-2. Re-run only failing tests: `npx playwright test --grep "VP-XXX-001|VP-XXX-002" --reporter=line`
-3. If new failures → repeat (max 3 attempts)
-4. After all fixes → run ALL tests once for regression check
+| Phase | What runs | Max fix attempts | On failure after max |
+|---|---|---|---|
+| 1. Smoke | First 5 @critical/@high | 2 | Ask user — fundamentals broken |
+| 2. Priority | All @critical + @high | 2 | Report failures, continue to Phase 3 |
+| 3. Full | All tests | 1 | Report @low/@normal failures, continue |
+| 4. Regression | All tests | 0 | Report final results |
 
-If still failing after 3 attempts → ask user for guidance.
+**Total worst case: 5 fix attempts** (2+2+1), not unbounded loops.