@openwop/openwop-conformance 1.0.0

package/src/scenarios/channel-ttl.test.ts

@@ -0,0 +1,70 @@
+/**
+ * Channel TTL scenarios (G5 / C3) — exercises `conformance-channel-ttl`.
+ *
+ * Workflow writes 3 entries (values a/b/c) to channel `events` with
+ * ttlMs=200, waits 300ms via `core.delay`, then writes a 4th (value d).
+ *
+ * Verifies:
+ *   1. Run reaches terminal `completed`.
+ *   2. After the post-TTL write, the `events` channel state contains
+ *      exactly one entry.
+ *   3. The remaining entry has value `"d"` (the 3 priors were dropped at
+ *      write time because their `_ts` predated `now - ttlMs`).
+ *   4. The remaining entry preserves the `_ts` timestamp produced at write.
+ *
+ * Spec references:
+ *   - channels-and-reducers.md §append + §TTL
+ *   - node-packs.md §Reserved Core openwop typeIds → core.channelWrite
+ *   - spec gap G5
+ */
+
+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 WORKFLOW_ID = 'conformance-channel-ttl';
+const SKIP_NO_FIXTURE = !isFixtureAdvertised(WORKFLOW_ID);
+
+interface ChannelEntry {
+  value: unknown;
+  _ts: number;
+}
+
+describe.skipIf(SKIP_NO_FIXTURE)('channel-ttl: conformance-channel-ttl drops entries older than ttlMs at write time', () => {
+  it('after the post-TTL write, the channel contains exactly one entry with value "d"', async () => {
+    const create = await driver.post('/v1/runs', { workflowId: WORKFLOW_ID });
+    expect(create.status).toBe(201);
+    const runId = (create.json as { runId: string }).runId;
+
+    const terminal = await pollUntilTerminal(runId);
+    expect(terminal.status, driver.describe(
+      'fixtures.md conformance-channel-ttl §Terminal status',
+      'fixture MUST reach terminal `completed`',
+    )).toBe('completed');
+
+    const variables = terminal.variables ?? {};
+    const events = variables.events as ChannelEntry[] | undefined;
+
+    expect(Array.isArray(events), driver.describe(
+      'channels-and-reducers.md §append',
+      'channel state MUST be stored as an array of {value, _ts} entries',
+    )).toBe(true);
+
+    expect(events!.length, driver.describe(
+      'channels-and-reducers.md §TTL — write-time filter',
+      'after the post-TTL write, exactly 1 entry MUST remain (the 3 priors aged out)',
+    )).toBe(1);
+
+    expect(events![0].value, driver.describe(
+      'fixtures.md conformance-channel-ttl §Topology',
+      'the surviving entry MUST be the post-delay write (value "d")',
+    )).toBe('d');
+
+    expect(typeof events![0]._ts, driver.describe(
+      'channels-and-reducers.md §append entry shape',
+      'each channel entry MUST carry a numeric `_ts` write timestamp',
+    )).toBe('number');
+    expect(events![0]._ts).toBeGreaterThan(0);
+  });
+});

package/src/scenarios/configurable-schema.test.ts

