viberadar 0.3.46 → 0.3.48

package/dist/server/index.js

@@ -52,21 +52,22 @@ const WIN = process.platform === 'win32';
  * --output-format stream-json gives real-time events (tool calls, writes, etc.)
  * File piping avoids TUI mode in Claude Code v2+.
  */
-function buildAgentShellCmd(agent, taskFile) {
+function buildAgentShellCmd(agent, taskFile, model) {
     const escaped = taskFile.replace(/\\/g, '\\\\');
+    const modelFlag = (agent === 'claude' && model) ? ` --model ${model}` : '';
     if (WIN) {
         if (agent === 'claude')
-            return `type "${escaped}" | claude.cmd --print --verbose --output-format stream-json`;
+            return `type "${escaped}" | claude.cmd --print --verbose --output-format stream-json${modelFlag}`;
         if (agent === 'codex')
-            return `type "${escaped}" | codex.cmd`;
+            return `type "${escaped}" | codex.cmd exec - --color never --sandbox workspace-write`;
     }
     else {
         if (agent === 'claude')
-            return `claude --print --verbose --output-format stream-json < "${escaped}"`;
+            return `claude --print --verbose --output-format stream-json${modelFlag} < "${escaped}"`;
         if (agent === 'codex')
-            return `codex < "${escaped}"`;
+            return `codex exec - --color never --sandbox workspace-write < "${escaped}"`;
     }
-    return `claude --print --verbose --output-format stream-json < "${escaped}"`;
+    return `claude --print --verbose --output-format stream-json${modelFlag} < "${escaped}"`;
 }
 /** Parse a Claude Code stream-json event into a human-readable line, or null to skip */
 function parseClaudeEvent(raw) {
@@ -123,6 +124,84 @@ function fmtTool(name, input = {}) {
         default: return `🔧 ${name}${fp ? ': ' + fp : ''}`;
     }
 }
+// ─── Test runner after agent ──────────────────────────────────────────────────
+const TEST_FILE_RE = /\.(test|spec)\.(ts|tsx|js|jsx)$/;
+function runTestFiles(files, projectRoot) {
+    return new Promise((resolve) => {
+        // 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.on('close', () => {
+            try {
+                // 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 assertions) {
+                        if (ar.status === 'failed') {
+                            errors.push({
+                                testName: ar.fullName ?? ar.title ?? 'unknown',
+                                message: (ar.failureMessages?.[0] ?? ar.errors?.[0]?.message ?? '').split('\n')[0].slice(0, 300),
+                            });
+                        }
+                    }
+                    fileDetails[fp] = {
+                        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,
+                    files,
+                    fileDetails,
+                });
+            }
+            catch (err) {
+                process.stdout.write(`   ❌ runTestFiles parse error: ${err.message}\n`);
+                resolve({ passed: 0, failed: files.length, files, fileDetails: {}, runError: err.message });
+            }
+        });
+        proc.on('error', (err) => resolve({ passed: 0, failed: files.length, files, fileDetails: {}, runError: err.message }));
+    });
+}
+// ─── E2E plan storage ─────────────────────────────────────────────────────────
 function e2ePlanDir(projectRoot) {
     return path.join(projectRoot, '.viberadar', 'e2e-plans');
 }
@@ -130,9 +209,11 @@ 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'));
+        const p = e2ePlanPath(projectRoot, featureKey);
+        if (!fs.existsSync(p))
+            return null;
+        return JSON.parse(fs.readFileSync(p, 'utf-8'));
     }
     catch {
         return null;
@@ -147,24 +228,19 @@ function saveE2ePlan(projectRoot, plan) {
 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;
+function collectScreenshots(projectRoot, featureKey, testCaseId) {
+    const dir = path.join(e2eScreenshotDir(projectRoot, featureKey), testCaseId);
     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);
-        }
+        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 [];
     }
