evolcore 0.0.1 → 0.0.3

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

@@ -0,0 +1,1733 @@
+import { BaseagentRunnerUnavailableError } from '../../agents/runner-types.js';
+import { renderCommandCardAsText } from '../interaction-router.js';
+import { buildEnvelope, sendInteractionPayload } from '../message/message-utils.js';
+import { resolvePaths, getPackageRoot } from '../../paths.js';
+import { loadDaemonConfig } from '../../config-store.js';
+import { logger } from '../../utils/logger.js';
+import { resolvePeerRoleDetail, roleToSessionIdentity } from '../../config/peer-role-resolver.js';
+import { isManagementRole } from '../../config/builtin-roles.js';
+import { formatPeerKey } from '../relation/peer-identity.js';
+import crypto from 'crypto';
+import path from 'path';
+import { parseDuration, parseTriggerSet, parseTriggerUpdate } from '../../trigger/parser.js';
+import { applyTriggerPatch, replaceEditableTriggerDefinition } from '../../trigger/patch.js';
+import { definitionRevision } from '../../trigger/validation.js';
+import { tryParseChannelKey } from '../channel-loader.js';
+import { displaySessionTitle } from '../session/session-title.js';
+import { buildSessionTurnList } from '../session/session-turns.js';
+import { resolveConfigCommand } from '../../config/resolved-config-op.js';
+import { AUTHENTICATED_CONFIG_ROLE_ENV, executeResolvedConfigCommand } from '../../config/config-operation-service.js';
+import { hashArgv } from '../auth/authorization-audit.js';
+import { executeResolvedContactCommand, resolveContactCommand } from '../../config/contact-operation-service.js';
+import { authorizeOperation, buildAuthSubject } from '../auth/auth-gateway.js';
+import { validateModelSelectionForRole } from '../model/model-permission.js';
+import { constrainRuntimePermissionMode, validateRuntimeStringFieldOverride } from '../role/runtime-policy.js';
+import { parsePeerKey } from '../relation/peer-identity.js';
+import { isQuickCommand } from './slash-gate.js';
+import { handleSlashCommand } from './slash-handler.js';
+import { resolveChatMode } from '../message/peer-mode.js';
+import { execMenuAction as menuExecMenuAction, execMenuForEcweb as menuExecMenuForEcweb, execMenuForControl as menuExecMenuForControl, execMenuQuery as menuExecMenuQuery, execMenuUpdate as menuExecMenuUpdate, getMenuItems as menuGetMenuItems, getSubMenuItems as menuGetSubMenuItems, } from './menu-handler.js';
+export { isProcessLevelOwner } from './menu-handler.js';
+const CLI_EXEC_TIMEOUT_MS = 15_000;
+const CLI_EXEC_MAX_OUTPUT = 128 * 1024;
+/**
+ * 写入用户级 ~/.claude/settings.json（与 Claude CLI 行为一致）
+ * ⚠️ 已禁用：按需求不再修改用户的 ~/.claude/settings.json 文件。
+ *    原会把 model/effortLevel 写入 settings.json（仅在找不到 owning agent 的 fallback 路径触发）。
+ *    现直接返回成功且不落盘；如需恢复，取消下方注释即可。
+ */
+function writeUserSettings(updates) {
+    void updates;
+    return { success: true };
+    /* eslint-disable no-unreachable */
+    // try {
+    //   const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
+    //   let settings: any = {};
+    //
+    //   if (fs.existsSync(settingsPath)) {
+    //     settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+    //   }
+    //
+    //   if (updates.model !== undefined) settings.model = updates.model;
+    //   if (updates.effortLevel !== undefined) {
+    //     if (updates.effortLevel === null) {
+    //       delete settings.effortLevel;
+    //     } else {
+    //       settings.effortLevel = updates.effortLevel;
+    //     }
+    //   }
+    //
+    //   const claudeDir = path.join(os.homedir(), '.claude');
+    //   if (!fs.existsSync(claudeDir)) {
+    //     fs.mkdirSync(claudeDir, { recursive: true });
+    //   }
+    //
+    //   fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
+    //   return { success: true };
+    // } catch (error: any) {
+    //   return { success: false, error: error.message };
+    // }
+    /* eslint-enable no-unreachable */
+}
+function isAdminRole(role) {
+    return isManagementRole(role);
+}
+export class CommandHandler {
+    sessionManager;
+    messageCache;
+    eventBus;
+    adapters = new Map();
+    policies = new Map();
+    channelObjects = new Map(); // name → actual channel instance (for /check)
+    channelTypeMap = new Map(); // name → channelType (for grouping)
+    processor;
+    messageQueue;
+    permissionGateway;
+    interactionRouter;
+    statsCollector;
+    agentMap;
+    primaryRunnerKey;
+    agentRegistry;
+    triggerSchedulerResolver;
+    triggerSchedulerFallback;
+    triggerSchedulerFallbackAid;
+    daemonStatusProvider;
+    agentDelegationRegistry;
+    /**
+     * Get the runner for a (channel, baseagent) pair.
+     *
+     * Resolves the owning EvolAgent via the registry. If the owner is known and
+     * the requested baseagent runner is absent, do not silently fall back to a
+     * different backend; that would corrupt session metadata.
+     */
+    getAgent(channel, baseagent) {
+        if (channel && baseagent) {
+            const owner = this.agentRegistry?.resolveByChannel(channel);
+            const evolName = owner?.name || '<unknown>';
+            const key = `${evolName}::${baseagent}`;
+            if (this.agentMap.has(key))
+                return this.agentMap.get(key);
+            if (owner) {
+                throw new BaseagentRunnerUnavailableError(evolName, baseagent, this.getAvailableBaseagentsForOwner(evolName));
+            }
+            const globalRunner = [...this.agentMap.entries()]
+                .find(([runnerKey]) => runnerKey === baseagent || runnerKey.endsWith(`::${baseagent}`));
+            if (globalRunner)
+                return globalRunner[1];
+        }
+        if (this.agentMap.has(this.primaryRunnerKey))
+            return this.agentMap.get(this.primaryRunnerKey);
+        return this.agentMap.values().next().value;
+    }
+    getAvailableBaseagentsForOwner(evolName) {
+        const prefix = `${evolName}::`;
+        return [...this.agentMap.keys()]
+            .filter(key => key.startsWith(prefix))
+            .map(key => key.slice(prefix.length));
+    }
+    formatBaseagentUnavailable(error) {
+        const available = error.availableBaseagents.length ? error.availableBaseagents.join(', ') : '(none)';
+        return `❌ 当前会话绑定的 baseagent 不可用: ${error.baseagent}\nAgent: ${error.evolagentName}\n可用: ${available}\n请使用 /baseagent 切换到可用后端。`;
+    }
+    /**
+     * Return the list of baseagents available to a given channel.
+     *
+     * Agent channels stay isolated to their owning EvolAgent. Control/daemon
+     * channels are virtual and have no owner, so expose the loaded runner types
+     * globally for menu.options(name=baseagent).
+     */
+    getAvailableBaseagents(channel) {
+        const owner = this.agentRegistry?.resolveByChannel(channel);
+        if (!owner) {
+            const result = new Set();
+            for (const key of this.agentMap.keys()) {
+                const idx = key.indexOf('::');
+                result.add(idx >= 0 ? key.slice(idx + 2) : key);
+            }
+            return [...result];
+        }
+        const evolName = owner.name || '<unknown>';
+        const prefix = `${evolName}::`;
+        const result = [];
+        for (const key of this.agentMap.keys()) {
+            if (key.startsWith(prefix))
+                result.push(key.slice(prefix.length));
+        }
+        return result;
+    }
+    /** Extract the baseagent component from `primaryRunnerKey` (e.g. `aid::claude` → `claude`). */
+    parseDefaultBaseagent() {
+        const idx = this.primaryRunnerKey.indexOf('::');
+        return idx >= 0 ? this.primaryRunnerKey.slice(idx + 2) : this.primaryRunnerKey;
+    }
+    constructor(sessionManager, agentRunnerOrMap, messageCache, eventBus, primaryRunnerKey) {
+        this.sessionManager = sessionManager;
+        this.messageCache = messageCache;
+        this.eventBus = eventBus;
+        if (agentRunnerOrMap instanceof Map) {
+            this.agentMap = agentRunnerOrMap;
+            this.primaryRunnerKey = primaryRunnerKey || '<unknown>::claude';
+        }
+        else {
+            // 测试 / 单 runner 路径：占位 agent name 用 '<unknown>'
+            this.agentMap = new Map([[`<unknown>::${agentRunnerOrMap.name}`, agentRunnerOrMap]]);
+            this.primaryRunnerKey = `<unknown>::${agentRunnerOrMap.name}`;
+        }
+    }
+    /** 注入 EvolAgentRegistry，用于判断通道是否被 EvolAgent 管理 */
+    setAgentRegistry(registry) {
+        this.agentRegistry = registry;
+    }
+    setTriggerSchedulerResolver(resolver) {
+        this.triggerSchedulerResolver = resolver;
+    }
+    /** Compatibility entrypoint for older tests/callers that inject a single scheduler. */
+    setTriggerScheduler(scheduler, manager) {
+        this.triggerSchedulerFallback = scheduler;
+        this.triggerSchedulerFallbackAid = manager?.agentAid;
+        this.triggerSchedulerResolver = (agentAid) => {
+            if (!this.triggerSchedulerFallbackAid || agentAid === this.triggerSchedulerFallbackAid) {
+                return scheduler;
+            }
+            return undefined;
+        };
+    }
+    setDaemonStatusProvider(provider) {
+        this.daemonStatusProvider = provider;
+    }
+    /** 返回管理当前通道的 EvolAgent，无则返回 null */
+    getOwningAgent(channel) {
+        if (!this.agentRegistry)
+            return null;
+        return this.agentRegistry.resolveByChannel(channel);
+    }
+    getTriggerSchedulerForChannel(channel) {
+        const agentAid = this.getOwningAgent(channel)?.aid ?? tryParseChannelKey(channel)?.selfAID;
+        return agentAid ? this.triggerSchedulerResolver?.(agentAid) : this.triggerSchedulerFallback;
+    }
+    getTriggerSchedulerForAgent(agentAid) {
+        return this.triggerSchedulerResolver?.(agentAid) ?? (this.triggerSchedulerFallbackAid === agentAid ? this.triggerSchedulerFallback : undefined);
+    }
+    triggerSourceFromSchedule(scheduleType, scheduleValue) {
+        if (scheduleType === 'once')
+            return { type: 'once' };
+        if (scheduleType === 'delay')
+            return { type: 'delay', afterMs: this.triggerDurationMs(scheduleValue) };
+        if (scheduleType === 'at')
+            return { type: 'at', at: scheduleValue };
+        if (scheduleType === 'cron')
+            return { type: 'cron', expression: scheduleValue };
+        if (scheduleType === 'interval')
+            return { type: 'interval', everyMs: this.triggerDurationMs(scheduleValue) };
+        if (scheduleType === 'event')
+            return { type: 'event', eventPattern: scheduleValue };
+        throw new Error(`unsupported scheduleType: ${scheduleType}`);
+    }
+    triggerDurationMs(value) {
+        const numeric = Number(value);
+        if (Number.isFinite(numeric))
+            return numeric;
+        const parsed = parseDuration(value);
+        if (parsed != null)
+            return parsed;
+        return Number.NaN;
+    }
+    scheduleViewFromSource(source) {
+        switch (source.type) {
+            case 'once': return { scheduleType: 'once', scheduleValue: '' };
+            case 'delay': return { scheduleType: 'delay', scheduleValue: String(source.afterMs) };
+            case 'at': return { scheduleType: 'at', scheduleValue: source.at };
+            case 'cron': return { scheduleType: 'cron', scheduleValue: source.expression };
+            case 'interval': return { scheduleType: 'interval', scheduleValue: String(source.everyMs) };
+            case 'event': return { scheduleType: 'event', scheduleValue: source.eventPattern };
+        }
+    }
+    triggerPrompt(definition) {
+        return definition.execution.type === 'script'
+            ? (definition.feedback.onReply?.template ?? '')
+            : (definition.execution.prompt ?? '');
+    }
+    definitionToTriggerView(definition, scheduler) {
+        const target = this.primaryFeedbackTarget(definition);
+        const schedule = this.scheduleViewFromSource(definition.source);
+        let schedulerDetails;
+        try {
+            schedulerDetails = scheduler?.show(definition.id);
+        }
+        catch { /* trigger state is best-effort for views */ }
+        // 运行统计（fireCount/failCount/lastFiredAt/lastResult）不写入 trigger.json，
+        // 按需从 append-only trigger history 汇总。
+        let stats = { fireCount: 0, failCount: 0 };
+        try {
+            if (scheduler?.stats)
+                stats = scheduler.stats(definition.id);
+        }
+        catch { /* trigger history 缺失/损坏时退回零值 */ }
+        return {
+            id: definition.id,
+            name: definition.name,
+            enabled: definition.enabled,
+            scheduleType: schedule.scheduleType,
+            scheduleValue: schedule.scheduleValue,
+            nextFireAt: definition.source.type === 'delay'
+                ? definition.createdAt + definition.source.afterMs
+                : definition.source.type === 'at'
+                    ? new Date(definition.source.at).getTime()
+                    : definition.source.type === 'event'
+                        ? undefined
+                        : schedulerDetails?.schedule?.nextFireAt,
+            targetChannel: target?.channelKey,
+            targetChannelName: target?.channelKey,
+            targetChannelId: target?.channelId,
+            targetChannelType: target ? this.resolveChannelType(target.channelKey) : undefined,
+            executionType: definition.execution.type,
+            feedbackStrategy: definition.feedback.strategy,
+            targetSessionStrategy: target?.session ?? 'main',
+            targetThreadId: target?.threadId,
+            model: definition.execution.model,
+            effort: definition.execution.effort,
+            permissionMode: definition.execution.permissionMode,
+            prompt: this.triggerPrompt(definition),
+            createdByPeerId: definition.origin?.peerId ?? '',
+            createdByChannel: definition.origin?.channelKey ?? '',
+            schedulerAid: definition.agentAid,
+            fireCount: stats.fireCount,
+            failCount: stats.failCount,
+            lastFiredAt: stats.lastFiredAt,
+            lastResult: stats.lastResult,
+            lastScheduledAt: schedulerDetails?.schedule?.lastScheduledAt,
+            createdAt: definition.createdAt,
+            updatedAt: definition.updatedAt,
+            status: definition.enabled ? 'active' : 'disabled',
+            limits: definition.limits,
+            limitState: schedulerDetails?.limitState,
+            subscription: schedulerDetails?.subscription,
+        };
+    }
+    primaryFeedbackTarget(definition) {
+        if (definition.feedback.strategy === 'target')
+            return definition.feedback.target;
+        if (!definition.origin)
+            return undefined;
+        return {
+            channelKey: definition.origin.channelKey,
+            channelId: definition.origin.channelId,
+            session: definition.origin.session,
+            threadId: definition.origin.threadId,
+        };
+    }
+    canAccessTriggerDefinition(definition, peerId, channel, isAdmin) {
+        if (isAdmin)
+            return true;
+        return definition.origin?.peerId === peerId && definition.origin?.channelKey === channel;
+    }
+    triggerPermissionFromParsed(parsed) {
+        return parsed.permissionMode ?? undefined;
+    }
+    validateTriggerPermissionModeForRole(mode, isAdmin, role, selfAid) {
+        if (!mode)
+            return undefined;
+        if (!role) {
+            if (mode === 'bypass' && !isAdmin)
+                return '无权限：只有 owner/admin 可以创建或修改 bypass trigger';
+            return undefined;
+        }
+        const decision = constrainRuntimePermissionMode({ selfAid, role, requestedValue: mode });
+        if (decision.constrained)
+            return `无权限：角色 ${role} 不能使用 ${mode} trigger permissionMode`;
+        return undefined;
+    }
+    triggerRoleContext(selfAid, channel, peerId, chatType) {
+        const owning = this.getOwningAgent(channel);
+        if (!owning || owning.aid !== selfAid)
+            return {};
+        const role = resolvePeerRoleDetail({
+            selfAid,
+            channelKey: channel,
+            channelType: this.resolveChannelType(channel),
+            chatType: chatType === 'group' ? 'group' : 'private',
+            actorId: peerId,
+            conversationId: peerId,
+        }).effectiveRole;
+        return { role: role || 'none', baseagent: owning.baseagent };
+    }
+    validateTriggerRuntimeFields(definition, role, baseagent) {
+        if (!role)
+            return undefined;
+        const executionBaseagent = definition.execution.type === 'trigger_session'
+            ? definition.execution.baseagent ?? baseagent
+            : baseagent;
+        if (definition.execution.model) {
+            const modelDecision = validateModelSelectionForRole({
+                role,
+                baseagent: executionBaseagent,
+                requestedModel: definition.execution.model,
+                selfAid: definition.agentAid,
+            });
+            if (!modelDecision.ok)
+                return modelDecision.message || '当前角色不允许使用该 Trigger 模型';
+        }
+        if (definition.execution.effort) {
+            const base = executionBaseagent || 'claude';
+            const effortDecision = validateRuntimeStringFieldOverride({
+                selfAid: definition.agentAid,
+                role,
+                field: `baseagents.${base}.${base === 'codex' ? 'reasoning' : 'effort'}`,
+                value: definition.execution.effort,
+            });
+            if (!effortDecision.ok)
+                return effortDecision.message || '当前角色不允许使用该 Trigger 推理强度';
+        }
+        return undefined;
+    }
+    findTriggerDefinition(scheduler, nameOrId, peerId, channel, isAdmin) {
+        return scheduler
+            .list({ all: true })
+            .find(definition => (definition.id === nameOrId || definition.name === nameOrId)
+            && this.canAccessTriggerDefinition(definition, peerId, channel, isAdmin));
+    }
+    async buildTriggerDefinitionFromParsed(parsed, channel, channelId, peerId, isAdmin, messageId, chatType, threadId) {
+        const now = Date.now();
+        const id = `trig_${now}_${crypto.randomBytes(4).toString('hex')}`;
+        const name = parsed.name ?? `trigger-${now.toString(36)}`;
+        const feedbackChannel = parsed.targetChannel ?? channel;
+        if (parsed.targetChannel && !this.adapters.has(parsed.targetChannel)) {
+            return { error: `目标渠道不存在或未启用：${parsed.targetChannel}` };
+        }
+        const targetChannelType = this.resolveChannelType(feedbackChannel);
+        const feedbackChannelId = parsed.targetChannelId ?? peerId;
+        if (targetChannelType === 'aun' && parsed.targetChannelId && !parsed.targetChannelId.includes('.')) {
+            return { error: `AUN 渠道的 --target-channel-id 必须是 AID 格式（如 user.agentid.pub），收到："${parsed.targetChannelId}"` };
+        }
+        const schedulerAid = parsed.agentId
+            ?? this.getOwningAgent(feedbackChannel)?.aid
+            ?? tryParseChannelKey(feedbackChannel)?.selfAID
+            ?? this.triggerSchedulerFallbackAid;
+        const scheduler = schedulerAid ? this.getTriggerSchedulerForAgent(schedulerAid) : this.triggerSchedulerFallback;
+        if (!schedulerAid || !scheduler) {
+            return { error: `目标 agent 不存在或未就绪：${schedulerAid ?? feedbackChannel}` };
+        }
+        const target = {
+            channelKey: feedbackChannel,
+            channelId: feedbackChannelId,
+            session: parsed.targetSession,
+            threadId: parsed.targetSession === 'thread' ? parsed.targetThreadId : undefined,
+        };
+        if (target.session === 'thread') {
+            const adapter = this.adapters.get(feedbackChannel);
+            if (!adapter?.capabilities.thread)
+                return { error: '目标渠道不支持 thread 会话' };
+            if (!target.threadId)
+                return { error: '--target-session thread 需要 --target-thread-id' };
+        }
+        const originIsGroup = chatType === 'group';
+        const activeSession = originIsGroup
+            ? undefined
+            : this.sessionManager.getActiveSessionSync(channel, peerId, this.resolveChannelType(channel), schedulerAid);
+        const origin = {
+            channelKey: channel,
+            channelType: this.resolveChannelType(channel),
+            channelId: peerId,
+            session: !originIsGroup && threadId ? 'thread' : 'main',
+            threadId: !originIsGroup ? threadId : undefined,
+            peerId,
+            sessionKey: activeSession?.sessionKey,
+        };
+        if (!isAdmin && parsed.feedbackStrategy === 'target' && !sameFeedbackTarget(target, origin)) {
+            return { error: '无权限：非 admin 只能把 trigger 投递到来源会话' };
+        }
+        const source = this.triggerSourceFromSchedule(parsed.scheduleType, parsed.scheduleValue);
+        if (parsed.timezone && source.type === 'cron') {
+            source.timezone = parsed.timezone;
+        }
+        const script = parsed.scriptPath ? {
+            path: parsed.scriptPath,
+            runtime: parsed.scriptRuntime,
+            args: parsed.scriptArgs,
+            timeoutMs: parsed.scriptTimeoutMs ?? 30_000,
+        } : undefined;
+        const permissionMode = this.triggerPermissionFromParsed(parsed);
+        const triggerRole = this.triggerRoleContext(schedulerAid, channel, peerId, chatType);
+        const permissionError = this.validateTriggerPermissionModeForRole(permissionMode, isAdmin, triggerRole.role, schedulerAid);
+        if (permissionError)
+            return { error: permissionError };
+        if (parsed.baseagent !== undefined) {
+            if (typeof parsed.baseagent !== 'string' || !parsed.baseagent.trim()) {
+                return { error: 'Trigger baseagent 不能为空' };
+            }
+            if (parsed.executionType !== 'trigger_session') {
+                return { error: 'Trigger baseagent 仅适用于 trigger_session' };
+            }
+        }
+        const triggerOwner = this.agentRegistry?.get?.(schedulerAid) ?? this.getOwningAgent(channel);
+        const executionBaseagent = parsed.executionType === 'trigger_session'
+            ? parsed.baseagent?.trim() ?? triggerOwner?.baseagent ?? triggerRole.baseagent
+            : undefined;
+        if (parsed.executionType === 'trigger_session') {
+            if (!executionBaseagent)
+                return { error: '无法确定 Trigger 会话的 baseagent' };
+            const ownerName = triggerOwner?.name || '<unknown>';
+            const available = this.getAvailableBaseagentsForOwner(ownerName);
+            if (!available.includes(executionBaseagent)) {
+                return {
+                    error: `Trigger baseagent 不可用：${executionBaseagent}（可用：${available.join(' / ') || '无'}）`,
+                };
+            }
+        }
+        const definition = {
+            $schema_version: 3.1,
+            id,
+            agentAid: schedulerAid,
+            enabled: true,
+            name,
+            createdAt: now,
+            updatedAt: now,
+            origin,
+            source,
+            execution: {
+                type: parsed.executionType,
+                ...(script ? { script } : { prompt: parsed.prompt || '' }),
+                ...(parsed.executionType === 'trigger_session' ? {
+                    thread: parsed.triggerThread ?? 'by_trigger',
+                    baseagent: executionBaseagent,
+                } : {}),
+                model: parsed.model,
+                effort: parsed.effort,
+                ...(permissionMode !== undefined ? { permissionMode } : {}),
+                onError: 'retry',
+                noopSentinel: '[[NOOP]]',
+            },
+            feedback: {
+                strategy: parsed.feedbackStrategy,
+                ...(parsed.feedbackStrategy === 'target' ? { target } : {}),
+            },
+            reliability: {
+                concurrency: 'forbid',
+                missedPolicy: 'run_once',
+                retry: { maxAttempts: 0, backoffMs: 30_000 },
+            },
+            limits: this.limitsFromParsed(parsed),
+        };
+        const runtimeFieldError = this.validateTriggerRuntimeFields(definition, triggerRole.role, triggerRole.baseagent);
+        if (runtimeFieldError)
+            return { error: runtimeFieldError };
+        return { definition, scheduler };
+    }
+    /** 返回当前通道的有效项目路径：从 owning agent 取。*/
+    getEffectiveDefaultPath(channel) {
+        const owning = this.getOwningAgent(channel);
+        if (owning)
+            return owning.projectPath;
+        return process.cwd();
+    }
+    /**
+     * 持久化 baseagent.model：写到 agent config.json；找不到 owning agent 时
+     * 退到用户级 ~/.claude/settings.json（Claude 专用）。
+     */
+    persistBaseagentModel(channel, baseagentName, newModel) {
+        const owning = this.getOwningAgent(channel);
+        if (owning) {
+            try {
+                owning.setBaseagentModel(newModel, baseagentName);
+            }
+            catch (e) {
+                return `⚠️ 写入 agent config 失败: ${e?.message || e}`;
+            }
+            return undefined;
+        }
+        // 无 owning agent（罕见，新结构下应当不会发生）→ 仅 Claude 走用户级 fallback
+        if (baseagentName !== 'claude') {
+            return `⚠️ 找不到通道 "${channel}" 所属的 self-agent`;
+        }
+        const updates = {};
+        if (newModel)
+            updates.model = newModel;
+        const writeResult = writeUserSettings(updates);
+        // writeUserSettings 已禁用写入，总是返回 success: true
+        if (!writeResult.success) {
+            return `⚠️ 写入用户配置失败: ${writeResult.error}`;
+        }
+        return undefined;
+    }
+    /**
+     * 持久化 baseagent.effort：写到 agent config.json；找不到时退到用户级 settings。
+     */
+    persistBaseagentEffort(channel, baseagentName, newEffort) {
+        const owning = this.getOwningAgent(channel);
+        if (owning) {
+            try {
+                owning.setBaseagentEffort(newEffort, baseagentName);
+            }
+            catch (e) {
+                return `⚠️ 写入 agent config 失败: ${e?.message || e}`;
+            }
+            return undefined;
+        }
+        if (baseagentName !== 'claude') {
+            return `⚠️ 找不到通道 "${channel}" 所属的 self-agent`;
+        }
+        const updates = { effortLevel: newEffort ?? null };
+        const writeResult = writeUserSettings(updates);
+        // writeUserSettings 已禁用写入，总是返回 success: true
+        if (!writeResult.success) {
+            return `⚠️ 写入用户配置失败: ${writeResult.error}`;
+        }
+        return undefined;
+    }
+    /** 项目列表快捷访问（无 channel 上下文时的 fallback，尽量不用） */
+    get projects() {
+        return {};
+    }
+    /** 根据项目路径查找配置中的项目名称 */
+    getConfiguredProjectName(projectPath) {
+        return Object.entries(this.projects).find(([_, p]) => p === projectPath)?.[0];
+    }
+    /** 根据项目路径查找项目名称（未配置时回退到目录名） */
+    getProjectName(projectPath) {
+        return this.getConfiguredProjectName(projectPath) || path.basename(projectPath);
+    }
+    /** 格式化运行时间 */
+    formatUptime(ms) {
+        const sec = Math.floor(ms / 1000);
+        const d = Math.floor(sec / 86400);
+        const h = Math.floor((sec % 86400) / 3600);
+        const m = Math.floor((sec % 3600) / 60);
+        const s = sec % 60;
+        const parts = [];
+        if (d > 0)
+            parts.push(`${d}天`);
+        if (h > 0)
+            parts.push(`${h}时`);
+        if (m > 0)
+            parts.push(`${m}分`);
+        if (parts.length === 0)
+            parts.push(`${s}秒`);
+        return parts.join('');
+    }
+    /** 获取消息队列 key：话题用 session.id，主会话用 channel-channelId */
+    getQueueKey(session, _channel, _channelId) {
+        // 队列和 agent 均使用 session.id 作为 key
+        return session?.id || '';
+    }
+    /** 从 session 提取渠道预构建的回复上下文 */
+    getReplyContext(session) {
+        return session.metadata?.replyContext;
+    }
+    /**
+     * 发送 CommandCard 卡片。卡片成功返回 null（调用方直接 return），失败返回降级文本。
+     * CommandCard 不进 InteractionRouter，按钮点击由 channel 直接构造伪命令入站消息。
+     *
+     * 走统一 adapter.send(envelope, { kind: 'interaction', ... }) 入口。
+     */
+    async sendCommandCard(opts) {
+        const adapter = this.adapters.get(opts.channel);
+        if (opts.interaction.kind.kind !== 'command-card') {
+            logger.warn(`[CommandHandler] sendCommandCard called with non-CommandCard kind`);
+            return null;
+        }
+        const card = opts.interaction.kind;
+        if (opts.canWrite === false)
+            return renderCommandCardAsText(card);
+        if (!adapter?.send)
+            return renderCommandCardAsText(card);
+        try {
+            const envelope = buildEnvelope({
+                channel: opts.channel,
+                channelId: opts.channelId,
+                agentName: this.agentRegistry?.resolveByChannel(opts.channel)?.name,
+                replyContext: opts.replyCtx,
+            });
+            const fallbackText = renderCommandCardAsText(card);
+            const messageId = await sendInteractionPayload(adapter, envelope, opts.interaction, fallbackText, opts.replyCtx);
+            if (messageId)
+                return null;
+        }
+        catch (e) {
+            logger.warn(`[CommandHandler] sendCommandCard failed: ${e}`);
+        }
+        return renderCommandCardAsText(card);
+    }
+    /**
+     * 通用降级应答入口：按 (sessionId, fallbackCommand) 查找 pending interaction 并路由。
+     * 返回 { matched: true } 表示已处理，调用方直接返回 result。
+     */
+    async handleInteractionFallback(command, args, sessionId, userId) {
+        if (!this.interactionRouter)
+            return { matched: false };
+        const pendingId = this.interactionRouter.findPendingByCommand(sessionId, command);
+        if (!pendingId)
+            return { matched: false };
+        const initiatorId = this.interactionRouter.getInitiator(pendingId);
+        if (initiatorId && initiatorId !== userId) {
+            return { matched: true, result: '⚠️ 仅卡片发起者可应答' };
+        }
+        const handled = this.interactionRouter.handle({
+            type: 'interaction.response',
+            id: pendingId,
+            action: args,
+            operatorId: userId,
+        });
+        return { matched: true, result: handled ? '✓ 已回答' : '⚠️ 无法验证应答者身份' };
+    }
+    setProcessor(processor) {
+        this.processor = processor;
+    }
+    setMessageQueue(messageQueue) {
+        this.messageQueue = messageQueue;
+    }
+    setPermissionGateway(gateway) {
+        this.permissionGateway = gateway;
+    }
+    setInteractionRouter(router) {
+        this.interactionRouter = router;
+    }
+    setStatsCollector(collector) {
+        this.statsCollector = collector;
+    }
+    registerAdapter(adapter) {
+        this.adapters.set(adapter.channelName, adapter);
+    }
+    registerChannel(name, channel, channelType) {
+        this.channelObjects.set(name, channel);
+        if (channelType)
+            this.channelTypeMap.set(name, channelType);
+    }
+    hasRegisteredChannel(channelName, channelType) {
+        if (!this.channelObjects.has(channelName))
+            return false;
+        return channelType === undefined || this.resolveChannelType(channelName) === channelType;
+    }
+    /** 将实例名解析为渠道类型（用于 session 查询） */
+    resolveChannelType(channelName) {
+        return this.channelTypeMap.get(channelName) || tryParseChannelKey(channelName)?.type || channelName;
+    }
+    /** CommandCard success is acknowledged by the card UI; failures still return command.error text. */
+    shouldSuppressCardTriggerResult(source, _channel) {
+        return source === 'card-trigger';
+    }
+    /**
+     * 从 channel key（<type>#<selfAID>#<name>）解析本地身份 AID。
+     * 非 evolagent 通道（裸 channelType，如 'feishu'）解析失败返回 undefined。
+     * aun 通道创建 session 时必须提供 selfAID，故所有 getOrCreateSession 调用都经此兜底。
+     */
+    resolveSelfAID(channel) {
+        return tryParseChannelKey(channel)?.selfAID;
+    }
+    resolveCtlIdentity(session, userId) {
+        const parsed = tryParseChannelKey(session.channel);
+        const owningAgent = this.getOwningAgent(session.channel);
+        const selfAid = session.selfAID || owningAgent?.aid || parsed?.selfAID;
+        const channelType = session.channelType || parsed?.type || this.resolveChannelType(session.channel);
+        const chatType = session.chatType === 'group' ? 'group' : 'private';
+        const actorId = userId || session.metadata?.peerId;
+        const conversationId = chatType === 'group'
+            ? (session.metadata?.groupId || session.channelId)
+            : actorId;
+        if (!selfAid || !actorId || !conversationId) {
+            const fallback = session.identity ?? this.sessionManager.resolveIdentity(session.channel, userId, chatType, conversationId ?? undefined);
+            logger.info(`[ctl] identity fallback: sessionId=${session.id} role=${fallback.role} selfAid=${selfAid ?? 'none'} actor=${actorId ?? 'none'} conversation=${conversationId ?? 'none'}`);
+            return fallback;
+        }
+        const detail = resolvePeerRoleDetail({
+            selfAid,
+            channelKey: session.channel,
+            channelType,
+            chatType,
+            actorId,
+            conversationId,
+            peerType: session.metadata?.peerType,
+        });
+        logger.info(`[ctl] identity resolved: sessionId=${session.id} role=${detail.effectiveRole} source=${detail.source} selfAid=${selfAid} actor=${actorId} conversation=${conversationId}`);
+        return roleToSessionIdentity(detail.effectiveRole);
+    }
+    registerPolicy(channelName, policy) {
+        this.policies.set(channelName, policy);
+    }
+    /**
+     * 注销渠道（热重载断开渠道时调用）。清理所有按实例名登记的 map，
+     * 避免死实例残留在 /status、菜单路由和 adapter 查找里。
+     */
+    unregisterChannel(channelName) {
+        this.adapters.delete(channelName);
+        this.channelObjects.delete(channelName);
+        this.channelTypeMap.delete(channelName);
+        this.policies.delete(channelName);
+    }
+    getAdapter(channelName) {
+        // 先按实例名查找，再按 channelType 查找
+        let adapter = this.adapters.get(channelName);
+        if (adapter)
+            return adapter;
+        for (const [name, a] of this.adapters) {
+            if ((this.channelTypeMap.get(name) || name) === channelName)
+                return a;
+        }
+        return undefined;
+    }
+    getPolicy(channel) {
+        return this.policies.get(channel) || {
+            canSwitchProject: () => true,
+            canListProjects: () => true,
+            canCreateSession: () => true,
+            canDeleteSession: () => true,
+            canImportCliSession: () => true,
+            messagePrefix: () => '',
+            showMiddleResult: () => true,
+            showIdleMonitor: () => true,
+            accumulateErrors: () => true,
+        };
+    }
+    resolveMenuChatType(channel, channelId, explicit) {
+        if (explicit)
+            return explicit;
+        const active = this.sessionManager.getActiveSessionSync(channel, channelId);
+        return active?.chatType === 'group' ? 'group' : 'private';
+    }
+    canReadTopics(role) {
+        return role !== 'none';
+    }
+    canDeleteTopic(role, chatType, topic, userId) {
+        if (role === 'none')
+            return false;
+        if (isAdminRole(role))
+            return true;
+        if (chatType === 'group')
+            return false;
+        return !!userId && topic.metadata?.peerId === userId;
+    }
+    buildTopicMenuItem(s) {
+        const displayName = displaySessionTitle(s.name, s.threadId || s.id.slice(0, 8));
+        const item = {
+            value: s.threadId,
+            label: displayName,
+        };
+        if (s.agentSessionId) {
+            item.agentSessionId = s.agentSessionId;
+            const fileInfo = this.sessionManager.getSessionFileInfo(s.projectPath, s.agentSessionId, s.baseagent);
+            if (fileInfo.turns)
+                item.turns = fileInfo.turns;
+            const firstMsg = this.sessionManager.readSessionFirstMessage(s.projectPath, s.agentSessionId, s.baseagent);
+            if (firstMsg)
+                item.preview = firstMsg.length > 80 ? firstMsg.slice(0, 80) + '...' : firstMsg;
+        }
+        if (s.updatedAt)
+            item.lastActive = s.updatedAt;
+        return item;
+    }
+    /**
+     * 返回结构化命令菜单（供 menu.query 使用）
+     * owner 看到全部命令，admin 看到管理级命令（不含 owner-only），visitor/member 仅看到用户级命令
+     */
+    getMenuItems(role, chatType = 'private', scope = 'agent') {
+        return menuGetMenuItems.call(this, role, chatType, scope);
+    }
+    /** 动态子菜单：根据 cmd 路径返回选项列表（供 menu.query + cmd 使用） */
+    async getSubMenuItems(cmd, channel, channelId, userId, args, overrideIdentity, explicitChatType, fromControlChannel = false, authSubject, source = 'menu') {
+        return await menuGetSubMenuItems.call(this, cmd, channel, channelId, userId, args, overrideIdentity, explicitChatType, fromControlChannel, authSubject, source);
+    }
+    // ── Menu Protocol exec ────────────────────────────────────────────────
+    async loadMenuContext(channel, channelId) {
+        const session = await this.sessionManager.getActiveSession(channel, channelId);
+        const evolagent = this.agentRegistry?.resolveByChannel(channel) ?? null;
+        return { session, evolagent };
+    }
+    requireSession(s) {
+        return s ? null : { error: '当前无活跃会话', code: 'NO_ACTIVE_SESSION' };
+    }
+    /** menu.query — 查询当前值。 */
+    async execMenuQuery(cmd, channel, channelId, userId, args, explicitChatType, fromControlChannel = false, overrideIdentity, authSubject, source = 'menu') {
+        return await menuExecMenuQuery.call(this, cmd, channel, channelId, userId, args, explicitChatType, fromControlChannel, overrideIdentity, authSubject, source);
+    }
+    /** menu.update — 写入新值。 */
+    async execMenuUpdate(cmd, value, channel, channelId, userId, overrideIdentity, fromControlChannel = false, args, authSubject, source = 'menu') {
+        return await menuExecMenuUpdate.call(this, cmd, value, channel, channelId, userId, overrideIdentity, fromControlChannel, args, authSubject, source);
+    }
+    /** menu.action — 触发动词。 */
+    async execMenuAction(cmd, action, args, channel, channelId, userId, overrideIdentity, explicitChatType, requestId, fromControlChannel = false, authSubject, source = 'menu') {
+        return await menuExecMenuAction.call(this, cmd, action, args, channel, channelId, userId, overrideIdentity, explicitChatType, requestId, fromControlChannel, authSubject, source);
+    }
+    /** ECWeb 专用入口：身份只取可信 IPC 信封。 */
+    async execMenuForEcweb(payload, auth) {
+        return await menuExecMenuForEcweb.call(this, payload, auth);
+    }
+    /** 控制 AID channel 专用入口：peerId 须 ∈ evolcore.owners，全量权限。 */
+    async execMenuForControl(payload, peerId) {
+        return await menuExecMenuForControl.call(this, payload, peerId);
+    }
+    /**
+     * CLI 透传执行：spawn `node dist/cli/index.js <argv>` 子进程，捕获输出回传。
+     * 不 in-process 调用（CLI handler 用 console.log + process.exit，spawn 行为与终端一致且隔离）。
+     * 调用方已完成 owner 校验与白名单过滤。
+     */
+    async execCliPassthrough(argv, authenticatedRole) {
+        const { spawn } = await import('child_process');
+        const cliEntry = path.join(getPackageRoot(), 'dist', 'cli', 'index.js');
+        const startedAt = Date.now();
+        return await new Promise((resolve) => {
+            let stdout = '';
+            let stderr = '';
+            let total = 0;
+            let truncated = false;
+            let settled = false;
+            let stdoutChunks = 0;
+            let stderrChunks = 0;
+            const child = spawn('node', [cliEntry, ...argv], {
+                env: {
+                    ...process.env,
+                    EVOLCORE_HOME: resolvePaths().root,
+                    ...(authenticatedRole ? { [AUTHENTICATED_CONFIG_ROLE_ENV]: authenticatedRole } : {}),
+                },
+                windowsHide: true,
+            });
+            const append = (buf, sink) => {
+                if (truncated)
+                    return;
+                const remaining = CLI_EXEC_MAX_OUTPUT - total;
+                if (remaining <= 0) {
+                    truncated = true;
+                    return;
+                }
+                const chunk = buf.length > remaining ? buf.subarray(0, remaining) : buf;
+                total += chunk.length;
+                if (sink === 'out') {
+                    stdout += chunk.toString('utf-8');
+                    stdoutChunks++;
+                }
+                else {
+                    stderr += chunk.toString('utf-8');
+                    stderrChunks++;
+                }
+                if (buf.length > remaining)
+                    truncated = true;
+            };
+            child.stdout?.on('data', (b) => {
+                append(b, 'out');
+            });
+            child.stderr?.on('data', (b) => {
+                append(b, 'err');
+            });
+            const timer = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch { }
+                logger.warn(`[CommandHandler] cli exec timeout: command=${argv[0] || '<none>'} durationMs=${CLI_EXEC_TIMEOUT_MS}`);
+                resolve({ error: `CLI execution exceeded ${CLI_EXEC_TIMEOUT_MS / 1000}s`, code: 'EXECUTION_TIMEOUT' });
+            }, CLI_EXEC_TIMEOUT_MS);
+            child.on('error', (e) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                logger.warn(`[CommandHandler] cli exec unavailable: command=${argv[0] || '<none>'} code=${e?.code || 'unknown'}`);
+                resolve({ error: 'CLI execution infrastructure is unavailable', code: 'TEMPORARILY_UNAVAILABLE' });
+            });
+            child.on('close', (exitCode) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                const elapsed = Date.now() - startedAt;
+                resolve({ data: {
+                        exitCode: exitCode ?? -1,
+                        stdout, stderr, truncated,
+                        durationMs: elapsed,
+                    } });
+            });
+        });
+    }
+    /** 把 menu.action 委派给已有 slash 命令处理逻辑，把 OutboundPayload 包成结构化结果。 */
+    async delegateAsAction(action, slashCmd, channel, channelId, userId, opts = {}) {
+        try {
+            const result = await this._handleInternal(slashCmd, channel, channelId, undefined, userId, undefined, undefined, undefined, undefined, undefined, opts.overrideIdentity, opts.authSubject);
+            if (result == null) {
+                // null / undefined: 命令未识别或前置守卫拦截（如 idle 检查），视为失败
+                return { error: '命令未执行（可能被前置守卫拦截）', code: 'EXEC_FAILED' };
+            }
+            if (typeof result !== 'object' || !('kind' in result)) {
+                return { data: { action, success: true } };
+            }
+            const payload = result;
+            if (payload.kind === 'command.error') {
+                return { error: payload.text || '执行失败', code: 'EXEC_FAILED' };
+            }
+            const data = payload.structured && typeof payload.structured === 'object'
+                ? { ...payload.structured }
+                : {};
+            data.action = action;
+            data.success = true;
+            if (payload.text)
+                data.message = payload.text;
+            if (payload.structured && typeof payload.structured === 'object') {
+                data.structured = payload.structured;
+            }
+            // 对于切换/创建类动作，附加切换后的活跃 session 信息便于客户端继续操作
+            if (opts.enrichSession) {
+                const newSession = await this.sessionManager.getActiveSession(channel, channelId);
+                if (newSession) {
+                    data.session = { id: newSession.id, name: newSession.name || null };
+                    if (newSession.agentSessionId)
+                        data.session.agentSessionId = newSession.agentSessionId;
+                }
+            }
+            return { data };
+        }
+        catch (e) {
+            return { error: e?.message || String(e), code: 'INTERNAL' };
+        }
+    }
+    isCommand(content) {
+        return isQuickCommand(content);
+    }
+    /**
+     * 主命令处理入口
+     */
+    async handle(content, channel, channelId, sendMessage, userId, threadId, chatType, source, messageId, selfAID, overrideIdentity, authSubject, replyContext) {
+        try {
+            const result = await this._handleInternal(content, channel, channelId, sendMessage, userId, threadId, chatType, source, messageId, selfAID, overrideIdentity, authSubject, replyContext);
+            return result;
+        }
+        catch (error) {
+            if (error instanceof BaseagentRunnerUnavailableError) {
+                logger.error(`[CommandHandler] baseagent mismatch blocked: channel=${channel} requested=${error.baseagent} owner=${error.evolagentName} available=${error.availableBaseagents.join(',') || '<none>'}`);
+                return { kind: 'command.error', text: this.formatBaseagentUnavailable(error), reason: error.code };
+            }
+            throw error;
+        }
+    }
+    async _handleInternal(content, channel, channelId, sendMessage, userId, threadId, chatType, source, messageId, selfAID, overrideIdentity, authSubject, replyContext) {
+        return await handleSlashCommand.call(this, content, channel, channelId, sendMessage, userId, threadId, chatType, source, messageId, selfAID, overrideIdentity, authSubject, replyContext);
+    }
+    async handleTriggerCommand(scheduler, content, channel, channelId, peerId, isAdmin, messageId, chatType, threadId) {
+        if (content === '/trigger') {
+            const visible = scheduler
+                .list()
+                .filter(definition => this.canAccessTriggerDefinition(definition, peerId, channel, isAdmin));
+            if (visible.length === 0)
+                return '📭 当前没有活跃的触发器';
+            const lines = visible.map(definition => {
+                const view = this.definitionToTriggerView(definition, scheduler);
+                const next = view.nextFireAt ? new Date(view.nextFireAt).toLocaleString() : '未计算';
+                return `• **${view.name}** [${view.scheduleType}] 下次: ${next}`;
+            });
+            return `📋 活跃触发器（${visible.length} 个）：\n\n${lines.join('\n')}`;
+        }
+        const sub = content.slice('/trigger '.length).trim();
+        if (sub === 'list' || sub.startsWith('list ')) {
+            const includeDisabled = sub.includes('--all') || sub.includes('all');
+            const visible = scheduler
+                .list({ all: includeDisabled })
+                .filter(definition => this.canAccessTriggerDefinition(definition, peerId, channel, isAdmin));
+            if (visible.length === 0)
+                return '📭 没有触发器记录';
+            const lines = visible.map(definition => {
+                const view = this.definitionToTriggerView(definition, scheduler);
+                const next = view.nextFireAt ? new Date(view.nextFireAt).toLocaleString() : '未计算';
+                const status = definition.enabled ? 'active' : 'disabled';
+                return `• ${view.name} [${view.scheduleType}] ${status} | 下次: ${next}`;
+            });
+            return `📋 触发器（${visible.length} 个）：\n\n${lines.join('\n')}`;
+        }
+        // Helper: extract nameOrId and find trigger with permission check
+        const extractAndFindTrigger = (sub, prefix, action) => {
+            const nameOrId = sub.slice(prefix.length).trim();
+            if (!nameOrId)
+                throw new Error(`❌ 用法：/trigger ${action} <名称>`);
+            const definition = this.findTriggerDefinition(scheduler, nameOrId, peerId, channel, isAdmin);
+            if (!definition) {
+                throw new Error(isAdmin
+                    ? `❌ 未找到触发器：${nameOrId}`
+                    : `❌ 未找到触发器 "${nameOrId}"，或无权限${action === 'show' ? '查看' : '修改'}`);
+            }
+            return { definition, nameOrId };
+        };
+        if (sub.startsWith('cancel ')) {
+            const { definition } = extractAndFindTrigger(sub, 'cancel ', 'cancel');
+            const cancelled = scheduler.cancel(definition.id);
+            this.eventBus.publish({ type: 'trigger:cancelled', triggerId: cancelled.id, name: cancelled.name, by: peerId });
+            return `✅ 触发器已禁用：**${cancelled.name}**`;
+        }
+        if (sub.startsWith('delete ') || sub.startsWith('remove ') || sub.startsWith('rm ')) {
+            const prefix = sub.startsWith('delete ') ? 'delete ' : sub.startsWith('remove ') ? 'remove ' : 'rm ';
+            const { definition } = extractAndFindTrigger(sub, prefix, 'delete');
+            const deleted = scheduler.delete(definition.id);
+            return `✅ 触发器已删除：**${deleted.name}**`;
+        }
+        if (sub.startsWith('enable ')) {
+            const { definition } = extractAndFindTrigger(sub, 'enable ', 'enable');
+            scheduler.setEnabled(definition.id, true);
+            return `✅ 触发器已启用：**${definition.name}**`;
+        }
+        if (sub.startsWith('disable ')) {
+            const { definition } = extractAndFindTrigger(sub, 'disable ', 'disable');
+            scheduler.setEnabled(definition.id, false);
+            return `✅ 触发器已暂停：**${definition.name}**`;
+        }
+        if (sub.startsWith('show ')) {
+            const { definition } = extractAndFindTrigger(sub, 'show ', 'show');
+            const details = scheduler.show(definition.id);
+            const view = this.definitionToTriggerView(definition, scheduler);
+            const nextStr = view.nextFireAt ? new Date(view.nextFireAt).toLocaleString() : '未计算';
+            const activeRuns = details.active?.length ?? 0;
+            const recentRuns = details.recentRuns?.slice(0, 5) ?? [];
+            let output = `📋 **${definition.name}** (${definition.id})\n`;
+            output += `状态: ${definition.enabled ? 'active' : 'disabled'}\n`;
+            output += `调度: ${view.scheduleType} | 下次: ${nextStr}\n`;
+            output += `处理: ${definition.execution.type}\n`;
+            output += `模型: ${definition.execution.model ?? 'inherit'}\n`;
+            output += `推理强度: ${definition.execution.effort ?? 'inherit'}\n`;
+            output += `权限: ${definition.execution.permissionMode ?? 'inherit'}\n`;
+            output += `反馈: ${definition.feedback.strategy}\n`;
+            if (definition.execution.type === 'script')
+                output += `脚本: ${this.scriptCommandLabel(definition.execution.script)}\n`;
+            if (definition.limits?.maxRuns !== undefined || definition.limits?.maxDuration !== undefined) {
+                const limitParts = [
+                    definition.limits.maxRuns !== undefined ? `maxRuns=${definition.limits.maxRuns}` : undefined,
+                    definition.limits.maxDuration !== undefined ? `maxDuration=${definition.limits.maxDuration}` : undefined,
+                ].filter(Boolean);
+                output += `限制: ${limitParts.join(', ')}\n`;
+            }
+            if (details.limitState) {
+                const stateParts = [
+                    `runCount=${details.limitState.runCount}`,
+                    `startedAt=${new Date(details.limitState.startedAt).toLocaleString()}`,
+                    details.limitState.disabledReason ? `disabledReason=${details.limitState.disabledReason}` : undefined,
+                ].filter(Boolean);
+                if (definition.limits?.maxDuration) {
+                    stateParts.push(`expiresAt=${new Date(details.limitState.startedAt + this.limitDurationMs(definition.limits.maxDuration)).toLocaleString()}`);
+                }
+                output += `限制状态: ${stateParts.join(', ')}\n`;
+            }
+            output += `活跃运行: ${activeRuns}\n`;
+            if (recentRuns.length > 0) {
+                output += `\n最近运行:\n`;
+                for (const r of recentRuns) {
+                    const ts = new Date(r.finishedAt).toLocaleString();
+                    output += `  • ${r.status} ${r.reason ?? ''} (${ts})\n`;
+                }
+            }
+            return output;
+        }
+        if (sub.startsWith('run ')) {
+            const args = sub.slice('run '.length).trim();
+            const parts = args.split(/\s+/);
+            const dryRunIdx = parts.indexOf('--dry-run');
+            const dryRun = dryRunIdx >= 0;
+            const nameOrId = dryRunIdx >= 0
+                ? parts.filter((_, i) => i !== dryRunIdx).join(' ').trim()
+                : args.trim();
+            if (!nameOrId)
+                return '❌ 用法：/trigger run <名称> [--dry-run]';
+            const definition = this.findTriggerDefinition(scheduler, nameOrId, peerId, channel, isAdmin);
+            if (!definition) {
+                return isAdmin
+                    ? `❌ 未找到触发器：${nameOrId}`
+                    : `❌ 未找到触发器 "${nameOrId}"，或无权限执行`;
+            }
+            try {
+                const result = await scheduler.run(definition.id, { dryRun });
+                const prefix = dryRun ? '🔍 试运行' : '▶️ 手动触发';
+                return `${prefix}：**${definition.name}**\n状态: ${result.status}${result.reason ? ` (${result.reason})` : ''}`;
+            }
+            catch (err) {
+                return `❌ 执行失败：${err?.message || err}`;
+            }
+        }
+        if (sub.startsWith('update ')) {
+            const args = sub.slice('update '.length);
+            const result = parseTriggerUpdate(args);
+            if (!result.ok)
+                return `❌ ${result.error}`;
+            const updated = await this.updateTriggerFromPatch(scheduler, result.nameOrId, result.value, channel, channelId, peerId, isAdmin, messageId, threadId);
+            if (!updated.ok)
+                return `❌ ${updated.error}`;
+            const nextStr = updated.trigger.nextFireAt ? new Date(updated.trigger.nextFireAt).toLocaleString() : '未计算';
+            return `✅ 触发器已更新：**${updated.trigger.name}**\n下次触发：${nextStr}`;
+        }
+        const createSubcommand = sub.startsWith('create ')
+            ? 'create'
+            : sub.startsWith('set ')
+                ? 'set'
+                : undefined;
+        if (createSubcommand) {
+            const args = sub.slice(`${createSubcommand} `.length);
+            const result = parseTriggerSet(args);
+            if (!result.ok)
+                return `❌ ${result.error}`;
+            const reg = await this.registerTriggerFromParsed(result.value, channel, channelId, peerId, messageId, chatType, threadId, isAdmin);
+            if (!reg.ok)
+                return `❌ ${reg.error}`;
+            const nextStr = reg.trigger.nextFireAt ? new Date(reg.trigger.nextFireAt).toLocaleString() : '未计算';
+            return `✅ 触发器已注册：**${reg.trigger.name}**\n下次触发：${nextStr}`;
+        }
+        return `❌ 未知子命令。用法：
+/trigger — 查看活跃触发器
+/trigger list [--all] — 查看所有触发器
+/trigger create <参数> — 创建触发器（set 为兼容别名）
+/trigger update <名称|ID> <参数> — 修改触发器
+常用参数：--delay/--at/--cron/--every、--prompt、--model、--effort、--permission（省略则继承；update 可用 inherit 清除覆盖）
+/trigger enable <名称|ID> — 启用触发器
+/trigger disable <名称|ID> — 暂停触发器
+/trigger show <名称|ID> — 查看触发器详情
+/trigger run <名称|ID> [--dry-run] — 手动触发
+/trigger cancel <名称|ID> — 禁用触发器（disable 的兼容别名）
+/trigger delete <名称|ID> — 删除触发器`;
+    }
+    async handleTrigger(content, channel, channelId, peerId, isAdmin, messageId, chatType, threadId) {
+        const scheduler = this.getTriggerSchedulerForChannel(channel);
+        if (!scheduler)
+            return '⚠️ 触发器功能未启用';
+        return await this.handleTriggerCommand(scheduler, content, channel, channelId, peerId, isAdmin, messageId, chatType, threadId);
+    }
+    async updateTriggerFromPatch(scheduler, nameOrId, patch, channel, channelId, peerId, isAdmin, messageId, threadId) {
+        const definition = this.findTriggerDefinition(scheduler, nameOrId, peerId, channel, isAdmin);
+        if (!definition) {
+            return { ok: false, error: isAdmin ? `未找到触发器：${nameOrId}` : `未找到触发器 "${nameOrId}"，或无权限修改` };
+        }
+        const currentRevision = definitionRevision(definition);
+        const hasFullDefinition = patch?.definition !== undefined;
+        const expectedRevision = patch?.expectedRevision;
+        if (expectedRevision !== undefined && (typeof expectedRevision !== 'string' || !expectedRevision.trim())) {
+            return { ok: false, code: 'INVALID_REVISION', error: 'expectedRevision 必须是非空字符串', currentRevision };
+        }
+        if (hasFullDefinition && expectedRevision === undefined) {
+            return {
+                ok: false,
+                code: 'REVISION_REQUIRED',
+                error: '完整 Trigger 定义替换必须提供 expectedRevision，请刷新后重试',
+                currentRevision,
+            };
+        }
+        if (expectedRevision !== undefined && expectedRevision !== currentRevision) {
+            return {
+                ok: false,
+                code: 'REVISION_CONFLICT',
+                error: `Trigger 已被其他修改，请刷新后重试（expected ${expectedRevision}, current ${currentRevision}）`,
+                currentRevision,
+            };
+        }
+        let updated;
+        try {
+            const { nameOrId: _nameOrId, expectedRevision: _expectedRevision, ...definitionPatch } = patch;
+            updated = definitionPatch.definition !== undefined
+                ? replaceEditableTriggerDefinition(definition, definitionPatch.definition)
+                : applyTriggerPatch(definition, definitionPatch);
+        }
+        catch (err) {
+            return { ok: false, error: err?.message || String(err) };
+        }
+        const target = this.primaryFeedbackTarget(updated);
+        if (!isAdmin && target && !sameFeedbackTarget(target, definition.origin)) {
+            return { ok: false, error: '无权限：非 admin 只能把 trigger 投递到来源会话' };
+        }
+        if (!isAdmin && updated.execution.type === 'script') {
+            return { ok: false, error: '无权限：只有 owner/admin 可以修改 script trigger' };
+        }
+        const triggerRole = this.triggerRoleContext(definition.agentAid, definition.origin?.channelKey || channel, definition.origin?.peerId || peerId);
+        const permissionError = this.validateTriggerPermissionModeForRole(updated.execution.permissionMode, isAdmin, triggerRole.role, definition.agentAid);
+        if (permissionError)
+            return { ok: false, error: permissionError };
+        const runtimeFieldError = this.validateTriggerRuntimeFields(updated, triggerRole.role, triggerRole.baseagent);
+        if (runtimeFieldError)
+            return { ok: false, error: runtimeFieldError };
+        try {
+            const saved = scheduler.update(definition.id, updated);
+            return {
+                ok: true,
+                trigger: this.definitionToTriggerView(saved, scheduler),
+                revision: definitionRevision(saved),
+            };
+        }
+        catch (err) {
+            return { ok: false, error: `更新失败：${err?.message || err}` };
+        }
+    }
+    /** 从已解析的 trigger 参数组装 definition 并注册。文本路径（handleTrigger）与 menu 路径共用。
+     *  parsed 形状 = parseTriggerSet 的 result.value（ParsedTriggerSet）。
+     *  失败 return { ok:false, error }；成功 return { ok:true, trigger }。 */
+    async registerTriggerFromParsed(parsed, channel, channelId, peerId, messageId, chatType, threadId, isAdmin = false) {
+        const built = await this.buildTriggerDefinitionFromParsed(parsed, channel, channelId, peerId, isAdmin, messageId, chatType, threadId);
+        if ('error' in built)
+            return { ok: false, error: built.error };
+        try {
+            const created = built.scheduler.create(built.definition, [], { enable: true });
+            return { ok: true, trigger: this.definitionToTriggerView(created, built.scheduler) };
+        }
+        catch (err) {
+            return { ok: false, error: `注册失败：${err?.message || err}` };
+        }
+    }
+    limitsFromParsed(parsed) {
+        const limits = {};
+        if (parsed.maxRuns !== undefined)
+            limits.maxRuns = parsed.maxRuns;
+        if (parsed.maxDuration !== undefined)
+            limits.maxDuration = parsed.maxDuration;
+        return limits.maxRuns === undefined && limits.maxDuration === undefined ? undefined : limits;
+    }
+    scriptCommandLabel(script) {
+        const args = Array.isArray(script.args) ? script.args.map(arg => this.shellQuoteArg(String(arg))).join(' ') : '';
+        const command = this.shellQuoteArg(script.path);
+        return `${script.runtime} ${command}${args ? ` ${args}` : ''}`;
+    }
+    shellQuoteArg(value) {
+        if (!value)
+            return "''";
+        return /[\s"'\\]/.test(value) ? `"${value.replace(/(["\\$`])/g, '\\$1')}"` : value;
+    }
+    limitDurationMs(value) {
+        const amount = Number(value.slice(0, -1));
+        const unit = value.slice(-1);
+        if (unit === 'd')
+            return amount * 86_400_000;
+        if (unit === 'h')
+            return amount * 3_600_000;
+        if (unit === 'm')
+            return amount * 60_000;
+        return amount * 1_000;
+    }
+    // ── /rewind helpers ──
+    async handleRewindList(session, agent) {
+        try {
+            const messages = await agent.getSessionMessages(session.agentSessionId, session.projectPath);
+            const turns = buildSessionTurnList(messages);
+            if (turns.length === 0) {
+                return '📋 当前会话暂无对话记录';
+            }
+            const lines = turns.map(t => `#${t.index} ${t.userContent}`);
+            return [
+                `📋 会话历史 (共 ${turns.length} 轮)`,
+                '',
+                ...lines,
+                '',
+                '💡 /rewind <N> chat|file|all — 撤销第N轮',
+            ].join('\n');
+        }
+        catch (error) {
+            logger.error('[CommandHandler] Failed to read session messages:', error);
+            return `❌ 读取会话历史失败: ${error instanceof Error ? error.message : '未知错误'}`;
+        }
+    }
+    async handleRewind(session, agent, turnNum, mode) {
+        try {
+            const messages = await agent.getSessionMessages(session.agentSessionId, session.projectPath);
+            const turns = buildSessionTurnList(messages);
+            if (turnNum < 1 || turnNum > turns.length) {
+                return `❌ 轮次超出范围，当前共 ${turns.length} 轮`;
+            }
+            // /rewind N = 撤销第N轮（及之后），保留 1..N-1
+            const rewindTarget = turns[turnNum - 1]; // 被撤销的轮次（用于文件回退）
+            const keepTarget = turnNum >= 2 ? turns[turnNum - 2] : null; // 保留到的轮次（用于对话回退）
+            const results = [];
+            // 文件回退（立即执行）
+            if (mode === 'file' || mode === 'all') {
+                if (!agent.rewindFiles) {
+                    return '❌ 当前 Agent 不支持文件回退';
+                }
+                const fileResult = await agent.rewindFiles(session.agentSessionId, session.projectPath, rewindTarget.userUuid);
+                if (!fileResult.canRewind) {
+                    if (mode === 'file') {
+                        return `❌ 当前会话无文件快照，无法回退文件${fileResult.error ? `\n原因: ${fileResult.error}` : ''}`;
+                    }
+                    results.push(`⚠️ 文件回退失败${fileResult.error ? `: ${fileResult.error}` : '（无文件快照）'}`);
+                }
+                else {
+                    const detail = fileResult.filesChanged
+                        ? `（恢复了 ${fileResult.filesChanged.length} 个文件）`
+                        : '';
+                    if (agent.capabilities?.fileRewind === 'git-head') {
+                        results.push(`✅ 已按 Git HEAD 恢复文件${detail}（Codex 当前不提供逐轮文件快照）`);
+                    }
+                    else {
+                        results.push(`✅ 已恢复文件到第 ${turnNum} 轮之前的状态${detail}`);
+                    }
+                }
+            }
+            // 对话回退：Codex app-server 可直接 rollback；Claude 走 resumeAt 延迟到下次消息生效。
+            if (mode === 'chat' || mode === 'all') {
+                const discarded = turns.length - turnNum + 1;
+                if (agent.rollbackSessionTurns) {
+                    const ok = await agent.rollbackSessionTurns(session.agentSessionId, session.projectPath, discarded);
+                    if (!ok)
+                        return '❌ 对话回退失败';
+                    const meta = { ...(session.metadata || {}) };
+                    delete meta.resumeAt;
+                    await this.sessionManager.updateSession(session.id, { metadata: meta });
+                }
+                else if (keepTarget) {
+                    const meta = { ...(session.metadata || {}), resumeAt: keepTarget.assistantUuid };
+                    await this.sessionManager.updateSession(session.id, { metadata: meta });
+                }
+                else {
+                    // N=1：撤销全部对话，清空 session 从头开始
+                    const meta = { ...(session.metadata || {}) };
+                    delete meta.resumeAt;
+                    await this.sessionManager.updateSession(session.id, {
+                        metadata: meta,
+                        agentSessionId: null,
+                    });
+                }
+                results.push(`✅ 已撤销第 ${turnNum} 轮${discarded > 1 ? `及后续共 ${discarded} 轮` : ''}`, keepTarget ? `下次发言将从第 ${turnNum - 1} 轮继续` : '下次发言将开始全新对话');
+            }
+            this.eventBus.publish({
+                type: 'session:rewind',
+                sessionId: session.id,
+                turnNum,
+                mode,
+            });
+            return results.join('\n');
+        }
+        catch (error) {
+            logger.error('[CommandHandler] Rewind failed:', error);
+            return `❌ 回退失败: ${error instanceof Error ? error.message : '未知错误'}`;
+        }
+    }
+    // ── Agent Ctl ──
+    static CTL_COMMANDS = [
+        '/status', '/pwd', '/file', '/send', '/rename', '/name', '/queue', '/restart', '/model', '/effort',
+    ];
+    /**
+     * 从 session 恢复 ReplyContext，用于 ctl send 主动发送文本时的路由
+     * - 群聊话题：metadata.replyContext.{threadId,peerId}
+     * - 私聊：metadata.peerId
+     * - taskId/chatmode：从 processing_state 和 effective chatmode 注入
+     */
+    buildCtlReplyContext(session) {
+        const ctx = {};
+        const meta = session.metadata;
+        if (meta?.replyContext?.threadId)
+            ctx.threadId = meta.replyContext.threadId;
+        if (meta?.replyContext?.peerId)
+            ctx.peerId = meta.replyContext.peerId;
+        if (!ctx.peerId && meta?.peerId)
+            ctx.peerId = meta.peerId;
+        // 话题（Feishu thread）路由：透传 replyToMessageId + replyInThread，
+        // 否则 ctl send/file 会丢失话题归属、落到主会话气泡。
+        if (meta?.replyContext?.replyToMessageId)
+            ctx.replyToMessageId = meta.replyContext.replyToMessageId;
+        if (meta?.replyContext?.replyInThread)
+            ctx.replyInThread = meta.replyContext.replyInThread;
+        const taskId = this.sessionManager.getActiveTaskId(session.id);
+        const chatmode = this.resolveEffectiveChatmodeForSession(session);
+        const encrypted = this.sessionManager.getSessionEncrypt(session.id);
+        // 诊断日志：记录 task_id 解析结果
+        logger.info(`[CommandHandler] buildCtlReplyContext: sessionId=${session.id} taskId=${taskId ?? 'none'} chatmode=${chatmode} threadId=${ctx.threadId ?? 'none'} replyTo=${ctx.replyToMessageId ?? 'none'} inThread=${ctx.replyInThread ?? false}`);
+        if (taskId || chatmode !== 'interactive' || encrypted != null) {
+            ctx.metadata = {};
+            if (taskId)
+                ctx.metadata.taskId = taskId;
+            if (chatmode !== 'interactive')
+                ctx.metadata.chatmode = chatmode;
+            if (encrypted != null)
+                ctx.metadata.encrypted = encrypted;
+        }
+        return Object.keys(ctx).length > 0 ? ctx : undefined;
+    }
+    resolveEffectiveChatmodeForSession(session) {
+        const peerType = session.metadata?.peerType;
+        try {
+            const self = session.selfAID || this.getOwningAgent(session.channel)?.aid;
+            const channelType = session.channelType || this.resolveChannelType(session.channel);
+            const peerKeyId = session.chatType === 'group'
+                ? (session.metadata?.groupId || session.channelId)
+                : (session.metadata?.peerId || session.channelId);
+            const peerKey = channelType && peerKeyId ? formatPeerKey(channelType, peerKeyId) : undefined;
+            return resolveChatMode({
+                self: self || undefined,
+                peerKey,
+                role: session.identity?.role,
+                chatType: session.chatType,
+                peerType,
+            });
+        }
+        catch {
+            return 'interactive';
+        }
+    }
+    /**
+     * Agent managed CLI config entrypoint. Identity and relation are resolved
+     * from the daemon-owned session rather than caller-provided flags.
+     */
+    async handleConfigOperation(argv, sessionId, delegationToken) {
+        if (!this.agentDelegationRegistry) {
+            return { ok: false, code: 'DELEGATION_REQUIRED', error: 'Task delegation is not configured' };
+        }
+        const delegation = this.agentDelegationRegistry.validate(delegationToken, sessionId);
+        if (!delegation.ok)
+            return { ok: false, code: delegation.code, error: delegation.reason };
+        const session = await this.sessionManager.getSessionById(sessionId);
+        if (!session)
+            return { ok: false, code: 'INVALID_SESSION', error: 'Invalid session' };
+        const grant = delegation.grant;
+        let conversationId;
+        try {
+            conversationId = parsePeerKey(grant.peerKey).channelId;
+        }
+        catch {
+            return { ok: false, code: 'INVALID_DELEGATION', error: 'Delegation contains an invalid relation key' };
+        }
+        const subject = buildAuthSubject({
+            selfAid: grant.selfAid,
+            actorId: grant.actorId,
+            channel: grant.channel,
+            channelType: grant.channelType,
+            channelId: conversationId,
+            chatType: grant.chatType,
+            conversationId,
+            processOwners: loadDaemonConfig().owners ?? [],
+        });
+        const resolved = resolveConfigCommand(argv, {
+            defaultRelation: { self: grant.selfAid, peerKey: grant.peerKey },
+        });
+        if (!resolved.ok)
+            return { ok: false, code: resolved.code, error: resolved.reason };
+        const decision = authorizeOperation({
+            source: 'agent-tool',
+            subject,
+            intent: {
+                operation: resolved.command.operationId,
+                scope: resolved.command.commandScope,
+                source: 'agent-tool',
+                args: {
+                    ...(resolved.command.self ? { self: resolved.command.self } : {}),
+                    ...(resolved.command.peerKey ? { peer: resolved.command.peerKey, peerKey: resolved.command.peerKey } : {}),
+                    ...('field' in resolved.command && resolved.command.field ? { field: resolved.command.field } : {}),
+                },
+                dangerous: resolved.command.dangerous,
+            },
+            resolvedConfigCommand: resolved.command,
+            auditMetadata: {
+                argvHash: hashArgv(resolved.command.canonicalArgv),
+                taskId: grant.taskId,
+                messageId: grant.messageId,
+            },
+        });
+        if (!decision.allow)
+            return { ok: false, code: decision.code, error: decision.reason };
+        const result = executeResolvedConfigCommand(resolved.command, { role: subject.role });
+        return result.ok
+            ? { ok: true, result }
+            : { ok: false, code: result.code, error: result.error, ...(result.data !== undefined ? { data: result.data } : {}) };
+    }
+    /** Agent-managed contact CLI entrypoint. The daemon owns actor resolution and authorization. */
+    async handleContactOperation(argv, sessionId, delegationToken) {
+        if (!this.agentDelegationRegistry) {
+            return { ok: false, code: 'DELEGATION_REQUIRED', error: 'Task delegation is not configured' };
+        }
+        const delegation = this.agentDelegationRegistry.validate(delegationToken, sessionId);
+        if (!delegation.ok)
+            return { ok: false, code: delegation.code, error: delegation.reason };
+        const session = await this.sessionManager.getSessionById(sessionId);
+        if (!session)
+            return { ok: false, code: 'INVALID_SESSION', error: 'Invalid session' };
+        const grant = delegation.grant;
+        let conversationId;
+        try {
+            conversationId = parsePeerKey(grant.peerKey).channelId;
+        }
+        catch {
+            return { ok: false, code: 'INVALID_DELEGATION', error: 'Delegation contains an invalid relation key' };
+        }
+        const resolved = resolveContactCommand(argv);
+        if (!resolved.ok)
+            return { ok: false, code: resolved.code, error: resolved.reason };
+        if (resolved.command.selfAid !== grant.selfAid) {
+            return { ok: false, code: 'SCOPE_MISMATCH', error: 'Only the current Agent contact book can be targeted' };
+        }
+        const subject = buildAuthSubject({
+            selfAid: grant.selfAid,
+            actorId: grant.actorId,
+            channel: grant.channel,
+            channelType: grant.channelType,
+            channelId: conversationId,
+            chatType: grant.chatType,
+            conversationId,
+            processOwners: loadDaemonConfig().owners ?? [],
+        });
+        const decision = authorizeOperation({
+            source: 'agent-tool',
+            subject,
+            intent: {
+                operation: resolved.command.operationId,
+                scope: 'agent',
+                source: 'agent-tool',
+                args: {
+                    self: resolved.command.selfAid,
+                    ...('primaryId' in resolved.command ? { primaryId: resolved.command.primaryId } : {}),
+                },
+            },
+            auditMetadata: {
+                argvHash: hashArgv(resolved.command.canonicalArgv),
+                taskId: grant.taskId,
+                messageId: grant.messageId,
+            },
+        });
+        if (!decision.allow)
+            return { ok: false, code: decision.code, error: decision.reason };
+        const result = await executeResolvedContactCommand(resolved.command, grant.actorId);
+        return result.ok
+            ? { ok: true, result }
+            : { ok: false, code: result.code, error: result.error, ...(result.data ? { data: result.data } : {}) };
+    }
+    setAgentDelegationRegistry(registry) {
+        this.agentDelegationRegistry = registry;
+    }
+    /**
+     * Agent ctl 入口：通过 IPC 接收 Agent 自主管理指令
+     * 复用现有 slash cmd 逻辑，权限继承 session 用户角色
+     */
+    async handleCtl(cmd, sessionId) {
+        logger.info(`[ctl] cmd="${cmd}" sessionId=${sessionId}`);
+        // 1. 白名单检查
+        const inputCmd = cmd.split(' ')[0];
+        if (!CommandHandler.CTL_COMMANDS.includes(inputCmd)) {
+            return { ok: false, error: `不允许的指令: ${inputCmd}` };
+        }
+        // 2. 通过 sessionId 查 session
+        const session = await this.sessionManager.getSessionById(sessionId);
+        if (!session) {
+            return { ok: false, error: '无效的 session' };
+        }
+        // 3. 从 session.metadata.peerId 获取 userId（用于权限判断）
+        const userId = session.metadata?.peerId;
+        const ctlIdentity = this.resolveCtlIdentity(session, userId);
+        // 4. /send 文本消息：直接通过 adapter 主动发送，不走 handle()
+        if (cmd.startsWith('/send ') || cmd === '/send') {
+            // 解析 --encrypt 标志和消息文本
+            const raw = cmd.startsWith('/send ') ? cmd.slice(6).trim() : '';
+            const forceEncrypt = raw.startsWith('--encrypt ');
+            const text = forceEncrypt ? raw.slice(10).trim() : raw;
+            if (!text)
+                return { ok: false, error: '消息内容不能为空' };
+            const adapter = this.adapters.get(session.channel);
+            if (!adapter)
+                return { ok: false, error: `adapter 未找到: ${session.channel}` };
+            try {
+                const replyContext = this.buildCtlReplyContext(session);
+                const taskId = replyContext?.metadata?.taskId;
+                const chatmode = replyContext?.metadata?.chatmode ?? 'interactive';
+                // --encrypt 覆盖 session 加密状态
+                // 添加 source: 'ctl' 标记（用于区分 ec ctl send）
+                const enrichedReplyContext = forceEncrypt
+                    ? { ...(replyContext ?? {}), metadata: { ...(replyContext?.metadata ?? {}), encrypted: true, source: 'ctl' } }
+                    : { ...(replyContext ?? {}), metadata: { ...(replyContext?.metadata ?? {}), source: 'ctl' } };
+                await adapter.send(buildEnvelope({ taskId, channel: adapter.channelName, channelId: session.channelId, chatmode, replyContext: enrichedReplyContext }), { kind: 'result.text', text, isFinal: true });
+                // 出方向 jsonl 写入已下沉到 aun.ts:deliverTextEntry，message.send 成功后统一写入。
+                return { ok: true, result: 'ok' };
+            }
+            catch (err) {
+                return { ok: false, error: err.message || String(err) };
+            }
+        }
+        // 5. file 路径限制：只允许 projectPath 下的文件
+        if (cmd.startsWith('/file')) {
+            const sendArgs = cmd.slice(5).trim();
+            const parts = sendArgs.split(/\s+/);
+            const filePath = parts[parts.length - 1];
+            if (filePath) {
+                const resolved = path.resolve(session.projectPath, filePath).replace(/\\/g, '/');
+                const projectPath = session.projectPath.replace(/\\/g, '/');
+                if (!resolved.startsWith(projectPath)) {
+                    return { ok: false, error: '路径越界：只能发送项目目录下的文件' };
+                }
+            }
+        }
+        // 5.1 /queue: 消息队列查询与操作（直接操作 MessageQueue，不走 handle()）
+        if (cmd === '/queue' || cmd.startsWith('/queue ')) {
+            const args = cmd.slice('/queue'.length).trim();
+            return await this.handleQueueCommand(sessionId, args);
+        }
+        // 6. 调用现有 handle()，不传 sendMessage 回调（结果直接返回）
+        try {
+            const result = await this._handleInternal(cmd, session.channel, session.channelId, undefined, // 不发送消息
+            userId, session.threadId || undefined, session.chatType, undefined, undefined, session.selfAID, ctlIdentity);
+            const text = typeof result === 'string' ? result : (result && 'text' in result ? result.text : '(无输出)');
+            if (result && typeof result === 'object' && 'kind' in result && result.kind === 'command.error') {
+                return { ok: false, error: text || '执行失败' };
+            }
+            return { ok: true, result: text || '(无输出)', ...(result && typeof result === 'object' && 'structured' in result ? { data: result.structured } : {}) };
+        }
+        catch (err) {
+            return { ok: false, error: err.message };
+        }
+    }
+    // ── Queue command ──
+    /** 提取命名参数值（如 --cancel msg123 → "msg123"） */
+    extractArg(args, flag) {
+        const idx = args.indexOf(flag);
+        if (idx === -1)
+            return '';
+        const rest = args.slice(idx + flag.length).trim();
+        const spaceIdx = rest.indexOf(' ');
+        return spaceIdx >= 0 ? rest.slice(0, spaceIdx) : rest;
+    }
+    async handleQueueCommand(sessionId, args) {
+        const showId = args.includes('--showid');
+        const formatJson = args.includes('--format json');
+        const full = args.includes('--full');
+        // 操作分支
+        if (args.includes('--clear')) {
+            const count = this.messageQueue.clearBySession(sessionId);
+            return { ok: true, result: `✅ 已清空 ${count} 条待处理消息` };
+        }
+        if (args.includes('--cancel')) {
+            const msgId = this.extractArg(args, '--cancel');
+            if (!msgId)
+                return { ok: false, error: '❌ --cancel 需要指定 messageId' };
+            const success = this.messageQueue.cancelMessageByIdInSession(sessionId, msgId);
+            return success
+                ? { ok: true, result: `✅ 已取消消息 ${msgId}` }
+                : { ok: false, error: `❌ 未找到消息 ${msgId}` };
+        }
+        if (args.includes('--interrupt')) {
+            const interrupted = await this.messageQueue.interruptBySession(sessionId);
+            return interrupted
+                ? { ok: true, result: `✅ 已打断处理中任务` }
+                : { ok: false, error: `❌ 当前无处理中任务` };
+        }
+        // 查询
+        const items = this.messageQueue.getQueueItemsBySession(sessionId);
+        if (formatJson) {
+            return { ok: true, result: JSON.stringify({ items }, null, 2) };
+        }
+        return { ok: true, result: renderQueueItemsCtl(items, showId, full) };
+    }
+}
+/**
+ * ctl 专用渲染：不显示 session 标识列（因为只有一个 session）
+ */
+function renderQueueItemsCtl(items, showId, full) {
+    if (items.length === 0) {
+        return `当前会话队列 (0 条待处理)\n\n(无待处理消息)`;
+    }
+    const lines = [`当前会话队列 (${items.length} 条待处理)`, ''];
+    // 计算列宽
+    const maxIdLen = showId ? Math.max(...items.map(i => i.messageId?.length ?? 0)) : 0;
+    const maxNameLen = Math.max(...items.map(i => (i.peerName ? `[${i.peerName}]`.length : 0)));
+    for (const item of items) {
+        const parts = [' '];
+        if (showId) {
+            const id = (item.messageId || '').padEnd(maxIdLen);
+            parts.push(` ${id}  `);
+        }
+        if (item.peerName) {
+            const name = `[${item.peerName}]`.padEnd(maxNameLen);
+            parts.push(` ${name}  `);
+        }
+        const content = full ? item.preview.replace('...', '') : item.preview;
+        parts.push(`"${content}"`);
+        lines.push(parts.join(''));
+    }
+    return lines.join('\n');
+}
+function sameFeedbackTarget(target, origin) {
+    if (!origin)
+        return false;
+    return target.channelKey === origin.channelKey
+        && target.channelId === origin.channelId
+        && target.session === origin.session
+        && (target.threadId ?? '') === (origin.threadId ?? '');
+}