mcp-event-intelligence 0.4.0 → 0.5.0

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

@@ -13,14 +13,50 @@ export declare const StructuredPredicateSchema: z.ZodDiscriminatedUnion<[z.ZodOb
     path: z.ZodString;
     op: z.ZodLiteral<"contains">;
     value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+}, z.core.$strip>, z.ZodObject<{
+    path: z.ZodString;
+    op: z.ZodLiteral<"startsWith">;
+    value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    path: z.ZodString;
+    op: z.ZodLiteral<"endsWith">;
+    value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    path: z.ZodString;
+    op: z.ZodLiteral<"regex">;
+    value: z.ZodString;
+    flags: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     path: z.ZodString;
     op: z.ZodLiteral<"in">;
     value: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+}, z.core.$strip>, z.ZodObject<{
+    path: z.ZodString;
+    op: z.ZodLiteral<"notIn">;
+    value: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+}, z.core.$strip>, z.ZodObject<{
+    path: z.ZodString;
+    op: z.ZodLiteral<"between">;
+    value: z.ZodTuple<[z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>], null>;
 }, z.core.$strip>, z.ZodObject<{
     path: z.ZodString;
     op: z.ZodLiteral<"exists">;
     value: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    path: z.ZodString;
+    op: z.ZodLiteral<"isNull">;
+    value: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    path: z.ZodString;
+    op: z.ZodLiteral<"type">;
+    value: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        object: "object";
+        null: "null";
+        array: "array";
+    }>;
 }, z.core.$strip>, z.ZodObject<{
     path: z.ZodString;
     op: z.ZodLiteral<"gt">;
@@ -56,14 +92,50 @@ export declare const TriggerClauseSchema: z.ZodObject<{
         path: z.ZodString;
         op: z.ZodLiteral<"contains">;
         value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strip>, z.ZodObject<{
+        path: z.ZodString;
+        op: z.ZodLiteral<"startsWith">;
+        value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        path: z.ZodString;
+        op: z.ZodLiteral<"endsWith">;
+        value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        path: z.ZodString;
+        op: z.ZodLiteral<"regex">;
+        value: z.ZodString;
+        flags: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         path: z.ZodString;
         op: z.ZodLiteral<"in">;
         value: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strip>, z.ZodObject<{
+        path: z.ZodString;
+        op: z.ZodLiteral<"notIn">;
+        value: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strip>, z.ZodObject<{
+        path: z.ZodString;
+        op: z.ZodLiteral<"between">;
+        value: z.ZodTuple<[z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>], null>;
     }, z.core.$strip>, z.ZodObject<{
         path: z.ZodString;
         op: z.ZodLiteral<"exists">;
         value: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        path: z.ZodString;
+        op: z.ZodLiteral<"isNull">;
+        value: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        path: z.ZodString;
+        op: z.ZodLiteral<"type">;
+        value: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            null: "null";
+            array: "array";
+        }>;
     }, z.core.$strip>, z.ZodObject<{
         path: z.ZodString;
         op: z.ZodLiteral<"gt">;
@@ -183,6 +255,29 @@ export declare const DerivedEventDefinitionSchema: z.ZodObject<{
         path: z.ZodString;
     }, z.core.$strict>>>;
     constants: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    measures: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        expression: z.ZodUnion<readonly [z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, z.ZodObject<{
+            kind: z.ZodLiteral<"aggregate">;
+            function: z.ZodEnum<{
+                first: "first";
+                last: "last";
+                nth: "nth";
+                sum: "sum";
+                avg: "avg";
+                min: "min";
+                max: "max";
+                count: "count";
+                countDistinct: "countDistinct";
+                stddev: "stddev";
+                percentile: "percentile";
+            }>;
+            ref: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+            nth: z.ZodOptional<z.ZodNumber>;
+            percentile: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>>>;
 }, z.core.$strict>;
 export declare const DerivedEventEvidenceRefSchema: z.ZodObject<{
     serverId: z.ZodNullable<z.ZodString>;
@@ -190,10 +285,14 @@ export declare const DerivedEventEvidenceRefSchema: z.ZodObject<{
     sourceEventId: z.ZodString;
     traceId: z.ZodString;
     occurredAt: z.ZodString;
+    receivedAt: z.ZodOptional<z.ZodString>;
     payloadHash: z.ZodNullable<z.ZodString>;
     contractVersion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     schemaFingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strict>;
+export declare const EventTimePolicySchema: z.ZodObject<{
+    allowedLatenessMs: z.ZodNumber;
+}, z.core.$strict>;
 export declare const TriggerLifecyclePolicySchema: z.ZodObject<{
     oneShot: z.ZodDefault<z.ZodBoolean>;
     maxFirings: z.ZodOptional<z.ZodNumber>;
@@ -245,6 +344,7 @@ export declare const CompositeTriggerDefinitionSchema: z.ZodObject<{
     triggerId: z.ZodString;
     version: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
+    conditionOnly: z.ZodDefault<z.ZodBoolean>;
     continuation: z.ZodOptional<z.ZodObject<{
         instruction: z.ZodString;
         contextPolicy: z.ZodDefault<z.ZodObject<{
@@ -274,14 +374,50 @@ export declare const CompositeTriggerDefinitionSchema: z.ZodObject<{
             path: z.ZodString;
             op: z.ZodLiteral<"contains">;
             value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strip>, z.ZodObject<{
+            path: z.ZodString;
+            op: z.ZodLiteral<"startsWith">;
+            value: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            path: z.ZodString;
+            op: z.ZodLiteral<"endsWith">;
+            value: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            path: z.ZodString;
+            op: z.ZodLiteral<"regex">;
+            value: z.ZodString;
+            flags: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodObject<{
             path: z.ZodString;
             op: z.ZodLiteral<"in">;
             value: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        }, z.core.$strip>, z.ZodObject<{
+            path: z.ZodString;
+            op: z.ZodLiteral<"notIn">;
+            value: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        }, z.core.$strip>, z.ZodObject<{
+            path: z.ZodString;
+            op: z.ZodLiteral<"between">;
+            value: z.ZodTuple<[z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>], null>;
         }, z.core.$strip>, z.ZodObject<{
             path: z.ZodString;
             op: z.ZodLiteral<"exists">;
             value: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            path: z.ZodString;
+            op: z.ZodLiteral<"isNull">;
+            value: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            path: z.ZodString;
+            op: z.ZodLiteral<"type">;
+            value: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                null: "null";
+                array: "array";
+            }>;
         }, z.core.$strip>, z.ZodObject<{
             path: z.ZodString;
             op: z.ZodLiteral<"gt">;
@@ -377,6 +513,43 @@ export declare const CompositeTriggerDefinitionSchema: z.ZodObject<{
         path: z.ZodString;
         atLeast: z.ZodNumber;
     }, z.core.$strip>], "kind">>>;
+    patternV2: z.ZodOptional<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>>;
+    eventTime: z.ZodOptional<z.ZodObject<{
+        allowedLatenessMs: z.ZodNumber;
+    }, z.core.$strict>>;
     lifecycle: z.ZodDefault<z.ZodObject<{
         oneShot: z.ZodDefault<z.ZodBoolean>;
         maxFirings: z.ZodOptional<z.ZodNumber>;
@@ -426,6 +599,29 @@ export declare const CompositeTriggerDefinitionSchema: z.ZodObject<{
             path: z.ZodString;
         }, z.core.$strict>>>;
         constants: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        measures: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            expression: z.ZodUnion<readonly [z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, z.ZodObject<{
+                kind: z.ZodLiteral<"aggregate">;
+                function: z.ZodEnum<{
+                    first: "first";
+                    last: "last";
+                    nth: "nth";
+                    sum: "sum";
+                    avg: "avg";
+                    min: "min";
+                    max: "max";
+                    count: "count";
+                    countDistinct: "countDistinct";
+                    stddev: "stddev";
+                    percentile: "percentile";
+                }>;
+                ref: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+                nth: z.ZodOptional<z.ZodNumber>;
+                percentile: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>>>;
     }, z.core.$strict>>;
 }, z.core.$strip>;
 export declare const CorrelatableEventSchema: z.ZodObject<{
@@ -433,6 +629,7 @@ export declare const CorrelatableEventSchema: z.ZodObject<{
     sourceEventId: z.ZodString;
     name: z.ZodString;
     occurredAt: z.ZodString;
+    receivedAt: z.ZodOptional<z.ZodString>;
     provider: z.ZodOptional<z.ZodString>;
     serverId: z.ZodOptional<z.ZodString>;
     subscriptionArguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -445,6 +642,7 @@ export declare const DerivedEventRecordSchema: z.ZodObject<{
         sourceEventId: z.ZodString;
         name: z.ZodString;
         occurredAt: z.ZodString;
+        receivedAt: z.ZodOptional<z.ZodString>;
         provider: z.ZodOptional<z.ZodString>;
         serverId: z.ZodOptional<z.ZodString>;
         subscriptionArguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -460,6 +658,7 @@ export declare const DerivedEventRecordSchema: z.ZodObject<{
         sourceEventId: z.ZodString;
         traceId: z.ZodString;
         occurredAt: z.ZodString;
+        receivedAt: z.ZodOptional<z.ZodString>;
         payloadHash: z.ZodNullable<z.ZodString>;
         contractVersion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         schemaFingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -470,6 +669,7 @@ export declare const DerivedEventRecordSchema: z.ZodObject<{
         sourceEventId: z.ZodString;
         traceId: z.ZodString;
         occurredAt: z.ZodString;
+        receivedAt: z.ZodOptional<z.ZodString>;
         payloadHash: z.ZodNullable<z.ZodString>;
         contractVersion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         schemaFingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -482,6 +682,7 @@ export declare const TriggerSourceEventSchema: z.ZodObject<{
     sourceEventId: z.ZodString;
     eventName: z.ZodString;
     occurredAt: z.ZodString;
+    receivedAt: z.ZodOptional<z.ZodString>;
     provider: z.ZodOptional<z.ZodString>;
     serverId: z.ZodOptional<z.ZodString>;
     subscriptionArguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -509,6 +710,32 @@ export declare const TriggerMatchStatusSchema: z.ZodEnum<{
     fired: "fired";
     expired: "expired";
 }>;
+export declare const PatternMatchStateSchema: z.ZodObject<{
+    version: z.ZodLiteral<"2">;
+    role: z.ZodEnum<{
+        match: "match";
+        buffer: "buffer";
+    }>;
+    signature: z.ZodOptional<z.ZodString>;
+    maxObservedOccurredAt: z.ZodOptional<z.ZodString>;
+    semanticDecisions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        nodeId: z.ZodString;
+        decision: z.ZodObject<{
+            evaluator: z.ZodString;
+            outcome: z.ZodEnum<{
+                match: "match";
+                reject: "reject";
+                uncertain: "uncertain";
+            }>;
+            probability: z.ZodNumber;
+            matched: z.ZodBoolean;
+            shouldEscalate: z.ZodBoolean;
+            inputFields: z.ZodArray<z.ZodString>;
+            providerEvidence: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            evaluatedAt: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
 export declare const TriggerMatchRecordSchema: z.ZodObject<{
     protocolVersion: z.ZodLiteral<"0.1.0">;
     schemaVersion: z.ZodLiteral<"trigger.v0.1">;
@@ -532,6 +759,7 @@ export declare const TriggerMatchRecordSchema: z.ZodObject<{
         sourceEventId: z.ZodString;
         eventName: z.ZodString;
         occurredAt: z.ZodString;
+        receivedAt: z.ZodOptional<z.ZodString>;
         provider: z.ZodOptional<z.ZodString>;
         serverId: z.ZodOptional<z.ZodString>;
         subscriptionArguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -552,12 +780,39 @@ export declare const TriggerMatchRecordSchema: z.ZodObject<{
         providerEvidence: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         evaluatedAt: z.ZodString;
     }, z.core.$strip>>;
+    patternState: z.ZodOptional<z.ZodObject<{
+        version: z.ZodLiteral<"2">;
+        role: z.ZodEnum<{
+            match: "match";
+            buffer: "buffer";
+        }>;
+        signature: z.ZodOptional<z.ZodString>;
+        maxObservedOccurredAt: z.ZodOptional<z.ZodString>;
+        semanticDecisions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            nodeId: z.ZodString;
+            decision: z.ZodObject<{
+                evaluator: z.ZodString;
+                outcome: z.ZodEnum<{
+                    match: "match";
+                    reject: "reject";
+                    uncertain: "uncertain";
+                }>;
+                probability: z.ZodNumber;
+                matched: z.ZodBoolean;
+                shouldEscalate: z.ZodBoolean;
+                inputFields: z.ZodArray<z.ZodString>;
+                providerEvidence: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                evaluatedAt: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
     firedWakeId: z.ZodNullable<z.ZodString>;
     derivedEventIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type StructuredPredicate = z.infer<typeof StructuredPredicateSchema>;
 export type TriggerClause = z.infer<typeof TriggerClauseSchema>;
 export type TemporalCondition = z.infer<typeof TemporalConditionSchema>;
+export type EventTimePolicy = z.infer<typeof EventTimePolicySchema>;
 export type TriggerLifecyclePolicy = z.infer<typeof TriggerLifecyclePolicySchema>;
 export type ContinuationContextPolicy = z.infer<typeof ContinuationContextPolicySchema>;
 export type ContinuationContract = z.infer<typeof ContinuationContractSchema>;
@@ -566,6 +821,7 @@ export type DerivedEventRecord = z.infer<typeof DerivedEventRecordSchema>;
 export type CompositeTriggerDefinition = z.infer<typeof CompositeTriggerDefinitionSchema>;
 export type CorrelatableEvent = z.infer<typeof CorrelatableEventSchema>;
 export type TriggerSourceEvent = z.infer<typeof TriggerSourceEventSchema>;
+export type PatternMatchState = z.infer<typeof PatternMatchStateSchema>;
 export type TriggerMatchRecord = z.infer<typeof TriggerMatchRecordSchema>;
 export type CompositeCorrelationDecision = z.infer<typeof CompositeCorrelationDecisionSchema>;
 export declare function parseCompositeTriggerDefinition(value: unknown): CompositeTriggerDefinition;

package/dist/src/intelligenceProtocol/triggerSchemas.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { RuntimeTargetSchema } from './schemas.js';
+import { PatternAstV2DefinitionSchema, PatternMeasureSchema, collectPatternDurationsMs, collectGuaranteedPatternBindings, collectPatternMeasureRefs, collectPatternRefs, } from './patternV2Schemas.js';
 export const COMPOSITE_TRIGGER_PROTOCOL_VERSION = '0.1.0';
 export const COMPOSITE_TRIGGER_SCHEMA_VERSION = 'trigger.v0.1';
 const Id = z.string().min(1).max(200);
@@ -11,8 +12,28 @@ export const StructuredPredicateSchema = z.discriminatedUnion('op', [
     z.object({ path: z.string().min(1), op: z.literal('eq'), value: Scalar }),
     z.object({ path: z.string().min(1), op: z.literal('neq'), value: Scalar }),
     z.object({ path: z.string().min(1), op: z.literal('contains'), value: Scalar }),
+    z.object({ path: z.string().min(1), op: z.literal('startsWith'), value: z.string() }),
+    z.object({ path: z.string().min(1), op: z.literal('endsWith'), value: z.string() }),
+    z.object({
+        path: z.string().min(1),
+        op: z.literal('regex'),
+        value: z.string(),
+        flags: z.string().max(10).optional(),
+    }),
     z.object({ path: z.string().min(1), op: z.literal('in'), value: z.array(Scalar).min(1) }),
+    z.object({ path: z.string().min(1), op: z.literal('notIn'), value: z.array(Scalar).min(1) }),
+    z.object({
+        path: z.string().min(1),
+        op: z.literal('between'),
+        value: z.tuple([Scalar, Scalar]),
+    }),
     z.object({ path: z.string().min(1), op: z.literal('exists'), value: z.boolean().default(true) }),
+    z.object({ path: z.string().min(1), op: z.literal('isNull'), value: z.boolean().default(true) }),
+    z.object({
+        path: z.string().min(1),
+        op: z.literal('type'),
+        value: z.enum(['string', 'number', 'boolean', 'null', 'object', 'array']),
+    }),
     z.object({ path: z.string().min(1), op: z.literal('gt'), value: z.number() }),
     z.object({ path: z.string().min(1), op: z.literal('gte'), value: z.number() }),
     z.object({ path: z.string().min(1), op: z.literal('lt'), value: z.number() }),
@@ -113,6 +134,7 @@ export const DerivedEventDefinitionSchema = z.object({
     contractVersion: z.string().min(1).max(50),
     projections: z.array(DerivedEventProjectionSchema).max(32).default([]),
     constants: z.record(z.string(), Scalar).default({}),
+    measures: z.array(PatternMeasureSchema).max(32).default([]),
 }).strict();
 export const DerivedEventEvidenceRefSchema = z.object({
     serverId: Id.nullable(),
@@ -120,10 +142,15 @@ export const DerivedEventEvidenceRefSchema = z.object({
     sourceEventId: Id,
     traceId: Id,
     occurredAt: Timestamp,
+    receivedAt: Timestamp.optional(),
     payloadHash: z.string().regex(/^[a-f0-9]{64}$/).nullable(),
     contractVersion: z.string().min(1).nullable().optional(),
     schemaFingerprint: z.string().regex(/^[a-f0-9]{64}$/).nullable().optional(),
 }).strict();
+export const EventTimePolicySchema = z.object({
+    allowedLatenessMs: z.number().int().nonnegative()
+        .max(1000 * 60 * 60 * 24 * 30),
+}).strict();
 export const TriggerLifecyclePolicySchema = z.object({
     oneShot: z.boolean().default(false),
     maxFirings: z.number().int().min(1).optional(),
@@ -182,10 +209,13 @@ export const CompositeTriggerDefinitionSchema = z.object({
     triggerId: Id,
     version: z.string().min(1),
     description: z.string().max(500).optional(),
+    conditionOnly: z.boolean().default(false),
     continuation: ContinuationContractSchema.optional(),
     clauses: z.array(TriggerClauseSchema).min(1),
     expression: TriggerExpressionSchema,
     temporal: z.array(TemporalConditionSchema).default([]),
+    patternV2: PatternAstV2DefinitionSchema.optional(),
+    eventTime: EventTimePolicySchema.optional(),
     lifecycle: TriggerLifecyclePolicySchema.default({
         oneShot: false,
         cooldownMs: 0,
@@ -199,10 +229,27 @@ export const CompositeTriggerDefinitionSchema = z.object({
     target: RuntimeTargetSchema.optional(),
     derivedEvent: DerivedEventDefinitionSchema.optional(),
 }).superRefine((value, ctx) => {
-    if (!value.target && !value.derivedEvent) {
+    if (!value.target && !value.derivedEvent && !value.conditionOnly) {
         ctx.addIssue({
             code: 'custom',
-            message: 'Trigger requires target, derivedEvent, or both',
+            message: 'Trigger requires target, derivedEvent, or conditionOnly=true',
+        });
+    }
+    if (value.conditionOnly &&
+        (value.target || value.derivedEvent || value.continuation)) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'conditionOnly triggers cannot declare target, derivedEvent, or continuation',
+        });
+    }
+    if (value.conditionOnly &&
+        (value.lifecycle.oneShot ||
+            value.lifecycle.maxFirings !== undefined ||
+            value.lifecycle.cooldownMs > 0 ||
+            value.lifecycle.completeOnGoal)) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'conditionOnly triggers cannot use effect-based lifecycle fields',
         });
     }
     if (value.continuation && !value.target) {
@@ -236,6 +283,36 @@ export const CompositeTriggerDefinitionSchema = z.object({
     }
     if (value.derivedEvent) {
         const projectionKeys = new Set();
+        const measureKeys = new Set();
+        for (const measure of value.derivedEvent.measures ?? []) {
+            if (measure.key === '_derived') {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: 'Derived event measure key _derived is reserved',
+                });
+            }
+            if (measureKeys.has(measure.key)) {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: `Derived event measure key must be unique: ${measure.key}`,
+                });
+            }
+            if (Object.prototype.hasOwnProperty.call(value.derivedEvent.constants, measure.key)) {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: `Derived event key cannot be both constant and measure: ${measure.key}`,
+                });
+            }
+            for (const ref of collectPatternMeasureRefs(measure)) {
+                if (!ids.has(ref)) {
+                    ctx.addIssue({
+                        code: 'custom',
+                        message: `Derived event measure ${measure.key} references unknown clause: ${ref}`,
+                    });
+                }
+            }
+            measureKeys.add(measure.key);
+        }
         for (const projection of value.derivedEvent.projections) {
             if (!ids.has(projection.ref)) {
                 ctx.addIssue({
@@ -243,6 +320,12 @@ export const CompositeTriggerDefinitionSchema = z.object({
                     message: `Derived event projection references unknown clause: ${projection.ref}`,
                 });
             }
+            if (measureKeys.has(projection.key)) {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: `Derived event key cannot be both measure and projection: ${projection.key}`,
+                });
+            }
             if (projectionKeys.has(projection.key)) {
                 ctx.addIssue({
                     code: 'custom',
@@ -270,6 +353,69 @@ export const CompositeTriggerDefinitionSchema = z.object({
             });
         }
     }
+    if (value.patternV2) {
+        const patternRefs = collectPatternRefs(value.patternV2.root);
+        for (const ref of patternRefs) {
+            if (!ids.has(ref)) {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: `Pattern AST v2 references unknown clause: ${ref}`,
+                });
+            }
+        }
+        for (const dimension of value.patternV2.partitionBy) {
+            const dimensionRefs = new Set();
+            for (const field of dimension.fields) {
+                if (!ids.has(field.ref)) {
+                    ctx.addIssue({
+                        code: 'custom',
+                        message: `Pattern partition ${dimension.key} references unknown clause: ${field.ref}`,
+                    });
+                }
+                if (dimensionRefs.has(field.ref)) {
+                    ctx.addIssue({
+                        code: 'custom',
+                        message: `Pattern partition ${dimension.key} has duplicate field mapping for ${field.ref}`,
+                    });
+                }
+                dimensionRefs.add(field.ref);
+            }
+            for (const ref of patternRefs) {
+                if (!dimensionRefs.has(ref)) {
+                    ctx.addIssue({
+                        code: 'custom',
+                        message: `Pattern partition ${dimension.key} does not map pattern ref: ${ref}`,
+                    });
+                }
+            }
+        }
+        const guaranteedPatternRefs = collectGuaranteedPatternBindings(value.patternV2.root);
+        if (typeof value.patternV2.selection.afterMatch === 'object' &&
+            !guaranteedPatternRefs.includes(value.patternV2.selection.afterMatch.ref)) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `Pattern afterMatch ref is not guaranteed by every match: ${value.patternV2.selection.afterMatch.ref}`,
+            });
+        }
+        for (const measure of value.derivedEvent?.measures ?? []) {
+            for (const ref of collectPatternMeasureRefs(measure)) {
+                if (!guaranteedPatternRefs.includes(ref)) {
+                    ctx.addIssue({
+                        code: 'custom',
+                        message: `Derived measure ${measure.key} references non-guaranteed pattern ref: ${ref}`,
+                    });
+                }
+            }
+        }
+        const oversized = collectPatternDurationsMs(value.patternV2.root)
+            .filter((duration) => duration > value.withinMs);
+        if (oversized.length) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `Pattern AST v2 duration exceeds trigger withinMs: ${Math.max(...oversized)} > ${value.withinMs}`,
+            });
+        }
+    }
     const conditionIds = new Set();
     for (const condition of value.temporal) {
         if (conditionIds.has(condition.id)) {
@@ -332,6 +478,7 @@ export const CorrelatableEventSchema = z.object({
     sourceEventId: Id,
     name: z.string().min(1),
     occurredAt: Timestamp,
+    receivedAt: Timestamp.optional(),
     provider: z.string().min(1).optional(),
     serverId: Id.optional(),
     subscriptionArguments: z.record(z.string(), z.unknown()).default({}),
@@ -353,6 +500,7 @@ export const TriggerSourceEventSchema = z.object({
     sourceEventId: Id,
     eventName: z.string().min(1),
     occurredAt: Timestamp,
+    receivedAt: Timestamp.optional(),
     provider: z.string().min(1).optional(),
     serverId: Id.optional(),
     subscriptionArguments: z.record(z.string(), z.unknown()).default({}),
@@ -376,6 +524,16 @@ export const TriggerMatchStatusSchema = z.enum([
     'fired',
     'expired',
 ]);
+export const PatternMatchStateSchema = z.object({
+    version: z.literal('2'),
+    role: z.enum(['buffer', 'match']),
+    signature: z.string().min(1).optional(),
+    maxObservedOccurredAt: Timestamp.optional(),
+    semanticDecisions: z.array(z.object({
+        nodeId: Id,
+        decision: CompositeCorrelationDecisionSchema,
+    }).strict()).default([]),
+}).strict();
 export const TriggerMatchRecordSchema = z.object({
     protocolVersion: z.literal(COMPOSITE_TRIGGER_PROTOCOL_VERSION),
     schemaVersion: z.literal(COMPOSITE_TRIGGER_SCHEMA_VERSION),
@@ -389,6 +547,7 @@ export const TriggerMatchRecordSchema = z.object({
     updatedAt: Timestamp,
     sourceEvents: z.array(TriggerSourceEventSchema),
     correlationDecision: CompositeCorrelationDecisionSchema.nullable(),
+    patternState: PatternMatchStateSchema.optional(),
     firedWakeId: Id.nullable(),
     derivedEventIds: z.array(Id).default([]),
 });

package/dist/src/mcpEvents/consumer.d.ts

@@ -5,4 +5,5 @@ export declare function mcpOccurrenceToCorrelatableEvent(event: EventOccurrence,
     provider?: string;
     serverId?: string;
     subscriptionArguments?: Record<string, unknown>;
+    receivedAt?: string;
 }): Promise<CorrelatableEvent>;

package/dist/src/mcpEvents/consumer.js

@@ -6,6 +6,7 @@ export async function mcpOccurrenceToCorrelatableEvent(event, input) {
         sourceEventId: event.eventId,
         name: event.name,
         occurredAt: event.timestamp,
+        ...(input.receivedAt ? { receivedAt: input.receivedAt } : {}),
         ...(input.provider ? { provider: input.provider } : {}),
         ...(input.serverId ? { serverId: input.serverId } : {}),
         subscriptionArguments: input.subscriptionArguments ?? {},