sema-core 2.0.0 → 2.0.1

package/dist/manager/StateManager.js

@@ -1,5 +1,15 @@
 "use strict";
 /**
+ * 多会话状态管理
+ *
+ * 两层隔离：sessionId → agentId
+ * - StateManager 是单例注册表，持有 Map<sessionId, SessionRuntime>
+ * - SessionRuntime 持有单个会话的全部状态：
+ *   - 按 agentId 隔离：statesMap / messageHistoryMap / readFileTimestampsMap / todosMap / todoTasksMap
+ *     （agentId='main' 为该会话主代理，子代理为各自 taskId）
+ *   - 会话级：abortController / 输入队列 / 编辑权限 / Plan&Design 模式标记 / 前台 agent 集合
+ *   - 会话级配置：agentMode / useTools
+ *
  * 子代理不触发 conversation:usage、message:chunk、tool:execution:chunk、state:update、todos:update、topic:update
  * 子代理相关事件 message:complete、tool:execution:complete、tool:execution:error、session:interrupted、tool:permission:request 有agentId字段
  */
@@ -37,7 +47,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStateManager = exports.StateManager = exports.MAIN_AGENT_ID = void 0;
+exports.getStateManager = exports.StateManager = exports.SessionRuntime = exports.MAIN_AGENT_ID = void 0;
 const crypto = __importStar(require("crypto"));
 const EventSystem_1 = require("../events/EventSystem");
 const log_1 = require("../util/log");
@@ -46,90 +56,49 @@ const ConfManager_1 = require("./ConfManager");
 // 主代理固定 ID
 exports.MAIN_AGENT_ID = 'main';
 /**
- * 全局状态管理器
- * 负责管理会话状态并发送状态更新事件
- *
- * 隔离状态（按 agentId）：
- * - statesMap: 代理状态 (currentState/previousState)
- * - messageHistoryMap: 消息历史
- * - readFileTimestampsMap: 文件读取时间戳
- * - todosMap: todos 列表
- *
- * 共享状态：
- * - sessionId: 会话ID
- * - globalEditPermissionGranted: 全局编辑权限
- * - currentAbortController: 中断控制器
+ * 单个会话的运行时状态
+ * 由 StateManager 按 sessionId 持有
  */
