evolcore 0.0.1 → 0.0.3

package/dist/index.js

@@ -1,6 +1,2928 @@
+// 【重要】最先加载环境变量，确保后续模块初始化时可用
+import dotenv from 'dotenv';
+import path from 'path';
+import { ensureDataDirs, resolvePaths, getPackageRoot, agentMdPath, eckDebugDir } from './paths.js';
+// 立即加载 .env 文件（在其他模块导入之前）
+try {
+    dotenv.config({ path: path.join(resolvePaths().root, '.env') });
+}
+catch {
+    // 首次运行时 .env 可能不存在，忽略错误
+}
+import { ClaudeSessionFileAdapter } from './core/session/adapters/claude-session-file-adapter.js';
+import { CodexSessionFileAdapter } from './core/session/adapters/codex-session-file-adapter.js';
+import { GeminiSessionFileAdapter } from './core/session/adapters/gemini-session-file-adapter.js';
+import { loadDefaults, loadAllAgents, migrateIdentitiesIfNeeded, loadDaemonConfig, initializeEckSnapshotsConfig } from './config-store.js';
+import { ConfigTarget, initConfigManager, onConfigWrite } from './config/config-manager.js';
+import { ensureRoleConfigV4OnStartup } from './config/role-config-v4-startup.js';
+import { ensureRoleConfigV5OnStartup } from './config/role-config-v5-startup.js';
+import { ensureContactBookV2OnStartup } from './config/contact-book-v2-startup.js';
+import { shouldFailFastForMissingOwners } from './config/owner-policy.js';
+import { isManagementRole } from './config/builtin-roles.js';
+import { checkRoleAccess, getFirstStaticAgentOwner, resolvePeerRoleDetail, roleToSessionIdentity } from './config/peer-role-resolver.js';
+import { ensureStartupConfigSnapshot, isConfigSnapshotsEnabled, retentionCleanup, readCurrent, readWVersion, diffWorkingVsVersion, paramDiff, incrementSuccessCount } from './config/snapshot.js';
+import { appendBootLog, selfDiagnose } from './config/boot-log.js';
+import { CONFIG_SCHEMA_VERSION } from './types.js';
+import { SessionManager } from './core/session/session-manager.js';
+import { ClaudeAgentPlugin } from './agents/claude-runner.js';
+import { CodexAgentPlugin } from './agents/codex-runner.js';
+import { GeminiAgentPlugin } from './agents/gemini-runner.js';
+import { FeishuChannelPlugin } from './channels/feishu.js';
+import { WechatChannelPlugin } from './channels/wechat.js';
+import { AUN_HANDOFF_MARKER_FIELD, AUNChannel, AUNChannelPlugin } from './channels/aun.js';
+import { startServiceProxy } from './aun/service-proxy.js';
+import { BindService } from './utils/aid-bind.js';
+import { DingtalkChannelPlugin, registerPendingDingtalkContactBind } from './channels/dingtalk.js';
+import { QQBotChannelPlugin } from './channels/qqbot.js';
+import { WecomChannelPlugin, registerPendingWecomContactBind } from './channels/wecom.js';
+import { buildEnvelope } from './core/message/message-utils.js';
+import { ResponseEngine } from './core/message/response-engine.js';
+import { MessageQueue } from './core/message/message-queue.js';
+import { MessageBridge } from './core/message/message-bridge.js';
+import { MenuRequestDeduper, hasValidMenuId, menuFailure, menuPayloadFingerprint, parseMenuControl, validateMenuRequest } from './core/command/menu-protocol.js';
+import { recoverAllRoleMutationsSync } from './core/command/role-menu.js';
+import { HandoffRuntime } from './core/handoff/runtime.js';
+import { BootstrapService } from './core/bootstrap-service.js';
+import { MessageCache } from './core/message/message-cache.js';
+import { CommandHandler, isProcessLevelOwner } from './core/command/command-handler.js';
+import { EventBus } from './core/event-bus.js';
+import { getEventCatalog } from './core/event-catalog.js';
+import { StatsCollector } from './utils/stats.js';
+import { AidStatsCollector } from './utils/stats.js';
+import { PermissionGateway } from './core/permission/approval-gateway.js';
+import { InteractionRouter } from './core/interaction-router.js';
+import { registerAdapterInteractions } from './core/interaction-registration.js';
+import { AgentDelegationRegistry, authorizeDelegatedAunMsgSend } from './core/auth/agent-delegation.js';
+import { authorizeOperation, buildAuthSubject } from './core/auth/auth-gateway.js';
+import { isHClassPath } from './core/protected-paths.js';
+import { ChannelLoader, tryParseChannelKey } from './core/channel-loader.js';
+import { AgentLoader } from './core/baseagent-loader.js';
+import { EvolAgentRegistry } from './core/evolagent-registry.js';
+import { buildReloadHooks } from './core/channel-loader.js';
+import { IpcServer } from './ipc.js';
+import { logger, setLogLevel } from './utils/logger.js';
+import { fetchEcwebPairCode } from './utils/ecweb-utils.js';
+import { writeMain, removeAll, isMainWinner, scanInstances } from './utils/instance-registry.js';
+import { detectDuplicates } from './core/evolagent-registry.js';
+import { loadKitManifest, cleanEckDebug, invalidateKitCache } from './eck/kit-renderer.js';
+import { initEck } from './eck/init.js';
+import { TriggerDefinitionManager } from './trigger/manager.js';
+import { TriggerRunStateStore } from './trigger/state.js';
+import { TriggerAuditLogger } from './trigger/audit.js';
+import { TriggerScriptExecutor } from './trigger/script-executor.js';
+import { TriggerFeedbackDispatcher } from './trigger/feedback.js';
+import { TriggerRuntimeScheduler } from './trigger/scheduler.js';
+import { DaemonChannel } from './channels/daemon.js';
+import { definitionRevision, normalizeTriggerDefinition } from './trigger/validation.js';
+import { applyTriggerPatch } from './trigger/patch.js';
+import { validateModelSelectionForRole } from './core/model/model-permission.js';
+import { constrainRuntimePermissionMode, validateRuntimeStringFieldOverride, } from './core/role/runtime-policy.js';
+import { atomicWriteJson } from './core/session/session-fs-store.js';
+import { cleanupLegacySystemControlSessions } from './core/system-channels.js';
+import { appendMessageLog, buildOutboundEntry, classifyAunPayloadForLog } from './core/message/message-log.js';
+import fs from 'fs';
+import crypto from 'crypto';
+import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+import * as platform from './utils/cross-platform.js';
+const controlMenuDeduper = new MenuRequestDeduper();
+/** 出站 payload 摘要（用于 channel-out.log） */
+function summarizeOutboundPayload(payload) {
+    if (!payload)
+        return { kind: 'unknown' };
+    const s = { kind: payload.kind };
+    switch (payload.kind) {
+        case 'activity.batch':
+            s.itemCount = payload.items?.length ?? 0;
+            s.items = payload.items;
+            break;
+        case 'result.text':
+            s.isFinal = payload.isFinal;
+            s.text = payload.text;
+            break;
+        case 'command.result':
+        case 'command.error':
+        case 'result.error':
+            s.text = payload.text;
+            break;
+        case 'result.file':
+            s.filePath = payload.filePath;
+            break;
+        case 'system.notice':
+        case 'system.error':
+            s.subtype = payload.subtype;
+            s.text = payload.text;
+            break;
+        case 'interaction':
+            s.interactionId = payload.interaction?.id;
+            s.interactionKind = payload.interaction?.kind?.kind;
+            break;
+        case 'status.started':
+        case 'status.progress':
+        case 'status.requires_action':
+        case 'status.queued':
+        case 'status.completed':
+        case 'status.interrupted':
+        case 'status.error':
+        case 'status.timeout':
+            s.metadata = payload.metadata;
+            break;
+    }
+    return s;
+}
+function shouldCountSentPayload(payload) {
+    return [
+        'result.text',
+        'result.file',
+        'result.image',
+        'result.error',
+        'command.result',
+        'command.error',
+        'interaction',
+    ].includes(payload.kind);
+}
+function outboundPayloadToLogText(payload) {
+    switch (payload.kind) {
+        case 'result.text':
+        case 'command.result':
+        case 'command.error':
+        case 'result.error':
+            return { text: payload.text, msgType: 'text' };
+        case 'result.file':
+            return { text: payload.fileName || payload.filePath, msgType: 'file' };
+        case 'result.image':
+            return { text: payload.alt || '[image]', msgType: 'image' };
+        case 'interaction':
+            return { text: payload.fallbackText || '[interaction]', msgType: 'text' };
+        default:
+            return null;
+    }
+}
+function normalizeMessageSource(value) {
+    return value === 'cli' || value === 'msg' || value === 'ctl' || value === 'owner-inject'
+        ? value
+        : 'daemon';
+}
+function daemonConversationWatchdogMs(settings) {
+    const idleTimeoutSec = settings.idleMonitor?.timeout;
+    const idleMs = typeof idleTimeoutSec === 'number' && Number.isFinite(idleTimeoutSec) && idleTimeoutSec > 0
+        ? idleTimeoutSec * 1000
+        : 120_000;
+    return Math.ceil(idleMs * 5 + 60_000);
+}
+function daemonConversationTotalExecutionMs(settings) {
+    const seconds = settings.idleMonitor?.maxExecutionTime;
+    return typeof seconds === 'number' && Number.isFinite(seconds) && seconds > 0
+        ? seconds * 1000
+        : 60 * 60 * 1000;
+}
+function originFromActorSession(session, authenticatedPeerId, authenticatedChannelKey, authenticatedChatType) {
+    const peerId = authenticatedPeerId || session.metadata?.peerId;
+    if (!peerId)
+        return undefined;
+    const sessionChannelKey = session.metadata?.channelKey || session.channel;
+    const channelKey = authenticatedChannelKey || sessionChannelKey;
+    const sameConversation = channelKey === sessionChannelKey;
+    const isGroup = authenticatedChatType === 'group' || session.chatType === 'group';
+    return {
+        channelKey,
+        channelType: session.channelType || tryParseChannelKey(channelKey)?.type || channelKey,
+        channelId: peerId,
+        session: sameConversation && !isGroup && session.threadId ? 'thread' : 'main',
+        threadId: sameConversation && !isGroup ? (session.threadId || undefined) : undefined,
+        peerId,
+        sessionKey: sameConversation && !isGroup ? session.sessionKey : undefined,
+    };
+}
+function seedUpgradeCheckTrigger(manager, owner) {
+    const now = Date.now();
+    const scriptName = 'upgrade-check.sh';
+    const definition = normalizeTriggerDefinition({
+        $schema_version: 3.1,
+        id: '__upgrade-check',
+        agentAid: owner.aid,
+        enabled: true,
+        name: '__upgrade-check',
+        description: 'System trigger: check EvolCore upgrades after install or upgrade.',
+        createdAt: now,
+        updatedAt: now,
+        origin: {
+            channelKey: 'daemon',
+            channelType: 'daemon',
+            channelId: owner.originPeerId || owner.aid,
+            session: 'main',
+            peerId: owner.originPeerId || owner.aid,
+            sessionKey: `daemon#${owner.originPeerId || owner.aid}#__system__`,
+        },
+        source: {
+            type: 'cron',
+            expression: '59 3 * * *',
+            timezone: 'Asia/Shanghai',
+        },
+        execution: {
+            type: 'script',
+            script: {
+                path: scriptName,
+                runtime: 'bash',
+                timeoutMs: 60_000,
+            },
+            permissionMode: 'bypass',
+            onError: 'fail',
+            noopSentinel: '[[NOOP]]',
+        },
+        feedback: {
+            strategy: 'silent',
+        },
+        reliability: {
+            concurrency: 'forbid',
+            missedPolicy: 'run_once',
+            retry: {
+                maxAttempts: 0,
+                backoffMs: 30_000,
+            },
+        },
+    });
+    const dir = manager.triggerDir(definition.id);
+    fs.mkdirSync(dir, { recursive: true });
+    const scriptPath = path.join(dir, scriptName);
+    const packageRoot = getPackageRoot();
+    const cliPath = path.join(packageRoot, 'dist', 'cli', 'index.js');
+    const packageJsonPath = path.join(packageRoot, 'package.json');
+    const devMode = fs.existsSync(path.join(packageRoot, 'src', 'index.ts'));
+    fs.writeFileSync(scriptPath, [
+        '#!/usr/bin/env bash',
+        'set -euo pipefail',
+        '',
+        `CLI_PATH=${JSON.stringify(cliPath)}`,
+        `PACKAGE_JSON=${JSON.stringify(packageJsonPath)}`,
+        `DEV_MODE=${devMode ? '1' : '0'}`,
+        '',
+        'json() {',
+        '  local outcome="$1"',
+        '  local text="$2"',
+        '  node -e \'console.log(JSON.stringify({ outcome: process.argv[1], text: process.argv[2], files: [] }))\' "$outcome" "$text"',
+        '}',
+        '',
+        'if [ "$DEV_MODE" = "1" ]; then',
+        '  json "noop" "upgrade check skipped in dev mode"',
+        '  exit 0',
+        'fi',
+        '',
+        'local_version="$(node -e \'try { console.log(require(process.argv[1]).version || "") } catch { process.exit(0) }\' "$PACKAGE_JSON")"',
+        'remote_version="$(npm view ec version 2>/dev/null || true)"',
+        '',
+        'if [ -z "$remote_version" ]; then',
+        '  json "error" "failed to check evolcore latest version"',
+        '  exit 0',
+        'fi',
+        '',
+        'if [ -z "$local_version" ]; then',
+        '  json "error" "failed to read local ec version"',
+        '  exit 0',
+        'fi',
+        '',
+        'version_cmp="$(node -e \'',
+        'const [a, b] = process.argv.slice(1);',
+        'const pa = a.split("-")[0].split(".").map(Number);',
+        'const pb = b.split("-")[0].split(".").map(Number);',
+        'const n = Math.max(pa.length, pb.length);',
+        'let out = 0;',
+        'for (let i = 0; i < n; i++) {',
+        '  const av = Number.isFinite(pa[i]) ? pa[i] : 0;',
+        '  const bv = Number.isFinite(pb[i]) ? pb[i] : 0;',
+        '  if (av < bv) { out = -1; break; }',
+        '  if (av > bv) { out = 1; break; }',
+        '}',
+        'console.log(out);',
+        '\' "$local_version" "$remote_version")"',
+        '',
+        'if [ "$version_cmp" != "-1" ]; then',
+        '  json "noop" "evolcore is already up to date ($local_version; latest $remote_version)"',
+        '  exit 0',
+        'fi',
+        '',
+        'if [ ! -f "$CLI_PATH" ]; then',
+        '  json "error" "restart-monitor entry not found: $CLI_PATH"',
+        '  exit 0',
+        'fi',
+        '',
+        'nohup node "$CLI_PATH" restart-monitor >/dev/null 2>&1 &',
+        'json "success" "evolcore upgrade available: ${local_version:-unknown} -> $remote_version; restart-monitor started"',
+        '',
+    ].join('\n'));
+    fs.chmodSync(scriptPath, 0o755);
+    atomicWriteJson(manager.definitionPath(definition.id), definition);
+    fs.rmSync(manager.activePath(definition.id), { force: true });
+}
+function removeLegacyAgentUpgradeCheck(manager) {
+    let existing;
+    try {
+        existing = manager.get('__upgrade-check');
+    }
+    catch {
+        fs.rmSync(manager.triggerDir('__upgrade-check'), { recursive: true, force: true });
+        return;
+    }
+    if (!existing)
+        return;
+    const isLegacySystemOrigin = existing.origin?.channelKey === '__system__' || existing.origin?.channelKey === 'daemon';
+    const isUpgradeScript = existing.execution.type === 'script'
+        && existing.execution.script?.path === 'upgrade-check.sh';
+    if (!isLegacySystemOrigin || !isUpgradeScript)
+        return;
+    fs.rmSync(manager.triggerDir('__upgrade-check'), { recursive: true, force: true });
+}
 /**
- * EvolCore - Core utilities and abstractions for EvolClaw ecosystem
- * @module evolcore
+ * 通过 adapter.send 发送系统类 payload（system.notice / system.error / 等）。
+ *
+ * 网关层（本文件）的所有出站系统通知（上线 / 重启完成 / 渠道告警 / agent 启动失败等）
+ * 走这里集中调度，让渠道按 capabilities 决定呈现方式。
+ *
+ * 当 adapter 还没实现 send（旧 adapter）时，按 payload.kind 降级到 sendText。
+ *
+ * Exported for unit test coverage; runtime callers are inside main() closure.
  */
