@openwop/openwop-conformance 2.45.15 → 2.45.16

package/src/lib/subworkflow-witness.ts

@@ -0,0 +1,192 @@
+/**
+ * The `core.subWorkflow` witness (`execution.md` §`subWorkflow`), a fixture
+ * port through `POST /runs` and `events/poll`. No seam.
+ *
+ * Linkage, on `conformance-subworkflow-parent` → `conformance-subworkflow-child`:
+ *   output         the parent's `node.completed` for `subwf-call` carries
+ *                  `outputs.childRunId` and `outputs.childStatus`
+ *                  (`completed | failed | cancelled`), and the status names the
+ *                  child's real terminal status;
+ *   outputMapping  after the child completes, the mapped variable is copied
+ *                  into the parent (`childOutcome` ← child `childResult`);
+ *   ancestry       where `getRunAncestry` is served (advertised by
+ *                  `multiAgent.executionModel.crossHostCausation.ancestryEndpointSupported`),
+ *                  the child's `parent` is the parent run with
+ *                  `cause: "core.subWorkflow"`.
+ * The v1 `parentRunId`/`parentNodeId` child-linkage leg is RETIRED at v2
+ * (`spec/v1/migrations.json` C4.18): `parentRunId` is fork lineage, not this link.
+ *
+ * Input mapping, on `conformance-subworkflow-input-mapping[-no-default]` →
+ * `conformance-subworkflow-input-mapping-child` (child default `receivedPrdId: "baked-in"`):
+ *   seed      the child's variable bag is seeded: `receivedPrdId` is present;
+ *   override  the mapping lands after and over the default: `"prd-1"`;
+ *   unset     an unset parent variable arrives undefined, never an error or
+ *             `null` (the run completes; the child's value is absent or its
+ *             own default).
+ *
+ * The drivers observe and assert nothing; the judges are pure, proven in
+ * `subworkflow-witness.test.ts`.
+ */
+
+import { driver } from './driver.js';
+import { isFixtureAdvertised } from './fixtures.js';
+import type { MajorProfile } from './major-profile.js';
+import {
+  completionsOf, finding, isRecord, observed, observeRun, readRun, runCompleted, skip,
+  type Finding, type ObservedRun, type ObserveOpts, type Outcome, type RunRead, type Skip, type Validate,
+} from './fixture-run-observer.js';
+
+export const PARENT_FIXTURE = 'conformance-subworkflow-parent';
+export const CHILD_FIXTURE = 'conformance-subworkflow-child';
+export const IM_PARENT_FIXTURE = 'conformance-subworkflow-input-mapping';
+export const IM_NO_DEFAULT_FIXTURE = 'conformance-subworkflow-input-mapping-no-default';
+export const IM_CHILD_FIXTURE = 'conformance-subworkflow-input-mapping-child';
+export const SUBWF_NODE = 'subwf-call';
+
+const DOC = 'execution.md §subWorkflow';
+const CHILD_STATUSES = new Set(['completed', 'failed', 'cancelled']);
+
+/** The child a `core.subWorkflow` node started, as its `node.completed` names it. */
+export interface ChildLink {
+  readonly outputs: Record<string, unknown> | undefined;
+  readonly childRunId: string | undefined;
+  readonly child: RunRead | undefined;
+}
+
+export interface LinkageObservation extends ChildLink {
+  readonly parent: ObservedRun;
+  /** `undefined`: the host does not advertise `getRunAncestry`, so the leg does not bind. */
+  readonly ancestry: { readonly status: number; readonly json: unknown } | undefined;
+}
+export interface MappingObservation extends ChildLink { readonly parent: ObservedRun }
+
+/** Whether the host advertises `getRunAncestry` (`runs.md` §Surface gate). */
+export function ancestryAdvertised(profile: MajorProfile, doc: unknown): boolean {
+  const ma = profile.family(doc, 'multiAgent');
+  const em = isRecord(ma?.['executionModel']) ? ma['executionModel'] : undefined;
+  const chc = isRecord(em?.['crossHostCausation']) ? em['crossHostCausation'] : undefined;
+  return chc?.['ancestryEndpointSupported'] === true;
+}
+
+function fixturesGate(...ids: string[]): Skip | null {
+  for (const id of ids) if (!isFixtureAdvertised(id)) return skip('inapplicable', `fixture ${id} is not advertised — the fixture is the opt-in`);
+  return null;
+}
+
+async function followChild(profile: MajorProfile, parent: ObservedRun): Promise<ChildLink> {
+  const done = completionsOf(parent.events, SUBWF_NODE)[0];
+  const outputs = isRecord(done?.payload['outputs']) ? done.payload['outputs'] : undefined;
+  const childRunId = typeof outputs?.['childRunId'] === 'string' && outputs['childRunId'].length > 0 ? outputs['childRunId'] : undefined;
+  return { outputs, childRunId, child: childRunId === undefined ? undefined : await readRun(profile, childRunId) };
+}
+
+/** Run the linkage fixture and follow it to the child. Asserts nothing. */
+export async function driveLinkage(profile: MajorProfile, doc: unknown, opts: ObserveOpts = {}): Promise<Skip | LinkageObservation> {
+  const g = fixturesGate(PARENT_FIXTURE, CHILD_FIXTURE);
+  if (g) return g;
+  const parent = await observeRun(profile, PARENT_FIXTURE, opts);
+  const link = await followChild(profile, parent);
+  let ancestry: LinkageObservation['ancestry'];
+  if (ancestryAdvertised(profile, doc) && link.childRunId !== undefined) {
+    const r = await driver.get(`${profile.runsPath}/${profile.idSegment(link.childRunId)}/ancestry`);
+    ancestry = { status: r.status, json: r.json };
+  }
+  return { parent, ...link, ancestry };
+}
+
+/** Run an input-mapping fixture and follow it to the child. Asserts nothing. */
+export async function driveInputMapping(profile: MajorProfile, fixture: string, opts: ObserveOpts = {}): Promise<Skip | MappingObservation> {
+  const g = fixturesGate(fixture, IM_CHILD_FIXTURE);
+  if (g) return g;
+  const parent = await observeRun(profile, fixture, opts);
+  return { parent, ...(await followChild(profile, parent)) };
+}
+
+/** Leg: `node.completed` carries `outputs.childRunId` and `outputs.childStatus`. Pure. */
+export function judgeOutput(o: LinkageObservation): Outcome {
+  const out: Finding[] = runCompleted(o.parent);
+  const status = o.outputs?.['childStatus'];
+  const childStatus = o.child?.snapshot['status'];
+  out.push(
+    finding(completionsOf(o.parent.events, SUBWF_NODE).length > 0, `${DOC} (Output)`, `the parent log MUST carry node.completed for the core.subWorkflow node ${SUBWF_NODE}`),
+    finding(o.childRunId !== undefined, `${DOC} (Output)`, `node.completed MUST carry outputs.childRunId (got ${JSON.stringify(o.outputs?.['childRunId'])})`),
+    finding(typeof status === 'string' && CHILD_STATUSES.has(status), `${DOC} (Output)`, `node.completed MUST carry outputs.childStatus, one of completed | failed | cancelled (got ${JSON.stringify(status)})`),
+  );
+  if (o.child !== undefined) {
+    out.push(
+      finding(o.child.status === 200, `${DOC} (Output)`, `outputs.childRunId MUST name a readable run (GET answered ${o.child.status})`),
+      finding(o.child.status !== 200 || status === childStatus, `${DOC} (Output)`, `outputs.childStatus MUST be the child's terminal status (got ${JSON.stringify(status)}, child is ${JSON.stringify(childStatus)})`),
+    );
+  }
+  return observed(out);
+}
+
+/** Leg: the mapped child variable is copied into the parent. Pure. */
+export function judgeOutputMapping(o: LinkageObservation): Outcome {
+  const vars = isRecord(o.parent.snapshot['variables']) ? o.parent.snapshot['variables'] : {};
+  return observed([
+    ...runCompleted(o.parent),
+    finding(vars['childOutcome'] === 'child-completed', `${DOC} (outputMapping)`, `after the child completes, the host MUST copy childResult into the parent's childOutcome ("child-completed"; got ${JSON.stringify(vars['childOutcome'])})`),
+  ]);
+}
+
+/** Leg: the child's ancestry names the parent with `cause: "core.subWorkflow"`. Pure. */
+export function judgeAncestry(o: LinkageObservation, validate: Validate): Outcome {
+  if (o.childRunId === undefined) return skip('blocked', 'the child run id is unobserved (node.completed carried no outputs.childRunId — the output leg convicts that), so its ancestry cannot be read');
+  if (o.ancestry === undefined) return skip('inapplicable', 'the host does not advertise multiAgent.executionModel.crossHostCausation.ancestryEndpointSupported, so getRunAncestry is not served');
+  const body = o.ancestry.json;
+  const parent = isRecord(body) && isRecord(body['parent']) ? body['parent'] : undefined;
+  const v = validate(body);
+  return observed([
+    finding(o.ancestry.status === 200, `${DOC} (Parent link); runs.md §Diff and ancestry`, `getRunAncestry of the child MUST answer 200 (got ${o.ancestry.status})`),
+    finding(v.ok, 'schemas run-ancestry-response', `the ancestry body MUST validate: ${v.errors}`),
+    finding(parent !== undefined && parent['runId'] === o.parent.runId, `${DOC} (Parent link)`, `the child's parent MUST be the parent run ${String(o.parent.runId)} (got ${JSON.stringify(parent?.['runId'] ?? (isRecord(body) ? body['parent'] : undefined))})`),
+    finding(parent?.['cause'] === 'core.subWorkflow', `${DOC} (Parent link)`, `the child's parent.cause MUST be core.subWorkflow (got ${JSON.stringify(parent?.['cause'])})`),
+  ]);
+}
+
+const childVars = (o: MappingObservation): Record<string, unknown> | undefined =>
+  o.child !== undefined && o.child.status === 200 ? (isRecord(o.child.snapshot['variables']) ? o.child.snapshot['variables'] : {}) : undefined;
+
+function childReached(o: MappingObservation): Finding[] {
+  return [
+    ...runCompleted(o.parent),
+    finding(o.childRunId !== undefined, `${DOC} (Output)`, `the parent's node.completed for ${SUBWF_NODE} MUST carry outputs.childRunId`),
+    finding(o.child?.status === 200, `${DOC} (Output)`, `outputs.childRunId MUST name a readable run (GET answered ${String(o.child?.status)})`),
+    finding(o.child?.snapshot['status'] === 'completed', `fixtures.md ${IM_CHILD_FIXTURE}`, `the child run MUST end completed (got ${JSON.stringify(o.child?.snapshot['status'])})`),
+  ];
+}
+
+/** Leg: the child's variable bag is seeded at creation — `receivedPrdId` is present. Pure. */
+export function judgeSeed(o: MappingObservation): Outcome {
+  const v = childVars(o)?.['receivedPrdId'];
+  return observed([
+    ...childReached(o),
+    finding(v !== undefined && v !== null, `${DOC} (inputMapping: defaultValue MUST seed first)`, `the child's receivedPrdId MUST be seeded at creation (got ${JSON.stringify(v)})`),
+  ]);
+}
+
+/** Leg: the mapping lands after and over the child's default. Pure. */
+export function judgeOverride(o: MappingObservation): Outcome {
+  const vars = childVars(o);
+  if (vars === undefined) return skip('blocked', 'the child run is unread (no outputs.childRunId, or GET failed — the seed leg convicts that)');
+  const v = vars['receivedPrdId'];
+  return observed([
+    finding(v !== 'baked-in', `${DOC} (inputMapping: after and over defaultValue)`, 'the child\'s defaultValue "baked-in" MUST NOT win over the mapped parent value'),
+    finding(v === 'prd-1', `${DOC} (inputMapping)`, `the child's receivedPrdId MUST be the parent's currentPrdId projection "prd-1" (got ${JSON.stringify(v)})`),
+  ]);
+}
+
+/** Leg: an unset parent variable arrives undefined — no error, no `null`. Pure. */
+export function judgeUnset(o: MappingObservation): Outcome {
+  const vars = childVars(o);
+  const out = childReached(o);
+  if (vars !== undefined) {
+    const v = vars['receivedPrdId'];
+    out.push(
+      finding(v !== null, `${DOC} (inputMapping: never null)`, 'an unset parent variable MUST NOT arrive as null'),
+      finding(!('receivedPrdId' in vars) || v === 'baked-in', `${DOC} (inputMapping: arrives undefined)`, `an unset parent variable MUST arrive undefined: the child's value is absent or its own default (got ${JSON.stringify(v)})`),
+    );
+  }
+  return observed(out);
+}

