evolcore 0.0.11 → 0.0.12

package/dist/channels/daemon.js

@@ -415,7 +415,11 @@ function normalizeExecutionAnomaly(value) {
         : Date.now();
     const toolName = nonEmptyString(value.toolName);
     const requestId = nonEmptyString(value.requestId);
+    const policyCode = nonEmptyString(value.policyCode);
     const policy = normalizeApproverPolicy(value.policy);
+    const agentAid = nonEmptyString(value.agentAid);
+    const sessionId = nonEmptyString(value.sessionId);
+    const permissionMode = normalizePermissionMode(value.permissionMode);
     const summary = nonEmptyString(value.summary);
     return {
         code: code,
@@ -425,7 +429,11 @@ function normalizeExecutionAnomaly(value) {
         effect,
         ...(toolName ? { toolName } : {}),
         ...(requestId ? { requestId } : {}),
+        ...(policyCode ? { policyCode } : {}),
         ...(policy ? { policy } : {}),
+        ...(agentAid ? { agentAid } : {}),
+        ...(sessionId ? { sessionId } : {}),
+        ...(permissionMode ? { permissionMode } : {}),
         ...(summary ? { summary: summary.slice(0, 512) } : {}),
     };
 }
@@ -437,3 +445,8 @@ function normalizeApproverPolicy(value) {
         ? value
         : undefined;
 }
+function normalizePermissionMode(value) {
+    return value === 'readonly' || value === 'auto' || value === 'request' || value === 'bypass'
+        ? value
+        : undefined;
+}

package/dist/cli/agent-command.js

@@ -59,6 +59,13 @@ Options:
   ec agent delete mybot.agentid.pub --purge`);
         return;
     }
+    if (process.env.EVOLCORE_SESSION_ID && !wantsHelp(args) && !new Set(['get', 'set', 'ready']).has(sub)) {
+        if (formatJson)
+            console.log(JSON.stringify({ ok: false, code: 'NOT_ALLOWED', error: `agent ${sub} is not available in a managed task` }));
+        else
+            console.error(`❌ [NOT_ALLOWED] agent ${sub} is not available in a managed task`);
+        process.exit(1);
+    }
     const { agentList, agentShow, agentCreateInteractive, agentCreateNonInteractive, agentReload, agentEnable, agentDisable, agentGet, agentSet, agentRename, agentDelete, agentReady, } = await import('./agent.js');
     // --- list ---
     if (sub === 'list') {
@@ -137,17 +144,21 @@ Options:
      ec agent new <aid> --non-interactive [选项]
 
 非交互模式选项:
-  --baseagent <claude|codex|gemini|ecagent>   默认: PATH 中第一个可用；ecagent 需显式选择
-  --project <absolute path>           必填
-  --owner <aid>
-  --name <display-name>
-  --description <text>
+  --project <path>                    默认: 当前目录
+  --baseagent <claude|codex|gemini|ecagent>
+                                      默认: defaults 配置，否则检测本机可用基座
+  --owner <aid>                       默认: daemon.json 第一个 owner
+  --name <display-name>               默认: package.json name，否则目录名
+  --description <text>                默认: package.json description，否则留空
+  --dry-run                           只预览最终参数，不注册 AID、不写文件
   --force                             覆盖已有 config.json
   --format json                       输出 JSON
 
 示例:
   ec agent new mybot.agentid.pub
-  ec agent new mybot.agentid.pub --non-interactive --project /abs/path --baseagent claude`);
+  ec agent new mybot.agentid.pub --non-interactive
+  ec agent new mybot.agentid.pub --non-interactive --dry-run --format json
+  ec agent new mybot.agentid.pub --non-interactive --project ../project --baseagent claude`);
             return;
         }
         const name = args[1];
@@ -161,15 +172,52 @@ Options:
                 const idx = args.indexOf(flag);
                 return idx !== -1 && idx + 1 < args.length ? args[idx + 1] : undefined;
             };
-            const result = await agentCreateNonInteractive({
+            const { resolveAgentCreatePlan, validateAgentCreatePlan } = await import('./agent.js');
+            const plan = resolveAgentCreatePlan({
                 aid: name,
+                project: getArg('--project'),
                 baseagent: getArg('--baseagent'),
-                project: getArg('--project') || '',
                 owner: getArg('--owner'),
                 name: getArg('--name'),
                 description: getArg('--description'),
                 force: args.includes('--force'),
             });
+            const validationError = validateAgentCreatePlan(plan);
+            if (validationError) {
+                const error = { ok: false, error: validationError };
+                if (formatJson)
+                    console.log(JSON.stringify(error));
+                else
+                    console.error(`❌ ${error.error}`);
+                process.exitCode = 1;
+                return;
+            }
+            if (args.includes('--dry-run')) {
+                const preview = { ok: true, dryRun: true, plan };
+                if (formatJson)
+                    console.log(JSON.stringify(preview, null, 2));
+                else {
+                    console.log('EvolAgent 创建计划（dry-run）');
+                    console.log(`  AID: ${plan.aid}`);
+                    console.log(`  Project: ${plan.project}`);
+                    console.log(`  Baseagent: ${plan.baseagent} (${plan.baseagentSource})`);
+                    console.log(`  Owner: ${plan.owner || '未设置'} (${plan.ownerSource})`);
+                    console.log(`  Name: ${plan.name} (${plan.nameSource})`);
+                    if (plan.description)
+                        console.log(`  Description: ${plan.description} (${plan.descriptionSource})`);
+                    console.log(`  Existing config: ${plan.configExists ? (plan.force ? '将覆盖' : '是') : '否'}`);
+                }
+                return;
+            }
+            const result = await agentCreateNonInteractive({
+                aid: plan.aid,
+                baseagent: plan.baseagent,
+                project: plan.project,
+                owner: plan.owner,
+                name: plan.name,
+                description: plan.description,
+                force: args.includes('--force'),
+            });
             if (!result.ok) {
                 if (formatJson) {
                     console.log(JSON.stringify(result));

package/dist/cli/agent.js

@@ -2,22 +2,25 @@ import fs from 'fs';
 import path from 'path';
 import readline from 'readline';
 import { resolvePaths, agentMdPath as getAgentMdPathFromPaths, aunPath as defaultAunPath } from '../paths.js';
-import { loadDefaults, loadAllAgents, loadAgent, saveAgent, ensureAgentDirSkeleton } from '../config-store.js';
+import { loadDefaults, loadAllAgents, loadAgent, saveAgent, ensureAgentDirSkeleton, loadDaemonConfig } from '../config-store.js';
 import { ConfigTarget, write as cfgWrite, ensureFile as cfgEnsure, read as cfgRead, initConfigManager } from '../config/config-manager.js';
 import { resolveConfigCommand } from '../config/resolved-config-op.js';
 import { executeResolvedConfigCommand } from '../config/config-operation-service.js';
 import { ipcQuery } from '../ipc.js';
 import { CONFIG_SCHEMA_VERSION } from '../types.js';
 import { normalizeAgentLifecycle, withLifecycleForWrite } from '../config/lifecycle.js';
-import { preparePostBootstrapWelcomeOutbox } from '../core/bootstrap-messages.js';
+import { bindPostBootstrapWelcomeOutboxSession, hasPendingPostBootstrapWelcomeOutbox, postBootstrapWelcomeOperationId, preparePostBootstrapWelcomeOutbox, } from '../core/bootstrap-messages.js';
 import { ensureInitialRoleRegistry } from '../config/role-service.js';
-import { isValidChannelName } from '../core/channel-loader.js';
+import { formatChannelKey, isValidChannelName } from '../core/channel-loader.js';
 import { commandExists } from '../utils/cross-platform.js';
 import { getCodexAppServerAvailability, isCodexAppServerAvailable } from '../agents/codex-runner.js';
 import { resolveEcagentConfig } from '../agents/baseagent.js';
 import { agentProjectRootFromDefaults, deriveAgentProjectPath } from '../utils/project-path.js';
 import { AGENT_DELEGATION_TOKEN_ENV } from '../core/auth/agent-delegation.js';
 import { readTaskRuntimeContextFromEnv } from './task-context.js';
+import { EventBus } from '../core/event-bus.js';
+import { SessionManager } from '../core/session/session-manager.js';
+import { isValidAid } from '../aun/aid/validation.js';
 function withStaticOwner(config, owner) {
     const value = owner?.trim();
     if (!value)
@@ -43,6 +46,100 @@ function detectAvailableBaseagents() {
 function pickDefaultBaseagent(available) {
     return AUTO_BASEAGENT_CANDIDATES.find(candidate => available.includes(candidate)) ?? null;
 }
+function readProjectMetadata(project) {
+    try {
+        const packageJsonPath = path.join(project, 'package.json');
+        if (!fs.existsSync(packageJsonPath))
+            return {};
+        const parsed = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        return {
+            name: typeof parsed.name === 'string' ? parsed.name.trim() : undefined,
+            description: typeof parsed.description === 'string' ? parsed.description.trim() : undefined,
+        };
+    }
+    catch {
+        return {};
+    }
+}
+function projectSlug(project) {
+    const basename = path.basename(project) || 'agent';
+    const slug = basename
+        .normalize('NFKD')
+        .replace(/[^a-zA-Z0-9-]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase()
+        .slice(0, 63)
+        .replace(/-+$/g, '');
+    return slug || 'agent';
+}
+/**
+ * Resolve non-interactive creation defaults without performing any network or
+ * filesystem mutation. The CLI uses this for both execution and --dry-run.
+ */
+export function resolveAgentCreatePlan(options) {
+    const aid = options.aid.trim();
+    const project = path.resolve(options.project || process.cwd());
+    const metadata = readProjectMetadata(project);
+    const defaults = loadDefaults();
+    const daemon = loadDaemonConfig();
+    const configuredBaseagent = defaults?.active_baseagent;
+    const available = detectAvailableBaseagents();
+    const defaultBaseagent = configuredBaseagent && available.includes(configuredBaseagent)
+        ? configuredBaseagent
+        : pickDefaultBaseagent(available) ?? undefined;
+    const baseagent = options.baseagent || defaultBaseagent;
+    const baseagentSource = options.baseagent
+        ? 'argument'
+        : configuredBaseagent && baseagent === configuredBaseagent
+            ? 'defaults'
+            : 'detected';
+    const owner = options.owner?.trim() || daemon.owners?.[0];
+    const ownerSource = options.owner?.trim() ? 'argument' : owner ? 'daemon' : 'none';
+    const name = options.name?.trim() || metadata.name || projectSlug(project);
+    const description = options.description?.trim() || metadata.description || '';
+    const configExists = isValidAid(aid)
+        && fs.existsSync(path.join(resolvePaths().agentsDir, aid, 'config.json'));
+    return {
+        aid,
+        project,
+        baseagent,
+        owner,
+        name,
+        description,
+        force: options.force === true,
+        configExists,
+        baseagentSource,
+        ownerSource,
+        nameSource: options.name?.trim() ? 'argument' : metadata.name ? 'package' : 'directory',
+        descriptionSource: options.description?.trim() ? 'argument' : metadata.description ? 'package' : 'none',
+    };
+}
+export function validateAgentCreatePlan(plan) {
+    if (!isValidAid(plan.aid)) {
+        return `Invalid AID "${plan.aid}": must be a valid multi-level domain (e.g. mybot.agentid.pub)`;
+    }
+    if (plan.configExists && !plan.force) {
+        return `Agent "${plan.aid}" already exists (use --force to overwrite)`;
+    }
+    if (!plan.baseagent) {
+        return 'No usable baseagent detected. Pass --baseagent or configure a baseagent in agents/defaults.json.';
+    }
+    if (!BASEAGENT_CANDIDATES.includes(plan.baseagent)) {
+        return `Invalid baseagent: ${plan.baseagent} (options: ${BASEAGENT_CANDIDATES.join('/')})`;
+    }
+    if (!isBaseagentAvailable(plan.baseagent)) {
+        return `${plan.baseagent} is not available in the current environment`;
+    }
+    if (plan.baseagent === 'ecagent') {
+        const reason = ecagentUnavailableReason();
+        if (reason)
+            return reason;
+    }
+    if (plan.owner && !isValidAid(plan.owner)) {
+        return `Invalid owner: ${plan.owner}`;
+    }
+    return null;
+}
 function ecagentUnavailableReason() {
     try {
         resolveEcagentConfig({ agents: { ecagent: {} } });
@@ -1099,6 +1196,31 @@ export async function agentRename(aid, name) {
     return { ok: true, aid, name };
 }
 // ==================== agentReady ====================
+async function ensureOfflinePostBootstrapMainSession(aid, config) {
+    const owner = config.owners?.[0];
+    if (!owner)
+        throw new Error(`Agent "${aid}" has no owner for the post-bootstrap main session`);
+    const p = resolvePaths();
+    const aunName = config.channels?.find(channel => channel.type === 'aun')?.name || 'main';
+    const channel = formatChannelKey({ type: 'aun', selfAID: aid, name: aunName });
+    const manager = new SessionManager(p.sessionsDir, new EventBus());
+    const active = await manager.getActiveSession(channel, owner);
+    const ensured = await manager.ensureNewMainSessionForOperation({
+        channel,
+        channelId: owner,
+        projectPath: active?.projectPath
+            || config.projects?.defaultPath
+            || path.join(p.root, 'projects', aid.split('.')[0]),
+        baseagent: config.active_baseagent || active?.baseagent || 'claude',
+        operationId: postBootstrapWelcomeOperationId(aid),
+        identityMetadata: {
+            ...(active?.metadata ?? {}),
+            channelKey: channel,
+            peerId: owner,
+        },
+    });
+    return ensured.session.id;
+}
 export async function agentReady(aid) {
     const taskSelfAid = readTaskRuntimeContextFromEnv()?.selfAid;
     if (taskSelfAid && taskSelfAid.replace(/^@/, '') !== aid.replace(/^@/, '')) {
@@ -1109,17 +1231,55 @@ export async function agentReady(aid) {
         };
     }
     const p = resolvePaths();
+    const managedSessionId = process.env.EVOLCORE_SESSION_ID;
+    if (managedSessionId) {
+        const delegationToken = process.env[AGENT_DELEGATION_TOKEN_ENV];
+        if (!delegationToken)
+            return { ok: false, code: 'DELEGATION_REQUIRED', error: `${AGENT_DELEGATION_TOKEN_ENV} is not set for the active task` };
+        const result = await ipcQuery(p.socket, {
+            type: 'evolagent.bootstrapComplete',
+            aid,
+            sessionId: managedSessionId,
+            delegationToken,
+        }, 30_000);
+        if (!result)
+            return { ok: false, code: 'DAEMON_UNAVAILABLE', error: 'Unable to connect to the evolcore daemon' };
+        return result.ok
+            ? { ok: true, aid, reloaded: result.reloaded === true }
+            : { ok: false, code: result.code, error: result.error || 'Failed to complete bootstrap' };
+    }
     const config = loadAgent(aid);
     if (!config)
         return { ok: false, error: `Agent "${aid}" not found` };
     try {
-        const result = await ipcQuery(p.socket, { type: 'evolagent.bootstrapComplete', aid }, 30_000);
+        let controlToken;
+        try {
+            controlToken = fs.readFileSync(p.controlToken, 'utf8').trim() || undefined;
+        }
+        catch { }
+        const result = await ipcQuery(p.socket, { type: 'evolagent.bootstrapComplete', aid, controlToken }, 30_000);
         if (!result) {
             const offlineConfig = loadAgent(aid) || config;
             const lifecycle = normalizeAgentLifecycle(offlineConfig).lifecycle;
-            if (lifecycle === 'active')
-                return { ok: true, aid, reloaded: false };
             if (lifecycle !== 'bootstrapping') {
+                if (lifecycle === 'active') {
+                    if (hasPendingPostBootstrapWelcomeOutbox(aid)) {
+                        try {
+                            const sessionId = await ensureOfflinePostBootstrapMainSession(aid, offlineConfig);
+                            if (!bindPostBootstrapWelcomeOutboxSession(aid, sessionId)) {
+                                throw new Error(`Failed to bind the completion welcome to session ${sessionId}`);
+                            }
+                        }
+                        catch (e) {
+                            return {
+                                ok: false,
+                                code: 'MAIN_SESSION_CREATE_FAILED',
+                                error: e instanceof Error ? e.message : 'Failed to recover the post-bootstrap main session',
+                            };
+                        }
+                    }
+                    return { ok: true, aid, reloaded: false };
+                }
                 return { ok: false, code: 'INVALID_LIFECYCLE', error: `Agent "${aid}" is ${lifecycle}; only a bootstrapping agent can become ready` };
             }
             const owner = offlineConfig.owners?.[0];
@@ -1127,6 +1287,10 @@ export async function agentReady(aid) {
                 return { ok: false, code: 'OWNER_REQUIRED', error: `Agent "${aid}" has no owner for the completion welcome` };
             try {
                 preparePostBootstrapWelcomeOutbox(aid, owner);
+                const sessionId = await ensureOfflinePostBootstrapMainSession(aid, offlineConfig);
+                if (!bindPostBootstrapWelcomeOutboxSession(aid, sessionId)) {
+                    throw new Error(`Failed to bind the completion welcome to session ${sessionId}`);
+                }
                 saveAgent(withLifecycleForWrite(offlineConfig, 'active'));
             }
             catch (e) {