mcp-event-intelligence 0.5.0 → 0.6.1

package/scripts/lib/trigger-control-plane.mjs

@@ -163,23 +163,24 @@ export class TriggerControlPlane {
     });
   }
 
-  listEventSources({ connectionIds } = {}) {
+  async listEventSources({ connectionIds } = {}) {
     return this.store.listEventSources({
       connectionIds,
       enabledOnly: true,
     });
   }
 
-  listTriggers({ owner: ownerInput } = {}) {
+  async listTriggers({ owner: ownerInput } = {}) {
     const owner = ownerInput ? actorIdentity(ownerInput) : null;
-    return this.store.listTriggers()
-      .map((definition) => ({
-        definition,
-        state: this.store.getTriggerState(
-          definition.triggerId,
-          definition.version,
-        ),
-      }))
+    const definitions = await this.store.listTriggers();
+    const entries = await Promise.all(definitions.map(async (definition) => ({
+      definition,
+      state: await this.store.getTriggerState(
+        definition.triggerId,
+        definition.version,
+      ),
+    })));
+    return entries
       .filter((entry) => !owner || samePrincipal(entry.state.owner, owner));
   }
 
@@ -236,9 +237,9 @@ export class TriggerControlPlane {
       throw error;
     }
 
-    this.assertSourcesAvailable(definition, allowedConnectionIds);
+    await this.assertSourcesAvailable(definition, allowedConnectionIds);
 
-    if (this.store.listTriggers().some((candidate) =>
+    if ((await this.store.listTriggers()).some((candidate) =>
       candidate.triggerId === definition.triggerId &&
       candidate.version === definition.version
     )) {
@@ -321,7 +322,7 @@ export class TriggerControlPlane {
       throw error;
     }
 
-    const current = this.store.listTriggers().find(
+    const current = (await this.store.listTriggers()).find(
       (candidate) =>
         candidate.triggerId === triggerId &&
         candidate.version === expectedVersion,
@@ -334,7 +335,7 @@ export class TriggerControlPlane {
       throw error;
     }
 
-    const currentState = this.store.getTriggerState(
+    const currentState = await this.store.getTriggerState(
       triggerId,
       expectedVersion,
     );
@@ -351,16 +352,19 @@ export class TriggerControlPlane {
       throw error;
     }
 
-    const competing = this.store.listTriggers()
-      .filter((candidate) => candidate.triggerId === triggerId)
-      .find((candidate) => {
-        if (candidate.version === expectedVersion) return false;
-        const state = this.store.getTriggerState(
-          candidate.triggerId,
-          candidate.version,
-        );
-        return state.status === 'active' || state.status === 'paused';
-      });
+    let competing = null;
+    for (const candidate of (await this.store.listTriggers())
+      .filter((item) => item.triggerId === triggerId)) {
+      if (candidate.version === expectedVersion) continue;
+      const state = await this.store.getTriggerState(
+        candidate.triggerId,
+        candidate.version,
+      );
+      if (state.status === 'active' || state.status === 'paused') {
+        competing = candidate;
+        break;
+      }
+    }
     if (competing) {
       const error = new Error(
         `Another trigger version is current: ${triggerId}@${competing.version}`,
@@ -380,7 +384,7 @@ export class TriggerControlPlane {
       error.code = 'TRIGGER_NEW_VERSION_REQUIRED';
       throw error;
     }
-    if (this.store.listTriggers().some((candidate) =>
+    if ((await this.store.listTriggers()).some((candidate) =>
       candidate.triggerId === triggerId &&
       candidate.version === definition.version
     )) {
@@ -395,7 +399,7 @@ export class TriggerControlPlane {
       ? [...new Set(connectionIds.map(String).filter(Boolean))]
       : currentState.connectionIds;
 
-    this.assertSourcesAvailable(definition, allowedConnectionIds);
+    await this.assertSourcesAvailable(definition, allowedConnectionIds);
 
     await this.retireMatches(
       triggerId,
@@ -486,7 +490,7 @@ export class TriggerControlPlane {
       throw error;
     }
 
-    const definition = this.store.listTriggers().find(
+    const definition = (await this.store.listTriggers()).find(
       (candidate) =>
         candidate.triggerId === triggerId &&
         candidate.version === version,
@@ -497,7 +501,7 @@ export class TriggerControlPlane {
       throw error;
     }
 
-    const currentState = this.store.getTriggerState(triggerId, version);
+    const currentState = await this.store.getTriggerState(triggerId, version);
     if (!samePrincipal(currentState.owner, owner)) {
       const error = new Error('Trigger owner mismatch');
       error.code = 'TRIGGER_OWNER_MISMATCH';
@@ -606,7 +610,7 @@ export class TriggerControlPlane {
       throw error;
     }
 
-    const definition = this.store.listTriggers().find(
+    const definition = (await this.store.listTriggers()).find(
       (candidate) =>
         candidate.triggerId === triggerId &&
         candidate.version === version,
@@ -617,7 +621,7 @@ export class TriggerControlPlane {
       throw error;
     }
 
-    const currentState = this.store.getTriggerState(triggerId, version);
+    const currentState = await this.store.getTriggerState(triggerId, version);
     if (!samePrincipal(currentState.owner, owner)) {
       const error = new Error('Trigger owner mismatch');
       error.code = 'TRIGGER_OWNER_MISMATCH';
@@ -673,7 +677,7 @@ export class TriggerControlPlane {
     };
   }
 
-  assertSourcesAvailable(definition, connectionIds) {
+  async assertSourcesAvailable(definition, connectionIds) {
     const allowedConnectionIds = Array.isArray(connectionIds)
       ? [...new Set(connectionIds.map(String).filter(Boolean))]
       : [];
@@ -685,7 +689,7 @@ export class TriggerControlPlane {
       throw error;
     }
 
-    const sources = this.listEventSources({
+    const sources = await this.listEventSources({
       connectionIds: allowedConnectionIds,
     });
 
@@ -771,19 +775,8 @@ export class TriggerControlPlane {
       }
     }
 
-    for (const field of definition.correlation?.deterministic?.fields ?? []) {
-      const clause = definition.clauses.find(
-        (candidate) => candidate.id === field.ref,
-      );
-      const source = clause ? resolveSource(clause) : null;
-      assertAdvertisedPath(
-        source,
-        field.path,
-        `Correlation ${field.ref}`,
-      );
-    }
 
-    if (definition.patternV2) {
+    {
       const clauseForRef = (ref) =>
         definition.clauses.find((candidate) => candidate.id === ref);
       const sourceForRef = (ref) => {
@@ -791,7 +784,7 @@ export class TriggerControlPlane {
         return clause ? resolveSource(clause) : null;
       };
 
-      for (const dimension of definition.patternV2.partitionBy ?? []) {
+      for (const dimension of definition.pattern.partitionBy ?? []) {
         for (const field of dimension.fields ?? []) {
           assertAdvertisedPath(
             sourceForRef(field.ref),
@@ -801,7 +794,7 @@ export class TriggerControlPlane {
         }
       }
 
-      walkPatternNode(definition.patternV2.root, (ref, fieldPath, purpose) => {
+      walkPatternNode(definition.pattern.root, (ref, fieldPath, purpose) => {
         assertAdvertisedPath(
           sourceForRef(ref),
           fieldPath,
@@ -869,7 +862,7 @@ export class TriggerControlPlane {
     return allowedConnectionIds;
   }
 
-  buildDerivedOutputPayloadSchema(definition) {
+  async buildDerivedOutputPayloadSchema(definition) {
     if (!definition.derivedEvent) return null;
 
     const properties = {
@@ -879,7 +872,7 @@ export class TriggerControlPlane {
           triggerId: { type: 'string' },
           triggerVersion: { type: 'string' },
           matchId: { type: 'string' },
-          correlationKey: { type: ['string', 'null'] },
+          partitionKey: { type: ['string', 'null'] },
           contractVersion: { type: 'string' },
           schemaFingerprint: { type: 'string' },
         },
@@ -899,7 +892,7 @@ export class TriggerControlPlane {
       properties[key] = scalarSchemaForConstant(value);
     }
 
-    const allSources = this.store.listEventSources();
+    const allSources = await this.store.listEventSources();
     const sourceSchemaForRefPath = (ref, fieldPath) => {
       const clause = definition.clauses.find(
         (candidate) => candidate.id === ref,
@@ -992,7 +985,7 @@ export class TriggerControlPlane {
 
   async assertDerivedOutputContract(definition) {
     if (!definition.derivedEvent) return null;
-    const payloadSchema = this.buildDerivedOutputPayloadSchema(definition);
+    const payloadSchema = await this.buildDerivedOutputPayloadSchema(definition);
     try {
       return await this.contractRegistry.assertCompatible({
         eventName: definition.derivedEvent.name,
@@ -1023,7 +1016,7 @@ export class TriggerControlPlane {
     if (!definition.derivedEvent) return null;
 
     const contractVersion = String(definition.derivedEvent.contractVersion);
-    const payloadSchema = this.buildDerivedOutputPayloadSchema(definition);
+    const payloadSchema = await this.buildDerivedOutputPayloadSchema(definition);
 
     const contract = await this.contractRegistry.registerProducer({
       eventName: definition.derivedEvent.name,
@@ -1066,7 +1059,7 @@ export class TriggerControlPlane {
 
   async retireMatches(triggerId, version, reason) {
     const now = this.now().toISOString();
-    const matches = this.store.listTriggerMatches(triggerId)
+    const matches = (await this.store.listTriggerMatches(triggerId))
       .filter((record) =>
         record.triggerVersion === version &&
         (record.status === 'partial' || record.status === 'matched')
@@ -1078,10 +1071,12 @@ export class TriggerControlPlane {
         status: 'expired',
         updatedAt: now,
       });
-      for (const deadline of this.store.listTemporalDeadlines?.({
-        matchId: record.matchId,
-        status: 'pending',
-      }) ?? []) {
+      for (const deadline of this.store.listTemporalDeadlines
+        ? await this.store.listTemporalDeadlines({
+          matchId: record.matchId,
+          status: 'pending',
+        })
+        : []) {
         await this.store.setTemporalDeadlineStatus?.(
           deadline.deadlineId,
           'cancelled',
@@ -1106,7 +1101,7 @@ export class TriggerControlPlane {
     await this.store.appendAudit({
       auditId: await stableId(
         'audit',
-        `${kind}:${entityType}:${entityId}:${timestamp}:${this.store.auditLength()}`,
+        `${kind}:${entityType}:${entityId}:${timestamp}:${await this.store.auditLength()}`,
       ),
       traceId,
       timestamp,

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,65 +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.',
-    };
-  }
-
-  if (definition.patternV2) {
-    return {
-      code: 'pattern_v2_waiting',
-      summary:
-        'Pattern AST v2 has buffered evidence but no new complete match is currently eligible.',
-      patternVersion: '2',
-      bufferRole: match.patternState?.role ?? null,
-      semanticDecisions:
-        match.patternState?.semanticDecisions ?? [],
-    };
-  }
-
-  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 ?? [],
   };
 }
 
@@ -227,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);
 
@@ -250,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
@@ -268,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',
@@ -294,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: {
@@ -322,9 +223,7 @@ export class TriggerInspector {
         continuation: definition.continuation ?? null,
         target: definition.target ?? null,
         derivedEvent: definition.derivedEvent ?? null,
-        expression: definition.expression,
-        temporal: definition.temporal ?? [],
-        patternV2: definition.patternV2 ?? null,
+        pattern: definition.pattern,
         lifecycle: definition.lifecycle ?? {},
       },
       lifecycle: state,
@@ -332,7 +231,7 @@ export class TriggerInspector {
         ? {
             matchId: match.matchId,
             status: match.status,
-            correlationKey: match.correlationKey,
+            partitionKey: match.partitionKey,
             openedAt: match.openedAt,
             expiresAt: match.expiresAt,
             updatedAt: match.updatedAt,
@@ -340,10 +239,6 @@ export class TriggerInspector {
           }
         : null,
       clauses,
-      temporal: {
-        outcome: temporal.outcome,
-        conditions: temporal.conditionStates,
-      },
       deadlines: deadlines.map((deadline) => ({
         deadlineId: deadline.deadlineId,
         conditionId: deadline.conditionId,
@@ -376,14 +271,7 @@ export class TriggerInspector {
         matchHistory,
         patternState: match?.patternState ?? null,
       },
-      why: explain({
-        definition,
-        state,
-        match,
-        clauses,
-        temporal,
-        wake,
-      }),
+      why: explain({ state, match, wake }),
     };
   }
 }
@@ -638,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,
     }),