sam-hotfix/e2e/runner/enhance-scenarios.js

#!/usr/bin/env node
/**
 * E2E Scenario Enhancement Script
 *
 * Enhances all 68 scenarios to "ultra-precise" level by adding:
 * - URL verification after navigation
 * - Table structure verification
 * - Statistics card checks
 * - Search functionality test (fill → verify → clear → verify)
 * - First row click → detail verification
 * - Add/create button → modal verification
 * - Console error check
 * - Enhanced verify_detail with visible_text format
 *
 * Categories:
 *   A (5-8 steps): Ultra-simple → target 15-18 steps
 *   B (10-12 steps): Simple READ → target 16-20 steps
 *   C (15-19 steps): Medium CRUD → target 20-25 steps
 *   D (20+ steps): Complex → fix warnings + add missing checks
 */

const fs = require('fs');
const path = require('path');

const SCENARIOS_DIR = path.join(__dirname, '..', 'scenarios');
const BACKUP_DIR = path.join(SCENARIOS_DIR, '_backup_before_enhance');

// Skip these special files
const SKIP_FILES = ['_global', 'login.json', 'pdf-download-test.json'];

// ─── Page Feature Exclusions (from test run analysis) ───

// Pages without standard <table> with clickable rows
const NO_CLICKABLE_ROWS = new Set([
  'production-dashboard', 'settings-position', 'settings-rank',
  'settings-account', 'settings-attendance', 'settings-company',
  'settings-notification', 'settings-subscription',
  'settings-vacation-policy', 'settings-work-schedule',
  'customer-faq', 'department-add', 'inventory-status'
]);

// Pages without standard search input
const NO_SEARCH = new Set([
  'production-dashboard', 'settings-position', 'settings-rank',
  'item-management'
]);

// Pages where menuNavigation.expectedUrl doesn't match actual URL
const WRONG_URL = new Set([
  'accounting-purchase', 'accounting-sales',
  'item-management', 'shipment-management'
]);

// ─── Enhancement Templates ─────────────────────────────

function makeVerifyUrl(expectedUrl, id) {
  return {
    id,
    name: 'URL 검증',
    action: 'verify_url',
    expected: { url_contains: expectedUrl }
  };
}

function makeVerifyTable(id) {
  return {
    id,
    name: '테이블 구조 검증',
    action: 'verify_table'
  };
}

function makeStatsCheck(id) {
  return {
    id,
    name: '통계 카드 확인',
    action: 'evaluate',
    script: `(() => {
      const cards = document.querySelectorAll('[class*="card"], [class*="Card"], [class*="stat"], [class*="Stat"], [class*="summary"]');
      const texts = Array.from(cards).map(c => c.innerText?.substring(0, 30)).filter(Boolean);
      return texts.length > 0 ? 'Stats: ' + texts.length + ' cards found' : 'No stat cards (ok)';
    })()`
  };
}

function makeSearchTest(keyword, id) {
  return {
    id,
    name: '⚠️ 필수 검증: 검색 기능',
    action: 'search',
    value: keyword
  };
}

function makeSearchWait(id) {
  return {
    id,
    name: '검색 결과 대기',
    action: 'wait',
    duration: 1000
  };
}

function makeSearchVerify(id) {
  return {
    id,
    name: '검색 결과 데이터 검증',
    action: 'evaluate',
    script: `(() => {
      const rows = document.querySelectorAll('table tbody tr, [role="row"]');
      return 'Search result: ' + rows.length + ' rows';
    })()`
  };
}

function makeSearchClear(id) {
  return {
    id,
    name: '검색 초기화',
    action: 'evaluate',
    script: `(() => {
      const selectors = ['input[type="search"]', 'input[placeholder*="검색"]', 'input[placeholder*="Search"]', 'input[role="searchbox"]', '[class*="search"] input'];
      for (const sel of selectors) {
        const el = document.querySelector(sel);
        if (el) {
          const nativeSetter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')?.set;
          if (nativeSetter) nativeSetter.call(el, '');
          else el.value = '';
          el.dispatchEvent(new Event('input', { bubbles: true }));
          el.dispatchEvent(new Event('change', { bubbles: true }));
          return 'Search cleared';
        }
      }
      return 'No search input found (ok)';
    })()`
  };
}

function makeSearchClearWait(id) {
  return {
    id,
    name: '검색 초기화 결과 대기',
    action: 'wait',
    duration: 1000
  };
}

