viberadar 0.3.44 → 0.3.46

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) {
@@ -124,47 +123,75 @@ function fmtTool(name, input = {}) {
         default: return `🔧 ${name}${fp ? ': ' + fp : ''}`;
     }
 }
-// ─── 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
+function e2ePlanDir(projectRoot) {
+    return path.join(projectRoot, '.viberadar', 'e2e-plans');
+}
+function e2ePlanPath(projectRoot, featureKey) {
+    return path.join(e2ePlanDir(projectRoot), `${featureKey}.json`);
+}
+function loadE2ePlan(projectRoot, featureKey) {
+    const fp = e2ePlanPath(projectRoot, featureKey);
+    try {
+        return JSON.parse(fs.readFileSync(fp, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function saveE2ePlan(projectRoot, plan) {
+    const dir = e2ePlanDir(projectRoot);
+    fs.mkdirSync(dir, { recursive: true });
+    plan.updatedAt = new Date().toISOString();
+    fs.writeFileSync(e2ePlanPath(projectRoot, plan.featureKey), JSON.stringify(plan, null, 2), 'utf-8');
+}
+function e2eScreenshotDir(projectRoot, featureKey) {
+    return path.join(projectRoot, '.viberadar', 'e2e-screenshots', featureKey);
+}
+function collectScreenshots(projectRoot, featureKey) {
+    const baseDir = e2eScreenshotDir(projectRoot, featureKey);
+    const result = new Map();
+    if (!fs.existsSync(baseDir))
+        return result;
+    try {
+        for (const entry of fs.readdirSync(baseDir, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const tcPath = path.join(baseDir, entry.name);
+            const screenshots = fs.readdirSync(tcPath)
+                .filter(f => /\.(png|jpg|jpeg|webp)$/i.test(f))
+                .map(f => `${featureKey}/${entry.name}/${f}`);
+            result.set(entry.name, screenshots);
+        }
+    }
+    catch { }
+    return result;
+}
+function hasPlaywright(projectRoot) {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(projectRoot, 'package.json'), 'utf-8'));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        return !!deps['@playwright/test'] || !!deps['playwright'];
+    }
+    catch {
+        return false;
     }
-    // Already relative or unrecognized format — return as-is
-    return filePath.replace(/\\/g, '/');
 }
+// ─── Test runner after agent ──────────────────────────────────────────────────
+const TEST_FILE_RE = /\.(test|spec)\.(ts|tsx|js|jsx)$/;
 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' });
+        const proc = (0, child_process_1.spawn)('npx', ['vitest', 'run', '--reporter=json', ...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.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;
-                }
-                const json = JSON.parse(match[0]);
+                const json = JSON.parse(match ? match[0] : stdout);
                 // Extract per-file failure details
                 const fileDetails = {};
                 for (const tr of (json.testResults ?? [])) {
-                    const fp = tr.name ?? tr.testFilePath ?? '';
+                    const fp = tr.testFilePath ?? '';
                     const errors = [];
                     for (const ar of (tr.assertionResults ?? [])) {
                         if (ar.status === 'failed') {
@@ -187,57 +214,70 @@ 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 {
+                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) {
-    try {
-        return fs.readFileSync(absPath, '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\`\`\``;
-    }
-    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 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' });
+        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 testResults = [];
+                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,
+                                    });
+                                }
+                            }
+                        }
+                        if (suite.suites)
+                            walkSuites(suite.suites);
+                    }
+                };
+                walkSuites(json.suites || []);
+                resolve({ passed, failed, testResults });
+            }
+            catch {
+                resolve({ passed: 0, failed: 0, testResults: [] });
+            }
+        });
+        proc.on('error', () => resolve({ passed: 0, failed: 0, testResults: [] }));
+    });
 }
-function buildWriteTestsPrompt(feat, modules, testRunner, projectRoot) {
+// ─── 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 +288,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 +371,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 +392,94 @@ function buildMapUnmappedPrompt(modules, features) {
         ...unmapped,
     ].join('\n');
 }
