Update app.js

app.js

@@ -8,7 +8,6 @@ import fs from 'fs';
 const app = express();
 const PORT = process.env.PORT || 7860;
 
-// Load prompts
 const sysPrompts = JSON.parse(fs.readFileSync('./prompts.json', 'utf8'));
 
 app.use(cors());
@@ -20,29 +19,32 @@ const validateRequest = (req, res, next) => {
     next();
 };
 
-// Helper to extract PM's isolated instruction
 function extractWorkerPrompt(text) {
     const match = text.match(/WORKER_PROMPT:\s*(.*)/s);
     return match ? match[1].trim() : null;
 }
 
-// Helper to format context for the AI
 function formatContext({ hierarchyContext, scriptContext, logContext }) {
     let out = "";
-    if (scriptContext) out += `\n[TARGET SCRIPT]: ${scriptContext.targetName}\n[SOURCE PREVIEW]: ${scriptContext.scriptSource.substring(0, 500)}...`;
+    if (scriptContext) out += `\n[TARGET SCRIPT]: ${scriptContext.targetName}\n[SOURCE PREVIEW]: ${scriptContext.scriptSource?.substring(0, 1000)}...`;
     if (logContext) out += `\n[LAST LOGS]: ${logContext.logs}`;
     return out;
 }
 
