foliko 1.1.68 → 1.1.69

package/plugins/session-plugin.js

@@ -1,249 +1,285 @@
 /**
- * Session 会话管理插件
- * 管理多个用户会话，支持会话隔离和历史记录
+ * Session Plugin - Session management with JSONL tree structure
+ * Rewritten to use pi-style SessionManager
  */
 
-const { Plugin } = require('../src/core/plugin-base')
-const { logger } = require('../src/utils/logger')
-const log = logger.child('Session')
-const { z } = require('zod')
-const { EventEmitter } = require('events')
+const { Plugin } = require('../src/core/plugin-base');
+const { logger } = require('../src/utils/logger');
+const log = logger.child('Session');
+const { z } = require('zod');
+const { EventEmitter } = require('events');
+const path = require('path');
+const { SessionManager } = require('../src/core/session-manager');
+const { buildSessionContext, EntryTypes } = require('../src/core/session-entry');
 
 /**
- * 生成 UUID
+ * Get default session directory for a cwd
  */
-function generateId() {
-  if (require('crypto').randomUUID) {
-    return require('crypto').randomUUID()
-  }
-  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
-    const r = Math.random() * 16 | 0
-    const v = c === 'x' ? r : (r & 0x3 | 0x8)
-    return v.toString(16)
-  })
+function getDefaultSessionDir(cwd) {
+  const agentDir = path.join(process.cwd(), '.foliko');
+  const sessionDir = path.join(agentDir, 'sessions');
+  return sessionDir;
 }
 
 class SessionPlugin extends Plugin {
   constructor(config = {}) {
-    super()
-    this.name = 'session'
-    this.version = '1.0.0'
-    this.description = '会话管理插件，支持多会话隔离、历史记录、会话超时清理'
-    this.priority = 5
+    super();
+    this.name = 'session';
+    this.version = '2.0.0';
+    this.description = '会话管理插件，支持多会话隔离、历史记录、树形分支结构';
+    this.priority = 5;
 
-    this.system = true
+    this.system = true;
 
     this.config = {
-      sessionTTL: config.sessionTTL || 30 * 60 * 1000,  // 30分钟
+      sessionTTL: config.sessionTTL || 30 * 60 * 1000,
       maxSessions: config.maxSessions || 100,
-      maxHistoryLength: config.maxHistoryLength || 150,  // 放宽到 150，Agent 已有智能压缩
-      autoCleanup: config.autoCleanup||false,  // 默认不开启自动清理，避免误删会话
-      cleanupInterval: config.cleanupInterval || 5 * 60 * 1000,  // 5分钟
-      persistToStorage: config.persistToStorage !== false,  // 默认持久化到 storage
-      // Session 钩子配置
+      maxHistoryLength: config.maxHistoryLength || 150,
+      autoCleanup: config.autoCleanup !== undefined ? config.autoCleanup : true,
+      cleanupInterval: config.cleanupInterval || 5 * 60 * 1000,
+      persistToStorage: config.persistToStorage !== false,
       onSessionStart: config.onSessionStart || null,
       onSessionEnd: config.onSessionEnd || null,
       onSessionCreated: config.onSessionCreated || null
-    }
-    // console.log('SessionPlugin config:', this.config)
-    this._framework = null
-    this._sessions = new Map()
-    this._cleanupTimer = null
-    this._events = new EventEmitter()
-    this._storageKeyPrefix = 'session:'
-  }
+    };
 
-  install(framework) {
-    this._framework = framework
-    return this
+    this._framework = null;
+    this._sessionManagers = new Map(); // sessionId -> SessionManager
+    this._cleanupTimer = null;
+    this._events = new EventEmitter();
   }
 
