@openwop/openwop-conformance 1.1.1 → 1.3.0

package/src/scenarios/aiEnvelope.contractRefusal.test.ts

@@ -0,0 +1,268 @@
+/**
+ * aiEnvelope.contractRefusal — FINAL v1.1 advertisement-shape verification + behavioral placeholders.
+ *
+ * Status: DRAFT (advertisement-shape). `spec/v1/ai-envelope.md` landed
+ * 2026-05-17 as DRAFT v1.x. Behavioral assertions stay `it.todo()` until a
+ * reference host wires Envelope Contract enforcement on a node typeId.
+ *
+ * Summary: an Envelope Contract is a per-typeId declaration of which envelope
+ * kinds that node accepts (`accepts: string[]` plus implicit universals). When
+ * a node emits an envelope whose `type` is neither universal nor in `accepts`:
+ *   - `refusalMode: "fail-node"` (default) — engine MUST emit `node.failed` with
+ *     `error.code = 'envelope_contract_violation'`, `error.details.refusedType`,
+ *     `error.details.acceptedTypes[]`.
+ *   - `refusalMode: "discard-and-warn"` (advisory) — engine MAY discard silently
+ *     after emitting `log.appended` (level warn) and proceed.
+ *
+ * Universals are ALWAYS accepted regardless of `accepts`.
+ *
+ * @see spec/v1/ai-envelope.md §"Envelope Contract"
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+
+interface DiscoveryDoc {
+  capabilities?: Record<string, unknown>;
+}
+
+describe('aiEnvelope.contractRefusal: advertisement shape (FINAL v1.1)', () => {
+  it('opted-in hosts advertise envelopeContracts.advertised as a boolean', async () => {
+    const res = await driver.get('/.well-known/openwop');
+    const body = res.json as DiscoveryDoc | undefined;
+    const top = body?.capabilities as Record<string, unknown> | undefined;
+    const block = top && typeof top === 'object' ? top['envelopeContracts'] : undefined;
+    if (block === undefined) return; // absent — skip
+    expect(
+      typeof (block as Record<string, unknown>)['advertised'],
+      driver.describe(
+        'ai-envelope.md §"Capability handshake integration"',
+        'envelopeContracts.advertised MUST be a boolean when present',
+      ),
+    ).toBe('boolean');
+  });
+});
+
+async function accept(envelope: unknown, opts: Record<string, unknown> = {}): Promise<{ status: number; body: { status?: string; reason?: string; allowedKinds?: string[] } }> {
+  const res = await driver.post('/v1/host/sample/envelope/accept', { envelope, ...opts });
+  return { status: res.status, body: res.json as { status?: string; reason?: string; allowedKinds?: string[] } };
+}
+
+const baseMeta = { source: 'ai-generation' as const, ts: '2026-05-18T10:00:00Z' };
+
+describe('aiEnvelope.contractRefusal: behavioral accept-gate (FINAL v1.1)', () => {
+  it('node with nodeAllowedKinds:["vendor.x.foo.create"] emits vendor.x.bar.create → status: gated', async () => {
+    const r = await accept(
+      {
+        type: 'vendor.x.bar.create',
+        schemaVersion: 1,
+        envelopeId: 'env-cr-1',
+        correlationId: 'r:n:0:cr1',
+        payload: {},
+        meta: baseMeta,
+      },
+      {
+        hostSupportedEnvelopes: ['vendor.x.bar.create', 'vendor.x.foo.create'],
+        nodeAllowedKinds: ['vendor.x.foo.create'],
+      },
+    );
+    if (r.status === 404) return;
+    expect(
+      r.body.status,
+      driver.describe('ai-envelope.md §"Envelope Contract"', 'envelope outside node accepts[] MUST be refused'),
+    ).toBe('gated');
+  });
+
+  it('gated outcome carries the union of universals + node-declared accepts as allowedKinds', async () => {
+    const r = await accept(
+      {
+        type: 'vendor.x.unknown.kind',
+        schemaVersion: 1,
+        envelopeId: 'env-cr-2',
+        correlationId: 'r:n:0:cr2',
+        payload: {},
+        meta: baseMeta,
+      },
+      {
+        hostSupportedEnvelopes: ['vendor.x.unknown.kind', 'vendor.x.foo.create'],
+        nodeAllowedKinds: ['vendor.x.foo.create'],
+      },
+    );
+    if (r.status === 404) return;
+    expect(Array.isArray(r.body.allowedKinds), 'allowedKinds MUST be an array').toBe(true);
+    expect(r.body.allowedKinds, 'allowedKinds MUST include universals + declared accepts').toEqual(
+      expect.arrayContaining(['clarification.request', 'schema.request', 'schema.response', 'error', 'vendor.x.foo.create']),
+    );
+  });
+
+  it('universals are accepted regardless of nodeAllowedKinds (always-allowed)', async () => {
+    const r = await accept(
+      {
+        type: 'clarification.request',
+        schemaVersion: 1,
+        envelopeId: 'env-cr-univ',
+        correlationId: 'r:n:0:univ',
+        payload: { questions: [{ id: 'q1', question: 'why?' }] },
+        meta: baseMeta,
+      },
+      { nodeAllowedKinds: ['vendor.x.foo.create'] }, // doesn't include clarification.request
+    );
+    if (r.status === 404) return;
+    expect(
+      r.body.status,
+      driver.describe('ai-envelope.md §"Universal kinds"', 'universal kinds MUST be accepted regardless of node accepts[]'),
+    ).toBe('accepted');
+  });
+
+  it('host-supportedEnvelopes gate fires BEFORE node accepts gate (kind unadvertised → gated, not invalid)', async () => {
+    const r = await accept(
+      {
+        type: 'vendor.unadvertised.kind',
+        schemaVersion: 1,
+        envelopeId: 'env-cr-hostgate',
+        correlationId: 'r:n:0:hostgate',
+        payload: {},
+        meta: baseMeta,
+      },
+      {
+        hostSupportedEnvelopes: ['vendor.advertised.only'],
+        nodeAllowedKinds: ['vendor.unadvertised.kind'], // node would allow but host doesn't
+      },
+    );
+    if (r.status === 404) return;
+    expect(
+      r.body.status,
+      driver.describe('ai-envelope.md §"Capability handshake integration"', 'host gate MUST fire before node gate'),
+    ).toBe('gated');
+  });
+});
+
+// E.1 engine-projection via the test-only event-log seam.
+import { queryTestEvents, isEventLogSeamAvailable, resetTestSeam } from '../lib/event-log-query.js';
+
+describe('aiEnvelope.contractRefusal: engine projection via event-log seam', () => {
+  it('gated (fail-node) → node.failed { error.code: "envelope_contract_violation" }', async () => {
+    if (!(await isEventLogSeamAvailable())) return;
+    const runId = `r-cr-fail-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const r = await accept(
+      {
+        type: 'vendor.x.bar.create',
+        schemaVersion: 1,
+        envelopeId: 'env-cr-proj-1',
+        correlationId: `${runId}:n:0:cr-proj-1`,
+        payload: {},
+        meta: baseMeta,
+      },
+      {
+        hostSupportedEnvelopes: ['vendor.x.bar.create', 'vendor.x.foo.create'],
+        nodeAllowedKinds: ['vendor.x.foo.create'],
+        projectTo: { runId, nodeId: 'n', refusalMode: 'fail-node' },
+      },
+    );
+    if (r.status === 404) return;
+    expect(r.body.status).toBe('gated');
+    const events = await queryTestEvents(runId, { type: 'node.failed' });
+    if (!events.ok || events.events.length === 0) return;
+    const err = events.events[0]!.payload.error as { code?: string; details?: { refusedType?: string; acceptedTypes?: string[] } };
+    expect(
+      err.code,
+      driver.describe('ai-envelope.md §"Envelope Contract"', 'gated outcome MUST project to node.failed with error.code = envelope_contract_violation'),
+    ).toBe('envelope_contract_violation');
+  });
+
+  it('refused envelope: error.details.refusedType names emitted kind; acceptedTypes lists allowed kinds', async () => {
+    if (!(await isEventLogSeamAvailable())) return;
+    const runId = `r-cr-details-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    await accept(
+      {
+        type: 'vendor.x.bar.create',
+        schemaVersion: 1,
+        envelopeId: 'env-cr-proj-details',
+        correlationId: `${runId}:n:0:cr-details`,
+        payload: {},
+        meta: baseMeta,
+      },
+      {
+        hostSupportedEnvelopes: ['vendor.x.bar.create', 'vendor.x.foo.create'],
+        nodeAllowedKinds: ['vendor.x.foo.create'],
+        projectTo: { runId, nodeId: 'n' },
+      },
+    );
+    const events = await queryTestEvents(runId, { type: 'node.failed' });
+    if (!events.ok || events.events.length === 0) return;
+    const details = (events.events[0]!.payload.error as { details?: { refusedType?: string; acceptedTypes?: string[] } }).details;
+    expect(details?.refusedType).toBe('vendor.x.bar.create');
+    expect(
+      Array.isArray(details?.acceptedTypes) && details!.acceptedTypes!.includes('vendor.x.foo.create'),
+      driver.describe('ai-envelope.md §"Envelope Contract"', 'error.details.acceptedTypes MUST list the node\'s declared accepts[] (plus universals)'),
+    ).toBe(true);
+  });
+
+  it('refusalMode:"discard-and-warn" → log.appended { level: "warn" } instead of node.failed', async () => {
+    if (!(await isEventLogSeamAvailable())) return;
+    const runId = `r-cr-warn-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    await accept(
+      {
+        type: 'vendor.x.bar.create',
+        schemaVersion: 1,
+        envelopeId: 'env-cr-proj-warn',
+        correlationId: `${runId}:n:0:cr-warn`,
+        payload: {},
+        meta: baseMeta,
+      },
+      {
+        hostSupportedEnvelopes: ['vendor.x.bar.create'],
+        nodeAllowedKinds: ['vendor.x.foo.create'], // gated
+        projectTo: { runId, nodeId: 'n', refusalMode: 'discard-and-warn' },
+      },
+    );
+    const warnEvents = await queryTestEvents(runId, { type: 'log.appended' });
+    const failEvents = await queryTestEvents(runId, { type: 'node.failed' });
+    if (!warnEvents.ok || !failEvents.ok) return;
+    expect(
+      warnEvents.events.some((e) => (e.payload as { level?: string }).level === 'warn'),
+      driver.describe('ai-envelope.md §"Envelope Contract"', 'discard-and-warn MUST emit log.appended at warn level'),
+    ).toBe(true);
+    expect(
+      failEvents.events.length,
+      driver.describe('ai-envelope.md §"Envelope Contract"', 'discard-and-warn MUST NOT emit node.failed'),
+    ).toBe(0);
+    await resetTestSeam();
+  });
+
+  it('host-gate refusal (hostSupportedEnvelopes) projects to node.failed with envelope_contract_violation', async () => {
+    if (!(await isEventLogSeamAvailable())) return;
+    const runId = `r-cr-host-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    await accept(
+      {
+        type: 'vendor.unadvertised.kind',
+        schemaVersion: 1,
+        envelopeId: 'env-cr-proj-host',
+        correlationId: `${runId}:n:0:cr-host`,
+        payload: {},
+        meta: baseMeta,
+      },
+      {
+        hostSupportedEnvelopes: ['vendor.advertised.only'],
+        nodeAllowedKinds: ['vendor.unadvertised.kind'],
+        projectTo: { runId, nodeId: 'n' },
+      },
+    );
+    const events = await queryTestEvents(runId, { type: 'node.failed' });
+    if (!events.ok || events.events.length === 0) return;
+    expect(
+      (events.events[0]!.payload.error as { code?: string }).code,
+      driver.describe('ai-envelope.md §"Capability handshake integration"', 'host-gate refusal MUST project to node.failed envelope_contract_violation (stacks above node-gate)'),
+    ).toBe('envelope_contract_violation');
+  });
+});
+
+describe('aiEnvelope.contractRefusal: capability-stacking placeholder', () => {
+  // Capability-gated typeId refusal stacking (host.aiEnvelope absent →
+  // typeId refused FIRST, before envelope contract gate) requires
+  // the workflow-register handler to consult host.aiEnvelope BEFORE
+  // dispatching envelope acceptance. Tracked under Thread E (engine
+  // integration of acceptor into node execution path); the seam
+  // alone can't verify the ordering.
+  it.todo('capability-gated typeId refusal stacks atop Envelope Contract refusal (host.aiEnvelope absent → typeId refused first; needs node-execution wiring)');
+});

package/src/scenarios/aiEnvelope.correlationReplay.test.ts

@@ -0,0 +1,284 @@
+/**
+ * aiEnvelope.correlationReplay — FINAL v1.1 advertisement-shape verification + behavioral placeholders.
+ *
+ * Status: DRAFT (advertisement-shape). `spec/v1/ai-envelope.md` landed
+ * 2026-05-17 as DRAFT v1.x. Behavioral assertions stay `it.todo()` until a
+ * reference host wires the accept path and the cross-process replay seam.
+ *
+ * Summary: two envelopes in the same run with the same `correlationId` MUST
+ * be treated as a re-emission. The second invocation returns the cached
+ * `EnvelopeOutcome` synchronously without re-invoking the handler. After
+ * process death + recovery, the engine MUST consult the run event log via
+ * `causationId = correlationId` and return the cached outcome — the handler
+ * runs at most once per `correlationId` per run lifetime. A re-emission with
+ * the same `correlationId` but a different `type` MUST be refused with
+ * `envelope_correlation_conflict`.
+ *
+ * @see spec/v1/ai-envelope.md §"Replay determinism"
+ * @see spec/v1/interrupt.md §"Replay determinism" (parallel contract)
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+
+interface DiscoveryDoc {
+  capabilities?: Record<string, unknown>;
+}
+
+async function isEnvelopeContractsAdvertised(): Promise<boolean> {
+  const res = await driver.get('/.well-known/openwop');
+  const body = res.json as DiscoveryDoc | undefined;
+  const top = body?.capabilities as Record<string, unknown> | undefined;
+  const block = top && typeof top === 'object' ? (top['envelopeContracts'] as Record<string, unknown> | undefined) : undefined;
+  return Boolean(block && block['advertised'] === true);
+}
+
+describe('aiEnvelope.correlationReplay: advertisement shape (FINAL v1.1)', () => {
+  it('host that advertises envelopeContracts.advertised:true claims the replay-determinism contract', async () => {
+    if (!(await isEnvelopeContractsAdvertised())) return; // not opted in — skip
+    // The contract has no separate capability flag — advertising
+    // envelopeContracts is the claim. The behavioral assertions below
+    // exercise the contract; this advertisement-shape test exists so
+    // a "no envelope contracts at all" host doesn't appear in failure
+    // reports for this scenario.
+    expect(true).toBe(true);
+  });
+});
+
+// Behavioral assertions through the workflow-engine sample's env-gated
+// `POST /v1/host/sample/envelope/accept` seam. The seam accepts a flat
+// `priorCorrelations` array (each entry: `{correlationId, outcome, envelopeType}`)
+// that the acceptor consumes as the per-run dedup store. Each test
+// soft-skips on HTTP 404 (host doesn't expose the seam).
+//
+// The cross-process replay assertion (process death + recovery) still
+// stays deferred — it requires a higher-level lifecycle seam that
+// persists the dedup state, which is engine scope, not acceptor scope.
+async function accept(envelope: unknown, opts: Record<string, unknown> = {}): Promise<{ status: number; body: { status?: string; reason?: string; envelopeId?: string; normalizedMeta?: { contentTrust?: string } } }> {
+  const res = await driver.post('/v1/host/sample/envelope/accept', { envelope, ...opts });
+  return { status: res.status, body: res.json as { status?: string; reason?: string; envelopeId?: string; normalizedMeta?: { contentTrust?: string } } };
+}
+
+const baseMeta = { source: 'ai-generation' as const, ts: '2026-05-18T10:00:00Z' };
+
+describe('aiEnvelope.correlationReplay: behavioral in-process dedup (FINAL v1.1)', () => {
+  it('same correlationId re-emission returns the cached outcome unchanged', async () => {
+    const envelope = {
+      type: 'clarification.request',
+      schemaVersion: 1,
+      envelopeId: 'env-cr-replay-1',
+      correlationId: 'r:n:0:replay1',
+      payload: { questions: [{ id: 'q1', question: 'why?' }] },
+      meta: baseMeta,
+    };
+    const first = await accept(envelope);
+    if (first.status === 404) return;
+    expect(first.body.status).toBe('accepted');
+    const cachedOutcome = first.body;
+
+    const second = await accept(envelope, {
+      priorCorrelations: [
+        {
+          correlationId: 'r:n:0:replay1',
+          outcome: cachedOutcome,
+          envelopeType: 'clarification.request',
+        },
+      ],
+    });
+    expect(
+      second.body.status,
+      driver.describe(
+        'ai-envelope.md §"Replay determinism"',
+        'second emission with same correlationId MUST return the cached outcome (handler runs at most once per correlationId)',
+      ),
+    ).toBe('accepted');
+    expect(second.body.envelopeId).toBe(cachedOutcome.envelopeId);
+  });
+
+  it('same correlationId, different envelope type → invalid envelope_correlation_conflict', async () => {
+    const r = await accept(
+      {
+        type: 'error', // re-using a correlationId previously bound to clarification.request
+        schemaVersion: 1,
+        envelopeId: 'env-cr-conflict',
+        correlationId: 'r:n:0:conflict',
+        payload: { code: 'x', message: 'y' },
+        meta: baseMeta,
+      },
+      {
+        priorCorrelations: [
+          {
+            correlationId: 'r:n:0:conflict',
+            outcome: { status: 'accepted', envelopeId: 'env-prior', recordedEventIds: [], normalizedMeta: { contentTrust: 'trusted' } },
+            envelopeType: 'clarification.request',
+          },
+        ],
+      },
+    );
+    if (r.status === 404) return;
+    expect(
+      r.body.status,
+      driver.describe(
+        'ai-envelope.md §"Replay determinism"',
+        'same correlationId with different type MUST refuse envelope_correlation_conflict',
+      ),
+    ).toBe('invalid');
+    expect(r.body.reason).toContain('envelope_correlation_conflict');
+  });
+
+  it('cached outcome of any status (invalid/gated/breached) replays identically', async () => {
+    // Plant a `gated` cached outcome; second emission MUST return the same gated outcome
+    // (handler MUST NOT re-run, even if conditions might now accept).
+    const cached = {
+      status: 'gated' as const,
+      reason: 'envelope type \'vendor.x.foo\' not advertised',
+      allowedKinds: ['clarification.request', 'schema.request', 'schema.response', 'error'],
+    };
+    const r = await accept(
+      {
+        type: 'vendor.x.foo',
+        schemaVersion: 1,
+        envelopeId: 'env-cr-cached-gated',
+        correlationId: 'r:n:0:cachedgated',
+        payload: {},
+        meta: baseMeta,
+      },
+      {
+        hostSupportedEnvelopes: ['vendor.x.foo'], // would otherwise accept
+        priorCorrelations: [
+          {
+            correlationId: 'r:n:0:cachedgated',
+            outcome: cached,
+            envelopeType: 'vendor.x.foo',
+          },
+        ],
+      },
+    );
+    if (r.status === 404) return;
+    expect(
+      r.body.status,
+      driver.describe(
+        'ai-envelope.md §"Replay determinism"',
+        'cached non-accepted outcome MUST replay identically (handler at most once per correlationId)',
+      ),
+    ).toBe('gated');
+  });
+});
+
+// E.1 engine-projection via the test-only event-log seam.
+import { queryTestEvents, isEventLogSeamAvailable, resetTestSeam } from '../lib/event-log-query.js';
+
+describe('aiEnvelope.correlationReplay: causationId projection via event-log seam', () => {
+  it('resulting RunEventDoc.causationId MUST equal the envelope.correlationId (causal chain preserved)', async () => {
+    if (!(await isEventLogSeamAvailable())) return;
+    const runId = `r-cr-cause-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const correlationId = `${runId}:n:0:causationId-link`;
+    await accept(
+      {
+        type: 'clarification.request',
+        schemaVersion: 1,
+        envelopeId: 'env-cr-cause-1',
+        correlationId,
+        payload: { questions: [{ id: 'q1', question: 'why?' }] },
+        meta: baseMeta,
+      },
+      { projectTo: { runId, nodeId: 'n' } },
+    );
+    const events = await queryTestEvents(runId);
+    if (!events.ok || events.events.length === 0) return;
+    for (const e of events.events) {
+      expect(
+        e.causationId,
+        driver.describe('ai-envelope.md §"Replay determinism"', 'every event projected from an envelope MUST carry causationId === envelope.correlationId'),
+      ).toBe(correlationId);
+    }
+    await resetTestSeam();
+  });
+});
+
+describe('aiEnvelope.correlationReplay: cross-process replay via persisted dedup', () => {
+  // Cross-process replay proven WITHOUT actually killing the process:
+  // when a caller supplies `persistedDedup: { runId }`, the seam reads
+  // the persisted store BEFORE consulting the in-memory priorCorrelations
+  // and writes the outcome back after a successful accept. A second
+  // call from the same (or a hypothetically-restarted) process with
+  // ONLY persistedDedup set — no in-memory priorCorrelations — MUST
+  // return the same outcome as the first. That is the cross-process
+  // semantics: the persisted store is the source of truth, the in-
+  // memory map a per-process accelerator.
+  it('persisted outcome replays for the same correlationId even with NO in-memory priorCorrelations', async () => {
+    const runId = `r-cr-persist-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const correlationId = `${runId}:n:0:persist1`;
+    const envelope = {
+      type: 'clarification.request',
+      schemaVersion: 1,
+      envelopeId: 'env-cr-persist-1',
+      correlationId,
+      payload: { questions: [{ id: 'q1', question: 'why?' }] },
+      meta: baseMeta,
+    };
+    // First accept persists the outcome under (runId, correlationId).
+    const first = await accept(envelope, { persistedDedup: { runId } });
+    if (first.status === 404) return; // seam not exposed — soft-skip
+    expect(first.body.status).toBe('accepted');
+    const cachedEnvelopeId = first.body.envelopeId;
+
+    // Second accept — same correlationId, NO priorCorrelations passed
+    // in-band. If the persisted store is consulted, the cached outcome
+    // is returned (same envelopeId). If only the in-memory map were
+    // used, the handler would re-run and mint a different envelopeId
+    // (or accept again with the original — either way, NOT the proof
+    // of cross-process semantics).
+    const second = await accept(envelope, { persistedDedup: { runId } });
+    expect(
+      second.body.envelopeId,
+      driver.describe(
+        'ai-envelope.md §"Replay determinism"',
+        'persisted outcome MUST replay across calls without an in-memory priorCorrelations map (cross-process recovery semantics)',
+      ),
+    ).toBe(cachedEnvelopeId);
+    expect(second.body.status).toBe('accepted');
+  });
+
+  it('persisted store enforces envelope_correlation_conflict across calls', async () => {
+    const runId = `r-cr-persist-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const correlationId = `${runId}:n:0:conflict1`;
+    // First accept: clarification.request.
+    const first = await accept(
+      {
+        type: 'clarification.request',
+        schemaVersion: 1,
+        envelopeId: 'env-cr-persist-conflict-1',
+        correlationId,
+        payload: { questions: [{ id: 'q1', question: 'why?' }] },
+        meta: baseMeta,
+      },
+      { persistedDedup: { runId } },
+    );
+    if (first.status === 404) return;
+    expect(first.body.status).toBe('accepted');
+
+    // Second accept: same correlationId, different envelope type, NO
+    // in-memory priorCorrelations — the conflict MUST be served from
+    // the persisted store.
+    const second = await accept(
+      {
+        type: 'error',
+        schemaVersion: 1,
+        envelopeId: 'env-cr-persist-conflict-2',
+        correlationId,
+        payload: { code: 'x', message: 'y' },
+        meta: baseMeta,
+      },
+      { persistedDedup: { runId } },
+    );
+    expect(
+      second.body.status,
+      driver.describe(
+        'ai-envelope.md §"Replay determinism"',
+        'persisted store MUST surface envelope_correlation_conflict on type mismatch without an in-memory priorCorrelations map',
+      ),
+    ).toBe('invalid');
+    expect(second.body.reason).toContain('envelope_correlation_conflict');
+  });
+});