mcp-event-intelligence 0.5.0 → 0.6.0

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

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-export declare const COMPOSITE_TRIGGER_PROTOCOL_VERSION: "0.1.0";
-export declare const COMPOSITE_TRIGGER_SCHEMA_VERSION: "trigger.v0.1";
+export declare const COMPOSITE_TRIGGER_PROTOCOL_VERSION: "0.2.0";
+export declare const COMPOSITE_TRIGGER_SCHEMA_VERSION: "trigger.v0.2";
 export declare const StructuredPredicateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     path: z.ZodString;
     op: z.ZodLiteral<"eq">;
@@ -154,93 +154,6 @@ export declare const TriggerClauseSchema: z.ZodObject<{
         value: z.ZodNumber;
     }, z.core.$strip>], "op">>>;
 }, z.core.$strip>;
-export declare const CalendarTemporalConditionSchema: z.ZodObject<{
-    id: z.ZodString;
-    kind: z.ZodLiteral<"calendar">;
-    ref: z.ZodString;
-    timezone: z.ZodString;
-    before: z.ZodOptional<z.ZodString>;
-    after: z.ZodOptional<z.ZodString>;
-    weekdays: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-    dates: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    dateRange: z.ZodOptional<z.ZodObject<{
-        start: z.ZodString;
-        end: z.ZodString;
-    }, z.core.$strip>>;
-    dayOfMonth: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-}, z.core.$strict>;
-export declare const AbsenceTemporalConditionSchema: z.ZodObject<{
-    id: z.ZodString;
-    kind: z.ZodLiteral<"absence">;
-    ref: z.ZodString;
-    afterRef: z.ZodString;
-    forMs: z.ZodOptional<z.ZodNumber>;
-    untilLocalTime: z.ZodOptional<z.ZodString>;
-    timezone: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const TemporalConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    id: z.ZodString;
-    kind: z.ZodLiteral<"calendar">;
-    ref: z.ZodString;
-    timezone: z.ZodString;
-    before: z.ZodOptional<z.ZodString>;
-    after: z.ZodOptional<z.ZodString>;
-    weekdays: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-    dates: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    dateRange: z.ZodOptional<z.ZodObject<{
-        start: z.ZodString;
-        end: z.ZodString;
-    }, z.core.$strip>>;
-    dayOfMonth: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-}, z.core.$strict>, z.ZodObject<{
-    id: z.ZodString;
-    kind: z.ZodLiteral<"absence">;
-    ref: z.ZodString;
-    afterRef: z.ZodString;
-    forMs: z.ZodOptional<z.ZodNumber>;
-    untilLocalTime: z.ZodOptional<z.ZodString>;
-    timezone: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    id: z.ZodString;
-    kind: z.ZodLiteral<"not">;
-    ref: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    id: z.ZodString;
-    kind: z.ZodLiteral<"unless">;
-    ref: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    id: z.ZodString;
-    kind: z.ZodLiteral<"after">;
-    ref: z.ZodString;
-    afterRef: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    id: z.ZodString;
-    kind: z.ZodLiteral<"until">;
-    ref: z.ZodString;
-    beforeRef: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    id: z.ZodString;
-    kind: z.ZodLiteral<"debounce">;
-    ref: z.ZodString;
-    forMs: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    id: z.ZodString;
-    kind: z.ZodLiteral<"threshold">;
-    ref: z.ZodString;
-    atLeast: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    id: z.ZodString;
-    kind: z.ZodLiteral<"rate">;
-    ref: z.ZodString;
-    atLeast: z.ZodNumber;
-    perMs: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    id: z.ZodString;
-    kind: z.ZodLiteral<"distinct">;
-    ref: z.ZodString;
-    path: z.ZodString;
-    atLeast: z.ZodNumber;
-}, z.core.$strip>], "kind">;
 export declare const DerivedEventProjectionSchema: z.ZodObject<{
     key: z.ZodString;
     ref: z.ZodString;
@@ -320,27 +233,9 @@ export declare const ContinuationContractSchema: z.ZodObject<{
         includeData: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-export declare const DeterministicCorrelationSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"same_value">;
-    fields: z.ZodArray<z.ZodObject<{
-        ref: z.ZodString;
-        path: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const SemanticCorrelationSchema: z.ZodObject<{
-    instruction: z.ZodString;
-    input: z.ZodArray<z.ZodString>;
-    matchThreshold: z.ZodNumber;
-    rejectThreshold: z.ZodNumber;
-    uncertain: z.ZodDefault<z.ZodEnum<{
-        match: "match";
-        reject: "reject";
-        escalate: "escalate";
-    }>>;
-}, z.core.$strip>;
 export declare const CompositeTriggerDefinitionSchema: z.ZodObject<{
-    protocolVersion: z.ZodDefault<z.ZodLiteral<"0.1.0">>;
-    schemaVersion: z.ZodDefault<z.ZodLiteral<"trigger.v0.1">>;
+    protocolVersion: z.ZodDefault<z.ZodLiteral<"0.2.0">>;
+    schemaVersion: z.ZodDefault<z.ZodLiteral<"trigger.v0.2">>;
     triggerId: z.ZodString;
     version: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
@@ -436,84 +331,7 @@ export declare const CompositeTriggerDefinitionSchema: z.ZodObject<{
             value: z.ZodNumber;
         }, z.core.$strip>], "op">>>;
     }, z.core.$strip>>;
-    expression: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"allOf">;
-        refs: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"anyOf">;
-        refs: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"sequence">;
-        refs: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"count">;
-        ref: z.ZodString;
-        atLeast: z.ZodNumber;
-    }, z.core.$strip>], "kind">;
-    temporal: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        id: z.ZodString;
-        kind: z.ZodLiteral<"calendar">;
-        ref: z.ZodString;
-        timezone: z.ZodString;
-        before: z.ZodOptional<z.ZodString>;
-        after: z.ZodOptional<z.ZodString>;
-        weekdays: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-        dates: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        dateRange: z.ZodOptional<z.ZodObject<{
-            start: z.ZodString;
-            end: z.ZodString;
-        }, z.core.$strip>>;
-        dayOfMonth: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-    }, z.core.$strict>, z.ZodObject<{
-        id: z.ZodString;
-        kind: z.ZodLiteral<"absence">;
-        ref: z.ZodString;
-        afterRef: z.ZodString;
-        forMs: z.ZodOptional<z.ZodNumber>;
-        untilLocalTime: z.ZodOptional<z.ZodString>;
-        timezone: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        id: z.ZodString;
-        kind: z.ZodLiteral<"not">;
-        ref: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        id: z.ZodString;
-        kind: z.ZodLiteral<"unless">;
-        ref: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        id: z.ZodString;
-        kind: z.ZodLiteral<"after">;
-        ref: z.ZodString;
-        afterRef: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        id: z.ZodString;
-        kind: z.ZodLiteral<"until">;
-        ref: z.ZodString;
-        beforeRef: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        id: z.ZodString;
-        kind: z.ZodLiteral<"debounce">;
-        ref: z.ZodString;
-        forMs: z.ZodNumber;
-    }, z.core.$strip>, z.ZodObject<{
-        id: z.ZodString;
-        kind: z.ZodLiteral<"threshold">;
-        ref: z.ZodString;
-        atLeast: z.ZodNumber;
-    }, z.core.$strip>, z.ZodObject<{
-        id: z.ZodString;
-        kind: z.ZodLiteral<"rate">;
-        ref: z.ZodString;
-        atLeast: z.ZodNumber;
-        perMs: z.ZodNumber;
-    }, z.core.$strip>, z.ZodObject<{
-        id: z.ZodString;
-        kind: z.ZodLiteral<"distinct">;
-        ref: z.ZodString;
-        path: z.ZodString;
-        atLeast: z.ZodNumber;
-    }, z.core.$strip>], "kind">>>;
-    patternV2: z.ZodOptional<z.ZodObject<{
+    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<{
@@ -546,7 +364,7 @@ export declare const CompositeTriggerDefinitionSchema: z.ZodObject<{
             maxSemanticEvaluations: z.ZodDefault<z.ZodNumber>;
             maxBufferedEvents: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strict>>;
-    }, z.core.$strict>>;
+    }, z.core.$strict>;
     eventTime: z.ZodOptional<z.ZodObject<{
         allowedLatenessMs: z.ZodNumber;
     }, z.core.$strict>>;
@@ -559,26 +377,6 @@ export declare const CompositeTriggerDefinitionSchema: z.ZodObject<{
         completeOnGoal: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
     withinMs: z.ZodNumber;
-    correlation: z.ZodOptional<z.ZodObject<{
-        deterministic: z.ZodOptional<z.ZodObject<{
-            kind: z.ZodLiteral<"same_value">;
-            fields: z.ZodArray<z.ZodObject<{
-                ref: z.ZodString;
-                path: z.ZodString;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
-        semantic: z.ZodOptional<z.ZodObject<{
-            instruction: z.ZodString;
-            input: z.ZodArray<z.ZodString>;
-            matchThreshold: z.ZodNumber;
-            rejectThreshold: z.ZodNumber;
-            uncertain: z.ZodDefault<z.ZodEnum<{
-                match: "match";
-                reject: "reject";
-                escalate: "escalate";
-            }>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
     target: z.ZodOptional<z.ZodObject<{
         runtime: z.ZodString;
         kind: z.ZodEnum<{
@@ -689,7 +487,7 @@ export declare const TriggerSourceEventSchema: z.ZodObject<{
     payloadHash: z.ZodOptional<z.ZodString>;
     data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$strip>;
-export declare const CompositeCorrelationDecisionSchema: z.ZodObject<{
+export declare const PatternSemanticDecisionSchema: z.ZodObject<{
     evaluator: z.ZodString;
     outcome: z.ZodEnum<{
         match: "match";
@@ -718,6 +516,7 @@ export declare const PatternMatchStateSchema: z.ZodObject<{
     }>;
     signature: z.ZodOptional<z.ZodString>;
     maxObservedOccurredAt: z.ZodOptional<z.ZodString>;
+    completedAt: z.ZodOptional<z.ZodString>;
     semanticDecisions: z.ZodDefault<z.ZodArray<z.ZodObject<{
         nodeId: z.ZodString;
         decision: z.ZodObject<{
@@ -737,8 +536,8 @@ export declare const PatternMatchStateSchema: z.ZodObject<{
     }, z.core.$strict>>>;
 }, z.core.$strict>;
 export declare const TriggerMatchRecordSchema: z.ZodObject<{
-    protocolVersion: z.ZodLiteral<"0.1.0">;
-    schemaVersion: z.ZodLiteral<"trigger.v0.1">;
+    protocolVersion: z.ZodLiteral<"0.2.0">;
+    schemaVersion: z.ZodLiteral<"trigger.v0.2">;
     matchId: z.ZodString;
     triggerId: z.ZodString;
     triggerVersion: z.ZodString;
@@ -749,7 +548,7 @@ export declare const TriggerMatchRecordSchema: z.ZodObject<{
         fired: "fired";
         expired: "expired";
     }>;
-    correlationKey: z.ZodNullable<z.ZodString>;
+    partitionKey: z.ZodNullable<z.ZodString>;
     openedAt: z.ZodString;
     expiresAt: z.ZodString;
     updatedAt: z.ZodString;
@@ -766,7 +565,7 @@ export declare const TriggerMatchRecordSchema: z.ZodObject<{
         payloadHash: z.ZodOptional<z.ZodString>;
         data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.core.$strip>>;
-    correlationDecision: z.ZodNullable<z.ZodObject<{
+    semanticDecision: z.ZodNullable<z.ZodObject<{
         evaluator: z.ZodString;
         outcome: z.ZodEnum<{
             match: "match";
@@ -788,6 +587,7 @@ export declare const TriggerMatchRecordSchema: z.ZodObject<{
         }>;
         signature: z.ZodOptional<z.ZodString>;
         maxObservedOccurredAt: z.ZodOptional<z.ZodString>;
+        completedAt: z.ZodOptional<z.ZodString>;
         semanticDecisions: z.ZodDefault<z.ZodArray<z.ZodObject<{
             nodeId: z.ZodString;
             decision: z.ZodObject<{
@@ -811,7 +611,6 @@ export declare const TriggerMatchRecordSchema: z.ZodObject<{
 }, 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>;
@@ -823,7 +622,7 @@ 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 type PatternSemanticDecision = z.infer<typeof PatternSemanticDecisionSchema>;
 export declare function parseCompositeTriggerDefinition(value: unknown): CompositeTriggerDefinition;
 export declare function parseCorrelatableEvent(value: unknown): CorrelatableEvent;
 export declare function parseTriggerMatchRecord(value: unknown): TriggerMatchRecord;

package/dist/src/intelligenceProtocol/triggerSchemas.js

@@ -1,13 +1,11 @@
 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';
+export const COMPOSITE_TRIGGER_PROTOCOL_VERSION = '0.2.0';
+export const COMPOSITE_TRIGGER_SCHEMA_VERSION = 'trigger.v0.2';
 const Id = z.string().min(1).max(200);
 const Timestamp = z.string().datetime({ offset: true });
 const Scalar = z.union([z.string(), z.number(), z.boolean()]);
-const ClockTime = z.string().regex(/^(?:[01]\d|2[0-3]):[0-5]\d$/);
-const CalendarDate = z.string().regex(/^\d{4}-\d{2}-\d{2}$/);
 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 }),
@@ -47,83 +45,6 @@ export const TriggerClauseSchema = z.object({
     arguments: z.record(z.string(), z.unknown()).default({}),
     where: z.array(StructuredPredicateSchema).default([]),
 });
-const TriggerExpressionSchema = z.discriminatedUnion('kind', [
-    z.object({ kind: z.literal('allOf'), refs: z.array(Id).min(2) }),
-    z.object({ kind: z.literal('anyOf'), refs: z.array(Id).min(1) }),
-    z.object({ kind: z.literal('sequence'), refs: z.array(Id).min(2) }),
-    z.object({ kind: z.literal('count'), ref: Id, atLeast: z.number().int().min(1) }),
-]);
-export const CalendarTemporalConditionSchema = z.object({
-    id: Id,
-    kind: z.literal('calendar'),
-    ref: Id,
-    timezone: z.string().min(1),
-    before: ClockTime.optional(),
-    after: ClockTime.optional(),
-    weekdays: z.array(z.number().int().min(1).max(7)).min(1).optional(),
-    dates: z.array(CalendarDate).min(1).optional(),
-    dateRange: z.object({
-        start: CalendarDate,
-        end: CalendarDate,
-    }).optional(),
-    dayOfMonth: z.array(z.number().int().min(1).max(31)).min(1).optional(),
-}).strict();
-export const AbsenceTemporalConditionSchema = z.object({
-    id: Id,
-    kind: z.literal('absence'),
-    ref: Id,
-    afterRef: Id,
-    forMs: z.number().int().positive().optional(),
-    untilLocalTime: ClockTime.optional(),
-    timezone: z.string().min(1).optional(),
-}).superRefine((value, ctx) => {
-    if (!value.forMs && !value.untilLocalTime) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'absence requires forMs or untilLocalTime',
-        });
-    }
-    if (value.untilLocalTime && !value.timezone) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'absence untilLocalTime requires timezone',
-        });
-    }
-});
-export const TemporalConditionSchema = z.discriminatedUnion('kind', [
-    CalendarTemporalConditionSchema,
-    AbsenceTemporalConditionSchema,
-    z.object({ id: Id, kind: z.literal('not'), ref: Id }),
-    z.object({ id: Id, kind: z.literal('unless'), ref: Id }),
-    z.object({ id: Id, kind: z.literal('after'), ref: Id, afterRef: Id }),
-    z.object({ id: Id, kind: z.literal('until'), ref: Id, beforeRef: Id }),
-    z.object({
-        id: Id,
-        kind: z.literal('debounce'),
-        ref: Id,
-        forMs: z.number().int().positive(),
-    }),
-    z.object({
-        id: Id,
-        kind: z.literal('threshold'),
-        ref: Id,
-        atLeast: z.number().int().min(1),
-    }),
-    z.object({
-        id: Id,
-        kind: z.literal('rate'),
-        ref: Id,
-        atLeast: z.number().int().min(1),
-        perMs: z.number().int().positive(),
-    }),
-    z.object({
-        id: Id,
-        kind: z.literal('distinct'),
-        ref: Id,
-        path: z.string().min(1),
-        atLeast: z.number().int().min(1),
-    }),
-]);
 export const DerivedEventProjectionSchema = z.object({
     key: z.string().regex(/^[A-Za-z_][A-Za-z0-9_-]{0,63}$/),
     ref: Id,
@@ -187,20 +108,6 @@ export const ContinuationContractSchema = z.object({
         includeData: true,
     }),
 }).strict();
-export const DeterministicCorrelationSchema = z.object({
-    kind: z.literal('same_value'),
-    fields: z.array(z.object({
-        ref: Id,
-        path: z.string().min(1),
-    })).min(2),
-});
-export const SemanticCorrelationSchema = z.object({
-    instruction: z.string().min(1),
-    input: z.array(z.string().min(1)).min(1),
-    matchThreshold: z.number().min(0).max(1),
-    rejectThreshold: z.number().min(0).max(1),
-    uncertain: z.enum(['escalate', 'reject', 'match']).default('escalate'),
-});
 export const CompositeTriggerDefinitionSchema = z.object({
     protocolVersion: z.literal(COMPOSITE_TRIGGER_PROTOCOL_VERSION)
         .default(COMPOSITE_TRIGGER_PROTOCOL_VERSION),
@@ -212,9 +119,7 @@ export const CompositeTriggerDefinitionSchema = z.object({
     conditionOnly: z.boolean().default(false),
     continuation: ContinuationContractSchema.optional(),
     clauses: z.array(TriggerClauseSchema).min(1),
-    expression: TriggerExpressionSchema,
-    temporal: z.array(TemporalConditionSchema).default([]),
-    patternV2: PatternAstV2DefinitionSchema.optional(),
+    pattern: PatternAstV2DefinitionSchema,
     eventTime: EventTimePolicySchema.optional(),
     lifecycle: TriggerLifecyclePolicySchema.default({
         oneShot: false,
@@ -222,10 +127,6 @@ export const CompositeTriggerDefinitionSchema = z.object({
         completeOnGoal: false,
     }),
     withinMs: z.number().int().positive().max(1000 * 60 * 60 * 24 * 30),
-    correlation: z.object({
-        deterministic: DeterministicCorrelationSchema.optional(),
-        semantic: SemanticCorrelationSchema.optional(),
-    }).optional(),
     target: RuntimeTargetSchema.optional(),
     derivedEvent: DerivedEventDefinitionSchema.optional(),
 }).superRefine((value, ctx) => {
@@ -262,25 +163,6 @@ export const CompositeTriggerDefinitionSchema = z.object({
     if (ids.size !== value.clauses.length) {
         ctx.addIssue({ code: 'custom', message: 'Trigger clause ids must be unique' });
     }
-    const refs = value.expression.kind === 'count'
-        ? [value.expression.ref]
-        : value.expression.refs;
-    for (const ref of refs) {
-        if (!ids.has(ref)) {
-            ctx.addIssue({
-                code: 'custom',
-                message: `Expression references unknown clause: ${ref}`,
-            });
-        }
-    }
-    for (const field of value.correlation?.deterministic?.fields ?? []) {
-        if (!ids.has(field.ref)) {
-            ctx.addIssue({
-                code: 'custom',
-                message: `Correlation references unknown clause: ${field.ref}`,
-            });
-        }
-    }
     if (value.derivedEvent) {
         const projectionKeys = new Set();
         const measureKeys = new Set();
@@ -353,17 +235,17 @@ export const CompositeTriggerDefinitionSchema = z.object({
             });
         }
     }
-    if (value.patternV2) {
-        const patternRefs = collectPatternRefs(value.patternV2.root);
+    {
+        const patternRefs = collectPatternRefs(value.pattern.root);
         for (const ref of patternRefs) {
             if (!ids.has(ref)) {
                 ctx.addIssue({
                     code: 'custom',
-                    message: `Pattern AST v2 references unknown clause: ${ref}`,
+                    message: `Pattern AST references unknown clause: ${ref}`,
                 });
             }
         }
-        for (const dimension of value.patternV2.partitionBy) {
+        for (const dimension of value.pattern.partitionBy) {
             const dimensionRefs = new Set();
             for (const field of dimension.fields) {
                 if (!ids.has(field.ref)) {
@@ -389,12 +271,12 @@ export const CompositeTriggerDefinitionSchema = z.object({
                 }
             }
         }
-        const guaranteedPatternRefs = collectGuaranteedPatternBindings(value.patternV2.root);
-        if (typeof value.patternV2.selection.afterMatch === 'object' &&
-            !guaranteedPatternRefs.includes(value.patternV2.selection.afterMatch.ref)) {
+        const guaranteedPatternRefs = collectGuaranteedPatternBindings(value.pattern.root);
+        if (typeof value.pattern.selection.afterMatch === 'object' &&
+            !guaranteedPatternRefs.includes(value.pattern.selection.afterMatch.ref)) {
             ctx.addIssue({
                 code: 'custom',
-                message: `Pattern afterMatch ref is not guaranteed by every match: ${value.patternV2.selection.afterMatch.ref}`,
+                message: `Pattern afterMatch ref is not guaranteed by every match: ${value.pattern.selection.afterMatch.ref}`,
             });
         }
         for (const measure of value.derivedEvent?.measures ?? []) {
@@ -407,71 +289,15 @@ export const CompositeTriggerDefinitionSchema = z.object({
                 }
             }
         }
-        const oversized = collectPatternDurationsMs(value.patternV2.root)
+        const oversized = collectPatternDurationsMs(value.pattern.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}`,
+                message: `Pattern AST duration exceeds trigger withinMs: ${Math.max(...oversized)} > ${value.withinMs}`,
             });
         }
     }
-    const conditionIds = new Set();
-    for (const condition of value.temporal) {
-        if (conditionIds.has(condition.id)) {
-            ctx.addIssue({
-                code: 'custom',
-                message: `Temporal condition id must be unique: ${condition.id}`,
-            });
-        }
-        conditionIds.add(condition.id);
-        const conditionRefs = [];
-        if ('ref' in condition)
-            conditionRefs.push(condition.ref);
-        if ('afterRef' in condition)
-            conditionRefs.push(condition.afterRef);
-        if ('beforeRef' in condition)
-            conditionRefs.push(condition.beforeRef);
-        for (const ref of conditionRefs) {
-            if (!ids.has(ref)) {
-                ctx.addIssue({
-                    code: 'custom',
-                    message: `Temporal condition ${condition.id} references unknown clause: ${ref}`,
-                });
-            }
-        }
-        if (condition.kind === 'calendar') {
-            try {
-                new Intl.DateTimeFormat('en-US', { timeZone: condition.timezone });
-            }
-            catch {
-                ctx.addIssue({
-                    code: 'custom',
-                    message: `Invalid IANA timezone: ${condition.timezone}`,
-                });
-            }
-            if (condition.before &&
-                condition.after &&
-                condition.before === condition.after) {
-                ctx.addIssue({
-                    code: 'custom',
-                    message: 'calendar before and after cannot be identical',
-                });
-            }
-        }
-        if (condition.kind === 'absence' &&
-            condition.timezone) {
-            try {
-                new Intl.DateTimeFormat('en-US', { timeZone: condition.timezone });
-            }
-            catch {
-                ctx.addIssue({
-                    code: 'custom',
-                    message: `Invalid IANA timezone: ${condition.timezone}`,
-                });
-            }
-        }
-    }
 });
 export const CorrelatableEventSchema = z.object({
     traceId: Id,
@@ -507,7 +333,7 @@ export const TriggerSourceEventSchema = z.object({
     payloadHash: z.string().regex(/^[a-f0-9]{64}$/).optional(),
     data: z.record(z.string(), z.unknown()),
 });
-export const CompositeCorrelationDecisionSchema = z.object({
+export const PatternSemanticDecisionSchema = z.object({
     evaluator: z.string().min(1),
     outcome: z.enum(['match', 'reject', 'uncertain']),
     probability: z.number().min(0).max(1),
@@ -529,9 +355,10 @@ export const PatternMatchStateSchema = z.object({
     role: z.enum(['buffer', 'match']),
     signature: z.string().min(1).optional(),
     maxObservedOccurredAt: Timestamp.optional(),
+    completedAt: Timestamp.optional(),
     semanticDecisions: z.array(z.object({
         nodeId: Id,
-        decision: CompositeCorrelationDecisionSchema,
+        decision: PatternSemanticDecisionSchema,
     }).strict()).default([]),
 }).strict();
 export const TriggerMatchRecordSchema = z.object({
@@ -541,12 +368,12 @@ export const TriggerMatchRecordSchema = z.object({
     triggerId: Id,
     triggerVersion: z.string().min(1),
     status: TriggerMatchStatusSchema,
-    correlationKey: z.string().nullable(),
+    partitionKey: z.string().nullable(),
     openedAt: Timestamp,
     expiresAt: Timestamp,
     updatedAt: Timestamp,
     sourceEvents: z.array(TriggerSourceEventSchema),
-    correlationDecision: CompositeCorrelationDecisionSchema.nullable(),
+    semanticDecision: PatternSemanticDecisionSchema.nullable(),
     patternState: PatternMatchStateSchema.optional(),
     firedWakeId: Id.nullable(),
     derivedEventIds: z.array(Id).default([]),

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

@@ -1,6 +1,6 @@
 export declare const EVENT_INTELLIGENCE_PROTOCOL: "mcp-event-intelligence";
-export declare const EVENT_INTELLIGENCE_PROTOCOL_VERSION: "0.1.0";
-export declare const EVENT_INTELLIGENCE_SCHEMA_VERSION: "ei.v0.1";
+export declare const EVENT_INTELLIGENCE_PROTOCOL_VERSION: "0.2.0";
+export declare const EVENT_INTELLIGENCE_SCHEMA_VERSION: "ei.v0.2";
 export declare const EVENT_INTELLIGENCE_COMPATIBILITY: {
     readonly mcpEvents: "experimental-ext-triggers-events/design-sketch";
     readonly mcpCore: "2026-07-28";

package/dist/src/intelligenceProtocol/version.js

@@ -1,6 +1,6 @@
 export const EVENT_INTELLIGENCE_PROTOCOL = 'mcp-event-intelligence';
-export const EVENT_INTELLIGENCE_PROTOCOL_VERSION = '0.1.0';
-export const EVENT_INTELLIGENCE_SCHEMA_VERSION = 'ei.v0.1';
+export const EVENT_INTELLIGENCE_PROTOCOL_VERSION = '0.2.0';
+export const EVENT_INTELLIGENCE_SCHEMA_VERSION = 'ei.v0.2';
 export const EVENT_INTELLIGENCE_COMPATIBILITY = {
     mcpEvents: 'experimental-ext-triggers-events/design-sketch',
     mcpCore: '2026-07-28',

package/dist/src/patternV2/evaluator.d.ts

@@ -18,10 +18,16 @@ export interface PatternV2SemanticTrace {
     candidateSignature: string;
     decision: SemanticDecision;
 }
+export interface PatternV2SemanticCache {
+    get(key: string): Promise<SemanticDecision | null> | SemanticDecision | null;
+    set(key: string, decision: SemanticDecision): Promise<void> | void;
+}
 export interface PatternV2Evaluation {
     matches: PatternV2Candidate[];
     pending: PatternV2Candidate[];
     semanticEvaluations: number;
+    semanticCacheHits: number;
+    semanticCacheMisses: number;
     semanticTrace: PatternV2SemanticTrace[];
     truncated: boolean;
 }
@@ -33,11 +39,13 @@ export declare function evaluatePatternAggregate(candidate: PatternV2Candidate,
     percentile?: number;
 }): unknown;
 export declare function evaluatePatternMeasure(candidate: PatternV2Candidate, measure: PatternMeasure): unknown;
-export declare function evaluatePatternV2({ definition, events, evaluator, now, allowedLatenessMs, }: {
+export declare function evaluatePatternV2({ definition, events, evaluator, now, allowedLatenessMs, semanticCache, semanticCacheNamespace, }: {
     definition: PatternAstV2Definition;
     events: TriggerSourceEvent[];
     evaluator?: SemanticEvaluator | null;
     now?: Date;
     allowedLatenessMs?: number;
+    semanticCache?: PatternV2SemanticCache | null;
+    semanticCacheNamespace?: string;
 }): Promise<PatternV2Evaluation>;
 export declare function patternV2CandidateSignature(candidate: PatternV2Candidate): string;