function makeSearchRestoredVerify(id) {
  return {
    id,
    name: '검색 초기화 및 복원 확인',
    action: 'evaluate',
    script: `(() => {
      const rows = document.querySelectorAll('table tbody tr, [role="row"]');
      return 'Restored: ' + rows.length + ' rows';
    })()`
  };
}

function makeClickFirstRow(id) {
  return {
    id,
    name: '테이블 행 클릭 - 상세 페이지 이동',
    action: 'click_first_row'
  };
}

function makeDetailWait(id) {
  return {
    id,
    name: '상세 페이지 로딩 대기',
    action: 'wait',
    duration: 1000
  };
}

function makeDetailUrlCheck(id) {
  return {
    id,
    name: '상세 페이지 - URL 확인',
    action: 'verify_url',
    expected: {}
  };
}

function makeDetailContentCheck(id, pageKeyword) {
  return {
    id,
    name: '상세 페이지 - 콘텐츠 확인',
    action: 'evaluate',
    script: `(() => {
      const inputs = document.querySelectorAll('input:not([type="hidden"]), textarea, select');
      const buttons = document.querySelectorAll('button');
      const hasDetail = inputs.length > 0 || document.body.innerText.includes('상세') || document.body.innerText.includes('수정');
      return hasDetail ? 'Detail page: ' + inputs.length + ' inputs, ' + buttons.length + ' buttons' : 'List page (no detail view)';
    })()`
  };
}

function makeNavigateBack(id) {
  return {
    id,
    name: '목록으로 복귀',
    action: 'click_if_exists',
    target: "button:has-text('목록'), a:has-text('목록'), button:has-text('뒤로'), [class*='back']"
  };
}

function makeCloseModalIfOpen(id) {
  return {
    id,
    name: '모달/상세 닫기',
    action: 'close_modal_if_open'
  };
}

function makeAddButtonTest(id) {
  return {
    id,
    name: '등록/추가 버튼 확인',
    action: 'click_if_exists',
    target: "button:has-text('등록'), button:has-text('추가'), button:has-text('신규'), button:has-text('작성')"
  };
}

function makeAddModalWait(id) {
  return {
    id,
    name: '등록 모달/폼 대기',
    action: 'wait',
    duration: 1000
  };
}

function makeAddModalVerify(id) {
  return {
    id,
    name: '등록 모달/폼 검증',
    action: 'evaluate',
    script: `(() => {
      const modal = document.querySelector("[role='dialog'], [aria-modal='true'], [class*='modal']:not([class*='tooltip']), [class*='Modal']");
      if (modal && modal.offsetParent !== null) {
        const inputs = modal.querySelectorAll('input:not([type="hidden"]), textarea, select');
        const buttons = modal.querySelectorAll('button');
        return 'Modal form: ' + inputs.length + ' inputs, ' + buttons.length + ' buttons';
      }
      const inputs = document.querySelectorAll('input:not([type="hidden"]), textarea, select');
      return 'Form page: ' + inputs.length + ' inputs';
    })()`
  };
}

function makeAddModalClose(id) {
  return {
    id,
    name: '등록 모달 닫기',
    action: 'close_modal_if_open'
  };
}

function makeConsoleErrorCheck(id) {
  return {
    id,
    name: '콘솔 에러 확인',
    action: 'verify_element',
    target: 'body'
  };
}

function makeFinalPageVerify(id, keyword) {
  return {
    id,
    name: '최종 페이지 상태 확인',
    action: 'verify_detail',
    checks: [`visible_text:${keyword}`]
  };
}

// Filter-specific steps
function makeFilterDropdownTest(filterName, id) {
  return {
    id,
    name: `${filterName} 필터 테스트`,
    action: 'evaluate',
    script: `(() => {
      const selects = document.querySelectorAll('select, [role="combobox"], button[class*="select"], button[class*="Select"]');
      if (selects.length > 0) {
        return 'Filters found: ' + selects.length;
      }
      return 'No filter dropdowns (ok)';
    })()`
  };
}

function makePaginationCheck(id) {
  return {
    id,
    name: '페이지네이션 확인',
    action: 'evaluate',
    script: `(() => {
      const paginationSels = ['[class*="pagination"]', '[class*="Pagination"]', 'nav[aria-label*="page"]', 'button[aria-label*="page"]', '[class*="pager"]'];
      for (const sel of paginationSels) {
        const el = document.querySelector(sel);
        if (el) return 'Pagination found';
      }
      const pageButtons = Array.from(document.querySelectorAll('button')).filter(b => /^\\d+$/.test(b.innerText?.trim()));
      if (pageButtons.length > 0) return 'Page buttons found: ' + pageButtons.length;
      return 'No pagination (ok - may have single page)';
    })()`
  };
}

