@openwop/openwop-conformance 2.35.0 → 2.36.0

package/src/scenarios/interrupt-approver-routing.test.ts

@@ -95,6 +95,9 @@ describe('interrupt-approver-routing: ApprovalData additive optionality (interru
   const ajv = new Ajv2020({ strict: false, allErrors: true });
   addFormats(ajv);
   const suspend = loadSchema('suspend-request.schema.json');
+  // RFC 0199 added CredentialData, whose `credentialRef` $refs credential-reference.schema.json;
+  // a standalone compile has to register it or the whole document fails to resolve.
+  ajv.addSchema(loadSchema('credential-reference.schema.json'));
   const validate = ajv.compile(suspend);
 
   const baseApproval = {

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

@@ -10,7 +10,7 @@
  *   A. Always-on, server-free legs — the `content` capability block, the four
  *      content schemas (section / page / language-settings / page-response),
  *      the §A capability-coherence constraints, and the §C per-section field
- *      merge reference algorithm (`resolveSection`, exact → family → base,
+ *      merge reference algorithm (`resolveSection`, exact → script family → language family → base (RFC 0206),
  *      shallow overlay) shared verbatim with hosts.
  *
  *   B. Capability-gated behavioral legs — on a host advertising
@@ -35,6 +35,7 @@ import { SCHEMAS_DIR } from '../lib/paths.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
 import { req } from '../lib/requirement-ids.js';
+import { resolveSection, resolveSectionRfc0103, type Section } from '../lib/localized-content.js';
 function loadSchema(name: string): Record<string, unknown> {
   return JSON.parse(readFileSync(join(SCHEMAS_DIR, name), 'utf8')) as Record<string, unknown>;
 }
@@ -53,20 +54,8 @@ interface I18nCap {
 const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
 
 // ── §C reference merge — shared verbatim with conforming hosts ──────────────
-type Section = {
-  data: Record<string, unknown>;
-  localizations: Record<string, Record<string, unknown>>;
-};
-function resolveSection(section: Section, negotiatedLocale: string, baseLocale: string): Record<string, unknown> {
-  const loc = section.localizations ?? {};
-  if (negotiatedLocale === baseLocale || Object.keys(loc).length === 0) return section.data;
-  if (loc[negotiatedLocale]) return { ...section.data, ...loc[negotiatedLocale] };
-  if (negotiatedLocale.includes('-')) {
-    const lang = negotiatedLocale.split('-')[0];
-    if (loc[lang]) return { ...section.data, ...loc[lang] };
-  }
-  return section.data;
-}
+// One copy in src/lib (RFC 0206 register G5), amended by RFC 0206 §B.4; the
+// corpus rows for it live in src/coherence/locale-key-grammar.test.ts.
 
 // ── §A capability-coherence predicate ──────────────────────────────────────
 function contentCoherent(content: ContentCap, i18n: I18nCap): boolean {
@@ -123,6 +112,18 @@ describe('localized-content: schema shapes (localized-content.md §B, server-fre
     expect(section({ ...goodSection, localizations: { EN: { heading: 'x' } } }), req('openwop.it.localized-content-delivery.a-localizations-key-with-wrong-case-underscore-is-rejected', 'RFC 0103 §B', 'a non-BCP-47-subset key MUST be rejected')).toBe(false);
     expect(section({ ...goodSection, localizations: { en_US: { heading: 'x' } } }), req('openwop.it.localized-content-delivery.a-localizations-key-with-wrong-case-underscore-is-rejected', 'RFC 0103 §B', 'an underscore locale key MUST be rejected')).toBe(false);
   });
+  // RFC 0206 §A (supplementary, non-gating here: the gating rows are the corpus
+  // coherence test locale-key-grammar.test.ts).
+  it('case-canonical BCP 47 keys outside the RFC 0103 subset validate (RFC 0206)', () => {
+    for (const key of ['zh-Hans', 'zh-Hant-TW', 'es-419', 'fil']) {
+      expect(section({ ...goodSection, localizations: { [key]: { heading: 'x' } } }), req('openwop.it.localized-content-delivery.case-canonical-bcp-47-keys-outside-the-rfc-0103-subset-validate-rfc-0206', 'RFC 0206 §A.1', `"${key}" MUST validate as a localizations key. Errors: ${JSON.stringify(section.errors)}`)).toBe(true);
+    }
+  });
+  it('non-canonical-case and out-of-subset keys are rejected (RFC 0206)', () => {
+    for (const key of ['en-us', 'zh-hans', 'de-CH-1996']) {
+      expect(section({ ...goodSection, localizations: { [key]: { heading: 'x' } } }), req('openwop.it.localized-content-delivery.non-canonical-case-and-out-of-subset-keys-are-rejected-rfc-0206', 'RFC 0206 §A.1', `"${key}" MUST be rejected as a localizations key`)).toBe(false);
+    }
+  });
   it('a section missing a required field is rejected', () => {
     const { status: _omit, ...noStatus } = goodSection;
     expect(section(noStatus), req('openwop.it.localized-content-delivery.a-section-missing-a-required-field-is-rejected', 'RFC 0103 §B', 'status is REQUIRED')).toBe(false);
@@ -177,6 +178,16 @@ describe('localized-content: per-section field merge (localized-content.md §C,
     const s: Section = { data: { h: 'Hi' }, localizations: { pt: { h: 'Oi' } } };
     expect(resolveSection(s, 'pt-BR', 'en'), req('openwop.it.localized-content-delivery.language-family-fallback-applies-when-exact-tag-is-absent', 'RFC 0103 §C', 'pt-BR MUST fall back to the pt family override')).toEqual({ h: 'Oi' });
   });
+  it('script-family fallback applies before the language family (RFC 0206)', () => {
+    const s: Section = { data: { h: 'x' }, localizations: { 'zh-Hant': { h: '繁' }, zh: { h: '简' } } };
+    expect(resolveSection(s, 'zh-Hant-TW', 'en'), req('openwop.it.localized-content-delivery.script-family-fallback-applies-before-the-language-family-rfc-0206', 'RFC 0206 §B.4', 'zh-Hant-TW MUST overlay zh-Hant before zh')).toEqual({ h: '繁' });
+  });
+  it('an RFC 0103-valid section resolves as RFC 0103 resolved it (RFC 0206)', () => {
+    const s: Section = { data: { h: 'x' }, localizations: { 'de-CH': { h: 'ch' }, de: { h: 'de' } } };
+    for (const n of ['de-CH-1996', 'de-CH', 'de-AT', 'en']) {
+      expect(resolveSection(s, n, 'en'), req('openwop.it.localized-content-delivery.an-rfc-0103-valid-section-resolves-as-rfc-0103-resolved-it-rfc-0206', 'RFC 0206 §B.5', `${n}: the amended merge MUST equal RFC 0103's`)).toEqual(resolveSectionRfc0103(s, n, 'en'));
+    }
+  });
   it('unsupported/base locale returns base data unchanged', () => {
     expect(resolveSection(section, 'de', 'en'), req('openwop.it.localized-content-delivery.unsupported-base-locale-returns-base-data-unchanged', 'RFC 0103 §C', 'no match MUST return base data')).toEqual(section.data);
     expect(resolveSection(section, 'en', 'en'), req('openwop.it.localized-content-delivery.unsupported-base-locale-returns-base-data-unchanged', 'RFC 0103 §C', 'base locale MUST return base data')).toEqual(section.data);

package/src/scenarios/mcp-current-auth-boundary.test.ts

@@ -20,6 +20,7 @@ import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { seamAbsent, softSkip } from '../lib/soft-skip.js';
 import { mcpServerMount } from '../lib/mcp-mount.js';
+import { parseChallenge, prmUrlFor } from '../lib/protected-resource.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 import { req } from '../lib/requirement-ids.js';
@@ -81,4 +82,41 @@ describe.skipIf(!process.env.OPENWOP_BASE_URL)('RFC 0153 §E — mcp-current-aut
       req('openwop.it.mcp-current-auth-boundary.an-unauthenticated-current-profile-request-is-refused-unless-anonymousactor-is-a', 'mcp-integration.md §E', 'a caller holding only a host-minted anonymous session cookie is still an anonymous principal — refuse (401/403) unless anonymousActor is advertised (S30)'),
     ).toContain(withSession.status);
   });
+
+  /**
+   * RFC 0200 §A.4 — the mount as its own OAuth protected resource. Upstream makes this a
+   * MUST for an MCP server whose mount requires OAuth ("MCP servers MUST implement one of
+   * the following discovery mechanisms"), and `mcp-integration.md` §E now carries it.
+   *
+   * NON-GATING coverage: this file is major-1 only, and `check-accepted-predicate` rule 4
+   * reads only certified v2 bundles, so a verdict recorded here can never satisfy the
+   * RFC's row. The gating witness is the mount leg of `v2-protected-resource-metadata`,
+   * against the v2 mount. This leg exists so a v1 host that DOES require an OAuth lane on
+   * its mount is measured today.
+   */
+  it('a mount that requires OAuth-lane authentication offers resource_metadata or a path-inserted PRM', async () => {
+    const { mcp, anon } = await disco();
+    const claims = mcp?.supported === true && (mcp.profiles ?? []).includes(PROFILE) && mcp.serverMount?.supported === true;
+    if (!behaviorGate(PROFILE, claims)) return;
+    if (anon?.supported === true) return softSkip('inapplicable', 'anonymousActor is advertised — the mount does not require authentication at all, so §A.4 does not bind it');
+    const mount = await mcpServerMount();
+    const anonymous = await driver.post(mount, REQ, { headers: HDR, authenticated: false });
+    if (anonymous.status !== 401) return softSkip('inapplicable', `the mount answered ${anonymous.status} without credentials, not 401 — §A.4 binds a mount that refuses for want of an OAuth-lane credential`);
+    const challenge = parseChallenge(anonymous.headers.get('www-authenticate'));
+    const viaChallenge = challenge !== null && challenge.scheme === 'bearer' && typeof challenge.params['resource_metadata'] === 'string';
+    let viaWellKnown = false;
+    if (!viaChallenge) {
+      const doc = await driver.get(prmUrlFor(mount.startsWith('http') ? mount : `${process.env['OPENWOP_BASE_URL'] ?? ''}${mount}`), { authenticated: false });
+      viaWellKnown = doc.status === 200 && typeof (doc.json as { resource?: unknown } | null)?.resource === 'string';
+    }
+    if (!viaChallenge && !viaWellKnown) {
+      // A mount that refuses an api-key caller for want of an api-key is not an OAuth
+      // protected resource, and this host's lanes are not readable from here at major 1.
+      return softSkip('inapplicable', 'the mount offers neither discovery mechanism and this host advertises no v1 OAuth/OIDC auth profile reachable from here — §A.4 binds only a mount that requires OAuth-lane authentication');
+    }
+    expect(
+      viaChallenge || viaWellKnown,
+      req('openwop.it.mcp-current-auth-boundary.a-mount-that-requires-oauth-lane-authentication-offers-resource-metadata-or-a-path-inserted-prm', 'spec/v1/mcp-integration.md §E (RFC 0200 §A.4)', 'a mount requiring OAuth-lane authentication MUST implement one of upstream\'s two discovery mechanisms for the mount URL as the resource'),
+    ).toBe(true);
+  });
 });

package/src/scenarios/mcp-tool-roundtrip.test.ts

@@ -332,3 +332,32 @@ describe('mcp-tool-roundtrip: host-mediated tool invocation', () => {
     )).toBe(true);
   });
 });
