Upload 38 files

CHANGELOG.md

@@ -1,40 +1,5 @@
 # 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,9 +140,6 @@
                 <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>
@@ -1089,10 +1086,7 @@
     </div>
 
     <script src="dexie.min.js"></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 src="kimi-locale/i18n.js" defer></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-css/kimi-style.css

@@ -1756,7 +1756,7 @@ button:focus,
     }
 
     .progress-container {
-        height: 12px;
+        height: 10px;
     }
 
     .mic-button {

kimi-js/kimi-constants.js

@@ -111,21 +111,7 @@ 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",
-            "ma femme",
-            "merveilleuse",
-            "merveilleux",
-            "passionné",
-            "adoré"
-        ],
+        romantic: ["amour", "romantique", "tendre", "câlin", "bisou", "mon cœur", "chéri", "ma belle", "passionné", "adoré"],
         flirtatious: [
             "flirt",
             "taquin",
@@ -227,19 +213,7 @@ 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",
-        "formidable",
-        "merveilleuse",
-        "merveilleux"
-    ],
+    fr: ["heureux", "joie", "génial", "parfait", "excellent", "magnifique", "super", "chouette"],
     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"],
@@ -398,18 +372,6 @@ 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: {
@@ -448,20 +410,7 @@ window.KIMI_PERSONALITY_KEYWORDS = {
             ]
         },
         romance: {
-            positive: [
-                "câlin",
-                "amour",
-                "romantique",
-                "bisou",
-                "tendresse",
-                "passion",
-                "séduisant",
-                "charmant",
-                "adorable",
-                "merveilleuse",
-                "merveilleux",
-                "ma femme"
-            ],
+            positive: ["câlin", "amour", "romantique", "bisou", "tendresse", "passion", "séduisant", "charmant", "adorable"],
             negative: [
                 "froid",
                 "froide",
@@ -486,10 +435,7 @@ window.KIMI_PERSONALITY_KEYWORDS = {
                 "câlin",
                 "aimer",
                 "adorer",
-                "adorable",
-                "merveilleuse",
-                "merveilleux",
-                "ma femme"
+                "adorable"
             ],
             negative: [
                 "méchant",
@@ -507,14 +453,8 @@ window.KIMI_PERSONALITY_KEYWORDS = {
                 "idiote",
                 "stupide",
                 "con",
-                "conne",
                 "connard",
-                "connasse",
-                "connasses",
-                "salope",
-                "pute",
-                "putain",
-                "poufiasse"
+                "salope"
             ]
         },
         playfulness: {
@@ -545,18 +485,6 @@ 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-system.js

@@ -9,20 +9,18 @@ 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 ALL synergy / balancing rules (single location to avoid double application).
+         * 3. Cross-trait modifiers (_applyCrossTraitModifiers) apply synergy / balancing rules (e.g. high empathy boosts affection, high romance stabilizes affection, intelligence supports empathy/humor).
          * 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. This class is the single source of truth; external helpers now delegate.
+         * 6. Global personality average (UI) = mean of six core traits (affection included).
          * 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 = {
@@ -68,29 +66,25 @@ 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)
-            trust: 50, // Trust starts neutral
-            intimacy: 45 // Intimacy builds slower than trust/romance
+            romance: 50 // Neutral romance baseline (earned over time)
         };
 
         // 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.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 }
+            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 }
         };
 
         // Trait keyword scaling model for conversation analysis (per-message delta shaping)
@@ -100,40 +94,8 @@ 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 },
-            trust: { posFactor: 0.45, negFactor: 0.9, streakPenaltyAfter: 2, maxStep: 1.2 },
-            intimacy: { posFactor: 0.35, negFactor: 0.6, streakPenaltyAfter: 2, maxStep: 1.0 }
+            intelligence: { posFactor: 0.35, negFactor: 0.55, streakPenaltyAfter: 2, maxStep: 1.2 }
         };
