@openwop/openwop-conformance 2.45.14 → 2.45.16

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-multi-party-conversation-advertisement.test.ts

@@ -0,0 +1,52 @@
+/**
+ * v2 — the `multiPartyConversation` advertisement (`spec/v2/core/conversation.md` §`multiPartyConversation`): the multi-party conversation (council) claim. The v1 twin is
+ * `multi-party-conversation-shape`;
+ * the legs live in `lib/family-advert-witness.ts` (witness wave 3).
+ *
+ *   record         the record validates against its capabilities-schema seat;
+ *   max-participants multiPartyConversation.maxParticipants is an integer of at least 2;
+ *
+ * Not here: roster enforcement and the over-cap refusal: v2 has no client route that opens a conversation with a roster, and the refusals name no error code (TODO §8).
+ *
+ * Dispositions: discovery unreadable ⇒ `blocked`; `multiPartyConversation` absent, or the
+ * facet a leg reads absent ⇒ `inapplicable`.
+ *
+ * @see spec/v2/core/conversation.md §`multiPartyConversation`
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery, familyAdvertised } 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 { multiPartyMaxParticipantsLeg, recordSchemaLeg } from '../lib/family-advert-witness.js';
+
+const PROFILE = majorProfile(2);
+const DOC = 'conversation.md §multiPartyConversation';
+const UNREADABLE = 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0';
+const ID_RECORD = 'openwop.requirement.multi-party-conversation.advert-record-schema';
+const ID_MAX_PARTICIPANTS = 'openwop.requirement.multi-party-conversation.max-participants';
+
+async function discovery(): Promise<Record<string, unknown> | null> {
+  try { return await v2Discovery(); } catch { return null; }
+}
+
+describe('v2 multiPartyConversation advertisement (conversation.md §multiPartyConversation)', () => {
+  it('the multiPartyConversation record validates against its capabilities-schema seat', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('multiPartyConversation'))) return softSkip('inapplicable', 'the host does not advertise multiPartyConversation');
+    const out = recordSchemaLeg(PROFILE, doc, 'multiPartyConversation', DOC);
+    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('multiPartyConversation.maxParticipants is an integer of at least 2', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('multiPartyConversation'))) return softSkip('inapplicable', 'the host does not advertise multiPartyConversation');
+    const out = multiPartyMaxParticipantsLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_MAX_PARTICIPANTS, x.doc, x.message)).toBe(true);
+  });
+});

package/src/scenarios/v2-node-pack-runtimes-advertisement.test.ts

@@ -0,0 +1,52 @@
+/**
+ * v2 — the `nodePackRuntimes` advertisement (`spec/v2/core/node-pack-runtimes.md` §WASM): the node-pack runtimes a host loads. The v1 twin is
+ * `wasm-pack-load`;
+ * the legs live in `lib/family-advert-witness.ts` (witness wave 3).
+ *
+ *   record         the record validates against its capabilities-schema seat;
+ *   wasm-facet-shape nodePackRuntimes.wasm lists ABI versions and a memory cap in range;
+ *
+ * Not here: ABI rejection at load and the memory-cap breach need an operator-installed fixture pack.
+ *
+ * Dispositions: discovery unreadable ⇒ `blocked`; `nodePackRuntimes` absent, or the
+ * facet a leg reads absent ⇒ `inapplicable`.
+ *
+ * @see spec/v2/core/node-pack-runtimes.md §WASM
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery, familyAdvertised } 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 { nodePackRuntimesWasmLeg, recordSchemaLeg } from '../lib/family-advert-witness.js';
+
+const PROFILE = majorProfile(2);
+const DOC = 'node-pack-runtimes.md §WASM';
+const UNREADABLE = 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0';
+const ID_RECORD = 'openwop.requirement.node-pack-runtimes.advert-record-schema';
+const ID_WASM_FACET_SHAPE = 'openwop.requirement.node-pack-runtimes.wasm-facet-shape';
+
+async function discovery(): Promise<Record<string, unknown> | null> {
+  try { return await v2Discovery(); } catch { return null; }
+}
+
+describe('v2 nodePackRuntimes advertisement (node-pack-runtimes.md §WASM)', () => {
+  it('the nodePackRuntimes record validates against its capabilities-schema seat', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('nodePackRuntimes'))) return softSkip('inapplicable', 'the host does not advertise nodePackRuntimes');
+    const out = recordSchemaLeg(PROFILE, doc, 'nodePackRuntimes', DOC);
+    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('nodePackRuntimes.wasm lists ABI versions and a memory cap in range', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('nodePackRuntimes'))) return softSkip('inapplicable', 'the host does not advertise nodePackRuntimes');
+    const out = nodePackRuntimesWasmLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_WASM_FACET_SHAPE, x.doc, x.message)).toBe(true);
+  });
+});

package/src/scenarios/v2-nondeterminism-policy-advertisement.test.ts

@@ -0,0 +1,41 @@
+/**
+ * v2 — the `nondeterminismPolicy` advertisement (`spec/v2/core/replay.md` §Declared nondeterminism): the declared-nondeterminism claim. The v1 twin is
+ * `agent-platform-profile`;
+ * the legs live in `lib/family-advert-witness.ts` (witness wave 3).
+ *
+ *   record         the record validates against its capabilities-schema seat;
+ *
+ * Not here: recording every declared source needs a `sources[]` seat and a named event (TODO §8).
+ *
+ * Dispositions: discovery unreadable ⇒ `blocked`; `nondeterminismPolicy` absent, or the
+ * facet a leg reads absent ⇒ `inapplicable`.
+ *
+ * @see spec/v2/core/replay.md §Declared nondeterminism
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery, familyAdvertised } 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 { recordSchemaLeg } from '../lib/family-advert-witness.js';
+
+const PROFILE = majorProfile(2);
+const DOC = 'replay.md §Declared nondeterminism';
+const UNREADABLE = 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0';
+const ID_RECORD = 'openwop.requirement.nondeterminism-policy.advert-record-schema';
+
+async function discovery(): Promise<Record<string, unknown> | null> {
+  try { return await v2Discovery(); } catch { return null; }
+}
+
+describe('v2 nondeterminismPolicy advertisement (replay.md §Declared nondeterminism)', () => {
+  it('the nondeterminismPolicy record validates against its capabilities-schema seat', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('nondeterminismPolicy'))) return softSkip('inapplicable', 'the host does not advertise nondeterminismPolicy');
+    const out = recordSchemaLeg(PROFILE, doc, 'nondeterminismPolicy', DOC);
+    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);
+  });
+});

package/src/scenarios/v2-portability-advertisement.test.ts

@@ -0,0 +1,63 @@
+/**
+ * v2 — the `portability` advertisement (`spec/v2/core/portability.md`; RFC
+ * 0098). The v1 twin is the advertisement leg of `export-bundle-portability`;
+ * the legs live in `lib/family-advert-witness.ts`.
+ *
+ *   record         the record validates against its capabilities-schema seat;
+ *   import⇒dryRun  "A host advertising `import` MUST advertise `dryRun: true`",
+ *                  read as the schema reads it: `import: true` ⇒ `dryRun: true`;
+ *   kinds          unique export-bundle item kinds.
+ *
+ * Not here: import refusal of credential material, dry-run no-write and
+ * idempotence: v2 defines no import route ("a host serves them on routes of its
+ * own"). The bundle shape is `v2-export-bundle-static`.
+ *
+ * Dispositions: discovery unreadable ⇒ `blocked`; `portability` absent, or the
+ * facet a leg reads absent ⇒ `inapplicable`.
+ *
+ * @see spec/v2/core/portability.md §The portability record
+ */
+
+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 { portabilityImportDryRunLeg, portabilityKindsLeg, recordSchemaLeg } from '../lib/family-advert-witness.js';
+
+const PROFILE = majorProfile(2);
+const DOC = 'portability.md §The portability record';
+const UNREADABLE = 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0';
+const ID_RECORD = 'openwop.requirement.portability.advert-record-schema';
+const ID_IMPORT_REQUIRES_DRY_RUN = 'openwop.requirement.portability.import-requires-dry-run';
+const ID_KINDS_SHAPE = 'openwop.requirement.portability.kinds-shape';
+
+async function discovery(): Promise<Record<string, unknown> | null> {
+  try { return await v2Discovery(); } catch { return null; }
+}
+
+describe('v2 portability advertisement (portability.md §The portability record)', () => {
+  it('the portability record validates against its capabilities-schema seat', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    const out = recordSchemaLeg(PROFILE, doc, 'portability', DOC);
+    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('a host advertising portability.import advertises dryRun: true', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    const out = portabilityImportDryRunLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_IMPORT_REQUIRES_DRY_RUN, x.doc, x.message)).toBe(true);
+  });
+
+  it('portability.kinds lists unique export-bundle item kinds', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    const out = portabilityKindsLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_KINDS_SHAPE, x.doc, x.message)).toBe(true);
+  });
+});

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-library-advertisement.test.ts

