mcp-event-intelligence 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -2,6 +2,67 @@
 
 All notable public changes are documented here.
 
+## [0.3.0] - 2026-09-20
+
+Agent-integration release focused on making Event Intelligence usable as a plug-and-play future-condition primitive.
+
+### Agent-friendly trigger planning
+
+- added deterministic `TriggerPlanInput` contracts;
+- added `host.planTrigger()` / scoped `planTrigger()`;
+- planner resolves live event sources and server IDs;
+- planner validates predicate paths against advertised payload schemas;
+- planner compiles `all`, `any`, `sequence` and `count` into the canonical trigger DSL;
+- added numeric predicates `gt`, `gte`, `lt` and `lte`.
+
+### Continuations and activation
+
+- trigger definitions may now persist a first-class `continuation` contract;
+- continuation instructions are separated from the condition that wakes the runtime;
+- added Activation Envelope contracts;
+- added `host.hydrateWake(wakeId)` / scoped `hydrateWake(wakeId)`;
+- hydrated evidence can include matched event payloads according to the trigger context policy;
+- activation evidence is explicitly labeled as untrusted external signal data;
+- the wire wake remains reference-only by default.
+
+### Embedded host ergonomics
+
+- embedded wake callbacks may now receive `(packet, activation)`;
+- existing one-argument callbacks remain compatible;
+- trigger inspection now includes the persisted continuation contract.
+
+### MCP control plane
+
+- added non-mutating `trigger_plan`;
+- added non-mutating `wake_hydrate`;
+- `trigger_create` now accepts either a raw canonical definition or an agent-friendly plan;
+- plan-based creation still uses the same confirmation, source-scope, owner and version checks.
+
+### Verification
+
+- end-to-end coverage verifies plan -> canonical trigger -> numeric predicate match -> reference-only wake -> hydrated activation -> runtime receipt;
+- context-policy coverage verifies refs-only activation evidence;
+- clean-room smoke now installs the candidate packed artifact rather than an old hard-coded npm version.
+
+### Compatibility
+
+Persisted protocol and trigger schema version identifiers remain at the v0.1 compatibility line. The new continuation field is optional, so existing stored triggers remain readable. Existing wake packets remain reference-only and unchanged on the wire.
+
+## [0.2.1] - 2026-09-20
+
+Patch hardening for shutdown determinism and multi-tenant verification.
+
+### Fixed
+
+- host shutdown now drains in-flight MCP polling, temporal/wake schedulers and persistent JSONL writes before returning;
+- prevents background writes from racing temporary-directory cleanup and causing intermittent `ENOTEMPTY` failures;
+- scoped isolation regression coverage now includes event source discovery, MCP client state/cursors, occurrences, audit records and wake visibility.
+
+### Clarified
+
+- the exported ERPNext helper is a typed MCP Events provider factory, not a credential-owning ERP connector;
+- the production authenticated ERPNext implementation remains in `world-capability-mcp`, where real data access, tenant/company filtering, pagination, cursors and timezone handling are implemented.
+
 ## [0.2.0] - 2026-09-20
 
 Production-hardening release for shared Event Intelligence hosts.

package/README.md