-
-        // 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 =====
@@ -194,15 +156,6 @@ 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);
@@ -218,7 +171,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 = stageSensitivity[key] != null ? stageSensitivity[key] : 1;
+                const weight = sensitivity[key] != null ? sensitivity[key] : 1;
                 const score = hits * weight;
                 if (score > bestScore) {
                     bestScore = score;
@@ -268,32 +221,24 @@ 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) => {
-            // 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;
+            // 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%
         };
+
         const adjustDown = (val, amount) => {
-            // 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;
+            // 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
         };
 
         // Unified emotion-based adjustments - More balanced and realistic progression
@@ -318,131 +263,24 @@ 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)) {
-                let delta = baseDelta * emoScale * intensity; // apply emotion & intensity
-                const perTraitScale = traitScalar[traitName];
-                if (typeof perTraitScale === "number") delta *= perTraitScale;
+                const delta = baseDelta; // base delta -> will be scaled below
                 if (delta === 0) continue;
                 switch (traitName) {
                     case "affection":
-                        let adjAffDelta = delta;
-                        if (delta > 0) adjAffDelta *= complimentDampFactor;
                         affection =
-                            adjAffDelta > 0
-                                ? Math.min(100, adjustUp(affection, scaleGain("affection", adjAffDelta)))
-                                : Math.max(0, adjustDown(affection, scaleLoss("affection", Math.abs(adjAffDelta))));
+                            delta > 0
+                                ? Math.min(100, adjustUp(affection, scaleGain("affection", delta)))
+                                : Math.max(0, adjustDown(affection, scaleLoss("affection", Math.abs(delta))));
                         break;
                     case "romance":
-                        let adjRomDelta = delta;
-                        if (delta > 0) adjRomDelta *= complimentDampFactor;
                         romance =
-                            adjRomDelta > 0
-                                ? Math.min(100, adjustUp(romance, scaleGain("romance", adjRomDelta)))
-                                : Math.max(0, adjustDown(romance, scaleLoss("romance", Math.abs(adjRomDelta))));
+                            delta > 0
+                                ? Math.min(100, adjustUp(romance, scaleGain("romance", delta)))
+                                : Math.max(0, adjustDown(romance, scaleLoss("romance", Math.abs(delta))));
                         break;
                     case "empathy":
                         empathy =
@@ -468,37 +306,28 @@ 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;
                 }
             }
         }
 
-        // 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)));
+        // 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)));
         }
 
-        // Cross-trait interactions removed here (now centralized exclusively in _applyCrossTraitModifiers)
-        // to avoid double application of synergy boosts.
+        // 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)));
+        }
 
         // Content-based adjustments (unified)
         await this._analyzeTextContent(
@@ -512,71 +341,6 @@ 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,
@@ -594,98 +358,24 @@ 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));
-        // 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 = {
+        const 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)),
-            trust: to2(clamp(trust)),
-            intimacy: to2(clamp(intimacy))
+            intelligence: to2(clamp(intelligence))
         };
 
-        // 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;
-                this._pendingDrift[trait] = 0; // reset drift
-            }
+            if (prep.shouldPersist) toPersist[trait] = prep.value;
         }
         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;
@@ -742,22 +432,7 @@ class KimiEmotionSystem {
         };
 
         const pendingUpdates = {};
-        // 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"
-        ]) {
+        for (const trait of ["humor", "intelligence", "romance", "affection", "playfulness", "empathy"]) {
             const posWords = getPersonalityWords(trait, "positive");
             const negWords = getPersonalityWords(trait, "negative");
             let currentVal =
@@ -771,21 +446,15 @@ class KimiEmotionSystem {
             let posScore = 0;
             let negScore = 0;
             for (const w of posWords) {
-                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;
+                posScore += this.countTokenMatches(lowerUser, String(w)) * 1.0;
+                posScore += this.countTokenMatches(lowerKimi, String(w)) * 0.5;
             }
             for (const w of negWords) {
-                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;
+                negScore += this.countTokenMatches(lowerUser, String(w)) * 1.0;
+                negScore += this.countTokenMatches(lowerKimi, String(w)) * 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;
@@ -805,27 +474,12 @@ class KimiEmotionSystem {
 
             if (rawDelta !== 0) {
                 let newVal = currentVal + rawDelta;
-                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);
-                    }
+                if (rawDelta > 0) {
+                    newVal = Math.min(100, newVal);
+                } else {
+                    newVal = Math.max(0, newVal);
                 }
+                pendingUpdates[trait] = newVal;
             }
         }
 
@@ -838,15 +492,10 @@ 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;
-                    this._pendingDrift[trait] = 0;
-                }
+                if (prep.shouldPersist) toPersist[trait] = prep.value;
             }
             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 });
             }
         }
     }
