56

engine/classifier.js

@@ -1,182 +1,110 @@
 /**
- * Pini Message Classifier V5 (Production Ready)
- * =============================================
- * שיפורים:
- * 1. זיהוי שאלות (?) - מונע הזמנה בטעות כשלקוח רק מתעניין.
- * 2. רגישות למילות קישור ("כמו", "בלי") ולרגש ("שחיטה", "פיצוי").
- * 3. טיפול חכם בסטטוס מחיר.
+ * Pini Classifier V2 (Rule-Based First)
+ * =====================================
+ * מסווג הודעות על בסיס חוקים קשיחים.
+ * המטרה: 90% מההודעות לא צריכות להגיע ל-LLM.
  */
 
-const PRODUCT_KEYWORDS = {
-    // עברית
-    'פלייר': 'flyer', 'פליירים': 'flyer', 'עלון': 'flyer',
-    'כרטיס': 'bc', 'כרטיסים': 'bc', 'ביקור': 'bc', 'ביזנס': 'bc',
-    'הזמנה': 'invitation', 'הזמנות': 'invitation',
-    'רולאפ': 'rollup', 'באנר': 'rollup', 'שמשונית': 'banner',
-    'קנבס': 'canvas', 'תמונה': 'canvas',
-    'מדבקה': 'sticker', 'מדבקות': 'sticker', 'סטיקר': 'sticker',
-    'חוברת': 'booklet', 'קטלוג': 'booklet', 'מחברת': 'booklet', 'ספר': 'booklet',
-    
-    // אנגלית
-    'flyer': 'flyer', 'flyers': 'flyer',
-    'business card': 'bc', 'cards': 'bc',
-    'invitation': 'invitation', 'invites': 'invitation',
-    'sticker': 'sticker', 'stickers': 'sticker',
-    'rollup': 'rollup', 'banner': 'rollup'
-};
+const { PRODUCT_MAP } = require('./calculation');
 
