Upload 34 files

CHANGELOG.md

@@ -1,5 +1,15 @@
 # Virtual Kimi App Changelog
 
+# [1.1.6.1] - 2025-09-05
+
+### Changed
+
+- Improved text formatting in the chat window.
+
+### Bug Fixes
+
+- Fixed some issues.
+
 # [1.1.5.1] - 2025-09-04
 
 ### Bug Fixes

index.html

@@ -1045,8 +1045,8 @@
                     <h3><i class="fas fa-code"></i> Technical Information</h3>
                     <div class="tech-info">
                         <p><strong>Created date :</strong> July 16, 2025</p>
-                        <p><strong>Version :</strong> v1.1.5.1</p>
-                        <p><strong>Last update :</strong> September 04, 2025</p>
+                        <p><strong>Version :</strong> v1.1.6.1</p>
+                        <p><strong>Last update :</strong> September 05, 2025</p>
                         <p><strong>Technologies :</strong> HTML5, CSS3, JavaScript ES6+, IndexedDB, Web Speech
                             API</p>
                         <p><strong>Status :</strong> ✅ Stable and functional</p>
@@ -1066,17 +1066,16 @@
         Keep this order when adding new managers. -->
     <script src="dexie.min.js"></script>
     <script src="kimi-locale/i18n.js"></script>
-    <script type="module" src="kimi-js/kimi-personality-utils.js"></script>
     <script type="module" src="kimi-js/kimi-utils.js"></script>
     <script type="module" src="kimi-js/kimi-main.js"></script>
     <script type="module" src="kimi-js/kimi-config.js"></script>
+    <script type="module" src="kimi-js/kimi-debug-utils.js"></script>
     <script type="module" src="kimi-js/kimi-error-manager.js"></script>
     <script type="module" src="kimi-js/kimi-security.js"></script>
     <script type="module" src="kimi-js/kimi-voices.js"></script>
     <script type="module" src="kimi-js/kimi-constants.js"></script>
     <script type="module" src="kimi-js/kimi-memory-ui.js"></script>
     <script type="module" src="kimi-js/kimi-appearance.js"></script>
-    <script type="module" src="kimi-js/kimi-data-manager.js"></script>
     <script type="module" src="kimi-js/kimi-module.js"></script>
     <script type="module" src="kimi-js/kimi-script.js"></script>
     <script type="module" src="kimi-js/kimi-plugin-manager.js"></script>

kimi-css/kimi-style.css

@@ -965,8 +965,10 @@ body {
     left: 50%;
     transform: translateX(-50%);
     width: 80%;
-    max-width: 600px;
+    max-width: 580px;
+    min-width: 280px;
     max-height: 400px;
+    min-height: 100px;
     padding: 15px;
     background: var(--transcript-bg);
     backdrop-filter: blur(10px);
@@ -979,6 +981,7 @@ body {
     box-shadow: 0 4px 20px rgba(0, 0, 0, 0.3);
     overflow-y: auto;
     overflow-x: hidden;
+    z-index: 100;
 }
 
 .transcript-container.visible {
@@ -1091,11 +1094,20 @@ button:focus,
     padding: 12px 16px;
     border-radius: 18px;
     font-size: 0.95rem;
-    line-height: 1.3;
-    white-space: pre-line;
+    line-height: 1.3; /* Espacement entre lignes dans un même paragraphe */
+    white-space: normal; /* Plus besoin de pre-line avec les <p> */
     animation: messageSlideIn 0.3s ease-out;
 }
 
+/* Contrôle de l'espacement entre paragraphes (sauts de ligne) */
+.message p {
+    margin: 0 0 0.8em 0; /* Espacement entre paragraphes */
+}
+
+.message p:last-child {
+    margin-bottom: 0; /* Pas d'espacement après le dernier paragraphe */
+}
+
 .message.user {
     align-self: flex-end;
     background: var(--chat-message-user-bg);
@@ -1693,10 +1705,13 @@ button:focus,
     .transcript-container {
         bottom: 200px;
         width: 90%;
+        max-height: 400px;
+        padding: 12px;
     }
 
     #transcript {
         font-size: 1rem;
+        line-height: 1.4;
     }
 
     .message {
@@ -1769,12 +1784,17 @@ button:focus,
     }
 
     .transcript-container {
-        bottom: 200px;
-        width: 90%;
+        bottom: 180px;
+        width: 95%;
+        max-height: 300px;
+        padding: 10px;
+        left: 50%;
+        transform: translateX(-50%);
     }
 
     #transcript {
-        font-size: 1rem;
+        font-size: 0.9rem;
+        line-height: 1.3;
     }
 
     .message {
@@ -1802,6 +1822,68 @@ button:focus,
     }
 }
 
+/* ===== TABLET SPECIFIC STYLES ===== */
+@media (min-width: 601px) and (max-width: 1024px) {
+    .transcript-container {
+        bottom: 200px;
+        width: 85%;
+        max-height: 350px;
+        padding: 15px;
+        max-width: 500px;
+    }
+
+    #transcript {
+        font-size: 1.1rem;
+        line-height: 1.4;
+    }
+}
+
+/* ===== VERY SMALL SCREENS ===== */
+@media (max-width: 400px) {
+    .transcript-container {
+        bottom: 160px;
+        width: 98%;
+        max-height: 250px;
+        padding: 8px;
+        border-radius: 8px;
+    }
+
+    #transcript {
+        font-size: 0.85rem;
+        line-height: 1.3;
+    }
+}
+
+/* ===== VERY LARGE SCREENS ===== */
+@media (min-width: 1400px) {
+    .transcript-container {
+        max-width: 600px;
+        max-height: 500px;
+        padding: 20px;
+        bottom: 200px;
+    }
+
+    #transcript {
+        font-size: 1.3rem;
+        line-height: 1.5;
+    }
+}
+
+/* ===== LANDSCAPE MODE ON MOBILE ===== */
+@media (max-width: 768px) and (orientation: landscape) {
+    .transcript-container {
+        bottom: 120px;
+        max-height: 200px;
+        width: 70%;
+        max-width: 400px;
+    }
+
+    #transcript {
+        font-size: 0.9rem;
+        line-height: 1.3;
+    }
+}
+
 /* Animation pour l'indicateur d'attente */
 .waiting-indicator {
     display: block;

kimi-js/kimi-config.js

@@ -67,6 +67,16 @@ window.KIMI_CONFIG = {
         NETWORK_ERROR: "Network error"
     },
 
+    // Debug configuration (centralized)
+    DEBUG: {
+        ENABLED: false, // Master debug switch
+        VOICE: false, // Voice system debug
+        VIDEO: false, // Video system debug
+        MEMORY: false, // Memory system debug
+        API: false, // API calls debug
+        SYNC: false // Synchronization debug
+    },
+
     // Available themes
     THEMES: {
         dark: "Dark Night",
@@ -109,6 +119,27 @@ window.KIMI_CONFIG.get = function (path, fallback = null) {
     }
 };
 
+// Centralized debug logging utility
+window.KIMI_CONFIG.debugLog = function (category, message, ...args) {
+    if (!this.DEBUG.ENABLED) return;
+
+    const categoryEnabled = category === "GENERAL" ? true : this.DEBUG[category];
+    if (!categoryEnabled) return;
+
+    const prefix =
+        category === "GENERAL"
+            ? "🔧"
+            : {
+                  VOICE: "🎤",
+                  VIDEO: "🎬",
+                  MEMORY: "💾",
+                  API: "📡",
+                  SYNC: "🔄"
+              }[category] || "🔧";
+
+    console.log(`${prefix} [${category}]`, message, ...args);
+};
+
 window.KIMI_CONFIG.validate = function (value, type) {
     try {
         const range = this.RANGES[type];

kimi-js/kimi-constants.js

@@ -262,7 +262,10 @@ window.KIMI_CONTEXT_NEGATIVE = {
         "idiote",
         "stupide",
         "con",
+        "conne",
+        "connasse",
         "connard",
+        "pute",
         "salope"
     ],
     es: [
@@ -1018,26 +1021,56 @@ window.KIMI_TRAIT_ADJUSTMENT = {
     }
 };
 
-// Helper function to get emotion keywords with fallback
+// Cached keyword lookups for performance
+const _keywordCache = new Map();
+
+// Helper function to get emotion keywords with fallback and caching
 window.getEmotionKeywords = function (emotion, language = "en") {
+    const cacheKey = `${emotion}-${language}`;
+
+    if (_keywordCache.has(cacheKey)) {
+        return _keywordCache.get(cacheKey);
+    }
+
     const keywords = window.KIMI_CONTEXT_KEYWORDS?.[language] || window.KIMI_CONTEXT_KEYWORDS?.en || {};
-    return keywords[emotion] || [];
+    const result = keywords[emotion] || [];
+
+    _keywordCache.set(cacheKey, result);
+    return result;
 };
 
-// Helper function to get personality keywords with fallback
+// Helper function to get personality keywords with fallback and caching
 window.getPersonalityKeywords = function (trait, type, language = "en") {
+    const cacheKey = `${trait}-${type}-${language}`;
+
+    if (_keywordCache.has(cacheKey)) {
+        return _keywordCache.get(cacheKey);
+    }
+
     const keywords = window.KIMI_PERSONALITY_KEYWORDS?.[language] || window.KIMI_PERSONALITY_KEYWORDS?.en || {};
-    return keywords[trait]?.[type] || [];
+    const result = keywords[trait]?.[type] || [];
+
+    _keywordCache.set(cacheKey, result);
+    return result;
 };
 
-// Helper function to get positive/negative context words
+// Helper function to get positive/negative context words with caching
 window.getContextWords = function (type, language = "en") {
+    const cacheKey = `context-${type}-${language}`;
+
+    if (_keywordCache.has(cacheKey)) {
+        return _keywordCache.get(cacheKey);
+    }
+
+    let result = [];
     if (type === "positive") {
-        return window.KIMI_CONTEXT_POSITIVE?.[language] || window.KIMI_CONTEXT_POSITIVE?.en || [];
+        result = window.KIMI_CONTEXT_POSITIVE?.[language] || window.KIMI_CONTEXT_POSITIVE?.en || [];
     } else if (type === "negative") {
-        return window.KIMI_CONTEXT_NEGATIVE?.[language] || window.KIMI_CONTEXT_NEGATIVE?.en || [];
+        result = window.KIMI_CONTEXT_NEGATIVE?.[language] || window.KIMI_CONTEXT_NEGATIVE?.en || [];
     }
-    return [];
+
+    _keywordCache.set(cacheKey, result);
+    return result;
 };
 
 // Helper function to validate character traits
@@ -1045,18 +1078,30 @@ window.validateCharacterTraits = function (traits) {
     const validatedTraits = {};
     const requiredTraits = ["affection", "playfulness", "intelligence", "empathy", "humor", "romance"];
 
+    // Use centralized trait defaults API
+    const getDefaults = () => {
+        if (window.getTraitDefaults) {
+            return window.getTraitDefaults();
+        }
+        // Fallback defaults that match KimiEmotionSystem.TRAIT_DEFAULTS
+        return {
+            affection: 55,
+            playfulness: 55,
+            intelligence: 70,
+            empathy: 75,
+            humor: 60,
+            romance: 50
+        };
+    };
+
+    const defaults = getDefaults();
+
     for (const trait of requiredTraits) {
         const value = traits[trait];
         if (typeof value === "number" && value >= 0 && value <= 100) {
             validatedTraits[trait] = value;
         } else {
-            // Use unified defaults from emotion system
-            if (window.KimiEmotionSystem) {
-                const emotionSystem = new window.KimiEmotionSystem();
-                validatedTraits[trait] = emotionSystem.TRAIT_DEFAULTS[trait] || 50;
-            } else {
-                validatedTraits[trait] = 50;
-            }
+            validatedTraits[trait] = defaults[trait] || 50;
         }
     }
 
@@ -1079,13 +1124,14 @@ window.KIMI_CHARACTERS = {
         name: "Kimi",
         summary: "Dreamy, intuitive, captivated by cosmic metaphors",
         traits: {
-            // Baseline balanced profile
-            affection: 55, // Starts neutral, grows with interaction
-            playfulness: 55,
-            intelligence: 75, // Higher intelligence - she's an astrophysicist
-            empathy: 75,
-            humor: 60,
-            romance: 50 // Romance develops slowly with cosmic connection
+            // Default character profile - MUST match KimiEmotionSystem.TRAIT_DEFAULTS exactly
+            // Kimi is the default character, so her traits serve as the system's fallback values
+            affection: 55, // Baseline neutral affection
+            playfulness: 55, // Moderately playful baseline
+            intelligence: 70, // Competent baseline intellect
+            empathy: 75, // Warm & caring baseline
+            humor: 60, // Mild sense of humor baseline
+            romance: 50 // Neutral romance baseline (earned over time)
         },
         age: 23,
         birthplace: "Tokyo, Japan",
@@ -1196,22 +1242,38 @@ window.KIMI_EMOTIONAL_RESPONSES = {
     cold: ["Hello.", "Yes?", "What do you want?", "I am here.", "How can I help you?"]
 };
 
-// Function to get localized emotional responses from translation files
+// Function to get localized emotional responses from translation files (with better error handling)
 window.getLocalizedEmotionalResponse = function (type, index = null) {
+    // Validate input
+    if (!type || typeof type !== "string") {
+        console.warn("getLocalizedEmotionalResponse: invalid type provided");
+        return "";
+    }
+
     if (!window.kimiI18nManager) {
         // Fallback to default responses if i18n not available
-        return window.KIMI_EMOTIONAL_RESPONSES[type]
-            ? window.KIMI_EMOTIONAL_RESPONSES[type][Math.floor(Math.random() * window.KIMI_EMOTIONAL_RESPONSES[type].length)]
-            : "";
+        const responses = window.KIMI_EMOTIONAL_RESPONSES[type];
+        if (!responses || !Array.isArray(responses) || responses.length === 0) {
+            return "";
+        }
+        return responses[Math.floor(Math.random() * responses.length)];
+    }
+
+    const responses = window.KIMI_EMOTIONAL_RESPONSES[type];
+    if (!responses || !Array.isArray(responses)) {
+        return "";
     }
 
-    const count = window.KIMI_EMOTIONAL_RESPONSES[type]?.length || 1;
-    const randomIndex = index !== null ? index : Math.floor(Math.random() * count) + 1;
+    const count = responses.length;
+    const randomIndex = index !== null ? Math.max(1, Math.min(count, index)) : Math.floor(Math.random() * count) + 1;
+
+    const translatedResponse = window.kimiI18nManager.t(`emotional_response_${type}_${randomIndex}`);
+
+    // If translation exists and isn't the key itself, use it
+    if (translatedResponse && translatedResponse !== `emotional_response_${type}_${randomIndex}`) {
+        return translatedResponse;
+    }
 
-    return (
-        window.kimiI18nManager.t(`emotional_response_${type}_${randomIndex}`) ||
-        (window.KIMI_EMOTIONAL_RESPONSES[type]
-            ? window.KIMI_EMOTIONAL_RESPONSES[type][Math.floor(Math.random() * window.KIMI_EMOTIONAL_RESPONSES[type].length)]
-            : "")
-    );
+    // Fallback to default responses
+    return responses[Math.floor(Math.random() * count)];
 };

kimi-js/kimi-database.js

@@ -17,7 +17,7 @@ class KimiDatabase {
                 settings: "category",
                 personality: "[character+trait],character",
                 llmModels: "id",
-                memories: "++id,[character+category],character,timestamp,isActive"
+                memories: "++id,[character+category],character,timestamp,isActive,importance"
             })
             .upgrade(async tx => {
                 try {
@@ -93,6 +93,36 @@ class KimiDatabase {
                     // Non-blocking: continue on error
                 }
             });
+
+        // Version 5: Clean schema with proper memory field defaults
+        this.db
+            .version(5)
+            .stores({
+                conversations: "++id,timestamp,favorability,character",
+                preferences: "key",
+                settings: "category",
+                personality: "[character+trait],character",
+                llmModels: "id",
+                memories: "++id,[character+category],character,timestamp,isActive,importance,accessCount"
+            })
+            .upgrade(async tx => {
+                try {
+                    // Ensure all memories have required fields for compatibility
+                    const memories = tx.table("memories");
+                    const now = new Date().toISOString();
+                    await memories.toCollection().modify(rec => {
+                        if (rec.isActive == null) rec.isActive = true;
+                        if (rec.importance == null) rec.importance = 0.5;
+                        if (rec.accessCount == null) rec.accessCount = 0;
+                        if (!rec.character) rec.character = "kimi";
+                        if (!rec.createdAt) rec.createdAt = rec.timestamp || now;
+                        if (!rec.lastAccess) rec.lastAccess = rec.timestamp || now;
+                    });
+                    console.log("✅ Database upgraded to v5: memory compatibility ensured");
+                } catch (e) {
+                    console.warn("Database upgrade v5 non-critical error:", e);
+                }
+            });
     }
 
     async setConversationsBatch(conversationsArray) {
@@ -104,6 +134,12 @@ class KimiDatabase {
             }
         } catch (error) {
             console.error("Error restoring conversations:", error);
+            // Log to error manager for tracking
+            if (window.kimiErrorManager) {
+                window.kimiErrorManager.logDatabaseError("restoreConversations", error, {
+                    conversationCount: conversationsArray.length
+                });
+            }
         }
     }
 
@@ -116,6 +152,12 @@ class KimiDatabase {
             }
         } catch (error) {
             console.error("Error restoring LLM models:", error);
+            // Log to error manager for tracking
+            if (window.kimiErrorManager) {
+                window.kimiErrorManager.logDatabaseError("setLLMModelsBatch", error, {
+                    modelCount: modelsArray.length
+                });
+            }
         }
     }
 
@@ -124,6 +166,16 @@ class KimiDatabase {
             return await this.db.memories.toArray();
         } catch (error) {
             console.warn("Error getting all memories:", error);
+            // Log to error manager for tracking
+            if (window.kimiErrorManager) {
+                const errorType = error.name === "SchemaError" ? "SchemaError" : "DatabaseError";
+                window.kimiErrorManager.logError(errorType, error, {
+                    operation: "getAllMemories",
+                    suggestion: error.message?.includes("not indexed")
+                        ? "Clear browser data to force schema upgrade"
+                        : "Check database integrity"
+                });
+            }
             return [];
         }
     }
