evolcore 0.0.8 → 0.0.10

package/dist/core/channel-loader.js

@@ -27,9 +27,11 @@ export function showActivitiesPolicy(mode, chatType, _identity) {
 // ── ChannelLoader ──────────────────────────────────────────────────────────
 export class ChannelLoader {
     processDebug;
+    aunDefaultEncrypt;
     plugins = new Map();
-    constructor(processDebug) {
+    constructor(processDebug, aunDefaultEncrypt) {
         this.processDebug = processDebug;
+        this.aunDefaultEncrypt = aunDefaultEncrypt;
     }
     register(plugin) {
         if (this.plugins.has(plugin.name)) {
@@ -51,6 +53,7 @@ export class ChannelLoader {
             agentName: agent.aid,
             defaultProjectPath: agent.config.projects?.defaultPath ?? process.cwd(),
             debug: this.processDebug,
+            aunDefaultEncrypt: this.aunDefaultEncrypt,
         };
         // Build the full list of config instances to create.
         // AUN is synthesised from agent.aid; any explicit aun entry in channels[] is skipped.
@@ -266,6 +269,7 @@ export function buildReloadHooks(deps) {
                 agentName: agent.aid ?? agent.config?.aid,
                 defaultProjectPath: agent.config?.projects?.defaultPath ?? process.cwd(),
                 debug: channelLoader.processDebug,
+                aunDefaultEncrypt: channelLoader.aunDefaultEncrypt,
             };
             const plugin = channelLoader.getPlugin(cfgInst.type);
             if (!plugin)

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

@@ -372,7 +372,7 @@ export class CommandHandler {
             const effortDecision = validateRuntimeStringFieldOverride({
                 selfAid: definition.agentAid,
                 role,
-                field: `baseagents.${base}.${base === 'codex' ? 'reasoning' : 'effort'}`,
+                field: `baseagents.${base}.effort`,
                 value: definition.execution.effort,
             });
             if (!effortDecision.ok)

package/dist/core/command/evol-menu-version-gate.js

@@ -30,9 +30,10 @@ export function isEvolMenuVersionGateEnabled() {
 export function isAunMenuTokenRequired() {
     return loadDaemonConfig().aun?.menuTokenRequired === true;
 }
-export function evolMenuResponseTransportMetadata(_requestEncrypted) {
+export function evolMenuResponseTransportMetadata() {
     return {
-        encrypted: true,
+        // Clear inherited request state so AUNChannel applies daemon aun.defaultEncrypt.
+        encrypted: undefined,
         protectedHeaders: { ec_version: readInstalledEvolcoreVersion() },
     };
 }

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

@@ -9,6 +9,7 @@ import { resolvePaths, getPackageRoot, daemonControlDir } from '../../paths.js';
 import { buildEnvelope } from '../message/message-utils.js';
 import path from 'path';
 import fs from 'fs';
+import os from 'os';
 import crypto from 'crypto';
 import { execFileSync } from 'child_process';
 import { CronExpressionParser } from 'cron-parser';
@@ -452,9 +453,6 @@ function menuConfigSource(fieldPath, sel) {
     return null;
 }
 function menuModelConfigFieldPath(target) {
-    if (target.field === 'effort' && target.baseagent === 'codex') {
-        return `baseagents.${target.baseagent}.reasoning`;
-    }
     return target.fieldPath;
 }
 function menuChatmodeScope(args) {
@@ -1881,7 +1879,6 @@ export async function execMenuQuery(cmd, channel, channelId, userId, args, expli
         const target = resolveCapabilityTarget.call(this, { channel, args, session, evolagent, fromControlChannel });
         if ('error' in target)
             return target;
-        const identity = this.sessionManager.resolveIdentity(channel, userId, ...menuIdentityArgs(session));
         const data = queryCapabilityTypes(target.ctx, target.config, type);
         return { data: sanitizeCapabilityQueryForRole(data, identity.role) };
     }
@@ -2179,11 +2176,13 @@ export async function execMenuQuery(cmd, channel, channelId, userId, args, expli
         if (!subject.isDaemonOwner) {
             return { error: '操作需要 owner 权限', code: 'FORBIDDEN' };
         }
-        const owningAgent = this.getOwningAgent(channel);
         const data = {
             aid: loadDaemonConfig().aid ?? null,
             pid: process.pid,
-            node: process.version,
+            nodejs: process.version,
+            hostname: os.hostname(),
+            platform: process.platform,
+            arch: process.arch,
             uptime: Math.floor(process.uptime()),
         };
         try {
@@ -2204,14 +2203,6 @@ export async function execMenuQuery(cmd, channel, channelId, userId, args, expli
         const ecwebPkg = resolveGlobalPkg(WEB_PACKAGE_NAME);
         if (ecwebPkg?.version)
             data.ecwebVersion = ecwebPkg.version;
-        const channels = owningAgent?.channelInstanceNames?.() ?? [];
-        if (channels.length) {
-            // 将 channelKey 字符串（如 "feishu#aid#name"）解析为对象 { type, instName }
-            data.channels = channels.map((key) => {
-                const parts = key.split('#');
-                return { type: parts[0], instName: parts[2] || parts[0] };
-            });
-        }
         // 收集主机级可用的所有 baseagent 类型（检测已安装的 CLI + 版本）
         const baseagents = [];
         for (const cmd of ['claude', 'gemini', 'codex']) {
@@ -2260,7 +2251,9 @@ export async function execMenuUpdate(cmd, value, channel, channelId, userId, ove
     if (cmdBase === '/perm') {
         return { error: 'permissionMode 只能通过角色策略编辑器修改', code: 'ROLE_POLICY_MANAGED' };
     }
-    const scopeError = validateConfigWriteScope(cmdBase, args);
+    // JSON Menu 入口在 validateMenuRequest 中要求 activity 显式 scope；保留
+    // 底层 execMenuUpdate 的旧默认行为，兼容旧版 slash/内部直调调用方。
+    const scopeError = validateConfigWriteScope(cmdBase, args, { includeActivity: false });
     if (scopeError)
         return { error: scopeError.message, code: scopeError.code };
     args = withoutLegacySessionConfigArgs(args);
@@ -3517,26 +3510,43 @@ const SYSTEM_CONTROL_NAME_MAP = {
     config: '/config', capability: '/capability', role: '/role',
     group: '/group', connect: '/connect',
 };
+function menuCommandToken(cmd) {
+    if (typeof cmd !== 'string')
+        return undefined;
+    return cmd.trim().split(/\s+/, 1)[0] || undefined;
+}
 function isProcessLevelMenu(name, cmd) {
+    const cmdToken = menuCommandToken(cmd);
     return name === 'system' || name === 'agent' || name === 'gateway' || name === 'config'
-        || cmd === '/system' || cmd === '/agent' || cmd === '/gateway' || cmd === '/config';
+        || cmdToken === '/system' || cmdToken === '/agent' || cmdToken === '/gateway' || cmdToken === '/config';
 }
 async function execMenuForSystemControl(payload, context) {
     const id = payload?.id ?? '';
     const name = payload?.name;
-    if (name === 'cli' || payload?.cmd === '/cli') {
+    const compatCmd = menuCommandToken(payload?.cmd);
+    // `menu.query(/file)` returns file metadata and is authorized as
+    // `file.fetch`, while `menu.action(file/fetch)` sends the file. Neither
+    // operation is available through Host/control: file operations must be
+    // addressed to the current Agent AID so the Agent project boundary applies.
+    const isFileFetch = (payload?.type === 'menu.query'
+        || (payload?.type === 'menu.action' && payload?.action === 'fetch'))
+        && (name === 'file' || compatCmd === '/file');
+    if (isFileFetch) {
+        return ecwebErr(id, name, 'NOT_SUPPORTED', 'Host/control 不支持 file.fetch，请通过目标 Agent AID 请求');
+    }
+    if (name === 'cli' || compatCmd === '/cli') {
         const message = context.source === 'ecweb'
             ? 'cli 不在 ECWeb 控制范围'
             : 'cli 不在控制 channel 范围';
         return { type: 'menu.response', id, name, error: { code: 'NOT_SUPPORTED', message } };
     }
     const isProcessLevel = isProcessLevelMenu(name, payload?.cmd);
-    const isRoleRequest = name === 'role' || payload?.cmd === '/role';
-    const isConnectRequest = name === 'connect' || payload?.cmd === '/connect';
+    const isRoleRequest = name === 'role' || compatCmd === '/role';
+    const isConnectRequest = name === 'connect' || compatCmd === '/connect';
     const requiresAgentTarget = isRoleRequest || isConnectRequest || [
         'observable', 'baseagent', 'model', 'effort', 'trigger', 'capability', 'group',
     ].includes(name)
-        || ['/observable', '/baseagent', '/model', '/effort', '/trigger', '/capability', '/group'].includes(payload?.cmd);
+        || ['/observable', '/baseagent', '/model', '/effort', '/trigger', '/capability', '/group'].includes(compatCmd ?? '');
     const target = isProcessLevel
         ? { channel: SYSTEM_CONTROL_CHANNEL }
         : resolveExternalMenuAgentChannel(this, payload, SYSTEM_CONTROL_CHANNEL, requiresAgentTarget);
@@ -3635,8 +3645,9 @@ export async function execMenuForControl(payload, peerId) {
     if (validationError)
         return menuFailure({ id, ...(name ? { name } : {}) }, validationError);
     const owners = loadDaemonConfig().owners ?? [];
-    const isRoleRequest = name === 'role' || payload?.cmd === '/role';
-    const isConnectRequest = name === 'connect' || payload?.cmd === '/connect';
+    const compatCmd = menuCommandToken(payload?.cmd);
+    const isRoleRequest = name === 'role' || compatCmd === '/role';
+    const isConnectRequest = name === 'connect' || compatCmd === '/connect';
     if (!isRoleRequest && !isConnectRequest && !isProcessLevelOwner(peerId, owners)) {
         return menuFailure({ id, ...(name ? { name } : {}) }, { code: 'ROLE_ACCESS_DENIED', message: '控制 channel 操作需要 owner 权限' });
     }

package/dist/core/command/menu-protocol.js

@@ -15,6 +15,7 @@ const EXPLICIT_SCOPE_UPDATE_NAMES = new Set([
     'mentionmode',
     'group',
     'permission',
+    'activity',
 ]);
 const EXPLICIT_SCOPE_UPDATE_COMMANDS = new Set([
     '/model',
@@ -24,18 +25,20 @@ const EXPLICIT_SCOPE_UPDATE_COMMANDS = new Set([
     '/mentionmode',
     '/group',
     '/perm',
+    '/activity',
 ]);
 function firstCommandToken(value) {
     if (typeof value !== 'string')
         return undefined;
     return value.trim().split(/\s+/, 1)[0] || undefined;
 }
-function requiresExplicitConfigWriteScope(nameOrCmd) {
+function requiresExplicitConfigWriteScope(nameOrCmd, includeActivity = true) {
     const token = firstCommandToken(nameOrCmd);
-    return !!token && (EXPLICIT_SCOPE_UPDATE_NAMES.has(token) || EXPLICIT_SCOPE_UPDATE_COMMANDS.has(token));
+    return !!token && (EXPLICIT_SCOPE_UPDATE_NAMES.has(token) || EXPLICIT_SCOPE_UPDATE_COMMANDS.has(token))
+        && (includeActivity || (token !== 'activity' && token !== '/activity'));
 }
-export function validateConfigWriteScope(nameOrCmd, args) {
-    if (!requiresExplicitConfigWriteScope(nameOrCmd))
+export function validateConfigWriteScope(nameOrCmd, args, options) {
+    if (!requiresExplicitConfigWriteScope(nameOrCmd, options?.includeActivity ?? true))
         return null;
     const rawScope = args?.scope;
     if (rawScope === undefined || rawScope === null || (typeof rawScope === 'string' && rawScope.trim().length === 0)) {

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

@@ -1146,7 +1146,7 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
             }
             catch { }
             const configuredModel = modelConfig.model;
-            const configuredEffort = modelConfig[fallbackBaseagent === 'codex' ? 'reasoning' : 'effort'];
+            const configuredEffort = modelConfig.effort;
             const rawModels = hasModelSwitcher(modelAgent) ? await modelAgent.listModels() : [];
             const models = hasModelSwitcher(modelAgent)
                 ? filterModelsForRole(identity.role, fallbackBaseagent, rawModels, modelAgent.resolveModelId?.bind(modelAgent))
@@ -1468,7 +1468,7 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
             }
             catch { }
             const configuredModel = modelConfig.model;
-            const configuredEffort = modelConfig[fallbackBaseagent === 'codex' ? 'reasoning' : 'effort'];
+            const configuredEffort = modelConfig.effort;
             const currentModel = hasModelSwitcher(effortAgent) ? (configuredModel || effortAgent.getModel()) : effortAgent.name;
             const efforts = getAvailableEfforts(effortAgent, currentModel);
             const currentEffort = configuredEffort ?? effortAgent.getEffort?.() ?? 'auto';
@@ -1530,7 +1530,7 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
         }
         catch { }
         const configuredModel = modelConfig.model;
-        const configuredEffort = modelConfig[fallbackBaseagent === 'codex' ? 'reasoning' : 'effort'];
+        const configuredEffort = modelConfig.effort;
         const currentModel = hasModelSwitcher(effortAgent) ? (configuredModel || effortAgent.getModel()) : effortAgent.name;
         const efforts = getAvailableEfforts(effortAgent, currentModel);
         const currentEffort = configuredEffort ?? effortAgent.getEffort?.() ?? 'auto';
@@ -2210,7 +2210,7 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
         }
         catch { }
         const backendModel = modelConfig.model || newRunner.getModel?.() || newAgent?.model;
-        const backendEffort = modelConfig[newBaseagent === 'codex' ? 'reasoning' : 'effort']
+        const backendEffort = modelConfig.effort
             ?? newRunner.getEffort?.()
             ?? newAgent?.effort;
         const backendBits = [newBaseagent, backendModel, backendEffort].filter(Boolean).join(' · ');

package/dist/core/data-migration.js

@@ -54,6 +54,14 @@ function operationTopologyKey(operation) {
         sessionChannelKey: operation.sessionChannelKey,
     });
 }
+function operationProofTopologyKey(operation) {
+    if (operation.kind !== 'contact-audit-partition')
+        return operationTopologyKey(operation);
+    return JSON.stringify({
+        kind: operation.kind,
+        source: operation.source,
+    });
+}
 /**
  * Manifests written before allowExistingDestinationMerge was introduced still
  * need safe recovery. Re-derive that narrow permission from their immutable
@@ -125,26 +133,40 @@ function acknowledgeCompletedCopies(root, operations) {
             if (manifest.planSignature === currentPlanSignature)
                 return;
             for (const operation of manifest.operations ?? []) {
-                if (operation.kind !== 'copy' || (operation.status !== 'committed' && operation.status !== 'skipped') || !operation.sourceHash)
+                if ((operation.kind !== 'copy' && operation.kind !== 'contact-audit-partition')
+                    || (operation.status !== 'committed' && operation.status !== 'skipped')
+                    || !operation.sourceHash)
                     continue;
-                const key = operationTopologyKey(operation);
-                if (!proofs.has(key))
-                    proofs.set(key, { migrationId: manifest.id, sourceHash: operation.sourceHash });
+                const key = operationProofTopologyKey(operation);
+                if (!proofs.has(key)) {
+                    proofs.set(key, {
+                        migrationId: manifest.id,
+                        sourceHash: operation.sourceHash,
+                        destinations: operation.kind === 'contact-audit-partition'
+                            ? [...(operation.destinations ?? [])]
+                            : operation.destination ? [operation.destination] : [],
+                    });
+                }
             }
         }
     }
     catch { }
     for (const operation of operations) {
-        if (operation.kind !== 'copy' || !operation.destination || !fs.existsSync(operation.destination))
+        if (operation.kind !== 'copy' && operation.kind !== 'contact-audit-partition')
             continue;
-        const proof = proofs.get(operationTopologyKey(operation));
+        const proof = proofs.get(operationProofTopologyKey(operation));
         if (!proof)
             continue;
+        if (operation.kind === 'copy' && (!operation.destination || !fs.existsSync(operation.destination)))
+            continue;
+        if (operation.kind === 'contact-audit-partition' && proof.destinations.some(destination => !fs.existsSync(destination)))
+            continue;
         try {
             if (treeHash(operation.source, operation.exclude) !== proof.sourceHash)
                 continue;
             operation.status = 'acknowledged';
             operation.acknowledgedBy = proof.migrationId;
+            operation.sourceHash = proof.sourceHash;
         }
         catch { }
     }
@@ -1419,6 +1441,18 @@ function atomicWriteText(target, content) {
 function hashContent(content) {
     return crypto.createHash('sha256').update(content, 'utf8').digest('hex');
 }
+function mergeJsonlContent(existing, incoming, deduplicateExisting = false) {
+    const existingLines = existing.split('\n').filter(line => line.trim());
+    const merged = deduplicateExisting ? [...new Set(existingLines)] : [...existingLines];
+    const lines = new Set(merged);
+    for (const line of incoming.split('\n')) {
+        if (!line.trim() || lines.has(line))
+            continue;
+        lines.add(line);
+        merged.push(line);
+    }
+    return merged.length ? `${merged.join('\n')}\n` : '';
+}
 function appendIssue(operation, issue) {
     const issues = operation.issues ?? [];
     if (!issues.includes(issue))
@@ -1457,20 +1491,18 @@ function executeContactAudit(manifest, operation, checkpoint) {
     for (const [aid, lines] of groups) {
         const destination = path.join(manifest.root, 'agents', aid, 'data', 'contact-audit.jsonl');
         const content = lines.join('\n') + '\n';
-        const expectedHash = hashContent(content);
+        const existing = fs.existsSync(destination) ? fs.readFileSync(destination, 'utf8') : undefined;
+        if (existing !== undefined)
+            strictJsonValidation(destination);
+        const expectedContent = existing === undefined ? content : mergeJsonlContent(existing, content);
+        const expectedHash = hashContent(expectedContent);
         operation.destinations.push(destination);
         operation.destinationHashes[destination] = expectedHash;
-        if (fs.existsSync(destination)) {
-            const existing = fs.readFileSync(destination, 'utf8');
+        if (existing !== undefined) {
             if (hashContent(existing) !== expectedHash) {
-                // Audit logs are append-only. An exact existing prefix is a partial
-                // prior copy, so replacing it with the verified complete partition is
-                // lossless; every other mismatch remains a manual conflict.
-                if (!content.startsWith(existing)) {
-                    appendIssue(operation, `destination conflict: ${destination}`);
-                    continue;
-                }
-                atomicWriteText(destination, content);
+                // The per-Agent audit may have advanced after an earlier migration.
+                // Preserve its order and append only legacy records not already present.
+                atomicWriteText(destination, expectedContent);
             }
             continue;
         }
@@ -1600,15 +1632,7 @@ function trackMergeSources(operation) {
     return sources;
 }
 function mergeJsonl(target, source) {
-    const lines = new Set(fs.readFileSync(target, 'utf8').split('\n').filter(line => line.trim()));
-    const merged = [...lines];
-    for (const line of fs.readFileSync(source, 'utf8').split('\n')) {
-        if (!line.trim() || lines.has(line))
-            continue;
-        lines.add(line);
-        merged.push(line);
-    }
-    fs.writeFileSync(target, merged.length ? `${merged.join('\n')}\n` : '');
+    fs.writeFileSync(target, mergeJsonlContent(fs.readFileSync(target, 'utf8'), fs.readFileSync(source, 'utf8'), true));
 }
 function copyTree(source, destination) {
     const stat = fs.statSync(source);
@@ -1741,6 +1765,34 @@ export function readDataMigration(root, id) {
         throw new Error(`migration manifest not found: ${id}`);
     return manifest;
 }
+function completedMigrationMatchesPlan(manifest, plan, planSignature) {
+    if (manifest.state !== 'completed' || manifest.planSignature !== planSignature)
+        return false;
+    const proofs = new Map(manifest.operations.map(operation => [operationProofTopologyKey(operation), operation]));
+    for (const operation of plan.operations.filter(item => item.status !== 'acknowledged')) {
+        const proof = proofs.get(operationProofTopologyKey(operation));
+        if (!proof || (proof.status !== 'committed' && proof.status !== 'skipped' && proof.status !== 'acknowledged'))
+            return false;
+        try {
+            for (const source of operationSources(operation)) {
+                const expected = proof.sourceHashes?.[source]
+                    ?? (source === proof.source ? proof.sourceHash : undefined);
+                if (!expected || treeHash(source, operation.exclude) !== expected)
+                    return false;
+            }
+        }
+        catch {
+            return false;
+        }
+        if ((operation.kind === 'copy' || operation.kind === 'merge-copy')
+            && (!operation.destination || !fs.existsSync(operation.destination)))
+            return false;
+        if (operation.kind === 'contact-audit-partition'
+            && (proof.destinations ?? []).some(destination => !fs.existsSync(destination)))
+            return false;
+    }
+    return true;
+}
 /**
  * Startup gate for the explicit migration workflow. Legacy source files are
  * deliberately retained after success, so their mere presence is not enough
@@ -1763,7 +1815,7 @@ export function inspectDataMigrationRequirement(root) {
             if (!entry.isFile() || !entry.name.endsWith('.json'))
                 continue;
             const manifest = readJson(path.join(migrationDir(root), entry.name));
-            if (manifest?.state !== 'completed' || manifest.planSignature !== planSignature)
+            if (!manifest || !completedMigrationMatchesPlan(manifest, plan, planSignature))
                 continue;
             completedMigrationId = manifest.id;
             break;

package/dist/core/inference/text-inference.js

@@ -3,8 +3,20 @@ function apiEndpoint(baseUrl, resource) {
     const configured = baseUrl?.trim();
     if (!configured)
         throw new Error('Direct text inference baseUrl is not configured');
-    const base = configured.replace(/\/+$/, '');
-    return base.endsWith('/v1') ? `${base}/${resource}` : `${base}/v1/${resource}`;
+    const parsed = new URL(configured);
+    const pathname = parsed.pathname.replace(/\/+$/, '');
+    parsed.pathname = pathname.endsWith('/v1')
+        ? `${pathname}/${resource}`
+        : `${pathname}/v1/${resource}`;
+    return parsed.toString();
+}
+function withQueryParams(url, queryParams) {
+    if (!queryParams || Object.keys(queryParams).length === 0)
+        return url;
+    const parsed = new URL(url);
+    for (const [name, value] of Object.entries(queryParams))
+        parsed.searchParams.set(name, value);
+    return parsed.toString();
 }
 async function parseError(response) {
     let raw = '';
@@ -28,10 +40,10 @@ export class AnthropicTextInferenceProvider {
         this.config = config;
     }
     async completeText(request) {
-        const response = await fetch(apiEndpoint(this.config.baseUrl, 'messages'), {
+        const response = await fetch(withQueryParams(apiEndpoint(this.config.baseUrl, 'messages'), this.config.queryParams), {
             method: 'POST',
             signal: request.signal,
-            headers: this.headers(),
+            headers: { ...this.headers(), ...this.config.headers },
             body: JSON.stringify({
                 model: request.model,
                 max_tokens: 256,
@@ -69,12 +81,13 @@ export class OpenAITextInferenceProvider {
         this.config = config;
     }
     async completeText(request) {
-        const response = await fetch(apiEndpoint(this.config.baseUrl, 'responses'), {
+        const response = await fetch(withQueryParams(apiEndpoint(this.config.baseUrl, 'responses'), this.config.queryParams), {
             method: 'POST',
             signal: request.signal,
             headers: {
                 'Content-Type': 'application/json',
                 Authorization: `Bearer ${this.config.apiKey}`,
+                ...this.config.headers,
             },
             body: JSON.stringify({
                 model: request.model,

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

@@ -627,6 +627,7 @@ export class MessageBridge {
                 const menuControl = resolvedChannelType === 'aun'
                     ? parseMenuControl(content)
                     : { isMenu: false };
+                let menuResponseWarning;
                 if (menuControl.isMenu) {
                     this.logMenuInbound(channelName, msg, menuControl);
                     if (!hasValidMenuId(menuControl)) {
@@ -649,7 +650,7 @@ export class MessageBridge {
                         await this.sendMenuResponse(adapter, channelName, msg, menuFailure(header, {
                             code: 'MENU_TOKEN_ENCRYPTION_REQUIRED',
                             message: 'Menu 请求必须使用 E2EE',
-                        }), true);
+                        }));
                         return;
                     }
                     if (!isTokenRequest) {
@@ -666,6 +667,13 @@ export class MessageBridge {
                             }));
                             return;
                         }
+                        if (!menuTokenRequired && tokenSupplied && !tokenValid) {
+                            this.logMenuDiagnostic('token-invalid-optional', channelName, msg, menuControl, 'MENU_TOKEN_INVALID');
+                            menuResponseWarning = {
+                                code: 'MENU_TOKEN_INVALID',
+                                message: 'Menu token 无效，请重新申请',
+                            };
+                        }
                     }
                     const validationError = validateMenuRequest(menuControl.request);
                     if (validationError) {
@@ -712,7 +720,7 @@ export class MessageBridge {
                 });
                 const identity = authSubject.identity;
                 if (menuControl.isMenu) {
-                    await this.handleMenuControl(menuControl, channelName, resolvedChannelType, msg, adapter, authSubject);
+                    await this.handleMenuControl(menuControl, channelName, resolvedChannelType, msg, adapter, authSubject, menuResponseWarning);
                     return;
                 }
                 // 普通消息保留原始日志；控制 payload 使用脱敏元数据日志。
@@ -1074,7 +1082,7 @@ export class MessageBridge {
             throw { code: 'NOT_SUPPORTED', message: `Unsupported menu name: ${name}` };
         return mapped;
     }
-    async handleMenuControl(parsed, channel, channelType, msg, adapter, authSubject) {
+    async handleMenuControl(parsed, channel, channelType, msg, adapter, authSubject, responseWarning) {
         if (!hasValidMenuId(parsed))
             return;
         const header = { id: parsed.id, ...(parsed.name?.trim() ? { name: parsed.name } : {}) };
@@ -1122,7 +1130,10 @@ export class MessageBridge {
         }
         if (deduped.replayed)
             this.logMenuDiagnostic('request-replay', channel, msg, parsed);
-        await this.sendMenuResponse(adapter, channel, msg, deduped.value, isTokenRequest);
+        const response = responseWarning && 'data' in deduped.value
+            ? { ...deduped.value, warning: responseWarning }
+            : deduped.value;
+        await this.sendMenuResponse(adapter, channel, msg, response);
         const deferredEffect = afterResponse;
         if (!deduped.replayed && deferredEffect) {
             try {
@@ -1191,7 +1202,7 @@ export class MessageBridge {
             return menuFailure(header, normalizeMenuError(error));
         }
     }
-    async sendMenuResponse(adapter, channel, msg, response, forceEncryption = false) {
+    async sendMenuResponse(adapter, channel, msg, response) {
         if (!adapter?.send) {
             this.logMenuDiagnostic('transport-unavailable', channel, msg, {
                 isMenu: true,
@@ -1208,7 +1219,7 @@ export class MessageBridge {
             ...(msg.replyContext ?? {}),
             metadata: {
                 ...(msg.replyContext?.metadata ?? {}),
-                ...evolMenuResponseTransportMetadata(forceEncryption ? true : msg.encrypted),
+                ...evolMenuResponseTransportMetadata(),
             },
         };
         const envelope = buildEnvelope({

package/dist/core/message/response-engine.js

@@ -890,6 +890,16 @@ export class ResponseEngine {
             return;
         renderer.addNotice(text, severity, subtype, true);
     }
+    async cancelStaleRunnerStart(agent, sessionId, streamKey, turnLease, taskId) {
+        if (this.turnCoordinator.isCurrent(turnLease))
+            return false;
+        logger.info(`[ResponseEngine] Stale turn detected after agent.runQuery start; cancelling unconsumed stream: session=${sessionId} task=${taskId}`);
+        await agent.interrupt(sessionId).catch(interruptError => {
+            logger.warn(`[ResponseEngine] Failed to cancel stale runner start: session=${sessionId} task=${taskId} error=${interruptError instanceof Error ? interruptError.message : String(interruptError)}`);
+        });
+        agent.cleanupStream(streamKey);
+        return true;
+    }
     async retryAfterContextRecovery(prompt, opts) {
         const { streamKey, renderer, agent, session, absoluteProjectPath, effectiveSystemPrompt, modelOverride, runtimeEnv, resetTimer, shouldSuppress, proactive, turnLease, } = opts;
         if (!session.agentSessionId || !canCompactAgent(agent)) {
@@ -911,6 +921,9 @@ export class ResponseEngine {
             await this.emitOperationalNotice(renderer, '✅ 压缩完成，继续处理...', 'info', 'compact-retry');
             await renderer.flush();
             const retryStream = await agent.runQuery(session.id, prompt, absoluteProjectPath, session.agentSessionId, undefined, effectiveSystemPrompt, this.sessionManager, modelOverride, runtimeEnv);
+            if (await this.cancelStaleRunnerStart(agent, session.id, streamKey, turnLease, turnLease.taskId)) {
+                throw new Error('RUNNER_START_SUPERSEDED');
+            }
             agent.registerStream(streamKey, retryStream);
             return await this.processEventStream(retryStream, session, agent, renderer, resetTimer, shouldSuppress, proactive, undefined, // 重试分支不调插件钩子
             undefined, turnLease);
@@ -2331,7 +2344,7 @@ export class ResponseEngine {
                 try {
                     const selector = { self: selfAid || undefined, peerKey };
                     const modelResolution = resolveEffectiveFieldWithSource(`baseagents.${normalizedBaseagent.canonical}.model`, selector, { cache: true });
-                    const effortResolution = resolveEffectiveFieldWithSource(`baseagents.${normalizedBaseagent.canonical}.${normalizedBaseagent.canonical === 'codex' ? 'reasoning' : 'effort'}`, selector, { cache: true });
+                    const effortResolution = resolveEffectiveFieldWithSource(`baseagents.${normalizedBaseagent.canonical}.effort`, selector, { cache: true });
                     const modelDecision = constrainResolvedModelForRole({
                         role: peerRole,
                         baseagent: normalizedBaseagent.canonical,
@@ -2342,7 +2355,7 @@ export class ResponseEngine {
                         selfAid: selfAid || undefined,
                     });
                     const model = modelDecision.model;
-                    const effortField = `baseagents.${normalizedBaseagent.canonical}.${normalizedBaseagent.canonical === 'codex' ? 'reasoning' : 'effort'}`;
+                    const effortField = `baseagents.${normalizedBaseagent.canonical}.effort`;
                     const effortDecision = resolveRuntimeStringField({
                         selfAid: selfAid || undefined,
                         role: peerRole,
@@ -2389,7 +2402,7 @@ export class ResponseEngine {
                         effectiveModelSource = triggerModelDecision.constrained ? 'role' : 'trigger';
                     }
                     if (triggerEffortOverride) {
-                        const effortField = `baseagents.${normalizedBaseagent.canonical}.${normalizedBaseagent.canonical === 'codex' ? 'reasoning' : 'effort'}`;
+                        const effortField = `baseagents.${normalizedBaseagent.canonical}.effort`;
                         const triggerEffortDecision = resolveRuntimeStringField({
                             selfAid: selfAid || undefined,
                             role: peerRole,
@@ -2766,6 +2779,12 @@ export class ResponseEngine {
                     try {
                         logger.info(`[ResponseEngine] agent.runQuery start: agent=${agent.name} session=${session.id} task=${taskId} attempt=${runAttempt} apiRetries=${retryScheduler.apiRetryAttemptsMade} agentSessionId=${session.agentSessionId ?? 'none'}`);
                         const stream = await agent.runQuery(session.id, effectivePrompt, absoluteProjectPath, session.agentSessionId, renderResult?.images.length ? renderResult.images : message.images, effectiveSystemPrompt, this.sessionManager, modelOverride, runtimeEnv);
+                        // The turn may be superseded while the runner is still creating its
+                        // backend query. Replay the interrupt after runQuery resolves, when
+                        // every runner is required to have an addressable cancellation handle.
+                        if (await this.cancelStaleRunnerStart(agent, session.id, streamKey, turnLease, taskId)) {
+                            throw new Error('RUNNER_START_SUPERSEDED');
+                        }
                         agent.registerStream(streamKey, stream);
                         streamRegistered = true;
                         if (shouldTimeoutRetryAttempt) {

package/dist/core/model/config-scope.js

@@ -82,9 +82,9 @@ export function activeBaseagent(self) {
     catch { /* fall through */ }
     return 'claude';
 }
-/** codex 的推理强度字段名是 reasoning，其余是 effort。 */
-function effortField(ba) {
-    return ba === 'codex' ? 'reasoning' : 'effort';
+/** 所有 baseagent 统一使用 effort 表达推理强度。 */
+function effortField(_ba) {
+    return 'effort';
 }
 // ── 写：单作用域 ──────────────────────────────────────────────────────
 /** 写入指定作用域。patch 中 undefined 不动；显式 null 删除字段。 */