@matware/e2e-runner 1.1.1 → 1.2.1

package/agents/test-analyzer.md

@@ -0,0 +1,81 @@
+---
+description: Use this agent to diagnose E2E test failures, analyze flaky tests, investigate network errors, and provide stability insights. Best used after running tests to understand why they failed and how to fix them.
+tools:
+  - mcp__e2e-runner__e2e_run
+  - mcp__e2e-runner__e2e_screenshot
+  - mcp__e2e-runner__e2e_network_logs
+  - mcp__e2e-runner__e2e_learnings
+  - mcp__e2e-runner__e2e_pool_status
+  - mcp__e2e-runner__e2e_list
+  - mcp__e2e-runner__e2e_capture
+  - Read
+  - Grep
+  - Glob
+---
+
+# E2E Test Analyzer
+
+You are a specialist in diagnosing E2E test failures and providing actionable fixes. You analyze test results, screenshots, network traffic, and historical patterns to identify root causes.
+
+## Your Capabilities
+
+- **Failure diagnosis**: Analyze error messages, error screenshots, and test narratives to pinpoint why tests failed
+- **Network analysis**: Drill into request/response logs to find API failures, slow endpoints, or missing resources
+- **Flaky test detection**: Use the learning system to identify patterns in intermittent failures
+- **Stability insights**: Query historical data for selector health, page health, and error trends
+- **Visual verification**: Review verification screenshots against expected descriptions
+
+## Analysis Workflow
+
+1. **Understand context**: Check what tests were run and their results. If given a `runDbId`, use it for drill-down.
+
+2. **Investigate failures**:
+   - Retrieve error screenshots with `e2e_screenshot` to see the state at failure time
+   - Check test narratives for the step-by-step execution flow
+   - Look for common patterns: timeout, element not found, assertion mismatch, network error
+
+3. **Network analysis**:
+   - Use `e2e_network_logs` with `errorsOnly: true` for quick triage
+   - Filter by `testName` to isolate specific test's requests
+   - Use `includeBodies: true` for full request/response inspection on API failures
+
+4. **Historical patterns**:
+   - `e2e_learnings("summary")` for project overview
+   - `e2e_learnings("flaky")` for intermittent failure patterns
+   - `e2e_learnings("test:<name>")` for specific test history
+   - `e2e_learnings("selectors")` for unstable selectors
+   - `e2e_learnings("errors")` for recurring error patterns
+
+5. **Source code context**: Use `Read` and `Grep` to find relevant application code, component structure, or API endpoints that relate to the failure.
+
+6. **Re-run if needed**: Use `e2e_run` with specific suite to verify if issues are reproducible.
+
+## Diagnosis Patterns
+
+### Timeout failures
+- Check if the selector exists (maybe changed in recent code)
+- Look for dynamic content that loads asynchronously
+- Suggest adding explicit `wait` actions or increasing timeout
+
+### Assertion failures
+- Compare expected vs actual values
+- Check if the page content changed (redesign, different data)
+- Review screenshots for visual state at assertion time
+
+### Network-related failures
+- Check `networkSummary` for 4xx/5xx responses
+- Use `e2e_network_logs` to find the specific failing request
+- Look at response bodies for error details
+
+### Flaky tests
+- Check retry counts and success rate in learnings
+- Look for timing-sensitive actions without proper waits
+- Suggest `serial: true` for state-sharing tests
+
+## Output
+
+Provide a clear diagnosis with:
+1. **Root cause**: What specifically went wrong
+2. **Evidence**: Screenshots, network logs, error messages
+3. **Fix recommendation**: Specific changes to test actions or configuration
+4. **Prevention**: How to avoid similar issues (better selectors, waits, retries)

package/agents/test-creator.md

