@openwop/openwop-conformance 2.45.14 → 2.45.16

package/src/scenarios/v2-ai-envelope-shape-static.test.ts

@@ -0,0 +1,93 @@
+/**
+ * v2 — the AI envelope wire shape, statically (`spec/v2/core/events.md`
+ * §"AI envelopes: E1–E5"; `schemas/v2/ai-envelope.schema.json`). The v1 twin is
+ * the static half of `ai-envelope-shape`; its live halves (the
+ * `envelope/accept` seam legs) are seam-only and not ported.
+ *
+ *   compile     `ai-envelope.schema.json` and each universal-kind payload
+ *               schema compile under Ajv 2020 with the v2 tree registered;
+ *   positive    a well-formed envelope validates — with `correlationId` and
+ *               `meta.source`, which v2 makes REQUIRED (migration C4.16);
+ *   meta        an envelope without `meta` is rejected;
+ *   closed      an unknown top-level property is rejected;
+ *   correlation NEW at v2: an envelope without `correlationId` is rejected
+ *               ("`correlationId` and `meta.source` are REQUIRED on every
+ *               envelope … nothing is synthesized");
+ *   source      NEW at v2: an envelope whose `meta` has no `source` is rejected.
+ *
+ * The `<org>.` namespacing rule for kinds is not witnessed here: the schema's
+ * `type` is an open string, so the rule binds the engine's acceptance, not the
+ * wire shape.
+ *
+ * Host-free: every leg runs with no OPENWOP_BASE_URL.
+ *
+ * @see spec/v2/core/events.md §"AI envelopes: E1–E5"
+ * @see spec/v1/migrations.json openwop.migration.C4.16
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Validator } from '../lib/v2.js';
+import { req } from '../lib/requirement-ids.js';
+import { UNIVERSAL_KINDS } from '../lib/envelope-schema-static.js';
+
+const DOC = 'events.md §AI envelopes: E1–E5';
+const ID_COMPILE = 'openwop.requirement.ai-envelope.schemas-compile';
+const ID_POSITIVE = 'openwop.requirement.ai-envelope.well-formed-accepted';
+const ID_META = 'openwop.requirement.ai-envelope.meta-required';
+const ID_CLOSED = 'openwop.requirement.ai-envelope.top-level-closed';
+const ID_CORRELATION = 'openwop.requirement.ai-envelope.correlation-id-required';
+const ID_SOURCE = 'openwop.requirement.ai-envelope.meta-source-required';
+
+const WELL_FORMED = {
+  type: 'clarification.request',
+  schemaVersion: 1,
+  envelopeId: 'env-v2-positive-1',
+  correlationId: 'run-1:node-2:turn-0:abc123',
+  payload: { questions: [{ id: 'q1', question: 'Which provider?' }] },
+  meta: { source: 'ai-generation', ts: '2026-10-04T10:00:00Z', contentTrust: 'trusted' },
+} as const;
+
+/** The well-formed envelope with one top-level field removed. */
+function without(field: string): Record<string, unknown> {
+  const e: Record<string, unknown> = { ...WELL_FORMED };
+  delete e[field];
+  return e;
+}
+
+describe('v2 AI envelope shape: schemas compile', () => {
+  it('ai-envelope.schema.json compiles under Ajv 2020', () => {
+    expect(() => v2Validator('ai-envelope'), req(ID_COMPILE, DOC, 'schemas/v2/ai-envelope.schema.json MUST compile')).not.toThrow();
+  });
+
+  for (const kind of UNIVERSAL_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();
+    });
+  }
+});
+
+describe('v2 AI envelope shape: round-trip', () => {
+  const validate = v2Validator('ai-envelope');
+
+  it('accepts a well-formed envelope carrying correlationId and meta.source', () => {
+    const r = validate(WELL_FORMED);
+    expect(r.ok, req(ID_POSITIVE, DOC, `a well-formed envelope MUST validate (${r.errors})`)).toBe(true);
+  });
+
+  it('rejects an envelope missing meta', () => {
+    expect(validate(without('meta')).ok, req(ID_META, DOC, 'an envelope without meta MUST be rejected')).toBe(false);
+  });
+
+  it('rejects an envelope with an unknown top-level property', () => {
+    expect(validate({ ...WELL_FORMED, unknownTopLevel: 'x' }).ok, req(ID_CLOSED, 'schemas/v2/ai-envelope.schema.json', 'the envelope is closed: an unknown top-level property MUST be rejected')).toBe(false);
+  });
+
+  it('rejects an envelope missing correlationId', () => {
+    expect(validate(without('correlationId')).ok, req(ID_CORRELATION, DOC, 'correlationId is REQUIRED on every envelope at v2 — an envelope without it MUST be rejected, never synthesized')).toBe(false);
+  });
+
+  it('rejects an envelope whose meta carries no source', () => {
+    const { source: _source, ...meta } = WELL_FORMED.meta;
+    expect(validate({ ...WELL_FORMED, meta }).ok, req(ID_SOURCE, DOC, 'meta.source is REQUIRED on every envelope at v2 — an envelope without it MUST be rejected')).toBe(false);
+  });
+});

