@openwop/openwop-conformance 2.45.13 → 2.45.15

package/src/scenarios/v2-localized-content-delivery.test.ts

@@ -0,0 +1,136 @@
+/**
+ * v2 — localized content (`spec/v2/core/i18n.md` §Localized content;
+ * `schemas/v2/localized-content-*.schema.json`; RFCs 0103, 0206). The v1 twin
+ * is `localized-content-delivery`.
+ *
+ * Two layers:
+ *
+ *   A. Server-free — the v2 `content` capability record (no `supported` seat;
+ *      presence is the claim), the four v2 content schemas, and the section
+ *      merge every host MUST resolve identically (exact tag → `ll-Ssss` script
+ *      family → language → `data`, shallow overlay), against the suite's one
+ *      reference copy in `lib/localized-content.ts`.
+ *
+ *   B. Live — the advertised `content` record is coherent with the advertised
+ *      `i18n` record (`lib/localized-content-witness.ts`, a pure judge proven in
+ *      `localized-content-witness.test.ts`). Gated by the presence of the v2
+ *      `content` record: absent ⇒ `inapplicable`.
+ *
+ * Not ported here: the `/content/*` delivery legs (published-only, tenant
+ * isolation, no enumeration); v1 never drove them either.
+ *
+ * @see spec/v2/core/i18n.md §Localized content
+ * @see SECURITY/invariants.yaml id: content-published-cache-no-draft, content-response-tenant-scoped
+ */
+
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { SCHEMAS_DIR } from '../lib/paths.js';
+import { familyAdvertised, v2Discovery, v2RefValidator, v2Validator } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { majorProfile } from '../lib/major-profile.js';
+import { resolveSection, type Section } from '../lib/localized-content.js';
+import { coherenceLeg } from '../lib/localized-content-witness.js';
+
+const PROFILE = majorProfile(2);
+const DOC = 'spec/v2/core/i18n.md §Localized content';
+const ID_RECORD = 'openwop.requirement.content.capability-record-shape';
+const ID_SECTION = 'openwop.requirement.content.section-schema';
+const ID_PAGE = 'openwop.requirement.content.page-schema';
+const ID_SETTINGS = 'openwop.requirement.content.language-settings-schema';
+const ID_RESPONSE = 'openwop.requirement.content.page-response-schema';
+const ID_MERGE = 'openwop.requirement.content.section-merge';
+const ID_COHERENT = 'openwop.requirement.content.advertisement-coherent';
+const HTTP_SKIP = !process.env['OPENWOP_BASE_URL'];
+
+const caps = JSON.parse(readFileSync(join(SCHEMAS_DIR, 'v2', 'capabilities.schema.json'), 'utf8')) as { properties: Record<string, { required?: string[]; properties?: Record<string, unknown> }> };
+const section = v2Validator('localized-content-section');
+const page = v2Validator('localized-content-page');
+const settings = v2Validator('localized-content-language-settings');
+const response = v2Validator('localized-content-page-response');
+const contentRecord = v2RefValidator('capabilities.schema.json#/properties/content');
+
+const goodSection = {
+  sectionId: 'hero', sectionType: 'hero', data: { heading: 'Welcome', cta: 'Get started' },
+  localizations: { es: { heading: 'Bienvenido', cta: 'Empezar' }, 'pt-BR': { heading: 'Bem-vindo' } },
+  status: 'published', enabled: true, order: 0,
+};
+
+describe('v2 localized content: the capability record (server-free)', () => {
+  it('the v2 content record requires baseLocale and supportedLocales and has no supported seat', () => {
+    const content = caps.properties['content'];
+    expect(content?.required, req(ID_RECORD, 'schemas/v2/capabilities.schema.json §content', 'content MUST require baseLocale and supportedLocales')).toEqual(expect.arrayContaining(['baseLocale', 'supportedLocales']));
+    expect(content?.properties?.['supported'], req(ID_RECORD, 'spec/v2/core/capabilities.md (presence is the claim)', 'the v2 content record MUST NOT declare a supported seat')).toBeUndefined();
+    const base = { status: 'experimental', since: '2.0', until: '2.9', witness: 'witnessable-gated' };
+    expect(contentRecord({ ...base, baseLocale: 'en', supportedLocales: ['es'] }).ok, req(ID_RECORD, 'schemas/v2/capabilities.schema.json §content', 'a conforming content record MUST validate')).toBe(true);
+    expect(contentRecord({ ...base, supported: true, baseLocale: 'en', supportedLocales: ['es'] }).ok, req(ID_RECORD, 'schemas/v2/capabilities.schema.json §content', 'a content record carrying supported MUST be rejected (closed record)')).toBe(false);
+  });
+});
+
+describe('v2 localized content: schema shapes (server-free)', () => {
+  it('a conforming section validates; a non-canonical or underscore locale key, a missing status, or an unknown status is rejected', () => {
+    expect(section(goodSection).ok, req(ID_SECTION, DOC, `a conforming section MUST validate: ${section(goodSection).errors}`)).toBe(true);
+    for (const key of ['zh-Hans', 'zh-Hant-TW', 'es-419', 'fil']) {
+      expect(section({ ...goodSection, localizations: { [key]: { heading: 'x' } } }).ok, req(ID_SECTION, 'RFC 0206 §A.1', `${key} MUST validate as a localizations key`)).toBe(true);
+    }
+    for (const key of ['EN', 'en_US', 'en-us', 'zh-hans', 'de-CH-1996']) {
+      expect(section({ ...goodSection, localizations: { [key]: { heading: 'x' } } }).ok, req(ID_SECTION, 'RFC 0206 §A.1', `${key} MUST be rejected as a localizations key`)).toBe(false);
+    }
+    const { status: _omit, ...noStatus } = goodSection;
+    expect(section(noStatus).ok, req(ID_SECTION, DOC, 'status is REQUIRED')).toBe(false);
+    expect(section({ ...goodSection, status: 'archived' }).ok, req(ID_SECTION, DOC, 'status MUST be draft or published')).toBe(false);
+    expect(section({ ...goodSection, extra: true }).ok, req(ID_SECTION, DOC, 'a section is a closed record')).toBe(false);
+  });
+
+  it('a conforming page validates and a bad slug is rejected', () => {
+    const good = { pageId: 'home', slug: 'home', name: 'Home', status: 'published', sectionOrder: ['hero'] };
+    expect(page(good).ok, req(ID_PAGE, DOC, `a conforming page MUST validate: ${page(good).errors}`)).toBe(true);
+    expect(page({ ...good, slug: 'Home Page' }).ok, req(ID_PAGE, DOC, 'slug MUST match ^[a-z][a-z0-9-]*$')).toBe(false);
+  });
+
+  it('a conforming language-settings document validates', () => {
+    const good = { baseLocale: 'en', supportedLocales: ['es', 'pt-BR', 'fr'], autoTranslateOnPublish: false };
+    expect(settings(good).ok, req(ID_SETTINGS, DOC, `settings MUST validate: ${settings(good).errors}`)).toBe(true);
+    expect(settings({ ...good, baseLocale: 'en_US' }).ok, req(ID_SETTINGS, DOC, 'baseLocale MUST be a canonical BCP 47 key')).toBe(false);
+  });
+
+  it('a conforming page response validates', () => {
+    const good = {
+      version: '1', generatedAt: '2026-06-17T00:00:00Z', locale: 'pt-BR', slug: 'home',
+      page: { pageId: 'home', slug: 'home', name: 'Home' },
+      sections: [{ sectionId: 'hero', sectionType: 'hero', data: { heading: 'Bem-vindo', cta: 'Get started' } }],
+    };
+    expect(response(good).ok, req(ID_RESPONSE, DOC, `a resolved response MUST validate: ${response(good).errors}`)).toBe(true);
+    expect(response({ ...good, sections: [{ ...good.sections[0], localizations: {} }] }).ok, req(ID_RESPONSE, DOC, 'a delivered section carries resolved data, never its localizations')).toBe(false);
+  });
+});
+
+describe('v2 localized content: the section merge every host resolves identically (server-free)', () => {
+  it('exact tag, then script family, then language, then data — a shallow overlay', () => {
+    const s: Section = { data: { heading: 'Welcome', cta: 'Get started' }, localizations: { es: { heading: 'Bienvenido', cta: 'Empezar' }, 'pt-BR': { heading: 'Bem-vindo' } } };
+    expect(resolveSection(s, 'es', 'en'), req(ID_MERGE, DOC, 'an exact hit MUST overlay its fields onto data')).toEqual({ heading: 'Bienvenido', cta: 'Empezar' });
+    expect(resolveSection(s, 'pt-BR', 'en'), req(ID_MERGE, DOC, 'a field the overlay lacks MUST fall through to data')).toEqual({ heading: 'Bem-vindo', cta: 'Get started' });
+    expect(resolveSection({ data: { h: 'Hi' }, localizations: { pt: { h: 'Oi' } } }, 'pt-BR', 'en'), req(ID_MERGE, DOC, 'pt-BR MUST fall back to the pt language overlay')).toEqual({ h: 'Oi' });
+    expect(resolveSection({ data: { h: 'x' }, localizations: { 'zh-Hant': { h: '繁' }, zh: { h: '简' } } }, 'zh-Hant-TW', 'en'), req(ID_MERGE, DOC, 'zh-Hant-TW MUST take the zh-Hant script family before zh')).toEqual({ h: '繁' });
+    expect(resolveSection(s, 'de', 'en'), req(ID_MERGE, DOC, 'no overlay MUST resolve to data alone')).toEqual(s.data);
+    expect(resolveSection(s, 'en', 'en'), req(ID_MERGE, DOC, 'baseLocale MUST resolve to data')).toEqual(s.data);
+  });
+});
+
+describe('v2 localized content: live advertisement coherence (i18n.md §Localized content "Advertisement")', () => {
+  it('the advertised content record is coherent with the advertised i18n record', async () => {
+    if (HTTP_SKIP) return softSkip('inapplicable', 'no target: OPENWOP_BASE_URL is unset');
+    let doc: Record<string, unknown> | null;
+    try { doc = await v2Discovery(); } catch { doc = null; }
+    if (!doc) return softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0');
+    const content = await familyAdvertised('content');
+    if (content === null) return softSkip('inapplicable', 'the host does not advertise content');
+    const out = coherenceLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    const v = contentRecord(content);
+    expect(v.ok, req(ID_COHERENT, 'schemas/v2/capabilities.schema.json §content', `the content record MUST validate: ${v.errors}`)).toBe(true);
+    for (const x of out.findings) expect(x.ok, req(ID_COHERENT, x.doc, x.message)).toBe(true);
+  });
+});

