evolcore 0.0.26 → 0.0.28

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';
@@ -97,11 +103,10 @@ import { atomicWriteJson } from './core/session/session-fs-store.js';
 import { DAEMON_RUNTIME_EPOCH_ENV, ensureProcessManagedTempDir } from './cli/task-context.js';
 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';
-import * as platform from './utils/cross-platform.js';
 const controlMenuDeduper = new MenuRequestDeduper();
 /** 出站 payload 摘要（用于 channel-out.log） */
 function summarizeOutboundPayload(payload) {
@@ -365,160 +370,23 @@ function seedUpgradeCheckTrigger(manager, owner) {
     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'));
-    // Resolve the launch argv at generation time: in a checkout this points the
-    // monitor at src/ through tsx, so a `npm run build` that wipes dist/ cannot
-    // take the watchdog down with it.
-    const monitorEntry = platform.resolveCliEntry(packageRoot);
-    const stageParent = path.join(resolvePaths().root, 'data', 'monitor-stage');
+    // Keep this generated script check-only. It never starts a monitor or runs npm install.
     fs.writeFileSync(scriptPath, `#!/usr/bin/env node
-const fs = require('node:fs');
-const path = require('node:path');
-const { existsSync, readFileSync } = fs;
-const { spawn } = require('node:child_process');
-
-const CLI_PATH = ${JSON.stringify(monitorEntry.entry)};
-const CLI_ARGS = ${JSON.stringify(monitorEntry.args)};
-const PACKAGE_ROOT = ${JSON.stringify(packageRoot)};
-const STAGE_PARENT = ${JSON.stringify(stageParent)};
-const PACKAGE_JSON = ${JSON.stringify(packageJsonPath)};
-const PACKAGE_NAME = ${JSON.stringify(MAIN_PACKAGE_NAME)};
-const DEV_MODE = ${devMode ? 'true' : 'false'};
-
-function emit(outcome, text) {
-  process.stdout.write(JSON.stringify({ outcome, text, files: [] }));
-}
-
-function compareVersions(a, b) {
-  const pa = a.split('-')[0].split('.').map(Number);
-  const pb = b.split('-')[0].split('.').map(Number);
-  const count = Math.max(pa.length, pb.length);
-  for (let i = 0; i < count; i += 1) {
-    const av = Number.isFinite(pa[i]) ? pa[i] : 0;
-    const bv = Number.isFinite(pb[i]) ? pb[i] : 0;
-    if (av < bv) return -1;
-    if (av > bv) return 1;
-  }
-  return 0;
-}
-
-async function latestVersion() {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), 10_000);
-  try {
-    const response = await fetch('https://registry.npmjs.org/' + encodeURIComponent(PACKAGE_NAME) + '/latest', {
-      signal: controller.signal,
-      headers: { Accept: 'application/json' },
-    });
-    if (!response.ok) return null;
-    const data = await response.json();
-    return typeof data.version === 'string' ? data.version : null;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
+const { pathToFileURL } = require('node:url');
+const entry = ${JSON.stringify(path.join(packageRoot, 'dist', 'utils', 'package-version-info.js'))};
 async function main() {
-  if (DEV_MODE) {
-    emit('noop', 'upgrade check skipped in dev mode');
-    return;
-  }
-
-  let localVersion;
-  try {
-    localVersion = JSON.parse(readFileSync(PACKAGE_JSON, 'utf8')).version;
-  } catch {
-    emit('error', 'failed to read local ec version');
-    return;
-  }
-  if (typeof localVersion !== 'string' || !localVersion) {
-    emit('error', 'failed to read local ec version');
-    return;
-  }
-
-  let remoteVersion;
-  try {
-    remoteVersion = await latestVersion();
-  } catch {
-    remoteVersion = null;
-  }
-  if (!remoteVersion) {
-    emit('error', 'failed to check evolcore latest version');
-    return;
-  }
-  if (compareVersions(localVersion, remoteVersion) >= 0) {
-    emit('noop', 'evolcore is already up to date (' + localVersion + '; latest ' + remoteVersion + ')');
-    return;
-  }
-  if (!existsSync(CLI_PATH)) {
-    emit('error', 'restart-monitor entry not found: ' + CLI_PATH);
-    return;
-  }
-
-  // Installed mode: copy the monitor out of the package before it upgrades that
-  // same package. Mirrors prepareMonitorStage(); kept inline because this file
-  // is generated standalone CJS. Any failure degrades to launching in place —
-  // losing upgrade isolation beats losing the upgrade.
-  let launchArgs = CLI_ARGS;
-  const launchEnv = { ...process.env };
-  if (!DEV_MODE && STAGE_PARENT) {
-    try {
-      const stageDir = path.join(STAGE_PARENT, 'upgrade-' + process.pid + '-' + Date.now());
-      fs.mkdirSync(stageDir, { recursive: true });
-      fs.cpSync(path.join(PACKAGE_ROOT, 'dist'), path.join(stageDir, 'dist'), { recursive: true });
-      if (existsSync(PACKAGE_JSON)) fs.copyFileSync(PACKAGE_JSON, path.join(stageDir, 'package.json'));
-      const modulesSource = path.join(PACKAGE_ROOT, 'node_modules');
-      if (existsSync(modulesSource)) {
-        const staged = path.join(stageDir, 'node_modules');
-        try {
-          // junction works unelevated on Windows; dir symlink elsewhere.
-          fs.symlinkSync(modulesSource, staged, process.platform === 'win32' ? 'junction' : 'dir');
-          fs.readdirSync(staged);
-        } catch (linkError) {
-          fs.rmSync(staged, { recursive: true, force: true });
-          fs.cpSync(modulesSource, staged, { recursive: true });
-        }
-      }
-      const stagedEntry = path.join(stageDir, 'dist', 'cli', 'index.js');
-      if (existsSync(stagedEntry)) {
-        launchArgs = [stagedEntry];
-        launchEnv.EVOLCORE_TARGET_PACKAGE_ROOT = PACKAGE_ROOT;
-        launchEnv.EVOLCORE_MONITOR_STAGE = stageDir;
-      }
-    } catch (stageError) {
-      // Fall through with the in-place entry.
-    }
-  }
-
-  try {
-    const child = spawn(process.execPath, [...launchArgs, 'restart-monitor'], {
-      detached: true,
-      stdio: 'ignore',
-      windowsHide: process.platform === 'win32',
-      env: launchEnv,
-    });
-    child.unref();
-    const pid = child.pid;
-    // The daemon is still running here — the monitor is what stops it. So a
-    // monitor that dies on load costs the upgrade, not the service; still,
-    // report it accurately instead of claiming success.
-    await new Promise(resolve => setTimeout(resolve, 3000));
-    let alive = false;
-    try { process.kill(pid, 0); alive = true; } catch (e) { alive = false; }
-    if (!alive) {
-      emit('error', 'restart-monitor exited during startup; upgrade to ' + remoteVersion + ' not applied');
-      return;
-    }
-    emit('success', 'evolcore upgrade available: ' + localVersion + ' -> ' + remoteVersion + '; restart-monitor started');
-  } catch (error) {
-    emit('error', 'failed to start restart-monitor: ' + (error && error.message ? error.message : String(error)));
-  }
+  const { refreshManagedPackageVersions } = await import(pathToFileURL(entry).href);
+  const results = await refreshManagedPackageVersions(undefined, { source: 'daily-check' });
+  const failed = results.some(result => result.status === 'unavailable');
+  process.stdout.write(JSON.stringify({
+    outcome: failed ? 'error' : 'success',
+    text: results.map(result => result.packageName + ': ' + result.status).join('; '),
+    files: [],
+  }));
 }
-
-main().catch((error) => {
-  emit('error', 'upgrade check failed: ' + (error && error.message ? error.message : String(error)));
+main().catch(() => {
+  process.stdout.write(JSON.stringify({ outcome: 'error', text: 'Version information refresh failed', files: [] }));
+  process.exitCode = 1;
 });
 `);
     // Remove the pre-Node script left by older installations so it cannot be
@@ -529,6 +397,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 +870,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 +1156,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 +1249,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 +1295,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 +1457,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 +1540,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 +1650,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 +1762,7 @@ async function main() {
         const manager = new TriggerDefinitionManager(owner.aid);
         if (opts.seedUpgradeCheck) {
             seedUpgradeCheckTrigger(manager, owner);
+            seedTaskRecoveryTrigger(manager, owner);
         }
         else {
             removeLegacyAgentUpgradeCheck(manager);
@@ -1840,6 +1773,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 +1891,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 +1929,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 +2499,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 +2587,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 +2600,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 +2798,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 +2865,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 +2976,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 +3658,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 +3811,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 +3840,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 +3903,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 +3914,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 +3966,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 +4001,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 +4170,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 +4215,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 +4650,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;