-  /**
-   * 获取存储实例
-   * @private
-   */
-  _getStorage() {
-    if (!this._framework) return null;
-    return this._framework.pluginManager.get('storage');
+  install(framework) {
+    this._framework = framework;
+    return this;
   }
 
   /**
-   * 从 storage 加载会话数据
-   * @private
+   * Get or create a SessionManager for a session
    */
-  _loadFromStorage(sessionId) {
-    const storage = this._getStorage();
-    if (!storage) return null;
-
-    try {
-      const store = storage.getStore();
-      const data = store.get(this._storageKeyPrefix + sessionId);
-      if (data && data.messages) {
-        return data;
-      }
-    } catch (err) {
-      // 忽略加载错误
+  _getSessionManager(sessionId, cwd = process.cwd()) {
+    if (this._sessionManagers.has(sessionId)) {
+      return this._sessionManagers.get(sessionId);
     }
-    return null;
-  }
-
-  /**
-   * 保存会话数据到 storage
-   * @private
-   */
-  _saveToStorage(session) {
-    const storage = this._getStorage();
-    if (!storage || !this.config.persistToStorage) return;
 
-    try {
-      storage.setDirect(this._storageKeyPrefix + session.id, {
-        messages: session.messages,
-        variables: session.variables,
-        metadata: session.metadata,
-        createdAt: session.createdAt,
-        lastActive: session.lastActive
-      });
-    } catch (err) {
-      // 忽略保存错误
-    }
+    const sessionDir = getDefaultSessionDir(cwd);
+    const sessionFile = path.join(sessionDir, `${sessionId}.jsonl`);
+    const manager = new SessionManager(cwd, sessionDir, sessionFile, true);
+    this._sessionManagers.set(sessionId, manager);
+    return manager;
   }
 
   /**
-   * 从 storage 删除会话数据
-   * @private
+   * List all sessions for current cwd
    */
-  _deleteFromStorage(sessionId) {
-    const storage = this._getStorage();
-    if (!storage) return;
+  async listSessions(cwd = process.cwd()) {
+    const sessionDir = getDefaultSessionDir(cwd);
+    const sessions = [];
 
     try {
-      storage.deleteDirect(this._storageKeyPrefix + sessionId);
-    } catch (err) {
-      // 忽略删除错误
-    }
-  }
-
-  /**
-   * 从 storage 加载所有会话
-   * @private
-   */
-  _loadAllFromStorage() {
-    const storage = this._getStorage();
-    if (!storage) return;
+      if (!require('fs').existsSync(sessionDir)) {
+        return sessions;
+      }
 
-    try {
-      const store = storage.getStore();
-      // 遍历 storage 找出所有 session: 开头的键
-      for (const [key, value] of store.entries()) {
-        if (key.startsWith(this._storageKeyPrefix)) {
-          const sessionId = key.substring(this._storageKeyPrefix.length);
-          const sessionData = value;
-          if (sessionId && sessionData && sessionData.messages) {
-            // 恢复会话到内存
-            this._sessions.set(sessionId, {
-              id: sessionId,
-              messages: sessionData.messages || [],
-              variables: sessionData.variables || {},
-              metadata: sessionData.metadata || {},
-              createdAt: sessionData.createdAt ? new Date(sessionData.createdAt) : new Date(),
-              lastActive: sessionData.lastActive ? new Date(sessionData.lastActive) : new Date()
-            });
-          }
+      const files = require('fs').readdirSync(sessionDir)
+        .filter(f => f.endsWith('.jsonl'));
+
+      for (const file of files) {
+        const filePath = path.join(sessionDir, file);
+        try {
+          const manager = SessionManager.open(filePath, sessionDir, cwd);
+          sessions.push({
+            sessionId: manager.getSessionId(),
+            sessionFile: manager.getSessionFile(),
+            messageCount: manager.getEntries().length,
+            leafId: manager.getLeafId()
+          });
+        } catch {
+          // Skip invalid session files
         }
       }
-      log.info(`Loaded ${this._sessions.size} sessions from storage`);
     } catch (err) {
-      log.warn('Failed to load sessions from storage:', err.message);
+      log.warn('Failed to list sessions:', err.message);
     }
+
+    return sessions;
   }
 
   start(framework) {
-    // 从 storage 加载所有会话
-    this._loadAllFromStorage();
-    // 注册会话管理工具
+    // Register session management tools
     framework.registerTool({
       name: 'session_create',
       description: '创建新会话',
       inputSchema: z.object({
         sessionId: z.string().optional().describe('可选：指定会话 ID'),
-        metadata: z.object({}).optional().describe('会话元数据')
+        cwd: z.string().optional().describe('工作目录')
       }),
-      execute: async (args) => {
-        const sessionId = args.sessionId || `session_${generateId()}`
-        const session = this.createSession(sessionId, { metadata: args.metadata })
+      execute: async (args, fw) => {
+        const cwd = args.cwd || process.cwd();
+        const sessionDir = getDefaultSessionDir(cwd);
+        const manager = new SessionManager(cwd, sessionDir, undefined, true);
+        const sessionId = manager.getSessionId();
+        this._sessionManagers.set(sessionId, manager);
+
         return {
           success: true,
-          data: { sessionId: session.id, createdAt: session.createdAt }
-        }
+          data: {
+            sessionId,
+            sessionFile: manager.getSessionFile(),
+            createdAt: new Date().toISOString()
+          }
+        };
       }
-    })
+    });
 
     framework.registerTool({
       name: 'session_get',
       description: '获取会话信息',
       inputSchema: z.object({
-        sessionId: z.string().describe('会话 ID')
+        sessionId: z.string().describe('会话 ID'),
+        cwd: z.string().optional().describe('工作目录')
       }),
       execute: async (args) => {
-        const session = this.getSession(args.sessionId)
-        if (!session) {
-          return { success: false, error: 'Session not found' }
-        }
+        const cwd = args.cwd || process.cwd();
+        const manager = this._getSessionManager(args.sessionId, cwd);
+        const entries = manager.getEntries();
+
         return {
           success: true,
           data: {
-            sessionId: session.id,
-            messageCount: session.messages.length,
-            variables: Object.keys(session.variables),
-            createdAt: session.createdAt,
-            lastActive: session.lastActive
+            sessionId: manager.getSessionId(),
+            messageCount: entries.length,
+            leafId: manager.getLeafId(),
+            sessionFile: manager.getSessionFile()
           }
-        }
+        };
       }
-    })
+    });
 
     framework.registerTool({
       name: 'session_list',
       description: '列出所有会话',
-      inputSchema: z.object({}),
-      execute: async () => {
-        const sessions = this.listSessions()
+      inputSchema: z.object({
+        cwd: z.string().optional().describe('工作目录')
+      }),
+      execute: async (args) => {
+        const cwd = args.cwd || process.cwd();
+        const sessions = await this.listSessions(cwd);
         return {
           success: true,
           data: sessions,
           metadata: { total: sessions.length }
-        }
+        };
       }
-    })
+    });
 
     framework.registerTool({
       name: 'session_delete',
       description: '删除会话',
       inputSchema: z.object({
-        sessionId: z.string().describe('会话 ID')
+        sessionId: z.string().describe('会话 ID'),
+        cwd: z.string().optional().describe('工作目录')
       }),
       execute: async (args) => {
-        const deleted = this.deleteSession(args.sessionId)
-        return { success: deleted, data: `会话 ${args.sessionId} 已${deleted ? '删除' : '删除失败'}` }
+        const cwd = args.cwd || process.cwd();
+        const manager = this._getSessionManager(args.sessionId, cwd);
+
+        if (manager.getSessionFile() && require('fs').existsSync(manager.getSessionFile())) {
+          require('fs').unlinkSync(manager.getSessionFile());
+        }
+
+        this._sessionManagers.delete(args.sessionId);
+
+        return { success: true, data: `Session ${args.sessionId} deleted` };
       }
-    })
+    });
 
     framework.registerTool({
       name: 'session_history',
       description: '获取会话历史消息',
       inputSchema: z.object({
         sessionId: z.string().describe('会话 ID'),
+        cwd: z.string().optional().describe('工作目录'),
         limit: z.number().optional().describe('返回消息数量限制')
       }),
       execute: async (args) => {
-        const history = this.getHistory(args.sessionId, args.limit)
+        const cwd = args.cwd || process.cwd();
+        const manager = this._getSessionManager(args.sessionId, cwd);
+        const context = manager.buildSessionContext();
+        let messages = context.messages;
+
+        if (args.limit) {
+          messages = messages.slice(-args.limit);
+        }
+
         return {
           success: true,
-          data: history,
-          metadata: { sessionId: args.sessionId, count: history.length }
+          data: messages,
+          metadata: {
+            sessionId: args.sessionId,
+            count: messages.length,
+            thinkingLevel: context.thinkingLevel
+          }
+        };
+      }
+    });
+
+    framework.registerTool({
+      name: 'session_branch',
+      description: '创建新分支',
+      inputSchema: z.object({
+        sessionId: z.string().describe('会话 ID'),
+        entryId: z.string().describe('分支点 entry ID'),
+        cwd: z.string().optional().describe('工作目录')
+      }),
+      execute: async (args) => {
+        const cwd = args.cwd || process.cwd();
+        const manager = this._getSessionManager(args.sessionId, cwd);
+
+        try {
+          manager.branch(args.entryId);
+          return {
+            success: true,
+            data: {
+              sessionId: args.sessionId,
+              newLeafId: args.entryId,
+              message: `Branch created from entry ${args.entryId}`
+            }
+          };
+        } catch (err) {
+          return { success: false, error: err.message };
+        }
+      }
+    });
+
+    framework.registerTool({
+      name: 'session_branch_with_summary',
+      description: '创建带摘要的分支',
+      inputSchema: z.object({
+        sessionId: z.string().describe('会话 ID'),
+        entryId: z.string().optional().describe('分支点 entry ID'),
+        summary: z.string().describe('分支摘要'),
+        cwd: z.string().optional().describe('工作目录')
+      }),
+      execute: async (args) => {
+        const cwd = args.cwd || process.cwd();
+        const manager = this._getSessionManager(args.sessionId, cwd);
+
+        try {
+          const branchId = manager.branchWithSummary(args.entryId || null, args.summary);
+          return {
+            success: true,
+            data: {
+              sessionId: args.sessionId,
+              branchId,
+              message: `Branch created with summary`
+            }
+          };
+        } catch (err) {
+          return { success: false, error: err.message };
         }
       }
-    })
+    });
 
     framework.registerTool({
       name: 'session_stats',
@@ -252,321 +288,201 @@ class SessionPlugin extends Plugin {
       execute: async () => {
         return {
           success: true,
-          data: this.getMemoryStats()
-        }
+          data: {
+            activeSessions: this._sessionManagers.size,
+            maxSessions: this.config.maxSessions
+          }
+        };
       }
-    })
+    });
 
