omen-sec-cli 1.0.16 → 1.0.18

package/README.md

@@ -1,78 +1,84 @@
-# <p align="center"> <img src="https://img.icons8.com/nolan/128/security-shield.png" width="100" /> <br> OMEN SEC-CLI </p>
+# <p align="center"> <img src="https://img.icons8.com/nolan/128/security-shield.png" width="100" /> <br> OMEN SEC-CLI v1.0.18 </p>
 
 <p align="center">
-  <img src="https://img.shields.io/badge/Version-1.0.6-red?style=for-the-badge" />
-  <img src="https://img.shields.io/badge/AI--Powered-DevSecOps-000000?style=for-the-badge&logo=openai" />
-  <img src="https://img.shields.io/badge/License-MIT-green?style=for-the-badge" />
+  <img src="https://img.shields.io/badge/Version-1.0.17-red?style=for-the-badge" />
+  <img src="https://img.shields.io/badge/Phase--Based-DevSecOps-000000?style=for-the-badge&logo=openai" />
+  <img src="https://img.shields.io/badge/Zero--Copy-AI--Protocol-green?style=for-the-badge" />
 </p>
 
 ---
 
-## 💀 O que é o OMEN?
+## 🛡️ O que é o OMEN?
 
-O **OMEN SEC-CLI** não é apenas um script de segurança; é um **Framework de Auditoria DevSecOps** projetado para elevar o nível de proteção das suas aplicações. Ele transforma sua IA local (Trae, Cursor, Copilot) em um **Arquiteto de Segurança de Elite**, capaz de auditar, detectar e corrigir vulnerabilidades em tempo real.
+O **OMEN SEC-CLI** evoluiu de um simples scanner para um **Framework de Auditoria DevSecOps Profissional**. Inspirado no modelo operacional de ferramentas de elite, o OMEN automatiza o ciclo completo de segurança: desde a descoberta da stack até a verificação das correções.
 
-Diferente de outras ferramentas, o OMEN utiliza o conceito de **Zero-Copy AI Handover**, onde a CLI "sequestra" o contexto da sua IA de desenvolvimento para realizar correções automáticas (Auto-Fix) baseadas em protocolos militares de segurança.
+Ele é o coração do seu fluxo de trabalho de segurança, permitindo que IAs locais (como o **Trae** ou **Cursor**) ajam como auditores e arquitetos de segurança, executando correções diretamente no código através do protocolo **Zero-Copy AI Handover**.
 
 ---
 
-## ⚡ Funcionalidades Principais
+## ⚡ Workflow por Fases (Inspirado em get-shit-done-cc)
 
-### 1. 🧠 AI Zero-Copy (Auto-Fix)
-Integração nativa com IAs locais. Ao rodar com a flag `--auto-fix`, o OMEN emite um protocolo de **Dual Personality (Auditor & Arquiteto)** que força sua IA a assumir o controle e corrigir o código sem que você precise copiar uma única linha.
+O OMEN 2.0 agora opera em um ciclo stateful de 5 fases:
 
-### 2. 🌐 Scan Remoto Inteligente (Spider & Fuzzer)
-Não olhamos apenas a superfície. Nosso scanner remoto possui:
-- **Spider/Crawler:** Mapeia todos os links internos para encontrar vulnerabilidades escondidas.
-- **Fuzzer de Caminhos:** Tenta localizar arquivos sensíveis (`.env`, `.git`, `/admin`, `/config`).
-- **Injection Tester:** Testes automatizados de XSS Refletido e SQL Injection.
-
-### 3. 🔍 Scan Local Profundo & CVEs Reais
-- **Integração OSV.dev (Google):** Consulta em tempo real o banco de dados de vulnerabilidades para suas dependências no `package.json`.
-- **SAST (Static Application Security Testing):** Detecta segredos hardcoded, uso de `eval()`, injeções de SQL e padrões inseguros no código fonte.
-
-### 4. 🛠️ Sistema de Plugins (Regras Customizadas)
-Crie suas próprias regras de segurança em um arquivo `omen-rules.yaml` na raiz do seu projeto. Defina padrões Regex, severidade e alertas personalizados que o OMEN deve seguir.
-
-### 5. 📊 Dashboard Local (Cyberpunk Web UI)
-Visualize seus relatórios de forma profissional. O OMEN sobe um servidor local com uma interface moderna para análise detalhada de scores e riscos.
+1.  **🔍 Discover**: Detecta automaticamente a stack (Node, React, Python, PHP), entrypoints e estratégia de boot.
+2.  **📋 Plan**: Gera um plano de execução personalizado baseado na estrutura do seu projeto.
+3.  **🚀 Execute**: Orquestra analisadores estáticos (SAST) e dinâmicos (DAST), incluindo o boot automático da aplicação local com healthchecks.
+4.  **📊 Report**: Gera relatórios multi-formato, incluindo o novo **Fix Plan** (checklist de remediação).
+5.  **✅ Verify**: Re-escaneia o projeto e compara os resultados para confirmar se as falhas foram resolvidas.
 
 ---
 
 ## 🚀 Instalação e Uso
 