package/src/scenarios/v2-agent-runtime-advertisement.test.ts

@@ -0,0 +1,51 @@
+/**
+ * v2 — the `agentRuntime` advertisement (`spec/v2/core/host-services.md` §`agentRuntime`): the agent runtime 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;
+ *   implies-manifest-runtime advertising agentRuntime also advertises agents.manifestRuntime;
+ *
+ * Not here: the `ctx` surface (`spawn`, `delegate`, `consensus`, `messageSend`) cannot be observed from outside a node.
+ *
+ * Dispositions: discovery unreadable ⇒ `blocked`; `agentRuntime` absent, or the
+ * facet a leg reads absent ⇒ `inapplicable`.
+ *
+ * @see spec/v2/core/host-services.md §`agentRuntime`
+ */
+
+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 { agentRuntimeImpliesManifestRuntimeLeg, recordSchemaLeg } from '../lib/family-advert-witness.js';
+
+const PROFILE = majorProfile(2);
+const DOC = 'host-services.md §agentRuntime';
+const UNREADABLE = 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0';
+const ID_RECORD = 'openwop.requirement.agent-runtime.advert-record-schema';
+const ID_IMPLIES_MANIFEST_RUNTIME = 'openwop.requirement.agent-runtime.implies-manifest-runtime';
+
+async function discovery(): Promise<Record<string, unknown> | null> {
+  try { return await v2Discovery(); } catch { return null; }
+}
+
+describe('v2 agentRuntime advertisement (host-services.md §agentRuntime)', () => {
+  it('the agentRuntime record validates against its capabilities-schema seat', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('agentRuntime'))) return softSkip('inapplicable', 'the host does not advertise agentRuntime');
+    const out = recordSchemaLeg(PROFILE, doc, 'agentRuntime', 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('advertising agentRuntime also advertises agents.manifestRuntime', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('agentRuntime'))) return softSkip('inapplicable', 'the host does not advertise agentRuntime');
+    const out = agentRuntimeImpliesManifestRuntimeLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_IMPLIES_MANIFEST_RUNTIME, x.doc, x.message)).toBe(true);
+  });
+});

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