@@ -0,0 +1,40 @@
+/**
+ * v2 — the `promptLibrary` advertisement (`spec/v2/core/host-services.md` §`promptLibrary`): the prompt library claim. It had no v1 witness;
+ * the legs live in `lib/family-advert-witness.ts` (witness wave 3).
+ *
+ *   record         the record validates against its capabilities-schema seat;
+ *
+ * Not here: returning a pinned version verbatim needs a fixture pack.
+ *
+ * Dispositions: discovery unreadable ⇒ `blocked`; `promptLibrary` absent, or the
+ * facet a leg reads absent ⇒ `inapplicable`.
+ *
+ * @see spec/v2/core/host-services.md §`promptLibrary`
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery, familyAdvertised } 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 { recordSchemaLeg } from '../lib/family-advert-witness.js';
+
+const PROFILE = majorProfile(2);
+const DOC = 'host-services.md §promptLibrary';
+const UNREADABLE = 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0';
+const ID_RECORD = 'openwop.requirement.prompt-library.advert-record-schema';
+
+async function discovery(): Promise<Record<string, unknown> | null> {
+  try { return await v2Discovery(); } catch { return null; }
+}
+
+describe('v2 promptLibrary advertisement (host-services.md §promptLibrary)', () => {
+  it('the promptLibrary record validates against its capabilities-schema seat', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('promptLibrary'))) return softSkip('inapplicable', 'the host does not advertise promptLibrary');
+    const out = recordSchemaLeg(PROFILE, doc, 'promptLibrary', DOC);
+    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);
+  });
+});

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);
+  });
+});