// ─── Category Detection ─────────────────────────────────

function detectCategory(scenario) {
  const steps = scenario.steps || [];
  const stepCount = steps.length;
  const hasCRUD = steps.some(s => s.phase && ['CREATE', 'UPDATE', 'DELETE'].includes(s.phase));

  if (stepCount <= 8) return 'A';
  if (stepCount <= 12) return 'B';
  if (stepCount <= 19) return 'C';
  return 'D';
}

function getExpectedUrl(scenario) {
  const menuNav = scenario.menuNavigation || {};
  return menuNav.expectedUrl || '';
}

function getPageKeyword(scenario) {
  const name = scenario.name || '';
  // Extract Korean keyword from name
  const match = name.match(/([가-힣]+)/);
  return match ? match[1] : scenario.id || '';
}

function getSearchKeyword(scenario) {
  // Use a generic search term based on the page type
  const id = scenario.id || '';
  if (id.includes('accounting') || id.includes('vendor') || id.includes('sales')) return '가우스';
  if (id.includes('hr') || id.includes('employee') || id.includes('attendance')) return '테스트';
  if (id.includes('board') || id.includes('customer') || id.includes('notice')) return '테스트';
  if (id.includes('production') || id.includes('quality') || id.includes('item')) return '테스트';
  if (id.includes('settings')) return '테스트';
  return '테스트';
}

// ─── Step Insertion Logic ───────────────────────────────

function hasAction(steps, actionType) {
  return steps.some(s => s.action === actionType);
}

function hasActionName(steps, namePattern) {
  return steps.some(s => s.name && s.name.includes(namePattern));
}

function findStepIndex(steps, actionType) {
  return steps.findIndex(s => s.action === actionType);
}

function renumberSteps(steps) {
  return steps.map((s, i) => ({
    ...s,
    id: i + 1
  }));
}

// ─── Main Enhancement Functions ─────────────────────────

function enhanceCategoryA(scenario) {
  // Ultra-simple (5-8 steps → 15-20 steps)
  const steps = [...scenario.steps];
  const expectedUrl = getExpectedUrl(scenario);
  const keyword = getPageKeyword(scenario);
  const searchKw = getSearchKeyword(scenario);
  const sid = scenario.id || '';

  let enhanced = [];
  let inserted = new Set();

  for (let i = 0; i < steps.length; i++) {
    const step = steps[i];
    enhanced.push(step);

    // After menu_navigate: add URL verify (skip for WRONG_URL pages)
    if (step.action === 'menu_navigate' && !inserted.has('verify_url')) {
      if (expectedUrl && !WRONG_URL.has(sid)) {
        enhanced.push(makeVerifyUrl(expectedUrl, 0));
      }
      inserted.add('verify_url');
    }

    // After verify_not_mockup: add table + stats + search + first row
    if (step.action === 'verify_not_mockup' && !inserted.has('table_section')) {
      // Table structure
      enhanced.push(makeVerifyTable(0));
      // Statistics cards
      enhanced.push(makeStatsCheck(0));
      // Search test (skip for NO_SEARCH pages)
      if (!NO_SEARCH.has(sid)) {
        enhanced.push(makeSearchTest(searchKw, 0));
        enhanced.push(makeSearchWait(0));
        enhanced.push(makeSearchVerify(0));
        // Search clear
        enhanced.push(makeSearchClear(0));
        enhanced.push(makeSearchClearWait(0));
        enhanced.push(makeSearchRestoredVerify(0));
      }
      // First row click (skip for NO_CLICKABLE_ROWS pages)
      if (!NO_CLICKABLE_ROWS.has(sid)) {
        enhanced.push(makeClickFirstRow(0));
        enhanced.push(makeDetailWait(0));
        enhanced.push(makeDetailContentCheck(0, keyword));
        enhanced.push(makeCloseModalIfOpen(0));
      }

      inserted.add('table_section');
    }
  }

  // Add console error check before the final step if not present
  if (!hasActionName(enhanced, '콘솔 에러')) {
    // Insert before last step
    const lastStep = enhanced.pop();
    enhanced.push(makeConsoleErrorCheck(0));
    enhanced.push(lastStep);
  }

  return renumberSteps(enhanced);
}

