mcp-event-intelligence 0.5.0 → 0.6.0

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

@@ -10,91 +10,6 @@ export declare const RuntimeTargetSchema: z.ZodObject<{
     }>;
     id: z.ZodString;
 }, z.core.$strip>;
-export declare const EventSourceSchema: z.ZodObject<{
-    serverId: z.ZodString;
-    transport: z.ZodEnum<{
-        stdio: "stdio";
-        streamable_http: "streamable_http";
-        webhook: "webhook";
-        poll: "poll";
-        internal: "internal";
-    }>;
-    provider: z.ZodOptional<z.ZodString>;
-    cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, z.core.$strip>;
-export declare const EventLineageSchema: z.ZodObject<{
-    protocol: z.ZodLiteral<"mcp-event-intelligence">;
-    protocolVersion: z.ZodLiteral<"0.1.0">;
-    schemaVersion: z.ZodLiteral<"ei.v0.1">;
-    traceId: z.ZodString;
-    environmentId: z.ZodString;
-    subscriptionId: z.ZodString;
-    sourceEventId: z.ZodString;
-    observedAt: z.ZodString;
-    source: z.ZodObject<{
-        serverId: z.ZodString;
-        transport: z.ZodEnum<{
-            stdio: "stdio";
-            streamable_http: "streamable_http";
-            webhook: "webhook";
-            poll: "poll";
-            internal: "internal";
-        }>;
-        provider: z.ZodOptional<z.ZodString>;
-        cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strip>;
-    target: z.ZodObject<{
-        runtime: z.ZodString;
-        kind: z.ZodEnum<{
-            goal: "goal";
-            session: "session";
-            conversation: "conversation";
-            task: "task";
-            spawn_template: "spawn_template";
-        }>;
-        id: z.ZodString;
-    }, z.core.$strip>;
-    event: z.ZodObject<{
-        name: z.ZodString;
-        occurredAt: z.ZodString;
-        payloadHash: z.ZodString;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export declare const SemanticDecisionRecordSchema: z.ZodObject<{
-    decisionId: z.ZodString;
-    traceId: z.ZodString;
-    subscriptionId: z.ZodString;
-    sourceEventId: z.ZodString;
-    createdAt: z.ZodString;
-    evaluator: z.ZodString;
-    outcome: z.ZodEnum<{
-        match: "match";
-        reject: "reject";
-        uncertain: "uncertain";
-    }>;
-    probability: z.ZodNumber;
-    matched: z.ZodBoolean;
-    shouldEscalate: z.ZodBoolean;
-    policy: z.ZodObject<{
-        matchThreshold: z.ZodNumber;
-        rejectThreshold: z.ZodNumber;
-        uncertain: z.ZodEnum<{
-            match: "match";
-            reject: "reject";
-            escalate: "escalate";
-        }>;
-    }, z.core.$strip>;
-    inputFields: z.ZodArray<z.ZodString>;
-    providerEvidence: z.ZodOptional<z.ZodObject<{
-        requestedModel: z.ZodOptional<z.ZodString>;
-        resolvedModel: z.ZodOptional<z.ZodString>;
-        requestId: z.ZodOptional<z.ZodString>;
-        httpStatus: z.ZodOptional<z.ZodNumber>;
-        inputTokens: z.ZodOptional<z.ZodNumber>;
-        outputTokens: z.ZodOptional<z.ZodNumber>;
-        providerReportedCost: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
 export declare const WakeRecordSchema: z.ZodObject<{
     wakeId: z.ZodString;
     traceId: z.ZodString;
@@ -116,8 +31,6 @@ export declare const WakeRecordSchema: z.ZodObject<{
     status: z.ZodEnum<{
         queued: "queued";
         delivered: "delivered";
-        handled: "handled";
-        duplicate: "duplicate";
         dead_letter: "dead_letter";
     }>;
     runtimeReceiptId: z.ZodOptional<z.ZodString>;
@@ -130,91 +43,18 @@ export declare const McpEventOccurrenceSchema: z.ZodObject<{
     cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
-export declare const SemanticConditionWireSchema: z.ZodObject<{
-    type: z.ZodLiteral<"semantic_boolean">;
-    instruction: z.ZodString;
-    input: z.ZodArray<z.ZodString>;
-    matchThreshold: z.ZodNumber;
-    rejectThreshold: z.ZodNumber;
-    uncertain: z.ZodEnum<{
-        match: "match";
-        reject: "reject";
-        escalate: "escalate";
-    }>;
-}, z.core.$strip>;
-export declare const EventIngestRequestSchema: z.ZodObject<{
-    event: z.ZodObject<{
-        eventId: z.ZodString;
-        name: z.ZodString;
-        timestamp: z.ZodString;
-        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>;
-    context: z.ZodObject<{
-        traceId: z.ZodOptional<z.ZodString>;
-        environmentId: z.ZodString;
-        subscriptionId: z.ZodString;
-        serverId: z.ZodString;
-        transport: z.ZodEnum<{
-            stdio: "stdio";
-            streamable_http: "streamable_http";
-            webhook: "webhook";
-            poll: "poll";
-            internal: "internal";
-        }>;
-        provider: z.ZodOptional<z.ZodString>;
-        target: z.ZodObject<{
-            runtime: z.ZodString;
-            kind: z.ZodEnum<{
-                goal: "goal";
-                session: "session";
-                conversation: "conversation";
-                task: "task";
-                spawn_template: "spawn_template";
-            }>;
-            id: z.ZodString;
-        }, z.core.$strip>;
-    }, z.core.$strip>;
-    semanticCondition: z.ZodOptional<z.ZodObject<{
-        type: z.ZodLiteral<"semantic_boolean">;
-        instruction: z.ZodString;
-        input: z.ZodArray<z.ZodString>;
-        matchThreshold: z.ZodNumber;
-        rejectThreshold: z.ZodNumber;
-        uncertain: z.ZodEnum<{
-            match: "match";
-            reject: "reject";
-            escalate: "escalate";
-        }>;
-    }, z.core.$strip>>;
-    wakeOnEscalation: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>;
 export declare const LifecycleStateSchema: z.ZodEnum<{
-    matched: "matched";
-    handled: "handled";
-    duplicate: "duplicate";
     dead_letter: "dead_letter";
-    received: "received";
-    evaluating: "evaluating";
-    rejected: "rejected";
-    escalated: "escalated";
     wake_queued: "wake_queued";
     wake_delivered: "wake_delivered";
-    failed: "failed";
 }>;
 export declare const AuditKindSchema: z.ZodEnum<{
     error: "error";
-    "event.received": "event.received";
-    "event.duplicate": "event.duplicate";
     "event.late_dropped": "event.late_dropped";
     "event.buffer_overflow": "event.buffer_overflow";
-    "decision.evaluated": "decision.evaluated";
-    "lifecycle.transition": "lifecycle.transition";
     "wake.queued": "wake.queued";
     "wake.delivered": "wake.delivered";
     "wake.retry_scheduled": "wake.retry_scheduled";
-    "wake.handled": "wake.handled";
     "wake.dead_letter": "wake.dead_letter";
     "trigger.partial": "trigger.partial";
     "trigger.correlation": "trigger.correlation";
@@ -243,16 +83,11 @@ export declare const AuditRecordSchema: z.ZodObject<{
     timestamp: z.ZodString;
     kind: z.ZodEnum<{
         error: "error";
-        "event.received": "event.received";
-        "event.duplicate": "event.duplicate";
         "event.late_dropped": "event.late_dropped";
         "event.buffer_overflow": "event.buffer_overflow";
-        "decision.evaluated": "decision.evaluated";
-        "lifecycle.transition": "lifecycle.transition";
         "wake.queued": "wake.queued";
         "wake.delivered": "wake.delivered";
         "wake.retry_scheduled": "wake.retry_scheduled";
-        "wake.handled": "wake.handled";
         "wake.dead_letter": "wake.dead_letter";
         "trigger.partial": "trigger.partial";
         "trigger.correlation": "trigger.correlation";
@@ -277,7 +112,6 @@ export declare const AuditRecordSchema: z.ZodObject<{
     entityType: z.ZodEnum<{
         runtime: "runtime";
         event: "event";
-        decision: "decision";
         wake: "wake";
         subscription: "subscription";
         trigger_match: "trigger_match";
@@ -288,30 +122,14 @@ export declare const AuditRecordSchema: z.ZodObject<{
     }>;
     entityId: z.ZodString;
     fromState: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-        matched: "matched";
-        handled: "handled";
-        duplicate: "duplicate";
         dead_letter: "dead_letter";
-        received: "received";
-        evaluating: "evaluating";
-        rejected: "rejected";
-        escalated: "escalated";
         wake_queued: "wake_queued";
         wake_delivered: "wake_delivered";
-        failed: "failed";
     }>>>;
     toState: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-        matched: "matched";
-        handled: "handled";
-        duplicate: "duplicate";
         dead_letter: "dead_letter";
-        received: "received";
-        evaluating: "evaluating";
-        rejected: "rejected";
-        escalated: "escalated";
         wake_queued: "wake_queued";
         wake_delivered: "wake_delivered";
-        failed: "failed";
     }>>>;
     details: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     previousHash: z.ZodNullable<z.ZodString>;
@@ -319,15 +137,8 @@ export declare const AuditRecordSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type RuntimeTarget = z.infer<typeof RuntimeTargetSchema>;
 export type McpEventOccurrence = z.infer<typeof McpEventOccurrenceSchema>;
-export type SemanticConditionWire = z.infer<typeof SemanticConditionWireSchema>;
-export type EventIngestRequest = z.infer<typeof EventIngestRequestSchema>;
-export type EventLineage = z.infer<typeof EventLineageSchema>;
-export type SemanticDecisionRecord = z.infer<typeof SemanticDecisionRecordSchema>;
 export type WakeRecord = z.infer<typeof WakeRecordSchema>;
 export type LifecycleState = z.infer<typeof LifecycleStateSchema>;
 export type AuditRecord = z.infer<typeof AuditRecordSchema>;
-export declare function parseEventIngestRequest(value: unknown): EventIngestRequest;
-export declare function parseEventLineage(value: unknown): EventLineage;
-export declare function parseSemanticDecisionRecord(value: unknown): SemanticDecisionRecord;
 export declare function parseWakeRecord(value: unknown): WakeRecord;
 export declare function parseAuditRecord(value: unknown): AuditRecord;

package/dist/src/intelligenceProtocol/schemas.js

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import { EVENT_INTELLIGENCE_PROTOCOL, EVENT_INTELLIGENCE_PROTOCOL_VERSION, EVENT_INTELLIGENCE_SCHEMA_VERSION, } from './version.js';
 const Id = z.string().min(1).max(200);
 const Timestamp = z.string().datetime({ offset: true });
 export const RuntimeTargetSchema = z.object({
@@ -7,56 +6,6 @@ export const RuntimeTargetSchema = z.object({
     kind: z.enum(['goal', 'session', 'conversation', 'task', 'spawn_template']),
     id: Id,
 });
-export const EventSourceSchema = z.object({
-    serverId: Id,
-    transport: z.enum(['stdio', 'streamable_http', 'webhook', 'poll', 'internal']),
-    provider: z.string().min(1).optional(),
-    cursor: z.string().nullable().optional(),
-});
-export const EventLineageSchema = z.object({
-    protocol: z.literal(EVENT_INTELLIGENCE_PROTOCOL),
-    protocolVersion: z.literal(EVENT_INTELLIGENCE_PROTOCOL_VERSION),
-    schemaVersion: z.literal(EVENT_INTELLIGENCE_SCHEMA_VERSION),
-    traceId: Id,
-    environmentId: Id,
-    subscriptionId: Id,
-    sourceEventId: Id,
-    observedAt: Timestamp,
-    source: EventSourceSchema,
-    target: RuntimeTargetSchema,
-    event: z.object({
-        name: z.string().min(1),
-        occurredAt: Timestamp,
-        payloadHash: z.string().regex(/^[a-f0-9]{64}$/),
-    }),
-});
-export const SemanticDecisionRecordSchema = z.object({
-    decisionId: Id,
-    traceId: Id,
-    subscriptionId: Id,
-    sourceEventId: Id,
-    createdAt: Timestamp,
-    evaluator: z.string().min(1),
-    outcome: z.enum(['match', 'reject', 'uncertain']),
-    probability: z.number().min(0).max(1),
-    matched: z.boolean(),
-    shouldEscalate: z.boolean(),
-    policy: z.object({
-        matchThreshold: z.number().min(0).max(1),
-        rejectThreshold: z.number().min(0).max(1),
-        uncertain: z.enum(['escalate', 'reject', 'match']),
-    }),
-    inputFields: z.array(z.string().min(1)),
-    providerEvidence: z.object({
-        requestedModel: z.string().min(1).optional(),
-        resolvedModel: z.string().min(1).optional(),
-        requestId: z.string().min(1).optional(),
-        httpStatus: z.number().int().min(100).max(599).optional(),
-        inputTokens: z.number().int().nonnegative().optional(),
-        outputTokens: z.number().int().nonnegative().optional(),
-        providerReportedCost: z.number().nonnegative().optional(),
-    }).optional(),
-});
 export const WakeRecordSchema = z.object({
     wakeId: Id,
     traceId: Id,
@@ -65,7 +14,7 @@ export const WakeRecordSchema = z.object({
     sourceEventId: Id,
     createdAt: Timestamp,
     target: RuntimeTargetSchema,
-    status: z.enum(['queued', 'delivered', 'handled', 'duplicate', 'dead_letter']),
+    status: z.enum(['queued', 'delivered', 'dead_letter']),
     runtimeReceiptId: Id.optional(),
 });
 export const McpEventOccurrenceSchema = z.object({
@@ -76,52 +25,17 @@ export const McpEventOccurrenceSchema = z.object({
     cursor: z.string().nullable().optional(),
     _meta: z.record(z.string(), z.unknown()).optional(),
 });
-export const SemanticConditionWireSchema = z.object({
-    type: z.literal('semantic_boolean'),
-    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']),
-});
-export const EventIngestRequestSchema = z.object({
-    event: McpEventOccurrenceSchema,
-    context: z.object({
-        traceId: Id.optional(),
-        environmentId: Id,
-        subscriptionId: Id,
-        serverId: Id,
-        transport: z.enum(['stdio', 'streamable_http', 'webhook', 'poll', 'internal']),
-        provider: z.string().min(1).optional(),
-        target: RuntimeTargetSchema,
-    }),
-    semanticCondition: SemanticConditionWireSchema.optional(),
-    wakeOnEscalation: z.boolean().default(false),
-});
 export const LifecycleStateSchema = z.enum([
-    'received',
-    'duplicate',
-    'evaluating',
-    'matched',
-    'rejected',
-    'escalated',
     'wake_queued',
     'wake_delivered',
-    'handled',
-    'failed',
     'dead_letter',
 ]);
 export const AuditKindSchema = z.enum([
-    'event.received',
-    'event.duplicate',
     'event.late_dropped',
     'event.buffer_overflow',
-    'decision.evaluated',
-    'lifecycle.transition',
     'wake.queued',
     'wake.delivered',
     'wake.retry_scheduled',
-    'wake.handled',
     'wake.dead_letter',
     'trigger.partial',
     'trigger.correlation',
@@ -152,7 +66,6 @@ export const AuditRecordSchema = z.object({
     kind: AuditKindSchema,
     entityType: z.enum([
         'event',
-        'decision',
         'wake',
         'subscription',
         'runtime',
@@ -169,15 +82,6 @@ export const AuditRecordSchema = z.object({
     previousHash: z.string().regex(/^[a-f0-9]{64}$/).nullable(),
     hash: z.string().regex(/^[a-f0-9]{64}$/),
 });
-export function parseEventIngestRequest(value) {
-    return EventIngestRequestSchema.parse(value);
-}
-export function parseEventLineage(value) {
-    return EventLineageSchema.parse(value);
-}
-export function parseSemanticDecisionRecord(value) {
-    return SemanticDecisionRecordSchema.parse(value);
-}
 export function parseWakeRecord(value) {
     return WakeRecordSchema.parse(value);
 }

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

@@ -78,15 +78,6 @@ export declare const TriggerPlanEventSchema: z.ZodObject<{
         value: z.ZodNumber;
     }, z.core.$strip>], "op">>>;
 }, z.core.$strict>;
-export declare const TriggerPlanMatchSchema: z.ZodUnion<readonly [z.ZodEnum<{
-    any: "any";
-    sequence: "sequence";
-    all: "all";
-}>, z.ZodObject<{
-    kind: z.ZodLiteral<"count">;
-    eventId: z.ZodString;
-    atLeast: z.ZodNumber;
-}, z.core.$strict>]>;
 export declare const TriggerPlanInputSchema: z.ZodObject<{
     triggerId: z.ZodOptional<z.ZodString>;
     version: z.ZodDefault<z.ZodString>;
@@ -170,83 +161,7 @@ export declare const TriggerPlanInputSchema: z.ZodObject<{
             value: z.ZodNumber;
         }, z.core.$strip>], "op">>>;
     }, z.core.$strict>>;
-    match: z.ZodDefault<z.ZodUnion<readonly [z.ZodEnum<{
-        any: "any";
-        sequence: "sequence";
-        all: "all";
-    }>, z.ZodObject<{
-        kind: z.ZodLiteral<"count">;
-        eventId: z.ZodString;
-        atLeast: z.ZodNumber;
-    }, z.core.$strict>]>>;
-    withinMs: z.ZodDefault<z.ZodNumber>;
-    eventTime: z.ZodOptional<z.ZodObject<{
-        allowedLatenessMs: z.ZodNumber;
-    }, z.core.$strict>>;
-    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.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<{
@@ -280,6 +195,10 @@ export declare const TriggerPlanInputSchema: z.ZodObject<{
             maxBufferedEvents: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
+    withinMs: z.ZodDefault<z.ZodNumber>;
+    eventTime: z.ZodOptional<z.ZodObject<{
+        allowedLatenessMs: z.ZodNumber;
+    }, z.core.$strict>>;
     lifecycle: z.ZodOptional<z.ZodObject<{
         oneShot: z.ZodOptional<z.ZodBoolean>;
         maxFirings: z.ZodOptional<z.ZodNumber>;
@@ -311,23 +230,7 @@ export declare const TriggerPlanInputSchema: z.ZodObject<{
             includeData: z.ZodDefault<z.ZodBoolean>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
-    correlateBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        eventId: z.ZodString;
-        path: z.ZodString;
-    }, z.core.$strict>>>;
-    semanticCorrelation: 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.$strict>;
 export type TriggerPlanEvent = z.infer<typeof TriggerPlanEventSchema>;
-export type TriggerPlanMatch = z.infer<typeof TriggerPlanMatchSchema>;
 export type TriggerPlanInput = z.infer<typeof TriggerPlanInputSchema>;
 export declare function parseTriggerPlanInput(value: unknown): TriggerPlanInput;

package/dist/src/intelligenceProtocol/triggerPlanSchemas.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { RuntimeTargetSchema } from './schemas.js';
 import { PatternAstV2DefinitionSchema, } from './patternV2Schemas.js';
-import { ContinuationContractSchema, SemanticCorrelationSchema, StructuredPredicateSchema, TemporalConditionSchema, } from './triggerSchemas.js';
+import { ContinuationContractSchema, StructuredPredicateSchema, } from './triggerSchemas.js';
 const Id = z.string().min(1).max(200);
 export const TriggerPlanEventSchema = z.object({
     id: Id.optional(),
@@ -10,28 +10,18 @@ export const TriggerPlanEventSchema = z.object({
     arguments: z.record(z.string(), z.unknown()).default({}),
     where: z.array(StructuredPredicateSchema).default([]),
 }).strict();
-export const TriggerPlanMatchSchema = z.union([
-    z.enum(['all', 'any', 'sequence']),
-    z.object({
-        kind: z.literal('count'),
-        eventId: Id,
-        atLeast: z.number().int().min(1),
-    }).strict(),
-]);
 export const TriggerPlanInputSchema = z.object({
     triggerId: Id.optional(),
     version: z.string().min(1).default('1'),
     description: z.string().max(500).optional(),
     events: z.array(TriggerPlanEventSchema).min(1),
-    match: TriggerPlanMatchSchema.default('all'),
+    pattern: PatternAstV2DefinitionSchema.optional(),
     withinMs: z.number().int().positive().max(1000 * 60 * 60 * 24 * 30)
         .default(60 * 60 * 1000),
     eventTime: z.object({
         allowedLatenessMs: z.number().int().nonnegative()
             .max(1000 * 60 * 60 * 24 * 30),
     }).strict().optional(),
-    temporal: z.array(TemporalConditionSchema).default([]),
-    patternV2: PatternAstV2DefinitionSchema.optional(),
     lifecycle: z.object({
         oneShot: z.boolean().optional(),
         maxFirings: z.number().int().min(1).optional(),
@@ -43,21 +33,7 @@ export const TriggerPlanInputSchema = z.object({
     conditionOnly: z.boolean().default(false),
     target: RuntimeTargetSchema.optional(),
     continuation: ContinuationContractSchema.optional(),
-    correlateBy: z.array(z.object({
-        eventId: Id,
-        path: z.string().min(1),
-    }).strict()).min(2).optional(),
-    semanticCorrelation: SemanticCorrelationSchema.optional(),
 }).strict().superRefine((value, ctx) => {
-    if (value.patternV2 &&
-        (value.temporal.length > 0 ||
-            value.correlateBy ||
-            value.semanticCorrelation)) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'patternV2 cannot be combined with legacy temporal/correlation fields',
-        });
-    }
     if (value.conditionOnly) {
         if (value.target || value.continuation) {
             ctx.addIssue({