mcp-event-intelligence 0.4.0 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,105 @@
 # Changelog
 
+## [0.6.0] - 2026-09-30
+
+Breaking architecture cleanup: Pattern AST is now the single trigger model.
+
+### Single canonical execution model
+
+- remove the pre-Pattern `expression + temporal + correlation` trigger representation;
+- remove `semanticCorrelation` and route semantic reasoning exclusively through explicit Pattern `semantic` nodes;
+- remove the legacy compiler and the parallel legacy execution path;
+- remove the direct single-event `EventProcessor`/semantic-condition wake path;
+- make persisted triggers `clauses + pattern + lifecycle/effect`;
+- make `TriggerPlanInput.pattern` the only advanced authoring surface, with simple plans deterministically compiling to Pattern automatically;
+- expose Pattern directly through activation and inspection surfaces.
+
+### Protocol and runtime
+
+- bump internal Event Intelligence protocol/schema to `0.2.0` / `ei.v0.2`;
+- bump composite trigger schema to `trigger.v0.2`;
+- Activation Envelope v2 carries canonical Pattern and partition state;
+- rename match correlation state to partition state where it represents Pattern partition identity;
+- keep Pattern wire grammar `version: "2"` as a schema version, not a second runtime architecture.
+
+### Production hardening
+
+- add reproducible Pattern conformance and benchmark evidence;
+- define explicit shared-store capabilities and fail closed when a backend cannot guarantee required distributed semantics;
+- add durable semantic-decision caching tied to evaluator identity, trigger revision and immutable candidate-event identity;
+- make authoritative runtime/store reads Promise-compatible for real database adapters;
+- align embedded host, MCP control-plane and inspector surfaces with async authoritative reads;
+- keep the bundled JSONL store explicitly single-process and reference-grade.
+
+### Documentation and release surface
+
+- rewrite README, Quickstart, Architecture and Protocol around the single Pattern runtime;
+- remove current documentation claims of legacy trigger compatibility;
+- align CLI, npm package metadata and MCP Registry metadata on v0.6.0.
+
+### Breaking change
+
+Persisted pre-v0.6 trigger definitions are intentionally not accepted by the v0.6 runtime. Historical release notes remain unchanged as history; runtime compatibility code does not.
+
+## [0.5.0] - 2026-09-30
+
+### Pattern AST v2 / advanced CEP
+
+- add additive recursive Pattern AST v2 while keeping legacy composite triggers executable;
+- add nested `allOf` / `anyOf` / `sequence`, explicit `next` / `followedBy` / `followedByAny` contiguity, repeat/optional quantifiers and greedy/lazy matching;
+- add bounded negative patterns (`notNext`, `notFollowedBy`) and first-class calendar/absence/debounce/rate/distinct temporal nodes;
+- add within/sliding/tumbling/hopping/session/count windows;
+- add cross-event arithmetic comparisons plus startsWith/endsWith/regex/notIn/between/isNull/type predicates;
+- add sum/avg/min/max/count/countDistinct/first/last/nth/stddev/percentile aggregates and derived-event measures;
+- add changed/changedFrom/increasedBy/decreasedBy/delta/percentChange/stableFor/crossesAbove/crossesBelow state operators;
+- add partitioned durable CEP buffers, overlap/after-match selection policies, bounded candidate budgets and bounded event-time retention;
+- add vendor-neutral first-class `semantic` nodes behind `SemanticEvaluator`; TypeSafe Jev remains optional and explicit;
+- enforce per-node semantic timeout, trigger-level semantic-evaluation budgets and audit every semantic decision, including rejects;
+- validate Pattern v2 refs, partition dimensions, durations, payload paths and derived measures against live source contracts;
+- add `compileLegacyTriggerToPatternV2()` for compatibility/migration and differential verification;
+- expose the complete v2 language through `describeTriggerLanguage()` / `trigger_language_describe`;
+- add end-to-end coverage for advanced predicates, quantifiers, contiguity, windows, arithmetic, state, semantic evaluation, partition isolation, negative deadlines and derived measures.
+
+### Event-time correctness
+
+- preserve host `receivedAt` separately from provider `occurredAt` through correlation evidence, derived lineage and activation hydration;
+- sequence and window evaluation no longer depend on delivery order;
+- partial matches are selected by compatible event-time span and can be re-anchored when an earlier event arrives late;
+- add explicit `eventTime.allowedLatenessMs` watermarks for bounded late-event tolerance;
+- events older than the watermark may finish retained compatible partials but cannot seed stale windows;
+- late events outside `withinMs` are isolated instead of creating false composite matches.
+
+### Agent authoring language
+
+- add a versioned, self-describing trigger operator registry;
+- add embedded `host.describeTriggerLanguage()` / scoped discovery;
+- add non-mutating MCP `trigger_language_describe` with category/operator filtering;
+- make the MCP `trigger_plan` tool reuse the package's canonical `TriggerPlanInputSchema` instead of maintaining a duplicate input schema;
+- expose all canonical temporal operators through `TriggerPlanInput.temporal`;
+- validate temporal event references and `distinct.path` against live source schemas before compilation;
+- add registry/schema parity tests so supported operators cannot silently drift out of the agent-visible catalog.
+
+### Trigger composition
+
+- add explicit `conditionOnly: true` programs with no runtime target, continuation or derived output;
+- agent-friendly planning can compile condition-only programs;
+- identical active `(connection, event, arguments)` clauses share one upstream MCP EventSubscription with observable local fan-out count.
+
+### MCP Events compatibility
+
+- external draft assumptions are centralized behind a versioned compatibility profile instead of being spread through the runtime;
+- the current default profile remains the 2026-09-25 experimental extension snapshot;
+- host-owned/embedded integration remains the primary architecture; standalone/provider-native paths are compatibility surfaces, not a new deployment requirement.
+
+
+### Compatibility
+
+- Pattern AST v2 is additive; legacy composite/temporal triggers remain executable unchanged;
+- the internal persisted Event Intelligence protocol/schema identifiers remain on the v0.1 compatibility line;
+- `compileLegacyTriggerToPatternV2()` is available for migration/differential verification without forcing existing persisted triggers to rewrite;
+- MCP Events remains experimental and isolated behind the versioned compatibility profile.
+
+
 ## [0.4.0] - 2026-09-25
 
 Current MCP Events draft alignment.

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.4.0-5b5bd6)](https://registry.modelcontextprotocol.io/?q=io.github.sarooo17%2Fevent-intelligence)
+[![MCP Registry](https://img.shields.io/badge/MCP%20Registry-v0.6.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.
@@ -19,7 +19,7 @@ An agent can express an intent such as:
 
 > When this PR is merged, the production deploy succeeds, and no error is observed for 10 minutes, wake this task and review the release.
 
-Event Intelligence persists that continuation independently of the model, waits for the world to satisfy it, and wakes the host only when necessary.
+Event Intelligence persists the future condition independently of the model, waits for the world to satisfy it, and wakes the host only when the condition has an activation target. Conditions may also exist without an agent continuation; higher-level facts are composed separately through derived-event triggers.
 
 ## Embed it in an existing agent host
 
@@ -59,7 +59,23 @@ Event Intelligence enumerates the host registry automatically. GitHub, Gmail, pr
 
 ### 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:
+Agents do not need a second DSL or a model-specific planner. The public authoring path is:
+
+```text
+event_sources_list
+        ↓
+trigger_language_describe   (only when grammar discovery is useful)
+        ↓
+trigger_plan
+        ↓
+Pattern AST definition
+        ↓
+trigger_create
+```
+
+`planTrigger()` is deterministic: it resolves live event sources, fills `serverId`, validates subscription arguments and predicate/pattern field paths against advertised schemas, and returns the canonical trigger definition plus the required connection IDs.
+
+For a simple condition, omitting `pattern` produces an `allOf` Pattern over the declared events:
 
 ```js
 const plan = await ei.planTrigger({
@@ -70,7 +86,6 @@ const plan = await ei.planTrigger({
       { path: 'grand_total', op: 'gt', value: 10000 },
     ],
   }],
-  match: 'all',
   withinMs: 60 * 60 * 1000,
   target: {
     runtime: 'agent',
@@ -82,27 +97,84 @@ const plan = await ei.planTrigger({
       'Check the submitted invoice for anomalies and report back in this conversation.',
   },
 });
+```
 
-await ei.triggerControl.createTrigger({
-  definition: plan.definition,
-  connectionIds: plan.connectionIds,
-  actor,
-  owner,
+For advanced CEP, author the same canonical `pattern` directly:
+
+```js
+const language = ei.describeTriggerLanguage({ category: 'pattern' });
+
+const plan = await ei.planTrigger({
+  events: [
+    { id: 'order', event: 'erpnext.sales_order.created' },
+    { id: 'failure', event: 'payments.failed' },
+    { id: 'ticket', event: 'support.ticket.created' },
+  ],
+  withinMs: 30 * 60 * 1000,
+  pattern: {
+    version: '2',
+    partitionBy: [{
+      key: 'customer',
+      fields: [
+        { ref: 'order', path: 'customer' },
+        { ref: 'failure', path: 'customer' },
+        { ref: 'ticket', path: 'customer' },
+      ],
+    }],
+    root: {
+      kind: 'aggregate',
+      function: 'sum',
+      ref: 'order',
+      path: 'grand_total',
+      op: 'gte',
+      value: 10000,
+      child: {
+        kind: 'sequence',
+        contiguity: 'followedBy',
+        children: [
+          { kind: 'event', ref: 'order' },
+          {
+            kind: 'repeat',
+            child: { kind: 'event', ref: 'failure' },
+            min: 2,
+            max: 5,
+            mode: 'greedy',
+          },
+          {
+            kind: 'optional',
+            child: { kind: 'event', ref: 'ticket' },
+            mode: 'greedy',
+          },
+        ],
+      },
+    },
+  },
+  target: {
+    runtime: 'agent',
+    kind: 'conversation',
+    id: 'chat-42',
+  },
+  continuation: {
+    instruction: 'Review this customer payment-risk pattern.',
+  },
 });
 ```
 
-`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.
+Pattern AST is the **single canonical trigger execution model**. It covers nested boolean and sequence patterns, contiguity, repeat/optional quantifiers, bounded negative patterns, calendar/absence/debounce/rate/distinct semantics, event-time windows, cross-event comparisons and arithmetic, aggregates, state transitions, partitioning, match-selection policy and deterministic derived measures.
+
+The wire schema currently identifies this grammar as `version: "2"`; that is a schema version, not a second execution architecture.
+
+The runtime is **deterministic first**. A first-class `semantic` node is available only when structural data cannot express the condition reliably. It is vendor-neutral and calls the configured `SemanticEvaluator`; the bundled TypeSafe Jev adapter is optional when `TYPESAFE_API_KEY` is present. Semantic calls are explicit, bounded, timed out, cacheable and audit-recorded; ordinary CEP execution requires no model API.
 
-The persisted `continuation` answers a separate question from the trigger condition: **what should the agent do after the future condition becomes true?**
+The persisted `continuation` answers a separate question from the trigger condition: **what should the agent do after the future condition becomes true?** A trigger can instead set `conditionOnly: true` and persist only the condition state, with no runtime target or continuation.
 
 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);
+const activation = await 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`.
-
+The envelope contains the configured continuation, canonical Pattern, 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
 
@@ -118,7 +190,7 @@ await tenant.triggerControl.createTrigger({
   owner,
 });
 
-const acmeConnections = tenant.mcpStatus();
+const acmeConnections = await tenant.mcpStatus();
 ```
 
 The default reference store physically namespaces non-default scopes under separate persistent store partitions. Trigger IDs, match IDs, cursors, event sources, deadlines, derived events and wake delivery state are therefore resolved inside a scope rather than filtered out of a global result after the fact. The root host object is the trusted operator/control-plane capability; tenant code should receive a scoped view.
@@ -203,7 +275,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.4 implements
+## What v0.6 implements
 
 ### Host-owned event sources
 
@@ -215,6 +287,7 @@ production ERP connector itself.
 - `events/poll` with server-directed `nextPollMs`, nullable cursors and bounded page draining;
 - host-owned push and webhook delivery adapters feeding the same EventOccurrence pipeline;
 - persistent opaque cursors and per-subscription delivery state;
+- shared upstream subscriptions fan out to every active trigger using the same `(connection, event, arguments)` tuple;
 - per-scope source/cursor isolation for shared hosts;
 - single-flight polling per connection plus bounded `hasMore` batch draining;
 - automatic event-source registration;
@@ -244,7 +317,7 @@ Poll, push and webhook are treated only as delivery mechanisms. All three normal
 - event-source discovery;
 - agent-friendly deterministic trigger planning/compilation;
 - MCP subscription `arguments` validated against each source `inputSchema`, kept distinct from EI payload predicates;
-- `eq`, `neq`, `contains`, `in`, `exists`, `gt`, `gte`, `lt`, `lte` predicates;
+- structured predicates including `eq`, `neq`, `contains`, `startsWith`, `endsWith`, `regex`, `in`, `notIn`, `between`, `exists`, `isNull`, `type`, `gt`, `gte`, `lt`, `lte`;
 - persisted continuation contracts separated from trigger conditions;
 - Activation Envelope hydration with matched event evidence;
 - embedded wake callbacks receive `(packet, activation)`;
@@ -306,17 +379,19 @@ This project does **not** propose a replacement for MCP Events and does not clai
 
 ## AI and API keys
 
-Event Intelligence has one optional AI boundary: **semantic correlation**.
+Event Intelligence has one optional AI boundary: **explicit semantic evaluation**.
 
-- `TYPESAFE_API_KEY` enables the bundled TypeSafe Jev evaluator when a trigger explicitly requests semantic correlation.
+- Pattern AST exposes a vendor-neutral `semantic` node as the only semantic condition form.
+- `TYPESAFE_API_KEY` enables the bundled TypeSafe Jev evaluator when a trigger explicitly requests semantic evaluation.
 - embedded hosts may inject a compatible `semanticEvaluator` instead.
+- deterministic predicates, patterns, windows, aggregations, state changes, deadlines and derived measures never require an AI evaluator.
 - there is no bundled OpenAI planner and no OpenAI API dependency.
 
 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.4 acceptance suite verifies:
+The v0.6 acceptance suite verifies:
 
 - host-owned MCP client → extension discovery → durable subscription → poll/push/webhook occurrence → composite match → in-process wake;
 - provider-neutral events → composite match → derived event → derived composition → signed runtime wake;
@@ -334,7 +409,9 @@ The v0.4 acceptance suite verifies:
 
 A separate live regression also verified real GitHub webhook ingress into the MCP EventOccurrence / composite fan-in path.
 
-## Standalone reference service
+## Reference/debug service
+
+The HTTP service remains useful for local development, conformance work and provider-native regression tests. It is **not** the primary integration model and does not replace the embedded host-owned package path above.
 
 ### Requirements
 
@@ -362,13 +439,13 @@ The standalone service supports manual/provider-native event ingress. It does no
 ### Docker
 
 ```bash
-docker build -t mcp-event-intelligence:0.4.0 .
+docker build -t mcp-event-intelligence:0.6.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.4.0
+  mcp-event-intelligence:0.6.0
 ```
 
 ## Optional MCP control plane
@@ -414,7 +491,11 @@ The detailed execution model, clocks, lifecycle, persistence and trust boundarie
 
 ### Event-time vs processing-time
 
-Normal event windows use event `occurredAt`.
+Normal event windows use event `occurredAt`; MCP ingress also preserves host `receivedAt` when available. Delivery order does not define event order.
+
+Out-of-order events are matched against compatible event-time windows. A late event may re-anchor a partial match to an earlier `occurredAt` only when the complete event-time span still fits `withinMs`; otherwise it starts a separate partial window and cannot create a false sequence.
+
+Triggers may set `eventTime.allowedLatenessMs` (default `0`). EI maintains an event-time watermark per trigger/correlation stream: old partial windows are retained until their expiry falls behind `maxObservedEventTime - allowedLatenessMs`. An event older than the watermark can still complete a retained compatible partial, but cannot seed a new stale window.
 
 Absence/deadline progression uses Event Intelligence processing time. This separation is explicit and tested.
 
@@ -432,7 +513,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.3 intentionally does not implement a mutable current-state/facts database.
+Event Intelligence intentionally does not implement a mutable current-state/facts database.
 
 ## Security
 
@@ -457,7 +538,7 @@ io.github.sarooo17/event-intelligence
 
 ## Project status
 
-**v0.4.x reference implementation / experimental.**
+**v0.6.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 package is pre-1.0. Security fixes are supported on the current 0.3.x line.
+The public package is pre-1.0. Security fixes are supported on the current 0.6.x line.
 
 | Version | Supported |
 | --- | --- |
-| 0.3.x | Yes |
-| < 0.3 | No |
+| 0.6.x | Yes |
+| < 0.6 | No |
 
 ## Reporting a vulnerability
 
@@ -26,7 +26,7 @@ Useful reports include:
 
 ## Security boundaries
 
-Event Intelligence 0.3.x is an experimental reference implementation with scoped multi-tenant host support. It is not a turnkey hardened hosted service.
+Event Intelligence 0.6.x is an experimental reference implementation with scoped multi-tenant host support. It is not a turnkey hardened hosted service.
 
 Important defaults and constraints:
 

package/bin/mcp-event-intelligence.mjs

@@ -4,14 +4,14 @@ const args = process.argv.slice(2);
 const flags = new Set(args);
 
 if (flags.has('--version') || flags.has('-v')) {
-  console.log('0.4.0');
+  console.log('0.6.0');
   process.exit(0);
 }
 
 if (flags.has('--help') || flags.has('-h')) {
-  console.log(`MCP Event Intelligence v0.4
+  console.log(`MCP Event Intelligence v0.6
 
-Durable temporal event intelligence for sleeping agents.
+MCP-native complex event processing for durable agents.
 
 Usage:
   mcp-event-intelligence          Start the HTTP reference service

package/dist/src/composite/engine.d.ts

@@ -8,19 +8,29 @@ export interface CompositeIngestResult {
     matched: boolean;
     fired: boolean;
 }
+export interface CompositeTriggerEngineOptions {
+    workerId?: string;
+    partitionLeaseMs?: number;
+}
 export declare class CompositeTriggerEngine {
     private readonly store;
     private readonly evaluator;
     private readonly now;
     private readonly support;
-    constructor(store: CompositeTriggerStore & CompositeTriggerAudit, evaluator?: SemanticEvaluator | null, now?: () => Date);
+    private readonly workerId;
+    private readonly partitionLeaseMs;
+    constructor(store: CompositeTriggerStore & CompositeTriggerAudit, evaluator?: SemanticEvaluator | null, now?: () => Date, options?: CompositeTriggerEngineOptions);
     register(definitionInput: unknown): Promise<CompositeTriggerDefinition>;
     ingest(eventInput: unknown): Promise<CompositeIngestResult[]>;
     markFired(matchId: string, wakeId: string): Promise<TriggerMatchRecord>;
     markDerivedEmitted(matchId: string, derivedEventId: string): Promise<TriggerMatchRecord>;
     private ingestTimerEvent;
-    private applyEvent;
-    private finalizeEligible;
-    private newMatch;
+    private patternPartitionKey;
+    private patternBufferId;
+    private patternDecisionRecord;
+    private applyPattern;
+    private applyPatternWithPartition;
+    private candidateFitsTriggerWindow;
+    private evaluatePatternBuffer;
     private latestMatch;
 }