@specwright/plugin 0.1.1 → 0.1.2

package/.claude_rules/onboarding.md

@@ -0,0 +1,122 @@
+# Onboarding
+
+Context for developers new to this project.
+
+---
+
+### Running E2E Tests for the First Time
+
+**Context:** New developers often run `playwright test` directly and get failures.
+**Decision/Finding:** The correct sequence is always:
+
+```bash
+# 1. Ensure you have valid test credentials in .env
+#    TEST_USER_EMAIL=your-email@example.com
+#    TEST_USER_PASSWORD=your-password
+
+# 2. Run the full BDD suite (bddgen runs automatically)
+pnpm test:bdd
+
+# 3. View results
+pnpm report:playwright
+```
+
+Never run `npx playwright test` directly — it skips `bddgen` and uses stale `.features-gen/` specs.
+
+---
+
+### Auth Credentials
+
+**Context:** E2E tests require valid login credentials.
+**Decision/Finding:** Set `TEST_USER_EMAIL` and `TEST_USER_PASSWORD` in your `.env` file at the project root. The `auth.setup.js` file reads from `authenticationData.js` which pulls from env vars. See `e2e-tests/.env.testing` for a template of all available env vars.
+
+Never hardcode credentials in `authenticationData.js` or any committed file.
+
+---
+
+### How `bddgen` Works
+
+**Context:** Developers are confused why test files in `.features-gen/` exist and whether to edit them.
+**Decision/Finding:** `bddgen` (part of `playwright-bdd`) compiles Gherkin `.feature` files into Playwright `*.spec.js` files inside `.features-gen/`. This directory is gitignored and auto-regenerated. Never edit files in `.features-gen/` — changes are overwritten. Edit the source `.feature` and `steps.js` files instead.
+
+---
+
+### Adding a New E2E Module
+
+**Context:** Step-by-step for creating tests for a new app feature.
+**Decision/Finding:**
+
+1. Create directory: `e2e-tests/features/playwright-bdd/@Modules/@YourModule/`
+2. Create feature file: `@YourModule/your-feature.feature`
+3. Create co-located steps: `@YourModule/steps.js`
+4. Import fixtures: `import { Given, When, Then } from '../../../../playwright/fixtures.js'`
+5. Tag the feature: `@your-module @your-feature` (lowercase module tag)
+6. If steps are reused by other modules, move them to `shared/` instead
+7. Run `pnpm test:bdd` — bddgen picks up new files automatically
+
+---
+
+### Adding a Cross-Module Workflow Test
+
+**Context:** When features span multiple modules with shared data.
+**Decision/Finding:** Workflow tests go in `e2e-tests/features/playwright-bdd/@Workflows/@YourWorkflow/`. Use numbered directories:
+
+- `@0-Precondition/` — serial, creates shared data (`@precondition @cross-feature-data`)
+- `@1-Consumer/` — loads predata via `Given I load predata from "workflow-name"` (`@workflow-consumer`)
+
+Steps that touch multiple modules must be in `shared/` — never co-locate them inside an `@`-prefixed directory.
+
+---
+
+### Module-Specific Test Scripts
+
+**Context:** Running tests for a single module without the full suite.
+**Decision/Finding:**
+
+```bash
+pnpm test:bdd:counter    # Counter module only (serial)
+pnpm test:bdd:users      # Users module only (parallel)
+pnpm test:bdd:bookings   # Bookings workflow only (serial)
+pnpm test:bdd:homepage   # HomePage module only (parallel)
+pnpm test:bdd:auth       # Authentication tests only
+pnpm test:bdd:workflows  # All @Workflows features
+```
+
+---
+
+### Agent Pipeline — Quick Start
+
+**Context:** Using the multi-agent test generation pipeline.
+**Decision/Finding:**
+
+1. Configure `instructions.js` in `e2e-tests/` (see `instructions.example.js`)
+2. Ensure dev server is running: `pnpm dev`
+3. Run `/e2e-automate` skill via Claude Code CLI
+4. The skill handles 10 phases: config → process → explore → approve → generate → execute → review
+5. Generated files appear in `e2e-tests/features/playwright-bdd/@Modules/` or `@Workflows/`
+
+Available skills: `/e2e-automate`, `/e2e-plan`, `/e2e-generate`, `/e2e-heal`, `/e2e-validate`, `/e2e-process`, `/e2e-run`
+
+---
+
+### E2E Directory Map (Quick Reference)
+
+```
+e2e-tests/
+├── features/playwright-bdd/   ← Gherkin feature files + co-located steps
+│   ├── @Modules/              ← single-module tests
+│   ├── @Workflows/            ← cross-module workflow tests
+│   └── shared/                ← globally scoped step definitions
+├── playwright/
+│   ├── fixtures.js            ← custom fixtures (import from here, not playwright-bdd)
+│   ├── auth.setup.js          ← two-step localStorage login
+│   ├── auth-storage/          ← .auth/user.json (gitignored)
+│   ├── generated/             ← seed.spec.js (exploration output)
+│   └── test-data/             ← scoped JSON files (auto-created at runtime)
+├── data/
+│   ├── authenticationData.js  ← credentials from env vars
+│   ├── testConfig.js          ← routes, timeouts, baseUrl
+│   └── migrations/            ← instructions.js for agent pipeline
+├── plans/                     ← generated test plans (intermediate, cleaned up)
+└── reports/                   ← execution reports, review plans
+```

