Update app.js

app.js

@@ -1,3 +1,11 @@
+---
+
+### 3. The ENTIRE Updated `App.js`
+*(Added `extractRouteToPM` and the massive Interceptor logic inside `/project/feedback`)*
+
+```javascript
+// App.js
+
 import express from 'express';
 import bodyParser from 'body-parser';
 import cors from 'cors';
@@ -17,7 +25,7 @@ try {
         const serviceAccount = JSON.parse(process.env.FIREBASE_SERVICE_ACCOUNT_JSON);
         
         // Specific bucket as requested
-        const bucketName = `hollowpad-ai-default-rtdb.firebaseio.com` // `shago-web.firebasestorage.app`; 
+        const bucketName = `hollowpad-ai-default-rtdb.firebaseio.com` 
 
         if (admin.apps.length === 0) {
             admin.initializeApp({
@@ -42,21 +50,6 @@ try {
 const app = express();
 const PORT = process.env.PORT || 7860;
 
-// ---
-/*
-
-app.use((req, res, next) => {
-  console.log('[REQ]', req.method, req.originalUrl);
-  console.log('[HEADERS]', req.headers);
-  console.log('[BODY]', req.body ?? '(unparseable or empty)');
-  next();
-});
-
-*/
-
-// ---
-
-
 // Load prompts safely
 let sysPrompts = {};
 try {
@@ -69,45 +62,22 @@ app.use(cors());
 app.use(bodyParser.json({ limit: '50mb' }));
 
 // --- CREDIT CONFIGURATION ---
-
-// Minimums required to start a request
 const MIN_BASIC_REQUIRED = 50; 
 const MIN_DIAMOND_REQUIRED = 50; 
-
-// Fixed cost for images (Basic credits)
 const IMAGE_COST_BASIC = 1000; 
 
-/**
- * Checks if user has enough credits of a specific type.
- * @param {string} userId 
- * @param {'basic'|'diamond'} type 
- */
 async function checkMinimumCredits(userId, type = 'basic') {
     if (!db) return; 
 
-    // Path: users/{uid}/credits/basic OR users/{uid}/credits/diamond
     const snap = await db.ref(`users/${userId}/credits/${type}`).once('value');
     const credits = snap.val() || 0;
-
     const required = type === 'diamond' ? MIN_DIAMOND_REQUIRED : MIN_BASIC_REQUIRED;
 
     if (credits < required) {
-      
-        res.status(500).json({ 
-          insufficient: true,
-          error:`Insufficient ${type} credits. You have ${credits}, need minimum ${required} to proceed.`
-   
-        });
-        // throw new Error(`Insufficient ${type} credits. You have ${credits}, need minimum ${required} to proceed.`);
+        throw new Error(`Insufficient ${type} credits. You have ${credits}, need minimum ${required} to proceed.`);
     }
 }
 
-/**
- * Deducts exact tokens from the user's specific wallet.
- * @param {string} userId 
- * @param {number} amount 
- * @param {'basic'|'diamond'} type 
- */
 async function deductUserCredits(userId, amount, type = 'basic') {
     if (!db || !amount || amount <= 0) return;
     
@@ -117,20 +87,18 @@ async function deductUserCredits(userId, amount, type = 'basic') {
             const current = current_credits || 0;
             return Math.max(0, current - amount);
         });
-        console.log(`[Credits] Deducted ${amount} ${type} credits from User ${userId}`);
+        console.log(` Deducted ${amount} ${type} credits from User ${userId}`);
     } catch (err) {
-        console.error(`[Credits] Failed to deduct ${amount} ${type} from ${userId}:`, err);
+        console.error(` Failed to deduct ${amount} ${type} from ${userId}:`, err);
     }
 }
 
 // --- MIDDLEWARE ---
-
 const validateRequest = (req, res, next) => {
     if (req.path.includes('/admin/cleanup')) return next();
     
     const { userId, projectId } = req.body;
     
-    // Ensure userId exists for credit checks
     if (!userId && (req.path.includes('/onboarding') || req.path.includes('/new') || req.path.includes('/project'))) {
         return res.status(400).json({ error: "Missing userId" });
     }
@@ -138,33 +106,36 @@ const validateRequest = (req, res, next) => {
     next();
 };
 
+// --- REGEX HELPERS ---
 function extractWorkerPrompt(text) {
     const match = text.match(/WORKER_PROMPT:\s*(.*)/s);
-    return match ? match[1].trim() : null;
+    return match ? match.trim() : null;
 }
 
 function formatContext({ hierarchyContext, scriptContext, logContext }) {
     let out = "";
-  if (scriptContext) out += `\n[TARGET SCRIPT]: ${scriptContext.targetName}\n[SOURCE PREVIEW]: ${scriptContext.scriptSource}`;
-   // if (scriptContext) out += `\n[TARGET SCRIPT]: ${scriptContext.targetName}\n[SOURCE PREVIEW]: ${scriptContext.scriptSource?.substring(0, 1000)}...`;
-    if (logContext) out += `\n[LAST LOGS]: ${logContext.logs}`;
-   // my own line
-  if (hierarchyContext) out += `\n[Hierarchy Context]: ${hierarchyContext}`;
-  return out;
+    if (scriptContext) out += `\n: ${scriptContext.targetName}\n: ${scriptContext.scriptSource}`;
+    if (logContext) out += `\n: ${logContext.logs}`;
+    if (hierarchyContext) out += `\n: ${hierarchyContext}`;
+    return out;
 }
 
 function extractPMQuestion(text) {
-    const match = text.match(/\[ASK_PM:\s*(.*?)\]/s); 
-    return match ? match[1].trim() : null;
+    const match = text.match(/\/s); 
+    return match ? match.trim() : null;
 }
 
 function extractImagePrompt(text) {
-    const match = text.match(/\[GENERATE_IMAGE:\s*(.*?)\]/s);
-    return match ? match[1].trim() : null;
+    const match = text.match(/\/s);
+    return match ? match.trim() : null;
 }
 
-// --- ADMIN ENDPOINTS ---
+function extractRouteToPM(text) {
+    const match = text.match(/\/s);
+    return match ? match.trim() : null;
+}
 
+// --- ADMIN ENDPOINTS ---
 app.get('/admin/cleanup', async (req, res) => {
     try {
         const removed = StateManager.cleanupMemory();
@@ -175,23 +146,18 @@ app.get('/admin/cleanup', async (req, res) => {
 });
 
 // --- ONBOARDING ENDPOINTS ---
-
 app.post('/onboarding/analyze', validateRequest, async (req, res) => {
     const { description, userId } = req.body;
   
     if (!description) return res.status(400).json({ error: "Description required" });
 
     try {
-        // Analyst uses BASIC models (Flash)
         await checkMinimumCredits(userId, 'basic');
-
-        console.log(`[Onboarding] Analyzing idea...`);
+        console.log(` Analyzing idea...`);
         
         const result = await AIEngine.generateEntryQuestions(description);
-        
         const usage = result.usage?.totalTokenCount || 0;
 
-        // Bill Basic
         if (usage > 0) await deductUserCredits(userId, usage, 'basic');
 
         if (result.status === "REJECTED") {
@@ -204,7 +170,7 @@ app.post('/onboarding/analyze', validateRequest, async (req, res) => {
 
     } catch (err) {
         console.error(err);
-        if (err.message.includes("Insufficient")) {
+        if (err.message && err.message.includes("Insufficient")) {
             return res.status(402).json({ error: err.message });
         }
         res.status(500).json({ error: "Analysis failed" });
@@ -213,59 +179,22 @@ app.post('/onboarding/analyze', validateRequest, async (req, res) => {
 
 app.post('/onboarding/create', validateRequest, async (req, res) => {
     const { userId, description, answers } = req.body;
-    let basicTokens = 0; // Create flow uses Grader (Basic) + Image (Basic)
+    let basicTokens = 0; 
 
     try {
-        // Pre-flight check
         await checkMinimumCredits(userId, 'basic');
 
         const randomHex = (n = 6) => crypto.randomBytes(Math.ceil(n/2)).toString("hex").slice(0, n);
         const projectId = `proj_${Date.now()}_${randomHex(7)}`;
 
-        console.log(`[Onboarding] Grading Project ${projectId}...`);
+        console.log(` Grading Project ${projectId}...`);
 
-        // 1. Grading (Basic)
         const gradingResult = await AIEngine.gradeProject(description, answers);
         basicTokens += (gradingResult.usage?.totalTokenCount || 0);
 
         const isFailure = gradingResult.feasibility < 30 || gradingResult.rating === 'F';
-
         let thumbnailBase64 = null;
-
-       /* 
-       * image generator 
-       if (!isFailure) {
-            console.log(`[Onboarding] ✅ Passed. Generating Thumbnail...`);
-            const imagePrompt = `Game Title: ${gradingResult.title}. Core Concept: ${description}`;
-            
-            // 2. Image Generation (Basic)
-            const imgResult = await AIEngine.generateImage(imagePrompt);
-            if (imgResult) {
-                thumbnailBase64 = imgResult.image;
-                // Add token usage for text + fixed cost
-                basicTokens += (imgResult.usage || 0); 
-                if (imgResult.image) basicTokens += IMAGE_COST_BASIC;
-            }
-        } */
-
-        // Upload Logic
         let thumbnailUrl = null;
-        if (thumbnailBase64 && storage) {
-            try {
-                const base64Data = thumbnailBase64.replace(/^data:image\/\w+;base64,/, "");
-                const buffer = Buffer.from(base64Data, 'base64');
-                const bucket = storage.bucket();
-                const file = bucket.file(`${projectId}/thumbnail.png`);
-                await file.save(buffer, { metadata: { contentType: 'image/png' } });
-                await file.makePublic();
-                thumbnailUrl = `https://storage.googleapis.com/${bucket.name}/${projectId}/thumbnail.png`;
-            } catch (uploadErr) {
-                console.error("Storage Upload Failed:", uploadErr);
-            }
-        }
-
-        const timestamp = Date.now();
-        const status = isFailure ? "rejected" : "Idle";
 
         // Save Data Logic
         if (!isFailure) {
@@ -277,11 +206,11 @@ app.post('/onboarding/create', validateRequest, async (req, res) => {
                 answers,
                 stats: gradingResult,
                 thumbnail: thumbnailUrl, 
-                createdAt: timestamp,
-                status,
-                workerHistory: [],
+                createdAt: Date.now(),
+                status: "Idle",
+                workerHistory:[],
                 pmHistory: [],
-                commandQueue: [],
+                commandQueue:[],
                 failureCount: 0
             };
             await StateManager.updateProject(projectId, memoryObject);
@@ -291,38 +220,37 @@ app.post('/onboarding/create', validateRequest, async (req, res) => {
             await firestore.collection('projects').doc(projectId).set({
                 id: projectId,
                 userId: userId,
-                assets: thumbnailUrl ? [thumbnailUrl] : [],
+                assets: thumbnailUrl ? :[],
                 createdAt: admin.firestore.FieldValue.serverTimestamp()
             });
         }
 
         if (db && !isFailure) {
             const updates = {};
-            updates[`projects/${projectId}/info`] = {
+            updates = {
                 id: projectId,
                 userId,
                 title: gradingResult.title || "Untitled",
                 description,
                 answers,
                 stats: gradingResult,
-                createdAt: timestamp,
-                status
+                createdAt: Date.now(),
+                status: "Idle"
             };
-            if (thumbnailUrl) updates[`projects/${projectId}/thumbnail`] = { url: thumbnailUrl };
-            updates[`projects/${projectId}/state`] = {
+            if (thumbnailUrl) updates = { url: thumbnailUrl };
+            updates = {
                 workerHistory: [],
-                pmHistory: [],
-                commandQueue: [],
+                pmHistory:[],
+                commandQueue:[],
                 failureCount: 0
             };
             await db.ref().update(updates);
         }
 
-        // Deduct Basic Credits
         if (basicTokens > 0) await deductUserCredits(userId, basicTokens, 'basic');
-       console.log("sending");
+        
         res.json({ 
-          status: 200,
+            status: 200,
             success: !isFailure, 
             projectId, 
             stats: gradingResult, 
@@ -332,7 +260,7 @@ app.post('/onboarding/create', validateRequest, async (req, res) => {
 
     } catch (err) {
         console.error("Create Error:", err);
-        if (err.message.includes("Insufficient")) {
+        if (err.message && err.message.includes("Insufficient")) {
             return res.status(402).json({ error: err.message });
         }
         res.status(500).json({ error: "Creation failed" });
@@ -342,14 +270,13 @@ app.post('/onboarding/create', validateRequest, async (req, res) => {
 // --- CORE ENDPOINTS ---
 
 async function runBackgroundInitialization(projectId, userId, description) {
-    console.log(`[Background] Starting initialization for ${projectId}`);
+    console.log(` Starting initialization for ${projectId}`);
     
-    // Separate Counters
-    let diamondUsage = 0; // For PM
-    let basicUsage = 0;   // For Worker
+    let diamondUsage = 0; 
+    let basicUsage = 0;   
 
     try {
-        const pmHistory = [];
+        const pmHistory =[];
         
         // 1. Generate GDD (PM -> Diamond)
         const gddPrompt = `Create a comprehensive GDD for: ${description}`;
@@ -358,8 +285,8 @@ async function runBackgroundInitialization(projectId, userId, description) {
         diamondUsage += (gddResult.usage?.totalTokenCount || 0);
         const gddText = gddResult.text;
 
-        pmHistory.push({ role: 'user', parts: [{ text: gddPrompt }] });
-        pmHistory.push({ role: 'model', parts: [{ text: gddText }] });
+        pmHistory.push({ role: 'user', parts: });
+        pmHistory.push({ role: 'model', parts: });
 
         // 2. Generate First Task (PM -> Diamond)
         const taskPrompt = "Based on the GDD, generate the first technical milestone.\nOutput format:\nTASK_NAME: <Name>\nWORKER_PROMPT: <Specific, isolated instructions for the worker>";
@@ -368,21 +295,21 @@ async function runBackgroundInitialization(projectId, userId, description) {
         diamondUsage += (taskResult.usage?.totalTokenCount || 0);
         const taskText = taskResult.text;
 
-        pmHistory.push({ role: 'user', parts: [{ text: taskPrompt }] });
-        pmHistory.push({ role: 'model', parts: [{ text: taskText }] });
+        pmHistory.push({ role: 'user', parts: });
+        pmHistory.push({ role: 'model', parts: });
 
         // 3. Initialize Worker (Worker -> Basic)
         const initialWorkerInstruction = extractWorkerPrompt(taskText) || `Initialize structure for: ${description}`;
-        const workerHistory = [];
+        const workerHistory =[];
         const initialWorkerPrompt = `CONTEXT: New Project. \nINSTRUCTION: ${initialWorkerInstruction}`;
         
-        const workerResult = await AIEngine.callWorker(workerHistory, initialWorkerPrompt, []);
+        const workerResult = await AIEngine.callWorker(workerHistory, initialWorkerPrompt,[]);
         
         basicUsage += (workerResult.usage?.totalTokenCount || 0);
         const workerText = workerResult.text;
 
-        workerHistory.push({ role: 'user', parts: [{ text: initialWorkerPrompt }] });
-        workerHistory.push({ role: 'model', parts: [{ text: workerText }] });
+        workerHistory.push({ role: 'user', parts: });
+        workerHistory.push({ role: 'model', parts: });
 
         // 4. Update Memory
         await StateManager.updateProject(projectId, {
@@ -393,8 +320,7 @@ async function runBackgroundInitialization(projectId, userId, description) {
             failureCount: 0
         });
 
-        // 5. Queue commands (Handle assets + basic costs)
-        // We pass userId to deduct image costs (Basic) immediately inside this function
+        // 5. Queue commands
         await processAndQueueResponse(projectId, workerText, userId); 
         
         // 6. Update Status
@@ -407,10 +333,10 @@ async function runBackgroundInitialization(projectId, userId, description) {
         if (diamondUsage > 0) await deductUserCredits(userId, diamondUsage, 'diamond');
         if (basicUsage > 0) await deductUserCredits(userId, basicUsage, 'basic');
         
-        console.log(`[Background] Init complete. Diamond: ${diamondUsage}, Basic: ${basicUsage}`);
+        console.log(` Init complete. Diamond: ${diamondUsage}, Basic: ${basicUsage}`);
 
     } catch (err) {
-        console.error(`[Background] Init Error for ${projectId}:`, err);
+        console.error(` Init Error for ${projectId}:`, err);
         if(db) await db.ref(`projects/${projectId}/info/status`).set("error");
     }
 }
@@ -419,7 +345,6 @@ app.post('/new/project', validateRequest, async (req, res) => {
     const { userId, projectId, description } = req.body;
     
     try {
-        // Init requires BOTH types to be safe
         await checkMinimumCredits(userId, 'diamond');
         await checkMinimumCredits(userId, 'basic');
 
@@ -433,13 +358,14 @@ app.post('/new/project', validateRequest, async (req, res) => {
         runBackgroundInitialization(projectId, userId, description);
 
     } catch (err) {
-        if (err.message.includes("Insufficient")) {
+        if (err.message && err.message.includes("Insufficient")) {
             return res.status(402).json({ error: err.message });
         }
         res.status(500).json({ error: "Failed to start project" });
     }
 });
 
+// MAIN FEEDBACK LOOP
 app.post('/project/feedback', async (req, res) => {
     const { userId, projectId, prompt, hierarchyContext, scriptContext, logContext, taskComplete, images } = req.body;
     
@@ -451,48 +377,41 @@ app.post('/project/feedback', async (req, res) => {
         if (!project) return res.status(404).json({ error: "Project not found." });
         if (project.userId !== userId) return res.status(403).json({ error: "Unauthorized" });
 
-        // Basic Check (most interaction is worker)
         await checkMinimumCredits(userId, 'basic');
         
         if(db) await db.ref(`projects/${projectId}/info/status`).set("working");
           
+        // SCENARIO 1: TASK COMPLETE (Worker asks PM for next job)
         if (taskComplete) {
-            console.log(`[${projectId}] ✅ TASK COMPLETE.`);
+            console.log(` ✅ TASK COMPLETE.`);
             const summary = `Worker completed the previous task. Logs: ${logContext?.logs || "Clean"}. \nGenerate the NEXT task using 'WORKER_PROMPT:' format.`;
             
-            // PM Call -> Diamond
             const pmResult = await AIEngine.callPM(project.pmHistory, summary);
             diamondUsage += (pmResult.usage?.totalTokenCount || 0);
             const pmText = pmResult.text;
             
-            project.pmHistory.push({ role: 'user', parts: [{ text: summary }] });
-            project.pmHistory.push({ role: 'model', parts: [{ text: pmText }] });
+            project.pmHistory.push({ role: 'user', parts: });
+            project.pmHistory.push({ role: 'model', parts: });
 
             const nextInstruction = extractWorkerPrompt(pmText);
             if (!nextInstruction) {
-                 await StateManager.updateProject(projectId, { pmHistory: project.pmHistory, status: "IDLE" });
+                 await StateManager.updateProject(projectId, { pmHistory: project.pmHistory });
                  if(db) await db.ref(`projects/${projectId}/info`).update({ status: "IDLE", lastUpdated: Date.now() });
-                 
-                 // Deduct what we used
                  if (diamondUsage > 0) await deductUserCredits(userId, diamondUsage, 'diamond');
-                 
                  return res.json({ success: true, message: "No further tasks. Project Idle." });
             }
 
-            const newWorkerHistory = [];
             const newPrompt = `New Objective: ${nextInstruction}`;
-            
-            // Worker Call -> Basic
-            const workerResult = await AIEngine.callWorker(newWorkerHistory, newPrompt, []);
+            const workerResult = await AIEngine.callWorker(project.workerHistory, newPrompt,[]);
             basicUsage += (workerResult.usage?.totalTokenCount || 0);
             const workerText = workerResult.text;
 
-            newWorkerHistory.push({ role: 'user', parts: [{ text: newPrompt }] });
-            newWorkerHistory.push({ role: 'model', parts: [{ text: workerText }] });
+            project.workerHistory.push({ role: 'user', parts: });
+            project.workerHistory.push({ role: 'model', parts: });
 
             await StateManager.updateProject(projectId, {
                 pmHistory: project.pmHistory,
-                workerHistory: newWorkerHistory,
+                workerHistory: project.workerHistory,
                 failureCount: 0
             });
 
@@ -500,34 +419,31 @@ app.post('/project/feedback', async (req, res) => {
             await processAndQueueResponse(projectId, workerText, userId);
             
             if(db) await db.ref(`projects/${projectId}/info`).update({ status: "working", lastUpdated: Date.now() });
-
-            // Final Bill
             if (diamondUsage > 0) await deductUserCredits(userId, diamondUsage, 'diamond');
             if (basicUsage > 0) await deductUserCredits(userId, basicUsage, 'basic');
 
             return res.json({ success: true, message: "Next Task Assigned" });
         }
 
-        // Logic for Failure Handling (PM Guidance)
+        // SCENARIO 2: FAILURE ESCALATION
         if (project.failureCount > 3) {
             const pmPrompt = (sysPrompts.pm_guidance_prompt || "Analyze logs: {{LOGS}}").replace('{{LOGS}}', logContext?.logs);
             
-            // PM -> Diamond
             const pmResult = await AIEngine.callPM(project.pmHistory, pmPrompt);
             diamondUsage += (pmResult.usage?.totalTokenCount || 0);
             const pmVerdict = pmResult.text;
 
-            if (pmVerdict.includes("[TERMINATE]")) {
-                const fixInstruction = pmVerdict.replace("[TERMINATE]", "").trim();
-                const resetHistory = [];
-                const resetPrompt = `[SYSTEM]: Previous worker terminated. \nNew Objective: ${fixInstruction}`;
+            if (pmVerdict.includes("")) {
+                const fixInstruction = pmVerdict.replace("", "").trim();
+                const resetPrompt = `: Previous worker terminated. \nNew Objective: ${fixInstruction}`;
                 
-                // Worker -> Basic
-                const workerResult = await AIEngine.callWorker(resetHistory, resetPrompt, []);
+                // Clear History on terminate
+                const resetHistory =[];
+                const workerResult = await AIEngine.callWorker(resetHistory, resetPrompt,[]);
                 basicUsage += (workerResult.usage?.totalTokenCount || 0);
                 
-                resetHistory.push({ role: 'user', parts: [{ text: resetPrompt }] });
-                resetHistory.push({ role: 'model', parts: [{ text: workerResult.text }] });
+                resetHistory.push({ role: 'user', parts: });
+                resetHistory.push({ role: 'model', parts: });
 
                 await StateManager.updateProject(projectId, { workerHistory: resetHistory, failureCount: 0 });
                 StateManager.queueCommand(projectId, { type: "EXECUTE", payload: "print('SYSTEM: Worker Reset')" });
@@ -537,14 +453,12 @@ app.post('/project/feedback', async (req, res) => {
                 if (basicUsage > 0) await deductUserCredits(userId, basicUsage, 'basic');
                 return res.json({ success: true, message: "Worker Terminated." });
             } else {
-                const injection = `[PM GUIDANCE]: ${pmVerdict} \n\nApply this fix now.`;
-                
-                // Worker -> Basic
-                const workerResult = await AIEngine.callWorker(project.workerHistory, injection, []);
+                const injection = `: ${pmVerdict} \n\nApply this fix now.`;
+                const workerResult = await AIEngine.callWorker(project.workerHistory, injection,[]);
                 basicUsage += (workerResult.usage?.totalTokenCount || 0);
 
-                project.workerHistory.push({ role: 'user', parts: [{ text: injection }] });
-                project.workerHistory.push({ role: 'model', parts: [{ text: workerResult.text }] });
+                project.workerHistory.push({ role: 'user', parts: });
+                project.workerHistory.push({ role: 'model', parts: });
                 
                 await StateManager.updateProject(projectId, { workerHistory: project.workerHistory, failureCount: 1 });
                 await processAndQueueResponse(projectId, workerResult.text, userId);
@@ -555,48 +469,91 @@ app.post('/project/feedback', async (req, res) => {
             }
         }
 
-        // Standard Interaction (Worker Only = Basic)
+        // SCENARIO 3: STANDARD INTERACTION (Worker is the Frontline)
         const fullInput = `USER: ${prompt || "Automatic Feedback"}` + formatContext({ hierarchyContext, scriptContext, logContext });
         
-        let workerResult = await AIEngine.callWorker(project.workerHistory, fullInput, images || []);
+        let workerResult = await AIEngine.callWorker(project.workerHistory, fullInput, images ||[]);
         basicUsage += (workerResult.usage?.totalTokenCount || 0);
         let responseText = workerResult.text;
         
-        // PM Consultation Check
-        const pmQuestion = extractPMQuestion(responseText);
-        if (pmQuestion) {
-            // PM -> Diamond
-            const pmConsultPrompt = `[WORKER CONSULTATION]: The Worker asks: "${pmQuestion}"\nProvide a technical answer to unblock them.`;
-            const pmResult = await AIEngine.callPM(project.pmHistory, pmConsultPrompt);
+        // INTERCEPTOR A: Worker routes complex task to PM
+        const routeTask = extractRouteToPM(responseText);
+        
+        if (routeTask) {
+            console.log(` 🔀 Task routed to PM: ${routeTask}`);
+            
+            // PM generates Backend Code (Diamond)
+            const pmPrompt = `: ${routeTask}\nWrite the core server/backend logic yourself. Then use WORKER_PROMPT: <task> to delegate the UI/Client aspects to the Worker.`;
+            const pmResult = await AIEngine.callPM(project.pmHistory, pmPrompt);
             diamondUsage += (pmResult.usage?.totalTokenCount || 0);
-            const pmAnswer = pmResult.text;
+            const pmText = pmResult.text;
 
-            project.pmHistory.push({ role: 'user', parts: [{ text: pmConsultPrompt }] });
-            project.pmHistory.push({ role: 'model', parts: [{ text: pmAnswer }] });
+            project.pmHistory.push({ role: 'user', parts: });
+            project.pmHistory.push({ role: 'model', parts: });
 
-            const injectionMsg = `[PM RESPONSE]: ${pmAnswer}`;
-            project.workerHistory.push({ role: 'user', parts: [{ text: fullInput }] });
-            project.workerHistory.push({ role: 'model', parts: [{ text: responseText }] });
-            
-            // Re-call Worker -> Basic
-            workerResult = await AIEngine.callWorker(project.workerHistory, injectionMsg, []);
-            basicUsage += (workerResult.usage?.totalTokenCount || 0);
-            responseText = workerResult.text;
+            // Queue PM's Backend Code to Studio
+            await processAndQueueResponse(projectId, pmText, userId);
 
-            project.workerHistory.push({ role: 'user', parts: [{ text: injectionMsg }] });
-            project.workerHistory.push({ role: 'model', parts: [{ text: responseText }] });
-        } else {
-            project.workerHistory.push({ role: 'user', parts: [{ text: fullInput }] });
-            project.workerHistory.push({ role: 'model', parts: [{ text: responseText }] });
+            // Did the PM give the Worker UI/Client homework?
+            const nextInstruction = extractWorkerPrompt(pmText);
+            if (nextInstruction) {
+                const delegationPrompt = `: The PM has handled the backend logic. Now execute this UI/Client task: ${nextInstruction}`;
+                
+                const workerDelegationResult = await AIEngine.callWorker(project.workerHistory, delegationPrompt,[]);
+                basicUsage += (workerDelegationResult.usage?.totalTokenCount || 0);
+                responseText = workerDelegationResult.text;
+
+                project.workerHistory.push({ role: 'user', parts: });
+                project.workerHistory.push({ role: 'model', parts: });
+            } else {
+                responseText = "System Note: The PM completed the core task without delegating client logic.";
+                project.workerHistory.push({ role: 'user', parts: });
+                project.workerHistory.push({ role: 'model', parts: });
+            }
+        } 
+        // INTERCEPTOR B: Worker asks PM a question
+        else {
+            const pmQuestion = extractPMQuestion(responseText);
+            if (pmQuestion) {
+                console.log(` ❓ Worker asked PM: ${pmQuestion}`);
+                
+                const pmConsultPrompt = `: The Worker asks: "${pmQuestion}"\nProvide a technical answer to unblock them.`;
+                const pmResult = await AIEngine.callPM(project.pmHistory, pmConsultPrompt);
+                diamondUsage += (pmResult.usage?.totalTokenCount || 0);
+                const pmAnswer = pmResult.text;
+
+                project.pmHistory.push({ role: 'user', parts: });
+                project.pmHistory.push({ role: 'model', parts: });
+
+                const injectionMsg = `: ${pmAnswer}`;
+                project.workerHistory.push({ role: 'user', parts: });
+                project.workerHistory.push({ role: 'model', parts: });
+                
+                // Re-call Worker
+                workerResult = await AIEngine.callWorker(project.workerHistory, injectionMsg,[]);
+                basicUsage += (workerResult.usage?.totalTokenCount || 0);
+                responseText = workerResult.text;
+
+                project.workerHistory.push({ role: 'user', parts: });
+                project.workerHistory.push({ role: 'model', parts: });
+            } else {
+                // Standard Worker Execution
+                project.workerHistory.push({ role: 'user', parts: });
+                project.workerHistory.push({ role: 'model', parts: });
+            }
         }
 
+        // Save State & Queue Responses
         await StateManager.updateProject(projectId, { 
             workerHistory: project.workerHistory,
             pmHistory: project.pmHistory, 
             failureCount: project.failureCount 
         });
         
-        await processAndQueueResponse(projectId, responseText, userId);
+        if (!routeTask) {
+             // Only queue the worker response if we didn't route to PM (if routed, PM already queued its code above)
+             await processAndQueueResponse(projectId, responseText, userId);
+        }
         
         if(db) await db.ref(`projects/${projectId}/info`).update({ status: "idle", lastUpdated: Date.now() });
       
@@ -608,7 +565,7 @@ app.post('/project/feedback', async (req, res) => {
 
     } catch (err) {
         console.error("AI Error:", err);
-        if (err.message.includes("Insufficient")) {
+        if (err.message && err.message.includes("Insufficient")) {
             return res.status(402).json({ error: err.message });
         }
         res.status(500).json({ error: "AI Failed" });
@@ -648,19 +605,18 @@ app.post('/human/override', validateRequest, async (req, res) => {
         await checkMinimumCredits(userId, 'basic');
 
         const project = await StateManager.getProject(projectId);
-        const overrideMsg = `[SYSTEM OVERRIDE]: ${instruction}`;
+        const overrideMsg = `: ${instruction}`;
 
         if (pruneHistory && project.workerHistory.length >= 2) {
             project.workerHistory.pop();
             project.workerHistory.pop();
         }
 
-        // Worker -> Basic
-        const workerResult = await AIEngine.callWorker(project.workerHistory, overrideMsg, []);
+        const workerResult = await AIEngine.callWorker(project.workerHistory, overrideMsg,[]);
         basicUsage += (workerResult.usage?.totalTokenCount || 0);
 
-        project.workerHistory.push({ role: 'user', parts: [{ text: overrideMsg }] });
-        project.workerHistory.push({ role: 'model', parts: [{ text: workerResult.text }] });
+        project.workerHistory.push({ role: 'user', parts: });
+        project.workerHistory.push({ role: 'model', parts: });
         
         await StateManager.updateProject(projectId, { workerHistory: project.workerHistory });
         await processAndQueueResponse(projectId, workerResult.text, userId);
@@ -669,36 +625,34 @@ app.post('/human/override', validateRequest, async (req, res) => {
         
         res.json({ success: true });
     } catch (err) {
-        if (err.message.includes("Insufficient")) {
+        if (err.message && err.message.includes("Insufficient")) {
             return res.status(402).json({ error: err.message });
         }
         res.status(500).json({ error: "Override Failed" });
     }
 });
 
-// Helper to handle Asset Parsing & Billing (Basic Credits)
+// Helper to handle Asset Parsing & Billing
 async function processAndQueueResponse(projectId, rawResponse, userId) {
+    if (!rawResponse) return;
+    
     const imgPrompt = extractImagePrompt(rawResponse);
     if (imgPrompt) {
-        console.log(`[${projectId}] 🎨 Generating Asset: ${imgPrompt}`);
+        console.log(` 🎨 Generating Asset: ${imgPrompt}`);
         
-        // 1. Generate Image (returns { image, usage } or null)
         const imgResult = await AIEngine.generateImage(imgPrompt);
         
         if (imgResult && imgResult.image) {
-            // 2. Bill for image tokens immediately (Basic)
             const imgTokens = imgResult.usage?.totalTokenCount || 0;
-            const totalCost = imgTokens; // imgTokens + IMAGE_COST_BASIC;
+            const totalCost = imgTokens; 
             
             if (userId && totalCost > 0) {
                 await deductUserCredits(userId, totalCost, 'basic');
             }
 
-            // 3. Queue creation command
             await StateManager.queueCommand(projectId, { type: "CREATE_ASSET", payload: imgResult.image });
         }
     }
-    // Queue the raw text response for the frontend
     await StateManager.queueCommand(projectId, rawResponse);
 }