function enhanceCategoryB(scenario) {
  // Simple READ (10-12 steps → 16-22 steps)
  const steps = [...scenario.steps];
  const expectedUrl = getExpectedUrl(scenario);
  const keyword = getPageKeyword(scenario);
  const searchKw = getSearchKeyword(scenario);
  const sid = scenario.id || '';

  let enhanced = [];
  let inserted = new Set();

  for (let i = 0; i < steps.length; i++) {
    const step = steps[i];
    enhanced.push(step);

    // After menu_navigate: add URL verify (skip for WRONG_URL pages)
    if (step.action === 'menu_navigate' && !inserted.has('verify_url')) {
      if (expectedUrl && !WRONG_URL.has(sid)) {
        enhanced.push(makeVerifyUrl(expectedUrl, 0));
      }
      inserted.add('verify_url');
    }

    // After verify_not_mockup: add stats + enhanced table
    if (step.action === 'verify_not_mockup' && !inserted.has('stats')) {
      enhanced.push(makeStatsCheck(0));
      inserted.add('stats');
    }

    // After verify_table: add filter check
    if (step.action === 'verify_table' && !inserted.has('filter')) {
      enhanced.push(makeFilterDropdownTest('목록', 0));
      inserted.add('filter');
    }

    // After search: add search verification if not present
    if (step.action === 'search' && !inserted.has('search_verify')) {
      if (!steps[i + 1] || steps[i + 1].action !== 'wait') {
        enhanced.push(makeSearchWait(0));
      }
      enhanced.push(makeSearchVerify(0));
      // Add clear + restore
      enhanced.push(makeSearchClear(0));
      enhanced.push(makeSearchClearWait(0));
      enhanced.push(makeSearchRestoredVerify(0));
      inserted.add('search_verify');
    }

    // After click_first_row: add detail verification
    if (step.action === 'click_first_row' && !inserted.has('detail_verify')) {
      enhanced.push(makeDetailWait(0));
      enhanced.push(makeDetailContentCheck(0, keyword));
      inserted.add('detail_verify');
    }
  }

  // If no search test exists, add one (skip for NO_SEARCH pages)
  if (!hasAction(steps, 'search') && !inserted.has('search_verify') && !NO_SEARCH.has(sid)) {
    const tableIdx = enhanced.findIndex(s => s.action === 'verify_table');
    if (tableIdx >= 0) {
      const insertAt = tableIdx + 1 + (inserted.has('filter') ? 1 : 0);
      const searchSteps = [
        makeSearchTest(searchKw, 0),
        makeSearchWait(0),
        makeSearchVerify(0),
        makeSearchClear(0),
        makeSearchClearWait(0),
        makeSearchRestoredVerify(0),
      ];
      enhanced.splice(insertAt, 0, ...searchSteps);
    }
  }

  // If no click_first_row, add one (skip for NO_CLICKABLE_ROWS pages)
  if (!hasAction(steps, 'click_first_row') && !hasActionName(steps, '행 클릭') && !inserted.has('detail_verify') && !NO_CLICKABLE_ROWS.has(sid)) {
    const lastModalIdx = enhanced.findLastIndex(s => s.action === 'close_modal_if_open' || s.action === 'close_modal');
    const insertAt = lastModalIdx >= 0 ? lastModalIdx : enhanced.length - 1;
    const detailSteps = [
      makeClickFirstRow(0),
      makeDetailWait(0),
      makeDetailContentCheck(0, keyword),
      makeCloseModalIfOpen(0),
    ];
    enhanced.splice(insertAt, 0, ...detailSteps);
  }

  // Add pagination check
  if (!hasActionName(enhanced, '페이지네이션')) {
    const lastStep = enhanced.pop();
    enhanced.push(makePaginationCheck(0));
    enhanced.push(lastStep);
  }

  // Add console error check
  if (!hasActionName(enhanced, '콘솔 에러')) {
    const lastStep = enhanced.pop();
    enhanced.push(makeConsoleErrorCheck(0));
    enhanced.push(lastStep);
  }

  return renumberSteps(enhanced);
}

