viberadar 0.3.46 → 0.3.47

package/dist/server/index.js

@@ -123,90 +123,68 @@ function fmtTool(name, input = {}) {
         default: return `🔧 ${name}${fp ? ': ' + fp : ''}`;
     }
 }
-function e2ePlanDir(projectRoot) {
-    return path.join(projectRoot, '.viberadar', 'e2e-plans');
-}
-function e2ePlanPath(projectRoot, featureKey) {
-    return path.join(e2ePlanDir(projectRoot), `${featureKey}.json`);
-}
-function loadE2ePlan(projectRoot, featureKey) {
-    const fp = e2ePlanPath(projectRoot, featureKey);
-    try {
-        return JSON.parse(fs.readFileSync(fp, 'utf-8'));
-    }
-    catch {
-        return null;
-    }
-}
-function saveE2ePlan(projectRoot, plan) {
-    const dir = e2ePlanDir(projectRoot);
-    fs.mkdirSync(dir, { recursive: true });
-    plan.updatedAt = new Date().toISOString();
-    fs.writeFileSync(e2ePlanPath(projectRoot, plan.featureKey), JSON.stringify(plan, null, 2), 'utf-8');
-}
-function e2eScreenshotDir(projectRoot, featureKey) {
-    return path.join(projectRoot, '.viberadar', 'e2e-screenshots', featureKey);
-}
-function collectScreenshots(projectRoot, featureKey) {
-    const baseDir = e2eScreenshotDir(projectRoot, featureKey);
-    const result = new Map();
-    if (!fs.existsSync(baseDir))
-        return result;
-    try {
-        for (const entry of fs.readdirSync(baseDir, { withFileTypes: true })) {
-            if (!entry.isDirectory())
-                continue;
-            const tcPath = path.join(baseDir, entry.name);
-            const screenshots = fs.readdirSync(tcPath)
-                .filter(f => /\.(png|jpg|jpeg|webp)$/i.test(f))
-                .map(f => `${featureKey}/${entry.name}/${f}`);
-            result.set(entry.name, screenshots);
-        }
-    }
-    catch { }
-    return result;
-}
-function hasPlaywright(projectRoot) {
-    try {
-        const pkg = JSON.parse(fs.readFileSync(path.join(projectRoot, 'package.json'), 'utf-8'));
-        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-        return !!deps['@playwright/test'] || !!deps['playwright'];
-    }
-    catch {
-        return false;
-    }
-}
 // ─── Test runner after agent ──────────────────────────────────────────────────
 const TEST_FILE_RE = /\.(test|spec)\.(ts|tsx|js|jsx)$/;
 function runTestFiles(files, projectRoot) {
     return new Promise((resolve) => {
-        const proc = (0, child_process_1.spawn)('npx', ['vitest', 'run', '--reporter=json', ...files], { cwd: projectRoot, shell: true, stdio: 'pipe' });
+        // Write JSON to a temp file — avoids stdout encoding/regex issues on Windows
+        const tmpDir = path.join(projectRoot, '.viberadar');
+        const tmpFile = path.join(tmpDir, '_test-results.json');
+        try {
+            fs.mkdirSync(tmpDir, { recursive: true });
+        }
+        catch { }
+        try {
+            fs.unlinkSync(tmpFile);
+        }
+        catch { }
+        const proc = (0, child_process_1.spawn)('npx', ['vitest', 'run', '--reporter=json', `--outputFile=${tmpFile}`, ...files], { cwd: projectRoot, shell: true, stdio: 'pipe' });
         let stdout = '';
-        proc.stdout?.on('data', (d) => stdout += d.toString());
+        proc.stdout?.on('data', (d) => { stdout += d.toString(); });
         proc.on('close', () => {
             try {
-                // vitest --reporter=json wraps output; find the JSON object
-                const match = stdout.match(/\{[\s\S]*"testResults"[\s\S]*\}/);
-                const json = JSON.parse(match ? match[0] : stdout);
+                // Prefer the output file (reliable); fall back to stdout
+                let jsonStr;
+                if (fs.existsSync(tmpFile)) {
+                    jsonStr = fs.readFileSync(tmpFile, 'utf-8').trim();
+                    process.stdout.write(`   ✅ vitest outputFile: ${tmpFile} (${jsonStr.length} bytes)\n`);
+                }
+                else {
+                    process.stdout.write(`   ⚠️  vitest outputFile not found, falling back to stdout (${stdout.length} bytes)\n`);
+                    const match = stdout.match(/\{[\s\S]*"testResults"[\s\S]*\}/);
+                    jsonStr = match ? match[0] : stdout.trim();
+                }
+                const json = JSON.parse(jsonStr);
+                process.stdout.write(`   🔍 vitest JSON: passed=${json.numPassedTests} failed=${json.numFailedTests} testResults=${(json.testResults ?? []).length}\n`);
                 // Extract per-file failure details
                 const fileDetails = {};
                 for (const tr of (json.testResults ?? [])) {
                     const fp = tr.testFilePath ?? '';
+                    if (!fp)
+                        continue;
+                    const assertions = tr.assertionResults ?? tr.testResults ?? [];
                     const errors = [];
-                    for (const ar of (tr.assertionResults ?? [])) {
+                    for (const ar of assertions) {
                         if (ar.status === 'failed') {
                             errors.push({
                                 testName: ar.fullName ?? ar.title ?? 'unknown',
-                                message: (ar.failureMessages?.[0] ?? '').split('\n')[0].slice(0, 300),
+                                message: (ar.failureMessages?.[0] ?? ar.errors?.[0]?.message ?? '').split('\n')[0].slice(0, 300),
                             });
                         }
                     }
                     fileDetails[fp] = {
-                        passed: (tr.assertionResults ?? []).filter((a) => a.status === 'passed').length,
+                        passed: assertions.filter((a) => a.status === 'passed').length,
                         failed: errors.length,
                         errors,
                     };
                 }
+                const failedFiles = Object.entries(fileDetails).filter(([, d]) => d.failed > 0);
+                process.stdout.write(`   🔍 fileDetails: ${Object.keys(fileDetails).length} files, ${failedFiles.length} with failures\n`);
+                if (failedFiles.length > 0) {
+                    for (const [fp, d] of failedFiles) {
+                        process.stdout.write(`      ❌ ${fp} → ${d.failed} failed\n`);
+                    }
+                }
                 resolve({
                     passed: json.numPassedTests ?? 0,
                     failed: json.numFailedTests ?? 0,
@@ -214,58 +192,106 @@ function runTestFiles(files, projectRoot) {
                     fileDetails,
                 });
             }
-            catch {
+            catch (err) {
+                process.stdout.write(`   ❌ runTestFiles parse error: ${err.message}\n`);
                 resolve({ passed: 0, failed: 0, files, fileDetails: {} });
             }
         });
         proc.on('error', () => resolve({ passed: 0, failed: 0, files, fileDetails: {} }));
     });
 }
+// ─── E2E plan storage ─────────────────────────────────────────────────────────
+function e2ePlanDir(projectRoot) {
+    return path.join(projectRoot, '.viberadar', 'e2e-plans');
+}
+function e2ePlanPath(projectRoot, featureKey) {
+    return path.join(e2ePlanDir(projectRoot), `${featureKey}.json`);
+}
+function loadE2ePlan(projectRoot, featureKey) {
+    try {
+        const p = e2ePlanPath(projectRoot, featureKey);
+        if (!fs.existsSync(p))
+            return null;
+        return JSON.parse(fs.readFileSync(p, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function saveE2ePlan(projectRoot, plan) {
+    const dir = e2ePlanDir(projectRoot);
+    fs.mkdirSync(dir, { recursive: true });
+    plan.updatedAt = new Date().toISOString();
+    fs.writeFileSync(e2ePlanPath(projectRoot, plan.featureKey), JSON.stringify(plan, null, 2), 'utf-8');
+}
+function e2eScreenshotDir(projectRoot, featureKey) {
+    return path.join(projectRoot, '.viberadar', 'e2e-screenshots', featureKey);
+}
+function collectScreenshots(projectRoot, featureKey, testCaseId) {
+    const dir = path.join(e2eScreenshotDir(projectRoot, featureKey), testCaseId);
+    try {
+        if (!fs.existsSync(dir))
+            return [];
+        return fs.readdirSync(dir)
+            .filter(f => /\.(png|jpg|jpeg|webp)$/i.test(f))
+            .sort()
+            .map(f => `${featureKey}/${testCaseId}/${f}`);
+    }
+    catch {
+        return [];
+    }
+}
+function hasPlaywright(projectRoot) {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(projectRoot, 'package.json'), 'utf-8'));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        return !!deps['@playwright/test'] || !!deps['playwright'];
+    }
+    catch {
+        return false;
+    }
+}
+// ─── Playwright runner ────────────────────────────────────────────────────────
 function runPlaywrightTests(files, projectRoot) {
     return new Promise((resolve) => {
-        const proc = (0, child_process_1.spawn)('npx', ['playwright', 'test', ...files, '--reporter=json'], { cwd: projectRoot, shell: true, stdio: 'pipe' });
+        const proc = (0, child_process_1.spawn)('npx', ['playwright', 'test', '--reporter=json', ...files], { cwd: projectRoot, shell: true, stdio: 'pipe' });
         let stdout = '';
-        proc.stdout?.on('data', (d) => stdout += d.toString());
+        proc.stdout?.on('data', (d) => { stdout += d.toString(); });
         proc.on('close', () => {
             try {
                 const match = stdout.match(/\{[\s\S]*"suites"[\s\S]*\}/);
                 const json = JSON.parse(match ? match[0] : stdout);
-                const testResults = [];
+                const results = {};
+                const errors = {};
                 let passed = 0, failed = 0;
                 const walkSuites = (suites) => {
-                    for (const suite of suites) {
-                        for (const spec of (suite.specs || [])) {
-                            for (const test of (spec.tests || [])) {
-                                for (const result of (test.results || [])) {
-                                    const status = result.status === 'passed' ? 'passed'
-                                        : result.status === 'failed' ? 'failed'
-                                            : 'skipped';
-                                    if (status === 'passed')
-                                        passed++;
-                                    if (status === 'failed')
-                                        failed++;
-                                    testResults.push({
-                                        testCaseId: spec.title || '',
-                                        title: spec.title || '',
-                                        status,
-                                        error: result.error?.message?.slice(0, 500),
-                                        duration: result.duration || 0,
-                                    });
-                                }
+                    for (const suite of suites ?? []) {
+                        for (const spec of suite.specs ?? []) {
+                            const ok = spec.tests?.every((t) => t.results?.every((r) => r.status === 'passed'));
+                            const title = spec.title ?? suite.title ?? 'unknown';
+                            if (ok) {
+                                results[title] = 'passed';
+                                passed++;
+                            }
+                            else {
+                                results[title] = 'failed';
+                                failed++;
+                                const errMsg = spec.tests?.[0]?.results?.[0]?.error?.message ?? 'Test failed';
+                                errors[title] = errMsg.split('\n')[0].slice(0, 300);
                             }
                         }
                         if (suite.suites)
                             walkSuites(suite.suites);
                     }
                 };
-                walkSuites(json.suites || []);
-                resolve({ passed, failed, testResults });
+                walkSuites(json.suites ?? []);
+                resolve({ passed, failed, results, errors });
             }
             catch {
-                resolve({ passed: 0, failed: 0, testResults: [] });
+                resolve({ passed: 0, failed: 0, results: {}, errors: {} });
             }
         });
-        proc.on('error', () => resolve({ passed: 0, failed: 0, testResults: [] }));
+        proc.on('error', () => resolve({ passed: 0, failed: 0, results: {}, errors: {} }));
     });
 }
 // ─── Prompt builders ──────────────────────────────────────────────────────────
@@ -392,92 +418,64 @@ function buildMapUnmappedPrompt(modules, features) {
         ...unmapped,
     ].join('\n');
 }
-// ─── E2E prompt builders ────────────────────────────────────────────────────
-function buildE2ePlanPrompt(feat, modules, projectRoot) {
-    const srcFiles = modules
+function buildE2ePlanPrompt(feat, modules) {
+    const files = modules
         .filter(m => m.featureKeys.includes(feat.key) && m.type !== 'test' && !m.isInfra)
         .map(m => '- ' + m.relativePath.replace(/\\/g, '/'));
-    const pageFiles = modules
-        .filter(m => m.featureKeys.includes(feat.key) &&
-        (/page\./i.test(m.name) || /route/i.test(m.name) || /\/(pages|app)\//i.test(m.relativePath)))
-        .map(m => '- ' + m.relativePath.replace(/\\/g, '/'));
-    const pwConfigExists = fs.existsSync(path.join(projectRoot, 'playwright.config.ts')) ||
-        fs.existsSync(path.join(projectRoot, 'playwright.config.js'));
     return [
-        `Создай план E2E-тестов для фичи "${feat.label}".`,
-        ``,
-        `Прочитай исходный код фичи чтобы понять UI: формы, кнопки, навигацию, состояния, API-вызовы.`,
+        `Ты — QA-инженер. Проанализируй исходный код фичи "${feat.label}" и составь подробный план E2E-тестирования.`,
         ``,
-        `Исходные файлы фичи (${srcFiles.length}):`,
-        ...srcFiles,
+        `Файлы фичи:`,
+        ...files,
         ``,
-        pageFiles.length > 0 ? `Страницы/роуты:\n${pageFiles.join('\n')}` : '',
+        `Прочитай эти файлы, изучи UI: формы, кнопки, навигацию, бизнес-логику.`,
         ``,
-        `Важно:`,
-        `- Каждый тест-кейс должен проверять один пользовательский сценарий`,
-        `- Включи happy path, edge cases, ошибки валидации`,
-        `- Steps должны быть конкретными: укажи селекторы, URL, текст кнопок из реального кода`,
-        `- id тест-кейса: ${feat.key}-<scenario>-NN (например: ${feat.key}-login-01)`,
-        ``,
-        `Ответ верни СТРОГО в формате JSON (без markdown-блоков, без комментариев, чистый JSON):`,
+        `Верни ТОЛЬКО валидный JSON без markdown-блоков в формате:`,
         `{`,
         `  "baseUrl": "http://localhost:3000",`,
         `  "testCases": [`,
         `    {`,
-        `      "id": "${feat.key}-example-01",`,
-        `      "name": "Описание сценария на английском",`,
-        `      "description": "Что проверяет этот тест",`,
-        `      "steps": [`,
-        `        "Navigate to /path",`,
-        `        "Fill [data-testid=email] with test@example.com",`,
-        `        "Click button:has-text('Submit')"`,
-        `      ],`,
-        `      "expectedResults": [`,
-        `        "URL changes to /dashboard",`,
-        `        "Text 'Welcome' is visible"`,
-        `      ]`,
+        `      "id": "feature-key-01",`,
+        `      "name": "Краткое название теста",`,
+        `      "description": "Что проверяет тест",`,
+        `      "steps": ["Шаг 1", "Шаг 2", "Шаг 3"],`,
+        `      "expectedResults": ["Ожидаемый результат 1", "Ожидаемый результат 2"]`,
         `    }`,
         `  ]`,
         `}`,
         ``,
-        `Генерируй 5–15 тест-кейсов, покрывающих все основные сценарии фичи.`,
-        !pwConfigExists ? `\n⚠️ playwright.config.ts не найден — его нужно будет создать перед написанием тестов.` : '',
-    ].filter(Boolean).join('\n');
+        `Требования:`,
+        `- 5-15 тест-кейсов, покрывающих основные сценарии`,
+        `- Каждый кейс: happy path, edge cases, обработка ошибок`,
+        `- id: строчные буквы и цифры через дефис, уникальный`,
+        `- Только JSON, без объяснений`,
+    ].join('\n');
 }
 function buildWriteE2eTestPrompt(feat, plan, modules) {
     const approvedCases = plan.testCases.filter(tc => tc.status === 'approved');
     const existingE2e = modules
-        .filter(m => m.testType === 'e2e' && m.featureKeys.includes(feat.key))
+        .filter(m => m.featureKeys.includes(feat.key) && m.type === 'e2e')
         .map(m => '- ' + m.relativePath.replace(/\\/g, '/'));
     return [
-        `Напиши Playwright E2E-тесты для фичи "${feat.label}".`,
-        `Base URL: ${plan.baseUrl || 'http://localhost:3000'}`,
-        ``,
-        `Утверждённые тест-кейсы (${approvedCases.length}):`,
+        `Напиши Playwright E2E тесты для фичи "${feat.label}".`,
         ``,
-        ...approvedCases.map((tc, i) => [
-            `### ${i + 1}. ${tc.name} (id: ${tc.id})`,
-            `Описание: ${tc.description}`,
-            `Шаги:`,
-            ...tc.steps.map((s, j) => `  ${j + 1}. ${s}`),
-            `Ожидаемый результат:`,
-            ...tc.expectedResults.map(r => `  - ${r}`),
-            ``,
+        `Approved тест-кейсы (${approvedCases.length}):`,
+        ...approvedCases.map(tc => [
+            `### ${tc.name} (id: ${tc.id})`,
+            `${tc.description}`,
+            `Шаги: ${tc.steps.join(' → ')}`,
+            `Ожидается: ${tc.expectedResults.join('; ')}`,
         ].join('\n')),
         ``,
-        existingE2e.length > 0
-            ? `Существующие E2E тесты (следуй этим паттернам):\n${existingE2e.join('\n')}`
-            : 'Существующих E2E тестов пока нет.',
+        existingE2e.length > 0 ? `Существующие E2E тесты (следуй паттернам):\n${existingE2e.join('\n')}` : '',
         ``,
         `Требования:`,
-        `- Используй Playwright: import { test, expect } from '@playwright/test'`,
-        `- Файлы создавай в e2e/${feat.key}/ директории`,
-        `- Каждый тест-кейс — отдельный test() блок`,
-        `- Добавляй скриншоты после ключевых шагов:`,
-        `  await page.screenshot({ path: '.viberadar/e2e-screenshots/${feat.key}/<test-id>/step-N.png' })`,
-        `- Используй data-testid селекторы где возможно`,
-        `- Добавь page.waitForLoadState() и другие ожидания`,
-        `- Не изменяй существующие тесты`,
+        `- Создай файлы в директории e2e/${feat.key}/`,
+        `- Используй @playwright/test`,
+        `- baseUrl: ${plan.baseUrl || 'http://localhost:3000'}`,
+        `- После ключевых шагов добавь скриншоты: await page.screenshot({ path: '.viberadar/e2e-screenshots/${feat.key}/<testCaseId>/step-N.png' })`,
+        `- Группируй по test case id (один файл на кейс или несколько кейсов в одном файле)`,
+        `- Следуй существующим паттернам проекта`,
     ].filter(Boolean).join('\n');
 }
 // ─── Coverage provider auto-install ──────────────────────────────────────────
@@ -705,27 +703,18 @@ function startServer({ data: initialData, port, projectRoot }) {
                     broadcast('agent-error', { message: `Фича не найдена: ${featureKey}` });
                     return;
                 }
-                prompt = buildE2ePlanPrompt(feat, currentData.modules, projectRoot);
+                prompt = buildE2ePlanPrompt(feat, currentData.modules);
                 title = `${agentLabel} — E2E план для "${feat.label}"`;
             }
             else if (task === 'write-e2e-tests') {
                 const feat = currentData.features?.find(f => f.key === featureKey);
-                if (!feat) {
-                    broadcast('agent-error', { message: `Фича не найдена: ${featureKey}` });
-                    return;
-                }
-                const plan = loadE2ePlan(projectRoot, feat.key);
-                if (!plan) {
-                    broadcast('agent-error', { message: `E2E план не найден для "${feat.label}". Сначала сгенерируй план.` });
-                    return;
-                }
-                const approved = plan.testCases.filter(tc => tc.status === 'approved');
-                if (approved.length === 0) {
-                    broadcast('agent-error', { message: `Нет одобренных тест-кейсов в плане "${feat.label}"` });
+                const plan = featureKey ? loadE2ePlan(projectRoot, featureKey) : null;
+                if (!feat || !plan) {
+                    broadcast('agent-error', { message: `Фича или план не найдены: ${featureKey}` });
                     return;
                 }
                 prompt = buildWriteE2eTestPrompt(feat, plan, currentData.modules);
-                title = `${agentLabel} — E2E тесты для "${feat.label}" (${approved.length} кейсов)`;
+                title = `${agentLabel} — пишу E2E тесты для "${feat.label}"`;
             }
             else {
                 prompt = buildMapUnmappedPrompt(currentData.modules, currentData.features || []);
@@ -754,7 +743,7 @@ function startServer({ data: initialData, port, projectRoot }) {
             broadcast('agent-output', { line: `📄 Задача записана в .viberadar/task.md` });
             // Track test files written/edited by agent (for auto-run after)
             const createdTestFiles = [];
-            // Accumulate full result text from agent (for JSON plan parsing)
+            // Accumulate full result text for E2E plan parsing
             let agentResultText = '';
             function trackWrittenFiles(raw) {
                 try {
@@ -786,11 +775,10 @@ function startServer({ data: initialData, port, projectRoot }) {
                     return;
                 }
                 if (parsed.startsWith('§RESULT§')) {
-                    const resultBody = parsed.slice('§RESULT§'.length);
-                    agentResultText += resultBody + '\n';
                     // Full result summary — split into lines and prefix with indent
+                    agentResultText = parsed.slice('§RESULT§'.length).trim();
                     broadcast('agent-output', { line: '─────────────────────────────' });
-                    for (const l of resultBody.split('\n')) {
+                    for (const l of agentResultText.split('\n')) {
                         if (l.trim())
                             broadcast('agent-output', { line: '  ' + l });
                     }
@@ -843,61 +831,36 @@ function startServer({ data: initialData, port, projectRoot }) {
                         }
                         broadcast('agent-summary', result);
                     }
-                    // ── E2E plan post-processing ─────────────────────────────────────
+                    // E2E plan post-processing
                     if (task === 'generate-e2e-plan' && featureKey) {
-                        const feat = currentData.features?.find(f => f.key === featureKey);
                         try {
-                            // Extract JSON from agent result text
                             const jsonMatch = agentResultText.match(/\{[\s\S]*"testCases"[\s\S]*\}/);
-                            if (jsonMatch) {
-                                const parsed = JSON.parse(jsonMatch[0]);
-                                const plan = {
-                                    featureKey,
-                                    featureLabel: feat?.label || featureKey,
-                                    generatedAt: new Date().toISOString(),
-                                    updatedAt: new Date().toISOString(),
-                                    baseUrl: parsed.baseUrl || 'http://localhost:3000',
-                                    testCases: (parsed.testCases || []).map((tc) => ({
-                                        id: tc.id || `${featureKey}-${Math.random().toString(36).slice(2, 6)}`,
-                                        name: tc.name || 'Unnamed test',
-                                        description: tc.description || '',
-                                        steps: tc.steps || [],
-                                        expectedResults: tc.expectedResults || [],
-                                        status: 'pending',
-                                    })),
-                                };
-                                saveE2ePlan(projectRoot, plan);
-                                broadcast('e2e-plan-ready', { featureKey, plan: plan });
-                                broadcast('agent-output', { line: `✅ E2E план сохранён: ${plan.testCases.length} тест-кейсов` });
-                            }
-                            else {
-                                broadcast('e2e-plan-error', { featureKey, message: 'Не удалось извлечь JSON из ответа агента' });
-                                broadcast('agent-output', { line: '❌ Не удалось распарсить JSON план из ответа', isError: true });
-                            }
+                            const parsed = JSON.parse(jsonMatch ? jsonMatch[0] : agentResultText);
+                            const feat = currentData.features?.find(f => f.key === featureKey);
+                            const plan = {
+                                featureKey,
+                                featureLabel: feat?.label || featureKey,
+                                generatedAt: new Date().toISOString(),
+                                updatedAt: new Date().toISOString(),
+                                baseUrl: parsed.baseUrl,
+                                testCases: (parsed.testCases || []).map((tc) => ({ ...tc, status: 'pending' })),
+                            };
+                            saveE2ePlan(projectRoot, plan);
+                            broadcast('e2e-plan-ready', { featureKey, plan });
                         }
                         catch (err) {
-                            broadcast('e2e-plan-error', { featureKey, message: err.message });
-                            broadcast('agent-output', { line: `❌ Ошибка парсинга плана: ${err.message}`, isError: true });
+                            broadcast('e2e-plan-error', { featureKey, message: `Не удалось распарсить план: ${err.message}` });
                         }
                     }
                     if (task === 'write-e2e-tests' && featureKey) {
-                        // Update plan: mark approved test cases as 'written' and set file paths
                         const plan = loadE2ePlan(projectRoot, featureKey);
                         if (plan) {
                             for (const tc of plan.testCases) {
-                                if (tc.status === 'approved') {
+                                if (tc.status === 'approved')
                                     tc.status = 'written';
-                                    // Try to match created test files to test cases
-                                    const matchingFile = createdTestFiles.find(fp => fp.replace(/\\/g, '/').includes(tc.id) ||
-                                        fp.replace(/\\/g, '/').includes(featureKey));
-                                    if (matchingFile) {
-                                        tc.testFilePath = path.relative(projectRoot, matchingFile).replace(/\\/g, '/');
-                                    }
-                                }
                             }
                             saveE2ePlan(projectRoot, plan);
-                            broadcast('e2e-plan-ready', { featureKey, plan: plan });
-                            broadcast('agent-output', { line: `✅ E2E план обновлён: тесты отмечены как написанные` });
+                            broadcast('e2e-tests-written', { featureKey, files: createdTestFiles });
                         }
                     }
                     process.stdout.write('   ✅ Agent done, rescanning...\n');
@@ -951,13 +914,13 @@ function startServer({ data: initialData, port, projectRoot }) {
                     testErrors[rel] = detail;
                 }
                 // Check which features have E2E plans
-                const e2ePlansExist = [];
-                const plansDir = e2ePlanDir(projectRoot);
+                const e2ePlansExist = {};
                 try {
-                    if (fs.existsSync(plansDir)) {
-                        for (const f of fs.readdirSync(plansDir)) {
+                    const planDir = e2ePlanDir(projectRoot);
+                    if (fs.existsSync(planDir)) {
+                        for (const f of fs.readdirSync(planDir)) {
                             if (f.endsWith('.json'))
-                                e2ePlansExist.push(f.replace('.json', ''));
+                                e2ePlansExist[f.replace('.json', '')] = true;
                         }
                     }
                 }
@@ -1025,7 +988,7 @@ function startServer({ data: initialData, port, projectRoot }) {
                                     }
                                 }
                             }
-                            broadcast('agent-output', { line: '  → Нажми 🔧 исправить рядом с файлом чтобы агент починил' });
+                            broadcast('agent-output', { line: '  → Нажми Починить рядом с файлом чтобы агент исправил' });
                         }
                         // Send testErrors directly in event — avoids path/timing issues with /api/data fetch
                         const testErrorsForClient = {};
@@ -1033,6 +996,11 @@ function startServer({ data: initialData, port, projectRoot }) {
                             const rel = path.relative(projectRoot, fp).replace(/\\/g, '/');
                             testErrorsForClient[rel] = detail;
                         }
+                        const errKeys = Object.keys(testErrorsForClient);
+                        process.stdout.write(`   🔍 testErrors to client: ${errKeys.length} keys: ${errKeys.slice(0, 3).join(', ')}\n`);
+                        if (result.failed > 0 && errKeys.length === 0) {
+                            broadcast('agent-output', { line: `⚠️ Есть ${result.failed} упавших теста, но детали по файлам не получены — проверь viberadar лог`, isDim: true });
+                        }
                         broadcast('tests-done', { passed: result.passed, failed: result.failed, testErrors: testErrorsForClient });
                     }
                     catch (err) {
@@ -1091,7 +1059,19 @@ function startServer({ data: initialData, port, projectRoot }) {
                 });
                 return;
             }
-            // ── E2E Plan API ──────────────────────────────────────────────────────────
+            // Server-Sent Events endpoint
+            if (url === '/api/events') {
+                res.writeHead(200, {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    'Connection': 'keep-alive',
+                });
+                res.write('data: connected\n\n');
+                sseClients.add(res);
+                req.on('close', () => sseClients.delete(res));
+                return;
+            }
+            // ── E2E routes ─────────────────────────────────────────────────────────
             if (url === '/api/e2e/generate-plan' && req.method === 'POST') {
                 let body = '';
                 req.on('data', d => body += d);
@@ -1110,18 +1090,17 @@ function startServer({ data: initialData, port, projectRoot }) {
                 });
                 return;
             }
-            // GET /api/e2e/plan/<featureKey>
-            if (url.startsWith('/api/e2e/plan/') && req.method === 'GET') {
-                const featureKey = decodeURIComponent(url.slice('/api/e2e/plan/'.length));
+            const planMatch = url.match(/^\/api\/e2e\/plan\/(.+)$/);
+            if (planMatch && req.method === 'GET') {
+                const featureKey = decodeURIComponent(planMatch[1]);
                 const plan = loadE2ePlan(projectRoot, featureKey);
-                if (plan) {
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify(plan));
-                }
-                else {
-                    res.writeHead(404, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'not found' }));
+                if (!plan) {
+                    res.writeHead(404);
+                    res.end(JSON.stringify({ error: 'Plan not found' }));
+                    return;
                 }
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(plan));
                 return;
             }
             if (url === '/api/e2e/review' && req.method === 'POST') {
@@ -1137,12 +1116,8 @@ function startServer({ data: initialData, port, projectRoot }) {
                             return;
                         }
                         const tc = plan.testCases.find(t => t.id === testCaseId);
-                        if (!tc) {
-                            res.writeHead(404);
-                            res.end(JSON.stringify({ error: 'Test case not found' }));
-                            return;
-                        }
-                        tc.status = status;
+                        if (tc)
+                            tc.status = status;
                         saveE2ePlan(projectRoot, plan);
                         res.writeHead(200, { 'Content-Type': 'application/json' });
                         res.end(JSON.stringify({ ok: true, plan }));
@@ -1166,10 +1141,8 @@ function startServer({ data: initialData, port, projectRoot }) {
                             res.end(JSON.stringify({ error: 'Plan not found' }));
                             return;
                         }
-                        for (const tc of plan.testCases) {
-                            if (tc.status === 'pending')
-                                tc.status = status;
-                        }
+                        for (const tc of plan.testCases)
+                            tc.status = status;
                         saveE2ePlan(projectRoot, plan);
                         res.writeHead(200, { 'Content-Type': 'application/json' });
                         res.end(JSON.stringify({ ok: true, plan }));
@@ -1211,58 +1184,26 @@ function startServer({ data: initialData, port, projectRoot }) {
                             res.end(JSON.stringify({ error: 'Plan not found' }));
                             return;
                         }
-                        // Collect test files from plan (written/passed/failed)
-                        const testFiles = plan.testCases
-                            .filter(tc => ['written', 'passed', 'failed'].includes(tc.status) && tc.testFilePath)
-                            .map(tc => tc.testFilePath);
-                        // Also scan e2e/<featureKey>/ for any test files
-                        const e2eDir = path.join(projectRoot, 'e2e', featureKey);
-                        if (fs.existsSync(e2eDir)) {
-                            for (const f of fs.readdirSync(e2eDir)) {
-                                if (/\.(spec|test)\.(ts|js)$/.test(f)) {
-                                    const relPath = `e2e/${featureKey}/${f}`;
-                                    if (!testFiles.includes(relPath))
-                                        testFiles.push(relPath);
-                                }
-                            }
-                        }
-                        if (testFiles.length === 0) {
-                            res.writeHead(200, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ ok: true, count: 0 }));
-                            broadcast('agent-output', { line: 'Нет E2E тест-файлов для запуска' });
-                            return;
-                        }
+                        const writtenCases = plan.testCases.filter(tc => ['written', 'passed', 'failed'].includes(tc.status));
+                        const testFiles = writtenCases
+                            .map(tc => tc.testFilePath)
+                            .filter((f) => !!f)
+                            .map(f => path.isAbsolute(f) ? f : path.join(projectRoot, f));
                         res.writeHead(200, { 'Content-Type': 'application/json' });
                         res.end(JSON.stringify({ ok: true, count: testFiles.length }));
                         broadcast('e2e-tests-running', { featureKey, count: testFiles.length });
-                        broadcast('agent-output', { line: `🎭 Запускаю E2E тесты (${testFiles.length} файлов)…` });
-                        const result = await runPlaywrightTests(testFiles, projectRoot);
-                        // Collect screenshots
-                        const screenshots = collectScreenshots(projectRoot, featureKey);
+                        const result = await runPlaywrightTests(testFiles.length > 0 ? testFiles : [`e2e/${featureKey}`], projectRoot);
                         // Update plan with results
                         for (const tc of plan.testCases) {
-                            if (!['written', 'passed', 'failed'].includes(tc.status))
-                                continue;
-                            const matching = result.testResults.find(r => r.title.toLowerCase().includes(tc.id.toLowerCase()) ||
-                                tc.name.toLowerCase().includes(r.title.toLowerCase()) ||
-                                r.title.toLowerCase().includes(tc.name.toLowerCase()));
-                            if (matching) {
-                                tc.status = matching.status === 'passed' ? 'passed' : 'failed';
-                                tc.lastError = matching.error;
+                            if (result.results[tc.name]) {
+                                tc.status = result.results[tc.name];
+                                if (result.errors[tc.name])
+                                    tc.lastError = result.errors[tc.name];
                             }
-                            tc.screenshotPaths = screenshots.get(tc.id) || [];
+                            tc.screenshotPaths = collectScreenshots(projectRoot, featureKey, tc.id);
                         }
                         saveE2ePlan(projectRoot, plan);
-                        const summary = result.failed === 0
-                            ? `✅ E2E: все ${result.passed} тестов прошли`
-                            : `⚠️ E2E: ${result.passed} passed, ${result.failed} failed`;
-                        broadcast('agent-output', { line: summary });
-                        broadcast('e2e-tests-done', {
-                            featureKey,
-                            passed: result.passed,
-                            failed: result.failed,
-                            plan: plan,
-                        });
+                        broadcast('e2e-tests-done', { featureKey, passed: result.passed, failed: result.failed, plan });
                     }
                     catch (err) {
                         res.writeHead(400);
@@ -1271,42 +1212,29 @@ function startServer({ data: initialData, port, projectRoot }) {
                 });
                 return;
             }
-            // Serve E2E screenshots
-            if (url.startsWith('/api/e2e/screenshot/')) {
+            if (url.startsWith('/api/e2e/screenshot/') && req.method === 'GET') {
                 const relPath = decodeURIComponent(url.slice('/api/e2e/screenshot/'.length));
-                const filePath = path.join(projectRoot, '.viberadar', 'e2e-screenshots', relPath);
-                // Security: prevent path traversal
-                const resolved = path.resolve(filePath);
-                const screenshotsRoot = path.resolve(path.join(projectRoot, '.viberadar', 'e2e-screenshots'));
-                if (!resolved.startsWith(screenshotsRoot)) {
+                // Path traversal protection
+                const screenshotBase = path.join(projectRoot, '.viberadar', 'e2e-screenshots');
+                const safePath = path.resolve(screenshotBase, relPath);
+                if (!safePath.startsWith(screenshotBase)) {
                     res.writeHead(403);
                     res.end('Forbidden');
                     return;
                 }
-                if (fs.existsSync(filePath)) {
-                    const ext = path.extname(filePath).toLowerCase();
-                    const mime = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.webp': 'image/webp' };
-                    res.writeHead(200, { 'Content-Type': mime[ext] || 'image/png' });
-                    fs.createReadStream(filePath).pipe(res);
+                try {
+                    const img = fs.readFileSync(safePath);
+                    const ext = path.extname(safePath).toLowerCase();
+                    const mime = ext === '.png' ? 'image/png' : ext === '.jpg' || ext === '.jpeg' ? 'image/jpeg' : 'image/webp';
+                    res.writeHead(200, { 'Content-Type': mime });
+                    res.end(img);
                 }
-                else {
+                catch {
                     res.writeHead(404);
-                    res.end('Screenshot not found');
+                    res.end('Not found');
                 }
                 return;
             }
-            // Server-Sent Events endpoint
-            if (url === '/api/events') {
-                res.writeHead(200, {
-                    'Content-Type': 'text/event-stream',
-                    'Cache-Control': 'no-cache',
-                    'Connection': 'keep-alive',
-                });
-                res.write('data: connected\n\n');
-                sseClients.add(res);
-                req.on('close', () => sseClients.delete(res));
-                return;
-            }
             res.writeHead(404);
             res.end('Not found');
         });