+// ─── E2E prompt builders ────────────────────────────────────────────────────
+function buildE2ePlanPrompt(feat, modules, projectRoot) {
+    const srcFiles = 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,
+        ``,
+        pageFiles.length > 0 ? `Страницы/роуты:\n${pageFiles.join('\n')}` : '',
+        ``,
+        `Важно:`,
+        `- Каждый тест-кейс должен проверять один пользовательский сценарий`,
+        `- Включи happy path, edge cases, ошибки валидации`,
+        `- Steps должны быть конкретными: укажи селекторы, URL, текст кнопок из реального кода`,
+        `- id тест-кейса: ${feat.key}-<scenario>-NN (например: ${feat.key}-login-01)`,
+        ``,
+        `Ответ верни СТРОГО в формате JSON (без markdown-блоков, без комментариев, чистый JSON):`,
+        `{`,
+        `  "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"`,
+        `      ]`,
+        `    }`,
+        `  ]`,
+        `}`,
+        ``,
+        `Генерируй 5–15 тест-кейсов, покрывающих все основные сценарии фичи.`,
+        !pwConfigExists ? `\n⚠️ playwright.config.ts не найден — его нужно будет создать перед написанием тестов.` : '',
+    ].filter(Boolean).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))
+        .map(m => '- ' + m.relativePath.replace(/\\/g, '/'));
+    return [
+        `Напиши Playwright E2E-тесты для фичи "${feat.label}".`,
+        `Base URL: ${plan.baseUrl || 'http://localhost:3000'}`,
+        ``,
+        `Утверждённые тест-кейсы (${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}`),
+            ``,
+        ].join('\n')),
+        ``,
+        existingE2e.length > 0
+            ? `Существующие E2E тесты (следуй этим паттернам):\n${existingE2e.join('\n')}`
+            : 'Существующих E2E тестов пока нет.',
+        ``,
+        `Требования:`,
+        `- Используй 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() и другие ожидания`,
+        `- Не изменяй существующие тесты`,
+    ].filter(Boolean).join('\n');
+}
 // ─── Coverage provider auto-install ──────────────────────────────────────────
 function autoInstallCoverageProvider(projectRoot) {
     return new Promise(resolve => {
@@ -491,7 +546,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 +644,95 @@ 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, projectRoot);
+                title = `${agentLabel} — E2E план для "${feat.label}"`;
+            }
+            else if (task === 'write-e2e-tests') {
+                const feat = currentData.features?.find(f => f.key === featureKey);
+                if (!feat) {
+                    broadcast('agent-error', { message: `Фича не найдена: ${featureKey}` });
+                    return;
+                }
+                const plan = loadE2ePlan(projectRoot, feat.key);
+                if (!plan) {
+                    broadcast('agent-error', { message: `E2E план не найден для "${feat.label}". Сначала сгенерируй план.` });
+                    return;
+                }
+                const approved = plan.testCases.filter(tc => tc.status === 'approved');
+                if (approved.length === 0) {
+                    broadcast('agent-error', { message: `Нет одобренных тест-кейсов в плане "${feat.label}"` });
+                    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, 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 +743,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 +754,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 from agent (for JSON plan parsing)
+            let agentResultText = '';
             function trackWrittenFiles(raw) {
                 try {
                     const ev = JSON.parse(raw);
@@ -734,9 +786,11 @@ function startServer({ data: initialData, port, projectRoot }) {
                     return;
                 }
                 if (parsed.startsWith('§RESULT§')) {
+                    const resultBody = parsed.slice('§RESULT§'.length);
+                    agentResultText += resultBody + '\n';
                     // Full result summary — split into lines and prefix with indent
                     broadcast('agent-output', { line: '─────────────────────────────' });
-                    for (const l of parsed.slice('§RESULT§'.length).split('\n')) {
+                    for (const l of resultBody.split('\n')) {
                         if (l.trim())
                             broadcast('agent-output', { line: '  ' + l });
                     }
@@ -759,33 +813,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 +843,82 @@ function startServer({ data: initialData, port, projectRoot }) {
                         }
                         broadcast('agent-summary', result);
                     }
+                    // ── 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 });
+                            }
+                        }
+                        catch (err) {
+                            broadcast('e2e-plan-error', { featureKey, message: err.message });
+                            broadcast('agent-output', { line: `❌ Ошибка парсинга плана: ${err.message}`, isError: true });
+                        }
+                    }
+                    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') {
+                                    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 план обновлён: тесты отмечены как написанные` });
+                        }
+                    }
                     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 +950,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 = [];
+                const plansDir = e2ePlanDir(projectRoot);
+                try {
+                    if (fs.existsSync(plansDir)) {
+                        for (const f of fs.readdirSync(plansDir)) {
+                            if (f.endsWith('.json'))
+                                e2ePlansExist.push(f.replace('.json', ''));
+                        }
+                    }
+                }
+                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 +1011,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)) {
@@ -1053,39 +1065,43 @@ 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(500);
+                        res.end(JSON.stringify({ error: err.message }));
+                    }
+                });
+                return;
+            }
+            // ── E2E Plan API ──────────────────────────────────────────────────────────
+            if (url === '/api/e2e/generate-plan' && req.method === 'POST') {
+                let body = '';
+                req.on('data', d => body += d);
+                req.on('end', () => {
+                    try {
+                        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 }));
                     }
                     catch (err) {
                         res.writeHead(400);
@@ -1094,125 +1110,191 @@ function startServer({ data: initialData, port, projectRoot }) {
                 });
                 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 }));
+            // GET /api/e2e/plan/<featureKey>
+            if (url.startsWith('/api/e2e/plan/') && req.method === 'GET') {
+                const featureKey = decodeURIComponent(url.slice('/api/e2e/plan/'.length));
+                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' }));
+                }
                 return;
             }
-            if (url === '/api/set-agent' && req.method === 'POST') {
+            if (url === '/api/e2e/review' && 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, 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) {
+                            res.writeHead(404);
+                            res.end(JSON.stringify({ error: 'Test case not found' }));
+                            return;
+                        }
+                        tc.status = status;
+                        saveE2ePlan(projectRoot, plan);
                         res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: true, agent }));
+                        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/set-model' && req.method === 'POST') {
+            if (url === '/api/e2e/review-all' && 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, 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) {
+                            if (tc.status === 'pending')
+                                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 });
-                    }
-                });
-                logoutProc.on('close', (logoutCode) => {
-                    if (logoutCode === 0) {
-                        broadcast('agent-output', { line: '✅ Вышли из аккаунта' });
+            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 });
+                });
+                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;
                         }
-                    });
-                    loginProc.stderr?.on('data', (d) => {
-                        for (const l of d.toString().split('\n').filter(Boolean)) {
-                            broadcast('agent-output', { line: l });
+                        // 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);
+                                }
+                            }
                         }
-                    });
-                    loginProc.on('close', (loginCode) => {
-                        if (loginCode === 0) {
-                            broadcast('agent-output', { line: '✅ Авторизация завершена! Можно запускать агента.' });
+                        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;
                         }
-                        else {
-                            broadcast('agent-output', { line: `⚠ Авторизация не завершена (код ${loginCode}).` });
-                            broadcast('agent-output', { line: `   Попробуй вручную: ${[cliName, ...loginArgs].join(' ')}` });
+                        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);
+                        // 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;
+                            }
+                            tc.screenshotPaths = screenshots.get(tc.id) || [];
                         }
-                    });
-                    loginProc.on('error', () => {
-                        broadcast('agent-output', { line: `❌ Не удалось запустить ${cliName} auth login` });
-                    });
-                });
-                logoutProc.on('error', () => {
-                    broadcast('agent-output', { line: `❌ Не удалось запустить ${cliName}. Проверь что CLI установлен.` });
+                        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,
+                        });
+                    }
+                    catch (err) {
+                        res.writeHead(400);
+                        res.end(JSON.stringify({ error: err.message }));
+                    }
                 });
                 return;
             }
+            // Serve E2E screenshots
+            if (url.startsWith('/api/e2e/screenshot/')) {
+                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)) {
+                    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);
+                }
+                else {
+                    res.writeHead(404);
+                    res.end('Screenshot not found');
+                }
+                return;
+            }
             // Server-Sent Events endpoint
             if (url === '/api/events') {
                 res.writeHead(200, {
@@ -1236,11 +1318,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