function enhanceCategoryC(scenario) {
  // Medium CRUD (15-19 steps → 20-28 steps)
  const steps = [...scenario.steps];
  const expectedUrl = getExpectedUrl(scenario);
  const keyword = getPageKeyword(scenario);
  const sid = scenario.id || '';

  let enhanced = [];
  let inserted = new Set();

  for (let i = 0; i < steps.length; i++) {
    const step = steps[i];
    enhanced.push(step);

    // After menu_navigate: add URL verify if not present (skip for WRONG_URL pages)
    if (step.action === 'menu_navigate' && !inserted.has('verify_url')) {
      const nextStep = steps[i + 1];
      if (!nextStep || nextStep.action !== 'verify_url') {
        if (expectedUrl && !WRONG_URL.has(sid)) {
          enhanced.push(makeVerifyUrl(expectedUrl, 0));
        }
      }
      inserted.add('verify_url');
    }

    // After verify_not_mockup: add stats
    if (step.action === 'verify_not_mockup' && !inserted.has('stats')) {
      const nextStep = steps[i + 1];
      if (!nextStep || !nextStep.name?.includes('통계')) {
        enhanced.push(makeStatsCheck(0));
      }
      inserted.add('stats');
    }

    // After verify_table: add filter test
    if (step.action === 'verify_table' && !inserted.has('filter')) {
      const nextStep = steps[i + 1];
      if (!nextStep || !nextStep.name?.includes('필터')) {
        enhanced.push(makeFilterDropdownTest('목록', 0));
      }
      inserted.add('filter');
    }

    // After search-related click_if_exists (with search in target)
    if (step.action === 'search' && !inserted.has('search_verify')) {
      enhanced.push(makeSearchVerify(0));
      inserted.add('search_verify');
    }

    // After CREATE save: add toast verify
    if (step.phase === 'CREATE' && step.name?.includes('저장') && !inserted.has('create_toast')) {
      const nextStep = steps[i + 1];
      if (!nextStep || nextStep.action !== 'verify_toast') {
        enhanced.push({
          id: 0,
          phase: 'CREATE',
          name: '[CREATE] 저장 완료 토스트 확인',
          action: 'verify_toast',
          verify: { contains: '등록|완료|성공|저장' }
        });
      }
      inserted.add('create_toast');
    }

    // After UPDATE save: add toast verify
    if (step.phase === 'UPDATE' && step.name?.includes('저장') && !inserted.has('update_toast')) {
      const nextStep = steps[i + 1];
      if (!nextStep || nextStep.action !== 'verify_toast') {
        enhanced.push({
          id: 0,
          phase: 'UPDATE',
          name: '[UPDATE] 수정 완료 토스트 확인',
          action: 'verify_toast',
          verify: { contains: '수정|완료|성공|저장' }
        });
      }
      inserted.add('update_toast');
    }

    // After DELETE confirm: add toast verify
    if (step.phase === 'DELETE' && (step.name?.includes('확인') || step.name?.includes('삭제')) &&
        step.action === 'click_dialog_confirm' && !inserted.has('delete_toast')) {
      const nextStep = steps[i + 1];
      if (!nextStep || nextStep.action !== 'verify_toast') {
        enhanced.push({
          id: 0,
          phase: 'DELETE',
          name: '[DELETE] 삭제 완료 토스트 확인',
          action: 'verify_toast',
          verify: { contains: '삭제|완료|성공|제거' }
        });
      }
      inserted.add('delete_toast');
    }
  }

  // Add console error check
  if (!hasActionName(enhanced, '콘솔 에러')) {
    enhanced.push(makeConsoleErrorCheck(0));
  }

  return renumberSteps(enhanced);
}

function enhanceCategoryD(scenario) {
  // Complex (20+ steps) → fix issues + minimal additions
  const steps = [...scenario.steps];
  const expectedUrl = getExpectedUrl(scenario);
  const sid = scenario.id || '';

  let enhanced = [];
  let inserted = new Set();

  for (let i = 0; i < steps.length; i++) {
    const step = steps[i];

    // Fix verify_detail_info → verify_detail with visible_text format
    if (step.action === 'verify_detail_info') {
      const fixedStep = {
        ...step,
        action: 'verify_detail',
        checks: (step.checks || []).map(c => {
          // If check already has visible_text format, keep it
          if (c.startsWith('visible_text:')) return c;
          // Convert "label: value" format to just check the label part
          const label = c.split(':')[0].trim().replace(/\s*(필드|정보|항목|카드)/g, '');
          return `visible_text:${label}`;
        })
      };
      enhanced.push(fixedStep);
      continue;
    }

    enhanced.push(step);

    // After menu_navigate: add URL verify if not present (skip for WRONG_URL pages)
    if (step.action === 'menu_navigate' && !inserted.has('verify_url')) {
      const nextStep = steps[i + 1];
      if (nextStep && nextStep.action !== 'verify_url') {
        if (expectedUrl && !WRONG_URL.has(sid)) {
          enhanced.push(makeVerifyUrl(expectedUrl, 0));
        }
      }
      inserted.add('verify_url');
    }
  }

  // Add console error check if not present
  if (!hasActionName(enhanced, '콘솔 에러')) {
    enhanced.push(makeConsoleErrorCheck(0));
  }

  return renumberSteps(enhanced);
}

