@openwop/openwop-conformance 1.0.0

package/src/scenarios/streamReconnect.test.ts

@@ -0,0 +1,162 @@
+/**
+ * Stream-reconnect scenarios per spec/v1/stream-modes.md §"Reconnection."
+ *
+ * After a client connects, reads some events, and disconnects, a fresh
+ * connection with `Last-Event-ID: <last-seq-seen>` MUST resume from the
+ * next event without loss or duplication.
+ *
+ * Profile gating: `openwop-stream-sse`. Hosts that don't expose SSE
+ * skip-equivalent.
+ *
+ * **Tagged `@timing-sensitive`** — relies on a long-running fixture
+ * (`conformance-cancellable` with `delayMs > 1000`) so the reconnect
+ * happens mid-stream. Tolerance window: 30s for the full run lifecycle.
+ *
+ * @see spec/v1/stream-modes.md §"Reconnection"
+ * @see lib/sse.ts — subscribe() accepts lastEventId
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { subscribe, type SseEvent } from '../lib/sse.js';
+import { pollUntilTerminal } from '../lib/polling.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+
+const WORKFLOW_ID = 'conformance-cancellable';
+const SKIP_NO_FIXTURE = !isFixtureAdvertised(WORKFLOW_ID);
+const TERMINAL_TYPES = new Set(['run.completed', 'run.failed', 'run.cancelled']);
+
+interface EventPayload {
+  seq?: number;
+  sequence?: number;
+  type?: string;
+  [key: string]: unknown;
+}
+
+function getSeq(event: SseEvent): number | null {
+  if (event.id !== null) {
+    const parsed = Number(event.id);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  try {
+    const payload = JSON.parse(event.data) as EventPayload;
+    if (typeof payload.sequence === 'number') return payload.sequence;
+    if (typeof payload.seq === 'number') return payload.seq;
+  } catch {
+    // ignore — not all events carry JSON data
+  }
+  return null;
+}
+
+describe.skipIf(SKIP_NO_FIXTURE)('stream-reconnect: Last-Event-ID resume per spec/v1/stream-modes.md', () => {
+  it(
+    'reconnect with Last-Event-ID resumes without loss or duplication',
+    async () => {
+      // Phase 1: kick off a long-running run.
+      const create = await driver.post('/v1/runs', {
+        workflowId: WORKFLOW_ID,
+        inputs: { delayMs: 2000 },
+      });
+      if (create.status !== 201) return; // host doesn't seed cancellable fixture; skip-equivalent
+
+      const runId = (create.json as { runId: string }).runId;
+
+      // Phase 2: connect, take ~1s of stream, disconnect.
+      const firstHalf = await subscribe(`/v1/runs/${encodeURIComponent(runId)}/events`, {
+        timeoutMs: 1000, // disconnect after ~1s
+      });
+      expect(firstHalf.status, driver.describe(
+        'spec/v1/stream-modes.md',
+        'SSE endpoint MUST return 200',
+      )).toBe(200);
+      // The first connection might or might not have caught the terminal
+      // event before timeout — either way, the test assertion is on the
+      // resume.
+
+      // Find the highest sequence number we saw.
+      const firstSeqs = firstHalf.events.map(getSeq).filter((s): s is number => s !== null);
+      const lastSeen = firstSeqs.length > 0 ? Math.max(...firstSeqs) : -1;
+
+      if (lastSeen < 0) {
+        // First connection emitted no events with a parseable sequence — e.g.
+        // because the run already completed and the server closed before we
+        // got events. Skip the rest of this scenario; the host is fast enough
+        // that the reconnect path doesn't apply.
+        return;
+      }
+
+      // Phase 3: reconnect with Last-Event-ID set to the last seq we saw.
+      // Per stream-modes.md, the resume MUST yield events with seq > lastSeen.
+      const resume = await subscribe(`/v1/runs/${encodeURIComponent(runId)}/events`, {
+        timeoutMs: 5000,
+        lastEventId: String(lastSeen),
+      });
+      expect(resume.status, driver.describe(
+        'spec/v1/stream-modes.md §"Reconnection"',
+        'reconnection with Last-Event-ID MUST return 200',
+      )).toBe(200);
+
+      // Phase 4: assert no duplicates.
+      const resumeSeqs = resume.events.map(getSeq).filter((s): s is number => s !== null);
+      for (const s of resumeSeqs) {
+        // Hosts MAY replay the boundary event (some impls do; spec is
+        // permissive). The strict assertion is "no event with seq <
+        // lastSeen-1" — i.e., no events from before the resume point.
+        expect(s, driver.describe(
+          'spec/v1/stream-modes.md §"Reconnection"',
+          `resume MUST NOT yield events with seq < lastSeen-1; got ${s} after lastSeen=${lastSeen}`,
+        )).toBeGreaterThanOrEqual(lastSeen - 1);
+      }
+
+      // Phase 5: ensure the run has reached terminal state by now.
+      await pollUntilTerminal(runId, { timeoutMs: 10_000 });
+    },
+    60_000, // overall scenario timeout — well above the 30s @timing-sensitive budget
+  );
+
+  it(
+    'reconnect with Last-Event-ID equal to terminal seq closes immediately',
+    async () => {
+      // Quick run, observe terminal seq, then attempt a reconnect after
+      // terminal — server SHOULD close immediately with no events.
+      const create = await driver.post('/v1/runs', { workflowId: 'conformance-noop' });
+      if (create.status !== 201) return;
+      const runId = (create.json as { runId: string }).runId;
+
+      const initial = await subscribe(`/v1/runs/${encodeURIComponent(runId)}/events`, {
+        timeoutMs: 5000,
+      });
+      if (initial.status !== 200 || initial.events.length === 0) return;
+
+      const terminalEvent = initial.events.find(
+        (e) => TERMINAL_TYPES.has(e.event) && e.id !== null && Number.isFinite(Number(e.id)),
+      );
+      if (!terminalEvent || terminalEvent.id === null) return;
+
+      const lastSeq = Number(terminalEvent.id);
+      if (!Number.isFinite(lastSeq)) return;
+
+      const reconnect = await subscribe(`/v1/runs/${encodeURIComponent(runId)}/events`, {
+        timeoutMs: 5000,
+        lastEventId: String(lastSeq),
+      });
+
+      // Reconnect MUST succeed (200) and SHOULD close quickly with no
+      // additional events beyond the terminal boundary. Permissive: the
+      // host MAY replay the terminal event itself.
+      expect(reconnect.status, driver.describe(
+        'spec/v1/stream-modes.md §"Reconnection"',
+        'reconnect after terminal MUST return 200',
+      )).toBe(200);
+
+      const newSeqs = reconnect.events
+        .map(getSeq)
+        .filter((s): s is number => s !== null && s > lastSeq);
+      expect(newSeqs.length, driver.describe(
+        'spec/v1/stream-modes.md §"Reconnection"',
+        'reconnect after terminal MUST NOT yield events with seq > lastSeq',
+      )).toBe(0);
+    },
+    30_000,
+  );
+});

package/src/scenarios/subworkflow.test.ts

@@ -0,0 +1,126 @@
+/**
+ * Sub-workflow scenarios (G3 / F2) — exercises `conformance-subworkflow-parent`
+ * which invokes `conformance-subworkflow-child` via `core.subWorkflow` with
+ * blocking dispatch.
+ *
+ * Verifies:
+ *   1. Parent run reaches terminal `completed`.
+ *   2. Child run was created and reached terminal `completed`.
+ *   3. Child run carries parent linkage (`parentRunId`, `parentNodeId`).
+ *   4. Child variables propagate to parent via outputMapping.
+ *   5. Both runs terminate within the parent's timeout.
+ *
+ * Spec references:
+ *   - node-packs.md §Reserved Core openwop typeIds → `core.subWorkflow`
+ *   - conformance/fixtures.md §F2 sub-workflow fixture
+ *   - spec gap G3
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { pollUntilTerminal } from '../lib/polling.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+
+const PARENT_WORKFLOW_ID = 'conformance-subworkflow-parent';
+const CHILD_WORKFLOW_ID = 'conformance-subworkflow-child';
+const SKIP_NO_FIXTURE =
+  !isFixtureAdvertised(PARENT_WORKFLOW_ID) || !isFixtureAdvertised(CHILD_WORKFLOW_ID);
+
+interface RunSnapshot {
+  readonly runId: string;
+  readonly status: string;
+  readonly variables?: Record<string, unknown>;
+  readonly parentRunId?: string;
+  readonly parentNodeId?: string;
+  readonly childDepth?: number;
+  readonly error?: { code?: string; message?: string };
+}
+
+interface RunEvent {
+  readonly type: string;
+  readonly nodeId?: string;
+  readonly sequence: number;
+  readonly payload?: unknown;
+}
+
+describe.skipIf(SKIP_NO_FIXTURE)('subworkflow: conformance-subworkflow-parent dispatches child + completes', () => {
+  it('parent run reaches terminal completed and child variable is propagated via outputMapping', async () => {
+    const create = await driver.post('/v1/runs', { workflowId: PARENT_WORKFLOW_ID });
+    expect(create.status).toBe(201);
+    const parentRunId = (create.json as { runId: string }).runId;
+
+    const parentTerminal = await pollUntilTerminal(parentRunId);
+    expect(parentTerminal.status, driver.describe(
+      'fixtures.md conformance-subworkflow-parent §Terminal status',
+      'parent fixture MUST reach terminal `completed` after child finishes',
+    )).toBe('completed');
+
+    // outputMapping in the parent fixture maps child's `childResult` →
+    // parent's `childOutcome`. The variable should appear on the parent's
+    // final variables.
+    const parentVars = (parentTerminal as RunSnapshot).variables ?? {};
+    expect(parentVars.childOutcome, driver.describe(
+      'node-packs.md §core.subWorkflow outputMapping',
+      'parent variables MUST include `childOutcome` mapped from child `childResult`',
+    )).toBeDefined();
+    expect(parentVars.childOutcome).toBe('child-completed');
+  });
+
+  it('child run is created with parent linkage fields and reaches terminal completed', async () => {
+    const create = await driver.post('/v1/runs', { workflowId: PARENT_WORKFLOW_ID });
+    const parentRunId = (create.json as { runId: string }).runId;
+
+    await pollUntilTerminal(parentRunId);
+
+    // Find the child run id from the parent's event log. The
+    // `node.completed` event for `subwf-call` carries `outputs.childRunId`
+    // per `core.subWorkflow`'s outputSchema.
+    const eventsRes = await driver.get(
+      `/v1/runs/${encodeURIComponent(parentRunId)}/events/poll?lastSequence=0&timeout=1`,
+    );
+    expect(eventsRes.status).toBe(200);
+    const events = (eventsRes.json as { events?: RunEvent[] } | undefined)?.events ?? [];
+
+    const subwfCompleted = events.find(
+      (e) => e.type === 'node.completed' && e.nodeId === 'subwf-call',
+    );
+    expect(subwfCompleted, driver.describe(
+      'node-packs.md §core.subWorkflow',
+      'parent event log MUST contain node.completed for the subwf-call node',
+    )).toBeDefined();
+
+    const subwfPayload = subwfCompleted?.payload as
+      | { outputs?: { childRunId?: string; childStatus?: string; skipped?: boolean } }
+      | undefined;
+    const childRunId = subwfPayload?.outputs?.childRunId;
+    expect(typeof childRunId, driver.describe(
+      'node-packs.md §core.subWorkflow outputSchema',
+      'core.subWorkflow output MUST include childRunId as a string',
+    )).toBe('string');
+
+    expect(subwfPayload?.outputs?.childStatus, driver.describe(
+      'node-packs.md §core.subWorkflow outputSchema',
+      'core.subWorkflow output MUST include childStatus="completed" on success',
+    )).toBe('completed');
+
+    // Fetch the child run snapshot and verify parent linkage.
+    const childRes = await driver.get(`/v1/runs/${encodeURIComponent(childRunId!)}`);
+    expect(childRes.status, 'child run snapshot MUST be retrievable').toBe(200);
+    const child = childRes.json as RunSnapshot;
+
+    expect(child.status, driver.describe(
+      'fixtures.md conformance-subworkflow-child §Terminal status',
+      'child MUST reach terminal `completed`',
+    )).toBe('completed');
+
+    expect(child.parentRunId, driver.describe(
+      'spec gap G3 parent linkage',
+      'child run MUST carry parentRunId pointing back to dispatcher',
+    )).toBe(parentRunId);
+
+    expect(child.parentNodeId, driver.describe(
+      'spec gap G3 parent linkage',
+      'child run MUST carry parentNodeId pointing back to the subwf-call node',
+    )).toBe('subwf-call');
+  });
+});

package/src/scenarios/version-negotiation.test.ts

@@ -0,0 +1,157 @@
+/**
+ * Version-negotiation scenarios — exercises the surface defined by
+ * `version-negotiation.md`. Spec gap (per fixtures.md §F5): full
+ * cross-version compat scenarios need a server with multiple
+ * `engineVersion` releases or a schema-version cycle, which the v1.0
+ * black-box suite can't synthesize.
+ *
+ * What we CAN test cheaply:
+ *   1. Server advertises a `protocolVersion` in `Capabilities`.
+ *   2. The four version axes (`engineVersion`,
+ *      `eventLogSchemaVersion`, per-event `schemaVersion`,
+ *      `pinnedVersions`) appear where the spec says they should.
+ *   3. Forward-compat read: events carrying an UNKNOWN
+ *      `schemaVersion` SHOULD still be readable via the events/poll
+ *      endpoint without 5xx (best-effort fold per
+ *      run-event.schema.json §schemaVersion description).
+ *      We can't synthesize unknown schemaVersions from the client, so
+ *      this is checked indirectly — every event the server emits today
+ *      MUST carry `eventId`, `runId`, `type`, `payload`, `timestamp`,
+ *      `sequence` (the required fields per the JSON Schema). Drift in
+ *      the canonical shape would trip this scenario before any future
+ *      version-bump scenario could.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { pollUntilTerminal } from '../lib/polling.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+
+const NOOP_WORKFLOW_ID = 'conformance-noop';
+const SKIP_NO_NOOP = !isFixtureAdvertised(NOOP_WORKFLOW_ID);
+
+interface RunEvent {
+  readonly eventId: string;
+  readonly runId: string;
+  readonly type: string;
+  readonly payload: unknown;
+  readonly timestamp: string;
+  readonly sequence: number;
+  readonly schemaVersion?: number;
+  readonly engineVersion?: string;
+}
+
+describe('version-negotiation: Capabilities advertises a protocolVersion', () => {
+  it('GET /.well-known/openwop returns Capabilities with protocolVersion (string)', async () => {
+    const res = await driver.get('/.well-known/openwop', { authenticated: false });
+    expect(res.status).toBe(200);
+
+    const caps = res.json as { protocolVersion?: unknown };
+    expect(typeof caps.protocolVersion, driver.describe(
+      'capabilities.md §3 + version-negotiation.md',
+      'Capabilities.protocolVersion MUST be a non-empty string',
+    )).toBe('string');
+    expect(String(caps.protocolVersion).length).toBeGreaterThan(0);
+  });
+});
+
+describe.skipIf(SKIP_NO_NOOP)('version-negotiation: persisted events carry the canonical RunEventDoc shape', () => {
+  it('every event has the 6 required RunEventDoc fields per run-event.schema.json', async () => {
+    const create = await driver.post('/v1/runs', { workflowId: NOOP_WORKFLOW_ID });
+    expect(create.status).toBe(201);
+    const runId = (create.json as { runId: string }).runId;
+
+    await pollUntilTerminal(runId);
+
+    const eventsRes = await driver.get(
+      `/v1/runs/${encodeURIComponent(runId)}/events/poll?lastSequence=0&timeout=1`,
+    );
+    expect(eventsRes.status).toBe(200);
+
+    const events = (eventsRes.json as { events?: RunEvent[] } | undefined)?.events ?? [];
+    expect(events.length, 'noop run MUST emit at least one event').toBeGreaterThan(0);
+
+    for (const e of events) {
+      expect(typeof e.eventId, driver.describe(
+        'run-event.schema.json §required',
+        'eventId MUST be a string',
+      )).toBe('string');
+      expect(typeof e.runId, driver.describe(
+        'run-event.schema.json §required',
+        'runId MUST be a string',
+      )).toBe('string');
+      expect(typeof e.type, driver.describe(
+        'run-event.schema.json §required',
+        'type MUST be a string (RunEventType discriminator)',
+      )).toBe('string');
+      expect(e.payload, driver.describe(
+        'run-event.schema.json §required',
+        'payload MUST be present (any JSON value, including null)',
+      )).not.toBe(undefined);
+      expect(typeof e.timestamp, driver.describe(
+        'run-event.schema.json §required',
+        'timestamp MUST be an ISO 8601 string',
+      )).toBe('string');
+      expect(Number.isInteger(e.sequence), driver.describe(
+        'run-event.schema.json §required',
+        'sequence MUST be a non-negative integer',
+      )).toBe(true);
+      expect(e.sequence, 'sequence MUST be >= 0').toBeGreaterThanOrEqual(0);
+    }
+  });
+
+  it('event sequences within a run are strictly monotonic', async () => {
+    const create = await driver.post('/v1/runs', { workflowId: NOOP_WORKFLOW_ID });
+    expect(create.status).toBe(201);
+    const runId = (create.json as { runId: string }).runId;
+
+    await pollUntilTerminal(runId);
+
+    const eventsRes = await driver.get(
+      `/v1/runs/${encodeURIComponent(runId)}/events/poll?lastSequence=0&timeout=1`,
+    );
+    const events = (eventsRes.json as { events?: RunEvent[] } | undefined)?.events ?? [];
+
+    const sequences = events.map((e) => e.sequence);
+    for (let i = 1; i < sequences.length; i++) {
+      const prev = sequences[i - 1] ?? -1;
+      const curr = sequences[i] ?? -1;
+      expect(
+        curr,
+        driver.describe(
+          'run-event.schema.json §sequence + idempotency.md',
+          `event[${i}].sequence (${curr}) MUST be > event[${i - 1}].sequence (${prev}) — strictly monotonic per run`,
+        ),
+      ).toBeGreaterThan(prev);
+    }
+  });
+});
+
+describe.skipIf(SKIP_NO_NOOP)('version-negotiation: events/poll forward-compat tolerance', () => {
+  it('events/poll with lastSequence past current end returns empty events + isComplete', async () => {
+    const create = await driver.post('/v1/runs', { workflowId: NOOP_WORKFLOW_ID });
+    expect(create.status).toBe(201);
+    const runId = (create.json as { runId: string }).runId;
+
+    await pollUntilTerminal(runId);
+
+    // For a terminal run, asking for events past the end is a benign
+    // empty response — not a 4xx. Forward-compat readers will use this
+    // pattern after recovering from a deploy that bumped sequence numbers.
+    const eventsRes = await driver.get(
+      `/v1/runs/${encodeURIComponent(runId)}/events/poll?lastSequence=99999&timeout=1`,
+    );
+
+    expect(
+      eventsRes.status,
+      driver.describe(
+        'rest-endpoints.md GET /v1/runs/{runId}/events/poll',
+        'lastSequence beyond the current end MUST return 200 with empty events, not 4xx',
+      ),
+    ).toBe(200);
+
+    const body = eventsRes.json as { events?: RunEvent[]; isComplete?: boolean };
+    expect(Array.isArray(body.events)).toBe(true);
+    expect(body.events?.length).toBe(0);
+  });
+});

package/src/scenarios/wasm-pack-abi-version-rejection.test.ts

@@ -0,0 +1,47 @@
+/**
+ * RFC 0008 §Conformance — scenario 6/6: ABI version mismatch.
+ *
+ * Verifies that a host refuses to load a WASM pack whose declared ABI
+ * version is not in the host's advertised `abiVersions[]`. The host's
+ * loader MUST surface a recognizable `unsupported_abi_version` error
+ * (or equivalent) and MUST NOT silently dispatch to the pack's
+ * `openwop_node_invoke`.
+ *
+ * Driving this end-to-end requires a pack with a deliberately wrong
+ * ABI version. That pack is filed as v1.x follow-up (an
+ * `examples/packs/abi-mismatch/`). The framework here asserts the
+ * shape of the host's advertisement so future scenarios can rely on it.
+ *
+ * @see RFCS/0008-wasm-abi.md §H (abiVersions array)
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+
+describe('wasm-pack-abi-version-rejection: host advertises supported ABI versions', () => {
+  it('abiVersions[] contains positive integers; loader rejects unsupported versions', async () => {
+    const disco = await driver.get('/.well-known/openwop');
+    const wasm =
+      (disco.json as {
+        capabilities?: { nodePackRuntimes?: { wasm?: { supported?: boolean; abiVersions?: unknown } } };
+      }).capabilities?.nodePackRuntimes?.wasm;
+
+    if (!wasm?.supported) return;
+
+    expect(Array.isArray(wasm.abiVersions), driver.describe(
+      'RFCS/0008-wasm-abi.md §H',
+      'capabilities.nodePackRuntimes.wasm.abiVersions MUST be an array',
+    )).toBe(true);
+
+    if (Array.isArray(wasm.abiVersions)) {
+      expect(wasm.abiVersions.length).toBeGreaterThan(0);
+      for (const v of wasm.abiVersions) {
+        expect(typeof v).toBe('number');
+        expect(Number.isInteger(v)).toBe(true);
+        expect(v).toBeGreaterThan(0);
+      }
+      // v1.1 hosts MUST support ABI v1 if they support WASM at all.
+      expect((wasm.abiVersions as number[]).includes(1)).toBe(true);
+    }
+  });
+});

package/src/scenarios/wasm-pack-invoke-completed.test.ts

@@ -0,0 +1,69 @@
+/**
+ * RFC 0008 §Conformance — scenario 2/6: invoke returning `outcome: 'completed'`.
+ *
+ * Verifies that a WASM-packaged node's completed-outcome response
+ * round-trips through the host:
+ *   1. Workflow runs to `completed` terminal.
+ *   2. The node's `node.completed` event carries the WASM-emitted output.
+ *
+ * Uses the reference Rust pack's `vendor.openwop.rust-hello.greet` typeId,
+ * whose contract is: `{ name: string }` → `{ greeting: "Hello, <name>!" }`.
+ *
+ * @see RFCS/0008-wasm-abi.md §D (response envelope shapes)
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { pollUntilTerminal } from '../lib/polling.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+
+const FIXTURE = 'conformance-wasm-pack-roundtrip';
+
+async function isWasmSupported(): Promise<boolean> {
+  const disco = await driver.get('/.well-known/openwop');
+  return Boolean(
+    (disco.json as { capabilities?: { nodePackRuntimes?: { wasm?: { supported?: boolean } } } })
+      .capabilities?.nodePackRuntimes?.wasm?.supported,
+  );
+}
+
+describe('wasm-pack-invoke-completed: round-trip output', () => {
+  it('greet node returns Hello, <name>! and run reaches completed', async () => {
+    if (!isFixtureAdvertised(FIXTURE)) return;
+    if (!(await isWasmSupported())) {
+      // eslint-disable-next-line no-console
+      console.warn('[wasm-pack-invoke-completed] WASM not advertised; skipping');
+      return;
+    }
+
+    const create = await driver.post('/v1/runs', {
+      workflowId: FIXTURE,
+      inputs: { name: 'openwop' },
+    });
+    expect(create.status).toBe(201);
+    const runId = (create.json as { runId: string }).runId;
+
+    const terminal = await pollUntilTerminal(runId, { timeoutMs: 15_000 });
+    expect(terminal.status, driver.describe(
+      'RFCS/0008-wasm-abi.md §D',
+      "WASM 'completed' outcome MUST drive terminal 'completed' run status",
+    )).toBe('completed');
+
+    const events = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/events`);
+    const list = (events.json as { events?: Array<{ type: string; data?: unknown }> }).events ?? [];
+    const completedNode = list.find((e) => e.type === 'node.completed');
+    const haystack = JSON.stringify(completedNode ?? {}).toLowerCase();
+    // Hosts MAY surface the WASM output on node.completed.data.output (this
+    // host's convention) OR via a downstream artifact. Either way the
+    // string "hello, openwop" MUST appear in the event log so observers
+    // can audit the round-trip.
+    const fullLog = JSON.stringify(list).toLowerCase();
+    expect(
+      haystack.includes('hello, openwop') || fullLog.includes('hello, openwop'),
+      driver.describe(
+        'RFCS/0008-wasm-abi.md §D',
+        "WASM completion output MUST be surfaced somewhere in the run's event log so consumers can read it",
+      ),
+    ).toBe(true);
+  });
+});

package/src/scenarios/wasm-pack-invoke-suspended.test.ts

@@ -0,0 +1,74 @@
+/**
+ * RFC 0008 §Conformance — scenario 3/6: invoke returning `outcome: 'suspended'`.
+ *
+ * Verifies that when a WASM-packaged node returns `outcome: 'suspended'`
+ * the host honors the suspension contract:
+ *   1. Run transitions to a `waiting-*` state (NOT terminal failure).
+ *   2. The interrupt payload reaches the run's interrupt surface.
+ *   3. Resolving the interrupt resumes the node, which re-invokes the
+ *      WASM `openwop_node_invoke` with the resume value available.
+ *
+ * Hosts that don't support WASM-driven suspends MAY return a recognizable
+ * `wasm_suspend_not_implemented` failure code — the scenario soft-passes
+ * in that case (the contract is "if supported, honor it"; explicit
+ * non-support is acceptable for v1.1).
+ *
+ * @see RFCS/0008-wasm-abi.md §D (response envelope) + §C (openwop_interrupt import)
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { pollUntilTerminal } from '../lib/polling.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+
+const FIXTURE = 'conformance-wasm-pack-roundtrip';
+
+async function isWasmSupported(): Promise<boolean> {
+  const disco = await driver.get('/.well-known/openwop');
+  return Boolean(
+    (disco.json as { capabilities?: { nodePackRuntimes?: { wasm?: { supported?: boolean } } } })
+      .capabilities?.nodePackRuntimes?.wasm?.supported,
+  );
+}
+
+describe('wasm-pack-invoke-suspended: suspend → resume round-trip', () => {
+  it('host either suspends the run or explicitly reports wasm_suspend_not_implemented', async () => {
+    if (!isFixtureAdvertised(FIXTURE)) return;
+    if (!(await isWasmSupported())) return;
+
+    // The reference rust-hello pack does NOT itself suspend (it always
+    // returns `completed`), so against that pack this scenario can only
+    // assert the negative path: a run completes without entering a
+    // waiting-* state. A pack that explicitly suspends would be needed
+    // to exercise the positive path; tracked as v1.x follow-up.
+    const create = await driver.post('/v1/runs', {
+      workflowId: FIXTURE,
+      inputs: { name: 'suspend-probe' },
+    });
+    expect(create.status).toBe(201);
+    const runId = (create.json as { runId: string }).runId;
+
+    const terminal = await pollUntilTerminal(runId, { timeoutMs: 15_000 });
+
+    if (terminal.status === 'failed') {
+      // Acceptable if the host reports the recognizable code from
+      // RFC 0008 §D for hosts that don't implement WASM suspends.
+      const events = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/events`);
+      const list = (events.json as { events?: Array<{ type: string; data?: unknown }> }).events ?? [];
+      const haystack = JSON.stringify(list).toLowerCase();
+      const ok =
+        haystack.includes('wasm_suspend_not_implemented') ||
+        haystack.includes('suspend_not_supported');
+      expect(ok, driver.describe(
+        'RFCS/0008-wasm-abi.md §D',
+        "if a host doesn't implement WASM-driven suspends it MUST surface a recognizable code",
+      )).toBe(true);
+      return;
+    }
+
+    // Completed path: the reference pack never suspends. Asserting
+    // 'completed' confirms the host did not spuriously enter a
+    // waiting-* state.
+    expect(terminal.status).toBe('completed');
+  });
+});