@@ -1007,22 +656,16 @@ class KimiEmotionSystem {
 
     // Decide whether to persist based on absolute change threshold. Returns {shouldPersist, value}
     _preparePersistTrait(trait, currentValue, candidateValue, character = null) {
-        // Adaptive threshold with drift accumulation.
+        // Configurable via globals
         const alpha = (window.KIMI_SMOOTHING_ALPHA && Number(window.KIMI_SMOOTHING_ALPHA)) || 0.3;
-        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 threshold = (window.KIMI_PERSIST_THRESHOLD && Number(window.KIMI_PERSIST_THRESHOLD)) || 0.25; // percent absolute
 
         const smoothed = this._applyEMA(currentValue, candidateValue, alpha);
-        const delta = smoothed - currentValue;
-        this._pendingDrift[trait] += delta;
-        const absAccum = Math.abs(this._pendingDrift[trait]);
-
-        if (absAccum < baseThreshold) {
+        const absDelta = Math.abs(smoothed - currentValue);
+        if (absDelta < threshold) {
             return { shouldPersist: false, value: currentValue };
         }
-        const newValue = Number(Number(currentValue + this._pendingDrift[trait]).toFixed(2));
-        return { shouldPersist: true, value: newValue };
+        return { shouldPersist: true, value: Number(Number(smoothed).toFixed(2)) };
     }
 
     // ===== UTILITY METHODS =====
@@ -1112,78 +755,12 @@ class KimiEmotionSystem {
 
     getMoodCategoryFromPersonality(traits) {
         const avg = this.calculatePersonalityAverage(traits);
-        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 */
-                    }
-                }
-            }
-        }
+        if (avg >= 80) return "speakingPositive";
+        if (avg >= 60) return "neutral";
+        if (avg >= 40) return "neutral";
+        if (avg >= 20) return "speakingNegative";
+        return "speakingNegative";
     }
 }
 

kimi-js/kimi-memory-system.js

@@ -14,21 +14,6 @@ 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: [
@@ -231,49 +216,11 @@ 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);
         }
@@ -758,20 +705,12 @@ class KimiMemorySystem {
                 console.log(`Memory added with ID: ${id}`);
             }
 
-            // Intelligent purge if over limits
-            await this.smartPurgeMemories();
+            // Cleanup old memories if we exceed limit
+            await this.cleanupOldMemories();
 
             // 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);
@@ -939,47 +878,8 @@ 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.max(0.0, Math.round(importance * 100) / 100));
+        return Math.min(1.0, Math.round(importance * 100) / 100);
     }
 
     // Derive semantic tags from memory content to assist prioritization and merging
@@ -1332,101 +1232,6 @@ 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 [];
@@ -1542,36 +1347,6 @@ 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);
     }
 
@@ -2183,135 +1958,9 @@ 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,8 +1,4 @@
 // ===== 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;
@@ -111,7 +107,10 @@ class KimiMemory {
         }
     }
 