-class StateManager {
-    constructor() {
-        // === 隔离状态（按 agentId） ===
+class SessionRuntime {
+    constructor(sessionId) {
+        this.sessionId = sessionId;
+        // === 按 agentId 隔离 ===
         this.statesMap = new Map();
         this.messageHistoryMap = new Map();
         this.readFileTimestampsMap = new Map();
         this.todosMap = new Map();
         this.todoTasksMap = new Map();
         this.fileLineEndingsMap = new Map();
-        // === 共享状态 ===
-        this.sessionId = null;
+        // === 会话级状态 ===
+        this.currentAbortController = null;
         this.globalEditPermissionGranted = false;
         this.planModeInfoSent = false;
         this.designModeInfoSent = false;
-        this.currentAbortController = null;
         // 当前正在运行的前台 agent taskId 集合
         this.foregroundAgents = new Set();
-        // 待处理用户输入队列（共享状态）
+        // 待处理用户输入队列
         this.pendingUserInputs = [];
-        // 私有构造函数，确保单例模式
-    }
-    /**
-     * 获取StateManager实例（单例模式）
-     */
-    static getInstance() {
-        if (!StateManager.instance) {
-            StateManager.instance = new StateManager();
-        }
-        return StateManager.instance;
-    }
-    /**
-     * 获取当前会话ID
-     */
-    getSessionId() {
-        return this.sessionId;
-    }
-    /**
-     * 设置会话ID
-     */
-    setSessionId(sessionId) {
-        this.sessionId = sessionId;
-        // 新建会话时重置全局编辑权限
-        this.globalEditPermissionGranted = false;
-        (0, log_1.logInfo)(`会话ID已设置: ${sessionId}，全局编辑权限已重置`);
+        // === 会话级配置（从全局 coreConfig 下沉到会话级）===
+        this.agentMode = 'Agent';
+        // 会话级系统提示快照：首次构建后冻结，整个会话不再变化
+        this.systemPromptContent = null;
     }
     // ============================================================
     // 消息历史管理（按代理隔离）
     // ============================================================
-    /**
-     * 设置消息历史
-     */
     setMessageHistory(messages, agentId = exports.MAIN_AGENT_ID, skipAutoSave = false) {
         this.messageHistoryMap.set(agentId, messages);
         // 主代理设置消息历史时自动保存
-        if (!skipAutoSave && agentId === exports.MAIN_AGENT_ID && this.sessionId && messages.length > 0) {
+        if (!skipAutoSave && agentId === exports.MAIN_AGENT_ID && messages.length > 0) {
             this.saveSessionHistory();
         }
     }
-    /**
-     * 获取消息历史
-     */
     getMessageHistory(agentId = exports.MAIN_AGENT_ID) {
         return this.messageHistoryMap.get(agentId) || [];
     }
     // ============================================================
     // 文件读取时间戳管理（按代理隔离）
     // ============================================================
-    /**
-     * 获取文件读取时间戳
-     */
     getReadFileTimestamps(agentId = exports.MAIN_AGENT_ID) {
         let timestamps = this.readFileTimestampsMap.get(agentId);
         if (!timestamps) {
@@ -138,37 +107,22 @@ class StateManager {
         }
         return timestamps;
     }
-    /**
-     * 设置单个文件的读取时间戳
-     */
     setReadFileTimestamp(filePath, timestamp, agentId = exports.MAIN_AGENT_ID) {
         const timestamps = this.getReadFileTimestamps(agentId);
         timestamps[filePath] = timestamp;
     }
-    /**
-     * 批量设置文件读取时间戳（覆盖）
-     */
     setReadFileTimestamps(timestamps, agentId = exports.MAIN_AGENT_ID) {
         this.readFileTimestampsMap.set(agentId, { ...timestamps });
     }
-    /**
-     * 获取单个文件的读取时间戳
-     */
     getReadFileTimestamp(filePath, agentId = exports.MAIN_AGENT_ID) {
         return this.getReadFileTimestamps(agentId)[filePath];
     }
     // ============================================================
     // 文件换行符缓存（按代理隔离）
     // ============================================================
-    /**
-     * 获取缓存的文件换行符类型
-     */
     getFileLineEnding(filePath, agentId = exports.MAIN_AGENT_ID) {
         return this.fileLineEndingsMap.get(agentId)?.[filePath];
     }
-    /**
-     * 缓存文件的换行符类型
-     */
     setFileLineEnding(filePath, ending, agentId = exports.MAIN_AGENT_ID) {
         let endings = this.fileLineEndingsMap.get(agentId);
         if (!endings) {
@@ -180,74 +134,50 @@ class StateManager {
     // ============================================================
     // todos 管理（按代理隔离）
     // ============================================================
-    /**
-     * 获取 todos 列表
-     */
     getTodos(agentId = exports.MAIN_AGENT_ID) {
         return this.todosMap.get(agentId) || [];
     }
-    /**
-     * 设置 todos 列表
-     */
     setTodos(todos, agentId = exports.MAIN_AGENT_ID) {
         this.todosMap.set(agentId, todos);
     }
-    /**
-     * 清理指定代理的 todos
-     */
     clearAgentTodos(agentId) {
         if (agentId !== exports.MAIN_AGENT_ID) {
             this.todosMap.delete(agentId);
             (0, log_1.logInfo)(`[${agentId}] todos已清理`);
         }
     }
-    /**
-     * 智能更新 todos 列表
-     * 如果传入的 todos 都有 id 且是现有 todos 的子集，则进行子集更新，否则进行完全替换
-     */
     updateTodosIntelligently(newTodos, agentId = exports.MAIN_AGENT_ID) {
         const currentTodos = this.todosMap.get(agentId) || [];
         if (newTodos.length === 0) {
-            // 空数组直接替换
             this.todosMap.set(agentId, newTodos);
             (0, log_1.logInfo)(`[${agentId}] todos完全替换: ${newTodos.length} 项`);
-            // 只有主代理才发送事件
             if (agentId === exports.MAIN_AGENT_ID) {
                 this.emitTodosUpdateEvent(newTodos);
             }
             return;
         }
-        // 检查是否为子集更新
         const isSubsetUpdate = newTodos.every(todo => todo.id && currentTodos.some(existing => existing.id === todo.id));
         if (isSubsetUpdate && currentTodos.length > 0) {
-            // 子集更新：更新现有 todos 中匹配的项
             const updatedTodos = currentTodos.map(existing => {
                 const update = newTodos.find(todo => todo.id === existing.id);
                 return update || existing;
             });
             this.todosMap.set(agentId, updatedTodos);
             (0, log_1.logInfo)(`[${agentId}] todos子集更新: ${newTodos.length} 项更新，总共 ${updatedTodos.length} 项`);
-            // 只有主代理才发送事件
             if (agentId === exports.MAIN_AGENT_ID) {
                 this.emitTodosUpdateEvent(newTodos);
             }
         }
         else {
-            // 完全替换：有新的 id 或没有 id 的情况
             this.todosMap.set(agentId, newTodos);
             (0, log_1.logInfo)(`[${agentId}] todos完全替换: ${newTodos.length} 项`);
-            // 只有主代理才发送事件
             if (agentId === exports.MAIN_AGENT_ID) {
                 this.emitTodosUpdateEvent(newTodos);
             }
         }
     }
-    /**
-     * 发送 todos 更新事件
-     */
     emitTodosUpdateEvent(todos) {
-        const eventBus = (0, EventSystem_1.getEventBus)();
-        eventBus.emit('todos:update', todos);
+        (0, EventSystem_1.getEventBus)().emit('todos:update', todos, this.sessionId);
     }
     // ============================================================
     // TodoTask CRUD（按代理隔离）
@@ -262,7 +192,6 @@ class StateManager {
     }
     createTodoTask(agentId, task) {
         const tasks = this.getTodoTasks(agentId);
-        // 递增数字编号：取当前最大 id + 1
         const maxId = tasks.reduce((max, t) => Math.max(max, parseInt(t.id, 10) || 0), 0);
         const id = String(maxId + 1);
         const now = Date.now();
@@ -309,7 +238,6 @@ class StateManager {
         if (idx === -1)
             return false;
         tasks.splice(idx, 1);
-        // 清理其他任务中对被删任务的引用
         for (const t of tasks) {
             t.blocks = t.blocks.filter(id => id !== taskId);
             t.blockedBy = t.blockedBy.filter(id => id !== taskId);
@@ -318,17 +246,12 @@ class StateManager {
         this.syncTodoTasksToTodos(agentId);
         return true;
     }
-    /**
-     * 建立阻塞关系：fromId 阻塞 toId（toId 需等待 fromId 完成）
-     * 双向写入保持一致性
-     */
     blockTask(agentId, fromId, toId) {
         const tasks = this.getTodoTasks(agentId);
         const fromTask = tasks.find(t => t.id === fromId);
         const toTask = tasks.find(t => t.id === toId);
         if (!fromTask || !toTask)
             return false;
-        // 去重追加
         if (!fromTask.blocks.includes(toId)) {
             fromTask.blocks.push(toId);
             fromTask.updatedAt = Date.now();
@@ -341,11 +264,7 @@ class StateManager {
         this.syncTodoTasksToTodos(agentId);
         return true;
     }
-    /**
-     * 从持久化数据恢复 TodoTask 列表（主代理）
-     */
     restoreTodoTasks(tasks) {
-        // 兼容旧数据：补充 blocks/blockedBy 默认值
         const normalized = tasks.map(t => ({
             ...t,
             blocks: t.blocks ?? [],
@@ -354,12 +273,9 @@ class StateManager {
         this.todoTasksMap.set(exports.MAIN_AGENT_ID, normalized);
         (0, log_1.logInfo)(`TodoTasks restored: ${tasks.length} 项`);
     }
-    /**
-     * 从旧版 TodoItem 格式恢复为 TodoTask（兼容旧历史数据）
-     */
     restoreTodoTasksFromLegacy(todos) {
         const now = Date.now();
-        const tasks = todos.map((todo, index) => ({
+        const tasks = todos.map((todo) => ({
             id: todo.id || crypto.randomBytes(4).toString('hex'),
             title: todo.title,
             description: todo.title,
@@ -373,12 +289,8 @@ class StateManager {
         this.todoTasksMap.set(exports.MAIN_AGENT_ID, tasks);
         (0, log_1.logInfo)(`TodoTasks restored from legacy todos: ${tasks.length} 项`);
     }
-    /**
-     * 将 TodoTask 列表同步到 todosMap 并触发 UI 更新事件
-     */
     syncTodoTasksToTodos(agentId) {
         const tasks = this.getTodoTasks(agentId);
-        // 排序：completed > in_progress > pending；pending 中被阻塞的排最后
         const statusOrder = { completed: 0, in_progress: 1, pending: 2 };
         const completedIds = new Set(tasks.filter(t => t.status === 'completed').map(t => t.id));
         const sorted = [...tasks].sort((a, b) => {
@@ -386,7 +298,6 @@ class StateManager {
             const ob = statusOrder[b.status] ?? 3;
             if (oa !== ob)
                 return oa - ob;
-            // 同为 pending 时，被阻塞（且阻塞者未完成）的排后面
             if (a.status === 'pending' && b.status === 'pending') {
                 const aBlocked = a.blockedBy.some(id => !completedIds.has(id));
                 const bBlocked = b.blockedBy.some(id => !completedIds.has(id));
@@ -409,9 +320,6 @@ class StateManager {
     // ============================================================
     // 代理状态管理（按代理隔离）
     // ============================================================
-    /**
-     * 获取代理状态
-     */
     getAgentState(agentId) {
         let state = this.statesMap.get(agentId);
         if (!state) {
@@ -426,18 +334,13 @@ class StateManager {
      */
     updateState(newState, agentId = exports.MAIN_AGENT_ID) {
         const agentState = this.getAgentState(agentId);
-        // 添加调试日志
-        (0, log_1.logInfo)(`updateState: agentId=${agentId}, current=${agentState.currentState}, new=${newState}, sessionId=${this.sessionId}`);
+        (0, log_1.logInfo)(`updateState: sessionId=${this.sessionId}, agentId=${agentId}, current=${agentState.currentState}, new=${newState}`);
         if (agentState.currentState !== newState) {
             agentState.previousState = agentState.currentState;
             agentState.currentState = newState;
-            // 只有主代理才发送全局状态更新事件（直接使用 eventBus，参见方法注释）
             if (agentId === exports.MAIN_AGENT_ID) {
-                const eventBus = (0, EventSystem_1.getEventBus)();
-                const stateData = {
-                    state: newState
-                };
-                eventBus.emit('state:update', stateData);
+                const stateData = { state: newState };
+                (0, EventSystem_1.getEventBus)().emit('state:update', stateData, this.sessionId);
                 (0, log_1.logInfo)(`状态更新: ${agentState.previousState} → ${newState}`);
             }
             else {
@@ -448,14 +351,11 @@ class StateManager {
             (0, log_1.logInfo)(`updateState: 状态未变化`);
         }
     }
-    /**
-     * 获取当前状态
-     */
     getCurrentState(agentId = exports.MAIN_AGENT_ID) {
         return this.getAgentState(agentId).currentState;
     }
     // ============================================================
-    // 前台 Agent 管理（共享状态）
+    // 前台 Agent 管理（会话级）
     // ============================================================
     addForegroundAgent(taskId) {
         this.foregroundAgents.add(taskId);
@@ -470,24 +370,14 @@ class StateManager {
         this.foregroundAgents.clear();
     }
     // ============================================================
-    // 待处理用户输入队列管理（共享状态）
+    // 待处理用户输入队列管理（会话级）
     // ============================================================
-    /**
-     * 添加待处理输入到队列末尾
-     */
     addPendingUserInput(item) {
         this.pendingUserInputs.push(item);
     }
-    /**
-     * 获取待处理输入队列长度
-     */
     getPendingUserInputsLength() {
         return this.pendingUserInputs.length;
     }
-    /**
-     * 从队头连续取 inject 类型，遇到 command 停止
-     * 取出的从队列移除，command 及之后保留
-     */
     consumeInjectInputsBeforeNextCommand() {
         const result = [];
         while (this.pendingUserInputs.length > 0 &&
@@ -496,39 +386,36 @@ class StateManager {
         }
         return result;
     }
-    /**
-     * 消费全部剩余输入并清空队列
-     */
     consumeAllPendingInputs() {
         return this.pendingUserInputs.splice(0);
     }
-    /**
-     * 清空待处理输入队列
-     */
     clearPendingUserInputs() {
         this.pendingUserInputs = [];
     }
+    // ============================================================
+    // 清理
+    // ============================================================
     /**
-     * 清空所有状态数据
+     * 清空本会话所有状态数据
      */
     clearAllState() {
-        // 清空所有隔离状态的 Map
         this.statesMap.clear();
         this.messageHistoryMap.clear();
         this.readFileTimestampsMap.clear();
         this.todosMap.clear();
         this.todoTasksMap.clear();
-        // 重置共享状态
+        this.fileLineEndingsMap.clear();
         this.currentAbortController = null;
+        this.systemPromptContent = null;
         this.globalEditPermissionGranted = false;
         this.planModeInfoSent = false;
         this.designModeInfoSent = false;
         this.foregroundAgents.clear();
         this.clearPendingUserInputs();
-        (0, log_1.logInfo)(`所有状态数据已清空`);
+        (0, log_1.logInfo)(`[${this.sessionId}] 所有状态数据已清空`);
     }
     /**
-     * 清理指定代理的所有隔离状态
+     * 清理指定子代理的所有隔离状态
      */
     clearAgentState(agentId) {
         if (agentId !== exports.MAIN_AGENT_ID) {
@@ -537,6 +424,7 @@ class StateManager {
             this.readFileTimestampsMap.delete(agentId);
             this.todosMap.delete(agentId);
             this.todoTasksMap.delete(agentId);
+            this.fileLineEndingsMap.delete(agentId);
             (0, log_1.logInfo)(`[${agentId}] 所有隔离状态已清理`);
         }
     }
@@ -550,9 +438,8 @@ class StateManager {
             const todoTasks = this.listTodoTasks(exports.MAIN_AGENT_ID);
             const readFileTimestamps = this.getReadFileTimestamps(exports.MAIN_AGENT_ID);
             const workingDir = (0, ConfManager_1.getConfManager)().getCoreConfig()?.workingDir;
-            if (this.sessionId && messageHistory.length > 0) {
+            if (messageHistory.length > 0) {
                 await (0, history_1.saveHistory)(this.sessionId, messageHistory, todos, workingDir, readFileTimestamps, todoTasks);
-                // logInfo(`saveHistory: ${JSON.stringify(messageHistory, null, 2)}`)
                 (0, log_1.logInfo)(`会话历史已保存: ${this.sessionId}`);
             }
         }
@@ -560,20 +447,17 @@ class StateManager {
             (0, log_1.logInfo)(`保存会话历史失败: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    /**
-     * 获取全局编辑权限状态
-     */
+    // ============================================================
+    // 全局编辑权限（会话级）
+    // ============================================================
     hasGlobalEditPermission() {
         return this.globalEditPermissionGranted;
     }
-    /**
-     * 授予全局编辑权限
-     */
     grantGlobalEditPermission() {
         if (this.globalEditPermissionGranted)
             return;
         this.globalEditPermissionGranted = true;
-        (0, log_1.logInfo)('全局编辑权限已授予');
+        (0, log_1.logInfo)(`[${this.sessionId}] 全局编辑权限已授予`);
         this.emitAutoEditUpdate(true);
     }
     /**
@@ -586,64 +470,53 @@ class StateManager {
         if (this.globalEditPermissionGranted === enable)
             return;
         this.globalEditPermissionGranted = enable;
-        (0, log_1.logInfo)(`自动编辑已${enable ? '开启' : '关闭'}`);
+        (0, log_1.logInfo)(`[${this.sessionId}] 自动编辑已${enable ? '开启' : '关闭'}`);
         this.emitAutoEditUpdate(enable);
     }
-    /**
-     * 发送自动编辑状态更新事件
-     */
     emitAutoEditUpdate(enable) {
         const data = { enable };
-        (0, EventSystem_1.getEventBus)().emit('autoEdit:update', data);
+        (0, EventSystem_1.getEventBus)().emit('autoEdit:update', data, this.sessionId);
     }
-    /**
-     * 检查 Plan 模式信息是否已发送
-     */
+    // ============================================================
+    // Plan / Design 模式信息发送标记（会话级）
+    // ============================================================
     isPlanModeInfoSent() {
         return this.planModeInfoSent;
     }
-    /**
-     * 标记 Plan 模式信息已发送
-     */
     markPlanModeInfoSent() {
         this.planModeInfoSent = true;
-        (0, log_1.logInfo)('Plan 模式信息已标记为已发送');
+        (0, log_1.logInfo)(`[${this.sessionId}] Plan 模式信息已标记为已发送`);
     }
-    /**
-     * 重置 Plan 模式信息发送状态
-     */
     resetPlanModeInfoSent() {
         this.planModeInfoSent = false;
-        (0, log_1.logInfo)('Plan 模式信息发送状态已重置');
+        (0, log_1.logInfo)(`[${this.sessionId}] Plan 模式信息发送状态已重置`);
     }
-    /**
-     * 检查 Design 模式信息是否已发送
-     */
     isDesignModeInfoSent() {
         return this.designModeInfoSent;
     }
-    /**
-     * 标记 Design 模式信息已发送
-     */
     markDesignModeInfoSent() {
         this.designModeInfoSent = true;
-        (0, log_1.logInfo)('Design 模式信息已标记为已发送');
+        (0, log_1.logInfo)(`[${this.sessionId}] Design 模式信息已标记为已发送`);
     }
-    /**
-     * 重置 Design 模式信息发送状态
-     */
     resetDesignModeInfoSent() {
         this.designModeInfoSent = false;
-        (0, log_1.logInfo)('Design 模式信息发送状态已重置');
+        (0, log_1.logInfo)(`[${this.sessionId}] Design 模式信息发送状态已重置`);
+    }
+    // ============================================================
+    // 系统提示快照（会话级，整会话不变）
+    // ============================================================
+    getSystemPromptContent() {
+        return this.systemPromptContent;
+    }
+    setSystemPromptContent(content) {
+        this.systemPromptContent = content;
     }
     /**
      * 为指定 agentId 创建状态访问代理对象
-     * 返回一个封装了该 agentId 所有状态操作的对象
      */
     forAgent(agentId) {
         const isSubagent = agentId !== exports.MAIN_AGENT_ID;
         return {
-            // Todos 管理
             getTodos: () => this.getTodos(agentId),
             setTodos: (todos) => this.setTodos(todos, agentId),
             updateTodosIntelligently: (todos) => this.updateTodosIntelligently(todos, agentId),
@@ -652,7 +525,6 @@ class StateManager {
                     this.clearAgentTodos(agentId);
                 }
             },
-            // 消息历史管理
             getMessageHistory: () => this.getMessageHistory(agentId),
             setMessageHistory: (messages, skipAutoSave) => this.setMessageHistory(messages, agentId, skipAutoSave),
             finalizeMessages: (messages) => {
@@ -660,25 +532,20 @@ class StateManager {
                 this.updateState('idle', agentId);
             },
             flushHistory: () => this.saveSessionHistory(),
-            // 文件读取时间戳管理
             getReadFileTimestamps: () => this.getReadFileTimestamps(agentId),
             getReadFileTimestamp: (filePath) => this.getReadFileTimestamp(filePath, agentId),
             setReadFileTimestamp: (filePath, timestamp) => this.setReadFileTimestamp(filePath, timestamp, agentId),
             setReadFileTimestamps: (timestamps) => this.setReadFileTimestamps(timestamps, agentId),
-            // 文件换行符缓存
             getFileLineEnding: (filePath) => this.getFileLineEnding(filePath, agentId),
             setFileLineEnding: (filePath, ending) => this.setFileLineEnding(filePath, ending, agentId),
-            // 状态管理
             getCurrentState: () => this.getCurrentState(agentId),
             updateState: (state) => this.updateState(state, agentId),
-            // TodoTask CRUD
             createTodoTask: (task) => this.createTodoTask(agentId, task),
             getTodoTask: (taskId) => this.getTodoTask(agentId, taskId),
             listTodoTasks: () => this.listTodoTasks(agentId),
             updateTodoTask: (taskId, updates) => this.updateTodoTask(agentId, taskId, updates),
             deleteTodoTask: (taskId) => this.deleteTodoTask(agentId, taskId),
             blockTask: (fromId, toId) => this.blockTask(agentId, fromId, toId),
-            // 清理
             clearAllState: () => {
                 if (isSubagent) {
                     this.clearAgentState(agentId);
@@ -687,6 +554,82 @@ class StateManager {
         };
     }
 }
+exports.SessionRuntime = SessionRuntime;
+/**
+ * 全局状态管理器（单例注册表）
+ * 按 sessionId 持有多个 SessionRuntime
+ */
+class StateManager {
+    constructor() {
+        this.sessions = new Map();
+        /** UI 层当前打开的活跃会话（多会话共存时由 UI 指定，用于通知兜底投递） */
+        this.activeSessionId = null;
+    }
+    static getInstance() {
+        if (!StateManager.instance) {
+            StateManager.instance = new StateManager();
+        }
+        return StateManager.instance;
+    }
+    /**
+     * 获取（不存在则创建）指定会话的运行时
+     */
+    session(sessionId) {
+        let runtime = this.sessions.get(sessionId);
+        if (!runtime) {
+            runtime = new SessionRuntime(sessionId);
+            this.sessions.set(sessionId, runtime);
+            (0, log_1.logInfo)(`SessionRuntime 已创建: ${sessionId}`);
+        }
+        return runtime;
+    }
+    /**
+     * 从 AgentContext 直接取得代理状态访问器
+     */
+    forAgent(ctx) {
+        return this.session(ctx.sessionId).forAgent(ctx.agentId);
+    }
+    hasSession(sessionId) {
+        return this.sessions.has(sessionId);
+    }
+    /** 设置 UI 层当前活跃会话 */
+    setActiveSession(sessionId) {
+        this.activeSessionId = sessionId;
+    }
+    /** 获取 UI 层当前活跃会话（未设置或已关闭则为 null） */
+    getActiveSessionId() {
+        return this.activeSessionId;
+    }
+    /**
+     * 移除单个会话的全部状态（会话级 dispose）
+     */
+    removeSession(sessionId) {
+        const runtime = this.sessions.get(sessionId);
+        if (runtime) {
+            runtime.clearAllState();
+            this.sessions.delete(sessionId);
+            (0, log_1.logInfo)(`SessionRuntime 已移除: ${sessionId}`);
+        }
+        // 活跃会话被关闭：清空，等待 UI 指定新的活跃会话
+        if (this.activeSessionId === sessionId) {
+            this.activeSessionId = null;
+        }
+    }
+    /**
+     * 清空所有会话（进程级 dispose）
+     */
+    clearAll() {
+        for (const runtime of this.sessions.values()) {
+            runtime.clearAllState();
+        }
+        this.sessions.clear();
+        this.activeSessionId = null;
+        (0, log_1.logInfo)(`所有会话状态数据已清空`);
+    }
+    getSessionIds() {
+        return Array.from(this.sessions.keys());
+    }
+}
 exports.StateManager = StateManager;
 StateManager.instance = null;
 /**