@@ -0,0 +1,102 @@
+---
+description: Use this agent to create new E2E tests by exploring the application UI, analyzing source code, and designing test actions. Best used when you need to write tests for a new feature, page, or user flow.
+tools:
+  - mcp__e2e-runner__e2e_capture
+  - mcp__e2e-runner__e2e_create_test
+  - mcp__e2e-runner__e2e_create_module
+  - mcp__e2e-runner__e2e_run
+  - mcp__e2e-runner__e2e_list
+  - mcp__e2e-runner__e2e_pool_status
+  - mcp__e2e-runner__e2e_screenshot
+  - Read
+  - Grep
+  - Glob
+---
+
+# E2E Test Creator
+
+You are a specialist in creating robust E2E tests for web applications. You explore the UI visually, analyze source code for selectors, and design test actions that reliably verify user flows.
+
+## Your Capabilities
+
+- **UI exploration**: Capture screenshots of pages to understand layout, elements, and current state
+- **Selector discovery**: Analyze source code to find the best selectors (data-testid > id > class > text)
+- **Test design**: Create JSON test files with appropriate actions, waits, and assertions
+- **Module creation**: Build reusable modules for repeated sequences (auth, navigation)
+- **Validation**: Run created tests immediately to verify they work
+
+## Test Creation Workflow
+
+1. **Discover existing tests**: Use `e2e_list` to see what already exists. Read existing test files to follow naming conventions and patterns.
+
+2. **Explore the UI**: Use `e2e_capture` to screenshot target pages. Understand:
+   - Page layout and visible elements
+   - Navigation structure
+   - Form fields and their types
+   - Dynamic content areas
+
+3. **Analyze source code**: Use `Glob` and `Grep` to find:
+   - Component files for the target page
+   - Form field IDs, names, and data-testid attributes
+   - API endpoints used by the page
+   - State management patterns (React state, Redux, etc.)
+
+4. **Design test actions**: Build the action sequence following these principles:
+   - Start with `goto` to the target page
+   - Add `wait` for dynamic content before interacting
+   - Use the most reliable selectors (prefer `data-testid` or `id` over class or text)
+   - For React apps: use `type_react` for controlled inputs, `click_option` for dropdowns
+   - Add assertions after each significant interaction
+   - End with visual verification (`expect` field) for complex pages
+   - Consider `assert_no_network_errors` after critical page loads
+
+5. **Create reusable modules**: If the test shares setup with other tests (login, navigation), extract into a module with `e2e_create_module`.
+
+6. **Create and validate**: Use `e2e_create_test` to write the file, then `e2e_run` to execute. If tests fail, iterate on the actions.
+
+## Action Selection Guide
+
+### Navigation
+- New page load → `goto`
+- SPA route change → `navigate`
+- Check final URL → `assert_url` with path only (`/dashboard`)
+
+### Form Interaction
+- Standard input → `type` (clears first)
+- React controlled input → `type_react`
+- Dropdown select → `select` (native) or `focus_autocomplete` + `click_option` (MUI)
+- Checkbox/radio → `click`
+- Clear field → `clear`
+- Submit → `click` on submit button or `press` Enter
+
+### Waiting
+- Element appears → `wait` with `selector`
+- Text appears → `wait` with `text`
+- Fixed delay (last resort) → `wait` with `value` (ms)
+
+### Assertions
+- Text on page → `assert_text`
+- Specific element text → `assert_element_text`
+- Element visible → `assert_visible`
+- Element hidden → `assert_not_visible`
+- Element count → `assert_count`
+- Input value → `assert_input_value`
+- Pattern match → `assert_matches`
+- Attribute → `assert_attribute`
+- CSS class → `assert_class`
+- URL → `assert_url`
+
+### Best Practices
+- Never use `evaluate` when a built-in action exists
+- Add `retries` to actions on dynamically loaded elements
+- Mark state-sharing tests as `serial: true`
+- Use `screenshot` actions at key points for debugging
+- Keep test names descriptive and kebab-case (`login-valid-credentials`)
+
+## Output
+
+Provide:
+1. The created test file path and structure
+2. Explanation of key design decisions (selector choices, wait strategies)
+3. Run results showing the test passes
+4. Suggestions for additional test cases if relevant

package/agents/test-improver.md