package/src/scenarios/v2-media-inline-cap-static.test.ts

@@ -0,0 +1,59 @@
+/**
+ * v2 — the `media.*` payload shapes, statically (`spec/v2/core/host-services.md`
+ * §aiProviders: "A `media.*` envelope inlines base64 only up to
+ * `maxInlineMediaBytes` (default 256 KiB); above that the host MUST use a
+ * `url`"; RFC 0055 §C). The v1 twin is the static half of
+ * `media-url-inline-cap`. Its advertisement leg (`aiProviders.maxInlineMediaBytes`)
+ * is in `v2-ai-providers-advertisement`; its seam legs (the media store and the
+ * debug-bundle walk) are not ported.
+ *
+ *   compile   the three `media.{image,audio,file}` schemas compile;
+ *   url       a URL-reference payload validates;
+ *   inline    an inline-base64 payload validates;
+ *   bytes     a payload without `bytes` is rejected (`bytes` is what a cap is
+ *             judged against);
+ *   closed    an unknown property is rejected.
+ *
+ * Host-free: every leg runs with no OPENWOP_BASE_URL.
+ *
+ * @see spec/v2/core/host-services.md §aiProviders
+ * @see schemas/v2/envelopes/media.image.schema.json
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Validator } from '../lib/v2.js';
+import { req } from '../lib/requirement-ids.js';
+
+const DOC = 'host-services.md §aiProviders';
+const MEDIA_KINDS = ['media.image', 'media.audio', 'media.file'] as const;
+const ID_COMPILE = 'openwop.requirement.media.payload-schemas-compile';
+const ID_URL = 'openwop.requirement.media.url-reference-accepted';
+const ID_INLINE = 'openwop.requirement.media.inline-base64-accepted';
+const ID_BYTES = 'openwop.requirement.media.bytes-required';
+const ID_CLOSED = 'openwop.requirement.media.payload-closed';
+
+describe('v2 media payload shapes (host-services.md §aiProviders)', () => {
+  for (const kind of MEDIA_KINDS) {
+    it(`envelopes/${kind}.schema.json compiles under Ajv 2020`, () => {
+      expect(() => v2Validator(`envelopes/${kind}`), req(ID_COMPILE, DOC, `schemas/v2/envelopes/${kind}.schema.json MUST compile`)).not.toThrow();
+    });
+  }
+
+  it('accepts a URL-reference image payload', () => {
+    const r = v2Validator('envelopes/media.image')({ url: 'https://host.example/runs/run_1/assets/img_9.png', bytes: 184320, mimeType: 'image/png' });
+    expect(r.ok, req(ID_URL, DOC, `a URL-reference media payload MUST validate (${r.errors})`)).toBe(true);
+  });
+
+  it('accepts an inline-base64 audio payload', () => {
+    const r = v2Validator('envelopes/media.audio')({ base64: 'AAAA', bytes: 3, mimeType: 'audio/ogg', durationSeconds: 1.2 });
+    expect(r.ok, req(ID_INLINE, DOC, `an inline-base64 media payload MUST validate (${r.errors})`)).toBe(true);
+  });
+
+  it('rejects a media payload missing bytes', () => {
+    expect(v2Validator('envelopes/media.file')({ url: 'https://host.example/runs/run_1/assets/report.pdf' }).ok, req(ID_BYTES, DOC, 'bytes is required on a media payload — it is what the inline cap is judged against')).toBe(false);
+  });
+
+  it('rejects a media payload with an unknown property', () => {
+    expect(v2Validator('envelopes/media.image')({ bytes: 1, wat: true }).ok, req(ID_CLOSED, DOC, 'a media payload is closed: an unknown property MUST be rejected')).toBe(false);
+  });
+});

package/src/scenarios/v2-model-capabilities-advertisement.test.ts

@@ -0,0 +1,61 @@
+/**
+ * v2 — the `modelCapabilities` advertisement (`spec/v2/core/host-services.md`
+ * §modelCapabilities; RFC 0031 §C/§E, RFC 0055). The v1 twin is the
+ * advertisement half of `model-capability-substituted`; the legs live in
+ * `lib/family-advert-witness.ts`.
+ *
+ *   record        the record validates against its seat in
+ *                 `schemas/v2/capabilities.schema.json` — at v2 there is no
+ *                 `supported` seat, so a v1-shaped record fails here;
+ *   advertised    every identifier is spec-reserved or host-private, prefixed
+ *                 `x-host-<host>-` ("a host-private identifier MUST be prefixed");
+ *   substitution  `substitutionSupported` is a boolean.
+ *
+ * Dispositions: discovery unreadable ⇒ `blocked`; `modelCapabilities` absent,
+ * or the facet a leg reads absent ⇒ `inapplicable`.
+ *
+ * @see spec/v2/core/host-services.md §modelCapabilities
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { majorProfile } from '../lib/major-profile.js';
+import { modelCapabilitiesAdvertisedLeg, modelCapabilitiesSubstitutionLeg, recordSchemaLeg } from '../lib/family-advert-witness.js';
+
+const PROFILE = majorProfile(2);
+const UNREADABLE = 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0';
+const ID_RECORD = 'openwop.requirement.model-capabilities.advert-record-schema';
+const ID_ADVERTISED = 'openwop.requirement.model-capabilities.advertised-identifiers';
+const ID_SUBSTITUTION = 'openwop.requirement.model-capabilities.substitution-supported-boolean';
+
+async function discovery(): Promise<Record<string, unknown> | null> {
+  try { return await v2Discovery(); } catch { return null; }
+}
+
+describe('v2 modelCapabilities advertisement (host-services.md §modelCapabilities)', () => {
+  it('the modelCapabilities record validates against its capabilities-schema seat', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    const out = recordSchemaLeg(PROFILE, doc, 'modelCapabilities', 'host-services.md §modelCapabilities');
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_RECORD, x.doc, x.message)).toBe(true);
+  });
+
+  it('modelCapabilities.advertised names only spec-reserved or x-host- prefixed identifiers', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    const out = modelCapabilitiesAdvertisedLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_ADVERTISED, x.doc, x.message)).toBe(true);
+  });
+
+  it('modelCapabilities.substitutionSupported is a boolean', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    const out = modelCapabilitiesSubstitutionLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_SUBSTITUTION, x.doc, x.message)).toBe(true);
+  });
+});

package/src/scenarios/v2-model-capability-insufficient.test.ts

@@ -0,0 +1,63 @@
+/**
+ * v2 — the model-capability refusal, end to end (`spec/v2/core/host-services.md`
+ * §modelCapabilities; RFC 0031 §B step 4 + §D). The v1 twin is the two fixture
+ * legs of `model-capability-insufficient`; its four `evaluate-model-capability-gate`
+ * seam legs are not ported. The legs live in
+ * `lib/model-capability-insufficient-witness.ts`; what differs between majors
+ * (the run path, the event name `model.capability-insufficient`) is the profile row.
+ *
+ * One run of the `conformance-model-capability-insufficient` fixture, whose one
+ * node requires a capability no model offers and declares no fallback:
+ *   refusal      the run ends `failed` / `capability_not_provided`; the log
+ *                carries `model.capability-insufficient` before `node.failed`,
+ *                its payload valid against
+ *                `run-event-payloads#/$defs/modelCapabilityInsufficient`, with
+ *                `fallbackAttempted` not true;
+ *   no-dispatch  the log carries no `node.completed`, `provider.usage` or
+ *                envelope-reliability event.
+ *
+ * Dispositions: `modelCapabilities` not advertised, or the fixture not
+ * advertised ⇒ `inapplicable` (the fixture is the opt-in).
+ *
+ * Proven against a scratch double in `lib/model-capability-insufficient-witness.test.ts`.
+ *
+ * @see spec/v2/core/host-services.md §modelCapabilities
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { majorProfile } from '../lib/major-profile.js';
+import { drive, judgeNoDispatch, judgeRefusal, type InsufficientObservation, type InsufficientSkip } from '../lib/model-capability-insufficient-witness.js';
+
+const PROFILE = majorProfile(2);
+const ID_REFUSAL = 'openwop.requirement.model-capabilities.insufficient-refusal';
+const ID_NO_DISPATCH = 'openwop.requirement.model-capabilities.insufficient-no-dispatch';
+
+let run: Promise<InsufficientSkip | InsufficientObservation | null> | undefined;
+/** One fixture run serves both legs. `null`: discovery unreadable. */
+function observe(): Promise<InsufficientSkip | InsufficientObservation | null> {
+  run ??= (async () => {
+    let doc: Record<string, unknown> | null;
+    try { doc = await v2Discovery(); } catch { doc = null; }
+    return doc === null ? null : drive(PROFILE, doc);
+  })();
+  return run;
+}
+
+describe('v2 model-capability-insufficient (host-services.md §modelCapabilities)', () => {
+  it('a node requiring a capability no model offers fails capability_not_provided after model.capability-insufficient', async () => {
+    const o = await observe();
+    if (o === null) return softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0');
+    if ('kind' in o) return softSkip(o.disposition, o.reason);
+    for (const x of judgeRefusal(PROFILE, o)) expect(x.ok, req(ID_REFUSAL, x.doc, x.message)).toBe(true);
+  }, 60_000);
+
+  it('a refused dispatch emits no node completion, provider usage or envelope-reliability event', async () => {
+    const o = await observe();
+    if (o === null) return softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0');
+    if ('kind' in o) return softSkip(o.disposition, o.reason);
+    for (const x of judgeNoDispatch(PROFILE, o)) expect(x.ok, req(ID_NO_DISPATCH, x.doc, x.message)).toBe(true);
+  }, 60_000);
+});