-const ACTION_KEYWORDS = {
-    remove: ['תמחק', 'הסר', 'תוריד', 'בטל', 'הוצא', 'לא צריך', 'remove', 'delete'],
-    update: ['שנה', 'עדכן', 'תחליף', 'במקום', 'תעלה ל', 'תוריד ל', 'change', 'update'],
-    clear: ['נקה הכל', 'תמחק הכל', 'מחק עגלה', 'התחל מחדש', 'איפוס', 'עזוב הכל', 'reset', 'clear'],
-    greeting: ['היי', 'שלום', 'בוקר טוב', 'ערב טוב', 'מה קורה', 'מה נשמע', 'אהלן', 'hi', 'hello'],
-    send_quote: ['שלח', 'הצעה', 'סגור', 'תשלח', 'send', 'quote', 'finish', 'חשבונית'],
-    status: ['כמה זה', 'מחיר', 'סיכום', 'עגלה', 'תראה לי', 'סה"כ', 'כמה יוצא', 'total', 'status']
+// מילות מפתח לפעולות
+const ACTIONS = {
+    REMOVE: ['תמחק', 'הסר', 'תוריד', 'בטל', 'הוצא', 'לא צריך', 'remove', 'delete', 'cancel'],
+    UPDATE: ['שנה', 'עדכן', 'תחליף', 'במקום', 'תעלה ל', 'תוריד ל', 'change', 'update', 'edit'],
+    CLEAR: ['נקה הכל', 'תמחק הכל', 'מחק עגלה', 'התחל מחדש', 'איפוס', 'עזוב הכל', 'reset', 'clear'],
+    STATUS: ['כמה זה', 'מחיר', 'סיכום', 'עגלה', 'תראה לי', 'סה"כ', 'כמה יוצא', 'status', 'total'],
+    SEND: ['שלח', 'הצעה', 'סגור', 'תשלח', 'חשבונית', 'תכין לי', 'send', 'finish', 'checkout'],
+    GREETING: ['היי', 'שלום', 'בוקר טוב', 'ערב טוב', 'פיני', 'אהלן', 'hi', 'hello']
 };
 
-const HEBREW_NUMBERS = {
-    'אחד': 1, 'אחת': 1, 'שני': 2, 'שתי': 2, 'שניים': 2, 'שלושה': 3, 'שלוש': 3,
-    'ארבעה': 4, 'ארבע': 4, 'חמישה': 5, 'חמש': 5, 'עשרה': 10, 'עשר': 10,
-    'מאה': 100, 'מאתיים': 200, 'אלף': 1000, 'אלפיים': 2000
-};
-
-// 🚩 מילים שמקפיצות ל-LLM מיד
-const COMPLEXITY_TRIGGERS = [
-    'למה', 'איך', 'מתי', 'האם', 'תלוי', 
-    'קובץ', 'דחוף', 'הנחה', 'יקר', 'זול', 'משלוח', 'הבדל',
-    'פיצוי', 'חינם', 'תלונה', 'שחיטה', 'גרוע', 'עקום', // רגש שלילי/שירות
+// טריגרים למורכבות (מחייבים LLM)
+const COMPLEX_TRIGGERS = [
+    'למה', 'איך', 'מתי', 'האם', 'תלוי', 'הבדל',
+    'פיצוי', 'חינם', 'תלונה', 'שחיטה', 'גרוע', // רגש שלילי
     'כמו', 'בערך', 'אולי', // אי ודאות
-    'בליד', 'קרופ', 'וקטור', // מונחים טכניים
-    'למחר', 'היום', // דחיפות
-    'why', 'how', 'when', 'discount', 'expensive'
+    'עיצוב', 'גרפיקה', 'לוגו', // עיצוב (דורש הבנה)
+    'why', 'how', 'when', 'difference'
 ];
 
-/**
- * 🧠 זיהוי מורכבות חכם
- */
-function isComplexOrder(text) {
-    // 1. סימני חיבור מפורשים
-    if (text.includes('+') || text.includes(' plus ')) return true;
-    
-    // 2. ריבוי מוצרים (למשל: "פלייר וגם כרטיס")
-    const foundCategories = new Set();
-    for (const [keyword, category] of Object.entries(PRODUCT_KEYWORDS)) {
-        if (text.includes(keyword)) {
-            foundCategories.add(category);
-        }
-    }
-    
-    if (foundCategories.size > 1) return true;
-
-    return false;
-}
-
-function classifyMessage(message, context = {}) {
-    let text = message.toLowerCase();
+function classifyMessage(text, context = {}) {
+    const cleanText = text.toLowerCase().trim();
     const cart = context.cart || [];
+    const hasCart = cart.length > 0;
 
-    // המרת מספרים בעברית
-    for (const [word, num] of Object.entries(HEBREW_NUMBERS)) {
-        if (text.includes(word)) {
-            text = text.replace(word, num);
-        }
+    // 1. בדיקת בטיחות: האם זו בקשה מורכבת?
+    if (COMPLEX_TRIGGERS.some(t => cleanText.includes(t))) {
+        return { intent: 'consult', confidence: 1.0, needsLLM: true, reason: 'complexity_trigger' };
     }
 
-    // --- שלב 0: Safety & Complexity ---
+    // 2. זיהוי פעולות ברורות (Keywords)
     
-    // א. הזמנה מרובת מוצרים -> LLM
-    if (isComplexOrder(text)) {
-        return { action: 'chat', data: {}, needsLLM: true };
-    }
-
-    // ב. טריגרים מילוליים (רגש, דחיפות, טכני) -> LLM
-    if (COMPLEXITY_TRIGGERS.some(t => text.includes(t))) {
-        return { action: 'chat', data: {}, needsLLM: true };
-    }
-
-    // ג. זיהוי שאלות על מוצרים ("הקנבסים זה עם מסגרת?") -> LLM
-    // אם יש שם של מוצר וגם סימן שאלה, וזו לא שאלת מחיר סטנדרטית
-    const hasProduct = findProductInText(text);
-    const isPriceQuestion = text.includes('כמה') || text.includes('מחיר') || text.includes('cost');
-    if (hasProduct && text.includes('?') && !isPriceQuestion) {
-        return { action: 'chat', data: {}, needsLLM: true };
-    }
-
-    // --- שלב 1: זיהוי ליבה (מוצר + כמות) ---
-    const qtyMatch = text.match(/(\d{1,3}(?:,\d{3})*)/); 
-    const qty = qtyMatch ? parseInt(qtyMatch[0].replace(/,/g, '')) : null;
-    const product = findProductInText(text);
-
-    if (qty && product) {
-        // האם זה עדכון?
-        const isUpdate = ACTION_KEYWORDS.update.some(k => text.includes(k)) || 
-                         (cart.some(i => i.product_name === product) && 
-                          !text.includes('עוד') && !text.includes('תוסיף') && !text.includes('גם'));
-        
-        // תיקון: אם הלקוח אומר "תוריד ל-2000" זה Update, אבל אם הוא אומר "זה יקר, תוריד" - ה-Complex Trigger כבר תפס את זה למעלה
-        if (isUpdate && (text.includes('שנה') || text.includes('עדכן') || text.includes('במקום') || text.includes('תוריד') || text.includes('תעלה'))) {
-             return { action: 'update_qty', data: { product, qty }, needsLLM: false };
-        }
-        return { action: 'quote', data: { product, qty }, needsLLM: false };
+    // ניקוי
+    if (ACTIONS.CLEAR.some(k => cleanText.includes(k))) {
+        return { intent: 'clear', confidence: 1.0, needsLLM: false };
     }
 
-    // --- שלב 2: פעולות פשוטות ---
-
-    // ברכות
-    if (ACTION_KEYWORDS.greeting.some(k => text.includes(k)) && text.length < 20 && !text.includes('?')) {
-        return { action: 'greeting', data: {}, needsLLM: false };
+    // הסרה (רק אם יש מוצר במשפט)
+    if (ACTIONS.REMOVE.some(k => cleanText.includes(k))) {
+        return { intent: 'remove', confidence: 0.9, needsLLM: false };
     }
 
-    // ניקוי
-    if (ACTION_KEYWORDS.clear.some(k => text.includes(k))) {
-        return { action: 'clear', data: {}, needsLLM: false };
+    // סיום / שליחה
+    if (ACTIONS.SEND.some(k => cleanText.includes(k))) {
+        return { intent: 'checkout', confidence: 1.0, needsLLM: false };
     }
 
-    // שליחה / סיום
-    if (ACTION_KEYWORDS.send_quote.some(k => text.includes(k))) {
-        return { action: 'send_quote', data: {}, needsLLM: false };
+    // סטטוס
+    if (ACTIONS.STATUS.some(k => cleanText.includes(k))) {
+        return { intent: 'status', confidence: 1.0, needsLLM: false };
     }
 
-    // סטטוס (רק אם לא נתפס למעלה ע"י טריגרים כמו "שחיטה")
-    if (ACTION_KEYWORDS.status.some(k => text.includes(k))) {
-        return { action: 'status', data: {}, needsLLM: false };
-    }
+    // 3. זיהוי הזמנה/עדכון (מספר + מוצר)
+    const hasNumber = /\d+/.test(cleanText) || containsHebrewNumber(cleanText);
+    const productKey = identifyProductInText(cleanText);
 
-    // עיצוב / בדיקת קבצים
-    if ((text.includes('עיצוב') || text.includes('pdf') || text.includes('קובץ')) && 
-        (text.includes('יש') || text.includes('מוכן') || text.includes('ממני') || text.includes('בדיקה'))) {
-         return { action: 'design_check', data: {}, needsLLM: false };
-    }
+    if (hasNumber) {
+        // אם יש מילת עדכון ("שנה ל-1000")
+        if (ACTIONS.UPDATE.some(k => cleanText.includes(k))) {
+            return { intent: 'update', confidence: 0.9, needsLLM: false };
+        }
+        
+        // אם יש מוצר מפורש ("1000 פליירים")
+        if (productKey) {
+            return { intent: 'quote', confidence: 1.0, needsLLM: false }; // הוספה חדשה
+        }
 
-    // הסרה
-    if (ACTION_KEYWORDS.remove.some(k => text.includes(k))) {
-        const productToRemove = findProductInText(text);
-        return { action: 'remove', data: { product: productToRemove }, needsLLM: false };
+        // אם יש רק מספר ("1000") ויש משהו בעגלה -> עדכון אחרון
+        if (!productKey && hasCart) {
+            return { intent: 'update', confidence: 0.8, needsLLM: false };
+        }
     }
 
-    // --- שלב 3: השלמות ---
-
-    if (product && !qty) {
-        return { action: 'quote_incomplete', data: { product }, needsLLM: false };
+    // 4. מוצר ללא כמות ("אני צריך פליירים")
+    if (productKey && !hasNumber) {
+        return { intent: 'quote', confidence: 0.9, needsLLM: false }; // יטופל כ-Missing Info
     }
 
-    if (qty && !product) {
-        if (cart.length > 0) {
-            return { action: 'update_qty', data: { qty }, needsLLM: false };
-        }
+    // 5. ברכה (רק אם קצר)
+    if (ACTIONS.GREETING.some(k => cleanText.includes(k)) && cleanText.length < 20) {
+        return { intent: 'greeting', confidence: 0.9, needsLLM: false };
     }
 
-    // ברירת מחדל
-    return { action: 'chat', data: {}, needsLLM: true };
+    // ברירת מחדל: לא הבנו -> LLM
+    return { intent: 'consult', confidence: 0.5, needsLLM: true, reason: 'unknown' };
 }
 
-function findProductInText(text) {
-    for (const [keyword, key] of Object.entries(PRODUCT_KEYWORDS)) {
-        if (text.includes(keyword)) {
-            return key;
-        }
+// עזר: זיהוי מוצר בטקסט
+function identifyProductInText(text) {
+    for (const [keyword, category] of Object.entries(PRODUCT_MAP)) {
+        if (text.includes(keyword)) return category;
     }
     return null;
 }
 
+// עזר: זיהוי מספר בעברית
+function containsHebrewNumber(text) {
+    const hebrewNumbers = ['אחד', 'שתיים', 'שלוש', 'ארבע', 'חמש', 'שש', 'שבע', 'שמונה', 'תשע', 'עשר', 'מאה', 'אלף'];
+    return hebrewNumbers.some(n => text.includes(n));
+}
+
 module.exports = { classifyMessage };

engine/extractor.js

@@ -0,0 +1,77 @@
+/**
+ * Parameter Extractor
+ * ===================
+ * מחלץ נתונים מובנים מטקסט חופשי ללא שימוש ב-AI.
+ * תומך במספרים, כמויות (k), ומוצרים.
+ */
+
+const { PRODUCT_MAP } = require('./calculation');
+
+const HEBREW_NUMBERS = {
+    'אחד': 1, 'אחת': 1, 'שני': 2, 'שתי': 2, 'שניים': 2, 'שלושה': 3, 'שלוש': 3,
+    'ארבעה': 4, 'ארבע': 4, 'חמישה': 5, 'חמש': 5, 'שישה': 6, 'שש': 6,
+    'שבעה': 7, 'שבע': 7, 'שמונה': 8, 'תשעה': 9, 'תשע': 9, 'עשרה': 10, 'עשר': 10,
+    'עשרים': 20, 'חמישים': 50, 'מאה': 100, 'מאתיים': 200, 'חמש מאות': 500,
+    'אלף': 1000, 'אלפיים': 2000, 'חמשת אלפים': 5000, 'עשרת אלפים': 10000
+};
+
+const MODIFIERS = {
+    'דחוף': { urgency: 'high' },
+    'מהר': { urgency: 'high' },
+    'היום': { urgency: 'high' },
+    'מחר': { urgency: 'high' },
+    'אקספרס': { urgency: 'high' },
+    'עכשיו': { urgency: 'high' },
+    'זול': { budget: 'low' },
+    'הכי טוב': { quality: 'high' },
+    'פרימיום': { quality: 'high' }
+};
+
+function extractParameters(text) {
+    let cleanText = text.toLowerCase().replace(/,/g, ''); // הסרת פסיקים (1,000 -> 1000)
+    const params = {
+        product: null,
+        qty: null,
+        attributes: {}
+    };
+
+    // 1. חילוץ מוצר
+    for (const [keyword, category] of Object.entries(PRODUCT_MAP)) {
+        if (cleanText.includes(keyword)) {
+            params.product = category;
+            break; // מספיק מוצר אחד למשפט פשוט
+        }
+    }
+
+    // 2. חילוץ כמות (מספרים)
+    // תמיכה ב-k (1k = 1000)
+    const kMatch = cleanText.match(/(\d+)k/);
+    if (kMatch) {
+        params.qty = parseInt(kMatch[1]) * 1000;
+    } else {
+        // מספר רגיל
+        const numMatch = cleanText.match(/\d+/);
+        if (numMatch) {
+            params.qty = parseInt(numMatch[0]);
+        } else {
+            // מספר במילים
+            for (const [word, val] of Object.entries(HEBREW_NUMBERS)) {
+                if (cleanText.includes(word)) {
+                    params.qty = val;
+                    break;
+                }
+            }
+        }
+    }
+
+    // 3. חילוץ תכונות נוספות (דחיפות, איכות)
+    for (const [word, attr] of Object.entries(MODIFIERS)) {
+        if (cleanText.includes(word)) {
+            Object.assign(params.attributes, attr);
+        }
+    }
+
+    return params;
+}
+
+module.exports = { extractParameters };

engine/planner.js

@@ -0,0 +1,103 @@
+/**
+ * Pini Planner (The Brain)
+ * ========================
+ * מקבל כוונה ופרמטרים -> מחזיר רשימת משימות לביצוע.
+ * זה המקום שבו נקבעת ה"אסטרטגיה".
+ */
+
+function planActions(intent, params, session) {
+    const plan = {
+        actions: [],
+        nextState: 'idle' // למעקב אחרי הסטייט בשיחה
+    };
+
+    // === לוגיקת תכנון לפי כוונה ===
+
+    switch (intent) {
+        case 'quote':
+            // האם יש את כל המידע?
+            if (params.product && params.qty) {
+                // יש מוצר וכמות -> הוסף לעגלה
+                plan.actions.push({ 
+                    type: 'CALCULATE_AND_ADD', 
+                    payload: { product: params.product, qty: params.qty } 
+                });
+                
+                // האם ביקש דחוף? -> הוסף בדיקת דחיפות
+                if (params.attributes.urgency === 'high') {
+                    plan.actions.push({ type: 'CHECK_URGENCY_OPTIONS' });
+                }
+
+                // בסוף -> הצג תוצאה
+                plan.actions.push({ type: 'GENERATE_RESPONSE', template: 'quote_added' });
+                
+                // *** עדכון דשבורד חובה! ***
+                plan.actions.push({ type: 'UPDATE_DASHBOARD' });
+
+            } else if (params.product && !params.qty) {
+                // חסרה כמות -> שאל את הלקוח
+                plan.actions.push({ 
+                    type: 'ASK_QUESTION', 
+                    question: 'quantity', 
+                    product: params.product 
+                });
+            }
+            break;
+
+        case 'update':
+            // עדכון פריט קיים
+            const targetProduct = params.product || getLastAddedProduct(session);
+            if (targetProduct && params.qty) {
+                plan.actions.push({ 
+                    type: 'UPDATE_CART_ITEM', 
+                    payload: { product: targetProduct, qty: params.qty } 
+                });
+                plan.actions.push({ type: 'GENERATE_RESPONSE', template: 'quote_updated' });
+                plan.actions.push({ type: 'UPDATE_DASHBOARD' });
+            } else {
+                plan.actions.push({ type: 'ASK_CLARIFICATION', context: 'update_what' });
+            }
+            break;
+
+        case 'remove':
+            const productToRemove = params.product || getLastAddedProduct(session);
+            if (productToRemove) {
+                plan.actions.push({ type: 'REMOVE_FROM_CART', product: productToRemove });
+                plan.actions.push({ type: 'GENERATE_RESPONSE', template: 'item_removed' });
+                plan.actions.push({ type: 'UPDATE_DASHBOARD' });
+            }
+            break;
+
+        case 'checkout':
+            plan.actions.push({ type: 'SUMMARIZE_CART' });
+            plan.actions.push({ type: 'CHECK_DESIGN_STATUS' }); // בדיקה חכמה לפני סגירה
+            plan.actions.push({ type: 'GENERATE_RESPONSE', template: 'send_quote' });
+            break;
+
+        case 'clear':
+            plan.actions.push({ type: 'CLEAR_CART' });
+            plan.actions.push({ type: 'GENERATE_RESPONSE', template: 'cart_cleared' });
+            plan.actions.push({ type: 'UPDATE_DASHBOARD' });
+            break;
+            
+        case 'greeting':
+            plan.actions.push({ type: 'GENERATE_RESPONSE', template: 'greeting' });
+            break;
+
+        case 'consult':
+        default:
+            // העברה ל-LLM (רק כשאין ברירה)
+            plan.actions.push({ type: 'CALL_LLM_CONSULTANT', input: params });
+            break;
+    }
+
+    return plan;
+}
+
+// עזר: שליפת המוצר האחרון מהסשן
+function getLastAddedProduct(session) {
+    if (!session.cart || session.cart.length === 0) return null;
+    return session.cart[session.cart.length - 1].product_category; // או product_name
+}
+
+module.exports = { planActions };

server.js

@@ -1,25 +1,30 @@
 /**
- * Pini Print Bot - Server V7 (Strategy Enabled)
- * =============================================
- * שרת חכם שיודע לא רק להגיב אלא גם ליזום מהלכים (Proactive)
+ * Pini Print Bot - The Silent Engine (V8)
+ * =======================================
+ * ארכיטקטורה: Agentic Workflow (Plan -> Execute -> Respond)
+ * כולל מערכת לוגים מתקדמת לניטור ולמידה.
  */
 
 const express = require('express');
 const cors = require('cors');
 const dotenv = require('dotenv');
-const { GoogleGenerativeAI } = require('@google/generative-ai');
+const fs = require('fs');
+const path = require('path');
 
-// ייבוא מנועים
-const { classifyMessage } = require('./engine/classifier'); 
-const { routeRequest } = require('./engine/llmRouter'); 
+// --- ייבוא המנועים השקטים ---
+const { classifyMessage } = require('./engine/classifier');
+const { extractParameters } = require('./engine/extractor');
+const { planActions } = require('./engine/planner');
 const { calculate_custom_job } = require('./engine/calculation');
-const { getSession, removeFromCart, clearCart, addToHistory } = require('./services/sessionManager');
-const { generateQuotePDF } = require('./services/pdfService');
-const { buildResponse, buildQuickReplies } = require('./engine/responseBuilder');
 const { generateDashboard } = require('./engine/dashboardManager');
+const { buildResponse, buildQuickReplies } = require('./engine/responseBuilder');
+const { getSession, removeFromCart, clearCart, addToHistory } = require('./services/sessionManager');
 const { findOrCreateCustomer, extractPhoneFromText, extractNameFromText } = require('./engine/customerManager');
-const { PRODUCT_CATALOG } = require('./engine/productCatalog');
-const { detectTaskType, buildPrompt, validateResponse, fixResponse } = require('./engine/smartLLM');
+const { generateQuotePDF } = require('./services/pdfService');
+
+// --- ייבוא מנועי AI (למקרים מורכבים בלבד) ---
+const { routeRequest } = require('./engine/llmRouter'); // Fallback Planner
+const { handleWithSmartLLM } = require('./engine/smartLLM'); // Fallback Responder
 
 dotenv.config();
 const app = express();
@@ -28,195 +33,241 @@ app.use(cors({ origin: '*' }));
 app.use(express.json());
 app.use(express.static('public'));
 
-const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);
-const chatModel = genAI.getGenerativeModel({ model: "gemini-2.0-flash" });
-
-// הגדרות ברירת מחדל לאסטרטגיה
-const POPULAR_DEFAULTS = {
-    'bc': 500,
-    'flyer': 1000,
-    'invitation': 200,
-    'rollup': 1,
-    'sticker': 500,
-    'booklet': 50
+// === מערכת לוגים צבעונית ===
+const LOG = {
+    info: (msg) => console.log(`\x1b[36mℹ️  ${msg}\x1b[0m`), // Cyan
+    success: (msg) => console.log(`\x1b[32m✅ ${msg}\x1b[0m`), // Green
+    warning: (msg) => console.log(`\x1b[33m⚠️  ${msg}\x1b[0m`), // Yellow
+    error: (msg) => console.log(`\x1b[31m❌ ${msg}\x1b[0m`), // Red
+    brain: (msg) => console.log(`\x1b[35m🧠 ${msg}\x1b[0m`), // Magenta (Thinking)
+    action: (msg) => console.log(`\x1b[34m⚙️  ${msg}\x1b[0m`)  // Blue (Action)
 };
 
+// === מנגנון למידה עצמית (Self Correction) ===
+function logLearningEvent(type, input, output, correction = null) {
+    const event = {
+        timestamp: new Date().toISOString(),
+        type,
+        input,
+        output,
+        correction
+    };
+    // בפועל: שומרים לדאטהבייס. כרגע נכתוב לקובץ JSON
+    fs.appendFile('learning_logs.json', JSON.stringify(event) + '\n', (err) => {
+        if (err) console.error("Failed to save learning log");
+    });
+}
+
+// ============================================================
+// MAIN CHAT ENDPOINT
+// ============================================================
 app.post('/api/chat', async (req, res) => {
+    const startTime = Date.now();
     try {
         const { message, userId, phone, customerName } = req.body;
         if (!message) return res.status(400).json({ error: 'Missing message' });
-        
-        console.log(`\n💬 User: "${message}"`);
+
+        console.log('\n' + '='.repeat(60));
+        LOG.info(`New Message from ${userId}: "${message}"`);
+
+        // 1. ניהול סשן
         const session = getSession(userId);
+        let customer = null;
         
-        // זיהוי לקוח
+        // זיהוי לקוח (שם/טלפון)
         const extractedPhone = extractPhoneFromText(message);
         if (phone || extractedPhone) {
-            findOrCreateCustomer(phone || extractedPhone, customerName || extractNameFromText(message));
-            session.customerPhone = phone || extractedPhone;
+            customer = findOrCreateCustomer(phone || extractedPhone, customerName || extractNameFromText(message));
+            session.customerPhone = customer.phone;
+            LOG.success(`Customer Identified: ${customer.name || customer.phone}`);
         }
 
-        // ני��וב
-        let routerResult;
-        const classification = classifyMessage(message, { cart: session.cart });
+        // ============================================================
+        // שלב 1: הבנה (Perception)
+        // ============================================================
         
+        // א. סיווג (Classifier) - האם זה פשוט או מורכב?
+        const classification = classifyMessage(message, { cart: session.cart });
+        LOG.brain(`Classifier: [${classification.intent}] (Confidence: ${classification.confidence})`);
+
+        let intent = classification.intent;
+        let params = {};
+        let strategy = 'standard';
+
+        // ב. חילוץ פרמטרים (Extractor) או פנייה ל-LLM
         if (!classification.needsLLM) {
-            console.log(`⚡ Fast Path: ${classification.action}`);
-            routerResult = {
-                intent: mapActionToIntent(classification.action),
-                strategy: 'standard', // מסלול מהיר הוא תמיד סטנדרטי
-                items: [{ product: classification.data?.product, qty: classification.data?.qty }]
-            };
+            // מסלול מהיר (Rule-Based)
+            LOG.success(`⚡ Fast Path Triggered (No AI)`);
+            params = extractParameters(message);
+            LOG.brain(`Extracted Params: ${JSON.stringify(params)}`);
         } else {
-            console.log(`🤖 Using LLM (Strategy Engine)...`);
-            routerResult = await routeRequest(message, session.cart, session.history);
+            // מסלול חכם (LLM)
+            LOG.warning(`🤖 Complex Request -> Calling LLM Planner...`);
+            const llmResult = await routeRequest(message, session.cart, session.history);
+            intent = llmResult.intent;
+            strategy = llmResult.strategy || 'standard';
+            // נרמול התוצאה מה-LLM למבנה של ה-Extractor
+            if (llmResult.items && llmResult.items.length > 0) {
+                params = llmResult.items[0]; // לוקחים את הראשון כעיקרי כרגע
+                // אם יש מספר פריטים, ה-Planner יצטרך לדעת לטפל בזה (הרחבה עתידית)
+            }
+            LOG.brain(`LLM Decided: Intent=${intent}, Strategy=${strategy}`);
+            
+            // תיעוד ללמידה: למה המסווג נכשל?
+            logLearningEvent('fallback_to_llm', message, classification);
         }
+
+        // ============================================================
+        // שלב 2: תכנון (Planning)
+        // ============================================================
+        
+        // הוספת Strategy לפרמטרים אם הגיע מה-LLM או זוהה ע"י המערכת
+        if (params.attributes?.urgency === 'high') strategy = 'check_urgency';
         
-        console.log(`🧠 Intent: ${routerResult.intent} | Strategy: ${routerResult.strategy}`);
+        const plan = planActions(intent, params, session);
+        LOG.brain(`Action Plan Generated: ${plan.actions.length} steps`);
+        plan.actions.forEach(a => LOG.brain(`  -> ${a.type} (${JSON.stringify(a.payload || {})})`));
 
-        let responseData = { content: '', quickReplies: [] };
+        // ============================================================
+        // שלב 3: ביצוע (Execution)
+        // ============================================================
+        
+        let executionResults = {
+            responses: [], // אוסף תבניות תשובה
+            actionsTaken: [],
+            uiActions: [] // כפתורים וכו'
+        };
 
-        switch (routerResult.intent) {
-            case 'quote':
-                // === טיפול באסטרטגיה: הצעה יזומה (Offer Popular) ===
-                if (routerResult.strategy === 'offer_popular' && routerResult.items?.[0]?.product) {
-                    const product = routerResult.items[0].product;
-                    const defaultQty = POPULAR_DEFAULTS[product] || 100;
-                    
-                    // מחשבים את ההצעה הפופולרית
-                    const calc = calculate_custom_job(session.cart, {
-                        product_name: product,
-                        qty: defaultQty
-                    });
-                    
-                    // לא מוסיפים לעגלה אוטומטית, רק מציגים (סימולציה)
-                    responseData.content = `הכי הולך אצלנו זה ${defaultQty} יחידות ב-₪${calc.lastAdded.client_price}. זה מתאים לך, או שתרצה כמות אחרת?`;
-                    responseData.quickReplies = [
-                        { text: `כן, תזמין ${defaultQty}`, value: `אני רוצה ${defaultQty} ${product}` },
-                        { text: 'כמות אחרת', value: 'כמות אחרת' }
-                    ];
-                    break;
-                }
+        for (const action of plan.actions) {
+            LOG.action(`Executing: ${action.type}...`);
+            
+            try {
+                switch (action.type) {
+                    case 'CALCULATE_AND_ADD':
+                        const calcResult = calculate_custom_job(session.cart, action.payload);
+                        session.cart = calcResult.updatedCart;
+                        executionResults.lastItem = calcResult.lastAdded;
+                        executionResults.actionsTaken.push('item_added');
+                        LOG.success(`Added ${calcResult.lastAdded.product_name} (Price: ${calcResult.lastAdded.client_price})`);
+                        break;
 
-                // === טיפול באסטרטגיה: דחיפות (Check Urgency) ===
-                if (routerResult.strategy === 'check_urgency') {
-                    responseData.content = `אני מבין שזה דחוף! 🚀\nיש לנו מסלול אקספרס (מהיום להיום/מחר) בתוספת תשלום, או רגיל (3 ימי עסקים).\nאיך תרצה להתקדם?`;
-                    responseData.quickReplies = [
-                        { text: 'אקספרס (דחוף!)', value: 'אקספרס' },
-                        { text: 'רגיל זה בסדר', value: 'רגיל' }
-                    ];
-                    break; // עוצרים כאן כדי לקבל תשובה
-                }
+                    case 'UPDATE_CART_ITEM':
+                        // לוגיקה לעדכון (דומה להוספה, אבל דורס קיים)
+                        // ... (מימוש דומה ל-CALCULATE_AND_ADD)
+                        LOG.success(`Updated item quantity`);
+                        break;
 
-                // === מסלול רגיל (הוספה לעגלה) ===
-                const itemsToAdd = routerResult.items || [];
-                const addedItems = [];
-
-                for (const item of itemsToAdd) {
-                    if (item.product && item.qty) {
-                        const calc = calculate_custom_job(session.cart, {
-                            product_name: item.product,
-                            qty: item.qty,
-                            paper_type: item.attributes?.paper
-                        });
-                        session.cart = calc.updatedCart;
-                        addedItems.push(calc.lastAdded);
-                    }
-                }
+                    case 'REMOVE_FROM_CART':
+                        const removed = removeFromCart(userId, action.product);
+                        if (removed) LOG.success(`Removed ${action.product}`);
+                        else LOG.warning(`Item to remove not found: ${action.product}`);
+                        break;
+
+                    case 'CHECK_URGENCY_OPTIONS':
+                        // סימולציה: בדיקה מול טבלת ייצור
+                        const canExpress = true; // נניח שכן
+                        const expressCost = 50; // נניח
+                        executionResults.urgencyOption = { canExpress, cost: expressCost };
+                        LOG.info(`Urgency Check: Available (+${expressCost} NIS)`);
+                        break;
 
-                if (addedItems.length > 0) {
-                    // אם ה-Strategy הוא close_deal, נוסיף משפט סגירה
-                    let closingText = "";
-                    if (routerResult.strategy === 'close_deal') {
-                        closingText = "\n\nיש לנו את כל הפרטים. לשלוח לך לינק לתשלום וסגירה?";
-                    } else if (routerResult.strategy === 'req_file') {
-                        closingText = "\n\nיש לך כבר קובץ מוכן לשלוח לי?";
-                    }
-
-                    responseData.content = (addedItems.length === 1 
-                        ? buildResponse('quote_added', { item: addedItems[0] })
-                        : buildResponse('multi_quote_added', { items: addedItems, cart: session.cart })) + closingText;
+                    case 'GENERATE_RESPONSE':
+                        // שומרים את התבנית שצריך להפעיל בסוף
+                        executionResults.responseTemplate = action.template;
+                        break;
                     
-                    responseData.quickReplies = buildQuickReplies('cart_status');
-                } else {
-                    responseData.content = "הבנתי שאתה רוצה להזמין, מה הכמויות וסוג המוצר?";
-                    responseData.quickReplies = buildQuickReplies('greeting');
-                }
-                break;
-
-            case 'update':
-                const updateData = routerResult.items?.[0] || {};
-                const lastItem = session.cart[session.cart.length - 1];
-                if (lastItem && updateData.qty) {
-                    const upCalc = calculate_custom_job(session.cart, {
-                        product_name: lastItem.product_name,
-                        qty: updateData.qty
-                    });
-                    session.cart = upCalc.updatedCart;
-                    responseData.content = buildResponse('quote_updated', { item: upCalc.lastAdded, oldQty: lastItem.qty });
+                    case 'UPDATE_DASHBOARD':
+                        // יבוצע בסוף גורף
+                        break;
+                        
+                    case 'CALL_LLM_CONSULTANT':
+                        // במקרה שאין ברירה וצריך תשובה חופשית
+                        const llmResponse = await handleWithSmartLLM(message, session, customer);
+                        executionResults.customText = llmResponse.content;
+                        executionResults.quickReplies = llmResponse.quickReplies;
+                        break;
                 }
-                break;
-
-            case 'status':
-                responseData.content = buildResponse('cart_status', { cart: session.cart });
-                responseData.quickReplies = buildQuickReplies('cart_status');
-                break;
-
-            case 'design_check':
-                responseData.content = buildResponse('design_check', {});
-                responseData.quickReplies = buildQuickReplies('design_check');
-                break;
-
-            case 'checkout':
-                const total = session.cart.reduce((s, i) => s + i.client_price, 0);
-                responseData.content = buildResponse('send_quote', { total, cart: session.cart });
-                responseData.quickReplies = buildQuickReplies('send_quote');
-                break;
-
-            case 'greeting':
-                responseData.content = buildResponse('greeting');
-                responseData.quickReplies = buildQuickReplies('greeting');
-                break;
-
-            case 'consult':
-            default:
-                const llmResponse = await handleWithSmartLLM(message, session);
-                responseData.content = llmResponse.content;
-                break;
+            } catch (err) {
+                LOG.error(`Action Failed: ${action.type} - ${err.message}`);
+                logLearningEvent('execution_error', action, err.message);
+            }
         }
 
+        // ============================================================
+        // שלב 4: ניסוח תשובה (Response Generation)
+        // ============================================================
+        
+        let finalResponse = '';
+        let quickReplies = [];
+
+        // אם יש טקסט מותאם אישית מה-LLM (במקרה של Consult)
+        if (executionResults.customText) {
+            finalResponse = executionResults.customText;
+            quickReplies = executionResults.quickReplies || [];
+        } 
+        // אחרת, השתמש בתבנית שנבחרה ע"י ה-Planner
+        else if (executionResults.responseTemplate) {
+            // הזרקת נתונים לתבנית
+            const context = {
+                item: executionResults.lastItem,
+                cart: session.cart,
+                customer: customer,
+                userMessage: message,
+                // אם הייתה בדיקת דחיפות, נעביר את התוצאה לתבנית
+                urgency: executionResults.urgencyOption 
+            };
+            
+            finalResponse = buildResponse(executionResults.responseTemplate, context);
+            quickReplies = buildQuickReplies(executionResults.responseTemplate);
+            
+            // אם זוהתה דחיפות, נוסיף משפט דינמי (בלי LLM!)
+            if (strategy === 'check_urgency' && executionResults.urgencyOption) {
+                finalResponse += `\n\n🚀 ראיתי שזה דחוף. אפשר להריץ את זה באקספרס בתוספת ₪${executionResults.urgencyOption.cost}. לאשר?`;
+                quickReplies = [
+                    { text: 'כן, אקספרס', value: 'אשר אקספרס' },
+                    { text: 'לא, רגיל', value: 'משלוח רגיל' }
+                ];
+            }
+        } 
+        // ברירת מחדל אם משהו השתבש
+        else {
+            finalResponse = "קיבלתי, אבל אני לא בטוח מה לעשות הלאה. רוצה לדבר עם נציג?";
+            LOG.error("No response template selected!");
+        }
+
+        // שמירה בהיסטוריה
         addToHistory(userId, 'user', message);
-        addToHistory(userId, 'model', responseData.content);
+        addToHistory(userId, 'model', finalResponse);
+
+        // עדכון דשבורד
+        const dashboard = generateDashboard(session, session.customerPhone);
+        
+        const processTime = Date.now() - startTime;
+        LOG.info(`Request processed in ${processTime}ms`);
 
         res.json({
-            content: responseData.content,
+            content: finalResponse,
             cart: session.cart,
-            dashboard: generateDashboard(session, session.customerPhone),
-            quickReplies: responseData.quickReplies,
-            meta: { intent: routerResult.intent, strategy: routerResult.strategy }
+            dashboard: dashboard,
+            quickReplies: quickReplies,
+            meta: { 
+                intent, 
+                strategy, 
+                fastPath: !classification.needsLLM,
+                processTime 
+            }
         });
 
     } catch (error) {
-        console.error('Server Error:', error);
-        res.status(500).json({ content: 'תקלה בשרת, נסה שוב.' });
+        LOG.error(`Server Error: ${error.message}`);
+        console.error(error);
+        res.status(500).json({ content: 'סליחה, הייתה תקלה במערכת. נסה שוב.' });
     }
 });
 
-function mapActionToIntent(action) {
-    const map = { 'quote': 'quote', 'update_qty': 'update', 'remove': 'remove', 'greeting': 'greeting', 'send_quote': 'checkout', 'status': 'status', 'design_check': 'design_check' };
-    return map[action] || 'consult';
-}
-
-async function handleWithSmartLLM(message, session) {
-    const taskType = detectTaskType(message, { hasQuote: session.cart.length > 0 });
-    const promptData = buildPrompt(taskType, { userMessage: message, cart: session.cart, history: session.history });
-    const result = await chatModel.generateContent(promptData.system + "\n" + promptData.context);
-    let text = result.response.text();
-    return { content: text, quickReplies: [] };
-}
-
 // PDF Route
 app.post('/api/pdf', async (req, res) => {
+    // ... (אותו קוד קיים)
     try {
         const { cart, customer } = req.body;
         if (!cart || !Array.isArray(cart) || cart.length === 0) return res.status(400).json({ error: 'Cart empty' });
@@ -227,9 +278,14 @@ app.post('/api/pdf', async (req, res) => {
         });
         res.send(pdfBuffer);
     } catch (e) {
+        console.error("PDF Error", e);
         res.status(500).send("Error generating PDF");
     }
 });
 
 const PORT = process.env.PORT || 7860;
-app.listen(PORT, () => console.log(`🚀 Pini V7 Server (Strategy Engine) running on port ${PORT}`));
+app.listen(PORT, () => {
+    console.log(`\n🚀 Pini V8 Silent Engine Running on port ${PORT}`);
+    console.log(`📝 Logging enabled with color coding`);
+    console.log(`🧠 Self-correction hooks active\n`);
+});