Upload 34 files

CHANGELOG.md

@@ -1,5 +1,40 @@
 # Virtual Kimi App Changelog
 
+# [1.1.4] - 2025-09-01
+
+### Added
+
+- Added two persistent traits: `trust` and `intimacy`.
+- Added an ephemeral relational state `warmth`. It decays over time and can be raised. Events: `relationship:trustChanged`, `relationship:intimacyChanged`, `relationship:warmthChanged`.
+- Auto-store short-term relationship memories on strong love declarations (`relationship:affirmation`, 6h cooldown).
+- Added EN/FR keyword lists for `trust`, `intimacy`, and `boundary` to drive conversation-based changes.
+
+### Improvements
+
+- Conversation drift now covers `trust`, `intimacy`, and `boundary`.
+- Boundary changes update trust, empathy, and intimacy with scaled effects.
+- `warmth` now affects speaking video selection: high warmth favors positive clips and suppresses negative ones.
+- Treats affectionate profanity (tender words mixed with mild swears) as romantic: small, safe boosts to affection, romance, trust/intimacy, plus a warmth pulse.
+- Words like "chaos" or "rebelle" raise playfulness and give a mild warmth boost.
+- Memory scoring: relationship/boundary/stage memories get higher relevance, influenced by current warmth.
+- Warmth amplification runs after base trait changes to scale final affection/romance/trust/intimacy values.
+
+### Safeguards
+
+- Limits per-message relational changes to avoid large spikes (soft scaling then hard cap).
+- Dampens repeated keyword hits (sqrt aggregation and per-word caps) to reduce farming.
+
+### Technical
+
+- Added configurable `WARMTH_CFG` for decay and amplification.
+- Centralized special-case handling to avoid double-counting (affectionate profanity, chaotic lexicon, romantic pulse).
+- Integrates with existing persistence smoothing and drift tracking; avoids duplicate writes.
+
+### Notes
+
+- `boundary` is currently stored as a trait. It may become a meta-signal in a future update.
+- Anti-spam cooldowns for repeated romantic bursts are planned but not yet implemented.
+
 # [1.1.3] - 2025-09-01
 
 ### Bug Fixes

index.html

@@ -140,6 +140,9 @@
                 <button class="mic-button" id="mic-button" aria-label="Start Listening">
                     <i class="fas fa-microphone"></i>
                 </button>
+                <span id="asr-lang-badge"
+                    style="display:none;align-self:center;font-size:11px;padding:2px 6px;border-radius:12px;background:#b34747;color:#fff;font-weight:600"
+                    title="ASR fallback language differs from UI language">ASR</span>
                 <button class="control-button-unified" id="settings-button" aria-label="Settings">
                     <i class="fas fa-cog"></i>
                 </button>
@@ -1086,7 +1089,10 @@
     </div>
 
     <script src="dexie.min.js"></script>
-    <script src="kimi-locale/i18n.js" defer></script>
+    <script src="kimi-locale/i18n.js"></script>
+    <script type="module" src="kimi-js/kimi-event-bus.js"></script>
+    <script type="module" src="kimi-js/kimi-emotion-config.js"></script>
+    <script type="module" src="kimi-js/kimi-trait-sim.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>

kimi-js/kimi-constants.js

