evolcore 0.0.23 → 0.0.25

package/dist/cli/agent-create.js

@@ -0,0 +1,576 @@
+import fs from 'fs';
+import path from 'path';
+import readline from 'readline';
+import { resolvePaths, aunPath as defaultAunPath } from '../paths.js';
+import { loadDefaults, loadAgent, saveAgent, ensureAgentDirSkeleton, loadDaemonConfig } from '../config-store.js';
+import { ConfigTarget, write as cfgWrite, ensureFile as cfgEnsure, read as cfgRead } from '../config/config-manager.js';
+import { ipcQuery } from '../ipc.js';
+import { CONFIG_SCHEMA_VERSION } from '../types.js';
+import { ensureInitialRoleRegistry } from '../config/role-service.js';
+import { getCodexAppServerAvailability } from '../agents/codex-runner.js';
+import { resolveEcagentConfig } from '../agents/baseagent.js';
+import { AUTO_BASEAGENT_CANDIDATES, BASEAGENT_CANDIDATES, detectAvailableBaseagents, } from '../agents/baseagent-availability.js';
+import { agentProjectRootFromDefaults, deriveAgentProjectPath } from '../utils/project-path.js';
+import { isValidAid } from '../aun/aid/validation.js';
+import { AGENT_TAG_MAX_COUNT, AGENT_TAG_MIN_COUNT, DEFAULT_AGENT_DESCRIPTION, validateAgentTags, } from '../aun/aid/agentmd.js';
+export function parseAgentTags(raw) {
+    if (raw === undefined)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error('--tags must be a JSON array of 3 to 6 valid tags');
+    }
+    if (!Array.isArray(parsed))
+        throw new Error('--tags must be a JSON array of 3 to 6 valid tags');
+    const tags = parsed.map(value => typeof value === 'string' ? value.trim() : value);
+    const tagErrors = validateAgentTags(tags, { minCount: AGENT_TAG_MIN_COUNT, maxCount: AGENT_TAG_MAX_COUNT });
+    if (tagErrors.length > 0)
+        throw new Error(`--tags ${tagErrors.join('; ')}`);
+    // Duplicate labels are harmless at the wire level, but should not consume
+    // the advertised 3-6 tag budget or produce duplicate frontmatter entries.
+    return [...new Set(tags)];
+}
+export function validateAgentOwnerOptions(options) {
+    if (options.owner !== undefined && options.owners !== undefined) {
+        return 'Options --owner and --owners are mutually exclusive';
+    }
+    if (options.owners !== undefined && (!Array.isArray(options.owners) || options.owners.length === 0)) {
+        return '--owners must be a non-empty JSON array of AIDs';
+    }
+    const owners = options.owners ?? (options.owner !== undefined ? [options.owner] : []);
+    if (owners.some(owner => typeof owner !== 'string' || !isValidAid(owner))) {
+        return 'Every owner must be a valid AID';
+    }
+    return null;
+}
+/** Shared by the standalone CLI and the authenticated daemon command path. */
+export function parseAgentOwnerArgs(argv) {
+    const hasOwner = argv.includes('--owner');
+    const hasOwners = argv.includes('--owners');
+    if (hasOwner && hasOwners)
+        throw new Error('Options --owner and --owners are mutually exclusive');
+    const value = (flag) => {
+        if (argv.filter(arg => arg === flag).length !== 1)
+            throw new Error(`${flag} must be supplied once`);
+        const argument = argv[argv.indexOf(flag) + 1];
+        if (!argument || argument.startsWith('--'))
+            throw new Error(`${flag} requires a value`);
+        return argument;
+    };
+    const options = {};
+    if (hasOwner)
+        options.owner = value('--owner');
+    if (hasOwners) {
+        const raw = value('--owners');
+        try {
+            options.owners = JSON.parse(raw);
+        }
+        catch {
+            throw new Error('--owners must be a non-empty JSON array of AIDs');
+        }
+    }
+    const error = validateAgentOwnerOptions(options);
+    if (error)
+        throw new Error(error);
+    if (options.owners)
+        options.owners = [...new Set(options.owners)];
+    return options;
+}
+function withStaticOwners(config, ownersInput) {
+    const values = (ownersInput ?? []).map(value => value.trim()).filter(Boolean);
+    if (values.length === 0)
+        return config;
+    const owners = config.owners ?? [];
+    return { ...config, owners: [...new Set([...owners, ...values])] };
+}
+function withStaticOwner(config, owner) {
+    return withStaticOwners(config, owner ? [owner] : undefined);
+}
+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';
+}
+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 owners = options.owners;
+    const owner = options.owner?.trim() || (owners === undefined ? daemon.owners?.[0] : undefined);
+    const ownerSource = owners !== undefined || options.owner?.trim() ? 'argument' : owner ? 'daemon' : 'none';
+    const name = options.name?.trim() || metadata.name || projectSlug(project);
+    const description = options.description?.trim() || metadata.description || DEFAULT_AGENT_DESCRIPTION;
+    const configExists = isValidAid(aid) && fs.existsSync(path.join(resolvePaths().agentsDir, aid, 'config.json'));
+    return {
+        aid, project, baseagent, owner, owners, handoff: options.handoff, name, description, tags: options.tags,
+        force: options.force === true, configExists, baseagentSource, ownerSource,
+        nameSource: options.name?.trim() ? 'argument' : metadata.name ? 'package' : 'directory',
+        descriptionSource: options.description?.trim() ? 'argument' : metadata.description ? 'package' : 'default',
+    };
+}
+export function validateAgentCreatePlan(plan) {
+    const ownerError = validateAgentOwnerOptions(plan);
+    if (ownerError)
+        return ownerError;
+    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.tags !== undefined) {
+        const tagErrors = validateAgentTags(plan.tags, { minCount: AGENT_TAG_MIN_COUNT, maxCount: AGENT_TAG_MAX_COUNT });
+        if (tagErrors.length > 0)
+            return `Invalid tags: ${tagErrors.join('; ')}`;
+    }
+    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 (!detectAvailableBaseagents().includes(plan.baseagent)) {
+        return `${plan.baseagent} is not available in the current environment`;
+    }
+    if (plan.baseagent === 'ecagent') {
+        const reason = ecagentUnavailableReason();
+        if (reason)
+            return reason;
+    }
+    return null;
+}
+function ecagentUnavailableReason() {
+    try {
+        resolveEcagentConfig({ agents: { ecagent: {} } });
+        return undefined;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
+function saveInitialBehavior(aid, baseagent) {
+    const behavior = {
+        active_baseagent: baseagent,
+        baseagents: { [baseagent]: {} },
+        chatmode: { private: 'interactive', group: 'proactive', nothuman: 'proactive' },
+    };
+    const sel = { self: aid };
+    const existingBehavior = cfgRead(ConfigTarget.Agent, sel) || {};
+    cfgEnsure(ConfigTarget.Agent, sel);
+    cfgWrite(ConfigTarget.Agent, { ...existingBehavior, ...behavior }, sel);
+}
+function toPosix(value) {
+    return value ? value.replace(/\\/g, '/') : null;
+}
+export async function agentCreateInteractive(opts = {}) {
+    const p = resolvePaths();
+    const ownRl = !opts.rl;
+    const rl = opts.rl ?? readline.createInterface({ input: opts.stdin || process.stdin, output: opts.stdout || process.stdout });
+    const ask = (q) => new Promise(r => rl.question(q, r));
+    try {
+        const { aidCreate, buildInitialAgentMd, agentmdPut } = await import('../aun/aid/index.js');
+        const aidPrompt = opts.suggestedName ? `AID [${opts.suggestedName}]: ` : 'AID (e.g. mybot.agentid.pub): ';
+        let aid = '';
+        while (!aid) {
+            const aidInput = (await ask(aidPrompt)).trim();
+            const candidate = aidInput || opts.suggestedName;
+            if (!candidate) {
+                console.log('  ⚠ AID is required.');
+                continue;
+            }
+            if (!isValidAid(candidate)) {
+                console.log(`  ⚠ Invalid AID "${candidate}": must be a valid multi-level domain (e.g. mybot.agentid.pub)`);
+                continue;
+            }
+            aid = candidate;
+        }
+        const agentDirPath = path.join(p.agentsDir, aid);
+        const configExists = fs.existsSync(path.join(agentDirPath, 'config.json'));
+        if (configExists) {
+            const ans = (await ask(`Agent "${aid}" already exists. Overwrite config.json? (AID 与 agent.md 保留) [y/N]: `)).trim().toLowerCase();
+            if (ans !== 'y' && ans !== 'yes')
+                return { ok: false, error: 'Aborted.' };
+        }
+        console.log(`\nCreating agent: ${aid}\n`);
+        let aidCreated = false;
+        try {
+            const result = await aidCreate(aid);
+            try {
+                await result.client.close();
+            }
+            catch { /* ignore */ }
+            aidCreated = !result.alreadyExisted;
+            console.log(`  ✓ AID ${result.alreadyExisted ? 'reused' : 'created'}: ${aid}`);
+        }
+        catch (e) {
+            return { ok: false, error: `AID creation failed: ${e?.message || e}` };
+        }
+        let suggestedProjectPath = '';
+        try {
+            suggestedProjectPath = deriveAgentProjectPath(agentProjectRootFromDefaults(loadDefaults(), p.root), aid);
+        }
+        catch {
+            suggestedProjectPath = deriveAgentProjectPath(agentProjectRootFromDefaults(null, p.root), aid);
+        }
+        const projectInput = (await ask(`Project path [${suggestedProjectPath}]: `)).trim();
+        const projectPath = projectInput || suggestedProjectPath;
+        if (!path.isAbsolute(projectPath))
+            return { ok: false, error: 'Project path must be an absolute path.' };
+        if (!fs.existsSync(projectPath)) {
+            const create = (await ask(`Project path does not exist. Create? [Y/n]: `)).trim().toLowerCase();
+            if (create === '' || create === 'y' || create === 'yes') {
+                try {
+                    fs.mkdirSync(projectPath, { recursive: true });
+                }
+                catch (e) {
+                    return { ok: false, error: `Failed to create project path "${projectPath}": ${e?.message || e}` };
+                }
+                console.log(`  ✓ Created ${projectPath}`);
+            }
+            else
+                return { ok: false, error: 'Aborted.' };
+        }
+        const available = detectAvailableBaseagents();
+        if (available.length === 0 || (available.length === 1 && available[0] === 'ecagent' && ecagentUnavailableReason())) {
+            return { ok: false, error: 'No usable baseagent detected. Install claude/gemini CLI or codex CLI with app-server, or configure bundled ecagent.' };
+        }
+        const defaultBa = pickDefaultBaseagent(available);
+        let baseagent;
+        if (available.length === 1 && defaultBa) {
+            console.log(`  Baseagent: ${defaultBa}`);
+            baseagent = defaultBa;
+        }
+        else {
+            let chosen = null;
+            while (chosen === null) {
+                const defaultHint = defaultBa ? ` [${defaultBa}]` : '';
+                const input = (await ask(`Baseagent (${available.join('/')})${defaultHint}: `)).trim() || defaultBa;
+                if (!input) {
+                    console.log('  ecagent is optional; enter ecagent to select it explicitly.');
+                    continue;
+                }
+                if (!BASEAGENT_CANDIDATES.includes(input)) {
+                    console.log(`  Invalid choice. Options: ${BASEAGENT_CANDIDATES.join('/')}`);
+                    continue;
+                }
+                if (!available.includes(input)) {
+                    console.log(`  ${input} is not available in the current environment. Available: ${available.join('/')}`);
+                    continue;
+                }
+                if (input === 'ecagent') {
+                    const reason = ecagentUnavailableReason();
+                    if (reason) {
+                        console.log(`  ecagent is unavailable: ${reason}`);
+                        continue;
+                    }
+                }
+                chosen = input;
+            }
+            baseagent = chosen;
+        }
+        const daemonCfg = loadDaemonConfig();
+        const daemonHasOwner = !!daemonCfg.owners?.length;
+        let owner;
+        let skipQrBinding = false;
+        if (daemonHasOwner) {
+            const defaultOwner = daemonCfg.owners[0];
+            while (true) {
+                const ownerInput = (await ask(`Owner AID [${defaultOwner}]: `)).trim();
+                if (!ownerInput) {
+                    owner = defaultOwner;
+                    break;
+                }
+                if (ownerInput.toLowerCase() === 'new' || ownerInput.toLowerCase() === 'qr') {
+                    break;
+                }
+                if (!isValidAid(ownerInput)) {
+                    console.log(`  ⚠ Invalid Owner AID "${ownerInput}"`);
+                    continue;
+                }
+                owner = ownerInput;
+                skipQrBinding = true;
+                break;
+            }
+        }
+        const defaultName = aid.split('.')[0];
+        const agentName = (await ask(`Display name [${defaultName}]: `)).trim() || defaultName;
+        const agentDescription = (await ask('Description (optional): ')).trim() || '';
+        const tagInput = (await ask('Tags (3-6, comma separated; optional): ')).trim();
+        let agentTags;
+        if (tagInput) {
+            agentTags = [...new Set(tagInput.split(/[,，\s]+/).map(tag => tag.trim()).filter(Boolean))];
+            const tagErrors = validateAgentTags(agentTags, { minCount: AGENT_TAG_MIN_COUNT, maxCount: AGENT_TAG_MAX_COUNT });
+            if (tagErrors.length > 0)
+                return { ok: false, error: `Invalid tags: ${tagErrors.join('; ')}` };
+        }
+        if (ownRl)
+            rl.close();
+        saveAgent(withStaticOwner({ $schema_version: CONFIG_SCHEMA_VERSION, aid, enabled: true, lifecycle: 'created', channels: [], projects: { defaultPath: projectPath } }, owner));
+        ensureInitialRoleRegistry(aid);
+        saveInitialBehavior(aid, baseagent);
+        ensureAgentDirSkeleton(aid);
+        let agentmdUploaded = false;
+        try {
+            const content = buildInitialAgentMd({ aid, name: agentName, description: agentDescription, tags: agentTags });
+            const aunPath = process.env.AUN_HOME || defaultAunPath();
+            let lastError;
+            for (let attempt = 1; attempt <= 3; attempt++) {
+                try {
+                    if (attempt > 1)
+                        await new Promise(r => setTimeout(r, 2000));
+                    await agentmdPut(content, { aid, aunPath });
+                    agentmdUploaded = true;
+                    break;
+                }
+                catch (e) {
+                    lastError = e;
+                }
+            }
+            if (!agentmdUploaded)
+                console.warn(`  ⚠ agent.md upload failed: ${lastError?.message || lastError}`);
+            await new Promise(r => setTimeout(r, 0));
+        }
+        catch (e) {
+            console.warn(`  ⚠ agent.md generation failed: ${e?.message || e}`);
+        }
+        let hotLoaded = false;
+        let hotLoadError;
+        try {
+            const ipcResult = await ipcQuery(p.socket, { type: 'evolagent.load', aid }, 30_000);
+            if (ipcResult?.ok)
+                hotLoaded = true;
+            else if (ipcResult)
+                hotLoadError = ipcResult.error;
+        }
+        catch { /* daemon not running */ }
+        let ownerBoundAid;
+        let ownerBindSkipped = false;
+        let ownerBindInterrupted = false;
+        if (!owner && !skipQrBinding && process.stdin.isTTY && daemonHasOwner) {
+            try {
+                const { runAgentOwnerQrBindFlow } = await import('./init-channel.js');
+                const bound = await runAgentOwnerQrBindFlow(aid, agentName);
+                if (bound.action === 'bound')
+                    ownerBoundAid = bound.boundAid;
+                else if (bound.action === 'manual') {
+                    ownerBindSkipped = true;
+                    ownerBoundAid = await promptAgentOwnerManually(aid);
+                }
+                else
+                    ownerBindInterrupted = true;
+            }
+            catch {
+                ownerBindSkipped = true;
+                ownerBoundAid = await promptAgentOwnerManually(aid);
+            }
+        }
+        return { ok: true, aid, configPath: toPosix(path.join(agentDirPath, 'config.json')), aidCreated, agentmdUploaded, hotLoaded, hotLoadError, ownerBoundAid, ownerBindSkipped, ownerBindInterrupted };
+    }
+    finally {
+        if (ownRl) {
+            try {
+                rl.close();
+            }
+            catch { /* ignore */ }
+        }
+    }
+}
+async function promptAgentOwnerManually(aid) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        while (true) {
+            const owner = (await new Promise(resolve => rl.question('\n扫码未完成。手动输入 agent owner AID（留空跳过）: ', resolve))).trim();
+            if (!owner)
+                return undefined;
+            if (!isValidAid(owner)) {
+                console.log('  ⚠ Owner AID 格式无效');
+                continue;
+            }
+            const agent = loadAgent(aid);
+            if (!agent)
+                return undefined;
+            saveAgent(withStaticOwner(agent, owner));
+            try {
+                await ipcQuery(resolvePaths().socket, { type: 'evolagent.reload', name: aid }, 30_000);
+            }
+            catch { /* daemon not running */ }
+            return owner;
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function agentCreateNonInteractive(opts, runtime = {}) {
+    const p = resolvePaths();
+    const { aidCreate, buildInitialAgentMd, agentmdPut } = await import('../aun/aid/index.js');
+    opts.onPhase?.('validating', 'begin');
+    const failValidating = (error) => { opts.onPhase?.('validating', 'failed', error); return { ok: false, error }; };
+    const ownerError = validateAgentOwnerOptions(opts);
+    if (ownerError)
+        return failValidating(ownerError);
+    if (opts.tags !== undefined) {
+        const tagErrors = validateAgentTags(opts.tags, { minCount: AGENT_TAG_MIN_COUNT, maxCount: AGENT_TAG_MAX_COUNT });
+        if (tagErrors.length > 0)
+            return failValidating(`Invalid tags: ${tagErrors.join('; ')}`);
+    }
+    if (!isValidAid(opts.aid))
+        return failValidating(`Invalid AID "${opts.aid}": must be a valid multi-level domain (e.g. mybot.agentid.pub)`);
+    const agentDirPath = path.join(p.agentsDir, opts.aid);
+    const configExists = fs.existsSync(path.join(agentDirPath, 'config.json'));
+    if (configExists && !opts.force)
+        return failValidating(`Agent "${opts.aid}" already exists: ${agentDirPath}/config.json (use --force to overwrite)`);
+    const available = detectAvailableBaseagents();
+    if (available.length === 0 || (available.length === 1 && available[0] === 'ecagent' && ecagentUnavailableReason()))
+        return failValidating('No usable baseagent detected. Install claude/gemini CLI or codex CLI with app-server, or configure bundled ecagent.');
+    let baseagent;
+    if (opts.baseagent) {
+        if (!BASEAGENT_CANDIDATES.includes(opts.baseagent))
+            return failValidating(`Invalid baseagent: ${opts.baseagent} (options: ${BASEAGENT_CANDIDATES.join('/')})`);
+        if (!available.includes(opts.baseagent))
+            return failValidating(opts.baseagent === 'codex' ? getCodexAppServerAvailability().reason || `${opts.baseagent} is not available in the current environment` : `${opts.baseagent} is not available in the current environment (available: ${available.join('/')})`);
+        if (opts.baseagent === 'ecagent') {
+            const reason = ecagentUnavailableReason();
+            if (reason)
+                return failValidating(reason);
+        }
+        baseagent = opts.baseagent;
+    }
+    else {
+        const defaultBaseagent = pickDefaultBaseagent(available);
+        if (!defaultBaseagent)
+            return failValidating('ecagent is optional; pass --baseagent ecagent after configuring its API key');
+        baseagent = defaultBaseagent;
+    }
+    if (!path.isAbsolute(opts.project))
+        return failValidating(`--project must be absolute: ${opts.project}`);
+    if (!fs.existsSync(opts.project)) {
+        try {
+            fs.mkdirSync(opts.project, { recursive: true });
+        }
+        catch (e) {
+            return failValidating(`Failed to create ${opts.project}: ${e?.message || e}`);
+        }
+    }
+    opts.onPhase?.('validating', 'done');
+    opts.onPhase?.('registering_aid', 'begin');
+    let aidCreated = false;
+    try {
+        const result = await aidCreate(opts.aid);
+        try {
+            await result.client.close();
+        }
+        catch { /* ignore */ }
+        aidCreated = !result.alreadyExisted;
+        opts.onPhase?.('registering_aid', 'done', aidCreated ? 'created' : 'existed');
+    }
+    catch (e) {
+        const error = `AID creation failed: ${e?.message || e}`;
+        opts.onPhase?.('registering_aid', 'failed', error);
+        return { ok: false, error };
+    }
+    let preservedLifecycle = 'created';
+    if (configExists) {
+        try {
+            const existing = loadAgent(opts.aid);
+            if (existing?.lifecycle)
+                preservedLifecycle = existing.lifecycle;
+        }
+        catch { /* ignore */ }
+    }
+    opts.onPhase?.('config_saved', 'begin');
+    saveAgent(withStaticOwners({ $schema_version: CONFIG_SCHEMA_VERSION, aid: opts.aid, enabled: true, lifecycle: preservedLifecycle, channels: [], projects: { defaultPath: opts.project } }, opts.owners ?? (opts.owner ? [opts.owner] : undefined)));
+    ensureInitialRoleRegistry(opts.aid);
+    saveInitialBehavior(opts.aid, baseagent);
+    ensureAgentDirSkeleton(opts.aid);
+    opts.onPhase?.('config_saved', 'done');
+    opts.onPhase?.('uploading_agentmd', 'begin');
+    let agentmdUploaded = false;
+    try {
+        const content = buildInitialAgentMd({ aid: opts.aid, name: opts.name, description: opts.description, tags: opts.tags });
+        const aunPath = process.env.AUN_HOME || defaultAunPath();
+        let lastError;
+        for (let attempt = 1; attempt <= 3; attempt++) {
+            try {
+                if (attempt > 1)
+                    await new Promise(r => setTimeout(r, 2000));
+                await agentmdPut(content, { aid: opts.aid, aunPath });
+                agentmdUploaded = true;
+                opts.onPhase?.('uploading_agentmd', 'done');
+                break;
+            }
+            catch (e) {
+                lastError = e;
+            }
+        }
+        if (!agentmdUploaded)
+            opts.onPhase?.('uploading_agentmd', 'warn', `upload failed: ${lastError?.message || lastError}`);
+        await new Promise(r => setTimeout(r, 0));
+    }
+    catch (e) {
+        opts.onPhase?.('uploading_agentmd', 'warn', `generation failed: ${e?.message || e}`);
+    }
+    let hotLoaded = false;
+    let hotLoadError;
+    opts.onPhase?.('hot_loading', 'begin');
+    try {
+        if (runtime.hotLoadAgent) {
+            await runtime.hotLoadAgent(opts.aid);
+            hotLoaded = true;
+            opts.onPhase?.('hot_loading', 'done');
+        }
+        else {
+            const ipcResult = await ipcQuery(p.socket, { type: 'evolagent.load', aid: opts.aid }, 30_000);
+            if (ipcResult?.ok) {
+                hotLoaded = true;
+                opts.onPhase?.('hot_loading', 'done');
+            }
+            else if (ipcResult) {
+                hotLoadError = ipcResult.error;
+                opts.onPhase?.('hot_loading', 'warn', hotLoadError);
+            }
+            else
+                opts.onPhase?.('hot_loading', 'warn', 'daemon not running');
+        }
+    }
+    catch (error) {
+        hotLoadError = error instanceof Error ? error.message : String(error);
+        opts.onPhase?.('hot_loading', 'warn', hotLoadError);
+    }
+    return { ok: true, aid: opts.aid, ownerAid: (opts.owners ?? (opts.owner ? [opts.owner] : undefined))?.[0], configPath: toPosix(path.join(agentDirPath, 'config.json')), aidCreated, agentmdUploaded, hotLoaded, hotLoadError };
+}