-    catch { }
-    return result;
 }
 function hasPlaywright(projectRoot) {
     try {
@@ -176,96 +252,47 @@ function hasPlaywright(projectRoot) {
         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' });
-        let stdout = '';
-        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);
-                // Extract per-file failure details
-                const fileDetails = {};
-                for (const tr of (json.testResults ?? [])) {
-                    const fp = tr.testFilePath ?? '';
-                    const errors = [];
-                    for (const ar of (tr.assertionResults ?? [])) {
-                        if (ar.status === 'failed') {
-                            errors.push({
-                                testName: ar.fullName ?? ar.title ?? 'unknown',
-                                message: (ar.failureMessages?.[0] ?? '').split('\n')[0].slice(0, 300),
-                            });
-                        }
-                    }
-                    fileDetails[fp] = {
-                        passed: (tr.assertionResults ?? []).filter((a) => a.status === 'passed').length,
-                        failed: errors.length,
-                        errors,
-                    };
-                }
-                resolve({
-                    passed: json.numPassedTests ?? 0,
-                    failed: json.numFailedTests ?? 0,
-                    files,
-                    fileDetails,
-                });
-            }
-            catch {
-                resolve({ passed: 0, failed: 0, files, fileDetails: {} });
-            }
-        });
-        proc.on('error', () => resolve({ passed: 0, failed: 0, files, fileDetails: {} }));
-    });
-}
+// ─── 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 ──────────────────────────────────────────────────────────
@@ -371,6 +398,28 @@ function buildFixTestsPrompt(filePath, errors) {
         `- После исправления запусти тест, чтобы убедиться что он проходит`,
     ].join('\n');
 }
+function buildFixAllTestsPrompt(failedFiles, testType) {
+    const totalErrors = failedFiles.reduce((sum, f) => sum + f.errors.length, 0);
+    const fileBlocks = failedFiles.map(f => {
+        const normalPath = f.filePath.replace(/\\/g, '/');
+        return [
+            `### \`${normalPath}\` (${f.errors.length} упало):`,
+            ...f.errors.map(e => `• "${e.testName}"\n  ${e.message}`),
+        ].join('\n');
+    });
+    return [
+        `Исправь все падающие ${testType} тесты (${totalErrors} тестов в ${failedFiles.length} файлах).`,
+        ``,
+        ...fileBlocks,
+        ``,
+        `Требования:`,
+        `- Исправь только падающие тесты, не трогай проходящие`,
+        `- Не удаляй тесты — исправь логику или моки`,
+        `- Если тест проверяет несуществующее поведение — адаптируй под реальное поведение кода`,
+        `- Если ошибка в исходном коде, а не в тесте — исправь код`,
+        `- После исправления каждого файла запусти его тесты, чтобы убедиться что проходят`,
+    ].join('\n');
+}
 function buildMapUnmappedPrompt(modules, features) {
     const unmapped = modules
         .filter(m => m.type !== 'test' && !m.isInfra && (!m.featureKeys || m.featureKeys.length === 0))
@@ -392,92 +441,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-вызовы.`,
-        ``,
-        `Исходные файлы фичи (${srcFiles.length}):`,
-        ...srcFiles,
+        `Ты — QA-инженер. Проанализируй исходный код фичи "${feat.label}" и составь подробный план E2E-тестирования.`,
         ``,
-        pageFiles.length > 0 ? `Страницы/роуты:\n${pageFiles.join('\n')}` : '',
+        `Файлы фичи:`,
+        ...files,
         ``,
-        `Важно:`,
-        `- Каждый тест-кейс должен проверять один пользовательский сценарий`,
-        `- Включи happy path, edge cases, ошибки валидации`,
-        `- Steps должны быть конкретными: укажи селекторы, URL, текст кнопок из реального кода`,
-        `- id тест-кейса: ${feat.key}-<scenario>-NN (например: ${feat.key}-login-01)`,
+        `Прочитай эти файлы, изучи UI: формы, кнопки, навигацию, бизнес-логику.`,
         ``,
-        `Ответ верни СТРОГО в формате 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'}`,
+        `Напиши Playwright E2E тесты для фичи "${feat.label}".`,
         ``,
-        `Утверждённые тест-кейсы (${approvedCases.length}):`,
-        ``,
-        ...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 ──────────────────────────────────────────
@@ -546,6 +567,7 @@ function startServer({ data: initialData, port, projectRoot }) {
         let coverageError = false;
         let agentRunning = false;
         let testsRunning = false;
+        const agentQueue = [];
         // Keyed by absolute file path → per-file failure details from last test run
         const lastTestResults = new Map();
         // ── SSE clients ────────────────────────────────────────────────────────────
@@ -644,95 +666,88 @@ function startServer({ data: initialData, port, projectRoot }) {
             });
         }
         // ── Agent runner ───────────────────────────────────────────────────────────