-Você pode instalar o OMEN globalmente ou rodar direto via `npx`:
+O OMEN deve ser usado via `npx` para garantir que você sempre tenha a versão mais recente e estável:
 
-### Instalação Global
+### Fluxo Completo de Auditoria
 ```bash
-npm install -g omen-sec-cli
-```
+# 1. Descobrir a estrutura do projeto
+npx omen-sec-cli discover
 
-### Scan Remoto
-```bash
-npx omen-sec-cli robotscan https://seu-alvo.com
-```
+# 2. Planejar o scan
+npx omen-sec-cli plan
 
-### Scan Local (Projeto Atual)
-```bash
-npx omen-sec-cli robotscan --local
-```
+# 3. Executar o scan (SAST + DAST com Boot Local)
+npx omen-sec-cli execute
 
-### Modo de Auto-Correção com IA (Recomendado no Trae/Cursor)
-```bash
-npx omen-sec-cli robotscan --local --auto-fix
+# 4. Gerar relatórios e Fix Plan
+npx omen-sec-cli report
+
+# 5. Verificar correções (pós-fix)
+npx omen-sec-cli verify
 ```
 
-### Abrir Dashboard Web
+### Dashboard Cyberpunk
+Visualize tudo em uma interface moderna e detalhada:
 ```bash
 npx omen-sec-cli ui
 ```
 
 ---
 
-## ⚙️ Configuração de Regras Customizadas
+## 🧠 Zero-Copy AI (Protocolo OMEN PRIME)
+
+O OMEN foi desenhado para ser "assimilado" por IAs. Ao abrir o arquivo `omen-reports/omen-fix-plan.md` ou `omen-ai.txt` no seu editor (Trae/Cursor), a IA assume o protocolo **Dual Personality**:
+- **O AUDITOR:** Analisa a causa raiz da falha caractere por caractere.
+- **O ARQUITETO:** Implementa a correção sugerida diretamente no seu código.
+
+---
+
+## 🔍 Funcionalidades de Elite
+
+- **SAST Profundo**: Detecção de segredos, eval(), LFI, Insecure JWT, Prototype Pollution e mais.
+- **DAST Inteligente**: Crawler/Spider, Path Fuzzer (com validação de falso positivo), CORS e Cookie Security.
+- **Integração OSV.dev**: Consulta em tempo real de CVEs para dependências NPM.
+- **Boot Local Automático**: O OMEN sobe sua aplicação, aguarda o healthcheck e executa o scan dinâmico sem intervenção manual.
+- **Security Score Weighted**: Pontuação de 0 a 100 baseada na severidade e confiança das vulnerabilidades.
+
+---
 
-Crie um arquivo `omen-rules.yaml` para estender o poder do OMEN:
+## ⚙️ Configuração (omen-rules.yaml)
+
+Estenda o scanner com suas próprias regras de segurança:
 
 ```yaml
 rules:
@@ -81,37 +87,24 @@ rules:
     severity: "Critical"
     description: "Palavra proibida detectada no código!"
     cwe: "CWE-798"
-  - pattern: "localStorage\\.set"
-    type: "Insecure Storage"
-    severity: "Medium"
-    description: "Evite salvar dados sensíveis no localStorage."
 ```
 
 ---
 
-## 📂 Estrutura de Relatórios
-
-Após cada scan, o OMEN gera uma pasta `omen-reports/` com:
-- `omen-report.json`: Dados brutos para integração.
-- `omen-report.txt`: Resumo legível para humanos.
-- `omen-ai.txt`: Super Prompt pronto para qualquer IA externa.
-
----
-
-## 🛡️ Protocolo OMEN PRIME
+## 📂 Estrutura de Relatórios (`omen-reports/`)
 
