deepdebug-local-agent 0.3.1

package/src/server.js

@@ -0,0 +1,4565 @@
+import express from "express";
+import cors from "cors";
+import bodyParser from "body-parser";
+import path from "path";
+import os from "os";
+import fs from "fs";
+const fsPromises = fs.promises;
+import { exec } from "child_process";
+import { promisify } from "util";
+import { EventEmitter } from "events";
+import { exists, listRecursive, readFile, writeFile } from "./fs-utils.js";
+import { detectProject, readText } from "./detectors.js";
+import { detectPort } from "./ports.js";
+import { compileAndTest, run } from "./exec-utils.js";
+import { applyUnifiedDiff } from "./patch.js";
+import { WorkspaceScanner } from "./workspace/scanner.js";
+import { FileReader } from "./workspace/file-reader.js";
+import { LanguageDetector } from "./detectors/language-detector.js";
+import { FrameworkDetector } from "./detectors/framework-detector.js";
+import { ServiceDetector } from "./detectors/service-detector.js";
+import { ProcessManager } from "./workspace/process-manager.js";
+import { ControllerAnalyzer } from "./analyzers/controller-analyzer.js";
+import { DTOAnalyzer } from "./analyzers/dto-analyzer.js";
+import { ConfigAnalyzer } from "./analyzers/config-analyzer.js";
+import { WorkspaceManager } from "./workspace-manager.js";
+import { startMCPHttpServer } from "./mcp-http-server.js";
+
+const execAsync = promisify(exec);
+
+// ============================================
+// 🧠 AI VIBE CODING ENGINE
+// Sistema universal de auto-healing que usa AI
+// para resolver QUALQUER erro automaticamente
+// ============================================
+
+class AIVibeCodingEngine extends EventEmitter {
+    constructor(processManager, getWorkspaceRoot) {
+        super();
+        this.processManager = processManager;
+        this.getWorkspaceRoot = getWorkspaceRoot;
+        this.gatewayUrl = process.env.GATEWAY_URL || 'http://localhost:8085';
+        this.maxRetries = 3;
+        this.isActive = true;
+
+        this.errorHistory = [];
+        this.fixHistory = [];
+        this.pendingFixes = [];
+        this.currentSession = null;
+        this.lastSuccessfulConfig = null;
+
+        console.log('🧠 [AI-Engine] Vibe Coding Engine initialized');
+        this.setupErrorMonitoring();
+    }
+
+    setupErrorMonitoring() {
+        this.processManager.on('log', async ({ serviceId, message, type }) => {
+            if (this.isActive && message && this.isError(message)) {
+                await this.handleRuntimeError(serviceId, message, type);
+            }
+        });
+
+        this.processManager.on('stopped', async ({ serviceId, code, signal }) => {
+            if (this.isActive && code !== 0 && code !== null) {
+                console.log(`🧠 [AI-Engine] Process ${serviceId} crashed (code: ${code})`);
+                if (this.pendingFixes.length > 0) {
+                    console.log(`💡 [AI-Engine] ${this.pendingFixes.length} fixes pending`);
+                }
+            }
+        });
+    }
+
+    isError(message) {
+        if (!message || typeof message !== 'string') return false;
+        const errorPatterns = [
+            /exception/i,
+            /error.*failed/i,
+            /failed.*to.*start/i,
+            /connection.*refused/i,
+            /unable.*to.*connect/i,
+            /port.*in.*use/i,
+            /address.*already.*in.*use/i,
+            /compilation.*failed/i,
+            /syntax.*error/i,
+            /null.*pointer/i,
+            /class.*not.*found/i,
+            /no.*such.*file/i,
+            /permission.*denied/i,
+            /module.*not.*found/i,
+            /cannot.*find.*module/i,
+            /application.*run.*failed/i,
+            /bean.*creation.*exception/i,
+            /hikaripool.*exception/i,  // Só exceções, não "HikariPool-1 - Starting"
+            /jdbc.*exception/i,
+            /datasource.*failed/i
+        ];
+
+        // Excluir falsos positivos (linhas normais que contêm palavras de erro)
+        const falsePositives = [
+            /hikaripool.*start/i,      // "HikariPool-1 - Starting..." é normal
+            /hikaripool.*completed/i,  // "HikariPool-1 - Start completed" é normal
+            /no active profile/i,      // "No active profile set" é normal
+            /exposing.*endpoint/i,     // Linha normal de startup
+            /started.*application/i,   // "Started PurePilatesCoreApplication" é sucesso!
+            /tomcat started/i          // "Tomcat started on port" é sucesso!
+        ];
+
+        // Se match com falso positivo, não é erro
+        if (falsePositives.some(p => p.test(message))) {
+            return false;
+        }
+
+        return errorPatterns.some(p => p.test(message));
+    }
+
+    classifyError(message) {
+        if (!message) return { type: 'unknown', severity: 'low', autoFixable: false };
+
+        const classifications = {
+            'database_connection': {
+                patterns: [/connection.*refused.*\d{4}/i, /jdbc/i, /hikari/i, /sql.*server/i, /mysql/i, /postgres/i],
+                severity: 'high', autoFixable: true
+            },
+            'port_conflict': {
+                patterns: [/port.*in.*use/i, /address.*already/i, /eaddrinuse/i],
+                severity: 'medium', autoFixable: true
+            },
+            'compilation': {
+                patterns: [/compilation.*failed/i, /syntax.*error/i, /cannot.*resolve/i],
+                severity: 'high', autoFixable: true
+            },
+            'dependency_missing': {
+                patterns: [/class.*not.*found/i, /module.*not.*found/i],
+                severity: 'high', autoFixable: true
+            },
+            'configuration': {
+                patterns: [/no.*qualifying.*bean/i, /could.*not.*autowire/i],
+                severity: 'medium', autoFixable: true
+            }
+        };
+
+        for (const [type, config] of Object.entries(classifications)) {
+            if (config.patterns.some(p => p.test(message))) {
+                return { type, ...config };
+            }
+        }
+        return { type: 'unknown', severity: 'low', autoFixable: false };
+    }
+
+    async handleRuntimeError(serviceId, errorMessage, type) {
+        const classification = this.classifyError(errorMessage);
+
+        const recent = this.errorHistory.find(e =>
+            e.classification.type === classification.type &&
+            Date.now() - e.timestamp < 5000
+        );
+        if (recent) return;
+
+        const entry = {
+            id: `err_${Date.now()}`,
+            serviceId, message: errorMessage, classification,
+            timestamp: Date.now()
+        };
+
+        this.errorHistory.push(entry);
+        if (this.errorHistory.length > 200) this.errorHistory = this.errorHistory.slice(-200);
+
+        console.log(`🧠 [AI-Engine] Error: ${classification.type} (${classification.severity})`);
+
+        if (classification.autoFixable) {
+            const fix = this.getQuickFix(classification.type, errorMessage);
+            if (fix) {
+                console.log(`💡 [AI-Engine] Quick fix: ${fix.description}`);
+                this.pendingFixes.push({ errorId: entry.id, fix, timestamp: Date.now() });
+            }
+        }
+    }
+
+    getQuickFix(errorType, message) {
+        const fixes = {
+            'database_connection': {
+                description: 'Switch to test/local profile with embedded DB',
+                action: 'change_profile',
+                profiles: ['test', 'local', 'h2']
+            },
+            'port_conflict': {
+                description: 'Use different port',
+                action: 'change_port',
+                portIncrement: 1
+            },
+            'compilation': {
+                description: 'Recompile project',
+                action: 'recompile'
+            },
+            'dependency_missing': {
+                description: 'Reinstall dependencies',
+                action: 'reinstall_dependencies'
+            },
+            'configuration': {
+                description: 'Use default config',
+                action: 'use_default_config'
+            }
+        };
+        return fixes[errorType] || null;
+    }
+
+    async startWithAutoHealing(config) {
+        console.log('🧠 [AI-Engine] Starting with auto-healing...');
+
+        this.currentSession = {
+            startTime: Date.now(),
+            attempts: [],
+            originalConfig: { ...config }
+        };
+
+        let currentConfig = { ...config };
+        let attempts = 0;
+        let lastError = null;
+
+        while (attempts < this.maxRetries) {
+            attempts++;
+            console.log(`\n🔄 [AI-Engine] Attempt ${attempts}/${this.maxRetries}`);
+
+            if (attempts > 1 && this.pendingFixes.length > 0) {
+                const fix = this.pendingFixes.shift();
+                console.log(`💡 Applying: ${fix.fix.description}`);
+                currentConfig = this.applyFix(currentConfig, fix.fix);
+            }
+
+            if (currentConfig.recompile) {
+                console.log('🔨 Recompiling...');
+                await this.recompile();
+                delete currentConfig.recompile;
+            }
+
+            const result = await this.attemptStart(currentConfig);
+
+            this.currentSession.attempts.push({
+                attempt: attempts,
+                config: { ...currentConfig },
+                result: result.success ? 'success' : 'failed',
+                error: result.error
+            });
+
+            if (result.success) {
+                console.log(`\n✅ [AI-Engine] Success after ${attempts} attempt(s)`);
+                this.lastSuccessfulConfig = { ...currentConfig };
+
+                if (attempts > 1) {
+                    this.fixHistory.push({
+                        original: this.currentSession.originalConfig,
+                        fixed: currentConfig,
+                        timestamp: Date.now()
+                    });
+                }
+
+                return { ok: true, attempts, config: currentConfig, autoHealed: attempts > 1 };
+            }
+
+            lastError = result.error;
+            console.log(`❌ Attempt ${attempts} failed: ${lastError?.substring(0, 100)}...`);
+
+            const fix = this.getFix(result.error, currentConfig);
+            if (fix) {
+                console.log(`💡 Fix: ${fix.description}`);
+                currentConfig = this.applyFix(currentConfig, fix);
+            } else {
+                const ai = await this.analyzeWithAI('startup', lastError, currentConfig);
+                if (ai?.newConfig) {
+                    console.log(`🤖 AI: ${ai.suggestion}`);
+                    currentConfig = ai.newConfig;
+                } else {
+                    break;
+                }
+            }
+        }
+
+        console.log(`\n❌ [AI-Engine] Failed after ${attempts} attempts`);
+        return { ok: false, attempts, error: lastError, config: currentConfig };
+    }
+
+    async attemptStart(config) {
+        return new Promise(async (resolve) => {
+            const logs = [];
+            let startupError = null;
+            let resolved = false;
+
+            const cleanup = () => {
+                this.processManager.off('log', logListener);
+                this.processManager.off('started', startedListener);
+                this.processManager.off('stopped', stoppedListener);
+                clearTimeout(timeout);
+            };
+
+            // Detectar sucesso do Spring Boot nos logs
+            const isStartupSuccess = (message) => {
+                if (!message) return false;
+                return /started.*in.*seconds/i.test(message) ||
+                    /tomcat started on port/i.test(message) ||
+                    /started.*application/i.test(message);
+            };
+
+            const logListener = ({ serviceId, message }) => {
+                if (serviceId === 'test-local' && message) {
+                    logs.push(message);
+
+                    // Detectar sucesso nos logs do Spring Boot
+                    if (isStartupSuccess(message) && !resolved) {
+                        console.log(`✅ [AI-Engine] Detected startup success: ${message.substring(0, 80)}...`);
+                        resolved = true;
+                        cleanup();
+                        resolve({ success: true, logs });
+                        return;
+                    }
+
+                    if (this.isError(message) && !startupError) {
+                        startupError = message;
+                    }
+                }
+            };
+
+            const startedListener = ({ serviceId }) => {
+                if (serviceId === 'test-local' && !resolved) {
+                    resolved = true; cleanup();
+                    resolve({ success: true, logs });
+                }
+            };
+
+            const stoppedListener = ({ serviceId, code }) => {
+                if (serviceId === 'test-local' && code !== 0 && !resolved) {
+                    resolved = true; cleanup();
+                    resolve({ success: false, error: startupError || `Exit code ${code}`, logs });
+                }
+            };
+
+            const timeout = setTimeout(() => {
+                if (!resolved) {
+                    resolved = true; cleanup();
+                    resolve(startupError
+                        ? { success: false, error: startupError, logs }
+                        : { success: true, logs, partial: true }
+                    );
+                }
+            }, 90000);
+
+            this.processManager.on('log', logListener);
+            this.processManager.on('started', startedListener);
+            this.processManager.on('stopped', stoppedListener);
+
+            try {
+                await this.processManager.start('test-local', config);
+            } catch (err) {
+                if (!resolved) {
+                    resolved = true; cleanup();
+                    resolve({ success: false, error: err.message, logs });
+                }
+            }
+        });
+    }
+
+    getFix(error, config) {
+        const classification = this.classifyError(error);
+        return this.getQuickFix(classification.type, error);
+    }
+
+    applyFix(config, fix) {
+        const newConfig = { ...config };
+
+        switch (fix.action) {
+            case 'change_profile':
+                const profiles = fix.profiles || ['test', 'local'];
+                const next = profiles.find(p => p !== config.profile) || profiles[0];
+                newConfig.profile = next;
+                newConfig.args = this.updateArgs(config.args, 'profile', next);
+                newConfig.env = { ...config.env, SPRING_PROFILES_ACTIVE: next };
+                console.log(`   → Profile: ${config.profile} → ${next}`);
+                break;
+
+            case 'change_port':
+                const newPort = (config.port || 8080) + 1;
+                newConfig.port = newPort;
+                newConfig.args = this.updateArgs(config.args, 'port', newPort);
+                newConfig.env = { ...config.env, SERVER_PORT: String(newPort), PORT: String(newPort) };
+                console.log(`   → Port: ${config.port} → ${newPort}`);
+                break;
+
+            case 'recompile':
+                newConfig.recompile = true;
+                break;
+
+            case 'reinstall_dependencies':
+                newConfig.recompile = true;
+                break;
+
+            case 'use_default_config':
+                newConfig.profile = null;
+                newConfig.args = this.removeArg(config.args, 'profile');
+                delete newConfig.env?.SPRING_PROFILES_ACTIVE;
+                break;
+        }
+
+        return newConfig;
+    }
+
+    async analyzeWithAI(errorType, error, config) {
+        try {
+            const workspaceRoot = this.getWorkspaceRoot();
+            const configFiles = this.collectConfigFiles(workspaceRoot);
+
+            const response = await fetch(`${this.gatewayUrl}/api/test-local/analyze-startup-error`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'X-Tenant-ID': 'default' },
+                body: JSON.stringify({
+                    context: { workspace: workspaceRoot, error, configFiles },
+                    currentConfig: config
+                }),
+                signal: AbortSignal.timeout(30000)
+            });
+
+            if (response.ok) return await response.json();
+        } catch (err) {
+            console.log(`⚠️ [AI-Engine] AI unavailable: ${err.message}`);
+        }
+
+        return this.localFallback(errorType, error, config);
+    }
+
+    localFallback(errorType, error, config) {
+        const tried = this.currentSession?.attempts?.map(a => a.config?.profile).filter(Boolean) || [];
+        const all = ['test', 'local', 'h2', 'dev'];
+        const next = all.find(p => !tried.includes(p));
+
+        if (next) {
+            return {
+                suggestion: `Trying ${next} profile`,
+                newConfig: {
+                    ...config,
+                    profile: next,
+                    args: this.updateArgs(config.args, 'profile', next),
+                    env: { ...config.env, SPRING_PROFILES_ACTIVE: next }
+                }
+            };
+        }
+        return null;
+    }
+
+    async recompile() {
+        const workspaceRoot = this.getWorkspaceRoot();
+        if (!workspaceRoot) return { success: false };
+
+        try {
+            const meta = await detectProject(workspaceRoot);
+            let cmd = meta.buildTool === 'maven' ? 'mvn clean install -DskipTests' :
+                meta.buildTool === 'gradle' ? './gradlew clean build -x test' : null;
+
+            if (cmd) {
+                await execAsync(cmd, { cwd: workspaceRoot, timeout: 300000 });
+            }
+            return { success: true };
+        } catch (err) {
+            return { success: false, error: err.message };
+        }
+    }
+
+    collectConfigFiles(workspaceRoot) {
+        if (!workspaceRoot) return {};
+        const configs = {};
+        const paths = [
+            'src/main/resources/application.yml',
+            'src/main/resources/application-dev.yml',
+            'src/main/resources/application-local.yml',
+            'src/main/resources/application-test.yml',
+            'pom.xml', 'package.json', '.env'
+        ];
+
+        for (const p of paths) {
+            const fullPath = path.join(workspaceRoot, p);
+            if (fs.existsSync(fullPath)) {
+                try {
+                    configs[p] = fs.readFileSync(fullPath, 'utf8').substring(0, 5000);
+                } catch (e) {}
+            }
+        }
+        return configs;
+    }
+
+    updateArgs(args, type, value) {
+        if (!args) args = [];
+        let newArgs = [...args];
+
+        if (type === 'profile') {
+            newArgs = newArgs.filter(a => !a.includes('spring.profiles.active'));
+            const jarIdx = newArgs.findIndex(a => a === '-jar');
+            if (jarIdx >= 0) {
+                newArgs.splice(jarIdx, 0, `-Dspring.profiles.active=${value}`);
+            } else {
+                newArgs.unshift(`-Dspring.profiles.active=${value}`);
+            }
+        }
+
+        if (type === 'port') {
+            newArgs = newArgs.filter(a => !a.includes('server.port'));
+            newArgs.push(`--server.port=${value}`);
+        }
+
+        return newArgs;
+    }
+
+    removeArg(args, type) {
+        if (!args) return [];
+        if (type === 'profile') {
+            return args.filter(a => !a.includes('spring.profiles.active'));
+        }
+        return args;
+    }
+
+    getStatus() {
+        return {
+            active: this.isActive,
+            gatewayUrl: this.gatewayUrl,
+            maxRetries: this.maxRetries,
+            errors: this.errorHistory.length,
+            fixes: this.fixHistory.length,
+            pending: this.pendingFixes.length,
+            lastConfig: this.lastSuccessfulConfig
+        };
+    }
+
+    setActive(active) {
+        this.isActive = active;
+        console.log(`🧠 [AI-Engine] ${active ? 'ENABLED' : 'DISABLED'}`);
+    }
+
+    clearHistory() {
+        this.errorHistory = [];
+        this.fixHistory = [];
+        this.pendingFixes = [];
+    }
+}
+
+// Instância global do AI Engine
+let aiEngine = null;
+
+const app = express();
+
+// ✅ FIXED: Support Cloud Run PORT environment variable (GCP uses PORT)
+const PORT = process.env.PORT || process.env.LOCAL_AGENT_PORT || 5055;
+
+// ✅ FIXED: Allow CORS from Cloud Run and local development
+app.use(cors({
+    origin: [
+        "http://localhost:3010",
+        "http://localhost:3000",
+        "http://localhost:8085",
+        "http://127.0.0.1:3010",
+        "http://127.0.0.1:3000",
+        "http://127.0.0.1:8085",
+        // Cloud Run URLs (regex patterns)
+        /https:\/\/.*\.run\.app$/,
+        /https:\/\/.*\.web\.app$/
+    ],
+    methods: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
+    allowedHeaders: ["Content-Type", "Authorization", "X-Tenant-ID"],
+    credentials: true
+}));
+
+// ✅ Handle preflight requests explicitly
+app.options('*', cors());
+
+app.use(bodyParser.json({ limit: "50mb" }));
+
+// 🔧 DEFAULT WORKSPACE - Define o workspace padrão
+// Pode ser sobrescrito via variável de ambiente ou POST /workspace/open
+const DEFAULT_WORKSPACE = process.env.DEFAULT_WORKSPACE || '/Users/macintosh/IdeaProjects/pure-core-ms';
+
+let WORKSPACE_ROOT = fs.existsSync(DEFAULT_WORKSPACE) ? DEFAULT_WORKSPACE : null;
+if (WORKSPACE_ROOT) {
+    console.log(`📁 Default workspace: ${WORKSPACE_ROOT}`);
+}
+
+let DETECTED_SERVICES = [];
+const processManager = new ProcessManager();
+const wsManager = new WorkspaceManager();
+const MCP_PORT = process.env.MCP_PORT || 5056;
+
+// 🧠 Inicializar AI Vibe Coding Engine
+aiEngine = new AIVibeCodingEngine(processManager, () => WORKSPACE_ROOT);
+
+// ============================================
+// 🆕 BACKUP STORAGE (Sprint 1.3)
+// In-memory backup storage with configurable max size
+// ============================================
+const BACKUPS = new Map();
+const MAX_BACKUPS = 50;
+const BACKUP_INDEX_PATH = path.join(os.tmpdir(), 'deepdebug-backups-index.json');
+
+/**
+ * Persist backup index to disk so diffs survive server restarts.
+ * Only saves the index (backupId → files paths), not the file contents.
+ * File contents are read from the backup directory on disk.
+ */
+function saveBackupIndex() {
+    try {
+        const index = {};
+        for (const [id, backup] of BACKUPS.entries()) {
+            index[id] = {
+                timestamp: backup.timestamp,
+                incidentId: backup.incidentId,
+                files: backup.files.map(f => ({
+                    path: f.path,
+                    backupPath: f.backupPath || null // path to backup copy on disk
+                }))
+            };
+        }
+        fs.writeFileSync(BACKUP_INDEX_PATH, JSON.stringify(index, null, 2));
+    } catch (e) {
+        console.warn('Could not save backup index:', e.message);
+    }
+}
+
+function loadBackupIndex() {
+    try {
+        if (fs.existsSync(BACKUP_INDEX_PATH)) {
+            const index = JSON.parse(fs.readFileSync(BACKUP_INDEX_PATH, 'utf8'));
+            for (const [id, backup] of Object.entries(index)) {
+                // Restore backup with file contents read from disk
+                const files = [];
+                for (const file of backup.files) {
+                    if (file.backupPath && fs.existsSync(file.backupPath)) {
+                        files.push({
+                            path: file.path,
+                            content: fs.readFileSync(file.backupPath, 'utf8'),
+                            backupPath: file.backupPath
+                        });
+                    }
+                }
+                if (files.length > 0) {
+                    BACKUPS.set(id, {
+                        timestamp: backup.timestamp,
+                        incidentId: backup.incidentId,
+                        files
+                    });
+                }
+            }
+            console.log(`📦 Restored ${BACKUPS.size} backups from disk`);
+        }
+    } catch (e) {
+        console.warn('Could not load backup index:', e.message);
+    }
+}
+
+// Load backups on startup
+loadBackupIndex();
+
+// Event listeners do ProcessManager
+processManager.on("started", ({ serviceId }) => {
+    console.log(`✅ Service ${serviceId} started successfully`);
+    updateServiceStatus(serviceId, "running");
+    addServerLog("info", `Service ${serviceId} started successfully`);
+});
+
+processManager.on("stopped", ({ serviceId }) => {
+    console.log(`ℹ️ Service ${serviceId} stopped`);
+    updateServiceStatus(serviceId, "stopped");
+    addServerLog("info", `Service ${serviceId} stopped`);
+});
+
+processManager.on("error", ({ serviceId, error }) => {
+    console.error(`❌ Service ${serviceId} error: ${error}`);
+    updateServiceStatus(serviceId, "failed");
+    addServerLog("error", `Service ${serviceId} error: ${error}`);
+});
+
+processManager.on("log", ({ serviceId, message, type }) => {
+    // Capture stdout/stderr from service
+    console.log(`[${serviceId}] ${message}`);
+    addServerLog(type || "stdout", message);
+});
+
+function addServerLog(type, line) {
+    const log = {
+        type: type,
+        line: line,
+        timestamp: Date.now()
+    };
+
+    TEST_LOCAL_STATE.serverLogs.push(log);
+
+    // Keep only last 1000 logs (circular buffer)
+    if (TEST_LOCAL_STATE.serverLogs.length > 1000) {
+        TEST_LOCAL_STATE.serverLogs.shift();
+    }
+}
+
+function updateServiceStatus(serviceId, status) {
+    const service = DETECTED_SERVICES.find(s => s.id === serviceId);
+    if (service) {
+        service.status = status;
+    }
+}
+
+/** Health */
+app.get("/health", (_req, res) => {
+    res.json({
+        status: "ok",
+        workspace: WORKSPACE_ROOT || null,
+        services: DETECTED_SERVICES.length,
+        mcpPort: MCP_PORT,
+        openWorkspaces: wsManager.count,
+        workspaces: wsManager.list().map(w => ({
+            id: w.id, root: w.root, language: w.projectInfo?.language
+        }))
+    });
+});
+
+/** Define/abre o workspace local */
+app.post("/workspace/open", async (req, res) => {
+    const { root, workspaceId } = req.body || {};
+    if (!root) return res.status(400).json({ error: "root is required" });
+    const abs = path.resolve(root);
+    if (!(await exists(abs))) return res.status(404).json({ error: "path not found" });
+
+    WORKSPACE_ROOT = abs;
+
+    // Registar no WorkspaceManager (multi-workspace support)
+    const wsId = workspaceId || "default";
+    try {
+        await wsManager.open(wsId, abs);
+    } catch (err) {
+        console.warn(`⚠️ WorkspaceManager open failed (non-fatal): ${err.message}`);
+    }
+
+    const meta = await detectProject(WORKSPACE_ROOT);
+    const port = await detectPort(WORKSPACE_ROOT);
+    res.json({ ok: true, root: WORKSPACE_ROOT, workspaceId: wsId, meta, port });
+});
+
+/** Info do workspace */
+app.get("/workspace/info", async (_req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+    const meta = await detectProject(WORKSPACE_ROOT);
+    const port = await detectPort(WORKSPACE_ROOT);
+    res.json({ root: WORKSPACE_ROOT, meta, port });
+});
+
+/** Scan completo do workspace */
+app.get("/workspace/scan", async (_req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+
+    try {
+        const scanner = new WorkspaceScanner(WORKSPACE_ROOT);
+        const structure = await scanner.scan();
+        res.json(structure);
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+/** Análise completa: language + framework */
+app.get("/workspace/analyze", async (_req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+
+    try {
+        const scanner = new WorkspaceScanner(WORKSPACE_ROOT);
+        const structure = await scanner.scan();
+
+        const languageDetector = new LanguageDetector(structure.files);
+        const languageInfo = languageDetector.detect();
+
+        const fileReader = new FileReader(WORKSPACE_ROOT);
+        const frameworkDetector = new FrameworkDetector(
+            languageInfo.primary,
+            structure.files,
+            fileReader
+        );
+        const frameworkInfo = await frameworkDetector.detect();
+
+        res.json({
+            workspace: WORKSPACE_ROOT,
+            language: languageInfo,
+            framework: frameworkInfo,
+            stats: structure.metadata,
+            analyzedAt: new Date().toISOString()
+        });
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+/** Lê conteúdo de arquivo específico */
+app.get("/workspace/file-content", async (req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+
+    const { path: relativePath } = req.query;
+    if (!relativePath) return res.status(400).json({ error: "path query param required" });
+
+    try {
+        const reader = new FileReader(WORKSPACE_ROOT);
+        const file = await reader.read(relativePath);
+        res.json(file);
+    } catch (err) {
+        res.status(404).json({ error: "file not found", details: err.message });
+    }
+});
+
+/** Lê múltiplos arquivos */
+app.post("/workspace/batch-read", async (req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+
+    const { paths } = req.body || {};
+    if (!paths || !Array.isArray(paths)) {
+        return res.status(400).json({ error: "paths array required" });
+    }
+
+    try {
+        const reader = new FileReader(WORKSPACE_ROOT);
+        const files = await reader.readMultiple(paths);
+        res.json(files);
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+// ============================================
+// 🆕 FILE VALIDATION ENDPOINTS (Enhanced Analysis)
+// ============================================
+
+/**
+ * GET /workspace/file-exists
+ * Checks if a file exists in the workspace
+ */
+app.get("/workspace/file-exists", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({ error: "workspace not set" });
+    }
+
+    const { path: relativePath } = req.query;
+    if (!relativePath) {
+        return res.status(400).json({ error: "path query param required" });
+    }
+
+    try {
+        const fullPath = path.join(WORKSPACE_ROOT, relativePath);
+        const fileExists = await exists(fullPath);
+
+        console.log(`🔍 [file-exists] ${relativePath} -> ${fileExists ? 'EXISTS' : 'NOT FOUND'}`);
+
+        res.json({
+            ok: true,
+            exists: fileExists,
+            path: relativePath,
+            fullPath: fullPath
+        });
+    } catch (err) {
+        console.error(`❌ [file-exists] Error:`, err.message);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * POST /workspace/validate-paths
+ * Validates multiple file paths at once
+ */
+app.post("/workspace/validate-paths", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({ error: "workspace not set" });
+    }
+
+    const { paths: pathList } = req.body || {};
+    if (!pathList || !Array.isArray(pathList)) {
+        return res.status(400).json({ error: "paths array required in body" });
+    }
+
+    try {
+        const results = await Promise.all(
+            pathList.map(async (relativePath) => {
+                const fullPath = path.join(WORKSPACE_ROOT, relativePath);
+                const fileExists = await exists(fullPath);
+                return { path: relativePath, exists: fileExists };
+            })
+        );
+
+        const allExist = results.every(r => r.exists);
+        const missingPaths = results.filter(r => !r.exists).map(r => r.path);
+
+        console.log(`🔍 [validate-paths] Checked ${pathList.length} paths, ${missingPaths.length} missing`);
+
+        res.json({
+            ok: true,
+            results,
+            allExist,
+            missingPaths,
+            totalChecked: pathList.length
+        });
+    } catch (err) {
+        console.error(`❌ [validate-paths] Error:`, err.message);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * POST /workspace/search-file
+ * Searches for a file by name in the workspace
+ *
+ * FIXED: Handle both string arrays and object arrays from listRecursive
+ */
+app.post("/workspace/search-file", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({ error: "workspace not set" });
+    }
+
+    const { fileName } = req.body || {};
+    if (!fileName) {
+        return res.status(400).json({ error: "fileName required in body" });
+    }
+
+    try {
+        console.log(`🔍 [search-file] Searching for: ${fileName}`);
+
+        const rawFiles = await listRecursive(WORKSPACE_ROOT, {
+            maxDepth: 15,
+            includeHidden: false,
+            extensions: null
+        });
+
+        // 🆕 FIXED: Normalize files to string paths
+        // listRecursive may return strings OR objects like {path: 'xxx', name: 'yyy'}
+        const allFiles = rawFiles.map(f => {
+            if (typeof f === 'string') return f;
+            if (f && typeof f === 'object' && f.path) return f.path;
+            if (f && typeof f === 'object' && f.name) return f.name;
+            return String(f);
+        }).filter(f => f && typeof f === 'string');
+
+        console.log(`📁 [search-file] Scanning ${allFiles.length} files`);
+
+        // Strategy 1: Exact path match
+        let foundPath = allFiles.find(f => f.endsWith('/' + fileName) || f === fileName);
+
+        // Strategy 2: Case-insensitive basename match
+        if (!foundPath) {
+            const fileNameLower = fileName.toLowerCase();
+            foundPath = allFiles.find(f => {
+                const basename = path.basename(f);
+                return basename.toLowerCase() === fileNameLower;
+            });
+        }
+
+        // Strategy 3: Partial name match (without extension)
+        if (!foundPath) {
+            const fileNameWithoutExt = fileName.replace(/\.[^.]+$/, '').toLowerCase();
+            foundPath = allFiles.find(f => {
+                const basename = path.basename(f).toLowerCase();
+                return basename.includes(fileNameWithoutExt);
+            });
+        }
+
+        // Strategy 4: Package-based search (for Java files like com.pure.core.SomeClass)
+        if (!foundPath && fileName.includes('.')) {
+            const packagePath = fileName.replace(/\./g, '/');
+            foundPath = allFiles.find(f => f.includes(packagePath));
+        }
+
+        if (foundPath) {
+            console.log(`✅ [search-file] Found: ${foundPath}`);
+            res.json({ ok: true, found: true, path: foundPath, fileName });
+        } else {
+            console.log(`⚠️ [search-file] Not found: ${fileName}`);
+            res.json({ ok: true, found: false, fileName, searchedFiles: allFiles.length });
+        }
+    } catch (err) {
+        console.error(`❌ [search-file] Error:`, err.message);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * POST /workspace/search-by-content
+ * Searches for files containing specific terms
+ *
+ * FIXED: Handle both string arrays and object arrays from listRecursive
+ */
+app.post("/workspace/search-by-content", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({ error: "workspace not set" });
+    }
+
+    const { terms, extensions, maxResults = 10 } = req.body || {};
+
+    if (!terms || !Array.isArray(terms) || terms.length === 0) {
+        return res.status(400).json({ error: "terms array required" });
+    }
+
+    try {
+        console.log(`🔍 [search-by-content] Searching for terms: ${terms.join(', ')}`);
+
+        const rawFiles = await listRecursive(WORKSPACE_ROOT, {
+            maxDepth: 15,
+            includeHidden: false
+        });
+
+        // 🆕 FIXED: Normalize files to string paths
+        const allFiles = rawFiles.map(f => {
+            if (typeof f === 'string') return f;
+            if (f && typeof f === 'object' && f.path) return f.path;
+            if (f && typeof f === 'object' && f.name) return f.name;
+            return String(f);
+        }).filter(f => f && typeof f === 'string');
+
+        const filteredFiles = allFiles.filter(filePath => {
+            if (!extensions || extensions.length === 0) return true;
+            return extensions.some(ext => filePath.endsWith(ext));
+        });
+
+        console.log(`📁 [search-by-content] Scanning ${filteredFiles.length} files`);
+
+        const results = [];
+
+        for (const filePath of filteredFiles) {
+            if (results.length >= maxResults * 2) break;
+
+            try {
+                const fullPath = path.join(WORKSPACE_ROOT, filePath);
+                const content = await readFile(fullPath, 'utf8');
+                const lines = content.split('\n');
+
+                for (const term of terms) {
+                    for (let i = 0; i < lines.length; i++) {
+                        if (lines[i].includes(term)) {
+                            results.push({
+                                path: filePath,
+                                matchedTerm: term,
+                                lineNumber: i + 1,
+                                lineContent: lines[i].trim().substring(0, 100)
+                            });
+                            break;
+                        }
+                    }
+                }
+            } catch (readErr) {
+                continue;
+            }
+        }
+
+        results.sort((a, b) => {
+            const aIsDto = a.path.toLowerCase().includes('request') || a.path.toLowerCase().includes('dto');
+            const bIsDto = b.path.toLowerCase().includes('request') || b.path.toLowerCase().includes('dto');
+            if (aIsDto && !bIsDto) return -1;
+            if (!aIsDto && bIsDto) return 1;
+            return 0;
+        });
+
+        const seen = new Set();
+        const dedupedResults = results.filter(r => {
+            if (seen.has(r.path)) return false;
+            seen.add(r.path);
+            return true;
+        }).slice(0, maxResults);
+
+        console.log(`✅ [search-by-content] Found ${dedupedResults.length} matching files`);
+
+        res.json({
+            ok: true,
+            results: dedupedResults,
+            totalSearched: filteredFiles.length,
+            termsSearched: terms
+        });
+    } catch (err) {
+        console.error(`❌ [search-by-content] Error:`, err.message);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * POST /workspace/find-field-definition
+ * Finds where a specific field is defined in the codebase
+ *
+ * FIXED: Handle both string arrays and object arrays from listRecursive
+ */
+app.post("/workspace/find-field-definition", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({ error: "workspace not set" });
+    }
+
+    const { fieldName, fileType = "java" } = req.body || {};
+
+    if (!fieldName) {
+        return res.status(400).json({ error: "fieldName required" });
+    }
+
+    try {
+        console.log(`🔍 [find-field] Searching for field: ${fieldName}`);
+
+        const rawFiles = await listRecursive(WORKSPACE_ROOT, {
+            maxDepth: 15,
+            includeHidden: false
+        });
+
+        // 🆕 FIXED: Normalize files to string paths
+        const allFiles = rawFiles.map(f => {
+            if (typeof f === 'string') return f;
+            if (f && typeof f === 'object' && f.path) return f.path;
+            if (f && typeof f === 'object' && f.name) return f.name;
+            return String(f);
+        }).filter(f => f && typeof f === 'string');
+
+        const targetFiles = allFiles.filter(filePath => filePath.endsWith(`.${fileType}`));
+        const definitions = [];
+
+        const fieldPatterns = [
+            new RegExp(`(private|protected|public)\\s+\\w+\\s+${fieldName}\\s*[;=]`, 'i'),
+            new RegExp(`(private|protected|public)\\s+\\w+<[^>]+>\\s+${fieldName}\\s*[;=]`, 'i'),
+            new RegExp(`^\\s*\\w+\\s+${fieldName}\\s*;`, 'i')
+        ];
+
+        for (const filePath of targetFiles) {
+            try {
+                const fullPath = path.join(WORKSPACE_ROOT, filePath);
+                const content = await readFile(fullPath, 'utf8');
+                const lines = content.split('\n');
+
+                for (let i = 0; i < lines.length; i++) {
+                    const line = lines[i];
+
+                    for (const pattern of fieldPatterns) {
+                        if (pattern.test(line)) {
+                            const annotations = [];
+                            for (let j = i - 1; j >= Math.max(0, i - 5); j--) {
+                                const prevLine = lines[j].trim();
+                                if (prevLine.startsWith('@')) {
+                                    const match = prevLine.match(/@(\w+)/);
+                                    if (match) annotations.unshift(match[0]);
+                                } else if (prevLine && !prevLine.startsWith('//') && !prevLine.startsWith('*')) {
+                                    break;
+                                }
+                            }
+
+                            let className = null;
+                            for (const l of lines) {
+                                const classMatch = l.match(/class\s+(\w+)/);
+                                if (classMatch) {
+                                    className = classMatch[1];
+                                    break;
+                                }
+                            }
+
+                            definitions.push({
+                                path: filePath,
+                                lineNumber: i + 1,
+                                lineContent: line.trim(),
+                                annotations,
+                                className
+                            });
+                            break;
+                        }
+                    }
+                }
+            } catch (readErr) {
+                continue;
+            }
+        }
+
+        definitions.sort((a, b) => {
+            const aIsDto = a.path.toLowerCase().includes('request') || a.path.toLowerCase().includes('dto');
+            const bIsDto = b.path.toLowerCase().includes('request') || b.path.toLowerCase().includes('dto');
+            if (aIsDto && !bIsDto) return -1;
+            if (!aIsDto && bIsDto) return 1;
+            return 0;
+        });
+
+        console.log(`✅ [find-field] Found ${definitions.length} definitions for '${fieldName}'`);
+
+        res.json({
+            ok: true,
+            fieldName,
+            definitions,
+            totalSearched: targetFiles.length
+        });
+    } catch (err) {
+        console.error(`❌ [find-field] Error:`, err.message);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+
+// ============================================
+// 🆕 RUNTIME MANAGEMENT ENDPOINTS
+// ============================================
+
+/** Detecta serviços no workspace */
+app.get("/workspace/services/detect", async (_req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+
+    try {
+        const scanner = new WorkspaceScanner(WORKSPACE_ROOT);
+        const structure = await scanner.scan();
+
+        const languageDetector = new LanguageDetector(structure.files);
+        const languageInfo = languageDetector.detect();
+
+        const fileReader = new FileReader(WORKSPACE_ROOT);
+        const frameworkDetector = new FrameworkDetector(
+            languageInfo.primary,
+            structure.files,
+            fileReader
+        );
+        const frameworkInfo = await frameworkDetector.detect();
+
+        const serviceDetector = new ServiceDetector(
+            WORKSPACE_ROOT,
+            languageInfo,
+            frameworkInfo
+        );
+
+        DETECTED_SERVICES = await serviceDetector.detect();
+
+        res.json({
+            services: DETECTED_SERVICES,
+            detectedAt: new Date().toISOString()
+        });
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+/** Lista todos os serviços */
+app.get("/workspace/services", (_req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+
+    // Atualizar status dos serviços com info do ProcessManager
+    const servicesWithStatus = DETECTED_SERVICES.map(service => {
+        const status = processManager.getStatus(service.id);
+        return {
+            ...service,
+            ...status
+        };
+    });
+
+    res.json({ services: servicesWithStatus });
+});
+
+/** Inicia um serviço */
+app.post("/workspace/services/:serviceId/start", async (req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+
+    const { serviceId } = req.params;
+    const service = DETECTED_SERVICES.find(s => s.id === serviceId);
+
+    if (!service) {
+        return res.status(404).json({ error: "service not found" });
+    }
+
+    try {
+        const result = await processManager.start(serviceId, {
+            language: service.language,
+            framework: service.framework,
+            buildTool: service.buildTool,
+            cwd: service.path,
+            port: service.port
+        });
+
+        res.json(result);
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+/** Para um serviço */
+app.post("/workspace/services/:serviceId/stop", async (req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+
+    const { serviceId } = req.params;
+
+    try {
+        const result = await processManager.stop(serviceId);
+        res.json(result);
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+/** Retorna status de um serviço */
+app.get("/workspace/services/:serviceId/status", (req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+
+    const { serviceId } = req.params;
+    const status = processManager.getStatus(serviceId);
+
+    res.json({ serviceId, ...status });
+});
+
+/** Retorna logs de um serviço */
+app.get("/workspace/services/:serviceId/logs", (req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+
+    const { serviceId } = req.params;
+    const { limit = 100 } = req.query;
+
+    try {
+        const logs = processManager.getLogs(serviceId, parseInt(limit));
+        res.json({ serviceId, logs });
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+/** Streaming de logs em tempo real (SSE) */
+app.get("/workspace/services/:serviceId/logs/stream", (req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+
+    const { serviceId } = req.params;
+
+    // Setup SSE
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+
+    // Enviar logs existentes
+    const existingLogs = processManager.getLogs(serviceId);
+    existingLogs.forEach(log => {
+        res.write(`data: ${JSON.stringify(log)}\n\n`);
+    });
+
+    // Listener para novos logs
+    const logHandler = ({ serviceId: sid, log, type }) => {
+        if (sid === serviceId) {
+            res.write(`data: ${JSON.stringify({ timestamp: new Date().toISOString(), type, message: log })}\n\n`);
+        }
+    };
+
+    processManager.on("log", logHandler);
+
+    // Cleanup ao fechar conexão
+    req.on("close", () => {
+        processManager.off("log", logHandler);
+    });
+});
+
+// ============================================
+// ENDPOINTS LEGADOS (manter compatibilidade)
+// ============================================
+
+app.get("/workspace/files", async (req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+    const { max = 5000 } = req.query;
+    const tree = await listRecursive(WORKSPACE_ROOT, { maxFiles: Number(max) });
+    res.json({ root: WORKSPACE_ROOT, count: tree.length, tree });
+});
+
+app.get("/workspace/file", async (req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+    const rel = req.query.path;
+    if (!rel) return res.status(400).json({ error: "path is required" });
+    try {
+        const content = await readText(WORKSPACE_ROOT, rel);
+        res.json({ path: rel, content });
+    } catch (e) {
+        res.status(404).json({ error: "file not found", details: String(e) });
+    }
+});
+
+app.post("/workspace/write", async (req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+    const { path: rel, content } = req.body || {};
+    if (!rel) return res.status(400).json({ error: "path is required" });
+    try {
+        await writeFile(path.join(WORKSPACE_ROOT, rel), content ?? "", "utf8");
+        res.json({ ok: true, path: rel, bytes: Buffer.byteLength(content ?? "", "utf8") });
+    } catch (e) {
+        res.status(400).json({ error: "write failed", details: String(e) });
+    }
+});
+
+// ============================================
+// ✅ CORRECTED: /workspace/patch endpoint
+// ============================================
+app.post("/workspace/patch", async (req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+    const { diff, incidentId } = req.body || {};
+    if (!diff) return res.status(400).json({ error: "diff is required" });
+
+    try {
+        console.log(`📝 Applying patch for incident: ${incidentId || 'unknown'}`);
+        const out = await applyUnifiedDiff(WORKSPACE_ROOT, diff);
+
+        // ✅ CRITICAL FIX: Format response as expected by Gateway
+        const response = {
+            ok: true,
+            filesModified: 1,
+            patchedFiles: [out.target],
+            bytesWritten: out.bytes,
+            target: out.target,
+            bytes: out.bytes,
+            message: `Patch applied successfully to ${out.target}`,
+            incidentId: incidentId
+        };
+
+        console.log(`✅ Patch applied successfully:`, {
+            target: out.target,
+            bytes: out.bytes,
+            incident: incidentId
+        });
+
+        res.json(response);
+    } catch (e) {
+        console.error(`❌ Patch failed:`, e.message);
+        res.status(400).json({
+            ok: false,
+            error: "patch failed",
+            details: String(e),
+            filesModified: 0,
+            patchedFiles: []
+        });
+    }
+});
+
+app.post("/workspace/test", async (_req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+    const meta = await detectProject(WORKSPACE_ROOT);
+    const result = await compileAndTest({ language: meta.language, buildTool: meta.buildTool, cwd: WORKSPACE_ROOT });
+    res.json({ root: WORKSPACE_ROOT, meta, result });
+});
+
+app.post("/workspace/run", async (req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+    const { cmd, args = [] } = req.body || {};
+    if (!cmd) return res.status(400).json({ error: "cmd is required" });
+    const out = await run(cmd, args, WORKSPACE_ROOT, 5 * 60 * 1000);
+    res.json(out);
+});
+
+// ============================================
+// 🆕 TEST LOCAL ENDPOINTS
+// ============================================
+
+/** Store test local state */
+let TEST_LOCAL_STATE = {
+    status: "idle", // idle, compiling, compiled, starting, running, stopped, error
+    compilationResult: null,
+    serverProcess: null,
+    endpoints: [],
+    config: null,
+    testResults: [],
+    serverLogs: [] // Buffer circular de logs do servidor (últimos 1000)
+};
+
+// ============================================
+// 🆕 TEST LOCAL STATE ENDPOINTS (ADDED)
+// ============================================
+
+/**
+ * GET /workspace/test-local/state
+ * Returns current test local state with auto-detected port
+ */
+app.get("/workspace/test-local/state", async (req, res) => {
+    console.log("📊 [TEST-LOCAL] Getting state:", TEST_LOCAL_STATE.status);
+
+    // Auto-detect port if not set in config
+    let port = TEST_LOCAL_STATE.config?.server?.port;
+    if (!port && WORKSPACE_ROOT) {
+        try {
+            port = await detectPort(WORKSPACE_ROOT);
+        } catch (e) {
+            port = 8080;
+        }
+    }
+
+    res.json({
+        ok: true,
+        status: TEST_LOCAL_STATE.status,
+        compilationResult: TEST_LOCAL_STATE.compilationResult,
+        endpoints: TEST_LOCAL_STATE.endpoints?.length || 0,
+        config: {
+            port: port || 8080,
+            contextPath: TEST_LOCAL_STATE.config?.server?.contextPath || "",
+            profiles: TEST_LOCAL_STATE.config?.profiles || []
+        },
+        testResultsCount: TEST_LOCAL_STATE.testResults?.length || 0,
+        serverLogsCount: TEST_LOCAL_STATE.serverLogs?.length || 0,
+        hasRunningServer: processManager.isRunning ? processManager.isRunning('test-local') : false,
+        workspace: WORKSPACE_ROOT,
+        timestamp: Date.now()
+    });
+});
+
+/**
+ * POST /workspace/test-local/compile
+ * Compiles the project without starting server
+ */
+app.post("/workspace/test-local/compile", async (req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+
+    try {
+        console.log("🔨 [TEST-LOCAL] Starting compilation...");
+        TEST_LOCAL_STATE.status = "compiling";
+
+        const meta = await detectProject(WORKSPACE_ROOT);
+        const compileResult = await compileAndTest({
+            language: meta.language,
+            buildTool: meta.buildTool,
+            cwd: WORKSPACE_ROOT,
+            skipTests: true
+        });
+
+        if (compileResult.code !== 0) {
+            TEST_LOCAL_STATE.status = "error";
+            TEST_LOCAL_STATE.compilationResult = {
+                success: false,
+                error: compileResult.stderr,
+                duration: compileResult.duration
+            };
+
+            return res.json({
+                ok: false,
+                error: compileResult.stderr,
+                stdout: compileResult.stdout,
+                duration: compileResult.duration
+            });
+        }
+
+        TEST_LOCAL_STATE.status = "compiled";
+        TEST_LOCAL_STATE.compilationResult = {
+            success: true,
+            language: meta.language,
+            buildTool: meta.buildTool,
+            duration: compileResult.duration
+        };
+
+        console.log("✅ [TEST-LOCAL] Compilation successful");
+
+        res.json({
+            ok: true,
+            language: meta.language,
+            buildTool: meta.buildTool,
+            duration: compileResult.duration,
+            stdout: compileResult.stdout
+        });
+    } catch (err) {
+        console.error("❌ [TEST-LOCAL] Compilation failed:", err.message);
+        TEST_LOCAL_STATE.status = "error";
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * POST /workspace/test-local/start
+ * Starts the local server with AUTO-HEALING
+ *
+ * 🧠 UPDATED: Now uses AI Vibe Coding Engine for auto-healing
+ */
+app.post("/workspace/test-local/start", async (req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+
+    const { port } = req.body || {};
+
+    try {
+        console.log(`\n🚀 [TEST-LOCAL] Starting server (SIMPLE MODE)...`);
+        TEST_LOCAL_STATE.status = "starting";
+
+        const meta = await detectProject(WORKSPACE_ROOT);
+
+        // Detect port if not provided
+        let serverPort = port || 8080;
+
+        // Para Java, encontrar o JAR e correr directamente
+        if (meta.language === 'java') {
+            const targetDir = path.join(WORKSPACE_ROOT, 'target');
+
+            if (!fs.existsSync(targetDir)) {
+                throw new Error('target/ directory not found. Run mvn clean install first.');
+            }
+
+            const files = fs.readdirSync(targetDir);
+            const jarFiles = files.filter(f =>
+                f.endsWith('.jar') &&
+                !f.endsWith('.original') &&
+                !f.includes('-sources') &&
+                !f.includes('-javadoc')
+            );
+
+            if (jarFiles.length === 0) {
+                throw new Error('No JAR found in target/. Run mvn clean install first.');
+            }
+
+            const jarPath = path.join(targetDir, jarFiles[0]);
+
+            // Comando EXACTO como no terminal (sem profiles!)
+            const command = 'java';
+            const args = ['-jar', jarPath, `--server.port=${serverPort}`];
+
+            console.log(`🚀 Command: ${command} ${args.join(' ')}`);
+
+            // Env LIMPO - remover TODAS as variáveis Spring que podem interferir
+            const cleanEnv = { ...process.env };
+            delete cleanEnv.SPRING_PROFILES_ACTIVE;
+            delete cleanEnv.SPRING_DATASOURCE_URL;
+            delete cleanEnv.SPRING_DATASOURCE_USERNAME;
+            delete cleanEnv.SPRING_DATASOURCE_PASSWORD;
+            // Remover qualquer variável que comece com SPRING_
+            Object.keys(cleanEnv).forEach(key => {
+                if (key.startsWith('SPRING_')) {
+                    delete cleanEnv[key];
+                }
+            });
+            cleanEnv.SERVER_PORT = String(serverPort);
+            cleanEnv.PORT = String(serverPort);
+
+            const startConfig = {
+                command,
+                args,
+                cwd: WORKSPACE_ROOT,
+                port: serverPort,
+                env: cleanEnv
+            };
+
+            await processManager.start('test-local', startConfig);
+
+            TEST_LOCAL_STATE.status = "running";
+            TEST_LOCAL_STATE.config = { port: serverPort };
+
+            console.log(`✅ [TEST-LOCAL] Server started on port ${serverPort}`);
+
+            res.json({
+                ok: true,
+                port: serverPort,
+                language: meta.language,
+                command: `${command} ${args.join(' ')}`,
+                status: "running"
+            });
+
+        } else {
+            // Outras linguagens - manter comportamento original
+            let command, args;
+
+            if (meta.language === 'node') {
+                command = meta.buildTool === 'yarn' ? 'yarn' : 'npm';
+                args = ['start'];
+            } else if (meta.language === 'python') {
+                command = 'python';
+                args = ['main.py'];
+            } else if (meta.language === 'go') {
+                command = 'go';
+                args = ['run', '.'];
+            } else if (meta.language === 'dotnet' || meta.language === '.net') {
+                command = 'dotnet';
+                args = ['run'];
+            } else {
+                throw new Error(`Unsupported language: ${meta.language}`);
+            }
+
+            await processManager.start('test-local', {
+                command,
+                args,
+                cwd: WORKSPACE_ROOT,
+                port: serverPort,
+                env: { ...process.env, PORT: String(serverPort) }
+            });
+
+            TEST_LOCAL_STATE.status = "running";
+            TEST_LOCAL_STATE.config = { port: serverPort };
+
+            res.json({
+                ok: true,
+                port: serverPort,
+                language: meta.language,
+                command: `${command} ${args.join(' ')}`,
+                status: "running"
+            });
+        }
+    } catch (err) {
+        console.error("❌ [TEST-LOCAL] Server start failed:", err.message);
+        TEST_LOCAL_STATE.status = "error";
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * POST /workspace/test-local/stop
+ * Stops the local server
+ */
+app.post("/workspace/test-local/stop", async (req, res) => {
+    try {
+        console.log("🛑 [TEST-LOCAL] Stopping server...");
+
+        await processManager.stop('test-local');
+        TEST_LOCAL_STATE.status = "stopped";
+
+        console.log("✅ [TEST-LOCAL] Server stopped");
+
+        res.json({
+            ok: true,
+            status: "stopped"
+        });
+    } catch (err) {
+        console.error("❌ [TEST-LOCAL] Server stop failed:", err.message);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * GET /workspace/test-local/endpoints
+ * Returns discovered endpoints
+ */
+app.get("/workspace/test-local/endpoints", async (req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+
+    try {
+        console.log("📋 [TEST-LOCAL] Getting endpoints...");
+
+        // If endpoints are cached, return them
+        if (TEST_LOCAL_STATE.endpoints && TEST_LOCAL_STATE.endpoints.length > 0) {
+            return res.json({
+                ok: true,
+                endpoints: TEST_LOCAL_STATE.endpoints,
+                cached: true
+            });
+        }
+
+        // Otherwise discover them
+        const scanner = new WorkspaceScanner(WORKSPACE_ROOT);
+        const structure = await scanner.scan();
+
+        const controllerAnalyzer = new ControllerAnalyzer(WORKSPACE_ROOT);
+        const apiDocs = await controllerAnalyzer.generateApiDocs(structure.files);
+
+        const dtoAnalyzer = new DTOAnalyzer(WORKSPACE_ROOT);
+        const payloadDocs = await dtoAnalyzer.generatePayloadDocs(structure.files, apiDocs.endpoints);
+
+        TEST_LOCAL_STATE.endpoints = payloadDocs.endpoints;
+
+        console.log(`✅ [TEST-LOCAL] Discovered ${payloadDocs.endpoints.length} endpoints`);
+
+        res.json({
+            ok: true,
+            endpoints: payloadDocs.endpoints,
+            cached: false
+        });
+    } catch (err) {
+        console.error("❌ [TEST-LOCAL] Failed to get endpoints:", err.message);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * POST /workspace/test-local/execute
+ * Executes a test request against the running server
+ */
+app.post("/workspace/test-local/execute", async (req, res) => {
+    const { method, path: reqPath, body, headers, port } = req.body || {};
+
+    if (!method || !reqPath) {
+        return res.status(400).json({ error: "method and path are required" });
+    }
+
+    try {
+        const serverPort = port || TEST_LOCAL_STATE.config?.server?.port || 8080;
+        const url = `http://localhost:${serverPort}${reqPath}`;
+
+        console.log(`🧪 [TEST-LOCAL] Executing: ${method} ${url}`);
+
+        const startTime = Date.now();
+
+        const fetchOptions = {
+            method: method.toUpperCase(),
+            headers: {
+                'Content-Type': 'application/json',
+                ...headers
+            }
+        };
+
+        if (body && ['POST', 'PUT', 'PATCH'].includes(method.toUpperCase())) {
+            fetchOptions.body = typeof body === 'string' ? body : JSON.stringify(body);
+        }
+
+        const response = await fetch(url, fetchOptions);
+        const duration = Date.now() - startTime;
+
+        let responseBody;
+        const contentType = response.headers.get('content-type');
+
+        if (contentType?.includes('application/json')) {
+            responseBody = await response.json();
+        } else {
+            responseBody = await response.text();
+        }
+
+        const result = {
+            statusCode: response.status,
+            statusText: response.statusText,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: responseBody,
+            duration,
+            url
+        };
+
+        // Store result
+        TEST_LOCAL_STATE.testResults.push({
+            timestamp: Date.now(),
+            request: { method, path: reqPath, body },
+            result
+        });
+
+        // Keep only last 100 results
+        if (TEST_LOCAL_STATE.testResults.length > 100) {
+            TEST_LOCAL_STATE.testResults.shift();
+        }
+
+        console.log(`✅ [TEST-LOCAL] Test result: ${response.status} (${duration}ms)`);
+
+        res.json({
+            ok: true,
+            result
+        });
+    } catch (err) {
+        console.error("❌ [TEST-LOCAL] Test execution failed:", err.message);
+        res.json({
+            ok: false,
+            error: err.message,
+            result: {
+                statusCode: 0,
+                statusText: 'Connection Failed',
+                body: err.message,
+                duration: 0
+            }
+        });
+    }
+});
+
+/**
+ * GET /workspace/test-local/results
+ * Returns stored test results
+ */
+app.get("/workspace/test-local/results", (req, res) => {
+    console.log("📊 [TEST-LOCAL] Getting test results...");
+
+    res.json({
+        ok: true,
+        results: TEST_LOCAL_STATE.testResults,
+        total: TEST_LOCAL_STATE.testResults.length
+    });
+});
+
+/**
+ * POST /workspace/test-local/clear-results
+ * Clears stored test results
+ */
+app.post("/workspace/test-local/clear-results", (req, res) => {
+    console.log("🗑️ [TEST-LOCAL] Clearing test results...");
+
+    TEST_LOCAL_STATE.testResults = [];
+
+    res.json({
+        ok: true,
+        message: "Test results cleared"
+    });
+});
+
+/**
+ * GET /workspace/test-local/logs
+ * Returns server logs (non-streaming)
+ */
+app.get("/workspace/test-local/logs", (req, res) => {
+    const limit = parseInt(req.query.limit) || 500;
+
+    console.log(`📋 [TEST-LOCAL] Getting logs (limit: ${limit})`);
+
+    const logs = TEST_LOCAL_STATE.serverLogs.slice(-limit);
+
+    res.json({
+        ok: true,
+        logs,
+        total: TEST_LOCAL_STATE.serverLogs.length,
+        returned: logs.length
+    });
+});
+
+
+/** Discover controllers and endpoints */
+app.get("/workspace/controllers", async (_req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+
+    try {
+        console.log("🔍 [CONTROLLERS] Discovering controllers...");
+
+        const scanner = new WorkspaceScanner(WORKSPACE_ROOT);
+        const structure = await scanner.scan();
+
+        const controllerAnalyzer = new ControllerAnalyzer(WORKSPACE_ROOT);
+        const apiDocs = await controllerAnalyzer.generateApiDocs(structure.files);
+
+        console.log(`✅ [CONTROLLERS] Found ${apiDocs.totalEndpoints} endpoints in ${apiDocs.totalControllers} controllers`);
+
+        res.json({
+            ok: true,
+            ...apiDocs
+        });
+    } catch (err) {
+        console.error("❌ [CONTROLLERS] Failed:", err.message);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/** Analyze DTOs and payloads */
+app.get("/workspace/dtos", async (_req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+
+    try {
+        console.log("📦 [DTOS] Analyzing DTOs...");
+
+        const scanner = new WorkspaceScanner(WORKSPACE_ROOT);
+        const structure = await scanner.scan();
+
+        const controllerAnalyzer = new ControllerAnalyzer(WORKSPACE_ROOT);
+        const apiDocs = await controllerAnalyzer.generateApiDocs(structure.files);
+
+        const dtoAnalyzer = new DTOAnalyzer(WORKSPACE_ROOT);
+        const payloadDocs = await dtoAnalyzer.generatePayloadDocs(structure.files, apiDocs.endpoints);
+
+        console.log(`✅ [DTOS] Found ${payloadDocs.totalDtos} DTOs`);
+
+        res.json({
+            ok: true,
+            ...payloadDocs
+        });
+    } catch (err) {
+        console.error("❌ [DTOS] Failed:", err.message);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/** Get server configuration */
+app.get("/workspace/config", async (_req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+
+    try {
+        console.log("⚙️ [CONFIG] Analyzing configuration...");
+
+        const configAnalyzer = new ConfigAnalyzer(WORKSPACE_ROOT);
+        const config = await configAnalyzer.analyze();
+
+        console.log(`✅ [CONFIG] Server port: ${config.server.port}`);
+
+        res.json({
+            ok: true,
+            ...config
+        });
+    } catch (err) {
+        console.error("❌ [CONFIG] Failed:", err.message);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+// ============================================
+// 🆕 BACKUP & ROLLBACK ENDPOINTS (Sprint 1.3)
+// Added without modifying existing endpoints
+// ============================================
+
+/**
+ * Helper: Validate diff format
+ */
+function validateDiff(diff) {
+    const errors = [];
+
+    if (!diff || typeof diff !== 'string') {
+        return { valid: false, errors: ['Diff text is empty or invalid'] };
+    }
+
+    const lines = diff.split('\n');
+    const hasOldFileHeader = lines.some(l => l.startsWith('--- '));
+    const hasNewFileHeader = lines.some(l => l.startsWith('+++ '));
+    const hasHunkHeader = lines.some(l => /^@@ -\d+,?\d* \+\d+,?\d* @@/.test(l));
+
+    if (!hasOldFileHeader) errors.push('Missing old file header (--- a/path/to/file)');
+    if (!hasNewFileHeader) errors.push('Missing new file header (+++ b/path/to/file)');
+    if (!hasHunkHeader) errors.push('Missing hunk header (@@ -line,count +line,count @@)');
+
+    return { valid: errors.length === 0, errors };
+}
+
+/**
+ * Helper: Extract target files from diff
+ */
+function extractTargetFiles(diff) {
+    const files = [];
+    const lines = diff.split('\n');
+
+    for (const line of lines) {
+        if (line.startsWith('+++ ')) {
+            let filePath = line.substring(4).trim();
+            // Remove prefixes like b/ or ./
+            filePath = filePath.replace(/^[ab]\//, '').replace(/^\.\//,'');
+            if (filePath && filePath !== '/dev/null') {
+                files.push(filePath);
+            }
+        }
+    }
+
+    return files;
+}
+
+/**
+ * POST /workspace/safe-patch
+ * Applies patch with automatic backup and rollback on failure
+ */
+app.post("/workspace/safe-patch", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({
+            error: "workspace not set",
+            hint: "call POST /workspace/open first"
+        });
+    }
+
+    const { diff, incidentId } = req.body || {};
+    if (!diff) return res.status(400).json({ error: "diff is required" });
+
+    console.log(`🔧 Safe patch requested for incident: ${incidentId || 'unknown'}`);
+
+    try {
+        // 1. Validate diff
+        const validation = validateDiff(diff);
+        if (!validation.valid) {
+            return res.status(400).json({
+                ok: false,
+                error: "Invalid diff format",
+                details: validation.errors
+            });
+        }
+
+        // 2. Extract target files
+        const targetFiles = extractTargetFiles(diff);
+        console.log(`📂 Target files: ${targetFiles.join(', ')}`);
+
+        // 3. Create backup
+        const backupId = `backup-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        const backupFiles = [];
+
+        for (const relPath of targetFiles) {
+            const fullPath = path.join(WORKSPACE_ROOT, relPath);
+            if (await exists(fullPath)) {
+                const content = await readFile(fullPath, 'utf8');
+                backupFiles.push({ path: relPath, content });
+            }
+        }
+
+        BACKUPS.set(backupId, {
+            files: backupFiles,
+            timestamp: new Date().toISOString(),
+            incidentId: incidentId || null
+        });
+
+        // Save backup files to disk for persistence across restarts
+        const backupDir = path.join(os.tmpdir(), 'deepdebug-backups', backupId);
+        try {
+            await fsPromises.mkdir(backupDir, { recursive: true });
+            for (const file of backupFiles) {
+                const backupFilePath = path.join(backupDir, file.path.replace(/\//g, '__'));
+                await fsPromises.writeFile(backupFilePath, file.content, 'utf8');
+                file.backupPath = backupFilePath;
+            }
+            saveBackupIndex();
+        } catch (e) {
+            console.warn(`⚠️ Could not persist backup to disk: ${e.message}`);
+        }
+
+        // Cleanup old backups if exceeded max
+        if (BACKUPS.size > MAX_BACKUPS) {
+            const oldest = Array.from(BACKUPS.keys())[0];
+            BACKUPS.delete(oldest);
+            console.log(`🗑️ Removed old backup: ${oldest}`);
+            saveBackupIndex();
+        }
+
+        console.log(`💾 Backup created: ${backupId} (${backupFiles.length} files)`);
+
+        // 4. Apply patch
+        try {
+            const result = await applyUnifiedDiff(WORKSPACE_ROOT, diff);
+            console.log(`✅ Patch applied successfully: ${result.target}`);
+
+            res.json({
+                ok: true,
+                backupId,
+                patchedFiles: [result.target],
+                bytesWritten: result.bytes,
+                message: "Patch applied successfully"
+            });
+        } catch (patchError) {
+            // 5. Rollback on failure
+            console.error(`❌ Patch failed, rolling back: ${patchError.message}`);
+
+            for (const file of backupFiles) {
+                const fullPath = path.join(WORKSPACE_ROOT, file.path);
+                await writeFile(fullPath, file.content, 'utf8');
+            }
+
+            BACKUPS.delete(backupId);
+
+            res.status(400).json({
+                ok: false,
+                error: "Patch failed and was rolled back",
+                details: patchError.message,
+                rolledBack: true
+            });
+        }
+    } catch (err) {
+        console.error(`❌ Safe patch error: ${err.message}`);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * POST /workspace/patch/dry-run
+ * Validates and simulates patch application WITHOUT modifying files
+ */
+app.post("/workspace/patch/dry-run", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({
+            error: "workspace not set",
+            hint: "call POST /workspace/open first"
+        });
+    }
+
+    const { diff } = req.body || {};
+    if (!diff) return res.status(400).json({ error: "diff is required" });
+
+    console.log(`🔍 Dry-run patch validation requested`);
+
+    try {
+        // 1. Validate diff format
+        const validation = validateDiff(diff);
+        if (!validation.valid) {
+            return res.json({
+                ok: true,
+                valid: false,
+                canApply: false,
+                errors: validation.errors,
+                wouldModify: [],
+                hunksCount: 0
+            });
+        }
+
+        // 2. Extract target files
+        const targetFiles = extractTargetFiles(diff);
+
+        // 3. Check if files exist
+        const fileChecks = await Promise.all(
+            targetFiles.map(async (relPath) => {
+                const fullPath = path.join(WORKSPACE_ROOT, relPath);
+                const fileExists = await exists(fullPath);
+                let currentContent = null;
+                let lineCount = 0;
+
+                if (fileExists) {
+                    try {
+                        currentContent = await readFile(fullPath, 'utf8');
+                        lineCount = currentContent.split('\n').length;
+                    } catch (e) {
+                        // File exists but can't be read
+                    }
+                }
+
+                return {
+                    path: relPath,
+                    exists: fileExists,
+                    lineCount
+                };
+            })
+        );
+
+        // 4. Count hunks
+        const hunkCount = (diff.match(/@@ -\d+,?\d* \+\d+,?\d* @@/g) || []).length;
+
+        // 5. Check if all files exist (for modification patches)
+        const allFilesExist = fileChecks.every(f => f.exists || diff.includes('--- /dev/null'));
+        const missingFiles = fileChecks.filter(f => !f.exists && !diff.includes('--- /dev/null'));
+
+        console.log(`✅ Dry-run complete: ${targetFiles.length} files, ${hunkCount} hunks`);
+
+        res.json({
+            ok: true,
+            valid: true,
+            canApply: allFilesExist,
+            wouldModify: targetFiles,
+            hunksCount: hunkCount,
+            fileChecks,
+            missingFiles: missingFiles.map(f => f.path),
+            warnings: missingFiles.length > 0 ? [`${missingFiles.length} file(s) not found`] : []
+        });
+    } catch (err) {
+        console.error(`❌ Dry-run error: ${err.message}`);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * POST /workspace/validate-diff
+ * Validates diff format without checking files
+ */
+app.post("/workspace/validate-diff", async (req, res) => {
+    const { diff } = req.body || {};
+    if (!diff) return res.status(400).json({ valid: false, errors: ["diff is required"] });
+
+    const validation = validateDiff(diff);
+    const targetFiles = validation.valid ? extractTargetFiles(diff) : [];
+    const hunkCount = validation.valid ? (diff.match(/@@ -\d+,?\d* \+\d+,?\d* @@/g) || []).length : 0;
+
+    res.json({
+        ...validation,
+        targetFiles,
+        hunksCount: hunkCount
+    });
+});
+
+/**
+ * POST /workspace/backup
+ * Creates manual backup of specific files
+ */
+app.post("/workspace/backup", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({
+            error: "workspace not set",
+            hint: "call POST /workspace/open first"
+        });
+    }
+
+    const { files, incidentId } = req.body || {};
+    if (!files || !Array.isArray(files)) {
+        return res.status(400).json({ error: "files array is required" });
+    }
+
+    try {
+        const backupId = `backup-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        const backupFiles = [];
+
+        for (const relPath of files) {
+            const fullPath = path.join(WORKSPACE_ROOT, relPath);
+            if (await exists(fullPath)) {
+                const content = await readFile(fullPath, 'utf8');
+                backupFiles.push({ path: relPath, content });
+            }
+        }
+
+        if (backupFiles.length === 0) {
+            return res.status(400).json({
+                ok: false,
+                error: "No valid files to backup",
+                requestedFiles: files
+            });
+        }
+
+        BACKUPS.set(backupId, {
+            files: backupFiles,
+            timestamp: new Date().toISOString(),
+            incidentId: incidentId || null
+        });
+
+        console.log(`💾 Manual backup created: ${backupId}`);
+
+        res.json({
+            ok: true,
+            backupId,
+            files: backupFiles.map(f => f.path),
+            timestamp: new Date().toISOString()
+        });
+    } catch (err) {
+        console.error(`❌ Backup error: ${err.message}`);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * POST /workspace/rollback
+ * Restores files from a backup
+ */
+app.post("/workspace/rollback", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({
+            error: "workspace not set",
+            hint: "call POST /workspace/open first"
+        });
+    }
+
+    const { backupId } = req.body || {};
+    if (!backupId) {
+        return res.status(400).json({ error: "backupId is required" });
+    }
+
+    const backup = BACKUPS.get(backupId);
+    if (!backup) {
+        return res.status(404).json({
+            error: "backup not found",
+            availableBackups: Array.from(BACKUPS.keys())
+        });
+    }
+
+    try {
+        console.log(`♻️ Rolling back to backup: ${backupId}`);
+
+        for (const file of backup.files) {
+            const fullPath = path.join(WORKSPACE_ROOT, file.path);
+            await writeFile(fullPath, file.content, 'utf8');
+        }
+
+        console.log(`✅ Rollback completed: ${backup.files.length} files restored`);
+
+        res.json({
+            ok: true,
+            backupId,
+            restoredFiles: backup.files.map(f => f.path),
+            timestamp: backup.timestamp
+        });
+    } catch (err) {
+        console.error(`❌ Rollback error: ${err.message}`);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * GET /workspace/backups
+ * Lists all available backups
+ */
+app.get("/workspace/backups", (_req, res) => {
+    const backupList = Array.from(BACKUPS.entries()).map(([id, data]) => ({
+        backupId: id,
+        timestamp: data.timestamp,
+        incidentId: data.incidentId,
+        fileCount: data.files.length,
+        files: data.files.map(f => f.path)
+    }));
+
+    // Sort by timestamp (newest first)
+    backupList.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+
+    res.json({
+        backups: backupList,
+        total: backupList.length,
+        maxBackups: MAX_BACKUPS
+    });
+});
+
+/**
+ * DELETE /workspace/backups/:backupId
+ * Deletes a specific backup
+ */
+app.delete("/workspace/backups/:backupId", (req, res) => {
+    const { backupId } = req.params;
+
+    if (!BACKUPS.has(backupId)) {
+        return res.status(404).json({ error: "backup not found" });
+    }
+
+    BACKUPS.delete(backupId);
+    console.log(`🗑️ Backup deleted: ${backupId}`);
+
+    res.json({
+        ok: true,
+        deleted: backupId
+    });
+});
+
+// ============================================
+// 📊 DIFF VIEWER ENDPOINT
+// Returns before/after content for files modified by a patch
+// Used by the frontend diff viewer
+// ============================================
+
+/**
+ * GET /workspace/diff/by-incident/:incidentId
+ *
+ * Find the most recent backup for an incident and return its diff.
+ * This is used when the frontend doesn't have the exact backupId.
+ */
+app.get("/workspace/diff/by-incident/:incidentId", async (req, res) => {
+    const { incidentId } = req.params;
+
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({ error: "workspace not set" });
+    }
+
+    // Find the most recent backup for this incident
+    let matchedBackupId = null;
+    let matchedBackup = null;
+    let latestTimestamp = 0;
+
+    for (const [id, backup] of BACKUPS.entries()) {
+        if (backup.incidentId === incidentId ||
+            backup.incidentId === `autofix-${incidentId}` ||
+            id.includes(incidentId)) {
+            const ts = backup.timestamp ? new Date(backup.timestamp).getTime() : 0;
+            if (ts > latestTimestamp || !matchedBackupId) {
+                matchedBackupId = id;
+                matchedBackup = backup;
+                latestTimestamp = ts;
+            }
+        }
+    }
+
+    // Also search by partial match on the last few chars
+    if (!matchedBackup) {
+        const shortId = incidentId.length > 8 ? incidentId.substring(incidentId.length - 8) : incidentId;
+        for (const [id, backup] of BACKUPS.entries()) {
+            if (id.includes(shortId) || (backup.incidentId && backup.incidentId.includes(shortId))) {
+                matchedBackupId = id;
+                matchedBackup = backup;
+                break;
+            }
+        }
+    }
+
+    if (!matchedBackup) {
+        console.log(`⚠️ No backup found for incident ${incidentId}. Available backups:`, Array.from(BACKUPS.keys()));
+        return res.status(404).json({
+            ok: false,
+            error: "No backup found for this incident",
+            incidentId,
+            availableBackups: Array.from(BACKUPS.keys())
+        });
+    }
+
+    console.log(`📊 Found backup ${matchedBackupId} for incident ${incidentId}`);
+
+    // Reuse the diff logic
+    try {
+        const diffs = [];
+        for (const file of matchedBackup.files) {
+            const fullPath = path.join(WORKSPACE_ROOT, file.path);
+            let currentContent = '';
+            try {
+                currentContent = await readFile(fullPath, 'utf8');
+            } catch (err) {
+                currentContent = '// File was deleted or moved after patching';
+            }
+            const hasChanges = file.content !== currentContent;
+            if (hasChanges) {
+                diffs.push({
+                    filePath: file.path,
+                    fileName: path.basename(file.path),
+                    before: file.content,
+                    after: currentContent,
+                    hasChanges: true,
+                    beforeLines: file.content.split('\n').length,
+                    afterLines: currentContent.split('\n').length
+                });
+            }
+        }
+
+        res.json({
+            ok: true,
+            backupId: matchedBackupId,
+            incidentId,
+            timestamp: matchedBackup.timestamp,
+            totalFiles: matchedBackup.files.length,
+            changedFiles: diffs.length,
+            files: diffs
+        });
+    } catch (err) {
+        console.error(`❌ Diff error: ${err.message}`);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * GET /workspace/diff/:backupId
+ *
+ * Returns before/after content for files modified by a patch.
+ * The BACKUPS map stores original file content (before patch).
+ * Current file content is read from disk (after patch).
+ *
+ * Response:
+ * {
+ *   "ok": true,
+ *   "backupId": "backup-xxx",
+ *   "files": [
+ *     {
+ *       "filePath": "src/main/java/.../Service.java",
+ *       "fileName": "Service.java",
+ *       "before": "original content...",
+ *       "after": "current content...",
+ *       "hasChanges": true
+ *     }
+ *   ]
+ * }
+ */
+app.get("/workspace/diff/:backupId", async (req, res) => {
+    const { backupId } = req.params;
+
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({ error: "workspace not set" });
+    }
+
+    const backup = BACKUPS.get(backupId);
+    if (!backup) {
+        return res.status(404).json({
+            ok: false,
+            error: "Backup not found. It may have expired or the server was restarted.",
+            availableBackups: Array.from(BACKUPS.keys())
+        });
+    }
+
+    try {
+        const diffs = [];
+
+        for (const file of backup.files) {
+            const fullPath = path.join(WORKSPACE_ROOT, file.path);
+            let currentContent = '';
+
+            try {
+                currentContent = await readFile(fullPath, 'utf8');
+            } catch (err) {
+                currentContent = '// File was deleted or moved after patching';
+            }
+
+            // Only include files that actually changed
+            const hasChanges = file.content !== currentContent;
+            if (hasChanges) {
+                diffs.push({
+                    filePath: file.path,
+                    fileName: path.basename(file.path),
+                    before: file.content,
+                    after: currentContent,
+                    hasChanges: true,
+                    beforeLines: file.content.split('\n').length,
+                    afterLines: currentContent.split('\n').length
+                });
+            }
+        }
+
+        console.log(`📊 Diff for ${backupId}: ${diffs.length} file(s) changed`);
+
+        res.json({
+            ok: true,
+            backupId,
+            timestamp: backup.timestamp,
+            incidentId: backup.incidentId,
+            totalFiles: backup.files.length,
+            changedFiles: diffs.length,
+            files: diffs
+        });
+    } catch (err) {
+        console.error(`❌ Diff error: ${err.message}`);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+// ============================================
+// 🆕 DETECT PORT ENDPOINT (Sprint 1.2)
+// Multi-language port detection
+// ============================================
+
+/**
+ * GET /workspace/detect-port
+ * Detects port from service configuration files
+ * Supports: Java (Spring Boot), Node.js, Python, .NET
+ *
+ * Query params:
+ * - servicePath: relative path to service (optional, defaults to workspace root)
+ * - language: java, node, python, dotnet (optional, auto-detect if not provided)
+ * - framework: spring-boot, express, flask, etc (optional)
+ */
+app.get("/workspace/detect-port", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({
+            error: "workspace not set",
+            hint: "call POST /workspace/open first"
+        });
+    }
+
+    const { servicePath = '', language, framework } = req.query;
+
+    try {
+        const fullPath = path.join(WORKSPACE_ROOT, servicePath);
+        console.log(`🔍 Detecting port for service at: ${fullPath}`);
+
+        let port = null;
+        let detectionMethod = null;
+
+        // Auto-detect language if not provided
+        let detectedLanguage = language;
+        if (!detectedLanguage) {
+            const meta = await detectProject(fullPath);
+            detectedLanguage = meta.language;
+        }
+
+        // Detect port based on language/framework
+        if (detectedLanguage === 'java') {
+            const result = await detectSpringBootPort(fullPath);
+            port = result.port;
+            detectionMethod = result.method;
+        } else if (detectedLanguage === 'node' || detectedLanguage === 'javascript' || detectedLanguage === 'typescript') {
+            const result = await detectNodePort(fullPath);
+            port = result.port;
+            detectionMethod = result.method;
+        } else if (detectedLanguage === 'python') {
+            const result = await detectPythonPort(fullPath);
+            port = result.port;
+            detectionMethod = result.method;
+        } else if (detectedLanguage === 'dotnet' || detectedLanguage === 'csharp') {
+            const result = await detectDotNetPort(fullPath);
+            port = result.port;
+            detectionMethod = result.method;
+        } else {
+            // Try global detection
+            port = await detectPort(fullPath);
+            detectionMethod = 'global-detection';
+        }
+
+        console.log(`✅ Detected port: ${port || 'default'} via ${detectionMethod}`);
+
+        res.json({
+            ok: true,
+            port,
+            language: detectedLanguage,
+            framework: framework || null,
+            detectionMethod,
+            servicePath: servicePath || '/'
+        });
+    } catch (err) {
+        console.error('❌ Error detecting port:', err.message);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * Detects Spring Boot port from configuration files
+ */
+async function detectSpringBootPort(servicePath) {
+    const candidates = [
+        path.join(servicePath, 'src/main/resources/application.yml'),
+        path.join(servicePath, 'src/main/resources/application.yaml'),
+        path.join(servicePath, 'src/main/resources/application.properties'),
+        path.join(servicePath, 'src/main/resources/application-local.yml'),
+        path.join(servicePath, 'src/main/resources/application-local.yaml'),
+        path.join(servicePath, 'src/main/resources/application-local.properties'),
+        path.join(servicePath, 'application.yml'),
+        path.join(servicePath, 'application.yaml'),
+        path.join(servicePath, 'application.properties')
+    ];
+
+    for (const filePath of candidates) {
+        if (await exists(filePath)) {
+            try {
+                const content = await readFile(filePath, 'utf8');
+
+                // YAML format
+                if (filePath.endsWith('.yml') || filePath.endsWith('.yaml')) {
+                    // Match patterns like: server:\n  port: 8090 or server.port: 8090
+                    const simpleMatch = content.match(/server:\s*\n\s+port:\s*(\d+)/);
+                    if (simpleMatch) {
+                        return { port: parseInt(simpleMatch[1]), method: `yaml:${path.basename(filePath)}` };
+                    }
+
+                    // Also check for ${PORT:8080} or ${SERVER_PORT:8080} patterns
+                    const envMatch = content.match(/port:\s*\$\{[A-Z_]+:(\d+)\}/);
+                    if (envMatch) {
+                        return { port: parseInt(envMatch[1]), method: `yaml-env-default:${path.basename(filePath)}` };
+                    }
+                }
+
+                // Properties format
+                if (filePath.endsWith('.properties')) {
+                    const match = content.match(/server\.port\s*=\s*(\d+)/);
+                    if (match) {
+                        return { port: parseInt(match[1]), method: `properties:${path.basename(filePath)}` };
+                    }
+
+                    // Check for ${PORT:8080} pattern
+                    const envMatch = content.match(/server\.port\s*=\s*\$\{[A-Z_]+:(\d+)\}/);
+                    if (envMatch) {
+                        return { port: parseInt(envMatch[1]), method: `properties-env-default:${path.basename(filePath)}` };
+                    }
+                }
+            } catch (e) {
+                continue;
+            }
+        }
+    }
+
+    return { port: 8080, method: 'spring-boot-default' };
+}
+
+/**
+ * Detects Node.js port from configuration files
+ */
+async function detectNodePort(servicePath) {
+    // Try .env file
+    const envPath = path.join(servicePath, '.env');
+    if (await exists(envPath)) {
+        try {
+            const content = await readFile(envPath, 'utf8');
+            const match = content.match(/PORT\s*=\s*(\d+)/i);
+            if (match) {
+                return { port: parseInt(match[1]), method: 'dotenv' };
+            }
+        } catch (e) {
+            // Continue to next method
+        }
+    }
+
+    // Try .env.local
+    const envLocalPath = path.join(servicePath, '.env.local');
+    if (await exists(envLocalPath)) {
+        try {
+            const content = await readFile(envLocalPath, 'utf8');
+            const match = content.match(/PORT\s*=\s*(\d+)/i);
+            if (match) {
+                return { port: parseInt(match[1]), method: 'dotenv-local' };
+            }
+        } catch (e) {
+            // Continue to next method
+        }
+    }
+
+    // Try package.json scripts
+    const pkgPath = path.join(servicePath, 'package.json');
+    if (await exists(pkgPath)) {
+        try {
+            const content = await readFile(pkgPath, 'utf8');
+            const pkg = JSON.parse(content);
+            const scripts = JSON.stringify(pkg.scripts || {});
+
+            // Look for --port or PORT= patterns
+            const match = scripts.match(/--port[=\s]+(\d+)|PORT[=\s]+(\d+)|-p\s+(\d+)/i);
+            if (match) {
+                const port = parseInt(match[1] || match[2] || match[3]);
+                return { port, method: 'package-json-scripts' };
+            }
+        } catch (e) {
+            // Continue to default
+        }
+    }
+
+    return { port: 3000, method: 'node-default' };
+}
+
+/**
+ * Detects Python port from configuration files
+ */
+async function detectPythonPort(servicePath) {
+    // Try .env file
+    const envPath = path.join(servicePath, '.env');
+    if (await exists(envPath)) {
+        try {
+            const content = await readFile(envPath, 'utf8');
+            const match = content.match(/PORT\s*=\s*(\d+)/i);
+            if (match) {
+                return { port: parseInt(match[1]), method: 'dotenv' };
+            }
+        } catch (e) {
+            // Continue to next method
+        }
+    }
+
+    // Try config.py or settings.py
+    const configFiles = ['config.py', 'settings.py', 'app/config.py', 'src/config.py'];
+    for (const configFile of configFiles) {
+        const configPath = path.join(servicePath, configFile);
+        if (await exists(configPath)) {
+            try {
+                const content = await readFile(configPath, 'utf8');
+                const match = content.match(/PORT\s*=\s*(\d+)/i);
+                if (match) {
+                    return { port: parseInt(match[1]), method: `python-config:${configFile}` };
+                }
+            } catch (e) {
+                continue;
+            }
+        }
+    }
+
+    return { port: 8000, method: 'python-default' };
+}
+
+/**
+ * Detects .NET port from launchSettings.json
+ */
+async function detectDotNetPort(servicePath) {
+    const launchSettings = path.join(servicePath, 'Properties/launchSettings.json');
+
+    if (await exists(launchSettings)) {
+        try {
+            const content = await readFile(launchSettings, 'utf8');
+            const settings = JSON.parse(content);
+
+            const profiles = settings.profiles || {};
+            for (const [profileName, profile] of Object.entries(profiles)) {
+                if (profile.applicationUrl) {
+                    const match = profile.applicationUrl.match(/:(\d+)/);
+                    if (match) {
+                        return { port: parseInt(match[1]), method: `launchSettings:${profileName}` };
+                    }
+                }
+            }
+        } catch (e) {
+            // Continue to default
+        }
+    }
+
+    // Try appsettings.json
+    const appSettings = path.join(servicePath, 'appsettings.json');
+    if (await exists(appSettings)) {
+        try {
+            const content = await readFile(appSettings, 'utf8');
+            const settings = JSON.parse(content);
+
+            if (settings.Kestrel?.Endpoints?.Http?.Url) {
+                const match = settings.Kestrel.Endpoints.Http.Url.match(/:(\d+)/);
+                if (match) {
+                    return { port: parseInt(match[1]), method: 'appsettings-kestrel' };
+                }
+            }
+        } catch (e) {
+            // Continue to default
+        }
+    }
+
+    return { port: 5000, method: 'dotnet-default' };
+}
+
+// ============================================
+// TEST LOCAL ENDPOINTS (existing)
+// ============================================
+
+/** Prepare for testing: compile + discover endpoints */
+app.post("/workspace/test-local/prepare", async (req, res) => {
+    if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
+
+    try {
+        console.log("🔧 [TEST-LOCAL] Preparing test environment...");
+        TEST_LOCAL_STATE.status = "compiling";
+
+        // Step 1: Compile
+        const meta = await detectProject(WORKSPACE_ROOT);
+        const compileResult = await compileAndTest({
+            language: meta.language,
+            buildTool: meta.buildTool,
+            cwd: WORKSPACE_ROOT,
+            skipTests: true
+        });
+
+        if (compileResult.code !== 0) {
+            TEST_LOCAL_STATE.status = "error";
+            return res.status(500).json({
+                ok: false,
+                step: "compile",
+                error: compileResult.stderr
+            });
+        }
+
+        TEST_LOCAL_STATE.status = "compiled";
+
+        // Step 2: Discover endpoints
+        const scanner = new WorkspaceScanner(WORKSPACE_ROOT);
+        const structure = await scanner.scan();
+
+        const controllerAnalyzer = new ControllerAnalyzer(WORKSPACE_ROOT);
+        const apiDocs = await controllerAnalyzer.generateApiDocs(structure.files);
+
+        const dtoAnalyzer = new DTOAnalyzer(WORKSPACE_ROOT);
+        const payloadDocs = await dtoAnalyzer.generatePayloadDocs(structure.files, apiDocs.endpoints);
+
+        TEST_LOCAL_STATE.endpoints = payloadDocs.endpoints;
+
+        // Step 3: Get config
+        const configAnalyzer = new ConfigAnalyzer(WORKSPACE_ROOT);
+        const config = await configAnalyzer.analyze();
+        TEST_LOCAL_STATE.config = config;
+
+        console.log(`✅ [TEST-LOCAL] Prepared: ${payloadDocs.endpoints.length} endpoints discovered`);
+
+        res.json({
+            ok: true,
+            compilation: {
+                success: true,
+                language: meta.language,
+                buildTool: meta.buildTool,
+                duration: compileResult.duration
+            },
+            discovery: {
+                endpoints: payloadDocs.endpoints.length,
+                dtos: payloadDocs.totalDtos,
+                controllers: apiDocs.totalControllers
+            },
+            config: {
+                port: config.server.port,
+                contextPath: config.server.contextPath,
+                profiles: configAnalyzer.detectProfiles(config.files)
+            },
+            endpoints: payloadDocs.endpoints
+        });
+    } catch (err) {
+        console.error("❌ [TEST-LOCAL] Prepare failed:", err.message);
+        TEST_LOCAL_STATE.status = "error";
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * GET /workspace/test-local/compile/stream
+ * SSE endpoint for real-time compilation logs
+ */
+app.get("/workspace/test-local/compile/stream", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        res.status(400).json({ error: "workspace not set" });
+        return;
+    }
+
+    console.log("[INFO] Starting compilation stream...");
+
+    // Set headers for SSE
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.flushHeaders();
+
+    try {
+        const meta = await detectProject(WORKSPACE_ROOT);
+
+        // Send initial event
+        res.write(`event: log\n`);
+        res.write(`data: ${JSON.stringify({ type: "info", line: `[INFO] Starting build (compile + package + install)...`, timestamp: Date.now() })}\n\n`);
+
+        res.write(`event: log\n`);
+        res.write(`data: ${JSON.stringify({ type: "info", line: `[INFO] Build tool: ${meta.buildTool}`, timestamp: Date.now() })}\n\n`);
+
+        // Import spawn
+        const { spawn } = await import("child_process");
+
+        // Determine command based on build tool
+        let command, args;
+        switch (meta.buildTool) {
+            case "maven":
+                command = "mvn";
+                args = ["clean", "install", "-DskipTests", "-B"];
+                break;
+            case "gradle":
+                command = "./gradlew";
+                args = ["clean", "build", "-x", "test"];
+                break;
+            case "npm":
+                command = "npm";
+                args = ["run", "build"];
+                break;
+            case "yarn":
+                command = "yarn";
+                args = ["build"];
+                break;
+            default:
+                res.write(`event: error\n`);
+                res.write(`data: ${JSON.stringify({ error: `Unsupported build tool: ${meta.buildTool}` })}\n\n`);
+                res.end();
+                return;
+        }
+
+        console.log(`[INFO] Running: ${command} ${args.join(" ")}`);
+
+        const startTime = Date.now();
+        const proc = spawn(command, args, {
+            cwd: WORKSPACE_ROOT,
+            shell: true,
+            env: { ...process.env, MAVEN_OPTS: "-Dorg.slf4j.simpleLogger.defaultLogLevel=info" }
+        });
+
+        // Stream stdout
+        proc.stdout.on("data", (data) => {
+            const lines = data.toString().split("\n").filter(l => l.trim());
+            lines.forEach(line => {
+                console.log(`[STDOUT] ${line}`);
+                res.write(`event: log\n`);
+                res.write(`data: ${JSON.stringify({ type: "stdout", line, timestamp: Date.now() })}\n\n`);
+            });
+        });
+
+        // Stream stderr
+        proc.stderr.on("data", (data) => {
+            const lines = data.toString().split("\n").filter(l => l.trim());
+            lines.forEach(line => {
+                console.log(`[STDERR] ${line}`);
+                res.write(`event: log\n`);
+                res.write(`data: ${JSON.stringify({ type: "stderr", line, timestamp: Date.now() })}\n\n`);
+            });
+        });
+
+        // Handle completion
+        proc.on("close", (code) => {
+            const duration = Date.now() - startTime;
+            const success = code === 0;
+
+            console.log(`[INFO] Compilation ${success ? "successful" : "failed"} (${duration}ms)`);
+
+            res.write(`event: complete\n`);
+            res.write(`data: ${JSON.stringify({
+                success,
+                exitCode: code,
+                duration,
+                message: success ? "Compilation successful" : "Compilation failed"
+            })}\n\n`);
+
+            res.end();
+        });
+
+        // Handle errors
+        proc.on("error", (error) => {
+            console.error(`[ERROR] Compilation process error: ${error.message}`);
+            res.write(`event: error\n`);
+            res.write(`data: ${JSON.stringify({ error: error.message })}\n\n`);
+            res.end();
+        });
+
+        // Handle client disconnect
+        req.on("close", () => {
+            console.log("[INFO] Client disconnected, killing compilation process");
+            proc.kill();
+        });
+
+    } catch (error) {
+        console.error(`[ERROR] Compilation stream error: ${error.message}`);
+        res.write(`event: error\n`);
+        res.write(`data: ${JSON.stringify({ error: error.message })}\n\n`);
+        res.end();
+    }
+});
+
+/**
+ * GET /workspace/test-local/logs/stream
+ * SSE endpoint for real-time server logs
+ */
+app.get("/workspace/test-local/logs/stream", async (req, res) => {
+    console.log("[INFO] Client connected to logs stream");
+
+    // Set headers for SSE
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.flushHeaders();
+
+    try {
+        // Send existing logs first
+        if (TEST_LOCAL_STATE.serverLogs.length > 0) {
+            TEST_LOCAL_STATE.serverLogs.forEach(log => {
+                res.write(`event: log\n`);
+                res.write(`data: ${JSON.stringify(log)}\n\n`);
+            });
+        }
+
+        // Send heartbeat to keep connection alive
+        const heartbeatInterval = setInterval(() => {
+            res.write(`event: heartbeat\n`);
+            res.write(`data: ${JSON.stringify({ timestamp: Date.now() })}\n\n`);
+        }, 30000);
+
+        // Monitor for new logs
+        const logCheckInterval = setInterval(() => {
+            // This will be updated by ProcessManager events
+            // For now, just keep connection alive
+        }, 1000);
+
+        // Handle client disconnect
+        req.on("close", () => {
+            console.log("[INFO] Client disconnected from logs stream");
+            clearInterval(heartbeatInterval);
+            clearInterval(logCheckInterval);
+        });
+
+    } catch (error) {
+        console.error(`[ERROR] Logs stream error: ${error.message}`);
+        res.write(`event: error\n`);
+        res.write(`data: ${JSON.stringify({ error: error.message })}\n\n`);
+        res.end();
+    }
+});
+
+// ============================================
+// 🆕 AUTO-TRAINING ENDPOINTS
+// Escanear e ler arquivos para treinamento AI
+// ============================================
+
+/**
+ * POST /workspace/scan-files
+ * Escaneia todos os arquivos do workspace para auto-training
+ */
+app.post("/workspace/scan-files", async (req, res) => {
+    const { root, excludePatterns = [], includeExtensions = [], maxDepth = 10, maxFiles = 1000 } = req.body;
+
+    const workspaceRoot = root || WORKSPACE_ROOT;
+    if (!workspaceRoot) {
+        return res.status(400).json({
+            error: "workspace not set",
+            hint: "provide 'root' in body or call POST /workspace/open first"
+        });
+    }
+
+    console.log(`📂 [SCAN-FILES] Scanning: ${workspaceRoot}`);
+    console.log(`   Extensions: ${includeExtensions.join(", ")}`);
+    console.log(`   Exclude: ${excludePatterns.join(", ")}`);
+
+    try {
+        const files = [];
+        const fs = await import("fs/promises");
+        const pathModule = await import("path");
+
+        // Padrões padrão para excluir
+        const defaultExcludes = [
+            "node_modules", "target", "build", "dist", ".git", ".idea",
+            ".vscode", "__pycache__", ".gradle", "bin", "obj",
+            "*.min.js", "*.min.css", "package-lock.json", "yarn.lock"
+        ];
+        const allExcludes = [...defaultExcludes, ...excludePatterns];
+
+        // Função recursiva para escanear
+        async function scanDir(dir, depth = 0) {
+            if (depth > maxDepth || files.length >= maxFiles) return;
+
+            try {
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+
+                for (const entry of entries) {
+                    if (files.length >= maxFiles) break;
+
+                    const fullPath = pathModule.join(dir, entry.name);
+                    const relativePath = pathModule.relative(workspaceRoot, fullPath);
+
+                    // Verificar se deve excluir
+                    const shouldExclude = allExcludes.some(pattern => {
+                        if (pattern.includes("*")) {
+                            const regex = new RegExp(pattern.replace(/\*/g, ".*"));
+                            return regex.test(entry.name) || regex.test(relativePath);
+                        }
+                        return entry.name === pattern || relativePath.includes(pattern);
+                    });
+
+                    if (shouldExclude) continue;
+
+                    if (entry.isDirectory()) {
+                        await scanDir(fullPath, depth + 1);
+                    } else if (entry.isFile()) {
+                        // Verificar extensão
+                        const ext = pathModule.extname(entry.name).toLowerCase();
+                        if (includeExtensions.length === 0 || includeExtensions.includes(ext)) {
+                            files.push(relativePath);
+                        }
+                    }
+                }
+            } catch (error) {
+                console.warn(`⚠️ Cannot read directory ${dir}: ${error.message}`);
+            }
+        }
+
+        await scanDir(workspaceRoot);
+
+        console.log(`✅ [SCAN-FILES] Found ${files.length} files`);
+
+        res.json({
+            success: true,
+            files,
+            totalFiles: files.length,
+            workspace: workspaceRoot
+        });
+
+    } catch (error) {
+        console.error(`❌ [SCAN-FILES] Error: ${error.message}`);
+        res.status(500).json({
+            success: false,
+            error: error.message,
+            files: []
+        });
+    }
+});
+
+/**
+ * POST /workspace/read-file
+ * Lê conteúdo de um arquivo específico
+ */
+app.post("/workspace/read-file", async (req, res) => {
+    const { root, filePath } = req.body;
+
+    const workspaceRoot = root || WORKSPACE_ROOT;
+    if (!workspaceRoot) {
+        return res.status(400).json({
+            error: "workspace not set"
+        });
+    }
+
+    if (!filePath) {
+        return res.status(400).json({
+            error: "filePath is required"
+        });
+    }
+
+    console.log(`📄 [READ-FILE] Reading: ${filePath}`);
+
+    try {
+        const fs = await import("fs/promises");
+        const pathModule = await import("path");
+
+        const fullPath = pathModule.join(workspaceRoot, filePath);
+
+        // Verificar se arquivo existe
+        const stats = await fs.stat(fullPath);
+
+        // Limitar tamanho (100KB)
+        if (stats.size > 100 * 1024) {
+            return res.json({
+                success: false,
+                error: "File too large (max 100KB)",
+                filePath,
+                sizeBytes: stats.size
+            });
+        }
+
+        const content = await fs.readFile(fullPath, "utf-8");
+
+        res.json({
+            success: true,
+            filePath,
+            content,
+            sizeBytes: content.length
+        });
+
+    } catch (error) {
+        console.error(`❌ [READ-FILE] Error: ${error.message}`);
+        res.status(404).json({
+            success: false,
+            error: error.message,
+            filePath
+        });
+    }
+});
+
+/**
+ * POST /workspace/read-files
+ * Lê múltiplos arquivos de uma vez (batch)
+ */
+app.post("/workspace/read-files", async (req, res) => {
+    const { root, filePaths } = req.body;
+
+    const workspaceRoot = root || WORKSPACE_ROOT;
+    if (!workspaceRoot) {
+        return res.status(400).json({
+            error: "workspace not set"
+        });
+    }
+
+    if (!filePaths || !Array.isArray(filePaths)) {
+        return res.status(400).json({
+            error: "filePaths array is required"
+        });
+    }
+
+    console.log(`📚 [READ-FILES] Reading ${filePaths.length} files`);
+
+    try {
+        const fs = await import("fs/promises");
+        const pathModule = await import("path");
+
+        const files = {};
+        const errors = [];
+
+        for (const filePath of filePaths) {
+            try {
+                const fullPath = pathModule.join(workspaceRoot, filePath);
+                const stats = await fs.stat(fullPath);
+
+                // Pular arquivos muito grandes
+                if (stats.size > 100 * 1024) {
+                    errors.push({ filePath, error: "File too large" });
+                    continue;
+                }
+
+                const content = await fs.readFile(fullPath, "utf-8");
+                files[filePath] = content;
+            } catch (error) {
+                errors.push({ filePath, error: error.message });
+            }
+        }
+
+        console.log(`✅ [READ-FILES] Read ${Object.keys(files).length} files, ${errors.length} errors`);
+
+        res.json({
+            success: true,
+            files,
+            totalRead: Object.keys(files).length,
+            errors: errors.length > 0 ? errors : undefined
+        });
+
+    } catch (error) {
+        console.error(`❌ [READ-FILES] Error: ${error.message}`);
+        res.status(500).json({
+            success: false,
+            error: error.message
+        });
+    }
+});
+
+// ============================================
+// 🆕 SYSTEM FOLDER PICKER ENDPOINT
+// Abre file picker nativo do SO (Windows/Mac/Linux)
+// ============================================
+
+/**
+ * GET /system/folder-picker
+ * Abre o file picker nativo do sistema operacional
+ */
+app.get("/system/folder-picker", async (req, res) => {
+    console.log(`📂 [FOLDER-PICKER] Opening native folder picker...`);
+
+    try {
+        const platform = process.platform;
+        let selectedPath = null;
+
+        if (platform === "darwin") {
+            // macOS - usar osascript (AppleScript)
+            const script = `osascript -e 'POSIX path of (choose folder with prompt "Select your project folder")'`;
+            try {
+                const { stdout } = await execAsync(script);
+                selectedPath = stdout.trim();
+            } catch (error) {
+                // Usuário cancelou
+                if (error.code === 1) {
+                    return res.json({
+                        success: true,
+                        path: null,
+                        canceled: true
+                    });
+                }
+                throw error;
+            }
+
+        } else if (platform === "win32") {
+            // Windows - usar PowerShell
+            const script = `powershell -command "Add-Type -AssemblyName System.Windows.Forms; $folder = New-Object System.Windows.Forms.FolderBrowserDialog; $folder.Description = 'Select your project folder'; $folder.ShowNewFolderButton = $true; if ($folder.ShowDialog() -eq 'OK') { $folder.SelectedPath } else { '' }"`;
+            try {
+                const { stdout } = await execAsync(script);
+                selectedPath = stdout.trim();
+                if (!selectedPath) {
+                    return res.json({
+                        success: true,
+                        path: null,
+                        canceled: true
+                    });
+                }
+            } catch (error) {
+                throw error;
+            }
+
+        } else if (platform === "linux") {
+            // Linux - tentar zenity, kdialog ou yad
+            const commands = [
+                `zenity --file-selection --directory --title="Select your project folder"`,
+                `kdialog --getexistingdirectory ~ --title "Select your project folder"`,
+                `yad --file --directory --title="Select your project folder"`
+            ];
+
+            let success = false;
+            for (const cmd of commands) {
+                try {
+                    const { stdout } = await execAsync(cmd);
+                    selectedPath = stdout.trim();
+                    if (selectedPath) {
+                        success = true;
+                        break;
+                    }
+                } catch (error) {
+                    continue;
+                }
+            }
+
+            if (!success) {
+                return res.status(500).json({
+                    success: false,
+                    error: "No file picker available. Install zenity, kdialog, or yad.",
+                    hint: "sudo apt install zenity"
+                });
+            }
+
+        } else {
+            return res.status(500).json({
+                success: false,
+                error: `Unsupported platform: ${platform}`
+            });
+        }
+
+        // Remover trailing slash se houver
+        if (selectedPath && selectedPath.endsWith("/")) {
+            selectedPath = selectedPath.slice(0, -1);
+        }
+
+        console.log(`✅ [FOLDER-PICKER] Selected: ${selectedPath}`);
+
+        res.json({
+            success: true,
+            path: selectedPath,
+            canceled: false
+        });
+
+    } catch (error) {
+        console.error(`❌ [FOLDER-PICKER] Error:`, error.message);
+        res.status(500).json({
+            success: false,
+            error: error.message,
+            path: null,
+            canceled: false
+        });
+    }
+});
+
+/**
+ * GET /system/info
+ * Retorna informações do sistema
+ */
+app.get("/system/info", (req, res) => {
+    res.json({
+        platform: process.platform,
+        arch: process.arch,
+        nodeVersion: process.version,
+        homedir: process.env.HOME || process.env.USERPROFILE,
+        cwd: process.cwd()
+    });
+});
+
+// ============================================
+// 🆕 API DOCS ENDPOINT
+// Retorna endpoints detectados das controllers
+// ============================================
+
+/**
+ * GET /workspace/api-docs
+ * Analisa controllers e retorna todos os endpoints da API
+ */
+app.get("/workspace/api-docs", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({
+            error: "workspace not set",
+            hint: "call POST /workspace/open first"
+        });
+    }
+
+    console.log(`📚 [API-DOCS] Analyzing controllers in ${WORKSPACE_ROOT}`);
+
+    try {
+        // Primeiro, escanear arquivos do workspace
+        const fs = await import("fs/promises");
+        const pathModule = await import("path");
+
+        const files = [];
+
+        async function scanDir(dir, depth = 0) {
+            if (depth > 10) return;
+
+            try {
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+
+                for (const entry of entries) {
+                    const fullPath = pathModule.join(dir, entry.name);
+                    const relativePath = pathModule.relative(WORKSPACE_ROOT, fullPath);
+
+                    // Skip common ignored directories
+                    if (entry.name === 'node_modules' || entry.name === 'target' ||
+                        entry.name === 'build' || entry.name === '.git' ||
+                        entry.name === '.idea' || entry.name === 'dist') {
+                        continue;
+                    }
+
+                    if (entry.isDirectory()) {
+                        await scanDir(fullPath, depth + 1);
+                    } else if (entry.isFile() && entry.name.endsWith('.java')) {
+                        files.push({ path: relativePath });
+                    }
+                }
+            } catch (err) {
+                // Ignore permission errors
+            }
+        }
+
+        await scanDir(WORKSPACE_ROOT);
+
+        console.log(`📁 [API-DOCS] Found ${files.length} Java files`);
+
+        // Agora analisar os controllers
+        const controllerAnalyzer = new ControllerAnalyzer(WORKSPACE_ROOT);
+        const apiDocs = await controllerAnalyzer.generateApiDocs(files);
+
+        console.log(`✅ [API-DOCS] Found ${apiDocs.totalEndpoints} endpoints in ${apiDocs.totalControllers} controllers`);
+
+        res.json({
+            success: true,
+            endpoints: apiDocs.endpoints,
+            controllers: apiDocs.controllers.map(c => c.className),
+            totalEndpoints: apiDocs.totalEndpoints,
+            totalControllers: apiDocs.totalControllers,
+            workspace: WORKSPACE_ROOT
+        });
+
+    } catch (error) {
+        console.error(`❌ [API-DOCS] Error:`, error.message);
+
+        res.json({
+            success: false,
+            error: error.message,
+            endpoints: [],
+            controllers: [],
+            totalEndpoints: 0,
+            totalControllers: 0
+        });
+    }
+});
+
+/**
+ * GET /workspace/api-docs/:controller
+ * Retorna endpoints de uma controller específica
+ */
+app.get("/workspace/api-docs/:controller", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({
+            error: "workspace not set",
+            hint: "call POST /workspace/open first"
+        });
+    }
+
+    const { controller } = req.params;
+    console.log(`📚 [API-DOCS] Getting endpoints for controller: ${controller}`);
+
+    try {
+        // Primeiro, escanear arquivos do workspace
+        const fs = await import("fs/promises");
+        const pathModule = await import("path");
+
+        const files = [];
+
+        async function scanDir(dir, depth = 0) {
+            if (depth > 10) return;
+
+            try {
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+
+                for (const entry of entries) {
+                    const fullPath = pathModule.join(dir, entry.name);
+                    const relativePath = pathModule.relative(WORKSPACE_ROOT, fullPath);
+
+                    if (entry.name === 'node_modules' || entry.name === 'target' ||
+                        entry.name === 'build' || entry.name === '.git' ||
+                        entry.name === '.idea' || entry.name === 'dist') {
+                        continue;
+                    }
+
+                    if (entry.isDirectory()) {
+                        await scanDir(fullPath, depth + 1);
+                    } else if (entry.isFile() && entry.name.endsWith('.java')) {
+                        files.push({ path: relativePath });
+                    }
+                }
+            } catch (err) {
+                // Ignore permission errors
+            }
+        }
+
+        await scanDir(WORKSPACE_ROOT);
+
+        // Analisar os controllers
+        const controllerAnalyzer = new ControllerAnalyzer(WORKSPACE_ROOT);
+        const apiDocs = await controllerAnalyzer.generateApiDocs(files);
+
+        const found = apiDocs.controllers?.find(c =>
+            c.className.toLowerCase() === controller.toLowerCase() ||
+            c.className.toLowerCase().includes(controller.toLowerCase())
+        );
+
+        if (!found) {
+            return res.status(404).json({
+                success: false,
+                error: `Controller '${controller}' not found`,
+                availableControllers: apiDocs.controllers?.map(c => c.className) || []
+            });
+        }
+
+        const endpoints = (found.endpoints || []).map(endpoint => ({
+            method: endpoint.method || "GET",
+            path: endpoint.path || "",
+            methodName: endpoint.methodName || "",
+            returnType: endpoint.returnType || "void",
+            requestBody: endpoint.requestBody || null,
+            pathVariables: endpoint.pathVariables || [],
+            queryParams: endpoint.queryParams || []
+        }));
+
+        res.json({
+            success: true,
+            controller: found.className,
+            file: found.file,
+            basePath: found.basePath,
+            endpoints,
+            totalEndpoints: endpoints.length
+        });
+
+    } catch (error) {
+        console.error(`❌ [API-DOCS] Error:`, error.message);
+        res.status(500).json({
+            success: false,
+            error: error.message
+        });
+    }
+});
+
+// ============================================
+// 🧠 AI ENGINE ENDPOINTS
+// ============================================
+
+/**
+ * GET /ai-engine/status
+ * Retorna estado do AI Vibe Coding Engine
+ */
+app.get("/ai-engine/status", (req, res) => {
+    res.json(aiEngine ? aiEngine.getStatus() : { active: false, error: 'AI Engine not initialized' });
+});
+
+/**
+ * POST /ai-engine/toggle
+ * Liga/desliga o auto-healing
+ */
+app.post("/ai-engine/toggle", (req, res) => {
+    const { active } = req.body || {};
+    if (aiEngine) {
+        aiEngine.setActive(active !== false);
+        res.json({ ok: true, active: aiEngine.isActive });
+    } else {
+        res.status(500).json({ ok: false, error: 'AI Engine not initialized' });
+    }
+});
+
+/**
+ * POST /ai-engine/clear-history
+ * Limpa histórico de erros e fixes
+ */
+app.post("/ai-engine/clear-history", (req, res) => {
+    if (aiEngine) {
+        aiEngine.clearHistory();
+        res.json({ ok: true });
+    } else {
+        res.status(500).json({ ok: false, error: 'AI Engine not initialized' });
+    }
+});
+
+/**
+ * GET /ai-engine/errors
+ * Retorna histórico de erros
+ */
+app.get("/ai-engine/errors", (req, res) => {
+    const { limit = 50 } = req.query;
+    if (aiEngine) {
+        res.json({
+            ok: true,
+            errors: aiEngine.errorHistory.slice(-parseInt(limit)),
+            total: aiEngine.errorHistory.length
+        });
+    } else {
+        res.json({ ok: true, errors: [], total: 0 });
+    }
+});
+
+/**
+ * GET /ai-engine/fixes
+ * Retorna histórico de fixes
+ */
+app.get("/ai-engine/fixes", (req, res) => {
+    if (aiEngine) {
+        res.json({
+            ok: true,
+            fixes: aiEngine.fixHistory,
+            pending: aiEngine.pendingFixes
+        });
+    } else {
+        res.json({ ok: true, fixes: [], pending: [] });
+    }
+});
+
+/**
+ * GET /workspace/smart-config
+ * Recolhe ficheiros de configuração para análise AI
+ */
+app.get("/workspace/smart-config", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({ error: "workspace not set" });
+    }
+
+    console.log("🧠 [SMART-CONFIG] Collecting configuration files...");
+
+    try {
+        const configPatterns = [
+            'pom.xml', 'build.gradle', 'build.gradle.kts',
+            'src/main/resources/application.yml',
+            'src/main/resources/application.yaml',
+            'src/main/resources/application.properties',
+            'src/main/resources/application-dev.yml',
+            'src/main/resources/application-local.yml',
+            'src/main/resources/application-test.yml',
+            'src/main/resources/application-h2.yml',
+            'src/main/resources/application-prod.yml',
+            'src/main/resources/bootstrap.yml',
+            'package.json', '.env', '.env.local',
+            'docker-compose.yml', 'Dockerfile'
+        ];
+
+        const collectedFiles = [];
+        const meta = await detectProject(WORKSPACE_ROOT);
+
+        for (const pattern of configPatterns) {
+            const filePath = path.join(WORKSPACE_ROOT, pattern);
+            if (fs.existsSync(filePath)) {
+                try {
+                    const content = fs.readFileSync(filePath, 'utf8');
+                    const maxSize = 15000;
+                    collectedFiles.push({
+                        path: pattern,
+                        content: content.length > maxSize
+                            ? content.substring(0, maxSize) + '\n...[truncated]'
+                            : content,
+                        size: content.length
+                    });
+                    console.log(`📄 Found: ${pattern}`);
+                } catch (err) {
+                    console.error(`❌ Error reading ${pattern}: ${err.message}`);
+                }
+            }
+        }
+
+        // Detectar profiles disponíveis
+        const availableProfiles = [];
+        const resourcesDir = path.join(WORKSPACE_ROOT, 'src/main/resources');
+        if (fs.existsSync(resourcesDir)) {
+            const files = fs.readdirSync(resourcesDir);
+            files.forEach(file => {
+                const match = file.match(/application-(\w+)\.(yml|yaml|properties)/);
+                if (match) availableProfiles.push(match[1]);
+            });
+        }
+
+        console.log(`✅ Collected ${collectedFiles.length} files, profiles: ${availableProfiles.join(', ')}`);
+
+        res.json({
+            ok: true,
+            workspace: WORKSPACE_ROOT,
+            language: meta.language,
+            buildTool: meta.buildTool,
+            framework: meta.framework || 'unknown',
+            files: collectedFiles,
+            availableProfiles,
+            collectedAt: new Date().toISOString()
+        });
+
+    } catch (err) {
+        console.error("❌ [SMART-CONFIG] Error:", err.message);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * POST /workspace/test-local/restart
+ * Restarts the server with auto-healing using last successful config
+ */
+app.post("/workspace/test-local/restart", async (req, res) => {
+    try {
+        console.log("🔄 [TEST-LOCAL] Restarting server...");
+
+        // Stop
+        await processManager.stop('test-local');
+
+        // Esperar um pouco
+        await new Promise(r => setTimeout(r, 2000));
+
+        // Usar última config que funcionou
+        const config = (aiEngine && aiEngine.lastSuccessfulConfig) || TEST_LOCAL_STATE.config;
+
+        if (!config) {
+            return res.status(400).json({ error: "No previous config found" });
+        }
+
+        // Start com auto-healing
+        let result;
+        if (aiEngine && aiEngine.isActive) {
+            result = await aiEngine.startWithAutoHealing(config);
+        } else {
+            await processManager.start('test-local', config);
+            result = { ok: true, config };
+        }
+
+        if (result.ok) {
+            TEST_LOCAL_STATE.status = "running";
+            TEST_LOCAL_STATE.config = result.config;
+
+            res.json({
+                ok: true,
+                status: "running",
+                config: result.config,
+                attempts: result.attempts || 1,
+                autoHealed: result.autoHealed || false
+            });
+        } else {
+            TEST_LOCAL_STATE.status = "error";
+            res.status(500).json({
+                ok: false,
+                error: result.error,
+                attempts: result.attempts
+            });
+        }
+
+    } catch (err) {
+        console.error("❌ [TEST-LOCAL] Restart failed:", err.message);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+// ============================================
+// 🤖 AGENTIC TOOLS ENDPOINTS
+// Used by the agentic Claude loop for autonomous debugging
+// ============================================
+
+/**
+ * POST /workspace/search
+ *
+ * Grep-based search across all files in the workspace.
+ * Used by the agentic Claude to find code patterns quickly.
+ *
+ * Body: { "pattern": "validateToken", "fileFilter": "*.java" }
+ * Response: { "ok": true, "results": "file:line: matching text\n...", "count": 15 }
+ */
+app.post("/workspace/search", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({
+            ok: false,
+            error: "workspace not set",
+            hint: "call POST /workspace/open first"
+        });
+    }
+
+    const { pattern, fileFilter } = req.body || {};
+    if (!pattern) {
+        return res.status(400).json({ ok: false, error: "pattern is required" });
+    }
+
+    console.log(`🔍 [workspace/search] pattern="${pattern}" filter="${fileFilter || '*'}"`);
+
+    try {
+        const { execSync } = await import('child_process');
+
+        // Build grep command with safety limits
+        let cmd = `grep -rn `;
+
+        // Apply file filter if provided
+        if (fileFilter && fileFilter.trim()) {
+            cmd += `--include="${fileFilter}" `;
+        }
+
+        // Exclude common non-source directories
+        cmd += `--exclude-dir=node_modules --exclude-dir=.git --exclude-dir=target `;
+        cmd += `--exclude-dir=build --exclude-dir=dist --exclude-dir=.idea `;
+        cmd += `--exclude-dir=__pycache__ --exclude-dir=.next --exclude-dir=vendor `;
+        cmd += `--exclude-dir=bin --exclude-dir=obj --exclude-dir=.gradle `;
+        cmd += `--exclude-dir=.mvn --exclude-dir=.venv --exclude-dir=coverage `;
+
+        // Escape pattern for shell safety and limit results
+        const safePattern = pattern.replace(/"/g, '\\"').replace(/`/g, '\\`').replace(/\$/g, '\\$');
+        cmd += `"${safePattern}" "${WORKSPACE_ROOT}" | head -100`;
+
+        let stdout = '';
+        try {
+            stdout = execSync(cmd, {
+                encoding: 'utf8',
+                timeout: 15000,
+                maxBuffer: 1024 * 1024
+            });
+        } catch (grepErr) {
+            // grep returns exit code 1 when no matches found
+            if (grepErr.status === 1) {
+                return res.json({
+                    ok: true,
+                    results: `No matches found for: ${pattern}`,
+                    count: 0
+                });
+            }
+            // Exit code 2 = error in grep
+            if (grepErr.status === 2) {
+                return res.status(400).json({
+                    ok: false,
+                    error: "Invalid search pattern: " + grepErr.message
+                });
+            }
+            throw grepErr;
+        }
+
+        // Make paths relative to workspace root for readability
+        const results = stdout
+            .split('\n')
+            .filter(line => line.trim())
+            .map(line => line.replace(WORKSPACE_ROOT + '/', ''))
+            .join('\n');
+
+        const count = results.split('\n').filter(l => l.trim()).length;
+        console.log(`  ✅ Found ${count} matches`);
+
+        res.json({
+            ok: true,
+            results: results,
+            count: count
+        });
+    } catch (err) {
+        console.error(`❌ [workspace/search] Error:`, err.message);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * POST /workspace/exec
+ *
+ * Execute a shell command in the workspace directory.
+ * Used by the agentic Claude for build steps, dependency checks, etc.
+ *
+ * Body: { "command": "mvn dependency:tree" }
+ * Response: { "ok": true, "stdout": "...", "stderr": "...", "exitCode": 0 }
+ *
+ * SECURITY: Commands run inside the workspace directory only.
+ * Dangerous commands are blocked.
+ */
+app.post("/workspace/exec", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({
+            ok: false,
+            error: "workspace not set",
+            hint: "call POST /workspace/open first"
+        });
+    }
+
+    const { command } = req.body || {};
+    if (!command) {
+        return res.status(400).json({ ok: false, error: "command is required" });
+    }
+
+    // Security: block dangerous commands
+    const dangerous = [
+        'rm -rf /', 'rm -rf /*', 'mkfs', 'dd if=', 'shutdown', 'reboot',
+        'init 0', '> /dev/', 'chmod -R 777 /', 'curl | sh', 'wget | sh',
+        'curl | bash', 'wget | bash', 'format c:', 'del /f /s /q'
+    ];
+    const lowerCmd = command.toLowerCase().trim();
+    if (dangerous.some(d => lowerCmd.includes(d))) {
+        console.warn(`⚠️ [workspace/exec] BLOCKED dangerous command: ${command}`);
+        return res.status(403).json({
+            ok: false,
+            error: "Command blocked for security reasons"
+        });
+    }
+
+    console.log(`⚡ [workspace/exec] Running: ${command.substring(0, 120)}...`);
+
+    try {
+        const { exec: execCb } = await import('child_process');
+        const { promisify } = await import('util');
+        const execAsync = promisify(execCb);
+
+        const result = await execAsync(command, {
+            cwd: WORKSPACE_ROOT,
+            timeout: 60000,
+            maxBuffer: 5 * 1024 * 1024,
+            env: { ...process.env, FORCE_COLOR: '0' }
+        });
+
+        console.log(`  ✅ Command completed (stdout: ${result.stdout.length} chars)`);
+
+        res.json({
+            ok: true,
+            stdout: result.stdout,
+            stderr: result.stderr,
+            exitCode: 0
+        });
+    } catch (err) {
+        console.error(`  ❌ Command failed (exit: ${err.code}):`, err.message?.substring(0, 200));
+        res.json({
+            ok: false,
+            stdout: err.stdout || '',
+            stderr: err.stderr || err.message,
+            exitCode: err.code || 1
+        });
+    }
+});
+
+// ============================================
+// 🧪 ENDPOINT TESTING
+// Execute curl-like requests and capture full request/response
+// ============================================
+
+/**
+ * POST /workspace/test-endpoint
+ * Makes an HTTP request and captures the full request/response for evidence.
+ *
+ * Body: { method, url, headers?, body?, testName, expectedStatus? }
+ */
+app.post("/workspace/test-endpoint", async (req, res) => {
+    const { method = 'GET', url, headers = {}, body: reqBody, testName, expectedStatus } = req.body || {};
+
+    if (!url) {
+        return res.status(400).json({ error: "url is required" });
+    }
+
+    // Security: only localhost
+    if (!url.startsWith('http://localhost') && !url.startsWith('http://127.0.0.1')) {
+        return res.status(403).json({ error: "Only localhost URLs allowed for security" });
+    }
+
+    console.log(`🧪 Testing: ${method} ${url} (${testName || 'unnamed'})`);
+
+    const startTime = Date.now();
+
+    try {
+        const fetchOptions = {
+            method: method.toUpperCase(),
+            headers: {
+                'Content-Type': 'application/json',
+                ...headers
+            },
+            signal: AbortSignal.timeout(15000) // 15s timeout
+        };
+
+        if (reqBody && ['POST', 'PUT', 'PATCH'].includes(method.toUpperCase())) {
+            fetchOptions.body = reqBody;
+        }
+
+        const response = await fetch(url, fetchOptions);
+        const durationMs = Date.now() - startTime;
+
+        // Capture response
+        let responseBody = '';
+        const contentType = response.headers.get('content-type') || '';
+        if (contentType.includes('json') || contentType.includes('text')) {
+            responseBody = await response.text();
+        } else {
+            responseBody = `[Binary content: ${contentType}, ${response.headers.get('content-length') || '?'} bytes]`;
+        }
+
+        // Capture response headers (key ones)
+        const responseHeaders = {};
+        for (const key of ['content-type', 'content-length', 'x-request-id', 'authorization', 'set-cookie']) {
+            const val = response.headers.get(key);
+            if (val) responseHeaders[key] = val;
+        }
+
+        const result = {
+            ok: true,
+            testName,
+            status: response.status,
+            statusText: response.statusText,
+            body: responseBody.substring(0, 5000), // Cap at 5KB
+            responseHeaders,
+            durationMs,
+            passed: expectedStatus
+                ? response.status === expectedStatus
+                : response.status >= 200 && response.status < 400
+        };
+
+        console.log(`   → ${response.status} ${response.statusText} (${durationMs}ms) ${result.passed ? '✅' : '❌'}`);
+        res.json(result);
+
+    } catch (err) {
+        const durationMs = Date.now() - startTime;
+        console.error(`   → ❌ Failed: ${err.message} (${durationMs}ms)`);
+
+        res.json({
+            ok: false,
+            testName,
+            status: 0,
+            statusText: 'Connection Failed',
+            body: err.message,
+            responseHeaders: {},
+            durationMs,
+            passed: false,
+            error: err.message
+        });
+    }
+});
+
+// ============================================
+// 🔀 GIT INTEGRATION
+// Create branch, commit, push for auto-fix PRs
+// ============================================
+
+/**
+ * POST /workspace/git/create-fix-branch
+ * Creates a branch, commits changes, and pushes to remote.
+ *
+ * Body: { branchName, commitMessage, files? }
+ */
+app.post("/workspace/git/create-fix-branch", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({ error: "workspace not set" });
+    }
+
+    const { branchName, commitMessage, files, gitToken, repoUrl } = req.body || {};
+    if (!branchName || !commitMessage) {
+        return res.status(400).json({ error: "branchName and commitMessage required" });
+    }
+
+    try {
+        const { execSync } = await import('child_process');
+        const opts = {
+            cwd: WORKSPACE_ROOT,
+            encoding: 'utf8',
+            timeout: 30000,
+            env: {
+                ...process.env,
+                GIT_TERMINAL_PROMPT: '0',      // Never prompt for credentials
+                GIT_ASKPASS: 'echo',            // Return empty if asked
+                GIT_SSH_COMMAND: 'ssh -o BatchMode=yes -o StrictHostKeyChecking=no -o ConnectTimeout=5'
+            }
+        };
+
+        // 1. Check if git repo
+        try {
+            execSync('git rev-parse --is-inside-work-tree', opts);
+        } catch {
+            return res.status(400).json({
+                ok: false,
+                error: "Not a git repository",
+                hint: "The workspace must be a git repository to create branches"
+            });
+        }
+
+        // 2. Get current branch
+        const currentBranch = execSync('git branch --show-current', opts).trim();
+
+        // 3. Stash any uncommitted changes first (they might conflict with checkout)
+        let hadStash = false;
+        try {
+            const stashResult = execSync('git stash --include-untracked 2>&1', opts).trim();
+            hadStash = !stashResult.includes('No local changes');
+            if (hadStash) console.log('📦 Stashed uncommitted changes');
+        } catch {}
+
+        // 4. Create and checkout new branch (with unique name if exists)
+        let finalBranchName = branchName;
+        try {
+            execSync(`git checkout -b ${finalBranchName}`, opts);
+        } catch (e) {
+            // Branch already exists — add timestamp suffix
+            finalBranchName = `${branchName}-${Date.now() % 100000}`;
+            try {
+                execSync(`git checkout -b ${finalBranchName}`, opts);
+            } catch (e2) {
+                // Restore stash and bail
+                if (hadStash) try { execSync('git stash pop', opts); } catch {}
+                return res.status(400).json({ ok: false, error: `Could not create branch: ${e2.message}` });
+            }
+        }
+
+        // 5. Pop the stash back (apply the changes on the new branch)
+        if (hadStash) {
+            try {
+                execSync('git stash pop', opts);
+            } catch (e) {
+                console.warn('⚠️ Stash pop had conflicts, trying apply:', e.message);
+                try { execSync('git stash apply', opts); } catch {}
+            }
+        }
+
+        // 6. Stage changes
+        if (files && files.length > 0) {
+            for (const file of files) {
+                execSync(`git add "${file}"`, opts);
+            }
+        } else {
+            execSync('git add -A', opts);
+        }
+
+        // 7. Check for changes
+        const status = execSync('git status --porcelain', opts).trim();
+        if (!status) {
+            try { execSync(`git checkout ${currentBranch}`, opts); } catch {}
+            return res.json({ ok: false, error: "No changes to commit" });
+        }
+
+        // 8. Commit
+        const safeMsg = commitMessage.replace(/"/g, '\\"').replace(/\n/g, '\\n');
+        execSync(`git commit -m "${safeMsg}"`, opts);
+
+        // 9. Push (use token if available for authentication)
+        let pushResult = '';
+        let pushed = false;
+
+        console.log(`🔑 Git push — gitToken provided: ${!!gitToken}, repoUrl provided: ${!!repoUrl}`);
+
+        // If gitToken provided, set up authenticated remote URL for push
+        if (gitToken) {
+            try {
+                let remoteUrlRaw = '';
+                try {
+                    remoteUrlRaw = execSync('git remote get-url origin 2>/dev/null', opts).trim();
+                } catch {
+                    // No remote configured — use repoUrl from integration if available
+                    if (repoUrl) {
+                        remoteUrlRaw = repoUrl;
+                        console.log(`📍 No git remote, using repoUrl from integration: ${repoUrl}`);
+                    }
+                }
+
+                console.log(`📍 Remote URL: ${remoteUrlRaw.replace(gitToken, '***')}`);
+                let authenticatedUrl = '';
+
+                if (remoteUrlRaw.includes('github.com')) {
+                    const repoPath = remoteUrlRaw
+                        .replace(/^https?:\/\/(.*@)?github\.com\//, '')
+                        .replace(/^git@github\.com:/, '')
+                        .replace(/\.git$/, '');
+                    authenticatedUrl = `https://x-access-token:${gitToken}@github.com/${repoPath}.git`;
+                    console.log(`📍 GitHub auth URL: https://x-access-token:***@github.com/${repoPath}.git`);
+                } else if (remoteUrlRaw.includes('gitlab.com') || remoteUrlRaw.includes('gitlab')) {
+                    const repoPath = remoteUrlRaw
+                        .replace(/^https?:\/\/(.*@)?[^\/]+\//, '')
+                        .replace(/^git@[^:]+:/, '')
+                        .replace(/\.git$/, '');
+                    const host = remoteUrlRaw.match(/https?:\/\/([^\/]+)/)?.[1] || 'gitlab.com';
+                    authenticatedUrl = `https://oauth2:${gitToken}@${host}/${repoPath}.git`;
+                    console.log(`📍 GitLab auth URL: https://oauth2:***@${host}/${repoPath}.git`);
+                } else if (remoteUrlRaw.includes('bitbucket.org') || remoteUrlRaw.includes('bitbucket')) {
+                    const repoPath = remoteUrlRaw
+                        .replace(/^https?:\/\/(.*@)?bitbucket\.org\//, '')
+                        .replace(/^git@bitbucket\.org:/, '')
+                        .replace(/\.git$/, '');
+                    authenticatedUrl = `https://x-token-auth:${gitToken}@bitbucket.org/${repoPath}.git`;
+                } else if (remoteUrlRaw) {
+                    // Unknown provider — try generic https with token
+                    const urlObj = new URL(remoteUrlRaw.replace(/^git@([^:]+):/, 'https://$1/'));
+                    authenticatedUrl = `https://oauth2:${gitToken}@${urlObj.host}${urlObj.pathname}`;
+                    if (!authenticatedUrl.endsWith('.git')) authenticatedUrl += '.git';
+                    console.log(`📍 Generic auth URL for ${urlObj.host}`);
+                }
+
+                if (authenticatedUrl) {
+                    console.log(`🚀 Pushing ${finalBranchName} with token auth...`);
+                    try {
+                        // Don't use 2>&1 — let execSync capture stderr separately
+                        pushResult = execSync(`git push ${authenticatedUrl} ${finalBranchName}`, {
+                            ...opts,
+                            timeout: 60000,  // 60s for slow connections
+                            stdio: ['pipe', 'pipe', 'pipe']  // capture stdin, stdout, stderr separately
+                        }).toString();
+                        pushed = true;
+                        console.log(`✅ Pushed with token authentication`);
+                    } catch (innerErr) {
+                        // Mask token in error messages before logging
+                        const maskToken = (str) => str ? str.replace(gitToken, '***TOKEN***') : '';
+                        const errMsg = maskToken(innerErr.stderr?.toString() || innerErr.stdout?.toString() || innerErr.message || '');
+                        console.warn(`⚠️ Authenticated push failed: ${errMsg}`);
+                        pushResult = errMsg;
+                    }
+                } else {
+                    console.warn(`⚠️ Could not construct authenticated URL from: ${remoteUrlRaw}`);
+                }
+            } catch (pushErr) {
+                const maskToken = (str) => str ? str.replace(gitToken, '***TOKEN***') : '';
+                console.warn(`⚠️ Git auth setup failed: ${maskToken(pushErr.message)}`);
+                pushResult = maskToken(pushErr.message) || 'Push setup failed';
+            }
+        }
+
+        // Fallback: try push without token (uses local git credentials)
+        if (!pushed) {
+            try {
+                pushResult = execSync(`git push -u origin ${finalBranchName} 2>&1`, opts).toString();
+                pushed = true;
+            } catch (pushErr) {
+                try {
+                    pushResult = execSync(`git push origin ${finalBranchName} 2>&1`, opts).toString();
+                    pushed = true;
+                } catch (pushErr2) {
+                    console.warn(`⚠️ Git push failed: ${pushErr2.message}`);
+                    pushResult = pushErr2.message || 'Push failed — no remote configured or auth required';
+                }
+            }
+        }
+
+        // 8. Get commit SHA
+        const commitSha = execSync('git rev-parse HEAD', opts).trim();
+
+        // 9. Get remote URL and generate MR/PR link
+        let remoteUrl = '';
+        let mrUrl = '';
+        let targetBranch = 'develop'; // default target — always prefer develop
+        try {
+            remoteUrl = execSync('git remote get-url origin 2>/dev/null', opts).trim();
+            // Always target develop if it exists, regardless of repo default branch
+            try {
+                execSync('git rev-parse --verify origin/develop 2>/dev/null', opts);
+                targetBranch = 'develop';
+            } catch {
+                // develop doesn't exist remotely, check locally
+                try {
+                    execSync('git rev-parse --verify develop 2>/dev/null', opts);
+                    targetBranch = 'develop';
+                } catch {
+                    // No develop branch at all — use main as last resort
+                    targetBranch = 'main';
+                }
+            }
+
+            // Generate MR/PR URL based on provider
+            const cleanUrl = remoteUrl
+                .replace(/\.git$/, '')
+                .replace(/^git@github\.com:/, 'https://github.com/')
+                .replace(/^git@gitlab\.com:/, 'https://gitlab.com/')
+                .replace(/^git@bitbucket\.org:/, 'https://bitbucket.org/');
+
+            if (cleanUrl.includes('github.com')) {
+                mrUrl = `${cleanUrl}/compare/${targetBranch}...${finalBranchName}?expand=1`;
+            } else if (cleanUrl.includes('gitlab.com') || cleanUrl.includes('gitlab')) {
+                mrUrl = `${cleanUrl}/-/merge_requests/new?merge_request[source_branch]=${finalBranchName}&merge_request[target_branch]=${targetBranch}`;
+            } else if (cleanUrl.includes('bitbucket.org') || cleanUrl.includes('bitbucket')) {
+                mrUrl = `${cleanUrl}/pull-requests/new?source=${finalBranchName}&dest=${targetBranch}`;
+            } else {
+                // Generic — try GitHub-style URL
+                mrUrl = `${cleanUrl}/compare/${targetBranch}...${finalBranchName}?expand=1`;
+            }
+        } catch (e) {
+            console.warn('Could not detect remote URL:', e.message);
+        }
+
+        console.log(`✅ Fix branch created: ${finalBranchName} (${commitSha.substring(0, 8)}) pushed=${pushed}`);
+        if (mrUrl) console.log(`🔗 MR URL: ${mrUrl}`);
+
+        // 10. Switch back to original branch and merge fix to keep changes on disk
+        try {
+            execSync(`git checkout ${currentBranch}`, opts);
+            // Merge the fix branch so the working directory has the patched files
+            // This keeps the diff viewer working (disk has patched version)
+            try {
+                execSync(`git merge ${finalBranchName} --no-edit`, opts);
+                console.log(`✅ Merged ${finalBranchName} into ${currentBranch}`);
+            } catch (mergeErr) {
+                // If merge fails (conflicts), just cherry-pick the changes without committing
+                try {
+                    execSync(`git merge --abort`, opts);
+                } catch {}
+                // Alternative: checkout the patched files from the fix branch
+                try {
+                    const changedFiles = status.split('\n').map(l => l.trim().split(/\s+/).pop()).filter(Boolean);
+                    for (const f of changedFiles) {
+                        try {
+                            execSync(`git checkout ${finalBranchName} -- ${f}`, opts);
+                        } catch {}
+                    }
+                    console.log(`✅ Cherry-picked ${changedFiles.length} file(s) from ${finalBranchName}`);
+                } catch {}
+            }
+        } catch {}
+
+        // 11. Auto-create Pull Request if pushed and token available
+        let prUrl = '';
+        if (pushed && gitToken && remoteUrl && remoteUrl.includes('github.com')) {
+            try {
+                const repoPath = remoteUrl
+                    .replace(/^https?:\/\/(.*@)?github\.com\//, '')
+                    .replace(/^git@github\.com:/, '')
+                    .replace(/\.git$/, '');
+
+                const prBody = {
+                    title: commitMessage,
+                    head: finalBranchName,
+                    base: targetBranch,
+                    body: `## 🤖 Auto-fix by DeepDebug AI\n\n` +
+                        `**Branch:** \`${finalBranchName}\`\n` +
+                        `**Files changed:** ${status.split('\n').length}\n` +
+                        `**Commit:** ${commitSha.substring(0, 8)}\n\n` +
+                        `This pull request was automatically created by DeepDebug AI after detecting and fixing a production error.\n\n` +
+                        `### Changes\n` +
+                        status.split('\n').map(l => `- \`${l.trim()}\``).join('\n') + '\n\n' +
+                        `---\n*Generated by [DeepDebug AI](https://deepdebug.ai) — Autonomous Debugging Platform*`
+                };
+
+                const response = await fetch(`https://api.github.com/repos/${repoPath}/pulls`, {
+                    method: 'POST',
+                    headers: {
+                        'Authorization': `Bearer ${gitToken}`,
+                        'Accept': 'application/vnd.github+json',
+                        'Content-Type': 'application/json',
+                        'X-GitHub-Api-Version': '2022-11-28'
+                    },
+                    body: JSON.stringify(prBody)
+                });
+
+                if (response.ok) {
+                    const prData = await response.json();
+                    prUrl = prData.html_url;
+                    console.log(`✅ Pull Request created: ${prUrl}`);
+                } else {
+                    const errText = await response.text();
+                    console.warn(`⚠️ PR creation failed (${response.status}): ${errText.substring(0, 200)}`);
+                    // Still use the compare URL as fallback
+                    prUrl = mrUrl;
+                }
+            } catch (prErr) {
+                console.warn(`⚠️ PR creation error: ${prErr.message}`);
+                prUrl = mrUrl;
+            }
+        }
+
+        res.json({
+            ok: true,
+            branch: finalBranchName,
+            previousBranch: currentBranch,
+            targetBranch,
+            commitSha,
+            commitMessage,
+            pushed,
+            pushResult: pushResult.toString().trim(),
+            remoteUrl,
+            mrUrl: prUrl || (pushed ? mrUrl : ''),
+            prCreated: !!prUrl && prUrl !== mrUrl,
+            filesChanged: status.split('\n').length,
+            changedFiles: status.split('\n').map(l => l.trim().split(/\s+/).pop())
+        });
+
+    } catch (err) {
+        console.error(`❌ Git branch creation failed: ${err.message}`);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * GET /workspace/git/status
+ * Returns current git status (branch, changes, remote)
+ */
+app.get("/workspace/git/status", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({ error: "workspace not set" });
+    }
+
+    try {
+        const { execSync } = await import('child_process');
+        const opts = { cwd: WORKSPACE_ROOT, encoding: 'utf8', timeout: 10000 };
+
+        let branch = '', remoteUrl = '', status = '';
+        let isGitRepo = false;
+
+        try {
+            execSync('git rev-parse --is-inside-work-tree', opts);
+            isGitRepo = true;
+            branch = execSync('git branch --show-current', opts).trim();
+            status = execSync('git status --porcelain', opts).trim();
+            try { remoteUrl = execSync('git remote get-url origin', opts).trim(); } catch {}
+        } catch {}
+
+        res.json({
+            ok: true,
+            isGitRepo,
+            branch,
+            hasChanges: status.length > 0,
+            changedFiles: status ? status.split('\n').filter(Boolean).length : 0,
+            remoteUrl
+        });
+    } catch (err) {
+        res.json({ ok: false, isGitRepo: false, error: err.message });
+    }
+});
+
+// ============================================
+// 📂 MULTI-WORKSPACE ENDPOINTS
+// ============================================
+
+/** Lista todos os workspaces abertos */
+app.get("/workspaces", (_req, res) => {
+    res.json({
+        workspaces: wsManager.list(),
+        total: wsManager.count,
+        defaultWorkspaceId: wsManager.defaultWorkspaceId
+    });
+});
+
+/** Fecha um workspace */
+app.post("/workspace/close", (req, res) => {
+    const { workspaceId } = req.body || {};
+    if (!workspaceId) return res.status(400).json({ error: "workspaceId required" });
+    const closed = wsManager.close(workspaceId);
+    if (closed && wsManager.defaultRoot) WORKSPACE_ROOT = wsManager.defaultRoot;
+    res.json({ ok: closed, remainingWorkspaces: wsManager.count });
+});
+
+/** Abre workspace por ID */
+app.post("/workspace/:workspaceId/open", async (req, res) => {
+    const { workspaceId } = req.params;
+    const { root } = req.body || {};
+    if (!root) return res.status(400).json({ error: "root is required" });
+    const abs = path.resolve(root);
+    if (!(await exists(abs))) return res.status(404).json({ error: "path not found" });
+    try {
+        const ws = await wsManager.open(workspaceId, abs);
+        if (wsManager.count === 1) WORKSPACE_ROOT = abs;
+        res.json({ ok: true, workspace: ws });
+    } catch (err) {
+        res.status(400).json({ error: err.message });
+    }
+});
+
+/** Aplica patch num workspace específico */
+app.post("/workspace/:workspaceId/patch", async (req, res) => {
+    const { workspaceId } = req.params;
+    const { diff } = req.body || {};
+    if (!diff) return res.status(400).json({ error: "diff is required" });
+    try {
+        const root = wsManager.resolveRoot(workspaceId);
+        const out = await applyUnifiedDiff(root, diff);
+        res.json({ ok: true, workspaceId, ...out });
+    } catch (e) {
+        res.status(400).json({ error: "patch failed", details: String(e) });
+    }
+});
+
+/** Compila e testa num workspace específico */
+app.post("/workspace/:workspaceId/test", async (req, res) => {
+    const { workspaceId } = req.params;
+    try {
+        const root = wsManager.resolveRoot(workspaceId);
+        const meta = await detectProject(root);
+        const result = await compileAndTest({ language: meta.language, buildTool: meta.buildTool, cwd: root });
+        res.json({ root, workspaceId, meta, result });
+    } catch (e) {
+        res.status(400).json({ error: String(e) });
+    }
+});
+
+/** Executa comando num workspace específico */
+app.post("/workspace/:workspaceId/run", async (req, res) => {
+    const { workspaceId } = req.params;
+    const { cmd, args = [] } = req.body || {};
+    if (!cmd) return res.status(400).json({ error: "cmd is required" });
+    try {
+        const root = wsManager.resolveRoot(workspaceId);
+        const out = await run(cmd, args, root, 5 * 60 * 1000);
+        res.json({ workspaceId, ...out });
+    } catch (e) {
+        res.status(400).json({ error: String(e) });
+    }
+});
+
+// ============================================
+// START SERVER
+// ============================================
+app.listen(PORT, '0.0.0.0', () => {
+    console.log(`\n🔌 DeepDebug Local Agent listening on port ${PORT}`);
+    console.log(`📦 Environment: ${process.env.NODE_ENV || 'development'}`);
+    console.log(`📦 Process Manager initialized`);
+    console.log(`💾 Backup system ready (max: ${MAX_BACKUPS} backups)`);
+    console.log(`🧠 AI Vibe Coding Engine: ${aiEngine?.isActive ? 'ACTIVE' : 'DISABLED'}`);
+    if (aiEngine) {
+        console.log(`   Gateway URL: ${aiEngine.gatewayUrl}`);
+        console.log(`   Max Retries: ${aiEngine.maxRetries}`);
+    }
+    console.log(`\n🚀 Ready to receive requests!\n`);
+});
+
+// Start MCP HTTP Bridge em paralelo (port 5056)
+try {
+    startMCPHttpServer(wsManager, parseInt(MCP_PORT));
+} catch (err) {
+    console.warn(`⚠️ MCP HTTP Server failed to start: ${err.message}`);
+    console.warn(`   (MCP features disabled, REST API continues normally)`);
+}
+
+// Auto-register default workspace in WorkspaceManager
+if (WORKSPACE_ROOT) {
+    wsManager.open("default", WORKSPACE_ROOT).catch(() => {});
+}