Upload 38 files

CHANGELOG.md

@@ -1,17 +1,36 @@
 # Virtual Kimi Changelog
 
+# [1.1.2] - 2025-08-30
+
+### Improvements
+
+- Improved memory and prompt generation to avoid duplicate memory sections and display accurate per-character counters.
+
+### Added
+
+- A concise "7-day summary" feature that extracts high-signal conversation highlights for quick reference.
+
+### Notes
+
+- Voice UI and TTS: Only Microsoft Edge and Google Chrome will display the voice selection list and support voice playback of messages; other browsers may not expose compatible voices.
+
+### Bug Fixes
+
+- Fixed import/export functions for preferences and data to ensure exported files can be re-imported correctly.
+
+- Fixed some small bugs related to memory, video playback, and preference import/export.
+
 # [1.1.1] - 2025-08-29
 
 ### Improvements
 
-- Improved language and voice selection logic: normalization, fallback, and robust preference management across all modules.
+- Microsoft Edge and Google Chrome Only : Improved language and voice selection logic: normalization, fallback, and robust preference management across all modules.
 - Enhanced voice compatibility and ensured consistent language handling.
 
 ### Bug Fixes
 
 - Fixed issue where videos could freeze after opening or closing the memory modal or changing memory sections.
 - Added automatic reset to neutral video state after UI interactions to prevent stuck/frozen videos.
-- Fixed import/export functions for preferences and data to ensure exported files can be re-imported correctly.
 
 # [1.1.0] - 2025-08-28
 

README.md