-    // Legacy wrapper: prefer updateGlobalPersonalityUI() elsewhere.
+    /**
+     * @deprecated Use updateGlobalPersonalityUI().
+     * Thin wrapper retained for backward compatibility only.
+     */
     updateFavorabilityBar() {
         if (window.updateGlobalPersonalityUI) {
             window.updateGlobalPersonalityUI();

kimi-js/kimi-module.js

@@ -330,6 +330,25 @@ 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 {
@@ -337,10 +356,7 @@ async function updateGlobalPersonalityUI(characterKey = null) {
         if (!db) return;
         const character = characterKey || (await db.getSelectedCharacter());
         const traits = await db.getAllPersonalityTraits(character);
-        const avg =
-            window.kimiEmotionSystem && typeof window.kimiEmotionSystem.calculatePersonalityAverage === "function"
-                ? Number(window.kimiEmotionSystem.calculatePersonalityAverage(traits).toFixed(2))
-                : 50;
+        const avg = computePersonalityAverage(traits);
         // 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,7 +5,25 @@
         if (window.kimiEmotionSystem && typeof window.kimiEmotionSystem.calculatePersonalityAverage === "function") {
             return window.kimiEmotionSystem.calculatePersonalityAverage(traits || {});
         }
-        return 50;
+        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);
+        }
     }
-    window.KimiPersonalityUtils = { calcAverage };
+    window.KimiPersonalityUtils = { calcAverage, refreshUI };
 })();

kimi-js/kimi-utils.js

@@ -901,51 +901,11 @@ 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) {
@@ -1056,30 +1016,18 @@ class KimiVideoManager {
         if (traits && typeof affection === "number") {
             let weights = candidateVideos.map(video => {
                 if (category === "speakingPositive") {
-                    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;
+                    // Positive videos favored by affection, romance, and humor
+                    const base = 1 + (affection / 100) * 0.4; // Affection influence factor
+                    let bonus = 0;
                     const rom = typeof traits.romance === "number" ? traits.romance : 50;
                     const hum = typeof traits.humor === "number" ? traits.humor : 50;
-                    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 (emotion === "romantic") bonus += (rom / 100) * 0.3; // Romance context bonus
+                    if (emotion === "laughing") bonus += (hum / 100) * 0.3; // Humor context bonus
+                    return base + bonus;
                 }
                 if (category === "speakingNegative") {
-                    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;
+                    // Negative videos when affection is low (reduced weight to balance)
+                    return 1 + ((100 - affection) / 100) * 0.3; // Low-affection influence factor
                 }
                 if (category === "neutral") {
                     // Neutral videos when affection is moderate, also influenced by intelligence
@@ -1939,12 +1887,28 @@ class KimiVideoManager {
 }
 
 function getMoodCategoryFromPersonality(traits) {
-    // Use unified emotion system if available
+    // Use unified emotion system
     if (window.kimiEmotionSystem) {
         return window.kimiEmotionSystem.getMoodCategoryFromPersonality(traits);
     }
-    // Fallback simplified: neutral baseline until system ready
-    return "neutral";
+
+    // 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";
 }
 
 // Centralized initialization manager
@@ -2331,6 +2295,23 @@ 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,7 +214,6 @@ 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");
 
@@ -388,8 +387,7 @@ class KimiVoiceManager {
         autoOption.textContent = "Automatic (Best voice for selected language)";
         voiceSelect.appendChild(autoOption);
 
-        const baseLang = this.effectiveLang || this.selectedLanguage;
-        const filteredVoices = this.getVoicesForLanguage(baseLang);
+        const filteredVoices = this.getVoicesForLanguage(this.selectedLanguage);
 
         // 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.
@@ -873,35 +871,16 @@ 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 effectiveLang = await this.getEffectiveLanguage(this.selectedLanguage);
-        this.effectiveLang = effectiveLang;
-        const langCode = this.getLanguageCode(effectiveLang || "en");
+        const normalized = await this.getEffectiveLanguage(this.selectedLanguage);
+        const langCode = this.getLanguageCode(normalized || "en");
         try {
             this.recognition.lang = langCode;
         } catch (e) {
             console.warn("Could not set recognition.lang, fallback en-US", e);
             this.recognition.lang = "en-US";
         }
-        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})`);
+        console.log(`🎤 SpeechRecognition initialized (lang=${this.recognition.lang})`);
         this.recognition.interimResults = true;
 
         // Add onstart handler to confirm permission
@@ -1524,22 +1503,6 @@ 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