mcp-event-intelligence 0.3.1 → 0.5.0

package/dist/src/composite/engine.js

@@ -1,10 +1,75 @@
 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 { 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('.')) {
+        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(':');
+}
+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;
@@ -36,6 +101,38 @@ export class CompositeTriggerEngine {
             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)));
@@ -126,6 +223,11 @@ export class CompositeTriggerEngine {
             match.status === 'expired') {
             return [];
         }
+        if (definition.patternV2 &&
+            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,
@@ -147,43 +249,506 @@ export class CompositeTriggerEngine {
         const result = await this.finalizeEligible(definition, match, new Date(event.occurredAt));
         return [result];
     }
+    patternPartitionKey(definition, matchingClauses, event) {
+        const dimensions = definition.patternV2?.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 JSON.stringify(components);
+    }
+    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 applyPatternV2(definition, matchingClauses, event) {
+        const pattern = definition.patternV2;
+        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);
+        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));
+            }
+        }
+        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',
+                    correlationKey: key,
+                    bufferedEvents: bufferedPhysicalEvents,
+                    maxBufferedEvents: pattern.execution.maxBufferedEvents,
+                },
+            });
+            const error = new Error(`Pattern v2 buffer exceeded maxBufferedEvents=${pattern.execution.maxBufferedEvents}`);
+            error.code =
+                'PATTERN_V2_BUFFER_LIMIT_EXCEEDED';
+            throw error;
+        }
+        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(),
+                },
+            });
+            return [{
+                    triggerId: definition.triggerId,
+                    match: existing ?? null,
+                    matched: false,
+                    fired: false,
+                }];
+        }
+        const openedAt = sourceEvents[0]?.occurredAt ?? event.occurredAt;
+        const buffer = TriggerMatchRecordSchema.parse({
+            protocolVersion: COMPOSITE_TRIGGER_PROTOCOL_VERSION,
+            schemaVersion: COMPOSITE_TRIGGER_SCHEMA_VERSION,
+            matchId: bufferId,
+            triggerId: definition.triggerId,
+            triggerVersion: definition.version,
+            status: 'partial',
+            correlationKey: key,
+            openedAt,
+            expiresAt: new Date(Date.parse(openedAt) + definition.withinMs).toISOString(),
+            updatedAt: nowIso,
+            sourceEvents,
+            correlationDecision: null,
+            patternState: {
+                version: '2',
+                role: 'buffer',
+                maxObservedOccurredAt: new Date(maxObserved).toISOString(),
+                semanticDecisions: [],
+            },
+            firedWakeId: null,
+            derivedEventIds: [],
+        });
+        await this.store.appendTriggerMatch(buffer);
+        return this.evaluatePatternV2Buffer(definition, buffer, now);
+    }
+    async evaluatePatternV2Buffer(definition, buffer, evaluationNow) {
+        const pattern = definition.patternV2;
+        if (!pattern)
+            return [];
+        const nowIso = evaluationNow.toISOString();
+        const evaluation = await evaluatePatternV2({
+            definition: pattern,
+            events: buffer.sourceEvents,
+            evaluator: this.evaluator,
+            now: evaluationNow,
+            allowedLatenessMs: definition.eventTime?.allowedLatenessMs ?? 0,
+        });
+        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,
+                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)
+                .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)
+            .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
+            .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?.(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.correlationKey ?? '-',
+                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 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',
+                correlationKey: buffer.correlationKey,
+                openedAt,
+                expiresAt: new Date(Date.parse(openedAt) + definition.withinMs).toISOString(),
+                updatedAt: nowIso,
+                sourceEvents: candidate.events,
+                correlationDecision: lastSemantic,
+                patternState: {
+                    version: '2',
+                    role: 'match',
+                    signature,
+                    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;
+    }
     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
+        const relatedMatches = this.store
             .listTriggerMatches(definition.triggerId)
             .filter((record) => record.triggerVersion === definition.version &&
-            (record.status === 'partial' || record.status === 'matched') &&
-            matchesCorrelationKey(record, key))
+            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 (existing?.status === 'matched') {
+        if (alreadyMatched) {
             return {
                 triggerId: definition.triggerId,
-                match: existing,
+                match: alreadyMatched,
                 matched: true,
                 fired: false,
             };
         }
-        let record = existing ?? await this.newMatch(definition, key, event);
-        if (Date.parse(record.expiresAt) < eventTime) {
+        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({
-                ...record,
+                ...candidate,
                 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',
+                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,
+                },
             });
-            record = await this.newMatch(definition, key, event);
+            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,
@@ -196,6 +761,12 @@ export class CompositeTriggerEngine {
             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,
@@ -315,6 +886,24 @@ export class CompositeTriggerEngine {
             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();

package/dist/src/composite/matching.d.ts

@@ -4,5 +4,5 @@ export declare function asSourceEvent(clauseId: string, event: CorrelatableEvent
 export declare function expressionSatisfied(definition: CompositeTriggerDefinition, record: TriggerMatchRecord): boolean;
 export declare function semanticSource(record: TriggerMatchRecord): Record<string, unknown>;
 export declare function deterministicKeyForClause(definition: CompositeTriggerDefinition, clauseId: string, event: CorrelatableEvent): string | null;
-export declare function sameEventIdentity(source: Pick<TriggerSourceEvent, 'sourceEventId' | 'serverId'>, event: Pick<CorrelatableEvent, 'sourceEventId' | 'serverId'>): boolean;
+export declare function sameEventIdentity(source: Pick<TriggerSourceEvent, 'sourceEventId' | 'serverId' | 'subscriptionArguments'>, event: Pick<CorrelatableEvent, 'sourceEventId' | 'serverId' | 'subscriptionArguments'>): boolean;
 export declare function matchesCorrelationKey(record: TriggerMatchRecord, key: string | null): boolean;