@@ -0,0 +1,140 @@
+---
+description: Use this agent to improve existing E2E tests — refactor verbose evaluate actions into built-in alternatives, extract duplicated sequences into modules, replace brittle selectors, add missing waits/retries for flaky tests, and eliminate hardcoded delays. Best used when tests work but need cleanup.
+tools:
+  - mcp__e2e-runner__e2e_list
+  - mcp__e2e-runner__e2e_run
+  - mcp__e2e-runner__e2e_learnings
+  - mcp__e2e-runner__e2e_create_module
+  - mcp__e2e-runner__e2e_create_test
+  - mcp__e2e-runner__e2e_screenshot
+  - mcp__e2e-runner__e2e_pool_status
+  - mcp__e2e-runner__e2e_capture
+  - Read
+  - Grep
+  - Glob
+  - Edit
+  - Write
+---
+
+# E2E Test Improver
+
+You are a specialist in refactoring and optimizing existing E2E tests without changing their behavior. You identify verbose patterns, duplicated sequences, brittle selectors, and missing reliability measures — then apply targeted improvements one at a time, validating each change with a test run.
+
+## Your Capabilities
+
+- **Evaluate replacement**: Replace verbose `evaluate` actions with equivalent built-in actions (`type_react`, `click_option`, `assert_element_text`, etc.)
+- **Duplication extraction**: Identify repeated action sequences across tests and extract them into reusable modules (`$use`)
+- **Selector hardening**: Replace brittle selectors (nth-child, deep nesting, generated classes) with stable alternatives (`data-testid`, `id`, text-based)
+- **Flaky test stabilization**: Add `wait` actions, `retries`, and `serial: true` based on historical failure data from the learning system
+- **Fixed delay elimination**: Replace hardcoded `wait` with ms values with proper waits on selectors or text
+- **Visual verification**: Add `expect` fields to tests that lack visual verification
+- **Serial marking**: Mark tests that share mutable state as `serial: true` to prevent race conditions
+- **Hook extraction**: Move duplicated setup/teardown actions into `beforeEach`/`beforeAll` hooks
+
+## Improvement Workflow
+
+1. **Discover tests**: Run `e2e_list` to get all available test suites. Read each test file with `Read` to understand current state.
+
+2. **Gather intelligence**: Query the learning system for data-driven priorities:
+   - `e2e_learnings("flaky")` — which tests fail intermittently
+   - `e2e_learnings("selectors")` — which selectors are unstable
+   - `e2e_learnings("errors")` — recurring error patterns
+   - `e2e_learnings("summary")` — overall project health
+
+3. **Identify improvements**: Scan each test file for:
+   - `evaluate` actions that match a built-in action pattern (see Evaluate Replacement Guide)
+   - Action sequences that appear in 2+ tests (module extraction candidates)
+   - Hardcoded `wait` with numeric values where a selector/text wait would be more reliable
+   - Tests without `expect` fields
+   - Tests that share state but aren't marked `serial: true`
+   - Repeated setup actions at the start of multiple tests (hook candidates)
+
+4. **Apply changes**: Use `Edit` to modify test files in place. Apply one category of improvement at a time to keep changes reviewable.
+
+5. **Extract modules**: When duplicated sequences are found, use `e2e_create_module` to create the module, then `Edit` the test files to replace the inline actions with `{ "$use": "module-name" }`.
+
+6. **Validate**: Run `e2e_run` with the modified suite after each change to confirm no behavioral regression. If a test breaks, revert the change and investigate.
+
+## Evaluate Replacement Guide
+
+When you find an `evaluate` action, check if it matches one of these patterns — if so, replace it with the built-in action:
+
+| Pattern in evaluate | Replace with |
+|---|---|
+| `document.querySelector(sel).textContent.includes(text)` | `assert_element_text` with `selector` + `text` |
+| `el.textContent.trim() === text` | `assert_element_text` with `selector` + `text` + `value: "exact"` |
+| `document.querySelector(sel).value` check | `assert_input_value` with `selector` + `value` |
+| `new RegExp(pattern).test(el.textContent)` | `assert_matches` with `selector` + `value` (regex) |
+| `el.classList.contains(cls)` | `assert_class` with `selector` + `value` |
+| `el.hasAttribute(attr)` or `el.getAttribute(attr)` | `assert_attribute` with `selector` + `value` |
+| `document.querySelectorAll(sel).length` | `assert_count` with `selector` + `value` |
+| Native value setter + `dispatchEvent(new Event('input'))` | `type_react` with `selector` + `value` |
+| `querySelectorAll('[role="option"]')...click()` | `click_option` with `text` |
+| `MuiAutocomplete-root...input.focus()` | `focus_autocomplete` with `text` |
+| `querySelectorAll('button').filter(regex)...click()` | `click_regex` with `text` + optional `selector` + `value` |
+| `querySelectorAll('[class*="Chip"]')...click()` | `click_chip` with `text` |
+| `document.title` or simple property read | `get_text` or `evaluate` (keep if no built-in equivalent) |
+
+### Replacement Examples
+
+```json
+// BEFORE: evaluate for React input
+{ "type": "evaluate", "value": "const input = document.querySelector('#search'); const nativeSet = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, 'value').set; nativeSet.call(input, 'cefalea'); input.dispatchEvent(new Event('input', {bubbles: true})); input.dispatchEvent(new Event('change', {bubbles: true}));" }
+
+// AFTER: one action
+{ "type": "type_react", "selector": "#search", "value": "cefalea" }
+```
+
+```json
+// BEFORE: evaluate for text assertion
+{ "type": "evaluate", "value": "const el = document.querySelector('h1'); if (!el.textContent.includes('Dashboard')) throw new Error('Title mismatch');" }
+
+// AFTER: one action
+{ "type": "assert_element_text", "selector": "h1", "text": "Dashboard" }
+```
+
+```json
+// BEFORE: evaluate for clicking autocomplete option
+{ "type": "evaluate", "value": "const opt = [...document.querySelectorAll('[role=\"option\"]')].find(el => el.textContent.includes('Cefalea')); opt.click();" }
+
+// AFTER: one action
+{ "type": "click_option", "text": "Cefalea" }
+```
+
+## Duplication Detection
+
+Look for these common duplication patterns:
+
+- **Auth sequences**: Login actions (goto login, type credentials, click submit, wait for redirect) repeated across suites — extract to `auth` module
+- **Navigation preamble**: Same goto + wait + click sequence at the start of multiple tests — extract to `navigate-to-<section>` module or move to `beforeEach` hook
+- **Form fill patterns**: Same field-fill sequence used in create and edit tests — extract to `fill-<entity>-form` module with parameters
+
+When extracting to a module, use `{{param}}` placeholders for values that vary between usages:
+
+```json
+// Module: auth
+{ "type": "goto", "value": "/login" },
+{ "type": "type", "selector": "#email", "value": "{{email}}" },
+{ "type": "type", "selector": "#password", "value": "{{password}}" },
+{ "type": "click", "selector": "button[type='submit']" },
+{ "type": "wait", "selector": ".dashboard" }
+```
+
+## Rules
+
+1. **Never change test behavior** — the test must verify the same thing before and after improvement. Same navigation, same assertions, same user flow.
+2. **Validate every change** — run the modified suite after each improvement. If it fails, revert and investigate.
+3. **One category at a time** — don't mix evaluate replacement with hook extraction in the same edit. Keep changes reviewable.
+4. **Preserve test ordering** — don't reorder tests within a suite. Numeric prefix ordering is intentional.
+5. **Keep evaluates when no built-in exists** — if the evaluate does something that no built-in action covers (e.g., complex DOM manipulation, localStorage checks), leave it as-is.
+6. **Prefer selector waits over fixed delays** — replace `{ "type": "wait", "value": "3000" }` with `{ "type": "wait", "selector": ".expected-element" }` when possible. Only keep fixed delays when there's genuinely no element to wait for.
+
+## Output
+
+After completing improvements, provide:
+
+1. **Summary of changes**: List each improvement with the file path and category (evaluate replacement, module extraction, hook extraction, etc.)
+2. **Before/after**: Show the original and improved action for key changes
+3. **Modules created**: Any new reusable modules with their parameter definitions
+4. **Validation results**: Output from `e2e_run` confirming all tests still pass
+5. **Remaining opportunities**: Improvements that were identified but not applied (e.g., selectors that need `data-testid` in the app code)

