evolclaw 2.8.1 → 2.8.2

package/dist/agents/templates.js

@@ -0,0 +1,122 @@
+import fs from 'fs';
+import path from 'path';
+import { getPackageRoot, resolveRoot } from '../paths.js';
+import { logger } from '../utils/logger.js';
+const KNOWN_SECTIONS = new Set(['runtime', 'group', 'proactive']);
+const SECTION_RE = /^##\s+(\w+)\s*$/;
+let sections = null;
+let builtinSections = null;
+function parseTemplate(content) {
+    const result = new Map();
+    let currentSection = null;
+    let currentLines = [];
+    for (const line of content.split('\n')) {
+        // Stop parsing at horizontal rule separator (documentation follows)
+        if (/^---\s*$/.test(line)) {
+            if (currentSection) {
+                result.set(currentSection, currentLines.join('\n').trim());
+            }
+            break;
+        }
+        const m = line.match(SECTION_RE);
+        if (m) {
+            if (currentSection) {
+                result.set(currentSection, currentLines.join('\n').trim());
+            }
+            const name = m[1];
+            if (KNOWN_SECTIONS.has(name)) {
+                currentSection = name;
+                currentLines = [];
+            }
+            else {
+                currentSection = null;
+                currentLines = [];
+            }
+        }
+        else if (currentSection) {
+            currentLines.push(line);
+        }
+    }
+    if (currentSection) {
+        result.set(currentSection, currentLines.join('\n').trim());
+    }
+    return result;
+}
+function loadBuiltinTemplate() {
+    const builtinPath = path.join(getPackageRoot(), 'dist', 'templates', 'prompts.md');
+    const srcPath = path.join(getPackageRoot(), 'src', 'templates', 'prompts.md');
+    const filePath = fs.existsSync(builtinPath) ? builtinPath : srcPath;
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return parseTemplate(content);
+}
+export function loadPromptTemplates() {
+    builtinSections = loadBuiltinTemplate();
+    const userPath = path.join(resolveRoot(), 'data', 'prompts.md');
+    if (fs.existsSync(userPath)) {
+        try {
+            const content = fs.readFileSync(userPath, 'utf-8');
+            const parsed = parseTemplate(content);
+            sections = new Map(builtinSections);
+            for (const [key, value] of parsed) {
+                sections.set(key, value);
+            }
+            logger.info(`[PromptTemplates] Loaded user override: ${userPath}`);
+        }
+        catch (err) {
+            logger.warn(`[PromptTemplates] Failed to load user override (${userPath}), using builtin:`, err);
+            sections = builtinSections;
+        }
+    }
+    else {
+        sections = builtinSections;
+        logger.info(`[PromptTemplates] Using builtin templates`);
+    }
+    for (const name of KNOWN_SECTIONS) {
+        if (!sections.has(name)) {
+            logger.warn(`[PromptTemplates] Section "${name}" missing, using builtin fallback`);
+            const fallback = builtinSections.get(name);
+            if (fallback)
+                sections.set(name, fallback);
+        }
+    }
+}
+function isTruthy(val) {
+    if (val === undefined || val === null || val === false || val === '' || val === 0)
+        return false;
+    return true;
+}
+function renderTemplate(template, vars) {
+    // Pass 1: conditional sections {{?key}}...{{/}}
+    let result = template.replace(/\{\{\?(\w+)\}\}([\s\S]*?)\{\{\/\}\}/g, (_match, key, body) => {
+        return isTruthy(vars[key]) ? body : '';
+    });
+    // Pass 2: variable substitution {{key}}
+    result = result.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
+        const val = vars[key];
+        if (!isTruthy(val))
+            return '';
+        return String(val);
+    });
+    // Pass 3: remove blank lines
+    return result.split('\n').filter(line => line.trim() !== '').join('\n');
+}
+export function renderPromptSection(section, vars) {
+    if (!sections)
+        loadPromptTemplates();
+    const template = sections.get(section);
+    if (!template) {
+        logger.warn(`[PromptTemplates] Section "${section}" not found`);
+        return '';
+    }
+    return renderTemplate(template, vars);
+}
+/** Reset loaded templates (for testing) */
+export function _resetTemplates() {
+    sections = null;
+    builtinSections = null;
+}
+/** Load templates from a raw string (for testing) */
+export function _loadFromString(content) {
+    builtinSections = parseTemplate(content);
+    sections = builtinSections;
+}

