evolcore 0.0.6 → 0.0.8

package/dist/cli/restart-monitor.js

@@ -15,6 +15,7 @@ import { WEB_PACKAGE_NAME } from '../product.js';
 import { shouldSuppressRealRestart } from '../utils/restart-safety.js';
 import { rotateStdoutLog } from '../utils/log-writer.js';
 import { inspectDataMigrationRequirement } from '../core/data-migration.js';
+import { serviceProxyNeedsEcweb, startEcwebIfEnabled } from './daemon-commands.js';
 const execFileAsync = promisify(execFile);
 // 清理 Claude Code 环境变量，防止 SDK 认为是嵌套会话
 function cleanEnv() {
@@ -92,6 +93,37 @@ export async function cmdRestartMonitor() {
             await sleep(500);
         }
     }
+    // A stale instance record can disappear while the real Windows process is
+    // still alive. Refuse to create a second daemon when an unregistered process
+    // from this package is found; a duplicate would connect AUN and kick the
+    // existing session before failing on IPC/port ownership.
+    const runtimeOrphans = findOrphanProcesses().filter(o => {
+        if (o.confirmedTestDaemon)
+            return false;
+        const homeMatches = o.evolcoreHome && normalizePath(o.evolcoreHome) === normalizePath(p.root);
+        const packageMatches = !o.evolcoreHome && normalizePath(o.cmdline).includes(normalizePath(getPackageRoot()));
+        return Boolean(homeMatches || packageMatches);
+    });
+    if (runtimeOrphans.length > 0) {
+        const pids = runtimeOrphans.map(o => o.pid).join(', ');
+        log(`Stopping unregistered EvolCore process(es): ${pids}`);
+        for (const orphan of runtimeOrphans) {
+            platform.killProcess(orphan.pid, false);
+        }
+        const exited = await Promise.all(runtimeOrphans.map(async (orphan) => {
+            if (await platform.waitForProcessExit(orphan.pid, 10_000))
+                return true;
+            platform.killProcess(orphan.pid, true);
+            return platform.waitForProcessExit(orphan.pid, 5_000);
+        }));
+        if (exited.some(result => !result)) {
+            const message = `未登记的 EvolCore 进程仍未退出（PID: ${pids}），已停止重启以避免重复连接 AUN。`;
+            log(message);
+            await notifyDaemonOwners(p, `❌ ${message}`, log);
+            process.exit(1);
+        }
+        cleanupInstances();
+    }
     // restart-pending.json 只留给新主进程发送发起会话内的“重启成功”回执。
     const pendingFile = path.join(daemonControlDir(), 'restart-pending.json');
     // 等待所有活 main 进程退出（可能不止一个）
@@ -107,24 +139,24 @@ export async function cmdRestartMonitor() {
             }
             catch { }
         }
-        await Promise.all(oldPids.map(oldPid => new Promise((resolve) => {
-            let waited = 0;
-            const interval = setInterval(() => {
-                waited++;
-                if (!platform.isProcessRunning(oldPid)) {
-                    clearInterval(interval);
-                    log(`Process ${oldPid} has exited`);
-                    resolve();
-                    return;
-                }
-                if (waited >= 30) {
-                    clearInterval(interval);
-                    log(`ERROR: Process ${oldPid} still running after 30s, force killing`);
-                    platform.killProcess(oldPid, true);
-                    resolve();
-                }
-            }, 1000);
-        })));
+        const exited = await Promise.all(oldPids.map(async (oldPid) => {
+            if (await platform.waitForProcessExit(oldPid, 30_000)) {
+                log(`Process ${oldPid} has exited`);
+                return true;
+            }
+            log(`ERROR: Process ${oldPid} still running after 30s, force killing`);
+            platform.killProcess(oldPid, true);
+            const forced = await platform.waitForProcessExit(oldPid, 5_000);
+            if (!forced)
+                log(`ERROR: Process ${oldPid} survived forced termination`);
+            return forced;
+        }));
+        if (exited.some(result => !result)) {
+            log('❌ Existing daemon process could not be stopped; refusing to spawn a replacement');
+            await notifyDaemonOwners(p, '❌ 旧 EvolCore 进程未能退出，已停止重启，避免重复连接 AUN。', log);
+            cleanupPendingFile(pendingFile, log);
+            process.exit(1);
+        }
         await sleep(3000);
         cleanupInstances();
     }
@@ -177,9 +209,22 @@ export async function cmdRestartMonitor() {
             await notifyDaemonOwners(p, `⚠️ ${WEB_PACKAGE_NAME} 升级失败，使用当前版本继续\n${ecwebUpgrade.error ?? ''}`.trim(), log);
             break;
     }