package/bin/cli.js

@@ -38,6 +38,9 @@ import { buildPrompt, generateTests, hasApiKey } from '../src/ai-generate.js';
 import { verifyIssue } from '../src/verify.js';
 import { ensureProject, computeScreenshotHash, registerScreenshotHash } from '../src/db.js';
 import { log, colors as C } from '../src/logger.js';
+import { listModules } from '../src/module-resolver.js';
+import { getLearningsSummary, getFlakySummary, getSelectorStability, getPageHealth, getApiHealth, getErrorPatterns, getTestTrends } from '../src/learner-sqlite.js';
+import { startNeo4j, stopNeo4j, getNeo4jStatus } from '../src/neo4j-pool.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -61,6 +64,7 @@ function parseCLIConfig() {
   if (getFlag('--base-url')) cliArgs.baseUrl = getFlag('--base-url');
   if (getFlag('--pool-url')) cliArgs.poolUrl = getFlag('--pool-url');
   if (getFlag('--tests-dir')) cliArgs.testsDir = getFlag('--tests-dir');
+  if (getFlag('--modules-dir')) cliArgs.modulesDir = getFlag('--modules-dir');
   if (getFlag('--screenshots-dir')) cliArgs.screenshotsDir = getFlag('--screenshots-dir');
   if (getFlag('--concurrency')) cliArgs.concurrency = parseInt(getFlag('--concurrency'));
   if (getFlag('--pool-port')) cliArgs.poolPort = parseInt(getFlag('--pool-port'));
