Update app.js

app.js

@@ -3,162 +3,606 @@ import bodyParser from 'body-parser';
 import cors from 'cors';
 import { StateManager, initDB } from './stateManager.js'; 
 import { AIEngine } from './aiEngine.js';
+import fs from 'fs';
 import crypto from "crypto";
 import dotenv from 'dotenv';
 
 dotenv.config();
+
 initDB();
 const supabase = StateManager.getSupabaseClient(); 
+
 const app = express();
 const PORT = process.env.PORT || 7860;
+
 app.use(cors());
 app.use(bodyParser.json({ limit: '50mb' }));
 
-const WORKER_PHASES = ["Worker: Analyzing Context...", "Worker: Triage Task...", "Worker: Planning Logic...", "Worker: Thinking..."];
-const PM_PHASES = ["Manager: Reviewing Request...", "Manager: Formulating Strategy...", "Manager: Preparing Delegation...", "Manager: Thinking..."];
+const MIN_BASIC_REQUIRED = 50; 
+const MIN_DIAMOND_REQUIRED = 50; 
+
+// --- STATUS PHASES ---
+const WORKER_PHASES = [
+    "Worker: Analyzing Request...",
+    "Worker: Reading Context...",
+    "Worker: Checking Hierarchy...",
+    "Worker: Planning Logic...",
+    "Worker: Preparing Environment...",
+    "Worker: Thinking..." 
+];
+
+const PM_PHASES = [
+    "Manager: Reviewing Request...",
+    "Manager: Analyzing Project Structure...",
+    "Manager: Consulting Guidelines...",
+    "Manager: Formulating Strategy...",
+    "Manager: Delegating Tasks...",
+    "Manager: Thinking..." 
+];
 
 function startStatusLoop(projectId, type = 'worker') {
     const phases = type === 'pm' ? PM_PHASES : WORKER_PHASES;
     let index = 0;
+    
     StateManager.setStatus(projectId, phases[0]);
+
     const interval = setInterval(() => {
         index++;
-        if (index < phases.length) StateManager.setStatus(projectId, phases[index]);
-        else clearInterval(interval);
+        if (index < phases.length) {
+            StateManager.setStatus(projectId, phases[index]);
+        } else {
+            clearInterval(interval);
+        }
     }, 1500); 
+
     return () => clearInterval(interval);
 }
 
 async function checkMinimumCredits(userId, type = 'basic') {
-    const { data } = await supabase.from('users').select('credits').eq('id', userId).single();
-    if (!data || (data.credits?.[type] || 0) < 50) throw new Error(`Insufficient credits.`);
+    if (!supabase) return; 
+
+    const { data, error } = await supabase
+        .from('users')
+        .select('credits')
+        .eq('id', userId)
+        .single();
+    
+    if (error || !data) return; 
+
+    const credits = data.credits?.[type] || 0;
+    const required = type === 'diamond' ? MIN_DIAMOND_REQUIRED : MIN_BASIC_REQUIRED;
+
+    if (credits < required) {
+        throw new Error(`Insufficient ${type} credits. You have ${credits}, need minimum ${required}.`);
+    }
 }
 
 async function deductUserCredits(userId, amount, type = 'basic') {
+    if (!supabase || !amount || amount <= 0) return;
+    
     try {
         const { data } = await supabase.from('users').select('credits').eq('id', userId).single();
-        const newVal = Math.max(0, (data?.credits?.[type] || 0) - amount);
-        await supabase.from('users').update({ credits: { ...data.credits, [type]: newVal } }).eq('id', userId);
-    } catch (e) { console.error("Credit Error:", e.message); }
+        if (!data) return;
+
+        const currentCredits = data.credits || {};
+        const currentVal = currentCredits[type] || 0;
+        const newVal = Math.max(0, currentVal - amount);
+        
+        const updatedCredits = { ...currentCredits, [type]: newVal };
+
+        await supabase
+            .from('users')
+            .update({ credits: updatedCredits })
+            .eq('id', userId);
+
+        console.log(`[Credits] Deducted ${amount} ${type} from User ${userId}`);
+    } catch (err) {
+        console.error(`[Credits] Failed to deduct from ${userId}:`, err);
+    }
 }
 