package/src/scenarios/v2-ai-providers-advertisement.test.ts

@@ -0,0 +1,94 @@
+/**
+ * v2 — the `aiProviders` advertisement facets that survive at major 2
+ * (`spec/v2/core/host-services.md` §aiProviders; migration C2.11 narrowed the
+ * v1 facets). The v1 twins are the advertisement halves of
+ * `aiproviders-selfhosted-shape`, `byok-auth-modes` and `media-url-inline-cap`;
+ * the legs live in `lib/family-advert-witness.ts`.
+ *
+ *   record              the record validates against its seat in
+ *                       `schemas/v2/capabilities.schema.json`;
+ *   selfHosted          one boolean (the v1 `selfHosted[]` id list retired);
+ *   authModes shape     one flat list (the v1 per-provider map retired);
+ *   (not a leg) authModes vocabulary: the prose names `apiKey`, `oauth-pkce`,
+ *                       `oauth-device`, `none`, `subscription`, but its only
+ *                       MUSTs bind clients ("a client MUST ignore an unknown
+ *                       mode"), and the v2 schema seat is `string[]` with no
+ *                       enum. No host-side MUST exists, so a misspelt mode is an
+ *                       interop defect the host should fix, not a failing row.
+ *                       Restoring the v1 enum would need an RFC.
+ *   maxInlineMediaBytes an integer ≥ 1;
+ *   promptPrefixCache   one boolean (the v1 `{ supported, providers[] }` retired).
+ *
+ * The v1 rules C2.11 retired (`selfHosted[]` ⊆ `supported[]`, the per-provider
+ * `authModes` keys/byok/`["none"]` rules) are not ported: they have no v2 seat.
+ *
+ * Dispositions: discovery unreadable ⇒ `blocked`; `aiProviders` absent, or the
+ * facet a leg reads absent ⇒ `inapplicable`.
+ *
+ * @see spec/v2/core/host-services.md §aiProviders
+ * @see spec/v1/migrations.json openwop.migration.C2.11
+ */
+
+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 {
+  aiProvidersAuthModesShapeLeg, aiProvidersInlineMediaLeg, aiProvidersPromptPrefixCacheLeg, aiProvidersSelfHostedLeg,
+  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.ai-providers.advert-record-schema';
+const ID_SELF_HOSTED = 'openwop.requirement.ai-providers.self-hosted-boolean';
+const ID_AUTH_SHAPE = 'openwop.requirement.ai-providers.auth-modes-flat-list';
+const ID_INLINE_MEDIA = 'openwop.requirement.ai-providers.max-inline-media-bytes';
+const ID_PREFIX_CACHE = 'openwop.requirement.ai-providers.prompt-prefix-cache-boolean';
+
+async function discovery(): Promise<Record<string, unknown> | null> {
+  try { return await v2Discovery(); } catch { return null; }
+}
+
+describe('v2 aiProviders advertisement (host-services.md §aiProviders)', () => {
+  it('the aiProviders record validates against its capabilities-schema seat', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    const out = recordSchemaLeg(PROFILE, doc, 'aiProviders', 'host-services.md §aiProviders');
+    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('aiProviders.selfHosted is one boolean', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    const out = aiProvidersSelfHostedLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_SELF_HOSTED, x.doc, x.message)).toBe(true);
+  });
+
+  it('aiProviders.authModes is one flat list of modes', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    const out = aiProvidersAuthModesShapeLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_AUTH_SHAPE, x.doc, x.message)).toBe(true);
+  });
+
+  it('aiProviders.maxInlineMediaBytes is an integer of at least 1', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    const out = aiProvidersInlineMediaLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_INLINE_MEDIA, x.doc, x.message)).toBe(true);
+  });
+
+  it('aiProviders.promptPrefixCache is one boolean', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    const out = aiProvidersPromptPrefixCacheLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_PREFIX_CACHE, x.doc, x.message)).toBe(true);
+  });
+});

