mcp-event-intelligence 0.5.0 → 0.6.0

package/scripts/lib/trigger-planner.mjs

@@ -103,50 +103,6 @@ function validatePredicateAgainstSource(source, predicate, warnings) {
   }
 }
 
-function clauseSourceForRef(ref, clauses, resolvedSources) {
-  const index = clauses.findIndex((clause) => clause.id === ref);
-  if (index < 0) {
-    const error = new Error(`Temporal condition references unknown event id: ${ref}`);
-    error.code = 'TRIGGER_PLAN_EVENT_REF_UNKNOWN';
-    throw error;
-  }
-  return resolvedSources[index];
-}
-
-function validateTemporalConditions(conditions, clauses, resolvedSources, warnings) {
-  const refs = new Set(clauses.map((clause) => clause.id));
-
-  for (const condition of conditions) {
-    const referenced = [];
-    if ('ref' in condition) referenced.push(condition.ref);
-    if ('afterRef' in condition) referenced.push(condition.afterRef);
-    if ('beforeRef' in condition) referenced.push(condition.beforeRef);
-
-    for (const ref of referenced) {
-      if (!refs.has(ref)) {
-        const error = new Error(
-          `Temporal condition ${condition.id} references unknown event id: ${ref}`,
-        );
-        error.code = 'TRIGGER_PLAN_EVENT_REF_UNKNOWN';
-        throw error;
-      }
-    }
-
-    if (condition.kind === 'distinct') {
-      const source = clauseSourceForRef(
-        condition.ref,
-        clauses,
-        resolvedSources,
-      );
-      validatePredicateAgainstSource(
-        source,
-        { path: condition.path, op: 'exists', value: true },
-        warnings,
-      );
-    }
-  }
-}
-
 function walkPatternValue(value, visitor) {
   if (!value || typeof value !== 'object') return;
   if (value.kind === 'field') {
@@ -189,32 +145,6 @@ function walkPatternNode(node, visitor) {
   if (node.forbidden) walkPatternNode(node.forbidden, visitor);
 }
 
-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 };
-  }
-
-  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;
-    }
-    return { kind: 'sequence', refs };
-  }
-
-  if (match === 'any' || refs.length === 1) {
-    return { kind: 'anyOf', refs };
-  }
-
-  return { kind: 'allOf', refs };
-}
-
 function lifecycleFor(input = {}) {
   return {
     oneShot: input.oneShot ?? false,
@@ -226,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;
@@ -233,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();
@@ -285,12 +240,13 @@ export class TriggerPlanner {
 
     const refs = clauses.map((clause) => clause.id);
 
-    if (plan.patternV2) {
-      const patternRefs = collectPatternRefs(plan.patternV2.root);
+    const pattern = plan.pattern ?? defaultPattern(refs);
+    {
+      const patternRefs = collectPatternRefs(pattern.root);
       for (const ref of patternRefs) {
         if (!refs.includes(ref)) {
           const error = new Error(
-            `Pattern AST v2 references unknown event id: ${ref}`,
+            `Pattern AST references unknown event id: ${ref}`,
           );
           error.code = 'TRIGGER_PLAN_EVENT_REF_UNKNOWN';
           throw error;
@@ -301,7 +257,7 @@ export class TriggerPlanner {
         const index = clauses.findIndex((candidate) => candidate.id === ref);
         if (index < 0) {
           const error = new Error(
-            `Pattern AST v2 references unknown event id: ${ref}`,
+            `Pattern AST references unknown event id: ${ref}`,
           );
           error.code = 'TRIGGER_PLAN_EVENT_REF_UNKNOWN';
           throw error;
@@ -309,7 +265,7 @@ export class TriggerPlanner {
         return resolvedSources[index];
       };
 
-      walkPatternNode(plan.patternV2.root, (ref, fieldPath, purpose) => {
+      walkPatternNode(pattern.root, (ref, fieldPath, purpose) => {
         validatePredicateAgainstSource(
           sourceForRef(ref),
           { path: fieldPath, op: 'exists', value: true },
@@ -317,7 +273,7 @@ export class TriggerPlanner {
         );
       });
 
-      for (const dimension of plan.patternV2.partitionBy) {
+      for (const dimension of pattern.partitionBy) {
         for (const field of dimension.fields) {
           const clauseIndex = clauses.findIndex(
             (candidate) => candidate.id === field.ref,
@@ -336,52 +292,14 @@ export class TriggerPlanner {
           );
         }
       }
-    } else {
-      validateTemporalConditions(
-        plan.temporal,
-        clauses,
-        resolvedSources,
-        warnings,
-      );
     }
 
-    const correlation = {};
-    if (!plan.patternV2 && plan.correlateBy) {
-      for (const field of plan.correlateBy) {
-        if (!refs.includes(field.eventId)) {
-          const error = new Error(
-            `Correlation references unknown event id: ${field.eventId}`,
-          );
-          error.code = 'TRIGGER_PLAN_EVENT_REF_UNKNOWN';
-          throw error;
-        }
-        const clause = clauses.find((candidate) => candidate.id === field.eventId);
-        const source = resolvedSources[clauses.indexOf(clause)];
-        validatePredicateAgainstSource(
-          source,
-          { 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.patternV2 && plan.semanticCorrelation) {
-      correlation.semantic = plan.semanticCorrelation;
-    }
 
     const triggerId = plan.triggerId || `planned_${(
       await sha256Hex(canonicalJson({
         target: plan.target ?? null,
         events: plan.events,
-        match: plan.match,
-        temporal: plan.temporal,
-        patternV2: plan.patternV2 ?? null,
+        pattern,
         eventTime: plan.eventTime ?? null,
         conditionOnly: plan.conditionOnly,
         continuation: plan.continuation?.instruction ?? null,
@@ -401,27 +319,21 @@ export class TriggerPlanner {
       conditionOnly: plan.conditionOnly,
       ...(plan.continuation ? { continuation: plan.continuation } : {}),
       clauses,
-      expression: plan.patternV2
-        ? { kind: 'anyOf', refs }
-        : expressionFor(plan.match, refs),
-      temporal: plan.patternV2 ? [] : plan.temporal,
-      ...(plan.patternV2 ? { patternV2: plan.patternV2 } : {}),
+      pattern,
       withinMs: plan.withinMs,
       ...(plan.eventTime ? { eventTime: plan.eventTime } : {}),
       lifecycle: lifecycleFor(plan.lifecycle),
-      ...(Object.keys(correlation).length ? { correlation } : {}),
       ...(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,
@@ -429,8 +341,7 @@ export class TriggerPlanner {
             arguments: clause.arguments,
             where: clause.where,
           })),
-          temporal: definition.temporal,
-          patternV2: definition.patternV2 ?? null,
+          pattern: definition.pattern,
           withinMs: definition.withinMs,
           eventTime: definition.eventTime ?? { allowedLatenessMs: 0 },
         },

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];
 

package/scripts/mcp-stdio-server.mjs

@@ -93,7 +93,7 @@ function registerReadTools(server, runtime) {
     async ({ connectionIds }) => {
       try {
         return jsonResult({
-          sources: runtime.triggerControl.listEventSources({
+          sources: await runtime.triggerControl.listEventSources({
             ...(connectionIds ? { connectionIds } : {}),
           }),
         });
@@ -147,7 +147,7 @@ function registerReadTools(server, runtime) {
     async ({ ownerOnly }) => {
       try {
         return jsonResult({
-          triggers: runtime.triggerControl.listTriggers(
+          triggers: await runtime.triggerControl.listTriggers(
             ownerOnly ? { owner: ownerFromEnv(process.env) } : {},
           ),
         });
@@ -210,7 +210,7 @@ function registerReadTools(server, runtime) {
     async ({ eventName }) => {
       try {
         return jsonResult({
-          contracts: runtime.store.listDerivedContracts(eventName),
+          contracts: await runtime.store.listDerivedContracts(eventName),
         });
       } catch (error) {
         return errorResult(error);
@@ -229,7 +229,7 @@ function registerReadTools(server, runtime) {
     },
     async ({ wakeId }) => {
       try {
-        return jsonResult(runtime.activationHydrator.hydrateWake(wakeId));
+        return jsonResult(await runtime.activationHydrator.hydrateWake(wakeId));
       } catch (error) {
         return errorResult(error);
       }
@@ -247,11 +247,11 @@ function registerReadTools(server, runtime) {
       try {
         return jsonResult({
           restored: runtime.restored,
-          hostMcpEventConnections: runtime.mcpEventsClient.status(),
+          hostMcpEventConnections: await runtime.mcpEventsClient.status(),
           pendingTemporalDeadlines:
-            runtime.store.listTemporalDeadlines({ status: 'pending' }).length,
-          derivedEvents: runtime.store.listDerivedEvents().length,
-          derivedContracts: runtime.store.listDerivedContracts().length,
+            (await runtime.store.listTemporalDeadlines({ status: 'pending' })).length,
+          derivedEvents: (await runtime.store.listDerivedEvents()).length,
+          derivedContracts: (await runtime.store.listDerivedContracts()).length,
           writeEnabled: process.env.MCP_WRITE_ENABLED === 'true',
         });
       } catch (error) {

package/scripts/service.mjs

@@ -13,13 +13,10 @@ import {
 import {
   ExperimentalMcpEventsServer,
 } from '../dist/src/mcpEvents/server.js';
-import { EventProcessor } from './lib/event-processor.mjs';
 import {
-  githubEventPassesStructuredFilter,
   translateGitHubWebhook,
   verifyGitHubWebhookSignature,
 } from './lib/github-webhook.mjs';
-import { createHttpWakeDeliverer } from './lib/http-wake-deliverer.mjs';
 import {
   CompositeWakeCoordinator,
 } from './lib/composite-wake-coordinator.mjs';
@@ -65,10 +62,6 @@ const evaluator = process.env.TYPESAFE_API_KEY
   ? TypeSafeJevEvaluator.fromEnvironment(process.env)
   : null;
 
-const wakeDeliverer = createHttpWakeDeliverer(
-  process.env.RUNTIME_WAKE_URL ?? '',
-);
-
 const deliveryOptions = {
   leaseMs: Number(process.env.WAKE_DELIVERY_LEASE_MS ?? 30000),
   maxAttempts: Number(process.env.WAKE_DELIVERY_MAX_ATTEMPTS ?? 5),
@@ -76,12 +69,6 @@ const deliveryOptions = {
   retryMaxDelayMs: Number(process.env.WAKE_RETRY_MAX_DELAY_MS ?? 60000),
 };
 
-const processor = new EventProcessor({
-  store,
-  evaluator,
-  wakeDeliverer,
-  ...deliveryOptions,
-});
 const compositeTriggers = new CompositeTriggerEngine(store, evaluator);
 const runtimeWakeTargets = readRuntimeWakeTargets(
   process.env.RUNTIME_WAKE_TARGETS_JSON,
@@ -104,7 +91,6 @@ const compositeEventConsumer = new CompositeEventConsumer({
   triggerEngine: compositeTriggers,
   wakeCoordinators,
   derivedEventCoordinator,
-  processor,
   maxDerivedDepth: Number(process.env.MAX_DERIVED_EVENT_DEPTH ?? 16),
 });
 const temporalScheduler = new TemporalDeadlineScheduler({
@@ -116,7 +102,6 @@ temporalScheduler.start();
 
 const wakeRetryScheduler = new WakeRetryScheduler({
   store,
-  eventProcessor: processor,
   resolveCoordinator: (runtime) => wakeCoordinators.get(runtime) ?? null,
   intervalMs: Number(process.env.WAKE_RETRY_TICK_MS ?? 1000),
 });
@@ -167,59 +152,6 @@ function requireBearer(request, response) {
   return true;
 }
 
-function githubSemanticCondition() {
-  const instruction = process.env.SEMANTIC_INSTRUCTION;
-  if (!instruction) return undefined;
-
-  return {
-    type: 'semantic_boolean',
-    instruction,
-    input: ['data.title', 'data.bodyPreview', 'data.labels'],
-    matchThreshold: Number(process.env.SEMANTIC_MATCH_THRESHOLD ?? 0.8),
-    rejectThreshold: Number(process.env.SEMANTIC_REJECT_THRESHOLD ?? 0.2),
-    uncertain: process.env.SEMANTIC_UNCERTAIN_POLICY ?? 'escalate',
-  };
-}
-
-function logProcessingResult(result) {
-  console.log(
-    JSON.stringify({
-      message: 'event_intelligence_result',
-      traceId: result.traceId,
-      sourceEventId: result.sourceEventId,
-      status: result.status,
-      decisionId: result.decision?.decisionId ?? null,
-      outcome: result.decision?.outcome ?? null,
-      probability: result.decision?.probability ?? null,
-      evaluator: result.decision?.evaluator ?? null,
-      providerEvidence: result.decision?.providerEvidence ?? null,
-      wakeId: result.wake?.wakeId ?? null,
-      wakeStatus: result.wake?.status ?? null,
-    }),
-  );
-}
-
-function githubContext() {
-  const targetId = process.env.RUNTIME_TARGET_ID;
-  if (!targetId) {
-    throw new Error('RUNTIME_TARGET_ID is required for GitHub webhook delivery');
-  }
-
-  return {
-    environmentId,
-    subscriptionId:
-      process.env.GITHUB_SUBSCRIPTION_ID ?? 'github-issues-default',
-    serverId: process.env.GITHUB_SERVER_ID ?? 'github-webhook-adapter',
-    transport: 'webhook',
-    provider: 'github',
-    target: {
-      runtime: process.env.RUNTIME_TARGET_RUNTIME ?? 'agent-runtime',
-      kind: process.env.RUNTIME_TARGET_KIND ?? 'session',
-      id: targetId,
-    },
-  };
-}
-
 const server = createServer(async (request, response) => {
   try {
     const url = new URL(
@@ -237,28 +169,20 @@ const server = createServer(async (request, response) => {
 
     if (request.method === 'GET' && url.pathname === '/readyz') {
       const auditValid = await store.verifyAudit();
-      const semanticRequired = Boolean(process.env.SEMANTIC_INSTRUCTION);
       const evaluatorConfigured = Boolean(evaluator);
-      const ready =
-        auditValid &&
-        (!semanticRequired || evaluatorConfigured);
+      const ready = auditValid;
 
       return sendJson(response, ready ? 200 : 503, {
-        status: ready
-          ? 'ready'
-          : !auditValid
-            ? 'audit_invalid'
-            : 'semantic_evaluator_unavailable',
+        status: ready ? 'ready' : 'audit_invalid',
         auditValid,
-        semanticRequired,
         evaluatorConfigured,
-        wakeCallbackConfigured: Boolean(wakeDeliverer),
+        wakeCallbackConfigured: runtimeWakeTargets.size > 0,
         genericRuntimeWakeTargets: [...runtimeWakeTargets.keys()],
-        eventSources: store.listEventSources().length,
+        eventSources: (await store.listEventSources()).length,
         pendingTemporalDeadlines:
-          store.listTemporalDeadlines({ status: 'pending' }).length,
-        derivedEvents: store.listDerivedEvents().length,
-        derivedContracts: store.listDerivedContracts().length,
+          (await store.listTemporalDeadlines({ status: 'pending' })).length,
+        derivedEvents: (await store.listDerivedEvents()).length,
+        derivedContracts: (await store.listDerivedContracts()).length,
       });
     }
 
@@ -338,27 +262,11 @@ const server = createServer(async (request, response) => {
         }));
       }
 
-      if (
-        !githubEventPassesStructuredFilter(translated.event, {
-          repository: process.env.GITHUB_REPOSITORY,
-          label: process.env.GITHUB_LABEL,
-        })
-      ) {
-        return sendJson(response, 202, {
-          status: 'filtered_structured',
-        });
-      }
-
-      const result = await processor.ingest({
-        event: translated.event,
-        context: githubContext(),
-        semanticCondition: githubSemanticCondition(),
-        wakeOnEscalation:
-          process.env.WAKE_ON_ESCALATION === 'true',
+      return sendJson(response, 202, {
+        status: mcpReceipt.accepted ? 'accepted' : 'duplicate',
+        mcpReceipt,
+        composite,
       });
-
-      logProcessingResult(result);
-      return sendJson(response, 202, result);
     }
 
     if (request.method === 'POST' && url.pathname === '/mcp') {
@@ -422,7 +330,7 @@ const server = createServer(async (request, response) => {
       url.pathname === '/v1/derived-contracts'
     ) {
       return sendJson(response, 200, {
-        contracts: store.listDerivedContracts(
+        contracts: await store.listDerivedContracts(
           url.searchParams.get('eventName') ?? undefined,
         ),
       });
@@ -433,7 +341,7 @@ const server = createServer(async (request, response) => {
       url.pathname === '/v1/derived-events'
     ) {
       return sendJson(response, 200, {
-        events: store.listDerivedEvents({
+        events: await store.listDerivedEvents({
           ...(url.searchParams.get('triggerId')
             ? { triggerId: url.searchParams.get('triggerId') }
             : {}),
@@ -454,7 +362,7 @@ const server = createServer(async (request, response) => {
       const triggerId = decodeURIComponent(
         url.pathname.slice('/v1/inspector/triggers/'.length),
       );
-      return sendJson(response, 200, triggerInspector.inspect({
+      return sendJson(response, 200, await triggerInspector.inspect({
         triggerId,
         version: url.searchParams.get('version') ?? undefined,
         matchId: url.searchParams.get('matchId') ?? undefined,
@@ -481,7 +389,7 @@ const server = createServer(async (request, response) => {
       url.pathname === '/v1/temporal/deadlines'
     ) {
       return sendJson(response, 200, {
-        deadlines: store.listTemporalDeadlines({
+        deadlines: await store.listTemporalDeadlines({
           ...(url.searchParams.get('triggerId')
             ? { triggerId: url.searchParams.get('triggerId') }
             : {}),
@@ -507,7 +415,7 @@ const server = createServer(async (request, response) => {
     if (request.method === 'GET' && url.pathname === '/v1/event-sources') {
       const connectionIds = url.searchParams.getAll('connectionId');
       return sendJson(response, 200, {
-        eventSources: triggerControl.listEventSources({
+        eventSources: await triggerControl.listEventSources({
           ...(connectionIds.length ? { connectionIds } : {}),
         }),
       });
@@ -528,7 +436,7 @@ const server = createServer(async (request, response) => {
       const ownerId = url.searchParams.get('ownerId');
       const tenantId = url.searchParams.get('tenantId');
       return sendJson(response, 200, {
-        triggers: triggerControl.listTriggers({
+        triggers: await triggerControl.listTriggers({
           ...(ownerType && ownerId
             ? {
               owner: {
@@ -633,14 +541,14 @@ const server = createServer(async (request, response) => {
 
     if (request.method === 'GET' && url.pathname === '/v1/triggers') {
       return sendJson(response, 200, {
-        triggers: store.listTriggers(),
+        triggers: await store.listTriggers(),
       });
     }
 
     if (request.method === 'GET' && url.pathname === '/v1/trigger-matches') {
       const triggerId = url.searchParams.get('triggerId') ?? undefined;
       return sendJson(response, 200, {
-        matches: store.listTriggerMatches(triggerId),
+        matches: await store.listTriggerMatches(triggerId),
       });
     }
 
@@ -704,13 +612,6 @@ const server = createServer(async (request, response) => {
       });
     }
 
-    if (request.method === 'POST' && url.pathname === '/v1/events/ingest') {
-      const raw = await readRawBody(request);
-      const body = JSON.parse(raw.toString('utf8'));
-      const result = await processor.ingest(body);
-      logProcessingResult(result);
-      return sendJson(response, 202, result);
-    }
 
     if (request.method === 'GET' && url.pathname === '/v1/audit') {
       const afterSequence = Number(url.searchParams.get('afterSequence') ?? -1);
@@ -731,26 +632,6 @@ const server = createServer(async (request, response) => {
       return sendJson(response, 200, store.trace(traceId));
     }
 
-    if (
-      request.method === 'POST' &&
-      url.pathname.startsWith('/v1/wakes/') &&
-      url.pathname.endsWith('/ack')
-    ) {
-      const wakeId = decodeURIComponent(
-        url.pathname.slice('/v1/wakes/'.length, -'/ack'.length),
-      );
-      const raw = await readRawBody(request);
-      const body = raw.length
-        ? JSON.parse(raw.toString('utf8'))
-        : {};
-      const handled = await processor.acknowledgeWake(
-        wakeId,
-        typeof body.runtimeReceiptId === 'string'
-          ? body.runtimeReceiptId
-          : undefined,
-      );
-      return sendJson(response, 200, handled);
-    }
 
     return sendJson(response, 404, { error: 'NOT_FOUND' });
   } catch (error) {

package/server.json

@@ -3,7 +3,7 @@
   "name": "io.github.sarooo17/event-intelligence",
   "title": "MCP Event Intelligence",
   "description": "MCP-native CEP for durable agents: event-time patterns, semantic predicates, derived events.",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "repository": {
     "url": "https://github.com/sarooo17/event-intelligence",
     "source": "github"
@@ -13,7 +13,7 @@
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "mcp-event-intelligence",
-      "version": "0.5.0",
+      "version": "0.6.0",
       "transport": {
         "type": "stdio"
       },
@@ -49,7 +49,7 @@
         },
         {
           "name": "TYPESAFE_API_KEY",
-          "description": "Optional TypeSafe Jev API key for semantic Pattern AST nodes and legacy semantic-correlation triggers.",
+          "description": "Optional TypeSafe Jev API key for explicit semantic Pattern AST nodes.",
           "isRequired": false,
           "isSecret": true,
           "format": "string"

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

@@ -1,3 +0,0 @@
-import type { EventLineage, SemanticDecisionRecord, WakeRecord } from './schemas.js';
-export declare function assertDecisionLineage(event: EventLineage, decision: SemanticDecisionRecord): void;
-export declare function assertWakeLineage(event: EventLineage, decision: SemanticDecisionRecord | null, wake: WakeRecord): void;