mcp-event-intelligence 0.4.0 → 0.6.0

package/scripts/lib/trigger-inspector.mjs

@@ -1,9 +1,6 @@
 import {
   CompositeTriggerEngine,
 } from '../../dist/src/composite/engine.js';
-import {
-  evaluateTemporalConditions,
-} from '../../dist/src/composite/temporal.js';
 import {
   parseCompositeTriggerDefinition,
   parseCorrelatableEvent,
@@ -11,8 +8,19 @@ import {
 } from '../../dist/src/intelligenceProtocol/index.js';
 
 function latest(records) {
+  const rank = (record) => {
+    if (record.status === 'fired') return 5;
+    if (record.status === 'emitted') return 4;
+    if (record.status === 'matched') return 3;
+    if (record.status === 'partial' && record.patternState?.role === 'match') return 2;
+    if (record.status === 'partial') return 1;
+    return 0;
+  };
+
   return [...records].sort(
-    (a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt),
+    (a, b) =>
+      Date.parse(b.updatedAt) - Date.parse(a.updatedAt) ||
+      rank(b) - rank(a),
   )[0] ?? null;
 }
 
@@ -32,12 +40,6 @@ function sourceRef(event) {
   };
 }
 
-function baseExpressionRefs(expression) {
-  return expression.kind === 'count'
-    ? [expression.ref]
-    : expression.refs;
-}
-
 function clauseState(definition, match) {
   const seen = new Map();
   for (const event of match?.sourceEvents ?? []) {
@@ -48,63 +50,19 @@ function clauseState(definition, match) {
 
   return definition.clauses.map((clause) => {
     const evidence = seen.get(clause.id) ?? [];
-    const requiredCount =
-      definition.expression.kind === 'count' &&
-      definition.expression.ref === clause.id
-        ? definition.expression.atLeast
-        : 1;
     return {
       clauseId: clause.id,
       event: clause.event,
       serverId: clause.serverId ?? null,
       contractVersion: clause.contractVersion ?? null,
-      status: evidence.length >= requiredCount ? 'satisfied' : 'waiting',
+      status: evidence.length ? 'observed' : 'waiting',
       observedCount: evidence.length,
-      requiredCount,
       evidence,
     };
   });
 }
 
-function baseExpressionSatisfied(definition, clauses) {
-  const byId = new Map(clauses.map((entry) => [entry.clauseId, entry]));
-  const expression = definition.expression;
-  if (expression.kind === 'allOf') {
-    return expression.refs.every(
-      (ref) => byId.get(ref)?.status === 'satisfied',
-    );
-  }
-  if (expression.kind === 'anyOf') {
-    return expression.refs.some(
-      (ref) => byId.get(ref)?.status === 'satisfied',
-    );
-  }
-  if (expression.kind === 'count') {
-    return (byId.get(expression.ref)?.observedCount ?? 0) >= expression.atLeast;
-  }
-
-  const ordered = [];
-  for (const ref of expression.refs) {
-    const evidence = byId.get(ref)?.evidence ?? [];
-    if (!evidence.length) return false;
-    ordered.push(evidence[0]);
-  }
-  return ordered.every(
-    (event, index) =>
-      index === 0 ||
-      Date.parse(event.occurredAt) >
-        Date.parse(ordered[index - 1].occurredAt),
-  );
-}
-
-function explain({
-  definition,
-  state,
-  match,
-  clauses,
-  temporal,
-  wake,
-}) {
+function explain({ state, match, wake }) {
   if (state.status === 'paused') {
     return {
       code: 'trigger_paused',
@@ -132,8 +90,9 @@ function explain({
 
   if (!match) {
     return {
-      code: 'waiting_for_first_event',
-      summary: `Waiting for: ${baseExpressionRefs(definition.expression).join(', ')}.`,
+      code: 'waiting_for_pattern_evidence',
+      summary: 'Waiting for evidence that can satisfy the Pattern AST.',
+      patternVersion: '2',
     };
   }
 
@@ -156,53 +115,22 @@ function explain({
   if (match.status === 'matched') {
     return {
       code: 'matched_waiting_delivery',
-      summary: 'All trigger conditions are satisfied; runtime delivery is pending or not yet marked fired.',
+      summary: 'The Pattern AST is satisfied; effect delivery is pending or not yet marked fired.',
     };
   }
   if (match.status === 'expired') {
     return {
       code: 'match_expired',
-      summary: 'This match can no longer satisfy the trigger.',
-    };
-  }
-
-  const missing = clauses
-    .filter((clause) => clause.status !== 'satisfied')
-    .map((clause) => clause.clauseId);
-
-  if (!baseExpressionSatisfied(definition, clauses)) {
-    return {
-      code: 'waiting_for_event_clauses',
-      summary: `Waiting for event clauses: ${missing.join(', ') || 'expression ordering'}.`,
-      missingClauses: missing,
-    };
-  }
-
-  const blocked = temporal.conditionStates.filter(
-    (condition) => condition.status === 'blocked',
-  );
-  if (blocked.length) {
-    return {
-      code: 'temporal_blocked',
-      summary: `Temporal condition blocked: ${blocked.map((entry) => entry.conditionId).join(', ')}.`,
-      temporalConditionIds: blocked.map((entry) => entry.conditionId),
-    };
-  }
-
-  const pending = temporal.conditionStates.filter(
-    (condition) => condition.status === 'pending',
-  );
-  if (pending.length) {
-    return {
-      code: 'waiting_for_temporal_conditions',
-      summary: `Waiting for temporal conditions: ${pending.map((entry) => entry.conditionId).join(', ')}.`,
-      temporalConditionIds: pending.map((entry) => entry.conditionId),
+      summary: 'This Pattern match can no longer satisfy the trigger.',
     };
   }
 
   return {
-    code: 'waiting_for_correlation',
-    summary: 'Event and temporal conditions are present; correlation or semantic evaluation has not completed.',
+    code: 'pattern_waiting',
+    summary: 'Pattern AST has buffered evidence but no new complete match is currently eligible.',
+    patternVersion: '2',
+    bufferRole: match.patternState?.role ?? null,
+    semanticDecisions: match.patternState?.semanticDecisions ?? [],
   };
 }
 
@@ -215,12 +143,12 @@ export class TriggerInspector {
     this.now = now;
   }
 
-  inspect({
+  async inspect({
     triggerId,
     version,
     matchId,
   }) {
-    const candidates = this.store.listTriggers()
+    const candidates = (await this.store.listTriggers())
       .filter((definition) => definition.triggerId === triggerId)
       .filter((definition) => !version || definition.version === version);
 
@@ -238,12 +166,12 @@ export class TriggerInspector {
           })
         )[0];
 
-    const state = this.store.getTriggerState(
+    const state = await this.store.getTriggerState(
       definition.triggerId,
       definition.version,
     );
 
-    const matches = this.store.listTriggerMatches(definition.triggerId)
+    const matches = (await this.store.listTriggerMatches(definition.triggerId))
       .filter((match) => match.triggerVersion === definition.version);
     const match = matchId
       ? matches.find((candidate) => candidate.matchId === matchId) ?? null
@@ -256,23 +184,8 @@ export class TriggerInspector {
     }
 
     const clauses = clauseState(definition, match);
-    const temporal = match
-      ? evaluateTemporalConditions(definition, match, this.now())
-      : {
-          outcome: definition.temporal?.length ? 'pending' : 'satisfied',
-          pendingDeadlines: [],
-          conditionStates: (definition.temporal ?? []).map((condition) => ({
-            conditionId: condition.id,
-            kind: condition.kind,
-            status: 'pending',
-            reason: 'waiting for a match',
-          })),
-        };
-
-    const deadlines = match
-      ? this.store.listTemporalDeadlines?.({
-          matchId: match.matchId,
-        }) ?? []
+    const deadlines = match && this.store.listTemporalDeadlines
+      ? await this.store.listTemporalDeadlines({ matchId: match.matchId })
       : [];
     const pendingDeadlines = deadlines.filter(
       (deadline) => deadline.status === 'pending',
@@ -282,25 +195,25 @@ export class TriggerInspector {
       .sort()[0] ?? null;
 
     const wake = match?.firedWakeId
-      ? this.store.latestWake(match.firedWakeId)
+      ? await this.store.latestWake(match.firedWakeId)
       : null;
 
     const derivedOutputs = match
-      ? (this.store.listDerivedEvents?.({ matchId: match.matchId }) ?? [])
+      ? (await this.store.listDerivedEvents?.({ matchId: match.matchId }) ?? [])
       : [];
 
-    const matchHistory = match
-      ? (this.store.listTriggerMatchHistory?.(match.matchId) ?? [match])
-          .map((record) => ({
-            status: record.status,
-            updatedAt: record.updatedAt,
-            firedWakeId: record.firedWakeId,
-            derivedEventIds: record.derivedEventIds ?? [],
-            sourceEventIds: record.sourceEvents.map(
-              (event) => event.sourceEventId,
-            ),
-          }))
-      : [];
+    const rawHistory = match && this.store.listTriggerMatchHistory
+      ? await this.store.listTriggerMatchHistory(match.matchId)
+      : (match ? [match] : []);
+    const matchHistory = rawHistory.map((record) => ({
+      status: record.status,
+      updatedAt: record.updatedAt,
+      firedWakeId: record.firedWakeId,
+      derivedEventIds: record.derivedEventIds ?? [],
+      sourceEventIds: record.sourceEvents.map(
+        (event) => event.sourceEventId,
+      ),
+    }));
 
     return {
       trigger: {
@@ -310,8 +223,7 @@ export class TriggerInspector {
         continuation: definition.continuation ?? null,
         target: definition.target ?? null,
         derivedEvent: definition.derivedEvent ?? null,
-        expression: definition.expression,
-        temporal: definition.temporal ?? [],
+        pattern: definition.pattern,
         lifecycle: definition.lifecycle ?? {},
       },
       lifecycle: state,
@@ -319,17 +231,14 @@ export class TriggerInspector {
         ? {
             matchId: match.matchId,
             status: match.status,
-            correlationKey: match.correlationKey,
+            partitionKey: match.partitionKey,
             openedAt: match.openedAt,
             expiresAt: match.expiresAt,
             updatedAt: match.updatedAt,
+            patternState: match.patternState ?? null,
           }
         : null,
       clauses,
-      temporal: {
-        outcome: temporal.outcome,
-        conditions: temporal.conditionStates,
-      },
       deadlines: deadlines.map((deadline) => ({
         deadlineId: deadline.deadlineId,
         conditionId: deadline.conditionId,
@@ -360,15 +269,9 @@ export class TriggerInspector {
           rootEvidence: record.rootEvidence,
         })),
         matchHistory,
+        patternState: match?.patternState ?? null,
       },
-      why: explain({
-        definition,
-        state,
-        match,
-        clauses,
-        temporal,
-        wake,
-      }),
+      why: explain({ state, match, wake }),
     };
   }
 }
@@ -623,7 +526,7 @@ export async function simulateTrigger({
     order,
     evaluatedUntil: clock.toISOString(),
     steps,
-    inspection: inspector.inspect({
+    inspection: await inspector.inspect({
       triggerId: definition.triggerId,
       version: definition.version,
     }),

package/scripts/lib/trigger-planner.mjs

@@ -1,5 +1,6 @@
 import {
   canonicalJson,
+  collectPatternRefs,
   parseCompositeTriggerDefinition,
   parseTriggerPlanInput,
   sha256Hex,
@@ -88,32 +89,60 @@ function validatePredicateAgainstSource(source, predicate, warnings) {
       [source],
     );
   }
+
+  if (
+    ['startsWith', 'endsWith', 'regex'].includes(predicate.op) &&
+    node?.type &&
+    node.type !== 'string'
+  ) {
+    throw sourceError(
+      'TRIGGER_PLAN_STRING_FIELD_REQUIRED',
+      `Predicate ${predicate.op} requires a string field, but ${predicate.path} is ${node.type}`,
+      [source],
+    );
+  }
 }
 
-function expressionFor(match, refs) {
-  if (typeof match === 'object' && match?.kind === 'count') {
-    if (!refs.includes(match.eventId)) {
-      const error = new Error(`Count match references unknown event id: ${match.eventId}`);
-      error.code = 'TRIGGER_PLAN_EVENT_REF_UNKNOWN';
-      throw error;
-    }
-    return { kind: 'count', ref: match.eventId, atLeast: match.atLeast };
+function walkPatternValue(value, visitor) {
+  if (!value || typeof value !== 'object') return;
+  if (value.kind === 'field') {
+    visitor(value.ref, value.path, 'pattern value');
+    return;
+  }
+  if (value.kind === 'arithmetic') {
+    for (const arg of value.args ?? []) walkPatternValue(arg, visitor);
   }
+}
+
+function walkPatternNode(node, visitor) {
+  if (!node || typeof node !== 'object') return;
 
-  if (match === 'sequence') {
-    if (refs.length < 2) {
-      const error = new Error('Sequence match requires at least two events');
-      error.code = 'TRIGGER_PLAN_SEQUENCE_REQUIRES_MULTIPLE_EVENTS';
-      throw error;
+  if (node.kind === 'compare') {
+    walkPatternValue(node.left, visitor);
+    if (node.right) walkPatternValue(node.right, visitor);
+  }
+  if (
+    (node.kind === 'aggregate' ||
+      node.kind === 'state' ||
+      node.kind === 'distinct') &&
+    node.path
+  ) {
+    visitor(node.ref, node.path, `pattern ${node.kind}`);
+  }
+  if (node.kind === 'semantic') {
+    for (const input of node.input ?? []) {
+      const [ref, ...parts] = String(input).split('.');
+      if (ref && parts.length) {
+        visitor(ref, parts.join('.'), 'pattern semantic input');
+      }
     }
-    return { kind: 'sequence', refs };
   }
 
-  if (match === 'any' || refs.length === 1) {
-    return { kind: 'anyOf', refs };
+  if (Array.isArray(node.children)) {
+    for (const child of node.children) walkPatternNode(child, visitor);
   }
-
-  return { kind: 'allOf', refs };
+  if (node.child) walkPatternNode(node.child, visitor);
+  if (node.forbidden) walkPatternNode(node.forbidden, visitor);
 }
 
 function lifecycleFor(input = {}) {
@@ -127,6 +156,31 @@ function lifecycleFor(input = {}) {
   };
 }
 
+function defaultPattern(refs) {
+  const root = refs.length === 1
+    ? { kind: 'event', ref: refs[0] }
+    : {
+        kind: 'allOf',
+        children: refs.map((ref) => ({ kind: 'event', ref })),
+      };
+
+  return {
+    version: '2',
+    root,
+    partitionBy: [],
+    selection: {
+      overlap: 'disallow',
+      afterMatch: 'skipPastLast',
+      maxMatchesPerEvent: 10,
+    },
+    execution: {
+      maxCandidates: 512,
+      maxSemanticEvaluations: 16,
+      maxBufferedEvents: 10000,
+    },
+  };
+}
+
 export class TriggerPlanner {
   constructor({ store }) {
     this.store = store;
@@ -134,7 +188,7 @@ export class TriggerPlanner {
 
   async plan(input) {
     const plan = parseTriggerPlanInput(input);
-    const activeSources = this.store.listEventSources({ enabledOnly: true });
+    const activeSources = await this.store.listEventSources({ enabledOnly: true });
     const warnings = [];
     const resolvedSources = [];
     const seenIds = new Set();
@@ -185,69 +239,101 @@ export class TriggerPlanner {
     });
 
     const refs = clauses.map((clause) => clause.id);
-    const correlation = {};
-    if (plan.correlateBy) {
-      for (const field of plan.correlateBy) {
-        if (!refs.includes(field.eventId)) {
+
+    const pattern = plan.pattern ?? defaultPattern(refs);
+    {
+      const patternRefs = collectPatternRefs(pattern.root);
+      for (const ref of patternRefs) {
+        if (!refs.includes(ref)) {
           const error = new Error(
-            `Correlation references unknown event id: ${field.eventId}`,
+            `Pattern AST references unknown event id: ${ref}`,
           );
           error.code = 'TRIGGER_PLAN_EVENT_REF_UNKNOWN';
           throw error;
         }
-        const clause = clauses.find((candidate) => candidate.id === field.eventId);
-        const source = resolvedSources[clauses.indexOf(clause)];
+      }
+
+      const sourceForRef = (ref) => {
+        const index = clauses.findIndex((candidate) => candidate.id === ref);
+        if (index < 0) {
+          const error = new Error(
+            `Pattern AST references unknown event id: ${ref}`,
+          );
+          error.code = 'TRIGGER_PLAN_EVENT_REF_UNKNOWN';
+          throw error;
+        }
+        return resolvedSources[index];
+      };
+
+      walkPatternNode(pattern.root, (ref, fieldPath, purpose) => {
         validatePredicateAgainstSource(
-          source,
-          { path: field.path, op: 'exists', value: true },
+          sourceForRef(ref),
+          { path: fieldPath, op: 'exists', value: true },
           warnings,
         );
+      });
+
+      for (const dimension of pattern.partitionBy) {
+        for (const field of dimension.fields) {
+          const clauseIndex = clauses.findIndex(
+            (candidate) => candidate.id === field.ref,
+          );
+          if (clauseIndex < 0) {
+            const error = new Error(
+              `Pattern partition references unknown event id: ${field.ref}`,
+            );
+            error.code = 'TRIGGER_PLAN_EVENT_REF_UNKNOWN';
+            throw error;
+          }
+          validatePredicateAgainstSource(
+            resolvedSources[clauseIndex],
+            { path: field.path, op: 'exists', value: true },
+            warnings,
+          );
+        }
       }
-      correlation.deterministic = {
-        kind: 'same_value',
-        fields: plan.correlateBy.map((field) => ({
-          ref: field.eventId,
-          path: field.path,
-        })),
-      };
-    }
-    if (plan.semanticCorrelation) {
-      correlation.semantic = plan.semanticCorrelation;
     }
 
+
     const triggerId = plan.triggerId || `planned_${(
       await sha256Hex(canonicalJson({
-        target: plan.target,
+        target: plan.target ?? null,
         events: plan.events,
-        match: plan.match,
-        continuation: plan.continuation.instruction,
+        pattern,
+        eventTime: plan.eventTime ?? null,
+        conditionOnly: plan.conditionOnly,
+        continuation: plan.continuation?.instruction ?? null,
       }))
     ).slice(0, 24)}`;
 
     const definition = parseCompositeTriggerDefinition({
       triggerId,
       version: plan.version,
-      description:
-        plan.description ||
-        plan.continuation.instruction.slice(0, 500),
-      continuation: plan.continuation,
+      ...(plan.description || plan.continuation?.instruction
+        ? {
+            description:
+              plan.description ||
+              plan.continuation.instruction.slice(0, 500),
+          }
+        : {}),
+      conditionOnly: plan.conditionOnly,
+      ...(plan.continuation ? { continuation: plan.continuation } : {}),
       clauses,
-      expression: expressionFor(plan.match, refs),
+      pattern,
       withinMs: plan.withinMs,
+      ...(plan.eventTime ? { eventTime: plan.eventTime } : {}),
       lifecycle: lifecycleFor(plan.lifecycle),
-      ...(Object.keys(correlation).length ? { correlation } : {}),
-      target: plan.target,
+      ...(plan.target ? { target: plan.target } : {}),
     });
 
     return {
-      planVersion: '1',
+      planVersion: '2',
       definition,
       connectionIds: [...new Set(resolvedSources.map((source) => source.connectionId))],
       resolvedSources: resolvedSources.map(sourceSummary),
       warnings,
       explanation: {
         when: {
-          expression: definition.expression,
           events: clauses.map((clause) => ({
             id: clause.id,
             event: clause.event,
@@ -255,12 +341,15 @@ export class TriggerPlanner {
             arguments: clause.arguments,
             where: clause.where,
           })),
+          pattern: definition.pattern,
           withinMs: definition.withinMs,
+          eventTime: definition.eventTime ?? { allowedLatenessMs: 0 },
         },
         then: {
-          target: definition.target,
+          conditionOnly: definition.conditionOnly,
+          target: definition.target ?? null,
           instruction: definition.continuation?.instruction ?? null,
-          evidence: definition.continuation?.contextPolicy?.evidence ?? 'matched_events',
+          evidence: definition.continuation?.contextPolicy?.evidence ?? null,
         },
       },
     };

package/scripts/lib/wake-retry-scheduler.mjs

@@ -2,13 +2,11 @@ export class WakeRetryScheduler {
   constructor({
     store,
     resolveCoordinator,
-    eventProcessor = null,
     intervalMs = 1000,
     now = () => new Date(),
   }) {
     this.store = store;
     this.resolveCoordinator = resolveCoordinator;
-    this.eventProcessor = eventProcessor;
     this.intervalMs = Math.max(100, Number(intervalMs) || 1000);
     this.now = now;
     this.timer = null;
@@ -19,25 +17,10 @@ export class WakeRetryScheduler {
     if (this.running) return [];
     this.running = true;
     try {
-      const due = this.store.listDueWakeDeliveries(this.now().toISOString());
+      const due = await this.store.listDueWakeDeliveries(this.now().toISOString());
       const outcomes = [];
 
       for (const delivery of due) {
-        if (delivery.sourceType === 'event') {
-          if (!this.eventProcessor || typeof this.eventProcessor.retryWake !== 'function') {
-            outcomes.push({
-              wakeId: delivery.wakeId,
-              status: 'event_processor_unconfigured',
-            });
-            continue;
-          }
-          const result = await this.eventProcessor.retryWake(delivery.wakeId);
-          outcomes.push({
-            wakeId: delivery.wakeId,
-            status: result.status,
-          });
-          continue;
-        }
 
         const coordinator = this.resolveCoordinator(delivery.runtime);
         if (!coordinator) {
@@ -48,7 +31,7 @@ export class WakeRetryScheduler {
           continue;
         }
 
-        const match = this.store.listTriggerMatches(delivery.triggerId)
+        const match = (await this.store.listTriggerMatches(delivery.triggerId))
           .filter((candidate) => candidate.matchId === delivery.matchId)
           .sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt))[0];