viberadar 0.3.45 → 0.3.47

package/dist/server/index.js

@@ -52,22 +52,21 @@ 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, model) {
+function buildAgentShellCmd(agent, taskFile) {
     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${modelFlag}`;
+            return `type "${escaped}" | claude.cmd --print --verbose --output-format stream-json`;
         if (agent === 'codex')
-            return `type "${escaped}" | codex.cmd exec - --color never --sandbox workspace-write`;
+            return `type "${escaped}" | codex.cmd`;
     }
     else {
         if (agent === 'claude')
-            return `claude --print --verbose --output-format stream-json${modelFlag} < "${escaped}"`;
+            return `claude --print --verbose --output-format stream-json < "${escaped}"`;
         if (agent === 'codex')
-            return `codex exec - --color never --sandbox workspace-write < "${escaped}"`;
+            return `codex < "${escaped}"`;
     }
-    return `claude --print --verbose --output-format stream-json${modelFlag} < "${escaped}"`;
+    return `claude --print --verbose --output-format stream-json < "${escaped}"`;
 }
 /** Parse a Claude Code stream-json event into a human-readable line, or null to skip */
 function parseClaudeEvent(raw) {
@@ -126,60 +125,66 @@ function fmtTool(name, input = {}) {
 }
 // ─── Test runner after agent ──────────────────────────────────────────────────
 const TEST_FILE_RE = /\.(test|spec)\.(ts|tsx|js|jsx)$/;
-/**
- * Normalize a file path (possibly git-bash style /c/Users/...) to a path
- * relative to projectRoot, so vitest can always find it regardless of OS.
- */
-function toRelativeTestPath(filePath, projectRoot) {
-    // Convert git-bash absolute path (/c/Users/foo) → Windows-style (c:/Users/foo)
-    const normalized = filePath.replace(/^\/([a-zA-Z])\//, '$1:/').replace(/\\/g, '/');
-    const rootNorm = projectRoot.replace(/\\/g, '/');
-    if (normalized.startsWith(rootNorm + '/')) {
-        return normalized.slice(rootNorm.length + 1); // relative, forward slashes
-    }
-    // Already relative or unrecognized format — return as-is
-    return filePath.replace(/\\/g, '/');
-}
 function runTestFiles(files, projectRoot) {
     return new Promise((resolve) => {
-        const relFiles = files.map(f => toRelativeTestPath(f, projectRoot));
-        const proc = (0, child_process_1.spawn)('npx', ['vitest', 'run', '--reporter=json', ...relFiles], { 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 = '';
-        let stderr = '';
-        proc.stdout?.on('data', (d) => stdout += d.toString());
-        proc.stderr?.on('data', (d) => stderr += d.toString());
-        proc.on('close', (code) => {
+        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]*\}/);
-                if (!match) {
-                    // JSON not found — tests likely failed to start (import error, syntax error, etc.)
-                    const hint = (stderr || stdout).split('\n')
-                        .filter(l => l.trim() && !l.includes('VITE') && !l.includes('Duration'))
-                        .slice(0, 5).join('\n');
-                    resolve({ passed: 0, failed: files.length, files, fileDetails: {}, runError: hint || `exit code ${code}` });
-                    return;
+                // 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`);
                 }
-                const json = JSON.parse(match[0]);
+                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.name ?? tr.testFilePath ?? '';
+                    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,
@@ -187,57 +192,118 @@ function runTestFiles(files, projectRoot) {
                     fileDetails,
                 });
             }
-            catch (e) {
-                const hint = (stderr || stdout).split('\n').filter(l => l.trim()).slice(0, 5).join('\n');
-                resolve({ passed: 0, failed: files.length, files, fileDetails: {}, runError: hint || e.message });
+            catch (err) {
+                process.stdout.write(`   ❌ runTestFiles parse error: ${err.message}\n`);
+                resolve({ passed: 0, failed: 0, files, fileDetails: {} });
             }
         });
-        proc.on('error', (err) => resolve({ passed: 0, failed: files.length, files, fileDetails: {}, runError: err.message }));
+        proc.on('error', () => resolve({ passed: 0, failed: 0, files, fileDetails: {} }));
     });
 }
-// ─── Prompt builders ──────────────────────────────────────────────────────────
-/** Safely read a file, return null if not found */
-function tryReadFile(absPath) {
+// ─── 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 {
-        return fs.readFileSync(absPath, 'utf-8');
+        const p = e2ePlanPath(projectRoot, featureKey);
+        if (!fs.existsSync(p))
+            return null;
+        return JSON.parse(fs.readFileSync(p, 'utf-8'));
     }
     catch {
         return null;
     }
 }
