mcp-event-intelligence 0.5.0 → 0.6.1

package/dist/src/composite/engine.js

@@ -1,24 +1,9 @@
-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 clauseAccumulatesOccurrences(definition, clauseId) {
-    if (definition.correlation?.semantic)
-        return true;
-    if (definition.expression.kind === 'count' &&
-        definition.expression.ref === clauseId) {
-        return true;
-    }
-    return definition.temporal.some((condition) => (condition.kind === 'threshold' ||
-        condition.kind === 'rate' ||
-        condition.kind === 'distinct' ||
-        condition.kind === 'debounce') &&
-        condition.ref === clauseId);
-}
 function getByPath(source, path) {
     let current = source;
     for (const part of path.split('.')) {
@@ -55,35 +40,32 @@ function patternPhysicalIdentity(event) {
         JSON.stringify(stablePatternValue(event.subscriptionArguments ?? {})),
     ].join(':');
 }
-function prospectiveEventWindow(record, event, withinMs) {
-    const eventTimes = [
-        ...record.sourceEvents.map((source) => Date.parse(source.occurredAt)),
-        Date.parse(event.occurredAt),
-    ];
-    const openedMs = Math.min(...eventTimes);
-    const latestMs = Math.max(...eventTimes);
-    const spanMs = latestMs - openedMs;
-    return {
-        openedAt: new Date(openedMs).toISOString(),
-        expiresAt: new Date(openedMs + withinMs).toISOString(),
-        spanMs,
-        fits: spanMs <= withinMs,
-    };
-}
 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;
     }
@@ -93,49 +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;
-            if (definition.patternV2) {
-                const replayed = 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,
-                        match: replayed,
-                        matched: replayed.status === 'matched' ||
-                            replayed.status === 'emitted' ||
-                            replayed.status === 'fired',
-                        fired: replayed.status === 'fired',
-                    });
-                    continue;
-                }
-                results.push(...await this.applyPatternV2(definition, matchingClauses, event));
-                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,
@@ -147,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')
@@ -174,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' &&
@@ -204,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' ||
@@ -223,34 +190,14 @@ export class CompositeTriggerEngine {
             match.status === 'expired') {
             return [];
         }
-        if (definition.patternV2 &&
-            match.patternState?.version === '2' &&
+        if (match.patternState?.version === '2' &&
             match.patternState.role === 'buffer') {
-            return this.evaluatePatternV2Buffer(definition, match, new Date(event.occurredAt));
-        }
-        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',
-            });
-            return [{
-                    triggerId: definition.triggerId,
-                    match: expired,
-                    matched: false,
-                    fired: false,
-                }];
+            return this.evaluatePatternBuffer(definition, match, new Date(event.occurredAt));
         }
-        const result = await this.finalizeEligible(definition, match, new Date(event.occurredAt));
-        return [result];
+        return [];
     }
     patternPartitionKey(definition, matchingClauses, event) {
-        const dimensions = definition.patternV2?.partitionBy ?? [];
+        const dimensions = definition.pattern?.partitionBy ?? [];
         if (!dimensions.length)
             return null;
         const clauseIds = new Set(matchingClauses.map((clause) => clause.id));
@@ -305,15 +252,55 @@ export class CompositeTriggerEngine {
             },
         };
     }