@@ -148,10 +200,16 @@ class KimiDatabase {
     }
 
     getUnifiedTraitDefaults() {
+        // Use centralized API instead of hardcoded values
+        if (window.getTraitDefaults) {
+            return window.getTraitDefaults();
+        }
+        // Fallback: create new instance only if no global API available
         if (window.KimiEmotionSystem) {
             const emotionSystem = new window.KimiEmotionSystem(this);
             return emotionSystem.TRAIT_DEFAULTS;
         }
+        // Ultimate fallback (should never be reached in normal operation)
         return {
             affection: 55,
             playfulness: 55,
@@ -751,24 +809,23 @@ class KimiDatabase {
 
         // Use unified defaults from emotion system
         if (defaultValue === null) {
-            if (window.KimiEmotionSystem) {
+            // Use centralized API for trait defaults
+            if (window.getTraitDefaults) {
+                defaultValue = window.getTraitDefaults()[trait] || 50;
+            } else if (window.KimiEmotionSystem) {
                 const emotionSystem = new window.KimiEmotionSystem(this);
                 defaultValue = emotionSystem.TRAIT_DEFAULTS[trait] || 50;
             } else {
-                // Fallback defaults (must match KimiEmotionSystem.TRAIT_DEFAULTS exactly)
-                if (window.getTraitDefaults) {
-                    defaultValue = window.getTraitDefaults()[trait] || 50;
-                } else {
-                    defaultValue =
-                        {
-                            affection: 55,
-                            playfulness: 55,
-                            intelligence: 70,
-                            empathy: 75,
-                            humor: 60,
-                            romance: 50
-                        }[trait] || 50;
-                }
+                // Ultimate fallback (hardcoded values - should be avoided)
+                defaultValue =
+                    {
+                        affection: 55,
+                        playfulness: 55,
+                        intelligence: 70,
+                        empathy: 75,
+                        humor: 60,
+                        romance: 50
+                    }[trait] || 50;
             }
         }
 
@@ -1011,9 +1068,14 @@ class KimiDatabase {
 
         // Validation stricte : empêcher NaN ou valeurs non numériques
         const getDefault = trait => {
+            // Use centralized API for consistency
+            if (window.getTraitDefaults) {
+                return window.getTraitDefaults()[trait] || 50;
+            }
             if (window.KimiEmotionSystem) {
                 return new window.KimiEmotionSystem(this).TRAIT_DEFAULTS[trait] || 50;
             }
+            // Ultimate fallback (should be avoided)
             const fallback = { affection: 55, playfulness: 55, intelligence: 70, empathy: 75, humor: 60, romance: 50 };
             return fallback[trait] || 50;
         };

kimi-js/kimi-debug-utils.js

@@ -0,0 +1,133 @@
+// KIMI DEBUG UTILITIES
+// Centralized debug management for production optimization
+//
+// USAGE:
+// debugOn() - Enable all debug logs
+// debugOff() - Disable all debug logs (production mode)
+// debugStatus() - Show current debug configuration
+// kimiDebugAll() - Complete debug dashboard (includes errors)
+// kimiDiagnosDB() - Database schema diagnostics
+//
+// CATEGORIES:
+// KimiDebugController.setDebugCategory("VIDEO", true)
+// KimiDebugController.setDebugCategory("MEMORY", false)
+// Available: VIDEO, VOICE, MEMORY, API, SYNC
+
+// Global debug controller
+window.KimiDebugController = {
+    // Enable/disable all debug features
+    setGlobalDebug(enabled) {
+        if (window.KIMI_CONFIG && window.KIMI_CONFIG.DEBUG) {
+            window.KIMI_CONFIG.DEBUG.ENABLED = enabled;
+            window.KIMI_CONFIG.DEBUG.VOICE = enabled;
+            window.KIMI_CONFIG.DEBUG.VIDEO = enabled;
+            window.KIMI_CONFIG.DEBUG.MEMORY = enabled;
+            window.KIMI_CONFIG.DEBUG.API = enabled;
+            window.KIMI_CONFIG.DEBUG.SYNC = enabled;
+        }
+
+        // Legacy flags (to be removed)
+        window.KIMI_DEBUG_SYNC = enabled;
+        window.KIMI_DEBUG_MEMORIES = enabled;
+        window.KIMI_DEBUG_API_AUDIT = enabled;
+        window.DEBUG_SAFE_LOGS = enabled;
+
+        console.log(`🔧 Global debug ${enabled ? "ENABLED" : "DISABLED"}`);
+    },
+
+    // Enable specific debug category
+    setDebugCategory(category, enabled) {
+        if (window.KIMI_CONFIG && window.KIMI_CONFIG.DEBUG) {
+            if (category in window.KIMI_CONFIG.DEBUG) {
+                window.KIMI_CONFIG.DEBUG[category] = enabled;
+                console.log(`🔧 Debug category ${category} ${enabled ? "ENABLED" : "DISABLED"}`);
+            }
+        }
+
+        // Video manager specific
+        if (category === "VIDEO" && window.kimiVideo) {
+            window.kimiVideo.setDebug(enabled);
+        }
+    },
+
+    // Production mode (all debug off)
+    setProductionMode() {
+        this.setGlobalDebug(false);
+        console.log("🚀 Production mode activated - all debug logs disabled");
+    },
+
+    // Development mode (selective debug on)
+    setDevelopmentMode() {
+        this.setGlobalDebug(true);
+        console.log("🛠️ Development mode activated - debug logs enabled");
+    },
+
+    // Get current debug status
+    getDebugStatus() {
+        const status = {
+            global: window.KIMI_CONFIG?.DEBUG?.ENABLED || false,
+            voice: window.KIMI_CONFIG?.DEBUG?.VOICE || false,
+            video: window.KIMI_CONFIG?.DEBUG?.VIDEO || false,
+            memory: window.KIMI_CONFIG?.DEBUG?.MEMORY || false,
+            api: window.KIMI_CONFIG?.DEBUG?.API || false,
+            sync: window.KIMI_CONFIG?.DEBUG?.SYNC || false
+        };
+
+        console.table(status);
+        return status;
+    }
+};
+
+// Quick shortcuts for console
+window.debugOn = () => window.KimiDebugController.setDevelopmentMode();
+window.debugOff = () => window.KimiDebugController.setProductionMode();
+window.debugStatus = () => window.KimiDebugController.getDebugStatus();
+
+// Integration with error manager for unified debugging
+window.kimiDebugAll = () => {
+    console.group("🔧 Kimi Debug Dashboard");
+    window.KimiDebugController.getDebugStatus();
+    if (window.kimiErrorManager) {
+        window.kimiErrorManager.printErrorSummary();
+    }
+    console.groupEnd();
+};
+
+// Database diagnostics helper
+window.kimiDiagnosDB = async () => {
+    console.group("🔍 Database Diagnostics");
+    try {
+        if (window.kimiDB) {
+            console.log("📊 Database version:", window.kimiDB.db.verno);
+            console.log("📋 Available tables:", Object.keys(window.kimiDB.db._dbSchema));
+
+            // Check memories table schema
+            const memoriesSchema = window.kimiDB.db._dbSchema.memories;
+            if (memoriesSchema) {
+                console.log("🧠 Memories schema:", memoriesSchema);
+                const hasCharacterIsActiveIndex = memoriesSchema.indexes?.some(
+                    idx =>
+                        idx.name === "[character+isActive]" ||
+                        (idx.keyPath?.includes("character") && idx.keyPath?.includes("isActive"))
+                );
+                console.log("✅ [character+isActive] index:", hasCharacterIsActiveIndex ? "PRESENT" : "❌ MISSING");
+
+                if (!hasCharacterIsActiveIndex) {
+                    console.warn(
+                        "🚨 SOLUTION: Clear browser data (Application > Storage > Clear Site Data) to force schema upgrade"
+                    );
+                }
+            }
+        } else {
+            console.warn("❌ Database not initialized yet");
+        }
+    } catch (error) {
+        console.error("Error during database diagnostics:", error);
+    }
+    console.groupEnd();
+};
+
+// Auto-initialize to production mode for performance
+if (typeof window.KIMI_CONFIG !== "undefined") {
+    window.KimiDebugController.setProductionMode();
+}

kimi-js/kimi-emotion-system.js

@@ -6,6 +6,11 @@ class KimiEmotionSystem {
         this.db = database;
         this.negativeStreaks = {};
 
+        // Debouncing system for personality updates
+        this._personalityUpdateQueue = {};
+        this._personalityUpdateTimer = null;
+        this._personalityUpdateDelay = 300; // ms
+
         // Unified emotion mappings
         this.EMOTIONS = {
             // Base emotions
@@ -26,23 +31,59 @@ class KimiEmotionSystem {
             GOODBYE: "goodbye"
         };
 
-        // Unified video context mapping
+        // Unified video context mapping - CENTRALIZED SOURCE OF TRUTH
         this.emotionToVideoCategory = {
+            // Base emotional states
             positive: "speakingPositive",
             negative: "speakingNegative",
             neutral: "neutral",
+
+            // Special contexts (always take priority)
             dancing: "dancing",
             listening: "listening",
+
+            // Specific emotions mapped to appropriate categories
             romantic: "speakingPositive",
             laughing: "speakingPositive",
             surprise: "speakingPositive",
             confident: "speakingPositive",
-            shy: "neutral",
             flirtatious: "speakingPositive",
             kiss: "speakingPositive",
-            goodbye: "neutral"
+
+            // Neutral/subdued emotions
+            shy: "neutral",
+            goodbye: "neutral",
+
+            // Explicit context mappings (for compatibility)
+            speaking: "speakingPositive", // Generic speaking defaults to positive
+            speakingPositive: "speakingPositive",
+            speakingNegative: "speakingNegative"
+        };
+
+        // Emotion priority weights for conflict resolution
+        this.emotionPriorities = {
+            dancing: 10, // Maximum priority - immersive experience
+            kiss: 9, // Very high - intimate moment
+            romantic: 8, // High - emotional connection
+            listening: 7, // High - active interaction
+            flirtatious: 6, // Medium-high - playful interaction
+            laughing: 6, // Medium-high - positive expression
+            surprise: 5, // Medium - reaction
+            confident: 5, // Medium - personality expression
+            speaking: 4, // Medium-low - generic speaking context
+            positive: 4, // Medium-low - general positive
+            negative: 4, // Medium-low - general negative
+            neutral: 3, // Low - default state
+            shy: 3, // Low - subdued state
+            goodbye: 2, // Very low - transitional
+            speakingPositive: 4, // Medium-low - for consistency
+            speakingNegative: 4 // Medium-low - for consistency
         };
 
+        // Context/emotion validation system for system integrity
+        this.validContexts = ["dancing", "listening", "speaking", "speakingPositive", "speakingNegative", "neutral"];
+        this.validEmotions = Object.values(this.EMOTIONS);
+
         // Unified trait defaults - Balanced for progressive experience
         this.TRAIT_DEFAULTS = {
             affection: 55, // Baseline neutral affection
@@ -81,7 +122,152 @@ class KimiEmotionSystem {
             intelligence: { posFactor: 0.35, negFactor: 0.55, streakPenaltyAfter: 2, maxStep: 1.2 }
         };
     }
-    // (Affection is an independent trait again; previous derived computation removed.)
+
+    // ===== DEBOUNCED PERSONALITY UPDATE SYSTEM =====
+    _debouncedPersonalityUpdate(updates, character) {
+        // Merge with existing queued updates for this character
+        if (!this._personalityUpdateQueue[character]) {
+            this._personalityUpdateQueue[character] = {};
+        }
+        Object.assign(this._personalityUpdateQueue[character], updates);
+
+        // Clear existing timer and set new one
+        if (this._personalityUpdateTimer) {
+            clearTimeout(this._personalityUpdateTimer);
+        }
+
+        this._personalityUpdateTimer = setTimeout(async () => {
+            try {
+                const allUpdates = { ...this._personalityUpdateQueue };
+                this._personalityUpdateQueue = {};
+                this._personalityUpdateTimer = null;
+
+                // Process all queued updates
+                for (const [char, traits] of Object.entries(allUpdates)) {
+                    if (Object.keys(traits).length > 0) {
+                        await this.db.setPersonalityBatch(traits, char);
+
+                        // Emit unified personality update event
+                        if (typeof window !== "undefined" && window.dispatchEvent) {
+                            window.dispatchEvent(
+                                new CustomEvent("personality:updated", {
+                                    detail: { character: char, traits: traits }
+                                })
+                            );
+                        }
+                    }
+                }
+            } catch (error) {
+                console.error("Error in debounced personality update:", error);
+            }
+        }, this._personalityUpdateDelay);
+    }
+
+    // ===== CENTRALIZED VALIDATION SYSTEM =====
+    validateContext(context) {
+        if (!context || typeof context !== "string") return "neutral";
+        const normalized = context.toLowerCase().trim();
+
+        // Check if it's a valid context
+        if (this.validContexts.includes(normalized)) return normalized;
+
+        // Check if it's a valid emotion that can be mapped to context
+        if (this.emotionToVideoCategory[normalized]) return normalized;
+
+        return "neutral"; // Safe fallback
+    }
+
+    validateEmotion(emotion) {
+        if (!emotion || typeof emotion !== "string") return "neutral";
+        const normalized = emotion.toLowerCase().trim();
+
+        // Check if it's a valid emotion
+        if (this.validEmotions.includes(normalized)) return normalized;
+
+        // Check common aliases
+        const aliases = {
+            happy: "positive",
+            sad: "negative",
+            mad: "negative",
+            angry: "negative",
+            excited: "positive",
+            calm: "neutral",
+            romance: "romantic",
+            laugh: "laughing",
+            dance: "dancing",
+            // Speaking contexts as emotion aliases
+            speaking: "positive", // Generic speaking defaults to positive
+            speakingpositive: "positive",
+            speakingnegative: "negative"
+        };
+
+        if (aliases[normalized]) return aliases[normalized];
+
+        return "neutral"; // Safe fallback
+    }
+
+    validateVideoCategory(category) {
+        const validCategories = ["dancing", "listening", "speakingPositive", "speakingNegative", "neutral"];
+        if (!category || typeof category !== "string") return "neutral";
+
+        const normalized = category.toLowerCase().trim();
+        return validCategories.includes(normalized) ? normalized : "neutral";
+    }
+
+    // Enhanced emotion analysis with validation
+    analyzeEmotionValidated(text, lang = "auto") {
+        const rawEmotion = this.analyzeEmotion(text, lang);
+        return this.validateEmotion(rawEmotion);
+    }
+
+    // ===== UTILITY METHODS FOR SYSTEM INTEGRATION =====
+    // Centralized method to get video category for any emotion/context combination
+    getVideoCategory(emotionOrContext, traits = null) {
+        // Handle the case where we get both context and emotion (e.g., from determineCategory calls)
+        // Priority: Specific contexts > Specific emotions > Generic fallbacks
+
+        // Try context validation first for immediate context matches
+        let validated = this.validateContext(emotionOrContext);
+        if (validated !== "neutral" || emotionOrContext === "neutral") {
+            // Valid context found or explicitly neutral
+            const category = this.emotionToVideoCategory[validated] || "neutral";
+            return this.validateVideoCategory(category);
+        }
+
+        // If no valid context, try as emotion
+        validated = this.validateEmotion(emotionOrContext);
+        const category = this.emotionToVideoCategory[validated] || "neutral";
+        return this.validateVideoCategory(category);
+    } // Get priority weight for any emotion/context
+    getPriorityWeight(emotionOrContext) {
+        // Try context validation first, then emotion validation
+        let validated = this.validateContext(emotionOrContext);
+        if (validated === "neutral" && emotionOrContext !== "neutral") {
+            // If context validation gave neutral but input wasn't neutral, try as emotion
+            validated = this.validateEmotion(emotionOrContext);
+        }
+
+        return this.emotionPriorities[validated] || 3; // Default medium-low priority
+    }
+
+    // Check if an emotion/context should override current state
+    shouldOverride(newEmotion, currentEmotion, currentContext = null) {
+        const newPriority = this.getPriorityWeight(newEmotion);
+        const currentPriority = Math.max(this.getPriorityWeight(currentEmotion), this.getPriorityWeight(currentContext));
+
+        return newPriority > currentPriority;
+    }
+
+    // Utility to normalize and validate a complete emotion/context request
+    normalizeEmotionRequest(context, emotion, traits = null) {
+        return {
+            context: this.validateContext(context),
+            emotion: this.validateEmotion(emotion),
+            category: this.getVideoCategory(emotion || context, traits),
+            priority: this.getPriorityWeight(emotion || context)
+        };
+    }
+
     // ===== UNIFIED EMOTION ANALYSIS =====
     analyzeEmotion(text, lang = "auto") {
         if (!text || typeof text !== "string") return this.EMOTIONS.NEUTRAL;
@@ -358,8 +544,10 @@ class KimiEmotionSystem {
             const prep = this._preparePersistTrait(trait, current, candValue, selectedCharacter);
             if (prep.shouldPersist) toPersist[trait] = prep.value;
         }
+
+        // Use debounced update instead of immediate DB write
         if (Object.keys(toPersist).length > 0) {
-            await this.db.setPersonalityBatch(toPersist, selectedCharacter);
+            this._debouncedPersonalityUpdate(toPersist, selectedCharacter);
         }
 
         return updatedTraits;
@@ -467,8 +655,6 @@ class KimiEmotionSystem {
             }
         }
 
-        // Affection stays as independently adjusted by keywords & emotion (no derived override)
-
         // Flush pending updates in a single batch write to avoid overwrites
         if (Object.keys(pendingUpdates).length > 0) {
             // Apply smoothing/threshold per trait (read current values)
@@ -484,21 +670,6 @@ class KimiEmotionSystem {
         }
     }
 
-    // ===== UNIFIED VIDEO CONTEXT MAPPING =====
-    mapEmotionToVideoCategory(emotion) {
-        return this.emotionToVideoCategory[emotion] || "neutral";
-    }
-
-    // ===== VALIDATION SYSTEM =====
-    validateEmotion(emotion) {
-        const validEmotions = Object.values(this.EMOTIONS);
-        if (!validEmotions.includes(emotion)) {
-            console.warn(`Invalid emotion detected: ${emotion}, falling back to neutral`);
-            return this.EMOTIONS.NEUTRAL;
-        }
-        return emotion;
-    }
-
     validatePersonalityTrait(trait, value) {
         if (typeof value !== "number" || value < 0 || value > 100) {
             console.warn(`Invalid trait value for ${trait}: ${value}, using default`);
@@ -803,36 +974,31 @@ window.refreshPersonalityAverageUI = async function (characterKey = null) {
 export default KimiEmotionSystem;
 
 // ===== BACKWARD COMPATIBILITY LAYER =====
-// Replace the old kimiAnalyzeEmotion function
-window.kimiAnalyzeEmotion = function (text, lang = "auto") {
+// Ensure single instance of KimiEmotionSystem (Singleton pattern)
+function getKimiEmotionSystemInstance() {
     if (!window.kimiEmotionSystem) {
         window.kimiEmotionSystem = new KimiEmotionSystem(window.kimiDB);
     }
-    return window.kimiEmotionSystem.analyzeEmotion(text, lang);
+    return window.kimiEmotionSystem;
+}
+
+// Replace the old kimiAnalyzeEmotion function
+window.kimiAnalyzeEmotion = function (text, lang = "auto") {
+    return getKimiEmotionSystemInstance().analyzeEmotion(text, lang);
 };
 
 // Replace the old updatePersonalityTraitsFromEmotion function
 window.updatePersonalityTraitsFromEmotion = async function (emotion, text) {
-    if (!window.kimiEmotionSystem) {
-        window.kimiEmotionSystem = new KimiEmotionSystem(window.kimiDB);
-    }
-
-    const updatedTraits = await window.kimiEmotionSystem.updatePersonalityFromEmotion(emotion, text);
-
+    const updatedTraits = await getKimiEmotionSystemInstance().updatePersonalityFromEmotion(emotion, text);
     return updatedTraits;
 };
 
 // Replace getPersonalityAverage function
 window.getPersonalityAverage = function (traits) {
-    if (!window.kimiEmotionSystem) {
-        window.kimiEmotionSystem = new KimiEmotionSystem(window.kimiDB);
-    }
-    return window.kimiEmotionSystem.calculatePersonalityAverage(traits);
+    return getKimiEmotionSystemInstance().calculatePersonalityAverage(traits);
 };
 
 // Unified trait defaults accessor
 window.getTraitDefaults = function () {
-    if (window.kimiEmotionSystem) return window.kimiEmotionSystem.TRAIT_DEFAULTS;
-    const temp = new KimiEmotionSystem(window.kimiDB);
-    return temp.TRAIT_DEFAULTS;
+    return getKimiEmotionSystemInstance().TRAIT_DEFAULTS;
 };

kimi-js/kimi-error-manager.js

@@ -169,6 +169,44 @@ class KimiErrorManager {
             throw error;
         }
     }
+
+    // Debug helpers for development
+    getErrorSummary() {
+        const summary = {
+            totalErrors: this.errorLog.length,
+            critical: this.errorLog.filter(e => e.severity === "critical").length,
+            warning: this.errorLog.filter(e => e.severity === "warning").length,
+            recent: this.errorLog.filter(e => {
+                const errorTime = new Date(e.timestamp);
+                const fiveMinutesAgo = new Date(Date.now() - 5 * 60 * 1000);
+                return errorTime > fiveMinutesAgo;
+            }).length,
+            types: [...new Set(this.errorLog.map(e => e.type))]
+        };
+        return summary;
+    }
+
+    printErrorSummary() {
+        const summary = this.getErrorSummary();
+        console.group("🔍 Kimi Error Manager Summary");
+        console.log(`📊 Total Errors: ${summary.totalErrors}`);
+        console.log(`🚨 Critical: ${summary.critical}`);
+        console.log(`⚠️ Warnings: ${summary.warning}`);
+        console.log(`⏰ Recent (5min): ${summary.recent}`);
+        console.log(`📋 Error Types:`, summary.types);
+        if (summary.totalErrors > 0) {
+            console.log(`💡 Use kimiErrorManager.getErrorLog() to see details`);
+        }
+        console.groupEnd();
+        return summary;
+    }
+
+    clearAndSummarize() {
+        const summary = this.getErrorSummary();
+        this.clearErrorLog();
+        console.log("🧹 Error log cleared. Previous summary:", summary);
+        return summary;
+    }
 }
 
 // Create global instance
@@ -176,3 +214,6 @@ window.kimiErrorManager = new KimiErrorManager();
 
 // Export class for manual instantiation if needed
 window.KimiErrorManager = KimiErrorManager;
+
+// Global debugging helper
+window.kimiDebugErrors = () => window.kimiErrorManager.printErrorSummary();

kimi-js/kimi-llm-manager.js

@@ -95,7 +95,9 @@ class KimiLLMManager {
         try {
             await this.refreshRemoteModels();
         } catch (e) {
-            console.warn("Unable to refresh remote models list:", e?.message || e);
+            if (window.KIMI_CONFIG?.DEBUG?.API) {
+                console.warn("Unable to refresh remote models list:", e?.message || e);
+            }
         }
 
         // Migration: prefer llmModelId; if legacy defaultLLMModel exists and llmModelId missing, migrate
@@ -282,19 +284,25 @@ class KimiLLMManager {
                         "\nUse these memories naturally in conversation to show you remember the user. Don't just repeat them verbatim.\n";
                 }
             } catch (error) {
-                console.warn("Error loading memories for personality:", error);
+                if (window.KIMI_CONFIG?.DEBUG?.MEMORY) {
+                    console.warn("Error loading memories for personality:", error);
+                }
             }
         }
         // Read per-character preference metrics so displayed counters reflect actual stored values
-        // Prefer the personality trait 'affection' where available (authoritative source)
         const totalInteractions = Number(await this.db.getPreference(`totalInteractions_${character}`, 0)) || 0;
-        // Favorability should reflect the authoritative personality trait (affection).
-        let favorabilityLevel = await this.db.getPersonalityTrait("affection", null, character);
-        if (typeof favorabilityLevel !== "number" || !isFinite(favorabilityLevel)) {
-            // Fallback to legacy preference if DB helper didn't return a proper number
-            favorabilityLevel = Number(await this.db.getPreference(`favorabilityLevel_${character}`, 50)) || 50;
-        }
-        favorabilityLevel = Math.max(0, Math.min(100, Number(favorabilityLevel)));
+
+        // Get current personality average for relationship context (replacing old favorabilityLevel)
+        const currentPersonality = await this.db.getAllPersonalityTraits(character);
+        const relationshipLevel = window.getPersonalityAverage
+            ? window.getPersonalityAverage(currentPersonality)
+            : (currentPersonality.affection +
+                  currentPersonality.romance +
+                  currentPersonality.empathy +
+                  currentPersonality.playfulness +
+                  currentPersonality.humor +
+                  currentPersonality.intelligence) /
+              6;
         const lastInteraction = await this.db.getPreference(`lastInteraction_${character}`, "First time");
         // Days together is computed and displayed in the UI (see `updateStats()` in `kimi-module.js`).
         let daysTogether = 0;
@@ -407,7 +415,7 @@ class KimiLLMManager {
             "",
             "LEARNED PREFERENCES:",
             `- Total interactions: ${totalInteractions}`,
-            `- Current affection level: ${favorabilityLevel}%`,
+            `- Current relationship level: ${relationshipLevel.toFixed(1)}%`,
             `- Last interaction: ${lastInteraction}`,
             `- Days together: ${daysTogether}`,
             "",
@@ -442,6 +450,12 @@ class KimiLLMManager {
             this.personalityPrompt = await this.assemblePrompt("");
         } catch (error) {
             console.warn("Error refreshing memory context:", error);
+            // Log to error manager for tracking memory context issues
+            if (window.kimiErrorManager) {
+                window.kimiErrorManager.logError("MemoryContextError", error, {
+                    operation: "refreshMemoryContext"
+                });
+            }
         }
     }
 
@@ -459,7 +473,53 @@ class KimiLLMManager {
     }
 
     async chat(userMessage, options = {}) {
-        // Get LLM settings from individual preferences (FIXED: was using grouped settings)
+        // Use error manager wrapper for robust error handling
+        return (
+            window.kimiErrorManager?.wrapAsync(
+                async () => {
+                    // Get LLM settings from individual preferences (FIXED: was using grouped settings)
+                    const llmSettings = {
+                        temperature: await this.db.getPreference("llmTemperature", 0.9),
+                        maxTokens: await this.db.getPreference("llmMaxTokens", 400),
+                        top_p: await this.db.getPreference("llmTopP", 0.9),
+                        frequency_penalty: await this.db.getPreference("llmFrequencyPenalty", 0.9),
+                        presence_penalty: await this.db.getPreference("llmPresencePenalty", 0.8)
+                    };
+                    const temperature = typeof options.temperature === "number" ? options.temperature : llmSettings.temperature;
+                    const maxTokens = typeof options.maxTokens === "number" ? options.maxTokens : llmSettings.maxTokens;
+                    const opts = { ...options, temperature, maxTokens };
+                    try {
+                        const provider = await this.db.getPreference("llmProvider", "openrouter");
+                        if (provider === "openrouter") {
+                            return await this.chatWithOpenRouter(userMessage, opts);
+                        }
+                        if (provider === "ollama") {
+                            return await this.chatWithLocal(userMessage, opts);
+                        }
+                        return await this.chatWithOpenAICompatible(userMessage, opts);
+                    } catch (error) {
+                        console.error("Error during chat:", error);
+                        if (error.message && error.message.includes("API")) {
+                            return this.getFallbackResponse(userMessage, "api");
+                        }
+                        if ((error.message && error.message.includes("model")) || error.message.includes("model")) {
+                            return this.getFallbackResponse(userMessage, "model");
+                        }
+                        if ((error.message && error.message.includes("connection")) || error.message.includes("network")) {
+                            return this.getFallbackResponse(userMessage, "network");
+                        }
+                        return this.getFallbackResponse(userMessage);
+                    }
+                },
+                { operation: "chat", userMessageLength: userMessage?.length || 0 }
+            ) ||
+            // Fallback if error manager not available
+            this.chatDirectly(userMessage, options)
+        );
+    }
+
+    // Fallback method without error manager wrapper
+    async chatDirectly(userMessage, options = {}) {
         const llmSettings = {
             temperature: await this.db.getPreference("llmTemperature", 0.9),
             maxTokens: await this.db.getPreference("llmMaxTokens", 400),
@@ -518,6 +578,14 @@ class KimiLLMManager {
             return await this.chatWithOpenAICompatibleStreaming(userMessage, onToken, opts);
         } catch (error) {
             console.error("Error during streaming chat:", error);
+            // Log API error for tracking
+            if (window.kimiErrorManager) {
+                window.kimiErrorManager.logAPIError("streamingChat", error, {
+                    provider: await this.db.getPreference("llmProvider", "openrouter").catch(() => "unknown"),
+                    messageLength: userMessage?.length || 0,
+                    options: opts
+                });
+            }
             // Fallback to non-streaming if streaming fails
             return await this.chat(userMessage, options);
         }

kimi-js/kimi-main.js

@@ -5,6 +5,7 @@ import KimiLLMManager from "./kimi-llm-manager.js";
 import KimiEmotionSystem from "./kimi-emotion-system.js";
 
 // Expose module imports to legacy code paths that still rely on window
+// Ensure KimiProviderUtils is available (imported from kimi-utils.js)
 window.KimiProviderUtils = window.KimiProviderUtils || KimiProviderUtils;
 window.KimiLLMManager = window.KimiLLMManager || KimiLLMManager;
 window.KimiEmotionSystem = window.KimiEmotionSystem || KimiEmotionSystem;

kimi-js/kimi-memory-database-optimization.js

@@ -0,0 +1,211 @@
+// ===== KIMI MEMORY DATABASE OPTIMIZATION SUGGESTIONS =====
+
+/**
+ * Performance Optimization Guide for Kimi Memory System
+ *
+ * This file contains recommendations for database schema optimizations
+ * to improve query performance in the memory system.
+ */
+
+// RECOMMENDED DEXIE INDEX CONFIGURATION
+// Add these indexes to your database schema for optimal performance
+
+const RECOMMENDED_MEMORY_INDEXES = {
+    // Current schema (for reference)
+    current: "++id, character, category, type, timestamp, isActive, confidence, importance, keywords",
+
+    // OPTIMIZED schema with composite indexes
+    optimized: [
+        "++id", // Primary key (auto-increment)
+
+        // Single field indexes (existing)
+        "character",
+        "category",
+        "type",
+        "timestamp",
+        "isActive",
+        "confidence",
+        "importance",
+        "*keywords", // Multi-entry index for keyword array
+
+        // COMPOSITE INDEXES for frequent query patterns
+        "[character+isActive]", // Filter by character and active status
+        "[character+category]", // Get memories by character and category
+        "[character+category+isActive]", // Most common query pattern
+        "[character+timestamp]", // Chronological queries by character
+        "[isActive+importance]", // Get active memories by importance
+        "[isActive+timestamp]", // Recent active memories
+        "[character+type+isActive]", // Filter by character, type, and status
+
+        // Advanced composite indexes for complex queries
+        "[character+isActive+importance]", // Prioritized active memories by character
+        "[character+category+timestamp]" // Category-specific chronological queries
+    ]
+};
+
+// QUERY OPTIMIZATION EXAMPLES
+const OPTIMIZED_QUERY_PATTERNS = {
+    // BEFORE: Multiple filter operations
+    getAllMemoriesOld: `
+        db.memories
+            .where("character").equals(character)
+            .filter(m => m.isActive !== false)
+            .reverse()
+            .sortBy("timestamp")
+    `,
+
+    // AFTER: Use composite index
+    getAllMemoriesOptimized: `
+        db.memories
+            .where("[character+isActive]").equals([character, true])
+            .reverse()
+            .sortBy("timestamp")
+    `,
+
+    // BEFORE: Filter after retrieval
+    getMemoriesByCategoryOld: `
+        db.memories
+            .where("[character+category]").equals([character, category])
+            .and(m => m.isActive)
+    `,
+
+    // AFTER: Direct composite index
+    getMemoriesByCategoryOptimized: `
+        db.memories
+            .where("[character+category+isActive]").equals([character, category, true])
+    `,
+
+    // NEW: Efficient importance-based queries
+    getTopMemoriesByImportance: `
+        db.memories
+            .where("[character+isActive+importance]")
+            .between([character, true, 0.8], [character, true, 1.0])
+            .reverse()
+            .limit(10)
+    `
+};
+
+// PERFORMANCE MONITORING UTILITIES
+class MemoryDatabaseProfiler {
+    constructor() {
+        this.queryTimes = new Map();
+        this.queryCount = new Map();
+    }
+
+    // Wrap database operations to measure performance
+    async profileQuery(queryName, queryFn) {
+        const start = performance.now();
+        const result = await queryFn();
+        const duration = performance.now() - start;
+
+        // Update statistics
+        if (!this.queryTimes.has(queryName)) {
+            this.queryTimes.set(queryName, []);
+            this.queryCount.set(queryName, 0);
+        }
+
+        this.queryTimes.get(queryName).push(duration);
+        this.queryCount.set(queryName, this.queryCount.get(queryName) + 1);
+
+        // Log slow queries
+        if (duration > 50) {
+            // 50ms threshold
+            console.warn(`🐌 Slow query detected: ${queryName} took ${duration.toFixed(2)}ms`);
+        }
+
+        return result;
+    }
+
+    // Get performance statistics
+    getStats() {
+        const stats = {};
+
+        for (const [queryName, times] of this.queryTimes.entries()) {
+            const count = this.queryCount.get(queryName);
+            const avgTime = times.reduce((sum, time) => sum + time, 0) / times.length;
+            const maxTime = Math.max(...times);
+            const minTime = Math.min(...times);
+
+            stats[queryName] = {
+                count,
+                avgTime: Math.round(avgTime * 100) / 100,
+                maxTime: Math.round(maxTime * 100) / 100,
+                minTime: Math.round(minTime * 100) / 100,
+                totalTime: Math.round(times.reduce((sum, time) => sum + time, 0) * 100) / 100
+            };
+        }
+
+        return stats;
+    }
+
+    // Reset statistics
+    reset() {
+        this.queryTimes.clear();
+        this.queryCount.clear();
+    }
+}
+
+// MEMORY USAGE OPTIMIZATION
+const MEMORY_CLEANUP_STRATEGIES = {
+    // Strategy 1: Batch cleanup operations
+    batchCleanup: async (db, maxBatchSize = 100) => {
+        const oldMemories = await db.memories.where("isActive").equals(false).limit(maxBatchSize).toArray();
+
+        if (oldMemories.length > 0) {
+            await db.memories.bulkDelete(oldMemories.map(m => m.id));
+            console.log(`🧹 Batch deleted ${oldMemories.length} inactive memories`);
+        }
+    },
+
+    // Strategy 2: Incremental keyword cleanup
+    cleanupKeywords: async db => {
+        const memoriesWithEmptyKeywords = await db.memories
+            .filter(m => !m.keywords || m.keywords.length === 0)
+            .limit(50)
+            .toArray();
+
+        for (const memory of memoriesWithEmptyKeywords) {
+            const keywords = deriveKeywords(memory.content || "");
+            await db.memories.update(memory.id, { keywords });
+        }
+    },
+
+    // Strategy 3: Compress old memories
+    compressOldMemories: async (db, daysThreshold = 90) => {
+        const cutoff = new Date();
+        cutoff.setDate(cutoff.getDate() - daysThreshold);
+
+        const oldMemories = await db.memories
+            .where("timestamp")
+            .below(cutoff)
+            .and(m => m.isActive && !m.compressed)
+            .limit(20)
+            .toArray();
+
+        for (const memory of oldMemories) {
+            // Compress by removing redundant fields and shortening content
+            const compressed = {
+                compressed: true,
+                originalLength: memory.content?.length || 0,
+                content: memory.content?.substring(0, 100) + "...",
+                // Remove non-essential fields
+                sourceText: undefined,
+                tags: memory.tags?.slice(0, 3) // Keep only top 3 tags
+            };
+
+            await db.memories.update(memory.id, compressed);
+        }
+    }
+};
+
+// EXPORT UTILITIES
+if (typeof window !== "undefined") {
+    window.KIMI_MEMORY_DB_OPTIMIZATION = {
+        RECOMMENDED_MEMORY_INDEXES,
+        OPTIMIZED_QUERY_PATTERNS,
+        MemoryDatabaseProfiler,
+        MEMORY_CLEANUP_STRATEGIES
+    };
+}
+
+export { RECOMMENDED_MEMORY_INDEXES, OPTIMIZED_QUERY_PATTERNS, MemoryDatabaseProfiler, MEMORY_CLEANUP_STRATEGIES };

kimi-js/kimi-memory-system.js

@@ -4,6 +4,99 @@ class KimiMemorySystem {
         this.db = database;
         this.memoryEnabled = true;
         this.maxMemoryEntries = 100;
+
+        // Performance optimization: keyword cache with LRU eviction
+        this.keywordCache = new Map(); // keyword_language -> boolean (is common)
+        this.keywordCacheSize = 1000; // Limit memory usage
+        this.keywordCacheHits = 0;
+        this.keywordCacheMisses = 0;
+
+        // Performance monitoring
+        this.queryStats = {
+            extractionTime: [],
+            addMemoryTime: [],
+            retrievalTime: []
+        };
+
+        // Centralized configuration for all thresholds and magic numbers
+        this.config = {
+            // Content validation thresholds
+            minContentLength: 2,
+            longContentThreshold: 24,
+            titleWordCount: {
+                preferred: 3,
+                min: 1,
+                max: 5
+            },
+
+            // Similarity and confidence thresholds
+            similarity: {
+                personal: 0.6, // Names can vary more (Jean vs Jean-Pierre)
+                preferences: 0.7, // Preferences can be expressed differently
+                default: 0.8, // General similarity threshold
+                veryHigh: 0.9, // For boost_confidence strategy
+                update: 0.3 // Lower threshold for memory updates
+            },
+
+            // Confidence scoring
+            confidence: {
+                base: 0.6,
+                explicitRequest: 1.0,
+                naturalExpression: 0.7,
+                bonusForLongContent: 0.1,
+                bonusForExplicitStatement: 0.3,
+                penaltyForUncertainty: 0.2,
+                min: 0.1,
+                max: 1.0
+            },
+
+            // Memory management
+            cleanup: {
+                maxEntries: 100,
+                ttlDays: 365,
+                batchSize: 100,
+                touchMinutes: 60
+            },
+
+            // Performance settings
+            cache: {
+                keywordCacheSize: 1000,
+                statHistorySize: 100
+            },
+
+            // Scoring weights for importance calculation
+            importance: {
+                categoryWeights: {
+                    important: 1.0,
+                    personal: 0.9,
+                    relationships: 0.85,
+                    goals: 0.75,
+                    experiences: 0.65,
+                    preferences: 0.6,
+                    activities: 0.5
+                },
+                bonuses: {
+                    relationshipMilestone: 0.15,
+                    boundaries: 0.15,
+                    strongEmotion: 0.05,
+                    futureReference: 0.05,
+                    longContent: 0.05,
+                    highConfidence: 0.05
+                }
+            },
+
+            // Relevance calculation weights
+            relevance: {
+                contentSimilarity: 0.35,
+                keywordOverlap: 0.25,
+                categoryRelevance: 0.1,
+                recencyBonus: 0.1,
+                confidenceBonus: 0.05,
+                importanceBonus: 0.05,
+                recentDaysThreshold: 30
+            }
+        };
+
         this.memoryCategories = {
             personal: "Personal Information",
             preferences: "Likes & Dislikes",
@@ -200,6 +293,45 @@ class KimiMemorySystem {
                 /请记住(.+)/i
             ]
         };
+
+        // Performance optimization: pre-compile regex patterns
+        this.compiledPatterns = {};
+        this.initializeCompiledPatterns();
+    }
+
+    // Pre-compile all regex patterns for better performance
+    initializeCompiledPatterns() {
+        try {
+            for (const [category, patterns] of Object.entries(this.extractionPatterns)) {
+                this.compiledPatterns[category] = patterns.map(pattern => {
+                    if (pattern instanceof RegExp) {
+                        return pattern; // Already compiled
+                    }
+                    return new RegExp(pattern.source, pattern.flags);
+                });
+            }
+
+            if (window.KIMI_CONFIG?.DEBUG?.MEMORY) {
+                const totalPatterns = Object.values(this.compiledPatterns).reduce((sum, arr) => sum + arr.length, 0);
+                console.log(`🚀 Pre-compiled ${totalPatterns} regex patterns for memory extraction`);
+            }
+        } catch (error) {
+            console.error("Error pre-compiling regex patterns:", error);
+            // Fallback: use original patterns
+            this.compiledPatterns = this.extractionPatterns;
+        }
+    }
+
+    // Utility method to get consistent creation timestamp
+    getCreationTimestamp(memory) {
+        // Prefer createdAt, fallback to timestamp for backward compatibility
+        return memory.createdAt || memory.timestamp || new Date();
+    }
+
+    // Utility method to calculate days since creation
+    getDaysSinceCreation(memory) {
+        const created = new Date(this.getCreationTimestamp(memory)).getTime();
+        return (Date.now() - created) / (1000 * 60 * 60 * 24);
     }
 
     async init() {
@@ -216,11 +348,9 @@ class KimiMemorySystem {
             this.selectedCharacter = await this.db.getSelectedCharacter();
             await this.createMemoryTables();
 
-            // Migrer les IDs incompatibles si nécessaire
-            await this.migrateIncompatibleIDs();
-
-            // Start background migration to populate keywords for existing memories (non-blocking)
-            this.populateKeywordsForAllMemories().catch(e => console.warn("Keyword population failed", e));
+            // Legacy migrations disabled - uncomment if needed for old databases
+            // await this.migrateIncompatibleIDs();
+            // this.populateKeywordsForAllMemories().catch(e => console.warn("Keyword population failed", e));
         } catch (error) {
             console.error("Memory system initialization error:", error);
         }
@@ -238,10 +368,15 @@ class KimiMemorySystem {
     async extractMemoryFromText(userText, kimiResponse = null) {
         if (!this.memoryEnabled || !userText) return [];
 
+        // Ensure selectedCharacter is initialized
+        if (!this.selectedCharacter) {
+            this.selectedCharacter = this.db ? await this.db.getSelectedCharacter() : "kimi";
+        }
+
         const extractedMemories = [];
         const text = userText.toLowerCase();
 
-        console.log("🔍 Memory extraction - Processing text:", userText);
+        // Memory extraction processing (debug info reduced for performance)
 
         // Enhanced extraction with context awareness
         const existingMemories = await this.getAllMemories();
@@ -249,19 +384,20 @@ class KimiMemorySystem {
         // First, check for explicit memory requests
         const explicitRequests = this.detectExplicitMemoryRequests(userText);
         if (explicitRequests.length > 0) {
-            console.log("🎯 Explicit memory requests detected:", explicitRequests);
+            // Explicit memory requests detected
             extractedMemories.push(...explicitRequests);
         }
 
-        // Extract using patterns
-        for (const [category, patterns] of Object.entries(this.extractionPatterns)) {
+        // Extract using pre-compiled patterns for better performance
+        const patternsToUse = this.compiledPatterns || this.extractionPatterns;
+        for (const [category, patterns] of Object.entries(patternsToUse)) {
             for (const pattern of patterns) {
                 const match = text.match(pattern);
                 if (match && match[1]) {
                     const content = match[1].trim();
 
                     // Skip very short or generic content
-                    if (content.length < 2 || this.isGenericContent(content)) {
+                    if (content.length < this.config.minContentLength || this.isGenericContent(content)) {
                         continue;
                     }
 
@@ -274,12 +410,12 @@ class KimiMemorySystem {
                         content: content,
                         sourceText: userText,
                         confidence: this.calculateExtractionConfidence(match, userText),
-                        timestamp: new Date(),
-                        character: this.selectedCharacter,
+                        createdAt: new Date(), // Use createdAt consistently
+                        character: this.selectedCharacter || "kimi", // Fallback protection
                         isUpdate: isUpdate
                     };
 
-                    console.log(`💡 Pattern match for ${category}:`, content);
+                    // Pattern match detected
                     extractedMemories.push(memory);
                 }
             }
@@ -292,14 +428,29 @@ class KimiMemorySystem {
         // Save extracted memories with intelligent deduplication
         const savedMemories = [];
         for (const memory of extractedMemories) {
-            console.log("💾 Saving memory:", memory.content);
-            const saved = await this.addMemory(memory);
-            if (saved) savedMemories.push(saved);
+            try {
+                console.log("💾 Saving memory:", memory.content);
+                const saved = await this.addMemory(memory);
+                if (saved) {
+                    savedMemories.push(saved);
+                } else {
+                    console.warn("⚠️ Memory was not saved (possibly filtered or merged):", memory.content);
+                }
+            } catch (error) {
+                console.error("❌ Failed to save memory:", {
+                    content: memory.content,
+                    category: memory.category,
+                    error: error.message
+                });
+                // Continue processing other memories even if one fails
+            }
         }
 
         if (savedMemories.length > 0) {
-            console.log(`✅ Successfully extracted and saved ${savedMemories.length} memories`);
-        } else {
+            if (window.KIMI_CONFIG?.DEBUG?.MEMORY) {
+                console.log(`✅ Successfully extracted and saved ${savedMemories.length} memories`);
+            }
+        } else if (window.KIMI_CONFIG?.DEBUG?.MEMORY) {
             console.log("📝 No memories extracted from this text");
         }
 
@@ -469,12 +620,12 @@ class KimiMemorySystem {
     // Check if content is too generic to be useful
     isGenericContent(content) {
         const genericWords = ["yes", "no", "ok", "okay", "sure", "thanks", "hello", "hi", "bye"];
-        return genericWords.includes(content.toLowerCase()) || content.length < 2;
+        return genericWords.includes(content.toLowerCase()) || content.length < this.config.minContentLength;
     }
 
     // Calculate confidence based on context and pattern strength
     calculateExtractionConfidence(match, fullText) {
-        let confidence = 0.6; // Base confidence
+        let confidence = this.config.confidence.base; // Base confidence from config
 
         // Boost confidence for explicit statements
         const lower = fullText.toLowerCase();
@@ -496,20 +647,20 @@ class KimiMemorySystem {
             lower.includes("我叫") ||
             lower.includes("我的名字是")
         ) {
-            confidence += 0.3;
+            confidence += this.config.confidence.bonusForExplicitStatement;
         }
 
         // Boost for longer, more specific content
-        if (match[1] && match[1].trim().length > 10) {
-            confidence += 0.1;
+        if (match[1] && match[1].trim().length > this.config.longContentThreshold) {
+            confidence += this.config.confidence.bonusForLongContent;
         }
 
         // Reduce confidence for uncertain language
         if (fullText.includes("maybe") || fullText.includes("perhaps") || fullText.includes("might")) {
-            confidence -= 0.2;
+            confidence -= this.config.confidence.penaltyForUncertainty;
         }
 
-        return Math.min(1.0, Math.max(0.1, confidence));
+        return Math.min(this.config.confidence.max, Math.max(this.config.confidence.min, confidence));
     }
 
     // Generate a short title (2-5 words max) from content for auto-extracted memories
@@ -525,9 +676,9 @@ class KimiMemorySystem {
         if (words.length === 0) return "";
         // Prefer 3 words when available, minimum 2 when possible, maximum 5
         let take;
-        if (words.length >= 3) take = 3;
+        if (words.length >= this.config.titleWordCount.preferred) take = this.config.titleWordCount.preferred;
         else take = words.length; // 1 or 2
-        take = Math.min(5, Math.max(1, take));
+        take = Math.min(this.config.titleWordCount.max, Math.max(this.config.titleWordCount.min, take));
 
         const slice = words.slice(0, take);
         // Capitalize first word for nicer title
@@ -541,7 +692,7 @@ class KimiMemorySystem {
 
         for (const memory of categoryMemories) {
             const similarity = this.calculateSimilarity(memory.content, content);
-            if (similarity > 0.3) {
+            if (similarity > this.config.similarity.update) {
                 // Lower threshold for updates
                 return true;
             }
@@ -598,8 +749,8 @@ class KimiMemorySystem {
                         content: name,
                         sourceText: text,
                         confidence: 0.7,
-                        timestamp: new Date(),
-                        character: this.selectedCharacter
+                        createdAt: new Date(), // Use createdAt consistently
+                        character: this.selectedCharacter || "kimi" // Fallback protection
                     });
                 }
             }
@@ -688,12 +839,11 @@ class KimiMemorySystem {
                           : "",
                 sourceText: memoryData.sourceText || "",
                 confidence: memoryData.confidence || 1.0,
-                timestamp: memoryData.timestamp || now,
-                character: memoryData.character || this.selectedCharacter,
+                createdAt: memoryData.createdAt || memoryData.timestamp || now, // Unified timestamp handling
+                character: memoryData.character || this.selectedCharacter || "kimi", // Fallback protection
                 isActive: true,
                 tags: [...new Set([...(memoryData.tags || []), ...this.deriveMemoryTags(memoryData)])],
                 lastModified: now,
-                createdAt: now,
                 lastAccess: now,
                 accessCount: 0,
                 importance: this.calculateImportance(memoryData)
@@ -702,7 +852,9 @@ class KimiMemorySystem {
             if (this.db.db.memories) {
                 const id = await this.db.db.memories.add(memory);
                 memory.id = id; // Store the auto-generated ID
-                console.log(`Memory added with ID: ${id}`);
+                if (window.KIMI_CONFIG?.DEBUG?.MEMORY) {
+                    console.log(`Memory added with ID: ${id}`);
+                }
             }
 
             // Cleanup old memories if we exceed limit
@@ -714,6 +866,7 @@ class KimiMemorySystem {
             return memory;
         } catch (error) {
             console.error("Error adding memory:", error);
+            return null; // Return null instead of undefined for clearer error handling
         }
     }
 
@@ -782,31 +935,33 @@ class KimiMemorySystem {
         }
     }
 
-    // Determine how to merge two related memories
+    // Simplified memory merge strategy determination
     determineMergeStrategy(existing, newData) {
         const similarity = this.calculateSimilarity(existing.content, newData.content);
-        const newConfidence = newData.confidence || 0.8;
+        const newConfidence = newData.confidence || this.config.confidence.base;
+        const existingConfidence = existing.confidence || this.config.confidence.base;
 
-        // If very similar content but new has higher confidence
-        if (similarity > 0.9 && newConfidence > existing.confidence) {
-            return "boost_confidence";
+        // Very high similarity (>90%) - boost confidence if new is more confident
+        if (similarity > this.config.similarity.veryHigh) {
+            return newConfidence > existingConfidence ? "boost_confidence" : "merge_content";
         }
 
-        // If moderately similar, decide based on specificity and recency
-        if (similarity > 0.7) {
+        // High similarity (>70%) - decide based on content length and specificity
+        if (similarity > this.config.similarity.preferences) {
+            // If new content is significantly longer (50% more), it's likely more detailed
             if (newData.content.length > existing.content.length * 1.5) {
-                return "update_content"; // New is more detailed
-            } else {
-                return "merge_content";
+                return "update_content";
             }
+            // If existing is longer, merge to preserve information
+            return "merge_content";
         }
 
-        // For names, handle as variants
+        // For personal names, handle as variants if they're related
         if (existing.category === "personal" && this.areRelatedNames(existing.content, newData.content)) {
             return "add_variant";
         }
 
-        // Default to merging
+        // Default strategy for moderate similarity
         return "merge_content";
     }
 
@@ -875,8 +1030,9 @@ class KimiMemorySystem {
         }
 
         // Longer details and high confidence
-        if (memoryData.content && memoryData.content.length > 24) importance += 0.05;
-        if (memoryData.confidence && memoryData.confidence > 0.9) importance += 0.05;
+        if (memoryData.content && memoryData.content.length > this.config.longContentThreshold)
+            importance += this.config.importance.bonuses.longContent;
+        if (memoryData.confidence && memoryData.confidence > 0.9) importance += this.config.importance.bonuses.highConfidence;
 
         // Round to two decimals to avoid floating point artifacts
         return Math.min(1.0, Math.round(importance * 100) / 100);
@@ -1010,7 +1166,7 @@ class KimiMemorySystem {
         if (!this.db) return [];
 
         try {
-            character = character || this.selectedCharacter;
+            character = character || this.selectedCharacter || "kimi"; // Unified fallback
 
             if (this.db.db.memories) {
                 const memories = await this.db.db.memories
@@ -1034,13 +1190,14 @@ class KimiMemorySystem {
         if (!this.db) return [];
 
         try {
-            character = character || this.selectedCharacter;
+            character = character || this.selectedCharacter || "kimi";
 
             if (this.db.db.memories) {
+                // Use simple character filter - compatible with all data
                 const memories = await this.db.db.memories
                     .where("character")
                     .equals(character)
-                    .and(m => m.isActive)
+                    .filter(memory => memory.isActive !== false) // Include records without isActive field
                     .reverse()
                     .sortBy("timestamp");
 
@@ -1077,12 +1234,7 @@ class KimiMemorySystem {
                 const contentSimilarity = this.calculateSimilarity(memory.content, memoryData.content);
 
                 // Different thresholds based on category
-                let threshold = 0.8;
-                if (memoryData.category === "personal") {
-                    threshold = 0.6; // Names and personal info can vary more
-                } else if (memoryData.category === "preferences") {
-                    threshold = 0.7; // Preferences can be expressed differently
-                }
+                const threshold = this.config.similarity[memoryData.category] || this.config.similarity.default;
 
                 if (contentSimilarity > threshold) {
                     return memory;
@@ -1171,11 +1323,130 @@ class KimiMemorySystem {
                     .toLowerCase()
                     .replace(/[\p{P}\p{S}]/gu, " ")
                     .split(/\s+/)
-                    .filter(w => w.length > 2 && !(this.isCommonWord && this.isCommonWord(w)))
+                    .filter(w => w.length > 2 && !this.isCommonWordSafe(w))
             )
         ];
     }
 
+    // Safe wrapper for isCommonWord to avoid undefined function errors
+    isCommonWordSafe(word, language = "en") {
+        const cacheKey = `${word.toLowerCase()}_${language}`;
+
+        // Check cache first
+        if (this.keywordCache.has(cacheKey)) {
+            this.keywordCacheHits++;
+            return this.keywordCache.get(cacheKey);
+        }
+
+        // Cache miss - compute the result
+        this.keywordCacheMisses++;
+        let isCommon = false;
+
+        try {
+            isCommon = typeof this.isCommonWord === "function" ? this.isCommonWord(word, language) : false;
+        } catch (error) {
+            console.warn("Error checking common word:", error);
+            isCommon = false;
+        }
+
+        // Add to cache with LRU eviction
+        if (this.keywordCache.size >= this.keywordCacheSize) {
+            // Simple LRU: remove oldest entry (first in Map)
+            const firstKey = this.keywordCache.keys().next().value;
+            this.keywordCache.delete(firstKey);
+        }
+
+        this.keywordCache.set(cacheKey, isCommon);
+        return isCommon;
+    }
+
+    // Get cache statistics for debugging
+    getKeywordCacheStats() {
+        const total = this.keywordCacheHits + this.keywordCacheMisses;
+        return {
+            size: this.keywordCache.size,
+            hits: this.keywordCacheHits,
+            misses: this.keywordCacheMisses,
+            hitRate: total > 0 ? ((this.keywordCacheHits / total) * 100).toFixed(2) + "%" : "0%"
+        };
+    }
+
+    // Get performance statistics for debugging and optimization
+    getPerformanceStats() {
+        const calculateStats = times => {
+            if (times.length === 0) return { avg: 0, max: 0, min: 0, count: 0 };
+            return {
+                avg: Math.round((times.reduce((sum, t) => sum + t, 0) / times.length) * 100) / 100,
+                max: Math.round(Math.max(...times) * 100) / 100,
+                min: Math.round(Math.min(...times) * 100) / 100,
+                count: times.length
+            };
+        };
+
+        return {
+            keywordCache: this.getKeywordCacheStats(),
+            extraction: calculateStats(this.queryStats.extractionTime),
+            addMemory: calculateStats(this.queryStats.addMemoryTime),
+            retrieval: calculateStats(this.queryStats.retrievalTime)
+        };
+    }
+
+    // Performance wrapper for memory extraction
+    async extractMemoryFromTextTimed(userText, kimiResponse = null) {
+        const start = performance.now();
+        const result = await this.extractMemoryFromText(userText, kimiResponse);
+        const duration = performance.now() - start;
+
+        this.queryStats.extractionTime.push(duration);
+        if (this.queryStats.extractionTime.length > 100) {
+            this.queryStats.extractionTime.shift(); // Keep only last 100 measurements
+        }
+
+        if (duration > 100 && window.KIMI_CONFIG?.DEBUG?.MEMORY) {
+            console.warn(`🐌 Slow memory extraction: ${duration.toFixed(2)}ms for text length ${userText?.length || 0}`);
+        }
+
+        return result;
+    }
+
+    // Get current configuration for debugging and monitoring
+    getConfiguration() {
+        return {
+            ...this.config,
+            memoryCategories: this.memoryCategories,
+            runtime: {
+                memoryEnabled: this.memoryEnabled,
+                maxMemoryEntries: this.maxMemoryEntries,
+                selectedCharacter: this.selectedCharacter,
+                keywordCacheSize: this.keywordCache.size,
+                compiledPatternsCount: Object.values(this.compiledPatterns || {}).reduce((sum, arr) => sum + arr.length, 0)
+            }
+        };
+    }
+
+    // Update configuration at runtime (for advanced users)
+    updateConfiguration(configPath, value) {
+        const keys = configPath.split(".");
+        let current = this.config;
+
+        // Navigate to the parent object
+        for (let i = 0; i < keys.length - 1; i++) {
+            if (!current[keys[i]]) current[keys[i]] = {};
+            current = current[keys[i]];
+        }
+
+        // Set the value
+        const lastKey = keys[keys.length - 1];
+        const oldValue = current[lastKey];
+        current[lastKey] = value;
+
+        if (window.KIMI_CONFIG?.DEBUG?.MEMORY) {
+            console.log(`🔧 Configuration updated: ${configPath} = ${value} (was: ${oldValue})`);
+        }
+
+        return { oldValue, newValue: value };
+    }
+
     async cleanupOldMemories() {
         if (!this.db) return;
 
@@ -1189,17 +1460,30 @@ class KimiMemorySystem {
             // Soft-expire memories older than TTL by marking isActive=false
             const now = Date.now();
             const ttlMs = ttlDays * 24 * 60 * 60 * 1000;
+            const expiredMemories = [];
+
             for (const mem of memories) {
-                const created = new Date(mem.timestamp).getTime();
+                const created = new Date(this.getCreationTimestamp(mem)).getTime();
                 if (now - created > ttlMs) {
                     try {
                         await this.updateMemory(mem.id, { isActive: false });
+                        expiredMemories.push(mem.id);
                     } catch (e) {
-                        console.warn("Failed to soft-expire memory", mem.id, e);
+                        console.error(`Memory expiration failed for ID ${mem.id}:`, {
+                            error: e.message,
+                            memoryId: mem.id,
+                            createdAt: this.getCreationTimestamp(mem),
+                            character: mem.character
+                        });
+                        // Continue with other memories even if one fails
                     }
                 }
             }
 
+            if (window.KIMI_CONFIG?.DEBUG?.MEMORY && expiredMemories.length > 0) {
+                console.log(`Successfully expired ${expiredMemories.length} memories:`, expiredMemories);
+            }
+
             // Refresh active memories after TTL purge
             const activeMemories = (await this.getAllMemories()).filter(m => m.isActive);
 
@@ -1210,22 +1494,38 @@ class KimiMemorySystem {
                     const scoreA =
                         (a.importance || 0.5) * -1 +
                         (a.accessCount || 0) * 0.01 +
-                        new Date(a.timestamp).getTime() / (1000 * 60 * 60 * 24);
+                        new Date(this.getCreationTimestamp(a)).getTime() / (1000 * 60 * 60 * 24);
                     const scoreB =
                         (b.importance || 0.5) * -1 +
                         (b.accessCount || 0) * 0.01 +
-                        new Date(b.timestamp).getTime() / (1000 * 60 * 60 * 24);
+                        new Date(this.getCreationTimestamp(b)).getTime() / (1000 * 60 * 60 * 24);
                     return scoreB - scoreA;
                 });
 
                 const toDeactivate = activeMemories.slice(maxEntries);
+                const deactivatedMemories = [];
+                const failedDeactivations = [];
+
                 for (const mem of toDeactivate) {
                     try {
                         await this.updateMemory(mem.id, { isActive: false });
+                        deactivatedMemories.push(mem.id);
                     } catch (e) {
-                        console.warn("Failed to deactivate memory", mem.id, e);
+                        console.error(`Memory deactivation failed for ID ${mem.id}:`, {
+                            error: e.message,
+                            memoryId: mem.id,
+                            importance: mem.importance,
+                            character: mem.character
+                        });
+                        failedDeactivations.push(mem.id);
                     }
                 }
+
+                if (window.KIMI_CONFIG?.DEBUG?.MEMORY) {
+                    console.log(
+                        `Memory cleanup: ${deactivatedMemories.length} deactivated, ${failedDeactivations.length} failed`
+                    );
+                }
             }
         } catch (error) {
             console.error("Error cleaning up old memories:", error);
@@ -1281,7 +1581,7 @@ class KimiMemorySystem {
             let score = memory.importance || 0.5;
 
             // Boost recent memories
-            const daysSinceCreation = (Date.now() - new Date(memory.timestamp)) / (1000 * 60 * 60 * 24);
+            const daysSinceCreation = this.getDaysSinceCreation(memory);
             score += Math.max(0, (7 - daysSinceCreation) / 7) * 0.2; // Recent boost
 
             // Boost frequently accessed memories
@@ -1311,7 +1611,7 @@ class KimiMemorySystem {
         let score = 0;
 
         // Enhanced content similarity with keyword matching
-        score += this.calculateSimilarity(memory.content, context) * 0.35;
+        score += this.calculateSimilarity(memory.content, context) * this.config.relevance.contentSimilarity;
 
         // Keyword overlap boost (derived keywords)
         try {
@@ -1319,7 +1619,7 @@ class KimiMemorySystem {
             const ctxKeys = this.deriveKeywords(context || "");
             const keyOverlap = ctxKeys.filter(k => memKeys.includes(k)).length;
             if (ctxKeys.length > 0) {
-                score += (keyOverlap / ctxKeys.length) * 0.25; // significant boost for keyword overlap
+                score += (keyOverlap / ctxKeys.length) * this.config.relevance.keywordOverlap;
             }
         } catch (e) {
             // fallback to original keyword matching
@@ -1330,22 +1630,24 @@ class KimiMemorySystem {
                 }
             }
             if (contextWords.length > 0) {
-                score += (keywordMatches / contextWords.length) * 0.3;
+                score += (keywordMatches / contextWords.length) * this.config.relevance.keywordOverlap;
             }
         }
 
-        // (legacy keyword matching handled above)
-
         // Category relevance bonus based on context
-        score += this.getCategoryRelevance(memory.category, context) * 0.1;
+        score += this.getCategoryRelevance(memory.category, context) * this.config.relevance.categoryRelevance;
 
         // Recent memories get bonus for current conversation
-        const daysSinceCreation = (Date.now() - new Date(memory.timestamp)) / (1000 * 60 * 60 * 24);
-        score += Math.max(0, (30 - daysSinceCreation) / 30) * 0.1;
+        const daysSinceCreation = this.getDaysSinceCreation(memory);
+        score +=
+            Math.max(
+                0,
+                (this.config.relevance.recentDaysThreshold - daysSinceCreation) / this.config.relevance.recentDaysThreshold
+            ) * this.config.relevance.recencyBonus;
 
         // Confidence and importance boost
-        score += (memory.confidence || 0.5) * 0.05;
-        score += (memory.importance || 0.5) * 0.05;
+        score += (memory.confidence || 0.5) * this.config.relevance.confidenceBonus;
+        score += (memory.importance || 0.5) * this.config.relevance.importanceBonus;
 
         return Math.min(1.0, score);
     }
@@ -1538,30 +1840,56 @@ class KimiMemorySystem {
     // Touch multiple memories to update lastAccess and accessCount
     async _touchMemories(memories, limit = 5) {
         if (!this.db || !Array.isArray(memories) || memories.length === 0) return;
+
         try {
             const top = memories.slice(0, limit);
-            const ops = [];
+            const now = new Date();
+            const minMinutes = window.KIMI_MEMORY_TOUCH_MINUTES || 60;
+            const minTouchInterval = minMinutes * 60 * 1000;
+
+            // Batch collection: gather all updates before executing
+            const batchUpdates = [];
+
             for (const m of top) {
                 try {
                     const id = m.id;
                     const existing = await this.db.db.memories.get(id);
                     if (existing) {
                         const lastAccess = existing.lastAccess ? new Date(existing.lastAccess).getTime() : 0;
-                        const minMinutes = window.KIMI_MEMORY_TOUCH_MINUTES || 60;
-                        const now = Date.now();
-                        if (now - lastAccess > minMinutes * 60 * 1000) {
-                            existing.accessCount = (existing.accessCount || 0) + 1;
-                            existing.lastAccess = new Date();
-                            ops.push(this.db.db.memories.put(existing));
+
+                        // Only touch if enough time has passed
+                        if (now.getTime() - lastAccess > minTouchInterval) {
+                            batchUpdates.push({
+                                key: id,
+                                changes: {
+                                    accessCount: (existing.accessCount || 0) + 1,
+                                    lastAccess: now
+                                }
+                            });
                         }
                     }
                 } catch (e) {
-                    console.warn("Error touching memory", m && m.id, e);
+                    console.warn("Error preparing memory touch batch for", m && m.id, e);
+                }
+            }
+
+            // Execute all updates in a single batch operation
+            if (batchUpdates.length > 0) {
+                if (this.db.db.memories.bulkUpdate) {
+                    // Use bulkUpdate if available (Dexie 3.x+)
+                    await this.db.db.memories.bulkUpdate(batchUpdates);
+                } else {
+                    // Fallback: parallel individual updates (still better than sequential)
+                    const updatePromises = batchUpdates.map(update => this.db.db.memories.update(update.key, update.changes));
+                    await Promise.all(updatePromises);
+                }
+
+                if (window.KIMI_CONFIG?.DEBUG?.MEMORY) {
+                    console.log(`📊 Batch touched ${batchUpdates.length} memories`);
                 }
             }
-            await Promise.all(ops);
         } catch (e) {
-            console.warn("Error in _touchMemories", e);
+            console.warn("Error in _touchMemories batch processing", e);
         }
     }
 
@@ -1654,7 +1982,7 @@ class KimiMemorySystem {
             // Exclude existing summaries to avoid summarizing summaries repeatedly
             const recent = all.filter(
                 m =>
-                    new Date(m.timestamp).getTime() >= cutoff &&
+                    new Date(this.getCreationTimestamp(m)).getTime() >= cutoff &&
                     m.isActive &&
                     m.type !== "summary" &&
                     !(m.tags && m.tags.includes("summary"))
@@ -1688,7 +2016,7 @@ class KimiMemorySystem {
                 sourceText: summaryContent,
                 summaryJson: JSON.stringify(summaryJson),
                 confidence: 0.9,
-                timestamp: new Date(),
+                createdAt: new Date(), // Use createdAt consistently
                 character: this.selectedCharacter,
                 isActive: true,
                 tags: ["summary"]
@@ -1723,7 +2051,7 @@ class KimiMemorySystem {
             // Exclude existing summaries to avoid recursive summarization
             const recent = all.filter(
                 m =>
-                    new Date(m.timestamp).getTime() >= cutoff &&
+                    new Date(this.getCreationTimestamp(m)).getTime() >= cutoff &&
                     m.isActive &&
                     m.type !== "summary" &&
                     !(m.tags && m.tags.includes("summary"))
@@ -1731,7 +2059,7 @@ class KimiMemorySystem {
             if (!recent.length) return null;
 
             // Build aggregate content from readable fields in chronological order
-            recent.sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp));
+            recent.sort((a, b) => new Date(this.getCreationTimestamp(a)) - new Date(this.getCreationTimestamp(b)));
             const texts = recent
                 .map(r => {
                     const raw =
@@ -1962,5 +2290,3 @@ class KimiMemorySystem {
 
 window.KimiMemorySystem = KimiMemorySystem;
 export default KimiMemorySystem;
-
-window.KimiMemorySystem = KimiMemorySystem;

kimi-js/kimi-memory.js

@@ -22,14 +22,12 @@ class KimiMemory {
         }
         try {
             this.selectedCharacter = await this.db.getSelectedCharacter();
-            // Start with lower favorability level - relationships must be built over time
-            this.favorabilityLevel = await this.db.getPreference(`favorabilityLevel_${this.selectedCharacter}`, 50);
 
-            // Load affection trait from personality database with coherent defaults
+            // Load affection trait from personality database with unified defaults
             const charDefAff =
                 (window.KIMI_CHARACTERS && window.KIMI_CHARACTERS[this.selectedCharacter]?.traits?.affection) || null;
-            const genericAff = (window.getTraitDefaults && window.getTraitDefaults().affection) || 55;
-            const defaultAff = typeof charDefAff === "number" ? charDefAff : genericAff;
+            const unifiedDefaults = window.kimiEmotionSystem?.TRAIT_DEFAULTS || { affection: 55 };
+            const defaultAff = typeof charDefAff === "number" ? charDefAff : unifiedDefaults.affection;
             this.affectionTrait = await this.db.getPersonalityTrait("affection", defaultAff, this.selectedCharacter);
 
             this.preferences = {
@@ -53,7 +51,17 @@ class KimiMemory {
 
         try {
             const character = await this.db.getSelectedCharacter();
-            await this.db.saveConversation(userText, kimiResponse, this.favorabilityLevel, new Date(), character);
+
+            // Use global personality average for conversation favorability score
+            let relationshipLevel = 50; // fallback
+            try {
+                const traits = await this.db.getAllPersonalityTraits(character);
+                relationshipLevel = window.getPersonalityAverage ? window.getPersonalityAverage(traits) : 50;
+            } catch (error) {
+                console.warn("Error calculating relationship level for conversation:", error);
+            }
+
+            await this.db.saveConversation(userText, kimiResponse, relationshipLevel, new Date(), character);
 
             // Legacy interactions counter kept for backward compatibility (not shown in UI now)
             let total = await this.db.getPreference(`totalInteractions_${character}`, 0);
@@ -100,7 +108,12 @@ class KimiMemory {
         try {
             this.selectedCharacter = await this.db.getSelectedCharacter();
             // Use unified default that matches KimiEmotionSystem
-            this.affectionTrait = await this.db.getPersonalityTrait("affection", 50, this.selectedCharacter);
+            const unifiedDefaults = window.kimiEmotionSystem?.TRAIT_DEFAULTS || { affection: 55 };
+            this.affectionTrait = await this.db.getPersonalityTrait(
+                "affection",
+                unifiedDefaults.affection,
+                this.selectedCharacter
+            );
             this.updateFavorabilityBar();
         } catch (error) {
             console.error("Error updating affection trait:", error);
@@ -117,13 +130,24 @@ class KimiMemory {
         }
     }
 
-    getGreeting() {
+    async getGreeting() {
         const i18n = window.kimiI18nManager;
 
-        if (this.affectionTrait <= 10) {
+        // Use global personality average instead of just affection trait
+        let relationshipLevel = 50; // fallback
+        try {
+            if (this.db) {
+                const traits = await this.db.getAllPersonalityTraits(this.selectedCharacter);
+                relationshipLevel = window.getPersonalityAverage ? window.getPersonalityAverage(traits) : 50;
+            }
+        } catch (error) {
+            console.warn("Error calculating greeting level:", error);
+        }
+
+        if (relationshipLevel <= 10) {
             return i18n?.t("greeting_low") || "Hello.";
         }
-        if (this.affectionTrait < 40) {
+        if (relationshipLevel < 40) {
             return i18n?.t("greeting_mid") || "Hi. How can I help you?";
         }
         return i18n?.t("greeting_high") || "Hello my love! 💕";

kimi-js/kimi-module.js

@@ -22,23 +22,9 @@ function updateFavorabilityLabel(characterKey) {
     }
 }
 
-// Delegated personality average computation (single source of truth in KimiEmotionSystem)
+// Simplified personality average computation using centralized system
 function computePersonalityAverage(traits) {
-    if (window.kimiEmotionSystem && typeof window.kimiEmotionSystem.calculatePersonalityAverage === "function") {
-        return Number(window.kimiEmotionSystem.calculatePersonalityAverage(traits).toFixed(2));
-    }
-    // Fallback minimal (should rarely occur before emotion system init)
-    const keys = ["affection", "playfulness", "intelligence", "empathy", "humor", "romance"];
-    let sum = 0,
-        count = 0;
-    for (const k of keys) {
-        const v = traits && traits[k];
-        if (typeof v === "number" && isFinite(v)) {
-            sum += Math.max(0, Math.min(100, v));
-            count++;
-        }
-    }
-    return count ? Number((sum / count).toFixed(2)) : 0;
+    return window.getPersonalityAverage ? window.getPersonalityAverage(traits) : 50;
 }
 
 // Update UI elements (bar + percentage text + label) based on overall personality average
@@ -293,10 +279,8 @@ async function analyzeAndReact(text, useAdvancedLLM = true, onStreamToken = null
         const affection = typeof traits.affection === "number" ? traits.affection : 55;
         const characterTraits = window.KIMI_CHARACTERS[selectedCharacter]?.traits || "";
 
-        // Always reflect user's input phase with a listening video (voice or chat)
-        if (kimiVideo && typeof kimiVideo.startListening === "function") {
-            kimiVideo.startListening();
-        }
+        // Only trigger listening videos for voice input, NOT for text chat
+        // Text chat should keep neutral videos until LLM response processing begins
 
         if (typeof window.updatePersonalityTraitsFromEmotion === "function") {
             await window.updatePersonalityTraitsFromEmotion(reaction, sanitizedText);
@@ -341,13 +325,9 @@ async function analyzeAndReact(text, useAdvancedLLM = true, onStreamToken = null
                     if (userAskedDance) {
                         kimiVideo.switchToContext("dancing", "dancing", null, updatedTraits, updatedTraits.affection);
                     } else {
-                        kimiVideo.analyzeAndSelectVideo(
-                            sanitizedText,
-                            response,
-                            { reaction: reaction, intensity: emotionIntensity },
-                            updatedTraits,
-                            updatedTraits.affection
-                        );
+                        // Use emotion analysis from the LLM RESPONSE, not user input
+                        const responseEmotion = window.kimiEmotionSystem?.analyzeEmotionValidated(response) || "positive";
+                        kimiVideo.respondWithEmotion(responseEmotion, updatedTraits, updatedTraits.affection);
                     }
 
                     if (kimiLLM.updatePersonalityFromResponse) {
@@ -528,7 +508,12 @@ function addMessageToChat(sender, text, conversationId = null) {
     messageTimeDiv.appendChild(deleteBtn);
 
     const textDiv = document.createElement("div");
-    textDiv.textContent = text || ""; // Handle empty strings properly
+    // Use formatted text with HTML support (secure formatting)
+    if (text && window.KimiValidationUtils && window.KimiValidationUtils.formatChatText) {
+        textDiv.innerHTML = window.KimiValidationUtils.formatChatText(text);
+    } else {
+        textDiv.textContent = text || ""; // Fallback to plain text
+    }
 
     messageDiv.appendChild(textDiv);
     messageDiv.appendChild(messageTimeDiv);
@@ -539,7 +524,12 @@ function addMessageToChat(sender, text, conversationId = null) {
     // Return an object that allows updating the message content for streaming
     return {
         updateText: newText => {
-            textDiv.textContent = newText;
+            // Use formatted text for streaming updates too
+            if (newText && window.KimiValidationUtils && window.KimiValidationUtils.formatChatText) {
+                textDiv.innerHTML = window.KimiValidationUtils.formatChatText(newText);
+            } else {
+                textDiv.textContent = newText;
+            }
             // Throttle scrolling to prevent visual stuttering during streaming
             if (!textDiv._scrollTimeout) {
                 textDiv._scrollTimeout = setTimeout(() => {
@@ -973,7 +963,9 @@ async function loadAvailableModels() {
 
         // Only log once when models are loaded, not repeated calls
         if (!loadAvailableModels._lastLoadTime || Date.now() - loadAvailableModels._lastLoadTime > 5000) {
-            console.log(`✅ Loaded ${Object.keys(stats.available).length} LLM models`);
+            if (window.KIMI_CONFIG?.DEBUG?.ENABLED) {
+                console.log(`✅ Loaded ${Object.keys(stats.available).length} LLM models`);
+            }
             loadAvailableModels._lastLoadTime = Date.now();
         }
         const createCard = (id, model) => {
@@ -1243,25 +1235,7 @@ async function loadAvailableModels() {
     }
 }
 
-// Debug function for testing models loading
-window.debugLoadModels = async function () {
-    console.log("🔧 Manual debug of loadAvailableModels");
-    console.log("🔧 window.kimiLLM:", window.kimiLLM);
-    console.log("🔧 Models container:", document.getElementById("models-container"));
-
-    if (window.kimiLLM) {
-        try {
-            const stats = await window.kimiLLM.getModelStats();
-            console.log("🔧 Model stats:", stats);
-        } catch (error) {
-            console.error("🔧 Error getting model stats:", error);
-        }
-    }
-
-    if (window.loadAvailableModels) {
-        await window.loadAvailableModels();
-    }
-};
+// Debug utilities removed for production optimization
 
 async function sendMessage() {
     const chatInput = document.getElementById("chat-input");
@@ -1320,7 +1294,10 @@ async function sendMessage() {
             }
 
             try {
-                console.log("🔄 Starting streaming response...");
+                // Start streaming response processing
+                if (window.KIMI_CONFIG?.DEBUG?.ENABLED) {
+                    console.log("🔄 Starting streaming response...");
+                }
                 let emotionDetected = false;
 
                 const response = await analyzeAndReact(message, true, token => {
@@ -1331,7 +1308,10 @@ async function sendMessage() {
                     // Progressive analysis disabled to prevent UI flickering during streaming
                     // All analysis will be done after streaming completes
                 });
-                console.log("✅ Streaming completed, final response length:", streamingResponse.length);
+                // Streaming completed
+                if (window.KIMI_CONFIG?.DEBUG?.ENABLED) {
+                    console.log("✅ Streaming completed, final response length:", streamingResponse.length);
+                }
 
                 // Final processing after streaming completes
                 let finalResponse = streamingResponse || response;
@@ -1968,54 +1948,19 @@ async function syncPersonalityTraits(characterName = null) {
     return updatedTraits;
 }
 
-// Function to validate emotion and context consistency
+// Simplified validation using centralized emotion system
 function validateEmotionContext(emotion) {
-    // Normalize video categories to base emotions before validation
-    const normalized = emotion === "speakingPositive" ? "positive" : emotion === "speakingNegative" ? "negative" : emotion;
-    // Use unified emotion system for validation
-    if (window.kimiEmotionSystem) {
-        return window.kimiEmotionSystem.validateEmotion(normalized);
-    }
-
-    // Fallback validation
-    const validEmotions = [
-        "positive",
-        "negative",
-        "neutral",
-        "dancing",
-        "listening",
-        "romantic",
-        "laughing",
-        "surprise",
-        "confident",
-        "shy",
-        "flirtatious",
-        "kiss",
-        "goodbye",
-        "speakingPositive",
-        "speakingNegative",
-        "speaking"
-    ];
-
-    if (!validEmotions.includes(normalized)) {
-        console.warn(`Invalid emotion detected: ${normalized}, falling back to neutral`);
-        return "neutral";
-    }
-
-    return normalized;
+    return window.kimiEmotionSystem?.validateEmotion(emotion) || "neutral";
 }
 
-// Function to ensure video context consistency
+// Simplified video context consistency check using centralized system
 async function ensureVideoContextConsistency() {
-    if (!window.kimiVideo) return;
+    if (!window.kimiVideo || !window.kimiDB) return;
 
-    const kimiDB = window.kimiDB;
-    if (!kimiDB) return;
-
-    const selectedCharacter = await kimiDB.getSelectedCharacter();
-    const traits = await kimiDB.getAllPersonalityTraits(selectedCharacter);
+    const selectedCharacter = await window.kimiDB.getSelectedCharacter();
+    const traits = await window.kimiDB.getAllPersonalityTraits(selectedCharacter);
 
-    // Validate current video context
+    // Validate current video context using centralized validation
     const currentInfo = window.kimiVideo.getCurrentVideoInfo();
     const validatedEmotion = validateEmotionContext(currentInfo.emotion);
 

kimi-js/kimi-script.js

@@ -83,6 +83,13 @@ document.addEventListener("DOMContentLoaded", async function () {
         }
     } catch (error) {
         console.error("Initialization error:", error);
+        // Log initialization error to error manager
+        if (window.kimiErrorManager) {
+            window.kimiErrorManager.logInitError("KimiApp", error, {
+                selectedCharacter: selectedCharacter,
+                stage: "main_initialization"
+            });
+        }
     }
     // Centralized helpers for API config UI
     const ApiUi = {
@@ -196,6 +203,12 @@ document.addEventListener("DOMContentLoaded", async function () {
             }
         } catch (e) {
             console.warn("Failed to initialize API config UI:", e);
+            // Log UI initialization error
+            if (window.kimiErrorManager) {
+                window.kimiErrorManager.logUIError("ApiConfigUI", e, {
+                    stage: "api_config_initialization"
+                });
+            }
         }
     }
     // Hydrate API config UI from DB after ApiUi is defined and function declared
@@ -520,7 +533,7 @@ document.addEventListener("DOMContentLoaded", async function () {
                 console.error("sendMessage function not available");
             }
         });
-        console.log("Send button event listener attached");
+        console.log("✅ Send button event listener attached");
     } else {
         console.error("Send button not found");
     }
@@ -551,7 +564,7 @@ document.addEventListener("DOMContentLoaded", async function () {
             el.addEventListener("focus", a);
             setTimeout(a, 0);
         })(chatInput);
-        console.log("Chat input event listener attached");
+        console.log("✅ Chat input event listener attached");
     } else {
         console.error("Chat input not found");
     }
@@ -998,7 +1011,7 @@ document.addEventListener("DOMContentLoaded", async function () {
                 safeTraits[key] = v;
             }
             if (window.KIMI_DEBUG_SYNC) {
-                console.log(`🧠 (Batched) Personality updated for ${character}:`, safeTraits);
+                window.KIMI_CONFIG?.debugLog("SYNC", `Personality updated for ${character}:`, safeTraits);
             }
             // Centralize side-effects elsewhere; aggregator remains a coalesced logger only.
         }

kimi-js/kimi-utils.js

@@ -19,6 +19,41 @@ window.KimiValidationUtils = {
         div.textContent = text;
         return div.innerHTML;
     },
+    /**
+     * Format chat text with simple markdown-like syntax (secure)
+     * Supports: **bold**, *italic*, and preserves line breaks
+     * Security: All text is escaped first, then selective formatting is applied
+     */
+    formatChatText(text) {
+        if (!text || typeof text !== "string") return "";
+
+        // First: Escape all HTML to prevent XSS
+        let escaped = this.escapeHtml(text);
+
+        // Optional: Replace em-dash with regular dash if preferred
+        escaped = escaped.replace(/—/g, "-");
+
+        // Second: Apply simple formatting (only on escaped text)
+        // **bold** -> <strong>bold</strong>
+        escaped = escaped.replace(/\*\*(.*?)\*\*/g, "<strong>$1</strong>");
+
+        // *italic* -> <em>italic</em> (but not if already inside **)
+        escaped = escaped.replace(/(?<!\*)\*([^*]+?)\*(?!\*)/g, "<em>$1</em>");
+
+        // Smart paragraph handling: only create <p> for double line breaks or real paragraphs
+        // Split by double line breaks (\n\n) to identify real paragraphs
+        const realParagraphs = escaped.split(/\n\s*\n/).filter(para => para.trim().length > 0);
+
+        if (realParagraphs.length > 1) {
+            // Multiple paragraphs found - wrap each in <p>
+            escaped = realParagraphs.map(p => `<p>${p.trim().replace(/\n/g, " ")}</p>`).join("");
+        } else {
+            // Single paragraph - just convert single \n to spaces (natural text flow)
+            escaped = escaped.replace(/\n/g, " ");
+        }
+
+        return escaped;
+    },
     validateRange(value, key) {
         const bounds = {
             voiceRate: { min: 0.5, max: 2, def: 1.1 },

kimi-js/kimi-videos.js

@@ -60,6 +60,115 @@ class KimiVideoManager {
         this._consecutiveErrorCount = 0;
         // Track per-video load attempts to adapt timeouts & avoid faux échecs
         this._videoAttempts = new Map();
+
+        // Error handling and recovery system
+        this._errorRecoveryAttempts = 0;
+        this._maxRecoveryAttempts = 3;
+        this._lastErrorTime = 0;
+        this._errorThreshold = 5000; // 5 seconds between error recovery attempts
+    }
+
+    // ===== ERROR HANDLING AND RECOVERY SYSTEM =====
+    _handleVideoError(error, videoSrc = null, context = "unknown") {
+        this._consecutiveErrorCount++;
+        this._lastErrorTime = Date.now();
+
+        const errorInfo = {
+            error: error.message || "Unknown video error",
+            videoSrc: videoSrc || "unknown",
+            context,
+            timestamp: Date.now(),
+            consecutiveCount: this._consecutiveErrorCount
+        };
+
+        if (window.KIMI_CONFIG?.DEBUG?.VIDEO) {
+            console.warn("🎬 Video error occurred:", errorInfo);
+        }
+
+        // Track failures for this specific video
+        if (videoSrc) {
+            this._recentFailures.set(videoSrc, Date.now());
+        }
+
+        // Attempt recovery if not too many consecutive errors
+        if (this._consecutiveErrorCount <= this._maxRecoveryAttempts) {
+            this._attemptErrorRecovery(context);
+        } else {
+            console.error("🎬 Too many consecutive video errors, disabling auto-recovery");
+            this._fallbackToSafeState();
+        }
+    }
+
+    _attemptErrorRecovery(context) {
+        console.log("🎬 Attempting video error recovery...");
+
+        // Try to switch to a safe neutral video
+        setTimeout(() => {
+            try {
+                // Choose a different neutral video that hasn't failed recently
+                const neutralVideos = this.videoCategories.neutral || [];
+                const safeVideos = neutralVideos.filter(
+                    video =>
+                        !this._recentFailures.has(video) || Date.now() - this._recentFailures.get(video) > this._failureCooldown
+                );
+
+                if (safeVideos.length > 0) {
+                    const safeVideo = safeVideos[0];
+                    this._resetErrorState();
+                    this.loadAndSwitchVideo(safeVideo, "recovery");
+                    console.log("🎬 Video error recovery successful");
+                } else {
+                    this._fallbackToSafeState();
+                }
+            } catch (recoveryError) {
+                console.error("🎬 Video recovery failed:", recoveryError);
+                this._fallbackToSafeState();
+            }
+        }, 1000); // Small delay before recovery attempt
+    }
+
+    _fallbackToSafeState() {
+        console.log("🎬 Falling back to safe state - pausing video system");
+
+        // Pause both videos to avoid further errors
+        try {
+            this.activeVideo?.pause();
+            this.inactiveVideo?.pause();
+        } catch (e) {
+            // Silent fallback
+        }
+
+        // Clear all pending operations
+        this._pendingSwitches.length = 0;
+        this._stickyContext = null;
+        this._stickyUntil = 0;
+        this.isEmotionVideoPlaying = false;
+
+        // Reset state with long cooldown
+        setTimeout(() => {
+            this._resetErrorState();
+            console.log("🎬 Video system ready for retry");
+        }, 10000);
+    }
+
+    _resetErrorState() {
+        this._consecutiveErrorCount = 0;
+        this._errorRecoveryAttempts = 0;
+
+        // Clean old failure records
+        const now = Date.now();
+        for (const [video, timestamp] of this._recentFailures.entries()) {
+            if (now - timestamp > this._failureCooldown) {
+                this._recentFailures.delete(video);
+            }
+        }
+    }
+
+    _isVideoSafe(videoSrc) {
+        if (!this._recentFailures.has(videoSrc)) return true;
+
+        const lastFailure = this._recentFailures.get(videoSrc);
+        return Date.now() - lastFailure > this._failureCooldown;
     }
 
     //Centralized crossfade transition between two videos.
@@ -177,18 +286,55 @@ class KimiVideoManager {
         console.log("🎬 VideoManager: history summary", summary);
     }
 
-    _priorityWeight(context) {
-        if (context === "speaking" || context === "speakingPositive" || context === "speakingNegative") return 3;
-        if (context === "dancing" || context === "listening") return 2;
-        return 1;
+    _priorityWeight(context, emotion = "neutral") {
+        // Use centralized priority system from emotion system if available
+        if (window.kimiEmotionSystem?.getPriorityWeight) {
+            // Try emotion first (more specific), then context
+            const emotionPriority = window.kimiEmotionSystem.getPriorityWeight(emotion);
+            const contextPriority = window.kimiEmotionSystem.getPriorityWeight(context);
+            return Math.max(emotionPriority, contextPriority);
+        }
+
+        // Legacy fallback priorities if emotion system not available
+        if (context === "dancing") return 10;
+        if (context === "listening") return 7;
+        if (context === "speaking" || context === "speakingPositive" || context === "speakingNegative") return 4;
+        return 3; // Default priority for neutral and other contexts
     }
 
     _enqueuePendingSwitch(req) {
-        // Keep small bounded list; prefer newest higher-priority
-        const maxSize = 5;
-        this._pendingSwitches.push(req);
-        if (this._pendingSwitches.length > maxSize) {
-            this._pendingSwitches = this._pendingSwitches.slice(-maxSize);
+        // Intelligent queue management - limit to 3 for better responsiveness
+        const maxSize = 3;
+
+        // Check if we already have a similar request (same context + emotion)
+        const existingIndex = this._pendingSwitches.findIndex(
+            pending => pending.context === req.context && pending.emotion === req.emotion
+        );
+
+        if (existingIndex !== -1) {
+            // Replace existing similar request with newer one
+            this._pendingSwitches[existingIndex] = req;
+            this._logDebug("Replaced similar pending switch", { context: req.context, emotion: req.emotion });
+        } else {
+            // Add new request
+            this._pendingSwitches.push(req);
+
+            // If exceeded max size, remove oldest lower-priority request
+            if (this._pendingSwitches.length > maxSize) {
+                // Sort by priority weight (lower = remove first) then by age (older = remove first)
+                this._pendingSwitches.sort((a, b) => {
+                    const priorityDiff = (b.priorityWeight || 1) - (a.priorityWeight || 1);
+                    if (priorityDiff !== 0) return priorityDiff;
+                    return a.requestedAt - b.requestedAt; // Older first
+                });
+
+                // Remove the lowest priority, oldest request
+                const removed = this._pendingSwitches.shift();
+                this._logDebug("Removed low-priority pending switch", {
+                    removed: removed.context,
+                    queueSize: this._pendingSwitches.length
+                });
+            }
         }
     }
 
@@ -380,9 +526,7 @@ class KimiVideoManager {
         // Respect sticky context (avoid overrides while dancing is requested/playing)
         if (this._stickyContext === "dancing" && context !== "dancing") {
             const categoryForPriority = this.determineCategory(context, emotion, traits);
-            const priorityWeight = this._priorityWeight(
-                categoryForPriority === "speakingPositive" || categoryForPriority === "speakingNegative" ? "speaking" : context
-            );
+            const priorityWeight = this._priorityWeight(context, emotion);
             if (Date.now() < (this._stickyUntil || 0)) {
                 this._enqueuePendingSwitch({
                     context,
@@ -410,9 +554,7 @@ class KimiVideoManager {
         ) {
             // Queue the request with appropriate priority to be processed after current clip
             const categoryForPriority = this.determineCategory(context, emotion, traits);
-            const priorityWeight = this._priorityWeight(
-                categoryForPriority === "speakingPositive" || categoryForPriority === "speakingNegative" ? "speaking" : context
-            );
+            const priorityWeight = this._priorityWeight(context, emotion);
             this._enqueuePendingSwitch({
                 context,
                 emotion,
@@ -436,7 +578,7 @@ class KimiVideoManager {
             this.currentEmotionContext &&
             this.currentEmotionContext !== emotion
         ) {
-            const priorityWeight = this._priorityWeight("speaking");
+            const priorityWeight = this._priorityWeight(context, emotion);
             this._enqueuePendingSwitch({
                 context,
                 emotion,
@@ -512,6 +654,17 @@ class KimiVideoManager {
             this.lastSwitchTime = Date.now();
             return;
         }
+
+        // ALSO handle speaking contexts even when TTS is not yet flagged as speaking
+        // This ensures immediate response to speaking context requests
+        if (context === "speaking" || context === "speakingPositive" || context === "speakingNegative") {
+            const speakingPath = this.selectOptimalVideo(category, specificVideo, traits, affection, emotion);
+            this.loadAndSwitchVideo(speakingPath, priority);
+            this.currentContext = category;
+            this.currentEmotion = emotion;
+            this.lastSwitchTime = Date.now();
+            return;
+        }
         if (window.voiceManager && window.voiceManager.isListening && context === "listening") {
             const listeningPath = this.selectOptimalVideo(category, specificVideo, traits, affection, emotion);
             const listeningCurrent = this.activeVideo.querySelector("source").getAttribute("src");
@@ -652,11 +805,11 @@ class KimiVideoManager {
         }
     }
 
-    // keep only the augmented determineCategory above (with traits)
+    // Enhanced selectOptimalVideo with safety checks
     selectOptimalVideo(category, specificVideo = null, traits = null, affection = null, emotion = null) {
         const availableVideos = this.videoCategories[category] || this.videoCategories.neutral;
 
-        if (specificVideo && availableVideos.includes(specificVideo)) {
+        if (specificVideo && availableVideos.includes(specificVideo) && this._isVideoSafe(specificVideo)) {
             if (typeof this.updatePlayHistory === "function") this.updatePlayHistory(category, specificVideo);
             this._logSelection(category, specificVideo, availableVideos);
             return specificVideo;
@@ -664,23 +817,34 @@ class KimiVideoManager {
 
         const currentVideoSrc = this.activeVideo.querySelector("source").getAttribute("src");
 
-        // Filter out recently played videos using adaptive history
+        // Filter out recently played videos using adaptive history AND safety checks
         const recentlyPlayed = this.playHistory[category] || [];
-        let candidateVideos = availableVideos.filter(video => video !== currentVideoSrc && !recentlyPlayed.includes(video));
+        let candidateVideos = availableVideos.filter(
+            video => video !== currentVideoSrc && !recentlyPlayed.includes(video) && this._isVideoSafe(video)
+        );
+
+        // If no safe fresh videos, allow recently played but safe videos (not current)
+        if (candidateVideos.length === 0) {
+            candidateVideos = availableVideos.filter(video => video !== currentVideoSrc && this._isVideoSafe(video));
+        }
 
-        // If no fresh videos, allow recently played but not current
+        // If still no safe videos, use any available (excluding current)
         if (candidateVideos.length === 0) {
             candidateVideos = availableVideos.filter(video => video !== currentVideoSrc);
         }
 
-        // Ultimate fallback
+        // Ultimate fallback - use all available
         if (candidateVideos.length === 0) {
             candidateVideos = availableVideos;
         }
 
-        // Ensure we're not falling back to wrong category
+        // Final fallback to neutral category if current category is empty
         if (candidateVideos.length === 0) {
-            candidateVideos = this.videoCategories.neutral;
+            const neutralVideos = this.videoCategories.neutral || [];
+            candidateVideos = neutralVideos.filter(video => this._isVideoSafe(video));
+            if (candidateVideos.length === 0) {
+                candidateVideos = neutralVideos; // Last resort
+            }
         }
 
         // If traits and affection are provided, weight the selection more subtly
@@ -775,46 +939,17 @@ class KimiVideoManager {
         }
     }
 
-    // Ensure determineCategory exists as a class method (used at line ~494 and ~537)
+    // Simplified determineCategory - pure delegation to centralized system
     determineCategory(context, emotion = "neutral", traits = null) {
-        // Get emotion mapping from centralized emotion system
-        const emotionToCategory = window.kimiEmotionSystem?.emotionToVideoCategory || {
-            listening: "listening",
-            positive: "speakingPositive",
-            negative: "speakingNegative",
-            neutral: "neutral",
-            surprise: "speakingPositive",
-            laughing: "speakingPositive",
-            shy: "neutral",
-            confident: "speakingPositive",
-            romantic: "speakingPositive",
-            flirtatious: "speakingPositive",
-            goodbye: "neutral",
-            kiss: "speakingPositive",
-            dancing: "dancing",
-            speaking: "speakingPositive",
-            speakingPositive: "speakingPositive",
-            speakingNegative: "speakingNegative"
-        };
-
-        // Prefer explicit context mapping if provided (e.g., 'listening','dancing')
-        if (emotionToCategory[context]) {
-            return emotionToCategory[context];
-        }
-        // Normalize generic 'speaking' by emotion polarity
-        if (context === "speaking") {
-            if (emotion === "positive") return "speakingPositive";
-            if (emotion === "negative") return "speakingNegative";
-            return "neutral";
-        }
-        // Map by emotion label when possible
-        if (emotionToCategory[emotion]) {
-            return emotionToCategory[emotion];
+        // Use centralized emotion system exclusively for consistency
+        if (window.kimiEmotionSystem?.getVideoCategory) {
+            return window.kimiEmotionSystem.getVideoCategory(context || emotion, traits);
         }
-        return "neutral";
-    }
 
-    // SPECIALIZED METHODS FOR EACH CONTEXT
+        // Minimal fallback only if emotion system completely unavailable
+        console.warn("KimiEmotionSystem not available - using minimal fallback");
+        return "neutral";
+    } // SPECIALIZED METHODS FOR EACH CONTEXT
     async startListening(traits = null, affection = null) {
         // If already listening and playing, avoid redundant switch
         if (this.currentContext === "listening" && !this.activeVideo.paused && !this.activeVideo.ended) {
@@ -1073,7 +1208,10 @@ class KimiVideoManager {
             }
         }
 
-        console.log(`Auto-transition scheduled in ${duration / 1000}s (${this.currentContext} → neutral)`);
+        // Auto-transition timing
+        if (window.KIMI_CONFIG?.DEBUG?.VIDEO) {
+            console.log(`Auto-transition scheduled in ${duration / 1000}s (${this.currentContext} → neutral)`);
+        }
         this.autoTransitionTimer = setTimeout(() => {
             if (this.currentContext !== "neutral" && this.currentContext !== "listening") {
                 if (!this._processPendingSwitches()) {
@@ -1139,7 +1277,10 @@ class KimiVideoManager {
         }
         // Only log high priority or error cases to reduce noise
         if (priority === "speaking" || priority === "high") {
-            console.log(`🎬 Loading video: ${videoSrc} (priority: ${priority})`);
+            // Video loading with priority
+            if (window.KIMI_CONFIG?.DEBUG?.VIDEO) {
+                console.log(`🎬 Loading video: ${videoSrc} (priority: ${priority})`);
+            }
         }
 
         // Si une vidéo haute priorité arrive, on peut interrompre le chargement en cours
@@ -1396,7 +1537,9 @@ class KimiVideoManager {
                         try {
                             const src = this.activeVideo?.querySelector("source")?.getAttribute("src");
                             const info = { context: this.currentContext, emotion: this.currentEmotion };
-                            console.log("🎬 VideoManager: Now playing:", src, info);
+                            if (this._debug) {
+                                console.log("🎬 VideoManager: Now playing:", src, info);
+                            }
                             // Recompute autoTransitionDuration from actual duration if available (C)
                             try {
                                 const d = this.activeVideo.duration;
@@ -1549,25 +1692,72 @@ class KimiVideoManager {
     }
 
     // METHODS TO ANALYZE EMOTIONS FROM TEXT
-    // CLEANUP
+    // CLEANUP - Enhanced memory management
     destroy() {
+        // Clear all timers
         clearTimeout(this.autoTransitionTimer);
+        clearTimeout(this._warmupTimer);
+        clearTimeout(this._listeningGraceTimer);
+        clearTimeout(this._pendingSpeakSwitch);
+
         this.autoTransitionTimer = null;
+        this._warmupTimer = null;
+        this._listeningGraceTimer = null;
+        this._pendingSpeakSwitch = null;
+
+        // Remove all event listeners
         if (this._visibilityHandler) {
             document.removeEventListener("visibilitychange", this._visibilityHandler);
             this._visibilityHandler = null;
         }
+
+        if (this._firstInteractionHandler) {
+            window.removeEventListener("click", this._firstInteractionHandler);
+            window.removeEventListener("keydown", this._firstInteractionHandler);
+            this._firstInteractionHandler = null;
+        }
+
+        // Clean up video loading handlers
+        this._cleanupLoadingHandlers();
+
+        // Clear global ended handler
+        if (this._globalEndedHandler) {
+            this.activeVideo?.removeEventListener("ended", this._globalEndedHandler);
+            this.inactiveVideo?.removeEventListener("ended", this._globalEndedHandler);
+            this._globalEndedHandler = null;
+        }
+
+        // Clear caches and queues
+        this._prefetchCache.clear();
+        this._prefetchInFlight.clear();
+        this._pendingSwitches.length = 0;
+        this._videoAttempts.clear();
+        this._recentFailures.clear();
+
+        // Reset history to prevent memory accumulation
+        this.playHistory = {};
+        this.emotionHistory.length = 0;
+
+        // Reset state flags
+        this._stickyContext = null;
+        this._stickyUntil = 0;
+        this.isEmotionVideoPlaying = false;
+        this.currentEmotionContext = null;
+        this._neutralLock = false;
     }
 
-    // Utilitaire pour déterminer la catégorie vidéo selon la moyenne des traits
+    // Simplified mood setting using centralized emotion system
     setMoodByPersonality(traits) {
         if (this._stickyContext === "dancing" || this.currentContext === "dancing") return;
-        const category = window.getMoodCategoryFromPersonality ? window.getMoodCategoryFromPersonality(traits) : "neutral";
-        // Normalize emotion so validation uses base emotion labels
+
+        // Use centralized mood calculation from emotion system
+        const category = window.kimiEmotionSystem?.getMoodCategoryFromPersonality(traits) || "neutral";
+
+        // Normalize emotion for consistent validation
         let emotion = category;
         if (category === "speakingPositive") emotion = "positive";
         else if (category === "speakingNegative") emotion = "negative";
-        // For other categories (neutral, listening, dancing) emotion can equal category
+
         this.switchToContext(category, emotion, null, traits, traits.affection);
     }
 

kimi-js/kimi-voices.js

@@ -70,16 +70,22 @@ class KimiVoiceManager {
             this.transcriptText = document.getElementById("transcript");
 
             if (!this.micButton) {
-                console.warn("Microphone button not found in DOM!");
+                if (window.KIMI_CONFIG?.DEBUG?.VOICE) {
+                    console.warn("Microphone button not found in DOM!");
+                }
                 return false;
             }
 
             // Check transcript elements (non-critical, just warn)
             if (!this.transcriptContainer) {
-                console.warn("Transcript container not found in DOM - transcript feature will be disabled");
+                if (window.KIMI_CONFIG?.DEBUG?.VOICE) {
+                    console.warn("Transcript container not found in DOM - transcript feature will be disabled");
+                }
             }
             if (!this.transcriptText) {
-                console.warn("Transcript text element not found in DOM - transcript feature will be disabled");
+                if (window.KIMI_CONFIG?.DEBUG?.VOICE) {
+                    console.warn("Transcript text element not found in DOM - transcript feature will be disabled");
+                }
             }
 
             // Initialize voice synthesis
@@ -167,13 +173,17 @@ class KimiVoiceManager {
         try {
             // Check if running on file:// protocol
             if (window.location.protocol === "file:") {
-                console.log("🎤 Running on file:// protocol - microphone permissions will be requested each time");
+                if (window.KIMI_CONFIG?.DEBUG?.VOICE) {
+                    console.log("🎤 Running on file:// protocol - microphone permissions will be requested each time");
+                }
                 this.micPermissionGranted = false;
                 return;
             }
 
             if (!navigator.permissions) {
-                console.log("🎤 Permissions API not available");
+                if (window.KIMI_CONFIG?.DEBUG?.VOICE) {
+                    console.log("🎤 Permissions API not available");
+                }
                 this.micPermissionGranted = false; // Set default state
                 return;
             }
@@ -316,10 +326,10 @@ class KimiVoiceManager {
             );
         });
 
-        // Debug: Check what we actually found
-        if (femaleVoice) {
+        // Debug: Voice analysis (debug mode only)
+        if (window.KIMI_DEBUG_VOICE) {
             console.log(`🎤 Female voice found: "${femaleVoice.name}" (${femaleVoice.lang})`);
-        } else {
+        } else if (window.KIMI_DEBUG_VOICE) {
             console.log(
                 `🎤 No female voice found, using first available: "${filteredVoices[0]?.name}" (${filteredVoices[0]?.lang})`
             );
@@ -542,23 +552,23 @@ class KimiVoiceManager {
 
     // ===== CHAT MESSAGE UTILITIES =====
     handleChatMessage(userMessage, kimiResponse) {
-        const chatContainer = document.getElementById("chat-container");
-        const chatMessages = document.getElementById("chat-messages");
-
-        if (!chatContainer || !chatContainer.classList.contains("visible") || !chatMessages) {
-            return;
-        }
-
+        // Always save to chat history, regardless of chat visibility
         const addMessageToChat = window.addMessageToChat || (typeof addMessageToChat !== "undefined" ? addMessageToChat : null);
 
         if (addMessageToChat) {
+            // Save messages to history
             addMessageToChat("user", userMessage);
             addMessageToChat(this.selectedCharacter.toLowerCase(), kimiResponse);
         } else {
-            // Fallback manual message creation
-            this.createChatMessage(chatMessages, "user", userMessage);
-            this.createChatMessage(chatMessages, this.selectedCharacter.toLowerCase(), kimiResponse);
-            chatMessages.scrollTop = chatMessages.scrollHeight;
+            // Fallback: only add to visible chat if available
+            const chatContainer = document.getElementById("chat-container");
+            const chatMessages = document.getElementById("chat-messages");
+
+            if (chatContainer && chatContainer.classList.contains("visible") && chatMessages) {
+                this.createChatMessage(chatMessages, "user", userMessage);
+                this.createChatMessage(chatMessages, this.selectedCharacter.toLowerCase(), kimiResponse);
+                chatMessages.scrollTop = chatMessages.scrollHeight;
+            }
         }
     }
 
@@ -644,12 +654,38 @@ class KimiVoiceManager {
 
         // Get volume using centralized utility
         utterance.volume = this.getVoicePreference("volume", options);
-        const emotionFromText = this.analyzeTextEmotion(text);
-        if (window.kimiVideo && emotionFromText !== "neutral") {
-            requestAnimationFrame(() => {
-                window.kimiVideo.respondWithEmotion(emotionFromText);
+
+        // Use centralized emotion system for consistency
+        const emotionFromText = window.kimiEmotionSystem?.analyzeEmotionValidated(text) || "neutral";
+
+        // PRE-PREPARE speaking animation before TTS starts
+        if (window.kimiVideo) {
+            // Always prepare a speaking context based on detected emotion
+            requestAnimationFrame(async () => {
+                try {
+                    const traits = await this.db?.getAllPersonalityTraits(
+                        window.kimiMemory?.selectedCharacter || (await this.db.getSelectedCharacter())
+                    );
+                    const affection = traits ? traits.affection : 50;
+
+                    // Choose the appropriate speaking context
+                    if (emotionFromText === "negative") {
+                        window.kimiVideo.switchToContext("speakingNegative", "negative", null, traits || {}, affection);
+                    } else if (emotionFromText === "neutral") {
+                        // Even neutral text should use speaking context during TTS
+                        window.kimiVideo.switchToContext("speakingPositive", "neutral", null, traits || {}, affection);
+                    } else {
+                        // For positive and specific emotions
+                        const videoCategory =
+                            window.kimiEmotionSystem?.getVideoCategory(emotionFromText, traits) || "speakingPositive";
+                        window.kimiVideo.switchToContext(videoCategory, emotionFromText, null, traits || {}, affection);
+                    }
+                } catch (e) {
+                    console.warn("Failed to prepare speaking animation:", e);
+                }
             });
         }
+
         if (typeof window.updatePersonalityTraitsFromEmotion === "function") {
             window.updatePersonalityTraitsFromEmotion(emotionFromText, text);
         }
@@ -657,24 +693,30 @@ class KimiVoiceManager {
 
         utterance.onstart = async () => {
             this.isSpeaking = true;
-            // Note: transcript visibility is already handled by showResponseWithPerfectTiming
-            // This ensures the transcript stays visible while AI is speaking
 
-            // Ensure a speaking animation plays (avoid frozen neutral frame during TTS)
+            // IMMEDIATELY switch to appropriate speaking animation when TTS starts
             try {
-                if (window.kimiVideo && window.kimiVideo.getCurrentVideoInfo) {
-                    const info = window.kimiVideo.getCurrentVideoInfo();
-                    if (info && !(info.context && info.context.startsWith("speaking"))) {
-                        // Use positive speaking as neutral fallback
-                        const traits = await this.db?.getAllPersonalityTraits(
-                            window.kimiMemory?.selectedCharacter || (await this.db.getSelectedCharacter())
-                        );
-                        const affection = traits ? traits.affection : 50;
-                        window.kimiVideo.switchToContext("speakingPositive", "positive", null, traits || {}, affection);
+                if (window.kimiVideo) {
+                    const traits = await this.db?.getAllPersonalityTraits(
+                        window.kimiMemory?.selectedCharacter || (await this.db.getSelectedCharacter())
+                    );
+                    const affection = traits ? traits.affection : 50;
+
+                    // Choose speaking context based on the detected emotion using centralized logic
+                    if (emotionFromText === "negative") {
+                        window.kimiVideo.switchToContext("speakingNegative", "negative", null, traits || {}, affection);
+                    } else if (emotionFromText === "neutral") {
+                        // Even for neutral speech, use speaking context during TTS
+                        window.kimiVideo.switchToContext("speakingPositive", "neutral", null, traits || {}, affection);
+                    } else {
+                        // For positive and specific emotions, use appropriate speaking context
+                        const videoCategory =
+                            window.kimiEmotionSystem?.getVideoCategory(emotionFromText, traits) || "speakingPositive";
+                        window.kimiVideo.switchToContext(videoCategory, emotionFromText, null, traits || {}, affection);
                     }
                 }
             } catch (e) {
-                // Silent fallback
+                console.warn("Failed to switch to speaking context:", e);
             }
         };
 
@@ -684,24 +726,35 @@ class KimiVoiceManager {
             this.updateTranscriptVisibility(false);
             // Clear any pending hide timeout
             this.clearTranscriptTimeout();
+
+            // IMMEDIATELY return to neutral when TTS ends
             if (window.kimiVideo) {
-                // Do not force neutral if an emotion clip is still playing (speaking/dancing)
                 try {
                     const info = window.kimiVideo.getCurrentVideoInfo ? window.kimiVideo.getCurrentVideoInfo() : null;
-                    const isEmotionClip =
-                        info &&
-                        (info.context === "speakingPositive" ||
-                            info.context === "speakingNegative" ||
-                            info.context === "dancing");
-                    if (!isEmotionClip) {
-                        requestAnimationFrame(() => {
-                            window.kimiVideo.returnToNeutral();
-                        });
+
+                    // Only return to neutral if currently in a speaking context
+                    if (info && (info.context === "speakingPositive" || info.context === "speakingNegative")) {
+                        // Use async pattern to get traits for neutral transition
+                        (async () => {
+                            try {
+                                const traits = await this.db?.getAllPersonalityTraits(
+                                    window.kimiMemory?.selectedCharacter || (await this.db.getSelectedCharacter())
+                                );
+                                window.kimiVideo.switchToContext(
+                                    "neutral",
+                                    "neutral",
+                                    null,
+                                    traits || {},
+                                    traits?.affection || 50
+                                );
+                            } catch (e) {
+                                // Fallback without traits
+                                window.kimiVideo.switchToContext("neutral", "neutral", null, {}, 50);
+                            }
+                        })();
                     }
-                } catch (_) {
-                    requestAnimationFrame(() => {
-                        window.kimiVideo.returnToNeutral();
-                    });
+                } catch (e) {
+                    console.warn("Failed to return to neutral after TTS:", e);
                 }
             }
         };
@@ -909,6 +962,9 @@ class KimiVoiceManager {
             }
             if (final_transcript && this.onSpeechAnalysis) {
                 try {
+                    // Show final user message in transcript before processing
+                    await this.showUserMessage(`You: ${final_transcript}`, 2000);
+
                     // Auto-stop after silence timeout following final transcript
                     setTimeout(() => {
                         this.stopListening();
@@ -1216,46 +1272,6 @@ class KimiVoiceManager {
         this.onSpeechAnalysis = callback;
     }
 
-    analyzeTextEmotion(text) {
-        // Use unified emotion system
-        if (window.kimiAnalyzeEmotion) {
-            const emotion = window.kimiAnalyzeEmotion(text, "auto");
-            return this._modulateEmotionByPersonality(emotion);
-        }
-        return "neutral";
-    } // Helper to modulate emotion based on personality traits
-    _modulateEmotionByPersonality(emotion) {
-        try {
-            // Obtain full traits if possible for a more robust modulation
-            let avg = 50;
-            if (window.kimiEmotionSystem && window.kimiEmotionSystem.db) {
-                // Attempt synchronous-like cache via memory first
-                const traits = {
-                    affection: this.memory?.affectionTrait,
-                    playfulness: this.memory?.playfulnessTrait,
-                    intelligence: this.memory?.intelligenceTrait,
-                    empathy: this.memory?.empathyTrait,
-                    humor: this.memory?.humorTrait,
-                    romance: this.memory?.romanceTrait
-                };
-                // If at least affection present, compute average using emotion system helper
-                if (typeof traits.affection === "number") {
-                    avg = window.kimiEmotionSystem.calculatePersonalityAverage(traits);
-                }
-            } else if (this.memory && typeof this.memory.affectionTrait === "number") {
-                avg = this.memory.affectionTrait; // fallback
-            }
-
-            // Weighted interpretation: very low affection still softens positive expression
-            // If overall avg low, dampen by shifting to 'shy'.
-            if (avg <= 20 && emotion !== "neutral") return "shy";
-            if (avg <= 40 && emotion === "positive") return "shy";
-            return emotion;
-        } catch (e) {
-            return emotion;
-        }
-    }
-
     async testVoice() {
         const testMessages = [
             window.kimiI18nManager?.t("test_voice_message_1") || "Hello my beloved! 💕",