-export const version = '0.0.1';
-//# sourceMappingURL=index.js.map
+export async function sendSystemPayload(adapter, envelope, payload) {
+    await adapter.send(envelope, payload);
+}
+async function runBindBootstrapDaemon(daemonCfg, defaults) {
+    logger.warn('[bind-bootstrap] starting control AID + IPC only');
+    const bindService = new BindService({
+        receiverAid: daemonCfg.aid,
+        getAvailableBaseagents: detectAvailableBaseagentsForBind,
+        getUptimeSeconds: () => Math.floor(process.uptime()),
+    });
+    bindService.startCleanup();
+    let controlChannel;
+    controlChannel = new AUNChannel({
+        aid: daemonCfg.aid,
+        agentName: daemonCfg.aid,
+        channelName: 'control',
+        pureIdentity: true,
+        aunTrace: daemonCfg.debug?.aunTrace ?? defaults.debug?.aunTrace,
+        aunSdkLog: daemonCfg.debug?.aunSdkLog ?? defaults.debug?.aunSdkLog,
+    });
+    try {
+        await controlChannel.connect();
+        logger.info(`✓ 控制 AID 已连接: ${daemonCfg.aid}`);
+    }
+    catch (e) {
+        logger.warn(`控制 AID 首连失败（后台自动重连，不影响 bootstrap IPC）: ${e?.message || e}`);
+    }
+    controlChannel.onMessage(async (opts) => {
+        const text = (opts.content || '').trim();
+        let parsed = null;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            parsed = null;
+        }
+        const response = parsed ? await bindService.handleRequest(parsed, opts.peerId) : null;
+        if (response) {
+            await controlChannel.sendMessage(opts.channelId, JSON.stringify(response));
+        }
+    });
+    const ipcServer = new IpcServer(resolvePaths().socket, () => ({
+        pid: process.pid,
+        uptime: Math.round(process.uptime() * 1000),
+        channels: {},
+        channelsByType: {},
+        queue: { pending: 0, processing: 0 },
+        controlAid: { aid: daemonCfg.aid, connected: controlChannel?.getAidState().status === 'connected' },
+    }));
+    ipcServer.setBindExecutor({
+        begin: (cmd) => bindService.begin(cmd),
+        status: (taskId) => bindService.status(taskId),
+        cancel: (taskId) => bindService.cancel(taskId),
+    });
+    await ipcServer.start();
+    fs.writeFileSync(resolvePaths().readySignal, String(Date.now()));
+    logger.info(`✓ Bind bootstrap ready signal written: ${resolvePaths().readySignal}`);
+    const shutdown = async (signal) => {
+        logger.info(`[bind-bootstrap] shutting down${signal ? ` (${signal})` : ''}`);
+        ipcServer.stop();
+        bindService.stopCleanup();
+        if (controlChannel) {
+            try {
+                await controlChannel.disconnect();
+            }
+            catch { /* ignore */ }
+        }
+        removeAll();
+        process.exit(0);
+    };
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    process.on('exit', () => removeAll());
+}
+export function readEvolcoreVersion() {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(getPackageRoot(), 'package.json'), 'utf-8'));
+        return pkg.version || 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function detectAvailableBaseagentsForBind() {
+    const out = [];
+    for (const cmd of ['claude', 'gemini', 'codex']) {
+        if (commandExists(cmd))
+            out.push(cmd);
+    }
+    return out;
+}
+/**
+ * 启动失败时分类打印（不交互、不自动回落，只给准确提示）。
+ * 分类：W 解析失败 / W 有未存改动(param diff) / W==w-version(版本自身坏) → 建议自检命令。
+ */
+function printConfigFailure(skipped) {
+    const root = resolvePaths().root;
+    const agentsDir = path.join(root, 'agents');
+    const lines = ['❌ 启动失败：无法加载任何 self-agent 配置。'];
+    // 先检查是否有解析错误（语法级失败）
+    const parseErrors = [];
+    if (fs.existsSync(agentsDir)) {
+        for (const entry of fs.readdirSync(agentsDir, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const cfgPath = path.join(agentsDir, entry.name, 'config.json');
+            if (!fs.existsSync(cfgPath))
+                continue;
+            try {
+                JSON.parse(fs.readFileSync(cfgPath, 'utf-8'));
+            }
+            catch (e) {
+                parseErrors.push(`  agents/${entry.name}/config.json 无法解析: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+    }
+    if (parseErrors.length > 0) {
+        lines.push('配置文件语法错误：');
+        lines.push(...parseErrors);
+        const wv = readWVersion();
+        if (wv)
+            lines.push(`  回退到上一版本: ec config restore ${wv.delta}`);
+    }
+    else {
+        // 检查 W vs w-version
+        const wv = readWVersion();
+        if (wv) {
+            const diff = diffWorkingVsVersion(wv.delta);
+            if (!('error' in diff) && (diff.modified.length + diff.added.length + diff.deleted.length > 0)) {
+                lines.push(`当前参数与版本 ${wv.delta} 存在差异（可能是失败原因）：`);
+                const pdiff = paramDiff(wv.delta);
+                if (!('error' in pdiff)) {
+                    for (const fd of pdiff) {
+                        for (const c of fd.changes) {
+                            lines.push(`  ${fd.file}: ${c.path}: ${JSON.stringify(c.before)} → ${JSON.stringify(c.after)}`);
+                        }
+                    }
+                }
+                lines.push(`  回退: ec config restore ${wv.delta}`);
+            }
+            else {
+                // W == w-version，版本自身有问题
+                lines.push('当前配置版本无法加载。');
+                lines.push('  用自检模式逐版本回落: ec start --diagnose  或  ec restart --diagnose');
+            }
+        }
+        else {
+            lines.push('No self-agent configured. Run `ec aid new <name>` to create one.');
+        }
+        if (skipped.length > 0) {
+            lines.push(`  跳过的目录 (${skipped.length}):`);
+            for (const s of skipped)
+                lines.push(`    - ${s.dirName}: ${s.reason}`);
+        }
+    }
+    const msg = lines.join('\n');
+    logger.error(msg);
+    console.error(msg);
+}
+function readFastaunVersion() {
+    try {
+        const url = import.meta.resolve?.('@agentunion/fastaun');
+        if (!url)
+            return 'unknown';
+        let dir = path.dirname(fileURLToPath(url));
+        while (dir !== path.dirname(dir)) {
+            const pkgPath = path.join(dir, 'package.json');
+            if (fs.existsSync(pkgPath)) {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                if (pkg.name === '@agentunion/fastaun')
+                    return pkg.version || 'unknown';
+            }
+            dir = path.dirname(dir);
+        }
+        return 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+async function main() {
+    // 启动信息：目录类型 + 版本号 + 代码最新时间戳
+    {
+        const pkgRoot = getPackageRoot();
+        const runDir = path.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/, '$1'));
+        const isDist = runDir.includes(path.join(pkgRoot, 'dist'));
+        const isLinked = fs.existsSync(path.join(pkgRoot, '.git'));
+        const dirType = isDist ? (isLinked ? '开发仓/dist' : '安装路径/dist') : '源码(tsx)';
+        const scanDir = isDist ? path.join(pkgRoot, 'dist') : path.join(pkgRoot, 'src');
+        let latestMtime = 0;
+        const scanRecursive = (dir) => {
+            try {
+                for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+                    if (entry.name === 'node_modules')
+                        continue;
+                    const full = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        scanRecursive(full);
+                        continue;
+                    }
+                    if (entry.name.endsWith('.js') || entry.name.endsWith('.ts')) {
+                        const mt = fs.statSync(full).mtimeMs;
+                        if (mt > latestMtime)
+                            latestMtime = mt;
+                    }
+                }
+            }
+            catch { }
+        };
+        scanRecursive(scanDir);
+        let version = '?';
+        try {
+            version = JSON.parse(fs.readFileSync(path.join(pkgRoot, 'package.json'), 'utf-8')).version;
+        }
+        catch { }
+        const fmtTime = (ms) => { const d = new Date(ms); return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')} ${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}:${String(d.getSeconds()).padStart(2, '0')}`; };
+        console.error(`[EvolCore] EvolCore v${version}`);
+        console.error(`[EvolCore] 执行类型: ${dirType}`);
+        console.error(`[EvolCore] 包路径:   ${pkgRoot}`);
+        console.error(`[EvolCore] 代码时间: ${latestMtime ? fmtTime(latestMtime) : '?'}`);
+    }
+    // 过滤飞书 SDK 的 info 日志
+    const originalLog = console.log;
+    const originalInfo = console.info;
+    const filter = (...args) => {
+        const firstArg = String(args[0] || '');
+        return firstArg.includes('[info]') || firstArg.includes('[ws]');
+    };
+    console.log = (...args) => {
+        if (filter(...args))
+            return;
+        originalLog(...args);
+    };
+    console.info = (...args) => {
+        if (filter(...args))
+            return;
+        originalInfo(...args);
+    };
+    logger.info(`EvolCore v${readEvolcoreVersion()} starting... (fastaun v${readFastaunVersion()})`);
+    // 确保数据目录存在
+    ensureDataDirs();
+    // .env 文件已在模块顶部加载，此处不再重复加载
+    // ── 单实例保护（pre-check + post-write self-check）──
+    // pre-check：发现已有活 main 直接退出，避免起任何副作用
+    {
+        const pre = scanInstances();
+        const aliveOthers = pre.mains.filter(m => m.alive && m.record.pid !== process.pid);
+        if (aliveOthers.length > 0) {
+            const pids = aliveOthers.map(m => m.record.pid).join(', ');
+            const msg = `❌ Another EvolCore instance is already running (PID: ${pids}). Use 'ec restart' to replace it.`;
+            logger.error(msg);
+            console.error(msg);
+            process.exit(1);
+        }
+    }
+    // 在登记 daemon 实例前自动备份并迁移旧角色配置；失败才阻止启动。
+    try {
+        // Crash recovery must precede schema gates and migrations so they never
+        // inspect or migrate a partially applied Role Menu transaction.
+        recoverAllRoleMutationsSync();
+        const migration = await ensureRoleConfigV4OnStartup();
+        if (migration) {
+            const msg = `✓ Role config v4 migration applied automatically: ${migration.changedFiles} file(s)` +
+                (migration.backup ? `; backup: ${migration.backup}` : '');
+            logger.info(msg);
+            console.error(msg);
+        }
+        const domainMigration = await ensureRoleConfigV5OnStartup();
+        if (domainMigration) {
+            const msg = `✓ Standalone role config migration applied automatically: ${domainMigration.changedFiles} file(s)` +
+                (domainMigration.backup ? `; backup: ${domainMigration.backup}` : '');
+            logger.info(msg);
+            console.error(msg);
+        }
+        const contactMigration = await ensureContactBookV2OnStartup();
+        if (contactMigration) {
+            const msg = `✓ Contact book v2 migration applied automatically: ${contactMigration.changedFiles} file(s)` +
+                (contactMigration.backup ? `; backup: ${contactMigration.backup}` : '');
+            logger.info(msg);
+            console.error(msg);
+        }
+    }
+    catch (e) {
+        const msg = `❌ ${e instanceof Error ? e.message : String(e)}`;
+        logger.error(msg);
+        console.error(msg);
+        process.exit(1);
+    }
+    // 立即登记自己（让其他并发启动者能看见我）
+    const launchedBy = process.env.EVOLCORE_LAUNCHED_BY || 'start';
+    writeMain(launchedBy);
+    logger.info(`✓ Instance record written: main-${process.pid}.json`);
+    // post-write 自检：写完 record 后再扫一次，发现并发对手时按 (startedAt, pid) 选赢家
+    {
+        const verdict = isMainWinner();
+        if (!verdict.winner) {
+            logger.warn(`Lost main election to PID ${verdict.conflictingPid}, yielding`);
+            console.error(`⚠ Another instance (PID ${verdict.conflictingPid}) started concurrently and won the election. Yielding.`);
+            removeAll();
+            process.exit(0);
+        }
+    }
+    // ── 自动迁移 ──
+    migrateIdentitiesIfNeeded();
+    // autoMigrateIfNeeded 已随配置体系 v2 退场（fresh init，不做兼容过渡）。
+    // ── 配置体系初始化（schema 字段不相交硬约束校验）──
+    try {
+        initConfigManager();
+    }
+    catch (e) {
+        const msg = `❌ 配置 schema 校验失败: ${e instanceof Error ? e.message : String(e)}`;
+        logger.error(msg);
+        console.error(msg);
+        process.exit(1);
+    }
+    const configSnapshotsEnabled = isConfigSnapshotsEnabled();
+    // ── 自检模式（EVOLCORE_DIAGNOSE=1 由 ec start --diagnose / ec restart --diagnose 注入）──
+    if (process.env.EVOLCORE_DIAGNOSE === '1') {
+        if (!configSnapshotsEnabled) {
+            const msg = '配置快照功能已关闭，无法执行版本回落；请设置 configSnapshots=true';
+            logger.error(`[diagnose] ${msg}`);
+            console.error(msg);
+            process.exit(1);
+        }
+        logger.info('[diagnose] 进入自检模式，逐版本回落尝试...');
+        const result = await selfDiagnose();
+        if (result.ok) {
+            logger.info(`[diagnose] ✓ 回落到 ${result.actualVersion?.delta} 成功，继续启动。`);
+            // W 已展开为好版本，继续正常启动流程（不再是诊断）
+        }
+        else {
+            const msg = result.message ?? '✗ 自检失败：未找到可用版本。';
+            logger.error(msg);
+            console.error(msg);
+            process.exit(1);
+        }
+    }
+    const daemonCfg = loadDaemonConfig();
+    if (initializeEckSnapshotsConfig(daemonCfg)) {
+        logger.warn(`[ECK] Debug snapshots enabled at ${eckDebugDir()}; files may contain sensitive context and local paths.`);
+    }
+    // ── ECK 运行时初始化 ──
+    initEck();
+    // 加载 ECK manifest + 清理旧调试文件
+    cleanEckDebug();
+    loadKitManifest();
+    // 加载配置（新结构：defaults.json + per-agent config.json）
+    const defaults = loadDefaults() ?? { $schema_version: CONFIG_SCHEMA_VERSION };
+    let processLevelOwners = daemonCfg.owners ?? [];
+    const bindBootstrapMode = process.env.EVOLCORE_BIND_BOOTSTRAP === '1';
+    if (processLevelOwners.length === 0 && shouldFailFastForMissingOwners()) {
+        throw new Error('daemon.json.owners is required when EVOLCORE_REQUIRE_OWNERS=1');
+    }
+    // 进程级 menu 操作（/system /agent）鉴权：owners 来自 daemon.json 顶层。
+    // owners 为空时这些操作一律 FORBIDDEN，启动时提示如何配置。
+    if (processLevelOwners.length === 0) {
+        logger.warn('[startup] daemon.json.owners 未配置：进程级 menu 操作（/system /agent）将一律拒绝。' +
+            '如需远程管理，请在 daemon.json 配置 owners: [<你的 AID>]');
+    }
+    // 应用配置中的日志级别（优先于环境变量）
+    // logLevel 现在不在新结构中——若要保留，将来可加 defaults.debug.logLevel
+    // 阶段 2c 暂跳过
+    const paths = resolvePaths();
+    if (bindBootstrapMode && daemonCfg.aid && loadAllAgents().agents.length === 0) {
+        await runBindBootstrapDaemon(daemonCfg, defaults);
+        return;
+    }
+    // ── EvolAgent Registry：加载 agents/<aid>/config.json ──
+    const agentRegistry = new EvolAgentRegistry(paths.agentsDir);
+    agentRegistry.loadAll();
+    const agentInfos = agentRegistry.list();
+    if (agentInfos.length === 0) {
+        const skipped = agentRegistry.getSkipped();
+        logger.info('✓ No self-agent configured; starting Control Plane only');
+        if (skipped.length > 0) {
+            logger.warn(`[startup] skipped ${skipped.length} agent director${skipped.length === 1 ? 'y' : 'ies'} while starting empty runtime`);
+            for (const s of skipped)
+                logger.warn(`  - ${s.dirName}: ${s.reason}`);
+        }
+    }
+    else {
+        logger.info(`✓ Loaded ${agentInfos.length} self-agent(s)`);
+        for (const info of agentInfos) {
+            if (info.status === 'error') {
+                logger.error(`  ✗ ${info.name}: ${info.error}`);
+            }
+            else if (info.status === 'disabled') {
+                logger.info(`  ○ ${info.name} (disabled)`);
+            }
+            else {
+                logger.info(`  ● ${info.name} ${info.baseagent} @ ${path.basename(info.projectPath)}`);
+            }
+        }
+    }
+    // 跨 agent 凭证冲突
+    {
+        const dups = detectDuplicates(agentRegistry.runnableAgents());
+        for (const d of dups) {
+            const owners = d.agents.map(o => `${o.aid}(${o.channelName})`).join(', ');
+            logger.warn(`⚠ Duplicate channel credential: ${d.fingerprint} claimed by ${owners}.`);
+        }
+    }
+    // 选定主 agent（启动期 anthropic resolve 用，配合 IPC `evolagent.list` 显示）。
+    // 空 runtime 下没有 primary agent，Control Plane 仍继续启动。
+    const primaryAgent = agentRegistry.runnableAgents()[0];
+    let agentRuntimeState = primaryAgent ? 'starting' : 'empty';
+    let agentRuntimeError;
+    if (!primaryAgent && agentInfos.length > 0) {
+        agentRuntimeState = 'error';
+        agentRuntimeError = 'No runnable self-agent (all are error/disabled).';
+        logger.warn(`[startup] ${agentRuntimeError} Control Plane will remain available.`);
+    }
+    // 进程级设置：idleMonitor 属于 daemon.json；debug 继续沿用 defaults 的现有行为。
+    const globalSettings = {
+        idleMonitor: daemonCfg.idleMonitor,
+        debug: defaults.debug,
+    };
+    if (globalSettings.debug?.logLevel) {
+        setLogLevel(globalSettings.debug.logLevel);
+    }
+    // 启动期 anthropic 凭证校验已移除：runner 创建时由 AgentLoader 错误处理
+    logger.info('✓ Config loaded');
+    // Store for IPC access (T10 will wire this)
+    // M4: removed dead globalThis.__evolcore_agentRegistry assignment
+    // 创建事件总线
+    const eventBus = new EventBus();
+    logger.info('✓ Event bus initialized');
+    // 把所有事件录到 events.log（受 EVENT_LOG 环境变量控制）
+    eventBus.subscribeAll((event) => logger.event(event));
+    eventBus.subscribe('agent:updated', (event) => {
+        if (event.nameChanged)
+            agentRegistry?.invalidateAgentDisplayCache?.(event.aid);
+    });
+    // 统计收集器（近 1 小时滚动统计）
+    const statsCollector = new StatsCollector(eventBus);
+    // Per-AID 消息统计收集器（累计，供 watch aid 实时展示）
+    const aidStatsCollector = new AidStatsCollector(eventBus);
+    // 持久化网络流量到 message_events 表
+    aidStatsCollector.onMessage = (ev) => {
+        import('./stats/writer.js').then(({ insertMessageEvent }) => {
+            insertMessageEvent(paths.root, ev);
+        }).catch(() => { });
+    };
+    // 日聚合表 usage_daily：首次启动回填 + 每日自愈。
+    // 首次：表为空但明细非空时全量回填历史数据；之后靠 writer 写时增量维护。
+    // 自愈：每日全量重建一次，纠正任何写时漂移。
+    import('./stats/db.js').then(({ getDb, rebuildDailyRollup }) => {
+        const db = getDb(paths.root);
+        if (!db)
+            return;
+        try {
+            const daily = db.prepare('SELECT COUNT(*) AS n FROM usage_daily').get();
+            const events = db.prepare('SELECT COUNT(*) AS n FROM usage_events').get();
+            if (daily.n === 0 && events.n > 0) {
+                logger.info('[Stats] usage_daily 为空，回填历史数据…');
+                rebuildDailyRollup(paths.root);
+            }
+        }
+        catch (e) {
+            logger.warn(`[Stats] usage_daily 回填检测失败（非致命）: ${e}`);
+        }
+        // 每日自愈（24h），纠正写时增量漂移。
+        setInterval(() => {
+            try {
+                rebuildDailyRollup(paths.root);
+            }
+            catch (e) {
+                logger.warn(`[Stats] usage_daily 自愈失败（非致命）: ${e}`);
+            }
+        }, 24 * 60 * 60 * 1000);
+    }).catch(() => { });
+    // 初始化 SessionManager（文件系统后端）
+    const resolveSessionIdentity = (channel, userId, chatType, conversationId) => {
+        const parsed = tryParseChannelKey(channel);
+        const owningAgent = agentRegistry.resolveByChannel(channel);
+        const selfAid = owningAgent?.aid ?? parsed?.selfAID;
+        if (!selfAid || !userId)
+            return { role: 'none', mode: 'interactive' };
+        const actualChatType = chatType || 'private';
+        // 群聊角色需按群 ID 命中群成员角色表；私聊按 userId。缺省回退到 userId 保持旧行为。
+        const actualConversationId = actualChatType === 'group'
+            ? (conversationId || userId)
+            : userId;
+        const detail = resolvePeerRoleDetail({
+            selfAid,
+            channelKey: channel,
+            channelType: parsed?.type || channel,
+            chatType: actualChatType,
+            actorId: userId,
+            conversationId: actualConversationId,
+        });
+        return roleToSessionIdentity(detail.effectiveRole);
+    };
+    const removedLegacyControlSessions = cleanupLegacySystemControlSessions(paths.sessionsDir);
+    if (removedLegacyControlSessions.length > 0) {
+        logger.info(`[startup] Removed legacy synthetic control sessions: ${removedLegacyControlSessions.join(', ')}`);
+    }
+    const sessionManager = new SessionManager(paths.sessionsDir, eventBus, resolveSessionIdentity);
+    logger.info('✓ Database initialized');
+    // 注册会话文件适配器（Claude / Codex 各自的会话文件操作）
+    sessionManager.registerFileAdapter(new ClaudeSessionFileAdapter());
+    sessionManager.registerFileAdapter(new CodexSessionFileAdapter());
+    sessionManager.registerFileAdapter(new GeminiSessionFileAdapter());
+    // Agent 插件系统：每个 EvolAgent × 每个 baseagent 一个独立 runner（H1/H2 修复）
+    const agentLoader = new AgentLoader();
+    agentLoader.register(new ClaudeAgentPlugin());
+    agentLoader.register(new CodexAgentPlugin());
+    agentLoader.register(new GeminiAgentPlugin());
+    const agentInstances = agentLoader.createAll(agentRegistry, {
+        onSessionIdUpdate: async (sessionId, agentSessionId) => {
+            await sessionManager.updateAgentSessionIdBySessionId(sessionId, agentSessionId);
+        },
+    });
+    // agentMap 复合键：${aid}::${baseagent}
+    const agentMap = new Map();
+    for (const inst of agentInstances) {
+        agentMap.set(`${inst.evolagentName}::${inst.baseagent}`, inst.agent);
+    }
+    const primaryBaseagent = primaryAgent?.baseagent ?? 'claude';
+    let primaryRunnerKey = primaryAgent ? `${primaryAgent.aid}::${primaryBaseagent}` : '<empty>::claude';
+    const agentRunner = agentMap.get(primaryRunnerKey) || agentInstances[0]?.agent;
+    if (primaryAgent && !agentRunner) {
+        agentRuntimeState = 'error';
+        agentRuntimeError = 'No agent backend available. Check baseagents config (no runners created).';
+        primaryAgent.status = 'error';
+        primaryAgent.error = agentRuntimeError;
+        logger.error(agentRuntimeError);
+    }
+    else if (!primaryAgent) {
+        logger.info('✓ Agent Runtime empty; no runners created');
+    }
+    else {
+        logger.info(`✓ Runners ready (primary key: ${primaryRunnerKey}, total: ${agentMap.size}, keys: ${[...agentMap.keys()].join(', ')})`);
+    }
+    // 权限审批网关
+    const permissionGateway = new PermissionGateway();
+    permissionGateway.setEventBus(eventBus);
+    onConfigWrite(({ target, selector }) => {
+        if ((target !== ConfigTarget.Agent
+            && target !== ConfigTarget.Contact
+            && target !== ConfigTarget.Relation) || !selector.self)
+            return;
+        const cancelled = permissionGateway.revalidatePendingApprovals(selector.self);
+        if (cancelled > 0) {
+            logger.info(`[PermissionGateway] Cancelled ${cancelled} stale management approval(s) after ${target} config write: agent=${selector.self}`);
+        }
+    });
+    eventBus.subscribe('task:interrupted', (event) => {
+        if ('sessionId' in event && event.sessionId) {
+            permissionGateway.cancelAll(event.sessionId, event.reason || 'interrupted');
+        }
+    });
+    eventBus.subscribe('task:error', (event) => {
+        if ('sessionId' in event && event.sessionId) {
+            permissionGateway.cancelAll(event.sessionId, 'task_error', false);
+        }
+    });
+    eventBus.subscribe('task:completed', (event) => {
+        if ('sessionId' in event && event.sessionId) {
+            permissionGateway.cancelAll(event.sessionId, 'task_completed', false);
+        }
+    });
+    // 交互路由器
+    const interactionRouter = new InteractionRouter();
+    // 为所有支持权限的 agent 设置 gateway
+    for (const inst of agentInstances) {
+        inst.agent.setPermissionGateway?.(permissionGateway);
+    }
+    // 创建消息缓存
+    const messageCache = new MessageCache();
+    logger.info('✓ Message cache initialized');
+    // 定期清理过期消息（每小时）
+    setInterval(() => {
+        messageCache.cleanupExpired();
+    }, 60 * 60 * 1000);
+    // 渠道插件系统
+    const channelLoader = new ChannelLoader();
+    channelLoader.register(new FeishuChannelPlugin());
+    channelLoader.register(new WechatChannelPlugin());
+    channelLoader.register(new AUNChannelPlugin());
+    channelLoader.register(new DingtalkChannelPlugin());
+    channelLoader.register(new QQBotChannelPlugin());
+    channelLoader.register(new WecomChannelPlugin());
+    // Create channel instances: 每个 self-agent 各自的 channels
+    const evolagentInstances = [];
+    for (const agent of agentRegistry.runnableAgents()) {
+        try {
+            const instances = await channelLoader.createForAgent(agent);
+            evolagentInstances.push(...instances);
+        }
+        catch (e) {
+            logger.error(`[Agent ${agent.aid}] Failed to create channels: ${e}`);
+            agent.status = 'error';
+            agent.error = `Channel creation failed: ${e}`;
+        }
+    }
+    const channelInstances = evolagentInstances;
+    logger.info(`✓ Created ${channelInstances.length} channel instance(s)`);
+    const bindService = daemonCfg.aid
+        ? new BindService({
+            receiverAid: daemonCfg.aid,
+            getAvailableBaseagents: detectAvailableBaseagentsForBind,
+            getUptimeSeconds: () => Math.floor(process.uptime()),
+            onDaemonOwnersUpdated: (owners) => { processLevelOwners = owners; },
+        })
+        : null;
+    bindService?.startCleanup();
+    const agentDelegationRegistry = new AgentDelegationRegistry();
+    // 创建命令处理器
+    const cmdHandler = new CommandHandler(sessionManager, agentMap, messageCache, eventBus, primaryRunnerKey);
+    cmdHandler.setAgentDelegationRegistry(agentDelegationRegistry);
+    cmdHandler.setPermissionGateway(permissionGateway);
+    cmdHandler.setInteractionRouter(interactionRouter);
+    cmdHandler.setStatsCollector(statsCollector);
+    // 创建消息处理器
+    // 默认使用 ResponseEngine（插件化引擎）。
+    // MessageProcessor（旧引擎）保留为参考真相，不删除但不再使用。
+    const responseEngine = new ResponseEngine(agentMap, sessionManager, globalSettings, messageCache, eventBus, (content, channel, channelId, userId, threadId) => {
+        const sendFn = async (id, text, opts) => {
+            const adapter = cmdHandler.getAdapter(channel);
+            if (!adapter)
+                return;
+            if (text) {
+                await adapter.send(buildEnvelope({ channel: adapter.channelName, channelId: id, replyContext: opts }), { kind: 'system.notice', text, subtype: 'health' });
+            }
+        };
+        return cmdHandler.handle(content, channel, channelId, sendFn, userId, threadId);
+    }, primaryRunnerKey);
+    responseEngine.setAgentDelegationRegistry(agentDelegationRegistry);
+    const processor = responseEngine;
+    // 回填 processor 和 messageQueue 的引用
+    cmdHandler.setProcessor(processor);
+    // Inject EvolAgentRegistry (methods added by T6/T7)
+    if (processor.setAgentRegistry) {
+        processor.setAgentRegistry(agentRegistry);
+    }
+    if (cmdHandler.setAgentRegistry) {
+        cmdHandler.setAgentRegistry(agentRegistry);
+    }
+    // 设置交互路由器
+    processor.setInteractionRouter(interactionRouter);
+    // 设置 compact 开始回调（对所有支持的 agent）
+    for (const inst of agentInstances) {
+        inst.agent.setCompactStartCallback?.((sessionId) => {
+            processor.handleCompactStart(sessionId);
+        });
+    }
+    // 创建消息队列
+    const messageQueue = new MessageQueue(async (message) => {
+        await processor.processMessage(message);
+    }, {
+        persistencePath: path.join(resolvePaths().dataDir, 'message-queue.json'),
+    });
+    // 设置中断回调（精确中断正在处理的 agent）
+    messageQueue.setInterruptCallback(async (sessionKey, baseagent, evolagentName, reason = 'new_message') => {
+        void baseagent;
+        void evolagentName;
+        await responseEngine.interruptSession(sessionKey, reason);
+    });
+    messageQueue.setEventBus(eventBus);
+    // 进程退出时立即刷盘队列状态（防止 debounce 期间的消息丢失）
+    onShutdown(() => messageQueue.persistQueuesImmediate());
+    // 回填 messageQueue 引用
+    cmdHandler.setMessageQueue(messageQueue);
+    processor.setMessageQueue(messageQueue);
+    const taskExecutionTtlMs = daemonConversationTotalExecutionMs(globalSettings);
+    const handoffRuntime = new HandoffRuntime(sessionManager, messageQueue, async (handoff) => {
+        const targetSession = await sessionManager.getSessionById(handoff.target_session_id);
+        if (!targetSession)
+            return { ok: false, error: 'target session not found' };
+        const inst = channelInstances.find(candidate => (candidate.channelType === 'aun' && (candidate.adapter.channelKey === targetSession.metadata?.channelKey
+            || candidate.adapter.channelName === targetSession.channel
+            || tryParseChannelKey(candidate.adapter.channelKey)?.selfAID === targetSession.selfAID)));
+        const channel = inst?.channel;
+        if (!channel) {
+            return { ok: false, error: `AUN channel not found for ${targetSession.selfAID || '<unknown>'}` };
+        }
+        const classified = classifyAunPayloadForLog(handoff.request.payload);
+        const log = {
+            content: classified.content,
+            sessionId: targetSession.id,
+            threadId: targetSession.threadId || null,
+            msgType: classified.msgType,
+            payloadType: classified.payloadType,
+            payloadSummary: classified.payloadSummary,
+            source: 'msg',
+            handoffTrace: { version: 2, handoff_id: handoff.handoff_id },
+        };
+        const result = targetSession.chatType === 'group'
+            ? typeof channel.sendDaemonGroupMsg === 'function'
+                ? await channel.sendDaemonGroupMsg({
+                    groupId: targetSession.channelId,
+                    payload: { ...handoff.request.payload, [AUN_HANDOFF_MARKER_FIELD]: handoff.handoff_id },
+                    encrypt: handoff.request.encrypt,
+                    log,
+                })
+                : { ok: false, error: 'AUN channel does not support daemon group sends' }
+            : typeof channel.sendDaemonMsg === 'function'
+                ? await channel.sendDaemonMsg({
+                    to: targetSession.channelId,
+                    payload: handoff.request.payload,
+                    encrypt: handoff.request.encrypt,
+                    causation: handoff.causation,
+                    log,
+                })
+                : { ok: false, error: 'AUN channel does not support daemon private sends' };
+        return { ok: result.ok, message_id: result.message_id, error: result.error };
+    }, undefined, { queueTtlMs: taskExecutionTtlMs });
+    responseEngine.setHandoffRuntime(handoffRuntime);
+    // Trigger runtime: daemon-level script + feedback scheduler.
+    const triggerSchedulers = new Map();
+    const triggerAudit = new TriggerAuditLogger();
+    const triggerScriptExecutor = new TriggerScriptExecutor();
+    const daemonChannel = new DaemonChannel(sessionManager, messageQueue, {
+        watchdogMs: daemonConversationWatchdogMs(globalSettings),
+        totalExecutionMs: taskExecutionTtlMs,
+    });
+    const triggerControlToken = crypto.randomBytes(32).toString('base64url');
+    fs.writeFileSync(resolvePaths().controlToken, triggerControlToken, { mode: 0o600 });
+    try {
+        fs.chmodSync(resolvePaths().controlToken, 0o600);
+    }
+    catch { }
+    const triggerStartupAgents = [...agentRegistry.runnableAgents()];
+    const controlAid = daemonCfg.aid || '__daemon__';
+    const daemonTriggerOwner = {
+        aid: triggerStartupAgents.some(agent => agent.aid === controlAid) ? `${controlAid}#daemon` : controlAid,
+        originPeerId: controlAid,
+        baseagent: primaryAgent?.baseagent || 'codex',
+        projectPath: primaryAgent?.projectPath || process.cwd(),
+    };
+    const triggerBaseagentsForAgent = (agentAid) => {
+        const ownerName = agentRegistry.get(agentAid)?.name
+            ?? (agentAid === daemonTriggerOwner.aid ? primaryAgent?.name : undefined);
+        if (!ownerName)
+            return [];
+        const prefix = `${ownerName}::`;
+        return [...agentMap.keys()]
+            .filter(key => key.startsWith(prefix))
+            .map(key => key.slice(prefix.length));
+    };
+    const materializeTriggerCreateBaseagent = (input, agentAid) => {
+        const rawExecution = input.execution;
+        if (!rawExecution || typeof rawExecution !== 'object' || Array.isArray(rawExecution))
+            return input;
+        const execution = rawExecution;
+        if (execution.type !== 'trigger_session') {
+            if (execution.baseagent !== undefined) {
+                throw new Error('execution.baseagent is only allowed when execution.type=trigger_session');
+            }
+            return input;
+        }
+        if (execution.baseagent !== undefined
+            && (typeof execution.baseagent !== 'string' || !execution.baseagent.trim())) {
+            throw new Error('execution.baseagent must be a non-empty string');
+        }
+        const baseagent = typeof execution.baseagent === 'string'
+            ? execution.baseagent.trim()
+            : agentRegistry.get(agentAid)?.baseagent
+                ?? (agentAid === daemonTriggerOwner.aid ? daemonTriggerOwner.baseagent : undefined);
+        if (!baseagent)
+            throw new Error('unable to resolve Trigger session baseagent');
+        const available = triggerBaseagentsForAgent(agentAid);
+        if (!available.includes(baseagent)) {
+            throw new Error(`Trigger baseagent unavailable for ${agentAid}: ${baseagent} (available: ${available.join(', ') || 'none'})`);
+        }
+        return { ...input, execution: { ...execution, baseagent } };
+    };
+    const getTriggerChannel = (agentAid, channelKey) => {
+        if (agentAid === daemonTriggerOwner.aid && channelKey === daemonChannel.channelKey) {
+            return {
+                adapter: daemonChannel,
+                agentAid,
+                agentName: daemonTriggerOwner.aid,
+                projectPath: daemonTriggerOwner.projectPath,
+                baseagent: daemonTriggerOwner.baseagent,
+            };
+        }
+        const agent = agentRegistry.get(agentAid);
+        if (!agent)
+            return undefined;
+        const inst = channelInstances.find((candidate) => (candidate.adapter.channelKey === channelKey
+            || candidate.adapter.channelName === channelKey));
+        const parsed = inst ? tryParseChannelKey(inst.adapter.channelKey) : null;
+        if (inst && parsed?.selfAID !== agentAid)
+            return undefined;
+        if (!inst)
+            return undefined;
+        return {
+            adapter: inst.adapter,
+            agentAid,
+            agentName: agent.aid,
+            projectPath: agent.projectPath,
+            baseagent: agent.baseagent,
+        };
+    };
+    const validateTriggerFeedbackChannels = (definition) => {
+        if (definition.feedback.strategy === 'silent')
+            return;
+        const target = definition.feedback.strategy === 'target'
+            ? definition.feedback.target
+            : definition.origin;
+        if (target && !getTriggerChannel(definition.agentAid, target.channelKey)) {
+            throw new Error(`agent ${definition.agentAid} has no configured channel ${target.channelKey}`);
+        }
+    };
+    const validateTriggerDefinitionForActor = (definition, actor) => {
+        if (definition.execution.type === 'script' && !actor.management) {
+            throw new Error('only owner/admin may create or update a script trigger');
+        }
+        if (definition.execution.permissionMode) {
+            const permissionDecision = constrainRuntimePermissionMode({
+                selfAid: definition.agentAid,
+                role: actor.role,
+                requestedValue: definition.execution.permissionMode,
+            });
+            if (permissionDecision.constrained) {
+                throw new Error(`trigger permissionMode ${definition.execution.permissionMode} exceeds current role ${actor.role}`);
+            }
+        }
+        if (definition.execution.model) {
+            const agent = agentRegistry.get(definition.agentAid);
+            const modelDecision = validateModelSelectionForRole({
+                role: actor.role,
+                baseagent: definition.execution.baseagent ?? agent?.baseagent,
+                requestedModel: definition.execution.model,
+                selfAid: definition.agentAid,
+            });
+            if (!modelDecision.ok)
+                throw new Error(modelDecision.message || 'trigger model is not allowed by current role');
+        }
+        if (definition.execution.effort) {
+            const baseagent = definition.execution.baseagent
+                ?? agentRegistry.get(definition.agentAid)?.baseagent
+                ?? 'claude';
+            const effortDecision = validateRuntimeStringFieldOverride({
+                selfAid: definition.agentAid,
+                role: actor.role,
+                field: `baseagents.${baseagent}.${baseagent === 'codex' ? 'reasoning' : 'effort'}`,
+                value: definition.execution.effort,
+            });
+            if (!effortDecision.ok)
+                throw new Error(effortDecision.message || 'trigger effort is not allowed by current role');
+        }
+        if (!actor.management && definition.feedback.strategy === 'target') {
+            const target = definition.feedback.target;
+            const origin = actor.origin;
+            if (!target || !origin
+                || target.channelKey !== origin.channelKey
+                || target.channelId !== origin.channelId
+                || target.session !== origin.session
+                || (target.threadId ?? '') !== (origin.threadId ?? '')) {
+                throw new Error('non-management trigger target must be the creator private conversation');
+            }
+        }
+    };
+    const authorizeTriggerExecution = (definition) => {
+        const origin = definition.origin;
+        if (!origin?.peerId)
+            return { allowed: false, reason: 'trigger origin peer is missing' };
+        if (origin.channelKey === 'daemon') {
+            const subject = buildAuthSubject({
+                selfAid: definition.agentAid,
+                actorId: origin.peerId,
+                channel: origin.channelKey,
+                channelType: origin.channelType || 'daemon',
+                channelId: origin.channelId,
+                chatType: 'private',
+                conversationId: origin.peerId,
+                identity: roleToSessionIdentity('owner'),
+                fromControlChannel: true,
+            });
+            const decision = authorizeOperation({
+                source: 'control',
+                subject,
+                intent: {
+                    operation: 'trigger.run',
+                    scope: 'relation',
+                    source: 'control',
+                    args: { self: definition.agentAid, peer: origin.peerId, peerKey: subject.peerKey, triggerId: definition.id },
+                },
+            });
+            return decision.allow ? { allowed: true } : { allowed: false, reason: decision.reason };
+        }
+        const channelType = origin.channelType || tryParseChannelKey(origin.channelKey)?.type;
+        if (!channelType)
+            return { allowed: false, reason: 'trigger origin channel type is missing' };
+        const roleDetail = resolvePeerRoleDetail({
+            selfAid: definition.agentAid,
+            channelKey: origin.channelKey,
+            channelType,
+            chatType: 'private',
+            actorId: origin.peerId,
+            conversationId: origin.peerId,
+        });
+        const role = roleDetail.effectiveRole;
+        if (!checkRoleAccess(role, definition.agentAid)) {
+            return { allowed: false, reason: `trigger creator no longer has access (role=${role ?? 'none'})` };
+        }
+        const subject = buildAuthSubject({
+            selfAid: definition.agentAid,
+            actorId: origin.peerId,
+            channel: origin.channelKey,
+            channelType,
+            channelId: origin.channelId,
+            chatType: 'private',
+            conversationId: origin.peerId,
+            roleDetail,
+            identity: roleToSessionIdentity(role),
+            fromControlChannel: false,
+        });
+        const operationDecision = authorizeOperation({
+            source: 'agent-tool',
+            subject,
+            intent: {
+                operation: 'trigger.run',
+                scope: 'relation',
+                source: 'agent-tool',
+                args: { self: definition.agentAid, peer: origin.peerId, peerKey: subject.peerKey, triggerId: definition.id },
+            },
+        });
+        if (!operationDecision.allow) {
+            return { allowed: false, reason: operationDecision.reason };
+        }
+        if (definition.execution.type === 'script' && !isManagementRole(role)) {
+            return { allowed: false, reason: `script trigger requires current owner/admin role (role=${role ?? 'none'})` };
+        }
+        if (definition.feedback.strategy === 'target' && !isManagementRole(role)) {
+            const target = definition.feedback.target;
+            if (!target
+                || target.channelKey !== origin.channelKey
+                || target.channelId !== origin.channelId
+                || target.session !== origin.session
+                || (target.threadId ?? '') !== (origin.threadId ?? '')) {
+                return { allowed: false, reason: `cross-conversation target requires current owner/admin role (role=${role ?? 'none'})` };
+            }
+        }
+        return { allowed: true };
+    };
+    const authenticatedTriggerActor = async (agentAid, actorSessionId, delegationToken, controlToken) => {
+        if (typeof actorSessionId !== 'string' || !actorSessionId) {
+            const providedToken = typeof controlToken === 'string' ? Buffer.from(controlToken) : undefined;
+            const expectedToken = Buffer.from(triggerControlToken);
+            if (!providedToken
+                || providedToken.length !== expectedToken.length
+                || !crypto.timingSafeEqual(providedToken, expectedToken)) {
+                throw new Error('valid local control token is required');
+            }
+            const origin = {
+                channelKey: 'daemon',
+                channelType: 'daemon',
+                channelId: daemonTriggerOwner.originPeerId,
+                session: 'main',
+                peerId: daemonTriggerOwner.originPeerId,
+                sessionKey: `daemon#${daemonTriggerOwner.originPeerId}#__control__`,
+            };
+            const subject = buildAuthSubject({
+                selfAid: agentAid,
+                actorId: origin.peerId,
+                channel: origin.channelKey,
+                channelType: origin.channelType,
+                channelId: origin.channelId,
+                chatType: 'private',
+                conversationId: origin.peerId,
+                identity: roleToSessionIdentity('owner'),
+                fromControlChannel: true,
+            });
+            return {
+                origin,
+                management: true,
+                control: true,
+                role: 'owner',
+                subject,
+            };
+        }
+        const validation = agentDelegationRegistry.validate(typeof delegationToken === 'string' ? delegationToken : undefined, actorSessionId);
+        if (!validation.ok)
+            throw new Error(validation.reason);
+        if (validation.grant.selfAid !== agentAid) {
+            throw new Error('trigger agent does not match authenticated task agent');
+        }
+        const actorSession = await sessionManager.getSessionById(actorSessionId);
+        const actorOrigin = actorSession ? originFromActorSession(actorSession, validation.grant.actorId, validation.grant.channel, validation.grant.chatType) : undefined;
+        if (!actorSession || !actorOrigin?.peerId)
+            throw new Error('trigger actor session has no authenticated peer');
+        if (validation.grant.actorId !== actorOrigin.peerId) {
+            throw new Error('trigger delegation actor does not match session peer');
+        }
+        const roleDetail = resolvePeerRoleDetail({
+            selfAid: validation.grant.selfAid,
+            channelKey: validation.grant.channel,
+            channelType: validation.grant.channelType,
+            chatType: 'private',
+            actorId: validation.grant.actorId,
+            conversationId: validation.grant.actorId,
+        });
+        const currentRole = roleDetail.effectiveRole;
+        if (!checkRoleAccess(currentRole, validation.grant.selfAid)) {
+            throw new Error('trigger actor no longer has access to this agent');
+        }
+        const subject = buildAuthSubject({
+            selfAid: validation.grant.selfAid,
+            actorId: validation.grant.actorId,
+            channel: validation.grant.channel,
+            channelType: validation.grant.channelType,
+            channelId: actorOrigin.channelId,
+            chatType: 'private',
+            conversationId: validation.grant.actorId,
+            roleDetail,
+            identity: roleToSessionIdentity(currentRole),
+            fromControlChannel: false,
+        });
+        return {
+            origin: actorOrigin,
+            management: isManagementRole(currentRole),
+            selfAid: validation.grant.selfAid,
+            control: false,
+            role: currentRole || 'none',
+            subject,
+        };
+    };
+    const startTriggerScheduler = async (owner, opts = {}) => {
+        await triggerSchedulers.get(owner.aid)?.stop();
+        const manager = new TriggerDefinitionManager(owner.aid);
+        if (opts.seedUpgradeCheck) {
+            seedUpgradeCheckTrigger(manager, owner);
+        }
+        else {
+            removeLegacyAgentUpgradeCheck(manager);
+        }
+        const state = new TriggerRunStateStore(manager);
+        const agentTriggerAudit = triggerAudit.withHistory(manager.history);
+        const dispatcher = new TriggerFeedbackDispatcher({
+            getChannel: getTriggerChannel,
+            sessionManager,
+            messageQueue,
+            eventBus,
+            tryHandoff: async (input, text, target, binding) => {
+                if (input.signal?.aborted) {
+                    throw input.signal.reason instanceof Error ? input.signal.reason : new Error('trigger feedback cancelled');
+                }
+                if (tryParseChannelKey(target.channelKey)?.type !== 'aun')
+                    return null;
+                const inst = channelInstances.find(candidate => (candidate.channelType === 'aun'
+                    && (candidate.adapter.channelKey === target.channelKey || candidate.adapter.channelName === target.channelKey)
+                    && tryParseChannelKey(candidate.adapter.channelKey)?.selfAID === input.trigger.agentAid));
+                const channel = inst?.channel;
+                if (!channel || typeof channel.isGroupId !== 'function')
+                    return null;
+                const targetChatType = channel.isGroupId(target.channelId) ? 'group' : 'private';
+                if (targetChatType === 'group' && typeof channel.sendDaemonGroupMsg !== 'function')
+                    return null;
+                if (targetChatType === 'private' && typeof channel.sendDaemonMsg !== 'function')
+                    return null;
+                const originSession = await daemonChannel.getOrCreateConversationSession(input.trigger, binding.projectPath, binding.baseagent || owner.baseagent, input.runId);
+                if (input.signal?.aborted) {
+                    throw input.signal.reason instanceof Error ? input.signal.reason : new Error('trigger feedback cancelled');
+                }
+                const payload = { type: 'text', text };
+                if (target.session === 'thread' && target.threadId)
+                    payload.thread_id = target.threadId;
+                const created = await handoffRuntime.createOutbound({
+                    selfAid: input.trigger.agentAid,
+                    to: target.channelId,
+                    originSessionId: originSession.id,
+                    originMessageId: input.runId,
+                    payload,
+                    encrypt: false,
+                    thread: target.session === 'thread' ? target.threadId : undefined,
+                    targetChatType,
+                    explicitReturnPolicy: 'none',
+                    causation: input.causation,
+                    signal: input.signal,
+                });
+                return created.crossSession && created.handoff
+                    ? { handoffId: created.handoff.handoff_id, targetSessionId: created.targetSession.id }
+                    : null;
+            },
+        });
+        const scheduler = new TriggerRuntimeScheduler(manager, state, agentTriggerAudit, triggerScriptExecutor, dispatcher, daemonChannel, {
+            projectPath: owner.projectPath,
+            baseagent: owner.baseagent,
+            getBaseagent: () => agentRegistry.get(owner.aid)?.baseagent || owner.baseagent,
+            authorizeExecution: authorizeTriggerExecution,
+        }, eventBus);
+        triggerSchedulers.set(owner.aid, scheduler);
+        try {
+            await scheduler.init();
+        }
+        catch (err) {
+            logger.error(`[Trigger] Scheduler init failed for ${owner.aid}: ${err}`);
+        }
+    };
+    cmdHandler.setTriggerSchedulerResolver((agentAid) => triggerSchedulers.get(agentAid));
+    const startedTriggerAgents = new Set();
+    const ensureTriggerSchedulerStarted = async (agent) => {
+        if (startedTriggerAgents.has(agent.aid))
+            return;
+        startedTriggerAgents.add(agent.aid);
+        await startTriggerScheduler(agent);
+    };
+    const ensureDaemonTriggerSchedulerStarted = async () => {
+        if (startedTriggerAgents.has(daemonTriggerOwner.aid))
+            return;
+        startedTriggerAgents.add(daemonTriggerOwner.aid);
+        await startTriggerScheduler(daemonTriggerOwner, { seedUpgradeCheck: true });
+    };
+    // 默认策略
+    const defaultPolicy = {
+        canSwitchProject: (chatType, role) => chatType === 'private' ? isManagementRole(role) : role === 'owner',
+        canListProjects: (chatType, role) => chatType === 'private' ? isManagementRole(role) : role === 'owner',
+        canCreateSession: () => true,
+        canDeleteSession: (chatType, role) => chatType === 'private' ? isManagementRole(role) : role === 'owner',
+        canImportCliSession: (chatType, role) => chatType === 'private' ? isManagementRole(role) : role === 'owner',
+        messagePrefix: () => '',
+        showMiddleResult: () => true,
+        showIdleMonitor: () => true,
+        accumulateErrors: () => true,
+    };
+    processor.registerChannel(daemonChannel, defaultPolicy, { channelType: 'daemon' });
+    cmdHandler.registerAdapter(daemonChannel);
+    cmdHandler.registerChannel(daemonChannel.channelName, daemonChannel, 'daemon');
+    // ── MessageBridge：Channel ↔ Core 消息桥梁 ──
+    const defaultProjectPath = primaryAgent?.projectPath
+        ?? defaults.projects?.defaultPath
+        ?? path.join(paths.root, 'projects', 'default');
+    const msgBridge = new MessageBridge(defaultProjectPath, sessionManager, processor, messageQueue, cmdHandler, eventBus, primaryAgent?.config.debounce, () => processLevelOwners);
+    msgBridge.setAgentRegistry(agentRegistry);
+    const bootstrapService = new BootstrapService(agentRegistry, eventBus);
+    msgBridge.setBootstrapService(bootstrapService);
+    msgBridge.setHandoffRuntime(handoffRuntime);
+    // ── Channel instance registration (shared by startup and hot-load) ──
+    function registerChannelInstance(inst) {
+        // 0. 包装 adapter.send，记录所有出站到 channel-out.log
+        const originalSend = inst.adapter.send.bind(inst.adapter);
+        inst.adapter.send = async (envelope, payload) => {
+            logger.channelOut({ channel: inst.adapter.channelName, channelId: envelope.channelId, taskId: envelope.taskId, payload: summarizeOutboundPayload(payload) });
+            const result = await originalSend(envelope, payload);
+            if (shouldCountSentPayload(payload)) {
+                const owningAgent = agentRegistry.resolveByChannel(inst.adapter.channelKey)
+                    ?? agentRegistry.resolveByChannel(inst.adapter.channelName);
+                if ((inst.channelType || inst.adapter.channelName) !== 'aun') {
+                    try {
+                        const logPayload = outboundPayloadToLogText(payload);
+                        const session = envelope.sessionId
+                            ? await sessionManager.getSessionById(envelope.sessionId)
+                            : envelope.replyContext?.threadId
+                                ? await sessionManager.getThreadSession(envelope.channel ?? inst.adapter.channelName, envelope.channelId, envelope.replyContext.threadId)
+                                : sessionManager.getActiveSessionSync(envelope.channel ?? inst.adapter.channelName, envelope.channelId, inst.channelType || inst.adapter.channelName, owningAgent?.aid);
+                        if (logPayload && session) {
+                            const chatDir = sessionManager.getChatDir(session);
+                            const isGroup = session.chatType === 'group';
+                            const target = isGroup
+                                ? (session.metadata?.groupId || session.channelId)
+                                : (session.metadata?.peerId || envelope.channelId);
+                            appendMessageLog(chatDir, buildOutboundEntry({
+                                from: owningAgent?.aid ?? envelope.agentName ?? session.selfAID ?? 'self',
+                                to: String(target || envelope.channelId),
+                                sessionId: session.id,
+                                threadId: envelope.replyContext?.threadId || session.threadId || null,
+                                chatType: isGroup ? 'group' : 'private',
+                                groupId: isGroup ? String(session.metadata?.groupId || session.channelId) : null,
+                                msgId: `${envelope.taskId || 'out'}_${Date.now()}`,
+                                content: logPayload.text,
+                                replyTo: envelope.replyContext?.replyToMessageId ?? null,
+                                agent: session.baseagent ?? null,
+                                model: null,
+                                durationMs: null,
+                                msgType: logPayload.msgType,
+                                source: normalizeMessageSource(envelope.replyContext?.metadata?.source),
+                                chatmode: envelope.chatmode,
+                            }));
+                        }
+                    }
+                    catch (err) {
+                        logger.debug(`[MessageLog] Failed to write outbound channel log: ${err}`);
+                    }
+                }
+                eventBus.publish({
+                    type: 'message:sent',
+                    sessionId: envelope.sessionId ?? envelope.taskId ?? `out-${Date.now()}`,
+                    channel: envelope.channel ?? inst.adapter.channelName,
+                    channelName: inst.adapter.channelName,
+                    channelId: envelope.channelId,
+                    agentName: owningAgent?.aid ?? envelope.agentName,
+                    payloadKind: payload.kind,
+                    timestamp: Date.now(),
+                });
+            }
+            return result;
+        };
+        // 1. 项目路径提供器
+        if (inst.onProjectPathRequest && inst.channel.onProjectPathRequest) {
+            inst.channel.onProjectPathRequest(async (channelId) => {
+                // Effective default path: use the agent that owns this channel.
+                const owningAgent = agentRegistry.resolveByChannel(inst.adapter.channelKey);
+                const effectiveDefault = owningAgent?.projectPath
+                    ?? defaultProjectPath;
+                const parsedKey = tryParseChannelKey(inst.adapter.channelKey);
+                const session = await sessionManager.getOrCreateSession(inst.adapter.channelKey, channelId, effectiveDefault, undefined, undefined, undefined, undefined, undefined, owningAgent?.baseagent, parsedKey?.selfAID, parsedKey?.type);
+                return path.isAbsolute(session.projectPath)
+                    ? session.projectPath
+                    : path.resolve(process.cwd(), session.projectPath);
+            });
+        }
+        // 2. 注册 adapter、policy 和 options（注入 channelType）
+        const opts = inst.channelType
+            ? { ...inst.options, channelType: inst.channelType }
+            : inst.options;
+        processor.registerChannel(inst.adapter, inst.policy || defaultPolicy, opts);
+        cmdHandler.registerAdapter(inst.adapter);
+        cmdHandler.registerChannel(inst.adapter.channelName, inst.channel, inst.channelType);
+        if (inst.policy) {
+            cmdHandler.registerPolicy(inst.adapter.channelName, inst.policy);
+        }
+        // 3. 交互回调
+        registerAdapterInteractions(inst.adapter, interactionRouter);
+        // 4. MessageBridge 注册
+        const channelType = inst.channelType || inst.adapter.channelName;
+        if (inst.registerBridge) {
+            inst.registerBridge(msgBridge, channelType);
+        }
+        // 4b. 生命周期钩子
+        if (inst.registerHooks) {
+            inst.registerHooks({ eventBus, sessionManager });
+        }
+        // 4c. 观察者模式配置读取器（AUN）：从 EvolAgent 的 merged config 读 observable/owners，
+        // 不另建缓存——EvolAgent 那份在启动/重启/热重载时统一更新，是唯一真相源。
+        const channelForObserver = inst.channel;
+        if (typeof channelForObserver.setObserverConfigResolver === 'function') {
+            const channelKey = inst.adapter.channelKey;
+            channelForObserver.setObserverConfigResolver(() => {
+                const owningAgent = agentRegistry.resolveByChannel(channelKey);
+                return {
+                    observable: owningAgent?.getObservable() ?? false,
+                    owners: owningAgent ? Array.from(new Set(owningAgent.config.owners ?? [])) : [],
+                };
+            });
+        }
+        // 5. 撤回消息 → 中断执行中任务
+        inst.channel.onRecall?.((messageId) => {
+            msgBridge.cancel(messageId);
+        });
+    }
+    // ── 注册所有渠道实例 ──
+    for (const inst of channelInstances) {
+        registerChannelInstance(inst);
+    }
+    // Bind adapters to their owning agents and mark running
+    for (const inst of channelInstances) {
+        const agent = agentRegistry.resolveByChannel(inst.adapter.channelKey);
+        if (!agent || agent.status === 'error')
+            continue;
+        agent.channels.set(inst.adapter.channelKey, inst.adapter);
+        const hasRunner = agentInstances.some(runner => runner.evolagentName === agent.aid);
+        if (agent.status === 'stopped' && hasRunner) {
+            agent.status = 'running';
+        }
+    }
+    if (agentRegistry.list().some((info) => info.status === 'running')) {
+        agentRuntimeState = 'running';
+        agentRuntimeError = undefined;
+    }
+    else if (agentRegistry.runnableAgents().length === 0 && agentRegistry.list().length === 0) {
+        agentRuntimeState = 'empty';
+    }
+    else if (agentRuntimeState === 'starting') {
+        agentRuntimeState = 'error';
+        agentRuntimeError = agentRuntimeError ?? 'No runnable self-agent reached running state.';
+    }
+    // ── 配置快照 + 启动日志（启动完毕锚点，网络无关）──────────────────
+    if (configSnapshotsEnabled) {
+        try {
+            const isDiagnoseMode = process.env.EVOLCORE_DIAGNOSE === '1';
+            // 正常启动：首次建立全量基线，后续仅在配置树变化时建立新版本。
+            // 自检模式已由 selfDiagnose 展开回落版本，避免重复存档。
+            const startupVersion = isDiagnoseMode ? readWVersion() : ensureStartupConfigSnapshot();
+            // P3/回落成功：W==w-version → successCount++
+            if (startupVersion) {
+                incrementSuccessCount(startupVersion.delta);
+            }
+            // boot-log
+            const startMethod = process.env.EVOLCORE_DIAGNOSE === '1' ? 'diagnose'
+                : (process.env.EVOLCORE_LAUNCHED_BY === 'start' ? 'manual' : 'auto');
+            appendBootLog({
+                bootedAt: new Date().toISOString(),
+                startMethod: startMethod,
+                selectedVersion: readCurrent(),
+                actualVersion: startupVersion,
+                fellBack: !!(isDiagnoseMode && startupVersion && readCurrent()?.delta !== startupVersion.delta),
+                versions: { evolcore: readEvolcoreVersion(), '@agentunion/fastaun': readFastaunVersion(), node: process.version },
+                platform: `${process.platform}/${process.arch}`,
+            });
+            retentionCleanup();
+        }
+        catch (e) {
+            logger.warn(`[config] startup snapshot/boot-log failed (non-fatal): ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    else {
+        logger.info('[config] snapshots disabled by configSnapshots=false');
+    }
+    // 预填充 Feishu 已知 thread_id（重启后避免误判话题创建）。
+    // 必须早于 connect()，后台连接后 Feishu 可能立即收到消息。
+    for (const inst of channelInstances) {
+        const channelType = inst.channelType || inst.adapter.channelName;
+        if (channelType === 'feishu' && 'preloadThreads' in inst.channel) {
+            const threadIds = sessionManager.getKnownThreadIds(inst.adapter.channelKey);
+            inst.channel.preloadThreads(threadIds);
+        }
+    }
+    const connectedChannels = new Set();
+    const onlineNoticeSent = new Set();
+    const pendingFile = path.join(resolvePaths().dataDir, 'restart-pending.json');
+    let pendingRestartNoticeInFlight = null;
+    let pendingRestartNoticeSent = false;
+    const sendOnlineNoticeForChannel = (inst) => {
+        const name = inst.adapter.channelName;
+        const agent = agentRegistry.resolveByChannel(inst.adapter.channelKey) ?? agentRegistry.resolveByChannel(name);
+        if (!agent)
+            return;
+        if (!agent.config.debug?.upmsg)
+            return;
+        const ownerAid = getFirstStaticAgentOwner(agent.aid);
+        if (!ownerAid)
+            return;
+        const noticeKey = `${agent.aid}#${name}`;
+        if (onlineNoticeSent.has(noticeKey))
+            return;
+        onlineNoticeSent.add(noticeKey);
+        setTimeout(() => {
+            const adapter = agent.channels.get(inst.adapter.channelKey) ?? agent.channels.get(name);
+            if (!adapter)
+                return;
+            let agentName = agent.aid;
+            try {
+                const mdPath = agentMdPath(agent.aid);
+                const content = fs.readFileSync(mdPath, 'utf-8');
+                const nameMatch = content.match(/^name:\s*"?([^"\n]+)/m);
+                if (nameMatch)
+                    agentName = nameMatch[1].trim().replace(/"$/, '');
+            }
+            catch { }
+            const projectDir = path.basename(agent.projectPath);
+            const text = `✓ ${agentName} 已上线 | 工作目录: ${projectDir}`;
+            const envelope = buildEnvelope({
+                taskId: `system-online-${crypto.randomBytes(5).toString('hex')}`,
+                channel: adapter.channelName,
+                channelId: ownerAid,
+                agentName,
+            });
+            sendSystemPayload(adapter, envelope, {
+                kind: 'system.notice',
+                text,
+                subtype: 'restarted',
+            }).catch(() => { });
+        }, 1000 + Math.random() * 2000);
+    };
+    const trySendPendingRestartNotice = async () => {
+        if (pendingRestartNoticeSent)
+            return;
+        if (pendingRestartNoticeInFlight) {
+            try {
+                await pendingRestartNoticeInFlight;
+            }
+            catch {
+                // The first caller logs the actual send/read error.
+            }
+            return;
+        }
+        if (!fs.existsSync(pendingFile))
+            return;
+        pendingRestartNoticeInFlight = (async () => {
+            if (pendingRestartNoticeSent)
+                return;
+            if (!fs.existsSync(pendingFile))
+                return;
+            const pending = JSON.parse(fs.readFileSync(pendingFile, 'utf-8'));
+            const adapter = cmdHandler.getAdapter(pending.channel)
+                ?? channelInstances.find(inst => inst.adapter.channelKey === pending.channel)?.adapter;
+            if (!adapter)
+                return;
+            if (!connectedChannels.has(pending.channel)
+                && !connectedChannels.has(adapter.channelName)
+                && !connectedChannels.has(adapter.channelKey)) {
+                logger.info(`[Restart] Pending notification waits for channel connection: ${pending.channel}`);
+                return;
+            }
+            const replyContext = pending.rootId
+                ? { replyToMessageId: pending.rootId, replyInThread: !!pending.threadId }
+                : undefined;
+            const owningAgent = agentRegistry.resolveByChannel(adapter.channelKey);
+            const envelope = buildEnvelope({
+                taskId: `system-restart-${process.pid}`,
+                channel: adapter.channelKey,
+                channelId: pending.channelId,
+                agentName: owningAgent?.aid || 'evolcore',
+                replyContext,
+            });
+            await sendSystemPayload(adapter, envelope, {
+                kind: 'system.notice',
+                text: '✅ 服务重启成功！',
+                subtype: 'restarted',
+            });
+            pendingRestartNoticeSent = true;
+            fs.rmSync(pendingFile, { force: true });
+            logger.info(`[Restart] Notification sent via ${pending.channel}`);
+        })();
+        try {
+            await pendingRestartNoticeInFlight;
+        }
+        catch (e) {
+            logger.error('[Restart] Failed to send restart notification:', e);
+        }
+        finally {
+            pendingRestartNoticeInFlight = null;
+        }
+    };
+    const summarizeConnectedChannels = (connected) => {
+        const connectedTypeCount = new Map();
+        const typeOrder = [];
+        for (const inst of channelInstances) {
+            const name = inst.adapter.channelName;
+            if (!connected.includes(name))
+                continue;
+            const type = inst.channelType || name;
+            if (!connectedTypeCount.has(type)) {
+                connectedTypeCount.set(type, 0);
+                typeOrder.push(type);
+            }
+            connectedTypeCount.set(type, connectedTypeCount.get(type) + 1);
+        }
+        return typeOrder
+            .map(type => {
+            const n = connectedTypeCount.get(type);
+            return n === 1 ? type : `${type}×${n}`;
+        })
+            .join(', ');
+    };
+    const markChannelConnected = async (inst) => {
+        const name = inst.adapter.channelName;
+        const key = inst.adapter.channelKey;
+        if (connectedChannels.has(name))
+            return;
+        connectedChannels.add(name);
+        connectedChannels.add(key);
+        const type = inst.channelType || name;
+        eventBus.publish({
+            type: 'channel:connected',
+            channel: type.toLowerCase(),
+            channelName: name,
+            timestamp: Date.now()
+        });
+        // Run async operations in parallel
+        const agent = agentRegistry.resolveByChannel(inst.adapter.channelKey) ?? agentRegistry.resolveByChannel(name);
+        await Promise.all([
+            bootstrapService.tryStartBootstrap({
+                adapter: inst.adapter,
+                channelKey: inst.adapter.channelKey,
+                channelType: inst.channelType || type,
+                source: 'connected',
+            }),
+            agent ? ensureTriggerSchedulerStarted(agent) : Promise.resolve(),
+            Promise.resolve().then(() => sendOnlineNoticeForChannel(inst)),
+            trySendPendingRestartNotice(),
+        ]);
+    };
+    const markChannelDisconnected = (channelName) => {
+        connectedChannels.delete(channelName);
+        const inst = channelInstances.find(candidate => candidate.adapter.channelName === channelName);
+        if (inst)
+            connectedChannels.delete(inst.adapter.channelKey);
+    };
+    // ── 连接所有渠道（后台首连，AUN/任意渠道故障不阻塞 daemon 主流程）──
+    logger.info(`🚀 EvolCore core is ready; connecting ${channelInstances.length} channel(s) in background`);
+    const connectAllPromise = channelLoader.connectAll(channelInstances, {
+        concurrency: 10,
+        onConnected: markChannelConnected,
+        onFailed: (inst, error) => {
+            logger.warn(`[startup] ${inst.adapter.channelName} initial connect failed: ${error}`);
+        },
+    });
+    connectAllPromise.then((connected) => {
+        const channelSummary = summarizeConnectedChannels(connected);
+        logger.info(`✅ ${connected.length} channel(s) connected: ${channelSummary}`);
+        eventBus.publish({
+            type: 'system:started',
+            channels: connected.map(c => c.toLowerCase()),
+            timestamp: Date.now()
+        });
+    }).catch((e) => {
+        logger.warn(`[startup] channel connection task failed unexpectedly: ${e}`);
+    });
+    // Trigger scheduler 与渠道连接解耦：cron 定时任务独立于渠道可用性运行
+    // （触发时若渠道未连，发送侧自行排队/重试）。markChannelConnected 里的
+    // ensureTriggerSchedulerStarted 仅作"尽早启动"优化，此处保证即使渠道首连
+    // 全部失败（如 gateway 宕机），trigger 仍无条件启动。Set 去重，不会重复。
+    ensureDaemonTriggerSchedulerStarted().catch((e) => {
+        logger.warn(`[startup] daemon trigger scheduler start failed for ${daemonTriggerOwner.aid}: ${e}`);
+    });
+    for (const agent of triggerStartupAgents) {
+        ensureTriggerSchedulerStarted(agent).catch((e) => {
+            logger.warn(`[startup] trigger scheduler start failed for ${agent.aid}: ${e}`);
+        });
+    }
+    // ── 控制 AID（daemon 进程身份）：pureIdentity 接入 AUN，独立于 evolagent ──
+    // 证书缺失检测/生成在 CLI 侧（ec start）完成。daemon 是后台进程无终端，
+    // 这里只做兜底：证书缺失时 warn 并继续（AUNChannel 内部后台重连），绝不阻塞。
+    if (daemonCfg.aid) {
+        const aunPath = resolvePaths().root;
+        const certKey = path.join(aunPath, 'AIDs', daemonCfg.aid, 'private', 'key.json');
+        if (!fs.existsSync(certKey)) {
+            logger.warn(`控制 AID 证书缺失：${daemonCfg.aid}（AUN 控制通道后台重连；如需重建运行 ec init）`);
+        }
+    }
+    let controlChannel;
+    if (daemonCfg.aid) {
+        controlChannel = new AUNChannel({
+            aid: daemonCfg.aid,
+            agentName: daemonCfg.aid,
+            channelName: 'control',
+            pureIdentity: true,
+            aunTrace: daemonCfg.debug?.aunTrace ?? defaults.debug?.aunTrace,
+            aunSdkLog: daemonCfg.debug?.aunSdkLog ?? defaults.debug?.aunSdkLog,
+        });
+        // connect() 失败不置空实例：AUNChannel 内部有无限重连（SDK auto_reconnect +
+        // scheduleReconnect），首连失败后台会自愈；保留实例供 status 显示 disconnected。
+        try {
+            await controlChannel.connect();
+            logger.info(`✓ 控制 AID 已连接: ${daemonCfg.aid}`);
+        }
+        catch (e) {
+            logger.warn(`控制 AID 首连失败（后台自动重连，不影响 daemon 主流程）: ${e?.message || e}`);
+        }
+        // ── ECWeb 自动启动 ──
+        // 如果 config.ecweb.enabled，自动拉起 ecweb 服务
+        if (daemonCfg.ecweb?.enabled) {
+            const ecwebPath = path.join(resolvePaths().root, 'ecweb');
+            const ecwebEntry = path.join(ecwebPath, 'dist', 'index.js');
+            if (fs.existsSync(ecwebEntry)) {
+                try {
+                    const ecwebProc = spawn('node', [ecwebEntry], {
+                        cwd: ecwebPath,
+                        detached: true,
+                        stdio: 'ignore',
+                        env: { ...process.env, EVOLCORE_HOME: resolvePaths().root }
+                    });
+                    ecwebProc.unref();
+                    logger.info(`✓ ECWeb 已启动 (PID: ${ecwebProc.pid})`);
+                    onShutdown(() => {
+                        try {
+                            if (ecwebProc.pid)
+                                platform.killProcess(ecwebProc.pid, true);
+                            logger.info(`✓ ECWeb 已停止`);
+                        }
+                        catch { }
+                    });
+                }
+                catch (e) {
+                    logger.warn(`ECWeb 启动失败: ${e?.message || e}`);
+                }
+            }
+            else {
+                logger.warn(`ECWeb 配置已启用但未找到 ${ecwebEntry}`);
+            }
+        }
+        // 控制 AID 接收 owner 指令：
+        // 1. /pair — ECWeb 配对码（文本快路径）
+        // 2. menu.* JSON — 路由到 cmdHandler.execMenuForControl（进程级 + 全量权限）
+        // 发送方身份由 AUN X.509 证书链验证，非 owner 完全静默。
+        controlChannel.onMessage(async (opts) => {
+            try {
+                const text = (opts.content || '').trim();
+                let parsed;
+                try {
+                    parsed = JSON.parse(text);
+                }
+                catch {
+                    parsed = null;
+                }
+                if (bindService && parsed?.type === 'bind.request') {
+                    const response = await bindService.handleRequest(parsed, opts.peerId);
+                    if (response) {
+                        // 用 sendStructured 直发 typed payload（payload.type='bind.response'），
+                        // 不能用 sendMessage——它会把内容包成 {type:'text', text:...}，App 无法识别。
+                        // encrypted 跟随入站请求：bind.response 与 bind.request 的加密/明文对称。
+                        await controlChannel.sendStructured(opts.channelId, response, { metadata: { encrypted: opts.encrypted } });
+                    }
+                    return;
+                }
+                const menuControl = parseMenuControl(text);
+                const isRoleMenu = menuControl.isMenu
+                    && (menuControl.name === 'role' || menuControl.request.cmd === '/role');
+                if (menuControl.isMenu && !hasValidMenuId(menuControl)) {
+                    logger.warn(`[ControlMenu] dropped malformed request without id type=${menuControl.type}`);
+                    return;
+                }
+                if (menuControl.isMenu && !isRoleMenu && !isProcessLevelOwner(opts.peerId, processLevelOwners)) {
+                    const response = menuFailure({ id: menuControl.id, ...(menuControl.name?.trim() ? { name: menuControl.name } : {}) }, { code: 'ROLE_ACCESS_DENIED', message: 'Current identity cannot access the control channel' });
+                    await controlChannel.sendStructured(opts.channelId, response, { metadata: { encrypted: opts.encrypted } });
+                    return;
+                }
+                if (!isRoleMenu && !isProcessLevelOwner(opts.peerId, processLevelOwners)) {
+                    logger.debug(`控制 AID 收到非 owner 消息，忽略: from=${opts.peerId}`);
+                    return;
+                }
+                if (text.toLowerCase() === '/pair') {
+                    const port = daemonCfg.ecweb?.port ?? 42705;
+                    const pair = await fetchEcwebPairCode(port);
+                    let reply;
+                    if (pair) {
+                        const mins = Math.max(0, Math.round((pair.expiresAt - Date.now()) / 60000));
+                        reply = `ECWeb 配对码：${pair.code}（约 ${mins} 分钟内有效）\n在浏览器打开 ECWeb 后输入此码登录`;
+                    }
+                    else {
+                        reply = 'ECWeb 未运行或暂不可达。请在主机运行 ec watch web 启动后重试。';
+                    }
+                    await controlChannel.sendMessage(opts.channelId, reply);
+                    return;
+                }
+                // menu.* JSON 路由：owner 已在上方校验，转交 execMenuForControl（fromControlChannel=true）
+                if (menuControl.isMenu) {
+                    const validationError = validateMenuRequest(menuControl.request);
+                    if (validationError) {
+                        await controlChannel.sendStructured(opts.channelId, menuFailure({ id: menuControl.id, ...(menuControl.name?.trim() ? { name: menuControl.name } : {}) }, validationError), { metadata: { encrypted: opts.encrypted } });
+                        return;
+                    }
+                    const deduped = await controlMenuDeduper.execute([opts.channelId, opts.peerId, menuControl.id].join('\u001f'), menuPayloadFingerprint(menuControl.raw), () => cmdHandler.execMenuForControl(parsed, opts.peerId));
+                    const response = 'conflict' in deduped
+                        ? menuFailure({ id: menuControl.id, ...(menuControl.name?.trim() ? { name: menuControl.name } : {}) }, { code: 'CONFLICT', message: 'Request ID was already used with a different payload' })
+                        : deduped.value;
+                    // 同 bind.response：sendStructured 直发 typed payload（payload.type='menu.response'），
+                    // 不能用 sendMessage（会包成 {type:'text',...}）；encrypted 跟随入站请求保持对称。
+                    await controlChannel.sendStructured(opts.channelId, response, { metadata: { encrypted: opts.encrypted } });
+                    return;
+                }
+                // owner 发的其他内容：提示可用指令
+                await controlChannel.sendMessage(opts.channelId, '可用指令：/pair（获取 ECWeb 登录配对码）');
+            }
+            catch (e) {
+                logger.warn(`控制 AID 消息处理失败: ${e?.message || e}`);
+            }
+        });
+        // ── Service Proxy：把本地服务（ecweb 等）通过控制 AID 暴露到 AUN 网络 ──
+        // 挂在控制 AUNChannel 上，动态解引用其 client（规避重连换 client）。
+        // 失败只 warn，不影响 daemon 主流程。
+        if (daemonCfg.serviceProxy?.enabled && daemonCfg.aid) {
+            // 短暂延迟确保控制 channel 完全就绪
+            const channel = controlChannel;
+            const aid = daemonCfg.aid;
+            const config = daemonCfg.serviceProxy;
+            setTimeout(() => {
+                if (!channel)
+                    return;
+                const proxyHandle = startServiceProxy(channel, aid, config);
+                if (proxyHandle) {
+                    onShutdown(() => proxyHandle.stop());
+                }
+            }, 500);
+        }
+    }
+    // 统一 channel:health 跨通道通知（仅 auth_error）
+    // 按 (channelType, ownerId) 去重，避免同类型多实例重复通知
+    eventBus.subscribe('channel:error', (event) => {
+        if (event.type !== 'channel:error' || event.status !== 'auth_error')
+            return;
+        const sourceChannelType = event.channel;
+        const sourceChannelName = event.channelName || sourceChannelType;
+        const msg = event.message;
+        logger.error(`[ChannelHealth] ${sourceChannelName} auth_error: ${msg}`);
+        const notified = new Set(); // channelType 去重（同类型只通知一次）
+        for (const other of channelInstances) {
+            const otherType = other.channelType || other.adapter.channelName;
+            if (otherType === sourceChannelType)
+                continue; // 跳过同类型通道
+            if (notified.has(otherType))
+                continue; // 同类型已通知过
+            const owningAgent = agentRegistry.resolveByChannel(other.adapter.channelKey);
+            const ownerId = owningAgent
+                ? getFirstStaticAgentOwner(owningAgent.aid)
+                : undefined;
+            if (!ownerId)
+                continue;
+            notified.add(otherType);
+            const envelope = buildEnvelope({
+                taskId: `system-channel-down-${crypto.randomBytes(5).toString('hex')}`,
+                channel: other.adapter.channelKey,
+                channelId: ownerId,
+                agentName: owningAgent?.aid || 'evolcore',
+            });
+            sendSystemPayload(other.adapter, envelope, {
+                kind: 'system.error',
+                text: msg,
+                subtype: 'channel_down',
+                recoverable: false,
+            }).catch(err => {
+                logger.error(`[ChannelHealth] Failed to notify ${other.adapter.channelName} owner:`, err);
+            });
+        }
+    });
+    // 先恢复消息队列。若某个 session 有原始 active/pending 消息，下面的泛化 resume 会跳过它。
+    messageQueue.restorePersisted(false);
+    const droppedTriggerSessionIds = new Set(messageQueue.consumeDroppedTriggerSessionIds());
+    // runnableAgents() only returns pre-start `stopped` agents. Reuse the stable
+    // startup snapshot because channel connection may already mark them running.
+    const recoveryAids = triggerStartupAgents.map(agent => agent.aid);
+    for (const aid of recoveryAids) {
+        try {
+            const expired = handoffRuntime.expireQueued([aid]);
+            if (expired > 0)
+                logger.info(`[Handoff] expired ${expired} stale queued delivery item(s) for ${aid}`);
+        }
+        catch (error) {
+            logger.error(`[Handoff] startup TTL cleanup failed for ${aid}:`, error);
+        }
+    }
+    const recoverHandoffsAndStartRestored = async () => {
+        try {
+            const outcomes = await Promise.allSettled(recoveryAids.map(aid => handoffRuntime.recover([aid])));
+            outcomes.forEach((outcome, index) => {
+                if (outcome.status === 'rejected') {
+                    logger.error(`[Handoff] startup recovery failed for ${recoveryAids[index]}:`, outcome.reason);
+                }
+            });
+        }
+        finally {
+            messageQueue.startRestored();
+        }
+    };
+    void connectAllPromise
+        .then(recoverHandoffsAndStartRestored, recoverHandoffsAndStartRestored)
+        .catch(error => logger.error('[Handoff] startup recovery coordinator failed:', error));
+    // 恢复重启前未完成的会话。这里是兜底路径：仅当队列文件没有原始消息时，才注入恢复提示。
+    const pendingSessions = sessionManager.getPendingProcessingSessions();
+    if (pendingSessions.length > 0) {
+        logger.info(`[Resume] Found ${pendingSessions.length} pending session(s) from before restart`);
+        for (const session of pendingSessions) {
+            if (droppedTriggerSessionIds.has(session.id)) {
+                logger.info(`[Resume] session ${session.id}: dropped stale Trigger execution, clearing processing without resume`);
+                sessionManager.clearProcessing(session.id);
+                continue;
+            }
+            if (messageQueue.isProcessing(session.id) || messageQueue.getQueueLength(session.id) > 0) {
+                logger.info(`[Resume] session ${session.id}: persisted queue already restored, skipping generic resume`);
+                continue;
+            }
+            if (!session.agentSessionId) {
+                sessionManager.clearProcessing(session.id);
+                continue;
+            }
+            // 复合键：${aid}::${baseagent}，从 channel 反查 self-agent
+            const owningAgent = agentRegistry.resolveByChannel(session.channel);
+            if (!owningAgent) {
+                logger.warn(`[Resume] session ${session.id}: channel "${session.channel}" not routable, skipping`);
+                sessionManager.clearProcessing(session.id);
+                continue;
+            }
+            const evolName = owningAgent.aid;
+            const baseagentName = session.baseagent || primaryBaseagent;
+            const agent = agentMap.get(`${evolName}::${baseagentName}`) || agentMap.get(primaryRunnerKey);
+            if (!agent) {
+                sessionManager.clearProcessing(session.id);
+                continue;
+            }
+            logger.info(`[Resume] Resuming session: ${session.id} (agent: ${evolName}::${baseagentName})`);
+            const parsedResumeKey = tryParseChannelKey(session.channel);
+            const resumeSelfAID = session.selfAID || parsedResumeKey?.selfAID;
+            const resumeMessage = {
+                channel: session.channel,
+                channelType: session.channelType || parsedResumeKey?.type,
+                selfAID: resumeSelfAID,
+                channelId: session.channelId,
+                content: '服务已重启，请继续之前未完成的任务。',
+                timestamp: Date.now(),
+                peerId: '',
+                threadId: session.threadId || undefined,
+                replyContext: session.metadata?.replyContext,
+            };
+            // 清除状态后入队（processMessage 会重新标记）
+            sessionManager.clearProcessing(session.id);
+            messageQueue.enqueue(session.id, resumeMessage, session.projectPath, { sessionKeyField: session.sessionKey, selfAID: resumeSelfAID }).catch(err => {
+                logger.error(`[Resume] Failed to resume session ${session.id}:`, err);
+            });
+        }
+    }
+    // IPC server — 供 CLI 查询实时状态 + Agent ctl 指令执行
+    const ipcServer = new IpcServer(resolvePaths().socket, () => {
+        const channels = {};
+        const channelsByType = {};
+        for (const inst of channelInstances) {
+            const name = inst.adapter.channelName;
+            const status = inst.channel.getStatus?.() ?? { connected: true };
+            const channelType = inst.channelType || name;
+            channels[name] = { ...status, channelType };
+            if (!channelsByType[channelType])
+                channelsByType[channelType] = [];
+            channelsByType[channelType].push(name);
+        }
+        const snap = statsCollector.getSnapshot();
+        const agentListForStatus = agentRegistry.list();
+        return {
+            pid: process.pid,
+            uptime: snap.uptimeMs,
+            controlPlane: {
+                ready: true,
+                owned: processLevelOwners.length > 0,
+            },
+            agentRuntime: {
+                state: agentRuntimeState,
+                runnableAgents: agentListForStatus.filter((a) => a.status !== 'error' && a.status !== 'disabled').length,
+                runningAgents: agentListForStatus.filter((a) => a.status === 'running').length,
+                ...(agentRuntimeError ? { error: agentRuntimeError } : {}),
+            },
+            channels,
+            channelsByType,
+            queue: {
+                pending: messageQueue.getGlobalQueueLength(),
+                processing: messageQueue.getGlobalProcessingCount(),
+            },
+            stats: {
+                received: snap.lastHour.received,
+                sent: snap.lastHour.sent,
+                completed: snap.lastHour.completed,
+                errors: snap.lastHour.errors,
+                avgResponseMs: snap.lastHour.avgResponseMs,
+            },
+            controlAid: daemonCfg.aid
+                ? { aid: daemonCfg.aid, connected: controlChannel?.getAidState().status === 'connected' }
+                : undefined,
+        };
+    }, async (cmd, sessionId, delegationToken) => {
+        const delegation = agentDelegationRegistry.validate(delegationToken, sessionId);
+        if (!delegation.ok)
+            return { ok: false, code: delegation.code, error: delegation.reason };
+        return cmdHandler.handleCtl(cmd, sessionId);
+    });
+    // M3: direct call (not cast) — wire EvolAgentRegistry into IPC for evolagent.* handlers
+    ipcServer.setAgentRegistry(agentRegistry);
+    ipcServer.setDingtalkContactBindExecutor({
+        register: (cmd) => registerPendingDingtalkContactBind(cmd),
+    });
+    ipcServer.setWecomContactBindExecutor({
+        register: (cmd) => registerPendingWecomContactBind(cmd),
+    });
+    ipcServer.setMenuExecutor((payload, auth) => cmdHandler.execMenuForEcweb(payload, auth));
+    ipcServer.setConfigOperationExecutor((argv, sessionId, delegationToken) => cmdHandler.handleConfigOperation(argv, sessionId, delegationToken));
+    ipcServer.setContactOperationExecutor((argv, sessionId, delegationToken) => cmdHandler.handleContactOperation(argv, sessionId, delegationToken));
+    cmdHandler.setDaemonStatusProvider(() => {
+        const aidState = controlChannel?.getAidState?.();
+        return {
+            aid: daemonCfg.aid ?? null,
+            aun: aidState ? {
+                connected: aidState.status === 'connected',
+                status: aidState.status,
+                reconnectCount: aidState.reconnectCount ?? 0,
+                flapCount: aidState.flapCount ?? 0,
+                ...(aidState.lastError ? { lastError: String(aidState.lastError).slice(0, 80) } : {}),
+                ...(aidState.kickDetail?.reason ? { kickReason: String(aidState.kickDetail.reason).slice(0, 80) } : {}),
+            } : {
+                connected: false,
+                status: daemonCfg.aid ? 'disconnected' : 'disabled',
+            },
+        };
+    });
+    if (bindService) {
+        ipcServer.setBindExecutor({
+            begin: (cmd) => bindService.begin(cmd),
+            status: (taskId) => bindService.status(taskId),
+            cancel: (taskId) => bindService.cancel(taskId),
+        });
+    }
+    // 注入 AUN AID 状态聚合器：遍历所有 aun 类型 channel，调 getAidState() 收集
+    ipcServer.setAunAidProvider(() => {
+        const out = [];
+        for (const inst of channelInstances) {
+            if (inst.channelType !== 'aun')
+                continue;
+            const ch = inst.channel;
+            if (typeof ch?.getAidState === 'function') {
+                try {
+                    const aidState = ch.getAidState();
+                    // 增强：添加队列状态
+                    const agentName = aidState.agentName || aidState.aid;
+                    const processing = messageQueue.getProcessingCountByAgent(agentName);
+                    const queued = messageQueue.getQueueLengthByAgent(agentName);
+                    out.push({
+                        ...aidState,
+                        queueStatus: { processing, queued }
+                    });
+                }
+                catch { /* ignore */ }
+            }
+        }
+        return out;
+    });
+    // 注入 Per-AID 统计收集器到所有 AUN channel 实例
+    for (const inst of channelInstances) {
+        if (inst.channelType !== 'aun')
+            continue;
+        const ch = inst.channel;
+        if (typeof ch?.setAidStatsCollector === 'function') {
+            ch.setAidStatsCollector(aidStatsCollector);
+        }
+    }
+    // 注入 Per-AID 统计 IPC provider
+    aidStatsCollector.setQueueStatsProvider((agentName) => ({
+        processing: messageQueue.getProcessingCountByAgent(agentName),
+        queued: messageQueue.getQueueLengthByAgent(agentName),
+        muted: messageQueue.isAgentMuted(agentName),
+    }));
+    ipcServer.setAunAidStatsProvider(() => aidStatsCollector.getAllSnapshots());
+    ipcServer.setAunAidStatsRecorder((params) => {
+        aidStatsCollector.recordOutbound(params.aid, params.toPeer, Buffer.byteLength(params.text || '', 'utf-8'), params.text, false, params.encrypt, params.chatmode, 'send');
+    });
+    ipcServer.setTaskRuntimeContextProvider(({ sessionId }) => responseEngine.getTaskRuntimeContext(sessionId));
+    ipcServer.setHandoffReturnExecutor((params) => responseEngine.returnHandoffResult(params));
+    ipcServer.setHandoffStatusExecutor(async (params) => {
+        if (!params.sessionId)
+            return { ok: false, code: 'HANDOFF_CALL_SESSION_REQUIRED', error: 'current session is required' };
+        const runtime = responseEngine.getTaskRuntimeContext(params.sessionId);
+        const session = await sessionManager.getSessionById(params.sessionId);
+        const selfAid = runtime?.selfAid || session?.selfAID;
+        if (!selfAid)
+            return { ok: false, code: 'HANDOFF_NOT_FOUND', error: 'handoff not found' };
+        return handoffRuntime.status(selfAid, params.handoffId)
+            ?? { ok: false, code: 'HANDOFF_NOT_FOUND', error: 'handoff not found' };
+    });
+    const resolveHandoffQueryAid = async (params) => {
+        if (params.sessionId) {
+            const runtime = responseEngine.getTaskRuntimeContext(params.sessionId);
+            const session = await sessionManager.getSessionById(params.sessionId);
+            const selfAid = runtime?.selfAid || session?.selfAID;
+            if (!selfAid) {
+                return { ok: false, code: 'HANDOFF_CALL_SESSION_INVALID', error: 'current session is invalid' };
+            }
+            if (params.agent && params.agent !== selfAid) {
+                return { ok: false, code: 'HANDOFF_AGENT_SCOPE_MISMATCH', error: 'agent does not match the current session' };
+            }
+            return { ok: true, aid: selfAid };
+        }
+        if (!params.agent) {
+            return { ok: false, code: 'HANDOFF_AGENT_REQUIRED', error: '--agent is required outside a task context' };
+        }
+        if (!agentRegistry.get(params.agent)) {
+            return { ok: false, code: 'HANDOFF_AGENT_NOT_FOUND', error: `agent not found: ${params.agent}` };
+        }
+        return { ok: true, aid: params.agent };
+    };
+    ipcServer.setHandoffListExecutor(async (params) => {
+        const scope = await resolveHandoffQueryAid(params);
+        if (!scope.ok)
+            return scope;
+        return handoffRuntime.listHandoffs({
+            selfAid: scope.aid,
+            state: params.state,
+            sessionId: params.filterSessionId,
+            limit: params.limit,
+        });
+    });
+    ipcServer.setHandoffTraceExecutor(async (params) => {
+        const scope = await resolveHandoffQueryAid(params);
+        if (!scope.ok)
+            return scope;
+        return handoffRuntime.traceHandoff(scope.aid, params.handoffId, params.limit)
+            ?? { ok: false, code: 'HANDOFF_NOT_FOUND', error: 'handoff not found' };
+    });
+    ipcServer.setAunMsgSender(async (params) => {
+        const runtimeCausation = params.originSessionId
+            ? responseEngine.getTaskRuntimeContext(params.originSessionId)?.causation
+            : undefined;
+        const delegation = authorizeDelegatedAunMsgSend(agentDelegationRegistry, {
+            delegationToken: params.delegationToken,
+            sessionId: params.originSessionId,
+            messageId: params.originMessageId,
+            aid: params.aid,
+            to: params.to,
+            scope: params.scope,
+            action: params.file ? 'file' : 'send',
+        });
+        if (!delegation.ok) {
+            return { ok: false, error: delegation.reason, code: delegation.code };
+        }
+        const inst = channelInstances.find((candidate) => {
+            if (candidate.channelType !== 'aun')
+                return false;
+            const ch = candidate.channel;
+            try {
+                const aidState = typeof ch?.getAidState === 'function' ? ch.getAidState() : null;
+                if (aidState?.aid === params.aid)
+                    return true;
+                if (typeof ch?.getAid === 'function' && ch.getAid() === params.aid)
+                    return true;
+            }
+            catch { /* ignore */ }
+            return false;
+        });
+        const ch = inst?.channel;
+        if (!ch) {
+            return { ok: false, error: `AUN channel not found for ${params.aid}`, code: 'AUN_CHANNEL_NOT_FOUND' };
+        }
+        const targetIsGroup = typeof ch.isGroupId === 'function' && ch.isGroupId(params.to);
+        if ((params.scope === 'group') !== targetIsGroup) {
+            return { ok: false, error: 'AUN target does not match the delegated send scope', code: 'UNSUPPORTED_TARGET' };
+        }
+        let payload = params.payload;
+        if (params.file) {
+            if (isHClassPath(params.file.filePath)) {
+                return {
+                    ok: false,
+                    error: 'H-class protected files cannot be uploaded by an agent task',
+                    code: 'H_CLASS_PROTECTED',
+                };
+            }
+            if (typeof ch.buildDaemonFilePayload !== 'function') {
+                return { ok: false, error: 'AUN channel does not support daemon file uploads', code: 'AUN_FILE_UNSUPPORTED' };
+            }
+            try {
+                payload = await ch.buildDaemonFilePayload(params.file);
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    code: error?.code ?? 'AUN_FILE_UPLOAD_FAILED',
+                };
+            }
+        }
+        if (!payload) {
+            return { ok: false, error: 'message payload is required', code: 'INVALID_PAYLOAD' };
+        }
+        if (params.thread && typeof payload.thread_id !== 'string') {
+            payload = { ...payload, thread_id: params.thread };
+        }
+        if (params.scope === 'group' && params.mentions?.length) {
+            payload = { ...payload, mentions: params.mentions };
+        }
+        let targetSessionId;
+        if (params.originSessionId && params.originMessageId) {
+            try {
+                const created = await handoffRuntime.createOutbound({
+                    selfAid: params.aid,
+                    to: params.to,
+                    originSessionId: params.originSessionId,
+                    originMessageId: params.originMessageId,
+                    payload,
+                    encrypt: params.encrypt === true,
+                    thread: params.thread,
+                    targetChatType: params.scope === 'group' ? 'group' : 'private',
+                    explicitReturnPolicy: params.returnPolicy,
+                    originAuthorization: {
+                        actorId: delegation.grant.actorId,
+                        channelKey: delegation.grant.channel,
+                        channelType: delegation.grant.channelType,
+                        chatType: delegation.grant.chatType,
+                        peerKey: delegation.grant.peerKey,
+                    },
+                    causation: runtimeCausation,
+                });
+                targetSessionId = created.targetSession.id;
+                if (created.crossSession && created.handoff) {
+                    return {
+                        ok: true,
+                        status: created.handoff.state === 'target_sent' ? 'delivered' : 'queued',
+                        message_id: created.handoff.target_message_id ?? undefined,
+                        handoff_id: created.handoff.handoff_id,
+                        target_session_id: created.targetSession.id,
+                    };
+                }
+                if (params.scope === 'msg' && !payload.ref_message_id) {
+                    payload.ref_message_id = params.originMessageId;
+                }
+            }
+            catch (error) {
+                const code = error?.code;
+                const handoffId = error?.handoffId
+                    ?? error?.blockingHandoffId;
+                return {
+                    ok: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    code,
+                    ...(handoffId ? { handoff_id: handoffId } : {}),
+                };
+            }
+        }
+        if (params.scope === 'group') {
+            if (typeof ch.sendDaemonGroupMsg !== 'function') {
+                return { ok: false, error: 'AUN channel does not support daemon group sends', code: 'AUN_GROUP_UNSUPPORTED' };
+            }
+            return await ch.sendDaemonGroupMsg({
+                groupId: params.to,
+                payload,
+                mentions: params.mentions,
+                encrypt: params.encrypt,
+                log: params.log ? { ...params.log, sessionId: targetSessionId ?? params.log.sessionId } : undefined,
+            });
+        }
+        if (typeof ch.sendDaemonMsg !== 'function') {
+            return { ok: false, error: 'AUN channel does not support daemon private sends', code: 'AUN_MSG_UNSUPPORTED' };
+        }
+        return await ch.sendDaemonMsg({
+            to: params.to,
+            payload,
+            encrypt: params.encrypt,
+            causation: runtimeCausation,
+            log: params.log ? { ...params.log, sessionId: targetSessionId ?? params.log.sessionId } : undefined,
+        });
+    });
+    // ── Reload hooks: enable agentRegistry.reload() to drain/disconnect/restart channels ──
+    const reloadHooks = buildReloadHooks({
+        channelLoader,
+        channelInstances,
+        registerChannelInstance,
+        unregisterChannelInstance: (channelName) => {
+            markChannelDisconnected(channelName);
+            processor.unregisterChannel(channelName);
+            cmdHandler.unregisterChannel(channelName);
+            msgBridge.removeChannel(channelName);
+        },
+        onChannelStarted: (inst) => {
+            // startChannel 重建渠道时重新注入 AidStatsCollector（与 hot-load 路径对齐）
+            if (inst.channelType === 'aun') {
+                const ch = inst.channel;
+                if (typeof ch?.setAidStatsCollector === 'function')
+                    ch.setAidStatsCollector(aidStatsCollector);
+            }
+        },
+        onChannelConnected: markChannelConnected,
+        messageQueue,
+        handoffRuntime,
+    });
+    // Make reload hooks accessible to IPC handler & ctl handler (both run in this process)
+    globalThis.__evolcore_reloadHooks = reloadHooks;
+    // Hot-load handler: dynamically add a new agent at runtime
+    globalThis.__evolcore_hotLoadAgent = async (aid) => {
+        handoffRuntime.pauseAgent(aid);
+        let resumed = false;
+        try {
+            agentRuntimeState = 'starting';
+            agentRuntimeError = undefined;
+            const agent = agentRegistry.loadNewAgent(aid);
+            if (!agent) {
+                agentRuntimeState = agentRegistry.runnableAgents().length > 0 ? 'running' : 'error';
+                agentRuntimeError = `Failed to load agent ${aid}`;
+                throw new Error(agentRuntimeError);
+            }
+            const newAgentInstances = agentLoader.createForAgent(agent, {
+                onSessionIdUpdate: async (sessionId, agentSessionId) => {
+                    await sessionManager.updateAgentSessionIdBySessionId(sessionId, agentSessionId);
+                },
+            });
+            for (const inst of newAgentInstances) {
+                agentMap.set(`${inst.evolagentName}::${inst.baseagent}`, inst.agent);
+                inst.agent.setPermissionGateway?.(permissionGateway);
+                inst.agent.setCompactStartCallback?.((sessionId) => {
+                    processor.handleCompactStart(sessionId);
+                });
+            }
+            if (newAgentInstances.length === 0) {
+                agent.status = 'error';
+                agent.error = 'No baseagent runner created for hot-loaded agent';
+                agentRuntimeState = 'error';
+                agentRuntimeError = agent.error;
+                throw new Error(agent.error);
+            }
+            // 创建 channels
+            const instances = await channelLoader.createForAgent(agent);
+            for (const inst of instances) {
+                registerChannelInstance(inst);
+                if (inst.channelType === 'aun') {
+                    const ch = inst.channel;
+                    if (typeof ch?.setAidStatsCollector === 'function')
+                        ch.setAidStatsCollector(aidStatsCollector);
+                }
+                agent.channels.set(inst.adapter.channelKey, inst.adapter);
+                channelInstances.push(inst);
+            }
+            agent.status = 'running';
+            // 连接
+            await channelLoader.connectAll(instances, { onConnected: markChannelConnected });
+            await handoffRuntime.recover([aid]);
+            await ensureTriggerSchedulerStarted(agent);
+            handoffRuntime.resumeAgent(aid);
+            resumed = true;
+            agentRuntimeState = 'running';
+            agentRuntimeError = undefined;
+            logger.info(`[HotLoad] ✓ Agent ${aid} online with ${instances.length} channel(s)`);
+        }
+        finally {
+            if (!resumed)
+                handoffRuntime.resumeAgent(aid);
+        }
+    };
+    // Full resync handler: scan disk, load new agents, unload removed/disabled, reload changed
+    globalThis.__evolcore_resyncAgents = async () => {
+        const { loadAllAgents: scanAgents, loadDefaults: readDefaults } = await import('./config-store.js');
+        const { resolveEffective } = await import('./config/config-manager.js');
+        const freshDefaults = readDefaults();
+        const { agents: diskAgents } = scanAgents();
+        const diskAidSet = new Set(diskAgents.map(a => a.aid));
+        const results = [];
+        // 1. 下线：运行时有但磁盘上没有 / disabled 的
+        for (const [aid, agent] of [...agentRegistry.agents.entries()]) {
+            const diskCfg = diskAgents.find(a => a.aid === aid);
+            if (!diskCfg || diskCfg.enabled === false) {
+                handoffRuntime.pauseAgent(aid);
+                try {
+                    await handoffRuntime.drainAgent(aid);
+                }
+                catch (error) {
+                    handoffRuntime.resumeAgent(aid);
+                    results.push(`⚠ ${aid}: ${error instanceof Error ? error.message : String(error)}`);
+                    continue;
+                }
+                await triggerSchedulers.get(aid)?.stop();
+                triggerSchedulers.delete(aid);
+                // 断开所有 channels
+                for (const chName of agent.channelInstanceNames()) {
+                    const inst = channelInstances.find(i => i.adapter.channelName === chName);
+                    if (inst) {
+                        try {
+                            await inst.disconnect();
+                        }
+                        catch { }
+                        markChannelDisconnected(inst.adapter.channelName);
+                        const idx = channelInstances.indexOf(inst);
+                        if (idx >= 0)
+                            channelInstances.splice(idx, 1);
+                    }
+                }
+                agentRegistry.agents.delete(aid);
+                results.push(`- ${aid} (offline)`);
+                continue;
+            }
+        }
+        // 2. 新增：磁盘上有但运行时没有的
+        for (const cfg of diskAgents) {
+            if (cfg.enabled === false)
+                continue;
+            if (agentRegistry.agents.has(cfg.aid))
+                continue;
+            try {
+                await globalThis.__evolcore_hotLoadAgent(cfg.aid);
+                results.push(`+ ${cfg.aid} (online)`);
+            }
+            catch (e) {
+                results.push(`✗ ${cfg.aid}: ${e?.message || e}`);
+            }
+        }
+        // 3. 已有的：重新 reload（config 可能改了）
+        const hooks = globalThis.__evolcore_reloadHooks;
+        for (const cfg of diskAgents) {
+            if (cfg.enabled === false)
+                continue;
+            if (!agentRegistry.agents.has(cfg.aid))
+                continue;
+            // 只有磁盘上存在且运行时也存在的才 reload
+            try {
+                await agentRegistry.reload(cfg.aid, hooks);
+                const runtimeAgent = agentRegistry.get(cfg.aid);
+                if (runtimeAgent)
+                    await startTriggerScheduler(runtimeAgent);
+                results.push(`↻ ${cfg.aid} (reloaded)`);
+            }
+            catch (e) {
+                results.push(`⚠ ${cfg.aid}: ${e?.message || e}`);
+            }
+        }
+        // 重建 channel index + 清除 kit 缓存
+        invalidateKitCache();
+        agentRegistry.channelIndex.clear();
+        agentRegistry.buildChannelIndex();
+        logger.info(`[Resync] Done: ${results.length} agent(s) processed`);
+        return results;
+    };
+    ipcServer.setStatsProvider(() => statsCollector.getSnapshot());
+    ipcServer.setAgentStatsProvider(() => agentRegistry.list().map((agent) => {
+        const snap = statsCollector.getSnapshot(agent.aid);
+        return {
+            aid: agent.aid,
+            received: snap.lastHour.received,
+            sent: snap.lastHour.sent,
+            completed: snap.lastHour.completed,
+            errors: snap.lastHour.errors,
+            interrupts: snap.lastHour.interrupts,
+            avgResponseMs: snap.lastHour.avgResponseMs,
+            processing: messageQueue.getProcessingCountByAgent(agent.aid),
+            queued: messageQueue.getQueueLengthByAgent(agent.aid),
+            muted: messageQueue.isAgentMuted(agent.aid),
+        };
+    }));
+    // Queue snapshot & action (for ec queue --agent CLI)
+    ipcServer.setQueueSnapshotProvider((params) => {
+        const handle = agentRegistry.get(params.agent);
+        const agentName = handle?.name;
+        if (!agentName)
+            return [];
+        return messageQueue.getQueueItemsByAgent(agentName);
+    });
+    ipcServer.setQueueActionExecutor(async (params) => {
+        const handle = agentRegistry.get(params.agent);
+        const agentName = handle?.name;
+        if (!agentName)
+            return { ok: false, error: `agent not found: ${params.agent}` };
+        switch (params.action) {
+            case 'clear':
+                return { ok: true, cleared: messageQueue.clearByAgent(agentName) };
+            case 'cancel':
+                if (!params.messageId)
+                    return { ok: false, error: 'missing messageId' };
+                return { ok: true, cancelled: messageQueue.cancelMessageById(agentName, params.messageId) };
+            case 'interrupt':
+                if (!params.sessionKey)
+                    return { ok: false, error: 'missing sessionKey' };
+                {
+                    const sessionId = messageQueue.findSessionIdBySessionKey(params.sessionKey);
+                    if (!sessionId)
+                        return { ok: false, error: `session not found: ${params.sessionKey}` };
+                    return { ok: true, interrupted: await messageQueue.interruptBySession(sessionId) };
+                }
+            default:
+                return { ok: false, error: `unknown action: ${params.action}` };
+        }
+    });
+    ipcServer.setTriggerExecutor(async (cmd) => {
+        const schedulerFor = (agentAid) => {
+            const scheduler = triggerSchedulers.get(agentAid);
+            if (!scheduler)
+                throw new Error(`trigger scheduler not found for agent: ${agentAid}`);
+            return scheduler;
+        };
+        const requireAgent = (agentAid) => {
+            if (typeof agentAid !== 'string' || !agentAid)
+                throw new Error('missing agentAid');
+            if (agentAid === daemonTriggerOwner.aid)
+                return agentAid;
+            if (!agentRegistry.get(agentAid))
+                throw new Error(`agent not found: ${agentAid}`);
+            return agentAid;
+        };
+        const authorizeTrigger = async (agentAid, operation, triggerId) => {
+            const actor = await authenticatedTriggerActor(agentAid, cmd.actorSessionId, cmd.delegationToken, cmd.controlToken);
+            if (!actor.control && actor.selfAid !== agentAid) {
+                throw new Error('trigger agent does not match authenticated task agent');
+            }
+            const operationDecision = authorizeOperation({
+                source: actor.control ? 'control' : 'agent-tool',
+                subject: actor.subject,
+                intent: {
+                    operation,
+                    scope: 'relation',
+                    source: actor.control ? 'control' : 'agent-tool',
+                    args: {
+                        self: agentAid,
+                        peer: actor.origin.peerId,
+                        peerKey: actor.subject.peerKey,
+                        ...(triggerId ? { triggerId } : {}),
+                    },
+                },
+            });
+            if (!operationDecision.allow)
+                throw new Error(operationDecision.reason);
+            if (actor.management)
+                return actor;
+            if (!triggerId)
+                return actor;
+            const definition = schedulerFor(agentAid).list({ all: true }).find(trigger => trigger.id === triggerId);
+            if (!definition
+                || definition.origin?.peerId !== actor.origin?.peerId
+                || definition.origin?.channelKey !== actor.origin?.channelKey) {
+                throw new Error('trigger not found or access denied');
+            }
+            return actor;
+        };
+        switch (cmd.type) {
+            case 'trigger.list': {
+                const agentAid = requireAgent(cmd.agentAid);
+                const actor = await authorizeTrigger(agentAid, 'trigger.list');
+                const scheduler = schedulerFor(agentAid);
+                const definitions = scheduler.list({ all: cmd.all === true }).filter(trigger => actor.management
+                    || (trigger.origin?.peerId === actor.origin?.peerId && trigger.origin?.channelKey === actor.origin?.channelKey));
+                return { ok: true, triggers: scheduler.listItems(definitions) };
+            }
+            case 'trigger.show': {
+                const agentAid = requireAgent(cmd.agentAid);
+                if (!cmd.triggerId)
+                    throw new Error('missing triggerId');
+                await authorizeTrigger(agentAid, 'trigger.show', cmd.triggerId);
+                return {
+                    ok: true,
+                    ...schedulerFor(agentAid).show(cmd.triggerId, {
+                        includeScriptPreview: cmd.includeScriptPreview !== false,
+                    }),
+                };
+            }
+            case 'trigger.history': {
+                const agentAid = requireAgent(cmd.agentAid);
+                const limit = cmd.limit === undefined ? 100 : Number(cmd.limit);
+                if (!Number.isInteger(limit) || limit <= 0 || limit > 10_000)
+                    throw new Error('invalid history limit');
+                if (cmd.triggerId !== undefined && (typeof cmd.triggerId !== 'string' || !cmd.triggerId)) {
+                    throw new Error('invalid triggerId');
+                }
+                if (cmd.triggerId)
+                    await authorizeTrigger(agentAid, 'trigger.history', cmd.triggerId);
+                else if (!(await authorizeTrigger(agentAid, 'trigger.history')).management) {
+                    throw new Error('triggerId is required for non-management history access');
+                }
+                return { ok: true, events: schedulerFor(agentAid).history(cmd.triggerId, limit) };
+            }
+            case 'trigger.eventCatalog': {
+                const agentAid = requireAgent(cmd.agentAid);
+                await authorizeTrigger(agentAid, 'trigger.eventCatalog');
+                return { ok: true, ...getEventCatalog({ includeInternal: cmd.includeInternal === true }) };
+            }
+            case 'trigger.create': {
+                const rawDefinition = cmd.definition;
+                if (!rawDefinition || typeof rawDefinition !== 'object' || Array.isArray(rawDefinition)) {
+                    throw new Error('trigger definition must be an object');
+                }
+                const agentAid = requireAgent(rawDefinition.agentAid);
+                const actor = await authorizeTrigger(agentAid, 'trigger.create');
+                const materialized = materializeTriggerCreateBaseagent({ ...rawDefinition, origin: actor.origin }, agentAid);
+                const definition = normalizeTriggerDefinition(materialized);
+                validateTriggerDefinitionForActor(definition, actor);
+                requireAgent(definition.agentAid);
+                validateTriggerFeedbackChannels(definition);
+                const trigger = schedulerFor(definition.agentAid).create(definition, cmd.files ?? [], { enable: cmd.enable });
+                return { ok: true, trigger };
+            }
+            case 'trigger.update': {
+                const agentAid = requireAgent(cmd.agentAid);
+                if (!cmd.triggerId)
+                    throw new Error('missing triggerId');
+                const actor = await authorizeTrigger(agentAid, 'trigger.update', cmd.triggerId);
+                const existing = schedulerFor(agentAid).list({ all: true }).find(trigger => trigger.id === cmd.triggerId);
+                if (!existing)
+                    throw new Error(`trigger not found: ${cmd.triggerId}`);
+                const currentRevision = definitionRevision(existing);
+                if (cmd.expectedRevision !== undefined && cmd.expectedRevision !== currentRevision) {
+                    throw new Error(`trigger revision conflict: expected ${cmd.expectedRevision}, current ${currentRevision}`);
+                }
+                const definition = applyTriggerPatch(existing, cmd.patch);
+                validateTriggerDefinitionForActor(definition, actor);
+                validateTriggerFeedbackChannels(definition);
+                const scheduler = schedulerFor(agentAid);
+                const trigger = scheduler.update(cmd.triggerId, definition);
+                return { ok: true, trigger: scheduler.listItem(trigger), revision: definitionRevision(trigger) };
+            }
+            case 'trigger.setEnabled': {
+                const agentAid = requireAgent(cmd.agentAid);
+                if (!cmd.triggerId)
+                    throw new Error('missing triggerId');
+                if (typeof cmd.enabled !== 'boolean')
+                    throw new Error('missing enabled');
+                await authorizeTrigger(agentAid, 'trigger.setEnabled', cmd.triggerId);
+                const trigger = schedulerFor(agentAid).setEnabled(cmd.triggerId, cmd.enabled);
+                return { ok: true, trigger };
+            }
+            case 'trigger.cancel': {
+                const agentAid = requireAgent(cmd.agentAid);
+                if (!cmd.triggerId)
+                    throw new Error('missing triggerId');
+                await authorizeTrigger(agentAid, 'trigger.cancel', cmd.triggerId);
+                const trigger = schedulerFor(agentAid).cancel(cmd.triggerId);
+                return { ok: true, trigger };
+            }
+            case 'trigger.delete': {
+                const agentAid = requireAgent(cmd.agentAid);
+                if (!cmd.triggerId)
+                    throw new Error('missing triggerId');
+                await authorizeTrigger(agentAid, 'trigger.delete', cmd.triggerId);
+                const trigger = schedulerFor(agentAid).delete(cmd.triggerId);
+                return { ok: true, trigger };
+            }
+            case 'trigger.run': {
+                const agentAid = requireAgent(cmd.agentAid);
+                if (!cmd.triggerId)
+                    throw new Error('missing triggerId');
+                await authorizeTrigger(agentAid, 'trigger.run', cmd.triggerId);
+                const result = await schedulerFor(agentAid).run(cmd.triggerId, {
+                    dryRun: cmd.dryRun === true,
+                    ...(cmd.eventPayload !== undefined ? { eventPayload: cmd.eventPayload } : {}),
+                });
+                return {
+                    ok: result.ok,
+                    result,
+                    runId: result.runId,
+                    triggerId: result.triggerId,
+                    status: result.status,
+                    reason: result.reason,
+                    conflictRunId: result.conflictRunId,
+                    error: result.error,
+                    audit: result.audit,
+                };
+            }
+            default:
+                return { ok: false, error: `unknown trigger command: ${cmd.type}` };
+        }
+    });
+    ipcServer.startCpuTracking();
+    // I3: start IPC server after all hooks/executors/providers are registered.
+    await ipcServer.start();
+    // 写入 ready 信号（Control Plane 已可通过 IPC 查询；channel 连接不阻塞启动判定）
+    const readySignalPath = resolvePaths().readySignal;
+    fs.writeFileSync(readySignalPath, String(Date.now()));
+    logger.info(`✓ Ready signal written: ${readySignalPath}`);
+    // 配置 reload 走 IPC `evolagent.reload` 触发，不再用 watchFile。
+    // 双 rename 原子写下 watchFile 的语义会被破坏，且新结构有 N 个 config.json 要监控；
+    // 显式触发更可控。
+    // 优雅关闭
+    let shutdownSignal = 'unknown';
+    const shutdown = async (signal) => {
+        if (signal)
+            shutdownSignal = signal;
+        const pid = process.pid;
+        const ppid = process.ppid;
+        logger.info(`\n\nShutting down gracefully... (signal=${shutdownSignal}, pid=${pid}, ppid=${ppid})`);
+        ipcServer.stopCpuTracking();
+        ipcServer.stop();
+        bindService?.stopCleanup();
+        await permissionGateway.cancelAllPending('daemon_restart');
+        await Promise.all([...triggerSchedulers.values()].map(scheduler => scheduler.waitForIdle(5_000)));
+        await Promise.all([...triggerSchedulers.values()].map(scheduler => scheduler.stop()));
+        eventBus.publish({
+            type: 'system:shutdown',
+            timestamp: Date.now()
+        });
+        // 断开插件系统的渠道
+        await channelLoader.disconnectAll(channelInstances);
+        for (const inst of channelInstances) {
+            const type = inst.channelType || inst.adapter.channelName;
+            eventBus.publish({ type: 'channel:disconnected', channel: type, channelName: inst.adapter.channelName, reason: 'shutdown' });
+        }
+        // 断开控制 AID（daemon 进程身份）
+        if (controlChannel) {
+            try {
+                await controlChannel.disconnect();
+            }
+            catch { /* ignore */ }
+        }
+        sessionManager.close();
+        removeAll();
+        logger.info('✓ Shutdown complete');
+        process.exit(0);
+    };
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    // 全局错误处理：防止未捕获的 WebSocket 错误导致进程崩溃
+    // 特别是 fastaun SDK 在连接超时时，WebSocket 可能发出未被监听的 'error' 事件
+    process.on('uncaughtException', (error) => {
+        // 检查是否是 WebSocket 连接超时相关错误
+        const isWsError = error.message?.includes('WebSocket was closed before the connection was established');
+        const isFastaunError = error.stack?.includes('@agentunion/fastaun');
+        if (isWsError || isFastaunError) {
+            logger.warn(`Caught WebSocket connection error (non-fatal): ${error.message}`);
+            logger.debug(`WebSocket error stack: ${error.stack}`);
+            // 不退出进程，让 AUN 重连机制处理
+            return;
+        }
+        // 其他未捕获错误仍然是致命的
+        logger.error('Uncaught exception:', error);
+        console.error('Uncaught exception:', error);
+        shutdown('uncaughtException');
+    });
+    process.on('unhandledRejection', (reason) => {
+        logger.error('Unhandled promise rejection:', reason);
+        console.error('Unhandled promise rejection:', reason);
+        // Promise rejection 不立即退出，记录后继续运行
+    });
+    // 兜底：进程退出前同步删除 instance 文件（防 async shutdown 未完成就被杀）
+    process.on('exit', () => {
+        removeAll();
+    });
+}
+// 仅在直接执行时启动；导入此模块（如单元测试）时不触发 main()。
+import { isMainScript, onShutdown, commandExists } from './utils/cross-platform.js';
+if (isMainScript(import.meta.url)) {
+    main().catch((error) => {
+        const msg = `Fatal error: ${error?.stack || error}`;
+        logger.error('Fatal error:', error);
+        console.error(msg); // ensure it lands in stdout.log for self-heal diagnostics
+        process.exit(1);
+    });
+}