-const formatContext = ({ hierarchyContext, scriptContext, logContext }) => {
+const validateRequest = (req, res, next) => {
+    if (req.path.includes('/admin/cleanup')) return next();
+    const { userId } = req.body;
+    if (!userId && (req.path.includes('/onboarding') || req.path.includes('/new') || req.path.includes('/project'))) {
+        return res.status(400).json({ error: "Missing userId" });
+    }
+    next();
+};
+
+function extractWorkerPrompt(text) {
+    if (!text || typeof text !== 'string') return null;
+    const match = text.match(/WORKER_PROMPT:\s*(.*)/s);
+    return match ? match[1].trim() : null;
+}
+
+function extractPMQuestion(text) {
+    if (!text || typeof text !== 'string') return null;
+    const match = text.match(/\[ASK_PM:\s*(.*?)\]/s); 
+    return match ? match[1].trim() : null;
+}
+
+function extractImagePrompt(text) {
+    if (!text || typeof text !== 'string') return null;
+    const match = text.match(/\[GENERATE_IMAGE:\s*(.*?)\]/s);
+    return match ? match[1].trim() : null;
+}
+
+function extractRouteToPM(text) {
+    if (!text || typeof text !== 'string') return null;
+    const match = text.match(/\[ROUTE_TO_PM:\s*(.*?)\]/s);
+    return match ? match[1].trim() : null;
+}
+
+function formatContext({ hierarchyContext, scriptContext, logContext }) {
     let out = "";
     if (scriptContext) out += `\n[TARGET SCRIPT]: ${scriptContext.targetName}\n[SOURCE PREVIEW]: ${scriptContext.scriptSource}`;
     if (logContext) out += `\n[LAST LOGS]: ${logContext.logs}`;
     if (hierarchyContext) out += `\n[Hierarchy Context]: ${hierarchyContext}`;
     return out;
-};
+}
 