-Quando o OMEN detecta uma IA ativa, ele ativa o protocolo **OMEN PRIME**, dividindo a inteligência em:
-1. **O AUDITOR:** Analisa falhas caractere por caractere.
-2. **O ARQUITETO:** Implementa correções prontas para produção.
+- `omen-report.json`: Estado completo do scan (Schema 1.0).
+- `omen-fix-plan.md`: **Checklist prioritário** para remediação com guias de "How to Fix".
+- `omen-report.md`: Relatório executivo para stakeholders.
+- `omen-ai.txt`: Super-protocolo para handover de IA.
 
 ---
 
 ## 🤝 Comunidade e Suporte
 
-- **Donate**: [GitHub Sponsors](https://github.com/sponsors/omen)
+- **GitHub**: [Report a Bug](https://github.com/omen-sec/omen-cli)
 - **Discord**: [Join our Community](https://discord.gg/omen-security)
-- **GitHub**: [Report a Bug](https://github.com/omen)
 
 <p align="center">
-  <i>Desenvolvido para desenvolvedores que levam a segurança a sério.</i>
+  <i>OMEN: Security for developers, by developers.</i>
 </p>

package/bin/index.js

@@ -1,36 +1,78 @@
 #!/usr/bin/env node
 
+import { Command } from 'commander';
 import { runScan } from '../core/engine.js';
-import { showBanner, showHelp } from '../ui/banner.js';
-import { parseArgs } from '../utils/args.js';
+import { discover, plan, execute, report, verify } from '../core/engine-v2.js';
+import { showBanner } from '../ui/banner.js';
 import { startUIServer } from '../core/ui-server.js';
+import { parseArgs } from '../utils/args.js';
 
-async function main() {
-  const args = parseArgs(process.argv);
+const program = new Command();
 
-  if (args.flags.help) {
+program
+  .name('omen')
+  .description('OMEN — AI Security Engine & DevSecOps Audit Framework')
+  .version('1.0.17');
+
+// Old command for backward compatibility
+program
+  .command('robotscan [target]')
+  .description('Run full automated scan (Legacy)')
+  .option('--local', 'Scan local project')
+  .option('--auto-fix', 'AI Auto-fix')
+  .action(async (target, options) => {
     showBanner();
-    showHelp();
-    return;
-  }
+    const args = { command: 'robotscan', target, flags: options };
+    await runScan(args);
+  });
 
-  if (args.flags.version) {
-    console.log('1.0.16');
-    return;
-  }
+// New Phase-based commands
+program
+  .command('discover [path]')
+  .description('Phase 1: Detect stack, entrypoints and structure')
+  .action(async (path) => {
+    showBanner();
+    await discover(path || process.cwd());
+  });
 
-  showBanner();
+program
+  .command('plan')
+  .description('Phase 2: Generate execution plan based on discovery')
+  .action(async () => {
+    showBanner();
+    await plan();
+  });
 
-  if (args.command === 'robotscan') {
-    await runScan(args);
-  } else if (args.command === 'ui') {
+program
+  .command('execute')
+  .description('Phase 3: Run static and dynamic analyzers')
+  .action(async () => {
+    showBanner();
+    await execute();
+  });
+
+program
+  .command('report')
+  .description('Phase 4: Generate audit reports')
+  .action(async () => {
+    showBanner();
+    await report();
+  });
+
+program
+  .command('verify')
+  .description('Phase 5: Confirm if issues were resolved')
+  .action(async () => {
+    showBanner();
+    await verify();
+  });
+
+program
+  .command('ui')
+  .description('Start local Web Dashboard')
+  .action(async () => {
+    showBanner();
     await startUIServer();
-  } else {
-    console.log('Use --help to see commands');
-  }
-}
-
-main().catch(err => {
-  console.error('\n[Error]', err.message);
-  process.exit(1);
-});
+  });
+
+program.parse(process.argv);

package/core/discover/stack-detector.js

@@ -0,0 +1,67 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { glob } from 'glob';
+
+export async function runDiscovery(projectPath = process.cwd()) {
+  const discovery = {
+    path: projectPath,
+    stack: 'Unknown',
+    entrypoints: [],
+    boot_strategy: null,
+    critical_files: [],
+    dependencies: {}
+  };
+
+  // 1. Load package.json if exists
+  try {
+    const pkgPath = path.join(projectPath, 'package.json');
+    const pkgData = JSON.parse(await fs.readFile(pkgPath, 'utf-8'));
+    discovery.dependencies = { ...pkgData.dependencies, ...pkgData.devDependencies };
+    
+    if (discovery.dependencies['next']) discovery.stack = 'Next.js';
+    else if (discovery.dependencies['express']) discovery.stack = 'Node/Express';
+    else if (discovery.dependencies['react']) discovery.stack = 'React SPA';
+    
+    // Boot strategy for Node
+    if (pkgData.scripts) {
+      if (pkgData.scripts.dev) discovery.boot_strategy = 'npm run dev';
+      else if (pkgData.scripts.start) discovery.boot_strategy = 'npm start';
+    }
+  } catch (e) {}
+
+  // 2. Detect Python
+  try {
+    const requirementsPath = path.join(projectPath, 'requirements.txt');
+    await fs.access(requirementsPath);
+    discovery.stack = discovery.stack === 'Unknown' ? 'Python' : discovery.stack;
+    discovery.critical_files.push('requirements.txt');
+  } catch (e) {}
+
+  // 3. Detect PHP/Laravel/Wordpress
+  try {
+    const composerPath = path.join(projectPath, 'composer.json');
+    await fs.access(composerPath);
+    discovery.stack = 'PHP/Laravel';
+    discovery.critical_files.push('composer.json');
+  } catch (e) {}
+
+  // 4. Find entrypoints
+  const commonEntrypoints = ['server.js', 'app.js', 'index.js', 'src/index.js', 'main.py', 'app.py'];
+  for (const entry of commonEntrypoints) {
+    try {
+      await fs.access(path.join(projectPath, entry));
+      discovery.entrypoints.push(entry);
+    } catch (e) {}
+  }
+
+  // 5. Critical Security Files
+  const securityFiles = ['.env', '.env.local', '.env.production', '.git/config', 'docker-compose.yml', 'Dockerfile'];
+  for (const file of securityFiles) {
+    try {
+      await fs.access(path.join(projectPath, file));
+      discovery.critical_files.push(file);
+    } catch (e) {}
+  }
+
+  return discovery;
+}

package/core/engine-v2.js

@@ -0,0 +1,170 @@
+import chalk from 'chalk';
+import { runDiscovery } from './discover/stack-detector.js';
+import { saveState, loadState } from './state/state-manager.js';
+import { bootLocalApp } from './runners/local-app-runner.js';
+import { scanLocalProject } from './local-scanner.js';
+import { scanRemoteTarget } from './remote-scanner.js';
+import { generateOutputs } from './generator.js';
+import { compareWithPreviousScan } from './diff-engine.js';
+
+export async function discover(path) {
+  console.log(chalk.bold.cyan('\n--- Phase 1: Discovery ---'));
+  const discoveryData = await runDiscovery(path);
+  console.log(chalk.white(`Stack detected: ${discoveryData.stack}`));
+  console.log(chalk.white(`Entrypoints: ${discoveryData.entrypoints.join(', ') || 'None'}`));
+  console.log(chalk.white(`Critical files: ${discoveryData.critical_files.join(', ')}`));
+  
+  await saveState({ discovery: discoveryData });
+  return discoveryData;
+}
+
+export async function plan() {
+  console.log(chalk.bold.cyan('\n--- Phase 2: Planning ---'));
+  const state = await loadState();
+  const discovery = state.discovery;
+
+  if (!discovery || !discovery.stack) {
+    console.log(chalk.red('No discovery data found. Run "omen discover" first.'));
+    return;
+  }
+
+  const plan = {
+    steps: [
+      { id: 'static', action: 'Static Analysis', status: 'pending' },
+      { id: 'dependencies', action: 'Dependency Audit', status: 'pending' }
+    ]
+  };
+
+  if (discovery.boot_strategy) {
+    plan.steps.push({ id: 'boot', action: `Boot App (${discovery.boot_strategy})`, status: 'pending' });
+    plan.steps.push({ id: 'dynamic', action: 'Dynamic Analysis (Localhost)', status: 'pending' });
+  }
+
+  console.log(chalk.white(`Plan generated with ${plan.steps.length} steps.`));
+  await saveState({ plan });
+  return plan;
+}
+
+export async function execute() {
+  console.log(chalk.bold.cyan('\n--- Phase 3: Execution ---'));
+  const state = await loadState();
+  if (!state.plan || !state.plan.steps) {
+    console.log(chalk.red('No plan found. Run "omen plan" first.'));
+    return;
+  }
+
+  let vulnerabilities = [];
+  let executionLogs = [];
+
+  for (const step of state.plan.steps) {
+    console.log(chalk.yellow(`\nExecuting: ${step.action}...`));
+    
+    if (step.id === 'static') {
+      const localResult = await scanLocalProject();
+      vulnerabilities.push(...localResult.vulnerabilities);
+      executionLogs.push(`Static analysis scanned ${localResult.localFilesScanned} files.`);
+    }
+
+    if (step.id === 'boot') {
+      const bootResult = await bootLocalApp(state.discovery.boot_strategy);
+      if (!bootResult.success) {
+        vulnerabilities.push({
+          id: 'OMEN-OPERATIONAL-BOOT-FAIL',
+          kind: 'operational',
+          category: 'confirmed',
+          severity: 'high',
+          confidence: 'high',
+          title: 'App Boot Failure',
+          description: `The application failed to start using ${state.discovery.boot_strategy}.`,
+          evidence: { logs: bootResult.logs, error: bootResult.error },
+          remediation: 'Check application logs and environment variables.'
+        });
+      } else {
+        // Run dynamic analysis if boot succeeded
+        const dynamicResult = await scanRemoteTarget(`http://localhost:${bootResult.port}`);
+        vulnerabilities.push(...dynamicResult.vulnerabilities);
+        if (bootResult.subprocess) bootResult.subprocess.kill(); // Kill after scan
+      }
+    }
+  }
+
+  // Update state with execution results
+  const execution = {
+    status: 'completed',
+    vulnerabilities,
+    logs: executionLogs,
+    timestamp: new Date().toISOString()
+  };
+
+  // Calculate score
+  const baseScore = 100;
+  // Penalty based on severity
+  const penalties = { critical: 20, high: 10, medium: 5, low: 2, info: 0 };
+  const totalPenalty = vulnerabilities.reduce((acc, v) => acc + (penalties[v.severity] || 0), 0);
+  const score = Math.max(0, baseScore - totalPenalty); 
+
+  const resultData = { 
+    execution, 
+    score, 
+    vulnerabilities, 
+    riskLevel: score < 40 ? 'Critical' : score < 70 ? 'High' : score < 90 ? 'Medium' : 'Low',
+    timestamp: new Date().toISOString(),
+    target: state.discovery?.path || process.cwd(),
+    scan_id: `OMEN-${Date.now()}`
+  };
+
+  await saveState(resultData);
+  console.log(chalk.green('\n[✔] Execution finished. Found', vulnerabilities.length, 'issues.'));
+  console.log(chalk.bold(`Security Score: ${score}/100 (${resultData.riskLevel})`));
+}
+
+export async function report() {
+  console.log(chalk.bold.cyan('\n--- Phase 4: Reporting ---'));
+  const state = await loadState();
+  await generateOutputs(state);
+  console.log(chalk.green('[✔] Reports generated in /omen-reports/'));
+}
+
+export async function verify() {
+  console.log(chalk.bold.cyan('\n--- Phase 5: Verification ---'));
+  const oldState = await loadState();
+  
+  // Re-run execution to get fresh results
+  await execute(); 
+  
+  const diff = await compareWithPreviousScan();
+  
+  if (!diff) {
+    console.log(chalk.yellow('Not enough history to perform a diff verification.'));
+    return;
+  }
+
+  console.log(chalk.bold('\nVerification Results:'));
+  
+  if (diff.fixedVulnerabilities.length > 0) {
+    console.log(chalk.green(`[✔] ${diff.fixedVulnerabilities.length} Issues RESOLVED:`));
+    diff.fixedVulnerabilities.forEach(v => console.log(`    - ${v.title || v.description}`));
+  } else {
+    console.log(chalk.red('[!] No previously found issues were resolved.'));
+  }
+
+  if (diff.newVulnerabilities.length > 0) {
+    console.log(chalk.yellow(`[+] ${diff.newVulnerabilities.length} NEW Issues found:`));
+    diff.newVulnerabilities.forEach(v => console.log(`    - ${v.title || v.description}`));
+  }
+
+  if (diff.scoreDiff !== 0) {
+    const color = diff.scoreDiff > 0 ? chalk.green : chalk.red;
+    const sign = diff.scoreDiff > 0 ? '+' : '';
+    console.log(color(`\nSecurity Score Change: ${sign}${diff.scoreDiff} points`));
+  }
+
+  await saveState({
+    verification: {
+      timestamp: new Date().toISOString(),
+      resolved_count: diff.fixedVulnerabilities.length,
+      new_count: diff.newVulnerabilities.length,
+      score_change: diff.scoreDiff
+    }
+  });
+}

package/core/generator.js

@@ -2,33 +2,66 @@ import fs from 'fs/promises';
 import chalk from 'chalk';
 import path from 'path';
 import { getMassiveAIProtocol } from './ai-protocol.js';
+import { generateMarkdownReport } from './reporters/markdown-reporter.js';
+import { generateFixPlan } from './reporters/fix-plan-reporter.js';
 
 export async function generateOutputs(scanData) {
-  const cwd = process.cwd();
-  const outputDir = path.join(cwd, 'omen-reports');
-  const historyDir = path.join(cwd, '.omen', 'history');
+  const outputDir = path.join(process.cwd(), 'omen-reports');
+  const historyDir = path.join(process.cwd(), '.omen', 'history');
 
   // Criar as pastas se não existirem
   try {
     await fs.mkdir(outputDir, { recursive: true });
     await fs.mkdir(historyDir, { recursive: true });
-  } catch (err) {
-    console.error(chalk.red(`Failed to create output directories: ${err.message}`));
-    return;
-  }
+  } catch (err) {}
 
   const jsonContent = JSON.stringify(scanData, null, 2);
-  
+
   // JSON Report
   const jsonReportPath = path.join(outputDir, 'omen-report.json');
   await fs.writeFile(jsonReportPath, jsonContent);
+  console.log(chalk.cyan(`\n[Generator] Outputs saved in:`));
   console.log(` /omen-reports/omen-report.json`);
   
   // TXT Report
   const txtReportPath = path.join(outputDir, 'omen-report.txt');
-  const txtContent = `OMEN SECURITY REPORT\n\nTarget: ${scanData.target}\nScore: ${scanData.score}\nRisk: ${scanData.riskLevel}\n\nVulnerabilities:\n${scanData.vulnerabilities.map(v => `- ${v.description}`).join('\n')}`;
+  let txtContent = `OMEN SECURITY REPORT\n`;
+  txtContent += `====================\n`;
+  txtContent += `Target: ${scanData.target || 'Local Project'}\n`;
+  txtContent += `Scan ID: ${scanData.scan_id || 'N/A'}\n`;
+  txtContent += `Date: ${scanData.timestamp || new Date().toISOString()}\n`;
+  txtContent += `Score: ${scanData.score || 0}/100\n`;
+  txtContent += `Risk Level: ${scanData.riskLevel || 'Unknown'}\n\n`;
+
+  txtContent += `VULNERABILITIES FOUND:\n`;
+  txtContent += `----------------------\n`;
+  
+  const vulnerabilities = scanData.vulnerabilities || [];
+  if (vulnerabilities.length === 0) {
+    txtContent += `No vulnerabilities detected.\n`;
+  } else {
+    vulnerabilities.forEach(v => {
+      txtContent += `[${v.severity?.toUpperCase() || 'INFO'}] ${v.title || v.description}\n`;
+      txtContent += `Category: ${v.category || 'N/A'} | Confidence: ${v.confidence || 'medium'}\n`;
+      txtContent += `Description: ${v.description}\n`;
+      if (v.remediation) txtContent += `Remediation: ${v.remediation}\n`;
+      txtContent += `----------------------\n`;
+    });
+  }
   await fs.writeFile(txtReportPath, txtContent);
   console.log(` /omen-reports/omen-report.txt`);
+
+  // Markdown Report
+  const mdReportPath = path.join(outputDir, 'omen-report.md');
+  const mdContent = generateMarkdownReport(scanData);
+  await fs.writeFile(mdReportPath, mdContent);
+  console.log(` /omen-reports/omen-report.md`);
+
+  // Fix Plan
+  const fixPlanPath = path.join(outputDir, 'omen-fix-plan.md');
+  const fixPlanContent = generateFixPlan(scanData);
+  await fs.writeFile(fixPlanPath, fixPlanContent);
+  console.log(` /omen-reports/omen-fix-plan.md`);
   
   // AI Protocol
   const aiReportPath = path.join(outputDir, 'omen-ai.txt');
@@ -37,6 +70,5 @@ export async function generateOutputs(scanData) {
 
   // Save historical report
   const timestamp = new Date().toISOString().replace(/:/g, '-');
-  const historyReportPath = path.join(historyDir, `omen-report-${timestamp}.json`);
-  await fs.writeFile(historyReportPath, jsonContent);
+  await fs.writeFile(path.join(historyDir, `report-${timestamp}.json`), jsonContent);
 }