@openwop/openwop-conformance 1.21.0 → 1.24.0

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

@@ -0,0 +1,181 @@
+/**
+ * i18n-negotiation — `spec/v1/i18n.md` locale negotiation (capability-gated).
+ *
+ * Always-on (when a host is reachable): the `i18n` advertisement-shape
+ * probe — absent is conformant ("host serves a single locale always");
+ * when present, `supported` is a boolean, `defaultLocale` /
+ * `supportedLocales` are BCP 47 tags, and `supportedLocales` contains
+ * `defaultLocale` (i18n.md §"Capability advertisement").
+ *
+ * Behavioral legs are gated via `behaviorGate('openwop-i18n',
+ * i18n.supported === true)` — soft-skip by default, hard-fail under
+ * `OPENWOP_REQUIRE_BEHAVIOR=true` (root-first family read per RFC 0073):
+ *
+ *   1. An UNSUPPORTED `Accept-Language` MUST NOT fail the request — the
+ *      host falls back to its default locale (i18n.md §Accept-Language
+ *      "Host MUST NOT" + §Fallback rules).
+ *   2. A MALFORMED `Accept-Language` MUST NOT cause `400` (i18n.md
+ *      §Accept-Language Host-MUST rule 1).
+ *   3. `Content-Language`, when emitted, is a BCP 47 tag and never lies:
+ *      for the unsupported-tag request it reflects the host default
+ *      (i18n.md §Fallback rules 3–4 + §Conformance).
+ *   4. The machine-readable error `code` stays the canonical English /
+ *      lowercase / underscore token regardless of the negotiated
+ *      language (i18n.md §"`locale` field on `ErrorEnvelope.details`").
+ *
+ * The probes drive a protected route that produces a human-facing error
+ * envelope (`GET /v1/runs/{unknown-id}` → `404 not_found`) so both the
+ * negotiation tolerance AND the error-code stability are observable
+ * black-box without any fixture.
+ *
+ * @see spec/v1/i18n.md
+ * @see schemas/capabilities.schema.json §i18n
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { behaviorGate } from '../lib/behavior-gate.js';
+import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
+
+const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
+
+/** BCP 47 well-formedness as pinned by capabilities.schema.json §i18n. */
+const BCP47 = /^[a-zA-Z]{2,3}(-[a-zA-Z0-9]{2,8}){0,3}$/;
+
+interface I18nCap {
+  readonly supported?: unknown;
+  readonly defaultLocale?: unknown;
+  readonly supportedLocales?: unknown;
+}
+
+/** A protected route that yields a canonical error envelope. */
+const PROBE_PATH = '/v1/runs/openwop-conformance-i18n-no-such-run';
+
+/** Pick a syntactically valid tag the host does NOT list as supported. */
+function pickUnsupportedTag(supportedLocales: readonly string[]): string {
+  const candidates = ['tlh', 'mi-NZ', 'eu-ES', 'kl-GL'];
+  return candidates.find((c) => !supportedLocales.includes(c)) ?? 'tlh';
+}
+
+function errCode(json: unknown): string | undefined {
+  const e = (json as { error?: unknown } | undefined)?.error;
+  return typeof e === 'string' ? e : undefined;
+}
+
+describe.skipIf(HTTP_SKIP)('i18n-negotiation: advertisement shape (i18n.md §Capability advertisement)', () => {
+  it('the i18n block is either absent or well-formed', async () => {
+    const cap = await readCapabilityFamily<I18nCap>('i18n');
+    if (cap === undefined) return; // absent ⇒ single-locale host — conformant
+
+    expect(
+      typeof cap.supported,
+      driver.describe('capabilities.schema.json §i18n', 'i18n.supported MUST be a boolean when the block is present'),
+    ).toBe('boolean');
+
+    if (cap.defaultLocale !== undefined) {
+      expect(
+        typeof cap.defaultLocale === 'string' && BCP47.test(cap.defaultLocale),
+        driver.describe('i18n.md §Capability advertisement', `i18n.defaultLocale MUST be a BCP 47 tag (got ${String(cap.defaultLocale)})`),
+      ).toBe(true);
+    }
+
+    if (cap.supportedLocales !== undefined) {
+      expect(
+        Array.isArray(cap.supportedLocales),
+        driver.describe('i18n.md §Capability advertisement', 'i18n.supportedLocales MUST be an array when present'),
+      ).toBe(true);
+      const locales = (cap.supportedLocales as unknown[]) ?? [];
+      for (const tag of locales) {
+        expect(
+          typeof tag === 'string' && BCP47.test(tag),
+          driver.describe('i18n.md §Capability advertisement', `every supportedLocales entry MUST be a BCP 47 tag (got ${String(tag)})`),
+        ).toBe(true);
+      }
+      if (typeof cap.defaultLocale === 'string') {
+        expect(
+          locales,
+          driver.describe('i18n.md §Capability advertisement', 'supportedLocales MUST contain defaultLocale'),
+        ).toContain(cap.defaultLocale);
+      }
+    }
+  });
+});
+
+describe.skipIf(HTTP_SKIP)('i18n-negotiation: behavioral (i18n.md §Accept-Language + §Fallback rules)', () => {
+  it('an unsupported Accept-Language falls back (never 400) and Content-Language reflects the default', async () => {
+    const cap = await readCapabilityFamily<I18nCap>('i18n');
+    if (!behaviorGate('openwop-i18n', cap?.supported === true)) return;
+
+    const supported = Array.isArray(cap?.supportedLocales)
+      ? (cap.supportedLocales as unknown[]).filter((t): t is string => typeof t === 'string')
+      : [];
+    const defaultLocale = typeof cap?.defaultLocale === 'string' ? cap.defaultLocale : 'en';
+
+    const res = await driver.get(PROBE_PATH, {
+      headers: { 'Accept-Language': pickUnsupportedTag(supported) },
+    });
+    expect(
+      res.status,
+      driver.describe(
+        'i18n.md §Accept-Language ("Host MUST NOT") + §Fallback rules',
+        'an unsupported Accept-Language MUST NOT fail the request — the route still answers 404 not_found, not 400/406',
+      ),
+    ).toBe(404);
+
+    const contentLanguage = res.headers.get('content-language');
+    if (contentLanguage !== null) {
+      expect(
+        BCP47.test(contentLanguage),
+        driver.describe('i18n.md §Accept-Language rule 4', `Content-Language MUST be a BCP 47 tag (got ${contentLanguage})`),
+      ).toBe(true);
+      const primary = (tag: string): string => (tag.split('-')[0] ?? tag).toLowerCase();
+      expect(
+        primary(contentLanguage),
+        driver.describe(
+          'i18n.md §Fallback rules 3–4 + §Conformance',
+          'for an unsupported Accept-Language, Content-Language MUST reflect the host default locale (never lie)',
+        ),
+      ).toBe(primary(defaultLocale));
+    }
+  });
+
+  it('a malformed Accept-Language MUST NOT cause 400', async () => {
+    const cap = await readCapabilityFamily<I18nCap>('i18n');
+    if (!behaviorGate('openwop-i18n', cap?.supported === true)) return;
+
+    const res = await driver.get(PROBE_PATH, {
+      headers: { 'Accept-Language': ';;;not===a,,language q=;' },
+    });
+    expect(
+      res.status,
+      driver.describe(
+        'i18n.md §Accept-Language Host-MUST rule 1',
+        'a malformed Accept-Language MUST NOT cause 400 — the host parses best-effort and proceeds (404 not_found here)',
+      ),
+    ).toBe(404);
+  });
+
+  it('the error `code` stays the canonical English token under a negotiated locale', async () => {
+    const cap = await readCapabilityFamily<I18nCap>('i18n');
+    if (!behaviorGate('openwop-i18n', cap?.supported === true)) return;
+
+    const supported = Array.isArray(cap?.supportedLocales)
+      ? (cap.supportedLocales as unknown[]).filter((t): t is string => typeof t === 'string')
+      : [];
+    const defaultLocale = typeof cap?.defaultLocale === 'string' ? cap.defaultLocale : 'en';
+    // Prefer a non-default supported locale so localization actually engages.
+    const negotiated = supported.find((t) => t !== defaultLocale) ?? defaultLocale;
+
+    const res = await driver.get(PROBE_PATH, {
+      headers: { 'Accept-Language': negotiated },
+    });
+    expect(res.status).toBe(404);
+    expect(
+      errCode(res.json),
+      driver.describe(
+        'i18n.md §"`locale` field on `ErrorEnvelope.details`"',
+        `the machine-readable error code MUST remain the canonical English token regardless of the negotiated locale (${negotiated})`,
+      ),
+    ).toBe('not_found');
+  });
+});

