sema-core 2.0.0 → 2.0.1

package/dist/core/SemaEngine.d.ts

@@ -1,21 +1,25 @@
-import { EventBus } from '../events/EventSystem';
+import { SessionEventBus } from '../events/EventSystem';
 import type { AgentMode } from '../types';
+import type { CreateSessionOptions } from '../types/session';
 /**
- * Sema 引擎 - 处理核心业务逻辑
+ * Sema 引擎 - 单个会话的核心业务逻辑
+ * 每个会话一个实例，绑定固定的 sessionId
  */
 export declare class SemaEngine {
-    private pendingSession;
+    readonly sessionId: string;
+    private readonly bus;
+    /** 当前正在执行的 processQuery Promise（用于 dispose 时等待） */
     private currentProcessingPromise;
-    private eventBus;
+    private readonly runtime;
     emit: <T>(event: string, data: T) => boolean;
-    on: <T>(event: string, listener: (data: T) => void) => EventBus;
-    once: <T>(event: string, listener: (data: T) => void) => EventBus;
-    off: <T>(event: string, listener: (data: T) => void) => EventBus;
-    constructor();
+    on: <T>(event: string, listener: (data: T) => void) => SessionEventBus;
+    once: <T>(event: string, listener: (data: T) => void) => SessionEventBus;
+    off: <T>(event: string, listener: (data: T) => void) => SessionEventBus;
+    constructor(sessionId: string, bus: SessionEventBus);
     /**
-     * 创建会话
+     * 初始化会话：加载历史、发送 session:ready
      */
-    createSession(sessionId?: string): Promise<void>;
+    createSession(opts?: CreateSessionOptions): Promise<void>;
     /**
      * 处理用户输入
      * 如果当前正在处理中，将输入加入队列等待
@@ -31,22 +35,27 @@ export declare class SemaEngine {
     private processQuery;
     /**
      * 中止当前正在进行的请求（仅处理 AbortController）
-     * 不更新状态，用于内部调用
      */
     private abortCurrentRequest;
     /**
      * 中断当前会话
-     * 仅中断当前正在执行的请求，队列中的待处理输入不受影响
-     * 由 processQuery 的 finally 决定是否继续消费队列或设为 idle
      */
     interruptSession(): void;
     /**
-     * 更新 Agent 模式
+     * 更新 Agent 模式（会话级）
      */
     updateAgentMode(mode: AgentMode): void;
+    /**
+     * 更新自动编辑状态
+     */
+    updateAutoEdit(enable: boolean): void;
     private initialize;
     /**
-     * 清理资源和停止所有活动
+     * 等待当前处理结束（最多 timeoutMs 毫秒）
+     */
+    waitForIdle(timeoutMs?: number): Promise<void>;
+    /**
+     * 清理本会话资源（会话级，不触碰全局单例）
      */
     dispose(): void;
 }