-        function runAgent(task, featureKey, filePath) {
-            if (agentRunning) {
-                process.stdout.write('   ⏳ Agent already running\n');
-                return;
+        /** Execute next queued item, or broadcast agent-done if queue is empty */
+        function processNextInQueue() {
+            if (agentQueue.length > 0) {
+                const next = agentQueue.shift();
+                process.stdout.write(`   📋 Starting next from queue: "${next.title}" (remaining: ${agentQueue.length})\n`);
+                broadcast('agent-output', { line: `📋 Следующая задача из очереди: ${next.title}` });
+                broadcast('agent-output', { line: `   В очереди осталось: ${agentQueue.length}` });
+                executeAgentItem(next);
             }
-            const agent = currentData.agent;
-            if (!agent) {
-                broadcast('agent-error', { message: 'Агент не выбран. Укажи agent в viberadar.config.json' });
-                return;
+            else {
+                broadcast('agent-done', { queueLength: 0 });
             }
-            // Build prompt
+        }
+        /** Actually spawn the agent process for a queue item */
+        function executeAgentItem(item) {
+            const { task, featureKey, filePath, title, agent, savedErrors, savedFailedFiles, savedTestType } = item;
+            // Build prompt lazily at execution time
             let prompt;
-            let title;
-            const agentLabel = agent === 'claude' ? 'Claude Code' : 'Codex';
             if (task === 'write-tests') {
                 const feat = currentData.features?.find(f => f.key === featureKey);
                 if (!feat) {
                     broadcast('agent-error', { message: `Фича не найдена: ${featureKey}` });
+                    agentRunning = false;
+                    processNextInQueue();
                     return;
                 }
                 prompt = buildWriteTestsPrompt(feat, currentData.modules, currentData.testRunner || 'vitest');
-                title = `${agentLabel} — тесты для "${feat.label}"`;
             }
             else if (task === 'write-tests-file') {
                 const feat = currentData.features?.find(f => f.key === featureKey);
                 if (!feat || !filePath) {
-                    broadcast('agent-error', { message: `Не указана фича или файл` });
+                    broadcast('agent-error', { message: 'Не указана фича или файл' });
+                    agentRunning = false;
+                    processNextInQueue();
                     return;
                 }
                 prompt = buildWriteTestsForFilePrompt(filePath, feat, currentData.modules, currentData.testRunner || 'vitest');
-                const fileName = filePath.replace(/\\/g, '/').split('/').pop() || filePath;
-                title = `${agentLabel} — тест для "${fileName}"`;
             }
             else if (task === 'fix-tests') {
-                if (!filePath) {
-                    broadcast('agent-error', { message: 'Не указан файл для исправления' });
+                if (!filePath || !savedErrors || savedErrors.length === 0) {
+                    broadcast('agent-error', { message: `Нет сохранённых ошибок для ${filePath}` });
+                    agentRunning = false;
+                    processNextInQueue();
                     return;
                 }
-                // Look up stored errors for this file (match by absolute or relative path)
-                let storedErrors;
-                for (const [fp, detail] of lastTestResults) {
-                    const rel = path.relative(projectRoot, fp).replace(/\\/g, '/');
-                    if (rel === filePath.replace(/\\/g, '/') || fp === filePath) {
-                        storedErrors = detail.errors;
-                        break;
-                    }
-                }
-                if (!storedErrors || storedErrors.length === 0) {
-                    broadcast('agent-error', { message: `Нет сохранённых ошибок для ${filePath}. Сначала запусти тесты.` });
+                prompt = buildFixTestsPrompt(filePath, savedErrors);
+            }
+            else if (task === 'fix-tests-all') {
+                if (!savedFailedFiles || savedFailedFiles.length === 0) {
+                    broadcast('agent-error', { message: 'Нет упавших тестов для исправления' });
+                    agentRunning = false;
+                    processNextInQueue();
                     return;
                 }
-                prompt = buildFixTestsPrompt(filePath, storedErrors);
-                const fileName = filePath.replace(/\\/g, '/').split('/').pop() || filePath;
-                title = `${agentLabel} — исправить тесты в "${fileName}"`;
+                prompt = buildFixAllTestsPrompt(savedFailedFiles, savedTestType || 'unit');
             }
             else if (task === 'generate-e2e-plan') {
                 const feat = currentData.features?.find(f => f.key === featureKey);
                 if (!feat) {
                     broadcast('agent-error', { message: `Фича не найдена: ${featureKey}` });
+                    agentRunning = false;
+                    processNextInQueue();
                     return;
                 }
-                prompt = buildE2ePlanPrompt(feat, currentData.modules, projectRoot);
-                title = `${agentLabel} — E2E план для "${feat.label}"`;
+                prompt = buildE2ePlanPrompt(feat, currentData.modules);
             }
             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}` });
+                    agentRunning = false;
+                    processNextInQueue();
                     return;
                 }
                 prompt = buildWriteE2eTestPrompt(feat, plan, currentData.modules);
-                title = `${agentLabel} — E2E тесты для "${feat.label}" (${approved.length} кейсов)`;
             }
             else {
                 prompt = buildMapUnmappedPrompt(currentData.modules, currentData.features || []);
-                title = `${agentLabel} — разобрать unmapped`;
             }
             agentRunning = true;
-            broadcast('agent-started', { title, task, featureKey });
+            broadcast('agent-started', { title, task, featureKey, filePath: filePath || null, queueLength: agentQueue.length });
             process.stdout.write(`   🤖 Running agent (${agent}): ${task}\n`);
             // Write prompt to .viberadar/task.md for reference
             const taskDir = path.join(projectRoot, '.viberadar');
@@ -743,7 +758,7 @@ function startServer({ data: initialData, port, projectRoot }) {
             }
             catch { }
             // Spawn via shell, piping prompt from file (avoids TUI mode, supports stream-json)
-            const shellCmd = buildAgentShellCmd(agent, taskFile);
+            const shellCmd = buildAgentShellCmd(agent, taskFile, currentData.model);
             process.stdout.write(`   🚀 Shell cmd: ${shellCmd}\n`);
             const proc = (0, child_process_1.spawn)(shellCmd, [], {
                 cwd: projectRoot,
@@ -754,7 +769,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 {
@@ -780,17 +795,14 @@ function startServer({ data: initialData, port, projectRoot }) {
                     return;
                 trackWrittenFiles(raw);
                 const parsed = agent === 'claude' ? parseClaudeEvent(raw) : raw;
-                // If parsing returned null (noise), still show raw line dimmed so user knows output is coming
                 if (!parsed) {
                     broadcast('agent-output', { line: raw.slice(0, 120), isDim: true });
                     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 });
                     }
@@ -813,21 +825,32 @@ function startServer({ data: initialData, port, projectRoot }) {
                 agentRunning = false;
                 if (code === 0) {
                     // Auto-run created/fixed test files and show results
-                    const testFilesToRun = task === 'fix-tests' && filePath ? [filePath] : createdTestFiles;
-                    if ((task === 'write-tests' || task === 'write-tests-file' || task === 'fix-tests') && testFilesToRun.length > 0) {
+                    let testFilesToRun;
+                    if (task === 'fix-tests-all') {
+                        testFilesToRun = [...lastTestResults.keys()];
+                    }
+                    else if (task === 'fix-tests' && filePath) {
+                        testFilesToRun = [filePath];
+                    }
+                    else {
+                        testFilesToRun = createdTestFiles;
+                    }
+                    if ((task === 'write-tests' || task === 'write-tests-file' || task === 'fix-tests' || task === 'fix-tests-all') && testFilesToRun.length > 0) {
                         broadcast('agent-output', { line: '─────────────────────────────' });
                         broadcast('agent-output', { line: `🧪 Запускаю тесты (${testFilesToRun.length} файлов)...` });
                         const result = await runTestFiles(testFilesToRun, projectRoot);
-                        // Store per-file results for "fix-tests" feature
-                        // path.resolve() normalizes slashes on Windows (vitest outputs forward slashes)
                         lastTestResults.clear();
                         for (const [fp, detail] of Object.entries(result.fileDetails)) {
                             if (detail.failed > 0)
                                 lastTestResults.set(path.resolve(fp), { failed: detail.failed, errors: detail.errors });
                         }
-                        const summary = result.failed === 0
-                            ? `✅ Все тесты прошли: ${result.passed} passed`
-                            : `⚠️  ${result.passed} passed, ${result.failed} failed`;
+                        const summary = result.runError
+                            ? `❌ Тесты не запустились: ${result.runError}`
+                            : result.failed === 0 && result.passed > 0
+                                ? `✅ Все тесты прошли: ${result.passed} passed`
+                                : result.failed === 0 && result.passed === 0
+                                    ? `⚠️ 0 тестов запустилось — проверь файл на ошибки импорта`
+                                    : `⚠️  ${result.passed} passed, ${result.failed} failed`;
                         broadcast('agent-output', { line: summary });
                         if (result.failed > 0) {
                             for (const [fp, detail] of Object.entries(result.fileDetails)) {
@@ -843,61 +866,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 parsedPlan = 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: parsedPlan.baseUrl,
+                                testCases: (parsedPlan.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');
@@ -906,19 +904,128 @@ function startServer({ data: initialData, port, projectRoot }) {
                         broadcast('data-updated');
                     }
                     catch { }
-                    broadcast('agent-done');
+                    processNextInQueue();
+                }
+                else if (code === 255) {
+                    process.stdout.write(`   ❌ Agent auth error (exit code 255)\n`);
+                    broadcast('agent-error', {
+                        message: `${agent === 'claude' ? 'Claude Code' : 'Codex'} не авторизован. Нажми 🔑 Перелогиниться в меню агента.`,
+                        authRequired: true,
+                        agent,
+                    });
+                    processNextInQueue();
                 }
                 else {
                     process.stdout.write(`   ❌ Agent failed (exit code ${code})\n`);
                     broadcast('agent-error', { message: `Агент завершился с кодом ${code}` });
+                    processNextInQueue();
                 }
             });
             proc.on('error', (err) => {
                 agentRunning = false;
+                const isNotFound = err.code === 'ENOENT' || err.message.includes('ENOENT');
+                const agentName = agent === 'claude' ? 'Claude Code' : 'Codex';
+                const msg = isNotFound
+                    ? `${agentName} не установлен. Скачай с ${agent === 'claude' ? 'claude.ai/download' : 'github.com/openai/codex'}`
+                    : `Не удалось запустить ${agent}: ${err.message}`;
                 process.stdout.write('   ❌ Agent spawn error: ' + err.message + '\n');
-                broadcast('agent-error', { message: `Не удалось запустить ${agent}: ${err.message}` });
+                broadcast('agent-error', { message: msg, notInstalled: isNotFound, agent });
+                processNextInQueue();
             });
         }
+        /** Validate task params and enqueue (prompt is built lazily at execution time) */
+        function runAgent(task, featureKey, filePath) {
+            const agent = currentData.agent;
+            if (!agent) {
+                broadcast('agent-error', { message: 'Агент не выбран. Укажи agent в viberadar.config.json' });
+                return;
+            }
+            const agentLabel = agent === 'claude' ? 'Claude Code' : 'Codex';
+            let title;
+            let savedErrors;
+            let savedFailedFiles;
+            let savedTestType;
+            if (task === 'write-tests') {
+                const feat = currentData.features?.find(f => f.key === featureKey);
+                if (!feat) {
+                    broadcast('agent-error', { message: `Фича не найдена: ${featureKey}` });
+                    return;
+                }
+                title = `${agentLabel} — тесты для "${feat.label}"`;
+            }
+            else if (task === 'write-tests-file') {
+                const feat = currentData.features?.find(f => f.key === featureKey);
+                if (!feat || !filePath) {
+                    broadcast('agent-error', { message: 'Не указана фича или файл' });
+                    return;
+                }
+                const fileName = filePath.replace(/\\/g, '/').split('/').pop() || filePath;
+                title = `${agentLabel} — тест для "${fileName}"`;
+            }
+            else if (task === 'fix-tests') {
+                if (!filePath) {
+                    broadcast('agent-error', { message: 'Не указан файл для исправления' });
+                    return;
+                }
+                for (const [fp, detail] of lastTestResults) {
+                    const rel = path.relative(projectRoot, fp).replace(/\\/g, '/');
+                    if (rel === filePath.replace(/\\/g, '/') || fp === filePath) {
+                        savedErrors = detail.errors;
+                        break;
+                    }
+                }
+                if (!savedErrors || savedErrors.length === 0) {
+                    broadcast('agent-error', { message: `Нет сохранённых ошибок для ${filePath}. Сначала запусти тесты.` });
+                    return;
+                }
+                const fileName = filePath.replace(/\\/g, '/').split('/').pop() || filePath;
+                title = `${agentLabel} — исправить тесты в "${fileName}"`;
+            }
+            else if (task === 'fix-tests-all') {
+                savedTestType = filePath || 'unit'; // filePath param is reused for testType in this case
+                savedFailedFiles = [];
+                for (const [fp, detail] of lastTestResults) {
+                    const rel = path.relative(projectRoot, fp).replace(/\\/g, '/');
+                    const mod = currentData.modules.find(m => m.relativePath.replace(/\\/g, '/') === rel && m.testType === savedTestType);
+                    if (mod && detail.errors.length > 0) {
+                        savedFailedFiles.push({ filePath: rel, errors: detail.errors });
+                    }
+                }
+                if (savedFailedFiles.length === 0) {
+                    broadcast('agent-error', { message: `Нет упавших ${savedTestType} тестов. Сначала запусти тесты.` });
+                    return;
+                }
+                title = `${agentLabel} — починить все ${savedTestType} тесты (${savedFailedFiles.length} файлов)`;
+            }
+            else if (task === 'generate-e2e-plan') {
+                const feat = currentData.features?.find(f => f.key === featureKey);
+                if (!feat) {
+                    broadcast('agent-error', { message: `Фича не найдена: ${featureKey}` });
+                    return;
+                }
+                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;
+                }
+                title = `${agentLabel} — пишу E2E тесты для "${feat.label}"`;
+            }
+            else {
+                title = `${agentLabel} — разобрать unmapped`;
+            }
+            const item = { task, featureKey, filePath, title, agent, savedErrors, savedFailedFiles, savedTestType };
+            if (agentRunning) {
+                agentQueue.push(item);
+                const ql = agentQueue.length;
+                process.stdout.write(`   📋 Agent busy, queued: "${title}" (queue size: ${ql})\n`);
+                broadcast('agent-queued', { queueLength: ql, title, task, featureKey: featureKey || null, filePath: filePath || null });
+                return;
+            }
+            executeAgentItem(item);
+        }
         // ── Chokidar watcher ───────────────────────────────────────────────────────
         chokidar_1.default.watch([
             '**/*.{ts,tsx,js,jsx,vue,svelte}',
@@ -951,13 +1058,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;
                         }
                     }
                 }
@@ -968,7 +1075,7 @@ function startServer({ data: initialData, port, projectRoot }) {
             }
             if (url === '/api/status') {
                 res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ coverageRunning, coverageError, agentRunning }));
+                res.end(JSON.stringify({ coverageRunning, coverageError, agentRunning, queueLength: agentQueue.length }));
                 return;
             }
             if (url === '/api/run-coverage' && req.method === 'POST') {
@@ -1025,7 +1132,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 +1140,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) {
@@ -1065,11 +1177,20 @@ function startServer({ data: initialData, port, projectRoot }) {
             }
             if (url === '/api/cancel-agent' && req.method === 'POST') {
                 agentRunning = false;
-                process.stdout.write('   ⏹ Agent state reset by user\n');
+                agentQueue.length = 0; // clear queue too
+                process.stdout.write('   ⏹ Agent state reset by user (queue cleared)\n');
                 res.writeHead(200, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({ ok: true }));
                 return;
             }
+            if (url === '/api/clear-queue' && req.method === 'POST') {
+                const cleared = agentQueue.length;
+                agentQueue.length = 0;
+                process.stdout.write(`   🗑 Queue cleared (${cleared} items)\n`);
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true, cleared }));
+                return;
+            }
             if (url === '/api/set-agent' && req.method === 'POST') {
                 let body = '';
                 req.on('data', d => body += d);
@@ -1091,7 +1212,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 +1243,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 +1269,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 +1294,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 +1337,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 +1365,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');
         });