package/src/scenarios/interrupt-token-matrix.test.ts

@@ -20,7 +20,7 @@
  *      (NEVER 200 from a different run's scope).
  *
  * Gating identical to interrupt-external-event-correlation: skips when
- * the `conformance-external-event` fixture isn't advertised.
+ * the `conformance-interrupt-external-event` fixture isn't advertised.
  *
  * @see spec/v1/interrupt.md §"Signed-token callback"
  * @see spec/v1/rest-endpoints.md §"GET /v1/interrupts/{token}" + §"POST /v1/interrupts/{token}"
@@ -31,7 +31,7 @@ import { driver } from '../lib/driver.js';
 import { pollUntilStatus } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 
-const FIXTURE = 'conformance-external-event';
+const FIXTURE = 'conformance-interrupt-external-event';
 const SKIP = !isFixtureAdvertised(FIXTURE);
 
 function randomBytesB64(length: number): string {

package/src/scenarios/media-url-inline-cap.test.ts

@@ -14,9 +14,11 @@
  *   4. When a host advertises `aiProviders.maxInlineMediaBytes`, it MUST be a
  *      non-negative integer.
  *
- * Behavioral (cross-tenant scoping + cap enforcement) is staged via `it.todo`
- * until a reference host wires tenant-scoped asset serving (greenfield;
- * RFC 0027 §G precedent — advertisement + schema land first).
+ * Behavioral (cross-tenant scoping + cap enforcement) runs as real `it()`
+ * bodies against the reference host's media-asset seam
+ * (`POST /v1/host/sample/media/put` store + `GET /v1/host/sample/assets/{token}`
+ * serve) and soft-skips (early `return`) on hosts that don't expose the
+ * store seam — no `it.todo` staging remains in this file.
  *
  * @see RFCS/0055-multimodal-envelope-variants-and-rendering-hints.md §C
  * @see spec/v1/ai-envelope.md §"Media reference payloads"

package/src/scenarios/proposal-reviewable-learning.test.ts

@@ -0,0 +1,129 @@
+/**
+ * Reviewable learning — the proposal lifecycle (RFC 0096; `agent-memory.md`
+ * §"Reviewable learning"). Public tests for the protocol-tier SECURITY
+ * invariants `proposal-inert-until-applied` and `proposal-no-resynthesis`.
+ *
+ * Two layers:
+ *
+ *   A. Always-on, server-free schema legs — the capability block, the
+ *      `proposal.schema.json` shape (incl. the dropped `rule` kind), and the
+ *      content-free `proposal.created` / `proposal.activated` event payloads.
+ *
+ *   B. Capability-gated behavioral legs — on a host advertising
+ *      `capabilities.agents.proposals` that exposes the
+ *      `/v1/host/sample/proposals` seam: inertness (a draft proposal does not
+ *      influence a run), gated activation (`apply` without scope → 403), and
+ *      no-re-synthesis (installed artifact byte-matches the last-persisted
+ *      `artifact`). Hosts without the seam soft-skip (404); unadvertised
+ *      hosts skip via the behavior gate.
+ *
+ * @see spec/v1/agent-memory.md §"Reviewable learning"
+ * @see SECURITY/invariants.yaml id: proposal-inert-until-applied, proposal-no-resynthesis
+ * @see RFCS/0096-reviewable-learning-skill-proposal-lifecycle.md
+ */
+
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import Ajv2020 from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+import { SCHEMAS_DIR } from '../lib/paths.js';
+import { driver } from '../lib/driver.js';
+import { behaviorGate } from '../lib/behavior-gate.js';
+import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
+
+const why = (specRef: string, requirement: string): string => `${specRef} — ${requirement}`;
+function loadSchema(name: string): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(SCHEMAS_DIR, name), 'utf8')) as Record<string, unknown>;
+}
+
+describe('proposal-reviewable-learning: capability advertisement (RFC 0096 §A, server-free)', () => {
+  const caps = loadSchema('capabilities.schema.json');
+  const agents = (caps.properties as Record<string, { properties?: Record<string, { properties?: Record<string, unknown>; required?: string[] }> }>).agents;
+
+  it('capabilities schema declares agents.proposals with its required sub-flags', () => {
+    const proposals = agents?.properties?.proposals;
+    expect(proposals, why('capabilities.md §agents', 'agents.proposals MUST be declared')).toBeDefined();
+    for (const flag of ['artifactKinds', 'duplicationDetection', 'activation']) {
+      expect(proposals?.properties?.[flag], why('RFC 0096 §A', `agents.proposals.${flag} MUST be declared`)).toBeDefined();
+    }
+    expect(proposals?.required, why('RFC 0096 §A', 'artifactKinds + activation MUST be required')).toEqual(
+      expect.arrayContaining(['artifactKinds', 'activation']),
+    );
+  });
+
+  it('the `rule` artifact kind is NOT in the enum (dropped — no defining RFC)', () => {
+    const kinds = (agents?.properties?.proposals as { properties?: Record<string, { items?: { enum?: string[] } }> })?.properties?.artifactKinds?.items?.enum ?? [];
+    expect(kinds, why('RFC 0096 §A', 'artifactKinds enumerates the four kinds with a defining RFC')).toEqual(
+      expect.arrayContaining(['agent-pack', 'workflow-chain-pack', 'prompt-template', 'automation']),
+    );
+    expect(kinds, why('RFC 0096 §A', '`rule` MUST NOT appear — it has no defining RFC, so its artifact is unvalidatable')).not.toContain('rule');
+  });
+});
+
+describe('proposal-reviewable-learning: Proposal shape (RFC 0096 §B, server-free)', () => {
+  const ajv = new Ajv2020({ strict: false, allErrors: true });
+  addFormats(ajv);
+  const validate = ajv.compile(loadSchema('proposal.schema.json'));
+
+  const good = {
+    id: 'prop-1',
+    kind: 'workflow-chain-pack',
+    state: 'draft',
+    artifact: { name: 'weekly-digest', version: '1.0.0' },
+    provenance: { sourceRunIds: ['run-a', 'run-b'] },
+    owner: { tenant: 'acme' },
+    createdAt: '2026-06-13T00:00:00Z',
+  };
+
+  it('validates a conforming draft proposal', () => {
+    expect(validate(good), why('RFC 0096 §B', `a conforming proposal MUST validate. Errors: ${JSON.stringify(validate.errors)}`)).toBe(true);
+  });
+
+  it('rejects an unknown state and the dropped `rule` kind', () => {
+    expect(validate({ ...good, state: 'live' }), why('RFC 0096 §B', 'a state outside the lifecycle enum MUST be rejected')).toBe(false);
+    expect(validate({ ...good, kind: 'rule' }), why('RFC 0096 §B', '`kind: "rule"` MUST be rejected (dropped from the enum)')).toBe(false);
+    expect(validate({ ...good, owner: { workspace: 'x' } }), why('RFC 0048', 'owner without tenant MUST be rejected')).toBe(false);
+  });
+});
+
+describe('proposal-reviewable-learning: content-free events (RFC 0096 §D, server-free)', () => {
+  const runEvent = loadSchema('run-event.schema.json');
+  const payloads = loadSchema('run-event-payloads.schema.json');
+  const ajv = new Ajv2020({ strict: false, allErrors: true });
+  addFormats(ajv);
+  ajv.addSchema(payloads, 'payloads');
+
+  it('proposal.created and proposal.activated are in the RunEventType enum', () => {
+    const en = (runEvent.$defs as Record<string, { enum?: string[] }>).RunEventType?.enum ?? [];
+    expect(en).toContain('proposal.created');
+    expect(en).toContain('proposal.activated');
+  });
+
+  it('proposal.created is content-free — an artifact body and rationale text are rejected', () => {
+    const created = ajv.getSchema('payloads#/$defs/proposalCreated')!;
+    expect(created({ proposalId: 'p1', kind: 'agent-pack', sourceRunIds: ['r1'], duplicateOf: null }), why('RFC 0096 §D', 'a content-free proposal.created MUST validate')).toBe(true);
+    expect(created({ proposalId: 'p1', kind: 'agent-pack', artifact: { x: 1 } }), why('SECURITY invariant proposal-inert-until-applied', 'proposal.created MUST NOT carry the artifact body')).toBe(false);
+    expect(created({ proposalId: 'p1', kind: 'agent-pack', rationale: 'because…' }), why('RFC 0096 §D', 'proposal.created MUST NOT carry rationale text')).toBe(false);
+  });
+});
+
+describe('proposal-reviewable-learning: behavioral (RFC 0096 §E, capability-gated)', () => {
+  it('apply without the activation scope is denied (403) and installs nothing', async () => {
+    const agents = await readCapabilityFamily<{ proposals?: { activation?: string } }>('agents');
+    if (!behaviorGate('agents.proposals', agents?.proposals !== undefined)) return;
+
+    const list = await driver.get('/v1/host/sample/proposals?state=draft');
+    if (list.status === 404 || list.status === 403) return; // seam unwired — soft-skip
+    const proposals = (list.json as { proposals?: Array<{ id: string }> })?.proposals ?? [];
+    if (proposals.length === 0) return; // nothing to act on — soft-skip
+
+    // Apply with no auth/scope — MUST be refused.
+    const res = await driver.post(`/v1/host/sample/proposals/${proposals[0]!.id}/apply`, {});
+    if (res.status === 404) return;
+    expect(
+      res.status,
+      driver.describe('agent-memory.md §"Reviewable learning" clause 2', 'apply without the activation scope MUST be denied (403)'),
+    ).toBe(403);
+  });
+});