-const FILE_BLOCK_LINE_LIMIT = 500;
-/** Embed file content as a fenced code block in prompt.
- *  For large files (> FILE_BLOCK_LINE_LIMIT lines) only embeds the first 200 lines
- *  (imports + types) and instructs the agent to read the full file by path. */
-function fileBlock(relPath, absPath) {
-    const content = tryReadFile(absPath);
-    if (!content)
-        return '';
-    const ext = absPath.split('.').pop() ?? 'ts';
-    const lines = content.split('\n');
-    if (lines.length > FILE_BLOCK_LINE_LIMIT) {
-        const preview = lines.slice(0, 200).join('\n');
-        return `### \`${relPath}\`\n_Файл большой (${lines.length} строк) — ниже первые 200 строк для контекста. Прочитай полный файл по пути: \`${absPath}\`_\n\`\`\`${ext}\n${preview}\n\`\`\``;
+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 [];
     }
-    return `### \`${relPath}\`\n\`\`\`${ext}\n${content}\n\`\`\``;
 }
-/**
- * Pick up to `n` example test files most relevant to `forRelPath`.
- * Prefer tests in the same directory (e.g. tests/client/ for client/src/pages/).
- */
-function pickExampleTests(forRelPath, testModules, n = 2) {
-    const isClient = forRelPath.includes('client/');
-    const preferred = testModules.filter(m => isClient ? m.relativePath.includes('client') : !m.relativePath.includes('client'));
-    const pool = preferred.length > 0 ? preferred : testModules;
-    return pool.slice(0, n);
+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;
+    }
 }
-function buildWriteTestsPrompt(feat, modules, testRunner, projectRoot) {
+// ─── Playwright runner ────────────────────────────────────────────────────────
+function runPlaywrightTests(files, projectRoot) {
+    return new Promise((resolve) => {
+        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.on('close', () => {
+            try {
+                const match = stdout.match(/\{[\s\S]*"suites"[\s\S]*\}/);
+                const json = JSON.parse(match ? match[0] : stdout);
+                const results = {};
+                const errors = {};
+                let passed = 0, failed = 0;
+                const walkSuites = (suites) => {
+                    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, results, errors });
+            }
+            catch {
+                resolve({ passed: 0, failed: 0, results: {}, errors: {} });
+            }
+        });
+        proc.on('error', () => resolve({ passed: 0, failed: 0, results: {}, errors: {} }));
+    });
+}
+// ─── Prompt builders ──────────────────────────────────────────────────────────
+function buildWriteTestsPrompt(feat, modules, testRunner) {
     const untestedMods = modules
         .filter(m => m.featureKeys.includes(feat.key) && m.type !== 'test' && !m.hasTests && !m.isInfra);
-    const existingTestMods = modules
-        .filter(m => m.featureKeys.includes(feat.key) && m.type === 'test');
+    const untestedPaths = untestedMods.map(m => '- ' + m.relativePath.replace(/\\/g, '/'));
+    const existing = modules
+        .filter(m => m.featureKeys.includes(feat.key) && m.type === 'test')
+        .map(m => '- ' + m.relativePath.replace(/\\/g, '/'));
     const hasNoTestInfra = modules.filter(m => m.type === 'test').length === 0;
-    // Split by suggested type
+    // Split by suggested type and give explicit guidance
     const unitFiles = untestedMods.filter(m => (m.suggestedTestType ?? 'unit') === 'unit');
     const integrationFiles = untestedMods.filter(m => m.suggestedTestType === 'integration');
     const typeSummary = [
@@ -248,123 +314,72 @@ function buildWriteTestsPrompt(feat, modules, testRunner, projectRoot) {
             ? `Integration-тесты (${integrationFiles.length} файлов): используй реальную БД через test-helpers или pg-mem`
             : '',
     ].filter(Boolean).join('\n');
-    // Embed source file contents (cap at 8 files to avoid huge prompts)
-    const sourceBlocks = untestedMods.slice(0, 8).map(m => fileBlock(m.relativePath.replace(/\\/g, '/'), m.path)).filter(Boolean);
-    // Pick example tests separately for client and server files
-    const clientMods = untestedMods.filter(m => m.relativePath.includes('client/'));
-    const serverMods = untestedMods.filter(m => !m.relativePath.includes('client/'));
-    const allTestMods = existingTestMods.length > 0 ? existingTestMods
-        : modules.filter(m => m.type === 'test');
-    const exampleSet = new Map();
-    if (clientMods.length > 0) {
-        pickExampleTests(clientMods[0].relativePath, allTestMods, 1)
-            .forEach(m => exampleSet.set(m.path, m));
-    }
-    if (serverMods.length > 0) {
-        pickExampleTests(serverMods[0].relativePath, allTestMods, 1)
-            .forEach(m => exampleSet.set(m.path, m));
-    }
-    if (exampleSet.size === 0) {
-        pickExampleTests('', allTestMods, 2).forEach(m => exampleSet.set(m.path, m));
-    }
-    const exampleBlocks = [...exampleSet.values()].map(m => fileBlock(m.relativePath.replace(/\\/g, '/'), m.path)).filter(Boolean);
-    // Embed test infrastructure: setup.ts + test-helpers.ts
-    const infraBlocks = [];
-    const setupPath = path.join(projectRoot, 'tests', 'setup.ts');
-    const helpersPath = path.join(projectRoot, 'tests', 'test-helpers.ts');
-    if (tryReadFile(setupPath))
-        infraBlocks.push(fileBlock('tests/setup.ts', setupPath));
-    if (tryReadFile(helpersPath))
-        infraBlocks.push(fileBlock('tests/test-helpers.ts', helpersPath));
     return [
         `Напиши тесты для фичи "${feat.label}".`,
         ``,
-        typeSummary ? `Рекомендации по типам тестов:\n${typeSummary}` : '',
-        ``,
-        `## Исходные файлы для покрытия`,
-        ...sourceBlocks,
+        `Файлов без тестов (${untestedMods.length}):`,
+        ...untestedPaths,
         ``,
-        exampleBlocks.length > 0 ? `## Примеры тестов (следуй этим паттернам)` : '',
-        ...exampleBlocks,
+        typeSummary ? `Рекомендации по типам тестов:\n${typeSummary}` : '',
         ``,
-        infraBlocks.length > 0 ? `## Тестовая инфраструктура` : '',
-        ...infraBlocks,
+        existing.length > 0
+            ? `Существующие тест-файлы (для справки по паттернам):\n${existing.join('\n')}`
+            : '',
         ``,
         hasNoTestInfra
             ? `⚠️ В проекте пока нет ни одного теста. Если нужна тестовая инфраструктура (test-helpers.ts, vitest.config.ts) — создай её сначала.`
             : '',
-        `## Требования`,
+        ``,
+        `Требования:`,
         `- Используй ${testRunner}`,
-        `- Для каждого исходного файла создай соответствующий тест-файл`,
-        `- Покрой: happy path, edge cases, обработку ошибок`,
-        `- Следуй паттернам примеров выше`,
+        `- Следуй паттернам существующих тестов в проекте`,
+        `- Для каждого файла создай соответствующий тест-файл`,
         `- Не изменяй существующие тесты`,
-        hasNoTestInfra
-            ? `- Если нужно — создай test-helpers.ts и vitest.config.ts перед написанием тестов`
-            : `- Если в исходном файле есть импорты типов которых нет выше — прочитай только эти файлы с типами. Не исследуй проект вширь.`,
-    ].filter(s => s !== null && s !== undefined && s !== '').join('\n');
+    ].filter(Boolean).join('\n');
 }