package/dist/core/SemaEngine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SemaEngine.d.ts","sourceRoot":"","sources":["../../src/core/SemaEngine.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAWjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAG1C;;GAEG;AACH,qBAAa,UAAU;IAErB,OAAO,CAAC,cAAc,CAAsB;IAE5C,OAAO,CAAC,wBAAwB,CAA6B;IAG7D,OAAO,CAAC,QAAQ,CAA0B;IAC1C,IAAI,GAAI,CAAC,EAAE,OAAO,MAAM,EAAE,MAAM,CAAC,aAA4D;IAC7F,EAAE,GAAI,CAAC,EAAE,OAAO,MAAM,EAAE,UAAU,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,cAAuC;IAC1F,IAAI,GAAI,CAAC,EAAE,OAAO,MAAM,EAAE,UAAU,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,cAAyC;IAC9F,GAAG,GAAI,CAAC,EAAE,OAAO,MAAM,EAAE,UAAU,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,cAAwC;;IAc5F;;OAEG;IACG,aAAa,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA8FtD;;;OAGG;IACH,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI;IAgD/E;;OAEG;IACH,OAAO,CAAC,UAAU;IAyClB;;OAEG;YACW,YAAY;IAuK1B;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAU3B;;;;OAIG;IACH,gBAAgB,IAAI,IAAI;IAMxB;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI;YAuBxB,UAAU;IAwCxB;;OAEG;IACH,OAAO,IAAI,IAAI;CAiBhB"}
+{"version":3,"file":"SemaEngine.d.ts","sourceRoot":"","sources":["../../src/core/SemaEngine.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAYxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAE7D;;;GAGG;AACH,qBAAa,UAAU;aAaH,SAAS,EAAE,MAAM;IACjC,OAAO,CAAC,QAAQ,CAAC,GAAG;IAbtB,mDAAmD;IACnD,OAAO,CAAC,wBAAwB,CAA6B;IAE7D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiB;IAGzC,IAAI,GAAI,CAAC,EAAE,OAAO,MAAM,EAAE,MAAM,CAAC,aAAgC;IACjE,EAAE,GAAI,CAAC,EAAE,OAAO,MAAM,EAAE,UAAU,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,qBAAkC;IACrF,IAAI,GAAI,CAAC,EAAE,OAAO,MAAM,EAAE,UAAU,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,qBAAoC;IACzF,GAAG,GAAI,CAAC,EAAE,OAAO,MAAM,EAAE,UAAU,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,qBAAmC;gBAGrE,SAAS,EAAE,MAAM,EAChB,GAAG,EAAE,eAAe;IAevC;;OAEG;IACG,aAAa,CAAC,IAAI,GAAE,oBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;IAsDnE;;;OAGG;IACH,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI;IA+C/E;;OAEG;IACH,OAAO,CAAC,UAAU;IAqClB;;OAEG;YACW,YAAY;IAuJ1B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAS3B;;OAEG;IACH,gBAAgB,IAAI,IAAI;IAIxB;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI;IAetC;;OAEG;IACH,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI;YAKvB,UAAU;IA8BxB;;OAEG;IACG,WAAW,CAAC,SAAS,SAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAYnD;;OAEG;IACH,OAAO,IAAI,IAAI;CAQhB"}

package/dist/core/SemaEngine.js

@@ -1,42 +1,7 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SemaEngine = void 0;
-const crypto = __importStar(require("crypto"));
 const log_1 = require("../util/log");
-const session_1 = require("../util/session");
 const tokens_1 = require("../util/tokens");
 const history_1 = require("../util/history");
 const topic_1 = require("../util/topic");
@@ -47,138 +12,103 @@ const inputQueue_1 = require("../util/inputQueue");
 const genSystemPrompt_1 = require("../services/agents/genSystemPrompt");
 const ConfManager_1 = require("../manager/ConfManager");
 const ModelManager_1 = require("../manager/ModelManager");
-const EventSystem_1 = require("../events/EventSystem");
 const errors_1 = require("../types/errors");
 const Conversation_1 = require("./Conversation");
 const StateManager_1 = require("../manager/StateManager");
+const session_1 = require("../util/session");
 const runCommand_1 = require("../services/commands/runCommand");
 const TaskManager_1 = require("../manager/TaskManager");
 const CronManager_1 = require("../manager/CronManager");
 const quickchat_1 = require("../util/quickchat");
 const tool_1 = require("../prompt/tool");
 /**
- * Sema 引擎 - 处理核心业务逻辑
+ * Sema 引擎 - 单个会话的核心业务逻辑
+ * 每个会话一个实例，绑定固定的 sessionId
  */
 class SemaEngine {
-    constructor() {
-        // 待处理的会话ID（只保留最新的一个）
-        this.pendingSession = null;
-        // 当前正在执行的 processQuery Promise（用于等待旧会话结束）
+    constructor(sessionId, bus) {
+        this.sessionId = sessionId;
+        this.bus = bus;
+        /** 当前正在执行的 processQuery Promise（用于 dispose 时等待） */
         this.currentProcessingPromise = null;
-        // 公共事件接口
-        this.eventBus = EventSystem_1.EventBus.getInstance();
-        this.emit = (event, data) => this.eventBus.emit(event, data);
-        this.on = (event, listener) => this.eventBus.on(event, listener);
-        this.once = (event, listener) => this.eventBus.once(event, listener);
-        this.off = (event, listener) => this.eventBus.off(event, listener);
-        // 注入后台任务通知回调：任务完成后将通知注入用户输入队列
-        (0, TaskManager_1.getTaskManager)().setNotifyCallback((msg) => {
+        // 公共事件接口（会话级，自动按 sessionId 路由）
+        this.emit = (event, data) => this.bus.emit(event, data);
+        this.on = (event, listener) => this.bus.on(event, listener);
+        this.once = (event, listener) => this.bus.once(event, listener);
+        this.off = (event, listener) => this.bus.off(event, listener);
+        this.runtime = (0, StateManager_1.getStateManager)().session(sessionId);
+        // 注入后台任务通知回调：完成后将通知注入本会话输入队列
+        (0, TaskManager_1.getTaskManager)().setNotifyCallback(sessionId, (msg) => {
             this.processUserInput(msg, undefined, true);
         });
         // 注入 Cron 定时任务通知回调
-        (0, CronManager_1.getCronManager)().setNotifyCallback((msg) => {
+        (0, CronManager_1.getCronManager)().setNotifyCallback(sessionId, (msg) => {
             this.processUserInput(msg, undefined, true);
         });
     }
     /**
-     * 创建会话
+     * 初始化会话：加载历史、发送 session:ready
      */
-    async createSession(sessionId) {
-        const finalSessionId = sessionId || (0, session_1.generateSessionId)();
-        const stateManager = (0, StateManager_1.getStateManager)();
-        const mainAgentState = stateManager.forAgent(StateManager_1.MAIN_AGENT_ID);
-        // 如果当前正在处理，中断并等待旧会话结束，然后 fall through 到下方统一创建新会话
-        if (mainAgentState.getCurrentState() === 'processing') {
-            this.pendingSession = finalSessionId; // 直接覆盖，只保留最新的会话
-            this.abortCurrentRequest();
-            (0, log_1.logInfo)(`会话正在处理中，中断并等待: ${finalSessionId}`);
-            // 等待旧会话处理完成（最多等待10秒）
-            if (this.currentProcessingPromise) {
-                const waitTimeoutSecond = 10;
-                (0, log_1.logInfo)(`等待旧会话结束...`);
-                try {
-                    await Promise.race([
-                        this.currentProcessingPromise,
-                        new Promise((_, reject) => setTimeout(() => reject(new Error('等待超时')), 1000 * waitTimeoutSecond))
-                    ]);
-                    (0, log_1.logInfo)(`旧会话已结束`);
-                }
-                catch (error) {
-                    (0, log_1.logWarn)(`等待旧会话结束时出错: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-            // 被更新的 createSession 调用覆盖（快速连续新建场景），放弃当前创建
-            if (this.pendingSession !== finalSessionId) {
-                (0, log_1.logInfo)(`会话创建被覆盖，放弃: ${finalSessionId}`);
-                return;
-            }
-        }
-        // 创建新会话，清空所有待处理状态
-        this.abortCurrentRequest();
-        stateManager.clearPendingUserInputs(); // 清空输入队列，因为这些输入属于旧会话
-        this.pendingSession = null;
-        // 关闭所有后台进程
-        (0, TaskManager_1.getTaskManager)().dispose();
-        // 清空所有状态
-        stateManager.clearAllState();
-        // 初始化新会话
-        await this.initialize(finalSessionId);
-        // 清空非持久化的定时任务，持久化任务保留
-        (0, CronManager_1.getCronManager)().clearNonDurableTasks();
+    async createSession(opts = {}) {
+        // 初始化系统配置与模型检查
+        await this.initialize();
+        // 会话级配置：Agent 模式
         const coreConfig = (0, ConfManager_1.getConfManager)().getCoreConfig();
+        this.runtime.agentMode = opts.agentMode || coreConfig?.agentMode || 'Agent';
+        // 构建会话级系统提示快照：整个会话不再变化（env/gitStatus 取会话创建时的快照）
+        this.runtime.setSystemPromptContent(await (0, genSystemPrompt_1.formatSystemPrompt)());
+        const mainAgentState = this.runtime.forAgent(StateManager_1.MAIN_AGENT_ID);
         const workingDir = coreConfig?.workingDir;
-        (0, log_1.logInfo)(`[DEBUG] loadHistory - workingDir: ${workingDir}, coreConfig: ${JSON.stringify(coreConfig)}`);
-        const historyData = await (0, history_1.loadHistory)(sessionId, workingDir);
-        (0, log_1.logInfo)(`会话CoreConfig: ${JSON.stringify(coreConfig, null, 2)}`);
+        const historyId = opts.sessionId;
+        const historyData = await (0, history_1.loadHistory)(historyId, workingDir);
         // 将加载的消息历史、todos 和 readFileTimestamps 设置到主代理状态
         // 初始化时跳过自动保存，避免把刚读取的数据重复写回文件
         mainAgentState.setMessageHistory(historyData.messages, true);
         mainAgentState.setTodos(historyData.todos);
         if (historyData.todoTasks && historyData.todoTasks.length > 0) {
-            // 新格式：直接恢复完整 TodoTask 数据
-            stateManager.restoreTodoTasks(historyData.todoTasks);
+            this.runtime.restoreTodoTasks(historyData.todoTasks);
         }
         else if (historyData.todos && historyData.todos.length > 0) {
-            // 旧格式兼容：将 TodoItem 转换为 TodoTask
-            stateManager.restoreTodoTasksFromLegacy(historyData.todos);
+            this.runtime.restoreTodoTasksFromLegacy(historyData.todos);
         }
         if (historyData.readFileTimestamps) {
             mainAgentState.setReadFileTimestamps(historyData.readFileTimestamps);
         }
-        // 使用全局配置获取工作路径
         const projectConfig = (0, ConfManager_1.getConfManager)().getProjectConfig();
         const projectInputHistory = projectConfig?.history || [];
-        // 获取tokens
         const usage = (0, tokens_1.getTokens)(mainAgentState.getMessageHistory());
         const sessionData = {
             pid: process.pid,
             workingDir: coreConfig?.workingDir,
-            sessionId: stateManager.getSessionId(),
-            historyLoaded: !!sessionId,
+            sessionId: this.sessionId,
+            historyLoaded: !!historyId,
             projectInputHistory: projectInputHistory,
             usage: usage,
             todos: mainAgentState.getTodos(),
             readFileTimestamps: historyData.readFileTimestamps || {}
         };
-        (0, log_1.logInfo)(`新会话创建完成，sessionId: ${stateManager.getSessionId()}`);
-        this.emit('session:ready', sessionData);
-        mainAgentState.updateState('idle');
+        (0, log_1.logInfo)(`新会话创建完成，sessionId: ${this.sessionId}`);
+        // 延迟一拍发送 session:ready：调用方需先拿到 createSession 返回的 SemaSession
+        // 并在其上注册监听器，再收到首个事件
+        setImmediate(() => {
+            this.emit('session:ready', sessionData);
+            mainAgentState.updateState('idle');
+        });
     }
     /**
      * 处理用户输入
      * 如果当前正在处理中，将输入加入队列等待
      */
     processUserInput(input, originalInput, silent) {
-        const stateManager = (0, StateManager_1.getStateManager)();
-        const mainAgentState = stateManager.forAgent(StateManager_1.MAIN_AGENT_ID);
-        const inputId = crypto.randomUUID().replace(/-/g, '').substring(0, 8);
+        const mainAgentState = this.runtime.forAgent(StateManager_1.MAIN_AGENT_ID);
+        const inputId = (0, session_1.generateShortId)();
         const trimmedInput = input.trim();
         // quickchat 旁路：不影响状态和队列，异步处理后直接返回
         if (trimmedInput === '/quickchat' || trimmedInput.startsWith('/quickchat ')) {
-            const question = trimmedInput.startsWith('/quickchat ') ? trimmedInput.slice(5).trim() : '';
+            const question = trimmedInput.startsWith('/quickchat ') ? trimmedInput.slice('/quickchat '.length).trim() : '';
             (0, ConfManager_1.getConfManager)().saveUserInputToHistory(originalInput || trimmedInput);
             if (question) {
-                (0, quickchat_1.handlequickchat)(question).catch(err => (0, log_1.logWarn)(`[quickchat] 未捕获异常: ${err instanceof Error ? err.message : String(err)}`));
+                (0, quickchat_1.handlequickchat)(question, this.sessionId).catch(err => (0, log_1.logWarn)(`[quickchat] 未捕获异常: ${err instanceof Error ? err.message : String(err)}`));
             }
             else {
                 this.emit('quickchat:response', { question: '', content: '' });
@@ -187,8 +117,8 @@ class SemaEngine {
         }
         if (mainAgentState.getCurrentState() === 'processing') {
             const type = trimmedInput.startsWith('/') ? 'command' : 'inject';
-            stateManager.addPendingUserInput({ inputId, input: trimmedInput, originalInput, silent, type });
-            (0, log_1.logInfo)(`输入已入队(${type})，队列长度: ${stateManager.getPendingUserInputsLength()}`);
+            this.runtime.addPendingUserInput({ inputId, input: trimmedInput, originalInput, silent, type });
+            (0, log_1.logInfo)(`输入已入队(${type})，队列长度: ${this.runtime.getPendingUserInputsLength()}`);
             if (!silent) {
                 this.emit('input:received', {
                     inputId,
@@ -196,7 +126,7 @@ class SemaEngine {
                     originalInput,
                     queued: true,
                     inject: type === 'inject',
-                    queueLength: stateManager.getPendingUserInputsLength(),
+                    queueLength: this.runtime.getPendingUserInputsLength(),
                 });
             }
             return;
@@ -217,21 +147,19 @@ class SemaEngine {
      * 启动一次查询（构建上下文并调用 processQuery）
      */
     startQuery(inputs) {
-        const stateManager = (0, StateManager_1.getStateManager)();
-        const mainAgentState = stateManager.forAgent(StateManager_1.MAIN_AGENT_ID);
+        const mainAgentState = this.runtime.forAgent(StateManager_1.MAIN_AGENT_ID);
         mainAgentState.updateState('processing');
         (0, log_1.logInfo)(`用户输入(${inputs.length}条): ${inputs.map(i => i.input).join(' | ')}`);
         // 创建新的 AbortController 用于此次处理
-        stateManager.currentAbortController = new AbortController();
-        // 获取核心配置
-        const coreConfig = (0, ConfManager_1.getConfManager)().getCoreConfig();
-        const agentMode = coreConfig?.agentMode || 'Agent';
-        // 获取工具集
+        this.runtime.currentAbortController = new AbortController();
+        const agentMode = this.runtime.agentMode;
+        // 获取工具集（按核心级 useTools 黑名单过滤）
         const tools = (0, tools_1.getAvailableTools)();
         // 构建主代理上下文
         const agentContext = {
+            sessionId: this.sessionId,
             agentId: StateManager_1.MAIN_AGENT_ID,
-            abortController: stateManager.currentAbortController,
+            abortController: this.runtime.currentAbortController,
             tools,
             model: 'main',
         };
@@ -239,14 +167,12 @@ class SemaEngine {
         this.currentProcessingPromise = this.processQuery(inputs, agentContext, agentMode)
             .catch(error => {
             (0, log_1.logWarn)(`processQuery 未捕获异常: ${error instanceof Error ? error.message : String(error)}`);
-            // 确保清理 AbortController（防止竞态条件）
-            if (stateManager.currentAbortController === agentContext.abortController) {
-                stateManager.currentAbortController = null;
+            if (this.runtime.currentAbortController === agentContext.abortController) {
+                this.runtime.currentAbortController = null;
             }
             mainAgentState.updateState('idle');
         })
             .finally(() => {
-            // 清空 Promise 引用
             this.currentProcessingPromise = null;
         });
     }
@@ -254,9 +180,7 @@ class SemaEngine {
      * 处理查询逻辑
      */
     async processQuery(inputs, agentContext, agentMode) {
-        // 获取状态管理器和主代理状态
-        const stateManager = (0, StateManager_1.getStateManager)();
-        const mainAgentState = stateManager.forAgent(StateManager_1.MAIN_AGENT_ID);
+        const mainAgentState = this.runtime.forAgent(StateManager_1.MAIN_AGENT_ID);
         // 为每条输入发送独立的 input:processing 事件（静默输入跳过）
         for (const item of inputs) {
             if (!item.silent) {
@@ -274,12 +198,11 @@ class SemaEngine {
             const allBlocks = [];
             let combinedProcessedText = '';
             for (const item of inputs) {
-                // abort 早期检查：避免会话切换后继续执行无用操作
                 if (agentContext.abortController.signal.aborted) {
                     (0, log_1.logInfo)('processQuery: abort detected during handleCommand loop, skipping remaining');
                     return;
                 }
-                const commandResult = await (0, runCommand_1.handleCommand)(item.input);
+                const commandResult = await (0, runCommand_1.handleCommand)(item.input, this.sessionId);
                 if (commandResult === null) {
                     // 系统命令已处理（如 /compact, /clear），跳过
                     continue;
@@ -287,23 +210,20 @@ class SemaEngine {
                 combinedProcessedText += (combinedProcessedText ? '\n' : '') + commandResult.processedText;
                 allBlocks.push(...commandResult.blocks);
             }
-            // 如果所有输入都是系统命令（返回 null），直接结束
             if (allBlocks.length === 0) {
                 return;
             }
-            // abort 早期检查
             if (agentContext.abortController.signal.aborted) {
                 (0, log_1.logInfo)('processQuery: abort detected after handleCommand, skipping remaining');
                 return;
             }
-            // 后台异步执行话题检测，不阻塞主流程（使用所有输入拼接）
-            // 跳过条件：全部输入均为 silent（来自 cron / 后台任务通知等系统注入），不应改变会话话题
+            // 后台异步执行话题检测，不阻塞主流程
             const allSilent = inputs.every(i => i.silent);
             const allOriginalTexts = inputs.map(i => i.originalInput || i.input).join('\n');
             if (!allSilent && !(0, ConfManager_1.getConfManager)().getCoreConfig()?.disableTopicDetection) {
-                (0, topic_1.detectTopicInBackground)(allOriginalTexts, stateManager.currentAbortController, (result) => this.emit('topic:update', result));
+                (0, topic_1.detectTopicInBackground)(allOriginalTexts, this.runtime.currentAbortController, (result) => this.emit('topic:update', result));
             }
-            // 处理文件引用以获取补充信息（使用处理后的文本）
+            // 处理文件引用以获取补充信息
             const fileReferencesResult = await (0, fileReference_1.processFileReferences)(combinedProcessedText, agentContext);
             (0, log_1.logInfo)(`返回文件引用信息: ${JSON.stringify(fileReferencesResult.supplementaryInfo, null, 2)}`);
             if (fileReferencesResult.supplementaryInfo.length > 0) {
@@ -311,25 +231,24 @@ class SemaEngine {
                     references: fileReferencesResult.supplementaryInfo
                 });
             }
-            // abort 早期检查
             if (agentContext.abortController.signal.aborted) {
                 (0, log_1.logInfo)('processQuery: abort detected after processFileReferences, skipping remaining');
                 return;
             }
-            // 1、构建系统提示（根据是否有代理配置决定）
+            // 1、系统提示：复用会话级快照（整会话不变）；缺失时兜底构建一次
             const hasSkillTool = agentContext.tools.some(tool => tool.name === tool_1.TOOL_NAME_SKILL);
-            const systemPromptContent = await (0, genSystemPrompt_1.formatSystemPrompt)();
+            let systemPromptContent = this.runtime.getSystemPromptContent();
+            if (!systemPromptContent) {
+                systemPromptContent = await (0, genSystemPrompt_1.formatSystemPrompt)();
+                this.runtime.setSystemPromptContent(systemPromptContent);
+            }
             // 2、构建用户消息内容
-            // 2.1 获取消息历史
             const messageHistory = mainAgentState.getMessageHistory();
-            // 2.2 当前用户输入
-            // 构建reminder信息 文件引用 每次输入均添加，首次查询添加 todos\rules，Plan 模式添加 Plan 信息
-            const additionalReminders = (0, message_1.buildAdditionalReminders)(fileReferencesResult.systemReminders, messageHistory, agentMode, hasSkillTool);
+            const additionalReminders = (0, message_1.buildAdditionalReminders)(fileReferencesResult.systemReminders, messageHistory, agentMode, this.sessionId, hasSkillTool);
             const userMessage = (0, message_1.buildUserMsg)([
                 ...additionalReminders,
                 ...allBlocks
             ]);
-            // 2.3 完整消息
             const messages = [...messageHistory, userMessage];
             // 调用 query 函数
             for await (const _message of (0, Conversation_1.ReAct)(messages, systemPromptContent, agentContext)) {
@@ -340,29 +259,20 @@ class SemaEngine {
             if ((0, errors_1.isInterruptedException)(error)) {
                 (0, log_1.logDebug)('用户中断操作');
             }
-            // API 错误已在 emitSessionError 中记录，这里不重复记录
         }
         finally {
-            // 延迟清空 AbortController，确保所有中断逻辑执行完毕（避免竞态条件）
-            const currentAbortController = stateManager.currentAbortController;
+            // 延迟清空 AbortController，确保所有中断逻辑执行完毕
+            const currentAbortController = this.runtime.currentAbortController;
             if (currentAbortController === agentContext.abortController) {
-                // 使用 setTimeout 0 确保当前执行栈完成后再清空
                 setTimeout(() => {
-                    if (stateManager.currentAbortController === currentAbortController) {
-                        stateManager.currentAbortController = null;
+                    if (this.runtime.currentAbortController === currentAbortController) {
+                        this.runtime.currentAbortController = null;
                     }
                 }, 0);
             }
-            // 会话切换：仅清空队列，不再递归调 createSession
-            // createSession 正在等待 currentProcessingPromise，由它接手创建新会话
-            if (this.pendingSession) {
-                stateManager.clearPendingUserInputs();
-                return;
-            }
-            // 处理同一会话中的待处理输入队列
-            const remaining = stateManager.consumeAllPendingInputs();
+            // 处理待处理输入队列
+            const remaining = this.runtime.consumeAllPendingInputs();
             if (remaining.length > 0) {
-                // 转换为 takeNextBatch 所需格式
                 const pending = remaining.map(item => ({
                     inputId: item.inputId,
                     input: item.input,
@@ -374,7 +284,7 @@ class SemaEngine {
                 if (pending.length > 0) {
                     for (const item of pending) {
                         const type = item.input.startsWith('/') ? 'command' : 'inject';
-                        stateManager.addPendingUserInput({ ...item, type });
+                        this.runtime.addPendingUserInput({ ...item, type });
                     }
                 }
                 (0, log_1.logInfo)(`处理队列中 ${batch.length} 条待处理输入`);
@@ -387,73 +297,62 @@ class SemaEngine {
     }
     /**
      * 中止当前正在进行的请求（仅处理 AbortController）
-     * 不更新状态，用于内部调用
      */
     abortCurrentRequest() {
-        const stateManager = (0, StateManager_1.getStateManager)();
-        const abortController = stateManager.currentAbortController;
+        const abortController = this.runtime.currentAbortController;
         if (abortController && !abortController.signal.aborted) {
             (0, log_1.logInfo)('通过 AbortController 发送中断信号');
             abortController.abort();
         }
-        stateManager.currentAbortController = null;
+        this.runtime.currentAbortController = null;
     }
     /**
      * 中断当前会话
-     * 仅中断当前正在执行的请求，队列中的待处理输入不受影响
-     * 由 processQuery 的 finally 决定是否继续消费队列或设为 idle
      */
     interruptSession() {
         this.abortCurrentRequest();
-        // 不直接设 idle，由 processQuery 的 finally 决定
-        // 若当前未在 processing（如已经 idle），则无需额外操作
     }
     /**
-     * 更新 Agent 模式
+     * 更新 Agent 模式（会话级）
      */
     updateAgentMode(mode) {
-        // 若模式值无变化，直接返回
-        const currentMode = (0, ConfManager_1.getConfManager)().getCoreConfig()?.agentMode || 'Agent';
-        if (currentMode === mode) {
+        if (this.runtime.agentMode === mode) {
             return;
         }
-        // 更新配置
-        (0, ConfManager_1.getConfManager)().updateAgentMode(mode);
-        // 切换到 Plan 模式时，重置 Plan 模式信息发送状态
+        this.runtime.agentMode = mode;
+        (0, log_1.logInfo)(`[${this.sessionId}] Agent 模式已更新: ${mode}`);
         if (mode === 'Plan') {
-            (0, StateManager_1.getStateManager)().resetPlanModeInfoSent();
+            this.runtime.resetPlanModeInfoSent();
         }
-        // 切换到 Design 模式时，重置 Design 模式信息发送状态
-        // 新会话由前端在切换 UI 时通过 createSession() 自行触发
         if (mode === 'Design') {
-            (0, StateManager_1.getStateManager)().resetDesignModeInfoSent();
+            this.runtime.resetDesignModeInfoSent();
         }
     }
-    // 初始化系统
-    async initialize(sessionId) {
+    /**
+     * 更新自动编辑状态
+     */
+    updateAutoEdit(enable) {
+        this.runtime.updateAutoEdit(enable);
+    }
+    // 初始化系统配置与模型检查
+    async initialize() {
         const coreConfig = (0, ConfManager_1.getConfManager)().getCoreConfig();
-        // 1、设置日志级别
         (0, log_1.setLogLevel)(coreConfig?.logLevel || 'info');
-        // 2、设置sessionId（如果为空则生成一个）
-        const finalSessionId = sessionId || (0, session_1.generateSessionId)();
-        const stateManager = (0, StateManager_1.getStateManager)();
-        stateManager.setSessionId(finalSessionId);
-        // 3、从配置文件加载模型配置 ~/.sema.conf
         try {
             const modelManager = (0, ModelManager_1.getModelManager)();
             const modelProfile = modelManager.getModel('main');
-            // 检查是否有可用模型
             if (!modelProfile) {
-                // 发送无模型配置事件
-                this.emit('config:no_models', {
-                    message: '未配置任何模型，请先添加模型配置',
-                    suggestion: ''
+                // 延迟一拍：等调用方在返回的 SemaSession 上注册监听器
+                setImmediate(() => {
+                    this.emit('config:no_models', {
+                        message: '未配置任何模型，请先添加模型配置',
+                        suggestion: ''
+                    });
                 });
             }
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            // 发送模型配置错误事件
             this.emit('session:error', {
                 type: 'model_error',
                 error: {
@@ -466,20 +365,31 @@ class SemaEngine {
         }
     }
     /**
-     * 清理资源和停止所有活动
+     * 等待当前处理结束（最多 timeoutMs 毫秒）
+     */
+    async waitForIdle(timeoutMs = 10000) {
+        if (!this.currentProcessingPromise)
+            return;
+        try {
+            await Promise.race([
+                this.currentProcessingPromise,
+                new Promise((_, reject) => setTimeout(() => reject(new Error('等待超时')), timeoutMs)),
+            ]);
+        }
+        catch (error) {
+            (0, log_1.logWarn)(`等待会话处理结束时出错: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * 清理本会话资源（会话级，不触碰全局单例）
      */
     dispose() {
-        (0, log_1.logInfo)('开始清理 SemaEngine 资源...');
-        // 1. 中止当前正在进行的请求并清空队列
+        (0, log_1.logInfo)(`清理 SemaEngine 资源: ${this.sessionId}`);
         this.abortCurrentRequest();
-        (0, StateManager_1.getStateManager)().clearPendingUserInputs();
-        this.pendingSession = null;
-        // 2. 清空所有状态数据
-        const stateManager = (0, StateManager_1.getStateManager)();
-        stateManager.clearAllState();
-        // 3. 移除所有事件监听器
-        this.eventBus.removeAllListeners();
-        (0, log_1.logInfo)('SemaEngine 资源清理完成');
+        this.runtime.clearPendingUserInputs();
+        // 移除本会话在 Task/Cron 管理器上的通知回调
+        (0, TaskManager_1.getTaskManager)().removeNotifyCallback(this.sessionId);
+        (0, CronManager_1.getCronManager)().removeNotifyCallback(this.sessionId);
     }
 }
 exports.SemaEngine = SemaEngine;