mcp-event-intelligence 0.4.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,89 +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";
-    "decision.evaluated": "decision.evaluated";
-    "lifecycle.transition": "lifecycle.transition";
+    "event.late_dropped": "event.late_dropped";
+    "event.buffer_overflow": "event.buffer_overflow";
     "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";
@@ -241,14 +83,11 @@ export declare const AuditRecordSchema: z.ZodObject<{
     timestamp: z.ZodString;
     kind: z.ZodEnum<{
         error: "error";
-        "event.received": "event.received";
-        "event.duplicate": "event.duplicate";
-        "decision.evaluated": "decision.evaluated";
-        "lifecycle.transition": "lifecycle.transition";
+        "event.late_dropped": "event.late_dropped";
+        "event.buffer_overflow": "event.buffer_overflow";
         "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";
@@ -273,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";
@@ -284,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>;
@@ -315,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,50 +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',
-    'decision.evaluated',
-    'lifecycle.transition',
+    'event.late_dropped',
+    'event.buffer_overflow',
     'wake.queued',
     'wake.delivered',
     'wake.retry_scheduled',
-    'wake.handled',
     'wake.dead_letter',
     'trigger.partial',
     'trigger.correlation',
@@ -150,7 +66,6 @@ export const AuditRecordSchema = z.object({
     kind: AuditKindSchema,
     entityType: z.enum([
         'event',
-        'decision',
         'wake',
         'subscription',
         'runtime',
@@ -167,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

@@ -16,14 +16,50 @@ export declare const TriggerPlanEventSchema: 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">;
@@ -42,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>;
@@ -72,14 +99,50 @@ export declare const TriggerPlanInputSchema: 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">;
@@ -98,16 +161,44 @@ 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>]>>;
+    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<{
+            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>>;
     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>;
@@ -116,7 +207,8 @@ export declare const TriggerPlanInputSchema: z.ZodObject<{
         leaseUntil: z.ZodOptional<z.ZodString>;
         completeOnGoal: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strict>>;
-    target: z.ZodObject<{
+    conditionOnly: z.ZodDefault<z.ZodBoolean>;
+    target: z.ZodOptional<z.ZodObject<{
         runtime: z.ZodString;
         kind: z.ZodEnum<{
             goal: "goal";
@@ -126,8 +218,8 @@ export declare const TriggerPlanInputSchema: z.ZodObject<{
             spawn_template: "spawn_template";
         }>;
         id: z.ZodString;
-    }, z.core.$strip>;
-    continuation: z.ZodObject<{
+    }, z.core.$strip>>;
+    continuation: z.ZodOptional<z.ZodObject<{
         instruction: z.ZodString;
         contextPolicy: z.ZodDefault<z.ZodObject<{
             evidence: z.ZodDefault<z.ZodEnum<{
@@ -137,24 +229,8 @@ export declare const TriggerPlanInputSchema: z.ZodObject<{
             maxEvents: z.ZodDefault<z.ZodNumber>;
             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>>;
 }, 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;