evolcore 0.0.26 → 0.0.28

package/dist/trigger/feedback.js

@@ -1,8 +1,13 @@
 import { buildEnvelope } from '../core/message/message-utils.js';
-import { renderTemplate, previewText, sha256 } from './validation.js';
+import { executionTimeoutMs, renderTemplate, previewText, sha256 } from './validation.js';
+import { isDaemonEventSessionTrigger } from './event-source.js';
+import { TASK_RECOVERY_PROMPT } from '../core/task/task-recovery-service.js';
+import { ExecutionTimeoutError, OrphanedTargetSessionError } from '../utils/error-utils.js';
 const FEEDBACK_DEADLINE_MS = 30_000;
-const TARGET_SESSION_DEADLINE_MS = 30 * 60_000;
 const TARGET_SESSION_CANCEL_GRACE_MS = 1_000;
+const TARGET_SESSION_OUTCOME_GRACE_MS = 5_000;
+const TARGET_SESSION_PROBE_MS = 30_000;
+const TARGET_SESSION_ORPHAN_GRACE_MS = 120_000;
 export class TriggerFeedbackDispatcher {
     deps;
     constructor(deps) {
@@ -50,20 +55,72 @@ export class TriggerFeedbackDispatcher {
     }
     async dispatchTargetSession(input) {
         const feedback = this.auditFeedback(input.trigger);
-        const unresolvedTarget = this.resolveDeliveryTarget(input.trigger);
+        let eventSession;
+        let eventAgentAid;
+        let unresolvedTarget = this.resolveDeliveryTarget(input.trigger);
+        if (input.trigger.feedback.strategy === 'event_session') {
+            const payload = input.sourcePayload;
+            eventAgentAid = typeof payload?.agentAid === 'string' && payload.agentAid.trim()
+                ? payload.agentAid.trim()
+                : undefined;
+            if (input.trigger.source.type !== 'event' || !payload || !eventAgentAid
+                || (!isDaemonEventSessionTrigger(input.trigger) && eventAgentAid !== input.trigger.agentAid)
+                || typeof payload.sessionId !== 'string' || !/^[A-Za-z0-9_-]+$/.test(payload.sessionId)
+                || typeof payload.peerId !== 'string' || !payload.peerId.trim()) {
+                return this.failed(feedback, [], 'event_session_invalid', 'event must identify the owning agent, session, and original actor');
+            }
+            try {
+                eventSession = await targetSessionLookup(this.deps.sessionManager.getSessionById(payload.sessionId));
+            }
+            catch (error) {
+                return this.failed(feedback, [], 'target_session_setup_failed', String(error));
+            }
+            if (!eventSession || eventSession.deletedAt) {
+                return this.failed(feedback, [], 'event_session_missing', 'event source session no longer exists');
+            }
+            if (eventSession.selfAID !== eventAgentAid
+                || (!isDaemonEventSessionTrigger(input.trigger) && eventSession.selfAID !== input.trigger.agentAid)) {
+                return this.failed(feedback, [], 'event_session_agent_mismatch', 'event source session belongs to another agent');
+            }
+            const channelKey = eventSession.metadata?.channelKey ?? eventSession.channel;
+            if (!['private', 'group'].includes(eventSession.chatType) || channelTypeFromKey(channelKey) === 'daemon') {
+                return this.failed(feedback, [], 'event_session_route_invalid', 'event source is not a channel conversation');
+            }
+            if (channelTypeFromKey(channelKey) === 'aun' && typeof payload.encrypted !== 'boolean') {
+                return this.failed(feedback, [], 'event_session_encryption_missing', 'AUN event source must preserve the original encryption mode');
+            }
+            unresolvedTarget = {
+                channelKey,
+                channelId: eventSession.channelId,
+                chatType: eventSession.chatType,
+                session: eventSession.threadId ? 'thread' : 'main',
+                ...(eventSession.threadId ? { threadId: eventSession.threadId } : {}),
+            };
+        }
         if (!unresolvedTarget)
             return this.failed(feedback, [], 'target_missing', 'target_session feedback target is missing');
         const target = unresolvedTarget;
         if (channelTypeFromKey(target.channelKey) === 'aun' && !targetChatType(target)) {
             return this.failed(feedback, [], 'route_missing', 'AUN target_session has no explicit delivery route');
         }
+        const isTaskErrorRecovery = !!eventSession && input.sourcePayload?.type === 'task:error';
+        if (isTaskErrorRecovery && (typeof input.sourcePayload?.taskId !== 'string' || !input.sourcePayload.taskId
+            || !Number.isSafeInteger(input.sourcePayload.generation))) {
+            return this.failed(feedback, [], 'recovery_event_invalid', 'task:error must identify the original task and generation');
+        }
+        const prompt = isTaskErrorRecovery ? TASK_RECOVERY_PROMPT : input.prompt;
+        const targetAgentAid = eventSession?.selfAID ?? input.trigger.agentAid;
         feedback.target = target;
-        feedback.renderedTextHash = sha256(input.prompt);
-        feedback.renderedTextPreview = previewText(input.prompt);
+        feedback.renderedTextHash = sha256(prompt);
+        feedback.renderedTextPreview = previewText(prompt);
         if (input.dryRun) {
             return { status: 'completed', feedback, effects: [], error: null };
         }
+        if (isTaskErrorRecovery && (!this.deps.recoverTask || !this.deps.eventBus)) {
+            return this.failed(feedback, [], 'recovery_unavailable', 'task recovery and outcome tracking must be configured');
+        }
         const delivery = new AbortController();
+        const timeoutMs = executionTimeoutMs(input.trigger.execution);
         let abortKind;
         const abortDelivery = (kind, reason) => {
             if (delivery.signal.aborted)
@@ -77,33 +134,36 @@ export class TriggerFeedbackDispatcher {
         input.signal?.addEventListener('abort', onInputAbort, { once: true });
         if (input.signal?.aborted)
             onInputAbort();
-        const deadlineTimer = setTimeout(() => abortDelivery('timeout', new Error(`target session timed out after ${TARGET_SESSION_DEADLINE_MS}ms`)), TARGET_SESSION_DEADLINE_MS);
-        deadlineTimer.unref?.();
+        const deadlineTimer = timeoutMs === undefined ? undefined : setTimeout(() => abortDelivery('timeout', new ExecutionTimeoutError('target_session_timeout', timeoutMs)), timeoutMs);
+        deadlineTimer?.unref?.();
         let outcome;
+        let probeTimer;
+        let probing = false;
+        let disposed = false;
         let releaseSessionLock;
         try {
             if (delivery.signal.aborted) {
                 const aborted = targetSessionCancellationError(abortKind, delivery.signal.reason, false);
                 return this.failed(feedback, [], aborted.code, aborted.message);
             }
-            const binding = this.deps.getChannel(input.trigger.agentAid, target.channelKey);
-            if (!binding) {
-                return this.failed(feedback, [], 'channel_not_configured', `agent ${input.trigger.agentAid} has no channel ${target.channelKey}`);
+            const binding = this.deps.getChannel(targetAgentAid, target.channelKey);
+            if (!binding || binding.agentAid !== targetAgentAid) {
+                return this.failed(feedback, [], 'channel_not_configured', `agent ${targetAgentAid} has no channel ${target.channelKey}`);
             }
             const startedAt = Date.now();
             const channelType = channelTypeFromKey(target.channelKey);
             let session;
             try {
-                const existingLookup = target.session === 'thread'
+                const existingLookup = eventSession ?? (target.session === 'thread'
                     ? target.threadId && this.deps.sessionManager.getThreadSession
                         ? this.deps.sessionManager.getThreadSession(target.channelKey, target.channelId, target.threadId)
                         : undefined
                     : this.deps.sessionManager.getActiveSession
                         ? this.deps.sessionManager.getActiveSession(target.channelKey, target.channelId)
-                        : undefined;
+                        : undefined);
                 const existing = existingLookup === undefined
                     ? undefined
-                    : await raceWithAbort(Promise.resolve(existingLookup), delivery.signal);
+                    : await raceWithAbort(targetSessionLookup(Promise.resolve(existingLookup)), delivery.signal);
                 if (existing) {
                     session = existing;
                 }
@@ -114,7 +174,7 @@ export class TriggerFeedbackDispatcher {
                     const mainLookup = this.deps.sessionManager.getActiveSession?.(target.channelKey, target.channelId);
                     const main = mainLookup === undefined
                         ? undefined
-                        : await raceWithAbort(Promise.resolve(mainLookup), delivery.signal);
+                        : await raceWithAbort(targetSessionLookup(Promise.resolve(mainLookup)), delivery.signal);
                     const mainMetadata = main?.metadata;
                     const targetDelivery = targetDeliveryFor(target);
                     const chatType = targetDelivery?.chatType
@@ -126,7 +186,7 @@ export class TriggerFeedbackDispatcher {
                             : mainMetadata?.groupId;
                     const peerId = mainMetadata?.peerId ?? `trigger:${input.trigger.id}`;
                     const peerType = mainMetadata?.peerType ?? 'system';
-                    session = await raceWithAbort(this.deps.sessionManager.getOrCreateSession(target.channelKey, target.channelId, main?.projectPath ?? binding.projectPath, target.threadId, {
+                    session = await raceWithAbort(targetSessionLookup(this.deps.sessionManager.getOrCreateSession(target.channelKey, target.channelId, main?.projectPath ?? binding.projectPath, target.threadId, {
                         channelKey: mainMetadata?.channelKey ?? target.channelKey,
                         peerId,
                         peerName: mainMetadata?.peerName ?? input.trigger.name,
@@ -134,17 +194,17 @@ export class TriggerFeedbackDispatcher {
                         ...(groupId ? { groupId } : {}),
                         ...(mainMetadata?.groupName ? { groupName: mainMetadata.groupName } : {}),
                         replyContext: replyContextFromTarget(target),
-                    }, input.trigger.name, peerId, chatType, main?.baseagent ?? binding.baseagent, main?.selfAID ?? input.trigger.agentAid, main?.channelType ?? channelType, peerType), delivery.signal);
+                    }, input.trigger.name, peerId, chatType, main?.baseagent ?? binding.baseagent, main?.selfAID ?? targetAgentAid, main?.channelType ?? channelType, peerType)), delivery.signal);
                 }
                 else {
                     const targetDelivery = targetDeliveryFor(target);
-                    session = await raceWithAbort(this.deps.sessionManager.getOrCreateSession(target.channelKey, target.channelId, binding.projectPath, undefined, {
+                    session = await raceWithAbort(targetSessionLookup(this.deps.sessionManager.getOrCreateSession(target.channelKey, target.channelId, binding.projectPath, undefined, {
                         channelKey: target.channelKey,
                         peerId: `trigger:${input.trigger.id}`,
                         peerName: input.trigger.name,
                         ...(targetDelivery?.chatType === 'group' ? { groupId: targetDelivery.groupId } : {}),
                         replyContext: replyContextFromTarget(target),
-                    }, input.trigger.name, undefined, targetDelivery?.chatType === 'group' ? 'group' : 'private', binding.baseagent, input.trigger.agentAid, channelType, 'system'), delivery.signal);
+                    }, input.trigger.name, undefined, targetDelivery?.chatType === 'group' ? 'group' : 'private', binding.baseagent, targetAgentAid, channelType, 'system')), delivery.signal);
                 }
             }
             catch (err) {
@@ -178,17 +238,23 @@ export class TriggerFeedbackDispatcher {
                 channel: target.channelKey,
                 channelType,
                 channelId: target.channelId,
-                selfAID: input.trigger.agentAid,
+                selfAID: targetAgentAid,
                 baseagent: session.baseagent || binding.baseagent,
                 threadId: session.threadId || '',
                 chatType: messageChatType,
                 peerId: `trigger:${input.trigger.id}`,
                 peerName: input.trigger.name,
                 peerType: 'system',
-                content: input.prompt,
+                content: prompt,
                 messageId: input.attemptId,
                 timestamp: Date.now(),
                 source: 'trigger',
+                ...(eventSession ? {
+                    // Bind the exact session; never fall back to a newly activated main
+                    // session or create a replacement for a deleted source thread.
+                    boundSessionId: eventSession.id,
+                    encrypted: input.sourcePayload?.encrypted,
+                } : {}),
                 causation: input.causation,
                 groupId: targetChatType === 'group' ? targetDelivery.groupId : undefined,
                 replyContext: replyContextFromTarget(target),
@@ -202,30 +268,128 @@ export class TriggerFeedbackDispatcher {
                     modelOverride: input.trigger.execution.model,
                     effortOverride: input.trigger.execution.effort,
                     permissionModeOverride: input.trigger.execution.permissionMode,
-                    originPeerId: input.trigger.origin?.peerId,
-                    originChannelKey: input.trigger.origin?.channelKey,
-                    originChannelType: input.trigger.origin?.channelType
+                    originPeerId: eventSession ? input.sourcePayload.peerId : input.trigger.origin?.peerId,
+                    originChannelKey: eventSession ? target.channelKey : input.trigger.origin?.channelKey,
+                    originChannelType: eventSession ? channelType : input.trigger.origin?.channelType
                         ?? (input.trigger.origin?.channelKey ? channelTypeFromKey(input.trigger.origin.channelKey) : undefined),
-                    originControl: input.trigger.origin?.channelKey === 'daemon',
+                    ...(eventSession ? { originChatType: messageChatType, originConversationId: target.channelId } : {}),
+                    originControl: !eventSession && input.trigger.origin?.channelKey === 'daemon',
                     authorizedBy: input.trigger.authorizedBy,
                 },
             };
             outcome = this.waitForTriggerOutcome(input.runId, input.attemptId, delivery.signal);
+            let missingSince;
+            let observedTaskId;
+            let orphanNotificationOwned = false;
+            const notifyOrphan = async () => {
+                if (orphanNotificationOwned || disposed || delivery.signal.aborted)
+                    return;
+                orphanNotificationOwned = true;
+                const text = '⚠️ 任务执行状态丢失，已结束本次执行。';
+                const envelope = buildEnvelope({
+                    taskId: observedTaskId ?? input.attemptId, sessionId: session.id,
+                    channel: target.channelKey, channelId: target.channelId,
+                    agentName: binding.agentName, chatmode: 'interactive', causation: input.causation,
+                    replyContext: { ...replyContextFromTarget(target), sessionId: session.id,
+                        metadata: { ...session.metadata?.replyContext?.metadata,
+                            ...(message.encrypted !== undefined ? { encrypted: message.encrypted } : {}) } },
+                });
+                await binding.adapter.send(envelope, { kind: 'status.error',
+                    metadata: { errorType: 'orphaned_target_session', message: text } });
+                await binding.adapter.send(envelope, { kind: 'result.error', reason: 'orphaned_target_session', text });
+            };
+            const inspect = async () => {
+                if (!this.deps.inspectTargetExecution || disposed || delivery.signal.aborted)
+                    return undefined;
+                const observed = await targetSessionLookup(this.deps.inspectTargetExecution(session.id, input.attemptId, targetAgentAid));
+                if (disposed || delivery.signal.aborted)
+                    return undefined;
+                observedTaskId = observed.taskId ?? observedTaskId;
+                if (observed.state === 'terminal') {
+                    const base = { triggerId: input.trigger.id, name: input.trigger.name, runId: input.runId,
+                        attemptId: input.attemptId, originTriggerId: input.trigger.id, messageId: input.attemptId,
+                        targetChannel: target.channelKey, targetChannelId: target.channelId, fireTime: input.firedAt };
+                    const event = observed.outcome === 'completed'
+                        ? { ...base, type: 'trigger:completed', durationMs: Date.now() - startedAt }
+                        : observed.outcome === 'failed'
+                            ? { ...base, type: 'trigger:failed', error: observed.reason ?? 'target_session_failed', phase: 'execute' }
+                            : { ...base, type: 'trigger:skipped', reason: observed.reason ?? 'stale_generation',
+                                decisionSource: 'infrastructure', executionState: 'interrupted' };
+                    outcome?.settle(event);
+                    return event;
+                }
+                if (observed.state !== 'missing') {
+                    missingSince = undefined;
+                    return undefined;
+                }
+                missingSince ??= Date.now();
+                if (Date.now() - missingSince >= TARGET_SESSION_ORPHAN_GRACE_MS) {
+                    if (!observed.hasTerminalOwner
+                        || this.deps.messageQueue.getMessageState(session.id, input.attemptId, targetAgentAid).state !== 'active') {
+                        await notifyOrphan();
+                    }
+                    abortDelivery('cancelled', new OrphanedTargetSessionError());
+                }
+                return undefined;
+            };
+            if (this.deps.inspectTargetExecution) {
+                probeTimer = setInterval(() => {
+                    if (probing || disposed)
+                        return;
+                    probing = true;
+                    void inspect().catch(() => { missingSince = undefined; }).finally(() => { probing = false; });
+                }, TARGET_SESSION_PROBE_MS);
+                probeTimer.unref?.();
+            }
             let enqueuePromise;
             let event;
             try {
-                enqueuePromise = this.deps.messageQueue.enqueue(session.id, message, session.projectPath, {
-                    interruptible: false,
-                    agentName: binding.agentName,
-                    sessionKeyField: session.sessionKey,
-                    selfAID: input.trigger.agentAid,
-                    signal: delivery.signal,
-                });
+                if (isTaskErrorRecovery) {
+                    const recovery = await this.deps.recoverTask({
+                        sessionId: session.id, agentAid: targetAgentAid, automatic: true,
+                        expectedTaskId: input.sourcePayload.taskId,
+                        expectedGeneration: input.sourcePayload.generation,
+                        peerId: input.sourcePayload.peerId,
+                        encrypted: input.sourcePayload.encrypted,
+                        message, signal: delivery.signal,
+                    });
+                    if (recovery.status !== 'queued_recovery') {
+                        if (delivery.signal.aborted)
+                            throw delivery.signal.reason;
+                        return { status: 'skipped', reason: `recovery_${recovery.status}`, feedback, effects: [], error: null };
+                    }
+                    if (!recovery.completion)
+                        throw new Error('task recovery completion tracking is unavailable');
+                    enqueuePromise = recovery.completion;
+                }
+                else {
+                    enqueuePromise = this.deps.messageQueue.enqueue(session.id, message, session.projectPath, {
+                        interruptible: false,
+                        agentName: binding.agentName,
+                        sessionKeyField: session.sessionKey,
+                        selfAID: targetAgentAid,
+                        signal: delivery.signal,
+                    });
+                }
                 if (outcome) {
                     const enqueueFailure = new Promise((_, reject) => {
                         void enqueuePromise.catch(reject);
                     });
-                    event = await Promise.race([outcome.promise, enqueueFailure]);
+                    const queueCompletion = enqueuePromise.then(async () => {
+                        const terminal = await settleTriggerOutcome(outcome.promise, TARGET_SESSION_OUTCOME_GRACE_MS);
+                        if (terminal)
+                            return terminal;
+                        if (disposed || delivery.signal.aborted)
+                            return undefined;
+                        const reconciled = await inspect();
+                        if (reconciled)
+                            return reconciled;
+                        if (this.deps.inspectTargetExecution)
+                            return outcome.promise;
+                        await notifyOrphan();
+                        throw new OrphanedTargetSessionError();
+                    });
+                    event = await Promise.race([outcome.promise, queueCompletion, enqueueFailure]);
                 }
                 else {
                     await raceWithAbort(enqueuePromise, delivery.signal);
@@ -261,12 +425,12 @@ export class TriggerFeedbackDispatcher {
                         }
                         : undefined;
                     return {
-                        status: interruption ? 'skipped' : 'failed',
+                        status: interruption || event.reason === 'recovery_stale' ? 'skipped' : 'failed',
                         reason: event.reason,
                         ...(interruption ? { interruption } : {}),
                         feedback,
                         effects: [this.inboundEffect('success', target, session.id, startedAt)],
-                        error: interruption
+                        error: interruption || event.reason === 'recovery_stale'
                             ? null
                             : { code: event.reason || 'target_session_skipped', message: event.reason || 'target session skipped' },
                     };
@@ -294,14 +458,17 @@ export class TriggerFeedbackDispatcher {
                 }
                 return {
                     status: 'failed',
-                    reason: 'enqueue_error',
+                    reason: err instanceof OrphanedTargetSessionError ? err.reason : 'enqueue_error',
                     feedback,
                     effects: [this.inboundEffect('failed', target, session.id, startedAt, undefined, err?.message || String(err))],
-                    error: { code: 'enqueue_error', message: err?.message || String(err) },
+                    error: { code: err instanceof OrphanedTargetSessionError ? err.reason : 'enqueue_error', message: err?.message || String(err) },
                 };
             }
         }
         finally {
+            disposed = true;
+            if (probeTimer)
+                clearInterval(probeTimer);
             releaseSessionLock?.();
             clearTimeout(deadlineTimer);
             input.signal?.removeEventListener('abort', onInputAbort);
@@ -334,7 +501,7 @@ export class TriggerFeedbackDispatcher {
         };
     }
     resolveDeliveryTarget(trigger) {
-        if (trigger.feedback.strategy === 'silent')
+        if (trigger.feedback.strategy === 'silent' || trigger.feedback.strategy === 'event_session')
             return undefined;
         if (trigger.feedback.strategy === 'target')
             return trigger.feedback.target;
@@ -526,6 +693,7 @@ export class TriggerFeedbackDispatcher {
         if (!this.deps.eventBus)
             return undefined;
         let cancel = () => { };
+        let settle = (_event) => { };
         const promise = new Promise(resolve => {
             let settled = false;
             const finish = (event) => {
@@ -570,8 +738,9 @@ export class TriggerFeedbackDispatcher {
             if (signal?.aborted)
                 onAbort();
             cancel = () => finish();
+            settle = event => finish(event);
         });
-        return { promise, cancel: () => cancel() };
+        return { promise, cancel: () => cancel(), settle: event => settle(event) };
     }
     failed(feedback, effects, code, message) {
         return {
@@ -751,9 +920,10 @@ function feedbackCancellation(parent, timeoutMs) {
     };
 }
 function targetSessionCancellationError(kind, reason, barrierTimedOut) {
-    const code = kind === 'timeout' ? 'target_session_timeout' : 'cancelled';
+    const code = reason instanceof OrphanedTargetSessionError ? reason.reason
+        : kind === 'timeout' ? 'target_session_timeout' : 'cancelled';
     const base = kind === 'timeout'
-        ? `target session timed out after ${TARGET_SESSION_DEADLINE_MS}ms`
+        ? `target session timed out after ${reason instanceof ExecutionTimeoutError ? reason.timeoutMs : 'unknown'}ms`
         : reason instanceof Error
             ? reason.message
             : 'target session delivery cancelled';
@@ -796,6 +966,21 @@ function settleWithin(promise, timeoutMs) {
         promise.then(() => finish(true), () => finish(true));
     });
 }
+function settleTriggerOutcome(promise, timeoutMs) {
+    return new Promise(resolve => {
+        let settled = false;
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(value);
+        };
+        const timer = setTimeout(() => finish(undefined), timeoutMs);
+        timer.unref?.();
+        promise.then(finish, () => finish(undefined));
+    });
+}
 function sleep(ms, signal) {
     if (signal?.aborted)
         return Promise.resolve(false);
@@ -815,3 +1000,11 @@ function sleep(ms, signal) {
         signal?.addEventListener('abort', onAbort, { once: true });
     });
 }
+/** Bound local session lookup/setup without limiting an admitted task's execution. */
+function targetSessionLookup(promise) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error('target_session_setup_timeout')), 30_000);
+        timer.unref?.();
+        promise.then(resolve, reject).finally(() => clearTimeout(timer));
+    });
+}

package/dist/trigger/parser.js

@@ -1,8 +1,8 @@
 import { CronExpressionParser } from 'cron-parser';
 const TRIGGER_UPDATE_FLAGS = new Set([
-    'once', 'delay', 'at', 'cron', 'every', 'event', 'tz',
+    'once', 'delay', 'at', 'cron', 'every', 'event', 'event-filter', 'tz',
     'prompt', 'name', 'description',
-    'script-file', 'script-runtime', 'script-args', 'script-timeout',
+    'script-file', 'script-runtime', 'script-args', 'script-timeout', 'execution-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',
@@ -10,9 +10,9 @@ const TRIGGER_UPDATE_FLAGS = new Set([
     'max-runs', 'max-duration', 'concurrency', 'missed-policy',
 ]);
 const TRIGGER_CREATE_FLAGS = new Set([
-    'once', 'delay', 'at', 'cron', 'every', 'event', 'tz',
+    'once', 'delay', 'at', 'cron', 'every', 'event', 'event-filter', 'tz',
     'exec', 'prompt', 'name', 'agent',
-    'script-path', 'script-runtime', 'script-args', 'script-timeout',
+    'script-path', 'script-runtime', 'script-args', 'script-timeout', 'execution-timeout',
     'feedback', 'target-channel', 'target-channel-id', 'target-chat-type', 'target-session', 'target-thread-id',
     'trigger-thread', 'baseagent',
     'model', 'effort', 'permission', 'max-runs', 'max-duration',
@@ -205,7 +205,9 @@ function parseFeedbackStrategy(flags) {
         return { ok: false, error: '--feedback 不能为空' };
     if (raw === 'origin' || raw === 'target' || raw === 'silent')
         return { ok: true, value: raw };
-    return { ok: false, error: '--feedback 只接受 origin、target 或 silent' };
+    if (raw === 'event-session' || raw === 'event_session')
+        return { ok: true, value: 'event_session' };
+    return { ok: false, error: '--feedback 只接受 origin、target、event-session 或 silent' };
 }
 function parseTriggerThread(flags) {
     if (!flags.has('trigger-thread'))
@@ -298,6 +300,24 @@ function parseSourceFlags(flags, opts = {}) {
         return { ok: false, error: '--event 不能为空' };
     return { ok: true, scheduleType: 'event', scheduleValue: raw };
 }
+function parseEventFilterFlag(flags) {
+    if (!flags.has('event-filter'))
+        return { ok: true };
+    const raw = flags.get('event-filter');
+    if (!raw || raw === true)
+        return { ok: false, error: '--event-filter 不能为空' };
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        return { ok: false, error: '--event-filter 必须是合法的 JSON 对象' };
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return { ok: false, error: '--event-filter 必须是合法的 JSON 对象' };
+    }
+    return { ok: true, value: value };
+}
 function commonParsed(flags, opts = {}) {
     const deprecated = rejectDeprecatedFlags(flags);
     if (deprecated)
@@ -311,6 +331,12 @@ function commonParsed(flags, opts = {}) {
     const source = parseSourceFlags(flags, opts);
     if (!source.ok)
         return source;
+    const eventFilter = parseEventFilterFlag(flags);
+    if (!eventFilter.ok)
+        return eventFilter;
+    if (flags.has('event-filter') && source.scheduleType !== 'event' && (!opts.update || source.scheduleType !== undefined)) {
+        return { ok: false, error: '--event-filter 只能和 --event 一起使用' };
+    }
     if (flags.has('tz') && source.scheduleType !== 'cron' && (!opts.update || source.scheduleType !== undefined)) {
         return { ok: false, error: '--tz 只能和 --cron 一起使用' };
     }
@@ -329,6 +355,11 @@ function commonParsed(flags, opts = {}) {
     const scriptTimeout = parseDurationFlag(flags, 'script-timeout', '--script-timeout');
     if (!scriptTimeout.ok)
         return scriptTimeout;
+    const executionTimeout = opts.update && flags.get('execution-timeout') === 'default'
+        ? { ok: true, value: undefined }
+        : parseDurationFlag(flags, 'execution-timeout', '--execution-timeout');
+    if (!executionTimeout.ok)
+        return executionTimeout;
     const maxRuns = parsePositiveIntegerFlag(flags, 'max-runs', '--max-runs');
     if (!maxRuns.ok)
         return maxRuns;
@@ -418,10 +449,18 @@ function commonParsed(flags, opts = {}) {
     }
     const targetSessionValue = targetSession.value ?? (targetThreadId ? 'thread' : 'main');
     const feedbackStrategy = feedback.value ?? (hasTargetField ? 'target' : 'origin');
+    if (feedbackStrategy === 'event_session') {
+        if (hasTargetField)
+            return { ok: false, error: '--feedback event-session 不能指定固定 target 字段' };
+        if (!opts.update && (source.scheduleType !== 'event' || inferredExecution !== 'target_session')) {
+            return { ok: false, error: '--feedback event-session 需要 --event 和 --exec target-session' };
+        }
+    }
     return {
         ok: true,
         value: {
             ...source,
+            eventFilter: eventFilter.value,
             executionType: execution.value,
             inferredExecution,
             feedbackStrategy,
@@ -437,6 +476,7 @@ function commonParsed(flags, opts = {}) {
             scriptRuntime: scriptRuntime,
             scriptArgs,
             scriptTimeoutMs: scriptTimeout.value,
+            executionTimeoutMs: executionTimeout.value,
             triggerThread: triggerThread.value,
             baseagent: baseagent.value,
             maxRuns: maxRuns.value,
@@ -462,6 +502,7 @@ export function parseTriggerSet(args) {
             scheduleType: value.scheduleType,
             scheduleValue: value.scheduleValue ?? '',
             timezone: value.timezone,
+            eventFilter: value.eventFilter,
             executionType: value.inferredExecution,
             feedbackStrategy: value.feedbackStrategy,
             targetChannel: value.targetChannel,
@@ -476,6 +517,7 @@ export function parseTriggerSet(args) {
             scriptRuntime: value.scriptRuntime,
             scriptArgs: value.scriptArgs,
             scriptTimeoutMs: value.scriptTimeoutMs,
+            executionTimeoutMs: value.executionTimeoutMs,
             triggerThread: value.triggerThread,
             baseagent: value.baseagent,
             maxRuns: value.maxRuns,
@@ -502,6 +544,7 @@ export function parseTriggerSetArgv(args, opts = {}) {
             scheduleType: value.scheduleType,
             scheduleValue: value.scheduleValue ?? '',
             timezone: value.timezone,
+            eventFilter: value.eventFilter,
             executionType: value.inferredExecution,
             feedbackStrategy: value.feedbackStrategy,
             targetChannel: value.targetChannel,
@@ -516,6 +559,7 @@ export function parseTriggerSetArgv(args, opts = {}) {
             scriptRuntime: value.scriptRuntime,
             scriptArgs: value.scriptArgs,
             scriptTimeoutMs: value.scriptTimeoutMs,
+            executionTimeoutMs: value.executionTimeoutMs,
             triggerThread: value.triggerThread,
             baseagent: value.baseagent,
             maxRuns: value.maxRuns,
@@ -625,6 +669,10 @@ function parseTriggerUpdateFlags(nameOrId, flags, opts = {}) {
         update.scriptFile = scriptFile.value;
     if (value.model !== undefined)
         update.model = value.model;
+    if (flags.get('execution-timeout') === 'default')
+        update.executionTimeoutMs = null;
+    else if (value.executionTimeoutMs !== undefined)
+        update.executionTimeoutMs = value.executionTimeoutMs;
     if (value.effort !== undefined)
         update.effort = value.effort;
     if (value.permissionMode !== undefined)
@@ -659,6 +707,8 @@ function parseTriggerUpdateFlags(nameOrId, flags, opts = {}) {
         update.description = description.value || null;
     if (flags.has('feedback') && value.feedbackStrategy !== undefined)
         update.feedback = value.feedbackStrategy;
+    if (flags.has('event-filter'))
+        update.eventFilter = value.eventFilter;
     if (value.targetChannel !== undefined)
         update.targetChannel = value.targetChannel;
     if (value.targetChannelId !== undefined)

package/dist/trigger/patch.js

@@ -5,8 +5,10 @@ const PATCH_KEYS = new Set([
     'scheduleType',
     'scheduleValue',
     'timezone',
+    'eventFilter',
     'prompt',
     'model',
+    'executionTimeoutMs',
     'effort',
     'permissionMode',
     'maxRuns',
@@ -56,6 +58,8 @@ export function applyTriggerPatch(definition, input, opts = {}) {
     }
     if (patch.model !== undefined)
         setOptional(updated.execution, 'model', patch.model);
+    if (patch.executionTimeoutMs !== undefined)
+        setOptional(updated.execution, 'timeoutMs', patch.executionTimeoutMs);
     if (patch.effort !== undefined)
         setOptional(updated.execution, 'effort', patch.effort);
     if (patch.permissionMode !== undefined)
@@ -226,6 +230,11 @@ function applySourcePatch(updated, patch) {
         else
             updated.source.timezone = String(patch.timezone);
     }
+    if (patch.eventFilter !== undefined) {
+        if (updated.source.type !== 'event')
+            throw new Error('eventFilter is only valid for an event trigger');
+        updated.source.filter = patch.eventFilter;
+    }
 }
 function sourceFromSchedule(type, value) {
     switch (type) {