Update app.js

app.js

@@ -9,16 +9,15 @@ import { createClient } from '@supabase/supabase-js';
 // ==========================================
 const PORT = 7860;
 const SUPABASE_URL = process.env.SUPABASE_URL;
-const SUPABASE_KEY = process.env.SUPABASE_SERVICE_KEY; // Must be Service Role
-const REMOTE_SERVER_URL = process.env.REMOTE_AI_URL || "http://localhost:7860";
+const SUPABASE_KEY = process.env.SUPABASE_SERVICE_KEY;
+const REMOTE_SERVER_URL = process.env.REMOTE_AI_URL || "http://localhost:11434"; // Defaulting to local Ollama/LMStudio if env missing
 const FRONT_URL = process.env.FRONT_URL;
+const CRON_REGISTRY_URL = process.env.CRON_REGISTRY_URL || "http://localhost:7861"; // URL of the Cron Server
+const CRON_SECRET = process.env.CRON_SECRET || "default_secret";
 
 // --- MODEL CONFIGURATION ---
-// Define your specific model IDs here. 
-// 'Architect': Used for PRDs, Briefings, Complex Reasoning.
-// 'Analyst': Used for raw log ingestion, MCP forwarding, and fast tasks.
-const SMART_MODEL_ID = "claude"; 
-const FAST_MODEL_ID = "gpt-5-mini"; // or "gpt-4o-mini"
+const SMART_MODEL_ID = "gpt-4-turbo"; 
+const FAST_MODEL_ID = "gpt-3.5-turbo"; 
 
 if (!SUPABASE_URL || !SUPABASE_KEY) {
     console.error("FATAL: Missing Supabase URL or Service Key.");
@@ -28,88 +27,71 @@ if (!SUPABASE_URL || !SUPABASE_KEY) {
 const app = express();
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
-// Increase limit to handle large file contexts/images
 app.use(express.json({ limit: '50mb' }));
 app.use(cors());
 
 // ==========================================
 // 2. PROMPT MANAGEMENT
 // ==========================================
-let prompts = {
-    director_system_prompt: "You are MOMENTUM, an elite AI Project Director. Your goal is to maintain flow.\n\nCOMMANDS:\n1. <thrust_create>{\"title\": \"...\", \"markdown_content\": \"...\", \"tasks\": [\"...\"]}</thrust_create>\n2. <timeline_log>{\"title\": \"...\", \"type\": \"feature\", \"description\": \"...\"}</timeline_log>\n3. <notification>Message</notification>\n4. <update_requirements>Markdown Content</update_requirements>\n\nOutput commands mixed with natural language.",
-    init_system_prompt: "You are the Lead Architect. Initialize this project.\n1. Analyze the user's idea.\n2. Create a comprehensive Requirements Document (Markdown).\n3. Create the FIRST Thrust (Briefing) to set up the environment.\n\nOUTPUT FORMAT:\nWrap the Requirements doc in <update_requirements>...</update_requirements> tags.\nWrap the First Thrust in <thrust_create>...</thrust_create> tags.",
-    log_analyst_prompt: "You are a Log Ingestion Analyst. Analyze the provided raw logs or MCP data. Summarize critical errors, performance bottlenecks, or notable events. Be concise."
-};
-
+let prompts = {}; 
+// Load synchronously on boot
 try {
     const promptsPath = path.resolve('./prompts.json');
     if (fs.existsSync(promptsPath)) {
-        console.log("Loading custom prompts from prompts.json...");
         const fileData = fs.readFileSync(promptsPath, 'utf8');
-        const parsed = JSON.parse(fileData);
-        prompts = { ...prompts, ...parsed };
+        prompts = JSON.parse(fileData);
+        console.log("✅ Prompts loaded.");
+    } else {
+        throw new Error("prompts.json not found");
     }
 } catch (e) {
-    console.error("Prompt Load Error (Using Defaults):", e.message);
+    console.error("❌ Prompt Load Error:", e.message);
+    process.exit(1);
 }
 
 // ==========================================
-// 3. STATE MANAGER (Full Implementation)
+// 3. STATE MANAGER
 // ==========================================
 const activeProjects = new Map();
 
 const StateManager = {
-    /**
-     * Fetches chat history, using in-memory cache if available/fresh,
-     * otherwise pulling from Supabase 'message_chunks'.
-     */
     getHistory: async (projectId) => {
-        // Cache Hit
         if (activeProjects.has(projectId)) {
             const cached = activeProjects.get(projectId);
             cached.lastActive = Date.now();
             return cached.history;
         }
 
-        // Cache Miss - DB Fetch
         const { data: chunks, error } = await supabase
             .from('message_chunks')
             .select('*')
             .eq('project_id', projectId)
             .order('chunk_index', { ascending: false })
-            .limit(10); // Load last 10 chunks (~200 messages max)
+            .limit(10);
 
-        if (error) {
-            console.error(`[StateManager] DB Fetch Error for ${projectId}:`, error.message);
-            return [];
-        }
-
-        // Flatten chunks (Newest chunks are first, so reverse to get chronological)
+        if (error) return [];
         const fullHistory = (chunks || []).reverse().flatMap(c => c.payload || []);
-
-        // Hydrate Cache
-        activeProjects.set(projectId, { history: fullHistory, lastActive: Date.now() });
+        
+        // Initialize Cache with default frozen state (false) if not known, will update from DB later
+        activeProjects.set(projectId, { history: fullHistory, lastActive: Date.now(), isFrozen: false });
         return fullHistory;
     },
 
-    /**
-     * Appends a message to the history.
-     * Handles the Chunking Logic: Appends to latest chunk if <20 msgs, else creates new.
-     */
     addHistory: async (projectId, role, text) => {
         const newMessage = { role, parts: [{ text }] };
 
-        // 1. Update In-Memory Cache
+        // Cache update
         if (activeProjects.has(projectId)) {
             const project = activeProjects.get(projectId);
             project.history.push(newMessage);
             project.lastActive = Date.now();
+            // User activity unfreezes project automatically
+            if (role === 'user') project.isFrozen = false; 
         }
 
-        // 2. Sync to Supabase
+        // DB Sync (Chunking Logic)
         try {
-            // Get the absolute latest chunk
-            const { data: latestData, error: fetchError } = await supabase
+            const { data: latestChunk } = await supabase
                 .from('message_chunks')
                 .select('id, chunk_index, payload')
                 .eq('project_id', projectId)
@@ -117,393 +99,359 @@ const StateManager = {
                 .limit(1)
                 .single();
 
-            if (fetchError && fetchError.code !== 'PGRST116') { // Ignore "No Rows Found" error
-                console.error("[StateManager] Chunk Fetch Error:", fetchError.message);
-            }
-
-            const latestChunk = latestData;
-            const currentPayload = (latestChunk && Array.isArray(latestChunk.payload)) ? latestChunk.payload : [];
+            const currentPayload = (latestChunk?.payload) || [];
 
             if (latestChunk && currentPayload.length < 20) {
-                // APPEND to existing chunk
-                const updatedPayload = [...currentPayload, newMessage];
-                const { error: updateError } = await supabase
-                    .from('message_chunks')
-                    .update({ payload: updatedPayload })
-                    .eq('id', latestChunk.id);
-
-                if (updateError) console.error("[StateManager] Chunk Update Failed:", updateError.message);
+                await supabase.from('message_chunks').update({ 
+                    payload: [...currentPayload, newMessage] 
+                }).eq('id', latestChunk.id);
             } else {
-                // CREATE NEW chunk
-                const nextIndex = (latestChunk?.chunk_index ?? -1) + 1;
-                const { error: insertError } = await supabase
-                    .from('message_chunks')
-                    .insert({
-                        project_id: projectId, // This maps to 'lead_id' in your schema logic, ensure column matches
-                        lead_id: projectId,    // Explicitly setting lead_id based on your schema reqs
-                        chunk_index: nextIndex,
-                        payload: [newMessage]
-                    });
-
-                if (insertError) console.error("[StateManager] Chunk Insert Failed:", insertError.message);
+                await supabase.from('message_chunks').insert({
+                    project_id: projectId,
+                    lead_id: projectId,
+                    chunk_index: (latestChunk?.chunk_index ?? -1) + 1,
+                    payload: [newMessage]
+                });
             }
-        } catch (e) {
-            console.error("[StateManager] Critical Logic Error:", e);
-        }
-    },
 
-    /**
-     * Garbage Collector
-     */
-    cleanup: () => {
-        const now = Date.now();
-        const TTL = 4 * 60 * 60 * 1000; // 4 Hours
-        let count = 0;
-        for (const [id, data] of activeProjects.entries()) {
-            if (now - data.lastActive > TTL) {
-                activeProjects.delete(id);
-                count++;
+            // If user spoke, unfreeze in DB
+            if (role === 'user') {
+                await supabase.from('leads').update({ is_frozen: false }).eq('id', projectId);
             }
-        }
-        if (count > 0) console.log(`[StateManager] 🧹 GC cleaned ${count} idle projects.`);
+
+        } catch (e) { console.error("History Sync Error", e); }
+    },
+    
+    // Check frozen state from DB
+    isFrozen: async (projectId) => {
+        if (activeProjects.has(projectId)) return activeProjects.get(projectId).isFrozen;
+        const { data } = await supabase.from('leads').select('is_frozen').eq('id', projectId).single();
+        return data?.is_frozen || false;
+    },
+
+    setFrozen: async (projectId, status) => {
+        if (activeProjects.has(projectId)) activeProjects.get(projectId).isFrozen = status;
+        await supabase.from('leads').update({ is_frozen: status }).eq('id', projectId);
     }
 };
 
-// Run GC every hour
-setInterval(StateManager.cleanup, 60 * 60 * 1000);
-
 // ==========================================
-// 4. AI ENGINE & CONTEXT LOGIC
+// 4. AI ENGINE
 // ==========================================
 
-const flattenHistory = (history, currentInput, systemPrompt, limit = 10, projectContext = "") => {
-    // Only take last 'limit' messages for context window to save tokens
-    const recentHistory = history ? history.slice(-limit) : [];
-
-    let contextStr = recentHistory.map(m => {
-        const roleName = m.role === 'model' ? 'Assistant' : 'User';
-        const content = m.parts?.[0]?.text || m.content || "";
-        return `${roleName}: ${content}`;
-    }).join('\n');
+const callAI = async (history, input, contextData, systemPrompt, projectContext, modelId) => {
+    // Construct Context
+    let contextStr = "";
+    try { contextStr = JSON.stringify(contextData, null, 2); } catch {}
 
-    // Robust prompt construction
-    return `System: ${systemPrompt}\n\n${projectContext}\n\n[CHAT HISTORY]:\n${contextStr}\n\nUser: ${currentInput}\nAssistant:`;
-};
+    const recentHistory = history.slice(-10).map(m => 
+        `${m.role === 'model' ? 'Assistant' : 'User'}: ${m.parts?.[0]?.text || ""}`
+    ).join('\n');
 
-/**
- * Enhanced callAI function that supports switching Model IDs
- */
-const callAI = async (history, input, contextData, systemPromptOverride = null, projectContext = "", targetModelId = SMART_MODEL_ID) => {
-    const systemPrompt = systemPromptOverride || prompts.director_system_prompt;
+    const fullPrompt = `System: ${systemPrompt}\n\n${projectContext}\n\n[HISTORY]:\n${recentHistory}\n\n[CONTEXT]: ${contextStr}\n\nUser: ${input}\nAssistant:`;
 
-    // Serialize Context safely
-    let contextString = "";
     try {
-        contextString = JSON.stringify(contextData, null, 2);
-    } catch (e) {
-        contextString = "Error serializing context data.";
-    }
-
-    const enrichedInput = `[CURRENT WORKSPACE CONTEXT]:\n${contextString}\n\n[USER INPUT]: ${input}`;
-    const prompt = flattenHistory(history, enrichedInput, systemPrompt, 10, projectContext);
-
-    try {
-        console.log(`[AI] Calling Remote Engine at ${REMOTE_SERVER_URL}...`);
-        console.log(`[AI] Selected Model: ${targetModelId}`);
-
         const response = await fetch(`${REMOTE_SERVER_URL}/api/generate`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                model: targetModelId, // DYNAMIC MODEL ID INJECTION
-                prompt: prompt,
-                system_prompt: systemPrompt
-            })
+            body: JSON.stringify({ model: modelId, prompt: fullPrompt, system_prompt: systemPrompt })
         });
 
-        if (!response.ok) {
-            const errText = await response.text();
-            throw new Error(`Remote AI Status ${response.status}: ${errText}`);
-        }
-
+        if (!response.ok) throw new Error("AI API Error");
         const result = await response.json();
-        const text = result.data || result.text || result.content || "";
-        const usage = result.usage || { totalTokenCount: 0 };
-
-        return { text, usage };
-
+        return { text: result.data || result.text || "", usage: result.usage };
     } catch (e) {
-        console.error("[AI] Connection Failed:", e.message);
-        return { text: "<notification>AI Connection Failed. Check Backend Logs.</notification>", usage: {} };
+        return { text: "<notification>AI Unreachable</notification>", usage: {} };
     }
 };
 
 // ==========================================
-// 5. COMMAND PARSER & EXECUTOR
+// 5. LOGIC & COMMANDS
 // ==========================================
 
 function extractCommands(text) {
     const commands = [];
-
-    // Helper to safely parse JSON from XML-like tags
-    const parse = (regex, type) => {
+    const parse = (regex, type, isJson = true) => {
         let match;
-        // Reset regex state just in case
         regex.lastIndex = 0;
         while ((match = regex.exec(text)) !== null) {
             try {
-                // If it's a notification, payload is string. Else JSON.
-                if (type === 'notification' || type === 'update_requirements') {
-                    commands.push({ type, payload: match[1].trim() });
-                } else {
-                    commands.push({ type, payload: JSON.parse(match[1]) });
-                }
-            } catch (e) {
-                console.error(`[Parser] JSON Error in ${type}:`, e.message);
-            }
+                commands.push({ type, payload: isJson ? JSON.parse(match[1]) : match[1].trim() });
+            } catch (e) { console.error(`Parse Error (${type})`, e); }
         }
     };
 
     parse(/<thrust_create>([\s\S]*?)<\/thrust_create>/g, 'create_thrust');
     parse(/<timeline_log>([\s\S]*?)<\/timeline_log>/g, 'log_timeline');
-    parse(/<notification>([\s\S]*?)<\/notification>/g, 'notification');
-    parse(/<update_requirements>([\s\S]*?)<\/update_requirements>/g, 'update_requirements');
+    parse(/<notification>([\s\S]*?)<\/notification>/g, 'notification', false);
+    parse(/<update_requirements>([\s\S]*?)<\/update_requirements>/g, 'update_requirements', false);
+    parse(/<schedule_briefing>([\s\S]*?)<\/schedule_briefing>/g, 'schedule_briefing');
+    parse(/<freeze_project>([\s\S]*?)<\/freeze_project>/g, 'freeze_project', false); // expecting "true"
+    parse(/<thrust_complete>([\s\S]*?)<\/thrust_complete>/g, 'thrust_complete', false); // expecting "true"
 
     return commands;
 }
 
+// Register Cron Helper
+async function registerMorningCron(projectId, offset) {
+    // 1. Calculate time until next 6 AM
+    const now = new Date();
+    const target = new Date(now);
+    
+    // Adjust logic: Find 6 AM in user's timezone relative to UTC
+    // Simple approach: Calculate ms delay
+    target.setUTCHours(6 - offset, 0, 0, 0); 
+    
+    if (target <= now) {
+        // If 6AM passed today, schedule for tomorrow
+        target.setDate(target.getDate() + 1);
+    }
+
+    const delayMs = target.getTime() - now.getTime();
+    const intervalMs = 24 * 60 * 60 * 1000; // 24 Hours
+
+    console.log(`⏰ Scheduling Briefing for ${projectId}. Next run in ${(delayMs/1000/60).toFixed(1)} mins.`);
+
+    // 2. Call Cron Registry (One time set for specific start, then interval)
+    // Note: The simple registry provided uses setInterval. To sync to 6AM exactly, 
+    // we register a job that fires in 'delayMs', which then executes logic and re-registers itself 
+    // OR simply use 24h interval starting NOW if close enough. 
+    
+    // Better strategy for this specific "Morning" requirement with a simple setInterval registry:
+    // We register a job with delayMs. The payload tells the Core "Setup Daily Loop".
+    
+    await fetch(`${CRON_REGISTRY_URL}/register`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            secret: CRON_SECRET,
+            jobId: `briefing_${projectId}`,
+            intervalMs: intervalMs, 
+            webhookUrl: `http://localhost:${PORT}/automated-briefing`, // Self-call
+            payload: { projectId, timezoneOffset: offset }
+        })
+    }).catch(e => console.error("Cron Reg Error", e));
+}
+
 async function executeCommands(userId, projectId, commands) {
-    let shouldReload = false;
+    let flags = { shouldReload: false, thrustComplete: false };
 
     for (const cmd of commands) {
-        console.log(`[Executor] Processing command: ${cmd.type}`);
+        console.log(`[CMD] ${cmd.type} -> Project: ${projectId}`);
+
         try {
-            // 1. Create Thrust (Briefing)
             if (cmd.type === 'create_thrust') {
-                const { data: thrust, error } = await supabase.from('thrusts').insert({
+                const { data: thrust } = await supabase.from('thrusts').insert({
                     lead_id: projectId,
                     title: cmd.payload.title,
                     markdown_content: cmd.payload.markdown_content,
                     status: 'active'
                 }).select().single();
 
-                if (error) throw new Error(`Thrust Insert: ${error.message}`);
-
-                if (thrust && cmd.payload.tasks && Array.isArray(cmd.payload.tasks)) {
+                if (thrust && cmd.payload.tasks) {
                     const tasks = cmd.payload.tasks.map(t => ({ thrust_id: thrust.id, title: t }));
-                    if (tasks.length > 0) {
-                        const { error: taskError } = await supabase.from('thrust_tasks').insert(tasks);
-                        if (taskError) console.error("Thrust Task Error:", taskError.message);
-                    }
+                    await supabase.from('thrust_tasks').insert(tasks);
                 }
-                shouldReload = true;
+                flags.shouldReload = true;
             }
 
-            // 2. Log Timeline
             if (cmd.type === 'log_timeline') {
-                const { error } = await supabase.from('timeline_events').insert({
+                await supabase.from('timeline_events').insert({
                     lead_id: projectId,
                     title: cmd.payload.title,
                     description: cmd.payload.description,
                     type: (cmd.payload.type || 'system').toLowerCase(),
                 });
-                if (error) console.error("Timeline Error:", error.message);
-                shouldReload = true;
+                flags.shouldReload = true;
             }
 
-            // 3. Update Requirements Doc
             if (cmd.type === 'update_requirements') {
-                const { error } = await supabase.from('leads').update({
-                    requirements_doc: cmd.payload
-                }).eq('id', projectId);
+                await supabase.from('leads').update({ requirements_doc: cmd.payload }).eq('id', projectId);
+                flags.shouldReload = true;
+            }
 
-                if (error) console.error("PRD Update Error:", error.message);
-                shouldReload = true; // Reload so context is fresh
+            if (cmd.type === 'schedule_briefing') {
+                const offset = cmd.payload.timezone_offset || 0;
+                await registerMorningCron(projectId, offset);
+            }
+
+            if (cmd.type === 'freeze_project') {
+                const isFrozen = cmd.payload === 'true';
+                await StateManager.setFrozen(projectId, isFrozen);
+                console.log(`❄️ Project ${projectId} Frozen: ${isFrozen}`);
+            }
+
+            if (cmd.type === 'thrust_complete') {
+                flags.thrustComplete = true; // Signals Core to trigger Smart Model
             }
 
-            // 4. Notify Frontend via Gateway
             if (cmd.type === 'notification' && FRONT_URL) {
-                // Fire and forget
                 fetch(`${FRONT_URL}/internal/notify`, {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        user_id: userId,
-                        type: 'toast',
-                        message: cmd.payload
-                    })
-                }).catch(e => console.error("Gateway Notify Error:", e.message));
+                    body: JSON.stringify({ user_id: userId, type: 'toast', message: cmd.payload })
+                }).catch(() => {});
             }
 
-        } catch (err) {
-            console.error(`[Executor] Failed to execute ${cmd.type}:`, err.message);
-        }
+        } catch (e) { console.error("Exec Error", e); }
     }
-    return shouldReload;
+    return flags;
 }
 
 // ==========================================
 // 6. ENDPOINTS
 // ==========================================
 