+// Helper to check for Consultant requests
+function extractPMQuestion(text) {
+    const match = text.match(/\[ASK_PM:\s*(.*?)\]/s); // 's' flag for multiline questions
+    return match ? match[1].trim() : null;
+}
+
 /**
- * 1. NEW PROJECT (Restored Full Logic)
- * Flow: PM (GDD) -> PM (Tasks) -> Worker (Task 1 Isolated)
+ * 1. NEW PROJECT
  */
 app.post('/new/project', validateRequest, async (req, res) => {
     const { userId, projectId, description } = req.body;
+    console.log(`[${projectId}] Init: ${description}`);
 
     try {
-        // 1. Generate GDD
         const pmHistory = [];
         const gddPrompt = `Create a comprehensive GDD for: ${description}`;
         const gddResponse = await AIEngine.callPM(pmHistory, gddPrompt);
@@ -50,25 +52,21 @@ app.post('/new/project', validateRequest, async (req, res) => {
         pmHistory.push({ role: 'user', parts: [{ text: gddPrompt }] });
         pmHistory.push({ role: 'model', parts: [{ text: gddResponse }] });
 
-        // 2. Generate Initial Task List & Extract First Prompt
         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 taskResponse = await AIEngine.callPM(pmHistory, taskPrompt);
 
         pmHistory.push({ role: 'user', parts: [{ text: taskPrompt }] });
         pmHistory.push({ role: 'model', parts: [{ text: taskResponse }] });
 
-        // 3. Extract the Isolated Prompt
         const initialWorkerInstruction = extractWorkerPrompt(taskResponse) || `Initialize structure for: ${description}`;
 
-        // 4. Initialize Worker (Fresh Scope)
         const workerHistory = [];
-        const initialWorkerPrompt = `CONTEXT: None (New Project). \nINSTRUCTION: ${initialWorkerInstruction}`;
-        const workerResponse = await AIEngine.callWorker(workerHistory, initialWorkerPrompt);
+        const initialWorkerPrompt = `CONTEXT: New Project. \nINSTRUCTION: ${initialWorkerInstruction}`;
+        const workerResponse = await AIEngine.callWorker(workerHistory, initialWorkerPrompt, []);
 
         workerHistory.push({ role: 'user', parts: [{ text: initialWorkerPrompt }] });
         workerHistory.push({ role: 'model', parts: [{ text: workerResponse }] });
 
-        // 5. Save State
         await StateManager.updateProject(projectId, {
             userId,
             pmHistory,
@@ -77,51 +75,43 @@ app.post('/new/project', validateRequest, async (req, res) => {
             failureCount: 0
         });
 
-        // Queue for Plugin
         StateManager.queueCommand(projectId, workerResponse);
-
         res.json({ success: true, message: "Project Initialized", gddPreview: gddResponse.substring(0, 200) });
 
     } catch (err) {
         console.error(err);
-        res.status(500).json({ error: "Initialization Failed" });
+        res.status(500).json({ error: "Init Failed" });
     }
 });
 
 /**
- * 2. FEEDBACK LOOP (Restored Escalation & Termination)
+ * 2. FEEDBACK LOOP (Enhanced with Consultation Channel)
  */
 app.post('/project/feedback', async (req, res) => {
-    const { projectId, prompt, hierarchyContext, scriptContext, logContext, taskComplete } = req.body;
+    const { projectId, prompt, hierarchyContext, scriptContext, logContext, taskComplete, images } = req.body;
     
     const project = await StateManager.getProject(projectId);
     if (!project) return res.status(404).json({ error: "Project not found." });
 
-    // ==========================================
-    // A. TASK COMPLETE -> SCOPE SWITCH
-    // ==========================================
+    // A. TASK COMPLETE
     if (taskComplete) {
         console.log(`[${projectId}] ✅ TASK COMPLETE.`);
         
-        // 1. Report to PM
         const summary = `Worker completed the previous task. Logs: ${logContext?.logs || "Clean"}. \nGenerate the NEXT task using 'WORKER_PROMPT:' format.`;
         const pmResponse = await AIEngine.callPM(project.pmHistory, summary);
         
         project.pmHistory.push({ role: 'user', parts: [{ text: summary }] });
         project.pmHistory.push({ role: 'model', parts: [{ text: pmResponse }] });
 
-        // 2. Get Next Instruction
         const nextInstruction = extractWorkerPrompt(pmResponse);
         if (!nextInstruction) {
              await StateManager.updateProject(projectId, { pmHistory: project.pmHistory, status: "IDLE" });
-             return res.json({ success: true, message: "No further tasks generated. Project Idle." });
+             return res.json({ success: true, message: "No further tasks. Project Idle." });
         }
 
-        // 3. NUKE WORKER (Scope Reset)
-        console.log(`[${projectId}] 🧹 Nuking Worker for next task.`);
         const newWorkerHistory = [];
         const newPrompt = `New Objective: ${nextInstruction}`;
-        const workerResponse = await AIEngine.callWorker(newWorkerHistory, newPrompt);
+        const workerResponse = await AIEngine.callWorker(newWorkerHistory, newPrompt, []);
 
         newWorkerHistory.push({ role: 'user', parts: [{ text: newPrompt }] });
         newWorkerHistory.push({ role: 'model', parts: [{ text: workerResponse }] });
@@ -132,46 +122,33 @@ app.post('/project/feedback', async (req, res) => {
             failureCount: 0
         });
 
-        // Clear Console Command + New Code
         StateManager.queueCommand(projectId, "CLEAR_CONSOLE"); 
         StateManager.queueCommand(projectId, workerResponse);
 
         return res.json({ success: true, message: "Next Task Assigned" });
     }
 
-    // ==========================================
-    // B. ERROR HANDLING & ESCALATION
-    // ==========================================
+    // B. ERROR ESCALATION
     let isFailure = false;
     if (logContext?.logs) {
-        const errs = ["Error", "Exception", "failed", "Stack Begin"];
+        const errs = ["Error", "Exception", "failed", "Stack Begin", "Infinite yield"];
         if (errs.some(k => logContext.logs.includes(k))) {
             isFailure = true;
             project.failureCount = (project.failureCount || 0) + 1;
         }
     }
 
-    // Prepare Prompt
-    const fullInput = `USER: ${prompt || "Automatic Feedback"}` + formatContext({ hierarchyContext, scriptContext, logContext });
-
-    // --- ESCALATION LOGIC (Restored) ---
-    if (project.failureCount > 2) {
-        console.log(`[${projectId}] 🚨 Escalating to PM (Failures: ${project.failureCount})...`);
-        
-        // 1. Ask PM for solution
+    // Escalation Threshold Check
+    if (project.failureCount > 3) {
+        console.log(`[${projectId}] 🚨 Escalating to PM...`);
         const pmPrompt = sysPrompts.pm_guidance_prompt.replace('{{LOGS}}', logContext?.logs);
         const pmVerdict = await AIEngine.callPM(project.pmHistory, pmPrompt);
 
-        // 2. CHECK: Did PM order termination?
         if (pmVerdict.includes("[TERMINATE]")) {
-            console.log(`[${projectId}] 💀 PM TERMINATED WORKER.`);
-            
             const fixInstruction = pmVerdict.replace("[TERMINATE]", "").trim();
-            
-            // Hard Reset
             const resetHistory = [];
             const resetPrompt = `[SYSTEM]: Previous worker terminated. \nNew Objective: ${fixInstruction}`;
-            const workerResp = await AIEngine.callWorker(resetHistory, resetPrompt);
+            const workerResp = await AIEngine.callWorker(resetHistory, resetPrompt, []);
             
             resetHistory.push({ role: 'user', parts: [{ text: resetPrompt }] });
             resetHistory.push({ role: 'model', parts: [{ text: workerResp }] });
@@ -179,40 +156,71 @@ app.post('/project/feedback', async (req, res) => {
             await StateManager.updateProject(projectId, { workerHistory: resetHistory, failureCount: 0 });
             StateManager.queueCommand(projectId, "CLEAR_CONSOLE");
             StateManager.queueCommand(projectId, workerResp);
-            
-            return res.json({ success: true, message: "Worker Terminated & Replaced." });
-        } 
-        else {
-            // 3. Just Guidance (Soft Fix)
-            console.log(`[${projectId}] 💡 PM Provided Guidance.`);
+            return res.json({ success: true, message: "Worker Terminated." });
+        } else {
             const injection = `[PM GUIDANCE]: ${pmVerdict} \n\nApply this fix now.`;
-            const workerResp = await AIEngine.callWorker(project.workerHistory, injection);
+            const workerResp = await AIEngine.callWorker(project.workerHistory, injection, []);
             
             project.workerHistory.push({ role: 'user', parts: [{ text: injection }] });
             project.workerHistory.push({ role: 'model', parts: [{ text: workerResp }] });
             
-            // Reset count slightly so we don't spam PM, but keep watch
-            await StateManager.updateProject(projectId, { workerHistory: project.workerHistory, failureCount: 0 });
+            await StateManager.updateProject(projectId, { workerHistory: project.workerHistory, failureCount: 1 });
             await StateManager.queueCommand(projectId, workerResp);
-            
             return res.json({ success: true, message: "PM Guidance Applied." });
         }
     }
 
-    // ==========================================
-    // C. STANDARD WORKER LOOP
-    // ==========================================
+    // C. STANDARD LOOP + CONSULTATION CHECK
     try {
-        const response = await AIEngine.callWorker(project.workerHistory, fullInput);
+        const fullInput = `USER: ${prompt || "Automatic Feedback"}` + formatContext({ hierarchyContext, scriptContext, logContext });
         
-        project.workerHistory.push({ role: 'user', parts: [{ text: fullInput }] });
-        project.workerHistory.push({ role: 'model', parts: [{ text: response }] });
+        // 1. Get Initial Worker Response
+        let response = await AIEngine.callWorker(project.workerHistory, fullInput, images || []);
         
+        // 2. CHECK FOR CONSULTATION REQUEST [ASK_PM: ...]
+        const pmQuestion = extractPMQuestion(response);
+
+        if (pmQuestion) {
+            console.log(`[${projectId}] 🙋 Worker asking PM: "${pmQuestion}"`);
+
+            // a. Ask PM
+            // We give the PM the worker's question AND a snippet of context so PM knows why
+            const pmConsultPrompt = `[WORKER CONSULTATION]: The Worker needs clarification:\n"${pmQuestion}"\n\nProvide a brief, technical answer to unblock them. Do not change the task scope unless necessary.`;
+            const pmAnswer = await AIEngine.callPM(project.pmHistory, pmConsultPrompt);
+
+            // Update PM history
+            project.pmHistory.push({ role: 'user', parts: [{ text: pmConsultPrompt }] });
+            project.pmHistory.push({ role: 'model', parts: [{ text: pmAnswer }] });
+
+            // b. Feed PM Answer back to Worker immediately
+            const injectionMsg = `[PM RESPONSE]: ${pmAnswer}\n\nProceed with this information.`;
+            
+            // We push the "Question" state to history so the worker remembers it asked
+            project.workerHistory.push({ role: 'user', parts: [{ text: fullInput }] });
+            project.workerHistory.push({ role: 'model', parts: [{ text: response }] }); // The response containing ASK_PM
+            
+            // Now we call worker again with the answer
+            console.log(`[${projectId}] 🗣️ PM Answered. Resuming Worker...`);
+            response = await AIEngine.callWorker(project.workerHistory, injectionMsg, []);
+            
+            // Push the answer transaction
+            project.workerHistory.push({ role: 'user', parts: [{ text: injectionMsg }] });
+            project.workerHistory.push({ role: 'model', parts: [{ text: response }] });
+
+        } else {
+            // Standard flow if no question
+            project.workerHistory.push({ role: 'user', parts: [{ text: fullInput }] });
+            project.workerHistory.push({ role: 'model', parts: [{ text: response }] });
+        }
+
+        // 3. Save & Queue Result
         await StateManager.updateProject(projectId, { 
             workerHistory: project.workerHistory,
+            pmHistory: project.pmHistory, // PM history might have updated if consulted
             failureCount: project.failureCount 
         });
         
+        // Queue whatever the FINAL response was (Code, Script read, etc.)
         await StateManager.queueCommand(projectId, response);
         res.json({ success: true });
 
@@ -223,21 +231,22 @@ app.post('/project/feedback', async (req, res) => {
 });
 
 /**
- * 3. HUMAN OVERRIDE (God Mode)
+ * 3. HUMAN OVERRIDE
  */
 app.post('/human/override', validateRequest, async (req, res) => {
     const { projectId, instruction, pruneHistory } = req.body;
     const project = await StateManager.getProject(projectId);
     
+    if (!project) return res.status(404).json({ error: "Project not found" });
+
     const overrideMsg = `[SYSTEM OVERRIDE]: ${instruction}`;
     
-    // Optional: Prune the argument if they are stuck
     if (pruneHistory && project.workerHistory.length >= 2) {
-        project.workerHistory.pop(); // last model
-        project.workerHistory.pop(); // last user
+        project.workerHistory.pop();
+        project.workerHistory.pop();
     }
 
-    const response = await AIEngine.callWorker(project.workerHistory, overrideMsg);
+    const response = await AIEngine.callWorker(project.workerHistory, overrideMsg, []);
     project.workerHistory.push({ role: 'user', parts: [{ text: overrideMsg }] });
     project.workerHistory.push({ role: 'model', parts: [{ text: response }] });
 
@@ -247,18 +256,15 @@ app.post('/human/override', validateRequest, async (req, res) => {
 });
 
 /**
- * 4. WORKER KILL (Manual Reassignment)
+ * 4. WORKER KILL
  */
 app.post('/worker/kill', validateRequest, async (req, res) => {
     const { projectId } = req.body;
-    // Logic: Just reset the history with a "Try again" prompt
-    const project = await StateManager.getProject(projectId);
-    
     const rebootPrompt = "[SYSTEM]: Worker process restarted. Attempt the task again from scratch.";
-    const response = await AIEngine.callWorker([{ role: 'user', parts: [{ text: rebootPrompt }] }], rebootPrompt);
+    const response = await AIEngine.callWorker([{ role: 'user', parts: [{ text: rebootPrompt }] }], rebootPrompt, []);
     
     await StateManager.updateProject(projectId, {
-        workerHistory: [{ role: 'user', parts: [{ text: rebootPrompt }] }], // Nuke history
+        workerHistory: [{ role: 'user', parts: [{ text: rebootPrompt }] }],
         workerHistory: [{ role: 'model', parts: [{ text: response }] }],
         failureCount: 0
     });
@@ -268,7 +274,7 @@ app.post('/worker/kill', validateRequest, async (req, res) => {
 });
 
 /**
- * 5. PING (Plugin Polling)
+ * 5. PING
  */
 app.post('/project/ping', async (req, res) => {
     const { projectId } = req.body;