Move active character info to cache

README.md

@@ -39,6 +39,7 @@ CharacterChatBot/
 ├── engine/                    # Core logic (no UI dependencies)
 │   ├── chat.py                # LLM streaming generator
 │   ├── prompt_builder.py      # System prompt assembly
+│   ├── static_files.py        # Bounded static JSON/text cache
 │   ├── memory.py              # Three-layer memory system
 │   ├── memory_controls.py     # Manual facts and source exclusions
 │   ├── memory_jobs.py         # Bounded background extraction
@@ -229,6 +230,19 @@ model calls. Source-linked events allow edits and retries to roll back affected
 developments and prevent counting the same extraction twice. Save / Load preserves
 this state; older saves begin with optional axes disabled.
 
+## Static file cache
+
+Character JSON and the system, reply-suggestion, and memory-extraction prompt
+files are cached in process RAM (up to 64 entries, least recently used eviction).
+Each access checks file metadata; edits and atomic replacements refresh the
+entry. Missing or invalid files raise errors instead of silently reusing old
+content. Character data is deep-copied for each caller to avoid shared mutations.
+The cache is protected by a lock for chat and background worker access.
+
+Conversation history, personas, summaries, and user memories are not cached here.
+This saves local file reads and JSON parsing only; model calls and token usage
+remain unchanged. Restarting the process clears the cache.
+
 ## Tests
 
 ```bash

engine/memory.py

@@ -8,6 +8,7 @@ import json
 import logging
 import os
 from pathlib import Path
+from engine.static_files import load_static_text
 import re
 import tempfile
 import threading
@@ -182,7 +183,7 @@ def update_memory(session_id, character_id, conversation, client, model, persona
     try:
         from engine.prompt_builder import load_character
         character = load_character(character_id)
-        prompt = (Path(__file__).resolve().parent.parent / 'prompts/memory_prompt.txt').read_text()
+        prompt = load_static_text(Path(__file__).resolve().parent.parent / 'prompts/memory_prompt.txt')
         response = client.chat_completion(
             messages=[{'role': 'system', 'content': prompt}, {'role': 'user', 'content': json.dumps({
                 'previous_summary': conversation['summary'],

engine/prompt_builder.py

@@ -13,13 +13,14 @@ Then passed as the system message, followed by:
 """
 
 import glob
-import json
 import logging
 import os
 import re
 from pathlib import Path
 from typing import Any
 
+from engine.static_files import load_static_json, load_static_text
+
 logger = logging.getLogger(__name__)
 
 ROOT = Path(__file__).resolve().parent.parent
@@ -37,8 +38,7 @@ def load_character(character_id: str) -> dict[str, Any]:
     path = os.path.join(CHARACTERS_DIR, f"{character_id}.json")
     if not os.path.exists(path):
         raise FileNotFoundError(f"Character file not found: {path}")
-    with open(path, "r", encoding="utf-8") as f:
-        return json.load(f)
+    return load_static_json(path)
 
 
 def list_characters() -> list[dict[str, str]]:
@@ -50,8 +50,7 @@ def list_characters() -> list[dict[str, str]]:
     characters = []
     for path in sorted(glob.glob(os.path.join(CHARACTERS_DIR, "*.json"))):
         try:
-            with open(path, "r", encoding="utf-8") as f:
-                data = json.load(f)
+            data = load_static_json(path)
             characters.append({
                 "id":          data.get("id", os.path.splitext(os.path.basename(path))[0]),
                 "name":        data.get("name", "Unknown"),
@@ -84,8 +83,7 @@ def get_avatar_path(character_id: str) -> str | None:
 def build_global_prompt() -> str:
     """Load the global system prompt from prompts/system_prompt.txt."""
     path = os.path.join(PROMPTS_DIR, "system_prompt.txt")
-    with open(path, "r", encoding="utf-8") as f:
-        return f.read().strip()
+    return load_static_text(path).strip()
 
 
 def build_character_prompt(character: dict[str, Any]) -> str:

engine/static_files.py

@@ -0,0 +1,48 @@
+"""Small process-local cache for static character and prompt files only."""
+
+from collections import OrderedDict
+from copy import deepcopy
+import json
+from pathlib import Path
+from threading import RLock
+
+_MAX_ENTRIES = 64
+_CACHE = OrderedDict()
+_LOCK = RLock()
+
+
+def _signature(path):
+    stat = path.stat()
+    return (stat.st_dev, stat.st_ino, stat.st_size, stat.st_mtime_ns, stat.st_ctime_ns)
+
+
+def _load(path, as_json):
+    path = Path(path).resolve()
+    key = (path, as_json)
+    with _LOCK:
+        # Always stat: changed or deleted files must never silently use stale data.
+        signature = _signature(path)
+        cached = _CACHE.get(key)
+        if cached is not None and cached[0] == signature:
+            _CACHE.move_to_end(key)
+            value = cached[1]
+        else:
+            _CACHE.pop(key, None)
+            text = path.read_text(encoding='utf-8')
+            value = json.loads(text) if as_json else text
+            # A concurrent file edit must not be cached under its older signature.
+            if _signature(path) == signature:
+                _CACHE[key] = (signature, value)
+                while len(_CACHE) > _MAX_ENTRIES:
+                    _CACHE.popitem(last=False)
+        return deepcopy(value) if as_json else value
+
+
+def load_static_json(path):
+    """Return a private copy of parsed JSON, refreshing when file metadata changes."""
+    return _load(path, as_json=True)
+
+
+def load_static_text(path):
+    """Return cached UTF-8 text without altering whitespace."""
+    return _load(path, as_json=False)

engine/suggestions.py

@@ -18,6 +18,7 @@ from typing import Any
 
 from huggingface_hub import InferenceClient
 from engine.persona import validate_persona
+from engine.static_files import load_static_text
 
 logger = logging.getLogger(__name__)
 
@@ -60,8 +61,7 @@ def fallback_suggestions(language):
 
 def _load_prompt() -> str:
     path = PROMPTS_DIR / "reply_suggestion.txt"
-    with open(path, "r", encoding="utf-8") as f:
-        return f.read().strip()
+    return load_static_text(path).strip()
 
 
 def _parse(raw: str) -> list[dict[str, str]]:

tests/test_static_files.py

@@ -0,0 +1,68 @@
+import json
+from pathlib import Path
+import tempfile
+import unittest
+from unittest.mock import patch
+
+from engine import static_files, prompt_builder
+
+
+class StaticFilesTests(unittest.TestCase):
+    def setUp(self):
+        self.directory = tempfile.TemporaryDirectory()
+        self.addCleanup(self.directory.cleanup)
+        self.path = Path(self.directory.name) / 'character.json'
+        static_files._CACHE.clear()
+        self.addCleanup(static_files._CACHE.clear)
+
+    def test_character_reads_once_and_returns_independent_nested_data(self):
+        self.path.write_text('{"personality": ["curious"]}')
+        original = Path.read_text
+        with patch.object(prompt_builder, 'CHARACTERS_DIR', self.path.parent), patch.object(
+            Path, 'read_text', autospec=True, side_effect=original
+        ) as read:
+            first = prompt_builder.load_character('character')
+            first['personality'].append('changed')
+            self.assertEqual(prompt_builder.load_character('character')['personality'], ['curious'])
+            self.assertEqual(read.call_count, 1)
+
+    def test_edit_replace_delete_and_invalid_json_do_not_return_stale_data(self):
+        self.path.write_text('{"name":"a"}')
+        self.assertEqual(static_files.load_static_json(self.path), {'name': 'a'})
+        self.path.write_text('{"name":"updated"}')
+        self.assertEqual(static_files.load_static_json(self.path), {'name': 'updated'})
+        replacement = self.path.with_suffix('.new')
+        replacement.write_text('{"name":"replacement"}')
+        replacement.replace(self.path)
+        self.assertEqual(static_files.load_static_json(self.path), {'name': 'replacement'})
+        self.path.write_text('{invalid')
+        with self.assertRaises(json.JSONDecodeError):
+            static_files.load_static_json(self.path)
+        self.path.unlink()
+        with self.assertRaises(FileNotFoundError):
+            static_files.load_static_json(self.path)
+        self.path.write_text('{}')
+        self.assertEqual(static_files.load_static_json(self.path), {})
+
+    def test_prompt_text_is_cached_and_refreshes(self):
+        self.path.write_text('  Türkçe\n')
+        original = Path.read_text
+        with patch.object(Path, 'read_text', autospec=True, side_effect=original) as read:
+            for _ in range(2):
+                self.assertEqual(static_files.load_static_text(self.path), '  Türkçe\n')
+            self.assertEqual(read.call_count, 1)
+            self.path.write_text('New prompt')
+            self.assertEqual(static_files.load_static_text(self.path), 'New prompt')
+            self.assertEqual(read.call_count, 2)
+
+    def test_cache_evicts_least_recently_used_file(self):
+        with patch.object(static_files, '_MAX_ENTRIES', 2):
+            paths = [self.path.with_name(str(i)) for i in range(3)]
+            for path in paths:
+                path.write_text(path.name)
+            for path in paths[:2]:
+                static_files.load_static_text(path)
+            static_files.load_static_text(paths[0])
+            static_files.load_static_text(paths[2])
+            self.assertEqual(len(static_files._CACHE), 2)
+            self.assertNotIn((paths[1].resolve(), False), static_files._CACHE)