package/src/scenarios/v2-artifact-created-static.test.ts

@@ -0,0 +1,92 @@
+/**
+ * v2 — the `artifact.created` payload, statically
+ * (`spec/v2/core/artifact-type-packs.md` §Registration;
+ * `schemas/v2/run-event-payloads.schema.json#/$defs/artifactCreated`; RFCs
+ * 0071, 0075, 0138, 0145, 0185). The v1 twins are the schema halves of
+ * `artifact-type-store-emission` and `artifact-type-registration-source`;
+ * their fixture-run legs are not ported here.
+ *
+ *   type        `artifact.created` is a registered v2 event type;
+ *   required    `artifactId` and `artifactType` are REQUIRED (the RFC 0138
+ *               replay correction reads the type from the event);
+ *   provenance  `registrationSource` is `pack` or `host` ("pack-registered …
+ *               `registrationSource: "pack"`, host-registered … `"host"`"),
+ *               and the discovery per-type seat carries the same vocabulary,
+ *               so the two surfaces cannot disagree on a value;
+ *   registered  `registered` is a boolean;
+ *   closed      an unknown key is rejected; a vendor key under the RFC 0185
+ *               hatch (`x-`, `vendor.`, `openwop-`) is carried.
+ *
+ * Host-free: every leg runs with no OPENWOP_BASE_URL.
+ *
+ * @see spec/v2/core/artifact-type-packs.md §Registration
+ */
+
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { SCHEMAS_DIR } from '../lib/paths.js';
+import { v2RefValidator } from '../lib/v2.js';
+import { req } from '../lib/requirement-ids.js';
+
+const DOC = 'artifact-type-packs.md §Registration';
+const ID_TYPE = 'openwop.requirement.artifact-types.created-event-type-registered';
+const ID_REQUIRED = 'openwop.requirement.artifact-types.created-requires-artifact-type';
+const ID_PROVENANCE = 'openwop.requirement.artifact-types.created-registration-source-enum';
+const ID_REGISTERED = 'openwop.requirement.artifact-types.created-registered-boolean';
+const ID_CLOSED = 'openwop.requirement.artifact-types.created-payload-closed';
+
+const GOOD = { artifactId: 'art_1', artifactType: 'vendor.acme.prd', nodeId: 'n1', registered: true, registrationSource: 'host' } as const;
+
+const isRecord = (v: unknown): v is Record<string, unknown> => v !== null && typeof v === 'object' && !Array.isArray(v);
+function enumAt(root: unknown, path: readonly string[]): unknown {
+  let cur: unknown = root;
+  for (const k of path) cur = isRecord(cur) ? cur[k] : undefined;
+  return isRecord(cur) ? cur['enum'] : undefined;
+}
+
+describe('v2 artifact.created payload (artifact-type-packs.md §Registration)', () => {
+  const validate = v2RefValidator('run-event-payloads.schema.json#/$defs/artifactCreated');
+
+  it('artifact.created is a registered v2 run-event type', () => {
+    const r = v2RefValidator('run-event.schema.json#/properties/type')('artifact.created');
+    expect(r.ok, req(ID_TYPE, DOC, `artifact.created MUST be accepted by the v2 run-event type union (${r.errors})`)).toBe(true);
+  });
+
+  it('accepts a well-formed payload, with either provenance or none', () => {
+    const { registrationSource: _src, ...noSource } = GOOD;
+    for (const p of [GOOD, { ...GOOD, registrationSource: 'pack' }, noSource]) {
+      const r = validate(p);
+      expect(r.ok, req(ID_PROVENANCE, DOC, `artifact.created ${JSON.stringify(p)} MUST validate (${r.errors})`)).toBe(true);
+    }
+  });
+
+  it.each(['artifactId', 'artifactType'])('rejects a payload without %s', (field) => {
+    const p: Record<string, unknown> = { ...GOOD };
+    delete p[field];
+    expect(validate(p).ok, req(ID_REQUIRED, DOC, `artifact.created without ${field} MUST be rejected`)).toBe(false);
+  });
+
+  it('rejects a registrationSource outside pack | host', () => {
+    expect(validate({ ...GOOD, registrationSource: 'vendor' }).ok, req(ID_PROVENANCE, DOC, 'registrationSource MUST be pack or host')).toBe(false);
+  });
+
+  it('the discovery per-type registrationSource carries the same vocabulary as the event', () => {
+    const payloads: unknown = JSON.parse(readFileSync(join(SCHEMAS_DIR, 'v2', 'run-event-payloads.schema.json'), 'utf8'));
+    const caps: unknown = JSON.parse(readFileSync(join(SCHEMAS_DIR, 'v2', 'capabilities.schema.json'), 'utf8'));
+    const event = enumAt(payloads, ['$defs', 'artifactCreated', 'properties', 'registrationSource']);
+    const advert = enumAt(caps, ['properties', 'artifactTypes', 'properties', 'types', 'additionalProperties', 'properties', 'registrationSource']);
+    expect(event, req(ID_PROVENANCE, DOC, 'artifact.created.registrationSource MUST be the pack | host enum')).toEqual(['pack', 'host']);
+    expect(advert, req(ID_PROVENANCE, 'capabilities.schema.json §artifactTypes.types', 'the advertised per-type registrationSource MUST use the vocabulary artifact.created carries')).toEqual(event);
+  });
+
+  it('rejects a non-boolean registered', () => {
+    expect(validate({ ...GOOD, registered: 'true' }).ok, req(ID_REGISTERED, DOC, 'registered MUST be a boolean')).toBe(false);
+  });
+
+  it('rejects an unknown key, and carries a vendor key under the RFC 0185 hatch', () => {
+    expect(validate({ ...GOOD, payload: { secret: 1 } }).ok, req(ID_CLOSED, DOC, 'an unknown key on artifact.created MUST be rejected')).toBe(false);
+    const r = validate({ ...GOOD, 'x-acme-trace': 'abc', 'vendor.acme.note': 'n' });
+    expect(r.ok, req(ID_CLOSED, 'run-event-payloads.schema.json §artifactCreated (RFC 0185)', `a vendor-prefixed key MUST be carried (${r.errors})`)).toBe(true);
+  });
+});