-    // 启动自动清理
+    // Start auto cleanup if enabled
     if (this.config.autoCleanup) {
-      this._startAutoCleanup()
+      this._startAutoCleanup();
     }
 
-    return this
+    return this;
   }
 
   /**
-   * 创建新会话
+   * Add message to session
    */
-  createSession(sessionId, options = {}) {
-    const id = sessionId || `session_${generateId()}`
-
-    if (this._sessions.has(id)) {
-      return this._sessions.get(id)
-    }
-
-    // 如果会话数超过限制，清理最老的
-    // if (this._sessions.size >= this.config.maxSessions) {
-    //   this._cleanupLRU()
-    // }
-
-    const session = {
-      id,
-      messages: options.initialMessages || [],
-      variables: options.variables || {},
-      metadata: options.metadata || {},
-      createdAt: new Date(),
-      lastActive: new Date()
-    }
-
-    this._sessions.set(id, session)
-    this._saveToStorage(session)
-
-    // 触发 session:created 事件
-    this._events.emit('session:created', session)
+  addMessage(sessionId, message, cwd = process.cwd()) {
+    const manager = this._getSessionManager(sessionId, cwd);
+    const entryId = manager.appendMessage(message);
 
-    // 调用 onSessionCreated 钩子
-    if (this.config.onSessionCreated) {
-      this._callHook(this.config.onSessionCreated, session)
+    // Emit session event
+    if (manager.getEntries().length === 1) {
+      this._events.emit('session:created', { sessionId, manager });
     }
 
-    return session
+    return entryId;
   }
 
   /**
-   * 获取会话
+   * Get session context for LLM
    */
-  getSession(sessionId) {
-    let session = this._sessions.get(sessionId)
-    if (session) {
-      session.lastActive = new Date()
-      return session
-    }
-
-    // 尝试从 storage 加载
-    const storageData = this._loadFromStorage(sessionId)
-    if (storageData) {
-      session = {
-        id: sessionId,
-        messages: storageData.messages || [],
-        variables: storageData.variables || {},
-        metadata: storageData.metadata || {},
-        createdAt: storageData.createdAt ? new Date(storageData.createdAt) : new Date(),
-        lastActive: new Date()
-      }
-      this._sessions.set(sessionId, session)
-      return session
-    }
-
-    return null
+  getSessionContext(sessionId, cwd = process.cwd()) {
+    const manager = this._getSessionManager(sessionId, cwd);
+    return manager.buildSessionContext();
   }
 
   /**
-   * 获取或创建会话
+   * Get or create session (alias for getSessionContext)
    */
-  getOrCreateSession(sessionId, options = {}) {
-    let session = this.getSession(sessionId)
-    if (!session) {
-      session = this.createSession(sessionId, options)
-    }
-    return session
+  getOrCreateSession(sessionId, options = {}, cwd = process.cwd()) {
+    return this.getSessionContext(sessionId, cwd);
   }
 
   /**
-   * 添加消息到会话
+   * Get specific entry
    */
-  addMessage(sessionId, message) {
-    const session = this.getSession(sessionId)
-    if (session) {
-      // 基础消息验证
-      if (!message || !message.role || !message.content) {
-        log.warn('Invalid message format, skipping:', { sessionId, message });
-        return session;
-      }
-
-      // 触发 session:started 事件（首次添加消息时）
-      if (session.messages.length === 0) {
-        this._events.emit('session:started', session)
-        if (this.config.onSessionStart) {
-          this._callHook(this.config.onSessionStart, session)
-        }
-      }
-
-      session.messages.push(message)
-      session.lastActive = new Date()
-
-      // 限制历史长度
-      if (session.messages.length > this.config.maxHistoryLength) {
-        session.messages = session.messages.slice(-this.config.maxHistoryLength)
-      }
-
-      // 持久化到 storage
-      this._saveToStorage(session)
-    }
-    return session
-  }
-
-  /**
-   * 整体替换会话消息（用于压缩后同步）
-   * @param {string} sessionId - 会话 ID
-   * @param {Array} messages - 新的消息数组
-   */
-  replaceMessages(sessionId, messages) {
-    const session = this.getSession(sessionId)
-    if (session) {
-      session.messages = messages || []
-      session.lastActive = new Date()
-      // 持久化到 storage
-      this._saveToStorage(session)
-    }
-    return session
+  getEntry(sessionId, entryId, cwd = process.cwd()) {
+    const manager = this._getSessionManager(sessionId, cwd);
+    return manager.getEntry(entryId);
   }
 
   /**
-   * 获取会话历史
+   * Get branch (path from root to leaf)
    */
-  getHistory(sessionId, limit = null) {
-    const session = this.getSession(sessionId)
-    if (!session) return []
-
-    const messages = session.messages
-    if (limit) {
-      return messages.slice(-limit)
-    }
-    return messages
+  getBranch(sessionId, fromId, cwd = process.cwd()) {
+    const manager = this._getSessionManager(sessionId, cwd);
+    return manager.getBranch(fromId);
   }
 
   /**
-   * 删除会话
+   * Append compaction entry
    */
-  deleteSession(sessionId) {
-    const deleted = this._sessions.delete(sessionId)
-    if (deleted) {
-      this._deleteFromStorage(sessionId)
-      this._events.emit('session:deleted', sessionId)
-    }
-    return deleted
+  appendCompaction(sessionId, summary, firstKeptEntryId, tokensBefore, details, cwd = process.cwd()) {
+    const manager = this._getSessionManager(sessionId, cwd);
+    return manager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, false);
   }
 
   /**
-   * 列出所有会话
+   * Append thinking level change
    */
-  listSessions() {
-    return Array.from(this._sessions.values()).map(s => ({
-      id: s.id,
-      messageCount: s.messages.length,
-      createdAt: s.createdAt,
-      lastActive: s.lastActive,
-      metadata: s.metadata
-    }))
+  appendThinkingLevelChange(sessionId, thinkingLevel, cwd = process.cwd()) {
+    const manager = this._getSessionManager(sessionId, cwd);
+    return manager.appendThinkingLevelChange(thinkingLevel);
   }
 
   /**
-   * 清理过期会话
+   * Append model change
    */
-  cleanup() {
-    const now = Date.now()
-    let cleanedCount = 0
-
-    for (const [sessionId, session] of this._sessions) {
-      if (now - session.lastActive.getTime() > this.config.sessionTTL) {
-        this._sessions.delete(sessionId)
-        cleanedCount++
-      }
-    }
-
-    return cleanedCount
+  appendModelChange(sessionId, provider, modelId, cwd = process.cwd()) {
+    const manager = this._getSessionManager(sessionId, cwd);
+    return manager.appendModelChange(provider, modelId);
   }
 
   /**
-   * LRU 清理 - 删除最老的 20% 会话
+   * Set session label
    */
-  _cleanupLRU() {
-    const sessions = Array.from(this._sessions.values())
-    if (sessions.length === 0) return
-
-    // 按最后活跃时间排序
-    sessions.sort((a, b) => a.lastActive.getTime() - b.lastActive.getTime())
-
-    // 删除最老的会话
-    const toDelete = sessions.slice(0, Math.ceil(sessions.length * 0.2))
-    for (const session of toDelete) {
-      this._sessions.delete(session.id)
-    }
+  setLabel(sessionId, entryId, label, cwd = process.cwd()) {
+    const manager = this._getSessionManager(sessionId, cwd);
+    return manager.appendLabelChange(entryId, label);
   }
 
   /**
-   * 获取内存统计
+   * Get session info (compatible with external callers)
    */
-  getMemoryStats() {
-    const sessionCount = this._sessions.size
-    const totalMessages = Array.from(this._sessions.values()).reduce(
-      (sum, s) => sum + s.messages.length, 0
-    )
-
+  getSession(sessionId, cwd = process.cwd()) {
+    const manager = this._getSessionManager(sessionId, cwd);
+    const entries = manager.getEntries();
     return {
-      sessionCount,
-      maxSessions: this.config.maxSessions,
-      totalMessages,
-      ttl: this.config.sessionTTL
-    }
+      id: sessionId,
+      messages: entries.filter(e => e.type === 'message'),
+      lastActive: manager.getHeader()?.timestamp ? new Date(manager.getHeader().timestamp) : null,
+    };
   }
 
   /**
-   * 清理所有会话
+   * Start auto cleanup timer
    */
-  clear() {
-    const sessionIds = Array.from(this._sessions.keys())
-    this._sessions.clear()
-    sessionIds.forEach(id => this._events.emit('session:deleted', id))
-  }
-
-  /**
-   * 监听会话事件
-   */
-  on(event, listener) {
-    this._events.on(event, listener)
+  _startAutoCleanup() {
+    if (this._cleanupTimer) {
+      clearInterval(this._cleanupTimer);
+    }
+    this._cleanupTimer = setInterval(async () => {
+      await this._doCleanup();
+    }, this.config.cleanupInterval);
+    log.info(`Auto cleanup started (interval: ${this.config.cleanupInterval}ms)`);
   }
 
   /**
-   * 移除会话事件监听
+   * Perform cleanup of old sessions and message history
    */
-  off(event, listener) {
-    this._events.off(event, listener)
-  }
+  async _doCleanup() {
+    try {
+      const fs = require('fs');
+      const sessionDir = getDefaultSessionDir(process.cwd());
+      
+      if (!fs.existsSync(sessionDir)) {
+        return;
+      }
 
-  /**
-   * 调用会话钩子
-   * @param {Function} hook - 钩子函数
-   * @param {Object} session - 会话对象
-   * @private
-   */
-  _callHook(hook, session) {
-    if (typeof hook === 'function') {
-      try {
-        const result = hook(session)
-        if (result && typeof result.catch === 'function') {
-          result.catch(err => log.warn('Session hook error:', err.message))
+      const files = fs.readdirSync(sessionDir).filter(f => f.endsWith('.jsonl'));
+      let cleanedCount = 0;
+
+      for (const file of files) {
+        const filePath = path.join(sessionDir, file);
+        try {
+          const manager = SessionManager.open(filePath, sessionDir, process.cwd());
+          const entries = manager.getEntries();
+          
+          // Clean up if exceeds maxHistoryLength
+          if (entries.length > this.config.maxHistoryLength) {
+            const toRemove = entries.length - this.config.maxHistoryLength;
+            // Keep session header, remove oldest entries
+            const entriesToKeep = manager.fileEntries.filter(e => e.type === 'session');
+            const messagesToKeep = manager.fileEntries
+              .filter(e => e.type !== 'session')
+              .slice(-this.config.maxHistoryLength);
+            
+            manager.fileEntries = [...entriesToKeep, ...messagesToKeep];
+            manager._rewriteFile();
+            cleanedCount++;
+            log.debug(`Cleaned ${file}: removed ${toRemove} entries, kept ${this.config.maxHistoryLength}`);
+          }
+        } catch (err) {
+          log.warn(`Failed to cleanup session ${file}: ${err.message}`);
         }
-      } catch (err) {
-        log.warn('Session hook error:', err.message)
       }
+
+      if (cleanedCount > 0) {
+        log.info(`Auto cleanup completed: cleaned ${cleanedCount} sessions`);
+      }
+    } catch (err) {
+      log.error(`Auto cleanup error: ${err.message}`);
     }
   }
 
   /**
-   * 结束会话（触发 session:ended 事件）
-   * 当会话完成处理时调用
-   * @param {string} sessionId - 会话 ID
+   * On session event listener
    */
-  endSession(sessionId) {
-    const session = this.getSession(sessionId)
-    if (session) {
-      this._events.emit('session:ended', session)
-      if (this.config.onSessionEnd) {
-        this._callHook(this.config.onSessionEnd, session)
-      }
-    }
+  on(event, listener) {
+    this._events.on(event, listener);
   }
 
   /**
-   * 启动自动清理定时器
+   * Off session event listener
    */
-  _startAutoCleanup() {
-    if (this._cleanupTimer) {
-      clearInterval(this._cleanupTimer)
-    }
-    this._cleanupTimer = setInterval(() => {
-      const cleaned = this.cleanup()
-      if (cleaned > 0) {
-        //log.info(` Cleaned up ${cleaned} expired sessions`)
-      }
-    }, this.config.cleanupInterval)
+  off(event, listener) {
+    this._events.off(event, listener);
   }
 
   reload(framework) {
-    this._framework = framework
+    this._framework = framework;
   }
 
   uninstall(framework) {
     if (this._cleanupTimer) {
-      clearInterval(this._cleanupTimer)
-      this._cleanupTimer = null
+      clearInterval(this._cleanupTimer);
+      this._cleanupTimer = null;
     }
-    this._events.removeAllListeners()
-    this._sessions.clear()
-    this._framework = null
+    this._events.removeAllListeners();
+    this._sessionManagers.clear();
+    this._framework = null;
   }
 }
 
-module.exports = SessionPlugin
+module.exports = { SessionPlugin };