+
+/**
+ * RFC 0204 §B — v1 `raw` (a MAY; major 1 only). When the fixture node's output
+ * carries `raw`, it MUST be the server's `CallToolResult` for the negotiated
+ * revision, unaltered, and `isError` MUST equal `raw.isError === true`. Absent
+ * ⇒ `inapplicable`. Non-gating: outside RFC 0204's Acceptance box, and no v2
+ * cut reaches a major-1 file. Sabotage: rebuild `raw` from `result`.
+ */
+describe('mcp-tool-roundtrip: v1 raw CallToolResult (RFC 0204 §B)', () => {
+  it('raw, when present, is the server CallToolResult unaltered and isError agrees', async () => {
+    const server = getMcpFakeServer();
+    if (!server) return softSkip('blocked', '[mcp-tool-roundtrip] fake server not started; the raw leg needs the host-mediated run');
+    if (!isFixtureAdvertised(ROUNDTRIP_FIXTURE)) return softSkip('inapplicable', `fixture ${ROUNDTRIP_FIXTURE} not advertised`);
+    server.reset();
+    const create = await driver.post('/v1/runs', { workflowId: ROUNDTRIP_FIXTURE, inputs: { text: 'raw-probe' } });
+    if (create.status !== 201) return softSkip('blocked', `POST /v1/runs answered ${create.status}`);
+    const runId = (create.json as { runId: string }).runId;
+    await pollUntilTerminal(runId, { timeoutMs: 30_000 });
+    const events = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/events`);
+    const list = (events.json as { events?: Array<{ type: string; payload?: Record<string, unknown> }> }).events ?? [];
+    const done = list.find((e) => e.type === 'node.completed' && e.payload?.['nodeId'] === 'mcp-call');
+    const outputs = (done?.payload?.['outputs'] ?? {}) as { raw?: unknown; isError?: unknown };
+    if (outputs.raw === undefined) return softSkip('inapplicable', 'the node output carries no raw (RFC 0204 §B: a MAY)');
+    const sent = [...server.exchanges()].reverse().find((x) => x.method === 'tools/call');
+    if (!sent) return softSkip('blocked', 'the output carries raw but the suite fake server answered no tools/call in this run');
+    expect(outputs.raw, req('openwop.it.mcp-tool-roundtrip.raw-when-present-is-the-server-calltoolresult-unaltered-and-iserror-agrees', 'host-capabilities.md §host.mcp (RFC 0204 §B)', 'raw MUST be the server\'s CallToolResult unaltered')).toEqual(sent.result);
+    expect(outputs.isError === true, req('openwop.it.mcp-tool-roundtrip.raw-when-present-is-the-server-calltoolresult-unaltered-and-iserror-agrees', 'host-capabilities.md §host.mcp (RFC 0204 §B)', 'isError MUST equal raw.isError === true')).toBe((outputs.raw as { isError?: unknown }).isError === true);
+  });
+});

package/src/scenarios/otel-mcp-semconv-projection.test.ts

@@ -0,0 +1,85 @@
+/**
+ * otel-mcp-semconv-projection — RFC 0207 §D (both majors: `BOTH_MAJORS`).
+ *
+ * `spec/v1/observability.md` §"MCP semantic-convention projection" (v1-carried
+ * normative text at major 2): a host MAY project `openwop.mcp.invocation` onto
+ * the OpenTelemetry MCP conventions (upstream Development stability). A host
+ * that emits ANY `mcp.*` attribute under the projection MUST also emit
+ * `openwop.otel.mcp_mapping_version: "0"` and `openwop.otel.mcp_semconv_ref:
+ * "open-telemetry/semantic-conventions-genai@<commit>"`, MUST NOT emit
+ * `mcp.session.id` for a 2026-07-28 exchange (that revision has no session), and
+ * MUST NOT emit `gen_ai.tool.call.arguments` / `.result` (content).
+ *
+ * Read from the suite's OTLP collector after one MCP-tool fixture run
+ * (`conformance-mcp-client` at major 2, `conformance-mcp-tool-roundtrip` at
+ * major 1). The projection is OPTIONAL, so a host that sends no `mcp.*` span —
+ * or a run with no collector to send it to — records `inapplicable` with that
+ * reason, never a failure and never a pass. Written major-aware: unversioned
+ * run paths through the driver, no capability-record gate.
+ *
+ * Sabotage: a projected span without the version stamp fails; one carrying
+ * `mcp.session.id` on a 2026-07-28 exchange fails; one carrying the tool
+ * arguments fails.
+ *
+ * @see spec/v1/observability.md §"MCP semantic-convention projection"
+ * @see RFCS/0207-trace-context-across-mcp-and-a2a.md §D
+ */
+
+import { describe, it, expect } from 'vitest';
+import { randomUUID } from 'node:crypto';
+import { driver } from '../lib/driver.js';
+import { targetMajor } from '../lib/seams.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { getMcpFakeServer } from '../lib/mcp-fake-server.js';
+import { getCollector, type CapturedSpan } from '../lib/otel-collector.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+export const REQUIRES_HOST_CALLBACK = "the host exports OTLP spans to the suite's collector";
+
+const ID = 'openwop.requirement.0207.mcp-semconv-stamped';
+const DOC = 'observability.md §"MCP semantic-convention projection" (RFC 0207 §D)';
+const SEMCONV_REF = /^open-telemetry\/semantic-conventions-genai@[0-9a-f]{7,40}$/;
+const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+/** One MCP-tool fixture run through the host, so an MCP span has a reason to exist. Best effort. */
+async function driveOneMcpCall(): Promise<void> {
+  if (getMcpFakeServer() === null) return;
+  const v2 = targetMajor() === 2;
+  const fixture = v2 ? 'conformance-mcp-client' : 'conformance-mcp-tool-roundtrip';
+  if (!isFixtureAdvertised(fixture)) return;
+  const inputs = v2 ? { method: 'callTool', serverId: 'conformance', name: 'structured-echo', arguments: { nonce: randomUUID() } } : { text: 'semconv-probe' };
+  const created = await driver.post(v2 ? '/runs' : '/v1/runs', { workflowId: fixture, inputs }).catch(() => null);
+  const runId = (created?.json as { runId?: unknown } | null | undefined)?.runId;
+  if (typeof runId !== 'string') return;
+  const t0 = Date.now();
+  while (Date.now() - t0 < 20_000) {
+    const snap = await driver.get(`${v2 ? '' : '/v1'}/runs/${encodeURIComponent(runId)}`).catch(() => null);
+    if (TERMINAL.has(String((snap?.json as { status?: unknown } | null | undefined)?.status ?? ''))) return;
+    await sleep(200);
+  }
+}
+
+const projected = (s: CapturedSpan): boolean => [...s.attributes.keys()].some((k) => k.startsWith('mcp.'));
+
+describe('otel-mcp-semconv-projection (RFC 0207 §D, both majors)', () => {
+  it('every projected mcp.* span carries the v0 version stamp and no forbidden attribute', async () => {
+    const collector = getCollector();
+    if (collector === null) return softSkip('inapplicable', 'the mcp.* projection is optional and observable only through OTLP export to the suite collector, which is not started in this run (OPENWOP_OTEL_COLLECTOR) — no mcp.* span can arrive');
+    await driveOneMcpCall();
+    await sleep(2_000);
+    const spans = collector.spans().filter(projected);
+    if (spans.length === 0) return softSkip('inapplicable', 'no span carrying an mcp.* attribute reached the suite collector — the host does not project onto the OTel MCP conventions (optional, RFC 0207 §D.12)');
+    for (const s of spans) {
+      const where = `span ${s.name} (${s.spanId})`;
+      expect(s.attributes.get('openwop.otel.mcp_mapping_version'), req(ID, DOC, `${where} carries mcp.* attributes and MUST carry openwop.otel.mcp_mapping_version: "0"`)).toBe('0');
+      const ref = s.attributes.get('openwop.otel.mcp_semconv_ref');
+      expect(typeof ref === 'string' && SEMCONV_REF.test(ref), req(ID, DOC, `${where} MUST carry openwop.otel.mcp_semconv_ref "open-telemetry/semantic-conventions-genai@<commit>" (got ${JSON.stringify(ref ?? null)})`)).toBe(true);
+      if (s.attributes.get('mcp.protocol.version') === '2026-07-28') {
+        expect(s.attributes.has('mcp.session.id'), req(ID, DOC, `${where} is a 2026-07-28 exchange and MUST NOT carry mcp.session.id (that revision is stateless)`)).toBe(false);
+      }
+      expect(s.attributes.has('gen_ai.tool.call.arguments') || s.attributes.has('gen_ai.tool.call.result'), req(ID, DOC, `${where} MUST NOT carry gen_ai.tool.call.arguments / .result under the projection (content)`)).toBe(false);
+    }
+  });
+});

package/src/scenarios/tool-catalog-compact-projection.test.ts

@@ -26,6 +26,11 @@
  *   5. BY-ID — `GET /v1/tools/{toolId}?view=compact` returns one schema-valid
  *      CompactToolDescriptor.
  *
+ * MAJORS [1, 2] since suite 2.36.0 (RFC 0204 G3): `spec/v2/core/tool-catalog.md`
+ * §Views and sessions restates §compact; the gate and paths resolve the major
+ * (`toolCatalogGate(…, 'compactView')`, `toolsPath`) and the schema is the v2
+ * `compact-tool-descriptor.schema.json` at major 2.
+ *
  * Spec references:
  *   - https://github.com/openwop/openwop/blob/main/spec/v1/tool-catalog.md (§compact)
  *   - https://github.com/openwop/openwop/blob/main/RFCS/0112-compact-tool-projection.md
@@ -37,10 +42,12 @@ import { join } from 'node:path';
 import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
 import { driver } from '../lib/driver.js';
-import { behaviorGate } from '../lib/behavior-gate.js';
 import { SCHEMAS_DIR } from '../lib/paths.js';
+import { targetMajor } from '../lib/seams.js';
+import { v2Validator } from '../lib/v2.js';
 import {
-  readToolCatalogCap,
+  toolCatalogGate,
+  toolsPath,
   listToolsCompact,
   COMPACT_DROPPED_FIELDS,
   findBannedInputSchemaKeyword,
@@ -53,6 +60,15 @@ function loadSchema(name: string): Record<string, unknown> {
   return JSON.parse(readFileSync(join(SCHEMAS_DIR, name), 'utf8')) as Record<string, unknown>;
 }
 
+/** The CompactToolDescriptor validator for the major in play. */
+function compactValidator(): (d: unknown) => { ok: boolean; errors: string } {
+  if (targetMajor() === 2) return v2Validator('compact-tool-descriptor');
+  const ajv = new Ajv2020({ strict: false, allErrors: true });
+  addFormats(ajv);
+  const validate = ajv.compile(loadSchema('compact-tool-descriptor.schema.json'));
+  return (d: unknown) => ({ ok: validate(d) as boolean, errors: ajv.errorsText(validate.errors) });
+}
+
 /** Extract the `toolId` set from a `GET /v1/tools` body, tolerating both the
  *  bare-array and `{ tools: [] }` envelope standard shapes (cast-free). */
 function toolIdSet(body: unknown): Set<string> {
@@ -73,12 +89,8 @@ function toolIdSet(body: unknown): Set<string> {
 
 describe('tool-catalog-compact-projection (RFC 0112 §compact)', () => {
   it('serves the { tools: CompactToolDescriptor[] } projection — closed shape, bounded inputSchema, same toolId set as standard', async () => {
-    const cap = await readToolCatalogCap();
-    if (!behaviorGate('openwop-tool-catalog-compact', cap?.compactView === true)) return;
-
-    const ajv = new Ajv2020({ strict: false, allErrors: true });
-    addFormats(ajv);
-    const validate = ajv.compile(loadSchema('compact-tool-descriptor.schema.json'));
+    if (!(await toolCatalogGate('openwop-tool-catalog-compact', 'compactView'))) return;
+    const validate = compactValidator();
 
     // ---- Leg 1: the compact envelope (§compact) -------------------------
     const compact = await listToolsCompact();
@@ -86,9 +98,10 @@ describe('tool-catalog-compact-projection (RFC 0112 §compact)', () => {
 
     for (const t of compact) {
       // ---- Leg 2: schema validity + heavy fields dropped ----------------
+      const v = validate(t);
       expect(
-        validate(t),
-        req('openwop.it.tool-catalog-compact-projection.serves-the-tools-compacttooldescriptor-projection-closed-shape-bounded-inputsche', 'compact-tool-descriptor.schema.json', `each CompactToolDescriptor MUST validate (${ajv.errorsText(validate.errors)})`),
+        v.ok,
+        req('openwop.it.tool-catalog-compact-projection.serves-the-tools-compacttooldescriptor-projection-closed-shape-bounded-inputsche', 'compact-tool-descriptor.schema.json', `each CompactToolDescriptor MUST validate (${v.errors})`),
       ).toBe(true);
       for (const f of COMPACT_DROPPED_FIELDS) {
         expect(
@@ -115,7 +128,7 @@ describe('tool-catalog-compact-projection (RFC 0112 §compact)', () => {
     }
 
     // ---- Leg 4: projection completeness vs the standard view -------------
-    const standardRes = await driver.get('/v1/tools');
+    const standardRes = await driver.get(toolsPath());
     const standardIds = toolIdSet(standardRes.json);
     const compactIds = new Set<string>();
     for (const t of compact) {
@@ -134,11 +147,12 @@ describe('tool-catalog-compact-projection (RFC 0112 §compact)', () => {
     // ---- Leg 5: by-id compact round-trip --------------------------------
     if (compact.length > 0 && typeof compact[0]!.toolId === 'string') {
       const id = compact[0]!.toolId;
-      const one = await driver.get(`/v1/tools/${encodeURIComponent(id)}?view=compact`);
+      const one = await driver.get(toolsPath(`/${encodeURIComponent(id)}?view=compact`));
       if (one.status === 200) {
+        const v1 = validate(one.json);
         expect(
-          validate(one.json),
-          req('openwop.it.tool-catalog-compact-projection.serves-the-tools-compacttooldescriptor-projection-closed-shape-bounded-inputsche', 'compact-tool-descriptor.schema.json', `GET /v1/tools/{toolId}?view=compact MUST return a valid CompactToolDescriptor (${ajv.errorsText(validate.errors)})`),
+          v1.ok,
+          req('openwop.it.tool-catalog-compact-projection.serves-the-tools-compacttooldescriptor-projection-closed-shape-bounded-inputsche', 'compact-tool-descriptor.schema.json', `GET /v1/tools/{toolId}?view=compact MUST return a valid CompactToolDescriptor (${v1.errors})`),
         ).toBe(true);
         const got = one.json;
         expect(

package/src/scenarios/tool-catalog-projection.test.ts

@@ -19,8 +19,20 @@
  *      "not found" — the authorization-scoped projection never discloses another
  *      principal's tools. Soft-skips when the env var is unset.
  *
+ * MAJORS [1, 2] since suite 2.36.0 (RFC 0204 G3). `spec/v2/core/tool-catalog.md`
+ * restates every v1 MUST this file checks, so the obligation holds at major 2
+ * unchanged; what held the file at [1] was the instrument — a `supported` gate
+ * (absent by construction at major 2) and hard-coded `/v1/tools` paths. Both now
+ * resolve the major (`toolCatalogGate`, `toolsPath`), and the descriptor is
+ * validated against `schemas/v2/tool-descriptor.schema.json` at major 2.
+ *
+ * Leg 5 (advisory, RFC 0204 §D.13 — a SHOULD, no certification row): two reads
+ * of the list are identical and sorted by `toolId`. Met ⇒ `executed-pass`; not
+ * met ⇒ recorded `inapplicable` with the reason, never failed.
+ *
  * Spec references:
  *   - https://github.com/openwop/openwop/blob/main/spec/v1/tool-catalog.md (§B/§F)
+ *   - https://github.com/openwop/openwop/blob/main/spec/v2/core/tool-catalog.md
  *   - https://github.com/openwop/openwop/blob/main/RFCS/0078-portable-tool-catalog-and-tool-session-contract.md
  */
 
@@ -30,10 +42,12 @@ import { join } from 'node:path';
 import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
 import { driver } from '../lib/driver.js';
-import { behaviorGate } from '../lib/behavior-gate.js';
 import { SCHEMAS_DIR } from '../lib/paths.js';
+import { targetMajor } from '../lib/seams.js';
+import { v2Validator } from '../lib/v2.js';
 import {
-  readToolCatalogCap,
+  toolCatalogGate,
+  toolsPath,
   listTools,
   getTool,
   TOOL_SOURCES,
@@ -47,6 +61,15 @@ function loadSchema(name: string): Record<string, unknown> {
   return JSON.parse(readFileSync(join(SCHEMAS_DIR, name), 'utf8')) as Record<string, unknown>;
 }
 
+/** The ToolDescriptor validator for the major in play. */
+function descriptorValidator(): (d: unknown) => { ok: boolean; errors: string } {
+  if (targetMajor() === 2) return v2Validator('tool-descriptor');
+  const ajv = new Ajv2020({ strict: false, allErrors: true });
+  addFormats(ajv);
+  const validate = ajv.compile(loadSchema('tool-descriptor.schema.json'));
+  return (d: unknown) => ({ ok: validate(d) as boolean, errors: ajv.errorsText(validate.errors) });
+}
+
 function expectContentFree(d: Record<string, unknown>, where: string): void {
   for (const f of TOOL_CONTENT_FORBIDDEN) {
     expect(
@@ -58,18 +81,14 @@ function expectContentFree(d: Record<string, unknown>, where: string): void {
 
 describe('tool-catalog-projection (RFC 0078 §B/§F)', () => {
   it('lists schema-valid ToolDescriptors, serves by-id + 404s, is auth-gated, and never discloses another principal', async () => {
-    const cap = await readToolCatalogCap();
-    if (!behaviorGate('openwop-tool-catalog', cap?.supported === true)) return;
-
-    const ajv = new Ajv2020({ strict: false, allErrors: true });
-    addFormats(ajv);
-    const validate = ajv.compile(loadSchema('tool-descriptor.schema.json'));
+    if (!(await toolCatalogGate('openwop-tool-catalog'))) return;
+    const validate = descriptorValidator();
 
     // ---- Leg 3: auth-gated (unauthenticated list MUST be 401) -------------
-    const unauth = await driver.get('/v1/tools', { authenticated: false });
+    const unauth = await driver.get(toolsPath(), { authenticated: false });
     expect(
       unauth.status === 401,
-      req('openwop.it.tool-catalog-projection.lists-schema-valid-tooldescriptors-serves-by-id-404s-is-auth-gated-and-never-dis', 'tool-catalog.md §B', 'GET /v1/tools MUST require authentication (401 unauthenticated)'),
+      req('openwop.it.tool-catalog-projection.lists-schema-valid-tooldescriptors-serves-by-id-404s-is-auth-gated-and-never-dis', 'tool-catalog.md §B', `GET ${toolsPath()} MUST require authentication (401 unauthenticated)`),
     ).toBe(true);
 
     // ---- Leg 1: the list (§B) -------------------------------------------
@@ -77,9 +96,10 @@ describe('tool-catalog-projection (RFC 0078 §B/§F)', () => {
     if (tools === null) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `tools === null` returned early (host advertises the cap but doesn\'t serve the read — soft-skip the rest)'); // host advertises the cap but doesn't serve the read — soft-skip the rest
 
     for (const t of tools) {
+      const v = validate(t);
       expect(
-        validate(t),
-        req('openwop.it.tool-catalog-projection.lists-schema-valid-tooldescriptors-serves-by-id-404s-is-auth-gated-and-never-dis', 'tool-descriptor.schema.json', `each ToolDescriptor MUST validate (${ajv.errorsText(validate.errors)})`),
+        v.ok,
+        req('openwop.it.tool-catalog-projection.lists-schema-valid-tooldescriptors-serves-by-id-404s-is-auth-gated-and-never-dis', 'tool-descriptor.schema.json', `each ToolDescriptor MUST validate (${v.errors})`),
       ).toBe(true);
       expect(
         typeof t.source === 'string' && TOOL_SOURCES.includes(t.source as string),
@@ -119,4 +139,20 @@ describe('tool-catalog-projection (RFC 0078 §B/§F)', () => {
       ).toBe(true);
     }
   });
+
+  it('advisory (SHOULD): an unchanged catalog reads identically, sorted by toolId', async () => {
+    if (!(await toolCatalogGate('openwop-tool-catalog'))) return;
+    const a = await listTools();
+    const b = await listTools();
+    if (a === null || b === null) return softSkip('inapplicable', 'the host advertises the catalog but does not serve the list read');
+    const ids = (l: ReadonlyArray<{ toolId?: unknown }>) => l.map((t) => String(t.toolId));
+    const first = ids(a); const second = ids(b);
+    const sorted = [...first].sort((x, y) => (x < y ? -1 : x > y ? 1 : 0));
+    const stable = JSON.stringify(first) === JSON.stringify(second);
+    const ordered = JSON.stringify(first) === JSON.stringify(sorted);
+    if (!stable || !ordered) {
+      return softSkip('inapplicable', `advisory SHOULD not met (RFC 0204 §D.13, tool-catalog.md §The catalog): ${stable ? '' : 'two reads returned different orders; '}${ordered ? '' : 'tools are not sorted by toolId'} — recorded, never failed`);
+    }
+    expect(stable && ordered, req('openwop.it.tool-catalog-projection.advisory-should-an-unchanged-catalog-reads-identically-sorted-by-toolid', 'spec/v2/core/tool-catalog.md §The catalog (SHOULD)', 'two reads are identical and sorted by toolId')).toBe(true);
+  });
 });

package/src/scenarios/tool-descriptor-shape.test.ts

@@ -23,6 +23,12 @@
  * per RFC 0078 §Conformance — reference host deferred). This scenario asserts the
  * wire contract, not host behavior.
  *
+ * MAJORS [1, 2] since suite 2.36.0 (RFC 0204 G3). At major 2 every leg reads the
+ * v2 schema of the same name (`schemas/v2/…`), the capability leg reads the v2
+ * `toolCatalog` record's facets (no `supported` field exists at major 2 — the
+ * record is the claim) and the event-name leg reads the v2 spellings
+ * (`tool.session-opened` / `tool.session-closed`, `spec/v2/event-codemap.json`).
+ *
  * Spec references:
  *   - https://github.com/openwop/openwop/blob/main/spec/v1/tool-catalog.md
  *   - https://github.com/openwop/openwop/blob/main/RFCS/0078-portable-tool-catalog-and-tool-session-contract.md
@@ -36,14 +42,24 @@ import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
 import { SCHEMAS_DIR } from '../lib/paths.js';
 import { req } from '../lib/requirement-ids.js';
+import { targetMajor } from '../lib/seams.js';
+import { v2Validator, v2RefValidator } from '../lib/v2.js';
+
+const V2 = targetMajor() === 2;
 
 function loadSchema(name: string): Record<string, unknown> {
-  return JSON.parse(readFileSync(join(SCHEMAS_DIR, name), 'utf8')) as Record<string, unknown>;
+  return JSON.parse(readFileSync(V2 ? join(SCHEMAS_DIR, 'v2', name) : join(SCHEMAS_DIR, name), 'utf8')) as Record<string, unknown>;
+}
+
+/** A boolean validator for a whole schema file, for the major in play. */
+function fileValidator(name: string): (d: unknown) => boolean {
+  if (V2) { const v = v2Validator(name); return (d) => v(d).ok; }
+  const v = addFormats(new Ajv2020({ strict: false })).compile(loadSchema(name));
+  return (d) => v(d) as boolean;
 }
 
 describe('tool-descriptor-shape: ToolDescriptor (RFC 0078 §C, server-free)', () => {
-  const ajv = addFormats(new Ajv2020({ strict: false }));
-  const validate = ajv.compile(loadSchema('tool-descriptor.schema.json'));
+  const validate = fileValidator('tool-descriptor.schema.json');
 
   it('a conforming descriptor validates', () => {
     expect(
@@ -91,7 +107,7 @@ describe('tool-descriptor-shape: capability advertisement (RFC 0078 §A, server-
       toolCatalog,
       req('openwop.it.tool-descriptor-shape.capabilities-toolcatalog-is-declared-with-its-sub-flags', 'capabilities.md §toolCatalog', 'capabilities.toolCatalog MUST be declared'),
     ).toBeDefined();
-    for (const flag of ['supported', 'sources', 'sessionLifecycle']) {
+    for (const flag of V2 ? ['sources', 'sessionLifecycle', 'compactView'] : ['supported', 'sources', 'sessionLifecycle']) {
       expect(
         toolCatalog?.properties?.[flag],
         req('openwop.it.tool-descriptor-shape.capabilities-toolcatalog-is-declared-with-its-sub-flags', 'tool-catalog.md §A', `capabilities.toolCatalog.${flag} MUST be declared`),
@@ -101,13 +117,16 @@ describe('tool-descriptor-shape: capability advertisement (RFC 0078 §A, server-
 });
 
 describe('tool-descriptor-shape: session lifecycle events (RFC 0078 §D, server-free)', () => {
-  const payloads = loadSchema('run-event-payloads.schema.json');
-  const ajv = addFormats(new Ajv2020({ strict: false }));
-  const compile = (defName: string) => ajv.compile({
-    $schema: 'https://json-schema.org/draft/2020-12/schema',
-    $defs: (payloads as { $defs: Record<string, unknown> }).$defs,
-    $ref: `#/$defs/${defName}`,
-  } as Record<string, unknown>);
+  const compile = (defName: string): ((d: unknown) => boolean) => {
+    if (V2) { const v = v2RefValidator(`run-event-payloads.schema.json#/$defs/${defName}`); return (d) => v(d).ok; }
+    const payloads = loadSchema('run-event-payloads.schema.json');
+    const v = addFormats(new Ajv2020({ strict: false })).compile({
+      $schema: 'https://json-schema.org/draft/2020-12/schema',
+      $defs: (payloads as { $defs: Record<string, unknown> }).$defs,
+      $ref: `#/$defs/${defName}`,
+    } as Record<string, unknown>);
+    return (d) => v(d) as boolean;
+  };
 
   it('tool.session.opened validates a content-free record', () => {
     const v = compile('toolSessionOpened');
@@ -124,8 +143,10 @@ describe('tool-descriptor-shape: session lifecycle events (RFC 0078 §D, server-
 
   it('both session event names appear in the RunEventType enum', () => {
     const runEvent = loadSchema('run-event.schema.json');
-    const enumVals = ((runEvent.$defs as Record<string, { enum?: string[] }>).RunEventType?.enum) ?? [];
-    for (const name of ['tool.session.opened', 'tool.session.closed']) {
+    const enumVals = V2
+      ? (((runEvent.properties as { type?: { oneOf?: Array<{ enum?: string[] }> } }).type?.oneOf ?? []).flatMap((b) => b.enum ?? []))
+      : (((runEvent.$defs as Record<string, { enum?: string[] }>).RunEventType?.enum) ?? []);
+    for (const name of V2 ? ['tool.session-opened', 'tool.session-closed'] : ['tool.session.opened', 'tool.session.closed']) {
       expect(enumVals.includes(name), req('openwop.it.tool-descriptor-shape.both-session-event-names-appear-in-the-runeventtype-enum', 'run-event.schema.json', `${name} MUST be in the RunEventType enum`)).toBe(true);
     }
   });