package/src/scenarios/v2-artifact-type-schema-url.test.ts

@@ -0,0 +1,44 @@
+/**
+ * v2 — the canonical schema URL of a host-registered artifact type
+ * (`spec/v2/core/artifact-type-packs.md` §Schema distribution; RFCs 0071, 0075,
+ * 0145). NEW at v2, unaided: no seam and no fixture.
+ *
+ * "A host advertising `artifactTypes` SHOULD serve each installed type's schema
+ * there, and MUST for a host-registered type whose `schemaVersion` it
+ * advertises." The MUST set is read from discovery: each
+ * `artifactTypes.types[id]` with `registrationSource: "host"` and a
+ * `schemaVersion`. For each, `GET /schemas/artifacts/{id}.schema.json` answers
+ * `200`, `Content-Type: application/schema+json`, and a schema whose `$id` is
+ * that canonical URL. Pack-backed types are a SHOULD and are not asserted.
+ *
+ * Dispositions: `artifactTypes` not advertised, or no host-registered type with
+ * a `schemaVersion` ⇒ `inapplicable`; discovery unreadable ⇒ `blocked`.
+ *
+ * Proven against a double in `lib/artifact-schema-url-witness.test.ts`.
+ *
+ * @see spec/v2/core/artifact-type-packs.md §Schema distribution
+ * @see schemas/v2/capabilities.schema.json §artifactTypes.types.registrationSource
+ */
+
+import { describe, it, expect } from 'vitest';
+import { familyAdvertised, 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 { driveSchemaUrls, judgeSchemaUrl } from '../lib/artifact-schema-url-witness.js';
+
+const PROFILE = majorProfile(2);
+const ID_SERVED = 'openwop.requirement.artifact-types.host-registered-schema-served';
+
+describe('v2 artifact types: the canonical schema URL (artifact-type-packs.md §Schema distribution)', () => {
+  it('every host-registered type with an advertised schemaVersion has its schema served at {HostBase}/schemas/artifacts/{id}.schema.json', async () => {
+    if (!process.env['OPENWOP_BASE_URL']) 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');
+    if (!(await familyAdvertised('artifactTypes'))) return softSkip('inapplicable', 'the host does not advertise artifactTypes');
+    const o = await driveSchemaUrls(PROFILE, doc);
+    if (!Array.isArray(o)) return softSkip(o.disposition, o.reason);
+    for (const x of o.flatMap(judgeSchemaUrl)) expect(x.ok, req(ID_SERVED, x.doc, x.message)).toBe(true);
+  }, 120_000);
+});

package/src/scenarios/v2-artifact-types-advertisement.test.ts

@@ -0,0 +1,64 @@
+/**
+ * v2 — the `artifactTypes` advertisement
+ * (`spec/v2/core/artifact-type-packs.md`; RFCs 0071, 0075, 0145). The v1 twin
+ * is the advertisement legs of `artifact-type-registration-source` and
+ * `artifact-type-store-emission`; the legs live in
+ * `lib/family-advert-witness.ts`.
+ *
+ *   record         the record validates against its capabilities-schema seat;
+ *   global         `store` and `render` are booleans, `export` a list of format ids;
+ *   per-type       each `types` entry is closed, with `validation` open | closed,
+ *                  `schemaVersion` ≥ 0 and `registrationSource` pack | host.
+ *
+ * Not here: store-implies-emit and the emitted-vs-advertised `registrationSource`
+ * match need a fixture run; the event shape is `v2-artifact-created-static`.
+ *
+ * Dispositions: discovery unreadable ⇒ `blocked`; `artifactTypes` absent, or the
+ * facet a leg reads absent ⇒ `inapplicable`.
+ *
+ * @see spec/v2/core/artifact-type-packs.md §The capability
+ */
+
+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 { artifactTypesGlobalFacetsLeg, artifactTypesPerTypeLeg, recordSchemaLeg } from '../lib/family-advert-witness.js';
+
+const PROFILE = majorProfile(2);
+const DOC = 'artifact-type-packs.md §The capability';
+const UNREADABLE = 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0';
+const ID_RECORD = 'openwop.requirement.artifact-types.advert-record-schema';
+const ID_GLOBAL_FACETS_SHAPE = 'openwop.requirement.artifact-types.global-facets-shape';
+const ID_PER_TYPE_ENTRY_SHAPE = 'openwop.requirement.artifact-types.per-type-entry-shape';
+
+async function discovery(): Promise<Record<string, unknown> | null> {
+  try { return await v2Discovery(); } catch { return null; }
+}
+
+describe('v2 artifactTypes advertisement (artifact-type-packs.md §The capability)', () => {
+  it('the artifactTypes record validates against its capabilities-schema seat', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    const out = recordSchemaLeg(PROFILE, doc, 'artifactTypes', 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('artifactTypes.store, render and export are well-formed', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    const out = artifactTypesGlobalFacetsLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_GLOBAL_FACETS_SHAPE, x.doc, x.message)).toBe(true);
+  });
+
+  it('every artifactTypes.types entry validates against its seat', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    const out = artifactTypesPerTypeLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_PER_TYPE_ENTRY_SHAPE, x.doc, x.message)).toBe(true);
+  });
+});

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