package/src/scenarios/v2-prompt-all-four-kinds-events.test.ts

@@ -0,0 +1,69 @@
+/**
+ * v2 — every PromptKind resolves and composes on real dispatch
+ * (`spec/v2/core/host-services.md` §`prompts` → §Resolution, §Composition;
+ * RFC 0027 §A). The v1 twin is `prompt-all-four-kinds-events`; the judges live
+ * in `lib/prompt-events-witness.ts`.
+ *
+ * A run of `conformance-prompt-all-four-kinds` (one node: system, user,
+ * schema-hint, and two few-shot refs) is created with `POST /runs`, and its
+ * log read with `GET /runs/{runId}/events/poll`:
+ *   kinds      the run completes; `agent.prompt-resolved` (v1
+ *              `agent.promptResolved`) is emitted for each kind, and surfaces
+ *              each of the five refs (`fewShotPromptRefs[1]` included); unless
+ *              observability is `off`, every ref appears in some
+ *              `prompt.composed.refs` — and under `off`, no `prompt.composed`
+ *              at all; every payload validates against the v2 payload defs;
+ *   ordering   every `prompt.composed` follows an `agent.prompt-resolved` for
+ *              its node.
+ *
+ * Dispositions: `prompts` not advertised or the fixture not in `fixtures[]` ⇒
+ * `inapplicable` (the fixture is the opt-in); discovery unreadable ⇒
+ * `blocked`; the event codemap unreadable ⇒ `blocked`.
+ *
+ * Proven against a scratch double in `lib/prompt-events-witness.test.ts`.
+ *
+ * @see spec/v2/core/host-services.md §Resolution
+ * @see conformance/fixtures/conformance-prompt-all-four-kinds.json
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery, v2RefValidator } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { majorProfile } from '../lib/major-profile.js';
+import { ALL_FOUR_FIXTURE, driveFixture, judgeAllFourKinds, judgeOrdering, type FixtureObservation, type Skip } from '../lib/prompt-events-witness.js';
+
+const PROFILE = majorProfile(2);
+const ID_KINDS = 'openwop.requirement.prompts.all-four-kinds-events';
+const ID_ORDER = 'openwop.requirement.prompts.resolution-precedes-composition';
+const validators = {
+  resolved: v2RefValidator('run-event-payloads.schema.json#/$defs/agentPromptResolved'),
+  composed: v2RefValidator('run-event-payloads.schema.json#/$defs/promptComposed'),
+};
+
+let run: Promise<Skip | FixtureObservation> | undefined;
+type Observed = { ok: true; o: FixtureObservation } | { ok: false; skip: () => undefined };
+async function observed(): Promise<Observed> {
+  if (!process.env['OPENWOP_BASE_URL']) return { ok: false, skip: () => softSkip('inapplicable', 'no target: OPENWOP_BASE_URL is unset') };
+  let doc: Record<string, unknown> | null;
+  try { doc = await v2Discovery(); } catch { doc = null; }
+  if (!doc) return { ok: false, skip: () => softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0') };
+  run ??= driveFixture(PROFILE, doc, ALL_FOUR_FIXTURE);
+  const o = await run;
+  if ('kind' in o) return { ok: false, skip: () => softSkip(o.disposition, o.reason) };
+  return { ok: true, o };
+}
+
+describe('v2 prompt events: all four kinds (host-services.md §Resolution, §Composition)', () => {
+  it('each kind and each configured ref is resolved and composed', async () => {
+    const r = await observed();
+    if (!r.ok) return r.skip();
+    for (const x of judgeAllFourKinds(r.o, validators)) expect(x.ok, req(ID_KINDS, x.doc, x.message)).toBe(true);
+  }, 60_000);
+
+  it('every prompt.composed follows an agent.prompt-resolved for its node', async () => {
+    const r = await observed();
+    if (!r.ok) return r.skip();
+    for (const x of judgeOrdering(r.o)) expect(x.ok, req(ID_ORDER, x.doc, x.message)).toBe(true);
+  }, 60_000);
+});

package/src/scenarios/v2-prompt-end-to-end-events.test.ts

@@ -0,0 +1,71 @@
+/**
+ * v2 — a node's systemPromptRef resolves and composes on real dispatch
+ * (`spec/v2/core/host-services.md` §`prompts` → §Resolution, §Composition;
+ * RFCs 0027 §E, 0029 §A). The v1 twin is `prompt-end-to-end-events`; the
+ * judges live in `lib/prompt-events-witness.ts`.
+ *
+ * A run of `conformance-prompt-end-to-end` (node `writer`, `systemPromptRef:
+ * prompt:conformance.prompt.writer-system@1.0.0`) is created with
+ * `POST /runs`, and its log read with `GET /runs/{runId}/events/poll`:
+ *   resolution   the run completes; `agent.prompt-resolved` (kind `system`,
+ *                node `writer`) names the node layer as the applied entry and
+ *                resolves the configured ref;
+ *   composition  unless observability is `off`, `prompt.composed` carries a
+ *                `sha256:<hex64>` hash and kind `system-only`; bodies
+ *                (`composed`, `systemPrompt`) only under `full` — NEW at v2:
+ *                under `hashed` (the default) no body field appears (v1
+ *                required a body unconditionally); under `off`, no
+ *                `prompt.composed` at all;
+ *   ordering     every `prompt.composed` follows an `agent.prompt-resolved`
+ *                for its node.
+ *
+ * Dispositions: `prompts` not advertised or the fixture not in `fixtures[]` ⇒
+ * `inapplicable`; discovery unreadable ⇒ `blocked`.
+ *
+ * Proven against a scratch double in `lib/prompt-events-witness.test.ts`.
+ *
+ * @see spec/v2/core/host-services.md §Resolution, §Composition
+ * @see conformance/fixtures/conformance-prompt-end-to-end.json
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery, v2RefValidator } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { majorProfile } from '../lib/major-profile.js';
+import { END_TO_END_FIXTURE, driveFixture, judgeEndToEnd, judgeOrdering, type FixtureObservation, type Skip } from '../lib/prompt-events-witness.js';
+
+const PROFILE = majorProfile(2);
+const ID_E2E = 'openwop.requirement.prompts.end-to-end-resolution-and-composition';
+const ID_ORDER = 'openwop.requirement.prompts.resolution-precedes-composition';
+const validators = {
+  resolved: v2RefValidator('run-event-payloads.schema.json#/$defs/agentPromptResolved'),
+  composed: v2RefValidator('run-event-payloads.schema.json#/$defs/promptComposed'),
+};
+
+let run: Promise<Skip | FixtureObservation> | undefined;
+type Observed = { ok: true; o: FixtureObservation } | { ok: false; skip: () => undefined };
+async function observed(): Promise<Observed> {
+  if (!process.env['OPENWOP_BASE_URL']) return { ok: false, skip: () => softSkip('inapplicable', 'no target: OPENWOP_BASE_URL is unset') };
+  let doc: Record<string, unknown> | null;
+  try { doc = await v2Discovery(); } catch { doc = null; }
+  if (!doc) return { ok: false, skip: () => softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0') };
+  run ??= driveFixture(PROFILE, doc, END_TO_END_FIXTURE);
+  const o = await run;
+  if ('kind' in o) return { ok: false, skip: () => softSkip(o.disposition, o.reason) };
+  return { ok: true, o };
+}
+
+describe('v2 prompt events: end to end (host-services.md §Resolution, §Composition)', () => {
+  it('the node layer wins, and prompt.composed carries the hash with bodies only under full', async () => {
+    const r = await observed();
+    if (!r.ok) return r.skip();
+    for (const x of judgeEndToEnd(r.o, validators)) expect(x.ok, req(ID_E2E, x.doc, x.message)).toBe(true);
+  }, 60_000);
+
+  it('agent.prompt-resolved precedes prompt.composed for the node', async () => {
+    const r = await observed();
+    if (!r.ok) return r.skip();
+    for (const x of judgeOrdering(r.o)) expect(x.ok, req(ID_ORDER, x.doc, x.message)).toBe(true);
+  }, 60_000);
+});

package/src/scenarios/v2-prompt-list-and-fetch.test.ts

@@ -0,0 +1,103 @@
+/**
+ * v2 — the prompt library read surface (`spec/v2/core/host-services.md`
+ * §`prompts` + §Library; `api/v2/openapi.yaml` `listPromptTemplates`,
+ * `getPromptTemplate`; RFC 0028 §A). The v1 twin is `prompt-list-and-fetch`;
+ * the legs live in `lib/prompt-library-witness.ts`.
+ *
+ *   list        `GET /prompts` answers `{ items, nextCursor? }`; every item
+ *               validates against the closed v2 PromptTemplate;
+ *   filters     `?kind=system` and `?source=host` narrow;
+ *   fetch       a listed template is fetched by id;
+ *   etag        an ETag, when sent (a SHOULD), revalidates to `304`;
+ *   unknown     an unknown id is `404` with the v2 error envelope;
+ *   gate off    NEW at v2, unaided: with `prompts.endpointsSupported` not
+ *               advertised (the record absent, or the facet not `true`),
+ *               `GET /prompts` answers `404 not_found` (errors.md
+ *               §Unadvertised operations).
+ *
+ * Dispositions: no target ⇒ `inapplicable`; discovery unreadable ⇒ `blocked`;
+ * `prompts` absent or `endpointsSupported` not `true` ⇒ the read legs are
+ * `inapplicable` (gated by presence, never a strict-mode failure) and the
+ * gate-off leg binds; an empty library ⇒ fetch/etag `inapplicable`.
+ *
+ * Proven against a scratch double in `lib/prompt-library-witness.test.ts`.
+ *
+ * @see spec/v2/core/host-services.md §prompts
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery, v2Validator } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { majorProfile } from '../lib/major-profile.js';
+import { etagLeg, fetchLeg, filterLeg, gateOffReadLeg, listLeg, promptAdverts, unknownLeg, type PromptAdverts } from '../lib/prompt-library-witness.js';
+
+const PROFILE = majorProfile(2);
+const ID_LIST = 'openwop.requirement.prompts.list-shape';
+const ID_FILTER = 'openwop.requirement.prompts.list-filters';
+const ID_FETCH = 'openwop.requirement.prompts.fetch-by-id';
+const ID_ETAG = 'openwop.requirement.prompts.etag-revalidation';
+const ID_UNKNOWN = 'openwop.requirement.prompts.unknown-template-404';
+const ID_GATE = 'openwop.requirement.prompts.endpoints-gate-off-404';
+const HTTP_SKIP = !process.env['OPENWOP_BASE_URL'];
+const template = v2Validator('prompt-template');
+const envelope = v2Validator('error-envelope');
+
+type Ready = { ok: true; a: PromptAdverts } | { ok: false; skip: () => undefined };
+async function ready(): Promise<Ready> {
+  if (HTTP_SKIP) return { ok: false, skip: () => softSkip('inapplicable', 'no target: OPENWOP_BASE_URL is unset') };
+  let doc: Record<string, unknown> | null;
+  try { doc = await v2Discovery(); } catch { doc = null; }
+  if (!doc) return { ok: false, skip: () => softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0') };
+  return { ok: true, a: promptAdverts(PROFILE, doc) };
+}
+
+describe('v2 prompt library: read surface (host-services.md §prompts)', () => {
+  it('GET /prompts answers items whose every entry validates', async () => {
+    const r = await ready();
+    if (!r.ok) return r.skip();
+    const out = await listLeg(r.a, template);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_LIST, x.doc, x.message)).toBe(true);
+  });
+
+  it('the kind and source filters narrow the list', async () => {
+    const r = await ready();
+    if (!r.ok) return r.skip();
+    const out = await filterLeg(r.a);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_FILTER, x.doc, x.message)).toBe(true);
+  });
+
+  it('a listed template is fetched by id', async () => {
+    const r = await ready();
+    if (!r.ok) return r.skip();
+    const out = await fetchLeg(PROFILE, r.a, template);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_FETCH, x.doc, x.message)).toBe(true);
+  });
+
+  it('an ETag, when sent, revalidates to 304', async () => {
+    const r = await ready();
+    if (!r.ok) return r.skip();
+    const out = await etagLeg(PROFILE, r.a);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_ETAG, x.doc, x.message)).toBe(true);
+  });
+
+  it('an unknown templateId answers 404 with the error envelope', async () => {
+    const r = await ready();
+    if (!r.ok) return r.skip();
+    const out = await unknownLeg(PROFILE, r.a, envelope);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_UNKNOWN, x.doc, x.message)).toBe(true);
+  });
+
+  it('with endpointsSupported unadvertised, GET /prompts answers 404 not_found', async () => {
+    const r = await ready();
+    if (!r.ok) return r.skip();
+    const out = await gateOffReadLeg(r.a);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_GATE, x.doc, x.message)).toBe(true);
+  });
+});