-const extractTags = (text) => ({
-    pmQuestion: text.match(/\[ASK_PM:\s*(.*?)\]/s)?.[1],
-    pmRoute: text.match(/\[ROUTE_TO_PM:\s*(.*?)\]/s)?.[1],
-    workerPrompt: text.match(/WORKER_PROMPT:\s*(.*)/s)?.[1]
-});
+async function runBackgroundInitialization(projectId, userId, description) {
+    if (StateManager.isLocked(projectId)) {
+        console.log(`[Init Guard] Project ${projectId} is already initializing. Skipping.`);
+        return;
+    }
+
+    StateManager.lock(projectId);
+    console.log(`[Background] Starting initialization for ${projectId}`);
+    
+    let diamondUsage = 0; 
+    let basicUsage = 0;   
+
+    try {
+        await StateManager.getProject(projectId);
+
+        await StateManager.updateProject(projectId, { 
+            status: "WORKING", 
+            gdd: "",
+            failureCount: 0 
+        });
+
+        const pmHistory = [];
+        
+        let stopStatus = startStatusLoop(projectId, 'pm');
+        
+        const gddPrompt = `Create a comprehensive Game Design Document (GDD) for: ${description}`;
+        const gddResult = await AIEngine.callPM(pmHistory, gddPrompt);
+        
+        stopStatus();
+        
+        if (!gddResult?.text) throw new Error("PM failed to generate GDD");
+        
+        const gddText = gddResult.text;
+        diamondUsage += (gddResult.usage?.totalTokenCount || 0);
+
+        await StateManager.addHistory(projectId, 'pm', 'user', gddPrompt);
+        await StateManager.addHistory(projectId, 'pm', 'model', gddText);
+
+        pmHistory.push({ role: 'user', parts: [{ text: gddPrompt }] });
+        pmHistory.push({ role: 'model', parts: [{ text: gddText }] });
+
+        stopStatus = startStatusLoop(projectId, 'pm');
+
+        const taskPrompt = "Based on the GDD, generate the first technical milestone.\nOutput format:\nTASK_NAME: <Name>\nWORKER_PROMPT: <Specific, isolated instructions for the worker>";
+        const taskResult = await AIEngine.callPM(pmHistory, taskPrompt);
+        
+        stopStatus();
+
+        if (!taskResult?.text) throw new Error("PM failed to generate Task");
+
+        const taskText = taskResult.text;
+        diamondUsage += (taskResult.usage?.totalTokenCount || 0);
+
+        await StateManager.addHistory(projectId, 'pm', 'user', taskPrompt);
+        await StateManager.addHistory(projectId, 'pm', 'model', taskText);
+
+        const initialWorkerInstruction = extractWorkerPrompt(taskText) || `Initialize structure for: ${description}`;
+        const initialWorkerPrompt = `CONTEXT: New Project. \nINSTRUCTION: ${initialWorkerInstruction}`;
+        
+        stopStatus = startStatusLoop(projectId, 'worker');
+        
+        let workerTextAccumulated = "";
+
+        await AIEngine.callWorkerStream(
+            [], 
+            initialWorkerPrompt, 
+            (thought) => {
+                stopStatus(); 
+                StateManager.setStatus(projectId, "Worker: Thinking...");
+                StateManager.appendSnapshotOnly(projectId, thought);
+            },
+            (chunk) => {
+                stopStatus(); 
+                StateManager.setStatus(projectId, "Worker: Coding...");
+                workerTextAccumulated += chunk;
+                StateManager.appendStream(projectId, chunk);
+            }
+        );
 
+        if (!workerTextAccumulated) throw new Error("Worker failed to initialize");
+
+        await StateManager.addHistory(projectId, 'worker', 'user', initialWorkerPrompt);
+        await StateManager.addHistory(projectId, 'worker', 'model', workerTextAccumulated);
+
+        await StateManager.updateProject(projectId, {
+            gdd: gddText,
+            status: "IDLE" 
+        });
+
+        await processAndQueueResponse(projectId, workerTextAccumulated, userId); 
+        
+        if (diamondUsage > 0) await deductUserCredits(userId, diamondUsage, 'diamond');
+        if (basicUsage > 0) await deductUserCredits(userId, basicUsage, 'basic');
+        
+        console.log(`[Background] Init complete for ${projectId}`);
+
+    } catch (err) {
+        console.error(`[Background] Init Error for ${projectId}:`, err.message);
+        await StateManager.updateProject(projectId, { status: "ERROR" });
+    } finally {
+        StateManager.unlock(projectId);
+    }
+}
+
+// --- UPDATED: Accepts IMAGES ---
 async function runAsyncFeedback(projectId, userId, fullInput, images = []) {
+    let diamondUsage = 0;
+    let basicUsage = 0;
+
     try {
         const project = await StateManager.getProject(projectId);
+        
         StateManager.clearSnapshot(projectId);
         
-        // --- PASS 1: WORKER ---
         let stopStatus = startStatusLoop(projectId, 'worker');
-        let workerPass1 = "";
-        const result1 = await AIEngine.callWorkerStream(
-            project.workerHistory, fullInput, 
-            (thought) => { stopStatus(); StateManager.setStatus(projectId, "Worker: Thinking..."); StateManager.appendSnapshotOnly(projectId, thought); },
-            (chunk) => { stopStatus(); StateManager.setStatus(projectId, "Worker: Coding..."); workerPass1 += chunk; StateManager.appendStream(projectId, chunk); },
-            images
+        
+        let responseText = ""; 
+        let thoughtText = "";  
+        
+        // Pass images to Worker Stream
+        await AIEngine.callWorkerStream(
+            project.workerHistory, 
+            fullInput, 
+            (thought) => {
+                stopStatus();
+                thoughtText += thought;
+                StateManager.setStatus(projectId, "Worker: Thinking...");
+                StateManager.appendSnapshotOnly(projectId, thought);
+            },
+            (chunk) => {
+                stopStatus();
+                responseText += chunk;
+                StateManager.setStatus(projectId, "Worker: Coding...");
+                StateManager.appendStream(projectId, chunk);
+            },
+            images // <--- Passing images here
         );
-        stopStatus();
 
-        const tags = extractTags(workerPass1);
-        if (tags.pmQuestion || tags.pmRoute) {
-            // Save Pass 1 immediately
-            await StateManager.addHistory(projectId, 'worker', 'user', fullInput);
-            await StateManager.addHistory(projectId, 'worker', 'model', workerPass1);
-            await StateManager.queueCommand(projectId, workerPass1);
+        const routeTask = extractRouteToPM(responseText);
+        const pmQuestion = extractPMQuestion(responseText);
 
-            // --- PASS 2: PROJECT MANAGER ---
-            StateManager.clearSnapshot(projectId);
+        if (routeTask) {
+            console.log(`[${projectId}] Routing task to PM...`);
+            StateManager.clearSnapshot(projectId); 
             stopStatus = startStatusLoop(projectId, 'pm');
-            const pmInput = tags.pmRoute ? `[ROUTED TASK]: ${tags.pmRoute}` : `[QUESTION]: ${tags.pmQuestion}`;
-            let pmText = "";
+            
+            const pmPrompt = `[ROUTED TASK]: ${routeTask}\nWrite the backend/logic. Then use WORKER_PROMPT: <task> to delegate.`;
+            let pmResponseText = "";
+            
             await AIEngine.callPMStream(
-                project.pmHistory, pmInput,
-                (thought) => { stopStatus(); StateManager.setStatus(projectId, "Manager: Thinking..."); StateManager.appendSnapshotOnly(projectId, thought); },
-                (chunk) => { stopStatus(); StateManager.setStatus(projectId, "Manager: Architecting..."); pmText += chunk; StateManager.appendSnapshotOnly(projectId, chunk); }
+                project.pmHistory,
+                pmPrompt,
+                (thought) => {
+                    stopStatus();
+                    StateManager.setStatus(projectId, "Manager: Thinking...");
+                    StateManager.appendSnapshotOnly(projectId, thought);
+                },
+                (chunk) => {
+                    stopStatus();
+                    StateManager.setStatus(projectId, "Manager: Planning...");
+                    pmResponseText += chunk;
+                    StateManager.appendSnapshotOnly(projectId, chunk); 
+                }
             );
-            stopStatus();
+            
+            diamondUsage += 0; 
+            
+            await StateManager.addHistory(projectId, 'pm', 'user', routeTask);
+            await StateManager.addHistory(projectId, 'pm', 'model', pmResponseText);
 
-            await StateManager.addHistory(projectId, 'pm', 'user', pmInput);
-            await StateManager.addHistory(projectId, 'pm', 'model', pmText);
-            await StateManager.queueCommand(projectId, pmText);
+            const nextInstruction = extractWorkerPrompt(pmResponseText);
+            if (nextInstruction) {
+                StateManager.clearSnapshot(projectId);
+                stopStatus = startStatusLoop(projectId, 'worker');
+                
+                let subResponse = "";
+                await AIEngine.callWorkerStream(
+                    project.workerHistory, 
+                    `[PM DELEGATION]: ${nextInstruction}`,
+                    (thought) => {
+                        stopStatus();
+                        StateManager.setStatus(projectId, "Worker: Thinking...");
+                        StateManager.appendSnapshotOnly(projectId, thought);
+                    },
+                    (chunk) => {
+                        stopStatus();
+                        StateManager.setStatus(projectId, "Worker: Coding...");
+                        subResponse += chunk;
+                        StateManager.appendStream(projectId, chunk); 
+                    }
+                );
+                responseText = subResponse; 
+            }
+        } else if (pmQuestion) {
+            console.log(`[${projectId}] Worker consulting PM...`);
+            StateManager.clearSnapshot(projectId);
+            stopStatus = startStatusLoop(projectId, 'pm');
 
-            // Save PM answer into Worker's persistent history
-            const pmAnswerVisible = `[PM RESPONSE]:\n${pmText}`;
-            await StateManager.addHistory(projectId, 'worker', 'model', pmAnswerVisible);
+            let pmResponseText = "";
+            await AIEngine.callPMStream(
+                project.pmHistory,
+                pmQuestion,
+                (thought) => {
+                    stopStatus();
+                    StateManager.setStatus(projectId, "Manager: Thinking...");
+                    StateManager.appendSnapshotOnly(projectId, thought);
+                },
+                (chunk) => {
+                    stopStatus();
+                    StateManager.setStatus(projectId, "Manager: Advising...");
+                    pmResponseText += chunk;
+                    StateManager.appendSnapshotOnly(projectId, chunk);
+                }
+            );
+            
+            diamondUsage += 0;
+            
+            await StateManager.addHistory(projectId, 'pm', 'user', pmQuestion);
+            await StateManager.addHistory(projectId, 'pm', 'model', pmResponseText);
 
-            // --- PASS 3: WORKER FINAL PASS ---
-            const nextTask = extractTags(pmText).workerPrompt || "Proceed based on PM answer.";
             StateManager.clearSnapshot(projectId);
             stopStatus = startStatusLoop(projectId, 'worker');
-            let workerPass2 = "";
-            const currentProj = await StateManager.getProject(projectId); // Refresh for Pass 2 context
+            
+            let subResponse = "";
             await AIEngine.callWorkerStream(
-                currentProj.workerHistory, nextTask,
-                (thought) => { stopStatus(); StateManager.appendSnapshotOnly(projectId, thought); },
-                (chunk) => { stopStatus(); workerPass2 += chunk; StateManager.appendStream(projectId, chunk); }
+                project.workerHistory, 
+                `[PM ANSWER]: ${pmResponseText}`,
+                (thought) => {
+                    stopStatus();
+                    StateManager.setStatus(projectId, "Worker: Thinking...");
+                    StateManager.appendSnapshotOnly(projectId, thought);
+                },
+                (chunk) => {
+                    stopStatus();
+                    StateManager.setStatus(projectId, "Worker: Coding...");
+                    subResponse += chunk;
+                    StateManager.appendStream(projectId, chunk);
+                }
             );
-            stopStatus();
-            await StateManager.addHistory(projectId, 'worker', 'model', workerPass2);
-            await StateManager.queueCommand(projectId, workerPass2);
-        } else {
-            await StateManager.addHistory(projectId, 'worker', 'user', fullInput);
-            await StateManager.addHistory(projectId, 'worker', 'model', workerPass1);
-            await StateManager.queueCommand(projectId, workerPass1);
+            responseText = subResponse;
         }
 
+        StateManager.setStatus(projectId, "Finalizing...");
+        
+        await StateManager.addHistory(projectId, 'worker', 'user', fullInput);
+        await StateManager.addHistory(projectId, 'worker', 'model', responseText);
+        
+        await processAndQueueResponse(projectId, responseText, userId);
+
         await StateManager.updateProject(projectId, { status: "idle" });
-        await deductUserCredits(userId, 10);
+
+        if (diamondUsage > 0) await deductUserCredits(userId, diamondUsage, 'diamond');
+        if (basicUsage > 0) await deductUserCredits(userId, basicUsage, 'basic');
+
     } catch (err) {
-        console.error("Feedback Loop Crashed:", err.message);
+        console.error("Async Feedback Error:", err);
         StateManager.setStatus(projectId, "Error: " + err.message);
         await StateManager.updateProject(projectId, { status: "error" });
     }
 }
 
+async function processAndQueueResponse(projectId, rawResponse, userId) {
+    if (!rawResponse) return;
+    
+    if (!StateManager.queueCommand) {
+        console.error("CRITICAL: StateManager.queueCommand is missing.");
+        return;
+    }
+
+    const imgPrompt = extractImagePrompt(rawResponse);
+    if (imgPrompt) {
+        const imgResult = await AIEngine.generateImage(imgPrompt);
+        if (imgResult?.image) {
+            if (userId) await deductUserCredits(userId, 1000, 'basic');
+            await StateManager.queueCommand(projectId, { type: "CREATE_ASSET", payload: imgResult.image });
+        }
+    }
+    
+    await StateManager.queueCommand(projectId, { type: "EXECUTE", payload: rawResponse });
+}
+
+app.post('/onboarding/analyze', validateRequest, async (req, res) => {
+    const { description, userId } = req.body;
+    if (!description) return res.status(400).json({ error: "Description required" });
+
+    try {
+        await checkMinimumCredits(userId, 'basic');
+        const result = await AIEngine.generateEntryQuestions(description);
+        const usage = result.usage?.totalTokenCount || 0;
+        if (usage > 0) await deductUserCredits(userId, usage, 'basic');
+
+        if (result.status === "REJECTED") {
+            return res.json({ rejected: true, reason: result.reason || "Idea violates TOS." });
+        }
+        res.json({ questions: result.questions });
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+app.post('/onboarding/create', validateRequest, async (req, res) => {
+    const { userId, description, answers } = req.body;
+    let basicTokens = 0; 
+
+    try {
+        await checkMinimumCredits(userId, 'basic');
+        await checkMinimumCredits(userId, 'diamond'); 
+
+        const randomHex = (n = 6) => crypto.randomBytes(Math.ceil(n/2)).toString("hex").slice(0, n);
+        const projectId = `proj_${Date.now()}_${randomHex(7)}`;
+
+        const gradingResult = await AIEngine.gradeProject(description, answers);
+        basicTokens += (gradingResult.usage?.totalTokenCount || 0);
+
+        const isFailure = gradingResult.feasibility < 30 || gradingResult.rating === 'F';
+        
+        if (!isFailure) {
+            const { error: insertError } = await supabase.from('projects').insert({
+                id: projectId,
+                user_id: userId,
+                info: {
+                    title: gradingResult.title || "Untitled",
+                    stats: gradingResult,
+                    description,
+                    answers,
+                    status: "initializing"
+                }
+            });
+
+            if (insertError) {
+                console.error("Failed to insert project:", insertError.message);
+                return res.status(500).json({ error: "Database save failed" });
+            }
+
+            runBackgroundInitialization(projectId, userId, description);
+        }
+
+        if (basicTokens > 0) await deductUserCredits(userId, basicTokens, 'basic');
+        
+        res.json({ 
+            status: 200,
+            success: !isFailure, 
+            projectId, 
+            stats: gradingResult, 
+            title: gradingResult.title || "Untitled"
+        });
+
+    } catch (err) {
+        console.error("Create Error:", err);
+        res.status(500).json({ error: err.message });
+    }
+});
+
 app.post('/project/feedback', async (req, res) => {
     const { userId, projectId, prompt, hierarchyContext, scriptContext, logContext, images } = req.body;
+    
     try {
         const project = await StateManager.getProject(projectId);
         if (!project || project.userId !== userId) return res.status(403).json({ error: "Auth Error" });
+
         await checkMinimumCredits(userId, 'basic');
+        
         await StateManager.updateProject(projectId, { status: "working" });
-        res.json({ success: true });
+          
         const context = formatContext({ hierarchyContext, scriptContext, logContext });
-        runAsyncFeedback(projectId, userId, `USER: ${prompt || "Auto-Correction Loop"}${context}`, images || []);
-    } catch (err) { res.status(500).json({ error: err.message }); }
+        const fullInput = `USER: ${prompt || "Automatic Feedback"}${context}`;
+        
+        // Pass images array to async runner
+        runAsyncFeedback(projectId, userId, fullInput, images || []);
+
+        res.json({ success: true, message: "Processing started" });
+
+    } catch (err) {
+        console.error("Feedback Error:", err);
+        await StateManager.updateProject(projectId, { status: "error" });
+        res.status(500).json({ error: "Feedback process failed" });
+    }
 });
 
 app.post('/project/ping', async (req, res) => {
     const { projectId, userId, isFrontend } = req.body;
+    if (!projectId || !userId) return res.status(400).json({ error: "Missing IDs" });
+    
     const project = await StateManager.getProject(projectId);
     if (!project || project.userId !== userId) return res.json({ action: "IDLE" });
-    if (isFrontend) return res.json({ status: StateManager.getStatus(projectId), snapshot: StateManager.getSnapshot(projectId) });
+
+    const currentStatus = StateManager.getStatus(projectId);
+
+    if (isFrontend) {
+        const snapshot = StateManager.getSnapshot(projectId);
+        return res.json({ status: currentStatus, snapshot });
+    }
+
     const command = await StateManager.popCommand(projectId);
-    const stream = StateManager.popStream(projectId);
-    let resData = { action: stream ? "STREAM_APPEND" : "IDLE", stream };
-    if (command) { resData.action = command.type; resData.target = command.payload; resData.code = command.payload; }
-    res.json(resData);
+    const streamData = StateManager.popStream(projectId);
+
+    let response = { action: "IDLE", stream: streamData || null };
+
+    if (streamData && streamData.length > 0) {
+        response.action = "STREAM_APPEND";
+    }
+
+    if (command) {
+        response.action = command.type; 
+        response.target = command.payload;
+        response.code = command.type === 'EXECUTE' ? command.payload : null;
+    }
+
+    res.json(response);
 });
 
-app.post('/onboarding/create', async (req, res) => {
-    const { userId, description, answers } = req.body;
-    const projectId = `proj_${Date.now()}_${crypto.randomBytes(2).toString("hex")}`;
-    const grade = await AIEngine.gradeProject(description, answers);
-    await supabase.from('projects').insert({ id: projectId, user_id: userId, info: { title: grade.title, status: "idle" } });
-    res.json({ success: true, projectId, grade });
+app.post('/human/override', validateRequest, async (req, res) => {
+    const { projectId, instruction, userId } = req.body;
+    try {
+        await checkMinimumCredits(userId, 'basic');
+        const project = await StateManager.getProject(projectId);
+        
+        res.json({ success: true });
+
+        const overrideMsg = `[SYSTEM OVERRIDE]: ${instruction}`;
+        
+        let overrideText = "";
+        let stopStatus = startStatusLoop(projectId, 'worker');
+
+        AIEngine.callWorkerStream(
+            project.workerHistory, 
+            overrideMsg,
+            (thought) => {
+                stopStatus();
+                StateManager.setStatus(projectId, "Worker: Thinking...");
+                StateManager.appendSnapshotOnly(projectId, thought);
+            },
+            (chunk) => {
+                stopStatus();
+                StateManager.setStatus(projectId, "Worker: Coding...");
+                overrideText += chunk;
+                StateManager.appendStream(projectId, chunk);
+            }
+        ).then(async (workerResult) => {
+            await StateManager.addHistory(projectId, 'worker', 'user', overrideMsg);
+            await StateManager.addHistory(projectId, 'worker', 'model', workerResult.text || overrideText);
+            await processAndQueueResponse(projectId, workerResult.text || overrideText, userId);
+            
+            const usage = workerResult.usage?.totalTokenCount || 0;
+            if (usage > 0) await deductUserCredits(userId, usage, 'basic');
+        });
+
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+app.get('/admin/cleanup', async (req, res) => {
+    try {
+        const removed = StateManager.cleanupMemory ? StateManager.cleanupMemory() : 0;
+        res.json({ success: true, removedCount: removed });
+    } catch (err) {
+        res.status(500).json({ error: "Cleanup failed" });
+    }
 });
 
-app.listen(PORT, () => console.log(`AI Backend live on ${PORT}`));
+app.listen(PORT, () => {
+    console.log(`AI Backend Running on ${PORT} (Supabase Edition)`);
+});