evolcore 0.0.20 → 0.0.21

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

@@ -1,5 +1,6 @@
 import { hasModelSwitcher, hasPermissionController } from '../../agents/runner-types.js';
 import { getCodexEfforts } from '../../agents/codex-runner.js';
+import { normalizeBaseagent } from '../../agents/baseagent.js';
 import { buildEnvelope, isDeliveryTargetForChannel } from '../message/message-utils.js';
 import { resolvePaths, getPackageRoot, daemonControlDir } from '../../paths.js';
 import { logger } from '../../utils/logger.js';
@@ -17,14 +18,15 @@ 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 { constrainResolvedModelForRole, filterModelsForRole, validateModelSelectionForRole } from '../model/model-permission.js';
+import { resolveRuntimeStringField } from '../role/runtime-policy.js';
 import { displaySessionTitle } 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 { isManagementRole } from '../../config/builtin-roles.js';
 import { isSystemControlChannel } from '../system-channels.js';
 import { spawnDetachedNode } from '../../utils/cross-platform.js';
-import { guardIdleCommand, guardKnownCommand, guardRoleCommand, guardThreadCommand, isRecognizedSlashCommand, normalizeSlashContent, } from './slash-gate.js';
+import { guardIdleCommand, guardKnownCommand, guardRoleCommand, guardThreadCommand, isRecognizedSlashCommand, normalizeSlashContent, probeSessionActivity, } from './slash-gate.js';
 const allEfforts = ['low', 'medium', 'high', 'xhigh', 'max'];
 const PERMISSION_MODE_KEYS = PUBLIC_PERMISSION_MODES;
 function defaultSlashChatmode(field) {
@@ -114,7 +116,7 @@ function resolveSlashRelationTarget(params) {
     const actualChatType = params.session?.chatType || params.chatType;
     const peerId = actualChatType === 'group'
         ? (params.session?.metadata?.groupId || params.channelId)
-        : (params.userId || params.session?.metadata?.peerId);
+        : (params.userId || params.session?.metadata?.peerId || params.session?.channelId || params.channelId);
     if (!peerId)
         return { error: 'missing current peer id', code: 'MISSING_PEER' };
     const channelType = params.session?.channelType || this.resolveChannelType?.(params.channel) || params.channel.split('#')[0];
@@ -419,10 +421,30 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
     // 权限检查：区分用户级命令和管理级命令
     const isOwner = identity.role === 'owner';
     const isAdmin = isManagementRole(identity.role);
-    const activeChatType = activeSession?.chatType || (chatType === 'group' ? 'group' : 'private');
+    // A topic's latest snapshot is authoritative and intentionally strict. Do
+    // not let a corrupt committed record turn a backend-management command into
+    // an unhandled quick-command failure; /renew will report it as UNKNOWN and
+    // leave the binding untouched.
+    let topicAuthSession;
+    let topicAuthSessionLookupFailed = false;
+    if (threadId) {
+        try {
+            topicAuthSession = await this.sessionManager.getThreadSession(channel, channelId, threadId);
+        }
+        catch (error) {
+            topicAuthSessionLookupFailed = true;
+            logger.warn(`[CommandHandler] topic session lookup failed: thread=${threadId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    const activeChatType = topicAuthSession?.chatType
+        || activeSession?.chatType
+        || (chatType === 'group' ? 'group' : 'private');
     const getExistingSessionForCommand = async () => {
-        if (threadId)
-            return await this.sessionManager.getThreadSession(channel, channelId, threadId);
+        if (threadId) {
+            if (topicAuthSessionLookupFailed)
+                return undefined;
+            return topicAuthSession ?? await this.sessionManager.getThreadSession(channel, channelId, threadId);
+        }
         return activeSession;
     };
     const getEffectiveChatmode = (session, fallbackChatType = activeChatType) => {
@@ -497,8 +519,103 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
                 agentName: this.agentRegistry?.resolveByChannel(channel)?.name ?? '<unknown>',
             });
             await this.processor.interruptSession(commandSession.id, 'stop');
+            this.processor?.clearPauseSession?.(commandSession.id);
         }
     };
+    /**
+     * Boundary-scoped activity probe shared by /renew and /compact.  The queue
+     * snapshot is taken at gate installation; later arrivals are deliberately
+     * excluded because they are cutoff-after work and remain durably queued.
+     */
+    const probeBackendActivity = (current, gateSnapshot) => {
+        const probes = {
+            paused: () => this.processor?.isPauseRequested?.(current.id) ?? false,
+            activeStream: () => this.getAgent(channel, current.baseagent).hasActiveStream(current.id),
+        };
+        if (this.permissionGateway) {
+            probes.pendingPermission = () => this.permissionGateway.getPendingRequests(current.id).length > 0;
+        }
+        if (this.interactionRouter) {
+            probes.pendingInteraction = () => this.interactionRouter.getPending(current.id).length > 0;
+        }
+        const selfAid = current.selfAID || selfAID || this.getOwningAgent(channel)?.aid;
+        if (this.handoffRuntime) {
+            probes.activeHandoff = () => {
+                if (!selfAid)
+                    throw new Error('handoff activity owner unavailable');
+                return this.handoffRuntime.hasActiveSessionWork(selfAid, current.id);
+            };
+            probes.openHandoffTarget = () => {
+                if (!selfAid)
+                    throw new Error('handoff activity owner unavailable');
+                return this.handoffRuntime.hasOpenTarget(selfAid, current.id);
+            };
+        }
+        return probeSessionActivity({
+            prequeue: gateSnapshot.prequeue,
+            active: gateSnapshot.active,
+            queued: gateSnapshot.queued,
+            dispatching: gateSnapshot.dispatching,
+            processing: !!current.processingState,
+            activeTurn: !!current.metadata?.turnState?.active,
+        }, probes);
+    };
+    const withIdleTopicBackend = async (sessionId, expectedThreadId, action, fallbackSession) => {
+        // Main-session /compact keeps its existing idle guard and provider path.
+        // Only topic backend operations require the stronger dequeue barrier.
+        if (!expectedThreadId) {
+            let current = fallbackSession;
+            if (!current) {
+                try {
+                    current = typeof this.sessionManager.getSessionById === 'function'
+                        ? await this.sessionManager.getSessionById(sessionId)
+                        : undefined;
+                }
+                catch (error) {
+                    logger.warn(`[CommandHandler] main session snapshot read failed: ${error instanceof Error ? error.message : String(error)}`);
+                    return { ok: false, reason: 'unknown' };
+                }
+            }
+            if (!current || current.threadId)
+                return { ok: false, reason: 'missing' };
+            // Preserve the legacy main-session /compact exclusion. Topic commands
+            // use the stronger barrier below; main sessions retain the historical
+            // keyed dequeue lock and provider behavior.
+            const releaseLock = typeof this.messageQueue.acquireLock === 'function'
+                ? this.messageQueue.acquireLock(sessionId)
+                : undefined;
+            try {
+                return { ok: true, value: await action(current) };
+            }
+            finally {
+                releaseLock?.();
+            }
+        }
+        if (typeof this.messageQueue.withSessionBarrier !== 'function') {
+            return { ok: false, reason: 'unknown' };
+        }
+        return this.messageQueue.withSessionBarrier(sessionId, async (snapshot) => {
+            let current;
+            try {
+                current = typeof this.sessionManager.getSessionById === 'function'
+                    ? await this.sessionManager.getSessionById(sessionId)
+                    : expectedThreadId
+                        ? await this.sessionManager.getThreadSession(channel, channelId, expectedThreadId)
+                        : fallbackSession;
+            }
+            catch (error) {
+                logger.warn(`[CommandHandler] session snapshot read failed: ${error instanceof Error ? error.message : String(error)}`);
+                return { ok: false, reason: 'unknown' };
+            }
+            if (!current || (current.threadId || undefined) !== expectedThreadId) {
+                return { ok: false, reason: 'missing' };
+            }
+            const activity = probeBackendActivity(current, snapshot);
+            if (activity !== 'idle')
+                return { ok: false, reason: activity };
+            return { ok: true, value: await action(current, snapshot) };
+        });
+    };
     // /help 命令不需要会话
     if (normalizedContent === '/help') {
         const canReadModel = canAccessSlashOperation('model.current', 'relation')
@@ -517,7 +634,7 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
         const appendProcessCommands = (lines) => {
             if (!isDaemonOwner)
                 return;
-            lines.push('', '🛠️ 进程级运维：', '  /restart - 重启服务', '  /upgrade - 检查版本更新', '  /reload [aid] - 热重载 Agent 配置');
+            lines.push('', '🛠️ 进程级运维：', '  /restart - 重启服务', '  /upgrade - 检查版本更新', '  /reload [aid] - 热重载 Agent 配置', '  /fa <提示词> - 单次使用宿主级 fullaccess 执行（别名: /fullaccess）');
         };
         if (!isAdmin && activeChatType === 'group') {
             const lines = [
@@ -559,6 +676,7 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
                 '  /s [cli|名称|序号|uuid] - 列出或切换会话（cli 查看未导入的 CLI 会话）',
                 '  /name <新名称> - 重命名当前会话',
                 '  /del <名称> - 删除指定会话（仅解绑，不删除文件）',
+                ...(threadId ? ['  /renew - 在当前话题中轮换 backend'] : []),
                 '  /pause - 在下一次工具调用前暂停当前任务',
                 '  /resume - 继续已暂停的当前任务',
                 '  /stop - 中断当前任务',
@@ -608,6 +726,7 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
             '  /fork [名称] - 分支当前会话（从当前对话点创建分支）',
             '  /rewind [N] [chat|file|all] - 查看历史/撤销指定轮次（别名: /rw）',
             '  /compact - 压缩会话上下文（减少 token 用量）',
+            '  /renew - 在话题中轮换 backend（下一条消息懒初始化）',
             '  /pause - 在下一次工具调用前暂停当前任务',
             '  /resume - 继续已暂停的当前任务',
             '  /stop - 中断当前任务',
@@ -639,6 +758,7 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
             ...(isDaemonOwner ? [
                 '  /restart - 重启服务',
                 '  /reload [aid] - 热重载 Agent 配置',
+                '  /fa <提示词> - 单次使用宿主级 fullaccess 执行（别名: /fullaccess）',
             ] : []),
             ...(!isDaemonOwner && isAdmin ? [
                 '  /reload - 热重载当前 Agent 配置',
@@ -682,6 +802,9 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
             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'] });
         }
+        if (threadId && (activeChatType !== 'group' || isAdmin)) {
+            cmds.push({ command: '/renew', description: '轮换当前话题 backend', category: '会话管理', roles: activeChatType === 'group' ? ['admin', 'owner'] : ['visitor', 'member', 'admin', 'owner'] });
+        }
         // Agent 与模型
         if (isAdmin)
             cmds.push({ command: '/baseagent', aliases: ['/base'], args: '[name]', description: '查看或切换 Agent 后端', category: 'Agent 与模型', roles: ['admin', 'owner'] });
@@ -707,6 +830,7 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
             cmds.push({ command: '/observable', args: '[true|false]', description: '查看或切换观察者模式', category: '运维', roles: ['owner'] });
         }
         if (isDaemonOwner) {
+            cmds.push({ command: '/fa', aliases: ['/fullaccess'], args: '<提示词>', description: '仅让当前提示词对应的 run 使用宿主级 fullaccess', category: '权限管理', roles: ['daemon-owner'] });
             cmds.push({ command: '/restart', description: '重启服务', category: '运维', roles: ['daemon-owner'] });
             cmds.push({ command: '/upgrade', description: '检查版本更新', category: '运维', roles: ['daemon-owner'] });
             cmds.push({ command: '/reload', args: '[aid]', description: '热重载 Agent 配置', category: '运维', roles: ['daemon-owner'] });
@@ -962,7 +1086,12 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
         }
         await interruptPausedSessionBeforeReplacement(await getExistingSessionForCommand());
         const previousDefaultBaseagent = owningAgent.baseagent || this.parseDefaultBaseagent();
-        owningAgent.setActiveBaseagent(args);
+        try {
+            owningAgent.setActiveBaseagent(args);
+        }
+        catch (error) {
+            return { kind: 'command.error', text: `❌ ${error instanceof Error ? error.message : String(error)}` };
+        }
         this.eventBus.publish({
             type: 'agent:baseagent-changed',
             aid: owningAgent.aid,
@@ -1655,7 +1784,7 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
             }).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);
+        const res = await execAgentAction('reload', { aid: targetAid }, userId ?? '', this.eventBus, this.agentApplicationService);
         if ('error' in res)
             return { kind: 'command.error', text: `❌ reload 失败：${res.error}` };
         return { kind: 'command.result', text: `✅ Agent ${targetAid} 配置已重载` };
@@ -2009,41 +2138,225 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
     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` };
+    // /renew：只支持话题会话。它废止当前 backend 绑定；下一条普通消息
+    // 才会在新的 TurnLease 中懒创建并绑定新 backend。
+    if (normalizedContent === '/renew' || /^\/renew\s/.test(normalizedContent)) {
+        if (normalizedContent !== '/renew') {
+            return { kind: 'command.error', text: '❌ /renew 不接受参数，请直接使用 /renew' };
         }
-        if (!session.agentSessionId) {
-            return { kind: 'command.error', text: '❌ 当前会话没有历史记录，无需压缩' };
+        if (!threadId) {
+            return { kind: 'command.error', text: '⚠️ /renew 仅支持话题会话' };
+        }
+        // Card callbacks use synthetic message IDs on several adapters. They are
+        // suitable for UI correlation, but not for the durable inbound claim.
+        if (source === 'card-trigger') {
+            return { kind: 'command.error', text: '⚠️ /renew 仅支持携带原生消息 ID 的普通消息' };
+        }
+        let renewSession;
+        try {
+            // Re-read rather than trusting the authorization lookup above: only a
+            // fresh strict snapshot may be used to choose the barrier key.
+            renewSession = await this.sessionManager.getThreadSession(channel, channelId, threadId);
+        }
+        catch (error) {
+            logger.warn(`[CommandHandler] /renew topic lookup failed: thread=${threadId}: ${error instanceof Error ? error.message : String(error)}`);
+            return { kind: 'command.error', text: '⚠️ 当前会话状态未知，无法安全轮换，请稍后再试' };
+        }
+        if (!renewSession) {
+            return { kind: 'command.error', text: '❌ 找不到当前话题会话' };
+        }
+        const inboundMessageId = messageId?.trim();
+        if (!inboundMessageId) {
+            return { kind: 'command.error', text: '❌ /renew 缺少稳定的消息 ID，当前渠道不支持安全重试' };
+        }
+        if (typeof this.sessionManager.rotateTopicBackend !== 'function'
+            || typeof this.messageQueue.withSessionBarrier !== 'function'
+            || typeof this.messageQueue.claimInbound !== 'function') {
+            return { kind: 'command.error', text: '❌ 当前运行环境不支持安全 backend 轮换' };
         }
-        await interruptPausedSessionBeforeReplacement(session);
-        const projectPath = path.isAbsolute(session.projectPath)
-            ? session.projectPath
-            : path.resolve(process.cwd(), session.projectPath);
-        const releaseLock = this.messageQueue.acquireLock(session.id);
         try {
+            const outcome = await this.messageQueue.withSessionBarrier(renewSession.id, async (snapshot) => {
+                let current;
+                try {
+                    current = typeof this.sessionManager.getSessionById === 'function'
+                        ? await this.sessionManager.getSessionById(renewSession.id)
+                        : undefined;
+                }
+                catch (error) {
+                    logger.warn(`[CommandHandler] /renew strict session read failed: session=${renewSession.id}: ${error instanceof Error ? error.message : String(error)}`);
+                    return { kind: 'unknown' };
+                }
+                if (!current || current.threadId !== threadId)
+                    return { kind: 'missing' };
+                let claim;
+                try {
+                    claim = this.messageQueue.claimInbound(current.id, inboundMessageId, selfAID ?? current.selfAID);
+                }
+                catch (error) {
+                    logger.error(`[CommandHandler] /renew inbound claim failed: session=${current.id}: ${error instanceof Error ? error.message : String(error)}`);
+                    return { kind: 'claim_failed' };
+                }
+                if (claim === 'duplicate')
+                    return { kind: 'duplicate' };
+                const activity = probeBackendActivity(current, snapshot);
+                if (activity !== 'idle')
+                    return { kind: activity };
+                const result = await this.sessionManager.rotateTopicBackend({
+                    sessionId: current.id,
+                    expectedThreadId: threadId,
+                });
+                return {
+                    kind: 'rotated',
+                    wasBound: result.wasBound,
+                };
+            });
+            if (outcome.kind === 'missing') {
+                return { kind: 'command.error', text: '❌ 当前话题会话已不存在或归属已变化' };
+            }
+            if (outcome.kind === 'claim_failed') {
+                return { kind: 'command.error', text: '❌ 当前渠道无法安全记录该请求，未执行 backend 轮换' };
+            }
+            if (outcome.kind === 'duplicate') {
+                return { kind: 'command.result', text: 'ℹ️ 该请求已接收过，不再重复执行' };
+            }
+            if (outcome.kind === 'busy' || outcome.kind === 'unknown') {
+                return {
+                    kind: 'command.error',
+                    text: outcome.kind === 'busy'
+                        ? '⚠️ 当前会话忙碌，无法安全轮换，请稍后再试'
+                        : '⚠️ 当前会话状态未知，无法安全轮换，请稍后再试',
+                };
+            }
+            if (outcome.kind !== 'rotated') {
+                return { kind: 'command.error', text: '⚠️ 当前会话状态未知，无法安全轮换，请稍后再试' };
+            }
+            return {
+                kind: 'command.result',
+                text: `✅ backend 已切换${outcome.wasBound ? '' : '（当前未绑定 backend）'}；下一条消息将初始化新 backend（阶段一不携带历史摘要）`,
+            };
+        }
+        catch (error) {
+            logger.error(`[CommandHandler] /renew failed: session=${renewSession.id}: ${error instanceof Error ? error.message : String(error)}`);
+            return { kind: 'command.error', text: `❌ backend 轮换失败：${error instanceof Error ? error.message : String(error)}` };
+        }
+    }
+    // /compact 命令：手动压缩会话上下文
+    if (normalizedContent === '/compact') {
+        const session = await getExistingSessionForCommand();
+        if (!session) {
+            return topicAuthSessionLookupFailed
+                ? { kind: 'command.error', text: '⚠️ 当前会话状态未知，无法安全压缩，请稍后再试' }
+                : { kind: 'command.error', text: '❌ 当前没有活跃会话，无需压缩' };
+        }
+        if (!session.threadId)
+            await interruptPausedSessionBeforeReplacement(session);
+        const outcome = await withIdleTopicBackend(session.id, session.threadId || undefined, async (session) => {
+            if (!session.agentSessionId) {
+                return { kind: 'command.error', text: '❌ 当前会话没有历史记录，无需压缩' };
+            }
+            const projectPath = path.isAbsolute(session.projectPath)
+                ? session.projectPath
+                : path.resolve(process.cwd(), session.projectPath);
+            const currentSessionAgent = this.getAgent(channel, session.baseagent);
+            if (!currentSessionAgent.capabilities?.compact) {
+                return { kind: 'command.error', text: `❌ 当前 Agent (${currentSessionAgent.name}) 不支持 /compact` };
+            }
             if (sendMessage) {
                 await sendMessage(channelId, '⏳ 正在压缩会话上下文...', this.getReplyContext(session));
             }
-            const compacted = await sessionAgent.compactSession(session.id, session.agentSessionId, projectPath);
-            if (compacted) {
+            // Resolve the same relation/agent effective model used for normal turns.
+            // The runner instance's model is only the final fallback; without this
+            // override Claude's /compact command could resume with a stale agent
+            // default (for example glm-5.3) while the turn itself used gpt-5.6-sol.
+            const compactBaseagentRaw = session.baseagent || currentSessionAgent.name;
+            const compactBaseagentNormalized = normalizeBaseagent(compactBaseagentRaw);
+            const compactBaseagent = compactBaseagentNormalized.canonical === 'unknown'
+                ? compactBaseagentRaw
+                : compactBaseagentNormalized.canonical;
+            const compactChatType = session.chatType;
+            const compactRelation = resolveSlashRelationTarget.call(this, {
+                session,
+                channel,
+                channelId,
+                userId,
+                selfAID,
+                role: session.identity?.role || identity.role,
+                chatType: compactChatType,
+            });
+            const compactSelector = 'error' in compactRelation
+                ? { self: selfAID ?? session.selfAID ?? this.resolveSelfAID(channel) }
+                : compactRelation;
+            let compactConfig = {};
+            try {
+                compactConfig = (resolveEffective(compactSelector, { cache: true }).baseagents || {})[compactBaseagent] || {};
+            }
+            catch {
+                compactConfig = {};
+            }
+            const compactModelDecision = constrainResolvedModelForRole({
+                role: session.identity?.role || identity.role,
+                baseagent: compactBaseagent,
+                model: typeof compactConfig.model === 'string' ? compactConfig.model : undefined,
+                resolveModelId: typeof currentSessionAgent.resolveModelId === 'function'
+                    ? currentSessionAgent.resolveModelId.bind(currentSessionAgent)
+                    : undefined,
+                selfAid: compactSelector.self,
+            });
+            const compactModel = compactModelDecision.model
+                || (typeof currentSessionAgent.getModel === 'function' ? currentSessionAgent.getModel() : undefined);
+            const compactEffortDecision = resolveRuntimeStringField({
+                selfAid: compactSelector.self,
+                role: session.identity?.role || identity.role,
+                field: `baseagents.${compactBaseagent}.effort`,
+                configuredValue: compactConfig.effort,
+            });
+            const compactConfiguredEffort = compactEffortDecision.effectiveValue;
+            const compactEffort = compactConfiguredEffort && compactConfiguredEffort !== 'auto'
+                ? compactConfiguredEffort
+                : (compactConfiguredEffort === 'auto' ? undefined : currentSessionAgent.getEffort?.());
+            // Only send an explicit override when config/role resolution decided a
+            // value. If neither scope provides one, the runner's own getModel/getEffort
+            // fallback is the same effective value and preserving an omitted fourth
+            // argument keeps older runner adapters source-compatible.
+            const hasExplicitCompactModel = typeof compactConfig.model === 'string' && compactConfig.model.trim().length > 0
+                || compactModelDecision.constrained;
+            const hasExplicitCompactEffort = typeof compactConfig.effort === 'string' && compactConfig.effort.trim().length > 0
+                || compactEffortDecision.decidedBy === 'role';
+            const compactOverride = (hasExplicitCompactModel && compactModel) || (hasExplicitCompactEffort && compactEffort)
+                ? {
+                    ...(hasExplicitCompactModel && compactModel ? { model: compactModel } : {}),
+                    ...(hasExplicitCompactEffort && compactEffort ? { effort: compactEffort } : {}),
+                }
+                : undefined;
+            const compacted = compactOverride
+                ? await currentSessionAgent.compactSession(session.id, session.agentSessionId, projectPath, compactOverride)
+                : await currentSessionAgent.compactSession(session.id, session.agentSessionId, projectPath);
+            const compactResult = compacted;
+            if (compactResult === true || compactResult?.ok === true) {
                 return {
                     kind: 'command.result',
                     text: '✅ 会话压缩完成',
                 };
             }
             else {
-                return { kind: 'command.error', text: '❌ 会话压缩失败，请稍后重试' };
+                return {
+                    kind: 'command.error',
+                    text: `❌ 会话压缩失败（${compactResult?.code ?? 'sdk_error'}）：${compactResult?.message ?? 'compact failed'}`,
+                };
             }
+        }, session);
+        if (!outcome.ok) {
+            if (outcome.reason === 'missing') {
+                return { kind: 'command.error', text: '❌ 当前会话已不存在或归属已变化' };
+            }
+            return {
+                kind: 'command.error',
+                text: outcome.reason === 'busy'
+                    ? '⚠️ 当前会话忙碌，请稍后再试\n使用 /stop 中断当前任务后重试'
+                    : '⚠️ 当前会话状态未知，无法安全压缩，请稍后再试',
+            };
         }
-        finally {
-            releaseLock();
-        }
+        return outcome.value;
     }
     // 后续命令可读取现有会话，但不应在这里隐式创建新会话。
     // 真正需要新会话的命令应显式调用 createNewSession()。
@@ -3203,7 +3516,12 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
                 const backupPath = await backupSessionFile(sessionFile);
                 const fsPromises = await import('fs/promises');
                 await fsPromises.unlink(sessionFile);
-                await this.sessionManager.updateAgentSessionIdBySessionId(repairSession.id, '');
+                // A topic backend binding may only be changed by an explicit boundary
+                // rotation/activation.  Repair clears runner-local state, but must not
+                // turn a legacy empty callback into an authoritative binding mutation.
+                if (!repairSession.threadId) {
+                    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}` };
@@ -3240,7 +3558,7 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
         });
         if (triggerAuthDenied)
             return triggerAuthDenied;
-        const text = await this.handleTrigger(normalizedContent, channel, channelId, userId ?? '', isAdmin, messageId, chatType, threadId);
+        const text = await this.handleTrigger(normalizedContent, channel, channelId, userId ?? '', isAdmin, messageId, chatType, threadId, isDaemonOwner, authSubject.canApprovePersistentFullAccess);
         return { kind: 'command.result', text };
     }
     return null;

package/dist/core/event-catalog.js

@@ -317,6 +317,7 @@ const CATALOG = [
             { path: 'eventPhase', type: 'string' },
             { path: 'callId', type: 'string', optional: true },
             { path: 'correlationId', type: 'string', optional: true },
+            { path: 'agentName', type: 'string', optional: true },
             { path: 'agentAid', type: 'string', optional: true },
             { path: 'permissionMode', type: 'string', optional: true },
             { path: 'decision', type: 'string' },
@@ -373,6 +374,8 @@ const CATALOG = [
             { path: 'approved', type: 'boolean' },
             { path: 'toolName', type: 'string', optional: true },
             { path: 'reason', type: 'string', optional: true },
+            { path: 'decisionSource', type: 'string', optional: true },
+            { path: 'policyCode', type: 'string', optional: true },
         ],
     },
     {
@@ -385,6 +388,8 @@ const CATALOG = [
             { path: 'requestId', type: 'string' },
             { path: 'toolName', type: 'string', optional: true },
             { path: 'reason', type: 'string', optional: true },
+            { path: 'decisionSource', type: 'string', optional: true },
+            { path: 'policyCode', type: 'string', optional: true },
         ],
     },
     {

package/dist/core/evolagent.js

@@ -6,6 +6,7 @@ import { ConfigTarget, read as cfgRead, write as cfgWrite, ensureFile as cfgEnsu
 import { withLifecycleForWrite } from '../config/lifecycle.js';
 import { isStaticAgentAdmin, isStaticAgentOwner } from '../config/peer-role-resolver.js';
 import { resolvePrincipal } from '../config/contact-book.js';
+import { isSupportedBaseagent } from '../agents/baseagent.js';
 /**
  * EvolAgent —— 一个 self-agent 的运行时表示。
  *
@@ -168,6 +169,9 @@ export class EvolAgent {
     // ── Baseagent 字段写入 ────────────────────────────
     /** 切换当前活跃 baseagent（写入 config.json）。 */
     setActiveBaseagent(value) {
+        if (value !== undefined && !isSupportedBaseagent(value)) {
+            throw new Error(`Unsupported baseagent: ${value} (choose: claude/codex/gemini/ecagent)`);
+        }
         this.merged.active_baseagent = value;
         this.updateAgentConfig(b => {
             if (value === undefined)

package/dist/core/handoff/dispatcher.js

@@ -63,6 +63,10 @@ export class HandoffDispatcher {
     isAgentPaused(selfAid) {
         return this.pausedAgents.has(selfAid);
     }
+    /** Whether delivery work for this exact target is currently executing. */
+    isRunning(selfAid, targetSessionId) {
+        return this.running.has(this.key(selfAid, targetSessionId));
+    }
     async drain(selfAid, targetSessionId) {
         const key = this.key(selfAid, targetSessionId);
         if (this.running.has(key)) {

package/dist/core/handoff/runtime.js

@@ -150,6 +150,16 @@ export class HandoffRuntime {
             .some(instance => instance.state === 'target_sent'
             || (instance.state === 'return_pending' && instance.return_policy === 'required'));
     }
+    /**
+     * Probe only in-flight delivery/return work.  Persisted handoffs that are
+     * merely waiting in the store may cross a backend generation; the queue or
+     * interaction probe handles the active parts separately.
+     */
+    hasActiveSessionWork(selfAid, sessionId) {
+        return this.dispatcher.isRunning(selfAid, sessionId)
+            || this.store.list(selfAid).some(instance => (instance.origin_session_id === sessionId
+                || instance.target_session_id === sessionId) && instance.state === 'origin_queued' && this.dispatcher.isRunning(selfAid, instance.target_session_id));
+    }
     async bindReply(input) {
         const key = `${input.selfAid}\u0000${input.targetSessionId}`;
         return this.mutexes.forKey(key).runExclusive(async () => {