evolcore 0.0.26 → 0.0.27

package/dist/index.js

@@ -14,6 +14,7 @@ import { CodexSessionFileAdapter } from './core/session/adapters/codex-session-f
 import { GeminiSessionFileAdapter } from './core/session/adapters/gemini-session-file-adapter.js';
 import { EcagentSessionFileAdapter } from './core/session/adapters/ecagent-session-file-adapter.js';
 import { autoMigrateIfNeeded, loadDefaults, loadAllAgents, migrateIdentitiesIfNeeded, loadDaemonConfig, initializeEckSnapshotsConfig, isFullAccessEnabled } from './config-store.js';
+import { migrateRelationSharedDirectories } from './core/relation/shared-data.js';
 import { DEFAULT_ECWEB_PORT, ecwebService } from './config/daemon-services.js';
 import { ConfigTarget, initConfigManager, onConfigWrite, read as readConfig, shouldFailFastForMissingOwners } from './config/config-manager.js';
 import { ensureRoleConfigV4OnStartup, ensureRoleConfigV5OnStartup } from './config/role-migration-startup.js';
@@ -53,6 +54,8 @@ import { BootstrapService, completeBootstrapWithWelcome } from './core/bootstrap
 import { postBootstrapWelcomeOperationId } from './core/bootstrap-messages.js';
 import { MessageCache } from './core/message/message-cache.js';
 import { CommandHandler, isProcessLevelOwner } from './core/command/command-handler.js';
+import { executeLocalInitializationCommand, AgentInitializationService, hasSuppliedInitialization, readInitialization, parseInitializationArgs, parseAgentWelcomeArgs, resolveInitializationPlan, } from './cli/agent-create.js';
+import { loadAgent } from './config-store.js';
 import { AgentApplicationService } from './core/agent-application-service.js';
 import { EventBus } from './core/event-bus.js';
 import { eventPatternIncludesInternal, getEventCatalog } from './core/event-catalog.js';
@@ -60,12 +63,13 @@ import { StatsCollector } from './utils/stats.js';
 import { AidStatsCollector } from './utils/stats.js';
 import { PermissionGateway } from './core/permission/approval-gateway.js';
 import { InteractionRouter, registerAdapterInteractions } from './core/interaction-router.js';
+import { GroupInviteReviewService } from './core/group/invite-service.js';
 import { AgentDelegationRegistry, authorizeDelegatedAunMsgSend, hasTrustedFullAccessDelegation, trustedExecutionIdentityInput, } from './core/auth/agent-delegation.js';
 import { authorizeOperation, buildAuthSubject, canApprovePersistentFullAccessTrigger, isCrossAgentTriggerOperationAllowed, } from './core/auth/auth-gateway.js';
 import { authorizationDenialData, formatAuthorizationDenial } from './core/auth/authorization-denial.js';
 import { auditFullAccessEvent } from './core/auth/authorization-audit.js';
 import { parsePeerKey } from './core/relation/peer-identity.js';
-import { isHClassPath } from './core/permission/protected-paths.js';
+import { isHClassPath, isSameOrDescendant } from './core/permission/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';
@@ -73,6 +77,8 @@ import { createRunnerReloadTransaction, disposeAgentInstances } from './core/run
 import { AgentReloadBusyError, AgentReloadCoordinator } from './core/agent-reload-coordinator.js';
 import { buildReloadHooks } from './core/channel-loader.js';
 import { IpcServer } from './ipc.js';
+import { executeTaskResume } from './core/task/task-resume-operation.js';
+import { TASK_RECOVERY_PROMPT } from './core/task/task-recovery-service.js';
 import { logger, setLogLevel } from './utils/logger.js';
 import { remoteAccessService } from './core/auth/remote-access-store.js';
 import { DiagService, executeDiagIpc } from './core/command/diag-service.js';
@@ -98,6 +104,7 @@ import { DAEMON_RUNTIME_EPOCH_ENV, ensureProcessManagedTempDir } from './cli/tas
 import { appendMessageLog, buildOutboundEntry, classifyAunPayloadForLog } from './core/message/message-log.js';
 import { normalizeAunMentionEntries } from './aun/msg/mention-schema.js';
 import { MAIN_PACKAGE_NAME } from './product.js';
