kiku-agent 1.0.0 → 1.0.4

package/server/agent/memory.js

@@ -1,566 +1,670 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-
-const MEMORY_DIR = path.resolve(process.cwd(), '.kiku_sessions');
-const MEMORY_FILE = path.join(MEMORY_DIR, 'long_term_memory.json');
-const SESSIONS_DIR = path.join(MEMORY_DIR, 'sessions');
-
-
-export class AgentMemory {
-  constructor() {
-    this.facts = [];
-    this.preferences = {
-      language: null,          
-      topicsOfInterest: [],    
-      responseStyle: 'default', 
-    };
-    this.sessions = [];         
-    this.summaries = [];       
-    this.stats = {
-      totalFacts: 0,
-      totalSessions: 0,
-      totalConsolidations: 0,
-      lastConsolidationAt: null,
-      createdAt: new Date()
-    };
-    this._loaded = false;
-  }
-
-
-  async init() {
-    try {
-      await fs.mkdir(MEMORY_DIR, { recursive: true });
-      await fs.mkdir(SESSIONS_DIR, { recursive: true });
-    } catch {}
-  }
-
-  
-  async load() {
-    try {
-      await this.init();
-      const data = await fs.readFile(MEMORY_FILE, 'utf-8');
-      const parsed = JSON.parse(data);
-      
-     
-      this.facts = (parsed.facts || []).map(f => ({
-        ...f,
-        createdAt: f.createdAt ? new Date(f.createdAt) : new Date(),
-        lastAccessedAt: f.lastAccessedAt ? new Date(f.lastAccessedAt) : new Date()
-      }));
-      
-      const loadedPrefs = parsed.preferences || {};
-      this.preferences = {
-        ...this.preferences,
-        ...loadedPrefs,
-        topicsOfInterest: (loadedPrefs.topicsOfInterest || []).map(t => ({
-          ...t,
-          lastSeen: t.lastSeen ? new Date(t.lastSeen) : new Date()
-        }))
-      };
-      
-      this.sessions = parsed.sessions || [];
-      this.summaries = parsed.summaries || [];
-      this.stats = { ...this.stats, ...(parsed.stats || {}) };
-      this._loaded = true;
-      return true;
-    } catch {
-      this._loaded = true;
-      return false;
-    }
-  }
-
-
-  async save() {
-    try {
-      await this.init();
-      
-      const serializablePrefs = {
-        ...this.preferences,
-        topicsOfInterest: (this.preferences.topicsOfInterest || []).map(t => ({
-          ...t,
-          lastSeen: t.lastSeen ? t.lastSeen.toISOString() : null
-        }))
-      };
-      const data = {
-        facts: this.facts.map(f => ({
-          ...f,
-          createdAt: f.createdAt ? f.createdAt.toISOString() : f.createdAt,
-          lastAccessedAt: f.lastAccessedAt ? f.lastAccessedAt.toISOString() : f.lastAccessedAt
-        })),
-        preferences: serializablePrefs,
-        sessions: this.sessions,
-        summaries: this.summaries,
-        stats: this.stats,
-        lastSavedAt: new Date().toISOString()
-      };
-      await fs.writeFile(MEMORY_FILE, JSON.stringify(data, null, 2), 'utf-8');
-      return true;
-    } catch (error) {
-      console.error('Failed to save long-term memory:', error);
-      return false;
-    }
-  }
-
-  addFact(fact, meta = {}) {
-    const entry = {
-      id: `fact_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
-      content: fact,
-      category: meta.category || 'general',
-      source: meta.source || 'conversation',
-      confidence: meta.confidence || 'high',
-      createdAt: new Date(),
-      lastAccessedAt: new Date(),
-      accessCount: 0,
-      tags: meta.tags || []
-    };
-    this.facts.push(entry);
-    this.stats.totalFacts = this.facts.length;
-    this.save().catch(() => {});
-    return entry;
-  }
-
- 
-  searchFacts(query, options = {}) {
-    const { category, limit = 10 } = options;
-    const q = (query || '').toLowerCase().trim();
-    
-    let results = this.facts;
-    
-    if (category) {
-      results = results.filter(f => f.category === category);
-    }
-    
-    if (q) {
-      results = results.filter(f => 
-        f.content.toLowerCase().includes(q) ||
-        f.tags.some(t => t.toLowerCase().includes(q))
-      );
-    }
-
-   
-    results.sort((a, b) => {
-      const scoreA = (a.accessCount || 0) + (new Date(a.createdAt).getTime() / 1e12);
-      const scoreB = (b.accessCount || 0) + (new Date(b.createdAt).getTime() / 1e12);
-      return scoreB - scoreA;
-    });
-
-  
-    for (const fact of results.slice(0, limit)) {
-      fact.lastAccessedAt = new Date();
-      fact.accessCount = (fact.accessCount || 0) + 1;
-    }
-
-    return results.slice(0, limit);
-  }
-
-  removeFact(factId) {
-    const idx = this.facts.findIndex(f => f.id === factId);
-    if (idx === -1) return false;
-    this.facts.splice(idx, 1);
-    this.stats.totalFacts = this.facts.length;
-    this.save().catch(() => {});
-    return true;
-  }
-
-  
-  getFactsByCategory() {
-    const grouped = {};
-    for (const fact of this.facts) {
-      const cat = fact.category || 'general';
-      if (!grouped[cat]) grouped[cat] = [];
-      grouped[cat].push(fact);
-    }
-    return grouped;
-  }
-
-  setPreference(key, value) {
-    this.preferences[key] = value;
-    this.save().catch(() => {});
-  }
-
-  
-  async savePreferences() {
-    await this.save();
-  }
-
-  
-  trackTopicInterest(topic) {
-    const existing = this.preferences.topicsOfInterest.find(
-      t => t.topic.toLowerCase() === topic.toLowerCase()
-    );
-    if (existing) {
-      existing.count++;
-      existing.lastSeen = new Date();
-    } else {
-      this.preferences.topicsOfInterest.push({
-        topic,
-        count: 1,
-        lastSeen: new Date()
-      });
-    }
-   
-    this.preferences.topicsOfInterest.sort((a, b) => b.count - a.count);
-    this.preferences.topicsOfInterest = this.preferences.topicsOfInterest.slice(0, 20);
-    this.save().catch(() => {});
-  }
-
-
-  getTopTopics(limit = 5) {
-    return this.preferences.topicsOfInterest.slice(0, limit);
-  }
-
-  
-  async archiveSession(sessionData) {
-    const archive = {
-      id: sessionData.id,
-      createdAt: sessionData.createdAt,
-      endedAt: new Date(),
-      messageCount: sessionData.messages?.length || 0,
-      stats: { ...sessionData.stats },
-      thinkingMode: sessionData.thinkingMode,
-      summary: null 
-    };
-
-   
-    try {
-      const sessionFile = path.join(SESSIONS_DIR, `${sessionData.id}.json`);
-      await fs.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), 'utf-8');
-    } catch (err) {
-      console.error('Failed to archive session file:', err);
-    }
-
-    this.sessions.push(archive);
-    this.stats.totalSessions = this.sessions.length;
-    await this.save();
-    return archive;
-  }
-
-  getArchivedSessions(limit = 20) {
-    return this.sessions
-      .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt))
-      .slice(0, limit);
-  }
-
-  async loadArchivedSession(sessionId) {
-    try {
-      const sessionFile = path.join(SESSIONS_DIR, `${sessionId}.json`);
-      const data = await fs.readFile(sessionFile, 'utf-8');
-      return JSON.parse(data);
-    } catch {
-      return null;
-    }
-  }
-
-
-  async consolidateSession(sessionData) {
-    if (!sessionData?.messages?.length) return null;
-
-    const userMessages = sessionData.messages
-      .filter(m => m.role === 'user')
-      .map(m => {
-        const textPart = m.parts?.find(p => p.type === 'text');
-        return textPart?.content || '';
-      })
-      .filter(Boolean);
-
-    const assistantMessages = sessionData.messages
-      .filter(m => m.role === 'assistant')
-      .map(m => {
-        const textPart = m.parts?.find(p => p.type === 'text');
-        return textPart?.content || '';
-      })
-      .filter(Boolean);
-
-    const topics = this._extractTopics(userMessages);
-
-    for (const topic of topics) {
-      this.trackTopicInterest(topic);
-    }
-
-    const summary = {
-      id: `sum_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
-      sessionId: sessionData.id,
-      createdAt: new Date(),
-      topics,
-      questionCount: userMessages.length,
-      keyExchanges: userMessages.slice(0, 5).map((q, i) => ({
-        question: q.slice(0, 200),
-        answerPreview: (assistantMessages[i] || '').slice(0, 200)
-      })),
-      durationMs: sessionData.stats?.totalDurationMs || 0,
-      toolCalls: sessionData.stats?.totalToolCalls || 0
-    };
-
-    this.summaries.push(summary);
-    this.stats.totalConsolidations = this.summaries.length;
-    this.stats.lastConsolidationAt = new Date();
-    
-    const archived = this.sessions.find(s => s.id === sessionData.id);
-    if (archived) {
-      archived.summary = summary;
-    }
-
-    await this.save();
-    return summary;
-  }
-
-  _extractTopics(messages) {
-    const topicKeywords = {
-      'drama': ['drama', 'series', 'ละคร', '剧', '电视', 'tv series', 'film', 'movie', 'work'],
-      'music': ['song', 'music', 'mv', 'single', 'ost', 'เพลง', '歌', 'album', 'discography'],
-      'brand': ['brand', 'ambassador', 'endorsement', 'แบรนด์', '品牌', 'commercial'],
-      'awards': ['award', 'honor', 'ceremony', 'รางวัล', '奖', 'winner'],
-      'profile': ['profile', 'bio', 'birthday', 'age', 'ประวัติ', '资料', '个人信息'],
-      'timeline': ['career', 'timeline', 'history', 'era', 'เส้นทาง', '经历', 'ปี'],
-      'news': ['news', 'latest', 'recent', 'update', 'ข่าว', '最新', 'ล่าสุด'],
-      'video': ['video', 'stage', 'performance', 'live', 'คลิป', '视频', '舞台'],
-      'social': ['weibo', 'douyin', 'instagram', 'social media', 'โซเชียล', '微博'],
-      'gallery': ['photo', 'picture', 'gallery', 'fashion', 'photoshoot', 'ภาพ', '照片']
-    };
-
-    const topicCounts = {};
-    const allText = messages.join(' ').toLowerCase();
-
-    for (const [topic, keywords] of Object.entries(topicKeywords)) {
-      const count = keywords.reduce((acc, kw) => {
-        const regex = new RegExp(`\\b${kw}\\b`, 'gi');
-        return acc + (allText.match(regex) || []).length;
-      }, 0);
-      if (count > 0) topicCounts[topic] = count;
-    }
-
-    return Object.entries(topicCounts)
-      .sort(([, a], [, b]) => b - a)
-      .slice(0, 5)
-      .map(([topic]) => topic);
-  }
-
-
-  buildMemoryContext() {
-    const parts = [];
-
-    if (this.preferences.language) {
-      parts.push(`User's preferred language: ${this.preferences.language}`);
-    }
-
-    const topTopics = this.getTopTopics(5);
-    if (topTopics.length > 0) {
-      const topicList = topTopics.map(t => `${t.topic} (${t.count}x)`).join(', ');
-      parts.push(`User frequently asks about: ${topicList}`);
-    }
-
-    const recentFacts = this.facts
-      .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt))
-      .slice(0, 8);
-    if (recentFacts.length > 0) {
-      const factList = recentFacts.map(f => `- ${f.content}`).join('\n');
-      parts.push(`Known facts from previous conversations:\n${factList}`);
-    }
-
-    const recentSummaries = this.summaries
-      .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt))
-      .slice(0, 3);
-    if (recentSummaries.length > 0) {
-      const sumList = recentSummaries.map(s => {
-        const date = new Date(s.createdAt).toLocaleDateString();
-        const topics = s.topics.join(', ');
-        return `- [${date}] Topics: ${topics} (${s.questionCount} questions)`;
-      }).join('\n');
-      parts.push(`Recent conversation themes:\n${sumList}`);
-    }
-
-    if (parts.length === 0) return '';
-
-    return `\n\n=== LONG-TERM MEMORY CONTEXT ===\n${parts.join('\n\n')}\n=== END MEMORY CONTEXT ===`;
-  }
-
-  getStatus() {
-    return {
-      factsCount: this.facts.length,
-      factsByCategory: this.getFactsByCategory(),
-      preferences: this.preferences,
-      sessionsCount: this.sessions.length,
-      summariesCount: this.summaries.length,
-      topTopics: this.getTopTopics(10),
-      stats: this.stats,
-      lastConsolidationAt: this.stats.lastConsolidationAt,
-      memoryFileSize: null
-    };
-  }
-
-  async importFromJSON(filePath) {
-    try {
-      const raw = await fs.readFile(filePath, 'utf-8');
-      const data = JSON.parse(raw);
-
-      if (!data.facts && !data.preferences && !data.sessions) {
-        return { success: false, message: 'Invalid memory file format — missing facts, preferences, or sessions.' };
-      }
-
-      let factsImported = 0;
-      let factsSkipped = 0;
-      let topicsImported = 0;
-
-      if (Array.isArray(data.facts)) {
-        for (const fact of data.facts) {
-          const isDuplicate = this.facts.some(
-            existing => existing.content === fact.content
-          );
-          if (!isDuplicate && fact.content) {
-            this.facts.push({
-              id: fact.id || `fact_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
-              content: fact.content,
-              category: fact.category || 'imported',
-              source: fact.source || 'import',
-              confidence: fact.confidence || 'high',
-              createdAt: fact.createdAt ? new Date(fact.createdAt) : new Date(),
-              lastAccessedAt: new Date(),
-              accessCount: 0,
-              tags: fact.tags || []
-            });
-            factsImported++;
-          } else {
-            factsSkipped++;
-          }
-        }
-      }
-
-      if (data.preferences) {
-        if (data.preferences.language) {
-          this.preferences.language = data.preferences.language;
-        }
-        if (data.preferences.responseStyle) {
-          this.preferences.responseStyle = data.preferences.responseStyle;
-        }
-        if (Array.isArray(data.preferences.topicsOfInterest)) {
-          for (const topic of data.preferences.topicsOfInterest) {
-            const existing = this.preferences.topicsOfInterest.find(
-              t => t.topic.toLowerCase() === topic.topic.toLowerCase()
-            );
-            if (existing) {
-              existing.count += topic.count || 1;
-              existing.lastSeen = new Date();
-            } else {
-              this.preferences.topicsOfInterest.push({
-                topic: topic.topic,
-                count: topic.count || 1,
-                lastSeen: topic.lastSeen ? new Date(topic.lastSeen) : new Date()
-              });
-              topicsImported++;
-            }
-          }
-          this.preferences.topicsOfInterest.sort((a, b) => b.count - a.count);
-          this.preferences.topicsOfInterest = this.preferences.topicsOfInterest.slice(0, 20);
-        }
-      }
-
-      if (Array.isArray(data.sessions)) {
-        for (const session of data.sessions) {
-          const isDuplicate = this.sessions.some(s => s.id === session.id);
-          if (!isDuplicate) {
-            this.sessions.push(session);
-          }
-        }
-      }
-
-      if (Array.isArray(data.summaries)) {
-        for (const summary of data.summaries) {
-          const isDuplicate = this.summaries.some(s => s.id === summary.id);
-          if (!isDuplicate) {
-            this.summaries.push(summary);
-          }
-        }
-      }
-
-      this.stats.totalFacts = this.facts.length;
-      this.stats.totalSessions = this.sessions.length;
-      this.stats.totalConsolidations = this.summaries.length;
-
-      await this.save();
-
-      return {
-        success: true,
-        factsImported,
-        factsSkipped,
-        topicsImported,
-        totalFacts: this.facts.length,
-        totalSessions: this.sessions.length,
-        totalSummaries: this.summaries.length
-      };
-    } catch (error) {
-      return { success: false, message: error.message };
-    }
-  }
-
-  async exportToJSON() {
-    const exportDir = path.resolve(process.cwd(), 'exports');
-    try {
-      await fs.mkdir(exportDir, { recursive: true });
-    } catch {}
-
-    const now = new Date();
-    const timestamp = now.toISOString().replace(/[:.]/g, '-').slice(0, 19);
-    const filename = `kiku-memory-${timestamp}.json`;
-    const filePath = path.join(exportDir, filename);
-
-    const exportData = {
-      exportedAt: now.toISOString(),
-      stats: this.stats,
-      preferences: {
-        ...this.preferences,
-        topicsOfInterest: (this.preferences.topicsOfInterest || []).map(t => ({
-          ...t,
-          lastSeen: t.lastSeen ? t.lastSeen.toISOString() : null
-        }))
-      },
-      facts: this.facts.map(f => ({
-        ...f,
-        createdAt: f.createdAt ? f.createdAt.toISOString() : f.createdAt,
-        lastAccessedAt: f.lastAccessedAt ? f.lastAccessedAt.toISOString() : f.lastAccessedAt
-      })),
-      factsByCategory: this.getFactsByCategory(),
-      sessions: this.sessions,
-      summaries: this.summaries
-    };
-
-    await fs.writeFile(filePath, JSON.stringify(exportData, null, 2), 'utf-8');
-    return { filePath, filename, size: (await fs.stat(filePath)).size };
-  }
-
-  async clearAll() {
-    this.facts = [];
-    this.preferences = {
-      language: null,
-      topicsOfInterest: [],
-      responseStyle: 'default'
-    };
-    this.sessions = [];
-    this.summaries = [];
-    this.stats = {
-      totalFacts: 0,
-      totalSessions: 0,
-      totalConsolidations: 0,
-      lastConsolidationAt: null,
-      createdAt: new Date()
-    };
-    await this.save();
-    return true;
-  }
-
-  async getStorageSize() {
-    try {
-      const stat = await fs.stat(MEMORY_FILE);
-      return stat.size;
-    } catch {
-      return 0;
-    }
-  }
-
-  static formatBytes(bytes) {
-    if (bytes === 0) return '0 B';
-    const k = 1024;
-    const sizes = ['B', 'KB', 'MB', 'GB'];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
-  }
-}
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { EXPORT_DIR, KIKU_DATA_DIR, SESSION_DIR } from './appPaths.js';
+
+const MEMORY_DIR = KIKU_DATA_DIR;
+const MEMORY_FILE = path.join(MEMORY_DIR, 'long_term_memory.json');
+const SESSIONS_DIR = SESSION_DIR;
+
+
+export class AgentMemory {
+  constructor() {
+    this.facts = [];
+    this.preferences = {
+      language: null,          
+      topicsOfInterest: [],    
+      responseStyle: 'default', 
+      userSkills: [],
+      skillsEnabled: true,
+    };
+    this.sessions = [];         
+    this.summaries = [];       
+    this.stats = {
+      totalFacts: 0,
+      totalSessions: 0,
+      totalConsolidations: 0,
+      lastConsolidationAt: null,
+      createdAt: new Date()
+    };
+    this._loaded = false;
+    this._storageWarningShown = false;
+    this._storageError = null;
+  }
+
+
+  async init() {
+    try {
+      await fs.mkdir(MEMORY_DIR, { recursive: true, mode: 0o700 });
+      await fs.mkdir(SESSIONS_DIR, { recursive: true, mode: 0o700 });
+      this._storageError = null;
+      return true;
+    } catch (error) {
+      this._storageError = error;
+      this._warnStorage(error);
+      return false;
+    }
+  }
+
+  _warnStorage(error) {
+    if (this._storageWarningShown) return;
+    this._storageWarningShown = true;
+    console.error(`Kiku memory is running without persistence (${error?.code || 'unknown'}) in ${MEMORY_DIR}. Set KIKU_DATA_DIR to a writable user folder; Administrator privileges are not required.`);
+  }
+
+  
+  async load() {
+    try {
+      await this.init();
+      const data = await fs.readFile(MEMORY_FILE, 'utf-8');
+      const parsed = JSON.parse(data);
+      
+     
+      this.facts = (parsed.facts || []).map(f => ({
+        ...f,
+        createdAt: f.createdAt ? new Date(f.createdAt) : new Date(),
+        lastAccessedAt: f.lastAccessedAt ? new Date(f.lastAccessedAt) : new Date()
+      }));
+      
+      const loadedPrefs = parsed.preferences || {};
+      this.preferences = {
+        ...this.preferences,
+        ...loadedPrefs,
+        userSkills: Array.isArray(loadedPrefs.userSkills) ? loadedPrefs.userSkills : [],
+        topicsOfInterest: (loadedPrefs.topicsOfInterest || []).map(t => ({
+          ...t,
+          lastSeen: t.lastSeen ? new Date(t.lastSeen) : new Date()
+        }))
+      };
+      
+      this.sessions = parsed.sessions || [];
+      this.summaries = parsed.summaries || [];
+      this.stats = { ...this.stats, ...(parsed.stats || {}) };
+      this._loaded = true;
+      return true;
+    } catch {
+      this._loaded = true;
+      return false;
+    }
+  }
+
+
+  async save() {
+    try {
+      if (!await this.init()) return false;
+      
+      const serializablePrefs = {
+        ...this.preferences,
+        topicsOfInterest: (this.preferences.topicsOfInterest || []).map(t => ({
+          ...t,
+          lastSeen: t.lastSeen ? t.lastSeen.toISOString() : null
+        }))
+      };
+      const data = {
+        facts: this.facts.map(f => ({
+          ...f,
+          createdAt: f.createdAt ? f.createdAt.toISOString() : f.createdAt,
+          lastAccessedAt: f.lastAccessedAt ? f.lastAccessedAt.toISOString() : f.lastAccessedAt
+        })),
+        preferences: serializablePrefs,
+        sessions: this.sessions,
+        summaries: this.summaries,
+        stats: this.stats,
+        lastSavedAt: new Date().toISOString()
+      };
+      await fs.writeFile(MEMORY_FILE, JSON.stringify(data, null, 2), 'utf-8');
+      return true;
+    } catch (error) {
+      this._warnStorage(error);
+      return false;
+    }
+  }
+
+  addFact(fact, meta = {}) {
+    const entry = {
+      id: `fact_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+      content: fact,
+      category: meta.category || 'general',
+      source: meta.source || 'conversation',
+      confidence: meta.confidence || 'high',
+      createdAt: new Date(),
+      lastAccessedAt: new Date(),
+      accessCount: 0,
+      tags: meta.tags || []
+    };
+    this.facts.push(entry);
+    this.stats.totalFacts = this.facts.length;
+    this.save().catch(() => {});
+    return entry;
+  }
+
+ 
+  scoreFactRelevance(fact, queryTerms = [], now = Date.now()) {
+    if (!fact) return 0;
+    const content = (fact.content || '').toLowerCase();
+    const tags = (fact.tags || []).map(t => String(t).toLowerCase());
+
+    let matchScore = 0;
+    if (queryTerms.length > 0) {
+      for (const term of queryTerms) {
+        if (!term || term.length < 2) continue;
+        if (tags.some(t => t.includes(term))) matchScore += 3.0;
+        if (content.includes(term)) matchScore += 2.0;
+      }
+    } else {
+      matchScore = 1.0;
+    }
+
+    const createdTime = fact.createdAt ? new Date(fact.createdAt).getTime() : now;
+    const ageInDays = Math.max(0, (now - createdTime) / (1000 * 60 * 60 * 24));
+    const recencyDecay = Math.exp(-ageInDays / 45);
+
+    const accessBoost = Math.log10(1 + (fact.accessCount || 0) * 2);
+
+    return (matchScore * (0.6 + 0.4 * recencyDecay)) + accessBoost;
+  }
+
+  getRelevantFacts(query = '', limit = 8) {
+    if (!this.facts || this.facts.length === 0) return [];
+    const q = String(query || '').toLowerCase().trim();
+    const terms = q ? q.split(/\s+/).filter(t => t.length >= 2) : [];
+    const now = Date.now();
+
+    const scored = this.facts.map(fact => ({
+      fact,
+      score: this.scoreFactRelevance(fact, terms, now)
+    }));
+
+    scored.sort((a, b) => b.score - a.score);
+    const top = scored.slice(0, limit).map(s => s.fact);
+
+    for (const f of top) {
+      f.lastAccessedAt = new Date();
+      f.accessCount = (f.accessCount || 0) + 1;
+    }
+    return top;
+  }
+
+  searchFacts(query, options = {}) {
+    const { category, limit = 10 } = options;
+    const q = (query || '').toLowerCase().trim();
+    
+    let results = this.facts;
+    
+    if (category) {
+      results = results.filter(f => f.category === category);
+    }
+    
+    if (q) {
+      results = results.filter(f => 
+        f.content.toLowerCase().includes(q) ||
+        f.tags.some(t => t.toLowerCase().includes(q))
+      );
+    }
+
+    const terms = q ? q.split(/\s+/).filter(t => t.length >= 2) : [];
+    const now = Date.now();
+
+    results.sort((a, b) => {
+      const scoreA = this.scoreFactRelevance(a, terms, now);
+      const scoreB = this.scoreFactRelevance(b, terms, now);
+      return scoreB - scoreA;
+    });
+
+    for (const fact of results.slice(0, limit)) {
+      fact.lastAccessedAt = new Date();
+      fact.accessCount = (fact.accessCount || 0) + 1;
+    }
+
+    return results.slice(0, limit);
+  }
+
+  removeFact(factId) {
+    const idx = this.facts.findIndex(f => f.id === factId);
+    if (idx === -1) return false;
+    this.facts.splice(idx, 1);
+    this.stats.totalFacts = this.facts.length;
+    this.save().catch(() => {});
+    return true;
+  }
+
+  
+  getFactsByCategory() {
+    const grouped = {};
+    for (const fact of this.facts) {
+      const cat = fact.category || 'general';
+      if (!grouped[cat]) grouped[cat] = [];
+      grouped[cat].push(fact);
+    }
+    return grouped;
+  }
+
+  setPreference(key, value) {
+    this.preferences[key] = value;
+    this.save().catch(() => {});
+  }
+
+  addUserSkill(instruction) {
+    const value = String(instruction || '').replace(/\s+/g, ' ').trim();
+    if (!value) return null;
+    if (value.length > 500) throw new Error('Skill instruction must be 500 characters or fewer.');
+    const duplicate = this.preferences.userSkills.find(skill => skill.instruction.toLowerCase() === value.toLowerCase());
+    if (duplicate) return duplicate;
+    const skill = { id: `skill_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`, instruction: value };
+    this.preferences.userSkills.push(skill);
+    this.preferences.userSkills = this.preferences.userSkills.slice(-20);
+    this.save().catch(() => {});
+    return skill;
+  }
+
+  removeUserSkill(id) {
+    const before = this.preferences.userSkills.length;
+    this.preferences.userSkills = this.preferences.userSkills.filter(skill => skill.id !== id);
+    if (this.preferences.userSkills.length === before) return false;
+    this.save().catch(() => {});
+    return true;
+  }
+
+  clearUserSkills() {
+    this.preferences.userSkills = [];
+    this.save().catch(() => {});
+  }
+
+  buildUserSkillContext() {
+    if (!this.preferences.skillsEnabled || this.preferences.userSkills.length === 0) return '';
+    return this.preferences.userSkills.map((skill, index) => `${index + 1}. ${skill.instruction}`).join('\n');
+  }
+
+  
+  async savePreferences() {
+    await this.save();
+  }
+
+  
+  trackTopicInterest(topic) {
+    const existing = this.preferences.topicsOfInterest.find(
+      t => t.topic.toLowerCase() === topic.toLowerCase()
+    );
+    if (existing) {
+      existing.count++;
+      existing.lastSeen = new Date();
+    } else {
+      this.preferences.topicsOfInterest.push({
+        topic,
+        count: 1,
+        lastSeen: new Date()
+      });
+    }
+   
+    this.preferences.topicsOfInterest.sort((a, b) => b.count - a.count);
+    this.preferences.topicsOfInterest = this.preferences.topicsOfInterest.slice(0, 20);
+    this.save().catch(() => {});
+  }
+
+
+  getTopTopics(limit = 5) {
+    return this.preferences.topicsOfInterest.slice(0, limit);
+  }
+
+  
+  async archiveSession(sessionData) {
+    const archive = {
+      id: sessionData.id,
+      createdAt: sessionData.createdAt,
+      endedAt: new Date(),
+      messageCount: sessionData.messages?.length || 0,
+      stats: { ...sessionData.stats },
+      thinkingMode: sessionData.thinkingMode,
+      summary: null 
+    };
+
+   
+    let archivedToDisk = false;
+    try {
+      if (!await this.init()) return null;
+      const sessionFile = path.join(SESSIONS_DIR, `${sessionData.id}.json`);
+      await fs.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), 'utf-8');
+      archivedToDisk = true;
+    } catch (err) {
+      this._warnStorage(err);
+    }
+
+    if (!archivedToDisk) return null;
+
+    this.sessions.push(archive);
+    this.stats.totalSessions = this.sessions.length;
+    await this.save();
+    return archive;
+  }
+
+  getArchivedSessions(limit = 20) {
+    return this.sessions
+      .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt))
+      .slice(0, limit);
+  }
+
+  async loadArchivedSession(sessionId) {
+    try {
+      const sessionFile = path.join(SESSIONS_DIR, `${sessionId}.json`);
+      const data = await fs.readFile(sessionFile, 'utf-8');
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+
+
+  async consolidateSession(sessionData) {
+    if (!sessionData?.messages?.length) return null;
+
+    const userMessages = sessionData.messages
+      .filter(m => m.role === 'user')
+      .map(m => {
+        const textPart = m.parts?.find(p => p.type === 'text');
+        return textPart?.content || '';
+      })
+      .filter(Boolean);
+
+    const assistantMessages = sessionData.messages
+      .filter(m => m.role === 'assistant')
+      .map(m => {
+        const textPart = m.parts?.find(p => p.type === 'text');
+        return textPart?.content || '';
+      })
+      .filter(Boolean);
+
+    const topics = this._extractTopics(userMessages);
+
+    for (const topic of topics) {
+      this.trackTopicInterest(topic);
+    }
+
+    const summary = {
+      id: `sum_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+      sessionId: sessionData.id,
+      createdAt: new Date(),
+      topics,
+      questionCount: userMessages.length,
+      keyExchanges: userMessages.slice(0, 5).map((q, i) => ({
+        question: q.slice(0, 200),
+        answerPreview: (assistantMessages[i] || '').slice(0, 200)
+      })),
+      durationMs: sessionData.stats?.totalDurationMs || 0,
+      toolCalls: sessionData.stats?.totalToolCalls || 0
+    };
+
+    this.summaries.push(summary);
+    this.stats.totalConsolidations = this.summaries.length;
+    this.stats.lastConsolidationAt = new Date();
+    
+    const archived = this.sessions.find(s => s.id === sessionData.id);
+    if (archived) {
+      archived.summary = summary;
+    }
+
+    await this.save();
+    return summary;
+  }
+
+  _extractTopics(messages) {
+    const topicKeywords = {
+      'drama': ['drama', 'series', 'ละคร', '剧', '电视', 'tv series', 'film', 'movie', 'work'],
+      'music': ['song', 'music', 'mv', 'single', 'ost', 'เพลง', '歌', 'album', 'discography'],
+      'brand': ['brand', 'ambassador', 'endorsement', 'แบรนด์', '品牌', 'commercial'],
+      'awards': ['award', 'honor', 'ceremony', 'รางวัล', '奖', 'winner'],
+      'profile': ['profile', 'bio', 'birthday', 'age', 'ประวัติ', '资料', '个人信息'],
+      'timeline': ['career', 'timeline', 'history', 'era', 'เส้นทาง', '经历', 'ปี'],
+      'news': ['news', 'latest', 'recent', 'update', 'ข่าว', '最新', 'ล่าสุด'],
+      'video': ['video', 'stage', 'performance', 'live', 'คลิป', '视频', '舞台'],
+      'social': ['weibo', 'douyin', 'instagram', 'social media', 'โซเชียล', '微博'],
+      'gallery': ['photo', 'picture', 'gallery', 'fashion', 'photoshoot', 'ภาพ', '照片']
+    };
+
+    const topicCounts = {};
+    const allText = messages.join(' ').toLowerCase();
+
+    for (const [topic, keywords] of Object.entries(topicKeywords)) {
+      const count = keywords.reduce((acc, kw) => {
+        const regex = new RegExp(`\\b${kw}\\b`, 'gi');
+        return acc + (allText.match(regex) || []).length;
+      }, 0);
+      if (count > 0) topicCounts[topic] = count;
+    }
+
+    return Object.entries(topicCounts)
+      .sort(([, a], [, b]) => b - a)
+      .slice(0, 5)
+      .map(([topic]) => topic);
+  }
+
+
+  buildMemoryContext(currentQuery = '') {
+    const parts = [];
+
+    if (this.preferences.language) {
+      parts.push(`User's preferred language: ${this.preferences.language}`);
+    }
+
+    const userSkillContext = this.buildUserSkillContext();
+    if (userSkillContext) {
+      parts.push(`User-taught response skills (follow these preferences unless they conflict with safety or verified facts):\n${userSkillContext}`);
+    }
+
+    const topTopics = this.getTopTopics(5);
+    if (topTopics.length > 0) {
+      const topicList = topTopics.map(t => `${t.topic} (${t.count}x)`).join(', ');
+      parts.push(`User frequently asks about: ${topicList}`);
+    }
+
+    const relevantFacts = currentQuery ? this.getRelevantFacts(currentQuery, 8) : this.facts.slice(-8);
+    if (relevantFacts.length > 0) {
+      const factList = relevantFacts.map(f => `- ${f.content}`).join('\n');
+      parts.push(`Known facts from previous conversations:\n${factList}`);
+    }
+
+    const recentSummaries = this.summaries
+      .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt))
+      .slice(0, 3);
+    if (recentSummaries.length > 0) {
+      const sumList = recentSummaries.map(s => {
+        const date = new Date(s.createdAt).toLocaleDateString();
+        const topics = s.topics.join(', ');
+        return `- [${date}] Topics: ${topics} (${s.questionCount} questions)`;
+      }).join('\n');
+      parts.push(`Recent conversation themes:\n${sumList}`);
+    }
+
+    if (parts.length === 0) return '';
+
+    return `\n\n=== LONG-TERM MEMORY CONTEXT ===\n${parts.join('\n\n')}\n=== END MEMORY CONTEXT ===`;
+  }
+
+  getStatus() {
+    return {
+      factsCount: this.facts.length,
+      factsByCategory: this.getFactsByCategory(),
+      preferences: this.preferences,
+      sessionsCount: this.sessions.length,
+      summariesCount: this.summaries.length,
+      topTopics: this.getTopTopics(10),
+      stats: this.stats,
+      lastConsolidationAt: this.stats.lastConsolidationAt,
+      memoryFileSize: null
+    };
+  }
+
+  async importFromJSON(filePath) {
+    try {
+      const raw = await fs.readFile(filePath, 'utf-8');
+      const data = JSON.parse(raw);
+
+      if (!data.facts && !data.preferences && !data.sessions) {
+        return { success: false, message: 'Invalid memory file format — missing facts, preferences, or sessions.' };
+      }
+
+      let factsImported = 0;
+      let factsSkipped = 0;
+      let topicsImported = 0;
+
+      if (Array.isArray(data.facts)) {
+        for (const fact of data.facts) {
+          const isDuplicate = this.facts.some(
+            existing => existing.content === fact.content
+          );
+          if (!isDuplicate && fact.content) {
+            this.facts.push({
+              id: fact.id || `fact_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+              content: fact.content,
+              category: fact.category || 'imported',
+              source: fact.source || 'import',
+              confidence: fact.confidence || 'high',
+              createdAt: fact.createdAt ? new Date(fact.createdAt) : new Date(),
+              lastAccessedAt: new Date(),
+              accessCount: 0,
+              tags: fact.tags || []
+            });
+            factsImported++;
+          } else {
+            factsSkipped++;
+          }
+        }
+      }
+
+      if (data.preferences) {
+        if (data.preferences.language) {
+          this.preferences.language = data.preferences.language;
+        }
+        if (data.preferences.responseStyle) {
+          this.preferences.responseStyle = data.preferences.responseStyle;
+        }
+        if (Array.isArray(data.preferences.topicsOfInterest)) {
+          for (const topic of data.preferences.topicsOfInterest) {
+            const existing = this.preferences.topicsOfInterest.find(
+              t => t.topic.toLowerCase() === topic.topic.toLowerCase()
+            );
+            if (existing) {
+              existing.count += topic.count || 1;
+              existing.lastSeen = new Date();
+            } else {
+              this.preferences.topicsOfInterest.push({
+                topic: topic.topic,
+                count: topic.count || 1,
+                lastSeen: topic.lastSeen ? new Date(topic.lastSeen) : new Date()
+              });
+              topicsImported++;
+            }
+          }
+          this.preferences.topicsOfInterest.sort((a, b) => b.count - a.count);
+          this.preferences.topicsOfInterest = this.preferences.topicsOfInterest.slice(0, 20);
+        }
+      }
+
+      if (Array.isArray(data.sessions)) {
+        for (const session of data.sessions) {
+          const isDuplicate = this.sessions.some(s => s.id === session.id);
+          if (!isDuplicate) {
+            this.sessions.push(session);
+          }
+        }
+      }
+
+      if (Array.isArray(data.summaries)) {
+        for (const summary of data.summaries) {
+          const isDuplicate = this.summaries.some(s => s.id === summary.id);
+          if (!isDuplicate) {
+            this.summaries.push(summary);
+          }
+        }
+      }
+
+      this.stats.totalFacts = this.facts.length;
+      this.stats.totalSessions = this.sessions.length;
+      this.stats.totalConsolidations = this.summaries.length;
+
+      await this.save();
+
+      return {
+        success: true,
+        factsImported,
+        factsSkipped,
+        topicsImported,
+        totalFacts: this.facts.length,
+        totalSessions: this.sessions.length,
+        totalSummaries: this.summaries.length
+      };
+    } catch (error) {
+      return { success: false, message: error.message };
+    }
+  }
+
+  async exportToJSON() {
+    const exportDir = EXPORT_DIR;
+    try {
+      await fs.mkdir(exportDir, { recursive: true });
+    } catch {}
+
+    const now = new Date();
+    const timestamp = now.toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const filename = `kiku-memory-${timestamp}.json`;
+    const filePath = path.join(exportDir, filename);
+
+    const exportData = {
+      exportedAt: now.toISOString(),
+      stats: this.stats,
+      preferences: {
+        ...this.preferences,
+        topicsOfInterest: (this.preferences.topicsOfInterest || []).map(t => ({
+          ...t,
+          lastSeen: t.lastSeen ? t.lastSeen.toISOString() : null
+        }))
+      },
+      facts: this.facts.map(f => ({
+        ...f,
+        createdAt: f.createdAt ? f.createdAt.toISOString() : f.createdAt,
+        lastAccessedAt: f.lastAccessedAt ? f.lastAccessedAt.toISOString() : f.lastAccessedAt
+      })),
+      factsByCategory: this.getFactsByCategory(),
+      sessions: this.sessions,
+      summaries: this.summaries
+    };
+
+    await fs.writeFile(filePath, JSON.stringify(exportData, null, 2), 'utf-8');
+    return { filePath, filename, size: (await fs.stat(filePath)).size };
+  }
+
+  async clearAll() {
+    this.facts = [];
+    this.preferences = {
+      language: null,
+      topicsOfInterest: [],
+      responseStyle: 'default'
+    };
+    this.sessions = [];
+    this.summaries = [];
+    this.stats = {
+      totalFacts: 0,
+      totalSessions: 0,
+      totalConsolidations: 0,
+      lastConsolidationAt: null,
+      createdAt: new Date()
+    };
+    await this.save();
+    return true;
+  }
+
+  async getStorageSize() {
+    try {
+      const stat = await fs.stat(MEMORY_FILE);
+      return stat.size;
+    } catch {
+      return 0;
+    }
+  }
+
+  static formatBytes(bytes) {
+    if (bytes === 0) return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
+  }
+}