package/src/scenarios/spec-corpus-validity.test.ts

@@ -1552,3 +1552,110 @@ describe.skipIf(RFC0089_BUNDLE_PATH === null || !existsSync(RFC0089_BUNDLE_PATH)
     expect(bundle.discovery.sha256).toBe(recomputed);
   });
 });
+
+describe('spec-corpus: createRun composed request schema is satisfiable (RFC 0094 §A)', () => {
+  // The 2026-06-11 corpus review found the published createRun requestBody
+  // unsatisfiable: BOTH allOf branches (the inline request object and
+  // run-options.schema.json) carried `additionalProperties: false`, so every
+  // documented body failed one branch or the other. RFC 0094 §A moves the
+  // closure to the composition site (`unevaluatedProperties: false`, JSON
+  // Schema 2020-12) and opens both branches. These probes pin the repaired
+  // contract so the defect class cannot silently return:
+  //   1. (structural) the YAML composition closes at the composed level,
+  //      never at a branch;
+  //   2. (semantic, ajv-2020) the canonical documented bodies PASS the
+  //      composition of the on-disk run-options.schema.json with the inline
+  //      branch's declared properties, while an undeclared property FAILS.
+  const openapiPath = join(API_DIR, 'openapi.yaml');
+
+  function extractCreateRunRequestBlock(raw: string): string {
+    const opStart = raw.indexOf('operationId: createRun');
+    expect(opStart, 'OpenAPI MUST declare operationId createRun').toBeGreaterThanOrEqual(0);
+    const bodyStart = raw.indexOf('requestBody:', opStart);
+    const responsesStart = raw.indexOf('\n      responses:', bodyStart);
+    expect(bodyStart, 'createRun MUST declare a requestBody').toBeGreaterThan(opStart);
+    expect(responsesStart, 'createRun requestBody MUST precede its responses').toBeGreaterThan(bodyStart);
+    return raw.slice(bodyStart, responsesStart);
+  }
+
+  /** Property names declared on the inline (non-$ref) allOf branch of the
+   *  createRun requestBody — the 20-space-indented keys, minus JSON Schema
+   *  keywords that can appear at the same indent inside if/then/else. */
+  function extractInlineBranchPropertyNames(block: string): string[] {
+    const keywords = new Set([
+      'type', 'properties', 'required', 'description', 'enum', 'format',
+      'items', 'minLength', 'if', 'then', 'else', 'allOf', 'additionalProperties',
+      'unevaluatedProperties',
+    ]);
+    const names: string[] = [];
+    const re = /^ {20}([A-Za-z][A-Za-z0-9]*):/gm;
+    let m: RegExpExecArray | null;
+    while ((m = re.exec(block)) !== null) {
+      const name = m[1];
+      if (name && !keywords.has(name) && !names.includes(name)) names.push(name);
+    }
+    return names;
+  }
+
+  it('the requestBody closes at the composition (unevaluatedProperties), not inside a branch', () => {
+    const { raw } = readYamlHeader(openapiPath);
+    const block = extractCreateRunRequestBlock(raw);
+
+    expect(
+      block,
+      'RFC 0094 §A: the composed createRun request schema MUST be closed with `unevaluatedProperties: false`',
+    ).toContain('unevaluatedProperties: false');
+    expect(
+      block,
+      'RFC 0094 §A: no allOf branch of the createRun requestBody may carry `additionalProperties: false` ' +
+        '(a closed branch inside an allOf re-creates the unsatisfiable composition)',
+    ).not.toContain('additionalProperties: false');
+  });
+
+  it('canonical createRun bodies PASS the composed schema; an undeclared property FAILS', () => {
+    const { raw } = readYamlHeader(openapiPath);
+    const inlineProps = extractInlineBranchPropertyNames(extractCreateRunRequestBlock(raw));
+    expect(inlineProps, 'the inline branch MUST declare workflowId').toContain('workflowId');
+
+    // Compose exactly what RFC 0094 §A specifies: the inline branch's
+    // declared properties + the REAL on-disk run-options.schema.json
+    // (embedded with its $id so its internal #/$defs refs keep resolving),
+    // closed at the composition with unevaluatedProperties.
+    const runOptionsSchema = readJson(join(SCHEMAS_DIR, 'run-options.schema.json')) as Record<string, unknown>;
+    delete runOptionsSchema['$schema']; // embedded subschema; the parent declares the dialect
+    const composed = {
+      $schema: 'https://json-schema.org/draft/2020-12/schema',
+      type: 'object',
+      allOf: [
+        {
+          type: 'object',
+          properties: Object.fromEntries(inlineProps.map((p) => [p, true])),
+        },
+        runOptionsSchema,
+      ],
+      unevaluatedProperties: false,
+    };
+
+    const ajv = new Ajv2020({ allErrors: true, strict: false });
+    addFormats(ajv);
+    const validate = ajv.compile(composed);
+
+    const canonicalBodies: Array<Record<string, unknown>> = [
+      { workflowId: 'wf-1' },
+      { workflowId: 'wf-1', configurable: {} },
+      { workflowId: 'wf-1', inputs: {}, configurable: {}, tags: ['conformance'], metadata: {} },
+    ];
+    for (const body of canonicalBodies) {
+      expect(
+        validate(body),
+        `RFC 0094 §A: documented body ${JSON.stringify(body)} MUST satisfy the composed createRun ` +
+          `request schema; ajv said: ${JSON.stringify(validate.errors)}`,
+      ).toBe(true);
+    }
+
+    expect(
+      validate({ workflowId: 'wf-1', definitelyNotASpecField: true }),
+      'RFC 0094 §A: an undeclared property MUST still fail at the composed level (unevaluatedProperties: false)',
+    ).toBe(false);
+  });
+});