+import { sanitizeMenuLogValue } from './core/command/menu-protocol.js';
 import fs from 'fs';
 import crypto from 'crypto';
 import { fileURLToPath } from 'url';
@@ -529,6 +536,51 @@ main().catch((error) => {
     atomicWriteJson(manager.definitionPath(definition.id), definition);
     fs.rmSync(manager.activePath(definition.id), { force: true });
 }
+/**
+ * Keep one daemon-owned recovery Trigger for all local Agent sessions. The
+ * event-session feedback path resolves the owning Agent from task:error rather
+ * than treating the daemon AID as the target Agent.
+ */
+function seedTaskRecoveryTrigger(manager, owner) {
+    const now = Date.now();
+    const definition = normalizeTriggerDefinition({
+        $schema_version: 3.1,
+        id: '__task-recovery',
+        agentAid: owner.aid,
+        enabled: true,
+        name: '__task-recovery',
+        description: 'System trigger: recover failed tasks for local Agents.',
+        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}#__task-recovery__`,
+        },
+        source: {
+            type: 'event',
+            eventPattern: 'task:error',
+        },
+        execution: {
+            type: 'target_session',
+            prompt: TASK_RECOVERY_PROMPT,
+            onError: 'retry',
+            noopSentinel: '[[NOOP]]',
+        },
+        feedback: { strategy: 'event_session' },
+        reliability: {
+            concurrency: 'forbid',
+            missedPolicy: 'run_once',
+            retry: { maxAttempts: 2, backoffMs: 30_000 },
+        },
+    });
+    fs.mkdirSync(manager.triggerDir(definition.id), { recursive: true });
+    atomicWriteJson(manager.definitionPath(definition.id), definition);
+    fs.rmSync(manager.activePath(definition.id), { force: true });
+}
 function removeLegacyAgentUpgradeCheck(manager) {
     let existing;
     try {
@@ -957,6 +1009,10 @@ async function main() {
     }
     // ── 自动迁移 ──
     migrateIdentitiesIfNeeded();
+    const relationSharedMigration = migrateRelationSharedDirectories();
+    if (relationSharedMigration.copied > 0) {
+        logger.info(`[migrate] Synced ${relationSharedMigration.copied} relation shared file(s) across ${relationSharedMigration.relations} relation(s)`);
+    }
     // daemon.json 的旧 ecweb/serviceProxy 结构已在启动前归一化为 services[]。
     // ── 配置体系初始化（schema 字段不相交硬约束校验）──
     try {
@@ -1239,6 +1295,11 @@ async function main() {
     });
     // 交互路由器
     const interactionRouter = new InteractionRouter();
+    const groupInviteReviewService = new GroupInviteReviewService(interactionRouter);
+    const removeGroupInviteConfigListener = onConfigWrite(({ target, selector }) => {
+        if (target === ConfigTarget.Agent && selector.self)
+            groupInviteReviewService.configurationChanged(selector.self);
+    });
     // 为所有支持权限的 agent 设置 gateway
     for (const inst of agentInstances) {
         inst.agent.setPermissionGateway?.(permissionGateway);
@@ -1327,6 +1388,7 @@ async function main() {
     // 创建命令处理器
     const cmdHandler = new CommandHandler(sessionManager, agentMap, messageCache, eventBus, primaryRunnerKey);
     let agentApplicationService;
+    let agentInitializationService;
     cmdHandler.setAgentDelegationRegistry(agentDelegationRegistry);
     cmdHandler.setPermissionGateway(permissionGateway);
     cmdHandler.setInteractionRouter(interactionRouter);
@@ -1372,10 +1434,13 @@ async function main() {
         dedupPath: daemonMessageDedupPath(),
     });
     // 设置中断回调（精确中断正在处理的 agent）
-    messageQueue.setInterruptCallback(async (sessionKey, baseagent, evolagentName, reason = 'new_message') => {
+    messageQueue.setInterruptCallback(async (sessionKey, baseagent, evolagentName, reason = 'new_message', timeout) => {
         void baseagent;
         void evolagentName;
-        await responseEngine.interruptSession(sessionKey, reason);
+        if (timeout)
+            await responseEngine.timeoutSession(sessionKey, timeout);
+        else
+            await responseEngine.interruptSession(sessionKey, reason);
     });
     messageQueue.setEventBus(eventBus);
     // Restore persisted input before Trigger schedulers start. Trigger-owned work
@@ -1531,7 +1596,7 @@ async function main() {
         };
     };
     const validateTriggerFeedbackChannels = (definition) => {
-        if (definition.feedback.strategy === 'silent')
+        if (definition.feedback.strategy === 'silent' || definition.feedback.strategy === 'event_session')
             return;
         const target = definition.feedback.strategy === 'target'
             ? definition.feedback.target
@@ -1614,6 +1679,9 @@ async function main() {
             if (!effortDecision.ok)
                 throw new Error(effortDecision.message || 'trigger effort is not allowed by current role');
         }
+        if (!actor.management && definition.feedback.strategy === 'event_session') {
+            throw new Error('event-session feedback requires owner/admin');
+        }
         if (!actor.management && definition.feedback.strategy === 'target') {
             const target = definition.feedback.target;
             const origin = actor.origin;
@@ -1721,6 +1789,9 @@ async function main() {
         if (privilegedReason && !persistedFullAccessApproval && !hasDaemonTriggerAuthority(subject)) {
             return { allowed: false, reason: `${privilegedReason} requires current DaemonOwner` };
         }
+        if (definition.feedback.strategy === 'event_session' && !isManagementRole(role)) {
+            return { allowed: false, reason: 'event-session feedback requires current owner/admin role' };
+        }
         if (definition.feedback.strategy === 'target' && !isManagementRole(role)) {
             const target = definition.feedback.target;
             if (!target
@@ -1830,6 +1901,7 @@ async function main() {
         const manager = new TriggerDefinitionManager(owner.aid);
         if (opts.seedUpgradeCheck) {
             seedUpgradeCheckTrigger(manager, owner);
+            seedTaskRecoveryTrigger(manager, owner);
         }
         else {
             removeLegacyAgentUpgradeCheck(manager);
@@ -1840,6 +1912,8 @@ async function main() {
             getChannel: getTriggerChannel,
             sessionManager,
             messageQueue,
+            recoverTask: request => responseEngine.recoverTask(request),
+            inspectTargetExecution: (sessionId, attemptId, selfAid) => responseEngine.inspectTargetExecution(sessionId, attemptId, selfAid),
             eventBus,
             tryHandoff: async (input, text, target, binding) => {
                 if (input.signal?.aborted) {
@@ -1956,9 +2030,21 @@ async function main() {
         const inst = channelInstances.find(candidate => candidate.adapter.channelKey === channelKey);
         return !!inst && inst.channel.getStatus?.().connected === true;
     };
+    cmdHandler.setAgentStorageClientResolver((channelKey, targetAid) => {
+        const inst = channelInstances.find(candidate => candidate.channelType === 'aun'
+            && (candidate.adapter.channelKey === channelKey || candidate.adapter.channelName === channelKey)
+            && candidate.channel.getAid?.() === targetAid);
+        if (!inst || inst.channel.getStatus?.().connected !== true)
+            return undefined;
+        // A reconnect replaces the Client; never capture it during startup.
+        const client = inst.channel.getClient?.();
+        return client?.aid === targetAid ? client : undefined;
+    });
     const msgBridge = new MessageBridge(defaultProjectPath, sessionManager, processor, messageQueue, cmdHandler, eventBus, primaryAgent?.config.debounce, () => processLevelOwners);
     msgBridge.setAgentRegistry(agentRegistry);
     msgBridge.setInteractionRouter(interactionRouter);
+    msgBridge.setGroupInviteReviewService(groupInviteReviewService);
+    cmdHandler.setGroupInviteDecisionResolver((selfAid, ownerAid, inviteId, action) => groupInviteReviewService.decideManaged(selfAid, ownerAid, inviteId, action));
     msgBridge.setContactBindRuntimeChecker(isContactBindChannelReady);
     msgBridge.setAidStatsCollector(aidStatsCollector);
     cmdHandler.setContactRequestSubmitter((input) => msgBridge.submitAgentContactRequest(input));
@@ -1982,7 +2068,7 @@ async function main() {
                 sessionId: envelope.sessionId,
                 agentAid: owningAgent?.aid,
                 agentName: envelope.agentName,
-                payload: summarizeOutboundPayload(payload),
+                payload: sanitizeMenuLogValue(summarizeOutboundPayload(payload)),
             });
             const result = await originalSend(envelope, payload);
             // AUN adapters return an explicit receipt. Only a receipt with a remote
@@ -2552,7 +2638,10 @@ async function main() {
                 catch {
                     parsed = null;
                 }
-                const menuResponseContext = () => controlReplyContext(opts, evolMenuResponseTransportMetadata());
+                const menuResponseContext = () => ({
+                    ...controlReplyContext(opts, evolMenuResponseTransportMetadata(opts.protectedHeaders?.sdk_version)),
+                    ...(opts.peerDeviceId ? { toDeviceId: opts.peerDeviceId } : {}),
+                });
                 const sendControlMenuResponse = async (response) => {
                     const timedResponse = withMenuProcessingTime(enforceMenuResponseSize(response, 128 * 1024 - 1024), menuTiming);
                     const request = activeMenuRequest ?? {
@@ -2637,9 +2726,9 @@ async function main() {
                     return;
                 }
                 if (text.toLowerCase() === '/pair') {
-                    const pair = remoteAccessService.getPairingCode(opts.peerId);
+                    const pair = remoteAccessService.getPairingCode(opts.peerId, Date.now(), 'pair');
                     const mins = Math.max(0, Math.round((pair.expiresAt - Date.now()) / 60000));
-                    const reply = `远程控制配对码：${pair.code}（约 ${mins} 分钟内有效）`;
+                    const reply = `远程控制配对码：${pair.code}（约 ${mins} 分钟内有效，仅可配对一次）`;
                     await controlChannel.sendMessage(opts.channelId, reply, controlReplyContext(opts));
                     return;
                 }
@@ -2650,7 +2739,7 @@ async function main() {
                         await sendControlMenuResponse(menuFailure({ id: menuControl.id, ...(menuControl.name?.trim() ? { name: menuControl.name } : {}) }, validationError));
                         return;
                     }
-                    const deduped = await controlMenuDeduper.execute([opts.channelId, opts.peerId, menuControl.id].join('\u001f'), menuPayloadFingerprint(menuControl.raw), () => cmdHandler.execMenuForControl(parsed, opts.peerId, {
+                    const deduped = await controlMenuDeduper.execute([opts.channelId, opts.peerId, opts.peerDeviceId || '', menuControl.id].join('\u001f'), menuPayloadFingerprint(menuControl.raw), () => cmdHandler.execMenuForControl(parsed, opts.peerId, {
                         encrypted: opts.encrypted,
                         protectedHeaders: opts.protectedHeaders,
                     }));
@@ -2848,6 +2937,41 @@ async function main() {
             });
         }
     }
+    async function completeAgentBootstrap(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(bootstrapService, aid, welcome, sessions);
+    }
     function configureIpc() {
         ipcServer.setShutdownExecutor(async (reason) => {
             if (!shutdown) {
@@ -2880,39 +3004,10 @@ async function main() {
                     return { ok: false, code: 'INVALID_CONTROL_TOKEN', error: 'valid local control token is required' };
                 }
             }
-            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(bootstrapService, aid, welcome, sessions);
+            if (hasSuppliedInitialization(aid) || loadAgent(aid)?.initialization) {
+                return { ok: false, code: 'INITIALIZATION_MANAGED', error: 'Use the initialization service for this Agent' };
+            }
+            return completeAgentBootstrap(aid);
         });
         ipcServer.setDingtalkContactBindExecutor({
             register: (cmd) => registerPendingDingtalkContactBind(cmd),
@@ -3020,6 +3115,14 @@ async function main() {
             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.setTaskRuntimeContextAuthorizer(({ sessionId, delegationToken, delegationCommandHash }) => {
+            // Codex persistent threads carry a command-scoped authorization. Looking
+            // up fresh routing context must not consume the subsequent CLI operation.
+            const authorization = agentDelegationRegistry.validateForContext(delegationToken, sessionId, delegationCommandHash);
+            return authorization.ok
+                ? { ok: true }
+                : { ok: false, code: authorization.code, error: authorization.reason };
+        });
         ipcServer.setCodexPreToolUseExecutor(async (params) => {
             for (const runner of new Set(agentMap.values())) {
                 if (typeof runner?.evaluatePreToolUse !== 'function')
@@ -3694,6 +3797,57 @@ async function main() {
             }),
             aunAidStats: () => aidStatsCollector.getAllSnapshots(),
         });
+        agentInitializationService = 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 coreHotLoadAgent(aid);
+                const until = Date.now() + 20_000;
+                while (Date.now() < until) {
+                    if (channelInstances.some(inst => inst.channelType === 'aun'
+                        && inst.channel.getAidState?.()?.aid === aid
+                        && inst.channel.getAidState?.()?.status === 'connected'))
+                        return;
+                    await new Promise(resolve => setTimeout(resolve, 250));
+                }
+                throw Object.assign(new Error('AUN connection unavailable'), { code: 'INITIALIZE_CHANNEL_UNAVAILABLE' });
+            },
+            activate: completeAgentBootstrap,
+            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}`)
+                    && channelInstances.some(inst => inst.channelType === 'aun'
+                        && inst.channel.getAidState?.()?.aid === aid
+                        && inst.channel.getAidState?.()?.status === 'connected');
+            },
+        });
+        agentApplicationService.setInitializationService(agentInitializationService);
+        ipcServer.setInitializationExecutor(async (cmd) => executeLocalInitializationCommand(agentInitializationService, cmd));
+        for (const entry of fs.readdirSync(resolvePaths().agentsDir, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            try {
+                const record = readInitialization(entry.name);
+                if (record?.status === 'in_progress')
+                    agentInitializationService.resume(entry.name, record.actor);
+            }
+            catch {
+                logger.warn('[Initialization] Recovery requires review for an incomplete operation');
+            }
+        }
         cmdHandler.setAgentApplicationService(agentApplicationService);
         ipcServer.setAgentApplicationService(agentApplicationService);
         ipcServer.setStatsProvider(() => statsCollector.getSnapshot());
@@ -3796,6 +3950,8 @@ async function main() {
                 ? {
                     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 };
         }
@@ -3823,26 +3979,41 @@ async function main() {
                 return fail('INVALID_DELEGATION', 'delegation does not match the current session');
             }
             const taskAid = delegation.grant.selfAid;
+            let welcomeArgs;
+            if (sub === 'welcome') {
+                try {
+                    welcomeArgs = parseAgentWelcomeArgs(argv.slice(2));
+                }
+                catch (error) {
+                    return fail('INVALID_ARGS', error.message);
+                }
+                if (delegation.grant.chatType !== 'private')
+                    return fail('NOT_ALLOWED', 'welcome requires a private conversation');
+            }
             const targetAid = sub === 'list'
                 ? undefined
                 : sub === 'persona'
                     ? taskAid
-                    : sub === 'show'
-                        ? (argv[2] && !argv[2].startsWith('--') ? argv[2] : taskAid)
-                        : sub === 'reload'
-                            ? (argv[2] && !argv[2].startsWith('--') ? argv[2] : undefined)
-                            : (argv[2] && !argv[2].startsWith('--') ? argv[2] : undefined);
+                    : sub === 'welcome'
+                        ? taskAid
+                        : sub === 'show'
+                            ? (argv[2] && !argv[2].startsWith('--') ? argv[2] : taskAid)
+                            : sub === 'reload'
+                                ? (argv[2] && !argv[2].startsWith('--') ? argv[2] : undefined)
+                                : (argv[2] && !argv[2].startsWith('--') ? argv[2] : undefined);
             const operation = sub === 'list' ? 'agent.list'
                 : sub === 'show' ? 'agent.show'
                     : sub === 'persona' ? 'agent.persona'
-                        : sub === 'new' ? 'agent.create'
-                            : sub === 'enable' ? 'agent.enable'
-                                : sub === 'disable' ? 'agent.disable'
-                                    : sub === 'reload' ? 'agent.reload'
-                                        : sub === 'delete' ? 'agent.delete' : undefined;
+                        : sub === 'welcome' ? 'agent.welcome'
+                            : sub === 'initialize' || (sub === 'new' && argv.includes('--initialize')) ? 'agent.initialize'
+                                : sub === 'new' ? 'agent.create'
+                                    : sub === 'enable' ? 'agent.enable'
+                                        : sub === 'disable' ? 'agent.disable'
+                                            : sub === 'reload' ? 'agent.reload'
+                                                : sub === 'delete' ? 'agent.delete' : undefined;
             if (!operation)
                 return fail('INVALID_ARGS', `unsupported managed agent command: ${sub}`);
-            if (sub === 'new' && !argv.includes('--non-interactive')) {
+            if (sub === 'new' && !argv.includes('--non-interactive') && !argv.includes('--initialize')) {
                 return fail('MANAGED_NON_INTERACTIVE_REQUIRED', 'interactive Agent creation is unavailable in a managed task', 'MANAGED_NON_INTERACTIVE_REQUIRED');
             }
             if (sub === 'delete' && argv.includes('--purge') && !argv.includes('--confirm-purge')) {
@@ -3871,7 +4042,7 @@ async function main() {
                 subject,
                 intent: {
                     operation,
-                    scope: operation === 'agent.show' || operation === 'agent.persona'
+                    scope: operation === 'agent.show' || operation === 'agent.persona' || operation === 'agent.welcome'
                         ? 'agent'
                         : operation === 'agent.reload' && targetAid
                             ? 'agent'
@@ -3882,6 +4053,7 @@ async function main() {
                         aid: targetAid ?? taskAid,
                         taskAgentAid: taskAid,
                         targetAgentAid: targetAid ?? taskAid,
+                        ...(welcomeArgs ? { action: welcomeArgs.action } : {}),
                     },
                 },
                 auditMetadata: { taskId: delegation.grant.taskId, messageId: delegation.grant.messageId },
@@ -3933,6 +4105,7 @@ async function main() {
                             : { config: null, agent_md: null, project: null, data: null },
                         ...(subject.dataScope === 'daemon' ? {} : { redacted: true }),
                         ...(agent.createProgress ? { createProgress: agent.createProgress } : {}),
+                        ...(agent.initialization ? { initialization: agent.initialization } : {}),
                     } };
             }
             if (operation === 'agent.persona') {
@@ -3967,6 +4140,48 @@ async function main() {
                         ...(result.saved ? { saved: true } : {}),
                     } };
             }
+            if (operation === 'agent.welcome') {
+                if (subject.role !== 'owner' && !(welcomeArgs?.action === 'show' && subject.role === 'admin')) {
+                    return fail('NOT_ALLOWED', 'welcome requires the current Agent Owner (admin may read)');
+                }
+                const { agentWelcome } = await import('./cli/agent.js');
+                const result = await agentWelcome(taskAid, { text: welcomeArgs?.text, trustedLocal: true });
+                if (!result.ok)
+                    return fail(result.code ?? 'INTERNAL', result.error);
+                return { ok: true, result: {
+                        ok: true,
+                        aid: taskAid,
+                        content: result.content,
+                        ...(result.path ? { path: result.path } : {}),
+                        ...(result.saved ? { saved: true } : {}),
+                        ...(result.bytes !== undefined ? { bytes: result.bytes } : {}),
+                        ...(result.sha256 ? { sha256: result.sha256 } : {}),
+                    } };
+            }
+            if (operation === 'agent.initialize') {
+                try {
+                    const parsed = parseInitializationArgs(argv.slice(1));
+                    const actor = delegation.grant.actorId;
+                    if (parsed.resume)
+                        return { ok: true, result: agentInitializationService.resume(parsed.aid, actor) };
+                    const createPermission = authorizeOperation({
+                        source: 'agent-tool', subject,
+                        intent: { operation: 'agent.create', scope: 'control', source: 'agent-tool', args: { aid: parsed.aid } },
+                        auditMetadata: { taskId: delegation.grant.taskId, messageId: delegation.grant.messageId },
+                    });
+                    if (!createPermission.allow)
+                        return fail(createPermission.code, createPermission.reason);
+                    if (!argv.includes('--owner') && !argv.includes('--owners'))
+                        return fail('INITIALIZE_OWNER_MISMATCH', 'Explicit Owner required');
+                    const plan = resolveInitializationPlan(argv.slice(1));
+                    if (!plan.owners.includes(actor))
+                        return fail('INITIALIZE_OWNER_MISMATCH', 'The authenticated requesting Owner must be retained');
+                    return { ok: true, result: agentInitializationService.start(plan, actor, parsed.dryRun) };
+                }
+                catch (error) {
+                    return fail(error.code ?? 'INVALID_ARGS', error.message);
+                }
+            }
             if (operation === 'agent.create') {
                 const aid = argv[2] && !argv[2].startsWith('--') ? argv[2] : undefined;
                 if (!aid)
@@ -4094,6 +4309,11 @@ async function main() {
             const result = await execAgentAction(sub, { aid: targetAid ?? taskAid, force: argv.includes('--force') }, delegation.grant.actorId, eventBus, agentApplicationService);
             return 'error' in result ? fail(result.code, result.error) : { ok: true, result: { ok: true, ...(result.data ?? {}) } };
         });
+        ipcServer.setTaskResumeExecutor(params => executeTaskResume(params, {
+            sessions: sessionManager,
+            authorizeManaged: authorizeManagedAgentOperation,
+            recover: request => responseEngine.recoverTask(request),
+        }));
         ipcServer.setQueueOperationExecutor(async (params) => {
             const operation = `ec.queue.${params.action ?? 'read'}`;
             const authorization = await authorizeManagedAgentOperation(params, operation);
@@ -4134,6 +4354,38 @@ async function main() {
             const authorization = await authorizeManagedAgentOperation({ ...params, targetAid: params.aid }, params.operation);
             return authorization.ok ? { ok: true } : authorization;
         });
+        ipcServer.setStorageUploadExecutor(async (params) => {
+            const authorization = await authorizeManagedAgentOperation({ ...params, targetAid: params.aid }, 'storage.upload');
+            if (!authorization.ok)
+                return authorization;
+            const session = await sessionManager.getSessionById(params.sessionId);
+            if (!session)
+                return { ok: false, code: 'SESSION_NOT_FOUND', error: 'current session not found' };
+            try {
+                const projectPath = fs.realpathSync(path.resolve(session.projectPath));
+                const requestedFile = path.resolve(session.projectPath, params.localFile);
+                const requestedStat = fs.lstatSync(requestedFile);
+                if (requestedStat.isSymbolicLink()) {
+                    return { ok: false, code: 'INVALID_LOCAL_FILE', error: 'Upload source must not be a symbolic link' };
+                }
+                const localFile = fs.realpathSync(requestedFile);
+                const stat = fs.lstatSync(localFile);
+                if (!isSameOrDescendant(localFile, projectPath) || isHClassPath(localFile)) {
+                    return { ok: false, code: 'INVALID_LOCAL_PATH', error: 'Upload source must be an unprotected file inside the current session project' };
+                }
+                if (!stat.isFile() || stat.isSymbolicLink()) {
+                    return { ok: false, code: 'INVALID_LOCAL_FILE', error: 'Upload source must be a regular non-symlink file' };
+                }
+                const { storageUpload } = await import('./aun/storage/index.js');
+                const result = await storageUpload(authorization.aid, localFile, params.remotePath, { isPublic: params.isPublic });
+                return result.ok
+                    ? { ok: true, objectKey: result.objectKey, publicUrl: result.publicUrl }
+                    : { ok: false, code: 'STORAGE_UPLOAD_FAILED', error: result.error };
+            }
+            catch (error) {
+                return { ok: false, code: 'INVALID_LOCAL_FILE', error: error instanceof Error ? error.message : String(error) };
+            }
+        });
         ipcServer.setTriggerExecutor(async (cmd) => {
             const schedulerFor = (agentAid) => {
                 const scheduler = triggerSchedulers.get(agentAid);
@@ -4537,6 +4789,8 @@ async function main() {
                 timestamp: Date.now()
             });
             // 断开插件系统的渠道
+            removeGroupInviteConfigListener();
+            await shutdownStep('stop group invitation review', () => groupInviteReviewService.dispose());
             await shutdownStep('disconnect channels', () => channelLoader.disconnectAll(channelInstances));
             for (const inst of channelInstances) {
                 const type = inst.channelType || inst.adapter.channelName;