@@ -4,7 +4,7 @@
 
 [![CI](https://github.com/sarooo17/event-intelligence/actions/workflows/ci.yml/badge.svg)](https://github.com/sarooo17/event-intelligence/actions/workflows/ci.yml)
 [![npm](https://img.shields.io/npm/v/mcp-event-intelligence.svg)](https://www.npmjs.com/package/mcp-event-intelligence)
-[![MCP Registry](https://img.shields.io/badge/MCP%20Registry-v0.2.0-5b5bd6)](https://registry.modelcontextprotocol.io/?q=io.github.sarooo17%2Fevent-intelligence)
+[![MCP Registry](https://img.shields.io/badge/MCP%20Registry-v0.3.0-5b5bd6)](https://registry.modelcontextprotocol.io/?q=io.github.sarooo17%2Fevent-intelligence)
 [![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
 
 MCP Event Intelligence is an experimental event runtime for agents that need to react to **future conditions over multiple event sources** without keeping an LLM or agent loop alive.
@@ -45,8 +45,11 @@ const ei = await createEventIntelligenceHost({
     listConnections: () => host.mcp.listConnections(),
     subscribe: (refresh) => host.mcp.onConnectionsChanged(refresh),
   }),
-  wake: async (packet) => {
-    const receipt = await host.resume(packet.target, packet);
+  wake: async (packet, activation) => {
+    const receipt = await host.resume(packet.target, {
+      packet,
+      activation,
+    });
     return { runtimeReceiptId: receipt.id };
   },
 });
@@ -54,6 +57,52 @@ const ei = await createEventIntelligenceHost({
 
 Event Intelligence enumerates the host registry automatically. GitHub, Gmail, private/company MCPs and future connections do not need to be configured again inside EI. Tools-only MCPs remain available to the agent and are ignored by the Events layer; Events-capable MCPs are attached automatically.
 
+### Agent-first trigger flow
+
+Agents no longer need to construct the low-level trigger DSL directly for common cases. Ask EI to compile an agent-friendly plan against the event sources that are actually available:
+
+```js
+const plan = await ei.planTrigger({
+  events: [{
+    id: 'invoice',
+    event: 'erpnext.sales_invoice.submitted',
+    where: [
+      { path: 'grand_total', op: 'gt', value: 10000 },
+    ],
+  }],
+  match: 'all',
+  withinMs: 60 * 60 * 1000,
+  target: {
+    runtime: 'agent',
+    kind: 'conversation',
+    id: 'chat-42',
+  },
+  continuation: {
+    instruction:
+      'Check the submitted invoice for anomalies and report back in this conversation.',
+  },
+});
+
+await ei.triggerControl.createTrigger({
+  definition: plan.definition,
+  connectionIds: plan.connectionIds,
+  actor,
+  owner,
+});
+```
+
+`planTrigger()` is deterministic. It does not call a model. It resolves event names to live source/server IDs, validates predicate paths against advertised payload schemas, compiles `all` / `any` / `sequence` / `count`, and returns the canonical trigger definition plus the required connection IDs.
+
+The persisted `continuation` answers a separate question from the trigger condition: **what should the agent do after the future condition becomes true?**
+
+The wire wake remains deliberately small and reference-only. Embedded hosts also receive an Activation Envelope as the second wake argument. The same envelope can be reconstructed later:
+
+```js
+const activation = ei.hydrateWake(wakeId);
+```
+
+The envelope contains the configured continuation, trigger/match state, and matched evidence. Event payloads are labeled as untrusted external signals and are included only according to the trigger's `continuation.contextPolicy`.
+
 
 ### Shared hosts, tenant isolation and storage
 
@@ -125,7 +174,7 @@ The package owns capability advertisement, `server/discover`, `events/list`, `ev
 This adapter remains experimental compatibility work around MCP Events; it is not a claim of finalized MCP Events conformance.
 
 
-A concrete ERP-shaped adapter is also exported, so the provider abstraction is exercised against a source structurally different from GitHub:
+An ERPNext-shaped **provider factory** is also exported:
 
 ```js
 import {
@@ -140,9 +189,21 @@ const events = createErpNextEventsProvider({
 });
 ```
 
-It exposes `erpnext.sales_invoice.submitted` and `erpnext.sales_order.created` while leaving ERP authentication/query ownership with the provider.
+This helper owns the MCP Events descriptors, schemas and response validation for
+`erpnext.sales_invoice.submitted` and `erpnext.sales_order.created`. It is
+**not** a credential-owning ERPNext connector: the host/provider must supply the
+actual data-access functions. That separation is intentional so Event
+Intelligence never duplicates provider authentication.
+
+The production proof that the abstraction works against a real ERP data layer
+lives in `sarooo17/world-capability-mcp`: its ERP Events implementation uses
+`createMcpEventsProvider` with authenticated ERPNext/Frappe record queries,
+tenant/company filters, opaque replay-safe cursors, pagination/`hasMore`,
+timezone normalization and deterministic occurrence IDs. The local factory in
+this package should therefore be read as a typed convenience API, not as the
+production ERP connector itself.
 
-## What v0.1 implements
+## What v0.3 implements
 
 ### Host-owned event sources
 
@@ -170,7 +231,11 @@ It exposes `erpnext.sales_invoice.submitted` and `erpnext.sales_order.created` w
 ### Agent-authored continuations
 
 - event-source discovery;
-- agent-authored structured trigger definitions;
+- agent-friendly deterministic trigger planning/compilation;
+- `eq`, `neq`, `contains`, `in`, `exists`, `gt`, `gte`, `lt`, `lte` predicates;
+- persisted continuation contracts separated from trigger conditions;
+- Activation Envelope hydration with matched event evidence;
+- embedded wake callbacks receive `(packet, activation)`;
 - deterministic validation against real source schemas and advertised fields;
 - approval-gated persistent mutations;
 - one-shot, cooldown, max-firings, expiry, leases, update and delete.
@@ -239,7 +304,7 @@ The agent/harness is already responsible for reasoning and can author a structur
 
 ## Full-system acceptance
 
-The v0.1 acceptance suite verifies:
+The v0.3 acceptance suite verifies:
 
 - host-owned MCP client → event discovery/poll → composite match → in-process wake;
 - provider-neutral events → composite match → derived event → derived composition → signed runtime wake;
@@ -285,13 +350,13 @@ The standalone service supports manual/provider-native event ingress. It does no
 ### Docker
 
 ```bash
-docker build -t mcp-event-intelligence:0.1.0 .
+docker build -t mcp-event-intelligence:0.3.0 .
 
 docker run --rm \
   -p 3000:3000 \
   -v mcp-event-intelligence-data:/data \
   -e SERVICE_AUTH_TOKEN="$(openssl rand -hex 32)" \
-  mcp-event-intelligence:0.1.0
+  mcp-event-intelligence:0.3.0
 ```
 
 ## Optional MCP control plane
@@ -302,7 +367,7 @@ The package also exposes a standard **MCP stdio** control plane through the offi
 npx mcp-event-intelligence mcp
 ```
 
-Read/non-mutating tools are exposed by default, including `event_sources_list`, inspection, simulation, contracts and runtime status. An agent uses those discovered source schemas to author the structured definition passed to `trigger_create`.
+Read/non-mutating tools are exposed by default, including `event_sources_list`, `trigger_plan`, inspection, simulation, `wake_hydrate`, contracts and runtime status. `trigger_create` accepts either a raw canonical definition or the same agent-friendly plan shape; EI compiles the latter before applying the normal mutation controls.
 
 Persistent trigger mutations are only registered when the operator explicitly enables `MCP_WRITE_ENABLED=true`, and each mutation still requires a `confirmationId`. The MCP server is a control-plane adapter; it is **not** a gateway through which the host's other MCP servers must be reconnected.
 
@@ -355,7 +420,7 @@ It uses stable wake IDs, persisted delivery state, atomic claim leases, bounded
 
 A derived event says **what became true at a point in history**.
 
-v0.1 intentionally does not implement a mutable current-state/facts database.
+v0.3 intentionally does not implement a mutable current-state/facts database.
 
 ## Security
 
@@ -380,7 +445,7 @@ io.github.sarooo17/event-intelligence
 
 ## Project status
 
-**v0.1 reference implementation / experimental.**
+**v0.3 reference implementation / experimental.**
 
 The architecture is implemented and exercised end-to-end. Storage is now injectable and scoped, while the bundled JSONL backend remains a single-process reference implementation. Remaining work is primarily production database adapters/HA validation, scale benchmarks and upstream feedback.
 

package/bin/mcp-event-intelligence.mjs

@@ -4,7 +4,7 @@ const args = process.argv.slice(2);
 const flags = new Set(args);
 
 if (flags.has('--version') || flags.has('-v')) {
-  console.log('0.2.0');
+  console.log('0.3.0');
   process.exit(0);
 }
 

package/dist/src/composite/matching.js

@@ -33,6 +33,14 @@ function predicateMatches(event, predicate) {
             return predicate.value.includes(value);
         case 'exists':
             return predicate.value ? value !== undefined : value === undefined;
+        case 'gt':
+            return typeof value === 'number' && value > predicate.value;
+        case 'gte':
+            return typeof value === 'number' && value >= predicate.value;
+        case 'lt':
+            return typeof value === 'number' && value < predicate.value;
+        case 'lte':
+            return typeof value === 'number' && value <= predicate.value;
     }
 }
 export function clauseMatches(clause, event) {

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

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+export declare const ActivationEvidenceSchema: z.ZodObject<{
+    clauseId: z.ZodString;
+    serverId: z.ZodNullable<z.ZodString>;
+    eventId: z.ZodString;
+    eventName: z.ZodString;
+    traceId: z.ZodString;
+    occurredAt: z.ZodString;
+    payloadHash: z.ZodNullable<z.ZodString>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export declare const ActivationEnvelopeSchema: z.ZodObject<{
+    activationVersion: z.ZodLiteral<"1">;
+    wake: z.ZodObject<{
+        wakeId: z.ZodString;
+        status: z.ZodString;
+        runtimeReceiptId: z.ZodNullable<z.ZodString>;
+        matchedAt: z.ZodString;
+    }, z.core.$strict>;
+    target: z.ZodObject<{
+        runtime: z.ZodString;
+        kind: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    trigger: z.ZodObject<{
+        triggerId: z.ZodString;
+        version: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        expression: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        lifecycle: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strict>;
+    continuation: z.ZodNullable<z.ZodObject<{
+        instruction: z.ZodString;
+        contextPolicy: z.ZodDefault<z.ZodObject<{
+            evidence: z.ZodDefault<z.ZodEnum<{
+                matched_events: "matched_events";
+                refs_only: "refs_only";
+            }>>;
+            maxEvents: z.ZodDefault<z.ZodNumber>;
+            includeData: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    match: z.ZodObject<{
+        matchId: z.ZodString;
+        status: z.ZodString;
+        correlationKey: z.ZodNullable<z.ZodString>;
+        openedAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>;
+    evidence: z.ZodArray<z.ZodObject<{
+        clauseId: z.ZodString;
+        serverId: z.ZodNullable<z.ZodString>;
+        eventId: z.ZodString;
+        eventName: z.ZodString;
+        traceId: z.ZodString;
+        occurredAt: z.ZodString;
+        payloadHash: z.ZodNullable<z.ZodString>;
+        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+    trust: z.ZodObject<{
+        continuation: z.ZodLiteral<"configured_trigger_instruction">;
+        evidence: z.ZodLiteral<"untrusted_external_signal">;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ActivationEvidence = z.infer<typeof ActivationEvidenceSchema>;
+export type ActivationEnvelope = z.infer<typeof ActivationEnvelopeSchema>;
+export declare function parseActivationEnvelope(value: unknown): ActivationEnvelope;

package/dist/src/intelligenceProtocol/activationSchemas.js

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { ContinuationContractSchema } from './triggerSchemas.js';
+const Id = z.string().min(1).max(200);
+const Timestamp = z.string().datetime({ offset: true });
+export const ActivationEvidenceSchema = z.object({
+    clauseId: Id,
+    serverId: Id.nullable(),
+    eventId: Id,
+    eventName: z.string().min(1),
+    traceId: Id,
+    occurredAt: Timestamp,
+    payloadHash: z.string().regex(/^[a-f0-9]{64}$/).nullable(),
+    data: z.record(z.string(), z.unknown()).optional(),
+}).strict();
+export const ActivationEnvelopeSchema = z.object({
+    activationVersion: z.literal('1'),
+    wake: z.object({
+        wakeId: Id,
+        status: z.string().min(1),
+        runtimeReceiptId: Id.nullable(),
+        matchedAt: Timestamp,
+    }).strict(),
+    target: z.object({
+        runtime: z.string().min(1),
+        kind: z.string().min(1),
+        id: Id,
+    }).strict(),
+    trigger: z.object({
+        triggerId: Id,
+        version: z.string().min(1),
+        description: z.string().nullable(),
+        expression: z.record(z.string(), z.unknown()),
+        lifecycle: z.record(z.string(), z.unknown()),
+    }).strict(),
+    continuation: ContinuationContractSchema.nullable(),
+    match: z.object({
+        matchId: Id,
+        status: z.string().min(1),
+        correlationKey: z.string().nullable(),
+        openedAt: Timestamp,
+        updatedAt: Timestamp,
+    }).strict(),
+    evidence: z.array(ActivationEvidenceSchema),
+    trust: z.object({
+        continuation: z.literal('configured_trigger_instruction'),
+        evidence: z.literal('untrusted_external_signal'),
+    }).strict(),
+}).strict();
+export function parseActivationEnvelope(value) {
+    return ActivationEnvelopeSchema.parse(value);
+}

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

@@ -8,5 +8,9 @@ export type { AppendAuditInput, } from './audit.js';
 export { mapMcpEventToLineage, } from './mapper.js';
 export type { MapMcpEventInput, } from './mapper.js';
 export { assertDecisionLineage, assertWakeLineage, } from './invariants.js';
-export { COMPOSITE_TRIGGER_PROTOCOL_VERSION, COMPOSITE_TRIGGER_SCHEMA_VERSION, StructuredPredicateSchema, TriggerClauseSchema, DerivedEventProjectionSchema, DerivedEventDefinitionSchema, DerivedEventEvidenceRefSchema, DerivedEventRecordSchema, DeterministicCorrelationSchema, SemanticCorrelationSchema, CompositeTriggerDefinitionSchema, CorrelatableEventSchema, TriggerSourceEventSchema, CompositeCorrelationDecisionSchema, TriggerMatchStatusSchema, TriggerMatchRecordSchema, parseCompositeTriggerDefinition, parseCorrelatableEvent, parseTriggerMatchRecord, parseDerivedEventRecord, } from './triggerSchemas.js';
-export type { StructuredPredicate, TriggerClause, DerivedEventDefinition, DerivedEventRecord, CompositeTriggerDefinition, CorrelatableEvent, TriggerSourceEvent, TriggerMatchRecord, CompositeCorrelationDecision, } from './triggerSchemas.js';
+export { COMPOSITE_TRIGGER_PROTOCOL_VERSION, COMPOSITE_TRIGGER_SCHEMA_VERSION, StructuredPredicateSchema, TriggerClauseSchema, ContinuationContextPolicySchema, ContinuationContractSchema, DerivedEventProjectionSchema, DerivedEventDefinitionSchema, DerivedEventEvidenceRefSchema, DerivedEventRecordSchema, DeterministicCorrelationSchema, SemanticCorrelationSchema, CompositeTriggerDefinitionSchema, CorrelatableEventSchema, TriggerSourceEventSchema, CompositeCorrelationDecisionSchema, TriggerMatchStatusSchema, TriggerMatchRecordSchema, parseCompositeTriggerDefinition, parseCorrelatableEvent, parseTriggerMatchRecord, parseDerivedEventRecord, } from './triggerSchemas.js';
+export type { StructuredPredicate, TriggerClause, ContinuationContextPolicy, ContinuationContract, DerivedEventDefinition, DerivedEventRecord, CompositeTriggerDefinition, CorrelatableEvent, TriggerSourceEvent, TriggerMatchRecord, CompositeCorrelationDecision, } from './triggerSchemas.js';
+export { TriggerPlanEventSchema, TriggerPlanMatchSchema, TriggerPlanInputSchema, parseTriggerPlanInput, } from './triggerPlanSchemas.js';
+export type { TriggerPlanEvent, TriggerPlanMatch, TriggerPlanInput, } from './triggerPlanSchemas.js';
+export { ActivationEvidenceSchema, ActivationEnvelopeSchema, parseActivationEnvelope, } from './activationSchemas.js';
+export type { ActivationEvidence, ActivationEnvelope, } from './activationSchemas.js';

package/dist/src/intelligenceProtocol/index.js

@@ -5,4 +5,6 @@ export { canonicalJson, sha256Hex, } from './canonical.js';
 export { AuditChain, } from './audit.js';
 export { mapMcpEventToLineage, } from './mapper.js';
 export { assertDecisionLineage, assertWakeLineage, } from './invariants.js';
-export { COMPOSITE_TRIGGER_PROTOCOL_VERSION, COMPOSITE_TRIGGER_SCHEMA_VERSION, StructuredPredicateSchema, TriggerClauseSchema, DerivedEventProjectionSchema, DerivedEventDefinitionSchema, DerivedEventEvidenceRefSchema, DerivedEventRecordSchema, DeterministicCorrelationSchema, SemanticCorrelationSchema, CompositeTriggerDefinitionSchema, CorrelatableEventSchema, TriggerSourceEventSchema, CompositeCorrelationDecisionSchema, TriggerMatchStatusSchema, TriggerMatchRecordSchema, parseCompositeTriggerDefinition, parseCorrelatableEvent, parseTriggerMatchRecord, parseDerivedEventRecord, } from './triggerSchemas.js';
+export { COMPOSITE_TRIGGER_PROTOCOL_VERSION, COMPOSITE_TRIGGER_SCHEMA_VERSION, StructuredPredicateSchema, TriggerClauseSchema, ContinuationContextPolicySchema, ContinuationContractSchema, DerivedEventProjectionSchema, DerivedEventDefinitionSchema, DerivedEventEvidenceRefSchema, DerivedEventRecordSchema, DeterministicCorrelationSchema, SemanticCorrelationSchema, CompositeTriggerDefinitionSchema, CorrelatableEventSchema, TriggerSourceEventSchema, CompositeCorrelationDecisionSchema, TriggerMatchStatusSchema, TriggerMatchRecordSchema, parseCompositeTriggerDefinition, parseCorrelatableEvent, parseTriggerMatchRecord, parseDerivedEventRecord, } from './triggerSchemas.js';
+export { TriggerPlanEventSchema, TriggerPlanMatchSchema, TriggerPlanInputSchema, parseTriggerPlanInput, } from './triggerPlanSchemas.js';
+export { ActivationEvidenceSchema, ActivationEnvelopeSchema, parseActivationEnvelope, } from './activationSchemas.js';

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

@@ -0,0 +1,158 @@
+import { z } from 'zod';
+export declare const TriggerPlanEventSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    event: z.ZodString;
+    serverId: z.ZodOptional<z.ZodString>;
+    where: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        path: z.ZodString;
+        op: z.ZodLiteral<"eq">;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strip>, z.ZodObject<{
+        path: z.ZodString;
+        op: z.ZodLiteral<"neq">;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strip>, 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<"in">;
+        value: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, 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<"gt">;
+        value: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        path: z.ZodString;
+        op: z.ZodLiteral<"gte">;
+        value: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        path: z.ZodString;
+        op: z.ZodLiteral<"lt">;
+        value: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        path: z.ZodString;
+        op: z.ZodLiteral<"lte">;
+        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>;
+    description: z.ZodOptional<z.ZodString>;
+    events: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        event: z.ZodString;
+        serverId: z.ZodOptional<z.ZodString>;
+        where: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            path: z.ZodString;
+            op: z.ZodLiteral<"eq">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strip>, z.ZodObject<{
+            path: z.ZodString;
+            op: z.ZodLiteral<"neq">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strip>, 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<"in">;
+            value: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        }, 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<"gt">;
+            value: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            path: z.ZodString;
+            op: z.ZodLiteral<"gte">;
+            value: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            path: z.ZodString;
+            op: z.ZodLiteral<"lt">;
+            value: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            path: z.ZodString;
+            op: z.ZodLiteral<"lte">;
+            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>;
+    lifecycle: z.ZodOptional<z.ZodObject<{
+        oneShot: z.ZodOptional<z.ZodBoolean>;
+        maxFirings: z.ZodOptional<z.ZodNumber>;
+        cooldownMs: z.ZodOptional<z.ZodNumber>;
+        expiresAt: z.ZodOptional<z.ZodString>;
+        leaseUntil: z.ZodOptional<z.ZodString>;
+        completeOnGoal: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    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>;
+    continuation: z.ZodObject<{
+        instruction: z.ZodString;
+        contextPolicy: z.ZodDefault<z.ZodObject<{
+            evidence: z.ZodDefault<z.ZodEnum<{
+                matched_events: "matched_events";
+                refs_only: "refs_only";
+            }>>;
+            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>;
+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

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { RuntimeTargetSchema } from './schemas.js';
+import { ContinuationContractSchema, SemanticCorrelationSchema, StructuredPredicateSchema, } from './triggerSchemas.js';
+const Id = z.string().min(1).max(200);
+export const TriggerPlanEventSchema = z.object({
+    id: Id.optional(),
+    event: z.string().min(1),
+    serverId: Id.optional(),
+    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'),
+    withinMs: z.number().int().positive().max(1000 * 60 * 60 * 24 * 30)
+        .default(60 * 60 * 1000),
+    lifecycle: z.object({
+        oneShot: z.boolean().optional(),
+        maxFirings: z.number().int().min(1).optional(),
+        cooldownMs: z.number().int().nonnegative().optional(),
+        expiresAt: z.string().datetime({ offset: true }).optional(),
+        leaseUntil: z.string().datetime({ offset: true }).optional(),
+        completeOnGoal: z.boolean().optional(),
+    }).strict().optional(),
+    target: RuntimeTargetSchema,
+    continuation: ContinuationContractSchema,
+    correlateBy: z.array(z.object({
+        eventId: Id,
+        path: z.string().min(1),
+    }).strict()).min(2).optional(),
+    semanticCorrelation: SemanticCorrelationSchema.optional(),
+}).strict();
+export function parseTriggerPlanInput(value) {
+    return TriggerPlanInputSchema.parse(value);
+}