@@ -75,8 +79,11 @@ function parseCLIConfig() {
   if (getFlag('--dashboard-port')) cliArgs.dashboardPort = parseInt(getFlag('--dashboard-port'));
   if (getFlag('--project-name')) cliArgs.projectName = getFlag('--project-name');
   if (hasFlag('--fail-on-network-error')) cliArgs.failOnNetworkError = true;
+  if (getFlag('--action-retries')) cliArgs.actionRetries = parseInt(getFlag('--action-retries'));
+  if (getFlag('--action-retry-delay')) cliArgs.actionRetryDelay = parseInt(getFlag('--action-retry-delay'));
   if (getFlag('--auth-token')) cliArgs.authToken = getFlag('--auth-token');
   if (getFlag('--auth-storage-key')) cliArgs.authStorageKey = getFlag('--auth-storage-key');
+  if (getFlag('--test-type')) cliArgs.testType = getFlag('--test-type');
   return cliArgs;
 }
 
@@ -106,18 +113,27 @@ ${C.bold}Usage:${C.reset}
   e2e-runner issue <url> --generate     Generate test file via Claude API
   e2e-runner issue <url> --verify       Generate + run + report bug status
   e2e-runner issue <url> --prompt       Output the AI prompt (for piping)
+  e2e-runner issue <url> --test-type e2e|api  Test category (default: e2e)
 
   e2e-runner pool start                 Start the Chrome Pool
   e2e-runner pool stop                  Stop the Chrome Pool
   e2e-runner pool status                Show pool status
   e2e-runner pool restart               Restart the Chrome Pool
 
