mcp-event-intelligence 0.4.0 → 0.6.0

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

@@ -1,8 +1,4 @@
-import type { CompositeTriggerDefinition, CorrelatableEvent, TriggerClause, TriggerMatchRecord, TriggerSourceEvent } from '../intelligenceProtocol/triggerSchemas.js';
+import type { CorrelatableEvent, TriggerClause, TriggerSourceEvent } from '../intelligenceProtocol/triggerSchemas.js';
 export declare function clauseMatches(clause: TriggerClause, event: CorrelatableEvent): boolean;
 export declare function asSourceEvent(clauseId: string, event: CorrelatableEvent): TriggerSourceEvent;
-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' | 'subscriptionArguments'>, event: Pick<CorrelatableEvent, 'sourceEventId' | 'serverId' | 'subscriptionArguments'>): boolean;
-export declare function matchesCorrelationKey(record: TriggerMatchRecord, key: string | null): boolean;

package/dist/src/composite/matching.js

@@ -26,13 +26,6 @@ function sameSubscriptionArguments(left, right) {
     return JSON.stringify(stableValue(left ?? {})) ===
         JSON.stringify(stableValue(right ?? {}));
 }
-function scalarKey(value) {
-    if (typeof value === 'string' ||
-        typeof value === 'number' ||
-        typeof value === 'boolean')
-        return String(value);
-    return null;
-}
 function predicateMatches(event, predicate) {
     const value = getByPath(event.data, predicate.path);
     switch (predicate.op) {
@@ -46,10 +39,54 @@ function predicateMatches(event, predicate) {
             if (Array.isArray(value))
                 return value.includes(predicate.value);
             return false;
+        case 'startsWith':
+            return typeof value === 'string' && value.startsWith(predicate.value);
+        case 'endsWith':
+            return typeof value === 'string' && value.endsWith(predicate.value);
+        case 'regex':
+            if (typeof value !== 'string')
+                return false;
+            try {
+                return new RegExp(predicate.value, predicate.flags ?? '').test(value);
+            }
+            catch {
+                return false;
+            }
         case 'in':
             return predicate.value.includes(value);
+        case 'notIn':
+            return !predicate.value.includes(value);
+        case 'between': {
+            const [lower, upper] = predicate.value;
+            if (typeof value === 'number') {
+                return (typeof lower === 'number' &&
+                    typeof upper === 'number' &&
+                    value >= lower &&
+                    value <= upper);
+            }
+            if (typeof value === 'string') {
+                return (typeof lower === 'string' &&
+                    typeof upper === 'string' &&
+                    value >= lower &&
+                    value <= upper);
+            }
+            return false;
+        }
         case 'exists':
             return predicate.value ? value !== undefined : value === undefined;
+        case 'isNull':
+            return predicate.value
+                ? value === null || value === undefined
+                : value !== null && value !== undefined;
+        case 'type':
+            if (predicate.value === 'null')
+                return value === null;
+            if (predicate.value === 'array')
+                return Array.isArray(value);
+            if (predicate.value === 'object') {
+                return value !== null && typeof value === 'object' && !Array.isArray(value);
+            }
+            return typeof value === predicate.value;
         case 'gt':
             return typeof value === 'number' && value > predicate.value;
         case 'gte':
@@ -76,6 +113,7 @@ export function asSourceEvent(clauseId, event) {
         sourceEventId: event.sourceEventId,
         eventName: event.name,
         occurredAt: event.occurredAt,
+        ...(event.receivedAt ? { receivedAt: event.receivedAt } : {}),
         ...(event.provider ? { provider: event.provider } : {}),
         ...(event.serverId ? { serverId: event.serverId } : {}),
         subscriptionArguments: event.subscriptionArguments ?? {},
@@ -83,55 +121,8 @@ export function asSourceEvent(clauseId, event) {
         data: event.data,
     };
 }
-function clauseEvents(record, ref) {
-    return record.sourceEvents
-        .filter((event) => event.clauseId === ref)
-        .sort((a, b) => Date.parse(a.occurredAt) - Date.parse(b.occurredAt));
-}
-export function expressionSatisfied(definition, record) {
-    const expression = definition.expression;
-    if (expression.kind === 'allOf') {
-        return expression.refs.every((ref) => clauseEvents(record, ref).length > 0);
-    }
-    if (expression.kind === 'anyOf') {
-        return expression.refs.some((ref) => clauseEvents(record, ref).length > 0);
-    }
-    if (expression.kind === 'count') {
-        return clauseEvents(record, expression.ref).length >= expression.atLeast;
-    }
-    let previous = Number.NEGATIVE_INFINITY;
-    for (const ref of expression.refs) {
-        const candidate = clauseEvents(record, ref)
-            .find((event) => Date.parse(event.occurredAt) > previous);
-        if (!candidate)
-            return false;
-        previous = Date.parse(candidate.occurredAt);
-    }
-    return true;
-}
-export function semanticSource(record) {
-    const source = {};
-    for (const event of record.sourceEvents) {
-        source[event.clauseId] = event.data;
-    }
-    return source;
-}
-export function deterministicKeyForClause(definition, clauseId, event) {
-    const deterministic = definition.correlation?.deterministic;
-    if (!deterministic)
-        return null;
-    const field = deterministic.fields.find((item) => item.ref === clauseId);
-    if (!field)
-        return null;
-    return scalarKey(getByPath(event.data, field.path));
-}
 export function sameEventIdentity(source, event) {
     return (source.sourceEventId === event.sourceEventId &&
         (source.serverId ?? null) === (event.serverId ?? null) &&
         sameSubscriptionArguments(source.subscriptionArguments, event.subscriptionArguments));
 }
-export function matchesCorrelationKey(record, key) {
-    if (record.correlationKey === null || key === null)
-        return true;
-    return record.correlationKey === key;
-}

package/dist/src/composite/runtimeSupport.js

@@ -17,7 +17,9 @@ export class CompositeTriggerRuntimeSupport {
                 deadline.conditionId,
                 deadline.dueAt,
             ].join(':'))).slice(0, 24)}`;
-            const existing = this.store.getTemporalDeadline?.(deadlineId);
+            const existing = this.store.getTemporalDeadline
+                ? await this.store.getTemporalDeadline(deadlineId)
+                : null;
             if (existing?.status === 'pending' || existing?.status === 'fired') {
                 continue;
             }
@@ -36,7 +38,7 @@ export class CompositeTriggerRuntimeSupport {
         if (!this.store.listTemporalDeadlines ||
             !this.store.setTemporalDeadlineStatus)
             return;
-        const pending = this.store.listTemporalDeadlines({
+        const pending = await this.store.listTemporalDeadlines({
             matchId,
             status: 'pending',
         });
@@ -45,9 +47,11 @@ export class CompositeTriggerRuntimeSupport {
         }
     }
     async advanceLifecycleAfterEffect(match, effectKind, effectId) {
-        const definition = this.store.listTriggers().find((candidate) => candidate.triggerId === match.triggerId &&
+        const definition = (await this.store.listTriggers()).find((candidate) => candidate.triggerId === match.triggerId &&
             candidate.version === match.triggerVersion);
-        const triggerState = this.store.getTriggerState?.(match.triggerId, match.triggerVersion) ?? null;
+        const triggerState = this.store.getTriggerState
+            ? await this.store.getTriggerState(match.triggerId, match.triggerVersion)
+            : null;
         if (!definition || !this.store.setTriggerState)
             return;
         const previousCount = triggerState?.fireCount ?? 0;
@@ -158,7 +162,7 @@ export class CompositeTriggerRuntimeSupport {
     }
     async auditMatch(record, kind, details = {}) {
         await this.store.appendAudit({
-            auditId: `audit_${(await sha256Hex(`${record.matchId}:${kind}:${record.updatedAt}:${this.store.listTriggerMatches().length}`)).slice(0, 24)}`,
+            auditId: `audit_${(await sha256Hex(`${record.matchId}:${kind}:${record.updatedAt}:${(await this.store.listTriggerMatches()).length}`)).slice(0, 24)}`,
             traceId: record.sourceEvents[0]?.traceId ?? record.matchId,
             timestamp: this.now().toISOString(),
             kind,
@@ -168,7 +172,7 @@ export class CompositeTriggerRuntimeSupport {
                 triggerId: record.triggerId,
                 triggerVersion: record.triggerVersion,
                 status: record.status,
-                correlationKey: record.correlationKey,
+                partitionKey: record.partitionKey,
                 ...details,
             },
         });

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

@@ -1,7 +1,25 @@
 import type { CompositeTriggerDefinition, TriggerMatchRecord } from '../intelligenceProtocol/triggerSchemas.js';
 export interface CompositeTriggerStore {
+    storeCapabilities?(): {
+        partitionLeases?: string;
+        [key: string]: unknown;
+    };
+    claimPartitionLease?(partitionKey: string, options: {
+        workerId: string;
+        now?: string;
+        leaseMs?: number;
+    }): Promise<unknown | null>;
+    renewPartitionLease?(partitionKey: string, options: {
+        workerId: string;
+        now?: string;
+        leaseMs?: number;
+    }): Promise<unknown | null>;
+    releasePartitionLease?(partitionKey: string, options: {
+        workerId: string;
+        now?: string;
+    }): Promise<boolean>;
     putTrigger(definition: CompositeTriggerDefinition): Promise<void>;
-    listTriggers(): CompositeTriggerDefinition[];
+    listTriggers(): CompositeTriggerDefinition[] | Promise<CompositeTriggerDefinition[]>;
     getTriggerState?(triggerId: string, version: string): {
         status: 'active' | 'paused' | 'completed' | 'expired' | 'deleted';
         owner?: unknown;
@@ -12,7 +30,7 @@ export interface CompositeTriggerStore {
     } | null;
     setTriggerState?(triggerId: string, version: string, status: 'active' | 'paused' | 'completed' | 'expired' | 'deleted', actor?: unknown, metadata?: Record<string, unknown>): Promise<unknown>;
     appendTriggerMatch(record: TriggerMatchRecord): Promise<void>;
-    listTriggerMatches(triggerId?: string): TriggerMatchRecord[];
+    listTriggerMatches(triggerId?: string): TriggerMatchRecord[] | Promise<TriggerMatchRecord[]>;
     getTemporalDeadline?(deadlineId: string): {
         deadlineId: string;
         triggerId: string;
@@ -21,7 +39,15 @@ export interface CompositeTriggerStore {
         conditionId: string;
         dueAt: string;
         status: 'pending' | 'cancelled' | 'fired';
-    } | null;
+    } | null | Promise<{
+        deadlineId: string;
+        triggerId: string;
+        triggerVersion: string;
+        matchId: string;
+        conditionId: string;
+        dueAt: string;
+        status: 'pending' | 'cancelled' | 'fired';
+    } | null>;
     listTemporalDeadlines?(filter?: {
         triggerId?: string;
         matchId?: string;
@@ -34,7 +60,15 @@ export interface CompositeTriggerStore {
         conditionId: string;
         dueAt: string;
         status: string;
-    }>;
+    }> | Promise<Array<{
+        deadlineId: string;
+        triggerId: string;
+        triggerVersion: string;
+        matchId: string;
+        conditionId: string;
+        dueAt: string;
+        status: string;
+    }>>;
     putTemporalDeadline?(input: {
         deadlineId: string;
         triggerId: string;

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

@@ -1,19 +1,3 @@
-import type { CompositeTriggerDefinition, TemporalCondition, TriggerMatchRecord } from '../intelligenceProtocol/triggerSchemas.js';
-export interface TemporalPendingDeadline {
-    conditionId: string;
-    dueAt: string;
-}
-export interface TemporalEvaluation {
-    outcome: 'satisfied' | 'pending' | 'blocked';
-    pendingDeadlines: TemporalPendingDeadline[];
-    conditionStates: Array<{
-        conditionId: string;
-        kind: TemporalCondition['kind'];
-        status: 'satisfied' | 'pending' | 'blocked';
-        dueAt?: string;
-        reason?: string;
-    }>;
-}
 export declare function zonedParts(timestamp: string | Date, timeZone: string): {
     year: number;
     month: number;
@@ -29,4 +13,3 @@ export declare function localDateTimeToUtc(date: {
     month: number;
     day: number;
 }, clock: string, timeZone: string): Date;
-export declare function evaluateTemporalConditions(definition: CompositeTriggerDefinition, record: TriggerMatchRecord, now: Date): TemporalEvaluation;

package/dist/src/composite/temporal.js

@@ -1,26 +1,3 @@
-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 eventsFor(record, ref) {
-    return record.sourceEvents
-        .filter((event) => event.clauseId === ref)
-        .sort((a, b) => Date.parse(a.occurredAt) - Date.parse(b.occurredAt));
-}
-function latestEvent(record, ref) {
-    return eventsFor(record, ref).at(-1) ?? null;
-}
-function parseClock(value) {
-    const [hour, minute] = value.split(':').map(Number);
-    return hour * 60 + minute;
-}
 const WEEKDAY_TO_ISO = {
     Mon: 1,
     Tue: 2,
@@ -72,246 +49,3 @@ export function localDateTimeToUtc(date, clock, timeZone) {
     }
     return new Date(guess);
 }
-function calendarMatches(condition, event) {
-    const parts = zonedParts(event.occurredAt, condition.timezone);
-    const minutes = parts.hour * 60 + parts.minute;
-    if (condition.weekdays && !condition.weekdays.includes(parts.weekday)) {
-        return false;
-    }
-    if (condition.dates && !condition.dates.includes(parts.date)) {
-        return false;
-    }
-    if (condition.dateRange &&
-        (parts.date < condition.dateRange.start ||
-            parts.date > condition.dateRange.end)) {
-        return false;
-    }
-    if (condition.dayOfMonth &&
-        !condition.dayOfMonth.includes(parts.day)) {
-        return false;
-    }
-    if (condition.before && condition.after) {
-        const before = parseClock(condition.before);
-        const after = parseClock(condition.after);
-        if (after <= before) {
-            if (minutes < after || minutes > before)
-                return false;
-        }
-        else {
-            if (!(minutes >= after || minutes <= before))
-                return false;
-        }
-    }
-    else {
-        if (condition.before && minutes > parseClock(condition.before)) {
-            return false;
-        }
-        if (condition.after && minutes < parseClock(condition.after)) {
-            return false;
-        }
-    }
-    return true;
-}
-function absenceDueAt(condition, anchor) {
-    const anchorMs = Date.parse(anchor.occurredAt);
-    if (condition.forMs) {
-        return new Date(anchorMs + condition.forMs);
-    }
-    const zone = condition.timezone;
-    const parts = zonedParts(anchor.occurredAt, zone);
-    const due = localDateTimeToUtc(parts, condition.untilLocalTime, zone);
-    return due.getTime() < anchorMs ? new Date(anchorMs) : due;
-}
-function state(condition, status, extra = {}) {
-    return {
-        conditionId: condition.id,
-        kind: condition.kind,
-        status,
-        ...extra,
-    };
-}
-export function evaluateTemporalConditions(definition, record, now) {
-    const states = [];
-    const pendingDeadlines = [];
-    for (const condition of definition.temporal ?? []) {
-        if (condition.kind === 'calendar') {
-            const event = latestEvent(record, condition.ref);
-            if (!event) {
-                states.push(state(condition, 'pending', {
-                    reason: 'referenced event has not occurred',
-                }));
-                continue;
-            }
-            states.push(calendarMatches(condition, event)
-                ? state(condition, 'satisfied')
-                : state(condition, 'blocked', {
-                    reason: 'event is outside the configured calendar window',
-                }));
-            continue;
-        }
-        if (condition.kind === 'not' || condition.kind === 'unless') {
-            const exists = eventsFor(record, condition.ref).length > 0;
-            states.push(exists
-                ? state(condition, 'blocked', {
-                    reason: `${condition.ref} occurred`,
-                })
-                : state(condition, 'satisfied'));
-            continue;
-        }
-        if (condition.kind === 'after') {
-            const event = latestEvent(record, condition.ref);
-            const anchor = latestEvent(record, condition.afterRef);
-            if (!event || !anchor) {
-                states.push(state(condition, 'pending', {
-                    reason: 'ordering events are incomplete',
-                }));
-            }
-            else if (Date.parse(event.occurredAt) > Date.parse(anchor.occurredAt)) {
-                states.push(state(condition, 'satisfied'));
-            }
-            else {
-                states.push(state(condition, 'blocked', {
-                    reason: `${condition.ref} did not occur after ${condition.afterRef}`,
-                }));
-            }
-            continue;
-        }
-        if (condition.kind === 'until') {
-            const event = latestEvent(record, condition.ref);
-            const boundary = latestEvent(record, condition.beforeRef);
-            if (!event || !boundary) {
-                states.push(state(condition, 'pending', {
-                    reason: 'ordering events are incomplete',
-                }));
-            }
-            else if (Date.parse(event.occurredAt) <= Date.parse(boundary.occurredAt)) {
-                states.push(state(condition, 'satisfied'));
-            }
-            else {
-                states.push(state(condition, 'blocked', {
-                    reason: `${condition.ref} occurred after ${condition.beforeRef}`,
-                }));
-            }
-            continue;
-        }
-        if (condition.kind === 'threshold') {
-            const count = eventsFor(record, condition.ref).length;
-            states.push(count >= condition.atLeast
-                ? state(condition, 'satisfied')
-                : state(condition, 'pending', {
-                    reason: `${count}/${condition.atLeast} occurrences`,
-                }));
-            continue;
-        }
-        if (condition.kind === 'distinct') {
-            const values = new Set(eventsFor(record, condition.ref)
-                .map((event) => getByPath(event.data, condition.path))
-                .filter((value) => typeof value === 'string' ||
-                typeof value === 'number' ||
-                typeof value === 'boolean')
-                .map(String));
-            states.push(values.size >= condition.atLeast
-                ? state(condition, 'satisfied')
-                : state(condition, 'pending', {
-                    reason: `${values.size}/${condition.atLeast} distinct values`,
-                }));
-            continue;
-        }
-        if (condition.kind === 'rate') {
-            const events = eventsFor(record, condition.ref);
-            if (!events.length) {
-                states.push(state(condition, 'pending', {
-                    reason: 'no events in rate window',
-                }));
-                continue;
-            }
-            const end = Math.max(now.getTime(), Date.parse(events.at(-1).occurredAt));
-            const count = events.filter((event) => end - Date.parse(event.occurredAt) <= condition.perMs).length;
-            states.push(count >= condition.atLeast
-                ? state(condition, 'satisfied')
-                : state(condition, 'pending', {
-                    reason: `${count}/${condition.atLeast} occurrences in rate window`,
-                }));
-            continue;
-        }
-        if (condition.kind === 'debounce') {
-            const event = latestEvent(record, condition.ref);
-            if (!event) {
-                states.push(state(condition, 'pending', {
-                    reason: 'debounced event has not occurred',
-                }));
-                continue;
-            }
-            const dueAt = new Date(Date.parse(event.occurredAt) + condition.forMs).toISOString();
-            if (now.getTime() >= Date.parse(dueAt)) {
-                states.push(state(condition, 'satisfied', { dueAt }));
-            }
-            else {
-                states.push(state(condition, 'pending', {
-                    dueAt,
-                    reason: 'waiting for quiet period',
-                }));
-                pendingDeadlines.push({
-                    conditionId: condition.id,
-                    dueAt,
-                });
-            }
-            continue;
-        }
-        if (condition.kind === 'absence') {
-            const anchor = latestEvent(record, condition.afterRef);
-            if (!anchor) {
-                states.push(state(condition, 'pending', {
-                    reason: `waiting for anchor ${condition.afterRef}`,
-                }));
-                continue;
-            }
-            const due = absenceDueAt(condition, anchor);
-            const dueAt = due.toISOString();
-            const anchorMs = Date.parse(anchor.occurredAt);
-            const disqualifying = eventsFor(record, condition.ref)
-                .some((event) => {
-                const at = Date.parse(event.occurredAt);
-                return at >= anchorMs && at <= due.getTime();
-            });
-            if (disqualifying) {
-                states.push(state(condition, 'blocked', {
-                    dueAt,
-                    reason: `${condition.ref} occurred before the absence deadline`,
-                }));
-            }
-            else if (now.getTime() >= due.getTime()) {
-                states.push(state(condition, 'satisfied', { dueAt }));
-            }
-            else {
-                states.push(state(condition, 'pending', {
-                    dueAt,
-                    reason: 'absence window is still open',
-                }));
-                pendingDeadlines.push({
-                    conditionId: condition.id,
-                    dueAt,
-                });
-            }
-        }
-    }
-    if (states.some((entry) => entry.status === 'blocked')) {
-        return {
-            outcome: 'blocked',
-            pendingDeadlines,
-            conditionStates: states,
-        };
-    }
-    if (states.some((entry) => entry.status === 'pending')) {
-        return {
-            outcome: 'pending',
-            pendingDeadlines,
-            conditionStates: states,
-        };
-    }
-    return {
-        outcome: 'satisfied',
-        pendingDeadlines,
-        conditionStates: states,
-    };
-}

package/dist/src/intelligenceProtocol/activationSchemas.d.ts

@@ -6,11 +6,12 @@ export declare const ActivationEvidenceSchema: z.ZodObject<{
     eventName: z.ZodString;
     traceId: z.ZodString;
     occurredAt: z.ZodString;
+    receivedAt: z.ZodOptional<z.ZodString>;
     payloadHash: z.ZodNullable<z.ZodString>;
     data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strict>;
 export declare const ActivationEnvelopeSchema: z.ZodObject<{
-    activationVersion: z.ZodLiteral<"1">;
+    activationVersion: z.ZodLiteral<"2">;
     wake: z.ZodObject<{
         wakeId: z.ZodString;
         status: z.ZodString;
@@ -26,7 +27,40 @@ export declare const ActivationEnvelopeSchema: z.ZodObject<{
         triggerId: z.ZodString;
         version: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
-        expression: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        pattern: z.ZodObject<{
+            version: z.ZodDefault<z.ZodLiteral<"2">>;
+            root: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+            partitionBy: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                fields: z.ZodArray<z.ZodObject<{
+                    ref: z.ZodString;
+                    path: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>;
+            selection: z.ZodDefault<z.ZodObject<{
+                overlap: z.ZodDefault<z.ZodEnum<{
+                    allow: "allow";
+                    disallow: "disallow";
+                }>>;
+                afterMatch: z.ZodDefault<z.ZodUnion<readonly [z.ZodEnum<{
+                    skipPastLast: "skipPastLast";
+                    skipToNext: "skipToNext";
+                    keepAll: "keepAll";
+                }>, z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        skipToFirst: "skipToFirst";
+                        skipToLast: "skipToLast";
+                    }>;
+                    ref: z.ZodString;
+                }, z.core.$strict>]>>;
+                maxMatchesPerEvent: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
+            execution: z.ZodDefault<z.ZodObject<{
+                maxCandidates: z.ZodDefault<z.ZodNumber>;
+                maxSemanticEvaluations: z.ZodDefault<z.ZodNumber>;
+                maxBufferedEvents: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
         lifecycle: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.core.$strict>;
     continuation: z.ZodNullable<z.ZodObject<{
@@ -43,7 +77,7 @@ export declare const ActivationEnvelopeSchema: z.ZodObject<{
     match: z.ZodObject<{
         matchId: z.ZodString;
         status: z.ZodString;
-        correlationKey: z.ZodNullable<z.ZodString>;
+        partitionKey: z.ZodNullable<z.ZodString>;
         openedAt: z.ZodString;
         updatedAt: z.ZodString;
     }, z.core.$strict>;
@@ -54,6 +88,7 @@ export declare const ActivationEnvelopeSchema: z.ZodObject<{
         eventName: z.ZodString;
         traceId: z.ZodString;
         occurredAt: z.ZodString;
+        receivedAt: z.ZodOptional<z.ZodString>;
         payloadHash: z.ZodNullable<z.ZodString>;
         data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>>;

package/dist/src/intelligenceProtocol/activationSchemas.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { ContinuationContractSchema } from './triggerSchemas.js';
+import { PatternAstV2DefinitionSchema } from './patternV2Schemas.js';
 const Id = z.string().min(1).max(200);
 const Timestamp = z.string().datetime({ offset: true });
 export const ActivationEvidenceSchema = z.object({
@@ -9,11 +10,12 @@ export const ActivationEvidenceSchema = z.object({
     eventName: z.string().min(1),
     traceId: Id,
     occurredAt: Timestamp,
+    receivedAt: Timestamp.optional(),
     payloadHash: z.string().regex(/^[a-f0-9]{64}$/).nullable(),
     data: z.record(z.string(), z.unknown()).optional(),
 }).strict();
 export const ActivationEnvelopeSchema = z.object({
-    activationVersion: z.literal('1'),
+    activationVersion: z.literal('2'),
     wake: z.object({
         wakeId: Id,
         status: z.string().min(1),
@@ -29,14 +31,14 @@ export const ActivationEnvelopeSchema = z.object({
         triggerId: Id,
         version: z.string().min(1),
         description: z.string().nullable(),
-        expression: z.record(z.string(), z.unknown()),
+        pattern: PatternAstV2DefinitionSchema,
         lifecycle: z.record(z.string(), z.unknown()),
     }).strict(),
     continuation: ContinuationContractSchema.nullable(),
     match: z.object({
         matchId: Id,
         status: z.string().min(1),
-        correlationKey: z.string().nullable(),
+        partitionKey: z.string().nullable(),
         openedAt: Timestamp,
         updatedAt: Timestamp,
     }).strict(),