@@ -0,0 +1,43 @@
+/**
+ * v2 — the `aiEnvelope` advertisement (`spec/v2/core/host-services.md`
+ * §aiEnvelope; RFC 0144). The v1 twin is the record shape `aiEnvelope` carried
+ * at v1; the legs live in `lib/family-advert-witness.ts`.
+ *
+ *   record         the record (with its optional `await` boolean) validates against
+ *                  its capabilities-schema seat.
+ *
+ * Not here: exposing `ctx.aiEnvelope.generate` / `await` to pack code is a
+ * pack-runtime surface with no wire witness.
+ *
+ * Dispositions: discovery unreadable ⇒ `blocked`; `aiEnvelope` absent, or the
+ * facet a leg reads absent ⇒ `inapplicable`.
+ *
+ * @see spec/v2/core/host-services.md §aiEnvelope
+ */
+
+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 §aiEnvelope';
+const UNREADABLE = 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0';
+const ID_RECORD = 'openwop.requirement.ai-envelope.advert-record-schema';
+
+async function discovery(): Promise<Record<string, unknown> | null> {
+  try { return await v2Discovery(); } catch { return null; }
+}
+
+describe('v2 aiEnvelope advertisement (host-services.md §aiEnvelope)', () => {
+  it('the aiEnvelope record validates against its capabilities-schema seat', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('aiEnvelope'))) return softSkip('inapplicable', 'the host does not advertise aiEnvelope');
+    const out = recordSchemaLeg(PROFILE, doc, 'aiEnvelope', 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-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);
+  });
+});