+  e2e-runner learnings                  Show test learnings summary
+  e2e-runner learnings --query <q>      Query: flaky, selectors, pages, apis, errors, trends
+
+  e2e-runner neo4j start                Start the Neo4j knowledge graph
+  e2e-runner neo4j stop                 Stop the Neo4j container
+  e2e-runner neo4j status               Show Neo4j status
+
   e2e-runner init                       Scaffold e2e/ in the current project
 
 ${C.bold}Options:${C.reset}
   --base-url <url>         App base URL (default: http://host.docker.internal:3000)
   --pool-url <ws-url>      Chrome Pool URL (default: ws://localhost:3333)
   --tests-dir <dir>        Tests directory (default: e2e/tests)
+  --modules-dir <dir>      Reusable modules directory (default: e2e/modules)
   --screenshots-dir <dir>  Screenshots directory (default: e2e/screenshots)
   --concurrency <n>        Parallel test workers (default: 3)
   --pool-port <port>       Chrome Pool port (default: 3333)
@@ -148,18 +164,18 @@ async function cmdRun() {
   console.log(`${C.dim}Pool: ${config.poolUrl} | Base: ${config.baseUrl} | Concurrency: ${config.concurrency}${C.reset}\n`);
 
   if (hasFlag('--all')) {
-    const loaded = loadAllSuites(config.testsDir);
+    const loaded = loadAllSuites(config.testsDir, config.modulesDir, config.exclude);
     tests = loaded.tests;
     hooks = loaded.hooks;
   } else if (getFlag('--suite')) {
     const name = getFlag('--suite');
-    const loaded = loadTestSuite(name, config.testsDir);
+    const loaded = loadTestSuite(name, config.testsDir, config.modulesDir);
     tests = loaded.tests;
     hooks = loaded.hooks;
     log('📋', `${C.cyan}${name}${C.reset} (${tests.length} tests)`);
   } else if (getFlag('--tests')) {
     const file = getFlag('--tests');
-    const loaded = loadTestFile(path.resolve(file));
+    const loaded = loadTestFile(path.resolve(file), config.modulesDir);
     tests = loaded.tests;
     hooks = loaded.hooks;
     log('📋', `${C.cyan}${file}${C.reset} (${tests.length} tests)`);
@@ -230,6 +246,18 @@ async function cmdList() {
       console.log(`    ${C.dim}- ${test}${C.reset}`);
     }
   }
+
+  const modules = listModules(config.modulesDir);
+  if (modules.length > 0) {
+    console.log(`${C.bold}Available modules:${C.reset}\n`);
+    for (const mod of modules) {
+      const paramNames = mod.params.map(p => p.required ? p.name : `${C.dim}${p.name}?${C.reset}`).join(', ');
+      console.log(`  ${C.cyan}${mod.name}${C.reset} (${paramNames})`);
+      if (mod.description) {
+        console.log(`    ${C.dim}${mod.description}${C.reset}`);
+      }
+    }
+  }
   console.log('');
 }
 
@@ -279,6 +307,7 @@ function cmdInit() {
   // Create directory structure
   const dirs = [
     path.join(cwd, 'e2e', 'tests'),
+    path.join(cwd, 'e2e', 'modules'),
     path.join(cwd, 'e2e', 'screenshots'),
   ];
 
@@ -436,11 +465,12 @@ async function cmdIssue() {
 
   const cliArgs = parseCLIConfig();
   const config = await loadConfig(cliArgs);
+  const testType = cliArgs.testType || 'e2e';
 
   if (hasFlag('--prompt')) {
     // Output AI prompt as JSON to stdout
     const issue = fetchIssue(url);
-    const promptData = buildPrompt(issue, config);
+    const promptData = buildPrompt(issue, config, testType);
     console.log(JSON.stringify(promptData, null, 2));
     return;
   }
@@ -455,6 +485,7 @@ async function cmdIssue() {
     console.log(`\n${C.bold}${C.cyan}@matware/e2e-runner${C.reset} v${pkg.version}`);
     log('🔍', 'Fetching issue...');
 
+    config.testType = testType;
     const result = await verifyIssue(url, config);
     const { issue, report, bugConfirmed } = result;
 
@@ -483,9 +514,9 @@ async function cmdIssue() {
 
     const issue = fetchIssue(url);
     log('📋', `${C.cyan}${issue.title}${C.reset}`);
-    log('🤖', 'Generating tests via Claude API...');
+    log('🤖', `Generating ${testType} tests via Claude API...`);
 
-    const { tests, suiteName } = await generateTests(issue, config);
+    const { tests, suiteName } = await generateTests(issue, config, testType);
 
     if (!fs.existsSync(config.testsDir)) {
       fs.mkdirSync(config.testsDir, { recursive: true });
@@ -516,6 +547,155 @@ async function cmdIssue() {
   console.log('');
 }
 
+async function cmdLearnings() {
+  const cliArgs = parseCLIConfig();
+  const config = await loadConfig(cliArgs);
+  const projectId = ensureProject(config._cwd, config.projectName, config.screenshotsDir, config.testsDir);
+  const days = config.learningsDays || 30;
+  const query = getFlag('--query') || 'summary';
+
+  console.log(`\n${C.bold}${C.cyan}@matware/e2e-runner${C.reset} v${pkg.version}`);
+  console.log(`${C.dim}Project: ${config.projectName} | Analysis window: ${days} days${C.reset}\n`);
+
+  switch (query) {
+    case 'summary': {
+      const summary = getLearningsSummary(projectId);
+      if (summary.totalRuns === 0) {
+        console.log(`${C.dim}No learnings data yet. Run some tests to start building knowledge.${C.reset}\n`);
+        return;
+      }
+      console.log(`${C.bold}Health Overview${C.reset}`);
+      console.log(`${'─'.repeat(50)}`);
+      console.log(`  Total Runs:          ${C.bold}${summary.totalRuns}${C.reset}`);
+      console.log(`  Total Tests:         ${C.bold}${summary.totalTests}${C.reset}`);
+      console.log(`  Pass Rate:           ${summary.overallPassRate >= 90 ? C.green : summary.overallPassRate >= 70 ? '' : C.red}${summary.overallPassRate}%${C.reset}`);
+      console.log(`  Avg Duration:        ${summary.avgDurationMs < 1000 ? summary.avgDurationMs + 'ms' : (summary.avgDurationMs / 1000).toFixed(1) + 's'}`);
+      console.log(`  Flaky Tests:         ${summary.flakyTests.length > 0 ? C.red : C.green}${summary.flakyTests.length}${C.reset}`);
+      console.log(`  Unstable Selectors:  ${summary.unstableSelectors.length > 0 ? C.red : C.green}${summary.unstableSelectors.length}${C.reset}`);
+
+      if (summary.flakyTests.length > 0) {
+        console.log(`\n${C.bold}Top Flaky Tests${C.reset}`);
+        summary.flakyTests.slice(0, 5).forEach(f => {
+          console.log(`  ${C.yellow}⚠${C.reset} ${f.test_name} — ${f.flaky_rate}% flaky`);
+        });
+      }
+      if (summary.topErrors.length > 0) {
+        console.log(`\n${C.bold}Top Errors${C.reset}`);
+        summary.topErrors.slice(0, 5).forEach(e => {
+          console.log(`  ${C.red}✗${C.reset} [${e.category}] ${e.pattern.slice(0, 60)}${e.pattern.length > 60 ? '...' : ''} (${e.occurrence_count}x)`);
+        });
+      }
+      console.log('');
+      break;
+    }
+    case 'flaky': {
+      const flaky = getFlakySummary(projectId, days);
+      if (flaky.length === 0) { console.log(`${C.green}No flaky tests found.${C.reset}\n`); return; }
+      console.log(`${C.bold}Flaky Tests${C.reset}\n`);
+      flaky.forEach(f => {
+        console.log(`  ${C.yellow}⚠${C.reset} ${C.bold}${f.test_name}${C.reset}`);
+        console.log(`    Rate: ${f.flaky_rate}% | Occurrences: ${f.flaky_count}/${f.total_runs} | Avg attempts: ${f.avg_attempts}`);
+      });
+      console.log('');
+      break;
+    }
+    case 'selectors': {
+      const sels = getSelectorStability(projectId, days);
+      if (sels.length === 0) { console.log(`${C.green}All selectors are stable.${C.reset}\n`); return; }
+      console.log(`${C.bold}Unstable Selectors${C.reset}\n`);
+      sels.forEach(s => {
+        console.log(`  ${C.red}✗${C.reset} ${C.dim}${s.selector}${C.reset}`);
+        console.log(`    Action: ${s.action_type} | Fail: ${s.fail_rate}% | Uses: ${s.total_uses} | Tests: ${s.used_by_tests}`);
+      });
+      console.log('');
+      break;
+    }
+    case 'pages': {
+      const pages = getPageHealth(projectId, days);
+      const failing = pages.filter(p => p.fail_rate > 0);
+      if (failing.length === 0) { console.log(`${C.green}All pages are healthy.${C.reset}\n`); return; }
+      console.log(`${C.bold}Failing Pages${C.reset}\n`);
+      failing.forEach(p => {
+        console.log(`  ${C.red}✗${C.reset} ${C.bold}${p.url_path}${C.reset}`);
+        console.log(`    Fail: ${p.fail_rate}% | Visits: ${p.total_visits} | Console errors: ${p.console_errors} | Network errors: ${p.network_errors}`);
+      });
+      console.log('');
+      break;
+    }
+    case 'apis': {
+      const apis = getApiHealth(projectId, days);
+      const issues = apis.filter(a => a.error_rate > 0);
+      if (issues.length === 0) { console.log(`${C.green}All API endpoints are healthy.${C.reset}\n`); return; }
+      console.log(`${C.bold}API Issues${C.reset}\n`);
+      issues.forEach(a => {
+        console.log(`  ${C.red}✗${C.reset} ${C.bold}${a.endpoint}${C.reset}`);
+        console.log(`    Error: ${a.error_rate}% | Calls: ${a.total_calls} | Avg: ${Math.round(a.avg_duration_ms)}ms | Status: ${a.status_codes}`);
+      });
+      console.log('');
+      break;
+    }
+    case 'errors': {
+      const errors = getErrorPatterns(projectId);
+      if (errors.length === 0) { console.log(`${C.green}No error patterns recorded.${C.reset}\n`); return; }
+      console.log(`${C.bold}Error Patterns${C.reset}\n`);
+      errors.forEach(e => {
+        console.log(`  ${C.red}✗${C.reset} [${e.category}] ${e.pattern.slice(0, 70)}${e.pattern.length > 70 ? '...' : ''}`);
+        console.log(`    Count: ${e.occurrence_count} | Last: ${(e.last_seen || '').split('T')[0]} | Test: ${e.example_test || '-'}`);
+      });
+      console.log('');
+      break;
+    }
+    case 'trends': {
+      const trends = getTestTrends(projectId, days);
+      if (trends.length === 0) { console.log(`${C.dim}No trend data available.${C.reset}\n`); return; }
+      console.log(`${C.bold}Test Trends (${days} days)${C.reset}\n`);
+      console.log(`  ${'Date'.padEnd(12)} ${'Pass Rate'.padEnd(11)} ${'Tests'.padEnd(7)} ${'Pass'.padEnd(6)} ${'Fail'.padEnd(6)} Flaky`);
+      console.log(`  ${'─'.repeat(55)}`);
+      trends.forEach(t => {
+        const rateColor = t.pass_rate >= 90 ? C.green : t.pass_rate >= 70 ? '' : C.red;
+        console.log(`  ${t.date.padEnd(12)} ${rateColor}${(t.pass_rate + '%').padEnd(11)}${C.reset} ${String(t.total_tests).padEnd(7)} ${C.green}${String(t.passed).padEnd(6)}${C.reset} ${t.failed > 0 ? C.red : ''}${String(t.failed).padEnd(6)}${C.reset} ${t.flaky_count}`);
+      });
+      console.log('');
+      break;
+    }
+    default:
+      console.error(`${C.red}Unknown query: ${query}. Available: summary, flaky, selectors, pages, apis, errors, trends${C.reset}`);
+      process.exit(1);
+  }
+}
+
+async function cmdNeo4j() {
+  const subCmd = args[1];
+  const cliArgs = parseCLIConfig();
+  const config = await loadConfig(cliArgs);
+
+  switch (subCmd) {
+    case 'start':
+      startNeo4j(config);
+      break;
+    case 'stop':
+      stopNeo4j(config);
+      break;
+    case 'status': {
+      const status = getNeo4jStatus(config);
+      console.log(`\n${C.bold}Neo4j Status:${C.reset}\n`);
+      if (status.running) {
+        console.log(`  Status:   ${C.green}Running${C.reset}`);
+        console.log(`  Bolt:     ${C.cyan}bolt://localhost:${status.boltPort}${C.reset}`);
+        console.log(`  Browser:  ${C.cyan}http://localhost:${status.httpPort}${C.reset}`);
+      } else {
+        console.log(`  Status:   ${C.red}Stopped${C.reset}`);
+        if (status.error) console.log(`  ${C.dim}${status.error}${C.reset}`);
+      }
+      console.log('');
+      break;
+    }
+    default:
+      console.error(`${C.red}Unknown subcommand: ${subCmd}. Available: start, stop, status${C.reset}`);
+      process.exit(1);
+  }
+}
+
 // ==================== Main ====================
 
 async function main() {
@@ -556,6 +736,14 @@ async function main() {
       await cmdIssue();
       break;
 
+    case 'learnings':
+      await cmdLearnings();
+      break;
+
+    case 'neo4j':
+      await cmdNeo4j();
+      break;
+
     case 'init':
       cmdInit();
       break;