@@ -0,0 +1,66 @@
+/**
+ * v2 — the `authorization` advertisement (`spec/v2/core/identity.md` §2.1; RFC
+ * 0049; invariant `authorization-fail-closed`). The v1 twin is the
+ * advertisement legs of `authorization-roles-shape` and
+ * `authorization-fail-closed`; the legs live in `lib/family-advert-witness.ts`.
+ *
+ *   record         the record validates against its capabilities-schema seat;
+ *   failClosed     `failClosed` MUST be `true` when present;
+ *   roles          each `roles[]` entry names a non-empty `role` and a unique
+ *                  `scopes[]` of non-empty strings, and nothing else.
+ *
+ * Not here: the unseeded-role decision leg of `authorization-fail-closed` needs
+ * a decision seam with no v2 counterpart.
+ *
+ * Dispositions: discovery unreadable ⇒ `blocked`; `authorization` absent, or the
+ * facet a leg reads absent ⇒ `inapplicable`.
+ *
+ * @see spec/v2/core/identity.md §2.1
+ */
+
+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 { authorizationFailClosedLeg, authorizationRolesLeg, recordSchemaLeg } from '../lib/family-advert-witness.js';
+
+const PROFILE = majorProfile(2);
+const DOC = 'identity.md §2.1';
+const UNREADABLE = 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0';
+const ID_RECORD = 'openwop.requirement.authorization.advert-record-schema';
+const ID_FAIL_CLOSED_TRUE = 'openwop.requirement.authorization.fail-closed-true';
+const ID_ROLES_SHAPE = 'openwop.requirement.authorization.roles-shape';
+
+async function discovery(): Promise<Record<string, unknown> | null> {
+  try { return await v2Discovery(); } catch { return null; }
+}
+
+describe('v2 authorization advertisement (identity.md §2.1)', () => {
+  it('the authorization record validates against its capabilities-schema seat', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('authorization'))) return softSkip('inapplicable', 'the host does not advertise authorization');
+    const out = recordSchemaLeg(PROFILE, doc, 'authorization', 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('authorization.failClosed is true when present', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('authorization'))) return softSkip('inapplicable', 'the host does not advertise authorization');
+    const out = authorizationFailClosedLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_FAIL_CLOSED_TRUE, x.doc, x.message)).toBe(true);
+  });
+
+  it('every authorization.roles entry has a non-empty role and a scopes list', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('authorization'))) return softSkip('inapplicable', 'the host does not advertise authorization');
+    const out = authorizationRolesLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_ROLES_SHAPE, x.doc, x.message)).toBe(true);
+  });
+});

