mcp-event-intelligence 0.2.1 → 0.3.1

package/CHANGELOG.md

@@ -2,6 +2,70 @@
 
 All notable public changes are documented here.
 
+## [0.3.1] - 2026-09-20
+
+Public-polish and reliability patch before wider distribution.
+
+### Reliability
+
+- fixed the lease-claim test cleanup race that could surface intermittent `ENOTEMPTY` errors while an in-flight worker was still writing;
+- added repeated direct lease-claim contention coverage and full coordinator contention stress coverage.
+
+### Documentation and public surface
+
+- refreshed Security Policy and Security Model for scoped multi-tenant hosts, Activation Envelopes and the v0.3 agent-friendly planning flow;
+- clarified the distinction between package version 0.3.x and the intentionally compatible internal protocol/schema v0.1 identifiers;
+- refreshed Architecture and Protocol docs for `planTrigger()`, continuation contracts and wake hydration;
+- updated MCP Registry docs to reflect the package and Registry as live, not deferred;
+- updated the CLI help banner;
+- removed the obsolete one-shot v0.1.0 release workflow.
+
+## [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.

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.1-5b5bd6)](https://registry.modelcontextprotocol.io/?q=io.github.sarooo17%2Fevent-intelligence)
+[![MCP Registry](https://img.shields.io/badge/MCP%20Registry-v0.3.1-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
 
@@ -154,7 +203,7 @@ 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
 
@@ -182,7 +231,11 @@ production ERP connector itself.
 ### 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.
@@ -247,11 +300,11 @@ Event Intelligence has one optional AI boundary: **semantic correlation**.
 - embedded hosts may inject a compatible `semanticEvaluator` instead.
 - there is no bundled OpenAI planner and no OpenAI API dependency.
 
-The agent/harness is already responsible for reasoning and can author a structured trigger directly from `event_sources_list` / the discovered schemas. Deterministic correlation, temporal logic, persistence, derived events and wake delivery require no model API.
+The agent/harness is already responsible for natural-language reasoning. It can use `trigger_plan` / `planTrigger()` to compile common requests deterministically against discovered source schemas, or submit a canonical trigger definition directly for advanced cases. Deterministic correlation, temporal logic, persistence, derived events and wake delivery require no model API.
 
 ## 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;
@@ -297,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.1 .
 
 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.1
 ```
 
 ## Optional MCP control plane
@@ -314,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.
 
@@ -367,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
 
@@ -392,7 +445,7 @@ io.github.sarooo17/event-intelligence
 
 ## Project status
 
-**v0.1 reference implementation / experimental.**
+**v0.3.x 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/SECURITY.md

@@ -2,12 +2,12 @@
 
 ## Supported versions
 
-The public reference implementation is currently pre-1.0.
+The public package is pre-1.0. Security fixes are supported on the current 0.3.x line.
 
 | Version | Supported |
 | --- | --- |
-| 0.1.x | Yes |
-| < 0.1 | No |
+| 0.3.x | Yes |
+| < 0.3 | No |
 
 ## Reporting a vulnerability
 
@@ -26,17 +26,21 @@ Useful reports include:
 
 ## Security boundaries
 
-Event Intelligence v0.1 is a reference implementation, not a hardened multi-tenant hosted service.
+Event Intelligence 0.3.x is an experimental reference implementation with scoped multi-tenant host support. It is not a turnkey hardened hosted service.
 
 Important defaults and constraints:
 
-- protected control-plane endpoints require `SERVICE_AUTH_TOKEN`;
+- tenant/workspace isolation is implemented through scoped store partitions; tenant-facing code should receive only the corresponding scoped host view;
+- protected standalone control-plane endpoints require `SERVICE_AUTH_TOKEN`;
 - GitHub ingress verifies provider HMAC when configured;
-- runtime wake packets are HMAC-signed and runtime targets are operator-configured;
+- standalone runtime wake packets are HMAC-signed and runtime targets are operator-configured;
+- embedded wakes preserve the configured continuation separately from untrusted matched-event evidence;
+- event receipt never grants new downstream authorization;
 - arbitrary public HTTP wake targets are rejected;
 - derived-event lineage is refs-only by default;
 - audit records are hash-linked and tamper-evident, not tamper-proof;
-- the JSONL store is single-writer and not safe for horizontal multi-replica deployment;
+- the bundled JSONL store is single-process reference infrastructure and is not safe as a shared multi-replica backend;
+- horizontally scaled custom stores must preserve scope isolation and implement wake claim/lease operations atomically;
 - secrets belong in environment variables / secret managers, never committed files.
 
 See `docs/SECURITY-MODEL.md` for the architectural model.

package/bin/mcp-event-intelligence.mjs

@@ -4,12 +4,12 @@ const args = process.argv.slice(2);
 const flags = new Set(args);
 
 if (flags.has('--version') || flags.has('-v')) {
-  console.log('0.2.1');
+  console.log('0.3.1');
   process.exit(0);
 }
 
 if (flags.has('--help') || flags.has('-h')) {
-  console.log(`MCP Event Intelligence v0.1
+  console.log(`MCP Event Intelligence v0.3
 
 Durable temporal event intelligence for sleeping agents.
 

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);
+}