evolcore 0.0.7 → 0.0.9

package/dist/config/config-manager.js

@@ -17,6 +17,7 @@ import { resolvePaths, agentConfig as agentConfigPath, agentContactConfig, agent
 import { atomicReadJson, atomicWriteJson } from '../utils/atomic-write.js';
 import { fileCache } from '../core/daemon-file-cache.js';
 import { isValidAid } from '../aun/aid/validation.js';
+import { normalizeAidDomain } from '../aun/aid/domain.js';
 import { isExplicitGroupId } from '../aun/group-identity.js';
 import { parseContactAlias } from './contact-alias.js';
 import { loadSchema, listSchemaVersions, currentVersion, isSchemaName, } from './schema-registry.js';
@@ -504,10 +505,40 @@ export function read(target, sel, opts = {}) {
         : target === ConfigTarget.Relation
             ? foldLegacyProactiveBlock(migrated)
             : migrated;
+    // Agent read compatibility may move the legacy top-level `agents` block to
+    // `baseagents`, so canonicalize effort after that structural migration.
+    const canonicalized = normalizeBaseagentEffortCompat(normalized);
     if (!opts.expand)
-        return normalized;
+        return canonicalized;
     const resolver = buildEnvResolver(envScopeFor(sel));
-    return expandVars(normalized, resolver);
+    return expandVars(canonicalized, resolver);
+}
+/**
+ * Canonicalize the legacy Codex `reasoning` config key to the public `effort`
+ * key.  The runner may still accept `reasoning` as an input alias, but all
+ * config scopes resolve and persist the same `effort` field.
+ */
+function normalizeBaseagentEffortCompat(value) {
+    const rawBaseagents = value?.baseagents;
+    if (!rawBaseagents || typeof rawBaseagents !== 'object' || Array.isArray(rawBaseagents))
+        return value;
+    const baseagents = { ...rawBaseagents };
+    let changed = false;
+    for (const [name, rawBlock] of Object.entries(baseagents)) {
+        if (!rawBlock || typeof rawBlock !== 'object' || Array.isArray(rawBlock))
+            continue;
+        const block = { ...rawBlock };
+        if (Object.prototype.hasOwnProperty.call(block, 'reasoning')) {
+            if (block.effort === undefined)
+                block.effort = block.reasoning;
+            delete block.reasoning;
+            baseagents[name] = block;
+            changed = true;
+        }
+    }
+    if (!changed)
+        return value;
+    return { ...value, baseagents };
 }
 function normalizeAgentConfigForRead(value, aid) {
     const config = foldLegacyProactiveBlock(normalizeAgentLifecycle(value));
@@ -548,7 +579,7 @@ function groupFor(target, sel) {
     return 'config';
 }
 function normalizeAgentConfigForWrite(value) {
-    const mutable = { ...value };
+    const mutable = normalizeBaseagentEffortCompat({ ...value });
     normalizeShowActivitiesCompat(mutable);
     // AID 格式校验
     if (mutable.aid && !isValidAid(mutable.aid)) {
@@ -571,8 +602,22 @@ function normalizeAgentConfigForWrite(value) {
     }
     return mutable;
 }
+function normalizeProcessConfigForWrite(value) {
+    const configuredAidDomain = value.aun?.defaultAidDomain;
+    if (configuredAidDomain === undefined)
+        return value;
+    try {
+        return {
+            ...value,
+            aun: { ...value.aun, defaultAidDomain: normalizeAidDomain(configuredAidDomain, 'aun.defaultAidDomain') },
+        };
+    }
+    catch (error) {
+        throw new ConfigError('VALIDATION_ERROR', error instanceof Error ? error.message : String(error));
+    }
+}
 function normalizeRelationConfigForWrite(value) {
-    const mutable = { ...value };
+    const mutable = normalizeBaseagentEffortCompat({ ...value });
     normalizeShowActivitiesCompat(mutable);
     return mutable;
 }
@@ -638,12 +683,15 @@ export function write(target, value, sel, opts = {}) {
         : loadSchema(TARGET_SCHEMA[target]);
     const withVer = ensureSchemaVersion(value, schema.version);
     const migrated = withVer;
+    const canonicalized = normalizeBaseagentEffortCompat(migrated);
     // Agent config 写入规范化（aid 校验、projects 字段清理）
     const normalized = target === ConfigTarget.Agent
-        ? normalizeAgentConfigForWrite(migrated)
+        ? normalizeAgentConfigForWrite(canonicalized)
         : target === ConfigTarget.Relation
-            ? normalizeRelationConfigForWrite(migrated)
-            : migrated;
+            ? normalizeRelationConfigForWrite(canonicalized)
+            : target === ConfigTarget.Process
+                ? normalizeProcessConfigForWrite(canonicalized)
+                : canonicalized;
     // 1. Schema 校验
     if (!opts.skipValidate) {
         validateOrThrow(schema, normalized, target);
@@ -836,7 +884,7 @@ function ensureSchemaVersion(value, version) {
 }
 function validateOrThrow(schema, value, target) {
     const ok = schema.validate(value);
-    const scopeErrors = validateProcessOnlyFields(target, value);
+    const scopeErrors = [...validateProcessOnlyFields(target, value), ...validateProcessAidDomain(target, value)];
     if (!ok || scopeErrors.length > 0) {
         const errs = [
             ...scopeErrors,
@@ -853,9 +901,29 @@ function validateOrThrow(schema, value, target) {
 function validateProcessOnlyFields(target, value) {
     if (target === ConfigTarget.Process || !value || typeof value !== 'object')
         return [];
-    if (!Object.prototype.hasOwnProperty.call(value, 'debug'))
+    const errors = [];
+    if (Object.prototype.hasOwnProperty.call(value, 'debug')) {
+        errors.push('/debug is only allowed in process config');
+    }
+    const aun = value.aun;
+    if (aun && typeof aun === 'object' && Object.prototype.hasOwnProperty.call(aun, 'defaultEncrypt')) {
+        errors.push('/aun/defaultEncrypt is only allowed in process config');
+    }
+    return errors;
+}
+function validateProcessAidDomain(target, value) {
+    if (target !== ConfigTarget.Process || !value || typeof value !== 'object')
+        return [];
+    const configuredAidDomain = value?.aun?.defaultAidDomain;
+    if (configuredAidDomain === undefined)
+        return [];
+    try {
+        normalizeAidDomain(configuredAidDomain, 'aun.defaultAidDomain');
         return [];
-    return ['/debug is only allowed in process config'];
+    }
+    catch (error) {
+        return [`/aun/defaultAidDomain ${error instanceof Error ? error.message : String(error)}`];
+    }
 }
 /**
  * responseModeParams 桶专项校验。
@@ -908,7 +976,7 @@ export function validateConfig(target, value) {
         : loadSchema(TARGET_SCHEMA[target]);
     const withVer = ensureSchemaVersion(value, schema.version);
     const ok = schema.validate(withVer);
-    const errors = validateProcessOnlyFields(target, withVer);
+    const errors = [...validateProcessOnlyFields(target, withVer), ...validateProcessAidDomain(target, withVer)];
     if (ok && errors.length === 0)
         return [];
     return [

package/dist/config/gateway-config.js

@@ -29,6 +29,47 @@ const DISPLAY_NAMES = {
 };
 // ── 掩码 ──
 const ENV_PREFIX = '$ENV:';
+// Claude Code supports both credential variable names. Keep AUTH_TOKEN first
+// to match the runtime resolver's precedence.
+const standardEnvKeys = {
+    apiKey: ['ANTHROPIC_AUTH_TOKEN'],
+    baseUrl: ['ANTHROPIC_BASE_URL'],
+};
+function envKeysForGateway(type, field) {
+    if (type === 'claude' && field === 'apiKey')
+        return ['ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_API_KEY'];
+    return standardEnvKeys[field];
+}
+function firstEnvValue(env, names) {
+    for (const name of names) {
+        const value = env[name];
+        if (value)
+            return { name, value };
+    }
+    return undefined;
+}
+const DEBUG_SECRET_KEY = /(?:key|token|secret|password|authorization|credential|private)/i;
+function redactDebugValue(value, key) {
+    if (typeof value === 'string') {
+        if (value === '(未设置)')
+            return value;
+        if (key && DEBUG_SECRET_KEY.test(key) && !value.startsWith(ENV_PREFIX))
+            return '***';
+        return value;
+    }
+    if (Array.isArray(value))
+        return value.map(item => redactDebugValue(item));
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value)
+            .map(([childKey, childValue]) => [childKey, redactDebugValue(childValue, childKey)]));
+    }
+    return value;
+}
+function redactMismatchValue(value, field) {
+    if (!value)
+        return value;
+    return field === 'apiKey' && !value.startsWith(ENV_PREFIX) ? '***' : value;
+}
 function maskApiKey(raw) {
     if (typeof raw !== 'string' || !raw)
         return { mask: undefined, isEnvRef: false };
@@ -203,21 +244,17 @@ function detectEnvMismatch(defaults, aids) {
     // 读取全局 .env 文件
     const rootEnvPath = path.join(resolvePaths().root, '.env');
     const rootEnvVars = parseEnvFileSync(rootEnvPath);
-    // 标准环境变量映射
-    const standardEnvKeys = {
-        apiKey: 'ANTHROPIC_AUTH_TOKEN',
-        baseUrl: 'ANTHROPIC_BASE_URL',
-    };
     // 记录进程环境变量
-    const processEnvDebug = {
+    const processEnvDebug = redactDebugValue({
         ANTHROPIC_BASE_URL: process.env.ANTHROPIC_BASE_URL || '(未设置)',
         ANTHROPIC_AUTH_TOKEN: process.env.ANTHROPIC_AUTH_TOKEN || '(未设置)',
-    };
+        ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || '(未设置)',
+    });
     // 收集调试信息返回给前端
     result.debug = {
         processEnv: processEnvDebug,
-        rootEnvFile: rootEnvVars,
-        defaultsConfig: defaultsBa,
+        rootEnvFile: redactDebugValue(rootEnvVars),
+        defaultsConfig: redactDebugValue(defaultsBa),
     };
     // 检测全局默认配置中的环境变量
     for (const type of GATEWAY_TYPES) {
@@ -243,23 +280,25 @@ function detectEnvMismatch(defaults, aids) {
                 }
             }
             // 情况2：配置值是实际值（非 $ENV 引用），检查是否应该使用环境变量
-            else if (typeof val === 'string' && val && standardEnvKeys[field]) {
-                const envVarName = standardEnvKeys[field];
-                const fileValue = rootEnvVars[envVarName];
-                const processValue = process.env[envVarName];
+            else if (typeof val === 'string' && val && envKeysForGateway(type, field)) {
+                const envKeys = envKeysForGateway(type, field);
+                const envValue = firstEnvValue(process.env, envKeys);
+                const fileValue = firstEnvValue(rootEnvVars, envKeys);
+                const envVarName = envValue?.name;
+                const processValue = envValue?.value;
                 // 如果进程环境中有值，但配置中的值与进程环境不一致
-                if (processValue && val !== processValue) {
+                if (processValue && val !== processValue && envVarName) {
                     // 同时检查 .env 文件：如果 .env 也没有这个值，说明需要同步
-                    if (!fileValue || fileValue !== processValue) {
+                    if (!fileValue || fileValue.value !== processValue) {
                         result.hasMismatch = true;
                         result.mismatches.push({
                             aid: 'defaults',
                             type,
                             field,
-                            envValue: fileValue || '(.env 中未设置)',
-                            configValue: val,
+                            envValue: redactMismatchValue(fileValue?.value, field) || '(.env 中未设置)',
+                            configValue: redactMismatchValue(val, field) || val,
                             envVarName,
-                            processValue,
+                            processValue: redactMismatchValue(processValue, field),
                         });
                     }
                 }
@@ -295,18 +334,20 @@ function detectEnvMismatch(defaults, aids) {
                     }
                 }
                 // 情况2：配置值是实际值
-                else if (typeof val === 'string' && val && standardEnvKeys[field]) {
-                    const envVarName = standardEnvKeys[field];
-                    const fileValue = agentEnvVars[envVarName];
-                    const processValue = process.env[envVarName];
-                    if (processValue && val !== processValue) {
-                        if (!fileValue || fileValue !== processValue) {
+                else if (typeof val === 'string' && val && envKeysForGateway(type, field)) {
+                    const envKeys = envKeysForGateway(type, field);
+                    const envValue = firstEnvValue(process.env, envKeys);
+                    const fileValue = firstEnvValue(agentEnvVars, envKeys);
+                    const envVarName = envValue?.name;
+                    const processValue = envValue?.value;
+                    if (processValue && val !== processValue && envVarName) {
+                        if (!fileValue || fileValue.value !== processValue) {
                             result.hasMismatch = true;
                             result.mismatches.push({
                                 aid,
                                 type,
                                 field,
-                                envValue: fileValue || '(.env 中未设置)',
+                                envValue: redactMismatchValue(fileValue?.value, field) || '(.env 中未设置)',
                                 configValue: `配置值与环境变量 ${envVarName} 不一致`,
                             });
                         }
@@ -707,11 +748,13 @@ export async function gatewaySyncEnv(args) {
                             }
                             // 情况2：实际值型，但与进程环境变量不一致
                             else {
-                                const standardEnvKey = field === 'apiKey' ? 'ANTHROPIC_AUTH_TOKEN' : field === 'baseUrl' ? 'ANTHROPIC_BASE_URL' : null;
-                                if (standardEnvKey) {
-                                    const processValue = process.env[standardEnvKey];
-                                    if (processValue && val !== processValue) {
-                                        block[field] = processValue;
+                                const envKeys = envKeysForGateway(type, field);
+                                const envValue = envKeys
+                                    ? firstEnvValue(process.env, envKeys)
+                                    : undefined;
+                                if (envValue) {
+                                    if (val !== envValue.value) {
+                                        block[field] = envValue.value;
                                         hasChanges = true;
                                     }
                                 }
@@ -751,11 +794,13 @@ export async function gatewaySyncEnv(args) {
                             }
                             // 情况2：实际值型
                             else {
-                                const standardEnvKey = field === 'apiKey' ? 'ANTHROPIC_AUTH_TOKEN' : field === 'baseUrl' ? 'ANTHROPIC_BASE_URL' : null;
-                                if (standardEnvKey) {
-                                    const processValue = process.env[standardEnvKey];
-                                    if (processValue && val !== processValue) {
-                                        block[field] = processValue;
+                                const envKeys = envKeysForGateway(type, field);
+                                const envValue = envKeys
+                                    ? firstEnvValue(process.env, envKeys)
+                                    : undefined;
+                                if (envValue) {
+                                    if (val !== envValue.value) {
+                                        block[field] = envValue.value;
                                         hasChanges = true;
                                     }
                                 }

package/dist/config/role-schema.js

@@ -1,4 +1,18 @@
 import { loadSchema } from './schema-registry.js';
+const LEGACY_CODEX_EFFORT_FIELD = 'baseagents.codex.reasoning';
+const CODEX_EFFORT_FIELD = 'baseagents.codex.effort';
+/** Convert the legacy flattened Codex role permission key to `effort`. */
+export function normalizeRoleEffortCompat(value) {
+    if (!isRecord(value) || !isRecord(value.permissions)
+        || !Object.hasOwn(value.permissions, LEGACY_CODEX_EFFORT_FIELD))
+        return value;
+    const permissions = { ...value.permissions };
+    if (!Object.hasOwn(permissions, CODEX_EFFORT_FIELD)) {
+        permissions[CODEX_EFFORT_FIELD] = permissions[LEGACY_CODEX_EFFORT_FIELD];
+    }
+    delete permissions[LEGACY_CODEX_EFFORT_FIELD];
+    return { ...value, permissions };
+}
 export function rolePermissionFields() {
     const raw = loadSchema('role-config').raw['x-permission-fields'];
     if (!Array.isArray(raw))
@@ -41,9 +55,10 @@ export function rolePermissionFieldPatterns(field) {
 }
 /** Shared RoleService/Menu validation backed by the published role schema. */
 export function validateRoleConfig(value) {
-    const normalized = isRecord(value) && !Object.hasOwn(value, '$schema_version')
-        ? { ...value, $schema_version: 1 }
-        : value;
+    const compatible = normalizeRoleEffortCompat(value);
+    const normalized = isRecord(compatible) && !Object.hasOwn(compatible, '$schema_version')
+        ? { ...compatible, $schema_version: 1 }
+        : compatible;
     const schema = loadSchema('role-config');
     if (!schema.validate(normalized)) {
         return (schema.validate.errors ?? []).map(error => ({

package/dist/config/role-service.js

@@ -6,7 +6,7 @@ import { loadSchema } from './schema-registry.js';
 import { clearRoleStoreCache, getStoredRoleRegistry, isRoleName, readRoleStore, roleRegistryExists, } from './role-store.js';
 import { expectedRoleRank, isManagementRole } from './builtin-roles.js';
 import { readBuiltinRoleTemplate } from './builtin-role-templates.js';
-import { validateRoleConfig } from './role-schema.js';
+import { normalizeRoleEffortCompat, validateRoleConfig } from './role-schema.js';
 export class RoleServiceError extends Error {
     code;
     data;
@@ -43,7 +43,7 @@ export function writeRoleRegistry(selfAid, value) {
 export function writeRoleDefinition(selfAid, roleId, value) {
     if (!isRoleName(roleId))
         throw new RoleServiceError('INVALID_ROLE_ID', `Invalid role id: ${roleId}`);
-    const normalized = { ...value, rank: expectedRoleRank(roleId), $schema_version: 1 };
+    const normalized = normalizeRoleEffortCompat({ ...value, rank: expectedRoleRank(roleId), $schema_version: 1 });
     validateRoleDefinition(normalized);
     const registry = readRoleRegistry(selfAid);
     if (!registry.roles.includes(roleId)) {
@@ -93,7 +93,7 @@ export function listRoleDiagnostics(selfAid) {
     return readRoleStore(selfAid).diagnostics;
 }
 function writeRoleDefinitionFile(selfAid, roleId, value) {
-    const normalized = { ...value, rank: expectedRoleRank(roleId), $schema_version: 1 };
+    const normalized = normalizeRoleEffortCompat({ ...value, rank: expectedRoleRank(roleId), $schema_version: 1 });
     validateRoleDefinition(normalized);
     const file = agentRoleConfig(selfAid, roleId);
     fs.mkdirSync(path.dirname(file), { recursive: true });

package/dist/config/role-store.js

@@ -5,7 +5,7 @@ import { agentRoleConfig, agentRolesDir, agentRolesIndex, kitsRoleTemplatesDir,
 import { applyManagementRoleCeiling, expectedRoleRank, getManagementRoleDefinition } from './builtin-roles.js';
 import { readBuiltinRoleTemplate } from './builtin-role-templates.js';
 import { loadSchema } from './schema-registry.js';
-import { validateRoleConfig } from './role-schema.js';
+import { normalizeRoleEffortCompat, validateRoleConfig } from './role-schema.js';
 const ROLE_NAME_RE = /^[a-z0-9_-]+$/;
 const BUILTIN_ROLES = ['owner', 'admin', 'member', 'visitor'];
 const cache = new Map();
@@ -154,9 +154,10 @@ function readDefinition(selfAid, roleId, diagnostics) {
         }
         if (raw === null)
             continue;
-        const issues = validateRoleConfig(raw);
+        const normalizedRaw = normalizeRoleEffortCompat(raw);
+        const issues = validateRoleConfig(normalizedRaw);
         if (issues.length === 0) {
-            const { $schema_version: _schemaVersion, ...definition } = raw;
+            const { $schema_version: _schemaVersion, ...definition } = normalizedRaw;
             const expectedRank = expectedRoleRank(roleId);
             if (definition.rank !== undefined && definition.rank !== expectedRank) {
                 diagnostics.push({

package/dist/config-store.js

@@ -20,6 +20,7 @@ import path from 'path';
 import { resolvePaths, agentDir, } from './paths.js';
 import { atomicReadJson, atomicWriteJson } from './utils/atomic-write.js';
 import { checkAgentDir, isValidAid } from './aun/aid/validation.js';
+import { normalizeAidDomain } from './aun/aid/domain.js';
 import { isValidChannelName } from './core/channel-loader.js';
 import { CONFIG_SCHEMA_VERSION } from './types.js';
 import { ConfigTarget, read as cfgRead, write as cfgWrite } from './config/config-manager.js';
@@ -29,7 +30,7 @@ import { parseStableSemver } from './utils/stable-semver.js';
 /** 读 {root}/daemon.json。文件不存在返回 {}，不报错。 */
 export function loadDaemonConfig() {
     const raw = atomicReadJson(resolvePaths().daemonConfig);
-    return validateDaemonConfig(raw ?? {});
+    return validateDaemonConfig(raw ?? {}, false);
 }
 let eckSnapshotsConfigCache;
 /** Parse the process-level snapshot gate once for the current daemon lifecycle. */
@@ -50,9 +51,16 @@ export function isEckSnapshotsEnabled() {
 }
 /** 原子写入 {root}/daemon.json。调用方负责传完整对象（含要保留的字段）。 */
 export function saveDaemonConfig(value) {
-    atomicWriteJson(resolvePaths().daemonConfig, validateDaemonConfig(value));
+    const configPath = resolvePaths().daemonConfig;
+    const current = atomicReadJson(configPath);
+    // A legacy default is irrelevant while an existing control AID is retained.
+    // Validate the field when it is created or changed, but do not make unrelated
+    // daemon.json updates fail because of a persisted, unused legacy value.
+    const validateAidDomain = current === null
+        || current.aun?.defaultAidDomain !== value.aun?.defaultAidDomain;
+    atomicWriteJson(configPath, validateDaemonConfig(value, validateAidDomain));
 }
-function validateDaemonConfig(value) {
+function validateDaemonConfig(value, validateAidDomain) {
     const minEvolVersion = value.aun?.minEvolVersion;
     if (minEvolVersion !== undefined && !parseStableSemver(minEvolVersion)) {
         throw new Error('daemon.json.aun.minEvolVersion must use stable X.Y.Z format');
@@ -61,6 +69,14 @@ function validateDaemonConfig(value) {
     if (menuTokenRequired !== undefined && typeof menuTokenRequired !== 'boolean') {
         throw new Error('daemon.json.aun.menuTokenRequired must be a boolean');
     }
+    const defaultEncrypt = value.aun?.defaultEncrypt;
+    if (defaultEncrypt !== undefined && typeof defaultEncrypt !== 'boolean') {
+        throw new Error('daemon.json.aun.defaultEncrypt must be a boolean');
+    }
+    if (validateAidDomain && value.aun?.defaultAidDomain !== undefined) {
+        const defaultAidDomain = normalizeAidDomain(value.aun.defaultAidDomain, 'daemon.json.aun.defaultAidDomain');
+        return { ...value, aun: { ...value.aun, defaultAidDomain } };
+    }
     return value;
 }
 const SUPPORTED_CHANNEL_TYPES = new Set([

package/dist/core/auth/operation-authorizer.js

@@ -673,7 +673,9 @@ function parseLegacyChannelType(peerKey) {
 }
 function checkFieldOverride(ctx, field) {
     const roleDef = getRoleDefinition(ctx.role, ctx.selfAid);
-    const fieldPermission = roleDef?.permissions?.[field];
+    const fieldPermission = roleDef
+        ? resolveRoleFieldPermission(roleDef.permissions || {}, field)
+        : undefined;
     if (!fieldPermission) {
         return { ok: false, reason: `Role ${ctx.role} has no field permission for ${field}` };
     }

package/dist/core/baseagent-loader.js

@@ -20,16 +20,16 @@ export class AgentLoader {
      * Iterate over all EvolAgents in the registry × all registered plugins.
      * Each successful (agent, plugin) pair yields one runner instance.
      */
-    createAll(registry, callbacks) {
+    createAll(registry, callbacks, creationErrors) {
         const instances = [];
         const allAgents = registry.runnableAgents();
         for (const agent of allAgents) {
-            instances.push(...this.createForAgent(agent, callbacks));
+            instances.push(...this.createForAgent(agent, callbacks, creationErrors));
         }
         return instances;
     }
     /** Create runners for one EvolAgent, used by runtime hot-load. */
-    createForAgent(agent, callbacks) {
+    createForAgent(agent, callbacks, creationErrors) {
         const instances = [];
         for (const [pluginName, plugin] of this.plugins) {
             if (!plugin.isEnabled(agent)) {
@@ -46,6 +46,8 @@ export class AgentLoader {
                 logger.info(`✓ Runner created: agent=${instance.evolagentName} baseagent=${instance.baseagent}`);
             }
             catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                creationErrors?.push({ evolagentName: agent.name, baseagent: pluginName, message });
                 logger.error(`✗ Failed to create runner for agent='${agent.name}' baseagent='${pluginName}':`, error);
             }
         }

package/dist/core/bootstrap-service.js

@@ -74,7 +74,6 @@ export class BootstrapService {
                 agentName: aid,
             }), { kind: 'result.text', text, isFinal: true });
             this.eventBus.publish({ type: 'agent:bootstrap-started', aid, channel: channelType || ctx.channelKey, timestamp: Date.now() });
-            await this.sendAunBindingCredentialIfSupported(ctx.adapter, recipientId, agentName, baseagent);
             logger.info(`[Bootstrap] Started for ${aid} via ${ctx.channelKey} (${ctx.source})`);
             return true;
         }
@@ -154,15 +153,4 @@ export class BootstrapService {
             logger.warn(`[Bootstrap] Failed to publish agent.md for ${aid}: ${e instanceof Error ? e.message : String(e)}`);
         }
     }
-    async sendAunBindingCredentialIfSupported(adapter, owner, name, baseagent) {
-        const sendBinding = adapter._sendBindingCredential;
-        if (typeof sendBinding !== 'function')
-            return;
-        try {
-            await sendBinding(owner, name, baseagent);
-        }
-        catch (e) {
-            logger.warn(`[Bootstrap] Binding credential failed: ${e instanceof Error ? e.message : String(e)}`);
-        }
-    }
 }

package/dist/core/capability/providers/codex-capability-provider.js

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
-import { execFileSync } from 'child_process';
+import { execCodexCliSync } from '../../../utils/codex-cli.js';
 function listDirectories(dir) {
     try {
         if (!fs.existsSync(dir))
@@ -34,7 +34,7 @@ function discoverSkills(ctx) {
 }
 function runCodexJson(args) {
     try {
-        const output = execFileSync('codex', args, {
+        const output = execCodexCliSync(args, {
             encoding: 'utf-8',
             timeout: 3000,
             stdio: ['ignore', 'pipe', 'pipe'],

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.
@@ -61,6 +64,8 @@ export class ChannelLoader {
             aid: agent.aid,
             owner: agent.getOwner(aunEffName),
             enabled: true,
+            keystorePath: agent.config.aun?.keystorePath,
+            gatewayUrl: agent.config.aun?.gatewayUrl,
         };
         const configInsts = [aunInst];
         for (const inst of agent.config.channels) {
@@ -240,7 +245,14 @@ export function buildReloadHooks(deps) {
             const isImplicitAun = channelName === aunEffName;
             // Find config instance: implicit AUN gets a synthetic entry; others scan channels[].
             const cfgInst = isImplicitAun
-                ? { type: 'aun', name: aunEffName, aid, enabled: true }
+                ? {
+                    type: 'aun',
+                    name: aunEffName,
+                    aid,
+                    enabled: true,
+                    keystorePath: agent.config?.aun?.keystorePath,
+                    gatewayUrl: agent.config?.aun?.gatewayUrl,
+                }
                 : (() => {
                     const agentChannels = agent.config?.channels ?? [];
                     return agentChannels.find((i) => {
@@ -257,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() },
     };
 }