@@ -0,0 +1,76 @@
+/**
+ * Track 13: per-workflow `configurableSchema` (run-options.md v1.1).
+ *
+ * Verifies that hosts which surface `configurableSchema` on a workflow
+ * definition (a) reject runs whose `configurable` violates the schema
+ * with `validation_error`, and (b) surface the schema on
+ * `GET /v1/workflows/{workflowId}`.
+ *
+ * Capability gating: skips when no advertised fixture declares
+ * `configurableSchema`. Hosts that don't yet support per-workflow
+ * configurableSchema return absence of the field on the manifest, in
+ * which case this scenario skips.
+ *
+ * @see spec/v1/run-options.md §"Per-workflow configurableSchema"
+ * @see schemas/workflow-definition.schema.json §configurableSchema
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+
+// Re-use `conformance-identity` if it advertises a configurableSchema;
+// otherwise the scenario soft-skips. Hosts adopting v1.1 SHOULD seed a
+// dedicated `conformance-configurable-schema` fixture; until that lands,
+// reuse what's available.
+const CANDIDATES = ['conformance-configurable-schema', 'conformance-identity'] as const;
+
+async function pickFixture(): Promise<string | null> {
+  for (const id of CANDIDATES) {
+    if (!isFixtureAdvertised(id)) continue;
+    const manifest = await driver.get(`/v1/workflows/${encodeURIComponent(id)}`);
+    if (manifest.status !== 200) continue;
+    const def = manifest.json as { configurableSchema?: unknown };
+    if (def.configurableSchema && typeof def.configurableSchema === 'object') return id;
+  }
+  return null;
+}
+
+describe('configurable-schema: per-workflow schema enforced', () => {
+  it('manifest surfaces configurableSchema; mismatched configurable is rejected', async () => {
+    const fixture = await pickFixture();
+    if (!fixture) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        '[configurable-schema] no advertised fixture declares configurableSchema; skipping',
+      );
+      return;
+    }
+
+    const manifest = await driver.get(`/v1/workflows/${encodeURIComponent(fixture)}`);
+    const schema = (manifest.json as { configurableSchema?: Record<string, unknown> })
+      .configurableSchema;
+    expect(schema, driver.describe(
+      'run-options.md §"Per-workflow configurableSchema"',
+      'GET /v1/workflows/{workflowId} MUST surface configurableSchema when the workflow declares one',
+    )).toBeDefined();
+
+    // Provide a deliberately invalid override — a key the schema either
+    // forbids (additionalProperties: false) or whose type is wrong. The
+    // generic shape `{__invalid_key__: 'not-a-number'}` exercises both.
+    const create = await driver.post('/v1/runs', {
+      workflowId: fixture,
+      configurable: { __conformance_invalid_key__: { unexpected: true } },
+    });
+    expect(
+      [400, 422].includes(create.status),
+      driver.describe(
+        'run-options.md §"Per-workflow configurableSchema"',
+        'configurable that violates the workflow schema MUST be rejected with 400/422',
+      ),
+    ).toBe(true);
+
+    const body = create.json as { error?: string };
+    expect(body.error).toBe('validation_error');
+  });
+});

package/src/scenarios/conversationCapabilityNegotiation.test.ts

@@ -0,0 +1,39 @@
+/**
+ * Multi-Agent Shift Phase 4 — capability-gate refusal contract.
+ *
+ * Verifies that a host which does NOT advertise
+ * `capabilities.conversationPrimitive: true` MUST refuse a workflow
+ * registration that declares `core.conversationGate` nodes, with
+ * `validation_error` per spec/v1/capabilities.md §`conversationPrimitive`.
+ *
+ * This scenario is the COMPLEMENT of the other Phase-4 scenarios — it
+ * runs ONLY when conversation primitive is NOT advertised, to verify the
+ * refusal contract is honored.
+ *
+ * Fixture-gated: requires `conformance-conversation-capability-negotiation`.
+ *
+ * @see spec/v1/capabilities.md §`conversationPrimitive`
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { isConversationPrimitiveSupported } from '../lib/multi-agent-capabilities.js';
+
+const FIXTURE = 'conformance-conversation-capability-negotiation';
+// Inverted gate: this scenario runs when host does NOT advertise the
+// capability, to verify the refusal contract.
+const SKIP = isConversationPrimitiveSupported() || !isFixtureAdvertised(FIXTURE);
+
+describe.skipIf(SKIP)('conversationCapabilityNegotiation: refusal contract', () => {
+  it('host without conversationPrimitive capability refuses conversation-bearing workflow', async () => {
+    const create = await driver.post('/v1/runs', { workflowId: FIXTURE });
+    // The host MUST reject — either at workflow registration (404/400)
+    // or at run-create (400). What MUST NOT happen is a successful
+    // 201 followed by silent fallback.
+    expect([400, 404, 422]).toContain(create.status);
+    const body = create.json as { error?: { code?: string }; code?: string };
+    const code = body.error?.code ?? body.code ?? '';
+    expect(typeof code).toBe('string');
+  });
+});

package/src/scenarios/conversationLifecycle.test.ts

@@ -0,0 +1,64 @@
+/**
+ * Multi-Agent Shift Phase 4 — conversation primitive lifecycle.
+ *
+ * Verifies the open → exchange → close lifecycle:
+ *   1. `conversation.opened` emitted on `core.conversationGate.open`.
+ *   2. `conversation.exchanged` emitted on resume after a single turn.
+ *   3. `conversation.closed` emitted on `core.conversationGate.close`.
+ *   4. All three events share the same `conversationId`.
+ *   5. Per CO-3: no `conversation.exchanged` events follow
+ *      `conversation.closed` for the same conversationId.
+ *
+ * Capability-gated: skips when host doesn't advertise
+ * `capabilities.conversationPrimitive: true`. Fixture-gated: requires
+ * `conformance-conversation-lifecycle`.
+ *
+ * @see spec/v1/interrupt.md §`conversation.start`
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { pollUntilTerminal } from '../lib/polling.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { isConversationPrimitiveSupported } from '../lib/multi-agent-capabilities.js';
+
+const FIXTURE = 'conformance-conversation-lifecycle';
+const SKIP = !isConversationPrimitiveSupported() || !isFixtureAdvertised(FIXTURE);
+
+describe.skipIf(SKIP)('conversationLifecycle: open → exchange → close round-trip', () => {
+  it('emits all three lifecycle events with matching conversationId; no exchanges after close', async () => {
+    const create = await driver.post('/v1/runs', { workflowId: FIXTURE });
+    expect(create.status).toBe(201);
+    const runId = (create.json as { runId: string }).runId;
+
+    // The fixture's exchange step requires resume input. Host-internal
+    // mock auto-resumes for conformance.
+    await pollUntilTerminal(runId);
+
+    const events = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/events`);
+    const list = (events.json as { events?: Array<{ type: string; payload?: Record<string, unknown> }> })
+      .events ?? [];
+
+    const opened = list.filter((e) => e.type === 'conversation.opened');
+    const exchanged = list.filter((e) => e.type === 'conversation.exchanged');
+    const closed = list.filter((e) => e.type === 'conversation.closed');
+
+    expect(opened.length).toBeGreaterThan(0);
+    expect(closed.length).toBeGreaterThan(0);
+
+    // All three event types MUST share the same conversationId for the
+    // fixture's single conversation.
+    const convId = opened[0].payload?.conversationId as string;
+    expect(typeof convId).toBe('string');
+    for (const ev of [...opened, ...exchanged, ...closed]) {
+      expect(ev.payload?.conversationId).toBe(convId);
+    }
+
+    // CO-3: closed.sequence > all exchanged.sequence for the same id.
+    const closedIdx = list.findIndex((e) => e.type === 'conversation.closed');
+    const exchangedAfterClose = list
+      .slice(closedIdx + 1)
+      .filter((e) => e.type === 'conversation.exchanged' && e.payload?.conversationId === convId);
+    expect(exchangedAfterClose.length).toBe(0);
+  });
+});

package/src/scenarios/conversationReplayDeterminism.test.ts

@@ -0,0 +1,52 @@
+/**
+ * Multi-Agent Shift Phase 4 — replay-fork of a conversation produces identical log.
+ *
+ * Verifies that running `:fork` on a conversation-bearing run yields
+ * a child run whose conversation log (folded via the `message` reducer)
+ * is byte-equal to the source run's. Replay determinism is required
+ * for audit + debug-bundle consistency.
+ *
+ * Capability-gated: skips when host doesn't advertise conversation
+ * primitive OR doesn't advertise replay-fork. Fixture-gated: requires
+ * `conformance-conversation-replay`.
+ *
+ * @see spec/v1/replay.md
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { pollUntilTerminal } from '../lib/polling.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { isConversationPrimitiveSupported } from '../lib/multi-agent-capabilities.js';
+
+const FIXTURE = 'conformance-conversation-replay';
+const SKIP = !isConversationPrimitiveSupported() || !isFixtureAdvertised(FIXTURE);
+
+describe.skipIf(SKIP)('conversationReplayDeterminism: replay-fork preserves conversation log', () => {
+  it('forked run yields byte-equal conversation channel projection', async () => {
+    const create = await driver.post('/v1/runs', { workflowId: FIXTURE });
+    expect(create.status).toBe(201);
+    const sourceRunId = (create.json as { runId: string }).runId;
+
+    const terminal = await pollUntilTerminal(sourceRunId);
+    expect(terminal.status).toBe('completed');
+
+    const sourceSnap = await driver.get(`/v1/runs/${encodeURIComponent(sourceRunId)}`);
+    const sourceConv = (sourceSnap.json as { channels?: Record<string, unknown> }).channels;
+
+    const fork = await driver.post(`/v1/runs/${encodeURIComponent(sourceRunId)}:fork`, {
+      mode: 'replay',
+    });
+    if (fork.status === 404 || fork.status === 501) return; // host doesn't support replay-fork
+    expect([200, 201]).toContain(fork.status);
+
+    const forkedRunId = (fork.json as { runId: string }).runId;
+    const forkedTerminal = await pollUntilTerminal(forkedRunId);
+    expect(forkedTerminal.status).toBe('completed');
+
+    const forkedSnap = await driver.get(`/v1/runs/${encodeURIComponent(forkedRunId)}`);
+    const forkedConv = (forkedSnap.json as { channels?: Record<string, unknown> }).channels;
+
+    expect(JSON.stringify(forkedConv)).toBe(JSON.stringify(sourceConv));
+  });
+});

package/src/scenarios/conversationVsLegacySuspend.test.ts

@@ -0,0 +1,46 @@
+/**
+ * Multi-Agent Shift Phase 4 — `conversation.exchange` differs from `clarification.requested`.
+ *
+ * Verifies that `core.conversationGate.exchange` produces
+ * `conversation.exchanged` events in the run log — distinct from the
+ * pre-MAS `clarification.requested` / `clarification.resolved` shape.
+ * Hosts MUST NOT emit `clarification.requested` for conversation.exchange
+ * suspends; the two surfaces are independent.
+ *
+ * Capability-gated: skips when host doesn't advertise
+ * `capabilities.conversationPrimitive: true`. Fixture-gated: requires
+ * `conformance-conversation-vs-clarification`.
+ *
+ * @see spec/v1/interrupt.md §`conversation.exchange` vs `clarification`
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { pollUntilTerminal } from '../lib/polling.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { isConversationPrimitiveSupported } from '../lib/multi-agent-capabilities.js';
+
+const FIXTURE = 'conformance-conversation-vs-clarification';
+const SKIP = !isConversationPrimitiveSupported() || !isFixtureAdvertised(FIXTURE);
+
+describe.skipIf(SKIP)('conversationVsLegacySuspend: distinct event surfaces', () => {
+  it('conversation suspend emits conversation.* events, not clarification.*', async () => {
+    const create = await driver.post('/v1/runs', { workflowId: FIXTURE });
+    expect(create.status).toBe(201);
+    const runId = (create.json as { runId: string }).runId;
+
+    await pollUntilTerminal(runId);
+
+    const events = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/events`);
+    const list = (events.json as { events?: Array<{ type: string }> }).events ?? [];
+
+    const conversationEvents = list.filter((e) => e.type.startsWith('conversation.'));
+    const clarificationEvents = list.filter((e) => e.type.startsWith('clarification.'));
+
+    expect(conversationEvents.length).toBeGreaterThan(0);
+    expect(
+      clarificationEvents.length,
+      'conversation.exchange MUST NOT emit clarification.* events',
+    ).toBe(0);
+  });
+});

package/src/scenarios/cost-attribution.test.ts

@@ -0,0 +1,207 @@
+/**
+ * Cost attribution scenarios (G6 / O4) — covered by the v1.0 conformance baseline.
+ *
+ * The runtime side of G6 is expected to provide:
+ *   - OPENWOP_COST_ATTRIBUTE_NAMES allowlist (6 attributes)
+ *   - sanitizeCostForOtel() pure function with redaction enforcement
+ *   - cost-attribute application wired into the host's span recorder
+ *   - RunSnapshot.metrics.openwopCost rollup exposed via GET /v1/runs/{runId}
+ *
+ * Two scenarios:
+ *   1. Forward-compat shape check on any run's metrics.openwopCost (passes if
+ *      the field is absent — spec-allowed — AND if present validates the
+ *      canonical shape).
+ *   2. End-to-end content roundtrip via the `openwop-smoke-cost-emit` fixture
+ *      workflow + `conformance.cost.emit` fixture node. The scenario
+ *      detects fixture availability via the `404 workflow_not_found`
+ *      error envelope and skips trivially-pass when absent. When present,
+ *      asserts the canary cost shape lands in `metrics.openwopCost` end-to-end.
+ *
+ * Two scenarios remain `it.todo` because they need observable-span
+ * access — the conformance suite is black-box and can only see what the
+ * REST + event-log surfaces expose. Hosts should cover runtime-side
+ * enforcement in host-specific observability tests.
+ *
+ * Spec references:
+ *   - https://github.com/openwop/openwop/blob/main/spec/v1/observability.md §"AI cost"
+ *   - https://github.com/openwop/openwop/blob/main/spec/v1/schemas/run-snapshot.schema.json §metrics.openwopCost
+ *   - conformance/fixtures.md §O4 cost-attribution fixture
+ */
+
+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 COST_EMIT_WORKFLOW_ID = 'openwop-smoke-cost-emit';
+const SKIP_NO_NOOP = !isFixtureAdvertised(NOOP_WORKFLOW_ID);
+const SKIP_NO_COST_EMIT = !isFixtureAdvertised(COST_EMIT_WORKFLOW_ID);
+
+describe.skipIf(SKIP_NO_NOOP)('cost-attribution: metrics.openwopCost forward-compat shape (G6)', () => {
+  it('on any run, IF metrics.openwopCost is present, its shape MUST match the spec', async () => {
+    // Use the noop fixture so we don't depend on AI nodes. The fixture
+    // doesn't emit recordCost, so metrics.openwopCost will typically be
+    // absent — that's allowed. The assertion is forward-compat: when
+    // present, the structure MUST be the canonical one.
+    const create = await driver.post('/v1/runs', { workflowId: 'conformance-noop' });
+    expect(create.status).toBe(201);
+    const runId = (create.json as { runId: string }).runId;
+
+    const terminal = await pollUntilTerminal(runId);
+    const openwopCost = terminal.metrics?.openwopCost;
+
+    if (openwopCost === undefined) {
+      // Spec-allowed — the noop fixture has no cost emission. Assertion
+      // passes trivially; don't force a value on a workflow that produces
+      // no cost.
+      expect(openwopCost).toBeUndefined();
+      return;
+    }
+
+    // When present, validate the canonical shape per
+    // run-snapshot.schema.json §metrics.openwopCost.
+    if ('usd' in openwopCost) {
+      expect(typeof openwopCost.usd, 'metrics.openwopCost.usd MUST be a number').toBe('number');
+      expect(openwopCost.usd!, 'metrics.openwopCost.usd MUST be >= 0').toBeGreaterThanOrEqual(0);
+    }
+    if ('tokens' in openwopCost && openwopCost.tokens) {
+      if ('input' in openwopCost.tokens) {
+        expect(Number.isInteger(openwopCost.tokens.input)).toBe(true);
+        expect(openwopCost.tokens.input!).toBeGreaterThanOrEqual(0);
+      }
+      if ('output' in openwopCost.tokens) {
+        expect(Number.isInteger(openwopCost.tokens.output)).toBe(true);
+        expect(openwopCost.tokens.output!).toBeGreaterThanOrEqual(0);
+      }
+    }
+    if ('duration_ms' in openwopCost) {
+      expect(Number.isInteger(openwopCost.duration_ms)).toBe(true);
+      expect(openwopCost.duration_ms!).toBeGreaterThanOrEqual(0);
+    }
+    if ('model' in openwopCost) {
+      expect(typeof openwopCost.model, 'metrics.openwopCost.model MUST be a string').toBe('string');
+    }
+    if ('provider' in openwopCost) {
+      expect(typeof openwopCost.provider, 'metrics.openwopCost.provider MUST be a string').toBe('string');
+    }
+  });
+});
+
+// Reference hosts MAY expose the same fixture node id with different
+// canary numbers. These
+// scenarios assert shape conformance + non-negative-integer/number
+// constraints, not exact numeric equality, so any host-canary works.
+
+describe.skipIf(SKIP_NO_COST_EMIT)('cost-attribution: end-to-end roundtrip via conformance.cost.emit (G6 / O4)', () => {
+  it('metrics.openwopCost MUST carry the canary cost shape after the fixture node runs', async () => {
+    // Try to start the cost-emit fixture workflow. If the host doesn't
+    // advertise the fixture surface (production deployments don't), we
+    // get 404 / 422 back and skip the scenario.
+    const create = await driver.post('/v1/runs', {
+      workflowId: 'openwop-smoke-cost-emit',
+    });
+
+    // Fixture absent — host does not opt into OPENWOP_CONFORMANCE_FIXTURES.
+    // That's spec-allowed; the scenario passes trivially.
+    if (create.status === 404 || create.status === 422) {
+      return;
+    }
+
+    expect(create.status, driver.describe(
+      'rest-endpoints.md POST /v1/runs',
+      'starting openwop-smoke-cost-emit MUST succeed when OPENWOP_CONFORMANCE_FIXTURES=1 is advertised',
+    )).toBe(201);
+    const runId = (create.json as { runId: string }).runId;
+
+    const terminal = await pollUntilTerminal(runId);
+    expect(terminal.status, driver.describe(
+      'observability.md §AI cost',
+      'cost-emit fixture run MUST reach terminal completed',
+    )).toBe('completed');
+
+    const openwopCost = terminal.metrics?.openwopCost;
+    expect(openwopCost, driver.describe(
+      'run-snapshot.schema.json §metrics.openwopCost',
+      'metrics.openwopCost MUST be populated after a node calls ctx.recordCost()',
+    )).toBeDefined();
+
+    // Provider — the fixture canary is a stable string. Host-defined
+    // overrides are spec-allowed; we assert shape rather than exact match.
+    if ('provider' in openwopCost!) {
+      expect(typeof openwopCost!.provider).toBe('string');
+      expect((openwopCost!.provider as string).length).toBeGreaterThan(0);
+    }
+
+    // Model — same: shape, not exact.
+    if ('model' in openwopCost!) {
+      expect(typeof openwopCost!.model).toBe('string');
+    }
+
+    // Tokens — MUST be non-negative integers when present.
+    if ('tokens' in openwopCost! && openwopCost!.tokens) {
+      if ('input' in openwopCost!.tokens) {
+        expect(Number.isInteger(openwopCost!.tokens.input), driver.describe(
+          'observability.md §openwop.cost.tokens.input',
+          'tokens.input MUST be a non-negative integer',
+        )).toBe(true);
+        expect(openwopCost!.tokens.input!).toBeGreaterThanOrEqual(0);
+      }
+      if ('output' in openwopCost!.tokens) {
+        expect(Number.isInteger(openwopCost!.tokens.output), driver.describe(
+          'observability.md §openwop.cost.tokens.output',
+          'tokens.output MUST be a non-negative integer',
+        )).toBe(true);
+        expect(openwopCost!.tokens.output!).toBeGreaterThanOrEqual(0);
+      }
+    }
+
+    // USD — MUST be non-negative number (fractional allowed).
+    if ('usd' in openwopCost!) {
+      expect(typeof openwopCost!.usd, driver.describe(
+        'observability.md §openwop.cost.usd',
+        'usd MUST be a number',
+      )).toBe('number');
+      expect(openwopCost!.usd!, driver.describe(
+        'observability.md §openwop.cost.usd',
+        'usd MUST be >= 0',
+      )).toBeGreaterThanOrEqual(0);
+    }
+  });
+
+  it('cost-emit fixture run MUST emit a node.completed event for the cost-emitting node', async () => {
+    const create = await driver.post('/v1/runs', {
+      workflowId: 'openwop-smoke-cost-emit',
+    });
+    if (create.status === 404 || create.status === 422) {
+      return;
+    }
+    expect(create.status).toBe(201);
+    const runId = (create.json as { runId: string }).runId;
+
+    await pollUntilTerminal(runId);
+
+    const eventsResp = await driver.get(`/v1/runs/${runId}/events`);
+    expect(eventsResp.status).toBe(200);
+    const events = (eventsResp.json as { events: Array<{ type: string; nodeId?: string }> })
+      .events;
+
+    const completed = events.filter(
+      (e) => e.type === 'node.completed' && e.nodeId === 'emit-cost',
+    );
+    expect(completed.length, driver.describe(
+      'event-log.md §node.completed',
+      'cost-emit fixture node MUST emit exactly one node.completed event',
+    )).toBe(1);
+  });
+});
+
+describe('cost-attribution: G6 / O4 (still deferred — observable-span access required)', () => {
+  it.todo(
+    'the OTel span attribute set MUST NOT contain any key outside OPENWOP_COST_ATTRIBUTE_NAMES (redaction) — BLOCKED on observable-span access; runtime enforcement belongs in host-specific observability tests',
+  );
+
+  it.todo(
+    'credential-shaped fields in the upstream provider response MUST NOT appear in any OTel attribute or in metrics.openwopCost (regression test for G6 close-criteria allowlist enforcement) — BLOCKED on observable-span access; sanitizer-level redaction is unit-tested today',
+  );
+});