@@ -111,7 +111,21 @@ window.KIMI_CONTEXT_KEYWORDS = {
         laughing: ["haha", "mdr", "rire", "drôle", "hilarant", "mort de rire", "ptdr", "rigole", "sourit", "tu plaisantes"],
         shy: ["timide", "gêné", "rougir", "honteux", "intimidé", "mal à l’aise", "réservé", "introverti", "timidité"],
         confident: ["confiance", "fier", "sûr", "fort", "déterminé", "assuré", "audacieux", "leader", "sans peur", "affirmé"],
-        romantic: ["amour", "romantique", "tendre", "câlin", "bisou", "mon cœur", "chéri", "ma belle", "passionné", "adoré"],
+        romantic: [
+            "amour",
+            "romantique",
+            "tendre",
+            "câlin",
+            "bisou",
+            "mon cœur",
+            "chéri",
+            "ma belle",
+            "ma femme",
+            "merveilleuse",
+            "merveilleux",
+            "passionné",
+            "adoré"
+        ],
         flirtatious: [
             "flirt",
             "taquin",
@@ -213,7 +227,19 @@ window.KIMI_CONTEXT_KEYWORDS = {
 
 window.KIMI_CONTEXT_POSITIVE = {
     en: ["happy", "joy", "great", "awesome", "perfect", "excellent", "magnificent", "lovely", "nice"],
-    fr: ["heureux", "joie", "génial", "parfait", "excellent", "magnifique", "super", "chouette"],
+    fr: [
+        "heureux",
+        "joie",
+        "génial",
+        "parfait",
+        "excellent",
+        "magnifique",
+        "super",
+        "chouette",
+        "formidable",
+        "merveilleuse",
+        "merveilleux"
+    ],
     es: ["feliz", "alegría", "genial", "perfecto", "excelente", "magnífico", "estupendo", "maravilloso"],
     de: ["glücklich", "freude", "toll", "perfekt", "ausgezeichnet", "großartig", "wunderbar", "herrlich"],
     it: ["felice", "gioia", "fantastico", "perfetto", "eccellente", "magnifico", "meraviglioso", "ottimo"],
@@ -372,6 +398,18 @@ window.KIMI_PERSONALITY_KEYWORDS = {
         empathy: {
             positive: ["listen", "understand", "empathy", "support", "help", "comfort", "compassion", "caring", "kindness"],
             negative: ["indifferent", "cold", "selfish", "ignore", "despise", "hostile", "uncaring"]
+        },
+        trust: {
+            positive: ["trust", "honest", "truth", "loyal", "loyalty", "reliable", "dependable", "safe"],
+            negative: ["lie", "lying", "betray", "betrayal", "cheat", "cheating", "unfaithful", "dishonest"]
+        },
+        intimacy: {
+            positive: ["intimate", "close", "deep", "vulnerable", "tender", "touch", "caress", "cuddle"],
+            negative: ["distant", "cold", "closed", "blocked", "awkward", "uncomfortable"]
+        },
+        boundary: {
+            positive: ["consent", "respect", "limit", "safe word", "ok with", "are you fine", "are you okay"],
+            negative: ["force", "coerce", "push you", "ignore your no", "against your will"]
         }
     },
     fr: {
@@ -410,7 +448,20 @@ window.KIMI_PERSONALITY_KEYWORDS = {
             ]
         },
         romance: {
-            positive: ["câlin", "amour", "romantique", "bisou", "tendresse", "passion", "séduisant", "charmant", "adorable"],
+            positive: [
+                "câlin",
+                "amour",
+                "romantique",
+                "bisou",
+                "tendresse",
+                "passion",
+                "séduisant",
+                "charmant",
+                "adorable",
+                "merveilleuse",
+                "merveilleux",
+                "ma femme"
+            ],
             negative: [
                 "froid",
                 "froide",
@@ -435,7 +486,10 @@ window.KIMI_PERSONALITY_KEYWORDS = {
                 "câlin",
                 "aimer",
                 "adorer",
-                "adorable"
+                "adorable",
+                "merveilleuse",
+                "merveilleux",
+                "ma femme"
             ],
             negative: [
                 "méchant",
@@ -453,8 +507,14 @@ window.KIMI_PERSONALITY_KEYWORDS = {
                 "idiote",
                 "stupide",
                 "con",
+                "conne",
                 "connard",
-                "salope"
+                "connasse",
+                "connasses",
+                "salope",
+                "pute",
+                "putain",
+                "poufiasse"
             ]
         },
         playfulness: {
@@ -485,6 +545,18 @@ window.KIMI_PERSONALITY_KEYWORDS = {
                 "bienveillance"
             ],
             negative: ["indifférent", "indifférente", "froid", "froide", "égoïste", "ignorer", "mépriser", "dénigrer", "hostile"]
+        },
+        trust: {
+            positive: ["confiance", "honnête", "fidèle", "fiable", "loyal", "sincère", "sécurité"],
+            negative: ["mensonge", "menti", "trahi", "trahison", "tromper", "infidèle", "malhonnête"]
+        },
+        intimacy: {
+            positive: ["intime", "proche", "profond", "vulnérable", "tendre", "toucher", "caresse", "câlin"],
+            negative: ["distant", "froide", "fermé", "bloqué", "mal à l'aise"]
+        },
+        boundary: {
+            positive: ["consentement", "respect", "limite", "d'accord", "ok pour", "ça te va"],
+            negative: ["forcer", "te pousser", "ignorer ton non", "contre ta volonté"]
         }
     },
     es: {

kimi-js/kimi-emotion-config.js

@@ -0,0 +1,31 @@
+// External emotion & personality tuning overrides
+// Can be edited or replaced without touching core system.
+(function () {
+    // Load order note:
+    // Include this file BEFORE modules that use KimiEmotionSystem so overrides apply on first use.
+    // Example (in index.html): event-bus -> emotion-config -> other kimi-*.js.
+    window.KIMI_EMOTION_CONFIG = {
+        moodThresholds: { positive: 80, neutralHigh: 55, neutralLow: 35, negative: 15 },
+        // Optional scaling multipliers per trait for emotion deltas (post base map, pre adjustUp/Down)
+        traitScalar: { affection: 1, romance: 1, empathy: 1, playfulness: 1, humor: 1, intelligence: 1 },
+        // Optional emotion specific multipliers
+        emotionScalar: {
+            positive: 1,
+            negative: 1,
+            romantic: 1,
+            flirting: 1,
+            laughing: 1,
+            dancing: 1,
+            surprise: 1,
+            shy: 1,
+            confident: 1,
+            listening: 1,
+            kiss: 1,
+            goodbye: 1
+        },
+        // Hook to modify final computed updatedTraits before persistence
+        finalize: function (traits) {
+            return traits;
+        }
+    };
+})();

kimi-js/kimi-emotion-system.js

@@ -9,18 +9,20 @@ class KimiEmotionSystem {
          *    - Each delta passes through adjustUp / adjustDown with global + per-trait multipliers
          *      (window.KIMI_TRAIT_ADJUSTMENT) for consistent scaling.
          * 2. Content keyword analysis (_analyzeTextContent) may override interim trait values (explicit matches).
-         * 3. Cross-trait modifiers (_applyCrossTraitModifiers) apply synergy / balancing rules (e.g. high empathy boosts affection, high romance stabilizes affection, intelligence supports empathy/humor).
+         * 3. Cross-trait modifiers (_applyCrossTraitModifiers) apply ALL synergy / balancing rules (single location to avoid double application).
          * 4. Conversation-based drift (updatePersonalityFromConversation) uses TRAIT_KEYWORD_MODEL:
          *      - Counts positive/negative keyword hits (user weighted 1.0, model weighted 0.5).
          *      - Computes rawDelta = posHits*posFactor - negHits*negFactor.
          *      - Applies sustained negativity amplification after streakPenaltyAfter.
          *      - Clamps magnitude to maxStep per trait, then applies directly with bounds [0,100].
          * 5. Persistence: _preparePersistTrait decides threshold & smoothing before batch write.
-         * 6. Global personality average (UI) = mean of six core traits (affection included).
+         * 6. Global personality average (UI) = mean of six core traits. This class is the single source of truth; external helpers now delegate.
          * NOTE: Affection is fully independent (no derived average). All adjustments centralized here to avoid duplication.
          */
         this.db = database;
         this.negativeStreaks = {};
+        // Accumulated micro-changes not yet persisted (trait -> float)
+        this._pendingDrift = {};
 
         // Unified emotion mappings
         this.EMOTIONS = {
@@ -66,25 +68,29 @@ class KimiEmotionSystem {
             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)
+            romance: 50, // Neutral romance baseline (earned over time)
+            trust: 50, // Trust starts neutral
+            intimacy: 45 // Intimacy builds slower than trust/romance
         };
 
         // Central emotion -> trait base deltas (pre global multipliers & gainCfg scaling)
         // Positive numbers increase trait, negative decrease.
         // Keep values small; final effect passes through adjustUp/adjustDown and global multipliers.
+        // Rebalanced: keep relative ordering but narrow spread to avoid runaway traits.
+        // Target typical per-event magnitude range ~0.1 - 0.5.
         this.EMOTION_TRAIT_EFFECTS = {
-            positive: { affection: 0.45, empathy: 0.2, playfulness: 0.25, humor: 0.25 },
-            negative: { affection: -0.7, empathy: 0.3 },
-            romantic: { romance: 0.7, affection: 0.55, empathy: 0.15 },
-            flirtatious: { romance: 0.55, playfulness: 0.45, affection: 0.25 },
-            laughing: { humor: 0.85, playfulness: 0.5, affection: 0.25 },
-            dancing: { playfulness: 1.1, affection: 0.45 },
-            surprise: { intelligence: 0.12, empathy: 0.12 },
-            shy: { romance: -0.3, affection: -0.12 },
-            confident: { intelligence: 0.15, affection: 0.55 },
-            listening: { empathy: 0.6, intelligence: 0.25 },
-            kiss: { romance: 0.85, affection: 0.7 },
-            goodbye: { affection: -0.15, empathy: 0.1 }
+            positive: { affection: 0.35, empathy: 0.18, playfulness: 0.2, humor: 0.22 },
+            negative: { affection: -0.55, empathy: 0.22 },
+            romantic: { romance: 0.55, affection: 0.45, empathy: 0.14 },
+            flirtatious: { romance: 0.45, playfulness: 0.38, affection: 0.2 },
+            laughing: { humor: 0.6, playfulness: 0.4, affection: 0.2 },
+            dancing: { playfulness: 0.55, affection: 0.35 },
+            surprise: { intelligence: 0.1, empathy: 0.1 },
+            shy: { romance: -0.25, affection: -0.1 },
+            confident: { intelligence: 0.13, affection: 0.45 },
+            listening: { empathy: 0.45, intelligence: 0.2 },
+            kiss: { romance: 0.65, affection: 0.55 },
+            goodbye: { affection: -0.12, empathy: 0.08 }
         };
 
         // Trait keyword scaling model for conversation analysis (per-message delta shaping)
@@ -94,8 +100,40 @@ class KimiEmotionSystem {
             empathy: { posFactor: 0.4, negFactor: 0.5, streakPenaltyAfter: 3, maxStep: 1.5 },
             playfulness: { posFactor: 0.45, negFactor: 0.4, streakPenaltyAfter: 4, maxStep: 1.4 },
             humor: { posFactor: 0.55, negFactor: 0.45, streakPenaltyAfter: 4, maxStep: 1.6 },
-            intelligence: { posFactor: 0.35, negFactor: 0.55, streakPenaltyAfter: 2, maxStep: 1.2 }
+            intelligence: { posFactor: 0.35, negFactor: 0.55, streakPenaltyAfter: 2, maxStep: 1.2 },
+            trust: { posFactor: 0.45, negFactor: 0.9, streakPenaltyAfter: 2, maxStep: 1.2 },
+            intimacy: { posFactor: 0.35, negFactor: 0.6, streakPenaltyAfter: 2, maxStep: 1.0 }
         };
+
+        // Ephemeral relational warmth (short-term amplifier damped over time)
+        this._warmth = 0; // range suggestion: -50..+50 (internally clamped)
+        this._lastWarmthDecay = Date.now();
+        this.WARMTH_CFG = Object.assign(
+            {
+                decayPerMinute: 2.5, // linear decay toward 0
+                maxAbs: 50,
+                affectionAmplifierAtMax: 0.25, // +25% affection delta at max warmth
+                romanceAmplifierAtMax: 0.2,
+                trustAmplifierAtMax: 0.22,
+                negativeMultiplier: 1.2 // negative warmth increases penalty magnitude slightly
+            },
+            window.KIMI_WARMTH_CONFIG || {}
+        );
+
+        // Relationship stage thresholds (can be overridden by window.KIMI_RELATIONSHIP_THRESHOLDS)
+        // Stages reflect progression: acquaintance -> friend -> close_friend -> romantic -> intimate -> deep_bond
+        this.RELATIONSHIP_STAGE_THRESHOLDS = Object.assign(
+            {
+                acquaintance: { minAffection: 0, minRomance: 0 },
+                friend: { minAffection: 40, minRomance: 0 },
+                close_friend: { minAffection: 60, minRomance: 10 },
+                romantic: { minAffection: 70, minRomance: 35 },
+                intimate: { minAffection: 82, minRomance: 55 },
+                deep_bond: { minAffection: 92, minRomance: 75 }
+            },
+            window.KIMI_RELATIONSHIP_THRESHOLDS || {}
+        );
+        this._currentRelationshipStage = "acquaintance";
     }
     // (Affection is an independent trait again; previous derived computation removed.)
     // ===== UNIFIED EMOTION ANALYSIS =====
@@ -156,6 +194,15 @@ class KimiEmotionSystem {
             negative: 1
         };
 
+        // Relationship-aware sensitivity adjustments (non-destructive copy)
+        let stage = this._currentRelationshipStage || "acquaintance";
+        const relBoost = { acquaintance: 0, friend: 0.05, close_friend: 0.1, romantic: 0.18, intimate: 0.25, deep_bond: 0.3 };
+        const mult = 1 + (relBoost[stage] || 0);
+        const stageSensitivity = { ...sensitivity };
+        stageSensitivity.romantic *= mult;
+        stageSensitivity.flirtatious *= mult;
+        stageSensitivity.kiss *= 1 + (relBoost[stage] || 0) * 1.2;
+
         // Normalize keyword lists to handle accents/contractions
         const normalizeList = arr => (Array.isArray(arr) ? arr.map(x => this.normalizeText(String(x))).filter(Boolean) : []);
         const normalizedPositiveWords = normalizeList(positiveWords);
@@ -171,7 +218,7 @@ class KimiEmotionSystem {
             const hits = check.keywords.reduce((acc, word) => acc + (this.countTokenMatches(lowerText, String(word)) ? 1 : 0), 0);
             if (hits > 0) {
                 const key = check.emotion;
-                const weight = sensitivity[key] != null ? sensitivity[key] : 1;
+                const weight = stageSensitivity[key] != null ? stageSensitivity[key] : 1;
                 const score = hits * weight;
                 if (score > bestScore) {
                     bestScore = score;
@@ -221,24 +268,32 @@ class KimiEmotionSystem {
         let playfulness = safe(traits?.playfulness, this.TRAIT_DEFAULTS.playfulness);
         let humor = safe(traits?.humor, this.TRAIT_DEFAULTS.humor);
         let intelligence = safe(traits?.intelligence, this.TRAIT_DEFAULTS.intelligence);
+        let trust = safe(traits?.trust, this.TRAIT_DEFAULTS.trust);
+        let intimacy = safe(traits?.intimacy, this.TRAIT_DEFAULTS.intimacy);
+
+        // Unified adjustment functions (parametric): soft diminishing returns / protection low end.
+        // Tunable via window.KIMI_ADJUST_TUNING = { upExponent, downExponent, minLossFactor, maxLossFactor, minGainFactor }
+        const tuning = window.KIMI_ADJUST_TUNING || {};
+        const upExp = typeof tuning.upExponent === "number" ? tuning.upExponent : 1.2; // >1 speeds early gains, slows late
+        const downExp = typeof tuning.downExponent === "number" ? tuning.downExponent : 1.1; // >1 accelerates high losses
+        const minGainFactor = typeof tuning.minGainFactor === "number" ? tuning.minGainFactor : 0.25; // floor near 100
+        const minLossFactor = typeof tuning.minLossFactor === "number" ? tuning.minLossFactor : 0.35; // floor near 0
+        const maxLossFactor = typeof tuning.maxLossFactor === "number" ? tuning.maxLossFactor : 1.15; // cap high-end loss accel
 
-        // Unified adjustment functions - More balanced progression for better user experience
         const adjustUp = (val, amount) => {
-            // Gradual slowdown only at very high levels to allow natural progression
-            if (val >= 95) return val + amount * 0.2; // Slow near max to preserve challenge
-            if (val >= 88) return val + amount * 0.5; // Moderate slowdown at very high levels
-            if (val >= 80) return val + amount * 0.7; // Slight slowdown at high levels
-            if (val >= 60) return val + amount * 0.9; // Nearly normal progression in mid-high range
-            return val + amount; // Normal progression below 60%
+            // Factor scales with remaining headroom (distance to 100)
+            const headroom = Math.max(0, 100 - val) / 100; // 1 at 0, 0 at 100
+            const factor = Math.max(minGainFactor, Math.pow(headroom, upExp));
+            return val + amount * factor;
         };
-
         const adjustDown = (val, amount) => {
-            // Faster decline at higher values - easier to lose than to gain
-            if (val >= 80) return val - amount * 1.2; // Faster loss at high levels
-            if (val >= 60) return val - amount; // Normal loss at medium levels
-            if (val >= 40) return val - amount * 0.8; // Slower loss at low-medium levels
-            if (val <= 20) return val - amount * 0.4; // Very slow loss at low levels
-            return val - amount * 0.6; // Moderate loss between 20-40
+            // Loss factor scales with current level (higher -> larger)
+            const level = Math.max(0, Math.min(100, val)) / 100; // 0..1
+            // curve amplifies as level increases
+            let factor = Math.pow(level, downExp) * maxLossFactor;
+            // Provide protection at very low end
+            if (level < 0.2) factor = Math.min(factor, minLossFactor);
+            return val - amount * factor;
         };
 
         // Unified emotion-based adjustments - More balanced and realistic progression
@@ -263,24 +318,131 @@ class KimiEmotionSystem {
             return baseDelta * GLOSS * t;
         };
 
+        // Lightweight per-call token cache (avoids repeated normalization/tokenization)
+        const _tokenCache = new Map();
+        const getTokenCount = phrase => {
+            if (!phrase) return 0;
+            const key = String(phrase);
+            if (_tokenCache.has(key)) return _tokenCache.get(key);
+            const c = this.tokenizeText(this.normalizeText(key)).length;
+            _tokenCache.set(key, c);
+            return c;
+        };
+
+        // Warmth decay (linear drift toward 0)
+        const nowTs = Date.now();
+        if (this._warmth !== 0) {
+            const mins = (nowTs - this._lastWarmthDecay) / 60000;
+            if (mins > 0.05) {
+                const decayAmt = this.WARMTH_CFG.decayPerMinute * mins;
+                if (this._warmth > 0) this._warmth = Math.max(0, this._warmth - decayAmt);
+                else this._warmth = Math.min(0, this._warmth + decayAmt);
+                this._lastWarmthDecay = nowTs;
+            }
+        }
+
+        // Derive a simple intensity factor from message length & punctuation emphasis
+        const wordCount = getTokenCount(text || "");
+        let intensity = 1;
+        if (wordCount >= 8 && wordCount < 25) intensity = 1.05;
+        else if (wordCount >= 25 && wordCount < 60) intensity = 1.12;
+        else if (wordCount >= 60) intensity = 1.18;
+        // Emphasis markers (!, ❤️, ???) add a small boost
+        const emphasisMatches = (text && text.match(/[!?!]{2,}|❤️|💖|😍/g)) || [];
+        if (emphasisMatches.length > 0) intensity += Math.min(0.12, 0.04 * emphasisMatches.length);
+
+        // ===== Contextual affectionate profanity & chaotic lexicon handling =====
+        const lower = (text || "").toLowerCase();
+        // Compliment anti-spam (exact token based) with exponential damping
+        this._complimentHistory = this._complimentHistory || [];
+        const nowMs = Date.now();
+        // Keep only last 60s entries
+        this._complimentHistory = this._complimentHistory.filter(t => nowMs - t < 60000);
+        const complimentTokens = ["merveilleuse", "merveilleux", "magnifique", "adorable", "charmant", "formidable"];
+        const messageTokens = this.tokenizeText(lower);
+        const complimentHits = messageTokens.filter(tok => complimentTokens.includes(tok)).length;
+        if (complimentHits > 0) {
+            for (let i = 0; i < complimentHits; i++) this._complimentHistory.push(nowMs);
+        }
+        const complimentDensity = this._complimentHistory.length; // raw count last 60s
+        // Exponential damping factor: each additional compliment reduces gains multiplicatively
+        // baseFactor^ (density-1), clamped
+        const baseFactor = 0.88; // 12% reduction per extra compliment
+        let complimentDampFactor = 1;
+        if (complimentDensity > 1) {
+            complimentDampFactor = Math.pow(baseFactor, complimentDensity - 1);
+        }
+        complimentDampFactor = Math.max(0.3, Math.min(1, complimentDampFactor));
+        const lovePatterns = [
+            /je t(?:'|e) ?aime/,
+            /i love you/,
+            /ti amo/,
+            /te quiero/,
+            /te amo/,
+            /ich liebe dich/,
+            /愛してる/,
+            /我爱你/,
+            /ti voglio bene/
+        ];
+        const softProfanity = /(putain|fuck|fucking|merde|shit|bordel)/;
+        const positiveAdj = /(adorable|magnifique|formidable|belle|bello|hermos[ao]|beautiful|amazing|wonderful|gorgeous)/;
+        const chaoticWords = /(chaos|chaotique|rebelle|rebel|wild|sauvage)/;
+        const conjugalTerms = /(ma femme|mon mari)/;
+
+        let affectionateProfane = false;
+        if (lovePatterns.some(r => r.test(lower)) && softProfanity.test(lower) && positiveAdj.test(lower)) {
+            affectionateProfane = true;
+        }
+        const containsChaos = chaoticWords.test(lower);
+        const containsConjugal = conjugalTerms.test(lower);
+
+        // If affectionate profanity detected while emotion not negative, gently bias toward romantic
+        if (affectionateProfane && emotion && emotion !== this.EMOTIONS.NEGATIVE) {
+            // Micro pre-boost before base map (acts like extra intensity)
+            intensity *= 1.04;
+            // Optionally upgrade neutral/positive to romantic
+            if (emotion === this.EMOTIONS.POSITIVE || emotion === this.EMOTIONS.NEUTRAL) {
+                emotion = this.EMOTIONS.ROMANTIC;
+            }
+        }
+
+        // Conjugal gating: if conjugal term appears but relationship stage < romantic, reduce romantic sensitivity
+        if (containsConjugal && emotion === this.EMOTIONS.ROMANTIC) {
+            const stageOrder = ["acquaintance", "friend", "close_friend", "romantic", "intimate", "deep_bond"];
+            const currentIdx = stageOrder.indexOf(this._currentRelationshipStage || "acquaintance");
+            if (currentIdx >= 0 && currentIdx < stageOrder.indexOf("romantic")) {
+                intensity *= 0.75; // soften premature strong romantic signal
+            }
+        }
+
         // Apply emotion deltas from centralized map (if defined)
         const map = this.EMOTION_TRAIT_EFFECTS?.[emotion];
+        const cfg = window.KIMI_EMOTION_CONFIG || null;
+        const traitScalar = cfg?.traitScalar || {};
+        const emotionScalar = cfg?.emotionScalar || {};
+        const emoScale = emotionScalar[emotion] || 1;
         if (map) {
             for (const [traitName, baseDelta] of Object.entries(map)) {
-                const delta = baseDelta; // base delta -> will be scaled below
+                let delta = baseDelta * emoScale * intensity; // apply emotion & intensity
+                const perTraitScale = traitScalar[traitName];
+                if (typeof perTraitScale === "number") delta *= perTraitScale;
                 if (delta === 0) continue;
                 switch (traitName) {
                     case "affection":
+                        let adjAffDelta = delta;
+                        if (delta > 0) adjAffDelta *= complimentDampFactor;
                         affection =
-                            delta > 0
-                                ? Math.min(100, adjustUp(affection, scaleGain("affection", delta)))
-                                : Math.max(0, adjustDown(affection, scaleLoss("affection", Math.abs(delta))));
+                            adjAffDelta > 0
+                                ? Math.min(100, adjustUp(affection, scaleGain("affection", adjAffDelta)))
+                                : Math.max(0, adjustDown(affection, scaleLoss("affection", Math.abs(adjAffDelta))));
                         break;
                     case "romance":
+                        let adjRomDelta = delta;
+                        if (delta > 0) adjRomDelta *= complimentDampFactor;
                         romance =
-                            delta > 0
-                                ? Math.min(100, adjustUp(romance, scaleGain("romance", delta)))
-                                : Math.max(0, adjustDown(romance, scaleLoss("romance", Math.abs(delta))));
+                            adjRomDelta > 0
+                                ? Math.min(100, adjustUp(romance, scaleGain("romance", adjRomDelta)))
+                                : Math.max(0, adjustDown(romance, scaleLoss("romance", Math.abs(adjRomDelta))));
                         break;
                     case "empathy":
                         empathy =
@@ -306,28 +468,37 @@ class KimiEmotionSystem {
                                 ? Math.min(100, adjustUp(intelligence, scaleGain("intelligence", delta)))
                                 : Math.max(0, adjustDown(intelligence, scaleLoss("intelligence", Math.abs(delta))));
                         break;
+                    case "trust":
+                        trust =
+                            delta > 0
+                                ? Math.min(100, adjustUp(trust, scaleGain("trust", delta * 0.6)))
+                                : Math.max(0, adjustDown(trust, scaleLoss("trust", Math.abs(delta) * 0.9)));
+                        break;
+                    case "intimacy":
+                        intimacy =
+                            delta > 0
+                                ? Math.min(100, adjustUp(intimacy, scaleGain("intimacy", delta * 0.5)))
+                                : Math.max(0, adjustDown(intimacy, scaleLoss("intimacy", Math.abs(delta) * 0.85)));
+                        break;
                 }
             }
         }
 
-        // Cross-trait interactions - traits influence each other for more realistic personality development
-        // High empathy should boost affection over time
-        if (empathy >= 75 && affection < empathy - 5) {
-            affection = Math.min(100, adjustUp(affection, scaleGain("affection", 0.1)));
+        // Micro direct trust/intimacy boost for respectful conjugal reference (stage-aware, only positive tone)
+        if (containsConjugal && emotion === this.EMOTIONS.ROMANTIC) {
+            const stageOrder = ["acquaintance", "friend", "close_friend", "romantic", "intimate", "deep_bond"];
+            const currentIdx = stageOrder.indexOf(this._currentRelationshipStage || "acquaintance");
+            const romanticIdx = stageOrder.indexOf("romantic");
+            let scale = 0.18; // base micro boost
+            if (currentIdx < romanticIdx) scale *= 0.5; // earlier stages smaller
+            // Compliment spam damping
+            scale *= complimentDampFactor;
+            trust = Math.min(100, adjustUp(trust, scaleGain("affection", scale * 0.8)));
+            intimacy = Math.min(100, adjustUp(intimacy, scaleGain("romance", scale * 0.6)));
         }
 
-        // High intelligence should slightly boost empathy (understanding others)
-        if (intelligence >= 80 && empathy < intelligence - 10) {
-            empathy = Math.min(100, adjustUp(empathy, scaleGain("empathy", 0.05)));
-        }
-
-        // Humor and playfulness should reinforce each other
-        if (humor >= 70 && playfulness < humor - 10) {
-            playfulness = Math.min(100, adjustUp(playfulness, scaleGain("playfulness", 0.05)));
-        }
-        if (playfulness >= 70 && humor < playfulness - 10) {
-            humor = Math.min(100, adjustUp(humor, scaleGain("humor", 0.05)));
-        }
+        // Cross-trait interactions removed here (now centralized exclusively in _applyCrossTraitModifiers)
+        // to avoid double application of synergy boosts.
 
         // Content-based adjustments (unified)
         await this._analyzeTextContent(
@@ -341,6 +512,71 @@ class KimiEmotionSystem {
             adjustUp
         );
 
+        // Micro contextual boosts (post content analysis, pre synergy)
+        if (affectionateProfane) {
+            // Treat as emphatic endearment: small extra romance & affection
+            affection = Math.min(100, adjustUp(affection, scaleGain("affection", 0.25 * intensity)));
+            romance = Math.min(100, adjustUp(romance, scaleGain("romance", 0.22 * intensity)));
+            // Warmth gain
+            this._warmth = Math.max(-this.WARMTH_CFG.maxAbs, Math.min(this.WARMTH_CFG.maxAbs, this._warmth + 8 * intensity));
+            // Trust/intimacy micro boost if not spamming (use last delta heuristic: only if romance<90)
+            if (romance < 90) {
+                trust = Math.min(100, adjustUp(trust, scaleGain("trust", 0.12 * intensity)));
+                intimacy = Math.min(100, adjustUp(intimacy, scaleGain("intimacy", 0.1 * intensity)));
+            }
+        }
+        if (containsChaos) {
+            playfulness = Math.min(100, adjustUp(playfulness, scaleGain("playfulness", 0.18 * intensity)));
+            // Slight warmth nudge (a playful chaotic vibe)
+            this._warmth = Math.max(-this.WARMTH_CFG.maxAbs, Math.min(this.WARMTH_CFG.maxAbs, this._warmth + 3 * intensity));
+        }
+        // Additional warmth gain for strong romantic emotion without profanity pattern
+        if (!affectionateProfane && emotion === this.EMOTIONS.ROMANTIC) {
+            const romanticPulse = 4 * intensity;
+            this._warmth = Math.max(-this.WARMTH_CFG.maxAbs, Math.min(this.WARMTH_CFG.maxAbs, this._warmth + romanticPulse));
+        }
+
+        // Relationship affirmation memory (deduplicate recent)
+        if (
+            (affectionateProfane || (emotion === this.EMOTIONS.ROMANTIC && lovePatterns.some(r => r.test(lower)))) &&
+            this.db?.db?.memories
+        ) {
+            try {
+                const cutoff = Date.now() - 1000 * 60 * 60 * 6; // 6h
+                const recent = await this.db.db.memories
+                    .where("category")
+                    .equals("relationships")
+                    .and(m => (m.tags || []).includes("relationship:affirmation") && new Date(m.timestamp).getTime() > cutoff)
+                    .limit(1)
+                    .toArray();
+                if (!recent || recent.length === 0) {
+                    const content = affectionateProfane
+                        ? "Intense affectionate profanity declaration"
+                        : "Romantic love affirmation";
+                    this.db.db.memories
+                        .add({
+                            category: "relationships",
+                            type: "affirmation",
+                            content,
+                            importance: 0.9,
+                            timestamp: new Date(),
+                            character: selectedCharacter,
+                            isActive: true,
+                            tags: ["relationship:affirmation", "relationship:love"],
+                            lastModified: new Date(),
+                            createdAt: new Date(),
+                            lastAccess: new Date(),
+                            accessCount: 0
+                        })
+                        .then(id => {
+                            if (window.kimiEventBus) window.kimiEventBus.emit("memory:stored", { memory: { id, content } });
+                        });
+                }
+            } catch (e) {
+                /* silent */
+            }
+        }
+
         // Cross-trait modifiers (applied after primary emotion & content changes)
         ({ affection, romance, empathy, playfulness, humor, intelligence } = this._applyCrossTraitModifiers({
             affection,
@@ -358,24 +594,98 @@ class KimiEmotionSystem {
         // Preserve fractional progress to allow gradual visible changes
         const to2 = v => Number(Number(v).toFixed(2));
         const clamp = v => Math.max(0, Math.min(100, v));
-        const updatedTraits = {
+        // Warmth amplification post base deltas (affects core relational traits)
+        if (this._warmth !== 0) {
+            const ampRatio = Math.min(1, Math.abs(this._warmth) / this.WARMTH_CFG.maxAbs);
+            const sign = this._warmth >= 0 ? 1 : -this.WARMTH_CFG.negativeMultiplier;
+            const amplify = (val, base, scale) => clamp(val + sign * (val - base) * scale * ampRatio);
+            affection = amplify(affection, this.TRAIT_DEFAULTS.affection, this.WARMTH_CFG.affectionAmplifierAtMax);
+            romance = amplify(romance, this.TRAIT_DEFAULTS.romance, this.WARMTH_CFG.romanceAmplifierAtMax);
+            trust = amplify(trust, this.TRAIT_DEFAULTS.trust, this.WARMTH_CFG.trustAmplifierAtMax);
+            intimacy = amplify(intimacy, this.TRAIT_DEFAULTS.intimacy, this.WARMTH_CFG.romanceAmplifierAtMax * 0.8);
+        }
+
+        let updatedTraits = {
             affection: to2(clamp(affection)),
             romance: to2(clamp(romance)),
             empathy: to2(clamp(empathy)),
             playfulness: to2(clamp(playfulness)),
             humor: to2(clamp(humor)),
-            intelligence: to2(clamp(intelligence))
+            intelligence: to2(clamp(intelligence)),
+            trust: to2(clamp(trust)),
+            intimacy: to2(clamp(intimacy))
         };
 
+        // Damping: limit per-message total movement across sensitive relational traits
+        const DAMP_CFG = Object.assign(
+            {
+                maxTotalDelta: 6, // sum of |delta| capped
+                focus: ["affection", "romance", "trust", "intimacy"],
+                softThreshold: 3.5 // start proportionally scaling beyond this
+            },
+            window.KIMI_DAMPING_CONFIG || {}
+        );
+        let total = 0;
+        const deltas = {};
+        for (const key of DAMP_CFG.focus) {
+            const prev = typeof traits?.[key] === "number" ? traits[key] : this.TRAIT_DEFAULTS[key];
+            const after = updatedTraits[key];
+            const delta = after - prev;
+            deltas[key] = delta;
+            total += Math.abs(delta);
+        }
+        if (total > DAMP_CFG.softThreshold) {
+            const scale = total > DAMP_CFG.maxTotalDelta ? DAMP_CFG.maxTotalDelta / total : DAMP_CFG.softThreshold / total;
+            if (scale < 1) {
+                for (const key of DAMP_CFG.focus) {
+                    const prev = typeof traits?.[key] === "number" ? traits[key] : this.TRAIT_DEFAULTS[key];
+                    updatedTraits[key] = to2(clamp(prev + deltas[key] * scale));
+                }
+            }
+        }
+
+        if (cfg && typeof cfg.finalize === "function") {
+            try {
+                const fin = cfg.finalize({ ...updatedTraits });
+                if (fin && typeof fin === "object") updatedTraits = { ...updatedTraits, ...fin };
+            } catch (e) {
+                console.warn("Finalize hook error", e);
+            }
+        }
+
+        // Emit event before persistence for observers/plugins
+        if (window.kimiEventBus) {
+            window.kimiEventBus.emit("traits:computed", { emotion, text, character: selectedCharacter, updatedTraits });
+            window.kimiEventBus.emit("relationship:trustChanged", { trust: updatedTraits.trust, character: selectedCharacter });
+            window.kimiEventBus.emit("relationship:intimacyChanged", {
+                intimacy: updatedTraits.intimacy,
+                character: selectedCharacter
+            });
+            window.kimiEventBus.emit("relationship:warmthChanged", { warmth: this._warmth, character: selectedCharacter });
+        }
+
+        // Update relationship stage based on new traits (affection & romance)
+        try {
+            this._updateRelationshipStage(updatedTraits, selectedCharacter);
+        } catch (e) {
+            /* non-blocking */
+        }
+
         // Prepare persistence with smoothing / threshold to avoid tiny writes
         const toPersist = {};
         for (const [trait, candValue] of Object.entries(updatedTraits)) {
             const current = typeof traits?.[trait] === "number" ? traits[trait] : this.TRAIT_DEFAULTS[trait];
             const prep = this._preparePersistTrait(trait, current, candValue, selectedCharacter);
-            if (prep.shouldPersist) toPersist[trait] = prep.value;
+            if (prep.shouldPersist) {
+                toPersist[trait] = prep.value;
+                this._pendingDrift[trait] = 0; // reset drift
+            }
         }
         if (Object.keys(toPersist).length > 0) {
+            if (window.kimiEventBus) window.kimiEventBus.emit("traits:willPersist", { character: selectedCharacter, toPersist });
             await this.db.setPersonalityBatch(toPersist, selectedCharacter);
+            if (window.kimiEventBus)
+                window.kimiEventBus.emit("traits:didPersist", { character: selectedCharacter, persisted: toPersist });
         }
 
         return updatedTraits;
@@ -432,7 +742,22 @@ class KimiEmotionSystem {
         };
 
         const pendingUpdates = {};
-        for (const trait of ["humor", "intelligence", "romance", "affection", "playfulness", "empathy"]) {
+        // Basic message intensity heuristic (long message -> slightly higher impact)
+        const tokenCount = this.tokenizeText(lowerUser).length;
+        const intensityFactor = tokenCount <= 4 ? 0.7 : tokenCount <= 12 ? 1 : tokenCount <= 30 ? 1.1 : 1.2;
+        const MAX_HITS_PER_WORD = 5; // cap repetition farming
+
+        for (const trait of [
+            "humor",
+            "intelligence",
+            "romance",
+            "affection",
+            "playfulness",
+            "empathy",
+            "trust",
+            "intimacy",
+            "boundary"
+        ]) {
             const posWords = getPersonalityWords(trait, "positive");
             const negWords = getPersonalityWords(trait, "negative");
             let currentVal =
@@ -446,15 +771,21 @@ class KimiEmotionSystem {
             let posScore = 0;
             let negScore = 0;
             for (const w of posWords) {
-                posScore += this.countTokenMatches(lowerUser, String(w)) * 1.0;
-                posScore += this.countTokenMatches(lowerKimi, String(w)) * 0.5;
+                const uHits = Math.min(MAX_HITS_PER_WORD, this.countTokenMatches(lowerUser, String(w)));
+                const kHits = Math.min(MAX_HITS_PER_WORD, this.countTokenMatches(lowerKimi, String(w)));
+                // sqrt dampening avoids farming same word
+                posScore += Math.sqrt(uHits) * 1.0 + Math.sqrt(kHits) * 0.5;
             }
             for (const w of negWords) {
-                negScore += this.countTokenMatches(lowerUser, String(w)) * 1.0;
-                negScore += this.countTokenMatches(lowerKimi, String(w)) * 0.5;
+                const uHits = Math.min(MAX_HITS_PER_WORD, this.countTokenMatches(lowerUser, String(w)));
+                const kHits = Math.min(MAX_HITS_PER_WORD, this.countTokenMatches(lowerKimi, String(w)));
+                negScore += Math.sqrt(uHits) * 1.0 + Math.sqrt(kHits) * 0.5;
             }
 
             let rawDelta = posScore * posFactor - negScore * negFactor;
+            const isBoundary = trait === "boundary";
+            // Apply message intensity scaling (kept modest)
+            rawDelta *= intensityFactor;
 
             // Track negative streaks per trait (only when net negative & no positives)
             if (!this.negativeStreaks[trait]) this.negativeStreaks[trait] = 0;
@@ -474,12 +805,27 @@ class KimiEmotionSystem {
 
             if (rawDelta !== 0) {
                 let newVal = currentVal + rawDelta;
-                if (rawDelta > 0) {
-                    newVal = Math.min(100, newVal);
-                } else {
-                    newVal = Math.max(0, newVal);
-                }
+                if (rawDelta > 0) newVal = Math.min(100, newVal);
+                else newVal = Math.max(0, newVal);
                 pendingUpdates[trait] = newVal;
+
+                if (isBoundary) {
+                    // Propagate boundary delta to trust/empathy/intimacy with scaled mapping
+                    const bDelta = rawDelta;
+                    if (bDelta > 0.05) {
+                        const trustBase = pendingUpdates.trust ?? traits.trust ?? this.TRAIT_DEFAULTS.trust;
+                        const empathyBase = pendingUpdates.empathy ?? traits.empathy ?? this.TRAIT_DEFAULTS.empathy;
+                        const intimacyBase = pendingUpdates.intimacy ?? traits.intimacy ?? this.TRAIT_DEFAULTS.intimacy;
+                        pendingUpdates.trust = Math.min(100, trustBase + bDelta * 0.6);
+                        pendingUpdates.empathy = Math.min(100, empathyBase + bDelta * 0.35);
+                        pendingUpdates.intimacy = Math.min(100, intimacyBase + bDelta * 0.25);
+                    } else if (bDelta < -0.05) {
+                        const trustBase = pendingUpdates.trust ?? traits.trust ?? this.TRAIT_DEFAULTS.trust;
+                        const intimacyBase = pendingUpdates.intimacy ?? traits.intimacy ?? this.TRAIT_DEFAULTS.intimacy;
+                        pendingUpdates.trust = Math.max(0, trustBase + bDelta * 0.7); // bDelta negative
+                        pendingUpdates.intimacy = Math.max(0, intimacyBase + bDelta * 0.5);
+                    }
+                }
             }
         }
 
@@ -492,10 +838,15 @@ class KimiEmotionSystem {
             for (const [trait, candValue] of Object.entries(pendingUpdates)) {
                 const current = typeof traits?.[trait] === "number" ? traits[trait] : this.TRAIT_DEFAULTS[trait];
                 const prep = this._preparePersistTrait(trait, current, candValue, character);
-                if (prep.shouldPersist) toPersist[trait] = prep.value;
+                if (prep.shouldPersist) {
+                    toPersist[trait] = prep.value;
+                    this._pendingDrift[trait] = 0;
+                }
             }
             if (Object.keys(toPersist).length > 0) {
+                if (window.kimiEventBus) window.kimiEventBus.emit("traits:willPersist", { character, toPersist });
                 await this.db.setPersonalityBatch(toPersist, character);
+                if (window.kimiEventBus) window.kimiEventBus.emit("traits:didPersist", { character, persisted: toPersist });
             }
         }
     }
@@ -656,16 +1007,22 @@ class KimiEmotionSystem {
 
     // Decide whether to persist based on absolute change threshold. Returns {shouldPersist, value}
     _preparePersistTrait(trait, currentValue, candidateValue, character = null) {
-        // Configurable via globals
+        // Adaptive threshold with drift accumulation.
         const alpha = (window.KIMI_SMOOTHING_ALPHA && Number(window.KIMI_SMOOTHING_ALPHA)) || 0.3;
-        const threshold = (window.KIMI_PERSIST_THRESHOLD && Number(window.KIMI_PERSIST_THRESHOLD)) || 0.25; // percent absolute
+        const baseThreshold = (window.KIMI_PERSIST_THRESHOLD && Number(window.KIMI_PERSIST_THRESHOLD)) || 0.15; // lowered from 0.25
+        // Initialize drift bucket
+        if (typeof this._pendingDrift[trait] !== "number") this._pendingDrift[trait] = 0;
 
         const smoothed = this._applyEMA(currentValue, candidateValue, alpha);
-        const absDelta = Math.abs(smoothed - currentValue);
-        if (absDelta < threshold) {
+        const delta = smoothed - currentValue;
+        this._pendingDrift[trait] += delta;
+        const absAccum = Math.abs(this._pendingDrift[trait]);
+
+        if (absAccum < baseThreshold) {
             return { shouldPersist: false, value: currentValue };
         }
-        return { shouldPersist: true, value: Number(Number(smoothed).toFixed(2)) };
+        const newValue = Number(Number(currentValue + this._pendingDrift[trait]).toFixed(2));
+        return { shouldPersist: true, value: newValue };
     }
 
     // ===== UTILITY METHODS =====
@@ -755,13 +1112,79 @@ class KimiEmotionSystem {
 
     getMoodCategoryFromPersonality(traits) {
         const avg = this.calculatePersonalityAverage(traits);
-
-        if (avg >= 80) return "speakingPositive";
-        if (avg >= 60) return "neutral";
-        if (avg >= 40) return "neutral";
-        if (avg >= 20) return "speakingNegative";
+        const cfg = window.KIMI_EMOTION_CONFIG && window.KIMI_EMOTION_CONFIG.moodThresholds;
+        // Default thresholds
+        const pos = cfg?.positive ?? 80;
+        const neutralHigh = cfg?.neutralHigh ?? 55;
+        const neutralLow = cfg?.neutralLow ?? 35;
+        const neg = cfg?.negative ?? 15;
+        if (avg >= pos) return "speakingPositive";
+        if (avg >= neutralHigh) return "neutral";
+        if (avg >= neutralLow) return "neutral";
+        if (avg >= neg) return "speakingNegative";
         return "speakingNegative";
     }
+
+    getRelationshipStage(affection, romance) {
+        const stages = ["deep_bond", "intimate", "romantic", "close_friend", "friend", "acquaintance"]; // check highest first
+        for (const stage of stages) {
+            const t = this.RELATIONSHIP_STAGE_THRESHOLDS[stage];
+            if (!t) continue;
+            if (affection >= t.minAffection && romance >= t.minRomance) return stage;
+        }
+        return "acquaintance";
+    }
+
+    _updateRelationshipStage(traits, character) {
+        const affection = traits.affection ?? this.TRAIT_DEFAULTS.affection;
+        const romance = traits.romance ?? this.TRAIT_DEFAULTS.romance;
+        const prev = this._currentRelationshipStage;
+        const next = this.getRelationshipStage(affection, romance);
+        if (next !== prev) {
+            this._currentRelationshipStage = next;
+            if (window.kimiEventBus) {
+                try {
+                    window.kimiEventBus.emit("relationship:stageChanged", {
+                        previous: prev,
+                        current: next,
+                        traits: { affection, romance },
+                        character
+                    });
+                } catch (e) {}
+            }
+            // Optionally add a memory note (only upward transitions)
+            if (typeof this.db?.db?.memories !== "undefined" && prev !== next) {
+                const upwardOrder = ["acquaintance", "friend", "close_friend", "romantic", "intimate", "deep_bond"];
+                if (upwardOrder.indexOf(next) > upwardOrder.indexOf(prev)) {
+                    try {
+                        this.db.db.memories
+                            .add({
+                                category: "relationships",
+                                type: "system_stage",
+                                content: `Relationship stage advanced to ${next}`,
+                                importance: 0.85,
+                                timestamp: new Date(),
+                                character: character,
+                                isActive: true,
+                                tags: ["relationship:stage", `relationship:stage_${next}`],
+                                lastModified: new Date(),
+                                createdAt: new Date(),
+                                lastAccess: new Date(),
+                                accessCount: 0
+                            })
+                            .then(id => {
+                                if (window.kimiEventBus)
+                                    try {
+                                        window.kimiEventBus.emit("memory:stored", { memory: { id, stage: next } });
+                                    } catch (e) {}
+                            });
+                    } catch (e) {
+                        /* non-blocking */
+                    }
+                }
+            }
+        }
+    }
 }
 
 window.KimiEmotionSystem = KimiEmotionSystem;

kimi-js/kimi-event-bus.js

@@ -0,0 +1,55 @@
+// Simple lightweight event bus with optional debug buffer
+(function () {
+    const listeners = new Map(); // event -> Set<fn>
+    const debugBuffer = [];
+    const MAX_DEBUG = 300;
+    let debugEnabled = false;
+
+    function on(event, handler) {
+        if (!listeners.has(event)) listeners.set(event, new Set());
+        listeners.get(event).add(handler);
+        return () => off(event, handler);
+    }
+    function once(event, handler) {
+        const wrap = payload => {
+            off(event, wrap);
+            try {
+                handler(payload);
+            } catch (e) {
+                console.error(e);
+            }
+        };
+        return on(event, wrap);
+    }
+    function off(event, handler) {
+        const set = listeners.get(event);
+        if (set) {
+            set.delete(handler);
+            if (set.size === 0) listeners.delete(event);
+        }
+    }
+    function emit(event, payload) {
+        if (debugEnabled) {
+            debugBuffer.push({ ts: Date.now(), event, payload });
+            if (debugBuffer.length > MAX_DEBUG) debugBuffer.shift();
+        }
+        const set = listeners.get(event);
+        if (set) {
+            for (const h of [...set]) {
+                try {
+                    h(payload);
+                } catch (e) {
+                    console.error("Event handler error", event, e);
+                }
+            }
+        }
+    }
+    function enableDebug(v = true) {
+        debugEnabled = !!v;
+    }
+    function getDebug() {
+        return debugBuffer.slice();
+    }
+
+    window.kimiEventBus = { on, once, off, emit, enableDebug, getDebug };
+})();

kimi-js/kimi-memory-system.js

@@ -14,6 +14,21 @@ class KimiMemorySystem {
             important: "Important Events"
         };
 
+        // Passive decay configuration (tunable via global window.KIMI_MEMORY_DECAY before init())
+        this.decayConfig = Object.assign(
+            {
+                enabled: true,
+                intervalMs: 60 * 60 * 1000, // hourly
+                halfLifeDays: 90,
+                minImportance: 0.05,
+                protectCategories: ["important", "relationships", "personal"],
+                recentBoostDays: 7,
+                accessRefreshBoost: 0.02
+            },
+            window.KIMI_MEMORY_DECAY || {}
+        );
+        this._lastDecayRun = 0;
+
         // Patterns for automatic memory extraction (multilingual)
         this.extractionPatterns = {
             personal: [
@@ -216,11 +231,49 @@ class KimiMemorySystem {
             this.selectedCharacter = await this.db.getSelectedCharacter();
             await this.createMemoryTables();
 
+            // Load last decay run timestamp (persisted across sessions)
+            try {
+                const storedLast = await this.db.getPreference("memoryLastDecayRun", 0);
+                if (storedLast && typeof storedLast === "number" && storedLast > 0) {
+                    this._lastDecayRun = storedLast;
+                }
+            } catch (e) {
+                if (window.KIMI_DEBUG_MEMORIES) console.warn("Could not load memoryLastDecayRun", e);
+            }
+
             // 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));
+
+            // Schedule passive decay loop if enabled
+            if (this.decayConfig.enabled) {
+                // Prevent duplicate timers if init() called multiple times
+                if (this._decayTimer) {
+                    clearTimeout(this._decayTimer);
+                }
+                const scheduleDecay = async () => {
+                    try {
+                        if (typeof this.applyMemoryDecay === "function") {
+                            await this.applyMemoryDecay();
+                        } else {
+                            console.warn("Memory decay skipped: applyMemoryDecay() not implemented");
+                            return; // do not reschedule endlessly if missing
+                        }
+                    } catch (e) {
+                        console.warn("memory decay tick failed", e);
+                    }
+                    this._decayTimer = setTimeout(scheduleDecay, this.decayConfig.intervalMs);
+                };
+                this._decayTimer = setTimeout(scheduleDecay, this.decayConfig.intervalMs);
+                if (window.KIMI_DEBUG_MEMORIES) {
+                    console.log(
+                        "⚙️ Passive memory decay scheduled. applyMemoryDecay present:",
+                        typeof this.applyMemoryDecay === "function"
+                    );
+                }
+            }
         } catch (error) {
             console.error("Memory system initialization error:", error);
         }
@@ -705,12 +758,20 @@ class KimiMemorySystem {
                 console.log(`Memory added with ID: ${id}`);
             }
 
-            // Cleanup old memories if we exceed limit
-            await this.cleanupOldMemories();
+            // Intelligent purge if over limits
+            await this.smartPurgeMemories();
 
             // Notify LLM system to refresh context
             this.notifyLLMContextUpdate();
 
+            // Emit event for observers (plugins, UI debug) after successful add
+            if (window.kimiEventBus) {
+                try {
+                    window.kimiEventBus.emit("memory:stored", { memory });
+                } catch (e) {
+                    console.warn("memory:stored emit failed", e);
+                }
+            }
             return memory;
         } catch (error) {
             console.error("Error adding memory:", error);
@@ -878,8 +939,47 @@ class KimiMemorySystem {
         if (memoryData.content && memoryData.content.length > 24) importance += 0.05;
         if (memoryData.confidence && memoryData.confidence > 0.9) importance += 0.05;
 
+        // Trait influence (pull current personality if available)
+        try {
+            if (window.kimiEmotionSystem && this.selectedCharacter) {
+                const traits =
+                    window.kimiEmotionSystem.db && window.kimiEmotionSystem.db.cachedPersonality
+                        ? window.kimiEmotionSystem.db.cachedPersonality[this.selectedCharacter] || {}
+                        : null;
+                if (traits) {
+                    const aff = typeof traits.affection === "number" ? traits.affection : 55;
+                    const emp = typeof traits.empathy === "number" ? traits.empathy : 75;
+                    // Scale 0..100 -> 0..1 then small weighted boost
+                    importance += (aff / 100) * 0.05; // affection: emotional salience
+                    if (memoryData.category === "personal" || memoryData.category === "relationships") {
+                        importance += (emp / 100) * 0.05; // empathy: care for personal/relationship
+                    }
+                }
+            }
+        } catch {}
+
+        // Frequency & recency influence (if existing memory object passed with stats)
+        if (typeof memoryData.accessCount === "number") {
+            const capped = Math.min(10, Math.max(0, memoryData.accessCount));
+            importance += (capped / 10) * 0.05; // up to +0.05
+        }
+        if (memoryData.lastAccess instanceof Date) {
+            const ageMs = Date.now() - memoryData.lastAccess.getTime();
+            const days = ageMs / 86400000;
+            if (days < 1)
+                importance += 0.03; // very recent recall
+            else if (days < 7) importance += 0.01;
+        }
+
+        // Decay slight if very old (timestamp far in past) without access metadata
+        if (memoryData.timestamp instanceof Date) {
+            const ageDays = (Date.now() - memoryData.timestamp.getTime()) / 86400000;
+            if (ageDays > 45) importance -= 0.04;
+            else if (ageDays > 90) importance -= 0.06; // stronger decay after 3 months
+        }
+
         // Round to two decimals to avoid floating point artifacts
-        return Math.min(1.0, Math.round(importance * 100) / 100);
+        return Math.min(1.0, Math.max(0.0, Math.round(importance * 100) / 100));
     }
 
     // Derive semantic tags from memory content to assist prioritization and merging
@@ -1232,6 +1332,101 @@ class KimiMemorySystem {
         }
     }
 
+    // SMART PURGE: multi-factor scoring to deactivate least valuable memories.
+    // Factors (low score purged first):
+    //  - Lower importance
+    //  - Older (timestamp, lastAccess)
+    //  - Low accessCount
+    //  - Category weight (preferences/activities lower, important/personal protected)
+    //  - Stale (not accessed recently and no boundary / relationship milestone tags)
+    async smartPurgeMemories() {
+        if (!this.db) return;
+        try {
+            const maxEntries = window.KIMI_MAX_MEMORIES || this.maxMemoryEntries || 100;
+            const memories = (await this.getAllMemories()).filter(m => m.isActive);
+            if (memories.length <= maxEntries) return; // nothing to do
+
+            const now = Date.now();
+            const PROTECT_TAGS = new Set([
+                "relationship:first_meet",
+                "relationship:first_date",
+                "relationship:first_kiss",
+                "relationship:anniversary",
+                "relationship:moved_in",
+                "boundary:dislike",
+                "boundary:preference",
+                "boundary:limit",
+                "boundary:consent"
+            ]);
+            const categoryBase = {
+                important: 1.0,
+                personal: 0.9,
+                relationships: 0.85,
+                goals: 0.75,
+                experiences: 0.6,
+                preferences: 0.5,
+                activities: 0.45
+            };
+            const recentWindowMs = 14 * 86400000; // 14 days
+            const freshWindowMs = 2 * 86400000; // 2 days (very recent boost)
+
+            const scored = memories.map(m => {
+                const importance = typeof m.importance === "number" ? m.importance : 0.5;
+                const created = new Date(m.timestamp).getTime();
+                const lastAccess = m.lastAccess ? new Date(m.lastAccess).getTime() : created;
+                const ageDays = (now - created) / 86400000;
+                const idleDays = (now - lastAccess) / 86400000;
+                const catW = categoryBase[m.category] || 0.5;
+                const access = m.accessCount || 0;
+                const tags = new Set(m.tags || []);
+                const hasProtectTag = [...tags].some(t => PROTECT_TAGS.has(t));
+                const recent = now - lastAccess < recentWindowMs;
+                const veryRecent = now - lastAccess < freshWindowMs;
+                // Build score (higher = keep)
+                let score = 0;
+                score += importance * 2.2; // primary weight
+                score += catW * 0.8;
+                score += Math.min(access, 20) * 0.05; // up to +1
+                if (recent) score += 0.4;
+                if (veryRecent) score += 0.3;
+                if (hasProtectTag) score += 0.6;
+                // Penalties
+                score -= Math.min(Math.max(idleDays - 30, 0) * 0.01, 0.5); // idle after 30d
+                score -= Math.min(ageDays * 0.002, 0.4); // very old slight penalty
+                return { memory: m, score };
+            });
+
+            // Sort ascending by score (lowest first) to know which to purge
+            scored.sort((a, b) => a.score - b.score);
+            const excess = scored.length - maxEntries;
+            if (excess <= 0) return;
+
+            const toPurge = scored
+                .slice(0, excess)
+                .filter(s => s.score < 2.2) // avoid purging those with already decent score
+                .map(s => s.memory);
+            if (toPurge.length === 0) return;
+
+            for (const mem of toPurge) {
+                try {
+                    await this.updateMemory(mem.id, { isActive: false, lastModified: new Date() });
+                } catch (e) {
+                    console.warn("Failed smart purge memory", mem.id, e);
+                }
+            }
+            if (window.kimiEventBus) {
+                try {
+                    window.kimiEventBus.emit("memory:purged", {
+                        purged: toPurge.length,
+                        remaining: memories.length - toPurge.length
+                    });
+                } catch (e) {}
+            }
+        } catch (e) {
+            console.warn("smartPurgeMemories failed", e);
+        }
+    }
+
     // MEMORY RETRIEVAL FOR LLM
     async getRelevantMemories(context = "", limit = 10) {
         if (!this.memoryEnabled) return [];
@@ -1347,6 +1542,36 @@ class KimiMemorySystem {
         score += (memory.confidence || 0.5) * 0.05;
         score += (memory.importance || 0.5) * 0.05;
 
+        // Relationship specific boosts
+        try {
+            const tags = new Set(memory.tags || []);
+            const relTags = [
+                "relationship:stage",
+                "relationship:first_meet",
+                "relationship:first_date",
+                "relationship:first_kiss",
+                "relationship:anniversary",
+                "relationship:moved_in"
+            ];
+            if (memory.category === "relationships") score += 0.08;
+            if ([...tags].some(t => relTags.includes(t))) score += 0.07;
+            if ([...tags].some(t => t.startsWith("boundary:"))) score += 0.06; // boundaries important contextually
+            if ([...tags].some(t => t.startsWith("relationship:stage_"))) score += 0.05;
+        } catch {}
+
+        // Warmth influence (pull from emotion system if present). High warmth favors relational memories.
+        try {
+            if (window.kimiEmotionSystem && typeof window.kimiEmotionSystem._warmth === "number") {
+                const w = window.kimiEmotionSystem._warmth; // -50..50
+                if (
+                    w > 5 &&
+                    (memory.category === "relationships" || (memory.tags || []).some(t => t.startsWith("relationship:")))
+                ) {
+                    score += Math.min(0.06, (w / 50) * 0.06);
+                }
+            }
+        } catch {}
+
         return Math.min(1.0, score);
     }
 
@@ -1958,9 +2183,135 @@ class KimiMemorySystem {
             return false;
         }
     }
+
+    // === PASSIVE MEMORY DECAY ===
+    // Gradually lowers importance of older / unused memories while protecting key categories.
+    async applyMemoryDecay() {
+        // Guards
+        if (!this.db || !this.db.db || !this.db.db.memories) return false;
+        if (!this.memoryEnabled) return false;
+        const cfg = this.decayConfig || {};
+        if (!cfg.enabled) return false;
+        if (!cfg.halfLifeDays || cfg.halfLifeDays <= 0) return false;
+
+        const now = Date.now();
+        const lastRun = this._lastDecayRun || 0;
+        // If never run, just set timestamp and skip decay to avoid immediate drop on startup
+        if (!lastRun) {
+            this._lastDecayRun = now;
+            if (window.KIMI_DEBUG_MEMORIES) console.log("⏳ Memory decay initialized (no decay applied on first run)");
+            return true;
+        }
+
+        const deltaMs = now - lastRun;
+        const deltaDays = deltaMs / 86400000; // convert ms -> days
+        if (deltaDays <= 0) return true;
+
+        this._lastDecayRun = now;
+        // Persist last run timestamp (fire and forget)
+        try {
+            this.db.setPreference && this.db.setPreference("memoryLastDecayRun", this._lastDecayRun);
+        } catch {}
+
+        // Pre-calc exponential decay factor based on half-life
+        // importance' = minImportance + (importance - minImportance) * 0.5^(deltaDays / halfLife)
+        const halfLife = cfg.halfLifeDays;
+        const minImp = typeof cfg.minImportance === "number" ? cfg.minImportance : 0.05;
+        const protectCats = new Set(cfg.protectCategories || []);
+        const recentBoostDays = typeof cfg.recentBoostDays === "number" ? cfg.recentBoostDays : 7;
+        const accessRefreshBoost = typeof cfg.accessRefreshBoost === "number" ? cfg.accessRefreshBoost : 0.02;
+        const decayPow = Math.pow(0.5, deltaDays / halfLife);
+
+        let updated = 0;
+        let skipped = 0;
+        let protectedCount = 0;
+
+        try {
+            const memories = await this.getAllMemories();
+            const ops = [];
+            for (const mem of memories) {
+                if (!mem.isActive) continue; // ignore inactive
+                if (protectCats.has(mem.category)) {
+                    protectedCount++;
+                    continue; // fully protected categories
+                }
+
+                if (typeof mem.importance !== "number") {
+                    // initialize missing importance
+                    mem.importance = this.calculateImportance(mem);
+                }
+
+                const originalImportance = mem.importance;
+                // Apply exponential decay toward min importance
+                let newImportance = minImp + (originalImportance - minImp) * decayPow;
+
+                // Recent access boost (prevents too-fast fading of freshly used memories)
+                try {
+                    if (mem.lastAccess) {
+                        const lastAccessDays = (now - new Date(mem.lastAccess).getTime()) / 86400000;
+                        if (lastAccessDays <= recentBoostDays) {
+                            newImportance += (recentBoostDays - lastAccessDays) * 0.002; // small tapering boost
+                        }
+                    }
+                } catch {}
+
+                // Access refresh micro-boost if accessCount increased recently (heuristic: lastAccess within decay window)
+                try {
+                    if (mem.lastAccess && now - new Date(mem.lastAccess).getTime() <= deltaMs) {
+                        newImportance += accessRefreshBoost;
+                    }
+                } catch {}
+
+                // Clamp
+                if (newImportance > 1) newImportance = 1;
+                if (newImportance < 0) newImportance = 0;
+
+                // Skip tiny changes to reduce writes
+                if (Math.abs(newImportance - originalImportance) < 0.005) {
+                    skipped++;
+                    continue;
+                }
+
+                mem.importance = Number(newImportance.toFixed(3));
+                mem.lastModified = new Date();
+                ops.push(this.db.db.memories.update(mem.id, { importance: mem.importance, lastModified: mem.lastModified }));
+                updated++;
+
+                // Batch writes to avoid blocking UI thread
+                if (ops.length >= 50) {
+                    await Promise.all(ops);
+                    ops.length = 0;
+                }
+            }
+            if (ops.length) await Promise.all(ops);
+        } catch (e) {
+            console.warn("Memory decay pass failed", e);
+            return false;
+        }
+
+        if (window.KIMI_DEBUG_MEMORIES || updated) {
+            console.log(
+                `🧪 Memory decay run: Δdays=${deltaDays.toFixed(3)} updated=${updated} skipped=${skipped} protected=${protectedCount}`
+            );
+        }
+        return true;
+    }
+
+    // Manually trigger a decay run and get a simple report (promise of boolean)
+    async runDecayNow() {
+        if (window.KIMI_DEBUG_MEMORIES) console.log("▶️ Manual memory decay trigger");
+        return this.applyMemoryDecay();
+    }
+
+    // Stop passive decay scheduling (e.g., when disabling memory system)
+    stopMemoryDecay() {
+        if (this._decayTimer) {
+            clearTimeout(this._decayTimer);
+            this._decayTimer = null;
+            if (window.KIMI_DEBUG_MEMORIES) console.log("⏹ Passive memory decay stopped");
+        }
+    }
 }
 
 window.KimiMemorySystem = KimiMemorySystem;
 export default KimiMemorySystem;
-
-window.KimiMemorySystem = KimiMemorySystem;

kimi-js/kimi-memory.js

@@ -1,4 +1,8 @@
 // ===== KIMI MEMORY MANAGER =====
+// ===== LEGACY KIMI MEMORY (FAVORABILITY) =====
+// LEGACY NOTE: This file is kept for backward compatibility (older favorability logic / UI hooks).
+// New memory extraction & storage is in `kimi-memory-system.js`.
+// Future work: gradually migrate any remaining calls to the new system and remove this file.
 class KimiMemory {
     constructor(database) {
         this.db = database;
@@ -107,10 +111,7 @@ class KimiMemory {
         }
     }
 
-    /**
-     * @deprecated Use updateGlobalPersonalityUI().
-     * Thin wrapper retained for backward compatibility only.
-     */
+    // Legacy wrapper: prefer updateGlobalPersonalityUI() elsewhere.
     updateFavorabilityBar() {
         if (window.updateGlobalPersonalityUI) {
             window.updateGlobalPersonalityUI();

kimi-js/kimi-module.js

@@ -330,25 +330,6 @@ function updateFavorabilityLabel(characterKey) {
     }
 }
 
-// Delegated personality average computation (single source of truth in KimiEmotionSystem)
-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;
-}
-
 // Update UI elements (bar + percentage text + label) based on overall personality average
 async function updateGlobalPersonalityUI(characterKey = null) {
     try {
@@ -356,7 +337,10 @@ async function updateGlobalPersonalityUI(characterKey = null) {
         if (!db) return;
         const character = characterKey || (await db.getSelectedCharacter());
         const traits = await db.getAllPersonalityTraits(character);
-        const avg = computePersonalityAverage(traits);
+        const avg =
+            window.kimiEmotionSystem && typeof window.kimiEmotionSystem.calculatePersonalityAverage === "function"
+                ? Number(window.kimiEmotionSystem.calculatePersonalityAverage(traits).toFixed(2))
+                : 50;
         // Reuse existing favorability bar elements for global average
         const bar = document.getElementById("favorability-bar");
         const text = document.getElementById("favorability-text");

kimi-js/kimi-personality-utils.js

@@ -5,25 +5,7 @@
         if (window.kimiEmotionSystem && typeof window.kimiEmotionSystem.calculatePersonalityAverage === "function") {
             return window.kimiEmotionSystem.calculatePersonalityAverage(traits || {});
         }
-        const keys = ["affection", "playfulness", "intelligence", "empathy", "humor", "romance"];
-        let sum = 0,
-            c = 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));
-                c++;
-            }
-        }
-        return c ? Number((sum / c).toFixed(2)) : 0;
-    }
-    /**
-     * @deprecated Call updateGlobalPersonalityUI() directly.
-     */
-    async function refreshUI(characterKey = null) {
-        if (window.updateGlobalPersonalityUI) {
-            return window.updateGlobalPersonalityUI(characterKey);
-        }
+        return 50;
     }
-    window.KimiPersonalityUtils = { calcAverage, refreshUI };
+    window.KimiPersonalityUtils = { calcAverage };
 })();

kimi-js/kimi-trait-sim.js

@@ -0,0 +1,19 @@
+// Simple trait simulation harness for development tuning.
+// Usage: window.kimiTraitSim.run([ { emotion: 'positive', text: 'love joke' }, ... ])
+(function () {
+    async function run(sequence, character = null) {
+        if (!window.kimiEmotionSystem || !window.kimiEmotionSystem.db) {
+            console.warn("Emotion system not ready");
+            return;
+        }
+        const results = [];
+        for (const step of sequence) {
+            const emotion = step.emotion || window.kimiEmotionSystem.analyzeEmotion(step.text || "", "auto");
+            const traits = await window.kimiEmotionSystem.updatePersonalityFromEmotion(emotion, step.text || "", character);
+            results.push({ emotion, text: step.text || "", traits: { ...traits } });
+        }
+        console.table(results.map(r => ({ emotion: r.emotion, ...r.traits })));
+        return results;
+    }
+    window.kimiTraitSim = { run };
+})();

kimi-js/kimi-utils.js

@@ -901,11 +901,51 @@ class KimiVideoManager {
 
         this._prefetchLikely(category);
 
+        const previous = { context: this.currentContext, emotion: this.currentEmotion };
+        if (window.kimiEventBus) {
+            try {
+                window.kimiEventBus.emit("video:willChange", {
+                    previous,
+                    next: { context: category, emotion, videoPath },
+                    ts: now
+                });
+            } catch (e) {}
+        }
+        // Anti-repetition strengthened: ensure recent history exists
+        if (!this._recentVideoHistory) this._recentVideoHistory = {};
+        const MAX_RECENT = 3;
+        // Replace selected video if it appears in recent list and there are alternatives
+        const recentList = this._recentVideoHistory[category] || [];
+        if (recentList.includes(videoPath) && (this.videoCategories[category] || []).length > 1) {
+            const alts = (this.videoCategories[category] || []).filter(v => !recentList.includes(v));
+            if (alts.length > 0) {
+                videoPath =
+                    typeof this._pickScoredVideo === "function"
+                        ? this._pickScoredVideo(category, alts, traits)
+                        : alts[Math.floor(Math.random() * alts.length)];
+            }
+        }
         this.loadAndSwitchVideo(videoPath, priority);
         // Always store normalized category as currentContext so event bindings match speakingPositive/Negative
         this.currentContext = category;
         this.currentEmotion = emotion;
         this.lastSwitchTime = now;
+        // Update history
+        const hist = this._recentVideoHistory[category] || [];
+        hist.push(videoPath);
+        while (hist.length > MAX_RECENT) hist.shift();
+        this._recentVideoHistory[category] = hist;
+        if (window.kimiEventBus) {
+            try {
+                window.kimiEventBus.emit("video:didChange", {
+                    context: category,
+                    emotion,
+                    videoPath,
+                    recent: [...hist],
+                    ts: now
+                });
+            } catch (e) {}
+        }
     }
 
     setupEventListenersForContext(context) {
@@ -1016,18 +1056,30 @@ class KimiVideoManager {
         if (traits && typeof affection === "number") {
             let weights = candidateVideos.map(video => {
                 if (category === "speakingPositive") {
-                    // Positive videos favored by affection, romance, and humor
-                    const base = 1 + (affection / 100) * 0.4; // Affection influence factor
-                    let bonus = 0;
+                    let warmth = 0;
+                    try {
+                        if (window.kimiEmotionSystem && typeof window.kimiEmotionSystem._warmth === "number")
+                            warmth = window.kimiEmotionSystem._warmth;
+                    } catch {}
+                    const warmthRatio = Math.min(1, Math.max(-1, warmth / (window.kimiEmotionSystem?.WARMTH_CFG?.maxAbs || 50)));
+                    const base = 1 + (affection / 100) * 0.35;
                     const rom = typeof traits.romance === "number" ? traits.romance : 50;
                     const hum = typeof traits.humor === "number" ? traits.humor : 50;
-                    if (emotion === "romantic") bonus += (rom / 100) * 0.3; // Romance context bonus
-                    if (emotion === "laughing") bonus += (hum / 100) * 0.3; // Humor context bonus
-                    return base + bonus;
+                    const romanceComponent = (rom / 100) * (emotion === "romantic" ? 0.35 : 0.2);
+                    const humorComponent = (hum / 100) * (emotion === "laughing" ? 0.35 : 0.15);
+                    const warmthBoost = warmthRatio >= 0 ? 1 + warmthRatio * 0.55 : 1 + warmthRatio * 0.25; // negative warmth reduces positive weight
+                    return base * (1 + romanceComponent + humorComponent) * warmthBoost;
                 }
                 if (category === "speakingNegative") {
-                    // Negative videos when affection is low (reduced weight to balance)
-                    return 1 + ((100 - affection) / 100) * 0.3; // Low-affection influence factor
+                    let warmth = 0;
+                    try {
+                        if (window.kimiEmotionSystem && typeof window.kimiEmotionSystem._warmth === "number")
+                            warmth = window.kimiEmotionSystem._warmth;
+                    } catch {}
+                    const warmthRatio = Math.min(1, Math.max(-1, warmth / (window.kimiEmotionSystem?.WARMTH_CFG?.maxAbs || 50)));
+                    const base = 1 + ((100 - affection) / 100) * 0.35;
+                    const warmthPenalty = warmthRatio > 0 ? 1 - warmthRatio * 0.65 : 1 - warmthRatio * 0.2; // cold slightly raises chance
+                    return base * warmthPenalty;
                 }
                 if (category === "neutral") {
                     // Neutral videos when affection is moderate, also influenced by intelligence
@@ -1887,28 +1939,12 @@ class KimiVideoManager {
 }
 
 function getMoodCategoryFromPersonality(traits) {
-    // Use unified emotion system
+    // Use unified emotion system if available
     if (window.kimiEmotionSystem) {
         return window.kimiEmotionSystem.getMoodCategoryFromPersonality(traits);
     }
-
-    // Fallback (should not be reached) - must match emotion system calculation
-    const keys = ["affection", "romance", "empathy", "playfulness", "humor", "intelligence"];
-    let sum = 0;
-    let count = 0;
-    keys.forEach(key => {
-        if (typeof traits[key] === "number") {
-            sum += traits[key];
-            count++;
-        }
-    });
-    const avg = count > 0 ? sum / count : 50;
-
-    if (avg >= 80) return "speakingPositive";
-    if (avg >= 60) return "neutral";
-    if (avg >= 40) return "neutral";
-    if (avg >= 20) return "speakingNegative";
-    return "speakingNegative";
+    // Fallback simplified: neutral baseline until system ready
+    return "neutral";
 }
 
 // Centralized initialization manager
@@ -2295,23 +2331,6 @@ class KimiUIStateManager {
         this.state.activeTab = tabName;
         if (this.tabManager) this.tabManager.activateTab(tabName);
     }
-    /**
-     * @deprecated Prefer calling updateGlobalPersonalityUI() after updating traits.
-     * This direct setter will be removed in a future cleanup.
-     */
-    setPersonalityAverage(value) {
-        const v = Number(value) || 0;
-        const clamped = Math.max(0, Math.min(100, v));
-        this.state.favorability = clamped;
-        window.KimiDOMUtils.setText("#favorability-text", `${clamped.toFixed(2)}%`);
-        window.KimiDOMUtils.get("#favorability-bar").style.width = `${clamped}%`;
-    }
-    /**
-     * @deprecated Use setPersonalityAverage() (itself deprecated) or updateGlobalPersonalityUI().
-     */
-    setFavorability(value) {
-        this.setPersonalityAverage(value);
-    }
     async setTranscript(text) {
         this.state.transcript = text;
         // Always use the proper transcript management via VoiceManager

kimi-js/kimi-voices.js

@@ -214,6 +214,7 @@ class KimiVoiceManager {
             this.selectedLanguage = window.KimiLanguageUtils.normalizeLanguageCode(selectedLanguage || "en") || "en";
         }
         const effectiveLang = await this.getEffectiveLanguage(this.selectedLanguage);
+        this.effectiveLang = effectiveLang;
 
         const savedVoice = await this.db?.getPreference("selectedVoice", "auto");
 
@@ -387,7 +388,8 @@ class KimiVoiceManager {
         autoOption.textContent = "Automatic (Best voice for selected language)";
         voiceSelect.appendChild(autoOption);
 
-        const filteredVoices = this.getVoicesForLanguage(this.selectedLanguage);
+        const baseLang = this.effectiveLang || this.selectedLanguage;
+        const filteredVoices = this.getVoicesForLanguage(baseLang);
 
         // If browser is not Chrome or Edge, do NOT expose voice options even when voices exist.
         // This avoids misleading users on Brave/Firefox/Opera/Safari who might think TTS is supported when it's not.
@@ -871,16 +873,35 @@ class KimiVoiceManager {
         this.recognition = new this.SpeechRecognition();
         this.recognition.continuous = true;
 
+        // Ensure UI language loaded before computing effectiveLang
+        if (!this.selectedLanguage) {
+            try {
+                const prefLang = await this.db?.getPreference("selectedLanguage", "en");
+                if (prefLang)
+                    this.selectedLanguage = window.KimiLanguageUtils.normalizeLanguageCode(prefLang) || prefLang || "en";
+            } catch {}
+        }
+
         // Resolve effective language (block invalid 'auto')
-        const normalized = await this.getEffectiveLanguage(this.selectedLanguage);
-        const langCode = this.getLanguageCode(normalized || "en");
+        const effectiveLang = await this.getEffectiveLanguage(this.selectedLanguage);
+        this.effectiveLang = effectiveLang;
+        const langCode = this.getLanguageCode(effectiveLang || "en");
         try {
             this.recognition.lang = langCode;
         } catch (e) {
             console.warn("Could not set recognition.lang, fallback en-US", e);
             this.recognition.lang = "en-US";
         }
-        console.log(`🎤 SpeechRecognition initialized (lang=${this.recognition.lang})`);
+        if (this.recognition.lang.toLowerCase().slice(0, 2) !== effectiveLang.slice(0, 2)) {
+            console.warn(
+                `🎤 Recognition language fallback mismatch: requested='${effectiveLang}' actual='${this.recognition.lang}'`
+            );
+            this._setASRBadgeState(true, effectiveLang, this.recognition.lang);
+        } else {
+            this._setASRBadgeState(false);
+        }
+        const uiLang = this.selectedLanguage || effectiveLang;
+        console.log(`🎤 SpeechRecognition initialized (ui=${uiLang}, effective=${effectiveLang}, lang=${this.recognition.lang})`);
         this.recognition.interimResults = true;
 
         // Add onstart handler to confirm permission
@@ -1503,6 +1524,22 @@ class KimiVoiceManager {
             autoStopDuration: this.autoStopDuration
         };
     }
+
+    _setASRBadgeState(mismatch, requested = "", actual = "") {
+        try {
+            const badge = document.getElementById("asr-lang-badge");
+            if (!badge) return;
+            if (!mismatch) {
+                badge.style.display = "none";
+                badge.textContent = "ASR";
+                badge.title = "ASR language matches UI language";
+                return;
+            }
+            badge.style.display = "inline-block";
+            badge.textContent = "ASR*";
+            badge.title = `Speech recognition fallback. UI=${requested} actual=${actual}`;
+        } catch {}
+    }
 }
 
 // Export for usage