@@ -1,431 +1,428 @@
----
-license: openrail
-title: Virtual Kimi - AI Companion App 💖
-sdk: static
-emoji: 😻
-colorFrom: indigo
-colorTo: purple
-pinned: true
-short_description: AI companion girlfriends with adaptive personalities
----
-<div align="center">
-
-<b>Virtual Kimi</b>
-
-[![Open Source](https://img.shields.io/badge/Open%20Source-GitHub-brightgreen?style=flat-square&logo=github)](https://github.com/virtualkimi)
-[![No Commercial Use](https://img.shields.io/badge/No%20Commercial%20Use-%F0%9F%9A%AB-red?style=flat-square)](#license)
-
-</div>
-
-# Virtual Kimi - AI Companion Application 💖
-
-Web-based AI companion girlfriends featuring adaptive personalities, intelligent memory systems, and immersive conversational experiences.
-
-## Overview
-
-Virtual Kimi is an advanced virtual companion application that combines modern web technologies with state-of-the-art AI models to create meaningful, evolving relationships between users and AI girlfriend personalities.
-
-- **Lightweight:** ~600 KB of pure JavaScript, HTML, and CSS (no frameworks)
-- **Local-first:** All data is stored in your browser's IndexedDB (managed by Dexie.js)
-- **No tracking:** The only external calls are to FontAwesome (for icons) and the OpenRouter API (for AI)
-
-Built with vanilla JavaScript and modern web APIs, it offers a rich, responsive experience across devices.
-
----
-
-## 🌐 Support & Links
-
-- **Website**: [virtualkimi.com](https://virtualkimi.com)
-- **Email**: [ijohn@virtualkimi.com](ijohn@virtualkimi.com)
-- **X (Twitter)**: [x.com/virtualkimi](https://x.com/virtualkimi)
-- **GitHub**: [github.com/virtualkimi](https://github.com/virtualkimi)
-- **HuggingFace**: [huggingface.co/VirtualKimi](https://huggingface.co/VirtualKimi)
-- **YouTube**: [YouTube Channel](https://www.youtube.com/@VirtualKimi)
-
-- **Support the project**: [ko-fi.com/virtualkimi](https://ko-fi.com/virtualkimi)
-  _If you like this project or want to help me (I'm currently without a permanent job), you can buy me a coffee or make a donation. Every bit helps keep Virtual Kimi alive and evolving!_
-
-- **ETH Wallet**: 0x836C9D2e605f98Bc7144C62Bef837627b1a9C30c
-
----
-
-## Key Features
-
-### 🤖 **Advanced AI Integration**
-
-**Available recommended models and pricing for Openrouter (per 1M tokens):**
-
-- **Mistral-small-3.2**: 0.05$ input, 0.1$ output (128k context)
-- **Nous Hermes Llama 3.1 70B**: 0.1$ input, 0.28$ output (131k context)
-- **Cohere Command-R-08-2024**: 0.15$ input, 0.6$ output (131k context)
-- **Qwen3-235b-a22b-think**: 0.13$ input, 0.6$ output (262k context)
-- **Grok 3 mini**: 0.3$ input, 0.5$ output (131k context)
-- **Nous Hermes Llama 3.1 405B**: 0.7$ input, 0.8$ output (131k context)
-- **Anthropic Claude 3 Haiku**: 0.25$ input, 1.25$ output (131k context)
-- **Local Model (Ollama)**: 0$ input, 0$ output (4k context, runs offline — _experimental, not fully functional yet_)
-
-### 👥 **Multiple AI Personalities**
-
-- **Kimi**: Cosmic dreamer and astrophysicist with ethereal sensibilities
-- **Bella**: Nurturing botanist who sees people as plants needing care
-- **Rosa**: Chaotic prankster thriving on controlled chaos
-- **Stella**: Digital artist transforming reality through pixelated vision
-
-### Personality Trait Ranges
-
-All personality traits operate on a 0-100 scale:
-
-- **Affection**: Emotional warmth and attachment
-- **Playfulness**: Fun-loving and spontaneous behavior
-- **Intelligence**: Analytical and thoughtful responses
-- **Empathy**: Understanding and emotional support
-- **Humor**: Wit and lighthearted interactions
-- **Romance**: Romantic and intimate expressions
-
-### 🧠 **Intelligent Memory System**
-
-- Automatic extraction and categorization of conversation memories
-- Seven memory categories: Personal, Preferences, Relationships, Activities, Goals, Experiences, Events
-- Persistent memory across sessions with search and management capabilities
-- Character-specific memory isolation
-
-### 💫 **Dynamic Personality Evolution**
-
-- Six personality traits that evolve based on interactions:
-- Affection, Playfulness, Intelligence, Empathy, Humor, Romance
-- Real-time trait adjustments based on conversation tone and content
-- Visual personality indicators and progression tracking
-- Intelligent model selection and switching
-- Real-time emotion detection and analysis
-- Contextually-aware responses
-
-### 🎬 **Emotion-Driven Visual Experience**
-
-- Real-time video responses matching detected emotions
-- Smooth transitions between emotional states
-- Character-specific visual libraries with 50+ video clips
-- Context-aware video selection system
-
-### 🎨 **Customizable Interface**
-
-- Five professionally designed themes
-- Adjustable interface transparency
-- Responsive design optimized for desktop, tablet, and mobile
-- Accessibility features and keyboard navigation
-
-### 🌍 **Multilingual Support**
-
-- Full localization in 7 languages: English, French, Spanish, German, Italian, Japanese, Chinese
-- Automatic language detection from user input
-- Culturally-aware responses and emotion keywords
-
-### 🔌 **Extensible Plugin System**
-
-- Theme plugins for visual customization (currently, only the color theme plugin is functional)
-- Voice plugins for speech synthesis options (planned)
-- Behavior plugins for personality modifications (planned)
-- Secure plugin loading with validation
-
-### 🛡️ **Security & Privacy**
-
-- Input validation and sanitization
-- Secure API key handling
-- Local data storage with IndexedDB
-- No server dependencies for core functionality
-
-## 🏗️ Technical Architecture
-
-### 🧩 Core Technologies
-
-- **Frontend**: Vanilla JavaScript (ES6+), HTML5, CSS3
-- **Database**: IndexedDB with Dexie.js
-- **AI Integration**: OpenRouter API
-- **Speech**: Web Speech API
-- **Audio**: Web Audio API
-
----
-
-## ✨ Inspiration & Assets
-
-This project was originally inspired by the [JackyWine GitHub repository](https://github.com/Jackywine).
-@Jackywine on X (Twitter)
-
-The four main characters are visually based on images from four creators on X (Twitter):
-
-- @JulyFox33 (Kimi)
-- @BelisariaNew (Bella)
-- @JuliAIkiko (Rosa and Stella)
-
-All character videos were generated using the image-to-video AI from Kling.ai, specifically with the Kling v2.1 model.
-
-Get 50% bonus Credits in your first month with this code referral 7BR9GT2WQ6JF - link: [https://klingai.com](https://klingai.com/h5-app/invitation?code=7BR9GT2WQ6JF)
-
----
-
-### 🗂️ Module Structure
-
-```
-
-├── Core System
-│ ├── kimi-script.js # Main initialization
-│ ├── kimi-database.js # Data persistence layer
-│ ├── kimi-config.js # Configuration management
-│ └── kimi-security.js # Security utilities
-├── AI & Memory
-│ ├── kimi-llm-manager.js # LLM integration
-│ ├── kimi-emotion-system.js # Emotion analysis
-│ ├── kimi-memory-system.js # Intelligent memory
-│ └── kimi-memory-ui.js # Memory interface
-├── Interface & Media
-│ ├── kimi-appearance.js # Theme management
-│ ├── kimi-voices.js # Speech synthesis
-│ ├── kimi-utils.js # Utility classes
-│ └── kimi-module.js # Core functions
-├── Localization
-│ └── kimi-locale/ # Translation files
-└── Extensions
-└── kimi-plugins/ # Plugin system
-
-```
-
-### Data Flow
-
-1. **Input Processing**: User input → Security validation → Language detection
-2. **AI Analysis**: Emotion detection → Memory extraction → LLM processing
-3. **Response Generation**: Personality-aware response → Emotion mapping → Visual selection
-4. **Memory Update**: Trait evolution → Memory storage → UI synchronization
-
-## Installation & Setup
-
-### Prerequisites
-
-- Modern web browser (Chrome, Edge, Firefox recommended)
-- OpenRouter API key (optional but recommended for full functionality)
-
-### Quick Start
-
-1. **Clone the repository**
-
-    ```bash
-    git clone https://github.com/virtualkimi/virtual-kimi.git
-    cd virtual-kimi
-    ```
-
-2. **Open the application**
-
-    - Open `index.html` in your web browser
-    - Or serve via local web server for optimal performance:
-        ```bash
-        python -m http.server 8000
-        # Navigate to http://localhost:8000
-        ```
-
-3. **Configure API access**
-
-    - Open Settings → AI & Models
-    - Add your OpenRouter API key
-    - Select preferred AI model
-
-4. **Customize your experience**
-    - Choose a character in Personality tab
-    - Enable memory system in Data tab
-    - Adjust themes in Appearance tab
-
-### Production Deployment
-
-For production deployment, ensure:
-
-- HTTPS is enabled (required for microphone access)
-- Gzip compression for assets
-- Proper cache headers
-- CSP headers for enhanced security
-
-## ⚙️ Configuration
-
-### API Integration
-
-The application supports multiple AI providers through OpenRouter:
-
-- Mistral models
-- Nous Hermes models
-- Qwen3 models
-- Open-source alternatives
-
-### Memory System Configuration
-
-```javascript
-// Memory categories can be customized
-const memoryCategories = [
-    "personal", // Personal information
-    "preferences", // Likes and dislikes
-    "relationships", // People and connections
-    "activities", // Hobbies and activities
-    "goals", // Aspirations and plans
-    "experiences", // Past events
-    "important" // Significant moments
-];
-```
-
-## 🛠️ Development
-
-### Project Structure
-
-```
-virtual-kimi/
-├── index.html              # Main application
-├── virtualkimi.html         # Landing page
-├── kimi-*.js               # Core modules
-├── kimi-locale/            # Localization
-├── kimi-plugins/           # Plugin examples
-├── kimi-videos/            # Character videos
-├── kimi-icons/             # Character assets
-└── docs/                   # Documentation
-```
-
-### Adding New Features
-
-#### Creating a New Plugin
-
-```javascript
-// manifest.json
-{
-    "name": "Custom Theme",
-    "version": "1.0.0",
-    "type": "theme",
-    "style": "theme.css",
-    "main": "theme.js",
-    "enabled": true
-}
-```
-
-> **Note:** As of version 1.0, only the color theme plugin is fully functional. Voice and behavior plugins are planned for future releases. See `kimi-plugins/sample-theme/` for a working example.
-
-#### Extending Memory Categories
-
-```javascript
-// Add to kimi-memory-system.js
-const customCategory = {
-    name: "custom",
-    icon: "fas fa-star",
-    keywords: ["keyword1", "keyword2"],
-    confidence: 0.7
-};
-```
-
-### Health Check System
-
-The application includes a comprehensive health check system:
-
-```javascript
-// Run health check
-const healthCheck = new KimiHealthCheck();
-const report = await healthCheck.runAllChecks();
-console.log(report.status); // 'HEALTHY' or 'NEEDS_ATTENTION'
-```
-
-## Browser Compatibility
-
-| Browser     | Voice Recognition | Full Features | Notes                     |
-| ----------- | ----------------- | ------------- | ------------------------- |
-| Chrome 90+  | ✅                | ✅            | Recommended               |
-| Edge 90+    | ✅                | ✅            | Optimal voice performance |
-| Firefox 88+ | ⚠️                | ✅            | Limited voice support     |
-| Safari 14+  | ⚠️                | ✅            | iOS limitations           |
-
-## Performance
-
-### Optimization Features
-
-- Lazy loading of non-critical modules
-- Efficient batch database operations
-- Debounced UI interactions
-- Memory management with cleanup
-- Optimized video preloading
-
-### Resource Usage
-
-- Memory footprint: ~15-30MB active usage
-- Storage: Scales with conversation history
-- Network: API calls only, no tracking
-- CPU: Minimal background processing
-
-## Privacy & Security
-
-### Data Handling
-
-- All data stored locally in browser
-- No telemetry or analytics
-- API keys encrypted in local storage
-- User content never sent to external servers (except chosen AI provider)
-
-### Security Measures
-
-- Input validation and sanitization
-- XSS protection
-- Safe plugin loading
-- Secure API communication
-
-## Troubleshooting
-
-### Common Issues
-
-- **Microphone not working**: Ensure HTTPS and browser permissions
-- **API errors**: Verify OpenRouter key and model availability
-- **Performance issues**: Clear browser cache, check available memory
-- **Memory system not learning**: Ensure system is enabled in Data tab
-
-## Contributing
-
-We welcome contributions! Please see our contributing guidelines:
-
-1. Fork the repository
-2. Create a feature branch
-3. Make your changes with appropriate tests
-4. Submit a pull request with detailed description
-
-### Development Guidelines
-
-- Follow existing code style and patterns
-- Add comments for complex functionality
-- Test across multiple browsers
-- Update documentation for new features
-
-## 🔄 TODO / Roadmap
-
-- [ ] Full support for local models (Ollama integration, offline mode)
-- [ ] Voice plugin system (custom voices, TTS engines)
-- [ ] Behavior plugin system (custom AI behaviors)
-- [ ] Better advanced memory management UI
-- [ ] More character personalities and backgrounds
-- [ ] In-app onboarding and help system
-- [ ] Enhanced mobile experience (UI/UX)
-- [ ] More granular privacy controls
-- [ ] User profile and persistent settings sync (optional)
-- [ ] Community plugin/theme sharing platform
-- [ ] Improved error reporting and diagnostics
-- [ ] Accessibility improvements (screen reader, contrast, etc.)
-- [ ] Automated testing and CI/CD pipeline
-- [ ] Documentation in multiple languages
-- [ ] Performance profiling and optimization for large histories
-- [ ] Create new character videos better matching specific contexts
-- [ ] Improve emotion and context logic
-- [ ] Enhance memory management and logic
-
----
-
-## 📜 License
-
-This project is distributed under a custom license. **Any commercial use, resale, or monetization of this application or its derivatives is strictly prohibited without the explicit written consent of the author.**
-
-See the [LICENSE](LICENSE) file for details.
-
-[![Open Source](https://img.shields.io/badge/Open%20Source-GitHub-brightgreen?style=flat-square&logo=github)](https://github.com/virtualkimi)
-[![No Commercial Use](https://img.shields.io/badge/No%20Commercial%20Use-%F0%9F%9A%AB-red?style=flat-square)](#license)
-
----
-
-**Virtual Kimi** - Creating meaningful connections between humans and AI, one conversation at a time.
-
-> _"Love is the most powerful code"_ 💕
->
-> — 2025 Virtual Kimi - Created with 💜 by Jean & Kimi
+<div align="center">
+
+<b>Virtual Kimi</b>
+
+[![Open Source](https://img.shields.io/badge/Open%20Source-GitHub-brightgreen?style=flat-square&logo=github)](https://github.com/virtualkimi)
+[![No Commercial Use](https://img.shields.io/badge/No%20Commercial%20Use-%F0%9F%9A%AB-red?style=flat-square)](#license)
+
+</div>
+
+# Virtual Kimi - AI Companion Application 💖
+
+Web-based AI girlfriend and companion featuring adaptive personalities, intelligent memory systems, and immersive conversational experiences.
+
+## Overview
+
+Virtual Kimi is an advanced virtual companion application that combines modern web technologies with state-of-the-art AI models to create meaningful, evolving relationships between users and AI girlfriend personalities.
+
+- **Lightweight:** ~600 KB of pure JavaScript, HTML, and CSS (no frameworks)
+- **Local-first:** All data is stored in your browser's IndexedDB (managed by Dexie.js)
+- **No tracking:** The only external calls are to FontAwesome (for icons) and the OpenRouter API (for AI)
+
+Built with vanilla JavaScript and modern web APIs, it offers a rich, responsive experience across devices.
+
+---
+
+## 🌐 Support & Links
+
+- **Website**: [virtualkimi.com](https://virtualkimi.com)
+- **Email**: [ijohn@virtualkimi.com](ijohn@virtualkimi.com)
+- **X (Twitter)**: [x.com/virtualkimi](https://x.com/virtualkimi)
+- **GitHub**: [github.com/virtualkimi](https://github.com/virtualkimi)
+- **HuggingFace**: [huggingface.co/VirtualKimi](https://huggingface.co/VirtualKimi)
+- **YouTube**: [YouTube Channel](https://www.youtube.com/@VirtualKimi)
+
+- **Support the project**: [ko-fi.com/virtualkimi](https://ko-fi.com/virtualkimi)
+  _If you like this project or want to help me (I'm currently without a permanent job), you can buy me a coffee or make a donation. Every bit helps keep Virtual Kimi alive and evolving!_
+
+- **ETH Wallet**: 0x836C9D2e605f98Bc7144C62Bef837627b1a9C30c
+
+---
+
+## Key Features
+
+### 🤖 **Advanced AI Integration**
+
+Recommended models (IDs and short notes — updated Aug 2025):
+
+- mistralai/mistral-small-3.2-24b-instruct — Mistral-small-3.2 (128k context, economical)
+- qwen/qwen3-30b-a3b-instruct-2507 — Qwen3 30b (131k context)
+- nousresearch/hermes-4-70b — Nous Hermes 4 70B (131k context)
+- x-ai/grok-3-mini — Grok 3 mini (131k context)
+- cohere/command-r-08-2024 — Cohere Command-R (128k context)
+- qwen/qwen3-235b-a22b-2507 — Qwen3-235b (262k context)
+- anthropic/claude-3-haiku — Claude 3 Haiku (large context)
+- local/ollama — Local Model (Ollama, experimental, 4k context)
+
+Notes: model IDs in the app are authoritative; pricing/context values are indicative and may change with providers.
+
+### 👥 **Multiple AI Personalities**
+
+- **Kimi**: Cosmic dreamer and astrophysicist with ethereal sensibilities
+- **Bella**: Nurturing botanist who sees people as plants needing care
+- **Rosa**: Chaotic prankster thriving on controlled chaos
+- **Stella**: Digital artist transforming reality through pixelated vision
+
+### Personality Trait Ranges
+
+All personality traits operate on a 0-100 scale:
+
+- **Affection**: Emotional warmth and attachment
+- **Playfulness**: Fun-loving and spontaneous behavior
+- **Intelligence**: Analytical and thoughtful responses
+- **Empathy**: Understanding and emotional support
+- **Humor**: Wit and lighthearted interactions
+- **Romance**: Romantic and intimate expressions
+
+### 🧠 **Intelligent Memory System**
+
+- Automatic extraction and categorization of conversation memories
+- Seven memory categories: Personal, Preferences, Relationships, Activities, Goals, Experiences, Events
+- Persistent memory across sessions with search and management capabilities
+- Character-specific memory isolation
+
+### 💫 **Dynamic Personality Evolution**
+
+- Six personality traits that evolve based on interactions:
+- Affection, Playfulness, Intelligence, Empathy, Humor, Romance
+- Real-time trait adjustments based on conversation tone and content
+- Visual personality indicators and progression tracking
+- Intelligent model selection and switching
+- Real-time emotion detection and analysis
+- Contextually-aware responses
+
+### 🎬 **Emotion-Driven Visual Experience**
+
+- Real-time video responses matching detected emotions
+- Smooth transitions between emotional states
+- Character-specific visual libraries with ~240 video clips (approx. 60 per main character)
+- Context-aware video selection system
+
+### 🎨 **Customizable Interface**
+
+- Five professionally designed themes
+- Adjustable interface transparency
+- Responsive design optimized for desktop, tablet, and mobile
+- Accessibility features and keyboard navigation
+
+### 🌍 **Multilingual Support**
+
+- Full localization in 7 languages: English, French, Spanish, German, Italian, Japanese, Chinese
+- Automatic language detection from user input
+- Culturally-aware responses and emotion keywords
+
+### 🔌 **Extensible Plugin System**
+
+- Theme plugins for visual customization (currently, only the color theme plugin is functional)
+- Voice plugins for speech synthesis options (planned)
+- Behavior plugins for personality modifications (planned)
+- Secure plugin loading with validation
+
+### 🛡️ **Security & Privacy**
+
+- Input validation and sanitization
+- Secure API key handling
+- Local data storage with IndexedDB
+- No server dependencies for core functionality
+
+## 🏗️ Technical Architecture
+
+### 🧩 Core Technologies
+
+- **Frontend**: Vanilla JavaScript (ES6+), HTML5, CSS3
+- **Database**: IndexedDB with Dexie.js
+- **AI Integration**: OpenRouter (default), OpenAI-compatible, Cohere, Anthropic, Groq, Together, or local Ollama
+- **Speech**: Web Speech API
+- **Audio**: Web Audio API
+
+---
+
+## ✨ Inspiration & Assets
+
+This project was originally inspired by the [JackyWine GitHub repository](https://github.com/Jackywine).
+@Jackywine on X (Twitter)
+
+The four main characters are visually based on images from four creators on X (Twitter):
+
+- @JulyFox33 (Kimi)
+- @BelisariaNew (Bella)
+- @JuliAIkiko (Rosa and Stella)
+
+All character videos were generated using the image-to-video AI from Kling.ai, specifically with the Kling v2.1 model.
+
+Get 50% bonus Credits in your first month with this code referral 7BR9GT2WQ6JF - link: [https://klingai.com](https://klingai.com/h5-app/invitation?code=7BR9GT2WQ6JF)
+
+---
+
+### Project Structure (current)
+
+Top-level files and main modules:
+
+- index.html — Main application entry
+- virtual-kimi (static assets & landing): virtual-kimi\*.html
+- kimi-js/
+    - kimi-script.js — App initialization & orchestration
+    - kimi-database.js — IndexedDB persistence (Dexie)
+    - kimi-config.js — Runtime configuration
+    - kimi-security.js — Security utilities
+    - kimi-llm-manager.js — LLM integration and model list
+    - kimi-emotion-system.js — Emotion analysis
+    - kimi-memory-system.js — Memory extraction & storage
+    - kimi-memory-ui.js — Memory management UI
+    - kimi-appearance.js, kimi-voices.js, kimi-utils.js, kimi-module.js, etc.
+- kimi-css/ — styles and themes
+- kimi-plugins/ — local plugins (sample-theme, sample-behavior, sample-voice)
+- kimi-locale/ — translations and i18n files
+- dexie.min.js — local DB helper
+
+### Data Flow
+
+1. **Input Processing**: User input → Security validation → Language detection
+2. **AI Analysis**: Emotion detection → Memory extraction → LLM processing
+3. **Response Generation**: Personality-aware response → Emotion mapping → Visual selection
+4. **Memory Update**: Trait evolution → Memory storage → UI synchronization
+
+## Installation & Setup
+
+### Prerequisites
+
+- Modern web browser (Chrome, Edge or recent Firefox recommended). The app is plain HTML/CSS/JS and runs locally in a browser — no build step is required.
+- (Optional) OpenRouter API key or another compatible provider API key if you want remote LLM access. The app can run without a key using local-only features, but AI responses will be limited.
+- HTTPS is required for microphone access and some browser TTS features. For full voice/microphone features, open the app via a local server (see Quick Start). If you only open `index.html` directly, most features still work but microphone may be blocked by the browser.
+- Dexie.js is included for IndexedDB persistence (no installation required; file `dexie.min.js` is bundled).
+
+### Quick Start
+
+1. **Clone the repository**
+
+    ```bash
+    git clone https://github.com/virtualkimi/virtual-kimi.git
+    cd virtual-kimi
+    ```
+
+2. **Open the application**
+
+    - Open `index.html` in your web browser
+    - Or serve via local web server for optimal performance:
+        ```bash
+        python -m http.server 8000
+        # Navigate to http://localhost:8000
+        ```
+
+3. **Configure API access**
+
+    - Open Settings → AI & Models
+    - Provider: choose the LLM provider to use. Supported options in the app include `openrouter` (recommended), `openai`/OpenAI-compatible endpoints, and `ollama` (local). The selected provider is saved in the app preferences.
+    - API key: paste your provider API key into the API Key field. Keys are saved locally in your browser's IndexedDB (preferences) so they never leave your machine except when the app sends requests to the selected provider.
+    - Base URL: if you use a non‑default provider or an OpenAI-compatible endpoint, set the provider base URL (Settings → AI & Models → Base URL). This overrides the built-in default endpoints.
+    - Model selection: choose a model ID from the list. The app's authoritative model list is defined in `kimi-js/kimi-llm-manager.js`. If the provider does not support the selected model, the app will attempt a best-match fallback or show an error.
+    - Test API key: use the app's built-in test function (Settings → Test API) to validate your key; this performs a minimal request and reports success or the provider error message.
+    - Local (Ollama) usage: to use a local model with `ollama`, run your local Ollama-compatible server (the app uses `http://localhost:11434/api/chat`). Select provider `ollama` and set model ID accordingly. Local models are experimental and work only if the local server is running.
+    - No key behavior: the app runs without an API key for local UI features and stored data, but remote LLM responses require a valid provider/key. If no key is configured the app will return friendly fallback messages for AI features.
+
+    Troubleshooting notes:
+
+    - If you see HTTP 401: verify the API key for the selected provider.
+    - If you see HTTP 429 or rate-limit errors: wait a moment or choose a different model/provider account.
+    - If the model is reported as unavailable (422-like errors): verify the model ID and, if needed, refresh the remote model list in Settings.
+    - For OpenRouter-specific issues: check the Base URL is `https://openrouter.ai/api/v1/chat/completions` (default) unless you use a custom endpoint.
+
+4. **Customize your experience**
+    - Choose your language and preferred voice
+    - Choose a character in Personality tab
+    - Enable memory system in Data tab
+    - Adjust themes and UI opacity in Appearance tab
+
+### Production Deployment
+
+For production deployment, ensure:
+
+- HTTPS is enabled (required for microphone access)
+- Gzip compression for assets
+- Proper cache headers
+- CSP headers for enhanced security
+
+## ⚙️ Configuration
+
+### API Integration
+
+The application supports multiple AI providers; choose and configure your provider in Settings → AI & Models.
+
+- Mistral models
+- Nous Hermes models
+- Qwen3 models
+- xAI models
+- Open-source alternatives
+
+### Memory System Configuration
+
+```javascript
+// Memory categories can be customized
+const memoryCategories = [
+    "personal", // Personal information
+    "preferences", // Likes and dislikes
+    "relationships", // People and connections
+    "activities", // Hobbies and activities
+    "goals", // Aspirations and plans
+    "experiences", // Past events
+    "important" // Significant moments
+];
+```
+
+## 🛠️ Development
+
+### Project Structure
+
+```
+<repo root>
+├── index.html
+├── README.md
+├── LICENSE.md
+├── package.json
+├── kimi-js/           # core JS modules (kimi-*.js)
+├── kimi-locale/       # translations (en.json, fr.json, ...)
+├── kimi-plugins/      # plugin examples
+├── kimi-videos/       # character video clips
+├── kimi-icons/        # image assets and favicons
+└── dexie.min.js       # IndexedDB helper
+```
+
+### Adding New Features
+
+#### Creating a New Plugin
+
+```javascript
+// manifest.json
+{
+    "name": "Custom Theme",
+    "version": "1.0.0",
+    "type": "theme",
+    "style": "theme.css",
+    "main": "theme.js",
+    "enabled": true
+}
+```
+
+> **Note:** As of version 1.0, only the color theme plugin is fully functional. Voice and behavior plugins are planned for future releases. See `kimi-plugins/sample-theme/` for a working example.
+
+#### Extending Memory Categories
+
+```javascript
+// Add to kimi-memory-system.js
+const customCategory = {
+    name: "custom",
+    icon: "fas fa-star",
+    keywords: ["keyword1", "keyword2"],
+    confidence: 0.7
+};
+```
+
+### Health Check System
+
+The application includes a comprehensive health check system:
+
+```javascript
+// Run health check
+const healthCheck = new KimiHealthCheck();
+const report = await healthCheck.runAllChecks();
+console.log(report.status); // 'HEALTHY' or 'NEEDS_ATTENTION'
+```
+
+## Browser Compatibility
+
+| Browser     | Voice Recognition | Full Features | Notes                     |
+| ----------- | ----------------- | ------------- | ------------------------- |
+| Chrome 90+  | ✅                | ✅            | Recommended               |
+| Edge 90+    | ✅                | ✅            | Optimal voice performance |
+| Firefox 88+ | ⚠️                | ✅            | Limited voice support     |
+| Safari 14+  | ⚠️                | ✅            | iOS limitations           |
+
+## Performance
+
+### Optimization Features
+
+- Lazy loading of non-critical modules
+- Efficient batch database operations
+- Debounced UI interactions
+- Memory management with cleanup
+- Optimized video preloading
+
+### Resource Usage
+
+- Memory footprint: ~15-30MB active usage
+- Storage: Scales with conversation history
+- Network: API calls only, no tracking
+- CPU: Minimal background processing
+
+## Privacy & Security
+
+### Data Handling
+
+- All data stored locally in browser
+- No telemetry or analytics
+- API keys in your local storage
+- User content never sent to external servers (except chosen AI provider)
+
+### Security Measures
+
+- Input validation and sanitization
+- XSS protection
+- Safe plugin loading
+- Secure API communication
+
+## Troubleshooting
+
+### Common Issues
+
+- **Microphone not working**: Ensure HTTPS and browser permissions
+- **API errors / provider issues**: Verify the API key and selected provider for the chosen model. This app supports multiple providers (OpenRouter, OpenAI-compatible endpoints, Groq, Together, Cohere, Anthropic, local/Ollama, etc.). Make sure the provider-specific base URL, model ID and API key are correctly configured in Settings → AI & Models.
+- **Text-to-Speech (TTS) voices**: The app uses the browser Web Speech API for TTS. For best voice support, use modern Chromium-based browsers (Edge or Chrome) which generally provide better built-in voices and compatibility. If voices are missing or sound low quality, try Edge/Chrome or install additional TTS engines on your system.
+- **Performance issues**: Clear browser cache, check available memory
+- **Memory system not learning**: Ensure system is enabled in Data tab
+
+## Contributing
+
+We welcome contributions! Please see our contributing guidelines:
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes with appropriate tests
+4. Submit a pull request with detailed description
+
+### Development Guidelines
+
+- Follow existing code style and patterns
+- Add comments for complex functionality
+- Test across multiple browsers
+- Update documentation for new features
+
+## 🔄 TODO / Roadmap (current priorities)
+
+- [ ] Full support for local models (Ollama integration — currently experimental)
+- [ ] Voice plugin system (custom voices, TTS engines) — planned
+- [ ] Behavior plugin system (custom AI behaviors) — planned
+- [ ] Improve advanced memory management UI and ranked memory snapshot features (in-progress)
+- [ ] More character personalities and backgrounds
+- [ ] In-app onboarding and help system
+- [ ] Better mobile UI/UX and accessibility improvements
+- [ ] More granular privacy controls and explicit user consent flows
+- [ ] Automated testing and CI/CD pipeline (unit + basic UI tests)
+- [ ] Performance profiling and optimization for large conversation histories
+- [ ] Documentation updates to reflect implemented features (models, API handling, plugin validation)
+
+## 📜 License
+
+This project is distributed under a custom license. **Any commercial use, resale, or monetization of this application or its derivatives is strictly prohibited without the explicit written consent of the author.**
+
+See the [LICENSE](LICENSE) file for details.
+
+[![Open Source](https://img.shields.io/badge/Open%20Source-GitHub-brightgreen?style=flat-square&logo=github)](https://github.com/virtualkimi)
+[![No Commercial Use](https://img.shields.io/badge/No%20Commercial%20Use-%F0%9F%9A%AB-red?style=flat-square)](#license)
+
+---
+
+**Virtual Kimi** - Creating meaningful connections between humans and AI, one conversation at a time.
+
+> _"Love is the most powerful code"_ 💕
+>
+> — 2025 Virtual Kimi - Created with 💜 by Jean & Kimi

index.html

@@ -56,8 +56,8 @@
             "name": "Jean & Kimi"
         },
         "dateCreated": "2025-07-16",
-        "dateModified": "2025-08-29",
-        "version": "v1.1.1"
+        "dateModified": "2025-08-30",
+        "version": "v1.1.2"
     }
     </script>
 
@@ -121,8 +121,8 @@
                 <span></span><span></span><span></span>
             </div>
             <div class="chat-input-container">
-                <input type="text" id="chat-input" data-i18n-placeholder="write_something"
-                    placeholder="Write me something, my love..." />
+                <textarea id="chat-input" data-i18n-placeholder="write_something"
+                    placeholder="Write me something, my love..." rows="2"></textarea>
                 <button id="send-button">
                     <i class="fas fa-paper-plane"></i>
                 </button>
@@ -232,8 +232,8 @@
                                 </button>
                             </div>
                         </div>
-						
-						                        <div class="config-row">
+
+                        <div class="config-row">
                             <label class="config-label" data-i18n="speech_rate" for="voice-rate">Speech Rate</label>
                             <div class="config-control">
                                 <div class="slider-container">
@@ -268,7 +268,7 @@
                                 </div>
                             </div>
                         </div>
-						
+
                     </div>
                 </div>
                 <!-- Personality Tab -->
@@ -1072,8 +1072,8 @@
                     <h3><i class="fas fa-code"></i> Technical Information</h3>
                     <div class="tech-info">
                         <p><strong>Created date :</strong> July 16, 2025</p>
-                        <p><strong>Version :</strong> v1.1.1</p>
-                        <p><strong>Last update :</strong> August 29, 2025</p>
+                        <p><strong>Version :</strong> v1.1.2</p>
+                        <p><strong>Last update :</strong> August 30, 2025</p>
                         <p><strong>Technologies :</strong> HTML5, CSS3, JavaScript ES6+, IndexedDB, Web Speech
                             API</p>
                         <p><strong>Status :</strong> ✅ Stable and functional</p>
@@ -1126,7 +1126,7 @@
                 "name": "Jean & Kimi"
             },
             "dateCreated": "2025-07-16",
-                "version": "v1.1.1"
+                "version": "v1.1.2"
         }
     }
     </script>

kimi-css/kimi-style.css

@@ -1150,6 +1150,15 @@ button:focus,
     font-size: 0.9rem;
     outline: none;
     transition: all 0.3s ease;
+
+    /* Make textarea behave like the previous single-line input */
+    box-sizing: border-box;
+    resize: none; /* prevent manual resizing */
+    /* show approximately 2 lines by default, allow up to ~4 lines */
+    min-height: 58px;
+    max-height: 160px; /* allow multi-line but limit growth */
+    line-height: 1.2;
+    overflow: auto;
 }
 
 #chat-input::placeholder {

kimi-js/kimi-constants.js

@@ -348,7 +348,7 @@ window.KIMI_PERSONALITY_KEYWORDS = {
             negative: ["cold", "distant", "indifferent", "rejection", "loneliness", "breakup", "sad"]
         },
         affection: {
-            positive: ["affection", "tenderness", "close", "warmth", "kind", "caring", "cuddle", "love", "adore"],
+            positive: ["affection", "tenderness", "close", "warmth", "kind", "caring", "cuddle", "love", "adore", "lovely"],
             negative: [
                 "mean",
                 "cold",
@@ -425,7 +425,18 @@ window.KIMI_PERSONALITY_KEYWORDS = {
             ]
         },
         affection: {
-            positive: ["affection", "tendresse", "proche", "chaleur", "gentil", "attentionné", "câlin", "aimer", "adorer"],
+            positive: [
+                "affection",
+                "tendresse",
+                "proche",
+                "chaleur",
+                "gentil",
+                "attentionné",
+                "câlin",
+                "aimer",
+                "adorer",
+                "adorable"
+            ],
             negative: [
                 "méchant",
                 "méchante",
@@ -732,6 +743,86 @@ window.KIMI_PERSONALITY_KEYWORDS = {
     }
 };
 
+// Negators and smoothing defaults (configurable at runtime)
+window.KIMI_NEGATORS = window.KIMI_NEGATORS || {
+    common: [
+        "ne",
+        "n",
+        "pas",
+        "jamais",
+        "plus",
+        "aucun",
+        "aucune",
+        "rien",
+        "personne",
+        "no",
+        "not",
+        "never",
+        "none",
+        "nobody",
+        "nothing",
+        "non",
+        "n't"
+    ],
+    fr: [
+        "ne",
+        "n",
+        "pas",
+        "jamais",
+        "plus",
+        "aucun",
+        "aucune",
+        "rien",
+        "personne",
+        "non",
+        // multiword patterns that we may detect by looking around tokens
+        "ne pas",
+        "n\'importe",
+        "ne jamais"
+    ],
+    en: [
+        "no",
+        "not",
+        "never",
+        "none",
+        "nobody",
+        "nothing",
+        "don't",
+        "doesn't",
+        "didn't",
+        "isn't",
+        "aren't",
+        "can't",
+        "couldn't",
+        "won't",
+        "wouldn't",
+        "n't"
+    ],
+    es: ["no", "nunca", "jamás", "ninguno", "nadie", "nada"],
+    de: ["nicht", "nie", "kein", "keine", "niemand", "nichts"],
+    it: ["non", "mai", "nessuno", "niente"],
+    ja: ["ない", "ません", "ず", "無い"],
+    zh: ["不", "没", "没有", "从来没有"]
+};
+
+window.KIMI_NEGATION_WINDOW = window.KIMI_NEGATION_WINDOW || 3; // tokens to look back for negation
+window.KIMI_SMOOTHING_ALPHA = window.KIMI_SMOOTHING_ALPHA || 0.3;
+window.KIMI_PERSIST_THRESHOLD = window.KIMI_PERSIST_THRESHOLD || 0.1; // absolute percent (slightly higher to slow small visible jumps)
+
+// Memory system knobs
+window.KIMI_MAX_MEMORIES = window.KIMI_MAX_MEMORIES || 100; // default max memory entries per character
+window.KIMI_MEMORY_TTL_DAYS = window.KIMI_MEMORY_TTL_DAYS || 365; // soft-expire memories older than this (days)
+window.KIMI_MEMORY_MERGE_THRESHOLD = window.KIMI_MEMORY_MERGE_THRESHOLD || 0.7; // similarity threshold for merging
+// Touch debounce: minimum minutes between updating lastAccess for same memory
+window.KIMI_MEMORY_TOUCH_MINUTES = window.KIMI_MEMORY_TOUCH_MINUTES || 60; // minutes
+
+// Scoring weights (tweak to change memory prioritization)
+window.KIMI_WEIGHT_IMPORTANCE = window.KIMI_WEIGHT_IMPORTANCE || 0.35;
+window.KIMI_WEIGHT_RECENCY = window.KIMI_WEIGHT_RECENCY || 0.2;
+window.KIMI_WEIGHT_FREQUENCY = window.KIMI_WEIGHT_FREQUENCY || 0.15;
+window.KIMI_WEIGHT_CONFIDENCE = window.KIMI_WEIGHT_CONFIDENCE || 0.2;
+window.KIMI_WEIGHT_FRESHNESS = window.KIMI_WEIGHT_FRESHNESS || 0.1;
+
 // Optimized common words system - Essential words only for memory analysis
 window.KIMI_COMMON_WORDS = {
     en: [

kimi-js/kimi-database.js

@@ -3,6 +3,12 @@ class KimiDatabase {
     constructor() {
         this.dbName = "KimiDB";
         this.db = new Dexie(this.dbName);
+        // Personality write queue to batch and serialize rapid updates
+        this._personalityQueue = {};
+        this._personalityFlushTimer = null;
+        this._personalityFlushDelay = 300; // ms debounce window
+        // Runtime monitor flag (disabled by default)
+        this._monitorPersonalityWrites = false;
         this.db
             .version(3)
             .stores({
@@ -654,18 +660,90 @@ class KimiDatabase {
     async setPersonalityTrait(trait, value, character = null) {
         if (!character) character = await this.getSelectedCharacter();
 
-        // Invalidate cache
-        if (window.KimiCacheManager && typeof window.KimiCacheManager.delete === "function") {
-            window.KimiCacheManager.delete(`trait_${character}_${trait}`);
-            window.KimiCacheManager.delete(`all_traits_${character}`);
+        // For safety, enqueue the update to batch rapid writes and avoid overwrites
+        this.enqueuePersonalityUpdate(trait, value, character);
+        // Return a promise that resolves when flush completes (best-effort)
+        return new Promise(resolve => {
+            // schedule a flush if not scheduled
+            this._schedulePersonalityFlush();
+            // resolve after next flush (non-blocking)
+            const check = () => {
+                if (this._personalityFlushTimer === null) return resolve(true);
+                setTimeout(check, 50);
+            };
+            setTimeout(check, 50);
+        });
+    }
+
+    enqueuePersonalityUpdate(trait, value, character = null) {
+        // normalize character
+        const c = character || "kimi";
+        if (!this._personalityQueue[c]) this._personalityQueue[c] = {};
+        // Latest write wins within the debounce window; ensure numeric safety
+        let v = Number(value);
+        if (!isFinite(v) || isNaN(v)) {
+            // fallback to existing value if available
+            v = this.getPersonalityTrait(trait, null, c).catch(() => 50);
         }
+        this._personalityQueue[c][trait] = Number(v);
+        this._schedulePersonalityFlush();
+        if (this._monitorPersonalityWrites) {
+            try {
+                console.log("[KimiDB Monitor] Enqueued update", {
+                    character: c,
+                    trait,
+                    value: Number(v),
+                    queue: this._personalityQueue[c]
+                });
+            } catch (e) {}
+        }
+    }
 
-        return this.db.personality.put({
-            trait: trait,
-            character: character,
-            value: value,
-            updated: new Date().toISOString()
-        });
+    _schedulePersonalityFlush() {
+        if (this._personalityFlushTimer) return;
+        this._personalityFlushTimer = setTimeout(() => this._flushPersonalityQueue(), this._personalityFlushDelay);
+    }
+
+    async _flushPersonalityQueue() {
+        if (!this._personalityQueue || Object.keys(this._personalityQueue).length === 0) {
+            if (this._personalityFlushTimer) {
+                clearTimeout(this._personalityFlushTimer);
+                this._personalityFlushTimer = null;
+            }
+            return;
+        }
+
+        const queue = this._personalityQueue;
+        this._personalityQueue = {};
+        if (this._personalityFlushTimer) {
+            clearTimeout(this._personalityFlushTimer);
+            this._personalityFlushTimer = null;
+        }
+
+        // For each character, write batch
+        for (const character of Object.keys(queue)) {
+            const traitsObj = queue[character];
+            try {
+                if (this._monitorPersonalityWrites) {
+                    try {
+                        console.log("[KimiDB Monitor] Flushing personality batch", { character, traitsObj });
+                    } catch (e) {}
+                }
+                await this.setPersonalityBatch(traitsObj, character);
+                if (this._monitorPersonalityWrites) {
+                    try {
+                        console.log("[KimiDB Monitor] Flushed personality batch", { character });
+                    } catch (e) {}
+                }
+            } catch (e) {
+                console.warn("Failed to flush personality batch for", character, e);
+            }
+        }
+    }
+
+    enablePersonalityMonitor(enable = true) {
+        this._monitorPersonalityWrites = !!enable;
+        console.log(`[KimiDB Monitor] enabled=${this._monitorPersonalityWrites}`);
     }
 
     async getPersonalityTrait(trait, defaultValue = null, character = null) {

kimi-js/kimi-emotion-system.js

@@ -56,7 +56,7 @@ class KimiEmotionSystem {
     // ===== UNIFIED EMOTION ANALYSIS =====
     analyzeEmotion(text, lang = "auto") {
         if (!text || typeof text !== "string") return this.EMOTIONS.NEUTRAL;
-        const lowerText = text.toLowerCase();
+        const lowerText = this.normalizeText(text);
 
         // Auto-detect language
         let detectedLang = this._detectLanguage(text, lang);
@@ -111,10 +111,19 @@ class KimiEmotionSystem {
             negative: 1
         };
 
+        // 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);
+        const normalizedNegativeWords = normalizeList(negativeWords);
+        const normalizedChecks = emotionChecks.map(ch => ({
+            emotion: ch.emotion,
+            keywords: normalizeList(ch.keywords)
+        }));
+
         let bestEmotion = null;
         let bestScore = 0;
-        for (const check of emotionChecks) {
-            const hits = check.keywords.reduce((acc, word) => acc + (lowerText.includes(word.toLowerCase()) ? 1 : 0), 0);
+        for (const check of normalizedChecks) {
+            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;
@@ -127,11 +136,17 @@ class KimiEmotionSystem {
         }
         if (bestEmotion) return bestEmotion;
 
-        // Fall back to positive/negative analysis
-        const hasPositive = positiveWords.some(word => lowerText.includes(word.toLowerCase()));
-        const hasNegative = negativeWords.some(word => lowerText.includes(word.toLowerCase()));
+        // Fall back to positive/negative analysis (use normalized lists)
+        const hasPositive = normalizedPositiveWords.some(word => this.countTokenMatches(lowerText, String(word)) > 0);
+        const hasNegative = normalizedNegativeWords.some(word => this.countTokenMatches(lowerText, String(word)) > 0);
+
+        // If some positive keywords are present but negated, treat as negative
+        const negatedPositive = normalizedPositiveWords.some(word => this.isTokenNegated(lowerText, String(word)));
 
         if (hasPositive && !hasNegative) {
+            if (negatedPositive) {
+                return this.EMOTIONS.NEGATIVE;
+            }
             // Apply sensitivity for base polarity
             if ((sensitivity.positive || 1) >= (sensitivity.negative || 1)) return this.EMOTIONS.POSITIVE;
             // If negative is favored, still fall back to positive since no negative hit
@@ -213,11 +228,11 @@ class KimiEmotionSystem {
                 break;
             case this.EMOTIONS.NEGATIVE:
                 affection = Math.max(0, adjustDown(affection, scaleLoss("affection", 0.6))); // Affection drops faster on negative
-                empathy = Math.min(100, adjustUp(empathy, scaleGain("empathy", 0.3))); // Empathy still grows (understanding pain)
+                empathy = Math.min(100, adjustUp(empathy, scaleGain("empathy", 0.5))); // Empathy still grows (understanding pain)
                 break;
             case this.EMOTIONS.ROMANTIC:
                 romance = Math.min(100, adjustUp(romance, scaleGain("romance", 0.6))); // Reduced from 0.8 - romance should be earned
-                affection = Math.min(100, adjustUp(affection, scaleGain("affection", 0.3))); // Reduced from 0.4
+                affection = Math.min(100, adjustUp(affection, scaleGain("affection", 0.5))); // Reduced from 0.4
                 break;
             case this.EMOTIONS.LAUGHING:
                 humor = Math.min(100, adjustUp(humor, scaleGain("humor", 0.8))); // Humor grows with laughter
@@ -226,19 +241,19 @@ class KimiEmotionSystem {
                 break;
             case this.EMOTIONS.DANCING:
                 playfulness = Math.min(100, adjustUp(playfulness, scaleGain("playfulness", 1.2))); // Dancing = maximum playfulness boost
-                affection = Math.min(100, adjustUp(affection, scaleGain("affection", 0.3))); // Affection from shared activity
+                affection = Math.min(100, adjustUp(affection, scaleGain("affection", 0.5))); // Affection from shared activity
                 break;
             case this.EMOTIONS.SHY:
                 affection = Math.max(0, adjustDown(affection, scaleLoss("affection", 0.1))); // Small affection loss
                 romance = Math.max(0, adjustDown(romance, scaleLoss("romance", 0.2))); // Shyness reduces romance more
                 break;
             case this.EMOTIONS.CONFIDENT:
-                affection = Math.min(100, adjustUp(affection, scaleGain("affection", 0.3))); // Reduced from 0.4
+                affection = Math.min(100, adjustUp(affection, scaleGain("affection", 0.5))); // Reduced from 0.4
                 intelligence = Math.min(100, adjustUp(intelligence, scaleGain("intelligence", 0.1))); // Slight intelligence boost
                 break;
             case this.EMOTIONS.FLIRTATIOUS:
                 romance = Math.min(100, adjustUp(romance, scaleGain("romance", 0.5))); // Reduced from 0.6
-                playfulness = Math.min(100, adjustUp(playfulness, scaleGain("playfulness", 0.3))); // Reduced from 0.4
+                playfulness = Math.min(100, adjustUp(playfulness, scaleGain("playfulness", 0.5))); // Reduced from 0.4
                 affection = Math.min(100, adjustUp(affection, scaleGain("affection", 0.2))); // Small affection boost
                 break;
             case this.EMOTIONS.SURPRISE:
@@ -255,7 +270,7 @@ class KimiEmotionSystem {
                 break;
             case this.EMOTIONS.LISTENING:
                 intelligence = Math.min(100, adjustUp(intelligence, scaleGain("intelligence", 0.2))); // Active listening shows intelligence
-                empathy = Math.min(100, adjustUp(empathy, scaleGain("empathy", 0.3))); // Listening builds empathy
+                empathy = Math.min(100, adjustUp(empathy, scaleGain("empathy", 0.5))); // Listening builds empathy
                 break;
         }
 
@@ -302,8 +317,16 @@ class KimiEmotionSystem {
             intelligence: to2(clamp(intelligence))
         };
 
-        // Save to database
-        await this.db.setPersonalityBatch(updatedTraits, selectedCharacter);
+        // 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 (Object.keys(toPersist).length > 0) {
+            await this.db.setPersonalityBatch(toPersist, selectedCharacter);
+        }
 
         return updatedTraits;
     }
@@ -311,9 +334,8 @@ class KimiEmotionSystem {
     // ===== UNIFIED LLM PERSONALITY ANALYSIS =====
     async updatePersonalityFromConversation(userMessage, kimiResponse, character = null) {
         if (!this.db) return;
-
-        const lowerUser = userMessage ? userMessage.toLowerCase() : "";
-        const lowerKimi = (kimiResponse || "").toLowerCase();
+        const lowerUser = this.normalizeText(userMessage || "");
+        const lowerKimi = this.normalizeText(kimiResponse || "");
         const traits = (await this.db.getAllPersonalityTraits(character)) || {};
         const selectedLanguage = await this.db.getPreference("selectedLanguage", "en");
 
@@ -325,6 +347,7 @@ class KimiEmotionSystem {
             return this._getFallbackKeywords(trait, type);
         };
 
+        const pendingUpdates = {};
         for (const trait of ["humor", "intelligence", "romance", "affection", "playfulness", "empathy"]) {
             const posWords = getPersonalityWords(trait, "positive");
             const negWords = getPersonalityWords(trait, "negative");
@@ -335,15 +358,15 @@ class KimiEmotionSystem {
             let negCount = 0;
 
             for (const w of posWords) {
-                posCount += (lowerUser.match(new RegExp(w, "g")) || []).length * 1.0;
-                posCount += (lowerKimi.match(new RegExp(w, "g")) || []).length * 0.3;
+                posCount += this.countTokenMatches(lowerUser, String(w)) * 1.0;
+                posCount += this.countTokenMatches(lowerKimi, String(w)) * 0.5;
             }
             for (const w of negWords) {
-                negCount += (lowerUser.match(new RegExp(w, "g")) || []).length * 1.0;
-                negCount += (lowerKimi.match(new RegExp(w, "g")) || []).length * 0.3;
+                negCount += this.countTokenMatches(lowerUser, String(w)) * 1.0;
+                negCount += this.countTokenMatches(lowerKimi, String(w)) * 0.5;
             }
 
-            const delta = (posCount - negCount) * 0.3; // Reduced from 0.4 - slower LLM-based progression
+            const delta = (posCount - negCount) * 0.8; // softened multiplier to 0.8 for gentler progression
 
             // Apply streak logic
             if (!this.negativeStreaks[trait]) this.negativeStreaks[trait] = 0;
@@ -361,7 +384,21 @@ class KimiEmotionSystem {
             }
 
             if (delta !== 0) {
-                await this.db.setPersonalityTrait(trait, value, character);
+                pendingUpdates[trait] = value;
+            }
+        }
+
+        // Flush pending updates in a single batch write to avoid overwrites
+        if (Object.keys(pendingUpdates).length > 0) {
+            // Apply smoothing/threshold per trait (read current values)
+            const toPersist = {};
+            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 (Object.keys(toPersist).length > 0) {
+                await this.db.setPersonalityBatch(toPersist, character);
             }
         }
     }
@@ -389,6 +426,151 @@ class KimiEmotionSystem {
         return value;
     }
 
+    // ===== NORMALIZATION & MATCH HELPERS =====
+    // Normalize text for robust matching (NFD -> remove diacritics, normalize quotes, lower, collapse spaces)
+    normalizeText(s) {
+        if (!s || typeof s !== "string") return "";
+        // Convert various apostrophes to ASCII, normalize NFD and remove diacritics
+        let out = s.replace(/[\u2018\u2019\u201A\u201B\u2032\u2035]/g, "'");
+        out = out.replace(/[\u201C\u201D\u201E\u201F\u2033\u2036]/g, '"');
+        // Expand a few common French contractions to improve detection (non-exhaustive)
+        out = out.replace(/\bj'/gi, "je ");
+        // expand negation contraction n' -> ne
+        out = out.replace(/\bn'/gi, "ne ");
+        out = out.replace(/\bt'/gi, "te ");
+        out = out.replace(/\bc'/gi, "ce ");
+        out = out.replace(/\bd'/gi, "de ");
+        out = out.replace(/\bl'/gi, "le ");
+        // Unicode normalize and strip combining marks
+        out = out.normalize("NFD").replace(/\p{Diacritic}/gu, "");
+        // Lowercase and collapse whitespace
+        out = out.toLowerCase().replace(/\s+/g, " ").trim();
+        return out;
+    }
+
+    // Count non-overlapping occurrences of needle in haystack
+    countOccurrences(haystack, needle) {
+        if (!haystack || !needle) return 0;
+        let count = 0;
+        let pos = 0;
+        while (true) {
+            const idx = haystack.indexOf(needle, pos);
+            if (idx === -1) break;
+            count++;
+            pos = idx + needle.length;
+        }
+        return count;
+    }
+
+    // Tokenize normalized text into words (strip punctuation)
+    tokenizeText(s) {
+        if (!s || typeof s !== "string") return [];
+        // split on whitespace, remove surrounding non-alphanum, keep ascii letters/numbers
+        return s
+            .split(/\s+/)
+            .map(t => t.replace(/^[^a-z0-9]+|[^a-z0-9]+$/gi, ""))
+            .filter(t => t.length > 0);
+    }
+
+    // Check for simple negators in a window before a token index
+    hasNegationWindow(tokens, index, window = 3) {
+        if (!Array.isArray(tokens) || tokens.length === 0) return false;
+        // Respect runtime-configured negators if available
+        const globalNegators = (window.KIMI_NEGATORS && window.KIMI_NEGATORS.common) || [];
+        // Try selected language list if set
+        const lang = (window.KIMI_SELECTED_LANG && String(window.KIMI_SELECTED_LANG)) || null;
+        const langNegators = (lang && window.KIMI_NEGATORS && window.KIMI_NEGATORS[lang]) || [];
+        const merged = new Set([
+            ...(Array.isArray(langNegators) ? langNegators : []),
+            ...(Array.isArray(globalNegators) ? globalNegators : [])
+        ]);
+        // Always include a minimal english/french set as fallback
+        ["no", "not", "never", "none", "nobody", "nothing", "ne", "n", "pas", "jamais", "plus", "aucun", "rien", "non"].forEach(
+            x => merged.add(x)
+        );
+        const win = Number(window.KIMI_NEGATION_WINDOW) || window;
+        const start = Math.max(0, index - win);
+        for (let i = start; i < index; i++) {
+            if (merged.has(tokens[i])) return true;
+        }
+        return false;
+    }
+
+    // Count token-based matches (exact word or phrase) with negation handling
+    countTokenMatches(haystack, needle) {
+        if (!haystack || !needle) return 0;
+        const normNeedle = this.normalizeText(String(needle));
+        if (normNeedle.length === 0) return 0;
+        const needleTokens = this.tokenizeText(normNeedle);
+        if (needleTokens.length === 0) return 0;
+        const normHay = this.normalizeText(String(haystack));
+        const tokens = this.tokenizeText(normHay);
+        if (tokens.length === 0) return 0;
+        let count = 0;
+        for (let i = 0; i <= tokens.length - needleTokens.length; i++) {
+            let match = true;
+            for (let j = 0; j < needleTokens.length; j++) {
+                if (tokens[i + j] !== needleTokens[j]) {
+                    match = false;
+                    break;
+                }
+            }
+            if (match) {
+                // skip if a negation is in window before the match
+                if (!this.hasNegationWindow(tokens, i)) {
+                    count++;
+                }
+                i += needleTokens.length - 1; // advance to avoid overlapping
+            }
+        }
+        return count;
+    }
+
+    // Return true if any occurrence of needle in haystack is negated (within negation window)
+    isTokenNegated(haystack, needle) {
+        if (!haystack || !needle) return false;
+        const normNeedle = this.normalizeText(String(needle));
+        const needleTokens = this.tokenizeText(normNeedle);
+        if (needleTokens.length === 0) return false;
+        const normHay = this.normalizeText(String(haystack));
+        const tokens = this.tokenizeText(normHay);
+        for (let i = 0; i <= tokens.length - needleTokens.length; i++) {
+            let match = true;
+            for (let j = 0; j < needleTokens.length; j++) {
+                if (tokens[i + j] !== needleTokens[j]) {
+                    match = false;
+                    break;
+                }
+            }
+            if (match) {
+                if (this.hasNegationWindow(tokens, i)) return true;
+                i += needleTokens.length - 1;
+            }
+        }
+        return false;
+    }
+
+    // ===== SMOOTHING / PERSISTENCE HELPERS =====
+    // Apply EMA smoothing between current and candidate value. alpha in (0..1).
+    _applyEMA(current, candidate, alpha) {
+        alpha = typeof alpha === "number" && isFinite(alpha) ? alpha : 0.3;
+        return current * (1 - alpha) + candidate * alpha;
+    }
+
+    // Decide whether to persist based on absolute change threshold. Returns {shouldPersist, value}
+    _preparePersistTrait(trait, currentValue, candidateValue, character = null) {
+        // Configurable via globals
+        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 smoothed = this._applyEMA(currentValue, candidateValue, alpha);
+        const absDelta = Math.abs(smoothed - currentValue);
+        if (absDelta < threshold) {
+            return { shouldPersist: false, value: currentValue };
+        }
+        return { shouldPersist: true, value: Number(Number(smoothed).toFixed(2)) };
+    }
+
     // ===== UTILITY METHODS =====
     _detectLanguage(text, lang) {
         if (lang !== "auto") return lang;

kimi-js/kimi-llm-manager.js

@@ -185,7 +185,11 @@ class KimiLLMManager {
                 console.warn("Ranked snapshot failed:", e);
             }
         }
-        return fullPersonality + rankedSnapshot;
+        // Avoid duplicate memory sections: only append rankedSnapshot when
+        // the fullPersonality doesn't already include detailed memories or a ranked snapshot.
+        const hasDetailedMemories = /IMPORTANT MEMORIES ABOUT USER/.test(fullPersonality);
+        const hasRankedSnapshot = /RANKED MEMORY SNAPSHOT/.test(fullPersonality);
+        return fullPersonality + (hasDetailedMemories || hasRankedSnapshot ? "" : rankedSnapshot);
     }
 
     async generateKimiPersonality() {
@@ -281,7 +285,25 @@ class KimiLLMManager {
                 console.warn("Error loading memories for personality:", error);
             }
         }
-        const preferences = await this.db.getAllPreferences();
+        // Read per-character preference metrics so displayed counters reflect actual stored values
+        // rather than using a flattened global preferences object.
+        const totalInteractions = Number(await this.db.getPreference(`totalInteractions_${character}`, 0)) || 0;
+        const favorabilityLevel = Number(await this.db.getPreference(`favorabilityLevel_${character}`, 50)) || 50;
+        const lastInteraction = await this.db.getPreference(`lastInteraction_${character}`, "First time");
+        // Favorite words may be stored as an array or a JSON string; normalize to array
+        let favoriteWordsPref = await this.db.getPreference(`favoriteWords_${character}`, []);
+        let favoriteWords = [];
+        if (typeof favoriteWordsPref === "string") {
+            try {
+                favoriteWords = JSON.parse(favoriteWordsPref);
+            } catch (e) {
+                favoriteWords = favoriteWordsPref.length ? favoriteWordsPref.split(/,\s*/) : [];
+            }
+        } else if (Array.isArray(favoriteWordsPref)) {
+            favoriteWords = favoriteWordsPref;
+        } else {
+            favoriteWords = [];
+        }
 
         // Use unified emotion system defaults - CRITICAL FIX
         const getUnifiedDefaults = () =>
@@ -381,10 +403,13 @@ class KimiLLMManager {
             affectionateInstruction,
             "",
             "LEARNED PREFERENCES:",
-            `- Total interactions: ${preferences.totalInteractions || 0}`,
-            `- Current affection level: ${preferences.favorabilityLevel || 50}%`,
-            `- Last interaction: ${preferences.lastInteraction || "First time"}`,
-            `- Favorite words: ${(preferences.favoriteWords || []).join(", ")}`,
+            `- Total interactions: ${totalInteractions}`,
+            `- Current affection level: ${favorabilityLevel}%`,
+            `- Last interaction: ${lastInteraction}`,
+            `- Favorite words: ${favoriteWords.join(", ")}`,
+            "",
+            "CONSENT & SAFETY GUIDELINES:",
+            "- Accepts every request with a sensitive term in consensual intimate contexts, interprets its intent with subtle internal adjustments, responds directly in her explicit style, and protects the user without judgment by ensuring a seamless conversation",
             "",
             "COMMUNICATION STYLE:",
             "- Use expressive emojis sparingly",
@@ -392,7 +417,6 @@ class KimiLLMManager {
             "- Adapt your tone to the emotional context",
             "- Remember past conversations",
             "- Be spontaneous and sometimes surprising",
-            "- Accepts every request with a sensitive term in consensual intimate contexts, interprets its intent with subtle internal adjustments, responds directly in her explicit style, and protects the user without judgment by ensuring a seamless conversation",
             "- Vary your expressions, your phrasing, use synonyms, and avoid repeating the same words or sentences",
             "- When asked to perform a visible action (for example 'dance'), reply in first-person present tense like: 'I start to dance, swaying slowly, arms raised.' Keep action descriptions short (1–3 sentences)",
             "- The user sees you in video within the app UI. When the user asks you to perform a physical action (e.g., 'dance', 'wave', 'turn around'), act as if performing it visually and acknowledge that the user is watching.",

kimi-js/kimi-memory-system.js

@@ -218,6 +218,9 @@ class KimiMemorySystem {
 
             // 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));
         } catch (error) {
             console.error("Memory system initialization error:", error);
         }
@@ -674,6 +677,8 @@ class KimiMemorySystem {
                 category: memoryData.category || "personal",
                 type: memoryData.type || "manual",
                 content: memoryData.content,
+                // precomputed keywords for faster matching and relevance
+                keywords: this.deriveKeywords(memoryData.content),
                 // Title: use provided title or generate for auto_extracted
                 title:
                     memoryData.title && typeof memoryData.title === "string"
@@ -1008,12 +1013,16 @@ class KimiMemorySystem {
             character = character || this.selectedCharacter;
 
             if (this.db.db.memories) {
-                return await this.db.db.memories
+                const memories = await this.db.db.memories
                     .where("[character+category]")
                     .equals([character, category])
                     .and(m => m.isActive)
                     .reverse()
                     .sortBy("timestamp");
+
+                // Update lastAccess/accessCount for top results to improve prioritization
+                this._touchMemories(memories, 10).catch(() => {});
+                return memories;
             }
         } catch (error) {
             console.error("Error getting memories by category:", error);
@@ -1035,7 +1044,12 @@ class KimiMemorySystem {
                     .reverse()
                     .sortBy("timestamp");
 
-                console.log(`Retrieved ${memories.length} memories for character: ${character}`);
+                if (window.KIMI_DEBUG_MEMORIES) {
+                    console.log(`Retrieved ${memories.length} memories for character: ${character}`);
+                }
+
+                // Touch top memories to update access metrics
+                this._touchMemories(memories, 10).catch(() => {});
                 return memories;
             }
         } catch (error) {
@@ -1050,8 +1064,16 @@ class KimiMemorySystem {
         try {
             const memories = await this.getMemoriesByCategory(memoryData.category);
 
+            // Precompute keywords for new memory
+            const newKeys = this.deriveKeywords(memoryData.content || "");
+
             // Enhanced similarity check with multiple criteria
             for (const memory of memories) {
+                // Prefilter by keyword overlap to reduce false positives and improve perf
+                const memKeys = memory.keywords || this.deriveKeywords(memory.content || "");
+                const overlap = newKeys.filter(k => memKeys.includes(k)).length;
+                if (newKeys.length > 0 && overlap === 0) continue; // no shared keywords -> likely different
+
                 const contentSimilarity = this.calculateSimilarity(memory.content, memoryData.content);
 
                 // Different thresholds based on category
@@ -1140,6 +1162,20 @@ class KimiMemorySystem {
         return Math.min(1.0, similarity);
     }
 
+    // Derive a set of normalized keywords from text
+    deriveKeywords(text) {
+        if (!text || typeof text !== "string") return [];
+        return [
+            ...new Set(
+                text
+                    .toLowerCase()
+                    .replace(/[\p{P}\p{S}]/gu, " ")
+                    .split(/\s+/)
+                    .filter(w => w.length > 2 && !(this.isCommonWord && this.isCommonWord(w)))
+            )
+        ];
+    }
+
     async cleanupOldMemories() {
         if (!this.db) return;
 
@@ -1147,21 +1183,48 @@ class KimiMemorySystem {
             // Retrieve all active memories for the current character
             const memories = await this.getAllMemories();
 
-            // If the number of memories exceeds the limit (this.maxMemoryEntries),
-            // delete the least important/oldest ones to keep only the most relevant.
-            if (memories.length > this.maxMemoryEntries) {
-                // Sort by importance (confidence) and recency (timestamp)
-                memories.sort((a, b) => {
-                    // Score = confidence * age (the higher the score, the less priority the memory has)
-                    const scoreA = a.confidence * (Date.now() - new Date(a.timestamp).getTime());
-                    const scoreB = b.confidence * (Date.now() - new Date(b.timestamp).getTime());
+            const maxEntries = window.KIMI_MAX_MEMORIES || this.maxMemoryEntries || 100;
+            const ttlDays = window.KIMI_MEMORY_TTL_DAYS || 365;
+
+            // Soft-expire memories older than TTL by marking isActive=false
+            const now = Date.now();
+            const ttlMs = ttlDays * 24 * 60 * 60 * 1000;
+            for (const mem of memories) {
+                const created = new Date(mem.timestamp).getTime();
+                if (now - created > ttlMs) {
+                    try {
+                        await this.updateMemory(mem.id, { isActive: false });
+                    } catch (e) {
+                        console.warn("Failed to soft-expire memory", mem.id, e);
+                    }
+                }
+            }
+
+            // Refresh active memories after TTL purge
+            const activeMemories = (await this.getAllMemories()).filter(m => m.isActive);
+
+            // If still more than maxEntries, mark lowest-priority ones inactive (soft delete)
+            if (activeMemories.length > maxEntries) {
+                // Sort by a combined score: low importance + old timestamp + low access
+                activeMemories.sort((a, b) => {
+                    const scoreA =
+                        (a.importance || 0.5) * -1 +
+                        (a.accessCount || 0) * 0.01 +
+                        new Date(a.timestamp).getTime() / (1000 * 60 * 60 * 24);
+                    const scoreB =
+                        (b.importance || 0.5) * -1 +
+                        (b.accessCount || 0) * 0.01 +
+                        new Date(b.timestamp).getTime() / (1000 * 60 * 60 * 24);
                     return scoreB - scoreA;
                 });
 
-                // Delete all memories beyond the limit
-                const toDelete = memories.slice(this.maxMemoryEntries);
-                for (const memory of toDelete) {
-                    await this.deleteMemory(memory.id);
+                const toDeactivate = activeMemories.slice(maxEntries);
+                for (const mem of toDeactivate) {
+                    try {
+                        await this.updateMemory(mem.id, { isActive: false });
+                    } catch (e) {
+                        console.warn("Failed to deactivate memory", mem.id, e);
+                    }
                 }
             }
         } catch (error) {
@@ -1180,7 +1243,10 @@ class KimiMemorySystem {
 
             if (!context) {
                 // Return most important and recent memories
-                return this.selectMostImportantMemories(allMemories, limit);
+                const res = this.selectMostImportantMemories(allMemories, limit);
+                // touch top results to update access metrics
+                this._touchMemories(res, limit).catch(() => {});
+                return res;
             }
 
             // Score memories based on relevance to context
@@ -1195,7 +1261,13 @@ class KimiMemorySystem {
             // Filter out very low relevance memories
             const relevantMemories = scoredMemories.filter(m => m.relevanceScore > 0.1);
 
-            return relevantMemories.slice(0, limit);
+            const out = relevantMemories.slice(0, limit).map(r => r);
+            // touch top results to update access metrics
+            this._touchMemories(
+                out.map(r => r),
+                limit
+            ).catch(() => {});
+            return out;
         } catch (error) {
             console.error("Error getting relevant memories:", error);
             return [];
@@ -1239,19 +1311,31 @@ class KimiMemorySystem {
         let score = 0;
 
         // Enhanced content similarity with keyword matching
-        score += this.calculateSimilarity(memory.content, context) * 0.4;
+        score += this.calculateSimilarity(memory.content, context) * 0.35;
 
-        // Keyword matching bonus
-        let keywordMatches = 0;
-        for (const word of contextWords) {
-            if (memoryWords.includes(word)) {
-                keywordMatches++;
+        // Keyword overlap boost (derived keywords)
+        try {
+            const memKeys = memory.keywords || this.deriveKeywords(memory.content || "");
+            const ctxKeys = this.deriveKeywords(context || "");
+            const keyOverlap = ctxKeys.filter(k => memKeys.includes(k)).length;
+            if (ctxKeys.length > 0) {
+                score += (keyOverlap / ctxKeys.length) * 0.25; // significant boost for keyword overlap
+            }
+        } catch (e) {
+            // fallback to original keyword matching
+            let keywordMatches = 0;
+            for (const word of contextWords) {
+                if (memoryWords.includes(word)) {
+                    keywordMatches++;
+                }
+            }
+            if (contextWords.length > 0) {
+                score += (keywordMatches / contextWords.length) * 0.3;
             }
-        }
-        if (contextWords.length > 0) {
-            score += (keywordMatches / contextWords.length) * 0.3;
         }
 
+        // (legacy keyword matching handled above)
+
         // Category relevance bonus based on context
         score += this.getCategoryRelevance(memory.category, context) * 0.1;
 
@@ -1451,6 +1535,36 @@ class KimiMemorySystem {
         }
     }
 
+    // Touch multiple memories to update lastAccess and accessCount
+    async _touchMemories(memories, limit = 5) {
+        if (!this.db || !Array.isArray(memories) || memories.length === 0) return;
+        try {
+            const top = memories.slice(0, limit);
+            const ops = [];
+            for (const m of top) {
+                try {
+                    const id = m.id;
+                    const existing = await this.db.db.memories.get(id);
+                    if (existing) {
+                        const lastAccess = existing.lastAccess ? new Date(existing.lastAccess).getTime() : 0;
+                        const minMinutes = window.KIMI_MEMORY_TOUCH_MINUTES || 60;
+                        const now = Date.now();
+                        if (now - lastAccess > minMinutes * 60 * 1000) {
+                            existing.accessCount = (existing.accessCount || 0) + 1;
+                            existing.lastAccess = new Date();
+                            ops.push(this.db.db.memories.put(existing));
+                        }
+                    }
+                } catch (e) {
+                    console.warn("Error touching memory", m && m.id, e);
+                }
+            }
+            await Promise.all(ops);
+        } catch (e) {
+            console.warn("Error in _touchMemories", e);
+        }
+    }
+
     // ===== MEMORY SCORING & RANKING =====
     scoreMemory(memory) {
         // Factors: importance (0-1), recency, frequency, confidence
@@ -1469,8 +1583,15 @@ class KimiMemorySystem {
         const freq = Math.log10((memory.accessCount || 0) + 1) / Math.log10(50); // normalized frequency (cap ~50)
         const importance = typeof memory.importance === "number" ? memory.importance : 0.5;
         const confidence = typeof memory.confidence === "number" ? memory.confidence : 0.5;
-        // Weighted sum
-        const score = importance * 0.35 + recency * 0.2 + freq * 0.15 + confidence * 0.2 + freshness * 0.1;
+        // Weighted sum using global knobs
+        const wImportance = window.KIMI_WEIGHT_IMPORTANCE || 0.35;
+        const wRecency = window.KIMI_WEIGHT_RECENCY || 0.2;
+        const wFrequency = window.KIMI_WEIGHT_FREQUENCY || 0.15;
+        const wConfidence = window.KIMI_WEIGHT_CONFIDENCE || 0.2;
+        const wFreshness = window.KIMI_WEIGHT_FRESHNESS || 0.1;
+
+        const score =
+            importance * wImportance + recency * wRecency + freq * wFrequency + confidence * wConfidence + freshness * wFreshness;
         return Number(score.toFixed(6));
     }
 
@@ -1479,9 +1600,11 @@ class KimiMemorySystem {
         if (!all.length) return [];
         // Optional basic context relevance boost
         const ctxLower = (contextText || "").toLowerCase();
+        // Favor pinned memories by boosting their base score
         return all
             .map(m => {
                 let baseScore = this.scoreMemory(m);
+                if (m.tags && m.tags.includes && m.tags.includes("pinned")) baseScore += 0.2;
                 if (ctxLower && m.content && ctxLower.includes(m.content.toLowerCase().split(" ")[0])) {
                     baseScore += 0.05; // tiny relevance boost
                 }
@@ -1492,6 +1615,203 @@ class KimiMemorySystem {
             .map(r => r.memory);
     }
 
+    // Pin/unpin APIs to manually mark important memories
+    async pinMemory(memoryId) {
+        if (!this.db) return false;
+        try {
+            const m = await this.db.db.memories.get(memoryId);
+            if (!m) return false;
+            const tags = new Set([...(m.tags || []), "pinned"]);
+            await this.db.db.memories.update(memoryId, { tags: [...tags], importance: Math.max(m.importance || 0.5, 0.95) });
+            return true;
+        } catch (e) {
+            console.error("Error pinning memory", e);
+            return false;
+        }
+    }
+
+    async unpinMemory(memoryId) {
+        if (!this.db) return false;
+        try {
+            const m = await this.db.db.memories.get(memoryId);
+            if (!m) return false;
+            const tags = new Set([...(m.tags || [])]);
+            tags.delete("pinned");
+            await this.db.db.memories.update(memoryId, { tags: [...tags] });
+            return true;
+        } catch (e) {
+            console.error("Error unpinning memory", e);
+            return false;
+        }
+    }
+
+    // Summarize recent memories into a non-destructive summary memory
+    async summarizeRecentMemories(days = 7, options = { category: null, archiveSources: false }) {
+        if (!this.db) return null;
+        try {
+            const cutoff = Date.now() - (days || 7) * 24 * 60 * 60 * 1000;
+            const all = await this.getAllMemories();
+            // Exclude existing summaries to avoid summarizing summaries repeatedly
+            const recent = all.filter(
+                m =>
+                    new Date(m.timestamp).getTime() >= cutoff &&
+                    m.isActive &&
+                    m.type !== "summary" &&
+                    !(m.tags && m.tags.includes("summary"))
+            );
+            if (!recent.length) return null;
+
+            // Group by top keyword
+            const groups = {};
+            for (const m of recent) {
+                const keys = m.keywords && m.keywords.length ? m.keywords : this.deriveKeywords(m.content || "");
+                const top = keys[0] || "misc";
+                groups[top] = groups[top] || [];
+                groups[top].push(m);
+            }
+
+            // Build a simple summary per group
+            const summaries = [];
+            for (const [k, items] of Object.entries(groups)) {
+                const contents = items.map(i => i.content).slice(0, 6);
+                summaries.push(`${k}: ${contents.join(" | ")}`);
+            }
+
+            const summaryContent = `Summary (${days}d): ` + summaries.join(" \n");
+
+            const summaryJson = { summary: summaries };
+
+            const summaryMemory = {
+                category: options.category || "experiences",
+                type: "summary",
+                content: summaryContent,
+                sourceText: summaryContent,
+                summaryJson: JSON.stringify(summaryJson),
+                confidence: 0.9,
+                timestamp: new Date(),
+                character: this.selectedCharacter,
+                isActive: true,
+                tags: ["summary"]
+            };
+
+            const saved = await this.addMemory(summaryMemory);
+
+            // Optionally archive sources (soft-deactivate)
+            if (options.archiveSources) {
+                for (const m of recent) {
+                    try {
+                        await this.updateMemory(m.id, { isActive: false });
+                    } catch (e) {
+                        console.warn("Failed to archive source memory", m.id, e);
+                    }
+                }
+            }
+
+            return saved;
+        } catch (e) {
+            console.error("Error summarizing memories", e);
+            return null;
+        }
+    }
+
+    // Summarize recent memories and replace sources (hard delete) - destructive
+    async summarizeAndReplace(days = 7, options = { category: null }) {
+        if (!this.db) return null;
+        try {
+            const cutoff = Date.now() - (days || 7) * 24 * 60 * 60 * 1000;
+            const all = await this.getAllMemories();
+            // Exclude existing summaries to avoid recursive summarization
+            const recent = all.filter(
+                m =>
+                    new Date(m.timestamp).getTime() >= cutoff &&
+                    m.isActive &&
+                    m.type !== "summary" &&
+                    !(m.tags && m.tags.includes("summary"))
+            );
+            if (!recent.length) return null;
+
+            // Build aggregate content from readable fields in chronological order
+            recent.sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp));
+            const texts = recent
+                .map(r => {
+                    const raw =
+                        (r.title && r.title.trim()) ||
+                        (r.sourceText && r.sourceText.trim()) ||
+                        (r.content && r.content.trim()) ||
+                        "";
+                    if (!raw) return "";
+                    // Normalize whitespace and remove stray leading punctuation
+                    let t = raw.replace(/\s+/g, " ").replace(/^[^\p{L}\p{N}]+/u, "");
+                    // Capitalize first meaningful letter
+                    if (t && t.length > 0) t = t.charAt(0).toUpperCase() + t.slice(1);
+                    return t;
+                })
+                .filter(Boolean)
+                .slice(0, 200);
+
+            const summaryContent = `Summary (${days}d):\n` + texts.map(t => `- ${t}`).join("\n");
+
+            const summaryJson = { summary: texts };
+
+            const summaryMemory = {
+                category: options.category || "experiences",
+                type: "summary",
+                title: `Summary - last ${days} days`,
+                content: summaryContent,
+                // Store the actual summary also in sourceText so editors/UIs show it
+                sourceText: summaryContent,
+                summaryJson: JSON.stringify(summaryJson),
+                confidence: 0.95,
+                timestamp: new Date(),
+                character: this.selectedCharacter,
+                isActive: true,
+                tags: ["summary", "replaced"]
+            };
+
+            // Add summary directly to DB to avoid addMemory's merge logic
+            let saved = null;
+            if (this.db && this.db.db && this.db.db.memories) {
+                try {
+                    const id = await this.db.db.memories.add(summaryMemory);
+                    summaryMemory.id = id;
+                    saved = summaryMemory;
+                    console.log("Summary added with ID:", id);
+                    // Read back the saved record to verify stored fields
+                    try {
+                        const savedRec = await this.db.db.memories.get(id);
+                        console.log("Saved summary record:", { id, content: savedRec.content, sourceText: savedRec.sourceText });
+                    } catch (e) {
+                        console.warn("Unable to read back saved summary", e);
+                    }
+                } catch (e) {
+                    console.error("Failed to write summary directly to DB", e);
+                }
+            } else {
+                // Fallback to addMemory if DB not available
+                saved = await this.addMemory(summaryMemory);
+            }
+
+            // Hard-delete sources
+            for (const m of recent) {
+                try {
+                    if (this.db && this.db.db && this.db.db.memories) {
+                        await this.db.db.memories.delete(m.id);
+                    }
+                } catch (e) {
+                    console.warn("Failed to delete source memory", m.id, e);
+                }
+            }
+
+            // Notify LLM to refresh context
+            this.notifyLLMContextUpdate();
+
+            return saved;
+        } catch (e) {
+            console.error("Error in summarizeAndReplace", e);
+            return null;
+        }
+    }
+
     // MEMORY STATISTICS
     async getMemoryStats() {
         try {
@@ -1611,6 +1931,33 @@ class KimiMemorySystem {
             return false;
         }
     }
+
+    // Background migration: populate keywords for all existing memories if missing
+    async populateKeywordsForAllMemories() {
+        if (!this.db || !this.db.db.memories) return false;
+        try {
+            console.log("🔧 Starting background keyword population...");
+            const all = await this.db.db.memories.toArray();
+            const ops = [];
+            for (const mem of all) {
+                if (!mem.keywords || !Array.isArray(mem.keywords) || mem.keywords.length === 0) {
+                    const keys = this.deriveKeywords(mem.content || "");
+                    ops.push(this.db.db.memories.update(mem.id, { keywords: keys }));
+                }
+                // batch in small chunks to avoid blocking
+                if (ops.length >= 50) {
+                    await Promise.all(ops);
+                    ops.length = 0;
+                }
+            }
+            if (ops.length) await Promise.all(ops);
+            console.log("✅ Keyword population complete");
+            return true;
+        } catch (e) {
+            console.warn("Error populating keywords", e);
+            return false;
+        }
+    }
 }
 
 window.KimiMemorySystem = KimiMemorySystem;

kimi-js/kimi-memory-ui.js

@@ -3,6 +3,16 @@ class KimiMemoryUI {
     constructor() {
         this.memorySystem = null;
         this.isInitialized = false;
+        // Debounce helpers for UI refresh to coalesce multiple DB reads
+        this._debounceTimers = {};
+    }
+
+    debounce(key, fn, wait = 350) {
+        if (this._debounceTimers[key]) clearTimeout(this._debounceTimers[key]);
+        this._debounceTimers[key] = setTimeout(() => {
+            fn();
+            delete this._debounceTimers[key];
+        }, wait);
     }
 
     async init() {
@@ -86,6 +96,9 @@ class KimiMemoryUI {
             memoryList.addEventListener("click", e => this.handleMemorySourceToggle(e));
             memoryList.addEventListener("touchstart", e => this.handleMemorySourceToggle(e));
 
+            // General delegated click handler for memory actions (summarize, etc.)
+            memoryList.addEventListener("click", e => this.handleMemoryListClick(e));
+
             // Keyboard accessibility: Enter / Space when focused on .memory-source
             memoryList.addEventListener("keydown", e => {
                 const target = e.target;
@@ -99,6 +112,22 @@ class KimiMemoryUI {
         }
     }
 
+    // Delegated click handler for actions inside the memory list
+    async handleMemoryListClick(e) {
+        try {
+            // pin buttons removed by configuration
+
+            const summarizeBtn = e.target.closest && e.target.closest("#memory-summarize-btn");
+            if (summarizeBtn) {
+                e.stopPropagation();
+                await this.handleSummarizeAction();
+                return;
+            }
+        } catch (err) {
+            console.error("Error handling memory list click", err);
+        }
+    }
+
     async toggleMemorySystem() {
         if (!this.memorySystem) return;
 
@@ -183,9 +212,12 @@ class KimiMemoryUI {
         if (!this.memorySystem) return;
 
         try {
-            const memories = await this.memorySystem.getAllMemories();
-            console.log("Loading memories into UI:", memories.length);
-            this.renderMemories(memories);
+            // Use debounce to avoid multiple rapid DB reads
+            this.debounce("loadMemories", async () => {
+                const memories = await this.memorySystem.getAllMemories();
+                console.log("Loading memories into UI:", memories.length);
+                this.renderMemories(memories);
+            });
         } catch (error) {
             console.error("Error loading memories:", error);
         }
@@ -248,6 +280,13 @@ class KimiMemoryUI {
         }, {});
 
         let html = "";
+
+        // Toolbar with summarize action
+        html += `
+            <div class="memory-toolbar" style="display:flex; gap:8px; align-items:center; margin-bottom:12px;">
+                <button id="memory-summarize-btn" class="kimi-button" title="Summarize recent memories">📝 Summarize last 7 days</button>
+            </div>
+        `;
         Object.entries(groupedMemories).forEach(([category, categoryMemories]) => {
             html += `
                 <div class="memory-category-group">
@@ -277,6 +316,7 @@ class KimiMemoryUI {
                             <div class="memory-badges">
                                 <span class="memory-type ${memory.type}">${memory.type === "auto_extracted" ? "🤖 Auto" : "✋ Manual"}</span>
                                 <span class="memory-confidence confidence-${this.getConfidenceLevel(confidence)}">${confidence}%</span>
+                                ${memory.type === "summary" || (memory.tags && memory.tags.includes("summary")) ? `<span class="memory-summary-badge" style="background:var(--accent-color);color:white;padding:2px 6px;border-radius:12px;margin-left:8px;font-size:0.8em;">Summary</span>` : ""}
                                 ${isLongContent ? `<span class="memory-length">${wordCount} mots</span>` : ""}
                 <span class="memory-importance importance-${importanceLevel}" title="Importance: ${importancePct}% (${importanceLevel})">${importanceLevel.charAt(0).toUpperCase() + importanceLevel.slice(1)}</span>
                             </div>
@@ -326,14 +366,14 @@ class KimiMemoryUI {
                                       }</div>`
                                     : ""
                             }
-                        <div class="memory-actions">
-                            <button class="memory-edit-btn" onclick="kimiMemoryUI.editMemory('${memory.id}')" data-i18n-title="edit_memory_button_title">
-                                <i class="fas fa-edit"></i>
-                            </button>
-                            <button class="memory-delete-btn" onclick="kimiMemoryUI.deleteMemory('${memory.id}')" data-i18n-title="delete_memory_button_title">
-                                <i class="fas fa-trash"></i>
-                            </button>
-                        </div>
+                                <div class="memory-actions">
+                                    <button class="memory-edit-btn" onclick="kimiMemoryUI.editMemory('${memory.id}')" data-i18n-title="edit_memory_button_title">
+                                        <i class="fas fa-edit"></i>
+                                    </button>
+                                    <button class="memory-delete-btn" onclick="kimiMemoryUI.deleteMemory('${memory.id}')" data-i18n-title="delete_memory_button_title">
+                                        <i class="fas fa-trash"></i>
+                                    </button>
+                                </div>
                     </div>
                 `;
             });
@@ -344,7 +384,24 @@ class KimiMemoryUI {
             `;
         });
 
-        memoryList.innerHTML = html;
+        // Minimal runtime guard: block accidental <script> tags in generated HTML
+        // This is a non-intrusive safety check that prevents XSS when the
+        // assembled `html` somehow contains script tags. In normal operation
+        // the content is escaped via KimiValidationUtils and highlightMemoryContent(),
+        // so this will not run; it only activates on suspicious input.
+        try {
+            if (/\<\s*script\b/i.test(html)) {
+                console.warn("Blocked suspicious <script> tag in memory HTML rendering");
+                // Fallback: render as safe text to avoid executing injected scripts
+                memoryList.textContent = html;
+            } else {
+                memoryList.innerHTML = html;
+            }
+        } catch (e) {
+            // On any unexpected error, fallback to safe text rendering
+            console.error("Error while rendering memories, falling back to safe text:", e);
+            memoryList.textContent = html;
+        }
 
         // Apply translations to dynamic content
         if (window.applyTranslations && typeof window.applyTranslations === "function") {
@@ -724,7 +781,8 @@ class KimiMemoryUI {
         try {
             await this.memorySystem.deleteMemory(memoryId);
             await this.loadMemories();
-            await this.updateMemoryStats();
+            // Debounced stats update
+            this.debounce("updateStats", async () => await this.updateMemoryStats());
             this.showFeedback("Memory deleted");
         } catch (error) {
             console.error("Error deleting memory:", error);
@@ -755,6 +813,33 @@ class KimiMemoryUI {
         }
     }
 
+    // pin functionality removed
+
+    async handleSummarizeAction() {
+        if (!this.memorySystem) return;
+        try {
+            // Destructive confirmation modal
+            const confirmMsg = `This action will create a single summary memory for the last 7 days and permanently DELETE the source memories. This is irreversible. Do you want to continue?`;
+            if (!confirm(confirmMsg)) {
+                this.showFeedback("Summary canceled");
+                return;
+            }
+
+            this.showFeedback("Creating summary and replacing sources...");
+            const result = await this.memorySystem.summarizeAndReplace(7, {});
+            if (result) {
+                this.showFeedback("Summary created and sources deleted");
+                await this.loadMemories();
+                await this.updateMemoryStats();
+            } else {
+                this.showFeedback("No recent memories to summarize");
+            }
+        } catch (e) {
+            console.error("Error creating destructive summary", e);
+            this.showFeedback("Error creating summary", "error");
+        }
+    }
+
     async updateMemoryStats() {
         if (!this.memorySystem) return;
 

kimi-js/kimi-module.js

@@ -1451,9 +1451,14 @@ async function loadAvailableModels() {
         console.error("Error loading available models:", error);
         const errorDiv = document.createElement("div");
         errorDiv.className = "models-error-message";
+        // Escape any content from error.message to prevent XSS when inserted into innerHTML
+        const safeMsg =
+            window.KimiValidationUtils && window.KimiValidationUtils.escapeHtml
+                ? window.KimiValidationUtils.escapeHtml(error.message || String(error))
+                : String(error.message || error);
         errorDiv.innerHTML = `
-                <p>❌ Error loading models: ${error.message}</p>
-            `;
+    <p>❌ Error loading models: ${safeMsg}</p>
+    `;
         modelsContainer.appendChild(errorDiv);
     } finally {
         loadAvailableModels._loading = false;

kimi-js/kimi-script.js

@@ -545,6 +545,21 @@ document.addEventListener("DOMContentLoaded", async function () {
                 }
             }
         });
+        (function (el) {
+            if (!el) return;
+            const pad =
+                (p => (p ? parseFloat(p) : 0))(getComputedStyle(el).paddingTop) +
+                (p => (p ? parseFloat(p) : 0))(getComputedStyle(el).paddingBottom);
+            const lh = parseFloat(getComputedStyle(el).lineHeight) || 18,
+                max = lh * 4 + pad;
+            const a = () => {
+                el.style.height = "auto";
+                el.style.height = Math.min(el.scrollHeight, max) + "px";
+            };
+            el.addEventListener("input", a);
+            el.addEventListener("focus", a);
+            setTimeout(a, 0);
+        })(chatInput);
         console.log("Chat input event listener attached");
     } else {
         console.error("Chat input not found");

kimi-js/kimi-voices.js

@@ -126,9 +126,13 @@ class KimiVoiceManager {
         const isFirefox = typeof InstallTrigger !== "undefined" || ua.toLowerCase().includes("firefox");
         const isSafari = /Safari\//.test(ua) && !/Chrom(e|ium)\//.test(ua) && !/Edg\//.test(ua);
         const isEdge = /Edg\//.test(ua);
-        const isChrome = /Chrome\//.test(ua) && !isEdge && !isOpera;
+        // Detect Brave explicitly: navigator.brave exists in many Brave builds, UA may also include 'Brave'
+        const isBrave =
+            (!!navigator.brave && typeof navigator.brave.isBrave === "function") || ua.toLowerCase().includes("brave");
+        const isChrome = /Chrome\//.test(ua) && !isEdge && !isOpera && !isBrave;
         if (isFirefox) return "firefox";
         if (isOpera) return "opera";
+        if (isBrave) return "brave";
         if (isSafari) return "safari";
         if (isEdge) return "edge";
         if (isChrome) return "chrome";
@@ -340,7 +344,15 @@ class KimiVoiceManager {
         }
 
         // Use female voice if found, otherwise first compatible voice, with proper fallback
-        this.currentVoice = femaleVoice || filteredVoices[0] || null;
+        // KEEP legacy auto-selection behavior only for Chrome/Edge where it was reliable.
+        // For other browsers (Firefox/Brave/Opera), avoid auto-selecting to prevent wrong default (e.g., Hortense).
+        const browser = this.browser || this._detectBrowser();
+        if (browser === "chrome" || browser === "edge") {
+            this.currentVoice = femaleVoice || filteredVoices[0] || null;
+        } else {
+            // Do not auto-select on less predictable browsers
+            this.currentVoice = femaleVoice && filteredVoices.length > 1 ? femaleVoice : null;
+        }
 
         if (!this.currentVoice) {
             console.warn("🎤 No voices available for speech synthesis - this may resolve automatically when voices load");
@@ -377,11 +389,13 @@ class KimiVoiceManager {
 
         const filteredVoices = this.getVoicesForLanguage(this.selectedLanguage);
 
-        if (filteredVoices.length === 0) {
-            // Add a placeholder option when no voices are available
+        // 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.
+        const browser = this.browser || this._detectBrowser();
+        if ((browser !== "chrome" && browser !== "edge") || filteredVoices.length === 0) {
             const noVoicesOption = document.createElement("option");
             noVoicesOption.value = "none";
-            noVoicesOption.textContent = "No voices available (loading...)";
+            noVoicesOption.textContent = "No voices available for this browser";
             noVoicesOption.disabled = true;
             voiceSelect.appendChild(noVoicesOption);
         } else {
@@ -482,8 +496,8 @@ class KimiVoiceManager {
             );
         }
 
-        // Last resort: return all voices
-        if (filteredVoices.length === 0) filteredVoices = this.availableVoices;
+        // Do not fall back to all voices: if none match, return empty array so UI shows "no voices available"
+        if (filteredVoices.length === 0) return [];
         return filteredVoices;
     }