package/src/scenarios/stream-text-fixture.test.ts

@@ -0,0 +1,212 @@
+/**
+ * stream-text-fixture — `stream-modes.md` §`messages` end-to-end through the
+ * deterministic `stream-text` mock provider. Consumer of the
+ * `conformance-stream-text` fixture (closes catalog gap F1 — the fixture
+ * previously had no consuming scenario; see `fixtures.md`).
+ *
+ * Gating: `describe.skipIf` on the advertised `conformance-stream-text`
+ * fixture id (RFC 0003). Inside the test, a host that advertises the
+ * fixture but not the `stream-text` mock provider
+ * (`Capabilities.testing.mockProviders`) soft-skips with a warning —
+ * fixtures.md lets hosts mark this fixture optional until the
+ * mock-provider extension lands. `403 mock_provider_forbidden` (a
+ * production-scoped key) also soft-skips honestly.
+ *
+ * What's asserted per the fixture driver (`fixtures.md` §`conformance-stream-text`):
+ *   1. `?streamMode=messages` delivers the mocked tokens
+ *      `["Hello", " ", "world", "!"]` as `ai.message.chunk` events in
+ *      token order (the documented fold behavior).
+ *   2. The final chunk carries `isLast: true`,
+ *      `meta.finishReason === "stop"`, and
+ *      `meta.usage.completionTokens === 4` — the `{nodeId, runId, chunk,
+ *      isLast}` minimum compliant payload per stream-modes.md §messages
+ *      (single-sourced by RFC 0094 §D).
+ *   3. The SSE stream is server-closed on terminal (not timed out).
+ *   4. The run reaches terminal `completed`.
+ *   5. Negative: an unknown `mockProvider.id` is rejected with
+ *      `400 unsupported_mock_provider`.
+ *
+ * @see spec/v1/stream-modes.md §`messages`
+ * @see conformance/fixtures.md §`conformance-stream-text`
+ * @see RFCS/0094-wire-shape-reconciliation.md §D
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { subscribe } from '../lib/sse.js';
+import { pollUntilTerminal } from '../lib/polling.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { capabilityFamily } from '../lib/discovery-capabilities.js';
+
+const FIXTURE_ID = 'conformance-stream-text';
+const SKIP_NO_FIXTURE = !isFixtureAdvertised(FIXTURE_ID);
+
+const MOCK_TOKENS = ['Hello', ' ', 'world', '!'];
+
+interface ChunkPayload {
+  readonly nodeId?: unknown;
+  readonly runId?: unknown;
+  readonly chunk?: unknown;
+  readonly isLast?: unknown;
+  readonly meta?: {
+    readonly finishReason?: unknown;
+    readonly usage?: { readonly completionTokens?: unknown };
+  };
+}
+
+function errCode(json: unknown): string | undefined {
+  const e = (json as { error?: unknown } | undefined)?.error;
+  return typeof e === 'string' ? e : undefined;
+}
+
+async function createMockRun(mockProviderId: string): Promise<OpenWOPResponse> {
+  return driver.post('/v1/runs', {
+    workflowId: FIXTURE_ID,
+    configurable: {
+      mockProvider: {
+        id: mockProviderId,
+        config: {
+          tokens: MOCK_TOKENS,
+          delayMsPerToken: 10,
+          finishReason: 'stop',
+          usage: { promptTokens: 5, completionTokens: 4, totalTokens: 9 },
+        },
+      },
+    },
+  });
+}
+
+/** True when the host advertises the v1-mandatory `stream-text` mock
+ *  provider in `Capabilities.testing.mockProviders`. */
+async function isStreamTextMockAdvertised(): Promise<boolean> {
+  const res = await driver.get('/.well-known/openwop');
+  if (res.status !== 200) return false;
+  const testing = capabilityFamily<{ mockProviders?: unknown }>(res.json, 'testing');
+  return Array.isArray(testing?.mockProviders) && testing.mockProviders.includes('stream-text');
+}
+
+describe.skipIf(SKIP_NO_FIXTURE)('stream-text-fixture: messages-mode fold through the stream-text mock (F1)', () => {
+  it('delivers the mocked tokens in order, terminates with isLast + meta, and server-closes', async () => {
+    if (!(await isStreamTextMockAdvertised())) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        '[stream-text-fixture] host does not advertise the stream-text mock provider ' +
+          '(Capabilities.testing.mockProviders); skipping',
+      );
+      return;
+    }
+
+    const create = await createMockRun('stream-text');
+    if (create.status === 403 && errCode(create.json) === 'mock_provider_forbidden') {
+      // eslint-disable-next-line no-console
+      console.warn('[stream-text-fixture] API key is production-scoped (403 mock_provider_forbidden); skipping');
+      return;
+    }
+    expect(
+      create.status,
+      driver.describe(
+        'fixtures.md §conformance-stream-text',
+        'a test key MUST be able to start the fixture with configurable.mockProvider',
+      ),
+    ).toBe(201);
+    const runId = (create.json as { runId: string }).runId;
+
+    const result = await subscribe(
+      `/v1/runs/${encodeURIComponent(runId)}/events?streamMode=messages`,
+      { timeoutMs: 15_000 },
+    );
+
+    // 3) server-closed, not timeout.
+    expect(
+      result.closedBy,
+      driver.describe('stream-modes.md §messages', 'server MUST close the messages stream on terminal run status'),
+    ).toBe('server');
+
+    // Collect ai.message.chunk payloads. Per stream-modes.md the SSE event
+    // type IS ai.message.chunk; tolerate hosts that wrap the payload under
+    // a `payload` envelope (the RunEventDoc shape).
+    const chunks: ChunkPayload[] = [];
+    for (const e of result.events) {
+      if (e.event !== 'ai.message.chunk') continue;
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(e.data);
+      } catch {
+        continue;
+      }
+      const direct = parsed as ChunkPayload & { payload?: ChunkPayload };
+      chunks.push(typeof direct.chunk === 'string' ? direct : (direct.payload ?? direct));
+    }
+
+    expect(
+      chunks.length,
+      driver.describe(
+        'stream-modes.md §messages',
+        'messages mode MUST emit ai.message.chunk SSE events for the streaming AI node',
+      ),
+    ).toBe(MOCK_TOKENS.length);
+
+    // 1) Token order matches the mock config exactly.
+    expect(
+      chunks.map((c) => c.chunk),
+      driver.describe(
+        'fixtures.md §conformance-stream-text',
+        'chunk arrival order MUST match the mock token order',
+      ),
+    ).toEqual(MOCK_TOKENS);
+
+    // 2) Final-chunk contract: isLast + Tier 1 meta.
+    const last = chunks[chunks.length - 1]!;
+    expect(
+      last.isLast,
+      driver.describe(
+        'stream-modes.md §messages + RFC 0094 §D',
+        'the final ai.message.chunk MUST carry isLast: true',
+      ),
+    ).toBe(true);
+    expect(
+      last.meta?.finishReason,
+      driver.describe('stream-modes.md §messages (Tier 1)', 'final chunk meta.finishReason MUST be "stop"'),
+    ).toBe('stop');
+    expect(
+      last.meta?.usage?.completionTokens,
+      driver.describe('stream-modes.md §messages (Tier 1)', 'final chunk meta.usage.completionTokens MUST echo the mock usage'),
+    ).toBe(4);
+
+    // Minimum compliant payload fields are present on every chunk.
+    for (const c of chunks) {
+      expect(typeof c.nodeId, driver.describe('run-event-payloads.schema.json §outputChunk', 'nodeId MUST be a string')).toBe('string');
+      expect(typeof c.runId, driver.describe('run-event-payloads.schema.json §outputChunk', 'runId MUST be a string')).toBe('string');
+      expect(typeof c.isLast, driver.describe('run-event-payloads.schema.json §outputChunk', 'isLast MUST be a boolean')).toBe('boolean');
+    }
+
+    // 4) Terminal completed.
+    const terminal = await pollUntilTerminal(runId);
+    expect(
+      terminal.status,
+      driver.describe('fixtures.md §conformance-stream-text', 'the fixture run MUST reach terminal completed'),
+    ).toBe('completed');
+  });
+
+  it('an unknown mockProvider.id is rejected with 400 unsupported_mock_provider', async () => {
+    if (!(await isStreamTextMockAdvertised())) {
+      // eslint-disable-next-line no-console
+      console.warn('[stream-text-fixture] stream-text mock not advertised; skipping negative leg');
+      return;
+    }
+    const create = await createMockRun('does-not-exist');
+    if (create.status === 403 && errCode(create.json) === 'mock_provider_forbidden') {
+      // eslint-disable-next-line no-console
+      console.warn('[stream-text-fixture] API key is production-scoped; skipping negative leg');
+      return;
+    }
+    expect(
+      create.status,
+      driver.describe('fixtures.md §conformance-stream-text', 'an unknown mockProvider.id MUST be rejected with 400'),
+    ).toBe(400);
+    expect(
+      errCode(create.json),
+      driver.describe('fixtures.md §conformance-stream-text', 'the refusal MUST carry the canonical unsupported_mock_provider code'),
+    ).toBe('unsupported_mock_provider');
+  });
+});