-app.get('/', (req, res) => res.send('Core Context Brain Active'));
-
-// --- Endpoint: Initialize Project (Background Architect) ---
-// USES: SMART_MODEL_ID
+// --- INIT ---
 app.post('/init-project', async (req, res) => {
     const { userId, name, description, localPath } = req.body;
+    
+    // Create DB Entry
+    const { data: lead } = await supabase.from('leads').insert({
+        user_id: userId, name, description, local_path: localPath, status: 'active', requirements_doc: "Init..."
+    }).select().single();
+
+    res.json({ success: true, leadId: lead.id });
+
+    // Background Process
+    setImmediate(async () => {
+        const initInput = `PROJECT: ${name}\nDESC: ${description}\nTask: Init PRD, First Thrust, Schedule Morning Briefing.`;
+        const aiResult = await callAI([], initInput, {}, prompts.init_system_prompt, "", SMART_MODEL_ID);
+        
+        await StateManager.addHistory(lead.id, 'user', initInput);
+        await StateManager.addHistory(lead.id, 'model', aiResult.text);
+        
+        const cmds = extractCommands(aiResult.text);
+        await executeCommands(userId, lead.id, cmds);
+    });
+});
 
-    if (!userId || !name) {
-        return res.status(400).json({ error: "Missing required fields" });
-    }
-
-    console.log(`🚀 Initializing Project: ${name} (${userId})`);
-
-    try {
-        // A. Create Lead in DB
-        const { data: lead, error } = await supabase.from('leads').insert({
-            user_id: userId,
-            name,
-            description,
-            local_path: localPath,
-            status: 'active',
-            requirements_doc: "Initializing..."
-        }).select().single();
-
-        if (error) throw error;
+// --- MAIN PROCESS ---
+app.post('/process', async (req, res) => {
+    const { userId, projectId, prompt, context, task_type = 'chat' } = req.body;
 
-        // B. Send HTTP Response immediately (Async processing)
-        res.json({ success: true, leadId: lead.id, message: "Project created. AI is Architecting..." });
+    // 1. Unfreeze if user interacts
+    if (task_type === 'chat') await StateManager.setFrozen(projectId, false);
 
-        // C. Background Operation
-        setImmediate(async () => {
-            console.log(`[Init] Starting AI Architecture for ${lead.id}...`);
-            const initInput = `PROJECT NAME: ${name}\nDESCRIPTION: ${description}\n\nTask: Initialize structure, create PRD, and first Thrust.`;
+    // 2. Select Model
+    // Logic: Log ingestion uses Fast model. If Fast model says "Thrust Complete", we switch to Smart.
+    let selectedModel = (task_type === 'log_ingestion') ? FAST_MODEL_ID : SMART_MODEL_ID;
+    let sysPrompt = (task_type === 'log_ingestion') ? prompts.log_analyst_prompt : prompts.director_system_prompt;
 
-            // 1. Call AI with INIT Prompt AND Smart Model
-            const aiResult = await callAI([], initInput, {}, prompts.init_system_prompt, "", SMART_MODEL_ID);
+    try {
+        // Fetch Context (PRD + Current Thrust)
+        const { data: lead } = await supabase.from('leads').select('requirements_doc').eq('id', projectId).single();
+        const { data: activeThrust } = await supabase.from('thrusts')
+            .select('title, tasks:thrust_tasks(title, status)')
+            .eq('lead_id', projectId)
+            .eq('status', 'active')
+            .order('created_at', { ascending: false })
+            .limit(1)
+            .single();
 
-            // 2. Add this interaction to history so the project has a "start"
-            await StateManager.addHistory(lead.id, 'user', initInput);
-            await StateManager.addHistory(lead.id, 'model', aiResult.text);
+        const projectContext = `
+        [PRD]: ${lead?.requirements_doc?.substring(0, 2000)}...
+        [CURRENT THRUST]: ${activeThrust ? JSON.stringify(activeThrust) : "None"}
+        `;
 
-            // 3. Execute (Save PRD, Create Thrust)
-            const commands = extractCommands(aiResult.text);
-            await executeCommands(userId, lead.id, commands);
+        const history = await StateManager.getHistory(projectId);
+        if (task_type === 'chat') await StateManager.addHistory(projectId, 'user', prompt);
+
+        // 3. AI Execution
+        let aiResult = await callAI(history, prompt, context, sysPrompt, projectContext, selectedModel);
+        
+        // 4. Command Execution
+        let cmds = extractCommands(aiResult.text);
+        let flags = await executeCommands(userId, projectId, cmds);
+
+        // 5. AUTO-ESCALATION (Fast -> Smart)
+        // If Log Analyst says thrust is done, we immediately call the Smart Director to generate the next one.
+        if (flags.thrustComplete && task_type === 'log_ingestion') {
+            console.log(`🚀 Thrust Complete detected by Analyst. Escalating to Director...`);
+            
+            const escalationPrompt = "The previous thrust is complete based on logs. Generate the next Thrust immediately to keep momentum.";
+            // Call Smart Model (No history of logs, just the context that it's done)
+            const smartResult = await callAI(history, escalationPrompt, context, prompts.director_system_prompt, projectContext, SMART_MODEL_ID);
+            
+            // Append Smart response
+            aiResult.text += `\n\n[DIRECTOR INTERVENTION]:\n${smartResult.text}`;
+            
+            const smartCmds = extractCommands(smartResult.text);
+            await executeCommands(userId, projectId, smartCmds);
+            
+            // Save history
+            await StateManager.addHistory(projectId, 'model', aiResult.text);
+        } else {
+            await StateManager.addHistory(projectId, 'model', aiResult.text);
+        }
 
-            console.log(`[Init] Architecture complete for ${lead.id}. Commands executed: ${commands.length}`);
+        // Clean output
+        const cleanText = aiResult.text.replace(/<[^>]+>[\s\S]*?<\/[^>]+>/g, '').trim();
 
-            // 4. Notify User
-            if (FRONT_URL) {
-                fetch(`${FRONT_URL}/internal/notify`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        user_id: userId,
-                        type: 'reload_project',
-                        message: "Project Architecture Ready"
-                    })
-                }).catch(e => console.error("Init Notify Failed", e.message));
-            }
-        });
+        res.json({ text: cleanText, should_reload: flags.shouldReload });
 
     } catch (e) {
-        console.error("Init Error:", e);
-        if (!res.headersSent) res.status(500).json({ error: e.message });
+        console.error(e);
+        res.status(500).json({ error: "Processing Error" });
     }
 });
 