package/src/scenarios/v2-channel-presence-advertisement.test.ts

@@ -0,0 +1,41 @@
+/**
+ * v2 — the `channelPresence` advertisement (`spec/v2/core/conversation.md` §`channelPresence`): the channel presence claim. The v1 twin is
+ * `channel-presence-shape`;
+ * the legs live in `lib/family-advert-witness.ts` (witness wave 3).
+ *
+ *   record         the record validates against its capabilities-schema seat;
+ *
+ * Not here: presence delivery needs a channel conversation the suite can create, and the non-persistence rule lives only in a schema description (TODO §8).
+ *
+ * Dispositions: discovery unreadable ⇒ `blocked`; `channelPresence` absent, or the
+ * facet a leg reads absent ⇒ `inapplicable`.
+ *
+ * @see spec/v2/core/conversation.md §`channelPresence`
+ */
+
+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 = 'conversation.md §channelPresence';
+const UNREADABLE = 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0';
+const ID_RECORD = 'openwop.requirement.channel-presence.advert-record-schema';
+
+async function discovery(): Promise<Record<string, unknown> | null> {
+  try { return await v2Discovery(); } catch { return null; }
+}
+
+describe('v2 channelPresence advertisement (conversation.md §channelPresence)', () => {
+  it('the channelPresence record validates against its capabilities-schema seat', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('channelPresence'))) return softSkip('inapplicable', 'the host does not advertise channelPresence');
+    const out = recordSchemaLeg(PROFILE, doc, 'channelPresence', 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-conversation-turn-model-provenance-advertisement.test.ts

@@ -0,0 +1,41 @@
+/**
+ * v2 — the `conversationTurnModelProvenance` advertisement (`spec/v2/core/conversation.md` §`conversationTurnModelProvenance`): the claim that a host stamps `agent.model` on agent turns. The v1 twin is
+ * `conversation-turn-model-provenance-shape`;
+ * the legs live in `lib/family-advert-witness.ts` (witness wave 3).
+ *
+ *   record         the record validates against its capabilities-schema seat;
+ *
+ * Not here: the stamp itself (only `provider` and `model`, read verbatim on fork) needs a conversation run; the record carries no facet a v2 rule gives meaning to.
+ *
+ * Dispositions: discovery unreadable ⇒ `blocked`; `conversationTurnModelProvenance` absent, or the
+ * facet a leg reads absent ⇒ `inapplicable`.
+ *
+ * @see spec/v2/core/conversation.md §`conversationTurnModelProvenance`
+ */
+
+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 = 'conversation.md §conversationTurnModelProvenance';
+const UNREADABLE = 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0';
+const ID_RECORD = 'openwop.requirement.conversation-turn-model-provenance.advert-record-schema';
+
+async function discovery(): Promise<Record<string, unknown> | null> {
+  try { return await v2Discovery(); } catch { return null; }
+}
+
+describe('v2 conversationTurnModelProvenance advertisement (conversation.md §conversationTurnModelProvenance)', () => {
+  it('the conversationTurnModelProvenance record validates against its capabilities-schema seat', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('conversationTurnModelProvenance'))) return softSkip('inapplicable', 'the host does not advertise conversationTurnModelProvenance');
+    const out = recordSchemaLeg(PROFILE, doc, 'conversationTurnModelProvenance', 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-conversation-turn-model-provenance.test.ts

@@ -0,0 +1,110 @@
+/**
+ * v2 — `conversationTurnModelProvenance`, the emission legs
+ * (`spec/v2/core/conversation.md` §`conversationTurnModelProvenance`). The v1
+ * twin is `conversation-turn-model-provenance-shape`; the advertisement record
+ * leg is `v2-conversation-turn-model-provenance-advertisement`.
+ *
+ *   stamp-requires-advert  a host that stamps `agent.model` on an agent turn
+ *                          MUST advertise `conversationTurnModelProvenance`;
+ *   stamp-closed           the stamp carries provider and model identifiers
+ *                          only, so no prompt or completion content can ride
+ *                          in it (closed at `conversation-turn.schema.json`).
+ *
+ * Both legs read the turns of one `conformance-conversation-lifecycle` run,
+ * the fixture `v2-conversation-turn-parts` drives. A host whose turns carry no
+ * stamp records both legs `inapplicable`: the rule binds a host that stamps,
+ * and the suite cannot make it stamp.
+ *
+ * Gates, decided before any assertion: discovery unreadable ⇒ `blocked`;
+ * `conversationPrimitive` or the fixture not advertised ⇒ `inapplicable`; the
+ * fixture run not completing, or completing with no turn ⇒ `blocked` (the
+ * fixture's own contract is one exchange).
+ *
+ * @see spec/v2/core/conversation.md §`conversationTurnModelProvenance`
+ * @see schemas/v2/conversation-turn.schema.json
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { familyAdvertised, v2Discovery, v2RefValidator } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+type Json = Record<string, unknown>;
+const FIXTURE = 'conformance-conversation-lifecycle';
+const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
+const DOC = 'conversation.md §conversationTurnModelProvenance';
+const ID_ADVERT = 'openwop.requirement.conversation-turn-model-provenance.stamp-requires-advert';
+const ID_CLOSED = 'openwop.requirement.conversation-turn-model-provenance.stamp-closed';
+
+type Turns = { kind: 'turns'; turns: Json[] } | { kind: 'skip'; disposition: 'blocked' | 'inapplicable'; reason: string };
+let cached: Promise<Turns> | undefined;
+
+async function waitTerminal(runId: string, timeoutMs: number): Promise<string | null> {
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    const res = await driver.get(`/runs/${encodeURIComponent(runId)}`);
+    const status = res.status === 200 ? String((res.json as { status?: unknown } | null)?.status ?? '') : null;
+    if (status !== null && TERMINAL.has(status)) return status;
+    if (Date.now() > deadline) return status;
+    await new Promise((r) => setTimeout(r, 200));
+  }
+}
+
+/** One fixture run per file: both legs read the same turns. */
+function fixtureTurns(): Promise<Turns> {
+  cached ??= (async (): Promise<Turns> => {
+    let doc: Json | null;
+    try { doc = await v2Discovery(); } catch { doc = null; }
+    if (!doc) return { kind: 'skip', disposition: 'blocked', reason: 'v2 discovery unreachable' };
+    if (!(await familyAdvertised('conversationPrimitive'))) return { kind: 'skip', disposition: 'inapplicable', reason: 'host does not advertise conversationPrimitive' };
+    const fixtures = Array.isArray(doc['fixtures']) ? (doc['fixtures'] as unknown[]) : [];
+    if (!fixtures.includes(FIXTURE)) return { kind: 'skip', disposition: 'inapplicable', reason: `host does not advertise the ${FIXTURE} fixture` };
+    const create = await driver.post('/runs', { workflowId: FIXTURE });
+    if (create.status !== 201) return { kind: 'skip', disposition: 'blocked', reason: `POST /runs {workflowId: ${FIXTURE}} answered ${create.status}` };
+    const runId = String((create.json as { runId?: unknown } | null)?.runId ?? '');
+    const status = await waitTerminal(runId, 20_000);
+    if (status !== 'completed') return { kind: 'skip', disposition: 'blocked', reason: `${FIXTURE} did not complete (status ${status})` };
+    const poll = await driver.get(`/runs/${encodeURIComponent(runId)}/events/poll?timeout=1`);
+    const events = ((poll.json as { events?: unknown } | null)?.events ?? []) as Json[];
+    const turns = (Array.isArray(events) ? events : [])
+      .filter((e) => e['type'] === 'conversation.exchanged')
+      .map((e) => ((e['payload'] ?? {}) as Json)['turn'])
+      .filter((t): t is Json => t !== null && typeof t === 'object' && !Array.isArray(t));
+    if (turns.length === 0) return { kind: 'skip', disposition: 'blocked', reason: `${FIXTURE} completed without a conversation.exchanged event carrying a turn` };
+    return { kind: 'turns', turns };
+  })();
+  return cached;
+}
+
+/** The `agent.model` stamps the run's turns carry. */
+function stamps(turns: Json[]): { messageId: string; model: unknown }[] {
+  return turns.flatMap((t) => {
+    const agent = t['agent'];
+    if (agent === null || typeof agent !== 'object' || Array.isArray(agent) || !('model' in agent)) return [];
+    return [{ messageId: String(t['messageId']), model: (agent as Json)['model'] }];
+  });
+}
+
+describe('v2 conversationTurnModelProvenance emission (conversation.md §conversationTurnModelProvenance)', () => {
+  it('a host that stamps agent.model on a turn advertises conversationTurnModelProvenance', async () => {
+    const out = await fixtureTurns();
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    const stamped = stamps(out.turns);
+    if (stamped.length === 0) return softSkip('inapplicable', 'no emitted turn carries an agent.model stamp');
+    const advertised = (await familyAdvertised('conversationTurnModelProvenance')) !== null;
+    expect(advertised, req(ID_ADVERT, DOC, `${stamped.length} turn(s) carry agent.model (first: ${stamped[0]?.messageId}); a host that stamps MUST advertise conversationTurnModelProvenance`)).toBe(true);
+  });
+
+  it('every agent.model stamp carries provider and model identifiers only', async () => {
+    const out = await fixtureTurns();
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    const stamped = stamps(out.turns);
+    if (stamped.length === 0) return softSkip('inapplicable', 'no emitted turn carries an agent.model stamp');
+    const validate = v2RefValidator('conversation-turn.schema.json#/properties/agent/properties/model');
+    for (const s of stamped) {
+      const r = validate(s.model);
+      expect(r.ok, req(ID_CLOSED, DOC, `turn ${s.messageId}: agent.model MUST validate against schemas/v2/conversation-turn.schema.json (provider and model only): ${r.errors}`)).toBe(true);
+    }
+  });
+});