mcp-event-intelligence 0.4.0 → 0.6.0

package/dist/src/composite/engine.js

@@ -1,24 +1,71 @@
-import { SemanticConditionEngine } from '../semantic/conditionEngine.js';
+import { evaluatePatternV2, patternV2CandidateSignature, } from '../patternV2/evaluator.js';
 import { sha256Hex } from '../intelligenceProtocol/canonical.js';
 import { COMPOSITE_TRIGGER_PROTOCOL_VERSION, COMPOSITE_TRIGGER_SCHEMA_VERSION, CompositeTriggerDefinitionSchema, CorrelatableEventSchema, TriggerMatchRecordSchema, } from '../intelligenceProtocol/triggerSchemas.js';
-import { evaluateTemporalConditions, } from './temporal.js';
-import { asSourceEvent, clauseMatches, deterministicKeyForClause, expressionSatisfied, matchesCorrelationKey, sameEventIdentity, semanticSource, } from './matching.js';
+import { asSourceEvent, clauseMatches, sameEventIdentity, } from './matching.js';
 import { assertNoDerivedEventCycle } from './derivedGraph.js';
 import { CompositeTriggerRuntimeSupport, } from './runtimeSupport.js';
+function getByPath(source, path) {
+    let current = source;
+    for (const part of path.split('.')) {
+        if (current === null ||
+            typeof current !== 'object' ||
+            Array.isArray(current))
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+function sourceEventOrder(left, right) {
+    return (Date.parse(left.occurredAt) - Date.parse(right.occurredAt) ||
+        left.sourceEventId.localeCompare(right.sourceEventId) ||
+        left.clauseId.localeCompare(right.clauseId));
+}
+function stablePatternValue(value) {
+    if (Array.isArray(value))
+        return value.map(stablePatternValue);
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.keys(value)
+            .sort()
+            .map((key) => [
+            key,
+            stablePatternValue(value[key]),
+        ]));
+    }
+    return value;
+}
+function patternPhysicalIdentity(event) {
+    return [
+        event.serverId ?? '-',
+        event.sourceEventId,
+        JSON.stringify(stablePatternValue(event.subscriptionArguments ?? {})),
+    ].join(':');
+}
 export class CompositeTriggerEngine {
     store;
     evaluator;
     now;
     support;
-    constructor(store, evaluator = null, now = () => new Date()) {
+    workerId;
+    partitionLeaseMs;
+    constructor(store, evaluator = null, now = () => new Date(), options = {}) {
         this.store = store;
         this.evaluator = evaluator;
         this.now = now;
         this.support = new CompositeTriggerRuntimeSupport(store, now);
+        this.workerId =
+            String(options.workerId || 'event-intelligence-engine');
+        this.partitionLeaseMs = Math.max(1000, Number(options.partitionLeaseMs) || 300000);
     }
     async register(definitionInput) {
         const definition = CompositeTriggerDefinitionSchema.parse(definitionInput);
-        assertNoDerivedEventCycle(this.store.listTriggers(), definition, this.store.getTriggerState?.bind(this.store));
+        const existingDefinitions = await this.store.listTriggers();
+        const stateByTrigger = new Map();
+        if (this.store.getTriggerState) {
+            await Promise.all(existingDefinitions.map(async (existing) => {
+                stateByTrigger.set(`${existing.triggerId}@${existing.version}`, await this.store.getTriggerState(existing.triggerId, existing.version));
+            }));
+        }
+        assertNoDerivedEventCycle(existingDefinitions, definition, (triggerId, version) => stateByTrigger.get(`${triggerId}@${version}`) ?? null);
         await this.store.putTrigger(definition);
         return definition;
     }
@@ -28,17 +75,33 @@ export class CompositeTriggerEngine {
             return this.ingestTimerEvent(event);
         }
         const results = [];
-        for (const definition of this.store.listTriggers()) {
-            const triggerState = this.store.getTriggerState?.(definition.triggerId, definition.version) ?? null;
+        for (const definition of await this.store.listTriggers()) {
+            const triggerState = this.store.getTriggerState
+                ? await this.store.getTriggerState(definition.triggerId, definition.version)
+                : null;
             if (!(await this.support.lifecycleAllows(definition, triggerState, this.now()))) {
                 continue;
             }
             const matchingClauses = definition.clauses.filter((clause) => clauseMatches(clause, event));
             if (matchingClauses.length === 0)
                 continue;
-            const replayed = this.store
-                .listTriggerMatches(definition.triggerId)
-                .find((record) => record.sourceEvents.some((source) => sameEventIdentity(source, event)));
+            const replayed = (await this.store
+                .listTriggerMatches(definition.triggerId))
+                .filter((record) => record.triggerVersion === definition.version &&
+                record.sourceEvents.some((source) => sameEventIdentity(source, event)))
+                .sort((a, b) => {
+                const rank = (status) => status === 'fired'
+                    ? 4
+                    : status === 'emitted'
+                        ? 3
+                        : status === 'matched'
+                            ? 2
+                            : status === 'partial'
+                                ? 1
+                                : 0;
+                return (rank(b.status) - rank(a.status) ||
+                    Date.parse(b.updatedAt) - Date.parse(a.updatedAt));
+            })[0];
             if (replayed) {
                 results.push({
                     triggerId: definition.triggerId,
@@ -50,13 +113,12 @@ export class CompositeTriggerEngine {
                 });
                 continue;
             }
-            const clause = matchingClauses[0];
-            results.push(await this.applyEvent(definition, clause, event));
+            results.push(...await this.applyPattern(definition, matchingClauses, event));
         }
         return results;
     }
     async markFired(matchId, wakeId) {
-        const latest = this.latestMatch(matchId);
+        const latest = await this.latestMatch(matchId);
         if (!latest)
             throw new Error(`Unknown trigger match: ${matchId}`);
         if (latest.status === 'fired')
@@ -77,7 +139,7 @@ export class CompositeTriggerEngine {
         return fired;
     }
     async markDerivedEmitted(matchId, derivedEventId) {
-        const latest = this.latestMatch(matchId);
+        const latest = await this.latestMatch(matchId);
         if (!latest)
             throw new Error(`Unknown trigger match: ${matchId}`);
         if (latest.status === 'emitted' &&
@@ -107,18 +169,20 @@ export class CompositeTriggerEngine {
         const deadlineId = String(event.data.deadlineId ?? '');
         if (!deadlineId || !this.store.getTemporalDeadline)
             return [];
-        const deadline = this.store.getTemporalDeadline(deadlineId);
+        const deadline = await this.store.getTemporalDeadline(deadlineId);
         if (!deadline || deadline.status !== 'pending')
             return [];
-        const definition = this.store.listTriggers().find((candidate) => candidate.triggerId === deadline.triggerId &&
+        const definition = (await this.store.listTriggers()).find((candidate) => candidate.triggerId === deadline.triggerId &&
             candidate.version === deadline.triggerVersion);
         if (!definition)
             return [];
-        const triggerState = this.store.getTriggerState?.(definition.triggerId, definition.version) ?? null;
+        const triggerState = this.store.getTriggerState
+            ? await this.store.getTriggerState(definition.triggerId, definition.version)
+            : null;
         if (!(await this.support.lifecycleAllows(definition, triggerState, this.now()))) {
             return [];
         }
-        const match = this.latestMatch(deadline.matchId);
+        const match = await this.latestMatch(deadline.matchId);
         if (!match ||
             match.status === 'matched' ||
             match.status === 'emitted' ||
@@ -126,224 +190,485 @@ export class CompositeTriggerEngine {
             match.status === 'expired') {
             return [];
         }
-        if (Date.parse(event.occurredAt) > Date.parse(match.expiresAt)) {
-            const expired = TriggerMatchRecordSchema.parse({
-                ...match,
-                status: 'expired',
-                updatedAt: event.occurredAt,
-            });
-            await this.store.appendTriggerMatch(expired);
-            await this.support.cancelDeadlinesForMatch(expired.matchId);
-            await this.support.auditMatch(expired, 'trigger.expired', {
-                reason: 'temporal_deadline_after_event_window',
+        if (match.patternState?.version === '2' &&
+            match.patternState.role === 'buffer') {
+            return this.evaluatePatternBuffer(definition, match, new Date(event.occurredAt));
+        }
+        return [];
+    }
+    patternPartitionKey(definition, matchingClauses, event) {
+        const dimensions = definition.pattern?.partitionBy ?? [];
+        if (!dimensions.length)
+            return null;
+        const clauseIds = new Set(matchingClauses.map((clause) => clause.id));
+        const components = [];
+        for (const dimension of dimensions) {
+            const fields = dimension.fields.filter((field) => clauseIds.has(field.ref));
+            if (!fields.length) {
+                throw new Error(`Pattern partition ${dimension.key} has no field for incoming event ${event.name}`);
+            }
+            const values = fields.map((field) => getByPath(event.data, field.path));
+            const first = values[0];
+            if (first === undefined ||
+                first === null ||
+                !['string', 'number', 'boolean'].includes(typeof first)) {
+                throw new Error(`Pattern partition ${dimension.key} resolved to a non-scalar value`);
+            }
+            if (values.some((value) => typeof value !== typeof first ||
+                value !== first)) {
+                throw new Error(`Pattern partition ${dimension.key} is ambiguous for incoming event ${event.name}`);
+            }
+            components.push({
+                key: dimension.key,
+                type: typeof first,
+                value: first,
             });
-            return [{
-                    triggerId: definition.triggerId,
-                    match: expired,
-                    matched: false,
-                    fired: false,
-                }];
         }
-        const result = await this.finalizeEligible(definition, match, new Date(event.occurredAt));
-        return [result];
+        return JSON.stringify(components);
     }
-    async applyEvent(definition, clause, event) {
-        const nowIso = this.now().toISOString();
-        const eventTime = Date.parse(event.occurredAt);
-        const key = deterministicKeyForClause(definition, clause.id, event);
-        const existing = this.store
-            .listTriggerMatches(definition.triggerId)
-            .filter((record) => record.triggerVersion === definition.version &&
-            (record.status === 'partial' || record.status === 'matched') &&
-            matchesCorrelationKey(record, key))
-            .sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt))[0];
-        if (existing?.status === 'matched') {
-            return {
-                triggerId: definition.triggerId,
-                match: existing,
-                matched: true,
-                fired: false,
-            };
+    async patternBufferId(definition, key) {
+        return `tm_${(await sha256Hex([
+            definition.triggerId,
+            definition.version,
+            key ?? '-',
+            'pattern-v2-buffer',
+        ].join(':'))).slice(0, 24)}`;
+    }
+    patternDecisionRecord(item, evaluatedAt) {
+        const decision = item.decision;
+        return {
+            nodeId: item.nodeId,
+            decision: {
+                evaluator: decision.evaluator,
+                outcome: decision.outcome,
+                probability: decision.probability,
+                matched: decision.matched,
+                shouldEscalate: decision.shouldEscalate,
+                inputFields: decision.condition.input,
+                ...(decision.metadata
+                    ? { providerEvidence: decision.metadata }
+                    : {}),
+                evaluatedAt,
+            },
+        };
+    }
+    async applyPattern(definition, matchingClauses, event) {
+        const key = this.patternPartitionKey(definition, matchingClauses, event);
+        const capabilities = this.store.storeCapabilities?.();
+        const distributedLeases = capabilities?.partitionLeases === 'distributed-atomic';
+        if (!distributedLeases) {
+            return this.applyPatternWithPartition(definition, matchingClauses, event, key);
         }
-        let record = existing ?? await this.newMatch(definition, key, event);
-        if (Date.parse(record.expiresAt) < eventTime) {
-            const expired = TriggerMatchRecordSchema.parse({
-                ...record,
-                status: 'expired',
-                updatedAt: nowIso,
-            });
-            await this.store.appendTriggerMatch(expired);
-            await this.support.cancelDeadlinesForMatch(expired.matchId);
-            await this.support.auditMatch(expired, 'trigger.expired', {
-                reason: 'window_expired_before_event',
-            });
-            record = await this.newMatch(definition, key, event);
+        if (!this.store.claimPartitionLease ||
+            !this.store.releasePartitionLease) {
+            const error = new Error('Distributed Pattern v2 store is missing partition lease methods');
+            error.code =
+                'PATTERN_PARTITION_LEASE_UNSUPPORTED';
+            throw error;
         }
-        const duplicate = record.sourceEvents.some((candidate) => sameEventIdentity(candidate, event));
-        if (!duplicate) {
-            record = TriggerMatchRecordSchema.parse({
-                ...record,
-                correlationKey: record.correlationKey ?? key,
-                updatedAt: nowIso,
-                sourceEvents: [
-                    ...record.sourceEvents,
-                    asSourceEvent(clause.id, event),
-                ],
-            });
+        const leaseKey = [
+            definition.triggerId,
+            definition.version,
+            key ?? '-',
+        ].join(':');
+        const nowIso = this.now().toISOString();
+        const lease = await this.store.claimPartitionLease(leaseKey, {
+            workerId: this.workerId,
+            now: nowIso,
+            leaseMs: this.partitionLeaseMs,
+        });
+        if (!lease) {
+            const error = new Error(`Pattern partition is currently owned by another worker: ${leaseKey}`);
+            error.code =
+                'PATTERN_PARTITION_LEASE_BUSY';
+            throw error;
+        }
+        try {
+            return await this.applyPatternWithPartition(definition, matchingClauses, event, key);
         }
-        if (!expressionSatisfied(definition, record)) {
-            await this.store.appendTriggerMatch(record);
-            await this.support.auditMatch(record, 'trigger.partial', {
-                clauseId: clause.id,
-                sourceEventId: event.sourceEventId,
+        finally {
+            await this.store.releasePartitionLease(leaseKey, {
+                workerId: this.workerId,
+                now: this.now().toISOString(),
             });
-            return {
-                triggerId: definition.triggerId,
-                match: record,
-                matched: false,
-                fired: false,
-            };
         }
-        return this.finalizeEligible(definition, record, this.now());
     }
-    async finalizeEligible(definition, record, evaluationNow) {
-        const nowIso = evaluationNow.toISOString();
-        const temporal = evaluateTemporalConditions(definition, record, evaluationNow);
-        if (temporal.outcome === 'blocked') {
-            const expired = TriggerMatchRecordSchema.parse({
-                ...record,
-                status: 'expired',
-                updatedAt: nowIso,
-            });
-            await this.store.appendTriggerMatch(expired);
-            await this.support.cancelDeadlinesForMatch(expired.matchId);
-            await this.support.auditMatch(expired, 'trigger.expired', {
-                reason: 'temporal_condition_blocked',
-                temporal: temporal.conditionStates,
-            });
-            return {
-                triggerId: definition.triggerId,
-                match: expired,
-                matched: false,
-                fired: false,
-            };
+    async applyPatternWithPartition(definition, matchingClauses, event, key) {
+        const pattern = definition.pattern;
+        if (!pattern)
+            return [];
+        const now = this.now();
+        const nowIso = now.toISOString();
+        const bufferId = await this.patternBufferId(definition, key);
+        const existing = await this.latestMatch(bufferId);
+        let sourceEvents = existing?.sourceEvents
+            ? [...existing.sourceEvents]
+            : [];
+        for (const clause of matchingClauses) {
+            const duplicate = sourceEvents.some((source) => source.clauseId === clause.id &&
+                sameEventIdentity(source, event));
+            if (!duplicate) {
+                sourceEvents.push(asSourceEvent(clause.id, event));
+            }
         }
-        if (temporal.outcome === 'pending') {
-            await this.store.appendTriggerMatch(TriggerMatchRecordSchema.parse({
-                ...record,
-                status: 'partial',
-                updatedAt: nowIso,
-            }));
-            await this.support.scheduleDeadlines(definition, record, temporal.pendingDeadlines);
-            await this.support.auditMatch(record, 'trigger.partial', {
-                reason: 'temporal_wait',
-                temporal: temporal.conditionStates,
+        sourceEvents.sort(sourceEventOrder);
+        const previousMaxObserved = existing?.patternState
+            ?.maxObservedOccurredAt
+            ? Date.parse(existing.patternState.maxObservedOccurredAt)
+            : Number.NEGATIVE_INFINITY;
+        const maxObserved = Math.max(previousMaxObserved, Date.parse(event.occurredAt), ...sourceEvents
+            .map((source) => Date.parse(source.occurredAt))
+            .filter(Number.isFinite));
+        const allowedLatenessMs = definition.eventTime?.allowedLatenessMs ?? 0;
+        const watermarkMs = maxObserved - allowedLatenessMs;
+        const retentionFloor = watermarkMs - definition.withinMs;
+        sourceEvents = sourceEvents.filter((source) => Date.parse(source.occurredAt) >= retentionFloor);
+        const bufferedPhysicalEvents = new Set(sourceEvents.map(patternPhysicalIdentity)).size;
+        if (bufferedPhysicalEvents > pattern.execution.maxBufferedEvents) {
+            await this.store.appendAudit({
+                auditId: `audit_${(await sha256Hex(`${definition.triggerId}:${definition.version}:pattern_buffer_overflow:${key ?? '-'}:${nowIso}`)).slice(0, 24)}`,
+                traceId: event.traceId,
+                timestamp: nowIso,
+                kind: 'event.buffer_overflow',
+                entityType: 'trigger',
+                entityId: definition.triggerId,
+                details: {
+                    triggerVersion: definition.version,
+                    patternVersion: '2',
+                    partitionKey: key,
+                    bufferedEvents: bufferedPhysicalEvents,
+                    maxBufferedEvents: pattern.execution.maxBufferedEvents,
+                },
             });
-            return {
-                triggerId: definition.triggerId,
-                match: record,
-                matched: false,
-                fired: false,
-            };
+            const error = new Error(`Pattern v2 buffer exceeded maxBufferedEvents=${pattern.execution.maxBufferedEvents}`);
+            error.code =
+                'PATTERN_V2_BUFFER_LIMIT_EXCEEDED';
+            throw error;
         }
-        await this.support.cancelDeadlinesForMatch(record.matchId);
-        if (definition.correlation?.semantic) {
-            if (!this.evaluator) {
-                await this.store.appendTriggerMatch(record);
-                await this.support.auditMatch(record, 'trigger.partial', {
-                    reason: 'semantic_evaluator_unavailable',
-                });
-                return {
-                    triggerId: definition.triggerId,
-                    match: record,
-                    matched: false,
-                    fired: false,
-                };
-            }
-            const semantic = definition.correlation.semantic;
-            const decision = await new SemanticConditionEngine(this.evaluator).evaluate(semanticSource(record), {
-                type: 'semantic_boolean',
-                instruction: semantic.instruction,
-                input: semantic.input,
-                matchThreshold: semantic.matchThreshold,
-                rejectThreshold: semantic.rejectThreshold,
-                uncertain: semantic.uncertain,
-            });
-            record = TriggerMatchRecordSchema.parse({
-                ...record,
-                correlationDecision: {
-                    evaluator: decision.evaluator,
-                    outcome: decision.outcome,
-                    probability: decision.probability,
-                    matched: decision.matched,
-                    shouldEscalate: decision.shouldEscalate,
-                    inputFields: semantic.input,
-                    ...(decision.metadata ? { providerEvidence: decision.metadata } : {}),
-                    evaluatedAt: nowIso,
+        if (Date.parse(event.occurredAt) < retentionFloor &&
+            !existing?.sourceEvents.some((source) => sameEventIdentity(source, event))) {
+            await this.store.appendAudit({
+                auditId: `audit_${(await sha256Hex(`${definition.triggerId}:${definition.version}:pattern_late_event_dropped:${event.sourceEventId}:${nowIso}`)).slice(0, 24)}`,
+                traceId: event.traceId,
+                timestamp: nowIso,
+                kind: 'event.late_dropped',
+                entityType: 'trigger',
+                entityId: definition.triggerId,
+                details: {
+                    triggerVersion: definition.version,
+                    patternVersion: '2',
+                    sourceEventId: event.sourceEventId,
+                    occurredAt: event.occurredAt,
+                    watermarkAt: new Date(watermarkMs).toISOString(),
+                    retentionFloor: new Date(retentionFloor).toISOString(),
                 },
-                updatedAt: nowIso,
             });
-            await this.store.appendTriggerMatch(record);
-            await this.support.auditMatch(record, 'trigger.correlation', {
-                outcome: decision.outcome,
-                probability: decision.probability,
-                evaluator: decision.evaluator,
-            });
-            if (!decision.matched) {
-                return {
+            return [{
                     triggerId: definition.triggerId,
-                    match: record,
+                    match: existing ?? null,
                     matched: false,
                     fired: false,
-                };
-            }
+                }];
         }
-        const matched = TriggerMatchRecordSchema.parse({
-            ...record,
-            status: 'matched',
-            updatedAt: nowIso,
-        });
-        await this.store.appendTriggerMatch(matched);
-        await this.support.auditMatch(matched, 'trigger.matched', {
-            sourceEventIds: matched.sourceEvents.map((item) => item.sourceEventId),
-            temporal: temporal.conditionStates,
-        });
-        return {
-            triggerId: definition.triggerId,
-            match: matched,
-            matched: true,
-            fired: false,
-        };
-    }
-    async newMatch(definition, key, event) {
-        const openedAt = event.occurredAt;
-        const expiresAt = new Date(Date.parse(openedAt) + definition.withinMs).toISOString();
-        const matchId = `tm_${(await sha256Hex([
-            definition.triggerId,
-            definition.version,
-            key ?? '-',
-            event.sourceEventId,
-        ].join(':'))).slice(0, 24)}`;
-        return TriggerMatchRecordSchema.parse({
+        const openedAt = sourceEvents[0]?.occurredAt ?? event.occurredAt;
+        const buffer = TriggerMatchRecordSchema.parse({
             protocolVersion: COMPOSITE_TRIGGER_PROTOCOL_VERSION,
             schemaVersion: COMPOSITE_TRIGGER_SCHEMA_VERSION,
-            matchId,
+            matchId: bufferId,
             triggerId: definition.triggerId,
             triggerVersion: definition.version,
             status: 'partial',
-            correlationKey: key,
+            partitionKey: key,
             openedAt,
-            expiresAt,
-            updatedAt: this.now().toISOString(),
-            sourceEvents: [],
-            correlationDecision: null,
+            expiresAt: new Date(Date.parse(openedAt) + definition.withinMs).toISOString(),
+            updatedAt: nowIso,
+            sourceEvents,
+            semanticDecision: null,
+            patternState: {
+                version: '2',
+                role: 'buffer',
+                maxObservedOccurredAt: new Date(maxObserved).toISOString(),
+                semanticDecisions: [],
+            },
             firedWakeId: null,
             derivedEventIds: [],
         });
+        await this.store.appendTriggerMatch(buffer);
+        return this.evaluatePatternBuffer(definition, buffer, now);
+    }
+    candidateFitsTriggerWindow(candidate, withinMs) {
+        if (candidate.events.length < 2)
+            return true;
+        const times = candidate.events
+            .map((event) => Date.parse(event.occurredAt))
+            .filter(Number.isFinite);
+        if (times.length < 2)
+            return true;
+        return Math.max(...times) - Math.min(...times) <= withinMs;
+    }
+    async evaluatePatternBuffer(definition, buffer, evaluationNow) {
+        const pattern = definition.pattern;
+        if (!pattern)
+            return [];
+        const nowIso = evaluationNow.toISOString();
+        const semanticCache = typeof this.store.getSemanticDecisionCache === 'function' &&
+            typeof this.store.putSemanticDecisionCache === 'function'
+            ? {
+                get: (key) => this.store.getSemanticDecisionCache(key),
+                set: (key, decision) => this.store.putSemanticDecisionCache(key, decision),
+            }
+            : null;
+        const reachedDeadlines = this.store.listTemporalDeadlines
+            ? (await this.store.listTemporalDeadlines({
+                matchId: buffer.matchId,
+                status: 'pending',
+            }))
+                .filter((deadline) => Date.parse(deadline.dueAt) <= evaluationNow.getTime())
+            : [];
+        const evaluation = await evaluatePatternV2({
+            definition: pattern,
+            events: buffer.sourceEvents,
+            evaluator: this.evaluator,
+            now: evaluationNow,
+            allowedLatenessMs: definition.eventTime?.allowedLatenessMs ?? 0,
+            semanticCache,
+            semanticCacheNamespace: `${definition.triggerId}@${definition.version}`,
+        });
+        for (const semantic of evaluation.semanticTrace) {
+            await this.support.auditMatch(buffer, 'trigger.correlation', {
+                patternVersion: '2',
+                semanticNodeId: semantic.nodeId,
+                candidateSignature: semantic.candidateSignature,
+                evaluator: semantic.decision.evaluator,
+                outcome: semantic.decision.outcome,
+                probability: semantic.decision.probability,
+                matched: semantic.decision.matched,
+                shouldEscalate: semantic.decision.shouldEscalate,
+                semanticCacheHits: evaluation.semanticCacheHits,
+                semanticCacheMisses: evaluation.semanticCacheMisses,
+                inputFields: semantic.decision.condition.input,
+                ...(semantic.decision.metadata
+                    ? { providerEvidence: semantic.decision.metadata }
+                    : {}),
+            });
+        }
+        await this.support.cancelDeadlinesForMatch(buffer.matchId);
+        if (evaluation.pending.length) {
+            const deadlines = evaluation.pending
+                .filter((candidate) => candidate.pendingUntil &&
+                this.candidateFitsTriggerWindow(candidate, definition.withinMs))
+                .map((candidate) => ({
+                conditionId: `pattern-v2:${patternV2CandidateSignature(candidate)}`,
+                dueAt: candidate.pendingUntil,
+            }));
+            await this.support.scheduleDeadlines(definition, buffer, deadlines);
+        }
+        const previouslyEmitted = new Set((await this.store
+            .listTriggerMatches(definition.triggerId))
+            .filter((record) => record.triggerVersion === definition.version &&
+            record.patternState?.version === '2' &&
+            record.patternState.role === 'match' &&
+            record.patternState.signature)
+            .map((record) => record.patternState.signature));
+        const fresh = evaluation.matches
+            .filter((candidate) => this.candidateFitsTriggerWindow(candidate, definition.withinMs))
+            .map((candidate, rank) => ({ candidate, rank }))
+            .filter(({ candidate }) => candidate.events.length > 0 &&
+            !previouslyEmitted.has(patternV2CandidateSignature(candidate)))
+            .sort((left, right) => left.candidate.startIndex - right.candidate.startIndex ||
+            left.rank - right.rank)
+            .map(({ candidate }) => candidate);
+        const selected = [];
+        const occupied = new Set();
+        let selectionLimit = pattern.selection.maxMatchesPerEvent;
+        const hasEffect = Boolean(definition.target || definition.derivedEvent);
+        if (hasEffect) {
+            const triggerState = this.store.getTriggerState
+                ? await this.store.getTriggerState(definition.triggerId, definition.version)
+                : null;
+            const lifecycle = definition.lifecycle ?? {};
+            if (lifecycle.oneShot || lifecycle.completeOnGoal) {
+                selectionLimit = Math.min(selectionLimit, 1);
+            }
+            if (lifecycle.maxFirings !== undefined) {
+                selectionLimit = Math.min(selectionLimit, Math.max(0, lifecycle.maxFirings - (triggerState?.fireCount ?? 0)));
+            }
+            if ((lifecycle.cooldownMs ?? 0) > 0) {
+                selectionLimit = Math.min(selectionLimit, 1);
+            }
+        }
+        const indexed = [...buffer.sourceEvents].sort(sourceEventOrder);
+        const indexByIdentity = new Map(indexed.map((source, index) => [
+            patternPhysicalIdentity(source),
+            index,
+        ]));
+        let skipPastLastThrough = -1;
+        let skipBefore = -1;
+        const skipStarts = new Set();
+        const bindingBoundary = (candidate, ref, edge) => {
+            const events = [...(candidate.bindings[ref] ?? [])]
+                .sort(sourceEventOrder);
+            const event = edge === 'first' ? events[0] : events.at(-1);
+            if (!event)
+                return null;
+            return indexByIdentity.get(patternPhysicalIdentity(event)) ?? null;
+        };
+        for (const candidate of fresh) {
+            if (selected.length >= selectionLimit)
+                break;
+            if (candidate.startIndex <= skipPastLastThrough)
+                continue;
+            if (candidate.startIndex < skipBefore)
+                continue;
+            if (skipStarts.has(candidate.startIndex))
+                continue;
+            const identities = candidate.events.map(patternPhysicalIdentity);
+            if (pattern.selection.overlap === 'disallow' &&
+                identities.some((identity) => occupied.has(identity))) {
+                continue;
+            }
+            selected.push(candidate);
+            identities.forEach((identity) => occupied.add(identity));
+            const afterMatch = pattern.selection.afterMatch;
+            if (afterMatch === 'skipPastLast') {
+                skipPastLastThrough = Math.max(skipPastLastThrough, candidate.endIndex);
+            }
+            else if (afterMatch === 'skipToNext') {
+                skipStarts.add(candidate.startIndex);
+            }
+            else if (typeof afterMatch === 'object') {
+                const boundary = bindingBoundary(candidate, afterMatch.ref, afterMatch.kind === 'skipToFirst' ? 'first' : 'last');
+                if (boundary !== null) {
+                    skipBefore = Math.max(skipBefore, boundary);
+                }
+            }
+        }
+        const results = [];
+        for (const candidate of selected) {
+            const signature = patternV2CandidateSignature(candidate);
+            const matchId = `tm_${(await sha256Hex([
+                definition.triggerId,
+                definition.version,
+                buffer.partitionKey ?? '-',
+                signature,
+                'pattern-v2-match',
+            ].join(':'))).slice(0, 24)}`;
+            const openedAt = candidate.events[0]?.occurredAt ?? buffer.openedAt;
+            const semanticDecisions = candidate.semanticDecisions.map((item) => this.patternDecisionRecord(item, nowIso));
+            const sourceCompletionAt = candidate.events
+                .map((item) => Date.parse(item.occurredAt))
+                .filter(Number.isFinite)
+                .sort((a, b) => b - a)[0] ?? evaluationNow.getTime();
+            const deadlineCompletionAt = reachedDeadlines
+                .map((deadline) => Date.parse(deadline.dueAt))
+                .filter(Number.isFinite)
+                .sort((a, b) => b - a)[0];
+            const completedAt = new Date(deadlineCompletionAt ?? sourceCompletionAt).toISOString();
+            const lastSemantic = semanticDecisions.at(-1)?.decision ?? null;
+            const matched = TriggerMatchRecordSchema.parse({
+                protocolVersion: COMPOSITE_TRIGGER_PROTOCOL_VERSION,
+                schemaVersion: COMPOSITE_TRIGGER_SCHEMA_VERSION,
+                matchId,
+                triggerId: definition.triggerId,
+                triggerVersion: definition.version,
+                status: 'matched',
+                partitionKey: buffer.partitionKey,
+                openedAt,
+                expiresAt: new Date(Date.parse(openedAt) + definition.withinMs).toISOString(),
+                updatedAt: nowIso,
+                sourceEvents: candidate.events,
+                semanticDecision: lastSemantic,
+                patternState: {
+                    version: '2',
+                    role: 'match',
+                    signature,
+                    completedAt,
+                    semanticDecisions,
+                },
+                firedWakeId: null,
+                derivedEventIds: [],
+            });
+            await this.store.appendTriggerMatch(matched);
+            await this.support.auditMatch(matched, 'trigger.matched', {
+                patternVersion: '2',
+                signature,
+                semanticEvaluations: evaluation.semanticEvaluations,
+                truncated: evaluation.truncated,
+                sourceEventIds: matched.sourceEvents.map((source) => source.sourceEventId),
+            });
+            results.push({
+                triggerId: definition.triggerId,
+                match: matched,
+                matched: true,
+                fired: false,
+            });
+        }
+        if (selected.length) {
+            const selectedIndexes = selected.flatMap((candidate) => [
+                candidate.startIndex,
+                candidate.endIndex,
+            ]).filter((index) => index >= 0);
+            const firstStart = selectedIndexes.length
+                ? Math.min(...selected.map((candidate) => candidate.startIndex))
+                : -1;
+            const lastEnd = selectedIndexes.length
+                ? Math.max(...selected.map((candidate) => candidate.endIndex))
+                : -1;
+            let retained = [...buffer.sourceEvents];
+            const shouldDropByIndex = (index) => {
+                const afterMatch = pattern.selection.afterMatch;
+                if (afterMatch === 'skipPastLast') {
+                    return index <= lastEnd;
+                }
+                if (afterMatch === 'skipToNext') {
+                    return index <= firstStart;
+                }
+                if (typeof afterMatch === 'object') {
+                    const boundaries = selected
+                        .map((candidate) => bindingBoundary(candidate, afterMatch.ref, afterMatch.kind === 'skipToFirst' ? 'first' : 'last'))
+                        .filter((value) => value !== null);
+                    if (!boundaries.length)
+                        return false;
+                    return index < Math.max(...boundaries);
+                }
+                return false;
+            };
+            const consumed = pattern.selection.overlap === 'disallow'
+                ? new Set(selected
+                    .flatMap((candidate) => candidate.events)
+                    .map(patternPhysicalIdentity))
+                : new Set();
+            retained = indexed.filter((source, index) => !shouldDropByIndex(index) &&
+                !consumed.has(patternPhysicalIdentity(source)));
+            const openedAt = retained[0]?.occurredAt ?? evaluationNow.toISOString();
+            const updatedBuffer = TriggerMatchRecordSchema.parse({
+                ...buffer,
+                openedAt,
+                expiresAt: new Date(Date.parse(openedAt) + definition.withinMs).toISOString(),
+                updatedAt: nowIso,
+                sourceEvents: retained,
+            });
+            await this.store.appendTriggerMatch(updatedBuffer);
+        }
+        if (!results.length) {
+            await this.support.auditMatch(buffer, 'trigger.partial', {
+                reason: 'pattern_v2_wait',
+                patternVersion: '2',
+                pendingCandidates: evaluation.pending.length,
+                semanticEvaluations: evaluation.semanticEvaluations,
+                truncated: evaluation.truncated,
+            });
+            return [{
+                    triggerId: definition.triggerId,
+                    match: buffer,
+                    matched: false,
+                    fired: false,
+                }];
+        }
+        return results;
     }
-    latestMatch(matchId) {
-        return this.store
-            .listTriggerMatches()
+    async latestMatch(matchId) {
+        return (await this.store.listTriggerMatches())
             .filter((record) => record.matchId === matchId)
             .sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt))[0] ?? null;
     }