evolclaw 2.4.0 → 2.5.0

package/dist/core/message/message-bridge.js

@@ -102,6 +102,7 @@ export class MessageBridge {
                     chatType,
                     images: msg.images, timestamp: Date.now(),
                     peerId: msg.peerId, peerName: msg.peerName,
+                    peerType: msg.peerType,
                     messageId: msg.messageId,
                     mentions: msg.mentions, threadId: msg.threadId,
                     replyContext: msg.replyContext,
@@ -151,8 +152,7 @@ export class MessageBridge {
             return false;
         if (parsed.type === 'menu.query') {
             const identity = this.sessionManager.resolveIdentity(channel, msg.peerId);
-            const isAdmin = identity.role === 'owner';
-            const items = this.cmdHandler.getMenuItems(isAdmin, msg.chatType || 'private');
+            const items = this.cmdHandler.getMenuItems(identity.role, msg.chatType || 'private');
             const response = JSON.stringify({ type: 'menu.response', items });
             if (adapter?.sendCustomPayload) {
                 adapter.sendCustomPayload(msg.channelId, response);
@@ -196,8 +196,8 @@ export class MessageBridge {
         return true;
     }
     /**
-     * 撤回消息：先查 debounce 窗口，再查 message queue。
-     * @returns true 如果找到并取消
+     * 撤回消息：先查 debounce 窗口，再查 message queue，最后查正在执行的任务。
+     * @returns true 如果找到并取消/中断
      */
     cancel(messageId) {
         // 阶段 1: debounce 窗口（尚未入队）
@@ -206,7 +206,10 @@ export class MessageBridge {
                 return true;
         }
         // 阶段 2: 已入队但未处理（合并后 messageId 可能是逗号分隔的多个 id）
-        return this.messageQueue.cancel(messageId);
+        if (this.messageQueue.cancel(messageId))
+            return true;
+        // 阶段 3: 正在执行的任务 → 触发 interrupt
+        return this.messageQueue.cancelActive(messageId);
     }
     /** 清理资源 */
     dispose() {

package/dist/core/message/message-processor.js

@@ -7,6 +7,7 @@ import { logger } from '../../utils/logger.js';
 import { getErrorMessage, classifyError, ErrorType, ERROR_PREFIX, isInfraError, prefixErrorType, isRetryableError } from '../../utils/error-utils.js';
 import { summarizeToolInput } from '../permission.js';
 import { getOwner } from '../../config.js';
+import { getPackageRoot, resolveRoot } from '../../paths.js';
 /**
  * 统一消息处理器
  * 负责处理来自不同渠道的消息，协调事件流处理
@@ -25,6 +26,9 @@ export class MessageProcessor {
     defaultAgentId;
     interruptedSessions = new Map(); // sessionId → reason ('new_message' | 'stop' | ...)
     interactionRouter;
+    messageQueue;
+    skillsHintDesc = undefined; // undefined=未加载, null=无模板, string=缓存描述
+    skillsEnsured = false; // 全局 SKILLS.md 是否已确保
     /** 按 agentId 获取 agent，回退到默认 */
     getAgent(agentId) {
         if (agentId && this.agentMap.has(agentId))
@@ -67,6 +71,9 @@ export class MessageProcessor {
     setInteractionRouter(router) {
         this.interactionRouter = router;
     }
+    setMessageQueue(queue) {
+        this.messageQueue = queue;
+    }
     /**
      * 注册渠道适配器
      */
@@ -149,7 +156,6 @@ export class MessageProcessor {
         // 按 session.agentId 选择 agent 后端
         const agent = this.getAgent(session.agentId);
         const monitorEnabled = this.config.idleMonitor?.enabled !== false;
-        const safeModeThreshold = this.config.idleMonitor?.safeModeThreshold ?? 3;
         const showIdleMonitor = policy.showIdleMonitor(chatType, identityRole);
         // 计算是否抑制中间输出（工具活动 + 流式文本）
         const shouldSuppress = () => {
@@ -219,25 +225,24 @@ export class MessageProcessor {
             if (channelInfo) {
                 try {
                     const errorType = classifyError(error);
-                    // 上下文过长是可恢复错误，不累计触发安全模式
+                    // 上下文过长是可恢复错误，不累计错误计数
                     if (errorType === ErrorType.CONTEXT_TOO_LONG) {
-                        logger.info(`[MessageProcessor] Context too long error, skipping safe mode accumulation`);
-                        // 认证错误（401 / Invalid API Key）不是会话问题，安全模式无法修复，不累计
+                        logger.info(`[MessageProcessor] Context too long error, skipping error accumulation`);
+                        // 认证错误（401 / Invalid API Key）不是会话问题，不累计
                     }
                     else if (errorType === ErrorType.AUTH_ERROR) {
-                        logger.info(`[MessageProcessor] Auth error (invalid API key), skipping safe mode accumulation`);
-                        // API 错误（5xx / 算力池切换等）是平台暂时性问题，安全模式无法修复，不累计
+                        logger.info(`[MessageProcessor] Auth error (invalid API key), skipping error accumulation`);
+                        // API 错误（5xx / 算力池切换等）是平台暂时性问题，不累计
                     }
                     else if (errorType === ErrorType.API_ERROR) {
-                        logger.info(`[MessageProcessor] API error, skipping safe mode accumulation`);
+                        logger.info(`[MessageProcessor] API error, skipping error accumulation`);
                     }
                     else if (!policy.accumulateErrors(chatType, identityRole)) {
-                        logger.info(`[MessageProcessor] Non-accumulating error (chatType=${chatType}, identity=${identityRole}), skipping safe mode accumulation`);
+                        logger.info(`[MessageProcessor] Non-accumulating error (chatType=${chatType}, identity=${identityRole}), skipping error accumulation`);
                     }
                     else {
                         const prefixed = prefixErrorType(ERROR_PREFIX.INFRA, errorType);
-                        const newCount = await this.sessionManager.recordError(session.id, prefixed, error.message);
-                        await this.checkSafeMode(session, message.channelId, channelInfo.adapter, safeModeThreshold, newCount, message);
+                        await this.sessionManager.recordError(session.id, prefixed, error.message);
                     }
                 }
                 catch (statusError) {
@@ -255,35 +260,7 @@ export class MessageProcessor {
     getReplyContext(message) {
         return message.replyContext;
     }
-    /**
-     * 检查是否需要进入安全模式（safeModeThreshold 为 0 时跳过）
-     */
-    async checkSafeMode(session, channelId, adapter, safeModeThreshold, consecutiveErrors, message) {
-        if (safeModeThreshold <= 0)
-            return;
-        const health = await this.sessionManager.getHealthStatus(session.id);
-        const sendOpts = this.getReplyContext(message);
-        const isThread = !!session.threadId;
-        if (consecutiveErrors >= safeModeThreshold && !health.safeMode) {
-            await this.sessionManager.setSafeMode(session.id, true);
-            logger.warn(`[MessageProcessor] Session ${session.id} entered safe mode after ${consecutiveErrors} errors`);
-            this.eventBus.publish({ type: 'session:safe-mode-entered', sessionId: session.id, consecutiveErrors });
-            const suggestions = isThread
-                ? `1. /repair - 检查并修复会话（推荐，保留历史）\n2. /clear - 清空会话历史\n3. /status - 查看详细状态`
-                : `1. /repair - 检查并修复会话（推荐，保留历史）\n2. /new [名称] - 创建新会话（清空历史）\n3. /status - 查看详细状态`;
-            await adapter.sendText(channelId, `\u26a0\ufe0f 安全模式已启用（连续 ${consecutiveErrors} 次异常）
-
-当前限制：
-- 无法记住之前的对话
-- 每次提问需要提供完整上下文
-
-建议操作：
-${suggestions}`, sendOpts);
-        }
-        else if (safeModeThreshold >= 2 && consecutiveErrors === safeModeThreshold - 1) {
-            await adapter.sendText(channelId, `\u26a0\ufe0f 检测到异常（${consecutiveErrors}/${safeModeThreshold}）\n\n如果问题持续，系统将自动进入安全模式。建议使用 /status 查看状态。`, sendOpts);
-        }
-    }
+    /** 自动安全模式已禁用：仅保留错误计数，不再自动切换状态 */
     async _processMessageInternal(message, session, absoluteProjectPath, resetTimer, shouldSuppress) {
         const messageId = `${message.channel}_${message.channelId}_${message.timestamp || Date.now()}`;
         const channelKey = session.metadata?.channelName || message.channel;
@@ -365,14 +342,21 @@ ${suggestions}`, sendOpts);
                 await adapter.sendText(message.channelId, text, this.getReplyContext(message));
             });
             // 设置权限审批的交互上下文（支持交互卡片）
-            agent.setPermissionContext?.({
+            agent.setPermissionContext?.(session.id, {
                 adapter,
                 channelId: message.channelId,
                 replyContext: this.getReplyContext(message),
                 interactionRouter: this.interactionRouter,
+                interceptNextMessage: this.messageQueue
+                    ? (sessionKey, handler) => this.messageQueue.interceptNext(sessionKey, handler)
+                    : undefined,
+                cancelIntercept: this.messageQueue
+                    ? (sessionKey) => this.messageQueue.cancelIntercept(sessionKey)
+                    : undefined,
             });
-            // 设置 per-session 权限模式（动态默认值：owner → bypass，guest → readonly）
-            const defaultPermMode = session.identity?.role === 'owner' ? 'bypass' : 'readonly';
+            // 设置 per-session 权限模式（动态默认值：owner → bypass，admin → auto，guest → readonly）
+            const role = session.identity?.role;
+            const defaultPermMode = role === 'owner' ? 'bypass' : role === 'admin' ? 'auto' : 'readonly';
             agent.setMode(session.metadata?.permissionMode ?? defaultPermMode);
             // 标记会话为处理中（实时持久化，重启后可恢复）
             this.sessionManager.markProcessing(session.id);
@@ -390,6 +374,7 @@ ${suggestions}`, sendOpts);
                 // 1. 当前环境信息
                 const peerLabel = session.identity?.role || 'unknown';
                 const peerName = message.peerName || session.metadata?.peerName;
+                const peerType = message.peerType;
                 const envParts = [
                     `会话通道: ${currentChannelType}`,
                     `当前项目: ${path.basename(absoluteProjectPath)}`,
@@ -399,6 +384,8 @@ ${suggestions}`, sendOpts);
                 envParts.push(`对端身份: ${peerLabel}`);
                 if (peerName)
                     envParts.push(`对端名称: ${peerName}`);
+                if (peerType && peerType !== 'unknown')
+                    envParts.push(`对端类型: ${peerType}`);
                 if (session.chatType)
                     envParts.push(`聊天类型: ${session.chatType}`);
                 if (session.agentId && session.agentId !== 'claude')
@@ -440,6 +427,15 @@ ${suggestions}`, sendOpts);
                 if (message.chatType === 'group' && message.peerId) {
                     contextParts.push(`[群聊回复规则] 回复时必须在开头添加 @${message.peerId} 来通知对方`);
                 }
+                // 5. Agent ctl 自管理指令提示 + SKILLS.md 生成
+                if (!this.skillsEnsured) {
+                    this.ensureSkillsFile();
+                    this.skillsEnsured = true;
+                }
+                const skillsHint = this.getSkillsHint();
+                if (skillsHint) {
+                    contextParts.push(`[EvolClaw 自管理] ${skillsHint}`);
+                }
                 const effectiveSystemPrompt = [options?.systemPromptAppend, ...contextParts].filter(Boolean).join('\n') || undefined;
                 // 可重试错误（403/429/5xx）指数退避重试，最多 3 次
                 const MAX_RETRIES = 3;
@@ -579,14 +575,6 @@ ${suggestions}`, sendOpts);
             }
             // Flush 剩余内容（文件标记已在 flush 时自动移除）
             await flusher.flush(true);
-            // 安全模式尾部提示：如果当前会话处于安全模式，追加提醒
-            const healthStatus = await this.sessionManager.getHealthStatus(session.id);
-            if (healthStatus.safeMode) {
-                const hint = session.threadId
-                    ? '\n\n\u26a0\ufe0f 当前处于安全模式（无上下文记忆）。使用 /repair 修复 或 /clear 清空会话'
-                    : '\n\n\u26a0\ufe0f 当前处于安全模式（无上下文记忆）。使用 /repair 修复 或 /new 新建会话';
-                await adapter.sendText(message.channelId, hint, this.getReplyContext(message));
-            }
             // 清理 activeStreams（正常完成）
             agent.cleanupStream(streamKey);
             // 清除处理中状态
@@ -606,15 +594,13 @@ ${suggestions}`, sendOpts);
                     errorType,
                     terminalReason: streamResult.terminalReason
                 });
-                // 仅系统级 subtype 累计安全模式（权限拒绝、max turns 等用户操作不累计）
+                // 系统级 subtype 仍累计错误计数，供 /status 诊断使用
                 if (isInfraError(rawSubtype, streamResult.terminalReason)) {
                     const chatType = message.chatType || 'private';
                     const identityRole = session.identity?.role || 'anonymous';
-                    const safeModeThreshold = this.config.idleMonitor?.safeModeThreshold ?? 3;
                     const { policy } = channelInfo;
                     if (policy.accumulateErrors(chatType, identityRole)) {
-                        const newCount = await this.sessionManager.recordError(session.id, errorType, errorSummary);
-                        await this.checkSafeMode(session, message.channelId, adapter, safeModeThreshold, newCount, message);
+                        await this.sessionManager.recordError(session.id, errorType, errorSummary);
                     }
                 }
                 logger.message({
@@ -959,9 +945,22 @@ ${suggestions}`, sendOpts);
         }
         catch (error) {
             // User interrupt (AbortError) is expected, log at info level
+            const catchInterruptReason = this.interruptedSessions.get(session.id);
+            const catchIsUserInterrupt = catchInterruptReason === 'new_message' || catchInterruptReason === 'stop';
             if (error instanceof Error && error.name === 'AbortError') {
                 logger.info('[MessageProcessor] Stream interrupted (AbortError)');
             }
+            else if (catchIsUserInterrupt) {
+                // SDK telemetry noise after user-initiated interrupt — not a real error
+                logger.debug('[MessageProcessor] Stream ended after user interrupt:', error?.message?.split('\n')[0]);
+                completeResult.isError = false;
+                completeResult.hasReceivedText = hasReceivedText;
+                return completeResult;
+            }
+            else if (isRetryableError(error)) {
+                // Retryable errors (network aborts, transient API failures) are noise at ERROR level
+                logger.warn('[MessageProcessor] Stream processing error (retryable):', error?.message?.split('\n')[0]);
+            }
             else {
                 logger.error('[MessageProcessor] Stream processing error:', error);
             }
@@ -1005,6 +1004,99 @@ ${suggestions}`, sendOpts);
         // 都找不到，返回项目根目录路径
         return rootPath;
     }
+    /**
+     * 确保全局数据目录下有最新版本的 SKILLS.md
+     * 目标：{EVOLCLAW_HOME}/data/SKILLS.md
+     */
+    ensureSkillsFile() {
+        try {
+            const targetDir = path.join(resolveRoot(), 'data');
+            const targetPath = path.join(targetDir, 'SKILLS.md');
+            const templatePath = path.join(getPackageRoot(), 'src', 'templates', 'skills.md');
+            // 模板不存在则跳过（构建环境可能没有 src/）
+            if (!fs.existsSync(templatePath)) {
+                // 尝试 dist/templates/skills.md
+                const distTemplatePath = path.join(getPackageRoot(), 'dist', 'templates', 'skills.md');
+                if (!fs.existsSync(distTemplatePath))
+                    return;
+                this.copySkillsIfNeeded(distTemplatePath, targetDir, targetPath);
+                return;
+            }
+            this.copySkillsIfNeeded(templatePath, targetDir, targetPath);
+        }
+        catch {
+            // 静默失败，不影响正常消息处理
+        }
+    }
+    copySkillsIfNeeded(templatePath, targetDir, targetPath) {
+        const templateContent = fs.readFileSync(templatePath, 'utf-8');
+        const templateVersion = templateContent.match(/^version:\s*(.+)$/m)?.[1]?.trim() || '0';
+        if (fs.existsSync(targetPath)) {
+            const existing = fs.readFileSync(targetPath, 'utf-8');
+            const existingVersion = existing.match(/^version:\s*(.+)$/m)?.[1]?.trim() || '0';
+            if (this.compareSemver(existingVersion, templateVersion) >= 0)
+                return; // 已是最新
+        }
+        if (!fs.existsSync(targetDir)) {
+            fs.mkdirSync(targetDir, { recursive: true });
+        }
+        fs.writeFileSync(targetPath, templateContent, 'utf-8');
+    }
+    /** 简易 semver 比较：支持 "1", "1.0", "1.0.0" 等格式，返回 -1/0/1 */
+    compareSemver(a, b) {
+        const pa = a.split('.').map(Number);
+        const pb = b.split('.').map(Number);
+        const len = Math.max(pa.length, pb.length);
+        for (let i = 0; i < len; i++) {
+            const na = pa[i] || 0;
+            const nb = pb[i] || 0;
+            if (na !== nb)
+                return na > nb ? 1 : -1;
+        }
+        return 0;
+    }
+    /**
+     * 从模板 frontmatter 缓存提示（懒加载，整个进程只读一次模板文件）
+     */
+    getSkillsHint() {
+        if (this.skillsHintDesc === undefined) {
+            this.skillsHintDesc = this.loadSkillsHint();
+        }
+        return this.skillsHintDesc;
+    }
+    /**
+     * 从包模板源读取 frontmatter 并生成提示（仅执行一次）
+     */
+    loadSkillsHint() {
+        try {
+            const candidates = [
+                path.join(getPackageRoot(), 'src', 'templates', 'skills.md'),
+                path.join(getPackageRoot(), 'dist', 'templates', 'skills.md'),
+            ];
+            for (const templatePath of candidates) {
+                if (!fs.existsSync(templatePath))
+                    continue;
+                const content = fs.readFileSync(templatePath, 'utf-8');
+                const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+                if (!frontmatterMatch)
+                    continue;
+                const fm = frontmatterMatch[1];
+                const desc = fm.match(/^description:\s*(.+)$/m)?.[1]?.trim() || 'EvolClaw 运行时管理指令';
+                const trigger = fm.match(/^trigger:\s*(.+)$/m)?.[1]?.trim() || '';
+                const skillsPath = path.join(resolveRoot(), 'data', 'SKILLS.md');
+                const parts = [
+                    `可通过 Bash 执行 \`evolclaw ctl <cmd>\` 管理运行时：${desc}`,
+                    trigger ? `触发时机：${trigger}` : '',
+                    `完整文档见 ${skillsPath}`,
+                ];
+                return parts.filter(Boolean).join('\n');
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
     /**
      * 判断文件路径是否为占位符/示例文本
      * 用于过滤大模型在说明文字中误写的 [SEND_FILE:...] 标记

package/dist/core/message/message-queue.js

@@ -8,10 +8,12 @@ export class MessageQueue {
     currentSessionKey;
     currentProjectPath;
     currentAgentId;
+    activeMessageIds = new Set(); // 正在执行的消息 ID
     interruptCallback;
     eventBus;
     recentMessageIds = new Set();
     DEDUP_WINDOW = 60_000; // 1 分钟窗口
+    interceptors = new Map();
     constructor(handler) {
         this.handler = handler;
     }
@@ -21,6 +23,19 @@ export class MessageQueue {
     setEventBus(eventBus) {
         this.eventBus = eventBus;
     }
+    /**
+     * 注册一次性消息拦截器：下一条来自 sessionKey 的消息不入队、不触发 interrupt，
+     * 直接传给 handler。用于 AskUserQuestion 的"手动输入"场景。
+     */
+    interceptNext(sessionKey, handler) {
+        this.interceptors.set(sessionKey, handler);
+    }
+    /**
+     * 取消拦截器（超时或卡片被其他方式回答时调用）
+     */
+    cancelIntercept(sessionKey) {
+        this.interceptors.delete(sessionKey);
+    }
     /**
      * 检查消息是否应该处理（去重）
      */
@@ -53,6 +68,14 @@ export class MessageQueue {
         if (!this.shouldProcess(message)) {
             return Promise.resolve();
         }
+        // 拦截器检查：AskUserQuestion 等场景的一次性消息拦截
+        const interceptor = this.interceptors.get(sessionKey);
+        if (interceptor) {
+            this.interceptors.delete(sessionKey);
+            logger.debug(`[Queue] Message intercepted for ${sessionKey}`);
+            interceptor(message);
+            return Promise.resolve();
+        }
         const queueKey = this.getQueueKey(sessionKey, projectPath);
         logger.debug(`[Queue] Enqueuing message for ${queueKey}`);
         return new Promise((resolve, reject) => {
@@ -97,6 +120,7 @@ export class MessageQueue {
                 this.processing.delete(queueKey);
                 this.currentSessionKey = undefined;
                 this.currentProjectPath = undefined;
+                this.activeMessageIds.clear();
                 return;
             }
             // FIFO 贪心合并：弹出队首连续同 peerId 的消息
@@ -105,6 +129,12 @@ export class MessageQueue {
             this.currentSessionKey = queueKey;
             this.currentProjectPath = merged.projectPath;
             this.currentAgentId = merged.message.agentId;
+            // 记录正在执行的 messageId（用于撤回中断）
+            this.activeMessageIds.clear();
+            for (const item of items) {
+                if (item.message.messageId)
+                    this.activeMessageIds.add(item.message.messageId);
+            }
             const resolves = items.map(i => i.resolve);
             const rejects = items.map(i => i.reject);
             logger.debug(`[Queue] Processing ${items.length} message(s) from ${merged.message.channel}:${merged.message.channelId}`);
@@ -200,6 +230,24 @@ export class MessageQueue {
         }
         return false;
     }
+    /**
+     * 撤回正在执行的消息：如果 messageId 正在处理中，触发 interrupt。
+     * @returns true 如果找到并触发了中断
+     */
+    cancelActive(messageId) {
+        if (!this.activeMessageIds.has(messageId))
+            return false;
+        if (!this.currentSessionKey)
+            return false;
+        // 从 queueKey 提取 sessionKey
+        const sessionKey = this.currentSessionKey.split('::')[0];
+        logger.info(`[Queue] Recalled active message ${messageId}, interrupting session ${sessionKey}`);
+        this.eventBus?.publish({ type: 'message:interrupted', sessionId: sessionKey, reason: 'recalled' });
+        if (this.interruptCallback) {
+            this.interruptCallback(sessionKey, this.currentAgentId).catch(() => { });
+        }
+        return true;
+    }
     /**
      * 外部锁：快速命令（/compact, /clear）执行期间阻塞队列处理
      * 返回 release 函数

package/dist/core/message/stream-flusher.js

@@ -161,13 +161,13 @@ export class StreamFlusher {
         if (this.diagEnabled)
             diag(this.instanceId, 'flushActivitiesOnly', { outputLen: output.length });
         if (output) {
+            this.sentContent = true; // 同步标记，避免 timer flush 未 await 时的竞态
             const text = output;
             // chain 保持不断裂：单条失败不阻塞后续（catch → resolve）
             this.sendChain = this.sendChain
                 .then(() => this.send(text, false, false))
                 .catch(e => { logger.warn('[StreamFlusher] send failed:', e); });
             await this.sendChain;
-            this.sentContent = true;
             this.lastFlush = Date.now();
             this.flushCount++;
         }
@@ -207,6 +207,7 @@ export class StreamFlusher {
         if (this.diagEnabled)
             diag(this.instanceId, 'flush', { isFinal, outputLen: output.length, flushCount: this.flushCount, sinceLastFlush: Date.now() - this.lastFlush, preview: output.substring(0, 80) });
         if (output) {
+            this.sentContent = true; // 同步标记，避免 timer flush 未 await 时的竞态
             const text = output;
             const final = isFinal;
             const ht = hasText;
@@ -214,7 +215,6 @@ export class StreamFlusher {
                 .then(() => this.send(text, final, ht))
                 .catch(e => { logger.warn('[StreamFlusher] send failed:', e); });
             await this.sendChain;
-            this.sentContent = true;
             this.lastFlush = Date.now();
             this.flushCount++;
         }

package/dist/core/session/session-manager.js

@@ -9,17 +9,22 @@ export class SessionManager {
     db;
     eventBus;
     ownerResolver;
+    adminResolver;
     fileAdapters = new Map();
-    constructor(dbPath = resolvePaths().db, eventBus, ownerResolver) {
+    constructor(dbPath = resolvePaths().db, eventBus, ownerResolver, adminResolver) {
         ensureDir(path.dirname(dbPath));
         this.db = new DatabaseSync(dbPath);
         this.eventBus = eventBus;
         this.ownerResolver = ownerResolver;
+        this.adminResolver = adminResolver;
         this.initDatabase();
     }
     setOwnerResolver(resolver) {
         this.ownerResolver = resolver;
     }
+    setAdminResolver(resolver) {
+        this.adminResolver = resolver;
+    }
     registerFileAdapter(adapter) {
         this.fileAdapters.set(adapter.agentId, adapter);
         logger.debug(`[SessionManager] Registered file adapter: ${adapter.agentId}`);
@@ -62,8 +67,11 @@ export class SessionManager {
     resolveIdentity(channel, userId) {
         if (!userId)
             return { role: 'anonymous', mode: 'interactive' };
-        const isOwner = this.ownerResolver?.(channel, userId) ?? false;
-        return { role: isOwner ? 'owner' : 'guest', mode: 'interactive' };
+        if (this.ownerResolver?.(channel, userId))
+            return { role: 'owner', mode: 'interactive' };
+        if (this.adminResolver?.(channel, userId))
+            return { role: 'admin', mode: 'interactive' };
+        return { role: 'guest', mode: 'interactive' };
     }
     /** 更新 session 的 identity（owner 绑定后调用） */
     async updateIdentity(sessionId, identity) {
@@ -546,6 +554,10 @@ export class SessionManager {
             sets.push('metadata = ?');
             values.push(updates.metadata ? JSON.stringify(updates.metadata) : null);
         }
+        if ('agentSessionId' in updates) {
+            sets.push('claude_session_id = ?');
+            values.push(updates.agentSessionId ?? null);
+        }
         if (sets.length === 0)
             return;
         sets.push('updated_at = ?');
@@ -731,6 +743,12 @@ export class SessionManager {
     `).get(targetChannel, ownerPeerId);
         return row?.channel_id;
     }
+    async getSessionById(sessionId) {
+        const row = this.db.prepare('SELECT * FROM sessions WHERE id = ? AND deleted_at IS NULL').get(sessionId);
+        if (!row)
+            return undefined;
+        return this.rowToSession(row);
+    }
     async getActiveSession(channel, channelId) {
         const row = this.db.prepare(`
       SELECT * FROM sessions