-function buildWriteTestsForFilePrompt(filePath, feat, modules, testRunner, projectRoot) {
+function buildWriteTestsForFilePrompt(filePath, feat, modules, testRunner) {
     const normalPath = filePath.replace(/\\/g, '/');
-    // Find module info to get suggestedTestType and absolute path
+    // Find module info to get suggestedTestType (match by relativePath or absolute path)
     const sourceModule = modules.find(m => m.relativePath.replace(/\\/g, '/') === normalPath || m.path === filePath);
     const suggestedTestType = sourceModule?.suggestedTestType ?? 'unit';
-    const absSourcePath = sourceModule?.path ?? path.join(projectRoot, filePath);
-    // Embed source file content
-    const sourceBlock = fileBlock(normalPath, absSourcePath);
-    // Pick 1-2 example tests most relevant to this file
-    const existingTestMods = modules.filter(m => m.type === 'test');
-    const featureTestMods = modules.filter(m => m.featureKeys.includes(feat.key) && m.type === 'test');
-    const examplePool = featureTestMods.length > 0 ? featureTestMods : existingTestMods;
-    const exampleTests = pickExampleTests(normalPath, examplePool, 2);
-    const exampleBlocks = exampleTests.map(m => fileBlock(m.relativePath.replace(/\\/g, '/'), m.path)).filter(Boolean);
-    // Embed test infrastructure: setup.ts + test-helpers.ts
-    const infraBlocks = [];
-    const setupPath = path.join(projectRoot, 'tests', 'setup.ts');
-    const helpersPath = path.join(projectRoot, 'tests', 'test-helpers.ts');
-    if (tryReadFile(setupPath))
-        infraBlocks.push(fileBlock('tests/setup.ts', setupPath));
-    if (tryReadFile(helpersPath))
-        infraBlocks.push(fileBlock('tests/test-helpers.ts', helpersPath));
+    const existing = modules
+        .filter(m => m.featureKeys.includes(feat.key) && m.type === 'test')
+        .map(m => '- ' + m.relativePath.replace(/\\/g, '/'));
+    const hasNoTestInfra = modules.filter(m => m.type === 'test').length === 0;
     const testTypeBlock = suggestedTestType === 'integration'
         ? [
             `Тип теста: INTEGRATION`,
-            `→ Используй test-helpers или реальную БД.`,
+            `Файл обращается к БД, репозиториям или внешним сервисам.`,
+            `→ Используй test-helpers или pg-mem для работы с реальной БД.`,
             `→ Не мокай репозитории — проверяй реальное поведение.`,
         ].join('\n')
         : [
             `Тип теста: UNIT`,
             `→ Замокай все внешние зависимости через \`vi.mock()\`.`,
             `→ Не используй реальную БД или внешние сервисы.`,
+            `→ Тест должен работать быстро без внешних зависимостей.`,
         ].join('\n');
-    const hasNoTestInfra = existingTestMods.length === 0;
     return [
-        `Напиши тест для файла \`${normalPath}\`. Фича: "${feat.label}"`,
+        `Напиши тест для файла \`${normalPath}\`.`,
+        `Фича: "${feat.label}"`,
         ``,
         testTypeBlock,
         ``,
-        `## Исходный файл`,
-        sourceBlock,
-        ``,
-        exampleBlocks.length > 0 ? `## Примеры тестов (следуй этим паттернам)` : '',
-        ...exampleBlocks,
-        ``,
-        infraBlocks.length > 0 ? `## Тестовая инфраструктура` : '',
-        ...infraBlocks,
+        existing.length > 0
+            ? `Существующие тест-файлы фичи (следуй этим паттернам):\n${existing.join('\n')}`
+            : 'Существующих тестов в этой фиче пока нет — следуй общим паттернам проекта.',
         ``,
         hasNoTestInfra
             ? `⚠️ В проекте пока нет ни одного теста. Если нужна тестовая инфраструктура (test-helpers.ts, vitest.config.ts) — создай её сначала.`
             : '',
-        `## Требования`,
+        ``,
+        `Требования:`,
         `- Используй ${testRunner}`,
         `- Создай один тест-файл для \`${normalPath}\``,
         `- Покрой: happy path, edge cases, обработку ошибок`,
-        `- Следуй паттернам примеров выше`,
+        `- Следуй паттернам существующих тестов в проекте`,
         `- Не изменяй существующие тесты`,
-        hasNoTestInfra
-            ? `- Если нужно — создай test-helpers.ts и vitest.config.ts перед написанием тестов`
-            : `- Если в исходном файле есть импорты типов которых нет выше — прочитай только эти файлы с типами. Не исследуй проект вширь.`,
-    ].filter(s => s !== null && s !== undefined && s !== '').join('\n');
+    ].filter(Boolean).join('\n');
 }
 function buildFixTestsPrompt(filePath, errors) {
     const normalPath = filePath.replace(/\\/g, '/');
@@ -382,28 +397,6 @@ 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))
@@ -425,6 +418,66 @@ function buildMapUnmappedPrompt(modules, features) {
         ...unmapped,
     ].join('\n');
 }
