evolcore 0.0.29 → 0.0.30

package/dist/core/agent-runtime.js

@@ -0,0 +1,435 @@
+import { buildReloadHooks } from './channel-loader.js';
+import { AgentReloadBusyError, AgentReloadCoordinator } from './agent-reload-coordinator.js';
+import { detectDuplicates } from './evolagent-registry.js';
+import { createRunnerReloadTransaction, disposeAgentInstances } from './runner-reload-transaction.js';
+import { ConfigTarget, read as readConfig } from '../config/config-manager.js';
+import { invalidateKitCache } from '../eck/kit-renderer.js';
+import { logger } from '../utils/logger.js';
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths } from '../paths.js';
+import { loadDaemonConfig } from '../config-store.js';
+import { AgentInitializationService, readInitialization } from '../cli/agent-create.js';
+export function loadStartupAgentRegistry(agentRegistry) {
+    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 entry of skipped)
+                logger.warn(`  - ${entry.dirName}: ${entry.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)}`);
+        }
+    }
+    for (const duplicate of detectDuplicates(agentRegistry.runnableAgents())) {
+        const owners = duplicate.agents.map(owner => `${owner.aid}(${owner.channelName})`).join(', ');
+        logger.warn(`⚠ Duplicate channel credential: ${duplicate.fingerprint} claimed by ${owners}.`);
+    }
+    const primaryAgent = agentRegistry.runnableAgents()[0];
+    const runtimeStatus = { state: primaryAgent ? 'starting' : 'empty' };
+    if (!primaryAgent && agentInfos.length > 0) {
+        runtimeStatus.state = 'error';
+        runtimeStatus.error = 'No runnable self-agent (all are error/disabled).';
+        logger.warn(`[startup] ${runtimeStatus.error} Control Plane will remain available.`);
+    }
+    return { primaryAgent, runtimeStatus };
+}
+export async function createStartupAgentRunners({ agentRegistry, agentLoader, sessionManager, primaryAgent, }) {
+    const creationErrors = [];
+    const agentInstances = await agentLoader.createAll(agentRegistry, {
+        onSessionIdUpdate: async (sessionId, agentSessionId, context) => (await sessionManager.updateAgentSessionIdBySessionId(sessionId, agentSessionId, context?.turn)),
+    }, creationErrors);
+    const agentMap = new Map();
+    for (const instance of agentInstances) {
+        agentMap.set(`${instance.evolagentName}::${instance.baseagent}`, instance.agent);
+    }
+    const primaryBaseagent = primaryAgent?.baseagent ?? 'claude';
+    const primaryRunnerKey = primaryAgent ? `${primaryAgent.aid}::${primaryBaseagent}` : '<empty>::claude';
+    const agentRunner = primaryAgent ? agentMap.get(primaryRunnerKey) : agentInstances[0]?.agent;
+    let runtimeError;
+    if (primaryAgent && !agentRunner) {
+        const primaryCreationErrors = creationErrors.filter(error => error.evolagentName === primaryAgent.name);
+        const creationDetail = primaryCreationErrors.length > 0
+            ? primaryCreationErrors.map(({ baseagent, message }) => `${baseagent}: ${message}`).join('; ')
+            : `active_baseagent=${primaryAgent.config.active_baseagent ?? '(unset)'}, configured=${Object.keys(primaryAgent.config.baseagents ?? {}).join(',') || '(none)'}`;
+        runtimeError = primaryCreationErrors.length > 0
+            ? creationDetail
+            : `No agent runner created for ${primaryAgent.name}: ${creationDetail}`;
+        primaryAgent.status = 'error';
+        primaryAgent.error = runtimeError;
+        logger.error(runtimeError);
+    }
+    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(', ')})`);
+    }
+    return { agentInstances, agentMap, primaryBaseagent, primaryRunnerKey, runtimeError };
+}
+export async function completeStartupAgentRuntime(agentRegistry, current) {
+    try {
+        const { watchAgentSkills } = await import('./skill/startup.js');
+        for (const info of agentRegistry.list()) {
+            if (info.status === 'running')
+                watchAgentSkills(info.aid);
+        }
+    }
+    catch (error) {
+        logger.warn(`[skill] agent 监控注册失败: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (agentRegistry.list().some(info => info.status === 'running')) {
+        return { state: 'running', error: undefined };
+    }
+    if (agentRegistry.runnableAgents().length === 0 && agentRegistry.list().length === 0) {
+        return { ...current, state: 'empty' };
+    }
+    if (current.state === 'starting') {
+        return { state: 'error', error: current.error ?? 'No runnable self-agent reached running state.' };
+    }
+    return current;
+}
+export function createAgentReloadRuntime({ agentRegistry, agentLoader, sessionManager, agentMap, permissionGateway, processor, channelLoader, channelInstances, registerChannelInstance, unregisterRuntimeChannel, markChannelConnected, bootstrapService, aidStatsCollector, handoffRuntime, messageQueue, }) {
+    const reloadHooks = buildReloadHooks({
+        channelLoader,
+        channelInstances,
+        registerChannelInstance,
+        unregisterChannelInstance: unregisterRuntimeChannel,
+        onChannelStarted: instance => {
+            if (instance.channelType === 'aun') {
+                const channel = instance.channel;
+                if (typeof channel?.setAidStatsCollector === 'function')
+                    channel.setAidStatsCollector(aidStatsCollector);
+            }
+        },
+        onChannelConnected: markChannelConnected,
+        onAgentReloaded: async (agent) => {
+            const instance = channelInstances.find(candidate => {
+                const owner = agentRegistry.resolveByChannel(candidate.adapter.channelKey)
+                    ?? agentRegistry.resolveByChannel(candidate.adapter.channelName);
+                return owner?.aid === agent.aid;
+            });
+            if (!instance)
+                return;
+            await bootstrapService.tryStartBootstrap({
+                adapter: instance.adapter,
+                channelKey: instance.adapter.channelKey,
+                channelType: instance.channelType,
+                agentAid: agent.aid,
+                source: 'owner-bound',
+            });
+        },
+        messageQueue,
+        handoffRuntime,
+        stageAgentRunners: async (candidate) => {
+            const creationErrors = [];
+            const staged = candidate.config.enabled === false
+                ? []
+                : await agentLoader.createForAgent(candidate, {
+                    onSessionIdUpdate: async (sessionId, agentSessionId, context) => (await sessionManager.updateAgentSessionIdBySessionId(sessionId, agentSessionId, context?.turn)),
+                }, creationErrors);
+            const onDisposeError = (instance, error) => {
+                logger.warn(`[Reload] Failed to dispose runner ${instance.evolagentName}::${instance.baseagent}: ${error instanceof Error ? error.message : String(error)}`);
+            };
+            if (creationErrors.length > 0) {
+                await disposeAgentInstances(staged, onDisposeError);
+                throw new Error(creationErrors.map(error => `${error.baseagent}: ${error.message}`).join('; '));
+            }
+            if (candidate.config.enabled !== false && staged.length === 0 && candidate.config.active_baseagent) {
+                throw new Error(`No runner could be created for ${candidate.aid}::${candidate.config.active_baseagent}`);
+            }
+            for (const instance of staged) {
+                instance.agent.setPermissionGateway?.(permissionGateway);
+                instance.agent.setCompactStartCallback?.((sessionId) => processor.handleCompactStart(sessionId));
+            }
+            return createRunnerReloadTransaction({ aid: candidate.aid, agentMap, staged, onDisposeError });
+        },
+    });
+    const reloadOwnedMutes = new Set();
+    const reloadCoordinator = new AgentReloadCoordinator({
+        registry: agentRegistry,
+        hooks: reloadHooks,
+        getBusyCount: aid => {
+            const agentName = agentRegistry.get(aid)?.name;
+            if (!agentName)
+                return 0;
+            return messageQueue.getProcessingCountByAgent(agentName) + messageQueue.getQueueLengthByAgent(agentName);
+        },
+        beforeReload: invalidateKitCache,
+        forceReload: async (aid) => {
+            const agentName = agentRegistry.get(aid)?.name;
+            if (!agentName)
+                return;
+            messageQueue.clearByAgent(agentName);
+            await messageQueue.interruptByAgentAndWait(agentName);
+            const deadline = Date.now() + 5_000;
+            while (messageQueue.getProcessingCountByAgent(agentName) > 0) {
+                if (Date.now() >= deadline)
+                    throw new Error(`Timed out waiting for Agent "${aid}" tasks to stop`);
+                await new Promise(resolve => setTimeout(resolve, 25));
+            }
+        },
+        acquireWorkGate: aid => {
+            const agentName = agentRegistry.get(aid)?.name;
+            if (!agentName)
+                return;
+            const inheritedReloadMute = reloadOwnedMutes.delete(agentName);
+            const alreadyMuted = messageQueue.isAgentMuted(agentName);
+            const ownsMute = inheritedReloadMute || !alreadyMuted;
+            if (!alreadyMuted)
+                messageQueue.muteAgent(agentName);
+            return () => {
+                const current = agentRegistry.get(aid);
+                if (!current) {
+                    messageQueue.clearByAgent(agentName);
+                    if (ownsMute)
+                        messageQueue.unmuteAgent(agentName);
+                    return;
+                }
+                if (current.status === 'disabled') {
+                    messageQueue.clearByAgent(agentName);
+                    if (ownsMute)
+                        reloadOwnedMutes.add(agentName);
+                    return;
+                }
+                if (ownsMute)
+                    messageQueue.unmuteAgent(agentName);
+            };
+        },
+    });
+    return { reloadHooks, reloadCoordinator };
+}
+export function createAgentInitializationRuntime({ agentRegistry, agentMap, channelInstances, hotLoad, activate, }) {
+    const isConnected = (aid) => channelInstances.some(instance => instance.channelType === 'aun'
+        && instance.channel.getAidState?.()?.aid === aid
+        && instance.channel.getAidState?.()?.status === 'connected');
+    return new AgentInitializationService({
+        register: async (aid) => {
+            const { aidCreate } = await import('../aun/aid/identity.js');
+            const created = await aidCreate(aid);
+            await created.client.close();
+        },
+        publish: async (aid, content) => {
+            const { agentmdPut } = await import('../aun/aid/agentmd.js');
+            await agentmdPut(content, { aid });
+        },
+        fetch: async (aid) => {
+            const { agentmdGet } = await import('../aun/aid/agentmd.js');
+            const card = await agentmdGet(aid, { withVerification: true, remoteOnly: true });
+            return { content: card.content, verified: card.verification.status === 'verified' };
+        },
+        hotLoad: async (aid) => {
+            await hotLoad(aid);
+            const until = Date.now() + 20_000;
+            while (Date.now() < until) {
+                if (isConnected(aid))
+                    return;
+                await new Promise(resolve => setTimeout(resolve, 250));
+            }
+            throw Object.assign(new Error('AUN connection unavailable'), { code: 'INITIALIZE_CHANNEL_UNAVAILABLE' });
+        },
+        activate,
+        authorize: actor => actor === 'local-control' || (loadDaemonConfig().owners ?? []).includes(actor),
+        usable: aid => {
+            const agent = agentRegistry.get(aid);
+            return !!agent && agent.config.enabled !== false && agentMap.has(`${aid}::${agent.baseagent}`) && isConnected(aid);
+        },
+    });
+}
+export function recoverIncompleteAgentInitializations(service, agentsDir = resolvePaths().agentsDir) {
+    for (const entry of fs.readdirSync(agentsDir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        try {
+            const record = readInitialization(entry.name);
+            if (record?.status === 'in_progress')
+                service.resume(entry.name, record.actor);
+        }
+        catch {
+            logger.warn('[Initialization] Recovery requires review for an incomplete operation');
+        }
+    }
+}
+export function createAgentRuntimeOperations({ agentRegistry, agentLoader, sessionManager, agentMap, permissionGateway, processor, channelLoader, channelInstances, registerChannelInstance, markChannelConnected, aidStatsCollector, handoffRuntime, triggerSchedulers, ensureTriggerSchedulerStarted, startTriggerScheduler, reloadCoordinator, unregisterRuntimeChannel, messageQueue, setAgentRuntimeState, setAgentRuntimeError, }) {
+    const hotLoad = async (aid) => {
+        handoffRuntime.pauseAgent(aid);
+        let resumed = false;
+        try {
+            setAgentRuntimeState('starting');
+            setAgentRuntimeError(undefined);
+            const agent = agentRegistry.loadNewAgent(aid);
+            if (!agent) {
+                const state = agentRegistry.runnableAgents().length > 0 ? 'running' : 'error';
+                setAgentRuntimeState(state);
+                const error = `Failed to load agent ${aid}`;
+                setAgentRuntimeError(error);
+                throw new Error(error);
+            }
+            const creationErrors = [];
+            const newAgentInstances = await agentLoader.createForAgent(agent, {
+                onSessionIdUpdate: async (sessionId, agentSessionId, context) => (await sessionManager.updateAgentSessionIdBySessionId(sessionId, agentSessionId, context?.turn)),
+            }, creationErrors);
+            for (const instance of newAgentInstances) {
+                agentMap.set(`${instance.evolagentName}::${instance.baseagent}`, instance.agent);
+                instance.agent.setPermissionGateway?.(permissionGateway);
+                instance.agent.setCompactStartCallback?.((sessionId) => {
+                    processor.handleCompactStart(sessionId);
+                });
+            }
+            if (newAgentInstances.length === 0) {
+                const creationDetail = creationErrors.length > 0
+                    ? creationErrors.map(({ baseagent, message }) => `${baseagent}: ${message}`).join('; ')
+                    : `active_baseagent=${agent.config.active_baseagent ?? '(unset)'}, configured=${Object.keys(agent.config.baseagents ?? {}).join(',') || '(none)'}`;
+                agent.status = 'error';
+                agent.error = creationErrors.length > 0
+                    ? creationDetail
+                    : `No baseagent runner created for hot-loaded agent: ${creationDetail}`;
+                setAgentRuntimeState('error');
+                setAgentRuntimeError(agent.error);
+                throw new Error(agent.error);
+            }
+            const instances = await channelLoader.createForAgent(agent);
+            for (const instance of instances) {
+                registerChannelInstance(instance);
+                if (instance.channelType === 'aun') {
+                    const channel = instance.channel;
+                    if (typeof channel?.setAidStatsCollector === 'function')
+                        channel.setAidStatsCollector(aidStatsCollector);
+                }
+                agent.channels.set(instance.adapter.channelKey, instance.adapter);
+                channelInstances.push(instance);
+            }
+            agent.status = 'running';
+            await channelLoader.connectAll(instances, { onConnected: markChannelConnected });
+            await handoffRuntime.recover([aid], { discardExpired: false });
+            await ensureTriggerSchedulerStarted(agent);
+            handoffRuntime.resumeAgent(aid);
+            resumed = true;
+            setAgentRuntimeState('running');
+            setAgentRuntimeError(undefined);
+            logger.info(`[HotLoad] ✓ Agent ${aid} online with ${instances.length} channel(s)`);
+        }
+        finally {
+            if (!resumed)
+                handoffRuntime.resumeAgent(aid);
+        }
+    };
+    let resyncInFlight;
+    const resync = async () => {
+        if (resyncInFlight)
+            return resyncInFlight;
+        const operation = (async () => {
+            invalidateKitCache();
+            const { loadAllAgents: scanAgents } = await import('../config-store.js');
+            const { agents: diskAgents } = scanAgents();
+            const results = [];
+            for (const [aid] of [...agentRegistry.agents.entries()]) {
+                const diskCfg = diskAgents.find(agent => agent.aid === aid);
+                if (!diskCfg || diskCfg.enabled === false) {
+                    try {
+                        const offlined = await reloadCoordinator.runExclusive(aid, async () => {
+                            const latestDiskCfg = readConfig(ConfigTarget.Agent, { self: aid }, { cache: false, expand: true });
+                            if (latestDiskCfg && latestDiskCfg.enabled !== false)
+                                return false;
+                            const runtimeAgent = agentRegistry.get(aid);
+                            if (!runtimeAgent)
+                                return false;
+                            let removed = false;
+                            handoffRuntime.pauseAgent(aid);
+                            try {
+                                await handoffRuntime.drainAgent(aid);
+                                await triggerSchedulers.remove(aid);
+                                for (const channelName of runtimeAgent.channelInstanceNames()) {
+                                    const instance = channelInstances.find(candidate => candidate.adapter.channelName === channelName);
+                                    if (instance) {
+                                        try {
+                                            await instance.disconnect();
+                                        }
+                                        catch { }
+                                        const index = channelInstances.indexOf(instance);
+                                        if (index >= 0)
+                                            channelInstances.splice(index, 1);
+                                    }
+                                    unregisterRuntimeChannel(channelName);
+                                }
+                                agentRegistry.agents.delete(aid);
+                                messageQueue.clearByAgent(runtimeAgent.name);
+                                removed = true;
+                                return true;
+                            }
+                            finally {
+                                if (!removed)
+                                    handoffRuntime.resumeAgent(aid);
+                            }
+                        });
+                        if (offlined)
+                            results.push(`- ${aid} (offline)`);
+                    }
+                    catch (error) {
+                        if (error instanceof AgentReloadBusyError) {
+                            results.push(`⏸ ${aid} (busy: ${error.busyCount} task(s); reload skipped)`);
+                        }
+                        else {
+                            results.push(`⚠ ${aid}: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                    }
+                    continue;
+                }
+            }
+            for (const config of diskAgents) {
+                if (config.enabled === false)
+                    continue;
+                if (agentRegistry.agents.has(config.aid))
+                    continue;
+                try {
+                    await hotLoad(config.aid);
+                    results.push(`+ ${config.aid} (online)`);
+                }
+                catch (error) {
+                    results.push(`✗ ${config.aid}: ${error?.message || error}`);
+                }
+            }
+            for (const config of diskAgents) {
+                if (config.enabled === false)
+                    continue;
+                if (!agentRegistry.agents.has(config.aid))
+                    continue;
+                try {
+                    await reloadCoordinator.reload(config.aid);
+                    const runtimeAgent = agentRegistry.get(config.aid);
+                    if (runtimeAgent)
+                        await startTriggerScheduler(runtimeAgent);
+                    results.push(`↻ ${config.aid} (reloaded)`);
+                }
+                catch (error) {
+                    results.push(`⚠ ${config.aid}: ${error?.message || error}`);
+                }
+            }
+            agentRegistry.channelIndex.clear();
+            agentRegistry.buildChannelIndex();
+            logger.info(`[Resync] Done: ${results.length} agent(s) processed`);
+            return results;
+        })();
+        resyncInFlight = operation;
+        try {
+            return await operation;
+        }
+        finally {
+            if (resyncInFlight === operation)
+                resyncInFlight = undefined;
+        }
+    };
+    return { hotLoad, resync };
+}

package/dist/core/auth/delegation-authorization.js

@@ -0,0 +1,58 @@
+import { authorizeOperation, buildAuthSubject } from './auth-gateway.js';
+import { trustedExecutionIdentityInput } from './agent-delegation.js';
+import { isManagementRole } from '../../config/builtin-roles.js';
+import { parsePeerKey } from '../relation/peer-identity.js';
+export function createDelegationAuthorizer({ agentDelegationRegistry, sessionManager, getProcessOwners, }) {
+    return async function authorizeManagedAgentOperation(params, operation) {
+        const delegation = agentDelegationRegistry.validate(params.delegationToken, params.sessionId, params.delegationCommandHash);
+        if (!delegation.ok)
+            return { ok: false, code: delegation.code, error: delegation.reason };
+        const session = await sessionManager.getSessionById(params.sessionId);
+        if (!session || session.selfAID !== delegation.grant.selfAid) {
+            return { ok: false, code: 'INVALID_DELEGATION', error: 'delegation does not match the current session' };
+        }
+        let conversationId;
+        try {
+            conversationId = parsePeerKey(delegation.grant.peerKey).channelId;
+        }
+        catch {
+            return { ok: false, code: 'INVALID_DELEGATION', error: 'delegation contains an invalid relation key' };
+        }
+        const subject = buildAuthSubject({
+            selfAid: delegation.grant.selfAid,
+            actorId: delegation.grant.actorId,
+            channel: delegation.grant.channel,
+            channelType: delegation.grant.channelType,
+            channelId: conversationId,
+            chatType: delegation.grant.chatType,
+            conversationId,
+            processOwners: getProcessOwners(),
+            ...trustedExecutionIdentityInput(delegation.grant),
+        });
+        if (params.targetAid
+            && params.targetAid !== delegation.grant.selfAid
+            && subject.dataScope !== 'daemon'
+            && !(operation === 'agent.show' && isManagementRole(subject.role))) {
+            return { ok: false, code: 'SCOPE_MISMATCH', error: 'only the current Agent can be targeted' };
+        }
+        const decision = authorizeOperation({
+            source: 'agent-tool',
+            subject,
+            intent: {
+                operation,
+                scope: operation === 'system.status' ? 'process' : 'agent',
+                source: 'agent-tool',
+                args: { self: delegation.grant.selfAid, aid: params.targetAid ?? delegation.grant.selfAid },
+            },
+            auditMetadata: { taskId: delegation.grant.taskId, messageId: delegation.grant.messageId },
+        });
+        return decision.allow
+            ? {
+                ok: true,
+                aid: subject.dataScope === 'daemon' ? (params.targetAid ?? delegation.grant.selfAid) : delegation.grant.selfAid,
+                dataScope: subject.dataScope,
+                management: isManagementRole(subject.role),
+            }
+            : { ok: false, code: decision.code, error: decision.reason };
+    };
+}

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

@@ -1094,6 +1094,14 @@ const OPERATIONS = [
         description: 'Sign and publish the current Agent local agent.md',
         sources: ['agent-tool'],
     },
+    {
+        id: 'ec.aid.agentmd.set',
+        category: 'write-agent',
+        dangerous: true,
+        defaultScopes: ['agent'],
+        description: 'Update one field and publish the current Agent agent.md',
+        sources: ['agent-tool'],
+    },
     {
         id: 'ec.aid.avatar',
         category: 'write-agent',

package/dist/core/bootstrap-service.js

@@ -10,8 +10,9 @@ import { loadAgent, saveAgent } from '../config-store.js';
 import { resolveAgentLifecycle, withLifecycleForWrite } from '../config/lifecycle.js';
 import { renderTemplate } from '../eck/manifest-engine.js';
 import { activeBaseagent } from './model/config-scope.js';
+import { getFirstStaticAgentOwner } from '../config/peer-role-resolver.js';
 import { buildEnvelope } from './message/message-utils.js';
-import { BOOTSTRAP_MESSAGE_TTL_MS, BOOTSTRAP_NOTIFICATION_WINDOW_MS, bootstrapInitialMessageOperationId, bootstrapInitialMessageOperationPrefix, bootstrapInitialRetryOperationId, cancelPendingBootstrapPrompts, postBootstrapWelcomeStatus, } from './bootstrap-messages.js';
+import { BOOTSTRAP_MESSAGE_TTL_MS, BOOTSTRAP_NOTIFICATION_WINDOW_MS, bootstrapInitialMessageOperationId, bootstrapInitialMessageOperationPrefix, bootstrapInitialRetryOperationId, cancelPendingBootstrapPrompts, postBootstrapWelcomeStatus, postBootstrapWelcomeOperationId, } from './bootstrap-messages.js';
 import { findLatestMessageLogOperation } from './message/message-log.js';
 import * as outbox from '../aun/outbox.js';
 import { chatDirPath } from './session/session-fs-store.js';
@@ -141,6 +142,69 @@ export async function completeBootstrapWithWelcome(service, aid, welcome, sessio
         mainSessionCreated: mainSession?.created,
     };
 }
+export function createBootstrapOwnerBoundHandler({ getService, agentRegistry, channelInstances, eventBus, }) {
+    return (agentAid, ownerAid) => {
+        const service = getService();
+        if (!service)
+            return;
+        const instance = channelInstances.find(candidate => {
+            const owner = agentRegistry.resolveByChannel(candidate.adapter.channelKey)
+                ?? agentRegistry.resolveByChannel(candidate.adapter.channelName);
+            return owner?.aid === agentAid;
+        });
+        if (!instance)
+            return;
+        eventBus.publish({ type: 'channel:owner-bound', channel: instance.channelType || instance.adapter.channelName, channelName: instance.adapter.channelName, userId: ownerAid });
+        void service.tryStartBootstrap({
+            adapter: instance.adapter,
+            channelKey: instance.adapter.channelKey,
+            channelType: instance.channelType,
+            agentAid,
+            recipientId: ownerAid,
+            channelId: instance.channelType === 'aun' ? ownerAid : undefined,
+            source: 'owner-bound',
+        }).catch(error => {
+            logger.warn(`[Bootstrap] Owner-bound start failed for ${agentAid}: ${error instanceof Error ? error.message : String(error)}`);
+        });
+    };
+}
+export function createBootstrapCompletionHandler({ service, agentRegistry, channelInstances, sessionManager, defaultProjectPath, primaryBaseagent, }) {
+    return async (aid) => {
+        const aunInstance = channelInstances.find(candidate => {
+            if (candidate.channelType !== 'aun')
+                return false;
+            const owner = agentRegistry.resolveByChannel(candidate.adapter.channelKey)
+                ?? agentRegistry.resolveByChannel(candidate.adapter.channelName);
+            return owner?.aid === aid;
+        });
+        const welcome = aunInstance?.channel;
+        const owningAgent = agentRegistry.get(aid);
+        const firstOwnerAid = getFirstStaticAgentOwner(aid);
+        const sessions = aunInstance && firstOwnerAid && owningAgent
+            ? {
+                ensurePostBootstrapMainSession: async (owner) => {
+                    const ownerAid = owner || firstOwnerAid;
+                    const channel = aunInstance.adapter.channelName;
+                    const active = await sessionManager.getActiveSession(channel, ownerAid);
+                    const ensured = await sessionManager.ensureNewMainSessionForOperation({
+                        channel,
+                        channelId: ownerAid,
+                        projectPath: active?.projectPath || owningAgent.projectPath || defaultProjectPath,
+                        baseagent: owningAgent.baseagent || active?.baseagent || primaryBaseagent,
+                        operationId: postBootstrapWelcomeOperationId(aid, ownerAid),
+                        identityMetadata: {
+                            ...(active?.metadata ?? {}),
+                            channelKey: aunInstance.adapter.channelKey,
+                            peerId: ownerAid,
+                        },
+                    });
+                    return { sessionId: ensured.session.id, created: ensured.created };
+                },
+            }
+            : undefined;
+        return completeBootstrapWithWelcome(service, aid, welcome, sessions);
+    };
+}
 export class BootstrapService {
     agentRegistry;
     eventBus;