evolcore 0.0.22 → 0.0.24

package/dist/ipc.js

@@ -17,6 +17,8 @@ import { classifyProcessTree, ProcessTreeSampler, readProcessMetrics } from './u
 import { readSystemMemoryUsage } from './utils/system-memory.js';
 import { hashCurrentDelegatedCommand } from './core/auth/agent-delegation.js';
 import { normalizeAunMentionEntries } from './aun/msg/mention-schema.js';
+import { remoteAccessService } from './core/auth/remote-access-store.js';
+import { setModelCatalogDaemonOwner } from './core/model/model-catalog.js';
 const isWindows = process.platform === 'win32';
 const isNamedPipe = (p) => isWindows && p.toLowerCase().startsWith('\\\\.\\pipe\\');
 const CPU_SAMPLE_INTERVAL_MS = 1000;
@@ -44,10 +46,15 @@ const LOCAL_CONTROL_COMMANDS = new Set([
     'evolagent.load',
     'evolagent.resync',
     'menu.exec',
+    'model.catalog',
     'monitor-snapshot',
     'monitor-subscribe',
     'monitor-unsubscribe',
     'shutdown',
+    'remote-auth.pair-code',
+    'remote-auth.issue-local',
+    'remote-auth.redeem',
+    'remote-auth.validate',
 ]);
 let ipcQuerySequence = 0;
 function ipcLogToken(value, fallback = 'unknown') {
@@ -127,6 +134,7 @@ export class IpcServer {
     wechatContactBindExecutor;
     controlToken;
     daemonRuntimeEpoch;
+    remoteAccessService = remoteAccessService;
     // CPU 占用追踪：IPC handler 是一次性同步调用，无法在响应里做 200ms 异步采样，
     // 故用后台 1s interval 累积 process.cpuUsage() 增量，handler 直接读最近值。
     // procCpuPercent = 本 daemon 进程占单核的百分比（可 >100% 仅当多核，已 clamp 到 100）；
@@ -177,6 +185,10 @@ export class IpcServer {
     setControlToken(token) {
         this.controlToken = Buffer.from(token);
     }
+    /** Use the daemon-owned remote access service for local consumers such as ECWeb. */
+    setRemoteAccessService(service) {
+        this.remoteAccessService = service;
+    }
     /** Set the process-lifetime marker used to reject stale managed children. */
     setDaemonRuntimeEpoch(epoch) {
         this.daemonRuntimeEpoch = epoch;
@@ -233,6 +245,87 @@ export class IpcServer {
     setAgentStatsProvider(provider) {
         this.agentStatsProvider = provider;
     }
+    /** Single current snapshot shared by ECWeb IPC and the daemon Menu view. */
+    getMonitorSnapshot(leaseId) {
+        if (typeof leaseId === 'string' && leaseId.trim())
+            this.refreshProcessTreeMonitor(leaseId);
+        else
+            this.sampleProcessTree();
+        const mem = process.memoryUsage();
+        const systemMemory = readSystemMemoryUsage();
+        const aids = this.aunAidProvider ? this.aunAidProvider() : [];
+        const aidStats = this.aunAidStatsProvider ? this.aunAidStatsProvider() : [];
+        const statsMap = new Map(aidStats.map(stat => [stat.aid, stat]));
+        const agentInfos = this.agentRegistry ? this.agentRegistry.list() : [];
+        const agentRuntimeStats = this.agentStatsProvider ? this.agentStatsProvider() : [];
+        const agentRuntimeStatsMap = new Map(agentRuntimeStats.map(stat => [stat.aid, stat]));
+        const aidStateMap = new Map(aids.map(state => [state.agentName || state.aid, state]));
+        const processTree = this.processTreeSnapshot;
+        const processTreeCpu = processTree?.processCount ? processTree.cpuPercent : this.cpuPercent;
+        const processTreeRss = processTree?.processCount ? processTree.rss : mem.rss;
+        const processTreeDetails = processTree ? {
+            ...processTree,
+            processes: classifyProcessTree(processTree.processes, process.pid, this.associatedProcessKinds),
+        } : {
+            rootPid: process.pid,
+            rootPids: [process.pid],
+            processCount: 1,
+            cpuPercent: Math.round(this.cpuPercent * 10) / 10,
+            rss: mem.rss,
+            processes: [{
+                    pid: process.pid,
+                    ppid: process.ppid,
+                    name: 'evolcore',
+                    cpuPercent: Math.round(this.cpuPercent * 10) / 10,
+                    rss: mem.rss,
+                    kind: 'daemon',
+                }],
+        };
+        return {
+            ok: true,
+            snapshot: {
+                ts: Date.now(),
+                uptimeMs: Math.round(process.uptime() * 1000),
+                cpuCount: os.cpus().length,
+                memory: {
+                    rss: processTreeRss,
+                    heapUsed: mem.heapUsed,
+                    heapTotal: mem.heapTotal,
+                    external: mem.external,
+                },
+                cpuPercent: processTreeCpu,
+                mainProcess: {
+                    pid: process.pid,
+                    cpuPercent: Math.round(this.cpuPercent * 10) / 10,
+                    memory: mem,
+                },
+                processTree: processTreeDetails,
+                sampling: {
+                    cpuIntervalMs: CPU_SAMPLE_INTERVAL_MS,
+                    processTreeIntervalMs: PROCESS_TREE_SAMPLE_INTERVAL_MS,
+                    eventLoopLagMs: this.eventLoopLagMs,
+                    maxEventLoopLagMs: this.maxEventLoopLagMs,
+                    processTree: { ...this.processTreeSampling },
+                },
+                system: {
+                    ...systemMemory,
+                    cpuPercent: Math.round(this.sysCpuPercent * 10) / 10,
+                    loadAvg: os.loadavg(),
+                },
+                stats: this.statsProvider ? this.statsProvider() : null,
+                agentSummary: summarizeMonitorAgents(agentInfos, aids),
+                agents: agentInfos.map(agent => ({
+                    aid: agent.aid,
+                    agentName: agent.name,
+                    status: agent.status,
+                    connectionStatus: aidStateMap.get(agent.aid)?.status ?? (agent.status === 'disabled' ? 'disabled' : 'unavailable'),
+                    online: agent.status !== 'disabled' && aidStateMap.get(agent.aid)?.status === 'connected',
+                    stats: statsMap.get(agent.aid) ?? null,
+                    runtimeStats: agentRuntimeStatsMap.get(agent.aid) ?? null,
+                })),
+            },
+        };
+    }
     /** Inject queue snapshot provider for queue-snapshot IPC handler (query mode) */
     setQueueSnapshotProvider(provider) {
         this.queueSnapshotProvider = provider;
@@ -623,6 +716,7 @@ export class IpcServer {
         return roots;
     }
     start() {
+        setModelCatalogDaemonOwner(true);
         if (this.server)
             return Promise.resolve();
         // Remove stale socket file (Unix only — named pipes auto-cleanup on process exit)
@@ -685,6 +779,7 @@ export class IpcServer {
         });
     }
     stop() {
+        setModelCatalogDaemonOwner(false);
         if (this.server) {
             this.server.close();
             this.server = null;
@@ -712,6 +807,19 @@ export class IpcServer {
             };
         }
         switch (cmd.type) {
+            case 'model.catalog': {
+                if ((cmd.self !== undefined && typeof cmd.self !== 'string')
+                    || (cmd.baseagent !== undefined && !['claude', 'codex', 'ecagent', 'gemini'].includes(cmd.baseagent))) {
+                    return { ok: false, error: 'Invalid model catalog scope' };
+                }
+                try {
+                    const { getLocalCatalog } = await import('./core/model/model-catalog.js');
+                    return { ok: true, snapshot: await getLocalCatalog(cmd.self, cmd.baseagent, cmd.refresh === true) };
+                }
+                catch {
+                    return { ok: false, error: 'Unable to resolve model catalog configuration' };
+                }
+            }
             case 'status':
                 return this.getStatus();
             case 'codex-pre-tool-use': {
@@ -722,12 +830,21 @@ export class IpcServer {
                     || typeof cmd.toolName !== 'string' || !cmd.toolName) {
                     return { ok: false, applicable: true, decision: 'deny', reason: 'invalid Codex hook request' };
                 }
+                // Unmanaged Codex processes carry no credential and are allowed
+                // without consulting any runner; see bin/codex-managed-hook.mjs.
+                const sessionToken = typeof cmd.sessionToken === 'string' && cmd.sessionToken
+                    ? cmd.sessionToken
+                    : undefined;
+                if (!sessionToken) {
+                    return { ok: true, applicable: true, decision: 'allow' };
+                }
                 try {
                     return await this.codexPreToolUseExecutor({
                         threadId: cmd.threadId,
                         toolName: cmd.toolName,
                         toolInput: cmd.toolInput,
                         callId: typeof cmd.callId === 'string' ? cmd.callId : undefined,
+                        sessionToken,
                         signal: requestSignal,
                     });
                 }
@@ -769,6 +886,19 @@ export class IpcServer {
                     ttlMs: cmd.ttlMs,
                 });
             }
+            case 'remote-auth.pair-code': {
+                const pair = this.remoteAccessService.getPairingCode(typeof cmd.authorizedBy === 'string' ? cmd.authorizedBy : undefined);
+                return { ok: true, ...pair };
+            }
+            case 'remote-auth.issue-local': {
+                return this.remoteAccessService.issueLocalToken(cmd.label);
+            }
+            case 'remote-auth.redeem': {
+                return this.remoteAccessService.redeemPairingCode(cmd.code, cmd.label, cmd.authorizedBy);
+            }
+            case 'remote-auth.validate': {
+                return { ok: true, ...this.remoteAccessService.validateToken(cmd.token) };
+            }
             case 'bind.status': {
                 if (!this.bindExecutor)
                     return { ok: false, error: 'bind executor not configured' };
@@ -1385,87 +1515,8 @@ export class IpcServer {
                     return { ok: false, error: e?.message ?? String(e) };
                 }
             }
-            case 'monitor-snapshot': {
-                this.refreshProcessTreeMonitor(cmd.leaseId);
-                // watch web Monitor 页用：进程级 + 系统级运行指标 + 全局 stats + per-agent 汇总。
-                const mem = process.memoryUsage();
-                const systemMemory = readSystemMemoryUsage();
-                const aids = this.aunAidProvider ? this.aunAidProvider() : [];
-                const aidStats = this.aunAidStatsProvider ? this.aunAidStatsProvider() : [];
-                const statsMap = new Map(aidStats.map((s) => [s.aid, s]));
-                const agentInfos = this.agentRegistry ? this.agentRegistry.list() : [];
-                const agentRuntimeStats = this.agentStatsProvider ? this.agentStatsProvider() : [];
-                const agentRuntimeStatsMap = new Map(agentRuntimeStats.map((s) => [s.aid, s]));
-                const aidStateMap = new Map(aids.map((state) => [state.agentName || state.aid, state]));
-                const agentSummary = summarizeMonitorAgents(agentInfos, aids);
-                const processTree = this.processTreeSnapshot;
-                const processTreeCpu = processTree?.processCount ? processTree.cpuPercent : this.cpuPercent;
-                const processTreeRss = processTree?.processCount ? processTree.rss : mem.rss;
-                const processTreeDetails = processTree ? {
-                    ...processTree,
-                    processes: classifyProcessTree(processTree.processes, process.pid, this.associatedProcessKinds),
-                } : {
-                    rootPid: process.pid,
-                    rootPids: [process.pid],
-                    processCount: 1,
-                    cpuPercent: Math.round(this.cpuPercent * 10) / 10,
-                    rss: mem.rss,
-                    processes: [{
-                            pid: process.pid,
-                            ppid: process.ppid,
-                            name: 'evolcore',
-                            cpuPercent: Math.round(this.cpuPercent * 10) / 10,
-                            rss: mem.rss,
-                            kind: 'daemon',
-                        }],
-                };
-                return {
-                    ok: true,
-                    snapshot: {
-                        ts: Date.now(),
-                        uptimeMs: Math.round(process.uptime() * 1000),
-                        cpuCount: os.cpus().length,
-                        // 进程级：daemon + 子进程 + 登记在册的关联进程树
-                        memory: {
-                            rss: processTreeRss,
-                            heapUsed: mem.heapUsed,
-                            heapTotal: mem.heapTotal,
-                            external: mem.external,
-                        },
-                        cpuPercent: processTreeCpu,
-                        mainProcess: {
-                            pid: process.pid,
-                            cpuPercent: Math.round(this.cpuPercent * 10) / 10,
-                            memory: mem,
-                        },
-                        processTree: processTreeDetails,
-                        sampling: {
-                            cpuIntervalMs: CPU_SAMPLE_INTERVAL_MS,
-                            processTreeIntervalMs: PROCESS_TREE_SAMPLE_INTERVAL_MS,
-                            eventLoopLagMs: this.eventLoopLagMs,
-                            maxEventLoopLagMs: this.maxEventLoopLagMs,
-                            processTree: { ...this.processTreeSampling },
-                        },
-                        // 系统级：整机
-                        system: {
-                            ...systemMemory,
-                            cpuPercent: Math.round(this.sysCpuPercent * 10) / 10,
-                            loadAvg: os.loadavg(), // [1m, 5m, 15m]（Windows 恒 0）
-                        },
-                        stats: this.statsProvider ? this.statsProvider() : null,
-                        agentSummary,
-                        agents: agentInfos.map((a) => ({
-                            aid: a.aid,
-                            agentName: a.name,
-                            status: a.status,
-                            connectionStatus: aidStateMap.get(a.aid)?.status ?? (a.status === 'disabled' ? 'disabled' : 'unavailable'),
-                            online: a.status !== 'disabled' && aidStateMap.get(a.aid)?.status === 'connected',
-                            stats: statsMap.get(a.aid) ?? null,
-                            runtimeStats: agentRuntimeStatsMap.get(a.aid) ?? null,
-                        })),
-                    },
-                };
-            }
+            case 'monitor-snapshot':
+                return this.getMonitorSnapshot(cmd.leaseId);
             case 'monitor-subscribe': {
                 const leaseId = typeof cmd.leaseId === 'string' ? cmd.leaseId.trim() : '';
                 if (!leaseId || leaseId.length > 128)
@@ -1492,12 +1543,26 @@ export class IpcServer {
             && crypto.timingSafeEqual(provided, this.controlToken);
     }
 }
-/**
- * Query the running EvolCore daemon via Unix socket.
- * Returns null if the service is not running or the socket is unreachable.
- */
+export class IpcTransportError extends Error {
+    code;
+    endpoint;
+    constructor(code, endpoint) {
+        const hint = code === 'EPERM' || code === 'EACCES'
+            ? '权限被拒绝；Windows 下请检查 daemon 与 CLI 是否使用相同用户和提升权限级别。'
+            : code === 'ETIMEDOUT'
+                ? '等待 daemon 响应超时；请求可能已执行，请先检查状态再重试。'
+                : code === 'ENOENT' || code === 'ECONNREFUSED'
+                    ? 'daemon 未运行或 IPC 端点不存在，请先执行 ec start，再重试。'
+                    : '请检查 daemon 进程及 IPC 端点状态。';
+        super(`daemon IPC 失败 (${code}): ${endpoint}。${hint}`);
+        this.code = code;
+        this.endpoint = endpoint;
+        this.name = 'IpcTransportError';
+    }
+}
+/** Query the daemon; opt in to transport errors instead of the legacy null result. */
 /** Pass `null` as timeoutMs to wait without a client-side deadline. */
-export function ipcQuery(socketPath, cmd, timeoutMs = 3000) {
+export async function ipcQuery(socketPath, cmd, timeoutMs = 3000, options = {}) {
     const endpoint = normalizeIpcEndpoint(socketPath);
     let socketCandidates = [endpoint];
     if (isNamedPipe(endpoint)) {
@@ -1505,22 +1570,35 @@ export function ipcQuery(socketPath, cmd, timeoutMs = 3000) {
         if (endpoint === paths.socket)
             socketCandidates = getWindowsInstanceSocketPathCandidates(paths.root);
     }
-    if (socketCandidates.length <= 1)
-        return ipcQueryOnce(endpoint, cmd, timeoutMs);
-    return (async () => {
-        const startedAt = Date.now();
-        for (const candidate of socketCandidates) {
-            const remainingTimeout = timeoutMs === null
-                ? null
-                : Math.max(0, timeoutMs - (Date.now() - startedAt));
-            if (remainingTimeout === 0)
-                return null;
+    const startedAt = Date.now();
+    let failure;
+    for (const candidate of socketCandidates) {
+        const remainingTimeout = timeoutMs === null
+            ? null
+            : Math.max(0, timeoutMs - (Date.now() - startedAt));
+        if (remainingTimeout === 0) {
+            failure ??= new IpcTransportError('ETIMEDOUT', candidate);
+            break;
+        }
+        try {
             const response = await ipcQueryOnce(candidate, cmd, remainingTimeout);
             if (response !== null)
                 return response;
         }
-        return null;
-    })();
+        catch (error) {
+            if (!(error instanceof IpcTransportError))
+                throw error;
+            // A missing legacy pipe must not hide a permission failure on the canonical pipe.
+            if (!failure || ['ENOENT', 'ECONNREFUSED'].includes(failure.code))
+                failure = error;
+            // Only connection failures are safe to retry against a legacy endpoint.
+            if (!['ENOENT', 'ECONNREFUSED', 'EPERM', 'EACCES'].includes(error.code))
+                break;
+        }
+    }
+    if (options.throwOnError && failure)
+        throw failure;
+    return null;
 }
 function ipcQueryOnce(socketPath, cmd, timeoutMs = 3000) {
     let authenticatedCmd = cmd;
@@ -1545,7 +1623,7 @@ function ipcQueryOnce(socketPath, cmd, timeoutMs = 3000) {
             ? { daemonRuntimeEpoch: process.env[DAEMON_RUNTIME_EPOCH_ENV] }
             : {}),
     };
-    return new Promise((resolve) => {
+    return new Promise((resolve, reject) => {
         const startedAtMono = performance.now();
         const queryId = nextIpcQueryId(request);
         const commandType = ipcLogToken(request.type);
@@ -1564,7 +1642,7 @@ function ipcQueryOnce(socketPath, cmd, timeoutMs = 3000) {
                 settled = true;
                 logPhase('timeout', ` timeout_ms=${timeoutMs}`);
                 conn.destroy();
-                resolve(null);
+                reject(new IpcTransportError('ETIMEDOUT', socketPath));
             }, timeoutMs);
         conn.on('connect', () => {
             if (settled)
@@ -1590,7 +1668,10 @@ function ipcQueryOnce(socketPath, cmd, timeoutMs = 3000) {
                     parse = 'invalid_json';
                 }
                 logPhase('response', ` bytes=${idx + 1} parse=${parse}`);
-                resolve(response);
+                if (parse === 'invalid_json')
+                    reject(new IpcTransportError('EPROTO', socketPath));
+                else
+                    resolve(response);
                 conn.destroy();
             }
         });
@@ -1601,7 +1682,15 @@ function ipcQueryOnce(socketPath, cmd, timeoutMs = 3000) {
             if (timer)
                 clearTimeout(timer);
             logPhase('error', ` code=${error.code ?? 'unknown'}`);
-            resolve(null);
+            reject(new IpcTransportError(error.code ?? 'UNKNOWN', socketPath));
+        });
+        conn.on('close', () => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            reject(new IpcTransportError('ECONNRESET', socketPath));
         });
     });
 }

package/dist/paths.js

@@ -129,11 +129,22 @@ export function agentHandoffDir(aid) {
     return path.join(agentDataDir(aid), 'handoff');
 }
 export function agentOutboxPath(aid) {
-    return path.join(agentDataDir(aid), 'outbox.jsonl');
+    return path.join(resolvePaths().outboxDir, encodeURIComponent(aid), 'outbox.jsonl');
 }
 export function agentActivityOutboxPath(aid) {
+    return path.join(resolvePaths().outboxDir, encodeURIComponent(aid), 'activity-outbox.jsonl');
+}
+/** Pre-v4 per-Agent outbox paths retained only for compatibility import. */
+export function legacyAgentOutboxPath(aid) {
+    return path.join(agentDataDir(aid), 'outbox.jsonl');
+}
+export function legacyAgentActivityOutboxPath(aid) {
     return path.join(agentDataDir(aid), 'activity-outbox.jsonl');
 }
+/** Earliest global outbox layout: data/outbox/<aid>.jsonl. */
+export function legacyFlatOutboxPath(aid) {
+    return path.join(resolvePaths().outboxDir, `${aid}.jsonl`);
+}
 /** Directory-safe channel instance key used by connector runtime state. */
 function encodePathKey(value) {
     return encodeURIComponent(value);
@@ -283,6 +294,17 @@ function migrateFromAun() {
     const markerPath = path.join(newRoot, MIGRATION_MARKER);
     if (fs.existsSync(markerPath))
         return;
+    // Test workers use isolated temporary homes.  Copying the developer's
+    // machine-wide ~/.aun tree into every fresh fixture is both unnecessary and
+    // can make process-boundary tests exceed their timeout.  Production roots
+    // retain the normal one-time migration behavior.
+    if (process.env.EVOLCORE_TEST === '1') {
+        try {
+            fs.writeFileSync(markerPath, new Date().toISOString(), 'utf-8');
+        }
+        catch { }
+        return;
+    }
     const oldRoot = path.join(os.homedir(), '.aun');
     if (!fs.existsSync(oldRoot) || oldRoot === newRoot) {
         try {

package/dist/stats/billing.js

@@ -1,11 +1,13 @@
 /**
- * billing.ts — 读 model-prices.jsonl，按 billing_fn 调对应算法函数计算费用。
+ * billing.ts — 读 model-prices.jsonl，按模型参数中的 billing_fn 计算费用。
  * 费用查询时实时计算，不存入 DB（价格可能变动）。
  */
 import fs from 'fs';
 import path from 'path';
 import { getPackageRoot } from '../paths.js';
-// 价格表缓存（进程内，5 分钟 TTL）
+// 模型参数缓存（进程内，5 分钟 TTL）
+let _parameterCache = null;
+let _parameterCacheTs = 0;
 let _priceCache = null;
 let _priceCacheTs = 0;
 const PRICE_CACHE_TTL = 5 * 60 * 1000;
@@ -44,6 +46,14 @@ function _loadJsonlMerged(evolcoreHome, filename) {
     }
     return results;
 }
+function loadModelParameters(evolcoreHome) {
+    if (_parameterCache && Date.now() - _parameterCacheTs < PRICE_CACHE_TTL)
+        return _parameterCache;
+    const params = _loadJsonlMerged(evolcoreHome, 'model-prices.jsonl');
+    _parameterCache = params;
+    _parameterCacheTs = Date.now();
+    return params;
+}
 let _aliasCache = null;
 let _aliasCacheTs = 0;
 function loadAliases(evolcoreHome) {
@@ -64,7 +74,8 @@ function loadPrices(evolcoreHome) {
     const now = Date.now();
     if (_priceCache && now - _priceCacheTs < PRICE_CACHE_TTL)
         return _priceCache;
-    _priceCache = _loadJsonlMerged(evolcoreHome, 'model-prices.jsonl');
+    _priceCache = loadModelParameters(evolcoreHome).filter((record) => (typeof record.billing_fn === 'string'
+        && (record.currency === 'USD' || record.currency === 'CNY')));
     _priceCacheTs = now;
     return _priceCache;
 }
@@ -140,13 +151,16 @@ export function calcCost(evolcoreHome, event) {
         return {};
     return fn(event, priceRow);
 }
+// ── Model Specs ──────────────────────────────────────────────────────────────
 let _specCache = null;
 let _specCacheTs = 0;
 function loadSpecs(evolcoreHome) {
     const now = Date.now();
     if (_specCache && now - _specCacheTs < PRICE_CACHE_TTL)
         return _specCache;
-    _specCache = _loadJsonlMerged(evolcoreHome, 'model-specs.jsonl');
+    _specCache = loadModelParameters(evolcoreHome).filter((record) => (typeof record.context_window === 'number'
+        && typeof record.max_input_tokens === 'number'
+        && typeof record.max_output_tokens === 'number'));
     _specCacheTs = now;
     return _specCache;
 }

package/dist/trigger/manager.js

@@ -92,7 +92,9 @@ export class TriggerDefinitionManager {
         assertExplicitAunDeliveryRoutes(updated);
         this.assertAgent(updated);
         if (existing.execution.baseagent !== updated.execution.baseagent) {
-            throw new Error('execution.baseagent is immutable; create a new Trigger to use another baseagent');
+            if (existing.execution.type !== 'trigger_session' || updated.execution.type !== 'trigger_session') {
+                throw new Error('execution.baseagent is only mutable between trigger_session Triggers');
+            }
         }
         updated.createdAt = existing.createdAt;
         updated.updatedAt = Date.now();

package/dist/trigger/parser.js

@@ -1,8 +1,11 @@
 import { CronExpressionParser } from 'cron-parser';
 const TRIGGER_UPDATE_FLAGS = new Set([
     'once', 'delay', 'at', 'cron', 'every', 'event', 'tz',
-    'prompt', 'name',
-    'script-file',
+    'prompt', 'name', 'description',
+    'script-file', 'script-runtime', 'script-args', 'script-timeout',
+    'feedback', 'target-channel', 'target-channel-id', 'target-chat-type', 'target-session', 'target-thread-id',
+    'trigger-thread', 'baseagent',
+    'on-error', 'noop-sentinel', 'retry-attempts', 'retry-backoff',
     'model', 'effort', 'permission',
     'max-runs', 'max-duration', 'concurrency', 'missed-policy',
 ]);
@@ -396,18 +399,22 @@ function commonParsed(flags, opts = {}) {
     if (!opts.update && !execution.value) {
         return { ok: false, error: '创建 trigger 必须显式指定 --exec script|trigger-session|target-session' };
     }
+    // update 场景下执行类型未知（不重命名 --exec），execution-type 相关校验
+    // 全部交给 patch/validation 按现有定义执行。
     const inferredExecution = execution.value;
-    if (baseagent.value && inferredExecution !== 'trigger_session') {
-        return { ok: false, error: '--baseagent 仅适用于 --exec trigger-session' };
-    }
-    if (inferredExecution === 'script') {
-        if (!scriptPath && !opts.update)
-            return { ok: false, error: '--exec script 需要 --script-path' };
-        if (scriptPath && !scriptRuntime && !opts.update)
-            return { ok: false, error: '--script-path 必须配合 --script-runtime 使用（node|python|bash）' };
-    }
-    else if (!prompt && !opts.update) {
-        return { ok: false, error: '--prompt 为必填项' };
+    if (!opts.update) {
+        if (baseagent.value && inferredExecution !== 'trigger_session') {
+            return { ok: false, error: '--baseagent 仅适用于 --exec trigger-session' };
+        }
+        if (inferredExecution === 'script') {
+            if (!scriptPath)
+                return { ok: false, error: '--exec script 需要 --script-path' };
+            if (scriptPath && !scriptRuntime)
+                return { ok: false, error: '--script-path 必须配合 --script-runtime 使用（node|python|bash）' };
+        }
+        else if (!prompt) {
+            return { ok: false, error: '--prompt 为必填项' };
+        }
     }
     const targetSessionValue = targetSession.value ?? (targetThreadId ? 'thread' : 'main');
     const feedbackStrategy = feedback.value ?? (hasTargetField ? 'target' : 'origin');
@@ -645,6 +652,63 @@ function parseTriggerUpdateFlags(nameOrId, flags, opts = {}) {
         }
         update.missedPolicy = normalized;
     }
+    const description = optionalFlagString(flags, 'description');
+    if ('error' in description)
+        return { ok: false, error: description.error };
+    if (description.value !== undefined)
+        update.description = description.value || null;
+    if (flags.has('feedback') && value.feedbackStrategy !== undefined)
+        update.feedback = value.feedbackStrategy;
+    if (value.targetChannel !== undefined)
+        update.targetChannel = value.targetChannel;
+    if (value.targetChannelId !== undefined)
+        update.targetChannelId = value.targetChannelId;
+    if (value.targetChatType !== undefined)
+        update.targetChatType = value.targetChatType;
+    if (value.targetSession !== undefined && flags.has('target-session'))
+        update.targetSession = value.targetSession;
+    if (value.targetThreadId !== undefined)
+        update.targetThreadId = value.targetThreadId;
+    if (value.triggerThread !== undefined)
+        update.triggerThread = value.triggerThread;
+    if (value.baseagent !== undefined)
+        update.baseagent = value.baseagent;
+    const onError = optionalFlagString(flags, 'on-error');
+    if ('error' in onError)
+        return { ok: false, error: onError.error };
+    if (onError.value !== undefined) {
+        if (onError.value !== 'fail' && onError.value !== 'retry') {
+            return { ok: false, error: '--on-error 只接受 fail 或 retry' };
+        }
+        update.onError = onError.value;
+    }
+    const noopSentinel = optionalFlagString(flags, 'noop-sentinel');
+    if ('error' in noopSentinel)
+        return { ok: false, error: noopSentinel.error };
+    if (noopSentinel.value !== undefined)
+        update.noopSentinel = noopSentinel.value || null;
+    const retryAttempts = optionalFlagString(flags, 'retry-attempts');
+    if ('error' in retryAttempts)
+        return { ok: false, error: retryAttempts.error };
+    if (retryAttempts.value !== undefined) {
+        if (!/^\d+$/.test(retryAttempts.value))
+            return { ok: false, error: '--retry-attempts 必须是非负整数' };
+        update.retryAttempts = Number(retryAttempts.value);
+    }
+    const retryBackoff = optionalFlagString(flags, 'retry-backoff');
+    if ('error' in retryBackoff)
+        return { ok: false, error: retryBackoff.error };
+    if (retryBackoff.value !== undefined) {
+        if (!/^\d+$/.test(retryBackoff.value))
+            return { ok: false, error: '--retry-backoff 必须是毫秒正整数' };
+        update.retryBackoff = Number(retryBackoff.value);
+    }
+    if (value.scriptRuntime !== undefined)
+        update.scriptRuntime = value.scriptRuntime;
+    if (value.scriptArgs !== undefined)
+        update.scriptArgs = value.scriptArgs;
+    if (value.scriptTimeoutMs !== undefined)
+        update.scriptTimeout = value.scriptTimeoutMs;
     if (Object.keys(update).length === 0)
         return { ok: false, error: '没有可更新的 trigger 参数' };
     return { ok: true, nameOrId, value: update };