evolcore 0.0.1 → 0.0.2

package/dist/core/command/slash-handler.js

@@ -0,0 +1,3056 @@
+import { hasModelSwitcher, hasPermissionController } from '../../agents/runner-types.js';
+import { getCodexEfforts } from '../../agents/codex-runner.js';
+import { buildEnvelope } from '../message/message-utils.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 { checkLatestVersion, getLocalVersion, isLinkedInstall, compareVersions } from '../../utils/npm-ops.js';
+import { loadDaemonConfig } from '../../config-store.js';
+import { read as cfgRead, resolveEffective, routeFieldPath, write as cfgWrite, } from '../../config/config-manager.js';
+import { execAgentAction } from './agent-control.js';
+import { authorizeOperation, buildAuthSubject } from '../auth/auth-gateway.js';
+import { resolvePermissionMode, writeScope } from '../model/config-scope.js';
+import { formatPeerKey } from '../relation/peer-identity.js';
+import { modelMatches } from '../model/model-catalog.js';
+import { formatModelCheck, runModelCheck } from '../model/model-diagnostics.js';
+import { filterModelsForRole, validateModelSelectionForRole } from '../model/model-permission.js';
+import { displaySessionTitle, isSyntheticCliPrompt } from '../session/session-title.js';
+import { chatmodeFieldForPeer, resolveChatModeForField } from '../message/peer-mode.js';
+import { normalizePermissionMode as normalizePermissionModeContract, PUBLIC_PERMISSION_MODES } from '../permission/mode.js';
+import { dispatchToMentionMode } from '../../config/mention-mode.js';
+import { isManagementRole } from '../../config/builtin-roles.js';
+import { isSystemControlChannel } from '../system-channels.js';
+import { guardIdleCommand, guardKnownCommand, guardRoleCommand, guardThreadCommand, isRecognizedSlashCommand, normalizeSlashContent, } from './slash-gate.js';
+const allEfforts = ['low', 'medium', 'high', 'xhigh', 'max'];
+const PERMISSION_MODE_KEYS = PUBLIC_PERMISSION_MODES;
+function defaultSlashChatmode(field) {
+    return field === 'private' ? 'interactive' : 'proactive';
+}
+function slashChatmodeField(session, chatType) {
+    return chatmodeFieldForPeer(session?.chatType ?? chatType, session?.metadata?.peerType);
+}
+function resolveSlashChatmodeTarget(params) {
+    const self = params.selfAID
+        ?? params.session?.selfAID
+        ?? this.getOwningAgent?.(params.channel)?.aid
+        ?? this.resolveSelfAID?.(params.channel);
+    if (!self)
+        return { error: '找不到当前 agent，无法读写 chatmode', code: 'MISSING_AID' };
+    const actualChatType = params.session?.chatType || params.chatType;
+    const peerId = actualChatType === 'group'
+        ? (params.session?.metadata?.groupId || params.channelId)
+        : (params.userId || params.session?.metadata?.peerId || params.channelId);
+    if (!peerId)
+        return { error: '找不到当前对端，无法读写 relation chatmode', code: 'MISSING_PEER' };
+    const channelType = params.session?.channelType
+        || this.resolveChannelType?.(params.channel)
+        || params.channel.split('#')[0];
+    const field = slashChatmodeField(params.session, params.chatType);
+    return {
+        sel: { self, peerKey: formatPeerKey(channelType, peerId) },
+        field,
+        fieldPath: `chatmode.${field}`,
+    };
+}
+function readSlashChatmode(target) {
+    try {
+        const mode = resolveChatModeForField({ ...target.sel, field: target.field });
+        return mode === 'interactive' || mode === 'proactive'
+            ? mode
+            : defaultSlashChatmode(target.field);
+    }
+    catch {
+        return defaultSlashChatmode(target.field);
+    }
+}
+function writeSlashChatmode(target, value) {
+    const route = routeFieldPath(target.fieldPath, 'relation');
+    const cur = cfgRead(route.target, target.sel) || {};
+    const block = cur.chatmode && typeof cur.chatmode === 'object' && !Array.isArray(cur.chatmode)
+        ? { ...cur.chatmode }
+        : {};
+    block[target.field] = value;
+    cur.chatmode = block;
+    cfgWrite(route.target, cur, target.sel);
+}
+function resolveSlashMentionModeTarget(params) {
+    const self = params.selfAID
+        ?? params.session?.selfAID
+        ?? this.getOwningAgent?.(params.channel)?.aid
+        ?? this.resolveSelfAID?.(params.channel);
+    if (!self)
+        return { error: '找不到当前 agent，无法读写 mentionMode', code: 'MISSING_AID' };
+    return { sel: { self }, fieldPath: 'mentionMode' };
+}
+function readSlashMentionMode(target, fallback = null) {
+    try {
+        const mode = resolveEffective(target.sel, { cache: true }).mentionMode;
+        return mode === 'disabled' || mode === 'mention-only' ? mode : fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+function writeSlashMentionMode(target, value) {
+    const route = routeFieldPath(target.fieldPath, 'agent');
+    const cur = cfgRead(route.target, target.sel) || {};
+    if (value === null)
+        delete cur.mentionMode;
+    else
+        cur.mentionMode = value;
+    cfgWrite(route.target, cur, target.sel);
+}
+function resolveSlashRelationTarget(params) {
+    const self = params.selfAID
+        ?? params.session?.selfAID
+        ?? this.getOwningAgent?.(params.channel)?.aid
+        ?? this.resolveSelfAID?.(params.channel);
+    if (!self)
+        return { error: 'missing current agent aid', code: 'MISSING_AID' };
+    const actualChatType = params.session?.chatType || params.chatType;
+    const peerId = actualChatType === 'group'
+        ? (params.session?.metadata?.groupId || params.channelId)
+        : (params.userId || params.session?.metadata?.peerId);
+    if (!peerId)
+        return { error: 'missing current peer id', code: 'MISSING_PEER' };
+    const channelType = params.session?.channelType || this.resolveChannelType?.(params.channel) || params.channel.split('#')[0];
+    return {
+        self,
+        peerKey: formatPeerKey(channelType, peerId),
+        role: params.role,
+    };
+}
+function getAvailableEfforts(agent, model) {
+    if (agent.name === 'claude')
+        return allEfforts;
+    if (agent.name === 'codex')
+        return getCodexEfforts(model);
+    return [];
+}
+function modelDisplayLabel(agent, model) {
+    const full = agent.resolveModelId?.(model);
+    return full && full !== model ? `${model} (${full})` : model;
+}
+function formatIdleTime(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0)
+        return `${days}天前`;
+    if (hours > 0)
+        return `${hours}小时前`;
+    if (minutes > 0)
+        return `${minutes}分钟前`;
+    return '刚刚';
+}
+async function authorizeSlashIntent(params) {
+    const { intent, identity, session, channel, channelId, userId, selfAid, isDaemonOwner } = params;
+    const chatType = session?.chatType ?? params.explicitChatType;
+    const peerKeyId = chatType === 'group'
+        ? (session?.metadata?.groupId || channelId)
+        : userId;
+    const channelType = channel.split('#')[0];
+    const peerKey = channelType && peerKeyId ? formatPeerKey(channelType, peerKeyId) : undefined;
+    const subject = params.subject
+        ? { ...params.subject, role: identity.role, identity }
+        : buildAuthSubject({
+            selfAid,
+            actorId: userId,
+            channel,
+            channelType,
+            channelId,
+            chatType,
+            conversationId: peerKeyId,
+            identity,
+            processOwners: isDaemonOwner && userId ? [userId] : [],
+            fromControlChannel: false,
+        });
+    if (intent.scope === 'relation') {
+        intent.args = buildSlashRelationIntentArgs({ args: intent.args, selfAid: subject.selfAid, peerKey: subject.peerKey ?? peerKey });
+    }
+    const decision = await authorizeOperation({ source: 'slash', intent, subject });
+    if (!decision.allow) {
+        return { kind: 'command.error', text: decision.reason };
+    }
+    return null;
+}
+function triggerOperationForSlash(content) {
+    const subcommand = content.slice('/trigger'.length).trim().split(/\s+/, 1)[0].toLowerCase();
+    if (!subcommand || subcommand === 'list')
+        return 'trigger.list';
+    if (subcommand === 'show')
+        return 'trigger.show';
+    if (subcommand === 'history')
+        return 'trigger.history';
+    if (subcommand === 'set')
+        return 'trigger.create';
+    if (subcommand === 'update')
+        return 'trigger.update';
+    if (subcommand === 'enable' || subcommand === 'disable')
+        return 'trigger.setEnabled';
+    if (subcommand === 'cancel')
+        return 'trigger.cancel';
+    if (subcommand === 'delete' || subcommand === 'remove' || subcommand === 'rm')
+        return 'trigger.delete';
+    if (subcommand === 'run' || subcommand === 'test')
+        return 'trigger.run';
+    return 'trigger.list';
+}
+function buildSlashRelationIntentArgs(params) {
+    const out = { ...(params.args ?? {}) };
+    if (params.selfAid && out.self === undefined)
+        out.self = params.selfAid;
+    if (params.peerKey && out.peer === undefined && out.peerKey === undefined)
+        out.peer = params.peerKey;
+    return out;
+}
+async function canReadSlashModelList(params) {
+    const { identity, session, channel, channelId, userId, selfAid, isDaemonOwner } = params;
+    const chatType = session?.chatType ?? params.explicitChatType;
+    const peerKeyId = chatType === 'group'
+        ? (session?.metadata?.groupId || channelId)
+        : userId;
+    const channelType = channel.split('#')[0];
+    const peerKey = channelType && peerKeyId ? formatPeerKey(channelType, peerKeyId) : undefined;
+    const intent = {
+        operation: 'model.list',
+        scope: 'relation',
+        source: 'slash',
+        args: buildSlashRelationIntentArgs({ selfAid, peerKey }),
+    };
+    const subject = params.subject ?? buildAuthSubject({
+        selfAid,
+        actorId: userId,
+        channel,
+        channelType,
+        channelId,
+        chatType,
+        conversationId: peerKeyId,
+        identity,
+        processOwners: isDaemonOwner && userId ? [userId] : [],
+        fromControlChannel: false,
+    });
+    const decision = await authorizeOperation({ source: 'slash', intent, subject, audit: false });
+    return decision.allow;
+}
+function getAgentBusyInfo(handler, aid, excludeSessionKey) {
+    if (!aid || !handler.agentRegistry)
+        return null;
+    const handle = handler.agentRegistry.get(aid) ?? null;
+    const agentName = handle?.name;
+    if (!agentName)
+        return null;
+    const processing = handler.messageQueue?.getProcessingDetailsByAgent?.(agentName, excludeSessionKey) ?? [];
+    const queueCount = handler.messageQueue?.getQueueLengthByAgent?.(agentName, excludeSessionKey) ?? 0;
+    return { count: processing.length + queueCount, processing, agentName };
+}
+function getAgentBusyCount(handler, aid, excludeSessionKey) {
+    return getAgentBusyInfo(handler, aid, excludeSessionKey)?.count ?? null;
+}
+async function getGitWorkingDirInfo(projectPath) {
+    try {
+        const { execFileSync } = await import('child_process');
+        const isInsideWorkTree = execFileSync('git', ['rev-parse', '--is-inside-work-tree'], {
+            cwd: projectPath,
+            encoding: 'utf8',
+            timeout: 1000,
+            stdio: ['ignore', 'pipe', 'ignore']
+        }).trim();
+        if (isInsideWorkTree !== 'true')
+            return null;
+        // 获取分支名
+        let branch = execFileSync('git', ['branch', '--show-current'], {
+            cwd: projectPath,
+            encoding: 'utf8',
+            timeout: 1000,
+            stdio: ['ignore', 'pipe', 'ignore']
+        }).trim();
+        if (!branch) {
+            branch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+                cwd: projectPath,
+                encoding: 'utf8',
+                timeout: 1000,
+                stdio: ['ignore', 'pipe', 'ignore']
+            }).trim();
+        }
+        if (!branch)
+            return null;
+        // 检查文件状态
+        const statusOutput = execFileSync('git', ['--no-optional-locks', 'status', '--porcelain'], {
+            cwd: projectPath,
+            encoding: 'utf8',
+            timeout: 1000,
+            stdio: ['ignore', 'pipe', 'ignore']
+        });
+        // 解析文件状态统计
+        const stats = { modified: 0, added: 0, deleted: 0, untracked: 0 };
+        const lines = statusOutput.trim().split('\n').filter(Boolean);
+        for (const line of lines) {
+            if (line.length < 2)
+                continue;
+            const index = line[0]; // staged status
+            const worktree = line[1]; // unstaged status
+            if (line.startsWith('??')) {
+                stats.untracked++;
+            }
+            else if (index === 'A') {
+                stats.added++;
+            }
+            else if (index === 'D' || worktree === 'D') {
+                stats.deleted++;
+            }
+            else if (index === 'M' || worktree === 'M' || index === 'R' || index === 'C') {
+                stats.modified++;
+            }
+        }
+        // 组装显示信息
+        const parts = [branch];
+        const isDirty = lines.length > 0;
+        if (isDirty) {
+            parts[0] = branch + '*'; // 分支名后加 * 表示有修改
+            const fileParts = [];
+            if (stats.modified > 0)
+                fileParts.push(`!${stats.modified}`);
+            if (stats.added > 0)
+                fileParts.push(`+${stats.added}`);
+            if (stats.deleted > 0)
+                fileParts.push(`-${stats.deleted}`);
+            if (stats.untracked > 0)
+                fileParts.push(`?${stats.untracked}`);
+            if (fileParts.length > 0) {
+                parts.push(`[${fileParts.join(' ')}]`);
+            }
+        }
+        // 获取 ahead/behind 信息
+        try {
+            const revOutput = execFileSync('git', ['rev-list', '--left-right', '--count', '@{upstream}...HEAD'], { cwd: projectPath, timeout: 1000, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+            const revParts = revOutput.trim().split(/\s+/);
+            if (revParts.length === 2) {
+                const behind = parseInt(revParts[0], 10) || 0;
+                const ahead = parseInt(revParts[1], 10) || 0;
+                if (ahead > 0 || behind > 0) {
+                    const aheadBehind = [];
+                    if (ahead > 0)
+                        aheadBehind.push(`↑${ahead}`);
+                    if (behind > 0)
+                        aheadBehind.push(`↓${behind}`);
+                    parts.push(aheadBehind.join(' '));
+                }
+            }
+        }
+        catch {
+            // No upstream or error, skip ahead/behind
+        }
+        return parts.join(' ');
+    }
+    catch (err) {
+        return null; // git 命令失败时静默返回 null
+    }
+}
+export async function handleSlashCommand(content, channel, channelId, sendMessage, userId, threadId, chatType, source, messageId, selfAID, overrideIdentity, overrideSubject) {
+    // 卡片回调的 chatType 不可靠（飞书 bot 单聊 chatId 也是 oc_ 前缀），
+    // 不应覆盖 session 中已有的正确值
+    if (source === 'card-trigger')
+        chatType = undefined;
+    // 解析身份（按实例名）
+    const narrowedChatType = chatType === 'group' ? 'group' : chatType === 'private' ? 'private' : undefined;
+    const identityConversationId = narrowedChatType === 'group' ? channelId : userId;
+    const resolvedIdentity = overrideIdentity ?? this.sessionManager.resolveIdentity(channel, userId, narrowedChatType, identityConversationId);
+    const authSubject = overrideSubject ?? buildAuthSubject({
+        selfAid: selfAID
+            ?? this.agentRegistry?.resolveByChannel(channel)?.aid
+            ?? this.resolveSelfAID(channel),
+        actorId: userId,
+        channel,
+        channelType: this.resolveChannelType(channel),
+        channelId,
+        chatType: narrowedChatType,
+        conversationId: identityConversationId,
+        identity: resolvedIdentity,
+        processOwners: loadDaemonConfig().owners ?? [],
+        fromControlChannel: false,
+    });
+    const identity = authSubject.identity;
+    const policy = this.getPolicy(channel);
+    // 按当前会话选择 agent 后端。懒加载，避免错配 session 卡住 /baseagent 等恢复命令。
+    const activeSession = await this.sessionManager.getActiveSession(channel, channelId);
+    let activeAgent;
+    const getActiveAgent = () => {
+        if (!activeAgent)
+            activeAgent = this.getAgent(channel, activeSession?.baseagent);
+        return activeAgent;
+    };
+    const getActiveAgentIfAvailable = () => {
+        try {
+            return activeSession ? getActiveAgent() : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    // 规范化命令（将别名转换为完整命令）
+    const normalizedContent = normalizeSlashContent(content);
+    if (normalizedContent !== content) {
+        logger.debug(`[CommandHandler] normalized: "${content}" -> "${normalizedContent}"`);
+    }
+    logger.info(`[CommandHandler] handle: channel=${channel} channelId=${channelId} cmd="${normalizedContent.split(' ')[0]}" user=${userId ?? 'n/a'} role=${identity?.role ?? 'n/a'}`);
+    // Agent-owned 通道：禁止项目切换和 agent 切换
+    // 权限检查：区分用户级命令和管理级命令
+    const isOwner = identity.role === 'owner';
+    const isAdmin = isManagementRole(identity.role);
+    const activeChatType = activeSession?.chatType || (chatType === 'group' ? 'group' : 'private');
+    const getExistingSessionForCommand = async () => {
+        if (threadId)
+            return await this.sessionManager.getThreadSession(channel, channelId, threadId);
+        return activeSession;
+    };
+    const getEffectiveChatmode = (session, fallbackChatType = activeChatType) => {
+        const target = resolveSlashChatmodeTarget.call(this, {
+            session,
+            channel,
+            channelId,
+            userId,
+            selfAID,
+            role: session?.identity?.role || identity.role,
+            chatType: session?.chatType || fallbackChatType,
+        });
+        return 'error' in target
+            ? defaultSlashChatmode(slashChatmodeField(session, fallbackChatType))
+            : readSlashChatmode(target);
+    };
+    const threadGuard = guardThreadCommand(normalizedContent, threadId);
+    if (threadGuard)
+        return threadGuard;
+    // daemon owner 判定（缓存一次，后续 /restart /reload 复用）
+    const isDaemonOwner = authSubject.isDaemonOwner;
+    const authorizeIntent = (params) => authorizeSlashIntent({
+        ...params,
+        subject: authSubject,
+    });
+    // roleGuard 仅对进程级命令（/restart /reload）放行 daemon owner 绕过，
+    // 其余命令严格按 agent-channel 的 isAdmin 判定，不越权。
+    const isProcessLevelSlash = normalizedContent === '/restart' || normalizedContent === '/reload' || normalizedContent.startsWith('/reload ');
+    const roleGuard = guardRoleCommand(normalizedContent, activeChatType, isAdmin || (isDaemonOwner && isProcessLevelSlash));
+    if (roleGuard)
+        return roleGuard;
+    const idleGuard = await guardIdleCommand({
+        content: normalizedContent,
+        threadId,
+        channel,
+        channelId,
+        activeSession,
+        activeAgent: getActiveAgentIfAvailable(),
+        sessionManager: this.sessionManager,
+        messageQueue: this.messageQueue,
+        getAgentForSession: session => this.getAgent(channel, session.baseagent),
+    });
+    if (idleGuard)
+        return idleGuard;
+    const knownGuard = guardKnownCommand(normalizedContent);
+    if (knownGuard)
+        return knownGuard;
+    const isCmd = isRecognizedSlashCommand(normalizedContent);
+    if (!isCmd)
+        return undefined;
+    // /help 命令不需要会话
+    if (normalizedContent === '/help') {
+        const appendProcessCommands = (lines) => {
+            if (!isDaemonOwner)
+                return;
+            lines.push('', '🛠️ 进程级运维：', '  /restart - 重启服务', '  /reload [aid] - 热重载 Agent 配置');
+        };
+        if (!isAdmin && activeChatType === 'group') {
+            const lines = [
+                '可用命令：',
+                '',
+                '其他：',
+                '  /status - 显示会话状态',
+                '  /check - 检查 EvolAgent 实例健康',
+                '  /help - 显示此帮助信息',
+            ];
+            appendProcessCommands(lines);
+            return { kind: 'command.result', text: lines.join('\n') };
+        }
+        if (!isAdmin) {
+            const lines = [
+                '可用命令：',
+                '',
+                '🔄 会话管理：',
+                '  /new [名称] - 创建新会话（清空历史请用此命令，可选命名）',
+                '  /s [cli|名称|序号|uuid] - 列出或切换会话（cli 查看未导入的 CLI 会话）',
+                '  /name <新名称> - 重命名当前会话',
+                '  /del <名称> - 删除指定会话（仅解绑，不删除文件）',
+                '  /status - 显示会话状态',
+                '  /check - 检查 EvolAgent 实例健康',
+                '',
+                '❓ 帮助：',
+                '  /help - 显示此帮助信息',
+            ];
+            appendProcessCommands(lines);
+            return { kind: 'command.result', text: lines.join('\n') };
+        }
+        // admin+ 基础命令
+        const lines = [
+            '可用命令：',
+            '',
+            '📁 项目：',
+            '  /pwd - 显示当前项目路径',
+            '',
+            '🔄 会话管理：',
+            '  /new [名称] - 创建新会话（清空历史请用此命令，可选命名）',
+            '  /s [cli|名称|序号|uuid] - 列出或切换会话（cli 查看未导入的 CLI 会话）',
+            '  /name <新名称> - 重命名当前会话',
+            '  /del <名称> - 删除指定会话（仅解绑，不删除文件）',
+            '  /fork [名称] - 分支当前会话（从当前对话点创建分支）',
+            '  /rewind [N] [chat|file|all] - 查看历史/撤销指定轮次（别名: /rw）',
+            '  /compact - 压缩会话上下文（减少 token 用量）',
+            '',
+            '🤖 Agent 与模型：',
+            '  /baseagent [name] - 查看或切换 Agent 后端（别名: /base）',
+            '  /model [model] - 查看或切换模型',
+            '  /effort [level] - 查看或切换推理强度',
+            '',
+            '💬 聊天设置：',
+            '  /activity [all|text|none] - 查看/控制中间输出显示模式',
+            '  /chatmode [interactive|proactive] - 查看/切换会话模式（被动响应或主动推进）',
+            '  /mentionmode [mention-only|disabled] - 查看/切换群聊 @ 处理模式（仅@响应或全部响应，仅群聊）',
+            '',
+            '🔐 权限管理：',
+            '  /perm - 查看当前权限模式',
+            ...(isAdmin ? ['  权限模式请通过角色策略编辑器修改'] : []),
+            '  /perm allow|always|deny - 审批权限请求',
+            '',
+            '🛠️ 运维：',
+            '  /status - 显示会话状态',
+            '  /stop - 中断当前任务',
+            '  /check - 检查 EvolAgent 实例健康',
+            ...(isOwner ? [
+                '  /observable [true|false] - 查看或切换观察者模式',
+            ] : []),
+            ...(isDaemonOwner ? [
+                '  /restart - 重启服务',
+                '  /reload [aid] - 热重载 Agent 配置',
+            ] : []),
+            ...(!isDaemonOwner && isAdmin ? [
+                '  /reload - 热重载当前 Agent 配置',
+            ] : []),
+            ...(isAdmin ? [
+                '',
+                '🧰 工具：',
+                `  /file ${isOwner ? '[channel] ' : ''}<path> - 发送项目内文件`,
+            ] : []),
+            '',
+            '❓ 帮助：',
+            '  /help - 显示此帮助信息',
+        ];
+        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: '/new', args: '[名称]', description: '创建新会话（清空历史请用此命令，可选命名）', category: '会话管理', roles: ['visitor', 'member', 'admin', 'owner'] });
+        cmds.push({ command: '/s', aliases: ['/session', '/slist'], args: '[cli|名称|序号|uuid]', description: '列出或切换会话', category: '会话管理', roles: ['visitor', 'member', 'admin', 'owner'] });
+        cmds.push({ command: '/name', aliases: ['/rename'], args: '<新名称>', description: '重命名当前会话', category: '会话管理', roles: ['visitor', 'member', 'admin', 'owner'] });
+        cmds.push({ command: '/del', args: '<名称>', description: '删除指定会话（仅解绑，不删除文件）', category: '会话管理', roles: ['visitor', 'member', '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: '/baseagent', aliases: ['/base'], 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', 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: ['visitor', 'member', 'admin', 'owner'] });
+        cmds.push({ command: '/stop', description: '中断当前任务', category: '运维', roles: ['admin', 'owner'] });
+        cmds.push({ command: '/check', description: '检查 EvolAgent 实例健康', category: '运维', roles: ['visitor', 'member', 'admin', 'owner'] });
+        if (isAdmin) {
+            cmds.push({ command: '/activity', args: '[all|text|none]', description: '查看/控制中间输出显示模式', category: '聊天设置', roles: ['admin', 'owner'] });
+        }
+        if (isOwner) {
+            cmds.push({ command: '/observable', args: '[true|false]', description: '查看或切换观察者模式', category: '运维', roles: ['owner'] });
+        }
+        if (isDaemonOwner) {
+            cmds.push({ command: '/restart', description: '重启服务', category: '运维', roles: ['daemon-owner'] });
+            cmds.push({ command: '/reload', args: '[aid]', description: '热重载 Agent 配置', category: '运维', roles: ['daemon-owner'] });
+        }
+        if (!isDaemonOwner && isAdmin) {
+            cmds.push({ command: '/reload', description: '热重载当前 Agent 配置', category: '运维', roles: ['admin', 'owner'] });
+        }
+        if (isAdmin) {
+            cmds.push({ command: '/file', args: isOwner ? '[channel] <path>' : '<path>', description: '发送项目内文件', category: '工具', roles: ['admin', 'owner'] });
+        }
+        // 聊天设置
+        if (isAdmin) {
+            cmds.push({ command: '/chatmode', args: '[interactive|proactive]', description: '查看/切换会话模式（被动响应或主动推进）', category: '聊天设置', roles: ['admin', 'owner'] });
+            cmds.push({ command: '/mentionmode', args: '[mention-only|disabled]', description: '查看/切换群聊 @ 处理模式（仅@响应或全部响应）', category: '聊天设置', roles: ['admin', 'owner'] });
+        }
+        // 交互
+        cmds.push({ command: '/ask', args: '<选项>', description: '回答 Agent 的交互式问题', category: '运维', roles: ['visitor', 'member', 'admin', 'owner'] });
+        // 帮助
+        cmds.push({ command: '/help', description: '显示帮助信息', category: '帮助', roles: ['visitor', 'member', '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();
+        const permissionDecisionLabels = {
+            allow: '✓ 已授权（本次），继续执行……',
+            always: '✓ 已授权（同会话同操作 30 分钟），继续执行……',
+            deny: '✓ 已拒绝',
+        };
+        // Explicit request IDs are globally unique and already bound to an exact
+        // authenticated approver in PermissionGateway. Handle this before session
+        // lookup so an owner can answer a handoff in an otherwise idle AUN chat.
+        const explicitParts = args.split(/\s+/);
+        if (explicitParts.length === 2
+            && (explicitParts[1] === 'allow' || explicitParts[1] === 'always' || explicitParts[1] === 'deny')) {
+            if (!this.permissionGateway) {
+                return { kind: 'command.error', text: '❌ 权限审批未启用' };
+            }
+            const decision = explicitParts[1];
+            const resolved = this.permissionGateway.resolvePermissionByRequestId(explicitParts[0], decision, userId, channel);
+            if (!resolved) {
+                return { kind: 'command.error', text: '❌ 请求不存在、无法验证审批人身份或审批资格已失效' };
+            }
+            return { kind: 'command.result', text: permissionDecisionLabels[decision] };
+        }
+        // 权限查询和审批依附于现有会话；不应隐式创建空会话。
+        const permSession = await getExistingSessionForCommand();
+        if (!permSession)
+            return { kind: 'command.result', text: '当前没有活跃会话' };
+        const permAgent = this.getAgent(channel, permSession.baseagent);
+        // 角色来自会话身份；permissionMode 只从该角色定义解析。
+        const permSelfAid = selfAID ?? permSession.selfAID ?? this.resolveSelfAID(channel);
+        const permChannelType = permSession.channelType ?? this.resolveChannelType(channel);
+        const permPeerKeyId = permSession.chatType === 'group'
+            ? (permSession.metadata?.groupId || channelId)
+            : (userId || permSession.metadata?.peerId);
+        const permPeerKey = (permChannelType && permPeerKeyId)
+            ? formatPeerKey(permChannelType, permPeerKeyId)
+            : undefined;
+        const permRole = permSession.identity?.role || identity.role || 'none';
+        const permScope = { self: permSelfAid || undefined, peerKey: permPeerKey, role: permRole };
+        const permIntentArgs = { self: permScope.self };
+        const authorizePermissionAnswer = async (decision) => authorizeIntent({
+            intent: {
+                operation: 'permission.answer',
+                scope: 'relation',
+                source: 'slash',
+                args: { ...permIntentArgs, value: decision },
+            },
+            identity,
+            session: permSession,
+            explicitChatType: permSession.chatType === 'group' ? 'group' : 'private',
+            channel,
+            channelId,
+            userId,
+            selfAid: permScope.self,
+            isDaemonOwner,
+        });
+        const resolvePermissionAnswer = (requestId, decision) => {
+            if (!this.permissionGateway) {
+                return { kind: 'command.error', text: '❌ 权限审批未启用' };
+            }
+            const pendingIds = this.permissionGateway.getPendingRequests(permSession.id);
+            if (!pendingIds.includes(requestId)) {
+                return { kind: 'command.error', text: `❌ 当前会话没有待审批请求: ${requestId}` };
+            }
+            const resolved = this.permissionGateway.resolvePermissionByRequestId(requestId, decision, userId, channel);
+            if (!resolved) {
+                return { kind: 'command.error', text: '❌ 无法验证审批人身份，或审批资格已失效' };
+            }
+            return { kind: 'command.result', text: permissionDecisionLabels[decision] };
+        };
+        // /perm（无参数）：显示当前角色决定的模式。
+        if (!args) {
+            const authDenied = await authorizeIntent({
+                intent: {
+                    operation: 'permission.current',
+                    scope: 'relation',
+                    source: 'slash',
+                    args: permIntentArgs,
+                },
+                identity,
+                session: permSession,
+                explicitChatType: permSession.chatType === 'group' ? 'group' : 'private',
+                channel,
+                channelId,
+                userId,
+                selfAid: permScope.self,
+                isDaemonOwner,
+            });
+            if (authDenied)
+                return authDenied;
+            const currentMode = normalizePermissionModeContract(resolvePermissionMode(permScope)).mode;
+            return { kind: 'command.result', text: `当前权限模式: ${currentMode}\n由角色 ${permRole} 的策略定义决定。` };
+        }
+        const parts = args.split(/\s+/);
+        // /perm <mode> 不再修改配置；allow/always/deny 仍用于快捷审批。
+        if (parts.length === 1) {
+            const arg = parts[0];
+            // /perm allow|always|deny：快捷审批
+            if (arg === 'allow' || arg === 'always' || arg === 'deny') {
+                const authDenied = await authorizePermissionAnswer(arg);
+                if (authDenied)
+                    return authDenied;
+                if (!this.permissionGateway) {
+                    return { kind: 'command.error', text: '❌ 权限审批未启用' };
+                }
+                const pendingIds = this.permissionGateway.getPendingRequests(permSession.id);
+                if (pendingIds.length === 0) {
+                    return { kind: 'command.error', text: '❌ 当前没有待审批的权限请求' };
+                }
+                if (pendingIds.length > 1) {
+                    return { kind: 'command.error', text: `❌ 当前有 ${pendingIds.length} 个待审批请求，请指定 requestId：\n${pendingIds.map((id) => `  /perm ${id} ${arg}`).join('\n')}` };
+                }
+                const requestId = pendingIds[0];
+                return resolvePermissionAnswer(requestId, arg);
+            }
+            // /perm <mode>：提示改用角色策略编辑器。
+            if (hasPermissionController(permAgent)) {
+                const modes = permAgent.listModes();
+                const matched = modes.find(m => m.key === arg);
+                if (matched) {
+                    return { kind: 'command.error', text: '❌ permissionMode 只能通过角色策略编辑器修改' };
+                }
+            }
+            // 不是已知模式名也不是 allow/deny
+            if (PERMISSION_MODE_KEYS.includes(arg)) {
+                return { kind: 'command.error', text: '❌ permissionMode 只能通过角色策略编辑器修改' };
+            }
+            return { kind: 'command.error', text: `❌ 未知参数: ${arg}\n用法: /perm 或 /perm allow|always|deny` };
+        }
+        return { kind: 'command.error', text: `❌ 未知参数: ${args}\n用法: /perm、/perm allow|always|deny 或 /perm <requestId> allow|always|deny` };
+    }
+    // /ask 命令：回答 AskUserQuestion / ExitPlanMode 的交互式问题
+    if (normalizedContent.startsWith('/ask')) {
+        const args = normalizedContent.slice(4).trim();
+        const askSession = await getExistingSessionForCommand();
+        if (!args) {
+            if (!askSession)
+                return { kind: 'command.result', text: '当前没有待回答的问题' };
+            const pendingIds = this.interactionRouter?.getPending(askSession.id) || [];
+            if (pendingIds.length === 0)
+                return { kind: 'command.result', text: '当前没有待回答的问题' };
+            return { kind: 'command.result', text: `当前有 ${pendingIds.length} 个待回答问题，请回复 /ask <选项>` };
+        }
+        if (!askSession)
+            return { kind: 'command.error', text: '❌ 当前没有待回答的问题' };
+        const fb = await this.handleInteractionFallback('ask', args, askSession.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 resumeSession = await getExistingSessionForCommand();
+        if (!resumeSession)
+            return { kind: 'command.result', text: '当前没有活跃会话' };
+        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) {
+                                    let candidate = '';
+                                    if (typeof msgContent === 'string') {
+                                        candidate = msgContent;
+                                    }
+                                    else if (Array.isArray(msgContent)) {
+                                        const textBlock = msgContent.find((c) => c.type === 'text');
+                                        if (textBlock?.text) {
+                                            candidate = textBlock.text;
+                                        }
+                                    }
+                                    // 跳过 Claude Code 注入的脚手架 prompt，取第一条真人消息
+                                    if (candidate && !isSyntheticCliPrompt(candidate, 'claude')) {
+                                        firstUserMessage = candidate.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 : '未知错误'}` };
+        }
+    }
+    // /baseagent 命令：查看或切换 Agent 后端
+    if (normalizedContent === '/baseagent' || normalizedContent.startsWith('/baseagent ')) {
+        const args = normalizedContent.slice(10).trim();
+        const owningAgent = this.agentRegistry?.resolveByChannel(channel);
+        // 切换（带参）会修改 agent active_baseagent，仅 owner 可操作；无参查询对所有人放开
+        if (args && !isOwner) {
+            return { kind: 'command.error', text: '❌ 无权限：切换 baseagent 仅限 owner 使用' };
+        }
+        const available = this.getAvailableBaseagents(channel);
+        if (!args) {
+            const activeBaseagent = owningAgent?.baseagent || this.parseDefaultBaseagent();
+            // 尝试发送 CommandCard 卡片
+            if (this.interactionRouter && available.length > 1) {
+                const interaction = {
+                    type: 'interaction',
+                    id: `agent-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`,
+                    channelId,
+                    sessionId: activeSession?.id || `agent-${Date.now()}`,
+                    initiatorId: userId,
+                    kind: {
+                        kind: 'command-card',
+                        title: '🔌 切换 Agent',
+                        buttons: available.map((a) => ({
+                            label: a === activeBaseagent ? `✓ ${a}` : a,
+                            command: `/baseagent ${a}`,
+                            style: (a === activeBaseagent ? 'primary' : 'default'),
+                            disabled: a === activeBaseagent,
+                        })),
+                    },
+                };
+                const replyCtx = activeSession ? this.getReplyContext(activeSession) : undefined;
+                const cardResult = await this.sendCommandCard({ channel, channelId, interaction, replyCtx, canWrite: isOwner });
+                if (cardResult === null)
+                    return null;
+                return { kind: 'command.result', text: cardResult };
+            }
+            // 降级：文本
+            const list = available.map((a) => `${a === activeBaseagent ? ' ✓' : '  '} ${a}`).join('\n');
+            const canSwitchAgent = isOwner;
+            if (canSwitchAgent) {
+                return { kind: 'command.result', text: `当前 Baseagent: ${activeBaseagent}\n\n可用:\n${list}\n用法: /baseagent <name>` };
+            }
+            return { kind: 'command.result', text: `当前 Baseagent: ${activeBaseagent}` };
+        }
+        if (!available.includes(args)) {
+            return { kind: 'command.error', text: `❌ 未知 Agent: ${args}\n可用: ${available.join(', ')}` };
+        }
+        if (!owningAgent) {
+            return { kind: 'command.error', text: '❌ 当前 channel 无绑定 agent，无法设置 active_baseagent' };
+        }
+        const previousDefaultBaseagent = owningAgent.baseagent || this.parseDefaultBaseagent();
+        owningAgent.setActiveBaseagent(args);
+        this.eventBus.publish({
+            type: 'agent:baseagent-changed',
+            aid: owningAgent.aid,
+            baseagent: args,
+            previousBaseagent: previousDefaultBaseagent,
+            scope: 'agent',
+            timestamp: Date.now(),
+        });
+        const projectName = this.getProjectName(owningAgent.projectPath);
+        const agentSwitchResponse = [
+            `✓ 已设置 Baseagent: ${args}`,
+            `  Agent: ${owningAgent.name}`,
+            `  项目: ${projectName}`,
+        ].join('\n');
+        return { kind: 'command.result', text: agentSwitchResponse };
+    }
+    // /model 命令：查看或切换模型/推理强度
+    if (normalizedContent.startsWith('/model')) {
+        const args = normalizedContent.slice(6).trim();
+        if (args === 'reset' || args === 'check') {
+            const modelSession = await getExistingSessionForCommand();
+            const fallbackBaseagent = modelSession?.baseagent || this.agentRegistry?.resolveByChannel(channel)?.baseagent || this.parseDefaultBaseagent();
+            const modelAgent = this.getAgent(channel, fallbackBaseagent);
+            const modelChatType = modelSession?.chatType
+                ?? (chatType === 'private' || chatType === 'group' ? chatType : undefined);
+            const peerKeyId = modelChatType === 'group'
+                ? (modelSession?.metadata?.groupId || channelId)
+                : userId;
+            const channelType = this.resolveChannelType(channel);
+            const peerKey = channelType && peerKeyId ? formatPeerKey(channelType, peerKeyId) : undefined;
+            const self = selfAID ?? modelSession?.selfAID ?? this.resolveSelfAID(channel);
+            if (args === 'check') {
+                const checkAuthDenied = await authorizeIntent({
+                    intent: {
+                        operation: 'model.check',
+                        scope: 'agent',
+                        source: 'slash',
+                        args: self ? { self } : {},
+                    },
+                    identity,
+                    session: modelSession,
+                    explicitChatType: modelChatType,
+                    channel,
+                    channelId,
+                    userId,
+                    selfAid: self,
+                    isDaemonOwner,
+                });
+                if (checkAuthDenied)
+                    return checkAuthDenied;
+                try {
+                    const result = await runModelCheck({
+                        self,
+                        peerKey,
+                        role: modelSession?.identity?.role || identity.role,
+                        baseagent: modelAgent.name,
+                    });
+                    return {
+                        kind: 'command.result',
+                        text: formatModelCheck(result),
+                        structured: {
+                            ok: true,
+                            steps: result.steps,
+                            configuredModel: result.configuredModel ?? null,
+                            configModelAvailable: result.configModelAvailable ?? null,
+                            availableModels: result.availableModels,
+                            catalogSource: result.catalogSource,
+                        },
+                    };
+                }
+                catch (error) {
+                    return { kind: 'command.error', text: `模型网关检查失败: ${error instanceof Error ? error.message : String(error)}` };
+                }
+            }
+            const resetAuthDenied = await authorizeIntent({
+                intent: {
+                    operation: 'model.reset',
+                    scope: 'relation',
+                    source: 'slash',
+                    args: buildSlashRelationIntentArgs({ selfAid: self, peerKey }),
+                },
+                identity,
+                session: modelSession,
+                explicitChatType: modelChatType,
+                channel,
+                channelId,
+                userId,
+                selfAid: self,
+                isDaemonOwner,
+            });
+            if (resetAuthDenied)
+                return resetAuthDenied;
+            const target = resolveSlashRelationTarget.call(this, {
+                session: modelSession,
+                channel,
+                channelId,
+                userId,
+                selfAID: self,
+                role: modelSession?.identity?.role || identity.role,
+                chatType: modelChatType,
+            });
+            if ('error' in target)
+                return { kind: 'command.error', text: `Cannot locate relation scope: ${target.error}` };
+            try {
+                writeScope('relation', target, modelAgent.name, { model: null, effort: null });
+            }
+            catch (error) {
+                return { kind: 'command.error', text: `Failed to reset relation model settings: ${error?.message || error}` };
+            }
+            this.eventBus.publish({
+                type: 'runner:model-changed',
+                sessionId: modelSession?.id,
+                agentName: this.agentRegistry?.resolveByChannel(channel)?.name,
+                baseagent: modelSession?.baseagent || modelAgent.name,
+                timestamp: Date.now(),
+            });
+            return {
+                kind: 'command.result',
+                text: '✓ 已清除当前关系的模型和推理强度设置',
+                structured: { ok: true, scope: 'relation', self: target.self, peerKey: target.peerKey },
+            };
+        }
+        if (!args || args === 'list' || args === 'current') {
+            const modelSession = await getExistingSessionForCommand();
+            const fallbackBaseagent = modelSession?.baseagent || this.agentRegistry?.resolveByChannel(channel)?.baseagent || this.parseDefaultBaseagent();
+            const modelAgent = this.getAgent(channel, fallbackBaseagent);
+            const modelTarget = resolveSlashRelationTarget.call(this, {
+                session: modelSession,
+                channel,
+                channelId,
+                userId,
+                selfAID,
+                role: modelSession?.identity?.role || identity.role,
+                chatType,
+            });
+            const modelSelector = 'error' in modelTarget
+                ? { self: selfAID ?? modelSession?.selfAID ?? this.resolveSelfAID(channel) }
+                : modelTarget;
+            if (args === 'list' || args === 'current') {
+                const readAuthDenied = await authorizeIntent({
+                    intent: {
+                        operation: args === 'list' ? 'model.list' : 'model.current',
+                        scope: 'relation',
+                        source: 'slash',
+                        args: 'error' in modelTarget
+                            ? { self: modelSelector.self }
+                            : buildSlashRelationIntentArgs({ selfAid: modelTarget.self, peerKey: modelTarget.peerKey }),
+                    },
+                    identity,
+                    session: modelSession,
+                    explicitChatType: modelSession?.chatType,
+                    channel,
+                    channelId,
+                    userId,
+                    selfAid: modelSelector.self,
+                    isDaemonOwner,
+                });
+                if (readAuthDenied)
+                    return readAuthDenied;
+            }
+            let modelConfig = {};
+            try {
+                modelConfig = (resolveEffective(modelSelector, { cache: true }).baseagents || {})[fallbackBaseagent] || {};
+            }
+            catch { }
+            const configuredModel = modelConfig.model;
+            const configuredEffort = modelConfig[fallbackBaseagent === 'codex' ? 'reasoning' : 'effort'];
+            const rawModels = hasModelSwitcher(modelAgent) ? await modelAgent.listModels() : [];
+            const models = hasModelSwitcher(modelAgent)
+                ? filterModelsForRole(identity.role, fallbackBaseagent, rawModels, modelAgent.resolveModelId?.bind(modelAgent))
+                : rawModels;
+            const currentModel = hasModelSwitcher(modelAgent) ? (configuredModel || modelAgent.getModel()) : modelAgent.name;
+            const efforts = getAvailableEfforts(modelAgent, currentModel);
+            const currentEffort = configuredEffort ?? modelAgent.getEffort?.() ?? 'auto';
+            const canReadModelList = await canReadSlashModelList({
+                subject: authSubject,
+                identity,
+                session: modelSession,
+                explicitChatType: chatType === 'private' || chatType === 'group' ? chatType : undefined,
+                channel,
+                channelId,
+                userId,
+                selfAid: selfAID ?? this.resolveSelfAID(channel),
+                isDaemonOwner,
+            });
+            // 尝试发送 CommandCard 卡片
+            if (!args && canReadModelList && this.interactionRouter && models.length > 0) {
+                const interaction = {
+                    type: 'interaction',
+                    id: `model-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`,
+                    channelId,
+                    sessionId: modelSession?.id || `model-${Date.now()}`,
+                    initiatorId: userId,
+                    kind: {
+                        kind: 'command-card',
+                        title: '🤖 切换模型',
+                        buttons: models.map((m) => {
+                            const display = modelDisplayLabel(modelAgent, m);
+                            return {
+                                label: modelMatches(modelAgent, m, currentModel) ? `✓ ${display}` : display,
+                                command: `/model ${m}`,
+                                style: (modelMatches(modelAgent, m, currentModel) ? 'primary' : 'default'),
+                                disabled: modelMatches(modelAgent, m, currentModel),
+                            };
+                        }),
+                    },
+                };
+                const replyCtx = modelSession ? this.getReplyContext(modelSession) : undefined;
+                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) => `  ${modelMatches(modelAgent, m, currentModel) ? '✓' : ' '} ${modelDisplayLabel(modelAgent, m)}`).join('\n');
+            const effortHint = efforts.length > 0
+                ? `\n推理强度: ${currentEffort === 'auto' ? 'auto (SDK默认)' : currentEffort}  (使用 /effort 调整)`
+                : '';
+            if (args === 'current') {
+                return {
+                    kind: 'command.result',
+                    text: `当前模型: ${modelDisplayLabel(modelAgent, currentModel)}${effortHint}`,
+                    structured: { ok: true, model: currentModel, effort: currentEffort, baseagent: fallbackBaseagent },
+                };
+            }
+            if (canReadModelList) {
+                const usage = !args && isAdmin ? '\n\n用法: /model <模型>' : '';
+                return {
+                    kind: 'command.result',
+                    text: `当前模型: ${modelDisplayLabel(modelAgent, currentModel)}${effortHint}\n\n可用模型：\n${modelList}${usage}`,
+                    ...(args === 'list' ? { structured: { ok: true, model: currentModel, effort: currentEffort, baseagent: fallbackBaseagent, models } } : {}),
+                };
+            }
+            return { kind: 'command.result', text: `当前模型: ${modelDisplayLabel(modelAgent, currentModel)}${effortHint}` };
+        }
+        const modelSession = await getExistingSessionForCommand();
+        const modelChatType = modelSession?.chatType
+            ?? (chatType === 'private' || chatType === 'group' ? chatType : undefined);
+        const peerKeyId = modelChatType === 'group'
+            ? (modelSession?.metadata?.groupId || channelId)
+            : userId;
+        const channelType = this.resolveChannelType(channel);
+        const peerKey = channelType && peerKeyId ? formatPeerKey(channelType, peerKeyId) : undefined;
+        const earlyUseAuthDenied = await authorizeIntent({
+            intent: {
+                operation: 'model.use',
+                scope: 'relation',
+                source: 'slash',
+                args: buildSlashRelationIntentArgs({
+                    args: { model: args.split(/\s+/)[0] },
+                    selfAid: selfAID ?? this.resolveSelfAID(channel),
+                    peerKey,
+                }),
+            },
+            identity,
+            session: modelSession,
+            explicitChatType: modelChatType,
+            channel,
+            channelId,
+            userId,
+            selfAid: selfAID ?? this.resolveSelfAID(channel),
+            isDaemonOwner,
+        });
+        if (earlyUseAuthDenied) {
+            return {
+                kind: 'command.error',
+                text: earlyUseAuthDenied.text.includes('无权限') ? earlyUseAuthDenied.text : `❌ 无权限：${earlyUseAuthDenied.text}`,
+            };
+        }
+        // 切换模型写入 agent/baseagent 配置；没有活跃会话时也不应创建空会话。
+        const fallbackBaseagent = modelSession?.baseagent || this.agentRegistry?.resolveByChannel(channel)?.baseagent || this.parseDefaultBaseagent();
+        const modelAgent = this.getAgent(channel, fallbackBaseagent);
+        const relationTarget = resolveSlashRelationTarget.call(this, {
+            session: modelSession,
+            channel,
+            channelId,
+            userId,
+            selfAID,
+            role: modelSession?.identity?.role || identity.role,
+            chatType: modelChatType,
+        });
+        const modelSelector = 'error' in relationTarget
+            ? { self: selfAID ?? modelSession?.selfAID ?? this.resolveSelfAID(channel) }
+            : relationTarget;
+        let configuredModel;
+        try {
+            configuredModel = (resolveEffective(modelSelector, { cache: true }).baseagents || {})[fallbackBaseagent]?.model;
+        }
+        catch { }
+        const models = hasModelSwitcher(modelAgent) ? await modelAgent.listModels() : [];
+        const allowedModels = hasModelSwitcher(modelAgent)
+            ? filterModelsForRole(identity.role, fallbackBaseagent, models, modelAgent.resolveModelId?.bind(modelAgent))
+            : models;
+        const parts = args.split(/\s+/);
+        let newModel;
+        let newEffort;
+        if (parts.length === 1) {
+            const arg = parts[0];
+            const currentModel = hasModelSwitcher(modelAgent) ? (configuredModel || modelAgent.getModel()) : modelAgent.name;
+            const efforts = getAvailableEfforts(modelAgent, currentModel);
+            // effort 相关参数统一转发到 /effort
+            if (efforts.includes(arg) || arg === 'auto') {
+                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 { kind: 'command.error', text: `⚠️ 请使用 /effort ${arg} 调整推理强度` };
+            }
+            else {
+                const resolvedArg = hasModelSwitcher(modelAgent) ? (modelAgent.resolveModelId?.(arg) ?? arg) : arg;
+                if (models.includes(resolvedArg)) {
+                    newModel = resolvedArg;
+                }
+                else if (models.includes(arg)) {
+                    newModel = arg;
+                }
+                else {
+                    const modelList = allowedModels.map((m) => `  ${modelMatches(modelAgent, m, currentModel) ? '✓' : ' '} ${modelDisplayLabel(modelAgent, m)}`).join('\n');
+                    const effortHint = efforts.length > 0 ? `\n\n推理强度请使用 /effort 命令` : '';
+                    return { kind: 'command.error', text: `❌ 无效参数: ${arg}\n\n可用模型：\n${modelList}${effortHint}` };
+                }
+            }
+        }
+        else {
+            // 双参数：model effort
+            const [modelArgRaw, effortArg] = parts;
+            const modelArg = hasModelSwitcher(modelAgent)
+                ? (models.includes(modelArgRaw) ? modelArgRaw : (modelAgent.resolveModelId?.(modelArgRaw) ?? modelArgRaw))
+                : modelArgRaw;
+            if (!models.includes(modelArg)) {
+                return { kind: 'command.error', text: `❌ 无效的模型ID: ${modelArgRaw}` };
+            }
+            const targetEfforts = getAvailableEfforts(modelAgent, modelArg);
+            if (targetEfforts.length === 0) {
+                return { kind: 'command.error', text: `⚠️ ${modelArg} 不支持推理强度设置` };
+            }
+            if (!targetEfforts.includes(effortArg)) {
+                const errorLabel = allEfforts.includes(effortArg) ? '⚠️' : '❌';
+                return { kind: 'command.result', text: `${errorLabel} ${modelArg} 不支持 ${effortArg} 推理强度\n可选: ${targetEfforts.join(' / ')}` };
+            }
+            newModel = modelArg;
+            newEffort = effortArg;
+        }
+        // 优先写关系级覆盖；只有无法定位关系且具备管理权限时才回退到 runner/agent 级。
+        if (newModel) {
+            const modelChatType = modelSession?.chatType
+                ?? (chatType === 'private' || chatType === 'group' ? chatType : undefined);
+            const peerKeyId = modelChatType === 'group'
+                ? (modelSession?.metadata?.groupId || channelId)
+                : userId;
+            const channelType = this.resolveChannelType(channel);
+            const peerKey = channelType && peerKeyId ? formatPeerKey(channelType, peerKeyId) : undefined;
+            const useAuthDenied = await authorizeIntent({
+                intent: {
+                    operation: 'model.use',
+                    scope: 'relation',
+                    source: 'slash',
+                    args: buildSlashRelationIntentArgs({
+                        args: { model: newModel },
+                        selfAid: selfAID ?? this.resolveSelfAID(channel),
+                        peerKey,
+                    }),
+                },
+                identity,
+                session: modelSession,
+                explicitChatType: modelChatType,
+                channel,
+                channelId,
+                userId,
+                selfAid: selfAID ?? this.resolveSelfAID(channel),
+                isDaemonOwner,
+            });
+            if (useAuthDenied)
+                return useAuthDenied;
+            const decision = validateModelSelectionForRole({
+                role: modelSession?.identity?.role || identity.role,
+                baseagent: fallbackBaseagent,
+                requestedModel: newModel,
+                models,
+                resolveModelId: modelAgent.resolveModelId?.bind(modelAgent),
+            });
+            if (!decision.ok) {
+                return { kind: 'command.error', text: decision.message || `invalid model: ${newModel}` };
+            }
+            newModel = decision.model || newModel;
+        }
+        const changes = [];
+        if (!('error' in relationTarget)) {
+            try {
+                writeScope('relation', {
+                    self: relationTarget.self,
+                    peerKey: relationTarget.peerKey,
+                    role: relationTarget.role,
+                }, modelAgent.name, {
+                    model: newModel,
+                    effort: newEffort,
+                });
+            }
+            catch (e) {
+                return { kind: 'command.error', text: `Failed to update relation model settings: ${e?.message || e}` };
+            }
+            if (newModel)
+                changes.push(`模型: ${newModel}`);
+            if (newEffort)
+                changes.push(`推理强度: ${newEffort}`);
+            this.eventBus.publish({
+                type: 'runner:model-changed',
+                sessionId: modelSession?.id,
+                agentName: this.agentRegistry?.resolveByChannel(channel)?.name,
+                baseagent: modelSession?.baseagent || modelAgent.name,
+                model: newModel,
+                effort: newEffort,
+                timestamp: Date.now()
+            });
+            if (this.shouldSuppressCardTriggerResult(source, channel))
+                return null;
+            return { kind: 'command.result', text: `✓ 已切换\n  ${changes.join('\n  ')}` };
+        }
+        if (!isAdmin) {
+            return { kind: 'command.error', text: `Cannot locate relation scope: ${relationTarget.error}` };
+        }
+        if (newModel) {
+            modelAgent.setModel?.(newModel);
+            this.eventBus.publish({
+                type: 'runner:model-changed',
+                sessionId: modelSession?.id,
+                agentName: this.agentRegistry?.resolveByChannel(channel)?.name,
+                baseagent: modelSession?.baseagent || modelAgent.name,
+                model: newModel,
+                effort: newEffort,
+                timestamp: Date.now()
+            });
+            changes.push(`模型: ${newModel}`);
+        }
+        if (newEffort) {
+            modelAgent.setEffort?.(newEffort);
+            if (!newModel) {
+                this.eventBus.publish({
+                    type: 'runner:model-changed',
+                    sessionId: modelSession?.id,
+                    agentName: this.agentRegistry?.resolveByChannel(channel)?.name,
+                    baseagent: modelSession?.baseagent || modelAgent.name,
+                    effort: newEffort,
+                    timestamp: Date.now(),
+                });
+            }
+            changes.push(`推理强度: ${newEffort}`);
+        }
+        // 持久化：agent-owned channel 写到 agent.json；default 走原"就近原则"
+        if (newModel) {
+            const err = this.persistBaseagentModel(channel, modelAgent.name, newModel);
+            if (err)
+                return { kind: 'command.result', text: `${err}\n已更新运行时配置，但未持久化` };
+        }
+        if (newEffort) {
+            const err = this.persistBaseagentEffort(channel, modelAgent.name, newEffort);
+            if (err)
+                return { kind: 'command.result', text: `${err}\n已更新运行时配置，但未持久化` };
+        }
+        if (this.shouldSuppressCardTriggerResult(source, channel))
+            return null;
+        return { kind: 'command.result', text: `✓ 已切换\n  ${changes.join('\n  ')}` };
+    }
+    // /effort 命令：查看或切换推理强度
+    if (normalizedContent.startsWith('/effort')) {
+        const args = normalizedContent.slice(7).trim();
+        if (!args) {
+            const effortSession = await getExistingSessionForCommand();
+            const fallbackBaseagent = effortSession?.baseagent || this.agentRegistry?.resolveByChannel(channel)?.baseagent || this.parseDefaultBaseagent();
+            const effortAgent = this.getAgent(channel, fallbackBaseagent);
+            const effortTarget = resolveSlashRelationTarget.call(this, {
+                session: effortSession,
+                channel,
+                channelId,
+                userId,
+                selfAID,
+                role: effortSession?.identity?.role || identity.role,
+                chatType,
+            });
+            const effortSelector = 'error' in effortTarget
+                ? { self: selfAID ?? effortSession?.selfAID ?? this.resolveSelfAID(channel) }
+                : effortTarget;
+            let modelConfig = {};
+            try {
+                modelConfig = (resolveEffective(effortSelector, { cache: true }).baseagents || {})[fallbackBaseagent] || {};
+            }
+            catch { }
+            const configuredModel = modelConfig.model;
+            const configuredEffort = modelConfig[fallbackBaseagent === 'codex' ? 'reasoning' : 'effort'];
+            const currentModel = hasModelSwitcher(effortAgent) ? (configuredModel || effortAgent.getModel()) : effortAgent.name;
+            const efforts = getAvailableEfforts(effortAgent, currentModel);
+            const currentEffort = configuredEffort ?? effortAgent.getEffort?.() ?? 'auto';
+            if (efforts.length === 0) {
+                return { kind: 'command.error', text: '⚠️ 当前模型不支持推理强度设置' };
+            }
+            // /effort（无参数）：显示当前推理强度 + 发送 CommandCard 卡片
+            if (this.interactionRouter) {
+                const allItems = [...efforts, 'auto'];
+                const interaction = {
+                    type: 'interaction',
+                    id: `effort-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`,
+                    channelId,
+                    sessionId: effortSession?.id || `effort-${Date.now()}`,
+                    initiatorId: userId,
+                    kind: {
+                        kind: 'command-card',
+                        title: '⚡ 推理强度',
+                        buttons: allItems.map(e => ({
+                            label: e === currentEffort ? `✓ ${e}` : e,
+                            command: `/effort ${e}`,
+                            style: (e === currentEffort ? 'primary' : 'default'),
+                            disabled: e === currentEffort,
+                        })),
+                    },
+                };
+                const replyCtx = effortSession ? this.getReplyContext(effortSession) : undefined;
+                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 effortOptions = [...efforts, 'auto'].join(' / ');
+            if (isAdmin) {
+                return { kind: 'command.result', text: `推理强度: ${effortDisplay}  可选: ${effortOptions}  用法: /effort <level>` };
+            }
+            return { kind: 'command.result', text: `推理强度: ${effortDisplay}` };
+        }
+        const effortSession = await getExistingSessionForCommand();
+        const fallbackBaseagent = effortSession?.baseagent || this.agentRegistry?.resolveByChannel(channel)?.baseagent || this.parseDefaultBaseagent();
+        const effortAgent = this.getAgent(channel, fallbackBaseagent);
+        const relationTarget = resolveSlashRelationTarget.call(this, {
+            session: effortSession,
+            channel,
+            channelId,
+            userId,
+            selfAID,
+            role: effortSession?.identity?.role || identity.role,
+            chatType,
+        });
+        const effortSelector = 'error' in relationTarget
+            ? { self: selfAID ?? effortSession?.selfAID ?? this.resolveSelfAID(channel) }
+            : relationTarget;
+        let modelConfig = {};
+        try {
+            modelConfig = (resolveEffective(effortSelector, { cache: true }).baseagents || {})[fallbackBaseagent] || {};
+        }
+        catch { }
+        const configuredModel = modelConfig.model;
+        const configuredEffort = modelConfig[fallbackBaseagent === 'codex' ? 'reasoning' : 'effort'];
+        const currentModel = hasModelSwitcher(effortAgent) ? (configuredModel || effortAgent.getModel()) : effortAgent.name;
+        const efforts = getAvailableEfforts(effortAgent, currentModel);
+        const currentEffort = configuredEffort ?? effortAgent.getEffort?.() ?? 'auto';
+        if (efforts.length === 0) {
+            return { kind: 'command.error', text: '⚠️ 当前模型不支持推理强度设置' };
+        }
+        // Non-admin users write effort overrides to their relation scope below.
+        // /effort auto：恢复 SDK 默认
+        if (args === 'auto') {
+            if (!('error' in relationTarget)) {
+                try {
+                    writeScope('relation', {
+                        self: relationTarget.self,
+                        peerKey: relationTarget.peerKey,
+                        role: relationTarget.role,
+                    }, effortAgent.name, { effort: null });
+                }
+                catch (e) {
+                    return { kind: 'command.error', text: `Failed to update relation effort: ${e?.message || e}` };
+                }
+                this.eventBus.publish({
+                    type: 'runner:model-changed',
+                    sessionId: effortSession?.id,
+                    agentName: this.agentRegistry?.resolveByChannel(channel)?.name,
+                    baseagent: effortSession?.baseagent || effortAgent.name,
+                    effort: 'auto',
+                    timestamp: Date.now(),
+                });
+                if (this.shouldSuppressCardTriggerResult(source, channel))
+                    return null;
+                return { kind: 'command.result', text: '✓ 推理强度已恢复为 auto (SDK默认)' };
+            }
+            if (!isAdmin)
+                return { kind: 'command.error', text: `Cannot locate relation scope: ${relationTarget.error}` };
+            effortAgent.setEffort?.(undefined);
+            const err = this.persistBaseagentEffort(channel, effortAgent.name, undefined);
+            if (err)
+                return { kind: 'command.result', text: `${err}\n已更新运行时配置，但未持久化` };
+            this.eventBus.publish({
+                type: 'runner:model-changed',
+                sessionId: effortSession?.id,
+                agentName: this.agentRegistry?.resolveByChannel(channel)?.name,
+                baseagent: effortSession?.baseagent || effortAgent.name,
+                effort: 'auto',
+                timestamp: Date.now(),
+            });
+            if (this.shouldSuppressCardTriggerResult(source, channel))
+                return null;
+            return { kind: 'command.result', text: '✓ 推理强度已恢复为 auto (SDK默认)' };
+        }
+        // /effort <level>：切换推理强度
+        if (!efforts.includes(args)) {
+            if (allEfforts.includes(args)) {
+                return { kind: 'command.error', text: `⚠️ ${currentModel} 不支持 ${args} 推理强度\n可选: ${efforts.join(' / ')}` };
+            }
+            return { kind: 'command.error', text: `❌ 无效参数: ${args}\n可选: ${efforts.join(' / ')} / auto` };
+        }
+        const newEffort = args;
+        if (!('error' in relationTarget)) {
+            try {
+                writeScope('relation', {
+                    self: relationTarget.self,
+                    peerKey: relationTarget.peerKey,
+                    role: relationTarget.role,
+                }, effortAgent.name, { effort: newEffort });
+            }
+            catch (e) {
+                return { kind: 'command.error', text: `Failed to update relation effort: ${e?.message || e}` };
+            }
+            this.eventBus.publish({
+                type: 'runner:model-changed',
+                sessionId: effortSession?.id,
+                agentName: this.agentRegistry?.resolveByChannel(channel)?.name,
+                baseagent: effortSession?.baseagent || effortAgent.name,
+                effort: newEffort,
+                timestamp: Date.now(),
+            });
+            if (this.shouldSuppressCardTriggerResult(source, channel))
+                return null;
+            return { kind: 'command.result', text: `✓ 推理强度: ${newEffort}` };
+        }
+        if (!isAdmin)
+            return { kind: 'command.error', text: `Cannot locate relation scope: ${relationTarget.error}` };
+        effortAgent.setEffort?.(newEffort);
+        const err = this.persistBaseagentEffort(channel, effortAgent.name, newEffort);
+        if (err)
+            return { kind: 'command.result', text: `${err}\n已更新运行时配置，但未持久化` };
+        this.eventBus.publish({
+            type: 'runner:model-changed',
+            sessionId: effortSession?.id,
+            agentName: this.agentRegistry?.resolveByChannel(channel)?.name,
+            baseagent: effortSession?.baseagent || effortAgent.name,
+            effort: newEffort,
+            timestamp: Date.now(),
+        });
+        if (this.shouldSuppressCardTriggerResult(source, channel))
+            return null;
+        return { kind: 'command.result', text: `✓ 推理强度: ${newEffort}` };
+    }
+    // /reload [aid] — 热重载 agent 配置
+    // daemon owner：可 reload 任意 aid（无参则 reload 自身所在 agent）
+    // agent channel owner/admin：仅可 reload 自身 agent
+    if (normalizedContent === '/reload' || normalizedContent.startsWith('/reload ')) {
+        const aidArg = normalizedContent.slice('/reload'.length).trim() || undefined;
+        const selfAid = this.agentRegistry?.resolveByChannel(channel)?.aid;
+        // agent channel 的 owner/admin 不能跨 agent reload；先返回领域内错误，避免落到
+        // 底层 daemon-owner 约束的英文 reason。
+        if (!isDaemonOwner && aidArg && aidArg !== selfAid) {
+            return { kind: 'command.error', text: '❌ 无权限：跨 agent reload 仅限 daemon owner 使用' };
+        }
+        const reloadScope = 'agent';
+        const authDenied = await authorizeIntent({
+            intent: {
+                operation: 'agent.reload',
+                scope: reloadScope,
+                source: 'slash',
+                args: { ...(aidArg ? { aid: aidArg } : {}), ...(selfAid ? { self: selfAid } : {}) },
+                dangerous: true,
+            },
+            identity: isDaemonOwner ? { ...identity, role: 'owner' } : identity,
+            session: activeSession,
+            channel,
+            channelId,
+            userId,
+            selfAid,
+            isDaemonOwner,
+        });
+        if (authDenied)
+            return authDenied;
+        // 权限判断：daemon owner 或 agent channel 的 owner/admin
+        if (!isDaemonOwner && !isAdmin) {
+            return { kind: 'command.error', text: '❌ 无权限：/reload 仅限 daemon owner 或 agent owner/admin 使用' };
+        }
+        const targetAid = aidArg ?? selfAid;
+        if (!targetAid) {
+            return { kind: 'command.error', text: '❌ 无法确定目标 agent，请指定 aid：/reload <aid>' };
+        }
+        // 繁忙检查（同 menu /agent reload）
+        const busyInfo = getAgentBusyInfo(this, targetAid);
+        if (busyInfo && busyInfo.count > 0) {
+            const processingLines = busyInfo.processing.map(p => {
+                const sessionId = p.queueKey.split('::')[0] || '?';
+                return `  · ${sessionId.slice(0, 32)}...`;
+            }).join('\n');
+            return { kind: 'command.error', text: `❌ 该 Agent 有 ${busyInfo.count} 个任务执行中，无法 reload。\n\n处理中：\n${processingLines}\n\n等待任务完成后重试，通常 30-60 秒。` };
+        }
+        const res = await execAgentAction('reload', { aid: targetAid }, userId ?? '', this.eventBus);
+        if ('error' in res)
+            return { kind: 'command.error', text: `❌ reload 失败：${res.error}` };
+        return { kind: 'command.result', text: `✅ Agent ${targetAid} 配置已重载` };
+    }
+    // /agent, /aid, /rpc, /storage — 仅限顶级 CLI 调用，slash 输入拒绝
+    if (normalizedContent === '/agent' || normalizedContent.startsWith('/agent ') ||
+        normalizedContent === '/aid' || normalizedContent.startsWith('/aid ') ||
+        normalizedContent === '/rpc' || normalizedContent.startsWith('/rpc ') ||
+        normalizedContent === '/storage' || normalizedContent.startsWith('/storage ')) {
+        return { kind: 'command.error', text: '❌ 此命令仅限 CLI 调用，不支持 slash 输入' };
+    }
+    if (normalizedContent === '/observable' || normalizedContent.startsWith('/observable ')) {
+        if (!isOwner)
+            return { kind: 'command.error', text: '❌ 观察者模式仅限 owner 查看和开关' };
+        const value = normalizedContent.slice('/observable'.length).trim();
+        if (!value) {
+            const result = await this.execMenuQuery('/observable', channel, channelId, userId, undefined, narrowedChatType, false, identity);
+            if ('error' in result)
+                return { kind: 'command.error', text: `❌ ${result.error}` };
+            return { kind: 'command.result', text: `观察者模式: ${result.data.observable ? 'true' : 'false'}  用法: /observable <true|false>` };
+        }
+        if (value !== 'true' && value !== 'false') {
+            return { kind: 'command.error', text: `❌ 无效参数: ${value}\n用法: /observable <true|false>` };
+        }
+        const result = await this.execMenuUpdate('/observable', value, channel, channelId, userId, identity, false);
+        if ('error' in result)
+            return { kind: 'command.error', text: `❌ ${result.error}` };
+        if (this.shouldSuppressCardTriggerResult(source, channel))
+            return null;
+        return { kind: 'command.result', text: `✅ 观察者模式: ${result.data.observable ? 'true' : 'false'}` };
+    }
+    if (normalizedContent === '/activity' || normalizedContent.startsWith('/activity ')) {
+        const activityArg = normalizedContent.slice(9).trim();
+        // 带参（写操作）需 admin+；无参查询对所有人开放（owner 门在具体切换点还有一道）
+        if (activityArg && !isAdmin)
+            return { kind: 'command.error', text: '❌ 无权限：此命令仅限管理员使用' };
+        // proactive 模式下流式输出全部静默，activity 配置无意义
+        if (getEffectiveChatmode(activeSession) === 'proactive') {
+            return { kind: 'command.error', text: '❌ 当前会话为 proactive 模式，不支持 activity 配置（流式输出已全部静默）' };
+        }
+        const modeMap = {
+            all: 'all',
+            text: 'text',
+            none: 'none',
+        };
+        const currentMode = this.agentRegistry?.getShowActivities?.(channel) ?? 'all';
+        // 模式描述列表（用于 body 和文本降级）。
+        // all = 文本 + activity；text = 仅文字进展；none = 全部静默。
+        const modeDescriptions = [
+            { key: 'all', configVal: 'all', label: '私聊显示' },
+            { key: 'text', configVal: 'text', label: '仅文字进展' },
+            { key: 'none', configVal: 'none', label: '全部静默' },
+        ];
+        if (!activityArg) {
+            // 尝试发送 CommandCard 卡片
+            {
+                const interaction = {
+                    type: 'interaction',
+                    id: `activity-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`,
+                    channelId,
+                    sessionId: activeSession?.id || '',
+                    initiatorId: userId,
+                    kind: {
+                        kind: 'command-card',
+                        title: '📋 中间输出模式',
+                        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 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}`;
+            }).join('\n');
+            if (isOwner) {
+                return { kind: 'command.result', text: `中间输出: ${currentMode}  用法: /activity <all|text|none>` };
+            }
+            return { kind: 'command.result', text: `中间输出: ${currentMode}` };
+        }
+        const newMode = modeMap[activityArg];
+        if (!newMode) {
+            return { kind: 'command.error', text: `❌ 无效参数: ${activityArg}\n可选: all / text / none` };
+        }
+        const label = modeDescriptions.find(m => m.configVal === newMode)?.label || newMode;
+        if (newMode === currentMode) {
+            return { kind: 'command.result', text: `📋 中间输出模式已是 ${activityArg}（${label}）` };
+        }
+        // 切换操作仅 owner
+        if (!isOwner)
+            return { kind: 'command.error', text: '❌ 中间输出模式切换仅限 owner' };
+        if (this.agentRegistry?.setShowActivities) {
+            this.agentRegistry.setShowActivities(channel, newMode);
+        }
+        else {
+            return { kind: 'command.error', text: `⚠️ 找不到通道 "${channel}" 所属的 self-agent，无法持久化` };
+        }
+        if (this.shouldSuppressCardTriggerResult(source, channel))
+            return null;
+        return { kind: 'command.result', text: `✅ 中间输出模式: ${activityArg}（${label}）` };
+    }
+    // /chatmode 命令：查看/切换当前 relation 的有效会话模式（interactive | proactive）
+    // - 查看：所有人可用
+    // - 设置：单聊任何角色可设置；群聊仅管理员可设置
+    if (normalizedContent === '/chatmode' || normalizedContent.startsWith('/chatmode ')) {
+        const arg = normalizedContent.slice(9).trim();
+        if (!arg) {
+            const existingChatmodeSession = await getExistingSessionForCommand();
+            const currentMode = getEffectiveChatmode(existingChatmodeSession);
+            // 尝试发送 CommandCard 卡片
+            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: existingChatmodeSession?.id || `chatmode-${Date.now()}`,
+                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 = existingChatmodeSession ? this.getReplyContext(existingChatmodeSession) : undefined;
+            const cardResult = await this.sendCommandCard({
+                channel,
+                channelId,
+                interaction,
+                replyCtx,
+                canWrite: activeChatType !== 'group' || isAdmin,
+            });
+            if (cardResult === null)
+                return null;
+            // 卡片降级：fall through 到下方文本输出
+            // 降级：文本
+            return { kind: 'command.result', text: `会话模式: ${currentMode}  用法: /chatmode <interactive|proactive>` };
+        }
+        if (arg !== 'interactive' && arg !== 'proactive') {
+            return { kind: 'command.error', text: `❌ 无效模式: ${arg}\n可选: interactive / proactive` };
+        }
+        if (activeChatType === 'group' && !isAdmin) {
+            return { kind: 'command.error', text: '❌ 群聊中切换会话模式仅限管理员使用' };
+        }
+        const chatmodeSession = await getExistingSessionForCommand();
+        const target = resolveSlashChatmodeTarget.call(this, {
+            session: chatmodeSession,
+            channel,
+            channelId,
+            userId,
+            selfAID,
+            role: chatmodeSession?.identity?.role || identity.role,
+            chatType: chatmodeSession?.chatType || activeChatType,
+        });
+        if ('error' in target) {
+            return { kind: 'command.error', text: `❌ ${target.error}` };
+        }
+        const currentMode = readSlashChatmode(target);
+        if (arg === currentMode) {
+            return { kind: 'command.result', text: `📋 当前会话模式已是 ${arg}` };
+        }
+        // 仅在真正需要切换时才要求会话空闲
+        if (chatmodeSession && threadId) {
+            const threadSession = await this.sessionManager.getThreadSession(channel, channelId, threadId);
+            if (threadSession) {
+                const threadAgent = this.getAgent(channel, threadSession.baseagent);
+                if (threadAgent.hasActiveStream(threadSession.id) || this.messageQueue?.isProcessing(threadSession.id)) {
+                    return { kind: 'command.error', text: '⚠️ 当前正在处理消息，请稍后再试\n使用 /stop 中断当前任务后重试' };
+                }
+            }
+        }
+        else if (chatmodeSession && (getActiveAgent().hasActiveStream(chatmodeSession.id) || this.messageQueue?.isProcessing(chatmodeSession.id))) {
+            return { kind: 'command.error', text: '⚠️ 当前正在处理消息，请稍后再试\n使用 /stop 中断当前任务后重试' };
+        }
+        const chatmodeAuthDenied = await authorizeIntent({
+            intent: {
+                operation: 'chatmode.update',
+                scope: 'relation',
+                source: 'slash',
+                args: {
+                    value: arg,
+                    self: target.sel.self,
+                    peer: target.sel.peerKey,
+                    peerKey: target.sel.peerKey,
+                },
+            },
+            identity,
+            session: chatmodeSession,
+            explicitChatType: activeChatType === 'group' ? 'group' : 'private',
+            channel,
+            channelId,
+            userId,
+            selfAid: target.sel.self,
+            isDaemonOwner,
+        });
+        if (chatmodeAuthDenied)
+            return chatmodeAuthDenied;
+        try {
+            writeSlashChatmode(target, arg);
+        }
+        catch (e) {
+            return { kind: 'command.error', text: `Failed to update relation chatmode: ${e?.message || e}` };
+        }
+        if (this.shouldSuppressCardTriggerResult(source, channel))
+            return null;
+        return { kind: 'command.result', text: `✅ 会话模式已切换: ${arg}` };
+    }
+    // /mentionmode 命令：查看/切换群聊 @ 处理模式（mention-only | disabled）
+    // 仅群聊可用；群聊中设置需管理员权限
+    if (normalizedContent === '/mentionmode' || normalizedContent.startsWith('/mentionmode ')) {
+        const mentionSession = await getExistingSessionForCommand();
+        if (!mentionSession)
+            return { kind: 'command.error', text: '❌ 当前没有活跃会话' };
+        const mentionChatType = mentionSession.chatType || activeChatType;
+        if (mentionChatType !== 'group') {
+            return { kind: 'command.error', text: '❌ /mentionmode 仅在群聊中可用' };
+        }
+        const arg = normalizedContent.slice('/mentionmode'.length).trim();
+        const mentionTarget = resolveSlashMentionModeTarget.call(this, {
+            session: mentionSession,
+            channel,
+            selfAID,
+            role: mentionSession.identity?.role || identity.role,
+        });
+        if ('error' in mentionTarget) {
+            return { kind: 'command.error', text: `❌ ${mentionTarget.error}` };
+        }
+        // session.metadata.dispatchMode 是 AUN 协议词汇（mention/broadcast），翻译成 mentionMode 词汇兜底
+        const mentionFallback = dispatchToMentionMode(mentionSession.metadata?.dispatchMode) ?? null;
+        const currentMode = readSlashMentionMode(mentionTarget, mentionFallback);
+        if (!arg) {
+            const displayMode = currentMode ?? '未设置（跟随群设置）';
+            // 尝试发送 CommandCard 卡片
+            if (isAdmin) {
+                const modes = [
+                    { key: 'mention-only', name: '提及模式', desc: '仅当被 @ 提及（含 @all）时响应群消息' },
+                    { key: 'disabled', name: '全响应模式', desc: '群内所有消息都触发响应' },
+                ];
+                const interaction = {
+                    type: 'interaction',
+                    id: `mentionmode-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`,
+                    channelId,
+                    sessionId: mentionSession.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: `/mentionmode ${m.key}`,
+                            style: (m.key === currentMode ? 'primary' : 'default'),
+                            disabled: m.key === currentMode,
+                        })),
+                    },
+                };
+                const replyCtx = this.getReplyContext(mentionSession);
+                const cardResult = await this.sendCommandCard({ channel, channelId, interaction, replyCtx, canWrite: isAdmin });
+                if (cardResult === null)
+                    return null;
+                // 卡片降级：fall through 到下方文本输出
+            }
+            // 降级：文本
+            if (isAdmin) {
+                return { kind: 'command.result', text: `@ 处理模式: ${displayMode}  用法: /mentionmode <mention-only|disabled|clear>` };
+            }
+            return { kind: 'command.result', text: `@ 处理模式: ${displayMode}` };
+        }
+        if (arg !== 'mention-only' && arg !== 'disabled' && arg !== 'clear') {
+            return { kind: 'command.error', text: `❌ 无效模式: ${arg}\n可选: mention-only / disabled / clear\n用法: /mentionmode <模式>` };
+        }
+        const mentionAuthDenied = await authorizeIntent({
+            intent: {
+                operation: 'mentionmode.update',
+                scope: 'agent',
+                source: 'slash',
+                args: { value: arg, self: mentionTarget.sel.self },
+            },
+            identity,
+            session: mentionSession,
+            explicitChatType: 'group',
+            channel,
+            channelId,
+            userId,
+            selfAid: mentionTarget.sel.self,
+            isDaemonOwner,
+        });
+        if (mentionAuthDenied)
+            return mentionAuthDenied;
+        if (arg === 'clear') {
+            writeSlashMentionMode(mentionTarget, null);
+            if (this.shouldSuppressCardTriggerResult(source, channel))
+                return null;
+            return { kind: 'command.result', text: '✅ 已清除本地覆盖，将跟随群设置' };
+        }
+        if (arg === currentMode) {
+            return { kind: 'command.result', text: `当前已是 ${arg}` };
+        }
+        writeSlashMentionMode(mentionTarget, arg);
+        if (this.shouldSuppressCardTriggerResult(source, channel))
+            return null;
+        return { kind: 'command.result', text: `✅ @ 处理模式已切换: ${currentMode ?? '未设置'} → ${arg}` };
+    }
+    // /stop 命令：中断当前任务
+    if (normalizedContent === '/stop') {
+        const stopSession = await getExistingSessionForCommand();
+        if (!stopSession)
+            return { kind: 'command.result', text: '当前没有正在处理的任务' };
+        const stopAgent = this.getAgent(channel, stopSession.baseagent);
+        const sessionKey = stopSession.id;
+        const queueLength = this.messageQueue.getQueueLength(sessionKey);
+        const hasActive = stopAgent.hasActiveStream(sessionKey);
+        const isProcessing = this.messageQueue.isProcessing(sessionKey);
+        if (queueLength === 0 && !hasActive && !isProcessing) {
+            return { kind: 'command.result', text: '当前没有正在处理的任务' };
+        }
+        // 发布中断事件，让 MessageProcessor 标记为 interrupted（而非 done）
+        this.eventBus.publish({
+            type: 'task:interrupted',
+            sessionId: sessionKey,
+            reason: 'stop',
+            agentName: this.agentRegistry?.resolveByChannel(channel)?.name ?? '<unknown>',
+        });
+        await this.processor.interruptSession(sessionKey, 'stop');
+        return { kind: 'command.result', text: '✓ 已发送中断信号，任务将尽快停止' };
+    }
+    // /clear 已移除：Claude/Codex/Gemini 对“清空当前 backend 历史”的语义不一致。
+    // 统一使用 /new 创建新会话来开始全新上下文。
+    if (normalizedContent === '/clear') {
+        return { kind: 'command.error', text: '⚠️ /clear 已移除\n\n请使用 /new [名称] 创建新会话来开始全新上下文。旧会话会保留，可通过 /s 查看或切换。' };
+    }
+    // /compact 命令：手动压缩会话上下文
+    if (normalizedContent === '/compact') {
+        const session = await getExistingSessionForCommand();
+        if (!session)
+            return { kind: 'command.error', text: '❌ 当前没有活跃会话，无需压缩' };
+        const sessionAgent = this.getAgent(channel, session.baseagent);
+        if (!sessionAgent.capabilities?.compact) {
+            return { kind: 'command.error', text: `❌ 当前 Agent (${sessionAgent.name}) 不支持 /compact` };
+        }
+        if (!session.agentSessionId) {
+            return { kind: 'command.error', text: '❌ 当前会话没有历史记录，无需压缩' };
+        }
+        const projectPath = path.isAbsolute(session.projectPath)
+            ? session.projectPath
+            : path.resolve(process.cwd(), session.projectPath);
+        const releaseLock = this.messageQueue.acquireLock(session.id);
+        try {
+            if (sendMessage) {
+                await sendMessage(channelId, '⏳ 正在压缩会话上下文...', this.getReplyContext(session));
+            }
+            const compacted = await sessionAgent.compactSession(session.id, session.agentSessionId, projectPath);
+            if (compacted) {
+                return {
+                    kind: 'command.result',
+                    text: '✅ 会话压缩完成',
+                };
+            }
+            else {
+                return { kind: 'command.error', text: '❌ 会话压缩失败，请稍后重试' };
+            }
+        }
+        finally {
+            releaseLock();
+        }
+    }
+    // 后续命令可读取现有会话，但不应在这里隐式创建新会话。
+    // 真正需要新会话的命令应显式调用 createNewSession()。
+    let session;
+    if (threadId) {
+        session = await this.sessionManager.getThreadSession(channel, channelId, threadId);
+    }
+    else {
+        session = await this.sessionManager.getActiveSession(channel, channelId);
+    }
+    // /status 命令：显示会话状态
+    if (normalizedContent === '/status') {
+        if (!session) {
+            return { kind: 'command.result', text: `📊 会话状态：当前没有活跃会话\n发送消息或使用 /new [名称] 创建会话` };
+        }
+        const sessionKey = this.getQueueKey(session, channel, channelId);
+        const sessionAgent = this.getAgent(channel, session.baseagent);
+        const isCurrentlyProcessing = this.messageQueue.isProcessing(sessionKey) || sessionAgent.hasActiveStream(sessionKey);
+        const queueLength = this.messageQueue.getQueueLength(sessionKey);
+        const isThread = !!session.threadId;
+        let sessionStatus = isCurrentlyProcessing ? '处理中' : '空闲';
+        // 处理中时显示时长
+        if (isCurrentlyProcessing) {
+            const elapsed = Date.now() - parseInt(session.processingState, 10);
+            if (!isNaN(elapsed) && elapsed > 0) {
+                const sec = Math.floor(elapsed / 1000);
+                sessionStatus = sec < 60 ? `处理中 (${sec}秒)` :
+                    sec < 3600 ? `处理中 (${Math.floor(sec / 60)}分钟)` :
+                        `处理中 (${Math.floor(sec / 3600)}小时)`;
+            }
+        }
+        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 ? '刚刚' :
+            timeSinceSuccess < 3600000 ? `${Math.floor(timeSinceSuccess / 60000)}分钟前` :
+                `${Math.floor(timeSinceSuccess / 3600000)}小时前`;
+        // 获取会话文件信息并同步 name
+        let sessionTurns = 0;
+        if (session.agentSessionId) {
+            const fileInfo = this.sessionManager.getSessionFileInfo(session.projectPath, session.agentSessionId, session.baseagent);
+            sessionTurns = fileInfo.turns;
+            if (fileInfo.title && fileInfo.title !== session.name) {
+                await this.sessionManager.renameSession(session.id, fileInfo.title);
+                session.name = fileInfo.title;
+            }
+        }
+        const lines = [];
+        const chatMode = getEffectiveChatmode(session);
+        const sessionRole = session.identity?.role || identity.role || 'none';
+        const sessionRoleLine = `角色身份: ${sessionRole}`;
+        const mentionModeTarget = resolveSlashMentionModeTarget.call(this, {
+            session,
+            channel,
+            selfAID,
+            role: sessionRole,
+        });
+        // session.metadata.dispatchMode 是 AUN 协议词汇，翻译成 mentionMode 词汇兜底
+        const mentionModeFallback = dispatchToMentionMode(session.metadata?.dispatchMode) ?? null;
+        const mentionMode = 'error' in mentionModeTarget
+            ? (mentionModeFallback ?? '未设置（跟随群设置）')
+            : (readSlashMentionMode(mentionModeTarget, mentionModeFallback) ?? '未设置（跟随群设置）');
+        const chatModeLine = `会话模式: ${chatMode}`;
+        const dispatchModeLine = session.chatType === 'group' ? `@ 处理模式: ${mentionMode}` : null;
+        if (isAdmin) {
+            const gitInfo = await getGitWorkingDirInfo(session.projectPath);
+            lines.push(`📊 ${isThread ? '话题' : '会话'}状态 (Agent: ${agentName})：`, `渠道: ${this.resolveChannelType(channel)} / 项目: ${projectName} / 会话: ${displaySessionTitle(session.name, '(未命名)')}`, `会话ID: ${session.id}`, `项目路径: ${session.projectPath}`);
+            if (gitInfo) {
+                lines.push(`Git: ${gitInfo}`);
+            }
+            lines.push(`会话状态: ${sessionStatus} / 轮数: ${sessionTurns}`, sessionRoleLine, chatModeLine, ...(dispatchModeLine ? [dispatchModeLine] : []));
+            if (health.consecutiveErrors > 0) {
+                lines.push(`异常计数: ${health.consecutiveErrors}`);
+            }
+            lines.push(`最后成功: ${timeStr}`, `${session.baseagent}会话: ${session.agentSessionId || '(未初始化)'}`, `创建时间: ${new Date(session.createdAt).toLocaleString('zh-CN')}`, `更新时间: ${new Date(session.updatedAt).toLocaleString('zh-CN')}`);
+        }
+        else {
+            lines.push(`📊 ${isThread ? '话题' : '会话'}状态 (Agent: ${agentName})：`, `渠道: ${channel} / 项目: ${projectName} / ${session.baseagent}会话`);
+            lines.push(`状态: ${sessionStatus} / 轮数: ${sessionTurns}`, sessionRoleLine, chatModeLine, ...(dispatchModeLine ? [dispatchModeLine] : []), `最后活跃: ${timeStr}`);
+        }
+        if (health.lastError) {
+            lines.push('');
+            lines.push(`最后错误: ${health.lastErrorType || 'unknown'}`);
+            lines.push(`错误信息: ${health.lastError.substring(0, 100)}`);
+        }
+        return { kind: 'command.result', text: lines.join('\n') };
+    }
+    // /new 命令：创建新会话（支持命名）
+    if (normalizedContent.startsWith('/new')) {
+        const sessionName = normalizedContent.slice(4).trim() || undefined;
+        if (sessionName) {
+            const existing = await this.sessionManager.getSessionByName(channel, channelId, sessionName);
+            if (existing) {
+                return { kind: 'command.error', text: `❌ 会话名称 "${sessionName}" 已存在，请使用其他名称` };
+            }
+        }
+        const projectPath = this.getEffectiveDefaultPath(channel);
+        if (sendMessage && session) {
+            await sendMessage(channelId, `⏳ 正在创建新会话${sessionName ? `: ${sessionName}` : ''}...`, this.getReplyContext(session));
+        }
+        const newSessionBaseagent = this.agentRegistry?.resolveByChannel(channel)?.baseagent || this.parseDefaultBaseagent();
+        const newSession = await this.sessionManager.createNewSession(channel, channelId, projectPath, sessionName, newSessionBaseagent);
+        const previousAgent = getActiveAgentIfAvailable();
+        if (session && previousAgent) {
+            // Reset agent backend state so the new
+            // session starts with a fresh conversation history
+            await previousAgent.clearSession(session.id, session.agentSessionId || '', session.projectPath);
+            await previousAgent.closeSession(session.id);
+        }
+        const newAgent = this.agentRegistry?.resolveByChannel(channel);
+        const newBaseagent = newSession.baseagent || newAgent?.baseagent || this.parseDefaultBaseagent();
+        // 与 /model 卡片保持一致：按 关系>角色>agent 解析实际生效的 model/effort，
+        // 不直接读 EvolAgent.model（那只是 agent 级静态配置，会无视关系/角色级覆盖）。
+        const newRunner = this.getAgent(channel, newSession.baseagent);
+        const newModelTarget = resolveSlashRelationTarget.call(this, {
+            session: newSession,
+            channel,
+            channelId,
+            userId,
+            selfAID,
+            role: newSession.identity?.role || identity.role,
+            chatType,
+        });
+        const newModelSelector = 'error' in newModelTarget
+            ? { self: selfAID ?? newSession.selfAID ?? this.resolveSelfAID(channel) }
+            : newModelTarget;
+        let modelConfig = {};
+        try {
+            modelConfig = (resolveEffective(newModelSelector, { cache: true }).baseagents || {})[newBaseagent] || {};
+        }
+        catch { }
+        const backendModel = modelConfig.model || newRunner.getModel?.() || newAgent?.model;
+        const backendEffort = modelConfig[newBaseagent === 'codex' ? 'reasoning' : 'effort']
+            ?? newRunner.getEffort?.()
+            ?? newAgent?.effort;
+        const backendBits = [newBaseagent, backendModel, backendEffort].filter(Boolean).join(' · ');
+        return { kind: 'command.result', text: `✓ 已创建新会话${sessionName ? `: ${sessionName}` : ''}\n  项目: ${this.getProjectName(projectPath)}\n  后端: ${backendBits}\n  之前的对话历史已保留，可通过 /s 查看` };
+    }
+    // /check 命令：检查 EvolAgent 实例健康（visitor/member 可用，详情仅 admin）
+    if (normalizedContent === '/check' || normalizedContent.startsWith('/check ')) {
+        // 限定可见渠道：agent-owned 通道仅显示该 agent 名下的渠道；
+        // 系统控制面是无持久化的全局入口，展示全部渠道；兼容旧虚拟 channel 名。
+        const isGlobalCheckChannel = isSystemControlChannel(channel);
+        const checkOwningAgent = isGlobalCheckChannel ? null : this.getOwningAgent(channel);
+        let allowedChannels;
+        if (checkOwningAgent) {
+            allowedChannels = new Set(checkOwningAgent.channelInstanceNames());
+        }
+        else if (isGlobalCheckChannel) {
+            // ECWeb / 控制 AID 全局视图：展示所有渠道
+            allowedChannels = new Set(this.adapters.keys());
+        }
+        else {
+            // default 范围：不再有 default channel 概念，等价于"所有 channel"
+            const defaultNames = [];
+            for (const [name] of this.adapters) {
+                const owner = this.agentRegistry?.resolveByChannel(name);
+                if (!owner)
+                    defaultNames.push(name);
+            }
+            allowedChannels = new Set(defaultNames);
+        }
+        // Default: show system health check (non-admin 仅看摘要)
+        const checkAgentName = checkOwningAgent?.name ?? (isGlobalCheckChannel ? 'EvolCore' : 'DefaultAgent');
+        const checkDefaultBaseagent = checkOwningAgent?.baseagent ?? this.parseDefaultBaseagent();
+        const checkBaseagent = activeSession?.baseagent ?? checkDefaultBaseagent;
+        const lines = [`📡 EvolAgent 实例健康 (Agent: ${checkAgentName})：`];
+        lines.push(`  Baseagent: ${checkBaseagent}`);
+        if (checkDefaultBaseagent !== checkBaseagent) {
+            lines.push(`  默认 Baseagent: ${checkDefaultBaseagent}`);
+        }
+        // Group by channelType
+        const groups = new Map();
+        for (const [name] of this.adapters) {
+            if (!allowedChannels.has(name))
+                continue;
+            const type = this.resolveChannelType(name);
+            const ch = this.channelObjects.get(name);
+            let status;
+            if (ch?.getStatus) {
+                const s = ch.getStatus();
+                status = s.connected ? '✓ 已连接' : '⏳ 重连中';
+            }
+            else {
+                status = '✓ 已注册';
+            }
+            if (!groups.has(type))
+                groups.set(type, []);
+            groups.get(type).push({ name, status });
+        }
+        if (!isAdmin) {
+            // visitor/member: 仅显示实例通道摘要
+            const total = [...groups.values()].flat().length;
+            const healthy = [...groups.values()].flat().filter(i => i.status.includes('✓')).length;
+            lines.push(`  ${healthy}/${total} 渠道正常`);
+            return { kind: 'command.result', text: lines.join('\n') };
+        }
+        for (const [type, instances] of groups) {
+            if (instances.length === 1) {
+                lines.push(`  ${type}: ${instances[0].status}`);
+            }
+            else {
+                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 查询）。运行统计按 AID 入桶。
+        const currentAgentName = checkOwningAgent?.aid ?? checkOwningAgent?.name ?? '<unknown>';
+        // 系统级入口使用全局统计（不按 agent 过滤）
+        const statsAgentName = isGlobalCheckChannel ? undefined : currentAgentName;
+        const queuePending = isGlobalCheckChannel
+            ? this.messageQueue.getGlobalQueueLength()
+            : this.messageQueue.getQueueLengthByAgent(currentAgentName);
+        const queueProcessing = isGlobalCheckChannel
+            ? this.messageQueue.getGlobalProcessingCount()
+            : this.messageQueue.getProcessingCountByAgent(currentAgentName);
+        // 队列状态（系统级入口为全局；agent 入口为当前 agent 维度）
+        lines.push('', '📬 队列状态：');
+        lines.push(`  待处理消息: ${queuePending}`);
+        lines.push(`  处理中队列: ${queueProcessing}`);
+        // 运行概况（全局，进程级）
+        lines.push('', '🖥️ 运行概况：');
+        const uptimeMs = this.statsCollector
+            ? this.statsCollector.getSnapshot().uptimeMs
+            : process.uptime() * 1000;
+        lines.push(`  运行时间: ${this.formatUptime(uptimeMs)}`);
+        // 近 1 小时统计（ECWeb 使用全局统计，agent-owned channel 使用 agent 统计）
+        if (this.statsCollector) {
+            const snap = this.statsCollector.getSnapshot(statsAgentName);
+            const h = snap.lastHour;
+            lines.push('', '📊 近 1 小时统计：');
+            lines.push(`  收到消息: ${h.received}`);
+            lines.push(`  完成处理: ${h.completed}`);
+            if (h.errors > 0) {
+                const breakdown = Object.entries(h.errorsByType).map(([t, c]) => `${t}: ${c}`).join(', ');
+                lines.push(`  处理出错: ${h.errors} (${breakdown})`);
+            }
+            else {
+                lines.push(`  处理出错: 0`);
+            }
+            if (h.toolErrors > 0) {
+                const toolBreakdown = Object.entries(h.toolErrorsByName).map(([t, c]) => `${t}: ${c}`).join(', ');
+                lines.push(`  工具失败: ${h.toolErrors} (${toolBreakdown})`);
+            }
+            lines.push(`  被中断: ${h.interrupts}`);
+            if (h.completed > 0) {
+                lines.push(`  平均响应耗时: ${(h.avgResponseMs / 1000).toFixed(1)}s`);
+            }
+        }
+        const checkSnap = this.statsCollector?.getSnapshot(statsAgentName);
+        // AUN 渠道的 per-AID 连接富状态（reconnect / flap / lastError / kick）
+        const aidStateByName = new Map();
+        for (const [cname, cobj] of this.channelObjects) {
+            if (typeof cobj?.getAidState === 'function') {
+                try {
+                    aidStateByName.set(cname, cobj.getAidState());
+                }
+                catch { /* ignore */ }
+            }
+        }
+        // 单个渠道实例的健康快照：基础连接态 + AUN 富状态
+        const channelHealth = (cname) => {
+            const type = this.resolveChannelType(cname);
+            const cobj = this.channelObjects.get(cname);
+            const seg = cname.split('#');
+            const instName = seg.length >= 3 ? seg.slice(2).join('#') : cname;
+            const aidState = aidStateByName.get(cname);
+            // cobj 缺失 = 渠道未注册（如 disabled agent），视为未连接；
+            // cobj 存在但无 getStatus = 已注册的活实例，视为已连接。
+            let connected = cobj ? (cobj.getStatus ? !!cobj.getStatus().connected : true) : false;
+            const h = { name: cname, instName, type, connected };
+            if (aidState) {
+                connected = aidState.status === 'connected';
+                h.connected = connected;
+                h.aidStatus = aidState.status;
+                h.reconnectCount = aidState.reconnectCount ?? 0;
+                h.flapCount = aidState.flapCount ?? 0;
+                if (aidState.lastConnectedAt)
+                    h.lastConnectedAt = aidState.lastConnectedAt;
+                if (aidState.lastError)
+                    h.lastError = String(aidState.lastError).slice(0, 80);
+                if (aidState.kickDetail?.reason)
+                    h.kickReason = String(aidState.kickDetail.reason).slice(0, 80);
+            }
+            return h;
+        };
+        // 以 EvolAgent 为中心聚合：后端 + 通道明细 + 负载，并记录已归属通道
+        const ownedNames = new Set();
+        const evolagents = (this.agentRegistry?.list() ?? []).map((ag) => {
+            const chans = (ag.channels ?? []).map((n) => { ownedNames.add(n); return channelHealth(n); });
+            // 队列按 agentName 聚合，入队时 agentName === EvolAgent.aid（见 message-bridge enqueue）。
+            // 这里必须用 ag.aid，不能用 ag.name —— toInfo 的 name 可能是 agent.md 的 displayName 短名，
+            // 与队列里的 AID 不匹配会导致 processing/pending 恒为 0。
+            const processing = this.messageQueue.getProcessingCountByAgent(ag.aid);
+            const pending = this.messageQueue.getQueueLengthByAgent(ag.aid);
+            return {
+                name: ag.name, aid: ag.aid ?? '', status: ag.status,
+                baseagent: ag.baseagent ?? null,
+                model: ag.model ?? null,
+                effort: ag.effort ?? null,
+                projectPath: ag.projectPath ?? null,
+                processing, pending,
+                activeTasks: processing + pending,
+                lastActivity: ag.lastActivity ?? 0,
+                error: ag.error,
+                channels: chans,
+            };
+        });
+        // 未归属到任何 EvolAgent 实例的系统通道（系统级 / DefaultAgent）
+        const unownedChannels = [];
+        for (const [cname] of this.adapters) {
+            if (!allowedChannels.has(cname) || ownedNames.has(cname))
+                continue;
+            unownedChannels.push(channelHealth(cname));
+        }
+        const structured = {
+            daemon: {
+                ...(typeof this.daemonStatusProvider === 'function' ? this.daemonStatusProvider() : {}),
+                status: 'running',
+            },
+            channels: [...groups.entries()].map(([type, instances]) => ({ type, instances })),
+            queue: {
+                pending: queuePending,
+                processing: queueProcessing,
+            },
+            baseagent: checkBaseagent,
+            defaultBaseagent: checkDefaultBaseagent,
+            uptimeMs,
+            lastHour: checkSnap?.lastHour ?? null,
+            evolagents,
+            unownedChannels,
+        };
+        return { kind: 'command.result', text: lines.join('\n'), structured };
+    }
+    // /restart 命令：重启服务（进程级，仅 daemon owner）
+    if (normalizedContent === '/restart') {
+        // 进程级操作：必须是 daemon owner（daemon.json.owners），与 menu 协议 /system restart 一致。
+        // agent-channel 的 owner/admin 角色不足以重启整个 daemon。
+        if (!isDaemonOwner) {
+            return { kind: 'command.error', text: '❌ 无权限：服务重启仅限 daemon owner 使用' };
+        }
+        const restartSelfAid = this.agentRegistry?.resolveByChannel(channel)?.aid;
+        const authDenied = await authorizeIntent({
+            intent: {
+                operation: 'system.restart',
+                scope: 'process',
+                source: 'slash',
+                args: {},
+                dangerous: true,
+            },
+            identity: { ...identity, role: 'owner' },
+            session: activeSession,
+            channel,
+            channelId,
+            userId,
+            selfAid: restartSelfAid,
+            isDaemonOwner,
+        });
+        if (authDenied)
+            return authDenied;
+        const selfAid = this.agentRegistry?.resolveByChannel(channel)?.aid;
+        // 排除当前会话（如果存在）。如果 activeSession 不存在，说明还没建立会话，
+        // 此时检查所有任务；如果有其他会话在处理，仍然阻塞重启。
+        const excludeKey = activeSession?.id;
+        const busyInfo = getAgentBusyInfo(this, selfAid, excludeKey);
+        if (busyInfo && busyInfo.count > 0) {
+            // busyInfo.count > 0 说明【除当前会话外】还有其他会话的任务在执行
+            const processingLines = busyInfo.processing.map(p => {
+                const keyParts = p.queueKey.split('::');
+                const sessionId = keyParts[0] || '?';
+                return `  · session ${sessionId.slice(0, 32)}... (agent: ${p.agentName})`;
+            }).join('\n');
+            return {
+                kind: 'command.error',
+                text: `❌ ${excludeKey ? '其他会话' : '该 Agent'} 有 ${busyInfo.count} 个任务执行中，无法重启。\n\n处理中的会话：\n${processingLines}\n\n建议：等待这些任务完成后重试。可通过 ec ctl status 查看队列状态；典型等待时间 30-60 秒，群聊大型任务可能更长。`,
+            };
+        }
+        const allSessions = await this.sessionManager.listSessions(channel, channelId);
+        const sessionsWithMessages = allSessions
+            .filter((s) => this.messageCache.hasMessages(s.id))
+            .map((s) => {
+            const count = this.messageCache.getCount(s.id);
+            return `${s.projectPath} 有 ${count} 条新消息`;
+        });
+        // 执行重启逻辑（共用于卡片回调和文本确认）
+        const executeRestart = async () => {
+            let replyContext;
+            if (threadId) {
+                const threadSession = await this.sessionManager.getThreadSession(channel, channelId, threadId);
+                if (threadSession)
+                    replyContext = this.getReplyContext(threadSession);
+            }
+            const restartInfo = {
+                channel,
+                channelId,
+                timestamp: Date.now(),
+                ...(replyContext?.replyToMessageId ? { rootId: replyContext.replyToMessageId } : {}),
+            };
+            const dataDir = resolvePaths().dataDir;
+            fs.mkdirSync(dataDir, { recursive: true });
+            fs.writeFileSync(path.join(dataDir, 'restart-pending.json'), JSON.stringify(restartInfo));
+            const { spawn } = await import('child_process');
+            spawn('node', [path.join(getPackageRoot(), 'dist', 'cli', 'index.js'), 'restart-monitor'], {
+                detached: true,
+                stdio: 'ignore',
+                env: { ...process.env, EVOLCORE_HOME: resolvePaths().root }
+            }).unref();
+            this.eventBus.publish({ type: 'system:restart', channel, channelId });
+            // 先发送重启反馈消息，等待发送完成后再 kill 进程
+            // 避免消息还没发出去进程就退出了
+            const adapter = this.adapters.get(channel);
+            if (adapter) {
+                try {
+                    const envelope = buildEnvelope({
+                        taskId: `restart-${Date.now()}`,
+                        channel,
+                        channelId,
+                        agentName: 'system',
+                        chatmode: 'interactive',
+                        replyContext,
+                    });
+                    await adapter.send(envelope, { kind: 'command.result', text: '🔄 服务正在重启，请稍候...（约 5 秒后恢复）' });
+                    // 等待消息发送完成后再延迟 kill
+                    await new Promise(resolve => setTimeout(resolve, 500));
+                }
+                catch (err) {
+                    logger.error('[System] Failed to send restart notification:', err);
+                }
+            }
+            // 发 SIGTERM 而非直接 process.exit(0)，让 index.ts 的 shutdown() 先
+            // 正常关闭所有 channel（包括 Feishu WebSocket close frame），
+            // 避免 Feishu 服务端因连接异常断开而重推未 ack 的消息给新进程。
+            setTimeout(() => {
+                logger.info('[System] Restarting by user command...');
+                process.kill(process.pid, 'SIGTERM');
+            }, 1000);
+            return true;
+        };
+        // 文本确认流程
+        if (sessionsWithMessages.length > 0) {
+            const restartKey = `${channel}-${channelId}`;
+            const dataDir = resolvePaths().dataDir;
+            fs.mkdirSync(dataDir, { recursive: true });
+            const restartConfirmFile = path.join(dataDir, `restart-confirm-${restartKey}.json`);
+            if (fs.existsSync(restartConfirmFile)) {
+                const confirmInfo = JSON.parse(fs.readFileSync(restartConfirmFile, 'utf-8'));
+                const now = Date.now();
+                if (now - confirmInfo.timestamp < 10000) {
+                    fs.unlinkSync(restartConfirmFile);
+                }
+                else {
+                    fs.writeFileSync(restartConfirmFile, JSON.stringify({ timestamp: now }));
+                    return { kind: 'command.result', text: sessionsWithMessages.join('\n') + '\n再次输入 /restart 将强制重启。' };
+                }
+            }
+            else {
+                fs.writeFileSync(restartConfirmFile, JSON.stringify({ timestamp: Date.now() }));
+                return { kind: 'command.result', text: sessionsWithMessages.join('\n') + '\n再次输入 /restart 将强制重启。' };
+            }
+        }
+        await executeRestart();
+        // executeRestart 内部已经发送了反馈消息，这里返回 null 避免重复发送
+        return null;
+    }
+    // /upgrade 命令：检查版本更新，提示用户手动重启
+    if (normalizedContent === '/upgrade') {
+        if (!isAdmin)
+            return { kind: 'command.error', text: '❌ 无权限：升级检查仅限管理员使用' };
+        if (isLinkedInstall()) {
+            return { kind: 'command.result', text: '⏭ 开发模式，跳过升级检查' };
+        }
+        const localVer = getLocalVersion();
+        const remoteVer = await checkLatestVersion();
+        if (!remoteVer) {
+            return { kind: 'command.result', text: `⚠️ 无法连接 npm registry（当前版本 ${localVer}）` };
+        }
+        if (compareVersions(localVer, remoteVer) >= 0) {
+            return { kind: 'command.result', text: `✓ 已是最新版本 (${localVer})` };
+        }
+        return { kind: 'command.result', text: `📦 发现新版本 ${localVer} → ${remoteVer}\n执行 /restart 升级` };
+    }
+    // /pwd 命令：显示当前项目路径
+    if (normalizedContent === '/pwd') {
+        if (!session) {
+            const defaultProjectPath = this.agentRegistry?.resolveByChannel(channel)?.projectPath || this.getEffectiveDefaultPath(channel);
+            const defaultConfigName = this.getConfiguredProjectName(defaultProjectPath);
+            if (defaultConfigName) {
+                return { kind: 'command.result', text: `当前项目: ${defaultConfigName}\n路径: ${defaultProjectPath}` };
+            }
+            return { kind: 'command.result', text: `当前项目: ${defaultProjectPath}` };
+        }
+        const configName = this.getConfiguredProjectName(session.projectPath);
+        if (configName) {
+            return { kind: 'command.result', text: `当前项目: ${configName}\n路径: ${session.projectPath}` };
+        }
+        return { kind: 'command.result', text: `当前项目: ${session.projectPath}` };
+    }
+    // /file 命令：发送项目内文件，支持 /file path 和 /file channel path
+    if (normalizedContent.startsWith('/file')) {
+        if (!isAdmin)
+            return { kind: 'command.error', text: '❌ 无权限：此命令仅限管理员使用' };
+        // 飞书会将 .md 等后缀自动转为 Markdown 链接: foo.md → [foo.md](http://foo.md/)
+        // 还原: 将 [text](url) 替换为 text
+        const rawArg = normalizedContent.slice(5).trim().replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');
+        if (!rawArg) {
+            const usage = isOwner
+                ? '用法: /file <相对路径> 或 /file <渠道> <相对路径>\n示例: /file src/index.ts\n示例: /file feishu report.md'
+                : '用法: /file <相对路径>\n示例: /file src/index.ts';
+            return { kind: 'command.result', text: usage };
+        }
+        // 解析目标通道：第一个 token 按实例名匹配，再按 channelType 匹配
+        const tokens = rawArg.split(/\s+/);
+        let targetChannel = channel;
+        let targetLabel = channel;
+        let filePath = rawArg;
+        if (tokens.length >= 2) {
+            const spec = tokens[0];
+            if (this.adapters.has(spec)) {
+                // 精确实例名
+                targetChannel = spec;
+                targetLabel = spec;
+                filePath = tokens.slice(1).join(' ');
+            }
+            else {
+                // 按 channelType 查找第一个匹配的实例
+                for (const [name] of this.adapters) {
+                    if ((this.channelTypeMap.get(name) || name) === spec) {
+                        targetChannel = name;
+                        targetLabel = spec;
+                        filePath = tokens.slice(1).join(' ');
+                        break;
+                    }
+                }
+            }
+        }
+        const isCrossChannel = targetChannel !== channel;
+        // 跨通道不属于当前关系级操作，仍仅限 owner。
+        if (isCrossChannel && identity.role !== 'owner') {
+            return { kind: 'command.error', text: '❌ 跨通道发送仅限 owner' };
+        }
+        // 找目标 adapter
+        const targetAdapter = this.adapters.get(targetChannel);
+        if (!targetAdapter) {
+            return { kind: 'command.error', text: `❌ 通道 ${targetLabel} 未启用或不存在` };
+        }
+        if (!targetAdapter.capabilities?.file) {
+            return { kind: 'command.error', text: `❌ 通道 ${targetLabel} 不支持文件发送` };
+        }
+        const sendSession = await getExistingSessionForCommand();
+        const projectPath = sendSession?.projectPath || this.agentRegistry?.resolveByChannel(channel)?.projectPath || this.getEffectiveDefaultPath(channel);
+        // 路径安全校验
+        if (path.isAbsolute(filePath)) {
+            return { kind: 'command.error', text: '❌ 不支持绝对路径\n请使用项目内的相对路径' };
+        }
+        if (filePath.split(path.sep).includes('..') || filePath.split('/').includes('..')) {
+            return { kind: 'command.error', text: '❌ 不支持 .. 路径穿越' };
+        }
+        const resolvedPath = path.resolve(projectPath, filePath);
+        // 存在性检查
+        if (!fs.existsSync(resolvedPath)) {
+            return { kind: 'command.error', text: `❌ 文件不存在: ${filePath}` };
+        }
+        // 符号链接安全：realpath 后验证仍在项目目录内
+        const realPath = fs.realpathSync(resolvedPath);
+        const realProjectPath = fs.realpathSync(projectPath);
+        if (!realPath.startsWith(realProjectPath + path.sep) && realPath !== realProjectPath) {
+            return { kind: 'command.error', text: '❌ 路径不允许: 文件不在项目目录内' };
+        }
+        const stat = fs.statSync(resolvedPath);
+        if (stat.isDirectory()) {
+            return { kind: 'command.error', text: '❌ 暂不支持发送目录\n目录打包发送将在后续版本支持' };
+        }
+        const MAX_SIZE = 10 * 1024 * 1024;
+        if (stat.size > MAX_SIZE) {
+            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);
+            targetChannelId = ownerPeerId ? (this.sessionManager.getOwnerChatId(targetChannel, ownerPeerId) ?? '') : '';
+            if (!targetChannelId) {
+                return { kind: 'command.error', text: `❌ 未找到 ${targetLabel} 的私聊会话，请先在该通道发送一条消息` };
+            }
+        }
+        // 发送文件
+        try {
+            const replyCtx = !isCrossChannel && sendSession ? this.getReplyContext(sendSession) : undefined;
+            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 { kind: 'command.result', text: isCrossChannel
+                    ? `📎 文件已通过 ${targetLabel} 发送: ${filePath} (${sizeStr})`
+                    : `✅ 已发送: ${filePath} (${sizeStr})` };
+        }
+        catch (error) {
+            logger.error('[CommandHandler] /file failed:', error);
+            return { kind: 'command.error', text: `❌ 文件发送失败: ${error.message || error}` };
+        }
+    }
+    // /slist 命令：列出当前项目的会话
+    // /slist      — 仅 EvolCore 会话
+    // /slist cli  — 仅 CLI 会话（未导入的）
+    if (normalizedContent === '/slist' || normalizedContent === '/slist cli') {
+        if (!session) {
+            return { kind: 'command.error', text: `❌ 当前没有活跃会话
+
+请先执行以下操作之一：
+1. 发送任意消息 - 自动创建新会话
+2. /new [名称] - 创建命名会话` };
+        }
+        const showCliOnly = normalizedContent === '/slist cli';
+        // /slist cli — 仅显示 CLI 会话
+        if (showCliOnly) {
+            const canImportCli = policy.canImportCliSession(session.chatType || 'private', identity.role);
+            if (!canImportCli) {
+                return { kind: 'command.error', text: '❌ 当前无权查看 CLI 会话' };
+            }
+            const orphanCliSessions = await this.sessionManager.listImportableCliSessions(session.projectPath, session.baseagent);
+            if (orphanCliSessions.length === 0) {
+                return { kind: 'command.result', text: `当前项目 ${path.basename(session.projectPath)} 没有未导入的 CLI 会话` };
+            }
+            // 构建显示数据（复用于卡片和文本）
+            const cliDisplayItems = orphanCliSessions.map((c) => {
+                const time = new Date(c.mtime).toLocaleString('zh-CN', { month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit' });
+                const uuid = c.uuid.substring(0, 8);
+                return { uuid, fullUuid: c.uuid, time, title: c.title || '(无标题)' };
+            });
+            // 尝试发送 CommandCard 卡片
+            if (this.interactionRouter && cliDisplayItems.length > 0) {
+                const bodyLines = cliDisplayItems.map((item) => `• ${item.time}  (${item.uuid})  "${item.title}"`);
+                const interaction = {
+                    type: 'interaction',
+                    id: `slist-cli-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`,
+                    channelId,
+                    sessionId: session.id,
+                    initiatorId: userId,
+                    kind: {
+                        kind: 'command-card',
+                        title: `📋 ${path.basename(session.projectPath)} CLI 会话 (${cliDisplayItems.length})`,
+                        body: bodyLines.join('\n'),
+                        buttons: cliDisplayItems.map((item) => ({
+                            label: item.uuid,
+                            command: `/session ${item.uuid}`,
+                            style: 'default',
+                        })),
+                    },
+                };
+                const replyCtx = this.getReplyContext(session);
+                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} 个):`, ''];
+            for (const item of cliDisplayItems) {
+                lines.push(`  ${item.time}  (${item.uuid})  "${item.title}"`);
+            }
+            lines.push('');
+            lines.push('使用 /s <8位uuid> 导入并切换到 CLI 会话');
+            return { kind: 'command.result', text: lines.join('\n') };
+        }
+        // /slist — 仅显示 EvolCore 会话
+        const sessions = await this.sessionManager.listSessions(channel, channelId);
+        const currentProjectSessions = sessions.filter((s) => s.projectPath === session.projectPath && s.baseagent === session.baseagent && !s.threadId);
+        // 从 SDK 同步会话名称（发现 CLI 改名）
+        try {
+            const sdkSessions = await this.sessionManager.listSdkSessions(session.projectPath, session.baseagent);
+            for (const sdkSession of sdkSessions) {
+                if (!sdkSession.title)
+                    continue;
+                const dbSession = currentProjectSessions.find((s) => s.agentSessionId === sdkSession.sessionId);
+                if (dbSession && sdkSession.title !== dbSession.name) {
+                    await this.sessionManager.renameSession(dbSession.id, sdkSession.title);
+                    dbSession.name = sdkSession.title;
+                }
+            }
+        }
+        catch (error) {
+            logger.debug('[CommandHandler] SDK listSessions sync failed (non-critical):', error);
+        }
+        // 构建可显示会话列表（复用于卡片和文本）
+        const maxDisplay = 10;
+        const displaySessions = [];
+        let displayIndex = 0;
+        for (let i = 0; i < currentProjectSessions.length; i++) {
+            const s = currentProjectSessions[i];
+            if (displayIndex >= maxDisplay)
+                break;
+            const isActive = s.metadata?.isActive === true;
+            displayIndex++;
+            const name = displaySessionTitle(s.name, '(未命名)');
+            const idleTime = formatIdleTime(Date.now() - s.updatedAt);
+            const fileMissing = !!(s.agentSessionId && !this.sessionManager.checkSessionFileExists(s.projectPath, s.agentSessionId, s.baseagent));
+            let status = '[空闲]';
+            if (fileMissing) {
+                status = '[会话文件缺失]';
+            }
+            else if (!!s.processingState) {
+                status = '[处理中]';
+            }
+            else if (isActive) {
+                status = '[活跃]';
+            }
+            displaySessions.push({ session: s, index: displayIndex, isActive, name, status, idleTime, fileMissing });
+        }
+        // 尝试发送 CommandCard 卡片（每个会话一个按钮，一键切换）
+        if (this.interactionRouter && displaySessions.length >= 1) {
+            const bodyLines = displaySessions.map(ds => {
+                const prefix = ds.isActive ? '✓' : '•';
+                const uuid = ds.session.agentSessionId ? `(${ds.session.agentSessionId.substring(0, 8)})` : '';
+                const fileMark = ds.fileMissing ? '❌ ' : '';
+                return `${prefix} ${ds.index}. ${fileMark}**${ds.name}** ${uuid}  ${ds.idleTime} ${ds.status}`;
+            });
+            const interaction = {
+                type: 'interaction',
+                id: `slist-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`,
+                channelId,
+                sessionId: session.id,
+                initiatorId: userId,
+                kind: {
+                    kind: 'command-card',
+                    title: `📋 ${path.basename(session.projectPath)} 会话列表`,
+                    body: bodyLines.join('\n'),
+                    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 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.baseagent}] 会话列表:`, ''];
+        if (currentProjectSessions.length > 0) {
+            for (const ds of displaySessions) {
+                const prefix = ds.isActive ? '  ✓' : '   ';
+                const num = `${ds.index}.`;
+                const uuid = ds.session.agentSessionId ? `(${ds.session.agentSessionId.substring(0, 8)})` : '';
+                if (ds.fileMissing) {
+                    lines.push(`${prefix} ${num} ❌ ${ds.name} ${uuid} - ${ds.idleTime} ${ds.status}`);
+                }
+                else {
+                    lines.push(`${prefix} ${num} ${ds.name} ${uuid} - ${ds.idleTime} ${ds.status}`);
+                }
+            }
+            const hiddenCount = currentProjectSessions.length - displayIndex;
+            if (hiddenCount > 0) {
+                const parts = [];
+                if (hiddenCount > 0)
+                    parts.push(`${hiddenCount} 个更早的会话`);
+                lines.push(`\n  (已隐藏 ${parts.join('、')})`);
+            }
+            lines.push('');
+        }
+        lines.push('使用 /s <序号、name或8位uuid> 切换会话');
+        lines.push('使用 /s cli 查看 CLI 会话');
+        return { kind: 'command.result', text: lines.join('\n') };
+    }
+    // /session（无参数）：直接复用 /slist 逻辑（含卡片交互）
+    if (normalizedContent === '/session') {
+        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') {
+        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 { kind: 'command.result', text: '用法: /s <序号、会话名称或前8位UUID>' };
+        let targetSession = await this.sessionManager.getSessionByName(channel, channelId, sessionName);
+        // 序号切换：纯数字时按 /slist 显示的序号匹配（超过10个时隐藏非活跃话题会话）
+        if (!targetSession && /^\d+$/.test(sessionName) && session) {
+            const idx = parseInt(sessionName, 10);
+            const allSessions = await this.sessionManager.listSessions(channel, channelId);
+            const visibleSessions = allSessions.filter((s) => s.projectPath === session.projectPath && s.baseagent === session.baseagent && !s.threadId);
+            if (idx >= 1 && idx <= visibleSessions.length) {
+                targetSession = visibleSessions[idx - 1];
+            }
+            else {
+                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?.threadId) {
+            return { kind: 'command.error', text: `❌ 话题会话不支持通过 /s 切换\n请在对应话题内继续对话` };
+        }
+        const canImport = policy.canImportCliSession(session?.chatType || 'private', identity.role);
+        if (!targetSession && sessionName.length >= 8 && canImport) {
+            const projectPaths = Object.values(this.projects);
+            if (session) {
+                projectPaths.unshift(session.projectPath);
+            }
+            for (const projectPath of projectPaths) {
+                const currentBaseagent = session?.baseagent || this.primaryRunnerKey;
+                const cliSessions = await this.sessionManager.listImportableCliSessions(projectPath, currentBaseagent);
+                const cliSession = cliSessions.find((c) => c.uuid.startsWith(sessionName));
+                if (cliSession) {
+                    const imported = await this.sessionManager.importCliSession(channel, channelId, projectPath, cliSession.uuid, currentBaseagent);
+                    this.eventBus.publish({ type: 'session:imported', sessionId: imported.id, agentSessionId: cliSession.uuid, projectPath });
+                    const projectName = this.getProjectName(projectPath);
+                    return { kind: 'command.result', text: `✓ 已导入 CLI 会话: ${displaySessionTitle(imported.name, '(未命名)')}\n  项目: ${projectName}\n  将继续之前的对话历史` };
+                }
+            }
+        }
+        if (!targetSession) {
+            return { kind: 'command.error', text: `❌ 会话不存在: ${sessionName}\n使用 /s 查看可用会话` };
+        }
+        const lastInput = targetSession.agentSessionId
+            ? this.sessionManager.readSessionLastUserMessage(targetSession.projectPath, targetSession.agentSessionId, targetSession.baseagent)
+            : null;
+        const lastInputLine = lastInput ? `\n  最后输入: "${lastInput}"` : '';
+        if (!session) {
+            const switched = await this.sessionManager.switchToSession(channel, channelId, targetSession.id);
+            if (!switched) {
+                return { kind: 'command.error', text: `❌ 切换会话失败` };
+            }
+            if (this.shouldSuppressCardTriggerResult(source, channel))
+                return null;
+            return { kind: 'command.result', text: `✓ 已切换到会话: ${displaySessionTitle(targetSession.name, sessionName)}\n  项目: ${path.basename(targetSession.projectPath)}${lastInputLine}` };
+        }
+        if (targetSession.id === session.id) {
+            return { kind: 'command.result', text: `当前已在会话: ${displaySessionTitle(targetSession.name, sessionName)}` };
+        }
+        // 阻止从主会话切换到话题会话
+        if (!session.threadId && targetSession.threadId) {
+            return { kind: 'command.error', text: `❌ 无法从主会话切换到话题会话\n话题会话仅在对应话题内可用` };
+        }
+        const switched = await this.sessionManager.switchToSession(channel, channelId, targetSession.id);
+        if (!switched) {
+            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  当前会话未有发言';
+        if (this.shouldSuppressCardTriggerResult(source, channel))
+            return null;
+        return { kind: 'command.result', text: `✓ 已切换到会话: ${displaySessionTitle(targetSession.name, sessionName)}${continueHint}${lastInputLine}` };
+    }
+    // /rename 或 /name 命令：重命名当前会话
+    if (normalizedContent === '/rename' || normalizedContent === '/name') {
+        return { kind: 'command.result', text: '用法: /name <新名称> 或 /rename <新名称>' };
+    }
+    if (normalizedContent.startsWith('/rename ')) {
+        const newName = normalizedContent.slice(8).trim();
+        if (!newName)
+            return { kind: 'command.result', text: '用法: /name <新名称> 或 /rename <新名称>' };
+        if (!session) {
+            return { kind: 'command.error', text: `❌ 当前没有活跃会话
+
+请先执行以下操作之一：
+1. 发送任意消息 - 自动创建新会话
+2. /new [名称] - 创建命名会话
+3. /session <名称> - 切换到已有会话` };
+        }
+        const existing = await this.sessionManager.getSessionByName(channel, channelId, newName);
+        if (existing && existing.id !== session.id) {
+            return { kind: 'command.error', text: `❌ 会话名称 "${newName}" 已存在，请使用其他名称` };
+        }
+        const oldName = displaySessionTitle(session.name, '(未命名)');
+        const success = await this.sessionManager.renameSession(session.id, newName);
+        if (success && session.agentSessionId) {
+            const renameAgent = this.getAgent(channel, session.baseagent);
+            await renameAgent.setSessionName?.(session.agentSessionId, newName).catch((error) => {
+                logger.debug('[CommandHandler] Backend session rename sync failed:', error);
+            });
+        }
+        if (!success) {
+            return { kind: 'command.error', text: `❌ 重命名失败` };
+        }
+        this.eventBus.publish({ type: 'session:renamed', sessionId: session.id, oldName, newName });
+        return { kind: 'command.result', text: `✓ 已将当前会话重命名为: ${newName}` };
+    }
+    // /del 命令：删除指定会话（仅解绑，不删除文件）
+    if (normalizedContent.startsWith('/del ')) {
+        const sessionName = normalizedContent.slice(5).trim();
+        if (!sessionName)
+            return { kind: 'command.result', text: '用法: /del <序号、会话名称或前8位UUID>' };
+        if (!session) {
+            return { kind: 'command.error', text: `❌ 当前没有活跃会话` };
+        }
+        // 权限检查：policy 控制谁可以删除会话
+        if (!policy.canDeleteSession(session.chatType || 'private', identity.role)) {
+            return { kind: 'command.error', text: `❌ 无权限：群聊中仅管理员可删除会话` };
+        }
+        let targetSession = await this.sessionManager.getSessionByName(channel, channelId, sessionName);
+        // 序号删除（与 /slist 显示序号一致）
+        if (!targetSession && /^\d+$/.test(sessionName)) {
+            const idx = parseInt(sessionName, 10);
+            const allSessions = await this.sessionManager.listSessions(channel, channelId);
+            const visibleSessions = allSessions.filter((s) => s.projectPath === session.projectPath && s.baseagent === session.baseagent && !s.threadId);
+            if (idx >= 1 && idx <= visibleSessions.length) {
+                targetSession = visibleSessions[idx - 1];
+            }
+            else {
+                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?.threadId) {
+            return { kind: 'command.error', text: `❌ 请使用话题管理删除话题会话` };
+        }
+        if (!targetSession) {
+            return { kind: 'command.error', text: `❌ 会话不存在: ${sessionName}\n使用 /s 查看可用会话` };
+        }
+        if (targetSession.id === session.id) {
+            return { kind: 'command.error', text: `❌ 无法删除当前活跃会话\n请先切换到其他会话` };
+        }
+        const success = await this.sessionManager.unbindSession(targetSession.id);
+        if (!success) {
+            return { kind: 'command.error', text: `❌ 删除失败` };
+        }
+        this.eventBus.publish({ type: 'session:deleted', sessionId: targetSession.id });
+        const targetAgent = this.getAgent(channel, targetSession.baseagent);
+        await targetAgent.closeSession(targetSession.id);
+        return { kind: 'command.result', text: `✓ 已删除会话: ${displaySessionTitle(targetSession.name, sessionName)}\n会话文件已保留，可通过 CLI 访问` };
+    }
+    // /fork 命令：分支当前会话
+    if (normalizedContent === '/fork' || normalizedContent.startsWith('/fork ')) {
+        const forkName = normalizedContent.slice(5).trim() || undefined;
+        if (!session) {
+            return { kind: 'command.error', text: `❌ 当前没有活跃会话，无法分支` };
+        }
+        if (!session.agentSessionId) {
+            return { kind: 'command.error', text: `❌ 当前会话尚未初始化对话，无法分支\n\n请先发送一条消息，然后再使用 /fork` };
+        }
+        const forkAgent = this.getAgent(channel, session.baseagent);
+        if (!forkAgent.capabilities?.fork) {
+            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);
+            await forkAgent.updateSessionMetadata?.(forkedSessionId, {
+                gitInfo: {
+                    branch: null,
+                    commitHash: null,
+                    repositoryUrl: null,
+                },
+                evolcoreSessionId: newSession.id,
+                sourceSessionId: session.id,
+            }).catch((error) => {
+                logger.debug('[CommandHandler] Backend fork metadata sync failed:', error);
+            });
+            this.eventBus.publish({ type: 'session:forked', sessionId: newSession.id, sourceSessionId: session.id, name: forkName });
+            return { kind: 'command.result', text: `✅ 会话已分支: ${displaySessionTitle(newSession.name, '(未命名)')}\n新会话已激活，可以继续对话\n\n使用 /s 查看所有会话，/s <名称> 切换回原会话` };
+        }
+        catch (error) {
+            logger.error('[CommandHandler] Fork session failed:', error);
+            return { kind: 'command.error', text: `❌ 会话分支失败: ${error instanceof Error ? error.message : '未知错误'}` };
+        }
+    }
+    // /rewind 命令：查看历史 / 回退会话
+    if (normalizedContent === '/rewind' || normalizedContent.startsWith('/rewind ')) {
+        const session = await getExistingSessionForCommand();
+        if (!session)
+            return { kind: 'command.error', text: '❌ 当前没有活跃会话' };
+        const rewindBaseagent = session.baseagent ?? session.agentId;
+        const rewindAgent = this.getAgent(channel, rewindBaseagent);
+        if (!session.agentSessionId) {
+            return { kind: 'command.error', text: '❌ 当前会话无历史记录\n\n请先发送一条消息，然后再使用 /rewind' };
+        }
+        if (!rewindAgent.getSessionMessages) {
+            return { kind: 'command.error', text: `❌ 当前 Agent (${rewindAgent.name}) 不支持 /rewind` };
+        }
+        const args = normalizedContent.slice('/rewind'.length).trim();
+        if (!args) {
+            return { kind: 'command.result', text: await this.handleRewindList(session, rewindAgent) };
+        }
+        // 带参（执行回退，会删除文件/改对话）需 admin+
+        if (!isAdmin)
+            return { kind: 'command.error', text: '❌ 无权限：回退操作仅限管理员使用' };
+        const parts = args.split(/\s+/);
+        const turnNum = parseInt(parts[0], 10);
+        if (isNaN(turnNum) || turnNum < 1) {
+            return { kind: 'command.error', text: '❌ 无效轮次，用法：/rewind <N> chat|file|all（撤销第N轮）' };
+        }
+        const mode = parts[1]?.toLowerCase();
+        if (!mode) {
+            return { kind: 'command.error', text: `❌ 请指定回退模式：/rewind ${turnNum} chat | file | all（撤销第${turnNum}轮）` };
+        }
+        if (!['chat', 'file', 'all'].includes(mode)) {
+            return { kind: 'command.error', text: `❌ 无效模式 "${mode}"，可选：chat | file | all` };
+        }
+        return { kind: 'command.result', text: await this.handleRewind(session, rewindAgent, turnNum, mode) };
+    }
+    // /repair 命令：检查并修复会话文件
+    if (normalizedContent === '/repair') {
+        const repairSession = await getExistingSessionForCommand();
+        if (!repairSession)
+            return { kind: 'command.result', text: '当前没有活跃会话' };
+        const repairAgent = this.getAgent(channel, repairSession.baseagent);
+        const { checkSessionFile, backupSessionFile } = await import('../session/session-file-health.js');
+        try {
+            if (!repairSession.agentSessionId) {
+                await this.sessionManager.resetHealthStatus(repairSession.id);
+                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 { kind: 'command.result', text: `✓ 修复完成\n\n修复内容：\n- 会话文件不存在（可能已被清理）\n- 已重置异常计数器` };
+            }
+            const healthCheck = await checkSessionFile(sessionFile);
+            if (healthCheck.corrupt) {
+                const backupPath = await backupSessionFile(sessionFile);
+                const fsPromises = await import('fs/promises');
+                await fsPromises.unlink(sessionFile);
+                await this.sessionManager.updateAgentSessionIdBySessionId(repairSession.id, '');
+                repairAgent.updateSessionId(repairSession.id, '');
+                await this.sessionManager.resetHealthStatus(repairSession.id);
+                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 { kind: 'command.error', text: `⚠️ 检测到问题：\n${healthCheck.issues.map((i) => `- ${i}`).join('\n')}\n\n建议使用 /new 创建新会话\n\n已重置异常计数器，可继续使用当前会话。` };
+            }
+            await this.sessionManager.resetHealthStatus(repairSession.id);
+            return { kind: 'command.result', text: `✓ 修复完成\n\n修复内容：\n- 未发现问题\n- 已重置异常计数器` };
+        }
+        catch (error) {
+            logger.error('[Repair] Failed:', error);
+            return { kind: 'command.error', text: `❌ 修复失败: ${error.message}` };
+        }
+    }
+    // /trigger 命令
+    if (normalizedContent === '/trigger' || normalizedContent.startsWith('/trigger ')) {
+        const triggerAuthDenied = await authorizeIntent({
+            intent: {
+                operation: triggerOperationForSlash(normalizedContent),
+                scope: 'relation',
+                source: 'slash',
+                args: {},
+            },
+            identity,
+            session: activeSession,
+            explicitChatType: activeChatType === 'private' || activeChatType === 'group' ? activeChatType : undefined,
+            channel,
+            channelId,
+            userId,
+            selfAid: selfAID ?? this.resolveSelfAID(channel),
+            isDaemonOwner,
+        });
+        if (triggerAuthDenied)
+            return triggerAuthDenied;
+        const text = await this.handleTrigger(normalizedContent, channel, channelId, userId ?? '', isAdmin, messageId, chatType, threadId);
+        return { kind: 'command.result', text };
+    }
+    return null;
+}