evolclaw 2.8.2 → 3.0.0

package/dist/core/command-handler.js

@@ -1,11 +1,15 @@
 import { DEFAULT_PERMISSION_MODE } from '../types.js';
 import { hasModelSwitcher, hasPermissionController } from '../agents/claude-runner.js';
-import { saveConfig, resolvePaths, getPackageRoot, getOwner, getChannelShowActivities, setChannelShowActivities } from '../config.js';
+import { renderCommandCardAsText } from './interaction-router.js';
+import { buildEnvelope, sendInteractionPayload } from './message/message-processor.js';
+import { resolvePaths, getPackageRoot } from '../paths.js';
 import { logger } from '../utils/logger.js';
 import crypto from 'crypto';
 import path from 'path';
 import fs from 'fs';
 import os from 'os';
+import { parseTriggerSet } from './trigger/parser.js';
+import { calcNextFireAt } from './trigger/scheduler.js';
 const allEfforts = ['low', 'medium', 'high', 'max'];
 const nonMaxEfforts = allEfforts.filter(e => e !== 'max');
 function getAvailableEfforts(agent, model) {
@@ -104,7 +108,7 @@ function formatIdleTime(ms) {
     return '刚刚';
 }
 // 支持的命令列表
-const commands = ['/new', '/pwd', '/plist', '/project', '/bind', '/help', '/status', '/restart', '/model', '/effort', '/agent', '/slist', '/session', '/rename', '/stop', '/clear', '/compact', '/repair', '/safe', '/fork', '/del', '/perm', '/file', '/check', '/rewind', '/activity', '/aid', '/agentmd', '/chatmode', '/ask'];
+const commands = ['/new', '/pwd', '/plist', '/project', '/bind', '/help', '/evolhelp', '/status', '/restart', '/model', '/setmodel', '/effort', '/agent', '/slist', '/session', '/rename', '/stop', '/clear', '/compact', '/repair', '/safe', '/fork', '/del', '/perm', '/file', '/check', '/rewind', '/activity', '/chatmode', '/dispatch', '/ask', '/resume', '/aid', '/rpc', '/storage', '/trigger'];
 // 命令别名映射
 const aliases = {
     '/p': '/project',
@@ -113,10 +117,9 @@ const aliases = {
     '/rw': '/rewind'
 };
 // 命令快速路径前缀（所有命令都不进入消息队列）
-const quickCommandPrefixes = ['/new', '/pwd', '/plist', '/project', '/bind', '/help', '/status', '/restart', '/model', '/effort', '/agent', '/slist', '/session', '/rename', '/repair', '/fork', '/stop', '/clear', '/compact', '/safe', '/del', '/perm', '/file', '/check', '/p ', '/s ', '/name', '/rewind', '/rw', '/rw ', '/activity', '/chatmode', '/aid', '/agentmd', '/ask'];
+const quickCommandPrefixes = ['/new', '/pwd', '/plist', '/project', '/bind', '/help', '/evolhelp', '/status', '/restart', '/model', '/setmodel', '/effort', '/agent', '/slist', '/session', '/rename', '/repair', '/fork', '/stop', '/clear', '/compact', '/safe', '/del', '/perm', '/file', '/check', '/p ', '/s ', '/name', '/rewind', '/rw', '/rw ', '/activity', '/chatmode', '/dispatch', '/ask', '/resume', '/aid', '/rpc', '/storage', '/trigger'];
 export class CommandHandler {
     sessionManager;
-    config;
     messageCache;
     eventBus;
     adapters = new Map();
@@ -129,50 +132,81 @@ export class CommandHandler {
     interactionRouter;
     statsCollector;
     agentMap;
-    defaultAgentId;
+    primaryRunnerKey;
     agentRegistry;
-    /** 按 agentId 获取 agent，回退到默认 */
-    getAgent(agentId) {
-        if (agentId && this.agentMap.has(agentId))
-            return this.agentMap.get(agentId);
-        return this.agentMap.get(this.defaultAgentId) || this.agentMap.values().next().value;
+    triggerScheduler;
+    triggerManager;
+    /**
+     * Get the runner for a (channel, baseagent) pair.
+     *
+     * Resolves the owning EvolAgent via the registry; falls back to default key.
+     * `baseagent` typically comes from `session.agentId` (e.g. 'claude').
+     */
+    getAgent(channel, baseagent) {
+        if (channel && baseagent) {
+            const evolName = this.agentRegistry?.resolveByChannel(channel)?.name || '<unknown>';
+            const key = `${evolName}::${baseagent}`;
+            if (this.agentMap.has(key))
+                return this.agentMap.get(key);
+        }
+        if (this.agentMap.has(this.primaryRunnerKey))
+            return this.agentMap.get(this.primaryRunnerKey);
+        return this.agentMap.values().next().value;
+    }
+    /** Return the list of baseagents available to a given channel (per-EvolAgent isolation). */
+    getAvailableBaseagents(channel) {
+        const evolName = this.agentRegistry?.resolveByChannel(channel)?.name || '<unknown>';
+        const prefix = `${evolName}::`;
+        const result = [];
+        for (const key of this.agentMap.keys()) {
+            if (key.startsWith(prefix))
+                result.push(key.slice(prefix.length));
+        }
+        return result;
     }
-    constructor(sessionManager, agentRunnerOrMap, config, messageCache, eventBus, defaultAgentId) {
+    /** Extract the baseagent component from `primaryRunnerKey` (e.g. `aid::claude` → `claude`). */
+    parseDefaultBaseagent() {
+        const idx = this.primaryRunnerKey.indexOf('::');
+        return idx >= 0 ? this.primaryRunnerKey.slice(idx + 2) : this.primaryRunnerKey;
+    }
+    constructor(sessionManager, agentRunnerOrMap, messageCache, eventBus, primaryRunnerKey) {
         this.sessionManager = sessionManager;
-        this.config = config;
         this.messageCache = messageCache;
         this.eventBus = eventBus;
         if (agentRunnerOrMap instanceof Map) {
             this.agentMap = agentRunnerOrMap;
-            this.defaultAgentId = defaultAgentId || 'claude';
+            this.primaryRunnerKey = primaryRunnerKey || '<unknown>::claude';
         }
         else {
-            this.agentMap = new Map([[agentRunnerOrMap.name, agentRunnerOrMap]]);
-            this.defaultAgentId = agentRunnerOrMap.name;
+            // 测试 / 单 runner 路径：占位 agent name 用 '<unknown>'
+            this.agentMap = new Map([[`<unknown>::${agentRunnerOrMap.name}`, agentRunnerOrMap]]);
+            this.primaryRunnerKey = `<unknown>::${agentRunnerOrMap.name}`;
         }
     }
     /** 注入 EvolAgentRegistry，用于判断通道是否被 EvolAgent 管理 */
     setAgentRegistry(registry) {
         this.agentRegistry = registry;
     }
-    /** 返回管理当前通道的 EvolAgent（非 default），无则返回 null */
+    /** 注入触发器调度器（由 index.ts 在初始化后调用） */
+    setTriggerScheduler(scheduler, manager) {
+        this.triggerScheduler = scheduler;
+        this.triggerManager = manager;
+    }
+    /** 返回管理当前通道的 EvolAgent，无则返回 null */
     getOwningAgent(channel) {
         if (!this.agentRegistry)
             return null;
-        const agent = this.agentRegistry.resolveByChannel(channel);
-        if (!agent || agent.isDefault)
-            return null;
-        return agent;
+        return this.agentRegistry.resolveByChannel(channel);
     }
-    /** 返回当前通道的有效项目路径：agent-owned 用 agent.projectPath；否则用全局 defaultPath。*/
+    /** 返回当前通道的有效项目路径：从 owning agent 取。*/
     getEffectiveDefaultPath(channel) {
         const owning = this.getOwningAgent(channel);
         if (owning)
             return owning.projectPath;
-        return this.config.projects?.defaultPath || process.cwd();
+        return process.cwd();
     }
     /**
-     * 返回当前通道有效的 projects.list（agent-owned 用 agent.json 的；否则全局 evolclaw.json 的）。
+     * 返回当前通道有效的 projects.list（从 owning agent 的 config 取）。
      * 都没配 list 时回退到 defaultPath 单项目。
      */
     getEffectiveProjects(channel) {
@@ -183,39 +217,24 @@ export class CommandHandler {
         return this.projects;
     }
     /**
-     * 添加项目到当前通道范围（agent-owned 写 agent.json；default 写 evolclaw.json）。
+     * 添加项目到当前通道范围（写到 owning agent 的 config.json）。
      */
     async addProjectInScope(channel, name, projectPath) {
         const owning = this.getOwningAgent(channel);
-        if (owning) {
-            try {
-                owning.addProject(name, projectPath);
-            }
-            catch (e) {
-                return `⚠️ 写入 agent.json 失败: ${e?.message || e}`;
-            }
-            return undefined;
-        }
-        if (!this.config.projects) {
-            this.config.projects = { defaultPath: process.cwd(), autoCreate: false, list: {} };
+        if (!owning) {
+            return `⚠️ 找不到通道 "${channel}" 所属的 self-agent`;
         }
-        if (!this.config.projects.list) {
-            this.config.projects.list = {};
-        }
-        this.config.projects.list[name] = projectPath;
         try {
-            const { saveConfig } = await import('../config.js');
-            saveConfig(this.config);
+            owning.addProject(name, projectPath);
         }
         catch (e) {
-            return `⚠️ 写入 evolclaw.json 失败: ${e?.message || e}`;
+            return `⚠️ 写入 agent config 失败: ${e?.message || e}`;
         }
-        // Refresh in-memory list cache (this.projects getter reads from this.config)
         return undefined;
     }
     /**
-     * 持久化 baseagent.model：agent-owned 写到 agent.json；否则写 evolclaw.json 或 ~/.claude/settings.json。
-     * 返回错误信息或 undefined。
+     * 持久化 baseagent.model：写到 agent config.json；找不到 owning agent 时
+     * 退到用户级 ~/.claude/settings.json（Claude 专用）。
      */
     persistBaseagentModel(channel, baseagentName, newModel) {
         const owning = this.getOwningAgent(channel);
@@ -224,42 +243,14 @@ export class CommandHandler {
                 owning.setBaseagentModel(newModel);
             }
             catch (e) {
-                return `⚠️ 写入 agent.json 失败: ${e?.message || e}`;
-            }
-            return undefined;
-        }
-        // DefaultAgent / 无 owning agent：保留原"就近原则"
-        if (!this.config.agents)
-            this.config.agents = {};
-        const isCodex = baseagentName === 'codex';
-        if (isCodex) {
-            if (!this.config.agents.codex)
-                this.config.agents.codex = {};
-            if (newModel)
-                this.config.agents.codex.model = newModel;
-            try {
-                saveConfig(this.config);
-            }
-            catch (e) {
-                return `⚠️ 写入 evolclaw.json 失败: ${e.message}`;
+                return `⚠️ 写入 agent config 失败: ${e?.message || e}`;
             }
             return undefined;
         }
-        const configuredInEvolclaw = !!(this.config.agents?.claude?.model || this.config.agents?.claude?.effort);
-        if (configuredInEvolclaw) {
-            if (!this.config.agents.claude)
-                this.config.agents.claude = {};
-            if (newModel)
-                this.config.agents.claude.model = newModel;
-            try {
-                saveConfig(this.config);
-            }
-            catch (e) {
-                return `⚠️ 写入 evolclaw.json 失败: ${e.message}`;
-            }
-            return undefined;
+        // 无 owning agent（罕见，新结构下应当不会发生）→ 仅 Claude 走用户级 fallback
+        if (baseagentName !== 'claude') {
+            return `⚠️ 找不到通道 "${channel}" 所属的 self-agent`;
         }
-        // Fallback: ~/.claude/settings.json
         const updates = {};
         if (newModel)
             updates.model = newModel;
@@ -270,7 +261,7 @@ export class CommandHandler {
         return undefined;
     }
     /**
-     * 持久化 baseagent.effort：agent-owned 写到 agent.json；否则就近原则。
+     * 持久化 baseagent.effort：写到 agent config.json；找不到时退到用户级 settings。
      */
     persistBaseagentEffort(channel, baseagentName, newEffort) {
         const owning = this.getOwningAgent(channel);
@@ -279,57 +270,12 @@ export class CommandHandler {
                 owning.setBaseagentEffort(newEffort);
             }
             catch (e) {
-                return `⚠️ 写入 agent.json 失败: ${e?.message || e}`;
+                return `⚠️ 写入 agent config 失败: ${e?.message || e}`;
             }
             return undefined;
         }
-        if (!this.config.agents)
-            this.config.agents = {};
-        const isCodex = baseagentName === 'codex';
-        if (isCodex) {
-            if (newEffort === undefined) {
-                if (this.config.agents.codex?.reasoning) {
-                    delete this.config.agents.codex.reasoning;
-                    try {
-                        saveConfig(this.config);
-                    }
-                    catch { }
-                }
-            }
-            else {
-                if (!this.config.agents.codex)
-                    this.config.agents.codex = {};
-                this.config.agents.codex.reasoning = newEffort;
-                try {
-                    saveConfig(this.config);
-                }
-                catch (e) {
-                    return `⚠️ 写入 evolclaw.json 失败: ${e.message}`;
-                }
-            }
-            return undefined;
-        }
-        const configuredInEvolclaw = !!(this.config.agents?.claude?.model || this.config.agents?.claude?.effort);
-        if (configuredInEvolclaw) {
-            if (newEffort === undefined) {
-                delete this.config.agents.claude.effort;
-                try {
-                    saveConfig(this.config);
-                }
-                catch { }
-            }
-            else {
-                if (!this.config.agents.claude)
-                    this.config.agents.claude = {};
-                this.config.agents.claude.effort = newEffort;
-                try {
-                    saveConfig(this.config);
-                }
-                catch (e) {
-                    return `⚠️ 写入 evolclaw.json 失败: ${e.message}`;
-                }
-            }
-            return undefined;
+        if (baseagentName !== 'claude') {
+            return `⚠️ 找不到通道 "${channel}" 所属的 self-agent`;
         }
         const updates = { effortLevel: newEffort ?? null };
         const writeResult = writeUserSettings(updates);
@@ -338,14 +284,8 @@ export class CommandHandler {
         }
         return undefined;
     }
-    /** 项目列表快捷访问（list 缺失时用 defaultPath 作为唯一项目） */
+    /** 项目列表快捷访问（无 channel 上下文时的 fallback，尽量不用） */
     get projects() {
-        const list = this.config.projects?.list;
-        if (list && Object.keys(list).length > 0)
-            return list;
-        const dp = this.config.projects?.defaultPath;
-        if (dp)
-            return { [path.basename(dp)]: dp };
         return {};
     }
     /** 根据项目路径查找配置中的项目名称 */
@@ -384,72 +324,63 @@ export class CommandHandler {
         return session.metadata?.replyContext;
     }
     /**
-     * 尝试通过渠道适配器发送交互卡片。
-     * 返回 message_id 表示卡片已发送，false 表示降级为文本。
+     * 发送 CommandCard 卡片。卡片成功返回 null（调用方直接 return），失败返回降级文本。
+     * CommandCard 不进 InteractionRouter，按钮点击由 channel 直接构造伪命令入站消息。
+     *
+     * 走统一 adapter.send(envelope, { kind: 'interaction', ... }) 入口。
      */
-    async trySendInteraction(channel, channelId, interaction, replyContext) {
-        const adapter = this.adapters.get(channel);
-        if (!adapter?.sendInteraction)
-            return false;
+    async sendCommandCard(opts) {
+        const adapter = this.adapters.get(opts.channel);
+        if (opts.interaction.kind.kind !== 'command-card') {
+            logger.warn(`[CommandHandler] sendCommandCard called with non-CommandCard kind`);
+            return null;
+        }
+        const card = opts.interaction.kind;
+        if (opts.canWrite === false)
+            return renderCommandCardAsText(card);
+        if (!adapter?.send)
+            return renderCommandCardAsText(card);
+        // session 忙碌时降级到文本，避免并发触发带参写操作
+        if (this.isSessionBusy(opts.interaction.sessionId))
+            return renderCommandCardAsText(card);
         try {
-            return await adapter.sendInteraction(channelId, interaction, replyContext);
+            const envelope = buildEnvelope({
+                channel: opts.channel,
+                channelId: opts.channelId,
+                agentName: this.agentRegistry?.resolveByChannel(opts.channel)?.name,
+                replyContext: opts.replyCtx,
+            });
+            const fallbackText = renderCommandCardAsText(card);
+            const messageId = await sendInteractionPayload(adapter, envelope, opts.interaction, fallbackText, opts.replyCtx);
+            if (messageId)
+                return null;
         }
         catch (e) {
-            logger.warn(`[CommandHandler] sendInteraction failed: ${e}`);
-            return false;
-        }
-    }
-    /** 作废某 session 下所有 pending 交互卡片（PATCH 禁用 + cancel） */
-    async invalidateOldCards(channel, sessionId) {
-        if (!this.interactionRouter)
-            return;
-        const adapter = this.adapters.get(channel);
-        const pending = this.interactionRouter.getPending(sessionId);
-        if (pending.length === 0)
-            return;
-        const disabledCard = {
-            config: { wide_screen_mode: true },
-            header: { template: 'grey', title: { tag: 'plain_text', content: '已过期' } },
-            elements: [{ tag: 'markdown', content: '此卡片已过期，请查看最新卡片。' }],
-        };
-        for (const id of pending) {
-            const msgId = this.interactionRouter.getMessageId(id);
-            if (msgId && adapter?.patchInteractionCard) {
-                adapter.patchInteractionCard(msgId, disabledCard).catch(() => { });
-            }
-            this.interactionRouter.cancel(id);
+            logger.warn(`[CommandHandler] sendCommandCard failed: ${e}`);
         }
+        return renderCommandCardAsText(card);
     }
     /**
-     * 发送交互卡片并注册回调。作废旧卡片 → 发送新卡片 → 注册到 interactionRouter。
-     * 返回 true 表示卡片已发送（调用方应 return null），false 表示降级到文本。
+     * 通用降级应答入口：按 (sessionId, fallbackCommand) 查找 pending interaction 并路由。
+     * 返回 { matched: true } 表示已处理，调用方直接返回 result。
      */
-    async sendInteractionCard(opts) {
+    async handleInteractionFallback(command, args, sessionId, userId) {
         if (!this.interactionRouter)
-            return false;
-        // 无写权限 → 走文本降级（由调用点 fall through 输出只读信息）
-        if (opts.canWrite === false)
-            return false;
-        // 有写权限但此刻忙碌 → 也走文本降级（避免诱导用户在忙碌状态下触发带参写操作）
-        if (this.isSessionBusy(opts.sessionId))
-            return false;
-        await this.invalidateOldCards(opts.channel, opts.sessionId);
-        const messageId = await this.trySendInteraction(opts.channel, opts.channelId, opts.interaction, opts.replyCtx);
-        if (!messageId)
-            return false;
-        const wrappedCallback = async (action, values, operatorId) => {
-            // 点击回调时二次校验：若会话此刻忙碌，忽略本次点击（防止已弹卡片被用于带参切换）
-            if (this.isSessionBusy(opts.sessionId)) {
-                const adapter = this.adapters.get(opts.channel);
-                adapter?.sendText(opts.channelId, '⚠️ 当前正在处理消息，请稍后再试\n使用 /stop 中断当前任务后重试', opts.replyCtx);
-                return;
-            }
-            await opts.callback(action, values, operatorId);
-            // 已完成交互的卡片：保留原始内容，仅禁用按钮（不标记为"已过期"）
-            // "已过期"仅用于被新卡片替代的旧卡片（invalidateOldCards）
-        };
-        this.interactionRouter.register(opts.requestId, opts.sessionId, wrappedCallback, { timeoutMs: 120_000, messageId });
-        return true;
+            return { matched: false };
+        const pendingId = this.interactionRouter.findPendingByCommand(sessionId, command);
+        if (!pendingId)
+            return { matched: false };
+        const initiatorId = this.interactionRouter.getInitiator(pendingId);
+        if (initiatorId && userId && initiatorId !== userId) {
+            return { matched: true, result: '⚠️ 仅卡片发起者可应答' };
+        }
+        this.interactionRouter.handle({
+            type: 'interaction.response',
+            id: pendingId,
+            action: args,
+            operatorId: userId,
+        });
+        return { matched: true, result: '✓ 已回答' };
     }
     /** 判断指定 session 是否有活跃流（用于 idle 守卫和卡片降级） */
     isSessionBusy(sessionId) {
@@ -459,8 +390,8 @@ export class CommandHandler {
         }
         return false;
     }
-    /** 获取活跃会话，无会话时返回统一错误提示 */
-    async ensureSession(channel, channelId, threadId) {
+    /** 获取活跃会话，无会话时自动创建（话题除外） */
+    async ensureSession(channel, channelId, threadId, chatType) {
         if (threadId) {
             // 话题会话：仅查询，不创建
             const session = await this.sessionManager.getThreadSession(channel, channelId, threadId);
@@ -469,9 +400,13 @@ export class CommandHandler {
             }
             return { session };
         }
-        const session = await this.sessionManager.getActiveSession(channel, channelId);
-        if (!session) {
-            return { error: '❌ 当前没有活跃会话\n使用 /new 创建新会话' };
+        const ct = chatType === 'group' ? 'group' : chatType === 'private' ? 'private' : undefined;
+        const session = await this.sessionManager.getActiveSession(channel, channelId)
+            ?? await this.sessionManager.getOrCreateSession(channel, channelId, this.getEffectiveDefaultPath(channel), undefined, undefined, undefined, undefined, ct);
+        // 如果 session 已存在但 chatType 跟传入的不一致，更新
+        if (ct && session.chatType !== ct) {
+            await this.sessionManager.updateSession(session.id, { chatType: ct });
+            session.chatType = ct;
         }
         return { session };
     }
@@ -589,6 +524,10 @@ export class CommandHandler {
                                 { value: 'interactive', label: '交互模式', desc: '仅在收到消息时响应' },
                                 { value: 'proactive', label: '主动模式', desc: 'Agent 可主动推进任务' },
                             ] } },
+                    { cmd: '/dispatch', label: '切换分发模式', desc: '控制群聊消息过滤（仅@提及或广播响应）', next: { type: 'select', items: [
+                                { value: 'mention', label: '@ 提及', desc: '仅在被 @ 提及时响应' },
+                                { value: 'all', label: '广播', desc: '响应群内所有消息' },
+                            ] } },
                 ]
             });
             items.push({
@@ -626,14 +565,6 @@ export class CommandHandler {
                     ] : []),
                     ...(isOwner ? [
                         { cmd: '/file', label: '发送项目内文件', desc: '将项目目录内的文件发送给用户' },
-                        { cmd: '/aid', label: 'AID 身份管理', desc: '管理本地 AID 身份（创建/列表）', next: { type: 'select', items: [
-                                    { value: 'list', label: '列表', desc: '列出本地所有 AID' },
-                                    { value: 'new', label: '创建', desc: '创建新 AID 身份', next: { type: 'text' } },
-                                ] } },
-                        { cmd: '/agentmd', label: '管理 agent.md', desc: '查看或更新 AUN 网络上的 agent.md 身份文件', next: { type: 'select', items: [
-                                    { value: 'put', label: '上传当前', desc: '将本地 agent.md 上传到 AUN 网络' },
-                                    { value: 'set', label: '直接设置', desc: '输入内容直接更新 agent.md', next: { type: 'text' } },
-                                ] } },
                     ] : []),
                 ]
             });
@@ -680,15 +611,15 @@ export class CommandHandler {
         }
         if (cmd === '/p') {
             // Use agent-scoped project list: agent-owned channels see their agent.json's
-            // projects.list; default channel sees evolclaw.json's projects.list
+            // projects.list; default channel sees agent config's projects.list
             const list = this.getEffectiveProjects(channel);
             return Object.entries(list).map(([name, path]) => ({ value: name, label: name, desc: path }));
         }
         if (cmd === '/agent') {
-            return [...this.agentMap.keys()].map(name => ({ value: name, label: name }));
+            return this.getAvailableBaseagents(channel).map(name => ({ value: name, label: name }));
         }
         if (cmd === '/model') {
-            const agent = this.getAgent(session?.agentId);
+            const agent = this.getAgent(channel, session?.agentId);
             if (hasModelSwitcher(agent) && agent.listModels) {
                 const models = await agent.listModels() ?? [];
                 if (models.length > 0)
@@ -697,10 +628,6 @@ export class CommandHandler {
             return null;
         }
         if (cmd === '/restart') {
-            // /restart 是服务级操作（重连/重启进程），仅限 default 通道。
-            // EvolAgent 通道返回空菜单（用户在 agent-owned 通道上无可选项）
-            if (this.getOwningAgent(channel))
-                return [];
             const isOwner = userId ? this.sessionManager.resolveIdentity(channel, userId).role === 'owner' : false;
             // 列出所有 channel type
             const visibleTypes = new Set();
@@ -737,7 +664,7 @@ export class CommandHandler {
             const identity = this.sessionManager.resolveIdentity(channel, userId);
             if (identity.role !== 'owner')
                 return { error: '无权限' };
-            const permAgent = this.getAgent(session.agentId);
+            const permAgent = this.getAgent(channel, session.agentId);
             const validModes = hasPermissionController(permAgent)
                 ? permAgent.listModes().filter(m => m.available).map(m => m.key)
                 : ['auto', 'bypass', 'plan', 'edit', 'request', 'noask'];
@@ -763,6 +690,27 @@ export class CommandHandler {
                 return { error: '无权限：群聊中仅管理员可切换' };
             }
             await this.sessionManager.updateSession(session.id, { sessionMode: arg });
+            this.eventBus.publish({ type: 'session:chat-mode-changed', sessionId: session.id, mode: arg, timestamp: Date.now() });
+            return { data: { mode: arg } };
+        }
+        if (cmdBase === '/dispatch') {
+            const currentMode = session.metadata?.dispatchMode || 'mention';
+            if (mode === 'query') {
+                return { data: { mode: currentMode } };
+            }
+            // update
+            if (!arg)
+                return { error: '缺少目标模式' };
+            if (arg !== 'mention' && arg !== 'all')
+                return { error: `无效模式: ${arg}` };
+            const identity = this.sessionManager.resolveIdentity(channel, userId);
+            const chatType = session.chatType || 'private';
+            if (chatType === 'group' && identity.role !== 'owner' && identity.role !== 'admin') {
+                return { error: '无权限：群聊中仅管理员可切换' };
+            }
+            const metadata = { ...(session.metadata || {}), dispatchMode: arg };
+            await this.sessionManager.updateSession(session.id, { metadata });
+            this.eventBus.publish({ type: 'session:dispatch-mode-changed', sessionId: session.id, mode: arg, timestamp: Date.now() });
             return { data: { mode: arg } };
         }
         return { error: `不支持 exec 模式: ${cmdBase}` };
@@ -773,13 +721,17 @@ export class CommandHandler {
     /**
      * 主命令处理入口
      */
-    async handle(content, channel, channelId, sendMessage, userId, threadId) {
+    async handle(content, channel, channelId, sendMessage, userId, threadId, chatType, source) {
+        const result = await this._handleInternal(content, channel, channelId, sendMessage, userId, threadId, chatType, source);
+        return result;
+    }
+    async _handleInternal(content, channel, channelId, sendMessage, userId, threadId, chatType, source) {
         // 解析身份（按实例名）
         const identity = this.sessionManager.resolveIdentity(channel, userId);
         const policy = this.getPolicy(channel);
         // 按当前会话选择 agent 后端
         const activeSession = await this.sessionManager.getActiveSession(channel, channelId);
-        const agent = this.getAgent(activeSession?.agentId);
+        const agent = this.getAgent(channel, activeSession?.agentId);
         // 规范化命令（将别名转换为完整命令）
         let normalizedContent = content;
         for (const [alias, full] of Object.entries(aliases)) {
@@ -797,7 +749,7 @@ export class CommandHandler {
             const threadBlocked = ['/new', '/slist', '/plist', '/bind', '/s', '/session', '/project', '/p', '/fork', '/del', '/agent'];
             const isBlocked = threadBlocked.some(c => normalizedContent === c || normalizedContent.startsWith(c + ' '));
             if (isBlocked) {
-                return '⚠️ 话题中不支持此命令';
+                return { kind: 'command.error', text: '⚠️ 话题中不支持此命令' };
             }
         }
         // Agent-owned 通道：禁止项目切换和 agent 切换
@@ -808,10 +760,10 @@ export class CommandHandler {
                 normalizedContent === '/plist' ||
                 normalizedContent === '/p' || normalizedContent.startsWith('/p ');
             if (isProjectCmd) {
-                return `❌ 当前通道由 agent [${owningAgent.name}] 管理，项目已锁定为 ${owningAgent.projectPath}`;
+                return { kind: 'command.error', text: `❌ 当前通道由 agent [${owningAgent.name}] 管理，项目已锁定为 ${owningAgent.projectPath}` };
             }
             if (normalizedContent.startsWith('/agent ')) {
-                return `❌ 当前通道由 agent [${owningAgent.name}] 管理，baseagent 已锁定为 ${owningAgent.baseagent}`;
+                return { kind: 'command.error', text: `❌ 当前通道由 agent [${owningAgent.name}] 管理，baseagent 已锁定为 ${owningAgent.baseagent}` };
             }
         }
         // 权限检查：区分用户级命令和管理级命令
@@ -821,8 +773,9 @@ export class CommandHandler {
         if (normalizedContent.startsWith('/')) {
             // guest 在群聊和私聊中均可访问的只读命令：纯查询形态（带参写操作由各 handler 内部守卫拦截）
             const guestGroupCommands = [
-                '/status', '/help', '/check', '/chatmode',
-                '/model', '/effort', '/agent', '/perm', '/activity', '/safe', '/stop',
+                '/status', '/help', '/evolhelp', '/check', '/chatmode', '/dispatch',
+                '/model', '/setmodel', '/effort', '/agent', '/perm', '/activity', '/safe', '/stop',
+                '/resume', '/trigger',
             ];
             const userCommands = activeChatType === 'group' && !isAdmin
                 ? guestGroupCommands
@@ -833,9 +786,9 @@ export class CommandHandler {
                 ];
             const isUserCommand = userCommands.some(cmd => normalizedContent === cmd.trimEnd() || normalizedContent.startsWith(cmd));
             if (!isUserCommand && !isAdmin) {
-                return activeChatType === 'group'
-                    ? '❌ 无权限：当前群聊仅支持 /status 和 /help'
-                    : '❌ 无权限：此命令仅限管理员使用';
+                return { kind: 'command.error', text: activeChatType === 'group'
+                        ? '❌ 无权限：当前群聊仅支持 /status 和 /help'
+                        : '❌ 无权限：此命令仅限管理员使用' };
             }
         }
         // 空闲检查：某些命令需要等待当前会话空闲
@@ -843,6 +796,7 @@ export class CommandHandler {
         // - 始终需要 idle（无参即写）：/new /clear /compact /repair /fork
         // - 仅带参时需要 idle（无参是列表/用法）：/session /bind /project /agent /rewind
         // - /chatmode：在 handler 内部自行做写操作的 idle 检查
+        // - /dispatch：在 handler 内部自行做写操作的 idle 检查
         // - /safe：已禁用 no-op，不再要求 idle
         const idleAlways = ['/new', '/clear', '/compact', '/repair', '/fork'];
         const idleWhenArg = ['/session', '/bind', '/project', '/agent', '/rewind'];
@@ -853,14 +807,14 @@ export class CommandHandler {
                 // 话题中：检查话题 session 是否在处理（不创建）
                 const threadSession = await this.sessionManager.getThreadSession(channel, channelId, threadId);
                 if (threadSession) {
-                    const threadAgent = this.getAgent(threadSession.agentId);
+                    const threadAgent = this.getAgent(channel, threadSession.agentId);
                     if (threadAgent.hasActiveStream(threadSession.id)) {
-                        return '⚠️ 当前正在处理消息，请稍后再试\n使用 /stop 中断当前任务后重试';
+                        return { kind: 'command.error', text: '⚠️ 当前正在处理消息，请稍后再试\n使用 /stop 中断当前任务后重试' };
                     }
                 }
             }
             else if (activeSession && agent.hasActiveStream(activeSession.id)) {
-                return '⚠️ 当前正在处理消息，请稍后再试\n使用 /stop 中断当前任务后重试';
+                return { kind: 'command.error', text: '⚠️ 当前正在处理消息，请稍后再试\n使用 /stop 中断当前任务后重试' };
             }
         }
         // 检查是否以 / 开头（可能是命令）
@@ -873,10 +827,10 @@ export class CommandHandler {
                     return distance <= 2;
                 });
                 if (similar) {
-                    return `❌ 未知命令: ${inputCmd}\n💡 你是不是想输入: ${similar}\n\n输入 /help 查看所有可用命令`;
+                    return { kind: 'command.error', text: `❌ 未知命令: ${inputCmd}\n💡 你是不是想输入: ${similar}\n\n输入 /help 查看所有可用命令` };
                 }
                 else {
-                    return `❌ 未知命令: ${inputCmd}\n\n输入 /help 查看所有可用命令`;
+                    return { kind: 'command.error', text: `❌ 未知命令: ${inputCmd}\n\n输入 /help 查看所有可用命令` };
                 }
             }
         }
@@ -894,7 +848,7 @@ export class CommandHandler {
                     '  /check - 检查渠道健康',
                     '  /help - 显示此帮助信息',
                 ];
-                return lines.join('\n');
+                return { kind: 'command.result', text: lines.join('\n') };
             }
             if (!isAdmin) {
                 const lines = [
@@ -911,7 +865,7 @@ export class CommandHandler {
                     '❓ 帮助：',
                     '  /help - 显示此帮助信息',
                 ];
-                return lines.join('\n');
+                return { kind: 'command.result', text: lines.join('\n') };
             }
             // admin+ 基础命令
             const lines = [
@@ -936,6 +890,11 @@ export class CommandHandler {
                 '  /model [model] - 查看或切换模型',
                 '  /effort [level] - 查看或切换推理强度',
                 '',
+                '💬 聊天设置：',
+                '  /activity [all|dm|owner|none] - 查看/控制中间输出显示模式',
+                '  /chatmode [interactive|proactive] - 查看/切换会话模式（被动响应或主动推进）',
+                '  /dispatch [mention|all] - 查看/切换群聊分发模式（仅@响应或广播响应，仅群聊）',
+                '',
                 '🔐 权限管理：',
                 '  /perm - 查看当前权限模式',
                 ...(isOwner ? ['  /perm <auto|bypass|request|edit|plan|noask> - 切换权限模式'] : []),
@@ -945,80 +904,123 @@ export class CommandHandler {
                 '  /status - 显示会话状态',
                 '  /stop - 中断当前任务',
                 '  /check - 检查渠道状态',
-                '  /activity [all|dm|owner|none] - 查看/控制中间输出显示模式',
                 ...(isAdmin ? [
                     '  /restart <type> - 重连该类型所有渠道实例（服务级，admin+）',
                 ] : []),
                 ...(isOwner ? [
                     '  /restart - 重启服务',
+                ] : []),
+                ...(isOwner ? [
+                    '',
+                    '🧰 工具：',
                     '  /file [channel] <path> - 发送项目内文件',
-                    '  /aid [list|new <aid>] - AID 身份管理',
-                    '  /agentmd [put|set <内容>] - 管理 agent.md',
+                    '  /aid [list|show|new|delete|lookup|agentmd] - AID 身份管理',
+                    '  /storage [upload|download|ls|rm|quota] <aid> - 文件存储',
                 ] : []),
                 '',
                 '❓ 帮助：',
                 '  /help - 显示此帮助信息',
             ];
-            return lines.join('\n');
+            return { kind: 'command.result', text: lines.join('\n') };
+        }
+        // /evolhelp 命令：返回 JSON 格式的命令列表（供程序解析）
+        if (normalizedContent === '/evolhelp') {
+            const cmds = [];
+            // 项目管理
+            cmds.push({ command: '/pwd', description: '显示当前项目路径', category: '项目管理', roles: ['admin', 'owner'] });
+            cmds.push({ command: '/p', aliases: ['/project', '/plist'], args: '[name|path]', description: '列出或切换项目', category: '项目管理', roles: ['admin', 'owner'] });
+            if (isOwner) {
+                cmds.push({ command: '/bind', args: '<path>', description: '绑定新项目目录', category: '项目管理', roles: ['owner'] });
+            }
+            // 会话管理
+            cmds.push({ command: '/new', args: '[名称]', description: '创建新会话（清空历史请用此命令，可选命名）', category: '会话管理', roles: ['guest', 'admin', 'owner'] });
+            cmds.push({ command: '/s', aliases: ['/session', '/slist'], args: '[cli|名称|序号|uuid]', description: '列出或切换会话', category: '会话管理', roles: ['guest', 'admin', 'owner'] });
+            cmds.push({ command: '/name', aliases: ['/rename'], args: '<新名称>', description: '重命名当前会话', category: '会话管理', roles: ['guest', 'admin', 'owner'] });
+            cmds.push({ command: '/del', args: '<名称>', description: '删除指定会话（仅解绑，不删除文件）', category: '会话管理', roles: ['guest', 'admin', 'owner'] });
+            if (isAdmin) {
+                cmds.push({ command: '/fork', args: '[名称]', description: '分支当前会话（从当前对话点创建分支）', category: '会话管理', roles: ['admin', 'owner'] });
+                cmds.push({ command: '/rewind', aliases: ['/rw'], args: '[N] [chat|file|all]', description: '查看历史/撤销指定轮次', category: '会话管理', roles: ['admin', 'owner'] });
+                cmds.push({ command: '/compact', description: '压缩会话上下文（减少 token 用量）', category: '会话管理', roles: ['admin', 'owner'] });
+            }
+            // Agent 与模型
+            if (isAdmin) {
+                cmds.push({ command: '/agent', args: '[name]', description: '查看或切换 Agent 后端', category: 'Agent 与模型', roles: ['admin', 'owner'] });
+                cmds.push({ command: '/model', args: '[model]', description: '查看或切换模型', category: 'Agent 与模型', roles: ['admin', 'owner'] });
+                cmds.push({ command: '/effort', args: '[level]', description: '查看或切换推理强度', category: 'Agent 与模型', roles: ['admin', 'owner'] });
+            }
+            // 权限管理
+            if (isAdmin) {
+                cmds.push({ command: '/perm', args: isOwner ? '<auto|bypass|request|edit|plan|noask>' : undefined, description: '查看当前权限模式', category: '权限管理', roles: ['admin', 'owner'] });
+                cmds.push({ command: '/perm', args: 'allow|always|deny', description: '审批权限请求', category: '权限管理', roles: ['admin', 'owner'] });
+            }
+            // 运维
+            cmds.push({ command: '/status', description: '显示会话状态', category: '运维', roles: ['guest', 'admin', 'owner'] });
+            cmds.push({ command: '/stop', description: '中断当前任务', category: '运维', roles: ['admin', 'owner'] });
+            cmds.push({ command: '/check', description: '检查渠道状态', category: '运维', roles: ['guest', 'admin', 'owner'] });
+            if (isAdmin) {
+                cmds.push({ command: '/activity', args: '[all|dm|owner|none]', description: '查看/控制中间输出显示模式', category: '聊天设置', roles: ['admin', 'owner'] });
+                cmds.push({ command: '/restart', args: '<channel>', description: '重连指定渠道', category: '运维', roles: ['admin', 'owner'] });
+            }
+            if (isOwner) {
+                cmds.push({ command: '/restart', description: '重启服务', category: '运维', roles: ['owner'] });
+                cmds.push({ command: '/file', args: '[channel] <path>', description: '发送项目内文件', category: '工具', roles: ['owner'] });
+                cmds.push({ command: '/aid', args: '[list|show|new|delete|lookup|agentmd]', description: 'AID 身份管理', category: '工具', roles: ['owner'] });
+                cmds.push({ command: '/storage', args: '[upload|download|ls|rm|quota] <aid>', description: '文件存储', category: '工具', roles: ['owner'] });
+            }
+            // 聊天设置
+            if (isAdmin) {
+                cmds.push({ command: '/chatmode', args: '[interactive|proactive]', description: '查看/切换会话模式（被动响应或主动推进）', category: '聊天设置', roles: ['admin', 'owner'] });
+                cmds.push({ command: '/dispatch', args: '[mention|all]', description: '查看/切换群聊分发模式（仅@响应或广播响应）', category: '聊天设置', roles: ['admin', 'owner'] });
+            }
+            // 交互
+            cmds.push({ command: '/ask', args: '<选项>', description: '回答 Agent 的交互式问题', category: '运维', roles: ['guest', 'admin', 'owner'] });
+            // 帮助
+            cmds.push({ command: '/help', description: '显示帮助信息', category: '帮助', roles: ['guest', 'admin', 'owner'] });
+            const categories = [...new Set(cmds.map(c => c.category))];
+            return { kind: 'command.result', text: JSON.stringify({ commands: cmds, categories }) };
         }
         // /perm 命令：权限模式切换 + 权限审批（快速路径，不进入消息队列）
         if (normalizedContent.startsWith('/perm')) {
             const args = normalizedContent.slice(5).trim();
             // 先获取正确的 session 和 agent（话题可能用不同 agent）
-            const permResult = await this.ensureSession(channel, channelId, threadId);
+            const permResult = await this.ensureSession(channel, channelId, threadId, chatType);
             if ('error' in permResult)
-                return permResult.error;
+                return { kind: 'command.result', text: permResult.error };
             const { session: permSession } = permResult;
-            const permAgent = this.getAgent(permSession.agentId);
+            const permAgent = this.getAgent(channel, permSession.agentId);
             // /perm（无参数）：显示当前模式和可选模式
             if (!args) {
                 if (!hasPermissionController(permAgent)) {
-                    return '❌ 权限控制不可用';
+                    return { kind: 'command.error', text: '❌ 权限控制不可用' };
                 }
                 const currentMode = permSession.metadata?.permissionMode ?? DEFAULT_PERMISSION_MODE;
                 const modes = permAgent.listModes();
-                // 尝试发送交互卡片
-                if (this.interactionRouter) {
-                    const requestId = `perm-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`;
+                // 尝试发送 CommandCard 卡片
+                {
                     const availableModes = modes.filter(m => m.available);
                     const interaction = {
                         type: 'interaction',
-                        id: requestId,
+                        id: `perm-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`,
                         channelId,
                         sessionId: permSession.id,
+                        initiatorId: userId,
                         kind: {
-                            kind: 'action',
+                            kind: 'command-card',
                             title: '🔐 权限模式',
                             body: availableModes.map(m => `${m.key === currentMode ? '✓' : '•'} **${m.key}** (${m.nameZh}) - ${m.description}`).join('\n'),
                             buttons: availableModes.map(m => ({
-                                key: m.key,
                                 label: m.key === currentMode ? `✓ ${m.key}` : m.key,
-                                style: m.key === currentMode ? 'primary' : 'default',
+                                command: `/perm ${m.key}`,
+                                style: (m.key === currentMode ? 'primary' : 'default'),
+                                disabled: m.key === currentMode,
                             })),
                         },
                     };
                     const replyCtx = this.getReplyContext(permSession);
-                    const cardSent = await this.sendInteractionCard({
-                        channel, channelId, sessionId: permSession.id, requestId, interaction, replyCtx,
-                        canWrite: isOwner,
-                        callback: async (action, _values, operatorId) => {
-                            if (action !== currentMode) {
-                                if (userId && operatorId && operatorId !== userId)
-                                    return;
-                                const result = await this.handle(`/perm ${action}`, channel, channelId, undefined, userId, threadId);
-                                if (result) {
-                                    const adapter = this.adapters.get(channel);
-                                    adapter?.sendText(channelId, result, replyCtx);
-                                }
-                                else {
-                                    // 切换成功后重新发新卡片（会自动 invalidate 旧卡片）
-                                    await this.handle('/perm', channel, channelId, undefined, userId, threadId);
-                                }
-                            }
-                        },
-                    });
-                    if (cardSent)
+                    const cardResult = await this.sendCommandCard({ channel, channelId, interaction, replyCtx, canWrite: isOwner });
+                    if (cardResult === null)
                         return null;
+                    return { kind: 'command.result', text: cardResult };
                 }
                 // 降级：文本
                 const modeList = modes.map(m => {
@@ -1027,25 +1029,30 @@ export class CommandHandler {
                     return `  ${prefix} ${m.key} (${m.nameZh}) - ${m.description}${suffix}`;
                 }).join('\n');
                 if (isOwner) {
-                    return `🔐 当前权限模式: ${currentMode}\n\n${modeList}\n\n用法:\n  /perm <模式>              切换权限模式\n  /perm allow|always|deny   审批权限请求`;
+                    return { kind: 'command.result', text: `🔐 当前权限模式: ${currentMode}\n\n${modeList}\n\n用法:\n  /perm <模式>              切换权限模式\n  /perm allow|always|deny   审批权限请求` };
                 }
-                return `🔐 当前权限模式: ${currentMode}`;
+                return { kind: 'command.result', text: `🔐 当前权限模式: ${currentMode}` };
             }
             const parts = args.split(/\s+/);
             // /perm <mode> 或 /perm allow|always|deny：切换模式 / 快捷审批
             if (parts.length === 1) {
                 const arg = parts[0];
-                // /perm allow|always|deny：快捷审批（自动找当前 session 唯一的 pending 请求）
+                // /perm allow|always|deny：快捷审批
+                // 优先走 InteractionRouter fallback（统一降级路径）
                 if (arg === 'allow' || arg === 'always' || arg === 'deny') {
+                    const fb = await this.handleInteractionFallback('perm', arg, permSession.id, userId);
+                    if (fb.matched)
+                        return { kind: 'command.result', text: fb.result ?? '✓ 已回答' };
+                    // fallback 不命中：走 permissionGateway 直接审批（兼容旧路径）
                     if (!this.permissionGateway) {
-                        return '❌ 权限审批未启用';
+                        return { kind: 'command.error', text: '❌ 权限审批未启用' };
                     }
                     const pendingIds = this.permissionGateway.getPendingRequests(permSession.id);
                     if (pendingIds.length === 0) {
-                        return '❌ 当前没有待审批的权限请求';
+                        return { kind: 'command.error', text: '❌ 当前没有待审批的权限请求' };
                     }
                     if (pendingIds.length > 1) {
-                        return `❌ 当前有 ${pendingIds.length} 个待审批请求，请指定 requestId：\n${pendingIds.map(id => `  /perm ${id} ${arg}`).join('\n')}`;
+                        return { kind: 'command.error', text: `❌ 当前有 ${pendingIds.length} 个待审批请求，请指定 requestId：\n${pendingIds.map(id => `  /perm ${id} ${arg}`).join('\n')}` };
                     }
                     const requestId = pendingIds[0];
                     const decision = arg;
@@ -1055,7 +1062,7 @@ export class CommandHandler {
                         always: '✓ 已授权（始终允许该工具），继续执行……',
                         deny: '✓ 已拒绝'
                     };
-                    return labels[decision];
+                    return { kind: 'command.result', text: labels[decision] };
                 }
                 // /perm <mode>：切换权限模式
                 if (hasPermissionController(permAgent)) {
@@ -1063,112 +1070,181 @@ export class CommandHandler {
                     const matched = modes.find(m => m.key === arg);
                     if (matched) {
                         if (!matched.available) {
-                            return `❌ ${matched.key} 模式当前不可用：${matched.unavailableReason}`;
+                            return { kind: 'command.error', text: `❌ ${matched.key} 模式当前不可用：${matched.unavailableReason}` };
                         }
                         // guest 和 admin 用户不能切换权限模式（仅 owner）
                         if (!isOwner) {
-                            return '❌ 权限模式切换仅限 owner';
+                            return { kind: 'command.error', text: '❌ 权限模式切换仅限 owner' };
                         }
                         const metadata = permSession.metadata || {};
                         metadata.permissionMode = arg;
                         await this.sessionManager.updateSession(permSession.id, { metadata });
-                        return `✓ 权限模式已切换为: ${matched.key} (${matched.nameZh})\n${matched.description}`;
+                        return { kind: 'command.result', text: `✓ 权限模式已切换为: ${matched.key} (${matched.nameZh})\n${matched.description}` };
                     }
                 }
                 // 不是已知模式名也不是 allow/deny
                 const modeKeys = hasPermissionController(permAgent) ? permAgent.listModes().map(m => m.key).join('|') : 'auto|bypass|request|edit|plan|noask';
-                return `❌ 未知参数: ${arg}\n用法: /perm <${modeKeys}> 或 /perm allow|always|deny`;
+                return { kind: 'command.error', text: `❌ 未知参数: ${arg}\n用法: /perm <${modeKeys}> 或 /perm allow|always|deny` };
             }
             // 双参数不再支持，提示正确用法
             const allModeKeys = hasPermissionController(permAgent) ? permAgent.listModes().map(m => m.key).join('|') : 'auto|bypass|request|edit|plan|noask';
-            return `❌ 未知参数: ${args}\n用法: /perm <${allModeKeys}> 或 /perm allow|always|deny`;
+            return { kind: 'command.error', text: `❌ 未知参数: ${args}\n用法: /perm <${allModeKeys}> 或 /perm allow|always|deny` };
         }
         // /ask 命令：回答 AskUserQuestion / ExitPlanMode 的交互式问题
         if (normalizedContent.startsWith('/ask')) {
             const args = normalizedContent.slice(4).trim();
             if (!args) {
-                // 无参数：列出当前 pending 的交互请求
-                const askResult = await this.ensureSession(channel, channelId, threadId);
+                const askResult = await this.ensureSession(channel, channelId, threadId, chatType);
                 if ('error' in askResult)
-                    return askResult.error;
+                    return { kind: 'command.result', text: askResult.error };
                 const pendingIds = this.interactionRouter?.getPending(askResult.session.id) || [];
                 if (pendingIds.length === 0)
-                    return '当前没有待回答的问题';
-                return `当前有 ${pendingIds.length} 个待回答问题，请回复 /ask <选项>`;
+                    return { kind: 'command.result', text: '当前没有待回答的问题' };
+                return { kind: 'command.result', text: `当前有 ${pendingIds.length} 个待回答问题，请回复 /ask <选项>` };
             }
-            const askResult = await this.ensureSession(channel, channelId, threadId);
+            const askResult = await this.ensureSession(channel, channelId, threadId, chatType);
             if ('error' in askResult)
-                return askResult.error;
-            const { session: askSession } = askResult;
-            const pendingIds = this.interactionRouter?.getPending(askSession.id) || [];
-            if (pendingIds.length === 0)
-                return '❌ 当前没有待回答的问题';
-            // 路由到最早的 pending interaction
-            const targetId = pendingIds[0];
-            this.interactionRouter.handle({ type: 'interaction.response', id: targetId, action: args, operatorId: userId });
-            return `✓ 已回答`;
+                return { kind: 'command.result', text: askResult.error };
+            const fb = await this.handleInteractionFallback('ask', args, askResult.session.id, userId);
+            if (fb.matched)
+                return { kind: 'command.result', text: fb.result ?? '✓ 已回答' };
+            return { kind: 'command.error', text: '❌ 当前没有待回答的问题' };
+        }
+        // /resume 命令：返回当前项目的 Claude 会话记录（JSON）
+        if (normalizedContent === '/resume' || normalizedContent.startsWith('/resume ')) {
+            const resumeResult = await this.ensureSession(channel, channelId, threadId, chatType);
+            if ('error' in resumeResult)
+                return { kind: 'command.result', text: resumeResult.error };
+            const { session: resumeSession } = resumeResult;
+            try {
+                const { encodePath } = await import('../utils/cross-platform.js');
+                const homeDir = os.homedir();
+                const encodedPath = encodePath(resumeSession.projectPath);
+                const projectDir = path.join(homeDir, '.claude', 'projects', encodedPath);
+                if (!fs.existsSync(projectDir)) {
+                    return { kind: 'command.error', text: '❌ 未找到 Claude 会话记录目录' };
+                }
+                const jsonlFiles = fs.readdirSync(projectDir).filter(f => f.endsWith('.jsonl'));
+                if (jsonlFiles.length === 0) {
+                    return { kind: 'command.error', text: '❌ 当前项目没有 Claude 会话记录' };
+                }
+                const sessions = [];
+                for (const file of jsonlFiles) {
+                    const filePath = path.join(projectDir, file);
+                    const sessionId = file.replace('.jsonl', '');
+                    let lastTimestamp = '';
+                    let firstUserMessage = '';
+                    let model = '';
+                    let branch = '';
+                    let turns = 0;
+                    try {
+                        const content = fs.readFileSync(filePath, 'utf-8');
+                        const lines = content.split('\n').filter(l => l.trim());
+                        for (const line of lines) {
+                            const event = JSON.parse(line);
+                            if (event.timestamp && event.timestamp > lastTimestamp) {
+                                lastTimestamp = event.timestamp;
+                            }
+                            if (event.gitBranch && !branch) {
+                                branch = event.gitBranch;
+                            }
+                            if (event.type === 'user' && event.message?.role === 'user') {
+                                const msgContent = event.message.content;
+                                const isToolResult = Array.isArray(msgContent) && msgContent.every((c) => c.type === 'tool_result');
+                                if (!isToolResult) {
+                                    turns++;
+                                    if (!firstUserMessage) {
+                                        if (typeof msgContent === 'string') {
+                                            firstUserMessage = msgContent.slice(0, 100);
+                                        }
+                                        else if (Array.isArray(msgContent)) {
+                                            const textBlock = msgContent.find((c) => c.type === 'text');
+                                            if (textBlock?.text) {
+                                                firstUserMessage = textBlock.text.slice(0, 100);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            if (event.type === 'assistant' && event.message?.model && !model) {
+                                model = event.message.model;
+                            }
+                        }
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (!lastTimestamp)
+                        continue;
+                    sessions.push({
+                        sessionId,
+                        lastMessageTime: lastTimestamp,
+                        firstUserMessage: firstUserMessage || '(无消息)',
+                        model: model || 'unknown',
+                        turns,
+                        branch: branch || 'unknown',
+                    });
+                }
+                sessions.sort((a, b) => b.lastMessageTime.localeCompare(a.lastMessageTime));
+                return { kind: 'command.result', text: JSON.stringify(sessions, null, 2) };
+            }
+            catch (error) {
+                logger.error('[CommandHandler] /resume failed:', error);
+                return { kind: 'command.error', text: `❌ 读取会话记录失败: ${error instanceof Error ? error.message : '未知错误'}` };
+            }
         }
         // /agent 命令：查看或切换 Agent 后端
         if (normalizedContent === '/agent' || normalizedContent.startsWith('/agent ')) {
             const args = normalizedContent.slice(6).trim();
             // 切换（带参）需权限：群聊 owner only，私聊 admin+；无参查询对所有人放开
             if (args && (activeChatType === 'group' ? !isOwner : !isAdmin)) {
-                return '❌ 无权限：此命令仅限管理员使用';
+                return { kind: 'command.error', text: '❌ 无权限：此命令仅限管理员使用' };
             }
-            const available = [...this.agentMap.keys()];
+            const available = this.getAvailableBaseagents(channel);
             if (!args) {
-                const currentAgent = activeSession?.agentId || this.defaultAgentId;
-                // 尝试发送交互卡片
+                // currentAgent: 当前 session 的 baseagent，或该 channel 所属 evolagent 的 baseagent
+                const currentAgent = activeSession?.agentId
+                    || this.agentRegistry?.resolveByChannel(channel)?.baseagent
+                    || this.parseDefaultBaseagent();
+                // 尝试发送 CommandCard 卡片
                 if (this.interactionRouter && available.length > 1) {
-                    const requestId = `agent-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`;
                     const interaction = {
                         type: 'interaction',
-                        id: requestId,
+                        id: `agent-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`,
                         channelId,
-                        sessionId: activeSession?.id || requestId,
+                        sessionId: activeSession?.id || `agent-${Date.now()}`,
+                        initiatorId: userId,
                         kind: {
-                            kind: 'action',
+                            kind: 'command-card',
                             title: '🔌 切换 Agent',
                             buttons: available.map(a => ({
-                                key: a,
                                 label: a === currentAgent ? `✓ ${a}` : a,
-                                style: a === currentAgent ? 'primary' : 'default',
+                                command: `/agent ${a}`,
+                                style: (a === currentAgent ? 'primary' : 'default'),
+                                disabled: a === currentAgent,
                             })),
                         },
                     };
                     const replyCtx = activeSession ? this.getReplyContext(activeSession) : undefined;
-                    const cardSent = await this.sendInteractionCard({
-                        channel, channelId, sessionId: activeSession?.id || requestId, requestId, interaction, replyCtx,
-                        canWrite: activeChatType === 'group' ? isOwner : isAdmin,
-                        callback: async (action, _values, operatorId) => {
-                            if (action !== currentAgent) {
-                                if (userId && operatorId && operatorId !== userId)
-                                    return;
-                                const result = await this.handle(`/agent ${action}`, channel, channelId, undefined, userId, threadId);
-                                if (result) {
-                                    const adapter = this.adapters.get(channel);
-                                    adapter?.sendText(channelId, result, replyCtx);
-                                }
-                            }
-                        },
-                    });
-                    if (cardSent)
+                    const cardResult = await this.sendCommandCard({ channel, channelId, interaction, replyCtx, canWrite: activeChatType === 'group' ? isOwner : isAdmin });
+                    if (cardResult === null)
                         return null;
+                    return { kind: 'command.result', text: cardResult };
                 }
                 // 降级：文本
                 const list = available.map(a => `${a === currentAgent ? ' ✓' : '  '} ${a}`).join('\n');
                 const canSwitchAgent = activeChatType === 'group' ? isOwner : isAdmin;
                 if (canSwitchAgent) {
-                    return `当前 Agent: ${currentAgent}\n\n可用:\n${list}\n\n用法: /agent <name>`;
+                    return { kind: 'command.result', text: `当前 Agent: ${currentAgent}\n\n可用:\n${list}\n\n用法: /agent <name>` };
                 }
-                return `当前 Agent: ${currentAgent}`;
+                return { kind: 'command.result', text: `当前 Agent: ${currentAgent}` };
             }
-            if (!this.agentMap.has(args)) {
-                return `❌ 未知 Agent: ${args}\n可用: ${available.join(', ')}`;
+            if (!available.includes(args)) {
+                return { kind: 'command.error', text: `❌ 未知 Agent: ${args}\n可用: ${available.join(', ')}` };
             }
-            const result = await this.ensureSession(channel, channelId, threadId);
+            const result = await this.ensureSession(channel, channelId, threadId, chatType);
             if ('error' in result)
-                return result.error;
+                return { kind: 'command.error', text: result.error };
             const { session } = result;
             // 取消原会话的 pending 权限请求和交互卡片
             if (this.permissionGateway) {
@@ -1182,58 +1258,114 @@ export class CommandHandler {
             const hasExistingSession = newSession.agentSessionId ? '（恢复已有会话）' : '（新建会话）';
             const projectName = this.getProjectName(session.projectPath);
             let agentSwitchResponse = `✓ 已切换 Agent: ${args}\n  项目: ${projectName}\n  会话: ${newSession.name || '(未命名)'}\n  ${hasExistingSession}`;
-            return agentSwitchResponse;
+            return { kind: 'command.result', text: agentSwitchResponse };
+        }
+        // /setmodel 命令：返回 JSON 格式的模型列表（供程序解析）
+        if (normalizedContent === '/setmodel' || normalizedContent.startsWith('/setmodel ')) {
+            const setmodelResult = await this.ensureSession(channel, channelId, threadId, chatType);
+            if ('error' in setmodelResult)
+                return { kind: 'command.result', text: setmodelResult.error };
+            const { session: setmodelSession } = setmodelResult;
+            const setmodelAgent = this.getAgent(channel, setmodelSession.agentId);
+            const currentModel = hasModelSwitcher(setmodelAgent) ? setmodelAgent.getModel() : setmodelAgent.name;
+            const efforts = getAvailableEfforts(setmodelAgent, currentModel);
+            const currentEffort = setmodelAgent.getEffort?.() || 'auto';
+            // 获取 API URL 用于请求 /models
+            let apiBaseUrl;
+            try {
+                const configBaseUrl = this.getOwningAgent(channel)?.config?.baseagents?.claude?.baseUrl;
+                const isPlaceholderUrl = configBaseUrl?.includes('api.anthropic.com');
+                if (configBaseUrl && !isPlaceholderUrl) {
+                    apiBaseUrl = configBaseUrl;
+                }
+                else if (process.env.ANTHROPIC_BASE_URL) {
+                    apiBaseUrl = process.env.ANTHROPIC_BASE_URL;
+                }
+                else {
+                    const claudeSettingsPath = path.join(os.homedir(), '.claude', 'settings.json');
+                    if (fs.existsSync(claudeSettingsPath)) {
+                        const claudeSettings = JSON.parse(fs.readFileSync(claudeSettingsPath, 'utf-8'));
+                        if (claudeSettings.env?.ANTHROPIC_BASE_URL) {
+                            apiBaseUrl = claudeSettings.env.ANTHROPIC_BASE_URL;
+                        }
+                    }
+                }
+            }
+            catch { }
+            let modelListData = null;
+            if (apiBaseUrl) {
+                try {
+                    const modelsUrl = apiBaseUrl.replace(/\/+$/, '') + '/v1/models';
+                    const controller = new AbortController();
+                    const timeout = setTimeout(() => controller.abort(), 5000);
+                    const resp = await fetch(modelsUrl, {
+                        signal: controller.signal,
+                        headers: { 'Authorization': `Bearer ${this.getOwningAgent(channel)?.config?.baseagents?.claude?.apiKey || process.env.ANTHROPIC_AUTH_TOKEN || ''}` },
+                    });
+                    clearTimeout(timeout);
+                    if (resp.ok) {
+                        modelListData = await resp.json();
+                    }
+                }
+                catch { }
+            }
+            // 兜底模型列表
+            if (!modelListData || !modelListData.data || modelListData.data.length === 0) {
+                const now = Math.floor(Date.now() / 1000);
+                modelListData = {
+                    object: 'list',
+                    data: [
+                        { id: 'claude-opus-4-7', object: 'model', created: now, owned_by: 'anthropic' },
+                        { id: 'claude-opus-4-6', object: 'model', created: now, owned_by: 'anthropic' },
+                        { id: 'claude-sonnet-4-6', object: 'model', created: now, owned_by: 'anthropic' },
+                    ],
+                };
+            }
+            return { kind: 'command.result', text: JSON.stringify({
+                    current_model: currentModel,
+                    current_effort: currentEffort,
+                    available_efforts: efforts,
+                    models: modelListData,
+                }, null, 2) };
         }
         // /model 命令：查看或切换模型/推理强度
         if (normalizedContent.startsWith('/model')) {
             const args = normalizedContent.slice(6).trim();
             // 获取当前会话（话题会话可能绑定不同 agent）
-            const modelResult = await this.ensureSession(channel, channelId, threadId);
+            const modelResult = await this.ensureSession(channel, channelId, threadId, chatType);
             if ('error' in modelResult)
-                return modelResult.error;
+                return { kind: 'command.result', text: modelResult.error };
             const { session: modelSession } = modelResult;
-            const modelAgent = this.getAgent(modelSession.agentId);
+            const modelAgent = this.getAgent(channel, modelSession.agentId);
             const models = hasModelSwitcher(modelAgent) ? modelAgent.listModels() : [];
             if (!args) {
                 const currentModel = hasModelSwitcher(modelAgent) ? modelAgent.getModel() : modelAgent.name;
                 const efforts = getAvailableEfforts(modelAgent, currentModel);
                 const currentEffort = modelAgent.getEffort?.() || 'auto';
-                // 尝试发送交互卡片
+                // 尝试发送 CommandCard 卡片
                 if (this.interactionRouter && models.length > 0) {
-                    const requestId = `model-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`;
                     const interaction = {
                         type: 'interaction',
-                        id: requestId,
+                        id: `model-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`,
                         channelId,
                         sessionId: modelSession.id,
+                        initiatorId: userId,
                         kind: {
-                            kind: 'action',
+                            kind: 'command-card',
                             title: '🤖 切换模型',
                             buttons: models.map((m) => ({
-                                key: m,
                                 label: m === currentModel ? `✓ ${m}` : m,
-                                style: m === currentModel ? 'primary' : 'default',
+                                command: `/model ${m}`,
+                                style: (m === currentModel ? 'primary' : 'default'),
+                                disabled: m === currentModel,
                             })),
                         },
                     };
                     const replyCtx = this.getReplyContext(modelSession);
-                    const cardSent = await this.sendInteractionCard({
-                        channel, channelId, sessionId: modelSession.id, requestId, interaction, replyCtx,
-                        canWrite: isAdmin,
-                        callback: async (action, _values, operatorId) => {
-                            if (action !== currentModel) {
-                                if (userId && operatorId && operatorId !== userId)
-                                    return;
-                                const result = await this.handle(`/model ${action}`, channel, channelId, undefined, userId, threadId);
-                                if (result) {
-                                    const adapter = this.adapters.get(channel);
-                                    adapter?.sendText(channelId, result, replyCtx);
-                                }
-                            }
-                        },
-                    });
-                    if (cardSent)
+                    const cardResult = await this.sendCommandCard({ channel, channelId, interaction, replyCtx, canWrite: isAdmin });
+                    if (cardResult === null)
                         return null;
+                    return { kind: 'command.result', text: cardResult };
                 }
                 // 降级：文本
                 const modelList = models.map((m) => `  ${m === currentModel ? '✓' : ' '} ${m}`).join('\n');
@@ -1241,13 +1373,13 @@ export class CommandHandler {
                     ? `\n推理强度: ${currentEffort === 'auto' ? 'auto (SDK默认)' : currentEffort}  (使用 /effort 调整)`
                     : '';
                 if (isAdmin) {
-                    return `当前模型: ${currentModel}${effortHint}\n\n可用模型：\n${modelList}\n\n${formatModelUsage(modelAgent, currentModel)}`;
+                    return { kind: 'command.result', text: `当前模型: ${currentModel}${effortHint}\n\n可用模型：\n${modelList}\n\n${formatModelUsage(modelAgent, currentModel)}` };
                 }
-                return `当前模型: ${currentModel}${effortHint}`;
+                return { kind: 'command.result', text: `当前模型: ${currentModel}${effortHint}` };
             }
             // 带参（切换/调整）需 admin+；无参查询已在上方返回
             if (!isAdmin)
-                return '❌ 无权限：切换模型仅限管理员使用';
+                return { kind: 'command.error', text: '❌ 无权限：切换模型仅限管理员使用' };
             const parts = args.split(/\s+/);
             let newModel;
             let newEffort;
@@ -1257,10 +1389,11 @@ export class CommandHandler {
                 const efforts = getAvailableEfforts(modelAgent, currentModel);
                 // effort 相关参数统一转发到 /effort
                 if (efforts.includes(arg) || arg === 'auto') {
-                    return this.handle(`/effort ${arg}`, channel, channelId, undefined, userId, threadId);
+                    const delegated = await this.handle(`/effort ${arg}`, channel, channelId, undefined, userId, threadId);
+                    return typeof delegated === 'string' ? { kind: 'command.result', text: delegated } : delegated;
                 }
                 else if (allEfforts.includes(arg)) {
-                    return `⚠️ 请使用 /effort ${arg} 调整推理强度`;
+                    return { kind: 'command.error', text: `⚠️ 请使用 /effort ${arg} 调整推理强度` };
                 }
                 else if (models.includes(arg)) {
                     newModel = arg;
@@ -1268,34 +1401,33 @@ export class CommandHandler {
                 else {
                     const modelList = models.map((m) => `  ${m === currentModel ? '✓' : ' '} ${m}`).join('\n');
                     const effortHint = efforts.length > 0 ? `\n\n推理强度请使用 /effort 命令` : '';
-                    return `❌ 无效参数: ${arg}\n\n可用模型：\n${modelList}${effortHint}`;
+                    return { kind: 'command.error', text: `❌ 无效参数: ${arg}\n\n可用模型：\n${modelList}${effortHint}` };
                 }
             }
             else {
                 // 双参数：model effort
                 const [modelArg, effortArg] = parts;
                 if (!models.includes(modelArg)) {
-                    return `❌ 无效的模型ID: ${modelArg}`;
+                    return { kind: 'command.error', text: `❌ 无效的模型ID: ${modelArg}` };
                 }
                 const targetEfforts = getAvailableEfforts(modelAgent, modelArg);
                 if (targetEfforts.length === 0) {
-                    return `⚠️ ${modelArg} 不支持推理强度设置`;
+                    return { kind: 'command.error', text: `⚠️ ${modelArg} 不支持推理强度设置` };
                 }
                 if (!targetEfforts.includes(effortArg)) {
                     const errorLabel = allEfforts.includes(effortArg) ? '⚠️' : '❌';
-                    return `${errorLabel} ${modelArg} 不支持 ${effortArg} 推理强度\n可选: ${targetEfforts.join(' / ')}`;
+                    return { kind: 'command.result', text: `${errorLabel} ${modelArg} 不支持 ${effortArg} 推理强度\n可选: ${targetEfforts.join(' / ')}` };
                 }
                 newModel = modelArg;
                 newEffort = effortArg;
             }
-            if (!this.config.agents)
-                this.config.agents = {};
+            // 运行时 model/effort 切换已通过 EvolAgent.setBaseagentModel/setBaseagentEffort 持久化
             const isCodexAgent = modelAgent.name === 'codex';
             const changes = [];
             if (newModel) {
                 modelAgent.setModel?.(newModel);
                 this.eventBus.publish({
-                    type: 'agent:model-changed',
+                    type: 'runner:model-changed',
                     sessionId: modelSession.id,
                     model: newModel,
                     timestamp: Date.now()
@@ -1310,231 +1442,160 @@ export class CommandHandler {
             if (newModel) {
                 const err = this.persistBaseagentModel(channel, modelAgent.name, newModel);
                 if (err)
-                    return `${err}\n已更新运行时配置，但未持久化`;
+                    return { kind: 'command.result', text: `${err}\n已更新运行时配置，但未持久化` };
             }
             if (newEffort) {
                 const err = this.persistBaseagentEffort(channel, modelAgent.name, newEffort);
                 if (err)
-                    return `${err}\n已更新运行时配置，但未持久化`;
+                    return { kind: 'command.result', text: `${err}\n已更新运行时配置，但未持久化` };
             }
-            return `✓ 已切换\n  ${changes.join('\n  ')}`;
+            return { kind: 'command.result', text: `✓ 已切换\n  ${changes.join('\n  ')}` };
         }
         // /effort 命令：查看或切换推理强度
         if (normalizedContent.startsWith('/effort')) {
             const args = normalizedContent.slice(7).trim();
-            const effortResult = await this.ensureSession(channel, channelId, threadId);
+            const effortResult = await this.ensureSession(channel, channelId, threadId, chatType);
             if ('error' in effortResult)
-                return effortResult.error;
+                return { kind: 'command.result', text: effortResult.error };
             const { session: effortSession } = effortResult;
-            const effortAgent = this.getAgent(effortSession.agentId);
+            const effortAgent = this.getAgent(channel, effortSession.agentId);
             const currentModel = hasModelSwitcher(effortAgent) ? effortAgent.getModel() : effortAgent.name;
             const efforts = getAvailableEfforts(effortAgent, currentModel);
             const currentEffort = effortAgent.getEffort?.() || 'auto';
             if (efforts.length === 0) {
-                return '⚠️ 当前模型不支持推理强度设置';
+                return { kind: 'command.error', text: '⚠️ 当前模型不支持推理强度设置' };
             }
             if (!args) {
-                // /effort（无参数）：显示当前推理强度 + 发送 Action 卡片
+                // /effort（无参数）：显示当前推理强度 + 发送 CommandCard 卡片
                 if (this.interactionRouter) {
-                    const requestId = `effort-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`;
-                    const buttons = [
-                        ...efforts.map(e => ({
-                            key: e,
-                            label: e === currentEffort ? `✓ ${e}` : e,
-                            style: e === currentEffort ? 'primary' : 'default',
-                        })),
-                        {
-                            key: 'auto',
-                            label: currentEffort === 'auto' ? '✓ auto' : 'auto',
-                            style: currentEffort === 'auto' ? 'primary' : 'default',
-                        },
-                    ];
+                    const allItems = [...efforts, 'auto'];
                     const interaction = {
                         type: 'interaction',
-                        id: requestId,
+                        id: `effort-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`,
                         channelId,
                         sessionId: effortSession.id,
+                        initiatorId: userId,
                         kind: {
-                            kind: 'action',
+                            kind: 'command-card',
                             title: '⚡ 推理强度',
-                            buttons,
+                            buttons: allItems.map(e => ({
+                                label: e === currentEffort ? `✓ ${e}` : e,
+                                command: `/effort ${e}`,
+                                style: (e === currentEffort ? 'primary' : 'default'),
+                                disabled: e === currentEffort,
+                            })),
                         },
                     };
                     const replyCtx = this.getReplyContext(effortSession);
-                    const cardSent = await this.sendInteractionCard({
-                        channel, channelId, sessionId: effortSession.id, requestId, interaction, replyCtx,
-                        canWrite: isAdmin,
-                        callback: async (action, _values, operatorId) => {
-                            if (action !== currentEffort) {
-                                if (userId && operatorId && operatorId !== userId)
-                                    return;
-                                const result = await this.handle(`/effort ${action}`, channel, channelId, undefined, userId, threadId);
-                                if (result) {
-                                    const adapter = this.adapters.get(channel);
-                                    adapter?.sendText(channelId, result, replyCtx);
-                                }
-                            }
-                        },
-                    });
-                    if (cardSent)
+                    const cardResult = await this.sendCommandCard({ channel, channelId, interaction, replyCtx, canWrite: isAdmin });
+                    if (cardResult === null)
                         return null;
+                    return { kind: 'command.result', text: cardResult };
                 }
                 // 降级：文本
                 const effortDisplay = currentEffort === 'auto' ? 'auto (SDK默认)' : currentEffort;
                 const allItems = [...efforts, 'auto'];
                 const effortList = allItems.map(e => `  ${e === currentEffort ? '✓' : ' '} ${e}${e === 'auto' ? ' (SDK默认)' : ''}`).join('\n');
                 if (isAdmin) {
-                    return `⚡ 推理强度: ${effortDisplay}\n\n可选:\n${effortList}\n\n用法: /effort <level>`;
+                    return { kind: 'command.result', text: `⚡ 推理强度: ${effortDisplay}\n\n可选:\n${effortList}\n\n用法: /effort <level>` };
                 }
-                return `⚡ 推理强度: ${effortDisplay}`;
+                return { kind: 'command.result', text: `⚡ 推理强度: ${effortDisplay}` };
             }
             // 带参（切换）需 admin+；无参查询已在上方返回
             if (!isAdmin)
-                return '❌ 无权限：切换推理强度仅限管理员使用';
+                return { kind: 'command.error', text: '❌ 无权限：切换推理强度仅限管理员使用' };
             // /effort auto：恢复 SDK 默认
             if (args === 'auto') {
                 effortAgent.setEffort?.(undefined);
                 const err = this.persistBaseagentEffort(channel, effortAgent.name, undefined);
                 if (err)
-                    return `${err}\n已更新运行时配置，但未持久化`;
-                return '✓ 推理强度已恢复为 auto (SDK默认)';
+                    return { kind: 'command.result', text: `${err}\n已更新运行时配置，但未持久化` };
+                return { kind: 'command.result', text: '✓ 推理强度已恢复为 auto (SDK默认)' };
             }
             // /effort <level>：切换推理强度
             if (!efforts.includes(args)) {
                 if (allEfforts.includes(args)) {
-                    return `⚠️ ${currentModel} 不支持 ${args} 推理强度\n可选: ${efforts.join(' / ')}`;
+                    return { kind: 'command.error', text: `⚠️ ${currentModel} 不支持 ${args} 推理强度\n可选: ${efforts.join(' / ')}` };
                 }
-                return `❌ 无效参数: ${args}\n可选: ${efforts.join(' / ')} / auto`;
+                return { kind: 'command.error', text: `❌ 无效参数: ${args}\n可选: ${efforts.join(' / ')} / auto` };
             }
             const newEffort = args;
             effortAgent.setEffort?.(newEffort);
             const err = this.persistBaseagentEffort(channel, effortAgent.name, newEffort);
             if (err)
-                return `${err}\n已更新运行时配置，但未持久化`;
-            return `✓ 推理强度: ${newEffort}`;
+                return { kind: 'command.result', text: `${err}\n已更新运行时配置，但未持久化` };
+            return { kind: 'command.result', text: `✓ 推理强度: ${newEffort}` };
         }
-        // /aid 命令：AID 身份管理（list / new）
-        if (normalizedContent === '/aid' || normalizedContent === '/aid list' || normalizedContent.startsWith('/aid ')) {
+        // /aid, /rpc, /storage — 转发到 CLI 执行
+        if (normalizedContent === '/aid' || normalizedContent.startsWith('/aid ') ||
+            normalizedContent === '/rpc' || normalizedContent.startsWith('/rpc ') ||
+            normalizedContent === '/storage' || normalizedContent.startsWith('/storage ')) {
             if (!isOwner)
-                return '❌ 无权限：此命令仅限 owner 使用';
-            const arg = normalizedContent.slice(4).trim();
-            const { aidList, aidCreate, agentmdPut, buildInitialAgentMd, isValidAid } = await import('../channels/aun-ops.js');
-            // /aid 或 /aid list — 列出本地所有 AID
-            if (!arg || arg === 'list') {
-                const aids = aidList();
-                if (aids.length === 0)
-                    return '本地无 AID';
-                const lines = ['本地 AID:'];
-                for (const a of aids) {
-                    const icons = [
-                        a.hasPrivateKey ? '🔑' : '  ',
-                        a.hasAgentMd ? '📄' : '  ',
-                    ].join('');
-                    lines.push(`  ${icons} ${a.aid}`);
-                }
-                lines.push('\n🔑=私钥  📄=agent.md');
-                return lines.join('\n');
-            }
-            // /aid new <aid> — 创建 AID（纯身份，不动 config）
-            if (arg.startsWith('new ')) {
-                const rawAid = arg.slice(4).trim();
-                if (!rawAid)
-                    return '用法: /aid new <完整AID>\n例: /aid new reviewer.agentid.pub';
-                if (!isValidAid(rawAid))
-                    return `❌ 无效 AID 格式: ${rawAid}`;
-                try {
-                    const result = await aidCreate(rawAid);
-                    if (!result.alreadyExisted) {
-                        const content = buildInitialAgentMd({ aid: rawAid });
-                        try {
-                            await agentmdPut(content, { aid: rawAid, client: result.client });
-                        }
-                        catch { /* non-fatal */ }
-                    }
-                    try {
-                        await result.client.close();
-                    }
-                    catch { /* ignore */ }
-                    const verb = result.alreadyExisted ? '已存在' : '已创建';
-                    return `✓ ${rawAid} ${verb}
-  如需上线 AUN 通道，运行 evolclaw init aun`;
-                }
-                catch (e) {
-                    return `❌ 创建失败: ${String(e.message || e).slice(0, 200)}`;
-                }
-            }
-            return '用法: /aid [list|new <aid>]';
-        }
-        // /agentmd 命令：管理 agent.md 身份文件
-        if (normalizedContent === '/agentmd' || normalizedContent.startsWith('/agentmd ')) {
-            if (!isOwner)
-                return '❌ 无权限：此命令仅限 owner 使用';
-            const adapter = this.adapters.get(channel);
-            if (!adapter?.uploadAgentMd)
-                return '❌ 当前通道不支持 agent.md 操作';
-            const selfAid = typeof adapter._selfAid === 'function' ? adapter._selfAid() : '';
-            const arg = normalizedContent.slice(9).trim();
-            const { agentmdGet, agentmdPut } = await import('../channels/aun-ops.js');
-            // put — read local agent.md and upload to network
-            if (arg === 'put') {
-                if (!selfAid)
-                    return '❌ 未连接，无法确定本地 AID';
-                try {
-                    const { readFileSync } = await import('node:fs');
-                    const { join } = await import('node:path');
-                    const { homedir } = await import('node:os');
-                    const localPath = join(homedir(), '.aun', 'AIDs', selfAid, 'agent.md');
-                    if (!readFileSync)
-                        return '❌ 读取失败';
-                    const content = readFileSync(localPath, 'utf-8');
-                    await agentmdPut(content, { aid: selfAid });
-                    return '✅ agent.md 已发布';
-                }
-                catch (e) {
-                    return `❌ 发布失败: ${String(e.message || e).slice(0, 100)}`;
-                }
-            }
-            // set <content> — upload inline content
-            if (arg.startsWith('set ')) {
-                const content = arg.slice(4).trim();
-                if (!content)
-                    return '用法：/agentmd set <内容>';
-                if (!selfAid)
-                    return '❌ 未连接，无法确定本地 AID';
-                try {
-                    await agentmdPut(content, { aid: selfAid });
-                    return '✅ agent.md 已更新并发布到AUN网络';
-                }
-                catch (e) {
-                    return `❌ 发布失败: ${String(e.message || e).slice(0, 100)}`;
-                }
+                return { kind: 'command.error', text: '❌ 无权限：此命令仅限 owner 使用' };
+            // 无参数时返回用法说明
+            if (normalizedContent === '/aid') {
+                return { kind: 'command.result', text: `🆔 AID 身份管理
+
+用法:
+  /aid list              列出本地所有 AID
+  /aid show <aid>        查看 AID 详情
+  /aid new <aid>         创建新 AID
+  /aid delete <aid>      删除本地 AID
+  /aid lookup <aid>      远程探测 AID
+  /aid agentmd put <aid> 签名并上传 agent.md
+  /aid agentmd get <aid> 下载并验签 agent.md` };
+            }
+            if (normalizedContent === '/rpc') {
+                return { kind: 'command.result', text: `📡 AUN RPC 调用
+
+用法:
+  /rpc --as <aid> --params <json>
+
+参数格式:
+  单行 JSON    单次调用
+  多行 JSONL   逐行执行，失败即停
+
+示例:
+  /rpc --as myaid.agentid.pub --params {"method":"meta.ping","params":{}}` };
             }
-            // view — /agentmd or /agentmd <aid>
-            const aidToView = arg || selfAid;
-            if (!aidToView)
-                return '用法：/agentmd [<aid>] | put | set <内容>';
+            if (normalizedContent === '/storage') {
+                return { kind: 'command.result', text: `📦 文件存储
+
+用法:
+  /storage upload <aid> <file> <path> [--public]   上传文件
+  /storage download <aid> <url> [local-path]       下载文件
+  /storage ls <aid> [prefix]                       列文件
+  /storage rm <aid> <path>                         删文件
+  /storage quota <aid>                             查配额` };
+            }
+            const cliArgs = normalizedContent.slice(1); // strip leading /
             try {
-                const md = await agentmdGet(aidToView);
-                if (!md || !md.trim())
-                    return `ℹ️ ${aidToView} 尚未设置 agent.md`;
-                return `\`\`\`\n${md.slice(0, 1500)}\n\`\`\``;
+                const { execFile } = await import('node:child_process');
+                const { promisify } = await import('node:util');
+                const execFileAsync = promisify(execFile);
+                const { stdout, stderr } = await execFileAsync('evolclaw', cliArgs.split(/\s+/), {
+                    timeout: 30000,
+                    encoding: 'utf-8',
+                    env: { ...process.env, AUN_LOG_INI_DISABLE: '1' },
+                });
+                const output = (stdout || '').trim();
+                if (!output && stderr)
+                    return { kind: 'command.result', text: `⚠ ${stderr.trim().slice(0, 500)}` };
+                return { kind: 'command.result', text: output || '(无输出)' };
             }
             catch (e) {
-                const msg = String(e.message || e);
-                if (msg.includes('not found') || msg.includes('404')) {
-                    return `ℹ️ ${aidToView} 尚未设置 agent.md`;
-                }
-                return `❌ 获取失败: ${msg.slice(0, 100)}`;
+                const msg = e.stderr?.trim() || e.stdout?.trim() || String(e.message || e);
+                return { kind: 'command.error', text: `❌ ${msg.slice(0, 500)}` };
             }
         }
         if (normalizedContent === '/activity' || normalizedContent.startsWith('/activity ')) {
             const activityArg = normalizedContent.slice(9).trim();
             // 带参（写操作）需 admin+；无参查询对所有人开放（owner 门在具体切换点还有一道）
             if (activityArg && !isAdmin)
-                return '❌ 无权限：此命令仅限管理员使用';
+                return { kind: 'command.error', text: '❌ 无权限：此命令仅限管理员使用' };
             // proactive 模式下流式输出全部静默，activity 配置无意义
             if (activeSession?.sessionMode === 'proactive') {
-                return '❌ 当前会话为 proactive 模式，不支持 activity 配置（流式输出已全部静默）';
+                return { kind: 'command.error', text: '❌ 当前会话为 proactive 模式，不支持 activity 配置（流式输出已全部静默）' };
             }
             const modeMap = {
                 all: 'all',
@@ -1542,7 +1603,7 @@ export class CommandHandler {
                 owner: 'owner-dm-only',
                 none: 'none',
             };
-            const currentMode = this.agentRegistry?.getShowActivities?.(channel) ?? getChannelShowActivities(this.config, channel);
+            const currentMode = this.agentRegistry?.getShowActivities?.(channel) ?? 'all';
             // 模式描述列表（用于 body 和文本降级）
             const modeDescriptions = [
                 { key: 'all', configVal: 'all', label: '全部显示' },
@@ -1551,153 +1612,252 @@ export class CommandHandler {
                 { key: 'none', configVal: 'none', label: '全部静默' },
             ];
             if (!activityArg) {
-                // 无参数：显示当前模式 + Action 卡片
-                if (this.interactionRouter) {
-                    const requestId = `activity-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`;
-                    const body = modeDescriptions.map(m => `${m.configVal === currentMode ? '✓' : '•'} **${m.key}** (${m.label})`).join('\n');
-                    const buttons = modeDescriptions.map(m => ({
-                        key: m.key,
-                        label: m.configVal === currentMode ? `✓ ${m.key}` : m.key,
-                        style: m.configVal === currentMode ? 'primary' : 'default',
-                    }));
+                // 尝试发送 CommandCard 卡片
+                {
                     const interaction = {
                         type: 'interaction',
-                        id: requestId,
+                        id: `activity-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`,
                         channelId,
-                        sessionId: activeSession?.id || requestId,
+                        sessionId: activeSession?.id || '',
+                        initiatorId: userId,
                         kind: {
-                            kind: 'action',
+                            kind: 'command-card',
                             title: '📋 中间输出模式',
-                            body,
-                            buttons,
+                            body: modeDescriptions.map(m => `${m.configVal === currentMode ? '✓' : '•'} **${m.key}** (${m.label})`).join('\n'),
+                            buttons: modeDescriptions.map(m => ({
+                                label: m.configVal === currentMode ? `✓ ${m.key}` : m.key,
+                                command: `/activity ${m.key}`,
+                                style: (m.configVal === currentMode ? 'primary' : 'default'),
+                                disabled: m.configVal === currentMode,
+                            })),
                         },
                     };
                     const replyCtx = activeSession ? this.getReplyContext(activeSession) : undefined;
-                    const cardSent = await this.sendInteractionCard({
-                        channel, channelId, sessionId: activeSession?.id || requestId, requestId, interaction, replyCtx,
-                        canWrite: isOwner,
-                        callback: async (action, _values, operatorId) => {
-                            const newMode = modeMap[action];
-                            if (newMode && newMode !== currentMode) {
-                                if (userId && operatorId && operatorId !== userId)
-                                    return;
-                                const result = await this.handle(`/activity ${action}`, channel, channelId, undefined, userId, threadId);
-                                if (result) {
-                                    const adapter = this.adapters.get(channel);
-                                    adapter?.sendText(channelId, result, replyCtx);
-                                }
-                            }
-                        },
-                    });
-                    if (cardSent)
+                    const cardResult = await this.sendCommandCard({ channel, channelId, interaction, replyCtx, canWrite: isOwner });
+                    if (cardResult === null)
                         return null;
+                    // 卡片降级：fall through 到下方文本输出
                 }
                 // 降级：文本
                 const modeList = modeDescriptions.map(m => {
-                    const prefix = m.configVal === currentMode ? '✓' : ' ';
-                    return `  ${prefix} ${m.key} (${m.label})`;
+                    const prefix = m.configVal === currentMode ? '✓' : '•';
+                    return `  ${prefix} ${m.key} — ${m.label}`;
                 }).join('\n');
                 if (isOwner) {
-                    return `📋 中间输出模式: ${currentMode}\n\n${modeList}\n\n用法:\n  /activity <模式>    切换中间输出显示模式`;
+                    return { kind: 'command.result', text: [`📋 中间输出模式: ${currentMode}`, '', modeList, '', '用法: /activity <all|dm|owner|none>'].join('\n') };
                 }
-                return `📋 中间输出模式: ${currentMode}`;
+                return { kind: 'command.result', text: `📋 中间输出模式: ${currentMode}` };
             }
             const newMode = modeMap[activityArg];
             if (!newMode) {
-                return `❌ 无效参数: ${activityArg}\n可选: all / dm / owner / none`;
+                return { kind: 'command.error', text: `❌ 无效参数: ${activityArg}\n可选: all / dm / owner / none` };
             }
             const label = modeDescriptions.find(m => m.configVal === newMode)?.label || newMode;
             if (newMode === currentMode) {
-                return `📋 中间输出模式已是 ${activityArg}（${label}）`;
+                return { kind: 'command.result', text: `📋 中间输出模式已是 ${activityArg}（${label}）` };
             }
             // 切换操作仅 owner
             if (!isOwner)
-                return '❌ 中间输出模式切换仅限 owner';
+                return { kind: 'command.error', text: '❌ 中间输出模式切换仅限 owner' };
             if (this.agentRegistry?.setShowActivities) {
                 this.agentRegistry.setShowActivities(channel, newMode);
             }
             else {
-                setChannelShowActivities(this.config, channel, newMode);
+                return { kind: 'command.error', text: `⚠️ 找不到通道 "${channel}" 所属的 self-agent，无法持久化` };
             }
-            return `✅ 中间输出模式: ${activityArg}（${label}）`;
+            return { kind: 'command.result', text: `✅ 中间输出模式: ${activityArg}（${label}）` };
         }
         // /chatmode 命令：查看/切换 session 会话模式（interactive | proactive）
         // - 查看：所有人可用
         // - 设置：单聊任何角色可设置；群聊仅管理员可设置
         if (normalizedContent === '/chatmode' || normalizedContent.startsWith('/chatmode ')) {
-            if (!activeSession)
-                return '❌ 当前无活跃会话';
+            const chatmodeResult = await this.ensureSession(channel, channelId, threadId, chatType);
+            if ('error' in chatmodeResult)
+                return { kind: 'command.result', text: chatmodeResult.error };
+            const chatmodeSession = chatmodeResult.session;
             const arg = normalizedContent.slice(9).trim();
-            const currentMode = activeSession.sessionMode || 'interactive';
+            const currentMode = chatmodeSession.sessionMode || 'interactive';
+            const chatmodeChatType = chatmodeSession.chatType || activeChatType;
+            const canSwitch = chatmodeChatType !== 'group' || isAdmin;
             if (!arg) {
-                const canSwitch = activeChatType !== 'group' || isAdmin;
+                // 尝试发送 CommandCard 卡片
                 if (canSwitch) {
-                    return `📋 当前会话模式: ${currentMode}\n可选: interactive / proactive\n用法: /chatmode <模式>`;
+                    const modes = [
+                        { key: 'interactive', name: '交互模式', desc: '被动响应：收到消息时才回复，回复直接显示' },
+                        { key: 'proactive', name: '主动模式', desc: '主动推进：流式输出静默，由 Agent 自调 ctl send 发声' },
+                    ];
+                    const interaction = {
+                        type: 'interaction',
+                        id: `chatmode-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`,
+                        channelId,
+                        sessionId: chatmodeSession.id,
+                        initiatorId: userId,
+                        kind: {
+                            kind: 'command-card',
+                            title: '🔄 会话模式',
+                            body: modes.map(m => `${m.key === currentMode ? '✓' : '•'} **${m.key}** (${m.name}) - ${m.desc}`).join('\n'),
+                            buttons: modes.map(m => ({
+                                label: m.key === currentMode ? `✓ ${m.key}` : m.key,
+                                command: `/chatmode ${m.key}`,
+                                style: (m.key === currentMode ? 'primary' : 'default'),
+                                disabled: m.key === currentMode,
+                            })),
+                        },
+                    };
+                    const replyCtx = this.getReplyContext(chatmodeSession);
+                    const cardResult = await this.sendCommandCard({ channel, channelId, interaction, replyCtx, canWrite: isAdmin });
+                    if (cardResult === null)
+                        return null;
+                    // 卡片降级：fall through 到下方文本输出
                 }
-                return `📋 当前会话模式: ${currentMode}`;
+                // 降级：文本
+                if (canSwitch) {
+                    return { kind: 'command.result', text: [
+                            `📋 会话模式: ${currentMode}`,
+                            '',
+                            '模式说明：',
+                            '  • interactive — 交互模式：收到消息时才回复，回复直接显示',
+                            '  • proactive   — 主动模式：流式输出静默，由 Agent 自调 ctl send 发声',
+                            '',
+                            '用法: /chatmode <interactive|proactive>',
+                        ].join('\n') };
+                }
+                return { kind: 'command.result', text: `📋 会话模式: ${currentMode}` };
             }
             if (arg !== 'interactive' && arg !== 'proactive') {
-                return `❌ 无效模式: ${arg}\n可选: interactive / proactive`;
+                return { kind: 'command.error', text: `❌ 无效模式: ${arg}\n可选: interactive / proactive` };
             }
-            if (activeChatType === 'group' && !isAdmin) {
-                return '❌ 无权限：群聊中切换会话模式仅限管理员使用';
+            if ((chatmodeSession.chatType || activeChatType) === 'group' && !isAdmin) {
+                return { kind: 'command.error', text: '❌ 无权限：群聊中切换会话模式仅限管理员使用' };
             }
             if (arg === currentMode) {
-                return `📋 当前会话模式已是 ${arg}`;
+                return { kind: 'command.result', text: `📋 当前会话模式已是 ${arg}` };
             }
             // 仅在真正需要切换时才要求会话空闲
             if (threadId) {
                 const threadSession = await this.sessionManager.getThreadSession(channel, channelId, threadId);
                 if (threadSession) {
-                    const threadAgent = this.getAgent(threadSession.agentId);
+                    const threadAgent = this.getAgent(channel, threadSession.agentId);
                     if (threadAgent.hasActiveStream(threadSession.id)) {
-                        return '⚠️ 当前正在处理消息，请稍后再试\n使用 /stop 中断当前任务后重试';
+                        return { kind: 'command.error', text: '⚠️ 当前正在处理消息，请稍后再试\n使用 /stop 中断当前任务后重试' };
                     }
                 }
             }
-            else if (agent.hasActiveStream(activeSession.id)) {
-                return '⚠️ 当前正在处理消息，请稍后再试\n使用 /stop 中断当前任务后重试';
+            else if (agent.hasActiveStream(chatmodeSession.id)) {
+                return { kind: 'command.error', text: '⚠️ 当前正在处理消息，请稍后再试\n使用 /stop 中断当前任务后重试' };
+            }
+            await this.sessionManager.updateSession(chatmodeSession.id, { sessionMode: arg });
+            this.eventBus.publish({ type: 'session:chat-mode-changed', sessionId: chatmodeSession.id, mode: arg, timestamp: Date.now() });
+            return { kind: 'command.result', text: `✅ 会话模式已切换: ${arg}` };
+        }
+        // /dispatch 命令：查看/切换群聊分发模式（mention | all）
+        // 仅群聊可用；群聊中设置需管理员权限
+        if (normalizedContent === '/dispatch' || normalizedContent.startsWith('/dispatch ')) {
+            const dispatchResult = await this.ensureSession(channel, channelId, threadId, chatType);
+            if ('error' in dispatchResult)
+                return { kind: 'command.result', text: dispatchResult.error };
+            const dispatchSession = dispatchResult.session;
+            const dispatchChatType = dispatchSession.chatType || activeChatType;
+            if (dispatchChatType !== 'group') {
+                return { kind: 'command.error', text: '❌ /dispatch 仅在群聊中可用' };
+            }
+            const arg = normalizedContent.slice(9).trim();
+            const currentMode = dispatchSession.metadata?.dispatchMode || 'mention';
+            if (!arg) {
+                // 尝试发送 CommandCard 卡片
+                if (isAdmin) {
+                    const modes = [
+                        { key: 'mention', name: '提及模式', desc: '仅当被 @ 提及（含 @all）时响应群消息' },
+                        { key: 'all', name: '广播模式', desc: '群内所有消息都触发响应' },
+                    ];
+                    const interaction = {
+                        type: 'interaction',
+                        id: `dispatch-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`,
+                        channelId,
+                        sessionId: dispatchSession.id,
+                        initiatorId: userId,
+                        kind: {
+                            kind: 'command-card',
+                            title: '📡 分发模式',
+                            body: modes.map(m => `${m.key === currentMode ? '✓' : '•'} **${m.key}** (${m.name}) - ${m.desc}`).join('\n'),
+                            buttons: modes.map(m => ({
+                                label: m.key === currentMode ? `✓ ${m.key}` : m.key,
+                                command: `/dispatch ${m.key}`,
+                                style: (m.key === currentMode ? 'primary' : 'default'),
+                                disabled: m.key === currentMode,
+                            })),
+                        },
+                    };
+                    const replyCtx = this.getReplyContext(dispatchSession);
+                    const cardResult = await this.sendCommandCard({ channel, channelId, interaction, replyCtx, canWrite: isAdmin });
+                    if (cardResult === null)
+                        return null;
+                    // 卡片降级：fall through 到下方文本输出
+                }
+                // 降级：文本
+                const lines = [];
+                lines.push(`📋 分发模式: ${currentMode}`);
+                lines.push('');
+                lines.push('模式说明：');
+                lines.push('  • mention — 提及模式：仅当被@提及时响应群消息(含@all)');
+                lines.push('  • all     — 广播模式：群内所有消息都触发响应');
+                if (isAdmin) {
+                    lines.push('');
+                    lines.push('用法: /dispatch <mention|all>');
+                }
+                return { kind: 'command.result', text: lines.join('\n') };
+            }
+            if (arg !== 'mention' && arg !== 'all') {
+                return { kind: 'command.error', text: `❌ 无效模式: ${arg}\n可选: mention / all\n用法: /dispatch <模式>` };
             }
-            await this.sessionManager.updateSession(activeSession.id, { sessionMode: arg });
-            return `✅ 会话模式已切换: ${arg}`;
+            if (!isAdmin) {
+                return { kind: 'command.error', text: '❌ 无权限：群聊中切换分发模式仅限管理员使用' };
+            }
+            if (arg === currentMode) {
+                return { kind: 'command.result', text: `📋 当前已是 ${arg}` };
+            }
+            const metadata = { ...(dispatchSession.metadata || {}), dispatchMode: arg };
+            await this.sessionManager.updateSession(dispatchSession.id, { metadata });
+            this.eventBus.publish({ type: 'session:dispatch-mode-changed', sessionId: dispatchSession.id, mode: arg, timestamp: Date.now() });
+            return { kind: 'command.result', text: `✅ 分发模式已切换: ${currentMode} → ${arg}` };
         }
         // /stop 命令：中断当前任务
         if (normalizedContent === '/stop') {
-            const stopResult = await this.ensureSession(channel, channelId, threadId);
+            const stopResult = await this.ensureSession(channel, channelId, threadId, chatType);
             if ('error' in stopResult)
-                return '当前没有正在处理的任务';
+                return { kind: 'command.result', text: '当前没有正在处理的任务' };
             const { session: stopSession } = stopResult;
-            const stopAgent = this.getAgent(stopSession.agentId);
+            const stopAgent = this.getAgent(channel, stopSession.agentId);
             const sessionKey = stopSession.id;
             const queueLength = this.messageQueue.getQueueLength(sessionKey);
             const hasActive = stopAgent.hasActiveStream(sessionKey);
             if (queueLength === 0 && !hasActive) {
-                return '当前没有正在处理的任务';
+                return { kind: 'command.result', text: '当前没有正在处理的任务' };
             }
             await stopAgent.interrupt(sessionKey);
             // 发布中断事件，让 MessageProcessor 标记为 interrupted（而非 done）
             this.eventBus.publish({
-                type: 'message:interrupted',
+                type: 'task:interrupted',
                 sessionId: sessionKey,
                 reason: 'stop',
-                agentName: this.agentRegistry?.resolveByChannel(channel)?.name ?? '[default]',
+                agentName: this.agentRegistry?.resolveByChannel(channel)?.name ?? '<unknown>',
             });
             // 强制清除 processing_state
             this.sessionManager.clearProcessing(sessionKey);
-            return '✓ 已发送中断信号，任务将尽快停止';
+            return { kind: 'command.result', text: '✓ 已发送中断信号，任务将尽快停止' };
         }
         // /clear 命令：通过 SDK /clear 清空会话历史
         if (normalizedContent === '/clear') {
-            const result = await this.ensureSession(channel, channelId, threadId);
+            const result = await this.ensureSession(channel, channelId, threadId, chatType);
             if ('error' in result)
-                return result.error;
+                return { kind: 'command.error', text: result.error };
             const { session } = result;
-            const sessionAgent = this.getAgent(session.agentId);
+            const sessionAgent = this.getAgent(channel, session.agentId);
             if (!sessionAgent.capabilities?.clear) {
-                return `❌ 当前 Agent (${sessionAgent.name}) 不支持 /clear\n\n可使用 /new 创建新会话替代`;
+                return { kind: 'command.error', text: `❌ 当前 Agent (${sessionAgent.name}) 不支持 /clear\n\n可使用 /new 创建新会话替代` };
             }
             if (!session.agentSessionId) {
-                return '❌ 当前会话没有历史记录，无需清空';
+                return { kind: 'command.error', text: '❌ 当前会话没有历史记录，无需清空' };
             }
             const projectPath = path.isAbsolute(session.projectPath)
                 ? session.projectPath
@@ -1708,10 +1868,10 @@ export class CommandHandler {
                 if (cleared) {
                     await this.sessionManager.updateAgentSessionIdBySessionId(session.id, '');
                     sessionAgent.updateSessionId(session.id, '');
-                    return '✅ 已清空当前会话的对话历史';
+                    return { kind: 'command.result', text: '✅ 已清空当前会话的对话历史' };
                 }
                 else {
-                    return '❌ 清空会话失败，请稍后重试';
+                    return { kind: 'command.error', text: '❌ 清空会话失败，请稍后重试' };
                 }
             }
             finally {
@@ -1720,16 +1880,16 @@ export class CommandHandler {
         }
         // /compact 命令：手动压缩会话上下文
         if (normalizedContent === '/compact') {
-            const result = await this.ensureSession(channel, channelId, threadId);
+            const result = await this.ensureSession(channel, channelId, threadId, chatType);
             if ('error' in result)
-                return result.error;
+                return { kind: 'command.error', text: result.error };
             const { session } = result;
-            const sessionAgent = this.getAgent(session.agentId);
+            const sessionAgent = this.getAgent(channel, session.agentId);
             if (!sessionAgent.capabilities?.compact) {
-                return `❌ 当前 Agent (${sessionAgent.name}) 不支持 /compact`;
+                return { kind: 'command.error', text: `❌ 当前 Agent (${sessionAgent.name}) 不支持 /compact` };
             }
             if (!session.agentSessionId) {
-                return '❌ 当前会话没有历史记录，无需压缩';
+                return { kind: 'command.error', text: '❌ 当前会话没有历史记录，无需压缩' };
             }
             const projectPath = path.isAbsolute(session.projectPath)
                 ? session.projectPath
@@ -1741,10 +1901,10 @@ export class CommandHandler {
                 }
                 const compacted = await sessionAgent.compactSession(session.id, session.agentSessionId, projectPath);
                 if (compacted) {
-                    return '✅ 会话上下文已压缩';
+                    return { kind: 'command.result', text: '✅ 会话上下文已压缩' };
                 }
                 else {
-                    return '❌ 会话压缩失败，请稍后重试';
+                    return { kind: 'command.error', text: '❌ 会话压缩失败，请稍后重试' };
                 }
             }
             finally {
@@ -1772,10 +1932,10 @@ export class CommandHandler {
         if (normalizedContent === '/status') {
             // session 现在总是存在（上面已自动创建）
             if (!session) {
-                return `❌ 无法创建会话，请检查配置`;
+                return { kind: 'command.error', text: `❌ 无法创建会话，请检查配置` };
             }
             const sessionKey = this.getQueueKey(session, channel, channelId);
-            const sessionAgent = this.getAgent(session.agentId);
+            const sessionAgent = this.getAgent(channel, session.agentId);
             const isCurrentlyProcessing = this.messageQueue.isProcessing(sessionKey) || sessionAgent.hasActiveStream(sessionKey);
             const queueLength = this.messageQueue.getQueueLength(sessionKey);
             const isThread = !!session.threadId;
@@ -1791,6 +1951,8 @@ export class CommandHandler {
                 }
             }
             const projectName = this.getProjectName(session.projectPath);
+            const owningAgent = this.getOwningAgent(channel);
+            const agentName = owningAgent?.name ?? 'DefaultAgent';
             const health = await this.sessionManager.getHealthStatus(session.id);
             const timeSinceSuccess = Date.now() - health.lastSuccessTime;
             const timeStr = timeSinceSuccess < 60000 ? '刚刚' :
@@ -1808,23 +1970,25 @@ export class CommandHandler {
             }
             const lines = [];
             const sessionMode = session.sessionMode || 'interactive';
+            const dispatchMode = session.metadata?.dispatchMode || 'mention';
             const chatModeLine = `会话模式: ${sessionMode}`;
+            const dispatchModeLine = session.chatType === 'group' ? `分发模式: ${dispatchMode}` : null;
             if (isAdmin) {
-                lines.push(`📊 ${isThread ? '话题' : '会话'}状态：`, `渠道: ${this.resolveChannelType(channel)} / 项目: ${projectName} / 会话: ${session.name || '(未命名)'}`, `会话ID: ${session.id}`, `项目路径: ${session.projectPath}`, `会话状态: ${sessionStatus}`, chatModeLine, `会话轮数: ${sessionTurns}`);
+                lines.push(`📊 ${isThread ? '话题' : '会话'}状态 (Agent: ${agentName})：`, `渠道: ${this.resolveChannelType(channel)} / 项目: ${projectName} / 会话: ${session.name || '(未命名)'}`, `会话ID: ${session.id}`, `项目路径: ${session.projectPath}`, `会话状态: ${sessionStatus}`, chatModeLine, ...(dispatchModeLine ? [dispatchModeLine] : []), `会话轮数: ${sessionTurns}`);
                 if (health.consecutiveErrors > 0) {
                     lines.push(`异常计数: ${health.consecutiveErrors}`);
                 }
                 lines.push(`最后成功: ${timeStr}`, `${session.agentId}会话: ${session.agentSessionId || '(未初始化)'}`, `创建时间: ${new Date(session.createdAt).toLocaleString('zh-CN')}`, `更新时间: ${new Date(session.updatedAt).toLocaleString('zh-CN')}`);
             }
             else {
-                lines.push(`📊 ${isThread ? '话题' : '会话'}状态：`, `渠道: ${channel} / 项目: ${projectName} / ${session.agentId}会话`, `状态: ${sessionStatus}`, chatModeLine, `会话轮数: ${sessionTurns}`, `最后活跃: ${timeStr}`);
+                lines.push(`📊 ${isThread ? '话题' : '会话'}状态 (Agent: ${agentName})：`, `渠道: ${channel} / 项目: ${projectName} / ${session.agentId}会话`, `状态: ${sessionStatus}`, chatModeLine, ...(dispatchModeLine ? [dispatchModeLine] : []), `会话轮数: ${sessionTurns}`, `最后活跃: ${timeStr}`);
             }
             if (health.lastError) {
                 lines.push('');
                 lines.push(`最后错误: ${health.lastErrorType || 'unknown'}`);
                 lines.push(`错误信息: ${health.lastError.substring(0, 100)}`);
             }
-            return lines.join('\n');
+            return { kind: 'command.result', text: lines.join('\n') };
         }
         // /new 命令：创建新会话（支持命名）
         if (normalizedContent.startsWith('/new')) {
@@ -1832,11 +1996,11 @@ export class CommandHandler {
             if (sessionName) {
                 const existing = await this.sessionManager.getSessionByName(channel, channelId, sessionName);
                 if (existing) {
-                    return `❌ 会话名称 "${sessionName}" 已存在，请使用其他名称`;
+                    return { kind: 'command.error', text: `❌ 会话名称 "${sessionName}" 已存在，请使用其他名称` };
                 }
             }
-            const projectPath = session?.projectPath || this.getEffectiveDefaultPath(channel);
-            const newSession = await this.sessionManager.createNewSession(channel, channelId, projectPath, sessionName, session?.agentId || this.defaultAgentId);
+            const projectPath = this.getEffectiveDefaultPath(channel);
+            const newSession = await this.sessionManager.createNewSession(channel, channelId, projectPath, sessionName, session?.agentId || this.primaryRunnerKey);
             this.eventBus.publish({
                 type: 'session:created',
                 sessionId: newSession.id,
@@ -1852,7 +2016,7 @@ export class CommandHandler {
                 await agent.clearSession(session.id, session.agentSessionId || '', session.projectPath);
                 await agent.closeSession(session.id);
             }
-            return `✓ 已创建新会话${sessionName ? `: ${sessionName}` : ''}\n  之前的对话历史已保留，可通过 /s 查看`;
+            return { kind: 'command.result', text: `✓ 已创建新会话${sessionName ? `: ${sessionName}` : ''}\n  项目: ${this.getProjectName(projectPath)}\n  之前的对话历史已保留，可通过 /s 查看` };
         }
         // /check 命令：检查渠道状态（guest 可用，详情仅 admin）/ 重连指定渠道（admin only）
         if (normalizedContent === '/check' || normalizedContent.startsWith('/check ')) {
@@ -1865,17 +2029,18 @@ export class CommandHandler {
                 allowedChannels = new Set(checkOwningAgent.channelInstanceNames());
             }
             else {
-                // default 范围：所有 channel 中，不属于任何 evolagent 的
+                // default 范围：不再有 default channel 概念，等价于"所有 channel"
                 const defaultNames = [];
                 for (const [name] of this.adapters) {
                     const owner = this.agentRegistry?.resolveByChannel(name);
-                    if (!owner || owner.isDefault)
+                    if (!owner)
                         defaultNames.push(name);
                 }
                 allowedChannels = new Set(defaultNames);
             }
             // Default: show system health check (non-admin 仅看摘要)
-            const lines = ['📡 渠道状态：'];
+            const checkAgentName = checkOwningAgent?.name ?? 'DefaultAgent';
+            const lines = [`📡 渠道状态 (Agent: ${checkAgentName})：`];
             // Group by channelType
             const groups = new Map();
             for (const [name] of this.adapters) {
@@ -1886,7 +2051,7 @@ export class CommandHandler {
                 let status;
                 if (ch?.getStatus) {
                     const s = ch.getStatus();
-                    status = s.connected ? '✓ 已连接' : s.reconnectAttempt > 0 ? `⏳ 重连中 (${s.reconnectAttempt}/${s.maxAttempts})` : '✗ 断开';
+                    status = s.connected ? '✓ 已连接' : '⏳ 重连中';
                 }
                 else {
                     status = '✓ 已注册';
@@ -1900,19 +2065,23 @@ export class CommandHandler {
                 const total = [...groups.values()].flat().length;
                 const healthy = [...groups.values()].flat().filter(i => i.status.includes('✓')).length;
                 lines.push(`  ${healthy}/${total} 渠道正常`);
-                return lines.join('\n');
+                return { kind: 'command.result', text: lines.join('\n') };
             }
             for (const [type, instances] of groups) {
                 if (instances.length === 1) {
-                    lines.push(`  ${instances[0].name}: ${instances[0].status}`);
+                    lines.push(`  ${type}: ${instances[0].status}`);
                 }
                 else {
-                    const parts = instances.map(i => `${i.name} ${i.status}`);
-                    lines.push(`  ${type}: [${parts.join(', ')}]`);
+                    const parts = instances.map(i => {
+                        const seg = i.name.split('#');
+                        const instName = seg.length >= 3 ? seg.slice(2).join('#') : i.name;
+                        return `${i.status.includes('✓') ? '✓' : '⏳'} ${instName}`;
+                    });
+                    lines.push(`  ${type}: ${parts.join(', ')}`);
                 }
             }
             // 当前 agent 名（用于 agent 维度 stats / queue 查询）
-            const currentAgentName = checkOwningAgent?.name ?? '[default]';
+            const currentAgentName = checkOwningAgent?.name ?? '<unknown>';
             // 队列状态（按当前 agent 维度）
             lines.push('', '📬 队列状态：');
             lines.push(`  待处理消息: ${this.messageQueue.getQueueLengthByAgent(currentAgentName)}`);
@@ -1946,19 +2115,15 @@ export class CommandHandler {
                     lines.push(`  平均响应耗时: ${(h.avgResponseMs / 1000).toFixed(1)}s`);
                 }
             }
-            return lines.join('\n');
+            return { kind: 'command.result', text: lines.join('\n') };
         }
         // /restart 命令：重启服务（owner only） / 重连指定渠道（admin+）
         if (normalizedContent === '/restart' || normalizedContent.startsWith('/restart ')) {
             const restartArg = normalizedContent.slice('/restart'.length).trim();
-            // /restart <type> — 重连指定类型的所有渠道（admin only，evolclaw 服务级操作）
-            // 服务级操作仅可从 default 通道发起，避免 evolagent owner/admin 越权
+            // /restart <type> — 重连指定类型的所有渠道（admin only）
             if (restartArg) {
-                if (this.getOwningAgent(channel)) {
-                    return '❌ 渠道重连只能从 DefaultAgent 通道发起（服务级操作）';
-                }
                 if (!isAdmin)
-                    return '❌ 无权限：渠道重连仅限管理员使用';
+                    return { kind: 'command.error', text: '❌ 无权限：渠道重连仅限管理员使用' };
                 const type = restartArg;
                 // /restart 是服务级操作：重连该 type 下的所有实例（不分 agent）
                 const scopedNames = [];
@@ -1967,7 +2132,7 @@ export class CommandHandler {
                         scopedNames.push(name);
                 }
                 if (scopedNames.length === 0) {
-                    return `❌ 没有类型为 "${type}" 的渠道`;
+                    return { kind: 'command.error', text: `❌ 没有类型为 "${type}" 的渠道` };
                 }
                 const results = [];
                 for (const name of scopedNames) {
@@ -1988,15 +2153,11 @@ export class CommandHandler {
                         results.push(`${name}: 重连失败 - ${e?.message || e}`);
                     }
                 }
-                return `🔄 重连 ${type}:\n  ${results.join('\n  ')}`;
-            }
-            // /restart（无参数）— 重启整个服务（owner only，且仅可从 default 通道触发）
-            // 防止 evolagent 通道的 owner 越权杀整个 evolclaw 进程（影响所有租户）
-            if (this.getOwningAgent(channel)) {
-                return '❌ 服务重启只能从 DefaultAgent 通道发起。EvolAgent 通道仅可执行 /restart <type> 重连特定类型渠道';
+                return { kind: 'command.result', text: `🔄 重连 ${type}:\n  ${results.join('\n  ')}` };
             }
+            // /restart（无参数）— 重启整个服务（owner only）
             if (!isOwner)
-                return '❌ 无权限：服务重启仅限 owner 使用';
+                return { kind: 'command.error', text: '❌ 无权限：服务重启仅限 owner 使用' };
             const allSessions = await this.sessionManager.listSessions(channel, channelId);
             const sessionsWithMessages = allSessions
                 .filter(s => this.messageCache.hasMessages(s.id))
@@ -2019,16 +2180,20 @@ export class CommandHandler {
                 };
                 fs.writeFileSync(path.join(resolvePaths().dataDir, 'restart-pending.json'), JSON.stringify(restartInfo));
                 const { spawn } = await import('child_process');
-                spawn('node', [path.join(getPackageRoot(), 'dist', 'cli.js'), 'restart-monitor'], {
+                spawn('node', [path.join(getPackageRoot(), 'dist', 'cli', 'index.js'), 'restart-monitor'], {
                     detached: true,
                     stdio: 'ignore',
                     env: { ...process.env, EVOLCLAW_HOME: resolvePaths().root }
                 }).unref();
                 this.eventBus.publish({ type: 'system:restart', channel, channelId });
+                // 发 SIGTERM 而非直接 process.exit(0)，让 index.ts 的 shutdown() 先
+                // 正常关闭所有 channel（包括 Feishu WebSocket close frame），
+                // 避免 Feishu 服务端因连接异常断开而重推未 ack 的消息给新进程。
                 setTimeout(() => {
                     logger.info('[System] Restarting by user command...');
-                    process.exit(0);
+                    process.kill(process.pid, 'SIGTERM');
                 }, 1000);
+                return true;
             };
             // 文本确认流程
             if (sessionsWithMessages.length > 0) {
@@ -2042,38 +2207,38 @@ export class CommandHandler {
                     }
                     else {
                         fs.writeFileSync(restartConfirmFile, JSON.stringify({ timestamp: now }));
-                        return sessionsWithMessages.join('\n') + '\n再次输入 /restart 将强制重启。';
+                        return { kind: 'command.result', text: sessionsWithMessages.join('\n') + '\n再次输入 /restart 将强制重启。' };
                     }
                 }
                 else {
                     fs.writeFileSync(restartConfirmFile, JSON.stringify({ timestamp: Date.now() }));
-                    return sessionsWithMessages.join('\n') + '\n再次输入 /restart 将强制重启。';
+                    return { kind: 'command.result', text: sessionsWithMessages.join('\n') + '\n再次输入 /restart 将强制重启。' };
                 }
             }
             await executeRestart();
-            return '🔄 服务正在重启，请稍候...（约 5 秒后恢复）';
+            return { kind: 'command.result', text: '🔄 服务正在重启，请稍候...（约 5 秒后恢复）' };
         }
         // /pwd 命令：显示当前项目路径
         if (normalizedContent === '/pwd') {
             // session 现在总是存在（上面已自动创建）
             if (!session) {
-                return `❌ 无法创建会话，请检查配置`;
+                return { kind: 'command.error', text: `❌ 无法创建会话，请检查配置` };
             }
             const configName = this.getConfiguredProjectName(session.projectPath);
             if (configName) {
-                return `当前项目: ${configName}\n路径: ${session.projectPath}`;
+                return { kind: 'command.result', text: `当前项目: ${configName}\n路径: ${session.projectPath}` };
             }
-            return `当前项目: ${session.projectPath}`;
+            return { kind: 'command.result', text: `当前项目: ${session.projectPath}` };
         }
         // /file 命令：发送项目内文件，支持 /file path 和 /file channel path（owner only）
         if (normalizedContent.startsWith('/file')) {
             if (!isOwner)
-                return '❌ 无权限：此命令仅限 owner 使用';
+                return { kind: 'command.error', text: '❌ 无权限：此命令仅限 owner 使用' };
             // 飞书会将 .md 等后缀自动转为 Markdown 链接: foo.md → [foo.md](http://foo.md/)
             // 还原: 将 [text](url) 替换为 text
             const rawArg = normalizedContent.slice(5).trim().replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');
             if (!rawArg) {
-                return '用法: /file <相对路径> 或 /file <渠道> <相对路径>\n示例: /file src/index.ts\n示例: /file feishu report.md';
+                return { kind: 'command.result', text: '用法: /file <相对路径> 或 /file <渠道> <相对路径>\n示例: /file src/index.ts\n示例: /file feishu report.md' };
             }
             // 解析目标通道：第一个 token 按实例名匹配，再按 channelType 匹配
             const tokens = rawArg.split(/\s+/);
@@ -2103,89 +2268,89 @@ export class CommandHandler {
             const isCrossChannel = targetChannel !== channel;
             // 跨通道仅限 owner
             if (isCrossChannel && identity.role !== 'owner') {
-                return '❌ 跨通道发送仅限管理员';
+                return { kind: 'command.error', text: '❌ 跨通道发送仅限管理员' };
             }
             // 找目标 adapter
             const targetAdapter = this.adapters.get(targetChannel);
             if (!targetAdapter) {
-                return `❌ 通道 ${targetLabel} 未启用或不存在`;
+                return { kind: 'command.error', text: `❌ 通道 ${targetLabel} 未启用或不存在` };
             }
-            if (!targetAdapter.sendFile) {
-                return `❌ 通道 ${targetLabel} 不支持文件发送`;
+            if (!targetAdapter.capabilities?.file) {
+                return { kind: 'command.error', text: `❌ 通道 ${targetLabel} 不支持文件发送` };
             }
             // 获取 session（需要 projectPath）
-            const sendResult = await this.ensureSession(channel, channelId, threadId);
+            const sendResult = await this.ensureSession(channel, channelId, threadId, chatType);
             if ('error' in sendResult)
-                return sendResult.error;
+                return { kind: 'command.result', text: sendResult.error };
             const sendSession = sendResult.session;
             // 路径安全校验
             if (path.isAbsolute(filePath)) {
-                return '❌ 不支持绝对路径\n请使用项目内的相对路径';
+                return { kind: 'command.error', text: '❌ 不支持绝对路径\n请使用项目内的相对路径' };
             }
             if (filePath.split(path.sep).includes('..') || filePath.split('/').includes('..')) {
-                return '❌ 不支持 .. 路径穿越';
+                return { kind: 'command.error', text: '❌ 不支持 .. 路径穿越' };
             }
             const resolvedPath = path.resolve(sendSession.projectPath, filePath);
             // 存在性检查
             if (!fs.existsSync(resolvedPath)) {
-                return `❌ 文件不存在: ${filePath}`;
+                return { kind: 'command.error', text: `❌ 文件不存在: ${filePath}` };
             }
             // 符号链接安全：realpath 后验证仍在项目目录内
             const realPath = fs.realpathSync(resolvedPath);
             const realProjectPath = fs.realpathSync(sendSession.projectPath);
             if (!realPath.startsWith(realProjectPath + path.sep) && realPath !== realProjectPath) {
-                return '❌ 路径不允许: 文件不在项目目录内';
+                return { kind: 'command.error', text: '❌ 路径不允许: 文件不在项目目录内' };
             }
             const stat = fs.statSync(resolvedPath);
             if (stat.isDirectory()) {
-                return '❌ 暂不支持发送目录\n目录打包发送将在后续版本支持';
+                return { kind: 'command.error', text: '❌ 暂不支持发送目录\n目录打包发送将在后续版本支持' };
             }
             const MAX_SIZE = 10 * 1024 * 1024;
             if (stat.size > MAX_SIZE) {
-                return `❌ 文件过大: ${(stat.size / 1024 / 1024).toFixed(1)} MB (限制 10 MB)`;
+                return { kind: 'command.error', text: `❌ 文件过大: ${(stat.size / 1024 / 1024).toFixed(1)} MB (限制 10 MB)` };
             }
             // 找目标 channelId
             let targetChannelId = channelId;
             if (isCrossChannel) {
-                const ownerPeerId = this.agentRegistry?.getOwner?.(targetChannel) ?? getOwner(this.config, targetChannel);
+                const ownerPeerId = this.agentRegistry?.getOwner?.(targetChannel);
                 targetChannelId = ownerPeerId ? (this.sessionManager.getOwnerChatId(targetChannel, ownerPeerId) ?? '') : '';
                 if (!targetChannelId) {
-                    return `❌ 未找到 ${targetLabel} 的私聊会话，请先在该通道发送一条消息`;
+                    return { kind: 'command.error', text: `❌ 未找到 ${targetLabel} 的私聊会话，请先在该通道发送一条消息` };
                 }
             }
             // 发送文件
             try {
                 const replyCtx = isCrossChannel ? undefined : this.getReplyContext(sendSession);
-                await targetAdapter.sendFile(targetChannelId, realPath, replyCtx);
+                await targetAdapter.send(buildEnvelope({ channel: targetAdapter.channelName, channelId: targetChannelId, replyContext: replyCtx }), { kind: 'result.file', filePath: realPath });
                 const sizeStr = stat.size < 1024 ? `${stat.size} B`
                     : stat.size < 1024 * 1024 ? `${(stat.size / 1024).toFixed(1)} KB`
                         : `${(stat.size / 1024 / 1024).toFixed(1)} MB`;
-                return isCrossChannel
-                    ? `📎 文件已通过 ${targetLabel} 发送: ${filePath} (${sizeStr})`
-                    : `✅ 已发送: ${filePath} (${sizeStr})`;
+                return { kind: 'command.result', text: isCrossChannel
+                        ? `📎 文件已通过 ${targetLabel} 发送: ${filePath} (${sizeStr})`
+                        : `✅ 已发送: ${filePath} (${sizeStr})` };
             }
             catch (error) {
                 logger.error('[CommandHandler] /file failed:', error);
-                return `❌ 文件发送失败: ${error.message || error}`;
+                return { kind: 'command.error', text: `❌ 文件发送失败: ${error.message || error}` };
             }
         }
         // /plist 命令：列出所有项目
         if (normalizedContent === '/plist') {
             if (!policy.canListProjects(session?.chatType || 'private', identity.role)) {
                 if (!session) {
-                    return `❌ 当前群聊未绑定项目
+                    return { kind: 'command.error', text: `❌ 当前群聊未绑定项目
 
-请使用 /bind <项目路径> 绑定项目`;
+请使用 /bind <项目路径> 绑定项目` };
                 }
                 const projectName = this.getProjectName(session.projectPath);
                 const isProcessing = !!session.processingState;
                 const status = isProcessing ? '[处理中]' : '[空闲]';
-                return `当前群聊绑定的项目：
+                return { kind: 'command.result', text: `当前群聊绑定的项目：
   ${projectName} (${session.projectPath}) - ${status}
 
-提示：群聊不支持切换项目`;
+提示：群聊不支持切换项目` };
             }
-            // 收集项目信息并按最近活跃排序（唯一来源：evolclaw.json projects.list）
+            // 收集项目信息并按最近活跃排序（唯一来源：agent config projects.list）
             const entries = [];
             for (const [name, projectPath] of Object.entries(this.projects)) {
                 // 跳过不存在的路径
@@ -2230,14 +2395,8 @@ export class CommandHandler {
                 }
                 return parts.join(' ');
             };
-            // 尝试发送 ActionInteraction 卡片（每个项目一个按钮，一键切换）
-            if (this.interactionRouter && entries.length > 0) {
-                const requestId = `plist-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`;
-                const buttons = entries.map(e => ({
-                    key: e.name,
-                    label: e.isCurrent ? `✓ ${e.name}` : e.name,
-                    style: e.isCurrent ? 'primary' : 'default',
-                }));
+            // 尝试发送 CommandCard 卡片（每个项目一个按钮，一键切换）
+            if (entries.length > 0) {
                 const bodyLines = entries.map(e => {
                     const status = buildStatusText(e);
                     const prefix = e.isCurrent ? '✓' : '•';
@@ -2245,35 +2404,27 @@ export class CommandHandler {
                 });
                 const interaction = {
                     type: 'interaction',
-                    id: requestId,
+                    id: `plist-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`,
                     channelId,
-                    sessionId: activeSession?.id || requestId,
+                    sessionId: activeSession?.id || '',
+                    initiatorId: userId,
                     kind: {
-                        kind: 'action',
+                        kind: 'command-card',
                         title: '📂 项目列表',
                         body: bodyLines.join('\n'),
-                        buttons,
+                        buttons: entries.map(e => ({
+                            label: e.isCurrent ? `✓ ${e.name}` : e.name,
+                            command: `/project ${e.name}`,
+                            style: (e.isCurrent ? 'primary' : 'default'),
+                            disabled: e.isCurrent,
+                        })),
                     },
                 };
                 const replyCtx = activeSession ? this.getReplyContext(activeSession) : undefined;
-                const cardSent = await this.sendInteractionCard({
-                    channel, channelId, sessionId: activeSession?.id || requestId, requestId, interaction, replyCtx,
-                    canWrite: isAdmin,
-                    callback: async (action, _values, operatorId) => {
-                        if (userId && operatorId && operatorId !== userId)
-                            return;
-                        const selectedEntry = entries.find(e => e.name === action);
-                        if (selectedEntry && !selectedEntry.isCurrent) {
-                            const result = await this.handle(`/project ${action}`, channel, channelId, undefined, userId, threadId);
-                            if (result) {
-                                const adapter = this.adapters.get(channel);
-                                adapter?.sendText(channelId, result, replyCtx);
-                            }
-                        }
-                    },
-                });
-                if (cardSent)
+                const cardResult = await this.sendCommandCard({ channel, channelId, interaction, replyCtx, canWrite: isAdmin });
+                if (cardResult === null)
                     return null;
+                return { kind: 'command.result', text: cardResult };
             }
             // 降级：文本列表
             const lines = ['可用项目:'];
@@ -2282,25 +2433,26 @@ export class CommandHandler {
                 lines.push(`${prefix} ${entry.name} (${entry.projectPath}) - ${buildStatusText(entry)}`);
             }
             lines.push('', '提示: 使用 /p <名称> 切换项目');
-            return lines.join('\n');
+            return { kind: 'command.result', text: lines.join('\n') };
         }
         // /project（无参数）：直接复用 /plist 逻辑（含卡片交互）
         if (normalizedContent === '/project') {
             if (!policy.canSwitchProject(session?.chatType || 'private', identity.role)) {
                 // 群聊不能切换项目，交由 /plist 逻辑处理
             }
-            return this.handle('/plist', channel, channelId, undefined, userId, threadId);
+            const delegated = await this.handle('/plist', channel, channelId, undefined, userId, threadId);
+            return typeof delegated === 'string' ? { kind: 'command.result', text: delegated } : delegated;
         }
         // /project 命令：切换项目（支持名称或路径）
         if (normalizedContent.startsWith('/project ')) {
             if (!policy.canSwitchProject(session?.chatType || 'private', identity.role)) {
-                return `❌ 群聊不支持切换项目
+                return { kind: 'command.error', text: `❌ 群聊不支持切换项目
 
-群聊只能绑定一个项目。如需更换项目，请联系管理员重新配置。`;
+群聊只能绑定一个项目。如需更换项目，请联系管理员重新配置。` };
             }
             let arg = normalizedContent.slice(9).trim();
             if (!arg)
-                return '用法: /p <name|path> 或 /project <name|path>';
+                return { kind: 'command.result', text: '用法: /p <name|path> 或 /project <name|path>' };
             // 检查确认标志
             const hasConfirm = arg.endsWith(' --confirm');
             if (hasConfirm) {
@@ -2310,10 +2462,10 @@ export class CommandHandler {
             let projectName;
             if (arg.includes('/')) {
                 if (!path.isAbsolute(arg)) {
-                    return '❌ 项目路径必须是绝对路径';
+                    return { kind: 'command.error', text: '❌ 项目路径必须是绝对路径' };
                 }
                 if (!fs.existsSync(arg)) {
-                    return `❌ 路径不存在: ${arg}`;
+                    return { kind: 'command.error', text: `❌ 路径不存在: ${arg}` };
                 }
                 projectPath = arg;
                 projectName = path.basename(arg);
@@ -2321,7 +2473,7 @@ export class CommandHandler {
             else {
                 projectPath = this.projects[arg];
                 if (!projectPath) {
-                    return `❌ 项目 "${arg}" 不存在\n提示: 使用 /p 查看可用项目`;
+                    return { kind: 'command.error', text: `❌ 项目 "${arg}" 不存在\n提示: 使用 /p 查看可用项目` };
                 }
                 projectName = arg;
             }
@@ -2329,13 +2481,13 @@ export class CommandHandler {
                 const normalizedSessionPath = path.resolve(session.projectPath);
                 const normalizedProjectPath = path.resolve(projectPath);
                 if (normalizedSessionPath === normalizedProjectPath) {
-                    return `当前已在项目: ${projectName}\n  路径: ${projectPath}`;
+                    return { kind: 'command.result', text: `当前已在项目: ${projectName}\n  路径: ${projectPath}` };
                 }
             }
             // 群聊切换项目需要确认
             const isGroupChat = session?.chatType === 'group';
             if (isGroupChat && !hasConfirm) {
-                return `⚠️ 群聊切换项目风险提示：
+                return { kind: 'command.error', text: `⚠️ 群聊切换项目风险提示：
 
 切换项目将影响所有群成员的对话上下文，可能导致：
   • 当前项目的会话历史被切换
@@ -2343,9 +2495,9 @@ export class CommandHandler {
   • 其他成员的工作受到影响
 
 确认切换请执行：
-  /p ${projectName} --confirm`;
+  /p ${projectName} --confirm` };
             }
-            const currentAgentId = activeSession?.agentId || this.defaultAgentId;
+            const currentAgentId = activeSession?.agentId || this.primaryRunnerKey;
             const newSession = await this.sessionManager.switchProject(channel, channelId, projectPath, currentAgentId);
             this.eventBus.publish({
                 type: 'project:switched',
@@ -2357,7 +2509,7 @@ export class CommandHandler {
             });
             const cachedEvents = this.messageCache.getEvents(newSession.id);
             const hasExistingSession = newSession.agentSessionId ? '（恢复已有会话）' : '（新建会话）';
-            const currentAgent = newSession.agentId || this.defaultAgentId;
+            const currentAgent = newSession.agentId || this.primaryRunnerKey;
             let response = `✓ 已切换到项目: ${projectName}\n  路径: ${projectPath}\n  Agent: ${currentAgent}\n  ${hasExistingSession}`;
             if (cachedEvents.length > 0 && sendMessage) {
                 for (const event of cachedEvents) {
@@ -2376,28 +2528,28 @@ export class CommandHandler {
                     await sendMessage(channelId, event.message);
                 }
                 this.messageCache.clearEvents(newSession.id);
-                return '';
+                return { kind: 'command.result', text: '' };
             }
-            return response;
+            return { kind: 'command.result', text: response };
         }
         // /bind 命令：持久化项目到配置（不切换）（owner only）
         if (normalizedContent === '/bind')
-            return '用法: /bind <路径>';
+            return { kind: 'command.result', text: '用法: /bind <路径>' };
         if (normalizedContent.startsWith('/bind ')) {
             if (!isOwner)
-                return '❌ 无权限：此命令仅限 owner 使用';
+                return { kind: 'command.error', text: '❌ 无权限：此命令仅限 owner 使用' };
             const projectPath = normalizedContent.slice(6).trim();
             if (!projectPath)
-                return '用法: /bind <路径>';
+                return { kind: 'command.result', text: '用法: /bind <路径>' };
             if (!path.isAbsolute(projectPath)) {
-                return '❌ 项目路径必须是绝对路径';
+                return { kind: 'command.error', text: '❌ 项目路径必须是绝对路径' };
             }
             if (!fs.existsSync(projectPath)) {
-                if (this.config.projects?.autoCreate) {
+                if (this.getOwningAgent(channel)?.config?.projects?.autoCreate) {
                     fs.mkdirSync(projectPath, { recursive: true });
                 }
                 else {
-                    return `❌ 路径不存在: ${projectPath}`;
+                    return { kind: 'command.error', text: `❌ 路径不存在: ${projectPath}` };
                 }
             }
             // 生成项目名称（使用目录名）
@@ -2407,34 +2559,34 @@ export class CommandHandler {
             const existing = scopeProjects[projectName];
             if (existing) {
                 if (existing === projectPath) {
-                    return `项目 "${projectName}" 已存在\n  路径: ${projectPath}\n\n使用 /p ${projectName} 切换到该项目`;
+                    return { kind: 'command.result', text: `项目 "${projectName}" 已存在\n  路径: ${projectPath}\n\n使用 /p ${projectName} 切换到该项目` };
                 }
-                return `❌ 项目名称 "${projectName}" 已被占用\n  现有路径: ${existing}\n  新路径: ${projectPath}\n\n请重命名目录或手动编辑配置文件`;
+                return { kind: 'command.error', text: `❌ 项目名称 "${projectName}" 已被占用\n  现有路径: ${existing}\n  新路径: ${projectPath}\n\n请重命名目录或手动编辑配置文件` };
             }
-            // 写入：agent-owned channel → agent.json；default → evolclaw.json
+            // 写入：agent-owned channel → agent.json；default → agent config
             const err = await this.addProjectInScope(channel, projectName, projectPath);
             if (err)
-                return err;
-            return `✓ 已添加项目: ${projectName}\n  路径: ${projectPath}\n\n使用 /p ${projectName} 切换到该项目`;
+                return { kind: 'command.result', text: err };
+            return { kind: 'command.result', text: `✓ 已添加项目: ${projectName}\n  路径: ${projectPath}\n\n使用 /p ${projectName} 切换到该项目` };
         }
         // /slist 命令：列出当前项目的会话
         // /slist      — 仅 EvolClaw 会话
         // /slist cli  — 仅 CLI 会话（未导入的）
         if (normalizedContent === '/slist' || normalizedContent === '/slist cli') {
             if (!session) {
-                return `❌ 当前没有活跃会话
+                return { kind: 'command.error', text: `❌ 当前没有活跃会话
 
 请先执行以下操作之一：
 1. 发送任意消息 - 自动创建新会话
 2. /new [名称] - 创建命名会话
-3. /p <项目> - 切换到指定项目`;
+3. /p <项目> - 切换到指定项目` };
             }
             const showCliOnly = normalizedContent === '/slist cli';
             // /slist cli — 仅显示 CLI 会话
             if (showCliOnly) {
                 const canImportCli = policy.canImportCliSession(session.chatType || 'private', identity.role);
                 if (!canImportCli) {
-                    return '❌ 当前无权查看 CLI 会话';
+                    return { kind: 'command.error', text: '❌ 当前无权查看 CLI 会话' };
                 }
                 const cliSessions = await this.sessionManager.scanCliSessions(session.projectPath, session.agentId);
                 const sessions = await this.sessionManager.listSessions(channel, channelId);
@@ -2442,7 +2594,7 @@ export class CommandHandler {
                 const dbSessionIds = new Set(currentProjectSessions.map(s => s.agentSessionId).filter(Boolean));
                 const orphanCliSessions = cliSessions.filter(c => !dbSessionIds.has(c.uuid));
                 if (orphanCliSessions.length === 0) {
-                    return `当前项目 ${path.basename(session.projectPath)} 没有未导入的 CLI 会话`;
+                    return { kind: 'command.result', text: `当前项目 ${path.basename(session.projectPath)} 没有未导入的 CLI 会话` };
                 }
                 // 构建显示数据（复用于卡片和文本）
                 const cliDisplayItems = orphanCliSessions.map(c => {
@@ -2451,42 +2603,31 @@ export class CommandHandler {
                     const uuid = c.uuid.substring(0, 8);
                     return { uuid, fullUuid: c.uuid, time, message };
                 });
-                // 尝试发送 ActionInteraction 卡片
+                // 尝试发送 CommandCard 卡片
                 if (this.interactionRouter && cliDisplayItems.length > 0) {
-                    const requestId = `slist-cli-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`;
-                    const buttons = cliDisplayItems.map(item => ({
-                        key: item.uuid,
-                        label: item.uuid,
-                        style: 'default',
-                    }));
                     const bodyLines = cliDisplayItems.map(item => `• ${item.time}  (${item.uuid})  "${item.message}"`);
                     const interaction = {
                         type: 'interaction',
-                        id: requestId,
+                        id: `slist-cli-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`,
                         channelId,
                         sessionId: session.id,
+                        initiatorId: userId,
                         kind: {
-                            kind: 'action',
+                            kind: 'command-card',
                             title: `📋 ${path.basename(session.projectPath)} CLI 会话 (${cliDisplayItems.length})`,
                             body: bodyLines.join('\n'),
-                            buttons,
+                            buttons: cliDisplayItems.map(item => ({
+                                label: item.uuid,
+                                command: `/session ${item.uuid}`,
+                                style: 'default',
+                            })),
                         },
                     };
                     const replyCtx = this.getReplyContext(session);
-                    const cardSent = await this.sendInteractionCard({
-                        channel, channelId, sessionId: session.id, requestId, interaction, replyCtx,
-                        callback: async (action, _values, operatorId) => {
-                            if (userId && operatorId && operatorId !== userId)
-                                return;
-                            const result = await this.handle(`/session ${action}`, channel, channelId, undefined, userId, threadId);
-                            if (result) {
-                                const adapter = this.adapters.get(channel);
-                                adapter?.sendText(channelId, result, replyCtx);
-                            }
-                        },
-                    });
-                    if (cardSent)
+                    const cardResult = await this.sendCommandCard({ channel, channelId, interaction, replyCtx });
+                    if (cardResult === null)
                         return null;
+                    return { kind: 'command.result', text: cardResult };
                 }
                 // 降级：文本列表
                 const lines = [`当前项目 ${path.basename(session.projectPath)} 的 CLI 会话 (共 ${orphanCliSessions.length} 个):`, ''];
@@ -2495,7 +2636,7 @@ export class CommandHandler {
                 }
                 lines.push('');
                 lines.push('使用 /s <8位uuid> 导入并切换到 CLI 会话');
-                return lines.join('\n');
+                return { kind: 'command.result', text: lines.join('\n') };
             }
             // /slist — 仅显示 EvolClaw 会话
             const sessions = await this.sessionManager.listSessions(channel, channelId);
@@ -2545,17 +2686,8 @@ export class CommandHandler {
                 }
                 displaySessions.push({ session: s, index: displayIndex, isActive, name, status, idleTime, fileMissing });
             }
-            // 尝试发送 ActionInteraction 卡片（每个会话一个按钮，一键切换）
+            // 尝试发送 CommandCard 卡片（每个会话一个按钮，一键切换）
             if (this.interactionRouter && displaySessions.length >= 1) {
-                const requestId = `slist-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`;
-                const buttons = displaySessions.map(ds => {
-                    const shortId = ds.session.agentSessionId ? ds.session.agentSessionId.substring(0, 8) : ds.name;
-                    return {
-                        key: String(ds.index),
-                        label: ds.isActive ? `✓ ${ds.index}. ${shortId}` : `${ds.index}. ${shortId}`,
-                        style: ds.isActive ? 'primary' : 'default',
-                    };
-                });
                 const bodyLines = displaySessions.map(ds => {
                     const prefix = ds.isActive ? '✓' : '•';
                     const threadTag = ds.session.threadId ? '[话题] ' : '';
@@ -2565,34 +2697,30 @@ export class CommandHandler {
                 });
                 const interaction = {
                     type: 'interaction',
-                    id: requestId,
+                    id: `slist-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`,
                     channelId,
                     sessionId: session.id,
+                    initiatorId: userId,
                     kind: {
-                        kind: 'action',
+                        kind: 'command-card',
                         title: `📋 ${path.basename(session.projectPath)} 会话列表`,
                         body: bodyLines.join('\n'),
-                        buttons,
+                        buttons: displaySessions.map(ds => {
+                            const shortId = ds.session.agentSessionId ? ds.session.agentSessionId.substring(0, 8) : ds.name;
+                            return {
+                                label: ds.isActive ? `✓ ${ds.index}. ${shortId}` : `${ds.index}. ${shortId}`,
+                                command: `/session ${ds.index}`,
+                                style: (ds.isActive ? 'primary' : 'default'),
+                                disabled: ds.isActive,
+                            };
+                        }),
                     },
                 };
                 const replyCtx = this.getReplyContext(session);
-                const cardSent = await this.sendInteractionCard({
-                    channel, channelId, sessionId: session.id, requestId, interaction, replyCtx,
-                    callback: async (action, _values, operatorId) => {
-                        if (userId && operatorId && operatorId !== userId)
-                            return;
-                        const target = displaySessions.find(ds => String(ds.index) === action);
-                        if (target && !target.isActive) {
-                            const result = await this.handle(`/session ${action}`, channel, channelId, undefined, userId, threadId);
-                            if (result) {
-                                const adapter = this.adapters.get(channel);
-                                adapter?.sendText(channelId, result, replyCtx);
-                            }
-                        }
-                    },
-                });
-                if (cardSent)
+                const cardResult = await this.sendCommandCard({ channel, channelId, interaction, replyCtx });
+                if (cardResult === null)
                     return null;
+                return { kind: 'command.result', text: cardResult };
             }
             // 降级：文本列表
             const lines = [`当前项目 ${path.basename(session.projectPath)} 的 [${session.agentId}] 会话列表:`, ''];
@@ -2622,21 +2750,23 @@ export class CommandHandler {
             }
             lines.push('使用 /s <序号、name或8位uuid> 切换会话');
             lines.push('使用 /s cli 查看 CLI 会话');
-            return lines.join('\n');
+            return { kind: 'command.result', text: lines.join('\n') };
         }
         // /session（无参数）：直接复用 /slist 逻辑（含卡片交互）
         if (normalizedContent === '/session') {
-            return this.handle('/slist', channel, channelId, undefined, userId, threadId);
+            const delegated = await this.handle('/slist', channel, channelId, undefined, userId, threadId);
+            return typeof delegated === 'string' ? { kind: 'command.result', text: delegated } : delegated;
         }
         // /session cli（= /s cli）：列出未导入的 CLI 会话
         if (normalizedContent === '/session cli') {
-            return this.handle('/slist cli', channel, channelId, undefined, userId, threadId);
+            const delegated = await this.handle('/slist cli', channel, channelId, undefined, userId, threadId);
+            return typeof delegated === 'string' ? { kind: 'command.result', text: delegated } : delegated;
         }
         // /session 或 /s 命令：切换会话
         if (normalizedContent.startsWith('/session ')) {
             const sessionName = normalizedContent.slice(9).trim();
             if (!sessionName)
-                return '用法: /s <序号、会话名称或前8位UUID>';
+                return { kind: 'command.result', text: '用法: /s <序号、会话名称或前8位UUID>' };
             let targetSession = await this.sessionManager.getSessionByName(channel, channelId, sessionName);
             // 序号切换：纯数字时按 /slist 显示的序号匹配（超过10个时隐藏非活跃话题会话）
             if (!targetSession && /^\d+$/.test(sessionName) && session) {
@@ -2652,7 +2782,7 @@ export class CommandHandler {
                     targetSession = visibleSessions[idx - 1];
                 }
                 else {
-                    return `❌ 序号超出范围 (1-${visibleSessions.length})\n使用 /s 查看可用会话`;
+                    return { kind: 'command.error', text: `❌ 序号超出范围 (1-${visibleSessions.length})\n使用 /s 查看可用会话` };
                 }
             }
             if (!targetSession && sessionName.length >= 8) {
@@ -2665,19 +2795,19 @@ export class CommandHandler {
                     projectPaths.unshift(session.projectPath);
                 }
                 for (const projectPath of projectPaths) {
-                    const currentAgentId = session?.agentId || this.defaultAgentId;
+                    const currentAgentId = session?.agentId || this.primaryRunnerKey;
                     const cliSessions = await this.sessionManager.scanCliSessions(projectPath, currentAgentId);
                     const cliSession = cliSessions.find(c => c.uuid.startsWith(sessionName));
                     if (cliSession) {
                         const imported = await this.sessionManager.importCliSession(channel, channelId, projectPath, cliSession.uuid, currentAgentId);
                         this.eventBus.publish({ type: 'session:imported', sessionId: imported.id, agentSessionId: cliSession.uuid, projectPath });
                         const projectName = this.getProjectName(projectPath);
-                        return `✓ 已导入 CLI 会话: ${imported.name}\n  项目: ${projectName}\n  将继续之前的对话历史`;
+                        return { kind: 'command.result', text: `✓ 已导入 CLI 会话: ${imported.name}\n  项目: ${projectName}\n  将继续之前的对话历史` };
                     }
                 }
             }
             if (!targetSession) {
-                return `❌ 会话不存在: ${sessionName}\n使用 /s 查看可用会话`;
+                return { kind: 'command.error', text: `❌ 会话不存在: ${sessionName}\n使用 /s 查看可用会话` };
             }
             const lastInput = targetSession.agentSessionId
                 ? this.sessionManager.readSessionLastUserMessage(targetSession.projectPath, targetSession.agentSessionId, targetSession.agentId)
@@ -2686,64 +2816,64 @@ export class CommandHandler {
             if (!session) {
                 const switched = await this.sessionManager.switchToSession(channel, channelId, targetSession.id);
                 if (!switched) {
-                    return `❌ 切换会话失败`;
+                    return { kind: 'command.error', text: `❌ 切换会话失败` };
                 }
-                return `✓ 已切换到会话: ${targetSession.name || sessionName}\n  项目: ${path.basename(targetSession.projectPath)}${lastInputLine}`;
+                return { kind: 'command.result', text: `✓ 已切换到会话: ${targetSession.name || sessionName}\n  项目: ${path.basename(targetSession.projectPath)}${lastInputLine}` };
             }
             if (targetSession.id === session.id) {
-                return `当前已在会话: ${targetSession.name || sessionName}`;
+                return { kind: 'command.result', text: `当前已在会话: ${targetSession.name || sessionName}` };
             }
             // 阻止从主会话切换到话题会话
             if (!session.threadId && targetSession.threadId) {
-                return `❌ 无法从主会话切换到话题会话\n话题会话仅在对应话题内可用`;
+                return { kind: 'command.error', text: `❌ 无法从主会话切换到话题会话\n话题会话仅在对应话题内可用` };
             }
             const switched = await this.sessionManager.switchToSession(channel, channelId, targetSession.id);
             if (!switched) {
-                return `❌ 切换会话失败`;
+                return { kind: 'command.error', text: `❌ 切换会话失败` };
             }
             this.eventBus.publish({ type: 'session:switched', sessionId: targetSession.id, fromSessionId: session.id, toSessionId: targetSession.id });
             const continueHint = lastInput ? '\n  将继续之前的对话历史' : '\n  当前会话未有发言';
-            return `✓ 已切换到会话: ${targetSession.name || sessionName}${continueHint}${lastInputLine}`;
+            return { kind: 'command.result', text: `✓ 已切换到会话: ${targetSession.name || sessionName}${continueHint}${lastInputLine}` };
         }
         // /rename 或 /name 命令：重命名当前会话
         if (normalizedContent === '/rename' || normalizedContent === '/name') {
-            return '用法: /name <新名称> 或 /rename <新名称>';
+            return { kind: 'command.result', text: '用法: /name <新名称> 或 /rename <新名称>' };
         }
         if (normalizedContent.startsWith('/rename ')) {
             const newName = normalizedContent.slice(8).trim();
             if (!newName)
-                return '用法: /name <新名称> 或 /rename <新名称>';
+                return { kind: 'command.result', text: '用法: /name <新名称> 或 /rename <新名称>' };
             if (!session) {
-                return `❌ 当前没有活跃会话
+                return { kind: 'command.error', text: `❌ 当前没有活跃会话
 
 请先执行以下操作之一：
 1. 发送任意消息 - 自动创建新会话
 2. /new [名称] - 创建命名会话
-3. /session <名称> - 切换到已有会话`;
+3. /session <名称> - 切换到已有会话` };
             }
             const existing = await this.sessionManager.getSessionByName(channel, channelId, newName);
             if (existing && existing.id !== session.id) {
-                return `❌ 会话名称 "${newName}" 已存在，请使用其他名称`;
+                return { kind: 'command.error', text: `❌ 会话名称 "${newName}" 已存在，请使用其他名称` };
             }
             const oldName = session.name || '(未命名)';
             const success = await this.sessionManager.renameSession(session.id, newName);
             if (!success) {
-                return `❌ 重命名失败`;
+                return { kind: 'command.error', text: `❌ 重命名失败` };
             }
             this.eventBus.publish({ type: 'session:renamed', sessionId: session.id, oldName, newName });
-            return `✓ 已将当前会话重命名为: ${newName}`;
+            return { kind: 'command.result', text: `✓ 已将当前会话重命名为: ${newName}` };
         }
         // /del 命令：删除指定会话（仅解绑，不删除文件）
         if (normalizedContent.startsWith('/del ')) {
             const sessionName = normalizedContent.slice(5).trim();
             if (!sessionName)
-                return '用法: /del <序号、会话名称或前8位UUID>';
+                return { kind: 'command.result', text: '用法: /del <序号、会话名称或前8位UUID>' };
             if (!session) {
-                return `❌ 当前没有活跃会话`;
+                return { kind: 'command.error', text: `❌ 当前没有活跃会话` };
             }
             // 权限检查：policy 控制谁可以删除会话
             if (!policy.canDeleteSession(session.chatType || 'private', identity.role)) {
-                return `❌ 无权限：群聊中仅管理员可删除会话`;
+                return { kind: 'command.error', text: `❌ 无权限：群聊中仅管理员可删除会话` };
             }
             let targetSession = await this.sessionManager.getSessionByName(channel, channelId, sessionName);
             // 序号删除（与 /slist 显示序号一致）
@@ -2759,107 +2889,107 @@ export class CommandHandler {
                     targetSession = visibleSessions[idx - 1];
                 }
                 else {
-                    return `❌ 序号超出范围 (1-${visibleSessions.length})\n使用 /s 查看可用会话`;
+                    return { kind: 'command.error', text: `❌ 序号超出范围 (1-${visibleSessions.length})\n使用 /s 查看可用会话` };
                 }
             }
             if (!targetSession && sessionName.length >= 8) {
                 targetSession = await this.sessionManager.getSessionByUuidPrefix(channel, channelId, sessionName);
             }
             if (!targetSession) {
-                return `❌ 会话不存在: ${sessionName}\n使用 /s 查看可用会话`;
+                return { kind: 'command.error', text: `❌ 会话不存在: ${sessionName}\n使用 /s 查看可用会话` };
             }
             if (targetSession.id === session.id) {
-                return `❌ 无法删除当前活跃会话\n请先切换到其他会话`;
+                return { kind: 'command.error', text: `❌ 无法删除当前活跃会话\n请先切换到其他会话` };
             }
             const success = await this.sessionManager.unbindSession(targetSession.id);
             if (!success) {
-                return `❌ 删除失败`;
+                return { kind: 'command.error', text: `❌ 删除失败` };
             }
             this.eventBus.publish({ type: 'session:deleted', sessionId: targetSession.id });
-            const targetAgent = this.getAgent(targetSession.agentId);
+            const targetAgent = this.getAgent(channel, targetSession.agentId);
             await targetAgent.closeSession(targetSession.id);
-            return `✓ 已删除会话: ${targetSession.name || sessionName}\n会话文件已保留，可通过 CLI 访问`;
+            return { kind: 'command.result', text: `✓ 已删除会话: ${targetSession.name || sessionName}\n会话文件已保留，可通过 CLI 访问` };
         }
         // /fork 命令：分支当前会话
         if (normalizedContent === '/fork' || normalizedContent.startsWith('/fork ')) {
             const forkName = normalizedContent.slice(5).trim() || undefined;
             if (!session) {
-                return `❌ 当前没有活跃会话，无法分支`;
+                return { kind: 'command.error', text: `❌ 当前没有活跃会话，无法分支` };
             }
             if (!session.agentSessionId) {
-                return `❌ 当前会话尚未初始化对话，无法分支\n\n请先发送一条消息，然后再使用 /fork`;
+                return { kind: 'command.error', text: `❌ 当前会话尚未初始化对话，无法分支\n\n请先发送一条消息，然后再使用 /fork` };
             }
-            const forkAgent = this.getAgent(session.agentId);
+            const forkAgent = this.getAgent(channel, session.agentId);
             if (!forkAgent.capabilities?.fork) {
-                return `❌ 当前 Agent (${forkAgent.name}) 不支持 /fork\n\n可使用 /new 创建新会话替代`;
+                return { kind: 'command.error', text: `❌ 当前 Agent (${forkAgent.name}) 不支持 /fork\n\n可使用 /new 创建新会话替代` };
             }
             try {
                 const forkedSessionId = await forkAgent.forkSession(session.agentSessionId, session.projectPath, forkName);
                 const newSession = await this.sessionManager.createForkedSession(session, forkedSessionId, forkName);
                 this.eventBus.publish({ type: 'session:forked', sessionId: newSession.id, sourceSessionId: session.id, name: forkName });
-                return `✅ 会话已分支: ${newSession.name}\n新会话已激活，可以继续对话\n\n使用 /s 查看所有会话，/s <名称> 切换回原会话`;
+                return { kind: 'command.result', text: `✅ 会话已分支: ${newSession.name}\n新会话已激活，可以继续对话\n\n使用 /s 查看所有会话，/s <名称> 切换回原会话` };
             }
             catch (error) {
                 logger.error('[CommandHandler] Fork session failed:', error);
-                return `❌ 会话分支失败: ${error instanceof Error ? error.message : '未知错误'}`;
+                return { kind: 'command.error', text: `❌ 会话分支失败: ${error instanceof Error ? error.message : '未知错误'}` };
             }
         }
         // /rewind 命令：查看历史 / 回退会话
         if (normalizedContent === '/rewind' || normalizedContent.startsWith('/rewind ')) {
-            const result = await this.ensureSession(channel, channelId, threadId);
+            const result = await this.ensureSession(channel, channelId, threadId, chatType);
             if ('error' in result)
-                return result.error;
+                return { kind: 'command.error', text: result.error };
             const { session } = result;
-            const rewindAgent = this.getAgent(session.agentId);
+            const rewindAgent = this.getAgent(channel, session.agentId);
             if (rewindAgent.name !== 'claude') {
-                return '❌ /rewind 仅支持 Claude 后端';
+                return { kind: 'command.error', text: '❌ /rewind 仅支持 Claude 后端' };
             }
             if (!session.agentSessionId) {
-                return '❌ 当前会话无历史记录\n\n请先发送一条消息，然后再使用 /rewind';
+                return { kind: 'command.error', text: '❌ 当前会话无历史记录\n\n请先发送一条消息，然后再使用 /rewind' };
             }
             if (!rewindAgent.getSessionMessages) {
-                return '❌ 当前 Agent 不支持 /rewind';
+                return { kind: 'command.error', text: '❌ 当前 Agent 不支持 /rewind' };
             }
             const args = normalizedContent.slice('/rewind'.length).trim();
             if (!args) {
-                return await this.handleRewindList(session, rewindAgent);
+                return { kind: 'command.result', text: await this.handleRewindList(session, rewindAgent) };
             }
             // 带参（执行回退，会删除文件/改对话）需 admin+
             if (!isAdmin)
-                return '❌ 无权限：回退操作仅限管理员使用';
+                return { kind: 'command.error', text: '❌ 无权限：回退操作仅限管理员使用' };
             const parts = args.split(/\s+/);
             const turnNum = parseInt(parts[0], 10);
             if (isNaN(turnNum) || turnNum < 1) {
-                return '❌ 无效轮次，用法：/rewind <N> chat|file|all（撤销第N轮）';
+                return { kind: 'command.error', text: '❌ 无效轮次，用法：/rewind <N> chat|file|all（撤销第N轮）' };
             }
             const mode = parts[1]?.toLowerCase();
             if (!mode) {
-                return `❌ 请指定回退模式：/rewind ${turnNum} chat | file | all（撤销第${turnNum}轮）`;
+                return { kind: 'command.error', text: `❌ 请指定回退模式：/rewind ${turnNum} chat | file | all（撤销第${turnNum}轮）` };
             }
             if (!['chat', 'file', 'all'].includes(mode)) {
-                return `❌ 无效模式 "${mode}"，可选：chat | file | all`;
+                return { kind: 'command.error', text: `❌ 无效模式 "${mode}"，可选：chat | file | all` };
             }
-            return await this.handleRewind(session, rewindAgent, turnNum, mode);
+            return { kind: 'command.result', text: await this.handleRewind(session, rewindAgent, turnNum, mode) };
         }
         // /repair 命令：检查并修复会话文件
         if (normalizedContent === '/repair') {
-            const repairResult = await this.ensureSession(channel, channelId, threadId);
+            const repairResult = await this.ensureSession(channel, channelId, threadId, chatType);
             if ('error' in repairResult)
-                return repairResult.error;
+                return { kind: 'command.result', text: repairResult.error };
             const { session: repairSession } = repairResult;
-            const repairAgent = this.getAgent(repairSession.agentId);
+            const repairAgent = this.getAgent(channel, repairSession.agentId);
             const { checkSessionFile, backupSessionFile } = await import('./session/session-file-health.js');
             try {
                 if (!repairSession.agentSessionId) {
                     await this.sessionManager.resetHealthStatus(repairSession.id);
-                    return `✓ 修复完成\n\n修复内容：\n- 未发现问题（新会话）\n- 已重置异常计数器`;
+                    return { kind: 'command.result', text: `✓ 修复完成\n\n修复内容：\n- 未发现问题（新会话）\n- 已重置异常计数器` };
                 }
                 // 通过 agent 定位 session 文件
                 const sessionFile = repairAgent.resolveSessionFile?.(repairSession.agentSessionId, repairSession.projectPath) ?? null;
                 if (!sessionFile) {
                     // 文件不存在（已被删除或从未创建），直接重置
                     await this.sessionManager.resetHealthStatus(repairSession.id);
-                    return `✓ 修复完成\n\n修复内容：\n- 会话文件不存在（可能已被清理）\n- 已重置异常计数器`;
+                    return { kind: 'command.result', text: `✓ 修复完成\n\n修复内容：\n- 会话文件不存在（可能已被清理）\n- 已重置异常计数器` };
                 }
                 const healthCheck = await checkSessionFile(sessionFile);
                 if (healthCheck.corrupt) {
@@ -2869,26 +2999,146 @@ export class CommandHandler {
                     await this.sessionManager.updateAgentSessionIdBySessionId(repairSession.id, '');
                     repairAgent.updateSessionId(repairSession.id, '');
                     await this.sessionManager.resetHealthStatus(repairSession.id);
-                    return `✓ 修复完成\n\n检测到问题：\n${healthCheck.issues.map((i) => `- ${i}`).join('\n')}\n\n修复操作：\n- 已备份损坏文件\n- 已删除损坏文件\n- 已重置异常计数器\n\n备份位置：${backupPath}`;
+                    return { kind: 'command.result', text: `✓ 修复完成\n\n检测到问题：\n${healthCheck.issues.map((i) => `- ${i}`).join('\n')}\n\n修复操作：\n- 已备份损坏文件\n- 已删除损坏文件\n- 已重置异常计数器\n\n备份位置：${backupPath}` };
                 }
                 if (healthCheck.issues.length > 0) {
                     await this.sessionManager.resetHealthStatus(repairSession.id);
-                    return `⚠️ 检测到问题：\n${healthCheck.issues.map((i) => `- ${i}`).join('\n')}\n\n建议使用 /new 创建新会话\n\n已重置异常计数器，可继续使用当前会话。`;
+                    return { kind: 'command.error', text: `⚠️ 检测到问题：\n${healthCheck.issues.map((i) => `- ${i}`).join('\n')}\n\n建议使用 /new 创建新会话\n\n已重置异常计数器，可继续使用当前会话。` };
                 }
                 await this.sessionManager.resetHealthStatus(repairSession.id);
-                return `✓ 修复完成\n\n修复内容：\n- 未发现问题\n- 已重置异常计数器`;
+                return { kind: 'command.result', text: `✓ 修复完成\n\n修复内容：\n- 未发现问题\n- 已重置异常计数器` };
             }
             catch (error) {
                 logger.error('[Repair] Failed:', error);
-                return `❌ 修复失败: ${error.message}`;
+                return { kind: 'command.error', text: `❌ 修复失败: ${error.message}` };
             }
         }
         // /safe 命令：安全模式已禁用
         if (normalizedContent === '/safe') {
-            return `ℹ️ 安全模式已禁用\n\n如需重置会话，请使用 /new 创建新会话。`;
+            return { kind: 'command.result', text: `ℹ️ 安全模式已禁用\n\n如需重置会话，请使用 /new 创建新会话。` };
+        }
+        // /trigger 命令
+        if (normalizedContent === '/trigger' || normalizedContent.startsWith('/trigger ')) {
+            const text = this.handleTrigger(normalizedContent, channel, channelId, userId ?? '', isAdmin);
+            return { kind: 'command.result', text };
         }
         return null;
     }
+    handleTrigger(content, channel, channelId, peerId, isAdmin) {
+        const scheduler = this.triggerScheduler;
+        const manager = this.triggerManager;
+        // Bare /trigger → list active
+        if (content === '/trigger') {
+            if (!manager)
+                return '⚠️ 触发器功能未启用';
+            const active = manager.listActive();
+            if (active.length === 0)
+                return '📭 当前没有活跃的触发器';
+            const lines = active.map(t => {
+                const next = new Date(t.nextFireAt).toLocaleString();
+                const fired = t.fireCount > 0 ? ` | 已触发 ${t.fireCount} 次` : '';
+                return `• **${t.name}** [${t.scheduleType}] 下次: ${next}${fired}`;
+            });
+            return `📋 活跃触发器（${active.length} 个）：\n\n${lines.join('\n')}`;
+        }
+        const sub = content.slice('/trigger '.length).trim();
+        // /trigger list → list all (active + history)
+        if (sub === 'list' || sub.startsWith('list ')) {
+            if (!manager)
+                return '⚠️ 触发器功能未启用';
+            const { active, history } = manager.listAll();
+            const lines = [];
+            if (active.length > 0) {
+                lines.push(`**活跃 (${active.length})**`);
+                for (const t of active) {
+                    const next = new Date(t.nextFireAt).toLocaleString();
+                    lines.push(`• ${t.name} [${t.scheduleType}] 下次: ${next} | 触发 ${t.fireCount} 次`);
+                }
+            }
+            if (history.length > 0) {
+                lines.push(`\n**历史 (${history.length})**`);
+                for (const h of history.slice(-10)) {
+                    const done = new Date(h.doneAt).toLocaleString();
+                    lines.push(`• ${h.name} [${h.doneReason}] ${done}`);
+                }
+            }
+            if (lines.length === 0)
+                return '📭 没有触发器记录';
+            return lines.join('\n');
+        }
+        // /trigger cancel <name|id>
+        if (sub.startsWith('cancel ')) {
+            if (!manager || !scheduler)
+                return '⚠️ 触发器功能未启用';
+            const nameOrId = sub.slice('cancel '.length).trim();
+            if (!nameOrId)
+                return '❌ 用法：/trigger cancel <名称>';
+            // Find trigger: non-admin lookup is scoped to (peerId, channel) to avoid info disclosure
+            // Non-admins can cancel by name or by their own trigger's UUID
+            let trigger;
+            if (isAdmin) {
+                trigger = manager.getByName(nameOrId) ?? manager.getById(nameOrId);
+            }
+            else {
+                trigger = manager.getByNameScoped(nameOrId, peerId, channel)
+                    ?? manager.getByIdScoped(nameOrId, peerId, channel);
+            }
+            if (!trigger) {
+                return isAdmin
+                    ? `❌ 未找到触发器：${nameOrId}`
+                    : `❌ 未找到触发器 "${nameOrId}"，或无权限取消`;
+            }
+            manager.moveToDone(trigger.id, 'cancelled');
+            scheduler.cancel(trigger.id);
+            this.eventBus.publish({ type: 'trigger:cancelled', triggerId: trigger.id, by: peerId });
+            return `✅ 触发器已取消：**${trigger.name}**`;
+        }
+        // /trigger set ...
+        if (sub.startsWith('set ')) {
+            if (!manager || !scheduler)
+                return '⚠️ 触发器功能未启用';
+            const args = sub.slice('set '.length);
+            const result = parseTriggerSet(args);
+            if (!result.ok)
+                return `❌ ${result.error}`;
+            const parsed = result.value;
+            const now = Date.now();
+            const nextFireAt = calcNextFireAt(parsed.scheduleType, parsed.scheduleValue, now);
+            // Auto-generate name if not provided
+            const name = parsed.name ?? `trigger-${Date.now().toString(36)}`;
+            const trigger = {
+                id: crypto.randomUUID(),
+                name,
+                scheduleType: parsed.scheduleType,
+                scheduleValue: parsed.scheduleValue,
+                nextFireAt,
+                targetChannel: parsed.targetChannel ?? channel,
+                targetChannelId: parsed.targetChannelId ?? channelId,
+                targetThreadId: parsed.targetThreadId,
+                targetSessionStrategy: parsed.targetSessionStrategy,
+                agentId: parsed.agentId,
+                prompt: parsed.prompt,
+                createdByPeerId: peerId,
+                createdByChannel: channel,
+                fireCount: 0,
+                createdAt: now,
+                updatedAt: now,
+            };
+            try {
+                // Validate name uniqueness before persisting (manager.register writes to disk)
+                // scheduler.register is in-memory only and cannot fail, so order is safe here.
+                // If manager.register throws (duplicate name/ID), nothing is persisted.
+                manager.register(trigger);
+                scheduler.register(trigger);
+            }
+            catch (err) {
+                return `❌ 注册失败：${err.message}`;
+            }
+            const nextStr = new Date(nextFireAt).toLocaleString();
+            return `✅ 触发器已注册：**${name}**\n下次触发：${nextStr}`;
+        }
+        return `❌ 未知子命令。用法：\n/trigger — 查看活跃触发器\n/trigger list — 查看所有触发器\n/trigger set <参数> — 注册触发器\n/trigger cancel <名称> — 取消触发器`;
+    }
     // ── /rewind helpers ──
     async handleRewindList(session, agent) {
         try {
@@ -3005,7 +3255,7 @@ export class CommandHandler {
     static CTL_COMMANDS = [
         '/help', '/status', '/check', '/pwd',
         '/model', '/effort', '/perm', '/agent',
-        '/compact', '/activity', '/file', '/send', '/chatmode', '/restart', '/agentmd', '/bind', '/aid',
+        '/compact', '/file', '/send', '/restart', '/bind', '/aid', '/rpc', '/storage',
         '/rename', '/name', '/evolagent',
     ];
     /** ctl 中仅允许查询形态的指令；写形态（带参）一律拒绝 */
@@ -3112,7 +3362,7 @@ export class CommandHandler {
                 return { ok: false, error: `adapter 未找到: ${session.channel}` };
             try {
                 const replyContext = this.buildCtlReplyContext(session);
-                await adapter.sendText(session.channelId, text, replyContext);
+                await adapter.send(buildEnvelope({ channel: adapter.channelName, channelId: session.channelId, replyContext: replyContext }), { kind: 'result.text', text, isFinal: true });
                 return { ok: true, result: '已发送' };
             }
             catch (err) {
@@ -3125,8 +3375,9 @@ export class CommandHandler {
             const parts = sendArgs.split(/\s+/);
             const filePath = parts[parts.length - 1];
             if (filePath) {
-                const resolved = path.resolve(session.projectPath, filePath);
-                if (!resolved.startsWith(session.projectPath)) {
+                const resolved = path.resolve(session.projectPath, filePath).replace(/\\/g, '/');
+                const projectPath = session.projectPath.replace(/\\/g, '/');
+                if (!resolved.startsWith(projectPath)) {
                     return { ok: false, error: '路径越界：只能发送项目目录下的文件' };
                 }
             }
@@ -3135,7 +3386,8 @@ export class CommandHandler {
         try {
             const result = await this.handle(cmd, session.channel, session.channelId, undefined, // 不发送消息
             userId);
-            return { ok: true, result: result ?? '(无输出)' };
+            const text = typeof result === 'string' ? result : (result && 'text' in result ? result.text : '(无输出)');
+            return { ok: true, result: text || '(无输出)' };
         }
         catch (err) {
             return { ok: false, error: err.message };