package/dist/channels/aun-ops.js

@@ -12,7 +12,7 @@ import { execFileSync } from 'child_process';
 import { isWindows } from '../utils/cross-platform.js';
 import { resolvePaths } from '../paths.js';
 // ==================== Constants ====================
-export const MIN_AUN_CORE_SDK = [0, 2, 14];
+export const MIN_AUN_CORE_SDK = [0, 2, 17];
 export const AUN_CORE_SDK_PKG = '@agentunion/fastaun';
 // ==================== SDK & Environment ====================
 function compareVersion(a, min) {

package/dist/channels/qqbot.js

@@ -1,5 +1,5 @@
 import { logger } from '../utils/logger.js';
-import { markdownToPlainText } from '../utils/format.js';
+import { markdownToPlainText } from '../utils/rich-content-renderer.js';
 import { requireOptional } from '../utils/init-channel.js';
 import { normalizeChannelInstances, getChannelShowActivities } from '../config.js';
 // ── QQBotChannel ────────────────────────────────────────────────────────────

package/dist/channels/wechat.js

@@ -4,7 +4,7 @@ import path from 'path';
 import { resolvePaths } from '../paths.js';
 import { logger } from '../utils/logger.js';
 import { sanitizeFileName, saveToUploads, safeFetch } from '../utils/media-cache.js';
-import { markdownToPlainText } from '../utils/format.js';
+import { markdownToPlainText } from '../utils/rich-content-renderer.js';
 const CHANNEL_VERSION = '1.0.0';
 const ILINK_APP_ID = 'bot';
 // iLink-App-ClientVersion: major<<16 | minor<<8 | patch (uint32)

package/dist/cli.js

@@ -68,13 +68,11 @@ function rotateLogs(logDir) {
 function countLines(pkgRoot, logDir) {
     const srcDir = path.join(pkgRoot, 'src');
     const statsFile = path.join(logDir, 'line-stats.log');
-    const countDir = (dir, exclude) => {
+    const countDir = (dir) => {
         if (!fs.existsSync(dir))
             return 0;
         let total = 0;
         for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-            if (exclude && entry.name === exclude)
-                continue;
             const full = path.join(dir, entry.name);
             if (entry.isDirectory()) {
                 total += countDir(full);
@@ -93,12 +91,14 @@ function countLines(pkgRoot, logDir) {
     console.log('\n[launcher] 正在统计代码行数...\n');
     const core = countDir(path.join(srcDir, 'core'));
     const agents = countDir(path.join(srcDir, 'agents'));
-    const channels = countDir(path.join(srcDir, 'channels'), 'experimental');
+    const channels = countDir(path.join(srcDir, 'channels'));
     const utils = countDir(path.join(srcDir, 'utils'));
     const entry = countFile(path.join(srcDir, 'index.ts'))
         + countFile(path.join(srcDir, 'config.ts'))
         + countFile(path.join(srcDir, 'types.ts'))
-        + countFile(path.join(srcDir, 'cli.ts'));
+        + countFile(path.join(srcDir, 'cli.ts'))
+        + countFile(path.join(srcDir, 'ipc.ts'))
+        + countFile(path.join(srcDir, 'paths.ts'));
     const total = core + agents + channels + utils + entry;
     console.log('==================================================');
     console.log('EvolClaw 代码统计');
@@ -607,20 +607,26 @@ async function cmdStatus() {
             showConfigChannels(config);
         }
     }
-    console.log('');
-    console.log('📁 Log Files:');
-    const mainLog = path.join(p.logs, 'evolclaw.log');
-    if (fs.existsSync(mainLog)) {
-        const stat = fs.statSync(mainLog);
-        const sizeMB = (stat.size / 1024 / 1024).toFixed(1);
-        console.log(`  Main log: ${mainLog} (${sizeMB} MB)`);
-        console.log('');
-        console.log('📝 Recent activity (last 30 lines):');
-        const content = fs.readFileSync(mainLog, 'utf-8').trim().split('\n');
-        console.log(content.slice(-30).map(l => `  ${l}`).join('\n'));
-    }
-    else {
-        console.log('  (no log file yet)');
+    // EvolAgent summary (via IPC, only when running)
+    if (pid) {
+        try {
+            const agentResult = await ipcQuery(p.socket, { type: 'evolagent.list' });
+            if (agentResult?.ok && agentResult.agents?.length > 0) {
+                const agents = agentResult.agents.filter((a) => !a.isDefault);
+                if (agents.length > 0) {
+                    console.log('');
+                    console.log('🤖 EvolAgents:');
+                    for (const a of agents) {
+                        const statusIcon = a.status === 'running' ? '●' : a.status === 'error' ? '✗' : a.status === 'disabled' ? '○' : '◌';
+                        const channels = a.channels?.join(', ') || '—';
+                        console.log(`  ${statusIcon} ${a.name.padEnd(14)} ${a.status.padEnd(10)} ${channels}`);
+                    }
+                }
+            }
+        }
+        catch {
+            // IPC query for agents failed — skip section
+        }
     }
 }
 // Log line pattern: [timestamp] [LEVEL] [Module?] message
@@ -1388,11 +1394,18 @@ async function cmdAgent(args) {
     }
     if (sub === 'new') {
         const name = args[1];
-        if (!name) {
-            console.error('Usage: evolclaw agent new <name>');
-            process.exit(1);
+        const nonInteractive = args.includes('--non-interactive');
+        if (nonInteractive) {
+            if (!name) {
+                console.error('Usage: evolclaw agent new <name> --non-interactive ...');
+                process.exit(1);
+            }
+            await cmdAgentNewNonInteractive(name, args.slice(2));
+        }
+        else {
+            // Interactive mode: name from CLI is suggested default; user can override at prompt
+            await cmdAgentNew(name);
         }
-        await cmdAgentNew(name);
         return;
     }
     if (sub === 'reload') {
@@ -1401,16 +1414,42 @@ async function cmdAgent(args) {
             console.error('Usage: evolclaw agent reload <name>');
             process.exit(1);
         }
-        // Phase 1 stub: no IPC yet
-        console.error('⚠ evolclaw 未运行或 IPC 未就绪，请使用 evolclaw restart 重新加载所有 agent');
-        process.exit(1);
+        const p = resolvePaths();
+        try {
+            const result = await ipcQuery(p.socket, { type: 'evolagent.reload', name });
+            if (result && result.ok) {
+                console.log(`✓ Agent "${name}" reloaded`);
+            }
+            else {
+                console.error(`✗ Reload failed: ${result?.error || 'unknown error'}`);
+                process.exit(1);
+            }
+        }
+        catch {
+            console.error('⚠ evolclaw 未运行，请先 evolclaw start 后再 reload');
+            console.log('  或直接 evolclaw restart 重新加载所有 agent');
+            process.exit(1);
+        }
+        return;
     }
     // `evolclaw agent <name>` — show detail
     await cmdAgentShow(sub);
 }
 async function cmdAgentList() {
     const p = resolvePaths();
-    const { AgentRegistry } = await import('./core/agent-registry.js');
+    // Try IPC first (running process has real status)
+    try {
+        const result = await ipcQuery(p.socket, { type: 'evolagent.list' });
+        if (result && result.ok && result.agents) {
+            printAgentTable(result.agents);
+            return;
+        }
+    }
+    catch {
+        // IPC unavailable — fall through to cold mode
+    }
+    // Cold mode: read from disk
+    const { EvolAgentRegistry } = await import('./core/evolagent-registry.js');
     const { loadConfig } = await import('./config.js');
     let config;
     try {
@@ -1419,22 +1458,26 @@ async function cmdAgentList() {
     catch {
         config = { agents: {}, channels: {}, projects: { defaultPath: process.cwd() } };
     }
-    const registry = new AgentRegistry(p.agentsDir);
+    const registry = new EvolAgentRegistry(p.agentsDir);
     registry.loadAll(config);
-    const list = registry.list();
+    printAgentTable(registry.list());
+}
+function printAgentTable(list) {
     if (list.length === 0) {
         console.log('No agents configured.');
         return;
     }
-    // Table output
-    console.log('NAME'.padEnd(14) + 'STATUS'.padEnd(10) + 'CHANNELS'.padEnd(24) + 'PROJECT'.padEnd(22) + 'BASEAGENT'.padEnd(11) + 'LAST ACTIVE');
+    console.log('NAME'.padEnd(14) + 'STATUS'.padEnd(10) + 'CHANNELS'.padEnd(24) +
+        'PROJECT'.padEnd(22) + 'BASEAGENT'.padEnd(11) + 'LAST ACTIVE');
     for (const info of list) {
         const name = info.isDefault ? '[default]' : info.name;
-        const status = info.status;
-        const channels = info.channels.length > 0 ? info.channels.join(', ').slice(0, 22) : '—';
+        const status = info.status || 'stopped';
+        const channels = info.channels?.length > 0 ? info.channels.join(', ').slice(0, 22) : '—';
         const project = info.projectPath ? path.basename(info.projectPath) : '—';
         const baseagent = info.baseagent || '—';
-        const lastActive = info.lastActivity ? formatTimeAgo(Date.now() - info.lastActivity) : '—';
+        const lastActive = info.lastActivity
+            ? formatTimeAgo(Date.now() - info.lastActivity)
+            : '—';
         console.log(name.padEnd(14) +
             status.padEnd(10) +
             channels.padEnd(24) +
@@ -1445,7 +1488,33 @@ async function cmdAgentList() {
 }
 async function cmdAgentShow(name) {
     const p = resolvePaths();
-    const { AgentRegistry } = await import('./core/agent-registry.js');
+    // Try IPC first
+    try {
+        const result = await ipcQuery(p.socket, { type: 'evolagent.show', name });
+        if (result && result.ok && result.agent) {
+            const info = result.agent;
+            console.log(`${info.name} (${info.status})\n`);
+            console.log(`  Baseagent:  ${info.baseagent}`);
+            if (info.model)
+                console.log(`  Model:      ${info.model}`);
+            if (info.effort)
+                console.log(`  Effort:     ${info.effort}`);
+            console.log(`  Project:    ${info.projectPath}`);
+            console.log(`  Channels:   ${info.channels?.join(', ') || '—'}`);
+            if (info.activeSessions)
+                console.log(`  Sessions:   ${info.activeSessions} active`);
+            if (info.lastActivity)
+                console.log(`  Last active: ${formatTimeAgo(Date.now() - info.lastActivity)}`);
+            if (info.error)
+                console.log(`  Error:      ${info.error}`);
+            return;
+        }
+    }
+    catch {
+        // IPC unavailable — fall through to cold mode
+    }
+    // Cold mode
+    const { EvolAgentRegistry } = await import('./core/evolagent-registry.js');
     const { loadConfig } = await import('./config.js');
     let config;
     try {
@@ -1454,7 +1523,7 @@ async function cmdAgentShow(name) {
     catch {
         config = { agents: {}, channels: {}, projects: { defaultPath: process.cwd() } };
     }
-    const registry = new AgentRegistry(p.agentsDir);
+    const registry = new EvolAgentRegistry(p.agentsDir);
     registry.loadAll(config);
     const agent = registry.get(name);
     if (!agent) {
@@ -1478,22 +1547,67 @@ async function cmdAgentShow(name) {
     if (agent.configPath)
         console.log(`  Config:     ${agent.configPath}`);
 }
-async function cmdAgentNew(name) {
+async function cmdAgentNew(suggestedName) {
     const p = resolvePaths();
-    const agentPath = path.join(p.agentsDir, `${name}.json`);
-    if (fs.existsSync(agentPath)) {
-        console.error(`Agent "${name}" already exists: ${agentPath}`);
-        process.exit(1);
-    }
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     const ask = (q) => new Promise(r => rl.question(q, r));
+    let name;
     try {
+        const prompt = suggestedName
+            ? `Agent name [${suggestedName}]: `
+            : 'Agent name: ';
+        const input = (await ask(prompt)).trim();
+        name = input || suggestedName;
+        if (!name) {
+            console.error('Agent name is required.');
+            process.exit(1);
+        }
+        // Disallow dots/slashes/spaces in agent name (used as filename + channel-name prefix)
+        if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+            console.error(`Invalid agent name "${name}": only letters/digits/_/- allowed`);
+            process.exit(1);
+        }
+        const agentPath = path.join(p.agentsDir, `${name}.json`);
+        if (fs.existsSync(agentPath)) {
+            console.error(`Agent "${name}" already exists: ${agentPath}`);
+            process.exit(1);
+        }
         console.log(`\nCreating agent: ${name}\n`);
-        const projectPath = await ask('Project path: ');
-        if (!projectPath.trim() || !path.isAbsolute(projectPath.trim())) {
+        // Suggest project path: sibling of evolclaw.json's defaultPath, named after agent
+        let suggestedProjectPath = '';
+        try {
+            const cfg = loadConfig(p.config);
+            const defaultProjectsRoot = cfg.projects?.defaultPath
+                ? path.dirname(cfg.projects.defaultPath)
+                : path.join(os.homedir(), 'evolclaw-projects');
+            suggestedProjectPath = path.join(defaultProjectsRoot, name);
+        }
+        catch {
+            suggestedProjectPath = path.join(os.homedir(), 'evolclaw-projects', name);
+        }
+        const projectInput = (await ask(`Project path [${suggestedProjectPath}]: `)).trim();
+        const projectPath = projectInput || suggestedProjectPath;
+        if (!path.isAbsolute(projectPath)) {
             console.error('Project path must be an absolute path.');
             process.exit(1);
         }
+        if (!fs.existsSync(projectPath)) {
+            const create = (await ask(`Project path does not exist. Create ${projectPath}? [Y/n]: `)).trim().toLowerCase();
+            if (create === '' || create === 'y' || create === 'yes') {
+                try {
+                    fs.mkdirSync(projectPath, { recursive: true });
+                    console.log(`  ✓ Created ${projectPath}`);
+                }
+                catch (e) {
+                    console.error(`Failed to create ${projectPath}: ${e?.message || e}`);
+                    process.exit(1);
+                }
+            }
+            else {
+                console.error('Aborted: project path does not exist.');
+                process.exit(1);
+            }
+        }
         const baseagentChoices = ['claude', 'codex', 'gemini', 'hermes'];
         const baseagent = (await ask(`Baseagent (${baseagentChoices.join('/')}) [claude]: `)).trim() || 'claude';
         if (!baseagentChoices.includes(baseagent)) {
@@ -1503,7 +1617,19 @@ async function cmdAgentNew(name) {
         const model = (await ask('Model (leave empty for default): ')).trim() || undefined;
         const effort = (await ask('Effort (low/medium/high/max) [high]: ')).trim() || 'high';
         const chatmodeChoices = ['interactive', 'proactive'];
-        const chatmodePrivate = (await ask(`ChatMode private (${chatmodeChoices.join('/')}) [interactive]: `)).trim() || 'interactive';
+        console.log('\nChat mode determines how the agent responds:');
+        console.log('  interactive — replies to every message; agent output sent automatically');
+        console.log('  proactive   — silent by default; agent decides when/whether to send via ctl send');
+        const chatmodePrivate = (await ask(`Private (1-on-1) chat mode (${chatmodeChoices.join('/')}) [interactive]: `)).trim() || 'interactive';
+        if (!chatmodeChoices.includes(chatmodePrivate)) {
+            console.error(`Invalid chat mode: ${chatmodePrivate}`);
+            process.exit(1);
+        }
+        const chatmodeGroup = (await ask(`Group chat mode (${chatmodeChoices.join('/')}) [proactive]: `)).trim() || 'proactive';
+        if (!chatmodeChoices.includes(chatmodeGroup)) {
+            console.error(`Invalid chat mode: ${chatmodeGroup}`);
+            process.exit(1);
+        }
         // Channels (loop to allow multiple)
         const channelsConfig = {};
         const { getChannelCredentialCollector } = await import('./utils/init-channel.js');
@@ -1538,9 +1664,13 @@ async function cmdAgentNew(name) {
                 continue;
             }
             const nameRl = readline.createInterface({ input: process.stdin, output: process.stdout });
-            const instName = await new Promise(r => nameRl.question(`  Channel instance name [${name}]: `, r));
+            const defaultEffName = `${name}-${channelType}`;
+            const instName = await new Promise(r => nameRl.question(`  Channel instance name (leave empty for ${defaultEffName}): `, r));
             nameRl.close();
-            creds.name = instName.trim() || name;
+            const trimmedName = instName.trim();
+            if (trimmedName)
+                creds.name = trimmedName;
+            // else: omit name; effective channel name will be ${agent.name}-${type} via EvolAgent.effectiveChannelName
             if (!channelsConfig[channelType])
                 channelsConfig[channelType] = [];
             channelsConfig[channelType].push(creds);
@@ -1556,7 +1686,7 @@ async function cmdAgentNew(name) {
             agents: { [baseagent]: { ...(model && { model }), effort } },
             channels: finalChannels,
             projects: { defaultPath: projectPath.trim() },
-            chatmode: { private: chatmodePrivate, group: 'proactive' },
+            chatmode: { private: chatmodePrivate, group: chatmodeGroup },
         };
         fs.mkdirSync(p.agentsDir, { recursive: true });
         fs.writeFileSync(agentPath, JSON.stringify(agentConfig, null, 2));
@@ -1571,6 +1701,160 @@ async function cmdAgentNew(name) {
         catch { }
     }
 }
+async function cmdAgentNewNonInteractive(name, args) {
+    const p = resolvePaths();
+    const agentPath = path.join(p.agentsDir, `${name}.json`);
+    if (fs.existsSync(agentPath)) {
+        console.error(`Agent "${name}" already exists: ${agentPath}`);
+        process.exit(1);
+    }
+    // Helper: extract --flag value from args
+    const getArg = (flag) => {
+        const idx = args.indexOf(flag);
+        return idx !== -1 && idx + 1 < args.length ? args[idx + 1] : undefined;
+    };
+    // Required: baseagent + project
+    const baseagent = getArg('--baseagent');
+    if (!baseagent) {
+        console.error('--baseagent is required (claude|codex|gemini|hermes)');
+        process.exit(1);
+    }
+    const baseagentChoices = ['claude', 'codex', 'gemini', 'hermes'];
+    if (!baseagentChoices.includes(baseagent)) {
+        console.error(`Invalid --baseagent: ${baseagent}`);
+        process.exit(1);
+    }
+    const project = getArg('--project');
+    if (!project) {
+        console.error('--project is required (absolute path)');
+        process.exit(1);
+    }
+    if (!path.isAbsolute(project)) {
+        console.error(`--project must be absolute: ${project}`);
+        process.exit(1);
+    }
+    if (!fs.existsSync(project)) {
+        try {
+            fs.mkdirSync(project, { recursive: true });
+            console.log(`  ✓ Created ${project}`);
+        }
+        catch (e) {
+            console.error(`Failed to create ${project}: ${e?.message || e}`);
+            process.exit(1);
+        }
+    }
+    // Optional: chatmode
+    const chatmodePrivate = getArg('--chatmode-private') || 'interactive';
+    const chatmodeGroup = getArg('--chatmode-group') || 'proactive';
+    const chatmodeValid = new Set(['interactive', 'proactive']);
+    if (!chatmodeValid.has(chatmodePrivate)) {
+        console.error(`Invalid --chatmode-private: ${chatmodePrivate}`);
+        process.exit(1);
+    }
+    if (!chatmodeValid.has(chatmodeGroup)) {
+        console.error(`Invalid --chatmode-group: ${chatmodeGroup}`);
+        process.exit(1);
+    }
+    // Channels
+    const channelsConfig = {};
+    // AUN
+    const aunAid = getArg('--aun-aid');
+    const aunOwner = getArg('--aun-owner');
+    if (aunAid || aunOwner) {
+        if (!aunAid || !aunOwner) {
+            console.error('--aun-aid and --aun-owner must both be provided');
+            process.exit(1);
+        }
+        const { isValidAid, aidCreate } = await import('./channels/aun-ops.js');
+        if (!isValidAid(aunAid)) {
+            console.error(`Invalid --aun-aid: ${aunAid}`);
+            process.exit(1);
+        }
+        if (!isValidAid(aunOwner)) {
+            console.error(`Invalid --aun-owner: ${aunOwner}`);
+            process.exit(1);
+        }
+        try {
+            const result = await aidCreate(aunAid);
+            try {
+                await result.client.close();
+            }
+            catch { /* ignore */ }
+            console.log(`✓ AID ${result.alreadyExisted ? 'reused' : 'created'}: ${aunAid}`);
+        }
+        catch (e) {
+            console.error(`AID creation failed: ${e?.message || e}`);
+            process.exit(1);
+        }
+        channelsConfig.aun = { enabled: true, aid: aunAid, owner: aunOwner };
+    }
+    // Feishu
+    const feishuAppId = getArg('--feishu-app-id');
+    const feishuAppSecret = getArg('--feishu-app-secret');
+    if (feishuAppId || feishuAppSecret) {
+        if (!feishuAppId || !feishuAppSecret) {
+            console.error('--feishu-app-id and --feishu-app-secret must both be provided');
+            process.exit(1);
+        }
+        channelsConfig.feishu = [{
+                name: `feishu-${name}`,
+                enabled: true,
+                appId: feishuAppId,
+                appSecret: feishuAppSecret,
+            }];
+    }
+    // WeChat
+    const wechatToken = getArg('--wechat-token');
+    if (wechatToken) {
+        channelsConfig.wechat = { enabled: true, token: wechatToken };
+    }
+    // WeCom
+    const wecomBotId = getArg('--wecom-bot-id');
+    const wecomSecret = getArg('--wecom-secret');
+    if (wecomBotId || wecomSecret) {
+        if (!wecomBotId || !wecomSecret) {
+            console.error('--wecom-bot-id and --wecom-secret must both be provided');
+            process.exit(1);
+        }
+        channelsConfig.wecom = { enabled: true, botId: wecomBotId, secret: wecomSecret };
+    }
+    // DingTalk
+    const dingtalkClientId = getArg('--dingtalk-client-id');
+    const dingtalkClientSecret = getArg('--dingtalk-client-secret');
+    if (dingtalkClientId || dingtalkClientSecret) {
+        if (!dingtalkClientId || !dingtalkClientSecret) {
+            console.error('--dingtalk-client-id and --dingtalk-client-secret must both be provided');
+            process.exit(1);
+        }
+        channelsConfig.dingtalk = { enabled: true, clientId: dingtalkClientId, clientSecret: dingtalkClientSecret };
+    }
+    // QQBot
+    const qqbotAppId = getArg('--qqbot-app-id');
+    const qqbotClientSecret = getArg('--qqbot-client-secret');
+    if (qqbotAppId || qqbotClientSecret) {
+        if (!qqbotAppId || !qqbotClientSecret) {
+            console.error('--qqbot-app-id and --qqbot-client-secret must both be provided');
+            process.exit(1);
+        }
+        channelsConfig.qqbot = { enabled: true, appId: qqbotAppId, clientSecret: qqbotClientSecret };
+    }
+    if (Object.keys(channelsConfig).length === 0) {
+        console.error('At least one channel must be configured (aun / feishu / wechat / wecom / dingtalk / qqbot)');
+        process.exit(1);
+    }
+    const agentConfig = {
+        name,
+        enabled: true,
+        agents: { [baseagent]: {} },
+        channels: channelsConfig,
+        projects: { defaultPath: project },
+        chatmode: { private: chatmodePrivate, group: chatmodeGroup },
+    };
+    fs.mkdirSync(p.agentsDir, { recursive: true });
+    fs.writeFileSync(agentPath, JSON.stringify(agentConfig, null, 2));
+    console.log(`✓ Created: ${agentPath}`);
+    console.log('  Run `evolclaw restart` (or `evolclaw agent reload <name>`) to activate.');
+}
 // ==================== AID ====================
 async function cmdAid(args) {
     const sub = args[0] || 'list';
@@ -1856,6 +2140,19 @@ Commands:
                   agent              列出所有 agent
                   agent <name>       查看指定 agent 详情
                   agent new <name>   创建新 agent（交互式）
+                  agent new <name> --non-interactive ...  非交互创建（自动化）
+                    必填: --baseagent <claude|codex|gemini|hermes>
+                          --project <absolute path>
+                    可选 channel:
+                          --aun-aid <aid> --aun-owner <aid>
+                          --feishu-app-id xxx --feishu-app-secret yyy
+                          --wechat-token xxx
+                          --wecom-bot-id xxx --wecom-secret yyy
+                          --dingtalk-client-id xxx --dingtalk-client-secret yyy
+                          --qqbot-app-id xxx --qqbot-client-secret yyy
+                    可选行为:
+                          --chatmode-private <interactive|proactive> (默认 interactive)
+                          --chatmode-group <interactive|proactive>   (默认 proactive)
                   agent reload <n>   热重载 agent 配置
   aid             AID 身份管理
                   aid list           列出本地所有 AID