+    // source=ecweb 的 Service Proxy 只在 daemon 启动后的短窗口内发现实例。
+    // restart-monitor 直接 spawn daemon，必须在此先启动独立的 ec-web，不能绕过
+    // cmdStart 的 ECWeb 生命周期逻辑。
+    const ecwebStartedBeforeDaemon = serviceProxyNeedsEcweb(loadDaemonConfig())
+        ? await startEcwebIfEnabled(p)
+        : false;
+    if (ecwebStartedBeforeDaemon)
+        log('ECWeb started before daemon');
     // 启动并检测 ready signal
     let started = await spawnAndWaitReady(p, log, READY_TIMEOUT);
     if (started) {
+        // 没有 Service Proxy 时可以等 daemon ready 后再启动；有代理时已在上方启动，
+        // 避免重新拉起造成实例记录和反向隧道短暂失配。
+        if (!ecwebStartedBeforeDaemon && await startEcwebIfEnabled(p)) {
+            log('ECWeb started after daemon');
+        }
         log('✓ Service restarted successfully');
         archiveSelfHealLog(p, log);
         // 发起会话内的“重启成功”通知由新进程自行发送，此处只负责失败/自愈告警。
@@ -192,10 +237,25 @@ export async function cmdRestartMonitor() {
         cleanupPendingFile(pendingFile, log);
         process.exit(1);
     }
+    if (hasStartupResourceConflict(p)) {
+        const message = '服务启动失败：IPC 管道或端口仍被占用，已跳过自动修复，避免重复连接 AUN。';
+        log(message);
+        await notifyDaemonOwners(p, `❌ ${message}`, log);
+        cleanupPendingFile(pendingFile, log);
+        process.exit(1);
+    }
     // 启动失败，进入 self-heal 循环
     log('❌ Service failed to start, entering self-heal loop');
     eventBus.publish({ type: 'self-heal:started', reason: 'Service failed to start after restart' });
     await notifyDaemonOwners(p, '⚠️ 服务启动失败，正在尝试自动修复...', log);
+    const claudePath = platform.resolveCommandPath('claude');
+    if (!claudePath) {
+        const message = '找不到 claude CLI，已停止自动修复；请检查后台进程 PATH。';
+        log(message);
+        await notifyDaemonOwners(p, `❌ ${message}`, log);
+        cleanupPendingFile(pendingFile, log);
+        process.exit(1);
+    }
     for (let attempt = 1; attempt <= MAX_HEAL_ATTEMPTS; attempt++) {
         // 前置检查：服务可能已被上一轮 claude 修复并启动
         if (isServiceAlive()) {
@@ -209,7 +269,7 @@ export async function cmdRestartMonitor() {
         log(`Self-heal attempt ${attempt}/${MAX_HEAL_ATTEMPTS}`);
         eventBus.publish({ type: 'self-heal:attempt', attemptNumber: attempt, maxAttempts: MAX_HEAL_ATTEMPTS });
         await notifyDaemonOwners(p, `🔧 自动修复中（第 ${attempt}/${MAX_HEAL_ATTEMPTS} 次）...`, log);
-        const healed = await invokeClaude(p, attempt, MAX_HEAL_ATTEMPTS, HEAL_TIMEOUT, log);
+        const healed = await invokeClaude(claudePath, p, attempt, MAX_HEAL_ATTEMPTS, HEAL_TIMEOUT, log);
         // 后置检查：不管 invokeClaude 返回什么，都检查服务实际状态
         if (isServiceAlive()) {
             log(`✓ Service is running after attempt ${attempt}`);
@@ -276,6 +336,30 @@ async function sendHealSummary(p, attempts, log) {
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
+function normalizePath(value) {
+    return value.replace(/[\\/]+/g, '/').toLowerCase();
+}
+function hasStartupResourceConflict(p) {
+    let daemonLog = null;
+    try {
+        daemonLog = fs.readdirSync(p.logs, { withFileTypes: true })
+            .filter(entry => entry.isFile() && /^daemon-.*\.log$/.test(entry.name))
+            .sort((a, b) => b.name.localeCompare(a.name))
+            .slice(0, 1)
+            .map(entry => path.join(p.logs, entry.name))[0] ?? null;
+    }
+    catch { }
+    const files = [path.join(p.logs, 'stdout.log'), ...(daemonLog ? [daemonLog] : [])];
+    return files.some(file => {
+        try {
+            const content = fs.readFileSync(file, 'utf-8');
+            return /EADDRINUSE|address already in use|pipe-.*already in use/i.test(content.slice(-64 * 1024));
+        }
+        catch {
+            return false;
+        }
+    });
+}
 function cleanupPendingFile(filePath, log) {
     try {
         if (fs.existsSync(filePath)) {
@@ -339,9 +423,17 @@ async function spawnAndWaitReady(p, log, timeout) {
         }
     }
     log(`Ready signal not received within ${timeout / 1000}s`);
-    // 超时后杀掉进程
+    // A timeout is still a live-process race: do not let self-heal spawn a
+    // replacement while the timed-out daemon owns the IPC endpoint or a port.
     if (platform.isProcessRunning(childPid)) {
         platform.killProcess(childPid);
+        if (!await platform.waitForProcessExit(childPid, 5_000)) {
+            log(`Process ${childPid} survived graceful termination, forcing kill`);
+            platform.killProcess(childPid, true);
+            if (!await platform.waitForProcessExit(childPid, 5_000)) {
+                log(`ERROR: Process ${childPid} survived forced termination`);
+            }
+        }
     }
     cleanupInstances();
     return false;
@@ -349,7 +441,7 @@ async function spawnAndWaitReady(p, log, timeout) {
 /**
  * 调用 claude CLI 进行自动修复
  */
-async function invokeClaude(p, attempt, maxAttempts, timeout, log) {
+async function invokeClaude(claudePath, p, attempt, maxAttempts, timeout, log) {
     const projectDir = getPackageRoot();
     const selfHealLog = p.selfHealLog;
     const stdoutLog = path.join(p.logs, 'stdout.log');
@@ -387,7 +479,7 @@ async function invokeClaude(p, attempt, maxAttempts, timeout, log) {
 注意：只修复导致启动失败的问题，不要做额外的重构或优化。`;
     try {
         log(`Invoking claude CLI (attempt ${attempt}, timeout ${timeout / 60000}min)...`);
-        const { stdout, stderr } = await execFileAsync('claude', [
+        const { stdout, stderr } = await execFileAsync(claudePath, [
             '-p', prompt,
             '--allowedTools', 'Read,Write,Edit,Bash,Glob,Grep',
             '--output-format', 'text',
@@ -395,6 +487,8 @@ async function invokeClaude(p, attempt, maxAttempts, timeout, log) {
         ], {
             cwd: projectDir,
             timeout,
+            // Windows npm CLIs are .cmd shims; execFile needs a shell to run them.
+            shell: platform.isWindows,
             env: { ...process.env, CLAUDE_CODE_ENTRYPOINT: 'cli' },
             maxBuffer: 10 * 1024 * 1024,
         });

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';
@@ -571,6 +572,20 @@ 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 };
     normalizeShowActivitiesCompat(mutable);
@@ -643,7 +658,9 @@ export function write(target, value, sel, opts = {}) {
         ? normalizeAgentConfigForWrite(migrated)
         : target === ConfigTarget.Relation
             ? normalizeRelationConfigForWrite(migrated)
-            : migrated;
+            : target === ConfigTarget.Process
+                ? normalizeProcessConfigForWrite(migrated)
+                : migrated;
     // 1. Schema 校验
     if (!opts.skipValidate) {
         validateOrThrow(schema, normalized, target);
@@ -836,7 +853,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,
@@ -857,6 +874,20 @@ function validateProcessOnlyFields(target, value) {
         return [];
     return ['/debug is only allowed in process config'];
 }
+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 [];
+    }
+    catch (error) {
+        return [`/aun/defaultAidDomain ${error instanceof Error ? error.message : String(error)}`];
+    }
+}
 /**
  * responseModeParams 桶专项校验。
  *
@@ -908,7 +939,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-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,10 @@ function validateDaemonConfig(value) {
     if (menuTokenRequired !== undefined && typeof menuTokenRequired !== 'boolean') {
         throw new Error('daemon.json.aun.menuTokenRequired 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/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/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

@@ -61,6 +61,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 +242,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) => {

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

@@ -4,6 +4,7 @@ import { modelMatches } from '../model/model-catalog.js';
 import { constrainResolvedModelForRole, filterModelsForRole, validateModelSelectionForRole } from '../model/model-permission.js';
 import { hasModelSwitcher } from '../../agents/runner-types.js';
 import { getCodexEfforts } from '../../agents/codex-runner.js';
+import { execCodexCliSync, resolveCodexCliPath } from '../../utils/codex-cli.js';
 import { resolvePaths, getPackageRoot, daemonControlDir } from '../../paths.js';
 import { buildEnvelope } from '../message/message-utils.js';
 import path from 'path';
@@ -45,15 +46,25 @@ import { groupMenuAuthorizationArgs, groupMenuIntent, handleGroupMenu, } from '.
  */
 function getBaseagentVersion(cmd) {
     try {
-        const output = execFileSync(cmd, ['--version'], {
-            encoding: 'utf-8',
-            timeout: 3000,
-            stdio: ['ignore', 'pipe', 'pipe'],
-        }).trim();
+        const executable = cmd === 'codex' ? resolveCodexCliPath() : cmd;
+        if (!executable)
+            return null;
+        const output = cmd === 'codex'
+            ? execCodexCliSync(['--version'], {
+                encoding: 'utf-8',
+                timeout: 3000,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            })
+            : execFileSync(executable, ['--version'], {
+                encoding: 'utf-8',
+                timeout: 3000,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+        const versionOutput = String(output).trim();
         // claude: "2.1.187 (Claude Code)" → 提取 "2.1.187"
         // gemini: "0.38.0" → 直接返回
         // codex: "codex-cli 0.142.0" → 提取 "0.142.0"
-        const match = output.match(/(\d+\.\d+\.\d+)/);
+        const match = versionOutput.match(/(\d+\.\d+\.\d+)/);
         return match ? match[1] : null;
     }
     catch {