+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, '/'));
+    return [
+        `Ты — QA-инженер. Проанализируй исходный код фичи "${feat.label}" и составь подробный план E2E-тестирования.`,
+        ``,
+        `Файлы фичи:`,
+        ...files,
+        ``,
+        `Прочитай эти файлы, изучи UI: формы, кнопки, навигацию, бизнес-логику.`,
+        ``,
+        `Верни ТОЛЬКО валидный JSON без markdown-блоков в формате:`,
+        `{`,
+        `  "baseUrl": "http://localhost:3000",`,
+        `  "testCases": [`,
+        `    {`,
+        `      "id": "feature-key-01",`,
+        `      "name": "Краткое название теста",`,
+        `      "description": "Что проверяет тест",`,
+        `      "steps": ["Шаг 1", "Шаг 2", "Шаг 3"],`,
+        `      "expectedResults": ["Ожидаемый результат 1", "Ожидаемый результат 2"]`,
+        `    }`,
+        `  ]`,
+        `}`,
+        ``,
+        `Требования:`,
+        `- 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.featureKeys.includes(feat.key) && m.type === 'e2e')
+        .map(m => '- ' + m.relativePath.replace(/\\/g, '/'));
+    return [
+        `Напиши Playwright E2E тесты для фичи "${feat.label}".`,
+        ``,
+        `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/${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 ──────────────────────────────────────────
 function autoInstallCoverageProvider(projectRoot) {
     return new Promise(resolve => {
@@ -491,7 +544,6 @@ 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 ────────────────────────────────────────────────────────────
@@ -590,99 +642,86 @@ function startServer({ data: initialData, port, projectRoot }) {
             });
         }
         // ── Agent runner ───────────────────────────────────────────────────────────
-        /** Check if the configured agent CLI is installed; broadcast a warning if not */
-        function checkAgentInstalled(agent) {
-            if (!agent)
+        function runAgent(task, featureKey, filePath) {
+            if (agentRunning) {
+                process.stdout.write('   ⏳ Agent already running\n');
                 return;
-            const cliName = agent === 'claude'
-                ? (WIN ? 'claude.cmd' : 'claude')
-                : (WIN ? 'codex.cmd' : 'codex');
-            const agentName = agent === 'claude' ? 'Claude Code' : 'Codex';
-            const downloadUrl = agent === 'claude' ? 'claude.ai/download' : 'github.com/openai/codex';
-            const check = (0, child_process_1.spawn)(cliName, ['--version'], { shell: true, stdio: 'pipe' });
-            check.on('error', () => {
-                process.stdout.write(`   ⚠️  ${agentName} не найден (${cliName})\n`);
-                broadcast('agent-error', {
-                    message: `${agentName} не установлен. Скачай с ${downloadUrl}`,
-                    notInstalled: true,
-                    agent,
-                });
-            });
-            check.on('close', (code) => {
-                if (code === 255) {
-                    process.stdout.write(`   ⚠️  ${agentName} не авторизован (exit 255 при --version)\n`);
-                    broadcast('agent-error', {
-                        message: `${agentName} не авторизован. Нажми 🔑 Перелогиниться в меню агента.`,
-                        authRequired: true,
-                        agent,
-                    });
-                }
-                else if (code === 0) {
-                    process.stdout.write(`   ✅ ${agentName} доступен\n`);
-                }
-            });
-        }
-        /** Execute the 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);
             }
-            else {
-                broadcast('agent-done', { queueLength: 0 });
+            const agent = currentData.agent;
+            if (!agent) {
+                broadcast('agent-error', { message: 'Агент не выбран. Укажи agent в viberadar.config.json' });
+                return;
             }
-        }
-        /** 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 here (not pre-built in queue) to avoid holding large strings in memory ──
+            // Build prompt
             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', projectRoot);
+                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: 'Не указана фича или файл' });
-                    agentRunning = false;
-                    processNextInQueue();
+                    broadcast('agent-error', { message: `Не указана фича или файл` });
                     return;
                 }
-                prompt = buildWriteTestsForFilePrompt(filePath, feat, currentData.modules, currentData.testRunner || 'vitest', projectRoot);
+                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 || !savedErrors || savedErrors.length === 0) {
-                    broadcast('agent-error', { message: `Нет сохранённых ошибок для ${filePath}` });
-                    agentRunning = false;
-                    processNextInQueue();
+                if (!filePath) {
+                    broadcast('agent-error', { message: 'Не указан файл для исправления' });
+                    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}. Сначала запусти тесты.` });
                     return;
                 }
-                prompt = buildFixTestsPrompt(filePath, savedErrors);
+                prompt = buildFixTestsPrompt(filePath, storedErrors);
+                const fileName = filePath.replace(/\\/g, '/').split('/').pop() || filePath;
+                title = `${agentLabel} — исправить тесты в "${fileName}"`;
             }
-            else if (task === 'fix-tests-all') {
-                if (!savedFailedFiles || savedFailedFiles.length === 0) {
-                    broadcast('agent-error', { message: 'Нет упавших тестов для исправления' });
-                    agentRunning = false;
-                    processNextInQueue();
+            else if (task === 'generate-e2e-plan') {
+                const feat = currentData.features?.find(f => f.key === featureKey);
+                if (!feat) {
+                    broadcast('agent-error', { message: `Фича не найдена: ${featureKey}` });
                     return;
                 }
-                prompt = buildFixAllTestsPrompt(savedFailedFiles, savedTestType || 'unit');
+                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);
+                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}"`;
             }
             else {
                 prompt = buildMapUnmappedPrompt(currentData.modules, currentData.features || []);
+                title = `${agentLabel} — разобрать unmapped`;
             }
             agentRunning = true;
-            broadcast('agent-started', { title, task, featureKey, filePath: filePath || null, queueLength: agentQueue.length });
+            broadcast('agent-started', { title, task, featureKey });
             process.stdout.write(`   🤖 Running agent (${agent}): ${task}\n`);
             // Write prompt to .viberadar/task.md for reference
             const taskDir = path.join(projectRoot, '.viberadar');
@@ -693,7 +732,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, currentData.model);
+            const shellCmd = buildAgentShellCmd(agent, taskFile);
             process.stdout.write(`   🚀 Shell cmd: ${shellCmd}\n`);
             const proc = (0, child_process_1.spawn)(shellCmd, [], {
                 cwd: projectRoot,
@@ -704,6 +743,8 @@ 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 for E2E plan parsing
+            let agentResultText = '';
             function trackWrittenFiles(raw) {
                 try {
                     const ev = JSON.parse(raw);
@@ -735,8 +776,9 @@ function startServer({ data: initialData, port, projectRoot }) {
                 }
                 if (parsed.startsWith('§RESULT§')) {
                     // Full result summary — split into lines and prefix with indent
+                    agentResultText = parsed.slice('§RESULT§'.length).trim();
                     broadcast('agent-output', { line: '─────────────────────────────' });
-                    for (const l of parsed.slice('§RESULT§'.length).split('\n')) {
+                    for (const l of agentResultText.split('\n')) {
                         if (l.trim())
                             broadcast('agent-output', { line: '  ' + l });
                     }
@@ -759,33 +801,21 @@ function startServer({ data: initialData, port, projectRoot }) {
                 agentRunning = false;
                 if (code === 0) {
                     // Auto-run created/fixed test files and show results
-                    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) {
+                    const testFilesToRun = task === 'fix-tests' && filePath ? [filePath] : createdTestFiles;
+                    if ((task === 'write-tests' || task === 'write-tests-file' || task === 'fix-tests') && 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.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`;
+                        const summary = result.failed === 0
+                            ? `✅ Все тесты прошли: ${result.passed} passed`
+                            : `⚠️  ${result.passed} passed, ${result.failed} failed`;
                         broadcast('agent-output', { line: summary });
                         if (result.failed > 0) {
                             for (const [fp, detail] of Object.entries(result.fileDetails)) {
@@ -801,120 +831,57 @@ function startServer({ data: initialData, port, projectRoot }) {
                         }
                         broadcast('agent-summary', result);
                     }
+                    // E2E plan post-processing
+                    if (task === 'generate-e2e-plan' && featureKey) {
+                        try {
+                            const jsonMatch = agentResultText.match(/\{[\s\S]*"testCases"[\s\S]*\}/);
+                            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}` });
+                        }
+                    }
+                    if (task === 'write-e2e-tests' && featureKey) {
+                        const plan = loadE2ePlan(projectRoot, featureKey);
+                        if (plan) {
+                            for (const tc of plan.testCases) {
+                                if (tc.status === 'approved')
+                                    tc.status = 'written';
+                            }
+                            saveE2ePlan(projectRoot, plan);
+                            broadcast('e2e-tests-written', { featureKey, files: createdTestFiles });
+                        }
+                    }
                     process.stdout.write('   ✅ Agent done, rescanning...\n');
                     try {
                         currentData = await (0, scanner_1.scanProject)(projectRoot);
                         broadcast('data-updated');
                     }
                     catch { }
-                    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();
+                    broadcast('agent-done');
                 }
                 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: msg, notInstalled: isNotFound, agent });
-                processNextInQueue();
+                broadcast('agent-error', { message: `Не удалось запустить ${agent}: ${err.message}` });
             });
         }
-        /** 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;
-            }
-            // Validate params upfront and snapshot only the small error data for fix tasks.
-            // The full prompt is NOT built here — executeAgentItem() builds it lazily to save memory.
-            let title;
-            let savedErrors;
-            let savedFailedFiles;
-            let savedTestType;
-            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}` });
-                    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';
-                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 {
-                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}',
@@ -946,13 +913,25 @@ function startServer({ data: initialData, port, projectRoot }) {
                     const rel = path.relative(projectRoot, fp).replace(/\\/g, '/');
                     testErrors[rel] = detail;
                 }
+                // Check which features have E2E plans
+                const e2ePlansExist = {};
+                try {
+                    const planDir = e2ePlanDir(projectRoot);
+                    if (fs.existsSync(planDir)) {
+                        for (const f of fs.readdirSync(planDir)) {
+                            if (f.endsWith('.json'))
+                                e2ePlansExist[f.replace('.json', '')] = true;
+                        }
+                    }
+                }
+                catch { }
                 res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ...currentData, testErrors }));
+                res.end(JSON.stringify({ ...currentData, testErrors, hasPlaywright: hasPlaywright(projectRoot), e2ePlansExist }));
                 return;
             }
             if (url === '/api/status') {
                 res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ coverageRunning, coverageError, agentRunning, queueLength: agentQueue.length }));
+                res.end(JSON.stringify({ coverageRunning, coverageError, agentRunning }));
                 return;
             }
             if (url === '/api/run-coverage' && req.method === 'POST') {
@@ -995,13 +974,9 @@ function startServer({ data: initialData, port, projectRoot }) {
                             if (detail.failed > 0)
                                 lastTestResults.set(path.resolve(fp), { failed: detail.failed, errors: detail.errors });
                         }
-                        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`;
+                        const summary = result.failed === 0
+                            ? `✅ Все тесты прошли: ${result.passed} passed`
+                            : `⚠️  ${result.passed} passed, ${result.failed} failed`;
                         broadcast('agent-output', { line: summary });
                         if (result.failed > 0) {
                             for (const [fp, detail] of Object.entries(result.fileDetails)) {
@@ -1013,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 = {};
@@ -1021,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) {
@@ -1053,176 +1033,206 @@ function startServer({ data: initialData, port, projectRoot }) {
             }
             if (url === '/api/cancel-agent' && req.method === 'POST') {
                 agentRunning = false;
-                agentQueue.length = 0; // clear queue too
-                process.stdout.write('   ⏹ Agent state reset by user (queue cleared)\n');
+                process.stdout.write('   ⏹ Agent state reset by user\n');
                 res.writeHead(200, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({ ok: true }));
                 return;
             }
-            if (url === '/api/get-prompt' && req.method === 'POST') {
+            if (url === '/api/set-agent' && req.method === 'POST') {
                 let body = '';
                 req.on('data', d => body += d);
                 req.on('end', () => {
                     try {
-                        const { task, featureKey, filePath } = JSON.parse(body);
-                        let prompt = '';
-                        if (task === 'write-tests-file') {
-                            const feat = currentData.features?.find(f => f.key === featureKey);
-                            if (!feat || !filePath) {
-                                res.writeHead(400);
-                                res.end(JSON.stringify({ error: 'Missing feat or file' }));
-                                return;
-                            }
-                            prompt = buildWriteTestsForFilePrompt(filePath, feat, currentData.modules, currentData.testRunner || 'vitest', projectRoot);
-                        }
-                        else if (task === 'write-tests') {
-                            const feat = currentData.features?.find(f => f.key === featureKey);
-                            if (!feat) {
-                                res.writeHead(400);
-                                res.end(JSON.stringify({ error: 'Feature not found' }));
-                                return;
-                            }
-                            prompt = buildWriteTestsPrompt(feat, currentData.modules, currentData.testRunner || 'vitest', projectRoot);
-                        }
+                        const { agent } = JSON.parse(body);
+                        const configPath = path.join(projectRoot, 'viberadar.config.json');
+                        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                        config.agent = agent;
+                        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+                        scheduleRescan();
                         res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ prompt }));
+                        res.end(JSON.stringify({ ok: true, agent }));
                     }
                     catch (err) {
-                        res.writeHead(400);
+                        res.writeHead(500);
                         res.end(JSON.stringify({ error: err.message }));
                     }
                 });
                 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 }));
+            // 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;
             }
-            if (url === '/api/set-agent' && req.method === 'POST') {
+            // ── E2E routes ─────────────────────────────────────────────────────────
+            if (url === '/api/e2e/generate-plan' && req.method === 'POST') {
                 let body = '';
                 req.on('data', d => body += d);
                 req.on('end', () => {
                     try {
-                        const { agent } = JSON.parse(body);
-                        const configPath = path.join(projectRoot, 'viberadar.config.json');
-                        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-                        config.agent = agent;
-                        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
-                        scheduleRescan();
+                        const { featureKey } = JSON.parse(body);
+                        broadcast('e2e-plan-generating', { featureKey });
+                        runAgent('generate-e2e-plan', featureKey);
                         res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: true, agent }));
+                        res.end(JSON.stringify({ ok: true }));
                     }
                     catch (err) {
-                        res.writeHead(500);
+                        res.writeHead(400);
                         res.end(JSON.stringify({ error: err.message }));
                     }
                 });
                 return;
             }
-            if (url === '/api/set-model' && req.method === 'POST') {
+            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(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') {
                 let body = '';
                 req.on('data', d => body += d);
                 req.on('end', () => {
                     try {
-                        const { model } = JSON.parse(body);
-                        const configPath = path.join(projectRoot, 'viberadar.config.json');
-                        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-                        config.model = model || undefined;
-                        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
-                        scheduleRescan();
+                        const { featureKey, testCaseId, status } = JSON.parse(body);
+                        const plan = loadE2ePlan(projectRoot, featureKey);
+                        if (!plan) {
+                            res.writeHead(404);
+                            res.end(JSON.stringify({ error: 'Plan not found' }));
+                            return;
+                        }
+                        const tc = plan.testCases.find(t => t.id === testCaseId);
+                        if (tc)
+                            tc.status = status;
+                        saveE2ePlan(projectRoot, plan);
                         res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: true, model }));
+                        res.end(JSON.stringify({ ok: true, plan }));
                     }
                     catch (err) {
-                        res.writeHead(500);
+                        res.writeHead(400);
                         res.end(JSON.stringify({ error: err.message }));
                     }
                 });
                 return;
             }
-            if (url === '/api/agent-reauth' && req.method === 'POST') {
-                const agent = currentData.agent;
-                if (!agent) {
-                    res.writeHead(400, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'No agent configured' }));
-                    return;
-                }
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: true }));
-                const cliName = agent === 'claude' ? (WIN ? 'claude.cmd' : 'claude') : (WIN ? 'codex.cmd' : 'codex');
-                // Claude: `claude auth logout` / `claude auth login`
-                // Codex:  `codex logout`       / `codex login`  (no `auth` subcommand)
-                const logoutArgs = agent === 'claude' ? ['auth', 'logout'] : ['logout'];
-                const loginArgs = agent === 'claude' ? ['auth', 'login'] : ['login'];
-                // Step 1: logout
-                broadcast('agent-output', { line: `🔑 Выхожу из ${agent}...` });
-                const logoutProc = (0, child_process_1.spawn)(cliName, logoutArgs, {
-                    cwd: projectRoot, shell: true, stdio: 'pipe',
-                });
-                let logoutStderr = '';
-                logoutProc.stderr?.on('data', (d) => { logoutStderr += d.toString(); });
-                logoutProc.stdout?.on('data', (d) => {
-                    for (const l of d.toString().split('\n').filter(Boolean)) {
-                        broadcast('agent-output', { line: l });
+            if (url === '/api/e2e/review-all' && req.method === 'POST') {
+                let body = '';
+                req.on('data', d => body += d);
+                req.on('end', () => {
+                    try {
+                        const { featureKey, status } = JSON.parse(body);
+                        const plan = loadE2ePlan(projectRoot, featureKey);
+                        if (!plan) {
+                            res.writeHead(404);
+                            res.end(JSON.stringify({ error: 'Plan not found' }));
+                            return;
+                        }
+                        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 }));
+                    }
+                    catch (err) {
+                        res.writeHead(400);
+                        res.end(JSON.stringify({ error: err.message }));
                     }
                 });
-                logoutProc.on('close', (logoutCode) => {
-                    if (logoutCode === 0) {
-                        broadcast('agent-output', { line: '✅ Вышли из аккаунта' });
+                return;
+            }
+            if (url === '/api/e2e/write-tests' && req.method === 'POST') {
+                let body = '';
+                req.on('data', d => body += d);
+                req.on('end', () => {
+                    try {
+                        const { featureKey } = JSON.parse(body);
+                        broadcast('e2e-tests-writing', { featureKey });
+                        runAgent('write-e2e-tests', featureKey);
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ ok: true }));
                     }
-                    else {
-                        broadcast('agent-output', { line: `⚠ logout вернул код ${logoutCode}` });
-                        if (logoutStderr.trim()) {
-                            broadcast('agent-output', { line: logoutStderr.trim(), isDim: true });
-                        }
+                    catch (err) {
+                        res.writeHead(400);
+                        res.end(JSON.stringify({ error: err.message }));
                     }
-                    // Step 2: login (opens browser)
-                    broadcast('agent-output', { line: `🔑 Запускаю авторизацию ${agent}...` });
-                    const loginProc = (0, child_process_1.spawn)(cliName, loginArgs, {
-                        cwd: projectRoot, shell: true, stdio: 'pipe',
-                    });
-                    loginProc.stdout?.on('data', (d) => {
-                        for (const l of d.toString().split('\n').filter(Boolean)) {
-                            broadcast('agent-output', { line: l });
-                        }
-                    });
-                    loginProc.stderr?.on('data', (d) => {
-                        for (const l of d.toString().split('\n').filter(Boolean)) {
-                            broadcast('agent-output', { line: l });
-                        }
-                    });
-                    loginProc.on('close', (loginCode) => {
-                        if (loginCode === 0) {
-                            broadcast('agent-output', { line: '✅ Авторизация завершена! Можно запускать агента.' });
+                });
+                return;
+            }
+            if (url === '/api/e2e/run-tests' && req.method === 'POST') {
+                let body = '';
+                req.on('data', d => body += d);
+                req.on('end', async () => {
+                    try {
+                        const { featureKey } = JSON.parse(body);
+                        const plan = loadE2ePlan(projectRoot, featureKey);
+                        if (!plan) {
+                            res.writeHead(404);
+                            res.end(JSON.stringify({ error: 'Plan not found' }));
+                            return;
                         }
-                        else {
-                            broadcast('agent-output', { line: `⚠ Авторизация не завершена (код ${loginCode}).` });
-                            broadcast('agent-output', { line: `   Попробуй вручную: ${[cliName, ...loginArgs].join(' ')}` });
+                        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 });
+                        const result = await runPlaywrightTests(testFiles.length > 0 ? testFiles : [`e2e/${featureKey}`], projectRoot);
+                        // Update plan with results
+                        for (const tc of plan.testCases) {
+                            if (result.results[tc.name]) {
+                                tc.status = result.results[tc.name];
+                                if (result.errors[tc.name])
+                                    tc.lastError = result.errors[tc.name];
+                            }
+                            tc.screenshotPaths = collectScreenshots(projectRoot, featureKey, tc.id);
                         }
-                    });
-                    loginProc.on('error', () => {
-                        broadcast('agent-output', { line: `❌ Не удалось запустить ${cliName} auth login` });
-                    });
-                });
-                logoutProc.on('error', () => {
-                    broadcast('agent-output', { line: `❌ Не удалось запустить ${cliName}. Проверь что CLI установлен.` });
+                        saveE2ePlan(projectRoot, plan);
+                        broadcast('e2e-tests-done', { featureKey, passed: result.passed, failed: result.failed, plan });
+                    }
+                    catch (err) {
+                        res.writeHead(400);
+                        res.end(JSON.stringify({ error: err.message }));
+                    }
                 });
                 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));
+            if (url.startsWith('/api/e2e/screenshot/') && req.method === 'GET') {
+                const relPath = decodeURIComponent(url.slice('/api/e2e/screenshot/'.length));
+                // 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;
+                }
+                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);
+                }
+                catch {
+                    res.writeHead(404);
+                    res.end('Not found');
+                }
                 return;
             }
             res.writeHead(404);
@@ -1236,11 +1246,7 @@ function startServer({ data: initialData, port, projectRoot }) {
                 reject(err);
             }
         });
-        server.listen(port, '127.0.0.1', () => {
-            resolve({ server, triggerCoverage });
-            // Async startup check — runs after server is up, doesn't block
-            checkAgentInstalled(currentData.agent);
-        });
+        server.listen(port, '127.0.0.1', () => resolve({ server, triggerCoverage }));
         process.once('SIGINT', () => {
             console.log('\n👋 VibeRadar stopped.');
             // Destroy all SSE connections so server.close() doesn't hang waiting for them