package/.claude_skills/e2e-automate/SKILL.md

@@ -0,0 +1,179 @@
+---
+name: e2e-automate
+description: Run the full 10-phase test automation pipeline — chains /e2e-process, /e2e-plan, /e2e-validate, /e2e-generate, /e2e-heal skills sequentially.
+context: fork
+---
+
+# Test Automation Pipeline
+
+Execute the complete test automation workflow by chaining skills sequentially.
+
+## Pipeline Overview
+
+```
+Phase 1-2: Read config → Detect route (jira/file/text)
+Phase 3:   /e2e-process (convert input to parsed test plan MD)
+Phase 4:   /e2e-plan (explore app + generate test plan)
+Phase 5:   /e2e-validate (validate seed file — optional)
+Phase 6:   ⛔ USER APPROVAL CHECKPOINT
+Phase 7:   /e2e-generate (create .feature + steps.js)
+Phase 8:   /e2e-heal (run tests + auto-heal — optional)
+Phase 9:   Cleanup
+Phase 10:  Final review (quality score + formatted summary)
+```
+
+## Execution Steps
+
+### Phase 1: Initialization
+
+Read `/e2e-tests/instructions.js` and validate configuration.
+
+### Phase 2: Detection & Routing
+
+For each config entry, detect the input type:
+
+- `inputs.jira.url` exists → Jira mode
+- `filePath` exists → File mode
+- `instructions[]` exists → Text mode
+- Otherwise → log error and skip
+
+### Phase 3: Input Processing
+
+Invoke `/e2e-process` with the appropriate input for each config entry:
+
+- Jira mode: pass the Jira URL
+- File mode: pass the file path
+- Text mode: pass as text instructions
+
+**Output:** Parsed MD file at `/e2e-tests/plans/{moduleName}-parsed.md`
+
+### Phase 4: Exploration & Planning
+
+Invoke `/e2e-plan` with the `pageURL` from each config entry.
+
+- If `explore: true`: the skill explores the app via MCP, discovers selectors, writes seed file
+- Saves test plan to `/e2e-tests/plans/{moduleName}-{fileName}-plan.md`
+- **After exploration**: update `.claude/agent-memory/playwright-test-planner/MEMORY.md` with ALL discovered selectors, navigation paths, and patterns. Read the file first, then Edit to add new entries.
+
+### Phase 5: Exploration Validation (Optional)
+
+**Skip if `runExploredCases` is false.**
+
+Invoke `/e2e-validate` to run the seed file tests and auto-heal failures.
+
+### Phase 6: User Approval (MANDATORY)
+
+⛔ **BLOCKING** — Do not proceed without explicit user approval.
+
+Present the test plan summary including:
+
+- Scenario count and names for each module
+- **File paths to the full plan files** so the user can review detailed plans with selectors, steps, and data tables
+
+Then ask:
+
+1. Approve & Generate
+2. View Full Plan
+3. Modify & Retry
+
+### Phase 7: BDD Generation
+
+Invoke `/e2e-generate` with the approved plan file path for each config entry.
+Creates complete `.feature` + `steps.js` files.
+
+### Phase 8: Test Execution & Healing (Optional)
+
+**Skip if `runGeneratedCases` is false.**
+
+Invoke `/e2e-heal` to run the generated BDD tests and auto-heal failures (max 3 iterations).
+
+### Phase 9: Cleanup & Aggregation
+
+Aggregate all results: configs processed, files generated, tests passed/failed, healing stats.
+
+**Clean up intermediate files:**
+
+```bash
+rm -f e2e-tests/plans/*.md
+```
+
+### Phase 10: Final Review
+
+Calculate a quality score from the aggregated pipeline data and display a formatted summary.
+
+**Quality Score Formula:**
+
+```
+qualityScore = (
+  inputProcessingScore * 0.25 +    // (successful configs / total configs) × 100
+  selectorDiscoveryScore * 0.20 +   // (validated selectors / total discovered) × 100, or 0 if no exploration
+  testExecutionScore * 0.30 +       // (passed tests / total tests) × 100, or 70 if execution skipped
+  healingSuccessScore * 0.25        // (auto-fixed / total failures) × 100, or 50 if healing skipped
+)
+```
+
+**Rating:** 95-100 Excellent ⭐⭐⭐⭐⭐ | 85-94 Very Good ⭐⭐⭐⭐ | 75-84 Good ⭐⭐⭐ | 60-74 Fair ⭐⭐ | 0-59 Poor ⭐
+
+**Status:** score>=95 → "READY FOR PRODUCTION" | >=85 → "READY WITH MINOR FIXES" | >=75 → "REQUIRES ATTENTION" | >=60 → "NEEDS IMPROVEMENT" | else → "SIGNIFICANT ISSUES"
+
+**Display format:**
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║             E2E AUTOMATION FINAL REVIEW                      ║
+║                  [{current date/time}]                        ║
+╚══════════════════════════════════════════════════════════════╝
+
+📊 QUALITY SCORE: {score}/100 {stars}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+{rating}
+
+🎯 GENERATION SUMMARY
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  Configs Processed:  {successful}/{total}
+  Feature Files:      {count} created
+  Step Definitions:   {count} files ({totalSteps} steps)
+  Scenarios:          {count} total
+
+📁 GENERATED FILES
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  {list each .feature and steps.js with full path}
+
+🧪 TEST EXECUTION
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  {if tests ran: Passed: X/Y (Z%), Duration: Ns}
+  {if skipped: "Skipped (runGeneratedCases: false)"}
+
+🔧 HEALING
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  {if healing ran: Attempts: N, Auto-fixed: N, Success Rate: N%}
+  {if skipped: "Skipped"}
+
+⏭️  SKIPPED PHASES
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  {list each skipped phase and reason}
+
+📋 NEXT STEPS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  1. Run tests: pnpm test:bdd
+  2. Fix failures: /e2e-heal
+  3. View report: pnpm report:playwright
+
+╔══════════════════════════════════════════════════════════════╗
+║  STATUS: {overallStatus}                                     ║
+╚══════════════════════════════════════════════════════════════╝
+```
+
+## Progress Display
+
+Show a todo list at start, update as each phase completes:
+
+- □ Not started → 🔄 In progress → ✅ Complete / ⏭️ Skipped / ❌ Failed
+
+## Error Handling
+
+If any config fails: log error, continue with next config, mark as failed in summary.
+
+## CRITICAL: Sequential Execution
+
+Execute phases ONE BY ONE. Never run phases in parallel. Always wait for the current phase before starting the next.

package/.claude_skills/e2e-generate/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: e2e-generate
+description: Generate Playwright BDD tests from a test plan — chains bdd-generator (feature files + step skeletons) → code-generator (Playwright implementations).
+argument-hint: <plan-file-or-feature>
+context: fork
+---
+
+# Test Generation
+
+Generate complete BDD test files from a test plan.
+
+## Agent Chain
+
+```
+@agent-bdd-generator
+  → Creates .feature file (Gherkin scenarios, data tables, tags)
+  → Creates steps.js skeleton (imports, step patterns, processDataTable wiring)
+  → Output: READY_FOR_CODE_GENERATION
+
+@agent-code-generator
+  → Reads seed file for validated selectors
+  → Fills in Playwright implementation code
+  → Applies code quality rules (no RegExp constructors, semantic locators, auto-retrying assertions)
+  → Output: Complete runnable steps.js
+```
+
+## Steps
+
+### Step 1: Generate BDD Files
+
+Invoke `@agent-bdd-generator` with:
+
+- Plan file path from $ARGUMENTS (or most recent plan in `/e2e-tests/plans/`)
+- Module config (moduleName, category, subModuleName, fileName)
+
+The agent creates both `.feature` and `steps.js` skeleton with correct imports, step patterns, and data table wiring.
+
+### Step 2: Generate Playwright Code
+
+Invoke `@agent-code-generator` with:
+
+- The steps.js skeleton from Step 1
+- Seed file at `e2e-tests/playwright/generated/seed.spec.js` (if exists)
+- Plan file for context
+
+The agent reads validated selectors from the seed file and fills in complete Playwright implementations.
+
+### Step 3: Verify (Optional)
+
+If the user requests verification, invoke `@agent-playwright-test-generator` to:
+
+- Execute the generated steps in a real browser via MCP
+- Confirm selectors work against the live app
+
+## Input: $ARGUMENTS
+
+Pass the plan file path or module name:
+
+```
+/e2e-generate /e2e-tests/plans/feature-plan.md
+/e2e-generate @ModuleName
+```
+
+## Output
+
+Generated files in `/e2e-tests/features/playwright-bdd/{category}/@{Module}/`:
+
+- `{feature}.feature` — Gherkin scenarios with tags and 3-column data tables
+- `steps.js` — Complete step definitions with Playwright code

package/.claude_skills/e2e-heal/SKILL.md

@@ -0,0 +1,99 @@
+---
+name: e2e-heal
+description: Run tests, diagnose failures, investigate source code, apply direct fixes, and auto-heal remaining issues with up to 3 healing iterations. Generates review plan for unresolved failures.
+argument-hint: <test-file-or-tag>
+context: fork
+---
+
+# Test Healing
+
+Run tests, triage failures, investigate source code, apply direct fixes, and auto-heal remaining issues.
+
+## Agent Chain
+
+```
+@agent-execution-manager (run + triage + source-fix)
+  ↕ loop (max 3 iterations)
+@agent-playwright-test-healer (fix timing/visibility failures via MCP)
+```
+
+## Steps
+
+### Step 1: Run Tests & Triage
+
+Invoke `@agent-execution-manager` in **bdd mode** with any filters from $ARGUMENTS.
+
+The agent:
+
+- Runs `npx bddgen && npx playwright test`
+- Categorizes failures (selector, timeout, assertion, network, data, server)
+- Investigates source code for fixable failures
+- **Directly edits step files** to fix clear selector mismatches
+- Returns execution report with `recommendation`
+
+### Step 2: Check Results
+
+- If `recommendation` is `all_passed` → done, go to Step 6 (memory)
+- If `recommendation` is `fixes_applied` → re-run to verify (go to Step 1)
+- If `recommendation` is `needs_healing` → proceed to Step 3
+- If `recommendation` is `needs_review` → generate review plan, go to Step 6
+
+### Step 3: Heal Remaining Failures
+
+Invoke `@agent-playwright-test-healer` with the `healableFailures` from Step 1.
+
+The healer:
+
+- Debugs each failure interactively using MCP browser tools
+- Captures page snapshots to understand context
+- Updates selectors, assertions, and timing
+- Verifies fixes by re-running the test
+
+### Step 4: Re-run (Loop)
+
+Invoke `@agent-execution-manager` again to verify healer's fixes.
+
+- If all pass → go to Step 6 (memory)
+- If still failing and iterations < 3 → go to Step 3
+- If iterations exhausted → generate review plan, go to Step 6
+
+### Step 5: Generate Review Plan (if failures remain)
+
+After exhausting iterations, generate:
+`/e2e-tests/reports/review-plan-{module}-{timestamp}.md`
+
+### Step 6: Update Agent Memory (MANDATORY — always execute)
+
+After ALL healing work is complete (whether tests pass or review plan generated), update memory files:
+
+**Update `.claude/agent-memory/playwright-test-healer/MEMORY.md`** with:
+
+- **Project Conventions**: Stable patterns discovered (e.g., "Elemental Card doesn't forward data-testid")
+- **Selector Fixes**: Each fix applied (date, module, old selector, new selector, reason) — max 20 entries
+- **Anti-Patterns**: Approaches that consistently fail and their alternatives
+
+**Update `.claude/agent-memory/execution-manager/MEMORY.md`** with:
+
+- **Module → Source Path Mappings**: Any new E2E module → src/ path discovered
+- **Selector Patterns**: ARIA quirks, force-click requirements found during source investigation
+- **Known Risks**: Timing issues, environment gotchas discovered
+
+Read each memory file first, then use the Edit tool to add new entries in-place. Do not overwrite existing entries — append new rows to tables.
+
+**This step is NOT optional.** Execute it even if all tests passed on the first run.
+
+## Input: $ARGUMENTS
+
+```
+/e2e-heal                    # Heal all failing tests
+/e2e-heal @ModuleName        # Heal tests matching tag
+/e2e-heal path/to/feature    # Heal specific feature
+```
+
+## Output
+
+- Fixed test files with updated selectors/assertions
+- Execution report with pass/fail metrics
+- Review plan file (if failures remain after 3 iterations)
+- Updated agent memory files with discovered patterns
+- Tests marked as `test.fixme()` if unfixable

package/.claude_skills/e2e-plan/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: e2e-plan
+description: Create a test plan for a web page or feature using browser exploration, selector discovery, and scenario design.
+argument-hint: <page-url-or-feature>
+context: fork
+agent: playwright-test-planner
+---
+
+# Test Planning Skill
+
+Create a comprehensive test plan by exploring the application in a real browser.
+
+## What This Does
+
+1. Opens browser and navigates to the target page
+2. Explores UI elements via MCP recording workflow
+3. Discovers and validates selectors (priority: testId > role > text > label)
+4. Identifies testable scenarios (happy path, edge cases, negative)
+5. Generates a structured test plan + seed file with validated selectors
+6. **Updates agent memory** with ALL discovered selectors and patterns
+
+## Usage
+
+```
+/e2e-plan /home                        # Plan tests for a page
+/e2e-plan http://localhost:5173/users  # Plan tests for a URL
+/e2e-plan "Login flow"                  # Plan tests for a feature
+```
+
+## Input: $ARGUMENTS
+
+Pass the page URL or feature description to plan tests for.
+
+## Output (3 required)
+
+1. **Seed file**: `e2e-tests/playwright/generated/seed.spec.js` (validated selectors)
+2. **Test plan**: `e2e-tests/plans/{feature}-plan.md` (scenarios, steps, data dependencies)
+3. **Memory update**: `.claude/agent-memory/playwright-test-planner/MEMORY.md` — ALL discovered selectors, navigation paths, reusable patterns, and known limitations written to the memory file

package/.claude_skills/e2e-process/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: e2e-process
+description: Process Jira tickets or files (Excel, CSV, PDF) into parsed test plan markdown.
+argument-hint: <jira-url-or-file-path>
+context: fork
+---
+
+# Input Processing
+
+Process Jira tickets, files, or text instructions into a parsed test plan markdown file.
+
+## Agent Chain
+
+```
+(detect input type)
+  ├─ Jira URL → @agent-jira-processor → @agent-input-processor
+  ├─ File path → @agent-input-processor
+  └─ Text instructions → @agent-input-processor
+```
+
+## Steps
+
+### Step 1: Detect Input Type
+
+From $ARGUMENTS, determine the input type:
+
+- Starts with `http` and contains `atlassian.net` or `jira` → **Jira mode**
+- Has a file extension (.xlsx, .csv, .json, .pdf, .docx) → **File mode**
+- Otherwise → **Text mode** (treat as instructions)
+
+### Step 2a: Jira Mode
+
+Invoke `@agent-jira-processor` with the Jira URL.
+It fetches requirements, analyzes gaps, asks clarifying questions.
+Take its refined output and pass to Step 3.
+
+### Step 2b: File/Text Mode
+
+Skip to Step 3 directly.
+
+### Step 3: Generate Parsed MD
+
+Invoke `@agent-input-processor` with:
+
+- **Jira mode:** refined jiraData from Step 2a
+- **File mode:** filePath from $ARGUMENTS
+- **Text mode:** instructions from $ARGUMENTS
+
+### Step 4: Report
+
+Output: path to generated test plan MD at `/e2e-tests/plans/{module}-parsed.md`
+
+## Input: $ARGUMENTS
+
+```
+/e2e-process https://org.atlassian.net/browse/PROJ-123    # Jira ticket
+/e2e-process /path/to/test-cases.xlsx                      # Excel file
+/e2e-process /path/to/requirements.pdf                     # PDF file
+```
+
+## Output
+
+Parsed test plan at `/e2e-tests/plans/{module}-parsed.md` with status `READY_FOR_VALIDATION`.

package/.claude_skills/e2e-run/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: e2e-run
+description: Run BDD tests and report results. Use to quickly execute E2E tests without the full automation pipeline.
+argument-hint: <project-or-tag>
+context: fork
+---
+
+# Quick Test Runner
+
+Run BDD tests quickly with optional filtering.
+
+## What This Does
+
+1. Runs `npx bddgen` to compile feature files
+2. Runs `npx playwright test` with optional filters from $ARGUMENTS
+3. Reports pass/fail summary
+4. Opens HTML report if failures detected
+
+## Usage
+
+```
+/e2e-run                                  # Run all BDD tests
+/e2e-run --project auth-tests             # Run specific project
+/e2e-run --grep @smoke                    # Run tests matching tag
+/e2e-run --project setup --project main-e2e  # Run multiple projects
+```
+
+## Input: $ARGUMENTS
+
+Optional Playwright CLI arguments (--project, --grep, --headed, --debug, etc.).
+
+## Execution
+
+```bash
+npx bddgen && npx playwright test $ARGUMENTS
+```
+
+If tests fail, automatically run:
+
+```bash
+npx playwright show-report
+```

package/.claude_skills/e2e-validate/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: e2e-validate
+description: Validate explored seed file tests before BDD generation — runs seed tests with random data and auto-heals failures.
+context: fork
+---
+
+# Seed File Validation
+
+Validate explored test cases from the seed file before proceeding with BDD generation.
+
+## Agent Chain
+
+```
+@agent-execution-manager (seed mode — run seed.spec.js)
+  ↕ loop (max 3 iterations)
+@agent-playwright-test-healer (fix selector/timing failures)
+```
+
+## Steps
+
+### Step 1: Execute Seed File
+
+Invoke `@agent-execution-manager` in **seed mode**.
+It runs `e2e-tests/playwright/generated/seed.spec.js` with random test data.
+
+### Step 2: Check Results
+
+- `all_passed` → report "Ready for BDD generation"
+- `needs_healing` → proceed to Step 3
+- `needs_review` → report issues to user
+
+### Step 3: Heal Failures
+
+Invoke `@agent-playwright-test-healer` with the healable failures.
+The healer fixes selectors in the seed file.
+
+### Step 4: Re-run (Loop)
+
+Invoke `@agent-execution-manager` seed mode again.
+
+- All pass → done
+- Still failing and iterations < 3 → go to Step 3
+- Exhausted → report remaining failures
+
+## Output
+
+```
+✅ READY FOR BDD GENERATION — all seed tests passing
+⚠️ NEEDS REVIEW — {n} failures remain after 3 healing iterations
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specwright/plugin",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Drop-in E2E test automation framework plugin — Playwright BDD + Claude Code agents",
   "license": "MIT",
   "bin": {
@@ -10,11 +10,17 @@
     "cli.js",
     "install.sh",
     "PLUGIN.md",
+    "README.md",
     "README-TESTING.md",
     "playwright.config.ts",
     "package.json.snippet",
     ".gitignore.snippet",
-    ".claude_*",
+    ".claude_agents/",
+    ".claude_skills/",
+    ".claude_rules/",
+    ".claude_agent-memory/",
+    ".claude_memory_MEMORY.md",
+    ".claude_README.md",
     "e2e-tests/"
   ],
   "publishConfig": {