-// --- Endpoint: Process Chat & Logs (Context Aware) ---
-// USES: DYNAMIC MODEL (Architect or Analyst)
-app.post('/process', async (req, res) => {
-    // task_type can be 'chat' (default) or 'log_ingestion'
-    const { userId, projectId, prompt, context, task_type = 'chat' } = req.body;
-
-    if (!userId || !projectId || !prompt) {
-        return res.status(400).json({ error: "Missing required fields" });
-    }
-
-    // --- SELECTION LOGIC ---
-    // Log ingestion uses the FAST model. High-level planning uses the SMART model.
-    const selectedModelId = task_type === 'log_ingestion' ? FAST_MODEL_ID : SMART_MODEL_ID;
-    const systemPromptOverride = task_type === 'log_ingestion' ? prompts.log_analyst_prompt : null;
-
-    console.log(`🧠 Processing for ${projectId} (Type: ${task_type} -> Model: ${selectedModelId})`);
+// --- AUTOMATED MORNING BRIEFING (Called by Cron) ---
+app.post('/automated-briefing', async (req, res) => {
+    const { projectId } = req.body;
+    console.log(`☀️ Morning Briefing Triggered: ${projectId}`);
 
     try {
-        // A. Fetch Context (PRD + Timeline)
-        // We fetch these fresh every time to ensure the AI has the "God View"
-        const { data: lead } = await supabase.from('leads')
-            .select('requirements_doc')
-            .eq('id', projectId)
-            .single();
-
-        const { data: timeline } = await supabase.from('timeline_events')
-            .select('title, type, description, created_at')
+        // 1. Check Freeze State
+        const isFrozen = await StateManager.isFrozen(projectId);
+        
+        // Check when the last thrust was made. If made today, skip.
+        const { data: lastThrust } = await supabase.from('thrusts')
+            .select('created_at')
             .eq('lead_id', projectId)
             .order('created_at', { ascending: false })
-            .limit(5);
+            .limit(1)
+            .single();
 
-        const projectContext = `
-[PROJECT REQUIREMENTS DOCUMENT]:
-${lead?.requirements_doc || "No requirements set yet."}
+        const lastThrustDate = lastThrust ? new Date(lastThrust.created_at).getDate() : 0;
+        const todayDate = new Date().getDate();
 
-[RECENT TIMELINE EVENTS]:
-${JSON.stringify(timeline || [])}
-`;
+        // LOGIC: If frozen, DO NOT generate. If thrust made today, DO NOT generate.
+        if (isFrozen) {
+            console.log(`Skipping briefing: Project Frozen.`);
+            return res.json({ status: "skipped_frozen" });
+        }
+        if (lastThrustDate === todayDate) {
+            console.log(`Skipping briefing: Thrust already exists for today.`);
+            return res.json({ status: "skipped_exists" });
+        }
 
-        // B. State Management: Fetch History & Add User Input
-        // If it's a huge log dump, we might NOT want to pollute history, but assuming we do for now:
+        // 2. Generate Briefing
+        const prompt = "It is 6 AM. Generate the Morning Briefing (New Thrust). If the project has been idle, use <freeze_project>true</freeze_project> after this.";
+        
+        // Use Process endpoint logic internally
+        // We create a fake "request" to process
+        // Ideally refactor logic out, but for now calling AI directly:
+        const { data: lead } = await supabase.from('leads').select('*').eq('id', projectId).single();
         const history = await StateManager.getHistory(projectId);
-        await StateManager.addHistory(projectId, 'user', prompt);
-
-        // C. AI Generation (Pass selected Model ID)
-        const aiResult = await callAI(history, prompt, context, systemPromptOverride, projectContext, selectedModelId);
-        const rawText = aiResult.text;
-
-        // D. State Management: Add AI Response
-        await StateManager.addHistory(projectId, 'model', rawText);
-
-        // E. Execute Commands (Only relevant if model returns commands, usually Smart model)
-        const commands = extractCommands(rawText);
-        const shouldReload = await executeCommands(userId, projectId, commands);
-
-        // F. Clean Response (Remove XML tags for frontend display)
-        const cleanText = rawText
-            .replace(/<thrust_create>[\s\S]*?<\/thrust_create>/g, '')
-            .replace(/<timeline_log>[\s\S]*?<\/timeline_log>/g, '')
-            .replace(/<notification>[\s\S]*?<\/notification>/g, '')
-            .replace(/<update_requirements>[\s\S]*?<\/update_requirements>/g, '')
-            .trim();
-
-        res.json({
-            text: cleanText,
-            should_reload: shouldReload,
-            usage: aiResult.usage,
-            model_used: selectedModelId
-        });
+        
+        const aiResult = await callAI(history, prompt, {}, prompts.director_system_prompt, `[PRD]: ${lead.requirements_doc}`, SMART_MODEL_ID);
+        
+        // 3. Save & Execute
+        await StateManager.addHistory(projectId, 'model', aiResult.text);
+        const cmds = extractCommands(aiResult.text);
+        await executeCommands(lead.user_id, projectId, cmds);
+
+        // 4. Force Freeze (Morning briefings lock the project until user returns)
+        // This ensures we don't pile up briefings on an abandoned project.
+        await StateManager.setFrozen(projectId, true); 
+
+        res.json({ success: true });
 
     } catch (e) {
-        console.error("Process Error:", e);
-        res.status(500).json({ error: "Processing Failed" });
+        console.error("Morning Briefing Error", e);
+        res.status(500).json({ error: e.message });
     }
 });
 
-// --- New Endpoint: Dedicated Log Ingestion (Optional helper) ---
-app.post('/ingest-logs', async (req, res) => {
-    // Wraps /process with enforced type
-    req.body.task_type = 'log_ingestion';
-    // Forward internally logic would go here, but usually, clients just call /process with flag
-    // This is just a placeholder if you need a specific route for webhooks.
-    res.redirect(307, '/process');
-});
-
-// ==========================================
-// 7. BOOT
-// ==========================================
-app.listen(PORT, () => {
-    console.log(`✅ Core Server is Online on Port ${PORT}`);
-    console.log(`🔗 Remote AI: ${REMOTE_SERVER_URL}`);
-    console.log(`🤖 Models Configured: Smart=${SMART_MODEL_ID}, Fast=${FAST_MODEL_ID}`);
-    console.log(`🔗 Front Gateway: ${FRONT_URL || "Not Set"}`);
-});
+app.listen(PORT, () => console.log(`✅ Core Online: ${PORT} | Smart: ${SMART_MODEL_ID} | Fast: ${FAST_MODEL_ID}`));