-    async applyPatternV2(definition, matchingClauses, event) {
-        const pattern = definition.patternV2;
+    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);
+        }
+        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 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);
+        }
+        finally {
+            await this.store.releasePartitionLease(leaseKey, {
+                workerId: this.workerId,
+                now: this.now().toISOString(),
+            });
+        }
+    }
+    async applyPatternWithPartition(definition, matchingClauses, event, key) {
+        const pattern = definition.pattern;
         if (!pattern)
             return [];
         const now = this.now();
         const nowIso = now.toISOString();
-        const key = this.patternPartitionKey(definition, matchingClauses, event);
         const bufferId = await this.patternBufferId(definition, key);
-        const existing = this.latestMatch(bufferId);
+        const existing = await this.latestMatch(bufferId);
         let sourceEvents = existing?.sourceEvents
             ? [...existing.sourceEvents]
             : [];
@@ -348,7 +335,7 @@ export class CompositeTriggerEngine {
                 details: {
                     triggerVersion: definition.version,
                     patternVersion: '2',
-                    correlationKey: key,
+                    partitionKey: key,
                     bufferedEvents: bufferedPhysicalEvents,
                     maxBufferedEvents: pattern.execution.maxBufferedEvents,
                 },
@@ -391,12 +378,12 @@ export class CompositeTriggerEngine {
             triggerId: definition.triggerId,
             triggerVersion: definition.version,
             status: 'partial',
-            correlationKey: key,
+            partitionKey: key,
             openedAt,
             expiresAt: new Date(Date.parse(openedAt) + definition.withinMs).toISOString(),
             updatedAt: nowIso,
             sourceEvents,
-            correlationDecision: null,
+            semanticDecision: null,
             patternState: {
                 version: '2',
                 role: 'buffer',
@@ -407,19 +394,45 @@ export class CompositeTriggerEngine {
             derivedEventIds: [],
         });
         await this.store.appendTriggerMatch(buffer);
-        return this.evaluatePatternV2Buffer(definition, buffer, now);
+        return this.evaluatePatternBuffer(definition, buffer, now);
     }
-    async evaluatePatternV2Buffer(definition, buffer, evaluationNow) {
-        const pattern = definition.patternV2;
+    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', {
@@ -431,6 +444,8 @@ export class CompositeTriggerEngine {
                 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 }
@@ -440,21 +455,23 @@ export class CompositeTriggerEngine {
         await this.support.cancelDeadlinesForMatch(buffer.matchId);
         if (evaluation.pending.length) {
             const deadlines = evaluation.pending
-                .filter((candidate) => candidate.pendingUntil)
+                .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(this.store
-            .listTriggerMatches(definition.triggerId)
+        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)))
@@ -466,7 +483,9 @@ export class CompositeTriggerEngine {
         let selectionLimit = pattern.selection.maxMatchesPerEvent;
         const hasEffect = Boolean(definition.target || definition.derivedEvent);
         if (hasEffect) {
-            const triggerState = this.store.getTriggerState?.(definition.triggerId, definition.version) ?? null;
+            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);
@@ -530,12 +549,23 @@ export class CompositeTriggerEngine {
             const matchId = `tm_${(await sha256Hex([
                 definition.triggerId,
                 definition.version,
-                buffer.correlationKey ?? '-',
+                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 deadlineConditionId = `pattern-v2:${signature}`;
+            const deadlineCompletionAt = reachedDeadlines
+                .filter((deadline) => deadline.conditionId === deadlineConditionId)
+                .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,
@@ -544,16 +574,17 @@ export class CompositeTriggerEngine {
                 triggerId: definition.triggerId,
                 triggerVersion: definition.version,
                 status: 'matched',
-                correlationKey: buffer.correlationKey,
+                partitionKey: buffer.partitionKey,
                 openedAt,
                 expiresAt: new Date(Date.parse(openedAt) + definition.withinMs).toISOString(),
                 updatedAt: nowIso,
                 sourceEvents: candidate.events,
-                correlationDecision: lastSemantic,
+                semanticDecision: lastSemantic,
                 patternState: {
                     version: '2',
                     role: 'match',
                     signature,
+                    completedAt,
                     semanticDecisions,
                 },
                 firedWakeId: null,
@@ -638,301 +669,8 @@ export class CompositeTriggerEngine {
         }
         return results;
     }
-    async applyEvent(definition, clause, event) {
-        const nowIso = this.now().toISOString();
-        const eventTime = Date.parse(event.occurredAt);
-        const key = deterministicKeyForClause(definition, clause.id, event);
-        const relatedMatches = this.store
-            .listTriggerMatches(definition.triggerId)
-            .filter((record) => record.triggerVersion === definition.version &&
-            matchesCorrelationKey(record, key));
-        const activeMatches = relatedMatches.filter((record) => record.status === 'partial' || record.status === 'matched');
-        const alreadyMatched = activeMatches
-            .filter((record) => record.status === 'matched')
-            .sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt))[0];
-        if (alreadyMatched) {
-            return {
-                triggerId: definition.triggerId,
-                match: alreadyMatched,
-                matched: true,
-                fired: false,
-            };
-        }
-        const partials = activeMatches.filter((record) => record.status === 'partial');
-        const observedEventTimes = relatedMatches.flatMap((record) => record.sourceEvents.map((source) => Date.parse(source.occurredAt)));
-        const maxObservedEventTime = Math.max(eventTime, ...observedEventTimes.filter(Number.isFinite));
-        const allowedLatenessMs = definition.eventTime?.allowedLatenessMs ?? 0;
-        const watermarkMs = maxObservedEventTime - allowedLatenessMs;
-        // The watermark is the point before which new standalone windows are too
-        // late to open. Existing partials are retained until their event-time
-        // expiry falls strictly behind it, allowing a late event to complete a
-        // still-valid in-window pattern.
-        const staleIds = new Set();
-        for (const candidate of partials) {
-            if (Date.parse(candidate.expiresAt) >= watermarkMs)
-                continue;
-            staleIds.add(candidate.matchId);
-            const expired = TriggerMatchRecordSchema.parse({
-                ...candidate,
-                status: 'expired',
-                updatedAt: nowIso,
-            });
-            await this.store.appendTriggerMatch(expired);
-            await this.support.cancelDeadlinesForMatch(expired.matchId);
-            await this.support.auditMatch(expired, 'trigger.expired', {
-                reason: 'event_time_watermark_advanced',
-                watermarkAt: new Date(watermarkMs).toISOString(),
-                allowedLatenessMs,
-                incomingSourceEventId: event.sourceEventId,
-                incomingOccurredAt: event.occurredAt,
-            });
-        }
-        const accumulatesOccurrences = clauseAccumulatesOccurrences(definition, clause.id);
-        const compatible = partials
-            .filter((record) => !staleIds.has(record.matchId))
-            .map((record) => ({
-            record,
-            window: prospectiveEventWindow(record, event, definition.withinMs),
-            hasClause: record.sourceEvents.some((source) => source.clauseId === clause.id),
-        }))
-            .filter(({ window }) => window.fits)
-            .sort((a, b) => (accumulatesOccurrences
-            ? 0
-            : Number(a.hasClause) - Number(b.hasClause)) ||
-            a.window.spanMs - b.window.spanMs ||
-            Date.parse(b.record.updatedAt) - Date.parse(a.record.updatedAt));
-        let record = compatible[0]?.record;
-        if (record &&
-            !accumulatesOccurrences &&
-            compatible[0]?.hasClause) {
-            // Repeated non-aggregating occurrences represent alternate paths through
-            // the same partial match. Branch the candidate so the new occurrence can
-            // advance the expression without destroying the pre-existing window.
-            record = await this.branchMatch(definition, record, event);
-        }
-        if (!record && eventTime < watermarkMs) {
-            await this.store.appendAudit({
-                auditId: `audit_${(await sha256Hex(`${definition.triggerId}:${definition.version}: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,
-                    sourceEventId: event.sourceEventId,
-                    occurredAt: event.occurredAt,
-                    receivedAt: event.receivedAt ?? null,
-                    watermarkAt: new Date(watermarkMs).toISOString(),
-                    allowedLatenessMs,
-                },
-            });
-            return {
-                triggerId: definition.triggerId,
-                match: null,
-                matched: false,
-                fired: false,
-            };
-        }
-        record ??= await this.newMatch(definition, key, event);
-        const duplicate = record.sourceEvents.some((candidate) => sameEventIdentity(candidate, event));
-        if (!duplicate) {
-            const window = prospectiveEventWindow(record, event, definition.withinMs);
-            if (!window.fits) {
-                // This can only happen for a newly-created incompatible candidate race.
-                // Keep the existing partial intact and seed a fresh event-time window.
-                record = await this.newMatch(definition, key, event);
-            }
-            const selectedWindow = prospectiveEventWindow(record, event, definition.withinMs);
-            record = TriggerMatchRecordSchema.parse({
-                ...record,
-                correlationKey: record.correlationKey ?? key,
-                openedAt: selectedWindow.openedAt,
-                expiresAt: selectedWindow.expiresAt,
-                updatedAt: nowIso,
-                sourceEvents: [
-                    ...record.sourceEvents,
-                    asSourceEvent(clause.id, event),
-                ],
-            });
-        }
-        if (!expressionSatisfied(definition, record)) {
-            await this.store.appendTriggerMatch(record);
-            await this.support.auditMatch(record, 'trigger.partial', {
-                clauseId: clause.id,
-                sourceEventId: event.sourceEventId,
-                occurredAt: event.occurredAt,
-                receivedAt: event.receivedAt ?? null,
-                eventTimeWindow: {
-                    openedAt: record.openedAt,
-                    expiresAt: record.expiresAt,
-                },
-            });
-            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,
-            };
-        }
-        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,
-            });
-            return {
-                triggerId: definition.triggerId,
-                match: record,
-                matched: false,
-                fired: false,
-            };
-        }
-        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,
-                },
-                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 {
-                    triggerId: definition.triggerId,
-                    match: record,
-                    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 branchMatch(definition, source, event) {
-        const matchId = `tm_${(await sha256Hex([
-            definition.triggerId,
-            definition.version,
-            source.matchId,
-            event.sourceEventId,
-            'branch',
-        ].join(':'))).slice(0, 24)}`;
-        return TriggerMatchRecordSchema.parse({
-            ...source,
-            matchId,
-            status: 'partial',
-            updatedAt: this.now().toISOString(),
-            correlationDecision: null,
-            firedWakeId: null,
-            derivedEventIds: [],
-        });
-    }
-    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({
-            protocolVersion: COMPOSITE_TRIGGER_PROTOCOL_VERSION,
-            schemaVersion: COMPOSITE_TRIGGER_SCHEMA_VERSION,
-            matchId,
-            triggerId: definition.triggerId,
-            triggerVersion: definition.version,
-            status: 'partial',
-            correlationKey: key,
-            openedAt,
-            expiresAt,
-            updatedAt: this.now().toISOString(),
-            sourceEvents: [],
-            correlationDecision: null,
-            firedWakeId: null,
-            derivedEventIds: [],
-        });
-    }
-    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;
     }