// ─── Main Processing ────────────────────────────────────

function processScenario(filePath) {
  const content = fs.readFileSync(filePath, 'utf-8');
  const scenario = JSON.parse(content);

  // Skip special scenarios
  const id = scenario.id || '';
  if (id === 'login' || id === 'pdf-download-test') {
    return { id, category: 'SKIP', before: scenario.steps.length, after: scenario.steps.length };
  }

  const category = detectCategory(scenario);
  const beforeCount = scenario.steps.length;

  let enhancedSteps;
  switch (category) {
    case 'A': enhancedSteps = enhanceCategoryA(scenario); break;
    case 'B': enhancedSteps = enhanceCategoryB(scenario); break;
    case 'C': enhancedSteps = enhanceCategoryC(scenario); break;
    case 'D': enhancedSteps = enhanceCategoryD(scenario); break;
    default: enhancedSteps = scenario.steps;
  }

  const afterCount = enhancedSteps.length;

  // Update scenario
  scenario.steps = enhancedSteps;

  // Write enhanced scenario
  fs.writeFileSync(filePath, JSON.stringify(scenario, null, 2) + '\n', 'utf-8');

  return { id, category, before: beforeCount, after: afterCount };
}

// ─── Entry Point ────────────────────────────────────────

function main() {
  console.log('\n=== E2E Scenario Enhancement ===\n');

  // Create backup
  if (!fs.existsSync(BACKUP_DIR)) {
    fs.mkdirSync(BACKUP_DIR, { recursive: true });
  }

  // Get all scenario files
  const files = fs.readdirSync(SCENARIOS_DIR)
    .filter(f => f.endsWith('.json') && !f.startsWith('_'))
    .sort();

  console.log(`Found ${files.length} scenarios\n`);

  // Backup all files
  for (const file of files) {
    const src = path.join(SCENARIOS_DIR, file);
    const dst = path.join(BACKUP_DIR, file);
    fs.copyFileSync(src, dst);
  }
  console.log(`Backed up to: ${BACKUP_DIR}\n`);

  // Process each scenario
  const results = [];
  let totalBefore = 0;
  let totalAfter = 0;

  for (const file of files) {
    const filePath = path.join(SCENARIOS_DIR, file);
    try {
      const result = processScenario(filePath);
      results.push(result);
      totalBefore += result.before;
      totalAfter += result.after;

      const delta = result.after - result.before;
      const deltaStr = delta > 0 ? `+${delta}` : delta === 0 ? '=' : `${delta}`;
      console.log(`  ${result.category} ${result.id.padEnd(35)} ${result.before} → ${result.after} (${deltaStr})`);
    } catch (err) {
      console.error(`  ❌ ${file}: ${err.message}`);
      results.push({ id: file, category: 'ERROR', before: 0, after: 0 });
    }
  }

  // Summary
  const catA = results.filter(r => r.category === 'A');
  const catB = results.filter(r => r.category === 'B');
  const catC = results.filter(r => r.category === 'C');
  const catD = results.filter(r => r.category === 'D');
  const skipped = results.filter(r => r.category === 'SKIP');

  console.log('\n=== Enhancement Summary ===');
  console.log(`Category A (ultra-simple):  ${catA.length} scenarios`);
  console.log(`Category B (simple READ):   ${catB.length} scenarios`);
  console.log(`Category C (medium CRUD):   ${catC.length} scenarios`);
  console.log(`Category D (complex):       ${catD.length} scenarios`);
  console.log(`Skipped:                    ${skipped.length} scenarios`);
  console.log(`\nTotal steps: ${totalBefore} → ${totalAfter} (+${totalAfter - totalBefore})`);
  console.log(`\nBackup at: ${BACKUP_DIR}`);
  console.log('\nDone! Run tests with: node e2e/runner/run-all.js\n');
}

main();